blob: c59f3ca2b41b02627a017354f35e319366571633 [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>
Trond Myklebust50e437d2007-06-07 22:44:34 -040017#include <linux/fsnotify.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070018#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);
Trond Myklebust4011cd92007-08-07 15:33:01 -0400135 cancel_delayed_work_sync(&rpci->queue_timeout);
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;
Christoph Lametere94b1762006-12-06 20:33:17 -0800145 rpci = (struct rpc_inode *)kmem_cache_alloc(rpc_inode_cachep, GFP_KERNEL);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700146 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{
Josef Sipek303b46b2006-12-08 02:37:42 -0800216 struct inode *inode = filp->f_path.dentry->d_inode;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700217 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{
Josef Sipek303b46b2006-12-08 02:37:42 -0800259 struct inode *inode = filp->f_path.dentry->d_inode;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700260 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
Josef Sipek303b46b2006-12-08 02:37:42 -0800277 rpci = RPC_I(filp->f_path.dentry->d_inode);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700278 poll_wait(filp, &rpci->waitq, wait);
279
280 mask = POLLOUT | POLLWRNORM;
281 if (rpci->ops == NULL)
282 mask |= POLLERR | POLLHUP;
J. Bruce Fieldseda4f9b2007-11-06 13:05:36 -0500283 if (filp->private_data || !list_empty(&rpci->pipe))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700284 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{
Josef Sipek303b46b2006-12-08 02:37:42 -0800292 struct rpc_inode *rpci = RPC_I(filp->f_path.dentry->d_inode);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700293 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
Arjan van de Venda7071d2007-02-12 00:55:36 -0800311static const struct file_operations rpc_pipe_fops = {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700312 .owner = THIS_MODULE,
313 .llseek = no_llseek,
314 .read = rpc_pipe_read,
315 .write = rpc_pipe_write,
316 .poll = rpc_pipe_poll,
317 .ioctl = rpc_pipe_ioctl,
318 .open = rpc_pipe_open,
319 .release = rpc_pipe_release,
320};
321
322static int
323rpc_show_info(struct seq_file *m, void *v)
324{
325 struct rpc_clnt *clnt = m->private;
326
327 seq_printf(m, "RPC server: %s\n", clnt->cl_server);
328 seq_printf(m, "service: %s (%d) version %d\n", clnt->cl_protname,
329 clnt->cl_prog, clnt->cl_vers);
Chuck Levere7f78652006-08-22 20:06:19 -0400330 seq_printf(m, "address: %s\n", rpc_peeraddr2str(clnt, RPC_DISPLAY_ADDR));
331 seq_printf(m, "protocol: %s\n", rpc_peeraddr2str(clnt, RPC_DISPLAY_PROTO));
J. Bruce Fieldsbf19aac2007-09-26 14:38:09 -0400332 seq_printf(m, "port: %s\n", rpc_peeraddr2str(clnt, RPC_DISPLAY_PORT));
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) {
Trond Myklebust34f52e32007-06-14 16:40:31 -0400347 kref_get(&clnt->cl_kref);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700348 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 Myklebust62e17612007-06-08 14:14:46 -0400451static int rpc_delete_dentry(struct dentry *dentry)
452{
453 return 1;
454}
455
456static struct dentry_operations rpc_dentry_operations = {
457 .d_delete = rpc_delete_dentry,
458};
459
Trond Myklebustf1345852005-09-23 11:08:25 -0400460static int
461rpc_lookup_parent(char *path, struct nameidata *nd)
462{
Josef 'Jeff' Sipek4ac4efc2007-07-19 01:48:20 -0700463 struct vfsmount *mnt;
464
Trond Myklebustf1345852005-09-23 11:08:25 -0400465 if (path[0] == '\0')
466 return -ENOENT;
Josef 'Jeff' Sipek4ac4efc2007-07-19 01:48:20 -0700467
468 mnt = rpc_get_mount();
469 if (IS_ERR(mnt)) {
Trond Myklebustf1345852005-09-23 11:08:25 -0400470 printk(KERN_WARNING "%s: %s failed to mount "
471 "pseudofilesystem \n", __FILE__, __FUNCTION__);
Josef 'Jeff' Sipek4ac4efc2007-07-19 01:48:20 -0700472 return PTR_ERR(mnt);
Trond Myklebustf1345852005-09-23 11:08:25 -0400473 }
Trond Myklebustf1345852005-09-23 11:08:25 -0400474
Josef 'Jeff' Sipek4ac4efc2007-07-19 01:48:20 -0700475 if (vfs_path_lookup(mnt->mnt_root, mnt, path, LOOKUP_PARENT, nd)) {
Trond Myklebustf1345852005-09-23 11:08:25 -0400476 printk(KERN_WARNING "%s: %s failed to find path %s\n",
477 __FILE__, __FUNCTION__, path);
478 rpc_put_mount();
479 return -ENOENT;
480 }
481 return 0;
482}
483
484static void
485rpc_release_path(struct nameidata *nd)
486{
487 path_release(nd);
488 rpc_put_mount();
489}
490
Linus Torvalds1da177e2005-04-16 15:20:36 -0700491static struct inode *
492rpc_get_inode(struct super_block *sb, int mode)
493{
494 struct inode *inode = new_inode(sb);
495 if (!inode)
496 return NULL;
497 inode->i_mode = mode;
498 inode->i_uid = inode->i_gid = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700499 inode->i_blocks = 0;
500 inode->i_atime = inode->i_mtime = inode->i_ctime = CURRENT_TIME;
501 switch(mode & S_IFMT) {
502 case S_IFDIR:
503 inode->i_fop = &simple_dir_operations;
504 inode->i_op = &simple_dir_inode_operations;
Dave Hansend8c76e62006-09-30 23:29:04 -0700505 inc_nlink(inode);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700506 default:
507 break;
508 }
509 return inode;
510}
511
512/*
513 * FIXME: This probably has races.
514 */
515static void
Trond Myklebust62e17612007-06-08 14:14:46 -0400516rpc_depopulate(struct dentry *parent, int start, int eof)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700517{
518 struct inode *dir = parent->d_inode;
519 struct list_head *pos, *next;
520 struct dentry *dentry, *dvec[10];
521 int n = 0;
522
Arjan van de Venc6573c22006-07-03 00:25:16 -0700523 mutex_lock_nested(&dir->i_mutex, I_MUTEX_CHILD);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700524repeat:
525 spin_lock(&dcache_lock);
526 list_for_each_safe(pos, next, &parent->d_subdirs) {
Eric Dumazet5160ee62006-01-08 01:03:32 -0800527 dentry = list_entry(pos, struct dentry, d_u.d_child);
Trond Myklebust62e17612007-06-08 14:14:46 -0400528 if (!dentry->d_inode ||
529 dentry->d_inode->i_ino < start ||
530 dentry->d_inode->i_ino >= eof)
531 continue;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700532 spin_lock(&dentry->d_lock);
533 if (!d_unhashed(dentry)) {
534 dget_locked(dentry);
535 __d_drop(dentry);
536 spin_unlock(&dentry->d_lock);
537 dvec[n++] = dentry;
538 if (n == ARRAY_SIZE(dvec))
539 break;
540 } else
541 spin_unlock(&dentry->d_lock);
542 }
543 spin_unlock(&dcache_lock);
544 if (n) {
545 do {
546 dentry = dvec[--n];
Trond Myklebust62e17612007-06-08 14:14:46 -0400547 if (S_ISREG(dentry->d_inode->i_mode))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700548 simple_unlink(dir, dentry);
Trond Myklebust62e17612007-06-08 14:14:46 -0400549 else if (S_ISDIR(dentry->d_inode->i_mode))
550 simple_rmdir(dir, dentry);
551 d_delete(dentry);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700552 dput(dentry);
553 } while (n);
554 goto repeat;
555 }
Jes Sorensen1b1dcc12006-01-09 15:59:24 -0800556 mutex_unlock(&dir->i_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700557}
558
559static int
560rpc_populate(struct dentry *parent,
561 struct rpc_filelist *files,
562 int start, int eof)
563{
564 struct inode *inode, *dir = parent->d_inode;
565 void *private = RPC_I(dir)->private;
566 struct dentry *dentry;
567 int mode, i;
568
Jes Sorensen1b1dcc12006-01-09 15:59:24 -0800569 mutex_lock(&dir->i_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700570 for (i = start; i < eof; i++) {
571 dentry = d_alloc_name(parent, files[i].name);
572 if (!dentry)
573 goto out_bad;
Trond Myklebust62e17612007-06-08 14:14:46 -0400574 dentry->d_op = &rpc_dentry_operations;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700575 mode = files[i].mode;
576 inode = rpc_get_inode(dir->i_sb, mode);
577 if (!inode) {
578 dput(dentry);
579 goto out_bad;
580 }
581 inode->i_ino = i;
582 if (files[i].i_fop)
583 inode->i_fop = files[i].i_fop;
584 if (private)
585 rpc_inode_setowner(inode, private);
586 if (S_ISDIR(mode))
Dave Hansend8c76e62006-09-30 23:29:04 -0700587 inc_nlink(dir);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700588 d_add(dentry, inode);
Trond Myklebust50e437d2007-06-07 22:44:34 -0400589 fsnotify_create(dir, dentry);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700590 }
Jes Sorensen1b1dcc12006-01-09 15:59:24 -0800591 mutex_unlock(&dir->i_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700592 return 0;
593out_bad:
Jes Sorensen1b1dcc12006-01-09 15:59:24 -0800594 mutex_unlock(&dir->i_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700595 printk(KERN_WARNING "%s: %s failed to populate directory %s\n",
596 __FILE__, __FUNCTION__, parent->d_name.name);
597 return -ENOMEM;
598}
599
Trond Myklebustf1345852005-09-23 11:08:25 -0400600static int
601__rpc_mkdir(struct inode *dir, struct dentry *dentry)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700602{
603 struct inode *inode;
604
Trond Myklebust1d216322007-02-02 15:56:06 -0800605 inode = rpc_get_inode(dir->i_sb, S_IFDIR | S_IRUGO | S_IXUGO);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700606 if (!inode)
Trond Myklebustf1345852005-09-23 11:08:25 -0400607 goto out_err;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700608 inode->i_ino = iunique(dir->i_sb, 100);
Christoph Hellwig278c9952005-07-24 23:53:01 +0100609 d_instantiate(dentry, inode);
Dave Hansend8c76e62006-09-30 23:29:04 -0700610 inc_nlink(dir);
Trond Myklebust50e437d2007-06-07 22:44:34 -0400611 fsnotify_mkdir(dir, dentry);
Trond Myklebustf1345852005-09-23 11:08:25 -0400612 return 0;
613out_err:
614 printk(KERN_WARNING "%s: %s failed to allocate inode for dentry %s\n",
615 __FILE__, __FUNCTION__, dentry->d_name.name);
616 return -ENOMEM;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700617}
618
Trond Myklebustf1345852005-09-23 11:08:25 -0400619static int
620__rpc_rmdir(struct inode *dir, struct dentry *dentry)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700621{
Trond Myklebustf1345852005-09-23 11:08:25 -0400622 int error;
Trond Myklebust62e17612007-06-08 14:14:46 -0400623 error = simple_rmdir(dir, dentry);
624 if (!error)
625 d_delete(dentry);
626 return error;
Trond Myklebustf1345852005-09-23 11:08:25 -0400627}
Christoph Hellwig278c9952005-07-24 23:53:01 +0100628
Trond Myklebustf1345852005-09-23 11:08:25 -0400629static struct dentry *
Trond Myklebust34f30892007-06-07 18:28:02 -0400630rpc_lookup_create(struct dentry *parent, const char *name, int len, int exclusive)
Trond Myklebustf1345852005-09-23 11:08:25 -0400631{
Trond Myklebust158998b2006-08-24 01:03:17 -0400632 struct inode *dir = parent->d_inode;
Trond Myklebustf1345852005-09-23 11:08:25 -0400633 struct dentry *dentry;
Trond Myklebustf1345852005-09-23 11:08:25 -0400634
Arjan van de Venc6573c22006-07-03 00:25:16 -0700635 mutex_lock_nested(&dir->i_mutex, I_MUTEX_PARENT);
Trond Myklebust158998b2006-08-24 01:03:17 -0400636 dentry = lookup_one_len(name, parent, len);
Trond Myklebustf1345852005-09-23 11:08:25 -0400637 if (IS_ERR(dentry))
638 goto out_err;
Trond Myklebust62e17612007-06-08 14:14:46 -0400639 if (!dentry->d_inode)
640 dentry->d_op = &rpc_dentry_operations;
641 else if (exclusive) {
Trond Myklebustf1345852005-09-23 11:08:25 -0400642 dput(dentry);
643 dentry = ERR_PTR(-EEXIST);
644 goto out_err;
645 }
646 return dentry;
647out_err:
Jes Sorensen1b1dcc12006-01-09 15:59:24 -0800648 mutex_unlock(&dir->i_mutex);
Trond Myklebust158998b2006-08-24 01:03:17 -0400649 return dentry;
650}
651
652static struct dentry *
653rpc_lookup_negative(char *path, struct nameidata *nd)
654{
655 struct dentry *dentry;
656 int error;
657
658 if ((error = rpc_lookup_parent(path, nd)) != 0)
659 return ERR_PTR(error);
Trond Myklebust34f30892007-06-07 18:28:02 -0400660 dentry = rpc_lookup_create(nd->dentry, nd->last.name, nd->last.len, 1);
Trond Myklebust158998b2006-08-24 01:03:17 -0400661 if (IS_ERR(dentry))
662 rpc_release_path(nd);
Trond Myklebustf1345852005-09-23 11:08:25 -0400663 return dentry;
664}
665
666
667struct dentry *
668rpc_mkdir(char *path, struct rpc_clnt *rpc_client)
669{
670 struct nameidata nd;
671 struct dentry *dentry;
672 struct inode *dir;
673 int error;
674
675 dentry = rpc_lookup_negative(path, &nd);
676 if (IS_ERR(dentry))
677 return dentry;
678 dir = nd.dentry->d_inode;
679 if ((error = __rpc_mkdir(dir, dentry)) != 0)
680 goto err_dput;
681 RPC_I(dentry->d_inode)->private = rpc_client;
682 error = rpc_populate(dentry, authfiles,
683 RPCAUTH_info, RPCAUTH_EOF);
684 if (error)
685 goto err_depopulate;
Trond Myklebust5c3e9852006-07-29 17:37:40 -0400686 dget(dentry);
Trond Myklebustf1345852005-09-23 11:08:25 -0400687out:
Jes Sorensen1b1dcc12006-01-09 15:59:24 -0800688 mutex_unlock(&dir->i_mutex);
Trond Myklebustf1345852005-09-23 11:08:25 -0400689 rpc_release_path(&nd);
Trond Myklebust5c3e9852006-07-29 17:37:40 -0400690 return dentry;
Trond Myklebustf1345852005-09-23 11:08:25 -0400691err_depopulate:
Trond Myklebust62e17612007-06-08 14:14:46 -0400692 rpc_depopulate(dentry, RPCAUTH_info, RPCAUTH_EOF);
Trond Myklebustf1345852005-09-23 11:08:25 -0400693 __rpc_rmdir(dir, dentry);
694err_dput:
695 dput(dentry);
696 printk(KERN_WARNING "%s: %s() failed to create directory %s (errno = %d)\n",
697 __FILE__, __FUNCTION__, path, error);
698 dentry = ERR_PTR(error);
699 goto out;
700}
701
702int
Trond Myklebustdff02cc2006-07-31 14:17:18 -0700703rpc_rmdir(struct dentry *dentry)
Trond Myklebustf1345852005-09-23 11:08:25 -0400704{
Trond Myklebustdff02cc2006-07-31 14:17:18 -0700705 struct dentry *parent;
Trond Myklebustf1345852005-09-23 11:08:25 -0400706 struct inode *dir;
707 int error;
708
Trond Myklebustdff02cc2006-07-31 14:17:18 -0700709 parent = dget_parent(dentry);
710 dir = parent->d_inode;
Arjan van de Venc6573c22006-07-03 00:25:16 -0700711 mutex_lock_nested(&dir->i_mutex, I_MUTEX_PARENT);
Trond Myklebust62e17612007-06-08 14:14:46 -0400712 rpc_depopulate(dentry, RPCAUTH_info, RPCAUTH_EOF);
Trond Myklebustf1345852005-09-23 11:08:25 -0400713 error = __rpc_rmdir(dir, dentry);
714 dput(dentry);
Jes Sorensen1b1dcc12006-01-09 15:59:24 -0800715 mutex_unlock(&dir->i_mutex);
Trond Myklebustdff02cc2006-07-31 14:17:18 -0700716 dput(parent);
Trond Myklebustf1345852005-09-23 11:08:25 -0400717 return error;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700718}
719
720struct dentry *
Trond Myklebust158998b2006-08-24 01:03:17 -0400721rpc_mkpipe(struct dentry *parent, const char *name, void *private, struct rpc_pipe_ops *ops, int flags)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700722{
Linus Torvalds1da177e2005-04-16 15:20:36 -0700723 struct dentry *dentry;
Trond Myklebustf1345852005-09-23 11:08:25 -0400724 struct inode *dir, *inode;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700725 struct rpc_inode *rpci;
726
Trond Myklebust34f30892007-06-07 18:28:02 -0400727 dentry = rpc_lookup_create(parent, name, strlen(name), 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700728 if (IS_ERR(dentry))
Trond Myklebustf1345852005-09-23 11:08:25 -0400729 return dentry;
Trond Myklebust158998b2006-08-24 01:03:17 -0400730 dir = parent->d_inode;
Trond Myklebust34f30892007-06-07 18:28:02 -0400731 if (dentry->d_inode) {
732 rpci = RPC_I(dentry->d_inode);
733 if (rpci->private != private ||
734 rpci->ops != ops ||
735 rpci->flags != flags) {
736 dput (dentry);
737 dentry = ERR_PTR(-EBUSY);
738 }
Trond Myklebust03a12562007-06-08 14:14:53 -0400739 rpci->nkern_readwriters++;
Trond Myklebust34f30892007-06-07 18:28:02 -0400740 goto out;
741 }
Steve Dicksona53a3c52006-09-06 11:51:21 -0400742 inode = rpc_get_inode(dir->i_sb, S_IFIFO | S_IRUSR | S_IWUSR);
Trond Myklebustf1345852005-09-23 11:08:25 -0400743 if (!inode)
744 goto err_dput;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700745 inode->i_ino = iunique(dir->i_sb, 100);
746 inode->i_fop = &rpc_pipe_fops;
Trond Myklebustf1345852005-09-23 11:08:25 -0400747 d_instantiate(dentry, inode);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700748 rpci = RPC_I(inode);
749 rpci->private = private;
750 rpci->flags = flags;
751 rpci->ops = ops;
Trond Myklebust03a12562007-06-08 14:14:53 -0400752 rpci->nkern_readwriters = 1;
Trond Myklebust50e437d2007-06-07 22:44:34 -0400753 fsnotify_create(dir, dentry);
Trond Myklebust5c3e9852006-07-29 17:37:40 -0400754 dget(dentry);
Trond Myklebustf1345852005-09-23 11:08:25 -0400755out:
Jes Sorensen1b1dcc12006-01-09 15:59:24 -0800756 mutex_unlock(&dir->i_mutex);
Trond Myklebust5c3e9852006-07-29 17:37:40 -0400757 return dentry;
Trond Myklebustf1345852005-09-23 11:08:25 -0400758err_dput:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700759 dput(dentry);
Trond Myklebustf1345852005-09-23 11:08:25 -0400760 dentry = ERR_PTR(-ENOMEM);
Trond Myklebust158998b2006-08-24 01:03:17 -0400761 printk(KERN_WARNING "%s: %s() failed to create pipe %s/%s (errno = %d)\n",
762 __FILE__, __FUNCTION__, parent->d_name.name, name,
763 -ENOMEM);
Trond Myklebustf1345852005-09-23 11:08:25 -0400764 goto out;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700765}
766
Trond Myklebustf1345852005-09-23 11:08:25 -0400767int
Trond Myklebust5d674762006-07-31 14:11:48 -0700768rpc_unlink(struct dentry *dentry)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700769{
Trond Myklebust5d674762006-07-31 14:11:48 -0700770 struct dentry *parent;
Trond Myklebustf1345852005-09-23 11:08:25 -0400771 struct inode *dir;
Trond Myklebust5d674762006-07-31 14:11:48 -0700772 int error = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700773
Trond Myklebust5d674762006-07-31 14:11:48 -0700774 parent = dget_parent(dentry);
775 dir = parent->d_inode;
Arjan van de Venc6573c22006-07-03 00:25:16 -0700776 mutex_lock_nested(&dir->i_mutex, I_MUTEX_PARENT);
Trond Myklebust03a12562007-06-08 14:14:53 -0400777 if (--RPC_I(dentry->d_inode)->nkern_readwriters == 0) {
778 rpc_close_pipes(dentry->d_inode);
779 error = simple_unlink(dir, dentry);
780 if (!error)
781 d_delete(dentry);
782 }
Trond Myklebustf1345852005-09-23 11:08:25 -0400783 dput(dentry);
Jes Sorensen1b1dcc12006-01-09 15:59:24 -0800784 mutex_unlock(&dir->i_mutex);
Trond Myklebust5d674762006-07-31 14:11:48 -0700785 dput(parent);
Trond Myklebustf1345852005-09-23 11:08:25 -0400786 return error;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700787}
788
789/*
790 * populate the filesystem
791 */
792static struct super_operations s_ops = {
793 .alloc_inode = rpc_alloc_inode,
794 .destroy_inode = rpc_destroy_inode,
795 .statfs = simple_statfs,
796};
797
798#define RPCAUTH_GSSMAGIC 0x67596969
799
800static int
801rpc_fill_super(struct super_block *sb, void *data, int silent)
802{
803 struct inode *inode;
804 struct dentry *root;
805
806 sb->s_blocksize = PAGE_CACHE_SIZE;
807 sb->s_blocksize_bits = PAGE_CACHE_SHIFT;
808 sb->s_magic = RPCAUTH_GSSMAGIC;
809 sb->s_op = &s_ops;
810 sb->s_time_gran = 1;
811
812 inode = rpc_get_inode(sb, S_IFDIR | 0755);
813 if (!inode)
814 return -ENOMEM;
815 root = d_alloc_root(inode);
816 if (!root) {
817 iput(inode);
818 return -ENOMEM;
819 }
820 if (rpc_populate(root, files, RPCAUTH_Root + 1, RPCAUTH_RootEOF))
821 goto out;
822 sb->s_root = root;
823 return 0;
824out:
825 d_genocide(root);
826 dput(root);
827 return -ENOMEM;
828}
829
David Howells454e2392006-06-23 02:02:57 -0700830static int
Linus Torvalds1da177e2005-04-16 15:20:36 -0700831rpc_get_sb(struct file_system_type *fs_type,
David Howells454e2392006-06-23 02:02:57 -0700832 int flags, const char *dev_name, void *data, struct vfsmount *mnt)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700833{
David Howells454e2392006-06-23 02:02:57 -0700834 return get_sb_single(fs_type, flags, data, rpc_fill_super, mnt);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700835}
836
837static struct file_system_type rpc_pipe_fs_type = {
838 .owner = THIS_MODULE,
839 .name = "rpc_pipefs",
840 .get_sb = rpc_get_sb,
841 .kill_sb = kill_litter_super,
842};
843
844static void
Christoph Lameter4ba9b9d2007-10-16 23:25:51 -0700845init_once(struct kmem_cache * cachep, void *foo)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700846{
847 struct rpc_inode *rpci = (struct rpc_inode *) foo;
848
Christoph Lametera35afb82007-05-16 22:10:57 -0700849 inode_init_once(&rpci->vfs_inode);
850 rpci->private = NULL;
851 rpci->nreaders = 0;
852 rpci->nwriters = 0;
853 INIT_LIST_HEAD(&rpci->in_upcall);
Trond Myklebust6e84c7b2007-06-07 15:31:36 -0400854 INIT_LIST_HEAD(&rpci->in_downcall);
Christoph Lametera35afb82007-05-16 22:10:57 -0700855 INIT_LIST_HEAD(&rpci->pipe);
856 rpci->pipelen = 0;
857 init_waitqueue_head(&rpci->waitq);
858 INIT_DELAYED_WORK(&rpci->queue_timeout,
859 rpc_timeout_upcall_queue);
860 rpci->ops = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700861}
862
863int register_rpc_pipefs(void)
864{
Akinobu Mita5bd5f582007-05-09 02:34:51 -0700865 int err;
866
Linus Torvalds1da177e2005-04-16 15:20:36 -0700867 rpc_inode_cachep = kmem_cache_create("rpc_inode_cache",
Paul Jacksonfffb60f2006-03-24 03:16:06 -0800868 sizeof(struct rpc_inode),
869 0, (SLAB_HWCACHE_ALIGN|SLAB_RECLAIM_ACCOUNT|
870 SLAB_MEM_SPREAD),
Paul Mundt20c2df82007-07-20 10:11:58 +0900871 init_once);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700872 if (!rpc_inode_cachep)
873 return -ENOMEM;
Akinobu Mita5bd5f582007-05-09 02:34:51 -0700874 err = register_filesystem(&rpc_pipe_fs_type);
875 if (err) {
876 kmem_cache_destroy(rpc_inode_cachep);
877 return err;
878 }
879
Linus Torvalds1da177e2005-04-16 15:20:36 -0700880 return 0;
881}
882
883void unregister_rpc_pipefs(void)
884{
Alexey Dobriyan1a1d92c2006-09-27 01:49:40 -0700885 kmem_cache_destroy(rpc_inode_cachep);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700886 unregister_filesystem(&rpc_pipe_fs_type);
887}