rpc_pipe.c 27.9 KB
Newer Older
L
Linus Torvalds 已提交
1 2 3 4 5
/*
 * net/sunrpc/rpc_pipe.c
 *
 * Userland/kernel interface for rpcauth_gss.
 * Code shamelessly plagiarized from fs/nfsd/nfsctl.c
6
 * and fs/sysfs/inode.c
L
Linus Torvalds 已提交
7 8 9 10 11 12 13 14 15 16
 *
 * Copyright (c) 2002, Trond Myklebust <trond.myklebust@fys.uio.no>
 *
 */
#include <linux/module.h>
#include <linux/slab.h>
#include <linux/string.h>
#include <linux/pagemap.h>
#include <linux/mount.h>
#include <linux/namei.h>
17
#include <linux/fsnotify.h>
L
Linus Torvalds 已提交
18 19 20 21 22 23 24 25 26 27 28
#include <linux/kernel.h>

#include <asm/ioctls.h>
#include <linux/fs.h>
#include <linux/poll.h>
#include <linux/wait.h>
#include <linux/seq_file.h>

#include <linux/sunrpc/clnt.h>
#include <linux/workqueue.h>
#include <linux/sunrpc/rpc_pipe_fs.h>
29
#include <linux/sunrpc/cache.h>
30
#include <linux/nsproxy.h>
31
#include <linux/notifier.h>
32 33

#include "netns.h"
34
#include "sunrpc.h"
L
Linus Torvalds 已提交
35

36 37 38 39
#define RPCDBG_FACILITY RPCDBG_DEBUG

#define NET_NAME(net)	((net == &init_net) ? " (init_net)" : "")

A
Al Viro 已提交
40
static struct vfsmount *rpc_mnt __read_mostly;
L
Linus Torvalds 已提交
41 42 43 44 45
static int rpc_mount_count;

static struct file_system_type rpc_pipe_fs_type;


46
static struct kmem_cache *rpc_inode_cachep __read_mostly;
L
Linus Torvalds 已提交
47 48 49

#define RPC_UPCALL_TIMEOUT (30*HZ)

50 51 52 53 54 55 56 57 58 59 60 61 62 63
static BLOCKING_NOTIFIER_HEAD(rpc_pipefs_notifier_list);

int rpc_pipefs_notifier_register(struct notifier_block *nb)
{
	return blocking_notifier_chain_cond_register(&rpc_pipefs_notifier_list, nb);
}
EXPORT_SYMBOL_GPL(rpc_pipefs_notifier_register);

void rpc_pipefs_notifier_unregister(struct notifier_block *nb)
{
	blocking_notifier_chain_unregister(&rpc_pipefs_notifier_list, nb);
}
EXPORT_SYMBOL_GPL(rpc_pipefs_notifier_unregister);

64
static void rpc_purge_list(struct rpc_pipe *pipe, struct list_head *head,
65
		void (*destroy_msg)(struct rpc_pipe_msg *), int err)
L
Linus Torvalds 已提交
66 67 68
{
	struct rpc_pipe_msg *msg;

69 70 71
	if (list_empty(head))
		return;
	do {
72
		msg = list_entry(head->next, struct rpc_pipe_msg, list);
73
		list_del_init(&msg->list);
L
Linus Torvalds 已提交
74
		msg->errno = err;
75
		destroy_msg(msg);
76
	} while (!list_empty(head));
77
	wake_up(&pipe->waitq);
L
Linus Torvalds 已提交
78 79 80
}

static void
81
rpc_timeout_upcall_queue(struct work_struct *work)
L
Linus Torvalds 已提交
82
{
83
	LIST_HEAD(free_list);
84 85
	struct rpc_pipe *pipe =
		container_of(work, struct rpc_pipe, queue_timeout.work);
86
	void (*destroy_msg)(struct rpc_pipe_msg *);
L
Linus Torvalds 已提交
87

88 89 90
	spin_lock(&pipe->lock);
	if (pipe->ops == NULL) {
		spin_unlock(&pipe->lock);
91 92
		return;
	}
93 94 95 96
	destroy_msg = pipe->ops->destroy_msg;
	if (pipe->nreaders == 0) {
		list_splice_init(&pipe->pipe, &free_list);
		pipe->pipelen = 0;
97
	}
98 99
	spin_unlock(&pipe->lock);
	rpc_purge_list(pipe, &free_list, destroy_msg, -ETIMEDOUT);
L
Linus Torvalds 已提交
100 101
}

102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121
ssize_t rpc_pipe_generic_upcall(struct file *filp, struct rpc_pipe_msg *msg,
				char __user *dst, size_t buflen)
{
	char *data = (char *)msg->data + msg->copied;
	size_t mlen = min(msg->len - msg->copied, buflen);
	unsigned long left;

	left = copy_to_user(dst, data, mlen);
	if (left == mlen) {
		msg->errno = -EFAULT;
		return -EFAULT;
	}

	mlen -= left;
	msg->copied += mlen;
	msg->errno = 0;
	return mlen;
}
EXPORT_SYMBOL_GPL(rpc_pipe_generic_upcall);

122
/**
123
 * rpc_queue_upcall - queue an upcall message to userspace
124 125 126 127 128 129 130 131
 * @inode: inode of upcall pipe on which to queue given message
 * @msg: message to queue
 *
 * Call with an @inode created by rpc_mkpipe() to queue an upcall.
 * A userspace process may then later read the upcall by performing a
 * read on an open file for this inode.  It is up to the caller to
 * initialize the fields of @msg (other than @msg->list) appropriately.
 */
L
Linus Torvalds 已提交
132
int
133
rpc_queue_upcall(struct rpc_pipe *pipe, struct rpc_pipe_msg *msg)
L
Linus Torvalds 已提交
134
{
135
	int res = -EPIPE;
L
Linus Torvalds 已提交
136

137 138
	spin_lock(&pipe->lock);
	if (pipe->ops == NULL)
139
		goto out;
140 141 142
	if (pipe->nreaders) {
		list_add_tail(&msg->list, &pipe->pipe);
		pipe->pipelen += msg->len;
143
		res = 0;
144 145
	} else if (pipe->flags & RPC_PIPE_WAIT_FOR_OPEN) {
		if (list_empty(&pipe->pipe))
146
			queue_delayed_work(rpciod_workqueue,
147
					&pipe->queue_timeout,
L
Linus Torvalds 已提交
148
					RPC_UPCALL_TIMEOUT);
149 150
		list_add_tail(&msg->list, &pipe->pipe);
		pipe->pipelen += msg->len;
151 152 153
		res = 0;
	}
out:
154 155
	spin_unlock(&pipe->lock);
	wake_up(&pipe->waitq);
L
Linus Torvalds 已提交
156 157
	return res;
}
158
EXPORT_SYMBOL_GPL(rpc_queue_upcall);
L
Linus Torvalds 已提交
159

