rpc_pipe.c 28.1 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 91 92
	spin_lock(&pipe->lock);
	destroy_msg = pipe->ops->destroy_msg;
	if (pipe->nreaders == 0) {
		list_splice_init(&pipe->pipe, &free_list);
		pipe->pipelen = 0;
93
	}
94 95
	spin_unlock(&pipe->lock);
	rpc_purge_list(pipe, &free_list, destroy_msg, -ETIMEDOUT);
L
Linus Torvalds 已提交
96 97
}

98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117
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);

118
/**
119
 * rpc_queue_upcall - queue an upcall message to userspace
120 121 122 123 124 125 126 127
 * @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 已提交
128
int
129
rpc_queue_upcall(struct rpc_pipe *pipe, struct rpc_pipe_msg *msg)
L
Linus Torvalds 已提交
130
{
131
	int res = -EPIPE;
L
Linus Torvalds 已提交
132

133 134 135 136
	spin_lock(&pipe->lock);
	if (pipe->nreaders) {
		list_add_tail(&msg->list, &pipe->pipe);
		pipe->pipelen += msg->len;
137
		res = 0;
138 139
	} else if (pipe->flags & RPC_PIPE_WAIT_FOR_OPEN) {
		if (list_empty(&pipe->pipe))
140
			queue_delayed_work(rpciod_workqueue,
141
					&pipe->queue_timeout,
L
Linus Torvalds 已提交
142
					RPC_UPCALL_TIMEOUT);
143 144
		list_add_tail(&msg->list, &pipe->pipe);
		pipe->pipelen += msg->len;
145 146
		res = 0;
	}
147 148
	spin_unlock(&pipe->lock);
	wake_up(&pipe->waitq);
L
Linus Torvalds 已提交
149 150
	return res;
}
151
EXPORT_SYMBOL_GPL(rpc_queue_upcall);
L
Linus Torvalds 已提交
152

153 154 155 156 157 158
static inline void
rpc_inode_setowner(struct inode *inode, void *private)
{
	RPC_I(inode)->private = private;
}

L
Linus Torvalds 已提交
159 160 161
static void
rpc_close_pipes(struct inode *inode)
{
162
	struct rpc_pipe *pipe = RPC_I(inode)->pipe;
163
	int need_release;
164
	LIST_HEAD(free_list);
L
Linus Torvalds 已提交
165

166
	mutex_lock(&inode->i_mutex);
167 168 169 170 171 172 173 174 175 176 177 178 179
	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->dentry = NULL;
	spin_unlock(&pipe->lock);
	rpc_purge_list(pipe, &free_list, pipe->ops->destroy_msg, -EPIPE);
	pipe->nwriters = 0;
	if (need_release && pipe->ops->release_pipe)
		pipe->ops->release_pipe(inode);
	cancel_delayed_work_sync(&pipe->queue_timeout);
180
	rpc_inode_setowner(inode, NULL);
181
	mutex_unlock(&inode->i_mutex);
L
Linus Torvalds 已提交
182 183 184 185 186 187
}

static struct inode *
rpc_alloc_inode(struct super_block *sb)
{
	struct rpc_inode *rpci;
188
	rpci = (struct rpc_inode *)kmem_cache_alloc(rpc_inode_cachep, GFP_KERNEL);
L
Linus Torvalds 已提交
189 190 191 192 193 194
	if (!rpci)
		return NULL;
	return &rpci->vfs_inode;
}

static void
N
Nick Piggin 已提交
195
rpc_i_callback(struct rcu_head *head)
L
Linus Torvalds 已提交
196
{
N
Nick Piggin 已提交
197
	struct inode *inode = container_of(head, struct inode, i_rcu);
L
Linus Torvalds 已提交
198 199 200
	kmem_cache_free(rpc_inode_cachep, RPC_I(inode));
}

N
Nick Piggin 已提交
201 202 203 204 205 206
static void
rpc_destroy_inode(struct inode *inode)
{
	call_rcu(&inode->i_rcu, rpc_i_callback);
}

L
Linus Torvalds 已提交
207 208 209
static int
rpc_pipe_open(struct inode *inode, struct file *filp)
{
210
	struct rpc_pipe *pipe = RPC_I(inode)->pipe;
211
	int first_open;
L
Linus Torvalds 已提交
212 213
	int res = -ENXIO;

214
	mutex_lock(&inode->i_mutex);
215
	if (pipe->dentry == NULL)
216
		goto out;
217 218 219
	first_open = pipe->nreaders == 0 && pipe->nwriters == 0;
	if (first_open && pipe->ops->open_pipe) {
		res = pipe->ops->open_pipe(inode);
220 221
		if (res)
			goto out;
L
Linus Torvalds 已提交
222
	}
223
	if (filp->f_mode & FMODE_READ)
224
		pipe->nreaders++;
225
	if (filp->f_mode & FMODE_WRITE)
226
		pipe->nwriters++;
227 228
	res = 0;
out:
229
	mutex_unlock(&inode->i_mutex);
L
Linus Torvalds 已提交
230 231 232 233 234 235
	return res;
}

static int
rpc_pipe_release(struct inode *inode, struct file *filp)
{
236
	struct rpc_pipe *pipe = RPC_I(inode)->pipe;
L
Linus Torvalds 已提交
237
	struct rpc_pipe_msg *msg;
238
	int last_close;
L
Linus Torvalds 已提交
239

240
	mutex_lock(&inode->i_mutex);
241
	if (pipe->dentry == NULL)
L
Linus Torvalds 已提交
242
		goto out;
243
	msg = filp->private_data;
L
Linus Torvalds 已提交
244
	if (msg != NULL) {
245
		spin_lock(&pipe->lock);
246
		msg->errno = -EAGAIN;
247
		list_del_init(&msg->list);
248 249
		spin_unlock(&pipe->lock);
		pipe->ops->destroy_msg(msg);
L
Linus Torvalds 已提交
250 251
	}
	if (filp->f_mode & FMODE_WRITE)
252
		pipe->nwriters --;
253
	if (filp->f_mode & FMODE_READ) {
254 255
		pipe->nreaders --;
		if (pipe->nreaders == 0) {
256
			LIST_HEAD(free_list);
257 258 259 260 261 262
			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);
263 264
		}
	}
265 266 267
	last_close = pipe->nwriters == 0 && pipe->nreaders == 0;
	if (last_close && pipe->ops->release_pipe)
		pipe->ops->release_pipe(inode);
L
Linus Torvalds 已提交
268
out:
269
	mutex_unlock(&inode->i_mutex);
L
Linus Torvalds 已提交
270 271 272 273 274 275
	return 0;
}

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

281
	mutex_lock(&inode->i_mutex);
282
	if (pipe->dentry == NULL) {
L
Linus Torvalds 已提交
283 284 285 286 287
		res = -EPIPE;
		goto out_unlock;
	}
	msg = filp->private_data;
	if (msg == NULL) {
288 289 290
		spin_lock(&pipe->lock);
		if (!list_empty(&pipe->pipe)) {
			msg = list_entry(pipe->pipe.next,
L
Linus Torvalds 已提交
291 292
					struct rpc_pipe_msg,
					list);
293 294
			list_move(&msg->list, &pipe->in_upcall);
			pipe->pipelen -= msg->len;
L
Linus Torvalds 已提交
295 296 297
			filp->private_data = msg;
			msg->copied = 0;
		}
298
		spin_unlock(&pipe->lock);
L
Linus Torvalds 已提交
299 300 301 302
		if (msg == NULL)
			goto out_unlock;
	}
	/* NOTE: it is up to the callback to update msg->copied */
