aboutsummaryrefslogtreecommitdiffstats
path: root/net
diff options
context:
space:
mode:
Diffstat (limited to 'net')
-rw-r--r--net/ipv6/netfilter/Kconfig2
-rw-r--r--net/sunrpc/auth.c13
-rw-r--r--net/sunrpc/auth_gss/auth_gss.c13
-rw-r--r--net/sunrpc/clnt.c188
-rw-r--r--net/sunrpc/rpc_pipe.c59
-rw-r--r--net/sunrpc/rpcb_clnt.c119
-rw-r--r--net/sunrpc/sched.c106
-rw-r--r--net/sunrpc/socklib.c2
-rw-r--r--net/sunrpc/stats.c8
-rw-r--r--net/sunrpc/sunrpc_syms.c66
-rw-r--r--net/sunrpc/svc.c1
-rw-r--r--net/sunrpc/sysctl.c7
-rw-r--r--net/sunrpc/xdr.c16
-rw-r--r--net/sunrpc/xprt.c54
-rw-r--r--net/sunrpc/xprtrdma/rpc_rdma.c8
-rw-r--r--net/sunrpc/xprtrdma/transport.c27
-rw-r--r--net/sunrpc/xprtrdma/verbs.c8
-rw-r--r--net/sunrpc/xprtsock.c226
18 files changed, 528 insertions, 395 deletions
diff --git a/net/ipv6/netfilter/Kconfig b/net/ipv6/netfilter/Kconfig
index 4fc0b023cfd7..6cae5475737e 100644
--- a/net/ipv6/netfilter/Kconfig
+++ b/net/ipv6/netfilter/Kconfig
@@ -99,7 +99,7 @@ config IP6_NF_MATCH_HL
99config IP6_NF_MATCH_IPV6HEADER 99config IP6_NF_MATCH_IPV6HEADER
100 tristate '"ipv6header" IPv6 Extension Headers Match' 100 tristate '"ipv6header" IPv6 Extension Headers Match'
101 depends on IP6_NF_IPTABLES 101 depends on IP6_NF_IPTABLES
102 depends on NETFILTER_ADVANCED 102 default m if NETFILTER_ADVANCED=n
103 help 103 help
104 This module allows one to match packets based upon 104 This module allows one to match packets based upon
105 the ipv6 extension headers. 105 the ipv6 extension headers.
diff --git a/net/sunrpc/auth.c b/net/sunrpc/auth.c
index 1ea27559b1de..bcd9abdb031c 100644
--- a/net/sunrpc/auth.c
+++ b/net/sunrpc/auth.c
@@ -51,6 +51,7 @@ rpcauth_register(const struct rpc_authops *ops)
51 spin_unlock(&rpc_authflavor_lock); 51 spin_unlock(&rpc_authflavor_lock);
52 return ret; 52 return ret;
53} 53}
54EXPORT_SYMBOL_GPL(rpcauth_register);
54 55
55int 56int
56rpcauth_unregister(const struct rpc_authops *ops) 57rpcauth_unregister(const struct rpc_authops *ops)
@@ -68,6 +69,7 @@ rpcauth_unregister(const struct rpc_authops *ops)
68 spin_unlock(&rpc_authflavor_lock); 69 spin_unlock(&rpc_authflavor_lock);
69 return ret; 70 return ret;
70} 71}
72EXPORT_SYMBOL_GPL(rpcauth_unregister);
71 73
72struct rpc_auth * 74struct rpc_auth *
73rpcauth_create(rpc_authflavor_t pseudoflavor, struct rpc_clnt *clnt) 75rpcauth_create(rpc_authflavor_t pseudoflavor, struct rpc_clnt *clnt)
@@ -102,6 +104,7 @@ rpcauth_create(rpc_authflavor_t pseudoflavor, struct rpc_clnt *clnt)
102out: 104out:
103 return auth; 105 return auth;
104} 106}
107EXPORT_SYMBOL_GPL(rpcauth_create);
105 108
106void 109void
107rpcauth_release(struct rpc_auth *auth) 110rpcauth_release(struct rpc_auth *auth)
@@ -151,6 +154,7 @@ rpcauth_init_credcache(struct rpc_auth *auth)
151 auth->au_credcache = new; 154 auth->au_credcache = new;
152 return 0; 155 return 0;
153} 156}
157EXPORT_SYMBOL_GPL(rpcauth_init_credcache);
154 158
155/* 159/*
156 * Destroy a list of credentials 160 * Destroy a list of credentials
@@ -213,6 +217,7 @@ rpcauth_destroy_credcache(struct rpc_auth *auth)
213 kfree(cache); 217 kfree(cache);
214 } 218 }
215} 219}
220EXPORT_SYMBOL_GPL(rpcauth_destroy_credcache);
216 221
217/* 222/*
218 * Remove stale credentials. Avoid sleeping inside the loop. 223 * Remove stale credentials. Avoid sleeping inside the loop.
@@ -332,6 +337,7 @@ found:
332out: 337out:
333 return cred; 338 return cred;
334} 339}
340EXPORT_SYMBOL_GPL(rpcauth_lookup_credcache);
335 341
336struct rpc_cred * 342struct rpc_cred *
337rpcauth_lookupcred(struct rpc_auth *auth, int flags) 343rpcauth_lookupcred(struct rpc_auth *auth, int flags)
@@ -350,6 +356,7 @@ rpcauth_lookupcred(struct rpc_auth *auth, int flags)
350 put_group_info(acred.group_info); 356 put_group_info(acred.group_info);
351 return ret; 357 return ret;
352} 358}
359EXPORT_SYMBOL_GPL(rpcauth_lookupcred);
353 360
354void 361void
355rpcauth_init_cred(struct rpc_cred *cred, const struct auth_cred *acred, 362rpcauth_init_cred(struct rpc_cred *cred, const struct auth_cred *acred,
@@ -366,7 +373,7 @@ rpcauth_init_cred(struct rpc_cred *cred, const struct auth_cred *acred,
366#endif 373#endif
367 cred->cr_uid = acred->uid; 374 cred->cr_uid = acred->uid;
368} 375}
369EXPORT_SYMBOL(rpcauth_init_cred); 376EXPORT_SYMBOL_GPL(rpcauth_init_cred);
370 377
371struct rpc_cred * 378struct rpc_cred *
372rpcauth_bindcred(struct rpc_task *task) 379rpcauth_bindcred(struct rpc_task *task)
@@ -378,6 +385,7 @@ rpcauth_bindcred(struct rpc_task *task)
378 .group_info = current->group_info, 385 .group_info = current->group_info,
379 }; 386 };
380 struct rpc_cred *ret; 387 struct rpc_cred *ret;
388 sigset_t oldset;
381 int flags = 0; 389 int flags = 0;
382 390
383 dprintk("RPC: %5u looking up %s cred\n", 391 dprintk("RPC: %5u looking up %s cred\n",
@@ -385,7 +393,9 @@ rpcauth_bindcred(struct rpc_task *task)
385 get_group_info(acred.group_info); 393 get_group_info(acred.group_info);
386 if (task->tk_flags & RPC_TASK_ROOTCREDS) 394 if (task->tk_flags & RPC_TASK_ROOTCREDS)
387 flags |= RPCAUTH_LOOKUP_ROOTCREDS; 395 flags |= RPCAUTH_LOOKUP_ROOTCREDS;
396 rpc_clnt_sigmask(task->tk_client, &oldset);
388 ret = auth->au_ops->lookup_cred(auth, &acred, flags); 397 ret = auth->au_ops->lookup_cred(auth, &acred, flags);
398 rpc_clnt_sigunmask(task->tk_client, &oldset);
389 if (!IS_ERR(ret)) 399 if (!IS_ERR(ret))
390 task->tk_msg.rpc_cred = ret; 400 task->tk_msg.rpc_cred = ret;
391 else 401 else
@@ -435,6 +445,7 @@ need_lock:
435out_destroy: 445out_destroy:
436 cred->cr_ops->crdestroy(cred); 446 cred->cr_ops->crdestroy(cred);
437} 447}
448EXPORT_SYMBOL_GPL(put_rpccred);
438 449
439void 450void
440rpcauth_unbindcred(struct rpc_task *task) 451rpcauth_unbindcred(struct rpc_task *task)
diff --git a/net/sunrpc/auth_gss/auth_gss.c b/net/sunrpc/auth_gss/auth_gss.c
index 1f2d85e869c0..6dac38792288 100644
--- a/net/sunrpc/auth_gss/auth_gss.c
+++ b/net/sunrpc/auth_gss/auth_gss.c
@@ -472,16 +472,15 @@ gss_pipe_upcall(struct file *filp, struct rpc_pipe_msg *msg,
472 char __user *dst, size_t buflen) 472 char __user *dst, size_t buflen)
473{ 473{
474 char *data = (char *)msg->data + msg->copied; 474 char *data = (char *)msg->data + msg->copied;
475 ssize_t mlen = msg->len; 475 size_t mlen = min(msg->len, buflen);
476 ssize_t left; 476 unsigned long left;
477 477
478 if (mlen > buflen)
479 mlen = buflen;
480 left = copy_to_user(dst, data, mlen); 478 left = copy_to_user(dst, data, mlen);
481 if (left < 0) { 479 if (left == mlen) {
482 msg->errno = left; 480 msg->errno = -EFAULT;
483 return left; 481 return -EFAULT;
484 } 482 }
483
485 mlen -= left; 484 mlen -= left;
486 msg->copied += mlen; 485 msg->copied += mlen;
487 msg->errno = 0; 486 msg->errno = 0;
diff --git a/net/sunrpc/clnt.c b/net/sunrpc/clnt.c
index 76be83ee4b04..924916ceaa43 100644
--- a/net/sunrpc/clnt.c
+++ b/net/sunrpc/clnt.c
@@ -30,6 +30,7 @@
30#include <linux/smp_lock.h> 30#include <linux/smp_lock.h>
31#include <linux/utsname.h> 31#include <linux/utsname.h>
32#include <linux/workqueue.h> 32#include <linux/workqueue.h>
33#include <linux/in6.h>
33 34
34#include <linux/sunrpc/clnt.h> 35#include <linux/sunrpc/clnt.h>
35#include <linux/sunrpc/rpc_pipe_fs.h> 36#include <linux/sunrpc/rpc_pipe_fs.h>
@@ -121,8 +122,9 @@ rpc_setup_pipedir(struct rpc_clnt *clnt, char *dir_name)
121 } 122 }
122} 123}
123 124
124static struct rpc_clnt * rpc_new_client(struct rpc_xprt *xprt, char *servname, struct rpc_program *program, u32 vers, rpc_authflavor_t flavor) 125static struct rpc_clnt * rpc_new_client(const struct rpc_create_args *args, struct rpc_xprt *xprt)
125{ 126{
127 struct rpc_program *program = args->program;
126 struct rpc_version *version; 128 struct rpc_version *version;
127 struct rpc_clnt *clnt = NULL; 129 struct rpc_clnt *clnt = NULL;
128 struct rpc_auth *auth; 130 struct rpc_auth *auth;
@@ -131,13 +133,13 @@ static struct rpc_clnt * rpc_new_client(struct rpc_xprt *xprt, char *servname, s
131 133
132 /* sanity check the name before trying to print it */ 134 /* sanity check the name before trying to print it */
133 err = -EINVAL; 135 err = -EINVAL;
134 len = strlen(servname); 136 len = strlen(args->servername);
135 if (len > RPC_MAXNETNAMELEN) 137 if (len > RPC_MAXNETNAMELEN)
136 goto out_no_rpciod; 138 goto out_no_rpciod;
137 len++; 139 len++;
138 140
139 dprintk("RPC: creating %s client for %s (xprt %p)\n", 141 dprintk("RPC: creating %s client for %s (xprt %p)\n",
140 program->name, servname, xprt); 142 program->name, args->servername, xprt);
141 143
142 err = rpciod_up(); 144 err = rpciod_up();
143 if (err) 145 if (err)
@@ -145,7 +147,11 @@ static struct rpc_clnt * rpc_new_client(struct rpc_xprt *xprt, char *servname, s
145 err = -EINVAL; 147 err = -EINVAL;
146 if (!xprt) 148 if (!xprt)
147 goto out_no_xprt; 149 goto out_no_xprt;
148 if (vers >= program->nrvers || !(version = program->version[vers])) 150
151 if (args->version >= program->nrvers)
152 goto out_err;
153 version = program->version[args->version];
154 if (version == NULL)
149 goto out_err; 155 goto out_err;
150 156
151 err = -ENOMEM; 157 err = -ENOMEM;
@@ -157,12 +163,12 @@ static struct rpc_clnt * rpc_new_client(struct rpc_xprt *xprt, char *servname, s
157 clnt->cl_server = clnt->cl_inline_name; 163 clnt->cl_server = clnt->cl_inline_name;
158 if (len > sizeof(clnt->cl_inline_name)) { 164 if (len > sizeof(clnt->cl_inline_name)) {
159 char *buf = kmalloc(len, GFP_KERNEL); 165 char *buf = kmalloc(len, GFP_KERNEL);
160 if (buf != 0) 166 if (buf != NULL)
161 clnt->cl_server = buf; 167 clnt->cl_server = buf;
162 else 168 else
163 len = sizeof(clnt->cl_inline_name); 169 len = sizeof(clnt->cl_inline_name);
164 } 170 }
165 strlcpy(clnt->cl_server, servname, len); 171 strlcpy(clnt->cl_server, args->servername, len);
166 172
167 clnt->cl_xprt = xprt; 173 clnt->cl_xprt = xprt;
168 clnt->cl_procinfo = version->procs; 174 clnt->cl_procinfo = version->procs;
@@ -182,8 +188,15 @@ static struct rpc_clnt * rpc_new_client(struct rpc_xprt *xprt, char *servname, s
182 if (!xprt_bound(clnt->cl_xprt)) 188 if (!xprt_bound(clnt->cl_xprt))
183 clnt->cl_autobind = 1; 189 clnt->cl_autobind = 1;
184 190
191 clnt->cl_timeout = xprt->timeout;
192 if (args->timeout != NULL) {
193 memcpy(&clnt->cl_timeout_default, args->timeout,
194 sizeof(clnt->cl_timeout_default));
195 clnt->cl_timeout = &clnt->cl_timeout_default;
196 }
197
185 clnt->cl_rtt = &clnt->cl_rtt_default; 198 clnt->cl_rtt = &clnt->cl_rtt_default;
186 rpc_init_rtt(&clnt->cl_rtt_default, xprt->timeout.to_initval); 199 rpc_init_rtt(&clnt->cl_rtt_default, clnt->cl_timeout->to_initval);
187 200
188 kref_init(&clnt->cl_kref); 201 kref_init(&clnt->cl_kref);
189 202
@@ -191,10 +204,10 @@ static struct rpc_clnt * rpc_new_client(struct rpc_xprt *xprt, char *servname, s
191 if (err < 0) 204 if (err < 0)
192 goto out_no_path; 205 goto out_no_path;
193 206
194 auth = rpcauth_create(flavor, clnt); 207 auth = rpcauth_create(args->authflavor, clnt);
195 if (IS_ERR(auth)) { 208 if (IS_ERR(auth)) {
196 printk(KERN_INFO "RPC: Couldn't create auth handle (flavor %u)\n", 209 printk(KERN_INFO "RPC: Couldn't create auth handle (flavor %u)\n",
197 flavor); 210 args->authflavor);
198 err = PTR_ERR(auth); 211 err = PTR_ERR(auth);
199 goto out_no_auth; 212 goto out_no_auth;
200 } 213 }
@@ -245,9 +258,8 @@ struct rpc_clnt *rpc_create(struct rpc_create_args *args)
245 .srcaddr = args->saddress, 258 .srcaddr = args->saddress,
246 .dstaddr = args->address, 259 .dstaddr = args->address,
247 .addrlen = args->addrsize, 260 .addrlen = args->addrsize,
248 .timeout = args->timeout
249 }; 261 };
250 char servername[20]; 262 char servername[48];
251 263
252 xprt = xprt_create_transport(&xprtargs); 264 xprt = xprt_create_transport(&xprtargs);
253 if (IS_ERR(xprt)) 265 if (IS_ERR(xprt))
@@ -258,13 +270,34 @@ struct rpc_clnt *rpc_create(struct rpc_create_args *args)
258 * up a string representation of the passed-in address. 270 * up a string representation of the passed-in address.
259 */ 271 */
260 if (args->servername == NULL) { 272 if (args->servername == NULL) {
261 struct sockaddr_in *addr = 273 servername[0] = '\0';
262 (struct sockaddr_in *) args->address; 274 switch (args->address->sa_family) {
263 snprintf(servername, sizeof(servername), NIPQUAD_FMT, 275 case AF_INET: {
264 NIPQUAD(addr->sin_addr.s_addr)); 276 struct sockaddr_in *sin =
277 (struct sockaddr_in *)args->address;
278 snprintf(servername, sizeof(servername), NIPQUAD_FMT,
279 NIPQUAD(sin->sin_addr.s_addr));
280 break;
281 }
282 case AF_INET6: {
283 struct sockaddr_in6 *sin =
284 (struct sockaddr_in6 *)args->address;
285 snprintf(servername, sizeof(servername), NIP6_FMT,
286 NIP6(sin->sin6_addr));
287 break;
288 }
289 default:
290 /* caller wants default server name, but
291 * address family isn't recognized. */
292 return ERR_PTR(-EINVAL);
293 }
265 args->servername = servername; 294 args->servername = servername;
266 } 295 }
267 296
297 xprt = xprt_create_transport(&xprtargs);
298 if (IS_ERR(xprt))
299 return (struct rpc_clnt *)xprt;
300
268 /* 301 /*
269 * By default, kernel RPC client connects from a reserved port. 302 * By default, kernel RPC client connects from a reserved port.
270 * CAP_NET_BIND_SERVICE will not be set for unprivileged requesters, 303 * CAP_NET_BIND_SERVICE will not be set for unprivileged requesters,
@@ -275,8 +308,7 @@ struct rpc_clnt *rpc_create(struct rpc_create_args *args)
275 if (args->flags & RPC_CLNT_CREATE_NONPRIVPORT) 308 if (args->flags & RPC_CLNT_CREATE_NONPRIVPORT)
276 xprt->resvport = 0; 309 xprt->resvport = 0;
277 310
278 clnt = rpc_new_client(xprt, args->servername, args->program, 311 clnt = rpc_new_client(args, xprt);
279 args->version, args->authflavor);
280 if (IS_ERR(clnt)) 312 if (IS_ERR(clnt))
281 return clnt; 313 return clnt;
282 314
@@ -322,7 +354,7 @@ rpc_clone_client(struct rpc_clnt *clnt)
322 new->cl_autobind = 0; 354 new->cl_autobind = 0;
323 INIT_LIST_HEAD(&new->cl_tasks); 355 INIT_LIST_HEAD(&new->cl_tasks);
324 spin_lock_init(&new->cl_lock); 356 spin_lock_init(&new->cl_lock);
325 rpc_init_rtt(&new->cl_rtt_default, clnt->cl_xprt->timeout.to_initval); 357 rpc_init_rtt(&new->cl_rtt_default, clnt->cl_timeout->to_initval);
326 new->cl_metrics = rpc_alloc_iostats(clnt); 358 new->cl_metrics = rpc_alloc_iostats(clnt);
327 if (new->cl_metrics == NULL) 359 if (new->cl_metrics == NULL)
328 goto out_no_stats; 360 goto out_no_stats;
@@ -345,6 +377,7 @@ out_no_clnt:
345 dprintk("RPC: %s: returned error %d\n", __FUNCTION__, err); 377 dprintk("RPC: %s: returned error %d\n", __FUNCTION__, err);
346 return ERR_PTR(err); 378 return ERR_PTR(err);
347} 379}
380EXPORT_SYMBOL_GPL(rpc_clone_client);
348 381
349/* 382/*
350 * Properly shut down an RPC client, terminating all outstanding 383 * Properly shut down an RPC client, terminating all outstanding
@@ -363,6 +396,7 @@ void rpc_shutdown_client(struct rpc_clnt *clnt)
363 396
364 rpc_release_client(clnt); 397 rpc_release_client(clnt);
365} 398}
399EXPORT_SYMBOL_GPL(rpc_shutdown_client);
366 400
367/* 401/*
368 * Free an RPC client 402 * Free an RPC client
@@ -467,6 +501,7 @@ struct rpc_clnt *rpc_bind_new_program(struct rpc_clnt *old,
467out: 501out:
468 return clnt; 502 return clnt;
469} 503}
504EXPORT_SYMBOL_GPL(rpc_bind_new_program);
470 505
471/* 506/*
472 * Default callback for async RPC calls 507 * Default callback for async RPC calls
@@ -498,12 +533,12 @@ static void rpc_save_sigmask(sigset_t *oldset, int intr)
498 sigprocmask(SIG_BLOCK, &sigmask, oldset); 533 sigprocmask(SIG_BLOCK, &sigmask, oldset);
499} 534}
500 535
501static inline void rpc_task_sigmask(struct rpc_task *task, sigset_t *oldset) 536static void rpc_task_sigmask(struct rpc_task *task, sigset_t *oldset)
502{ 537{
503 rpc_save_sigmask(oldset, !RPC_TASK_UNINTERRUPTIBLE(task)); 538 rpc_save_sigmask(oldset, !RPC_TASK_UNINTERRUPTIBLE(task));
504} 539}
505 540
506static inline void rpc_restore_sigmask(sigset_t *oldset) 541static void rpc_restore_sigmask(sigset_t *oldset)
507{ 542{
508 sigprocmask(SIG_SETMASK, oldset, NULL); 543 sigprocmask(SIG_SETMASK, oldset, NULL);
509} 544}
@@ -512,45 +547,49 @@ void rpc_clnt_sigmask(struct rpc_clnt *clnt, sigset_t *oldset)
512{ 547{
513 rpc_save_sigmask(oldset, clnt->cl_intr); 548 rpc_save_sigmask(oldset, clnt->cl_intr);
514} 549}
550EXPORT_SYMBOL_GPL(rpc_clnt_sigmask);
515 551
516void rpc_clnt_sigunmask(struct rpc_clnt *clnt, sigset_t *oldset) 552void rpc_clnt_sigunmask(struct rpc_clnt *clnt, sigset_t *oldset)
517{ 553{
518 rpc_restore_sigmask(oldset); 554 rpc_restore_sigmask(oldset);
519} 555}
556EXPORT_SYMBOL_GPL(rpc_clnt_sigunmask);
520 557
521static 558/**
522struct rpc_task *rpc_do_run_task(struct rpc_clnt *clnt, 559 * rpc_run_task - Allocate a new RPC task, then run rpc_execute against it
523 struct rpc_message *msg, 560 * @task_setup_data: pointer to task initialisation data
524 int flags, 561 */
525 const struct rpc_call_ops *ops, 562struct rpc_task *rpc_run_task(const struct rpc_task_setup *task_setup_data)
526 void *data)
527{ 563{
528 struct rpc_task *task, *ret; 564 struct rpc_task *task, *ret;
529 sigset_t oldset; 565 sigset_t oldset;
530 566
531 task = rpc_new_task(clnt, flags, ops, data); 567 task = rpc_new_task(task_setup_data);
532 if (task == NULL) { 568 if (task == NULL) {
533 rpc_release_calldata(ops, data); 569 rpc_release_calldata(task_setup_data->callback_ops,
534 return ERR_PTR(-ENOMEM); 570 task_setup_data->callback_data);
571 ret = ERR_PTR(-ENOMEM);
572 goto out;
535 } 573 }
536 574
537 /* Mask signals on synchronous RPC calls and RPCSEC_GSS upcalls */ 575 if (task->tk_status != 0) {
538 rpc_task_sigmask(task, &oldset); 576 ret = ERR_PTR(task->tk_status);
539 if (msg != NULL) { 577 rpc_put_task(task);
540 rpc_call_setup(task, msg, 0); 578 goto out;
541 if (task->tk_status != 0) {
542 ret = ERR_PTR(task->tk_status);
543 rpc_put_task(task);
544 goto out;
545 }
546 } 579 }
547 atomic_inc(&task->tk_count); 580 atomic_inc(&task->tk_count);
548 rpc_execute(task); 581 /* Mask signals on synchronous RPC calls and RPCSEC_GSS upcalls */
582 if (!RPC_IS_ASYNC(task)) {
583 rpc_task_sigmask(task, &oldset);
584 rpc_execute(task);
585 rpc_restore_sigmask(&oldset);
586 } else
587 rpc_execute(task);
549 ret = task; 588 ret = task;
550out: 589out:
551 rpc_restore_sigmask(&oldset);
552 return ret; 590 return ret;
553} 591}
592EXPORT_SYMBOL_GPL(rpc_run_task);
554 593
555/** 594/**
556 * rpc_call_sync - Perform a synchronous RPC call 595 * rpc_call_sync - Perform a synchronous RPC call
@@ -561,17 +600,24 @@ out:
561int rpc_call_sync(struct rpc_clnt *clnt, struct rpc_message *msg, int flags) 600int rpc_call_sync(struct rpc_clnt *clnt, struct rpc_message *msg, int flags)
562{ 601{
563 struct rpc_task *task; 602 struct rpc_task *task;
603 struct rpc_task_setup task_setup_data = {
604 .rpc_client = clnt,
605 .rpc_message = msg,
606 .callback_ops = &rpc_default_ops,
607 .flags = flags,
608 };
564 int status; 609 int status;
565 610
566 BUG_ON(flags & RPC_TASK_ASYNC); 611 BUG_ON(flags & RPC_TASK_ASYNC);
567 612
568 task = rpc_do_run_task(clnt, msg, flags, &rpc_default_ops, NULL); 613 task = rpc_run_task(&task_setup_data);
569 if (IS_ERR(task)) 614 if (IS_ERR(task))
570 return PTR_ERR(task); 615 return PTR_ERR(task);
571 status = task->tk_status; 616 status = task->tk_status;
572 rpc_put_task(task); 617 rpc_put_task(task);
573 return status; 618 return status;
574} 619}
620EXPORT_SYMBOL_GPL(rpc_call_sync);
575 621
576/** 622/**
577 * rpc_call_async - Perform an asynchronous RPC call 623 * rpc_call_async - Perform an asynchronous RPC call
@@ -586,45 +632,28 @@ rpc_call_async(struct rpc_clnt *clnt, struct rpc_message *msg, int flags,
586 const struct rpc_call_ops *tk_ops, void *data) 632 const struct rpc_call_ops *tk_ops, void *data)
587{ 633{
588 struct rpc_task *task; 634 struct rpc_task *task;
635 struct rpc_task_setup task_setup_data = {
636 .rpc_client = clnt,
637 .rpc_message = msg,
638 .callback_ops = tk_ops,
639 .callback_data = data,
640 .flags = flags|RPC_TASK_ASYNC,
641 };
589 642
590 task = rpc_do_run_task(clnt, msg, flags|RPC_TASK_ASYNC, tk_ops, data); 643 task = rpc_run_task(&task_setup_data);
591 if (IS_ERR(task)) 644 if (IS_ERR(task))
592 return PTR_ERR(task); 645 return PTR_ERR(task);
593 rpc_put_task(task); 646 rpc_put_task(task);
594 return 0; 647 return 0;
595} 648}
596 649EXPORT_SYMBOL_GPL(rpc_call_async);
597/**
598 * rpc_run_task - Allocate a new RPC task, then run rpc_execute against it
599 * @clnt: pointer to RPC client
600 * @flags: RPC flags
601 * @ops: RPC call ops
602 * @data: user call data
603 */
604struct rpc_task *rpc_run_task(struct rpc_clnt *clnt, int flags,
605 const struct rpc_call_ops *tk_ops,
606 void *data)
607{
608 return rpc_do_run_task(clnt, NULL, flags, tk_ops, data);
609}
610EXPORT_SYMBOL(rpc_run_task);
611 650
612void 651void
613rpc_call_setup(struct rpc_task *task, struct rpc_message *msg, int flags) 652rpc_call_start(struct rpc_task *task)
614{ 653{
615 task->tk_msg = *msg; 654 task->tk_action = call_start;
616 task->tk_flags |= flags;
617 /* Bind the user cred */
618 if (task->tk_msg.rpc_cred != NULL)
619 rpcauth_holdcred(task);
620 else
621 rpcauth_bindcred(task);
622
623 if (task->tk_status == 0)
624 task->tk_action = call_start;
625 else
626 task->tk_action = rpc_exit_task;
627} 655}
656EXPORT_SYMBOL_GPL(rpc_call_start);
628 657
629/** 658/**
630 * rpc_peeraddr - extract remote peer address from clnt's xprt 659 * rpc_peeraddr - extract remote peer address from clnt's xprt
@@ -653,7 +682,8 @@ EXPORT_SYMBOL_GPL(rpc_peeraddr);
653 * @format: address format 682 * @format: address format
654 * 683 *
655 */ 684 */
656char *rpc_peeraddr2str(struct rpc_clnt *clnt, enum rpc_display_format_t format) 685const char *rpc_peeraddr2str(struct rpc_clnt *clnt,
686 enum rpc_display_format_t format)
657{ 687{
658 struct rpc_xprt *xprt = clnt->cl_xprt; 688 struct rpc_xprt *xprt = clnt->cl_xprt;
659 689
@@ -671,6 +701,7 @@ rpc_setbufsize(struct rpc_clnt *clnt, unsigned int sndsize, unsigned int rcvsize
671 if (xprt->ops->set_buffer_size) 701 if (xprt->ops->set_buffer_size)
672 xprt->ops->set_buffer_size(xprt, sndsize, rcvsize); 702 xprt->ops->set_buffer_size(xprt, sndsize, rcvsize);
673} 703}
704EXPORT_SYMBOL_GPL(rpc_setbufsize);
674 705
675/* 706/*
676 * Return size of largest payload RPC client can support, in bytes 707 * Return size of largest payload RPC client can support, in bytes
@@ -710,6 +741,7 @@ rpc_restart_call(struct rpc_task *task)
710 741
711 task->tk_action = call_start; 742 task->tk_action = call_start;
712} 743}
744EXPORT_SYMBOL_GPL(rpc_restart_call);
713 745
714/* 746/*
715 * 0. Initial state 747 * 0. Initial state
@@ -1137,7 +1169,7 @@ call_status(struct rpc_task *task)
1137 case -ETIMEDOUT: 1169 case -ETIMEDOUT:
1138 task->tk_action = call_timeout; 1170 task->tk_action = call_timeout;
1139 if (task->tk_client->cl_discrtry) 1171 if (task->tk_client->cl_discrtry)
1140 xprt_disconnect(task->tk_xprt); 1172 xprt_force_disconnect(task->tk_xprt);
1141 break; 1173 break;
1142 case -ECONNREFUSED: 1174 case -ECONNREFUSED:
1143 case -ENOTCONN: 1175 case -ENOTCONN:
@@ -1260,7 +1292,7 @@ out_retry:
1260 req->rq_received = req->rq_private_buf.len = 0; 1292 req->rq_received = req->rq_private_buf.len = 0;
1261 task->tk_status = 0; 1293 task->tk_status = 0;
1262 if (task->tk_client->cl_discrtry) 1294 if (task->tk_client->cl_discrtry)
1263 xprt_disconnect(task->tk_xprt); 1295 xprt_force_disconnect(task->tk_xprt);
1264} 1296}
1265 1297
1266/* 1298/*
@@ -1517,9 +1549,15 @@ struct rpc_task *rpc_call_null(struct rpc_clnt *clnt, struct rpc_cred *cred, int
1517 .rpc_proc = &rpcproc_null, 1549 .rpc_proc = &rpcproc_null,
1518 .rpc_cred = cred, 1550 .rpc_cred = cred,
1519 }; 1551 };
1520 return rpc_do_run_task(clnt, &msg, flags, &rpc_default_ops, NULL); 1552 struct rpc_task_setup task_setup_data = {
1553 .rpc_client = clnt,
1554 .rpc_message = &msg,
1555 .callback_ops = &rpc_default_ops,
1556 .flags = flags,
1557 };
1558 return rpc_run_task(&task_setup_data);
1521} 1559}
1522EXPORT_SYMBOL(rpc_call_null); 1560EXPORT_SYMBOL_GPL(rpc_call_null);
1523 1561
1524#ifdef RPC_DEBUG 1562#ifdef RPC_DEBUG
1525void rpc_show_tasks(void) 1563void rpc_show_tasks(void)
diff --git a/net/sunrpc/rpc_pipe.c b/net/sunrpc/rpc_pipe.c
index c59f3ca2b41b..7e197168a245 100644
--- a/net/sunrpc/rpc_pipe.c
+++ b/net/sunrpc/rpc_pipe.c
@@ -76,6 +76,16 @@ rpc_timeout_upcall_queue(struct work_struct *work)
76 rpc_purge_list(rpci, &free_list, destroy_msg, -ETIMEDOUT); 76 rpc_purge_list(rpci, &free_list, destroy_msg, -ETIMEDOUT);
77} 77}
78 78
79/**
80 * rpc_queue_upcall
81 * @inode: inode of upcall pipe on which to queue given message
82 * @msg: message to queue
83 *
84 * Call with an @inode created by rpc_mkpipe() to queue an upcall.
85 * A userspace process may then later read the upcall by performing a
86 * read on an open file for this inode. It is up to the caller to
87 * initialize the fields of @msg (other than @msg->list) appropriately.
88 */
79int 89int
80rpc_queue_upcall(struct inode *inode, struct rpc_pipe_msg *msg) 90rpc_queue_upcall(struct inode *inode, struct rpc_pipe_msg *msg)
81{ 91{
@@ -103,6 +113,7 @@ out:
103 wake_up(&rpci->waitq); 113 wake_up(&rpci->waitq);
104 return res; 114 return res;
105} 115}
116EXPORT_SYMBOL(rpc_queue_upcall);
106 117
107static inline void 118static inline void
108rpc_inode_setowner(struct inode *inode, void *private) 119rpc_inode_setowner(struct inode *inode, void *private)
@@ -512,8 +523,8 @@ rpc_get_inode(struct super_block *sb, int mode)
512/* 523/*
513 * FIXME: This probably has races. 524 * FIXME: This probably has races.
514 */ 525 */
515static void 526static void rpc_depopulate(struct dentry *parent,
516rpc_depopulate(struct dentry *parent, int start, int eof) 527 unsigned long start, unsigned long eof)
517{ 528{
518 struct inode *dir = parent->d_inode; 529 struct inode *dir = parent->d_inode;
519 struct list_head *pos, *next; 530 struct list_head *pos, *next;
@@ -663,7 +674,16 @@ rpc_lookup_negative(char *path, struct nameidata *nd)
663 return dentry; 674 return dentry;
664} 675}
665 676
666 677/**
678 * rpc_mkdir - Create a new directory in rpc_pipefs
679 * @path: path from the rpc_pipefs root to the new directory
680 * @rpc_clnt: rpc client to associate with this directory
681 *
682 * This creates a directory at the given @path associated with
683 * @rpc_clnt, which will contain a file named "info" with some basic
684 * information about the client, together with any "pipes" that may
685 * later be created using rpc_mkpipe().
686 */
667struct dentry * 687struct dentry *
668rpc_mkdir(char *path, struct rpc_clnt *rpc_client) 688rpc_mkdir(char *path, struct rpc_clnt *rpc_client)
669{ 689{
@@ -699,6 +719,10 @@ err_dput:
699 goto out; 719 goto out;
700} 720}
701 721
722/**
723 * rpc_rmdir - Remove a directory created with rpc_mkdir()
724 * @dentry: directory to remove
725 */
702int 726int
703rpc_rmdir(struct dentry *dentry) 727rpc_rmdir(struct dentry *dentry)
704{ 728{
@@ -717,6 +741,25 @@ rpc_rmdir(struct dentry *dentry)
717 return error; 741 return error;
718} 742}
719 743
744/**
745 * rpc_mkpipe - make an rpc_pipefs file for kernel<->userspace communication
746 * @parent: dentry of directory to create new "pipe" in
747 * @name: name of pipe
748 * @private: private data to associate with the pipe, for the caller's use
749 * @ops: operations defining the behavior of the pipe: upcall, downcall,
750 * release_pipe, and destroy_msg.
751 *
752 * Data is made available for userspace to read by calls to
753 * rpc_queue_upcall(). The actual reads will result in calls to
754 * @ops->upcall, which will be called with the file pointer,
755 * message, and userspace buffer to copy to.
756 *
757 * Writes can come at any time, and do not necessarily have to be
758 * responses to upcalls. They will result in calls to @msg->downcall.
759 *
760 * The @private argument passed here will be available to all these methods
761 * from the file pointer, via RPC_I(file->f_dentry->d_inode)->private.
762 */
720struct dentry * 763struct dentry *
721rpc_mkpipe(struct dentry *parent, const char *name, void *private, struct rpc_pipe_ops *ops, int flags) 764rpc_mkpipe(struct dentry *parent, const char *name, void *private, struct rpc_pipe_ops *ops, int flags)
722{ 765{
@@ -763,7 +806,16 @@ err_dput:
763 -ENOMEM); 806 -ENOMEM);
764 goto out; 807 goto out;
765} 808}
809EXPORT_SYMBOL(rpc_mkpipe);
766 810
811/**
812 * rpc_unlink - remove a pipe
813 * @dentry: dentry for the pipe, as returned from rpc_mkpipe
814 *
815 * After this call, lookups will no longer find the pipe, and any
816 * attempts to read or write using preexisting opens of the pipe will
817 * return -EPIPE.
818 */
767int 819int
768rpc_unlink(struct dentry *dentry) 820rpc_unlink(struct dentry *dentry)
769{ 821{
@@ -785,6 +837,7 @@ rpc_unlink(struct dentry *dentry)
785 dput(parent); 837 dput(parent);
786 return error; 838 return error;
787} 839}
840EXPORT_SYMBOL(rpc_unlink);
788 841
789/* 842/*
790 * populate the filesystem 843 * populate the filesystem
diff --git a/net/sunrpc/rpcb_clnt.c b/net/sunrpc/rpcb_clnt.c
index a05493aedb68..fa5b8f202d5b 100644
--- a/net/sunrpc/rpcb_clnt.c
+++ b/net/sunrpc/rpcb_clnt.c
@@ -55,45 +55,6 @@ enum {
55#define RPCB_HIGHPROC_4 RPCBPROC_GETSTAT 55#define RPCB_HIGHPROC_4 RPCBPROC_GETSTAT
56 56
57/* 57/*
58 * r_addr
59 *
60 * Quoting RFC 3530, section 2.2:
61 *
62 * For TCP over IPv4 and for UDP over IPv4, the format of r_addr is the
63 * US-ASCII string:
64 *
65 * h1.h2.h3.h4.p1.p2
66 *
67 * The prefix, "h1.h2.h3.h4", is the standard textual form for
68 * representing an IPv4 address, which is always four octets long.
69 * Assuming big-endian ordering, h1, h2, h3, and h4, are respectively,
70 * the first through fourth octets each converted to ASCII-decimal.
71 * Assuming big-endian ordering, p1 and p2 are, respectively, the first
72 * and second octets each converted to ASCII-decimal. For example, if a
73 * host, in big-endian order, has an address of 0x0A010307 and there is
74 * a service listening on, in big endian order, port 0x020F (decimal
75 * 527), then the complete universal address is "10.1.3.7.2.15".
76 *
77 * ...
78 *
79 * For TCP over IPv6 and for UDP over IPv6, the format of r_addr is the
80 * US-ASCII string:
81 *
82 * x1:x2:x3:x4:x5:x6:x7:x8.p1.p2
83 *
84 * The suffix "p1.p2" is the service port, and is computed the same way
85 * as with universal addresses for TCP and UDP over IPv4. The prefix,
86 * "x1:x2:x3:x4:x5:x6:x7:x8", is the standard textual form for
87 * representing an IPv6 address as defined in Section 2.2 of [RFC2373].
88 * Additionally, the two alternative forms specified in Section 2.2 of
89 * [RFC2373] are also acceptable.
90 *
91 * XXX: Currently this implementation does not explicitly convert the
92 * stored address to US-ASCII on non-ASCII systems.
93 */
94#define RPCB_MAXADDRLEN (128u)
95
96/*
97 * r_owner 58 * r_owner
98 * 59 *
99 * The "owner" is allowed to unset a service in the rpcbind database. 60 * The "owner" is allowed to unset a service in the rpcbind database.
@@ -112,9 +73,9 @@ struct rpcbind_args {
112 u32 r_vers; 73 u32 r_vers;
113 u32 r_prot; 74 u32 r_prot;
114 unsigned short r_port; 75 unsigned short r_port;
115 char * r_netid; 76 const char * r_netid;
116 char r_addr[RPCB_MAXADDRLEN]; 77 const char * r_addr;
117 char * r_owner; 78 const char * r_owner;
118}; 79};
119 80
120static struct rpc_procinfo rpcb_procedures2[]; 81static struct rpc_procinfo rpcb_procedures2[];
@@ -128,19 +89,6 @@ struct rpcb_info {
128static struct rpcb_info rpcb_next_version[]; 89static struct rpcb_info rpcb_next_version[];
129static struct rpcb_info rpcb_next_version6[]; 90static struct rpcb_info rpcb_next_version6[];
130 91
131static void rpcb_getport_prepare(struct rpc_task *task, void *calldata)
132{
133 struct rpcbind_args *map = calldata;
134 struct rpc_xprt *xprt = map->r_xprt;
135 struct rpc_message msg = {
136 .rpc_proc = rpcb_next_version[xprt->bind_index].rpc_proc,
137 .rpc_argp = map,
138 .rpc_resp = &map->r_port,
139 };
140
141 rpc_call_setup(task, &msg, 0);
142}
143
144static void rpcb_map_release(void *data) 92static void rpcb_map_release(void *data)
145{ 93{
146 struct rpcbind_args *map = data; 94 struct rpcbind_args *map = data;
@@ -150,7 +98,6 @@ static void rpcb_map_release(void *data)
150} 98}
151 99
152static const struct rpc_call_ops rpcb_getport_ops = { 100static const struct rpc_call_ops rpcb_getport_ops = {
153 .rpc_call_prepare = rpcb_getport_prepare,
154 .rpc_call_done = rpcb_getport_done, 101 .rpc_call_done = rpcb_getport_done,
155 .rpc_release = rpcb_map_release, 102 .rpc_release = rpcb_map_release,
156}; 103};
@@ -162,12 +109,13 @@ static void rpcb_wake_rpcbind_waiters(struct rpc_xprt *xprt, int status)
162} 109}
163 110
164static struct rpc_clnt *rpcb_create(char *hostname, struct sockaddr *srvaddr, 111static struct rpc_clnt *rpcb_create(char *hostname, struct sockaddr *srvaddr,
165 int proto, int version, int privileged) 112 size_t salen, int proto, u32 version,
113 int privileged)
166{ 114{
167 struct rpc_create_args args = { 115 struct rpc_create_args args = {
168 .protocol = proto, 116 .protocol = proto,
169 .address = srvaddr, 117 .address = srvaddr,
170 .addrsize = sizeof(struct sockaddr_in), 118 .addrsize = salen,
171 .servername = hostname, 119 .servername = hostname,
172 .program = &rpcb_program, 120 .program = &rpcb_program,
173 .version = version, 121 .version = version,
@@ -230,7 +178,7 @@ int rpcb_register(u32 prog, u32 vers, int prot, unsigned short port, int *okay)
230 prog, vers, prot, port); 178 prog, vers, prot, port);
231 179
232 rpcb_clnt = rpcb_create("localhost", (struct sockaddr *) &sin, 180 rpcb_clnt = rpcb_create("localhost", (struct sockaddr *) &sin,
233 XPRT_TRANSPORT_UDP, 2, 1); 181 sizeof(sin), XPRT_TRANSPORT_UDP, 2, 1);
234 if (IS_ERR(rpcb_clnt)) 182 if (IS_ERR(rpcb_clnt))
235 return PTR_ERR(rpcb_clnt); 183 return PTR_ERR(rpcb_clnt);
236 184
@@ -252,13 +200,15 @@ int rpcb_register(u32 prog, u32 vers, int prot, unsigned short port, int *okay)
252 * @vers: RPC version number to bind 200 * @vers: RPC version number to bind
253 * @prot: transport protocol to use to make this request 201 * @prot: transport protocol to use to make this request
254 * 202 *
203 * Return value is the requested advertised port number,
204 * or a negative errno value.
205 *
255 * Called from outside the RPC client in a synchronous task context. 206 * Called from outside the RPC client in a synchronous task context.
256 * Uses default timeout parameters specified by underlying transport. 207 * Uses default timeout parameters specified by underlying transport.
257 * 208 *
258 * XXX: Needs to support IPv6, and rpcbind versions 3 and 4 209 * XXX: Needs to support IPv6
259 */ 210 */
260int rpcb_getport_sync(struct sockaddr_in *sin, __u32 prog, 211int rpcb_getport_sync(struct sockaddr_in *sin, u32 prog, u32 vers, int prot)
261 __u32 vers, int prot)
262{ 212{
263 struct rpcbind_args map = { 213 struct rpcbind_args map = {
264 .r_prog = prog, 214 .r_prog = prog,
@@ -272,14 +222,13 @@ int rpcb_getport_sync(struct sockaddr_in *sin, __u32 prog,
272 .rpc_resp = &map.r_port, 222 .rpc_resp = &map.r_port,
273 }; 223 };
274 struct rpc_clnt *rpcb_clnt; 224 struct rpc_clnt *rpcb_clnt;
275 char hostname[40];
276 int status; 225 int status;
277 226
278 dprintk("RPC: %s(" NIPQUAD_FMT ", %u, %u, %d)\n", 227 dprintk("RPC: %s(" NIPQUAD_FMT ", %u, %u, %d)\n",
279 __FUNCTION__, NIPQUAD(sin->sin_addr.s_addr), prog, vers, prot); 228 __FUNCTION__, NIPQUAD(sin->sin_addr.s_addr), prog, vers, prot);
280 229
281 sprintf(hostname, NIPQUAD_FMT, NIPQUAD(sin->sin_addr.s_addr)); 230 rpcb_clnt = rpcb_create(NULL, (struct sockaddr *)sin,
282 rpcb_clnt = rpcb_create(hostname, (struct sockaddr *)sin, prot, 2, 0); 231 sizeof(*sin), prot, 2, 0);
283 if (IS_ERR(rpcb_clnt)) 232 if (IS_ERR(rpcb_clnt))
284 return PTR_ERR(rpcb_clnt); 233 return PTR_ERR(rpcb_clnt);
285 234
@@ -295,6 +244,24 @@ int rpcb_getport_sync(struct sockaddr_in *sin, __u32 prog,
295} 244}
296EXPORT_SYMBOL_GPL(rpcb_getport_sync); 245EXPORT_SYMBOL_GPL(rpcb_getport_sync);
297 246
247static struct rpc_task *rpcb_call_async(struct rpc_clnt *rpcb_clnt, struct rpcbind_args *map, int version)
248{
249 struct rpc_message msg = {
250 .rpc_proc = rpcb_next_version[version].rpc_proc,
251 .rpc_argp = map,
252 .rpc_resp = &map->r_port,
253 };
254 struct rpc_task_setup task_setup_data = {
255 .rpc_client = rpcb_clnt,
256 .rpc_message = &msg,
257 .callback_ops = &rpcb_getport_ops,
258 .callback_data = map,
259 .flags = RPC_TASK_ASYNC,
260 };
261
262 return rpc_run_task(&task_setup_data);
263}
264
298/** 265/**
299 * rpcb_getport_async - obtain the port for a given RPC service on a given host 266 * rpcb_getport_async - obtain the port for a given RPC service on a given host
300 * @task: task that is waiting for portmapper request 267 * @task: task that is waiting for portmapper request
@@ -305,12 +272,14 @@ EXPORT_SYMBOL_GPL(rpcb_getport_sync);
305void rpcb_getport_async(struct rpc_task *task) 272void rpcb_getport_async(struct rpc_task *task)
306{ 273{
307 struct rpc_clnt *clnt = task->tk_client; 274 struct rpc_clnt *clnt = task->tk_client;
308 int bind_version; 275 u32 bind_version;
309 struct rpc_xprt *xprt = task->tk_xprt; 276 struct rpc_xprt *xprt = task->tk_xprt;
310 struct rpc_clnt *rpcb_clnt; 277 struct rpc_clnt *rpcb_clnt;
311 static struct rpcbind_args *map; 278 static struct rpcbind_args *map;
312 struct rpc_task *child; 279 struct rpc_task *child;
313 struct sockaddr addr; 280 struct sockaddr_storage addr;
281 struct sockaddr *sap = (struct sockaddr *)&addr;
282 size_t salen;
314 int status; 283 int status;
315 struct rpcb_info *info; 284 struct rpcb_info *info;
316 285
@@ -340,10 +309,10 @@ void rpcb_getport_async(struct rpc_task *task)
340 goto bailout_nofree; 309 goto bailout_nofree;
341 } 310 }
342 311
343 rpc_peeraddr(clnt, (void *)&addr, sizeof(addr)); 312 salen = rpc_peeraddr(clnt, sap, sizeof(addr));
344 313
345 /* Don't ever use rpcbind v2 for AF_INET6 requests */ 314 /* Don't ever use rpcbind v2 for AF_INET6 requests */
346 switch (addr.sa_family) { 315 switch (sap->sa_family) {
347 case AF_INET: 316 case AF_INET:
348 info = rpcb_next_version; 317 info = rpcb_next_version;
349 break; 318 break;
@@ -368,7 +337,7 @@ void rpcb_getport_async(struct rpc_task *task)
368 dprintk("RPC: %5u %s: trying rpcbind version %u\n", 337 dprintk("RPC: %5u %s: trying rpcbind version %u\n",
369 task->tk_pid, __FUNCTION__, bind_version); 338 task->tk_pid, __FUNCTION__, bind_version);
370 339
371 rpcb_clnt = rpcb_create(clnt->cl_server, &addr, xprt->prot, 340 rpcb_clnt = rpcb_create(clnt->cl_server, sap, salen, xprt->prot,
372 bind_version, 0); 341 bind_version, 0);
373 if (IS_ERR(rpcb_clnt)) { 342 if (IS_ERR(rpcb_clnt)) {
374 status = PTR_ERR(rpcb_clnt); 343 status = PTR_ERR(rpcb_clnt);
@@ -390,12 +359,10 @@ void rpcb_getport_async(struct rpc_task *task)
390 map->r_port = 0; 359 map->r_port = 0;
391 map->r_xprt = xprt_get(xprt); 360 map->r_xprt = xprt_get(xprt);
392 map->r_netid = rpc_peeraddr2str(clnt, RPC_DISPLAY_NETID); 361 map->r_netid = rpc_peeraddr2str(clnt, RPC_DISPLAY_NETID);
393 memcpy(map->r_addr, 362 map->r_addr = rpc_peeraddr2str(rpcb_clnt, RPC_DISPLAY_UNIVERSAL_ADDR);
394 rpc_peeraddr2str(rpcb_clnt, RPC_DISPLAY_UNIVERSAL_ADDR),
395 sizeof(map->r_addr));
396 map->r_owner = RPCB_OWNER_STRING; /* ignored for GETADDR */ 363 map->r_owner = RPCB_OWNER_STRING; /* ignored for GETADDR */
397 364
398 child = rpc_run_task(rpcb_clnt, RPC_TASK_ASYNC, &rpcb_getport_ops, map); 365 child = rpcb_call_async(rpcb_clnt, map, xprt->bind_index);
399 rpc_release_client(rpcb_clnt); 366 rpc_release_client(rpcb_clnt);
400 if (IS_ERR(child)) { 367 if (IS_ERR(child)) {
401 status = -EIO; 368 status = -EIO;
@@ -518,7 +485,7 @@ static int rpcb_decode_getaddr(struct rpc_rqst *req, __be32 *p,
518 * Simple sanity check. The smallest possible universal 485 * Simple sanity check. The smallest possible universal
519 * address is an IPv4 address string containing 11 bytes. 486 * address is an IPv4 address string containing 11 bytes.
520 */ 487 */
521 if (addr_len < 11 || addr_len > RPCB_MAXADDRLEN) 488 if (addr_len < 11 || addr_len > RPCBIND_MAXUADDRLEN)
522 goto out_err; 489 goto out_err;
523 490
524 /* 491 /*
@@ -569,7 +536,7 @@ out_err:
569#define RPCB_boolean_sz (1u) 536#define RPCB_boolean_sz (1u)
570 537
571#define RPCB_netid_sz (1+XDR_QUADLEN(RPCBIND_MAXNETIDLEN)) 538#define RPCB_netid_sz (1+XDR_QUADLEN(RPCBIND_MAXNETIDLEN))
572#define RPCB_addr_sz (1+XDR_QUADLEN(RPCB_MAXADDRLEN)) 539#define RPCB_addr_sz (1+XDR_QUADLEN(RPCBIND_MAXUADDRLEN))
573#define RPCB_ownerstring_sz (1+XDR_QUADLEN(RPCB_MAXOWNERLEN)) 540#define RPCB_ownerstring_sz (1+XDR_QUADLEN(RPCB_MAXOWNERLEN))
574 541
575#define RPCB_mappingargs_sz RPCB_program_sz+RPCB_version_sz+ \ 542#define RPCB_mappingargs_sz RPCB_program_sz+RPCB_version_sz+ \
diff --git a/net/sunrpc/sched.c b/net/sunrpc/sched.c
index eed5dd9819cd..40ce6f6672d6 100644
--- a/net/sunrpc/sched.c
+++ b/net/sunrpc/sched.c
@@ -45,7 +45,7 @@ static void rpc_release_task(struct rpc_task *task);
45/* 45/*
46 * RPC tasks sit here while waiting for conditions to improve. 46 * RPC tasks sit here while waiting for conditions to improve.
47 */ 47 */
48static RPC_WAITQ(delay_queue, "delayq"); 48static struct rpc_wait_queue delay_queue;
49 49
50/* 50/*
51 * rpciod-related stuff 51 * rpciod-related stuff
@@ -135,7 +135,7 @@ static void __rpc_add_wait_queue_priority(struct rpc_wait_queue *queue, struct r
135 if (unlikely(task->tk_priority > queue->maxpriority)) 135 if (unlikely(task->tk_priority > queue->maxpriority))
136 q = &queue->tasks[queue->maxpriority]; 136 q = &queue->tasks[queue->maxpriority];
137 list_for_each_entry(t, q, u.tk_wait.list) { 137 list_for_each_entry(t, q, u.tk_wait.list) {
138 if (t->tk_cookie == task->tk_cookie) { 138 if (t->tk_owner == task->tk_owner) {
139 list_add_tail(&task->u.tk_wait.list, &t->u.tk_wait.links); 139 list_add_tail(&task->u.tk_wait.list, &t->u.tk_wait.links);
140 return; 140 return;
141 } 141 }
@@ -208,26 +208,26 @@ static inline void rpc_set_waitqueue_priority(struct rpc_wait_queue *queue, int
208 queue->count = 1 << (priority * 2); 208 queue->count = 1 << (priority * 2);
209} 209}
210 210
211static inline void rpc_set_waitqueue_cookie(struct rpc_wait_queue *queue, unsigned long cookie) 211static inline void rpc_set_waitqueue_owner(struct rpc_wait_queue *queue, pid_t pid)
212{ 212{
213 queue->cookie = cookie; 213 queue->owner = pid;
214 queue->nr = RPC_BATCH_COUNT; 214 queue->nr = RPC_BATCH_COUNT;
215} 215}
216 216
217static inline void rpc_reset_waitqueue_priority(struct rpc_wait_queue *queue) 217static inline void rpc_reset_waitqueue_priority(struct rpc_wait_queue *queue)
218{ 218{
219 rpc_set_waitqueue_priority(queue, queue->maxpriority); 219 rpc_set_waitqueue_priority(queue, queue->maxpriority);
220 rpc_set_waitqueue_cookie(queue, 0); 220 rpc_set_waitqueue_owner(queue, 0);
221} 221}
222 222
223static void __rpc_init_priority_wait_queue(struct rpc_wait_queue *queue, const char *qname, int maxprio) 223static void __rpc_init_priority_wait_queue(struct rpc_wait_queue *queue, const char *qname, unsigned char nr_queues)
224{ 224{
225 int i; 225 int i;
226 226
227 spin_lock_init(&queue->lock); 227 spin_lock_init(&queue->lock);
228 for (i = 0; i < ARRAY_SIZE(queue->tasks); i++) 228 for (i = 0; i < ARRAY_SIZE(queue->tasks); i++)
229 INIT_LIST_HEAD(&queue->tasks[i]); 229 INIT_LIST_HEAD(&queue->tasks[i]);
230 queue->maxpriority = maxprio; 230 queue->maxpriority = nr_queues - 1;
231 rpc_reset_waitqueue_priority(queue); 231 rpc_reset_waitqueue_priority(queue);
232#ifdef RPC_DEBUG 232#ifdef RPC_DEBUG
233 queue->name = qname; 233 queue->name = qname;
@@ -236,14 +236,14 @@ static void __rpc_init_priority_wait_queue(struct rpc_wait_queue *queue, const c
236 236
237void rpc_init_priority_wait_queue(struct rpc_wait_queue *queue, const char *qname) 237void rpc_init_priority_wait_queue(struct rpc_wait_queue *queue, const char *qname)
238{ 238{
239 __rpc_init_priority_wait_queue(queue, qname, RPC_PRIORITY_HIGH); 239 __rpc_init_priority_wait_queue(queue, qname, RPC_NR_PRIORITY);
240} 240}
241 241
242void rpc_init_wait_queue(struct rpc_wait_queue *queue, const char *qname) 242void rpc_init_wait_queue(struct rpc_wait_queue *queue, const char *qname)
243{ 243{
244 __rpc_init_priority_wait_queue(queue, qname, 0); 244 __rpc_init_priority_wait_queue(queue, qname, 1);
245} 245}
246EXPORT_SYMBOL(rpc_init_wait_queue); 246EXPORT_SYMBOL_GPL(rpc_init_wait_queue);
247 247
248static int rpc_wait_bit_interruptible(void *word) 248static int rpc_wait_bit_interruptible(void *word)
249{ 249{
@@ -303,7 +303,7 @@ int __rpc_wait_for_completion_task(struct rpc_task *task, int (*action)(void *))
303 return wait_on_bit(&task->tk_runstate, RPC_TASK_ACTIVE, 303 return wait_on_bit(&task->tk_runstate, RPC_TASK_ACTIVE,
304 action, TASK_INTERRUPTIBLE); 304 action, TASK_INTERRUPTIBLE);
305} 305}
306EXPORT_SYMBOL(__rpc_wait_for_completion_task); 306EXPORT_SYMBOL_GPL(__rpc_wait_for_completion_task);
307 307
308/* 308/*
309 * Make an RPC task runnable. 309 * Make an RPC task runnable.
@@ -373,6 +373,7 @@ void rpc_sleep_on(struct rpc_wait_queue *q, struct rpc_task *task,
373 __rpc_sleep_on(q, task, action, timer); 373 __rpc_sleep_on(q, task, action, timer);
374 spin_unlock_bh(&q->lock); 374 spin_unlock_bh(&q->lock);
375} 375}
376EXPORT_SYMBOL_GPL(rpc_sleep_on);
376 377
377/** 378/**
378 * __rpc_do_wake_up_task - wake up a single rpc_task 379 * __rpc_do_wake_up_task - wake up a single rpc_task
@@ -444,6 +445,7 @@ void rpc_wake_up_task(struct rpc_task *task)
444 } 445 }
445 rcu_read_unlock_bh(); 446 rcu_read_unlock_bh();
446} 447}
448EXPORT_SYMBOL_GPL(rpc_wake_up_task);
447 449
448/* 450/*
449 * Wake up the next task on a priority queue. 451 * Wake up the next task on a priority queue.
@@ -454,12 +456,12 @@ static struct rpc_task * __rpc_wake_up_next_priority(struct rpc_wait_queue *queu
454 struct rpc_task *task; 456 struct rpc_task *task;
455 457
456 /* 458 /*
457 * Service a batch of tasks from a single cookie. 459 * Service a batch of tasks from a single owner.
458 */ 460 */
459 q = &queue->tasks[queue->priority]; 461 q = &queue->tasks[queue->priority];
460 if (!list_empty(q)) { 462 if (!list_empty(q)) {
461 task = list_entry(q->next, struct rpc_task, u.tk_wait.list); 463 task = list_entry(q->next, struct rpc_task, u.tk_wait.list);
462 if (queue->cookie == task->tk_cookie) { 464 if (queue->owner == task->tk_owner) {
463 if (--queue->nr) 465 if (--queue->nr)
464 goto out; 466 goto out;
465 list_move_tail(&task->u.tk_wait.list, q); 467 list_move_tail(&task->u.tk_wait.list, q);
@@ -468,7 +470,7 @@ static struct rpc_task * __rpc_wake_up_next_priority(struct rpc_wait_queue *queu
468 * Check if we need to switch queues. 470 * Check if we need to switch queues.
469 */ 471 */
470 if (--queue->count) 472 if (--queue->count)
471 goto new_cookie; 473 goto new_owner;
472 } 474 }
473 475
474 /* 476 /*
@@ -490,8 +492,8 @@ static struct rpc_task * __rpc_wake_up_next_priority(struct rpc_wait_queue *queu
490 492
491new_queue: 493new_queue:
492 rpc_set_waitqueue_priority(queue, (unsigned int)(q - &queue->tasks[0])); 494 rpc_set_waitqueue_priority(queue, (unsigned int)(q - &queue->tasks[0]));
493new_cookie: 495new_owner:
494 rpc_set_waitqueue_cookie(queue, task->tk_cookie); 496 rpc_set_waitqueue_owner(queue, task->tk_owner);
495out: 497out:
496 __rpc_wake_up_task(task); 498 __rpc_wake_up_task(task);
497 return task; 499 return task;
@@ -519,6 +521,7 @@ struct rpc_task * rpc_wake_up_next(struct rpc_wait_queue *queue)
519 521
520 return task; 522 return task;
521} 523}
524EXPORT_SYMBOL_GPL(rpc_wake_up_next);
522 525
523/** 526/**
524 * rpc_wake_up - wake up all rpc_tasks 527 * rpc_wake_up - wake up all rpc_tasks
@@ -544,6 +547,7 @@ void rpc_wake_up(struct rpc_wait_queue *queue)
544 spin_unlock(&queue->lock); 547 spin_unlock(&queue->lock);
545 rcu_read_unlock_bh(); 548 rcu_read_unlock_bh();
546} 549}
550EXPORT_SYMBOL_GPL(rpc_wake_up);
547 551
548/** 552/**
549 * rpc_wake_up_status - wake up all rpc_tasks and set their status value. 553 * rpc_wake_up_status - wake up all rpc_tasks and set their status value.
@@ -572,6 +576,7 @@ void rpc_wake_up_status(struct rpc_wait_queue *queue, int status)
572 spin_unlock(&queue->lock); 576 spin_unlock(&queue->lock);
573 rcu_read_unlock_bh(); 577 rcu_read_unlock_bh();
574} 578}
579EXPORT_SYMBOL_GPL(rpc_wake_up_status);
575 580
576static void __rpc_atrun(struct rpc_task *task) 581static void __rpc_atrun(struct rpc_task *task)
577{ 582{
@@ -586,6 +591,7 @@ void rpc_delay(struct rpc_task *task, unsigned long delay)
586 task->tk_timeout = delay; 591 task->tk_timeout = delay;
587 rpc_sleep_on(&delay_queue, task, NULL, __rpc_atrun); 592 rpc_sleep_on(&delay_queue, task, NULL, __rpc_atrun);
588} 593}
594EXPORT_SYMBOL_GPL(rpc_delay);
589 595
590/* 596/*
591 * Helper to call task->tk_ops->rpc_call_prepare 597 * Helper to call task->tk_ops->rpc_call_prepare
@@ -614,7 +620,7 @@ void rpc_exit_task(struct rpc_task *task)
614 } 620 }
615 } 621 }
616} 622}
617EXPORT_SYMBOL(rpc_exit_task); 623EXPORT_SYMBOL_GPL(rpc_exit_task);
618 624
619void rpc_release_calldata(const struct rpc_call_ops *ops, void *calldata) 625void rpc_release_calldata(const struct rpc_call_ops *ops, void *calldata)
620{ 626{
@@ -808,39 +814,49 @@ EXPORT_SYMBOL_GPL(rpc_free);
808/* 814/*
809 * Creation and deletion of RPC task structures 815 * Creation and deletion of RPC task structures
810 */ 816 */
811void rpc_init_task(struct rpc_task *task, struct rpc_clnt *clnt, int flags, const struct rpc_call_ops *tk_ops, void *calldata) 817static void rpc_init_task(struct rpc_task *task, const struct rpc_task_setup *task_setup_data)
812{ 818{
813 memset(task, 0, sizeof(*task)); 819 memset(task, 0, sizeof(*task));
814 setup_timer(&task->tk_timer, (void (*)(unsigned long))rpc_run_timer, 820 setup_timer(&task->tk_timer, (void (*)(unsigned long))rpc_run_timer,
815 (unsigned long)task); 821 (unsigned long)task);
816 atomic_set(&task->tk_count, 1); 822 atomic_set(&task->tk_count, 1);
817 task->tk_client = clnt; 823 task->tk_flags = task_setup_data->flags;
818 task->tk_flags = flags; 824 task->tk_ops = task_setup_data->callback_ops;
819 task->tk_ops = tk_ops; 825 task->tk_calldata = task_setup_data->callback_data;
820 if (tk_ops->rpc_call_prepare != NULL)
821 task->tk_action = rpc_prepare_task;
822 task->tk_calldata = calldata;
823 INIT_LIST_HEAD(&task->tk_task); 826 INIT_LIST_HEAD(&task->tk_task);
824 827
825 /* Initialize retry counters */ 828 /* Initialize retry counters */
826 task->tk_garb_retry = 2; 829 task->tk_garb_retry = 2;
827 task->tk_cred_retry = 2; 830 task->tk_cred_retry = 2;
828 831
829 task->tk_priority = RPC_PRIORITY_NORMAL; 832 task->tk_priority = task_setup_data->priority - RPC_PRIORITY_LOW;
830 task->tk_cookie = (unsigned long)current; 833 task->tk_owner = current->tgid;
831 834
832 /* Initialize workqueue for async tasks */ 835 /* Initialize workqueue for async tasks */
833 task->tk_workqueue = rpciod_workqueue; 836 task->tk_workqueue = rpciod_workqueue;
834 837
835 if (clnt) { 838 task->tk_client = task_setup_data->rpc_client;
836 kref_get(&clnt->cl_kref); 839 if (task->tk_client != NULL) {
837 if (clnt->cl_softrtry) 840 kref_get(&task->tk_client->cl_kref);
841 if (task->tk_client->cl_softrtry)
838 task->tk_flags |= RPC_TASK_SOFT; 842 task->tk_flags |= RPC_TASK_SOFT;
839 if (!clnt->cl_intr) 843 if (!task->tk_client->cl_intr)
840 task->tk_flags |= RPC_TASK_NOINTR; 844 task->tk_flags |= RPC_TASK_NOINTR;
841 } 845 }
842 846
843 BUG_ON(task->tk_ops == NULL); 847 if (task->tk_ops->rpc_call_prepare != NULL)
848 task->tk_action = rpc_prepare_task;
849
850 if (task_setup_data->rpc_message != NULL) {
851 memcpy(&task->tk_msg, task_setup_data->rpc_message, sizeof(task->tk_msg));
852 /* Bind the user cred */
853 if (task->tk_msg.rpc_cred != NULL)
854 rpcauth_holdcred(task);
855 else
856 rpcauth_bindcred(task);
857 if (task->tk_action == NULL)
858 rpc_call_start(task);
859 }
844 860
845 /* starting timestamp */ 861 /* starting timestamp */
846 task->tk_start = jiffies; 862 task->tk_start = jiffies;
@@ -865,18 +881,22 @@ static void rpc_free_task(struct rcu_head *rcu)
865/* 881/*
866 * Create a new task for the specified client. 882 * Create a new task for the specified client.
867 */ 883 */
868struct rpc_task *rpc_new_task(struct rpc_clnt *clnt, int flags, const struct rpc_call_ops *tk_ops, void *calldata) 884struct rpc_task *rpc_new_task(const struct rpc_task_setup *setup_data)
869{ 885{
870 struct rpc_task *task; 886 struct rpc_task *task = setup_data->task;
871 887 unsigned short flags = 0;
872 task = rpc_alloc_task(); 888
873 if (!task) 889 if (task == NULL) {
874 goto out; 890 task = rpc_alloc_task();
891 if (task == NULL)
892 goto out;
893 flags = RPC_TASK_DYNAMIC;
894 }
875 895
876 rpc_init_task(task, clnt, flags, tk_ops, calldata); 896 rpc_init_task(task, setup_data);
877 897
898 task->tk_flags |= flags;
878 dprintk("RPC: allocated task %p\n", task); 899 dprintk("RPC: allocated task %p\n", task);
879 task->tk_flags |= RPC_TASK_DYNAMIC;
880out: 900out:
881 return task; 901 return task;
882} 902}
@@ -902,7 +922,7 @@ void rpc_put_task(struct rpc_task *task)
902 call_rcu_bh(&task->u.tk_rcu, rpc_free_task); 922 call_rcu_bh(&task->u.tk_rcu, rpc_free_task);
903 rpc_release_calldata(tk_ops, calldata); 923 rpc_release_calldata(tk_ops, calldata);
904} 924}
905EXPORT_SYMBOL(rpc_put_task); 925EXPORT_SYMBOL_GPL(rpc_put_task);
906 926
907static void rpc_release_task(struct rpc_task *task) 927static void rpc_release_task(struct rpc_task *task)
908{ 928{
@@ -959,6 +979,7 @@ void rpc_killall_tasks(struct rpc_clnt *clnt)
959 } 979 }
960 spin_unlock(&clnt->cl_lock); 980 spin_unlock(&clnt->cl_lock);
961} 981}
982EXPORT_SYMBOL_GPL(rpc_killall_tasks);
962 983
963int rpciod_up(void) 984int rpciod_up(void)
964{ 985{
@@ -1038,6 +1059,11 @@ rpc_init_mempool(void)
1038 goto err_nomem; 1059 goto err_nomem;
1039 if (!rpciod_start()) 1060 if (!rpciod_start())
1040 goto err_nomem; 1061 goto err_nomem;
1062 /*
1063 * The following is not strictly a mempool initialisation,
1064 * but there is no harm in doing it here
1065 */
1066 rpc_init_wait_queue(&delay_queue, "delayq");
1041 return 0; 1067 return 0;
1042err_nomem: 1068err_nomem:
1043 rpc_destroy_mempool(); 1069 rpc_destroy_mempool();
diff --git a/net/sunrpc/socklib.c b/net/sunrpc/socklib.c
index 97ac45f034d6..a661a3acb37e 100644
--- a/net/sunrpc/socklib.c
+++ b/net/sunrpc/socklib.c
@@ -72,7 +72,7 @@ ssize_t xdr_partial_copy_from_skb(struct xdr_buf *xdr, unsigned int base, struct
72 struct page **ppage = xdr->pages; 72 struct page **ppage = xdr->pages;
73 unsigned int len, pglen = xdr->page_len; 73 unsigned int len, pglen = xdr->page_len;
74 ssize_t copied = 0; 74 ssize_t copied = 0;
75 int ret; 75 size_t ret;
76 76
77 len = xdr->head[0].iov_len; 77 len = xdr->head[0].iov_len;
78 if (base < len) { 78 if (base < len) {
diff --git a/net/sunrpc/stats.c b/net/sunrpc/stats.c
index 4d4f3738b688..74df2d358e61 100644
--- a/net/sunrpc/stats.c
+++ b/net/sunrpc/stats.c
@@ -118,7 +118,7 @@ struct rpc_iostats *rpc_alloc_iostats(struct rpc_clnt *clnt)
118 new = kcalloc(clnt->cl_maxproc, sizeof(struct rpc_iostats), GFP_KERNEL); 118 new = kcalloc(clnt->cl_maxproc, sizeof(struct rpc_iostats), GFP_KERNEL);
119 return new; 119 return new;
120} 120}
121EXPORT_SYMBOL(rpc_alloc_iostats); 121EXPORT_SYMBOL_GPL(rpc_alloc_iostats);
122 122
123/** 123/**
124 * rpc_free_iostats - release an rpc_iostats structure 124 * rpc_free_iostats - release an rpc_iostats structure
@@ -129,7 +129,7 @@ void rpc_free_iostats(struct rpc_iostats *stats)
129{ 129{
130 kfree(stats); 130 kfree(stats);
131} 131}
132EXPORT_SYMBOL(rpc_free_iostats); 132EXPORT_SYMBOL_GPL(rpc_free_iostats);
133 133
134/** 134/**
135 * rpc_count_iostats - tally up per-task stats 135 * rpc_count_iostats - tally up per-task stats
@@ -215,7 +215,7 @@ void rpc_print_iostats(struct seq_file *seq, struct rpc_clnt *clnt)
215 metrics->om_execute * MILLISECS_PER_JIFFY); 215 metrics->om_execute * MILLISECS_PER_JIFFY);
216 } 216 }
217} 217}
218EXPORT_SYMBOL(rpc_print_iostats); 218EXPORT_SYMBOL_GPL(rpc_print_iostats);
219 219
220/* 220/*
221 * Register/unregister RPC proc files 221 * Register/unregister RPC proc files
@@ -241,12 +241,14 @@ rpc_proc_register(struct rpc_stat *statp)
241{ 241{
242 return do_register(statp->program->name, statp, &rpc_proc_fops); 242 return do_register(statp->program->name, statp, &rpc_proc_fops);
243} 243}
244EXPORT_SYMBOL_GPL(rpc_proc_register);
244 245
245void 246void
246rpc_proc_unregister(const char *name) 247rpc_proc_unregister(const char *name)
247{ 248{
248 remove_proc_entry(name, proc_net_rpc); 249 remove_proc_entry(name, proc_net_rpc);
249} 250}
251EXPORT_SYMBOL_GPL(rpc_proc_unregister);
250 252
251struct proc_dir_entry * 253struct proc_dir_entry *
252svc_proc_register(struct svc_stat *statp, const struct file_operations *fops) 254svc_proc_register(struct svc_stat *statp, const struct file_operations *fops)
diff --git a/net/sunrpc/sunrpc_syms.c b/net/sunrpc/sunrpc_syms.c
index 33d89e842c85..1a7e309d008b 100644
--- a/net/sunrpc/sunrpc_syms.c
+++ b/net/sunrpc/sunrpc_syms.c
@@ -22,45 +22,6 @@
22#include <linux/sunrpc/rpc_pipe_fs.h> 22#include <linux/sunrpc/rpc_pipe_fs.h>
23#include <linux/sunrpc/xprtsock.h> 23#include <linux/sunrpc/xprtsock.h>
24 24
25/* RPC scheduler */
26EXPORT_SYMBOL(rpc_execute);
27EXPORT_SYMBOL(rpc_init_task);
28EXPORT_SYMBOL(rpc_sleep_on);
29EXPORT_SYMBOL(rpc_wake_up_next);
30EXPORT_SYMBOL(rpc_wake_up_task);
31EXPORT_SYMBOL(rpc_wake_up_status);
32
33/* RPC client functions */
34EXPORT_SYMBOL(rpc_clone_client);
35EXPORT_SYMBOL(rpc_bind_new_program);
36EXPORT_SYMBOL(rpc_shutdown_client);
37EXPORT_SYMBOL(rpc_killall_tasks);
38EXPORT_SYMBOL(rpc_call_sync);
39EXPORT_SYMBOL(rpc_call_async);
40EXPORT_SYMBOL(rpc_call_setup);
41EXPORT_SYMBOL(rpc_clnt_sigmask);
42EXPORT_SYMBOL(rpc_clnt_sigunmask);
43EXPORT_SYMBOL(rpc_delay);
44EXPORT_SYMBOL(rpc_restart_call);
45EXPORT_SYMBOL(rpc_setbufsize);
46EXPORT_SYMBOL(rpc_unlink);
47EXPORT_SYMBOL(rpc_wake_up);
48EXPORT_SYMBOL(rpc_queue_upcall);
49EXPORT_SYMBOL(rpc_mkpipe);
50
51/* Client transport */
52EXPORT_SYMBOL(xprt_set_timeout);
53
54/* Client credential cache */
55EXPORT_SYMBOL(rpcauth_register);
56EXPORT_SYMBOL(rpcauth_unregister);
57EXPORT_SYMBOL(rpcauth_create);
58EXPORT_SYMBOL(rpcauth_lookupcred);
59EXPORT_SYMBOL(rpcauth_lookup_credcache);
60EXPORT_SYMBOL(rpcauth_destroy_credcache);
61EXPORT_SYMBOL(rpcauth_init_credcache);
62EXPORT_SYMBOL(put_rpccred);
63
64/* RPC server stuff */ 25/* RPC server stuff */
65EXPORT_SYMBOL(svc_create); 26EXPORT_SYMBOL(svc_create);
66EXPORT_SYMBOL(svc_create_thread); 27EXPORT_SYMBOL(svc_create_thread);
@@ -81,8 +42,6 @@ EXPORT_SYMBOL(svc_set_client);
81 42
82/* RPC statistics */ 43/* RPC statistics */
83#ifdef CONFIG_PROC_FS 44#ifdef CONFIG_PROC_FS
84EXPORT_SYMBOL(rpc_proc_register);
85EXPORT_SYMBOL(rpc_proc_unregister);
86EXPORT_SYMBOL(svc_proc_register); 45EXPORT_SYMBOL(svc_proc_register);
87EXPORT_SYMBOL(svc_proc_unregister); 46EXPORT_SYMBOL(svc_proc_unregister);
88EXPORT_SYMBOL(svc_seq_show); 47EXPORT_SYMBOL(svc_seq_show);
@@ -105,31 +64,6 @@ EXPORT_SYMBOL(qword_get);
105EXPORT_SYMBOL(svcauth_unix_purge); 64EXPORT_SYMBOL(svcauth_unix_purge);
106EXPORT_SYMBOL(unix_domain_find); 65EXPORT_SYMBOL(unix_domain_find);
107 66
108/* Generic XDR */
109EXPORT_SYMBOL(xdr_encode_string);
110EXPORT_SYMBOL(xdr_decode_string_inplace);
111EXPORT_SYMBOL(xdr_decode_netobj);
112EXPORT_SYMBOL(xdr_encode_netobj);
113EXPORT_SYMBOL(xdr_encode_pages);
114EXPORT_SYMBOL(xdr_inline_pages);
115EXPORT_SYMBOL(xdr_shift_buf);
116EXPORT_SYMBOL(xdr_encode_word);
117EXPORT_SYMBOL(xdr_decode_word);
118EXPORT_SYMBOL(xdr_encode_array2);
119EXPORT_SYMBOL(xdr_decode_array2);
120EXPORT_SYMBOL(xdr_buf_from_iov);
121EXPORT_SYMBOL(xdr_buf_subsegment);
122EXPORT_SYMBOL(xdr_buf_read_netobj);
123EXPORT_SYMBOL(read_bytes_from_xdr_buf);
124
125/* Debugging symbols */
126#ifdef RPC_DEBUG
127EXPORT_SYMBOL(rpc_debug);
128EXPORT_SYMBOL(nfs_debug);
129EXPORT_SYMBOL(nfsd_debug);
130EXPORT_SYMBOL(nlm_debug);
131#endif
132
133extern struct cache_detail ip_map_cache, unix_gid_cache; 67extern struct cache_detail ip_map_cache, unix_gid_cache;
134 68
135static int __init 69static int __init
diff --git a/net/sunrpc/svc.c b/net/sunrpc/svc.c
index a4a6bf7deaa4..4ad5fbbb18b4 100644
--- a/net/sunrpc/svc.c
+++ b/net/sunrpc/svc.c
@@ -18,6 +18,7 @@
18#include <linux/mm.h> 18#include <linux/mm.h>
19#include <linux/interrupt.h> 19#include <linux/interrupt.h>
20#include <linux/module.h> 20#include <linux/module.h>
21#include <linux/sched.h>
21 22
22#include <linux/sunrpc/types.h> 23#include <linux/sunrpc/types.h>
23#include <linux/sunrpc/xdr.h> 24#include <linux/sunrpc/xdr.h>
diff --git a/net/sunrpc/sysctl.c b/net/sunrpc/sysctl.c
index 2be714e9b382..bada7de0c2fc 100644
--- a/net/sunrpc/sysctl.c
+++ b/net/sunrpc/sysctl.c
@@ -23,9 +23,16 @@
23 * Declare the debug flags here 23 * Declare the debug flags here
24 */ 24 */
25unsigned int rpc_debug; 25unsigned int rpc_debug;
26EXPORT_SYMBOL_GPL(rpc_debug);
27
26unsigned int nfs_debug; 28unsigned int nfs_debug;
29EXPORT_SYMBOL_GPL(nfs_debug);
30
27unsigned int nfsd_debug; 31unsigned int nfsd_debug;
32EXPORT_SYMBOL_GPL(nfsd_debug);
33
28unsigned int nlm_debug; 34unsigned int nlm_debug;
35EXPORT_SYMBOL_GPL(nlm_debug);
29 36
30#ifdef RPC_DEBUG 37#ifdef RPC_DEBUG
31 38
diff --git a/net/sunrpc/xdr.c b/net/sunrpc/xdr.c
index fdc5e6d7562b..54264062ea69 100644
--- a/net/sunrpc/xdr.c
+++ b/net/sunrpc/xdr.c
@@ -28,6 +28,7 @@ xdr_encode_netobj(__be32 *p, const struct xdr_netobj *obj)
28 memcpy(p, obj->data, obj->len); 28 memcpy(p, obj->data, obj->len);
29 return p + XDR_QUADLEN(obj->len); 29 return p + XDR_QUADLEN(obj->len);
30} 30}
31EXPORT_SYMBOL(xdr_encode_netobj);
31 32
32__be32 * 33__be32 *
33xdr_decode_netobj(__be32 *p, struct xdr_netobj *obj) 34xdr_decode_netobj(__be32 *p, struct xdr_netobj *obj)
@@ -40,6 +41,7 @@ xdr_decode_netobj(__be32 *p, struct xdr_netobj *obj)
40 obj->data = (u8 *) p; 41 obj->data = (u8 *) p;
41 return p + XDR_QUADLEN(len); 42 return p + XDR_QUADLEN(len);
42} 43}
44EXPORT_SYMBOL(xdr_decode_netobj);
43 45
44/** 46/**
45 * xdr_encode_opaque_fixed - Encode fixed length opaque data 47 * xdr_encode_opaque_fixed - Encode fixed length opaque data
@@ -91,6 +93,7 @@ xdr_encode_string(__be32 *p, const char *string)
91{ 93{
92 return xdr_encode_array(p, string, strlen(string)); 94 return xdr_encode_array(p, string, strlen(string));
93} 95}
96EXPORT_SYMBOL(xdr_encode_string);
94 97
95__be32 * 98__be32 *
96xdr_decode_string_inplace(__be32 *p, char **sp, int *lenp, int maxlen) 99xdr_decode_string_inplace(__be32 *p, char **sp, int *lenp, int maxlen)
@@ -103,6 +106,7 @@ xdr_decode_string_inplace(__be32 *p, char **sp, int *lenp, int maxlen)
103 *sp = (char *) p; 106 *sp = (char *) p;
104 return p + XDR_QUADLEN(len); 107 return p + XDR_QUADLEN(len);
105} 108}
109EXPORT_SYMBOL(xdr_decode_string_inplace);
106 110
107void 111void
108xdr_encode_pages(struct xdr_buf *xdr, struct page **pages, unsigned int base, 112xdr_encode_pages(struct xdr_buf *xdr, struct page **pages, unsigned int base,
@@ -130,6 +134,7 @@ xdr_encode_pages(struct xdr_buf *xdr, struct page **pages, unsigned int base,
130 xdr->buflen += len; 134 xdr->buflen += len;
131 xdr->len += len; 135 xdr->len += len;
132} 136}
137EXPORT_SYMBOL(xdr_encode_pages);
133 138
134void 139void
135xdr_inline_pages(struct xdr_buf *xdr, unsigned int offset, 140xdr_inline_pages(struct xdr_buf *xdr, unsigned int offset,
@@ -151,7 +156,7 @@ xdr_inline_pages(struct xdr_buf *xdr, unsigned int offset,
151 156
152 xdr->buflen += len; 157 xdr->buflen += len;
153} 158}
154 159EXPORT_SYMBOL(xdr_inline_pages);
155 160
156/* 161/*
157 * Helper routines for doing 'memmove' like operations on a struct xdr_buf 162 * Helper routines for doing 'memmove' like operations on a struct xdr_buf
@@ -418,6 +423,7 @@ xdr_shift_buf(struct xdr_buf *buf, size_t len)
418{ 423{
419 xdr_shrink_bufhead(buf, len); 424 xdr_shrink_bufhead(buf, len);
420} 425}
426EXPORT_SYMBOL(xdr_shift_buf);
421 427
422/** 428/**
423 * xdr_init_encode - Initialize a struct xdr_stream for sending data. 429 * xdr_init_encode - Initialize a struct xdr_stream for sending data.
@@ -639,6 +645,7 @@ xdr_buf_from_iov(struct kvec *iov, struct xdr_buf *buf)
639 buf->page_len = 0; 645 buf->page_len = 0;
640 buf->buflen = buf->len = iov->iov_len; 646 buf->buflen = buf->len = iov->iov_len;
641} 647}
648EXPORT_SYMBOL(xdr_buf_from_iov);
642 649
643/* Sets subbuf to the portion of buf of length len beginning base bytes 650/* Sets subbuf to the portion of buf of length len beginning base bytes
644 * from the start of buf. Returns -1 if base of length are out of bounds. */ 651 * from the start of buf. Returns -1 if base of length are out of bounds. */
@@ -687,6 +694,7 @@ xdr_buf_subsegment(struct xdr_buf *buf, struct xdr_buf *subbuf,
687 return -1; 694 return -1;
688 return 0; 695 return 0;
689} 696}
697EXPORT_SYMBOL(xdr_buf_subsegment);
690 698
691static void __read_bytes_from_xdr_buf(struct xdr_buf *subbuf, void *obj, unsigned int len) 699static void __read_bytes_from_xdr_buf(struct xdr_buf *subbuf, void *obj, unsigned int len)
692{ 700{
@@ -717,6 +725,7 @@ int read_bytes_from_xdr_buf(struct xdr_buf *buf, unsigned int base, void *obj, u
717 __read_bytes_from_xdr_buf(&subbuf, obj, len); 725 __read_bytes_from_xdr_buf(&subbuf, obj, len);
718 return 0; 726 return 0;
719} 727}
728EXPORT_SYMBOL(read_bytes_from_xdr_buf);
720 729
721static void __write_bytes_to_xdr_buf(struct xdr_buf *subbuf, void *obj, unsigned int len) 730static void __write_bytes_to_xdr_buf(struct xdr_buf *subbuf, void *obj, unsigned int len)
722{ 731{
@@ -760,6 +769,7 @@ xdr_decode_word(struct xdr_buf *buf, unsigned int base, u32 *obj)
760 *obj = ntohl(raw); 769 *obj = ntohl(raw);
761 return 0; 770 return 0;
762} 771}
772EXPORT_SYMBOL(xdr_decode_word);
763 773
764int 774int
765xdr_encode_word(struct xdr_buf *buf, unsigned int base, u32 obj) 775xdr_encode_word(struct xdr_buf *buf, unsigned int base, u32 obj)
@@ -768,6 +778,7 @@ xdr_encode_word(struct xdr_buf *buf, unsigned int base, u32 obj)
768 778
769 return write_bytes_to_xdr_buf(buf, base, &raw, sizeof(obj)); 779 return write_bytes_to_xdr_buf(buf, base, &raw, sizeof(obj));
770} 780}
781EXPORT_SYMBOL(xdr_encode_word);
771 782
772/* If the netobj starting offset bytes from the start of xdr_buf is contained 783/* If the netobj starting offset bytes from the start of xdr_buf is contained
773 * entirely in the head or the tail, set object to point to it; otherwise 784 * entirely in the head or the tail, set object to point to it; otherwise
@@ -805,6 +816,7 @@ int xdr_buf_read_netobj(struct xdr_buf *buf, struct xdr_netobj *obj, unsigned in
805 __read_bytes_from_xdr_buf(&subbuf, obj->data, obj->len); 816 __read_bytes_from_xdr_buf(&subbuf, obj->data, obj->len);
806 return 0; 817 return 0;
807} 818}
819EXPORT_SYMBOL(xdr_buf_read_netobj);
808 820
809/* Returns 0 on success, or else a negative error code. */ 821/* Returns 0 on success, or else a negative error code. */
810static int 822static int
@@ -1010,6 +1022,7 @@ xdr_decode_array2(struct xdr_buf *buf, unsigned int base,
1010 1022
1011 return xdr_xcode_array2(buf, base, desc, 0); 1023 return xdr_xcode_array2(buf, base, desc, 0);
1012} 1024}
1025EXPORT_SYMBOL(xdr_decode_array2);
1013 1026
1014int 1027int
1015xdr_encode_array2(struct xdr_buf *buf, unsigned int base, 1028xdr_encode_array2(struct xdr_buf *buf, unsigned int base,
@@ -1021,6 +1034,7 @@ xdr_encode_array2(struct xdr_buf *buf, unsigned int base,
1021 1034
1022 return xdr_xcode_array2(buf, base, desc, 1); 1035 return xdr_xcode_array2(buf, base, desc, 1);
1023} 1036}
1037EXPORT_SYMBOL(xdr_encode_array2);
1024 1038
1025int 1039int
1026xdr_process_buf(struct xdr_buf *buf, unsigned int offset, unsigned int len, 1040xdr_process_buf(struct xdr_buf *buf, unsigned int offset, unsigned int len,
diff --git a/net/sunrpc/xprt.c b/net/sunrpc/xprt.c
index fb92f51405c5..cfcade906a56 100644
--- a/net/sunrpc/xprt.c
+++ b/net/sunrpc/xprt.c
@@ -501,9 +501,10 @@ EXPORT_SYMBOL_GPL(xprt_set_retrans_timeout_def);
501void xprt_set_retrans_timeout_rtt(struct rpc_task *task) 501void xprt_set_retrans_timeout_rtt(struct rpc_task *task)
502{ 502{
503 int timer = task->tk_msg.rpc_proc->p_timer; 503 int timer = task->tk_msg.rpc_proc->p_timer;
504 struct rpc_rtt *rtt = task->tk_client->cl_rtt; 504 struct rpc_clnt *clnt = task->tk_client;
505 struct rpc_rtt *rtt = clnt->cl_rtt;
505 struct rpc_rqst *req = task->tk_rqstp; 506 struct rpc_rqst *req = task->tk_rqstp;
506 unsigned long max_timeout = req->rq_xprt->timeout.to_maxval; 507 unsigned long max_timeout = clnt->cl_timeout->to_maxval;
507 508
508 task->tk_timeout = rpc_calc_rto(rtt, timer); 509 task->tk_timeout = rpc_calc_rto(rtt, timer);
509 task->tk_timeout <<= rpc_ntimeo(rtt, timer) + req->rq_retries; 510 task->tk_timeout <<= rpc_ntimeo(rtt, timer) + req->rq_retries;
@@ -514,7 +515,7 @@ EXPORT_SYMBOL_GPL(xprt_set_retrans_timeout_rtt);
514 515
515static void xprt_reset_majortimeo(struct rpc_rqst *req) 516static void xprt_reset_majortimeo(struct rpc_rqst *req)
516{ 517{
517 struct rpc_timeout *to = &req->rq_xprt->timeout; 518 const struct rpc_timeout *to = req->rq_task->tk_client->cl_timeout;
518 519
519 req->rq_majortimeo = req->rq_timeout; 520 req->rq_majortimeo = req->rq_timeout;
520 if (to->to_exponential) 521 if (to->to_exponential)
@@ -534,7 +535,7 @@ static void xprt_reset_majortimeo(struct rpc_rqst *req)
534int xprt_adjust_timeout(struct rpc_rqst *req) 535int xprt_adjust_timeout(struct rpc_rqst *req)
535{ 536{
536 struct rpc_xprt *xprt = req->rq_xprt; 537 struct rpc_xprt *xprt = req->rq_xprt;
537 struct rpc_timeout *to = &xprt->timeout; 538 const struct rpc_timeout *to = req->rq_task->tk_client->cl_timeout;
538 int status = 0; 539 int status = 0;
539 540
540 if (time_before(jiffies, req->rq_majortimeo)) { 541 if (time_before(jiffies, req->rq_majortimeo)) {
@@ -568,17 +569,17 @@ static void xprt_autoclose(struct work_struct *work)
568 struct rpc_xprt *xprt = 569 struct rpc_xprt *xprt =
569 container_of(work, struct rpc_xprt, task_cleanup); 570 container_of(work, struct rpc_xprt, task_cleanup);
570 571
571 xprt_disconnect(xprt);
572 xprt->ops->close(xprt); 572 xprt->ops->close(xprt);
573 clear_bit(XPRT_CLOSE_WAIT, &xprt->state);
573 xprt_release_write(xprt, NULL); 574 xprt_release_write(xprt, NULL);
574} 575}
575 576
576/** 577/**
577 * xprt_disconnect - mark a transport as disconnected 578 * xprt_disconnect_done - mark a transport as disconnected
578 * @xprt: transport to flag for disconnect 579 * @xprt: transport to flag for disconnect
579 * 580 *
580 */ 581 */
581void xprt_disconnect(struct rpc_xprt *xprt) 582void xprt_disconnect_done(struct rpc_xprt *xprt)
582{ 583{
583 dprintk("RPC: disconnected transport %p\n", xprt); 584 dprintk("RPC: disconnected transport %p\n", xprt);
584 spin_lock_bh(&xprt->transport_lock); 585 spin_lock_bh(&xprt->transport_lock);
@@ -586,7 +587,26 @@ void xprt_disconnect(struct rpc_xprt *xprt)
586 xprt_wake_pending_tasks(xprt, -ENOTCONN); 587 xprt_wake_pending_tasks(xprt, -ENOTCONN);
587 spin_unlock_bh(&xprt->transport_lock); 588 spin_unlock_bh(&xprt->transport_lock);
588} 589}
589EXPORT_SYMBOL_GPL(xprt_disconnect); 590EXPORT_SYMBOL_GPL(xprt_disconnect_done);
591
592/**
593 * xprt_force_disconnect - force a transport to disconnect
594 * @xprt: transport to disconnect
595 *
596 */
597void xprt_force_disconnect(struct rpc_xprt *xprt)
598{
599 /* Don't race with the test_bit() in xprt_clear_locked() */
600 spin_lock_bh(&xprt->transport_lock);
601 set_bit(XPRT_CLOSE_WAIT, &xprt->state);
602 /* Try to schedule an autoclose RPC call */
603 if (test_and_set_bit(XPRT_LOCKED, &xprt->state) == 0)
604 queue_work(rpciod_workqueue, &xprt->task_cleanup);
605 else if (xprt->snd_task != NULL)
606 rpc_wake_up_task(xprt->snd_task);
607 spin_unlock_bh(&xprt->transport_lock);
608}
609EXPORT_SYMBOL_GPL(xprt_force_disconnect);
590 610
591static void 611static void
592xprt_init_autodisconnect(unsigned long data) 612xprt_init_autodisconnect(unsigned long data)
@@ -909,7 +929,7 @@ static void xprt_request_init(struct rpc_task *task, struct rpc_xprt *xprt)
909{ 929{
910 struct rpc_rqst *req = task->tk_rqstp; 930 struct rpc_rqst *req = task->tk_rqstp;
911 931
912 req->rq_timeout = xprt->timeout.to_initval; 932 req->rq_timeout = task->tk_client->cl_timeout->to_initval;
913 req->rq_task = task; 933 req->rq_task = task;
914 req->rq_xprt = xprt; 934 req->rq_xprt = xprt;
915 req->rq_buffer = NULL; 935 req->rq_buffer = NULL;
@@ -959,22 +979,6 @@ void xprt_release(struct rpc_task *task)
959} 979}
960 980
961/** 981/**
962 * xprt_set_timeout - set constant RPC timeout
963 * @to: RPC timeout parameters to set up
964 * @retr: number of retries
965 * @incr: amount of increase after each retry
966 *
967 */
968void xprt_set_timeout(struct rpc_timeout *to, unsigned int retr, unsigned long incr)
969{
970 to->to_initval =
971 to->to_increment = incr;
972 to->to_maxval = to->to_initval + (incr * retr);
973 to->to_retries = retr;
974 to->to_exponential = 0;
975}
976
977/**
978 * xprt_create_transport - create an RPC transport 982 * xprt_create_transport - create an RPC transport
979 * @args: rpc transport creation arguments 983 * @args: rpc transport creation arguments
980 * 984 *
diff --git a/net/sunrpc/xprtrdma/rpc_rdma.c b/net/sunrpc/xprtrdma/rpc_rdma.c
index 1aa1580cda6d..e55427f73dfe 100644
--- a/net/sunrpc/xprtrdma/rpc_rdma.c
+++ b/net/sunrpc/xprtrdma/rpc_rdma.c
@@ -83,7 +83,7 @@ static const char transfertypes[][12] = {
83 */ 83 */
84 84
85static int 85static int
86rpcrdma_convert_iovs(struct xdr_buf *xdrbuf, int pos, 86rpcrdma_convert_iovs(struct xdr_buf *xdrbuf, unsigned int pos,
87 enum rpcrdma_chunktype type, struct rpcrdma_mr_seg *seg, int nsegs) 87 enum rpcrdma_chunktype type, struct rpcrdma_mr_seg *seg, int nsegs)
88{ 88{
89 int len, n = 0, p; 89 int len, n = 0, p;
@@ -169,7 +169,7 @@ rpcrdma_create_chunks(struct rpc_rqst *rqst, struct xdr_buf *target,
169 struct rpcrdma_req *req = rpcr_to_rdmar(rqst); 169 struct rpcrdma_req *req = rpcr_to_rdmar(rqst);
170 struct rpcrdma_xprt *r_xprt = rpcx_to_rdmax(rqst->rq_task->tk_xprt); 170 struct rpcrdma_xprt *r_xprt = rpcx_to_rdmax(rqst->rq_task->tk_xprt);
171 int nsegs, nchunks = 0; 171 int nsegs, nchunks = 0;
172 int pos; 172 unsigned int pos;
173 struct rpcrdma_mr_seg *seg = req->rl_segments; 173 struct rpcrdma_mr_seg *seg = req->rl_segments;
174 struct rpcrdma_read_chunk *cur_rchunk = NULL; 174 struct rpcrdma_read_chunk *cur_rchunk = NULL;
175 struct rpcrdma_write_array *warray = NULL; 175 struct rpcrdma_write_array *warray = NULL;
@@ -213,7 +213,7 @@ rpcrdma_create_chunks(struct rpc_rqst *rqst, struct xdr_buf *target,
213 (__be32 *)&cur_rchunk->rc_target.rs_offset, 213 (__be32 *)&cur_rchunk->rc_target.rs_offset,
214 seg->mr_base); 214 seg->mr_base);
215 dprintk("RPC: %s: read chunk " 215 dprintk("RPC: %s: read chunk "
216 "elem %d@0x%llx:0x%x pos %d (%s)\n", __func__, 216 "elem %d@0x%llx:0x%x pos %u (%s)\n", __func__,
217 seg->mr_len, (unsigned long long)seg->mr_base, 217 seg->mr_len, (unsigned long long)seg->mr_base,
218 seg->mr_rkey, pos, n < nsegs ? "more" : "last"); 218 seg->mr_rkey, pos, n < nsegs ? "more" : "last");
219 cur_rchunk++; 219 cur_rchunk++;
@@ -552,7 +552,7 @@ rpcrdma_marshal_req(struct rpc_rqst *rqst)
552 * RDMA'd by server. See map at rpcrdma_create_chunks()! :-) 552 * RDMA'd by server. See map at rpcrdma_create_chunks()! :-)
553 */ 553 */
554static int 554static int
555rpcrdma_count_chunks(struct rpcrdma_rep *rep, int max, int wrchunk, __be32 **iptrp) 555rpcrdma_count_chunks(struct rpcrdma_rep *rep, unsigned int max, int wrchunk, __be32 **iptrp)
556{ 556{
557 unsigned int i, total_len; 557 unsigned int i, total_len;
558 struct rpcrdma_write_chunk *cur_wchunk; 558 struct rpcrdma_write_chunk *cur_wchunk;
diff --git a/net/sunrpc/xprtrdma/transport.c b/net/sunrpc/xprtrdma/transport.c
index 6f2112dd9f78..02c522c17de5 100644
--- a/net/sunrpc/xprtrdma/transport.c
+++ b/net/sunrpc/xprtrdma/transport.c
@@ -212,12 +212,16 @@ xprt_rdma_format_addresses(struct rpc_xprt *xprt)
212static void 212static void
213xprt_rdma_free_addresses(struct rpc_xprt *xprt) 213xprt_rdma_free_addresses(struct rpc_xprt *xprt)
214{ 214{
215 kfree(xprt->address_strings[RPC_DISPLAY_ADDR]); 215 unsigned int i;
216 kfree(xprt->address_strings[RPC_DISPLAY_PORT]); 216
217 kfree(xprt->address_strings[RPC_DISPLAY_ALL]); 217 for (i = 0; i < RPC_DISPLAY_MAX; i++)
218 kfree(xprt->address_strings[RPC_DISPLAY_HEX_ADDR]); 218 switch (i) {
219 kfree(xprt->address_strings[RPC_DISPLAY_HEX_PORT]); 219 case RPC_DISPLAY_PROTO:
220 kfree(xprt->address_strings[RPC_DISPLAY_UNIVERSAL_ADDR]); 220 case RPC_DISPLAY_NETID:
221 continue;
222 default:
223 kfree(xprt->address_strings[i]);
224 }
221} 225}
222 226
223static void 227static void
@@ -289,6 +293,11 @@ xprt_rdma_destroy(struct rpc_xprt *xprt)
289 module_put(THIS_MODULE); 293 module_put(THIS_MODULE);
290} 294}
291 295
296static const struct rpc_timeout xprt_rdma_default_timeout = {
297 .to_initval = 60 * HZ,
298 .to_maxval = 60 * HZ,
299};
300
292/** 301/**
293 * xprt_setup_rdma - Set up transport to use RDMA 302 * xprt_setup_rdma - Set up transport to use RDMA
294 * 303 *
@@ -327,7 +336,7 @@ xprt_setup_rdma(struct xprt_create *args)
327 } 336 }
328 337
329 /* 60 second timeout, no retries */ 338 /* 60 second timeout, no retries */
330 xprt_set_timeout(&xprt->timeout, 0, 60UL * HZ); 339 xprt->timeout = &xprt_rdma_default_timeout;
331 xprt->bind_timeout = (60U * HZ); 340 xprt->bind_timeout = (60U * HZ);
332 xprt->connect_timeout = (60U * HZ); 341 xprt->connect_timeout = (60U * HZ);
333 xprt->reestablish_timeout = (5U * HZ); 342 xprt->reestablish_timeout = (5U * HZ);
@@ -449,7 +458,7 @@ xprt_rdma_close(struct rpc_xprt *xprt)
449 struct rpcrdma_xprt *r_xprt = rpcx_to_rdmax(xprt); 458 struct rpcrdma_xprt *r_xprt = rpcx_to_rdmax(xprt);
450 459
451 dprintk("RPC: %s: closing\n", __func__); 460 dprintk("RPC: %s: closing\n", __func__);
452 xprt_disconnect(xprt); 461 xprt_disconnect_done(xprt);
453 (void) rpcrdma_ep_disconnect(&r_xprt->rx_ep, &r_xprt->rx_ia); 462 (void) rpcrdma_ep_disconnect(&r_xprt->rx_ep, &r_xprt->rx_ia);
454} 463}
455 464
@@ -682,7 +691,7 @@ xprt_rdma_send_request(struct rpc_task *task)
682 } 691 }
683 692
684 if (rpcrdma_ep_post(&r_xprt->rx_ia, &r_xprt->rx_ep, req)) { 693 if (rpcrdma_ep_post(&r_xprt->rx_ia, &r_xprt->rx_ep, req)) {
685 xprt_disconnect(xprt); 694 xprt_disconnect_done(xprt);
686 return -ENOTCONN; /* implies disconnect */ 695 return -ENOTCONN; /* implies disconnect */
687 } 696 }
688 697
diff --git a/net/sunrpc/xprtrdma/verbs.c b/net/sunrpc/xprtrdma/verbs.c
index 44b0fb942e8d..ffbf22a1d2ca 100644
--- a/net/sunrpc/xprtrdma/verbs.c
+++ b/net/sunrpc/xprtrdma/verbs.c
@@ -522,7 +522,7 @@ rpcrdma_ep_create(struct rpcrdma_ep *ep, struct rpcrdma_ia *ia,
522 struct rpcrdma_create_data_internal *cdata) 522 struct rpcrdma_create_data_internal *cdata)
523{ 523{
524 struct ib_device_attr devattr; 524 struct ib_device_attr devattr;
525 int rc; 525 int rc, err;
526 526
527 rc = ib_query_device(ia->ri_id->device, &devattr); 527 rc = ib_query_device(ia->ri_id->device, &devattr);
528 if (rc) { 528 if (rc) {
@@ -648,8 +648,10 @@ rpcrdma_ep_create(struct rpcrdma_ep *ep, struct rpcrdma_ia *ia,
648 return 0; 648 return 0;
649 649
650out2: 650out2:
651 if (ib_destroy_cq(ep->rep_cq)) 651 err = ib_destroy_cq(ep->rep_cq);
652 ; 652 if (err)
653 dprintk("RPC: %s: ib_destroy_cq returned %i\n",
654 __func__, err);
653out1: 655out1:
654 return rc; 656 return rc;
655} 657}
diff --git a/net/sunrpc/xprtsock.c b/net/sunrpc/xprtsock.c
index 6fa52f44de0f..30e7ac243a90 100644
--- a/net/sunrpc/xprtsock.c
+++ b/net/sunrpc/xprtsock.c
@@ -280,7 +280,9 @@ static inline struct sockaddr_in6 *xs_addr_in6(struct rpc_xprt *xprt)
280 return (struct sockaddr_in6 *) &xprt->addr; 280 return (struct sockaddr_in6 *) &xprt->addr;
281} 281}
282 282
283static void xs_format_ipv4_peer_addresses(struct rpc_xprt *xprt) 283static void xs_format_ipv4_peer_addresses(struct rpc_xprt *xprt,
284 const char *protocol,
285 const char *netid)
284{ 286{
285 struct sockaddr_in *addr = xs_addr_in(xprt); 287 struct sockaddr_in *addr = xs_addr_in(xprt);
286 char *buf; 288 char *buf;
@@ -299,21 +301,14 @@ static void xs_format_ipv4_peer_addresses(struct rpc_xprt *xprt)
299 } 301 }
300 xprt->address_strings[RPC_DISPLAY_PORT] = buf; 302 xprt->address_strings[RPC_DISPLAY_PORT] = buf;
301 303
302 buf = kzalloc(8, GFP_KERNEL); 304 xprt->address_strings[RPC_DISPLAY_PROTO] = protocol;
303 if (buf) {
304 if (xprt->prot == IPPROTO_UDP)
305 snprintf(buf, 8, "udp");
306 else
307 snprintf(buf, 8, "tcp");
308 }
309 xprt->address_strings[RPC_DISPLAY_PROTO] = buf;
310 305
311 buf = kzalloc(48, GFP_KERNEL); 306 buf = kzalloc(48, GFP_KERNEL);
312 if (buf) { 307 if (buf) {
313 snprintf(buf, 48, "addr="NIPQUAD_FMT" port=%u proto=%s", 308 snprintf(buf, 48, "addr="NIPQUAD_FMT" port=%u proto=%s",
314 NIPQUAD(addr->sin_addr.s_addr), 309 NIPQUAD(addr->sin_addr.s_addr),
315 ntohs(addr->sin_port), 310 ntohs(addr->sin_port),
316 xprt->prot == IPPROTO_UDP ? "udp" : "tcp"); 311 protocol);
317 } 312 }
318 xprt->address_strings[RPC_DISPLAY_ALL] = buf; 313 xprt->address_strings[RPC_DISPLAY_ALL] = buf;
319 314
@@ -340,12 +335,12 @@ static void xs_format_ipv4_peer_addresses(struct rpc_xprt *xprt)
340 } 335 }
341 xprt->address_strings[RPC_DISPLAY_UNIVERSAL_ADDR] = buf; 336 xprt->address_strings[RPC_DISPLAY_UNIVERSAL_ADDR] = buf;
342 337
343 xprt->address_strings[RPC_DISPLAY_NETID] = 338 xprt->address_strings[RPC_DISPLAY_NETID] = netid;
344 kstrdup(xprt->prot == IPPROTO_UDP ?
345 RPCBIND_NETID_UDP : RPCBIND_NETID_TCP, GFP_KERNEL);
346} 339}
347 340
348static void xs_format_ipv6_peer_addresses(struct rpc_xprt *xprt) 341static void xs_format_ipv6_peer_addresses(struct rpc_xprt *xprt,
342 const char *protocol,
343 const char *netid)
349{ 344{
350 struct sockaddr_in6 *addr = xs_addr_in6(xprt); 345 struct sockaddr_in6 *addr = xs_addr_in6(xprt);
351 char *buf; 346 char *buf;
@@ -364,21 +359,14 @@ static void xs_format_ipv6_peer_addresses(struct rpc_xprt *xprt)
364 } 359 }
365 xprt->address_strings[RPC_DISPLAY_PORT] = buf; 360 xprt->address_strings[RPC_DISPLAY_PORT] = buf;
366 361
367 buf = kzalloc(8, GFP_KERNEL); 362 xprt->address_strings[RPC_DISPLAY_PROTO] = protocol;
368 if (buf) {
369 if (xprt->prot == IPPROTO_UDP)
370 snprintf(buf, 8, "udp");
371 else
372 snprintf(buf, 8, "tcp");
373 }
374 xprt->address_strings[RPC_DISPLAY_PROTO] = buf;
375 363
376 buf = kzalloc(64, GFP_KERNEL); 364 buf = kzalloc(64, GFP_KERNEL);
377 if (buf) { 365 if (buf) {
378 snprintf(buf, 64, "addr="NIP6_FMT" port=%u proto=%s", 366 snprintf(buf, 64, "addr="NIP6_FMT" port=%u proto=%s",
379 NIP6(addr->sin6_addr), 367 NIP6(addr->sin6_addr),
380 ntohs(addr->sin6_port), 368 ntohs(addr->sin6_port),
381 xprt->prot == IPPROTO_UDP ? "udp" : "tcp"); 369 protocol);
382 } 370 }
383 xprt->address_strings[RPC_DISPLAY_ALL] = buf; 371 xprt->address_strings[RPC_DISPLAY_ALL] = buf;
384 372
@@ -405,17 +393,21 @@ static void xs_format_ipv6_peer_addresses(struct rpc_xprt *xprt)
405 } 393 }
406 xprt->address_strings[RPC_DISPLAY_UNIVERSAL_ADDR] = buf; 394 xprt->address_strings[RPC_DISPLAY_UNIVERSAL_ADDR] = buf;
407 395
408 xprt->address_strings[RPC_DISPLAY_NETID] = 396 xprt->address_strings[RPC_DISPLAY_NETID] = netid;
409 kstrdup(xprt->prot == IPPROTO_UDP ?
410 RPCBIND_NETID_UDP6 : RPCBIND_NETID_TCP6, GFP_KERNEL);
411} 397}
412 398
413static void xs_free_peer_addresses(struct rpc_xprt *xprt) 399static void xs_free_peer_addresses(struct rpc_xprt *xprt)
414{ 400{
415 int i; 401 unsigned int i;
416 402
417 for (i = 0; i < RPC_DISPLAY_MAX; i++) 403 for (i = 0; i < RPC_DISPLAY_MAX; i++)
418 kfree(xprt->address_strings[i]); 404 switch (i) {
405 case RPC_DISPLAY_PROTO:
406 case RPC_DISPLAY_NETID:
407 continue;
408 default:
409 kfree(xprt->address_strings[i]);
410 }
419} 411}
420 412
421#define XS_SENDMSG_FLAGS (MSG_DONTWAIT | MSG_NOSIGNAL) 413#define XS_SENDMSG_FLAGS (MSG_DONTWAIT | MSG_NOSIGNAL)
@@ -614,6 +606,22 @@ static int xs_udp_send_request(struct rpc_task *task)
614 return status; 606 return status;
615} 607}
616 608
609/**
610 * xs_tcp_shutdown - gracefully shut down a TCP socket
611 * @xprt: transport
612 *
613 * Initiates a graceful shutdown of the TCP socket by calling the
614 * equivalent of shutdown(SHUT_WR);
615 */
616static void xs_tcp_shutdown(struct rpc_xprt *xprt)
617{
618 struct sock_xprt *transport = container_of(xprt, struct sock_xprt, xprt);
619 struct socket *sock = transport->sock;
620
621 if (sock != NULL)
622 kernel_sock_shutdown(sock, SHUT_WR);
623}
624
617static inline void xs_encode_tcp_record_marker(struct xdr_buf *buf) 625static inline void xs_encode_tcp_record_marker(struct xdr_buf *buf)
618{ 626{
619 u32 reclen = buf->len - sizeof(rpc_fraghdr); 627 u32 reclen = buf->len - sizeof(rpc_fraghdr);
@@ -691,7 +699,7 @@ static int xs_tcp_send_request(struct rpc_task *task)
691 default: 699 default:
692 dprintk("RPC: sendmsg returned unrecognized error %d\n", 700 dprintk("RPC: sendmsg returned unrecognized error %d\n",
693 -status); 701 -status);
694 xprt_disconnect(xprt); 702 xs_tcp_shutdown(xprt);
695 break; 703 break;
696 } 704 }
697 705
@@ -759,7 +767,9 @@ static void xs_close(struct rpc_xprt *xprt)
759clear_close_wait: 767clear_close_wait:
760 smp_mb__before_clear_bit(); 768 smp_mb__before_clear_bit();
761 clear_bit(XPRT_CLOSE_WAIT, &xprt->state); 769 clear_bit(XPRT_CLOSE_WAIT, &xprt->state);
770 clear_bit(XPRT_CLOSING, &xprt->state);
762 smp_mb__after_clear_bit(); 771 smp_mb__after_clear_bit();
772 xprt_disconnect_done(xprt);
763} 773}
764 774
765/** 775/**
@@ -775,7 +785,6 @@ static void xs_destroy(struct rpc_xprt *xprt)
775 785
776 cancel_rearming_delayed_work(&transport->connect_worker); 786 cancel_rearming_delayed_work(&transport->connect_worker);
777 787
778 xprt_disconnect(xprt);
779 xs_close(xprt); 788 xs_close(xprt);
780 xs_free_peer_addresses(xprt); 789 xs_free_peer_addresses(xprt);
781 kfree(xprt->slot); 790 kfree(xprt->slot);
@@ -886,7 +895,7 @@ static inline void xs_tcp_read_fraghdr(struct rpc_xprt *xprt, struct xdr_skb_rea
886 /* Sanity check of the record length */ 895 /* Sanity check of the record length */
887 if (unlikely(transport->tcp_reclen < 4)) { 896 if (unlikely(transport->tcp_reclen < 4)) {
888 dprintk("RPC: invalid TCP record fragment length\n"); 897 dprintk("RPC: invalid TCP record fragment length\n");
889 xprt_disconnect(xprt); 898 xprt_force_disconnect(xprt);
890 return; 899 return;
891 } 900 }
892 dprintk("RPC: reading TCP record fragment of length %d\n", 901 dprintk("RPC: reading TCP record fragment of length %d\n",
@@ -1113,21 +1122,44 @@ static void xs_tcp_state_change(struct sock *sk)
1113 transport->tcp_flags = 1122 transport->tcp_flags =
1114 TCP_RCV_COPY_FRAGHDR | TCP_RCV_COPY_XID; 1123 TCP_RCV_COPY_FRAGHDR | TCP_RCV_COPY_XID;
1115 1124
1116 xprt->reestablish_timeout = XS_TCP_INIT_REEST_TO;
1117 xprt_wake_pending_tasks(xprt, 0); 1125 xprt_wake_pending_tasks(xprt, 0);
1118 } 1126 }
1119 spin_unlock_bh(&xprt->transport_lock); 1127 spin_unlock_bh(&xprt->transport_lock);
1120 break; 1128 break;
1121 case TCP_SYN_SENT: 1129 case TCP_FIN_WAIT1:
1122 case TCP_SYN_RECV: 1130 /* The client initiated a shutdown of the socket */
1131 xprt->reestablish_timeout = 0;
1132 set_bit(XPRT_CLOSING, &xprt->state);
1133 smp_mb__before_clear_bit();
1134 clear_bit(XPRT_CONNECTED, &xprt->state);
1135 clear_bit(XPRT_CLOSE_WAIT, &xprt->state);
1136 smp_mb__after_clear_bit();
1123 break; 1137 break;
1124 case TCP_CLOSE_WAIT: 1138 case TCP_CLOSE_WAIT:
1125 /* Try to schedule an autoclose RPC calls */ 1139 /* The server initiated a shutdown of the socket */
1126 set_bit(XPRT_CLOSE_WAIT, &xprt->state); 1140 set_bit(XPRT_CLOSING, &xprt->state);
1127 if (test_and_set_bit(XPRT_LOCKED, &xprt->state) == 0) 1141 xprt_force_disconnect(xprt);
1128 queue_work(rpciod_workqueue, &xprt->task_cleanup); 1142 case TCP_SYN_SENT:
1129 default: 1143 case TCP_CLOSING:
1130 xprt_disconnect(xprt); 1144 /*
1145 * If the server closed down the connection, make sure that
1146 * we back off before reconnecting
1147 */
1148 if (xprt->reestablish_timeout < XS_TCP_INIT_REEST_TO)
1149 xprt->reestablish_timeout = XS_TCP_INIT_REEST_TO;
1150 break;
1151 case TCP_LAST_ACK:
1152 smp_mb__before_clear_bit();
1153 clear_bit(XPRT_CONNECTED, &xprt->state);
1154 smp_mb__after_clear_bit();
1155 break;
1156 case TCP_CLOSE:
1157 smp_mb__before_clear_bit();
1158 clear_bit(XPRT_CLOSE_WAIT, &xprt->state);
1159 clear_bit(XPRT_CLOSING, &xprt->state);
1160 smp_mb__after_clear_bit();
1161 /* Mark transport as closed and wake up all pending tasks */
1162 xprt_disconnect_done(xprt);
1131 } 1163 }
1132 out: 1164 out:
1133 read_unlock(&sk->sk_callback_lock); 1165 read_unlock(&sk->sk_callback_lock);
@@ -1279,34 +1311,53 @@ static void xs_set_port(struct rpc_xprt *xprt, unsigned short port)
1279 } 1311 }
1280} 1312}
1281 1313
1314static unsigned short xs_get_srcport(struct sock_xprt *transport, struct socket *sock)
1315{
1316 unsigned short port = transport->port;
1317
1318 if (port == 0 && transport->xprt.resvport)
1319 port = xs_get_random_port();
1320 return port;
1321}
1322
1323static unsigned short xs_next_srcport(struct sock_xprt *transport, struct socket *sock, unsigned short port)
1324{
1325 if (transport->port != 0)
1326 transport->port = 0;
1327 if (!transport->xprt.resvport)
1328 return 0;
1329 if (port <= xprt_min_resvport || port > xprt_max_resvport)
1330 return xprt_max_resvport;
1331 return --port;
1332}
1333
1282static int xs_bind4(struct sock_xprt *transport, struct socket *sock) 1334static int xs_bind4(struct sock_xprt *transport, struct socket *sock)
1283{ 1335{
1284 struct sockaddr_in myaddr = { 1336 struct sockaddr_in myaddr = {
1285 .sin_family = AF_INET, 1337 .sin_family = AF_INET,
1286 }; 1338 };
1287 struct sockaddr_in *sa; 1339 struct sockaddr_in *sa;
1288 int err; 1340 int err, nloop = 0;
1289 unsigned short port = transport->port; 1341 unsigned short port = xs_get_srcport(transport, sock);
1342 unsigned short last;
1290 1343
1291 if (!transport->xprt.resvport)
1292 port = 0;
1293 sa = (struct sockaddr_in *)&transport->addr; 1344 sa = (struct sockaddr_in *)&transport->addr;
1294 myaddr.sin_addr = sa->sin_addr; 1345 myaddr.sin_addr = sa->sin_addr;
1295 do { 1346 do {
1296 myaddr.sin_port = htons(port); 1347 myaddr.sin_port = htons(port);
1297 err = kernel_bind(sock, (struct sockaddr *) &myaddr, 1348 err = kernel_bind(sock, (struct sockaddr *) &myaddr,
1298 sizeof(myaddr)); 1349 sizeof(myaddr));
1299 if (!transport->xprt.resvport) 1350 if (port == 0)
1300 break; 1351 break;
1301 if (err == 0) { 1352 if (err == 0) {
1302 transport->port = port; 1353 transport->port = port;
1303 break; 1354 break;
1304 } 1355 }
1305 if (port <= xprt_min_resvport) 1356 last = port;
1306 port = xprt_max_resvport; 1357 port = xs_next_srcport(transport, sock, port);
1307 else 1358 if (port > last)
1308 port--; 1359 nloop++;
1309 } while (err == -EADDRINUSE && port != transport->port); 1360 } while (err == -EADDRINUSE && nloop != 2);
1310 dprintk("RPC: %s "NIPQUAD_FMT":%u: %s (%d)\n", 1361 dprintk("RPC: %s "NIPQUAD_FMT":%u: %s (%d)\n",
1311 __FUNCTION__, NIPQUAD(myaddr.sin_addr), 1362 __FUNCTION__, NIPQUAD(myaddr.sin_addr),
1312 port, err ? "failed" : "ok", err); 1363 port, err ? "failed" : "ok", err);
@@ -1319,28 +1370,27 @@ static int xs_bind6(struct sock_xprt *transport, struct socket *sock)
1319 .sin6_family = AF_INET6, 1370 .sin6_family = AF_INET6,
1320 }; 1371 };
1321 struct sockaddr_in6 *sa; 1372 struct sockaddr_in6 *sa;
1322 int err; 1373 int err, nloop = 0;
1323 unsigned short port = transport->port; 1374 unsigned short port = xs_get_srcport(transport, sock);
1375 unsigned short last;
1324 1376
1325 if (!transport->xprt.resvport)
1326 port = 0;
1327 sa = (struct sockaddr_in6 *)&transport->addr; 1377 sa = (struct sockaddr_in6 *)&transport->addr;
1328 myaddr.sin6_addr = sa->sin6_addr; 1378 myaddr.sin6_addr = sa->sin6_addr;
1329 do { 1379 do {
1330 myaddr.sin6_port = htons(port); 1380 myaddr.sin6_port = htons(port);
1331 err = kernel_bind(sock, (struct sockaddr *) &myaddr, 1381 err = kernel_bind(sock, (struct sockaddr *) &myaddr,
1332 sizeof(myaddr)); 1382 sizeof(myaddr));
1333 if (!transport->xprt.resvport) 1383 if (port == 0)
1334 break; 1384 break;
1335 if (err == 0) { 1385 if (err == 0) {
1336 transport->port = port; 1386 transport->port = port;
1337 break; 1387 break;
1338 } 1388 }
1339 if (port <= xprt_min_resvport) 1389 last = port;
1340 port = xprt_max_resvport; 1390 port = xs_next_srcport(transport, sock, port);
1341 else 1391 if (port > last)
1342 port--; 1392 nloop++;
1343 } while (err == -EADDRINUSE && port != transport->port); 1393 } while (err == -EADDRINUSE && nloop != 2);
1344 dprintk("RPC: xs_bind6 "NIP6_FMT":%u: %s (%d)\n", 1394 dprintk("RPC: xs_bind6 "NIP6_FMT":%u: %s (%d)\n",
1345 NIP6(myaddr.sin6_addr), port, err ? "failed" : "ok", err); 1395 NIP6(myaddr.sin6_addr), port, err ? "failed" : "ok", err);
1346 return err; 1396 return err;
@@ -1602,8 +1652,7 @@ static void xs_tcp_connect_worker4(struct work_struct *work)
1602 break; 1652 break;
1603 default: 1653 default:
1604 /* get rid of existing socket, and retry */ 1654 /* get rid of existing socket, and retry */
1605 xs_close(xprt); 1655 xs_tcp_shutdown(xprt);
1606 break;
1607 } 1656 }
1608 } 1657 }
1609out: 1658out:
@@ -1662,8 +1711,7 @@ static void xs_tcp_connect_worker6(struct work_struct *work)
1662 break; 1711 break;
1663 default: 1712 default:
1664 /* get rid of existing socket, and retry */ 1713 /* get rid of existing socket, and retry */
1665 xs_close(xprt); 1714 xs_tcp_shutdown(xprt);
1666 break;
1667 } 1715 }
1668 } 1716 }
1669out: 1717out:
@@ -1710,6 +1758,19 @@ static void xs_connect(struct rpc_task *task)
1710 } 1758 }
1711} 1759}
1712 1760
1761static void xs_tcp_connect(struct rpc_task *task)
1762{
1763 struct rpc_xprt *xprt = task->tk_xprt;
1764
1765 /* Initiate graceful shutdown of the socket if not already done */
1766 if (test_bit(XPRT_CONNECTED, &xprt->state))
1767 xs_tcp_shutdown(xprt);
1768 /* Exit if we need to wait for socket shutdown to complete */
1769 if (test_bit(XPRT_CLOSING, &xprt->state))
1770 return;
1771 xs_connect(task);
1772}
1773
1713/** 1774/**
1714 * xs_udp_print_stats - display UDP socket-specifc stats 1775 * xs_udp_print_stats - display UDP socket-specifc stats
1715 * @xprt: rpc_xprt struct containing statistics 1776 * @xprt: rpc_xprt struct containing statistics
@@ -1780,12 +1841,12 @@ static struct rpc_xprt_ops xs_tcp_ops = {
1780 .release_xprt = xs_tcp_release_xprt, 1841 .release_xprt = xs_tcp_release_xprt,
1781 .rpcbind = rpcb_getport_async, 1842 .rpcbind = rpcb_getport_async,
1782 .set_port = xs_set_port, 1843 .set_port = xs_set_port,
1783 .connect = xs_connect, 1844 .connect = xs_tcp_connect,
1784 .buf_alloc = rpc_malloc, 1845 .buf_alloc = rpc_malloc,
1785 .buf_free = rpc_free, 1846 .buf_free = rpc_free,
1786 .send_request = xs_tcp_send_request, 1847 .send_request = xs_tcp_send_request,
1787 .set_retrans_timeout = xprt_set_retrans_timeout_def, 1848 .set_retrans_timeout = xprt_set_retrans_timeout_def,
1788 .close = xs_close, 1849 .close = xs_tcp_shutdown,
1789 .destroy = xs_destroy, 1850 .destroy = xs_destroy,
1790 .print_stats = xs_tcp_print_stats, 1851 .print_stats = xs_tcp_print_stats,
1791}; 1852};
@@ -1822,11 +1883,17 @@ static struct rpc_xprt *xs_setup_xprt(struct xprt_create *args,
1822 xprt->addrlen = args->addrlen; 1883 xprt->addrlen = args->addrlen;
1823 if (args->srcaddr) 1884 if (args->srcaddr)
1824 memcpy(&new->addr, args->srcaddr, args->addrlen); 1885 memcpy(&new->addr, args->srcaddr, args->addrlen);
1825 new->port = xs_get_random_port();
1826 1886
1827 return xprt; 1887 return xprt;
1828} 1888}
1829 1889
1890static const struct rpc_timeout xs_udp_default_timeout = {
1891 .to_initval = 5 * HZ,
1892 .to_maxval = 30 * HZ,
1893 .to_increment = 5 * HZ,
1894 .to_retries = 5,
1895};
1896
1830/** 1897/**
1831 * xs_setup_udp - Set up transport to use a UDP socket 1898 * xs_setup_udp - Set up transport to use a UDP socket
1832 * @args: rpc transport creation arguments 1899 * @args: rpc transport creation arguments
@@ -1855,10 +1922,7 @@ static struct rpc_xprt *xs_setup_udp(struct xprt_create *args)
1855 1922
1856 xprt->ops = &xs_udp_ops; 1923 xprt->ops = &xs_udp_ops;
1857 1924
1858 if (args->timeout) 1925 xprt->timeout = &xs_udp_default_timeout;
1859 xprt->timeout = *args->timeout;
1860 else
1861 xprt_set_timeout(&xprt->timeout, 5, 5 * HZ);
1862 1926
1863 switch (addr->sa_family) { 1927 switch (addr->sa_family) {
1864 case AF_INET: 1928 case AF_INET:
@@ -1867,7 +1931,7 @@ static struct rpc_xprt *xs_setup_udp(struct xprt_create *args)
1867 1931
1868 INIT_DELAYED_WORK(&transport->connect_worker, 1932 INIT_DELAYED_WORK(&transport->connect_worker,
1869 xs_udp_connect_worker4); 1933 xs_udp_connect_worker4);
1870 xs_format_ipv4_peer_addresses(xprt); 1934 xs_format_ipv4_peer_addresses(xprt, "udp", RPCBIND_NETID_UDP);
1871 break; 1935 break;
1872 case AF_INET6: 1936 case AF_INET6:
1873 if (((struct sockaddr_in6 *)addr)->sin6_port != htons(0)) 1937 if (((struct sockaddr_in6 *)addr)->sin6_port != htons(0))
@@ -1875,7 +1939,7 @@ static struct rpc_xprt *xs_setup_udp(struct xprt_create *args)
1875 1939
1876 INIT_DELAYED_WORK(&transport->connect_worker, 1940 INIT_DELAYED_WORK(&transport->connect_worker,
1877 xs_udp_connect_worker6); 1941 xs_udp_connect_worker6);
1878 xs_format_ipv6_peer_addresses(xprt); 1942 xs_format_ipv6_peer_addresses(xprt, "udp", RPCBIND_NETID_UDP6);
1879 break; 1943 break;
1880 default: 1944 default:
1881 kfree(xprt); 1945 kfree(xprt);
@@ -1893,6 +1957,12 @@ static struct rpc_xprt *xs_setup_udp(struct xprt_create *args)
1893 return ERR_PTR(-EINVAL); 1957 return ERR_PTR(-EINVAL);
1894} 1958}
1895 1959
1960static const struct rpc_timeout xs_tcp_default_timeout = {
1961 .to_initval = 60 * HZ,
1962 .to_maxval = 60 * HZ,
1963 .to_retries = 2,
1964};
1965
1896/** 1966/**
1897 * xs_setup_tcp - Set up transport to use a TCP socket 1967 * xs_setup_tcp - Set up transport to use a TCP socket
1898 * @args: rpc transport creation arguments 1968 * @args: rpc transport creation arguments
@@ -1919,11 +1989,7 @@ static struct rpc_xprt *xs_setup_tcp(struct xprt_create *args)
1919 xprt->idle_timeout = XS_IDLE_DISC_TO; 1989 xprt->idle_timeout = XS_IDLE_DISC_TO;
1920 1990
1921 xprt->ops = &xs_tcp_ops; 1991 xprt->ops = &xs_tcp_ops;
1922 1992 xprt->timeout = &xs_tcp_default_timeout;
1923 if (args->timeout)
1924 xprt->timeout = *args->timeout;
1925 else
1926 xprt_set_timeout(&xprt->timeout, 2, 60 * HZ);
1927 1993
1928 switch (addr->sa_family) { 1994 switch (addr->sa_family) {
1929 case AF_INET: 1995 case AF_INET:
@@ -1931,14 +1997,14 @@ static struct rpc_xprt *xs_setup_tcp(struct xprt_create *args)
1931 xprt_set_bound(xprt); 1997 xprt_set_bound(xprt);
1932 1998
1933 INIT_DELAYED_WORK(&transport->connect_worker, xs_tcp_connect_worker4); 1999 INIT_DELAYED_WORK(&transport->connect_worker, xs_tcp_connect_worker4);
1934 xs_format_ipv4_peer_addresses(xprt); 2000 xs_format_ipv4_peer_addresses(xprt, "tcp", RPCBIND_NETID_TCP);
1935 break; 2001 break;
1936 case AF_INET6: 2002 case AF_INET6:
1937 if (((struct sockaddr_in6 *)addr)->sin6_port != htons(0)) 2003 if (((struct sockaddr_in6 *)addr)->sin6_port != htons(0))
1938 xprt_set_bound(xprt); 2004 xprt_set_bound(xprt);
1939 2005
1940 INIT_DELAYED_WORK(&transport->connect_worker, xs_tcp_connect_worker6); 2006 INIT_DELAYED_WORK(&transport->connect_worker, xs_tcp_connect_worker6);
1941 xs_format_ipv6_peer_addresses(xprt); 2007 xs_format_ipv6_peer_addresses(xprt, "tcp", RPCBIND_NETID_TCP6);
1942 break; 2008 break;
1943 default: 2009 default:
1944 kfree(xprt); 2010 kfree(xprt);
generated by cgit v1.2.2 (git 2.25.0) at 2025-09-11 11:08:32 -0400