1/*
   2 *  linux/net/sunrpc/clnt.c
   3 *
   4 *  This file contains the high-level RPC interface.
   5 *  It is modeled as a finite state machine to support both synchronous
   6 *  and asynchronous requests.
   7 *
   8 *  -	RPC header generation and argument serialization.
   9 *  -	Credential refresh.
  10 *  -	TCP connect handling.
  11 *  -	Retry of operation when it is suspected the operation failed because
  12 *	of uid squashing on the server, or when the credentials were stale
  13 *	and need to be refreshed, or when a packet was damaged in transit.
  14 *	This may be have to be moved to the VFS layer.
  15 *
  16 *  Copyright (C) 1992,1993 Rick Sladkey <jrs@world.std.com>
  17 *  Copyright (C) 1995,1996 Olaf Kirch <okir@monad.swb.de>
  18 */
  19
  20
  21#include <linux/module.h>
  22#include <linux/types.h>
  23#include <linux/kallsyms.h>
  24#include <linux/mm.h>
  25#include <linux/namei.h>
  26#include <linux/mount.h>
  27#include <linux/slab.h>
  28#include <linux/rcupdate.h>
  29#include <linux/utsname.h>
  30#include <linux/workqueue.h>
  31#include <linux/in.h>
  32#include <linux/in6.h>
  33#include <linux/un.h>
  34
  35#include <linux/sunrpc/clnt.h>
  36#include <linux/sunrpc/addr.h>
  37#include <linux/sunrpc/rpc_pipe_fs.h>
  38#include <linux/sunrpc/metrics.h>
  39#include <linux/sunrpc/bc_xprt.h>
  40#include <trace/events/sunrpc.h>
  41
  42#include "sunrpc.h"
  43#include "netns.h"
  44
  45#if IS_ENABLED(CONFIG_SUNRPC_DEBUG)
  46# define RPCDBG_FACILITY	RPCDBG_CALL
  47#endif
  48
  49#define dprint_status(t)					\
  50	dprintk("RPC: %5u %s (status %d)\n", t->tk_pid,		\
  51			__func__, t->tk_status)
  52
  53/*
  54 * All RPC clients are linked into this list
  55 */
  56
  57static DECLARE_WAIT_QUEUE_HEAD(destroy_wait);
  58
  59
  60static void	call_start(struct rpc_task *task);
  61static void	call_reserve(struct rpc_task *task);
  62static void	call_reserveresult(struct rpc_task *task);
  63static void	call_allocate(struct rpc_task *task);
 
  64static void	call_decode(struct rpc_task *task);
  65static void	call_bind(struct rpc_task *task);
  66static void	call_bind_status(struct rpc_task *task);
  67static void	call_transmit(struct rpc_task *task);
  68#if defined(CONFIG_SUNRPC_BACKCHANNEL)
  69static void	call_bc_transmit(struct rpc_task *task);
  70#endif /* CONFIG_SUNRPC_BACKCHANNEL */
  71static void	call_status(struct rpc_task *task);
  72static void	call_transmit_status(struct rpc_task *task);
  73static void	call_refresh(struct rpc_task *task);
  74static void	call_refreshresult(struct rpc_task *task);
  75static void	call_timeout(struct rpc_task *task);
  76static void	call_connect(struct rpc_task *task);
  77static void	call_connect_status(struct rpc_task *task);
  78
  79static __be32	*rpc_encode_header(struct rpc_task *task);
  80static __be32	*rpc_verify_header(struct rpc_task *task);
 
 
  81static int	rpc_ping(struct rpc_clnt *clnt);
 
  82
  83static void rpc_register_client(struct rpc_clnt *clnt)
  84{
  85	struct net *net = rpc_net_ns(clnt);
  86	struct sunrpc_net *sn = net_generic(net, sunrpc_net_id);
  87
  88	spin_lock(&sn->rpc_client_lock);
  89	list_add(&clnt->cl_clients, &sn->all_clients);
  90	spin_unlock(&sn->rpc_client_lock);
  91}
  92
  93static void rpc_unregister_client(struct rpc_clnt *clnt)
  94{
  95	struct net *net = rpc_net_ns(clnt);
  96	struct sunrpc_net *sn = net_generic(net, sunrpc_net_id);
  97
  98	spin_lock(&sn->rpc_client_lock);
  99	list_del(&clnt->cl_clients);
 100	spin_unlock(&sn->rpc_client_lock);
 101}
 102
 103static void __rpc_clnt_remove_pipedir(struct rpc_clnt *clnt)
 104{
 105	rpc_remove_client_dir(clnt);
 106}
 107
 108static void rpc_clnt_remove_pipedir(struct rpc_clnt *clnt)
 109{
 110	struct net *net = rpc_net_ns(clnt);
 111	struct super_block *pipefs_sb;
 112
 113	pipefs_sb = rpc_get_sb_net(net);
 114	if (pipefs_sb) {
 115		__rpc_clnt_remove_pipedir(clnt);
 116		rpc_put_sb_net(net);
 117	}
 118}
 119
 120static struct dentry *rpc_setup_pipedir_sb(struct super_block *sb,
 121				    struct rpc_clnt *clnt)
 122{
 123	static uint32_t clntid;
 124	const char *dir_name = clnt->cl_program->pipe_dir_name;
 125	char name[15];
 126	struct dentry *dir, *dentry;
 127
 128	dir = rpc_d_lookup_sb(sb, dir_name);
 129	if (dir == NULL) {
 130		pr_info("RPC: pipefs directory doesn't exist: %s\n", dir_name);
 131		return dir;
 132	}
 133	for (;;) {
 134		snprintf(name, sizeof(name), "clnt%x", (unsigned int)clntid++);
 135		name[sizeof(name) - 1] = '\0';
 136		dentry = rpc_create_client_dir(dir, name, clnt);
 137		if (!IS_ERR(dentry))
 138			break;
 139		if (dentry == ERR_PTR(-EEXIST))
 140			continue;
 141		printk(KERN_INFO "RPC: Couldn't create pipefs entry"
 142				" %s/%s, error %ld\n",
 143				dir_name, name, PTR_ERR(dentry));
 144		break;
 145	}
 146	dput(dir);
 147	return dentry;
 148}
 149
 150static int
 151rpc_setup_pipedir(struct super_block *pipefs_sb, struct rpc_clnt *clnt)
 152{
 153	struct dentry *dentry;
 154
 155	if (clnt->cl_program->pipe_dir_name != NULL) {
 156		dentry = rpc_setup_pipedir_sb(pipefs_sb, clnt);
 157		if (IS_ERR(dentry))
 158			return PTR_ERR(dentry);
 159	}
 160	return 0;
 161}
 162
 163static int rpc_clnt_skip_event(struct rpc_clnt *clnt, unsigned long event)
 164{
 165	if (clnt->cl_program->pipe_dir_name == NULL)
 166		return 1;
 167
 168	switch (event) {
 169	case RPC_PIPEFS_MOUNT:
 170		if (clnt->cl_pipedir_objects.pdh_dentry != NULL)
 171			return 1;
 172		if (atomic_read(&clnt->cl_count) == 0)
 173			return 1;
 174		break;
 175	case RPC_PIPEFS_UMOUNT:
 176		if (clnt->cl_pipedir_objects.pdh_dentry == NULL)
 177			return 1;
 178		break;
 179	}
 180	return 0;
 181}
 182
 183static int __rpc_clnt_handle_event(struct rpc_clnt *clnt, unsigned long event,
 184				   struct super_block *sb)
 185{
 186	struct dentry *dentry;
 187	int err = 0;
 188
 189	switch (event) {
 190	case RPC_PIPEFS_MOUNT:
 191		dentry = rpc_setup_pipedir_sb(sb, clnt);
 192		if (!dentry)
 193			return -ENOENT;
 194		if (IS_ERR(dentry))
 195			return PTR_ERR(dentry);
 196		break;
 197	case RPC_PIPEFS_UMOUNT:
 198		__rpc_clnt_remove_pipedir(clnt);
 199		break;
 200	default:
 201		printk(KERN_ERR "%s: unknown event: %ld\n", __func__, event);
 202		return -ENOTSUPP;
 203	}
 204	return err;
 205}
 206
 207static int __rpc_pipefs_event(struct rpc_clnt *clnt, unsigned long event,
 208				struct super_block *sb)
 209{
 210	int error = 0;
 211
 212	for (;; clnt = clnt->cl_parent) {
 213		if (!rpc_clnt_skip_event(clnt, event))
 214			error = __rpc_clnt_handle_event(clnt, event, sb);
 215		if (error || clnt == clnt->cl_parent)
 216			break;
 217	}
 218	return error;
 219}
 220
 221static struct rpc_clnt *rpc_get_client_for_event(struct net *net, int event)
 222{
 223	struct sunrpc_net *sn = net_generic(net, sunrpc_net_id);
 224	struct rpc_clnt *clnt;
 225
 226	spin_lock(&sn->rpc_client_lock);
 227	list_for_each_entry(clnt, &sn->all_clients, cl_clients) {
 228		if (rpc_clnt_skip_event(clnt, event))
 229			continue;
 230		spin_unlock(&sn->rpc_client_lock);
 231		return clnt;
 232	}
 233	spin_unlock(&sn->rpc_client_lock);
 234	return NULL;
 235}
 236
 237static int rpc_pipefs_event(struct notifier_block *nb, unsigned long event,
 238			    void *ptr)
 239{
 240	struct super_block *sb = ptr;
 241	struct rpc_clnt *clnt;
 242	int error = 0;
 243
 244	while ((clnt = rpc_get_client_for_event(sb->s_fs_info, event))) {
 245		error = __rpc_pipefs_event(clnt, event, sb);
 246		if (error)
 247			break;
 248	}
 249	return error;
 250}
 251
 252static struct notifier_block rpc_clients_block = {
 253	.notifier_call	= rpc_pipefs_event,
 254	.priority	= SUNRPC_PIPEFS_RPC_PRIO,
 255};
 256
 257int rpc_clients_notifier_register(void)
 258{
 259	return rpc_pipefs_notifier_register(&rpc_clients_block);
 260}
 261
 262void rpc_clients_notifier_unregister(void)
 263{
 264	return rpc_pipefs_notifier_unregister(&rpc_clients_block);
 265}
 266
 267static struct rpc_xprt *rpc_clnt_set_transport(struct rpc_clnt *clnt,
 268		struct rpc_xprt *xprt,
 269		const struct rpc_timeout *timeout)
 270{
 271	struct rpc_xprt *old;
 272
 273	spin_lock(&clnt->cl_lock);
 274	old = rcu_dereference_protected(clnt->cl_xprt,
 275			lockdep_is_held(&clnt->cl_lock));
 276
 277	if (!xprt_bound(xprt))
 278		clnt->cl_autobind = 1;
 279
 280	clnt->cl_timeout = timeout;
 281	rcu_assign_pointer(clnt->cl_xprt, xprt);
 282	spin_unlock(&clnt->cl_lock);
 283
 284	return old;
 285}
 286
 287static void rpc_clnt_set_nodename(struct rpc_clnt *clnt, const char *nodename)
 288{
 289	clnt->cl_nodelen = strlcpy(clnt->cl_nodename,
 290			nodename, sizeof(clnt->cl_nodename));
 291}
 292
 293static int rpc_client_register(struct rpc_clnt *clnt,
 294			       rpc_authflavor_t pseudoflavor,
 295			       const char *client_name)
 296{
 297	struct rpc_auth_create_args auth_args = {
 298		.pseudoflavor = pseudoflavor,
 299		.target_name = client_name,
 300	};
 301	struct rpc_auth *auth;
 302	struct net *net = rpc_net_ns(clnt);
 303	struct super_block *pipefs_sb;
 304	int err;
 305
 306	rpc_clnt_debugfs_register(clnt);
 307
 308	pipefs_sb = rpc_get_sb_net(net);
 309	if (pipefs_sb) {
 310		err = rpc_setup_pipedir(pipefs_sb, clnt);
 311		if (err)
 312			goto out;
 313	}
 314
 315	rpc_register_client(clnt);
 316	if (pipefs_sb)
 317		rpc_put_sb_net(net);
 318
 319	auth = rpcauth_create(&auth_args, clnt);
 320	if (IS_ERR(auth)) {
 321		dprintk("RPC:       Couldn't create auth handle (flavor %u)\n",
 322				pseudoflavor);
 323		err = PTR_ERR(auth);
 324		goto err_auth;
 325	}
 326	return 0;
 327err_auth:
 328	pipefs_sb = rpc_get_sb_net(net);
 329	rpc_unregister_client(clnt);
 330	__rpc_clnt_remove_pipedir(clnt);
 331out:
 332	if (pipefs_sb)
 333		rpc_put_sb_net(net);
 334	rpc_clnt_debugfs_unregister(clnt);
 335	return err;
 336}
 337
 338static DEFINE_IDA(rpc_clids);
 339
 
 
 
 
 
 340static int rpc_alloc_clid(struct rpc_clnt *clnt)
 341{
 342	int clid;
 343
 344	clid = ida_simple_get(&rpc_clids, 0, 0, GFP_KERNEL);
 345	if (clid < 0)
 346		return clid;
 347	clnt->cl_clid = clid;
 348	return 0;
 349}
 350
 351static void rpc_free_clid(struct rpc_clnt *clnt)
 352{
 353	ida_simple_remove(&rpc_clids, clnt->cl_clid);
 354}
 355
 356static struct rpc_clnt * rpc_new_client(const struct rpc_create_args *args,
 357		struct rpc_xprt_switch *xps,
 358		struct rpc_xprt *xprt,
 359		struct rpc_clnt *parent)
 360{
 361	const struct rpc_program *program = args->program;
 362	const struct rpc_version *version;
 363	struct rpc_clnt *clnt = NULL;
 364	const struct rpc_timeout *timeout;
 365	const char *nodename = args->nodename;
 366	int err;
 367
 368	/* sanity check the name before trying to print it */
 369	dprintk("RPC:       creating %s client for %s (xprt %p)\n",
 370			program->name, args->servername, xprt);
 371
 372	err = rpciod_up();
 373	if (err)
 374		goto out_no_rpciod;
 375
 376	err = -EINVAL;
 377	if (args->version >= program->nrvers)
 378		goto out_err;
 379	version = program->version[args->version];
 380	if (version == NULL)
 381		goto out_err;
 382
 383	err = -ENOMEM;
 384	clnt = kzalloc(sizeof(*clnt), GFP_KERNEL);
 385	if (!clnt)
 386		goto out_err;
 387	clnt->cl_parent = parent ? : clnt;
 388
 389	err = rpc_alloc_clid(clnt);
 390	if (err)
 391		goto out_no_clid;
 392
 
 393	clnt->cl_procinfo = version->procs;
 394	clnt->cl_maxproc  = version->nrprocs;
 395	clnt->cl_prog     = args->prognumber ? : program->number;
 396	clnt->cl_vers     = version->number;
 397	clnt->cl_stats    = program->stats;
 398	clnt->cl_metrics  = rpc_alloc_iostats(clnt);
 399	rpc_init_pipe_dir_head(&clnt->cl_pipedir_objects);
 400	err = -ENOMEM;
 401	if (clnt->cl_metrics == NULL)
 402		goto out_no_stats;
 403	clnt->cl_program  = program;
 404	INIT_LIST_HEAD(&clnt->cl_tasks);
 405	spin_lock_init(&clnt->cl_lock);
 406
 407	timeout = xprt->timeout;
 408	if (args->timeout != NULL) {
 409		memcpy(&clnt->cl_timeout_default, args->timeout,
 410				sizeof(clnt->cl_timeout_default));
 411		timeout = &clnt->cl_timeout_default;
 412	}
 413
 414	rpc_clnt_set_transport(clnt, xprt, timeout);
 415	xprt_iter_init(&clnt->cl_xpi, xps);
 416	xprt_switch_put(xps);
 417
 418	clnt->cl_rtt = &clnt->cl_rtt_default;
 419	rpc_init_rtt(&clnt->cl_rtt_default, clnt->cl_timeout->to_initval);
 420
 421	atomic_set(&clnt->cl_count, 1);
 422
 423	if (nodename == NULL)
 424		nodename = utsname()->nodename;
 425	/* save the nodename */
 426	rpc_clnt_set_nodename(clnt, nodename);
 427
 428	err = rpc_client_register(clnt, args->authflavor, args->client_name);
 429	if (err)
 430		goto out_no_path;
 431	if (parent)
 432		atomic_inc(&parent->cl_count);
 433	return clnt;
 434
 435out_no_path:
 436	rpc_free_iostats(clnt->cl_metrics);
 437out_no_stats:
 
 438	rpc_free_clid(clnt);
 439out_no_clid:
 440	kfree(clnt);
 441out_err:
 442	rpciod_down();
 443out_no_rpciod:
 444	xprt_switch_put(xps);
 445	xprt_put(xprt);
 446	return ERR_PTR(err);
 447}
 448
 449struct rpc_clnt *rpc_create_xprt(struct rpc_create_args *args,
 450					struct rpc_xprt *xprt)
 451{
 452	struct rpc_clnt *clnt = NULL;
 453	struct rpc_xprt_switch *xps;
 454
 455	xps = xprt_switch_alloc(xprt, GFP_KERNEL);
 456	if (xps == NULL)
 457		return ERR_PTR(-ENOMEM);
 458
 
 
 
 
 
 
 
 
 
 
 
 459	clnt = rpc_new_client(args, xps, xprt, NULL);
 460	if (IS_ERR(clnt))
 461		return clnt;
 462
 463	if (!(args->flags & RPC_CLNT_CREATE_NOPING)) {
 464		int err = rpc_ping(clnt);
 465		if (err != 0) {
 466			rpc_shutdown_client(clnt);
 467			return ERR_PTR(err);
 468		}
 469	}
 470
 471	clnt->cl_softrtry = 1;
 472	if (args->flags & RPC_CLNT_CREATE_HARDRTRY)
 473		clnt->cl_softrtry = 0;
 
 
 
 474
 475	if (args->flags & RPC_CLNT_CREATE_AUTOBIND)
 476		clnt->cl_autobind = 1;
 477	if (args->flags & RPC_CLNT_CREATE_NO_RETRANS_TIMEOUT)
 478		clnt->cl_noretranstimeo = 1;
 479	if (args->flags & RPC_CLNT_CREATE_DISCRTRY)
 480		clnt->cl_discrtry = 1;
 481	if (!(args->flags & RPC_CLNT_CREATE_QUIET))
 482		clnt->cl_chatty = 1;
 483
 484	return clnt;
 485}
 486EXPORT_SYMBOL_GPL(rpc_create_xprt);
 487
 488/**
 489 * rpc_create - create an RPC client and transport with one call
 490 * @args: rpc_clnt create argument structure
 491 *
 492 * Creates and initializes an RPC transport and an RPC client.
 493 *
 494 * It can ping the server in order to determine if it is up, and to see if
 495 * it supports this program and version.  RPC_CLNT_CREATE_NOPING disables
 496 * this behavior so asynchronous tasks can also use rpc_create.
 497 */
 498struct rpc_clnt *rpc_create(struct rpc_create_args *args)
 499{
 500	struct rpc_xprt *xprt;
 501	struct xprt_create xprtargs = {
 502		.net = args->net,
 503		.ident = args->protocol,
 504		.srcaddr = args->saddress,
 505		.dstaddr = args->address,
 506		.addrlen = args->addrsize,
 507		.servername = args->servername,
 508		.bc_xprt = args->bc_xprt,
 509	};
 510	char servername[48];
 
 
 
 
 
 
 
 
 
 
 
 511
 512	if (args->flags & RPC_CLNT_CREATE_INFINITE_SLOTS)
 513		xprtargs.flags |= XPRT_CREATE_INFINITE_SLOTS;
 514	if (args->flags & RPC_CLNT_CREATE_NO_IDLE_TIMEOUT)
 515		xprtargs.flags |= XPRT_CREATE_NO_IDLE_TIMEOUT;
 516	/*
 517	 * If the caller chooses not to specify a hostname, whip
 518	 * up a string representation of the passed-in address.
 519	 */
 520	if (xprtargs.servername == NULL) {
 521		struct sockaddr_un *sun =
 522				(struct sockaddr_un *)args->address;
 523		struct sockaddr_in *sin =
 524				(struct sockaddr_in *)args->address;
 525		struct sockaddr_in6 *sin6 =
 526				(struct sockaddr_in6 *)args->address;
 527
 528		servername[0] = '\0';
 529		switch (args->address->sa_family) {
 530		case AF_LOCAL:
 531			snprintf(servername, sizeof(servername), "%s",
 532				 sun->sun_path);
 533			break;
 534		case AF_INET:
 535			snprintf(servername, sizeof(servername), "%pI4",
 536				 &sin->sin_addr.s_addr);
 537			break;
 538		case AF_INET6:
 539			snprintf(servername, sizeof(servername), "%pI6",
 540				 &sin6->sin6_addr);
 541			break;
 542		default:
 543			/* caller wants default server name, but
 544			 * address family isn't recognized. */
 545			return ERR_PTR(-EINVAL);
 546		}
 547		xprtargs.servername = servername;
 548	}
 549
 550	xprt = xprt_create_transport(&xprtargs);
 551	if (IS_ERR(xprt))
 552		return (struct rpc_clnt *)xprt;
 553
 554	/*
 555	 * By default, kernel RPC client connects from a reserved port.
 556	 * CAP_NET_BIND_SERVICE will not be set for unprivileged requesters,
 557	 * but it is always enabled for rpciod, which handles the connect
 558	 * operation.
 559	 */
 560	xprt->resvport = 1;
 561	if (args->flags & RPC_CLNT_CREATE_NONPRIVPORT)
 562		xprt->resvport = 0;
 563
 564	return rpc_create_xprt(args, xprt);
 
 
 
 
 
 
 
 
 565}
 566EXPORT_SYMBOL_GPL(rpc_create);
 567
 568/*
 569 * This function clones the RPC client structure. It allows us to share the
 570 * same transport while varying parameters such as the authentication
 571 * flavour.
 572 */
 573static struct rpc_clnt *__rpc_clone_client(struct rpc_create_args *args,
 574					   struct rpc_clnt *clnt)
 575{
 576	struct rpc_xprt_switch *xps;
 577	struct rpc_xprt *xprt;
 578	struct rpc_clnt *new;
 579	int err;
 580
 581	err = -ENOMEM;
 582	rcu_read_lock();
 583	xprt = xprt_get(rcu_dereference(clnt->cl_xprt));
 584	xps = xprt_switch_get(rcu_dereference(clnt->cl_xpi.xpi_xpswitch));
 585	rcu_read_unlock();
 586	if (xprt == NULL || xps == NULL) {
 587		xprt_put(xprt);
 588		xprt_switch_put(xps);
 589		goto out_err;
 590	}
 591	args->servername = xprt->servername;
 592	args->nodename = clnt->cl_nodename;
 593
 594	new = rpc_new_client(args, xps, xprt, clnt);
 595	if (IS_ERR(new)) {
 596		err = PTR_ERR(new);
 597		goto out_err;
 598	}
 599
 600	/* Turn off autobind on clones */
 601	new->cl_autobind = 0;
 602	new->cl_softrtry = clnt->cl_softrtry;
 
 603	new->cl_noretranstimeo = clnt->cl_noretranstimeo;
 604	new->cl_discrtry = clnt->cl_discrtry;
 605	new->cl_chatty = clnt->cl_chatty;
 
 606	return new;
 607
 608out_err:
 609	dprintk("RPC:       %s: returned error %d\n", __func__, err);
 610	return ERR_PTR(err);
 611}
 612
 613/**
 614 * rpc_clone_client - Clone an RPC client structure
 615 *
 616 * @clnt: RPC client whose parameters are copied
 617 *
 618 * Returns a fresh RPC client or an ERR_PTR.
 619 */
 620struct rpc_clnt *rpc_clone_client(struct rpc_clnt *clnt)
 621{
 622	struct rpc_create_args args = {
 623		.program	= clnt->cl_program,
 624		.prognumber	= clnt->cl_prog,
 625		.version	= clnt->cl_vers,
 626		.authflavor	= clnt->cl_auth->au_flavor,
 
 627	};
 628	return __rpc_clone_client(&args, clnt);
 629}
 630EXPORT_SYMBOL_GPL(rpc_clone_client);
 631
 632/**
 633 * rpc_clone_client_set_auth - Clone an RPC client structure and set its auth
 634 *
 635 * @clnt: RPC client whose parameters are copied
 636 * @flavor: security flavor for new client
 637 *
 638 * Returns a fresh RPC client or an ERR_PTR.
 639 */
 640struct rpc_clnt *
 641rpc_clone_client_set_auth(struct rpc_clnt *clnt, rpc_authflavor_t flavor)
 642{
 643	struct rpc_create_args args = {
 644		.program	= clnt->cl_program,
 645		.prognumber	= clnt->cl_prog,
 646		.version	= clnt->cl_vers,
 647		.authflavor	= flavor,
 
 648	};
 649	return __rpc_clone_client(&args, clnt);
 650}
 651EXPORT_SYMBOL_GPL(rpc_clone_client_set_auth);
 652
 653/**
 654 * rpc_switch_client_transport: switch the RPC transport on the fly
 655 * @clnt: pointer to a struct rpc_clnt
 656 * @args: pointer to the new transport arguments
 657 * @timeout: pointer to the new timeout parameters
 658 *
 659 * This function allows the caller to switch the RPC transport for the
 660 * rpc_clnt structure 'clnt' to allow it to connect to a mirrored NFS
 661 * server, for instance.  It assumes that the caller has ensured that
 662 * there are no active RPC tasks by using some form of locking.
 663 *
 664 * Returns zero if "clnt" is now using the new xprt.  Otherwise a
 665 * negative errno is returned, and "clnt" continues to use the old
 666 * xprt.
 667 */
 668int rpc_switch_client_transport(struct rpc_clnt *clnt,
 669		struct xprt_create *args,
 670		const struct rpc_timeout *timeout)
 671{
 672	const struct rpc_timeout *old_timeo;
 673	rpc_authflavor_t pseudoflavor;
 674	struct rpc_xprt_switch *xps, *oldxps;
 675	struct rpc_xprt *xprt, *old;
 676	struct rpc_clnt *parent;
 677	int err;
 678
 679	xprt = xprt_create_transport(args);
 680	if (IS_ERR(xprt)) {
 681		dprintk("RPC:       failed to create new xprt for clnt %p\n",
 682			clnt);
 683		return PTR_ERR(xprt);
 684	}
 685
 686	xps = xprt_switch_alloc(xprt, GFP_KERNEL);
 687	if (xps == NULL) {
 688		xprt_put(xprt);
 689		return -ENOMEM;
 690	}
 691
 692	pseudoflavor = clnt->cl_auth->au_flavor;
 693
 694	old_timeo = clnt->cl_timeout;
 695	old = rpc_clnt_set_transport(clnt, xprt, timeout);
 696	oldxps = xprt_iter_xchg_switch(&clnt->cl_xpi, xps);
 697
 698	rpc_unregister_client(clnt);
 699	__rpc_clnt_remove_pipedir(clnt);
 700	rpc_clnt_debugfs_unregister(clnt);
 701
 702	/*
 703	 * A new transport was created.  "clnt" therefore
 704	 * becomes the root of a new cl_parent tree.  clnt's
 705	 * children, if it has any, still point to the old xprt.
 706	 */
 707	parent = clnt->cl_parent;
 708	clnt->cl_parent = clnt;
 709
 710	/*
 711	 * The old rpc_auth cache cannot be re-used.  GSS
 712	 * contexts in particular are between a single
 713	 * client and server.
 714	 */
 715	err = rpc_client_register(clnt, pseudoflavor, NULL);
 716	if (err)
 717		goto out_revert;
 718
 719	synchronize_rcu();
 720	if (parent != clnt)
 721		rpc_release_client(parent);
 722	xprt_switch_put(oldxps);
 723	xprt_put(old);
 724	dprintk("RPC:       replaced xprt for clnt %p\n", clnt);
 725	return 0;
 726
 727out_revert:
 728	xps = xprt_iter_xchg_switch(&clnt->cl_xpi, oldxps);
 729	rpc_clnt_set_transport(clnt, old, old_timeo);
 730	clnt->cl_parent = parent;
 731	rpc_client_register(clnt, pseudoflavor, NULL);
 732	xprt_switch_put(xps);
 733	xprt_put(xprt);
 734	dprintk("RPC:       failed to switch xprt for clnt %p\n", clnt);
 735	return err;
 736}
 737EXPORT_SYMBOL_GPL(rpc_switch_client_transport);
 738
 739static
 740int rpc_clnt_xprt_iter_init(struct rpc_clnt *clnt, struct rpc_xprt_iter *xpi)
 741{
 742	struct rpc_xprt_switch *xps;
 743
 744	rcu_read_lock();
 745	xps = xprt_switch_get(rcu_dereference(clnt->cl_xpi.xpi_xpswitch));
 746	rcu_read_unlock();
 747	if (xps == NULL)
 748		return -EAGAIN;
 749	xprt_iter_init_listall(xpi, xps);
 750	xprt_switch_put(xps);
 751	return 0;
 752}
 753
 754/**
 755 * rpc_clnt_iterate_for_each_xprt - Apply a function to all transports
 756 * @clnt: pointer to client
 757 * @fn: function to apply
 758 * @data: void pointer to function data
 759 *
 760 * Iterates through the list of RPC transports currently attached to the
 761 * client and applies the function fn(clnt, xprt, data).
 762 *
 763 * On error, the iteration stops, and the function returns the error value.
 764 */
 765int rpc_clnt_iterate_for_each_xprt(struct rpc_clnt *clnt,
 766		int (*fn)(struct rpc_clnt *, struct rpc_xprt *, void *),
 767		void *data)
 768{
 769	struct rpc_xprt_iter xpi;
 770	int ret;
 771
 772	ret = rpc_clnt_xprt_iter_init(clnt, &xpi);
 773	if (ret)
 774		return ret;
 775	for (;;) {
 776		struct rpc_xprt *xprt = xprt_iter_get_next(&xpi);
 777
 778		if (!xprt)
 779			break;
 780		ret = fn(clnt, xprt, data);
 781		xprt_put(xprt);
 782		if (ret < 0)
 783			break;
 784	}
 785	xprt_iter_destroy(&xpi);
 786	return ret;
 787}
 788EXPORT_SYMBOL_GPL(rpc_clnt_iterate_for_each_xprt);
 789
 790/*
 791 * Kill all tasks for the given client.
 792 * XXX: kill their descendants as well?
 793 */
 794void rpc_killall_tasks(struct rpc_clnt *clnt)
 795{
 796	struct rpc_task	*rovr;
 797
 798
 799	if (list_empty(&clnt->cl_tasks))
 800		return;
 801	dprintk("RPC:       killing all tasks for client %p\n", clnt);
 802	/*
 803	 * Spin lock all_tasks to prevent changes...
 804	 */
 805	spin_lock(&clnt->cl_lock);
 806	list_for_each_entry(rovr, &clnt->cl_tasks, tk_task) {
 807		if (!RPC_IS_ACTIVATED(rovr))
 808			continue;
 809		if (!(rovr->tk_flags & RPC_TASK_KILLED)) {
 810			rovr->tk_flags |= RPC_TASK_KILLED;
 811			rpc_exit(rovr, -EIO);
 812			if (RPC_IS_QUEUED(rovr))
 813				rpc_wake_up_queued_task(rovr->tk_waitqueue,
 814							rovr);
 815		}
 816	}
 817	spin_unlock(&clnt->cl_lock);
 818}
 819EXPORT_SYMBOL_GPL(rpc_killall_tasks);
 820
 821/*
 822 * Properly shut down an RPC client, terminating all outstanding
 823 * requests.
 824 */
 825void rpc_shutdown_client(struct rpc_clnt *clnt)
 826{
 827	might_sleep();
 828
 829	dprintk_rcu("RPC:       shutting down %s client for %s\n",
 830			clnt->cl_program->name,
 831			rcu_dereference(clnt->cl_xprt)->servername);
 832
 833	while (!list_empty(&clnt->cl_tasks)) {
 834		rpc_killall_tasks(clnt);
 835		wait_event_timeout(destroy_wait,
 836			list_empty(&clnt->cl_tasks), 1*HZ);
 837	}
 838
 839	rpc_release_client(clnt);
 840}
 841EXPORT_SYMBOL_GPL(rpc_shutdown_client);
 842
 843/*
 844 * Free an RPC client
 845 */
 846static struct rpc_clnt *
 847rpc_free_client(struct rpc_clnt *clnt)
 848{
 849	struct rpc_clnt *parent = NULL;
 850
 851	dprintk_rcu("RPC:       destroying %s client for %s\n",
 852			clnt->cl_program->name,
 853			rcu_dereference(clnt->cl_xprt)->servername);
 854	if (clnt->cl_parent != clnt)
 855		parent = clnt->cl_parent;
 856	rpc_clnt_debugfs_unregister(clnt);
 857	rpc_clnt_remove_pipedir(clnt);
 858	rpc_unregister_client(clnt);
 859	rpc_free_iostats(clnt->cl_metrics);
 860	clnt->cl_metrics = NULL;
 861	xprt_put(rcu_dereference_raw(clnt->cl_xprt));
 862	xprt_iter_destroy(&clnt->cl_xpi);
 863	rpciod_down();
 
 864	rpc_free_clid(clnt);
 865	kfree(clnt);
 866	return parent;
 867}
 868
 869/*
 870 * Free an RPC client
 871 */
 872static struct rpc_clnt * 
 873rpc_free_auth(struct rpc_clnt *clnt)
 874{
 875	if (clnt->cl_auth == NULL)
 876		return rpc_free_client(clnt);
 877
 878	/*
 879	 * Note: RPCSEC_GSS may need to send NULL RPC calls in order to
 880	 *       release remaining GSS contexts. This mechanism ensures
 881	 *       that it can do so safely.
 882	 */
 883	atomic_inc(&clnt->cl_count);
 884	rpcauth_release(clnt->cl_auth);
 885	clnt->cl_auth = NULL;
 886	if (atomic_dec_and_test(&clnt->cl_count))
 887		return rpc_free_client(clnt);
 888	return NULL;
 889}
 890
 891/*
 892 * Release reference to the RPC client
 893 */
 894void
 895rpc_release_client(struct rpc_clnt *clnt)
 896{
 897	dprintk("RPC:       rpc_release_client(%p)\n", clnt);
 898
 899	do {
 900		if (list_empty(&clnt->cl_tasks))
 901			wake_up(&destroy_wait);
 902		if (!atomic_dec_and_test(&clnt->cl_count))
 903			break;
 904		clnt = rpc_free_auth(clnt);
 905	} while (clnt != NULL);
 906}
 907EXPORT_SYMBOL_GPL(rpc_release_client);
 908
 909/**
 910 * rpc_bind_new_program - bind a new RPC program to an existing client
 911 * @old: old rpc_client
 912 * @program: rpc program to set
 913 * @vers: rpc program version
 914 *
 915 * Clones the rpc client and sets up a new RPC program. This is mainly
 916 * of use for enabling different RPC programs to share the same transport.
 917 * The Sun NFSv2/v3 ACL protocol can do this.
 918 */
 919struct rpc_clnt *rpc_bind_new_program(struct rpc_clnt *old,
 920				      const struct rpc_program *program,
 921				      u32 vers)
 922{
 923	struct rpc_create_args args = {
 924		.program	= program,
 925		.prognumber	= program->number,
 926		.version	= vers,
 927		.authflavor	= old->cl_auth->au_flavor,
 
 928	};
 929	struct rpc_clnt *clnt;
 930	int err;
 931
 932	clnt = __rpc_clone_client(&args, old);
 933	if (IS_ERR(clnt))
 934		goto out;
 935	err = rpc_ping(clnt);
 936	if (err != 0) {
 937		rpc_shutdown_client(clnt);
 938		clnt = ERR_PTR(err);
 939	}
 940out:
 941	return clnt;
 942}
 943EXPORT_SYMBOL_GPL(rpc_bind_new_program);
 944
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 945void rpc_task_release_client(struct rpc_task *task)
 946{
 947	struct rpc_clnt *clnt = task->tk_client;
 948	struct rpc_xprt *xprt = task->tk_xprt;
 949
 
 950	if (clnt != NULL) {
 951		/* Remove from client task list */
 952		spin_lock(&clnt->cl_lock);
 953		list_del(&task->tk_task);
 954		spin_unlock(&clnt->cl_lock);
 955		task->tk_client = NULL;
 956
 957		rpc_release_client(clnt);
 958	}
 
 959
 960	if (xprt != NULL) {
 961		task->tk_xprt = NULL;
 
 
 962
 963		xprt_put(xprt);
 964	}
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 965}
 966
 967static
 968void rpc_task_set_client(struct rpc_task *task, struct rpc_clnt *clnt)
 969{
 970
 971	if (clnt != NULL) {
 972		rpc_task_release_client(task);
 973		if (task->tk_xprt == NULL)
 974			task->tk_xprt = xprt_iter_get_next(&clnt->cl_xpi);
 975		task->tk_client = clnt;
 976		atomic_inc(&clnt->cl_count);
 977		if (clnt->cl_softrtry)
 978			task->tk_flags |= RPC_TASK_SOFT;
 
 
 979		if (clnt->cl_noretranstimeo)
 980			task->tk_flags |= RPC_TASK_NO_RETRANS_TIMEOUT;
 981		if (atomic_read(&clnt->cl_swapper))
 982			task->tk_flags |= RPC_TASK_SWAPPER;
 983		/* Add to the client's list of all tasks */
 984		spin_lock(&clnt->cl_lock);
 985		list_add_tail(&task->tk_task, &clnt->cl_tasks);
 986		spin_unlock(&clnt->cl_lock);
 987	}
 988}
 989
 990static void
 991rpc_task_set_rpc_message(struct rpc_task *task, const struct rpc_message *msg)
 992{
 993	if (msg != NULL) {
 994		task->tk_msg.rpc_proc = msg->rpc_proc;
 995		task->tk_msg.rpc_argp = msg->rpc_argp;
 996		task->tk_msg.rpc_resp = msg->rpc_resp;
 997		if (msg->rpc_cred != NULL)
 998			task->tk_msg.rpc_cred = get_rpccred(msg->rpc_cred);
 999	}
1000}
1001
1002/*
1003 * Default callback for async RPC calls
1004 */
1005static void
1006rpc_default_callback(struct rpc_task *task, void *data)
1007{
1008}
1009
1010static const struct rpc_call_ops rpc_default_ops = {
1011	.rpc_call_done = rpc_default_callback,
1012};
1013
1014/**
1015 * rpc_run_task - Allocate a new RPC task, then run rpc_execute against it
1016 * @task_setup_data: pointer to task initialisation data
1017 */
1018struct rpc_task *rpc_run_task(const struct rpc_task_setup *task_setup_data)
1019{
1020	struct rpc_task *task;
1021
1022	task = rpc_new_task(task_setup_data);
1023	if (IS_ERR(task))
1024		goto out;
1025
1026	rpc_task_set_client(task, task_setup_data->rpc_client);
1027	rpc_task_set_rpc_message(task, task_setup_data->rpc_message);
1028
1029	if (task->tk_action == NULL)
1030		rpc_call_start(task);
1031
1032	atomic_inc(&task->tk_count);
1033	rpc_execute(task);
1034out:
1035	return task;
1036}
1037EXPORT_SYMBOL_GPL(rpc_run_task);
1038
1039/**
1040 * rpc_call_sync - Perform a synchronous RPC call
1041 * @clnt: pointer to RPC client
1042 * @msg: RPC call parameters
1043 * @flags: RPC call flags
1044 */
1045int rpc_call_sync(struct rpc_clnt *clnt, const struct rpc_message *msg, int flags)
1046{
1047	struct rpc_task	*task;
1048	struct rpc_task_setup task_setup_data = {
1049		.rpc_client = clnt,
1050		.rpc_message = msg,
1051		.callback_ops = &rpc_default_ops,
1052		.flags = flags,
1053	};
1054	int status;
1055
1056	WARN_ON_ONCE(flags & RPC_TASK_ASYNC);
1057	if (flags & RPC_TASK_ASYNC) {
1058		rpc_release_calldata(task_setup_data.callback_ops,
1059			task_setup_data.callback_data);
1060		return -EINVAL;
1061	}
1062
1063	task = rpc_run_task(&task_setup_data);
1064	if (IS_ERR(task))
1065		return PTR_ERR(task);
1066	status = task->tk_status;
1067	rpc_put_task(task);
1068	return status;
1069}
1070EXPORT_SYMBOL_GPL(rpc_call_sync);
1071
1072/**
1073 * rpc_call_async - Perform an asynchronous RPC call
1074 * @clnt: pointer to RPC client
1075 * @msg: RPC call parameters
1076 * @flags: RPC call flags
1077 * @tk_ops: RPC call ops
1078 * @data: user call data
1079 */
1080int
1081rpc_call_async(struct rpc_clnt *clnt, const struct rpc_message *msg, int flags,
1082	       const struct rpc_call_ops *tk_ops, void *data)
1083{
1084	struct rpc_task	*task;
1085	struct rpc_task_setup task_setup_data = {
1086		.rpc_client = clnt,
1087		.rpc_message = msg,
1088		.callback_ops = tk_ops,
1089		.callback_data = data,
1090		.flags = flags|RPC_TASK_ASYNC,
1091	};
1092
1093	task = rpc_run_task(&task_setup_data);
1094	if (IS_ERR(task))
1095		return PTR_ERR(task);
1096	rpc_put_task(task);
1097	return 0;
1098}
1099EXPORT_SYMBOL_GPL(rpc_call_async);
1100
1101#if defined(CONFIG_SUNRPC_BACKCHANNEL)
 
 
1102/**
1103 * rpc_run_bc_task - Allocate a new RPC task for backchannel use, then run
1104 * rpc_execute against it
1105 * @req: RPC request
1106 */
1107struct rpc_task *rpc_run_bc_task(struct rpc_rqst *req)
1108{
1109	struct rpc_task *task;
1110	struct xdr_buf *xbufp = &req->rq_snd_buf;
1111	struct rpc_task_setup task_setup_data = {
1112		.callback_ops = &rpc_default_ops,
1113		.flags = RPC_TASK_SOFTCONN,
 
1114	};
1115
1116	dprintk("RPC: rpc_run_bc_task req= %p\n", req);
1117	/*
1118	 * Create an rpc_task to send the data
1119	 */
1120	task = rpc_new_task(&task_setup_data);
1121	if (IS_ERR(task)) {
1122		xprt_free_bc_request(req);
1123		goto out;
1124	}
1125	task->tk_rqstp = req;
1126
1127	/*
1128	 * Set up the xdr_buf length.
1129	 * This also indicates that the buffer is XDR encoded already.
1130	 */
1131	xbufp->len = xbufp->head[0].iov_len + xbufp->page_len +
1132			xbufp->tail[0].iov_len;
1133
1134	task->tk_action = call_bc_transmit;
1135	atomic_inc(&task->tk_count);
1136	WARN_ON_ONCE(atomic_read(&task->tk_count) != 2);
1137	rpc_execute(task);
1138
1139out:
1140	dprintk("RPC: rpc_run_bc_task: task= %p\n", task);
1141	return task;
1142}
1143#endif /* CONFIG_SUNRPC_BACKCHANNEL */
1144
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1145void
1146rpc_call_start(struct rpc_task *task)
1147{
1148	task->tk_action = call_start;
1149}
1150EXPORT_SYMBOL_GPL(rpc_call_start);
1151
1152/**
1153 * rpc_peeraddr - extract remote peer address from clnt's xprt
1154 * @clnt: RPC client structure
1155 * @buf: target buffer
1156 * @bufsize: length of target buffer
1157 *
1158 * Returns the number of bytes that are actually in the stored address.
1159 */
1160size_t rpc_peeraddr(struct rpc_clnt *clnt, struct sockaddr *buf, size_t bufsize)
1161{
1162	size_t bytes;
1163	struct rpc_xprt *xprt;
1164
1165	rcu_read_lock();
1166	xprt = rcu_dereference(clnt->cl_xprt);
1167
1168	bytes = xprt->addrlen;
1169	if (bytes > bufsize)
1170		bytes = bufsize;
1171	memcpy(buf, &xprt->addr, bytes);
1172	rcu_read_unlock();
1173
1174	return bytes;
1175}
1176EXPORT_SYMBOL_GPL(rpc_peeraddr);
1177
1178/**
1179 * rpc_peeraddr2str - return remote peer address in printable format
1180 * @clnt: RPC client structure
1181 * @format: address format
1182 *
1183 * NB: the lifetime of the memory referenced by the returned pointer is
1184 * the same as the rpc_xprt itself.  As long as the caller uses this
1185 * pointer, it must hold the RCU read lock.
1186 */
1187const char *rpc_peeraddr2str(struct rpc_clnt *clnt,
1188			     enum rpc_display_format_t format)
1189{
1190	struct rpc_xprt *xprt;
1191
1192	xprt = rcu_dereference(clnt->cl_xprt);
1193
1194	if (xprt->address_strings[format] != NULL)
1195		return xprt->address_strings[format];
1196	else
1197		return "unprintable";
1198}
1199EXPORT_SYMBOL_GPL(rpc_peeraddr2str);
1200
1201static const struct sockaddr_in rpc_inaddr_loopback = {
1202	.sin_family		= AF_INET,
1203	.sin_addr.s_addr	= htonl(INADDR_ANY),
1204};
1205
1206static const struct sockaddr_in6 rpc_in6addr_loopback = {
1207	.sin6_family		= AF_INET6,
1208	.sin6_addr		= IN6ADDR_ANY_INIT,
1209};
1210
1211/*
1212 * Try a getsockname() on a connected datagram socket.  Using a
1213 * connected datagram socket prevents leaving a socket in TIME_WAIT.
1214 * This conserves the ephemeral port number space.
1215 *
1216 * Returns zero and fills in "buf" if successful; otherwise, a
1217 * negative errno is returned.
1218 */
1219static int rpc_sockname(struct net *net, struct sockaddr *sap, size_t salen,
1220			struct sockaddr *buf, int buflen)
1221{
1222	struct socket *sock;
1223	int err;
1224
1225	err = __sock_create(net, sap->sa_family,
1226				SOCK_DGRAM, IPPROTO_UDP, &sock, 1);
1227	if (err < 0) {
1228		dprintk("RPC:       can't create UDP socket (%d)\n", err);
1229		goto out;
1230	}
1231
1232	switch (sap->sa_family) {
1233	case AF_INET:
1234		err = kernel_bind(sock,
1235				(struct sockaddr *)&rpc_inaddr_loopback,
1236				sizeof(rpc_inaddr_loopback));
1237		break;
1238	case AF_INET6:
1239		err = kernel_bind(sock,
1240				(struct sockaddr *)&rpc_in6addr_loopback,
1241				sizeof(rpc_in6addr_loopback));
1242		break;
1243	default:
1244		err = -EAFNOSUPPORT;
1245		goto out;
1246	}
1247	if (err < 0) {
1248		dprintk("RPC:       can't bind UDP socket (%d)\n", err);
1249		goto out_release;
1250	}
1251
1252	err = kernel_connect(sock, sap, salen, 0);
1253	if (err < 0) {
1254		dprintk("RPC:       can't connect UDP socket (%d)\n", err);
1255		goto out_release;
1256	}
1257
1258	err = kernel_getsockname(sock, buf, &buflen);
1259	if (err < 0) {
1260		dprintk("RPC:       getsockname failed (%d)\n", err);
1261		goto out_release;
1262	}
1263
1264	err = 0;
1265	if (buf->sa_family == AF_INET6) {
1266		struct sockaddr_in6 *sin6 = (struct sockaddr_in6 *)buf;
1267		sin6->sin6_scope_id = 0;
1268	}
1269	dprintk("RPC:       %s succeeded\n", __func__);
1270
1271out_release:
1272	sock_release(sock);
1273out:
1274	return err;
1275}
1276
1277/*
1278 * Scraping a connected socket failed, so we don't have a useable
1279 * local address.  Fallback: generate an address that will prevent
1280 * the server from calling us back.
1281 *
1282 * Returns zero and fills in "buf" if successful; otherwise, a
1283 * negative errno is returned.
1284 */
1285static int rpc_anyaddr(int family, struct sockaddr *buf, size_t buflen)
1286{
1287	switch (family) {
1288	case AF_INET:
1289		if (buflen < sizeof(rpc_inaddr_loopback))
1290			return -EINVAL;
1291		memcpy(buf, &rpc_inaddr_loopback,
1292				sizeof(rpc_inaddr_loopback));
1293		break;
1294	case AF_INET6:
1295		if (buflen < sizeof(rpc_in6addr_loopback))
1296			return -EINVAL;
1297		memcpy(buf, &rpc_in6addr_loopback,
1298				sizeof(rpc_in6addr_loopback));
1299		break;
1300	default:
1301		dprintk("RPC:       %s: address family not supported\n",
1302			__func__);
1303		return -EAFNOSUPPORT;
1304	}
1305	dprintk("RPC:       %s: succeeded\n", __func__);
1306	return 0;
1307}
1308
1309/**
1310 * rpc_localaddr - discover local endpoint address for an RPC client
1311 * @clnt: RPC client structure
1312 * @buf: target buffer
1313 * @buflen: size of target buffer, in bytes
1314 *
1315 * Returns zero and fills in "buf" and "buflen" if successful;
1316 * otherwise, a negative errno is returned.
1317 *
1318 * This works even if the underlying transport is not currently connected,
1319 * or if the upper layer never previously provided a source address.
1320 *
1321 * The result of this function call is transient: multiple calls in
1322 * succession may give different results, depending on how local
1323 * networking configuration changes over time.
1324 */
1325int rpc_localaddr(struct rpc_clnt *clnt, struct sockaddr *buf, size_t buflen)
1326{
1327	struct sockaddr_storage address;
1328	struct sockaddr *sap = (struct sockaddr *)&address;
1329	struct rpc_xprt *xprt;
1330	struct net *net;
1331	size_t salen;
1332	int err;
1333
1334	rcu_read_lock();
1335	xprt = rcu_dereference(clnt->cl_xprt);
1336	salen = xprt->addrlen;
1337	memcpy(sap, &xprt->addr, salen);
1338	net = get_net(xprt->xprt_net);
1339	rcu_read_unlock();
1340
1341	rpc_set_port(sap, 0);
1342	err = rpc_sockname(net, sap, salen, buf, buflen);
1343	put_net(net);
1344	if (err != 0)
1345		/* Couldn't discover local address, return ANYADDR */
1346		return rpc_anyaddr(sap->sa_family, buf, buflen);
1347	return 0;
1348}
1349EXPORT_SYMBOL_GPL(rpc_localaddr);
1350
1351void
1352rpc_setbufsize(struct rpc_clnt *clnt, unsigned int sndsize, unsigned int rcvsize)
1353{
1354	struct rpc_xprt *xprt;
1355
1356	rcu_read_lock();
1357	xprt = rcu_dereference(clnt->cl_xprt);
1358	if (xprt->ops->set_buffer_size)
1359		xprt->ops->set_buffer_size(xprt, sndsize, rcvsize);
1360	rcu_read_unlock();
1361}
1362EXPORT_SYMBOL_GPL(rpc_setbufsize);
1363
1364/**
1365 * rpc_protocol - Get transport protocol number for an RPC client
1366 * @clnt: RPC client to query
1367 *
1368 */
1369int rpc_protocol(struct rpc_clnt *clnt)
1370{
1371	int protocol;
1372
1373	rcu_read_lock();
1374	protocol = rcu_dereference(clnt->cl_xprt)->prot;
1375	rcu_read_unlock();
1376	return protocol;
1377}
1378EXPORT_SYMBOL_GPL(rpc_protocol);
1379
1380/**
1381 * rpc_net_ns - Get the network namespace for this RPC client
1382 * @clnt: RPC client to query
1383 *
1384 */
1385struct net *rpc_net_ns(struct rpc_clnt *clnt)
1386{
1387	struct net *ret;
1388
1389	rcu_read_lock();
1390	ret = rcu_dereference(clnt->cl_xprt)->xprt_net;
1391	rcu_read_unlock();
1392	return ret;
1393}
1394EXPORT_SYMBOL_GPL(rpc_net_ns);
1395
1396/**
1397 * rpc_max_payload - Get maximum payload size for a transport, in bytes
1398 * @clnt: RPC client to query
1399 *
1400 * For stream transports, this is one RPC record fragment (see RFC
1401 * 1831), as we don't support multi-record requests yet.  For datagram
1402 * transports, this is the size of an IP packet minus the IP, UDP, and
1403 * RPC header sizes.
1404 */
1405size_t rpc_max_payload(struct rpc_clnt *clnt)
1406{
1407	size_t ret;
1408
1409	rcu_read_lock();
1410	ret = rcu_dereference(clnt->cl_xprt)->max_payload;
1411	rcu_read_unlock();
1412	return ret;
1413}
1414EXPORT_SYMBOL_GPL(rpc_max_payload);
1415
1416/**
1417 * rpc_get_timeout - Get timeout for transport in units of HZ
1418 * @clnt: RPC client to query
1419 */
1420unsigned long rpc_get_timeout(struct rpc_clnt *clnt)
 
 
 
 
 
 
 
 
 
 
 
 
 
