blob: 9ea45383480ee4ddc65711b0c3b45016ff048f0b [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>
Trond Myklebust8854e822009-08-09 15:14:30 -040029#include <linux/sunrpc/cache.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070030
Eric Dumazetba899662005-08-26 12:05:31 -070031static struct vfsmount *rpc_mount __read_mostly;
Linus Torvalds1da177e2005-04-16 15:20:36 -070032static int rpc_mount_count;
33
34static struct file_system_type rpc_pipe_fs_type;
35
36
Christoph Lametere18b8902006-12-06 20:33:20 -080037static struct kmem_cache *rpc_inode_cachep __read_mostly;
Linus Torvalds1da177e2005-04-16 15:20:36 -070038
39#define RPC_UPCALL_TIMEOUT (30*HZ)
40
Trond Myklebust9842ef32006-02-01 12:18:44 -050041static void rpc_purge_list(struct rpc_inode *rpci, struct list_head *head,
42 void (*destroy_msg)(struct rpc_pipe_msg *), int err)
Trond Myklebustb3eb67a2005-11-25 17:10:11 -050043{
44 struct rpc_pipe_msg *msg;
Trond Myklebustb3eb67a2005-11-25 17:10:11 -050045
Trond Myklebust9842ef32006-02-01 12:18:44 -050046 if (list_empty(head))
47 return;
48 do {
Trond Myklebustb3eb67a2005-11-25 17:10:11 -050049 msg = list_entry(head->next, struct rpc_pipe_msg, list);
Trond Myklebust9842ef32006-02-01 12:18:44 -050050 list_del(&msg->list);
Trond Myklebustb3eb67a2005-11-25 17:10:11 -050051 msg->errno = err;
52 destroy_msg(msg);
Trond Myklebust9842ef32006-02-01 12:18:44 -050053 } while (!list_empty(head));
Linus Torvalds1da177e2005-04-16 15:20:36 -070054 wake_up(&rpci->waitq);
55}
56
57static void
David Howells65f27f32006-11-22 14:55:48 +000058rpc_timeout_upcall_queue(struct work_struct *work)
Linus Torvalds1da177e2005-04-16 15:20:36 -070059{
Trond Myklebust9842ef32006-02-01 12:18:44 -050060 LIST_HEAD(free_list);
David Howells65f27f32006-11-22 14:55:48 +000061 struct rpc_inode *rpci =
62 container_of(work, struct rpc_inode, queue_timeout.work);
Linus Torvalds1da177e2005-04-16 15:20:36 -070063 struct inode *inode = &rpci->vfs_inode;
Trond Myklebust9842ef32006-02-01 12:18:44 -050064 void (*destroy_msg)(struct rpc_pipe_msg *);
Linus Torvalds1da177e2005-04-16 15:20:36 -070065
Trond Myklebust9842ef32006-02-01 12:18:44 -050066 spin_lock(&inode->i_lock);
67 if (rpci->ops == NULL) {
68 spin_unlock(&inode->i_lock);
69 return;
70 }
71 destroy_msg = rpci->ops->destroy_msg;
72 if (rpci->nreaders == 0) {
73 list_splice_init(&rpci->pipe, &free_list);
74 rpci->pipelen = 0;
75 }
76 spin_unlock(&inode->i_lock);
77 rpc_purge_list(rpci, &free_list, destroy_msg, -ETIMEDOUT);
Linus Torvalds1da177e2005-04-16 15:20:36 -070078}
79
J. Bruce Fields93a44a72007-11-06 13:06:03 -050080/**
Ben Hutchings1a5778a2010-02-14 22:35:47 -080081 * rpc_queue_upcall - queue an upcall message to userspace
J. Bruce Fields93a44a72007-11-06 13:06:03 -050082 * @inode: inode of upcall pipe on which to queue given message
83 * @msg: message to queue
84 *
85 * Call with an @inode created by rpc_mkpipe() to queue an upcall.
86 * A userspace process may then later read the upcall by performing a
87 * read on an open file for this inode. It is up to the caller to
88 * initialize the fields of @msg (other than @msg->list) appropriately.
89 */
Linus Torvalds1da177e2005-04-16 15:20:36 -070090int
91rpc_queue_upcall(struct inode *inode, struct rpc_pipe_msg *msg)
92{
93 struct rpc_inode *rpci = RPC_I(inode);
Trond Myklebust6070fe62005-10-27 22:12:46 -040094 int res = -EPIPE;
Linus Torvalds1da177e2005-04-16 15:20:36 -070095
Trond Myklebust9842ef32006-02-01 12:18:44 -050096 spin_lock(&inode->i_lock);
Trond Myklebust6070fe62005-10-27 22:12:46 -040097 if (rpci->ops == NULL)
98 goto out;
Linus Torvalds1da177e2005-04-16 15:20:36 -070099 if (rpci->nreaders) {
100 list_add_tail(&msg->list, &rpci->pipe);
101 rpci->pipelen += msg->len;
Trond Myklebust6070fe62005-10-27 22:12:46 -0400102 res = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700103 } else if (rpci->flags & RPC_PIPE_WAIT_FOR_OPEN) {
104 if (list_empty(&rpci->pipe))
Trond Myklebust24c5d9d2006-03-20 13:44:08 -0500105 queue_delayed_work(rpciod_workqueue,
106 &rpci->queue_timeout,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700107 RPC_UPCALL_TIMEOUT);
108 list_add_tail(&msg->list, &rpci->pipe);
109 rpci->pipelen += msg->len;
Trond Myklebust6070fe62005-10-27 22:12:46 -0400110 res = 0;
111 }
112out:
Trond Myklebust9842ef32006-02-01 12:18:44 -0500113 spin_unlock(&inode->i_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700114 wake_up(&rpci->waitq);
115 return res;
116}
Trond Myklebust468039e2008-12-23 15:21:31 -0500117EXPORT_SYMBOL_GPL(rpc_queue_upcall);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700118
Trond Myklebust6070fe62005-10-27 22:12:46 -0400119static inline void
120rpc_inode_setowner(struct inode *inode, void *private)
121{
122 RPC_I(inode)->private = private;
123}
124
Linus Torvalds1da177e2005-04-16 15:20:36 -0700125static void
126rpc_close_pipes(struct inode *inode)
127{
128 struct rpc_inode *rpci = RPC_I(inode);
Trond Myklebustb693ba42009-08-09 15:14:15 -0400129 const struct rpc_pipe_ops *ops;
\"J. Bruce Fields\e7128042008-12-23 16:09:47 -0500130 int need_release;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700131
Jes Sorensen1b1dcc12006-01-09 15:59:24 -0800132 mutex_lock(&inode->i_mutex);
Trond Myklebust9842ef32006-02-01 12:18:44 -0500133 ops = rpci->ops;
134 if (ops != NULL) {
135 LIST_HEAD(free_list);
Trond Myklebust9842ef32006-02-01 12:18:44 -0500136 spin_lock(&inode->i_lock);
\"J. Bruce Fields\e7128042008-12-23 16:09:47 -0500137 need_release = rpci->nreaders != 0 || rpci->nwriters != 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700138 rpci->nreaders = 0;
Trond Myklebust9842ef32006-02-01 12:18:44 -0500139 list_splice_init(&rpci->in_upcall, &free_list);
140 list_splice_init(&rpci->pipe, &free_list);
141 rpci->pipelen = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700142 rpci->ops = NULL;
Trond Myklebust9842ef32006-02-01 12:18:44 -0500143 spin_unlock(&inode->i_lock);
144 rpc_purge_list(rpci, &free_list, ops->destroy_msg, -EPIPE);
145 rpci->nwriters = 0;
\"J. Bruce Fields\e7128042008-12-23 16:09:47 -0500146 if (need_release && ops->release_pipe)
Trond Myklebust9842ef32006-02-01 12:18:44 -0500147 ops->release_pipe(inode);
Trond Myklebust4011cd92007-08-07 15:33:01 -0400148 cancel_delayed_work_sync(&rpci->queue_timeout);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700149 }
Trond Myklebust6070fe62005-10-27 22:12:46 -0400150 rpc_inode_setowner(inode, NULL);
Jes Sorensen1b1dcc12006-01-09 15:59:24 -0800151 mutex_unlock(&inode->i_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700152}
153
Linus Torvalds1da177e2005-04-16 15:20:36 -0700154static struct inode *
155rpc_alloc_inode(struct super_block *sb)
156{
157 struct rpc_inode *rpci;
Christoph Lametere94b1762006-12-06 20:33:17 -0800158 rpci = (struct rpc_inode *)kmem_cache_alloc(rpc_inode_cachep, GFP_KERNEL);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700159 if (!rpci)
160 return NULL;
161 return &rpci->vfs_inode;
162}
163
164static void
165rpc_destroy_inode(struct inode *inode)
166{
167 kmem_cache_free(rpc_inode_cachep, RPC_I(inode));
168}
169
170static int
171rpc_pipe_open(struct inode *inode, struct file *filp)
172{
173 struct rpc_inode *rpci = RPC_I(inode);
\"J. Bruce Fields\c3810602008-12-23 16:08:32 -0500174 int first_open;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700175 int res = -ENXIO;
176
Jes Sorensen1b1dcc12006-01-09 15:59:24 -0800177 mutex_lock(&inode->i_mutex);
\"J. Bruce Fields\c3810602008-12-23 16:08:32 -0500178 if (rpci->ops == NULL)
179 goto out;
180 first_open = rpci->nreaders == 0 && rpci->nwriters == 0;
181 if (first_open && rpci->ops->open_pipe) {
182 res = rpci->ops->open_pipe(inode);
183 if (res)
184 goto out;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700185 }
\"J. Bruce Fields\c3810602008-12-23 16:08:32 -0500186 if (filp->f_mode & FMODE_READ)
187 rpci->nreaders++;
188 if (filp->f_mode & FMODE_WRITE)
189 rpci->nwriters++;
190 res = 0;
191out:
Jes Sorensen1b1dcc12006-01-09 15:59:24 -0800192 mutex_unlock(&inode->i_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700193 return res;
194}
195
196static int
197rpc_pipe_release(struct inode *inode, struct file *filp)
198{
Trond Myklebust969b7f22006-01-03 09:55:36 +0100199 struct rpc_inode *rpci = RPC_I(inode);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700200 struct rpc_pipe_msg *msg;
\"J. Bruce Fields\e7128042008-12-23 16:09:47 -0500201 int last_close;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700202
Jes Sorensen1b1dcc12006-01-09 15:59:24 -0800203 mutex_lock(&inode->i_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700204 if (rpci->ops == NULL)
205 goto out;
206 msg = (struct rpc_pipe_msg *)filp->private_data;
207 if (msg != NULL) {
Trond Myklebust9842ef32006-02-01 12:18:44 -0500208 spin_lock(&inode->i_lock);
Trond Myklebust48e49182005-12-19 17:11:22 -0500209 msg->errno = -EAGAIN;
Trond Myklebust9842ef32006-02-01 12:18:44 -0500210 list_del(&msg->list);
211 spin_unlock(&inode->i_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700212 rpci->ops->destroy_msg(msg);
213 }
214 if (filp->f_mode & FMODE_WRITE)
215 rpci->nwriters --;
Trond Myklebust9842ef32006-02-01 12:18:44 -0500216 if (filp->f_mode & FMODE_READ) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700217 rpci->nreaders --;
Trond Myklebust9842ef32006-02-01 12:18:44 -0500218 if (rpci->nreaders == 0) {
219 LIST_HEAD(free_list);
220 spin_lock(&inode->i_lock);
221 list_splice_init(&rpci->pipe, &free_list);
222 rpci->pipelen = 0;
223 spin_unlock(&inode->i_lock);
224 rpc_purge_list(rpci, &free_list,
225 rpci->ops->destroy_msg, -EAGAIN);
226 }
227 }
\"J. Bruce Fields\e7128042008-12-23 16:09:47 -0500228 last_close = rpci->nwriters == 0 && rpci->nreaders == 0;
229 if (last_close && rpci->ops->release_pipe)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700230 rpci->ops->release_pipe(inode);
231out:
Jes Sorensen1b1dcc12006-01-09 15:59:24 -0800232 mutex_unlock(&inode->i_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700233 return 0;
234}
235
236static ssize_t
237rpc_pipe_read(struct file *filp, char __user *buf, size_t len, loff_t *offset)
238{
Josef Sipek303b46b2006-12-08 02:37:42 -0800239 struct inode *inode = filp->f_path.dentry->d_inode;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700240 struct rpc_inode *rpci = RPC_I(inode);
241 struct rpc_pipe_msg *msg;
242 int res = 0;
243
Jes Sorensen1b1dcc12006-01-09 15:59:24 -0800244 mutex_lock(&inode->i_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700245 if (rpci->ops == NULL) {
246 res = -EPIPE;
247 goto out_unlock;
248 }
249 msg = filp->private_data;
250 if (msg == NULL) {
Trond Myklebust9842ef32006-02-01 12:18:44 -0500251 spin_lock(&inode->i_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700252 if (!list_empty(&rpci->pipe)) {
253 msg = list_entry(rpci->pipe.next,
254 struct rpc_pipe_msg,
255 list);
256 list_move(&msg->list, &rpci->in_upcall);
257 rpci->pipelen -= msg->len;
258 filp->private_data = msg;
259 msg->copied = 0;
260 }
Trond Myklebust9842ef32006-02-01 12:18:44 -0500261 spin_unlock(&inode->i_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700262 if (msg == NULL)
263 goto out_unlock;
264 }
265 /* NOTE: it is up to the callback to update msg->copied */
266 res = rpci->ops->upcall(filp, msg, buf, len);
267 if (res < 0 || msg->len == msg->copied) {
268 filp->private_data = NULL;
Trond Myklebust9842ef32006-02-01 12:18:44 -0500269 spin_lock(&inode->i_lock);
270 list_del(&msg->list);
271 spin_unlock(&inode->i_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700272 rpci->ops->destroy_msg(msg);
273 }
274out_unlock:
Jes Sorensen1b1dcc12006-01-09 15:59:24 -0800275 mutex_unlock(&inode->i_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700276 return res;
277}
278
279static ssize_t
280rpc_pipe_write(struct file *filp, const char __user *buf, size_t len, loff_t *offset)
281{
Josef Sipek303b46b2006-12-08 02:37:42 -0800282 struct inode *inode = filp->f_path.dentry->d_inode;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700283 struct rpc_inode *rpci = RPC_I(inode);
284 int res;
285
Jes Sorensen1b1dcc12006-01-09 15:59:24 -0800286 mutex_lock(&inode->i_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700287 res = -EPIPE;
288 if (rpci->ops != NULL)
289 res = rpci->ops->downcall(filp, buf, len);
Jes Sorensen1b1dcc12006-01-09 15:59:24 -0800290 mutex_unlock(&inode->i_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700291 return res;
292}
293
294static unsigned int
295rpc_pipe_poll(struct file *filp, struct poll_table_struct *wait)
296{
297 struct rpc_inode *rpci;
298 unsigned int mask = 0;
299
Josef Sipek303b46b2006-12-08 02:37:42 -0800300 rpci = RPC_I(filp->f_path.dentry->d_inode);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700301 poll_wait(filp, &rpci->waitq, wait);
302
303 mask = POLLOUT | POLLWRNORM;
304 if (rpci->ops == NULL)
305 mask |= POLLERR | POLLHUP;
J. Bruce Fieldseda4f9b2007-11-06 13:05:36 -0500306 if (filp->private_data || !list_empty(&rpci->pipe))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700307 mask |= POLLIN | POLLRDNORM;
308 return mask;
309}
310
311static int
312rpc_pipe_ioctl(struct inode *ino, struct file *filp,
313 unsigned int cmd, unsigned long arg)
314{
Josef Sipek303b46b2006-12-08 02:37:42 -0800315 struct rpc_inode *rpci = RPC_I(filp->f_path.dentry->d_inode);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700316 int len;
317
318 switch (cmd) {
319 case FIONREAD:
320 if (rpci->ops == NULL)
321 return -EPIPE;
322 len = rpci->pipelen;
323 if (filp->private_data) {
324 struct rpc_pipe_msg *msg;
325 msg = (struct rpc_pipe_msg *)filp->private_data;
326 len += msg->len - msg->copied;
327 }
328 return put_user(len, (int __user *)arg);
329 default:
330 return -EINVAL;
331 }
332}
333
Arjan van de Venda7071d2007-02-12 00:55:36 -0800334static const struct file_operations rpc_pipe_fops = {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700335 .owner = THIS_MODULE,
336 .llseek = no_llseek,
337 .read = rpc_pipe_read,
338 .write = rpc_pipe_write,
339 .poll = rpc_pipe_poll,
340 .ioctl = rpc_pipe_ioctl,
341 .open = rpc_pipe_open,
342 .release = rpc_pipe_release,
343};
344
345static int
346rpc_show_info(struct seq_file *m, void *v)
347{
348 struct rpc_clnt *clnt = m->private;
349
350 seq_printf(m, "RPC server: %s\n", clnt->cl_server);
351 seq_printf(m, "service: %s (%d) version %d\n", clnt->cl_protname,
352 clnt->cl_prog, clnt->cl_vers);
Chuck Levere7f78652006-08-22 20:06:19 -0400353 seq_printf(m, "address: %s\n", rpc_peeraddr2str(clnt, RPC_DISPLAY_ADDR));
354 seq_printf(m, "protocol: %s\n", rpc_peeraddr2str(clnt, RPC_DISPLAY_PROTO));
J. Bruce Fieldsbf19aac2007-09-26 14:38:09 -0400355 seq_printf(m, "port: %s\n", rpc_peeraddr2str(clnt, RPC_DISPLAY_PORT));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700356 return 0;
357}
358
359static int
360rpc_info_open(struct inode *inode, struct file *file)
361{
362 struct rpc_clnt *clnt;
363 int ret = single_open(file, rpc_show_info, NULL);
364
365 if (!ret) {
366 struct seq_file *m = file->private_data;
Jes Sorensen1b1dcc12006-01-09 15:59:24 -0800367 mutex_lock(&inode->i_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700368 clnt = RPC_I(inode)->private;
369 if (clnt) {
Trond Myklebust34f52e32007-06-14 16:40:31 -0400370 kref_get(&clnt->cl_kref);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700371 m->private = clnt;
372 } else {
373 single_release(inode, file);
374 ret = -EINVAL;
375 }
Jes Sorensen1b1dcc12006-01-09 15:59:24 -0800376 mutex_unlock(&inode->i_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700377 }
378 return ret;
379}
380
381static int
382rpc_info_release(struct inode *inode, struct file *file)
383{
384 struct seq_file *m = file->private_data;
385 struct rpc_clnt *clnt = (struct rpc_clnt *)m->private;
386
387 if (clnt)
388 rpc_release_client(clnt);
389 return single_release(inode, file);
390}
391
Arjan van de Venda7071d2007-02-12 00:55:36 -0800392static const struct file_operations rpc_info_operations = {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700393 .owner = THIS_MODULE,
394 .open = rpc_info_open,
395 .read = seq_read,
396 .llseek = seq_lseek,
397 .release = rpc_info_release,
398};
399
400
401/*
Linus Torvalds1da177e2005-04-16 15:20:36 -0700402 * Description of fs contents.
403 */
404struct rpc_filelist {
Trond Myklebustac6fece2009-08-09 15:14:20 -0400405 const char *name;
Arjan van de Ven99ac48f2006-03-28 01:56:41 -0800406 const struct file_operations *i_fop;
Trond Myklebust7364af62009-08-09 15:14:16 -0400407 umode_t mode;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700408};
409
Trond Myklebust54281542006-03-20 13:44:49 -0500410struct vfsmount *rpc_get_mount(void)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700411{
Trond Myklebust54281542006-03-20 13:44:49 -0500412 int err;
413
Trond Myklebust1f5ce9e2006-06-09 09:34:16 -0400414 err = simple_pin_fs(&rpc_pipe_fs_type, &rpc_mount, &rpc_mount_count);
Trond Myklebust54281542006-03-20 13:44:49 -0500415 if (err != 0)
416 return ERR_PTR(err);
417 return rpc_mount;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700418}
Trond Myklebuste571cbf2009-08-19 18:12:27 -0400419EXPORT_SYMBOL_GPL(rpc_get_mount);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700420
Trond Myklebust54281542006-03-20 13:44:49 -0500421void rpc_put_mount(void)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700422{
423 simple_release_fs(&rpc_mount, &rpc_mount_count);
424}
Trond Myklebuste571cbf2009-08-19 18:12:27 -0400425EXPORT_SYMBOL_GPL(rpc_put_mount);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700426
Trond Myklebust62e17612007-06-08 14:14:46 -0400427static int rpc_delete_dentry(struct dentry *dentry)
428{
429 return 1;
430}
431
Al Viro3ba13d12009-02-20 06:02:22 +0000432static const struct dentry_operations rpc_dentry_operations = {
Trond Myklebust62e17612007-06-08 14:14:46 -0400433 .d_delete = rpc_delete_dentry,
434};
435
Linus Torvalds1da177e2005-04-16 15:20:36 -0700436static struct inode *
Trond Myklebust7364af62009-08-09 15:14:16 -0400437rpc_get_inode(struct super_block *sb, umode_t mode)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700438{
439 struct inode *inode = new_inode(sb);
440 if (!inode)
441 return NULL;
442 inode->i_mode = mode;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700443 inode->i_atime = inode->i_mtime = inode->i_ctime = CURRENT_TIME;
444 switch(mode & S_IFMT) {
445 case S_IFDIR:
446 inode->i_fop = &simple_dir_operations;
447 inode->i_op = &simple_dir_inode_operations;
Dave Hansend8c76e62006-09-30 23:29:04 -0700448 inc_nlink(inode);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700449 default:
450 break;
451 }
452 return inode;
453}
454
Trond Myklebust75898062009-08-09 15:14:17 -0400455static int __rpc_create_common(struct inode *dir, struct dentry *dentry,
456 umode_t mode,
457 const struct file_operations *i_fop,
458 void *private)
459{
460 struct inode *inode;
461
462 BUG_ON(!d_unhashed(dentry));
463 inode = rpc_get_inode(dir->i_sb, mode);
464 if (!inode)
465 goto out_err;
466 inode->i_ino = iunique(dir->i_sb, 100);
467 if (i_fop)
468 inode->i_fop = i_fop;
469 if (private)
470 rpc_inode_setowner(inode, private);
471 d_add(dentry, inode);
472 return 0;
473out_err:
474 printk(KERN_WARNING "%s: %s failed to allocate inode for dentry %s\n",
475 __FILE__, __func__, dentry->d_name.name);
476 dput(dentry);
477 return -ENOMEM;
478}
479
Trond Myklebustac6fece2009-08-09 15:14:20 -0400480static int __rpc_create(struct inode *dir, struct dentry *dentry,
481 umode_t mode,
482 const struct file_operations *i_fop,
483 void *private)
484{
485 int err;
486
487 err = __rpc_create_common(dir, dentry, S_IFREG | mode, i_fop, private);
488 if (err)
489 return err;
490 fsnotify_create(dir, dentry);
491 return 0;
492}
493
Trond Myklebust75898062009-08-09 15:14:17 -0400494static int __rpc_mkdir(struct inode *dir, struct dentry *dentry,
495 umode_t mode,
496 const struct file_operations *i_fop,
497 void *private)
498{
499 int err;
500
501 err = __rpc_create_common(dir, dentry, S_IFDIR | mode, i_fop, private);
502 if (err)
503 return err;
504 inc_nlink(dir);
505 fsnotify_mkdir(dir, dentry);
506 return 0;
507}
508
509static int __rpc_mkpipe(struct inode *dir, struct dentry *dentry,
510 umode_t mode,
511 const struct file_operations *i_fop,
512 void *private,
513 const struct rpc_pipe_ops *ops,
514 int flags)
515{
516 struct rpc_inode *rpci;
517 int err;
518
519 err = __rpc_create_common(dir, dentry, S_IFIFO | mode, i_fop, private);
520 if (err)
521 return err;
522 rpci = RPC_I(dentry->d_inode);
523 rpci->nkern_readwriters = 1;
524 rpci->private = private;
525 rpci->flags = flags;
526 rpci->ops = ops;
527 fsnotify_create(dir, dentry);
528 return 0;
529}
530
Trond Myklebustac6fece2009-08-09 15:14:20 -0400531static int __rpc_rmdir(struct inode *dir, struct dentry *dentry)
532{
533 int ret;
534
535 dget(dentry);
536 ret = simple_rmdir(dir, dentry);
537 d_delete(dentry);
538 dput(dentry);
539 return ret;
540}
541
Trond Myklebust810d90b2009-08-09 15:14:18 -0400542static int __rpc_unlink(struct inode *dir, struct dentry *dentry)
543{
544 int ret;
545
546 dget(dentry);
547 ret = simple_unlink(dir, dentry);
548 d_delete(dentry);
549 dput(dentry);
550 return ret;
551}
552
553static int __rpc_rmpipe(struct inode *dir, struct dentry *dentry)
554{
555 struct inode *inode = dentry->d_inode;
556 struct rpc_inode *rpci = RPC_I(inode);
557
558 rpci->nkern_readwriters--;
559 if (rpci->nkern_readwriters != 0)
560 return 0;
561 rpc_close_pipes(inode);
562 return __rpc_unlink(dir, dentry);
563}
564
Trond Myklebustcfeaa4a2009-08-09 15:14:20 -0400565static struct dentry *__rpc_lookup_create(struct dentry *parent,
566 struct qstr *name)
567{
568 struct dentry *dentry;
569
570 dentry = d_lookup(parent, name);
571 if (!dentry) {
572 dentry = d_alloc(parent, name);
573 if (!dentry) {
574 dentry = ERR_PTR(-ENOMEM);
575 goto out_err;
576 }
577 }
578 if (!dentry->d_inode)
579 dentry->d_op = &rpc_dentry_operations;
580out_err:
581 return dentry;
582}
583
584static struct dentry *__rpc_lookup_create_exclusive(struct dentry *parent,
585 struct qstr *name)
586{
587 struct dentry *dentry;
588
589 dentry = __rpc_lookup_create(parent, name);
590 if (dentry->d_inode == NULL)
591 return dentry;
592 dput(dentry);
593 return ERR_PTR(-EEXIST);
594}
595
Linus Torvalds1da177e2005-04-16 15:20:36 -0700596/*
597 * FIXME: This probably has races.
598 */
Trond Myklebustac6fece2009-08-09 15:14:20 -0400599static void __rpc_depopulate(struct dentry *parent,
600 const struct rpc_filelist *files,
601 int start, int eof)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700602{
603 struct inode *dir = parent->d_inode;
Trond Myklebustac6fece2009-08-09 15:14:20 -0400604 struct dentry *dentry;
605 struct qstr name;
606 int i;
607
608 for (i = start; i < eof; i++) {
609 name.name = files[i].name;
610 name.len = strlen(files[i].name);
611 name.hash = full_name_hash(name.name, name.len);
612 dentry = d_lookup(parent, &name);
613
614 if (dentry == NULL)
615 continue;
616 if (dentry->d_inode == NULL)
617 goto next;
618 switch (dentry->d_inode->i_mode & S_IFMT) {
619 default:
620 BUG();
621 case S_IFREG:
622 __rpc_unlink(dir, dentry);
623 break;
624 case S_IFDIR:
625 __rpc_rmdir(dir, dentry);
626 }
627next:
628 dput(dentry);
629 }
630}
631
632static void rpc_depopulate(struct dentry *parent,
633 const struct rpc_filelist *files,
634 int start, int eof)
635{
636 struct inode *dir = parent->d_inode;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700637
Arjan van de Venc6573c22006-07-03 00:25:16 -0700638 mutex_lock_nested(&dir->i_mutex, I_MUTEX_CHILD);
Trond Myklebustac6fece2009-08-09 15:14:20 -0400639 __rpc_depopulate(parent, files, start, eof);
Jes Sorensen1b1dcc12006-01-09 15:59:24 -0800640 mutex_unlock(&dir->i_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700641}
642
Trond Myklebustac6fece2009-08-09 15:14:20 -0400643static int rpc_populate(struct dentry *parent,
644 const struct rpc_filelist *files,
645 int start, int eof,
646 void *private)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700647{
Trond Myklebustac6fece2009-08-09 15:14:20 -0400648 struct inode *dir = parent->d_inode;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700649 struct dentry *dentry;
Trond Myklebustac6fece2009-08-09 15:14:20 -0400650 int i, err;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700651
Jes Sorensen1b1dcc12006-01-09 15:59:24 -0800652 mutex_lock(&dir->i_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700653 for (i = start; i < eof; i++) {
Trond Myklebustac6fece2009-08-09 15:14:20 -0400654 struct qstr q;
655
656 q.name = files[i].name;
657 q.len = strlen(files[i].name);
658 q.hash = full_name_hash(q.name, q.len);
659 dentry = __rpc_lookup_create_exclusive(parent, &q);
660 err = PTR_ERR(dentry);
661 if (IS_ERR(dentry))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700662 goto out_bad;
Trond Myklebustac6fece2009-08-09 15:14:20 -0400663 switch (files[i].mode & S_IFMT) {
664 default:
665 BUG();
666 case S_IFREG:
667 err = __rpc_create(dir, dentry,
668 files[i].mode,
669 files[i].i_fop,
670 private);
671 break;
672 case S_IFDIR:
673 err = __rpc_mkdir(dir, dentry,
674 files[i].mode,
675 NULL,
676 private);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700677 }
Trond Myklebustac6fece2009-08-09 15:14:20 -0400678 if (err != 0)
679 goto out_bad;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700680 }
Jes Sorensen1b1dcc12006-01-09 15:59:24 -0800681 mutex_unlock(&dir->i_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700682 return 0;
683out_bad:
Trond Myklebustac6fece2009-08-09 15:14:20 -0400684 __rpc_depopulate(parent, files, start, eof);
Jes Sorensen1b1dcc12006-01-09 15:59:24 -0800685 mutex_unlock(&dir->i_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700686 printk(KERN_WARNING "%s: %s failed to populate directory %s\n",
Harvey Harrison0dc47872008-03-05 20:47:47 -0800687 __FILE__, __func__, parent->d_name.name);
Trond Myklebustac6fece2009-08-09 15:14:20 -0400688 return err;
Trond Myklebustf1345852005-09-23 11:08:25 -0400689}
Christoph Hellwig278c9952005-07-24 23:53:01 +0100690
Trond Myklebuste57aed72009-08-09 15:14:26 -0400691static struct dentry *rpc_mkdir_populate(struct dentry *parent,
692 struct qstr *name, umode_t mode, void *private,
693 int (*populate)(struct dentry *, void *), void *args_populate)
Trond Myklebustf1345852005-09-23 11:08:25 -0400694{
Trond Myklebustf1345852005-09-23 11:08:25 -0400695 struct dentry *dentry;
Trond Myklebust7d59d1e2009-08-09 15:14:23 -0400696 struct inode *dir = parent->d_inode;
Trond Myklebustf1345852005-09-23 11:08:25 -0400697 int error;
698
Trond Myklebust7d59d1e2009-08-09 15:14:23 -0400699 mutex_lock_nested(&dir->i_mutex, I_MUTEX_PARENT);
700 dentry = __rpc_lookup_create_exclusive(parent, name);
Trond Myklebustf1345852005-09-23 11:08:25 -0400701 if (IS_ERR(dentry))
Trond Myklebust7d59d1e2009-08-09 15:14:23 -0400702 goto out;
703 error = __rpc_mkdir(dir, dentry, mode, NULL, private);
Trond Myklebust75898062009-08-09 15:14:17 -0400704 if (error != 0)
705 goto out_err;
Trond Myklebuste57aed72009-08-09 15:14:26 -0400706 if (populate != NULL) {
707 error = populate(dentry, args_populate);
708 if (error)
709 goto err_rmdir;
710 }
Trond Myklebustf1345852005-09-23 11:08:25 -0400711out:
Jes Sorensen1b1dcc12006-01-09 15:59:24 -0800712 mutex_unlock(&dir->i_mutex);
Trond Myklebust5c3e9852006-07-29 17:37:40 -0400713 return dentry;
Trond Myklebustac6fece2009-08-09 15:14:20 -0400714err_rmdir:
Trond Myklebustf1345852005-09-23 11:08:25 -0400715 __rpc_rmdir(dir, dentry);
Trond Myklebust75898062009-08-09 15:14:17 -0400716out_err:
Trond Myklebustf1345852005-09-23 11:08:25 -0400717 dentry = ERR_PTR(error);
718 goto out;
719}
720
Trond Myklebuste57aed72009-08-09 15:14:26 -0400721static int rpc_rmdir_depopulate(struct dentry *dentry,
722 void (*depopulate)(struct dentry *))
Trond Myklebustf1345852005-09-23 11:08:25 -0400723{
Trond Myklebustdff02cc2006-07-31 14:17:18 -0700724 struct dentry *parent;
Trond Myklebustf1345852005-09-23 11:08:25 -0400725 struct inode *dir;
726 int error;
727
Trond Myklebustdff02cc2006-07-31 14:17:18 -0700728 parent = dget_parent(dentry);
729 dir = parent->d_inode;
Arjan van de Venc6573c22006-07-03 00:25:16 -0700730 mutex_lock_nested(&dir->i_mutex, I_MUTEX_PARENT);
Trond Myklebuste57aed72009-08-09 15:14:26 -0400731 if (depopulate != NULL)
732 depopulate(dentry);
Trond Myklebustf1345852005-09-23 11:08:25 -0400733 error = __rpc_rmdir(dir, dentry);
Jes Sorensen1b1dcc12006-01-09 15:59:24 -0800734 mutex_unlock(&dir->i_mutex);
Trond Myklebustdff02cc2006-07-31 14:17:18 -0700735 dput(parent);
Trond Myklebustf1345852005-09-23 11:08:25 -0400736 return error;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700737}
738
J. Bruce Fields93a44a72007-11-06 13:06:03 -0500739/**
740 * rpc_mkpipe - make an rpc_pipefs file for kernel<->userspace communication
741 * @parent: dentry of directory to create new "pipe" in
742 * @name: name of pipe
743 * @private: private data to associate with the pipe, for the caller's use
744 * @ops: operations defining the behavior of the pipe: upcall, downcall,
\"J. Bruce Fields\c3810602008-12-23 16:08:32 -0500745 * release_pipe, open_pipe, and destroy_msg.
Randy Dunlap65b6e422008-02-13 15:03:23 -0800746 * @flags: rpc_inode flags
J. Bruce Fields93a44a72007-11-06 13:06:03 -0500747 *
748 * Data is made available for userspace to read by calls to
749 * rpc_queue_upcall(). The actual reads will result in calls to
750 * @ops->upcall, which will be called with the file pointer,
751 * message, and userspace buffer to copy to.
752 *
753 * Writes can come at any time, and do not necessarily have to be
754 * responses to upcalls. They will result in calls to @msg->downcall.
755 *
756 * The @private argument passed here will be available to all these methods
757 * from the file pointer, via RPC_I(file->f_dentry->d_inode)->private.
758 */
Trond Myklebustb693ba42009-08-09 15:14:15 -0400759struct dentry *rpc_mkpipe(struct dentry *parent, const char *name,
760 void *private, const struct rpc_pipe_ops *ops,
761 int flags)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700762{
Linus Torvalds1da177e2005-04-16 15:20:36 -0700763 struct dentry *dentry;
Trond Myklebust75898062009-08-09 15:14:17 -0400764 struct inode *dir = parent->d_inode;
Trond Myklebust7364af62009-08-09 15:14:16 -0400765 umode_t umode = S_IFIFO | S_IRUSR | S_IWUSR;
Trond Myklebustcfeaa4a2009-08-09 15:14:20 -0400766 struct qstr q;
Trond Myklebust75898062009-08-09 15:14:17 -0400767 int err;
Trond Myklebust7364af62009-08-09 15:14:16 -0400768
769 if (ops->upcall == NULL)
770 umode &= ~S_IRUGO;
771 if (ops->downcall == NULL)
772 umode &= ~S_IWUGO;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700773
Trond Myklebustcfeaa4a2009-08-09 15:14:20 -0400774 q.name = name;
775 q.len = strlen(name);
776 q.hash = full_name_hash(q.name, q.len),
777
778 mutex_lock_nested(&dir->i_mutex, I_MUTEX_PARENT);
779 dentry = __rpc_lookup_create(parent, &q);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700780 if (IS_ERR(dentry))
Trond Myklebustcfeaa4a2009-08-09 15:14:20 -0400781 goto out;
Trond Myklebust34f30892007-06-07 18:28:02 -0400782 if (dentry->d_inode) {
Trond Myklebust75898062009-08-09 15:14:17 -0400783 struct rpc_inode *rpci = RPC_I(dentry->d_inode);
Trond Myklebust34f30892007-06-07 18:28:02 -0400784 if (rpci->private != private ||
785 rpci->ops != ops ||
786 rpci->flags != flags) {
787 dput (dentry);
Trond Myklebust810d90b2009-08-09 15:14:18 -0400788 err = -EBUSY;
789 goto out_err;
Trond Myklebust34f30892007-06-07 18:28:02 -0400790 }
Trond Myklebust03a12562007-06-08 14:14:53 -0400791 rpci->nkern_readwriters++;
Trond Myklebust34f30892007-06-07 18:28:02 -0400792 goto out;
793 }
Trond Myklebust75898062009-08-09 15:14:17 -0400794
795 err = __rpc_mkpipe(dir, dentry, umode, &rpc_pipe_fops,
Trond Myklebust810d90b2009-08-09 15:14:18 -0400796 private, ops, flags);
Trond Myklebust75898062009-08-09 15:14:17 -0400797 if (err)
798 goto out_err;
Trond Myklebustf1345852005-09-23 11:08:25 -0400799out:
Jes Sorensen1b1dcc12006-01-09 15:59:24 -0800800 mutex_unlock(&dir->i_mutex);
Trond Myklebust5c3e9852006-07-29 17:37:40 -0400801 return dentry;
Trond Myklebust75898062009-08-09 15:14:17 -0400802out_err:
803 dentry = ERR_PTR(err);
Trond Myklebust158998b2006-08-24 01:03:17 -0400804 printk(KERN_WARNING "%s: %s() failed to create pipe %s/%s (errno = %d)\n",
Harvey Harrison0dc47872008-03-05 20:47:47 -0800805 __FILE__, __func__, parent->d_name.name, name,
Trond Myklebust75898062009-08-09 15:14:17 -0400806 err);
Trond Myklebustf1345852005-09-23 11:08:25 -0400807 goto out;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700808}
Trond Myklebust468039e2008-12-23 15:21:31 -0500809EXPORT_SYMBOL_GPL(rpc_mkpipe);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700810
J. Bruce Fields93a44a72007-11-06 13:06:03 -0500811/**
812 * rpc_unlink - remove a pipe
813 * @dentry: dentry for the pipe, as returned from rpc_mkpipe
814 *
815 * After this call, lookups will no longer find the pipe, and any
816 * attempts to read or write using preexisting opens of the pipe will
817 * return -EPIPE.
818 */
Trond Myklebustf1345852005-09-23 11:08:25 -0400819int
Trond Myklebust5d674762006-07-31 14:11:48 -0700820rpc_unlink(struct dentry *dentry)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700821{
Trond Myklebust5d674762006-07-31 14:11:48 -0700822 struct dentry *parent;
Trond Myklebustf1345852005-09-23 11:08:25 -0400823 struct inode *dir;
Trond Myklebust5d674762006-07-31 14:11:48 -0700824 int error = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700825
Trond Myklebust5d674762006-07-31 14:11:48 -0700826 parent = dget_parent(dentry);
827 dir = parent->d_inode;
Arjan van de Venc6573c22006-07-03 00:25:16 -0700828 mutex_lock_nested(&dir->i_mutex, I_MUTEX_PARENT);
Trond Myklebust810d90b2009-08-09 15:14:18 -0400829 error = __rpc_rmpipe(dir, dentry);
Jes Sorensen1b1dcc12006-01-09 15:59:24 -0800830 mutex_unlock(&dir->i_mutex);
Trond Myklebust5d674762006-07-31 14:11:48 -0700831 dput(parent);
Trond Myklebustf1345852005-09-23 11:08:25 -0400832 return error;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700833}
Trond Myklebust468039e2008-12-23 15:21:31 -0500834EXPORT_SYMBOL_GPL(rpc_unlink);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700835
Trond Myklebuste57aed72009-08-09 15:14:26 -0400836enum {
837 RPCAUTH_info,
838 RPCAUTH_EOF
839};
840
841static const struct rpc_filelist authfiles[] = {
842 [RPCAUTH_info] = {
843 .name = "info",
844 .i_fop = &rpc_info_operations,
845 .mode = S_IFREG | S_IRUSR,
846 },
847};
848
849static int rpc_clntdir_populate(struct dentry *dentry, void *private)
850{
851 return rpc_populate(dentry,
852 authfiles, RPCAUTH_info, RPCAUTH_EOF,
853 private);
854}
855
856static void rpc_clntdir_depopulate(struct dentry *dentry)
857{
858 rpc_depopulate(dentry, authfiles, RPCAUTH_info, RPCAUTH_EOF);
859}
860
Trond Myklebust7d59d1e2009-08-09 15:14:23 -0400861/**
862 * rpc_create_client_dir - Create a new rpc_client directory in rpc_pipefs
Randy Dunlap4111d4f2009-09-23 14:36:38 -0400863 * @dentry: dentry from the rpc_pipefs root to the new directory
864 * @name: &struct qstr for the name
Trond Myklebust7d59d1e2009-08-09 15:14:23 -0400865 * @rpc_client: rpc client to associate with this directory
866 *
867 * This creates a directory at the given @path associated with
868 * @rpc_clnt, which will contain a file named "info" with some basic
869 * information about the client, together with any "pipes" that may
870 * later be created using rpc_mkpipe().
871 */
Trond Myklebust23ac6582009-08-09 15:14:25 -0400872struct dentry *rpc_create_client_dir(struct dentry *dentry,
Trond Myklebuste57aed72009-08-09 15:14:26 -0400873 struct qstr *name,
874 struct rpc_clnt *rpc_client)
Trond Myklebust7d59d1e2009-08-09 15:14:23 -0400875{
Trond Myklebuste57aed72009-08-09 15:14:26 -0400876 return rpc_mkdir_populate(dentry, name, S_IRUGO | S_IXUGO, NULL,
877 rpc_clntdir_populate, rpc_client);
878}
879
880/**
881 * rpc_remove_client_dir - Remove a directory created with rpc_create_client_dir()
882 * @dentry: directory to remove
883 */
884int rpc_remove_client_dir(struct dentry *dentry)
885{
886 return rpc_rmdir_depopulate(dentry, rpc_clntdir_depopulate);
Trond Myklebust7d59d1e2009-08-09 15:14:23 -0400887}
888
Trond Myklebust8854e822009-08-09 15:14:30 -0400889static const struct rpc_filelist cache_pipefs_files[3] = {
890 [0] = {
891 .name = "channel",
892 .i_fop = &cache_file_operations_pipefs,
Trond Myklebust96c61cb2009-08-19 18:12:21 -0400893 .mode = S_IFREG|S_IRUSR|S_IWUSR,
Trond Myklebust8854e822009-08-09 15:14:30 -0400894 },
895 [1] = {
896 .name = "content",
897 .i_fop = &content_file_operations_pipefs,
898 .mode = S_IFREG|S_IRUSR,
899 },
900 [2] = {
901 .name = "flush",
902 .i_fop = &cache_flush_operations_pipefs,
903 .mode = S_IFREG|S_IRUSR|S_IWUSR,
904 },
905};
906
907static int rpc_cachedir_populate(struct dentry *dentry, void *private)
908{
909 return rpc_populate(dentry,
910 cache_pipefs_files, 0, 3,
911 private);
912}
913
914static void rpc_cachedir_depopulate(struct dentry *dentry)
915{
916 rpc_depopulate(dentry, cache_pipefs_files, 0, 3);
917}
918
919struct dentry *rpc_create_cache_dir(struct dentry *parent, struct qstr *name,
920 mode_t umode, struct cache_detail *cd)
921{
922 return rpc_mkdir_populate(parent, name, umode, NULL,
923 rpc_cachedir_populate, cd);
924}
925
926void rpc_remove_cache_dir(struct dentry *dentry)
927{
928 rpc_rmdir_depopulate(dentry, rpc_cachedir_depopulate);
929}
930
Linus Torvalds1da177e2005-04-16 15:20:36 -0700931/*
932 * populate the filesystem
933 */
Alexey Dobriyanb87221d2009-09-21 17:01:09 -0700934static const struct super_operations s_ops = {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700935 .alloc_inode = rpc_alloc_inode,
936 .destroy_inode = rpc_destroy_inode,
937 .statfs = simple_statfs,
938};
939
940#define RPCAUTH_GSSMAGIC 0x67596969
941
Trond Myklebustbb156742009-08-09 15:14:21 -0400942/*
943 * We have a single directory with 1 node in it.
944 */
945enum {
946 RPCAUTH_lockd,
947 RPCAUTH_mount,
948 RPCAUTH_nfs,
949 RPCAUTH_portmap,
950 RPCAUTH_statd,
951 RPCAUTH_nfsd4_cb,
Trond Myklebuste571cbf2009-08-19 18:12:27 -0400952 RPCAUTH_cache,
Trond Myklebustbb156742009-08-09 15:14:21 -0400953 RPCAUTH_RootEOF
954};
955
956static const struct rpc_filelist files[] = {
957 [RPCAUTH_lockd] = {
958 .name = "lockd",
959 .mode = S_IFDIR | S_IRUGO | S_IXUGO,
960 },
961 [RPCAUTH_mount] = {
962 .name = "mount",
963 .mode = S_IFDIR | S_IRUGO | S_IXUGO,
964 },
965 [RPCAUTH_nfs] = {
966 .name = "nfs",
967 .mode = S_IFDIR | S_IRUGO | S_IXUGO,
968 },
969 [RPCAUTH_portmap] = {
970 .name = "portmap",
971 .mode = S_IFDIR | S_IRUGO | S_IXUGO,
972 },
973 [RPCAUTH_statd] = {
974 .name = "statd",
975 .mode = S_IFDIR | S_IRUGO | S_IXUGO,
976 },
977 [RPCAUTH_nfsd4_cb] = {
978 .name = "nfsd4_cb",
979 .mode = S_IFDIR | S_IRUGO | S_IXUGO,
980 },
Trond Myklebuste571cbf2009-08-19 18:12:27 -0400981 [RPCAUTH_cache] = {
982 .name = "cache",
983 .mode = S_IFDIR | S_IRUGO | S_IXUGO,
984 },
Trond Myklebustbb156742009-08-09 15:14:21 -0400985};
986
Linus Torvalds1da177e2005-04-16 15:20:36 -0700987static int
988rpc_fill_super(struct super_block *sb, void *data, int silent)
989{
990 struct inode *inode;
991 struct dentry *root;
992
993 sb->s_blocksize = PAGE_CACHE_SIZE;
994 sb->s_blocksize_bits = PAGE_CACHE_SHIFT;
995 sb->s_magic = RPCAUTH_GSSMAGIC;
996 sb->s_op = &s_ops;
997 sb->s_time_gran = 1;
998
999 inode = rpc_get_inode(sb, S_IFDIR | 0755);
1000 if (!inode)
1001 return -ENOMEM;
1002 root = d_alloc_root(inode);
1003 if (!root) {
1004 iput(inode);
1005 return -ENOMEM;
1006 }
Trond Myklebustac6fece2009-08-09 15:14:20 -04001007 if (rpc_populate(root, files, RPCAUTH_lockd, RPCAUTH_RootEOF, NULL))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001008 goto out;
1009 sb->s_root = root;
1010 return 0;
1011out:
1012 d_genocide(root);
1013 dput(root);
1014 return -ENOMEM;
1015}
1016
David Howells454e2392006-06-23 02:02:57 -07001017static int
Linus Torvalds1da177e2005-04-16 15:20:36 -07001018rpc_get_sb(struct file_system_type *fs_type,
David Howells454e2392006-06-23 02:02:57 -07001019 int flags, const char *dev_name, void *data, struct vfsmount *mnt)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001020{
David Howells454e2392006-06-23 02:02:57 -07001021 return get_sb_single(fs_type, flags, data, rpc_fill_super, mnt);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001022}
1023
1024static struct file_system_type rpc_pipe_fs_type = {
1025 .owner = THIS_MODULE,
1026 .name = "rpc_pipefs",
1027 .get_sb = rpc_get_sb,
1028 .kill_sb = kill_litter_super,
1029};
1030
1031static void
Alexey Dobriyan51cc5062008-07-25 19:45:34 -07001032init_once(void *foo)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001033{
1034 struct rpc_inode *rpci = (struct rpc_inode *) foo;
1035
Christoph Lametera35afb82007-05-16 22:10:57 -07001036 inode_init_once(&rpci->vfs_inode);
1037 rpci->private = NULL;
1038 rpci->nreaders = 0;
1039 rpci->nwriters = 0;
1040 INIT_LIST_HEAD(&rpci->in_upcall);
Trond Myklebust6e84c7b2007-06-07 15:31:36 -04001041 INIT_LIST_HEAD(&rpci->in_downcall);
Christoph Lametera35afb82007-05-16 22:10:57 -07001042 INIT_LIST_HEAD(&rpci->pipe);
1043 rpci->pipelen = 0;
1044 init_waitqueue_head(&rpci->waitq);
1045 INIT_DELAYED_WORK(&rpci->queue_timeout,
1046 rpc_timeout_upcall_queue);
1047 rpci->ops = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001048}
1049
1050int register_rpc_pipefs(void)
1051{
Akinobu Mita5bd5f582007-05-09 02:34:51 -07001052 int err;
1053
Linus Torvalds1da177e2005-04-16 15:20:36 -07001054 rpc_inode_cachep = kmem_cache_create("rpc_inode_cache",
Paul Jacksonfffb60f2006-03-24 03:16:06 -08001055 sizeof(struct rpc_inode),
1056 0, (SLAB_HWCACHE_ALIGN|SLAB_RECLAIM_ACCOUNT|
1057 SLAB_MEM_SPREAD),
Paul Mundt20c2df82007-07-20 10:11:58 +09001058 init_once);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001059 if (!rpc_inode_cachep)
1060 return -ENOMEM;
Akinobu Mita5bd5f582007-05-09 02:34:51 -07001061 err = register_filesystem(&rpc_pipe_fs_type);
1062 if (err) {
1063 kmem_cache_destroy(rpc_inode_cachep);
1064 return err;
1065 }
1066
Linus Torvalds1da177e2005-04-16 15:20:36 -07001067 return 0;
1068}
1069
1070void unregister_rpc_pipefs(void)
1071{
Alexey Dobriyan1a1d92c2006-09-27 01:49:40 -07001072 kmem_cache_destroy(rpc_inode_cachep);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001073 unregister_filesystem(&rpc_pipe_fs_type);
1074}