303
	res = pipe->ops->upcall(filp, msg, buf, len);
L
Linus Torvalds 已提交
304 305
	if (res < 0 || msg->len == msg->copied) {
		filp->private_data = NULL;
306
		spin_lock(&pipe->lock);
307
		list_del_init(&msg->list);
308 309
		spin_unlock(&pipe->lock);
		pipe->ops->destroy_msg(msg);
L
Linus Torvalds 已提交
310 311
	}
out_unlock:
312
	mutex_unlock(&inode->i_mutex);
L
Linus Torvalds 已提交
313 314 315 316 317 318
	return res;
}

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

323
	mutex_lock(&inode->i_mutex);
L
Linus Torvalds 已提交
324
	res = -EPIPE;
325
	if (pipe->dentry != NULL)
326
		res = pipe->ops->downcall(filp, buf, len);
327
	mutex_unlock(&inode->i_mutex);
L
Linus Torvalds 已提交
328 329 330 331 332 333
	return res;
}

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

337
	poll_wait(filp, &pipe->waitq, wait);
L
Linus Torvalds 已提交
338 339

	mask = POLLOUT | POLLWRNORM;
340
	if (pipe->dentry == NULL)
L
Linus Torvalds 已提交
341
		mask |= POLLERR | POLLHUP;