160 161 162 163 164 165
static inline void
rpc_inode_setowner(struct inode *inode, void *private)
{
	RPC_I(inode)->private = private;
}

L
Linus Torvalds 已提交
166 167 168
static void
rpc_close_pipes(struct inode *inode)
{
169
	struct rpc_pipe *pipe = RPC_I(inode)->pipe;
170
	const struct rpc_pipe_ops *ops;
171
	int need_release;
L
Linus Torvalds 已提交
172

173
	mutex_lock(&inode->i_mutex);
174
	ops = pipe->ops;
175 176
	if (ops != NULL) {
		LIST_HEAD(free_list);
177 178 179 180 181 182 183 184 185 186
		spin_lock(&pipe->lock);
		need_release = pipe->nreaders != 0 || pipe->nwriters != 0;
		pipe->nreaders = 0;
		list_splice_init(&pipe->in_upcall, &free_list);
		list_splice_init(&pipe->pipe, &free_list);
		pipe->pipelen = 0;
		pipe->ops = NULL;
		spin_unlock(&pipe->lock);
		rpc_purge_list(pipe, &free_list, ops->destroy_msg, -EPIPE);
		pipe->nwriters = 0;
187
		if (need_release && ops->release_pipe)
188
			ops->release_pipe(inode);
189
		cancel_delayed_work_sync(&pipe->queue_timeout);
L
Linus Torvalds 已提交
190
	}
191
	rpc_inode_setowner(inode, NULL);
192
	mutex_unlock(&inode->i_mutex);
L
Linus Torvalds 已提交
193 194 195 196 197 198
}

static struct inode *
rpc_alloc_inode(struct super_block *sb)
{
	struct rpc_inode *rpci;
199
	rpci = (struct rpc_inode *)kmem_cache_alloc(rpc_inode_cachep, GFP_KERNEL);
L
Linus Torvalds 已提交
200 201 202 203 204 205
	if (!rpci)
		return NULL;
	return &rpci->vfs_inode;
}

static void
N
Nick Piggin 已提交
206
rpc_i_callback(struct rcu_head *head)
L
Linus Torvalds 已提交
207
{
N
Nick Piggin 已提交
208
	struct inode *inode = container_of(head, struct inode, i_rcu);
209
	kfree(RPC_I(inode)->pipe);
L
Linus Torvalds 已提交
210 211 212
	kmem_cache_free(rpc_inode_cachep, RPC_I(inode));
}

N
Nick Piggin 已提交
213 214 215 216 217 218
static void
rpc_destroy_inode(struct inode *inode)
{
	call_rcu(&inode->i_rcu, rpc_i_callback);
}

L
Linus Torvalds 已提交
219 220 221
static int
rpc_pipe_open(struct inode *inode, struct file *filp)
{
222
	struct rpc_pipe *pipe = RPC_I(inode)->pipe;
223
	int first_open;
L
Linus Torvalds 已提交
224 225
	int res = -ENXIO;

226
	mutex_lock(&inode->i_mutex);
227
	if (pipe->ops == NULL)
228
		goto out;
229 230 231
	first_open = pipe->nreaders == 0 && pipe->nwriters == 0;
	if (first_open && pipe->ops->open_pipe) {
		res = pipe->ops->open_pipe(inode);
232 233
		if (res)
			goto out;
L
Linus Torvalds 已提交
234
	}
235
	if (filp->f_mode & FMODE_READ)
236
		pipe->nreaders++;
237
	if (filp->f_mode & FMODE_WRITE)
238
		pipe->nwriters++;
239 240
	res = 0;
out:
241
	mutex_unlock(&inode->i_mutex);
L
Linus Torvalds 已提交
242 243 244 245 246 247
	return res;
}

static int
rpc_pipe_release(struct inode *inode, struct file *filp)
{
248
	struct rpc_pipe *pipe = RPC_I(inode)->pipe;
L
Linus Torvalds 已提交
249
	struct rpc_pipe_msg *msg;
250
	int last_close;
L
Linus Torvalds 已提交
251

252
	mutex_lock(&inode->i_mutex);
253
	if (pipe->ops == NULL)
L
Linus Torvalds 已提交
254
		goto out;
255
	msg = filp->private_data;
L
Linus Torvalds 已提交
256
	if (msg != NULL) {
257
		spin_lock(&pipe->lock);
258
		msg->errno = -EAGAIN;
259
		list_del_init(&msg->list);
260 261
		spin_unlock(&pipe->lock);
		pipe->ops->destroy_msg(msg);
L
Linus Torvalds 已提交
262 263
	}
	if (filp->f_mode & FMODE_WRITE)
264
		pipe->nwriters --;
265
	if (filp->f_mode & FMODE_READ) {
266 267
		pipe->nreaders --;
		if (pipe->nreaders == 0) {
268
			LIST_HEAD(free_list);
269 270 271 272 273 274
			spin_lock(&pipe->lock);
			list_splice_init(&pipe->pipe, &free_list);
			pipe->pipelen = 0;
			spin_unlock(&pipe->lock);
			rpc_purge_list(pipe, &free_list,
					pipe->ops->destroy_msg, -EAGAIN);
275 276
		}
	}
277 278 279
	last_close = pipe->nwriters == 0 && pipe->nreaders == 0;
	if (last_close && pipe->ops->release_pipe)
		pipe->ops->release_pipe(inode);
L
Linus Torvalds 已提交
280
out:
281
	mutex_unlock(&inode->i_mutex);
L
Linus Torvalds 已提交
282 283 284 285 286 287
	return 0;
}

