1 // SPDX-License-Identifier: GPL-2.0-only
3 * linux/net/sunrpc/clnt.c
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.
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.
17 * Copyright (C) 1992,1993 Rick Sladkey <jrs@world.std.com>
18 * Copyright (C) 1995,1996 Olaf Kirch <okir@monad.swb.de>
22 #include <linux/module.h>
23 #include <linux/types.h>
24 #include <linux/kallsyms.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>
33 #include <linux/in6.h>
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>
47 #if IS_ENABLED(CONFIG_SUNRPC_DEBUG)
48 # define RPCDBG_FACILITY RPCDBG_CALL
52 * All RPC clients are linked into this list
55 static DECLARE_WAIT_QUEUE_HEAD(destroy_wait
);
58 static void call_start(struct rpc_task
*task
);
59 static void call_reserve(struct rpc_task
*task
);
60 static void call_reserveresult(struct rpc_task
*task
);
61 static void call_allocate(struct rpc_task
*task
);
62 static void call_encode(struct rpc_task
*task
);
63 static void call_decode(struct rpc_task
*task
);
64 static void call_bind(struct rpc_task
*task
);
65 static void call_bind_status(struct rpc_task
*task
);
66 static void call_transmit(struct rpc_task
*task
);
67 static void call_status(struct rpc_task
*task
);
68 static void call_transmit_status(struct rpc_task
*task
);
69 static void call_refresh(struct rpc_task
*task
);
70 static void call_refreshresult(struct rpc_task
*task
);
71 static void call_connect(struct rpc_task
*task
);
72 static void call_connect_status(struct rpc_task
*task
);
74 static int rpc_encode_header(struct rpc_task
*task
,
75 struct xdr_stream
*xdr
);
76 static int rpc_decode_header(struct rpc_task
*task
,
77 struct xdr_stream
*xdr
);
78 static int rpc_ping(struct rpc_clnt
*clnt
);
79 static void rpc_check_timeout(struct rpc_task
*task
);
81 static void rpc_register_client(struct rpc_clnt
*clnt
)
83 struct net
*net
= rpc_net_ns(clnt
);
84 struct sunrpc_net
*sn
= net_generic(net
, sunrpc_net_id
);
86 spin_lock(&sn
->rpc_client_lock
);
87 list_add(&clnt
->cl_clients
, &sn
->all_clients
);
88 spin_unlock(&sn
->rpc_client_lock
);
91 static void rpc_unregister_client(struct rpc_clnt
*clnt
)
93 struct net
*net
= rpc_net_ns(clnt
);
94 struct sunrpc_net
*sn
= net_generic(net
, sunrpc_net_id
);
96 spin_lock(&sn
->rpc_client_lock
);
97 list_del(&clnt
->cl_clients
);
98 spin_unlock(&sn
->rpc_client_lock
);
101 static void __rpc_clnt_remove_pipedir(struct rpc_clnt
*clnt
)
103 rpc_remove_client_dir(clnt
);
106 static void rpc_clnt_remove_pipedir(struct rpc_clnt
*clnt
)
108 struct net
*net
= rpc_net_ns(clnt
);
109 struct super_block
*pipefs_sb
;
111 pipefs_sb
= rpc_get_sb_net(net
);
113 __rpc_clnt_remove_pipedir(clnt
);
118 static struct dentry
*rpc_setup_pipedir_sb(struct super_block
*sb
,
119 struct rpc_clnt
*clnt
)
121 static uint32_t clntid
;
122 const char *dir_name
= clnt
->cl_program
->pipe_dir_name
;
124 struct dentry
*dir
, *dentry
;
126 dir
= rpc_d_lookup_sb(sb
, dir_name
);
128 pr_info("RPC: pipefs directory doesn't exist: %s\n", dir_name
);
132 snprintf(name
, sizeof(name
), "clnt%x", (unsigned int)clntid
++);
133 name
[sizeof(name
) - 1] = '\0';
134 dentry
= rpc_create_client_dir(dir
, name
, clnt
);
137 if (dentry
== ERR_PTR(-EEXIST
))
139 printk(KERN_INFO
"RPC: Couldn't create pipefs entry"
140 " %s/%s, error %ld\n",
141 dir_name
, name
, PTR_ERR(dentry
));
149 rpc_setup_pipedir(struct super_block
*pipefs_sb
, struct rpc_clnt
*clnt
)
151 struct dentry
*dentry
;
153 if (clnt
->cl_program
->pipe_dir_name
!= NULL
) {
154 dentry
= rpc_setup_pipedir_sb(pipefs_sb
, clnt
);
156 return PTR_ERR(dentry
);
161 static int rpc_clnt_skip_event(struct rpc_clnt
*clnt
, unsigned long event
)
163 if (clnt
->cl_program
->pipe_dir_name
== NULL
)
167 case RPC_PIPEFS_MOUNT
:
168 if (clnt
->cl_pipedir_objects
.pdh_dentry
!= NULL
)
170 if (refcount_read(&clnt
->cl_count
) == 0)
173 case RPC_PIPEFS_UMOUNT
:
174 if (clnt
->cl_pipedir_objects
.pdh_dentry
== NULL
)
181 static int __rpc_clnt_handle_event(struct rpc_clnt
*clnt
, unsigned long event
,
182 struct super_block
*sb
)
184 struct dentry
*dentry
;
187 case RPC_PIPEFS_MOUNT
:
188 dentry
= rpc_setup_pipedir_sb(sb
, clnt
);
192 return PTR_ERR(dentry
);
194 case RPC_PIPEFS_UMOUNT
:
195 __rpc_clnt_remove_pipedir(clnt
);
198 printk(KERN_ERR
"%s: unknown event: %ld\n", __func__
, event
);
204 static int __rpc_pipefs_event(struct rpc_clnt
*clnt
, unsigned long event
,
205 struct super_block
*sb
)
209 for (;; clnt
= clnt
->cl_parent
) {
210 if (!rpc_clnt_skip_event(clnt
, event
))
211 error
= __rpc_clnt_handle_event(clnt
, event
, sb
);
212 if (error
|| clnt
== clnt
->cl_parent
)
218 static struct rpc_clnt
*rpc_get_client_for_event(struct net
*net
, int event
)
220 struct sunrpc_net
*sn
= net_generic(net
, sunrpc_net_id
);
221 struct rpc_clnt
*clnt
;
223 spin_lock(&sn
->rpc_client_lock
);
224 list_for_each_entry(clnt
, &sn
->all_clients
, cl_clients
) {
225 if (rpc_clnt_skip_event(clnt
, event
))
227 spin_unlock(&sn
->rpc_client_lock
);
230 spin_unlock(&sn
->rpc_client_lock
);
234 static int rpc_pipefs_event(struct notifier_block
*nb
, unsigned long event
,
237 struct super_block
*sb
= ptr
;
238 struct rpc_clnt
*clnt
;
241 while ((clnt
= rpc_get_client_for_event(sb
->s_fs_info
, event
))) {
242 error
= __rpc_pipefs_event(clnt
, event
, sb
);
249 static struct notifier_block rpc_clients_block
= {
250 .notifier_call
= rpc_pipefs_event
,
251 .priority
= SUNRPC_PIPEFS_RPC_PRIO
,
254 int rpc_clients_notifier_register(void)
256 return rpc_pipefs_notifier_register(&rpc_clients_block
);
259 void rpc_clients_notifier_unregister(void)
261 return rpc_pipefs_notifier_unregister(&rpc_clients_block
);
264 static struct rpc_xprt
*rpc_clnt_set_transport(struct rpc_clnt
*clnt
,
265 struct rpc_xprt
*xprt
,
266 const struct rpc_timeout
*timeout
)
268 struct rpc_xprt
*old
;
270 spin_lock(&clnt
->cl_lock
);
271 old
= rcu_dereference_protected(clnt
->cl_xprt
,
272 lockdep_is_held(&clnt
->cl_lock
));
274 if (!xprt_bound(xprt
))
275 clnt
->cl_autobind
= 1;
277 clnt
->cl_timeout
= timeout
;
278 rcu_assign_pointer(clnt
->cl_xprt
, xprt
);
279 spin_unlock(&clnt
->cl_lock
);
284 static void rpc_clnt_set_nodename(struct rpc_clnt
*clnt
, const char *nodename
)
286 clnt
->cl_nodelen
= strlcpy(clnt
->cl_nodename
,
287 nodename
, sizeof(clnt
->cl_nodename
));
290 static int rpc_client_register(struct rpc_clnt
*clnt
,
291 rpc_authflavor_t pseudoflavor
,
292 const char *client_name
)
294 struct rpc_auth_create_args auth_args
= {
295 .pseudoflavor
= pseudoflavor
,
296 .target_name
= client_name
,
298 struct rpc_auth
*auth
;
299 struct net
*net
= rpc_net_ns(clnt
);
300 struct super_block
*pipefs_sb
;
303 rpc_clnt_debugfs_register(clnt
);
305 pipefs_sb
= rpc_get_sb_net(net
);
307 err
= rpc_setup_pipedir(pipefs_sb
, clnt
);
312 rpc_register_client(clnt
);
316 auth
= rpcauth_create(&auth_args
, clnt
);
318 dprintk("RPC: Couldn't create auth handle (flavor %u)\n",
325 pipefs_sb
= rpc_get_sb_net(net
);
326 rpc_unregister_client(clnt
);
327 __rpc_clnt_remove_pipedir(clnt
);
331 rpc_sysfs_client_destroy(clnt
);
332 rpc_clnt_debugfs_unregister(clnt
);
336 static DEFINE_IDA(rpc_clids
);
338 void rpc_cleanup_clids(void)
340 ida_destroy(&rpc_clids
);
343 static int rpc_alloc_clid(struct rpc_clnt
*clnt
)
347 clid
= ida_simple_get(&rpc_clids
, 0, 0, GFP_KERNEL
);
350 clnt
->cl_clid
= clid
;
354 static void rpc_free_clid(struct rpc_clnt
*clnt
)
356 ida_simple_remove(&rpc_clids
, clnt
->cl_clid
);
359 static struct rpc_clnt
* rpc_new_client(const struct rpc_create_args
*args
,
360 struct rpc_xprt_switch
*xps
,
361 struct rpc_xprt
*xprt
,
362 struct rpc_clnt
*parent
)
364 const struct rpc_program
*program
= args
->program
;
365 const struct rpc_version
*version
;
366 struct rpc_clnt
*clnt
= NULL
;
367 const struct rpc_timeout
*timeout
;
368 const char *nodename
= args
->nodename
;
376 if (args
->version
>= program
->nrvers
)
378 version
= program
->version
[args
->version
];
383 clnt
= kzalloc(sizeof(*clnt
), GFP_KERNEL
);
386 clnt
->cl_parent
= parent
? : clnt
;
388 err
= rpc_alloc_clid(clnt
);
392 clnt
->cl_cred
= get_cred(args
->cred
);
393 clnt
->cl_procinfo
= version
->procs
;
394 clnt
->cl_maxproc
= version
->nrprocs
;
395 clnt
->cl_prog
= args
->prognumber
? : program
->number
;
396 clnt
->cl_vers
= version
->number
;
397 clnt
->cl_stats
= program
->stats
;
398 clnt
->cl_metrics
= rpc_alloc_iostats(clnt
);
399 rpc_init_pipe_dir_head(&clnt
->cl_pipedir_objects
);
401 if (clnt
->cl_metrics
== NULL
)
403 clnt
->cl_program
= program
;
404 INIT_LIST_HEAD(&clnt
->cl_tasks
);
405 spin_lock_init(&clnt
->cl_lock
);
407 timeout
= xprt
->timeout
;
408 if (args
->timeout
!= NULL
) {
409 memcpy(&clnt
->cl_timeout_default
, args
->timeout
,
410 sizeof(clnt
->cl_timeout_default
));
411 timeout
= &clnt
->cl_timeout_default
;
414 rpc_clnt_set_transport(clnt
, xprt
, timeout
);
416 xprt_iter_init(&clnt
->cl_xpi
, xps
);
417 xprt_switch_put(xps
);
419 clnt
->cl_rtt
= &clnt
->cl_rtt_default
;
420 rpc_init_rtt(&clnt
->cl_rtt_default
, clnt
->cl_timeout
->to_initval
);
422 refcount_set(&clnt
->cl_count
, 1);
424 if (nodename
== NULL
)
425 nodename
= utsname()->nodename
;
426 /* save the nodename */
427 rpc_clnt_set_nodename(clnt
, nodename
);
429 rpc_sysfs_client_setup(clnt
, xps
, rpc_net_ns(clnt
));
430 err
= rpc_client_register(clnt
, args
->authflavor
, args
->client_name
);
434 refcount_inc(&parent
->cl_count
);
436 trace_rpc_clnt_new(clnt
, xprt
, program
->name
, args
->servername
);
440 rpc_free_iostats(clnt
->cl_metrics
);
442 put_cred(clnt
->cl_cred
);
449 xprt_switch_put(xps
);
451 trace_rpc_clnt_new_err(program
->name
, args
->servername
, err
);
455 static struct rpc_clnt
*rpc_create_xprt(struct rpc_create_args
*args
,
456 struct rpc_xprt
*xprt
)
458 struct rpc_clnt
*clnt
= NULL
;
459 struct rpc_xprt_switch
*xps
;
461 if (args
->bc_xprt
&& args
->bc_xprt
->xpt_bc_xps
) {
462 WARN_ON_ONCE(!(args
->protocol
& XPRT_TRANSPORT_BC
));
463 xps
= args
->bc_xprt
->xpt_bc_xps
;
464 xprt_switch_get(xps
);
466 xps
= xprt_switch_alloc(xprt
, GFP_KERNEL
);
469 return ERR_PTR(-ENOMEM
);
472 xprt_switch_get(xps
);
473 xprt
->bc_xprt
->xpt_bc_xps
= xps
;
476 clnt
= rpc_new_client(args
, xps
, xprt
, NULL
);
480 if (!(args
->flags
& RPC_CLNT_CREATE_NOPING
)) {
481 int err
= rpc_ping(clnt
);
483 rpc_shutdown_client(clnt
);
488 clnt
->cl_softrtry
= 1;
489 if (args
->flags
& (RPC_CLNT_CREATE_HARDRTRY
|RPC_CLNT_CREATE_SOFTERR
)) {
490 clnt
->cl_softrtry
= 0;
491 if (args
->flags
& RPC_CLNT_CREATE_SOFTERR
)
492 clnt
->cl_softerr
= 1;
495 if (args
->flags
& RPC_CLNT_CREATE_AUTOBIND
)
496 clnt
->cl_autobind
= 1;
497 if (args
->flags
& RPC_CLNT_CREATE_NO_RETRANS_TIMEOUT
)
498 clnt
->cl_noretranstimeo
= 1;
499 if (args
->flags
& RPC_CLNT_CREATE_DISCRTRY
)
500 clnt
->cl_discrtry
= 1;
501 if (!(args
->flags
& RPC_CLNT_CREATE_QUIET
))
508 * rpc_create - create an RPC client and transport with one call
509 * @args: rpc_clnt create argument structure
511 * Creates and initializes an RPC transport and an RPC client.
513 * It can ping the server in order to determine if it is up, and to see if
514 * it supports this program and version. RPC_CLNT_CREATE_NOPING disables
515 * this behavior so asynchronous tasks can also use rpc_create.
517 struct rpc_clnt
*rpc_create(struct rpc_create_args
*args
)
519 struct rpc_xprt
*xprt
;
520 struct xprt_create xprtargs
= {
522 .ident
= args
->protocol
,
523 .srcaddr
= args
->saddress
,
524 .dstaddr
= args
->address
,
525 .addrlen
= args
->addrsize
,
526 .servername
= args
->servername
,
527 .bc_xprt
= args
->bc_xprt
,
530 struct rpc_clnt
*clnt
;
534 WARN_ON_ONCE(!(args
->protocol
& XPRT_TRANSPORT_BC
));
535 xprt
= args
->bc_xprt
->xpt_bc_xprt
;
538 return rpc_create_xprt(args
, xprt
);
542 if (args
->flags
& RPC_CLNT_CREATE_INFINITE_SLOTS
)
543 xprtargs
.flags
|= XPRT_CREATE_INFINITE_SLOTS
;
544 if (args
->flags
& RPC_CLNT_CREATE_NO_IDLE_TIMEOUT
)
545 xprtargs
.flags
|= XPRT_CREATE_NO_IDLE_TIMEOUT
;
547 * If the caller chooses not to specify a hostname, whip
548 * up a string representation of the passed-in address.
550 if (xprtargs
.servername
== NULL
) {
551 struct sockaddr_un
*sun
=
552 (struct sockaddr_un
*)args
->address
;
553 struct sockaddr_in
*sin
=
554 (struct sockaddr_in
*)args
->address
;
555 struct sockaddr_in6
*sin6
=
556 (struct sockaddr_in6
*)args
->address
;
558 servername
[0] = '\0';
559 switch (args
->address
->sa_family
) {
561 snprintf(servername
, sizeof(servername
), "%s",
565 snprintf(servername
, sizeof(servername
), "%pI4",
566 &sin
->sin_addr
.s_addr
);
569 snprintf(servername
, sizeof(servername
), "%pI6",
573 /* caller wants default server name, but
574 * address family isn't recognized. */
575 return ERR_PTR(-EINVAL
);
577 xprtargs
.servername
= servername
;
580 xprt
= xprt_create_transport(&xprtargs
);
582 return (struct rpc_clnt
*)xprt
;
585 * By default, kernel RPC client connects from a reserved port.
586 * CAP_NET_BIND_SERVICE will not be set for unprivileged requesters,
587 * but it is always enabled for rpciod, which handles the connect
591 if (args
->flags
& RPC_CLNT_CREATE_NONPRIVPORT
)
594 if (args
->flags
& RPC_CLNT_CREATE_REUSEPORT
)
597 clnt
= rpc_create_xprt(args
, xprt
);
598 if (IS_ERR(clnt
) || args
->nconnect
<= 1)
601 for (i
= 0; i
< args
->nconnect
- 1; i
++) {
602 if (rpc_clnt_add_xprt(clnt
, &xprtargs
, NULL
, NULL
) < 0)
607 EXPORT_SYMBOL_GPL(rpc_create
);
610 * This function clones the RPC client structure. It allows us to share the
611 * same transport while varying parameters such as the authentication
614 static struct rpc_clnt
*__rpc_clone_client(struct rpc_create_args
*args
,
615 struct rpc_clnt
*clnt
)
617 struct rpc_xprt_switch
*xps
;
618 struct rpc_xprt
*xprt
;
619 struct rpc_clnt
*new;
624 xprt
= xprt_get(rcu_dereference(clnt
->cl_xprt
));
625 xps
= xprt_switch_get(rcu_dereference(clnt
->cl_xpi
.xpi_xpswitch
));
627 if (xprt
== NULL
|| xps
== NULL
) {
629 xprt_switch_put(xps
);
632 args
->servername
= xprt
->servername
;
633 args
->nodename
= clnt
->cl_nodename
;
635 new = rpc_new_client(args
, xps
, xprt
, clnt
);
639 /* Turn off autobind on clones */
640 new->cl_autobind
= 0;
641 new->cl_softrtry
= clnt
->cl_softrtry
;
642 new->cl_softerr
= clnt
->cl_softerr
;
643 new->cl_noretranstimeo
= clnt
->cl_noretranstimeo
;
644 new->cl_discrtry
= clnt
->cl_discrtry
;
645 new->cl_chatty
= clnt
->cl_chatty
;
646 new->cl_principal
= clnt
->cl_principal
;
650 trace_rpc_clnt_clone_err(clnt
, err
);
655 * rpc_clone_client - Clone an RPC client structure
657 * @clnt: RPC client whose parameters are copied
659 * Returns a fresh RPC client or an ERR_PTR.
661 struct rpc_clnt
*rpc_clone_client(struct rpc_clnt
*clnt
)
663 struct rpc_create_args args
= {
664 .program
= clnt
->cl_program
,
665 .prognumber
= clnt
->cl_prog
,
666 .version
= clnt
->cl_vers
,
667 .authflavor
= clnt
->cl_auth
->au_flavor
,
668 .cred
= clnt
->cl_cred
,
670 return __rpc_clone_client(&args
, clnt
);
672 EXPORT_SYMBOL_GPL(rpc_clone_client
);
675 * rpc_clone_client_set_auth - Clone an RPC client structure and set its auth
677 * @clnt: RPC client whose parameters are copied
678 * @flavor: security flavor for new client
680 * Returns a fresh RPC client or an ERR_PTR.
683 rpc_clone_client_set_auth(struct rpc_clnt
*clnt
, rpc_authflavor_t flavor
)
685 struct rpc_create_args args
= {
686 .program
= clnt
->cl_program
,
687 .prognumber
= clnt
->cl_prog
,
688 .version
= clnt
->cl_vers
,
689 .authflavor
= flavor
,
690 .cred
= clnt
->cl_cred
,
692 return __rpc_clone_client(&args
, clnt
);
694 EXPORT_SYMBOL_GPL(rpc_clone_client_set_auth
);
697 * rpc_switch_client_transport: switch the RPC transport on the fly
698 * @clnt: pointer to a struct rpc_clnt
699 * @args: pointer to the new transport arguments
700 * @timeout: pointer to the new timeout parameters
702 * This function allows the caller to switch the RPC transport for the
703 * rpc_clnt structure 'clnt' to allow it to connect to a mirrored NFS
704 * server, for instance. It assumes that the caller has ensured that
705 * there are no active RPC tasks by using some form of locking.
707 * Returns zero if "clnt" is now using the new xprt. Otherwise a
708 * negative errno is returned, and "clnt" continues to use the old
711 int rpc_switch_client_transport(struct rpc_clnt
*clnt
,
712 struct xprt_create
*args
,
713 const struct rpc_timeout
*timeout
)
715 const struct rpc_timeout
*old_timeo
;
716 rpc_authflavor_t pseudoflavor
;
717 struct rpc_xprt_switch
*xps
, *oldxps
;
718 struct rpc_xprt
*xprt
, *old
;
719 struct rpc_clnt
*parent
;
722 xprt
= xprt_create_transport(args
);
724 return PTR_ERR(xprt
);
726 xps
= xprt_switch_alloc(xprt
, GFP_KERNEL
);
732 pseudoflavor
= clnt
->cl_auth
->au_flavor
;
734 old_timeo
= clnt
->cl_timeout
;
735 old
= rpc_clnt_set_transport(clnt
, xprt
, timeout
);
736 oldxps
= xprt_iter_xchg_switch(&clnt
->cl_xpi
, xps
);
738 rpc_unregister_client(clnt
);
739 __rpc_clnt_remove_pipedir(clnt
);
740 rpc_sysfs_client_destroy(clnt
);
741 rpc_clnt_debugfs_unregister(clnt
);
744 * A new transport was created. "clnt" therefore
745 * becomes the root of a new cl_parent tree. clnt's
746 * children, if it has any, still point to the old xprt.
748 parent
= clnt
->cl_parent
;
749 clnt
->cl_parent
= clnt
;
752 * The old rpc_auth cache cannot be re-used. GSS
753 * contexts in particular are between a single
756 err
= rpc_client_register(clnt
, pseudoflavor
, NULL
);
762 rpc_release_client(parent
);
763 xprt_switch_put(oldxps
);
765 trace_rpc_clnt_replace_xprt(clnt
);
769 xps
= xprt_iter_xchg_switch(&clnt
->cl_xpi
, oldxps
);
770 rpc_clnt_set_transport(clnt
, old
, old_timeo
);
771 clnt
->cl_parent
= parent
;
772 rpc_client_register(clnt
, pseudoflavor
, NULL
);
773 xprt_switch_put(xps
);
775 trace_rpc_clnt_replace_xprt_err(clnt
);
778 EXPORT_SYMBOL_GPL(rpc_switch_client_transport
);
781 int rpc_clnt_xprt_iter_init(struct rpc_clnt
*clnt
, struct rpc_xprt_iter
*xpi
)
783 struct rpc_xprt_switch
*xps
;
786 xps
= xprt_switch_get(rcu_dereference(clnt
->cl_xpi
.xpi_xpswitch
));
790 xprt_iter_init_listall(xpi
, xps
);
791 xprt_switch_put(xps
);
796 * rpc_clnt_iterate_for_each_xprt - Apply a function to all transports
797 * @clnt: pointer to client
798 * @fn: function to apply
799 * @data: void pointer to function data
801 * Iterates through the list of RPC transports currently attached to the
802 * client and applies the function fn(clnt, xprt, data).
804 * On error, the iteration stops, and the function returns the error value.
806 int rpc_clnt_iterate_for_each_xprt(struct rpc_clnt
*clnt
,
807 int (*fn
)(struct rpc_clnt
*, struct rpc_xprt
*, void *),
810 struct rpc_xprt_iter xpi
;
813 ret
= rpc_clnt_xprt_iter_init(clnt
, &xpi
);
817 struct rpc_xprt
*xprt
= xprt_iter_get_next(&xpi
);
821 ret
= fn(clnt
, xprt
, data
);
826 xprt_iter_destroy(&xpi
);
829 EXPORT_SYMBOL_GPL(rpc_clnt_iterate_for_each_xprt
);
832 * Kill all tasks for the given client.
833 * XXX: kill their descendants as well?
835 void rpc_killall_tasks(struct rpc_clnt
*clnt
)
837 struct rpc_task
*rovr
;
840 if (list_empty(&clnt
->cl_tasks
))
844 * Spin lock all_tasks to prevent changes...
846 trace_rpc_clnt_killall(clnt
);
847 spin_lock(&clnt
->cl_lock
);
848 list_for_each_entry(rovr
, &clnt
->cl_tasks
, tk_task
)
849 rpc_signal_task(rovr
);
850 spin_unlock(&clnt
->cl_lock
);
852 EXPORT_SYMBOL_GPL(rpc_killall_tasks
);
855 * Properly shut down an RPC client, terminating all outstanding
858 void rpc_shutdown_client(struct rpc_clnt
*clnt
)
862 trace_rpc_clnt_shutdown(clnt
);
864 while (!list_empty(&clnt
->cl_tasks
)) {
865 rpc_killall_tasks(clnt
);
866 wait_event_timeout(destroy_wait
,
867 list_empty(&clnt
->cl_tasks
), 1*HZ
);
870 rpc_release_client(clnt
);
872 EXPORT_SYMBOL_GPL(rpc_shutdown_client
);
877 static void rpc_free_client_work(struct work_struct
*work
)
879 struct rpc_clnt
*clnt
= container_of(work
, struct rpc_clnt
, cl_work
);
881 trace_rpc_clnt_free(clnt
);
883 /* These might block on processes that might allocate memory,
884 * so they cannot be called in rpciod, so they are handled separately
887 rpc_sysfs_client_destroy(clnt
);
888 rpc_clnt_debugfs_unregister(clnt
);
890 rpc_clnt_remove_pipedir(clnt
);
891 xprt_put(rcu_dereference_raw(clnt
->cl_xprt
));
896 static struct rpc_clnt
*
897 rpc_free_client(struct rpc_clnt
*clnt
)
899 struct rpc_clnt
*parent
= NULL
;
901 trace_rpc_clnt_release(clnt
);
902 if (clnt
->cl_parent
!= clnt
)
903 parent
= clnt
->cl_parent
;
904 rpc_unregister_client(clnt
);
905 rpc_free_iostats(clnt
->cl_metrics
);
906 clnt
->cl_metrics
= NULL
;
907 xprt_iter_destroy(&clnt
->cl_xpi
);
908 put_cred(clnt
->cl_cred
);
910 INIT_WORK(&clnt
->cl_work
, rpc_free_client_work
);
911 schedule_work(&clnt
->cl_work
);
918 static struct rpc_clnt
*
919 rpc_free_auth(struct rpc_clnt
*clnt
)
922 * Note: RPCSEC_GSS may need to send NULL RPC calls in order to
923 * release remaining GSS contexts. This mechanism ensures
924 * that it can do so safely.
926 if (clnt
->cl_auth
!= NULL
) {
927 rpcauth_release(clnt
->cl_auth
);
928 clnt
->cl_auth
= NULL
;
930 if (refcount_dec_and_test(&clnt
->cl_count
))
931 return rpc_free_client(clnt
);
936 * Release reference to the RPC client
939 rpc_release_client(struct rpc_clnt
*clnt
)
942 if (list_empty(&clnt
->cl_tasks
))
943 wake_up(&destroy_wait
);
944 if (refcount_dec_not_one(&clnt
->cl_count
))
946 clnt
= rpc_free_auth(clnt
);
947 } while (clnt
!= NULL
);
949 EXPORT_SYMBOL_GPL(rpc_release_client
);
952 * rpc_bind_new_program - bind a new RPC program to an existing client
953 * @old: old rpc_client
954 * @program: rpc program to set
955 * @vers: rpc program version
957 * Clones the rpc client and sets up a new RPC program. This is mainly
958 * of use for enabling different RPC programs to share the same transport.
959 * The Sun NFSv2/v3 ACL protocol can do this.
961 struct rpc_clnt
*rpc_bind_new_program(struct rpc_clnt
*old
,
962 const struct rpc_program
*program
,
965 struct rpc_create_args args
= {
967 .prognumber
= program
->number
,
969 .authflavor
= old
->cl_auth
->au_flavor
,
970 .cred
= old
->cl_cred
,
972 struct rpc_clnt
*clnt
;
975 clnt
= __rpc_clone_client(&args
, old
);
978 err
= rpc_ping(clnt
);
980 rpc_shutdown_client(clnt
);
986 EXPORT_SYMBOL_GPL(rpc_bind_new_program
);
989 rpc_task_get_xprt(struct rpc_clnt
*clnt
, struct rpc_xprt
*xprt
)
991 struct rpc_xprt_switch
*xps
;
996 xps
= rcu_dereference(clnt
->cl_xpi
.xpi_xpswitch
);
997 atomic_long_inc(&xps
->xps_queuelen
);
999 atomic_long_inc(&xprt
->queuelen
);
1005 rpc_task_release_xprt(struct rpc_clnt
*clnt
, struct rpc_xprt
*xprt
)
1007 struct rpc_xprt_switch
*xps
;
1009 atomic_long_dec(&xprt
->queuelen
);
1011 xps
= rcu_dereference(clnt
->cl_xpi
.xpi_xpswitch
);
1012 atomic_long_dec(&xps
->xps_queuelen
);
1018 void rpc_task_release_transport(struct rpc_task
*task
)
1020 struct rpc_xprt
*xprt
= task
->tk_xprt
;
1023 task
->tk_xprt
= NULL
;
1024 if (task
->tk_client
)
1025 rpc_task_release_xprt(task
->tk_client
, xprt
);
1030 EXPORT_SYMBOL_GPL(rpc_task_release_transport
);
1032 void rpc_task_release_client(struct rpc_task
*task
)
1034 struct rpc_clnt
*clnt
= task
->tk_client
;
1036 rpc_task_release_transport(task
);
1038 /* Remove from client task list */
1039 spin_lock(&clnt
->cl_lock
);
1040 list_del(&task
->tk_task
);
1041 spin_unlock(&clnt
->cl_lock
);
1042 task
->tk_client
= NULL
;
1044 rpc_release_client(clnt
);
1048 static struct rpc_xprt
*
1049 rpc_task_get_first_xprt(struct rpc_clnt
*clnt
)
1051 struct rpc_xprt
*xprt
;
1054 xprt
= xprt_get(rcu_dereference(clnt
->cl_xprt
));
1056 return rpc_task_get_xprt(clnt
, xprt
);
1059 static struct rpc_xprt
*
1060 rpc_task_get_next_xprt(struct rpc_clnt
*clnt
)
1062 return rpc_task_get_xprt(clnt
, xprt_iter_get_next(&clnt
->cl_xpi
));
1066 void rpc_task_set_transport(struct rpc_task
*task
, struct rpc_clnt
*clnt
)
1068 if (task
->tk_xprt
&&
1069 !(test_bit(XPRT_OFFLINE
, &task
->tk_xprt
->state
) &&
1070 (task
->tk_flags
& RPC_TASK_MOVEABLE
)))
1072 if (task
->tk_flags
& RPC_TASK_NO_ROUND_ROBIN
)
1073 task
->tk_xprt
= rpc_task_get_first_xprt(clnt
);
1075 task
->tk_xprt
= rpc_task_get_next_xprt(clnt
);
1079 void rpc_task_set_client(struct rpc_task
*task
, struct rpc_clnt
*clnt
)
1083 rpc_task_set_transport(task
, clnt
);
1084 task
->tk_client
= clnt
;
1085 refcount_inc(&clnt
->cl_count
);
1086 if (clnt
->cl_softrtry
)
1087 task
->tk_flags
|= RPC_TASK_SOFT
;
1088 if (clnt
->cl_softerr
)
1089 task
->tk_flags
|= RPC_TASK_TIMEOUT
;
1090 if (clnt
->cl_noretranstimeo
)
1091 task
->tk_flags
|= RPC_TASK_NO_RETRANS_TIMEOUT
;
1092 if (atomic_read(&clnt
->cl_swapper
))
1093 task
->tk_flags
|= RPC_TASK_SWAPPER
;
1094 /* Add to the client's list of all tasks */
1095 spin_lock(&clnt
->cl_lock
);
1096 list_add_tail(&task
->tk_task
, &clnt
->cl_tasks
);
1097 spin_unlock(&clnt
->cl_lock
);
1102 rpc_task_set_rpc_message(struct rpc_task
*task
, const struct rpc_message
*msg
)
1105 task
->tk_msg
.rpc_proc
= msg
->rpc_proc
;
1106 task
->tk_msg
.rpc_argp
= msg
->rpc_argp
;
1107 task
->tk_msg
.rpc_resp
= msg
->rpc_resp
;
1108 task
->tk_msg
.rpc_cred
= msg
->rpc_cred
;
1109 if (!(task
->tk_flags
& RPC_TASK_CRED_NOREF
))
1110 get_cred(task
->tk_msg
.rpc_cred
);
1115 * Default callback for async RPC calls
1118 rpc_default_callback(struct rpc_task
*task
, void *data
)
1122 static const struct rpc_call_ops rpc_default_ops
= {
1123 .rpc_call_done
= rpc_default_callback
,
1127 * rpc_run_task - Allocate a new RPC task, then run rpc_execute against it
1128 * @task_setup_data: pointer to task initialisation data
1130 struct rpc_task
*rpc_run_task(const struct rpc_task_setup
*task_setup_data
)
1132 struct rpc_task
*task
;
1134 task
= rpc_new_task(task_setup_data
);
1136 if (!RPC_IS_ASYNC(task
))
1137 task
->tk_flags
|= RPC_TASK_CRED_NOREF
;
1139 rpc_task_set_client(task
, task_setup_data
->rpc_client
);
1140 rpc_task_set_rpc_message(task
, task_setup_data
->rpc_message
);
1142 if (task
->tk_action
== NULL
)
1143 rpc_call_start(task
);
1145 atomic_inc(&task
->tk_count
);
1149 EXPORT_SYMBOL_GPL(rpc_run_task
);
1152 * rpc_call_sync - Perform a synchronous RPC call
1153 * @clnt: pointer to RPC client
1154 * @msg: RPC call parameters
1155 * @flags: RPC call flags
1157 int rpc_call_sync(struct rpc_clnt
*clnt
, const struct rpc_message
*msg
, int flags
)
1159 struct rpc_task
*task
;
1160 struct rpc_task_setup task_setup_data
= {
1163 .callback_ops
= &rpc_default_ops
,
1168 WARN_ON_ONCE(flags
& RPC_TASK_ASYNC
);
1169 if (flags
& RPC_TASK_ASYNC
) {
1170 rpc_release_calldata(task_setup_data
.callback_ops
,
1171 task_setup_data
.callback_data
);
1175 task
= rpc_run_task(&task_setup_data
);
1177 return PTR_ERR(task
);
1178 status
= task
->tk_status
;
1182 EXPORT_SYMBOL_GPL(rpc_call_sync
);
1185 * rpc_call_async - Perform an asynchronous RPC call
1186 * @clnt: pointer to RPC client
1187 * @msg: RPC call parameters
1188 * @flags: RPC call flags
1189 * @tk_ops: RPC call ops
1190 * @data: user call data
1193 rpc_call_async(struct rpc_clnt
*clnt
, const struct rpc_message
*msg
, int flags
,
1194 const struct rpc_call_ops
*tk_ops
, void *data
)
1196 struct rpc_task
*task
;
1197 struct rpc_task_setup task_setup_data
= {
1200 .callback_ops
= tk_ops
,
1201 .callback_data
= data
,
1202 .flags
= flags
|RPC_TASK_ASYNC
,
1205 task
= rpc_run_task(&task_setup_data
);
1207 return PTR_ERR(task
);
1211 EXPORT_SYMBOL_GPL(rpc_call_async
);
1213 #if defined(CONFIG_SUNRPC_BACKCHANNEL)
1214 static void call_bc_encode(struct rpc_task
*task
);
1217 * rpc_run_bc_task - Allocate a new RPC task for backchannel use, then run
1218 * rpc_execute against it
1221 struct rpc_task
*rpc_run_bc_task(struct rpc_rqst
*req
)
1223 struct rpc_task
*task
;
1224 struct rpc_task_setup task_setup_data
= {
1225 .callback_ops
= &rpc_default_ops
,
1226 .flags
= RPC_TASK_SOFTCONN
|
1227 RPC_TASK_NO_RETRANS_TIMEOUT
,
1230 dprintk("RPC: rpc_run_bc_task req= %p\n", req
);
1232 * Create an rpc_task to send the data
1234 task
= rpc_new_task(&task_setup_data
);
1235 xprt_init_bc_request(req
, task
);
1237 task
->tk_action
= call_bc_encode
;
1238 atomic_inc(&task
->tk_count
);
1239 WARN_ON_ONCE(atomic_read(&task
->tk_count
) != 2);
1242 dprintk("RPC: rpc_run_bc_task: task= %p\n", task
);
1245 #endif /* CONFIG_SUNRPC_BACKCHANNEL */
1248 * rpc_prepare_reply_pages - Prepare to receive a reply data payload into pages
1249 * @req: RPC request to prepare
1250 * @pages: vector of struct page pointers
1251 * @base: offset in first page where receive should start, in bytes
1252 * @len: expected size of the upper layer data payload, in bytes
1253 * @hdrsize: expected size of upper layer reply header, in XDR words
1256 void rpc_prepare_reply_pages(struct rpc_rqst
*req
, struct page
**pages
,
1257 unsigned int base
, unsigned int len
,
1258 unsigned int hdrsize
)
1260 hdrsize
+= RPC_REPHDRSIZE
+ req
->rq_cred
->cr_auth
->au_ralign
;
1262 xdr_inline_pages(&req
->rq_rcv_buf
, hdrsize
<< 2, pages
, base
, len
);
1263 trace_rpc_xdr_reply_pages(req
->rq_task
, &req
->rq_rcv_buf
);
1265 EXPORT_SYMBOL_GPL(rpc_prepare_reply_pages
);
1268 rpc_call_start(struct rpc_task
*task
)
1270 task
->tk_action
= call_start
;
1272 EXPORT_SYMBOL_GPL(rpc_call_start
);
1275 * rpc_peeraddr - extract remote peer address from clnt's xprt
1276 * @clnt: RPC client structure
1277 * @buf: target buffer
1278 * @bufsize: length of target buffer
1280 * Returns the number of bytes that are actually in the stored address.
1282 size_t rpc_peeraddr(struct rpc_clnt
*clnt
, struct sockaddr
*buf
, size_t bufsize
)
1285 struct rpc_xprt
*xprt
;
1288 xprt
= rcu_dereference(clnt
->cl_xprt
);
1290 bytes
= xprt
->addrlen
;
1291 if (bytes
> bufsize
)
1293 memcpy(buf
, &xprt
->addr
, bytes
);
1298 EXPORT_SYMBOL_GPL(rpc_peeraddr
);
1301 * rpc_peeraddr2str - return remote peer address in printable format
1302 * @clnt: RPC client structure
1303 * @format: address format
1305 * NB: the lifetime of the memory referenced by the returned pointer is
1306 * the same as the rpc_xprt itself. As long as the caller uses this
1307 * pointer, it must hold the RCU read lock.
1309 const char *rpc_peeraddr2str(struct rpc_clnt
*clnt
,
1310 enum rpc_display_format_t format
)
1312 struct rpc_xprt
*xprt
;
1314 xprt
= rcu_dereference(clnt
->cl_xprt
);
1316 if (xprt
->address_strings
[format
] != NULL
)
1317 return xprt
->address_strings
[format
];
1319 return "unprintable";
1321 EXPORT_SYMBOL_GPL(rpc_peeraddr2str
);
1323 static const struct sockaddr_in rpc_inaddr_loopback
= {
1324 .sin_family
= AF_INET
,
1325 .sin_addr
.s_addr
= htonl(INADDR_ANY
),
1328 static const struct sockaddr_in6 rpc_in6addr_loopback
= {
1329 .sin6_family
= AF_INET6
,
1330 .sin6_addr
= IN6ADDR_ANY_INIT
,
1334 * Try a getsockname() on a connected datagram socket. Using a
1335 * connected datagram socket prevents leaving a socket in TIME_WAIT.
1336 * This conserves the ephemeral port number space.
1338 * Returns zero and fills in "buf" if successful; otherwise, a
1339 * negative errno is returned.
1341 static int rpc_sockname(struct net
*net
, struct sockaddr
*sap
, size_t salen
,
1342 struct sockaddr
*buf
)
1344 struct socket
*sock
;
1347 err
= __sock_create(net
, sap
->sa_family
,
1348 SOCK_DGRAM
, IPPROTO_UDP
, &sock
, 1);
1350 dprintk("RPC: can't create UDP socket (%d)\n", err
);
1354 switch (sap
->sa_family
) {
1356 err
= kernel_bind(sock
,
1357 (struct sockaddr
*)&rpc_inaddr_loopback
,
1358 sizeof(rpc_inaddr_loopback
));
1361 err
= kernel_bind(sock
,
1362 (struct sockaddr
*)&rpc_in6addr_loopback
,
1363 sizeof(rpc_in6addr_loopback
));
1366 err
= -EAFNOSUPPORT
;
1370 dprintk("RPC: can't bind UDP socket (%d)\n", err
);
1374 err
= kernel_connect(sock
, sap
, salen
, 0);
1376 dprintk("RPC: can't connect UDP socket (%d)\n", err
);
1380 err
= kernel_getsockname(sock
, buf
);
1382 dprintk("RPC: getsockname failed (%d)\n", err
);
1387 if (buf
->sa_family
== AF_INET6
) {
1388 struct sockaddr_in6
*sin6
= (struct sockaddr_in6
*)buf
;
1389 sin6
->sin6_scope_id
= 0;
1391 dprintk("RPC: %s succeeded\n", __func__
);
1400 * Scraping a connected socket failed, so we don't have a useable
1401 * local address. Fallback: generate an address that will prevent
1402 * the server from calling us back.
1404 * Returns zero and fills in "buf" if successful; otherwise, a
1405 * negative errno is returned.
1407 static int rpc_anyaddr(int family
, struct sockaddr
*buf
, size_t buflen
)
1411 if (buflen
< sizeof(rpc_inaddr_loopback
))
1413 memcpy(buf
, &rpc_inaddr_loopback
,
1414 sizeof(rpc_inaddr_loopback
));
1417 if (buflen
< sizeof(rpc_in6addr_loopback
))
1419 memcpy(buf
, &rpc_in6addr_loopback
,
1420 sizeof(rpc_in6addr_loopback
));
1423 dprintk("RPC: %s: address family not supported\n",
1425 return -EAFNOSUPPORT
;
1427 dprintk("RPC: %s: succeeded\n", __func__
);
1432 * rpc_localaddr - discover local endpoint address for an RPC client
1433 * @clnt: RPC client structure
1434 * @buf: target buffer
1435 * @buflen: size of target buffer, in bytes
1437 * Returns zero and fills in "buf" and "buflen" if successful;
1438 * otherwise, a negative errno is returned.
1440 * This works even if the underlying transport is not currently connected,
1441 * or if the upper layer never previously provided a source address.
1443 * The result of this function call is transient: multiple calls in
1444 * succession may give different results, depending on how local
1445 * networking configuration changes over time.
1447 int rpc_localaddr(struct rpc_clnt
*clnt
, struct sockaddr
*buf
, size_t buflen
)
1449 struct sockaddr_storage address
;
1450 struct sockaddr
*sap
= (struct sockaddr
*)&address
;
1451 struct rpc_xprt
*xprt
;
1457 xprt
= rcu_dereference(clnt
->cl_xprt
);
1458 salen
= xprt
->addrlen
;
1459 memcpy(sap
, &xprt
->addr
, salen
);
1460 net
= get_net(xprt
->xprt_net
);
1463 rpc_set_port(sap
, 0);
1464 err
= rpc_sockname(net
, sap
, salen
, buf
);
1467 /* Couldn't discover local address, return ANYADDR */
1468 return rpc_anyaddr(sap
->sa_family
, buf
, buflen
);
1471 EXPORT_SYMBOL_GPL(rpc_localaddr
);
1474 rpc_setbufsize(struct rpc_clnt
*clnt
, unsigned int sndsize
, unsigned int rcvsize
)
1476 struct rpc_xprt
*xprt
;
1479 xprt
= rcu_dereference(clnt
->cl_xprt
);
1480 if (xprt
->ops
->set_buffer_size
)
1481 xprt
->ops
->set_buffer_size(xprt
, sndsize
, rcvsize
);
1484 EXPORT_SYMBOL_GPL(rpc_setbufsize
);
1487 * rpc_net_ns - Get the network namespace for this RPC client
1488 * @clnt: RPC client to query
1491 struct net
*rpc_net_ns(struct rpc_clnt
*clnt
)
1496 ret
= rcu_dereference(clnt
->cl_xprt
)->xprt_net
;
1500 EXPORT_SYMBOL_GPL(rpc_net_ns
);
1503 * rpc_max_payload - Get maximum payload size for a transport, in bytes
1504 * @clnt: RPC client to query
1506 * For stream transports, this is one RPC record fragment (see RFC
1507 * 1831), as we don't support multi-record requests yet. For datagram
1508 * transports, this is the size of an IP packet minus the IP, UDP, and
1511 size_t rpc_max_payload(struct rpc_clnt
*clnt
)
1516 ret
= rcu_dereference(clnt
->cl_xprt
)->max_payload
;
1520 EXPORT_SYMBOL_GPL(rpc_max_payload
);
1523 * rpc_max_bc_payload - Get maximum backchannel payload size, in bytes
1524 * @clnt: RPC client to query
1526 size_t rpc_max_bc_payload(struct rpc_clnt
*clnt
)
1528 struct rpc_xprt
*xprt
;
1532 xprt
= rcu_dereference(clnt
->cl_xprt
);
1533 ret
= xprt
->ops
->bc_maxpayload(xprt
);
1537 EXPORT_SYMBOL_GPL(rpc_max_bc_payload
);
1539 unsigned int rpc_num_bc_slots(struct rpc_clnt
*clnt
)
1541 struct rpc_xprt
*xprt
;
1545 xprt
= rcu_dereference(clnt
->cl_xprt
);
1546 ret
= xprt
->ops
->bc_num_slots(xprt
);
1550 EXPORT_SYMBOL_GPL(rpc_num_bc_slots
);
1553 * rpc_force_rebind - force transport to check that remote port is unchanged
1554 * @clnt: client to rebind
1557 void rpc_force_rebind(struct rpc_clnt
*clnt
)
1559 if (clnt
->cl_autobind
) {
1561 xprt_clear_bound(rcu_dereference(clnt
->cl_xprt
));
1565 EXPORT_SYMBOL_GPL(rpc_force_rebind
);
1568 __rpc_restart_call(struct rpc_task
*task
, void (*action
)(struct rpc_task
*))
1570 task
->tk_status
= 0;
1571 task
->tk_rpc_status
= 0;
1572 task
->tk_action
= action
;
1577 * Restart an (async) RPC call. Usually called from within the
1581 rpc_restart_call(struct rpc_task
*task
)
1583 return __rpc_restart_call(task
, call_start
);
1585 EXPORT_SYMBOL_GPL(rpc_restart_call
);
1588 * Restart an (async) RPC call from the call_prepare state.
1589 * Usually called from within the exit handler.
1592 rpc_restart_call_prepare(struct rpc_task
*task
)
1594 if (task
->tk_ops
->rpc_call_prepare
!= NULL
)
1595 return __rpc_restart_call(task
, rpc_prepare_task
);
1596 return rpc_restart_call(task
);
1598 EXPORT_SYMBOL_GPL(rpc_restart_call_prepare
);
1601 *rpc_proc_name(const struct rpc_task
*task
)
1603 const struct rpc_procinfo
*proc
= task
->tk_msg
.rpc_proc
;
1607 return proc
->p_name
;
1615 __rpc_call_rpcerror(struct rpc_task
*task
, int tk_status
, int rpc_status
)
1617 trace_rpc_call_rpcerror(task
, tk_status
, rpc_status
);
1618 task
->tk_rpc_status
= rpc_status
;
1619 rpc_exit(task
, tk_status
);
1623 rpc_call_rpcerror(struct rpc_task
*task
, int status
)
1625 __rpc_call_rpcerror(task
, status
, status
);
1631 * Other FSM states can be visited zero or more times, but
1632 * this state is visited exactly once for each RPC.
1635 call_start(struct rpc_task
*task
)
1637 struct rpc_clnt
*clnt
= task
->tk_client
;
1638 int idx
= task
->tk_msg
.rpc_proc
->p_statidx
;
1640 trace_rpc_request(task
);
1642 /* Increment call count (version might not be valid for ping) */
1643 if (clnt
->cl_program
->version
[clnt
->cl_vers
])
1644 clnt
->cl_program
->version
[clnt
->cl_vers
]->counts
[idx
]++;
1645 clnt
->cl_stats
->rpccnt
++;
1646 task
->tk_action
= call_reserve
;
1647 rpc_task_set_transport(task
, clnt
);
1651 * 1. Reserve an RPC call slot
1654 call_reserve(struct rpc_task
*task
)
1656 task
->tk_status
= 0;
1657 task
->tk_action
= call_reserveresult
;
1661 static void call_retry_reserve(struct rpc_task
*task
);
1664 * 1b. Grok the result of xprt_reserve()
1667 call_reserveresult(struct rpc_task
*task
)
1669 int status
= task
->tk_status
;
1672 * After a call to xprt_reserve(), we must have either
1673 * a request slot or else an error status.
1675 task
->tk_status
= 0;
1677 if (task
->tk_rqstp
) {
1678 task
->tk_action
= call_refresh
;
1682 rpc_call_rpcerror(task
, -EIO
);
1688 rpc_delay(task
, HZ
>> 2);
1690 case -EAGAIN
: /* woken up; retry */
1691 task
->tk_action
= call_retry_reserve
;
1694 rpc_call_rpcerror(task
, status
);
1699 * 1c. Retry reserving an RPC call slot
1702 call_retry_reserve(struct rpc_task
*task
)
1704 task
->tk_status
= 0;
1705 task
->tk_action
= call_reserveresult
;
1706 xprt_retry_reserve(task
);
1710 * 2. Bind and/or refresh the credentials
1713 call_refresh(struct rpc_task
*task
)
1715 task
->tk_action
= call_refreshresult
;
1716 task
->tk_status
= 0;
1717 task
->tk_client
->cl_stats
->rpcauthrefresh
++;
1718 rpcauth_refreshcred(task
);
1722 * 2a. Process the results of a credential refresh
1725 call_refreshresult(struct rpc_task
*task
)
1727 int status
= task
->tk_status
;
1729 task
->tk_status
= 0;
1730 task
->tk_action
= call_refresh
;
1733 if (rpcauth_uptodatecred(task
)) {
1734 task
->tk_action
= call_allocate
;
1737 /* Use rate-limiting and a max number of retries if refresh
1738 * had status 0 but failed to update the cred.
1742 rpc_delay(task
, 3*HZ
);
1748 if (!task
->tk_cred_retry
)
1750 task
->tk_cred_retry
--;
1751 trace_rpc_retry_refresh_status(task
);
1754 trace_rpc_refresh_status(task
);
1755 rpc_call_rpcerror(task
, status
);
1759 * 2b. Allocate the buffer. For details, see sched.c:rpc_malloc.
1760 * (Note: buffer memory is freed in xprt_release).
1763 call_allocate(struct rpc_task
*task
)
1765 const struct rpc_auth
*auth
= task
->tk_rqstp
->rq_cred
->cr_auth
;
1766 struct rpc_rqst
*req
= task
->tk_rqstp
;
1767 struct rpc_xprt
*xprt
= req
->rq_xprt
;
1768 const struct rpc_procinfo
*proc
= task
->tk_msg
.rpc_proc
;
1771 task
->tk_status
= 0;
1772 task
->tk_action
= call_encode
;
1777 if (proc
->p_proc
!= 0) {
1778 BUG_ON(proc
->p_arglen
== 0);
1779 if (proc
->p_decode
!= NULL
)
1780 BUG_ON(proc
->p_replen
== 0);
1784 * Calculate the size (in quads) of the RPC call
1785 * and reply headers, and convert both values
1788 req
->rq_callsize
= RPC_CALLHDRSIZE
+ (auth
->au_cslack
<< 1) +
1790 req
->rq_callsize
<<= 2;
1792 * Note: the reply buffer must at minimum allocate enough space
1793 * for the 'struct accepted_reply' from RFC5531.
1795 req
->rq_rcvsize
= RPC_REPHDRSIZE
+ auth
->au_rslack
+ \
1796 max_t(size_t, proc
->p_replen
, 2);
1797 req
->rq_rcvsize
<<= 2;
1799 status
= xprt
->ops
->buf_alloc(task
);
1800 trace_rpc_buf_alloc(task
, status
);
1803 if (status
!= -ENOMEM
) {
1804 rpc_call_rpcerror(task
, status
);
1808 if (RPC_IS_ASYNC(task
) || !fatal_signal_pending(current
)) {
1809 task
->tk_action
= call_allocate
;
1810 rpc_delay(task
, HZ
>>4);
1814 rpc_call_rpcerror(task
, -ERESTARTSYS
);
1818 rpc_task_need_encode(struct rpc_task
*task
)
1820 return test_bit(RPC_TASK_NEED_XMIT
, &task
->tk_runstate
) == 0 &&
1821 (!(task
->tk_flags
& RPC_TASK_SENT
) ||
1822 !(task
->tk_flags
& RPC_TASK_NO_RETRANS_TIMEOUT
) ||
1823 xprt_request_need_retransmit(task
));
1827 rpc_xdr_encode(struct rpc_task
*task
)
1829 struct rpc_rqst
*req
= task
->tk_rqstp
;
1830 struct xdr_stream xdr
;
1832 xdr_buf_init(&req
->rq_snd_buf
,
1835 xdr_buf_init(&req
->rq_rcv_buf
,
1839 req
->rq_reply_bytes_recvd
= 0;
1840 req
->rq_snd_buf
.head
[0].iov_len
= 0;
1841 xdr_init_encode(&xdr
, &req
->rq_snd_buf
,
1842 req
->rq_snd_buf
.head
[0].iov_base
, req
);
1843 xdr_free_bvec(&req
->rq_snd_buf
);
1844 if (rpc_encode_header(task
, &xdr
))
1847 task
->tk_status
= rpcauth_wrap_req(task
, &xdr
);
1851 * 3. Encode arguments of an RPC call
1854 call_encode(struct rpc_task
*task
)
1856 if (!rpc_task_need_encode(task
))
1859 /* Dequeue task from the receive queue while we're encoding */
1860 xprt_request_dequeue_xprt(task
);
1861 /* Encode here so that rpcsec_gss can use correct sequence number. */
1862 rpc_xdr_encode(task
);
1863 /* Did the encode result in an error condition? */
1864 if (task
->tk_status
!= 0) {
1865 /* Was the error nonfatal? */
1866 switch (task
->tk_status
) {
1869 rpc_delay(task
, HZ
>> 4);
1872 if (!task
->tk_cred_retry
) {
1873 rpc_exit(task
, task
->tk_status
);
1875 task
->tk_action
= call_refresh
;
1876 task
->tk_cred_retry
--;
1877 trace_rpc_retry_refresh_status(task
);
1881 rpc_call_rpcerror(task
, task
->tk_status
);
1886 /* Add task to reply queue before transmission to avoid races */
1887 if (rpc_reply_expected(task
))
1888 xprt_request_enqueue_receive(task
);
1889 xprt_request_enqueue_transmit(task
);
1891 task
->tk_action
= call_transmit
;
1892 /* Check that the connection is OK */
1893 if (!xprt_bound(task
->tk_xprt
))
1894 task
->tk_action
= call_bind
;
1895 else if (!xprt_connected(task
->tk_xprt
))
1896 task
->tk_action
= call_connect
;
1900 * Helpers to check if the task was already transmitted, and
1901 * to take action when that is the case.
1904 rpc_task_transmitted(struct rpc_task
*task
)
1906 return !test_bit(RPC_TASK_NEED_XMIT
, &task
->tk_runstate
);
1910 rpc_task_handle_transmitted(struct rpc_task
*task
)
1912 xprt_end_transmit(task
);
1913 task
->tk_action
= call_transmit_status
;
1917 * 4. Get the server port number if not yet set
1920 call_bind(struct rpc_task
*task
)
1922 struct rpc_xprt
*xprt
= task
->tk_rqstp
->rq_xprt
;
1924 if (rpc_task_transmitted(task
)) {
1925 rpc_task_handle_transmitted(task
);
1929 if (xprt_bound(xprt
)) {
1930 task
->tk_action
= call_connect
;
1934 task
->tk_action
= call_bind_status
;
1935 if (!xprt_prepare_transmit(task
))
1938 xprt
->ops
->rpcbind(task
);
1942 * 4a. Sort out bind result
1945 call_bind_status(struct rpc_task
*task
)
1947 struct rpc_xprt
*xprt
= task
->tk_rqstp
->rq_xprt
;
1950 if (rpc_task_transmitted(task
)) {
1951 rpc_task_handle_transmitted(task
);
1955 if (task
->tk_status
>= 0)
1957 if (xprt_bound(xprt
)) {
1958 task
->tk_status
= 0;
1962 switch (task
->tk_status
) {
1964 rpc_delay(task
, HZ
>> 2);
1967 trace_rpcb_prog_unavail_err(task
);
1968 /* fail immediately if this is an RPC ping */
1969 if (task
->tk_msg
.rpc_proc
->p_proc
== 0) {
1970 status
= -EOPNOTSUPP
;
1973 if (task
->tk_rebind_retry
== 0)
1975 task
->tk_rebind_retry
--;
1976 rpc_delay(task
, 3*HZ
);
1979 rpc_delay(task
, HZ
>> 2);
1984 trace_rpcb_timeout_err(task
);
1987 /* server doesn't support any rpcbind version we know of */
1988 trace_rpcb_bind_version_err(task
);
1990 case -EPROTONOSUPPORT
:
1991 trace_rpcb_bind_version_err(task
);
1993 case -ECONNREFUSED
: /* connection problems */
2002 trace_rpcb_unreachable_err(task
);
2003 if (!RPC_IS_SOFTCONN(task
)) {
2004 rpc_delay(task
, 5*HZ
);
2007 status
= task
->tk_status
;
2010 trace_rpcb_unrecognized_err(task
);
2013 rpc_call_rpcerror(task
, status
);
2016 task
->tk_action
= call_connect
;
2019 task
->tk_status
= 0;
2020 task
->tk_action
= call_bind
;
2021 rpc_check_timeout(task
);
2025 * 4b. Connect to the RPC server
2028 call_connect(struct rpc_task
*task
)
2030 struct rpc_xprt
*xprt
= task
->tk_rqstp
->rq_xprt
;
2032 if (rpc_task_transmitted(task
)) {
2033 rpc_task_handle_transmitted(task
);
2037 if (xprt_connected(xprt
)) {
2038 task
->tk_action
= call_transmit
;
2042 task
->tk_action
= call_connect_status
;
2043 if (task
->tk_status
< 0)
2045 if (task
->tk_flags
& RPC_TASK_NOCONNECT
) {
2046 rpc_call_rpcerror(task
, -ENOTCONN
);
2049 if (!xprt_prepare_transmit(task
))
2055 * 4c. Sort out connect result
2058 call_connect_status(struct rpc_task
*task
)
2060 struct rpc_xprt
*xprt
= task
->tk_rqstp
->rq_xprt
;
2061 struct rpc_clnt
*clnt
= task
->tk_client
;
2062 int status
= task
->tk_status
;
2064 if (rpc_task_transmitted(task
)) {
2065 rpc_task_handle_transmitted(task
);
2069 trace_rpc_connect_status(task
);
2071 if (task
->tk_status
== 0) {
2072 clnt
->cl_stats
->netreconn
++;
2075 if (xprt_connected(xprt
)) {
2076 task
->tk_status
= 0;
2080 task
->tk_status
= 0;
2083 /* A positive refusal suggests a rebind is needed. */
2084 if (RPC_IS_SOFTCONN(task
))
2086 if (clnt
->cl_autobind
) {
2087 rpc_force_rebind(clnt
);
2098 xprt_conditional_disconnect(task
->tk_rqstp
->rq_xprt
,
2099 task
->tk_rqstp
->rq_connect_cookie
);
2100 if (RPC_IS_SOFTCONN(task
))
2102 /* retry with existing socket, after a delay */
2103 rpc_delay(task
, 3*HZ
);
2109 if (!(task
->tk_flags
& RPC_TASK_NO_ROUND_ROBIN
) &&
2110 (task
->tk_flags
& RPC_TASK_MOVEABLE
) &&
2111 test_bit(XPRT_REMOVE
, &xprt
->state
)) {
2112 struct rpc_xprt
*saved
= task
->tk_xprt
;
2113 struct rpc_xprt_switch
*xps
;
2116 xps
= xprt_switch_get(rcu_dereference(clnt
->cl_xpi
.xpi_xpswitch
));
2118 if (xps
->xps_nxprts
> 1) {
2122 value
= atomic_long_dec_return(&xprt
->queuelen
);
2124 rpc_xprt_switch_remove_xprt(xps
, saved
);
2126 task
->tk_xprt
= NULL
;
2127 task
->tk_action
= call_start
;
2129 xprt_switch_put(xps
);
2135 rpc_delay(task
, HZ
>> 2);
2138 rpc_call_rpcerror(task
, status
);
2141 task
->tk_action
= call_transmit
;
2144 /* Check for timeouts before looping back to call_bind */
2145 task
->tk_action
= call_bind
;
2146 rpc_check_timeout(task
);
2150 * 5. Transmit the RPC request, and wait for reply
2153 call_transmit(struct rpc_task
*task
)
2155 if (rpc_task_transmitted(task
)) {
2156 rpc_task_handle_transmitted(task
);
2160 task
->tk_action
= call_transmit_status
;
2161 if (!xprt_prepare_transmit(task
))
2163 task
->tk_status
= 0;
2164 if (test_bit(RPC_TASK_NEED_XMIT
, &task
->tk_runstate
)) {
2165 if (!xprt_connected(task
->tk_xprt
)) {
2166 task
->tk_status
= -ENOTCONN
;
2169 xprt_transmit(task
);
2171 xprt_end_transmit(task
);
2175 * 5a. Handle cleanup after a transmission
2178 call_transmit_status(struct rpc_task
*task
)
2180 task
->tk_action
= call_status
;
2183 * Common case: success. Force the compiler to put this
2186 if (rpc_task_transmitted(task
)) {
2187 task
->tk_status
= 0;
2188 xprt_request_wait_receive(task
);
2192 switch (task
->tk_status
) {
2196 task
->tk_status
= 0;
2197 task
->tk_action
= call_encode
;
2200 * Special cases: if we've been waiting on the
2201 * socket's write_space() callback, or if the
2202 * socket just returned a connection error,
2203 * then hold onto the transport lock.
2206 rpc_delay(task
, HZ
>>2);
2210 task
->tk_action
= call_transmit
;
2211 task
->tk_status
= 0;
2219 if (RPC_IS_SOFTCONN(task
)) {
2220 if (!task
->tk_msg
.rpc_proc
->p_proc
)
2221 trace_xprt_ping(task
->tk_xprt
,
2223 rpc_call_rpcerror(task
, task
->tk_status
);
2232 task
->tk_action
= call_bind
;
2233 task
->tk_status
= 0;
2236 rpc_check_timeout(task
);
2239 #if defined(CONFIG_SUNRPC_BACKCHANNEL)
2240 static void call_bc_transmit(struct rpc_task
*task
);
2241 static void call_bc_transmit_status(struct rpc_task
*task
);
2244 call_bc_encode(struct rpc_task
*task
)
2246 xprt_request_enqueue_transmit(task
);
2247 task
->tk_action
= call_bc_transmit
;
2251 * 5b. Send the backchannel RPC reply. On error, drop the reply. In
2252 * addition, disconnect on connectivity errors.
2255 call_bc_transmit(struct rpc_task
*task
)
2257 task
->tk_action
= call_bc_transmit_status
;
2258 if (test_bit(RPC_TASK_NEED_XMIT
, &task
->tk_runstate
)) {
2259 if (!xprt_prepare_transmit(task
))
2261 task
->tk_status
= 0;
2262 xprt_transmit(task
);
2264 xprt_end_transmit(task
);
2268 call_bc_transmit_status(struct rpc_task
*task
)
2270 struct rpc_rqst
*req
= task
->tk_rqstp
;
2272 if (rpc_task_transmitted(task
))
2273 task
->tk_status
= 0;
2275 switch (task
->tk_status
) {
2289 rpc_delay(task
, HZ
>>2);
2293 task
->tk_status
= 0;
2294 task
->tk_action
= call_bc_transmit
;
2298 * Problem reaching the server. Disconnect and let the
2299 * forechannel reestablish the connection. The server will
2300 * have to retransmit the backchannel request and we'll
2301 * reprocess it. Since these ops are idempotent, there's no
2302 * need to cache our reply at this time.
2304 printk(KERN_NOTICE
"RPC: Could not send backchannel reply "
2305 "error: %d\n", task
->tk_status
);
2306 xprt_conditional_disconnect(req
->rq_xprt
,
2307 req
->rq_connect_cookie
);
2311 * We were unable to reply and will have to drop the
2312 * request. The server should reconnect and retransmit.
2314 printk(KERN_NOTICE
"RPC: Could not send backchannel reply "
2315 "error: %d\n", task
->tk_status
);
2318 task
->tk_action
= rpc_exit_task
;
2320 #endif /* CONFIG_SUNRPC_BACKCHANNEL */
2323 * 6. Sort out the RPC call status
2326 call_status(struct rpc_task
*task
)
2328 struct rpc_clnt
*clnt
= task
->tk_client
;
2331 if (!task
->tk_msg
.rpc_proc
->p_proc
)
2332 trace_xprt_ping(task
->tk_xprt
, task
->tk_status
);
2334 status
= task
->tk_status
;
2336 task
->tk_action
= call_decode
;
2340 trace_rpc_call_status(task
);
2341 task
->tk_status
= 0;
2348 if (RPC_IS_SOFTCONN(task
))
2351 * Delay any retries for 3 seconds, then handle as if it
2354 rpc_delay(task
, 3*HZ
);
2362 rpc_force_rebind(clnt
);
2365 rpc_delay(task
, 3*HZ
);
2371 /* shutdown or soft timeout */
2374 if (clnt
->cl_chatty
)
2375 printk("%s: RPC call returned error %d\n",
2376 clnt
->cl_program
->name
, -status
);
2379 task
->tk_action
= call_encode
;
2380 if (status
!= -ECONNRESET
&& status
!= -ECONNABORTED
)
2381 rpc_check_timeout(task
);
2384 rpc_call_rpcerror(task
, status
);
2388 rpc_check_connected(const struct rpc_rqst
*req
)
2390 /* No allocated request or transport? return true */
2391 if (!req
|| !req
->rq_xprt
)
2393 return xprt_connected(req
->rq_xprt
);
2397 rpc_check_timeout(struct rpc_task
*task
)
2399 struct rpc_clnt
*clnt
= task
->tk_client
;
2401 if (RPC_SIGNALLED(task
)) {
2402 rpc_call_rpcerror(task
, -ERESTARTSYS
);
2406 if (xprt_adjust_timeout(task
->tk_rqstp
) == 0)
2409 trace_rpc_timeout_status(task
);
2410 task
->tk_timeouts
++;
2412 if (RPC_IS_SOFTCONN(task
) && !rpc_check_connected(task
->tk_rqstp
)) {
2413 rpc_call_rpcerror(task
, -ETIMEDOUT
);
2417 if (RPC_IS_SOFT(task
)) {
2419 * Once a "no retrans timeout" soft tasks (a.k.a NFSv4) has
2420 * been sent, it should time out only if the transport
2421 * connection gets terminally broken.
2423 if ((task
->tk_flags
& RPC_TASK_NO_RETRANS_TIMEOUT
) &&
2424 rpc_check_connected(task
->tk_rqstp
))
2427 if (clnt
->cl_chatty
) {
2428 pr_notice_ratelimited(
2429 "%s: server %s not responding, timed out\n",
2430 clnt
->cl_program
->name
,
2431 task
->tk_xprt
->servername
);
2433 if (task
->tk_flags
& RPC_TASK_TIMEOUT
)
2434 rpc_call_rpcerror(task
, -ETIMEDOUT
);
2436 __rpc_call_rpcerror(task
, -EIO
, -ETIMEDOUT
);
2440 if (!(task
->tk_flags
& RPC_CALL_MAJORSEEN
)) {
2441 task
->tk_flags
|= RPC_CALL_MAJORSEEN
;
2442 if (clnt
->cl_chatty
) {
2443 pr_notice_ratelimited(
2444 "%s: server %s not responding, still trying\n",
2445 clnt
->cl_program
->name
,
2446 task
->tk_xprt
->servername
);
2449 rpc_force_rebind(clnt
);
2451 * Did our request time out due to an RPCSEC_GSS out-of-sequence
2452 * event? RFC2203 requires the server to drop all such requests.
2454 rpcauth_invalcred(task
);
2458 * 7. Decode the RPC reply
2461 call_decode(struct rpc_task
*task
)
2463 struct rpc_clnt
*clnt
= task
->tk_client
;
2464 struct rpc_rqst
*req
= task
->tk_rqstp
;
2465 struct xdr_stream xdr
;
2468 if (!task
->tk_msg
.rpc_proc
->p_decode
) {
2469 task
->tk_action
= rpc_exit_task
;
2473 if (task
->tk_flags
& RPC_CALL_MAJORSEEN
) {
2474 if (clnt
->cl_chatty
) {
2475 pr_notice_ratelimited("%s: server %s OK\n",
2476 clnt
->cl_program
->name
,
2477 task
->tk_xprt
->servername
);
2479 task
->tk_flags
&= ~RPC_CALL_MAJORSEEN
;
2483 * Did we ever call xprt_complete_rqst()? If not, we should assume
2484 * the message is incomplete.
2487 if (!req
->rq_reply_bytes_recvd
)
2490 /* Ensure that we see all writes made by xprt_complete_rqst()
2491 * before it changed req->rq_reply_bytes_recvd.
2495 req
->rq_rcv_buf
.len
= req
->rq_private_buf
.len
;
2496 trace_rpc_xdr_recvfrom(task
, &req
->rq_rcv_buf
);
2498 /* Check that the softirq receive buffer is valid */
2499 WARN_ON(memcmp(&req
->rq_rcv_buf
, &req
->rq_private_buf
,
2500 sizeof(req
->rq_rcv_buf
)) != 0);
2502 xdr_init_decode(&xdr
, &req
->rq_rcv_buf
,
2503 req
->rq_rcv_buf
.head
[0].iov_base
, req
);
2504 err
= rpc_decode_header(task
, &xdr
);
2508 task
->tk_action
= rpc_exit_task
;
2509 task
->tk_status
= rpcauth_unwrap_resp(task
, &xdr
);
2512 task
->tk_status
= 0;
2513 if (task
->tk_client
->cl_discrtry
)
2514 xprt_conditional_disconnect(req
->rq_xprt
,
2515 req
->rq_connect_cookie
);
2516 task
->tk_action
= call_encode
;
2517 rpc_check_timeout(task
);
2520 task
->tk_action
= call_reserve
;
2521 rpc_check_timeout(task
);
2522 rpcauth_invalcred(task
);
2523 /* Ensure we obtain a new XID if we retry! */
2529 rpc_encode_header(struct rpc_task
*task
, struct xdr_stream
*xdr
)
2531 struct rpc_clnt
*clnt
= task
->tk_client
;
2532 struct rpc_rqst
*req
= task
->tk_rqstp
;
2537 p
= xdr_reserve_space(xdr
, RPC_CALLHDRSIZE
<< 2);
2542 *p
++ = cpu_to_be32(RPC_VERSION
);
2543 *p
++ = cpu_to_be32(clnt
->cl_prog
);
2544 *p
++ = cpu_to_be32(clnt
->cl_vers
);
2545 *p
= cpu_to_be32(task
->tk_msg
.rpc_proc
->p_proc
);
2547 error
= rpcauth_marshcred(task
, xdr
);
2552 trace_rpc_bad_callhdr(task
);
2553 rpc_call_rpcerror(task
, error
);
2558 rpc_decode_header(struct rpc_task
*task
, struct xdr_stream
*xdr
)
2560 struct rpc_clnt
*clnt
= task
->tk_client
;
2564 /* RFC-1014 says that the representation of XDR data must be a
2565 * multiple of four bytes
2566 * - if it isn't pointer subtraction in the NFS client may give
2569 if (task
->tk_rqstp
->rq_rcv_buf
.len
& 3)
2570 goto out_unparsable
;
2572 p
= xdr_inline_decode(xdr
, 3 * sizeof(*p
));
2574 goto out_unparsable
;
2576 if (*p
++ != rpc_reply
)
2577 goto out_unparsable
;
2578 if (*p
++ != rpc_msg_accepted
)
2579 goto out_msg_denied
;
2581 error
= rpcauth_checkverf(task
, xdr
);
2585 p
= xdr_inline_decode(xdr
, sizeof(*p
));
2587 goto out_unparsable
;
2591 case rpc_prog_unavail
:
2592 trace_rpc__prog_unavail(task
);
2593 error
= -EPFNOSUPPORT
;
2595 case rpc_prog_mismatch
:
2596 trace_rpc__prog_mismatch(task
);
2597 error
= -EPROTONOSUPPORT
;
2599 case rpc_proc_unavail
:
2600 trace_rpc__proc_unavail(task
);
2601 error
= -EOPNOTSUPP
;
2603 case rpc_garbage_args
:
2604 case rpc_system_err
:
2605 trace_rpc__garbage_args(task
);
2609 goto out_unparsable
;
2613 clnt
->cl_stats
->rpcgarbage
++;
2614 if (task
->tk_garb_retry
) {
2615 task
->tk_garb_retry
--;
2616 task
->tk_action
= call_encode
;
2620 rpc_call_rpcerror(task
, error
);
2624 trace_rpc__unparsable(task
);
2629 trace_rpc_bad_verifier(task
);
2634 p
= xdr_inline_decode(xdr
, sizeof(*p
));
2636 goto out_unparsable
;
2638 case rpc_auth_error
:
2641 trace_rpc__mismatch(task
);
2642 error
= -EPROTONOSUPPORT
;
2645 goto out_unparsable
;
2648 p
= xdr_inline_decode(xdr
, sizeof(*p
));
2650 goto out_unparsable
;
2652 case rpc_autherr_rejectedcred
:
2653 case rpc_autherr_rejectedverf
:
2654 case rpcsec_gsserr_credproblem
:
2655 case rpcsec_gsserr_ctxproblem
:
2656 if (!task
->tk_cred_retry
)
2658 task
->tk_cred_retry
--;
2659 trace_rpc__stale_creds(task
);
2660 return -EKEYREJECTED
;
2661 case rpc_autherr_badcred
:
2662 case rpc_autherr_badverf
:
2663 /* possibly garbled cred/verf? */
2664 if (!task
->tk_garb_retry
)
2666 task
->tk_garb_retry
--;
2667 trace_rpc__bad_creds(task
);
2668 task
->tk_action
= call_encode
;
2670 case rpc_autherr_tooweak
:
2671 trace_rpc__auth_tooweak(task
);
2672 pr_warn("RPC: server %s requires stronger authentication.\n",
2673 task
->tk_xprt
->servername
);
2676 goto out_unparsable
;
2681 static void rpcproc_encode_null(struct rpc_rqst
*rqstp
, struct xdr_stream
*xdr
,
2686 static int rpcproc_decode_null(struct rpc_rqst
*rqstp
, struct xdr_stream
*xdr
,
2692 static const struct rpc_procinfo rpcproc_null
= {
2693 .p_encode
= rpcproc_encode_null
,
2694 .p_decode
= rpcproc_decode_null
,
2698 rpc_null_call_prepare(struct rpc_task
*task
, void *data
)
2700 task
->tk_flags
&= ~RPC_TASK_NO_RETRANS_TIMEOUT
;
2701 rpc_call_start(task
);
2704 static const struct rpc_call_ops rpc_null_ops
= {
2705 .rpc_call_prepare
= rpc_null_call_prepare
,
2706 .rpc_call_done
= rpc_default_callback
,
2710 struct rpc_task
*rpc_call_null_helper(struct rpc_clnt
*clnt
,
2711 struct rpc_xprt
*xprt
, struct rpc_cred
*cred
, int flags
,
2712 const struct rpc_call_ops
*ops
, void *data
)
2714 struct rpc_message msg
= {
2715 .rpc_proc
= &rpcproc_null
,
2717 struct rpc_task_setup task_setup_data
= {
2720 .rpc_message
= &msg
,
2721 .rpc_op_cred
= cred
,
2722 .callback_ops
= ops
?: &rpc_null_ops
,
2723 .callback_data
= data
,
2724 .flags
= flags
| RPC_TASK_SOFT
| RPC_TASK_SOFTCONN
|
2728 return rpc_run_task(&task_setup_data
);
2731 struct rpc_task
*rpc_call_null(struct rpc_clnt
*clnt
, struct rpc_cred
*cred
, int flags
)
2733 return rpc_call_null_helper(clnt
, NULL
, cred
, flags
, NULL
, NULL
);
2735 EXPORT_SYMBOL_GPL(rpc_call_null
);
2737 static int rpc_ping(struct rpc_clnt
*clnt
)
2739 struct rpc_task
*task
;
2742 task
= rpc_call_null_helper(clnt
, NULL
, NULL
, 0, NULL
, NULL
);
2744 return PTR_ERR(task
);
2745 status
= task
->tk_status
;
2750 struct rpc_cb_add_xprt_calldata
{
2751 struct rpc_xprt_switch
*xps
;
2752 struct rpc_xprt
*xprt
;
2755 static void rpc_cb_add_xprt_done(struct rpc_task
*task
, void *calldata
)
2757 struct rpc_cb_add_xprt_calldata
*data
= calldata
;
2759 if (task
->tk_status
== 0)
2760 rpc_xprt_switch_add_xprt(data
->xps
, data
->xprt
);
2763 static void rpc_cb_add_xprt_release(void *calldata
)
2765 struct rpc_cb_add_xprt_calldata
*data
= calldata
;
2767 xprt_put(data
->xprt
);
2768 xprt_switch_put(data
->xps
);
2772 static const struct rpc_call_ops rpc_cb_add_xprt_call_ops
= {
2773 .rpc_call_prepare
= rpc_null_call_prepare
,
2774 .rpc_call_done
= rpc_cb_add_xprt_done
,
2775 .rpc_release
= rpc_cb_add_xprt_release
,
2779 * rpc_clnt_test_and_add_xprt - Test and add a new transport to a rpc_clnt
2780 * @clnt: pointer to struct rpc_clnt
2781 * @xps: pointer to struct rpc_xprt_switch,
2782 * @xprt: pointer struct rpc_xprt
2785 int rpc_clnt_test_and_add_xprt(struct rpc_clnt
*clnt
,
2786 struct rpc_xprt_switch
*xps
, struct rpc_xprt
*xprt
,
2789 struct rpc_cb_add_xprt_calldata
*data
;
2790 struct rpc_task
*task
;
2792 if (xps
->xps_nunique_destaddr_xprts
+ 1 > clnt
->cl_max_connect
) {
2794 pr_warn("SUNRPC: reached max allowed number (%d) did not add "
2795 "transport to server: %s\n", clnt
->cl_max_connect
,
2796 rpc_peeraddr2str(clnt
, RPC_DISPLAY_ADDR
));
2801 data
= kmalloc(sizeof(*data
), GFP_NOFS
);
2804 data
->xps
= xprt_switch_get(xps
);
2805 data
->xprt
= xprt_get(xprt
);
2806 if (rpc_xprt_switch_has_addr(data
->xps
, (struct sockaddr
*)&xprt
->addr
)) {
2807 rpc_cb_add_xprt_release(data
);
2811 task
= rpc_call_null_helper(clnt
, xprt
, NULL
, RPC_TASK_ASYNC
,
2812 &rpc_cb_add_xprt_call_ops
, data
);
2813 data
->xps
->xps_nunique_destaddr_xprts
++;
2818 EXPORT_SYMBOL_GPL(rpc_clnt_test_and_add_xprt
);
2821 * rpc_clnt_setup_test_and_add_xprt()
2823 * This is an rpc_clnt_add_xprt setup() function which returns 1 so:
2824 * 1) caller of the test function must dereference the rpc_xprt_switch
2826 * 2) test function must call rpc_xprt_switch_add_xprt, usually in
2827 * the rpc_call_done routine.
2829 * Upon success (return of 1), the test function adds the new
2830 * transport to the rpc_clnt xprt switch
2832 * @clnt: struct rpc_clnt to get the new transport
2833 * @xps: the rpc_xprt_switch to hold the new transport
2834 * @xprt: the rpc_xprt to test
2835 * @data: a struct rpc_add_xprt_test pointer that holds the test function
2836 * and test function call data
2838 int rpc_clnt_setup_test_and_add_xprt(struct rpc_clnt
*clnt
,
2839 struct rpc_xprt_switch
*xps
,
2840 struct rpc_xprt
*xprt
,
2843 struct rpc_task
*task
;
2844 struct rpc_add_xprt_test
*xtest
= (struct rpc_add_xprt_test
*)data
;
2845 int status
= -EADDRINUSE
;
2847 xprt
= xprt_get(xprt
);
2848 xprt_switch_get(xps
);
2850 if (rpc_xprt_switch_has_addr(xps
, (struct sockaddr
*)&xprt
->addr
))
2853 /* Test the connection */
2854 task
= rpc_call_null_helper(clnt
, xprt
, NULL
, 0, NULL
, NULL
);
2856 status
= PTR_ERR(task
);
2859 status
= task
->tk_status
;
2865 /* rpc_xprt_switch and rpc_xprt are deferrenced by add_xprt_test() */
2866 xtest
->add_xprt_test(clnt
, xprt
, xtest
->data
);
2869 xprt_switch_put(xps
);
2871 /* so that rpc_clnt_add_xprt does not call rpc_xprt_switch_add_xprt */
2875 xprt_switch_put(xps
);
2876 pr_info("RPC: rpc_clnt_test_xprt failed: %d addr %s not added\n",
2877 status
, xprt
->address_strings
[RPC_DISPLAY_ADDR
]);
2880 EXPORT_SYMBOL_GPL(rpc_clnt_setup_test_and_add_xprt
);
2883 * rpc_clnt_add_xprt - Add a new transport to a rpc_clnt
2884 * @clnt: pointer to struct rpc_clnt
2885 * @xprtargs: pointer to struct xprt_create
2886 * @setup: callback to test and/or set up the connection
2887 * @data: pointer to setup function data
2889 * Creates a new transport using the parameters set in args and
2891 * If ping is set, then test that connectivity succeeds before
2892 * adding the new transport.
2895 int rpc_clnt_add_xprt(struct rpc_clnt
*clnt
,
2896 struct xprt_create
*xprtargs
,
2897 int (*setup
)(struct rpc_clnt
*,
2898 struct rpc_xprt_switch
*,
2903 struct rpc_xprt_switch
*xps
;
2904 struct rpc_xprt
*xprt
;
2905 unsigned long connect_timeout
;
2906 unsigned long reconnect_timeout
;
2907 unsigned char resvport
, reuseport
;
2911 xps
= xprt_switch_get(rcu_dereference(clnt
->cl_xpi
.xpi_xpswitch
));
2912 xprt
= xprt_iter_xprt(&clnt
->cl_xpi
);
2913 if (xps
== NULL
|| xprt
== NULL
) {
2915 xprt_switch_put(xps
);
2918 resvport
= xprt
->resvport
;
2919 reuseport
= xprt
->reuseport
;
2920 connect_timeout
= xprt
->connect_timeout
;
2921 reconnect_timeout
= xprt
->max_reconnect_timeout
;
2922 ident
= xprt
->xprt_class
->ident
;
2925 if (!xprtargs
->ident
)
2926 xprtargs
->ident
= ident
;
2927 xprt
= xprt_create_transport(xprtargs
);
2929 ret
= PTR_ERR(xprt
);
2930 goto out_put_switch
;
2932 xprt
->resvport
= resvport
;
2933 xprt
->reuseport
= reuseport
;
2934 if (xprt
->ops
->set_connect_timeout
!= NULL
)
2935 xprt
->ops
->set_connect_timeout(xprt
,
2939 rpc_xprt_switch_set_roundrobin(xps
);
2941 ret
= setup(clnt
, xps
, xprt
, data
);
2945 rpc_xprt_switch_add_xprt(xps
, xprt
);
2949 xprt_switch_put(xps
);
2952 EXPORT_SYMBOL_GPL(rpc_clnt_add_xprt
);
2954 struct connect_timeout_data
{
2955 unsigned long connect_timeout
;
2956 unsigned long reconnect_timeout
;
2960 rpc_xprt_set_connect_timeout(struct rpc_clnt
*clnt
,
2961 struct rpc_xprt
*xprt
,
2964 struct connect_timeout_data
*timeo
= data
;
2966 if (xprt
->ops
->set_connect_timeout
)
2967 xprt
->ops
->set_connect_timeout(xprt
,
2968 timeo
->connect_timeout
,
2969 timeo
->reconnect_timeout
);
2974 rpc_set_connect_timeout(struct rpc_clnt
*clnt
,
2975 unsigned long connect_timeout
,
2976 unsigned long reconnect_timeout
)
2978 struct connect_timeout_data timeout
= {
2979 .connect_timeout
= connect_timeout
,
2980 .reconnect_timeout
= reconnect_timeout
,
2982 rpc_clnt_iterate_for_each_xprt(clnt
,
2983 rpc_xprt_set_connect_timeout
,
2986 EXPORT_SYMBOL_GPL(rpc_set_connect_timeout
);
2988 void rpc_clnt_xprt_switch_put(struct rpc_clnt
*clnt
)
2991 xprt_switch_put(rcu_dereference(clnt
->cl_xpi
.xpi_xpswitch
));
2994 EXPORT_SYMBOL_GPL(rpc_clnt_xprt_switch_put
);
2996 void rpc_clnt_xprt_switch_add_xprt(struct rpc_clnt
*clnt
, struct rpc_xprt
*xprt
)
2999 rpc_xprt_switch_add_xprt(rcu_dereference(clnt
->cl_xpi
.xpi_xpswitch
),
3003 EXPORT_SYMBOL_GPL(rpc_clnt_xprt_switch_add_xprt
);
3005 bool rpc_clnt_xprt_switch_has_addr(struct rpc_clnt
*clnt
,
3006 const struct sockaddr
*sap
)
3008 struct rpc_xprt_switch
*xps
;
3012 xps
= rcu_dereference(clnt
->cl_xpi
.xpi_xpswitch
);
3013 ret
= rpc_xprt_switch_has_addr(xps
, sap
);
3017 EXPORT_SYMBOL_GPL(rpc_clnt_xprt_switch_has_addr
);
3019 #if IS_ENABLED(CONFIG_SUNRPC_DEBUG)
3020 static void rpc_show_header(void)
3022 printk(KERN_INFO
"-pid- flgs status -client- --rqstp- "
3023 "-timeout ---ops--\n");
3026 static void rpc_show_task(const struct rpc_clnt
*clnt
,
3027 const struct rpc_task
*task
)
3029 const char *rpc_waitq
= "none";
3031 if (RPC_IS_QUEUED(task
))
3032 rpc_waitq
= rpc_qname(task
->tk_waitqueue
);
3034 printk(KERN_INFO
"%5u %04x %6d %8p %8p %8ld %8p %sv%u %s a:%ps q:%s\n",
3035 task
->tk_pid
, task
->tk_flags
, task
->tk_status
,
3036 clnt
, task
->tk_rqstp
, rpc_task_timeout(task
), task
->tk_ops
,
3037 clnt
->cl_program
->name
, clnt
->cl_vers
, rpc_proc_name(task
),
3038 task
->tk_action
, rpc_waitq
);
3041 void rpc_show_tasks(struct net
*net
)
3043 struct rpc_clnt
*clnt
;
3044 struct rpc_task
*task
;
3046 struct sunrpc_net
*sn
= net_generic(net
, sunrpc_net_id
);
3048 spin_lock(&sn
->rpc_client_lock
);
3049 list_for_each_entry(clnt
, &sn
->all_clients
, cl_clients
) {
3050 spin_lock(&clnt
->cl_lock
);
3051 list_for_each_entry(task
, &clnt
->cl_tasks
, tk_task
) {
3056 rpc_show_task(clnt
, task
);
3058 spin_unlock(&clnt
->cl_lock
);
3060 spin_unlock(&sn
->rpc_client_lock
);
3064 #if IS_ENABLED(CONFIG_SUNRPC_SWAP)
3066 rpc_clnt_swap_activate_callback(struct rpc_clnt
*clnt
,
3067 struct rpc_xprt
*xprt
,
3070 return xprt_enable_swap(xprt
);
3074 rpc_clnt_swap_activate(struct rpc_clnt
*clnt
)
3076 if (atomic_inc_return(&clnt
->cl_swapper
) == 1)
3077 return rpc_clnt_iterate_for_each_xprt(clnt
,
3078 rpc_clnt_swap_activate_callback
, NULL
);
3081 EXPORT_SYMBOL_GPL(rpc_clnt_swap_activate
);
3084 rpc_clnt_swap_deactivate_callback(struct rpc_clnt
*clnt
,
3085 struct rpc_xprt
*xprt
,
3088 xprt_disable_swap(xprt
);
3093 rpc_clnt_swap_deactivate(struct rpc_clnt
*clnt
)
3095 if (atomic_dec_if_positive(&clnt
->cl_swapper
) == 0)
3096 rpc_clnt_iterate_for_each_xprt(clnt
,
3097 rpc_clnt_swap_deactivate_callback
, NULL
);
3099 EXPORT_SYMBOL_GPL(rpc_clnt_swap_deactivate
);
3100 #endif /* CONFIG_SUNRPC_SWAP */