blob: 325a0858700f6c4eba5d9a0c0fe1c7800d42d541 [file] [log] [blame]
Thomas Gleixner457c8992019-05-19 13:08:55 +01001// SPDX-License-Identifier: GPL-2.0-only
Linus Torvalds1da177e2005-04-16 15:20:36 -07002/*
Chuck Lever55aa4f52005-08-11 16:25:47 -04003 * linux/net/sunrpc/clnt.c
Linus Torvalds1da177e2005-04-16 15:20:36 -07004 *
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 *
Linus Torvalds1da177e2005-04-16 15:20:36 -070017 * Copyright (C) 1992,1993 Rick Sladkey <jrs@world.std.com>
18 * Copyright (C) 1995,1996 Olaf Kirch <okir@monad.swb.de>
19 */
20
Linus Torvalds1da177e2005-04-16 15:20:36 -070021
22#include <linux/module.h>
23#include <linux/types.h>
Chuck Levercb3997b2008-05-21 17:09:41 -040024#include <linux/kallsyms.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070025#include <linux/mm.h>
Trond Myklebust23ac6582009-08-09 15:14:25 -040026#include <linux/namei.h>
27#include <linux/mount.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070028#include <linux/slab.h>
Trond Myklebust40b00b6b2013-10-17 14:12:23 -040029#include <linux/rcupdate.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070030#include <linux/utsname.h>
Chuck Lever11c556b2006-03-20 13:44:22 -050031#include <linux/workqueue.h>
Chuck Lever176e21e2011-05-09 15:22:44 -040032#include <linux/in.h>
Chuck Lever510deb02007-12-10 14:56:24 -050033#include <linux/in6.h>
Chuck Lever176e21e2011-05-09 15:22:44 -040034#include <linux/un.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070035
36#include <linux/sunrpc/clnt.h>
Jeff Layton59766872013-02-04 12:50:00 -050037#include <linux/sunrpc/addr.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070038#include <linux/sunrpc/rpc_pipe_fs.h>
Chuck Lever11c556b2006-03-20 13:44:22 -050039#include <linux/sunrpc/metrics.h>
Ricardo Labiaga55ae1aa2009-04-01 09:23:03 -040040#include <linux/sunrpc/bc_xprt.h>
Steve Dickson5753cba2012-02-06 10:08:08 -050041#include <trace/events/sunrpc.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070042
Ricardo Labiaga55ae1aa2009-04-01 09:23:03 -040043#include "sunrpc.h"
Stanislav Kinsbursky70abc492012-01-12 22:07:51 +040044#include "netns.h"
Linus Torvalds1da177e2005-04-16 15:20:36 -070045
Jeff Laytonf895b252014-11-17 16:58:04 -050046#if IS_ENABLED(CONFIG_SUNRPC_DEBUG)
Linus Torvalds1da177e2005-04-16 15:20:36 -070047# define RPCDBG_FACILITY RPCDBG_CALL
48#endif
49
Chuck Lever46121cf2007-01-31 12:14:08 -050050#define dprint_status(t) \
51 dprintk("RPC: %5u %s (status %d)\n", t->tk_pid, \
Harvey Harrison0dc47872008-03-05 20:47:47 -080052 __func__, t->tk_status)
Chuck Lever46121cf2007-01-31 12:14:08 -050053
Trond Myklebust188fef12007-06-16 14:18:40 -040054/*
55 * All RPC clients are linked into this list
56 */
Trond Myklebust188fef12007-06-16 14:18:40 -040057
Linus Torvalds1da177e2005-04-16 15:20:36 -070058static DECLARE_WAIT_QUEUE_HEAD(destroy_wait);
59
60
61static void call_start(struct rpc_task *task);
62static void call_reserve(struct rpc_task *task);
63static void call_reserveresult(struct rpc_task *task);
64static void call_allocate(struct rpc_task *task);
Trond Myklebust762e4e62018-08-24 16:28:28 -040065static void call_encode(struct rpc_task *task);
Linus Torvalds1da177e2005-04-16 15:20:36 -070066static void call_decode(struct rpc_task *task);
67static void call_bind(struct rpc_task *task);
Chuck Leverda351872005-08-11 16:25:11 -040068static void call_bind_status(struct rpc_task *task);
Linus Torvalds1da177e2005-04-16 15:20:36 -070069static void call_transmit(struct rpc_task *task);
70static void call_status(struct rpc_task *task);
Trond Myklebust940e3312005-11-09 21:45:24 -050071static void call_transmit_status(struct rpc_task *task);
Linus Torvalds1da177e2005-04-16 15:20:36 -070072static void call_refresh(struct rpc_task *task);
73static void call_refreshresult(struct rpc_task *task);
Linus Torvalds1da177e2005-04-16 15:20:36 -070074static void call_connect(struct rpc_task *task);
75static void call_connect_status(struct rpc_task *task);
Linus Torvalds1da177e2005-04-16 15:20:36 -070076
Chuck Levere8680a22019-02-11 11:24:48 -050077static int rpc_encode_header(struct rpc_task *task,
78 struct xdr_stream *xdr);
Chuck Levera0584ee2019-02-11 11:24:58 -050079static int rpc_decode_header(struct rpc_task *task,
80 struct xdr_stream *xdr);
Chuck Levercaabea82009-12-03 15:58:56 -050081static int rpc_ping(struct rpc_clnt *clnt);
Trond Myklebust7b3fef82019-03-07 14:10:32 -050082static void rpc_check_timeout(struct rpc_task *task);
Trond Myklebust64c91a12007-06-23 10:17:16 -040083
Trond Myklebust188fef12007-06-16 14:18:40 -040084static void rpc_register_client(struct rpc_clnt *clnt)
85{
Trond Myklebust2446ab62012-03-01 17:00:56 -050086 struct net *net = rpc_net_ns(clnt);
87 struct sunrpc_net *sn = net_generic(net, sunrpc_net_id);
Stanislav Kinsbursky70abc492012-01-12 22:07:51 +040088
89 spin_lock(&sn->rpc_client_lock);
90 list_add(&clnt->cl_clients, &sn->all_clients);
91 spin_unlock(&sn->rpc_client_lock);
Trond Myklebust188fef12007-06-16 14:18:40 -040092}
93
94static void rpc_unregister_client(struct rpc_clnt *clnt)
95{
Trond Myklebust2446ab62012-03-01 17:00:56 -050096 struct net *net = rpc_net_ns(clnt);
97 struct sunrpc_net *sn = net_generic(net, sunrpc_net_id);
Stanislav Kinsbursky70abc492012-01-12 22:07:51 +040098
99 spin_lock(&sn->rpc_client_lock);
Trond Myklebust188fef12007-06-16 14:18:40 -0400100 list_del(&clnt->cl_clients);
Stanislav Kinsbursky70abc492012-01-12 22:07:51 +0400101 spin_unlock(&sn->rpc_client_lock);
Trond Myklebust188fef12007-06-16 14:18:40 -0400102}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700103
Stanislav Kinsbursky0157d022012-01-11 19:18:01 +0400104static void __rpc_clnt_remove_pipedir(struct rpc_clnt *clnt)
105{
Trond Myklebustc36dcfe12013-08-26 17:44:26 -0400106 rpc_remove_client_dir(clnt);
Stanislav Kinsbursky0157d022012-01-11 19:18:01 +0400107}
108
109static void rpc_clnt_remove_pipedir(struct rpc_clnt *clnt)
110{
Trond Myklebust2446ab62012-03-01 17:00:56 -0500111 struct net *net = rpc_net_ns(clnt);
Stanislav Kinsbursky0157d022012-01-11 19:18:01 +0400112 struct super_block *pipefs_sb;
Stanislav Kinsbursky0157d022012-01-11 19:18:01 +0400113
Trond Myklebust2446ab62012-03-01 17:00:56 -0500114 pipefs_sb = rpc_get_sb_net(net);
Stanislav Kinsbursky0157d022012-01-11 19:18:01 +0400115 if (pipefs_sb) {
Stanislav Kinsbursky0157d022012-01-11 19:18:01 +0400116 __rpc_clnt_remove_pipedir(clnt);
Trond Myklebust2446ab62012-03-01 17:00:56 -0500117 rpc_put_sb_net(net);
Stanislav Kinsbursky0157d022012-01-11 19:18:01 +0400118 }
Stanislav Kinsbursky0157d022012-01-11 19:18:01 +0400119}
120
121static struct dentry *rpc_setup_pipedir_sb(struct super_block *sb,
Trond Myklebust41b6b4d2013-08-23 13:03:50 -0400122 struct rpc_clnt *clnt)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700123{
Trond Myklebustf1345852005-09-23 11:08:25 -0400124 static uint32_t clntid;
Trond Myklebust41b6b4d2013-08-23 13:03:50 -0400125 const char *dir_name = clnt->cl_program->pipe_dir_name;
Trond Myklebust23ac6582009-08-09 15:14:25 -0400126 char name[15];
Stanislav Kinsbursky0157d022012-01-11 19:18:01 +0400127 struct dentry *dir, *dentry;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700128
Stanislav Kinsbursky0157d022012-01-11 19:18:01 +0400129 dir = rpc_d_lookup_sb(sb, dir_name);
Weston Andros Adamson922eeac2012-10-23 10:43:25 -0400130 if (dir == NULL) {
131 pr_info("RPC: pipefs directory doesn't exist: %s\n", dir_name);
Stanislav Kinsbursky0157d022012-01-11 19:18:01 +0400132 return dir;
Weston Andros Adamson922eeac2012-10-23 10:43:25 -0400133 }
Stanislav Kinsbursky0157d022012-01-11 19:18:01 +0400134 for (;;) {
Al Viroa95e6912013-07-14 16:43:54 +0400135 snprintf(name, sizeof(name), "clnt%x", (unsigned int)clntid++);
Stanislav Kinsbursky0157d022012-01-11 19:18:01 +0400136 name[sizeof(name) - 1] = '\0';
Al Viroa95e6912013-07-14 16:43:54 +0400137 dentry = rpc_create_client_dir(dir, name, clnt);
Stanislav Kinsbursky0157d022012-01-11 19:18:01 +0400138 if (!IS_ERR(dentry))
139 break;
Al Viroa95e6912013-07-14 16:43:54 +0400140 if (dentry == ERR_PTR(-EEXIST))
141 continue;
142 printk(KERN_INFO "RPC: Couldn't create pipefs entry"
143 " %s/%s, error %ld\n",
144 dir_name, name, PTR_ERR(dentry));
145 break;
Stanislav Kinsbursky0157d022012-01-11 19:18:01 +0400146 }
147 dput(dir);
148 return dentry;
149}
150
151static int
Trond Myklebust41b6b4d2013-08-23 13:03:50 -0400152rpc_setup_pipedir(struct super_block *pipefs_sb, struct rpc_clnt *clnt)
Stanislav Kinsbursky0157d022012-01-11 19:18:01 +0400153{
Stanislav Kinsbursky30507f52012-01-11 19:18:42 +0400154 struct dentry *dentry;
Stanislav Kinsbursky0157d022012-01-11 19:18:01 +0400155
Trond Myklebustc36dcfe12013-08-26 17:44:26 -0400156 if (clnt->cl_program->pipe_dir_name != NULL) {
157 dentry = rpc_setup_pipedir_sb(pipefs_sb, clnt);
158 if (IS_ERR(dentry))
159 return PTR_ERR(dentry);
160 }
Trond Myklebust23ac6582009-08-09 15:14:25 -0400161 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700162}
163
Trond Myklebust41b6b4d2013-08-23 13:03:50 -0400164static int rpc_clnt_skip_event(struct rpc_clnt *clnt, unsigned long event)
Stanislav Kinsburskyea8cfa02012-04-27 13:00:17 +0400165{
Trond Myklebust41b6b4d2013-08-23 13:03:50 -0400166 if (clnt->cl_program->pipe_dir_name == NULL)
Stanislav Kinsburskyea8cfa02012-04-27 13:00:17 +0400167 return 1;
Trond Myklebust41b6b4d2013-08-23 13:03:50 -0400168
Trond Myklebustc36dcfe12013-08-26 17:44:26 -0400169 switch (event) {
170 case RPC_PIPEFS_MOUNT:
171 if (clnt->cl_pipedir_objects.pdh_dentry != NULL)
172 return 1;
173 if (atomic_read(&clnt->cl_count) == 0)
174 return 1;
175 break;
176 case RPC_PIPEFS_UMOUNT:
177 if (clnt->cl_pipedir_objects.pdh_dentry == NULL)
178 return 1;
179 break;
180 }
Stanislav Kinsburskyea8cfa02012-04-27 13:00:17 +0400181 return 0;
182}
183
184static int __rpc_clnt_handle_event(struct rpc_clnt *clnt, unsigned long event,
185 struct super_block *sb)
Stanislav Kinsbursky80df9d22012-01-11 19:18:17 +0400186{
187 struct dentry *dentry;
Stanislav Kinsbursky80df9d22012-01-11 19:18:17 +0400188
189 switch (event) {
190 case RPC_PIPEFS_MOUNT:
Trond Myklebust41b6b4d2013-08-23 13:03:50 -0400191 dentry = rpc_setup_pipedir_sb(sb, clnt);
Weston Andros Adamson922eeac2012-10-23 10:43:25 -0400192 if (!dentry)
193 return -ENOENT;
Stanislav Kinsbursky80df9d22012-01-11 19:18:17 +0400194 if (IS_ERR(dentry))
195 return PTR_ERR(dentry);
Stanislav Kinsbursky80df9d22012-01-11 19:18:17 +0400196 break;
197 case RPC_PIPEFS_UMOUNT:
198 __rpc_clnt_remove_pipedir(clnt);
199 break;
200 default:
201 printk(KERN_ERR "%s: unknown event: %ld\n", __func__, event);
202 return -ENOTSUPP;
203 }
Amitoj Kaur Chawla2813b622016-08-08 14:43:49 +0530204 return 0;
Stanislav Kinsbursky80df9d22012-01-11 19:18:17 +0400205}
206
Stanislav Kinsburskyea8cfa02012-04-27 13:00:17 +0400207static int __rpc_pipefs_event(struct rpc_clnt *clnt, unsigned long event,
208 struct super_block *sb)
209{
210 int error = 0;
211
212 for (;; clnt = clnt->cl_parent) {
213 if (!rpc_clnt_skip_event(clnt, event))
214 error = __rpc_clnt_handle_event(clnt, event, sb);
215 if (error || clnt == clnt->cl_parent)
216 break;
217 }
218 return error;
219}
220
Stanislav Kinsburskyda3b4622012-02-27 22:05:29 +0400221static struct rpc_clnt *rpc_get_client_for_event(struct net *net, int event)
222{
223 struct sunrpc_net *sn = net_generic(net, sunrpc_net_id);
224 struct rpc_clnt *clnt;
225
226 spin_lock(&sn->rpc_client_lock);
227 list_for_each_entry(clnt, &sn->all_clients, cl_clients) {
Stanislav Kinsburskyea8cfa02012-04-27 13:00:17 +0400228 if (rpc_clnt_skip_event(clnt, event))
Stanislav Kinsburskyda3b4622012-02-27 22:05:29 +0400229 continue;
Stanislav Kinsburskyda3b4622012-02-27 22:05:29 +0400230 spin_unlock(&sn->rpc_client_lock);
231 return clnt;
232 }
233 spin_unlock(&sn->rpc_client_lock);
234 return NULL;
235}
236
Stanislav Kinsbursky80df9d22012-01-11 19:18:17 +0400237static int rpc_pipefs_event(struct notifier_block *nb, unsigned long event,
238 void *ptr)
239{
240 struct super_block *sb = ptr;
241 struct rpc_clnt *clnt;
242 int error = 0;
Stanislav Kinsbursky80df9d22012-01-11 19:18:17 +0400243
Stanislav Kinsburskyda3b4622012-02-27 22:05:29 +0400244 while ((clnt = rpc_get_client_for_event(sb->s_fs_info, event))) {
Stanislav Kinsbursky80df9d22012-01-11 19:18:17 +0400245 error = __rpc_pipefs_event(clnt, event, sb);
246 if (error)
247 break;
248 }
Stanislav Kinsbursky80df9d22012-01-11 19:18:17 +0400249 return error;
250}
251
252static struct notifier_block rpc_clients_block = {
253 .notifier_call = rpc_pipefs_event,
Stanislav Kinsburskyeee173252012-01-10 16:13:19 +0400254 .priority = SUNRPC_PIPEFS_RPC_PRIO,
Stanislav Kinsbursky80df9d22012-01-11 19:18:17 +0400255};
256
257int rpc_clients_notifier_register(void)
258{
259 return rpc_pipefs_notifier_register(&rpc_clients_block);
260}
261
262void rpc_clients_notifier_unregister(void)
263{
264 return rpc_pipefs_notifier_unregister(&rpc_clients_block);
265}
266
Trond Myklebust40b00b6b2013-10-17 14:12:23 -0400267static struct rpc_xprt *rpc_clnt_set_transport(struct rpc_clnt *clnt,
268 struct rpc_xprt *xprt,
269 const struct rpc_timeout *timeout)
270{
271 struct rpc_xprt *old;
272
273 spin_lock(&clnt->cl_lock);
Trond Myklebust34751b92013-10-28 16:42:44 -0400274 old = rcu_dereference_protected(clnt->cl_xprt,
275 lockdep_is_held(&clnt->cl_lock));
Trond Myklebust40b00b6b2013-10-17 14:12:23 -0400276
277 if (!xprt_bound(xprt))
278 clnt->cl_autobind = 1;
279
280 clnt->cl_timeout = timeout;
281 rcu_assign_pointer(clnt->cl_xprt, xprt);
282 spin_unlock(&clnt->cl_lock);
283
284 return old;
285}
286
Trond Myklebustcbbb3442012-04-30 11:52:40 -0400287static void rpc_clnt_set_nodename(struct rpc_clnt *clnt, const char *nodename)
288{
Trond Myklebust03a9a422015-01-30 18:12:28 -0500289 clnt->cl_nodelen = strlcpy(clnt->cl_nodename,
290 nodename, sizeof(clnt->cl_nodename));
Trond Myklebustcbbb3442012-04-30 11:52:40 -0400291}
292
Chuck Leverd746e542013-10-17 14:12:17 -0400293static int rpc_client_register(struct rpc_clnt *clnt,
294 rpc_authflavor_t pseudoflavor,
295 const char *client_name)
Stanislav Kinsburskye73f4cc2013-06-24 11:52:52 +0400296{
Trond Myklebustc2190662013-08-26 19:23:04 -0400297 struct rpc_auth_create_args auth_args = {
Chuck Leverd746e542013-10-17 14:12:17 -0400298 .pseudoflavor = pseudoflavor,
299 .target_name = client_name,
Trond Myklebustc2190662013-08-26 19:23:04 -0400300 };
Stanislav Kinsburskye73f4cc2013-06-24 11:52:52 +0400301 struct rpc_auth *auth;
302 struct net *net = rpc_net_ns(clnt);
303 struct super_block *pipefs_sb;
Trond Myklebusteeee2452013-07-10 15:33:01 -0400304 int err;
Stanislav Kinsburskye73f4cc2013-06-24 11:52:52 +0400305
Jeff Laytonf9c72d12015-03-31 12:03:28 -0400306 rpc_clnt_debugfs_register(clnt);
Jeff Laytonb4b9d2c2014-11-26 14:44:43 -0500307
Stanislav Kinsburskye73f4cc2013-06-24 11:52:52 +0400308 pipefs_sb = rpc_get_sb_net(net);
309 if (pipefs_sb) {
Trond Myklebust41b6b4d2013-08-23 13:03:50 -0400310 err = rpc_setup_pipedir(pipefs_sb, clnt);
Stanislav Kinsburskye73f4cc2013-06-24 11:52:52 +0400311 if (err)
312 goto out;
313 }
314
Trond Myklebusteeee2452013-07-10 15:33:01 -0400315 rpc_register_client(clnt);
316 if (pipefs_sb)
317 rpc_put_sb_net(net);
318
Trond Myklebustc2190662013-08-26 19:23:04 -0400319 auth = rpcauth_create(&auth_args, clnt);
Stanislav Kinsburskye73f4cc2013-06-24 11:52:52 +0400320 if (IS_ERR(auth)) {
321 dprintk("RPC: Couldn't create auth handle (flavor %u)\n",
Chuck Leverd746e542013-10-17 14:12:17 -0400322 pseudoflavor);
Stanislav Kinsburskye73f4cc2013-06-24 11:52:52 +0400323 err = PTR_ERR(auth);
324 goto err_auth;
325 }
Trond Myklebusteeee2452013-07-10 15:33:01 -0400326 return 0;
327err_auth:
328 pipefs_sb = rpc_get_sb_net(net);
Trond Myklebust1540c5d2013-07-14 22:57:50 -0400329 rpc_unregister_client(clnt);
Trond Myklebusteeee2452013-07-10 15:33:01 -0400330 __rpc_clnt_remove_pipedir(clnt);
Stanislav Kinsburskye73f4cc2013-06-24 11:52:52 +0400331out:
332 if (pipefs_sb)
333 rpc_put_sb_net(net);
Jeff Laytonb4b9d2c2014-11-26 14:44:43 -0500334 rpc_clnt_debugfs_unregister(clnt);
Stanislav Kinsburskye73f4cc2013-06-24 11:52:52 +0400335 return err;
Stanislav Kinsburskye73f4cc2013-06-24 11:52:52 +0400336}
337
Trond Myklebust2f048db2013-09-04 21:51:44 -0400338static DEFINE_IDA(rpc_clids);
339
Kinglong Meec929ea02017-01-20 16:48:39 +0800340void rpc_cleanup_clids(void)
341{
342 ida_destroy(&rpc_clids);
343}
344
Trond Myklebust2f048db2013-09-04 21:51:44 -0400345static int rpc_alloc_clid(struct rpc_clnt *clnt)
346{
347 int clid;
348
349 clid = ida_simple_get(&rpc_clids, 0, 0, GFP_KERNEL);
350 if (clid < 0)
351 return clid;
352 clnt->cl_clid = clid;
353 return 0;
354}
355
356static void rpc_free_clid(struct rpc_clnt *clnt)
357{
358 ida_simple_remove(&rpc_clids, clnt->cl_clid);
359}
360
Trond Myklebust280ebcf2013-09-02 13:28:04 -0400361static struct rpc_clnt * rpc_new_client(const struct rpc_create_args *args,
Trond Myklebustad01b2c2016-01-30 14:17:26 -0500362 struct rpc_xprt_switch *xps,
Trond Myklebust280ebcf2013-09-02 13:28:04 -0400363 struct rpc_xprt *xprt,
364 struct rpc_clnt *parent)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700365{
Trond Myklebusta613fa12012-01-20 13:53:56 -0500366 const struct rpc_program *program = args->program;
367 const struct rpc_version *version;
Trond Myklebust40b00b6b2013-10-17 14:12:23 -0400368 struct rpc_clnt *clnt = NULL;
369 const struct rpc_timeout *timeout;
Trond Myklebust03a9a422015-01-30 18:12:28 -0500370 const char *nodename = args->nodename;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700371 int err;
Chuck Lever06b8d252007-09-11 18:00:20 -0400372
373 /* sanity check the name before trying to print it */
Chuck Lever46121cf2007-01-31 12:14:08 -0500374 dprintk("RPC: creating %s client for %s (xprt %p)\n",
Trond Myklebust698b6d02007-12-20 16:03:53 -0500375 program->name, args->servername, xprt);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700376
Trond Myklebust4ada5392007-06-14 17:26:17 -0400377 err = rpciod_up();
378 if (err)
379 goto out_no_rpciod;
Trond Myklebust698b6d02007-12-20 16:03:53 -0500380
Trond Myklebustf05c1242013-04-05 14:13:21 -0400381 err = -EINVAL;
Trond Myklebust698b6d02007-12-20 16:03:53 -0500382 if (args->version >= program->nrvers)
383 goto out_err;
384 version = program->version[args->version];
385 if (version == NULL)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700386 goto out_err;
387
388 err = -ENOMEM;
Panagiotis Issaris0da974f2006-07-21 14:51:30 -0700389 clnt = kzalloc(sizeof(*clnt), GFP_KERNEL);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700390 if (!clnt)
391 goto out_err;
Trond Myklebust280ebcf2013-09-02 13:28:04 -0400392 clnt->cl_parent = parent ? : clnt;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700393
Trond Myklebust2f048db2013-09-04 21:51:44 -0400394 err = rpc_alloc_clid(clnt);
395 if (err)
396 goto out_no_clid;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700397
Trond Myklebust79caa5f2019-04-24 17:46:42 -0400398 clnt->cl_cred = get_cred(args->cred);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700399 clnt->cl_procinfo = version->procs;
400 clnt->cl_maxproc = version->nrprocs;
Benny Halevyd5b337b2008-09-28 09:21:26 +0300401 clnt->cl_prog = args->prognumber ? : program->number;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700402 clnt->cl_vers = version->number;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700403 clnt->cl_stats = program->stats;
Chuck Lever11c556b2006-03-20 13:44:22 -0500404 clnt->cl_metrics = rpc_alloc_iostats(clnt);
Trond Myklebust6739ffb2013-08-26 15:38:11 -0400405 rpc_init_pipe_dir_head(&clnt->cl_pipedir_objects);
Trond Myklebust23bf85b2006-11-21 10:40:23 -0500406 err = -ENOMEM;
407 if (clnt->cl_metrics == NULL)
408 goto out_no_stats;
Trond Myklebust3e32a5d2006-11-16 11:37:27 -0500409 clnt->cl_program = program;
Trond Myklebust6529eba2007-06-14 16:40:14 -0400410 INIT_LIST_HEAD(&clnt->cl_tasks);
Trond Myklebust4bef61f2007-06-16 14:17:01 -0400411 spin_lock_init(&clnt->cl_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700412
Trond Myklebust40b00b6b2013-10-17 14:12:23 -0400413 timeout = xprt->timeout;
Trond Myklebustba7392b2007-12-20 16:03:55 -0500414 if (args->timeout != NULL) {
415 memcpy(&clnt->cl_timeout_default, args->timeout,
416 sizeof(clnt->cl_timeout_default));
Trond Myklebust40b00b6b2013-10-17 14:12:23 -0400417 timeout = &clnt->cl_timeout_default;
Trond Myklebustba7392b2007-12-20 16:03:55 -0500418 }
419
Trond Myklebust40b00b6b2013-10-17 14:12:23 -0400420 rpc_clnt_set_transport(clnt, xprt, timeout);
Trond Myklebustad01b2c2016-01-30 14:17:26 -0500421 xprt_iter_init(&clnt->cl_xpi, xps);
422 xprt_switch_put(xps);
Trond Myklebust40b00b6b2013-10-17 14:12:23 -0400423
Linus Torvalds1da177e2005-04-16 15:20:36 -0700424 clnt->cl_rtt = &clnt->cl_rtt_default;
Trond Myklebustba7392b2007-12-20 16:03:55 -0500425 rpc_init_rtt(&clnt->cl_rtt_default, clnt->cl_timeout->to_initval);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700426
Trond Myklebust006abe82010-09-12 19:55:25 -0400427 atomic_set(&clnt->cl_count, 1);
Trond Myklebust34f52e32007-06-14 16:40:31 -0400428
Trond Myklebust03a9a422015-01-30 18:12:28 -0500429 if (nodename == NULL)
430 nodename = utsname()->nodename;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700431 /* save the nodename */
Trond Myklebust03a9a422015-01-30 18:12:28 -0500432 rpc_clnt_set_nodename(clnt, nodename);
Stanislav Kinsburskye73f4cc2013-06-24 11:52:52 +0400433
Chuck Leverd746e542013-10-17 14:12:17 -0400434 err = rpc_client_register(clnt, args->authflavor, args->client_name);
Stanislav Kinsburskye73f4cc2013-06-24 11:52:52 +0400435 if (err)
436 goto out_no_path;
Trond Myklebust280ebcf2013-09-02 13:28:04 -0400437 if (parent)
438 atomic_inc(&parent->cl_count);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700439 return clnt;
440
Linus Torvalds1da177e2005-04-16 15:20:36 -0700441out_no_path:
Trond Myklebust23bf85b2006-11-21 10:40:23 -0500442 rpc_free_iostats(clnt->cl_metrics);
443out_no_stats:
Trond Myklebust79caa5f2019-04-24 17:46:42 -0400444 put_cred(clnt->cl_cred);
Trond Myklebust2f048db2013-09-04 21:51:44 -0400445 rpc_free_clid(clnt);
446out_no_clid:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700447 kfree(clnt);
448out_err:
Trond Myklebust4ada5392007-06-14 17:26:17 -0400449 rpciod_down();
450out_no_rpciod:
Trond Myklebustad01b2c2016-01-30 14:17:26 -0500451 xprt_switch_put(xps);
Trond Myklebustf05c1242013-04-05 14:13:21 -0400452 xprt_put(xprt);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700453 return ERR_PTR(err);
454}
455
J. Bruce Fieldsd50039e2016-05-16 17:03:42 -0400456static struct rpc_clnt *rpc_create_xprt(struct rpc_create_args *args,
Kinglong Mee83ddfeb2014-03-24 11:58:59 +0800457 struct rpc_xprt *xprt)
458{
459 struct rpc_clnt *clnt = NULL;
Trond Myklebustad01b2c2016-01-30 14:17:26 -0500460 struct rpc_xprt_switch *xps;
Kinglong Mee83ddfeb2014-03-24 11:58:59 +0800461
J. Bruce Fields39a9beab2016-05-17 12:38:21 -0400462 if (args->bc_xprt && args->bc_xprt->xpt_bc_xps) {
Chuck Lever16590a22016-08-22 14:57:42 -0400463 WARN_ON_ONCE(!(args->protocol & XPRT_TRANSPORT_BC));
J. Bruce Fields39a9beab2016-05-17 12:38:21 -0400464 xps = args->bc_xprt->xpt_bc_xps;
465 xprt_switch_get(xps);
466 } else {
467 xps = xprt_switch_alloc(xprt, GFP_KERNEL);
468 if (xps == NULL) {
469 xprt_put(xprt);
470 return ERR_PTR(-ENOMEM);
471 }
472 if (xprt->bc_xprt) {
473 xprt_switch_get(xps);
474 xprt->bc_xprt->xpt_bc_xps = xps;
475 }
J. Bruce Fields1208fd52016-05-20 17:07:17 -0400476 }
Trond Myklebustad01b2c2016-01-30 14:17:26 -0500477 clnt = rpc_new_client(args, xps, xprt, NULL);
Kinglong Mee83ddfeb2014-03-24 11:58:59 +0800478 if (IS_ERR(clnt))
479 return clnt;
480
481 if (!(args->flags & RPC_CLNT_CREATE_NOPING)) {
482 int err = rpc_ping(clnt);
483 if (err != 0) {
484 rpc_shutdown_client(clnt);
485 return ERR_PTR(err);
486 }
487 }
488
489 clnt->cl_softrtry = 1;
Trond Myklebustae6ec912019-04-07 13:58:58 -0400490 if (args->flags & (RPC_CLNT_CREATE_HARDRTRY|RPC_CLNT_CREATE_SOFTERR)) {
Kinglong Mee83ddfeb2014-03-24 11:58:59 +0800491 clnt->cl_softrtry = 0;
Trond Myklebustae6ec912019-04-07 13:58:58 -0400492 if (args->flags & RPC_CLNT_CREATE_SOFTERR)
493 clnt->cl_softerr = 1;
494 }
Kinglong Mee83ddfeb2014-03-24 11:58:59 +0800495
496 if (args->flags & RPC_CLNT_CREATE_AUTOBIND)
497 clnt->cl_autobind = 1;
Trond Myklebust2aca5b82014-09-24 22:35:58 -0400498 if (args->flags & RPC_CLNT_CREATE_NO_RETRANS_TIMEOUT)
499 clnt->cl_noretranstimeo = 1;
Kinglong Mee83ddfeb2014-03-24 11:58:59 +0800500 if (args->flags & RPC_CLNT_CREATE_DISCRTRY)
501 clnt->cl_discrtry = 1;
502 if (!(args->flags & RPC_CLNT_CREATE_QUIET))
503 clnt->cl_chatty = 1;
504
505 return clnt;
506}
Kinglong Mee83ddfeb2014-03-24 11:58:59 +0800507
Ben Hutchings2c530402012-07-10 10:55:09 +0000508/**
Chuck Leverc2866762006-08-22 20:06:20 -0400509 * 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 */
518struct rpc_clnt *rpc_create(struct rpc_create_args *args)
519{
520 struct rpc_xprt *xprt;
\"Talpey, Thomas\3c341b0b2007-09-10 13:47:07 -0400521 struct xprt_create xprtargs = {
Pavel Emelyanov9a23e332010-09-29 16:05:12 +0400522 .net = args->net,
\"Talpey, Thomas\4fa016e2007-09-10 13:47:57 -0400523 .ident = args->protocol,
Frank van Maarseveend3bc9a12007-07-09 22:23:35 +0200524 .srcaddr = args->saddress,
Frank van Maarseveen96802a02007-07-08 13:08:54 +0200525 .dstaddr = args->address,
526 .addrlen = args->addrsize,
Trond Myklebust4e0038b2012-03-01 17:01:05 -0500527 .servername = args->servername,
Alexandros Batsakisf300bab2009-09-10 17:33:30 +0300528 .bc_xprt = args->bc_xprt,
Frank van Maarseveen96802a02007-07-08 13:08:54 +0200529 };
Chuck Lever510deb02007-12-10 14:56:24 -0500530 char servername[48];
Trond Myklebust612b41f2017-04-27 08:50:51 -0400531 struct rpc_clnt *clnt;
532 int i;
Chuck Leverc2866762006-08-22 20:06:20 -0400533
J. Bruce Fieldsd50039e2016-05-16 17:03:42 -0400534 if (args->bc_xprt) {
Chuck Lever16590a22016-08-22 14:57:42 -0400535 WARN_ON_ONCE(!(args->protocol & XPRT_TRANSPORT_BC));
J. Bruce Fieldsd50039e2016-05-16 17:03:42 -0400536 xprt = args->bc_xprt->xpt_bc_xprt;
537 if (xprt) {
538 xprt_get(xprt);
539 return rpc_create_xprt(args, xprt);
540 }
541 }
542
Trond Myklebustb7993ce2013-04-14 11:42:00 -0400543 if (args->flags & RPC_CLNT_CREATE_INFINITE_SLOTS)
544 xprtargs.flags |= XPRT_CREATE_INFINITE_SLOTS;
J. Bruce Fields33d90ac2013-04-11 15:06:36 -0400545 if (args->flags & RPC_CLNT_CREATE_NO_IDLE_TIMEOUT)
546 xprtargs.flags |= XPRT_CREATE_NO_IDLE_TIMEOUT;
Chuck Leverc2866762006-08-22 20:06:20 -0400547 /*
Chuck Lever43780b82007-07-01 12:13:22 -0400548 * If the caller chooses not to specify a hostname, whip
549 * up a string representation of the passed-in address.
550 */
Trond Myklebust4e0038b2012-03-01 17:01:05 -0500551 if (xprtargs.servername == NULL) {
Chuck Lever176e21e2011-05-09 15:22:44 -0400552 struct sockaddr_un *sun =
553 (struct sockaddr_un *)args->address;
Chuck Leverda09eb92011-05-09 15:22:25 -0400554 struct sockaddr_in *sin =
555 (struct sockaddr_in *)args->address;
556 struct sockaddr_in6 *sin6 =
557 (struct sockaddr_in6 *)args->address;
558
Chuck Lever510deb02007-12-10 14:56:24 -0500559 servername[0] = '\0';
560 switch (args->address->sa_family) {
Chuck Lever176e21e2011-05-09 15:22:44 -0400561 case AF_LOCAL:
562 snprintf(servername, sizeof(servername), "%s",
563 sun->sun_path);
564 break;
Chuck Leverda09eb92011-05-09 15:22:25 -0400565 case AF_INET:
Harvey Harrison21454aa2008-10-31 00:54:56 -0700566 snprintf(servername, sizeof(servername), "%pI4",
567 &sin->sin_addr.s_addr);
Chuck Lever510deb02007-12-10 14:56:24 -0500568 break;
Chuck Leverda09eb92011-05-09 15:22:25 -0400569 case AF_INET6:
Harvey Harrison5b095d9892008-10-29 12:52:50 -0700570 snprintf(servername, sizeof(servername), "%pI6",
Chuck Leverda09eb92011-05-09 15:22:25 -0400571 &sin6->sin6_addr);
Chuck Lever510deb02007-12-10 14:56:24 -0500572 break;
Chuck Lever510deb02007-12-10 14:56:24 -0500573 default:
574 /* caller wants default server name, but
575 * address family isn't recognized. */
576 return ERR_PTR(-EINVAL);
577 }
Trond Myklebust4e0038b2012-03-01 17:01:05 -0500578 xprtargs.servername = servername;
Chuck Lever43780b82007-07-01 12:13:22 -0400579 }
580
Chuck Lever510deb02007-12-10 14:56:24 -0500581 xprt = xprt_create_transport(&xprtargs);
582 if (IS_ERR(xprt))
583 return (struct rpc_clnt *)xprt;
584
Chuck Lever43780b82007-07-01 12:13:22 -0400585 /*
Chuck Leverc2866762006-08-22 20:06:20 -0400586 * 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 xprt->resvport = 1;
592 if (args->flags & RPC_CLNT_CREATE_NONPRIVPORT)
593 xprt->resvport = 0;
Trond Myklebuste6237b62019-10-17 11:13:54 -0400594 xprt->reuseport = 0;
595 if (args->flags & RPC_CLNT_CREATE_REUSEPORT)
596 xprt->reuseport = 1;
Chuck Leverc2866762006-08-22 20:06:20 -0400597
Trond Myklebust612b41f2017-04-27 08:50:51 -0400598 clnt = rpc_create_xprt(args, xprt);
599 if (IS_ERR(clnt) || args->nconnect <= 1)
600 return clnt;
601
602 for (i = 0; i < args->nconnect - 1; i++) {
603 if (rpc_clnt_add_xprt(clnt, &xprtargs, NULL, NULL) < 0)
604 break;
605 }
606 return clnt;
Chuck Leverc2866762006-08-22 20:06:20 -0400607}
Chuck Leverb86acd52006-08-22 20:06:22 -0400608EXPORT_SYMBOL_GPL(rpc_create);
Chuck Leverc2866762006-08-22 20:06:20 -0400609
Linus Torvalds1da177e2005-04-16 15:20:36 -0700610/*
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 */
Chuck Lever1b63a752012-09-14 17:23:52 -0400615static struct rpc_clnt *__rpc_clone_client(struct rpc_create_args *args,
616 struct rpc_clnt *clnt)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700617{
Trond Myklebustad01b2c2016-01-30 14:17:26 -0500618 struct rpc_xprt_switch *xps;
Trond Myklebust2446ab62012-03-01 17:00:56 -0500619 struct rpc_xprt *xprt;
Chuck Lever1b63a752012-09-14 17:23:52 -0400620 struct rpc_clnt *new;
621 int err;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700622
Chuck Lever1b63a752012-09-14 17:23:52 -0400623 err = -ENOMEM;
Trond Myklebust2446ab62012-03-01 17:00:56 -0500624 rcu_read_lock();
625 xprt = xprt_get(rcu_dereference(clnt->cl_xprt));
Trond Myklebustad01b2c2016-01-30 14:17:26 -0500626 xps = xprt_switch_get(rcu_dereference(clnt->cl_xpi.xpi_xpswitch));
Trond Myklebust2446ab62012-03-01 17:00:56 -0500627 rcu_read_unlock();
Trond Myklebustad01b2c2016-01-30 14:17:26 -0500628 if (xprt == NULL || xps == NULL) {
629 xprt_put(xprt);
630 xprt_switch_put(xps);
Chuck Lever1b63a752012-09-14 17:23:52 -0400631 goto out_err;
Trond Myklebustad01b2c2016-01-30 14:17:26 -0500632 }
Chuck Lever1b63a752012-09-14 17:23:52 -0400633 args->servername = xprt->servername;
Trond Myklebust03a9a422015-01-30 18:12:28 -0500634 args->nodename = clnt->cl_nodename;
Chuck Lever1b63a752012-09-14 17:23:52 -0400635
Trond Myklebustad01b2c2016-01-30 14:17:26 -0500636 new = rpc_new_client(args, xps, xprt, clnt);
Chuck Lever1b63a752012-09-14 17:23:52 -0400637 if (IS_ERR(new)) {
638 err = PTR_ERR(new);
Chuck Levera58e0be2013-03-22 12:52:59 -0400639 goto out_err;
Chuck Lever1b63a752012-09-14 17:23:52 -0400640 }
641
Chuck Lever1b63a752012-09-14 17:23:52 -0400642 /* Turn off autobind on clones */
643 new->cl_autobind = 0;
644 new->cl_softrtry = clnt->cl_softrtry;
Trond Myklebustae6ec912019-04-07 13:58:58 -0400645 new->cl_softerr = clnt->cl_softerr;
Trond Myklebust2aca5b82014-09-24 22:35:58 -0400646 new->cl_noretranstimeo = clnt->cl_noretranstimeo;
Chuck Lever1b63a752012-09-14 17:23:52 -0400647 new->cl_discrtry = clnt->cl_discrtry;
648 new->cl_chatty = clnt->cl_chatty;
NeilBrown5e169232018-12-03 11:30:30 +1100649 new->cl_principal = clnt->cl_principal;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700650 return new;
Chuck Lever1b63a752012-09-14 17:23:52 -0400651
Chuck Lever1b63a752012-09-14 17:23:52 -0400652out_err:
Harvey Harrison0dc47872008-03-05 20:47:47 -0800653 dprintk("RPC: %s: returned error %d\n", __func__, err);
Trond Myklebust3e32a5d2006-11-16 11:37:27 -0500654 return ERR_PTR(err);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700655}
Chuck Lever1b63a752012-09-14 17:23:52 -0400656
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 */
664struct rpc_clnt *rpc_clone_client(struct rpc_clnt *clnt)
665{
666 struct rpc_create_args args = {
667 .program = clnt->cl_program,
668 .prognumber = clnt->cl_prog,
669 .version = clnt->cl_vers,
670 .authflavor = clnt->cl_auth->au_flavor,
Trond Myklebust79caa5f2019-04-24 17:46:42 -0400671 .cred = clnt->cl_cred,
Chuck Lever1b63a752012-09-14 17:23:52 -0400672 };
673 return __rpc_clone_client(&args, clnt);
674}
Trond Myklebuste8914c62007-07-14 15:39:59 -0400675EXPORT_SYMBOL_GPL(rpc_clone_client);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700676
Chuck Leverba9b5842012-09-14 17:24:02 -0400677/**
678 * rpc_clone_client_set_auth - Clone an RPC client structure and set its auth
679 *
680 * @clnt: RPC client whose parameters are copied
Randy Dunlap7144bca2013-01-09 17:12:35 -0800681 * @flavor: security flavor for new client
Chuck Leverba9b5842012-09-14 17:24:02 -0400682 *
683 * Returns a fresh RPC client or an ERR_PTR.
684 */
685struct rpc_clnt *
686rpc_clone_client_set_auth(struct rpc_clnt *clnt, rpc_authflavor_t flavor)
687{
688 struct rpc_create_args args = {
689 .program = clnt->cl_program,
690 .prognumber = clnt->cl_prog,
691 .version = clnt->cl_vers,
692 .authflavor = flavor,
Trond Myklebust79caa5f2019-04-24 17:46:42 -0400693 .cred = clnt->cl_cred,
Chuck Leverba9b5842012-09-14 17:24:02 -0400694 };
695 return __rpc_clone_client(&args, clnt);
696}
697EXPORT_SYMBOL_GPL(rpc_clone_client_set_auth);
698
Trond Myklebust40b00b6b2013-10-17 14:12:23 -0400699/**
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 */
714int rpc_switch_client_transport(struct rpc_clnt *clnt,
715 struct xprt_create *args,
716 const struct rpc_timeout *timeout)
717{
718 const struct rpc_timeout *old_timeo;
719 rpc_authflavor_t pseudoflavor;
Trond Myklebustad01b2c2016-01-30 14:17:26 -0500720 struct rpc_xprt_switch *xps, *oldxps;
Trond Myklebust40b00b6b2013-10-17 14:12:23 -0400721 struct rpc_xprt *xprt, *old;
722 struct rpc_clnt *parent;
723 int err;
724
725 xprt = xprt_create_transport(args);
726 if (IS_ERR(xprt)) {
727 dprintk("RPC: failed to create new xprt for clnt %p\n",
728 clnt);
729 return PTR_ERR(xprt);
730 }
731
Trond Myklebustad01b2c2016-01-30 14:17:26 -0500732 xps = xprt_switch_alloc(xprt, GFP_KERNEL);
733 if (xps == NULL) {
734 xprt_put(xprt);
735 return -ENOMEM;
736 }
737
Trond Myklebust40b00b6b2013-10-17 14:12:23 -0400738 pseudoflavor = clnt->cl_auth->au_flavor;
739
740 old_timeo = clnt->cl_timeout;
741 old = rpc_clnt_set_transport(clnt, xprt, timeout);
Trond Myklebustad01b2c2016-01-30 14:17:26 -0500742 oldxps = xprt_iter_xchg_switch(&clnt->cl_xpi, xps);
Trond Myklebust40b00b6b2013-10-17 14:12:23 -0400743
744 rpc_unregister_client(clnt);
745 __rpc_clnt_remove_pipedir(clnt);
Jeff Laytonb4b9d2c2014-11-26 14:44:43 -0500746 rpc_clnt_debugfs_unregister(clnt);
Trond Myklebust40b00b6b2013-10-17 14:12:23 -0400747
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 parent = clnt->cl_parent;
754 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 err = rpc_client_register(clnt, pseudoflavor, NULL);
762 if (err)
763 goto out_revert;
764
765 synchronize_rcu();
766 if (parent != clnt)
767 rpc_release_client(parent);
Trond Myklebustad01b2c2016-01-30 14:17:26 -0500768 xprt_switch_put(oldxps);
Trond Myklebust40b00b6b2013-10-17 14:12:23 -0400769 xprt_put(old);
770 dprintk("RPC: replaced xprt for clnt %p\n", clnt);
771 return 0;
772
773out_revert:
Trond Myklebustad01b2c2016-01-30 14:17:26 -0500774 xps = xprt_iter_xchg_switch(&clnt->cl_xpi, oldxps);
Trond Myklebust40b00b6b2013-10-17 14:12:23 -0400775 rpc_clnt_set_transport(clnt, old, old_timeo);
776 clnt->cl_parent = parent;
777 rpc_client_register(clnt, pseudoflavor, NULL);
Trond Myklebustad01b2c2016-01-30 14:17:26 -0500778 xprt_switch_put(xps);
Trond Myklebust40b00b6b2013-10-17 14:12:23 -0400779 xprt_put(xprt);
780 dprintk("RPC: failed to switch xprt for clnt %p\n", clnt);
781 return err;
782}
783EXPORT_SYMBOL_GPL(rpc_switch_client_transport);
784
Trond Myklebust32278862016-01-30 20:39:19 -0500785static
786int rpc_clnt_xprt_iter_init(struct rpc_clnt *clnt, struct rpc_xprt_iter *xpi)
787{
788 struct rpc_xprt_switch *xps;
789
790 rcu_read_lock();
791 xps = xprt_switch_get(rcu_dereference(clnt->cl_xpi.xpi_xpswitch));
792 rcu_read_unlock();
793 if (xps == NULL)
794 return -EAGAIN;
795 xprt_iter_init_listall(xpi, xps);
796 xprt_switch_put(xps);
797 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 */
811int 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 struct rpc_xprt_iter xpi;
816 int ret;
817
818 ret = rpc_clnt_xprt_iter_init(clnt, &xpi);
819 if (ret)
820 return ret;
821 for (;;) {
822 struct rpc_xprt *xprt = xprt_iter_get_next(&xpi);
823
824 if (!xprt)
825 break;
826 ret = fn(clnt, xprt, data);
827 xprt_put(xprt);
828 if (ret < 0)
829 break;
830 }
831 xprt_iter_destroy(&xpi);
832 return ret;
833}
834EXPORT_SYMBOL_GPL(rpc_clnt_iterate_for_each_xprt);
835
Linus Torvalds1da177e2005-04-16 15:20:36 -0700836/*
Trond Myklebust58f96122010-07-31 14:29:08 -0400837 * Kill all tasks for the given client.
838 * XXX: kill their descendants as well?
839 */
840void rpc_killall_tasks(struct rpc_clnt *clnt)
841{
842 struct rpc_task *rovr;
843
844
845 if (list_empty(&clnt->cl_tasks))
846 return;
847 dprintk("RPC: killing all tasks for client %p\n", clnt);
848 /*
849 * Spin lock all_tasks to prevent changes...
850 */
851 spin_lock(&clnt->cl_lock);
Trond Myklebustae67bd32019-04-07 13:58:44 -0400852 list_for_each_entry(rovr, &clnt->cl_tasks, tk_task)
853 rpc_signal_task(rovr);
Trond Myklebust58f96122010-07-31 14:29:08 -0400854 spin_unlock(&clnt->cl_lock);
855}
856EXPORT_SYMBOL_GPL(rpc_killall_tasks);
857
858/*
Linus Torvalds1da177e2005-04-16 15:20:36 -0700859 * Properly shut down an RPC client, terminating all outstanding
Trond Myklebust90c57552007-06-09 19:49:36 -0400860 * requests.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700861 */
Trond Myklebust4c402b42007-06-14 16:40:32 -0400862void rpc_shutdown_client(struct rpc_clnt *clnt)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700863{
Weston Andros Adamson168e4b32012-10-30 17:01:40 -0400864 might_sleep();
865
Trond Myklebust4e0038b2012-03-01 17:01:05 -0500866 dprintk_rcu("RPC: shutting down %s client for %s\n",
Trond Myklebust55909f22013-08-23 11:48:15 -0400867 clnt->cl_program->name,
Trond Myklebust4e0038b2012-03-01 17:01:05 -0500868 rcu_dereference(clnt->cl_xprt)->servername);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700869
Trond Myklebust34f52e32007-06-14 16:40:31 -0400870 while (!list_empty(&clnt->cl_tasks)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700871 rpc_killall_tasks(clnt);
Ingo Molnar532347e2006-01-09 20:52:53 -0800872 wait_event_timeout(destroy_wait,
Trond Myklebust34f52e32007-06-14 16:40:31 -0400873 list_empty(&clnt->cl_tasks), 1*HZ);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700874 }
875
Trond Myklebust4c402b42007-06-14 16:40:32 -0400876 rpc_release_client(clnt);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700877}
Trond Myklebuste8914c62007-07-14 15:39:59 -0400878EXPORT_SYMBOL_GPL(rpc_shutdown_client);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700879
880/*
Trond Myklebust34f52e32007-06-14 16:40:31 -0400881 * Free an RPC client
Linus Torvalds1da177e2005-04-16 15:20:36 -0700882 */
Trond Myklebustd07ba842013-11-12 17:24:36 -0500883static struct rpc_clnt *
Trond Myklebust006abe82010-09-12 19:55:25 -0400884rpc_free_client(struct rpc_clnt *clnt)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700885{
Trond Myklebustd07ba842013-11-12 17:24:36 -0500886 struct rpc_clnt *parent = NULL;
887
Trond Myklebust4e0038b2012-03-01 17:01:05 -0500888 dprintk_rcu("RPC: destroying %s client for %s\n",
Trond Myklebust55909f22013-08-23 11:48:15 -0400889 clnt->cl_program->name,
Trond Myklebust4e0038b2012-03-01 17:01:05 -0500890 rcu_dereference(clnt->cl_xprt)->servername);
Trond Myklebust6eac7d32012-01-20 13:53:37 -0500891 if (clnt->cl_parent != clnt)
Trond Myklebustd07ba842013-11-12 17:24:36 -0500892 parent = clnt->cl_parent;
Jeff Laytonb4b9d2c2014-11-26 14:44:43 -0500893 rpc_clnt_debugfs_unregister(clnt);
Stanislav Kinsburskyf5131252012-01-11 19:18:26 +0400894 rpc_clnt_remove_pipedir(clnt);
Stanislav Kinsburskyadb6fa72013-06-26 10:15:14 +0400895 rpc_unregister_client(clnt);
Chuck Lever11c556b2006-03-20 13:44:22 -0500896 rpc_free_iostats(clnt->cl_metrics);
897 clnt->cl_metrics = NULL;
Trond Myklebust2446ab62012-03-01 17:00:56 -0500898 xprt_put(rcu_dereference_raw(clnt->cl_xprt));
Trond Myklebustad01b2c2016-01-30 14:17:26 -0500899 xprt_iter_destroy(&clnt->cl_xpi);
Trond Myklebust4ada5392007-06-14 17:26:17 -0400900 rpciod_down();
Trond Myklebust79caa5f2019-04-24 17:46:42 -0400901 put_cred(clnt->cl_cred);
Trond Myklebust2f048db2013-09-04 21:51:44 -0400902 rpc_free_clid(clnt);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700903 kfree(clnt);
Trond Myklebustd07ba842013-11-12 17:24:36 -0500904 return parent;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700905}
906
907/*
Trond Myklebust1dd17ec2007-06-26 16:57:41 -0400908 * Free an RPC client
909 */
Stephen Hemminger8fdee4c2018-07-24 12:29:15 -0700910static struct rpc_clnt *
Trond Myklebust006abe82010-09-12 19:55:25 -0400911rpc_free_auth(struct rpc_clnt *clnt)
Trond Myklebust1dd17ec2007-06-26 16:57:41 -0400912{
Trond Myklebustd07ba842013-11-12 17:24:36 -0500913 if (clnt->cl_auth == NULL)
914 return rpc_free_client(clnt);
Trond Myklebust1dd17ec2007-06-26 16:57:41 -0400915
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 */
Trond Myklebust006abe82010-09-12 19:55:25 -0400921 atomic_inc(&clnt->cl_count);
Trond Myklebust1dd17ec2007-06-26 16:57:41 -0400922 rpcauth_release(clnt->cl_auth);
923 clnt->cl_auth = NULL;
Trond Myklebust006abe82010-09-12 19:55:25 -0400924 if (atomic_dec_and_test(&clnt->cl_count))
Trond Myklebustd07ba842013-11-12 17:24:36 -0500925 return rpc_free_client(clnt);
926 return NULL;
Trond Myklebust1dd17ec2007-06-26 16:57:41 -0400927}
928
929/*
Trond Myklebust34f52e32007-06-14 16:40:31 -0400930 * Release reference to the RPC client
Linus Torvalds1da177e2005-04-16 15:20:36 -0700931 */
932void
933rpc_release_client(struct rpc_clnt *clnt)
934{
Trond Myklebust34f52e32007-06-14 16:40:31 -0400935 dprintk("RPC: rpc_release_client(%p)\n", clnt);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700936
Trond Myklebustd07ba842013-11-12 17:24:36 -0500937 do {
938 if (list_empty(&clnt->cl_tasks))
939 wake_up(&destroy_wait);
940 if (!atomic_dec_and_test(&clnt->cl_count))
941 break;
942 clnt = rpc_free_auth(clnt);
943 } while (clnt != NULL);
Trond Myklebust34f52e32007-06-14 16:40:31 -0400944}
Simo Sorce1d658332012-05-25 18:09:55 -0400945EXPORT_SYMBOL_GPL(rpc_release_client);
Trond Myklebust34f52e32007-06-14 16:40:31 -0400946
Andreas Gruenbacher007e2512005-06-22 17:16:23 +0000947/**
948 * rpc_bind_new_program - bind a new RPC program to an existing client
Randy Dunlap65b6e422008-02-13 15:03:23 -0800949 * @old: old rpc_client
950 * @program: rpc program to set
951 * @vers: rpc program version
Andreas Gruenbacher007e2512005-06-22 17:16:23 +0000952 *
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 */
957struct rpc_clnt *rpc_bind_new_program(struct rpc_clnt *old,
Trond Myklebusta613fa12012-01-20 13:53:56 -0500958 const struct rpc_program *program,
Chuck Lever89eb21c2007-09-11 18:00:09 -0400959 u32 vers)
Andreas Gruenbacher007e2512005-06-22 17:16:23 +0000960{
Trond Myklebustf994c432012-11-01 12:14:14 -0400961 struct rpc_create_args args = {
962 .program = program,
963 .prognumber = program->number,
964 .version = vers,
965 .authflavor = old->cl_auth->au_flavor,
Trond Myklebust79caa5f2019-04-24 17:46:42 -0400966 .cred = old->cl_cred,
Trond Myklebustf994c432012-11-01 12:14:14 -0400967 };
Andreas Gruenbacher007e2512005-06-22 17:16:23 +0000968 struct rpc_clnt *clnt;
Andreas Gruenbacher007e2512005-06-22 17:16:23 +0000969 int err;
970
Trond Myklebustf994c432012-11-01 12:14:14 -0400971 clnt = __rpc_clone_client(&args, old);
Andreas Gruenbacher007e2512005-06-22 17:16:23 +0000972 if (IS_ERR(clnt))
973 goto out;
Chuck Levercaabea82009-12-03 15:58:56 -0500974 err = rpc_ping(clnt);
Andreas Gruenbacher007e2512005-06-22 17:16:23 +0000975 if (err != 0) {
976 rpc_shutdown_client(clnt);
977 clnt = ERR_PTR(err);
978 }
YOSHIFUJI Hideakicca51722007-02-09 15:38:13 -0800979out:
Andreas Gruenbacher007e2512005-06-22 17:16:23 +0000980 return clnt;
981}
Trond Myklebuste8914c62007-07-14 15:39:59 -0400982EXPORT_SYMBOL_GPL(rpc_bind_new_program);
Andreas Gruenbacher007e2512005-06-22 17:16:23 +0000983
Trond Myklebusta101b042019-07-11 16:33:12 -0400984struct rpc_xprt *
985rpc_task_get_xprt(struct rpc_clnt *clnt, struct rpc_xprt *xprt)
Trond Myklebust21f0ffa2017-04-28 10:52:42 -0400986{
987 struct rpc_xprt_switch *xps;
Trond Myklebust21f0ffa2017-04-28 10:52:42 -0400988
989 if (!xprt)
990 return NULL;
991 rcu_read_lock();
992 xps = rcu_dereference(clnt->cl_xpi.xpi_xpswitch);
993 atomic_long_inc(&xps->xps_queuelen);
994 rcu_read_unlock();
995 atomic_long_inc(&xprt->queuelen);
996
997 return xprt;
998}
999
1000static void
1001rpc_task_release_xprt(struct rpc_clnt *clnt, struct rpc_xprt *xprt)
1002{
1003 struct rpc_xprt_switch *xps;
1004
1005 atomic_long_dec(&xprt->queuelen);
1006 rcu_read_lock();
1007 xps = rcu_dereference(clnt->cl_xpi.xpi_xpswitch);
1008 atomic_long_dec(&xps->xps_queuelen);
1009 rcu_read_unlock();
1010
1011 xprt_put(xprt);
1012}
1013
Bill Baker0f90be12018-06-19 16:24:58 -05001014void rpc_task_release_transport(struct rpc_task *task)
1015{
1016 struct rpc_xprt *xprt = task->tk_xprt;
1017
1018 if (xprt) {
1019 task->tk_xprt = NULL;
Trond Myklebust21f0ffa2017-04-28 10:52:42 -04001020 if (task->tk_client)
1021 rpc_task_release_xprt(task->tk_client, xprt);
1022 else
1023 xprt_put(xprt);
Bill Baker0f90be12018-06-19 16:24:58 -05001024 }
1025}
1026EXPORT_SYMBOL_GPL(rpc_task_release_transport);
1027
Trond Myklebust58f96122010-07-31 14:29:08 -04001028void rpc_task_release_client(struct rpc_task *task)
1029{
1030 struct rpc_clnt *clnt = task->tk_client;
1031
Trond Myklebust21f0ffa2017-04-28 10:52:42 -04001032 rpc_task_release_transport(task);
Trond Myklebust58f96122010-07-31 14:29:08 -04001033 if (clnt != NULL) {
1034 /* Remove from client task list */
1035 spin_lock(&clnt->cl_lock);
1036 list_del(&task->tk_task);
1037 spin_unlock(&clnt->cl_lock);
1038 task->tk_client = NULL;
1039
1040 rpc_release_client(clnt);
1041 }
Bill Baker0f90be12018-06-19 16:24:58 -05001042}
Trond Myklebustfb43d172016-01-30 16:39:26 -05001043
Trond Myklebusta101b042019-07-11 16:33:12 -04001044static struct rpc_xprt *
1045rpc_task_get_first_xprt(struct rpc_clnt *clnt)
1046{
1047 struct rpc_xprt *xprt;
1048
1049 rcu_read_lock();
1050 xprt = xprt_get(rcu_dereference(clnt->cl_xprt));
1051 rcu_read_unlock();
1052 return rpc_task_get_xprt(clnt, xprt);
1053}
1054
1055static struct rpc_xprt *
1056rpc_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
Bill Baker0f90be12018-06-19 16:24:58 -05001061static
1062void rpc_task_set_transport(struct rpc_task *task, struct rpc_clnt *clnt)
1063{
NeilBrown5a0c2572019-05-30 10:41:28 +10001064 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
Trond Myklebusta101b042019-07-11 16:33:12 -04001069 task->tk_xprt = rpc_task_get_next_xprt(clnt);
Trond Myklebust58f96122010-07-31 14:29:08 -04001070}
1071
1072static
1073void rpc_task_set_client(struct rpc_task *task, struct rpc_clnt *clnt)
1074{
Trond Myklebustfb43d172016-01-30 16:39:26 -05001075
Trond Myklebust58f96122010-07-31 14:29:08 -04001076 if (clnt != NULL) {
Bill Baker0f90be12018-06-19 16:24:58 -05001077 rpc_task_set_transport(task, clnt);
Trond Myklebust58f96122010-07-31 14:29:08 -04001078 task->tk_client = clnt;
Trond Myklebust006abe82010-09-12 19:55:25 -04001079 atomic_inc(&clnt->cl_count);
Trond Myklebust58f96122010-07-31 14:29:08 -04001080 if (clnt->cl_softrtry)
1081 task->tk_flags |= RPC_TASK_SOFT;
Trond Myklebustae6ec912019-04-07 13:58:58 -04001082 if (clnt->cl_softerr)
1083 task->tk_flags |= RPC_TASK_TIMEOUT;
Trond Myklebust8a19a0b2013-09-24 12:00:27 -04001084 if (clnt->cl_noretranstimeo)
1085 task->tk_flags |= RPC_TASK_NO_RETRANS_TIMEOUT;
Jeff Layton3c87ef62015-06-03 16:14:25 -04001086 if (atomic_read(&clnt->cl_swapper))
1087 task->tk_flags |= RPC_TASK_SWAPPER;
Trond Myklebust58f96122010-07-31 14:29:08 -04001088 /* Add to the client's list of all tasks */
1089 spin_lock(&clnt->cl_lock);
1090 list_add_tail(&task->tk_task, &clnt->cl_tasks);
1091 spin_unlock(&clnt->cl_lock);
1092 }
1093}
1094
1095static void
1096rpc_task_set_rpc_message(struct rpc_task *task, const struct rpc_message *msg)
1097{
1098 if (msg != NULL) {
1099 task->tk_msg.rpc_proc = msg->rpc_proc;
1100 task->tk_msg.rpc_argp = msg->rpc_argp;
1101 task->tk_msg.rpc_resp = msg->rpc_resp;
Trond Myklebust7eac5262020-02-07 19:11:12 -05001102 task->tk_msg.rpc_cred = msg->rpc_cred;
1103 if (!(task->tk_flags & RPC_TASK_CRED_NOREF))
1104 get_cred(task->tk_msg.rpc_cred);
Trond Myklebust58f96122010-07-31 14:29:08 -04001105 }
1106}
1107
Linus Torvalds1da177e2005-04-16 15:20:36 -07001108/*
1109 * Default callback for async RPC calls
1110 */
1111static void
Trond Myklebust963d8fe2006-01-03 09:55:04 +01001112rpc_default_callback(struct rpc_task *task, void *data)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001113{
1114}
1115
Trond Myklebust963d8fe2006-01-03 09:55:04 +01001116static const struct rpc_call_ops rpc_default_ops = {
1117 .rpc_call_done = rpc_default_callback,
1118};
1119
Trond Myklebustc970aa82007-07-14 15:39:59 -04001120/**
1121 * rpc_run_task - Allocate a new RPC task, then run rpc_execute against it
1122 * @task_setup_data: pointer to task initialisation data
1123 */
1124struct rpc_task *rpc_run_task(const struct rpc_task_setup *task_setup_data)
Trond Myklebust6e5b70e2007-06-12 10:02:37 -04001125{
Trond Myklebust19445b92010-04-16 16:41:10 -04001126 struct rpc_task *task;
Trond Myklebust6e5b70e2007-06-12 10:02:37 -04001127
Trond Myklebust84115e12007-07-14 15:39:59 -04001128 task = rpc_new_task(task_setup_data);
Trond Myklebust6e5b70e2007-06-12 10:02:37 -04001129
Trond Myklebust263fb9c2020-02-07 19:16:34 -05001130 if (!RPC_IS_ASYNC(task))
1131 task->tk_flags |= RPC_TASK_CRED_NOREF;
1132
Trond Myklebust58f96122010-07-31 14:29:08 -04001133 rpc_task_set_client(task, task_setup_data->rpc_client);
1134 rpc_task_set_rpc_message(task, task_setup_data->rpc_message);
1135
Trond Myklebust58f96122010-07-31 14:29:08 -04001136 if (task->tk_action == NULL)
1137 rpc_call_start(task);
1138
Trond Myklebust6e5b70e2007-06-12 10:02:37 -04001139 atomic_inc(&task->tk_count);
1140 rpc_execute(task);
Trond Myklebust19445b92010-04-16 16:41:10 -04001141 return task;
Trond Myklebust6e5b70e2007-06-12 10:02:37 -04001142}
Trond Myklebustc970aa82007-07-14 15:39:59 -04001143EXPORT_SYMBOL_GPL(rpc_run_task);
Trond Myklebust6e5b70e2007-06-12 10:02:37 -04001144
1145/**
1146 * rpc_call_sync - Perform a synchronous RPC call
1147 * @clnt: pointer to RPC client
1148 * @msg: RPC call parameters
1149 * @flags: RPC call flags
Linus Torvalds1da177e2005-04-16 15:20:36 -07001150 */
Trond Myklebustcbc20052008-02-14 11:11:30 -05001151int rpc_call_sync(struct rpc_clnt *clnt, const struct rpc_message *msg, int flags)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001152{
1153 struct rpc_task *task;
Trond Myklebust84115e12007-07-14 15:39:59 -04001154 struct rpc_task_setup task_setup_data = {
1155 .rpc_client = clnt,
1156 .rpc_message = msg,
1157 .callback_ops = &rpc_default_ops,
1158 .flags = flags,
1159 };
Trond Myklebust6e5b70e2007-06-12 10:02:37 -04001160 int status;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001161
Weston Andros Adamson50d2bdb2012-11-01 16:04:40 -04001162 WARN_ON_ONCE(flags & RPC_TASK_ASYNC);
1163 if (flags & RPC_TASK_ASYNC) {
1164 rpc_release_calldata(task_setup_data.callback_ops,
1165 task_setup_data.callback_data);
1166 return -EINVAL;
1167 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001168
Trond Myklebustc970aa82007-07-14 15:39:59 -04001169 task = rpc_run_task(&task_setup_data);
Trond Myklebust6e5b70e2007-06-12 10:02:37 -04001170 if (IS_ERR(task))
1171 return PTR_ERR(task);
Trond Myklebuste60859a2006-01-03 09:55:10 +01001172 status = task->tk_status;
Trond Myklebustbde8f002007-01-24 11:54:53 -08001173 rpc_put_task(task);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001174 return status;
1175}
Trond Myklebuste8914c62007-07-14 15:39:59 -04001176EXPORT_SYMBOL_GPL(rpc_call_sync);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001177
Trond Myklebust6e5b70e2007-06-12 10:02:37 -04001178/**
1179 * rpc_call_async - Perform an asynchronous RPC call
1180 * @clnt: pointer to RPC client
1181 * @msg: RPC call parameters
1182 * @flags: RPC call flags
Randy Dunlap65b6e422008-02-13 15:03:23 -08001183 * @tk_ops: RPC call ops
Trond Myklebust6e5b70e2007-06-12 10:02:37 -04001184 * @data: user call data
Linus Torvalds1da177e2005-04-16 15:20:36 -07001185 */
1186int
Trond Myklebustcbc20052008-02-14 11:11:30 -05001187rpc_call_async(struct rpc_clnt *clnt, const struct rpc_message *msg, int flags,
Trond Myklebust963d8fe2006-01-03 09:55:04 +01001188 const struct rpc_call_ops *tk_ops, void *data)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001189{
1190 struct rpc_task *task;
Trond Myklebust84115e12007-07-14 15:39:59 -04001191 struct rpc_task_setup task_setup_data = {
1192 .rpc_client = clnt,
1193 .rpc_message = msg,
1194 .callback_ops = tk_ops,
1195 .callback_data = data,
1196 .flags = flags|RPC_TASK_ASYNC,
1197 };
Linus Torvalds1da177e2005-04-16 15:20:36 -07001198
Trond Myklebustc970aa82007-07-14 15:39:59 -04001199 task = rpc_run_task(&task_setup_data);
Trond Myklebust6e5b70e2007-06-12 10:02:37 -04001200 if (IS_ERR(task))
1201 return PTR_ERR(task);
1202 rpc_put_task(task);
1203 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001204}
Trond Myklebuste8914c62007-07-14 15:39:59 -04001205EXPORT_SYMBOL_GPL(rpc_call_async);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001206
Trond Myklebust9e00abc2011-07-13 19:20:49 -04001207#if defined(CONFIG_SUNRPC_BACKCHANNEL)
Trond Myklebust477687e2019-03-05 07:30:48 -05001208static void call_bc_encode(struct rpc_task *task);
1209
Ricardo Labiaga55ae1aa2009-04-01 09:23:03 -04001210/**
1211 * rpc_run_bc_task - Allocate a new RPC task for backchannel use, then run
1212 * rpc_execute against it
Jaswinder Singh Rajput7a73fdd2009-09-24 14:58:42 -04001213 * @req: RPC request
Ricardo Labiaga55ae1aa2009-04-01 09:23:03 -04001214 */
Trond Myklebust0f419792015-06-01 22:59:08 -04001215struct rpc_task *rpc_run_bc_task(struct rpc_rqst *req)
Ricardo Labiaga55ae1aa2009-04-01 09:23:03 -04001216{
1217 struct rpc_task *task;
Ricardo Labiaga55ae1aa2009-04-01 09:23:03 -04001218 struct rpc_task_setup task_setup_data = {
Trond Myklebust0f419792015-06-01 22:59:08 -04001219 .callback_ops = &rpc_default_ops,
Trond Myklebust762e4e62018-08-24 16:28:28 -04001220 .flags = RPC_TASK_SOFTCONN |
1221 RPC_TASK_NO_RETRANS_TIMEOUT,
Ricardo Labiaga55ae1aa2009-04-01 09:23:03 -04001222 };
1223
1224 dprintk("RPC: rpc_run_bc_task req= %p\n", req);
1225 /*
1226 * Create an rpc_task to send the data
1227 */
1228 task = rpc_new_task(&task_setup_data);
Trond Myklebust902c5882018-09-01 17:21:01 -04001229 xprt_init_bc_request(req, task);
Ricardo Labiaga55ae1aa2009-04-01 09:23:03 -04001230
Trond Myklebust477687e2019-03-05 07:30:48 -05001231 task->tk_action = call_bc_encode;
Ricardo Labiaga55ae1aa2009-04-01 09:23:03 -04001232 atomic_inc(&task->tk_count);
Weston Andros Adamson9a6478f2012-10-23 10:43:27 -04001233 WARN_ON_ONCE(atomic_read(&task->tk_count) != 2);
Ricardo Labiaga55ae1aa2009-04-01 09:23:03 -04001234 rpc_execute(task);
1235
Ricardo Labiaga55ae1aa2009-04-01 09:23:03 -04001236 dprintk("RPC: rpc_run_bc_task: task= %p\n", task);
1237 return task;
1238}
Trond Myklebust9e00abc2011-07-13 19:20:49 -04001239#endif /* CONFIG_SUNRPC_BACKCHANNEL */
Ricardo Labiaga55ae1aa2009-04-01 09:23:03 -04001240
Chuck Levercf500ba2019-02-11 11:25:20 -05001241/**
1242 * rpc_prepare_reply_pages - Prepare to receive a reply data payload into pages
1243 * @req: RPC request to prepare
1244 * @pages: vector of struct page pointers
1245 * @base: offset in first page where receive should start, in bytes
1246 * @len: expected size of the upper layer data payload, in bytes
1247 * @hdrsize: expected size of upper layer reply header, in XDR words
1248 *
1249 */
1250void rpc_prepare_reply_pages(struct rpc_rqst *req, struct page **pages,
1251 unsigned int base, unsigned int len,
1252 unsigned int hdrsize)
1253{
Chuck Lever02ef04e2019-02-11 11:25:25 -05001254 /* Subtract one to force an extra word of buffer space for the
1255 * payload's XDR pad to fall into the rcv_buf's tail iovec.
1256 */
Chuck Lever35e77d22019-02-11 11:25:36 -05001257 hdrsize += RPC_REPHDRSIZE + req->rq_cred->cr_auth->au_ralign - 1;
Chuck Lever02ef04e2019-02-11 11:25:25 -05001258
Chuck Levercf500ba2019-02-11 11:25:20 -05001259 xdr_inline_pages(&req->rq_rcv_buf, hdrsize << 2, pages, base, len);
1260 trace_rpc_reply_pages(req);
1261}
1262EXPORT_SYMBOL_GPL(rpc_prepare_reply_pages);
1263
Linus Torvalds1da177e2005-04-16 15:20:36 -07001264void
Trond Myklebust77de2c52007-10-25 18:40:21 -04001265rpc_call_start(struct rpc_task *task)
1266{
1267 task->tk_action = call_start;
1268}
1269EXPORT_SYMBOL_GPL(rpc_call_start);
1270
Chuck Levered394402006-08-22 20:06:17 -04001271/**
1272 * rpc_peeraddr - extract remote peer address from clnt's xprt
1273 * @clnt: RPC client structure
1274 * @buf: target buffer
Randy Dunlap65b6e422008-02-13 15:03:23 -08001275 * @bufsize: length of target buffer
Chuck Levered394402006-08-22 20:06:17 -04001276 *
1277 * Returns the number of bytes that are actually in the stored address.
1278 */
1279size_t rpc_peeraddr(struct rpc_clnt *clnt, struct sockaddr *buf, size_t bufsize)
1280{
1281 size_t bytes;
Trond Myklebust2446ab62012-03-01 17:00:56 -05001282 struct rpc_xprt *xprt;
Chuck Levered394402006-08-22 20:06:17 -04001283
Trond Myklebust2446ab62012-03-01 17:00:56 -05001284 rcu_read_lock();
1285 xprt = rcu_dereference(clnt->cl_xprt);
1286
1287 bytes = xprt->addrlen;
Chuck Levered394402006-08-22 20:06:17 -04001288 if (bytes > bufsize)
1289 bytes = bufsize;
Trond Myklebust2446ab62012-03-01 17:00:56 -05001290 memcpy(buf, &xprt->addr, bytes);
1291 rcu_read_unlock();
1292
1293 return bytes;
Chuck Levered394402006-08-22 20:06:17 -04001294}
Chuck Leverb86acd52006-08-22 20:06:22 -04001295EXPORT_SYMBOL_GPL(rpc_peeraddr);
Chuck Levered394402006-08-22 20:06:17 -04001296
Chuck Leverf425eba2006-08-22 20:06:18 -04001297/**
1298 * rpc_peeraddr2str - return remote peer address in printable format
1299 * @clnt: RPC client structure
1300 * @format: address format
1301 *
Trond Myklebust2446ab62012-03-01 17:00:56 -05001302 * NB: the lifetime of the memory referenced by the returned pointer is
1303 * the same as the rpc_xprt itself. As long as the caller uses this
1304 * pointer, it must hold the RCU read lock.
Chuck Leverf425eba2006-08-22 20:06:18 -04001305 */
Chuck Leverb454ae92008-01-07 18:34:48 -05001306const char *rpc_peeraddr2str(struct rpc_clnt *clnt,
1307 enum rpc_display_format_t format)
Chuck Leverf425eba2006-08-22 20:06:18 -04001308{
Trond Myklebust2446ab62012-03-01 17:00:56 -05001309 struct rpc_xprt *xprt;
1310
1311 xprt = rcu_dereference(clnt->cl_xprt);
Chuck Lever7559c7a2006-12-05 16:35:37 -05001312
1313 if (xprt->address_strings[format] != NULL)
1314 return xprt->address_strings[format];
1315 else
1316 return "unprintable";
Chuck Leverf425eba2006-08-22 20:06:18 -04001317}
Chuck Leverb86acd52006-08-22 20:06:22 -04001318EXPORT_SYMBOL_GPL(rpc_peeraddr2str);
Chuck Leverf425eba2006-08-22 20:06:18 -04001319
Chuck Lever2e738fd2012-03-01 17:01:14 -05001320static const struct sockaddr_in rpc_inaddr_loopback = {
1321 .sin_family = AF_INET,
1322 .sin_addr.s_addr = htonl(INADDR_ANY),
1323};
1324
1325static const struct sockaddr_in6 rpc_in6addr_loopback = {
1326 .sin6_family = AF_INET6,
1327 .sin6_addr = IN6ADDR_ANY_INIT,
1328};
1329
1330/*
1331 * Try a getsockname() on a connected datagram socket. Using a
1332 * connected datagram socket prevents leaving a socket in TIME_WAIT.
1333 * This conserves the ephemeral port number space.
1334 *
1335 * Returns zero and fills in "buf" if successful; otherwise, a
1336 * negative errno is returned.
1337 */
1338static int rpc_sockname(struct net *net, struct sockaddr *sap, size_t salen,
Denys Vlasenko9b2c45d2018-02-12 20:00:20 +01001339 struct sockaddr *buf)
Chuck Lever2e738fd2012-03-01 17:01:14 -05001340{
1341 struct socket *sock;
1342 int err;
1343
1344 err = __sock_create(net, sap->sa_family,
1345 SOCK_DGRAM, IPPROTO_UDP, &sock, 1);
1346 if (err < 0) {
1347 dprintk("RPC: can't create UDP socket (%d)\n", err);
1348 goto out;
1349 }
1350
1351 switch (sap->sa_family) {
1352 case AF_INET:
1353 err = kernel_bind(sock,
1354 (struct sockaddr *)&rpc_inaddr_loopback,
1355 sizeof(rpc_inaddr_loopback));
1356 break;
1357 case AF_INET6:
1358 err = kernel_bind(sock,
1359 (struct sockaddr *)&rpc_in6addr_loopback,
1360 sizeof(rpc_in6addr_loopback));
1361 break;
1362 default:
1363 err = -EAFNOSUPPORT;
1364 goto out;
1365 }
1366 if (err < 0) {
1367 dprintk("RPC: can't bind UDP socket (%d)\n", err);
1368 goto out_release;
1369 }
1370
1371 err = kernel_connect(sock, sap, salen, 0);
1372 if (err < 0) {
1373 dprintk("RPC: can't connect UDP socket (%d)\n", err);
1374 goto out_release;
1375 }
1376
Denys Vlasenko9b2c45d2018-02-12 20:00:20 +01001377 err = kernel_getsockname(sock, buf);
Chuck Lever2e738fd2012-03-01 17:01:14 -05001378 if (err < 0) {
1379 dprintk("RPC: getsockname failed (%d)\n", err);
1380 goto out_release;
1381 }
1382
1383 err = 0;
1384 if (buf->sa_family == AF_INET6) {
1385 struct sockaddr_in6 *sin6 = (struct sockaddr_in6 *)buf;
1386 sin6->sin6_scope_id = 0;
1387 }
1388 dprintk("RPC: %s succeeded\n", __func__);
1389
1390out_release:
1391 sock_release(sock);
1392out:
1393 return err;
1394}
1395
1396/*
1397 * Scraping a connected socket failed, so we don't have a useable
1398 * local address. Fallback: generate an address that will prevent
1399 * the server from calling us back.
1400 *
1401 * Returns zero and fills in "buf" if successful; otherwise, a
1402 * negative errno is returned.
1403 */
1404static int rpc_anyaddr(int family, struct sockaddr *buf, size_t buflen)
1405{
1406 switch (family) {
1407 case AF_INET:
1408 if (buflen < sizeof(rpc_inaddr_loopback))
1409 return -EINVAL;
1410 memcpy(buf, &rpc_inaddr_loopback,
1411 sizeof(rpc_inaddr_loopback));
1412 break;
1413 case AF_INET6:
1414 if (buflen < sizeof(rpc_in6addr_loopback))
1415 return -EINVAL;
1416 memcpy(buf, &rpc_in6addr_loopback,
1417 sizeof(rpc_in6addr_loopback));
Trond Myklebust0b161e62015-12-30 18:14:06 -05001418 break;
Chuck Lever2e738fd2012-03-01 17:01:14 -05001419 default:
1420 dprintk("RPC: %s: address family not supported\n",
1421 __func__);
1422 return -EAFNOSUPPORT;
1423 }
1424 dprintk("RPC: %s: succeeded\n", __func__);
1425 return 0;
1426}
1427
1428/**
1429 * rpc_localaddr - discover local endpoint address for an RPC client
1430 * @clnt: RPC client structure
1431 * @buf: target buffer
1432 * @buflen: size of target buffer, in bytes
1433 *
1434 * Returns zero and fills in "buf" and "buflen" if successful;
1435 * otherwise, a negative errno is returned.
1436 *
1437 * This works even if the underlying transport is not currently connected,
1438 * or if the upper layer never previously provided a source address.
1439 *
1440 * The result of this function call is transient: multiple calls in
1441 * succession may give different results, depending on how local
1442 * networking configuration changes over time.
1443 */
1444int rpc_localaddr(struct rpc_clnt *clnt, struct sockaddr *buf, size_t buflen)
1445{
1446 struct sockaddr_storage address;
1447 struct sockaddr *sap = (struct sockaddr *)&address;
1448 struct rpc_xprt *xprt;
1449 struct net *net;
1450 size_t salen;
1451 int err;
1452
1453 rcu_read_lock();
1454 xprt = rcu_dereference(clnt->cl_xprt);
1455 salen = xprt->addrlen;
1456 memcpy(sap, &xprt->addr, salen);
1457 net = get_net(xprt->xprt_net);
1458 rcu_read_unlock();
1459
1460 rpc_set_port(sap, 0);
Denys Vlasenko9b2c45d2018-02-12 20:00:20 +01001461 err = rpc_sockname(net, sap, salen, buf);
Chuck Lever2e738fd2012-03-01 17:01:14 -05001462 put_net(net);
1463 if (err != 0)
1464 /* Couldn't discover local address, return ANYADDR */
1465 return rpc_anyaddr(sap->sa_family, buf, buflen);
1466 return 0;
1467}
1468EXPORT_SYMBOL_GPL(rpc_localaddr);
1469
Linus Torvalds1da177e2005-04-16 15:20:36 -07001470void
1471rpc_setbufsize(struct rpc_clnt *clnt, unsigned int sndsize, unsigned int rcvsize)
1472{
Trond Myklebust2446ab62012-03-01 17:00:56 -05001473 struct rpc_xprt *xprt;
1474
1475 rcu_read_lock();
1476 xprt = rcu_dereference(clnt->cl_xprt);
Chuck Lever470056c2005-08-25 16:25:56 -07001477 if (xprt->ops->set_buffer_size)
1478 xprt->ops->set_buffer_size(xprt, sndsize, rcvsize);
Trond Myklebust2446ab62012-03-01 17:00:56 -05001479 rcu_read_unlock();
Linus Torvalds1da177e2005-04-16 15:20:36 -07001480}
Trond Myklebuste8914c62007-07-14 15:39:59 -04001481EXPORT_SYMBOL_GPL(rpc_setbufsize);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001482
Trond Myklebust2446ab62012-03-01 17:00:56 -05001483/**
Trond Myklebust2446ab62012-03-01 17:00:56 -05001484 * rpc_net_ns - Get the network namespace for this RPC client
1485 * @clnt: RPC client to query
1486 *
1487 */
1488struct net *rpc_net_ns(struct rpc_clnt *clnt)
1489{
1490 struct net *ret;
1491
1492 rcu_read_lock();
1493 ret = rcu_dereference(clnt->cl_xprt)->xprt_net;
1494 rcu_read_unlock();
1495 return ret;
1496}
1497EXPORT_SYMBOL_GPL(rpc_net_ns);
1498
1499/**
1500 * rpc_max_payload - Get maximum payload size for a transport, in bytes
1501 * @clnt: RPC client to query
Linus Torvalds1da177e2005-04-16 15:20:36 -07001502 *
1503 * For stream transports, this is one RPC record fragment (see RFC
1504 * 1831), as we don't support multi-record requests yet. For datagram
1505 * transports, this is the size of an IP packet minus the IP, UDP, and
1506 * RPC header sizes.
1507 */
1508size_t rpc_max_payload(struct rpc_clnt *clnt)
1509{
Trond Myklebust2446ab62012-03-01 17:00:56 -05001510 size_t ret;
1511
1512 rcu_read_lock();
1513 ret = rcu_dereference(clnt->cl_xprt)->max_payload;
1514 rcu_read_unlock();
1515 return ret;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001516}
Chuck Leverb86acd52006-08-22 20:06:22 -04001517EXPORT_SYMBOL_GPL(rpc_max_payload);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001518
Chuck Lever35f5a422006-01-03 09:55:50 +01001519/**
Chuck Lever6b26cc82016-05-02 14:40:40 -04001520 * rpc_max_bc_payload - Get maximum backchannel payload size, in bytes
1521 * @clnt: RPC client to query
1522 */
1523size_t rpc_max_bc_payload(struct rpc_clnt *clnt)
1524{
1525 struct rpc_xprt *xprt;
1526 size_t ret;
1527
1528 rcu_read_lock();
1529 xprt = rcu_dereference(clnt->cl_xprt);
1530 ret = xprt->ops->bc_maxpayload(xprt);
1531 rcu_read_unlock();
1532 return ret;
1533}
1534EXPORT_SYMBOL_GPL(rpc_max_bc_payload);
1535
Trond Myklebust7402a4f2019-07-16 13:51:29 -04001536unsigned int rpc_num_bc_slots(struct rpc_clnt *clnt)
1537{
1538 struct rpc_xprt *xprt;
1539 unsigned int ret;
1540
1541 rcu_read_lock();
1542 xprt = rcu_dereference(clnt->cl_xprt);
1543 ret = xprt->ops->bc_num_slots(xprt);
1544 rcu_read_unlock();
1545 return ret;
1546}
1547EXPORT_SYMBOL_GPL(rpc_num_bc_slots);
1548
Chuck Lever6b26cc82016-05-02 14:40:40 -04001549/**
Chuck Lever35f5a422006-01-03 09:55:50 +01001550 * rpc_force_rebind - force transport to check that remote port is unchanged
1551 * @clnt: client to rebind
1552 *
1553 */
1554void rpc_force_rebind(struct rpc_clnt *clnt)
1555{
Trond Myklebust2446ab62012-03-01 17:00:56 -05001556 if (clnt->cl_autobind) {
1557 rcu_read_lock();
1558 xprt_clear_bound(rcu_dereference(clnt->cl_xprt));
1559 rcu_read_unlock();
1560 }
Chuck Lever35f5a422006-01-03 09:55:50 +01001561}
Chuck Leverb86acd52006-08-22 20:06:22 -04001562EXPORT_SYMBOL_GPL(rpc_force_rebind);
Chuck Lever35f5a422006-01-03 09:55:50 +01001563
Trond Myklebust9e6fa0b2019-04-07 13:58:45 -04001564static int
1565__rpc_restart_call(struct rpc_task *task, void (*action)(struct rpc_task *))
Andy Adamsonaae20062009-04-01 09:22:40 -04001566{
Trond Myklebust494314c2014-03-20 12:59:09 -04001567 task->tk_status = 0;
Trond Myklebust5ad64b32019-04-07 13:58:54 -04001568 task->tk_rpc_status = 0;
Trond Myklebust9e6fa0b2019-04-07 13:58:45 -04001569 task->tk_action = action;
Trond Myklebustf1f88fc2010-07-31 14:29:07 -04001570 return 1;
Andy Adamsonaae20062009-04-01 09:22:40 -04001571}
Andy Adamsonaae20062009-04-01 09:22:40 -04001572
1573/*
Linus Torvalds1da177e2005-04-16 15:20:36 -07001574 * Restart an (async) RPC call. Usually called from within the
1575 * exit handler.
1576 */
Trond Myklebustf1f88fc2010-07-31 14:29:07 -04001577int
Linus Torvalds1da177e2005-04-16 15:20:36 -07001578rpc_restart_call(struct rpc_task *task)
1579{
Trond Myklebust9e6fa0b2019-04-07 13:58:45 -04001580 return __rpc_restart_call(task, call_start);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001581}
Trond Myklebuste8914c62007-07-14 15:39:59 -04001582EXPORT_SYMBOL_GPL(rpc_restart_call);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001583
Trond Myklebust9e6fa0b2019-04-07 13:58:45 -04001584/*
1585 * Restart an (async) RPC call from the call_prepare state.
1586 * Usually called from within the exit handler.
1587 */
1588int
1589rpc_restart_call_prepare(struct rpc_task *task)
1590{
1591 if (task->tk_ops->rpc_call_prepare != NULL)
1592 return __rpc_restart_call(task, rpc_prepare_task);
1593 return rpc_restart_call(task);
1594}
1595EXPORT_SYMBOL_GPL(rpc_restart_call_prepare);
1596
Jeff Laytonb4b9d2c2014-11-26 14:44:43 -05001597const char
1598*rpc_proc_name(const struct rpc_task *task)
Chuck Lever3748f1e2008-05-21 17:09:12 -04001599{
1600 const struct rpc_procinfo *proc = task->tk_msg.rpc_proc;
1601
1602 if (proc) {
1603 if (proc->p_name)
1604 return proc->p_name;
1605 else
1606 return "NULL";
1607 } else
1608 return "no proc";
1609}
Chuck Lever3748f1e2008-05-21 17:09:12 -04001610
Trond Myklebust5ad64b32019-04-07 13:58:54 -04001611static void
1612__rpc_call_rpcerror(struct rpc_task *task, int tk_status, int rpc_status)
1613{
1614 task->tk_rpc_status = rpc_status;
1615 rpc_exit(task, tk_status);
1616}
1617
1618static void
1619rpc_call_rpcerror(struct rpc_task *task, int status)
1620{
1621 __rpc_call_rpcerror(task, status, status);
1622}
1623
Linus Torvalds1da177e2005-04-16 15:20:36 -07001624/*
1625 * 0. Initial state
1626 *
1627 * Other FSM states can be visited zero or more times, but
1628 * this state is visited exactly once for each RPC.
1629 */
1630static void
1631call_start(struct rpc_task *task)
1632{
1633 struct rpc_clnt *clnt = task->tk_client;
Christoph Hellwig1c5876d2017-05-08 23:27:10 +02001634 int idx = task->tk_msg.rpc_proc->p_statidx;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001635
Chuck Leverc435da62017-11-03 13:46:14 -04001636 trace_rpc_request(task);
Chuck Lever3748f1e2008-05-21 17:09:12 -04001637 dprintk("RPC: %5u call_start %s%d proc %s (%s)\n", task->tk_pid,
Trond Myklebust55909f22013-08-23 11:48:15 -04001638 clnt->cl_program->name, clnt->cl_vers,
Chuck Lever3748f1e2008-05-21 17:09:12 -04001639 rpc_proc_name(task),
Chuck Lever46121cf2007-01-31 12:14:08 -05001640 (RPC_IS_ASYNC(task) ? "async" : "sync"));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001641
Christoph Hellwig1c5876d2017-05-08 23:27:10 +02001642 /* 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]++;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001645 clnt->cl_stats->rpccnt++;
1646 task->tk_action = call_reserve;
Bill Baker0f90be12018-06-19 16:24:58 -05001647 rpc_task_set_transport(task, clnt);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001648}
1649
1650/*
1651 * 1. Reserve an RPC call slot
1652 */
1653static void
1654call_reserve(struct rpc_task *task)
1655{
Chuck Lever46121cf2007-01-31 12:14:08 -05001656 dprint_status(task);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001657
Linus Torvalds1da177e2005-04-16 15:20:36 -07001658 task->tk_status = 0;
1659 task->tk_action = call_reserveresult;
1660 xprt_reserve(task);
1661}
1662
Trond Myklebustba60eb22013-04-14 10:49:37 -04001663static void call_retry_reserve(struct rpc_task *task);
1664
Linus Torvalds1da177e2005-04-16 15:20:36 -07001665/*
1666 * 1b. Grok the result of xprt_reserve()
1667 */
1668static void
1669call_reserveresult(struct rpc_task *task)
1670{
1671 int status = task->tk_status;
1672
Chuck Lever46121cf2007-01-31 12:14:08 -05001673 dprint_status(task);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001674
1675 /*
1676 * After a call to xprt_reserve(), we must have either
1677 * a request slot or else an error status.
1678 */
1679 task->tk_status = 0;
1680 if (status >= 0) {
1681 if (task->tk_rqstp) {
J. Bruce Fieldsf2d47d02010-09-12 19:55:25 -04001682 task->tk_action = call_refresh;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001683 return;
1684 }
1685
Trond Myklebust5ad64b32019-04-07 13:58:54 -04001686 rpc_call_rpcerror(task, -EIO);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001687 return;
1688 }
1689
1690 /*
1691 * Even though there was an error, we may have acquired
1692 * a request slot somehow. Make sure not to leak it.
1693 */
Chuck Lever5cd8b0d2019-10-09 12:58:08 -04001694 if (task->tk_rqstp)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001695 xprt_release(task);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001696
1697 switch (status) {
Trond Myklebust1afeaf52012-05-19 12:12:53 -04001698 case -ENOMEM:
1699 rpc_delay(task, HZ >> 2);
Gustavo A. R. Silvae9d47632017-10-20 11:48:30 -05001700 /* fall through */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001701 case -EAGAIN: /* woken up; retry */
Trond Myklebustba60eb22013-04-14 10:49:37 -04001702 task->tk_action = call_retry_reserve;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001703 return;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001704 default:
Chuck Lever5cd8b0d2019-10-09 12:58:08 -04001705 rpc_call_rpcerror(task, status);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001706 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001707}
1708
1709/*
Trond Myklebustba60eb22013-04-14 10:49:37 -04001710 * 1c. Retry reserving an RPC call slot
1711 */
1712static void
1713call_retry_reserve(struct rpc_task *task)
1714{
1715 dprint_status(task);
1716
1717 task->tk_status = 0;
1718 task->tk_action = call_reserveresult;
1719 xprt_retry_reserve(task);
1720}
1721
1722/*
J. Bruce Fields55576242010-09-12 19:55:25 -04001723 * 2. Bind and/or refresh the credentials
1724 */
1725static void
1726call_refresh(struct rpc_task *task)
1727{
1728 dprint_status(task);
1729
1730 task->tk_action = call_refreshresult;
1731 task->tk_status = 0;
1732 task->tk_client->cl_stats->rpcauthrefresh++;
1733 rpcauth_refreshcred(task);
1734}
1735
1736/*
1737 * 2a. Process the results of a credential refresh
1738 */
1739static void
1740call_refreshresult(struct rpc_task *task)
1741{
1742 int status = task->tk_status;
1743
1744 dprint_status(task);
1745
1746 task->tk_status = 0;
Trond Myklebust5fc43972010-11-20 11:13:31 -05001747 task->tk_action = call_refresh;
J. Bruce Fields55576242010-09-12 19:55:25 -04001748 switch (status) {
Trond Myklebust5fc43972010-11-20 11:13:31 -05001749 case 0:
Weston Andros Adamson6ff33b72013-12-17 12:16:11 -05001750 if (rpcauth_uptodatecred(task)) {
Trond Myklebust5fc43972010-11-20 11:13:31 -05001751 task->tk_action = call_allocate;
Weston Andros Adamson6ff33b72013-12-17 12:16:11 -05001752 return;
1753 }
1754 /* Use rate-limiting and a max number of retries if refresh
1755 * had status 0 but failed to update the cred.
1756 */
Gustavo A. R. Silvae9d47632017-10-20 11:48:30 -05001757 /* fall through */
J. Bruce Fields55576242010-09-12 19:55:25 -04001758 case -ETIMEDOUT:
1759 rpc_delay(task, 3*HZ);
Gustavo A. R. Silvae9d47632017-10-20 11:48:30 -05001760 /* fall through */
Trond Myklebust5fc43972010-11-20 11:13:31 -05001761 case -EAGAIN:
1762 status = -EACCES;
Gustavo A. R. Silvae9d47632017-10-20 11:48:30 -05001763 /* fall through */
Andy Adamsonf1ff0c22013-08-14 11:59:13 -04001764 case -EKEYEXPIRED:
Trond Myklebust5fc43972010-11-20 11:13:31 -05001765 if (!task->tk_cred_retry)
1766 break;
1767 task->tk_cred_retry--;
1768 dprintk("RPC: %5u %s: retry refresh creds\n",
1769 task->tk_pid, __func__);
1770 return;
J. Bruce Fields55576242010-09-12 19:55:25 -04001771 }
Trond Myklebust5fc43972010-11-20 11:13:31 -05001772 dprintk("RPC: %5u %s: refresh creds failed with error %d\n",
1773 task->tk_pid, __func__, status);
Trond Myklebust5ad64b32019-04-07 13:58:54 -04001774 rpc_call_rpcerror(task, status);
J. Bruce Fields55576242010-09-12 19:55:25 -04001775}
1776
1777/*
1778 * 2b. Allocate the buffer. For details, see sched.c:rpc_malloc.
Chuck Lever02107142006-01-03 09:55:49 +01001779 * (Note: buffer memory is freed in xprt_release).
Linus Torvalds1da177e2005-04-16 15:20:36 -07001780 */
1781static void
1782call_allocate(struct rpc_task *task)
1783{
Chuck Lever2c94b8e2019-02-11 11:25:41 -05001784 const struct rpc_auth *auth = task->tk_rqstp->rq_cred->cr_auth;
Chuck Lever02107142006-01-03 09:55:49 +01001785 struct rpc_rqst *req = task->tk_rqstp;
Trond Myklebusta4f08352013-01-08 09:10:21 -05001786 struct rpc_xprt *xprt = req->rq_xprt;
Christoph Hellwig499b4982017-05-12 15:36:49 +02001787 const struct rpc_procinfo *proc = task->tk_msg.rpc_proc;
Chuck Lever5fe6eaa2016-09-15 10:55:20 -04001788 int status;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001789
Chuck Lever46121cf2007-01-31 12:14:08 -05001790 dprint_status(task);
1791
Chuck Lever2bea90d2007-03-29 16:47:53 -04001792 task->tk_status = 0;
Trond Myklebust762e4e62018-08-24 16:28:28 -04001793 task->tk_action = call_encode;
Chuck Lever2bea90d2007-03-29 16:47:53 -04001794
Trond Myklebustaf6b61d2019-04-11 15:16:52 -04001795 if (req->rq_buffer)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001796 return;
1797
Chuck Lever2bea90d2007-03-29 16:47:53 -04001798 if (proc->p_proc != 0) {
1799 BUG_ON(proc->p_arglen == 0);
1800 if (proc->p_decode != NULL)
1801 BUG_ON(proc->p_replen == 0);
1802 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001803
Chuck Lever2bea90d2007-03-29 16:47:53 -04001804 /*
1805 * Calculate the size (in quads) of the RPC call
1806 * and reply headers, and convert both values
1807 * to byte sizes.
1808 */
Chuck Lever2c94b8e2019-02-11 11:25:41 -05001809 req->rq_callsize = RPC_CALLHDRSIZE + (auth->au_cslack << 1) +
1810 proc->p_arglen;
Chuck Lever2bea90d2007-03-29 16:47:53 -04001811 req->rq_callsize <<= 2;
Trond Myklebust51314962019-03-15 12:55:59 -04001812 /*
1813 * Note: the reply buffer must at minimum allocate enough space
1814 * for the 'struct accepted_reply' from RFC5531.
1815 */
1816 req->rq_rcvsize = RPC_REPHDRSIZE + auth->au_rslack + \
1817 max_t(size_t, proc->p_replen, 2);
Chuck Lever2bea90d2007-03-29 16:47:53 -04001818 req->rq_rcvsize <<= 2;
1819
Chuck Lever5fe6eaa2016-09-15 10:55:20 -04001820 status = xprt->ops->buf_alloc(task);
Chuck Lever4a068252015-05-11 14:02:25 -04001821 xprt_inject_disconnect(xprt);
Trond Myklebustaf6b61d2019-04-11 15:16:52 -04001822 if (status == 0)
Chuck Lever5fe6eaa2016-09-15 10:55:20 -04001823 return;
1824 if (status != -ENOMEM) {
Trond Myklebust5ad64b32019-04-07 13:58:54 -04001825 rpc_call_rpcerror(task, status);
Chuck Lever5fe6eaa2016-09-15 10:55:20 -04001826 return;
1827 }
Chuck Lever46121cf2007-01-31 12:14:08 -05001828
1829 dprintk("RPC: %5u rpc_buffer allocation failed\n", task->tk_pid);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001830
Trond Myklebust5afa91332011-06-17 10:14:59 -04001831 if (RPC_IS_ASYNC(task) || !fatal_signal_pending(current)) {
Trond Myklebustb6e9c712007-10-01 12:06:44 -04001832 task->tk_action = call_allocate;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001833 rpc_delay(task, HZ>>4);
1834 return;
1835 }
1836
Trond Myklebust714fbc72019-09-12 08:06:51 -04001837 rpc_call_rpcerror(task, -ERESTARTSYS);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001838}
1839
Trond Myklebust7ebbbc62018-08-28 09:00:27 -04001840static int
Trond Myklebust940e3312005-11-09 21:45:24 -05001841rpc_task_need_encode(struct rpc_task *task)
1842{
Trond Myklebust762e4e62018-08-24 16:28:28 -04001843 return test_bit(RPC_TASK_NEED_XMIT, &task->tk_runstate) == 0 &&
1844 (!(task->tk_flags & RPC_TASK_SENT) ||
1845 !(task->tk_flags & RPC_TASK_NO_RETRANS_TIMEOUT) ||
1846 xprt_request_need_retransmit(task));
Trond Myklebust940e3312005-11-09 21:45:24 -05001847}
1848
Linus Torvalds1da177e2005-04-16 15:20:36 -07001849static void
Chuck Leverb0e1c572008-05-21 17:09:19 -04001850rpc_xdr_encode(struct rpc_task *task)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001851{
Linus Torvalds1da177e2005-04-16 15:20:36 -07001852 struct rpc_rqst *req = task->tk_rqstp;
Chuck Levere8680a22019-02-11 11:24:48 -05001853 struct xdr_stream xdr;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001854
Chuck Leverb9c5bc02016-09-15 10:55:12 -04001855 xdr_buf_init(&req->rq_snd_buf,
1856 req->rq_buffer,
1857 req->rq_callsize);
1858 xdr_buf_init(&req->rq_rcv_buf,
Chuck Lever68778942016-09-15 10:55:37 -04001859 req->rq_rbuffer,
Chuck Leverb9c5bc02016-09-15 10:55:12 -04001860 req->rq_rcvsize);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001861
Trond Myklebustcc204d02019-09-10 13:01:35 -04001862 req->rq_reply_bytes_recvd = 0;
Chuck Levere8680a22019-02-11 11:24:48 -05001863 req->rq_snd_buf.head[0].iov_len = 0;
1864 xdr_init_encode(&xdr, &req->rq_snd_buf,
1865 req->rq_snd_buf.head[0].iov_base, req);
Trond Myklebust75369082019-07-17 21:22:38 -04001866 xdr_free_bvec(&req->rq_snd_buf);
Chuck Levere8680a22019-02-11 11:24:48 -05001867 if (rpc_encode_header(task, &xdr))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001868 return;
Chuck Leverb0e1c572008-05-21 17:09:19 -04001869
Chuck Levere8680a22019-02-11 11:24:48 -05001870 task->tk_status = rpcauth_wrap_req(task, &xdr);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001871}
1872
1873/*
Trond Myklebust762e4e62018-08-24 16:28:28 -04001874 * 3. Encode arguments of an RPC call
1875 */
1876static void
1877call_encode(struct rpc_task *task)
1878{
1879 if (!rpc_task_need_encode(task))
1880 goto out;
Chuck Levere8680a22019-02-11 11:24:48 -05001881 dprint_status(task);
Trond Myklebustcc204d02019-09-10 13:01:35 -04001882 /* Dequeue task from the receive queue while we're encoding */
1883 xprt_request_dequeue_xprt(task);
Trond Myklebust762e4e62018-08-24 16:28:28 -04001884 /* Encode here so that rpcsec_gss can use correct sequence number. */
1885 rpc_xdr_encode(task);
1886 /* Did the encode result in an error condition? */
1887 if (task->tk_status != 0) {
1888 /* Was the error nonfatal? */
Trond Myklebust97b78ae2019-01-02 17:53:13 -05001889 switch (task->tk_status) {
1890 case -EAGAIN:
1891 case -ENOMEM:
Trond Myklebust762e4e62018-08-24 16:28:28 -04001892 rpc_delay(task, HZ >> 4);
Trond Myklebust97b78ae2019-01-02 17:53:13 -05001893 break;
1894 case -EKEYEXPIRED:
ZhangXiaoxu9c5948c2019-04-29 17:32:31 +08001895 if (!task->tk_cred_retry) {
1896 rpc_exit(task, task->tk_status);
1897 } else {
1898 task->tk_action = call_refresh;
1899 task->tk_cred_retry--;
1900 dprintk("RPC: %5u %s: retry refresh creds\n",
1901 task->tk_pid, __func__);
1902 }
Trond Myklebust97b78ae2019-01-02 17:53:13 -05001903 break;
1904 default:
Trond Myklebust5ad64b32019-04-07 13:58:54 -04001905 rpc_call_rpcerror(task, task->tk_status);
Trond Myklebust97b78ae2019-01-02 17:53:13 -05001906 }
Trond Myklebust762e4e62018-08-24 16:28:28 -04001907 return;
1908 }
1909
1910 /* Add task to reply queue before transmission to avoid races */
1911 if (rpc_reply_expected(task))
1912 xprt_request_enqueue_receive(task);
1913 xprt_request_enqueue_transmit(task);
1914out:
Trond Myklebustaf6b61d2019-04-11 15:16:52 -04001915 task->tk_action = call_transmit;
1916 /* Check that the connection is OK */
1917 if (!xprt_bound(task->tk_xprt))
1918 task->tk_action = call_bind;
1919 else if (!xprt_connected(task->tk_xprt))
1920 task->tk_action = call_connect;
Trond Myklebust762e4e62018-08-24 16:28:28 -04001921}
1922
1923/*
Trond Myklebust03e51d32019-03-10 11:17:13 -04001924 * Helpers to check if the task was already transmitted, and
1925 * to take action when that is the case.
1926 */
1927static bool
1928rpc_task_transmitted(struct rpc_task *task)
1929{
1930 return !test_bit(RPC_TASK_NEED_XMIT, &task->tk_runstate);
1931}
1932
1933static void
1934rpc_task_handle_transmitted(struct rpc_task *task)
1935{
1936 xprt_end_transmit(task);
1937 task->tk_action = call_transmit_status;
Trond Myklebust03e51d32019-03-10 11:17:13 -04001938}
1939
1940/*
Linus Torvalds1da177e2005-04-16 15:20:36 -07001941 * 4. Get the server port number if not yet set
1942 */
1943static void
1944call_bind(struct rpc_task *task)
1945{
Trond Myklebustad2368d2013-01-08 10:08:33 -05001946 struct rpc_xprt *xprt = task->tk_rqstp->rq_xprt;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001947
Trond Myklebust03e51d32019-03-10 11:17:13 -04001948 if (rpc_task_transmitted(task)) {
1949 rpc_task_handle_transmitted(task);
1950 return;
1951 }
1952
Trond Myklebust009a82f2019-03-09 12:07:17 -05001953 if (xprt_bound(xprt)) {
1954 task->tk_action = call_connect;
Trond Myklebust009a82f2019-03-09 12:07:17 -05001955 return;
1956 }
1957
Chuck Lever46121cf2007-01-31 12:14:08 -05001958 dprint_status(task);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001959
Trond Myklebust009a82f2019-03-09 12:07:17 -05001960 task->tk_action = call_bind_status;
Trond Myklebust4d6c6712019-03-10 12:22:39 -04001961 if (!xprt_prepare_transmit(task))
1962 return;
1963
Trond Myklebust009a82f2019-03-09 12:07:17 -05001964 xprt->ops->rpcbind(task);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001965}
1966
1967/*
Chuck Leverda351872005-08-11 16:25:11 -04001968 * 4a. Sort out bind result
1969 */
1970static void
1971call_bind_status(struct rpc_task *task)
1972{
Trond Myklebustbd736ed2019-08-15 17:26:17 -04001973 struct rpc_xprt *xprt = task->tk_rqstp->rq_xprt;
Chuck Lever906462a2007-09-11 18:00:47 -04001974 int status = -EIO;
Chuck Leverda351872005-08-11 16:25:11 -04001975
Trond Myklebust03e51d32019-03-10 11:17:13 -04001976 if (rpc_task_transmitted(task)) {
1977 rpc_task_handle_transmitted(task);
1978 return;
1979 }
1980
Trond Myklebustbd736ed2019-08-15 17:26:17 -04001981 dprint_status(task);
1982 trace_rpc_bind_status(task);
1983 if (task->tk_status >= 0)
1984 goto out_next;
1985 if (xprt_bound(xprt)) {
Chuck Leverda351872005-08-11 16:25:11 -04001986 task->tk_status = 0;
Trond Myklebustbd736ed2019-08-15 17:26:17 -04001987 goto out_next;
Chuck Leverda351872005-08-11 16:25:11 -04001988 }
1989
1990 switch (task->tk_status) {
Trond Myklebust381ba742008-07-07 12:18:53 -04001991 case -ENOMEM:
1992 dprintk("RPC: %5u rpcbind out of memory\n", task->tk_pid);
1993 rpc_delay(task, HZ >> 2);
Chuck Lever2429cbf2007-09-11 18:00:41 -04001994 goto retry_timeout;
Chuck Leverda351872005-08-11 16:25:11 -04001995 case -EACCES:
Chuck Lever46121cf2007-01-31 12:14:08 -05001996 dprintk("RPC: %5u remote rpcbind: RPC program/version "
1997 "unavailable\n", task->tk_pid);
Chuck Leverb79dc8c2007-09-11 18:00:52 -04001998 /* fail immediately if this is an RPC ping */
1999 if (task->tk_msg.rpc_proc->p_proc == 0) {
2000 status = -EOPNOTSUPP;
2001 break;
2002 }
Trond Myklebust0b760112011-05-31 15:15:34 -04002003 if (task->tk_rebind_retry == 0)
2004 break;
2005 task->tk_rebind_retry--;
Chuck Leverea635a52005-10-06 23:12:58 -04002006 rpc_delay(task, 3*HZ);
Trond Myklebustda45828e2006-08-31 15:44:52 -04002007 goto retry_timeout;
Trond Myklebust80f455d2019-08-15 22:55:19 -04002008 case -ENOBUFS:
2009 rpc_delay(task, HZ >> 2);
2010 goto retry_timeout;
Trond Myklebust4d6c6712019-03-10 12:22:39 -04002011 case -EAGAIN:
2012 goto retry_timeout;
Chuck Leverda351872005-08-11 16:25:11 -04002013 case -ETIMEDOUT:
Chuck Lever46121cf2007-01-31 12:14:08 -05002014 dprintk("RPC: %5u rpcbind request timed out\n",
Chuck Leverda351872005-08-11 16:25:11 -04002015 task->tk_pid);
Trond Myklebustda45828e2006-08-31 15:44:52 -04002016 goto retry_timeout;
Chuck Leverda351872005-08-11 16:25:11 -04002017 case -EPFNOSUPPORT:
Chuck Lever906462a2007-09-11 18:00:47 -04002018 /* server doesn't support any rpcbind version we know of */
Chuck Lever012da1582009-12-03 15:58:56 -05002019 dprintk("RPC: %5u unrecognized remote rpcbind service\n",
Chuck Leverda351872005-08-11 16:25:11 -04002020 task->tk_pid);
2021 break;
2022 case -EPROTONOSUPPORT:
Chuck Lever00a6e7b2007-03-29 16:48:33 -04002023 dprintk("RPC: %5u remote rpcbind version unavailable, retrying\n",
Chuck Leverda351872005-08-11 16:25:11 -04002024 task->tk_pid);
Trond Myklebustfdb63dc2014-03-17 12:57:31 -04002025 goto retry_timeout;
Chuck Lever012da1582009-12-03 15:58:56 -05002026 case -ECONNREFUSED: /* connection problems */
2027 case -ECONNRESET:
Trond Myklebustdf277272013-12-31 13:11:43 -05002028 case -ECONNABORTED:
Chuck Lever012da1582009-12-03 15:58:56 -05002029 case -ENOTCONN:
2030 case -EHOSTDOWN:
Trond Myklebusteb5b46f2017-11-30 07:21:33 -05002031 case -ENETDOWN:
Chuck Lever012da1582009-12-03 15:58:56 -05002032 case -EHOSTUNREACH:
2033 case -ENETUNREACH:
2034 case -EPIPE:
2035 dprintk("RPC: %5u remote rpcbind unreachable: %d\n",
2036 task->tk_pid, task->tk_status);
2037 if (!RPC_IS_SOFTCONN(task)) {
2038 rpc_delay(task, 5*HZ);
2039 goto retry_timeout;
2040 }
2041 status = task->tk_status;
2042 break;
Chuck Leverda351872005-08-11 16:25:11 -04002043 default:
Chuck Lever46121cf2007-01-31 12:14:08 -05002044 dprintk("RPC: %5u unrecognized rpcbind error (%d)\n",
Chuck Leverda351872005-08-11 16:25:11 -04002045 task->tk_pid, -task->tk_status);
Chuck Leverda351872005-08-11 16:25:11 -04002046 }
2047
Trond Myklebust5ad64b32019-04-07 13:58:54 -04002048 rpc_call_rpcerror(task, status);
Chuck Leverda351872005-08-11 16:25:11 -04002049 return;
Trond Myklebustbd736ed2019-08-15 17:26:17 -04002050out_next:
2051 task->tk_action = call_connect;
2052 return;
Trond Myklebustda45828e2006-08-31 15:44:52 -04002053retry_timeout:
Trond Myklebustfdb63dc2014-03-17 12:57:31 -04002054 task->tk_status = 0;
Trond Myklebust4d6c6712019-03-10 12:22:39 -04002055 task->tk_action = call_bind;
Trond Myklebustcea57782019-03-09 16:06:47 -05002056 rpc_check_timeout(task);
Chuck Leverda351872005-08-11 16:25:11 -04002057}
2058
2059/*
2060 * 4b. Connect to the RPC server
Linus Torvalds1da177e2005-04-16 15:20:36 -07002061 */
2062static void
2063call_connect(struct rpc_task *task)
2064{
Trond Myklebustad2368d2013-01-08 10:08:33 -05002065 struct rpc_xprt *xprt = task->tk_rqstp->rq_xprt;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002066
Trond Myklebust03e51d32019-03-10 11:17:13 -04002067 if (rpc_task_transmitted(task)) {
2068 rpc_task_handle_transmitted(task);
2069 return;
2070 }
2071
Trond Myklebust009a82f2019-03-09 12:07:17 -05002072 if (xprt_connected(xprt)) {
2073 task->tk_action = call_transmit;
Trond Myklebust009a82f2019-03-09 12:07:17 -05002074 return;
2075 }
2076
Chuck Lever46121cf2007-01-31 12:14:08 -05002077 dprintk("RPC: %5u call_connect xprt %p %s connected\n",
Chuck Leverda351872005-08-11 16:25:11 -04002078 task->tk_pid, xprt,
2079 (xprt_connected(xprt) ? "is" : "is not"));
Linus Torvalds1da177e2005-04-16 15:20:36 -07002080
Trond Myklebust009a82f2019-03-09 12:07:17 -05002081 task->tk_action = call_connect_status;
2082 if (task->tk_status < 0)
2083 return;
2084 if (task->tk_flags & RPC_TASK_NOCONNECT) {
Trond Myklebust5ad64b32019-04-07 13:58:54 -04002085 rpc_call_rpcerror(task, -ENOTCONN);
Trond Myklebust009a82f2019-03-09 12:07:17 -05002086 return;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002087 }
Trond Myklebust4d6c6712019-03-10 12:22:39 -04002088 if (!xprt_prepare_transmit(task))
2089 return;
Trond Myklebust009a82f2019-03-09 12:07:17 -05002090 xprt_connect(task);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002091}
2092
2093/*
Chuck Leverda351872005-08-11 16:25:11 -04002094 * 4c. Sort out connect result
Linus Torvalds1da177e2005-04-16 15:20:36 -07002095 */
2096static void
2097call_connect_status(struct rpc_task *task)
2098{
Trond Myklebustbd736ed2019-08-15 17:26:17 -04002099 struct rpc_xprt *xprt = task->tk_rqstp->rq_xprt;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002100 struct rpc_clnt *clnt = task->tk_client;
2101 int status = task->tk_status;
2102
Trond Myklebust03e51d32019-03-10 11:17:13 -04002103 if (rpc_task_transmitted(task)) {
2104 rpc_task_handle_transmitted(task);
Trond Myklebust9bd11522018-11-30 12:48:47 -05002105 return;
2106 }
2107
Chuck Lever46121cf2007-01-31 12:14:08 -05002108 dprint_status(task);
Chuck Levere671edb2018-03-16 10:33:44 -04002109 trace_rpc_connect_status(task);
Trond Myklebustbd736ed2019-08-15 17:26:17 -04002110
2111 if (task->tk_status == 0) {
2112 clnt->cl_stats->netreconn++;
2113 goto out_next;
2114 }
2115 if (xprt_connected(xprt)) {
2116 task->tk_status = 0;
2117 goto out_next;
2118 }
2119
Trond Myklebust561ec162013-09-26 15:22:45 -04002120 task->tk_status = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002121 switch (status) {
Trond Myklebust3ed5e2a2013-03-04 17:29:33 -05002122 case -ECONNREFUSED:
NeilBrownfd01b252017-08-18 17:12:51 +10002123 /* A positive refusal suggests a rebind is needed. */
2124 if (RPC_IS_SOFTCONN(task))
2125 break;
2126 if (clnt->cl_autobind) {
2127 rpc_force_rebind(clnt);
Trond Myklebust7b3fef82019-03-07 14:10:32 -05002128 goto out_retry;
NeilBrownfd01b252017-08-18 17:12:51 +10002129 }
Gustavo A. R. Silvae9d47632017-10-20 11:48:30 -05002130 /* fall through */
Trond Myklebust3ed5e2a2013-03-04 17:29:33 -05002131 case -ECONNRESET:
Trond Myklebustdf277272013-12-31 13:11:43 -05002132 case -ECONNABORTED:
Trond Myklebusteb5b46f2017-11-30 07:21:33 -05002133 case -ENETDOWN:
Trond Myklebust3ed5e2a2013-03-04 17:29:33 -05002134 case -ENETUNREACH:
Trond Myklebustdf277272013-12-31 13:11:43 -05002135 case -EHOSTUNREACH:
Trond Myklebust2fc193c2014-07-03 00:02:57 -04002136 case -EPIPE:
Chuck Leverb8457602019-12-23 10:28:44 -05002137 case -EPROTO:
NeilBrown2c2ee6d2016-11-23 14:44:58 +11002138 xprt_conditional_disconnect(task->tk_rqstp->rq_xprt,
2139 task->tk_rqstp->rq_connect_cookie);
Trond Myklebust3ed5e2a2013-03-04 17:29:33 -05002140 if (RPC_IS_SOFTCONN(task))
2141 break;
Steve Dickson1fa3e2e2014-03-20 11:23:03 -04002142 /* retry with existing socket, after a delay */
2143 rpc_delay(task, 3*HZ);
Gustavo A. R. Silvae9d47632017-10-20 11:48:30 -05002144 /* fall through */
Trond Myklebust80f455d2019-08-15 22:55:19 -04002145 case -EADDRINUSE:
Trond Myklebust0445f922018-12-17 13:34:59 -05002146 case -ENOTCONN:
Trond Myklebust3ed5e2a2013-03-04 17:29:33 -05002147 case -EAGAIN:
Trond Myklebust485f2252014-03-17 12:51:44 -04002148 case -ETIMEDOUT:
Trond Myklebust7b3fef82019-03-07 14:10:32 -05002149 goto out_retry;
Trond Myklebust80f455d2019-08-15 22:55:19 -04002150 case -ENOBUFS:
2151 rpc_delay(task, HZ >> 2);
2152 goto out_retry;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002153 }
Trond Myklebust5ad64b32019-04-07 13:58:54 -04002154 rpc_call_rpcerror(task, status);
Trond Myklebust7b3fef82019-03-07 14:10:32 -05002155 return;
Trond Myklebustbd736ed2019-08-15 17:26:17 -04002156out_next:
2157 task->tk_action = call_transmit;
2158 return;
Trond Myklebust7b3fef82019-03-07 14:10:32 -05002159out_retry:
2160 /* Check for timeouts before looping back to call_bind */
2161 task->tk_action = call_bind;
2162 rpc_check_timeout(task);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002163}
2164
2165/*
2166 * 5. Transmit the RPC request, and wait for reply
2167 */
2168static void
2169call_transmit(struct rpc_task *task)
2170{
Trond Myklebust03e51d32019-03-10 11:17:13 -04002171 if (rpc_task_transmitted(task)) {
2172 rpc_task_handle_transmitted(task);
2173 return;
2174 }
2175
Chuck Lever46121cf2007-01-31 12:14:08 -05002176 dprint_status(task);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002177
Trond Myklebusted7dc972019-03-04 14:19:31 -05002178 task->tk_action = call_transmit_status;
Trond Myklebust009a82f2019-03-09 12:07:17 -05002179 if (!xprt_prepare_transmit(task))
2180 return;
2181 task->tk_status = 0;
Trond Myklebustc5445772018-09-03 23:39:27 -04002182 if (test_bit(RPC_TASK_NEED_XMIT, &task->tk_runstate)) {
Trond Myklebust009a82f2019-03-09 12:07:17 -05002183 if (!xprt_connected(task->tk_xprt)) {
2184 task->tk_status = -ENOTCONN;
Trond Myklebustc5445772018-09-03 23:39:27 -04002185 return;
Trond Myklebusted7dc972019-03-04 14:19:31 -05002186 }
Trond Myklebust009a82f2019-03-09 12:07:17 -05002187 xprt_transmit(task);
Trond Myklebustc5445772018-09-03 23:39:27 -04002188 }
Trond Myklebustc5445772018-09-03 23:39:27 -04002189 xprt_end_transmit(task);
Trond Myklebuste0ab53d2006-07-27 17:22:50 -04002190}
2191
2192/*
2193 * 5a. Handle cleanup after a transmission
2194 */
2195static void
2196call_transmit_status(struct rpc_task *task)
2197{
2198 task->tk_action = call_status;
Chuck Lever206a1342009-12-03 15:58:56 -05002199
2200 /*
2201 * Common case: success. Force the compiler to put this
2202 * test first.
2203 */
Trond Myklebust009a82f2019-03-09 12:07:17 -05002204 if (rpc_task_transmitted(task)) {
Trond Myklebusta7b1a482019-04-15 11:54:13 -04002205 task->tk_status = 0;
2206 xprt_request_wait_receive(task);
Chuck Lever206a1342009-12-03 15:58:56 -05002207 return;
2208 }
2209
Trond Myklebust15f081c2009-03-11 14:37:57 -04002210 switch (task->tk_status) {
Trond Myklebust15f081c2009-03-11 14:37:57 -04002211 default:
Chuck Lever206a1342009-12-03 15:58:56 -05002212 dprint_status(task);
Trond Myklebust75891f52018-09-03 17:37:36 -04002213 break;
Trond Myklebust78b576c2018-08-28 09:20:10 -04002214 case -EBADMSG:
Trond Myklebust762e4e62018-08-24 16:28:28 -04002215 task->tk_status = 0;
2216 task->tk_action = call_encode;
Trond Myklebust78b576c2018-08-28 09:20:10 -04002217 break;
Trond Myklebust15f081c2009-03-11 14:37:57 -04002218 /*
2219 * Special cases: if we've been waiting on the
2220 * socket's write_space() callback, or if the
2221 * socket just returned a connection error,
2222 * then hold onto the transport lock.
2223 */
Trond Myklebust78b576c2018-08-28 09:20:10 -04002224 case -ENOBUFS:
2225 rpc_delay(task, HZ>>2);
2226 /* fall through */
Trond Myklebustc5445772018-09-03 23:39:27 -04002227 case -EBADSLT:
Trond Myklebust78b576c2018-08-28 09:20:10 -04002228 case -EAGAIN:
2229 task->tk_action = call_transmit;
2230 task->tk_status = 0;
2231 break;
Trond Myklebust15f081c2009-03-11 14:37:57 -04002232 case -ECONNREFUSED:
Trond Myklebust15f081c2009-03-11 14:37:57 -04002233 case -EHOSTDOWN:
Trond Myklebusteb5b46f2017-11-30 07:21:33 -05002234 case -ENETDOWN:
Trond Myklebust15f081c2009-03-11 14:37:57 -04002235 case -EHOSTUNREACH:
2236 case -ENETUNREACH:
Jason Baron3dedbb52014-09-24 18:08:04 +00002237 case -EPERM:
Chuck Lever09a21c42009-12-03 15:58:56 -05002238 if (RPC_IS_SOFTCONN(task)) {
Chuck Levera25a4cb2018-03-16 10:33:55 -04002239 if (!task->tk_msg.rpc_proc->p_proc)
2240 trace_xprt_ping(task->tk_xprt,
2241 task->tk_status);
Trond Myklebust5ad64b32019-04-07 13:58:54 -04002242 rpc_call_rpcerror(task, task->tk_status);
Trond Myklebust7b3fef82019-03-07 14:10:32 -05002243 return;
Chuck Lever09a21c42009-12-03 15:58:56 -05002244 }
Gustavo A. R. Silvae9d47632017-10-20 11:48:30 -05002245 /* fall through */
Chuck Lever09a21c42009-12-03 15:58:56 -05002246 case -ECONNRESET:
Trond Myklebustdf277272013-12-31 13:11:43 -05002247 case -ECONNABORTED:
Trond Myklebust3913c782015-02-08 21:44:04 -05002248 case -EADDRINUSE:
Chuck Lever09a21c42009-12-03 15:58:56 -05002249 case -ENOTCONN:
Trond Myklebustc8485e42009-03-11 14:37:59 -04002250 case -EPIPE:
Trond Myklebusted7dc972019-03-04 14:19:31 -05002251 task->tk_action = call_bind;
2252 task->tk_status = 0;
Trond Myklebust7ebbbc62018-08-28 09:00:27 -04002253 break;
Trond Myklebust15f081c2009-03-11 14:37:57 -04002254 }
Trond Myklebust7b3fef82019-03-07 14:10:32 -05002255 rpc_check_timeout(task);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002256}
2257
Trond Myklebust9e00abc2011-07-13 19:20:49 -04002258#if defined(CONFIG_SUNRPC_BACKCHANNEL)
Trond Myklebust477687e2019-03-05 07:30:48 -05002259static void call_bc_transmit(struct rpc_task *task);
2260static void call_bc_transmit_status(struct rpc_task *task);
2261
2262static void
2263call_bc_encode(struct rpc_task *task)
2264{
2265 xprt_request_enqueue_transmit(task);
2266 task->tk_action = call_bc_transmit;
2267}
2268
Ricardo Labiaga55ae1aa2009-04-01 09:23:03 -04002269/*
2270 * 5b. Send the backchannel RPC reply. On error, drop the reply. In
2271 * addition, disconnect on connectivity errors.
2272 */
2273static void
2274call_bc_transmit(struct rpc_task *task)
2275{
Trond Myklebust477687e2019-03-05 07:30:48 -05002276 task->tk_action = call_bc_transmit_status;
2277 if (test_bit(RPC_TASK_NEED_XMIT, &task->tk_runstate)) {
2278 if (!xprt_prepare_transmit(task))
2279 return;
2280 task->tk_status = 0;
2281 xprt_transmit(task);
2282 }
2283 xprt_end_transmit(task);
2284}
2285
2286static void
2287call_bc_transmit_status(struct rpc_task *task)
2288{
Ricardo Labiaga55ae1aa2009-04-01 09:23:03 -04002289 struct rpc_rqst *req = task->tk_rqstp;
2290
Trond Myklebusta7b1a482019-04-15 11:54:13 -04002291 if (rpc_task_transmitted(task))
2292 task->tk_status = 0;
2293
Ricardo Labiaga55ae1aa2009-04-01 09:23:03 -04002294 dprint_status(task);
Trond Myklebust477687e2019-03-05 07:30:48 -05002295
Ricardo Labiaga55ae1aa2009-04-01 09:23:03 -04002296 switch (task->tk_status) {
2297 case 0:
2298 /* Success */
Trond Myklebusteb5b46f2017-11-30 07:21:33 -05002299 case -ENETDOWN:
Ricardo Labiaga55ae1aa2009-04-01 09:23:03 -04002300 case -EHOSTDOWN:
2301 case -EHOSTUNREACH:
2302 case -ENETUNREACH:
Trond Myklebust38325912015-06-19 13:04:13 -04002303 case -ECONNRESET:
2304 case -ECONNREFUSED:
2305 case -EADDRINUSE:
2306 case -ENOTCONN:
2307 case -EPIPE:
2308 break;
Trond Myklebust477687e2019-03-05 07:30:48 -05002309 case -ENOBUFS:
2310 rpc_delay(task, HZ>>2);
2311 /* fall through */
2312 case -EBADSLT:
Trond Myklebustc5445772018-09-03 23:39:27 -04002313 case -EAGAIN:
Trond Myklebust477687e2019-03-05 07:30:48 -05002314 task->tk_status = 0;
2315 task->tk_action = call_bc_transmit;
2316 return;
Ricardo Labiaga55ae1aa2009-04-01 09:23:03 -04002317 case -ETIMEDOUT:
2318 /*
2319 * Problem reaching the server. Disconnect and let the
2320 * forechannel reestablish the connection. The server will
2321 * have to retransmit the backchannel request and we'll
2322 * reprocess it. Since these ops are idempotent, there's no
2323 * need to cache our reply at this time.
2324 */
2325 printk(KERN_NOTICE "RPC: Could not send backchannel reply "
2326 "error: %d\n", task->tk_status);
Trond Myklebusta4f08352013-01-08 09:10:21 -05002327 xprt_conditional_disconnect(req->rq_xprt,
Ricardo Labiaga55ae1aa2009-04-01 09:23:03 -04002328 req->rq_connect_cookie);
2329 break;
2330 default:
2331 /*
2332 * We were unable to reply and will have to drop the
2333 * request. The server should reconnect and retransmit.
2334 */
Ricardo Labiaga55ae1aa2009-04-01 09:23:03 -04002335 printk(KERN_NOTICE "RPC: Could not send backchannel reply "
2336 "error: %d\n", task->tk_status);
2337 break;
2338 }
Trond Myklebust1193d582015-06-02 11:53:21 -04002339 task->tk_action = rpc_exit_task;
Ricardo Labiaga55ae1aa2009-04-01 09:23:03 -04002340}
Trond Myklebust9e00abc2011-07-13 19:20:49 -04002341#endif /* CONFIG_SUNRPC_BACKCHANNEL */
Ricardo Labiaga55ae1aa2009-04-01 09:23:03 -04002342
Linus Torvalds1da177e2005-04-16 15:20:36 -07002343/*
2344 * 6. Sort out the RPC call status
2345 */
2346static void
2347call_status(struct rpc_task *task)
2348{
2349 struct rpc_clnt *clnt = task->tk_client;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002350 int status;
2351
Chuck Levera25a4cb2018-03-16 10:33:55 -04002352 if (!task->tk_msg.rpc_proc->p_proc)
2353 trace_xprt_ping(task->tk_xprt, task->tk_status);
2354
Chuck Lever46121cf2007-01-31 12:14:08 -05002355 dprint_status(task);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002356
2357 status = task->tk_status;
2358 if (status >= 0) {
2359 task->tk_action = call_decode;
2360 return;
2361 }
2362
Steve Dickson5753cba2012-02-06 10:08:08 -05002363 trace_rpc_call_status(task);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002364 task->tk_status = 0;
2365 switch(status) {
Trond Myklebust76303992006-08-30 14:32:49 -04002366 case -EHOSTDOWN:
Trond Myklebusteb5b46f2017-11-30 07:21:33 -05002367 case -ENETDOWN:
Trond Myklebust76303992006-08-30 14:32:49 -04002368 case -EHOSTUNREACH:
2369 case -ENETUNREACH:
Jason Baron3dedbb52014-09-24 18:08:04 +00002370 case -EPERM:
Trond Myklebustcea57782019-03-09 16:06:47 -05002371 if (RPC_IS_SOFTCONN(task))
2372 goto out_exit;
Trond Myklebust76303992006-08-30 14:32:49 -04002373 /*
2374 * Delay any retries for 3 seconds, then handle as if it
2375 * were a timeout.
2376 */
2377 rpc_delay(task, 3*HZ);
Gustavo A. R. Silvae9d47632017-10-20 11:48:30 -05002378 /* fall through */
Linus Torvalds1da177e2005-04-16 15:20:36 -07002379 case -ETIMEDOUT:
Linus Torvalds1da177e2005-04-16 15:20:36 -07002380 break;
2381 case -ECONNREFUSED:
Trond Myklebustdf277272013-12-31 13:11:43 -05002382 case -ECONNRESET:
2383 case -ECONNABORTED:
Olga Kornievskaiaec6017d2019-05-29 10:46:00 -04002384 case -ENOTCONN:
Chuck Lever35f5a422006-01-03 09:55:50 +01002385 rpc_force_rebind(clnt);
Trond Myklebustc82e5472019-08-16 08:58:48 -04002386 break;
Trond Myklebust3913c782015-02-08 21:44:04 -05002387 case -EADDRINUSE:
Trond Myklebustc8485e42009-03-11 14:37:59 -04002388 rpc_delay(task, 3*HZ);
Gustavo A. R. Silvae9d47632017-10-20 11:48:30 -05002389 /* fall through */
Trond Myklebustc8485e42009-03-11 14:37:59 -04002390 case -EPIPE:
Linus Torvalds1da177e2005-04-16 15:20:36 -07002391 case -EAGAIN:
Linus Torvalds1da177e2005-04-16 15:20:36 -07002392 break;
2393 case -EIO:
2394 /* shutdown or soft timeout */
Trond Myklebustcea57782019-03-09 16:06:47 -05002395 goto out_exit;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002396 default:
Olga Kornievskaiab6b61522008-06-09 16:51:31 -04002397 if (clnt->cl_chatty)
2398 printk("%s: RPC call returned error %d\n",
Trond Myklebust55909f22013-08-23 11:48:15 -04002399 clnt->cl_program->name, -status);
Trond Myklebustcea57782019-03-09 16:06:47 -05002400 goto out_exit;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002401 }
Trond Myklebustcea57782019-03-09 16:06:47 -05002402 task->tk_action = call_encode;
2403 rpc_check_timeout(task);
2404 return;
2405out_exit:
Trond Myklebust5ad64b32019-04-07 13:58:54 -04002406 rpc_call_rpcerror(task, status);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002407}
2408
Trond Myklebustd84dd3f2019-03-19 11:24:54 -04002409static bool
2410rpc_check_connected(const struct rpc_rqst *req)
2411{
2412 /* No allocated request or transport? return true */
2413 if (!req || !req->rq_xprt)
2414 return true;
2415 return xprt_connected(req->rq_xprt);
2416}
2417
Linus Torvalds1da177e2005-04-16 15:20:36 -07002418static void
Trond Myklebust7b3fef82019-03-07 14:10:32 -05002419rpc_check_timeout(struct rpc_task *task)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002420{
2421 struct rpc_clnt *clnt = task->tk_client;
2422
Trond Myklebust7b3fef82019-03-07 14:10:32 -05002423 if (xprt_adjust_timeout(task->tk_rqstp) == 0)
2424 return;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002425
Chuck Lever46121cf2007-01-31 12:14:08 -05002426 dprintk("RPC: %5u call_timeout (major)\n", task->tk_pid);
Chuck Leveref759a22006-03-20 13:44:17 -05002427 task->tk_timeouts++;
2428
Trond Myklebustd84dd3f2019-03-19 11:24:54 -04002429 if (RPC_IS_SOFTCONN(task) && !rpc_check_connected(task->tk_rqstp)) {
Trond Myklebust5ad64b32019-04-07 13:58:54 -04002430 rpc_call_rpcerror(task, -ETIMEDOUT);
Chuck Lever3a28bec2009-12-03 15:58:56 -05002431 return;
2432 }
Trond Myklebustd84dd3f2019-03-19 11:24:54 -04002433
Linus Torvalds1da177e2005-04-16 15:20:36 -07002434 if (RPC_IS_SOFT(task)) {
Trond Myklebuste4ec48d2019-04-07 13:58:55 -04002435 /*
2436 * Once a "no retrans timeout" soft tasks (a.k.a NFSv4) has
2437 * been sent, it should time out only if the transport
2438 * connection gets terminally broken.
2439 */
2440 if ((task->tk_flags & RPC_TASK_NO_RETRANS_TIMEOUT) &&
2441 rpc_check_connected(task->tk_rqstp))
2442 return;
2443
Joe Perchescac5d072012-07-18 11:17:11 -07002444 if (clnt->cl_chatty) {
Trond Myklebust0729d992019-04-07 13:58:57 -04002445 pr_notice_ratelimited(
2446 "%s: server %s not responding, timed out\n",
Trond Myklebust55909f22013-08-23 11:48:15 -04002447 clnt->cl_program->name,
Trond Myklebustfb43d172016-01-30 16:39:26 -05002448 task->tk_xprt->servername);
Joe Perchescac5d072012-07-18 11:17:11 -07002449 }
Trond Myklebust7494d002011-04-24 14:28:45 -04002450 if (task->tk_flags & RPC_TASK_TIMEOUT)
Trond Myklebust5ad64b32019-04-07 13:58:54 -04002451 rpc_call_rpcerror(task, -ETIMEDOUT);
Trond Myklebust7494d002011-04-24 14:28:45 -04002452 else
Trond Myklebust5ad64b32019-04-07 13:58:54 -04002453 __rpc_call_rpcerror(task, -EIO, -ETIMEDOUT);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002454 return;
2455 }
2456
Chuck Leverf518e35a2006-01-03 09:55:52 +01002457 if (!(task->tk_flags & RPC_CALL_MAJORSEEN)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002458 task->tk_flags |= RPC_CALL_MAJORSEEN;
Trond Myklebust4e0038b2012-03-01 17:01:05 -05002459 if (clnt->cl_chatty) {
Trond Myklebust0729d992019-04-07 13:58:57 -04002460 pr_notice_ratelimited(
2461 "%s: server %s not responding, still trying\n",
2462 clnt->cl_program->name,
2463 task->tk_xprt->servername);
Trond Myklebust4e0038b2012-03-01 17:01:05 -05002464 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07002465 }
Chuck Lever35f5a422006-01-03 09:55:50 +01002466 rpc_force_rebind(clnt);
Trond Myklebustb48633b2008-04-22 16:47:55 -04002467 /*
2468 * Did our request time out due to an RPCSEC_GSS out-of-sequence
2469 * event? RFC2203 requires the server to drop all such requests.
2470 */
2471 rpcauth_invalcred(task);
Trond Myklebust7b3fef82019-03-07 14:10:32 -05002472}
Linus Torvalds1da177e2005-04-16 15:20:36 -07002473
Trond Myklebust7b3fef82019-03-07 14:10:32 -05002474/*
Linus Torvalds1da177e2005-04-16 15:20:36 -07002475 * 7. Decode the RPC reply
2476 */
2477static void
2478call_decode(struct rpc_task *task)
2479{
2480 struct rpc_clnt *clnt = task->tk_client;
2481 struct rpc_rqst *req = task->tk_rqstp;
Chuck Levera0584ee2019-02-11 11:24:58 -05002482 struct xdr_stream xdr;
Trond Myklebust9ba82882019-09-16 09:12:19 -04002483 int err;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002484
Vasily Averin726fd6a2011-06-01 16:23:59 +04002485 dprint_status(task);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002486
Chuck Levera0584ee2019-02-11 11:24:58 -05002487 if (!task->tk_msg.rpc_proc->p_decode) {
Trond Myklebust9ee94d32018-08-28 16:27:31 -04002488 task->tk_action = rpc_exit_task;
2489 return;
2490 }
2491
Chuck Leverf518e35a2006-01-03 09:55:52 +01002492 if (task->tk_flags & RPC_CALL_MAJORSEEN) {
Trond Myklebust4e0038b2012-03-01 17:01:05 -05002493 if (clnt->cl_chatty) {
Trond Myklebust0729d992019-04-07 13:58:57 -04002494 pr_notice_ratelimited("%s: server %s OK\n",
Trond Myklebust55909f22013-08-23 11:48:15 -04002495 clnt->cl_program->name,
Trond Myklebustfb43d172016-01-30 16:39:26 -05002496 task->tk_xprt->servername);
Trond Myklebust4e0038b2012-03-01 17:01:05 -05002497 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07002498 task->tk_flags &= ~RPC_CALL_MAJORSEEN;
2499 }
2500
Trond Myklebust43ac3f22006-03-20 13:44:51 -05002501 /*
2502 * Ensure that we see all writes made by xprt_complete_rqst()
Ricardo Labiagadd2b63d2009-04-01 09:23:28 -04002503 * before it changed req->rq_reply_bytes_recvd.
Trond Myklebust43ac3f22006-03-20 13:44:51 -05002504 */
2505 smp_rmb();
Trond Myklebust9ba82882019-09-16 09:12:19 -04002506
2507 /*
2508 * Did we ever call xprt_complete_rqst()? If not, we should assume
2509 * the message is incomplete.
2510 */
2511 err = -EAGAIN;
2512 if (!req->rq_reply_bytes_recvd)
2513 goto out;
2514
Linus Torvalds1da177e2005-04-16 15:20:36 -07002515 req->rq_rcv_buf.len = req->rq_private_buf.len;
Chuck Leverb20dfc32020-03-02 15:01:08 -05002516 trace_xprt_recvfrom(&req->rq_rcv_buf);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002517
2518 /* Check that the softirq receive buffer is valid */
2519 WARN_ON(memcmp(&req->rq_rcv_buf, &req->rq_private_buf,
2520 sizeof(req->rq_rcv_buf)) != 0);
2521
Chuck Levera0584ee2019-02-11 11:24:58 -05002522 xdr_init_decode(&xdr, &req->rq_rcv_buf,
2523 req->rq_rcv_buf.head[0].iov_base, req);
Trond Myklebust9ba82882019-09-16 09:12:19 -04002524 err = rpc_decode_header(task, &xdr);
2525out:
2526 switch (err) {
Chuck Levera0584ee2019-02-11 11:24:58 -05002527 case 0:
2528 task->tk_action = rpc_exit_task;
2529 task->tk_status = rpcauth_unwrap_resp(task, &xdr);
2530 dprintk("RPC: %5u %s result %d\n",
2531 task->tk_pid, __func__, task->tk_status);
Trond Myklebustabbcf282006-01-03 09:55:03 +01002532 return;
Chuck Levera0584ee2019-02-11 11:24:58 -05002533 case -EAGAIN:
Chuck Levera0584ee2019-02-11 11:24:58 -05002534 task->tk_status = 0;
Trond Myklebust7987b692019-05-29 12:49:52 -04002535 if (task->tk_client->cl_discrtry)
2536 xprt_conditional_disconnect(req->rq_xprt,
2537 req->rq_connect_cookie);
Trond Myklebustcea57782019-03-09 16:06:47 -05002538 task->tk_action = call_encode;
2539 rpc_check_timeout(task);
Trond Myklebust7987b692019-05-29 12:49:52 -04002540 break;
2541 case -EKEYREJECTED:
2542 task->tk_action = call_reserve;
2543 rpc_check_timeout(task);
2544 rpcauth_invalcred(task);
2545 /* Ensure we obtain a new XID if we retry! */
2546 xprt_release(task);
Trond Myklebust24b74bf2008-04-19 13:15:47 -04002547 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07002548}
2549
Chuck Levere8680a22019-02-11 11:24:48 -05002550static int
2551rpc_encode_header(struct rpc_task *task, struct xdr_stream *xdr)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002552{
2553 struct rpc_clnt *clnt = task->tk_client;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002554 struct rpc_rqst *req = task->tk_rqstp;
Chuck Levere8680a22019-02-11 11:24:48 -05002555 __be32 *p;
2556 int error;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002557
Chuck Levere8680a22019-02-11 11:24:48 -05002558 error = -EMSGSIZE;
2559 p = xdr_reserve_space(xdr, RPC_CALLHDRSIZE << 2);
2560 if (!p)
2561 goto out_fail;
2562 *p++ = req->rq_xid;
2563 *p++ = rpc_call;
2564 *p++ = cpu_to_be32(RPC_VERSION);
2565 *p++ = cpu_to_be32(clnt->cl_prog);
2566 *p++ = cpu_to_be32(clnt->cl_vers);
2567 *p = cpu_to_be32(task->tk_msg.rpc_proc->p_proc);
Chuck Lever808012f2005-08-25 16:25:49 -07002568
Chuck Levere8680a22019-02-11 11:24:48 -05002569 error = rpcauth_marshcred(task, xdr);
2570 if (error < 0)
2571 goto out_fail;
2572 return 0;
2573out_fail:
2574 trace_rpc_bad_callhdr(task);
Trond Myklebust714fbc72019-09-12 08:06:51 -04002575 rpc_call_rpcerror(task, error);
Chuck Levere8680a22019-02-11 11:24:48 -05002576 return error;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002577}
2578
Chuck Levera0584ee2019-02-11 11:24:58 -05002579static noinline int
2580rpc_decode_header(struct rpc_task *task, struct xdr_stream *xdr)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002581{
Trond Myklebust4e0038b2012-03-01 17:01:05 -05002582 struct rpc_clnt *clnt = task->tk_client;
Trond Myklebusteb90a162019-03-15 09:29:00 -04002583 int error;
Chuck Levera0584ee2019-02-11 11:24:58 -05002584 __be32 *p;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002585
Chuck Lever7f5667a52019-02-11 11:24:53 -05002586 /* RFC-1014 says that the representation of XDR data must be a
2587 * multiple of four bytes
2588 * - if it isn't pointer subtraction in the NFS client may give
2589 * undefined results
2590 */
2591 if (task->tk_rqstp->rq_rcv_buf.len & 3)
Trond Myklebusteb90a162019-03-15 09:29:00 -04002592 goto out_unparsable;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002593
Chuck Levera0584ee2019-02-11 11:24:58 -05002594 p = xdr_inline_decode(xdr, 3 * sizeof(*p));
2595 if (!p)
2596 goto out_unparsable;
Chuck Lever7f5667a52019-02-11 11:24:53 -05002597 p++; /* skip XID */
2598 if (*p++ != rpc_reply)
2599 goto out_unparsable;
2600 if (*p++ != rpc_msg_accepted)
2601 goto out_msg_denied;
Ricardo Labiagaf4a2e412009-04-01 09:22:54 -04002602
Chuck Levera0584ee2019-02-11 11:24:58 -05002603 error = rpcauth_checkverf(task, xdr);
2604 if (error)
Chuck Lever7f5667a52019-02-11 11:24:53 -05002605 goto out_verifier;
2606
Chuck Levera0584ee2019-02-11 11:24:58 -05002607 p = xdr_inline_decode(xdr, sizeof(*p));
2608 if (!p)
Chuck Lever7f5667a52019-02-11 11:24:53 -05002609 goto out_unparsable;
Chuck Levera0584ee2019-02-11 11:24:58 -05002610 switch (*p) {
Chuck Lever7f5667a52019-02-11 11:24:53 -05002611 case rpc_success:
Chuck Levera0584ee2019-02-11 11:24:58 -05002612 return 0;
Chuck Lever7f5667a52019-02-11 11:24:53 -05002613 case rpc_prog_unavail:
2614 trace_rpc__prog_unavail(task);
Andreas Gruenbachercdf47702005-06-22 17:16:23 +00002615 error = -EPFNOSUPPORT;
2616 goto out_err;
Chuck Lever7f5667a52019-02-11 11:24:53 -05002617 case rpc_prog_mismatch:
2618 trace_rpc__prog_mismatch(task);
Andreas Gruenbachercdf47702005-06-22 17:16:23 +00002619 error = -EPROTONOSUPPORT;
2620 goto out_err;
Chuck Lever7f5667a52019-02-11 11:24:53 -05002621 case rpc_proc_unavail:
2622 trace_rpc__proc_unavail(task);
Andreas Gruenbachercdf47702005-06-22 17:16:23 +00002623 error = -EOPNOTSUPP;
2624 goto out_err;
Chuck Lever7f5667a52019-02-11 11:24:53 -05002625 case rpc_garbage_args:
Trond Myklebust928d42f2019-03-15 10:12:30 -04002626 case rpc_system_err:
Chuck Lever7f5667a52019-02-11 11:24:53 -05002627 trace_rpc__garbage_args(task);
Trond Myklebusteb90a162019-03-15 09:29:00 -04002628 error = -EIO;
Chuck Lever7f5667a52019-02-11 11:24:53 -05002629 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002630 default:
Trond Myklebusteb90a162019-03-15 09:29:00 -04002631 goto out_unparsable;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002632 }
2633
Trond Myklebustabbcf282006-01-03 09:55:03 +01002634out_garbage:
Trond Myklebust4e0038b2012-03-01 17:01:05 -05002635 clnt->cl_stats->rpcgarbage++;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002636 if (task->tk_garb_retry) {
2637 task->tk_garb_retry--;
Trond Myklebust762e4e62018-08-24 16:28:28 -04002638 task->tk_action = call_encode;
Chuck Levera0584ee2019-02-11 11:24:58 -05002639 return -EAGAIN;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002640 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07002641out_err:
Trond Myklebust714fbc72019-09-12 08:06:51 -04002642 rpc_call_rpcerror(task, error);
Chuck Levera0584ee2019-02-11 11:24:58 -05002643 return error;
Chuck Lever7f5667a52019-02-11 11:24:53 -05002644
Chuck Lever7f5667a52019-02-11 11:24:53 -05002645out_unparsable:
2646 trace_rpc__unparsable(task);
2647 error = -EIO;
Trond Myklebustabbcf282006-01-03 09:55:03 +01002648 goto out_garbage;
Chuck Lever7f5667a52019-02-11 11:24:53 -05002649
2650out_verifier:
2651 trace_rpc_bad_verifier(task);
Chuck Lever7f5667a52019-02-11 11:24:53 -05002652 goto out_garbage;
2653
2654out_msg_denied:
Trond Myklebusteb90a162019-03-15 09:29:00 -04002655 error = -EACCES;
Chuck Levera0584ee2019-02-11 11:24:58 -05002656 p = xdr_inline_decode(xdr, sizeof(*p));
2657 if (!p)
2658 goto out_unparsable;
Chuck Lever7f5667a52019-02-11 11:24:53 -05002659 switch (*p++) {
2660 case rpc_auth_error:
2661 break;
2662 case rpc_mismatch:
2663 trace_rpc__mismatch(task);
2664 error = -EPROTONOSUPPORT;
2665 goto out_err;
2666 default:
Trond Myklebusteb90a162019-03-15 09:29:00 -04002667 goto out_unparsable;
Chuck Lever7f5667a52019-02-11 11:24:53 -05002668 }
2669
Chuck Levera0584ee2019-02-11 11:24:58 -05002670 p = xdr_inline_decode(xdr, sizeof(*p));
2671 if (!p)
2672 goto out_unparsable;
Chuck Lever7f5667a52019-02-11 11:24:53 -05002673 switch (*p++) {
2674 case rpc_autherr_rejectedcred:
2675 case rpc_autherr_rejectedverf:
2676 case rpcsec_gsserr_credproblem:
2677 case rpcsec_gsserr_ctxproblem:
2678 if (!task->tk_cred_retry)
2679 break;
2680 task->tk_cred_retry--;
2681 trace_rpc__stale_creds(task);
Trond Myklebust7987b692019-05-29 12:49:52 -04002682 return -EKEYREJECTED;
Chuck Lever7f5667a52019-02-11 11:24:53 -05002683 case rpc_autherr_badcred:
2684 case rpc_autherr_badverf:
2685 /* possibly garbled cred/verf? */
2686 if (!task->tk_garb_retry)
2687 break;
2688 task->tk_garb_retry--;
2689 trace_rpc__bad_creds(task);
2690 task->tk_action = call_encode;
Chuck Levera0584ee2019-02-11 11:24:58 -05002691 return -EAGAIN;
Chuck Lever7f5667a52019-02-11 11:24:53 -05002692 case rpc_autherr_tooweak:
2693 trace_rpc__auth_tooweak(task);
2694 pr_warn("RPC: server %s requires stronger authentication.\n",
2695 task->tk_xprt->servername);
2696 break;
2697 default:
Trond Myklebusteb90a162019-03-15 09:29:00 -04002698 goto out_unparsable;
Chuck Lever7f5667a52019-02-11 11:24:53 -05002699 }
2700 goto out_err;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002701}
Trond Myklebust5ee0ed72005-06-22 17:16:20 +00002702
Christoph Hellwigc512f362017-05-08 09:31:19 +02002703static void rpcproc_encode_null(struct rpc_rqst *rqstp, struct xdr_stream *xdr,
2704 const void *obj)
Trond Myklebust5ee0ed72005-06-22 17:16:20 +00002705{
Trond Myklebust5ee0ed72005-06-22 17:16:20 +00002706}
2707
Christoph Hellwig73c8dc12017-05-08 14:58:11 +02002708static int rpcproc_decode_null(struct rpc_rqst *rqstp, struct xdr_stream *xdr,
2709 void *obj)
Trond Myklebust5ee0ed72005-06-22 17:16:20 +00002710{
2711 return 0;
2712}
2713
Christoph Hellwig499b4982017-05-12 15:36:49 +02002714static const struct rpc_procinfo rpcproc_null = {
Trond Myklebust5ee0ed72005-06-22 17:16:20 +00002715 .p_encode = rpcproc_encode_null,
2716 .p_decode = rpcproc_decode_null,
2717};
2718
Chuck Levercaabea82009-12-03 15:58:56 -05002719static int rpc_ping(struct rpc_clnt *clnt)
Trond Myklebust5ee0ed72005-06-22 17:16:20 +00002720{
2721 struct rpc_message msg = {
2722 .rpc_proc = &rpcproc_null,
2723 };
2724 int err;
NeilBrowna68a72e2018-12-03 11:30:30 +11002725 err = rpc_call_sync(clnt, &msg, RPC_TASK_SOFT | RPC_TASK_SOFTCONN |
2726 RPC_TASK_NULLCREDS);
Trond Myklebust5ee0ed72005-06-22 17:16:20 +00002727 return err;
2728}
Trond Myklebust188fef12007-06-16 14:18:40 -04002729
Trond Myklebust7f554892016-01-30 23:43:35 -05002730static
2731struct rpc_task *rpc_call_null_helper(struct rpc_clnt *clnt,
2732 struct rpc_xprt *xprt, struct rpc_cred *cred, int flags,
2733 const struct rpc_call_ops *ops, void *data)
Trond Myklebust5e1550d2007-06-23 10:17:16 -04002734{
2735 struct rpc_message msg = {
2736 .rpc_proc = &rpcproc_null,
Trond Myklebust5e1550d2007-06-23 10:17:16 -04002737 };
Trond Myklebust84115e12007-07-14 15:39:59 -04002738 struct rpc_task_setup task_setup_data = {
2739 .rpc_client = clnt,
Trond Myklebust7f554892016-01-30 23:43:35 -05002740 .rpc_xprt = xprt,
Trond Myklebust84115e12007-07-14 15:39:59 -04002741 .rpc_message = &msg,
NeilBrown1de7eea2018-12-03 11:30:30 +11002742 .rpc_op_cred = cred,
Trond Myklebust7f554892016-01-30 23:43:35 -05002743 .callback_ops = (ops != NULL) ? ops : &rpc_default_ops,
2744 .callback_data = data,
NeilBrowna52458b2018-12-03 11:30:31 +11002745 .flags = flags | RPC_TASK_NULLCREDS,
Trond Myklebust84115e12007-07-14 15:39:59 -04002746 };
Trond Myklebust7f554892016-01-30 23:43:35 -05002747
Trond Myklebustc970aa82007-07-14 15:39:59 -04002748 return rpc_run_task(&task_setup_data);
Trond Myklebust5e1550d2007-06-23 10:17:16 -04002749}
Trond Myklebust7f554892016-01-30 23:43:35 -05002750
2751struct rpc_task *rpc_call_null(struct rpc_clnt *clnt, struct rpc_cred *cred, int flags)
2752{
2753 return rpc_call_null_helper(clnt, NULL, cred, flags, NULL, NULL);
2754}
Trond Myklebuste8914c62007-07-14 15:39:59 -04002755EXPORT_SYMBOL_GPL(rpc_call_null);
Trond Myklebust5e1550d2007-06-23 10:17:16 -04002756
Trond Myklebust7f554892016-01-30 23:43:35 -05002757struct rpc_cb_add_xprt_calldata {
2758 struct rpc_xprt_switch *xps;
2759 struct rpc_xprt *xprt;
2760};
2761
2762static void rpc_cb_add_xprt_done(struct rpc_task *task, void *calldata)
2763{
2764 struct rpc_cb_add_xprt_calldata *data = calldata;
2765
2766 if (task->tk_status == 0)
2767 rpc_xprt_switch_add_xprt(data->xps, data->xprt);
2768}
2769
2770static void rpc_cb_add_xprt_release(void *calldata)
2771{
2772 struct rpc_cb_add_xprt_calldata *data = calldata;
2773
2774 xprt_put(data->xprt);
2775 xprt_switch_put(data->xps);
2776 kfree(data);
2777}
2778
Trond Myklebustce272302016-07-24 17:06:28 -04002779static const struct rpc_call_ops rpc_cb_add_xprt_call_ops = {
Trond Myklebust7f554892016-01-30 23:43:35 -05002780 .rpc_call_done = rpc_cb_add_xprt_done,
2781 .rpc_release = rpc_cb_add_xprt_release,
2782};
2783
2784/**
2785 * rpc_clnt_test_and_add_xprt - Test and add a new transport to a rpc_clnt
2786 * @clnt: pointer to struct rpc_clnt
2787 * @xps: pointer to struct rpc_xprt_switch,
2788 * @xprt: pointer struct rpc_xprt
2789 * @dummy: unused
2790 */
2791int rpc_clnt_test_and_add_xprt(struct rpc_clnt *clnt,
2792 struct rpc_xprt_switch *xps, struct rpc_xprt *xprt,
2793 void *dummy)
2794{
2795 struct rpc_cb_add_xprt_calldata *data;
Trond Myklebust7f554892016-01-30 23:43:35 -05002796 struct rpc_task *task;
2797
2798 data = kmalloc(sizeof(*data), GFP_NOFS);
2799 if (!data)
2800 return -ENOMEM;
2801 data->xps = xprt_switch_get(xps);
2802 data->xprt = xprt_get(xprt);
Trond Myklebust612b41f2017-04-27 08:50:51 -04002803 if (rpc_xprt_switch_has_addr(data->xps, (struct sockaddr *)&xprt->addr)) {
2804 rpc_cb_add_xprt_release(data);
2805 goto success;
2806 }
Trond Myklebust7f554892016-01-30 23:43:35 -05002807
NeilBrowna68a72e2018-12-03 11:30:30 +11002808 task = rpc_call_null_helper(clnt, xprt, NULL,
2809 RPC_TASK_SOFT|RPC_TASK_SOFTCONN|RPC_TASK_ASYNC|RPC_TASK_NULLCREDS,
Trond Myklebust7f554892016-01-30 23:43:35 -05002810 &rpc_cb_add_xprt_call_ops, data);
Trond Myklebust7f554892016-01-30 23:43:35 -05002811 if (IS_ERR(task))
2812 return PTR_ERR(task);
2813 rpc_put_task(task);
Trond Myklebust612b41f2017-04-27 08:50:51 -04002814success:
Trond Myklebust7f554892016-01-30 23:43:35 -05002815 return 1;
2816}
2817EXPORT_SYMBOL_GPL(rpc_clnt_test_and_add_xprt);
2818
2819/**
Andy Adamsonfda0ab42016-09-09 09:22:26 -04002820 * rpc_clnt_setup_test_and_add_xprt()
2821 *
2822 * This is an rpc_clnt_add_xprt setup() function which returns 1 so:
2823 * 1) caller of the test function must dereference the rpc_xprt_switch
2824 * and the rpc_xprt.
2825 * 2) test function must call rpc_xprt_switch_add_xprt, usually in
2826 * the rpc_call_done routine.
2827 *
2828 * Upon success (return of 1), the test function adds the new
2829 * transport to the rpc_clnt xprt switch
2830 *
2831 * @clnt: struct rpc_clnt to get the new transport
2832 * @xps: the rpc_xprt_switch to hold the new transport
2833 * @xprt: the rpc_xprt to test
2834 * @data: a struct rpc_add_xprt_test pointer that holds the test function
2835 * and test function call data
2836 */
2837int rpc_clnt_setup_test_and_add_xprt(struct rpc_clnt *clnt,
2838 struct rpc_xprt_switch *xps,
2839 struct rpc_xprt *xprt,
2840 void *data)
2841{
Andy Adamsonfda0ab42016-09-09 09:22:26 -04002842 struct rpc_task *task;
2843 struct rpc_add_xprt_test *xtest = (struct rpc_add_xprt_test *)data;
2844 int status = -EADDRINUSE;
2845
2846 xprt = xprt_get(xprt);
2847 xprt_switch_get(xps);
2848
2849 if (rpc_xprt_switch_has_addr(xps, (struct sockaddr *)&xprt->addr))
2850 goto out_err;
2851
2852 /* Test the connection */
NeilBrowna68a72e2018-12-03 11:30:30 +11002853 task = rpc_call_null_helper(clnt, xprt, NULL,
2854 RPC_TASK_SOFT | RPC_TASK_SOFTCONN | RPC_TASK_NULLCREDS,
Andy Adamsonfda0ab42016-09-09 09:22:26 -04002855 NULL, NULL);
Andy Adamsonfda0ab42016-09-09 09:22:26 -04002856 if (IS_ERR(task)) {
2857 status = PTR_ERR(task);
2858 goto out_err;
2859 }
2860 status = task->tk_status;
2861 rpc_put_task(task);
2862
2863 if (status < 0)
2864 goto out_err;
2865
2866 /* rpc_xprt_switch and rpc_xprt are deferrenced by add_xprt_test() */
2867 xtest->add_xprt_test(clnt, xprt, xtest->data);
2868
Santosh kumar pradhan10e037d2018-12-19 12:29:57 +05302869 xprt_put(xprt);
2870 xprt_switch_put(xps);
2871
Andy Adamsonfda0ab42016-09-09 09:22:26 -04002872 /* so that rpc_clnt_add_xprt does not call rpc_xprt_switch_add_xprt */
2873 return 1;
2874out_err:
2875 xprt_put(xprt);
2876 xprt_switch_put(xps);
2877 pr_info("RPC: rpc_clnt_test_xprt failed: %d addr %s not added\n",
2878 status, xprt->address_strings[RPC_DISPLAY_ADDR]);
2879 return status;
2880}
2881EXPORT_SYMBOL_GPL(rpc_clnt_setup_test_and_add_xprt);
2882
2883/**
Trond Myklebust7f554892016-01-30 23:43:35 -05002884 * rpc_clnt_add_xprt - Add a new transport to a rpc_clnt
2885 * @clnt: pointer to struct rpc_clnt
2886 * @xprtargs: pointer to struct xprt_create
2887 * @setup: callback to test and/or set up the connection
2888 * @data: pointer to setup function data
2889 *
2890 * Creates a new transport using the parameters set in args and
2891 * adds it to clnt.
2892 * If ping is set, then test that connectivity succeeds before
2893 * adding the new transport.
2894 *
2895 */
2896int rpc_clnt_add_xprt(struct rpc_clnt *clnt,
2897 struct xprt_create *xprtargs,
2898 int (*setup)(struct rpc_clnt *,
2899 struct rpc_xprt_switch *,
2900 struct rpc_xprt *,
2901 void *),
2902 void *data)
2903{
2904 struct rpc_xprt_switch *xps;
2905 struct rpc_xprt *xprt;
Trond Myklebust7196dbb2017-02-08 11:17:54 -05002906 unsigned long connect_timeout;
Trond Myklebust3851f1c2016-08-04 00:08:45 -04002907 unsigned long reconnect_timeout;
Trond Myklebuste6237b62019-10-17 11:13:54 -04002908 unsigned char resvport, reuseport;
Trond Myklebust7f554892016-01-30 23:43:35 -05002909 int ret = 0;
2910
2911 rcu_read_lock();
2912 xps = xprt_switch_get(rcu_dereference(clnt->cl_xpi.xpi_xpswitch));
2913 xprt = xprt_iter_xprt(&clnt->cl_xpi);
2914 if (xps == NULL || xprt == NULL) {
2915 rcu_read_unlock();
Lin Yib9622612019-06-10 10:16:56 +08002916 xprt_switch_put(xps);
Trond Myklebust7f554892016-01-30 23:43:35 -05002917 return -EAGAIN;
2918 }
2919 resvport = xprt->resvport;
Trond Myklebuste6237b62019-10-17 11:13:54 -04002920 reuseport = xprt->reuseport;
Trond Myklebust7196dbb2017-02-08 11:17:54 -05002921 connect_timeout = xprt->connect_timeout;
Trond Myklebust3851f1c2016-08-04 00:08:45 -04002922 reconnect_timeout = xprt->max_reconnect_timeout;
Trond Myklebust7f554892016-01-30 23:43:35 -05002923 rcu_read_unlock();
2924
2925 xprt = xprt_create_transport(xprtargs);
2926 if (IS_ERR(xprt)) {
2927 ret = PTR_ERR(xprt);
2928 goto out_put_switch;
2929 }
2930 xprt->resvport = resvport;
Trond Myklebuste6237b62019-10-17 11:13:54 -04002931 xprt->reuseport = reuseport;
Trond Myklebust7196dbb2017-02-08 11:17:54 -05002932 if (xprt->ops->set_connect_timeout != NULL)
2933 xprt->ops->set_connect_timeout(xprt,
2934 connect_timeout,
2935 reconnect_timeout);
Trond Myklebust7f554892016-01-30 23:43:35 -05002936
2937 rpc_xprt_switch_set_roundrobin(xps);
2938 if (setup) {
2939 ret = setup(clnt, xps, xprt, data);
2940 if (ret != 0)
2941 goto out_put_xprt;
2942 }
2943 rpc_xprt_switch_add_xprt(xps, xprt);
2944out_put_xprt:
2945 xprt_put(xprt);
2946out_put_switch:
2947 xprt_switch_put(xps);
2948 return ret;
2949}
2950EXPORT_SYMBOL_GPL(rpc_clnt_add_xprt);
2951
Trond Myklebust7196dbb2017-02-08 11:17:54 -05002952struct connect_timeout_data {
2953 unsigned long connect_timeout;
2954 unsigned long reconnect_timeout;
2955};
2956
Trond Myklebust8d480322016-08-05 19:03:31 -04002957static int
Trond Myklebust7196dbb2017-02-08 11:17:54 -05002958rpc_xprt_set_connect_timeout(struct rpc_clnt *clnt,
Trond Myklebust8d480322016-08-05 19:03:31 -04002959 struct rpc_xprt *xprt,
2960 void *data)
2961{
Trond Myklebust7196dbb2017-02-08 11:17:54 -05002962 struct connect_timeout_data *timeo = data;
Trond Myklebust8d480322016-08-05 19:03:31 -04002963
Trond Myklebust7196dbb2017-02-08 11:17:54 -05002964 if (xprt->ops->set_connect_timeout)
2965 xprt->ops->set_connect_timeout(xprt,
2966 timeo->connect_timeout,
2967 timeo->reconnect_timeout);
Trond Myklebust8d480322016-08-05 19:03:31 -04002968 return 0;
2969}
2970
2971void
Trond Myklebust26ae1022017-02-08 11:17:55 -05002972rpc_set_connect_timeout(struct rpc_clnt *clnt,
2973 unsigned long connect_timeout,
2974 unsigned long reconnect_timeout)
Trond Myklebust8d480322016-08-05 19:03:31 -04002975{
Trond Myklebust7196dbb2017-02-08 11:17:54 -05002976 struct connect_timeout_data timeout = {
Trond Myklebust26ae1022017-02-08 11:17:55 -05002977 .connect_timeout = connect_timeout,
2978 .reconnect_timeout = reconnect_timeout,
Trond Myklebust7196dbb2017-02-08 11:17:54 -05002979 };
Trond Myklebust8d480322016-08-05 19:03:31 -04002980 rpc_clnt_iterate_for_each_xprt(clnt,
Trond Myklebust7196dbb2017-02-08 11:17:54 -05002981 rpc_xprt_set_connect_timeout,
2982 &timeout);
Trond Myklebust8d480322016-08-05 19:03:31 -04002983}
Trond Myklebust26ae1022017-02-08 11:17:55 -05002984EXPORT_SYMBOL_GPL(rpc_set_connect_timeout);
Trond Myklebust8d480322016-08-05 19:03:31 -04002985
Andy Adamson3b58a8a2016-09-09 09:22:23 -04002986void rpc_clnt_xprt_switch_put(struct rpc_clnt *clnt)
2987{
Anna Schumakerbb29dd82016-10-26 10:33:31 -04002988 rcu_read_lock();
Andy Adamson3b58a8a2016-09-09 09:22:23 -04002989 xprt_switch_put(rcu_dereference(clnt->cl_xpi.xpi_xpswitch));
Anna Schumakerbb29dd82016-10-26 10:33:31 -04002990 rcu_read_unlock();
Andy Adamson3b58a8a2016-09-09 09:22:23 -04002991}
2992EXPORT_SYMBOL_GPL(rpc_clnt_xprt_switch_put);
2993
Andy Adamsondd691712016-09-09 09:22:24 -04002994void rpc_clnt_xprt_switch_add_xprt(struct rpc_clnt *clnt, struct rpc_xprt *xprt)
2995{
Anna Schumakerbb29dd82016-10-26 10:33:31 -04002996 rcu_read_lock();
Andy Adamsondd691712016-09-09 09:22:24 -04002997 rpc_xprt_switch_add_xprt(rcu_dereference(clnt->cl_xpi.xpi_xpswitch),
2998 xprt);
Anna Schumakerbb29dd82016-10-26 10:33:31 -04002999 rcu_read_unlock();
Andy Adamsondd691712016-09-09 09:22:24 -04003000}
3001EXPORT_SYMBOL_GPL(rpc_clnt_xprt_switch_add_xprt);
3002
Andy Adamson39e5d2d2016-09-09 09:22:25 -04003003bool rpc_clnt_xprt_switch_has_addr(struct rpc_clnt *clnt,
3004 const struct sockaddr *sap)
3005{
3006 struct rpc_xprt_switch *xps;
3007 bool ret;
3008
Andy Adamson39e5d2d2016-09-09 09:22:25 -04003009 rcu_read_lock();
Anna Schumakerbb29dd82016-10-26 10:33:31 -04003010 xps = rcu_dereference(clnt->cl_xpi.xpi_xpswitch);
Andy Adamson39e5d2d2016-09-09 09:22:25 -04003011 ret = rpc_xprt_switch_has_addr(xps, sap);
3012 rcu_read_unlock();
3013 return ret;
3014}
3015EXPORT_SYMBOL_GPL(rpc_clnt_xprt_switch_has_addr);
3016
Jeff Laytonf895b252014-11-17 16:58:04 -05003017#if IS_ENABLED(CONFIG_SUNRPC_DEBUG)
Chuck Lever68a23ee2008-05-21 17:09:26 -04003018static void rpc_show_header(void)
3019{
Chuck Levercb3997b2008-05-21 17:09:41 -04003020 printk(KERN_INFO "-pid- flgs status -client- --rqstp- "
3021 "-timeout ---ops--\n");
Chuck Lever68a23ee2008-05-21 17:09:26 -04003022}
3023
Chuck Lever38e886e2008-05-21 17:09:33 -04003024static void rpc_show_task(const struct rpc_clnt *clnt,
3025 const struct rpc_task *task)
3026{
3027 const char *rpc_waitq = "none";
Chuck Lever38e886e2008-05-21 17:09:33 -04003028
3029 if (RPC_IS_QUEUED(task))
3030 rpc_waitq = rpc_qname(task->tk_waitqueue);
3031
Joe Perchesb3bceda2010-12-21 10:52:24 -05003032 printk(KERN_INFO "%5u %04x %6d %8p %8p %8ld %8p %sv%u %s a:%ps q:%s\n",
Chuck Levercb3997b2008-05-21 17:09:41 -04003033 task->tk_pid, task->tk_flags, task->tk_status,
Trond Myklebust5efd1872019-04-07 13:58:50 -04003034 clnt, task->tk_rqstp, rpc_task_timeout(task), task->tk_ops,
Trond Myklebust55909f22013-08-23 11:48:15 -04003035 clnt->cl_program->name, clnt->cl_vers, rpc_proc_name(task),
Joe Perchesb3bceda2010-12-21 10:52:24 -05003036 task->tk_action, rpc_waitq);
Chuck Lever38e886e2008-05-21 17:09:33 -04003037}
3038
Stanislav Kinsbursky70abc492012-01-12 22:07:51 +04003039void rpc_show_tasks(struct net *net)
Trond Myklebust188fef12007-06-16 14:18:40 -04003040{
3041 struct rpc_clnt *clnt;
Chuck Lever38e886e2008-05-21 17:09:33 -04003042 struct rpc_task *task;
Chuck Lever68a23ee2008-05-21 17:09:26 -04003043 int header = 0;
Stanislav Kinsbursky70abc492012-01-12 22:07:51 +04003044 struct sunrpc_net *sn = net_generic(net, sunrpc_net_id);
Trond Myklebust188fef12007-06-16 14:18:40 -04003045
Stanislav Kinsbursky70abc492012-01-12 22:07:51 +04003046 spin_lock(&sn->rpc_client_lock);
3047 list_for_each_entry(clnt, &sn->all_clients, cl_clients) {
Trond Myklebust188fef12007-06-16 14:18:40 -04003048 spin_lock(&clnt->cl_lock);
Chuck Lever38e886e2008-05-21 17:09:33 -04003049 list_for_each_entry(task, &clnt->cl_tasks, tk_task) {
Chuck Lever68a23ee2008-05-21 17:09:26 -04003050 if (!header) {
3051 rpc_show_header();
3052 header++;
3053 }
Chuck Lever38e886e2008-05-21 17:09:33 -04003054 rpc_show_task(clnt, task);
Trond Myklebust188fef12007-06-16 14:18:40 -04003055 }
3056 spin_unlock(&clnt->cl_lock);
3057 }
Stanislav Kinsbursky70abc492012-01-12 22:07:51 +04003058 spin_unlock(&sn->rpc_client_lock);
Trond Myklebust188fef12007-06-16 14:18:40 -04003059}
3060#endif
Jeff Layton3c87ef62015-06-03 16:14:25 -04003061
3062#if IS_ENABLED(CONFIG_SUNRPC_SWAP)
Trond Myklebust15001e52016-01-30 20:05:34 -05003063static int
3064rpc_clnt_swap_activate_callback(struct rpc_clnt *clnt,
3065 struct rpc_xprt *xprt,
3066 void *dummy)
3067{
3068 return xprt_enable_swap(xprt);
3069}
3070
Jeff Layton3c87ef62015-06-03 16:14:25 -04003071int
3072rpc_clnt_swap_activate(struct rpc_clnt *clnt)
3073{
Trond Myklebust15001e52016-01-30 20:05:34 -05003074 if (atomic_inc_return(&clnt->cl_swapper) == 1)
3075 return rpc_clnt_iterate_for_each_xprt(clnt,
3076 rpc_clnt_swap_activate_callback, NULL);
3077 return 0;
Jeff Layton3c87ef62015-06-03 16:14:25 -04003078}
3079EXPORT_SYMBOL_GPL(rpc_clnt_swap_activate);
3080
Trond Myklebust15001e52016-01-30 20:05:34 -05003081static int
3082rpc_clnt_swap_deactivate_callback(struct rpc_clnt *clnt,
3083 struct rpc_xprt *xprt,
3084 void *dummy)
3085{
3086 xprt_disable_swap(xprt);
3087 return 0;
3088}
3089
Jeff Layton3c87ef62015-06-03 16:14:25 -04003090void
3091rpc_clnt_swap_deactivate(struct rpc_clnt *clnt)
3092{
Trond Myklebust15001e52016-01-30 20:05:34 -05003093 if (atomic_dec_if_positive(&clnt->cl_swapper) == 0)
3094 rpc_clnt_iterate_for_each_xprt(clnt,
3095 rpc_clnt_swap_deactivate_callback, NULL);
Jeff Layton3c87ef62015-06-03 16:14:25 -04003096}
3097EXPORT_SYMBOL_GPL(rpc_clnt_swap_deactivate);
3098#endif /* CONFIG_SUNRPC_SWAP */