static ssize_t
rpc_pipe_read(struct file *filp, char __user *buf, size_t len, loff_t *offset)
{
J
Josef Sipek 已提交
288
	struct inode *inode = filp->f_path.dentry->d_inode;
289
	struct rpc_pipe *pipe = RPC_I(inode)->pipe;
L
Linus Torvalds 已提交
290 291 292
	struct rpc_pipe_msg *msg;
	int res = 0;

293
	mutex_lock(&inode->i_mutex);
294
	if (pipe->ops == NULL) {
L
Linus Torvalds 已提交
295 296 297 298 299
		res = -EPIPE;
		goto out_unlock;
	}
	msg = filp->private_data;
	if (msg == NULL) {
300 301 302
		spin_lock(&pipe->lock);
		if (!list_empty(&pipe->pipe)) {
			msg = list_entry(pipe->pipe.next,
L
Linus Torvalds 已提交
303 304
					struct rpc_pipe_msg,
					list);
305 306
			list_move(&msg->list, &pipe->in_upcall);
			pipe->pipelen -= msg->len;
L
Linus Torvalds 已提交
307 308 309
			filp->private_data = msg;
			msg->copied = 0;
		}
310
		spin_unlock(&pipe->lock);
L
Linus Torvalds 已提交
311 312 313 314
		if (msg == NULL)
			goto out_unlock;
	}
	/* NOTE: it is up to the callback to update msg->copied */
315
	res = pipe->ops->upcall(filp, msg, buf, len);
L
Linus Torvalds 已提交
316 317
	if (res < 0 || msg->len == msg->copied) {
		filp->private_data = NULL;
318
		spin_lock(&pipe->lock);
319
		list_del_init(&msg->list);
320 321
		spin_unlock(&pipe->lock);
		pipe->ops->destroy_msg(msg);
L
Linus Torvalds 已提交
322 323
	}
out_unlock:
324
	mutex_unlock(&inode->i_mutex);
L
Linus Torvalds 已提交
325 326 327 328 329 330
	return res;
}

static ssize_t
rpc_pipe_write(struct file *filp, const char __user *buf, size_t len, loff_t *offset)
{
J
Josef Sipek 已提交
331
	struct inode *inode = filp->f_path.dentry->d_inode;
332
	struct rpc_pipe *pipe = RPC_I(inode)->pipe;
L
Linus Torvalds 已提交
333 334
	int res;

335
	mutex_lock(&inode->i_mutex);
L
Linus Torvalds 已提交
336
	res = -EPIPE;
337 338
	if (pipe->ops != NULL)
		res = pipe->ops->downcall(filp, buf, len);
339
	mutex_unlock(&inode->i_mutex);
L
Linus Torvalds 已提交
340 341 342 343 344 345
	return res;
}

static unsigned int
rpc_pipe_poll(struct file *filp, struct poll_table_struct *wait)
{
346
	struct rpc_pipe *pipe = RPC_I(filp->f_path.dentry->d_inode)->pipe;
L
Linus Torvalds 已提交
347 348
	unsigned int mask = 0;

349
	poll_wait(filp, &pipe->waitq, wait);
L
Linus Torvalds 已提交
350 351

	mask = POLLOUT | POLLWRNORM;
352
	if (pipe->ops == NULL)
L
Linus Torvalds 已提交
353
		mask |= POLLERR | POLLHUP;
354
	if (filp->private_data || !list_empty(&pipe->pipe))
L
Linus Torvalds 已提交
355 356 357 358
		mask |= POLLIN | POLLRDNORM;
	return mask;
}

A
Arnd Bergmann 已提交
359 360
static long
rpc_pipe_ioctl(struct file *filp, unsigned int cmd, unsigned long arg)
L
Linus Torvalds 已提交
361
{
A
Arnd Bergmann 已提交
362
	struct inode *inode = filp->f_path.dentry->d_inode;
363
	struct rpc_pipe *pipe = RPC_I(inode)->pipe;
L
Linus Torvalds 已提交
364 365 366 367
	int len;

	switch (cmd) {
	case FIONREAD:
368 369 370
		spin_lock(&pipe->lock);
		if (pipe->ops == NULL) {
			spin_unlock(&pipe->lock);
L
Linus Torvalds 已提交
371
			return -EPIPE;
A
Arnd Bergmann 已提交
372
		}
373
		len = pipe->pipelen;
L
Linus Torvalds 已提交
374 375
		if (filp->private_data) {
			struct rpc_pipe_msg *msg;
376
			msg = filp->private_data;
L
Linus Torvalds 已提交
377 378
			len += msg->len - msg->copied;
		}
379
		spin_unlock(&pipe->lock);
L
Linus Torvalds 已提交
380 381 382 383 384 385
		return put_user(len, (int __user *)arg);
	default:
		return -EINVAL;
	}
}

386
static const struct file_operations rpc_pipe_fops = {
L
Linus Torvalds 已提交
387 388 389 390 391
	.owner		= THIS_MODULE,
	.llseek		= no_llseek,
	.read		= rpc_pipe_read,
	.write		= rpc_pipe_write,
	.poll		= rpc_pipe_poll,
392
	.unlocked_ioctl	= rpc_pipe_ioctl,
L
Linus Torvalds 已提交
393 394 395 396 397 398 399 400 401 402 403 404
	.open		= rpc_pipe_open,
	.release	= rpc_pipe_release,
};

static int
rpc_show_info(struct seq_file *m, void *v)
{
	struct rpc_clnt *clnt = m->private;

	seq_printf(m, "RPC server: %s\n", clnt->cl_server);
	seq_printf(m, "service: %s (%d) version %d\n", clnt->cl_protname,
			clnt->cl_prog, clnt->cl_vers);
405 406
	seq_printf(m, "address: %s\n", rpc_peeraddr2str(clnt, RPC_DISPLAY_ADDR));
	seq_printf(m, "protocol: %s\n", rpc_peeraddr2str(clnt, RPC_DISPLAY_PROTO));
407
	seq_printf(m, "port: %s\n", rpc_peeraddr2str(clnt, RPC_DISPLAY_PORT));
L
Linus Torvalds 已提交
408 409 410 411 412 413
	return 0;
}

