1 // SPDX-License-Identifier: GPL-2.0-only
2 /*
3  *  linux/net/sunrpc/clnt.c
4  *
5  *  This file contains the high-level RPC interface.
6  *  It is modeled as a finite state machine to support both synchronous
7  *  and asynchronous requests.
8  *
9  *  -	RPC header generation and argument serialization.
10  *  -	Credential refresh.
11  *  -	TCP connect handling.
12  *  -	Retry of operation when it is suspected the operation failed because
13  *	of uid squashing on the server, or when the credentials were stale
14  *	and need to be refreshed, or when a packet was damaged in transit.
15  *	This may be have to be moved to the VFS layer.
16  *
17  *  Copyright (C) 1992,1993 Rick Sladkey <jrs@world.std.com>
18  *  Copyright (C) 1995,1996 Olaf Kirch <okir@monad.swb.de>
19  */
20 
21 
22 #include <linux/module.h>
23 #include <linux/types.h>
24 #include <linux/kallsyms.h>
25 #include <linux/mm.h>
26 #include <linux/namei.h>
27 #include <linux/mount.h>
28 #include <linux/slab.h>
29 #include <linux/rcupdate.h>
30 #include <linux/utsname.h>
31 #include <linux/workqueue.h>
32 #include <linux/in.h>
33 #include <linux/in6.h>
34 #include <linux/un.h>
35 
36 #include <linux/sunrpc/clnt.h>
37 #include <linux/sunrpc/addr.h>
38 #include <linux/sunrpc/rpc_pipe_fs.h>
39 #include <linux/sunrpc/metrics.h>
40 #include <linux/sunrpc/bc_xprt.h>
41 #include <trace/events/sunrpc.h>
42 
43 #include "sunrpc.h"
44 #include "sysfs.h"
45 #include "netns.h"
46 
47 #if IS_ENABLED(CONFIG_SUNRPC_DEBUG)
48 # define RPCDBG_FACILITY	RPCDBG_CALL
49 #endif
50 
51 /*
52  * All RPC clients are linked into this list
53  */
54 
55 static DECLARE_WAIT_QUEUE_HEAD(destroy_wait);
56 
57 
58 static void	call_start(struct rpc_task *task);
59 static void	call_reserve(struct rpc_task *task);
60 static void	call_reserveresult(struct rpc_task *task);
61 static void	call_allocate(struct rpc_task *task);
62 static void	call_encode(struct rpc_task *task);
63 static void	call_decode(struct rpc_task *task);
64 static void	call_bind(struct rpc_task *task);
65 static void	call_bind_status(struct rpc_task *task);
66 static void	call_transmit(struct rpc_task *task);
67 static void	call_status(struct rpc_task *task);
68 static void	call_transmit_status(struct rpc_task *task);
69 static void	call_refresh(struct rpc_task *task);
70 static void	call_refreshresult(struct rpc_task *task);
71 static void	call_connect(struct rpc_task *task);
72 static void	call_connect_status(struct rpc_task *task);
73 
74 static int	rpc_encode_header(struct rpc_task *task,
75 				  struct xdr_stream *xdr);
76 static int	rpc_decode_header(struct rpc_task *task,
77 				  struct xdr_stream *xdr);
78 static int	rpc_ping(struct rpc_clnt *clnt);
79 static int	rpc_ping_noreply(struct rpc_clnt *clnt);
80 static void	rpc_check_timeout(struct rpc_task *task);
81 
rpc_register_client(struct rpc_clnt * clnt)82 static void rpc_register_client(struct rpc_clnt *clnt)
83 {
84 	struct net *net = rpc_net_ns(clnt);
85 	struct sunrpc_net *sn = net_generic(net, sunrpc_net_id);
86 
87 	spin_lock(&sn->rpc_client_lock);
88 	list_add(&clnt->cl_clients, &sn->all_clients);
89 	spin_unlock(&sn->rpc_client_lock);
90 }
91 
rpc_unregister_client(struct rpc_clnt * clnt)92 static void rpc_unregister_client(struct rpc_clnt *clnt)
93 {
94 	struct net *net = rpc_net_ns(clnt);
95 	struct sunrpc_net *sn = net_generic(net, sunrpc_net_id);
96 
97 	spin_lock(&sn->rpc_client_lock);
98 	list_del(&clnt->cl_clients);
99 	spin_unlock(&sn->rpc_client_lock);
100 }
101 
__rpc_clnt_remove_pipedir(struct rpc_clnt * clnt)102 static void __rpc_clnt_remove_pipedir(struct rpc_clnt *clnt)
103 {
104 	rpc_remove_client_dir(clnt);
105 }
106 
rpc_clnt_remove_pipedir(struct rpc_clnt * clnt)107 static void rpc_clnt_remove_pipedir(struct rpc_clnt *clnt)
108 {
109 	struct net *net = rpc_net_ns(clnt);
110 	struct super_block *pipefs_sb;
111 
112 	pipefs_sb = rpc_get_sb_net(net);
113 	if (pipefs_sb) {
114 		__rpc_clnt_remove_pipedir(clnt);
115 		rpc_put_sb_net(net);
116 	}
117 }
118 
rpc_setup_pipedir_sb(struct super_block * sb,struct rpc_clnt * clnt)119 static struct dentry *rpc_setup_pipedir_sb(struct super_block *sb,
120 				    struct rpc_clnt *clnt)
121 {
122 	static uint32_t clntid;
123 	const char *dir_name = clnt->cl_program->pipe_dir_name;
124 	char name[15];
125 	struct dentry *dir, *dentry;
126 
127 	dir = rpc_d_lookup_sb(sb, dir_name);
128 	if (dir == NULL) {
129 		pr_info("RPC: pipefs directory doesn't exist: %s\n", dir_name);
130 		return dir;
131 	}
132 	for (;;) {
133 		snprintf(name, sizeof(name), "clnt%x", (unsigned int)clntid++);
134 		name[sizeof(name) - 1] = '\0';
135 		dentry = rpc_create_client_dir(dir, name, clnt);
136 		if (!IS_ERR(dentry))
137 			break;
138 		if (dentry == ERR_PTR(-EEXIST))
139 			continue;
140 		printk(KERN_INFO "RPC: Couldn't create pipefs entry"
141 				" %s/%s, error %ld\n",
142 				dir_name, name, PTR_ERR(dentry));
143 		break;
144 	}
145 	dput(dir);
146 	return dentry;
147 }
148 
149 static int
rpc_setup_pipedir(struct super_block * pipefs_sb,struct rpc_clnt * clnt)150 rpc_setup_pipedir(struct super_block *pipefs_sb, struct rpc_clnt *clnt)
151 {
152 	struct dentry *dentry;
153 
154 	if (clnt->cl_program->pipe_dir_name != NULL) {
155 		dentry = rpc_setup_pipedir_sb(pipefs_sb, clnt);
156 		if (IS_ERR(dentry))
157 			return PTR_ERR(dentry);
158 	}
159 	return 0;
160 }
161 
rpc_clnt_skip_event(struct rpc_clnt * clnt,unsigned long event)162 static int rpc_clnt_skip_event(struct rpc_clnt *clnt, unsigned long event)
163 {
164 	if (clnt->cl_program->pipe_dir_name == NULL)
165 		return 1;
166 
167 	switch (event) {
168 	case RPC_PIPEFS_MOUNT:
169 		if (clnt->cl_pipedir_objects.pdh_dentry != NULL)
170 			return 1;
171 		if (refcount_read(&clnt->cl_count) == 0)
172 			return 1;
173 		break;
174 	case RPC_PIPEFS_UMOUNT:
175 		if (clnt->cl_pipedir_objects.pdh_dentry == NULL)
176 			return 1;
177 		break;
178 	}
179 	return 0;
180 }
181 
__rpc_clnt_handle_event(struct rpc_clnt * clnt,unsigned long event,struct super_block * sb)182 static int __rpc_clnt_handle_event(struct rpc_clnt *clnt, unsigned long event,
183 				   struct super_block *sb)
184 {
185 	struct dentry *dentry;
186 
187 	switch (event) {
188 	case RPC_PIPEFS_MOUNT:
189 		dentry = rpc_setup_pipedir_sb(sb, clnt);
190 		if (!dentry)
191 			return -ENOENT;
192 		if (IS_ERR(dentry))
193 			return PTR_ERR(dentry);
194 		break;
195 	case RPC_PIPEFS_UMOUNT:
196 		__rpc_clnt_remove_pipedir(clnt);
197 		break;
198 	default:
199 		printk(KERN_ERR "%s: unknown event: %ld\n", __func__, event);
200 		return -ENOTSUPP;
201 	}
202 	return 0;
203 }
204 
__rpc_pipefs_event(struct rpc_clnt * clnt,unsigned long event,struct super_block * sb)205 static int __rpc_pipefs_event(struct rpc_clnt *clnt, unsigned long event,
206 				struct super_block *sb)
207 {
208 	int error = 0;
209 
210 	for (;; clnt = clnt->cl_parent) {
211 		if (!rpc_clnt_skip_event(clnt, event))
212 			error = __rpc_clnt_handle_event(clnt, event, sb);
213 		if (error || clnt == clnt->cl_parent)
214 			break;
215 	}
216 	return error;
217 }
218 
rpc_get_client_for_event(struct net * net,int event)219 static struct rpc_clnt *rpc_get_client_for_event(struct net *net, int event)
220 {
221 	struct sunrpc_net *sn = net_generic(net, sunrpc_net_id);
222 	struct rpc_clnt *clnt;
223 
224 	spin_lock(&sn->rpc_client_lock);
225 	list_for_each_entry(clnt, &sn->all_clients, cl_clients) {
226 		if (rpc_clnt_skip_event(clnt, event))
227 			continue;
228 		spin_unlock(&sn->rpc_client_lock);
229 		return clnt;
230 	}
231 	spin_unlock(&sn->rpc_client_lock);
232 	return NULL;
233 }
234 
rpc_pipefs_event(struct notifier_block * nb,unsigned long event,void * ptr)235 static int rpc_pipefs_event(struct notifier_block *nb, unsigned long event,
236 			    void *ptr)
237 {
238 	struct super_block *sb = ptr;
239 	struct rpc_clnt *clnt;
240 	int error = 0;
241 
242 	while ((clnt = rpc_get_client_for_event(sb->s_fs_info, event))) {
243 		error = __rpc_pipefs_event(clnt, event, sb);
244 		if (error)
245 			break;
246 	}
247 	return error;
248 }
249 
250 static struct notifier_block rpc_clients_block = {
251 	.notifier_call	= rpc_pipefs_event,
252 	.priority	= SUNRPC_PIPEFS_RPC_PRIO,
253 };
254 
rpc_clients_notifier_register(void)255 int rpc_clients_notifier_register(void)
256 {
257 	return rpc_pipefs_notifier_register(&rpc_clients_block);
258 }
259 
rpc_clients_notifier_unregister(void)260 void rpc_clients_notifier_unregister(void)
261 {
262 	return rpc_pipefs_notifier_unregister(&rpc_clients_block);
263 }
264 
rpc_clnt_set_transport(struct rpc_clnt * clnt,struct rpc_xprt * xprt,const struct rpc_timeout * timeout)265 static struct rpc_xprt *rpc_clnt_set_transport(struct rpc_clnt *clnt,
266 		struct rpc_xprt *xprt,
267 		const struct rpc_timeout *timeout)
268 {
269 	struct rpc_xprt *old;
270 
271 	spin_lock(&clnt->cl_lock);
272 	old = rcu_dereference_protected(clnt->cl_xprt,
273 			lockdep_is_held(&clnt->cl_lock));
274 
275 	if (!xprt_bound(xprt))
276 		clnt->cl_autobind = 1;
277 
278 	clnt->cl_timeout = timeout;
279 	rcu_assign_pointer(clnt->cl_xprt, xprt);
280 	spin_unlock(&clnt->cl_lock);
281 
282 	return old;
283 }
284 
rpc_clnt_set_nodename(struct rpc_clnt * clnt,const char * nodename)285 static void rpc_clnt_set_nodename(struct rpc_clnt *clnt, const char *nodename)
286 {
287 	clnt->cl_nodelen = strlcpy(clnt->cl_nodename,
288 			nodename, sizeof(clnt->cl_nodename));
289 }
290 
rpc_client_register(struct rpc_clnt * clnt,rpc_authflavor_t pseudoflavor,const char * client_name)291 static int rpc_client_register(struct rpc_clnt *clnt,
292 			       rpc_authflavor_t pseudoflavor,
293 			       const char *client_name)
294 {
295 	struct rpc_auth_create_args auth_args = {
296 		.pseudoflavor = pseudoflavor,
297 		.target_name = client_name,
298 	};
299 	struct rpc_auth *auth;
300 	struct net *net = rpc_net_ns(clnt);
301 	struct super_block *pipefs_sb;
302 	int err;
303 
304 	rpc_clnt_debugfs_register(clnt);
305 
306 	pipefs_sb = rpc_get_sb_net(net);
307 	if (pipefs_sb) {
308 		err = rpc_setup_pipedir(pipefs_sb, clnt);
309 		if (err)
310 			goto out;
311 	}
312 
313 	rpc_register_client(clnt);
314 	if (pipefs_sb)
315 		rpc_put_sb_net(net);
316 
317 	auth = rpcauth_create(&auth_args, clnt);
318 	if (IS_ERR(auth)) {
319 		dprintk("RPC:       Couldn't create auth handle (flavor %u)\n",
320 				pseudoflavor);
321 		err = PTR_ERR(auth);
322 		goto err_auth;
323 	}
324 	return 0;
325 err_auth:
326 	pipefs_sb = rpc_get_sb_net(net);
327 	rpc_unregister_client(clnt);
328 	__rpc_clnt_remove_pipedir(clnt);
329 out:
330 	if (pipefs_sb)
331 		rpc_put_sb_net(net);
332 	rpc_sysfs_client_destroy(clnt);
333 	rpc_clnt_debugfs_unregister(clnt);
334 	return err;
335 }
336 
337 static DEFINE_IDA(rpc_clids);
338 
rpc_cleanup_clids(void)339 void rpc_cleanup_clids(void)
340 {
341 	ida_destroy(&rpc_clids);
342 }
343 
rpc_alloc_clid(struct rpc_clnt * clnt)344 static int rpc_alloc_clid(struct rpc_clnt *clnt)
345 {
346 	int clid;
347 
348 	clid = ida_alloc(&rpc_clids, GFP_KERNEL);
349 	if (clid < 0)
350 		return clid;
351 	clnt->cl_clid = clid;
352 	return 0;
353 }
354 
rpc_free_clid(struct rpc_clnt * clnt)355 static void rpc_free_clid(struct rpc_clnt *clnt)
356 {
357 	ida_free(&rpc_clids, clnt->cl_clid);
358 }
359 
rpc_new_client(const struct rpc_create_args * args,struct rpc_xprt_switch * xps,struct rpc_xprt * xprt,struct rpc_clnt * parent)360 static struct rpc_clnt * rpc_new_client(const struct rpc_create_args *args,
361 		struct rpc_xprt_switch *xps,
362 		struct rpc_xprt *xprt,
363 		struct rpc_clnt *parent)
364 {
365 	const struct rpc_program *program = args->program;
366 	const struct rpc_version *version;
367 	struct rpc_clnt *clnt = NULL;
368 	const struct rpc_timeout *timeout;
369 	const char *nodename = args->nodename;
370 	int err;
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_cred	  = get_cred(args->cred);
394 	clnt->cl_procinfo = version->procs;
395 	clnt->cl_maxproc  = version->nrprocs;
396 	clnt->cl_prog     = args->prognumber ? : program->number;
397 	clnt->cl_vers     = version->number;
398 	clnt->cl_stats    = program->stats;
399 	clnt->cl_metrics  = rpc_alloc_iostats(clnt);
400 	rpc_init_pipe_dir_head(&clnt->cl_pipedir_objects);
401 	err = -ENOMEM;
402 	if (clnt->cl_metrics == NULL)
403 		goto out_no_stats;
404 	clnt->cl_program  = program;
405 	INIT_LIST_HEAD(&clnt->cl_tasks);
406 	spin_lock_init(&clnt->cl_lock);
407 
408 	timeout = xprt->timeout;
409 	if (args->timeout != NULL) {
410 		memcpy(&clnt->cl_timeout_default, args->timeout,
411 				sizeof(clnt->cl_timeout_default));
412 		timeout = &clnt->cl_timeout_default;
413 	}
414 
415 	rpc_clnt_set_transport(clnt, xprt, timeout);
416 	xprt->main = true;
417 	xprt_iter_init(&clnt->cl_xpi, xps);
418 	xprt_switch_put(xps);
419 
420 	clnt->cl_rtt = &clnt->cl_rtt_default;
421 	rpc_init_rtt(&clnt->cl_rtt_default, clnt->cl_timeout->to_initval);
422 
423 	refcount_set(&clnt->cl_count, 1);
424 
425 	if (nodename == NULL)
426 		nodename = utsname()->nodename;
427 	/* save the nodename */
428 	rpc_clnt_set_nodename(clnt, nodename);
429 
430 	rpc_sysfs_client_setup(clnt, xps, rpc_net_ns(clnt));
431 	err = rpc_client_register(clnt, args->authflavor, args->client_name);
432 	if (err)
433 		goto out_no_path;
434 	if (parent)
435 		refcount_inc(&parent->cl_count);
436 
437 	trace_rpc_clnt_new(clnt, xprt, program->name, args->servername);
438 	return clnt;
439 
440 out_no_path:
441 	rpc_free_iostats(clnt->cl_metrics);
442 out_no_stats:
443 	put_cred(clnt->cl_cred);
444 	rpc_free_clid(clnt);
445 out_no_clid:
446 	kfree(clnt);
447 out_err:
448 	rpciod_down();
449 out_no_rpciod:
450 	xprt_switch_put(xps);
451 	xprt_put(xprt);
452 	trace_rpc_clnt_new_err(program->name, args->servername, err);
453 	return ERR_PTR(err);
454 }
455 
rpc_create_xprt(struct rpc_create_args * args,struct rpc_xprt * xprt)456 static struct rpc_clnt *rpc_create_xprt(struct rpc_create_args *args,
457 					struct rpc_xprt *xprt)
458 {
459 	struct rpc_clnt *clnt = NULL;
460 	struct rpc_xprt_switch *xps;
461 
462 	if (args->bc_xprt && args->bc_xprt->xpt_bc_xps) {
463 		WARN_ON_ONCE(!(args->protocol & XPRT_TRANSPORT_BC));
464 		xps = args->bc_xprt->xpt_bc_xps;
465 		xprt_switch_get(xps);
466 	} else {
467 		xps = xprt_switch_alloc(xprt, GFP_KERNEL);
468 		if (xps == NULL) {
469 			xprt_put(xprt);
470 			return ERR_PTR(-ENOMEM);
471 		}
472 		if (xprt->bc_xprt) {
473 			xprt_switch_get(xps);
474 			xprt->bc_xprt->xpt_bc_xps = xps;
475 		}
476 	}
477 	clnt = rpc_new_client(args, xps, xprt, NULL);
478 	if (IS_ERR(clnt))
479 		return clnt;
480 
481 	if (!(args->flags & RPC_CLNT_CREATE_NOPING)) {
482 		int err = rpc_ping(clnt);
483 		if (err != 0) {
484 			rpc_shutdown_client(clnt);
485 			return ERR_PTR(err);
486 		}
487 	} else if (args->flags & RPC_CLNT_CREATE_CONNECTED) {
488 		int err = rpc_ping_noreply(clnt);
489 		if (err != 0) {
490 			rpc_shutdown_client(clnt);
491 			return ERR_PTR(err);
492 		}
493 	}
494 
495 	clnt->cl_softrtry = 1;
496 	if (args->flags & (RPC_CLNT_CREATE_HARDRTRY|RPC_CLNT_CREATE_SOFTERR)) {
497 		clnt->cl_softrtry = 0;
498 		if (args->flags & RPC_CLNT_CREATE_SOFTERR)
499 			clnt->cl_softerr = 1;
500 	}
501 
502 	if (args->flags & RPC_CLNT_CREATE_AUTOBIND)
503 		clnt->cl_autobind = 1;
504 	if (args->flags & RPC_CLNT_CREATE_NO_RETRANS_TIMEOUT)
505 		clnt->cl_noretranstimeo = 1;
506 	if (args->flags & RPC_CLNT_CREATE_DISCRTRY)
507 		clnt->cl_discrtry = 1;
508 	if (!(args->flags & RPC_CLNT_CREATE_QUIET))
509 		clnt->cl_chatty = 1;
510 
511 	return clnt;
512 }
513 
514 /**
515  * rpc_create - create an RPC client and transport with one call
516  * @args: rpc_clnt create argument structure
517  *
518  * Creates and initializes an RPC transport and an RPC client.
519  *
520  * It can ping the server in order to determine if it is up, and to see if
521  * it supports this program and version.  RPC_CLNT_CREATE_NOPING disables
522  * this behavior so asynchronous tasks can also use rpc_create.
523  */
rpc_create(struct rpc_create_args * args)524 struct rpc_clnt *rpc_create(struct rpc_create_args *args)
525 {
526 	struct rpc_xprt *xprt;
527 	struct xprt_create xprtargs = {
528 		.net = args->net,
529 		.ident = args->protocol,
530 		.srcaddr = args->saddress,
531 		.dstaddr = args->address,
532 		.addrlen = args->addrsize,
533 		.servername = args->servername,
534 		.bc_xprt = args->bc_xprt,
535 	};
536 	char servername[48];
537 	struct rpc_clnt *clnt;
538 	int i;
539 
540 	if (args->bc_xprt) {
541 		WARN_ON_ONCE(!(args->protocol & XPRT_TRANSPORT_BC));
542 		xprt = args->bc_xprt->xpt_bc_xprt;
543 		if (xprt) {
544 			xprt_get(xprt);
545 			return rpc_create_xprt(args, xprt);
546 		}
547 	}
548 
549 	if (args->flags & RPC_CLNT_CREATE_INFINITE_SLOTS)
550 		xprtargs.flags |= XPRT_CREATE_INFINITE_SLOTS;
551 	if (args->flags & RPC_CLNT_CREATE_NO_IDLE_TIMEOUT)
552 		xprtargs.flags |= XPRT_CREATE_NO_IDLE_TIMEOUT;
553 	/*
554 	 * If the caller chooses not to specify a hostname, whip
555 	 * up a string representation of the passed-in address.
556 	 */
557 	if (xprtargs.servername == NULL) {
558 		struct sockaddr_un *sun =
559 				(struct sockaddr_un *)args->address;
560 		struct sockaddr_in *sin =
561 				(struct sockaddr_in *)args->address;
562 		struct sockaddr_in6 *sin6 =
563 				(struct sockaddr_in6 *)args->address;
564 
565 		servername[0] = '\0';
566 		switch (args->address->sa_family) {
567 		case AF_LOCAL:
568 			snprintf(servername, sizeof(servername), "%s",
569 				 sun->sun_path);
570 			break;
571 		case AF_INET:
572 			snprintf(servername, sizeof(servername), "%pI4",
573 				 &sin->sin_addr.s_addr);
574 			break;
575 		case AF_INET6:
576 			snprintf(servername, sizeof(servername), "%pI6",
577 				 &sin6->sin6_addr);
578 			break;
579 		default:
580 			/* caller wants default server name, but
581 			 * address family isn't recognized. */
582 			return ERR_PTR(-EINVAL);
583 		}
584 		xprtargs.servername = servername;
585 	}
586 
587 	xprt = xprt_create_transport(&xprtargs);
588 	if (IS_ERR(xprt))
589 		return (struct rpc_clnt *)xprt;
590 
591 	/*
592 	 * By default, kernel RPC client connects from a reserved port.
593 	 * CAP_NET_BIND_SERVICE will not be set for unprivileged requesters,
594 	 * but it is always enabled for rpciod, which handles the connect
595 	 * operation.
596 	 */
597 	xprt->resvport = 1;
598 	if (args->flags & RPC_CLNT_CREATE_NONPRIVPORT)
599 		xprt->resvport = 0;
600 	xprt->reuseport = 0;
601 	if (args->flags & RPC_CLNT_CREATE_REUSEPORT)
602 		xprt->reuseport = 1;
603 
604 	clnt = rpc_create_xprt(args, xprt);
605 	if (IS_ERR(clnt) || args->nconnect <= 1)
606 		return clnt;
607 
608 	for (i = 0; i < args->nconnect - 1; i++) {
609 		if (rpc_clnt_add_xprt(clnt, &xprtargs, NULL, NULL) < 0)
610 			break;
611 	}
612 	return clnt;
613 }
614 EXPORT_SYMBOL_GPL(rpc_create);
615 
616 /*
617  * This function clones the RPC client structure. It allows us to share the
618  * same transport while varying parameters such as the authentication
619  * flavour.
620  */
__rpc_clone_client(struct rpc_create_args * args,struct rpc_clnt * clnt)621 static struct rpc_clnt *__rpc_clone_client(struct rpc_create_args *args,
622 					   struct rpc_clnt *clnt)
623 {
624 	struct rpc_xprt_switch *xps;
625 	struct rpc_xprt *xprt;
626 	struct rpc_clnt *new;
627 	int err;
628 
629 	err = -ENOMEM;
630 	rcu_read_lock();
631 	xprt = xprt_get(rcu_dereference(clnt->cl_xprt));
632 	xps = xprt_switch_get(rcu_dereference(clnt->cl_xpi.xpi_xpswitch));
633 	rcu_read_unlock();
634 	if (xprt == NULL || xps == NULL) {
635 		xprt_put(xprt);
636 		xprt_switch_put(xps);
637 		goto out_err;
638 	}
639 	args->servername = xprt->servername;
640 	args->nodename = clnt->cl_nodename;
641 
642 	new = rpc_new_client(args, xps, xprt, clnt);
643 	if (IS_ERR(new))
644 		return new;
645 
646 	/* Turn off autobind on clones */
647 	new->cl_autobind = 0;
648 	new->cl_softrtry = clnt->cl_softrtry;
649 	new->cl_softerr = clnt->cl_softerr;
650 	new->cl_noretranstimeo = clnt->cl_noretranstimeo;
651 	new->cl_discrtry = clnt->cl_discrtry;
652 	new->cl_chatty = clnt->cl_chatty;
653 	new->cl_principal = clnt->cl_principal;
654 	new->cl_max_connect = clnt->cl_max_connect;
655 	return new;
656 
657 out_err:
658 	trace_rpc_clnt_clone_err(clnt, err);
659 	return ERR_PTR(err);
660 }
661 
662 /**
663  * rpc_clone_client - Clone an RPC client structure
664  *
665  * @clnt: RPC client whose parameters are copied
666  *
667  * Returns a fresh RPC client or an ERR_PTR.
668  */
rpc_clone_client(struct rpc_clnt * clnt)669 struct rpc_clnt *rpc_clone_client(struct rpc_clnt *clnt)
670 {
671 	struct rpc_create_args args = {
672 		.program	= clnt->cl_program,
673 		.prognumber	= clnt->cl_prog,
674 		.version	= clnt->cl_vers,
675 		.authflavor	= clnt->cl_auth->au_flavor,
676 		.cred		= clnt->cl_cred,
677 	};
678 	return __rpc_clone_client(&args, clnt);
679 }
680 EXPORT_SYMBOL_GPL(rpc_clone_client);
681 
682 /**
683  * rpc_clone_client_set_auth - Clone an RPC client structure and set its auth
684  *
685  * @clnt: RPC client whose parameters are copied
686  * @flavor: security flavor for new client
687  *
688  * Returns a fresh RPC client or an ERR_PTR.
689  */
690 struct rpc_clnt *
rpc_clone_client_set_auth(struct rpc_clnt * clnt,rpc_authflavor_t flavor)691 rpc_clone_client_set_auth(struct rpc_clnt *clnt, rpc_authflavor_t flavor)
692 {
693 	struct rpc_create_args args = {
694 		.program	= clnt->cl_program,
695 		.prognumber	= clnt->cl_prog,
696 		.version	= clnt->cl_vers,
697 		.authflavor	= flavor,
698 		.cred		= clnt->cl_cred,
699 	};
700 	return __rpc_clone_client(&args, clnt);
701 }
702 EXPORT_SYMBOL_GPL(rpc_clone_client_set_auth);
703 
704 /**
705  * rpc_switch_client_transport: switch the RPC transport on the fly
706  * @clnt: pointer to a struct rpc_clnt
707  * @args: pointer to the new transport arguments
708  * @timeout: pointer to the new timeout parameters
709  *
710  * This function allows the caller to switch the RPC transport for the
711  * rpc_clnt structure 'clnt' to allow it to connect to a mirrored NFS
712  * server, for instance.  It assumes that the caller has ensured that
713  * there are no active RPC tasks by using some form of locking.
714  *
715  * Returns zero if "clnt" is now using the new xprt.  Otherwise a
716  * negative errno is returned, and "clnt" continues to use the old
717  * xprt.
718  */
rpc_switch_client_transport(struct rpc_clnt * clnt,struct xprt_create * args,const struct rpc_timeout * timeout)719 int rpc_switch_client_transport(struct rpc_clnt *clnt,
720 		struct xprt_create *args,
721 		const struct rpc_timeout *timeout)
722 {
723 	const struct rpc_timeout *old_timeo;
724 	rpc_authflavor_t pseudoflavor;
725 	struct rpc_xprt_switch *xps, *oldxps;
726 	struct rpc_xprt *xprt, *old;
727 	struct rpc_clnt *parent;
728 	int err;
729 
730 	xprt = xprt_create_transport(args);
731 	if (IS_ERR(xprt))
732 		return PTR_ERR(xprt);
733 
734 	xps = xprt_switch_alloc(xprt, GFP_KERNEL);
735 	if (xps == NULL) {
736 		xprt_put(xprt);
737 		return -ENOMEM;
738 	}
739 
740 	pseudoflavor = clnt->cl_auth->au_flavor;
741 
742 	old_timeo = clnt->cl_timeout;
743 	old = rpc_clnt_set_transport(clnt, xprt, timeout);
744 	oldxps = xprt_iter_xchg_switch(&clnt->cl_xpi, xps);
745 
746 	rpc_unregister_client(clnt);
747 	__rpc_clnt_remove_pipedir(clnt);
748 	rpc_sysfs_client_destroy(clnt);
749 	rpc_clnt_debugfs_unregister(clnt);
750 
751 	/*
752 	 * A new transport was created.  "clnt" therefore
753 	 * becomes the root of a new cl_parent tree.  clnt's
754 	 * children, if it has any, still point to the old xprt.
755 	 */
756 	parent = clnt->cl_parent;
757 	clnt->cl_parent = clnt;
758 
759 	/*
760 	 * The old rpc_auth cache cannot be re-used.  GSS
761 	 * contexts in particular are between a single
762 	 * client and server.
763 	 */
764 	err = rpc_client_register(clnt, pseudoflavor, NULL);
765 	if (err)
766 		goto out_revert;
767 
768 	synchronize_rcu();
769 	if (parent != clnt)
770 		rpc_release_client(parent);
771 	xprt_switch_put(oldxps);
772 	xprt_put(old);
773 	trace_rpc_clnt_replace_xprt(clnt);
774 	return 0;
775 
776 out_revert:
777 	xps = xprt_iter_xchg_switch(&clnt->cl_xpi, oldxps);
778 	rpc_clnt_set_transport(clnt, old, old_timeo);
779 	clnt->cl_parent = parent;
780 	rpc_client_register(clnt, pseudoflavor, NULL);
781 	xprt_switch_put(xps);
782 	xprt_put(xprt);
783 	trace_rpc_clnt_replace_xprt_err(clnt);
784 	return err;
785 }
786 EXPORT_SYMBOL_GPL(rpc_switch_client_transport);
787 
788 static
_rpc_clnt_xprt_iter_init(struct rpc_clnt * clnt,struct rpc_xprt_iter * xpi,void func (struct rpc_xprt_iter * xpi,struct rpc_xprt_switch * xps))789 int _rpc_clnt_xprt_iter_init(struct rpc_clnt *clnt, struct rpc_xprt_iter *xpi,
790 			     void func(struct rpc_xprt_iter *xpi, struct rpc_xprt_switch *xps))
791 {
792 	struct rpc_xprt_switch *xps;
793 
794 	rcu_read_lock();
795 	xps = xprt_switch_get(rcu_dereference(clnt->cl_xpi.xpi_xpswitch));
796 	rcu_read_unlock();
797 	if (xps == NULL)
798 		return -EAGAIN;
799 	func(xpi, xps);
800 	xprt_switch_put(xps);
801 	return 0;
802 }
803 
804 static
rpc_clnt_xprt_iter_init(struct rpc_clnt * clnt,struct rpc_xprt_iter * xpi)805 int rpc_clnt_xprt_iter_init(struct rpc_clnt *clnt, struct rpc_xprt_iter *xpi)
806 {
807 	return _rpc_clnt_xprt_iter_init(clnt, xpi, xprt_iter_init_listall);
808 }
809 
810 static
rpc_clnt_xprt_iter_offline_init(struct rpc_clnt * clnt,struct rpc_xprt_iter * xpi)811 int rpc_clnt_xprt_iter_offline_init(struct rpc_clnt *clnt,
812 				    struct rpc_xprt_iter *xpi)
813 {
814 	return _rpc_clnt_xprt_iter_init(clnt, xpi, xprt_iter_init_listoffline);
815 }
816 
817 /**
818  * rpc_clnt_iterate_for_each_xprt - Apply a function to all transports
819  * @clnt: pointer to client
820  * @fn: function to apply
821  * @data: void pointer to function data
822  *
823  * Iterates through the list of RPC transports currently attached to the
824  * client and applies the function fn(clnt, xprt, data).
825  *
826  * On error, the iteration stops, and the function returns the error value.
827  */
rpc_clnt_iterate_for_each_xprt(struct rpc_clnt * clnt,int (* fn)(struct rpc_clnt *,struct rpc_xprt *,void *),void * data)828 int rpc_clnt_iterate_for_each_xprt(struct rpc_clnt *clnt,
829 		int (*fn)(struct rpc_clnt *, struct rpc_xprt *, void *),
830 		void *data)
831 {
832 	struct rpc_xprt_iter xpi;
833 	int ret;
834 
835 	ret = rpc_clnt_xprt_iter_init(clnt, &xpi);
836 	if (ret)
837 		return ret;
838 	for (;;) {
839 		struct rpc_xprt *xprt = xprt_iter_get_next(&xpi);
840 
841 		if (!xprt)
842 			break;
843 		ret = fn(clnt, xprt, data);
844 		xprt_put(xprt);
845 		if (ret < 0)
846 			break;
847 	}
848 	xprt_iter_destroy(&xpi);
849 	return ret;
850 }
851 EXPORT_SYMBOL_GPL(rpc_clnt_iterate_for_each_xprt);
852 
853 /*
854  * Kill all tasks for the given client.
855  * XXX: kill their descendants as well?
856  */
rpc_killall_tasks(struct rpc_clnt * clnt)857 void rpc_killall_tasks(struct rpc_clnt *clnt)
858 {
859 	struct rpc_task	*rovr;
860 
861 
862 	if (list_empty(&clnt->cl_tasks))
863 		return;
864 
865 	/*
866 	 * Spin lock all_tasks to prevent changes...
867 	 */
868 	trace_rpc_clnt_killall(clnt);
869 	spin_lock(&clnt->cl_lock);
870 	list_for_each_entry(rovr, &clnt->cl_tasks, tk_task)
871 		rpc_signal_task(rovr);
872 	spin_unlock(&clnt->cl_lock);
873 }
874 EXPORT_SYMBOL_GPL(rpc_killall_tasks);
875 
876 /**
877  * rpc_cancel_tasks - try to cancel a set of RPC tasks
878  * @clnt: Pointer to RPC client
879  * @error: RPC task error value to set
880  * @fnmatch: Pointer to selector function
881  * @data: User data
882  *
883  * Uses @fnmatch to define a set of RPC tasks that are to be cancelled.
884  * The argument @error must be a negative error value.
885  */
rpc_cancel_tasks(struct rpc_clnt * clnt,int error,bool (* fnmatch)(const struct rpc_task *,const void *),const void * data)886 unsigned long rpc_cancel_tasks(struct rpc_clnt *clnt, int error,
887 			       bool (*fnmatch)(const struct rpc_task *,
888 					       const void *),
889 			       const void *data)
890 {
891 	struct rpc_task *task;
892 	unsigned long count = 0;
893 
894 	if (list_empty(&clnt->cl_tasks))
895 		return 0;
896 	/*
897 	 * Spin lock all_tasks to prevent changes...
898 	 */
899 	spin_lock(&clnt->cl_lock);
900 	list_for_each_entry(task, &clnt->cl_tasks, tk_task) {
901 		if (!RPC_IS_ACTIVATED(task))
902 			continue;
903 		if (!fnmatch(task, data))
904 			continue;
905 		rpc_task_try_cancel(task, error);
906 		count++;
907 	}
908 	spin_unlock(&clnt->cl_lock);
909 	return count;
910 }
911 EXPORT_SYMBOL_GPL(rpc_cancel_tasks);
912 
rpc_clnt_disconnect_xprt(struct rpc_clnt * clnt,struct rpc_xprt * xprt,void * dummy)913 static int rpc_clnt_disconnect_xprt(struct rpc_clnt *clnt,
914 				    struct rpc_xprt *xprt, void *dummy)
915 {
916 	if (xprt_connected(xprt))
917 		xprt_force_disconnect(xprt);
918 	return 0;
919 }
920 
rpc_clnt_disconnect(struct rpc_clnt * clnt)921 void rpc_clnt_disconnect(struct rpc_clnt *clnt)
922 {
923 	rpc_clnt_iterate_for_each_xprt(clnt, rpc_clnt_disconnect_xprt, NULL);
924 }
925 EXPORT_SYMBOL_GPL(rpc_clnt_disconnect);
926 
927 /*
928  * Properly shut down an RPC client, terminating all outstanding
929  * requests.
930  */
rpc_shutdown_client(struct rpc_clnt * clnt)931 void rpc_shutdown_client(struct rpc_clnt *clnt)
932 {
933 	might_sleep();
934 
935 	trace_rpc_clnt_shutdown(clnt);
936 
937 	while (!list_empty(&clnt->cl_tasks)) {
938 		rpc_killall_tasks(clnt);
939 		wait_event_timeout(destroy_wait,
940 			list_empty(&clnt->cl_tasks), 1*HZ);
941 	}
942 
943 	rpc_release_client(clnt);
944 }
945 EXPORT_SYMBOL_GPL(rpc_shutdown_client);
946 
947 /*
948  * Free an RPC client
949  */
rpc_free_client_work(struct work_struct * work)950 static void rpc_free_client_work(struct work_struct *work)
951 {
952 	struct rpc_clnt *clnt = container_of(work, struct rpc_clnt, cl_work);
953 
954 	trace_rpc_clnt_free(clnt);
955 
956 	/* These might block on processes that might allocate memory,
957 	 * so they cannot be called in rpciod, so they are handled separately
958 	 * here.
959 	 */
960 	rpc_sysfs_client_destroy(clnt);
961 	rpc_clnt_debugfs_unregister(clnt);
962 	rpc_free_clid(clnt);
963 	rpc_clnt_remove_pipedir(clnt);
964 	xprt_put(rcu_dereference_raw(clnt->cl_xprt));
965 
966 	kfree(clnt);
967 	rpciod_down();
968 }
969 static struct rpc_clnt *
rpc_free_client(struct rpc_clnt * clnt)970 rpc_free_client(struct rpc_clnt *clnt)
971 {
972 	struct rpc_clnt *parent = NULL;
973 
974 	trace_rpc_clnt_release(clnt);
975 	if (clnt->cl_parent != clnt)
976 		parent = clnt->cl_parent;
977 	rpc_unregister_client(clnt);
978 	rpc_free_iostats(clnt->cl_metrics);
979 	clnt->cl_metrics = NULL;
980 	xprt_iter_destroy(&clnt->cl_xpi);
981 	put_cred(clnt->cl_cred);
982 
983 	INIT_WORK(&clnt->cl_work, rpc_free_client_work);
984 	schedule_work(&clnt->cl_work);
985 	return parent;
986 }
987 
988 /*
989  * Free an RPC client
990  */
991 static struct rpc_clnt *
rpc_free_auth(struct rpc_clnt * clnt)992 rpc_free_auth(struct rpc_clnt *clnt)
993 {
994 	/*
995 	 * Note: RPCSEC_GSS may need to send NULL RPC calls in order to
996 	 *       release remaining GSS contexts. This mechanism ensures
997 	 *       that it can do so safely.
998 	 */
999 	if (clnt->cl_auth != NULL) {
1000 		rpcauth_release(clnt->cl_auth);
1001 		clnt->cl_auth = NULL;
1002 	}
1003 	if (refcount_dec_and_test(&clnt->cl_count))
1004 		return rpc_free_client(clnt);
1005 	return NULL;
1006 }
1007 
1008 /*
1009  * Release reference to the RPC client
1010  */
1011 void
rpc_release_client(struct rpc_clnt * clnt)1012 rpc_release_client(struct rpc_clnt *clnt)
1013 {
1014 	do {
1015 		if (list_empty(&clnt->cl_tasks))
1016 			wake_up(&destroy_wait);
1017 		if (refcount_dec_not_one(&clnt->cl_count))
1018 			break;
1019 		clnt = rpc_free_auth(clnt);
1020 	} while (clnt != NULL);
1021 }
1022 EXPORT_SYMBOL_GPL(rpc_release_client);
1023 
1024 /**
1025  * rpc_bind_new_program - bind a new RPC program to an existing client
1026  * @old: old rpc_client
1027  * @program: rpc program to set
1028  * @vers: rpc program version
1029  *
1030  * Clones the rpc client and sets up a new RPC program. This is mainly
1031  * of use for enabling different RPC programs to share the same transport.
1032  * The Sun NFSv2/v3 ACL protocol can do this.
1033  */
rpc_bind_new_program(struct rpc_clnt * old,const struct rpc_program * program,u32 vers)1034 struct rpc_clnt *rpc_bind_new_program(struct rpc_clnt *old,
1035 				      const struct rpc_program *program,
1036 				      u32 vers)
1037 {
1038 	struct rpc_create_args args = {
1039 		.program	= program,
1040 		.prognumber	= program->number,
1041 		.version	= vers,
1042 		.authflavor	= old->cl_auth->au_flavor,
1043 		.cred		= old->cl_cred,
1044 	};
1045 	struct rpc_clnt *clnt;
1046 	int err;
1047 
1048 	clnt = __rpc_clone_client(&args, old);
1049 	if (IS_ERR(clnt))
1050 		goto out;
1051 	err = rpc_ping(clnt);
1052 	if (err != 0) {
1053 		rpc_shutdown_client(clnt);
1054 		clnt = ERR_PTR(err);
1055 	}
1056 out:
1057 	return clnt;
1058 }
1059 EXPORT_SYMBOL_GPL(rpc_bind_new_program);
1060 
1061 struct rpc_xprt *
rpc_task_get_xprt(struct rpc_clnt * clnt,struct rpc_xprt * xprt)1062 rpc_task_get_xprt(struct rpc_clnt *clnt, struct rpc_xprt *xprt)
1063 {
1064 	struct rpc_xprt_switch *xps;
1065 
1066 	if (!xprt)
1067 		return NULL;
1068 	rcu_read_lock();
1069 	xps = rcu_dereference(clnt->cl_xpi.xpi_xpswitch);
1070 	atomic_long_inc(&xps->xps_queuelen);
1071 	rcu_read_unlock();
1072 	atomic_long_inc(&xprt->queuelen);
1073 
1074 	return xprt;
1075 }
1076 
1077 static void
rpc_task_release_xprt(struct rpc_clnt * clnt,struct rpc_xprt * xprt)1078 rpc_task_release_xprt(struct rpc_clnt *clnt, struct rpc_xprt *xprt)
1079 {
1080 	struct rpc_xprt_switch *xps;
1081 
1082 	atomic_long_dec(&xprt->queuelen);
1083 	rcu_read_lock();
1084 	xps = rcu_dereference(clnt->cl_xpi.xpi_xpswitch);
1085 	atomic_long_dec(&xps->xps_queuelen);
1086 	rcu_read_unlock();
1087 
1088 	xprt_put(xprt);
1089 }
1090 
rpc_task_release_transport(struct rpc_task * task)1091 void rpc_task_release_transport(struct rpc_task *task)
1092 {
1093 	struct rpc_xprt *xprt = task->tk_xprt;
1094 
1095 	if (xprt) {
1096 		task->tk_xprt = NULL;
1097 		if (task->tk_client)
1098 			rpc_task_release_xprt(task->tk_client, xprt);
1099 		else
1100 			xprt_put(xprt);
1101 	}
1102 }
1103 EXPORT_SYMBOL_GPL(rpc_task_release_transport);
1104 
rpc_task_release_client(struct rpc_task * task)1105 void rpc_task_release_client(struct rpc_task *task)
1106 {
1107 	struct rpc_clnt *clnt = task->tk_client;
1108 
1109 	rpc_task_release_transport(task);
1110 	if (clnt != NULL) {
1111 		/* Remove from client task list */
1112 		spin_lock(&clnt->cl_lock);
1113 		list_del(&task->tk_task);
1114 		spin_unlock(&clnt->cl_lock);
1115 		task->tk_client = NULL;
1116 
1117 		rpc_release_client(clnt);
1118 	}
1119 }
1120 
1121 static struct rpc_xprt *
rpc_task_get_first_xprt(struct rpc_clnt * clnt)1122 rpc_task_get_first_xprt(struct rpc_clnt *clnt)
1123 {
1124 	struct rpc_xprt *xprt;
1125 
1126 	rcu_read_lock();
1127 	xprt = xprt_get(rcu_dereference(clnt->cl_xprt));
1128 	rcu_read_unlock();
1129 	return rpc_task_get_xprt(clnt, xprt);
1130 }
1131 
1132 static struct rpc_xprt *
rpc_task_get_next_xprt(struct rpc_clnt * clnt)1133 rpc_task_get_next_xprt(struct rpc_clnt *clnt)
1134 {
1135 	return rpc_task_get_xprt(clnt, xprt_iter_get_next(&clnt->cl_xpi));
1136 }
1137 
1138 static
rpc_task_set_transport(struct rpc_task * task,struct rpc_clnt * clnt)1139 void rpc_task_set_transport(struct rpc_task *task, struct rpc_clnt *clnt)
1140 {
1141 	if (task->tk_xprt) {
1142 		if (!(test_bit(XPRT_OFFLINE, &task->tk_xprt->state) &&
1143 		      (task->tk_flags & RPC_TASK_MOVEABLE)))
1144 			return;
1145 		xprt_release(task);
1146 		xprt_put(task->tk_xprt);
1147 	}
1148 	if (task->tk_flags & RPC_TASK_NO_ROUND_ROBIN)
1149 		task->tk_xprt = rpc_task_get_first_xprt(clnt);
1150 	else
1151 		task->tk_xprt = rpc_task_get_next_xprt(clnt);
1152 }
1153 
1154 static
rpc_task_set_client(struct rpc_task * task,struct rpc_clnt * clnt)1155 void rpc_task_set_client(struct rpc_task *task, struct rpc_clnt *clnt)
1156 {
1157 	rpc_task_set_transport(task, clnt);
1158 	task->tk_client = clnt;
1159 	refcount_inc(&clnt->cl_count);
1160 	if (clnt->cl_softrtry)
1161 		task->tk_flags |= RPC_TASK_SOFT;
1162 	if (clnt->cl_softerr)
1163 		task->tk_flags |= RPC_TASK_TIMEOUT;
1164 	if (clnt->cl_noretranstimeo)
1165 		task->tk_flags |= RPC_TASK_NO_RETRANS_TIMEOUT;
1166 	/* Add to the client's list of all tasks */
1167 	spin_lock(&clnt->cl_lock);
1168 	list_add_tail(&task->tk_task, &clnt->cl_tasks);
1169 	spin_unlock(&clnt->cl_lock);
1170 }
1171 
1172 static void
rpc_task_set_rpc_message(struct rpc_task * task,const struct rpc_message * msg)1173 rpc_task_set_rpc_message(struct rpc_task *task, const struct rpc_message *msg)
1174 {
1175 	if (msg != NULL) {
1176 		task->tk_msg.rpc_proc = msg->rpc_proc;
1177 		task->tk_msg.rpc_argp = msg->rpc_argp;
1178 		task->tk_msg.rpc_resp = msg->rpc_resp;
1179 		task->tk_msg.rpc_cred = msg->rpc_cred;
1180 		if (!(task->tk_flags & RPC_TASK_CRED_NOREF))
1181 			get_cred(task->tk_msg.rpc_cred);
1182 	}
1183 }
1184 
1185 /*
1186  * Default callback for async RPC calls
1187  */
1188 static void
rpc_default_callback(struct rpc_task * task,void * data)1189 rpc_default_callback(struct rpc_task *task, void *data)
1190 {
1191 }
1192 
1193 static const struct rpc_call_ops rpc_default_ops = {
1194 	.rpc_call_done = rpc_default_callback,
1195 };
1196 
1197 /**
1198  * rpc_run_task - Allocate a new RPC task, then run rpc_execute against it
1199  * @task_setup_data: pointer to task initialisation data
1200  */
rpc_run_task(const struct rpc_task_setup * task_setup_data)1201 struct rpc_task *rpc_run_task(const struct rpc_task_setup *task_setup_data)
1202 {
1203 	struct rpc_task *task;
1204 
1205 	task = rpc_new_task(task_setup_data);
1206 	if (IS_ERR(task))
1207 		return task;
1208 
1209 	if (!RPC_IS_ASYNC(task))
1210 		task->tk_flags |= RPC_TASK_CRED_NOREF;
1211 
1212 	rpc_task_set_client(task, task_setup_data->rpc_client);
1213 	rpc_task_set_rpc_message(task, task_setup_data->rpc_message);
1214 
1215 	if (task->tk_action == NULL)
1216 		rpc_call_start(task);
1217 
1218 	atomic_inc(&task->tk_count);
1219 	rpc_execute(task);
1220 	return task;
1221 }
1222 EXPORT_SYMBOL_GPL(rpc_run_task);
1223 
1224 /**
1225  * rpc_call_sync - Perform a synchronous RPC call
1226  * @clnt: pointer to RPC client
1227  * @msg: RPC call parameters
1228  * @flags: RPC call flags
1229  */
rpc_call_sync(struct rpc_clnt * clnt,const struct rpc_message * msg,int flags)1230 int rpc_call_sync(struct rpc_clnt *clnt, const struct rpc_message *msg, int flags)
1231 {
1232 	struct rpc_task	*task;
1233 	struct rpc_task_setup task_setup_data = {
1234 		.rpc_client = clnt,
1235 		.rpc_message = msg,
1236 		.callback_ops = &rpc_default_ops,
1237 		.flags = flags,
1238 	};
1239 	int status;
1240 
1241 	WARN_ON_ONCE(flags & RPC_TASK_ASYNC);
1242 	if (flags & RPC_TASK_ASYNC) {
1243 		rpc_release_calldata(task_setup_data.callback_ops,
1244 			task_setup_data.callback_data);
1245 		return -EINVAL;
1246 	}
1247 
1248 	task = rpc_run_task(&task_setup_data);
1249 	if (IS_ERR(task))
1250 		return PTR_ERR(task);
1251 	status = task->tk_status;
1252 	rpc_put_task(task);
1253 	return status;
1254 }
1255 EXPORT_SYMBOL_GPL(rpc_call_sync);
1256 
1257 /**
1258  * rpc_call_async - Perform an asynchronous RPC call
1259  * @clnt: pointer to RPC client
1260  * @msg: RPC call parameters
1261  * @flags: RPC call flags
1262  * @tk_ops: RPC call ops
1263  * @data: user call data
1264  */
1265 int
rpc_call_async(struct rpc_clnt * clnt,const struct rpc_message * msg,int flags,const struct rpc_call_ops * tk_ops,void * data)1266 rpc_call_async(struct rpc_clnt *clnt, const struct rpc_message *msg, int flags,
1267 	       const struct rpc_call_ops *tk_ops, void *data)
1268 {
1269 	struct rpc_task	*task;
1270 	struct rpc_task_setup task_setup_data = {
1271 		.rpc_client = clnt,
1272 		.rpc_message = msg,
1273 		.callback_ops = tk_ops,
1274 		.callback_data = data,
1275 		.flags = flags|RPC_TASK_ASYNC,
1276 	};
1277 
1278 	task = rpc_run_task(&task_setup_data);
1279 	if (IS_ERR(task))
1280 		return PTR_ERR(task);
1281 	rpc_put_task(task);
1282 	return 0;
1283 }
1284 EXPORT_SYMBOL_GPL(rpc_call_async);
1285 
1286 #if defined(CONFIG_SUNRPC_BACKCHANNEL)
1287 static void call_bc_encode(struct rpc_task *task);
1288 
1289 /**
1290  * rpc_run_bc_task - Allocate a new RPC task for backchannel use, then run
1291  * rpc_execute against it
1292  * @req: RPC request
1293  */
rpc_run_bc_task(struct rpc_rqst * req)1294 struct rpc_task *rpc_run_bc_task(struct rpc_rqst *req)
1295 {
1296 	struct rpc_task *task;
1297 	struct rpc_task_setup task_setup_data = {
1298 		.callback_ops = &rpc_default_ops,
1299 		.flags = RPC_TASK_SOFTCONN |
1300 			RPC_TASK_NO_RETRANS_TIMEOUT,
1301 	};
1302 
1303 	dprintk("RPC: rpc_run_bc_task req= %p\n", req);
1304 	/*
1305 	 * Create an rpc_task to send the data
1306 	 */
1307 	task = rpc_new_task(&task_setup_data);
1308 	if (IS_ERR(task)) {
1309 		xprt_free_bc_request(req);
1310 		return task;
1311 	}
1312 
1313 	xprt_init_bc_request(req, task);
1314 
1315 	task->tk_action = call_bc_encode;
1316 	atomic_inc(&task->tk_count);
1317 	WARN_ON_ONCE(atomic_read(&task->tk_count) != 2);
1318 	rpc_execute(task);
1319 
1320 	dprintk("RPC: rpc_run_bc_task: task= %p\n", task);
1321 	return task;
1322 }
1323 #endif /* CONFIG_SUNRPC_BACKCHANNEL */
1324 
1325 /**
1326  * rpc_prepare_reply_pages - Prepare to receive a reply data payload into pages
1327  * @req: RPC request to prepare
1328  * @pages: vector of struct page pointers
1329  * @base: offset in first page where receive should start, in bytes
1330  * @len: expected size of the upper layer data payload, in bytes
1331  * @hdrsize: expected size of upper layer reply header, in XDR words
1332  *
1333  */
rpc_prepare_reply_pages(struct rpc_rqst * req,struct page ** pages,unsigned int base,unsigned int len,unsigned int hdrsize)1334 void rpc_prepare_reply_pages(struct rpc_rqst *req, struct page **pages,
1335 			     unsigned int base, unsigned int len,
1336 			     unsigned int hdrsize)
1337 {
1338 	hdrsize += RPC_REPHDRSIZE + req->rq_cred->cr_auth->au_ralign;
1339 
1340 	xdr_inline_pages(&req->rq_rcv_buf, hdrsize << 2, pages, base, len);
1341 	trace_rpc_xdr_reply_pages(req->rq_task, &req->rq_rcv_buf);
1342 }
1343 EXPORT_SYMBOL_GPL(rpc_prepare_reply_pages);
1344 
1345 void
rpc_call_start(struct rpc_task * task)1346 rpc_call_start(struct rpc_task *task)
1347 {
1348 	task->tk_action = call_start;
1349 }
1350 EXPORT_SYMBOL_GPL(rpc_call_start);
1351 
1352 /**
1353  * rpc_peeraddr - extract remote peer address from clnt's xprt
1354  * @clnt: RPC client structure
1355  * @buf: target buffer
1356  * @bufsize: length of target buffer
1357  *
1358  * Returns the number of bytes that are actually in the stored address.
1359  */
rpc_peeraddr(struct rpc_clnt * clnt,struct sockaddr * buf,size_t bufsize)1360 size_t rpc_peeraddr(struct rpc_clnt *clnt, struct sockaddr *buf, size_t bufsize)
1361 {
1362 	size_t bytes;
1363 	struct rpc_xprt *xprt;
1364 
1365 	rcu_read_lock();
1366 	xprt = rcu_dereference(clnt->cl_xprt);
1367 
1368 	bytes = xprt->addrlen;
1369 	if (bytes > bufsize)
1370 		bytes = bufsize;
1371 	memcpy(buf, &xprt->addr, bytes);
1372 	rcu_read_unlock();
1373 
1374 	return bytes;
1375 }
1376 EXPORT_SYMBOL_GPL(rpc_peeraddr);
1377 
1378 /**
1379  * rpc_peeraddr2str - return remote peer address in printable format
1380  * @clnt: RPC client structure
1381  * @format: address format
1382  *
1383  * NB: the lifetime of the memory referenced by the returned pointer is
1384  * the same as the rpc_xprt itself.  As long as the caller uses this
1385  * pointer, it must hold the RCU read lock.
1386  */
rpc_peeraddr2str(struct rpc_clnt * clnt,enum rpc_display_format_t format)1387 const char *rpc_peeraddr2str(struct rpc_clnt *clnt,
1388 			     enum rpc_display_format_t format)
1389 {
1390 	struct rpc_xprt *xprt;
1391 
1392 	xprt = rcu_dereference(clnt->cl_xprt);
1393 
1394 	if (xprt->address_strings[format] != NULL)
1395 		return xprt->address_strings[format];
1396 	else
1397 		return "unprintable";
1398 }
1399 EXPORT_SYMBOL_GPL(rpc_peeraddr2str);
1400 
1401 static const struct sockaddr_in rpc_inaddr_loopback = {
1402 	.sin_family		= AF_INET,
1403 	.sin_addr.s_addr	= htonl(INADDR_ANY),
1404 };
1405 
1406 static const struct sockaddr_in6 rpc_in6addr_loopback = {
1407 	.sin6_family		= AF_INET6,
1408 	.sin6_addr		= IN6ADDR_ANY_INIT,
1409 };
1410 
1411 /*
1412  * Try a getsockname() on a connected datagram socket.  Using a
1413  * connected datagram socket prevents leaving a socket in TIME_WAIT.
1414  * This conserves the ephemeral port number space.
1415  *
1416  * Returns zero and fills in "buf" if successful; otherwise, a
1417  * negative errno is returned.
1418  */
rpc_sockname(struct net * net,struct sockaddr * sap,size_t salen,struct sockaddr * buf)1419 static int rpc_sockname(struct net *net, struct sockaddr *sap, size_t salen,
1420 			struct sockaddr *buf)
1421 {
1422 	struct socket *sock;
1423 	int err;
1424 
1425 	err = __sock_create(net, sap->sa_family,
1426 				SOCK_DGRAM, IPPROTO_UDP, &sock, 1);
1427 	if (err < 0) {
1428 		dprintk("RPC:       can't create UDP socket (%d)\n", err);
1429 		goto out;
1430 	}
1431 
1432 	switch (sap->sa_family) {
1433 	case AF_INET:
1434 		err = kernel_bind(sock,
1435 				(struct sockaddr *)&rpc_inaddr_loopback,
1436 				sizeof(rpc_inaddr_loopback));
1437 		break;
1438 	case AF_INET6:
1439 		err = kernel_bind(sock,
1440 				(struct sockaddr *)&rpc_in6addr_loopback,
1441 				sizeof(rpc_in6addr_loopback));
1442 		break;
1443 	default:
1444 		err = -EAFNOSUPPORT;
1445 		goto out_release;
1446 	}
1447 	if (err < 0) {
1448 		dprintk("RPC:       can't bind UDP socket (%d)\n", err);
1449 		goto out_release;
1450 	}
1451 
1452 	err = kernel_connect(sock, sap, salen, 0);
1453 	if (err < 0) {
1454 		dprintk("RPC:       can't connect UDP socket (%d)\n", err);
1455 		goto out_release;
1456 	}
1457 
1458 	err = kernel_getsockname(sock, buf);
1459 	if (err < 0) {
1460 		dprintk("RPC:       getsockname failed (%d)\n", err);
1461 		goto out_release;
1462 	}
1463 
1464 	err = 0;
1465 	if (buf->sa_family == AF_INET6) {
1466 		struct sockaddr_in6 *sin6 = (struct sockaddr_in6 *)buf;
1467 		sin6->sin6_scope_id = 0;
1468 	}
1469 	dprintk("RPC:       %s succeeded\n", __func__);
1470 
1471 out_release:
1472 	sock_release(sock);
1473 out:
1474 	return err;
1475 }
1476 
1477 /*
1478  * Scraping a connected socket failed, so we don't have a useable
1479  * local address.  Fallback: generate an address that will prevent
1480  * the server from calling us back.
1481  *
1482  * Returns zero and fills in "buf" if successful; otherwise, a
1483  * negative errno is returned.
1484  */
rpc_anyaddr(int family,struct sockaddr * buf,size_t buflen)1485 static int rpc_anyaddr(int family, struct sockaddr *buf, size_t buflen)
1486 {
1487 	switch (family) {
1488 	case AF_INET:
1489 		if (buflen < sizeof(rpc_inaddr_loopback))
1490 			return -EINVAL;
1491 		memcpy(buf, &rpc_inaddr_loopback,
1492 				sizeof(rpc_inaddr_loopback));
1493 		break;
1494 	case AF_INET6:
1495 		if (buflen < sizeof(rpc_in6addr_loopback))
1496 			return -EINVAL;
1497 		memcpy(buf, &rpc_in6addr_loopback,
1498 				sizeof(rpc_in6addr_loopback));
1499 		break;
1500 	default:
1501 		dprintk("RPC:       %s: address family not supported\n",
1502 			__func__);
1503 		return -EAFNOSUPPORT;
1504 	}
1505 	dprintk("RPC:       %s: succeeded\n", __func__);
1506 	return 0;
1507 }
1508 
1509 /**
1510  * rpc_localaddr - discover local endpoint address for an RPC client
1511  * @clnt: RPC client structure
1512  * @buf: target buffer
1513  * @buflen: size of target buffer, in bytes
1514  *
1515  * Returns zero and fills in "buf" and "buflen" if successful;
1516  * otherwise, a negative errno is returned.
1517  *
1518  * This works even if the underlying transport is not currently connected,
1519  * or if the upper layer never previously provided a source address.
1520  *
1521  * The result of this function call is transient: multiple calls in
1522  * succession may give different results, depending on how local
1523  * networking configuration changes over time.
1524  */
rpc_localaddr(struct rpc_clnt * clnt,struct sockaddr * buf,size_t buflen)1525 int rpc_localaddr(struct rpc_clnt *clnt, struct sockaddr *buf, size_t buflen)
1526 {
1527 	struct sockaddr_storage address;
1528 	struct sockaddr *sap = (struct sockaddr *)&address;
1529 	struct rpc_xprt *xprt;
1530 	struct net *net;
1531 	size_t salen;
1532 	int err;
1533 
1534 	rcu_read_lock();
1535 	xprt = rcu_dereference(clnt->cl_xprt);
1536 	salen = xprt->addrlen;
1537 	memcpy(sap, &xprt->addr, salen);
1538 	net = get_net(xprt->xprt_net);
1539 	rcu_read_unlock();
1540 
1541 	rpc_set_port(sap, 0);
1542 	err = rpc_sockname(net, sap, salen, buf);
1543 	put_net(net);
1544 	if (err != 0)
1545 		/* Couldn't discover local address, return ANYADDR */
1546 		return rpc_anyaddr(sap->sa_family, buf, buflen);
1547 	return 0;
1548 }
1549 EXPORT_SYMBOL_GPL(rpc_localaddr);
1550 
1551 void
rpc_setbufsize(struct rpc_clnt * clnt,unsigned int sndsize,unsigned int rcvsize)1552 rpc_setbufsize(struct rpc_clnt *clnt, unsigned int sndsize, unsigned int rcvsize)
1553 {
1554 	struct rpc_xprt *xprt;
1555 
1556 	rcu_read_lock();
1557 	xprt = rcu_dereference(clnt->cl_xprt);
1558 	if (xprt->ops->set_buffer_size)
1559 		xprt->ops->set_buffer_size(xprt, sndsize, rcvsize);
1560 	rcu_read_unlock();
1561 }
1562 EXPORT_SYMBOL_GPL(rpc_setbufsize);
1563 
1564 /**
1565  * rpc_net_ns - Get the network namespace for this RPC client
1566  * @clnt: RPC client to query
1567  *
1568  */
rpc_net_ns(struct rpc_clnt * clnt)1569 struct net *rpc_net_ns(struct rpc_clnt *clnt)
1570 {
1571 	struct net *ret;
1572 
1573 	rcu_read_lock();
1574 	ret = rcu_dereference(clnt->cl_xprt)->xprt_net;
1575 	rcu_read_unlock();
1576 	return ret;
1577 }
1578 EXPORT_SYMBOL_GPL(rpc_net_ns);
1579 
1580 /**
1581  * rpc_max_payload - Get maximum payload size for a transport, in bytes
1582  * @clnt: RPC client to query
1583  *
1584  * For stream transports, this is one RPC record fragment (see RFC
1585  * 1831), as we don't support multi-record requests yet.  For datagram
1586  * transports, this is the size of an IP packet minus the IP, UDP, and
1587  * RPC header sizes.
1588  */
rpc_max_payload(struct rpc_clnt * clnt)1589 size_t rpc_max_payload(struct rpc_clnt *clnt)
1590 {
1591 	size_t ret;
1592 
1593 	rcu_read_lock();
1594 	ret = rcu_dereference(clnt->cl_xprt)->max_payload;
1595 	rcu_read_unlock();
1596 	return ret;
1597 }
1598 EXPORT_SYMBOL_GPL(rpc_max_payload);
1599 
1600 /**
1601  * rpc_max_bc_payload - Get maximum backchannel payload size, in bytes
1602  * @clnt: RPC client to query
1603  */
rpc_max_bc_payload(struct rpc_clnt * clnt)1604 size_t rpc_max_bc_payload(struct rpc_clnt *clnt)
1605 {
1606 	struct rpc_xprt *xprt;
1607 	size_t ret;
1608 
1609 	rcu_read_lock();
1610 	xprt = rcu_dereference(clnt->cl_xprt);
1611 	ret = xprt->ops->bc_maxpayload(xprt);
1612 	rcu_read_unlock();
1613 	return ret;
1614 }
1615 EXPORT_SYMBOL_GPL(rpc_max_bc_payload);
1616 
rpc_num_bc_slots(struct rpc_clnt * clnt)1617 unsigned int rpc_num_bc_slots(struct rpc_clnt *clnt)
1618 {
1619 	struct rpc_xprt *xprt;
1620 	unsigned int ret;
1621 
1622 	rcu_read_lock();
1623 	xprt = rcu_dereference(clnt->cl_xprt);
1624 	ret = xprt->ops->bc_num_slots(xprt);
1625 	rcu_read_unlock();
1626 	return ret;
1627 }
1628 EXPORT_SYMBOL_GPL(rpc_num_bc_slots);
1629 
1630 /**
1631  * rpc_force_rebind - force transport to check that remote port is unchanged
1632  * @clnt: client to rebind
1633  *
1634  */
rpc_force_rebind(struct rpc_clnt * clnt)1635 void rpc_force_rebind(struct rpc_clnt *clnt)
1636 {
1637 	if (clnt->cl_autobind) {
1638 		rcu_read_lock();
1639 		xprt_clear_bound(rcu_dereference(clnt->cl_xprt));
1640 		rcu_read_unlock();
1641 	}
1642 }
1643 EXPORT_SYMBOL_GPL(rpc_force_rebind);
1644 
1645 static int
__rpc_restart_call(struct rpc_task * task,void (* action)(struct rpc_task *))1646 __rpc_restart_call(struct rpc_task *task, void (*action)(struct rpc_task *))
1647 {
1648 	task->tk_status = 0;
1649 	task->tk_rpc_status = 0;
1650 	task->tk_action = action;
1651 	return 1;
1652 }
1653 
1654 /*
1655  * Restart an (async) RPC call. Usually called from within the
1656  * exit handler.
1657  */
1658 int
rpc_restart_call(struct rpc_task * task)1659 rpc_restart_call(struct rpc_task *task)
1660 {
1661 	return __rpc_restart_call(task, call_start);
1662 }
1663 EXPORT_SYMBOL_GPL(rpc_restart_call);
1664 
1665 /*
1666  * Restart an (async) RPC call from the call_prepare state.
1667  * Usually called from within the exit handler.
1668  */
1669 int
rpc_restart_call_prepare(struct rpc_task * task)1670 rpc_restart_call_prepare(struct rpc_task *task)
1671 {
1672 	if (task->tk_ops->rpc_call_prepare != NULL)
1673 		return __rpc_restart_call(task, rpc_prepare_task);
1674 	return rpc_restart_call(task);
1675 }
1676 EXPORT_SYMBOL_GPL(rpc_restart_call_prepare);
1677 
1678 const char
rpc_proc_name(const struct rpc_task * task)1679 *rpc_proc_name(const struct rpc_task *task)
1680 {
1681 	const struct rpc_procinfo *proc = task->tk_msg.rpc_proc;
1682 
1683 	if (proc) {
1684 		if (proc->p_name)
1685 			return proc->p_name;
1686 		else
1687 			return "NULL";
1688 	} else
1689 		return "no proc";
1690 }
1691 
1692 static void
__rpc_call_rpcerror(struct rpc_task * task,int tk_status,int rpc_status)1693 __rpc_call_rpcerror(struct rpc_task *task, int tk_status, int rpc_status)
1694 {
1695 	trace_rpc_call_rpcerror(task, tk_status, rpc_status);
1696 	rpc_task_set_rpc_status(task, rpc_status);
1697 	rpc_exit(task, tk_status);
1698 }
1699 
1700 static void
rpc_call_rpcerror(struct rpc_task * task,int status)1701 rpc_call_rpcerror(struct rpc_task *task, int status)
1702 {
1703 	__rpc_call_rpcerror(task, status, status);
1704 }
1705 
1706 /*
1707  * 0.  Initial state
1708  *
1709  *     Other FSM states can be visited zero or more times, but
1710  *     this state is visited exactly once for each RPC.
1711  */
1712 static void
call_start(struct rpc_task * task)1713 call_start(struct rpc_task *task)
1714 {
1715 	struct rpc_clnt	*clnt = task->tk_client;
1716 	int idx = task->tk_msg.rpc_proc->p_statidx;
1717 
1718 	trace_rpc_request(task);
1719 
1720 	/* Increment call count (version might not be valid for ping) */
1721 	if (clnt->cl_program->version[clnt->cl_vers])
1722 		clnt->cl_program->version[clnt->cl_vers]->counts[idx]++;
1723 	clnt->cl_stats->rpccnt++;
1724 	task->tk_action = call_reserve;
1725 	rpc_task_set_transport(task, clnt);
1726 }
1727 
1728 /*
1729  * 1.	Reserve an RPC call slot
1730  */
1731 static void
call_reserve(struct rpc_task * task)1732 call_reserve(struct rpc_task *task)
1733 {
1734 	task->tk_status  = 0;
1735 	task->tk_action  = call_reserveresult;
1736 	xprt_reserve(task);
1737 }
1738 
1739 static void call_retry_reserve(struct rpc_task *task);
1740 
1741 /*
1742  * 1b.	Grok the result of xprt_reserve()
1743  */
1744 static void
call_reserveresult(struct rpc_task * task)1745 call_reserveresult(struct rpc_task *task)
1746 {
1747 	int status = task->tk_status;
1748 
1749 	/*
1750 	 * After a call to xprt_reserve(), we must have either
1751 	 * a request slot or else an error status.
1752 	 */
1753 	task->tk_status = 0;
1754 	if (status >= 0) {
1755 		if (task->tk_rqstp) {
1756 			task->tk_action = call_refresh;
1757 			return;
1758 		}
1759 
1760 		rpc_call_rpcerror(task, -EIO);
1761 		return;
1762 	}
1763 
1764 	switch (status) {
1765 	case -ENOMEM:
1766 		rpc_delay(task, HZ >> 2);
1767 		fallthrough;
1768 	case -EAGAIN:	/* woken up; retry */
1769 		task->tk_action = call_retry_reserve;
1770 		return;
1771 	default:
1772 		rpc_call_rpcerror(task, status);
1773 	}
1774 }
1775 
1776 /*
1777  * 1c.	Retry reserving an RPC call slot
1778  */
1779 static void
call_retry_reserve(struct rpc_task * task)1780 call_retry_reserve(struct rpc_task *task)
1781 {
1782 	task->tk_status  = 0;
1783 	task->tk_action  = call_reserveresult;
1784 	xprt_retry_reserve(task);
1785 }
1786 
1787 /*
1788  * 2.	Bind and/or refresh the credentials
1789  */
1790 static void
call_refresh(struct rpc_task * task)1791 call_refresh(struct rpc_task *task)
1792 {
1793 	task->tk_action = call_refreshresult;
1794 	task->tk_status = 0;
1795 	task->tk_client->cl_stats->rpcauthrefresh++;
1796 	rpcauth_refreshcred(task);
1797 }
1798 
1799 /*
1800  * 2a.	Process the results of a credential refresh
1801  */
1802 static void
call_refreshresult(struct rpc_task * task)1803 call_refreshresult(struct rpc_task *task)
1804 {
1805 	int status = task->tk_status;
1806 
1807 	task->tk_status = 0;
1808 	task->tk_action = call_refresh;
1809 	switch (status) {
1810 	case 0:
1811 		if (rpcauth_uptodatecred(task)) {
1812 			task->tk_action = call_allocate;
1813 			return;
1814 		}
1815 		/* Use rate-limiting and a max number of retries if refresh
1816 		 * had status 0 but failed to update the cred.
1817 		 */
1818 		fallthrough;
1819 	case -ETIMEDOUT:
1820 		rpc_delay(task, 3*HZ);
1821 		fallthrough;
1822 	case -EAGAIN:
1823 		status = -EACCES;
1824 		fallthrough;
1825 	case -EKEYEXPIRED:
1826 		if (!task->tk_cred_retry)
1827 			break;
1828 		task->tk_cred_retry--;
1829 		trace_rpc_retry_refresh_status(task);
1830 		return;
1831 	case -ENOMEM:
1832 		rpc_delay(task, HZ >> 4);
1833 		return;
1834 	}
1835 	trace_rpc_refresh_status(task);
1836 	rpc_call_rpcerror(task, status);
1837 }
1838 
1839 /*
1840  * 2b.	Allocate the buffer. For details, see sched.c:rpc_malloc.
1841  *	(Note: buffer memory is freed in xprt_release).
1842  */
1843 static void
call_allocate(struct rpc_task * task)1844 call_allocate(struct rpc_task *task)
1845 {
1846 	const struct rpc_auth *auth = task->tk_rqstp->rq_cred->cr_auth;
1847 	struct rpc_rqst *req = task->tk_rqstp;
1848 	struct rpc_xprt *xprt = req->rq_xprt;
1849 	const struct rpc_procinfo *proc = task->tk_msg.rpc_proc;
1850 	int status;
1851 
1852 	task->tk_status = 0;
1853 	task->tk_action = call_encode;
1854 
1855 	if (req->rq_buffer)
1856 		return;
1857 
1858 	if (proc->p_proc != 0) {
1859 		BUG_ON(proc->p_arglen == 0);
1860 		if (proc->p_decode != NULL)
1861 			BUG_ON(proc->p_replen == 0);
1862 	}
1863 
1864 	/*
1865 	 * Calculate the size (in quads) of the RPC call
1866 	 * and reply headers, and convert both values
1867 	 * to byte sizes.
1868 	 */
1869 	req->rq_callsize = RPC_CALLHDRSIZE + (auth->au_cslack << 1) +
1870 			   proc->p_arglen;
1871 	req->rq_callsize <<= 2;
1872 	/*
1873 	 * Note: the reply buffer must at minimum allocate enough space
1874 	 * for the 'struct accepted_reply' from RFC5531.
1875 	 */
1876 	req->rq_rcvsize = RPC_REPHDRSIZE + auth->au_rslack + \
1877 			max_t(size_t, proc->p_replen, 2);
1878 	req->rq_rcvsize <<= 2;
1879 
1880 	status = xprt->ops->buf_alloc(task);
1881 	trace_rpc_buf_alloc(task, status);
1882 	if (status == 0)
1883 		return;
1884 	if (status != -ENOMEM) {
1885 		rpc_call_rpcerror(task, status);
1886 		return;
1887 	}
1888 
1889 	if (RPC_IS_ASYNC(task) || !fatal_signal_pending(current)) {
1890 		task->tk_action = call_allocate;
1891 		rpc_delay(task, HZ>>4);
1892 		return;
1893 	}
1894 
1895 	rpc_call_rpcerror(task, -ERESTARTSYS);
1896 }
1897 
1898 static int
rpc_task_need_encode(struct rpc_task * task)1899 rpc_task_need_encode(struct rpc_task *task)
1900 {
1901 	return test_bit(RPC_TASK_NEED_XMIT, &task->tk_runstate) == 0 &&
1902 		(!(task->tk_flags & RPC_TASK_SENT) ||
1903 		 !(task->tk_flags & RPC_TASK_NO_RETRANS_TIMEOUT) ||
1904 		 xprt_request_need_retransmit(task));
1905 }
1906 
1907 static void
rpc_xdr_encode(struct rpc_task * task)1908 rpc_xdr_encode(struct rpc_task *task)
1909 {
1910 	struct rpc_rqst	*req = task->tk_rqstp;
1911 	struct xdr_stream xdr;
1912 
1913 	xdr_buf_init(&req->rq_snd_buf,
1914 		     req->rq_buffer,
1915 		     req->rq_callsize);
1916 	xdr_buf_init(&req->rq_rcv_buf,
1917 		     req->rq_rbuffer,
1918 		     req->rq_rcvsize);
1919 
1920 	req->rq_reply_bytes_recvd = 0;
1921 	req->rq_snd_buf.head[0].iov_len = 0;
1922 	xdr_init_encode(&xdr, &req->rq_snd_buf,
1923 			req->rq_snd_buf.head[0].iov_base, req);
1924 	if (rpc_encode_header(task, &xdr))
1925 		return;
1926 
1927 	task->tk_status = rpcauth_wrap_req(task, &xdr);
1928 }
1929 
1930 /*
1931  * 3.	Encode arguments of an RPC call
1932  */
1933 static void
call_encode(struct rpc_task * task)1934 call_encode(struct rpc_task *task)
1935 {
1936 	if (!rpc_task_need_encode(task))
1937 		goto out;
1938 
1939 	/* Dequeue task from the receive queue while we're encoding */
1940 	xprt_request_dequeue_xprt(task);
1941 	/* Encode here so that rpcsec_gss can use correct sequence number. */
1942 	rpc_xdr_encode(task);
1943 	/* Add task to reply queue before transmission to avoid races */
1944 	if (task->tk_status == 0 && rpc_reply_expected(task))
1945 		task->tk_status = xprt_request_enqueue_receive(task);
1946 	/* Did the encode result in an error condition? */
1947 	if (task->tk_status != 0) {
1948 		/* Was the error nonfatal? */
1949 		switch (task->tk_status) {
1950 		case -EAGAIN:
1951 		case -ENOMEM:
1952 			rpc_delay(task, HZ >> 4);
1953 			break;
1954 		case -EKEYEXPIRED:
1955 			if (!task->tk_cred_retry) {
1956 				rpc_call_rpcerror(task, task->tk_status);
1957 			} else {
1958 				task->tk_action = call_refresh;
1959 				task->tk_cred_retry--;
1960 				trace_rpc_retry_refresh_status(task);
1961 			}
1962 			break;
1963 		default:
1964 			rpc_call_rpcerror(task, task->tk_status);
1965 		}
1966 		return;
1967 	}
1968 
1969 	xprt_request_enqueue_transmit(task);
1970 out:
1971 	task->tk_action = call_transmit;
1972 	/* Check that the connection is OK */
1973 	if (!xprt_bound(task->tk_xprt))
1974 		task->tk_action = call_bind;
1975 	else if (!xprt_connected(task->tk_xprt))
1976 		task->tk_action = call_connect;
1977 }
1978 
1979 /*
1980  * Helpers to check if the task was already transmitted, and
1981  * to take action when that is the case.
1982  */
1983 static bool
rpc_task_transmitted(struct rpc_task * task)1984 rpc_task_transmitted(struct rpc_task *task)
1985 {
1986 	return !test_bit(RPC_TASK_NEED_XMIT, &task->tk_runstate);
1987 }
1988 
1989 static void
rpc_task_handle_transmitted(struct rpc_task * task)1990 rpc_task_handle_transmitted(struct rpc_task *task)
1991 {
1992 	xprt_end_transmit(task);
1993 	task->tk_action = call_transmit_status;
1994 }
1995 
1996 /*
1997  * 4.	Get the server port number if not yet set
1998  */
1999 static void
call_bind(struct rpc_task * task)2000 call_bind(struct rpc_task *task)
2001 {
2002 	struct rpc_xprt *xprt = task->tk_rqstp->rq_xprt;
2003 
2004 	if (rpc_task_transmitted(task)) {
2005 		rpc_task_handle_transmitted(task);
2006 		return;
2007 	}
2008 
2009 	if (xprt_bound(xprt)) {
2010 		task->tk_action = call_connect;
2011 		return;
2012 	}
2013 
2014 	task->tk_action = call_bind_status;
2015 	if (!xprt_prepare_transmit(task))
2016 		return;
2017 
2018 	xprt->ops->rpcbind(task);
2019 }
2020 
2021 /*
2022  * 4a.	Sort out bind result
2023  */
2024 static void
call_bind_status(struct rpc_task * task)2025 call_bind_status(struct rpc_task *task)
2026 {
2027 	struct rpc_xprt *xprt = task->tk_rqstp->rq_xprt;
2028 	int status = -EIO;
2029 
2030 	if (rpc_task_transmitted(task)) {
2031 		rpc_task_handle_transmitted(task);
2032 		return;
2033 	}
2034 
2035 	if (task->tk_status >= 0)
2036 		goto out_next;
2037 	if (xprt_bound(xprt)) {
2038 		task->tk_status = 0;
2039 		goto out_next;
2040 	}
2041 
2042 	switch (task->tk_status) {
2043 	case -ENOMEM:
2044 		rpc_delay(task, HZ >> 2);
2045 		goto retry_timeout;
2046 	case -EACCES:
2047 		trace_rpcb_prog_unavail_err(task);
2048 		/* fail immediately if this is an RPC ping */
2049 		if (task->tk_msg.rpc_proc->p_proc == 0) {
2050 			status = -EOPNOTSUPP;
2051 			break;
2052 		}
2053 		if (task->tk_rebind_retry == 0)
2054 			break;
2055 		task->tk_rebind_retry--;
2056 		rpc_delay(task, 3*HZ);
2057 		goto retry_timeout;
2058 	case -ENOBUFS:
2059 		rpc_delay(task, HZ >> 2);
2060 		goto retry_timeout;
2061 	case -EAGAIN:
2062 		goto retry_timeout;
2063 	case -ETIMEDOUT:
2064 		trace_rpcb_timeout_err(task);
2065 		goto retry_timeout;
2066 	case -EPFNOSUPPORT:
2067 		/* server doesn't support any rpcbind version we know of */
2068 		trace_rpcb_bind_version_err(task);
2069 		break;
2070 	case -EPROTONOSUPPORT:
2071 		trace_rpcb_bind_version_err(task);
2072 		goto retry_timeout;
2073 	case -ECONNREFUSED:		/* connection problems */
2074 	case -ECONNRESET:
2075 	case -ECONNABORTED:
2076 	case -ENOTCONN:
2077 	case -EHOSTDOWN:
2078 	case -ENETDOWN:
2079 	case -EHOSTUNREACH:
2080 	case -ENETUNREACH:
2081 	case -EPIPE:
2082 		trace_rpcb_unreachable_err(task);
2083 		if (!RPC_IS_SOFTCONN(task)) {
2084 			rpc_delay(task, 5*HZ);
2085 			goto retry_timeout;
2086 		}
2087 		status = task->tk_status;
2088 		break;
2089 	default:
2090 		trace_rpcb_unrecognized_err(task);
2091 	}
2092 
2093 	rpc_call_rpcerror(task, status);
2094 	return;
2095 out_next:
2096 	task->tk_action = call_connect;
2097 	return;
2098 retry_timeout:
2099 	task->tk_status = 0;
2100 	task->tk_action = call_bind;
2101 	rpc_check_timeout(task);
2102 }
2103 
2104 /*
2105  * 4b.	Connect to the RPC server
2106  */
2107 static void
call_connect(struct rpc_task * task)2108 call_connect(struct rpc_task *task)
2109 {
2110 	struct rpc_xprt *xprt = task->tk_rqstp->rq_xprt;
2111 
2112 	if (rpc_task_transmitted(task)) {
2113 		rpc_task_handle_transmitted(task);
2114 		return;
2115 	}
2116 
2117 	if (xprt_connected(xprt)) {
2118 		task->tk_action = call_transmit;
2119 		return;
2120 	}
2121 
2122 	task->tk_action = call_connect_status;
2123 	if (task->tk_status < 0)
2124 		return;
2125 	if (task->tk_flags & RPC_TASK_NOCONNECT) {
2126 		rpc_call_rpcerror(task, -ENOTCONN);
2127 		return;
2128 	}
2129 	if (!xprt_prepare_transmit(task))
2130 		return;
2131 	xprt_connect(task);
2132 }
2133 
2134 /*
2135  * 4c.	Sort out connect result
2136  */
2137 static void
call_connect_status(struct rpc_task * task)2138 call_connect_status(struct rpc_task *task)
2139 {
2140 	struct rpc_xprt *xprt = task->tk_rqstp->rq_xprt;
2141 	struct rpc_clnt *clnt = task->tk_client;
2142 	int status = task->tk_status;
2143 
2144 	if (rpc_task_transmitted(task)) {
2145 		rpc_task_handle_transmitted(task);
2146 		return;
2147 	}
2148 
2149 	trace_rpc_connect_status(task);
2150 
2151 	if (task->tk_status == 0) {
2152 		clnt->cl_stats->netreconn++;
2153 		goto out_next;
2154 	}
2155 	if (xprt_connected(xprt)) {
2156 		task->tk_status = 0;
2157 		goto out_next;
2158 	}
2159 
2160 	task->tk_status = 0;
2161 	switch (status) {
2162 	case -ECONNREFUSED:
2163 		/* A positive refusal suggests a rebind is needed. */
2164 		if (RPC_IS_SOFTCONN(task))
2165 			break;
2166 		if (clnt->cl_autobind) {
2167 			rpc_force_rebind(clnt);
2168 			goto out_retry;
2169 		}
2170 		fallthrough;
2171 	case -ECONNRESET:
2172 	case -ECONNABORTED:
2173 	case -ENETDOWN:
2174 	case -ENETUNREACH:
2175 	case -EHOSTUNREACH:
2176 	case -EPIPE:
2177 	case -EPROTO:
2178 		xprt_conditional_disconnect(task->tk_rqstp->rq_xprt,
2179 					    task->tk_rqstp->rq_connect_cookie);
2180 		if (RPC_IS_SOFTCONN(task))
2181 			break;
2182 		/* retry with existing socket, after a delay */
2183 		rpc_delay(task, 3*HZ);
2184 		fallthrough;
2185 	case -EADDRINUSE:
2186 	case -ENOTCONN:
2187 	case -EAGAIN:
2188 	case -ETIMEDOUT:
2189 		if (!(task->tk_flags & RPC_TASK_NO_ROUND_ROBIN) &&
2190 		    (task->tk_flags & RPC_TASK_MOVEABLE) &&
2191 		    test_bit(XPRT_REMOVE, &xprt->state)) {
2192 			struct rpc_xprt *saved = task->tk_xprt;
2193 			struct rpc_xprt_switch *xps;
2194 
2195 			rcu_read_lock();
2196 			xps = xprt_switch_get(rcu_dereference(clnt->cl_xpi.xpi_xpswitch));
2197 			rcu_read_unlock();
2198 			if (xps->xps_nxprts > 1) {
2199 				long value;
2200 
2201 				xprt_release(task);
2202 				value = atomic_long_dec_return(&xprt->queuelen);
2203 				if (value == 0)
2204 					rpc_xprt_switch_remove_xprt(xps, saved,
2205 								    true);
2206 				xprt_put(saved);
2207 				task->tk_xprt = NULL;
2208 				task->tk_action = call_start;
2209 			}
2210 			xprt_switch_put(xps);
2211 			if (!task->tk_xprt)
2212 				return;
2213 		}
2214 		goto out_retry;
2215 	case -ENOBUFS:
2216 		rpc_delay(task, HZ >> 2);
2217 		goto out_retry;
2218 	}
2219 	rpc_call_rpcerror(task, status);
2220 	return;
2221 out_next:
2222 	task->tk_action = call_transmit;
2223 	return;
2224 out_retry:
2225 	/* Check for timeouts before looping back to call_bind */
2226 	task->tk_action = call_bind;
2227 	rpc_check_timeout(task);
2228 }
2229 
2230 /*
2231  * 5.	Transmit the RPC request, and wait for reply
2232  */
2233 static void
call_transmit(struct rpc_task * task)2234 call_transmit(struct rpc_task *task)
2235 {
2236 	if (rpc_task_transmitted(task)) {
2237 		rpc_task_handle_transmitted(task);
2238 		return;
2239 	}
2240 
2241 	task->tk_action = call_transmit_status;
2242 	if (!xprt_prepare_transmit(task))
2243 		return;
2244 	task->tk_status = 0;
2245 	if (test_bit(RPC_TASK_NEED_XMIT, &task->tk_runstate)) {
2246 		if (!xprt_connected(task->tk_xprt)) {
2247 			task->tk_status = -ENOTCONN;
2248 			return;
2249 		}
2250 		xprt_transmit(task);
2251 	}
2252 	xprt_end_transmit(task);
2253 }
2254 
2255 /*
2256  * 5a.	Handle cleanup after a transmission
2257  */
2258 static void
call_transmit_status(struct rpc_task * task)2259 call_transmit_status(struct rpc_task *task)
2260 {
2261 	task->tk_action = call_status;
2262 
2263 	/*
2264 	 * Common case: success.  Force the compiler to put this
2265 	 * test first.
2266 	 */
2267 	if (rpc_task_transmitted(task)) {
2268 		task->tk_status = 0;
2269 		xprt_request_wait_receive(task);
2270 		return;
2271 	}
2272 
2273 	switch (task->tk_status) {
2274 	default:
2275 		break;
2276 	case -EBADMSG:
2277 		task->tk_status = 0;
2278 		task->tk_action = call_encode;
2279 		break;
2280 		/*
2281 		 * Special cases: if we've been waiting on the
2282 		 * socket's write_space() callback, or if the
2283 		 * socket just returned a connection error,
2284 		 * then hold onto the transport lock.
2285 		 */
2286 	case -ENOMEM:
2287 	case -ENOBUFS:
2288 		rpc_delay(task, HZ>>2);
2289 		fallthrough;
2290 	case -EBADSLT:
2291 	case -EAGAIN:
2292 		task->tk_action = call_transmit;
2293 		task->tk_status = 0;
2294 		break;
2295 	case -ECONNREFUSED:
2296 	case -EHOSTDOWN:
2297 	case -ENETDOWN:
2298 	case -EHOSTUNREACH:
2299 	case -ENETUNREACH:
2300 	case -EPERM:
2301 		if (RPC_IS_SOFTCONN(task)) {
2302 			if (!task->tk_msg.rpc_proc->p_proc)
2303 				trace_xprt_ping(task->tk_xprt,
2304 						task->tk_status);
2305 			rpc_call_rpcerror(task, task->tk_status);
2306 			return;
2307 		}
2308 		fallthrough;
2309 	case -ECONNRESET:
2310 	case -ECONNABORTED:
2311 	case -EADDRINUSE:
2312 	case -ENOTCONN:
2313 	case -EPIPE:
2314 		task->tk_action = call_bind;
2315 		task->tk_status = 0;
2316 		break;
2317 	}
2318 	rpc_check_timeout(task);
2319 }
2320 
2321 #if defined(CONFIG_SUNRPC_BACKCHANNEL)
2322 static void call_bc_transmit(struct rpc_task *task);
2323 static void call_bc_transmit_status(struct rpc_task *task);
2324 
2325 static void
call_bc_encode(struct rpc_task * task)2326 call_bc_encode(struct rpc_task *task)
2327 {
2328 	xprt_request_enqueue_transmit(task);
2329 	task->tk_action = call_bc_transmit;
2330 }
2331 
2332 /*
2333  * 5b.	Send the backchannel RPC reply.  On error, drop the reply.  In
2334  * addition, disconnect on connectivity errors.
2335  */
2336 static void
call_bc_transmit(struct rpc_task * task)2337 call_bc_transmit(struct rpc_task *task)
2338 {
2339 	task->tk_action = call_bc_transmit_status;
2340 	if (test_bit(RPC_TASK_NEED_XMIT, &task->tk_runstate)) {
2341 		if (!xprt_prepare_transmit(task))
2342 			return;
2343 		task->tk_status = 0;
2344 		xprt_transmit(task);
2345 	}
2346 	xprt_end_transmit(task);
2347 }
2348 
2349 static void
call_bc_transmit_status(struct rpc_task * task)2350 call_bc_transmit_status(struct rpc_task *task)
2351 {
2352 	struct rpc_rqst *req = task->tk_rqstp;
2353 
2354 	if (rpc_task_transmitted(task))
2355 		task->tk_status = 0;
2356 
2357 	switch (task->tk_status) {
2358 	case 0:
2359 		/* Success */
2360 	case -ENETDOWN:
2361 	case -EHOSTDOWN:
2362 	case -EHOSTUNREACH:
2363 	case -ENETUNREACH:
2364 	case -ECONNRESET:
2365 	case -ECONNREFUSED:
2366 	case -EADDRINUSE:
2367 	case -ENOTCONN:
2368 	case -EPIPE:
2369 		break;
2370 	case -ENOMEM:
2371 	case -ENOBUFS:
2372 		rpc_delay(task, HZ>>2);
2373 		fallthrough;
2374 	case -EBADSLT:
2375 	case -EAGAIN:
2376 		task->tk_status = 0;
2377 		task->tk_action = call_bc_transmit;
2378 		return;
2379 	case -ETIMEDOUT:
2380 		/*
2381 		 * Problem reaching the server.  Disconnect and let the
2382 		 * forechannel reestablish the connection.  The server will
2383 		 * have to retransmit the backchannel request and we'll
2384 		 * reprocess it.  Since these ops are idempotent, there's no
2385 		 * need to cache our reply at this time.
2386 		 */
2387 		printk(KERN_NOTICE "RPC: Could not send backchannel reply "
2388 			"error: %d\n", task->tk_status);
2389 		xprt_conditional_disconnect(req->rq_xprt,
2390 			req->rq_connect_cookie);
2391 		break;
2392 	default:
2393 		/*
2394 		 * We were unable to reply and will have to drop the
2395 		 * request.  The server should reconnect and retransmit.
2396 		 */
2397 		printk(KERN_NOTICE "RPC: Could not send backchannel reply "
2398 			"error: %d\n", task->tk_status);
2399 		break;
2400 	}
2401 	task->tk_action = rpc_exit_task;
2402 }
2403 #endif /* CONFIG_SUNRPC_BACKCHANNEL */
2404 
2405 /*
2406  * 6.	Sort out the RPC call status
2407  */
2408 static void
call_status(struct rpc_task * task)2409 call_status(struct rpc_task *task)
2410 {
2411 	struct rpc_clnt	*clnt = task->tk_client;
2412 	int		status;
2413 
2414 	if (!task->tk_msg.rpc_proc->p_proc)
2415 		trace_xprt_ping(task->tk_xprt, task->tk_status);
2416 
2417 	status = task->tk_status;
2418 	if (status >= 0) {
2419 		task->tk_action = call_decode;
2420 		return;
2421 	}
2422 
2423 	trace_rpc_call_status(task);
2424 	task->tk_status = 0;
2425 	switch(status) {
2426 	case -EHOSTDOWN:
2427 	case -ENETDOWN:
2428 	case -EHOSTUNREACH:
2429 	case -ENETUNREACH:
2430 	case -EPERM:
2431 		if (RPC_IS_SOFTCONN(task))
2432 			goto out_exit;
2433 		/*
2434 		 * Delay any retries for 3 seconds, then handle as if it
2435 		 * were a timeout.
2436 		 */
2437 		rpc_delay(task, 3*HZ);
2438 		fallthrough;
2439 	case -ETIMEDOUT:
2440 		break;
2441 	case -ECONNREFUSED:
2442 	case -ECONNRESET:
2443 	case -ECONNABORTED:
2444 	case -ENOTCONN:
2445 		rpc_force_rebind(clnt);
2446 		break;
2447 	case -EADDRINUSE:
2448 		rpc_delay(task, 3*HZ);
2449 		fallthrough;
2450 	case -EPIPE:
2451 	case -EAGAIN:
2452 		break;
2453 	case -ENFILE:
2454 	case -ENOBUFS:
2455 	case -ENOMEM:
2456 		rpc_delay(task, HZ>>2);
2457 		break;
2458 	case -EIO:
2459 		/* shutdown or soft timeout */
2460 		goto out_exit;
2461 	default:
2462 		if (clnt->cl_chatty)
2463 			printk("%s: RPC call returned error %d\n",
2464 			       clnt->cl_program->name, -status);
2465 		goto out_exit;
2466 	}
2467 	task->tk_action = call_encode;
2468 	if (status != -ECONNRESET && status != -ECONNABORTED)
2469 		rpc_check_timeout(task);
2470 	return;
2471 out_exit:
2472 	rpc_call_rpcerror(task, status);
2473 }
2474 
2475 static bool
rpc_check_connected(const struct rpc_rqst * req)2476 rpc_check_connected(const struct rpc_rqst *req)
2477 {
2478 	/* No allocated request or transport? return true */
2479 	if (!req || !req->rq_xprt)
2480 		return true;
2481 	return xprt_connected(req->rq_xprt);
2482 }
2483 
2484 static void
rpc_check_timeout(struct rpc_task * task)2485 rpc_check_timeout(struct rpc_task *task)
2486 {
2487 	struct rpc_clnt	*clnt = task->tk_client;
2488 
2489 	if (RPC_SIGNALLED(task))
2490 		return;
2491 
2492 	if (xprt_adjust_timeout(task->tk_rqstp) == 0)
2493 		return;
2494 
2495 	trace_rpc_timeout_status(task);
2496 	task->tk_timeouts++;
2497 
2498 	if (RPC_IS_SOFTCONN(task) && !rpc_check_connected(task->tk_rqstp)) {
2499 		rpc_call_rpcerror(task, -ETIMEDOUT);
2500 		return;
2501 	}
2502 
2503 	if (RPC_IS_SOFT(task)) {
2504 		/*
2505 		 * Once a "no retrans timeout" soft tasks (a.k.a NFSv4) has
2506 		 * been sent, it should time out only if the transport
2507 		 * connection gets terminally broken.
2508 		 */
2509 		if ((task->tk_flags & RPC_TASK_NO_RETRANS_TIMEOUT) &&
2510 		    rpc_check_connected(task->tk_rqstp))
2511 			return;
2512 
2513 		if (clnt->cl_chatty) {
2514 			pr_notice_ratelimited(
2515 				"%s: server %s not responding, timed out\n",
2516 				clnt->cl_program->name,
2517 				task->tk_xprt->servername);
2518 		}
2519 		if (task->tk_flags & RPC_TASK_TIMEOUT)
2520 			rpc_call_rpcerror(task, -ETIMEDOUT);
2521 		else
2522 			__rpc_call_rpcerror(task, -EIO, -ETIMEDOUT);
2523 		return;
2524 	}
2525 
2526 	if (!(task->tk_flags & RPC_CALL_MAJORSEEN)) {
2527 		task->tk_flags |= RPC_CALL_MAJORSEEN;
2528 		if (clnt->cl_chatty) {
2529 			pr_notice_ratelimited(
2530 				"%s: server %s not responding, still trying\n",
2531 				clnt->cl_program->name,
2532 				task->tk_xprt->servername);
2533 		}
2534 	}
2535 	rpc_force_rebind(clnt);
2536 	/*
2537 	 * Did our request time out due to an RPCSEC_GSS out-of-sequence
2538 	 * event? RFC2203 requires the server to drop all such requests.
2539 	 */
2540 	rpcauth_invalcred(task);
2541 }
2542 
2543 /*
2544  * 7.	Decode the RPC reply
2545  */
2546 static void
call_decode(struct rpc_task * task)2547 call_decode(struct rpc_task *task)
2548 {
2549 	struct rpc_clnt	*clnt = task->tk_client;
2550 	struct rpc_rqst	*req = task->tk_rqstp;
2551 	struct xdr_stream xdr;
2552 	int err;
2553 
2554 	if (!task->tk_msg.rpc_proc->p_decode) {
2555 		task->tk_action = rpc_exit_task;
2556 		return;
2557 	}
2558 
2559 	if (task->tk_flags & RPC_CALL_MAJORSEEN) {
2560 		if (clnt->cl_chatty) {
2561 			pr_notice_ratelimited("%s: server %s OK\n",
2562 				clnt->cl_program->name,
2563 				task->tk_xprt->servername);
2564 		}
2565 		task->tk_flags &= ~RPC_CALL_MAJORSEEN;
2566 	}
2567 
2568 	/*
2569 	 * Did we ever call xprt_complete_rqst()? If not, we should assume
2570 	 * the message is incomplete.
2571 	 */
2572 	err = -EAGAIN;
2573 	if (!req->rq_reply_bytes_recvd)
2574 		goto out;
2575 
2576 	/* Ensure that we see all writes made by xprt_complete_rqst()
2577 	 * before it changed req->rq_reply_bytes_recvd.
2578 	 */
2579 	smp_rmb();
2580 
2581 	req->rq_rcv_buf.len = req->rq_private_buf.len;
2582 	trace_rpc_xdr_recvfrom(task, &req->rq_rcv_buf);
2583 
2584 	/* Check that the softirq receive buffer is valid */
2585 	WARN_ON(memcmp(&req->rq_rcv_buf, &req->rq_private_buf,
2586 				sizeof(req->rq_rcv_buf)) != 0);
2587 
2588 	xdr_init_decode(&xdr, &req->rq_rcv_buf,
2589 			req->rq_rcv_buf.head[0].iov_base, req);
2590 	err = rpc_decode_header(task, &xdr);
2591 out:
2592 	switch (err) {
2593 	case 0:
2594 		task->tk_action = rpc_exit_task;
2595 		task->tk_status = rpcauth_unwrap_resp(task, &xdr);
2596 		return;
2597 	case -EAGAIN:
2598 		task->tk_status = 0;
2599 		if (task->tk_client->cl_discrtry)
2600 			xprt_conditional_disconnect(req->rq_xprt,
2601 						    req->rq_connect_cookie);
2602 		task->tk_action = call_encode;
2603 		rpc_check_timeout(task);
2604 		break;
2605 	case -EKEYREJECTED:
2606 		task->tk_action = call_reserve;
2607 		rpc_check_timeout(task);
2608 		rpcauth_invalcred(task);
2609 		/* Ensure we obtain a new XID if we retry! */
2610 		xprt_release(task);
2611 	}
2612 }
2613 
2614 static int
rpc_encode_header(struct rpc_task * task,struct xdr_stream * xdr)2615 rpc_encode_header(struct rpc_task *task, struct xdr_stream *xdr)
2616 {
2617 	struct rpc_clnt *clnt = task->tk_client;
2618 	struct rpc_rqst	*req = task->tk_rqstp;
2619 	__be32 *p;
2620 	int error;
2621 
2622 	error = -EMSGSIZE;
2623 	p = xdr_reserve_space(xdr, RPC_CALLHDRSIZE << 2);
2624 	if (!p)
2625 		goto out_fail;
2626 	*p++ = req->rq_xid;
2627 	*p++ = rpc_call;
2628 	*p++ = cpu_to_be32(RPC_VERSION);
2629 	*p++ = cpu_to_be32(clnt->cl_prog);
2630 	*p++ = cpu_to_be32(clnt->cl_vers);
2631 	*p   = cpu_to_be32(task->tk_msg.rpc_proc->p_proc);
2632 
2633 	error = rpcauth_marshcred(task, xdr);
2634 	if (error < 0)
2635 		goto out_fail;
2636 	return 0;
2637 out_fail:
2638 	trace_rpc_bad_callhdr(task);
2639 	rpc_call_rpcerror(task, error);
2640 	return error;
2641 }
2642 
2643 static noinline int
rpc_decode_header(struct rpc_task * task,struct xdr_stream * xdr)2644 rpc_decode_header(struct rpc_task *task, struct xdr_stream *xdr)
2645 {
2646 	struct rpc_clnt *clnt = task->tk_client;
2647 	int error;
2648 	__be32 *p;
2649 
2650 	/* RFC-1014 says that the representation of XDR data must be a
2651 	 * multiple of four bytes
2652 	 * - if it isn't pointer subtraction in the NFS client may give
2653 	 *   undefined results
2654 	 */
2655 	if (task->tk_rqstp->rq_rcv_buf.len & 3)
2656 		goto out_unparsable;
2657 
2658 	p = xdr_inline_decode(xdr, 3 * sizeof(*p));
2659 	if (!p)
2660 		goto out_unparsable;
2661 	p++;	/* skip XID */
2662 	if (*p++ != rpc_reply)
2663 		goto out_unparsable;
2664 	if (*p++ != rpc_msg_accepted)
2665 		goto out_msg_denied;
2666 
2667 	error = rpcauth_checkverf(task, xdr);
2668 	if (error)
2669 		goto out_verifier;
2670 
2671 	p = xdr_inline_decode(xdr, sizeof(*p));
2672 	if (!p)
2673 		goto out_unparsable;
2674 	switch (*p) {
2675 	case rpc_success:
2676 		return 0;
2677 	case rpc_prog_unavail:
2678 		trace_rpc__prog_unavail(task);
2679 		error = -EPFNOSUPPORT;
2680 		goto out_err;
2681 	case rpc_prog_mismatch:
2682 		trace_rpc__prog_mismatch(task);
2683 		error = -EPROTONOSUPPORT;
2684 		goto out_err;
2685 	case rpc_proc_unavail:
2686 		trace_rpc__proc_unavail(task);
2687 		error = -EOPNOTSUPP;
2688 		goto out_err;
2689 	case rpc_garbage_args:
2690 	case rpc_system_err:
2691 		trace_rpc__garbage_args(task);
2692 		error = -EIO;
2693 		break;
2694 	default:
2695 		goto out_unparsable;
2696 	}
2697 
2698 out_garbage:
2699 	clnt->cl_stats->rpcgarbage++;
2700 	if (task->tk_garb_retry) {
2701 		task->tk_garb_retry--;
2702 		task->tk_action = call_encode;
2703 		return -EAGAIN;
2704 	}
2705 out_err:
2706 	rpc_call_rpcerror(task, error);
2707 	return error;
2708 
2709 out_unparsable:
2710 	trace_rpc__unparsable(task);
2711 	error = -EIO;
2712 	goto out_garbage;
2713 
2714 out_verifier:
2715 	trace_rpc_bad_verifier(task);
2716 	goto out_err;
2717 
2718 out_msg_denied:
2719 	error = -EACCES;
2720 	p = xdr_inline_decode(xdr, sizeof(*p));
2721 	if (!p)
2722 		goto out_unparsable;
2723 	switch (*p++) {
2724 	case rpc_auth_error:
2725 		break;
2726 	case rpc_mismatch:
2727 		trace_rpc__mismatch(task);
2728 		error = -EPROTONOSUPPORT;
2729 		goto out_err;
2730 	default:
2731 		goto out_unparsable;
2732 	}
2733 
2734 	p = xdr_inline_decode(xdr, sizeof(*p));
2735 	if (!p)
2736 		goto out_unparsable;
2737 	switch (*p++) {
2738 	case rpc_autherr_rejectedcred:
2739 	case rpc_autherr_rejectedverf:
2740 	case rpcsec_gsserr_credproblem:
2741 	case rpcsec_gsserr_ctxproblem:
2742 		if (!task->tk_cred_retry)
2743 			break;
2744 		task->tk_cred_retry--;
2745 		trace_rpc__stale_creds(task);
2746 		return -EKEYREJECTED;
2747 	case rpc_autherr_badcred:
2748 	case rpc_autherr_badverf:
2749 		/* possibly garbled cred/verf? */
2750 		if (!task->tk_garb_retry)
2751 			break;
2752 		task->tk_garb_retry--;
2753 		trace_rpc__bad_creds(task);
2754 		task->tk_action = call_encode;
2755 		return -EAGAIN;
2756 	case rpc_autherr_tooweak:
2757 		trace_rpc__auth_tooweak(task);
2758 		pr_warn("RPC: server %s requires stronger authentication.\n",
2759 			task->tk_xprt->servername);
2760 		break;
2761 	default:
2762 		goto out_unparsable;
2763 	}
2764 	goto out_err;
2765 }
2766 
rpcproc_encode_null(struct rpc_rqst * rqstp,struct xdr_stream * xdr,const void * obj)2767 static void rpcproc_encode_null(struct rpc_rqst *rqstp, struct xdr_stream *xdr,
2768 		const void *obj)
2769 {
2770 }
2771 
rpcproc_decode_null(struct rpc_rqst * rqstp,struct xdr_stream * xdr,void * obj)2772 static int rpcproc_decode_null(struct rpc_rqst *rqstp, struct xdr_stream *xdr,
2773 		void *obj)
2774 {
2775 	return 0;
2776 }
2777 
2778 static const struct rpc_procinfo rpcproc_null = {
2779 	.p_encode = rpcproc_encode_null,
2780 	.p_decode = rpcproc_decode_null,
2781 };
2782 
2783 static const struct rpc_procinfo rpcproc_null_noreply = {
2784 	.p_encode = rpcproc_encode_null,
2785 };
2786 
2787 static void
rpc_null_call_prepare(struct rpc_task * task,void * data)2788 rpc_null_call_prepare(struct rpc_task *task, void *data)
2789 {
2790 	task->tk_flags &= ~RPC_TASK_NO_RETRANS_TIMEOUT;
2791 	rpc_call_start(task);
2792 }
2793 
2794 static const struct rpc_call_ops rpc_null_ops = {
2795 	.rpc_call_prepare = rpc_null_call_prepare,
2796 	.rpc_call_done = rpc_default_callback,
2797 };
2798 
2799 static
rpc_call_null_helper(struct rpc_clnt * clnt,struct rpc_xprt * xprt,struct rpc_cred * cred,int flags,const struct rpc_call_ops * ops,void * data)2800 struct rpc_task *rpc_call_null_helper(struct rpc_clnt *clnt,
2801 		struct rpc_xprt *xprt, struct rpc_cred *cred, int flags,
2802 		const struct rpc_call_ops *ops, void *data)
2803 {
2804 	struct rpc_message msg = {
2805 		.rpc_proc = &rpcproc_null,
2806 	};
2807 	struct rpc_task_setup task_setup_data = {
2808 		.rpc_client = clnt,
2809 		.rpc_xprt = xprt,
2810 		.rpc_message = &msg,
2811 		.rpc_op_cred = cred,
2812 		.callback_ops = ops ?: &rpc_null_ops,
2813 		.callback_data = data,
2814 		.flags = flags | RPC_TASK_SOFT | RPC_TASK_SOFTCONN |
2815 			 RPC_TASK_NULLCREDS,
2816 	};
2817 
2818 	return rpc_run_task(&task_setup_data);
2819 }
2820 
rpc_call_null(struct rpc_clnt * clnt,struct rpc_cred * cred,int flags)2821 struct rpc_task *rpc_call_null(struct rpc_clnt *clnt, struct rpc_cred *cred, int flags)
2822 {
2823 	return rpc_call_null_helper(clnt, NULL, cred, flags, NULL, NULL);
2824 }
2825 EXPORT_SYMBOL_GPL(rpc_call_null);
2826 
rpc_ping(struct rpc_clnt * clnt)2827 static int rpc_ping(struct rpc_clnt *clnt)
2828 {
2829 	struct rpc_task	*task;
2830 	int status;
2831 
2832 	task = rpc_call_null_helper(clnt, NULL, NULL, 0, NULL, NULL);
2833 	if (IS_ERR(task))
2834 		return PTR_ERR(task);
2835 	status = task->tk_status;
2836 	rpc_put_task(task);
2837 	return status;
2838 }
2839 
rpc_ping_noreply(struct rpc_clnt * clnt)2840 static int rpc_ping_noreply(struct rpc_clnt *clnt)
2841 {
2842 	struct rpc_message msg = {
2843 		.rpc_proc = &rpcproc_null_noreply,
2844 	};
2845 	struct rpc_task_setup task_setup_data = {
2846 		.rpc_client = clnt,
2847 		.rpc_message = &msg,
2848 		.callback_ops = &rpc_null_ops,
2849 		.flags = RPC_TASK_SOFT | RPC_TASK_SOFTCONN | RPC_TASK_NULLCREDS,
2850 	};
2851 	struct rpc_task	*task;
2852 	int status;
2853 
2854 	task = rpc_run_task(&task_setup_data);
2855 	if (IS_ERR(task))
2856 		return PTR_ERR(task);
2857 	status = task->tk_status;
2858 	rpc_put_task(task);
2859 	return status;
2860 }
2861 
2862 struct rpc_cb_add_xprt_calldata {
2863 	struct rpc_xprt_switch *xps;
2864 	struct rpc_xprt *xprt;
2865 };
2866 
rpc_cb_add_xprt_done(struct rpc_task * task,void * calldata)2867 static void rpc_cb_add_xprt_done(struct rpc_task *task, void *calldata)
2868 {
2869 	struct rpc_cb_add_xprt_calldata *data = calldata;
2870 
2871 	if (task->tk_status == 0)
2872 		rpc_xprt_switch_add_xprt(data->xps, data->xprt);
2873 }
2874 
rpc_cb_add_xprt_release(void * calldata)2875 static void rpc_cb_add_xprt_release(void *calldata)
2876 {
2877 	struct rpc_cb_add_xprt_calldata *data = calldata;
2878 
2879 	xprt_put(data->xprt);
2880 	xprt_switch_put(data->xps);
2881 	kfree(data);
2882 }
2883 
2884 static const struct rpc_call_ops rpc_cb_add_xprt_call_ops = {
2885 	.rpc_call_prepare = rpc_null_call_prepare,
2886 	.rpc_call_done = rpc_cb_add_xprt_done,
2887 	.rpc_release = rpc_cb_add_xprt_release,
2888 };
2889 
2890 /**
2891  * rpc_clnt_test_and_add_xprt - Test and add a new transport to a rpc_clnt
2892  * @clnt: pointer to struct rpc_clnt
2893  * @xps: pointer to struct rpc_xprt_switch,
2894  * @xprt: pointer struct rpc_xprt
2895  * @dummy: unused
2896  */
rpc_clnt_test_and_add_xprt(struct rpc_clnt * clnt,struct rpc_xprt_switch * xps,struct rpc_xprt * xprt,void * dummy)2897 int rpc_clnt_test_and_add_xprt(struct rpc_clnt *clnt,
2898 		struct rpc_xprt_switch *xps, struct rpc_xprt *xprt,
2899 		void *dummy)
2900 {
2901 	struct rpc_cb_add_xprt_calldata *data;
2902 	struct rpc_task *task;
2903 
2904 	if (xps->xps_nunique_destaddr_xprts + 1 > clnt->cl_max_connect) {
2905 		rcu_read_lock();
2906 		pr_warn("SUNRPC: reached max allowed number (%d) did not add "
2907 			"transport to server: %s\n", clnt->cl_max_connect,
2908 			rpc_peeraddr2str(clnt, RPC_DISPLAY_ADDR));
2909 		rcu_read_unlock();
2910 		return -EINVAL;
2911 	}
2912 
2913 	data = kmalloc(sizeof(*data), GFP_KERNEL);
2914 	if (!data)
2915 		return -ENOMEM;
2916 	data->xps = xprt_switch_get(xps);
2917 	data->xprt = xprt_get(xprt);
2918 	if (rpc_xprt_switch_has_addr(data->xps, (struct sockaddr *)&xprt->addr)) {
2919 		rpc_cb_add_xprt_release(data);
2920 		goto success;
2921 	}
2922 
2923 	task = rpc_call_null_helper(clnt, xprt, NULL, RPC_TASK_ASYNC,
2924 			&rpc_cb_add_xprt_call_ops, data);
2925 	if (IS_ERR(task))
2926 		return PTR_ERR(task);
2927 
2928 	data->xps->xps_nunique_destaddr_xprts++;
2929 	rpc_put_task(task);
2930 success:
2931 	return 1;
2932 }
2933 EXPORT_SYMBOL_GPL(rpc_clnt_test_and_add_xprt);
2934 
rpc_clnt_add_xprt_helper(struct rpc_clnt * clnt,struct rpc_xprt * xprt,struct rpc_add_xprt_test * data)2935 static int rpc_clnt_add_xprt_helper(struct rpc_clnt *clnt,
2936 				    struct rpc_xprt *xprt,
2937 				    struct rpc_add_xprt_test *data)
2938 {
2939 	struct rpc_task *task;
2940 	int status = -EADDRINUSE;
2941 
2942 	/* Test the connection */
2943 	task = rpc_call_null_helper(clnt, xprt, NULL, 0, NULL, NULL);
2944 	if (IS_ERR(task))
2945 		return PTR_ERR(task);
2946 
2947 	status = task->tk_status;
2948 	rpc_put_task(task);
2949 
2950 	if (status < 0)
2951 		return status;
2952 
2953 	/* rpc_xprt_switch and rpc_xprt are deferrenced by add_xprt_test() */
2954 	data->add_xprt_test(clnt, xprt, data->data);
2955 
2956 	return 0;
2957 }
2958 
2959 /**
2960  * rpc_clnt_setup_test_and_add_xprt()
2961  *
2962  * This is an rpc_clnt_add_xprt setup() function which returns 1 so:
2963  *   1) caller of the test function must dereference the rpc_xprt_switch
2964  *   and the rpc_xprt.
2965  *   2) test function must call rpc_xprt_switch_add_xprt, usually in
2966  *   the rpc_call_done routine.
2967  *
2968  * Upon success (return of 1), the test function adds the new
2969  * transport to the rpc_clnt xprt switch
2970  *
2971  * @clnt: struct rpc_clnt to get the new transport
2972  * @xps:  the rpc_xprt_switch to hold the new transport
2973  * @xprt: the rpc_xprt to test
2974  * @data: a struct rpc_add_xprt_test pointer that holds the test function
2975  *        and test function call data
2976  */
rpc_clnt_setup_test_and_add_xprt(struct rpc_clnt * clnt,struct rpc_xprt_switch * xps,struct rpc_xprt * xprt,void * data)2977 int rpc_clnt_setup_test_and_add_xprt(struct rpc_clnt *clnt,
2978 				     struct rpc_xprt_switch *xps,
2979 				     struct rpc_xprt *xprt,
2980 				     void *data)
2981 {
2982 	int status = -EADDRINUSE;
2983 
2984 	xprt = xprt_get(xprt);
2985 	xprt_switch_get(xps);
2986 
2987 	if (rpc_xprt_switch_has_addr(xps, (struct sockaddr *)&xprt->addr))
2988 		goto out_err;
2989 
2990 	status = rpc_clnt_add_xprt_helper(clnt, xprt, data);
2991 	if (status < 0)
2992 		goto out_err;
2993 
2994 	status = 1;
2995 out_err:
2996 	xprt_put(xprt);
2997 	xprt_switch_put(xps);
2998 	if (status < 0)
2999 		pr_info("RPC:   rpc_clnt_test_xprt failed: %d addr %s not "
3000 			"added\n", status,
3001 			xprt->address_strings[RPC_DISPLAY_ADDR]);
3002 	/* so that rpc_clnt_add_xprt does not call rpc_xprt_switch_add_xprt */
3003 	return status;
3004 }
3005 EXPORT_SYMBOL_GPL(rpc_clnt_setup_test_and_add_xprt);
3006 
3007 /**
3008  * rpc_clnt_add_xprt - Add a new transport to a rpc_clnt
3009  * @clnt: pointer to struct rpc_clnt
3010  * @xprtargs: pointer to struct xprt_create
3011  * @setup: callback to test and/or set up the connection
3012  * @data: pointer to setup function data
3013  *
3014  * Creates a new transport using the parameters set in args and
3015  * adds it to clnt.
3016  * If ping is set, then test that connectivity succeeds before
3017  * adding the new transport.
3018  *
3019  */
rpc_clnt_add_xprt(struct rpc_clnt * clnt,struct xprt_create * xprtargs,int (* setup)(struct rpc_clnt *,struct rpc_xprt_switch *,struct rpc_xprt *,void *),void * data)3020 int rpc_clnt_add_xprt(struct rpc_clnt *clnt,
3021 		struct xprt_create *xprtargs,
3022 		int (*setup)(struct rpc_clnt *,
3023 			struct rpc_xprt_switch *,
3024 			struct rpc_xprt *,
3025 			void *),
3026 		void *data)
3027 {
3028 	struct rpc_xprt_switch *xps;
3029 	struct rpc_xprt *xprt;
3030 	unsigned long connect_timeout;
3031 	unsigned long reconnect_timeout;
3032 	unsigned char resvport, reuseport;
3033 	int ret = 0, ident;
3034 
3035 	rcu_read_lock();
3036 	xps = xprt_switch_get(rcu_dereference(clnt->cl_xpi.xpi_xpswitch));
3037 	xprt = xprt_iter_xprt(&clnt->cl_xpi);
3038 	if (xps == NULL || xprt == NULL) {
3039 		rcu_read_unlock();
3040 		xprt_switch_put(xps);
3041 		return -EAGAIN;
3042 	}
3043 	resvport = xprt->resvport;
3044 	reuseport = xprt->reuseport;
3045 	connect_timeout = xprt->connect_timeout;
3046 	reconnect_timeout = xprt->max_reconnect_timeout;
3047 	ident = xprt->xprt_class->ident;
3048 	rcu_read_unlock();
3049 
3050 	if (!xprtargs->ident)
3051 		xprtargs->ident = ident;
3052 	xprt = xprt_create_transport(xprtargs);
3053 	if (IS_ERR(xprt)) {
3054 		ret = PTR_ERR(xprt);
3055 		goto out_put_switch;
3056 	}
3057 	xprt->resvport = resvport;
3058 	xprt->reuseport = reuseport;
3059 	if (xprt->ops->set_connect_timeout != NULL)
3060 		xprt->ops->set_connect_timeout(xprt,
3061 				connect_timeout,
3062 				reconnect_timeout);
3063 
3064 	rpc_xprt_switch_set_roundrobin(xps);
3065 	if (setup) {
3066 		ret = setup(clnt, xps, xprt, data);
3067 		if (ret != 0)
3068 			goto out_put_xprt;
3069 	}
3070 	rpc_xprt_switch_add_xprt(xps, xprt);
3071 out_put_xprt:
3072 	xprt_put(xprt);
3073 out_put_switch:
3074 	xprt_switch_put(xps);
3075 	return ret;
3076 }
3077 EXPORT_SYMBOL_GPL(rpc_clnt_add_xprt);
3078 
rpc_xprt_probe_trunked(struct rpc_clnt * clnt,struct rpc_xprt * xprt,struct rpc_add_xprt_test * data)3079 static int rpc_xprt_probe_trunked(struct rpc_clnt *clnt,
3080 				  struct rpc_xprt *xprt,
3081 				  struct rpc_add_xprt_test *data)
3082 {
3083 	struct rpc_xprt_switch *xps;
3084 	struct rpc_xprt *main_xprt;
3085 	int status = 0;
3086 
3087 	xprt_get(xprt);
3088 
3089 	rcu_read_lock();
3090 	main_xprt = xprt_get(rcu_dereference(clnt->cl_xprt));
3091 	xps = xprt_switch_get(rcu_dereference(clnt->cl_xpi.xpi_xpswitch));
3092 	status = rpc_cmp_addr_port((struct sockaddr *)&xprt->addr,
3093 				   (struct sockaddr *)&main_xprt->addr);
3094 	rcu_read_unlock();
3095 	xprt_put(main_xprt);
3096 	if (status || !test_bit(XPRT_OFFLINE, &xprt->state))
3097 		goto out;
3098 
3099 	status = rpc_clnt_add_xprt_helper(clnt, xprt, data);
3100 out:
3101 	xprt_put(xprt);
3102 	xprt_switch_put(xps);
3103 	return status;
3104 }
3105 
3106 /* rpc_clnt_probe_trunked_xprt -- probe offlined transport for session trunking
3107  * @clnt rpc_clnt structure
3108  *
3109  * For each offlined transport found in the rpc_clnt structure call
3110  * the function rpc_xprt_probe_trunked() which will determine if this
3111  * transport still belongs to the trunking group.
3112  */
rpc_clnt_probe_trunked_xprts(struct rpc_clnt * clnt,struct rpc_add_xprt_test * data)3113 void rpc_clnt_probe_trunked_xprts(struct rpc_clnt *clnt,
3114 				  struct rpc_add_xprt_test *data)
3115 {
3116 	struct rpc_xprt_iter xpi;
3117 	int ret;
3118 
3119 	ret = rpc_clnt_xprt_iter_offline_init(clnt, &xpi);
3120 	if (ret)
3121 		return;
3122 	for (;;) {
3123 		struct rpc_xprt *xprt = xprt_iter_get_next(&xpi);
3124 
3125 		if (!xprt)
3126 			break;
3127 		ret = rpc_xprt_probe_trunked(clnt, xprt, data);
3128 		xprt_put(xprt);
3129 		if (ret < 0)
3130 			break;
3131 		xprt_iter_rewind(&xpi);
3132 	}
3133 	xprt_iter_destroy(&xpi);
3134 }
3135 EXPORT_SYMBOL_GPL(rpc_clnt_probe_trunked_xprts);
3136 
rpc_xprt_offline(struct rpc_clnt * clnt,struct rpc_xprt * xprt,void * data)3137 static int rpc_xprt_offline(struct rpc_clnt *clnt,
3138 			    struct rpc_xprt *xprt,
3139 			    void *data)
3140 {
3141 	struct rpc_xprt *main_xprt;
3142 	struct rpc_xprt_switch *xps;
3143 	int err = 0;
3144 
3145 	xprt_get(xprt);
3146 
3147 	rcu_read_lock();
3148 	main_xprt = xprt_get(rcu_dereference(clnt->cl_xprt));
3149 	xps = xprt_switch_get(rcu_dereference(clnt->cl_xpi.xpi_xpswitch));
3150 	err = rpc_cmp_addr_port((struct sockaddr *)&xprt->addr,
3151 				(struct sockaddr *)&main_xprt->addr);
3152 	rcu_read_unlock();
3153 	xprt_put(main_xprt);
3154 	if (err)
3155 		goto out;
3156 
3157 	if (wait_on_bit_lock(&xprt->state, XPRT_LOCKED, TASK_KILLABLE)) {
3158 		err = -EINTR;
3159 		goto out;
3160 	}
3161 	xprt_set_offline_locked(xprt, xps);
3162 
3163 	xprt_release_write(xprt, NULL);
3164 out:
3165 	xprt_put(xprt);
3166 	xprt_switch_put(xps);
3167 	return err;
3168 }
3169 
3170 /* rpc_clnt_manage_trunked_xprts -- offline trunked transports
3171  * @clnt rpc_clnt structure
3172  *
3173  * For each active transport found in the rpc_clnt structure call
3174  * the function rpc_xprt_offline() which will identify trunked transports
3175  * and will mark them offline.
3176  */
rpc_clnt_manage_trunked_xprts(struct rpc_clnt * clnt)3177 void rpc_clnt_manage_trunked_xprts(struct rpc_clnt *clnt)
3178 {
3179 	rpc_clnt_iterate_for_each_xprt(clnt, rpc_xprt_offline, NULL);
3180 }
3181 EXPORT_SYMBOL_GPL(rpc_clnt_manage_trunked_xprts);
3182 
3183 struct connect_timeout_data {
3184 	unsigned long connect_timeout;
3185 	unsigned long reconnect_timeout;
3186 };
3187 
3188 static int
rpc_xprt_set_connect_timeout(struct rpc_clnt * clnt,struct rpc_xprt * xprt,void * data)3189 rpc_xprt_set_connect_timeout(struct rpc_clnt *clnt,
3190 		struct rpc_xprt *xprt,
3191 		void *data)
3192 {
3193 	struct connect_timeout_data *timeo = data;
3194 
3195 	if (xprt->ops->set_connect_timeout)
3196 		xprt->ops->set_connect_timeout(xprt,
3197 				timeo->connect_timeout,
3198 				timeo->reconnect_timeout);
3199 	return 0;
3200 }
3201 
3202 void
rpc_set_connect_timeout(struct rpc_clnt * clnt,unsigned long connect_timeout,unsigned long reconnect_timeout)3203 rpc_set_connect_timeout(struct rpc_clnt *clnt,
3204 		unsigned long connect_timeout,
3205 		unsigned long reconnect_timeout)
3206 {
3207 	struct connect_timeout_data timeout = {
3208 		.connect_timeout = connect_timeout,
3209 		.reconnect_timeout = reconnect_timeout,
3210 	};
3211 	rpc_clnt_iterate_for_each_xprt(clnt,
3212 			rpc_xprt_set_connect_timeout,
3213 			&timeout);
3214 }
3215 EXPORT_SYMBOL_GPL(rpc_set_connect_timeout);
3216 
rpc_clnt_xprt_switch_put(struct rpc_clnt * clnt)3217 void rpc_clnt_xprt_switch_put(struct rpc_clnt *clnt)
3218 {
3219 	rcu_read_lock();
3220 	xprt_switch_put(rcu_dereference(clnt->cl_xpi.xpi_xpswitch));
3221 	rcu_read_unlock();
3222 }
3223 EXPORT_SYMBOL_GPL(rpc_clnt_xprt_switch_put);
3224 
rpc_clnt_xprt_set_online(struct rpc_clnt * clnt,struct rpc_xprt * xprt)3225 void rpc_clnt_xprt_set_online(struct rpc_clnt *clnt, struct rpc_xprt *xprt)
3226 {
3227 	struct rpc_xprt_switch *xps;
3228 
3229 	rcu_read_lock();
3230 	xps = rcu_dereference(clnt->cl_xpi.xpi_xpswitch);
3231 	rcu_read_unlock();
3232 	xprt_set_online_locked(xprt, xps);
3233 }
3234 
rpc_clnt_xprt_switch_add_xprt(struct rpc_clnt * clnt,struct rpc_xprt * xprt)3235 void rpc_clnt_xprt_switch_add_xprt(struct rpc_clnt *clnt, struct rpc_xprt *xprt)
3236 {
3237 	if (rpc_clnt_xprt_switch_has_addr(clnt,
3238 		(const struct sockaddr *)&xprt->addr)) {
3239 		return rpc_clnt_xprt_set_online(clnt, xprt);
3240 	}
3241 	rcu_read_lock();
3242 	rpc_xprt_switch_add_xprt(rcu_dereference(clnt->cl_xpi.xpi_xpswitch),
3243 				 xprt);
3244 	rcu_read_unlock();
3245 }
3246 EXPORT_SYMBOL_GPL(rpc_clnt_xprt_switch_add_xprt);
3247 
rpc_clnt_xprt_switch_remove_xprt(struct rpc_clnt * clnt,struct rpc_xprt * xprt)3248 void rpc_clnt_xprt_switch_remove_xprt(struct rpc_clnt *clnt, struct rpc_xprt *xprt)
3249 {
3250 	struct rpc_xprt_switch *xps;
3251 
3252 	rcu_read_lock();
3253 	xps = rcu_dereference(clnt->cl_xpi.xpi_xpswitch);
3254 	rpc_xprt_switch_remove_xprt(rcu_dereference(clnt->cl_xpi.xpi_xpswitch),
3255 				    xprt, 0);
3256 	xps->xps_nunique_destaddr_xprts--;
3257 	rcu_read_unlock();
3258 }
3259 EXPORT_SYMBOL_GPL(rpc_clnt_xprt_switch_remove_xprt);
3260 
rpc_clnt_xprt_switch_has_addr(struct rpc_clnt * clnt,const struct sockaddr * sap)3261 bool rpc_clnt_xprt_switch_has_addr(struct rpc_clnt *clnt,
3262 				   const struct sockaddr *sap)
3263 {
3264 	struct rpc_xprt_switch *xps;
3265 	bool ret;
3266 
3267 	rcu_read_lock();
3268 	xps = rcu_dereference(clnt->cl_xpi.xpi_xpswitch);
3269 	ret = rpc_xprt_switch_has_addr(xps, sap);
3270 	rcu_read_unlock();
3271 	return ret;
3272 }
3273 EXPORT_SYMBOL_GPL(rpc_clnt_xprt_switch_has_addr);
3274 
3275 #if IS_ENABLED(CONFIG_SUNRPC_DEBUG)
rpc_show_header(void)3276 static void rpc_show_header(void)
3277 {
3278 	printk(KERN_INFO "-pid- flgs status -client- --rqstp- "
3279 		"-timeout ---ops--\n");
3280 }
3281 
rpc_show_task(const struct rpc_clnt * clnt,const struct rpc_task * task)3282 static void rpc_show_task(const struct rpc_clnt *clnt,
3283 			  const struct rpc_task *task)
3284 {
3285 	const char *rpc_waitq = "none";
3286 
3287 	if (RPC_IS_QUEUED(task))
3288 		rpc_waitq = rpc_qname(task->tk_waitqueue);
3289 
3290 	printk(KERN_INFO "%5u %04x %6d %8p %8p %8ld %8p %sv%u %s a:%ps q:%s\n",
3291 		task->tk_pid, task->tk_flags, task->tk_status,
3292 		clnt, task->tk_rqstp, rpc_task_timeout(task), task->tk_ops,
3293 		clnt->cl_program->name, clnt->cl_vers, rpc_proc_name(task),
3294 		task->tk_action, rpc_waitq);
3295 }
3296 
rpc_show_tasks(struct net * net)3297 void rpc_show_tasks(struct net *net)
3298 {
3299 	struct rpc_clnt *clnt;
3300 	struct rpc_task *task;
3301 	int header = 0;
3302 	struct sunrpc_net *sn = net_generic(net, sunrpc_net_id);
3303 
3304 	spin_lock(&sn->rpc_client_lock);
3305 	list_for_each_entry(clnt, &sn->all_clients, cl_clients) {
3306 		spin_lock(&clnt->cl_lock);
3307 		list_for_each_entry(task, &clnt->cl_tasks, tk_task) {
3308 			if (!header) {
3309 				rpc_show_header();
3310 				header++;
3311 			}
3312 			rpc_show_task(clnt, task);
3313 		}
3314 		spin_unlock(&clnt->cl_lock);
3315 	}
3316 	spin_unlock(&sn->rpc_client_lock);
3317 }
3318 #endif
3319 
3320 #if IS_ENABLED(CONFIG_SUNRPC_SWAP)
3321 static int
rpc_clnt_swap_activate_callback(struct rpc_clnt * clnt,struct rpc_xprt * xprt,void * dummy)3322 rpc_clnt_swap_activate_callback(struct rpc_clnt *clnt,
3323 		struct rpc_xprt *xprt,
3324 		void *dummy)
3325 {
3326 	return xprt_enable_swap(xprt);
3327 }
3328 
3329 int
rpc_clnt_swap_activate(struct rpc_clnt * clnt)3330 rpc_clnt_swap_activate(struct rpc_clnt *clnt)
3331 {
3332 	while (clnt != clnt->cl_parent)
3333 		clnt = clnt->cl_parent;
3334 	if (atomic_inc_return(&clnt->cl_swapper) == 1)
3335 		return rpc_clnt_iterate_for_each_xprt(clnt,
3336 				rpc_clnt_swap_activate_callback, NULL);
3337 	return 0;
3338 }
3339 EXPORT_SYMBOL_GPL(rpc_clnt_swap_activate);
3340 
3341 static int
rpc_clnt_swap_deactivate_callback(struct rpc_clnt * clnt,struct rpc_xprt * xprt,void * dummy)3342 rpc_clnt_swap_deactivate_callback(struct rpc_clnt *clnt,
3343 		struct rpc_xprt *xprt,
3344 		void *dummy)
3345 {
3346 	xprt_disable_swap(xprt);
3347 	return 0;
3348 }
3349 
3350 void
rpc_clnt_swap_deactivate(struct rpc_clnt * clnt)3351 rpc_clnt_swap_deactivate(struct rpc_clnt *clnt)
3352 {
3353 	if (atomic_dec_if_positive(&clnt->cl_swapper) == 0)
3354 		rpc_clnt_iterate_for_each_xprt(clnt,
3355 				rpc_clnt_swap_deactivate_callback, NULL);
3356 }
3357 EXPORT_SYMBOL_GPL(rpc_clnt_swap_deactivate);
3358 #endif /* CONFIG_SUNRPC_SWAP */
3359