blob: cc673dd8433fd3653d66100e460acf7cdfac60ac [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 */
11#include <linux/config.h>
12#include <linux/module.h>
13#include <linux/slab.h>
14#include <linux/string.h>
15#include <linux/pagemap.h>
16#include <linux/mount.h>
17#include <linux/namei.h>
18#include <linux/dnotify.h>
19#include <linux/kernel.h>
20
21#include <asm/ioctls.h>
22#include <linux/fs.h>
23#include <linux/poll.h>
24#include <linux/wait.h>
25#include <linux/seq_file.h>
26
27#include <linux/sunrpc/clnt.h>
28#include <linux/workqueue.h>
29#include <linux/sunrpc/rpc_pipe_fs.h>
30
Eric Dumazetba899662005-08-26 12:05:31 -070031static struct vfsmount *rpc_mount __read_mostly;
Linus Torvalds1da177e2005-04-16 15:20:36 -070032static int rpc_mount_count;
33
34static struct file_system_type rpc_pipe_fs_type;
35
36
Eric Dumazetba899662005-08-26 12:05:31 -070037static kmem_cache_t *rpc_inode_cachep __read_mostly;
Linus Torvalds1da177e2005-04-16 15:20:36 -070038
39#define RPC_UPCALL_TIMEOUT (30*HZ)
40
Trond Myklebust9842ef32006-02-01 12:18:44 -050041static void rpc_purge_list(struct rpc_inode *rpci, struct list_head *head,
42 void (*destroy_msg)(struct rpc_pipe_msg *), int err)
Trond Myklebustb3eb67a2005-11-25 17:10:11 -050043{
44 struct rpc_pipe_msg *msg;
Trond Myklebustb3eb67a2005-11-25 17:10:11 -050045
Trond Myklebust9842ef32006-02-01 12:18:44 -050046 if (list_empty(head))
47 return;
48 do {
Trond Myklebustb3eb67a2005-11-25 17:10:11 -050049 msg = list_entry(head->next, struct rpc_pipe_msg, list);
Trond Myklebust9842ef32006-02-01 12:18:44 -050050 list_del(&msg->list);
Trond Myklebustb3eb67a2005-11-25 17:10:11 -050051 msg->errno = err;
52 destroy_msg(msg);
Trond Myklebust9842ef32006-02-01 12:18:44 -050053 } while (!list_empty(head));
Linus Torvalds1da177e2005-04-16 15:20:36 -070054 wake_up(&rpci->waitq);
55}
56
57static void
58rpc_timeout_upcall_queue(void *data)
59{
Trond Myklebust9842ef32006-02-01 12:18:44 -050060 LIST_HEAD(free_list);
Linus Torvalds1da177e2005-04-16 15:20:36 -070061 struct rpc_inode *rpci = (struct rpc_inode *)data;
62 struct inode *inode = &rpci->vfs_inode;
Trond Myklebust9842ef32006-02-01 12:18:44 -050063 void (*destroy_msg)(struct rpc_pipe_msg *);
Linus Torvalds1da177e2005-04-16 15:20:36 -070064
Trond Myklebust9842ef32006-02-01 12:18:44 -050065 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);
Linus Torvalds1da177e2005-04-16 15:20:36 -070077}
78
79int
80rpc_queue_upcall(struct inode *inode, struct rpc_pipe_msg *msg)
81{
82 struct rpc_inode *rpci = RPC_I(inode);
Trond Myklebust6070fe62005-10-27 22:12:46 -040083 int res = -EPIPE;
Linus Torvalds1da177e2005-04-16 15:20:36 -070084
Trond Myklebust9842ef32006-02-01 12:18:44 -050085 spin_lock(&inode->i_lock);
Trond Myklebust6070fe62005-10-27 22:12:46 -040086 if (rpci->ops == NULL)
87 goto out;
Linus Torvalds1da177e2005-04-16 15:20:36 -070088 if (rpci->nreaders) {
89 list_add_tail(&msg->list, &rpci->pipe);
90 rpci->pipelen += msg->len;
Trond Myklebust6070fe62005-10-27 22:12:46 -040091 res = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -070092 } else if (rpci->flags & RPC_PIPE_WAIT_FOR_OPEN) {
93 if (list_empty(&rpci->pipe))
Trond Myklebust24c5d9d2006-03-20 13:44:08 -050094 queue_delayed_work(rpciod_workqueue,
95 &rpci->queue_timeout,
Linus Torvalds1da177e2005-04-16 15:20:36 -070096 RPC_UPCALL_TIMEOUT);
97 list_add_tail(&msg->list, &rpci->pipe);
98 rpci->pipelen += msg->len;
Trond Myklebust6070fe62005-10-27 22:12:46 -040099 res = 0;
100 }
101out:
Trond Myklebust9842ef32006-02-01 12:18:44 -0500102 spin_unlock(&inode->i_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700103 wake_up(&rpci->waitq);
104 return res;
105}
106
Trond Myklebust6070fe62005-10-27 22:12:46 -0400107static inline void
108rpc_inode_setowner(struct inode *inode, void *private)
109{
110 RPC_I(inode)->private = private;
111}
112
Linus Torvalds1da177e2005-04-16 15:20:36 -0700113static void
114rpc_close_pipes(struct inode *inode)
115{
116 struct rpc_inode *rpci = RPC_I(inode);
Trond Myklebust9842ef32006-02-01 12:18:44 -0500117 struct rpc_pipe_ops *ops;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700118
Jes Sorensen1b1dcc12006-01-09 15:59:24 -0800119 mutex_lock(&inode->i_mutex);
Trond Myklebust9842ef32006-02-01 12:18:44 -0500120 ops = rpci->ops;
121 if (ops != NULL) {
122 LIST_HEAD(free_list);
123
124 spin_lock(&inode->i_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700125 rpci->nreaders = 0;
Trond Myklebust9842ef32006-02-01 12:18:44 -0500126 list_splice_init(&rpci->in_upcall, &free_list);
127 list_splice_init(&rpci->pipe, &free_list);
128 rpci->pipelen = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700129 rpci->ops = NULL;
Trond Myklebust9842ef32006-02-01 12:18:44 -0500130 spin_unlock(&inode->i_lock);
131 rpc_purge_list(rpci, &free_list, ops->destroy_msg, -EPIPE);
132 rpci->nwriters = 0;
133 if (ops->release_pipe)
134 ops->release_pipe(inode);
135 cancel_delayed_work(&rpci->queue_timeout);
Trond Myklebust24c5d9d2006-03-20 13:44:08 -0500136 flush_workqueue(rpciod_workqueue);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700137 }
Trond Myklebust6070fe62005-10-27 22:12:46 -0400138 rpc_inode_setowner(inode, NULL);
Jes Sorensen1b1dcc12006-01-09 15:59:24 -0800139 mutex_unlock(&inode->i_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700140}
141
Linus Torvalds1da177e2005-04-16 15:20:36 -0700142static struct inode *
143rpc_alloc_inode(struct super_block *sb)
144{
145 struct rpc_inode *rpci;
146 rpci = (struct rpc_inode *)kmem_cache_alloc(rpc_inode_cachep, SLAB_KERNEL);
147 if (!rpci)
148 return NULL;
149 return &rpci->vfs_inode;
150}
151
152static void
153rpc_destroy_inode(struct inode *inode)
154{
155 kmem_cache_free(rpc_inode_cachep, RPC_I(inode));
156}
157
158static int
159rpc_pipe_open(struct inode *inode, struct file *filp)
160{
161 struct rpc_inode *rpci = RPC_I(inode);
162 int res = -ENXIO;
163
Jes Sorensen1b1dcc12006-01-09 15:59:24 -0800164 mutex_lock(&inode->i_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700165 if (rpci->ops != NULL) {
166 if (filp->f_mode & FMODE_READ)
167 rpci->nreaders ++;
168 if (filp->f_mode & FMODE_WRITE)
169 rpci->nwriters ++;
170 res = 0;
171 }
Jes Sorensen1b1dcc12006-01-09 15:59:24 -0800172 mutex_unlock(&inode->i_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700173 return res;
174}
175
176static int
177rpc_pipe_release(struct inode *inode, struct file *filp)
178{
Trond Myklebust969b7f22006-01-03 09:55:36 +0100179 struct rpc_inode *rpci = RPC_I(inode);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700180 struct rpc_pipe_msg *msg;
181
Jes Sorensen1b1dcc12006-01-09 15:59:24 -0800182 mutex_lock(&inode->i_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700183 if (rpci->ops == NULL)
184 goto out;
185 msg = (struct rpc_pipe_msg *)filp->private_data;
186 if (msg != NULL) {
Trond Myklebust9842ef32006-02-01 12:18:44 -0500187 spin_lock(&inode->i_lock);
Trond Myklebust48e49182005-12-19 17:11:22 -0500188 msg->errno = -EAGAIN;
Trond Myklebust9842ef32006-02-01 12:18:44 -0500189 list_del(&msg->list);
190 spin_unlock(&inode->i_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700191 rpci->ops->destroy_msg(msg);
192 }
193 if (filp->f_mode & FMODE_WRITE)
194 rpci->nwriters --;
Trond Myklebust9842ef32006-02-01 12:18:44 -0500195 if (filp->f_mode & FMODE_READ) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700196 rpci->nreaders --;
Trond Myklebust9842ef32006-02-01 12:18:44 -0500197 if (rpci->nreaders == 0) {
198 LIST_HEAD(free_list);
199 spin_lock(&inode->i_lock);
200 list_splice_init(&rpci->pipe, &free_list);
201 rpci->pipelen = 0;
202 spin_unlock(&inode->i_lock);
203 rpc_purge_list(rpci, &free_list,
204 rpci->ops->destroy_msg, -EAGAIN);
205 }
206 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700207 if (rpci->ops->release_pipe)
208 rpci->ops->release_pipe(inode);
209out:
Jes Sorensen1b1dcc12006-01-09 15:59:24 -0800210 mutex_unlock(&inode->i_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700211 return 0;
212}
213
214static ssize_t
215rpc_pipe_read(struct file *filp, char __user *buf, size_t len, loff_t *offset)
216{
217 struct inode *inode = filp->f_dentry->d_inode;
218 struct rpc_inode *rpci = RPC_I(inode);
219 struct rpc_pipe_msg *msg;
220 int res = 0;
221
Jes Sorensen1b1dcc12006-01-09 15:59:24 -0800222 mutex_lock(&inode->i_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700223 if (rpci->ops == NULL) {
224 res = -EPIPE;
225 goto out_unlock;
226 }
227 msg = filp->private_data;
228 if (msg == NULL) {
Trond Myklebust9842ef32006-02-01 12:18:44 -0500229 spin_lock(&inode->i_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700230 if (!list_empty(&rpci->pipe)) {
231 msg = list_entry(rpci->pipe.next,
232 struct rpc_pipe_msg,
233 list);
234 list_move(&msg->list, &rpci->in_upcall);
235 rpci->pipelen -= msg->len;
236 filp->private_data = msg;
237 msg->copied = 0;
238 }
Trond Myklebust9842ef32006-02-01 12:18:44 -0500239 spin_unlock(&inode->i_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700240 if (msg == NULL)
241 goto out_unlock;
242 }
243 /* NOTE: it is up to the callback to update msg->copied */
244 res = rpci->ops->upcall(filp, msg, buf, len);
245 if (res < 0 || msg->len == msg->copied) {
246 filp->private_data = NULL;
Trond Myklebust9842ef32006-02-01 12:18:44 -0500247 spin_lock(&inode->i_lock);
248 list_del(&msg->list);
249 spin_unlock(&inode->i_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700250 rpci->ops->destroy_msg(msg);
251 }
252out_unlock:
Jes Sorensen1b1dcc12006-01-09 15:59:24 -0800253 mutex_unlock(&inode->i_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700254 return res;
255}
256
257static ssize_t
258rpc_pipe_write(struct file *filp, const char __user *buf, size_t len, loff_t *offset)
259{
260 struct inode *inode = filp->f_dentry->d_inode;
261 struct rpc_inode *rpci = RPC_I(inode);
262 int res;
263
Jes Sorensen1b1dcc12006-01-09 15:59:24 -0800264 mutex_lock(&inode->i_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700265 res = -EPIPE;
266 if (rpci->ops != NULL)
267 res = rpci->ops->downcall(filp, buf, len);
Jes Sorensen1b1dcc12006-01-09 15:59:24 -0800268 mutex_unlock(&inode->i_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700269 return res;
270}
271
272static unsigned int
273rpc_pipe_poll(struct file *filp, struct poll_table_struct *wait)
274{
275 struct rpc_inode *rpci;
276 unsigned int mask = 0;
277
278 rpci = RPC_I(filp->f_dentry->d_inode);
279 poll_wait(filp, &rpci->waitq, wait);
280
281 mask = POLLOUT | POLLWRNORM;
282 if (rpci->ops == NULL)
283 mask |= POLLERR | POLLHUP;
284 if (!list_empty(&rpci->pipe))
285 mask |= POLLIN | POLLRDNORM;
286 return mask;
287}
288
289static int
290rpc_pipe_ioctl(struct inode *ino, struct file *filp,
291 unsigned int cmd, unsigned long arg)
292{
293 struct rpc_inode *rpci = RPC_I(filp->f_dentry->d_inode);
294 int len;
295
296 switch (cmd) {
297 case FIONREAD:
298 if (rpci->ops == NULL)
299 return -EPIPE;
300 len = rpci->pipelen;
301 if (filp->private_data) {
302 struct rpc_pipe_msg *msg;
303 msg = (struct rpc_pipe_msg *)filp->private_data;
304 len += msg->len - msg->copied;
305 }
306 return put_user(len, (int __user *)arg);
307 default:
308 return -EINVAL;
309 }
310}
311
312static struct file_operations rpc_pipe_fops = {
313 .owner = THIS_MODULE,
314 .llseek = no_llseek,
315 .read = rpc_pipe_read,
316 .write = rpc_pipe_write,
317 .poll = rpc_pipe_poll,
318 .ioctl = rpc_pipe_ioctl,
319 .open = rpc_pipe_open,
320 .release = rpc_pipe_release,
321};
322
323static int
324rpc_show_info(struct seq_file *m, void *v)
325{
326 struct rpc_clnt *clnt = m->private;
327
328 seq_printf(m, "RPC server: %s\n", clnt->cl_server);
329 seq_printf(m, "service: %s (%d) version %d\n", clnt->cl_protname,
330 clnt->cl_prog, clnt->cl_vers);
331 seq_printf(m, "address: %u.%u.%u.%u\n",
332 NIPQUAD(clnt->cl_xprt->addr.sin_addr.s_addr));
333 seq_printf(m, "protocol: %s\n",
334 clnt->cl_xprt->prot == IPPROTO_UDP ? "udp" : "tcp");
335 return 0;
336}
337
338static int
339rpc_info_open(struct inode *inode, struct file *file)
340{
341 struct rpc_clnt *clnt;
342 int ret = single_open(file, rpc_show_info, NULL);
343
344 if (!ret) {
345 struct seq_file *m = file->private_data;
Jes Sorensen1b1dcc12006-01-09 15:59:24 -0800346 mutex_lock(&inode->i_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700347 clnt = RPC_I(inode)->private;
348 if (clnt) {
349 atomic_inc(&clnt->cl_users);
350 m->private = clnt;
351 } else {
352 single_release(inode, file);
353 ret = -EINVAL;
354 }
Jes Sorensen1b1dcc12006-01-09 15:59:24 -0800355 mutex_unlock(&inode->i_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700356 }
357 return ret;
358}
359
360static int
361rpc_info_release(struct inode *inode, struct file *file)
362{
363 struct seq_file *m = file->private_data;
364 struct rpc_clnt *clnt = (struct rpc_clnt *)m->private;
365
366 if (clnt)
367 rpc_release_client(clnt);
368 return single_release(inode, file);
369}
370
371static struct file_operations rpc_info_operations = {
372 .owner = THIS_MODULE,
373 .open = rpc_info_open,
374 .read = seq_read,
375 .llseek = seq_lseek,
376 .release = rpc_info_release,
377};
378
379
380/*
381 * We have a single directory with 1 node in it.
382 */
383enum {
384 RPCAUTH_Root = 1,
385 RPCAUTH_lockd,
386 RPCAUTH_mount,
387 RPCAUTH_nfs,
388 RPCAUTH_portmap,
389 RPCAUTH_statd,
390 RPCAUTH_RootEOF
391};
392
393/*
394 * Description of fs contents.
395 */
396struct rpc_filelist {
397 char *name;
Arjan van de Ven99ac48f2006-03-28 01:56:41 -0800398 const struct file_operations *i_fop;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700399 int mode;
400};
401
402static struct rpc_filelist files[] = {
403 [RPCAUTH_lockd] = {
404 .name = "lockd",
405 .mode = S_IFDIR | S_IRUGO | S_IXUGO,
406 },
407 [RPCAUTH_mount] = {
408 .name = "mount",
409 .mode = S_IFDIR | S_IRUGO | S_IXUGO,
410 },
411 [RPCAUTH_nfs] = {
412 .name = "nfs",
413 .mode = S_IFDIR | S_IRUGO | S_IXUGO,
414 },
415 [RPCAUTH_portmap] = {
416 .name = "portmap",
417 .mode = S_IFDIR | S_IRUGO | S_IXUGO,
418 },
419 [RPCAUTH_statd] = {
420 .name = "statd",
421 .mode = S_IFDIR | S_IRUGO | S_IXUGO,
422 },
423};
424
425enum {
426 RPCAUTH_info = 2,
427 RPCAUTH_EOF
428};
429
430static struct rpc_filelist authfiles[] = {
431 [RPCAUTH_info] = {
432 .name = "info",
433 .i_fop = &rpc_info_operations,
434 .mode = S_IFREG | S_IRUSR,
435 },
436};
437
Trond Myklebust54281542006-03-20 13:44:49 -0500438struct vfsmount *rpc_get_mount(void)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700439{
Trond Myklebust54281542006-03-20 13:44:49 -0500440 int err;
441
442 err = simple_pin_fs("rpc_pipefs", &rpc_mount, &rpc_mount_count);
443 if (err != 0)
444 return ERR_PTR(err);
445 return rpc_mount;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700446}
447
Trond Myklebust54281542006-03-20 13:44:49 -0500448void rpc_put_mount(void)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700449{
450 simple_release_fs(&rpc_mount, &rpc_mount_count);
451}
452
Trond Myklebustf1345852005-09-23 11:08:25 -0400453static int
454rpc_lookup_parent(char *path, struct nameidata *nd)
455{
456 if (path[0] == '\0')
457 return -ENOENT;
Trond Myklebust54281542006-03-20 13:44:49 -0500458 nd->mnt = rpc_get_mount();
459 if (IS_ERR(nd->mnt)) {
Trond Myklebustf1345852005-09-23 11:08:25 -0400460 printk(KERN_WARNING "%s: %s failed to mount "
461 "pseudofilesystem \n", __FILE__, __FUNCTION__);
Trond Myklebust54281542006-03-20 13:44:49 -0500462 return PTR_ERR(nd->mnt);
Trond Myklebustf1345852005-09-23 11:08:25 -0400463 }
Trond Myklebust54281542006-03-20 13:44:49 -0500464 mntget(nd->mnt);
Trond Myklebustf1345852005-09-23 11:08:25 -0400465 nd->dentry = dget(rpc_mount->mnt_root);
466 nd->last_type = LAST_ROOT;
467 nd->flags = LOOKUP_PARENT;
468 nd->depth = 0;
469
470 if (path_walk(path, nd)) {
471 printk(KERN_WARNING "%s: %s failed to find path %s\n",
472 __FILE__, __FUNCTION__, path);
473 rpc_put_mount();
474 return -ENOENT;
475 }
476 return 0;
477}
478
479static void
480rpc_release_path(struct nameidata *nd)
481{
482 path_release(nd);
483 rpc_put_mount();
484}
485
Linus Torvalds1da177e2005-04-16 15:20:36 -0700486static struct inode *
487rpc_get_inode(struct super_block *sb, int mode)
488{
489 struct inode *inode = new_inode(sb);
490 if (!inode)
491 return NULL;
492 inode->i_mode = mode;
493 inode->i_uid = inode->i_gid = 0;
494 inode->i_blksize = PAGE_CACHE_SIZE;
495 inode->i_blocks = 0;
496 inode->i_atime = inode->i_mtime = inode->i_ctime = CURRENT_TIME;
497 switch(mode & S_IFMT) {
498 case S_IFDIR:
499 inode->i_fop = &simple_dir_operations;
500 inode->i_op = &simple_dir_inode_operations;
501 inode->i_nlink++;
502 default:
503 break;
504 }
505 return inode;
506}
507
508/*
509 * FIXME: This probably has races.
510 */
511static void
512rpc_depopulate(struct dentry *parent)
513{
514 struct inode *dir = parent->d_inode;
515 struct list_head *pos, *next;
516 struct dentry *dentry, *dvec[10];
517 int n = 0;
518
Jes Sorensen1b1dcc12006-01-09 15:59:24 -0800519 mutex_lock(&dir->i_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700520repeat:
521 spin_lock(&dcache_lock);
522 list_for_each_safe(pos, next, &parent->d_subdirs) {
Eric Dumazet5160ee62006-01-08 01:03:32 -0800523 dentry = list_entry(pos, struct dentry, d_u.d_child);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700524 spin_lock(&dentry->d_lock);
525 if (!d_unhashed(dentry)) {
526 dget_locked(dentry);
527 __d_drop(dentry);
528 spin_unlock(&dentry->d_lock);
529 dvec[n++] = dentry;
530 if (n == ARRAY_SIZE(dvec))
531 break;
532 } else
533 spin_unlock(&dentry->d_lock);
534 }
535 spin_unlock(&dcache_lock);
536 if (n) {
537 do {
538 dentry = dvec[--n];
539 if (dentry->d_inode) {
540 rpc_close_pipes(dentry->d_inode);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700541 simple_unlink(dir, dentry);
542 }
543 dput(dentry);
544 } while (n);
545 goto repeat;
546 }
Jes Sorensen1b1dcc12006-01-09 15:59:24 -0800547 mutex_unlock(&dir->i_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700548}
549
550static int
551rpc_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;
559
Jes Sorensen1b1dcc12006-01-09 15:59:24 -0800560 mutex_lock(&dir->i_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700561 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 }
Jes Sorensen1b1dcc12006-01-09 15:59:24 -0800580 mutex_unlock(&dir->i_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700581 return 0;
582out_bad:
Jes Sorensen1b1dcc12006-01-09 15:59:24 -0800583 mutex_unlock(&dir->i_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700584 printk(KERN_WARNING "%s: %s failed to populate directory %s\n",
585 __FILE__, __FUNCTION__, parent->d_name.name);
586 return -ENOMEM;
587}
588
Trond Myklebustf1345852005-09-23 11:08:25 -0400589static int
590__rpc_mkdir(struct inode *dir, struct dentry *dentry)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700591{
592 struct inode *inode;
593
594 inode = rpc_get_inode(dir->i_sb, S_IFDIR | S_IRUSR | S_IXUSR);
595 if (!inode)
Trond Myklebustf1345852005-09-23 11:08:25 -0400596 goto out_err;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700597 inode->i_ino = iunique(dir->i_sb, 100);
Christoph Hellwig278c9952005-07-24 23:53:01 +0100598 d_instantiate(dentry, inode);
Trond Myklebustf1345852005-09-23 11:08:25 -0400599 dir->i_nlink++;
Christoph Hellwig278c9952005-07-24 23:53:01 +0100600 inode_dir_notify(dir, DN_CREATE);
Trond Myklebustf1345852005-09-23 11:08:25 -0400601 return 0;
602out_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;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700606}
607
Trond Myklebustf1345852005-09-23 11:08:25 -0400608static int
609__rpc_rmdir(struct inode *dir, struct dentry *dentry)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700610{
Trond Myklebustf1345852005-09-23 11:08:25 -0400611 int error;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700612
Trond Myklebustf1345852005-09-23 11:08:25 -0400613 shrink_dcache_parent(dentry);
Trond Myklebust6070fe62005-10-27 22:12:46 -0400614 if (dentry->d_inode)
Christoph Hellwig278c9952005-07-24 23:53:01 +0100615 rpc_close_pipes(dentry->d_inode);
Trond Myklebustf1345852005-09-23 11:08:25 -0400616 if ((error = simple_rmdir(dir, dentry)) != 0)
617 return error;
618 if (!error) {
619 inode_dir_notify(dir, DN_DELETE);
620 d_drop(dentry);
Trond Myklebustf1345852005-09-23 11:08:25 -0400621 }
622 return 0;
623}
Christoph Hellwig278c9952005-07-24 23:53:01 +0100624
Trond Myklebustf1345852005-09-23 11:08:25 -0400625static struct dentry *
626rpc_lookup_negative(char *path, struct nameidata *nd)
627{
628 struct dentry *dentry;
629 struct inode *dir;
630 int error;
631
632 if ((error = rpc_lookup_parent(path, nd)) != 0)
633 return ERR_PTR(error);
634 dir = nd->dentry->d_inode;
Jes Sorensen1b1dcc12006-01-09 15:59:24 -0800635 mutex_lock(&dir->i_mutex);
Trond Myklebustadb12f62006-02-01 12:19:13 -0500636 dentry = lookup_one_len(nd->last.name, nd->dentry, nd->last.len);
Trond Myklebustf1345852005-09-23 11:08:25 -0400637 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;
645out_err:
Jes Sorensen1b1dcc12006-01-09 15:59:24 -0800646 mutex_unlock(&dir->i_mutex);
Trond Myklebustf1345852005-09-23 11:08:25 -0400647 rpc_release_path(nd);
648 return dentry;
649}
650
651
652struct dentry *
653rpc_mkdir(char *path, struct rpc_clnt *rpc_client)
654{
655 struct nameidata nd;
656 struct dentry *dentry;
657 struct inode *dir;
658 int error;
659
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;
671out:
Jes Sorensen1b1dcc12006-01-09 15:59:24 -0800672 mutex_unlock(&dir->i_mutex);
Trond Myklebustf1345852005-09-23 11:08:25 -0400673 rpc_release_path(&nd);
Trond Myklebust12de3b32006-03-20 13:44:09 -0500674 return dget(dentry);
Trond Myklebustf1345852005-09-23 11:08:25 -0400675err_depopulate:
676 rpc_depopulate(dentry);
677 __rpc_rmdir(dir, dentry);
678err_dput:
679 dput(dentry);
680 printk(KERN_WARNING "%s: %s() failed to create directory %s (errno = %d)\n",
681 __FILE__, __FUNCTION__, path, error);
682 dentry = ERR_PTR(error);
683 goto out;
684}
685
686int
687rpc_rmdir(char *path)
688{
689 struct nameidata nd;
690 struct dentry *dentry;
691 struct inode *dir;
692 int error;
693
694 if ((error = rpc_lookup_parent(path, &nd)) != 0)
695 return error;
696 dir = nd.dentry->d_inode;
Jes Sorensen1b1dcc12006-01-09 15:59:24 -0800697 mutex_lock(&dir->i_mutex);
Trond Myklebustadb12f62006-02-01 12:19:13 -0500698 dentry = lookup_one_len(nd.last.name, nd.dentry, nd.last.len);
Trond Myklebustf1345852005-09-23 11:08:25 -0400699 if (IS_ERR(dentry)) {
700 error = PTR_ERR(dentry);
701 goto out_release;
702 }
703 rpc_depopulate(dentry);
704 error = __rpc_rmdir(dir, dentry);
705 dput(dentry);
706out_release:
Jes Sorensen1b1dcc12006-01-09 15:59:24 -0800707 mutex_unlock(&dir->i_mutex);
Trond Myklebustf1345852005-09-23 11:08:25 -0400708 rpc_release_path(&nd);
709 return error;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700710}
711
712struct dentry *
Trond Myklebustf1345852005-09-23 11:08:25 -0400713rpc_mkpipe(char *path, void *private, struct rpc_pipe_ops *ops, int flags)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700714{
Trond Myklebustf1345852005-09-23 11:08:25 -0400715 struct nameidata nd;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700716 struct dentry *dentry;
Trond Myklebustf1345852005-09-23 11:08:25 -0400717 struct inode *dir, *inode;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700718 struct rpc_inode *rpci;
719
Trond Myklebustf1345852005-09-23 11:08:25 -0400720 dentry = rpc_lookup_negative(path, &nd);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700721 if (IS_ERR(dentry))
Trond Myklebustf1345852005-09-23 11:08:25 -0400722 return dentry;
723 dir = nd.dentry->d_inode;
724 inode = rpc_get_inode(dir->i_sb, S_IFSOCK | S_IRUSR | S_IWUSR);
725 if (!inode)
726 goto err_dput;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700727 inode->i_ino = iunique(dir->i_sb, 100);
728 inode->i_fop = &rpc_pipe_fops;
Trond Myklebustf1345852005-09-23 11:08:25 -0400729 d_instantiate(dentry, inode);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700730 rpci = RPC_I(inode);
731 rpci->private = private;
732 rpci->flags = flags;
733 rpci->ops = ops;
734 inode_dir_notify(dir, DN_CREATE);
Trond Myklebustf1345852005-09-23 11:08:25 -0400735out:
Jes Sorensen1b1dcc12006-01-09 15:59:24 -0800736 mutex_unlock(&dir->i_mutex);
Trond Myklebustf1345852005-09-23 11:08:25 -0400737 rpc_release_path(&nd);
Trond Myklebust12de3b32006-03-20 13:44:09 -0500738 return dget(dentry);
Trond Myklebustf1345852005-09-23 11:08:25 -0400739err_dput:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700740 dput(dentry);
Trond Myklebustf1345852005-09-23 11:08:25 -0400741 dentry = ERR_PTR(-ENOMEM);
742 printk(KERN_WARNING "%s: %s() failed to create pipe %s (errno = %d)\n",
743 __FILE__, __FUNCTION__, path, -ENOMEM);
744 goto out;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700745}
746
Trond Myklebustf1345852005-09-23 11:08:25 -0400747int
748rpc_unlink(char *path)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700749{
Trond Myklebustf1345852005-09-23 11:08:25 -0400750 struct nameidata nd;
751 struct dentry *dentry;
752 struct inode *dir;
753 int error;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700754
Trond Myklebustf1345852005-09-23 11:08:25 -0400755 if ((error = rpc_lookup_parent(path, &nd)) != 0)
756 return error;
757 dir = nd.dentry->d_inode;
Jes Sorensen1b1dcc12006-01-09 15:59:24 -0800758 mutex_lock(&dir->i_mutex);
Trond Myklebustadb12f62006-02-01 12:19:13 -0500759 dentry = lookup_one_len(nd.last.name, nd.dentry, nd.last.len);
Trond Myklebustf1345852005-09-23 11:08:25 -0400760 if (IS_ERR(dentry)) {
761 error = PTR_ERR(dentry);
762 goto out_release;
763 }
764 d_drop(dentry);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700765 if (dentry->d_inode) {
766 rpc_close_pipes(dentry->d_inode);
Trond Myklebustf1345852005-09-23 11:08:25 -0400767 error = simple_unlink(dir, dentry);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700768 }
Trond Myklebustf1345852005-09-23 11:08:25 -0400769 dput(dentry);
770 inode_dir_notify(dir, DN_DELETE);
771out_release:
Jes Sorensen1b1dcc12006-01-09 15:59:24 -0800772 mutex_unlock(&dir->i_mutex);
Trond Myklebustf1345852005-09-23 11:08:25 -0400773 rpc_release_path(&nd);
774 return error;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700775}
776
777/*
778 * populate the filesystem
779 */
780static struct super_operations s_ops = {
781 .alloc_inode = rpc_alloc_inode,
782 .destroy_inode = rpc_destroy_inode,
783 .statfs = simple_statfs,
784};
785
786#define RPCAUTH_GSSMAGIC 0x67596969
787
788static int
789rpc_fill_super(struct super_block *sb, void *data, int silent)
790{
791 struct inode *inode;
792 struct dentry *root;
793
794 sb->s_blocksize = PAGE_CACHE_SIZE;
795 sb->s_blocksize_bits = PAGE_CACHE_SHIFT;
796 sb->s_magic = RPCAUTH_GSSMAGIC;
797 sb->s_op = &s_ops;
798 sb->s_time_gran = 1;
799
800 inode = rpc_get_inode(sb, S_IFDIR | 0755);
801 if (!inode)
802 return -ENOMEM;
803 root = d_alloc_root(inode);
804 if (!root) {
805 iput(inode);
806 return -ENOMEM;
807 }
808 if (rpc_populate(root, files, RPCAUTH_Root + 1, RPCAUTH_RootEOF))
809 goto out;
810 sb->s_root = root;
811 return 0;
812out:
813 d_genocide(root);
814 dput(root);
815 return -ENOMEM;
816}
817
818static struct super_block *
819rpc_get_sb(struct file_system_type *fs_type,
820 int flags, const char *dev_name, void *data)
821{
822 return get_sb_single(fs_type, flags, data, rpc_fill_super);
823}
824
825static struct file_system_type rpc_pipe_fs_type = {
826 .owner = THIS_MODULE,
827 .name = "rpc_pipefs",
828 .get_sb = rpc_get_sb,
829 .kill_sb = kill_litter_super,
830};
831
832static void
833init_once(void * foo, kmem_cache_t * cachep, unsigned long flags)
834{
835 struct rpc_inode *rpci = (struct rpc_inode *) foo;
836
837 if ((flags & (SLAB_CTOR_VERIFY|SLAB_CTOR_CONSTRUCTOR)) ==
838 SLAB_CTOR_CONSTRUCTOR) {
839 inode_init_once(&rpci->vfs_inode);
840 rpci->private = NULL;
841 rpci->nreaders = 0;
842 rpci->nwriters = 0;
843 INIT_LIST_HEAD(&rpci->in_upcall);
844 INIT_LIST_HEAD(&rpci->pipe);
845 rpci->pipelen = 0;
846 init_waitqueue_head(&rpci->waitq);
847 INIT_WORK(&rpci->queue_timeout, rpc_timeout_upcall_queue, rpci);
848 rpci->ops = NULL;
849 }
850}
851
852int register_rpc_pipefs(void)
853{
854 rpc_inode_cachep = kmem_cache_create("rpc_inode_cache",
Paul Jacksonfffb60f2006-03-24 03:16:06 -0800855 sizeof(struct rpc_inode),
856 0, (SLAB_HWCACHE_ALIGN|SLAB_RECLAIM_ACCOUNT|
857 SLAB_MEM_SPREAD),
858 init_once, NULL);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700859 if (!rpc_inode_cachep)
860 return -ENOMEM;
861 register_filesystem(&rpc_pipe_fs_type);
862 return 0;
863}
864
865void unregister_rpc_pipefs(void)
866{
867 if (kmem_cache_destroy(rpc_inode_cachep))
868 printk(KERN_WARNING "RPC: unable to free inode cache\n");
869 unregister_filesystem(&rpc_pipe_fs_type);
870}