static int
rpc_info_open(struct inode *inode, struct file *file)
{
414
	struct rpc_clnt *clnt = NULL;
L
Linus Torvalds 已提交
415 416 417 418
	int ret = single_open(file, rpc_show_info, NULL);

	if (!ret) {
		struct seq_file *m = file->private_data;
419 420 421 422 423 424

		spin_lock(&file->f_path.dentry->d_lock);
		if (!d_unhashed(file->f_path.dentry))
			clnt = RPC_I(inode)->private;
		if (clnt != NULL && atomic_inc_not_zero(&clnt->cl_count)) {
			spin_unlock(&file->f_path.dentry->d_lock);
L
Linus Torvalds 已提交
425 426
			m->private = clnt;
		} else {
427
			spin_unlock(&file->f_path.dentry->d_lock);
L
Linus Torvalds 已提交
428 429 430 431 432 433 434 435 436 437 438 439 440 441 442 443 444 445
			single_release(inode, file);
			ret = -EINVAL;
		}
	}
	return ret;
}

static int
rpc_info_release(struct inode *inode, struct file *file)
{
	struct seq_file *m = file->private_data;
	struct rpc_clnt *clnt = (struct rpc_clnt *)m->private;

	if (clnt)
		rpc_release_client(clnt);
	return single_release(inode, file);
}

446
static const struct file_operations rpc_info_operations = {
L
Linus Torvalds 已提交
447 448 449 450 451 452 453 454 455 456 457 458
	.owner		= THIS_MODULE,
	.open		= rpc_info_open,
	.read		= seq_read,
	.llseek		= seq_lseek,
	.release	= rpc_info_release,
};


/*
 * Description of fs contents.
 */
struct rpc_filelist {
459
	const char *name;
460
	const struct file_operations *i_fop;
461
	umode_t mode;
L
Linus Torvalds 已提交
462 463
};

464
struct vfsmount *rpc_get_mount(void)
L
Linus Torvalds 已提交
465
{
466 467
	int err;

A
Al Viro 已提交
468
	err = simple_pin_fs(&rpc_pipe_fs_type, &rpc_mnt, &rpc_mount_count);
469 470
	if (err != 0)
		return ERR_PTR(err);
A
Al Viro 已提交
471
	return rpc_mnt;
L
Linus Torvalds 已提交
472
}
473
EXPORT_SYMBOL_GPL(rpc_get_mount);
L
Linus Torvalds 已提交
474

475
void rpc_put_mount(void)
L
Linus Torvalds 已提交
476
{
A
Al Viro 已提交
477
	simple_release_fs(&rpc_mnt, &rpc_mount_count);
L
Linus Torvalds 已提交
478
}
479
EXPORT_SYMBOL_GPL(rpc_put_mount);
L
Linus Torvalds 已提交
480

N
Nick Piggin 已提交
481
static int rpc_delete_dentry(const struct dentry *dentry)
T
Trond Myklebust 已提交
482 483 484 485
{
	return 1;
}

A
Al Viro 已提交
486
static const struct dentry_operations rpc_dentry_operations = {
T
Trond Myklebust 已提交
487 488 489
	.d_delete = rpc_delete_dentry,
};

L
Linus Torvalds 已提交
490
static struct inode *
491
rpc_get_inode(struct super_block *sb, umode_t mode)
L
Linus Torvalds 已提交
492 493 494 495
{
	struct inode *inode = new_inode(sb);
	if (!inode)
		return NULL;
496
	inode->i_ino = get_next_ino();
L
Linus Torvalds 已提交
497 498
	inode->i_mode = mode;
	inode->i_atime = inode->i_mtime = inode->i_ctime = CURRENT_TIME;
J
Joe Perches 已提交
499 500 501 502 503 504 505
	switch (mode & S_IFMT) {
	case S_IFDIR:
		inode->i_fop = &simple_dir_operations;
		inode->i_op = &simple_dir_inode_operations;
		inc_nlink(inode);
	default:
		break;
L
Linus Torvalds 已提交
506 507 508 509
	}
	return inode;
}

510 511 512 513 514 515 516
static int __rpc_create_common(struct inode *dir, struct dentry *dentry,
			       umode_t mode,
			       const struct file_operations *i_fop,
			       void *private)
{
	struct inode *inode;

T
Trond Myklebust 已提交
517
	d_drop(dentry);
518 519 520 521 522 523 524 525 526 527 528 529 530 531 532 533 534
	inode = rpc_get_inode(dir->i_sb, mode);
	if (!inode)
		goto out_err;
	inode->i_ino = iunique(dir->i_sb, 100);
	if (i_fop)
		inode->i_fop = i_fop;
	if (private)
		rpc_inode_setowner(inode, private);
	d_add(dentry, inode);
	return 0;
out_err:
	printk(KERN_WARNING "%s: %s failed to allocate inode for dentry %s\n",
			__FILE__, __func__, dentry->d_name.name);
	dput(dentry);
	return -ENOMEM;
}

535 536 537 538 539 540 541 542 543 544 545 546 547 548
static int __rpc_create(struct inode *dir, struct dentry *dentry,
			umode_t mode,
			const struct file_operations *i_fop,
			void *private)
{
	int err;

	err = __rpc_create_common(dir, dentry, S_IFREG | mode, i_fop, private);
	if (err)
		return err;
	fsnotify_create(dir, dentry);
	return 0;
}

549 550 551 552 553 554 555 556 557 558 559 560 561 562 563
static int __rpc_mkdir(struct inode *dir, struct dentry *dentry,
		       umode_t mode,
		       const struct file_operations *i_fop,
		       void *private)
{
	int err;

	err = __rpc_create_common(dir, dentry, S_IFDIR | mode, i_fop, private);
	if (err)
		return err;
	inc_nlink(dir);
	fsnotify_mkdir(dir, dentry);
	return 0;
}

564 565 566 567 568 569 570 571 572 573 574 575 576 577 578 579 580
static void
init_pipe(struct rpc_pipe *pipe)
{
	pipe->nreaders = 0;
	pipe->nwriters = 0;
	INIT_LIST_HEAD(&pipe->in_upcall);
	INIT_LIST_HEAD(&pipe->in_downcall);
	INIT_LIST_HEAD(&pipe->pipe);
	pipe->pipelen = 0;
	init_waitqueue_head(&pipe->waitq);
	INIT_DELAYED_WORK(&pipe->queue_timeout,
			    rpc_timeout_upcall_queue);
	pipe->ops = NULL;
	spin_lock_init(&pipe->lock);

}