1421{
1422	unsigned long ret;
 
1423
1424	rcu_read_lock();
1425	ret = rcu_dereference(clnt->cl_xprt)->timeout->to_initval;
 
1426	rcu_read_unlock();
1427	return ret;
1428}
1429EXPORT_SYMBOL_GPL(rpc_get_timeout);
1430
1431/**
1432 * rpc_force_rebind - force transport to check that remote port is unchanged
1433 * @clnt: client to rebind
1434 *
1435 */
1436void rpc_force_rebind(struct rpc_clnt *clnt)
1437{
1438	if (clnt->cl_autobind) {
1439		rcu_read_lock();
1440		xprt_clear_bound(rcu_dereference(clnt->cl_xprt));
1441		rcu_read_unlock();
1442	}
1443}
1444EXPORT_SYMBOL_GPL(rpc_force_rebind);
1445
1446/*
1447 * Restart an (async) RPC call from the call_prepare state.
1448 * Usually called from within the exit handler.
1449 */
1450int
1451rpc_restart_call_prepare(struct rpc_task *task)
1452{
1453	if (RPC_ASSASSINATED(task))
1454		return 0;
1455	task->tk_action = call_start;
1456	task->tk_status = 0;
1457	if (task->tk_ops->rpc_call_prepare != NULL)
1458		task->tk_action = rpc_prepare_task;
1459	return 1;
1460}
1461EXPORT_SYMBOL_GPL(rpc_restart_call_prepare);
1462
1463/*
1464 * Restart an (async) RPC call. Usually called from within the
1465 * exit handler.
1466 */
1467int
1468rpc_restart_call(struct rpc_task *task)
1469{
1470	if (RPC_ASSASSINATED(task))
1471		return 0;
1472	task->tk_action = call_start;
1473	task->tk_status = 0;
1474	return 1;
1475}
1476EXPORT_SYMBOL_GPL(rpc_restart_call);
1477
1478#if IS_ENABLED(CONFIG_SUNRPC_DEBUG)
 
 
 
 
 
 
 
 
 
 
 
 
1479const char
1480*rpc_proc_name(const struct rpc_task *task)
1481{
1482	const struct rpc_procinfo *proc = task->tk_msg.rpc_proc;
1483
1484	if (proc) {
1485		if (proc->p_name)
1486			return proc->p_name;
1487		else
1488			return "NULL";
1489	} else
1490		return "no proc";
1491}
1492#endif
 
 
 
 
 
 
 
 
 
 
 
 
1493
1494/*
1495 * 0.  Initial state
1496 *
1497 *     Other FSM states can be visited zero or more times, but
1498 *     this state is visited exactly once for each RPC.
1499 */
1500static void
1501call_start(struct rpc_task *task)
1502{
1503	struct rpc_clnt	*clnt = task->tk_client;
 
1504
 
1505	dprintk("RPC: %5u call_start %s%d proc %s (%s)\n", task->tk_pid,
1506			clnt->cl_program->name, clnt->cl_vers,
1507			rpc_proc_name(task),
1508			(RPC_IS_ASYNC(task) ? "async" : "sync"));
1509
1510	/* Increment call count */
1511	task->tk_msg.rpc_proc->p_count++;
 
1512	clnt->cl_stats->rpccnt++;
1513	task->tk_action = call_reserve;
 
1514}
1515
1516/*
1517 * 1.	Reserve an RPC call slot
1518 */
1519static void
1520call_reserve(struct rpc_task *task)
1521{
1522	dprint_status(task);
1523
1524	task->tk_status  = 0;
1525	task->tk_action  = call_reserveresult;
1526	xprt_reserve(task);
1527}
1528
1529static void call_retry_reserve(struct rpc_task *task);
1530
1531/*
1532 * 1b.	Grok the result of xprt_reserve()
1533 */
1534static void
1535call_reserveresult(struct rpc_task *task)
1536{
1537	int status = task->tk_status;
1538
1539	dprint_status(task);
1540
1541	/*
1542	 * After a call to xprt_reserve(), we must have either
1543	 * a request slot or else an error status.
1544	 */
1545	task->tk_status = 0;
1546	if (status >= 0) {
1547		if (task->tk_rqstp) {
1548			task->tk_action = call_refresh;
1549			return;
1550		}
1551
1552		printk(KERN_ERR "%s: status=%d, but no request slot, exiting\n",
1553				__func__, status);
1554		rpc_exit(task, -EIO);
1555		return;
1556	}
1557
1558	/*
1559	 * Even though there was an error, we may have acquired
1560	 * a request slot somehow.  Make sure not to leak it.
1561	 */
1562	if (task->tk_rqstp) {
1563		printk(KERN_ERR "%s: status=%d, request allocated anyway\n",
1564				__func__, status);
1565		xprt_release(task);
1566	}
1567
1568	switch (status) {
1569	case -ENOMEM:
1570		rpc_delay(task, HZ >> 2);
 
1571	case -EAGAIN:	/* woken up; retry */
1572		task->tk_action = call_retry_reserve;
1573		return;
1574	case -EIO:	/* probably a shutdown */
1575		break;
1576	default:
1577		printk(KERN_ERR "%s: unrecognized error %d, exiting\n",
1578				__func__, status);
1579		break;
1580	}
1581	rpc_exit(task, status);
1582}
1583
1584/*
1585 * 1c.	Retry reserving an RPC call slot
1586 */
1587static void
1588call_retry_reserve(struct rpc_task *task)
1589{
1590	dprint_status(task);
1591
1592	task->tk_status  = 0;
1593	task->tk_action  = call_reserveresult;
1594	xprt_retry_reserve(task);
1595}
1596
1597/*
1598 * 2.	Bind and/or refresh the credentials
1599 */
1600static void
1601call_refresh(struct rpc_task *task)
1602{
1603	dprint_status(task);
1604
1605	task->tk_action = call_refreshresult;
1606	task->tk_status = 0;
1607	task->tk_client->cl_stats->rpcauthrefresh++;
1608	rpcauth_refreshcred(task);
1609}
1610
1611/*
1612 * 2a.	Process the results of a credential refresh
1613 */
1614static void
1615call_refreshresult(struct rpc_task *task)
1616{
1617	int status = task->tk_status;
1618
1619	dprint_status(task);
1620
1621	task->tk_status = 0;
1622	task->tk_action = call_refresh;
1623	switch (status) {
1624	case 0:
1625		if (rpcauth_uptodatecred(task)) {
1626			task->tk_action = call_allocate;
1627			return;
1628		}
1629		/* Use rate-limiting and a max number of retries if refresh
1630		 * had status 0 but failed to update the cred.
1631		 */
 
1632	case -ETIMEDOUT:
1633		rpc_delay(task, 3*HZ);
 
1634	case -EAGAIN:
1635		status = -EACCES;
 
1636	case -EKEYEXPIRED:
1637		if (!task->tk_cred_retry)
1638			break;
1639		task->tk_cred_retry--;
1640		dprintk("RPC: %5u %s: retry refresh creds\n",
1641				task->tk_pid, __func__);
1642		return;
1643	}
1644	dprintk("RPC: %5u %s: refresh creds failed with error %d\n",
1645				task->tk_pid, __func__, status);
1646	rpc_exit(task, status);
1647}
1648
1649/*
1650 * 2b.	Allocate the buffer. For details, see sched.c:rpc_malloc.
1651 *	(Note: buffer memory is freed in xprt_release).
1652 */
1653static void
1654call_allocate(struct rpc_task *task)
1655{
1656	unsigned int slack = task->tk_rqstp->rq_cred->cr_auth->au_cslack;
1657	struct rpc_rqst *req = task->tk_rqstp;
1658	struct rpc_xprt *xprt = req->rq_xprt;
1659	struct rpc_procinfo *proc = task->tk_msg.rpc_proc;
 
1660
1661	dprint_status(task);
1662
1663	task->tk_status = 0;
1664	task->tk_action = call_bind;
1665
1666	if (req->rq_buffer)
1667		return;
1668
1669	if (proc->p_proc != 0) {
1670		BUG_ON(proc->p_arglen == 0);
1671		if (proc->p_decode != NULL)
1672			BUG_ON(proc->p_replen == 0);
1673	}
1674
1675	/*
1676	 * Calculate the size (in quads) of the RPC call
1677	 * and reply headers, and convert both values
1678	 * to byte sizes.
1679	 */
1680	req->rq_callsize = RPC_CALLHDRSIZE + (slack << 1) + proc->p_arglen;
 
1681	req->rq_callsize <<= 2;
1682	req->rq_rcvsize = RPC_REPHDRSIZE + slack + proc->p_replen;
 
 
 
 
 
1683	req->rq_rcvsize <<= 2;
1684
1685	req->rq_buffer = xprt->ops->buf_alloc(task,
1686					req->rq_callsize + req->rq_rcvsize);
1687	if (req->rq_buffer != NULL)
1688		return;
1689	xprt_inject_disconnect(xprt);
 
 
 
 
 
 
1690
1691	dprintk("RPC: %5u rpc_buffer allocation failed\n", task->tk_pid);
1692
1693	if (RPC_IS_ASYNC(task) || !fatal_signal_pending(current)) {
1694		task->tk_action = call_allocate;
1695		rpc_delay(task, HZ>>4);
1696		return;
1697	}
1698
1699	rpc_exit(task, -ERESTARTSYS);
1700}
1701
1702static inline int
1703rpc_task_need_encode(struct rpc_task *task)
1704{
1705	return task->tk_rqstp->rq_snd_buf.len == 0;
 
 
 
1706}
1707
1708static inline void
1709rpc_task_force_reencode(struct rpc_task *task)
1710{
1711	task->tk_rqstp->rq_snd_buf.len = 0;
1712	task->tk_rqstp->rq_bytes_sent = 0;
1713}
1714
1715static inline void
1716rpc_xdr_buf_init(struct xdr_buf *buf, void *start, size_t len)
1717{
1718	buf->head[0].iov_base = start;
1719	buf->head[0].iov_len = len;
1720	buf->tail[0].iov_len = 0;
1721	buf->page_len = 0;
1722	buf->flags = 0;
1723	buf->len = 0;
1724	buf->buflen = len;
 
 
 
 
 
 
1725}
1726
1727/*
1728 * 3.	Encode arguments of an RPC call
1729 */
1730static void
1731rpc_xdr_encode(struct rpc_task *task)
1732{
1733	struct rpc_rqst	*req = task->tk_rqstp;
1734	kxdreproc_t	encode;
1735	__be32		*p;
1736
1737	dprint_status(task);
1738
1739	rpc_xdr_buf_init(&req->rq_snd_buf,
1740			 req->rq_buffer,
1741			 req->rq_callsize);
1742	rpc_xdr_buf_init(&req->rq_rcv_buf,
1743			 (char *)req->rq_buffer + req->rq_callsize,
1744			 req->rq_rcvsize);
1745
1746	p = rpc_encode_header(task);
1747	if (p == NULL) {
1748		printk(KERN_INFO "RPC: couldn't encode RPC header, exit EIO\n");
1749		rpc_exit(task, -EIO);
 
 
 
 
 
 
 
 
 
 
 
 
 
1750		return;
1751	}
1752
1753	encode = task->tk_msg.rpc_proc->p_encode;
1754	if (encode == NULL)
1755		return;
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1756
1757	task->tk_status = rpcauth_wrap_req(task, encode, req, p,
1758			task->tk_msg.rpc_argp);
 
 
 
1759}
1760
1761/*
1762 * 4.	Get the server port number if not yet set
1763 */
1764static void
1765call_bind(struct rpc_task *task)
1766{
1767	struct rpc_xprt *xprt = task->tk_rqstp->rq_xprt;
1768
1769	dprint_status(task);
 
 
 
1770
1771	task->tk_action = call_connect;
1772	if (!xprt_bound(xprt)) {
1773		task->tk_action = call_bind_status;
1774		task->tk_timeout = xprt->bind_timeout;
1775		xprt->ops->rpcbind(task);
1776	}
 
 
 
 
 
 
 
 
1777}
1778
1779/*
1780 * 4a.	Sort out bind result
1781 */
1782static void
1783call_bind_status(struct rpc_task *task)
1784{
 
1785	int status = -EIO;
1786
1787	if (task->tk_status >= 0) {
1788		dprint_status(task);
1789		task->tk_status = 0;
1790		task->tk_action = call_connect;
1791		return;
1792	}
1793
 
1794	trace_rpc_bind_status(task);
 
 
 
 
 
 
 
1795	switch (task->tk_status) {
1796	case -ENOMEM:
1797		dprintk("RPC: %5u rpcbind out of memory\n", task->tk_pid);
1798		rpc_delay(task, HZ >> 2);
1799		goto retry_timeout;
1800	case -EACCES:
1801		dprintk("RPC: %5u remote rpcbind: RPC program/version "
1802				"unavailable\n", task->tk_pid);
1803		/* fail immediately if this is an RPC ping */
1804		if (task->tk_msg.rpc_proc->p_proc == 0) {
1805			status = -EOPNOTSUPP;
1806			break;
1807		}
1808		if (task->tk_rebind_retry == 0)
1809			break;
1810		task->tk_rebind_retry--;
1811		rpc_delay(task, 3*HZ);
1812		goto retry_timeout;
 
 
 
 
 
1813	case -ETIMEDOUT:
1814		dprintk("RPC: %5u rpcbind request timed out\n",
1815				task->tk_pid);
1816		goto retry_timeout;
1817	case -EPFNOSUPPORT:
1818		/* server doesn't support any rpcbind version we know of */
1819		dprintk("RPC: %5u unrecognized remote rpcbind service\n",
1820				task->tk_pid);
1821		break;
1822	case -EPROTONOSUPPORT:
1823		dprintk("RPC: %5u remote rpcbind version unavailable, retrying\n",
1824				task->tk_pid);
1825		goto retry_timeout;
1826	case -ECONNREFUSED:		/* connection problems */
1827	case -ECONNRESET:
1828	case -ECONNABORTED:
1829	case -ENOTCONN:
1830	case -EHOSTDOWN:
 
1831	case -EHOSTUNREACH:
1832	case -ENETUNREACH:
1833	case -ENOBUFS:
1834	case -EPIPE:
1835		dprintk("RPC: %5u remote rpcbind unreachable: %d\n",
1836				task->tk_pid, task->tk_status);
1837		if (!RPC_IS_SOFTCONN(task)) {
1838			rpc_delay(task, 5*HZ);
1839			goto retry_timeout;
1840		}
1841		status = task->tk_status;
1842		break;
1843	default:
1844		dprintk("RPC: %5u unrecognized rpcbind error (%d)\n",
1845				task->tk_pid, -task->tk_status);
1846	}
1847
1848	rpc_exit(task, status);
 
 
 
1849	return;
1850
1851retry_timeout:
1852	task->tk_status = 0;
1853	task->tk_action = call_timeout;
 
1854}
1855
1856/*
1857 * 4b.	Connect to the RPC server
1858 */
1859static void
1860call_connect(struct rpc_task *task)
1861{
1862	struct rpc_xprt *xprt = task->tk_rqstp->rq_xprt;
1863
 
 
 
 
 
 
 
 
 
 
1864	dprintk("RPC: %5u call_connect xprt %p %s connected\n",
1865			task->tk_pid, xprt,
1866			(xprt_connected(xprt) ? "is" : "is not"));
1867
1868	task->tk_action = call_transmit;
1869	if (!xprt_connected(xprt)) {
1870		task->tk_action = call_connect_status;
1871		if (task->tk_status < 0)
1872			return;
1873		if (task->tk_flags & RPC_TASK_NOCONNECT) {
1874			rpc_exit(task, -ENOTCONN);
1875			return;
1876		}
1877		xprt_connect(task);
1878	}
 
 
 
1879}
1880
1881/*
1882 * 4c.	Sort out connect result
1883 */
1884static void
1885call_connect_status(struct rpc_task *task)
1886{
 
1887	struct rpc_clnt *clnt = task->tk_client;
1888	int status = task->tk_status;
1889
 
 
 
 
 
1890	dprint_status(task);
 
 
 
 
 
 
 
 
 
 
1891
1892	trace_rpc_connect_status(task, status);
1893	task->tk_status = 0;
1894	switch (status) {
1895	case -ECONNREFUSED:
 
 
 
 
 
 
 
 
1896	case -ECONNRESET:
1897	case -ECONNABORTED:
 
1898	case -ENETUNREACH:
1899	case -EHOSTUNREACH:
1900	case -EADDRINUSE:
1901	case -ENOBUFS:
1902	case -EPIPE:
 
 
1903		if (RPC_IS_SOFTCONN(task))
1904			break;
1905		/* retry with existing socket, after a delay */
1906		rpc_delay(task, 3*HZ);
 
 
 
1907	case -EAGAIN:
1908		/* Check for timeouts before looping back to call_bind */
1909	case -ETIMEDOUT:
1910		task->tk_action = call_timeout;
1911		return;
1912	case 0:
1913		clnt->cl_stats->netreconn++;
1914		task->tk_action = call_transmit;
1915		return;
1916	}
1917	rpc_exit(task, status);
 
 
 
 
 
 
 
 
1918}
1919
1920/*
1921 * 5.	Transmit the RPC request, and wait for reply
1922 */
1923static void
1924call_transmit(struct rpc_task *task)
1925{
1926	int is_retrans = RPC_WAS_SENT(task);
 
 
 
1927
1928	dprint_status(task);
1929
1930	task->tk_action = call_status;
1931	if (task->tk_status < 0)
1932		return;
1933	if (!xprt_prepare_transmit(task))
1934		return;
1935	task->tk_action = call_transmit_status;
1936	/* Encode here so that rpcsec_gss can use correct sequence number. */
1937	if (rpc_task_need_encode(task)) {
1938		rpc_xdr_encode(task);
1939		/* Did the encode result in an error condition? */
1940		if (task->tk_status != 0) {
1941			/* Was the error nonfatal? */
1942			if (task->tk_status == -EAGAIN)
1943				rpc_delay(task, HZ >> 4);
1944			else
1945				rpc_exit(task, task->tk_status);
1946			return;
1947		}
 
1948	}
1949	xprt_transmit(task);
1950	if (task->tk_status < 0)
1951		return;
1952	if (is_retrans)
1953		task->tk_client->cl_stats->rpcretrans++;
1954	/*
1955	 * On success, ensure that we call xprt_end_transmit() before sleeping
1956	 * in order to allow access to the socket to other RPC requests.
1957	 */
1958	call_transmit_status(task);
1959	if (rpc_reply_expected(task))
1960		return;
1961	task->tk_action = rpc_exit_task;
1962	rpc_wake_up_queued_task(&task->tk_rqstp->rq_xprt->pending, task);
1963}
1964
1965/*
1966 * 5a.	Handle cleanup after a transmission
1967 */
1968static void
1969call_transmit_status(struct rpc_task *task)
1970{
1971	task->tk_action = call_status;
1972
1973	/*
1974	 * Common case: success.  Force the compiler to put this
1975	 * test first.
1976	 */
1977	if (task->tk_status == 0) {
1978		xprt_end_transmit(task);
1979		rpc_task_force_reencode(task);
1980		return;
1981	}
1982
1983	switch (task->tk_status) {
1984	case -EAGAIN:
1985	case -ENOBUFS:
1986		break;
1987	default:
1988		dprint_status(task);
1989		xprt_end_transmit(task);
1990		rpc_task_force_reencode(task);
 
 
1991		break;
1992		/*
1993		 * Special cases: if we've been waiting on the
1994		 * socket's write_space() callback, or if the
1995		 * socket just returned a connection error,
1996		 * then hold onto the transport lock.
1997		 */
 
 
 
 
 
 
 
 
1998	case -ECONNREFUSED:
1999	case -EHOSTDOWN:
 
2000	case -EHOSTUNREACH:
2001	case -ENETUNREACH:
2002	case -EPERM:
2003		if (RPC_IS_SOFTCONN(task)) {
2004			xprt_end_transmit(task);
2005			rpc_exit(task, task->tk_status);
2006			break;
 
 
2007		}
 
2008	case -ECONNRESET:
2009	case -ECONNABORTED:
2010	case -EADDRINUSE:
2011	case -ENOTCONN:
2012	case -EPIPE:
2013		rpc_task_force_reencode(task);
 
 
2014	}
 
2015}
2016
2017#if defined(CONFIG_SUNRPC_BACKCHANNEL)
 
 
 
 
 
 
 
 
 
 
2018/*
2019 * 5b.	Send the backchannel RPC reply.  On error, drop the reply.  In
2020 * addition, disconnect on connectivity errors.
2021 */
2022static void
2023call_bc_transmit(struct rpc_task *task)
2024{
2025	struct rpc_rqst *req = task->tk_rqstp;
2026
2027	if (!xprt_prepare_transmit(task))
2028		goto out_retry;
2029
2030	if (task->tk_status < 0) {
2031		printk(KERN_NOTICE "RPC: Could not send backchannel reply "
2032			"error: %d\n", task->tk_status);
2033		goto out_done;
2034	}
2035	if (req->rq_connect_cookie != req->rq_xprt->connect_cookie)
2036		req->rq_bytes_sent = 0;
2037
2038	xprt_transmit(task);
 
 
 
2039
2040	if (task->tk_status == -EAGAIN)
2041		goto out_nospace;
2042
2043	xprt_end_transmit(task);
2044	dprint_status(task);
 
2045	switch (task->tk_status) {
2046	case 0:
2047		/* Success */
 
2048	case -EHOSTDOWN:
2049	case -EHOSTUNREACH:
2050	case -ENETUNREACH:
2051	case -ECONNRESET:
2052	case -ECONNREFUSED:
2053	case -EADDRINUSE:
2054	case -ENOTCONN:
2055	case -EPIPE:
2056		break;
 
 
 
 
 
 
 
 
2057	case -ETIMEDOUT:
2058		/*
2059		 * Problem reaching the server.  Disconnect and let the
2060		 * forechannel reestablish the connection.  The server will
2061		 * have to retransmit the backchannel request and we'll
2062		 * reprocess it.  Since these ops are idempotent, there's no
2063		 * need to cache our reply at this time.
2064		 */
2065		printk(KERN_NOTICE "RPC: Could not send backchannel reply "
2066			"error: %d\n", task->tk_status);
2067		xprt_conditional_disconnect(req->rq_xprt,
2068			req->rq_connect_cookie);
2069		break;
2070	default:
2071		/*
2072		 * We were unable to reply and will have to drop the
2073		 * request.  The server should reconnect and retransmit.
2074		 */
2075		WARN_ON_ONCE(task->tk_status == -EAGAIN);
2076		printk(KERN_NOTICE "RPC: Could not send backchannel reply "
2077			"error: %d\n", task->tk_status);
2078		break;
2079	}
2080	rpc_wake_up_queued_task(&req->rq_xprt->pending, task);
2081out_done:
2082	task->tk_action = rpc_exit_task;
2083	return;
2084out_nospace:
2085	req->rq_connect_cookie = req->rq_xprt->connect_cookie;
2086out_retry:
2087	task->tk_status = 0;
2088}
2089#endif /* CONFIG_SUNRPC_BACKCHANNEL */
2090
2091/*
2092 * 6.	Sort out the RPC call status
2093 */
2094static void
2095call_status(struct rpc_task *task)
2096{
2097	struct rpc_clnt	*clnt = task->tk_client;
2098	struct rpc_rqst	*req = task->tk_rqstp;
2099	int		status;
2100
2101	if (req->rq_reply_bytes_recvd > 0 && !req->rq_bytes_sent)
2102		task->tk_status = req->rq_reply_bytes_recvd;
2103
2104	dprint_status(task);
2105
2106	status = task->tk_status;
2107	if (status >= 0) {
2108		task->tk_action = call_decode;
2109		return;
2110	}
2111
2112	trace_rpc_call_status(task);
2113	task->tk_status = 0;
2114	switch(status) {
2115	case -EHOSTDOWN:
 
2116	case -EHOSTUNREACH:
2117	case -ENETUNREACH:
2118	case -EPERM:
2119		if (RPC_IS_SOFTCONN(task)) {
2120			rpc_exit(task, status);
2121			break;
2122		}
2123		/*
2124		 * Delay any retries for 3 seconds, then handle as if it
2125		 * were a timeout.
2126		 */
2127		rpc_delay(task, 3*HZ);
 
2128	case -ETIMEDOUT:
2129		task->tk_action = call_timeout;
2130		if (!(task->tk_flags & RPC_TASK_NO_RETRANS_TIMEOUT)
2131		    && task->tk_client->cl_discrtry)
2132			xprt_conditional_disconnect(req->rq_xprt,
2133					req->rq_connect_cookie);
2134		break;
2135	case -ECONNREFUSED:
2136	case -ECONNRESET:
2137	case -ECONNABORTED:
 
2138		rpc_force_rebind(clnt);
 
2139	case -EADDRINUSE:
2140		rpc_delay(task, 3*HZ);
 
2141	case -EPIPE:
2142	case -ENOTCONN:
2143		task->tk_action = call_bind;
2144		break;
2145	case -ENOBUFS:
2146		rpc_delay(task, HZ>>2);
2147	case -EAGAIN:
2148		task->tk_action = call_transmit;
2149		break;
2150	case -EIO:
2151		/* shutdown or soft timeout */
2152		rpc_exit(task, status);
2153		break;
2154	default:
2155		if (clnt->cl_chatty)
2156			printk("%s: RPC call returned error %d\n",
2157			       clnt->cl_program->name, -status);
2158		rpc_exit(task, status);
2159	}
 
 
 
 
 
 
 
 
 
 
 
 
 
 
2160}
2161
2162/*
2163 * 6a.	Handle RPC timeout
2164 * 	We do not release the request slot, so we keep using the
2165 *	same XID for all retransmits.
2166 */
2167static void
2168call_timeout(struct rpc_task *task)
2169{
2170	struct rpc_clnt	*clnt = task->tk_client;
2171
2172	if (xprt_adjust_timeout(task->tk_rqstp) == 0) {
2173		dprintk("RPC: %5u call_timeout (minor)\n", task->tk_pid);
2174		goto retry;
2175	}
2176
2177	dprintk("RPC: %5u call_timeout (major)\n", task->tk_pid);
2178	task->tk_timeouts++;
2179
2180	if (RPC_IS_SOFTCONN(task)) {
2181		rpc_exit(task, -ETIMEDOUT);
2182		return;
2183	}
 
2184	if (RPC_IS_SOFT(task)) {
 
 
 
 
 
 
 
 
 
2185		if (clnt->cl_chatty) {
2186			printk(KERN_NOTICE "%s: server %s not responding, timed out\n",
 
2187				clnt->cl_program->name,
2188				task->tk_xprt->servername);
2189		}
2190		if (task->tk_flags & RPC_TASK_TIMEOUT)
2191			rpc_exit(task, -ETIMEDOUT);
2192		else
2193			rpc_exit(task, -EIO);
2194		return;
2195	}
2196
2197	if (!(task->tk_flags & RPC_CALL_MAJORSEEN)) {
2198		task->tk_flags |= RPC_CALL_MAJORSEEN;
2199		if (clnt->cl_chatty) {
2200			printk(KERN_NOTICE "%s: server %s not responding, still trying\n",
2201			clnt->cl_program->name,
2202			task->tk_xprt->servername);
 
2203		}
2204	}
2205	rpc_force_rebind(clnt);
2206	/*
2207	 * Did our request time out due to an RPCSEC_GSS out-of-sequence
2208	 * event? RFC2203 requires the server to drop all such requests.
2209	 */
2210	rpcauth_invalcred(task);
2211
2212retry:
2213	task->tk_action = call_bind;
2214	task->tk_status = 0;
2215}
2216
2217/*
2218 * 7.	Decode the RPC reply
2219 */
2220static void
2221call_decode(struct rpc_task *task)
2222{
2223	struct rpc_clnt	*clnt = task->tk_client;
2224	struct rpc_rqst	*req = task->tk_rqstp;
2225	kxdrdproc_t	decode = task->tk_msg.rpc_proc->p_decode;
2226	__be32		*p;
2227
2228	dprint_status(task);
2229
 
 
 
 
 
2230	if (task->tk_flags & RPC_CALL_MAJORSEEN) {
2231		if (clnt->cl_chatty) {
2232			printk(KERN_NOTICE "%s: server %s OK\n",
2233				clnt->cl_program->name,
2234				task->tk_xprt->servername);
2235		}
2236		task->tk_flags &= ~RPC_CALL_MAJORSEEN;
2237	}
2238
2239	/*
2240	 * Ensure that we see all writes made by xprt_complete_rqst()
2241	 * before it changed req->rq_reply_bytes_recvd.
2242	 */
2243	smp_rmb();
 
 
 
 
 
 
 
 
 
2244	req->rq_rcv_buf.len = req->rq_private_buf.len;
2245
2246	/* Check that the softirq receive buffer is valid */
2247	WARN_ON(memcmp(&req->rq_rcv_buf, &req->rq_private_buf,
2248				sizeof(req->rq_rcv_buf)) != 0);
2249
2250	if (req->rq_rcv_buf.len < 12) {
2251		if (!RPC_IS_SOFT(task)) {
2252			task->tk_action = call_bind;
2253			goto out_retry;
2254		}
2255		dprintk("RPC:       %s: too small RPC reply size (%d bytes)\n",
2256				clnt->cl_program->name, task->tk_status);
2257		task->tk_action = call_timeout;
2258		goto out_retry;
2259	}
2260
2261	p = rpc_verify_header(task);
2262	if (IS_ERR(p)) {
2263		if (p == ERR_PTR(-EAGAIN))
2264			goto out_retry;
2265		return;
2266	}
2267
2268	task->tk_action = rpc_exit_task;
2269
2270	if (decode) {
2271		task->tk_status = rpcauth_unwrap_resp(task, decode, req, p,
2272						      task->tk_msg.rpc_resp);
2273	}
2274	dprintk("RPC: %5u call_decode result %d\n", task->tk_pid,
2275			task->tk_status);
2276	return;
2277out_retry:
2278	task->tk_status = 0;
2279	/* Note: rpc_verify_header() may have freed the RPC slot */
2280	if (task->tk_rqstp == req) {
2281		req->rq_reply_bytes_recvd = req->rq_rcv_buf.len = 0;
2282		if (task->tk_client->cl_discrtry)
2283			xprt_conditional_disconnect(req->rq_xprt,
2284					req->rq_connect_cookie);
 
 
 
 
 
 
 
 
 
2285	}
2286}
2287
2288static __be32 *
2289rpc_encode_header(struct rpc_task *task)
2290{
2291	struct rpc_clnt *clnt = task->tk_client;
2292	struct rpc_rqst	*req = task->tk_rqstp;
2293	__be32		*p = req->rq_svec[0].iov_base;
2294
2295	/* FIXME: check buffer size? */
2296
2297	p = xprt_skip_transport_header(req->rq_xprt, p);
2298	*p++ = req->rq_xid;		/* XID */
2299	*p++ = htonl(RPC_CALL);		/* CALL */
2300	*p++ = htonl(RPC_VERSION);	/* RPC version */
2301	*p++ = htonl(clnt->cl_prog);	/* program number */
2302	*p++ = htonl(clnt->cl_vers);	/* program version */
2303	*p++ = htonl(task->tk_msg.rpc_proc->p_proc);	/* procedure */
2304	p = rpcauth_marshcred(task, p);
2305	req->rq_slen = xdr_adjust_iovec(&req->rq_svec[0], p);
2306	return p;
 
 
 
 
 
 
 
 
 
2307}
2308
2309static __be32 *
2310rpc_verify_header(struct rpc_task *task)
2311{
2312	struct rpc_clnt *clnt = task->tk_client;
2313	struct kvec *iov = &task->tk_rqstp->rq_rcv_buf.head[0];
2314	int len = task->tk_rqstp->rq_rcv_buf.len >> 2;
2315	__be32	*p = iov->iov_base;
2316	u32 n;
2317	int error = -EACCES;
2318
2319	if ((task->tk_rqstp->rq_rcv_buf.len & 3) != 0) {
2320		/* RFC-1014 says that the representation of XDR data must be a
2321		 * multiple of four bytes
2322		 * - if it isn't pointer subtraction in the NFS client may give
2323		 *   undefined results
2324		 */
2325		dprintk("RPC: %5u %s: XDR representation not a multiple of"
2326		       " 4 bytes: 0x%x\n", task->tk_pid, __func__,
2327		       task->tk_rqstp->rq_rcv_buf.len);
2328		error = -EIO;
2329		goto out_err;
2330	}
2331	if ((len -= 3) < 0)
2332		goto out_overflow;
2333
2334	p += 1; /* skip XID */
2335	if ((n = ntohl(*p++)) != RPC_REPLY) {
2336		dprintk("RPC: %5u %s: not an RPC reply: %x\n",
2337			task->tk_pid, __func__, n);
2338		error = -EIO;
2339		goto out_garbage;
2340	}
2341
2342	if ((n = ntohl(*p++)) != RPC_MSG_ACCEPTED) {
2343		if (--len < 0)
2344			goto out_overflow;
2345		switch ((n = ntohl(*p++))) {
2346		case RPC_AUTH_ERROR:
2347			break;
2348		case RPC_MISMATCH:
2349			dprintk("RPC: %5u %s: RPC call version mismatch!\n",
2350				task->tk_pid, __func__);
2351			error = -EPROTONOSUPPORT;
2352			goto out_err;
2353		default:
2354			dprintk("RPC: %5u %s: RPC call rejected, "
2355				"unknown error: %x\n",
2356				task->tk_pid, __func__, n);
2357			error = -EIO;
2358			goto out_err;
2359		}
2360		if (--len < 0)
2361			goto out_overflow;
2362		switch ((n = ntohl(*p++))) {
2363		case RPC_AUTH_REJECTEDCRED:
2364		case RPC_AUTH_REJECTEDVERF:
2365		case RPCSEC_GSS_CREDPROBLEM:
2366		case RPCSEC_GSS_CTXPROBLEM:
2367			if (!task->tk_cred_retry)
2368				break;
2369			task->tk_cred_retry--;
2370			dprintk("RPC: %5u %s: retry stale creds\n",
2371					task->tk_pid, __func__);
2372			rpcauth_invalcred(task);
2373			/* Ensure we obtain a new XID! */
2374			xprt_release(task);
2375			task->tk_action = call_reserve;
2376			goto out_retry;
2377		case RPC_AUTH_BADCRED:
2378		case RPC_AUTH_BADVERF:
2379			/* possibly garbled cred/verf? */
2380			if (!task->tk_garb_retry)
2381				break;
2382			task->tk_garb_retry--;
2383			dprintk("RPC: %5u %s: retry garbled creds\n",
2384					task->tk_pid, __func__);
2385			task->tk_action = call_bind;
2386			goto out_retry;
2387		case RPC_AUTH_TOOWEAK:
2388			printk(KERN_NOTICE "RPC: server %s requires stronger "
2389			       "authentication.\n",
2390			       task->tk_xprt->servername);
2391			break;
2392		default:
2393			dprintk("RPC: %5u %s: unknown auth error: %x\n",
2394					task->tk_pid, __func__, n);
2395			error = -EIO;
2396		}
2397		dprintk("RPC: %5u %s: call rejected %d\n",
2398				task->tk_pid, __func__, n);
2399		goto out_err;
2400	}
2401	p = rpcauth_checkverf(task, p);
2402	if (IS_ERR(p)) {
2403		error = PTR_ERR(p);
2404		dprintk("RPC: %5u %s: auth check failed with %d\n",
2405				task->tk_pid, __func__, error);
2406		goto out_garbage;		/* bad verifier, retry */
2407	}
2408	len = p - (__be32 *)iov->iov_base - 1;
2409	if (len < 0)
2410		goto out_overflow;
2411	switch ((n = ntohl(*p++))) {
2412	case RPC_SUCCESS:
2413		return p;
2414	case RPC_PROG_UNAVAIL:
2415		dprintk("RPC: %5u %s: program %u is unsupported "
2416				"by server %s\n", task->tk_pid, __func__,
2417				(unsigned int)clnt->cl_prog,
2418				task->tk_xprt->servername);
2419		error = -EPFNOSUPPORT;
2420		goto out_err;
2421	case RPC_PROG_MISMATCH:
2422		dprintk("RPC: %5u %s: program %u, version %u unsupported "
2423				"by server %s\n", task->tk_pid, __func__,
2424				(unsigned int)clnt->cl_prog,
2425				(unsigned int)clnt->cl_vers,
2426				task->tk_xprt->servername);
2427		error = -EPROTONOSUPPORT;
2428		goto out_err;
2429	case RPC_PROC_UNAVAIL:
2430		dprintk("RPC: %5u %s: proc %s unsupported by program %u, "
2431				"version %u on server %s\n",
2432				task->tk_pid, __func__,
2433				rpc_proc_name(task),
2434				clnt->cl_prog, clnt->cl_vers,
2435				task->tk_xprt->servername);
2436		error = -EOPNOTSUPP;
2437		goto out_err;
2438	case RPC_GARBAGE_ARGS:
2439		dprintk("RPC: %5u %s: server saw garbage\n",
2440				task->tk_pid, __func__);
2441		break;			/* retry */
 
2442	default:
2443		dprintk("RPC: %5u %s: server accept status: %x\n",
2444				task->tk_pid, __func__, n);
2445		/* Also retry */
2446	}
2447
2448out_garbage:
2449	clnt->cl_stats->rpcgarbage++;
2450	if (task->tk_garb_retry) {
2451		task->tk_garb_retry--;
2452		dprintk("RPC: %5u %s: retrying\n",
2453				task->tk_pid, __func__);
2454		task->tk_action = call_bind;
2455out_retry:
2456		return ERR_PTR(-EAGAIN);
2457	}
2458out_err:
2459	rpc_exit(task, error);
2460	dprintk("RPC: %5u %s: call failed with error %d\n", task->tk_pid,
2461			__func__, error);
2462	return ERR_PTR(error);
2463out_overflow:
2464	dprintk("RPC: %5u %s: server reply was truncated.\n", task->tk_pid,
2465			__func__);
2466	goto out_garbage;
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
2467}
2468
2469static void rpcproc_encode_null(void *rqstp, struct xdr_stream *xdr, void *obj)
 
