blob: 9dab9573be4146feafd1fb2db584faa3b61b0b0b [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 *
16 * NB: BSD uses a more intelligent approach to guessing when a request
17 * or reply has been lost by keeping the RTO estimate for each procedure.
18 * We currently make do with a constant timeout value.
19 *
20 * Copyright (C) 1992,1993 Rick Sladkey <jrs@world.std.com>
21 * Copyright (C) 1995,1996 Olaf Kirch <okir@monad.swb.de>
22 */
23
24#include <asm/system.h>
25
26#include <linux/module.h>
27#include <linux/types.h>
Chuck Levercb3997b2008-05-21 17:09:41 -040028#include <linux/kallsyms.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070029#include <linux/mm.h>
Trond Myklebust23ac6582009-08-09 15:14:25 -040030#include <linux/namei.h>
31#include <linux/mount.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070032#include <linux/slab.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070033#include <linux/utsname.h>
Chuck Lever11c556b2006-03-20 13:44:22 -050034#include <linux/workqueue.h>
Chuck Lever510deb02007-12-10 14:56:24 -050035#include <linux/in6.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070036
37#include <linux/sunrpc/clnt.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070038#include <linux/sunrpc/rpc_pipe_fs.h>
Chuck Lever11c556b2006-03-20 13:44:22 -050039#include <linux/sunrpc/metrics.h>
Ricardo Labiaga55ae1aa2009-04-01 09:23:03 -040040#include <linux/sunrpc/bc_xprt.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070041
Ricardo Labiaga55ae1aa2009-04-01 09:23:03 -040042#include "sunrpc.h"
Linus Torvalds1da177e2005-04-16 15:20:36 -070043
Linus Torvalds1da177e2005-04-16 15:20:36 -070044#ifdef RPC_DEBUG
45# define RPCDBG_FACILITY RPCDBG_CALL
46#endif
47
Chuck Lever46121cf2007-01-31 12:14:08 -050048#define dprint_status(t) \
49 dprintk("RPC: %5u %s (status %d)\n", t->tk_pid, \
Harvey Harrison0dc47872008-03-05 20:47:47 -080050 __func__, t->tk_status)
Chuck Lever46121cf2007-01-31 12:14:08 -050051
Trond Myklebust188fef12007-06-16 14:18:40 -040052/*
53 * All RPC clients are linked into this list
54 */
55static LIST_HEAD(all_clients);
56static DEFINE_SPINLOCK(rpc_client_lock);
57
Linus Torvalds1da177e2005-04-16 15:20:36 -070058static DECLARE_WAIT_QUEUE_HEAD(destroy_wait);
59
60
61static void call_start(struct rpc_task *task);
62static void call_reserve(struct rpc_task *task);
63static void call_reserveresult(struct rpc_task *task);
64static void call_allocate(struct rpc_task *task);
Linus Torvalds1da177e2005-04-16 15:20:36 -070065static void call_decode(struct rpc_task *task);
66static void call_bind(struct rpc_task *task);
Chuck Leverda351872005-08-11 16:25:11 -040067static void call_bind_status(struct rpc_task *task);
Linus Torvalds1da177e2005-04-16 15:20:36 -070068static void call_transmit(struct rpc_task *task);
Ricardo Labiaga55ae1aa2009-04-01 09:23:03 -040069#if defined(CONFIG_NFS_V4_1)
70static void call_bc_transmit(struct rpc_task *task);
71#endif /* CONFIG_NFS_V4_1 */
Linus Torvalds1da177e2005-04-16 15:20:36 -070072static void call_status(struct rpc_task *task);
Trond Myklebust940e3312005-11-09 21:45:24 -050073static void call_transmit_status(struct rpc_task *task);
Linus Torvalds1da177e2005-04-16 15:20:36 -070074static void call_refresh(struct rpc_task *task);
75static void call_refreshresult(struct rpc_task *task);
76static void call_timeout(struct rpc_task *task);
77static void call_connect(struct rpc_task *task);
78static void call_connect_status(struct rpc_task *task);
Linus Torvalds1da177e2005-04-16 15:20:36 -070079
Chuck Leverb0e1c572008-05-21 17:09:19 -040080static __be32 *rpc_encode_header(struct rpc_task *task);
81static __be32 *rpc_verify_header(struct rpc_task *task);
Chuck Levercaabea82009-12-03 15:58:56 -050082static int rpc_ping(struct rpc_clnt *clnt);
Trond Myklebust64c91a12007-06-23 10:17:16 -040083
Trond Myklebust188fef12007-06-16 14:18:40 -040084static void rpc_register_client(struct rpc_clnt *clnt)
85{
86 spin_lock(&rpc_client_lock);
87 list_add(&clnt->cl_clients, &all_clients);
88 spin_unlock(&rpc_client_lock);
89}
90
91static void rpc_unregister_client(struct rpc_clnt *clnt)
92{
93 spin_lock(&rpc_client_lock);
94 list_del(&clnt->cl_clients);
95 spin_unlock(&rpc_client_lock);
96}
Linus Torvalds1da177e2005-04-16 15:20:36 -070097
98static int
99rpc_setup_pipedir(struct rpc_clnt *clnt, char *dir_name)
100{
Trond Myklebustf1345852005-09-23 11:08:25 -0400101 static uint32_t clntid;
Trond Myklebust23ac6582009-08-09 15:14:25 -0400102 struct nameidata nd;
103 struct path path;
104 char name[15];
105 struct qstr q = {
106 .name = name,
107 };
Linus Torvalds1da177e2005-04-16 15:20:36 -0700108 int error;
109
Trond Myklebust7d217ca2009-08-09 15:14:24 -0400110 clnt->cl_path.mnt = ERR_PTR(-ENOENT);
111 clnt->cl_path.dentry = ERR_PTR(-ENOENT);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700112 if (dir_name == NULL)
113 return 0;
Trond Myklebust54281542006-03-20 13:44:49 -0500114
Trond Myklebust23ac6582009-08-09 15:14:25 -0400115 path.mnt = rpc_get_mount();
116 if (IS_ERR(path.mnt))
117 return PTR_ERR(path.mnt);
118 error = vfs_path_lookup(path.mnt->mnt_root, path.mnt, dir_name, 0, &nd);
119 if (error)
120 goto err;
Trond Myklebust54281542006-03-20 13:44:49 -0500121
Trond Myklebustf1345852005-09-23 11:08:25 -0400122 for (;;) {
Trond Myklebust23ac6582009-08-09 15:14:25 -0400123 q.len = snprintf(name, sizeof(name), "clnt%x", (unsigned int)clntid++);
124 name[sizeof(name) - 1] = '\0';
125 q.hash = full_name_hash(q.name, q.len);
126 path.dentry = rpc_create_client_dir(nd.path.dentry, &q, clnt);
127 if (!IS_ERR(path.dentry))
128 break;
129 error = PTR_ERR(path.dentry);
Trond Myklebustf1345852005-09-23 11:08:25 -0400130 if (error != -EEXIST) {
Trond Myklebust23ac6582009-08-09 15:14:25 -0400131 printk(KERN_INFO "RPC: Couldn't create pipefs entry"
132 " %s/%s, error %d\n",
133 dir_name, name, error);
134 goto err_path_put;
Trond Myklebustf1345852005-09-23 11:08:25 -0400135 }
Christoph Hellwig278c9952005-07-24 23:53:01 +0100136 }
Trond Myklebust23ac6582009-08-09 15:14:25 -0400137 path_put(&nd.path);
138 clnt->cl_path = path;
139 return 0;
140err_path_put:
141 path_put(&nd.path);
142err:
143 rpc_put_mount();
144 return error;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700145}
146
Trond Myklebust698b6d02007-12-20 16:03:53 -0500147static struct rpc_clnt * rpc_new_client(const struct rpc_create_args *args, struct rpc_xprt *xprt)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700148{
Trond Myklebust698b6d02007-12-20 16:03:53 -0500149 struct rpc_program *program = args->program;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700150 struct rpc_version *version;
151 struct rpc_clnt *clnt = NULL;
J. Bruce Fields6a192752005-06-22 17:16:23 +0000152 struct rpc_auth *auth;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700153 int err;
Chuck Lever06b8d252007-09-11 18:00:20 -0400154 size_t len;
155
156 /* sanity check the name before trying to print it */
157 err = -EINVAL;
Trond Myklebust698b6d02007-12-20 16:03:53 -0500158 len = strlen(args->servername);
Chuck Lever06b8d252007-09-11 18:00:20 -0400159 if (len > RPC_MAXNETNAMELEN)
160 goto out_no_rpciod;
161 len++;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700162
Chuck Lever46121cf2007-01-31 12:14:08 -0500163 dprintk("RPC: creating %s client for %s (xprt %p)\n",
Trond Myklebust698b6d02007-12-20 16:03:53 -0500164 program->name, args->servername, xprt);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700165
Trond Myklebust4ada5392007-06-14 17:26:17 -0400166 err = rpciod_up();
167 if (err)
168 goto out_no_rpciod;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700169 err = -EINVAL;
170 if (!xprt)
Adrian Bunk712917d2006-03-13 21:20:47 -0800171 goto out_no_xprt;
Trond Myklebust698b6d02007-12-20 16:03:53 -0500172
173 if (args->version >= program->nrvers)
174 goto out_err;
175 version = program->version[args->version];
176 if (version == NULL)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700177 goto out_err;
178
179 err = -ENOMEM;
Panagiotis Issaris0da974f2006-07-21 14:51:30 -0700180 clnt = kzalloc(sizeof(*clnt), GFP_KERNEL);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700181 if (!clnt)
182 goto out_err;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700183 clnt->cl_parent = clnt;
184
185 clnt->cl_server = clnt->cl_inline_name;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700186 if (len > sizeof(clnt->cl_inline_name)) {
187 char *buf = kmalloc(len, GFP_KERNEL);
Trond Myklebust698b6d02007-12-20 16:03:53 -0500188 if (buf != NULL)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700189 clnt->cl_server = buf;
190 else
191 len = sizeof(clnt->cl_inline_name);
192 }
Trond Myklebust698b6d02007-12-20 16:03:53 -0500193 strlcpy(clnt->cl_server, args->servername, len);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700194
195 clnt->cl_xprt = xprt;
196 clnt->cl_procinfo = version->procs;
197 clnt->cl_maxproc = version->nrprocs;
198 clnt->cl_protname = program->name;
Benny Halevyd5b337b2008-09-28 09:21:26 +0300199 clnt->cl_prog = args->prognumber ? : program->number;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700200 clnt->cl_vers = version->number;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700201 clnt->cl_stats = program->stats;
Chuck Lever11c556b2006-03-20 13:44:22 -0500202 clnt->cl_metrics = rpc_alloc_iostats(clnt);
Trond Myklebust23bf85b2006-11-21 10:40:23 -0500203 err = -ENOMEM;
204 if (clnt->cl_metrics == NULL)
205 goto out_no_stats;
Trond Myklebust3e32a5d2006-11-16 11:37:27 -0500206 clnt->cl_program = program;
Trond Myklebust6529eba2007-06-14 16:40:14 -0400207 INIT_LIST_HEAD(&clnt->cl_tasks);
Trond Myklebust4bef61f2007-06-16 14:17:01 -0400208 spin_lock_init(&clnt->cl_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700209
Chuck Leverec739ef2006-08-22 20:06:15 -0400210 if (!xprt_bound(clnt->cl_xprt))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700211 clnt->cl_autobind = 1;
212
Trond Myklebustba7392b2007-12-20 16:03:55 -0500213 clnt->cl_timeout = xprt->timeout;
214 if (args->timeout != NULL) {
215 memcpy(&clnt->cl_timeout_default, args->timeout,
216 sizeof(clnt->cl_timeout_default));
217 clnt->cl_timeout = &clnt->cl_timeout_default;
218 }
219
Linus Torvalds1da177e2005-04-16 15:20:36 -0700220 clnt->cl_rtt = &clnt->cl_rtt_default;
Trond Myklebustba7392b2007-12-20 16:03:55 -0500221 rpc_init_rtt(&clnt->cl_rtt_default, clnt->cl_timeout->to_initval);
Olga Kornievskaia608207e2008-12-23 16:17:40 -0500222 clnt->cl_principal = NULL;
223 if (args->client_name) {
224 clnt->cl_principal = kstrdup(args->client_name, GFP_KERNEL);
225 if (!clnt->cl_principal)
226 goto out_no_principal;
227 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700228
Trond Myklebust006abe82010-09-12 19:55:25 -0400229 atomic_set(&clnt->cl_count, 1);
Trond Myklebust34f52e32007-06-14 16:40:31 -0400230
Linus Torvalds1da177e2005-04-16 15:20:36 -0700231 err = rpc_setup_pipedir(clnt, program->pipe_dir_name);
232 if (err < 0)
233 goto out_no_path;
234
Trond Myklebust698b6d02007-12-20 16:03:53 -0500235 auth = rpcauth_create(args->authflavor, clnt);
J. Bruce Fields6a192752005-06-22 17:16:23 +0000236 if (IS_ERR(auth)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700237 printk(KERN_INFO "RPC: Couldn't create auth handle (flavor %u)\n",
Trond Myklebust698b6d02007-12-20 16:03:53 -0500238 args->authflavor);
J. Bruce Fields6a192752005-06-22 17:16:23 +0000239 err = PTR_ERR(auth);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700240 goto out_no_auth;
241 }
242
243 /* save the nodename */
Cedric Le Goater63ffc232008-10-03 23:41:51 -0400244 clnt->cl_nodelen = strlen(init_utsname()->nodename);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700245 if (clnt->cl_nodelen > UNX_MAXNODENAME)
246 clnt->cl_nodelen = UNX_MAXNODENAME;
Cedric Le Goater63ffc232008-10-03 23:41:51 -0400247 memcpy(clnt->cl_nodename, init_utsname()->nodename, clnt->cl_nodelen);
Trond Myklebust6529eba2007-06-14 16:40:14 -0400248 rpc_register_client(clnt);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700249 return clnt;
250
251out_no_auth:
Trond Myklebust7d217ca2009-08-09 15:14:24 -0400252 if (!IS_ERR(clnt->cl_path.dentry)) {
253 rpc_remove_client_dir(clnt->cl_path.dentry);
Trond Myklebust54281542006-03-20 13:44:49 -0500254 rpc_put_mount();
255 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700256out_no_path:
Olga Kornievskaia608207e2008-12-23 16:17:40 -0500257 kfree(clnt->cl_principal);
258out_no_principal:
Trond Myklebust23bf85b2006-11-21 10:40:23 -0500259 rpc_free_iostats(clnt->cl_metrics);
260out_no_stats:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700261 if (clnt->cl_server != clnt->cl_inline_name)
262 kfree(clnt->cl_server);
263 kfree(clnt);
264out_err:
Trond Myklebust6b6ca862006-09-05 12:55:57 -0400265 xprt_put(xprt);
Adrian Bunk712917d2006-03-13 21:20:47 -0800266out_no_xprt:
Trond Myklebust4ada5392007-06-14 17:26:17 -0400267 rpciod_down();
268out_no_rpciod:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700269 return ERR_PTR(err);
270}
271
Chuck Leverc2866762006-08-22 20:06:20 -0400272/*
273 * rpc_create - create an RPC client and transport with one call
274 * @args: rpc_clnt create argument structure
275 *
276 * Creates and initializes an RPC transport and an RPC client.
277 *
278 * It can ping the server in order to determine if it is up, and to see if
279 * it supports this program and version. RPC_CLNT_CREATE_NOPING disables
280 * this behavior so asynchronous tasks can also use rpc_create.
281 */
282struct rpc_clnt *rpc_create(struct rpc_create_args *args)
283{
284 struct rpc_xprt *xprt;
285 struct rpc_clnt *clnt;
\"Talpey, Thomas\3c341b0b2007-09-10 13:47:07 -0400286 struct xprt_create xprtargs = {
Pavel Emelyanov9a23e332010-09-29 16:05:12 +0400287 .net = args->net,
\"Talpey, Thomas\4fa016e2007-09-10 13:47:57 -0400288 .ident = args->protocol,
Frank van Maarseveend3bc9a12007-07-09 22:23:35 +0200289 .srcaddr = args->saddress,
Frank van Maarseveen96802a02007-07-08 13:08:54 +0200290 .dstaddr = args->address,
291 .addrlen = args->addrsize,
Alexandros Batsakisf300bab2009-09-10 17:33:30 +0300292 .bc_xprt = args->bc_xprt,
Frank van Maarseveen96802a02007-07-08 13:08:54 +0200293 };
Chuck Lever510deb02007-12-10 14:56:24 -0500294 char servername[48];
Chuck Leverc2866762006-08-22 20:06:20 -0400295
Chuck Leverc2866762006-08-22 20:06:20 -0400296 /*
Chuck Lever43780b82007-07-01 12:13:22 -0400297 * If the caller chooses not to specify a hostname, whip
298 * up a string representation of the passed-in address.
299 */
300 if (args->servername == NULL) {
Chuck Lever510deb02007-12-10 14:56:24 -0500301 servername[0] = '\0';
302 switch (args->address->sa_family) {
303 case AF_INET: {
304 struct sockaddr_in *sin =
305 (struct sockaddr_in *)args->address;
Harvey Harrison21454aa2008-10-31 00:54:56 -0700306 snprintf(servername, sizeof(servername), "%pI4",
307 &sin->sin_addr.s_addr);
Chuck Lever510deb02007-12-10 14:56:24 -0500308 break;
309 }
310 case AF_INET6: {
311 struct sockaddr_in6 *sin =
312 (struct sockaddr_in6 *)args->address;
Harvey Harrison5b095d9892008-10-29 12:52:50 -0700313 snprintf(servername, sizeof(servername), "%pI6",
Harvey Harrisonfdb46ee2008-10-28 16:10:17 -0700314 &sin->sin6_addr);
Chuck Lever510deb02007-12-10 14:56:24 -0500315 break;
316 }
317 default:
318 /* caller wants default server name, but
319 * address family isn't recognized. */
320 return ERR_PTR(-EINVAL);
321 }
Chuck Lever43780b82007-07-01 12:13:22 -0400322 args->servername = servername;
323 }
324
Chuck Lever510deb02007-12-10 14:56:24 -0500325 xprt = xprt_create_transport(&xprtargs);
326 if (IS_ERR(xprt))
327 return (struct rpc_clnt *)xprt;
328
Chuck Lever43780b82007-07-01 12:13:22 -0400329 /*
Chuck Leverc2866762006-08-22 20:06:20 -0400330 * By default, kernel RPC client connects from a reserved port.
331 * CAP_NET_BIND_SERVICE will not be set for unprivileged requesters,
332 * but it is always enabled for rpciod, which handles the connect
333 * operation.
334 */
335 xprt->resvport = 1;
336 if (args->flags & RPC_CLNT_CREATE_NONPRIVPORT)
337 xprt->resvport = 0;
338
Trond Myklebust698b6d02007-12-20 16:03:53 -0500339 clnt = rpc_new_client(args, xprt);
Chuck Leverc2866762006-08-22 20:06:20 -0400340 if (IS_ERR(clnt))
341 return clnt;
342
343 if (!(args->flags & RPC_CLNT_CREATE_NOPING)) {
Chuck Levercaabea82009-12-03 15:58:56 -0500344 int err = rpc_ping(clnt);
Chuck Leverc2866762006-08-22 20:06:20 -0400345 if (err != 0) {
346 rpc_shutdown_client(clnt);
347 return ERR_PTR(err);
348 }
349 }
350
351 clnt->cl_softrtry = 1;
352 if (args->flags & RPC_CLNT_CREATE_HARDRTRY)
353 clnt->cl_softrtry = 0;
354
Chuck Leverc2866762006-08-22 20:06:20 -0400355 if (args->flags & RPC_CLNT_CREATE_AUTOBIND)
356 clnt->cl_autobind = 1;
Chuck Lever43d78ef2007-02-06 18:26:11 -0500357 if (args->flags & RPC_CLNT_CREATE_DISCRTRY)
358 clnt->cl_discrtry = 1;
Olga Kornievskaiab6b61522008-06-09 16:51:31 -0400359 if (!(args->flags & RPC_CLNT_CREATE_QUIET))
360 clnt->cl_chatty = 1;
Chuck Leverc2866762006-08-22 20:06:20 -0400361
362 return clnt;
363}
Chuck Leverb86acd52006-08-22 20:06:22 -0400364EXPORT_SYMBOL_GPL(rpc_create);
Chuck Leverc2866762006-08-22 20:06:20 -0400365
Linus Torvalds1da177e2005-04-16 15:20:36 -0700366/*
367 * This function clones the RPC client structure. It allows us to share the
368 * same transport while varying parameters such as the authentication
369 * flavour.
370 */
371struct rpc_clnt *
372rpc_clone_client(struct rpc_clnt *clnt)
373{
374 struct rpc_clnt *new;
Trond Myklebust3e32a5d2006-11-16 11:37:27 -0500375 int err = -ENOMEM;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700376
Arnaldo Carvalho de Meloe69062b2006-11-21 01:21:34 -0200377 new = kmemdup(clnt, sizeof(*new), GFP_KERNEL);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700378 if (!new)
379 goto out_no_clnt;
Trond Myklebustd431a5552007-06-17 17:07:54 -0400380 new->cl_parent = clnt;
381 /* Turn off autobind on clones */
382 new->cl_autobind = 0;
383 INIT_LIST_HEAD(&new->cl_tasks);
384 spin_lock_init(&new->cl_lock);
Trond Myklebustba7392b2007-12-20 16:03:55 -0500385 rpc_init_rtt(&new->cl_rtt_default, clnt->cl_timeout->to_initval);
Trond Myklebust23bf85b2006-11-21 10:40:23 -0500386 new->cl_metrics = rpc_alloc_iostats(clnt);
387 if (new->cl_metrics == NULL)
388 goto out_no_stats;
Olga Kornievskaia608207e2008-12-23 16:17:40 -0500389 if (clnt->cl_principal) {
390 new->cl_principal = kstrdup(clnt->cl_principal, GFP_KERNEL);
391 if (new->cl_principal == NULL)
392 goto out_no_principal;
393 }
Trond Myklebust006abe82010-09-12 19:55:25 -0400394 atomic_set(&new->cl_count, 1);
Trond Myklebust3e32a5d2006-11-16 11:37:27 -0500395 err = rpc_setup_pipedir(new, clnt->cl_program->pipe_dir_name);
396 if (err != 0)
397 goto out_no_path;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700398 if (new->cl_auth)
399 atomic_inc(&new->cl_auth->au_count);
Trond Myklebustd431a5552007-06-17 17:07:54 -0400400 xprt_get(clnt->cl_xprt);
Trond Myklebust006abe82010-09-12 19:55:25 -0400401 atomic_inc(&clnt->cl_count);
Trond Myklebust6529eba2007-06-14 16:40:14 -0400402 rpc_register_client(new);
Trond Myklebust4ada5392007-06-14 17:26:17 -0400403 rpciod_up();
Linus Torvalds1da177e2005-04-16 15:20:36 -0700404 return new;
Trond Myklebust3e32a5d2006-11-16 11:37:27 -0500405out_no_path:
Olga Kornievskaia608207e2008-12-23 16:17:40 -0500406 kfree(new->cl_principal);
407out_no_principal:
Trond Myklebust3e32a5d2006-11-16 11:37:27 -0500408 rpc_free_iostats(new->cl_metrics);
Trond Myklebust23bf85b2006-11-21 10:40:23 -0500409out_no_stats:
410 kfree(new);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700411out_no_clnt:
Harvey Harrison0dc47872008-03-05 20:47:47 -0800412 dprintk("RPC: %s: returned error %d\n", __func__, err);
Trond Myklebust3e32a5d2006-11-16 11:37:27 -0500413 return ERR_PTR(err);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700414}
Trond Myklebuste8914c62007-07-14 15:39:59 -0400415EXPORT_SYMBOL_GPL(rpc_clone_client);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700416
417/*
Trond Myklebust58f96122010-07-31 14:29:08 -0400418 * Kill all tasks for the given client.
419 * XXX: kill their descendants as well?
420 */
421void rpc_killall_tasks(struct rpc_clnt *clnt)
422{
423 struct rpc_task *rovr;
424
425
426 if (list_empty(&clnt->cl_tasks))
427 return;
428 dprintk("RPC: killing all tasks for client %p\n", clnt);
429 /*
430 * Spin lock all_tasks to prevent changes...
431 */
432 spin_lock(&clnt->cl_lock);
433 list_for_each_entry(rovr, &clnt->cl_tasks, tk_task) {
434 if (!RPC_IS_ACTIVATED(rovr))
435 continue;
436 if (!(rovr->tk_flags & RPC_TASK_KILLED)) {
437 rovr->tk_flags |= RPC_TASK_KILLED;
438 rpc_exit(rovr, -EIO);
439 rpc_wake_up_queued_task(rovr->tk_waitqueue, rovr);
440 }
441 }
442 spin_unlock(&clnt->cl_lock);
443}
444EXPORT_SYMBOL_GPL(rpc_killall_tasks);
445
446/*
Linus Torvalds1da177e2005-04-16 15:20:36 -0700447 * Properly shut down an RPC client, terminating all outstanding
Trond Myklebust90c57552007-06-09 19:49:36 -0400448 * requests.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700449 */
Trond Myklebust4c402b42007-06-14 16:40:32 -0400450void rpc_shutdown_client(struct rpc_clnt *clnt)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700451{
Trond Myklebust34f52e32007-06-14 16:40:31 -0400452 dprintk("RPC: shutting down %s client for %s\n",
453 clnt->cl_protname, clnt->cl_server);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700454
Trond Myklebust34f52e32007-06-14 16:40:31 -0400455 while (!list_empty(&clnt->cl_tasks)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700456 rpc_killall_tasks(clnt);
Ingo Molnar532347e2006-01-09 20:52:53 -0800457 wait_event_timeout(destroy_wait,
Trond Myklebust34f52e32007-06-14 16:40:31 -0400458 list_empty(&clnt->cl_tasks), 1*HZ);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700459 }
460
Trond Myklebust4c402b42007-06-14 16:40:32 -0400461 rpc_release_client(clnt);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700462}
Trond Myklebuste8914c62007-07-14 15:39:59 -0400463EXPORT_SYMBOL_GPL(rpc_shutdown_client);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700464
465/*
Trond Myklebust34f52e32007-06-14 16:40:31 -0400466 * Free an RPC client
Linus Torvalds1da177e2005-04-16 15:20:36 -0700467 */
Trond Myklebust34f52e32007-06-14 16:40:31 -0400468static void
Trond Myklebust006abe82010-09-12 19:55:25 -0400469rpc_free_client(struct rpc_clnt *clnt)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700470{
Chuck Lever46121cf2007-01-31 12:14:08 -0500471 dprintk("RPC: destroying %s client for %s\n",
Linus Torvalds1da177e2005-04-16 15:20:36 -0700472 clnt->cl_protname, clnt->cl_server);
Trond Myklebust7d217ca2009-08-09 15:14:24 -0400473 if (!IS_ERR(clnt->cl_path.dentry)) {
474 rpc_remove_client_dir(clnt->cl_path.dentry);
Trond Myklebust8f8e7a52006-08-14 13:11:15 -0400475 rpc_put_mount();
476 }
Trond Myklebust3e32a5d2006-11-16 11:37:27 -0500477 if (clnt->cl_parent != clnt) {
Trond Myklebust8ad7c892007-06-14 16:40:32 -0400478 rpc_release_client(clnt->cl_parent);
Trond Myklebust3e32a5d2006-11-16 11:37:27 -0500479 goto out_free;
480 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700481 if (clnt->cl_server != clnt->cl_inline_name)
482 kfree(clnt->cl_server);
483out_free:
Trond Myklebust6529eba2007-06-14 16:40:14 -0400484 rpc_unregister_client(clnt);
Chuck Lever11c556b2006-03-20 13:44:22 -0500485 rpc_free_iostats(clnt->cl_metrics);
Olga Kornievskaia608207e2008-12-23 16:17:40 -0500486 kfree(clnt->cl_principal);
Chuck Lever11c556b2006-03-20 13:44:22 -0500487 clnt->cl_metrics = NULL;
Trond Myklebust6b6ca862006-09-05 12:55:57 -0400488 xprt_put(clnt->cl_xprt);
Trond Myklebust4ada5392007-06-14 17:26:17 -0400489 rpciod_down();
Linus Torvalds1da177e2005-04-16 15:20:36 -0700490 kfree(clnt);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700491}
492
493/*
Trond Myklebust1dd17ec2007-06-26 16:57:41 -0400494 * Free an RPC client
495 */
496static void
Trond Myklebust006abe82010-09-12 19:55:25 -0400497rpc_free_auth(struct rpc_clnt *clnt)
Trond Myklebust1dd17ec2007-06-26 16:57:41 -0400498{
Trond Myklebust1dd17ec2007-06-26 16:57:41 -0400499 if (clnt->cl_auth == NULL) {
Trond Myklebust006abe82010-09-12 19:55:25 -0400500 rpc_free_client(clnt);
Trond Myklebust1dd17ec2007-06-26 16:57:41 -0400501 return;
502 }
503
504 /*
505 * Note: RPCSEC_GSS may need to send NULL RPC calls in order to
506 * release remaining GSS contexts. This mechanism ensures
507 * that it can do so safely.
508 */
Trond Myklebust006abe82010-09-12 19:55:25 -0400509 atomic_inc(&clnt->cl_count);
Trond Myklebust1dd17ec2007-06-26 16:57:41 -0400510 rpcauth_release(clnt->cl_auth);
511 clnt->cl_auth = NULL;
Trond Myklebust006abe82010-09-12 19:55:25 -0400512 if (atomic_dec_and_test(&clnt->cl_count))
513 rpc_free_client(clnt);
Trond Myklebust1dd17ec2007-06-26 16:57:41 -0400514}
515
516/*
Trond Myklebust34f52e32007-06-14 16:40:31 -0400517 * Release reference to the RPC client
Linus Torvalds1da177e2005-04-16 15:20:36 -0700518 */
519void
520rpc_release_client(struct rpc_clnt *clnt)
521{
Trond Myklebust34f52e32007-06-14 16:40:31 -0400522 dprintk("RPC: rpc_release_client(%p)\n", clnt);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700523
Trond Myklebust34f52e32007-06-14 16:40:31 -0400524 if (list_empty(&clnt->cl_tasks))
525 wake_up(&destroy_wait);
Trond Myklebust006abe82010-09-12 19:55:25 -0400526 if (atomic_dec_and_test(&clnt->cl_count))
527 rpc_free_auth(clnt);
Trond Myklebust34f52e32007-06-14 16:40:31 -0400528}
529
Andreas Gruenbacher007e2512005-06-22 17:16:23 +0000530/**
531 * rpc_bind_new_program - bind a new RPC program to an existing client
Randy Dunlap65b6e422008-02-13 15:03:23 -0800532 * @old: old rpc_client
533 * @program: rpc program to set
534 * @vers: rpc program version
Andreas Gruenbacher007e2512005-06-22 17:16:23 +0000535 *
536 * Clones the rpc client and sets up a new RPC program. This is mainly
537 * of use for enabling different RPC programs to share the same transport.
538 * The Sun NFSv2/v3 ACL protocol can do this.
539 */
540struct rpc_clnt *rpc_bind_new_program(struct rpc_clnt *old,
541 struct rpc_program *program,
Chuck Lever89eb21c2007-09-11 18:00:09 -0400542 u32 vers)
Andreas Gruenbacher007e2512005-06-22 17:16:23 +0000543{
544 struct rpc_clnt *clnt;
545 struct rpc_version *version;
546 int err;
547
548 BUG_ON(vers >= program->nrvers || !program->version[vers]);
549 version = program->version[vers];
550 clnt = rpc_clone_client(old);
551 if (IS_ERR(clnt))
552 goto out;
553 clnt->cl_procinfo = version->procs;
554 clnt->cl_maxproc = version->nrprocs;
555 clnt->cl_protname = program->name;
556 clnt->cl_prog = program->number;
557 clnt->cl_vers = version->number;
558 clnt->cl_stats = program->stats;
Chuck Levercaabea82009-12-03 15:58:56 -0500559 err = rpc_ping(clnt);
Andreas Gruenbacher007e2512005-06-22 17:16:23 +0000560 if (err != 0) {
561 rpc_shutdown_client(clnt);
562 clnt = ERR_PTR(err);
563 }
YOSHIFUJI Hideakicca51722007-02-09 15:38:13 -0800564out:
Andreas Gruenbacher007e2512005-06-22 17:16:23 +0000565 return clnt;
566}
Trond Myklebuste8914c62007-07-14 15:39:59 -0400567EXPORT_SYMBOL_GPL(rpc_bind_new_program);
Andreas Gruenbacher007e2512005-06-22 17:16:23 +0000568
Trond Myklebust58f96122010-07-31 14:29:08 -0400569void rpc_task_release_client(struct rpc_task *task)
570{
571 struct rpc_clnt *clnt = task->tk_client;
572
573 if (clnt != NULL) {
574 /* Remove from client task list */
575 spin_lock(&clnt->cl_lock);
576 list_del(&task->tk_task);
577 spin_unlock(&clnt->cl_lock);
578 task->tk_client = NULL;
579
580 rpc_release_client(clnt);
581 }
582}
583
584static
585void rpc_task_set_client(struct rpc_task *task, struct rpc_clnt *clnt)
586{
587 if (clnt != NULL) {
588 rpc_task_release_client(task);
589 task->tk_client = clnt;
Trond Myklebust006abe82010-09-12 19:55:25 -0400590 atomic_inc(&clnt->cl_count);
Trond Myklebust58f96122010-07-31 14:29:08 -0400591 if (clnt->cl_softrtry)
592 task->tk_flags |= RPC_TASK_SOFT;
593 /* Add to the client's list of all tasks */
594 spin_lock(&clnt->cl_lock);
595 list_add_tail(&task->tk_task, &clnt->cl_tasks);
596 spin_unlock(&clnt->cl_lock);
597 }
598}
599
600static void
601rpc_task_set_rpc_message(struct rpc_task *task, const struct rpc_message *msg)
602{
603 if (msg != NULL) {
604 task->tk_msg.rpc_proc = msg->rpc_proc;
605 task->tk_msg.rpc_argp = msg->rpc_argp;
606 task->tk_msg.rpc_resp = msg->rpc_resp;
Trond Myklebusta17c2152010-07-31 14:29:08 -0400607 if (msg->rpc_cred != NULL)
608 task->tk_msg.rpc_cred = get_rpccred(msg->rpc_cred);
Trond Myklebust58f96122010-07-31 14:29:08 -0400609 }
610}
611
Linus Torvalds1da177e2005-04-16 15:20:36 -0700612/*
613 * Default callback for async RPC calls
614 */
615static void
Trond Myklebust963d8fe2006-01-03 09:55:04 +0100616rpc_default_callback(struct rpc_task *task, void *data)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700617{
618}
619
Trond Myklebust963d8fe2006-01-03 09:55:04 +0100620static const struct rpc_call_ops rpc_default_ops = {
621 .rpc_call_done = rpc_default_callback,
622};
623
Trond Myklebustc970aa82007-07-14 15:39:59 -0400624/**
625 * rpc_run_task - Allocate a new RPC task, then run rpc_execute against it
626 * @task_setup_data: pointer to task initialisation data
627 */
628struct rpc_task *rpc_run_task(const struct rpc_task_setup *task_setup_data)
Trond Myklebust6e5b70e2007-06-12 10:02:37 -0400629{
Trond Myklebust19445b92010-04-16 16:41:10 -0400630 struct rpc_task *task;
Trond Myklebust6e5b70e2007-06-12 10:02:37 -0400631
Trond Myklebust84115e12007-07-14 15:39:59 -0400632 task = rpc_new_task(task_setup_data);
Trond Myklebust19445b92010-04-16 16:41:10 -0400633 if (IS_ERR(task))
Trond Myklebust50859252007-10-25 18:19:37 -0400634 goto out;
Trond Myklebust6e5b70e2007-06-12 10:02:37 -0400635
Trond Myklebust58f96122010-07-31 14:29:08 -0400636 rpc_task_set_client(task, task_setup_data->rpc_client);
637 rpc_task_set_rpc_message(task, task_setup_data->rpc_message);
638
639 if (task->tk_status != 0) {
640 int ret = task->tk_status;
641 rpc_put_task(task);
642 return ERR_PTR(ret);
643 }
644
645 if (task->tk_action == NULL)
646 rpc_call_start(task);
647
Trond Myklebust6e5b70e2007-06-12 10:02:37 -0400648 atomic_inc(&task->tk_count);
649 rpc_execute(task);
Trond Myklebust6e5b70e2007-06-12 10:02:37 -0400650out:
Trond Myklebust19445b92010-04-16 16:41:10 -0400651 return task;
Trond Myklebust6e5b70e2007-06-12 10:02:37 -0400652}
Trond Myklebustc970aa82007-07-14 15:39:59 -0400653EXPORT_SYMBOL_GPL(rpc_run_task);
Trond Myklebust6e5b70e2007-06-12 10:02:37 -0400654
655/**
656 * rpc_call_sync - Perform a synchronous RPC call
657 * @clnt: pointer to RPC client
658 * @msg: RPC call parameters
659 * @flags: RPC call flags
Linus Torvalds1da177e2005-04-16 15:20:36 -0700660 */
Trond Myklebustcbc20052008-02-14 11:11:30 -0500661int rpc_call_sync(struct rpc_clnt *clnt, const struct rpc_message *msg, int flags)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700662{
663 struct rpc_task *task;
Trond Myklebust84115e12007-07-14 15:39:59 -0400664 struct rpc_task_setup task_setup_data = {
665 .rpc_client = clnt,
666 .rpc_message = msg,
667 .callback_ops = &rpc_default_ops,
668 .flags = flags,
669 };
Trond Myklebust6e5b70e2007-06-12 10:02:37 -0400670 int status;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700671
Linus Torvalds1da177e2005-04-16 15:20:36 -0700672 BUG_ON(flags & RPC_TASK_ASYNC);
673
Trond Myklebustc970aa82007-07-14 15:39:59 -0400674 task = rpc_run_task(&task_setup_data);
Trond Myklebust6e5b70e2007-06-12 10:02:37 -0400675 if (IS_ERR(task))
676 return PTR_ERR(task);
Trond Myklebuste60859a2006-01-03 09:55:10 +0100677 status = task->tk_status;
Trond Myklebustbde8f002007-01-24 11:54:53 -0800678 rpc_put_task(task);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700679 return status;
680}
Trond Myklebuste8914c62007-07-14 15:39:59 -0400681EXPORT_SYMBOL_GPL(rpc_call_sync);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700682
Trond Myklebust6e5b70e2007-06-12 10:02:37 -0400683/**
684 * rpc_call_async - Perform an asynchronous RPC call
685 * @clnt: pointer to RPC client
686 * @msg: RPC call parameters
687 * @flags: RPC call flags
Randy Dunlap65b6e422008-02-13 15:03:23 -0800688 * @tk_ops: RPC call ops
Trond Myklebust6e5b70e2007-06-12 10:02:37 -0400689 * @data: user call data
Linus Torvalds1da177e2005-04-16 15:20:36 -0700690 */
691int
Trond Myklebustcbc20052008-02-14 11:11:30 -0500692rpc_call_async(struct rpc_clnt *clnt, const struct rpc_message *msg, int flags,
Trond Myklebust963d8fe2006-01-03 09:55:04 +0100693 const struct rpc_call_ops *tk_ops, void *data)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700694{
695 struct rpc_task *task;
Trond Myklebust84115e12007-07-14 15:39:59 -0400696 struct rpc_task_setup task_setup_data = {
697 .rpc_client = clnt,
698 .rpc_message = msg,
699 .callback_ops = tk_ops,
700 .callback_data = data,
701 .flags = flags|RPC_TASK_ASYNC,
702 };
Linus Torvalds1da177e2005-04-16 15:20:36 -0700703
Trond Myklebustc970aa82007-07-14 15:39:59 -0400704 task = rpc_run_task(&task_setup_data);
Trond Myklebust6e5b70e2007-06-12 10:02:37 -0400705 if (IS_ERR(task))
706 return PTR_ERR(task);
707 rpc_put_task(task);
708 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700709}
Trond Myklebuste8914c62007-07-14 15:39:59 -0400710EXPORT_SYMBOL_GPL(rpc_call_async);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700711
Ricardo Labiaga55ae1aa2009-04-01 09:23:03 -0400712#if defined(CONFIG_NFS_V4_1)
713/**
714 * rpc_run_bc_task - Allocate a new RPC task for backchannel use, then run
715 * rpc_execute against it
Jaswinder Singh Rajput7a73fdd2009-09-24 14:58:42 -0400716 * @req: RPC request
717 * @tk_ops: RPC call ops
Ricardo Labiaga55ae1aa2009-04-01 09:23:03 -0400718 */
719struct rpc_task *rpc_run_bc_task(struct rpc_rqst *req,
Jaswinder Singh Rajput7a73fdd2009-09-24 14:58:42 -0400720 const struct rpc_call_ops *tk_ops)
Ricardo Labiaga55ae1aa2009-04-01 09:23:03 -0400721{
722 struct rpc_task *task;
723 struct xdr_buf *xbufp = &req->rq_snd_buf;
724 struct rpc_task_setup task_setup_data = {
725 .callback_ops = tk_ops,
726 };
727
728 dprintk("RPC: rpc_run_bc_task req= %p\n", req);
729 /*
730 * Create an rpc_task to send the data
731 */
732 task = rpc_new_task(&task_setup_data);
Trond Myklebust19445b92010-04-16 16:41:10 -0400733 if (IS_ERR(task)) {
Ricardo Labiaga55ae1aa2009-04-01 09:23:03 -0400734 xprt_free_bc_request(req);
735 goto out;
736 }
737 task->tk_rqstp = req;
738
739 /*
740 * Set up the xdr_buf length.
741 * This also indicates that the buffer is XDR encoded already.
742 */
743 xbufp->len = xbufp->head[0].iov_len + xbufp->page_len +
744 xbufp->tail[0].iov_len;
745
746 task->tk_action = call_bc_transmit;
747 atomic_inc(&task->tk_count);
748 BUG_ON(atomic_read(&task->tk_count) != 2);
749 rpc_execute(task);
750
751out:
752 dprintk("RPC: rpc_run_bc_task: task= %p\n", task);
753 return task;
754}
755#endif /* CONFIG_NFS_V4_1 */
756
Linus Torvalds1da177e2005-04-16 15:20:36 -0700757void
Trond Myklebust77de2c52007-10-25 18:40:21 -0400758rpc_call_start(struct rpc_task *task)
759{
760 task->tk_action = call_start;
761}
762EXPORT_SYMBOL_GPL(rpc_call_start);
763
Chuck Levered394402006-08-22 20:06:17 -0400764/**
765 * rpc_peeraddr - extract remote peer address from clnt's xprt
766 * @clnt: RPC client structure
767 * @buf: target buffer
Randy Dunlap65b6e422008-02-13 15:03:23 -0800768 * @bufsize: length of target buffer
Chuck Levered394402006-08-22 20:06:17 -0400769 *
770 * Returns the number of bytes that are actually in the stored address.
771 */
772size_t rpc_peeraddr(struct rpc_clnt *clnt, struct sockaddr *buf, size_t bufsize)
773{
774 size_t bytes;
775 struct rpc_xprt *xprt = clnt->cl_xprt;
776
777 bytes = sizeof(xprt->addr);
778 if (bytes > bufsize)
779 bytes = bufsize;
780 memcpy(buf, &clnt->cl_xprt->addr, bytes);
Chuck Leverc4efcb12006-08-22 20:06:19 -0400781 return xprt->addrlen;
Chuck Levered394402006-08-22 20:06:17 -0400782}
Chuck Leverb86acd52006-08-22 20:06:22 -0400783EXPORT_SYMBOL_GPL(rpc_peeraddr);
Chuck Levered394402006-08-22 20:06:17 -0400784
Chuck Leverf425eba2006-08-22 20:06:18 -0400785/**
786 * rpc_peeraddr2str - return remote peer address in printable format
787 * @clnt: RPC client structure
788 * @format: address format
789 *
790 */
Chuck Leverb454ae92008-01-07 18:34:48 -0500791const char *rpc_peeraddr2str(struct rpc_clnt *clnt,
792 enum rpc_display_format_t format)
Chuck Leverf425eba2006-08-22 20:06:18 -0400793{
794 struct rpc_xprt *xprt = clnt->cl_xprt;
Chuck Lever7559c7a2006-12-05 16:35:37 -0500795
796 if (xprt->address_strings[format] != NULL)
797 return xprt->address_strings[format];
798 else
799 return "unprintable";
Chuck Leverf425eba2006-08-22 20:06:18 -0400800}
Chuck Leverb86acd52006-08-22 20:06:22 -0400801EXPORT_SYMBOL_GPL(rpc_peeraddr2str);
Chuck Leverf425eba2006-08-22 20:06:18 -0400802
Linus Torvalds1da177e2005-04-16 15:20:36 -0700803void
804rpc_setbufsize(struct rpc_clnt *clnt, unsigned int sndsize, unsigned int rcvsize)
805{
806 struct rpc_xprt *xprt = clnt->cl_xprt;
Chuck Lever470056c2005-08-25 16:25:56 -0700807 if (xprt->ops->set_buffer_size)
808 xprt->ops->set_buffer_size(xprt, sndsize, rcvsize);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700809}
Trond Myklebuste8914c62007-07-14 15:39:59 -0400810EXPORT_SYMBOL_GPL(rpc_setbufsize);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700811
812/*
813 * Return size of largest payload RPC client can support, in bytes
814 *
815 * For stream transports, this is one RPC record fragment (see RFC
816 * 1831), as we don't support multi-record requests yet. For datagram
817 * transports, this is the size of an IP packet minus the IP, UDP, and
818 * RPC header sizes.
819 */
820size_t rpc_max_payload(struct rpc_clnt *clnt)
821{
822 return clnt->cl_xprt->max_payload;
823}
Chuck Leverb86acd52006-08-22 20:06:22 -0400824EXPORT_SYMBOL_GPL(rpc_max_payload);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700825
Chuck Lever35f5a422006-01-03 09:55:50 +0100826/**
827 * rpc_force_rebind - force transport to check that remote port is unchanged
828 * @clnt: client to rebind
829 *
830 */
831void rpc_force_rebind(struct rpc_clnt *clnt)
832{
833 if (clnt->cl_autobind)
Chuck Leverec739ef2006-08-22 20:06:15 -0400834 xprt_clear_bound(clnt->cl_xprt);
Chuck Lever35f5a422006-01-03 09:55:50 +0100835}
Chuck Leverb86acd52006-08-22 20:06:22 -0400836EXPORT_SYMBOL_GPL(rpc_force_rebind);
Chuck Lever35f5a422006-01-03 09:55:50 +0100837
Linus Torvalds1da177e2005-04-16 15:20:36 -0700838/*
Andy Adamsonaae20062009-04-01 09:22:40 -0400839 * Restart an (async) RPC call from the call_prepare state.
840 * Usually called from within the exit handler.
841 */
Trond Myklebustf1f88fc2010-07-31 14:29:07 -0400842int
Andy Adamsonaae20062009-04-01 09:22:40 -0400843rpc_restart_call_prepare(struct rpc_task *task)
844{
845 if (RPC_ASSASSINATED(task))
Trond Myklebustf1f88fc2010-07-31 14:29:07 -0400846 return 0;
Andy Adamsonaae20062009-04-01 09:22:40 -0400847 task->tk_action = rpc_prepare_task;
Trond Myklebustf1f88fc2010-07-31 14:29:07 -0400848 return 1;
Andy Adamsonaae20062009-04-01 09:22:40 -0400849}
850EXPORT_SYMBOL_GPL(rpc_restart_call_prepare);
851
852/*
Linus Torvalds1da177e2005-04-16 15:20:36 -0700853 * Restart an (async) RPC call. Usually called from within the
854 * exit handler.
855 */
Trond Myklebustf1f88fc2010-07-31 14:29:07 -0400856int
Linus Torvalds1da177e2005-04-16 15:20:36 -0700857rpc_restart_call(struct rpc_task *task)
858{
859 if (RPC_ASSASSINATED(task))
Trond Myklebustf1f88fc2010-07-31 14:29:07 -0400860 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700861 task->tk_action = call_start;
Trond Myklebustf1f88fc2010-07-31 14:29:07 -0400862 return 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700863}
Trond Myklebuste8914c62007-07-14 15:39:59 -0400864EXPORT_SYMBOL_GPL(rpc_restart_call);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700865
Chuck Lever3748f1e2008-05-21 17:09:12 -0400866#ifdef RPC_DEBUG
867static const char *rpc_proc_name(const struct rpc_task *task)
868{
869 const struct rpc_procinfo *proc = task->tk_msg.rpc_proc;
870
871 if (proc) {
872 if (proc->p_name)
873 return proc->p_name;
874 else
875 return "NULL";
876 } else
877 return "no proc";
878}
879#endif
880
Linus Torvalds1da177e2005-04-16 15:20:36 -0700881/*
882 * 0. Initial state
883 *
884 * Other FSM states can be visited zero or more times, but
885 * this state is visited exactly once for each RPC.
886 */
887static void
888call_start(struct rpc_task *task)
889{
890 struct rpc_clnt *clnt = task->tk_client;
891
Chuck Lever3748f1e2008-05-21 17:09:12 -0400892 dprintk("RPC: %5u call_start %s%d proc %s (%s)\n", task->tk_pid,
Chuck Lever46121cf2007-01-31 12:14:08 -0500893 clnt->cl_protname, clnt->cl_vers,
Chuck Lever3748f1e2008-05-21 17:09:12 -0400894 rpc_proc_name(task),
Chuck Lever46121cf2007-01-31 12:14:08 -0500895 (RPC_IS_ASYNC(task) ? "async" : "sync"));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700896
897 /* Increment call count */
898 task->tk_msg.rpc_proc->p_count++;
899 clnt->cl_stats->rpccnt++;
900 task->tk_action = call_reserve;
901}
902
903/*
904 * 1. Reserve an RPC call slot
905 */
906static void
907call_reserve(struct rpc_task *task)
908{
Chuck Lever46121cf2007-01-31 12:14:08 -0500909 dprint_status(task);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700910
Linus Torvalds1da177e2005-04-16 15:20:36 -0700911 task->tk_status = 0;
912 task->tk_action = call_reserveresult;
913 xprt_reserve(task);
914}
915
916/*
917 * 1b. Grok the result of xprt_reserve()
918 */
919static void
920call_reserveresult(struct rpc_task *task)
921{
922 int status = task->tk_status;
923
Chuck Lever46121cf2007-01-31 12:14:08 -0500924 dprint_status(task);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700925
926 /*
927 * After a call to xprt_reserve(), we must have either
928 * a request slot or else an error status.
929 */
930 task->tk_status = 0;
931 if (status >= 0) {
932 if (task->tk_rqstp) {
J. Bruce Fieldsf2d47d02010-09-12 19:55:25 -0400933 task->tk_action = call_refresh;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700934 return;
935 }
936
937 printk(KERN_ERR "%s: status=%d, but no request slot, exiting\n",
Harvey Harrison0dc47872008-03-05 20:47:47 -0800938 __func__, status);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700939 rpc_exit(task, -EIO);
940 return;
941 }
942
943 /*
944 * Even though there was an error, we may have acquired
945 * a request slot somehow. Make sure not to leak it.
946 */
947 if (task->tk_rqstp) {
948 printk(KERN_ERR "%s: status=%d, request allocated anyway\n",
Harvey Harrison0dc47872008-03-05 20:47:47 -0800949 __func__, status);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700950 xprt_release(task);
951 }
952
953 switch (status) {
954 case -EAGAIN: /* woken up; retry */
955 task->tk_action = call_reserve;
956 return;
957 case -EIO: /* probably a shutdown */
958 break;
959 default:
960 printk(KERN_ERR "%s: unrecognized error %d, exiting\n",
Harvey Harrison0dc47872008-03-05 20:47:47 -0800961 __func__, status);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700962 break;
963 }
964 rpc_exit(task, status);
965}
966
967/*
J. Bruce Fields55576242010-09-12 19:55:25 -0400968 * 2. Bind and/or refresh the credentials
969 */
970static void
971call_refresh(struct rpc_task *task)
972{
973 dprint_status(task);
974
975 task->tk_action = call_refreshresult;
976 task->tk_status = 0;
977 task->tk_client->cl_stats->rpcauthrefresh++;
978 rpcauth_refreshcred(task);
979}
980
981/*
982 * 2a. Process the results of a credential refresh
983 */
984static void
985call_refreshresult(struct rpc_task *task)
986{
987 int status = task->tk_status;
988
989 dprint_status(task);
990
991 task->tk_status = 0;
992 task->tk_action = call_allocate;
993 if (status >= 0 && rpcauth_uptodatecred(task))
994 return;
995 switch (status) {
996 case -EACCES:
997 rpc_exit(task, -EACCES);
998 return;
999 case -ENOMEM:
1000 rpc_exit(task, -ENOMEM);
1001 return;
1002 case -ETIMEDOUT:
1003 rpc_delay(task, 3*HZ);
1004 }
1005 task->tk_action = call_refresh;
1006}
1007
1008/*
1009 * 2b. Allocate the buffer. For details, see sched.c:rpc_malloc.
Chuck Lever02107142006-01-03 09:55:49 +01001010 * (Note: buffer memory is freed in xprt_release).
Linus Torvalds1da177e2005-04-16 15:20:36 -07001011 */
1012static void
1013call_allocate(struct rpc_task *task)
1014{
J. Bruce Fieldsf2d47d02010-09-12 19:55:25 -04001015 unsigned int slack = task->tk_rqstp->rq_cred->cr_auth->au_cslack;
Chuck Lever02107142006-01-03 09:55:49 +01001016 struct rpc_rqst *req = task->tk_rqstp;
1017 struct rpc_xprt *xprt = task->tk_xprt;
Chuck Lever2bea90d2007-03-29 16:47:53 -04001018 struct rpc_procinfo *proc = task->tk_msg.rpc_proc;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001019
Chuck Lever46121cf2007-01-31 12:14:08 -05001020 dprint_status(task);
1021
Chuck Lever2bea90d2007-03-29 16:47:53 -04001022 task->tk_status = 0;
J. Bruce Fieldsf2d47d02010-09-12 19:55:25 -04001023 task->tk_action = call_bind;
Chuck Lever2bea90d2007-03-29 16:47:53 -04001024
Chuck Lever02107142006-01-03 09:55:49 +01001025 if (req->rq_buffer)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001026 return;
1027
Chuck Lever2bea90d2007-03-29 16:47:53 -04001028 if (proc->p_proc != 0) {
1029 BUG_ON(proc->p_arglen == 0);
1030 if (proc->p_decode != NULL)
1031 BUG_ON(proc->p_replen == 0);
1032 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001033
Chuck Lever2bea90d2007-03-29 16:47:53 -04001034 /*
1035 * Calculate the size (in quads) of the RPC call
1036 * and reply headers, and convert both values
1037 * to byte sizes.
1038 */
1039 req->rq_callsize = RPC_CALLHDRSIZE + (slack << 1) + proc->p_arglen;
1040 req->rq_callsize <<= 2;
1041 req->rq_rcvsize = RPC_REPHDRSIZE + slack + proc->p_replen;
1042 req->rq_rcvsize <<= 2;
1043
Chuck Leverc5a4dd82007-03-29 16:47:58 -04001044 req->rq_buffer = xprt->ops->buf_alloc(task,
1045 req->rq_callsize + req->rq_rcvsize);
Chuck Lever2bea90d2007-03-29 16:47:53 -04001046 if (req->rq_buffer != NULL)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001047 return;
Chuck Lever46121cf2007-01-31 12:14:08 -05001048
1049 dprintk("RPC: %5u rpc_buffer allocation failed\n", task->tk_pid);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001050
Trond Myklebust14b218a2005-06-22 17:16:28 +00001051 if (RPC_IS_ASYNC(task) || !signalled()) {
Trond Myklebustb6e9c712007-10-01 12:06:44 -04001052 task->tk_action = call_allocate;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001053 rpc_delay(task, HZ>>4);
1054 return;
1055 }
1056
1057 rpc_exit(task, -ERESTARTSYS);
1058}
1059
Trond Myklebust940e3312005-11-09 21:45:24 -05001060static inline int
1061rpc_task_need_encode(struct rpc_task *task)
1062{
1063 return task->tk_rqstp->rq_snd_buf.len == 0;
1064}
1065
1066static inline void
1067rpc_task_force_reencode(struct rpc_task *task)
1068{
1069 task->tk_rqstp->rq_snd_buf.len = 0;
Trond Myklebust2574cc92009-08-28 11:12:12 -04001070 task->tk_rqstp->rq_bytes_sent = 0;
Trond Myklebust940e3312005-11-09 21:45:24 -05001071}
1072
Chuck Lever2bea90d2007-03-29 16:47:53 -04001073static inline void
1074rpc_xdr_buf_init(struct xdr_buf *buf, void *start, size_t len)
1075{
1076 buf->head[0].iov_base = start;
1077 buf->head[0].iov_len = len;
1078 buf->tail[0].iov_len = 0;
1079 buf->page_len = 0;
\"Talpey, Thomas\4f22ccc2007-09-10 13:44:58 -04001080 buf->flags = 0;
Chuck Lever2bea90d2007-03-29 16:47:53 -04001081 buf->len = 0;
1082 buf->buflen = len;
1083}
1084
Linus Torvalds1da177e2005-04-16 15:20:36 -07001085/*
1086 * 3. Encode arguments of an RPC call
1087 */
1088static void
Chuck Leverb0e1c572008-05-21 17:09:19 -04001089rpc_xdr_encode(struct rpc_task *task)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001090{
Linus Torvalds1da177e2005-04-16 15:20:36 -07001091 struct rpc_rqst *req = task->tk_rqstp;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001092 kxdrproc_t encode;
Alexey Dobriyand8ed0292006-09-26 22:29:38 -07001093 __be32 *p;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001094
Chuck Lever46121cf2007-01-31 12:14:08 -05001095 dprint_status(task);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001096
Chuck Lever2bea90d2007-03-29 16:47:53 -04001097 rpc_xdr_buf_init(&req->rq_snd_buf,
1098 req->rq_buffer,
1099 req->rq_callsize);
1100 rpc_xdr_buf_init(&req->rq_rcv_buf,
1101 (char *)req->rq_buffer + req->rq_callsize,
1102 req->rq_rcvsize);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001103
Chuck Leverb0e1c572008-05-21 17:09:19 -04001104 p = rpc_encode_header(task);
1105 if (p == NULL) {
1106 printk(KERN_INFO "RPC: couldn't encode RPC header, exit EIO\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -07001107 rpc_exit(task, -EIO);
1108 return;
1109 }
Chuck Leverb0e1c572008-05-21 17:09:19 -04001110
1111 encode = task->tk_msg.rpc_proc->p_encode;
J. Bruce Fieldsf3680312005-10-13 16:54:48 -04001112 if (encode == NULL)
1113 return;
1114
1115 task->tk_status = rpcauth_wrap_req(task, encode, req, p,
1116 task->tk_msg.rpc_argp);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001117}
1118
1119/*
1120 * 4. Get the server port number if not yet set
1121 */
1122static void
1123call_bind(struct rpc_task *task)
1124{
Chuck Leverec739ef2006-08-22 20:06:15 -04001125 struct rpc_xprt *xprt = task->tk_xprt;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001126
Chuck Lever46121cf2007-01-31 12:14:08 -05001127 dprint_status(task);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001128
Chuck Leverda351872005-08-11 16:25:11 -04001129 task->tk_action = call_connect;
Chuck Leverec739ef2006-08-22 20:06:15 -04001130 if (!xprt_bound(xprt)) {
Chuck Leverda351872005-08-11 16:25:11 -04001131 task->tk_action = call_bind_status;
Chuck Leverec739ef2006-08-22 20:06:15 -04001132 task->tk_timeout = xprt->bind_timeout;
Chuck Leverbbf7c1d2006-08-22 20:06:16 -04001133 xprt->ops->rpcbind(task);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001134 }
1135}
1136
1137/*
Chuck Leverda351872005-08-11 16:25:11 -04001138 * 4a. Sort out bind result
1139 */
1140static void
1141call_bind_status(struct rpc_task *task)
1142{
Chuck Lever906462a2007-09-11 18:00:47 -04001143 int status = -EIO;
Chuck Leverda351872005-08-11 16:25:11 -04001144
1145 if (task->tk_status >= 0) {
Chuck Lever46121cf2007-01-31 12:14:08 -05001146 dprint_status(task);
Chuck Leverda351872005-08-11 16:25:11 -04001147 task->tk_status = 0;
1148 task->tk_action = call_connect;
1149 return;
1150 }
1151
1152 switch (task->tk_status) {
Trond Myklebust381ba742008-07-07 12:18:53 -04001153 case -ENOMEM:
1154 dprintk("RPC: %5u rpcbind out of memory\n", task->tk_pid);
1155 rpc_delay(task, HZ >> 2);
Chuck Lever2429cbf2007-09-11 18:00:41 -04001156 goto retry_timeout;
Chuck Leverda351872005-08-11 16:25:11 -04001157 case -EACCES:
Chuck Lever46121cf2007-01-31 12:14:08 -05001158 dprintk("RPC: %5u remote rpcbind: RPC program/version "
1159 "unavailable\n", task->tk_pid);
Chuck Leverb79dc8c2007-09-11 18:00:52 -04001160 /* fail immediately if this is an RPC ping */
1161 if (task->tk_msg.rpc_proc->p_proc == 0) {
1162 status = -EOPNOTSUPP;
1163 break;
1164 }
Chuck Leverea635a52005-10-06 23:12:58 -04001165 rpc_delay(task, 3*HZ);
Trond Myklebustda458282006-08-31 15:44:52 -04001166 goto retry_timeout;
Chuck Leverda351872005-08-11 16:25:11 -04001167 case -ETIMEDOUT:
Chuck Lever46121cf2007-01-31 12:14:08 -05001168 dprintk("RPC: %5u rpcbind request timed out\n",
Chuck Leverda351872005-08-11 16:25:11 -04001169 task->tk_pid);
Trond Myklebustda458282006-08-31 15:44:52 -04001170 goto retry_timeout;
Chuck Leverda351872005-08-11 16:25:11 -04001171 case -EPFNOSUPPORT:
Chuck Lever906462a2007-09-11 18:00:47 -04001172 /* server doesn't support any rpcbind version we know of */
Chuck Lever012da152009-12-03 15:58:56 -05001173 dprintk("RPC: %5u unrecognized remote rpcbind service\n",
Chuck Leverda351872005-08-11 16:25:11 -04001174 task->tk_pid);
1175 break;
1176 case -EPROTONOSUPPORT:
Chuck Lever00a6e7b2007-03-29 16:48:33 -04001177 dprintk("RPC: %5u remote rpcbind version unavailable, retrying\n",
Chuck Leverda351872005-08-11 16:25:11 -04001178 task->tk_pid);
Chuck Lever00a6e7b2007-03-29 16:48:33 -04001179 task->tk_status = 0;
1180 task->tk_action = call_bind;
1181 return;
Chuck Lever012da152009-12-03 15:58:56 -05001182 case -ECONNREFUSED: /* connection problems */
1183 case -ECONNRESET:
1184 case -ENOTCONN:
1185 case -EHOSTDOWN:
1186 case -EHOSTUNREACH:
1187 case -ENETUNREACH:
1188 case -EPIPE:
1189 dprintk("RPC: %5u remote rpcbind unreachable: %d\n",
1190 task->tk_pid, task->tk_status);
1191 if (!RPC_IS_SOFTCONN(task)) {
1192 rpc_delay(task, 5*HZ);
1193 goto retry_timeout;
1194 }
1195 status = task->tk_status;
1196 break;
Chuck Leverda351872005-08-11 16:25:11 -04001197 default:
Chuck Lever46121cf2007-01-31 12:14:08 -05001198 dprintk("RPC: %5u unrecognized rpcbind error (%d)\n",
Chuck Leverda351872005-08-11 16:25:11 -04001199 task->tk_pid, -task->tk_status);
Chuck Leverda351872005-08-11 16:25:11 -04001200 }
1201
1202 rpc_exit(task, status);
1203 return;
1204
Trond Myklebustda458282006-08-31 15:44:52 -04001205retry_timeout:
1206 task->tk_action = call_timeout;
Chuck Leverda351872005-08-11 16:25:11 -04001207}
1208
1209/*
1210 * 4b. Connect to the RPC server
Linus Torvalds1da177e2005-04-16 15:20:36 -07001211 */
1212static void
1213call_connect(struct rpc_task *task)
1214{
Chuck Leverda351872005-08-11 16:25:11 -04001215 struct rpc_xprt *xprt = task->tk_xprt;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001216
Chuck Lever46121cf2007-01-31 12:14:08 -05001217 dprintk("RPC: %5u call_connect xprt %p %s connected\n",
Chuck Leverda351872005-08-11 16:25:11 -04001218 task->tk_pid, xprt,
1219 (xprt_connected(xprt) ? "is" : "is not"));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001220
Chuck Leverda351872005-08-11 16:25:11 -04001221 task->tk_action = call_transmit;
1222 if (!xprt_connected(xprt)) {
1223 task->tk_action = call_connect_status;
1224 if (task->tk_status < 0)
1225 return;
1226 xprt_connect(task);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001227 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001228}
1229
1230/*
Chuck Leverda351872005-08-11 16:25:11 -04001231 * 4c. Sort out connect result
Linus Torvalds1da177e2005-04-16 15:20:36 -07001232 */
1233static void
1234call_connect_status(struct rpc_task *task)
1235{
1236 struct rpc_clnt *clnt = task->tk_client;
1237 int status = task->tk_status;
1238
Chuck Lever46121cf2007-01-31 12:14:08 -05001239 dprint_status(task);
Chuck Leverda351872005-08-11 16:25:11 -04001240
Linus Torvalds1da177e2005-04-16 15:20:36 -07001241 task->tk_status = 0;
Trond Myklebust2a491992009-03-11 14:38:00 -04001242 if (status >= 0 || status == -EAGAIN) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001243 clnt->cl_stats->netreconn++;
1244 task->tk_action = call_transmit;
1245 return;
1246 }
1247
Linus Torvalds1da177e2005-04-16 15:20:36 -07001248 switch (status) {
Trond Myklebustda458282006-08-31 15:44:52 -04001249 /* if soft mounted, test if we've timed out */
1250 case -ETIMEDOUT:
1251 task->tk_action = call_timeout;
Trond Myklebust2a491992009-03-11 14:38:00 -04001252 break;
1253 default:
1254 rpc_exit(task, -EIO);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001255 }
1256}
1257
1258/*
1259 * 5. Transmit the RPC request, and wait for reply
1260 */
1261static void
1262call_transmit(struct rpc_task *task)
1263{
Chuck Lever46121cf2007-01-31 12:14:08 -05001264 dprint_status(task);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001265
1266 task->tk_action = call_status;
1267 if (task->tk_status < 0)
1268 return;
1269 task->tk_status = xprt_prepare_transmit(task);
1270 if (task->tk_status != 0)
1271 return;
Trond Myklebuste0ab53d2006-07-27 17:22:50 -04001272 task->tk_action = call_transmit_status;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001273 /* Encode here so that rpcsec_gss can use correct sequence number. */
Trond Myklebust940e3312005-11-09 21:45:24 -05001274 if (rpc_task_need_encode(task)) {
Trond Myklebuste0ab53d2006-07-27 17:22:50 -04001275 BUG_ON(task->tk_rqstp->rq_bytes_sent != 0);
Chuck Leverb0e1c572008-05-21 17:09:19 -04001276 rpc_xdr_encode(task);
Trond Myklebust5e5ce5b2005-10-18 14:20:11 -07001277 /* Did the encode result in an error condition? */
Trond Myklebust8b39f2b2008-05-14 19:48:25 -07001278 if (task->tk_status != 0) {
1279 /* Was the error nonfatal? */
1280 if (task->tk_status == -EAGAIN)
1281 rpc_delay(task, HZ >> 4);
1282 else
1283 rpc_exit(task, task->tk_status);
Trond Myklebuste0ab53d2006-07-27 17:22:50 -04001284 return;
Trond Myklebust8b39f2b2008-05-14 19:48:25 -07001285 }
Trond Myklebust5e5ce5b2005-10-18 14:20:11 -07001286 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001287 xprt_transmit(task);
1288 if (task->tk_status < 0)
1289 return;
Trond Myklebuste0ab53d2006-07-27 17:22:50 -04001290 /*
1291 * On success, ensure that we call xprt_end_transmit() before sleeping
1292 * in order to allow access to the socket to other RPC requests.
1293 */
1294 call_transmit_status(task);
Ricardo Labiaga55ae1aa2009-04-01 09:23:03 -04001295 if (rpc_reply_expected(task))
Trond Myklebuste0ab53d2006-07-27 17:22:50 -04001296 return;
1297 task->tk_action = rpc_exit_task;
Trond Myklebustfda13932008-02-22 16:34:12 -05001298 rpc_wake_up_queued_task(&task->tk_xprt->pending, task);
Trond Myklebuste0ab53d2006-07-27 17:22:50 -04001299}
1300
1301/*
1302 * 5a. Handle cleanup after a transmission
1303 */
1304static void
1305call_transmit_status(struct rpc_task *task)
1306{
1307 task->tk_action = call_status;
Chuck Lever206a1342009-12-03 15:58:56 -05001308
1309 /*
1310 * Common case: success. Force the compiler to put this
1311 * test first.
1312 */
1313 if (task->tk_status == 0) {
1314 xprt_end_transmit(task);
1315 rpc_task_force_reencode(task);
1316 return;
1317 }
1318
Trond Myklebust15f081c2009-03-11 14:37:57 -04001319 switch (task->tk_status) {
1320 case -EAGAIN:
1321 break;
1322 default:
Chuck Lever206a1342009-12-03 15:58:56 -05001323 dprint_status(task);
Trond Myklebust15f081c2009-03-11 14:37:57 -04001324 xprt_end_transmit(task);
Chuck Lever09a21c42009-12-03 15:58:56 -05001325 rpc_task_force_reencode(task);
1326 break;
Trond Myklebust15f081c2009-03-11 14:37:57 -04001327 /*
1328 * Special cases: if we've been waiting on the
1329 * socket's write_space() callback, or if the
1330 * socket just returned a connection error,
1331 * then hold onto the transport lock.
1332 */
1333 case -ECONNREFUSED:
Trond Myklebust15f081c2009-03-11 14:37:57 -04001334 case -EHOSTDOWN:
1335 case -EHOSTUNREACH:
1336 case -ENETUNREACH:
Chuck Lever09a21c42009-12-03 15:58:56 -05001337 if (RPC_IS_SOFTCONN(task)) {
1338 xprt_end_transmit(task);
1339 rpc_exit(task, task->tk_status);
1340 break;
1341 }
1342 case -ECONNRESET:
1343 case -ENOTCONN:
Trond Myklebustc8485e42009-03-11 14:37:59 -04001344 case -EPIPE:
Trond Myklebust15f081c2009-03-11 14:37:57 -04001345 rpc_task_force_reencode(task);
1346 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001347}
1348
Ricardo Labiaga55ae1aa2009-04-01 09:23:03 -04001349#if defined(CONFIG_NFS_V4_1)
1350/*
1351 * 5b. Send the backchannel RPC reply. On error, drop the reply. In
1352 * addition, disconnect on connectivity errors.
1353 */
1354static void
1355call_bc_transmit(struct rpc_task *task)
1356{
1357 struct rpc_rqst *req = task->tk_rqstp;
1358
1359 BUG_ON(task->tk_status != 0);
1360 task->tk_status = xprt_prepare_transmit(task);
1361 if (task->tk_status == -EAGAIN) {
1362 /*
1363 * Could not reserve the transport. Try again after the
1364 * transport is released.
1365 */
1366 task->tk_status = 0;
1367 task->tk_action = call_bc_transmit;
1368 return;
1369 }
1370
1371 task->tk_action = rpc_exit_task;
1372 if (task->tk_status < 0) {
1373 printk(KERN_NOTICE "RPC: Could not send backchannel reply "
1374 "error: %d\n", task->tk_status);
1375 return;
1376 }
1377
1378 xprt_transmit(task);
1379 xprt_end_transmit(task);
1380 dprint_status(task);
1381 switch (task->tk_status) {
1382 case 0:
1383 /* Success */
1384 break;
1385 case -EHOSTDOWN:
1386 case -EHOSTUNREACH:
1387 case -ENETUNREACH:
1388 case -ETIMEDOUT:
1389 /*
1390 * Problem reaching the server. Disconnect and let the
1391 * forechannel reestablish the connection. The server will
1392 * have to retransmit the backchannel request and we'll
1393 * reprocess it. Since these ops are idempotent, there's no
1394 * need to cache our reply at this time.
1395 */
1396 printk(KERN_NOTICE "RPC: Could not send backchannel reply "
1397 "error: %d\n", task->tk_status);
1398 xprt_conditional_disconnect(task->tk_xprt,
1399 req->rq_connect_cookie);
1400 break;
1401 default:
1402 /*
1403 * We were unable to reply and will have to drop the
1404 * request. The server should reconnect and retransmit.
1405 */
1406 BUG_ON(task->tk_status == -EAGAIN);
1407 printk(KERN_NOTICE "RPC: Could not send backchannel reply "
1408 "error: %d\n", task->tk_status);
1409 break;
1410 }
1411 rpc_wake_up_queued_task(&req->rq_xprt->pending, task);
1412}
1413#endif /* CONFIG_NFS_V4_1 */
1414
Linus Torvalds1da177e2005-04-16 15:20:36 -07001415/*
1416 * 6. Sort out the RPC call status
1417 */
1418static void
1419call_status(struct rpc_task *task)
1420{
1421 struct rpc_clnt *clnt = task->tk_client;
1422 struct rpc_rqst *req = task->tk_rqstp;
1423 int status;
1424
Ricardo Labiagadd2b63d2009-04-01 09:23:28 -04001425 if (req->rq_reply_bytes_recvd > 0 && !req->rq_bytes_sent)
1426 task->tk_status = req->rq_reply_bytes_recvd;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001427
Chuck Lever46121cf2007-01-31 12:14:08 -05001428 dprint_status(task);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001429
1430 status = task->tk_status;
1431 if (status >= 0) {
1432 task->tk_action = call_decode;
1433 return;
1434 }
1435
1436 task->tk_status = 0;
1437 switch(status) {
Trond Myklebust76303992006-08-30 14:32:49 -04001438 case -EHOSTDOWN:
1439 case -EHOSTUNREACH:
1440 case -ENETUNREACH:
1441 /*
1442 * Delay any retries for 3 seconds, then handle as if it
1443 * were a timeout.
1444 */
1445 rpc_delay(task, 3*HZ);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001446 case -ETIMEDOUT:
1447 task->tk_action = call_timeout;
Trond Myklebust241c39b2007-04-20 16:12:55 -04001448 if (task->tk_client->cl_discrtry)
Trond Myklebust7c1d71c2008-04-17 16:52:57 -04001449 xprt_conditional_disconnect(task->tk_xprt,
1450 req->rq_connect_cookie);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001451 break;
Trond Myklebustc8485e42009-03-11 14:37:59 -04001452 case -ECONNRESET:
Linus Torvalds1da177e2005-04-16 15:20:36 -07001453 case -ECONNREFUSED:
Chuck Lever35f5a422006-01-03 09:55:50 +01001454 rpc_force_rebind(clnt);
Trond Myklebustc8485e42009-03-11 14:37:59 -04001455 rpc_delay(task, 3*HZ);
1456 case -EPIPE:
1457 case -ENOTCONN:
Linus Torvalds1da177e2005-04-16 15:20:36 -07001458 task->tk_action = call_bind;
1459 break;
1460 case -EAGAIN:
1461 task->tk_action = call_transmit;
1462 break;
1463 case -EIO:
1464 /* shutdown or soft timeout */
1465 rpc_exit(task, status);
1466 break;
1467 default:
Olga Kornievskaiab6b61522008-06-09 16:51:31 -04001468 if (clnt->cl_chatty)
1469 printk("%s: RPC call returned error %d\n",
Linus Torvalds1da177e2005-04-16 15:20:36 -07001470 clnt->cl_protname, -status);
1471 rpc_exit(task, status);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001472 }
1473}
1474
1475/*
Trond Myklebuste0ab53d2006-07-27 17:22:50 -04001476 * 6a. Handle RPC timeout
Linus Torvalds1da177e2005-04-16 15:20:36 -07001477 * We do not release the request slot, so we keep using the
1478 * same XID for all retransmits.
1479 */
1480static void
1481call_timeout(struct rpc_task *task)
1482{
1483 struct rpc_clnt *clnt = task->tk_client;
1484
1485 if (xprt_adjust_timeout(task->tk_rqstp) == 0) {
Chuck Lever46121cf2007-01-31 12:14:08 -05001486 dprintk("RPC: %5u call_timeout (minor)\n", task->tk_pid);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001487 goto retry;
1488 }
1489
Chuck Lever46121cf2007-01-31 12:14:08 -05001490 dprintk("RPC: %5u call_timeout (major)\n", task->tk_pid);
Chuck Leveref759a22006-03-20 13:44:17 -05001491 task->tk_timeouts++;
1492
Chuck Lever3a28bec2009-12-03 15:58:56 -05001493 if (RPC_IS_SOFTCONN(task)) {
1494 rpc_exit(task, -ETIMEDOUT);
1495 return;
1496 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001497 if (RPC_IS_SOFT(task)) {
Olga Kornievskaiab6b61522008-06-09 16:51:31 -04001498 if (clnt->cl_chatty)
1499 printk(KERN_NOTICE "%s: server %s not responding, timed out\n",
Linus Torvalds1da177e2005-04-16 15:20:36 -07001500 clnt->cl_protname, clnt->cl_server);
1501 rpc_exit(task, -EIO);
1502 return;
1503 }
1504
Chuck Leverf518e35a2006-01-03 09:55:52 +01001505 if (!(task->tk_flags & RPC_CALL_MAJORSEEN)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001506 task->tk_flags |= RPC_CALL_MAJORSEEN;
Olga Kornievskaiab6b61522008-06-09 16:51:31 -04001507 if (clnt->cl_chatty)
1508 printk(KERN_NOTICE "%s: server %s not responding, still trying\n",
Linus Torvalds1da177e2005-04-16 15:20:36 -07001509 clnt->cl_protname, clnt->cl_server);
1510 }
Chuck Lever35f5a422006-01-03 09:55:50 +01001511 rpc_force_rebind(clnt);
Trond Myklebustb48633b2008-04-22 16:47:55 -04001512 /*
1513 * Did our request time out due to an RPCSEC_GSS out-of-sequence
1514 * event? RFC2203 requires the server to drop all such requests.
1515 */
1516 rpcauth_invalcred(task);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001517
1518retry:
1519 clnt->cl_stats->rpcretrans++;
1520 task->tk_action = call_bind;
1521 task->tk_status = 0;
1522}
1523
1524/*
1525 * 7. Decode the RPC reply
1526 */
1527static void
1528call_decode(struct rpc_task *task)
1529{
1530 struct rpc_clnt *clnt = task->tk_client;
1531 struct rpc_rqst *req = task->tk_rqstp;
1532 kxdrproc_t decode = task->tk_msg.rpc_proc->p_decode;
Alexey Dobriyand8ed0292006-09-26 22:29:38 -07001533 __be32 *p;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001534
Chuck Lever46121cf2007-01-31 12:14:08 -05001535 dprintk("RPC: %5u call_decode (status %d)\n",
1536 task->tk_pid, task->tk_status);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001537
Chuck Leverf518e35a2006-01-03 09:55:52 +01001538 if (task->tk_flags & RPC_CALL_MAJORSEEN) {
Olga Kornievskaiab6b61522008-06-09 16:51:31 -04001539 if (clnt->cl_chatty)
1540 printk(KERN_NOTICE "%s: server %s OK\n",
1541 clnt->cl_protname, clnt->cl_server);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001542 task->tk_flags &= ~RPC_CALL_MAJORSEEN;
1543 }
1544
Trond Myklebust43ac3f22006-03-20 13:44:51 -05001545 /*
1546 * Ensure that we see all writes made by xprt_complete_rqst()
Ricardo Labiagadd2b63d2009-04-01 09:23:28 -04001547 * before it changed req->rq_reply_bytes_recvd.
Trond Myklebust43ac3f22006-03-20 13:44:51 -05001548 */
1549 smp_rmb();
Linus Torvalds1da177e2005-04-16 15:20:36 -07001550 req->rq_rcv_buf.len = req->rq_private_buf.len;
1551
1552 /* Check that the softirq receive buffer is valid */
1553 WARN_ON(memcmp(&req->rq_rcv_buf, &req->rq_private_buf,
1554 sizeof(req->rq_rcv_buf)) != 0);
1555
Trond Myklebust1e799b62008-03-21 16:19:41 -04001556 if (req->rq_rcv_buf.len < 12) {
1557 if (!RPC_IS_SOFT(task)) {
1558 task->tk_action = call_bind;
1559 clnt->cl_stats->rpcretrans++;
1560 goto out_retry;
1561 }
1562 dprintk("RPC: %s: too small RPC reply size (%d bytes)\n",
1563 clnt->cl_protname, task->tk_status);
1564 task->tk_action = call_timeout;
1565 goto out_retry;
1566 }
1567
Chuck Leverb0e1c572008-05-21 17:09:19 -04001568 p = rpc_verify_header(task);
Trond Myklebustabbcf282006-01-03 09:55:03 +01001569 if (IS_ERR(p)) {
1570 if (p == ERR_PTR(-EAGAIN))
1571 goto out_retry;
1572 return;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001573 }
1574
Trond Myklebustabbcf282006-01-03 09:55:03 +01001575 task->tk_action = rpc_exit_task;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001576
Trond Myklebust6d5fcb52006-10-18 16:01:06 -04001577 if (decode) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001578 task->tk_status = rpcauth_unwrap_resp(task, decode, req, p,
1579 task->tk_msg.rpc_resp);
Trond Myklebust6d5fcb52006-10-18 16:01:06 -04001580 }
Chuck Lever46121cf2007-01-31 12:14:08 -05001581 dprintk("RPC: %5u call_decode result %d\n", task->tk_pid,
1582 task->tk_status);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001583 return;
1584out_retry:
Linus Torvalds1da177e2005-04-16 15:20:36 -07001585 task->tk_status = 0;
Chuck Leverb0e1c572008-05-21 17:09:19 -04001586 /* Note: rpc_verify_header() may have freed the RPC slot */
Trond Myklebust24b74bf2008-04-19 13:15:47 -04001587 if (task->tk_rqstp == req) {
Ricardo Labiagadd2b63d2009-04-01 09:23:28 -04001588 req->rq_reply_bytes_recvd = req->rq_rcv_buf.len = 0;
Trond Myklebust24b74bf2008-04-19 13:15:47 -04001589 if (task->tk_client->cl_discrtry)
Trond Myklebust7c1d71c2008-04-17 16:52:57 -04001590 xprt_conditional_disconnect(task->tk_xprt,
1591 req->rq_connect_cookie);
Trond Myklebust24b74bf2008-04-19 13:15:47 -04001592 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001593}
1594
Alexey Dobriyand8ed0292006-09-26 22:29:38 -07001595static __be32 *
Chuck Leverb0e1c572008-05-21 17:09:19 -04001596rpc_encode_header(struct rpc_task *task)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001597{
1598 struct rpc_clnt *clnt = task->tk_client;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001599 struct rpc_rqst *req = task->tk_rqstp;
Alexey Dobriyand8ed0292006-09-26 22:29:38 -07001600 __be32 *p = req->rq_svec[0].iov_base;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001601
1602 /* FIXME: check buffer size? */
Chuck Lever808012f2005-08-25 16:25:49 -07001603
1604 p = xprt_skip_transport_header(task->tk_xprt, p);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001605 *p++ = req->rq_xid; /* XID */
1606 *p++ = htonl(RPC_CALL); /* CALL */
1607 *p++ = htonl(RPC_VERSION); /* RPC version */
1608 *p++ = htonl(clnt->cl_prog); /* program number */
1609 *p++ = htonl(clnt->cl_vers); /* program version */
1610 *p++ = htonl(task->tk_msg.rpc_proc->p_proc); /* procedure */
Trond Myklebust334ccfd2005-06-22 17:16:19 +00001611 p = rpcauth_marshcred(task, p);
1612 req->rq_slen = xdr_adjust_iovec(&req->rq_svec[0], p);
1613 return p;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001614}
1615
Alexey Dobriyand8ed0292006-09-26 22:29:38 -07001616static __be32 *
Chuck Leverb0e1c572008-05-21 17:09:19 -04001617rpc_verify_header(struct rpc_task *task)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001618{
1619 struct kvec *iov = &task->tk_rqstp->rq_rcv_buf.head[0];
1620 int len = task->tk_rqstp->rq_rcv_buf.len >> 2;
Alexey Dobriyand8ed0292006-09-26 22:29:38 -07001621 __be32 *p = iov->iov_base;
1622 u32 n;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001623 int error = -EACCES;
1624
David Howellse8896492006-08-24 15:44:19 -04001625 if ((task->tk_rqstp->rq_rcv_buf.len & 3) != 0) {
1626 /* RFC-1014 says that the representation of XDR data must be a
1627 * multiple of four bytes
1628 * - if it isn't pointer subtraction in the NFS client may give
1629 * undefined results
1630 */
Trond Myklebust8a702bb2007-06-27 18:30:26 -04001631 dprintk("RPC: %5u %s: XDR representation not a multiple of"
Harvey Harrison0dc47872008-03-05 20:47:47 -08001632 " 4 bytes: 0x%x\n", task->tk_pid, __func__,
Trond Myklebust8a702bb2007-06-27 18:30:26 -04001633 task->tk_rqstp->rq_rcv_buf.len);
David Howellse8896492006-08-24 15:44:19 -04001634 goto out_eio;
1635 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001636 if ((len -= 3) < 0)
1637 goto out_overflow;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001638
Ricardo Labiagaf4a2e412009-04-01 09:22:54 -04001639 p += 1; /* skip XID */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001640 if ((n = ntohl(*p++)) != RPC_REPLY) {
Trond Myklebust8a702bb2007-06-27 18:30:26 -04001641 dprintk("RPC: %5u %s: not an RPC reply: %x\n",
Ricardo Labiagaf4a2e412009-04-01 09:22:54 -04001642 task->tk_pid, __func__, n);
Trond Myklebustabbcf282006-01-03 09:55:03 +01001643 goto out_garbage;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001644 }
Ricardo Labiagaf4a2e412009-04-01 09:22:54 -04001645
Linus Torvalds1da177e2005-04-16 15:20:36 -07001646 if ((n = ntohl(*p++)) != RPC_MSG_ACCEPTED) {
1647 if (--len < 0)
1648 goto out_overflow;
1649 switch ((n = ntohl(*p++))) {
1650 case RPC_AUTH_ERROR:
1651 break;
1652 case RPC_MISMATCH:
Chuck Lever46121cf2007-01-31 12:14:08 -05001653 dprintk("RPC: %5u %s: RPC call version "
1654 "mismatch!\n",
Harvey Harrison0dc47872008-03-05 20:47:47 -08001655 task->tk_pid, __func__);
Andreas Gruenbachercdf47702005-06-22 17:16:23 +00001656 error = -EPROTONOSUPPORT;
1657 goto out_err;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001658 default:
Chuck Lever46121cf2007-01-31 12:14:08 -05001659 dprintk("RPC: %5u %s: RPC call rejected, "
1660 "unknown error: %x\n",
Harvey Harrison0dc47872008-03-05 20:47:47 -08001661 task->tk_pid, __func__, n);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001662 goto out_eio;
1663 }
1664 if (--len < 0)
1665 goto out_overflow;
1666 switch ((n = ntohl(*p++))) {
1667 case RPC_AUTH_REJECTEDCRED:
1668 case RPC_AUTH_REJECTEDVERF:
1669 case RPCSEC_GSS_CREDPROBLEM:
1670 case RPCSEC_GSS_CTXPROBLEM:
1671 if (!task->tk_cred_retry)
1672 break;
1673 task->tk_cred_retry--;
Chuck Lever46121cf2007-01-31 12:14:08 -05001674 dprintk("RPC: %5u %s: retry stale creds\n",
Harvey Harrison0dc47872008-03-05 20:47:47 -08001675 task->tk_pid, __func__);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001676 rpcauth_invalcred(task);
Trond Myklebust220bcc22007-10-01 12:06:48 -04001677 /* Ensure we obtain a new XID! */
1678 xprt_release(task);
Trond Myklebust118df3d2010-10-24 17:17:31 -04001679 task->tk_action = call_reserve;
Trond Myklebustabbcf282006-01-03 09:55:03 +01001680 goto out_retry;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001681 case RPC_AUTH_BADCRED:
1682 case RPC_AUTH_BADVERF:
1683 /* possibly garbled cred/verf? */
1684 if (!task->tk_garb_retry)
1685 break;
1686 task->tk_garb_retry--;
Chuck Lever46121cf2007-01-31 12:14:08 -05001687 dprintk("RPC: %5u %s: retry garbled creds\n",
Harvey Harrison0dc47872008-03-05 20:47:47 -08001688 task->tk_pid, __func__);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001689 task->tk_action = call_bind;
Trond Myklebustabbcf282006-01-03 09:55:03 +01001690 goto out_retry;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001691 case RPC_AUTH_TOOWEAK:
Chuck Leverb0e1c572008-05-21 17:09:19 -04001692 printk(KERN_NOTICE "RPC: server %s requires stronger "
Levent Serinol1356b8c2006-03-20 13:44:11 -05001693 "authentication.\n", task->tk_client->cl_server);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001694 break;
1695 default:
Trond Myklebust8a702bb2007-06-27 18:30:26 -04001696 dprintk("RPC: %5u %s: unknown auth error: %x\n",
Harvey Harrison0dc47872008-03-05 20:47:47 -08001697 task->tk_pid, __func__, n);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001698 error = -EIO;
1699 }
Chuck Lever46121cf2007-01-31 12:14:08 -05001700 dprintk("RPC: %5u %s: call rejected %d\n",
Harvey Harrison0dc47872008-03-05 20:47:47 -08001701 task->tk_pid, __func__, n);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001702 goto out_err;
1703 }
1704 if (!(p = rpcauth_checkverf(task, p))) {
Trond Myklebust8a702bb2007-06-27 18:30:26 -04001705 dprintk("RPC: %5u %s: auth check failed\n",
Harvey Harrison0dc47872008-03-05 20:47:47 -08001706 task->tk_pid, __func__);
Trond Myklebustabbcf282006-01-03 09:55:03 +01001707 goto out_garbage; /* bad verifier, retry */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001708 }
Alexey Dobriyand8ed0292006-09-26 22:29:38 -07001709 len = p - (__be32 *)iov->iov_base - 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001710 if (len < 0)
1711 goto out_overflow;
1712 switch ((n = ntohl(*p++))) {
1713 case RPC_SUCCESS:
1714 return p;
1715 case RPC_PROG_UNAVAIL:
Chuck Lever46121cf2007-01-31 12:14:08 -05001716 dprintk("RPC: %5u %s: program %u is unsupported by server %s\n",
Harvey Harrison0dc47872008-03-05 20:47:47 -08001717 task->tk_pid, __func__,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001718 (unsigned int)task->tk_client->cl_prog,
1719 task->tk_client->cl_server);
Andreas Gruenbachercdf47702005-06-22 17:16:23 +00001720 error = -EPFNOSUPPORT;
1721 goto out_err;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001722 case RPC_PROG_MISMATCH:
Chuck Lever46121cf2007-01-31 12:14:08 -05001723 dprintk("RPC: %5u %s: program %u, version %u unsupported by "
Harvey Harrison0dc47872008-03-05 20:47:47 -08001724 "server %s\n", task->tk_pid, __func__,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001725 (unsigned int)task->tk_client->cl_prog,
1726 (unsigned int)task->tk_client->cl_vers,
1727 task->tk_client->cl_server);
Andreas Gruenbachercdf47702005-06-22 17:16:23 +00001728 error = -EPROTONOSUPPORT;
1729 goto out_err;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001730 case RPC_PROC_UNAVAIL:
Chuck Lever3748f1e2008-05-21 17:09:12 -04001731 dprintk("RPC: %5u %s: proc %s unsupported by program %u, "
Chuck Lever46121cf2007-01-31 12:14:08 -05001732 "version %u on server %s\n",
Harvey Harrison0dc47872008-03-05 20:47:47 -08001733 task->tk_pid, __func__,
Chuck Lever3748f1e2008-05-21 17:09:12 -04001734 rpc_proc_name(task),
Linus Torvalds1da177e2005-04-16 15:20:36 -07001735 task->tk_client->cl_prog,
1736 task->tk_client->cl_vers,
1737 task->tk_client->cl_server);
Andreas Gruenbachercdf47702005-06-22 17:16:23 +00001738 error = -EOPNOTSUPP;
1739 goto out_err;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001740 case RPC_GARBAGE_ARGS:
Chuck Lever46121cf2007-01-31 12:14:08 -05001741 dprintk("RPC: %5u %s: server saw garbage\n",
Harvey Harrison0dc47872008-03-05 20:47:47 -08001742 task->tk_pid, __func__);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001743 break; /* retry */
1744 default:
Trond Myklebust8a702bb2007-06-27 18:30:26 -04001745 dprintk("RPC: %5u %s: server accept status: %x\n",
Harvey Harrison0dc47872008-03-05 20:47:47 -08001746 task->tk_pid, __func__, n);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001747 /* Also retry */
1748 }
1749
Trond Myklebustabbcf282006-01-03 09:55:03 +01001750out_garbage:
Linus Torvalds1da177e2005-04-16 15:20:36 -07001751 task->tk_client->cl_stats->rpcgarbage++;
1752 if (task->tk_garb_retry) {
1753 task->tk_garb_retry--;
Chuck Lever46121cf2007-01-31 12:14:08 -05001754 dprintk("RPC: %5u %s: retrying\n",
Harvey Harrison0dc47872008-03-05 20:47:47 -08001755 task->tk_pid, __func__);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001756 task->tk_action = call_bind;
Trond Myklebustabbcf282006-01-03 09:55:03 +01001757out_retry:
1758 return ERR_PTR(-EAGAIN);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001759 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001760out_eio:
1761 error = -EIO;
1762out_err:
1763 rpc_exit(task, error);
Trond Myklebust8a702bb2007-06-27 18:30:26 -04001764 dprintk("RPC: %5u %s: call failed with error %d\n", task->tk_pid,
Harvey Harrison0dc47872008-03-05 20:47:47 -08001765 __func__, error);
Trond Myklebustabbcf282006-01-03 09:55:03 +01001766 return ERR_PTR(error);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001767out_overflow:
Trond Myklebust8a702bb2007-06-27 18:30:26 -04001768 dprintk("RPC: %5u %s: server reply was truncated.\n", task->tk_pid,
Harvey Harrison0dc47872008-03-05 20:47:47 -08001769 __func__);
Trond Myklebustabbcf282006-01-03 09:55:03 +01001770 goto out_garbage;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001771}
Trond Myklebust5ee0ed72005-06-22 17:16:20 +00001772
Alexey Dobriyand8ed0292006-09-26 22:29:38 -07001773static int rpcproc_encode_null(void *rqstp, __be32 *data, void *obj)
Trond Myklebust5ee0ed72005-06-22 17:16:20 +00001774{
1775 return 0;
1776}
1777
Alexey Dobriyand8ed0292006-09-26 22:29:38 -07001778static int rpcproc_decode_null(void *rqstp, __be32 *data, void *obj)
Trond Myklebust5ee0ed72005-06-22 17:16:20 +00001779{
1780 return 0;
1781}
1782
1783static struct rpc_procinfo rpcproc_null = {
1784 .p_encode = rpcproc_encode_null,
1785 .p_decode = rpcproc_decode_null,
1786};
1787
Chuck Levercaabea82009-12-03 15:58:56 -05001788static int rpc_ping(struct rpc_clnt *clnt)
Trond Myklebust5ee0ed72005-06-22 17:16:20 +00001789{
1790 struct rpc_message msg = {
1791 .rpc_proc = &rpcproc_null,
1792 };
1793 int err;
1794 msg.rpc_cred = authnull_ops.lookup_cred(NULL, NULL, 0);
Chuck Levercaabea82009-12-03 15:58:56 -05001795 err = rpc_call_sync(clnt, &msg, RPC_TASK_SOFT | RPC_TASK_SOFTCONN);
Trond Myklebust5ee0ed72005-06-22 17:16:20 +00001796 put_rpccred(msg.rpc_cred);
1797 return err;
1798}
Trond Myklebust188fef12007-06-16 14:18:40 -04001799
Trond Myklebust5e1550d2007-06-23 10:17:16 -04001800struct rpc_task *rpc_call_null(struct rpc_clnt *clnt, struct rpc_cred *cred, int flags)
1801{
1802 struct rpc_message msg = {
1803 .rpc_proc = &rpcproc_null,
1804 .rpc_cred = cred,
1805 };
Trond Myklebust84115e12007-07-14 15:39:59 -04001806 struct rpc_task_setup task_setup_data = {
1807 .rpc_client = clnt,
1808 .rpc_message = &msg,
1809 .callback_ops = &rpc_default_ops,
1810 .flags = flags,
1811 };
Trond Myklebustc970aa82007-07-14 15:39:59 -04001812 return rpc_run_task(&task_setup_data);
Trond Myklebust5e1550d2007-06-23 10:17:16 -04001813}
Trond Myklebuste8914c62007-07-14 15:39:59 -04001814EXPORT_SYMBOL_GPL(rpc_call_null);
Trond Myklebust5e1550d2007-06-23 10:17:16 -04001815
Trond Myklebust188fef12007-06-16 14:18:40 -04001816#ifdef RPC_DEBUG
Chuck Lever68a23ee2008-05-21 17:09:26 -04001817static void rpc_show_header(void)
1818{
Chuck Levercb3997b2008-05-21 17:09:41 -04001819 printk(KERN_INFO "-pid- flgs status -client- --rqstp- "
1820 "-timeout ---ops--\n");
Chuck Lever68a23ee2008-05-21 17:09:26 -04001821}
1822
Chuck Lever38e886e2008-05-21 17:09:33 -04001823static void rpc_show_task(const struct rpc_clnt *clnt,
1824 const struct rpc_task *task)
1825{
1826 const char *rpc_waitq = "none";
Chuck Levercb3997b2008-05-21 17:09:41 -04001827 char *p, action[KSYM_SYMBOL_LEN];
Chuck Lever38e886e2008-05-21 17:09:33 -04001828
1829 if (RPC_IS_QUEUED(task))
1830 rpc_waitq = rpc_qname(task->tk_waitqueue);
1831
Chuck Levercb3997b2008-05-21 17:09:41 -04001832 /* map tk_action pointer to a function name; then trim off
1833 * the "+0x0 [sunrpc]" */
1834 sprint_symbol(action, (unsigned long)task->tk_action);
1835 p = strchr(action, '+');
1836 if (p)
1837 *p = '\0';
1838
1839 printk(KERN_INFO "%5u %04x %6d %8p %8p %8ld %8p %sv%u %s a:%s q:%s\n",
1840 task->tk_pid, task->tk_flags, task->tk_status,
1841 clnt, task->tk_rqstp, task->tk_timeout, task->tk_ops,
1842 clnt->cl_protname, clnt->cl_vers, rpc_proc_name(task),
1843 action, rpc_waitq);
Chuck Lever38e886e2008-05-21 17:09:33 -04001844}
1845
Trond Myklebust188fef12007-06-16 14:18:40 -04001846void rpc_show_tasks(void)
1847{
1848 struct rpc_clnt *clnt;
Chuck Lever38e886e2008-05-21 17:09:33 -04001849 struct rpc_task *task;
Chuck Lever68a23ee2008-05-21 17:09:26 -04001850 int header = 0;
Trond Myklebust188fef12007-06-16 14:18:40 -04001851
1852 spin_lock(&rpc_client_lock);
Trond Myklebust188fef12007-06-16 14:18:40 -04001853 list_for_each_entry(clnt, &all_clients, cl_clients) {
Trond Myklebust188fef12007-06-16 14:18:40 -04001854 spin_lock(&clnt->cl_lock);
Chuck Lever38e886e2008-05-21 17:09:33 -04001855 list_for_each_entry(task, &clnt->cl_tasks, tk_task) {
Chuck Lever68a23ee2008-05-21 17:09:26 -04001856 if (!header) {
1857 rpc_show_header();
1858 header++;
1859 }
Chuck Lever38e886e2008-05-21 17:09:33 -04001860 rpc_show_task(clnt, task);
Trond Myklebust188fef12007-06-16 14:18:40 -04001861 }
1862 spin_unlock(&clnt->cl_lock);
1863 }
Trond Myklebust188fef12007-06-16 14:18:40 -04001864 spin_unlock(&rpc_client_lock);
1865}
1866#endif