581 582 583 584 585 586 587
static int __rpc_mkpipe(struct inode *dir, struct dentry *dentry,
			umode_t mode,
			const struct file_operations *i_fop,
			void *private,
			const struct rpc_pipe_ops *ops,
			int flags)
{
588
	struct rpc_pipe *pipe;
589 590 591
	struct rpc_inode *rpci;
	int err;

592 593 594 595
	pipe = kzalloc(sizeof(struct rpc_pipe), GFP_KERNEL);
	if (!pipe)
		return -ENOMEM;
	init_pipe(pipe);
596
	err = __rpc_create_common(dir, dentry, S_IFIFO | mode, i_fop, private);
597 598
	if (err) {
		kfree(pipe);
599
		return err;
600
	}
601 602
	rpci = RPC_I(dentry->d_inode);
	rpci->private = private;
603 604 605
	rpci->pipe = pipe;
	rpci->pipe->flags = flags;
	rpci->pipe->ops = ops;
606 607 608 609
	fsnotify_create(dir, dentry);
	return 0;
}

610 611 612 613 614 615 616 617 618 619 620
static int __rpc_rmdir(struct inode *dir, struct dentry *dentry)
{
	int ret;

	dget(dentry);
	ret = simple_rmdir(dir, dentry);
	d_delete(dentry);
	dput(dentry);
	return ret;
}

T
Trond Myklebust 已提交
621 622 623 624 625 626 627 628 629 630 631 632 633 634 635 636 637 638 639
static int __rpc_unlink(struct inode *dir, struct dentry *dentry)
{
	int ret;

	dget(dentry);
	ret = simple_unlink(dir, dentry);
	d_delete(dentry);
	dput(dentry);
	return ret;
}

static int __rpc_rmpipe(struct inode *dir, struct dentry *dentry)
{
	struct inode *inode = dentry->d_inode;

	rpc_close_pipes(inode);
	return __rpc_unlink(dir, dentry);
}

640
static struct dentry *__rpc_lookup_create_exclusive(struct dentry *parent,
641 642 643 644 645 646 647
					  struct qstr *name)
{
	struct dentry *dentry;

	dentry = d_lookup(parent, name);
	if (!dentry) {
		dentry = d_alloc(parent, name);
648 649
		if (!dentry)
			return ERR_PTR(-ENOMEM);
650
	}
651
	if (dentry->d_inode == NULL) {
652
		d_set_d_op(dentry, &rpc_dentry_operations);
653
		return dentry;
654
	}
655 656 657 658
	dput(dentry);
	return ERR_PTR(-EEXIST);
}

L
Linus Torvalds 已提交
659 660 661
/*
 * FIXME: This probably has races.
 */
662 663 664
static void __rpc_depopulate(struct dentry *parent,
			     const struct rpc_filelist *files,
			     int start, int eof)
L
Linus Torvalds 已提交
665 666
{
	struct inode *dir = parent->d_inode;
667 668 669
	struct dentry *dentry;
	struct qstr name;
	int i;
L
Linus Torvalds 已提交
670

671 672 673 674 675 676 677
	for (i = start; i < eof; i++) {
		name.name = files[i].name;
		name.len = strlen(files[i].name);
		name.hash = full_name_hash(name.name, name.len);
		dentry = d_lookup(parent, &name);

		if (dentry == NULL)
T
Trond Myklebust 已提交
678
			continue;
679 680 681 682 683 684 685
		if (dentry->d_inode == NULL)
			goto next;
		switch (dentry->d_inode->i_mode & S_IFMT) {
			default:
				BUG();
			case S_IFREG:
				__rpc_unlink(dir, dentry);
L
Linus Torvalds 已提交
686
				break;
687 688 689 690 691
			case S_IFDIR:
				__rpc_rmdir(dir, dentry);
		}
next:
		dput(dentry);
L
Linus Torvalds 已提交
692
	}
693 694 695 696 697 698 699 700 701 702
}

static void rpc_depopulate(struct dentry *parent,
			   const struct rpc_filelist *files,
			   int start, int eof)
{
	struct inode *dir = parent->d_inode;

	mutex_lock_nested(&dir->i_mutex, I_MUTEX_CHILD);
	__rpc_depopulate(parent, files, start, eof);
703
	mutex_unlock(&dir->i_mutex);
L
Linus Torvalds 已提交
704 705
}

706 707 708 709
static int rpc_populate(struct dentry *parent,
			const struct rpc_filelist *files,
			int start, int eof,
			void *private)
L
Linus Torvalds 已提交
710
{
711
	struct inode *dir = parent->d_inode;
L
Linus Torvalds 已提交
712
	struct dentry *dentry;
713
	int i, err;
L
Linus Torvalds 已提交
714

715
	mutex_lock(&dir->i_mutex);
L
Linus Torvalds 已提交
716
	for (i = start; i < eof; i++) {
717 718 719 720 721 722 723 724
		struct qstr q;

		q.name = files[i].name;
		q.len = strlen(files[i].name);
		q.hash = full_name_hash(q.name, q.len);
		dentry = __rpc_lookup_create_exclusive(parent, &q);
		err = PTR_ERR(dentry);
		if (IS_ERR(dentry))
L
Linus Torvalds 已提交
725
			goto out_bad;
726 727 728 729 730 731 732 733 734 735 736 737 738 739
		switch (files[i].mode & S_IFMT) {
			default:
				BUG();
			case S_IFREG:
				err = __rpc_create(dir, dentry,
						files[i].mode,
						files[i].i_fop,
						private);
				break;
			case S_IFDIR:
				err = __rpc_mkdir(dir, dentry,
						files[i].mode,
						NULL,
						private);
L
Linus Torvalds 已提交
740
		}
741 742
		if (err != 0)
			goto out_bad;
L
Linus Torvalds 已提交
743
	}
744
	mutex_unlock(&dir->i_mutex);
L
Linus Torvalds 已提交
745 746
	return 0;
out_bad:
747
	__rpc_depopulate(parent, files, start, eof);
748
	mutex_unlock(&dir->i_mutex);
L
Linus Torvalds 已提交
749
	printk(KERN_WARNING "%s: %s failed to populate directory %s\n",
750
			__FILE__, __func__, parent->d_name.name);
751
	return err;
752
}
L
Linus Torvalds 已提交
753

754 755 756
static struct dentry *rpc_mkdir_populate(struct dentry *parent,
		struct qstr *name, umode_t mode, void *private,
		int (*populate)(struct dentry *, void *), void *args_populate)
