blob: a2f1893bde53e41137a96b3cee5de618a629c2b9 [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
Christoph Lametere18b8902006-12-06 20:33:20 -080036static struct kmem_cache *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
David Howells65f27f32006-11-22 14:55:48 +000057rpc_timeout_upcall_queue(struct work_struct *work)
Linus Torvalds1da177e2005-04-16 15:20:36 -070058{
Trond Myklebust9842ef32006-02-01 12:18:44 -050059 LIST_HEAD(free_list);
David Howells65f27f32006-11-22 14:55:48 +000060 struct rpc_inode *rpci =
61 container_of(work, struct rpc_inode, queue_timeout.work);
Linus Torvalds1da177e2005-04-16 15:20:36 -070062 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;
Christoph Lametere94b1762006-12-06 20:33:17 -0800146 rpci = (struct rpc_inode *)kmem_cache_alloc(rpc_inode_cachep, GFP_KERNEL);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700147 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{
Josef Sipek303b46b2006-12-08 02:37:42 -0800217 struct inode *inode = filp->f_path.dentry->d_inode;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700218 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{
Josef Sipek303b46b2006-12-08 02:37:42 -0800260 struct inode *inode = filp->f_path.dentry->d_inode;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700261 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
Josef Sipek303b46b2006-12-08 02:37:42 -0800278 rpci = RPC_I(filp->f_path.dentry->d_inode);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700279 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{
Josef Sipek303b46b2006-12-08 02:37:42 -0800293 struct rpc_inode *rpci = RPC_I(filp->f_path.dentry->d_inode);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700294 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
Arjan van de Venda7071d2007-02-12 00:55:36 -0800312static const struct file_operations rpc_pipe_fops = {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700313 .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);
Chuck Levere7f78652006-08-22 20:06:19 -0400331 seq_printf(m, "address: %s\n", rpc_peeraddr2str(clnt, RPC_DISPLAY_ADDR));
332 seq_printf(m, "protocol: %s\n", rpc_peeraddr2str(clnt, RPC_DISPLAY_PROTO));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700333 return 0;
334}
335
336static int
337rpc_info_open(struct inode *inode, struct file *file)
338{
339 struct rpc_clnt *clnt;
340 int ret = single_open(file, rpc_show_info, NULL);
341
342 if (!ret) {
343 struct seq_file *m = file->private_data;
Jes Sorensen1b1dcc12006-01-09 15:59:24 -0800344 mutex_lock(&inode->i_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700345 clnt = RPC_I(inode)->private;
346 if (clnt) {
347 atomic_inc(&clnt->cl_users);
348 m->private = clnt;
349 } else {
350 single_release(inode, file);
351 ret = -EINVAL;
352 }
Jes Sorensen1b1dcc12006-01-09 15:59:24 -0800353 mutex_unlock(&inode->i_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700354 }
355 return ret;
356}
357
358static int
359rpc_info_release(struct inode *inode, struct file *file)
360{
361 struct seq_file *m = file->private_data;
362 struct rpc_clnt *clnt = (struct rpc_clnt *)m->private;
363
364 if (clnt)
365 rpc_release_client(clnt);
366 return single_release(inode, file);
367}
368
Arjan van de Venda7071d2007-02-12 00:55:36 -0800369static const struct file_operations rpc_info_operations = {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700370 .owner = THIS_MODULE,
371 .open = rpc_info_open,
372 .read = seq_read,
373 .llseek = seq_lseek,
374 .release = rpc_info_release,
375};
376
377
378/*
379 * We have a single directory with 1 node in it.
380 */
381enum {
382 RPCAUTH_Root = 1,
383 RPCAUTH_lockd,
384 RPCAUTH_mount,
385 RPCAUTH_nfs,
386 RPCAUTH_portmap,
387 RPCAUTH_statd,
388 RPCAUTH_RootEOF
389};
390
391/*
392 * Description of fs contents.
393 */
394struct rpc_filelist {
395 char *name;
Arjan van de Ven99ac48f2006-03-28 01:56:41 -0800396 const struct file_operations *i_fop;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700397 int mode;
398};
399
400static struct rpc_filelist files[] = {
401 [RPCAUTH_lockd] = {
402 .name = "lockd",
403 .mode = S_IFDIR | S_IRUGO | S_IXUGO,
404 },
405 [RPCAUTH_mount] = {
406 .name = "mount",
407 .mode = S_IFDIR | S_IRUGO | S_IXUGO,
408 },
409 [RPCAUTH_nfs] = {
410 .name = "nfs",
411 .mode = S_IFDIR | S_IRUGO | S_IXUGO,
412 },
413 [RPCAUTH_portmap] = {
414 .name = "portmap",
415 .mode = S_IFDIR | S_IRUGO | S_IXUGO,
416 },
417 [RPCAUTH_statd] = {
418 .name = "statd",
419 .mode = S_IFDIR | S_IRUGO | S_IXUGO,
420 },
421};
422
423enum {
424 RPCAUTH_info = 2,
425 RPCAUTH_EOF
426};
427
428static struct rpc_filelist authfiles[] = {
429 [RPCAUTH_info] = {
430 .name = "info",
431 .i_fop = &rpc_info_operations,
432 .mode = S_IFREG | S_IRUSR,
433 },
434};
435
Trond Myklebust54281542006-03-20 13:44:49 -0500436struct vfsmount *rpc_get_mount(void)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700437{
Trond Myklebust54281542006-03-20 13:44:49 -0500438 int err;
439
Trond Myklebust1f5ce9e2006-06-09 09:34:16 -0400440 err = simple_pin_fs(&rpc_pipe_fs_type, &rpc_mount, &rpc_mount_count);
Trond Myklebust54281542006-03-20 13:44:49 -0500441 if (err != 0)
442 return ERR_PTR(err);
443 return rpc_mount;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700444}
445
Trond Myklebust54281542006-03-20 13:44:49 -0500446void rpc_put_mount(void)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700447{
448 simple_release_fs(&rpc_mount, &rpc_mount_count);
449}
450
Trond Myklebustf1345852005-09-23 11:08:25 -0400451static int
452rpc_lookup_parent(char *path, struct nameidata *nd)
453{
454 if (path[0] == '\0')
455 return -ENOENT;
Trond Myklebust54281542006-03-20 13:44:49 -0500456 nd->mnt = rpc_get_mount();
457 if (IS_ERR(nd->mnt)) {
Trond Myklebustf1345852005-09-23 11:08:25 -0400458 printk(KERN_WARNING "%s: %s failed to mount "
459 "pseudofilesystem \n", __FILE__, __FUNCTION__);
Trond Myklebust54281542006-03-20 13:44:49 -0500460 return PTR_ERR(nd->mnt);
Trond Myklebustf1345852005-09-23 11:08:25 -0400461 }
Trond Myklebust54281542006-03-20 13:44:49 -0500462 mntget(nd->mnt);
Trond Myklebustf1345852005-09-23 11:08:25 -0400463 nd->dentry = dget(rpc_mount->mnt_root);
464 nd->last_type = LAST_ROOT;
465 nd->flags = LOOKUP_PARENT;
466 nd->depth = 0;
467
468 if (path_walk(path, nd)) {
469 printk(KERN_WARNING "%s: %s failed to find path %s\n",
470 __FILE__, __FUNCTION__, path);
471 rpc_put_mount();
472 return -ENOENT;
473 }
474 return 0;
475}
476
477static void
478rpc_release_path(struct nameidata *nd)
479{
480 path_release(nd);
481 rpc_put_mount();
482}
483
Linus Torvalds1da177e2005-04-16 15:20:36 -0700484static struct inode *
485rpc_get_inode(struct super_block *sb, int mode)
486{
487 struct inode *inode = new_inode(sb);
488 if (!inode)
489 return NULL;
490 inode->i_mode = mode;
491 inode->i_uid = inode->i_gid = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700492 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;
Dave Hansend8c76e62006-09-30 23:29:04 -0700498 inc_nlink(inode);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700499 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))
Dave Hansend8c76e62006-09-30 23:29:04 -0700575 inc_nlink(dir);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700576 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
Trond Myklebust1d216322007-02-02 15:56:06 -0800592 inode = rpc_get_inode(dir->i_sb, S_IFDIR | S_IRUGO | S_IXUGO);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700593 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);
Dave Hansend8c76e62006-09-30 23:29:04 -0700597 inc_nlink(dir);
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;
Steve Dicksona53a3c52006-09-06 11:51:21 -0400723 inode = rpc_get_inode(dir->i_sb, S_IFIFO | S_IRUSR | S_IWUSR);
Trond Myklebustf1345852005-09-23 11:08:25 -0400724 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
Christoph Lametere18b8902006-12-06 20:33:20 -0800827init_once(void * foo, struct kmem_cache * cachep, unsigned long flags)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700828{
829 struct rpc_inode *rpci = (struct rpc_inode *) foo;
830
Christoph Lameter50953fe2007-05-06 14:50:16 -0700831 if (flags & SLAB_CTOR_CONSTRUCTOR) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700832 inode_init_once(&rpci->vfs_inode);
833 rpci->private = NULL;
834 rpci->nreaders = 0;
835 rpci->nwriters = 0;
836 INIT_LIST_HEAD(&rpci->in_upcall);
837 INIT_LIST_HEAD(&rpci->pipe);
838 rpci->pipelen = 0;
839 init_waitqueue_head(&rpci->waitq);
David Howells52bad642006-11-22 14:54:01 +0000840 INIT_DELAYED_WORK(&rpci->queue_timeout,
David Howells65f27f32006-11-22 14:55:48 +0000841 rpc_timeout_upcall_queue);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700842 rpci->ops = NULL;
843 }
844}
845
846int register_rpc_pipefs(void)
847{
Akinobu Mita5bd5f582007-05-09 02:34:51 -0700848 int err;
849
Linus Torvalds1da177e2005-04-16 15:20:36 -0700850 rpc_inode_cachep = kmem_cache_create("rpc_inode_cache",
Paul Jacksonfffb60f2006-03-24 03:16:06 -0800851 sizeof(struct rpc_inode),
852 0, (SLAB_HWCACHE_ALIGN|SLAB_RECLAIM_ACCOUNT|
853 SLAB_MEM_SPREAD),
854 init_once, NULL);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700855 if (!rpc_inode_cachep)
856 return -ENOMEM;
Akinobu Mita5bd5f582007-05-09 02:34:51 -0700857 err = register_filesystem(&rpc_pipe_fs_type);
858 if (err) {
859 kmem_cache_destroy(rpc_inode_cachep);
860 return err;
861 }
862
Linus Torvalds1da177e2005-04-16 15:20:36 -0700863 return 0;
864}
865
866void unregister_rpc_pipefs(void)
867{
Alexey Dobriyan1a1d92c2006-09-27 01:49:40 -0700868 kmem_cache_destroy(rpc_inode_cachep);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700869 unregister_filesystem(&rpc_pipe_fs_type);
870}