342
	if (filp->private_data || !list_empty(&pipe->pipe))
L
Linus Torvalds 已提交
343 344 345 346
		mask |= POLLIN | POLLRDNORM;
	return mask;
}

A
Arnd Bergmann 已提交
347 348
static long
rpc_pipe_ioctl(struct file *filp, unsigned int cmd, unsigned long arg)
L
Linus Torvalds 已提交
349
{
A
Arnd Bergmann 已提交
350
	struct inode *inode = filp->f_path.dentry->d_inode;
351
	struct rpc_pipe *pipe = RPC_I(inode)->pipe;
L
Linus Torvalds 已提交
352 353 354 355
	int len;

	switch (cmd) {
	case FIONREAD:
356
		spin_lock(&pipe->lock);
357
		if (pipe->dentry == NULL) {
358
			spin_unlock(&pipe->lock);
L
Linus Torvalds 已提交
359
			return -EPIPE;
A
Arnd Bergmann 已提交
360
		}
361
		len = pipe->pipelen;
L
Linus Torvalds 已提交
362 363
		if (filp->private_data) {
			struct rpc_pipe_msg *msg;
364
			msg = filp->private_data;
L
Linus Torvalds 已提交
365 366
			len += msg->len - msg->copied;
		}
367
		spin_unlock(&pipe->lock);
L
Linus Torvalds 已提交
368 369 370 371 372 373
		return put_user(len, (int __user *)arg);
	default:
		return -EINVAL;
	}
}

374
static const struct file_operations rpc_pipe_fops = {
L
Linus Torvalds 已提交
375 376 377 378 379
	.owner		= THIS_MODULE,
	.llseek		= no_llseek,
	.read		= rpc_pipe_read,
	.write		= rpc_pipe_write,
	.poll		= rpc_pipe_poll,
380
	.unlocked_ioctl	= rpc_pipe_ioctl,
L
Linus Torvalds 已提交
381 382 383 384 385 386 387 388 389 390 391 392
	.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);
393 394
	seq_printf(m, "address: %s\n", rpc_peeraddr2str(clnt, RPC_DISPLAY_ADDR));
	seq_printf(m, "protocol: %s\n", rpc_peeraddr2str(clnt, RPC_DISPLAY_PROTO));
395
	seq_printf(m, "port: %s\n", rpc_peeraddr2str(clnt, RPC_DISPLAY_PORT));
L
Linus Torvalds 已提交
396 397 398 399 400 401
	return 0;
}

static int
rpc_info_open(struct inode *inode, struct file *file)
{
402
	struct rpc_clnt *clnt = NULL;
L
Linus Torvalds 已提交
403 404 405 406
	int ret = single_open(file, rpc_show_info, NULL);

	if (!ret) {
		struct seq_file *m = file->private_data;
407 408 409 410 411 412

		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 已提交
413 414
			m->private = clnt;
		} else {
415
			spin_unlock(&file->f_path.dentry->d_lock);
L
Linus Torvalds 已提交
416 417 418 419 420 421 422 423 424 425 426 427 428 429 430 431 432 433
			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);
}

434
static const struct file_operations rpc_info_operations = {
L
Linus Torvalds 已提交
435 436 437 438 439 440 441 442 443 444 445 446
	.owner		= THIS_MODULE,
	.open		= rpc_info_open,
	.read		= seq_read,
	.llseek		= seq_lseek,
	.release	= rpc_info_release,
};


/*
 * Description of fs contents.
 */
struct rpc_filelist {
447
	const char *name;
448
	const struct file_operations *i_fop;
449
	umode_t mode;
L
Linus Torvalds 已提交
450 451
};