757 758
{
	struct dentry *dentry;
759
	struct inode *dir = parent->d_inode;
760 761
	int error;

762 763
	mutex_lock_nested(&dir->i_mutex, I_MUTEX_PARENT);
	dentry = __rpc_lookup_create_exclusive(parent, name);
764
	if (IS_ERR(dentry))
765 766
		goto out;
	error = __rpc_mkdir(dir, dentry, mode, NULL, private);
767 768
	if (error != 0)
		goto out_err;
769 770 771 772 773
	if (populate != NULL) {
		error = populate(dentry, args_populate);
		if (error)
			goto err_rmdir;
	}
774
out:
775
	mutex_unlock(&dir->i_mutex);
776
	return dentry;
777
err_rmdir:
778
	__rpc_rmdir(dir, dentry);
779
out_err:
780 781
	dentry = ERR_PTR(error);
	goto out;
L
Linus Torvalds 已提交
782 783
}

784 785
static int rpc_rmdir_depopulate(struct dentry *dentry,
		void (*depopulate)(struct dentry *))
L
Linus Torvalds 已提交
786
{
T
Trond Myklebust 已提交
787
	struct dentry *parent;
788 789
	struct inode *dir;
	int error;
790

T
Trond Myklebust 已提交
791 792
	parent = dget_parent(dentry);
	dir = parent->d_inode;
793
	mutex_lock_nested(&dir->i_mutex, I_MUTEX_PARENT);
794 795
	if (depopulate != NULL)
		depopulate(dentry);
796
	error = __rpc_rmdir(dir, dentry);
797
	mutex_unlock(&dir->i_mutex);
T
Trond Myklebust 已提交
798
	dput(parent);
799
	return error;
L
Linus Torvalds 已提交
800 801
}

802 803 804 805 806 807
/**
 * rpc_mkpipe - make an rpc_pipefs file for kernel<->userspace communication
 * @parent: dentry of directory to create new "pipe" in
 * @name: name of pipe
 * @private: private data to associate with the pipe, for the caller's use
 * @ops: operations defining the behavior of the pipe: upcall, downcall,
808
 *	release_pipe, open_pipe, and destroy_msg.
809
 * @flags: rpc_pipe flags
810 811 812 813 814 815 816 817 818 819 820 821
 *
 * Data is made available for userspace to read by calls to
 * rpc_queue_upcall().  The actual reads will result in calls to
 * @ops->upcall, which will be called with the file pointer,
 * message, and userspace buffer to copy to.
 *
 * Writes can come at any time, and do not necessarily have to be
 * responses to upcalls.  They will result in calls to @msg->downcall.
 *
 * The @private argument passed here will be available to all these methods
 * from the file pointer, via RPC_I(file->f_dentry->d_inode)->private.
 */
822 823 824
struct dentry *rpc_mkpipe(struct dentry *parent, const char *name,
			  void *private, const struct rpc_pipe_ops *ops,
			  int flags)
L
Linus Torvalds 已提交
825 826
{
	struct dentry *dentry;
827
	struct inode *dir = parent->d_inode;
828
	umode_t umode = S_IFIFO | S_IRUSR | S_IWUSR;
829
	struct qstr q;
830
	int err;
831 832 833 834 835

	if (ops->upcall == NULL)
		umode &= ~S_IRUGO;
	if (ops->downcall == NULL)
		umode &= ~S_IWUGO;
L
Linus Torvalds 已提交
836

837 838 839 840 841
	q.name = name;
	q.len = strlen(name);
	q.hash = full_name_hash(q.name, q.len),

	mutex_lock_nested(&dir->i_mutex, I_MUTEX_PARENT);
842
	dentry = __rpc_lookup_create_exclusive(parent, &q);
L
Linus Torvalds 已提交
843
	if (IS_ERR(dentry))
844
		goto out;
845
	err = __rpc_mkpipe(dir, dentry, umode, &rpc_pipe_fops,
T
Trond Myklebust 已提交
846
			   private, ops, flags);
847 848
	if (err)
		goto out_err;
849
out:
850
	mutex_unlock(&dir->i_mutex);
851
	return dentry;
852 853
out_err:
	dentry = ERR_PTR(err);
854
	printk(KERN_WARNING "%s: %s() failed to create pipe %s/%s (errno = %d)\n",
855
			__FILE__, __func__, parent->d_name.name, name,
856
			err);
857
	goto out;
L
Linus Torvalds 已提交
858
}
859
EXPORT_SYMBOL_GPL(rpc_mkpipe);
L
Linus Torvalds 已提交
860

861 862 863 864 865 866 867 868
/**
 * rpc_unlink - remove a pipe
 * @dentry: dentry for the pipe, as returned from rpc_mkpipe
 *
 * After this call, lookups will no longer find the pipe, and any
 * attempts to read or write using preexisting opens of the pipe will
 * return -EPIPE.
 */
869
int
870
rpc_unlink(struct dentry *dentry)
L
Linus Torvalds 已提交
871
{
872
	struct dentry *parent;
873
	struct inode *dir;
874
	int error = 0;
L
Linus Torvalds 已提交
875

876 877
	parent = dget_parent(dentry);
	dir = parent->d_inode;
878
	mutex_lock_nested(&dir->i_mutex, I_MUTEX_PARENT);
T
Trond Myklebust 已提交
879
	error = __rpc_rmpipe(dir, dentry);
880
	mutex_unlock(&dir->i_mutex);
881
	dput(parent);
882
	return error;
L
Linus Torvalds 已提交
883
}
884
EXPORT_SYMBOL_GPL(rpc_unlink);
L
Linus Torvalds 已提交
885

886 887 888 889 890 891 892 893 894 895 896 897 898 899 900 901 902 903 904 905 906 907 908 909 910
enum {
	RPCAUTH_info,
	RPCAUTH_EOF
};

static const struct rpc_filelist authfiles[] = {
	[RPCAUTH_info] = {
		.name = "info",
		.i_fop = &rpc_info_operations,
		.mode = S_IFREG | S_IRUSR,
	},
};

static int rpc_clntdir_populate(struct dentry *dentry, void *private)
{
	return rpc_populate(dentry,
			    authfiles, RPCAUTH_info, RPCAUTH_EOF,
			    private);
}

