blob: 11ec12a09d704cc9e81c474e43dcf83fe6aab21c [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/*
2 * net/sunrpc/rpc_pipe.c
3 *
4 * Userland/kernel interface for rpcauth_gss.
5 * Code shamelessly plagiarized from fs/nfsd/nfsctl.c
Rolf Eike Beerd51fe1b2005-09-02 08:59:25 +02006 * and fs/sysfs/inode.c
Linus Torvalds1da177e2005-04-16 15:20:36 -07007 *
8 * Copyright (c) 2002, Trond Myklebust <trond.myklebust@fys.uio.no>
9 *
10 */
Linus Torvalds1da177e2005-04-16 15:20:36 -070011#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>
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
Eric Dumazetba899662005-08-26 12:05:31 -070030static struct vfsmount *rpc_mount __read_mostly;
Linus Torvalds1da177e2005-04-16 15:20:36 -070031static int rpc_mount_count;
32
33static struct file_system_type rpc_pipe_fs_type;
34
35
Eric Dumazetba899662005-08-26 12:05:31 -070036static kmem_cache_t *rpc_inode_cachep __read_mostly;
Linus Torvalds1da177e2005-04-16 15:20:36 -070037
38#define RPC_UPCALL_TIMEOUT (30*HZ)
39
Trond Myklebust9842ef32006-02-01 12:18:44 -050040static void rpc_purge_list(struct rpc_inode *rpci, struct list_head *head,
41 void (*destroy_msg)(struct rpc_pipe_msg *), int err)
Trond Myklebustb3eb67a2005-11-25 17:10:11 -050042{
43 struct rpc_pipe_msg *msg;
Trond Myklebustb3eb67a2005-11-25 17:10:11 -050044
Trond Myklebust9842ef32006-02-01 12:18:44 -050045 if (list_empty(head))
46 return;
47 do {
Trond Myklebustb3eb67a2005-11-25 17:10:11 -050048 msg = list_entry(head->next, struct rpc_pipe_msg, list);
Trond Myklebust9842ef32006-02-01 12:18:44 -050049 list_del(&msg->list);
Trond Myklebustb3eb67a2005-11-25 17:10:11 -050050 msg->errno = err;
51 destroy_msg(msg);
Trond Myklebust9842ef32006-02-01 12:18:44 -050052 } while (!list_empty(head));
Linus Torvalds1da177e2005-04-16 15:20:36 -070053 wake_up(&rpci->waitq);
54}
55
56static void
57rpc_timeout_upcall_queue(void *data)
58{
Trond Myklebust9842ef32006-02-01 12:18:44 -050059 LIST_HEAD(free_list);
Linus Torvalds1da177e2005-04-16 15:20:36 -070060 struct rpc_inode *rpci = (struct rpc_inode *)data;
61 struct inode *inode = &rpci->vfs_inode;
Trond Myklebust9842ef32006-02-01 12:18:44 -050062 void (*destroy_msg)(struct rpc_pipe_msg *);
Linus Torvalds1da177e2005-04-16 15:20:36 -070063
Trond Myklebust9842ef32006-02-01 12:18:44 -050064 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);
Linus Torvalds1da177e2005-04-16 15:20:36 -070076}
77
78int
79rpc_queue_upcall(struct inode *inode, struct rpc_pipe_msg *msg)
80{
81 struct rpc_inode *rpci = RPC_I(inode);
Trond Myklebust6070fe62005-10-27 22:12:46 -040082 int res = -EPIPE;
Linus Torvalds1da177e2005-04-16 15:20:36 -070083
Trond Myklebust9842ef32006-02-01 12:18:44 -050084 spin_lock(&inode->i_lock);
Trond Myklebust6070fe62005-10-27 22:12:46 -040085 if (rpci->ops == NULL)
86 goto out;
Linus Torvalds1da177e2005-04-16 15:20:36 -070087 if (rpci->nreaders) {
88 list_add_tail(&msg->list, &rpci->pipe);
89 rpci->pipelen += msg->len;
Trond Myklebust6070fe62005-10-27 22:12:46 -040090 res = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -070091 } else if (rpci->flags & RPC_PIPE_WAIT_FOR_OPEN) {
92 if (list_empty(&rpci->pipe))
Trond Myklebust24c5d9d2006-03-20 13:44:08 -050093 queue_delayed_work(rpciod_workqueue,
94 &rpci->queue_timeout,
Linus Torvalds1da177e2005-04-16 15:20:36 -070095 RPC_UPCALL_TIMEOUT);
96 list_add_tail(&msg->list, &rpci->pipe);
97 rpci->pipelen += msg->len;
Trond Myklebust6070fe62005-10-27 22:12:46 -040098 res = 0;
99 }
100out:
Trond Myklebust9842ef32006-02-01 12:18:44 -0500101 spin_unlock(&inode->i_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700102 wake_up(&rpci->waitq);
103 return res;
104}
105
Trond Myklebust6070fe62005-10-27 22:12:46 -0400106static inline void
107rpc_inode_setowner(struct inode *inode, void *private)
108{
109 RPC_I(inode)->private = private;
110}
111
Linus Torvalds1da177e2005-04-16 15:20:36 -0700112static void
113rpc_close_pipes(struct inode *inode)
114{
115 struct rpc_inode *rpci = RPC_I(inode);
Trond Myklebust9842ef32006-02-01 12:18:44 -0500116 struct rpc_pipe_ops *ops;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700117
Jes Sorensen1b1dcc12006-01-09 15:59:24 -0800118 mutex_lock(&inode->i_mutex);
Trond Myklebust9842ef32006-02-01 12:18:44 -0500119 ops = rpci->ops;
120 if (ops != NULL) {
121 LIST_HEAD(free_list);
122
123 spin_lock(&inode->i_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700124 rpci->nreaders = 0;
Trond Myklebust9842ef32006-02-01 12:18:44 -0500125 list_splice_init(&rpci->in_upcall, &free_list);
126 list_splice_init(&rpci->pipe, &free_list);
127 rpci->pipelen = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700128 rpci->ops = NULL;
Trond Myklebust9842ef32006-02-01 12:18:44 -0500129 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);
Trond Myklebust24c5d9d2006-03-20 13:44:08 -0500135 flush_workqueue(rpciod_workqueue);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700136 }
Trond Myklebust6070fe62005-10-27 22:12:46 -0400137 rpc_inode_setowner(inode, NULL);
Jes Sorensen1b1dcc12006-01-09 15:59:24 -0800138 mutex_unlock(&inode->i_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700139}
140
Linus Torvalds1da177e2005-04-16 15:20:36 -0700141static struct inode *
142rpc_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}
150
151static void
152rpc_destroy_inode(struct inode *inode)
153{
154 kmem_cache_free(rpc_inode_cachep, RPC_I(inode));
155}
156
157static int
158rpc_pipe_open(struct inode *inode, struct file *filp)
159{
160 struct rpc_inode *rpci = RPC_I(inode);
161 int res = -ENXIO;
162
Jes Sorensen1b1dcc12006-01-09 15:59:24 -0800163 mutex_lock(&inode->i_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700164 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 }
Jes Sorensen1b1dcc12006-01-09 15:59:24 -0800171 mutex_unlock(&inode->i_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700172 return res;
173}
174
175static int
176rpc_pipe_release(struct inode *inode, struct file *filp)
177{
Trond Myklebust969b7f22006-01-03 09:55:36 +0100178 struct rpc_inode *rpci = RPC_I(inode);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700179 struct rpc_pipe_msg *msg;
180
Jes Sorensen1b1dcc12006-01-09 15:59:24 -0800181 mutex_lock(&inode->i_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700182 if (rpci->ops == NULL)
183 goto out;
184 msg = (struct rpc_pipe_msg *)filp->private_data;
185 if (msg != NULL) {
Trond Myklebust9842ef32006-02-01 12:18:44 -0500186 spin_lock(&inode->i_lock);
Trond Myklebust48e49182005-12-19 17:11:22 -0500187 msg->errno = -EAGAIN;
Trond Myklebust9842ef32006-02-01 12:18:44 -0500188 list_del(&msg->list);
189 spin_unlock(&inode->i_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700190 rpci->ops->destroy_msg(msg);
191 }
192 if (filp->f_mode & FMODE_WRITE)
193 rpci->nwriters --;
Trond Myklebust9842ef32006-02-01 12:18:44 -0500194 if (filp->f_mode & FMODE_READ) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700195 rpci->nreaders --;
Trond Myklebust9842ef32006-02-01 12:18:44 -0500196 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 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700206 if (rpci->ops->release_pipe)
207 rpci->ops->release_pipe(inode);
208out:
Jes Sorensen1b1dcc12006-01-09 15:59:24 -0800209 mutex_unlock(&inode->i_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700210 return 0;
211}
212
213static ssize_t
214rpc_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;
220
Jes Sorensen1b1dcc12006-01-09 15:59:24 -0800221 mutex_lock(&inode->i_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700222 if (rpci->ops == NULL) {
223 res = -EPIPE;
224 goto out_unlock;
225 }
226 msg = filp->private_data;
227 if (msg == NULL) {
Trond Myklebust9842ef32006-02-01 12:18:44 -0500228 spin_lock(&inode->i_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700229 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 }
Trond Myklebust9842ef32006-02-01 12:18:44 -0500238 spin_unlock(&inode->i_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700239 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;
Trond Myklebust9842ef32006-02-01 12:18:44 -0500246 spin_lock(&inode->i_lock);
247 list_del(&msg->list);
248 spin_unlock(&inode->i_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700249 rpci->ops->destroy_msg(msg);
250 }
251out_unlock:
Jes Sorensen1b1dcc12006-01-09 15:59:24 -0800252 mutex_unlock(&inode->i_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700253 return res;
254}
255
256static ssize_t
257rpc_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;
262
Jes Sorensen1b1dcc12006-01-09 15:59:24 -0800263 mutex_lock(&inode->i_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700264 res = -EPIPE;
265 if (rpci->ops != NULL)
266 res = rpci->ops->downcall(filp, buf, len);
Jes Sorensen1b1dcc12006-01-09 15:59:24 -0800267 mutex_unlock(&inode->i_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700268 return res;
269}
270
271static unsigned int
272rpc_pipe_poll(struct file *filp, struct poll_table_struct *wait)
273{
274 struct rpc_inode *rpci;
275 unsigned int mask = 0;
276
277 rpci = RPC_I(filp->f_dentry->d_inode);
278 poll_wait(filp, &rpci->waitq, wait);
279
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}
287
288static int
289rpc_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;
294
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}
310
311static 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};
321
322static int
323rpc_show_info(struct seq_file *m, void *v)
324{
325 struct rpc_clnt *clnt = m->private;
326
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);
Chuck Levere7f78652006-08-22 20:06:19 -0400330 seq_printf(m, "address: %s\n", rpc_peeraddr2str(clnt, RPC_DISPLAY_ADDR));
331 seq_printf(m, "protocol: %s\n", rpc_peeraddr2str(clnt, RPC_DISPLAY_PROTO));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700332 return 0;
333}
334
335static int
336rpc_info_open(struct inode *inode, struct file *file)
337{
338 struct rpc_clnt *clnt;
339 int ret = single_open(file, rpc_show_info, NULL);
340
341 if (!ret) {
342 struct seq_file *m = file->private_data;
Jes Sorensen1b1dcc12006-01-09 15:59:24 -0800343 mutex_lock(&inode->i_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700344 clnt = RPC_I(inode)->private;
345 if (clnt) {
346 atomic_inc(&clnt->cl_users);
347 m->private = clnt;
348 } else {
349 single_release(inode, file);
350 ret = -EINVAL;
351 }
Jes Sorensen1b1dcc12006-01-09 15:59:24 -0800352 mutex_unlock(&inode->i_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700353 }
354 return ret;
355}
356
357static int
358rpc_info_release(struct inode *inode, struct file *file)
359{
360 struct seq_file *m = file->private_data;
361 struct rpc_clnt *clnt = (struct rpc_clnt *)m->private;
362
363 if (clnt)
364 rpc_release_client(clnt);
365 return single_release(inode, file);
366}
367
368static struct file_operations rpc_info_operations = {
369 .owner = THIS_MODULE,
370 .open = rpc_info_open,
371 .read = seq_read,
372 .llseek = seq_lseek,
373 .release = rpc_info_release,
374};
375
376
377/*
378 * We have a single directory with 1 node in it.
379 */
380enum {
381 RPCAUTH_Root = 1,
382 RPCAUTH_lockd,
383 RPCAUTH_mount,
384 RPCAUTH_nfs,
385 RPCAUTH_portmap,
386 RPCAUTH_statd,
387 RPCAUTH_RootEOF
388};
389
390/*
391 * Description of fs contents.
392 */
393struct rpc_filelist {
394 char *name;
Arjan van de Ven99ac48f2006-03-28 01:56:41 -0800395 const struct file_operations *i_fop;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700396 int mode;
397};
398
399static struct rpc_filelist files[] = {
400 [RPCAUTH_lockd] = {
401 .name = "lockd",
402 .mode = S_IFDIR | S_IRUGO | S_IXUGO,
403 },
404 [RPCAUTH_mount] = {
405 .name = "mount",
406 .mode = S_IFDIR | S_IRUGO | S_IXUGO,
407 },
408 [RPCAUTH_nfs] = {
409 .name = "nfs",
410 .mode = S_IFDIR | S_IRUGO | S_IXUGO,
411 },
412 [RPCAUTH_portmap] = {
413 .name = "portmap",
414 .mode = S_IFDIR | S_IRUGO | S_IXUGO,
415 },
416 [RPCAUTH_statd] = {
417 .name = "statd",
418 .mode = S_IFDIR | S_IRUGO | S_IXUGO,
419 },
420};
421
422enum {
423 RPCAUTH_info = 2,
424 RPCAUTH_EOF
425};
426
427static struct rpc_filelist authfiles[] = {
428 [RPCAUTH_info] = {
429 .name = "info",
430 .i_fop = &rpc_info_operations,
431 .mode = S_IFREG | S_IRUSR,
432 },
433};
434
Trond Myklebust54281542006-03-20 13:44:49 -0500435struct vfsmount *rpc_get_mount(void)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700436{
Trond Myklebust54281542006-03-20 13:44:49 -0500437 int err;
438
Trond Myklebust1f5ce9e2006-06-09 09:34:16 -0400439 err = simple_pin_fs(&rpc_pipe_fs_type, &rpc_mount, &rpc_mount_count);
Trond Myklebust54281542006-03-20 13:44:49 -0500440 if (err != 0)
441 return ERR_PTR(err);
442 return rpc_mount;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700443}
444
Trond Myklebust54281542006-03-20 13:44:49 -0500445void rpc_put_mount(void)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700446{
447 simple_release_fs(&rpc_mount, &rpc_mount_count);
448}
449
Trond Myklebustf1345852005-09-23 11:08:25 -0400450static int
451rpc_lookup_parent(char *path, struct nameidata *nd)
452{
453 if (path[0] == '\0')
454 return -ENOENT;
Trond Myklebust54281542006-03-20 13:44:49 -0500455 nd->mnt = rpc_get_mount();
456 if (IS_ERR(nd->mnt)) {
Trond Myklebustf1345852005-09-23 11:08:25 -0400457 printk(KERN_WARNING "%s: %s failed to mount "
458 "pseudofilesystem \n", __FILE__, __FUNCTION__);
Trond Myklebust54281542006-03-20 13:44:49 -0500459 return PTR_ERR(nd->mnt);
Trond Myklebustf1345852005-09-23 11:08:25 -0400460 }
Trond Myklebust54281542006-03-20 13:44:49 -0500461 mntget(nd->mnt);
Trond Myklebustf1345852005-09-23 11:08:25 -0400462 nd->dentry = dget(rpc_mount->mnt_root);
463 nd->last_type = LAST_ROOT;
464 nd->flags = LOOKUP_PARENT;
465 nd->depth = 0;
466
467 if (path_walk(path, nd)) {
468 printk(KERN_WARNING "%s: %s failed to find path %s\n",
469 __FILE__, __FUNCTION__, path);
470 rpc_put_mount();
471 return -ENOENT;
472 }
473 return 0;
474}
475
476static void
477rpc_release_path(struct nameidata *nd)
478{
479 path_release(nd);
480 rpc_put_mount();
481}
482
Linus Torvalds1da177e2005-04-16 15:20:36 -0700483static struct inode *
484rpc_get_inode(struct super_block *sb, int mode)
485{
486 struct inode *inode = new_inode(sb);
487 if (!inode)
488 return NULL;
489 inode->i_mode = mode;
490 inode->i_uid = inode->i_gid = 0;
491 inode->i_blksize = PAGE_CACHE_SIZE;
492 inode->i_blocks = 0;
493 inode->i_atime = inode->i_mtime = inode->i_ctime = CURRENT_TIME;
494 switch(mode & S_IFMT) {
495 case S_IFDIR:
496 inode->i_fop = &simple_dir_operations;
497 inode->i_op = &simple_dir_inode_operations;
498 inode->i_nlink++;
499 default:
500 break;
501 }
502 return inode;
503}
504
505/*
506 * FIXME: This probably has races.
507 */
508static void
509rpc_depopulate(struct dentry *parent)
510{
511 struct inode *dir = parent->d_inode;
512 struct list_head *pos, *next;
513 struct dentry *dentry, *dvec[10];
514 int n = 0;
515
Arjan van de Venc6573c22006-07-03 00:25:16 -0700516 mutex_lock_nested(&dir->i_mutex, I_MUTEX_CHILD);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700517repeat:
518 spin_lock(&dcache_lock);
519 list_for_each_safe(pos, next, &parent->d_subdirs) {
Eric Dumazet5160ee62006-01-08 01:03:32 -0800520 dentry = list_entry(pos, struct dentry, d_u.d_child);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700521 spin_lock(&dentry->d_lock);
522 if (!d_unhashed(dentry)) {
523 dget_locked(dentry);
524 __d_drop(dentry);
525 spin_unlock(&dentry->d_lock);
526 dvec[n++] = dentry;
527 if (n == ARRAY_SIZE(dvec))
528 break;
529 } else
530 spin_unlock(&dentry->d_lock);
531 }
532 spin_unlock(&dcache_lock);
533 if (n) {
534 do {
535 dentry = dvec[--n];
536 if (dentry->d_inode) {
537 rpc_close_pipes(dentry->d_inode);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700538 simple_unlink(dir, dentry);
539 }
Trond Myklebust68adb0a2006-08-10 17:51:46 -0400540 inode_dir_notify(dir, DN_DELETE);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700541 dput(dentry);
542 } while (n);
543 goto repeat;
544 }
Jes Sorensen1b1dcc12006-01-09 15:59:24 -0800545 mutex_unlock(&dir->i_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700546}
547
548static int
549rpc_populate(struct dentry *parent,
550 struct rpc_filelist *files,
551 int start, int eof)
552{
553 struct inode *inode, *dir = parent->d_inode;
554 void *private = RPC_I(dir)->private;
555 struct dentry *dentry;
556 int mode, i;
557
Jes Sorensen1b1dcc12006-01-09 15:59:24 -0800558 mutex_lock(&dir->i_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700559 for (i = start; i < eof; i++) {
560 dentry = d_alloc_name(parent, files[i].name);
561 if (!dentry)
562 goto out_bad;
563 mode = files[i].mode;
564 inode = rpc_get_inode(dir->i_sb, mode);
565 if (!inode) {
566 dput(dentry);
567 goto out_bad;
568 }
569 inode->i_ino = i;
570 if (files[i].i_fop)
571 inode->i_fop = files[i].i_fop;
572 if (private)
573 rpc_inode_setowner(inode, private);
574 if (S_ISDIR(mode))
575 dir->i_nlink++;
576 d_add(dentry, inode);
577 }
Jes Sorensen1b1dcc12006-01-09 15:59:24 -0800578 mutex_unlock(&dir->i_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700579 return 0;
580out_bad:
Jes Sorensen1b1dcc12006-01-09 15:59:24 -0800581 mutex_unlock(&dir->i_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700582 printk(KERN_WARNING "%s: %s failed to populate directory %s\n",
583 __FILE__, __FUNCTION__, parent->d_name.name);
584 return -ENOMEM;
585}
586
Trond Myklebustf1345852005-09-23 11:08:25 -0400587static int
588__rpc_mkdir(struct inode *dir, struct dentry *dentry)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700589{
590 struct inode *inode;
591
592 inode = rpc_get_inode(dir->i_sb, S_IFDIR | S_IRUSR | S_IXUSR);
593 if (!inode)
Trond Myklebustf1345852005-09-23 11:08:25 -0400594 goto out_err;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700595 inode->i_ino = iunique(dir->i_sb, 100);
Christoph Hellwig278c9952005-07-24 23:53:01 +0100596 d_instantiate(dentry, inode);
Trond Myklebustf1345852005-09-23 11:08:25 -0400597 dir->i_nlink++;
Christoph Hellwig278c9952005-07-24 23:53:01 +0100598 inode_dir_notify(dir, DN_CREATE);
Trond Myklebustf1345852005-09-23 11:08:25 -0400599 return 0;
600out_err:
601 printk(KERN_WARNING "%s: %s failed to allocate inode for dentry %s\n",
602 __FILE__, __FUNCTION__, dentry->d_name.name);
603 return -ENOMEM;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700604}
605
Trond Myklebustf1345852005-09-23 11:08:25 -0400606static int
607__rpc_rmdir(struct inode *dir, struct dentry *dentry)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700608{
Trond Myklebustf1345852005-09-23 11:08:25 -0400609 int error;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700610
Trond Myklebustf1345852005-09-23 11:08:25 -0400611 shrink_dcache_parent(dentry);
Trond Myklebust68adb0a2006-08-10 17:51:46 -0400612 if (d_unhashed(dentry))
613 return 0;
Trond Myklebustf1345852005-09-23 11:08:25 -0400614 if ((error = simple_rmdir(dir, dentry)) != 0)
615 return error;
616 if (!error) {
617 inode_dir_notify(dir, DN_DELETE);
618 d_drop(dentry);
Trond Myklebustf1345852005-09-23 11:08:25 -0400619 }
620 return 0;
621}
Christoph Hellwig278c9952005-07-24 23:53:01 +0100622
Trond Myklebustf1345852005-09-23 11:08:25 -0400623static struct dentry *
Trond Myklebust158998b2006-08-24 01:03:17 -0400624rpc_lookup_create(struct dentry *parent, const char *name, int len)
Trond Myklebustf1345852005-09-23 11:08:25 -0400625{
Trond Myklebust158998b2006-08-24 01:03:17 -0400626 struct inode *dir = parent->d_inode;
Trond Myklebustf1345852005-09-23 11:08:25 -0400627 struct dentry *dentry;
Trond Myklebustf1345852005-09-23 11:08:25 -0400628
Arjan van de Venc6573c22006-07-03 00:25:16 -0700629 mutex_lock_nested(&dir->i_mutex, I_MUTEX_PARENT);
Trond Myklebust158998b2006-08-24 01:03:17 -0400630 dentry = lookup_one_len(name, parent, len);
Trond Myklebustf1345852005-09-23 11:08:25 -0400631 if (IS_ERR(dentry))
632 goto out_err;
633 if (dentry->d_inode) {
634 dput(dentry);
635 dentry = ERR_PTR(-EEXIST);
636 goto out_err;
637 }
638 return dentry;
639out_err:
Jes Sorensen1b1dcc12006-01-09 15:59:24 -0800640 mutex_unlock(&dir->i_mutex);
Trond Myklebust158998b2006-08-24 01:03:17 -0400641 return dentry;
642}
643
644static struct dentry *
645rpc_lookup_negative(char *path, struct nameidata *nd)
646{
647 struct dentry *dentry;
648 int error;
649
650 if ((error = rpc_lookup_parent(path, nd)) != 0)
651 return ERR_PTR(error);
652 dentry = rpc_lookup_create(nd->dentry, nd->last.name, nd->last.len);
653 if (IS_ERR(dentry))
654 rpc_release_path(nd);
Trond Myklebustf1345852005-09-23 11:08:25 -0400655 return dentry;
656}
657
658
659struct dentry *
660rpc_mkdir(char *path, struct rpc_clnt *rpc_client)
661{
662 struct nameidata nd;
663 struct dentry *dentry;
664 struct inode *dir;
665 int error;
666
667 dentry = rpc_lookup_negative(path, &nd);
668 if (IS_ERR(dentry))
669 return dentry;
670 dir = nd.dentry->d_inode;
671 if ((error = __rpc_mkdir(dir, dentry)) != 0)
672 goto err_dput;
673 RPC_I(dentry->d_inode)->private = rpc_client;
674 error = rpc_populate(dentry, authfiles,
675 RPCAUTH_info, RPCAUTH_EOF);
676 if (error)
677 goto err_depopulate;
Trond Myklebust5c3e9852006-07-29 17:37:40 -0400678 dget(dentry);
Trond Myklebustf1345852005-09-23 11:08:25 -0400679out:
Jes Sorensen1b1dcc12006-01-09 15:59:24 -0800680 mutex_unlock(&dir->i_mutex);
Trond Myklebustf1345852005-09-23 11:08:25 -0400681 rpc_release_path(&nd);
Trond Myklebust5c3e9852006-07-29 17:37:40 -0400682 return dentry;
Trond Myklebustf1345852005-09-23 11:08:25 -0400683err_depopulate:
684 rpc_depopulate(dentry);
685 __rpc_rmdir(dir, dentry);
686err_dput:
687 dput(dentry);
688 printk(KERN_WARNING "%s: %s() failed to create directory %s (errno = %d)\n",
689 __FILE__, __FUNCTION__, path, error);
690 dentry = ERR_PTR(error);
691 goto out;
692}
693
694int
Trond Myklebustdff02cc2006-07-31 14:17:18 -0700695rpc_rmdir(struct dentry *dentry)
Trond Myklebustf1345852005-09-23 11:08:25 -0400696{
Trond Myklebustdff02cc2006-07-31 14:17:18 -0700697 struct dentry *parent;
Trond Myklebustf1345852005-09-23 11:08:25 -0400698 struct inode *dir;
699 int error;
700
Trond Myklebustdff02cc2006-07-31 14:17:18 -0700701 parent = dget_parent(dentry);
702 dir = parent->d_inode;
Arjan van de Venc6573c22006-07-03 00:25:16 -0700703 mutex_lock_nested(&dir->i_mutex, I_MUTEX_PARENT);
Trond Myklebustf1345852005-09-23 11:08:25 -0400704 rpc_depopulate(dentry);
705 error = __rpc_rmdir(dir, dentry);
706 dput(dentry);
Jes Sorensen1b1dcc12006-01-09 15:59:24 -0800707 mutex_unlock(&dir->i_mutex);
Trond Myklebustdff02cc2006-07-31 14:17:18 -0700708 dput(parent);
Trond Myklebustf1345852005-09-23 11:08:25 -0400709 return error;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700710}
711
712struct dentry *
Trond Myklebust158998b2006-08-24 01:03:17 -0400713rpc_mkpipe(struct dentry *parent, const char *name, void *private, struct rpc_pipe_ops *ops, int flags)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700714{
Linus Torvalds1da177e2005-04-16 15:20:36 -0700715 struct dentry *dentry;
Trond Myklebustf1345852005-09-23 11:08:25 -0400716 struct inode *dir, *inode;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700717 struct rpc_inode *rpci;
718
Trond Myklebust158998b2006-08-24 01:03:17 -0400719 dentry = rpc_lookup_create(parent, name, strlen(name));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700720 if (IS_ERR(dentry))
Trond Myklebustf1345852005-09-23 11:08:25 -0400721 return dentry;
Trond Myklebust158998b2006-08-24 01:03:17 -0400722 dir = parent->d_inode;
Trond Myklebustf1345852005-09-23 11:08:25 -0400723 inode = rpc_get_inode(dir->i_sb, S_IFSOCK | S_IRUSR | S_IWUSR);
724 if (!inode)
725 goto err_dput;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700726 inode->i_ino = iunique(dir->i_sb, 100);
727 inode->i_fop = &rpc_pipe_fops;
Trond Myklebustf1345852005-09-23 11:08:25 -0400728 d_instantiate(dentry, inode);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700729 rpci = RPC_I(inode);
730 rpci->private = private;
731 rpci->flags = flags;
732 rpci->ops = ops;
733 inode_dir_notify(dir, DN_CREATE);
Trond Myklebust5c3e9852006-07-29 17:37:40 -0400734 dget(dentry);
Trond Myklebustf1345852005-09-23 11:08:25 -0400735out:
Jes Sorensen1b1dcc12006-01-09 15:59:24 -0800736 mutex_unlock(&dir->i_mutex);
Trond Myklebust5c3e9852006-07-29 17:37:40 -0400737 return dentry;
Trond Myklebustf1345852005-09-23 11:08:25 -0400738err_dput:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700739 dput(dentry);
Trond Myklebustf1345852005-09-23 11:08:25 -0400740 dentry = ERR_PTR(-ENOMEM);
Trond Myklebust158998b2006-08-24 01:03:17 -0400741 printk(KERN_WARNING "%s: %s() failed to create pipe %s/%s (errno = %d)\n",
742 __FILE__, __FUNCTION__, parent->d_name.name, name,
743 -ENOMEM);
Trond Myklebustf1345852005-09-23 11:08:25 -0400744 goto out;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700745}
746
Trond Myklebustf1345852005-09-23 11:08:25 -0400747int
Trond Myklebust5d674762006-07-31 14:11:48 -0700748rpc_unlink(struct dentry *dentry)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700749{
Trond Myklebust5d674762006-07-31 14:11:48 -0700750 struct dentry *parent;
Trond Myklebustf1345852005-09-23 11:08:25 -0400751 struct inode *dir;
Trond Myklebust5d674762006-07-31 14:11:48 -0700752 int error = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700753
Trond Myklebust5d674762006-07-31 14:11:48 -0700754 parent = dget_parent(dentry);
755 dir = parent->d_inode;
Arjan van de Venc6573c22006-07-03 00:25:16 -0700756 mutex_lock_nested(&dir->i_mutex, I_MUTEX_PARENT);
Trond Myklebust68adb0a2006-08-10 17:51:46 -0400757 if (!d_unhashed(dentry)) {
758 d_drop(dentry);
759 if (dentry->d_inode) {
760 rpc_close_pipes(dentry->d_inode);
761 error = simple_unlink(dir, dentry);
762 }
763 inode_dir_notify(dir, DN_DELETE);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700764 }
Trond Myklebustf1345852005-09-23 11:08:25 -0400765 dput(dentry);
Jes Sorensen1b1dcc12006-01-09 15:59:24 -0800766 mutex_unlock(&dir->i_mutex);
Trond Myklebust5d674762006-07-31 14:11:48 -0700767 dput(parent);
Trond Myklebustf1345852005-09-23 11:08:25 -0400768 return error;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700769}
770
771/*
772 * populate the filesystem
773 */
774static struct super_operations s_ops = {
775 .alloc_inode = rpc_alloc_inode,
776 .destroy_inode = rpc_destroy_inode,
777 .statfs = simple_statfs,
778};
779
780#define RPCAUTH_GSSMAGIC 0x67596969
781
782static int
783rpc_fill_super(struct super_block *sb, void *data, int silent)
784{
785 struct inode *inode;
786 struct dentry *root;
787
788 sb->s_blocksize = PAGE_CACHE_SIZE;
789 sb->s_blocksize_bits = PAGE_CACHE_SHIFT;
790 sb->s_magic = RPCAUTH_GSSMAGIC;
791 sb->s_op = &s_ops;
792 sb->s_time_gran = 1;
793
794 inode = rpc_get_inode(sb, S_IFDIR | 0755);
795 if (!inode)
796 return -ENOMEM;
797 root = d_alloc_root(inode);
798 if (!root) {
799 iput(inode);
800 return -ENOMEM;
801 }
802 if (rpc_populate(root, files, RPCAUTH_Root + 1, RPCAUTH_RootEOF))
803 goto out;
804 sb->s_root = root;
805 return 0;
806out:
807 d_genocide(root);
808 dput(root);
809 return -ENOMEM;
810}
811
David Howells454e2392006-06-23 02:02:57 -0700812static int
Linus Torvalds1da177e2005-04-16 15:20:36 -0700813rpc_get_sb(struct file_system_type *fs_type,
David Howells454e2392006-06-23 02:02:57 -0700814 int flags, const char *dev_name, void *data, struct vfsmount *mnt)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700815{
David Howells454e2392006-06-23 02:02:57 -0700816 return get_sb_single(fs_type, flags, data, rpc_fill_super, mnt);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700817}
818
819static struct file_system_type rpc_pipe_fs_type = {
820 .owner = THIS_MODULE,
821 .name = "rpc_pipefs",
822 .get_sb = rpc_get_sb,
823 .kill_sb = kill_litter_super,
824};
825
826static void
827init_once(void * foo, kmem_cache_t * cachep, unsigned long flags)
828{
829 struct rpc_inode *rpci = (struct rpc_inode *) foo;
830
831 if ((flags & (SLAB_CTOR_VERIFY|SLAB_CTOR_CONSTRUCTOR)) ==
832 SLAB_CTOR_CONSTRUCTOR) {
833 inode_init_once(&rpci->vfs_inode);
834 rpci->private = NULL;
835 rpci->nreaders = 0;
836 rpci->nwriters = 0;
837 INIT_LIST_HEAD(&rpci->in_upcall);
838 INIT_LIST_HEAD(&rpci->pipe);
839 rpci->pipelen = 0;
840 init_waitqueue_head(&rpci->waitq);
841 INIT_WORK(&rpci->queue_timeout, rpc_timeout_upcall_queue, rpci);
842 rpci->ops = NULL;
843 }
844}
845
846int register_rpc_pipefs(void)
847{
848 rpc_inode_cachep = kmem_cache_create("rpc_inode_cache",
Paul Jacksonfffb60f2006-03-24 03:16:06 -0800849 sizeof(struct rpc_inode),
850 0, (SLAB_HWCACHE_ALIGN|SLAB_RECLAIM_ACCOUNT|
851 SLAB_MEM_SPREAD),
852 init_once, NULL);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700853 if (!rpc_inode_cachep)
854 return -ENOMEM;
855 register_filesystem(&rpc_pipe_fs_type);
856 return 0;
857}
858
859void unregister_rpc_pipefs(void)
860{
861 if (kmem_cache_destroy(rpc_inode_cachep))
862 printk(KERN_WARNING "RPC: unable to free inode cache\n");
863 unregister_filesystem(&rpc_pipe_fs_type);
864}