blob: 3105efbb182d463eed47a03f4771820bd889c3ed [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
J. Bruce Fields93a44a72007-11-06 13:06:03 -050079/**
80 * rpc_queue_upcall
81 * @inode: inode of upcall pipe on which to queue given message
82 * @msg: message to queue
83 *
84 * Call with an @inode created by rpc_mkpipe() to queue an upcall.
85 * A userspace process may then later read the upcall by performing a
86 * read on an open file for this inode. It is up to the caller to
87 * initialize the fields of @msg (other than @msg->list) appropriately.
88 */
Linus Torvalds1da177e2005-04-16 15:20:36 -070089int
90rpc_queue_upcall(struct inode *inode, struct rpc_pipe_msg *msg)
91{
92 struct rpc_inode *rpci = RPC_I(inode);
Trond Myklebust6070fe62005-10-27 22:12:46 -040093 int res = -EPIPE;
Linus Torvalds1da177e2005-04-16 15:20:36 -070094
Trond Myklebust9842ef32006-02-01 12:18:44 -050095 spin_lock(&inode->i_lock);
Trond Myklebust6070fe62005-10-27 22:12:46 -040096 if (rpci->ops == NULL)
97 goto out;
Linus Torvalds1da177e2005-04-16 15:20:36 -070098 if (rpci->nreaders) {
99 list_add_tail(&msg->list, &rpci->pipe);
100 rpci->pipelen += msg->len;
Trond Myklebust6070fe62005-10-27 22:12:46 -0400101 res = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700102 } else if (rpci->flags & RPC_PIPE_WAIT_FOR_OPEN) {
103 if (list_empty(&rpci->pipe))
Trond Myklebust24c5d9d2006-03-20 13:44:08 -0500104 queue_delayed_work(rpciod_workqueue,
105 &rpci->queue_timeout,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700106 RPC_UPCALL_TIMEOUT);
107 list_add_tail(&msg->list, &rpci->pipe);
108 rpci->pipelen += msg->len;
Trond Myklebust6070fe62005-10-27 22:12:46 -0400109 res = 0;
110 }
111out:
Trond Myklebust9842ef32006-02-01 12:18:44 -0500112 spin_unlock(&inode->i_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700113 wake_up(&rpci->waitq);
114 return res;
115}
Trond Myklebust468039e2008-12-23 15:21:31 -0500116EXPORT_SYMBOL_GPL(rpc_queue_upcall);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700117
Trond Myklebust6070fe62005-10-27 22:12:46 -0400118static inline void
119rpc_inode_setowner(struct inode *inode, void *private)
120{
121 RPC_I(inode)->private = private;
122}
123
Linus Torvalds1da177e2005-04-16 15:20:36 -0700124static void
125rpc_close_pipes(struct inode *inode)
126{
127 struct rpc_inode *rpci = RPC_I(inode);
Trond Myklebust9842ef32006-02-01 12:18:44 -0500128 struct rpc_pipe_ops *ops;
\"J. Bruce Fields\e7128042008-12-23 16:09:47 -0500129 int need_release;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700130
Jes Sorensen1b1dcc12006-01-09 15:59:24 -0800131 mutex_lock(&inode->i_mutex);
Trond Myklebust9842ef32006-02-01 12:18:44 -0500132 ops = rpci->ops;
133 if (ops != NULL) {
134 LIST_HEAD(free_list);
Trond Myklebust9842ef32006-02-01 12:18:44 -0500135 spin_lock(&inode->i_lock);
\"J. Bruce Fields\e7128042008-12-23 16:09:47 -0500136 need_release = rpci->nreaders != 0 || rpci->nwriters != 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700137 rpci->nreaders = 0;
Trond Myklebust9842ef32006-02-01 12:18:44 -0500138 list_splice_init(&rpci->in_upcall, &free_list);
139 list_splice_init(&rpci->pipe, &free_list);
140 rpci->pipelen = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700141 rpci->ops = NULL;
Trond Myklebust9842ef32006-02-01 12:18:44 -0500142 spin_unlock(&inode->i_lock);
143 rpc_purge_list(rpci, &free_list, ops->destroy_msg, -EPIPE);
144 rpci->nwriters = 0;
\"J. Bruce Fields\e7128042008-12-23 16:09:47 -0500145 if (need_release && ops->release_pipe)
Trond Myklebust9842ef32006-02-01 12:18:44 -0500146 ops->release_pipe(inode);
Trond Myklebust4011cd92007-08-07 15:33:01 -0400147 cancel_delayed_work_sync(&rpci->queue_timeout);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700148 }
Trond Myklebust6070fe62005-10-27 22:12:46 -0400149 rpc_inode_setowner(inode, NULL);
Jes Sorensen1b1dcc12006-01-09 15:59:24 -0800150 mutex_unlock(&inode->i_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700151}
152
Linus Torvalds1da177e2005-04-16 15:20:36 -0700153static struct inode *
154rpc_alloc_inode(struct super_block *sb)
155{
156 struct rpc_inode *rpci;
Christoph Lametere94b1762006-12-06 20:33:17 -0800157 rpci = (struct rpc_inode *)kmem_cache_alloc(rpc_inode_cachep, GFP_KERNEL);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700158 if (!rpci)
159 return NULL;
160 return &rpci->vfs_inode;
161}
162
163static void
164rpc_destroy_inode(struct inode *inode)
165{
166 kmem_cache_free(rpc_inode_cachep, RPC_I(inode));
167}
168
169static int
170rpc_pipe_open(struct inode *inode, struct file *filp)
171{
172 struct rpc_inode *rpci = RPC_I(inode);
\"J. Bruce Fields\c3810602008-12-23 16:08:32 -0500173 int first_open;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700174 int res = -ENXIO;
175
Jes Sorensen1b1dcc12006-01-09 15:59:24 -0800176 mutex_lock(&inode->i_mutex);
\"J. Bruce Fields\c3810602008-12-23 16:08:32 -0500177 if (rpci->ops == NULL)
178 goto out;
179 first_open = rpci->nreaders == 0 && rpci->nwriters == 0;
180 if (first_open && rpci->ops->open_pipe) {
181 res = rpci->ops->open_pipe(inode);
182 if (res)
183 goto out;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700184 }
\"J. Bruce Fields\c3810602008-12-23 16:08:32 -0500185 if (filp->f_mode & FMODE_READ)
186 rpci->nreaders++;
187 if (filp->f_mode & FMODE_WRITE)
188 rpci->nwriters++;
189 res = 0;
190out:
Jes Sorensen1b1dcc12006-01-09 15:59:24 -0800191 mutex_unlock(&inode->i_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700192 return res;
193}
194
195static int
196rpc_pipe_release(struct inode *inode, struct file *filp)
197{
Trond Myklebust969b7f22006-01-03 09:55:36 +0100198 struct rpc_inode *rpci = RPC_I(inode);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700199 struct rpc_pipe_msg *msg;
\"J. Bruce Fields\e7128042008-12-23 16:09:47 -0500200 int last_close;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700201
Jes Sorensen1b1dcc12006-01-09 15:59:24 -0800202 mutex_lock(&inode->i_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700203 if (rpci->ops == NULL)
204 goto out;
205 msg = (struct rpc_pipe_msg *)filp->private_data;
206 if (msg != NULL) {
Trond Myklebust9842ef32006-02-01 12:18:44 -0500207 spin_lock(&inode->i_lock);
Trond Myklebust48e49182005-12-19 17:11:22 -0500208 msg->errno = -EAGAIN;
Trond Myklebust9842ef32006-02-01 12:18:44 -0500209 list_del(&msg->list);
210 spin_unlock(&inode->i_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700211 rpci->ops->destroy_msg(msg);
212 }
213 if (filp->f_mode & FMODE_WRITE)
214 rpci->nwriters --;
Trond Myklebust9842ef32006-02-01 12:18:44 -0500215 if (filp->f_mode & FMODE_READ) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700216 rpci->nreaders --;
Trond Myklebust9842ef32006-02-01 12:18:44 -0500217 if (rpci->nreaders == 0) {
218 LIST_HEAD(free_list);
219 spin_lock(&inode->i_lock);
220 list_splice_init(&rpci->pipe, &free_list);
221 rpci->pipelen = 0;
222 spin_unlock(&inode->i_lock);
223 rpc_purge_list(rpci, &free_list,
224 rpci->ops->destroy_msg, -EAGAIN);
225 }
226 }
\"J. Bruce Fields\e7128042008-12-23 16:09:47 -0500227 last_close = rpci->nwriters == 0 && rpci->nreaders == 0;
228 if (last_close && rpci->ops->release_pipe)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700229 rpci->ops->release_pipe(inode);
230out:
Jes Sorensen1b1dcc12006-01-09 15:59:24 -0800231 mutex_unlock(&inode->i_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700232 return 0;
233}
234
235static ssize_t
236rpc_pipe_read(struct file *filp, char __user *buf, size_t len, loff_t *offset)
237{
Josef Sipek303b46b2006-12-08 02:37:42 -0800238 struct inode *inode = filp->f_path.dentry->d_inode;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700239 struct rpc_inode *rpci = RPC_I(inode);
240 struct rpc_pipe_msg *msg;
241 int res = 0;
242
Jes Sorensen1b1dcc12006-01-09 15:59:24 -0800243 mutex_lock(&inode->i_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700244 if (rpci->ops == NULL) {
245 res = -EPIPE;
246 goto out_unlock;
247 }
248 msg = filp->private_data;
249 if (msg == NULL) {
Trond Myklebust9842ef32006-02-01 12:18:44 -0500250 spin_lock(&inode->i_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700251 if (!list_empty(&rpci->pipe)) {
252 msg = list_entry(rpci->pipe.next,
253 struct rpc_pipe_msg,
254 list);
255 list_move(&msg->list, &rpci->in_upcall);
256 rpci->pipelen -= msg->len;
257 filp->private_data = msg;
258 msg->copied = 0;
259 }
Trond Myklebust9842ef32006-02-01 12:18:44 -0500260 spin_unlock(&inode->i_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700261 if (msg == NULL)
262 goto out_unlock;
263 }
264 /* NOTE: it is up to the callback to update msg->copied */
265 res = rpci->ops->upcall(filp, msg, buf, len);
266 if (res < 0 || msg->len == msg->copied) {
267 filp->private_data = NULL;
Trond Myklebust9842ef32006-02-01 12:18:44 -0500268 spin_lock(&inode->i_lock);
269 list_del(&msg->list);
270 spin_unlock(&inode->i_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700271 rpci->ops->destroy_msg(msg);
272 }
273out_unlock:
Jes Sorensen1b1dcc12006-01-09 15:59:24 -0800274 mutex_unlock(&inode->i_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700275 return res;
276}
277
278static ssize_t
279rpc_pipe_write(struct file *filp, const char __user *buf, size_t len, loff_t *offset)
280{
Josef Sipek303b46b2006-12-08 02:37:42 -0800281 struct inode *inode = filp->f_path.dentry->d_inode;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700282 struct rpc_inode *rpci = RPC_I(inode);
283 int res;
284
Jes Sorensen1b1dcc12006-01-09 15:59:24 -0800285 mutex_lock(&inode->i_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700286 res = -EPIPE;
287 if (rpci->ops != NULL)
288 res = rpci->ops->downcall(filp, buf, len);
Jes Sorensen1b1dcc12006-01-09 15:59:24 -0800289 mutex_unlock(&inode->i_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700290 return res;
291}
292
293static unsigned int
294rpc_pipe_poll(struct file *filp, struct poll_table_struct *wait)
295{
296 struct rpc_inode *rpci;
297 unsigned int mask = 0;
298
Josef Sipek303b46b2006-12-08 02:37:42 -0800299 rpci = RPC_I(filp->f_path.dentry->d_inode);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700300 poll_wait(filp, &rpci->waitq, wait);
301
302 mask = POLLOUT | POLLWRNORM;
303 if (rpci->ops == NULL)
304 mask |= POLLERR | POLLHUP;
J. Bruce Fieldseda4f9b2007-11-06 13:05:36 -0500305 if (filp->private_data || !list_empty(&rpci->pipe))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700306 mask |= POLLIN | POLLRDNORM;
307 return mask;
308}
309
310static int
311rpc_pipe_ioctl(struct inode *ino, struct file *filp,
312 unsigned int cmd, unsigned long arg)
313{
Josef Sipek303b46b2006-12-08 02:37:42 -0800314 struct rpc_inode *rpci = RPC_I(filp->f_path.dentry->d_inode);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700315 int len;
316
317 switch (cmd) {
318 case FIONREAD:
319 if (rpci->ops == NULL)
320 return -EPIPE;
321 len = rpci->pipelen;
322 if (filp->private_data) {
323 struct rpc_pipe_msg *msg;
324 msg = (struct rpc_pipe_msg *)filp->private_data;
325 len += msg->len - msg->copied;
326 }
327 return put_user(len, (int __user *)arg);
328 default:
329 return -EINVAL;
330 }
331}
332
Arjan van de Venda7071d2007-02-12 00:55:36 -0800333static const struct file_operations rpc_pipe_fops = {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700334 .owner = THIS_MODULE,
335 .llseek = no_llseek,
336 .read = rpc_pipe_read,
337 .write = rpc_pipe_write,
338 .poll = rpc_pipe_poll,
339 .ioctl = rpc_pipe_ioctl,
340 .open = rpc_pipe_open,
341 .release = rpc_pipe_release,
342};
343
344static int
345rpc_show_info(struct seq_file *m, void *v)
346{
347 struct rpc_clnt *clnt = m->private;
348
349 seq_printf(m, "RPC server: %s\n", clnt->cl_server);
350 seq_printf(m, "service: %s (%d) version %d\n", clnt->cl_protname,
351 clnt->cl_prog, clnt->cl_vers);
Chuck Levere7f78652006-08-22 20:06:19 -0400352 seq_printf(m, "address: %s\n", rpc_peeraddr2str(clnt, RPC_DISPLAY_ADDR));
353 seq_printf(m, "protocol: %s\n", rpc_peeraddr2str(clnt, RPC_DISPLAY_PROTO));
J. Bruce Fieldsbf19aac2007-09-26 14:38:09 -0400354 seq_printf(m, "port: %s\n", rpc_peeraddr2str(clnt, RPC_DISPLAY_PORT));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700355 return 0;
356}
357
358static int
359rpc_info_open(struct inode *inode, struct file *file)
360{
361 struct rpc_clnt *clnt;
362 int ret = single_open(file, rpc_show_info, NULL);
363
364 if (!ret) {
365 struct seq_file *m = file->private_data;
Jes Sorensen1b1dcc12006-01-09 15:59:24 -0800366 mutex_lock(&inode->i_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700367 clnt = RPC_I(inode)->private;
368 if (clnt) {
Trond Myklebust34f52e32007-06-14 16:40:31 -0400369 kref_get(&clnt->cl_kref);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700370 m->private = clnt;
371 } else {
372 single_release(inode, file);
373 ret = -EINVAL;
374 }
Jes Sorensen1b1dcc12006-01-09 15:59:24 -0800375 mutex_unlock(&inode->i_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700376 }
377 return ret;
378}
379
380static int
381rpc_info_release(struct inode *inode, struct file *file)
382{
383 struct seq_file *m = file->private_data;
384 struct rpc_clnt *clnt = (struct rpc_clnt *)m->private;
385
386 if (clnt)
387 rpc_release_client(clnt);
388 return single_release(inode, file);
389}
390
Arjan van de Venda7071d2007-02-12 00:55:36 -0800391static const struct file_operations rpc_info_operations = {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700392 .owner = THIS_MODULE,
393 .open = rpc_info_open,
394 .read = seq_read,
395 .llseek = seq_lseek,
396 .release = rpc_info_release,
397};
398
399
400/*
401 * We have a single directory with 1 node in it.
402 */
403enum {
404 RPCAUTH_Root = 1,
405 RPCAUTH_lockd,
406 RPCAUTH_mount,
407 RPCAUTH_nfs,
408 RPCAUTH_portmap,
409 RPCAUTH_statd,
410 RPCAUTH_RootEOF
411};
412
413/*
414 * Description of fs contents.
415 */
416struct rpc_filelist {
417 char *name;
Arjan van de Ven99ac48f2006-03-28 01:56:41 -0800418 const struct file_operations *i_fop;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700419 int mode;
420};
421
422static struct rpc_filelist files[] = {
423 [RPCAUTH_lockd] = {
424 .name = "lockd",
425 .mode = S_IFDIR | S_IRUGO | S_IXUGO,
426 },
427 [RPCAUTH_mount] = {
428 .name = "mount",
429 .mode = S_IFDIR | S_IRUGO | S_IXUGO,
430 },
431 [RPCAUTH_nfs] = {
432 .name = "nfs",
433 .mode = S_IFDIR | S_IRUGO | S_IXUGO,
434 },
435 [RPCAUTH_portmap] = {
436 .name = "portmap",
437 .mode = S_IFDIR | S_IRUGO | S_IXUGO,
438 },
439 [RPCAUTH_statd] = {
440 .name = "statd",
441 .mode = S_IFDIR | S_IRUGO | S_IXUGO,
442 },
443};
444
445enum {
446 RPCAUTH_info = 2,
447 RPCAUTH_EOF
448};
449
450static struct rpc_filelist authfiles[] = {
451 [RPCAUTH_info] = {
452 .name = "info",
453 .i_fop = &rpc_info_operations,
454 .mode = S_IFREG | S_IRUSR,
455 },
456};
457
Trond Myklebust54281542006-03-20 13:44:49 -0500458struct vfsmount *rpc_get_mount(void)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700459{
Trond Myklebust54281542006-03-20 13:44:49 -0500460 int err;
461
Trond Myklebust1f5ce9e2006-06-09 09:34:16 -0400462 err = simple_pin_fs(&rpc_pipe_fs_type, &rpc_mount, &rpc_mount_count);
Trond Myklebust54281542006-03-20 13:44:49 -0500463 if (err != 0)
464 return ERR_PTR(err);
465 return rpc_mount;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700466}
467
Trond Myklebust54281542006-03-20 13:44:49 -0500468void rpc_put_mount(void)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700469{
470 simple_release_fs(&rpc_mount, &rpc_mount_count);
471}
472
Trond Myklebust62e17612007-06-08 14:14:46 -0400473static int rpc_delete_dentry(struct dentry *dentry)
474{
475 return 1;
476}
477
478static struct dentry_operations rpc_dentry_operations = {
479 .d_delete = rpc_delete_dentry,
480};
481
Trond Myklebustf1345852005-09-23 11:08:25 -0400482static int
483rpc_lookup_parent(char *path, struct nameidata *nd)
484{
Josef 'Jeff' Sipek4ac4efc2007-07-19 01:48:20 -0700485 struct vfsmount *mnt;
486
Trond Myklebustf1345852005-09-23 11:08:25 -0400487 if (path[0] == '\0')
488 return -ENOENT;
Josef 'Jeff' Sipek4ac4efc2007-07-19 01:48:20 -0700489
490 mnt = rpc_get_mount();
491 if (IS_ERR(mnt)) {
Trond Myklebustf1345852005-09-23 11:08:25 -0400492 printk(KERN_WARNING "%s: %s failed to mount "
Harvey Harrison0dc47872008-03-05 20:47:47 -0800493 "pseudofilesystem \n", __FILE__, __func__);
Josef 'Jeff' Sipek4ac4efc2007-07-19 01:48:20 -0700494 return PTR_ERR(mnt);
Trond Myklebustf1345852005-09-23 11:08:25 -0400495 }
Trond Myklebustf1345852005-09-23 11:08:25 -0400496
Josef 'Jeff' Sipek4ac4efc2007-07-19 01:48:20 -0700497 if (vfs_path_lookup(mnt->mnt_root, mnt, path, LOOKUP_PARENT, nd)) {
Trond Myklebustf1345852005-09-23 11:08:25 -0400498 printk(KERN_WARNING "%s: %s failed to find path %s\n",
Harvey Harrison0dc47872008-03-05 20:47:47 -0800499 __FILE__, __func__, path);
Trond Myklebustf1345852005-09-23 11:08:25 -0400500 rpc_put_mount();
501 return -ENOENT;
502 }
503 return 0;
504}
505
506static void
507rpc_release_path(struct nameidata *nd)
508{
Jan Blunck1d957f92008-02-14 19:34:35 -0800509 path_put(&nd->path);
Trond Myklebustf1345852005-09-23 11:08:25 -0400510 rpc_put_mount();
511}
512
Linus Torvalds1da177e2005-04-16 15:20:36 -0700513static struct inode *
514rpc_get_inode(struct super_block *sb, int mode)
515{
516 struct inode *inode = new_inode(sb);
517 if (!inode)
518 return NULL;
519 inode->i_mode = mode;
520 inode->i_uid = inode->i_gid = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700521 inode->i_blocks = 0;
522 inode->i_atime = inode->i_mtime = inode->i_ctime = CURRENT_TIME;
523 switch(mode & S_IFMT) {
524 case S_IFDIR:
525 inode->i_fop = &simple_dir_operations;
526 inode->i_op = &simple_dir_inode_operations;
Dave Hansend8c76e62006-09-30 23:29:04 -0700527 inc_nlink(inode);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700528 default:
529 break;
530 }
531 return inode;
532}
533
534/*
535 * FIXME: This probably has races.
536 */
Chuck Lever9b45b742007-10-26 13:31:04 -0400537static void rpc_depopulate(struct dentry *parent,
538 unsigned long start, unsigned long eof)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700539{
540 struct inode *dir = parent->d_inode;
541 struct list_head *pos, *next;
542 struct dentry *dentry, *dvec[10];
543 int n = 0;
544
Arjan van de Venc6573c22006-07-03 00:25:16 -0700545 mutex_lock_nested(&dir->i_mutex, I_MUTEX_CHILD);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700546repeat:
547 spin_lock(&dcache_lock);
548 list_for_each_safe(pos, next, &parent->d_subdirs) {
Eric Dumazet5160ee62006-01-08 01:03:32 -0800549 dentry = list_entry(pos, struct dentry, d_u.d_child);
Trond Myklebust62e17612007-06-08 14:14:46 -0400550 if (!dentry->d_inode ||
551 dentry->d_inode->i_ino < start ||
552 dentry->d_inode->i_ino >= eof)
553 continue;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700554 spin_lock(&dentry->d_lock);
555 if (!d_unhashed(dentry)) {
556 dget_locked(dentry);
557 __d_drop(dentry);
558 spin_unlock(&dentry->d_lock);
559 dvec[n++] = dentry;
560 if (n == ARRAY_SIZE(dvec))
561 break;
562 } else
563 spin_unlock(&dentry->d_lock);
564 }
565 spin_unlock(&dcache_lock);
566 if (n) {
567 do {
568 dentry = dvec[--n];
Trond Myklebust62e17612007-06-08 14:14:46 -0400569 if (S_ISREG(dentry->d_inode->i_mode))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700570 simple_unlink(dir, dentry);
Trond Myklebust62e17612007-06-08 14:14:46 -0400571 else if (S_ISDIR(dentry->d_inode->i_mode))
572 simple_rmdir(dir, dentry);
573 d_delete(dentry);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700574 dput(dentry);
575 } while (n);
576 goto repeat;
577 }
Jes Sorensen1b1dcc12006-01-09 15:59:24 -0800578 mutex_unlock(&dir->i_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700579}
580
581static int
582rpc_populate(struct dentry *parent,
583 struct rpc_filelist *files,
584 int start, int eof)
585{
586 struct inode *inode, *dir = parent->d_inode;
587 void *private = RPC_I(dir)->private;
588 struct dentry *dentry;
589 int mode, i;
590
Jes Sorensen1b1dcc12006-01-09 15:59:24 -0800591 mutex_lock(&dir->i_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700592 for (i = start; i < eof; i++) {
593 dentry = d_alloc_name(parent, files[i].name);
594 if (!dentry)
595 goto out_bad;
Trond Myklebust62e17612007-06-08 14:14:46 -0400596 dentry->d_op = &rpc_dentry_operations;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700597 mode = files[i].mode;
598 inode = rpc_get_inode(dir->i_sb, mode);
599 if (!inode) {
600 dput(dentry);
601 goto out_bad;
602 }
603 inode->i_ino = i;
604 if (files[i].i_fop)
605 inode->i_fop = files[i].i_fop;
606 if (private)
607 rpc_inode_setowner(inode, private);
608 if (S_ISDIR(mode))
Dave Hansend8c76e62006-09-30 23:29:04 -0700609 inc_nlink(dir);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700610 d_add(dentry, inode);
Trond Myklebust50e437d2007-06-07 22:44:34 -0400611 fsnotify_create(dir, dentry);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700612 }
Jes Sorensen1b1dcc12006-01-09 15:59:24 -0800613 mutex_unlock(&dir->i_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700614 return 0;
615out_bad:
Jes Sorensen1b1dcc12006-01-09 15:59:24 -0800616 mutex_unlock(&dir->i_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700617 printk(KERN_WARNING "%s: %s failed to populate directory %s\n",
Harvey Harrison0dc47872008-03-05 20:47:47 -0800618 __FILE__, __func__, parent->d_name.name);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700619 return -ENOMEM;
620}
621
Trond Myklebustf1345852005-09-23 11:08:25 -0400622static int
623__rpc_mkdir(struct inode *dir, struct dentry *dentry)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700624{
625 struct inode *inode;
626
Trond Myklebust1d216322007-02-02 15:56:06 -0800627 inode = rpc_get_inode(dir->i_sb, S_IFDIR | S_IRUGO | S_IXUGO);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700628 if (!inode)
Trond Myklebustf1345852005-09-23 11:08:25 -0400629 goto out_err;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700630 inode->i_ino = iunique(dir->i_sb, 100);
Christoph Hellwig278c9952005-07-24 23:53:01 +0100631 d_instantiate(dentry, inode);
Dave Hansend8c76e62006-09-30 23:29:04 -0700632 inc_nlink(dir);
Trond Myklebust50e437d2007-06-07 22:44:34 -0400633 fsnotify_mkdir(dir, dentry);
Trond Myklebustf1345852005-09-23 11:08:25 -0400634 return 0;
635out_err:
636 printk(KERN_WARNING "%s: %s failed to allocate inode for dentry %s\n",
Harvey Harrison0dc47872008-03-05 20:47:47 -0800637 __FILE__, __func__, dentry->d_name.name);
Trond Myklebustf1345852005-09-23 11:08:25 -0400638 return -ENOMEM;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700639}
640
Trond Myklebustf1345852005-09-23 11:08:25 -0400641static int
642__rpc_rmdir(struct inode *dir, struct dentry *dentry)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700643{
Trond Myklebustf1345852005-09-23 11:08:25 -0400644 int error;
Trond Myklebust62e17612007-06-08 14:14:46 -0400645 error = simple_rmdir(dir, dentry);
646 if (!error)
647 d_delete(dentry);
648 return error;
Trond Myklebustf1345852005-09-23 11:08:25 -0400649}
Christoph Hellwig278c9952005-07-24 23:53:01 +0100650
Trond Myklebustf1345852005-09-23 11:08:25 -0400651static struct dentry *
Trond Myklebust34f30892007-06-07 18:28:02 -0400652rpc_lookup_create(struct dentry *parent, const char *name, int len, int exclusive)
Trond Myklebustf1345852005-09-23 11:08:25 -0400653{
Trond Myklebust158998b2006-08-24 01:03:17 -0400654 struct inode *dir = parent->d_inode;
Trond Myklebustf1345852005-09-23 11:08:25 -0400655 struct dentry *dentry;
Trond Myklebustf1345852005-09-23 11:08:25 -0400656
Arjan van de Venc6573c22006-07-03 00:25:16 -0700657 mutex_lock_nested(&dir->i_mutex, I_MUTEX_PARENT);
Trond Myklebust158998b2006-08-24 01:03:17 -0400658 dentry = lookup_one_len(name, parent, len);
Trond Myklebustf1345852005-09-23 11:08:25 -0400659 if (IS_ERR(dentry))
660 goto out_err;
Trond Myklebust62e17612007-06-08 14:14:46 -0400661 if (!dentry->d_inode)
662 dentry->d_op = &rpc_dentry_operations;
663 else if (exclusive) {
Trond Myklebustf1345852005-09-23 11:08:25 -0400664 dput(dentry);
665 dentry = ERR_PTR(-EEXIST);
666 goto out_err;
667 }
668 return dentry;
669out_err:
Jes Sorensen1b1dcc12006-01-09 15:59:24 -0800670 mutex_unlock(&dir->i_mutex);
Trond Myklebust158998b2006-08-24 01:03:17 -0400671 return dentry;
672}
673
674static struct dentry *
675rpc_lookup_negative(char *path, struct nameidata *nd)
676{
677 struct dentry *dentry;
678 int error;
679
680 if ((error = rpc_lookup_parent(path, nd)) != 0)
681 return ERR_PTR(error);
Jan Blunck4ac91372008-02-14 19:34:32 -0800682 dentry = rpc_lookup_create(nd->path.dentry, nd->last.name, nd->last.len,
683 1);
Trond Myklebust158998b2006-08-24 01:03:17 -0400684 if (IS_ERR(dentry))
685 rpc_release_path(nd);
Trond Myklebustf1345852005-09-23 11:08:25 -0400686 return dentry;
687}
688
J. Bruce Fields93a44a72007-11-06 13:06:03 -0500689/**
690 * rpc_mkdir - Create a new directory in rpc_pipefs
691 * @path: path from the rpc_pipefs root to the new directory
Randy Dunlap65b6e422008-02-13 15:03:23 -0800692 * @rpc_client: rpc client to associate with this directory
J. Bruce Fields93a44a72007-11-06 13:06:03 -0500693 *
694 * This creates a directory at the given @path associated with
695 * @rpc_clnt, which will contain a file named "info" with some basic
696 * information about the client, together with any "pipes" that may
697 * later be created using rpc_mkpipe().
698 */
Trond Myklebustf1345852005-09-23 11:08:25 -0400699struct dentry *
700rpc_mkdir(char *path, struct rpc_clnt *rpc_client)
701{
702 struct nameidata nd;
703 struct dentry *dentry;
704 struct inode *dir;
705 int error;
706
707 dentry = rpc_lookup_negative(path, &nd);
708 if (IS_ERR(dentry))
709 return dentry;
Jan Blunck4ac91372008-02-14 19:34:32 -0800710 dir = nd.path.dentry->d_inode;
Trond Myklebustf1345852005-09-23 11:08:25 -0400711 if ((error = __rpc_mkdir(dir, dentry)) != 0)
712 goto err_dput;
713 RPC_I(dentry->d_inode)->private = rpc_client;
714 error = rpc_populate(dentry, authfiles,
715 RPCAUTH_info, RPCAUTH_EOF);
716 if (error)
717 goto err_depopulate;
Trond Myklebust5c3e9852006-07-29 17:37:40 -0400718 dget(dentry);
Trond Myklebustf1345852005-09-23 11:08:25 -0400719out:
Jes Sorensen1b1dcc12006-01-09 15:59:24 -0800720 mutex_unlock(&dir->i_mutex);
Trond Myklebustf1345852005-09-23 11:08:25 -0400721 rpc_release_path(&nd);
Trond Myklebust5c3e9852006-07-29 17:37:40 -0400722 return dentry;
Trond Myklebustf1345852005-09-23 11:08:25 -0400723err_depopulate:
Trond Myklebust62e17612007-06-08 14:14:46 -0400724 rpc_depopulate(dentry, RPCAUTH_info, RPCAUTH_EOF);
Trond Myklebustf1345852005-09-23 11:08:25 -0400725 __rpc_rmdir(dir, dentry);
726err_dput:
727 dput(dentry);
728 printk(KERN_WARNING "%s: %s() failed to create directory %s (errno = %d)\n",
Harvey Harrison0dc47872008-03-05 20:47:47 -0800729 __FILE__, __func__, path, error);
Trond Myklebustf1345852005-09-23 11:08:25 -0400730 dentry = ERR_PTR(error);
731 goto out;
732}
733
J. Bruce Fields93a44a72007-11-06 13:06:03 -0500734/**
735 * rpc_rmdir - Remove a directory created with rpc_mkdir()
736 * @dentry: directory to remove
737 */
Trond Myklebustf1345852005-09-23 11:08:25 -0400738int
Trond Myklebustdff02cc2006-07-31 14:17:18 -0700739rpc_rmdir(struct dentry *dentry)
Trond Myklebustf1345852005-09-23 11:08:25 -0400740{
Trond Myklebustdff02cc2006-07-31 14:17:18 -0700741 struct dentry *parent;
Trond Myklebustf1345852005-09-23 11:08:25 -0400742 struct inode *dir;
743 int error;
744
Trond Myklebustdff02cc2006-07-31 14:17:18 -0700745 parent = dget_parent(dentry);
746 dir = parent->d_inode;
Arjan van de Venc6573c22006-07-03 00:25:16 -0700747 mutex_lock_nested(&dir->i_mutex, I_MUTEX_PARENT);
Trond Myklebust62e17612007-06-08 14:14:46 -0400748 rpc_depopulate(dentry, RPCAUTH_info, RPCAUTH_EOF);
Trond Myklebustf1345852005-09-23 11:08:25 -0400749 error = __rpc_rmdir(dir, dentry);
750 dput(dentry);
Jes Sorensen1b1dcc12006-01-09 15:59:24 -0800751 mutex_unlock(&dir->i_mutex);
Trond Myklebustdff02cc2006-07-31 14:17:18 -0700752 dput(parent);
Trond Myklebustf1345852005-09-23 11:08:25 -0400753 return error;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700754}
755
J. Bruce Fields93a44a72007-11-06 13:06:03 -0500756/**
757 * rpc_mkpipe - make an rpc_pipefs file for kernel<->userspace communication
758 * @parent: dentry of directory to create new "pipe" in
759 * @name: name of pipe
760 * @private: private data to associate with the pipe, for the caller's use
761 * @ops: operations defining the behavior of the pipe: upcall, downcall,
\"J. Bruce Fields\c3810602008-12-23 16:08:32 -0500762 * release_pipe, open_pipe, and destroy_msg.
Randy Dunlap65b6e422008-02-13 15:03:23 -0800763 * @flags: rpc_inode flags
J. Bruce Fields93a44a72007-11-06 13:06:03 -0500764 *
765 * Data is made available for userspace to read by calls to
766 * rpc_queue_upcall(). The actual reads will result in calls to
767 * @ops->upcall, which will be called with the file pointer,
768 * message, and userspace buffer to copy to.
769 *
770 * Writes can come at any time, and do not necessarily have to be
771 * responses to upcalls. They will result in calls to @msg->downcall.
772 *
773 * The @private argument passed here will be available to all these methods
774 * from the file pointer, via RPC_I(file->f_dentry->d_inode)->private.
775 */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700776struct dentry *
Trond Myklebust158998b2006-08-24 01:03:17 -0400777rpc_mkpipe(struct dentry *parent, const char *name, void *private, struct rpc_pipe_ops *ops, int flags)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700778{
Linus Torvalds1da177e2005-04-16 15:20:36 -0700779 struct dentry *dentry;
Trond Myklebustf1345852005-09-23 11:08:25 -0400780 struct inode *dir, *inode;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700781 struct rpc_inode *rpci;
782
Trond Myklebust34f30892007-06-07 18:28:02 -0400783 dentry = rpc_lookup_create(parent, name, strlen(name), 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700784 if (IS_ERR(dentry))
Trond Myklebustf1345852005-09-23 11:08:25 -0400785 return dentry;
Trond Myklebust158998b2006-08-24 01:03:17 -0400786 dir = parent->d_inode;
Trond Myklebust34f30892007-06-07 18:28:02 -0400787 if (dentry->d_inode) {
788 rpci = RPC_I(dentry->d_inode);
789 if (rpci->private != private ||
790 rpci->ops != ops ||
791 rpci->flags != flags) {
792 dput (dentry);
793 dentry = ERR_PTR(-EBUSY);
794 }
Trond Myklebust03a12562007-06-08 14:14:53 -0400795 rpci->nkern_readwriters++;
Trond Myklebust34f30892007-06-07 18:28:02 -0400796 goto out;
797 }
Steve Dicksona53a3c52006-09-06 11:51:21 -0400798 inode = rpc_get_inode(dir->i_sb, S_IFIFO | S_IRUSR | S_IWUSR);
Trond Myklebustf1345852005-09-23 11:08:25 -0400799 if (!inode)
800 goto err_dput;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700801 inode->i_ino = iunique(dir->i_sb, 100);
802 inode->i_fop = &rpc_pipe_fops;
Trond Myklebustf1345852005-09-23 11:08:25 -0400803 d_instantiate(dentry, inode);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700804 rpci = RPC_I(inode);
805 rpci->private = private;
806 rpci->flags = flags;
807 rpci->ops = ops;
Trond Myklebust03a12562007-06-08 14:14:53 -0400808 rpci->nkern_readwriters = 1;
Trond Myklebust50e437d2007-06-07 22:44:34 -0400809 fsnotify_create(dir, dentry);
Trond Myklebust5c3e9852006-07-29 17:37:40 -0400810 dget(dentry);
Trond Myklebustf1345852005-09-23 11:08:25 -0400811out:
Jes Sorensen1b1dcc12006-01-09 15:59:24 -0800812 mutex_unlock(&dir->i_mutex);
Trond Myklebust5c3e9852006-07-29 17:37:40 -0400813 return dentry;
Trond Myklebustf1345852005-09-23 11:08:25 -0400814err_dput:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700815 dput(dentry);
Trond Myklebustf1345852005-09-23 11:08:25 -0400816 dentry = ERR_PTR(-ENOMEM);
Trond Myklebust158998b2006-08-24 01:03:17 -0400817 printk(KERN_WARNING "%s: %s() failed to create pipe %s/%s (errno = %d)\n",
Harvey Harrison0dc47872008-03-05 20:47:47 -0800818 __FILE__, __func__, parent->d_name.name, name,
Trond Myklebust158998b2006-08-24 01:03:17 -0400819 -ENOMEM);
Trond Myklebustf1345852005-09-23 11:08:25 -0400820 goto out;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700821}
Trond Myklebust468039e2008-12-23 15:21:31 -0500822EXPORT_SYMBOL_GPL(rpc_mkpipe);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700823
J. Bruce Fields93a44a72007-11-06 13:06:03 -0500824/**
825 * rpc_unlink - remove a pipe
826 * @dentry: dentry for the pipe, as returned from rpc_mkpipe
827 *
828 * After this call, lookups will no longer find the pipe, and any
829 * attempts to read or write using preexisting opens of the pipe will
830 * return -EPIPE.
831 */
Trond Myklebustf1345852005-09-23 11:08:25 -0400832int
Trond Myklebust5d674762006-07-31 14:11:48 -0700833rpc_unlink(struct dentry *dentry)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700834{
Trond Myklebust5d674762006-07-31 14:11:48 -0700835 struct dentry *parent;
Trond Myklebustf1345852005-09-23 11:08:25 -0400836 struct inode *dir;
Trond Myklebust5d674762006-07-31 14:11:48 -0700837 int error = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700838
Trond Myklebust5d674762006-07-31 14:11:48 -0700839 parent = dget_parent(dentry);
840 dir = parent->d_inode;
Arjan van de Venc6573c22006-07-03 00:25:16 -0700841 mutex_lock_nested(&dir->i_mutex, I_MUTEX_PARENT);
Trond Myklebust03a12562007-06-08 14:14:53 -0400842 if (--RPC_I(dentry->d_inode)->nkern_readwriters == 0) {
843 rpc_close_pipes(dentry->d_inode);
844 error = simple_unlink(dir, dentry);
845 if (!error)
846 d_delete(dentry);
847 }
Trond Myklebustf1345852005-09-23 11:08:25 -0400848 dput(dentry);
Jes Sorensen1b1dcc12006-01-09 15:59:24 -0800849 mutex_unlock(&dir->i_mutex);
Trond Myklebust5d674762006-07-31 14:11:48 -0700850 dput(parent);
Trond Myklebustf1345852005-09-23 11:08:25 -0400851 return error;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700852}
Trond Myklebust468039e2008-12-23 15:21:31 -0500853EXPORT_SYMBOL_GPL(rpc_unlink);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700854
855/*
856 * populate the filesystem
857 */
858static struct super_operations s_ops = {
859 .alloc_inode = rpc_alloc_inode,
860 .destroy_inode = rpc_destroy_inode,
861 .statfs = simple_statfs,
862};
863
864#define RPCAUTH_GSSMAGIC 0x67596969
865
866static int
867rpc_fill_super(struct super_block *sb, void *data, int silent)
868{
869 struct inode *inode;
870 struct dentry *root;
871
872 sb->s_blocksize = PAGE_CACHE_SIZE;
873 sb->s_blocksize_bits = PAGE_CACHE_SHIFT;
874 sb->s_magic = RPCAUTH_GSSMAGIC;
875 sb->s_op = &s_ops;
876 sb->s_time_gran = 1;
877
878 inode = rpc_get_inode(sb, S_IFDIR | 0755);
879 if (!inode)
880 return -ENOMEM;
881 root = d_alloc_root(inode);
882 if (!root) {
883 iput(inode);
884 return -ENOMEM;
885 }
886 if (rpc_populate(root, files, RPCAUTH_Root + 1, RPCAUTH_RootEOF))
887 goto out;
888 sb->s_root = root;
889 return 0;
890out:
891 d_genocide(root);
892 dput(root);
893 return -ENOMEM;
894}
895
David Howells454e2392006-06-23 02:02:57 -0700896static int
Linus Torvalds1da177e2005-04-16 15:20:36 -0700897rpc_get_sb(struct file_system_type *fs_type,
David Howells454e2392006-06-23 02:02:57 -0700898 int flags, const char *dev_name, void *data, struct vfsmount *mnt)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700899{
David Howells454e2392006-06-23 02:02:57 -0700900 return get_sb_single(fs_type, flags, data, rpc_fill_super, mnt);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700901}
902
903static struct file_system_type rpc_pipe_fs_type = {
904 .owner = THIS_MODULE,
905 .name = "rpc_pipefs",
906 .get_sb = rpc_get_sb,
907 .kill_sb = kill_litter_super,
908};
909
910static void
Alexey Dobriyan51cc5062008-07-25 19:45:34 -0700911init_once(void *foo)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700912{
913 struct rpc_inode *rpci = (struct rpc_inode *) foo;
914
Christoph Lametera35afb82007-05-16 22:10:57 -0700915 inode_init_once(&rpci->vfs_inode);
916 rpci->private = NULL;
917 rpci->nreaders = 0;
918 rpci->nwriters = 0;
919 INIT_LIST_HEAD(&rpci->in_upcall);
Trond Myklebust6e84c7b2007-06-07 15:31:36 -0400920 INIT_LIST_HEAD(&rpci->in_downcall);
Christoph Lametera35afb82007-05-16 22:10:57 -0700921 INIT_LIST_HEAD(&rpci->pipe);
922 rpci->pipelen = 0;
923 init_waitqueue_head(&rpci->waitq);
924 INIT_DELAYED_WORK(&rpci->queue_timeout,
925 rpc_timeout_upcall_queue);
926 rpci->ops = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700927}
928
929int register_rpc_pipefs(void)
930{
Akinobu Mita5bd5f582007-05-09 02:34:51 -0700931 int err;
932
Linus Torvalds1da177e2005-04-16 15:20:36 -0700933 rpc_inode_cachep = kmem_cache_create("rpc_inode_cache",
Paul Jacksonfffb60f2006-03-24 03:16:06 -0800934 sizeof(struct rpc_inode),
935 0, (SLAB_HWCACHE_ALIGN|SLAB_RECLAIM_ACCOUNT|
936 SLAB_MEM_SPREAD),
Paul Mundt20c2df82007-07-20 10:11:58 +0900937 init_once);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700938 if (!rpc_inode_cachep)
939 return -ENOMEM;
Akinobu Mita5bd5f582007-05-09 02:34:51 -0700940 err = register_filesystem(&rpc_pipe_fs_type);
941 if (err) {
942 kmem_cache_destroy(rpc_inode_cachep);
943 return err;
944 }
945
Linus Torvalds1da177e2005-04-16 15:20:36 -0700946 return 0;
947}
948
949void unregister_rpc_pipefs(void)
950{
Alexey Dobriyan1a1d92c2006-09-27 01:49:40 -0700951 kmem_cache_destroy(rpc_inode_cachep);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700952 unregister_filesystem(&rpc_pipe_fs_type);
953}