static void rpc_clntdir_depopulate(struct dentry *dentry)
{
	rpc_depopulate(dentry, authfiles, RPCAUTH_info, RPCAUTH_EOF);
}

911 912
/**
 * rpc_create_client_dir - Create a new rpc_client directory in rpc_pipefs
913 914
 * @dentry: dentry from the rpc_pipefs root to the new directory
 * @name: &struct qstr for the name
915 916 917 918 919 920 921
 * @rpc_client: rpc client to associate with this directory
 *
 * This creates a directory at the given @path associated with
 * @rpc_clnt, which will contain a file named "info" with some basic
 * information about the client, together with any "pipes" that may
 * later be created using rpc_mkpipe().
 */
922
struct dentry *rpc_create_client_dir(struct dentry *dentry,
923 924 925 926 927 928 929 930 931 932 933 934
				   struct qstr *name,
				   struct rpc_clnt *rpc_client)
{
	return rpc_mkdir_populate(dentry, name, S_IRUGO | S_IXUGO, NULL,
			rpc_clntdir_populate, rpc_client);
}

/**
 * rpc_remove_client_dir - Remove a directory created with rpc_create_client_dir()
 * @dentry: directory to remove
 */
int rpc_remove_client_dir(struct dentry *dentry)
935
{
936
	return rpc_rmdir_depopulate(dentry, rpc_clntdir_depopulate);
937 938
}

939 940 941 942
static const struct rpc_filelist cache_pipefs_files[3] = {
	[0] = {
		.name = "channel",
		.i_fop = &cache_file_operations_pipefs,
943
		.mode = S_IFREG|S_IRUSR|S_IWUSR,
944 945 946 947 948 949 950 951 952 953 954 955 956 957 958 959 960 961 962 963 964 965 966 967 968 969
	},
	[1] = {
		.name = "content",
		.i_fop = &content_file_operations_pipefs,
		.mode = S_IFREG|S_IRUSR,
	},
	[2] = {
		.name = "flush",
		.i_fop = &cache_flush_operations_pipefs,
		.mode = S_IFREG|S_IRUSR|S_IWUSR,
	},
};

static int rpc_cachedir_populate(struct dentry *dentry, void *private)
{
	return rpc_populate(dentry,
			    cache_pipefs_files, 0, 3,
			    private);
}

static void rpc_cachedir_depopulate(struct dentry *dentry)
{
	rpc_depopulate(dentry, cache_pipefs_files, 0, 3);
}

struct dentry *rpc_create_cache_dir(struct dentry *parent, struct qstr *name,
A
Al Viro 已提交
970
				    umode_t umode, struct cache_detail *cd)
971 972 973 974 975 976 977 978 979 980
{
	return rpc_mkdir_populate(parent, name, umode, NULL,
			rpc_cachedir_populate, cd);
}

void rpc_remove_cache_dir(struct dentry *dentry)
{
	rpc_rmdir_depopulate(dentry, rpc_cachedir_depopulate);
}

L
Linus Torvalds 已提交
981 982 983
/*
 * populate the filesystem
 */
984
static const struct super_operations s_ops = {
L
Linus Torvalds 已提交
985 986 987 988 989 990 991
	.alloc_inode	= rpc_alloc_inode,
	.destroy_inode	= rpc_destroy_inode,
	.statfs		= simple_statfs,
};

#define RPCAUTH_GSSMAGIC 0x67596969

T
Trond Myklebust 已提交
992 993 994 995 996 997 998 999 1000 1001
/*
 * We have a single directory with 1 node in it.
 */
enum {
	RPCAUTH_lockd,
	RPCAUTH_mount,
	RPCAUTH_nfs,
	RPCAUTH_portmap,
	RPCAUTH_statd,
	RPCAUTH_nfsd4_cb,
1002
	RPCAUTH_cache,
T
Trond Myklebust 已提交
1003 1004 1005 1006 1007 1008 1009 1010 1011 1012 1013 1014 1015 1016 1017 1018 1019 1020 1021 1022 1023 1024 1025 1026 1027 1028 1029 1030
	RPCAUTH_RootEOF
};

static const struct rpc_filelist files[] = {
	[RPCAUTH_lockd] = {
		.name = "lockd",
		.mode = S_IFDIR | S_IRUGO | S_IXUGO,
	},
	[RPCAUTH_mount] = {
		.name = "mount",
		.mode = S_IFDIR | S_IRUGO | S_IXUGO,
	},
	[RPCAUTH_nfs] = {
		.name = "nfs",
		.mode = S_IFDIR | S_IRUGO | S_IXUGO,
	},
	[RPCAUTH_portmap] = {
		.name = "portmap",
		.mode = S_IFDIR | S_IRUGO | S_IXUGO,
	},
	[RPCAUTH_statd] = {
		.name = "statd",
		.mode = S_IFDIR | S_IRUGO | S_IXUGO,
	},
	[RPCAUTH_nfsd4_cb] = {
		.name = "nfsd4_cb",
		.mode = S_IFDIR | S_IRUGO | S_IXUGO,
	},
1031 1032 1033 1034
	[RPCAUTH_cache] = {
		.name = "cache",
		.mode = S_IFDIR | S_IRUGO | S_IXUGO,
	},
T
Trond Myklebust 已提交
1035 1036
};

1037 1038 1039 1040 1041 1042 1043 1044 1045 1046 1047 1048 1049 1050 1051 1052
/*
 * This call can be used only in RPC pipefs mount notification hooks.
 */
struct dentry *rpc_d_lookup_sb(const struct super_block *sb,
			       const unsigned char *dir_name)
{
	struct qstr dir = {
		.name = dir_name,
		.len = strlen(dir_name),
		.hash = full_name_hash(dir_name, strlen(dir_name)),
	};

	return d_lookup(sb->s_root, &dir);
}
EXPORT_SYMBOL_GPL(rpc_d_lookup_sb);

1053 1054 1055 1056 1057 1058 1059 1060 1061 1062 1063 1064 1065 1066 1067 1068 1069 1070 1071 1072 1073 1074 1075 1076 1077 1078 1079 1080 1081 1082 1083 1084 1085 1086
void rpc_pipefs_init_net(struct net *net)
{
	struct sunrpc_net *sn = net_generic(net, sunrpc_net_id);

	mutex_init(&sn->pipefs_sb_lock);
}

