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