blob: a5c0c7b6e151b4a8712ec67d3c3cdbf32308497c [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))
94 schedule_delayed_work(&rpci->queue_timeout,
95 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);
135 flush_scheduled_work();
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);
330 seq_printf(m, "address: %u.%u.%u.%u\n",
331 NIPQUAD(clnt->cl_xprt->addr.sin_addr.s_addr));
332 seq_printf(m, "protocol: %s\n",
333 clnt->cl_xprt->prot == IPPROTO_UDP ? "udp" : "tcp");
334 return 0;
335}
336
337static int
338rpc_info_open(struct inode *inode, struct file *file)
339{
340 struct rpc_clnt *clnt;
341 int ret = single_open(file, rpc_show_info, NULL);
342
343 if (!ret) {
344 struct seq_file *m = file->private_data;
Jes Sorensen1b1dcc12006-01-09 15:59:24 -0800345 mutex_lock(&inode->i_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700346 clnt = RPC_I(inode)->private;
347 if (clnt) {
348 atomic_inc(&clnt->cl_users);
349 m->private = clnt;
350 } else {
351 single_release(inode, file);
352 ret = -EINVAL;
353 }
Jes Sorensen1b1dcc12006-01-09 15:59:24 -0800354 mutex_unlock(&inode->i_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700355 }
356 return ret;
357}
358
359static int
360rpc_info_release(struct inode *inode, struct file *file)
361{
362 struct seq_file *m = file->private_data;
363 struct rpc_clnt *clnt = (struct rpc_clnt *)m->private;
364
365 if (clnt)
366 rpc_release_client(clnt);
367 return single_release(inode, file);
368}
369
370static struct file_operations rpc_info_operations = {
371 .owner = THIS_MODULE,
372 .open = rpc_info_open,
373 .read = seq_read,
374 .llseek = seq_lseek,
375 .release = rpc_info_release,
376};
377
378
379/*
380 * We have a single directory with 1 node in it.
381 */
382enum {
383 RPCAUTH_Root = 1,
384 RPCAUTH_lockd,
385 RPCAUTH_mount,
386 RPCAUTH_nfs,
387 RPCAUTH_portmap,
388 RPCAUTH_statd,
389 RPCAUTH_RootEOF
390};
391
392/*
393 * Description of fs contents.
394 */
395struct rpc_filelist {
396 char *name;
397 struct file_operations *i_fop;
398 int mode;
399};
400
401static struct rpc_filelist files[] = {
402 [RPCAUTH_lockd] = {
403 .name = "lockd",
404 .mode = S_IFDIR | S_IRUGO | S_IXUGO,
405 },
406 [RPCAUTH_mount] = {
407 .name = "mount",
408 .mode = S_IFDIR | S_IRUGO | S_IXUGO,
409 },
410 [RPCAUTH_nfs] = {
411 .name = "nfs",
412 .mode = S_IFDIR | S_IRUGO | S_IXUGO,
413 },
414 [RPCAUTH_portmap] = {
415 .name = "portmap",
416 .mode = S_IFDIR | S_IRUGO | S_IXUGO,
417 },
418 [RPCAUTH_statd] = {
419 .name = "statd",
420 .mode = S_IFDIR | S_IRUGO | S_IXUGO,
421 },
422};
423
424enum {
425 RPCAUTH_info = 2,
426 RPCAUTH_EOF
427};
428
429static struct rpc_filelist authfiles[] = {
430 [RPCAUTH_info] = {
431 .name = "info",
432 .i_fop = &rpc_info_operations,
433 .mode = S_IFREG | S_IRUSR,
434 },
435};
436
437static int
438rpc_get_mount(void)
439{
440 return simple_pin_fs("rpc_pipefs", &rpc_mount, &rpc_mount_count);
441}
442
443static void
444rpc_put_mount(void)
445{
446 simple_release_fs(&rpc_mount, &rpc_mount_count);
447}
448
Trond Myklebustf1345852005-09-23 11:08:25 -0400449static int
450rpc_lookup_parent(char *path, struct nameidata *nd)
451{
452 if (path[0] == '\0')
453 return -ENOENT;
454 if (rpc_get_mount()) {
455 printk(KERN_WARNING "%s: %s failed to mount "
456 "pseudofilesystem \n", __FILE__, __FUNCTION__);
457 return -ENODEV;
458 }
459 nd->mnt = mntget(rpc_mount);
460 nd->dentry = dget(rpc_mount->mnt_root);
461 nd->last_type = LAST_ROOT;
462 nd->flags = LOOKUP_PARENT;
463 nd->depth = 0;
464
465 if (path_walk(path, nd)) {
466 printk(KERN_WARNING "%s: %s failed to find path %s\n",
467 __FILE__, __FUNCTION__, path);
468 rpc_put_mount();
469 return -ENOENT;
470 }
471 return 0;
472}
473
474static void
475rpc_release_path(struct nameidata *nd)
476{
477 path_release(nd);
478 rpc_put_mount();
479}
480
Linus Torvalds1da177e2005-04-16 15:20:36 -0700481static struct inode *
482rpc_get_inode(struct super_block *sb, int mode)
483{
484 struct inode *inode = new_inode(sb);
485 if (!inode)
486 return NULL;
487 inode->i_mode = mode;
488 inode->i_uid = inode->i_gid = 0;
489 inode->i_blksize = PAGE_CACHE_SIZE;
490 inode->i_blocks = 0;
491 inode->i_atime = inode->i_mtime = inode->i_ctime = CURRENT_TIME;
492 switch(mode & S_IFMT) {
493 case S_IFDIR:
494 inode->i_fop = &simple_dir_operations;
495 inode->i_op = &simple_dir_inode_operations;
496 inode->i_nlink++;
497 default:
498 break;
499 }
500 return inode;
501}
502
503/*
504 * FIXME: This probably has races.
505 */
506static void
507rpc_depopulate(struct dentry *parent)
508{
509 struct inode *dir = parent->d_inode;
510 struct list_head *pos, *next;
511 struct dentry *dentry, *dvec[10];
512 int n = 0;
513
Jes Sorensen1b1dcc12006-01-09 15:59:24 -0800514 mutex_lock(&dir->i_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700515repeat:
516 spin_lock(&dcache_lock);
517 list_for_each_safe(pos, next, &parent->d_subdirs) {
Eric Dumazet5160ee62006-01-08 01:03:32 -0800518 dentry = list_entry(pos, struct dentry, d_u.d_child);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700519 spin_lock(&dentry->d_lock);
520 if (!d_unhashed(dentry)) {
521 dget_locked(dentry);
522 __d_drop(dentry);
523 spin_unlock(&dentry->d_lock);
524 dvec[n++] = dentry;
525 if (n == ARRAY_SIZE(dvec))
526 break;
527 } else
528 spin_unlock(&dentry->d_lock);
529 }
530 spin_unlock(&dcache_lock);
531 if (n) {
532 do {
533 dentry = dvec[--n];
534 if (dentry->d_inode) {
535 rpc_close_pipes(dentry->d_inode);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700536 simple_unlink(dir, dentry);
537 }
538 dput(dentry);
539 } while (n);
540 goto repeat;
541 }
Jes Sorensen1b1dcc12006-01-09 15:59:24 -0800542 mutex_unlock(&dir->i_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700543}
544
545static int
546rpc_populate(struct dentry *parent,
547 struct rpc_filelist *files,
548 int start, int eof)
549{
550 struct inode *inode, *dir = parent->d_inode;
551 void *private = RPC_I(dir)->private;
552 struct dentry *dentry;
553 int mode, i;
554
Jes Sorensen1b1dcc12006-01-09 15:59:24 -0800555 mutex_lock(&dir->i_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700556 for (i = start; i < eof; i++) {
557 dentry = d_alloc_name(parent, files[i].name);
558 if (!dentry)
559 goto out_bad;
560 mode = files[i].mode;
561 inode = rpc_get_inode(dir->i_sb, mode);
562 if (!inode) {
563 dput(dentry);
564 goto out_bad;
565 }
566 inode->i_ino = i;
567 if (files[i].i_fop)
568 inode->i_fop = files[i].i_fop;
569 if (private)
570 rpc_inode_setowner(inode, private);
571 if (S_ISDIR(mode))
572 dir->i_nlink++;
573 d_add(dentry, inode);
574 }
Jes Sorensen1b1dcc12006-01-09 15:59:24 -0800575 mutex_unlock(&dir->i_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700576 return 0;
577out_bad:
Jes Sorensen1b1dcc12006-01-09 15:59:24 -0800578 mutex_unlock(&dir->i_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700579 printk(KERN_WARNING "%s: %s failed to populate directory %s\n",
580 __FILE__, __FUNCTION__, parent->d_name.name);
581 return -ENOMEM;
582}
583
Trond Myklebustf1345852005-09-23 11:08:25 -0400584static int
585__rpc_mkdir(struct inode *dir, struct dentry *dentry)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700586{
587 struct inode *inode;
588
589 inode = rpc_get_inode(dir->i_sb, S_IFDIR | S_IRUSR | S_IXUSR);
590 if (!inode)
Trond Myklebustf1345852005-09-23 11:08:25 -0400591 goto out_err;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700592 inode->i_ino = iunique(dir->i_sb, 100);
Christoph Hellwig278c9952005-07-24 23:53:01 +0100593 d_instantiate(dentry, inode);
Trond Myklebustf1345852005-09-23 11:08:25 -0400594 dir->i_nlink++;
Christoph Hellwig278c9952005-07-24 23:53:01 +0100595 inode_dir_notify(dir, DN_CREATE);
Trond Myklebustf1345852005-09-23 11:08:25 -0400596 rpc_get_mount();
597 return 0;
598out_err:
599 printk(KERN_WARNING "%s: %s failed to allocate inode for dentry %s\n",
600 __FILE__, __FUNCTION__, dentry->d_name.name);
601 return -ENOMEM;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700602}
603
Trond Myklebustf1345852005-09-23 11:08:25 -0400604static int
605__rpc_rmdir(struct inode *dir, struct dentry *dentry)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700606{
Trond Myklebustf1345852005-09-23 11:08:25 -0400607 int error;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700608
Trond Myklebustf1345852005-09-23 11:08:25 -0400609 shrink_dcache_parent(dentry);
Trond Myklebust6070fe62005-10-27 22:12:46 -0400610 if (dentry->d_inode)
Christoph Hellwig278c9952005-07-24 23:53:01 +0100611 rpc_close_pipes(dentry->d_inode);
Trond Myklebustf1345852005-09-23 11:08:25 -0400612 if ((error = simple_rmdir(dir, dentry)) != 0)
613 return error;
614 if (!error) {
615 inode_dir_notify(dir, DN_DELETE);
616 d_drop(dentry);
617 rpc_put_mount();
618 }
619 return 0;
620}
Christoph Hellwig278c9952005-07-24 23:53:01 +0100621
Trond Myklebustf1345852005-09-23 11:08:25 -0400622static struct dentry *
623rpc_lookup_negative(char *path, struct nameidata *nd)
624{
625 struct dentry *dentry;
626 struct inode *dir;
627 int error;
628
629 if ((error = rpc_lookup_parent(path, nd)) != 0)
630 return ERR_PTR(error);
631 dir = nd->dentry->d_inode;
Jes Sorensen1b1dcc12006-01-09 15:59:24 -0800632 mutex_lock(&dir->i_mutex);
Trond Myklebustadb12f62006-02-01 12:19:13 -0500633 dentry = lookup_one_len(nd->last.name, nd->dentry, nd->last.len);
Trond Myklebustf1345852005-09-23 11:08:25 -0400634 if (IS_ERR(dentry))
635 goto out_err;
636 if (dentry->d_inode) {
637 dput(dentry);
638 dentry = ERR_PTR(-EEXIST);
639 goto out_err;
640 }
641 return dentry;
642out_err:
Jes Sorensen1b1dcc12006-01-09 15:59:24 -0800643 mutex_unlock(&dir->i_mutex);
Trond Myklebustf1345852005-09-23 11:08:25 -0400644 rpc_release_path(nd);
645 return dentry;
646}
647
648
649struct dentry *
650rpc_mkdir(char *path, struct rpc_clnt *rpc_client)
651{
652 struct nameidata nd;
653 struct dentry *dentry;
654 struct inode *dir;
655 int error;
656
657 dentry = rpc_lookup_negative(path, &nd);
658 if (IS_ERR(dentry))
659 return dentry;
660 dir = nd.dentry->d_inode;
661 if ((error = __rpc_mkdir(dir, dentry)) != 0)
662 goto err_dput;
663 RPC_I(dentry->d_inode)->private = rpc_client;
664 error = rpc_populate(dentry, authfiles,
665 RPCAUTH_info, RPCAUTH_EOF);
666 if (error)
667 goto err_depopulate;
668out:
Jes Sorensen1b1dcc12006-01-09 15:59:24 -0800669 mutex_unlock(&dir->i_mutex);
Trond Myklebustf1345852005-09-23 11:08:25 -0400670 rpc_release_path(&nd);
671 return dentry;
672err_depopulate:
673 rpc_depopulate(dentry);
674 __rpc_rmdir(dir, dentry);
675err_dput:
676 dput(dentry);
677 printk(KERN_WARNING "%s: %s() failed to create directory %s (errno = %d)\n",
678 __FILE__, __FUNCTION__, path, error);
679 dentry = ERR_PTR(error);
680 goto out;
681}
682
683int
684rpc_rmdir(char *path)
685{
686 struct nameidata nd;
687 struct dentry *dentry;
688 struct inode *dir;
689 int error;
690
691 if ((error = rpc_lookup_parent(path, &nd)) != 0)
692 return error;
693 dir = nd.dentry->d_inode;
Jes Sorensen1b1dcc12006-01-09 15:59:24 -0800694 mutex_lock(&dir->i_mutex);
Trond Myklebustadb12f62006-02-01 12:19:13 -0500695 dentry = lookup_one_len(nd.last.name, nd.dentry, nd.last.len);
Trond Myklebustf1345852005-09-23 11:08:25 -0400696 if (IS_ERR(dentry)) {
697 error = PTR_ERR(dentry);
698 goto out_release;
699 }
700 rpc_depopulate(dentry);
701 error = __rpc_rmdir(dir, dentry);
702 dput(dentry);
703out_release:
Jes Sorensen1b1dcc12006-01-09 15:59:24 -0800704 mutex_unlock(&dir->i_mutex);
Trond Myklebustf1345852005-09-23 11:08:25 -0400705 rpc_release_path(&nd);
706 return error;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700707}
708
709struct dentry *
Trond Myklebustf1345852005-09-23 11:08:25 -0400710rpc_mkpipe(char *path, void *private, struct rpc_pipe_ops *ops, int flags)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700711{
Trond Myklebustf1345852005-09-23 11:08:25 -0400712 struct nameidata nd;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700713 struct dentry *dentry;
Trond Myklebustf1345852005-09-23 11:08:25 -0400714 struct inode *dir, *inode;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700715 struct rpc_inode *rpci;
716
Trond Myklebustf1345852005-09-23 11:08:25 -0400717 dentry = rpc_lookup_negative(path, &nd);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700718 if (IS_ERR(dentry))
Trond Myklebustf1345852005-09-23 11:08:25 -0400719 return dentry;
720 dir = nd.dentry->d_inode;
721 inode = rpc_get_inode(dir->i_sb, S_IFSOCK | S_IRUSR | S_IWUSR);
722 if (!inode)
723 goto err_dput;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700724 inode->i_ino = iunique(dir->i_sb, 100);
725 inode->i_fop = &rpc_pipe_fops;
Trond Myklebustf1345852005-09-23 11:08:25 -0400726 d_instantiate(dentry, inode);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700727 rpci = RPC_I(inode);
728 rpci->private = private;
729 rpci->flags = flags;
730 rpci->ops = ops;
731 inode_dir_notify(dir, DN_CREATE);
Trond Myklebustf1345852005-09-23 11:08:25 -0400732out:
Jes Sorensen1b1dcc12006-01-09 15:59:24 -0800733 mutex_unlock(&dir->i_mutex);
Trond Myklebustf1345852005-09-23 11:08:25 -0400734 rpc_release_path(&nd);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700735 return dentry;
Trond Myklebustf1345852005-09-23 11:08:25 -0400736err_dput:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700737 dput(dentry);
Trond Myklebustf1345852005-09-23 11:08:25 -0400738 dentry = ERR_PTR(-ENOMEM);
739 printk(KERN_WARNING "%s: %s() failed to create pipe %s (errno = %d)\n",
740 __FILE__, __FUNCTION__, path, -ENOMEM);
741 goto out;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700742}
743
Trond Myklebustf1345852005-09-23 11:08:25 -0400744int
745rpc_unlink(char *path)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700746{
Trond Myklebustf1345852005-09-23 11:08:25 -0400747 struct nameidata nd;
748 struct dentry *dentry;
749 struct inode *dir;
750 int error;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700751
Trond Myklebustf1345852005-09-23 11:08:25 -0400752 if ((error = rpc_lookup_parent(path, &nd)) != 0)
753 return error;
754 dir = nd.dentry->d_inode;
Jes Sorensen1b1dcc12006-01-09 15:59:24 -0800755 mutex_lock(&dir->i_mutex);
Trond Myklebustadb12f62006-02-01 12:19:13 -0500756 dentry = lookup_one_len(nd.last.name, nd.dentry, nd.last.len);
Trond Myklebustf1345852005-09-23 11:08:25 -0400757 if (IS_ERR(dentry)) {
758 error = PTR_ERR(dentry);
759 goto out_release;
760 }
761 d_drop(dentry);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700762 if (dentry->d_inode) {
763 rpc_close_pipes(dentry->d_inode);
Trond Myklebustf1345852005-09-23 11:08:25 -0400764 error = simple_unlink(dir, dentry);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700765 }
Trond Myklebustf1345852005-09-23 11:08:25 -0400766 dput(dentry);
767 inode_dir_notify(dir, DN_DELETE);
768out_release:
Jes Sorensen1b1dcc12006-01-09 15:59:24 -0800769 mutex_unlock(&dir->i_mutex);
Trond Myklebustf1345852005-09-23 11:08:25 -0400770 rpc_release_path(&nd);
771 return error;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700772}
773
774/*
775 * populate the filesystem
776 */
777static struct super_operations s_ops = {
778 .alloc_inode = rpc_alloc_inode,
779 .destroy_inode = rpc_destroy_inode,
780 .statfs = simple_statfs,
781};
782
783#define RPCAUTH_GSSMAGIC 0x67596969
784
785static int
786rpc_fill_super(struct super_block *sb, void *data, int silent)
787{
788 struct inode *inode;
789 struct dentry *root;
790
791 sb->s_blocksize = PAGE_CACHE_SIZE;
792 sb->s_blocksize_bits = PAGE_CACHE_SHIFT;
793 sb->s_magic = RPCAUTH_GSSMAGIC;
794 sb->s_op = &s_ops;
795 sb->s_time_gran = 1;
796
797 inode = rpc_get_inode(sb, S_IFDIR | 0755);
798 if (!inode)
799 return -ENOMEM;
800 root = d_alloc_root(inode);
801 if (!root) {
802 iput(inode);
803 return -ENOMEM;
804 }
805 if (rpc_populate(root, files, RPCAUTH_Root + 1, RPCAUTH_RootEOF))
806 goto out;
807 sb->s_root = root;
808 return 0;
809out:
810 d_genocide(root);
811 dput(root);
812 return -ENOMEM;
813}
814
815static struct super_block *
816rpc_get_sb(struct file_system_type *fs_type,
817 int flags, const char *dev_name, void *data)
818{
819 return get_sb_single(fs_type, flags, data, rpc_fill_super);
820}
821
822static struct file_system_type rpc_pipe_fs_type = {
823 .owner = THIS_MODULE,
824 .name = "rpc_pipefs",
825 .get_sb = rpc_get_sb,
826 .kill_sb = kill_litter_super,
827};
828
829static void
830init_once(void * foo, kmem_cache_t * cachep, unsigned long flags)
831{
832 struct rpc_inode *rpci = (struct rpc_inode *) foo;
833
834 if ((flags & (SLAB_CTOR_VERIFY|SLAB_CTOR_CONSTRUCTOR)) ==
835 SLAB_CTOR_CONSTRUCTOR) {
836 inode_init_once(&rpci->vfs_inode);
837 rpci->private = NULL;
838 rpci->nreaders = 0;
839 rpci->nwriters = 0;
840 INIT_LIST_HEAD(&rpci->in_upcall);
841 INIT_LIST_HEAD(&rpci->pipe);
842 rpci->pipelen = 0;
843 init_waitqueue_head(&rpci->waitq);
844 INIT_WORK(&rpci->queue_timeout, rpc_timeout_upcall_queue, rpci);
845 rpci->ops = NULL;
846 }
847}
848
849int register_rpc_pipefs(void)
850{
851 rpc_inode_cachep = kmem_cache_create("rpc_inode_cache",
852 sizeof(struct rpc_inode),
853 0, SLAB_HWCACHE_ALIGN|SLAB_RECLAIM_ACCOUNT,
854 init_once, NULL);
855 if (!rpc_inode_cachep)
856 return -ENOMEM;
857 register_filesystem(&rpc_pipe_fs_type);
858 return 0;
859}
860
861void unregister_rpc_pipefs(void)
862{
863 if (kmem_cache_destroy(rpc_inode_cachep))
864 printk(KERN_WARNING "RPC: unable to free inode cache\n");
865 unregister_filesystem(&rpc_pipe_fs_type);
866}