/*
 * This call will be used for per network namespace operations calls.
 * Note: Function will be returned with pipefs_sb_lock taken if superblock was
 * found. This lock have to be released by rpc_put_sb_net() when all operations
 * will be completed.
 */
struct super_block *rpc_get_sb_net(const struct net *net)
{
	struct sunrpc_net *sn = net_generic(net, sunrpc_net_id);

	mutex_lock(&sn->pipefs_sb_lock);
	if (sn->pipefs_sb)
		return sn->pipefs_sb;
	mutex_unlock(&sn->pipefs_sb_lock);
	return NULL;
}
EXPORT_SYMBOL_GPL(rpc_get_sb_net);

void rpc_put_sb_net(const struct net *net)
{
	struct sunrpc_net *sn = net_generic(net, sunrpc_net_id);

	BUG_ON(sn->pipefs_sb == NULL);
	mutex_unlock(&sn->pipefs_sb_lock);
}
EXPORT_SYMBOL_GPL(rpc_put_sb_net);

L
Linus Torvalds 已提交
1087 1088 1089 1090 1091
static int
rpc_fill_super(struct super_block *sb, void *data, int silent)
{
	struct inode *inode;
	struct dentry *root;
1092
	struct net *net = data;
1093
	struct sunrpc_net *sn = net_generic(net, sunrpc_net_id);
1094
	int err;
L
Linus Torvalds 已提交
1095 1096 1097 1098 1099 1100 1101 1102 1103 1104

	sb->s_blocksize = PAGE_CACHE_SIZE;
	sb->s_blocksize_bits = PAGE_CACHE_SHIFT;
	sb->s_magic = RPCAUTH_GSSMAGIC;
	sb->s_op = &s_ops;
	sb->s_time_gran = 1;

	inode = rpc_get_inode(sb, S_IFDIR | 0755);
	if (!inode)
		return -ENOMEM;
1105
	sb->s_root = root = d_alloc_root(inode);
L
Linus Torvalds 已提交
1106 1107 1108 1109
	if (!root) {
		iput(inode);
		return -ENOMEM;
	}
1110
	if (rpc_populate(root, files, RPCAUTH_lockd, RPCAUTH_RootEOF, NULL))
1111
		return -ENOMEM;
1112 1113
	dprintk("RPC:	sending pipefs MOUNT notification for net %p%s\n", net,
								NET_NAME(net));
1114 1115 1116 1117 1118
	err = blocking_notifier_call_chain(&rpc_pipefs_notifier_list,
					   RPC_PIPEFS_MOUNT,
					   sb);
	if (err)
		goto err_depopulate;
1119
	sb->s_fs_info = get_net(net);
1120
	sn->pipefs_sb = sb;
L
Linus Torvalds 已提交
1121
	return 0;
1122 1123 1124 1125 1126 1127 1128

err_depopulate:
	blocking_notifier_call_chain(&rpc_pipefs_notifier_list,
					   RPC_PIPEFS_UMOUNT,
					   sb);
	__rpc_depopulate(root, files, RPCAUTH_lockd, RPCAUTH_RootEOF);
	return err;
L
Linus Torvalds 已提交
1129 1130
}

A
Al Viro 已提交
1131 1132 1133
static struct dentry *
rpc_mount(struct file_system_type *fs_type,
		int flags, const char *dev_name, void *data)
L
Linus Torvalds 已提交
1134
{
1135
	return mount_ns(fs_type, flags, current->nsproxy->net_ns, rpc_fill_super);
L
Linus Torvalds 已提交
1136 1137
}

1138 1139 1140
void rpc_kill_sb(struct super_block *sb)
{
	struct net *net = sb->s_fs_info;
1141
	struct sunrpc_net *sn = net_generic(net, sunrpc_net_id);
1142

1143
	mutex_lock(&sn->pipefs_sb_lock);
1144
	sn->pipefs_sb = NULL;
1145
	mutex_unlock(&sn->pipefs_sb_lock);
1146
	put_net(net);
1147 1148
	dprintk("RPC:	sending pipefs UMOUNT notification for net %p%s\n", net,
								NET_NAME(net));
1149 1150 1151
	blocking_notifier_call_chain(&rpc_pipefs_notifier_list,
					   RPC_PIPEFS_UMOUNT,
					   sb);
1152 1153 1154
	kill_litter_super(sb);
}

L
Linus Torvalds 已提交
1155 1156 1157
static struct file_system_type rpc_pipe_fs_type = {
	.owner		= THIS_MODULE,
	.name		= "rpc_pipefs",
A
Al Viro 已提交
1158
	.mount		= rpc_mount,
1159
	.kill_sb	= rpc_kill_sb,
L
Linus Torvalds 已提交
1160 1161 1162
};

static void
1163
init_once(void *foo)
L
Linus Torvalds 已提交
1164 1165 1166
{
	struct rpc_inode *rpci = (struct rpc_inode *) foo;

C
Christoph Lameter 已提交
1167 1168
	inode_init_once(&rpci->vfs_inode);
	rpci->private = NULL;
1169
	rpci->pipe = NULL;
L
Linus Torvalds 已提交
1170 1171 1172 1173
}

int register_rpc_pipefs(void)
{
1174 1175
	int err;

L
Linus Torvalds 已提交
1176
	rpc_inode_cachep = kmem_cache_create("rpc_inode_cache",
1177 1178 1179
				sizeof(struct rpc_inode),
				0, (SLAB_HWCACHE_ALIGN|SLAB_RECLAIM_ACCOUNT|
						SLAB_MEM_SPREAD),
1180
				init_once);
L
Linus Torvalds 已提交
1181 1182
	if (!rpc_inode_cachep)
		return -ENOMEM;
1183 1184 1185 1186 1187 1188
	err = register_filesystem(&rpc_pipe_fs_type);
	if (err) {
		kmem_cache_destroy(rpc_inode_cachep);
		return err;
	}

L
Linus Torvalds 已提交
1189 1190 1191 1192 1193
	return 0;
}

void unregister_rpc_pipefs(void)
{
1194
	kmem_cache_destroy(rpc_inode_cachep);
L
Linus Torvalds 已提交
1195 1196
	unregister_filesystem(&rpc_pipe_fs_type);
}
1197 1198 1199

/* Make 'mount -t rpc_pipefs ...' autoload this module. */
MODULE_ALIAS("rpc_pipefs");