blob: a9129f8d70706f5e33ac8f39cb3ea8a3e5825ca2 [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>
Trond Myklebust2446ab62012-03-01 17:00:56 -050019#include <linux/rcupdate.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070020
21#include <asm/ioctls.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070022#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>
Stanislav Kinsbursky021c68d2011-12-26 15:39:04 +030030#include <linux/nsproxy.h>
Stanislav Kinsbursky2d001312011-12-26 15:39:13 +030031#include <linux/notifier.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070032
Stanislav Kinsbursky021c68d2011-12-26 15:39:04 +030033#include "netns.h"
Stanislav Kinsbursky2d001312011-12-26 15:39:13 +030034#include "sunrpc.h"
Linus Torvalds1da177e2005-04-16 15:20:36 -070035
Stanislav Kinsburskyefc46bf2011-12-26 15:39:47 +030036#define RPCDBG_FACILITY RPCDBG_DEBUG
37
38#define NET_NAME(net) ((net == &init_net) ? " (init_net)" : "")
Linus Torvalds1da177e2005-04-16 15:20:36 -070039
40static struct file_system_type rpc_pipe_fs_type;
41
42
Christoph Lametere18b8902006-12-06 20:33:20 -080043static struct kmem_cache *rpc_inode_cachep __read_mostly;
Linus Torvalds1da177e2005-04-16 15:20:36 -070044
45#define RPC_UPCALL_TIMEOUT (30*HZ)
46
Stanislav Kinsbursky2d001312011-12-26 15:39:13 +030047static BLOCKING_NOTIFIER_HEAD(rpc_pipefs_notifier_list);
48
49int rpc_pipefs_notifier_register(struct notifier_block *nb)
50{
51 return blocking_notifier_chain_cond_register(&rpc_pipefs_notifier_list, nb);
52}
53EXPORT_SYMBOL_GPL(rpc_pipefs_notifier_register);
54
55void rpc_pipefs_notifier_unregister(struct notifier_block *nb)
56{
57 blocking_notifier_chain_unregister(&rpc_pipefs_notifier_list, nb);
58}
59EXPORT_SYMBOL_GPL(rpc_pipefs_notifier_unregister);
60
Stanislav Kinsbursky591ad7f2012-02-27 22:05:54 +040061static void rpc_purge_list(wait_queue_head_t *waitq, struct list_head *head,
Trond Myklebust9842ef32006-02-01 12:18:44 -050062 void (*destroy_msg)(struct rpc_pipe_msg *), int err)
Trond Myklebustb3eb67a2005-11-25 17:10:11 -050063{
64 struct rpc_pipe_msg *msg;
Trond Myklebustb3eb67a2005-11-25 17:10:11 -050065
Trond Myklebust9842ef32006-02-01 12:18:44 -050066 if (list_empty(head))
67 return;
68 do {
Trond Myklebustb3eb67a2005-11-25 17:10:11 -050069 msg = list_entry(head->next, struct rpc_pipe_msg, list);
Trond Myklebust5a676572010-09-12 19:55:25 -040070 list_del_init(&msg->list);
Trond Myklebustb3eb67a2005-11-25 17:10:11 -050071 msg->errno = err;
72 destroy_msg(msg);
Trond Myklebust9842ef32006-02-01 12:18:44 -050073 } while (!list_empty(head));
Jeff Layton92123e02012-06-11 10:03:42 -040074
75 if (waitq)
76 wake_up(waitq);
Linus Torvalds1da177e2005-04-16 15:20:36 -070077}
78
79static void
David Howells65f27f32006-11-22 14:55:48 +000080rpc_timeout_upcall_queue(struct work_struct *work)
Linus Torvalds1da177e2005-04-16 15:20:36 -070081{
Trond Myklebust9842ef32006-02-01 12:18:44 -050082 LIST_HEAD(free_list);
Stanislav Kinsburskyba9e0972011-12-26 15:43:32 +030083 struct rpc_pipe *pipe =
84 container_of(work, struct rpc_pipe, queue_timeout.work);
Trond Myklebust9842ef32006-02-01 12:18:44 -050085 void (*destroy_msg)(struct rpc_pipe_msg *);
Stanislav Kinsbursky591ad7f2012-02-27 22:05:54 +040086 struct dentry *dentry;
Linus Torvalds1da177e2005-04-16 15:20:36 -070087
Stanislav Kinsburskyba9e0972011-12-26 15:43:32 +030088 spin_lock(&pipe->lock);
Stanislav Kinsburskyba9e0972011-12-26 15:43:32 +030089 destroy_msg = pipe->ops->destroy_msg;
90 if (pipe->nreaders == 0) {
91 list_splice_init(&pipe->pipe, &free_list);
92 pipe->pipelen = 0;
Trond Myklebust9842ef32006-02-01 12:18:44 -050093 }
Stanislav Kinsbursky591ad7f2012-02-27 22:05:54 +040094 dentry = dget(pipe->dentry);
Stanislav Kinsburskyba9e0972011-12-26 15:43:32 +030095 spin_unlock(&pipe->lock);
Jeff Layton92123e02012-06-11 10:03:42 -040096 rpc_purge_list(dentry ? &RPC_I(dentry->d_inode)->waitq : NULL,
97 &free_list, destroy_msg, -ETIMEDOUT);
98 dput(dentry);
Linus Torvalds1da177e2005-04-16 15:20:36 -070099}
100
Peng Taoc1225152011-09-22 21:50:10 -0400101ssize_t rpc_pipe_generic_upcall(struct file *filp, struct rpc_pipe_msg *msg,
102 char __user *dst, size_t buflen)
103{
104 char *data = (char *)msg->data + msg->copied;
105 size_t mlen = min(msg->len - msg->copied, buflen);
106 unsigned long left;
107
108 left = copy_to_user(dst, data, mlen);
109 if (left == mlen) {
110 msg->errno = -EFAULT;
111 return -EFAULT;
112 }
113
114 mlen -= left;
115 msg->copied += mlen;
116 msg->errno = 0;
117 return mlen;
118}
119EXPORT_SYMBOL_GPL(rpc_pipe_generic_upcall);
120
J. Bruce Fields93a44a72007-11-06 13:06:03 -0500121/**
Ben Hutchings1a5778a2010-02-14 22:35:47 -0800122 * rpc_queue_upcall - queue an upcall message to userspace
Randy Dunlapbda14602012-05-13 10:35:40 -0700123 * @pipe: upcall pipe on which to queue given message
J. Bruce Fields93a44a72007-11-06 13:06:03 -0500124 * @msg: message to queue
125 *
126 * Call with an @inode created by rpc_mkpipe() to queue an upcall.
127 * A userspace process may then later read the upcall by performing a
128 * read on an open file for this inode. It is up to the caller to
129 * initialize the fields of @msg (other than @msg->list) appropriately.
130 */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700131int
Stanislav Kinsburskyd706ed12011-12-26 15:43:49 +0300132rpc_queue_upcall(struct rpc_pipe *pipe, struct rpc_pipe_msg *msg)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700133{
Trond Myklebust6070fe62005-10-27 22:12:46 -0400134 int res = -EPIPE;
Stanislav Kinsbursky591ad7f2012-02-27 22:05:54 +0400135 struct dentry *dentry;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700136
Stanislav Kinsburskyd0fe13b2011-12-26 15:43:41 +0300137 spin_lock(&pipe->lock);
Stanislav Kinsburskyd0fe13b2011-12-26 15:43:41 +0300138 if (pipe->nreaders) {
139 list_add_tail(&msg->list, &pipe->pipe);
140 pipe->pipelen += msg->len;
Trond Myklebust6070fe62005-10-27 22:12:46 -0400141 res = 0;
Stanislav Kinsburskyd0fe13b2011-12-26 15:43:41 +0300142 } else if (pipe->flags & RPC_PIPE_WAIT_FOR_OPEN) {
143 if (list_empty(&pipe->pipe))
Trond Myklebust24c5d9d2006-03-20 13:44:08 -0500144 queue_delayed_work(rpciod_workqueue,
Stanislav Kinsburskyd0fe13b2011-12-26 15:43:41 +0300145 &pipe->queue_timeout,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700146 RPC_UPCALL_TIMEOUT);
Stanislav Kinsburskyd0fe13b2011-12-26 15:43:41 +0300147 list_add_tail(&msg->list, &pipe->pipe);
148 pipe->pipelen += msg->len;
Trond Myklebust6070fe62005-10-27 22:12:46 -0400149 res = 0;
150 }
Stanislav Kinsbursky591ad7f2012-02-27 22:05:54 +0400151 dentry = dget(pipe->dentry);
Stanislav Kinsburskyd0fe13b2011-12-26 15:43:41 +0300152 spin_unlock(&pipe->lock);
Stanislav Kinsbursky591ad7f2012-02-27 22:05:54 +0400153 if (dentry) {
154 wake_up(&RPC_I(dentry->d_inode)->waitq);
155 dput(dentry);
156 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700157 return res;
158}
Trond Myklebust468039e2008-12-23 15:21:31 -0500159EXPORT_SYMBOL_GPL(rpc_queue_upcall);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700160
Trond Myklebust6070fe62005-10-27 22:12:46 -0400161static inline void
162rpc_inode_setowner(struct inode *inode, void *private)
163{
164 RPC_I(inode)->private = private;
165}
166
Linus Torvalds1da177e2005-04-16 15:20:36 -0700167static void
168rpc_close_pipes(struct inode *inode)
169{
Stanislav Kinsburskyba9e0972011-12-26 15:43:32 +0300170 struct rpc_pipe *pipe = RPC_I(inode)->pipe;
\"J. Bruce Fields\e7128042008-12-23 16:09:47 -0500171 int need_release;
Stanislav Kinsburskyad6b1342012-01-10 16:12:38 +0400172 LIST_HEAD(free_list);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700173
Jes Sorensen1b1dcc12006-01-09 15:59:24 -0800174 mutex_lock(&inode->i_mutex);
Stanislav Kinsburskyad6b1342012-01-10 16:12:38 +0400175 spin_lock(&pipe->lock);
176 need_release = pipe->nreaders != 0 || pipe->nwriters != 0;
177 pipe->nreaders = 0;
178 list_splice_init(&pipe->in_upcall, &free_list);
179 list_splice_init(&pipe->pipe, &free_list);
180 pipe->pipelen = 0;
181 pipe->dentry = NULL;
182 spin_unlock(&pipe->lock);
Stanislav Kinsbursky591ad7f2012-02-27 22:05:54 +0400183 rpc_purge_list(&RPC_I(inode)->waitq, &free_list, pipe->ops->destroy_msg, -EPIPE);
Stanislav Kinsburskyad6b1342012-01-10 16:12:38 +0400184 pipe->nwriters = 0;
185 if (need_release && pipe->ops->release_pipe)
186 pipe->ops->release_pipe(inode);
187 cancel_delayed_work_sync(&pipe->queue_timeout);
Trond Myklebust6070fe62005-10-27 22:12:46 -0400188 rpc_inode_setowner(inode, NULL);
Stanislav Kinsbursky2c9030e2012-02-27 22:05:45 +0400189 RPC_I(inode)->pipe = NULL;
Jes Sorensen1b1dcc12006-01-09 15:59:24 -0800190 mutex_unlock(&inode->i_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700191}
192
Linus Torvalds1da177e2005-04-16 15:20:36 -0700193static struct inode *
194rpc_alloc_inode(struct super_block *sb)
195{
196 struct rpc_inode *rpci;
Christoph Lametere94b1762006-12-06 20:33:17 -0800197 rpci = (struct rpc_inode *)kmem_cache_alloc(rpc_inode_cachep, GFP_KERNEL);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700198 if (!rpci)
199 return NULL;
200 return &rpci->vfs_inode;
201}
202
203static void
Nick Pigginfa0d7e3d2011-01-07 17:49:49 +1100204rpc_i_callback(struct rcu_head *head)
205{
206 struct inode *inode = container_of(head, struct inode, i_rcu);
Nick Pigginfa0d7e3d2011-01-07 17:49:49 +1100207 kmem_cache_free(rpc_inode_cachep, RPC_I(inode));
208}
209
210static void
Linus Torvalds1da177e2005-04-16 15:20:36 -0700211rpc_destroy_inode(struct inode *inode)
212{
Nick Pigginfa0d7e3d2011-01-07 17:49:49 +1100213 call_rcu(&inode->i_rcu, rpc_i_callback);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700214}
215
216static int
217rpc_pipe_open(struct inode *inode, struct file *filp)
218{
Stanislav Kinsbursky2c9030e2012-02-27 22:05:45 +0400219 struct rpc_pipe *pipe;
\"J. Bruce Fields\c3810602008-12-23 16:08:32 -0500220 int first_open;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700221 int res = -ENXIO;
222
Jes Sorensen1b1dcc12006-01-09 15:59:24 -0800223 mutex_lock(&inode->i_mutex);
Stanislav Kinsbursky2c9030e2012-02-27 22:05:45 +0400224 pipe = RPC_I(inode)->pipe;
225 if (pipe == NULL)
\"J. Bruce Fields\c3810602008-12-23 16:08:32 -0500226 goto out;
Stanislav Kinsburskyd0fe13b2011-12-26 15:43:41 +0300227 first_open = pipe->nreaders == 0 && pipe->nwriters == 0;
228 if (first_open && pipe->ops->open_pipe) {
229 res = pipe->ops->open_pipe(inode);
\"J. Bruce Fields\c3810602008-12-23 16:08:32 -0500230 if (res)
231 goto out;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700232 }
\"J. Bruce Fields\c3810602008-12-23 16:08:32 -0500233 if (filp->f_mode & FMODE_READ)
Stanislav Kinsburskyd0fe13b2011-12-26 15:43:41 +0300234 pipe->nreaders++;
\"J. Bruce Fields\c3810602008-12-23 16:08:32 -0500235 if (filp->f_mode & FMODE_WRITE)
Stanislav Kinsburskyd0fe13b2011-12-26 15:43:41 +0300236 pipe->nwriters++;
\"J. Bruce Fields\c3810602008-12-23 16:08:32 -0500237 res = 0;
238out:
Jes Sorensen1b1dcc12006-01-09 15:59:24 -0800239 mutex_unlock(&inode->i_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700240 return res;
241}
242
243static int
244rpc_pipe_release(struct inode *inode, struct file *filp)
245{
Stanislav Kinsbursky2c9030e2012-02-27 22:05:45 +0400246 struct rpc_pipe *pipe;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700247 struct rpc_pipe_msg *msg;
\"J. Bruce Fields\e7128042008-12-23 16:09:47 -0500248 int last_close;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700249
Jes Sorensen1b1dcc12006-01-09 15:59:24 -0800250 mutex_lock(&inode->i_mutex);
Stanislav Kinsbursky2c9030e2012-02-27 22:05:45 +0400251 pipe = RPC_I(inode)->pipe;
252 if (pipe == NULL)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700253 goto out;
Joe Perches655b5bb2010-09-04 18:52:53 -0700254 msg = filp->private_data;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700255 if (msg != NULL) {
Stanislav Kinsburskyba9e0972011-12-26 15:43:32 +0300256 spin_lock(&pipe->lock);
Trond Myklebust48e49182005-12-19 17:11:22 -0500257 msg->errno = -EAGAIN;
Trond Myklebust5a676572010-09-12 19:55:25 -0400258 list_del_init(&msg->list);
Stanislav Kinsburskyba9e0972011-12-26 15:43:32 +0300259 spin_unlock(&pipe->lock);
260 pipe->ops->destroy_msg(msg);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700261 }
262 if (filp->f_mode & FMODE_WRITE)
Stanislav Kinsburskyba9e0972011-12-26 15:43:32 +0300263 pipe->nwriters --;
Trond Myklebust9842ef32006-02-01 12:18:44 -0500264 if (filp->f_mode & FMODE_READ) {
Stanislav Kinsburskyba9e0972011-12-26 15:43:32 +0300265 pipe->nreaders --;
266 if (pipe->nreaders == 0) {
Trond Myklebust9842ef32006-02-01 12:18:44 -0500267 LIST_HEAD(free_list);
Stanislav Kinsburskyba9e0972011-12-26 15:43:32 +0300268 spin_lock(&pipe->lock);
269 list_splice_init(&pipe->pipe, &free_list);
270 pipe->pipelen = 0;
271 spin_unlock(&pipe->lock);
Stanislav Kinsbursky591ad7f2012-02-27 22:05:54 +0400272 rpc_purge_list(&RPC_I(inode)->waitq, &free_list,
Stanislav Kinsburskyba9e0972011-12-26 15:43:32 +0300273 pipe->ops->destroy_msg, -EAGAIN);
Trond Myklebust9842ef32006-02-01 12:18:44 -0500274 }
275 }
Stanislav Kinsburskyba9e0972011-12-26 15:43:32 +0300276 last_close = pipe->nwriters == 0 && pipe->nreaders == 0;
277 if (last_close && pipe->ops->release_pipe)
278 pipe->ops->release_pipe(inode);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700279out:
Jes Sorensen1b1dcc12006-01-09 15:59:24 -0800280 mutex_unlock(&inode->i_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700281 return 0;
282}
283
284static ssize_t
285rpc_pipe_read(struct file *filp, char __user *buf, size_t len, loff_t *offset)
286{
Al Viro496ad9a2013-01-23 17:07:38 -0500287 struct inode *inode = file_inode(filp);
Stanislav Kinsbursky2c9030e2012-02-27 22:05:45 +0400288 struct rpc_pipe *pipe;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700289 struct rpc_pipe_msg *msg;
290 int res = 0;
291
Jes Sorensen1b1dcc12006-01-09 15:59:24 -0800292 mutex_lock(&inode->i_mutex);
Stanislav Kinsbursky2c9030e2012-02-27 22:05:45 +0400293 pipe = RPC_I(inode)->pipe;
294 if (pipe == NULL) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700295 res = -EPIPE;
296 goto out_unlock;
297 }
298 msg = filp->private_data;
299 if (msg == NULL) {
Stanislav Kinsburskyd0fe13b2011-12-26 15:43:41 +0300300 spin_lock(&pipe->lock);
301 if (!list_empty(&pipe->pipe)) {
302 msg = list_entry(pipe->pipe.next,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700303 struct rpc_pipe_msg,
304 list);
Stanislav Kinsburskyd0fe13b2011-12-26 15:43:41 +0300305 list_move(&msg->list, &pipe->in_upcall);
306 pipe->pipelen -= msg->len;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700307 filp->private_data = msg;
308 msg->copied = 0;
309 }
Stanislav Kinsburskyd0fe13b2011-12-26 15:43:41 +0300310 spin_unlock(&pipe->lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700311 if (msg == NULL)
312 goto out_unlock;
313 }
314 /* NOTE: it is up to the callback to update msg->copied */
Stanislav Kinsburskyd0fe13b2011-12-26 15:43:41 +0300315 res = pipe->ops->upcall(filp, msg, buf, len);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700316 if (res < 0 || msg->len == msg->copied) {
317 filp->private_data = NULL;
Stanislav Kinsburskyd0fe13b2011-12-26 15:43:41 +0300318 spin_lock(&pipe->lock);
Trond Myklebust5a676572010-09-12 19:55:25 -0400319 list_del_init(&msg->list);
Stanislav Kinsburskyd0fe13b2011-12-26 15:43:41 +0300320 spin_unlock(&pipe->lock);
321 pipe->ops->destroy_msg(msg);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700322 }
323out_unlock:
Jes Sorensen1b1dcc12006-01-09 15:59:24 -0800324 mutex_unlock(&inode->i_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700325 return res;
326}
327
328static ssize_t
329rpc_pipe_write(struct file *filp, const char __user *buf, size_t len, loff_t *offset)
330{
Al Viro496ad9a2013-01-23 17:07:38 -0500331 struct inode *inode = file_inode(filp);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700332 int res;
333
Jes Sorensen1b1dcc12006-01-09 15:59:24 -0800334 mutex_lock(&inode->i_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700335 res = -EPIPE;
Stanislav Kinsbursky2c9030e2012-02-27 22:05:45 +0400336 if (RPC_I(inode)->pipe != NULL)
337 res = RPC_I(inode)->pipe->ops->downcall(filp, buf, len);
Jes Sorensen1b1dcc12006-01-09 15:59:24 -0800338 mutex_unlock(&inode->i_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700339 return res;
340}
341
342static unsigned int
343rpc_pipe_poll(struct file *filp, struct poll_table_struct *wait)
344{
Al Viro496ad9a2013-01-23 17:07:38 -0500345 struct inode *inode = file_inode(filp);
Stanislav Kinsbursky591ad7f2012-02-27 22:05:54 +0400346 struct rpc_inode *rpci = RPC_I(inode);
347 unsigned int mask = POLLOUT | POLLWRNORM;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700348
Linus Torvalds1da177e2005-04-16 15:20:36 -0700349 poll_wait(filp, &rpci->waitq, wait);
350
Stanislav Kinsbursky591ad7f2012-02-27 22:05:54 +0400351 mutex_lock(&inode->i_mutex);
352 if (rpci->pipe == NULL)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700353 mask |= POLLERR | POLLHUP;
Stanislav Kinsbursky591ad7f2012-02-27 22:05:54 +0400354 else if (filp->private_data || !list_empty(&rpci->pipe->pipe))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700355 mask |= POLLIN | POLLRDNORM;
Stanislav Kinsbursky591ad7f2012-02-27 22:05:54 +0400356 mutex_unlock(&inode->i_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700357 return mask;
358}
359
Arnd Bergmanna6f8dbc2010-10-04 21:18:23 +0200360static long
361rpc_pipe_ioctl(struct file *filp, unsigned int cmd, unsigned long arg)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700362{
Al Viro496ad9a2013-01-23 17:07:38 -0500363 struct inode *inode = file_inode(filp);
Stanislav Kinsbursky2c9030e2012-02-27 22:05:45 +0400364 struct rpc_pipe *pipe;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700365 int len;
366
367 switch (cmd) {
368 case FIONREAD:
Stanislav Kinsbursky2c9030e2012-02-27 22:05:45 +0400369 mutex_lock(&inode->i_mutex);
370 pipe = RPC_I(inode)->pipe;
371 if (pipe == NULL) {
372 mutex_unlock(&inode->i_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700373 return -EPIPE;
Arnd Bergmanna6f8dbc2010-10-04 21:18:23 +0200374 }
Stanislav Kinsbursky2c9030e2012-02-27 22:05:45 +0400375 spin_lock(&pipe->lock);
Stanislav Kinsburskyd0fe13b2011-12-26 15:43:41 +0300376 len = pipe->pipelen;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700377 if (filp->private_data) {
378 struct rpc_pipe_msg *msg;
Joe Perches655b5bb2010-09-04 18:52:53 -0700379 msg = filp->private_data;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700380 len += msg->len - msg->copied;
381 }
Stanislav Kinsburskyd0fe13b2011-12-26 15:43:41 +0300382 spin_unlock(&pipe->lock);
Stanislav Kinsbursky2c9030e2012-02-27 22:05:45 +0400383 mutex_unlock(&inode->i_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700384 return put_user(len, (int __user *)arg);
385 default:
386 return -EINVAL;
387 }
388}
389
Arjan van de Venda7071d2007-02-12 00:55:36 -0800390static const struct file_operations rpc_pipe_fops = {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700391 .owner = THIS_MODULE,
392 .llseek = no_llseek,
393 .read = rpc_pipe_read,
394 .write = rpc_pipe_write,
395 .poll = rpc_pipe_poll,
Frederic Weisbecker674b6042010-05-19 15:08:17 +0200396 .unlocked_ioctl = rpc_pipe_ioctl,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700397 .open = rpc_pipe_open,
398 .release = rpc_pipe_release,
399};
400
401static int
402rpc_show_info(struct seq_file *m, void *v)
403{
404 struct rpc_clnt *clnt = m->private;
405
Trond Myklebust2446ab62012-03-01 17:00:56 -0500406 rcu_read_lock();
Trond Myklebust4e0038b2012-03-01 17:01:05 -0500407 seq_printf(m, "RPC server: %s\n",
408 rcu_dereference(clnt->cl_xprt)->servername);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700409 seq_printf(m, "service: %s (%d) version %d\n", clnt->cl_protname,
410 clnt->cl_prog, clnt->cl_vers);
Chuck Levere7f78652006-08-22 20:06:19 -0400411 seq_printf(m, "address: %s\n", rpc_peeraddr2str(clnt, RPC_DISPLAY_ADDR));
412 seq_printf(m, "protocol: %s\n", rpc_peeraddr2str(clnt, RPC_DISPLAY_PROTO));
J. Bruce Fieldsbf19aac2007-09-26 14:38:09 -0400413 seq_printf(m, "port: %s\n", rpc_peeraddr2str(clnt, RPC_DISPLAY_PORT));
Trond Myklebust2446ab62012-03-01 17:00:56 -0500414 rcu_read_unlock();
Linus Torvalds1da177e2005-04-16 15:20:36 -0700415 return 0;
416}
417
418static int
419rpc_info_open(struct inode *inode, struct file *file)
420{
Trond Myklebust006abe82010-09-12 19:55:25 -0400421 struct rpc_clnt *clnt = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700422 int ret = single_open(file, rpc_show_info, NULL);
423
424 if (!ret) {
425 struct seq_file *m = file->private_data;
Trond Myklebust006abe82010-09-12 19:55:25 -0400426
427 spin_lock(&file->f_path.dentry->d_lock);
428 if (!d_unhashed(file->f_path.dentry))
429 clnt = RPC_I(inode)->private;
430 if (clnt != NULL && atomic_inc_not_zero(&clnt->cl_count)) {
431 spin_unlock(&file->f_path.dentry->d_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700432 m->private = clnt;
433 } else {
Trond Myklebust006abe82010-09-12 19:55:25 -0400434 spin_unlock(&file->f_path.dentry->d_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700435 single_release(inode, file);
436 ret = -EINVAL;
437 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700438 }
439 return ret;
440}
441
442static int
443rpc_info_release(struct inode *inode, struct file *file)
444{
445 struct seq_file *m = file->private_data;
446 struct rpc_clnt *clnt = (struct rpc_clnt *)m->private;
447
448 if (clnt)
449 rpc_release_client(clnt);
450 return single_release(inode, file);
451}
452
Arjan van de Venda7071d2007-02-12 00:55:36 -0800453static const struct file_operations rpc_info_operations = {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700454 .owner = THIS_MODULE,
455 .open = rpc_info_open,
456 .read = seq_read,
457 .llseek = seq_lseek,
458 .release = rpc_info_release,
459};
460
461
462/*
Linus Torvalds1da177e2005-04-16 15:20:36 -0700463 * Description of fs contents.
464 */
465struct rpc_filelist {
Trond Myklebustac6fece2009-08-09 15:14:20 -0400466 const char *name;
Arjan van de Ven99ac48f2006-03-28 01:56:41 -0800467 const struct file_operations *i_fop;
Trond Myklebust7364af62009-08-09 15:14:16 -0400468 umode_t mode;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700469};
470
Nick Pigginfe15ce42011-01-07 17:49:23 +1100471static int rpc_delete_dentry(const struct dentry *dentry)
Trond Myklebust62e17612007-06-08 14:14:46 -0400472{
473 return 1;
474}
475
Al Viro3ba13d12009-02-20 06:02:22 +0000476static const struct dentry_operations rpc_dentry_operations = {
Trond Myklebust62e17612007-06-08 14:14:46 -0400477 .d_delete = rpc_delete_dentry,
478};
479
Linus Torvalds1da177e2005-04-16 15:20:36 -0700480static struct inode *
Trond Myklebust7364af62009-08-09 15:14:16 -0400481rpc_get_inode(struct super_block *sb, umode_t mode)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700482{
483 struct inode *inode = new_inode(sb);
484 if (!inode)
485 return NULL;
Christoph Hellwig85fe4022010-10-23 11:19:54 -0400486 inode->i_ino = get_next_ino();
Linus Torvalds1da177e2005-04-16 15:20:36 -0700487 inode->i_mode = mode;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700488 inode->i_atime = inode->i_mtime = inode->i_ctime = CURRENT_TIME;
Joe Perches89f0e4f2011-07-01 09:43:12 +0000489 switch (mode & S_IFMT) {
490 case S_IFDIR:
491 inode->i_fop = &simple_dir_operations;
492 inode->i_op = &simple_dir_inode_operations;
493 inc_nlink(inode);
494 default:
495 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700496 }
497 return inode;
498}
499
Trond Myklebust75898062009-08-09 15:14:17 -0400500static int __rpc_create_common(struct inode *dir, struct dentry *dentry,
501 umode_t mode,
502 const struct file_operations *i_fop,
503 void *private)
504{
505 struct inode *inode;
506
Trond Myklebustbeb0f0a2010-12-20 21:19:26 +0000507 d_drop(dentry);
Trond Myklebust75898062009-08-09 15:14:17 -0400508 inode = rpc_get_inode(dir->i_sb, mode);
509 if (!inode)
510 goto out_err;
511 inode->i_ino = iunique(dir->i_sb, 100);
512 if (i_fop)
513 inode->i_fop = i_fop;
514 if (private)
515 rpc_inode_setowner(inode, private);
516 d_add(dentry, inode);
517 return 0;
518out_err:
519 printk(KERN_WARNING "%s: %s failed to allocate inode for dentry %s\n",
520 __FILE__, __func__, dentry->d_name.name);
521 dput(dentry);
522 return -ENOMEM;
523}
524
Trond Myklebustac6fece2009-08-09 15:14:20 -0400525static int __rpc_create(struct inode *dir, struct dentry *dentry,
526 umode_t mode,
527 const struct file_operations *i_fop,
528 void *private)
529{
530 int err;
531
532 err = __rpc_create_common(dir, dentry, S_IFREG | mode, i_fop, private);
533 if (err)
534 return err;
535 fsnotify_create(dir, dentry);
536 return 0;
537}
538
Trond Myklebust75898062009-08-09 15:14:17 -0400539static int __rpc_mkdir(struct inode *dir, struct dentry *dentry,
540 umode_t mode,
541 const struct file_operations *i_fop,
542 void *private)
543{
544 int err;
545
546 err = __rpc_create_common(dir, dentry, S_IFDIR | mode, i_fop, private);
547 if (err)
548 return err;
549 inc_nlink(dir);
550 fsnotify_mkdir(dir, dentry);
551 return 0;
552}
553
Stanislav Kinsburskyba9e0972011-12-26 15:43:32 +0300554static void
555init_pipe(struct rpc_pipe *pipe)
556{
557 pipe->nreaders = 0;
558 pipe->nwriters = 0;
559 INIT_LIST_HEAD(&pipe->in_upcall);
560 INIT_LIST_HEAD(&pipe->in_downcall);
561 INIT_LIST_HEAD(&pipe->pipe);
562 pipe->pipelen = 0;
Stanislav Kinsburskyba9e0972011-12-26 15:43:32 +0300563 INIT_DELAYED_WORK(&pipe->queue_timeout,
564 rpc_timeout_upcall_queue);
565 pipe->ops = NULL;
566 spin_lock_init(&pipe->lock);
Stanislav Kinsburskyc239d832011-12-26 15:44:06 +0300567 pipe->dentry = NULL;
Stanislav Kinsburskyba9e0972011-12-26 15:43:32 +0300568}
569
Stanislav Kinsburskyc239d832011-12-26 15:44:06 +0300570void rpc_destroy_pipe_data(struct rpc_pipe *pipe)
571{
572 kfree(pipe);
573}
574EXPORT_SYMBOL_GPL(rpc_destroy_pipe_data);
575
576struct rpc_pipe *rpc_mkpipe_data(const struct rpc_pipe_ops *ops, int flags)
Trond Myklebust75898062009-08-09 15:14:17 -0400577{
Stanislav Kinsburskyba9e0972011-12-26 15:43:32 +0300578 struct rpc_pipe *pipe;
Trond Myklebust75898062009-08-09 15:14:17 -0400579
Stanislav Kinsburskyba9e0972011-12-26 15:43:32 +0300580 pipe = kzalloc(sizeof(struct rpc_pipe), GFP_KERNEL);
581 if (!pipe)
Stanislav Kinsburskyc239d832011-12-26 15:44:06 +0300582 return ERR_PTR(-ENOMEM);
Stanislav Kinsburskyba9e0972011-12-26 15:43:32 +0300583 init_pipe(pipe);
Stanislav Kinsburskyc239d832011-12-26 15:44:06 +0300584 pipe->ops = ops;
585 pipe->flags = flags;
586 return pipe;
587}
588EXPORT_SYMBOL_GPL(rpc_mkpipe_data);
589
590static int __rpc_mkpipe_dentry(struct inode *dir, struct dentry *dentry,
591 umode_t mode,
592 const struct file_operations *i_fop,
593 void *private,
594 struct rpc_pipe *pipe)
Trond Myklebust75898062009-08-09 15:14:17 -0400595{
596 struct rpc_inode *rpci;
597 int err;
598
599 err = __rpc_create_common(dir, dentry, S_IFIFO | mode, i_fop, private);
600 if (err)
601 return err;
602 rpci = RPC_I(dentry->d_inode);
Trond Myklebust75898062009-08-09 15:14:17 -0400603 rpci->private = private;
Stanislav Kinsburskyba9e0972011-12-26 15:43:32 +0300604 rpci->pipe = pipe;
Trond Myklebust75898062009-08-09 15:14:17 -0400605 fsnotify_create(dir, dentry);
606 return 0;
607}
608
Trond Myklebustac6fece2009-08-09 15:14:20 -0400609static int __rpc_rmdir(struct inode *dir, struct dentry *dentry)
610{
611 int ret;
612
613 dget(dentry);
614 ret = simple_rmdir(dir, dentry);
615 d_delete(dentry);
616 dput(dentry);
617 return ret;
618}
619
Stanislav Kinsburskyeee17322012-01-10 16:13:19 +0400620int rpc_rmdir(struct dentry *dentry)
621{
622 struct dentry *parent;
623 struct inode *dir;
624 int error;
625
626 parent = dget_parent(dentry);
627 dir = parent->d_inode;
628 mutex_lock_nested(&dir->i_mutex, I_MUTEX_PARENT);
629 error = __rpc_rmdir(dir, dentry);
630 mutex_unlock(&dir->i_mutex);
631 dput(parent);
632 return error;
633}
634EXPORT_SYMBOL_GPL(rpc_rmdir);
635
Trond Myklebust810d90b2009-08-09 15:14:18 -0400636static int __rpc_unlink(struct inode *dir, struct dentry *dentry)
637{
638 int ret;
639
640 dget(dentry);
641 ret = simple_unlink(dir, dentry);
642 d_delete(dentry);
643 dput(dentry);
644 return ret;
645}
646
647static int __rpc_rmpipe(struct inode *dir, struct dentry *dentry)
648{
649 struct inode *inode = dentry->d_inode;
Trond Myklebust810d90b2009-08-09 15:14:18 -0400650
Trond Myklebust810d90b2009-08-09 15:14:18 -0400651 rpc_close_pipes(inode);
652 return __rpc_unlink(dir, dentry);
653}
654
Trond Myklebustcfeaa4a2009-08-09 15:14:20 -0400655static struct dentry *__rpc_lookup_create_exclusive(struct dentry *parent,
656 struct qstr *name)
657{
658 struct dentry *dentry;
659
Stanislav Kinsbursky5bff0382011-11-08 15:09:19 +0300660 dentry = d_lookup(parent, name);
661 if (!dentry) {
662 dentry = d_alloc(parent, name);
663 if (!dentry)
664 return ERR_PTR(-ENOMEM);
665 }
666 if (dentry->d_inode == NULL) {
667 d_set_d_op(dentry, &rpc_dentry_operations);
Dan Carpenterf1f0abe2010-03-21 12:10:34 -0400668 return dentry;
Stanislav Kinsbursky5bff0382011-11-08 15:09:19 +0300669 }
Trond Myklebustcfeaa4a2009-08-09 15:14:20 -0400670 dput(dentry);
671 return ERR_PTR(-EEXIST);
672}
673
Linus Torvalds1da177e2005-04-16 15:20:36 -0700674/*
675 * FIXME: This probably has races.
676 */
Trond Myklebustac6fece2009-08-09 15:14:20 -0400677static void __rpc_depopulate(struct dentry *parent,
678 const struct rpc_filelist *files,
679 int start, int eof)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700680{
681 struct inode *dir = parent->d_inode;
Trond Myklebustac6fece2009-08-09 15:14:20 -0400682 struct dentry *dentry;
683 struct qstr name;
684 int i;
685
686 for (i = start; i < eof; i++) {
687 name.name = files[i].name;
688 name.len = strlen(files[i].name);
689 name.hash = full_name_hash(name.name, name.len);
690 dentry = d_lookup(parent, &name);
691
692 if (dentry == NULL)
693 continue;
694 if (dentry->d_inode == NULL)
695 goto next;
696 switch (dentry->d_inode->i_mode & S_IFMT) {
697 default:
698 BUG();
699 case S_IFREG:
700 __rpc_unlink(dir, dentry);
701 break;
702 case S_IFDIR:
703 __rpc_rmdir(dir, dentry);
704 }
705next:
706 dput(dentry);
707 }
708}
709
710static void rpc_depopulate(struct dentry *parent,
711 const struct rpc_filelist *files,
712 int start, int eof)
713{
714 struct inode *dir = parent->d_inode;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700715
Arjan van de Venc6573c22006-07-03 00:25:16 -0700716 mutex_lock_nested(&dir->i_mutex, I_MUTEX_CHILD);
Trond Myklebustac6fece2009-08-09 15:14:20 -0400717 __rpc_depopulate(parent, files, start, eof);
Jes Sorensen1b1dcc12006-01-09 15:59:24 -0800718 mutex_unlock(&dir->i_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700719}
720
Trond Myklebustac6fece2009-08-09 15:14:20 -0400721static int rpc_populate(struct dentry *parent,
722 const struct rpc_filelist *files,
723 int start, int eof,
724 void *private)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700725{
Trond Myklebustac6fece2009-08-09 15:14:20 -0400726 struct inode *dir = parent->d_inode;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700727 struct dentry *dentry;
Trond Myklebustac6fece2009-08-09 15:14:20 -0400728 int i, err;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700729
Jes Sorensen1b1dcc12006-01-09 15:59:24 -0800730 mutex_lock(&dir->i_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700731 for (i = start; i < eof; i++) {
Trond Myklebustac6fece2009-08-09 15:14:20 -0400732 struct qstr q;
733
734 q.name = files[i].name;
735 q.len = strlen(files[i].name);
736 q.hash = full_name_hash(q.name, q.len);
737 dentry = __rpc_lookup_create_exclusive(parent, &q);
738 err = PTR_ERR(dentry);
739 if (IS_ERR(dentry))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700740 goto out_bad;
Trond Myklebustac6fece2009-08-09 15:14:20 -0400741 switch (files[i].mode & S_IFMT) {
742 default:
743 BUG();
744 case S_IFREG:
745 err = __rpc_create(dir, dentry,
746 files[i].mode,
747 files[i].i_fop,
748 private);
749 break;
750 case S_IFDIR:
751 err = __rpc_mkdir(dir, dentry,
752 files[i].mode,
753 NULL,
754 private);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700755 }
Trond Myklebustac6fece2009-08-09 15:14:20 -0400756 if (err != 0)
757 goto out_bad;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700758 }
Jes Sorensen1b1dcc12006-01-09 15:59:24 -0800759 mutex_unlock(&dir->i_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700760 return 0;
761out_bad:
Trond Myklebustac6fece2009-08-09 15:14:20 -0400762 __rpc_depopulate(parent, files, start, eof);
Jes Sorensen1b1dcc12006-01-09 15:59:24 -0800763 mutex_unlock(&dir->i_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700764 printk(KERN_WARNING "%s: %s failed to populate directory %s\n",
Harvey Harrison0dc47872008-03-05 20:47:47 -0800765 __FILE__, __func__, parent->d_name.name);
Trond Myklebustac6fece2009-08-09 15:14:20 -0400766 return err;
Trond Myklebustf1345852005-09-23 11:08:25 -0400767}
Christoph Hellwig278c9952005-07-24 23:53:01 +0100768
Trond Myklebuste57aed72009-08-09 15:14:26 -0400769static struct dentry *rpc_mkdir_populate(struct dentry *parent,
770 struct qstr *name, umode_t mode, void *private,
771 int (*populate)(struct dentry *, void *), void *args_populate)
Trond Myklebustf1345852005-09-23 11:08:25 -0400772{
Trond Myklebustf1345852005-09-23 11:08:25 -0400773 struct dentry *dentry;
Trond Myklebust7d59d1e2009-08-09 15:14:23 -0400774 struct inode *dir = parent->d_inode;
Trond Myklebustf1345852005-09-23 11:08:25 -0400775 int error;
776
Trond Myklebust7d59d1e2009-08-09 15:14:23 -0400777 mutex_lock_nested(&dir->i_mutex, I_MUTEX_PARENT);
778 dentry = __rpc_lookup_create_exclusive(parent, name);
Trond Myklebustf1345852005-09-23 11:08:25 -0400779 if (IS_ERR(dentry))
Trond Myklebust7d59d1e2009-08-09 15:14:23 -0400780 goto out;
781 error = __rpc_mkdir(dir, dentry, mode, NULL, private);
Trond Myklebust75898062009-08-09 15:14:17 -0400782 if (error != 0)
783 goto out_err;
Trond Myklebuste57aed72009-08-09 15:14:26 -0400784 if (populate != NULL) {
785 error = populate(dentry, args_populate);
786 if (error)
787 goto err_rmdir;
788 }
Trond Myklebustf1345852005-09-23 11:08:25 -0400789out:
Jes Sorensen1b1dcc12006-01-09 15:59:24 -0800790 mutex_unlock(&dir->i_mutex);
Trond Myklebust5c3e9852006-07-29 17:37:40 -0400791 return dentry;
Trond Myklebustac6fece2009-08-09 15:14:20 -0400792err_rmdir:
Trond Myklebustf1345852005-09-23 11:08:25 -0400793 __rpc_rmdir(dir, dentry);
Trond Myklebust75898062009-08-09 15:14:17 -0400794out_err:
Trond Myklebustf1345852005-09-23 11:08:25 -0400795 dentry = ERR_PTR(error);
796 goto out;
797}
798
Trond Myklebuste57aed72009-08-09 15:14:26 -0400799static int rpc_rmdir_depopulate(struct dentry *dentry,
800 void (*depopulate)(struct dentry *))
Trond Myklebustf1345852005-09-23 11:08:25 -0400801{
Trond Myklebustdff02cc2006-07-31 14:17:18 -0700802 struct dentry *parent;
Trond Myklebustf1345852005-09-23 11:08:25 -0400803 struct inode *dir;
804 int error;
805
Trond Myklebustdff02cc2006-07-31 14:17:18 -0700806 parent = dget_parent(dentry);
807 dir = parent->d_inode;
Arjan van de Venc6573c22006-07-03 00:25:16 -0700808 mutex_lock_nested(&dir->i_mutex, I_MUTEX_PARENT);
Trond Myklebuste57aed72009-08-09 15:14:26 -0400809 if (depopulate != NULL)
810 depopulate(dentry);
Trond Myklebustf1345852005-09-23 11:08:25 -0400811 error = __rpc_rmdir(dir, dentry);
Jes Sorensen1b1dcc12006-01-09 15:59:24 -0800812 mutex_unlock(&dir->i_mutex);
Trond Myklebustdff02cc2006-07-31 14:17:18 -0700813 dput(parent);
Trond Myklebustf1345852005-09-23 11:08:25 -0400814 return error;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700815}
816
J. Bruce Fields93a44a72007-11-06 13:06:03 -0500817/**
818 * rpc_mkpipe - make an rpc_pipefs file for kernel<->userspace communication
819 * @parent: dentry of directory to create new "pipe" in
820 * @name: name of pipe
821 * @private: private data to associate with the pipe, for the caller's use
Randy Dunlapbda14602012-05-13 10:35:40 -0700822 * @pipe: &rpc_pipe containing input parameters
J. Bruce Fields93a44a72007-11-06 13:06:03 -0500823 *
824 * Data is made available for userspace to read by calls to
825 * rpc_queue_upcall(). The actual reads will result in calls to
826 * @ops->upcall, which will be called with the file pointer,
827 * message, and userspace buffer to copy to.
828 *
829 * Writes can come at any time, and do not necessarily have to be
830 * responses to upcalls. They will result in calls to @msg->downcall.
831 *
832 * The @private argument passed here will be available to all these methods
Al Viro496ad9a2013-01-23 17:07:38 -0500833 * from the file pointer, via RPC_I(file_inode(file))->private.
J. Bruce Fields93a44a72007-11-06 13:06:03 -0500834 */
Stanislav Kinsburskyc239d832011-12-26 15:44:06 +0300835struct dentry *rpc_mkpipe_dentry(struct dentry *parent, const char *name,
836 void *private, struct rpc_pipe *pipe)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700837{
Linus Torvalds1da177e2005-04-16 15:20:36 -0700838 struct dentry *dentry;
Trond Myklebust75898062009-08-09 15:14:17 -0400839 struct inode *dir = parent->d_inode;
Trond Myklebust7364af62009-08-09 15:14:16 -0400840 umode_t umode = S_IFIFO | S_IRUSR | S_IWUSR;
Trond Myklebustcfeaa4a2009-08-09 15:14:20 -0400841 struct qstr q;
Trond Myklebust75898062009-08-09 15:14:17 -0400842 int err;
Trond Myklebust7364af62009-08-09 15:14:16 -0400843
Stanislav Kinsburskyc239d832011-12-26 15:44:06 +0300844 if (pipe->ops->upcall == NULL)
Trond Myklebust7364af62009-08-09 15:14:16 -0400845 umode &= ~S_IRUGO;
Stanislav Kinsburskyc239d832011-12-26 15:44:06 +0300846 if (pipe->ops->downcall == NULL)
Trond Myklebust7364af62009-08-09 15:14:16 -0400847 umode &= ~S_IWUGO;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700848
Trond Myklebustcfeaa4a2009-08-09 15:14:20 -0400849 q.name = name;
850 q.len = strlen(name);
851 q.hash = full_name_hash(q.name, q.len),
852
853 mutex_lock_nested(&dir->i_mutex, I_MUTEX_PARENT);
Stanislav Kinsbursky5bff0382011-11-08 15:09:19 +0300854 dentry = __rpc_lookup_create_exclusive(parent, &q);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700855 if (IS_ERR(dentry))
Trond Myklebustcfeaa4a2009-08-09 15:14:20 -0400856 goto out;
Stanislav Kinsburskyc239d832011-12-26 15:44:06 +0300857 err = __rpc_mkpipe_dentry(dir, dentry, umode, &rpc_pipe_fops,
858 private, pipe);
Trond Myklebust75898062009-08-09 15:14:17 -0400859 if (err)
860 goto out_err;
Trond Myklebustf1345852005-09-23 11:08:25 -0400861out:
Jes Sorensen1b1dcc12006-01-09 15:59:24 -0800862 mutex_unlock(&dir->i_mutex);
Trond Myklebust5c3e9852006-07-29 17:37:40 -0400863 return dentry;
Trond Myklebust75898062009-08-09 15:14:17 -0400864out_err:
865 dentry = ERR_PTR(err);
Trond Myklebust158998b2006-08-24 01:03:17 -0400866 printk(KERN_WARNING "%s: %s() failed to create pipe %s/%s (errno = %d)\n",
Harvey Harrison0dc47872008-03-05 20:47:47 -0800867 __FILE__, __func__, parent->d_name.name, name,
Trond Myklebust75898062009-08-09 15:14:17 -0400868 err);
Trond Myklebustf1345852005-09-23 11:08:25 -0400869 goto out;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700870}
Stanislav Kinsburskyc239d832011-12-26 15:44:06 +0300871EXPORT_SYMBOL_GPL(rpc_mkpipe_dentry);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700872
J. Bruce Fields93a44a72007-11-06 13:06:03 -0500873/**
874 * rpc_unlink - remove a pipe
875 * @dentry: dentry for the pipe, as returned from rpc_mkpipe
876 *
877 * After this call, lookups will no longer find the pipe, and any
878 * attempts to read or write using preexisting opens of the pipe will
879 * return -EPIPE.
880 */
Trond Myklebustf1345852005-09-23 11:08:25 -0400881int
Trond Myklebust5d674762006-07-31 14:11:48 -0700882rpc_unlink(struct dentry *dentry)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700883{
Trond Myklebust5d674762006-07-31 14:11:48 -0700884 struct dentry *parent;
Trond Myklebustf1345852005-09-23 11:08:25 -0400885 struct inode *dir;
Trond Myklebust5d674762006-07-31 14:11:48 -0700886 int error = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700887
Trond Myklebust5d674762006-07-31 14:11:48 -0700888 parent = dget_parent(dentry);
889 dir = parent->d_inode;
Arjan van de Venc6573c22006-07-03 00:25:16 -0700890 mutex_lock_nested(&dir->i_mutex, I_MUTEX_PARENT);
Trond Myklebust810d90b2009-08-09 15:14:18 -0400891 error = __rpc_rmpipe(dir, dentry);
Jes Sorensen1b1dcc12006-01-09 15:59:24 -0800892 mutex_unlock(&dir->i_mutex);
Trond Myklebust5d674762006-07-31 14:11:48 -0700893 dput(parent);
Trond Myklebustf1345852005-09-23 11:08:25 -0400894 return error;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700895}
Trond Myklebust468039e2008-12-23 15:21:31 -0500896EXPORT_SYMBOL_GPL(rpc_unlink);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700897
Trond Myklebuste57aed72009-08-09 15:14:26 -0400898enum {
899 RPCAUTH_info,
900 RPCAUTH_EOF
901};
902
903static const struct rpc_filelist authfiles[] = {
904 [RPCAUTH_info] = {
905 .name = "info",
906 .i_fop = &rpc_info_operations,
907 .mode = S_IFREG | S_IRUSR,
908 },
909};
910
911static int rpc_clntdir_populate(struct dentry *dentry, void *private)
912{
913 return rpc_populate(dentry,
914 authfiles, RPCAUTH_info, RPCAUTH_EOF,
915 private);
916}
917
918static void rpc_clntdir_depopulate(struct dentry *dentry)
919{
920 rpc_depopulate(dentry, authfiles, RPCAUTH_info, RPCAUTH_EOF);
921}
922
Trond Myklebust7d59d1e2009-08-09 15:14:23 -0400923/**
924 * rpc_create_client_dir - Create a new rpc_client directory in rpc_pipefs
Randy Dunlap4111d4f2009-09-23 14:36:38 -0400925 * @dentry: dentry from the rpc_pipefs root to the new directory
926 * @name: &struct qstr for the name
Trond Myklebust7d59d1e2009-08-09 15:14:23 -0400927 * @rpc_client: rpc client to associate with this directory
928 *
929 * This creates a directory at the given @path associated with
930 * @rpc_clnt, which will contain a file named "info" with some basic
931 * information about the client, together with any "pipes" that may
932 * later be created using rpc_mkpipe().
933 */
Trond Myklebust23ac6582009-08-09 15:14:25 -0400934struct dentry *rpc_create_client_dir(struct dentry *dentry,
Trond Myklebuste57aed72009-08-09 15:14:26 -0400935 struct qstr *name,
936 struct rpc_clnt *rpc_client)
Trond Myklebust7d59d1e2009-08-09 15:14:23 -0400937{
Trond Myklebuste57aed72009-08-09 15:14:26 -0400938 return rpc_mkdir_populate(dentry, name, S_IRUGO | S_IXUGO, NULL,
939 rpc_clntdir_populate, rpc_client);
940}
941
942/**
943 * rpc_remove_client_dir - Remove a directory created with rpc_create_client_dir()
Randy Dunlapbda14602012-05-13 10:35:40 -0700944 * @dentry: dentry for the pipe
Trond Myklebuste57aed72009-08-09 15:14:26 -0400945 */
946int rpc_remove_client_dir(struct dentry *dentry)
947{
948 return rpc_rmdir_depopulate(dentry, rpc_clntdir_depopulate);
Trond Myklebust7d59d1e2009-08-09 15:14:23 -0400949}
950
Trond Myklebust8854e822009-08-09 15:14:30 -0400951static const struct rpc_filelist cache_pipefs_files[3] = {
952 [0] = {
953 .name = "channel",
954 .i_fop = &cache_file_operations_pipefs,
Trond Myklebust96c61cb2009-08-19 18:12:21 -0400955 .mode = S_IFREG|S_IRUSR|S_IWUSR,
Trond Myklebust8854e822009-08-09 15:14:30 -0400956 },
957 [1] = {
958 .name = "content",
959 .i_fop = &content_file_operations_pipefs,
960 .mode = S_IFREG|S_IRUSR,
961 },
962 [2] = {
963 .name = "flush",
964 .i_fop = &cache_flush_operations_pipefs,
965 .mode = S_IFREG|S_IRUSR|S_IWUSR,
966 },
967};
968
969static int rpc_cachedir_populate(struct dentry *dentry, void *private)
970{
971 return rpc_populate(dentry,
972 cache_pipefs_files, 0, 3,
973 private);
974}
975
976static void rpc_cachedir_depopulate(struct dentry *dentry)
977{
978 rpc_depopulate(dentry, cache_pipefs_files, 0, 3);
979}
980
981struct dentry *rpc_create_cache_dir(struct dentry *parent, struct qstr *name,
Al Viro64f14262011-07-25 00:35:13 -0400982 umode_t umode, struct cache_detail *cd)
Trond Myklebust8854e822009-08-09 15:14:30 -0400983{
984 return rpc_mkdir_populate(parent, name, umode, NULL,
985 rpc_cachedir_populate, cd);
986}
987
988void rpc_remove_cache_dir(struct dentry *dentry)
989{
990 rpc_rmdir_depopulate(dentry, rpc_cachedir_depopulate);
991}
992
Linus Torvalds1da177e2005-04-16 15:20:36 -0700993/*
994 * populate the filesystem
995 */
Alexey Dobriyanb87221d2009-09-21 17:01:09 -0700996static const struct super_operations s_ops = {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700997 .alloc_inode = rpc_alloc_inode,
998 .destroy_inode = rpc_destroy_inode,
999 .statfs = simple_statfs,
1000};
1001
1002#define RPCAUTH_GSSMAGIC 0x67596969
1003
Trond Myklebustbb156742009-08-09 15:14:21 -04001004/*
1005 * We have a single directory with 1 node in it.
1006 */
1007enum {
1008 RPCAUTH_lockd,
1009 RPCAUTH_mount,
1010 RPCAUTH_nfs,
1011 RPCAUTH_portmap,
1012 RPCAUTH_statd,
1013 RPCAUTH_nfsd4_cb,
Trond Myklebuste571cbf2009-08-19 18:12:27 -04001014 RPCAUTH_cache,
Jeff Laytonb3537c32012-03-21 09:52:04 -04001015 RPCAUTH_nfsd,
Trond Myklebustbb156742009-08-09 15:14:21 -04001016 RPCAUTH_RootEOF
1017};
1018
1019static const struct rpc_filelist files[] = {
1020 [RPCAUTH_lockd] = {
1021 .name = "lockd",
1022 .mode = S_IFDIR | S_IRUGO | S_IXUGO,
1023 },
1024 [RPCAUTH_mount] = {
1025 .name = "mount",
1026 .mode = S_IFDIR | S_IRUGO | S_IXUGO,
1027 },
1028 [RPCAUTH_nfs] = {
1029 .name = "nfs",
1030 .mode = S_IFDIR | S_IRUGO | S_IXUGO,
1031 },
1032 [RPCAUTH_portmap] = {
1033 .name = "portmap",
1034 .mode = S_IFDIR | S_IRUGO | S_IXUGO,
1035 },
1036 [RPCAUTH_statd] = {
1037 .name = "statd",
1038 .mode = S_IFDIR | S_IRUGO | S_IXUGO,
1039 },
1040 [RPCAUTH_nfsd4_cb] = {
1041 .name = "nfsd4_cb",
1042 .mode = S_IFDIR | S_IRUGO | S_IXUGO,
1043 },
Trond Myklebuste571cbf2009-08-19 18:12:27 -04001044 [RPCAUTH_cache] = {
1045 .name = "cache",
1046 .mode = S_IFDIR | S_IRUGO | S_IXUGO,
1047 },
Jeff Laytonb3537c32012-03-21 09:52:04 -04001048 [RPCAUTH_nfsd] = {
1049 .name = "nfsd",
1050 .mode = S_IFDIR | S_IRUGO | S_IXUGO,
1051 },
Trond Myklebustbb156742009-08-09 15:14:21 -04001052};
1053
Stanislav Kinsbursky432eb1a2011-12-26 15:39:22 +03001054/*
1055 * This call can be used only in RPC pipefs mount notification hooks.
1056 */
1057struct dentry *rpc_d_lookup_sb(const struct super_block *sb,
1058 const unsigned char *dir_name)
1059{
Linus Torvalds26fe5752012-05-10 13:14:12 -07001060 struct qstr dir = QSTR_INIT(dir_name, strlen(dir_name));
Stanislav Kinsbursky432eb1a2011-12-26 15:39:22 +03001061
Linus Torvalds26fe5752012-05-10 13:14:12 -07001062 dir.hash = full_name_hash(dir.name, dir.len);
Stanislav Kinsbursky432eb1a2011-12-26 15:39:22 +03001063 return d_lookup(sb->s_root, &dir);
1064}
1065EXPORT_SYMBOL_GPL(rpc_d_lookup_sb);
1066
Stanislav Kinsburskyc21a5882011-12-26 15:39:39 +03001067void rpc_pipefs_init_net(struct net *net)
1068{
1069 struct sunrpc_net *sn = net_generic(net, sunrpc_net_id);
1070
1071 mutex_init(&sn->pipefs_sb_lock);
1072}
1073
1074/*
1075 * This call will be used for per network namespace operations calls.
1076 * Note: Function will be returned with pipefs_sb_lock taken if superblock was
1077 * found. This lock have to be released by rpc_put_sb_net() when all operations
1078 * will be completed.
1079 */
1080struct super_block *rpc_get_sb_net(const struct net *net)
1081{
1082 struct sunrpc_net *sn = net_generic(net, sunrpc_net_id);
1083
1084 mutex_lock(&sn->pipefs_sb_lock);
1085 if (sn->pipefs_sb)
1086 return sn->pipefs_sb;
1087 mutex_unlock(&sn->pipefs_sb_lock);
1088 return NULL;
1089}
1090EXPORT_SYMBOL_GPL(rpc_get_sb_net);
1091
1092void rpc_put_sb_net(const struct net *net)
1093{
1094 struct sunrpc_net *sn = net_generic(net, sunrpc_net_id);
1095
Weston Andros Adamson749386e2012-10-23 10:43:37 -04001096 WARN_ON(sn->pipefs_sb == NULL);
Stanislav Kinsburskyc21a5882011-12-26 15:39:39 +03001097 mutex_unlock(&sn->pipefs_sb_lock);
1098}
1099EXPORT_SYMBOL_GPL(rpc_put_sb_net);
1100
Linus Torvalds1da177e2005-04-16 15:20:36 -07001101static int
1102rpc_fill_super(struct super_block *sb, void *data, int silent)
1103{
1104 struct inode *inode;
1105 struct dentry *root;
Stanislav Kinsbursky38b0da72011-12-26 15:38:56 +03001106 struct net *net = data;
Stanislav Kinsbursky90c4e822011-12-26 15:39:30 +03001107 struct sunrpc_net *sn = net_generic(net, sunrpc_net_id);
Stanislav Kinsbursky2d001312011-12-26 15:39:13 +03001108 int err;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001109
1110 sb->s_blocksize = PAGE_CACHE_SIZE;
1111 sb->s_blocksize_bits = PAGE_CACHE_SHIFT;
1112 sb->s_magic = RPCAUTH_GSSMAGIC;
1113 sb->s_op = &s_ops;
1114 sb->s_time_gran = 1;
1115
Jeff Layton7e450b42012-05-16 13:04:26 -04001116 inode = rpc_get_inode(sb, S_IFDIR | S_IRUGO | S_IXUGO);
Al Viro48fde702012-01-08 22:15:13 -05001117 sb->s_root = root = d_make_root(inode);
1118 if (!root)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001119 return -ENOMEM;
Trond Myklebustac6fece2009-08-09 15:14:20 -04001120 if (rpc_populate(root, files, RPCAUTH_lockd, RPCAUTH_RootEOF, NULL))
Al Virofc7bed82010-01-25 18:30:38 -05001121 return -ENOMEM;
Chuck Leverd8af9bc12012-09-14 17:23:34 -04001122 dprintk("RPC: sending pipefs MOUNT notification for net %p%s\n",
1123 net, NET_NAME(net));
Stanislav Kinsbursky37629b52012-04-20 18:19:56 +04001124 sn->pipefs_sb = sb;
Stanislav Kinsbursky2d001312011-12-26 15:39:13 +03001125 err = blocking_notifier_call_chain(&rpc_pipefs_notifier_list,
1126 RPC_PIPEFS_MOUNT,
1127 sb);
1128 if (err)
1129 goto err_depopulate;
Stanislav Kinsbursky021c68d2011-12-26 15:39:04 +03001130 sb->s_fs_info = get_net(net);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001131 return 0;
Stanislav Kinsbursky2d001312011-12-26 15:39:13 +03001132
1133err_depopulate:
1134 blocking_notifier_call_chain(&rpc_pipefs_notifier_list,
1135 RPC_PIPEFS_UMOUNT,
1136 sb);
Stanislav Kinsbursky37629b52012-04-20 18:19:56 +04001137 sn->pipefs_sb = NULL;
Stanislav Kinsbursky2d001312011-12-26 15:39:13 +03001138 __rpc_depopulate(root, files, RPCAUTH_lockd, RPCAUTH_RootEOF);
1139 return err;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001140}
1141
Al Virofc14f2f2010-07-25 01:48:30 +04001142static struct dentry *
1143rpc_mount(struct file_system_type *fs_type,
1144 int flags, const char *dev_name, void *data)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001145{
Stanislav Kinsbursky38b0da72011-12-26 15:38:56 +03001146 return mount_ns(fs_type, flags, current->nsproxy->net_ns, rpc_fill_super);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001147}
1148
Trond Myklebust09acfea2012-03-11 15:22:54 -04001149static void rpc_kill_sb(struct super_block *sb)
Stanislav Kinsbursky021c68d2011-12-26 15:39:04 +03001150{
1151 struct net *net = sb->s_fs_info;
Stanislav Kinsbursky90c4e822011-12-26 15:39:30 +03001152 struct sunrpc_net *sn = net_generic(net, sunrpc_net_id);
Stanislav Kinsbursky021c68d2011-12-26 15:39:04 +03001153
Stanislav Kinsburskyc21a5882011-12-26 15:39:39 +03001154 mutex_lock(&sn->pipefs_sb_lock);
Trond Myklebust642fe4d2012-11-08 10:01:26 -05001155 if (sn->pipefs_sb != sb) {
1156 mutex_unlock(&sn->pipefs_sb_lock);
1157 goto out;
1158 }
Stanislav Kinsbursky90c4e822011-12-26 15:39:30 +03001159 sn->pipefs_sb = NULL;
Stanislav Kinsburskyc21a5882011-12-26 15:39:39 +03001160 mutex_unlock(&sn->pipefs_sb_lock);
Chuck Leverd8af9bc12012-09-14 17:23:34 -04001161 dprintk("RPC: sending pipefs UMOUNT notification for net %p%s\n",
1162 net, NET_NAME(net));
Stanislav Kinsbursky2d001312011-12-26 15:39:13 +03001163 blocking_notifier_call_chain(&rpc_pipefs_notifier_list,
1164 RPC_PIPEFS_UMOUNT,
1165 sb);
Trond Myklebust642fe4d2012-11-08 10:01:26 -05001166 put_net(net);
1167out:
Stanislav Kinsbursky021c68d2011-12-26 15:39:04 +03001168 kill_litter_super(sb);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001169}
1170
1171static struct file_system_type rpc_pipe_fs_type = {
1172 .owner = THIS_MODULE,
1173 .name = "rpc_pipefs",
Al Virofc14f2f2010-07-25 01:48:30 +04001174 .mount = rpc_mount,
Stanislav Kinsbursky021c68d2011-12-26 15:39:04 +03001175 .kill_sb = rpc_kill_sb,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001176};
Eric W. Biederman7f78e032013-03-02 19:39:14 -08001177MODULE_ALIAS_FS("rpc_pipefs");
Eric W. Biedermanfa7614dd2013-03-12 18:27:41 -07001178MODULE_ALIAS("rpc_pipefs");
Linus Torvalds1da177e2005-04-16 15:20:36 -07001179
1180static void
Alexey Dobriyan51cc5062008-07-25 19:45:34 -07001181init_once(void *foo)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001182{
1183 struct rpc_inode *rpci = (struct rpc_inode *) foo;
1184
Christoph Lametera35afb82007-05-16 22:10:57 -07001185 inode_init_once(&rpci->vfs_inode);
1186 rpci->private = NULL;
Stanislav Kinsburskyba9e0972011-12-26 15:43:32 +03001187 rpci->pipe = NULL;
Christoph Lametera35afb82007-05-16 22:10:57 -07001188 init_waitqueue_head(&rpci->waitq);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001189}
1190
1191int register_rpc_pipefs(void)
1192{
Akinobu Mita5bd5f582007-05-09 02:34:51 -07001193 int err;
1194
Linus Torvalds1da177e2005-04-16 15:20:36 -07001195 rpc_inode_cachep = kmem_cache_create("rpc_inode_cache",
Paul Jacksonfffb60f2006-03-24 03:16:06 -08001196 sizeof(struct rpc_inode),
1197 0, (SLAB_HWCACHE_ALIGN|SLAB_RECLAIM_ACCOUNT|
1198 SLAB_MEM_SPREAD),
Paul Mundt20c2df82007-07-20 10:11:58 +09001199 init_once);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001200 if (!rpc_inode_cachep)
1201 return -ENOMEM;
Stanislav Kinsbursky80df9d22012-01-11 19:18:17 +04001202 err = rpc_clients_notifier_register();
1203 if (err)
1204 goto err_notifier;
Akinobu Mita5bd5f582007-05-09 02:34:51 -07001205 err = register_filesystem(&rpc_pipe_fs_type);
Stanislav Kinsbursky80df9d22012-01-11 19:18:17 +04001206 if (err)
1207 goto err_register;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001208 return 0;
Stanislav Kinsbursky80df9d22012-01-11 19:18:17 +04001209
1210err_register:
1211 rpc_clients_notifier_unregister();
1212err_notifier:
1213 kmem_cache_destroy(rpc_inode_cachep);
1214 return err;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001215}
1216
1217void unregister_rpc_pipefs(void)
1218{
Stanislav Kinsbursky80df9d22012-01-11 19:18:17 +04001219 rpc_clients_notifier_unregister();
Alexey Dobriyan1a1d92c2006-09-27 01:49:40 -07001220 kmem_cache_destroy(rpc_inode_cachep);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001221 unregister_filesystem(&rpc_pipe_fs_type);
1222}