452
struct vfsmount *rpc_get_mount(void)
L
Linus Torvalds 已提交
453
{
454 455
	int err;

A
Al Viro 已提交
456
	err = simple_pin_fs(&rpc_pipe_fs_type, &rpc_mnt, &rpc_mount_count);
457 458
	if (err != 0)
		return ERR_PTR(err);
A
Al Viro 已提交
459
	return rpc_mnt;
L
Linus Torvalds 已提交
460
}
461
EXPORT_SYMBOL_GPL(rpc_get_mount);
L
Linus Torvalds 已提交
462

463
void rpc_put_mount(void)
L
Linus Torvalds 已提交
464
{
A
Al Viro 已提交
465
	simple_release_fs(&rpc_mnt, &rpc_mount_count);
L
Linus Torvalds 已提交
466
}
467
EXPORT_SYMBOL_GPL(rpc_put_mount);
L
Linus Torvalds 已提交
468

N
Nick Piggin 已提交
469
static int rpc_delete_dentry(const struct dentry *dentry)
T
Trond Myklebust 已提交
470 471 472 473
{
	return 1;
}

A
Al Viro 已提交
474
static const struct dentry_operations rpc_dentry_operations = {
T
Trond Myklebust 已提交
475 476 477
	.d_delete = rpc_delete_dentry,
};

L
Linus Torvalds 已提交
478
static struct inode *
479
rpc_get_inode(struct super_block *sb, umode_t mode)
L
Linus Torvalds 已提交
480 481 482 483
{
	struct inode *inode = new_inode(sb);
	if (!inode)
		return NULL;
484
	inode->i_ino = get_next_ino();
L
Linus Torvalds 已提交
485 486
	inode->i_mode = mode;
	inode->i_atime = inode->i_mtime = inode->i_ctime = CURRENT_TIME;
J
Joe Perches 已提交
487 488 489 490 491 492 493
	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 已提交
494 495 496 497
	}
	return inode;
}

498 499 500 501 502 503 504
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 已提交
505
	d_drop(dentry);
506 507 508 509 510 511 512 513 514 515 516 517 518 519 520 521 522
	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;
}

523 524 525 526 527 528 529 530 531 532 533 534 535 536
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;
}

537 538 539 540 541 542 543 544 545 546 547 548 549 550 551
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;
}

552 553 554 555 556 557 558 559 560 561 562 563 564 565
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);
566 567
	pipe->dentry = NULL;
}
568

569 570 571
void rpc_destroy_pipe_data(struct rpc_pipe *pipe)
{
	kfree(pipe);
572
}
573
EXPORT_SYMBOL_GPL(rpc_destroy_pipe_data);
574

575
struct rpc_pipe *rpc_mkpipe_data(const struct rpc_pipe_ops *ops, int flags)
576
{
577
	struct rpc_pipe *pipe;
578

579 580
	pipe = kzalloc(sizeof(struct rpc_pipe), GFP_KERNEL);
	if (!pipe)
581
		return ERR_PTR(-ENOMEM);
582
	init_pipe(pipe);
583 584 585 586 587 588 589 590 591 592 593 594 595 596 597
	pipe->ops = ops;
	pipe->flags = flags;
	return pipe;
}
EXPORT_SYMBOL_GPL(rpc_mkpipe_data);

static int __rpc_mkpipe_dentry(struct inode *dir, struct dentry *dentry,
			       umode_t mode,
			       const struct file_operations *i_fop,
			       void *private,
			       struct rpc_pipe *pipe)
{
	struct rpc_inode *rpci;
	int err;

598
	err = __rpc_create_common(dir, dentry, S_IFIFO | mode, i_fop, private);
599
	if (err)
600 601 602
		return err;
	rpci = RPC_I(dentry->d_inode);
	rpci->private = private;
603
	rpci->pipe = pipe;
604 605 606 607
	fsnotify_create(dir, dentry);
	return 0;
}

608 609 610 611 612 613 614 615 616 617 618
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 已提交
619 620 621 622 623 624 625 626 627 628 629 630 631 632 633 634 635 636 637
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);
}

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

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

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

669 670 671 672 673 674 675
	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 已提交
676
			continue;
677 678 679 680 681 682 683
		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 已提交
684
				break;
685 686 687 688 689
			case S_IFDIR:
				__rpc_rmdir(dir, dentry);
		}
