blob: 05da12a33945aafe6b17a0174a7652880d5d9f49 [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/*
Chuck Lever55aa4f52005-08-11 16:25:47 -04002 * linux/net/sunrpc/clnt.c
Linus Torvalds1da177e2005-04-16 15:20:36 -07003 *
4 * This file contains the high-level RPC interface.
5 * It is modeled as a finite state machine to support both synchronous
6 * and asynchronous requests.
7 *
8 * - RPC header generation and argument serialization.
9 * - Credential refresh.
10 * - TCP connect handling.
11 * - Retry of operation when it is suspected the operation failed because
12 * of uid squashing on the server, or when the credentials were stale
13 * and need to be refreshed, or when a packet was damaged in transit.
14 * This may be have to be moved to the VFS layer.
15 *
Linus Torvalds1da177e2005-04-16 15:20:36 -070016 * Copyright (C) 1992,1993 Rick Sladkey <jrs@world.std.com>
17 * Copyright (C) 1995,1996 Olaf Kirch <okir@monad.swb.de>
18 */
19
Linus Torvalds1da177e2005-04-16 15:20:36 -070020
21#include <linux/module.h>
22#include <linux/types.h>
Chuck Levercb3997b2008-05-21 17:09:41 -040023#include <linux/kallsyms.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070024#include <linux/mm.h>
Trond Myklebust23ac6582009-08-09 15:14:25 -040025#include <linux/namei.h>
26#include <linux/mount.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070027#include <linux/slab.h>
Trond Myklebust40b00b6b2013-10-17 14:12:23 -040028#include <linux/rcupdate.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070029#include <linux/utsname.h>
Chuck Lever11c556b2006-03-20 13:44:22 -050030#include <linux/workqueue.h>
Chuck Lever176e21e2011-05-09 15:22:44 -040031#include <linux/in.h>
Chuck Lever510deb02007-12-10 14:56:24 -050032#include <linux/in6.h>
Chuck Lever176e21e2011-05-09 15:22:44 -040033#include <linux/un.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070034
35#include <linux/sunrpc/clnt.h>
Jeff Layton59766872013-02-04 12:50:00 -050036#include <linux/sunrpc/addr.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070037#include <linux/sunrpc/rpc_pipe_fs.h>
Chuck Lever11c556b2006-03-20 13:44:22 -050038#include <linux/sunrpc/metrics.h>
Ricardo Labiaga55ae1aa2009-04-01 09:23:03 -040039#include <linux/sunrpc/bc_xprt.h>
Steve Dickson5753cba2012-02-06 10:08:08 -050040#include <trace/events/sunrpc.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070041
Ricardo Labiaga55ae1aa2009-04-01 09:23:03 -040042#include "sunrpc.h"
Stanislav Kinsbursky70abc492012-01-12 22:07:51 +040043#include "netns.h"
Linus Torvalds1da177e2005-04-16 15:20:36 -070044
Jeff Laytonf895b252014-11-17 16:58:04 -050045#if IS_ENABLED(CONFIG_SUNRPC_DEBUG)
Linus Torvalds1da177e2005-04-16 15:20:36 -070046# define RPCDBG_FACILITY RPCDBG_CALL
47#endif
48
Chuck Lever46121cf2007-01-31 12:14:08 -050049#define dprint_status(t) \
50 dprintk("RPC: %5u %s (status %d)\n", t->tk_pid, \
Harvey Harrison0dc47872008-03-05 20:47:47 -080051 __func__, t->tk_status)
Chuck Lever46121cf2007-01-31 12:14:08 -050052
Trond Myklebust188fef12007-06-16 14:18:40 -040053/*
54 * All RPC clients are linked into this list
55 */
Trond Myklebust188fef12007-06-16 14:18:40 -040056
Linus Torvalds1da177e2005-04-16 15:20:36 -070057static DECLARE_WAIT_QUEUE_HEAD(destroy_wait);
58
59
60static void call_start(struct rpc_task *task);
61static void call_reserve(struct rpc_task *task);
62static void call_reserveresult(struct rpc_task *task);
63static void call_allocate(struct rpc_task *task);
Linus Torvalds1da177e2005-04-16 15:20:36 -070064static void call_decode(struct rpc_task *task);
65static void call_bind(struct rpc_task *task);
Chuck Leverda351872005-08-11 16:25:11 -040066static void call_bind_status(struct rpc_task *task);
Linus Torvalds1da177e2005-04-16 15:20:36 -070067static void call_transmit(struct rpc_task *task);
Trond Myklebust9e00abc2011-07-13 19:20:49 -040068#if defined(CONFIG_SUNRPC_BACKCHANNEL)
Ricardo Labiaga55ae1aa2009-04-01 09:23:03 -040069static void call_bc_transmit(struct rpc_task *task);
Trond Myklebust9e00abc2011-07-13 19:20:49 -040070#endif /* CONFIG_SUNRPC_BACKCHANNEL */
Linus Torvalds1da177e2005-04-16 15:20:36 -070071static void call_status(struct rpc_task *task);
Trond Myklebust940e3312005-11-09 21:45:24 -050072static void call_transmit_status(struct rpc_task *task);
Linus Torvalds1da177e2005-04-16 15:20:36 -070073static void call_refresh(struct rpc_task *task);
74static void call_refreshresult(struct rpc_task *task);
75static void call_timeout(struct rpc_task *task);
76static void call_connect(struct rpc_task *task);
77static void call_connect_status(struct rpc_task *task);
Linus Torvalds1da177e2005-04-16 15:20:36 -070078
Chuck Leverb0e1c572008-05-21 17:09:19 -040079static __be32 *rpc_encode_header(struct rpc_task *task);
80static __be32 *rpc_verify_header(struct rpc_task *task);
Chuck Levercaabea82009-12-03 15:58:56 -050081static int rpc_ping(struct rpc_clnt *clnt);
Trond Myklebust64c91a12007-06-23 10:17:16 -040082
Trond Myklebust188fef12007-06-16 14:18:40 -040083static void rpc_register_client(struct rpc_clnt *clnt)
84{
Trond Myklebust2446ab62012-03-01 17:00:56 -050085 struct net *net = rpc_net_ns(clnt);
86 struct sunrpc_net *sn = net_generic(net, sunrpc_net_id);
Stanislav Kinsbursky70abc492012-01-12 22:07:51 +040087
88 spin_lock(&sn->rpc_client_lock);
89 list_add(&clnt->cl_clients, &sn->all_clients);
90 spin_unlock(&sn->rpc_client_lock);
Trond Myklebust188fef12007-06-16 14:18:40 -040091}
92
93static void rpc_unregister_client(struct rpc_clnt *clnt)
94{
Trond Myklebust2446ab62012-03-01 17:00:56 -050095 struct net *net = rpc_net_ns(clnt);
96 struct sunrpc_net *sn = net_generic(net, sunrpc_net_id);
Stanislav Kinsbursky70abc492012-01-12 22:07:51 +040097
98 spin_lock(&sn->rpc_client_lock);
Trond Myklebust188fef12007-06-16 14:18:40 -040099 list_del(&clnt->cl_clients);
Stanislav Kinsbursky70abc492012-01-12 22:07:51 +0400100 spin_unlock(&sn->rpc_client_lock);
Trond Myklebust188fef12007-06-16 14:18:40 -0400101}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700102
Stanislav Kinsbursky0157d022012-01-11 19:18:01 +0400103static void __rpc_clnt_remove_pipedir(struct rpc_clnt *clnt)
104{
Trond Myklebustc36dcfe12013-08-26 17:44:26 -0400105 rpc_remove_client_dir(clnt);
Stanislav Kinsbursky0157d022012-01-11 19:18:01 +0400106}
107
108static void rpc_clnt_remove_pipedir(struct rpc_clnt *clnt)
109{
Trond Myklebust2446ab62012-03-01 17:00:56 -0500110 struct net *net = rpc_net_ns(clnt);
Stanislav Kinsbursky0157d022012-01-11 19:18:01 +0400111 struct super_block *pipefs_sb;
Stanislav Kinsbursky0157d022012-01-11 19:18:01 +0400112
Trond Myklebust2446ab62012-03-01 17:00:56 -0500113 pipefs_sb = rpc_get_sb_net(net);
Stanislav Kinsbursky0157d022012-01-11 19:18:01 +0400114 if (pipefs_sb) {
Stanislav Kinsbursky0157d022012-01-11 19:18:01 +0400115 __rpc_clnt_remove_pipedir(clnt);
Trond Myklebust2446ab62012-03-01 17:00:56 -0500116 rpc_put_sb_net(net);
Stanislav Kinsbursky0157d022012-01-11 19:18:01 +0400117 }
Stanislav Kinsbursky0157d022012-01-11 19:18:01 +0400118}
119
120static struct dentry *rpc_setup_pipedir_sb(struct super_block *sb,
Trond Myklebust41b6b4d2013-08-23 13:03:50 -0400121 struct rpc_clnt *clnt)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700122{
Trond Myklebustf1345852005-09-23 11:08:25 -0400123 static uint32_t clntid;
Trond Myklebust41b6b4d2013-08-23 13:03:50 -0400124 const char *dir_name = clnt->cl_program->pipe_dir_name;
Trond Myklebust23ac6582009-08-09 15:14:25 -0400125 char name[15];
Stanislav Kinsbursky0157d022012-01-11 19:18:01 +0400126 struct dentry *dir, *dentry;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700127
Stanislav Kinsbursky0157d022012-01-11 19:18:01 +0400128 dir = rpc_d_lookup_sb(sb, dir_name);
Weston Andros Adamson922eeac2012-10-23 10:43:25 -0400129 if (dir == NULL) {
130 pr_info("RPC: pipefs directory doesn't exist: %s\n", dir_name);
Stanislav Kinsbursky0157d022012-01-11 19:18:01 +0400131 return dir;
Weston Andros Adamson922eeac2012-10-23 10:43:25 -0400132 }
Stanislav Kinsbursky0157d022012-01-11 19:18:01 +0400133 for (;;) {
Al Viroa95e6912013-07-14 16:43:54 +0400134 snprintf(name, sizeof(name), "clnt%x", (unsigned int)clntid++);
Stanislav Kinsbursky0157d022012-01-11 19:18:01 +0400135 name[sizeof(name) - 1] = '\0';
Al Viroa95e6912013-07-14 16:43:54 +0400136 dentry = rpc_create_client_dir(dir, name, clnt);
Stanislav Kinsbursky0157d022012-01-11 19:18:01 +0400137 if (!IS_ERR(dentry))
138 break;
Al Viroa95e6912013-07-14 16:43:54 +0400139 if (dentry == ERR_PTR(-EEXIST))
140 continue;
141 printk(KERN_INFO "RPC: Couldn't create pipefs entry"
142 " %s/%s, error %ld\n",
143 dir_name, name, PTR_ERR(dentry));
144 break;
Stanislav Kinsbursky0157d022012-01-11 19:18:01 +0400145 }
146 dput(dir);
147 return dentry;
148}
149
150static int
Trond Myklebust41b6b4d2013-08-23 13:03:50 -0400151rpc_setup_pipedir(struct super_block *pipefs_sb, struct rpc_clnt *clnt)
Stanislav Kinsbursky0157d022012-01-11 19:18:01 +0400152{
Stanislav Kinsbursky30507f52012-01-11 19:18:42 +0400153 struct dentry *dentry;
Stanislav Kinsbursky0157d022012-01-11 19:18:01 +0400154
Trond Myklebustc36dcfe12013-08-26 17:44:26 -0400155 if (clnt->cl_program->pipe_dir_name != NULL) {
156 dentry = rpc_setup_pipedir_sb(pipefs_sb, clnt);
157 if (IS_ERR(dentry))
158 return PTR_ERR(dentry);
159 }
Trond Myklebust23ac6582009-08-09 15:14:25 -0400160 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700161}
162
Trond Myklebust41b6b4d2013-08-23 13:03:50 -0400163static int rpc_clnt_skip_event(struct rpc_clnt *clnt, unsigned long event)
Stanislav Kinsburskyea8cfa02012-04-27 13:00:17 +0400164{
Trond Myklebust41b6b4d2013-08-23 13:03:50 -0400165 if (clnt->cl_program->pipe_dir_name == NULL)
Stanislav Kinsburskyea8cfa02012-04-27 13:00:17 +0400166 return 1;
Trond Myklebust41b6b4d2013-08-23 13:03:50 -0400167
Trond Myklebustc36dcfe12013-08-26 17:44:26 -0400168 switch (event) {
169 case RPC_PIPEFS_MOUNT:
170 if (clnt->cl_pipedir_objects.pdh_dentry != NULL)
171 return 1;
172 if (atomic_read(&clnt->cl_count) == 0)
173 return 1;
174 break;
175 case RPC_PIPEFS_UMOUNT:
176 if (clnt->cl_pipedir_objects.pdh_dentry == NULL)
177 return 1;
178 break;
179 }
Stanislav Kinsburskyea8cfa02012-04-27 13:00:17 +0400180 return 0;
181}
182
183static int __rpc_clnt_handle_event(struct rpc_clnt *clnt, unsigned long event,
184 struct super_block *sb)
Stanislav Kinsbursky80df9d22012-01-11 19:18:17 +0400185{
186 struct dentry *dentry;
187 int err = 0;
188
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 }
204 return err;
205}
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 Kinsburskyeee17322012-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{
289 clnt->cl_nodelen = strlen(nodename);
290 if (clnt->cl_nodelen > UNX_MAXNODENAME)
291 clnt->cl_nodelen = UNX_MAXNODENAME;
292 memcpy(clnt->cl_nodename, nodename, clnt->cl_nodelen);
293}
294
Chuck Leverd746e542013-10-17 14:12:17 -0400295static int rpc_client_register(struct rpc_clnt *clnt,
296 rpc_authflavor_t pseudoflavor,
297 const char *client_name)
Stanislav Kinsburskye73f4cc2013-06-24 11:52:52 +0400298{
Trond Myklebustc2190662013-08-26 19:23:04 -0400299 struct rpc_auth_create_args auth_args = {
Chuck Leverd746e542013-10-17 14:12:17 -0400300 .pseudoflavor = pseudoflavor,
301 .target_name = client_name,
Trond Myklebustc2190662013-08-26 19:23:04 -0400302 };
Stanislav Kinsburskye73f4cc2013-06-24 11:52:52 +0400303 struct rpc_auth *auth;
304 struct net *net = rpc_net_ns(clnt);
305 struct super_block *pipefs_sb;
Trond Myklebusteeee2452013-07-10 15:33:01 -0400306 int err;
Stanislav Kinsburskye73f4cc2013-06-24 11:52:52 +0400307
Jeff Laytonb4b9d2c2014-11-26 14:44:43 -0500308 err = rpc_clnt_debugfs_register(clnt);
309 if (err)
310 return err;
311
Stanislav Kinsburskye73f4cc2013-06-24 11:52:52 +0400312 pipefs_sb = rpc_get_sb_net(net);
313 if (pipefs_sb) {
Trond Myklebust41b6b4d2013-08-23 13:03:50 -0400314 err = rpc_setup_pipedir(pipefs_sb, clnt);
Stanislav Kinsburskye73f4cc2013-06-24 11:52:52 +0400315 if (err)
316 goto out;
317 }
318
Trond Myklebusteeee2452013-07-10 15:33:01 -0400319 rpc_register_client(clnt);
320 if (pipefs_sb)
321 rpc_put_sb_net(net);
322
Trond Myklebustc2190662013-08-26 19:23:04 -0400323 auth = rpcauth_create(&auth_args, clnt);
Stanislav Kinsburskye73f4cc2013-06-24 11:52:52 +0400324 if (IS_ERR(auth)) {
325 dprintk("RPC: Couldn't create auth handle (flavor %u)\n",
Chuck Leverd746e542013-10-17 14:12:17 -0400326 pseudoflavor);
Stanislav Kinsburskye73f4cc2013-06-24 11:52:52 +0400327 err = PTR_ERR(auth);
328 goto err_auth;
329 }
Trond Myklebusteeee2452013-07-10 15:33:01 -0400330 return 0;
331err_auth:
332 pipefs_sb = rpc_get_sb_net(net);
Trond Myklebust1540c5d2013-07-14 22:57:50 -0400333 rpc_unregister_client(clnt);
Trond Myklebusteeee2452013-07-10 15:33:01 -0400334 __rpc_clnt_remove_pipedir(clnt);
Stanislav Kinsburskye73f4cc2013-06-24 11:52:52 +0400335out:
336 if (pipefs_sb)
337 rpc_put_sb_net(net);
Jeff Laytonb4b9d2c2014-11-26 14:44:43 -0500338 rpc_clnt_debugfs_unregister(clnt);
Stanislav Kinsburskye73f4cc2013-06-24 11:52:52 +0400339 return err;
Stanislav Kinsburskye73f4cc2013-06-24 11:52:52 +0400340}
341
Trond Myklebust2f048db2013-09-04 21:51:44 -0400342static DEFINE_IDA(rpc_clids);
343
344static int rpc_alloc_clid(struct rpc_clnt *clnt)
345{
346 int clid;
347
348 clid = ida_simple_get(&rpc_clids, 0, 0, GFP_KERNEL);
349 if (clid < 0)
350 return clid;
351 clnt->cl_clid = clid;
352 return 0;
353}
354
355static void rpc_free_clid(struct rpc_clnt *clnt)
356{
357 ida_simple_remove(&rpc_clids, clnt->cl_clid);
358}
359
Trond Myklebust280ebcf2013-09-02 13:28:04 -0400360static struct rpc_clnt * rpc_new_client(const struct rpc_create_args *args,
361 struct rpc_xprt *xprt,
362 struct rpc_clnt *parent)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700363{
Trond Myklebusta613fa12012-01-20 13:53:56 -0500364 const struct rpc_program *program = args->program;
365 const struct rpc_version *version;
Trond Myklebust40b00b6b2013-10-17 14:12:23 -0400366 struct rpc_clnt *clnt = NULL;
367 const struct rpc_timeout *timeout;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700368 int err;
Chuck Lever06b8d252007-09-11 18:00:20 -0400369
370 /* sanity check the name before trying to print it */
Chuck Lever46121cf2007-01-31 12:14:08 -0500371 dprintk("RPC: creating %s client for %s (xprt %p)\n",
Trond Myklebust698b6d02007-12-20 16:03:53 -0500372 program->name, args->servername, xprt);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700373
Trond Myklebust4ada5392007-06-14 17:26:17 -0400374 err = rpciod_up();
375 if (err)
376 goto out_no_rpciod;
Trond Myklebust698b6d02007-12-20 16:03:53 -0500377
Trond Myklebustf05c1242013-04-05 14:13:21 -0400378 err = -EINVAL;
Trond Myklebust698b6d02007-12-20 16:03:53 -0500379 if (args->version >= program->nrvers)
380 goto out_err;
381 version = program->version[args->version];
382 if (version == NULL)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700383 goto out_err;
384
385 err = -ENOMEM;
Panagiotis Issaris0da974f2006-07-21 14:51:30 -0700386 clnt = kzalloc(sizeof(*clnt), GFP_KERNEL);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700387 if (!clnt)
388 goto out_err;
Trond Myklebust280ebcf2013-09-02 13:28:04 -0400389 clnt->cl_parent = parent ? : clnt;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700390
Trond Myklebust2f048db2013-09-04 21:51:44 -0400391 err = rpc_alloc_clid(clnt);
392 if (err)
393 goto out_no_clid;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700394
Linus Torvalds1da177e2005-04-16 15:20:36 -0700395 clnt->cl_procinfo = version->procs;
396 clnt->cl_maxproc = version->nrprocs;
Benny Halevyd5b337b2008-09-28 09:21:26 +0300397 clnt->cl_prog = args->prognumber ? : program->number;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700398 clnt->cl_vers = version->number;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700399 clnt->cl_stats = program->stats;
Chuck Lever11c556b2006-03-20 13:44:22 -0500400 clnt->cl_metrics = rpc_alloc_iostats(clnt);
Trond Myklebust6739ffb2013-08-26 15:38:11 -0400401 rpc_init_pipe_dir_head(&clnt->cl_pipedir_objects);
Trond Myklebust23bf85b2006-11-21 10:40:23 -0500402 err = -ENOMEM;
403 if (clnt->cl_metrics == NULL)
404 goto out_no_stats;
Trond Myklebust3e32a5d2006-11-16 11:37:27 -0500405 clnt->cl_program = program;
Trond Myklebust6529eba2007-06-14 16:40:14 -0400406 INIT_LIST_HEAD(&clnt->cl_tasks);
Trond Myklebust4bef61f2007-06-16 14:17:01 -0400407 spin_lock_init(&clnt->cl_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700408
Trond Myklebust40b00b6b2013-10-17 14:12:23 -0400409 timeout = xprt->timeout;
Trond Myklebustba7392b2007-12-20 16:03:55 -0500410 if (args->timeout != NULL) {
411 memcpy(&clnt->cl_timeout_default, args->timeout,
412 sizeof(clnt->cl_timeout_default));
Trond Myklebust40b00b6b2013-10-17 14:12:23 -0400413 timeout = &clnt->cl_timeout_default;
Trond Myklebustba7392b2007-12-20 16:03:55 -0500414 }
415
Trond Myklebust40b00b6b2013-10-17 14:12:23 -0400416 rpc_clnt_set_transport(clnt, xprt, timeout);
417
Linus Torvalds1da177e2005-04-16 15:20:36 -0700418 clnt->cl_rtt = &clnt->cl_rtt_default;
Trond Myklebustba7392b2007-12-20 16:03:55 -0500419 rpc_init_rtt(&clnt->cl_rtt_default, clnt->cl_timeout->to_initval);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700420
Trond Myklebust006abe82010-09-12 19:55:25 -0400421 atomic_set(&clnt->cl_count, 1);
Trond Myklebust34f52e32007-06-14 16:40:31 -0400422
Linus Torvalds1da177e2005-04-16 15:20:36 -0700423 /* save the nodename */
Trond Myklebustcbbb3442012-04-30 11:52:40 -0400424 rpc_clnt_set_nodename(clnt, utsname()->nodename);
Stanislav Kinsburskye73f4cc2013-06-24 11:52:52 +0400425
Chuck Leverd746e542013-10-17 14:12:17 -0400426 err = rpc_client_register(clnt, args->authflavor, args->client_name);
Stanislav Kinsburskye73f4cc2013-06-24 11:52:52 +0400427 if (err)
428 goto out_no_path;
Trond Myklebust280ebcf2013-09-02 13:28:04 -0400429 if (parent)
430 atomic_inc(&parent->cl_count);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700431 return clnt;
432
Linus Torvalds1da177e2005-04-16 15:20:36 -0700433out_no_path:
Trond Myklebust23bf85b2006-11-21 10:40:23 -0500434 rpc_free_iostats(clnt->cl_metrics);
435out_no_stats:
Trond Myklebust2f048db2013-09-04 21:51:44 -0400436 rpc_free_clid(clnt);
437out_no_clid:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700438 kfree(clnt);
439out_err:
Trond Myklebust4ada5392007-06-14 17:26:17 -0400440 rpciod_down();
441out_no_rpciod:
Trond Myklebustf05c1242013-04-05 14:13:21 -0400442 xprt_put(xprt);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700443 return ERR_PTR(err);
444}
445
Kinglong Mee83ddfeb2014-03-24 11:58:59 +0800446struct rpc_clnt *rpc_create_xprt(struct rpc_create_args *args,
447 struct rpc_xprt *xprt)
448{
449 struct rpc_clnt *clnt = NULL;
450
451 clnt = rpc_new_client(args, xprt, NULL);
452 if (IS_ERR(clnt))
453 return clnt;
454
455 if (!(args->flags & RPC_CLNT_CREATE_NOPING)) {
456 int err = rpc_ping(clnt);
457 if (err != 0) {
458 rpc_shutdown_client(clnt);
459 return ERR_PTR(err);
460 }
461 }
462
463 clnt->cl_softrtry = 1;
464 if (args->flags & RPC_CLNT_CREATE_HARDRTRY)
465 clnt->cl_softrtry = 0;
466
467 if (args->flags & RPC_CLNT_CREATE_AUTOBIND)
468 clnt->cl_autobind = 1;
Trond Myklebust2aca5b82014-09-24 22:35:58 -0400469 if (args->flags & RPC_CLNT_CREATE_NO_RETRANS_TIMEOUT)
470 clnt->cl_noretranstimeo = 1;
Kinglong Mee83ddfeb2014-03-24 11:58:59 +0800471 if (args->flags & RPC_CLNT_CREATE_DISCRTRY)
472 clnt->cl_discrtry = 1;
473 if (!(args->flags & RPC_CLNT_CREATE_QUIET))
474 clnt->cl_chatty = 1;
475
476 return clnt;
477}
478EXPORT_SYMBOL_GPL(rpc_create_xprt);
479
Ben Hutchings2c530402012-07-10 10:55:09 +0000480/**
Chuck Leverc2866762006-08-22 20:06:20 -0400481 * rpc_create - create an RPC client and transport with one call
482 * @args: rpc_clnt create argument structure
483 *
484 * Creates and initializes an RPC transport and an RPC client.
485 *
486 * It can ping the server in order to determine if it is up, and to see if
487 * it supports this program and version. RPC_CLNT_CREATE_NOPING disables
488 * this behavior so asynchronous tasks can also use rpc_create.
489 */
490struct rpc_clnt *rpc_create(struct rpc_create_args *args)
491{
492 struct rpc_xprt *xprt;
\"Talpey, Thomas\3c341b0b2007-09-10 13:47:07 -0400493 struct xprt_create xprtargs = {
Pavel Emelyanov9a23e332010-09-29 16:05:12 +0400494 .net = args->net,
\"Talpey, Thomas\4fa016e2007-09-10 13:47:57 -0400495 .ident = args->protocol,
Frank van Maarseveend3bc9a12007-07-09 22:23:35 +0200496 .srcaddr = args->saddress,
Frank van Maarseveen96802a02007-07-08 13:08:54 +0200497 .dstaddr = args->address,
498 .addrlen = args->addrsize,
Trond Myklebust4e0038b2012-03-01 17:01:05 -0500499 .servername = args->servername,
Alexandros Batsakisf300bab2009-09-10 17:33:30 +0300500 .bc_xprt = args->bc_xprt,
Frank van Maarseveen96802a02007-07-08 13:08:54 +0200501 };
Chuck Lever510deb02007-12-10 14:56:24 -0500502 char servername[48];
Chuck Leverc2866762006-08-22 20:06:20 -0400503
Trond Myklebustb7993ce2013-04-14 11:42:00 -0400504 if (args->flags & RPC_CLNT_CREATE_INFINITE_SLOTS)
505 xprtargs.flags |= XPRT_CREATE_INFINITE_SLOTS;
J. Bruce Fields33d90ac2013-04-11 15:06:36 -0400506 if (args->flags & RPC_CLNT_CREATE_NO_IDLE_TIMEOUT)
507 xprtargs.flags |= XPRT_CREATE_NO_IDLE_TIMEOUT;
Chuck Leverc2866762006-08-22 20:06:20 -0400508 /*
Chuck Lever43780b82007-07-01 12:13:22 -0400509 * If the caller chooses not to specify a hostname, whip
510 * up a string representation of the passed-in address.
511 */
Trond Myklebust4e0038b2012-03-01 17:01:05 -0500512 if (xprtargs.servername == NULL) {
Chuck Lever176e21e2011-05-09 15:22:44 -0400513 struct sockaddr_un *sun =
514 (struct sockaddr_un *)args->address;
Chuck Leverda09eb92011-05-09 15:22:25 -0400515 struct sockaddr_in *sin =
516 (struct sockaddr_in *)args->address;
517 struct sockaddr_in6 *sin6 =
518 (struct sockaddr_in6 *)args->address;
519
Chuck Lever510deb02007-12-10 14:56:24 -0500520 servername[0] = '\0';
521 switch (args->address->sa_family) {
Chuck Lever176e21e2011-05-09 15:22:44 -0400522 case AF_LOCAL:
523 snprintf(servername, sizeof(servername), "%s",
524 sun->sun_path);
525 break;
Chuck Leverda09eb92011-05-09 15:22:25 -0400526 case AF_INET:
Harvey Harrison21454aa2008-10-31 00:54:56 -0700527 snprintf(servername, sizeof(servername), "%pI4",
528 &sin->sin_addr.s_addr);
Chuck Lever510deb02007-12-10 14:56:24 -0500529 break;
Chuck Leverda09eb92011-05-09 15:22:25 -0400530 case AF_INET6:
Harvey Harrison5b095d9892008-10-29 12:52:50 -0700531 snprintf(servername, sizeof(servername), "%pI6",
Chuck Leverda09eb92011-05-09 15:22:25 -0400532 &sin6->sin6_addr);
Chuck Lever510deb02007-12-10 14:56:24 -0500533 break;
Chuck Lever510deb02007-12-10 14:56:24 -0500534 default:
535 /* caller wants default server name, but
536 * address family isn't recognized. */
537 return ERR_PTR(-EINVAL);
538 }
Trond Myklebust4e0038b2012-03-01 17:01:05 -0500539 xprtargs.servername = servername;
Chuck Lever43780b82007-07-01 12:13:22 -0400540 }
541
Chuck Lever510deb02007-12-10 14:56:24 -0500542 xprt = xprt_create_transport(&xprtargs);
543 if (IS_ERR(xprt))
544 return (struct rpc_clnt *)xprt;
545
Chuck Lever43780b82007-07-01 12:13:22 -0400546 /*
Chuck Leverc2866762006-08-22 20:06:20 -0400547 * By default, kernel RPC client connects from a reserved port.
548 * CAP_NET_BIND_SERVICE will not be set for unprivileged requesters,
549 * but it is always enabled for rpciod, which handles the connect
550 * operation.
551 */
552 xprt->resvport = 1;
553 if (args->flags & RPC_CLNT_CREATE_NONPRIVPORT)
554 xprt->resvport = 0;
555
Kinglong Mee83ddfeb2014-03-24 11:58:59 +0800556 return rpc_create_xprt(args, xprt);
Chuck Leverc2866762006-08-22 20:06:20 -0400557}
Chuck Leverb86acd52006-08-22 20:06:22 -0400558EXPORT_SYMBOL_GPL(rpc_create);
Chuck Leverc2866762006-08-22 20:06:20 -0400559
Linus Torvalds1da177e2005-04-16 15:20:36 -0700560/*
561 * This function clones the RPC client structure. It allows us to share the
562 * same transport while varying parameters such as the authentication
563 * flavour.
564 */
Chuck Lever1b63a752012-09-14 17:23:52 -0400565static struct rpc_clnt *__rpc_clone_client(struct rpc_create_args *args,
566 struct rpc_clnt *clnt)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700567{
Trond Myklebust2446ab62012-03-01 17:00:56 -0500568 struct rpc_xprt *xprt;
Chuck Lever1b63a752012-09-14 17:23:52 -0400569 struct rpc_clnt *new;
570 int err;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700571
Chuck Lever1b63a752012-09-14 17:23:52 -0400572 err = -ENOMEM;
Trond Myklebust2446ab62012-03-01 17:00:56 -0500573 rcu_read_lock();
574 xprt = xprt_get(rcu_dereference(clnt->cl_xprt));
575 rcu_read_unlock();
576 if (xprt == NULL)
Chuck Lever1b63a752012-09-14 17:23:52 -0400577 goto out_err;
578 args->servername = xprt->servername;
579
Trond Myklebust280ebcf2013-09-02 13:28:04 -0400580 new = rpc_new_client(args, xprt, clnt);
Chuck Lever1b63a752012-09-14 17:23:52 -0400581 if (IS_ERR(new)) {
582 err = PTR_ERR(new);
Chuck Levera58e0be2013-03-22 12:52:59 -0400583 goto out_err;
Chuck Lever1b63a752012-09-14 17:23:52 -0400584 }
585
Chuck Lever1b63a752012-09-14 17:23:52 -0400586 /* Turn off autobind on clones */
587 new->cl_autobind = 0;
588 new->cl_softrtry = clnt->cl_softrtry;
Trond Myklebust2aca5b82014-09-24 22:35:58 -0400589 new->cl_noretranstimeo = clnt->cl_noretranstimeo;
Chuck Lever1b63a752012-09-14 17:23:52 -0400590 new->cl_discrtry = clnt->cl_discrtry;
591 new->cl_chatty = clnt->cl_chatty;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700592 return new;
Chuck Lever1b63a752012-09-14 17:23:52 -0400593
Chuck Lever1b63a752012-09-14 17:23:52 -0400594out_err:
Harvey Harrison0dc47872008-03-05 20:47:47 -0800595 dprintk("RPC: %s: returned error %d\n", __func__, err);
Trond Myklebust3e32a5d2006-11-16 11:37:27 -0500596 return ERR_PTR(err);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700597}
Chuck Lever1b63a752012-09-14 17:23:52 -0400598
599/**
600 * rpc_clone_client - Clone an RPC client structure
601 *
602 * @clnt: RPC client whose parameters are copied
603 *
604 * Returns a fresh RPC client or an ERR_PTR.
605 */
606struct rpc_clnt *rpc_clone_client(struct rpc_clnt *clnt)
607{
608 struct rpc_create_args args = {
609 .program = clnt->cl_program,
610 .prognumber = clnt->cl_prog,
611 .version = clnt->cl_vers,
612 .authflavor = clnt->cl_auth->au_flavor,
Chuck Lever1b63a752012-09-14 17:23:52 -0400613 };
614 return __rpc_clone_client(&args, clnt);
615}
Trond Myklebuste8914c62007-07-14 15:39:59 -0400616EXPORT_SYMBOL_GPL(rpc_clone_client);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700617
Chuck Leverba9b5842012-09-14 17:24:02 -0400618/**
619 * rpc_clone_client_set_auth - Clone an RPC client structure and set its auth
620 *
621 * @clnt: RPC client whose parameters are copied
Randy Dunlap7144bca2013-01-09 17:12:35 -0800622 * @flavor: security flavor for new client
Chuck Leverba9b5842012-09-14 17:24:02 -0400623 *
624 * Returns a fresh RPC client or an ERR_PTR.
625 */
626struct rpc_clnt *
627rpc_clone_client_set_auth(struct rpc_clnt *clnt, rpc_authflavor_t flavor)
628{
629 struct rpc_create_args args = {
630 .program = clnt->cl_program,
631 .prognumber = clnt->cl_prog,
632 .version = clnt->cl_vers,
633 .authflavor = flavor,
Chuck Leverba9b5842012-09-14 17:24:02 -0400634 };
635 return __rpc_clone_client(&args, clnt);
636}
637EXPORT_SYMBOL_GPL(rpc_clone_client_set_auth);
638
Trond Myklebust40b00b6b2013-10-17 14:12:23 -0400639/**
640 * rpc_switch_client_transport: switch the RPC transport on the fly
641 * @clnt: pointer to a struct rpc_clnt
642 * @args: pointer to the new transport arguments
643 * @timeout: pointer to the new timeout parameters
644 *
645 * This function allows the caller to switch the RPC transport for the
646 * rpc_clnt structure 'clnt' to allow it to connect to a mirrored NFS
647 * server, for instance. It assumes that the caller has ensured that
648 * there are no active RPC tasks by using some form of locking.
649 *
650 * Returns zero if "clnt" is now using the new xprt. Otherwise a
651 * negative errno is returned, and "clnt" continues to use the old
652 * xprt.
653 */
654int rpc_switch_client_transport(struct rpc_clnt *clnt,
655 struct xprt_create *args,
656 const struct rpc_timeout *timeout)
657{
658 const struct rpc_timeout *old_timeo;
659 rpc_authflavor_t pseudoflavor;
660 struct rpc_xprt *xprt, *old;
661 struct rpc_clnt *parent;
662 int err;
663
664 xprt = xprt_create_transport(args);
665 if (IS_ERR(xprt)) {
666 dprintk("RPC: failed to create new xprt for clnt %p\n",
667 clnt);
668 return PTR_ERR(xprt);
669 }
670
671 pseudoflavor = clnt->cl_auth->au_flavor;
672
673 old_timeo = clnt->cl_timeout;
674 old = rpc_clnt_set_transport(clnt, xprt, timeout);
675
676 rpc_unregister_client(clnt);
677 __rpc_clnt_remove_pipedir(clnt);
Jeff Laytonb4b9d2c2014-11-26 14:44:43 -0500678 rpc_clnt_debugfs_unregister(clnt);
Trond Myklebust40b00b6b2013-10-17 14:12:23 -0400679
680 /*
681 * A new transport was created. "clnt" therefore
682 * becomes the root of a new cl_parent tree. clnt's
683 * children, if it has any, still point to the old xprt.
684 */
685 parent = clnt->cl_parent;
686 clnt->cl_parent = clnt;
687
688 /*
689 * The old rpc_auth cache cannot be re-used. GSS
690 * contexts in particular are between a single
691 * client and server.
692 */
693 err = rpc_client_register(clnt, pseudoflavor, NULL);
694 if (err)
695 goto out_revert;
696
697 synchronize_rcu();
698 if (parent != clnt)
699 rpc_release_client(parent);
700 xprt_put(old);
701 dprintk("RPC: replaced xprt for clnt %p\n", clnt);
702 return 0;
703
704out_revert:
705 rpc_clnt_set_transport(clnt, old, old_timeo);
706 clnt->cl_parent = parent;
707 rpc_client_register(clnt, pseudoflavor, NULL);
708 xprt_put(xprt);
709 dprintk("RPC: failed to switch xprt for clnt %p\n", clnt);
710 return err;
711}
712EXPORT_SYMBOL_GPL(rpc_switch_client_transport);
713
Linus Torvalds1da177e2005-04-16 15:20:36 -0700714/*
Trond Myklebust58f96122010-07-31 14:29:08 -0400715 * Kill all tasks for the given client.
716 * XXX: kill their descendants as well?
717 */
718void rpc_killall_tasks(struct rpc_clnt *clnt)
719{
720 struct rpc_task *rovr;
721
722
723 if (list_empty(&clnt->cl_tasks))
724 return;
725 dprintk("RPC: killing all tasks for client %p\n", clnt);
726 /*
727 * Spin lock all_tasks to prevent changes...
728 */
729 spin_lock(&clnt->cl_lock);
730 list_for_each_entry(rovr, &clnt->cl_tasks, tk_task) {
731 if (!RPC_IS_ACTIVATED(rovr))
732 continue;
733 if (!(rovr->tk_flags & RPC_TASK_KILLED)) {
734 rovr->tk_flags |= RPC_TASK_KILLED;
735 rpc_exit(rovr, -EIO);
Stanislav Kinsbursky8e26de22011-03-17 18:54:23 +0300736 if (RPC_IS_QUEUED(rovr))
737 rpc_wake_up_queued_task(rovr->tk_waitqueue,
738 rovr);
Trond Myklebust58f96122010-07-31 14:29:08 -0400739 }
740 }
741 spin_unlock(&clnt->cl_lock);
742}
743EXPORT_SYMBOL_GPL(rpc_killall_tasks);
744
745/*
Linus Torvalds1da177e2005-04-16 15:20:36 -0700746 * Properly shut down an RPC client, terminating all outstanding
Trond Myklebust90c57552007-06-09 19:49:36 -0400747 * requests.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700748 */
Trond Myklebust4c402b42007-06-14 16:40:32 -0400749void rpc_shutdown_client(struct rpc_clnt *clnt)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700750{
Weston Andros Adamson168e4b32012-10-30 17:01:40 -0400751 might_sleep();
752
Trond Myklebust4e0038b2012-03-01 17:01:05 -0500753 dprintk_rcu("RPC: shutting down %s client for %s\n",
Trond Myklebust55909f22013-08-23 11:48:15 -0400754 clnt->cl_program->name,
Trond Myklebust4e0038b2012-03-01 17:01:05 -0500755 rcu_dereference(clnt->cl_xprt)->servername);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700756
Trond Myklebust34f52e32007-06-14 16:40:31 -0400757 while (!list_empty(&clnt->cl_tasks)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700758 rpc_killall_tasks(clnt);
Ingo Molnar532347e2006-01-09 20:52:53 -0800759 wait_event_timeout(destroy_wait,
Trond Myklebust34f52e32007-06-14 16:40:31 -0400760 list_empty(&clnt->cl_tasks), 1*HZ);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700761 }
762
Trond Myklebust4c402b42007-06-14 16:40:32 -0400763 rpc_release_client(clnt);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700764}
Trond Myklebuste8914c62007-07-14 15:39:59 -0400765EXPORT_SYMBOL_GPL(rpc_shutdown_client);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700766
767/*
Trond Myklebust34f52e32007-06-14 16:40:31 -0400768 * Free an RPC client
Linus Torvalds1da177e2005-04-16 15:20:36 -0700769 */
Trond Myklebustd07ba842013-11-12 17:24:36 -0500770static struct rpc_clnt *
Trond Myklebust006abe82010-09-12 19:55:25 -0400771rpc_free_client(struct rpc_clnt *clnt)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700772{
Trond Myklebustd07ba842013-11-12 17:24:36 -0500773 struct rpc_clnt *parent = NULL;
774
Trond Myklebust4e0038b2012-03-01 17:01:05 -0500775 dprintk_rcu("RPC: destroying %s client for %s\n",
Trond Myklebust55909f22013-08-23 11:48:15 -0400776 clnt->cl_program->name,
Trond Myklebust4e0038b2012-03-01 17:01:05 -0500777 rcu_dereference(clnt->cl_xprt)->servername);
Trond Myklebust6eac7d32012-01-20 13:53:37 -0500778 if (clnt->cl_parent != clnt)
Trond Myklebustd07ba842013-11-12 17:24:36 -0500779 parent = clnt->cl_parent;
Jeff Laytonb4b9d2c2014-11-26 14:44:43 -0500780 rpc_clnt_debugfs_unregister(clnt);
Stanislav Kinsburskyf5131252012-01-11 19:18:26 +0400781 rpc_clnt_remove_pipedir(clnt);
Stanislav Kinsburskyadb6fa72013-06-26 10:15:14 +0400782 rpc_unregister_client(clnt);
Chuck Lever11c556b2006-03-20 13:44:22 -0500783 rpc_free_iostats(clnt->cl_metrics);
784 clnt->cl_metrics = NULL;
Trond Myklebust2446ab62012-03-01 17:00:56 -0500785 xprt_put(rcu_dereference_raw(clnt->cl_xprt));
Trond Myklebust4ada5392007-06-14 17:26:17 -0400786 rpciod_down();
Trond Myklebust2f048db2013-09-04 21:51:44 -0400787 rpc_free_clid(clnt);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700788 kfree(clnt);
Trond Myklebustd07ba842013-11-12 17:24:36 -0500789 return parent;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700790}
791
792/*
Trond Myklebust1dd17ec2007-06-26 16:57:41 -0400793 * Free an RPC client
794 */
Trond Myklebustd07ba842013-11-12 17:24:36 -0500795static struct rpc_clnt *
Trond Myklebust006abe82010-09-12 19:55:25 -0400796rpc_free_auth(struct rpc_clnt *clnt)
Trond Myklebust1dd17ec2007-06-26 16:57:41 -0400797{
Trond Myklebustd07ba842013-11-12 17:24:36 -0500798 if (clnt->cl_auth == NULL)
799 return rpc_free_client(clnt);
Trond Myklebust1dd17ec2007-06-26 16:57:41 -0400800
801 /*
802 * Note: RPCSEC_GSS may need to send NULL RPC calls in order to
803 * release remaining GSS contexts. This mechanism ensures
804 * that it can do so safely.
805 */
Trond Myklebust006abe82010-09-12 19:55:25 -0400806 atomic_inc(&clnt->cl_count);
Trond Myklebust1dd17ec2007-06-26 16:57:41 -0400807 rpcauth_release(clnt->cl_auth);
808 clnt->cl_auth = NULL;
Trond Myklebust006abe82010-09-12 19:55:25 -0400809 if (atomic_dec_and_test(&clnt->cl_count))
Trond Myklebustd07ba842013-11-12 17:24:36 -0500810 return rpc_free_client(clnt);
811 return NULL;
Trond Myklebust1dd17ec2007-06-26 16:57:41 -0400812}
813
814/*
Trond Myklebust34f52e32007-06-14 16:40:31 -0400815 * Release reference to the RPC client
Linus Torvalds1da177e2005-04-16 15:20:36 -0700816 */
817void
818rpc_release_client(struct rpc_clnt *clnt)
819{
Trond Myklebust34f52e32007-06-14 16:40:31 -0400820 dprintk("RPC: rpc_release_client(%p)\n", clnt);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700821
Trond Myklebustd07ba842013-11-12 17:24:36 -0500822 do {
823 if (list_empty(&clnt->cl_tasks))
824 wake_up(&destroy_wait);
825 if (!atomic_dec_and_test(&clnt->cl_count))
826 break;
827 clnt = rpc_free_auth(clnt);
828 } while (clnt != NULL);
Trond Myklebust34f52e32007-06-14 16:40:31 -0400829}
Simo Sorce1d658332012-05-25 18:09:55 -0400830EXPORT_SYMBOL_GPL(rpc_release_client);
Trond Myklebust34f52e32007-06-14 16:40:31 -0400831
Andreas Gruenbacher007e2512005-06-22 17:16:23 +0000832/**
833 * rpc_bind_new_program - bind a new RPC program to an existing client
Randy Dunlap65b6e422008-02-13 15:03:23 -0800834 * @old: old rpc_client
835 * @program: rpc program to set
836 * @vers: rpc program version
Andreas Gruenbacher007e2512005-06-22 17:16:23 +0000837 *
838 * Clones the rpc client and sets up a new RPC program. This is mainly
839 * of use for enabling different RPC programs to share the same transport.
840 * The Sun NFSv2/v3 ACL protocol can do this.
841 */
842struct rpc_clnt *rpc_bind_new_program(struct rpc_clnt *old,
Trond Myklebusta613fa12012-01-20 13:53:56 -0500843 const struct rpc_program *program,
Chuck Lever89eb21c2007-09-11 18:00:09 -0400844 u32 vers)
Andreas Gruenbacher007e2512005-06-22 17:16:23 +0000845{
Trond Myklebustf994c432012-11-01 12:14:14 -0400846 struct rpc_create_args args = {
847 .program = program,
848 .prognumber = program->number,
849 .version = vers,
850 .authflavor = old->cl_auth->au_flavor,
Trond Myklebustf994c432012-11-01 12:14:14 -0400851 };
Andreas Gruenbacher007e2512005-06-22 17:16:23 +0000852 struct rpc_clnt *clnt;
Andreas Gruenbacher007e2512005-06-22 17:16:23 +0000853 int err;
854
Trond Myklebustf994c432012-11-01 12:14:14 -0400855 clnt = __rpc_clone_client(&args, old);
Andreas Gruenbacher007e2512005-06-22 17:16:23 +0000856 if (IS_ERR(clnt))
857 goto out;
Chuck Levercaabea82009-12-03 15:58:56 -0500858 err = rpc_ping(clnt);
Andreas Gruenbacher007e2512005-06-22 17:16:23 +0000859 if (err != 0) {
860 rpc_shutdown_client(clnt);
861 clnt = ERR_PTR(err);
862 }
YOSHIFUJI Hideakicca51722007-02-09 15:38:13 -0800863out:
Andreas Gruenbacher007e2512005-06-22 17:16:23 +0000864 return clnt;
865}
Trond Myklebuste8914c62007-07-14 15:39:59 -0400866EXPORT_SYMBOL_GPL(rpc_bind_new_program);
Andreas Gruenbacher007e2512005-06-22 17:16:23 +0000867
Trond Myklebust58f96122010-07-31 14:29:08 -0400868void rpc_task_release_client(struct rpc_task *task)
869{
870 struct rpc_clnt *clnt = task->tk_client;
871
872 if (clnt != NULL) {
873 /* Remove from client task list */
874 spin_lock(&clnt->cl_lock);
875 list_del(&task->tk_task);
876 spin_unlock(&clnt->cl_lock);
877 task->tk_client = NULL;
878
879 rpc_release_client(clnt);
880 }
881}
882
883static
884void rpc_task_set_client(struct rpc_task *task, struct rpc_clnt *clnt)
885{
886 if (clnt != NULL) {
887 rpc_task_release_client(task);
888 task->tk_client = clnt;
Trond Myklebust006abe82010-09-12 19:55:25 -0400889 atomic_inc(&clnt->cl_count);
Trond Myklebust58f96122010-07-31 14:29:08 -0400890 if (clnt->cl_softrtry)
891 task->tk_flags |= RPC_TASK_SOFT;
Trond Myklebust8a19a0b2013-09-24 12:00:27 -0400892 if (clnt->cl_noretranstimeo)
893 task->tk_flags |= RPC_TASK_NO_RETRANS_TIMEOUT;
Mel Gormana564b8f2012-07-31 16:45:12 -0700894 if (sk_memalloc_socks()) {
895 struct rpc_xprt *xprt;
896
897 rcu_read_lock();
898 xprt = rcu_dereference(clnt->cl_xprt);
899 if (xprt->swapper)
900 task->tk_flags |= RPC_TASK_SWAPPER;
901 rcu_read_unlock();
902 }
Trond Myklebust58f96122010-07-31 14:29:08 -0400903 /* Add to the client's list of all tasks */
904 spin_lock(&clnt->cl_lock);
905 list_add_tail(&task->tk_task, &clnt->cl_tasks);
906 spin_unlock(&clnt->cl_lock);
907 }
908}
909
Andy Adamsoncbdabc7f2011-03-01 01:34:20 +0000910void rpc_task_reset_client(struct rpc_task *task, struct rpc_clnt *clnt)
911{
912 rpc_task_release_client(task);
913 rpc_task_set_client(task, clnt);
914}
915EXPORT_SYMBOL_GPL(rpc_task_reset_client);
916
917
Trond Myklebust58f96122010-07-31 14:29:08 -0400918static void
919rpc_task_set_rpc_message(struct rpc_task *task, const struct rpc_message *msg)
920{
921 if (msg != NULL) {
922 task->tk_msg.rpc_proc = msg->rpc_proc;
923 task->tk_msg.rpc_argp = msg->rpc_argp;
924 task->tk_msg.rpc_resp = msg->rpc_resp;
Trond Myklebusta17c2152010-07-31 14:29:08 -0400925 if (msg->rpc_cred != NULL)
926 task->tk_msg.rpc_cred = get_rpccred(msg->rpc_cred);
Trond Myklebust58f96122010-07-31 14:29:08 -0400927 }
928}
929
Linus Torvalds1da177e2005-04-16 15:20:36 -0700930/*
931 * Default callback for async RPC calls
932 */
933static void
Trond Myklebust963d8fe2006-01-03 09:55:04 +0100934rpc_default_callback(struct rpc_task *task, void *data)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700935{
936}
937
Trond Myklebust963d8fe2006-01-03 09:55:04 +0100938static const struct rpc_call_ops rpc_default_ops = {
939 .rpc_call_done = rpc_default_callback,
940};
941
Trond Myklebustc970aa82007-07-14 15:39:59 -0400942/**
943 * rpc_run_task - Allocate a new RPC task, then run rpc_execute against it
944 * @task_setup_data: pointer to task initialisation data
945 */
946struct rpc_task *rpc_run_task(const struct rpc_task_setup *task_setup_data)
Trond Myklebust6e5b70e2007-06-12 10:02:37 -0400947{
Trond Myklebust19445b92010-04-16 16:41:10 -0400948 struct rpc_task *task;
Trond Myklebust6e5b70e2007-06-12 10:02:37 -0400949
Trond Myklebust84115e12007-07-14 15:39:59 -0400950 task = rpc_new_task(task_setup_data);
Trond Myklebust19445b92010-04-16 16:41:10 -0400951 if (IS_ERR(task))
Trond Myklebust50859252007-10-25 18:19:37 -0400952 goto out;
Trond Myklebust6e5b70e2007-06-12 10:02:37 -0400953
Trond Myklebust58f96122010-07-31 14:29:08 -0400954 rpc_task_set_client(task, task_setup_data->rpc_client);
955 rpc_task_set_rpc_message(task, task_setup_data->rpc_message);
956
Trond Myklebust58f96122010-07-31 14:29:08 -0400957 if (task->tk_action == NULL)
958 rpc_call_start(task);
959
Trond Myklebust6e5b70e2007-06-12 10:02:37 -0400960 atomic_inc(&task->tk_count);
961 rpc_execute(task);
Trond Myklebust6e5b70e2007-06-12 10:02:37 -0400962out:
Trond Myklebust19445b92010-04-16 16:41:10 -0400963 return task;
Trond Myklebust6e5b70e2007-06-12 10:02:37 -0400964}
Trond Myklebustc970aa82007-07-14 15:39:59 -0400965EXPORT_SYMBOL_GPL(rpc_run_task);
Trond Myklebust6e5b70e2007-06-12 10:02:37 -0400966
967/**
968 * rpc_call_sync - Perform a synchronous RPC call
969 * @clnt: pointer to RPC client
970 * @msg: RPC call parameters
971 * @flags: RPC call flags
Linus Torvalds1da177e2005-04-16 15:20:36 -0700972 */
Trond Myklebustcbc20052008-02-14 11:11:30 -0500973int rpc_call_sync(struct rpc_clnt *clnt, const struct rpc_message *msg, int flags)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700974{
975 struct rpc_task *task;
Trond Myklebust84115e12007-07-14 15:39:59 -0400976 struct rpc_task_setup task_setup_data = {
977 .rpc_client = clnt,
978 .rpc_message = msg,
979 .callback_ops = &rpc_default_ops,
980 .flags = flags,
981 };
Trond Myklebust6e5b70e2007-06-12 10:02:37 -0400982 int status;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700983
Weston Andros Adamson50d2bdb2012-11-01 16:04:40 -0400984 WARN_ON_ONCE(flags & RPC_TASK_ASYNC);
985 if (flags & RPC_TASK_ASYNC) {
986 rpc_release_calldata(task_setup_data.callback_ops,
987 task_setup_data.callback_data);
988 return -EINVAL;
989 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700990
Trond Myklebustc970aa82007-07-14 15:39:59 -0400991 task = rpc_run_task(&task_setup_data);
Trond Myklebust6e5b70e2007-06-12 10:02:37 -0400992 if (IS_ERR(task))
993 return PTR_ERR(task);
Trond Myklebuste60859a2006-01-03 09:55:10 +0100994 status = task->tk_status;
Trond Myklebustbde8f002007-01-24 11:54:53 -0800995 rpc_put_task(task);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700996 return status;
997}
Trond Myklebuste8914c62007-07-14 15:39:59 -0400998EXPORT_SYMBOL_GPL(rpc_call_sync);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700999
Trond Myklebust6e5b70e2007-06-12 10:02:37 -04001000/**
1001 * rpc_call_async - Perform an asynchronous RPC call
1002 * @clnt: pointer to RPC client
1003 * @msg: RPC call parameters
1004 * @flags: RPC call flags
Randy Dunlap65b6e422008-02-13 15:03:23 -08001005 * @tk_ops: RPC call ops
Trond Myklebust6e5b70e2007-06-12 10:02:37 -04001006 * @data: user call data
Linus Torvalds1da177e2005-04-16 15:20:36 -07001007 */
1008int
Trond Myklebustcbc20052008-02-14 11:11:30 -05001009rpc_call_async(struct rpc_clnt *clnt, const struct rpc_message *msg, int flags,
Trond Myklebust963d8fe2006-01-03 09:55:04 +01001010 const struct rpc_call_ops *tk_ops, void *data)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001011{
1012 struct rpc_task *task;
Trond Myklebust84115e12007-07-14 15:39:59 -04001013 struct rpc_task_setup task_setup_data = {
1014 .rpc_client = clnt,
1015 .rpc_message = msg,
1016 .callback_ops = tk_ops,
1017 .callback_data = data,
1018 .flags = flags|RPC_TASK_ASYNC,
1019 };
Linus Torvalds1da177e2005-04-16 15:20:36 -07001020
Trond Myklebustc970aa82007-07-14 15:39:59 -04001021 task = rpc_run_task(&task_setup_data);
Trond Myklebust6e5b70e2007-06-12 10:02:37 -04001022 if (IS_ERR(task))
1023 return PTR_ERR(task);
1024 rpc_put_task(task);
1025 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001026}
Trond Myklebuste8914c62007-07-14 15:39:59 -04001027EXPORT_SYMBOL_GPL(rpc_call_async);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001028
Trond Myklebust9e00abc2011-07-13 19:20:49 -04001029#if defined(CONFIG_SUNRPC_BACKCHANNEL)
Ricardo Labiaga55ae1aa2009-04-01 09:23:03 -04001030/**
1031 * rpc_run_bc_task - Allocate a new RPC task for backchannel use, then run
1032 * rpc_execute against it
Jaswinder Singh Rajput7a73fdd2009-09-24 14:58:42 -04001033 * @req: RPC request
1034 * @tk_ops: RPC call ops
Ricardo Labiaga55ae1aa2009-04-01 09:23:03 -04001035 */
1036struct rpc_task *rpc_run_bc_task(struct rpc_rqst *req,
Jaswinder Singh Rajput7a73fdd2009-09-24 14:58:42 -04001037 const struct rpc_call_ops *tk_ops)
Ricardo Labiaga55ae1aa2009-04-01 09:23:03 -04001038{
1039 struct rpc_task *task;
1040 struct xdr_buf *xbufp = &req->rq_snd_buf;
1041 struct rpc_task_setup task_setup_data = {
1042 .callback_ops = tk_ops,
1043 };
1044
1045 dprintk("RPC: rpc_run_bc_task req= %p\n", req);
1046 /*
1047 * Create an rpc_task to send the data
1048 */
1049 task = rpc_new_task(&task_setup_data);
Trond Myklebust19445b92010-04-16 16:41:10 -04001050 if (IS_ERR(task)) {
Ricardo Labiaga55ae1aa2009-04-01 09:23:03 -04001051 xprt_free_bc_request(req);
1052 goto out;
1053 }
1054 task->tk_rqstp = req;
1055
1056 /*
1057 * Set up the xdr_buf length.
1058 * This also indicates that the buffer is XDR encoded already.
1059 */
1060 xbufp->len = xbufp->head[0].iov_len + xbufp->page_len +
1061 xbufp->tail[0].iov_len;
1062
1063 task->tk_action = call_bc_transmit;
1064 atomic_inc(&task->tk_count);
Weston Andros Adamson9a6478f2012-10-23 10:43:27 -04001065 WARN_ON_ONCE(atomic_read(&task->tk_count) != 2);
Ricardo Labiaga55ae1aa2009-04-01 09:23:03 -04001066 rpc_execute(task);
1067
1068out:
1069 dprintk("RPC: rpc_run_bc_task: task= %p\n", task);
1070 return task;
1071}
Trond Myklebust9e00abc2011-07-13 19:20:49 -04001072#endif /* CONFIG_SUNRPC_BACKCHANNEL */
Ricardo Labiaga55ae1aa2009-04-01 09:23:03 -04001073
Linus Torvalds1da177e2005-04-16 15:20:36 -07001074void
Trond Myklebust77de2c52007-10-25 18:40:21 -04001075rpc_call_start(struct rpc_task *task)
1076{
1077 task->tk_action = call_start;
1078}
1079EXPORT_SYMBOL_GPL(rpc_call_start);
1080
Chuck Levered394402006-08-22 20:06:17 -04001081/**
1082 * rpc_peeraddr - extract remote peer address from clnt's xprt
1083 * @clnt: RPC client structure
1084 * @buf: target buffer
Randy Dunlap65b6e422008-02-13 15:03:23 -08001085 * @bufsize: length of target buffer
Chuck Levered394402006-08-22 20:06:17 -04001086 *
1087 * Returns the number of bytes that are actually in the stored address.
1088 */
1089size_t rpc_peeraddr(struct rpc_clnt *clnt, struct sockaddr *buf, size_t bufsize)
1090{
1091 size_t bytes;
Trond Myklebust2446ab62012-03-01 17:00:56 -05001092 struct rpc_xprt *xprt;
Chuck Levered394402006-08-22 20:06:17 -04001093
Trond Myklebust2446ab62012-03-01 17:00:56 -05001094 rcu_read_lock();
1095 xprt = rcu_dereference(clnt->cl_xprt);
1096
1097 bytes = xprt->addrlen;
Chuck Levered394402006-08-22 20:06:17 -04001098 if (bytes > bufsize)
1099 bytes = bufsize;
Trond Myklebust2446ab62012-03-01 17:00:56 -05001100 memcpy(buf, &xprt->addr, bytes);
1101 rcu_read_unlock();
1102
1103 return bytes;
Chuck Levered394402006-08-22 20:06:17 -04001104}
Chuck Leverb86acd52006-08-22 20:06:22 -04001105EXPORT_SYMBOL_GPL(rpc_peeraddr);
Chuck Levered394402006-08-22 20:06:17 -04001106
Chuck Leverf425eba2006-08-22 20:06:18 -04001107/**
1108 * rpc_peeraddr2str - return remote peer address in printable format
1109 * @clnt: RPC client structure
1110 * @format: address format
1111 *
Trond Myklebust2446ab62012-03-01 17:00:56 -05001112 * NB: the lifetime of the memory referenced by the returned pointer is
1113 * the same as the rpc_xprt itself. As long as the caller uses this
1114 * pointer, it must hold the RCU read lock.
Chuck Leverf425eba2006-08-22 20:06:18 -04001115 */
Chuck Leverb454ae92008-01-07 18:34:48 -05001116const char *rpc_peeraddr2str(struct rpc_clnt *clnt,
1117 enum rpc_display_format_t format)
Chuck Leverf425eba2006-08-22 20:06:18 -04001118{
Trond Myklebust2446ab62012-03-01 17:00:56 -05001119 struct rpc_xprt *xprt;
1120
1121 xprt = rcu_dereference(clnt->cl_xprt);
Chuck Lever7559c7a2006-12-05 16:35:37 -05001122
1123 if (xprt->address_strings[format] != NULL)
1124 return xprt->address_strings[format];
1125 else
1126 return "unprintable";
Chuck Leverf425eba2006-08-22 20:06:18 -04001127}
Chuck Leverb86acd52006-08-22 20:06:22 -04001128EXPORT_SYMBOL_GPL(rpc_peeraddr2str);
Chuck Leverf425eba2006-08-22 20:06:18 -04001129
Chuck Lever2e738fd2012-03-01 17:01:14 -05001130static const struct sockaddr_in rpc_inaddr_loopback = {
1131 .sin_family = AF_INET,
1132 .sin_addr.s_addr = htonl(INADDR_ANY),
1133};
1134
1135static const struct sockaddr_in6 rpc_in6addr_loopback = {
1136 .sin6_family = AF_INET6,
1137 .sin6_addr = IN6ADDR_ANY_INIT,
1138};
1139
1140/*
1141 * Try a getsockname() on a connected datagram socket. Using a
1142 * connected datagram socket prevents leaving a socket in TIME_WAIT.
1143 * This conserves the ephemeral port number space.
1144 *
1145 * Returns zero and fills in "buf" if successful; otherwise, a
1146 * negative errno is returned.
1147 */
1148static int rpc_sockname(struct net *net, struct sockaddr *sap, size_t salen,
1149 struct sockaddr *buf, int buflen)
1150{
1151 struct socket *sock;
1152 int err;
1153
1154 err = __sock_create(net, sap->sa_family,
1155 SOCK_DGRAM, IPPROTO_UDP, &sock, 1);
1156 if (err < 0) {
1157 dprintk("RPC: can't create UDP socket (%d)\n", err);
1158 goto out;
1159 }
1160
1161 switch (sap->sa_family) {
1162 case AF_INET:
1163 err = kernel_bind(sock,
1164 (struct sockaddr *)&rpc_inaddr_loopback,
1165 sizeof(rpc_inaddr_loopback));
1166 break;
1167 case AF_INET6:
1168 err = kernel_bind(sock,
1169 (struct sockaddr *)&rpc_in6addr_loopback,
1170 sizeof(rpc_in6addr_loopback));
1171 break;
1172 default:
1173 err = -EAFNOSUPPORT;
1174 goto out;
1175 }
1176 if (err < 0) {
1177 dprintk("RPC: can't bind UDP socket (%d)\n", err);
1178 goto out_release;
1179 }
1180
1181 err = kernel_connect(sock, sap, salen, 0);
1182 if (err < 0) {
1183 dprintk("RPC: can't connect UDP socket (%d)\n", err);
1184 goto out_release;
1185 }
1186
1187 err = kernel_getsockname(sock, buf, &buflen);
1188 if (err < 0) {
1189 dprintk("RPC: getsockname failed (%d)\n", err);
1190 goto out_release;
1191 }
1192
1193 err = 0;
1194 if (buf->sa_family == AF_INET6) {
1195 struct sockaddr_in6 *sin6 = (struct sockaddr_in6 *)buf;
1196 sin6->sin6_scope_id = 0;
1197 }
1198 dprintk("RPC: %s succeeded\n", __func__);
1199
1200out_release:
1201 sock_release(sock);
1202out:
1203 return err;
1204}
1205
1206/*
1207 * Scraping a connected socket failed, so we don't have a useable
1208 * local address. Fallback: generate an address that will prevent
1209 * the server from calling us back.
1210 *
1211 * Returns zero and fills in "buf" if successful; otherwise, a
1212 * negative errno is returned.
1213 */
1214static int rpc_anyaddr(int family, struct sockaddr *buf, size_t buflen)
1215{
1216 switch (family) {
1217 case AF_INET:
1218 if (buflen < sizeof(rpc_inaddr_loopback))
1219 return -EINVAL;
1220 memcpy(buf, &rpc_inaddr_loopback,
1221 sizeof(rpc_inaddr_loopback));
1222 break;
1223 case AF_INET6:
1224 if (buflen < sizeof(rpc_in6addr_loopback))
1225 return -EINVAL;
1226 memcpy(buf, &rpc_in6addr_loopback,
1227 sizeof(rpc_in6addr_loopback));
1228 default:
1229 dprintk("RPC: %s: address family not supported\n",
1230 __func__);
1231 return -EAFNOSUPPORT;
1232 }
1233 dprintk("RPC: %s: succeeded\n", __func__);
1234 return 0;
1235}
1236
1237/**
1238 * rpc_localaddr - discover local endpoint address for an RPC client
1239 * @clnt: RPC client structure
1240 * @buf: target buffer
1241 * @buflen: size of target buffer, in bytes
1242 *
1243 * Returns zero and fills in "buf" and "buflen" if successful;
1244 * otherwise, a negative errno is returned.
1245 *
1246 * This works even if the underlying transport is not currently connected,
1247 * or if the upper layer never previously provided a source address.
1248 *
1249 * The result of this function call is transient: multiple calls in
1250 * succession may give different results, depending on how local
1251 * networking configuration changes over time.
1252 */
1253int rpc_localaddr(struct rpc_clnt *clnt, struct sockaddr *buf, size_t buflen)
1254{
1255 struct sockaddr_storage address;
1256 struct sockaddr *sap = (struct sockaddr *)&address;
1257 struct rpc_xprt *xprt;
1258 struct net *net;
1259 size_t salen;
1260 int err;
1261
1262 rcu_read_lock();
1263 xprt = rcu_dereference(clnt->cl_xprt);
1264 salen = xprt->addrlen;
1265 memcpy(sap, &xprt->addr, salen);
1266 net = get_net(xprt->xprt_net);
1267 rcu_read_unlock();
1268
1269 rpc_set_port(sap, 0);
1270 err = rpc_sockname(net, sap, salen, buf, buflen);
1271 put_net(net);
1272 if (err != 0)
1273 /* Couldn't discover local address, return ANYADDR */
1274 return rpc_anyaddr(sap->sa_family, buf, buflen);
1275 return 0;
1276}
1277EXPORT_SYMBOL_GPL(rpc_localaddr);
1278
Linus Torvalds1da177e2005-04-16 15:20:36 -07001279void
1280rpc_setbufsize(struct rpc_clnt *clnt, unsigned int sndsize, unsigned int rcvsize)
1281{
Trond Myklebust2446ab62012-03-01 17:00:56 -05001282 struct rpc_xprt *xprt;
1283
1284 rcu_read_lock();
1285 xprt = rcu_dereference(clnt->cl_xprt);
Chuck Lever470056c2005-08-25 16:25:56 -07001286 if (xprt->ops->set_buffer_size)
1287 xprt->ops->set_buffer_size(xprt, sndsize, rcvsize);
Trond Myklebust2446ab62012-03-01 17:00:56 -05001288 rcu_read_unlock();
Linus Torvalds1da177e2005-04-16 15:20:36 -07001289}
Trond Myklebuste8914c62007-07-14 15:39:59 -04001290EXPORT_SYMBOL_GPL(rpc_setbufsize);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001291
Trond Myklebust2446ab62012-03-01 17:00:56 -05001292/**
1293 * rpc_protocol - Get transport protocol number for an RPC client
1294 * @clnt: RPC client to query
1295 *
1296 */
1297int rpc_protocol(struct rpc_clnt *clnt)
1298{
1299 int protocol;
1300
1301 rcu_read_lock();
1302 protocol = rcu_dereference(clnt->cl_xprt)->prot;
1303 rcu_read_unlock();
1304 return protocol;
1305}
1306EXPORT_SYMBOL_GPL(rpc_protocol);
1307
1308/**
1309 * rpc_net_ns - Get the network namespace for this RPC client
1310 * @clnt: RPC client to query
1311 *
1312 */
1313struct net *rpc_net_ns(struct rpc_clnt *clnt)
1314{
1315 struct net *ret;
1316
1317 rcu_read_lock();
1318 ret = rcu_dereference(clnt->cl_xprt)->xprt_net;
1319 rcu_read_unlock();
1320 return ret;
1321}
1322EXPORT_SYMBOL_GPL(rpc_net_ns);
1323
1324/**
1325 * rpc_max_payload - Get maximum payload size for a transport, in bytes
1326 * @clnt: RPC client to query
Linus Torvalds1da177e2005-04-16 15:20:36 -07001327 *
1328 * For stream transports, this is one RPC record fragment (see RFC
1329 * 1831), as we don't support multi-record requests yet. For datagram
1330 * transports, this is the size of an IP packet minus the IP, UDP, and
1331 * RPC header sizes.
1332 */
1333size_t rpc_max_payload(struct rpc_clnt *clnt)
1334{
Trond Myklebust2446ab62012-03-01 17:00:56 -05001335 size_t ret;
1336
1337 rcu_read_lock();
1338 ret = rcu_dereference(clnt->cl_xprt)->max_payload;
1339 rcu_read_unlock();
1340 return ret;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001341}
Chuck Leverb86acd52006-08-22 20:06:22 -04001342EXPORT_SYMBOL_GPL(rpc_max_payload);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001343
Chuck Lever35f5a422006-01-03 09:55:50 +01001344/**
Trond Myklebust512e4b22013-03-02 15:54:11 -08001345 * rpc_get_timeout - Get timeout for transport in units of HZ
Weston Andros Adamsonedddbb12013-02-28 20:30:09 -05001346 * @clnt: RPC client to query
1347 */
1348unsigned long rpc_get_timeout(struct rpc_clnt *clnt)
1349{
1350 unsigned long ret;
1351
1352 rcu_read_lock();
1353 ret = rcu_dereference(clnt->cl_xprt)->timeout->to_initval;
1354 rcu_read_unlock();
1355 return ret;
1356}
1357EXPORT_SYMBOL_GPL(rpc_get_timeout);
1358
1359/**
Chuck Lever35f5a422006-01-03 09:55:50 +01001360 * rpc_force_rebind - force transport to check that remote port is unchanged
1361 * @clnt: client to rebind
1362 *
1363 */
1364void rpc_force_rebind(struct rpc_clnt *clnt)
1365{
Trond Myklebust2446ab62012-03-01 17:00:56 -05001366 if (clnt->cl_autobind) {
1367 rcu_read_lock();
1368 xprt_clear_bound(rcu_dereference(clnt->cl_xprt));
1369 rcu_read_unlock();
1370 }
Chuck Lever35f5a422006-01-03 09:55:50 +01001371}
Chuck Leverb86acd52006-08-22 20:06:22 -04001372EXPORT_SYMBOL_GPL(rpc_force_rebind);
Chuck Lever35f5a422006-01-03 09:55:50 +01001373
Linus Torvalds1da177e2005-04-16 15:20:36 -07001374/*
Andy Adamsonaae20062009-04-01 09:22:40 -04001375 * Restart an (async) RPC call from the call_prepare state.
1376 * Usually called from within the exit handler.
1377 */
Trond Myklebustf1f88fc2010-07-31 14:29:07 -04001378int
Andy Adamsonaae20062009-04-01 09:22:40 -04001379rpc_restart_call_prepare(struct rpc_task *task)
1380{
1381 if (RPC_ASSASSINATED(task))
Trond Myklebustf1f88fc2010-07-31 14:29:07 -04001382 return 0;
Trond Myklebustd00c5d42011-10-19 12:17:29 -07001383 task->tk_action = call_start;
Trond Myklebust494314c2014-03-20 12:59:09 -04001384 task->tk_status = 0;
Trond Myklebustd00c5d42011-10-19 12:17:29 -07001385 if (task->tk_ops->rpc_call_prepare != NULL)
1386 task->tk_action = rpc_prepare_task;
Trond Myklebustf1f88fc2010-07-31 14:29:07 -04001387 return 1;
Andy Adamsonaae20062009-04-01 09:22:40 -04001388}
1389EXPORT_SYMBOL_GPL(rpc_restart_call_prepare);
1390
1391/*
Linus Torvalds1da177e2005-04-16 15:20:36 -07001392 * Restart an (async) RPC call. Usually called from within the
1393 * exit handler.
1394 */
Trond Myklebustf1f88fc2010-07-31 14:29:07 -04001395int
Linus Torvalds1da177e2005-04-16 15:20:36 -07001396rpc_restart_call(struct rpc_task *task)
1397{
1398 if (RPC_ASSASSINATED(task))
Trond Myklebustf1f88fc2010-07-31 14:29:07 -04001399 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001400 task->tk_action = call_start;
Trond Myklebust494314c2014-03-20 12:59:09 -04001401 task->tk_status = 0;
Trond Myklebustf1f88fc2010-07-31 14:29:07 -04001402 return 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001403}
Trond Myklebuste8914c62007-07-14 15:39:59 -04001404EXPORT_SYMBOL_GPL(rpc_restart_call);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001405
Jeff Laytonf895b252014-11-17 16:58:04 -05001406#if IS_ENABLED(CONFIG_SUNRPC_DEBUG)
Jeff Laytonb4b9d2c2014-11-26 14:44:43 -05001407const char
1408*rpc_proc_name(const struct rpc_task *task)
Chuck Lever3748f1e2008-05-21 17:09:12 -04001409{
1410 const struct rpc_procinfo *proc = task->tk_msg.rpc_proc;
1411
1412 if (proc) {
1413 if (proc->p_name)
1414 return proc->p_name;
1415 else
1416 return "NULL";
1417 } else
1418 return "no proc";
1419}
1420#endif
1421
Linus Torvalds1da177e2005-04-16 15:20:36 -07001422/*
1423 * 0. Initial state
1424 *
1425 * Other FSM states can be visited zero or more times, but
1426 * this state is visited exactly once for each RPC.
1427 */
1428static void
1429call_start(struct rpc_task *task)
1430{
1431 struct rpc_clnt *clnt = task->tk_client;
1432
Chuck Lever3748f1e2008-05-21 17:09:12 -04001433 dprintk("RPC: %5u call_start %s%d proc %s (%s)\n", task->tk_pid,
Trond Myklebust55909f22013-08-23 11:48:15 -04001434 clnt->cl_program->name, clnt->cl_vers,
Chuck Lever3748f1e2008-05-21 17:09:12 -04001435 rpc_proc_name(task),
Chuck Lever46121cf2007-01-31 12:14:08 -05001436 (RPC_IS_ASYNC(task) ? "async" : "sync"));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001437
1438 /* Increment call count */
1439 task->tk_msg.rpc_proc->p_count++;
1440 clnt->cl_stats->rpccnt++;
1441 task->tk_action = call_reserve;
1442}
1443
1444/*
1445 * 1. Reserve an RPC call slot
1446 */
1447static void
1448call_reserve(struct rpc_task *task)
1449{
Chuck Lever46121cf2007-01-31 12:14:08 -05001450 dprint_status(task);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001451
Linus Torvalds1da177e2005-04-16 15:20:36 -07001452 task->tk_status = 0;
1453 task->tk_action = call_reserveresult;
1454 xprt_reserve(task);
1455}
1456
Trond Myklebustba60eb22013-04-14 10:49:37 -04001457static void call_retry_reserve(struct rpc_task *task);
1458
Linus Torvalds1da177e2005-04-16 15:20:36 -07001459/*
1460 * 1b. Grok the result of xprt_reserve()
1461 */
1462static void
1463call_reserveresult(struct rpc_task *task)
1464{
1465 int status = task->tk_status;
1466
Chuck Lever46121cf2007-01-31 12:14:08 -05001467 dprint_status(task);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001468
1469 /*
1470 * After a call to xprt_reserve(), we must have either
1471 * a request slot or else an error status.
1472 */
1473 task->tk_status = 0;
1474 if (status >= 0) {
1475 if (task->tk_rqstp) {
J. Bruce Fieldsf2d47d02010-09-12 19:55:25 -04001476 task->tk_action = call_refresh;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001477 return;
1478 }
1479
1480 printk(KERN_ERR "%s: status=%d, but no request slot, exiting\n",
Harvey Harrison0dc47872008-03-05 20:47:47 -08001481 __func__, status);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001482 rpc_exit(task, -EIO);
1483 return;
1484 }
1485
1486 /*
1487 * Even though there was an error, we may have acquired
1488 * a request slot somehow. Make sure not to leak it.
1489 */
1490 if (task->tk_rqstp) {
1491 printk(KERN_ERR "%s: status=%d, request allocated anyway\n",
Harvey Harrison0dc47872008-03-05 20:47:47 -08001492 __func__, status);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001493 xprt_release(task);
1494 }
1495
1496 switch (status) {
Trond Myklebust1afeaf52012-05-19 12:12:53 -04001497 case -ENOMEM:
1498 rpc_delay(task, HZ >> 2);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001499 case -EAGAIN: /* woken up; retry */
Trond Myklebustba60eb22013-04-14 10:49:37 -04001500 task->tk_action = call_retry_reserve;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001501 return;
1502 case -EIO: /* probably a shutdown */
1503 break;
1504 default:
1505 printk(KERN_ERR "%s: unrecognized error %d, exiting\n",
Harvey Harrison0dc47872008-03-05 20:47:47 -08001506 __func__, status);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001507 break;
1508 }
1509 rpc_exit(task, status);
1510}
1511
1512/*
Trond Myklebustba60eb22013-04-14 10:49:37 -04001513 * 1c. Retry reserving an RPC call slot
1514 */
1515static void
1516call_retry_reserve(struct rpc_task *task)
1517{
1518 dprint_status(task);
1519
1520 task->tk_status = 0;
1521 task->tk_action = call_reserveresult;
1522 xprt_retry_reserve(task);
1523}
1524
1525/*
J. Bruce Fields55576242010-09-12 19:55:25 -04001526 * 2. Bind and/or refresh the credentials
1527 */
1528static void
1529call_refresh(struct rpc_task *task)
1530{
1531 dprint_status(task);
1532
1533 task->tk_action = call_refreshresult;
1534 task->tk_status = 0;
1535 task->tk_client->cl_stats->rpcauthrefresh++;
1536 rpcauth_refreshcred(task);
1537}
1538
1539/*
1540 * 2a. Process the results of a credential refresh
1541 */
1542static void
1543call_refreshresult(struct rpc_task *task)
1544{
1545 int status = task->tk_status;
1546
1547 dprint_status(task);
1548
1549 task->tk_status = 0;
Trond Myklebust5fc43972010-11-20 11:13:31 -05001550 task->tk_action = call_refresh;
J. Bruce Fields55576242010-09-12 19:55:25 -04001551 switch (status) {
Trond Myklebust5fc43972010-11-20 11:13:31 -05001552 case 0:
Weston Andros Adamson6ff33b72013-12-17 12:16:11 -05001553 if (rpcauth_uptodatecred(task)) {
Trond Myklebust5fc43972010-11-20 11:13:31 -05001554 task->tk_action = call_allocate;
Weston Andros Adamson6ff33b72013-12-17 12:16:11 -05001555 return;
1556 }
1557 /* Use rate-limiting and a max number of retries if refresh
1558 * had status 0 but failed to update the cred.
1559 */
J. Bruce Fields55576242010-09-12 19:55:25 -04001560 case -ETIMEDOUT:
1561 rpc_delay(task, 3*HZ);
Trond Myklebust5fc43972010-11-20 11:13:31 -05001562 case -EAGAIN:
1563 status = -EACCES;
Andy Adamsonf1ff0c22013-08-14 11:59:13 -04001564 case -EKEYEXPIRED:
Trond Myklebust5fc43972010-11-20 11:13:31 -05001565 if (!task->tk_cred_retry)
1566 break;
1567 task->tk_cred_retry--;
1568 dprintk("RPC: %5u %s: retry refresh creds\n",
1569 task->tk_pid, __func__);
1570 return;
J. Bruce Fields55576242010-09-12 19:55:25 -04001571 }
Trond Myklebust5fc43972010-11-20 11:13:31 -05001572 dprintk("RPC: %5u %s: refresh creds failed with error %d\n",
1573 task->tk_pid, __func__, status);
1574 rpc_exit(task, status);
J. Bruce Fields55576242010-09-12 19:55:25 -04001575}
1576
1577/*
1578 * 2b. Allocate the buffer. For details, see sched.c:rpc_malloc.
Chuck Lever02107142006-01-03 09:55:49 +01001579 * (Note: buffer memory is freed in xprt_release).
Linus Torvalds1da177e2005-04-16 15:20:36 -07001580 */
1581static void
1582call_allocate(struct rpc_task *task)
1583{
J. Bruce Fieldsf2d47d02010-09-12 19:55:25 -04001584 unsigned int slack = task->tk_rqstp->rq_cred->cr_auth->au_cslack;
Chuck Lever02107142006-01-03 09:55:49 +01001585 struct rpc_rqst *req = task->tk_rqstp;
Trond Myklebusta4f08352013-01-08 09:10:21 -05001586 struct rpc_xprt *xprt = req->rq_xprt;
Chuck Lever2bea90d2007-03-29 16:47:53 -04001587 struct rpc_procinfo *proc = task->tk_msg.rpc_proc;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001588
Chuck Lever46121cf2007-01-31 12:14:08 -05001589 dprint_status(task);
1590
Chuck Lever2bea90d2007-03-29 16:47:53 -04001591 task->tk_status = 0;
J. Bruce Fieldsf2d47d02010-09-12 19:55:25 -04001592 task->tk_action = call_bind;
Chuck Lever2bea90d2007-03-29 16:47:53 -04001593
Chuck Lever02107142006-01-03 09:55:49 +01001594 if (req->rq_buffer)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001595 return;
1596
Chuck Lever2bea90d2007-03-29 16:47:53 -04001597 if (proc->p_proc != 0) {
1598 BUG_ON(proc->p_arglen == 0);
1599 if (proc->p_decode != NULL)
1600 BUG_ON(proc->p_replen == 0);
1601 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001602
Chuck Lever2bea90d2007-03-29 16:47:53 -04001603 /*
1604 * Calculate the size (in quads) of the RPC call
1605 * and reply headers, and convert both values
1606 * to byte sizes.
1607 */
1608 req->rq_callsize = RPC_CALLHDRSIZE + (slack << 1) + proc->p_arglen;
1609 req->rq_callsize <<= 2;
1610 req->rq_rcvsize = RPC_REPHDRSIZE + slack + proc->p_replen;
1611 req->rq_rcvsize <<= 2;
1612
Chuck Leverc5a4dd82007-03-29 16:47:58 -04001613 req->rq_buffer = xprt->ops->buf_alloc(task,
1614 req->rq_callsize + req->rq_rcvsize);
Chuck Lever2bea90d2007-03-29 16:47:53 -04001615 if (req->rq_buffer != NULL)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001616 return;
Chuck Lever46121cf2007-01-31 12:14:08 -05001617
1618 dprintk("RPC: %5u rpc_buffer allocation failed\n", task->tk_pid);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001619
Trond Myklebust5afa9132011-06-17 10:14:59 -04001620 if (RPC_IS_ASYNC(task) || !fatal_signal_pending(current)) {
Trond Myklebustb6e9c712007-10-01 12:06:44 -04001621 task->tk_action = call_allocate;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001622 rpc_delay(task, HZ>>4);
1623 return;
1624 }
1625
1626 rpc_exit(task, -ERESTARTSYS);
1627}
1628
Trond Myklebust940e3312005-11-09 21:45:24 -05001629static inline int
1630rpc_task_need_encode(struct rpc_task *task)
1631{
1632 return task->tk_rqstp->rq_snd_buf.len == 0;
1633}
1634
1635static inline void
1636rpc_task_force_reencode(struct rpc_task *task)
1637{
1638 task->tk_rqstp->rq_snd_buf.len = 0;
Trond Myklebust2574cc92009-08-28 11:12:12 -04001639 task->tk_rqstp->rq_bytes_sent = 0;
Trond Myklebust940e3312005-11-09 21:45:24 -05001640}
1641
Chuck Lever2bea90d2007-03-29 16:47:53 -04001642static inline void
1643rpc_xdr_buf_init(struct xdr_buf *buf, void *start, size_t len)
1644{
1645 buf->head[0].iov_base = start;
1646 buf->head[0].iov_len = len;
1647 buf->tail[0].iov_len = 0;
1648 buf->page_len = 0;
\"Talpey, Thomas\4f22ccc2007-09-10 13:44:58 -04001649 buf->flags = 0;
Chuck Lever2bea90d2007-03-29 16:47:53 -04001650 buf->len = 0;
1651 buf->buflen = len;
1652}
1653
Linus Torvalds1da177e2005-04-16 15:20:36 -07001654/*
1655 * 3. Encode arguments of an RPC call
1656 */
1657static void
Chuck Leverb0e1c572008-05-21 17:09:19 -04001658rpc_xdr_encode(struct rpc_task *task)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001659{
Linus Torvalds1da177e2005-04-16 15:20:36 -07001660 struct rpc_rqst *req = task->tk_rqstp;
Chuck Lever9f06c712010-12-14 14:59:18 +00001661 kxdreproc_t encode;
Alexey Dobriyand8ed0292006-09-26 22:29:38 -07001662 __be32 *p;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001663
Chuck Lever46121cf2007-01-31 12:14:08 -05001664 dprint_status(task);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001665
Chuck Lever2bea90d2007-03-29 16:47:53 -04001666 rpc_xdr_buf_init(&req->rq_snd_buf,
1667 req->rq_buffer,
1668 req->rq_callsize);
1669 rpc_xdr_buf_init(&req->rq_rcv_buf,
1670 (char *)req->rq_buffer + req->rq_callsize,
1671 req->rq_rcvsize);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001672
Chuck Leverb0e1c572008-05-21 17:09:19 -04001673 p = rpc_encode_header(task);
1674 if (p == NULL) {
1675 printk(KERN_INFO "RPC: couldn't encode RPC header, exit EIO\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -07001676 rpc_exit(task, -EIO);
1677 return;
1678 }
Chuck Leverb0e1c572008-05-21 17:09:19 -04001679
1680 encode = task->tk_msg.rpc_proc->p_encode;
J. Bruce Fieldsf3680312005-10-13 16:54:48 -04001681 if (encode == NULL)
1682 return;
1683
1684 task->tk_status = rpcauth_wrap_req(task, encode, req, p,
1685 task->tk_msg.rpc_argp);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001686}
1687
1688/*
1689 * 4. Get the server port number if not yet set
1690 */
1691static void
1692call_bind(struct rpc_task *task)
1693{
Trond Myklebustad2368d2013-01-08 10:08:33 -05001694 struct rpc_xprt *xprt = task->tk_rqstp->rq_xprt;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001695
Chuck Lever46121cf2007-01-31 12:14:08 -05001696 dprint_status(task);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001697
Chuck Leverda351872005-08-11 16:25:11 -04001698 task->tk_action = call_connect;
Chuck Leverec739ef2006-08-22 20:06:15 -04001699 if (!xprt_bound(xprt)) {
Chuck Leverda351872005-08-11 16:25:11 -04001700 task->tk_action = call_bind_status;
Chuck Leverec739ef2006-08-22 20:06:15 -04001701 task->tk_timeout = xprt->bind_timeout;
Chuck Leverbbf7c1d2006-08-22 20:06:16 -04001702 xprt->ops->rpcbind(task);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001703 }
1704}
1705
1706/*
Chuck Leverda351872005-08-11 16:25:11 -04001707 * 4a. Sort out bind result
1708 */
1709static void
1710call_bind_status(struct rpc_task *task)
1711{
Chuck Lever906462a2007-09-11 18:00:47 -04001712 int status = -EIO;
Chuck Leverda351872005-08-11 16:25:11 -04001713
1714 if (task->tk_status >= 0) {
Chuck Lever46121cf2007-01-31 12:14:08 -05001715 dprint_status(task);
Chuck Leverda351872005-08-11 16:25:11 -04001716 task->tk_status = 0;
1717 task->tk_action = call_connect;
1718 return;
1719 }
1720
Steve Dickson5753cba2012-02-06 10:08:08 -05001721 trace_rpc_bind_status(task);
Chuck Leverda351872005-08-11 16:25:11 -04001722 switch (task->tk_status) {
Trond Myklebust381ba742008-07-07 12:18:53 -04001723 case -ENOMEM:
1724 dprintk("RPC: %5u rpcbind out of memory\n", task->tk_pid);
1725 rpc_delay(task, HZ >> 2);
Chuck Lever2429cbf2007-09-11 18:00:41 -04001726 goto retry_timeout;
Chuck Leverda351872005-08-11 16:25:11 -04001727 case -EACCES:
Chuck Lever46121cf2007-01-31 12:14:08 -05001728 dprintk("RPC: %5u remote rpcbind: RPC program/version "
1729 "unavailable\n", task->tk_pid);
Chuck Leverb79dc8c2007-09-11 18:00:52 -04001730 /* fail immediately if this is an RPC ping */
1731 if (task->tk_msg.rpc_proc->p_proc == 0) {
1732 status = -EOPNOTSUPP;
1733 break;
1734 }
Trond Myklebust0b760112011-05-31 15:15:34 -04001735 if (task->tk_rebind_retry == 0)
1736 break;
1737 task->tk_rebind_retry--;
Chuck Leverea635a52005-10-06 23:12:58 -04001738 rpc_delay(task, 3*HZ);
Trond Myklebustda458282006-08-31 15:44:52 -04001739 goto retry_timeout;
Chuck Leverda351872005-08-11 16:25:11 -04001740 case -ETIMEDOUT:
Chuck Lever46121cf2007-01-31 12:14:08 -05001741 dprintk("RPC: %5u rpcbind request timed out\n",
Chuck Leverda351872005-08-11 16:25:11 -04001742 task->tk_pid);
Trond Myklebustda458282006-08-31 15:44:52 -04001743 goto retry_timeout;
Chuck Leverda351872005-08-11 16:25:11 -04001744 case -EPFNOSUPPORT:
Chuck Lever906462a2007-09-11 18:00:47 -04001745 /* server doesn't support any rpcbind version we know of */
Chuck Lever012da152009-12-03 15:58:56 -05001746 dprintk("RPC: %5u unrecognized remote rpcbind service\n",
Chuck Leverda351872005-08-11 16:25:11 -04001747 task->tk_pid);
1748 break;
1749 case -EPROTONOSUPPORT:
Chuck Lever00a6e7b2007-03-29 16:48:33 -04001750 dprintk("RPC: %5u remote rpcbind version unavailable, retrying\n",
Chuck Leverda351872005-08-11 16:25:11 -04001751 task->tk_pid);
Trond Myklebustfdb63dc2014-03-17 12:57:31 -04001752 goto retry_timeout;
Chuck Lever012da152009-12-03 15:58:56 -05001753 case -ECONNREFUSED: /* connection problems */
1754 case -ECONNRESET:
Trond Myklebustdf277272013-12-31 13:11:43 -05001755 case -ECONNABORTED:
Chuck Lever012da152009-12-03 15:58:56 -05001756 case -ENOTCONN:
1757 case -EHOSTDOWN:
1758 case -EHOSTUNREACH:
1759 case -ENETUNREACH:
Trond Myklebust3601c4a2014-06-30 13:42:19 -04001760 case -ENOBUFS:
Chuck Lever012da152009-12-03 15:58:56 -05001761 case -EPIPE:
1762 dprintk("RPC: %5u remote rpcbind unreachable: %d\n",
1763 task->tk_pid, task->tk_status);
1764 if (!RPC_IS_SOFTCONN(task)) {
1765 rpc_delay(task, 5*HZ);
1766 goto retry_timeout;
1767 }
1768 status = task->tk_status;
1769 break;
Chuck Leverda351872005-08-11 16:25:11 -04001770 default:
Chuck Lever46121cf2007-01-31 12:14:08 -05001771 dprintk("RPC: %5u unrecognized rpcbind error (%d)\n",
Chuck Leverda351872005-08-11 16:25:11 -04001772 task->tk_pid, -task->tk_status);
Chuck Leverda351872005-08-11 16:25:11 -04001773 }
1774
1775 rpc_exit(task, status);
1776 return;
1777
Trond Myklebustda458282006-08-31 15:44:52 -04001778retry_timeout:
Trond Myklebustfdb63dc2014-03-17 12:57:31 -04001779 task->tk_status = 0;
Trond Myklebustda458282006-08-31 15:44:52 -04001780 task->tk_action = call_timeout;
Chuck Leverda351872005-08-11 16:25:11 -04001781}
1782
1783/*
1784 * 4b. Connect to the RPC server
Linus Torvalds1da177e2005-04-16 15:20:36 -07001785 */
1786static void
1787call_connect(struct rpc_task *task)
1788{
Trond Myklebustad2368d2013-01-08 10:08:33 -05001789 struct rpc_xprt *xprt = task->tk_rqstp->rq_xprt;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001790
Chuck Lever46121cf2007-01-31 12:14:08 -05001791 dprintk("RPC: %5u call_connect xprt %p %s connected\n",
Chuck Leverda351872005-08-11 16:25:11 -04001792 task->tk_pid, xprt,
1793 (xprt_connected(xprt) ? "is" : "is not"));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001794
Chuck Leverda351872005-08-11 16:25:11 -04001795 task->tk_action = call_transmit;
1796 if (!xprt_connected(xprt)) {
1797 task->tk_action = call_connect_status;
1798 if (task->tk_status < 0)
1799 return;
Trond Myklebust786615b2013-08-05 16:04:47 -04001800 if (task->tk_flags & RPC_TASK_NOCONNECT) {
1801 rpc_exit(task, -ENOTCONN);
1802 return;
1803 }
Chuck Leverda351872005-08-11 16:25:11 -04001804 xprt_connect(task);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001805 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001806}
1807
1808/*
Chuck Leverda351872005-08-11 16:25:11 -04001809 * 4c. Sort out connect result
Linus Torvalds1da177e2005-04-16 15:20:36 -07001810 */
1811static void
1812call_connect_status(struct rpc_task *task)
1813{
1814 struct rpc_clnt *clnt = task->tk_client;
1815 int status = task->tk_status;
1816
Chuck Lever46121cf2007-01-31 12:14:08 -05001817 dprint_status(task);
Chuck Leverda351872005-08-11 16:25:11 -04001818
Steve Dickson5753cba2012-02-06 10:08:08 -05001819 trace_rpc_connect_status(task, status);
Trond Myklebust561ec162013-09-26 15:22:45 -04001820 task->tk_status = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001821 switch (status) {
Trond Myklebust3ed5e2a2013-03-04 17:29:33 -05001822 case -ECONNREFUSED:
1823 case -ECONNRESET:
Trond Myklebustdf277272013-12-31 13:11:43 -05001824 case -ECONNABORTED:
Trond Myklebust3ed5e2a2013-03-04 17:29:33 -05001825 case -ENETUNREACH:
Trond Myklebustdf277272013-12-31 13:11:43 -05001826 case -EHOSTUNREACH:
Trond Myklebust3601c4a2014-06-30 13:42:19 -04001827 case -ENOBUFS:
Trond Myklebust2fc193c2014-07-03 00:02:57 -04001828 case -EPIPE:
Trond Myklebust3ed5e2a2013-03-04 17:29:33 -05001829 if (RPC_IS_SOFTCONN(task))
1830 break;
Steve Dickson1fa3e2e2014-03-20 11:23:03 -04001831 /* retry with existing socket, after a delay */
1832 rpc_delay(task, 3*HZ);
Trond Myklebust3ed5e2a2013-03-04 17:29:33 -05001833 case -EAGAIN:
Trond Myklebust485f2252014-03-17 12:51:44 -04001834 /* Check for timeouts before looping back to call_bind */
1835 case -ETIMEDOUT:
1836 task->tk_action = call_timeout;
Trond Myklebust561ec162013-09-26 15:22:45 -04001837 return;
1838 case 0:
Trond Myklebust3ed5e2a2013-03-04 17:29:33 -05001839 clnt->cl_stats->netreconn++;
1840 task->tk_action = call_transmit;
1841 return;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001842 }
Trond Myklebust3ed5e2a2013-03-04 17:29:33 -05001843 rpc_exit(task, status);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001844}
1845
1846/*
1847 * 5. Transmit the RPC request, and wait for reply
1848 */
1849static void
1850call_transmit(struct rpc_task *task)
1851{
Trond Myklebustca7f33a2013-09-25 13:39:45 -04001852 int is_retrans = RPC_WAS_SENT(task);
1853
Chuck Lever46121cf2007-01-31 12:14:08 -05001854 dprint_status(task);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001855
1856 task->tk_action = call_status;
1857 if (task->tk_status < 0)
1858 return;
Trond Myklebust90051ea2013-09-25 12:17:18 -04001859 if (!xprt_prepare_transmit(task))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001860 return;
Trond Myklebuste0ab53d2006-07-27 17:22:50 -04001861 task->tk_action = call_transmit_status;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001862 /* Encode here so that rpcsec_gss can use correct sequence number. */
Trond Myklebust940e3312005-11-09 21:45:24 -05001863 if (rpc_task_need_encode(task)) {
Chuck Leverb0e1c572008-05-21 17:09:19 -04001864 rpc_xdr_encode(task);
Trond Myklebust5e5ce5b2005-10-18 14:20:11 -07001865 /* Did the encode result in an error condition? */
Trond Myklebust8b39f2b2008-05-14 19:48:25 -07001866 if (task->tk_status != 0) {
1867 /* Was the error nonfatal? */
1868 if (task->tk_status == -EAGAIN)
1869 rpc_delay(task, HZ >> 4);
1870 else
1871 rpc_exit(task, task->tk_status);
Trond Myklebuste0ab53d2006-07-27 17:22:50 -04001872 return;
Trond Myklebust8b39f2b2008-05-14 19:48:25 -07001873 }
Trond Myklebust5e5ce5b2005-10-18 14:20:11 -07001874 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001875 xprt_transmit(task);
1876 if (task->tk_status < 0)
1877 return;
Trond Myklebustca7f33a2013-09-25 13:39:45 -04001878 if (is_retrans)
1879 task->tk_client->cl_stats->rpcretrans++;
Trond Myklebuste0ab53d2006-07-27 17:22:50 -04001880 /*
1881 * On success, ensure that we call xprt_end_transmit() before sleeping
1882 * in order to allow access to the socket to other RPC requests.
1883 */
1884 call_transmit_status(task);
Ricardo Labiaga55ae1aa2009-04-01 09:23:03 -04001885 if (rpc_reply_expected(task))
Trond Myklebuste0ab53d2006-07-27 17:22:50 -04001886 return;
1887 task->tk_action = rpc_exit_task;
Trond Myklebusta4f08352013-01-08 09:10:21 -05001888 rpc_wake_up_queued_task(&task->tk_rqstp->rq_xprt->pending, task);
Trond Myklebuste0ab53d2006-07-27 17:22:50 -04001889}
1890
1891/*
1892 * 5a. Handle cleanup after a transmission
1893 */
1894static void
1895call_transmit_status(struct rpc_task *task)
1896{
1897 task->tk_action = call_status;
Chuck Lever206a1342009-12-03 15:58:56 -05001898
1899 /*
1900 * Common case: success. Force the compiler to put this
1901 * test first.
1902 */
1903 if (task->tk_status == 0) {
1904 xprt_end_transmit(task);
1905 rpc_task_force_reencode(task);
1906 return;
1907 }
1908
Trond Myklebust15f081c2009-03-11 14:37:57 -04001909 switch (task->tk_status) {
1910 case -EAGAIN:
1911 break;
1912 default:
Chuck Lever206a1342009-12-03 15:58:56 -05001913 dprint_status(task);
Trond Myklebust15f081c2009-03-11 14:37:57 -04001914 xprt_end_transmit(task);
Chuck Lever09a21c42009-12-03 15:58:56 -05001915 rpc_task_force_reencode(task);
1916 break;
Trond Myklebust15f081c2009-03-11 14:37:57 -04001917 /*
1918 * Special cases: if we've been waiting on the
1919 * socket's write_space() callback, or if the
1920 * socket just returned a connection error,
1921 * then hold onto the transport lock.
1922 */
1923 case -ECONNREFUSED:
Trond Myklebust15f081c2009-03-11 14:37:57 -04001924 case -EHOSTDOWN:
1925 case -EHOSTUNREACH:
1926 case -ENETUNREACH:
Jason Baron3dedbb52014-09-24 18:08:04 +00001927 case -EPERM:
Chuck Lever09a21c42009-12-03 15:58:56 -05001928 if (RPC_IS_SOFTCONN(task)) {
1929 xprt_end_transmit(task);
1930 rpc_exit(task, task->tk_status);
1931 break;
1932 }
1933 case -ECONNRESET:
Trond Myklebustdf277272013-12-31 13:11:43 -05001934 case -ECONNABORTED:
Chuck Lever09a21c42009-12-03 15:58:56 -05001935 case -ENOTCONN:
Trond Myklebust3601c4a2014-06-30 13:42:19 -04001936 case -ENOBUFS:
Trond Myklebustc8485e42009-03-11 14:37:59 -04001937 case -EPIPE:
Trond Myklebust15f081c2009-03-11 14:37:57 -04001938 rpc_task_force_reencode(task);
1939 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001940}
1941
Trond Myklebust9e00abc2011-07-13 19:20:49 -04001942#if defined(CONFIG_SUNRPC_BACKCHANNEL)
Ricardo Labiaga55ae1aa2009-04-01 09:23:03 -04001943/*
1944 * 5b. Send the backchannel RPC reply. On error, drop the reply. In
1945 * addition, disconnect on connectivity errors.
1946 */
1947static void
1948call_bc_transmit(struct rpc_task *task)
1949{
1950 struct rpc_rqst *req = task->tk_rqstp;
1951
Trond Myklebust90051ea2013-09-25 12:17:18 -04001952 if (!xprt_prepare_transmit(task)) {
Ricardo Labiaga55ae1aa2009-04-01 09:23:03 -04001953 /*
1954 * Could not reserve the transport. Try again after the
1955 * transport is released.
1956 */
1957 task->tk_status = 0;
1958 task->tk_action = call_bc_transmit;
1959 return;
1960 }
1961
1962 task->tk_action = rpc_exit_task;
1963 if (task->tk_status < 0) {
1964 printk(KERN_NOTICE "RPC: Could not send backchannel reply "
1965 "error: %d\n", task->tk_status);
1966 return;
1967 }
1968
1969 xprt_transmit(task);
1970 xprt_end_transmit(task);
1971 dprint_status(task);
1972 switch (task->tk_status) {
1973 case 0:
1974 /* Success */
1975 break;
1976 case -EHOSTDOWN:
1977 case -EHOSTUNREACH:
1978 case -ENETUNREACH:
1979 case -ETIMEDOUT:
1980 /*
1981 * Problem reaching the server. Disconnect and let the
1982 * forechannel reestablish the connection. The server will
1983 * have to retransmit the backchannel request and we'll
1984 * reprocess it. Since these ops are idempotent, there's no
1985 * need to cache our reply at this time.
1986 */
1987 printk(KERN_NOTICE "RPC: Could not send backchannel reply "
1988 "error: %d\n", task->tk_status);
Trond Myklebusta4f08352013-01-08 09:10:21 -05001989 xprt_conditional_disconnect(req->rq_xprt,
Ricardo Labiaga55ae1aa2009-04-01 09:23:03 -04001990 req->rq_connect_cookie);
1991 break;
1992 default:
1993 /*
1994 * We were unable to reply and will have to drop the
1995 * request. The server should reconnect and retransmit.
1996 */
Weston Andros Adamson1facf4c2012-10-23 10:43:30 -04001997 WARN_ON_ONCE(task->tk_status == -EAGAIN);
Ricardo Labiaga55ae1aa2009-04-01 09:23:03 -04001998 printk(KERN_NOTICE "RPC: Could not send backchannel reply "
1999 "error: %d\n", task->tk_status);
2000 break;
2001 }
2002 rpc_wake_up_queued_task(&req->rq_xprt->pending, task);
2003}
Trond Myklebust9e00abc2011-07-13 19:20:49 -04002004#endif /* CONFIG_SUNRPC_BACKCHANNEL */
Ricardo Labiaga55ae1aa2009-04-01 09:23:03 -04002005
Linus Torvalds1da177e2005-04-16 15:20:36 -07002006/*
2007 * 6. Sort out the RPC call status
2008 */
2009static void
2010call_status(struct rpc_task *task)
2011{
2012 struct rpc_clnt *clnt = task->tk_client;
2013 struct rpc_rqst *req = task->tk_rqstp;
2014 int status;
2015
Ricardo Labiagadd2b63d2009-04-01 09:23:28 -04002016 if (req->rq_reply_bytes_recvd > 0 && !req->rq_bytes_sent)
2017 task->tk_status = req->rq_reply_bytes_recvd;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002018
Chuck Lever46121cf2007-01-31 12:14:08 -05002019 dprint_status(task);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002020
2021 status = task->tk_status;
2022 if (status >= 0) {
2023 task->tk_action = call_decode;
2024 return;
2025 }
2026
Steve Dickson5753cba2012-02-06 10:08:08 -05002027 trace_rpc_call_status(task);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002028 task->tk_status = 0;
2029 switch(status) {
Trond Myklebust76303992006-08-30 14:32:49 -04002030 case -EHOSTDOWN:
2031 case -EHOSTUNREACH:
2032 case -ENETUNREACH:
Jason Baron3dedbb52014-09-24 18:08:04 +00002033 case -EPERM:
Trond Myklebust9455e3f2014-03-19 13:25:43 -04002034 if (RPC_IS_SOFTCONN(task)) {
2035 rpc_exit(task, status);
2036 break;
2037 }
Trond Myklebust76303992006-08-30 14:32:49 -04002038 /*
2039 * Delay any retries for 3 seconds, then handle as if it
2040 * were a timeout.
2041 */
2042 rpc_delay(task, 3*HZ);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002043 case -ETIMEDOUT:
2044 task->tk_action = call_timeout;
Trond Myklebust8a19a0b2013-09-24 12:00:27 -04002045 if (!(task->tk_flags & RPC_TASK_NO_RETRANS_TIMEOUT)
2046 && task->tk_client->cl_discrtry)
Trond Myklebusta4f08352013-01-08 09:10:21 -05002047 xprt_conditional_disconnect(req->rq_xprt,
Trond Myklebust7c1d71c2008-04-17 16:52:57 -04002048 req->rq_connect_cookie);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002049 break;
2050 case -ECONNREFUSED:
Trond Myklebustdf277272013-12-31 13:11:43 -05002051 case -ECONNRESET:
2052 case -ECONNABORTED:
Chuck Lever35f5a422006-01-03 09:55:50 +01002053 rpc_force_rebind(clnt);
Trond Myklebust3601c4a2014-06-30 13:42:19 -04002054 case -ENOBUFS:
Trond Myklebustc8485e42009-03-11 14:37:59 -04002055 rpc_delay(task, 3*HZ);
2056 case -EPIPE:
2057 case -ENOTCONN:
Linus Torvalds1da177e2005-04-16 15:20:36 -07002058 task->tk_action = call_bind;
2059 break;
2060 case -EAGAIN:
2061 task->tk_action = call_transmit;
2062 break;
2063 case -EIO:
2064 /* shutdown or soft timeout */
2065 rpc_exit(task, status);
2066 break;
2067 default:
Olga Kornievskaiab6b61522008-06-09 16:51:31 -04002068 if (clnt->cl_chatty)
2069 printk("%s: RPC call returned error %d\n",
Trond Myklebust55909f22013-08-23 11:48:15 -04002070 clnt->cl_program->name, -status);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002071 rpc_exit(task, status);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002072 }
2073}
2074
2075/*
Trond Myklebuste0ab53d2006-07-27 17:22:50 -04002076 * 6a. Handle RPC timeout
Linus Torvalds1da177e2005-04-16 15:20:36 -07002077 * We do not release the request slot, so we keep using the
2078 * same XID for all retransmits.
2079 */
2080static void
2081call_timeout(struct rpc_task *task)
2082{
2083 struct rpc_clnt *clnt = task->tk_client;
2084
2085 if (xprt_adjust_timeout(task->tk_rqstp) == 0) {
Chuck Lever46121cf2007-01-31 12:14:08 -05002086 dprintk("RPC: %5u call_timeout (minor)\n", task->tk_pid);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002087 goto retry;
2088 }
2089
Chuck Lever46121cf2007-01-31 12:14:08 -05002090 dprintk("RPC: %5u call_timeout (major)\n", task->tk_pid);
Chuck Leveref759a22006-03-20 13:44:17 -05002091 task->tk_timeouts++;
2092
Chuck Lever3a28bec2009-12-03 15:58:56 -05002093 if (RPC_IS_SOFTCONN(task)) {
2094 rpc_exit(task, -ETIMEDOUT);
2095 return;
2096 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07002097 if (RPC_IS_SOFT(task)) {
Joe Perchescac5d072012-07-18 11:17:11 -07002098 if (clnt->cl_chatty) {
Trond Myklebust4e0038b2012-03-01 17:01:05 -05002099 rcu_read_lock();
Olga Kornievskaiab6b61522008-06-09 16:51:31 -04002100 printk(KERN_NOTICE "%s: server %s not responding, timed out\n",
Trond Myklebust55909f22013-08-23 11:48:15 -04002101 clnt->cl_program->name,
Trond Myklebust4e0038b2012-03-01 17:01:05 -05002102 rcu_dereference(clnt->cl_xprt)->servername);
2103 rcu_read_unlock();
Joe Perchescac5d072012-07-18 11:17:11 -07002104 }
Trond Myklebust7494d002011-04-24 14:28:45 -04002105 if (task->tk_flags & RPC_TASK_TIMEOUT)
2106 rpc_exit(task, -ETIMEDOUT);
2107 else
2108 rpc_exit(task, -EIO);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002109 return;
2110 }
2111
Chuck Leverf518e35a2006-01-03 09:55:52 +01002112 if (!(task->tk_flags & RPC_CALL_MAJORSEEN)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002113 task->tk_flags |= RPC_CALL_MAJORSEEN;
Trond Myklebust4e0038b2012-03-01 17:01:05 -05002114 if (clnt->cl_chatty) {
2115 rcu_read_lock();
Olga Kornievskaiab6b61522008-06-09 16:51:31 -04002116 printk(KERN_NOTICE "%s: server %s not responding, still trying\n",
Trond Myklebust55909f22013-08-23 11:48:15 -04002117 clnt->cl_program->name,
Trond Myklebust4e0038b2012-03-01 17:01:05 -05002118 rcu_dereference(clnt->cl_xprt)->servername);
2119 rcu_read_unlock();
2120 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07002121 }
Chuck Lever35f5a422006-01-03 09:55:50 +01002122 rpc_force_rebind(clnt);
Trond Myklebustb48633b2008-04-22 16:47:55 -04002123 /*
2124 * Did our request time out due to an RPCSEC_GSS out-of-sequence
2125 * event? RFC2203 requires the server to drop all such requests.
2126 */
2127 rpcauth_invalcred(task);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002128
2129retry:
Linus Torvalds1da177e2005-04-16 15:20:36 -07002130 task->tk_action = call_bind;
2131 task->tk_status = 0;
2132}
2133
2134/*
2135 * 7. Decode the RPC reply
2136 */
2137static void
2138call_decode(struct rpc_task *task)
2139{
2140 struct rpc_clnt *clnt = task->tk_client;
2141 struct rpc_rqst *req = task->tk_rqstp;
Chuck Leverbf269552010-12-14 14:59:29 +00002142 kxdrdproc_t decode = task->tk_msg.rpc_proc->p_decode;
Alexey Dobriyand8ed0292006-09-26 22:29:38 -07002143 __be32 *p;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002144
Vasily Averin726fd6a2011-06-01 16:23:59 +04002145 dprint_status(task);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002146
Chuck Leverf518e35a2006-01-03 09:55:52 +01002147 if (task->tk_flags & RPC_CALL_MAJORSEEN) {
Trond Myklebust4e0038b2012-03-01 17:01:05 -05002148 if (clnt->cl_chatty) {
2149 rcu_read_lock();
Olga Kornievskaiab6b61522008-06-09 16:51:31 -04002150 printk(KERN_NOTICE "%s: server %s OK\n",
Trond Myklebust55909f22013-08-23 11:48:15 -04002151 clnt->cl_program->name,
Trond Myklebust4e0038b2012-03-01 17:01:05 -05002152 rcu_dereference(clnt->cl_xprt)->servername);
2153 rcu_read_unlock();
2154 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07002155 task->tk_flags &= ~RPC_CALL_MAJORSEEN;
2156 }
2157
Trond Myklebust43ac3f22006-03-20 13:44:51 -05002158 /*
2159 * Ensure that we see all writes made by xprt_complete_rqst()
Ricardo Labiagadd2b63d2009-04-01 09:23:28 -04002160 * before it changed req->rq_reply_bytes_recvd.
Trond Myklebust43ac3f22006-03-20 13:44:51 -05002161 */
2162 smp_rmb();
Linus Torvalds1da177e2005-04-16 15:20:36 -07002163 req->rq_rcv_buf.len = req->rq_private_buf.len;
2164
2165 /* Check that the softirq receive buffer is valid */
2166 WARN_ON(memcmp(&req->rq_rcv_buf, &req->rq_private_buf,
2167 sizeof(req->rq_rcv_buf)) != 0);
2168
Trond Myklebust1e799b62008-03-21 16:19:41 -04002169 if (req->rq_rcv_buf.len < 12) {
2170 if (!RPC_IS_SOFT(task)) {
2171 task->tk_action = call_bind;
Trond Myklebust1e799b62008-03-21 16:19:41 -04002172 goto out_retry;
2173 }
2174 dprintk("RPC: %s: too small RPC reply size (%d bytes)\n",
Trond Myklebust55909f22013-08-23 11:48:15 -04002175 clnt->cl_program->name, task->tk_status);
Trond Myklebust1e799b62008-03-21 16:19:41 -04002176 task->tk_action = call_timeout;
2177 goto out_retry;
2178 }
2179
Chuck Leverb0e1c572008-05-21 17:09:19 -04002180 p = rpc_verify_header(task);
Trond Myklebustabbcf282006-01-03 09:55:03 +01002181 if (IS_ERR(p)) {
2182 if (p == ERR_PTR(-EAGAIN))
2183 goto out_retry;
2184 return;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002185 }
2186
Trond Myklebustabbcf282006-01-03 09:55:03 +01002187 task->tk_action = rpc_exit_task;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002188
Trond Myklebust6d5fcb52006-10-18 16:01:06 -04002189 if (decode) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002190 task->tk_status = rpcauth_unwrap_resp(task, decode, req, p,
2191 task->tk_msg.rpc_resp);
Trond Myklebust6d5fcb52006-10-18 16:01:06 -04002192 }
Chuck Lever46121cf2007-01-31 12:14:08 -05002193 dprintk("RPC: %5u call_decode result %d\n", task->tk_pid,
2194 task->tk_status);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002195 return;
2196out_retry:
Linus Torvalds1da177e2005-04-16 15:20:36 -07002197 task->tk_status = 0;
Chuck Leverb0e1c572008-05-21 17:09:19 -04002198 /* Note: rpc_verify_header() may have freed the RPC slot */
Trond Myklebust24b74bf2008-04-19 13:15:47 -04002199 if (task->tk_rqstp == req) {
Ricardo Labiagadd2b63d2009-04-01 09:23:28 -04002200 req->rq_reply_bytes_recvd = req->rq_rcv_buf.len = 0;
Trond Myklebust24b74bf2008-04-19 13:15:47 -04002201 if (task->tk_client->cl_discrtry)
Trond Myklebusta4f08352013-01-08 09:10:21 -05002202 xprt_conditional_disconnect(req->rq_xprt,
Trond Myklebust7c1d71c2008-04-17 16:52:57 -04002203 req->rq_connect_cookie);
Trond Myklebust24b74bf2008-04-19 13:15:47 -04002204 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07002205}
2206
Alexey Dobriyand8ed0292006-09-26 22:29:38 -07002207static __be32 *
Chuck Leverb0e1c572008-05-21 17:09:19 -04002208rpc_encode_header(struct rpc_task *task)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002209{
2210 struct rpc_clnt *clnt = task->tk_client;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002211 struct rpc_rqst *req = task->tk_rqstp;
Alexey Dobriyand8ed0292006-09-26 22:29:38 -07002212 __be32 *p = req->rq_svec[0].iov_base;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002213
2214 /* FIXME: check buffer size? */
Chuck Lever808012f2005-08-25 16:25:49 -07002215
Trond Myklebusta4f08352013-01-08 09:10:21 -05002216 p = xprt_skip_transport_header(req->rq_xprt, p);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002217 *p++ = req->rq_xid; /* XID */
2218 *p++ = htonl(RPC_CALL); /* CALL */
2219 *p++ = htonl(RPC_VERSION); /* RPC version */
2220 *p++ = htonl(clnt->cl_prog); /* program number */
2221 *p++ = htonl(clnt->cl_vers); /* program version */
2222 *p++ = htonl(task->tk_msg.rpc_proc->p_proc); /* procedure */
Trond Myklebust334ccfd2005-06-22 17:16:19 +00002223 p = rpcauth_marshcred(task, p);
2224 req->rq_slen = xdr_adjust_iovec(&req->rq_svec[0], p);
2225 return p;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002226}
2227
Alexey Dobriyand8ed0292006-09-26 22:29:38 -07002228static __be32 *
Chuck Leverb0e1c572008-05-21 17:09:19 -04002229rpc_verify_header(struct rpc_task *task)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002230{
Trond Myklebust4e0038b2012-03-01 17:01:05 -05002231 struct rpc_clnt *clnt = task->tk_client;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002232 struct kvec *iov = &task->tk_rqstp->rq_rcv_buf.head[0];
2233 int len = task->tk_rqstp->rq_rcv_buf.len >> 2;
Alexey Dobriyand8ed0292006-09-26 22:29:38 -07002234 __be32 *p = iov->iov_base;
2235 u32 n;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002236 int error = -EACCES;
2237
David Howellse8896492006-08-24 15:44:19 -04002238 if ((task->tk_rqstp->rq_rcv_buf.len & 3) != 0) {
2239 /* RFC-1014 says that the representation of XDR data must be a
2240 * multiple of four bytes
2241 * - if it isn't pointer subtraction in the NFS client may give
2242 * undefined results
2243 */
Trond Myklebust8a702bb2007-06-27 18:30:26 -04002244 dprintk("RPC: %5u %s: XDR representation not a multiple of"
Harvey Harrison0dc47872008-03-05 20:47:47 -08002245 " 4 bytes: 0x%x\n", task->tk_pid, __func__,
Trond Myklebust8a702bb2007-06-27 18:30:26 -04002246 task->tk_rqstp->rq_rcv_buf.len);
Andy Adamson35fa5f72013-08-14 11:59:17 -04002247 error = -EIO;
2248 goto out_err;
David Howellse8896492006-08-24 15:44:19 -04002249 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07002250 if ((len -= 3) < 0)
2251 goto out_overflow;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002252
Ricardo Labiagaf4a2e412009-04-01 09:22:54 -04002253 p += 1; /* skip XID */
Linus Torvalds1da177e2005-04-16 15:20:36 -07002254 if ((n = ntohl(*p++)) != RPC_REPLY) {
Trond Myklebust8a702bb2007-06-27 18:30:26 -04002255 dprintk("RPC: %5u %s: not an RPC reply: %x\n",
Ricardo Labiagaf4a2e412009-04-01 09:22:54 -04002256 task->tk_pid, __func__, n);
Andy Adamson35fa5f72013-08-14 11:59:17 -04002257 error = -EIO;
Trond Myklebustabbcf282006-01-03 09:55:03 +01002258 goto out_garbage;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002259 }
Ricardo Labiagaf4a2e412009-04-01 09:22:54 -04002260
Linus Torvalds1da177e2005-04-16 15:20:36 -07002261 if ((n = ntohl(*p++)) != RPC_MSG_ACCEPTED) {
2262 if (--len < 0)
2263 goto out_overflow;
2264 switch ((n = ntohl(*p++))) {
Joe Perches89f0e4f2011-07-01 09:43:12 +00002265 case RPC_AUTH_ERROR:
2266 break;
2267 case RPC_MISMATCH:
2268 dprintk("RPC: %5u %s: RPC call version mismatch!\n",
2269 task->tk_pid, __func__);
2270 error = -EPROTONOSUPPORT;
2271 goto out_err;
2272 default:
2273 dprintk("RPC: %5u %s: RPC call rejected, "
2274 "unknown error: %x\n",
2275 task->tk_pid, __func__, n);
Andy Adamson35fa5f72013-08-14 11:59:17 -04002276 error = -EIO;
2277 goto out_err;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002278 }
2279 if (--len < 0)
2280 goto out_overflow;
2281 switch ((n = ntohl(*p++))) {
2282 case RPC_AUTH_REJECTEDCRED:
2283 case RPC_AUTH_REJECTEDVERF:
2284 case RPCSEC_GSS_CREDPROBLEM:
2285 case RPCSEC_GSS_CTXPROBLEM:
2286 if (!task->tk_cred_retry)
2287 break;
2288 task->tk_cred_retry--;
Chuck Lever46121cf2007-01-31 12:14:08 -05002289 dprintk("RPC: %5u %s: retry stale creds\n",
Harvey Harrison0dc47872008-03-05 20:47:47 -08002290 task->tk_pid, __func__);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002291 rpcauth_invalcred(task);
Trond Myklebust220bcc22007-10-01 12:06:48 -04002292 /* Ensure we obtain a new XID! */
2293 xprt_release(task);
Trond Myklebust118df3d2010-10-24 17:17:31 -04002294 task->tk_action = call_reserve;
Trond Myklebustabbcf282006-01-03 09:55:03 +01002295 goto out_retry;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002296 case RPC_AUTH_BADCRED:
2297 case RPC_AUTH_BADVERF:
2298 /* possibly garbled cred/verf? */
2299 if (!task->tk_garb_retry)
2300 break;
2301 task->tk_garb_retry--;
Chuck Lever46121cf2007-01-31 12:14:08 -05002302 dprintk("RPC: %5u %s: retry garbled creds\n",
Harvey Harrison0dc47872008-03-05 20:47:47 -08002303 task->tk_pid, __func__);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002304 task->tk_action = call_bind;
Trond Myklebustabbcf282006-01-03 09:55:03 +01002305 goto out_retry;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002306 case RPC_AUTH_TOOWEAK:
Trond Myklebust4e0038b2012-03-01 17:01:05 -05002307 rcu_read_lock();
Chuck Leverb0e1c572008-05-21 17:09:19 -04002308 printk(KERN_NOTICE "RPC: server %s requires stronger "
Trond Myklebust4e0038b2012-03-01 17:01:05 -05002309 "authentication.\n",
2310 rcu_dereference(clnt->cl_xprt)->servername);
2311 rcu_read_unlock();
Linus Torvalds1da177e2005-04-16 15:20:36 -07002312 break;
2313 default:
Trond Myklebust8a702bb2007-06-27 18:30:26 -04002314 dprintk("RPC: %5u %s: unknown auth error: %x\n",
Harvey Harrison0dc47872008-03-05 20:47:47 -08002315 task->tk_pid, __func__, n);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002316 error = -EIO;
2317 }
Chuck Lever46121cf2007-01-31 12:14:08 -05002318 dprintk("RPC: %5u %s: call rejected %d\n",
Harvey Harrison0dc47872008-03-05 20:47:47 -08002319 task->tk_pid, __func__, n);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002320 goto out_err;
2321 }
Andy Adamson35fa5f72013-08-14 11:59:17 -04002322 p = rpcauth_checkverf(task, p);
2323 if (IS_ERR(p)) {
2324 error = PTR_ERR(p);
2325 dprintk("RPC: %5u %s: auth check failed with %d\n",
2326 task->tk_pid, __func__, error);
Trond Myklebustabbcf282006-01-03 09:55:03 +01002327 goto out_garbage; /* bad verifier, retry */
Linus Torvalds1da177e2005-04-16 15:20:36 -07002328 }
Alexey Dobriyand8ed0292006-09-26 22:29:38 -07002329 len = p - (__be32 *)iov->iov_base - 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002330 if (len < 0)
2331 goto out_overflow;
2332 switch ((n = ntohl(*p++))) {
2333 case RPC_SUCCESS:
2334 return p;
2335 case RPC_PROG_UNAVAIL:
Trond Myklebust4e0038b2012-03-01 17:01:05 -05002336 dprintk_rcu("RPC: %5u %s: program %u is unsupported "
2337 "by server %s\n", task->tk_pid, __func__,
2338 (unsigned int)clnt->cl_prog,
2339 rcu_dereference(clnt->cl_xprt)->servername);
Andreas Gruenbachercdf47702005-06-22 17:16:23 +00002340 error = -EPFNOSUPPORT;
2341 goto out_err;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002342 case RPC_PROG_MISMATCH:
Trond Myklebust4e0038b2012-03-01 17:01:05 -05002343 dprintk_rcu("RPC: %5u %s: program %u, version %u unsupported "
2344 "by server %s\n", task->tk_pid, __func__,
2345 (unsigned int)clnt->cl_prog,
2346 (unsigned int)clnt->cl_vers,
2347 rcu_dereference(clnt->cl_xprt)->servername);
Andreas Gruenbachercdf47702005-06-22 17:16:23 +00002348 error = -EPROTONOSUPPORT;
2349 goto out_err;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002350 case RPC_PROC_UNAVAIL:
Trond Myklebust4e0038b2012-03-01 17:01:05 -05002351 dprintk_rcu("RPC: %5u %s: proc %s unsupported by program %u, "
Chuck Lever46121cf2007-01-31 12:14:08 -05002352 "version %u on server %s\n",
Harvey Harrison0dc47872008-03-05 20:47:47 -08002353 task->tk_pid, __func__,
Chuck Lever3748f1e2008-05-21 17:09:12 -04002354 rpc_proc_name(task),
Trond Myklebust4e0038b2012-03-01 17:01:05 -05002355 clnt->cl_prog, clnt->cl_vers,
2356 rcu_dereference(clnt->cl_xprt)->servername);
Andreas Gruenbachercdf47702005-06-22 17:16:23 +00002357 error = -EOPNOTSUPP;
2358 goto out_err;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002359 case RPC_GARBAGE_ARGS:
Chuck Lever46121cf2007-01-31 12:14:08 -05002360 dprintk("RPC: %5u %s: server saw garbage\n",
Harvey Harrison0dc47872008-03-05 20:47:47 -08002361 task->tk_pid, __func__);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002362 break; /* retry */
2363 default:
Trond Myklebust8a702bb2007-06-27 18:30:26 -04002364 dprintk("RPC: %5u %s: server accept status: %x\n",
Harvey Harrison0dc47872008-03-05 20:47:47 -08002365 task->tk_pid, __func__, n);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002366 /* Also retry */
2367 }
2368
Trond Myklebustabbcf282006-01-03 09:55:03 +01002369out_garbage:
Trond Myklebust4e0038b2012-03-01 17:01:05 -05002370 clnt->cl_stats->rpcgarbage++;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002371 if (task->tk_garb_retry) {
2372 task->tk_garb_retry--;
Chuck Lever46121cf2007-01-31 12:14:08 -05002373 dprintk("RPC: %5u %s: retrying\n",
Harvey Harrison0dc47872008-03-05 20:47:47 -08002374 task->tk_pid, __func__);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002375 task->tk_action = call_bind;
Trond Myklebustabbcf282006-01-03 09:55:03 +01002376out_retry:
2377 return ERR_PTR(-EAGAIN);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002378 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07002379out_err:
2380 rpc_exit(task, error);
Trond Myklebust8a702bb2007-06-27 18:30:26 -04002381 dprintk("RPC: %5u %s: call failed with error %d\n", task->tk_pid,
Harvey Harrison0dc47872008-03-05 20:47:47 -08002382 __func__, error);
Trond Myklebustabbcf282006-01-03 09:55:03 +01002383 return ERR_PTR(error);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002384out_overflow:
Trond Myklebust8a702bb2007-06-27 18:30:26 -04002385 dprintk("RPC: %5u %s: server reply was truncated.\n", task->tk_pid,
Harvey Harrison0dc47872008-03-05 20:47:47 -08002386 __func__);
Trond Myklebustabbcf282006-01-03 09:55:03 +01002387 goto out_garbage;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002388}
Trond Myklebust5ee0ed72005-06-22 17:16:20 +00002389
Chuck Lever9f06c712010-12-14 14:59:18 +00002390static void rpcproc_encode_null(void *rqstp, struct xdr_stream *xdr, void *obj)
Trond Myklebust5ee0ed72005-06-22 17:16:20 +00002391{
Trond Myklebust5ee0ed72005-06-22 17:16:20 +00002392}
2393
Chuck Leverbf269552010-12-14 14:59:29 +00002394static int rpcproc_decode_null(void *rqstp, struct xdr_stream *xdr, void *obj)
Trond Myklebust5ee0ed72005-06-22 17:16:20 +00002395{
2396 return 0;
2397}
2398
2399static struct rpc_procinfo rpcproc_null = {
2400 .p_encode = rpcproc_encode_null,
2401 .p_decode = rpcproc_decode_null,
2402};
2403
Chuck Levercaabea82009-12-03 15:58:56 -05002404static int rpc_ping(struct rpc_clnt *clnt)
Trond Myklebust5ee0ed72005-06-22 17:16:20 +00002405{
2406 struct rpc_message msg = {
2407 .rpc_proc = &rpcproc_null,
2408 };
2409 int err;
2410 msg.rpc_cred = authnull_ops.lookup_cred(NULL, NULL, 0);
Chuck Levercaabea82009-12-03 15:58:56 -05002411 err = rpc_call_sync(clnt, &msg, RPC_TASK_SOFT | RPC_TASK_SOFTCONN);
Trond Myklebust5ee0ed72005-06-22 17:16:20 +00002412 put_rpccred(msg.rpc_cred);
2413 return err;
2414}
Trond Myklebust188fef12007-06-16 14:18:40 -04002415
Trond Myklebust5e1550d2007-06-23 10:17:16 -04002416struct rpc_task *rpc_call_null(struct rpc_clnt *clnt, struct rpc_cred *cred, int flags)
2417{
2418 struct rpc_message msg = {
2419 .rpc_proc = &rpcproc_null,
2420 .rpc_cred = cred,
2421 };
Trond Myklebust84115e12007-07-14 15:39:59 -04002422 struct rpc_task_setup task_setup_data = {
2423 .rpc_client = clnt,
2424 .rpc_message = &msg,
2425 .callback_ops = &rpc_default_ops,
2426 .flags = flags,
2427 };
Trond Myklebustc970aa82007-07-14 15:39:59 -04002428 return rpc_run_task(&task_setup_data);
Trond Myklebust5e1550d2007-06-23 10:17:16 -04002429}
Trond Myklebuste8914c62007-07-14 15:39:59 -04002430EXPORT_SYMBOL_GPL(rpc_call_null);
Trond Myklebust5e1550d2007-06-23 10:17:16 -04002431
Jeff Laytonf895b252014-11-17 16:58:04 -05002432#if IS_ENABLED(CONFIG_SUNRPC_DEBUG)
Chuck Lever68a23ee2008-05-21 17:09:26 -04002433static void rpc_show_header(void)
2434{
Chuck Levercb3997b2008-05-21 17:09:41 -04002435 printk(KERN_INFO "-pid- flgs status -client- --rqstp- "
2436 "-timeout ---ops--\n");
Chuck Lever68a23ee2008-05-21 17:09:26 -04002437}
2438
Chuck Lever38e886e2008-05-21 17:09:33 -04002439static void rpc_show_task(const struct rpc_clnt *clnt,
2440 const struct rpc_task *task)
2441{
2442 const char *rpc_waitq = "none";
Chuck Lever38e886e2008-05-21 17:09:33 -04002443
2444 if (RPC_IS_QUEUED(task))
2445 rpc_waitq = rpc_qname(task->tk_waitqueue);
2446
Joe Perchesb3bceda2010-12-21 10:52:24 -05002447 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 -04002448 task->tk_pid, task->tk_flags, task->tk_status,
2449 clnt, task->tk_rqstp, task->tk_timeout, task->tk_ops,
Trond Myklebust55909f22013-08-23 11:48:15 -04002450 clnt->cl_program->name, clnt->cl_vers, rpc_proc_name(task),
Joe Perchesb3bceda2010-12-21 10:52:24 -05002451 task->tk_action, rpc_waitq);
Chuck Lever38e886e2008-05-21 17:09:33 -04002452}
2453
Stanislav Kinsbursky70abc492012-01-12 22:07:51 +04002454void rpc_show_tasks(struct net *net)
Trond Myklebust188fef12007-06-16 14:18:40 -04002455{
2456 struct rpc_clnt *clnt;
Chuck Lever38e886e2008-05-21 17:09:33 -04002457 struct rpc_task *task;
Chuck Lever68a23ee2008-05-21 17:09:26 -04002458 int header = 0;
Stanislav Kinsbursky70abc492012-01-12 22:07:51 +04002459 struct sunrpc_net *sn = net_generic(net, sunrpc_net_id);
Trond Myklebust188fef12007-06-16 14:18:40 -04002460
Stanislav Kinsbursky70abc492012-01-12 22:07:51 +04002461 spin_lock(&sn->rpc_client_lock);
2462 list_for_each_entry(clnt, &sn->all_clients, cl_clients) {
Trond Myklebust188fef12007-06-16 14:18:40 -04002463 spin_lock(&clnt->cl_lock);
Chuck Lever38e886e2008-05-21 17:09:33 -04002464 list_for_each_entry(task, &clnt->cl_tasks, tk_task) {
Chuck Lever68a23ee2008-05-21 17:09:26 -04002465 if (!header) {
2466 rpc_show_header();
2467 header++;
2468 }
Chuck Lever38e886e2008-05-21 17:09:33 -04002469 rpc_show_task(clnt, task);
Trond Myklebust188fef12007-06-16 14:18:40 -04002470 }
2471 spin_unlock(&clnt->cl_lock);
2472 }
Stanislav Kinsbursky70abc492012-01-12 22:07:51 +04002473 spin_unlock(&sn->rpc_client_lock);
Trond Myklebust188fef12007-06-16 14:18:40 -04002474}
2475#endif