1/*
   2 * net/sunrpc/rpc_pipe.c
   3 *
   4 * Userland/kernel interface for rpcauth_gss.
   5 * Code shamelessly plagiarized from fs/nfsd/nfsctl.c
   6 * and fs/sysfs/inode.c
   7 *
   8 * Copyright (c) 2002, Trond Myklebust <trond.myklebust@fys.uio.no>
   9 *
  10 */
  11#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>
  17#include <linux/fsnotify.h>
  18#include <linux/kernel.h>
 
 
  19
  20#include <asm/ioctls.h>
  21#include <linux/fs.h>
  22#include <linux/poll.h>
  23#include <linux/wait.h>
  24#include <linux/seq_file.h>
  25
  26#include <linux/sunrpc/clnt.h>
  27#include <linux/workqueue.h>
  28#include <linux/sunrpc/rpc_pipe_fs.h>
  29#include <linux/sunrpc/cache.h>
 
 
  30
  31static struct vfsmount *rpc_mnt __read_mostly;
  32static int rpc_mount_count;
  33
  34static struct file_system_type rpc_pipe_fs_type;
 
 
  35
 
 
  36
  37static struct kmem_cache *rpc_inode_cachep __read_mostly;
  38
  39#define RPC_UPCALL_TIMEOUT (30*HZ)
  40
  41static void rpc_purge_list(struct rpc_inode *rpci, struct list_head *head,
 
 
 
 
 
 
 
 
 
 
 
 
 
 
  42		void (*destroy_msg)(struct rpc_pipe_msg *), int err)
  43{
  44	struct rpc_pipe_msg *msg;
  45
  46	if (list_empty(head))
  47		return;
  48	do {
  49		msg = list_entry(head->next, struct rpc_pipe_msg, list);
  50		list_del_init(&msg->list);
  51		msg->errno = err;
  52		destroy_msg(msg);
  53	} while (!list_empty(head));
  54	wake_up(&rpci->waitq);
 
 
  55}
  56
  57static void
  58rpc_timeout_upcall_queue(struct work_struct *work)
  59{
  60	LIST_HEAD(free_list);
  61	struct rpc_inode *rpci =
  62		container_of(work, struct rpc_inode, queue_timeout.work);
  63	struct inode *inode = &rpci->vfs_inode;
  64	void (*destroy_msg)(struct rpc_pipe_msg *);
 
  65
  66	spin_lock(&inode->i_lock);
  67	if (rpci->ops == NULL) {
  68		spin_unlock(&inode->i_lock);
  69		return;
 
  70	}
  71	destroy_msg = rpci->ops->destroy_msg;
  72	if (rpci->nreaders == 0) {
  73		list_splice_init(&rpci->pipe, &free_list);
  74		rpci->pipelen = 0;
 
 
 
 
 
 
 
 
 
 
 
 
 
 
  75	}
  76	spin_unlock(&inode->i_lock);
  77	rpc_purge_list(rpci, &free_list, destroy_msg, -ETIMEDOUT);
 
 
 
  78}
 
  79
  80/**
  81 * rpc_queue_upcall - queue an upcall message to userspace
  82 * @inode: inode of upcall pipe on which to queue given message
  83 * @msg: message to queue
  84 *
  85 * Call with an @inode created by rpc_mkpipe() to queue an upcall.
  86 * A userspace process may then later read the upcall by performing a
  87 * read on an open file for this inode.  It is up to the caller to
  88 * initialize the fields of @msg (other than @msg->list) appropriately.
  89 */
  90int
  91rpc_queue_upcall(struct inode *inode, struct rpc_pipe_msg *msg)
  92{
  93	struct rpc_inode *rpci = RPC_I(inode);
  94	int res = -EPIPE;
 
  95
  96	spin_lock(&inode->i_lock);
  97	if (rpci->ops == NULL)
  98		goto out;
  99	if (rpci->nreaders) {
 100		list_add_tail(&msg->list, &rpci->pipe);
 101		rpci->pipelen += msg->len;
 102		res = 0;
 103	} else if (rpci->flags & RPC_PIPE_WAIT_FOR_OPEN) {
 104		if (list_empty(&rpci->pipe))
 105			queue_delayed_work(rpciod_workqueue,
 106					&rpci->queue_timeout,
 107					RPC_UPCALL_TIMEOUT);
 108		list_add_tail(&msg->list, &rpci->pipe);
 109		rpci->pipelen += msg->len;
 110		res = 0;
 111	}
 112out:
 113	spin_unlock(&inode->i_lock);
 114	wake_up(&rpci->waitq);
 
 
 
 115	return res;
 116}
 117EXPORT_SYMBOL_GPL(rpc_queue_upcall);
 118
 119static inline void
 120rpc_inode_setowner(struct inode *inode, void *private)
 121{
 122	RPC_I(inode)->private = private;
 123}
 124
 125static void
 126rpc_close_pipes(struct inode *inode)
 127{
 128	struct rpc_inode *rpci = RPC_I(inode);
 129	const struct rpc_pipe_ops *ops;
 130	int need_release;
 
 131
 132	mutex_lock(&inode->i_mutex);
 133	ops = rpci->ops;
 134	if (ops != NULL) {
 135		LIST_HEAD(free_list);
 136		spin_lock(&inode->i_lock);
 137		need_release = rpci->nreaders != 0 || rpci->nwriters != 0;
 138		rpci->nreaders = 0;
 139		list_splice_init(&rpci->in_upcall, &free_list);
 140		list_splice_init(&rpci->pipe, &free_list);
 141		rpci->pipelen = 0;
 142		rpci->ops = NULL;
 143		spin_unlock(&inode->i_lock);
 144		rpc_purge_list(rpci, &free_list, ops->destroy_msg, -EPIPE);
 145		rpci->nwriters = 0;
 146		if (need_release && ops->release_pipe)
 147			ops->release_pipe(inode);
 148		cancel_delayed_work_sync(&rpci->queue_timeout);
 149	}
 150	rpc_inode_setowner(inode, NULL);
 151	mutex_unlock(&inode->i_mutex);
 
 152}
 153
 154static struct inode *
 155rpc_alloc_inode(struct super_block *sb)
 156{
 157	struct rpc_inode *rpci;
 158	rpci = (struct rpc_inode *)kmem_cache_alloc(rpc_inode_cachep, GFP_KERNEL);
 159	if (!rpci)
 160		return NULL;
 161	return &rpci->vfs_inode;
 162}
 163
 164static void
 165rpc_i_callback(struct rcu_head *head)
 166{
 167	struct inode *inode = container_of(head, struct inode, i_rcu);
 168	INIT_LIST_HEAD(&inode->i_dentry);
 169	kmem_cache_free(rpc_inode_cachep, RPC_I(inode));
 170}
 171
 172static void
 173rpc_destroy_inode(struct inode *inode)
 174{
 175	call_rcu(&inode->i_rcu, rpc_i_callback);
 176}
 177
 178static int
 179rpc_pipe_open(struct inode *inode, struct file *filp)
 180{
 181	struct rpc_inode *rpci = RPC_I(inode);
 182	int first_open;
 183	int res = -ENXIO;
 184
 185	mutex_lock(&inode->i_mutex);
 186	if (rpci->ops == NULL)
 
 187		goto out;
 188	first_open = rpci->nreaders == 0 && rpci->nwriters == 0;
 189	if (first_open && rpci->ops->open_pipe) {
 190		res = rpci->ops->open_pipe(inode);
 191		if (res)
 192			goto out;
 193	}
 194	if (filp->f_mode & FMODE_READ)
 195		rpci->nreaders++;
 196	if (filp->f_mode & FMODE_WRITE)
 197		rpci->nwriters++;
 198	res = 0;
 199out:
 200	mutex_unlock(&inode->i_mutex);
 201	return res;
 202}
 203
 204static int
 205rpc_pipe_release(struct inode *inode, struct file *filp)
 206{
 207	struct rpc_inode *rpci = RPC_I(inode);
 208	struct rpc_pipe_msg *msg;
 209	int last_close;
 210
 211	mutex_lock(&inode->i_mutex);
 212	if (rpci->ops == NULL)
 
 213		goto out;
 214	msg = filp->private_data;
 215	if (msg != NULL) {
 216		spin_lock(&inode->i_lock);
 217		msg->errno = -EAGAIN;
 218		list_del_init(&msg->list);
 219		spin_unlock(&inode->i_lock);
 220		rpci->ops->destroy_msg(msg);
 221	}
 222	if (filp->f_mode & FMODE_WRITE)
 223		rpci->nwriters --;
 224	if (filp->f_mode & FMODE_READ) {
 225		rpci->nreaders --;
 226		if (rpci->nreaders == 0) {
 227			LIST_HEAD(free_list);
 228			spin_lock(&inode->i_lock);
 229			list_splice_init(&rpci->pipe, &free_list);
 230			rpci->pipelen = 0;
 231			spin_unlock(&inode->i_lock);
 232			rpc_purge_list(rpci, &free_list,
 233					rpci->ops->destroy_msg, -EAGAIN);
 234		}
 235	}
 236	last_close = rpci->nwriters == 0 && rpci->nreaders == 0;
 237	if (last_close && rpci->ops->release_pipe)
 238		rpci->ops->release_pipe(inode);
 239out:
 240	mutex_unlock(&inode->i_mutex);
 241	return 0;
 242}
 243
 244static ssize_t
 245rpc_pipe_read(struct file *filp, char __user *buf, size_t len, loff_t *offset)
 246{
 247	struct inode *inode = filp->f_path.dentry->d_inode;
 248	struct rpc_inode *rpci = RPC_I(inode);
 249	struct rpc_pipe_msg *msg;
 250	int res = 0;
 251
 252	mutex_lock(&inode->i_mutex);
 253	if (rpci->ops == NULL) {
 
 254		res = -EPIPE;
 255		goto out_unlock;
 256	}
 257	msg = filp->private_data;
 258	if (msg == NULL) {
 259		spin_lock(&inode->i_lock);
 260		if (!list_empty(&rpci->pipe)) {
 261			msg = list_entry(rpci->pipe.next,
 262					struct rpc_pipe_msg,
 263					list);
 264			list_move(&msg->list, &rpci->in_upcall);
 265			rpci->pipelen -= msg->len;
 266			filp->private_data = msg;
 267			msg->copied = 0;
 268		}
 269		spin_unlock(&inode->i_lock);
 270		if (msg == NULL)
 271			goto out_unlock;
 272	}
 273	/* NOTE: it is up to the callback to update msg->copied */
 274	res = rpci->ops->upcall(filp, msg, buf, len);
 275	if (res < 0 || msg->len == msg->copied) {
 276		filp->private_data = NULL;
 277		spin_lock(&inode->i_lock);
 278		list_del_init(&msg->list);
 279		spin_unlock(&inode->i_lock);
 280		rpci->ops->destroy_msg(msg);
 281	}
 282out_unlock:
 283	mutex_unlock(&inode->i_mutex);
 284	return res;
 285}
 286
 287static ssize_t
 288rpc_pipe_write(struct file *filp, const char __user *buf, size_t len, loff_t *offset)
 289{
 290	struct inode *inode = filp->f_path.dentry->d_inode;
 291	struct rpc_inode *rpci = RPC_I(inode);
 292	int res;
 293
 294	mutex_lock(&inode->i_mutex);
 295	res = -EPIPE;
 296	if (rpci->ops != NULL)
 297		res = rpci->ops->downcall(filp, buf, len);
 298	mutex_unlock(&inode->i_mutex);
 299	return res;
 300}
 301
 302static unsigned int
 303rpc_pipe_poll(struct file *filp, struct poll_table_struct *wait)
 304{
 305	struct rpc_inode *rpci;
 306	unsigned int mask = 0;
 
 307
 308	rpci = RPC_I(filp->f_path.dentry->d_inode);
 309	poll_wait(filp, &rpci->waitq, wait);
 310
 311	mask = POLLOUT | POLLWRNORM;
 312	if (rpci->ops == NULL)
 313		mask |= POLLERR | POLLHUP;
 314	if (filp->private_data || !list_empty(&rpci->pipe))
 315		mask |= POLLIN | POLLRDNORM;
 
 316	return mask;
 317}
 318
 319static long
 320rpc_pipe_ioctl(struct file *filp, unsigned int cmd, unsigned long arg)
 321{
 322	struct inode *inode = filp->f_path.dentry->d_inode;
 323	struct rpc_inode *rpci = RPC_I(inode);
 324	int len;
 325
 326	switch (cmd) {
 327	case FIONREAD:
 328		spin_lock(&inode->i_lock);
 329		if (rpci->ops == NULL) {
 330			spin_unlock(&inode->i_lock);
 
 331			return -EPIPE;
 332		}
 333		len = rpci->pipelen;
 
 334		if (filp->private_data) {
 335			struct rpc_pipe_msg *msg;
 336			msg = filp->private_data;
 337			len += msg->len - msg->copied;
 338		}
 339		spin_unlock(&inode->i_lock);
 
 340		return put_user(len, (int __user *)arg);
 341	default:
 342		return -EINVAL;
 343	}
 344}
 345
 346static const struct file_operations rpc_pipe_fops = {
 347	.owner		= THIS_MODULE,
 348	.llseek		= no_llseek,
 349	.read		= rpc_pipe_read,
 350	.write		= rpc_pipe_write,
 351	.poll		= rpc_pipe_poll,
 352	.unlocked_ioctl	= rpc_pipe_ioctl,
 353	.open		= rpc_pipe_open,
 354	.release	= rpc_pipe_release,
 355};
 356
 357static int
 358rpc_show_info(struct seq_file *m, void *v)
 359{
 360	struct rpc_clnt *clnt = m->private;
 361
 362	seq_printf(m, "RPC server: %s\n", clnt->cl_server);
 363	seq_printf(m, "service: %s (%d) version %d\n", clnt->cl_protname,
 
 
 364			clnt->cl_prog, clnt->cl_vers);
 365	seq_printf(m, "address: %s\n", rpc_peeraddr2str(clnt, RPC_DISPLAY_ADDR));
 366	seq_printf(m, "protocol: %s\n", rpc_peeraddr2str(clnt, RPC_DISPLAY_PROTO));
 367	seq_printf(m, "port: %s\n", rpc_peeraddr2str(clnt, RPC_DISPLAY_PORT));
 
 368	return 0;
 369}
 370
 371static int
 372rpc_info_open(struct inode *inode, struct file *file)
 373{
 374	struct rpc_clnt *clnt = NULL;
 375	int ret = single_open(file, rpc_show_info, NULL);
 376
 377	if (!ret) {
 378		struct seq_file *m = file->private_data;
 379
 380		spin_lock(&file->f_path.dentry->d_lock);
 381		if (!d_unhashed(file->f_path.dentry))
 382			clnt = RPC_I(inode)->private;
 383		if (clnt != NULL && atomic_inc_not_zero(&clnt->cl_count)) {
 384			spin_unlock(&file->f_path.dentry->d_lock);
 385			m->private = clnt;
 386		} else {
 387			spin_unlock(&file->f_path.dentry->d_lock);
 388			single_release(inode, file);
 389			ret = -EINVAL;
 390		}
 391	}
 392	return ret;
 393}
 394
 395static int
 396rpc_info_release(struct inode *inode, struct file *file)
 397{
 398	struct seq_file *m = file->private_data;
 399	struct rpc_clnt *clnt = (struct rpc_clnt *)m->private;
 400
 401	if (clnt)
 402		rpc_release_client(clnt);
 403	return single_release(inode, file);
 404}
 405
 406static const struct file_operations rpc_info_operations = {
 407	.owner		= THIS_MODULE,
 408	.open		= rpc_info_open,
 409	.read		= seq_read,
 410	.llseek		= seq_lseek,
 411	.release	= rpc_info_release,
 412};
 413
 414
 415/*
 416 * Description of fs contents.
 417 */
 418struct rpc_filelist {
 419	const char *name;
 420	const struct file_operations *i_fop;
 421	umode_t mode;
 422};
 423
 424struct vfsmount *rpc_get_mount(void)
 425{
 426	int err;
 427
 428	err = simple_pin_fs(&rpc_pipe_fs_type, &rpc_mnt, &rpc_mount_count);
 429	if (err != 0)
 430		return ERR_PTR(err);
 431	return rpc_mnt;
 432}
 433EXPORT_SYMBOL_GPL(rpc_get_mount);
 434
 435void rpc_put_mount(void)
 436{
 437	simple_release_fs(&rpc_mnt, &rpc_mount_count);
 438}
 439EXPORT_SYMBOL_GPL(rpc_put_mount);
 440
 441static int rpc_delete_dentry(const struct dentry *dentry)
 442{
 443	return 1;
 444}
 445
 446static const struct dentry_operations rpc_dentry_operations = {
 447	.d_delete = rpc_delete_dentry,
 448};
 449
 450static struct inode *
 451rpc_get_inode(struct super_block *sb, umode_t mode)
 452{
 453	struct inode *inode = new_inode(sb);
 454	if (!inode)
 455		return NULL;
 456	inode->i_ino = get_next_ino();
 457	inode->i_mode = mode;
 458	inode->i_atime = inode->i_mtime = inode->i_ctime = CURRENT_TIME;
 459	switch (mode & S_IFMT) {
 460	case S_IFDIR:
 461		inode->i_fop = &simple_dir_operations;
 462		inode->i_op = &simple_dir_inode_operations;
 463		inc_nlink(inode);
 464	default:
 465		break;
 466	}
 467	return inode;
 468}
 469
 470static int __rpc_create_common(struct inode *dir, struct dentry *dentry,
 471			       umode_t mode,
 472			       const struct file_operations *i_fop,
 473			       void *private)
 474{
 475	struct inode *inode;
 476
 477	d_drop(dentry);
 478	inode = rpc_get_inode(dir->i_sb, mode);
 479	if (!inode)
 480		goto out_err;
 481	inode->i_ino = iunique(dir->i_sb, 100);
 482	if (i_fop)
 483		inode->i_fop = i_fop;
 484	if (private)
 485		rpc_inode_setowner(inode, private);
 486	d_add(dentry, inode);
 487	return 0;
 488out_err:
 489	printk(KERN_WARNING "%s: %s failed to allocate inode for dentry %s\n",
 490			__FILE__, __func__, dentry->d_name.name);
 491	dput(dentry);
 492	return -ENOMEM;
 493}
 494
 495static int __rpc_create(struct inode *dir, struct dentry *dentry,
 496			umode_t mode,
 497			const struct file_operations *i_fop,
 498			void *private)
 499{
 500	int err;
 501
 502	err = __rpc_create_common(dir, dentry, S_IFREG | mode, i_fop, private);
 503	if (err)
 504		return err;
 505	fsnotify_create(dir, dentry);
 506	return 0;
 507}
 508
 509static int __rpc_mkdir(struct inode *dir, struct dentry *dentry,
 510		       umode_t mode,
 511		       const struct file_operations *i_fop,
 512		       void *private)
 513{
 514	int err;
 515
 516	err = __rpc_create_common(dir, dentry, S_IFDIR | mode, i_fop, private);
 517	if (err)
 518		return err;
 519	inc_nlink(dir);
 520	fsnotify_mkdir(dir, dentry);
 521	return 0;
 522}
 523
 524static int __rpc_mkpipe(struct inode *dir, struct dentry *dentry,
 525			umode_t mode,
 526			const struct file_operations *i_fop,
 527			void *private,
 528			const struct rpc_pipe_ops *ops,
 529			int flags)
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 530{
 531	struct rpc_inode *rpci;
 532	int err;
 533
 534	err = __rpc_create_common(dir, dentry, S_IFIFO | mode, i_fop, private);
 535	if (err)
 536		return err;
 537	rpci = RPC_I(dentry->d_inode);
 538	rpci->nkern_readwriters = 1;
 539	rpci->private = private;
 540	rpci->flags = flags;
 541	rpci->ops = ops;
 542	fsnotify_create(dir, dentry);
 543	return 0;
 544}
 545
 546static int __rpc_rmdir(struct inode *dir, struct dentry *dentry)
 547{
 548	int ret;
 549
 550	dget(dentry);
 551	ret = simple_rmdir(dir, dentry);
 552	d_delete(dentry);
 553	dput(dentry);
 554	return ret;
 555}
 556
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 557static int __rpc_unlink(struct inode *dir, struct dentry *dentry)
 558{
 559	int ret;
 560
 561	dget(dentry);
 562	ret = simple_unlink(dir, dentry);
 563	d_delete(dentry);
 564	dput(dentry);
 565	return ret;
 566}
 567
 568static int __rpc_rmpipe(struct inode *dir, struct dentry *dentry)
 569{
 570	struct inode *inode = dentry->d_inode;
 571	struct rpc_inode *rpci = RPC_I(inode);
 572
 573	rpci->nkern_readwriters--;
 574	if (rpci->nkern_readwriters != 0)
 575		return 0;
 576	rpc_close_pipes(inode);
 577	return __rpc_unlink(dir, dentry);
 578}
 579
 580static struct dentry *__rpc_lookup_create(struct dentry *parent,
 581					  struct qstr *name)
 582{
 583	struct dentry *dentry;
 584
 585	dentry = d_lookup(parent, name);
 586	if (!dentry) {
 587		dentry = d_alloc(parent, name);
 588		if (!dentry) {
 589			dentry = ERR_PTR(-ENOMEM);
 590			goto out_err;
 591		}
 592	}
 593	if (!dentry->d_inode)
 594		d_set_d_op(dentry, &rpc_dentry_operations);
 595out_err:
 596	return dentry;
 597}
 598
 599static struct dentry *__rpc_lookup_create_exclusive(struct dentry *parent,
 600					  struct qstr *name)
 601{
 602	struct dentry *dentry;
 603
 604	dentry = __rpc_lookup_create(parent, name);
 605	if (IS_ERR(dentry))
 606		return dentry;
 607	if (dentry->d_inode == NULL)
 608		return dentry;
 609	dput(dentry);
 610	return ERR_PTR(-EEXIST);
 611}
 612
 613/*
 614 * FIXME: This probably has races.
 615 */
 616static void __rpc_depopulate(struct dentry *parent,
 617			     const struct rpc_filelist *files,
 618			     int start, int eof)
 619{
 620	struct inode *dir = parent->d_inode;
 621	struct dentry *dentry;
 622	struct qstr name;
 623	int i;
 624
 625	for (i = start; i < eof; i++) {
 626		name.name = files[i].name;
 627		name.len = strlen(files[i].name);
 628		name.hash = full_name_hash(name.name, name.len);
 629		dentry = d_lookup(parent, &name);
 630
 631		if (dentry == NULL)
 632			continue;
 633		if (dentry->d_inode == NULL)
 634			goto next;
 635		switch (dentry->d_inode->i_mode & S_IFMT) {
 636			default:
 637				BUG();
 638			case S_IFREG:
 639				__rpc_unlink(dir, dentry);
 640				break;
 641			case S_IFDIR:
 642				__rpc_rmdir(dir, dentry);
 643		}
 644next:
 645		dput(dentry);
 646	}
 647}
 648
 649static void rpc_depopulate(struct dentry *parent,
 650			   const struct rpc_filelist *files,
 651			   int start, int eof)
 652{
 653	struct inode *dir = parent->d_inode;
 654
 655	mutex_lock_nested(&dir->i_mutex, I_MUTEX_CHILD);
 656	__rpc_depopulate(parent, files, start, eof);
 657	mutex_unlock(&dir->i_mutex);
 658}
 659
 660static int rpc_populate(struct dentry *parent,
 661			const struct rpc_filelist *files,
 662			int start, int eof,
 663			void *private)
 664{
 665	struct inode *dir = parent->d_inode;
 666	struct dentry *dentry;
 667	int i, err;
 668
 669	mutex_lock(&dir->i_mutex);
 670	for (i = start; i < eof; i++) {
 671		struct qstr q;
 672
 673		q.name = files[i].name;
 674		q.len = strlen(files[i].name);
 675		q.hash = full_name_hash(q.name, q.len);
 676		dentry = __rpc_lookup_create_exclusive(parent, &q);
 677		err = PTR_ERR(dentry);
 678		if (IS_ERR(dentry))
 679			goto out_bad;
 680		switch (files[i].mode & S_IFMT) {
 681			default:
 682				BUG();
 683			case S_IFREG:
 684				err = __rpc_create(dir, dentry,
 685						files[i].mode,
 686						files[i].i_fop,
 687						private);
 688				break;
 689			case S_IFDIR:
 690				err = __rpc_mkdir(dir, dentry,
 691						files[i].mode,
 692						NULL,
 693						private);
 694		}
 695		if (err != 0)
 696			goto out_bad;
 697	}
 698	mutex_unlock(&dir->i_mutex);
 699	return 0;
 700out_bad:
 701	__rpc_depopulate(parent, files, start, eof);
 702	mutex_unlock(&dir->i_mutex);
 703	printk(KERN_WARNING "%s: %s failed to populate directory %s\n",
 704			__FILE__, __func__, parent->d_name.name);
 705	return err;
 706}
 707
 708static struct dentry *rpc_mkdir_populate(struct dentry *parent,
 709		struct qstr *name, umode_t mode, void *private,
 710		int (*populate)(struct dentry *, void *), void *args_populate)
 711{
 712	struct dentry *dentry;
 713	struct inode *dir = parent->d_inode;
 714	int error;
 715
 716	mutex_lock_nested(&dir->i_mutex, I_MUTEX_PARENT);
 717	dentry = __rpc_lookup_create_exclusive(parent, name);
 718	if (IS_ERR(dentry))
 719		goto out;
 720	error = __rpc_mkdir(dir, dentry, mode, NULL, private);
 721	if (error != 0)
 722		goto out_err;
 723	if (populate != NULL) {
 724		error = populate(dentry, args_populate);
 725		if (error)
 726			goto err_rmdir;
 727	}
 728out:
 729	mutex_unlock(&dir->i_mutex);
 730	return dentry;
 731err_rmdir:
 732	__rpc_rmdir(dir, dentry);
 733out_err:
 734	dentry = ERR_PTR(error);
 735	goto out;
 736}
 737
 738static int rpc_rmdir_depopulate(struct dentry *dentry,
 739		void (*depopulate)(struct dentry *))
 740{
 741	struct dentry *parent;
 742	struct inode *dir;
 743	int error;
 744
 745	parent = dget_parent(dentry);
 746	dir = parent->d_inode;
 747	mutex_lock_nested(&dir->i_mutex, I_MUTEX_PARENT);
 748	if (depopulate != NULL)
 749		depopulate(dentry);
 750	error = __rpc_rmdir(dir, dentry);
 751	mutex_unlock(&dir->i_mutex);
 752	dput(parent);
 753	return error;
 754}
 755
 756/**
 757 * rpc_mkpipe - make an rpc_pipefs file for kernel<->userspace communication
 758 * @parent: dentry of directory to create new "pipe" in
 759 * @name: name of pipe
 760 * @private: private data to associate with the pipe, for the caller's use
 761 * @ops: operations defining the behavior of the pipe: upcall, downcall,
 762 *	release_pipe, open_pipe, and destroy_msg.
 763 * @flags: rpc_inode flags
 764 *
 765 * Data is made available for userspace to read by calls to
 766 * rpc_queue_upcall().  The actual reads will result in calls to
 767 * @ops->upcall, which will be called with the file pointer,
 768 * message, and userspace buffer to copy to.
 769 *
 770 * Writes can come at any time, and do not necessarily have to be
 771 * responses to upcalls.  They will result in calls to @msg->downcall.
 772 *
 773 * The @private argument passed here will be available to all these methods
 774 * from the file pointer, via RPC_I(file->f_dentry->d_inode)->private.
 775 */
 776struct dentry *rpc_mkpipe(struct dentry *parent, const char *name,
 777			  void *private, const struct rpc_pipe_ops *ops,
 778			  int flags)
 779{
 780	struct dentry *dentry;
 781	struct inode *dir = parent->d_inode;
 782	umode_t umode = S_IFIFO | S_IRUSR | S_IWUSR;
 783	struct qstr q;
 784	int err;
 785
 786	if (ops->upcall == NULL)
 787		umode &= ~S_IRUGO;
 788	if (ops->downcall == NULL)
 789		umode &= ~S_IWUGO;
 790
 791	q.name = name;
 792	q.len = strlen(name);
 793	q.hash = full_name_hash(q.name, q.len),
 794
 795	mutex_lock_nested(&dir->i_mutex, I_MUTEX_PARENT);
 796	dentry = __rpc_lookup_create(parent, &q);
 797	if (IS_ERR(dentry))
 798		goto out;
 799	if (dentry->d_inode) {
 800		struct rpc_inode *rpci = RPC_I(dentry->d_inode);
 801		if (rpci->private != private ||
 802				rpci->ops != ops ||
 803				rpci->flags != flags) {
 804			dput (dentry);
 805			err = -EBUSY;
 806			goto out_err;
 807		}
 808		rpci->nkern_readwriters++;
 809		goto out;
 810	}
 811
 812	err = __rpc_mkpipe(dir, dentry, umode, &rpc_pipe_fops,
 813			   private, ops, flags);
 814	if (err)
 815		goto out_err;
 816out:
 817	mutex_unlock(&dir->i_mutex);
 818	return dentry;
 819out_err:
 820	dentry = ERR_PTR(err);
 821	printk(KERN_WARNING "%s: %s() failed to create pipe %s/%s (errno = %d)\n",
 822			__FILE__, __func__, parent->d_name.name, name,
 823			err);
 824	goto out;
 825}
 826EXPORT_SYMBOL_GPL(rpc_mkpipe);
 827
 828/**
 829 * rpc_unlink - remove a pipe
 830 * @dentry: dentry for the pipe, as returned from rpc_mkpipe
 831 *
 832 * After this call, lookups will no longer find the pipe, and any
 833 * attempts to read or write using preexisting opens of the pipe will
 834 * return -EPIPE.
 835 */
 836int
 837rpc_unlink(struct dentry *dentry)
 838{
 839	struct dentry *parent;
 840	struct inode *dir;
 841	int error = 0;
 842
 843	parent = dget_parent(dentry);
 844	dir = parent->d_inode;
 845	mutex_lock_nested(&dir->i_mutex, I_MUTEX_PARENT);
 846	error = __rpc_rmpipe(dir, dentry);
 847	mutex_unlock(&dir->i_mutex);
 848	dput(parent);
 849	return error;
 850}
 851EXPORT_SYMBOL_GPL(rpc_unlink);
 852
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 853enum {
 854	RPCAUTH_info,
 855	RPCAUTH_EOF
 856};
 857
 858static const struct rpc_filelist authfiles[] = {
 859	[RPCAUTH_info] = {
 860		.name = "info",
 861		.i_fop = &rpc_info_operations,
 862		.mode = S_IFREG | S_IRUSR,
 863	},
 864};
 865
 866static int rpc_clntdir_populate(struct dentry *dentry, void *private)
 867{
 868	return rpc_populate(dentry,
 869			    authfiles, RPCAUTH_info, RPCAUTH_EOF,
 870			    private);
 871}
 872
 873static void rpc_clntdir_depopulate(struct dentry *dentry)
 874{
 875	rpc_depopulate(dentry, authfiles, RPCAUTH_info, RPCAUTH_EOF);
 876}
 877
 878/**
 879 * rpc_create_client_dir - Create a new rpc_client directory in rpc_pipefs
 880 * @dentry: dentry from the rpc_pipefs root to the new directory
 881 * @name: &struct qstr for the name
 882 * @rpc_client: rpc client to associate with this directory
 883 *
 884 * This creates a directory at the given @path associated with
 885 * @rpc_clnt, which will contain a file named "info" with some basic
 886 * information about the client, together with any "pipes" that may
 887 * later be created using rpc_mkpipe().
 888 */
 889struct dentry *rpc_create_client_dir(struct dentry *dentry,
 890				   struct qstr *name,
 891				   struct rpc_clnt *rpc_client)
 892{
 893	return rpc_mkdir_populate(dentry, name, S_IRUGO | S_IXUGO, NULL,
 
 
 894			rpc_clntdir_populate, rpc_client);
 
 
 
 
 
 895}
 896
 897/**
 898 * rpc_remove_client_dir - Remove a directory created with rpc_create_client_dir()
 899 * @dentry: directory to remove
 900 */
 901int rpc_remove_client_dir(struct dentry *dentry)
 902{
 
 
 
 
 
 
 903	return rpc_rmdir_depopulate(dentry, rpc_clntdir_depopulate);
 904}
 905
 906static const struct rpc_filelist cache_pipefs_files[3] = {
 907	[0] = {
 908		.name = "channel",
 909		.i_fop = &cache_file_operations_pipefs,
 910		.mode = S_IFREG|S_IRUSR|S_IWUSR,
 911	},
 912	[1] = {
 913		.name = "content",
 914		.i_fop = &content_file_operations_pipefs,
 915		.mode = S_IFREG|S_IRUSR,
 916	},
 917	[2] = {
 918		.name = "flush",
 919		.i_fop = &cache_flush_operations_pipefs,
 920		.mode = S_IFREG|S_IRUSR|S_IWUSR,
 921	},
 922};
 923
 924static int rpc_cachedir_populate(struct dentry *dentry, void *private)
 925{
 926	return rpc_populate(dentry,
 927			    cache_pipefs_files, 0, 3,
 928			    private);
 929}
 930
 931static void rpc_cachedir_depopulate(struct dentry *dentry)
 932{
 933	rpc_depopulate(dentry, cache_pipefs_files, 0, 3);
 934}
 935
 936struct dentry *rpc_create_cache_dir(struct dentry *parent, struct qstr *name,
 937				    mode_t umode, struct cache_detail *cd)
 938{
 939	return rpc_mkdir_populate(parent, name, umode, NULL,
 940			rpc_cachedir_populate, cd);
 941}
 942
 943void rpc_remove_cache_dir(struct dentry *dentry)
 944{
 945	rpc_rmdir_depopulate(dentry, rpc_cachedir_depopulate);
 946}
 947
 948/*
 949 * populate the filesystem
 950 */
 951static const struct super_operations s_ops = {
 952	.alloc_inode	= rpc_alloc_inode,
 953	.destroy_inode	= rpc_destroy_inode,
 954	.statfs		= simple_statfs,
 955};
 956
 957#define RPCAUTH_GSSMAGIC 0x67596969
 958
 959/*
 960 * We have a single directory with 1 node in it.
 961 */
 962enum {
 963	RPCAUTH_lockd,
 964	RPCAUTH_mount,
 965	RPCAUTH_nfs,
 966	RPCAUTH_portmap,
 967	RPCAUTH_statd,
 968	RPCAUTH_nfsd4_cb,
 969	RPCAUTH_cache,
 
 
 970	RPCAUTH_RootEOF
 971};
 972
 973static const struct rpc_filelist files[] = {
 974	[RPCAUTH_lockd] = {
 975		.name = "lockd",
 976		.mode = S_IFDIR | S_IRUGO | S_IXUGO,
 977	},
 978	[RPCAUTH_mount] = {
 979		.name = "mount",
 980		.mode = S_IFDIR | S_IRUGO | S_IXUGO,
 981	},
 982	[RPCAUTH_nfs] = {
 983		.name = "nfs",
 984		.mode = S_IFDIR | S_IRUGO | S_IXUGO,
 985	},
 986	[RPCAUTH_portmap] = {
 987		.name = "portmap",
 988		.mode = S_IFDIR | S_IRUGO | S_IXUGO,
 989	},
 990	[RPCAUTH_statd] = {
 991		.name = "statd",
 992		.mode = S_IFDIR | S_IRUGO | S_IXUGO,
 993	},
 994	[RPCAUTH_nfsd4_cb] = {
 995		.name = "nfsd4_cb",
 996		.mode = S_IFDIR | S_IRUGO | S_IXUGO,
 997	},
 998	[RPCAUTH_cache] = {
 999		.name = "cache",
1000		.mode = S_IFDIR | S_IRUGO | S_IXUGO,
1001	},
 
 
 
 
 
 
 
 
1002};
1003
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1004static int
1005rpc_fill_super(struct super_block *sb, void *data, int silent)
1006{
1007	struct inode *inode;
1008	struct dentry *root;
 
 
 
1009
1010	sb->s_blocksize = PAGE_CACHE_SIZE;
1011	sb->s_blocksize_bits = PAGE_CACHE_SHIFT;
1012	sb->s_magic = RPCAUTH_GSSMAGIC;
1013	sb->s_op = &s_ops;
 
1014	sb->s_time_gran = 1;
1015
1016	inode = rpc_get_inode(sb, S_IFDIR | 0755);
1017	if (!inode)
1018		return -ENOMEM;
1019	sb->s_root = root = d_alloc_root(inode);
1020	if (!root) {
1021		iput(inode);
1022		return -ENOMEM;
1023	}
1024	if (rpc_populate(root, files, RPCAUTH_lockd, RPCAUTH_RootEOF, NULL))
1025		return -ENOMEM;
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1026	return 0;
 
 
 
 
 
 
 
 
 
 
1027}
1028
 
 
 
 
 
 
 
 
 
 
1029static struct dentry *
1030rpc_mount(struct file_system_type *fs_type,
1031		int flags, const char *dev_name, void *data)
1032{
1033	return mount_single(fs_type, flags, data, rpc_fill_super);
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1034}
1035
1036static struct file_system_type rpc_pipe_fs_type = {
1037	.owner		= THIS_MODULE,
1038	.name		= "rpc_pipefs",
1039	.mount		= rpc_mount,
1040	.kill_sb	= kill_litter_super,
1041};
 
 
1042
1043static void
1044init_once(void *foo)
1045{
1046	struct rpc_inode *rpci = (struct rpc_inode *) foo;
1047
1048	inode_init_once(&rpci->vfs_inode);
1049	rpci->private = NULL;
1050	rpci->nreaders = 0;
1051	rpci->nwriters = 0;
1052	INIT_LIST_HEAD(&rpci->in_upcall);
1053	INIT_LIST_HEAD(&rpci->in_downcall);
1054	INIT_LIST_HEAD(&rpci->pipe);
1055	rpci->pipelen = 0;
1056	init_waitqueue_head(&rpci->waitq);
1057	INIT_DELAYED_WORK(&rpci->queue_timeout,
1058			    rpc_timeout_upcall_queue);
1059	rpci->ops = NULL;
1060}
1061
1062int register_rpc_pipefs(void)
1063{
1064	int err;
1065
1066	rpc_inode_cachep = kmem_cache_create("rpc_inode_cache",
1067				sizeof(struct rpc_inode),
1068				0, (SLAB_HWCACHE_ALIGN|SLAB_RECLAIM_ACCOUNT|
1069						SLAB_MEM_SPREAD),
1070				init_once);
1071	if (!rpc_inode_cachep)
1072		return -ENOMEM;
 
 
 
1073	err = register_filesystem(&rpc_pipe_fs_type);
1074	if (err) {
1075		kmem_cache_destroy(rpc_inode_cachep);
1076		return err;
1077	}
1078
1079	return 0;
 
 
 
 
 
 
1080}
1081
1082void unregister_rpc_pipefs(void)
1083{
 
1084	kmem_cache_destroy(rpc_inode_cachep);
1085	unregister_filesystem(&rpc_pipe_fs_type);
1086}