next:
		dput(dentry);
L
Linus Torvalds 已提交
690
	}
691 692 693 694 695 696 697 698 699 700
}

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);
701
	mutex_unlock(&dir->i_mutex);
L
Linus Torvalds 已提交
702 703
}

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

713
	mutex_lock(&dir->i_mutex);
L
Linus Torvalds 已提交
714
	for (i = start; i < eof; i++) {
715 716 717 718 719 720 721 722
		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 已提交
723
			goto out_bad;
724 725 726 727 728 729 730 731 732 733 734 735 736 737
		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 已提交
738
		}
739 740
		if (err != 0)
			goto out_bad;
L
Linus Torvalds 已提交
741
	}
742
	mutex_unlock(&dir->i_mutex);
L
Linus Torvalds 已提交
743 744
	return 0;
out_bad:
745
	__rpc_depopulate(parent, files, start, eof);
746
	mutex_unlock(&dir->i_mutex);
L
Linus Torvalds 已提交
747
	printk(KERN_WARNING "%s: %s failed to populate directory %s\n",
748
			__FILE__, __func__, parent->d_name.name);
749
	return err;
750
}
L
Linus Torvalds 已提交
751

752 753 754
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)
755 756
{
	struct dentry *dentry;
757
	struct inode *dir = parent->d_inode;
758 759
	int error;

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

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

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

800 801 802 803 804 805
/**
 * 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,
806
 *	release_pipe, open_pipe, and destroy_msg.
807
 * @flags: rpc_pipe flags
808 809 810 811 812 813 814 815 816 817 818 819
 *
 * 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.
 */
820 821
struct dentry *rpc_mkpipe_dentry(struct dentry *parent, const char *name,
				 void *private, struct rpc_pipe *pipe)
L
Linus Torvalds 已提交
822 823
{
	struct dentry *dentry;
824
	struct inode *dir = parent->d_inode;
825
	umode_t umode = S_IFIFO | S_IRUSR | S_IWUSR;
826
	struct qstr q;
827
	int err;
828

829
	if (pipe->ops->upcall == NULL)
830
		umode &= ~S_IRUGO;
831
	if (pipe->ops->downcall == NULL)
832
		umode &= ~S_IWUGO;
L
Linus Torvalds 已提交
833

834 835 836 837 838
	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);
839
	dentry = __rpc_lookup_create_exclusive(parent, &q);
L
Linus Torvalds 已提交
840
	if (IS_ERR(dentry))
841
		goto out;
842 843
	err = __rpc_mkpipe_dentry(dir, dentry, umode, &rpc_pipe_fops,
				  private, pipe);
844 845
	if (err)
		goto out_err;
846
out:
847
	mutex_unlock(&dir->i_mutex);
848
	return dentry;
849 850
out_err:
	dentry = ERR_PTR(err);
851
	printk(KERN_WARNING "%s: %s() failed to create pipe %s/%s (errno = %d)\n",
852
			__FILE__, __func__, parent->d_name.name, name,
853
			err);
854
	goto out;
L
Linus Torvalds 已提交
855
}
856
EXPORT_SYMBOL_GPL(rpc_mkpipe_dentry);
L
Linus Torvalds 已提交
857

858 859 860 861 862 863 864 865
/**
 * 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.
 */
866
int
867
rpc_unlink(struct dentry *dentry)
L
Linus Torvalds 已提交
868
{
869
	struct dentry *parent;
870
	struct inode *dir;
871
	int error = 0;
L
Linus Torvalds 已提交
872

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

883 884 885 886 887 888 889 890 891 892 893 894 895 896 897 898 899 900 901 902 903 904 905 906 907
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);
}

908 909
/**
 * rpc_create_client_dir - Create a new rpc_client directory in rpc_pipefs
910 911
 * @dentry: dentry from the rpc_pipefs root to the new directory
 * @name: &struct qstr for the name
912 913 914 915 916 917 918
 * @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().
 */