2470{
2471}
2472
2473static int rpcproc_decode_null(void *rqstp, struct xdr_stream *xdr, void *obj)
 
2474{
2475	return 0;
2476}
2477
2478static struct rpc_procinfo rpcproc_null = {
2479	.p_encode = rpcproc_encode_null,
2480	.p_decode = rpcproc_decode_null,
2481};
2482
2483static int rpc_ping(struct rpc_clnt *clnt)
2484{
2485	struct rpc_message msg = {
2486		.rpc_proc = &rpcproc_null,
2487	};
2488	int err;
2489	msg.rpc_cred = authnull_ops.lookup_cred(NULL, NULL, 0);
2490	err = rpc_call_sync(clnt, &msg, RPC_TASK_SOFT | RPC_TASK_SOFTCONN);
2491	put_rpccred(msg.rpc_cred);
2492	return err;
2493}
2494
2495static
2496struct rpc_task *rpc_call_null_helper(struct rpc_clnt *clnt,
2497		struct rpc_xprt *xprt, struct rpc_cred *cred, int flags,
2498		const struct rpc_call_ops *ops, void *data)
2499{
2500	struct rpc_message msg = {
2501		.rpc_proc = &rpcproc_null,
2502		.rpc_cred = cred,
2503	};
2504	struct rpc_task_setup task_setup_data = {
2505		.rpc_client = clnt,
2506		.rpc_xprt = xprt,
2507		.rpc_message = &msg,
 
2508		.callback_ops = (ops != NULL) ? ops : &rpc_default_ops,
2509		.callback_data = data,
2510		.flags = flags,
2511	};
2512
2513	return rpc_run_task(&task_setup_data);
2514}
2515
2516struct rpc_task *rpc_call_null(struct rpc_clnt *clnt, struct rpc_cred *cred, int flags)
2517{
2518	return rpc_call_null_helper(clnt, NULL, cred, flags, NULL, NULL);
2519}
2520EXPORT_SYMBOL_GPL(rpc_call_null);
2521
2522struct rpc_cb_add_xprt_calldata {
2523	struct rpc_xprt_switch *xps;
2524	struct rpc_xprt *xprt;
2525};
2526
2527static void rpc_cb_add_xprt_done(struct rpc_task *task, void *calldata)
2528{
2529	struct rpc_cb_add_xprt_calldata *data = calldata;
2530
2531	if (task->tk_status == 0)
2532		rpc_xprt_switch_add_xprt(data->xps, data->xprt);
2533}
2534
2535static void rpc_cb_add_xprt_release(void *calldata)
2536{
2537	struct rpc_cb_add_xprt_calldata *data = calldata;
2538
2539	xprt_put(data->xprt);
2540	xprt_switch_put(data->xps);
2541	kfree(data);
2542}
2543
2544const static struct rpc_call_ops rpc_cb_add_xprt_call_ops = {
2545	.rpc_call_done = rpc_cb_add_xprt_done,
2546	.rpc_release = rpc_cb_add_xprt_release,
2547};
2548
2549/**
2550 * rpc_clnt_test_and_add_xprt - Test and add a new transport to a rpc_clnt
2551 * @clnt: pointer to struct rpc_clnt
2552 * @xps: pointer to struct rpc_xprt_switch,
2553 * @xprt: pointer struct rpc_xprt
2554 * @dummy: unused
2555 */
2556int rpc_clnt_test_and_add_xprt(struct rpc_clnt *clnt,
2557		struct rpc_xprt_switch *xps, struct rpc_xprt *xprt,
2558		void *dummy)
2559{
2560	struct rpc_cb_add_xprt_calldata *data;
2561	struct rpc_cred *cred;
2562	struct rpc_task *task;
2563
2564	data = kmalloc(sizeof(*data), GFP_NOFS);
2565	if (!data)
2566		return -ENOMEM;
2567	data->xps = xprt_switch_get(xps);
2568	data->xprt = xprt_get(xprt);
 
 
 
 
2569
2570	cred = authnull_ops.lookup_cred(NULL, NULL, 0);
2571	task = rpc_call_null_helper(clnt, xprt, cred,
2572			RPC_TASK_SOFT|RPC_TASK_SOFTCONN|RPC_TASK_ASYNC,
2573			&rpc_cb_add_xprt_call_ops, data);
2574	put_rpccred(cred);
2575	if (IS_ERR(task))
2576		return PTR_ERR(task);
2577	rpc_put_task(task);
 
2578	return 1;
2579}
2580EXPORT_SYMBOL_GPL(rpc_clnt_test_and_add_xprt);
2581
2582/**
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
2583 * rpc_clnt_add_xprt - Add a new transport to a rpc_clnt
2584 * @clnt: pointer to struct rpc_clnt
2585 * @xprtargs: pointer to struct xprt_create
2586 * @setup: callback to test and/or set up the connection
2587 * @data: pointer to setup function data
2588 *
2589 * Creates a new transport using the parameters set in args and
2590 * adds it to clnt.
2591 * If ping is set, then test that connectivity succeeds before
2592 * adding the new transport.
2593 *
2594 */
2595int rpc_clnt_add_xprt(struct rpc_clnt *clnt,
2596		struct xprt_create *xprtargs,
2597		int (*setup)(struct rpc_clnt *,
2598			struct rpc_xprt_switch *,
2599			struct rpc_xprt *,
2600			void *),
2601		void *data)
2602{
2603	struct rpc_xprt_switch *xps;
2604	struct rpc_xprt *xprt;
 
 
2605	unsigned char resvport;
2606	int ret = 0;
2607
2608	rcu_read_lock();
2609	xps = xprt_switch_get(rcu_dereference(clnt->cl_xpi.xpi_xpswitch));
2610	xprt = xprt_iter_xprt(&clnt->cl_xpi);
2611	if (xps == NULL || xprt == NULL) {
2612		rcu_read_unlock();
 
2613		return -EAGAIN;
2614	}
2615	resvport = xprt->resvport;
 
 
2616	rcu_read_unlock();
2617
2618	xprt = xprt_create_transport(xprtargs);
2619	if (IS_ERR(xprt)) {
2620		ret = PTR_ERR(xprt);
2621		goto out_put_switch;
2622	}
2623	xprt->resvport = resvport;
 
 
 
 
2624
2625	rpc_xprt_switch_set_roundrobin(xps);
2626	if (setup) {
2627		ret = setup(clnt, xps, xprt, data);
2628		if (ret != 0)
2629			goto out_put_xprt;
2630	}
2631	rpc_xprt_switch_add_xprt(xps, xprt);
2632out_put_xprt:
2633	xprt_put(xprt);
2634out_put_switch:
2635	xprt_switch_put(xps);
2636	return ret;
2637}
2638EXPORT_SYMBOL_GPL(rpc_clnt_add_xprt);
2639
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
2640#if IS_ENABLED(CONFIG_SUNRPC_DEBUG)
2641static void rpc_show_header(void)
2642{
2643	printk(KERN_INFO "-pid- flgs status -client- --rqstp- "
2644		"-timeout ---ops--\n");
2645}
2646
2647static void rpc_show_task(const struct rpc_clnt *clnt,
2648			  const struct rpc_task *task)
2649{
2650	const char *rpc_waitq = "none";
2651
2652	if (RPC_IS_QUEUED(task))
2653		rpc_waitq = rpc_qname(task->tk_waitqueue);
2654
2655	printk(KERN_INFO "%5u %04x %6d %8p %8p %8ld %8p %sv%u %s a:%ps q:%s\n",
2656		task->tk_pid, task->tk_flags, task->tk_status,
2657		clnt, task->tk_rqstp, task->tk_timeout, task->tk_ops,
2658		clnt->cl_program->name, clnt->cl_vers, rpc_proc_name(task),
2659		task->tk_action, rpc_waitq);
2660}
2661
2662void rpc_show_tasks(struct net *net)
2663{
2664	struct rpc_clnt *clnt;
2665	struct rpc_task *task;
2666	int header = 0;
2667	struct sunrpc_net *sn = net_generic(net, sunrpc_net_id);
2668
2669	spin_lock(&sn->rpc_client_lock);
2670	list_for_each_entry(clnt, &sn->all_clients, cl_clients) {
2671		spin_lock(&clnt->cl_lock);
2672		list_for_each_entry(task, &clnt->cl_tasks, tk_task) {
2673			if (!header) {
2674				rpc_show_header();
2675				header++;
2676			}
2677			rpc_show_task(clnt, task);
2678		}
2679		spin_unlock(&clnt->cl_lock);
2680	}
2681	spin_unlock(&sn->rpc_client_lock);
2682}
2683#endif
2684
2685#if IS_ENABLED(CONFIG_SUNRPC_SWAP)
2686static int
2687rpc_clnt_swap_activate_callback(struct rpc_clnt *clnt,
2688		struct rpc_xprt *xprt,
2689		void *dummy)
2690{
2691	return xprt_enable_swap(xprt);
2692}
2693
2694int
2695rpc_clnt_swap_activate(struct rpc_clnt *clnt)
2696{
2697	if (atomic_inc_return(&clnt->cl_swapper) == 1)
2698		return rpc_clnt_iterate_for_each_xprt(clnt,
2699				rpc_clnt_swap_activate_callback, NULL);
2700	return 0;
2701}
2702EXPORT_SYMBOL_GPL(rpc_clnt_swap_activate);
2703
2704static int
2705rpc_clnt_swap_deactivate_callback(struct rpc_clnt *clnt,
2706		struct rpc_xprt *xprt,
2707		void *dummy)
2708{
2709	xprt_disable_swap(xprt);
2710	return 0;
2711}
2712
2713void
2714rpc_clnt_swap_deactivate(struct rpc_clnt *clnt)
2715{
2716	if (atomic_dec_if_positive(&clnt->cl_swapper) == 0)
2717		rpc_clnt_iterate_for_each_xprt(clnt,
2718				rpc_clnt_swap_deactivate_callback, NULL);
2719}
2720EXPORT_SYMBOL_GPL(rpc_clnt_swap_deactivate);
2721#endif /* CONFIG_SUNRPC_SWAP */