919
struct dentry *rpc_create_client_dir(struct dentry *dentry,
920 921 922 923 924 925 926 927 928
				   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()
929
 * @clnt: rpc client
930 931
 */
int rpc_remove_client_dir(struct dentry *dentry)
932
{
933
	return rpc_rmdir_depopulate(dentry, rpc_clntdir_depopulate);
934 935
}

936 937 938 939
static const struct rpc_filelist cache_pipefs_files[3] = {
	[0] = {
		.name = "channel",
		.i_fop = &cache_file_operations_pipefs,
940
		.mode = S_IFREG|S_IRUSR|S_IWUSR,
941 942 943 944 945 946 947 948 949 950 951 952 953 954 955 956 957 958 959 960 961 962 963 964 965 966
	},
	[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 已提交
967
				    umode_t umode, struct cache_detail *cd)
968 969 970 971 972 973 974 975 976 977
{
	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 已提交
978 979 980
/*
 * populate the filesystem
 */
981
static const struct super_operations s_ops = {
L
Linus Torvalds 已提交
982 983 984 985 986 987 988
	.alloc_inode	= rpc_alloc_inode,
	.destroy_inode	= rpc_destroy_inode,
	.statfs		= simple_statfs,
};

#define RPCAUTH_GSSMAGIC 0x67596969

T
Trond Myklebust 已提交
989 990 991 992 993 994 995 996 997 998
/*
 * We have a single directory with 1 node in it.
 */
enum {
	RPCAUTH_lockd,
	RPCAUTH_mount,
	RPCAUTH_nfs,
	RPCAUTH_portmap,
	RPCAUTH_statd,
	RPCAUTH_nfsd4_cb,
999
	RPCAUTH_cache,
T
Trond Myklebust 已提交
1000 1001 1002 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
	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,
	},
1028 1029 1030 1031
	[RPCAUTH_cache] = {
		.name = "cache",
		.mode = S_IFDIR | S_IRUGO | S_IXUGO,
	},
T
Trond Myklebust 已提交
1032 1033
};

1034 1035 1036 1037 1038 1039 1040 1041 1042 1043 1044 1045 1046 1047 1048 1049
/*
 * 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);

1050 1051 1052 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
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 已提交
1084 1085 1086 1087 1088
static int
rpc_fill_super(struct super_block *sb, void *data, int silent)
{
	struct inode *inode;
	struct dentry *root;
1089
	struct net *net = data;
1090
	struct sunrpc_net *sn = net_generic(net, sunrpc_net_id);
1091
	int err;
L
Linus Torvalds 已提交
1092 1093 1094 1095 1096 1097 1098 1099 1100 1101

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

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 已提交
1126 1127
}

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

1135 1136 1137
void rpc_kill_sb(struct super_block *sb)
{
	struct net *net = sb->s_fs_info;
1138
	struct sunrpc_net *sn = net_generic(net, sunrpc_net_id);
1139

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

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

static void
1160
init_once(void *foo)
L
Linus Torvalds 已提交
1161 1162 1163
{
	struct rpc_inode *rpci = (struct rpc_inode *) foo;

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

int register_rpc_pipefs(void)
{
1171 1172
	int err;

L
Linus Torvalds 已提交
1173
	rpc_inode_cachep = kmem_cache_create("rpc_inode_cache",
1174 1175 1176
				sizeof(struct rpc_inode),
				0, (SLAB_HWCACHE_ALIGN|SLAB_RECLAIM_ACCOUNT|
						SLAB_MEM_SPREAD),
1177
				init_once);
L
Linus Torvalds 已提交
1178 1179
	if (!rpc_inode_cachep)
		return -ENOMEM;
1180 1181 1182
	err = rpc_clients_notifier_register();
	if (err)
		goto err_notifier;
1183
	err = register_filesystem(&rpc_pipe_fs_type);
1184 1185
	if (err)
		goto err_register;
L
Linus Torvalds 已提交
1186
	return 0;
1187 1188 1189 1190 1191 1192

err_register:
	rpc_clients_notifier_unregister();
err_notifier:
	kmem_cache_destroy(rpc_inode_cachep);
	return err;
L
Linus Torvalds 已提交
1193 1194 1195 1196
}

void unregister_rpc_pipefs(void)
{
1197
	rpc_clients_notifier_unregister();
1198
	kmem_cache_destroy(rpc_inode_cachep);
L
Linus Torvalds 已提交
1199 1200
	unregister_filesystem(&rpc_pipe_fs_type);
}
1201 1202 1203

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