aboutsummaryrefslogtreecommitdiffstats
path: root/net/sunrpc
diff options
context:
space:
mode:
Diffstat (limited to 'net/sunrpc')
-rw-r--r--net/sunrpc/auth.c25
-rw-r--r--net/sunrpc/auth_gss/auth_gss.c52
-rw-r--r--net/sunrpc/auth_gss/gss_krb5_crypto.c10
-rw-r--r--net/sunrpc/auth_gss/gss_krb5_mech.c3
-rw-r--r--net/sunrpc/auth_gss/gss_krb5_seal.c2
-rw-r--r--net/sunrpc/auth_gss/gss_krb5_seqnum.c2
-rw-r--r--net/sunrpc/auth_gss/gss_krb5_unseal.c2
-rw-r--r--net/sunrpc/auth_gss/gss_krb5_wrap.c4
-rw-r--r--net/sunrpc/auth_gss/gss_mech_switch.c6
-rw-r--r--net/sunrpc/auth_gss/gss_spkm3_mech.c9
-rw-r--r--net/sunrpc/auth_gss/gss_spkm3_seal.c14
-rw-r--r--net/sunrpc/auth_gss/gss_spkm3_token.c14
-rw-r--r--net/sunrpc/auth_gss/gss_spkm3_unseal.c9
-rw-r--r--net/sunrpc/auth_gss/svcauth_gss.c11
-rw-r--r--net/sunrpc/auth_unix.c9
-rw-r--r--net/sunrpc/cache.c3
-rw-r--r--net/sunrpc/clnt.c145
-rw-r--r--net/sunrpc/pmap_clnt.c26
-rw-r--r--net/sunrpc/rpc_pipe.c2
-rw-r--r--net/sunrpc/sched.c78
-rw-r--r--net/sunrpc/stats.c6
-rw-r--r--net/sunrpc/svc.c6
-rw-r--r--net/sunrpc/xprt.c67
-rw-r--r--net/sunrpc/xprtsock.c107
24 files changed, 330 insertions, 282 deletions
diff --git a/net/sunrpc/auth.c b/net/sunrpc/auth.c
index 76f7eac4082d..9527f2bb1744 100644
--- a/net/sunrpc/auth.c
+++ b/net/sunrpc/auth.c
@@ -181,7 +181,7 @@ rpcauth_gc_credcache(struct rpc_auth *auth, struct hlist_head *free)
181 struct rpc_cred *cred; 181 struct rpc_cred *cred;
182 int i; 182 int i;
183 183
184 dprintk("RPC: gc'ing RPC credentials for auth %p\n", auth); 184 dprintk("RPC: gc'ing RPC credentials for auth %p\n", auth);
185 for (i = 0; i < RPC_CREDCACHE_NR; i++) { 185 for (i = 0; i < RPC_CREDCACHE_NR; i++) {
186 hlist_for_each_safe(pos, next, &cache->hashtable[i]) { 186 hlist_for_each_safe(pos, next, &cache->hashtable[i]) {
187 cred = hlist_entry(pos, struct rpc_cred, cr_hash); 187 cred = hlist_entry(pos, struct rpc_cred, cr_hash);
@@ -267,7 +267,7 @@ rpcauth_lookupcred(struct rpc_auth *auth, int flags)
267 }; 267 };
268 struct rpc_cred *ret; 268 struct rpc_cred *ret;
269 269
270 dprintk("RPC: looking up %s cred\n", 270 dprintk("RPC: looking up %s cred\n",
271 auth->au_ops->au_name); 271 auth->au_ops->au_name);
272 get_group_info(acred.group_info); 272 get_group_info(acred.group_info);
273 ret = auth->au_ops->lookup_cred(auth, &acred, flags); 273 ret = auth->au_ops->lookup_cred(auth, &acred, flags);
@@ -287,7 +287,7 @@ rpcauth_bindcred(struct rpc_task *task)
287 struct rpc_cred *ret; 287 struct rpc_cred *ret;
288 int flags = 0; 288 int flags = 0;
289 289
290 dprintk("RPC: %4d looking up %s cred\n", 290 dprintk("RPC: %5u looking up %s cred\n",
291 task->tk_pid, task->tk_auth->au_ops->au_name); 291 task->tk_pid, task->tk_auth->au_ops->au_name);
292 get_group_info(acred.group_info); 292 get_group_info(acred.group_info);
293 if (task->tk_flags & RPC_TASK_ROOTCREDS) 293 if (task->tk_flags & RPC_TASK_ROOTCREDS)
@@ -304,8 +304,9 @@ rpcauth_bindcred(struct rpc_task *task)
304void 304void
305rpcauth_holdcred(struct rpc_task *task) 305rpcauth_holdcred(struct rpc_task *task)
306{ 306{
307 dprintk("RPC: %4d holding %s cred %p\n", 307 dprintk("RPC: %5u holding %s cred %p\n",
308 task->tk_pid, task->tk_auth->au_ops->au_name, task->tk_msg.rpc_cred); 308 task->tk_pid, task->tk_auth->au_ops->au_name,
309 task->tk_msg.rpc_cred);
309 if (task->tk_msg.rpc_cred) 310 if (task->tk_msg.rpc_cred)
310 get_rpccred(task->tk_msg.rpc_cred); 311 get_rpccred(task->tk_msg.rpc_cred);
311} 312}
@@ -324,7 +325,7 @@ rpcauth_unbindcred(struct rpc_task *task)
324{ 325{
325 struct rpc_cred *cred = task->tk_msg.rpc_cred; 326 struct rpc_cred *cred = task->tk_msg.rpc_cred;
326 327
327 dprintk("RPC: %4d releasing %s cred %p\n", 328 dprintk("RPC: %5u releasing %s cred %p\n",
328 task->tk_pid, task->tk_auth->au_ops->au_name, cred); 329 task->tk_pid, task->tk_auth->au_ops->au_name, cred);
329 330
330 put_rpccred(cred); 331 put_rpccred(cred);
@@ -336,7 +337,7 @@ rpcauth_marshcred(struct rpc_task *task, __be32 *p)
336{ 337{
337 struct rpc_cred *cred = task->tk_msg.rpc_cred; 338 struct rpc_cred *cred = task->tk_msg.rpc_cred;
338 339
339 dprintk("RPC: %4d marshaling %s cred %p\n", 340 dprintk("RPC: %5u marshaling %s cred %p\n",
340 task->tk_pid, task->tk_auth->au_ops->au_name, cred); 341 task->tk_pid, task->tk_auth->au_ops->au_name, cred);
341 342
342 return cred->cr_ops->crmarshal(task, p); 343 return cred->cr_ops->crmarshal(task, p);
@@ -347,7 +348,7 @@ rpcauth_checkverf(struct rpc_task *task, __be32 *p)
347{ 348{
348 struct rpc_cred *cred = task->tk_msg.rpc_cred; 349 struct rpc_cred *cred = task->tk_msg.rpc_cred;
349 350
350 dprintk("RPC: %4d validating %s cred %p\n", 351 dprintk("RPC: %5u validating %s cred %p\n",
351 task->tk_pid, task->tk_auth->au_ops->au_name, cred); 352 task->tk_pid, task->tk_auth->au_ops->au_name, cred);
352 353
353 return cred->cr_ops->crvalidate(task, p); 354 return cred->cr_ops->crvalidate(task, p);
@@ -359,7 +360,7 @@ rpcauth_wrap_req(struct rpc_task *task, kxdrproc_t encode, void *rqstp,
359{ 360{
360 struct rpc_cred *cred = task->tk_msg.rpc_cred; 361 struct rpc_cred *cred = task->tk_msg.rpc_cred;
361 362
362 dprintk("RPC: %4d using %s cred %p to wrap rpc data\n", 363 dprintk("RPC: %5u using %s cred %p to wrap rpc data\n",
363 task->tk_pid, cred->cr_ops->cr_name, cred); 364 task->tk_pid, cred->cr_ops->cr_name, cred);
364 if (cred->cr_ops->crwrap_req) 365 if (cred->cr_ops->crwrap_req)
365 return cred->cr_ops->crwrap_req(task, encode, rqstp, data, obj); 366 return cred->cr_ops->crwrap_req(task, encode, rqstp, data, obj);
@@ -373,7 +374,7 @@ rpcauth_unwrap_resp(struct rpc_task *task, kxdrproc_t decode, void *rqstp,
373{ 374{
374 struct rpc_cred *cred = task->tk_msg.rpc_cred; 375 struct rpc_cred *cred = task->tk_msg.rpc_cred;
375 376
376 dprintk("RPC: %4d using %s cred %p to unwrap rpc data\n", 377 dprintk("RPC: %5u using %s cred %p to unwrap rpc data\n",
377 task->tk_pid, cred->cr_ops->cr_name, cred); 378 task->tk_pid, cred->cr_ops->cr_name, cred);
378 if (cred->cr_ops->crunwrap_resp) 379 if (cred->cr_ops->crunwrap_resp)
379 return cred->cr_ops->crunwrap_resp(task, decode, rqstp, 380 return cred->cr_ops->crunwrap_resp(task, decode, rqstp,
@@ -388,7 +389,7 @@ rpcauth_refreshcred(struct rpc_task *task)
388 struct rpc_cred *cred = task->tk_msg.rpc_cred; 389 struct rpc_cred *cred = task->tk_msg.rpc_cred;
389 int err; 390 int err;
390 391
391 dprintk("RPC: %4d refreshing %s cred %p\n", 392 dprintk("RPC: %5u refreshing %s cred %p\n",
392 task->tk_pid, task->tk_auth->au_ops->au_name, cred); 393 task->tk_pid, task->tk_auth->au_ops->au_name, cred);
393 394
394 err = cred->cr_ops->crrefresh(task); 395 err = cred->cr_ops->crrefresh(task);
@@ -400,7 +401,7 @@ rpcauth_refreshcred(struct rpc_task *task)
400void 401void
401rpcauth_invalcred(struct rpc_task *task) 402rpcauth_invalcred(struct rpc_task *task)
402{ 403{
403 dprintk("RPC: %4d invalidating %s cred %p\n", 404 dprintk("RPC: %5u invalidating %s cred %p\n",
404 task->tk_pid, task->tk_auth->au_ops->au_name, task->tk_msg.rpc_cred); 405 task->tk_pid, task->tk_auth->au_ops->au_name, task->tk_msg.rpc_cred);
405 spin_lock(&rpc_credcache_lock); 406 spin_lock(&rpc_credcache_lock);
406 if (task->tk_msg.rpc_cred) 407 if (task->tk_msg.rpc_cred)
diff --git a/net/sunrpc/auth_gss/auth_gss.c b/net/sunrpc/auth_gss/auth_gss.c
index 718fb94ad0f7..4e4ccc5b6fea 100644
--- a/net/sunrpc/auth_gss/auth_gss.c
+++ b/net/sunrpc/auth_gss/auth_gss.c
@@ -241,7 +241,7 @@ gss_fill_context(const void *p, const void *end, struct gss_cl_ctx *ctx, struct
241 } 241 }
242 return q; 242 return q;
243err: 243err:
244 dprintk("RPC: gss_fill_context returning %ld\n", -PTR_ERR(p)); 244 dprintk("RPC: gss_fill_context returning %ld\n", -PTR_ERR(p));
245 return p; 245 return p;
246} 246}
247 247
@@ -276,10 +276,10 @@ __gss_find_upcall(struct gss_auth *gss_auth, uid_t uid)
276 if (pos->uid != uid) 276 if (pos->uid != uid)
277 continue; 277 continue;
278 atomic_inc(&pos->count); 278 atomic_inc(&pos->count);
279 dprintk("RPC: gss_find_upcall found msg %p\n", pos); 279 dprintk("RPC: gss_find_upcall found msg %p\n", pos);
280 return pos; 280 return pos;
281 } 281 }
282 dprintk("RPC: gss_find_upcall found nothing\n"); 282 dprintk("RPC: gss_find_upcall found nothing\n");
283 return NULL; 283 return NULL;
284} 284}
285 285
@@ -393,7 +393,8 @@ gss_refresh_upcall(struct rpc_task *task)
393 struct gss_upcall_msg *gss_msg; 393 struct gss_upcall_msg *gss_msg;
394 int err = 0; 394 int err = 0;
395 395
396 dprintk("RPC: %4u gss_refresh_upcall for uid %u\n", task->tk_pid, cred->cr_uid); 396 dprintk("RPC: %5u gss_refresh_upcall for uid %u\n", task->tk_pid,
397 cred->cr_uid);
397 gss_msg = gss_setup_upcall(task->tk_client, gss_auth, cred); 398 gss_msg = gss_setup_upcall(task->tk_client, gss_auth, cred);
398 if (IS_ERR(gss_msg)) { 399 if (IS_ERR(gss_msg)) {
399 err = PTR_ERR(gss_msg); 400 err = PTR_ERR(gss_msg);
@@ -413,8 +414,8 @@ gss_refresh_upcall(struct rpc_task *task)
413 spin_unlock(&gss_auth->lock); 414 spin_unlock(&gss_auth->lock);
414 gss_release_msg(gss_msg); 415 gss_release_msg(gss_msg);
415out: 416out:
416 dprintk("RPC: %4u gss_refresh_upcall for uid %u result %d\n", task->tk_pid, 417 dprintk("RPC: %5u gss_refresh_upcall for uid %u result %d\n",
417 cred->cr_uid, err); 418 task->tk_pid, cred->cr_uid, err);
418 return err; 419 return err;
419} 420}
420 421
@@ -426,7 +427,7 @@ gss_create_upcall(struct gss_auth *gss_auth, struct gss_cred *gss_cred)
426 DEFINE_WAIT(wait); 427 DEFINE_WAIT(wait);
427 int err = 0; 428 int err = 0;
428 429
429 dprintk("RPC: gss_upcall for uid %u\n", cred->cr_uid); 430 dprintk("RPC: gss_upcall for uid %u\n", cred->cr_uid);
430 gss_msg = gss_setup_upcall(gss_auth->client, gss_auth, cred); 431 gss_msg = gss_setup_upcall(gss_auth->client, gss_auth, cred);
431 if (IS_ERR(gss_msg)) { 432 if (IS_ERR(gss_msg)) {
432 err = PTR_ERR(gss_msg); 433 err = PTR_ERR(gss_msg);
@@ -454,7 +455,8 @@ out_intr:
454 finish_wait(&gss_msg->waitqueue, &wait); 455 finish_wait(&gss_msg->waitqueue, &wait);
455 gss_release_msg(gss_msg); 456 gss_release_msg(gss_msg);
456out: 457out:
457 dprintk("RPC: gss_create_upcall for uid %u result %d\n", cred->cr_uid, err); 458 dprintk("RPC: gss_create_upcall for uid %u result %d\n",
459 cred->cr_uid, err);
458 return err; 460 return err;
459} 461}
460 462
@@ -546,14 +548,14 @@ gss_pipe_downcall(struct file *filp, const char __user *src, size_t mlen)
546 } 548 }
547 gss_put_ctx(ctx); 549 gss_put_ctx(ctx);
548 kfree(buf); 550 kfree(buf);
549 dprintk("RPC: gss_pipe_downcall returning length %Zu\n", mlen); 551 dprintk("RPC: gss_pipe_downcall returning length %Zu\n", mlen);
550 return mlen; 552 return mlen;
551err_put_ctx: 553err_put_ctx:
552 gss_put_ctx(ctx); 554 gss_put_ctx(ctx);
553err: 555err:
554 kfree(buf); 556 kfree(buf);
555out: 557out:
556 dprintk("RPC: gss_pipe_downcall returning %d\n", err); 558 dprintk("RPC: gss_pipe_downcall returning %d\n", err);
557 return err; 559 return err;
558} 560}
559 561
@@ -591,7 +593,7 @@ gss_pipe_destroy_msg(struct rpc_pipe_msg *msg)
591 static unsigned long ratelimit; 593 static unsigned long ratelimit;
592 594
593 if (msg->errno < 0) { 595 if (msg->errno < 0) {
594 dprintk("RPC: gss_pipe_destroy_msg releasing msg %p\n", 596 dprintk("RPC: gss_pipe_destroy_msg releasing msg %p\n",
595 gss_msg); 597 gss_msg);
596 atomic_inc(&gss_msg->count); 598 atomic_inc(&gss_msg->count);
597 gss_unhash_msg(gss_msg); 599 gss_unhash_msg(gss_msg);
@@ -618,7 +620,7 @@ gss_create(struct rpc_clnt *clnt, rpc_authflavor_t flavor)
618 struct rpc_auth * auth; 620 struct rpc_auth * auth;
619 int err = -ENOMEM; /* XXX? */ 621 int err = -ENOMEM; /* XXX? */
620 622
621 dprintk("RPC: creating GSS authenticator for client %p\n",clnt); 623 dprintk("RPC: creating GSS authenticator for client %p\n", clnt);
622 624
623 if (!try_module_get(THIS_MODULE)) 625 if (!try_module_get(THIS_MODULE))
624 return ERR_PTR(err); 626 return ERR_PTR(err);
@@ -670,8 +672,8 @@ gss_destroy(struct rpc_auth *auth)
670{ 672{
671 struct gss_auth *gss_auth; 673 struct gss_auth *gss_auth;
672 674
673 dprintk("RPC: destroying GSS authenticator %p flavor %d\n", 675 dprintk("RPC: destroying GSS authenticator %p flavor %d\n",
674 auth, auth->au_flavor); 676 auth, auth->au_flavor);
675 677
676 gss_auth = container_of(auth, struct gss_auth, rpc_auth); 678 gss_auth = container_of(auth, struct gss_auth, rpc_auth);
677 rpc_unlink(gss_auth->dentry); 679 rpc_unlink(gss_auth->dentry);
@@ -689,7 +691,7 @@ gss_destroy(struct rpc_auth *auth)
689static void 691static void
690gss_destroy_ctx(struct gss_cl_ctx *ctx) 692gss_destroy_ctx(struct gss_cl_ctx *ctx)
691{ 693{
692 dprintk("RPC: gss_destroy_ctx\n"); 694 dprintk("RPC: gss_destroy_ctx\n");
693 695
694 if (ctx->gc_gss_ctx) 696 if (ctx->gc_gss_ctx)
695 gss_delete_sec_context(&ctx->gc_gss_ctx); 697 gss_delete_sec_context(&ctx->gc_gss_ctx);
@@ -703,7 +705,7 @@ gss_destroy_cred(struct rpc_cred *rc)
703{ 705{
704 struct gss_cred *cred = container_of(rc, struct gss_cred, gc_base); 706 struct gss_cred *cred = container_of(rc, struct gss_cred, gc_base);
705 707
706 dprintk("RPC: gss_destroy_cred \n"); 708 dprintk("RPC: gss_destroy_cred \n");
707 709
708 if (cred->gc_ctx) 710 if (cred->gc_ctx)
709 gss_put_ctx(cred->gc_ctx); 711 gss_put_ctx(cred->gc_ctx);
@@ -726,7 +728,7 @@ gss_create_cred(struct rpc_auth *auth, struct auth_cred *acred, int flags)
726 struct gss_cred *cred = NULL; 728 struct gss_cred *cred = NULL;
727 int err = -ENOMEM; 729 int err = -ENOMEM;
728 730
729 dprintk("RPC: gss_create_cred for uid %d, flavor %d\n", 731 dprintk("RPC: gss_create_cred for uid %d, flavor %d\n",
730 acred->uid, auth->au_flavor); 732 acred->uid, auth->au_flavor);
731 733
732 if (!(cred = kzalloc(sizeof(*cred), GFP_KERNEL))) 734 if (!(cred = kzalloc(sizeof(*cred), GFP_KERNEL)))
@@ -745,7 +747,7 @@ gss_create_cred(struct rpc_auth *auth, struct auth_cred *acred, int flags)
745 return &cred->gc_base; 747 return &cred->gc_base;
746 748
747out_err: 749out_err:
748 dprintk("RPC: gss_create_cred failed with error %d\n", err); 750 dprintk("RPC: gss_create_cred failed with error %d\n", err);
749 return ERR_PTR(err); 751 return ERR_PTR(err);
750} 752}
751 753
@@ -799,7 +801,7 @@ gss_marshal(struct rpc_task *task, __be32 *p)
799 struct kvec iov; 801 struct kvec iov;
800 struct xdr_buf verf_buf; 802 struct xdr_buf verf_buf;
801 803
802 dprintk("RPC: %4u gss_marshal\n", task->tk_pid); 804 dprintk("RPC: %5u gss_marshal\n", task->tk_pid);
803 805
804 *p++ = htonl(RPC_AUTH_GSS); 806 *p++ = htonl(RPC_AUTH_GSS);
805 cred_len = p++; 807 cred_len = p++;
@@ -865,7 +867,7 @@ gss_validate(struct rpc_task *task, __be32 *p)
865 u32 flav,len; 867 u32 flav,len;
866 u32 maj_stat; 868 u32 maj_stat;
867 869
868 dprintk("RPC: %4u gss_validate\n", task->tk_pid); 870 dprintk("RPC: %5u gss_validate\n", task->tk_pid);
869 871
870 flav = ntohl(*p++); 872 flav = ntohl(*p++);
871 if ((len = ntohl(*p++)) > RPC_MAX_AUTH_SIZE) 873 if ((len = ntohl(*p++)) > RPC_MAX_AUTH_SIZE)
@@ -888,12 +890,12 @@ gss_validate(struct rpc_task *task, __be32 *p)
888 * calculate the length of the verifier: */ 890 * calculate the length of the verifier: */
889 task->tk_auth->au_verfsize = XDR_QUADLEN(len) + 2; 891 task->tk_auth->au_verfsize = XDR_QUADLEN(len) + 2;
890 gss_put_ctx(ctx); 892 gss_put_ctx(ctx);
891 dprintk("RPC: %4u GSS gss_validate: gss_verify_mic succeeded.\n", 893 dprintk("RPC: %5u gss_validate: gss_verify_mic succeeded.\n",
892 task->tk_pid); 894 task->tk_pid);
893 return p + XDR_QUADLEN(len); 895 return p + XDR_QUADLEN(len);
894out_bad: 896out_bad:
895 gss_put_ctx(ctx); 897 gss_put_ctx(ctx);
896 dprintk("RPC: %4u gss_validate failed.\n", task->tk_pid); 898 dprintk("RPC: %5u gss_validate failed.\n", task->tk_pid);
897 return NULL; 899 return NULL;
898} 900}
899 901
@@ -1063,7 +1065,7 @@ gss_wrap_req(struct rpc_task *task,
1063 struct gss_cl_ctx *ctx = gss_cred_get_ctx(cred); 1065 struct gss_cl_ctx *ctx = gss_cred_get_ctx(cred);
1064 int status = -EIO; 1066 int status = -EIO;
1065 1067
1066 dprintk("RPC: %4u gss_wrap_req\n", task->tk_pid); 1068 dprintk("RPC: %5u gss_wrap_req\n", task->tk_pid);
1067 if (ctx->gc_proc != RPC_GSS_PROC_DATA) { 1069 if (ctx->gc_proc != RPC_GSS_PROC_DATA) {
1068 /* The spec seems a little ambiguous here, but I think that not 1070 /* The spec seems a little ambiguous here, but I think that not
1069 * wrapping context destruction requests makes the most sense. 1071 * wrapping context destruction requests makes the most sense.
@@ -1086,7 +1088,7 @@ gss_wrap_req(struct rpc_task *task,
1086 } 1088 }
1087out: 1089out:
1088 gss_put_ctx(ctx); 1090 gss_put_ctx(ctx);
1089 dprintk("RPC: %4u gss_wrap_req returning %d\n", task->tk_pid, status); 1091 dprintk("RPC: %5u gss_wrap_req returning %d\n", task->tk_pid, status);
1090 return status; 1092 return status;
1091} 1093}
1092 1094
@@ -1192,7 +1194,7 @@ out_decode:
1192 status = decode(rqstp, p, obj); 1194 status = decode(rqstp, p, obj);
1193out: 1195out:
1194 gss_put_ctx(ctx); 1196 gss_put_ctx(ctx);
1195 dprintk("RPC: %4u gss_unwrap_resp returning %d\n", task->tk_pid, 1197 dprintk("RPC: %5u gss_unwrap_resp returning %d\n", task->tk_pid,
1196 status); 1198 status);
1197 return status; 1199 return status;
1198} 1200}
diff --git a/net/sunrpc/auth_gss/gss_krb5_crypto.c b/net/sunrpc/auth_gss/gss_krb5_crypto.c
index 0a9948de0992..f441aa0b26dc 100644
--- a/net/sunrpc/auth_gss/gss_krb5_crypto.c
+++ b/net/sunrpc/auth_gss/gss_krb5_crypto.c
@@ -66,8 +66,8 @@ krb5_encrypt(
66 goto out; 66 goto out;
67 67
68 if (crypto_blkcipher_ivsize(tfm) > 16) { 68 if (crypto_blkcipher_ivsize(tfm) > 16) {
69 dprintk("RPC: gss_k5encrypt: tfm iv size to large %d\n", 69 dprintk("RPC: gss_k5encrypt: tfm iv size to large %d\n",
70 crypto_blkcipher_ivsize(tfm)); 70 crypto_blkcipher_ivsize(tfm));
71 goto out; 71 goto out;
72 } 72 }
73 73
@@ -79,7 +79,7 @@ krb5_encrypt(
79 79
80 ret = crypto_blkcipher_encrypt_iv(&desc, sg, sg, length); 80 ret = crypto_blkcipher_encrypt_iv(&desc, sg, sg, length);
81out: 81out:
82 dprintk("RPC: krb5_encrypt returns %d\n",ret); 82 dprintk("RPC: krb5_encrypt returns %d\n", ret);
83 return ret; 83 return ret;
84} 84}
85 85
@@ -102,7 +102,7 @@ krb5_decrypt(
102 goto out; 102 goto out;
103 103
104 if (crypto_blkcipher_ivsize(tfm) > 16) { 104 if (crypto_blkcipher_ivsize(tfm) > 16) {
105 dprintk("RPC: gss_k5decrypt: tfm iv size to large %d\n", 105 dprintk("RPC: gss_k5decrypt: tfm iv size to large %d\n",
106 crypto_blkcipher_ivsize(tfm)); 106 crypto_blkcipher_ivsize(tfm));
107 goto out; 107 goto out;
108 } 108 }
@@ -114,7 +114,7 @@ krb5_decrypt(
114 114
115 ret = crypto_blkcipher_decrypt_iv(&desc, sg, sg, length); 115 ret = crypto_blkcipher_decrypt_iv(&desc, sg, sg, length);
116out: 116out:
117 dprintk("RPC: gss_k5decrypt returns %d\n",ret); 117 dprintk("RPC: gss_k5decrypt returns %d\n",ret);
118 return ret; 118 return ret;
119} 119}
120 120
diff --git a/net/sunrpc/auth_gss/gss_krb5_mech.c b/net/sunrpc/auth_gss/gss_krb5_mech.c
index 05d4bee86fc0..7b1943217053 100644
--- a/net/sunrpc/auth_gss/gss_krb5_mech.c
+++ b/net/sunrpc/auth_gss/gss_krb5_mech.c
@@ -175,7 +175,8 @@ gss_import_sec_context_kerberos(const void *p,
175 } 175 }
176 176
177 ctx_id->internal_ctx_id = ctx; 177 ctx_id->internal_ctx_id = ctx;
178 dprintk("RPC: Successfully imported new context.\n"); 178
179 dprintk("RPC: Successfully imported new context.\n");
179 return 0; 180 return 0;
180 181
181out_err_free_key2: 182out_err_free_key2:
diff --git a/net/sunrpc/auth_gss/gss_krb5_seal.c b/net/sunrpc/auth_gss/gss_krb5_seal.c
index d0bb5064f8c5..a0d9faa59cb5 100644
--- a/net/sunrpc/auth_gss/gss_krb5_seal.c
+++ b/net/sunrpc/auth_gss/gss_krb5_seal.c
@@ -83,7 +83,7 @@ gss_get_mic_kerberos(struct gss_ctx *gss_ctx, struct xdr_buf *text,
83 s32 now; 83 s32 now;
84 u32 seq_send; 84 u32 seq_send;
85 85
86 dprintk("RPC: gss_krb5_seal\n"); 86 dprintk("RPC: gss_krb5_seal\n");
87 87
88 now = get_seconds(); 88 now = get_seconds();
89 89
diff --git a/net/sunrpc/auth_gss/gss_krb5_seqnum.c b/net/sunrpc/auth_gss/gss_krb5_seqnum.c
index 3e315a68efaa..43f3421f1e6a 100644
--- a/net/sunrpc/auth_gss/gss_krb5_seqnum.c
+++ b/net/sunrpc/auth_gss/gss_krb5_seqnum.c
@@ -70,7 +70,7 @@ krb5_get_seq_num(struct crypto_blkcipher *key,
70 s32 code; 70 s32 code;
71 unsigned char plain[8]; 71 unsigned char plain[8];
72 72
73 dprintk("RPC: krb5_get_seq_num:\n"); 73 dprintk("RPC: krb5_get_seq_num:\n");
74 74
75 if ((code = krb5_decrypt(key, cksum, buf, plain, 8))) 75 if ((code = krb5_decrypt(key, cksum, buf, plain, 8)))
76 return code; 76 return code;
diff --git a/net/sunrpc/auth_gss/gss_krb5_unseal.c b/net/sunrpc/auth_gss/gss_krb5_unseal.c
index 87f8977ccece..e30a993466bc 100644
--- a/net/sunrpc/auth_gss/gss_krb5_unseal.c
+++ b/net/sunrpc/auth_gss/gss_krb5_unseal.c
@@ -86,7 +86,7 @@ gss_verify_mic_kerberos(struct gss_ctx *gss_ctx,
86 unsigned char *ptr = (unsigned char *)read_token->data; 86 unsigned char *ptr = (unsigned char *)read_token->data;
87 int bodysize; 87 int bodysize;
88 88
89 dprintk("RPC: krb5_read_token\n"); 89 dprintk("RPC: krb5_read_token\n");
90 90
91 if (g_verify_token_header(&ctx->mech_used, &bodysize, &ptr, 91 if (g_verify_token_header(&ctx->mech_used, &bodysize, &ptr,
92 read_token->len)) 92 read_token->len))
diff --git a/net/sunrpc/auth_gss/gss_krb5_wrap.c b/net/sunrpc/auth_gss/gss_krb5_wrap.c
index fe25b3d898dc..42b3220bed39 100644
--- a/net/sunrpc/auth_gss/gss_krb5_wrap.c
+++ b/net/sunrpc/auth_gss/gss_krb5_wrap.c
@@ -129,7 +129,7 @@ gss_wrap_kerberos(struct gss_ctx *ctx, int offset,
129 struct page **tmp_pages; 129 struct page **tmp_pages;
130 u32 seq_send; 130 u32 seq_send;
131 131
132 dprintk("RPC: gss_wrap_kerberos\n"); 132 dprintk("RPC: gss_wrap_kerberos\n");
133 133
134 now = get_seconds(); 134 now = get_seconds();
135 135
@@ -215,7 +215,7 @@ gss_unwrap_kerberos(struct gss_ctx *ctx, int offset, struct xdr_buf *buf)
215 int data_len; 215 int data_len;
216 int blocksize; 216 int blocksize;
217 217
218 dprintk("RPC: gss_unwrap_kerberos\n"); 218 dprintk("RPC: gss_unwrap_kerberos\n");
219 219
220 ptr = (u8 *)buf->head[0].iov_base + offset; 220 ptr = (u8 *)buf->head[0].iov_base + offset;
221 if (g_verify_token_header(&kctx->mech_used, &bodysize, &ptr, 221 if (g_verify_token_header(&kctx->mech_used, &bodysize, &ptr,
diff --git a/net/sunrpc/auth_gss/gss_mech_switch.c b/net/sunrpc/auth_gss/gss_mech_switch.c
index 3423890e4a30..26872517ccf3 100644
--- a/net/sunrpc/auth_gss/gss_mech_switch.c
+++ b/net/sunrpc/auth_gss/gss_mech_switch.c
@@ -113,7 +113,7 @@ gss_mech_register(struct gss_api_mech *gm)
113 spin_lock(&registered_mechs_lock); 113 spin_lock(&registered_mechs_lock);
114 list_add(&gm->gm_list, &registered_mechs); 114 list_add(&gm->gm_list, &registered_mechs);
115 spin_unlock(&registered_mechs_lock); 115 spin_unlock(&registered_mechs_lock);
116 dprintk("RPC: registered gss mechanism %s\n", gm->gm_name); 116 dprintk("RPC: registered gss mechanism %s\n", gm->gm_name);
117 return 0; 117 return 0;
118} 118}
119 119
@@ -125,7 +125,7 @@ gss_mech_unregister(struct gss_api_mech *gm)
125 spin_lock(&registered_mechs_lock); 125 spin_lock(&registered_mechs_lock);
126 list_del(&gm->gm_list); 126 list_del(&gm->gm_list);
127 spin_unlock(&registered_mechs_lock); 127 spin_unlock(&registered_mechs_lock);
128 dprintk("RPC: unregistered gss mechanism %s\n", gm->gm_name); 128 dprintk("RPC: unregistered gss mechanism %s\n", gm->gm_name);
129 gss_mech_free(gm); 129 gss_mech_free(gm);
130} 130}
131 131
@@ -298,7 +298,7 @@ gss_unwrap(struct gss_ctx *ctx_id,
298u32 298u32
299gss_delete_sec_context(struct gss_ctx **context_handle) 299gss_delete_sec_context(struct gss_ctx **context_handle)
300{ 300{
301 dprintk("RPC: gss_delete_sec_context deleting %p\n", 301 dprintk("RPC: gss_delete_sec_context deleting %p\n",
302 *context_handle); 302 *context_handle);
303 303
304 if (!*context_handle) 304 if (!*context_handle)
diff --git a/net/sunrpc/auth_gss/gss_spkm3_mech.c b/net/sunrpc/auth_gss/gss_spkm3_mech.c
index 8ef3f1c19435..7e15aa68ae64 100644
--- a/net/sunrpc/auth_gss/gss_spkm3_mech.c
+++ b/net/sunrpc/auth_gss/gss_spkm3_mech.c
@@ -97,7 +97,8 @@ gss_import_sec_context_spkm3(const void *p, size_t len,
97 if (IS_ERR(p)) 97 if (IS_ERR(p))
98 goto out_err_free_ctx; 98 goto out_err_free_ctx;
99 if (version != 1) { 99 if (version != 1) {
100 dprintk("RPC: unknown spkm3 token format: obsolete nfs-utils?\n"); 100 dprintk("RPC: unknown spkm3 token format: "
101 "obsolete nfs-utils?\n");
101 goto out_err_free_ctx; 102 goto out_err_free_ctx;
102 } 103 }
103 104
@@ -138,7 +139,7 @@ gss_import_sec_context_spkm3(const void *p, size_t len,
138 139
139 ctx_id->internal_ctx_id = ctx; 140 ctx_id->internal_ctx_id = ctx;
140 141
141 dprintk("Successfully imported new spkm context.\n"); 142 dprintk("RPC: Successfully imported new spkm context.\n");
142 return 0; 143 return 0;
143 144
144out_err_free_intg_key: 145out_err_free_intg_key:
@@ -183,7 +184,7 @@ gss_verify_mic_spkm3(struct gss_ctx *ctx,
183 184
184 maj_stat = spkm3_read_token(sctx, checksum, signbuf, SPKM_MIC_TOK); 185 maj_stat = spkm3_read_token(sctx, checksum, signbuf, SPKM_MIC_TOK);
185 186
186 dprintk("RPC: gss_verify_mic_spkm3 returning %d\n", maj_stat); 187 dprintk("RPC: gss_verify_mic_spkm3 returning %d\n", maj_stat);
187 return maj_stat; 188 return maj_stat;
188} 189}
189 190
@@ -197,7 +198,7 @@ gss_get_mic_spkm3(struct gss_ctx *ctx,
197 198
198 err = spkm3_make_token(sctx, message_buffer, 199 err = spkm3_make_token(sctx, message_buffer,
199 message_token, SPKM_MIC_TOK); 200 message_token, SPKM_MIC_TOK);
200 dprintk("RPC: gss_get_mic_spkm3 returning %d\n", err); 201 dprintk("RPC: gss_get_mic_spkm3 returning %d\n", err);
201 return err; 202 return err;
202} 203}
203 204
diff --git a/net/sunrpc/auth_gss/gss_spkm3_seal.c b/net/sunrpc/auth_gss/gss_spkm3_seal.c
index b179d58c6249..104cbf4f769f 100644
--- a/net/sunrpc/auth_gss/gss_spkm3_seal.c
+++ b/net/sunrpc/auth_gss/gss_spkm3_seal.c
@@ -75,20 +75,21 @@ spkm3_make_token(struct spkm3_ctx *ctx,
75 now = jiffies; 75 now = jiffies;
76 76
77 if (ctx->ctx_id.len != 16) { 77 if (ctx->ctx_id.len != 16) {
78 dprintk("RPC: spkm3_make_token BAD ctx_id.len %d\n", 78 dprintk("RPC: spkm3_make_token BAD ctx_id.len %d\n",
79 ctx->ctx_id.len); 79 ctx->ctx_id.len);
80 goto out_err; 80 goto out_err;
81 } 81 }
82 82
83 if (!g_OID_equal(&ctx->intg_alg, &hmac_md5_oid)) { 83 if (!g_OID_equal(&ctx->intg_alg, &hmac_md5_oid)) {
84 dprintk("RPC: gss_spkm3_seal: unsupported I-ALG algorithm." 84 dprintk("RPC: gss_spkm3_seal: unsupported I-ALG "
85 "only support hmac-md5 I-ALG.\n"); 85 "algorithm. only support hmac-md5 I-ALG.\n");
86 goto out_err; 86 goto out_err;
87 } else 87 } else
88 checksum_type = CKSUMTYPE_HMAC_MD5; 88 checksum_type = CKSUMTYPE_HMAC_MD5;
89 89
90 if (!g_OID_equal(&ctx->conf_alg, &cast5_cbc_oid)) { 90 if (!g_OID_equal(&ctx->conf_alg, &cast5_cbc_oid)) {
91 dprintk("RPC: gss_spkm3_seal: unsupported C-ALG algorithm\n"); 91 dprintk("RPC: gss_spkm3_seal: unsupported C-ALG "
92 "algorithm\n");
92 goto out_err; 93 goto out_err;
93 } 94 }
94 95
@@ -113,7 +114,8 @@ spkm3_make_token(struct spkm3_ctx *ctx,
113 114
114 spkm3_make_mic_token(&ptr, tokenlen, &mic_hdr, &md5cksum, md5elen, md5zbit); 115 spkm3_make_mic_token(&ptr, tokenlen, &mic_hdr, &md5cksum, md5elen, md5zbit);
115 } else if (toktype == SPKM_WRAP_TOK) { /* Not Supported */ 116 } else if (toktype == SPKM_WRAP_TOK) { /* Not Supported */
116 dprintk("RPC: gss_spkm3_seal: SPKM_WRAP_TOK not supported\n"); 117 dprintk("RPC: gss_spkm3_seal: SPKM_WRAP_TOK "
118 "not supported\n");
117 goto out_err; 119 goto out_err;
118 } 120 }
119 121
@@ -153,7 +155,7 @@ make_spkm3_checksum(s32 cksumtype, struct xdr_netobj *key, char *header,
153 cksumname = "md5"; 155 cksumname = "md5";
154 break; 156 break;
155 default: 157 default:
156 dprintk("RPC: spkm3_make_checksum:" 158 dprintk("RPC: spkm3_make_checksum:"
157 " unsupported checksum %d", cksumtype); 159 " unsupported checksum %d", cksumtype);
158 return GSS_S_FAILURE; 160 return GSS_S_FAILURE;
159 } 161 }
diff --git a/net/sunrpc/auth_gss/gss_spkm3_token.c b/net/sunrpc/auth_gss/gss_spkm3_token.c
index 8400b621971e..6cdd241ad267 100644
--- a/net/sunrpc/auth_gss/gss_spkm3_token.c
+++ b/net/sunrpc/auth_gss/gss_spkm3_token.c
@@ -209,7 +209,7 @@ spkm3_verify_mic_token(unsigned char **tokp, int *mic_hdrlen, unsigned char **ck
209 209
210 /* spkm3 innercontext token preamble */ 210 /* spkm3 innercontext token preamble */
211 if ((ptr[0] != 0xa4) || (ptr[2] != 0x30)) { 211 if ((ptr[0] != 0xa4) || (ptr[2] != 0x30)) {
212 dprintk("RPC: BAD SPKM ictoken preamble\n"); 212 dprintk("RPC: BAD SPKM ictoken preamble\n");
213 goto out; 213 goto out;
214 } 214 }
215 215
@@ -217,25 +217,25 @@ spkm3_verify_mic_token(unsigned char **tokp, int *mic_hdrlen, unsigned char **ck
217 217
218 /* token type */ 218 /* token type */
219 if ((ptr[4] != 0x02) || (ptr[5] != 0x02)) { 219 if ((ptr[4] != 0x02) || (ptr[5] != 0x02)) {
220 dprintk("RPC: BAD asn1 SPKM3 token type\n"); 220 dprintk("RPC: BAD asn1 SPKM3 token type\n");
221 goto out; 221 goto out;
222 } 222 }
223 223
224 /* only support SPKM_MIC_TOK */ 224 /* only support SPKM_MIC_TOK */
225 if((ptr[6] != 0x01) || (ptr[7] != 0x01)) { 225 if((ptr[6] != 0x01) || (ptr[7] != 0x01)) {
226 dprintk("RPC: ERROR unsupported SPKM3 token \n"); 226 dprintk("RPC: ERROR unsupported SPKM3 token \n");
227 goto out; 227 goto out;
228 } 228 }
229 229
230 /* contextid */ 230 /* contextid */
231 if (ptr[8] != 0x03) { 231 if (ptr[8] != 0x03) {
232 dprintk("RPC: BAD SPKM3 asn1 context-id type\n"); 232 dprintk("RPC: BAD SPKM3 asn1 context-id type\n");
233 goto out; 233 goto out;
234 } 234 }
235 235
236 ctxelen = ptr[9]; 236 ctxelen = ptr[9];
237 if (ctxelen > 17) { /* length includes asn1 zbit octet */ 237 if (ctxelen > 17) { /* length includes asn1 zbit octet */
238 dprintk("RPC: BAD SPKM3 contextid len %d\n", ctxelen); 238 dprintk("RPC: BAD SPKM3 contextid len %d\n", ctxelen);
239 goto out; 239 goto out;
240 } 240 }
241 241
@@ -251,7 +251,9 @@ spkm3_verify_mic_token(unsigned char **tokp, int *mic_hdrlen, unsigned char **ck
251 */ 251 */
252 252
253 if (*mic_hdrlen != 6 + ctxelen) { 253 if (*mic_hdrlen != 6 + ctxelen) {
254 dprintk("RPC: BAD SPKM_ MIC_TOK header len %d: we only support default int-alg (should be absent) and do not support snd-seq\n", *mic_hdrlen); 254 dprintk("RPC: BAD SPKM_ MIC_TOK header len %d: we only "
255 "support default int-alg (should be absent) "
256 "and do not support snd-seq\n", *mic_hdrlen);
255 goto out; 257 goto out;
256 } 258 }
257 /* checksum */ 259 /* checksum */
diff --git a/net/sunrpc/auth_gss/gss_spkm3_unseal.c b/net/sunrpc/auth_gss/gss_spkm3_unseal.c
index 35a1b34c4a1d..cc21ee860bb6 100644
--- a/net/sunrpc/auth_gss/gss_spkm3_unseal.c
+++ b/net/sunrpc/auth_gss/gss_spkm3_unseal.c
@@ -72,7 +72,7 @@ spkm3_read_token(struct spkm3_ctx *ctx,
72 /* decode the token */ 72 /* decode the token */
73 73
74 if (toktype != SPKM_MIC_TOK) { 74 if (toktype != SPKM_MIC_TOK) {
75 dprintk("RPC: BAD SPKM3 token type: %d\n", toktype); 75 dprintk("RPC: BAD SPKM3 token type: %d\n", toktype);
76 goto out; 76 goto out;
77 } 77 }
78 78
@@ -80,7 +80,7 @@ spkm3_read_token(struct spkm3_ctx *ctx,
80 goto out; 80 goto out;
81 81
82 if (*cksum++ != 0x03) { 82 if (*cksum++ != 0x03) {
83 dprintk("RPC: spkm3_read_token BAD checksum type\n"); 83 dprintk("RPC: spkm3_read_token BAD checksum type\n");
84 goto out; 84 goto out;
85 } 85 }
86 md5elen = *cksum++; 86 md5elen = *cksum++;
@@ -97,7 +97,8 @@ spkm3_read_token(struct spkm3_ctx *ctx,
97 */ 97 */
98 ret = GSS_S_DEFECTIVE_TOKEN; 98 ret = GSS_S_DEFECTIVE_TOKEN;
99 if (!g_OID_equal(&ctx->intg_alg, &hmac_md5_oid)) { 99 if (!g_OID_equal(&ctx->intg_alg, &hmac_md5_oid)) {
100 dprintk("RPC: gss_spkm3_seal: unsupported I-ALG algorithm\n"); 100 dprintk("RPC: gss_spkm3_seal: unsupported I-ALG "
101 "algorithm\n");
101 goto out; 102 goto out;
102 } 103 }
103 104
@@ -113,7 +114,7 @@ spkm3_read_token(struct spkm3_ctx *ctx,
113 ret = GSS_S_BAD_SIG; 114 ret = GSS_S_BAD_SIG;
114 code = memcmp(md5cksum.data, wire_cksum.data, wire_cksum.len); 115 code = memcmp(md5cksum.data, wire_cksum.data, wire_cksum.len);
115 if (code) { 116 if (code) {
116 dprintk("RPC: bad MIC checksum\n"); 117 dprintk("RPC: bad MIC checksum\n");
117 goto out; 118 goto out;
118 } 119 }
119 120
diff --git a/net/sunrpc/auth_gss/svcauth_gss.c b/net/sunrpc/auth_gss/svcauth_gss.c
index 8fde38ecaf21..db298b501c81 100644
--- a/net/sunrpc/auth_gss/svcauth_gss.c
+++ b/net/sunrpc/auth_gss/svcauth_gss.c
@@ -669,14 +669,14 @@ gss_verify_header(struct svc_rqst *rqstp, struct rsc *rsci,
669 } 669 }
670 670
671 if (gc->gc_seq > MAXSEQ) { 671 if (gc->gc_seq > MAXSEQ) {
672 dprintk("RPC: svcauth_gss: discarding request with large sequence number %d\n", 672 dprintk("RPC: svcauth_gss: discarding request with "
673 gc->gc_seq); 673 "large sequence number %d\n", gc->gc_seq);
674 *authp = rpcsec_gsserr_ctxproblem; 674 *authp = rpcsec_gsserr_ctxproblem;
675 return SVC_DENIED; 675 return SVC_DENIED;
676 } 676 }
677 if (!gss_check_seq_num(rsci, gc->gc_seq)) { 677 if (!gss_check_seq_num(rsci, gc->gc_seq)) {
678 dprintk("RPC: svcauth_gss: discarding request with old sequence number %d\n", 678 dprintk("RPC: svcauth_gss: discarding request with "
679 gc->gc_seq); 679 "old sequence number %d\n", gc->gc_seq);
680 return SVC_DROP; 680 return SVC_DROP;
681 } 681 }
682 return SVC_OK; 682 return SVC_OK;
@@ -958,7 +958,8 @@ svcauth_gss_accept(struct svc_rqst *rqstp, __be32 *authp)
958 __be32 *reject_stat = resv->iov_base + resv->iov_len; 958 __be32 *reject_stat = resv->iov_base + resv->iov_len;
959 int ret; 959 int ret;
960 960
961 dprintk("RPC: svcauth_gss: argv->iov_len = %zd\n",argv->iov_len); 961 dprintk("RPC: svcauth_gss: argv->iov_len = %zd\n",
962 argv->iov_len);
962 963
963 *authp = rpc_autherr_badcred; 964 *authp = rpc_autherr_badcred;
964 if (!svcdata) 965 if (!svcdata)
diff --git a/net/sunrpc/auth_unix.c b/net/sunrpc/auth_unix.c
index f7f990c9afe2..4e7733aee36e 100644
--- a/net/sunrpc/auth_unix.c
+++ b/net/sunrpc/auth_unix.c
@@ -39,7 +39,8 @@ static struct rpc_credops unix_credops;
39static struct rpc_auth * 39static struct rpc_auth *
40unx_create(struct rpc_clnt *clnt, rpc_authflavor_t flavor) 40unx_create(struct rpc_clnt *clnt, rpc_authflavor_t flavor)
41{ 41{
42 dprintk("RPC: creating UNIX authenticator for client %p\n", clnt); 42 dprintk("RPC: creating UNIX authenticator for client %p\n",
43 clnt);
43 if (atomic_inc_return(&unix_auth.au_count) == 0) 44 if (atomic_inc_return(&unix_auth.au_count) == 0)
44 unix_cred_cache.nextgc = jiffies + (unix_cred_cache.expire >> 1); 45 unix_cred_cache.nextgc = jiffies + (unix_cred_cache.expire >> 1);
45 return &unix_auth; 46 return &unix_auth;
@@ -48,7 +49,7 @@ unx_create(struct rpc_clnt *clnt, rpc_authflavor_t flavor)
48static void 49static void
49unx_destroy(struct rpc_auth *auth) 50unx_destroy(struct rpc_auth *auth)
50{ 51{
51 dprintk("RPC: destroying UNIX authenticator %p\n", auth); 52 dprintk("RPC: destroying UNIX authenticator %p\n", auth);
52 rpcauth_free_credcache(auth); 53 rpcauth_free_credcache(auth);
53} 54}
54 55
@@ -67,8 +68,8 @@ unx_create_cred(struct rpc_auth *auth, struct auth_cred *acred, int flags)
67 struct unx_cred *cred; 68 struct unx_cred *cred;
68 int i; 69 int i;
69 70
70 dprintk("RPC: allocating UNIX cred for uid %d gid %d\n", 71 dprintk("RPC: allocating UNIX cred for uid %d gid %d\n",
71 acred->uid, acred->gid); 72 acred->uid, acred->gid);
72 73
73 if (!(cred = kmalloc(sizeof(*cred), GFP_KERNEL))) 74 if (!(cred = kmalloc(sizeof(*cred), GFP_KERNEL)))
74 return ERR_PTR(-ENOMEM); 75 return ERR_PTR(-ENOMEM);
diff --git a/net/sunrpc/cache.c b/net/sunrpc/cache.c
index 8612044b9189..f02f24ae9468 100644
--- a/net/sunrpc/cache.c
+++ b/net/sunrpc/cache.c
@@ -215,7 +215,8 @@ int cache_check(struct cache_detail *detail,
215 if (rv == -EAGAIN) 215 if (rv == -EAGAIN)
216 rv = -ENOENT; 216 rv = -ENOENT;
217 } else if (rv == -EAGAIN || age > refresh_age/2) { 217 } else if (rv == -EAGAIN || age > refresh_age/2) {
218 dprintk("Want update, refage=%ld, age=%ld\n", refresh_age, age); 218 dprintk("RPC: Want update, refage=%ld, age=%ld\n",
219 refresh_age, age);
219 if (!test_and_set_bit(CACHE_PENDING, &h->flags)) { 220 if (!test_and_set_bit(CACHE_PENDING, &h->flags)) {
220 switch (cache_make_upcall(detail, h)) { 221 switch (cache_make_upcall(detail, h)) {
221 case -EINVAL: 222 case -EINVAL:
diff --git a/net/sunrpc/clnt.c b/net/sunrpc/clnt.c
index c95a61736d1c..6d7221fe990a 100644
--- a/net/sunrpc/clnt.c
+++ b/net/sunrpc/clnt.c
@@ -42,6 +42,10 @@
42# define RPCDBG_FACILITY RPCDBG_CALL 42# define RPCDBG_FACILITY RPCDBG_CALL
43#endif 43#endif
44 44
45#define dprint_status(t) \
46 dprintk("RPC: %5u %s (status %d)\n", t->tk_pid, \
47 __FUNCTION__, t->tk_status)
48
45static DECLARE_WAIT_QUEUE_HEAD(destroy_wait); 49static DECLARE_WAIT_QUEUE_HEAD(destroy_wait);
46 50
47 51
@@ -106,8 +110,8 @@ static struct rpc_clnt * rpc_new_client(struct rpc_xprt *xprt, char *servname, s
106 int err; 110 int err;
107 int len; 111 int len;
108 112
109 dprintk("RPC: creating %s client for %s (xprt %p)\n", 113 dprintk("RPC: creating %s client for %s (xprt %p)\n",
110 program->name, servname, xprt); 114 program->name, servname, xprt);
111 115
112 err = -EINVAL; 116 err = -EINVAL;
113 if (!xprt) 117 if (!xprt)
@@ -220,7 +224,7 @@ struct rpc_clnt *rpc_create(struct rpc_create_args *args)
220 xprt->resvport = 0; 224 xprt->resvport = 0;
221 225
222 dprintk("RPC: creating %s client for %s (xprt %p)\n", 226 dprintk("RPC: creating %s client for %s (xprt %p)\n",
223 args->program->name, args->servername, xprt); 227 args->program->name, args->servername, xprt);
224 228
225 clnt = rpc_new_client(xprt, args->servername, args->program, 229 clnt = rpc_new_client(xprt, args->servername, args->program,
226 args->version, args->authflavor); 230 args->version, args->authflavor);
@@ -245,6 +249,8 @@ struct rpc_clnt *rpc_create(struct rpc_create_args *args)
245 clnt->cl_autobind = 1; 249 clnt->cl_autobind = 1;
246 if (args->flags & RPC_CLNT_CREATE_ONESHOT) 250 if (args->flags & RPC_CLNT_CREATE_ONESHOT)
247 clnt->cl_oneshot = 1; 251 clnt->cl_oneshot = 1;
252 if (args->flags & RPC_CLNT_CREATE_DISCRTRY)
253 clnt->cl_discrtry = 1;
248 254
249 return clnt; 255 return clnt;
250} 256}
@@ -288,7 +294,7 @@ out_no_path:
288out_no_stats: 294out_no_stats:
289 kfree(new); 295 kfree(new);
290out_no_clnt: 296out_no_clnt:
291 dprintk("RPC: %s returned error %d\n", __FUNCTION__, err); 297 dprintk("RPC: %s: returned error %d\n", __FUNCTION__, err);
292 return ERR_PTR(err); 298 return ERR_PTR(err);
293} 299}
294 300
@@ -301,7 +307,7 @@ out_no_clnt:
301int 307int
302rpc_shutdown_client(struct rpc_clnt *clnt) 308rpc_shutdown_client(struct rpc_clnt *clnt)
303{ 309{
304 dprintk("RPC: shutting down %s client for %s, tasks=%d\n", 310 dprintk("RPC: shutting down %s client for %s, tasks=%d\n",
305 clnt->cl_protname, clnt->cl_server, 311 clnt->cl_protname, clnt->cl_server,
306 atomic_read(&clnt->cl_users)); 312 atomic_read(&clnt->cl_users));
307 313
@@ -336,7 +342,7 @@ rpc_destroy_client(struct rpc_clnt *clnt)
336 return 1; 342 return 1;
337 BUG_ON(atomic_read(&clnt->cl_users) != 0); 343 BUG_ON(atomic_read(&clnt->cl_users) != 0);
338 344
339 dprintk("RPC: destroying %s client for %s\n", 345 dprintk("RPC: destroying %s client for %s\n",
340 clnt->cl_protname, clnt->cl_server); 346 clnt->cl_protname, clnt->cl_server);
341 if (clnt->cl_auth) { 347 if (clnt->cl_auth) {
342 rpcauth_destroy(clnt->cl_auth); 348 rpcauth_destroy(clnt->cl_auth);
@@ -366,8 +372,8 @@ out_free:
366void 372void
367rpc_release_client(struct rpc_clnt *clnt) 373rpc_release_client(struct rpc_clnt *clnt)
368{ 374{
369 dprintk("RPC: rpc_release_client(%p, %d)\n", 375 dprintk("RPC: rpc_release_client(%p, %d)\n",
370 clnt, atomic_read(&clnt->cl_users)); 376 clnt, atomic_read(&clnt->cl_users));
371 377
372 if (!atomic_dec_and_test(&clnt->cl_users)) 378 if (!atomic_dec_and_test(&clnt->cl_users))
373 return; 379 return;
@@ -486,17 +492,13 @@ int rpc_call_sync(struct rpc_clnt *clnt, struct rpc_message *msg, int flags)
486 /* Mask signals on RPC calls _and_ GSS_AUTH upcalls */ 492 /* Mask signals on RPC calls _and_ GSS_AUTH upcalls */
487 rpc_task_sigmask(task, &oldset); 493 rpc_task_sigmask(task, &oldset);
488 494
489 rpc_call_setup(task, msg, 0);
490
491 /* Set up the call info struct and execute the task */ 495 /* Set up the call info struct and execute the task */
496 rpc_call_setup(task, msg, 0);
497 if (task->tk_status == 0) {
498 atomic_inc(&task->tk_count);
499 rpc_execute(task);
500 }
492 status = task->tk_status; 501 status = task->tk_status;
493 if (status != 0)
494 goto out;
495 atomic_inc(&task->tk_count);
496 status = rpc_execute(task);
497 if (status == 0)
498 status = task->tk_status;
499out:
500 rpc_put_task(task); 502 rpc_put_task(task);
501 rpc_restore_sigmask(&oldset); 503 rpc_restore_sigmask(&oldset);
502 return status; 504 return status;
@@ -658,9 +660,10 @@ call_start(struct rpc_task *task)
658{ 660{
659 struct rpc_clnt *clnt = task->tk_client; 661 struct rpc_clnt *clnt = task->tk_client;
660 662
661 dprintk("RPC: %4d call_start %s%d proc %d (%s)\n", task->tk_pid, 663 dprintk("RPC: %5u call_start %s%d proc %d (%s)\n", task->tk_pid,
662 clnt->cl_protname, clnt->cl_vers, task->tk_msg.rpc_proc->p_proc, 664 clnt->cl_protname, clnt->cl_vers,
663 (RPC_IS_ASYNC(task) ? "async" : "sync")); 665 task->tk_msg.rpc_proc->p_proc,
666 (RPC_IS_ASYNC(task) ? "async" : "sync"));
664 667
665 /* Increment call count */ 668 /* Increment call count */
666 task->tk_msg.rpc_proc->p_count++; 669 task->tk_msg.rpc_proc->p_count++;
@@ -674,7 +677,7 @@ call_start(struct rpc_task *task)
674static void 677static void
675call_reserve(struct rpc_task *task) 678call_reserve(struct rpc_task *task)
676{ 679{
677 dprintk("RPC: %4d call_reserve\n", task->tk_pid); 680 dprint_status(task);
678 681
679 if (!rpcauth_uptodatecred(task)) { 682 if (!rpcauth_uptodatecred(task)) {
680 task->tk_action = call_refresh; 683 task->tk_action = call_refresh;
@@ -694,8 +697,7 @@ call_reserveresult(struct rpc_task *task)
694{ 697{
695 int status = task->tk_status; 698 int status = task->tk_status;
696 699
697 dprintk("RPC: %4d call_reserveresult (status %d)\n", 700 dprint_status(task);
698 task->tk_pid, task->tk_status);
699 701
700 /* 702 /*
701 * After a call to xprt_reserve(), we must have either 703 * After a call to xprt_reserve(), we must have either
@@ -749,8 +751,8 @@ call_allocate(struct rpc_task *task)
749 struct rpc_xprt *xprt = task->tk_xprt; 751 struct rpc_xprt *xprt = task->tk_xprt;
750 unsigned int bufsiz; 752 unsigned int bufsiz;
751 753
752 dprintk("RPC: %4d call_allocate (status %d)\n", 754 dprint_status(task);
753 task->tk_pid, task->tk_status); 755
754 task->tk_action = call_bind; 756 task->tk_action = call_bind;
755 if (req->rq_buffer) 757 if (req->rq_buffer)
756 return; 758 return;
@@ -761,7 +763,8 @@ call_allocate(struct rpc_task *task)
761 763
762 if (xprt->ops->buf_alloc(task, bufsiz << 1) != NULL) 764 if (xprt->ops->buf_alloc(task, bufsiz << 1) != NULL)
763 return; 765 return;
764 printk(KERN_INFO "RPC: buffer allocation failed for task %p\n", task); 766
767 dprintk("RPC: %5u rpc_buffer allocation failed\n", task->tk_pid);
765 768
766 if (RPC_IS_ASYNC(task) || !signalled()) { 769 if (RPC_IS_ASYNC(task) || !signalled()) {
767 xprt_release(task); 770 xprt_release(task);
@@ -798,8 +801,7 @@ call_encode(struct rpc_task *task)
798 kxdrproc_t encode; 801 kxdrproc_t encode;
799 __be32 *p; 802 __be32 *p;
800 803
801 dprintk("RPC: %4d call_encode (status %d)\n", 804 dprint_status(task);
802 task->tk_pid, task->tk_status);
803 805
804 /* Default buffer setup */ 806 /* Default buffer setup */
805 bufsiz = req->rq_bufsize >> 1; 807 bufsiz = req->rq_bufsize >> 1;
@@ -845,8 +847,7 @@ call_bind(struct rpc_task *task)
845{ 847{
846 struct rpc_xprt *xprt = task->tk_xprt; 848 struct rpc_xprt *xprt = task->tk_xprt;
847 849
848 dprintk("RPC: %4d call_bind (status %d)\n", 850 dprint_status(task);
849 task->tk_pid, task->tk_status);
850 851
851 task->tk_action = call_connect; 852 task->tk_action = call_connect;
852 if (!xprt_bound(xprt)) { 853 if (!xprt_bound(xprt)) {
@@ -865,8 +866,7 @@ call_bind_status(struct rpc_task *task)
865 int status = -EACCES; 866 int status = -EACCES;
866 867
867 if (task->tk_status >= 0) { 868 if (task->tk_status >= 0) {
868 dprintk("RPC: %4d call_bind_status (status %d)\n", 869 dprint_status(task);
869 task->tk_pid, task->tk_status);
870 task->tk_status = 0; 870 task->tk_status = 0;
871 task->tk_action = call_connect; 871 task->tk_action = call_connect;
872 return; 872 return;
@@ -874,24 +874,24 @@ call_bind_status(struct rpc_task *task)
874 874
875 switch (task->tk_status) { 875 switch (task->tk_status) {
876 case -EACCES: 876 case -EACCES:
877 dprintk("RPC: %4d remote rpcbind: RPC program/version unavailable\n", 877 dprintk("RPC: %5u remote rpcbind: RPC program/version "
878 task->tk_pid); 878 "unavailable\n", task->tk_pid);
879 rpc_delay(task, 3*HZ); 879 rpc_delay(task, 3*HZ);
880 goto retry_timeout; 880 goto retry_timeout;
881 case -ETIMEDOUT: 881 case -ETIMEDOUT:
882 dprintk("RPC: %4d rpcbind request timed out\n", 882 dprintk("RPC: %5u rpcbind request timed out\n",
883 task->tk_pid); 883 task->tk_pid);
884 goto retry_timeout; 884 goto retry_timeout;
885 case -EPFNOSUPPORT: 885 case -EPFNOSUPPORT:
886 dprintk("RPC: %4d remote rpcbind service unavailable\n", 886 dprintk("RPC: %5u remote rpcbind service unavailable\n",
887 task->tk_pid); 887 task->tk_pid);
888 break; 888 break;
889 case -EPROTONOSUPPORT: 889 case -EPROTONOSUPPORT:
890 dprintk("RPC: %4d remote rpcbind version 2 unavailable\n", 890 dprintk("RPC: %5u remote rpcbind version 2 unavailable\n",
891 task->tk_pid); 891 task->tk_pid);
892 break; 892 break;
893 default: 893 default:
894 dprintk("RPC: %4d unrecognized rpcbind error (%d)\n", 894 dprintk("RPC: %5u unrecognized rpcbind error (%d)\n",
895 task->tk_pid, -task->tk_status); 895 task->tk_pid, -task->tk_status);
896 status = -EIO; 896 status = -EIO;
897 } 897 }
@@ -911,7 +911,7 @@ call_connect(struct rpc_task *task)
911{ 911{
912 struct rpc_xprt *xprt = task->tk_xprt; 912 struct rpc_xprt *xprt = task->tk_xprt;
913 913
914 dprintk("RPC: %4d call_connect xprt %p %s connected\n", 914 dprintk("RPC: %5u call_connect xprt %p %s connected\n",
915 task->tk_pid, xprt, 915 task->tk_pid, xprt,
916 (xprt_connected(xprt) ? "is" : "is not")); 916 (xprt_connected(xprt) ? "is" : "is not"));
917 917
@@ -933,8 +933,7 @@ call_connect_status(struct rpc_task *task)
933 struct rpc_clnt *clnt = task->tk_client; 933 struct rpc_clnt *clnt = task->tk_client;
934 int status = task->tk_status; 934 int status = task->tk_status;
935 935
936 dprintk("RPC: %5u call_connect_status (status %d)\n", 936 dprint_status(task);
937 task->tk_pid, task->tk_status);
938 937
939 task->tk_status = 0; 938 task->tk_status = 0;
940 if (status >= 0) { 939 if (status >= 0) {
@@ -966,8 +965,7 @@ call_connect_status(struct rpc_task *task)
966static void 965static void
967call_transmit(struct rpc_task *task) 966call_transmit(struct rpc_task *task)
968{ 967{
969 dprintk("RPC: %4d call_transmit (status %d)\n", 968 dprint_status(task);
970 task->tk_pid, task->tk_status);
971 969
972 task->tk_action = call_status; 970 task->tk_action = call_status;
973 if (task->tk_status < 0) 971 if (task->tk_status < 0)
@@ -1028,8 +1026,7 @@ call_status(struct rpc_task *task)
1028 if (req->rq_received > 0 && !req->rq_bytes_sent) 1026 if (req->rq_received > 0 && !req->rq_bytes_sent)
1029 task->tk_status = req->rq_received; 1027 task->tk_status = req->rq_received;
1030 1028
1031 dprintk("RPC: %4d call_status (status %d)\n", 1029 dprint_status(task);
1032 task->tk_pid, task->tk_status);
1033 1030
1034 status = task->tk_status; 1031 status = task->tk_status;
1035 if (status >= 0) { 1032 if (status >= 0) {
@@ -1080,11 +1077,11 @@ call_timeout(struct rpc_task *task)
1080 struct rpc_clnt *clnt = task->tk_client; 1077 struct rpc_clnt *clnt = task->tk_client;
1081 1078
1082 if (xprt_adjust_timeout(task->tk_rqstp) == 0) { 1079 if (xprt_adjust_timeout(task->tk_rqstp) == 0) {
1083 dprintk("RPC: %4d call_timeout (minor)\n", task->tk_pid); 1080 dprintk("RPC: %5u call_timeout (minor)\n", task->tk_pid);
1084 goto retry; 1081 goto retry;
1085 } 1082 }
1086 1083
1087 dprintk("RPC: %4d call_timeout (major)\n", task->tk_pid); 1084 dprintk("RPC: %5u call_timeout (major)\n", task->tk_pid);
1088 task->tk_timeouts++; 1085 task->tk_timeouts++;
1089 1086
1090 if (RPC_IS_SOFT(task)) { 1087 if (RPC_IS_SOFT(task)) {
@@ -1118,8 +1115,8 @@ call_decode(struct rpc_task *task)
1118 kxdrproc_t decode = task->tk_msg.rpc_proc->p_decode; 1115 kxdrproc_t decode = task->tk_msg.rpc_proc->p_decode;
1119 __be32 *p; 1116 __be32 *p;
1120 1117
1121 dprintk("RPC: %4d call_decode (status %d)\n", 1118 dprintk("RPC: %5u call_decode (status %d)\n",
1122 task->tk_pid, task->tk_status); 1119 task->tk_pid, task->tk_status);
1123 1120
1124 if (task->tk_flags & RPC_CALL_MAJORSEEN) { 1121 if (task->tk_flags & RPC_CALL_MAJORSEEN) {
1125 printk(KERN_NOTICE "%s: server %s OK\n", 1122 printk(KERN_NOTICE "%s: server %s OK\n",
@@ -1133,8 +1130,8 @@ call_decode(struct rpc_task *task)
1133 clnt->cl_stats->rpcretrans++; 1130 clnt->cl_stats->rpcretrans++;
1134 goto out_retry; 1131 goto out_retry;
1135 } 1132 }
1136 dprintk("%s: too small RPC reply size (%d bytes)\n", 1133 dprintk("RPC: %s: too small RPC reply size (%d bytes)\n",
1137 clnt->cl_protname, task->tk_status); 1134 clnt->cl_protname, task->tk_status);
1138 task->tk_action = call_timeout; 1135 task->tk_action = call_timeout;
1139 goto out_retry; 1136 goto out_retry;
1140 } 1137 }
@@ -1166,8 +1163,8 @@ call_decode(struct rpc_task *task)
1166 task->tk_msg.rpc_resp); 1163 task->tk_msg.rpc_resp);
1167 unlock_kernel(); 1164 unlock_kernel();
1168 } 1165 }
1169 dprintk("RPC: %4d call_decode result %d\n", task->tk_pid, 1166 dprintk("RPC: %5u call_decode result %d\n", task->tk_pid,
1170 task->tk_status); 1167 task->tk_status);
1171 return; 1168 return;
1172out_retry: 1169out_retry:
1173 req->rq_received = req->rq_private_buf.len = 0; 1170 req->rq_received = req->rq_private_buf.len = 0;
@@ -1180,7 +1177,7 @@ out_retry:
1180static void 1177static void
1181call_refresh(struct rpc_task *task) 1178call_refresh(struct rpc_task *task)
1182{ 1179{
1183 dprintk("RPC: %4d call_refresh\n", task->tk_pid); 1180 dprint_status(task);
1184 1181
1185 xprt_release(task); /* Must do to obtain new XID */ 1182 xprt_release(task); /* Must do to obtain new XID */
1186 task->tk_action = call_refreshresult; 1183 task->tk_action = call_refreshresult;
@@ -1196,8 +1193,8 @@ static void
1196call_refreshresult(struct rpc_task *task) 1193call_refreshresult(struct rpc_task *task)
1197{ 1194{
1198 int status = task->tk_status; 1195 int status = task->tk_status;
1199 dprintk("RPC: %4d call_refreshresult (status %d)\n", 1196
1200 task->tk_pid, task->tk_status); 1197 dprint_status(task);
1201 1198
1202 task->tk_status = 0; 1199 task->tk_status = 0;
1203 task->tk_action = call_reserve; 1200 task->tk_action = call_reserve;
@@ -1275,11 +1272,15 @@ call_verify(struct rpc_task *task)
1275 case RPC_AUTH_ERROR: 1272 case RPC_AUTH_ERROR:
1276 break; 1273 break;
1277 case RPC_MISMATCH: 1274 case RPC_MISMATCH:
1278 dprintk("%s: RPC call version mismatch!\n", __FUNCTION__); 1275 dprintk("RPC: %5u %s: RPC call version "
1276 "mismatch!\n",
1277 task->tk_pid, __FUNCTION__);
1279 error = -EPROTONOSUPPORT; 1278 error = -EPROTONOSUPPORT;
1280 goto out_err; 1279 goto out_err;
1281 default: 1280 default:
1282 dprintk("%s: RPC call rejected, unknown error: %x\n", __FUNCTION__, n); 1281 dprintk("RPC: %5u %s: RPC call rejected, "
1282 "unknown error: %x\n",
1283 task->tk_pid, __FUNCTION__, n);
1283 goto out_eio; 1284 goto out_eio;
1284 } 1285 }
1285 if (--len < 0) 1286 if (--len < 0)
@@ -1292,8 +1293,8 @@ call_verify(struct rpc_task *task)
1292 if (!task->tk_cred_retry) 1293 if (!task->tk_cred_retry)
1293 break; 1294 break;
1294 task->tk_cred_retry--; 1295 task->tk_cred_retry--;
1295 dprintk("RPC: %4d call_verify: retry stale creds\n", 1296 dprintk("RPC: %5u %s: retry stale creds\n",
1296 task->tk_pid); 1297 task->tk_pid, __FUNCTION__);
1297 rpcauth_invalcred(task); 1298 rpcauth_invalcred(task);
1298 task->tk_action = call_refresh; 1299 task->tk_action = call_refresh;
1299 goto out_retry; 1300 goto out_retry;
@@ -1303,8 +1304,8 @@ call_verify(struct rpc_task *task)
1303 if (!task->tk_garb_retry) 1304 if (!task->tk_garb_retry)
1304 break; 1305 break;
1305 task->tk_garb_retry--; 1306 task->tk_garb_retry--;
1306 dprintk("RPC: %4d call_verify: retry garbled creds\n", 1307 dprintk("RPC: %5u %s: retry garbled creds\n",
1307 task->tk_pid); 1308 task->tk_pid, __FUNCTION__);
1308 task->tk_action = call_bind; 1309 task->tk_action = call_bind;
1309 goto out_retry; 1310 goto out_retry;
1310 case RPC_AUTH_TOOWEAK: 1311 case RPC_AUTH_TOOWEAK:
@@ -1315,8 +1316,8 @@ call_verify(struct rpc_task *task)
1315 printk(KERN_WARNING "call_verify: unknown auth error: %x\n", n); 1316 printk(KERN_WARNING "call_verify: unknown auth error: %x\n", n);
1316 error = -EIO; 1317 error = -EIO;
1317 } 1318 }
1318 dprintk("RPC: %4d call_verify: call rejected %d\n", 1319 dprintk("RPC: %5u %s: call rejected %d\n",
1319 task->tk_pid, n); 1320 task->tk_pid, __FUNCTION__, n);
1320 goto out_err; 1321 goto out_err;
1321 } 1322 }
1322 if (!(p = rpcauth_checkverf(task, p))) { 1323 if (!(p = rpcauth_checkverf(task, p))) {
@@ -1330,20 +1331,24 @@ call_verify(struct rpc_task *task)
1330 case RPC_SUCCESS: 1331 case RPC_SUCCESS:
1331 return p; 1332 return p;
1332 case RPC_PROG_UNAVAIL: 1333 case RPC_PROG_UNAVAIL:
1333 dprintk("RPC: call_verify: program %u is unsupported by server %s\n", 1334 dprintk("RPC: %5u %s: program %u is unsupported by server %s\n",
1335 task->tk_pid, __FUNCTION__,
1334 (unsigned int)task->tk_client->cl_prog, 1336 (unsigned int)task->tk_client->cl_prog,
1335 task->tk_client->cl_server); 1337 task->tk_client->cl_server);
1336 error = -EPFNOSUPPORT; 1338 error = -EPFNOSUPPORT;
1337 goto out_err; 1339 goto out_err;
1338 case RPC_PROG_MISMATCH: 1340 case RPC_PROG_MISMATCH:
1339 dprintk("RPC: call_verify: program %u, version %u unsupported by server %s\n", 1341 dprintk("RPC: %5u %s: program %u, version %u unsupported by "
1342 "server %s\n", task->tk_pid, __FUNCTION__,
1340 (unsigned int)task->tk_client->cl_prog, 1343 (unsigned int)task->tk_client->cl_prog,
1341 (unsigned int)task->tk_client->cl_vers, 1344 (unsigned int)task->tk_client->cl_vers,
1342 task->tk_client->cl_server); 1345 task->tk_client->cl_server);
1343 error = -EPROTONOSUPPORT; 1346 error = -EPROTONOSUPPORT;
1344 goto out_err; 1347 goto out_err;
1345 case RPC_PROC_UNAVAIL: 1348 case RPC_PROC_UNAVAIL:
1346 dprintk("RPC: call_verify: proc %p unsupported by program %u, version %u on server %s\n", 1349 dprintk("RPC: %5u %s: proc %p unsupported by program %u, "
1350 "version %u on server %s\n",
1351 task->tk_pid, __FUNCTION__,
1347 task->tk_msg.rpc_proc, 1352 task->tk_msg.rpc_proc,
1348 task->tk_client->cl_prog, 1353 task->tk_client->cl_prog,
1349 task->tk_client->cl_vers, 1354 task->tk_client->cl_vers,
@@ -1351,7 +1356,8 @@ call_verify(struct rpc_task *task)
1351 error = -EOPNOTSUPP; 1356 error = -EOPNOTSUPP;
1352 goto out_err; 1357 goto out_err;
1353 case RPC_GARBAGE_ARGS: 1358 case RPC_GARBAGE_ARGS:
1354 dprintk("RPC: %4d %s: server saw garbage\n", task->tk_pid, __FUNCTION__); 1359 dprintk("RPC: %5u %s: server saw garbage\n",
1360 task->tk_pid, __FUNCTION__);
1355 break; /* retry */ 1361 break; /* retry */
1356 default: 1362 default:
1357 printk(KERN_WARNING "call_verify: server accept status: %x\n", n); 1363 printk(KERN_WARNING "call_verify: server accept status: %x\n", n);
@@ -1362,7 +1368,8 @@ out_garbage:
1362 task->tk_client->cl_stats->rpcgarbage++; 1368 task->tk_client->cl_stats->rpcgarbage++;
1363 if (task->tk_garb_retry) { 1369 if (task->tk_garb_retry) {
1364 task->tk_garb_retry--; 1370 task->tk_garb_retry--;
1365 dprintk("RPC %s: retrying %4d\n", __FUNCTION__, task->tk_pid); 1371 dprintk("RPC: %5u %s: retrying\n",
1372 task->tk_pid, __FUNCTION__);
1366 task->tk_action = call_bind; 1373 task->tk_action = call_bind;
1367out_retry: 1374out_retry:
1368 return ERR_PTR(-EAGAIN); 1375 return ERR_PTR(-EAGAIN);
diff --git a/net/sunrpc/pmap_clnt.c b/net/sunrpc/pmap_clnt.c
index f4e1357bc186..d9f765344589 100644
--- a/net/sunrpc/pmap_clnt.c
+++ b/net/sunrpc/pmap_clnt.c
@@ -62,7 +62,10 @@ static inline void pmap_map_free(struct portmap_args *map)
62 62
63static void pmap_map_release(void *data) 63static void pmap_map_release(void *data)
64{ 64{
65 pmap_map_free(data); 65 struct portmap_args *map = data;
66
67 xprt_put(map->pm_xprt);
68 pmap_map_free(map);
66} 69}
67 70
68static const struct rpc_call_ops pmap_getport_ops = { 71static const struct rpc_call_ops pmap_getport_ops = {
@@ -94,7 +97,7 @@ void rpc_getport(struct rpc_task *task)
94 struct rpc_task *child; 97 struct rpc_task *child;
95 int status; 98 int status;
96 99
97 dprintk("RPC: %4d rpc_getport(%s, %u, %u, %d)\n", 100 dprintk("RPC: %5u rpc_getport(%s, %u, %u, %d)\n",
98 task->tk_pid, clnt->cl_server, 101 task->tk_pid, clnt->cl_server,
99 clnt->cl_prog, clnt->cl_vers, xprt->prot); 102 clnt->cl_prog, clnt->cl_vers, xprt->prot);
100 103
@@ -133,7 +136,7 @@ void rpc_getport(struct rpc_task *task)
133 status = -EIO; 136 status = -EIO;
134 child = rpc_run_task(pmap_clnt, RPC_TASK_ASYNC, &pmap_getport_ops, map); 137 child = rpc_run_task(pmap_clnt, RPC_TASK_ASYNC, &pmap_getport_ops, map);
135 if (IS_ERR(child)) 138 if (IS_ERR(child))
136 goto bailout; 139 goto bailout_nofree;
137 rpc_put_task(child); 140 rpc_put_task(child);
138 141
139 task->tk_xprt->stat.bind_count++; 142 task->tk_xprt->stat.bind_count++;
@@ -175,7 +178,7 @@ int rpc_getport_external(struct sockaddr_in *sin, __u32 prog, __u32 vers, int pr
175 char hostname[32]; 178 char hostname[32];
176 int status; 179 int status;
177 180
178 dprintk("RPC: rpc_getport_external(%u.%u.%u.%u, %u, %u, %d)\n", 181 dprintk("RPC: rpc_getport_external(%u.%u.%u.%u, %u, %u, %d)\n",
179 NIPQUAD(sin->sin_addr.s_addr), prog, vers, prot); 182 NIPQUAD(sin->sin_addr.s_addr), prog, vers, prot);
180 183
181 sprintf(hostname, "%u.%u.%u.%u", NIPQUAD(sin->sin_addr.s_addr)); 184 sprintf(hostname, "%u.%u.%u.%u", NIPQUAD(sin->sin_addr.s_addr));
@@ -218,11 +221,10 @@ static void pmap_getport_done(struct rpc_task *child, void *data)
218 status = 0; 221 status = 0;
219 } 222 }
220 223
221 dprintk("RPC: %4d pmap_getport_done(status %d, port %u)\n", 224 dprintk("RPC: %5u pmap_getport_done(status %d, port %u)\n",
222 child->tk_pid, status, map->pm_port); 225 child->tk_pid, status, map->pm_port);
223 226
224 pmap_wake_portmap_waiters(xprt, status); 227 pmap_wake_portmap_waiters(xprt, status);
225 xprt_put(xprt);
226} 228}
227 229
228/** 230/**
@@ -255,13 +257,14 @@ int rpc_register(u32 prog, u32 vers, int prot, unsigned short port, int *okay)
255 struct rpc_clnt *pmap_clnt; 257 struct rpc_clnt *pmap_clnt;
256 int error = 0; 258 int error = 0;
257 259
258 dprintk("RPC: registering (%u, %u, %d, %u) with portmapper.\n", 260 dprintk("RPC: registering (%u, %u, %d, %u) with portmapper.\n",
259 prog, vers, prot, port); 261 prog, vers, prot, port);
260 262
261 pmap_clnt = pmap_create("localhost", &sin, IPPROTO_UDP, 1); 263 pmap_clnt = pmap_create("localhost", &sin, IPPROTO_UDP, 1);
262 if (IS_ERR(pmap_clnt)) { 264 if (IS_ERR(pmap_clnt)) {
263 error = PTR_ERR(pmap_clnt); 265 error = PTR_ERR(pmap_clnt);
264 dprintk("RPC: couldn't create pmap client. Error = %d\n", error); 266 dprintk("RPC: couldn't create pmap client. Error = %d\n",
267 error);
265 return error; 268 return error;
266 } 269 }
267 270
@@ -272,7 +275,7 @@ int rpc_register(u32 prog, u32 vers, int prot, unsigned short port, int *okay)
272 "RPC: failed to contact portmap (errno %d).\n", 275 "RPC: failed to contact portmap (errno %d).\n",
273 error); 276 error);
274 } 277 }
275 dprintk("RPC: registration status %d/%d\n", error, *okay); 278 dprintk("RPC: registration status %d/%d\n", error, *okay);
276 279
277 /* Client deleted automatically because cl_oneshot == 1 */ 280 /* Client deleted automatically because cl_oneshot == 1 */
278 return error; 281 return error;
@@ -303,8 +306,9 @@ static struct rpc_clnt *pmap_create(char *hostname, struct sockaddr_in *srvaddr,
303 */ 306 */
304static int xdr_encode_mapping(struct rpc_rqst *req, __be32 *p, struct portmap_args *map) 307static int xdr_encode_mapping(struct rpc_rqst *req, __be32 *p, struct portmap_args *map)
305{ 308{
306 dprintk("RPC: xdr_encode_mapping(%u, %u, %u, %u)\n", 309 dprintk("RPC: xdr_encode_mapping(%u, %u, %u, %u)\n",
307 map->pm_prog, map->pm_vers, map->pm_prot, map->pm_port); 310 map->pm_prog, map->pm_vers,
311 map->pm_prot, map->pm_port);
308 *p++ = htonl(map->pm_prog); 312 *p++ = htonl(map->pm_prog);
309 *p++ = htonl(map->pm_vers); 313 *p++ = htonl(map->pm_vers);
310 *p++ = htonl(map->pm_prot); 314 *p++ = htonl(map->pm_prot);
diff --git a/net/sunrpc/rpc_pipe.c b/net/sunrpc/rpc_pipe.c
index e1fad77a2257..9b9ea5045569 100644
--- a/net/sunrpc/rpc_pipe.c
+++ b/net/sunrpc/rpc_pipe.c
@@ -589,7 +589,7 @@ __rpc_mkdir(struct inode *dir, struct dentry *dentry)
589{ 589{
590 struct inode *inode; 590 struct inode *inode;
591 591
592 inode = rpc_get_inode(dir->i_sb, S_IFDIR | S_IRUSR | S_IXUSR); 592 inode = rpc_get_inode(dir->i_sb, S_IFDIR | S_IRUGO | S_IXUGO);
593 if (!inode) 593 if (!inode)
594 goto out_err; 594 goto out_err;
595 inode->i_ino = iunique(dir->i_sb, 100); 595 inode->i_ino = iunique(dir->i_sb, 100);
diff --git a/net/sunrpc/sched.c b/net/sunrpc/sched.c
index 54a6b92525ea..6d87320074b1 100644
--- a/net/sunrpc/sched.c
+++ b/net/sunrpc/sched.c
@@ -74,7 +74,7 @@ static DEFINE_SPINLOCK(rpc_sched_lock);
74static inline void 74static inline void
75__rpc_disable_timer(struct rpc_task *task) 75__rpc_disable_timer(struct rpc_task *task)
76{ 76{
77 dprintk("RPC: %4d disabling timer\n", task->tk_pid); 77 dprintk("RPC: %5u disabling timer\n", task->tk_pid);
78 task->tk_timeout_fn = NULL; 78 task->tk_timeout_fn = NULL;
79 task->tk_timeout = 0; 79 task->tk_timeout = 0;
80} 80}
@@ -93,7 +93,7 @@ static void rpc_run_timer(struct rpc_task *task)
93 callback = task->tk_timeout_fn; 93 callback = task->tk_timeout_fn;
94 task->tk_timeout_fn = NULL; 94 task->tk_timeout_fn = NULL;
95 if (callback && RPC_IS_QUEUED(task)) { 95 if (callback && RPC_IS_QUEUED(task)) {
96 dprintk("RPC: %4d running timer\n", task->tk_pid); 96 dprintk("RPC: %5u running timer\n", task->tk_pid);
97 callback(task); 97 callback(task);
98 } 98 }
99 smp_mb__before_clear_bit(); 99 smp_mb__before_clear_bit();
@@ -110,7 +110,7 @@ __rpc_add_timer(struct rpc_task *task, rpc_action timer)
110 if (!task->tk_timeout) 110 if (!task->tk_timeout)
111 return; 111 return;
112 112
113 dprintk("RPC: %4d setting alarm for %lu ms\n", 113 dprintk("RPC: %5u setting alarm for %lu ms\n",
114 task->tk_pid, task->tk_timeout * 1000 / HZ); 114 task->tk_pid, task->tk_timeout * 1000 / HZ);
115 115
116 if (timer) 116 if (timer)
@@ -132,7 +132,7 @@ rpc_delete_timer(struct rpc_task *task)
132 return; 132 return;
133 if (test_and_clear_bit(RPC_TASK_HAS_TIMER, &task->tk_runstate)) { 133 if (test_and_clear_bit(RPC_TASK_HAS_TIMER, &task->tk_runstate)) {
134 del_singleshot_timer_sync(&task->tk_timer); 134 del_singleshot_timer_sync(&task->tk_timer);
135 dprintk("RPC: %4d deleting timer\n", task->tk_pid); 135 dprintk("RPC: %5u deleting timer\n", task->tk_pid);
136 } 136 }
137} 137}
138 138
@@ -179,8 +179,8 @@ static void __rpc_add_wait_queue(struct rpc_wait_queue *queue, struct rpc_task *
179 queue->qlen++; 179 queue->qlen++;
180 rpc_set_queued(task); 180 rpc_set_queued(task);
181 181
182 dprintk("RPC: %4d added to queue %p \"%s\"\n", 182 dprintk("RPC: %5u added to queue %p \"%s\"\n",
183 task->tk_pid, queue, rpc_qname(queue)); 183 task->tk_pid, queue, rpc_qname(queue));
184} 184}
185 185
186/* 186/*
@@ -212,8 +212,8 @@ static void __rpc_remove_wait_queue(struct rpc_task *task)
212 else 212 else
213 list_del(&task->u.tk_wait.list); 213 list_del(&task->u.tk_wait.list);
214 queue->qlen--; 214 queue->qlen--;
215 dprintk("RPC: %4d removed from queue %p \"%s\"\n", 215 dprintk("RPC: %5u removed from queue %p \"%s\"\n",
216 task->tk_pid, queue, rpc_qname(queue)); 216 task->tk_pid, queue, rpc_qname(queue));
217} 217}
218 218
219static inline void rpc_set_waitqueue_priority(struct rpc_wait_queue *queue, int priority) 219static inline void rpc_set_waitqueue_priority(struct rpc_wait_queue *queue, int priority)
@@ -344,8 +344,8 @@ static void rpc_make_runnable(struct rpc_task *task)
344static void __rpc_sleep_on(struct rpc_wait_queue *q, struct rpc_task *task, 344static void __rpc_sleep_on(struct rpc_wait_queue *q, struct rpc_task *task,
345 rpc_action action, rpc_action timer) 345 rpc_action action, rpc_action timer)
346{ 346{
347 dprintk("RPC: %4d sleep_on(queue \"%s\" time %ld)\n", task->tk_pid, 347 dprintk("RPC: %5u sleep_on(queue \"%s\" time %lu)\n",
348 rpc_qname(q), jiffies); 348 task->tk_pid, rpc_qname(q), jiffies);
349 349
350 if (!RPC_IS_ASYNC(task) && !RPC_IS_ACTIVATED(task)) { 350 if (!RPC_IS_ASYNC(task) && !RPC_IS_ACTIVATED(task)) {
351 printk(KERN_ERR "RPC: Inactive synchronous task put to sleep!\n"); 351 printk(KERN_ERR "RPC: Inactive synchronous task put to sleep!\n");
@@ -381,7 +381,8 @@ void rpc_sleep_on(struct rpc_wait_queue *q, struct rpc_task *task,
381 */ 381 */
382static void __rpc_do_wake_up_task(struct rpc_task *task) 382static void __rpc_do_wake_up_task(struct rpc_task *task)
383{ 383{
384 dprintk("RPC: %4d __rpc_wake_up_task (now %ld)\n", task->tk_pid, jiffies); 384 dprintk("RPC: %5u __rpc_wake_up_task (now %lu)\n",
385 task->tk_pid, jiffies);
385 386
386#ifdef RPC_DEBUG 387#ifdef RPC_DEBUG
387 BUG_ON(task->tk_magic != RPC_TASK_MAGIC_ID); 388 BUG_ON(task->tk_magic != RPC_TASK_MAGIC_ID);
@@ -397,7 +398,7 @@ static void __rpc_do_wake_up_task(struct rpc_task *task)
397 398
398 rpc_make_runnable(task); 399 rpc_make_runnable(task);
399 400
400 dprintk("RPC: __rpc_wake_up_task done\n"); 401 dprintk("RPC: __rpc_wake_up_task done\n");
401} 402}
402 403
403/* 404/*
@@ -418,7 +419,7 @@ static void __rpc_wake_up_task(struct rpc_task *task)
418static void 419static void
419__rpc_default_timer(struct rpc_task *task) 420__rpc_default_timer(struct rpc_task *task)
420{ 421{
421 dprintk("RPC: %d timeout (default timer)\n", task->tk_pid); 422 dprintk("RPC: %5u timeout (default timer)\n", task->tk_pid);
422 task->tk_status = -ETIMEDOUT; 423 task->tk_status = -ETIMEDOUT;
423 rpc_wake_up_task(task); 424 rpc_wake_up_task(task);
424} 425}
@@ -502,7 +503,8 @@ struct rpc_task * rpc_wake_up_next(struct rpc_wait_queue *queue)
502{ 503{
503 struct rpc_task *task = NULL; 504 struct rpc_task *task = NULL;
504 505
505 dprintk("RPC: wake_up_next(%p \"%s\")\n", queue, rpc_qname(queue)); 506 dprintk("RPC: wake_up_next(%p \"%s\")\n",
507 queue, rpc_qname(queue));
506 rcu_read_lock_bh(); 508 rcu_read_lock_bh();
507 spin_lock(&queue->lock); 509 spin_lock(&queue->lock);
508 if (RPC_IS_PRIORITY(queue)) 510 if (RPC_IS_PRIORITY(queue))
@@ -625,12 +627,12 @@ void rpc_release_calldata(const struct rpc_call_ops *ops, void *calldata)
625/* 627/*
626 * This is the RPC `scheduler' (or rather, the finite state machine). 628 * This is the RPC `scheduler' (or rather, the finite state machine).
627 */ 629 */
628static int __rpc_execute(struct rpc_task *task) 630static void __rpc_execute(struct rpc_task *task)
629{ 631{
630 int status = 0; 632 int status = 0;
631 633
632 dprintk("RPC: %4d rpc_execute flgs %x\n", 634 dprintk("RPC: %5u __rpc_execute flags=0x%x\n",
633 task->tk_pid, task->tk_flags); 635 task->tk_pid, task->tk_flags);
634 636
635 BUG_ON(RPC_IS_QUEUED(task)); 637 BUG_ON(RPC_IS_QUEUED(task));
636 638
@@ -679,14 +681,14 @@ static int __rpc_execute(struct rpc_task *task)
679 if (RPC_IS_ASYNC(task)) { 681 if (RPC_IS_ASYNC(task)) {
680 /* Careful! we may have raced... */ 682 /* Careful! we may have raced... */
681 if (RPC_IS_QUEUED(task)) 683 if (RPC_IS_QUEUED(task))
682 return 0; 684 return;
683 if (rpc_test_and_set_running(task)) 685 if (rpc_test_and_set_running(task))
684 return 0; 686 return;
685 continue; 687 continue;
686 } 688 }
687 689
688 /* sync task: sleep here */ 690 /* sync task: sleep here */
689 dprintk("RPC: %4d sync task going to sleep\n", task->tk_pid); 691 dprintk("RPC: %5u sync task going to sleep\n", task->tk_pid);
690 /* Note: Caller should be using rpc_clnt_sigmask() */ 692 /* Note: Caller should be using rpc_clnt_sigmask() */
691 status = out_of_line_wait_on_bit(&task->tk_runstate, 693 status = out_of_line_wait_on_bit(&task->tk_runstate,
692 RPC_TASK_QUEUED, rpc_wait_bit_interruptible, 694 RPC_TASK_QUEUED, rpc_wait_bit_interruptible,
@@ -698,19 +700,19 @@ static int __rpc_execute(struct rpc_task *task)
698 * clean up after sleeping on some queue, we don't 700 * clean up after sleeping on some queue, we don't
699 * break the loop here, but go around once more. 701 * break the loop here, but go around once more.
700 */ 702 */
701 dprintk("RPC: %4d got signal\n", task->tk_pid); 703 dprintk("RPC: %5u got signal\n", task->tk_pid);
702 task->tk_flags |= RPC_TASK_KILLED; 704 task->tk_flags |= RPC_TASK_KILLED;
703 rpc_exit(task, -ERESTARTSYS); 705 rpc_exit(task, -ERESTARTSYS);
704 rpc_wake_up_task(task); 706 rpc_wake_up_task(task);
705 } 707 }
706 rpc_set_running(task); 708 rpc_set_running(task);
707 dprintk("RPC: %4d sync task resuming\n", task->tk_pid); 709 dprintk("RPC: %5u sync task resuming\n", task->tk_pid);
708 } 710 }
709 711
710 dprintk("RPC: %4d, return %d, status %d\n", task->tk_pid, status, task->tk_status); 712 dprintk("RPC: %5u return %d, status %d\n", task->tk_pid, status,
713 task->tk_status);
711 /* Release all resources associated with the task */ 714 /* Release all resources associated with the task */
712 rpc_release_task(task); 715 rpc_release_task(task);
713 return status;
714} 716}
715 717
716/* 718/*
@@ -722,12 +724,11 @@ static int __rpc_execute(struct rpc_task *task)
722 * released. In particular note that tk_release() will have 724 * released. In particular note that tk_release() will have
723 * been called, so your task memory may have been freed. 725 * been called, so your task memory may have been freed.
724 */ 726 */
725int 727void rpc_execute(struct rpc_task *task)
726rpc_execute(struct rpc_task *task)
727{ 728{
728 rpc_set_active(task); 729 rpc_set_active(task);
729 rpc_set_running(task); 730 rpc_set_running(task);
730 return __rpc_execute(task); 731 __rpc_execute(task);
731} 732}
732 733
733static void rpc_async_schedule(struct work_struct *work) 734static void rpc_async_schedule(struct work_struct *work)
@@ -826,7 +827,7 @@ void rpc_init_task(struct rpc_task *task, struct rpc_clnt *clnt, int flags, cons
826 /* starting timestamp */ 827 /* starting timestamp */
827 task->tk_start = jiffies; 828 task->tk_start = jiffies;
828 829
829 dprintk("RPC: %4d new task procpid %d\n", task->tk_pid, 830 dprintk("RPC: new task initialized, procpid %u\n",
830 current->pid); 831 current->pid);
831} 832}
832 833
@@ -839,7 +840,7 @@ rpc_alloc_task(void)
839static void rpc_free_task(struct rcu_head *rcu) 840static void rpc_free_task(struct rcu_head *rcu)
840{ 841{
841 struct rpc_task *task = container_of(rcu, struct rpc_task, u.tk_rcu); 842 struct rpc_task *task = container_of(rcu, struct rpc_task, u.tk_rcu);
842 dprintk("RPC: %4d freeing task\n", task->tk_pid); 843 dprintk("RPC: %5u freeing task\n", task->tk_pid);
843 mempool_free(task, rpc_task_mempool); 844 mempool_free(task, rpc_task_mempool);
844} 845}
845 846
@@ -858,7 +859,7 @@ struct rpc_task *rpc_new_task(struct rpc_clnt *clnt, int flags, const struct rpc
858 859
859 rpc_init_task(task, clnt, flags, tk_ops, calldata); 860 rpc_init_task(task, clnt, flags, tk_ops, calldata);
860 861
861 dprintk("RPC: %4d allocated task\n", task->tk_pid); 862 dprintk("RPC: allocated task %p\n", task);
862 task->tk_flags |= RPC_TASK_DYNAMIC; 863 task->tk_flags |= RPC_TASK_DYNAMIC;
863out: 864out:
864 return task; 865 return task;
@@ -902,7 +903,7 @@ static void rpc_release_task(struct rpc_task *task)
902#ifdef RPC_DEBUG 903#ifdef RPC_DEBUG
903 BUG_ON(task->tk_magic != RPC_TASK_MAGIC_ID); 904 BUG_ON(task->tk_magic != RPC_TASK_MAGIC_ID);
904#endif 905#endif
905 dprintk("RPC: %4d release task\n", task->tk_pid); 906 dprintk("RPC: %5u release task\n", task->tk_pid);
906 907
907 /* Remove from global task list */ 908 /* Remove from global task list */
908 spin_lock(&rpc_sched_lock); 909 spin_lock(&rpc_sched_lock);
@@ -955,7 +956,7 @@ void rpc_killall_tasks(struct rpc_clnt *clnt)
955 struct rpc_task *rovr; 956 struct rpc_task *rovr;
956 struct list_head *le; 957 struct list_head *le;
957 958
958 dprintk("RPC: killing all tasks for client %p\n", clnt); 959 dprintk("RPC: killing all tasks for client %p\n", clnt);
959 960
960 /* 961 /*
961 * Spin lock all_tasks to prevent changes... 962 * Spin lock all_tasks to prevent changes...
@@ -984,7 +985,8 @@ static void rpciod_killall(void)
984 rpc_killall_tasks(NULL); 985 rpc_killall_tasks(NULL);
985 flush_workqueue(rpciod_workqueue); 986 flush_workqueue(rpciod_workqueue);
986 if (!list_empty(&all_tasks)) { 987 if (!list_empty(&all_tasks)) {
987 dprintk("rpciod_killall: waiting for tasks to exit\n"); 988 dprintk("RPC: rpciod_killall: waiting for tasks "
989 "to exit\n");
988 yield(); 990 yield();
989 } 991 }
990 } 992 }
@@ -1004,7 +1006,7 @@ rpciod_up(void)
1004 int error = 0; 1006 int error = 0;
1005 1007
1006 mutex_lock(&rpciod_mutex); 1008 mutex_lock(&rpciod_mutex);
1007 dprintk("rpciod_up: users %d\n", rpciod_users); 1009 dprintk("RPC: rpciod_up: users %u\n", rpciod_users);
1008 rpciod_users++; 1010 rpciod_users++;
1009 if (rpciod_workqueue) 1011 if (rpciod_workqueue)
1010 goto out; 1012 goto out;
@@ -1012,7 +1014,7 @@ rpciod_up(void)
1012 * If there's no pid, we should be the first user. 1014 * If there's no pid, we should be the first user.
1013 */ 1015 */
1014 if (rpciod_users > 1) 1016 if (rpciod_users > 1)
1015 printk(KERN_WARNING "rpciod_up: no workqueue, %d users??\n", rpciod_users); 1017 printk(KERN_WARNING "rpciod_up: no workqueue, %u users??\n", rpciod_users);
1016 /* 1018 /*
1017 * Create the rpciod thread and wait for it to start. 1019 * Create the rpciod thread and wait for it to start.
1018 */ 1020 */
@@ -1034,7 +1036,7 @@ void
1034rpciod_down(void) 1036rpciod_down(void)
1035{ 1037{
1036 mutex_lock(&rpciod_mutex); 1038 mutex_lock(&rpciod_mutex);
1037 dprintk("rpciod_down sema %d\n", rpciod_users); 1039 dprintk("RPC: rpciod_down sema %u\n", rpciod_users);
1038 if (rpciod_users) { 1040 if (rpciod_users) {
1039 if (--rpciod_users) 1041 if (--rpciod_users)
1040 goto out; 1042 goto out;
@@ -1042,7 +1044,7 @@ rpciod_down(void)
1042 printk(KERN_WARNING "rpciod_down: no users??\n"); 1044 printk(KERN_WARNING "rpciod_down: no users??\n");
1043 1045
1044 if (!rpciod_workqueue) { 1046 if (!rpciod_workqueue) {
1045 dprintk("rpciod_down: Nothing to do!\n"); 1047 dprintk("RPC: rpciod_down: Nothing to do!\n");
1046 goto out; 1048 goto out;
1047 } 1049 }
1048 rpciod_killall(); 1050 rpciod_killall();
@@ -1072,7 +1074,7 @@ void rpc_show_tasks(void)
1072 if (RPC_IS_QUEUED(t)) 1074 if (RPC_IS_QUEUED(t))
1073 rpc_waitq = rpc_qname(t->u.tk_wait.rpc_waitq); 1075 rpc_waitq = rpc_qname(t->u.tk_wait.rpc_waitq);
1074 1076
1075 printk("%05d %04d %04x %06d %8p %6d %8p %08ld %8s %8p %8p\n", 1077 printk("%5u %04d %04x %6d %8p %6d %8p %8ld %8s %8p %8p\n",
1076 t->tk_pid, 1078 t->tk_pid,
1077 (t->tk_msg.rpc_proc ? t->tk_msg.rpc_proc->p_proc : -1), 1079 (t->tk_msg.rpc_proc ? t->tk_msg.rpc_proc->p_proc : -1),
1078 t->tk_flags, t->tk_status, 1080 t->tk_flags, t->tk_status,
diff --git a/net/sunrpc/stats.c b/net/sunrpc/stats.c
index 044d9484bb8c..2878e20ebd04 100644
--- a/net/sunrpc/stats.c
+++ b/net/sunrpc/stats.c
@@ -226,7 +226,7 @@ do_register(const char *name, void *data, const struct file_operations *fops)
226 struct proc_dir_entry *ent; 226 struct proc_dir_entry *ent;
227 227
228 rpc_proc_init(); 228 rpc_proc_init();
229 dprintk("RPC: registering /proc/net/rpc/%s\n", name); 229 dprintk("RPC: registering /proc/net/rpc/%s\n", name);
230 230
231 ent = create_proc_entry(name, 0, proc_net_rpc); 231 ent = create_proc_entry(name, 0, proc_net_rpc);
232 if (ent) { 232 if (ent) {
@@ -263,7 +263,7 @@ svc_proc_unregister(const char *name)
263void 263void
264rpc_proc_init(void) 264rpc_proc_init(void)
265{ 265{
266 dprintk("RPC: registering /proc/net/rpc\n"); 266 dprintk("RPC: registering /proc/net/rpc\n");
267 if (!proc_net_rpc) { 267 if (!proc_net_rpc) {
268 struct proc_dir_entry *ent; 268 struct proc_dir_entry *ent;
269 ent = proc_mkdir("rpc", proc_net); 269 ent = proc_mkdir("rpc", proc_net);
@@ -277,7 +277,7 @@ rpc_proc_init(void)
277void 277void
278rpc_proc_exit(void) 278rpc_proc_exit(void)
279{ 279{
280 dprintk("RPC: unregistering /proc/net/rpc\n"); 280 dprintk("RPC: unregistering /proc/net/rpc\n");
281 if (proc_net_rpc) { 281 if (proc_net_rpc) {
282 proc_net_rpc = NULL; 282 proc_net_rpc = NULL;
283 remove_proc_entry("net/rpc", NULL); 283 remove_proc_entry("net/rpc", NULL);
diff --git a/net/sunrpc/svc.c b/net/sunrpc/svc.c
index b00511d39b65..4ab137403e1a 100644
--- a/net/sunrpc/svc.c
+++ b/net/sunrpc/svc.c
@@ -317,7 +317,7 @@ __svc_create(struct svc_program *prog, unsigned int bufsize, int npools,
317 for (i = 0; i < serv->sv_nrpools; i++) { 317 for (i = 0; i < serv->sv_nrpools; i++) {
318 struct svc_pool *pool = &serv->sv_pools[i]; 318 struct svc_pool *pool = &serv->sv_pools[i];
319 319
320 dprintk("initialising pool %u for %s\n", 320 dprintk("svc: initialising pool %u for %s\n",
321 i, serv->sv_name); 321 i, serv->sv_name);
322 322
323 pool->sp_id = i; 323 pool->sp_id = i;
@@ -368,7 +368,7 @@ svc_destroy(struct svc_serv *serv)
368{ 368{
369 struct svc_sock *svsk; 369 struct svc_sock *svsk;
370 370
371 dprintk("RPC: svc_destroy(%s, %d)\n", 371 dprintk("svc: svc_destroy(%s, %d)\n",
372 serv->sv_program->pg_name, 372 serv->sv_program->pg_name,
373 serv->sv_nrthreads); 373 serv->sv_nrthreads);
374 374
@@ -654,7 +654,7 @@ svc_register(struct svc_serv *serv, int proto, unsigned short port)
654 if (progp->pg_vers[i] == NULL) 654 if (progp->pg_vers[i] == NULL)
655 continue; 655 continue;
656 656
657 dprintk("RPC: svc_register(%s, %s, %d, %d)%s\n", 657 dprintk("svc: svc_register(%s, %s, %d, %d)%s\n",
658 progp->pg_name, 658 progp->pg_name,
659 proto == IPPROTO_UDP? "udp" : "tcp", 659 proto == IPPROTO_UDP? "udp" : "tcp",
660 port, 660 port,
diff --git a/net/sunrpc/xprt.c b/net/sunrpc/xprt.c
index e7c71a1ea3d4..ee6ffa01dfb1 100644
--- a/net/sunrpc/xprt.c
+++ b/net/sunrpc/xprt.c
@@ -108,7 +108,7 @@ int xprt_reserve_xprt(struct rpc_task *task)
108 return 1; 108 return 1;
109 109
110out_sleep: 110out_sleep:
111 dprintk("RPC: %4d failed to lock transport %p\n", 111 dprintk("RPC: %5u failed to lock transport %p\n",
112 task->tk_pid, xprt); 112 task->tk_pid, xprt);
113 task->tk_timeout = 0; 113 task->tk_timeout = 0;
114 task->tk_status = -EAGAIN; 114 task->tk_status = -EAGAIN;
@@ -158,7 +158,7 @@ int xprt_reserve_xprt_cong(struct rpc_task *task)
158 } 158 }
159 xprt_clear_locked(xprt); 159 xprt_clear_locked(xprt);
160out_sleep: 160out_sleep:
161 dprintk("RPC: %4d failed to lock transport %p\n", task->tk_pid, xprt); 161 dprintk("RPC: %5u failed to lock transport %p\n", task->tk_pid, xprt);
162 task->tk_timeout = 0; 162 task->tk_timeout = 0;
163 task->tk_status = -EAGAIN; 163 task->tk_status = -EAGAIN;
164 if (req && req->rq_ntrans) 164 if (req && req->rq_ntrans)
@@ -281,7 +281,7 @@ __xprt_get_cong(struct rpc_xprt *xprt, struct rpc_task *task)
281 281
282 if (req->rq_cong) 282 if (req->rq_cong)
283 return 1; 283 return 1;
284 dprintk("RPC: %4d xprt_cwnd_limited cong = %ld cwnd = %ld\n", 284 dprintk("RPC: %5u xprt_cwnd_limited cong = %lu cwnd = %lu\n",
285 task->tk_pid, xprt->cong, xprt->cwnd); 285 task->tk_pid, xprt->cong, xprt->cwnd);
286 if (RPCXPRT_CONGESTED(xprt)) 286 if (RPCXPRT_CONGESTED(xprt))
287 return 0; 287 return 0;
@@ -340,7 +340,7 @@ void xprt_adjust_cwnd(struct rpc_task *task, int result)
340 if (cwnd < RPC_CWNDSCALE) 340 if (cwnd < RPC_CWNDSCALE)
341 cwnd = RPC_CWNDSCALE; 341 cwnd = RPC_CWNDSCALE;
342 } 342 }
343 dprintk("RPC: cong %ld, cwnd was %ld, now %ld\n", 343 dprintk("RPC: cong %ld, cwnd was %ld, now %ld\n",
344 xprt->cong, xprt->cwnd, cwnd); 344 xprt->cong, xprt->cwnd, cwnd);
345 xprt->cwnd = cwnd; 345 xprt->cwnd = cwnd;
346 __xprt_put_cong(xprt, req); 346 __xprt_put_cong(xprt, req);
@@ -387,8 +387,8 @@ void xprt_write_space(struct rpc_xprt *xprt)
387 387
388 spin_lock_bh(&xprt->transport_lock); 388 spin_lock_bh(&xprt->transport_lock);
389 if (xprt->snd_task) { 389 if (xprt->snd_task) {
390 dprintk("RPC: write space: waking waiting task on xprt %p\n", 390 dprintk("RPC: write space: waking waiting task on "
391 xprt); 391 "xprt %p\n", xprt);
392 rpc_wake_up_task(xprt->snd_task); 392 rpc_wake_up_task(xprt->snd_task);
393 } 393 }
394 spin_unlock_bh(&xprt->transport_lock); 394 spin_unlock_bh(&xprt->transport_lock);
@@ -494,7 +494,7 @@ static void xprt_autoclose(struct work_struct *work)
494 */ 494 */
495void xprt_disconnect(struct rpc_xprt *xprt) 495void xprt_disconnect(struct rpc_xprt *xprt)
496{ 496{
497 dprintk("RPC: disconnected transport %p\n", xprt); 497 dprintk("RPC: disconnected transport %p\n", xprt);
498 spin_lock_bh(&xprt->transport_lock); 498 spin_lock_bh(&xprt->transport_lock);
499 xprt_clear_connected(xprt); 499 xprt_clear_connected(xprt);
500 xprt_wake_pending_tasks(xprt, -ENOTCONN); 500 xprt_wake_pending_tasks(xprt, -ENOTCONN);
@@ -530,7 +530,7 @@ void xprt_connect(struct rpc_task *task)
530{ 530{
531 struct rpc_xprt *xprt = task->tk_xprt; 531 struct rpc_xprt *xprt = task->tk_xprt;
532 532
533 dprintk("RPC: %4d xprt_connect xprt %p %s connected\n", task->tk_pid, 533 dprintk("RPC: %5u xprt_connect xprt %p %s connected\n", task->tk_pid,
534 xprt, (xprt_connected(xprt) ? "is" : "is not")); 534 xprt, (xprt_connected(xprt) ? "is" : "is not"));
535 535
536 if (!xprt_bound(xprt)) { 536 if (!xprt_bound(xprt)) {
@@ -560,7 +560,7 @@ static void xprt_connect_status(struct rpc_task *task)
560 if (task->tk_status >= 0) { 560 if (task->tk_status >= 0) {
561 xprt->stat.connect_count++; 561 xprt->stat.connect_count++;
562 xprt->stat.connect_time += (long)jiffies - xprt->stat.connect_start; 562 xprt->stat.connect_time += (long)jiffies - xprt->stat.connect_start;
563 dprintk("RPC: %4d xprt_connect_status: connection established\n", 563 dprintk("RPC: %5u xprt_connect_status: connection established\n",
564 task->tk_pid); 564 task->tk_pid);
565 return; 565 return;
566 } 566 }
@@ -568,20 +568,22 @@ static void xprt_connect_status(struct rpc_task *task)
568 switch (task->tk_status) { 568 switch (task->tk_status) {
569 case -ECONNREFUSED: 569 case -ECONNREFUSED:
570 case -ECONNRESET: 570 case -ECONNRESET:
571 dprintk("RPC: %4d xprt_connect_status: server %s refused connection\n", 571 dprintk("RPC: %5u xprt_connect_status: server %s refused "
572 task->tk_pid, task->tk_client->cl_server); 572 "connection\n", task->tk_pid,
573 task->tk_client->cl_server);
573 break; 574 break;
574 case -ENOTCONN: 575 case -ENOTCONN:
575 dprintk("RPC: %4d xprt_connect_status: connection broken\n", 576 dprintk("RPC: %5u xprt_connect_status: connection broken\n",
576 task->tk_pid); 577 task->tk_pid);
577 break; 578 break;
578 case -ETIMEDOUT: 579 case -ETIMEDOUT:
579 dprintk("RPC: %4d xprt_connect_status: connect attempt timed out\n", 580 dprintk("RPC: %5u xprt_connect_status: connect attempt timed "
580 task->tk_pid); 581 "out\n", task->tk_pid);
581 break; 582 break;
582 default: 583 default:
583 dprintk("RPC: %4d xprt_connect_status: error %d connecting to server %s\n", 584 dprintk("RPC: %5u xprt_connect_status: error %d connecting to "
584 task->tk_pid, -task->tk_status, task->tk_client->cl_server); 585 "server %s\n", task->tk_pid, -task->tk_status,
586 task->tk_client->cl_server);
585 xprt_release_write(xprt, task); 587 xprt_release_write(xprt, task);
586 task->tk_status = -EIO; 588 task->tk_status = -EIO;
587 } 589 }
@@ -602,6 +604,9 @@ struct rpc_rqst *xprt_lookup_rqst(struct rpc_xprt *xprt, __be32 xid)
602 if (entry->rq_xid == xid) 604 if (entry->rq_xid == xid)
603 return entry; 605 return entry;
604 } 606 }
607
608 dprintk("RPC: xprt_lookup_rqst did not find xid %08x\n",
609 ntohl(xid));
605 xprt->stat.bad_xids++; 610 xprt->stat.bad_xids++;
606 return NULL; 611 return NULL;
607} 612}
@@ -654,7 +659,7 @@ static void xprt_timer(struct rpc_task *task)
654 struct rpc_rqst *req = task->tk_rqstp; 659 struct rpc_rqst *req = task->tk_rqstp;
655 struct rpc_xprt *xprt = req->rq_xprt; 660 struct rpc_xprt *xprt = req->rq_xprt;
656 661
657 dprintk("RPC: %4d xprt_timer\n", task->tk_pid); 662 dprintk("RPC: %5u xprt_timer\n", task->tk_pid);
658 663
659 spin_lock(&xprt->transport_lock); 664 spin_lock(&xprt->transport_lock);
660 if (!req->rq_received) { 665 if (!req->rq_received) {
@@ -678,7 +683,7 @@ int xprt_prepare_transmit(struct rpc_task *task)
678 struct rpc_xprt *xprt = req->rq_xprt; 683 struct rpc_xprt *xprt = req->rq_xprt;
679 int err = 0; 684 int err = 0;
680 685
681 dprintk("RPC: %4d xprt_prepare_transmit\n", task->tk_pid); 686 dprintk("RPC: %5u xprt_prepare_transmit\n", task->tk_pid);
682 687
683 spin_lock_bh(&xprt->transport_lock); 688 spin_lock_bh(&xprt->transport_lock);
684 if (req->rq_received && !req->rq_bytes_sent) { 689 if (req->rq_received && !req->rq_bytes_sent) {
@@ -716,7 +721,7 @@ void xprt_transmit(struct rpc_task *task)
716 struct rpc_xprt *xprt = req->rq_xprt; 721 struct rpc_xprt *xprt = req->rq_xprt;
717 int status; 722 int status;
718 723
719 dprintk("RPC: %4d xprt_transmit(%u)\n", task->tk_pid, req->rq_slen); 724 dprintk("RPC: %5u xprt_transmit(%u)\n", task->tk_pid, req->rq_slen);
720 725
721 if (!req->rq_received) { 726 if (!req->rq_received) {
722 if (list_empty(&req->rq_list)) { 727 if (list_empty(&req->rq_list)) {
@@ -730,13 +735,23 @@ void xprt_transmit(struct rpc_task *task)
730 xprt_reset_majortimeo(req); 735 xprt_reset_majortimeo(req);
731 /* Turn off autodisconnect */ 736 /* Turn off autodisconnect */
732 del_singleshot_timer_sync(&xprt->timer); 737 del_singleshot_timer_sync(&xprt->timer);
738 } else {
739 /* If all request bytes have been sent,
740 * then we must be retransmitting this one */
741 if (!req->rq_bytes_sent) {
742 if (task->tk_client->cl_discrtry) {
743 xprt_disconnect(xprt);
744 task->tk_status = -ENOTCONN;
745 return;
746 }
747 }
733 } 748 }
734 } else if (!req->rq_bytes_sent) 749 } else if (!req->rq_bytes_sent)
735 return; 750 return;
736 751
737 status = xprt->ops->send_request(task); 752 status = xprt->ops->send_request(task);
738 if (status == 0) { 753 if (status == 0) {
739 dprintk("RPC: %4d xmit complete\n", task->tk_pid); 754 dprintk("RPC: %5u xmit complete\n", task->tk_pid);
740 spin_lock_bh(&xprt->transport_lock); 755 spin_lock_bh(&xprt->transport_lock);
741 756
742 xprt->ops->set_retrans_timeout(task); 757 xprt->ops->set_retrans_timeout(task);
@@ -777,7 +792,7 @@ static inline void do_xprt_reserve(struct rpc_task *task)
777 xprt_request_init(task, xprt); 792 xprt_request_init(task, xprt);
778 return; 793 return;
779 } 794 }
780 dprintk("RPC: waiting for request slot\n"); 795 dprintk("RPC: waiting for request slot\n");
781 task->tk_status = -EAGAIN; 796 task->tk_status = -EAGAIN;
782 task->tk_timeout = 0; 797 task->tk_timeout = 0;
783 rpc_sleep_on(&xprt->backlog, task, NULL, NULL); 798 rpc_sleep_on(&xprt->backlog, task, NULL, NULL);
@@ -822,7 +837,7 @@ static void xprt_request_init(struct rpc_task *task, struct rpc_xprt *xprt)
822 req->rq_xid = xprt_alloc_xid(xprt); 837 req->rq_xid = xprt_alloc_xid(xprt);
823 req->rq_release_snd_buf = NULL; 838 req->rq_release_snd_buf = NULL;
824 xprt_reset_majortimeo(req); 839 xprt_reset_majortimeo(req);
825 dprintk("RPC: %4d reserved req %p xid %08x\n", task->tk_pid, 840 dprintk("RPC: %5u reserved req %p xid %08x\n", task->tk_pid,
826 req, ntohl(req->rq_xid)); 841 req, ntohl(req->rq_xid));
827} 842}
828 843
@@ -856,7 +871,7 @@ void xprt_release(struct rpc_task *task)
856 req->rq_release_snd_buf(req); 871 req->rq_release_snd_buf(req);
857 memset(req, 0, sizeof(*req)); /* mark unused */ 872 memset(req, 0, sizeof(*req)); /* mark unused */
858 873
859 dprintk("RPC: %4d release request %p\n", task->tk_pid, req); 874 dprintk("RPC: %5u release request %p\n", task->tk_pid, req);
860 875
861 spin_lock(&xprt->reserve_lock); 876 spin_lock(&xprt->reserve_lock);
862 list_add(&req->rq_list, &xprt->free); 877 list_add(&req->rq_list, &xprt->free);
@@ -906,7 +921,7 @@ struct rpc_xprt *xprt_create_transport(int proto, struct sockaddr *ap, size_t si
906 return ERR_PTR(-EIO); 921 return ERR_PTR(-EIO);
907 } 922 }
908 if (IS_ERR(xprt)) { 923 if (IS_ERR(xprt)) {
909 dprintk("RPC: xprt_create_transport: failed, %ld\n", 924 dprintk("RPC: xprt_create_transport: failed, %ld\n",
910 -PTR_ERR(xprt)); 925 -PTR_ERR(xprt));
911 return xprt; 926 return xprt;
912 } 927 }
@@ -936,7 +951,7 @@ struct rpc_xprt *xprt_create_transport(int proto, struct sockaddr *ap, size_t si
936 951
937 xprt_init_xid(xprt); 952 xprt_init_xid(xprt);
938 953
939 dprintk("RPC: created transport %p with %u slots\n", xprt, 954 dprintk("RPC: created transport %p with %u slots\n", xprt,
940 xprt->max_reqs); 955 xprt->max_reqs);
941 956
942 return xprt; 957 return xprt;
@@ -951,7 +966,7 @@ static void xprt_destroy(struct kref *kref)
951{ 966{
952 struct rpc_xprt *xprt = container_of(kref, struct rpc_xprt, kref); 967 struct rpc_xprt *xprt = container_of(kref, struct rpc_xprt, kref);
953 968
954 dprintk("RPC: destroying transport %p\n", xprt); 969 dprintk("RPC: destroying transport %p\n", xprt);
955 xprt->shutdown = 1; 970 xprt->shutdown = 1;
956 del_timer_sync(&xprt->timer); 971 del_timer_sync(&xprt->timer);
957 972
diff --git a/net/sunrpc/xprtsock.c b/net/sunrpc/xprtsock.c
index 49cabffd7fdb..64736b3a59a7 100644
--- a/net/sunrpc/xprtsock.c
+++ b/net/sunrpc/xprtsock.c
@@ -192,7 +192,7 @@ static void xs_pktdump(char *msg, u32 *packet, unsigned int count)
192 u8 *buf = (u8 *) packet; 192 u8 *buf = (u8 *) packet;
193 int j; 193 int j;
194 194
195 dprintk("RPC: %s\n", msg); 195 dprintk("RPC: %s\n", msg);
196 for (j = 0; j < count && j < 128; j += 4) { 196 for (j = 0; j < count && j < 128; j += 4) {
197 if (!(j & 31)) { 197 if (!(j & 31)) {
198 if (j) 198 if (j)
@@ -418,7 +418,7 @@ static void xs_nospace(struct rpc_task *task)
418 struct rpc_xprt *xprt = req->rq_xprt; 418 struct rpc_xprt *xprt = req->rq_xprt;
419 struct sock_xprt *transport = container_of(xprt, struct sock_xprt, xprt); 419 struct sock_xprt *transport = container_of(xprt, struct sock_xprt, xprt);
420 420
421 dprintk("RPC: %4d xmit incomplete (%u left of %u)\n", 421 dprintk("RPC: %5u xmit incomplete (%u left of %u)\n",
422 task->tk_pid, req->rq_slen - req->rq_bytes_sent, 422 task->tk_pid, req->rq_slen - req->rq_bytes_sent,
423 req->rq_slen); 423 req->rq_slen);
424 424
@@ -467,7 +467,7 @@ static int xs_udp_send_request(struct rpc_task *task)
467 xprt->addrlen, xdr, 467 xprt->addrlen, xdr,
468 req->rq_bytes_sent); 468 req->rq_bytes_sent);
469 469
470 dprintk("RPC: xs_udp_send_request(%u) = %d\n", 470 dprintk("RPC: xs_udp_send_request(%u) = %d\n",
471 xdr->len - req->rq_bytes_sent, status); 471 xdr->len - req->rq_bytes_sent, status);
472 472
473 if (likely(status >= (int) req->rq_slen)) 473 if (likely(status >= (int) req->rq_slen))
@@ -488,7 +488,7 @@ static int xs_udp_send_request(struct rpc_task *task)
488 xs_nospace(task); 488 xs_nospace(task);
489 break; 489 break;
490 default: 490 default:
491 dprintk("RPC: sendmsg returned unrecognized error %d\n", 491 dprintk("RPC: sendmsg returned unrecognized error %d\n",
492 -status); 492 -status);
493 break; 493 break;
494 } 494 }
@@ -539,7 +539,7 @@ static int xs_tcp_send_request(struct rpc_task *task)
539 status = xs_sendpages(transport->sock, 539 status = xs_sendpages(transport->sock,
540 NULL, 0, xdr, req->rq_bytes_sent); 540 NULL, 0, xdr, req->rq_bytes_sent);
541 541
542 dprintk("RPC: xs_tcp_send_request(%u) = %d\n", 542 dprintk("RPC: xs_tcp_send_request(%u) = %d\n",
543 xdr->len - req->rq_bytes_sent, status); 543 xdr->len - req->rq_bytes_sent, status);
544 544
545 if (unlikely(status < 0)) 545 if (unlikely(status < 0))
@@ -570,7 +570,7 @@ static int xs_tcp_send_request(struct rpc_task *task)
570 status = -ENOTCONN; 570 status = -ENOTCONN;
571 break; 571 break;
572 default: 572 default:
573 dprintk("RPC: sendmsg returned unrecognized error %d\n", 573 dprintk("RPC: sendmsg returned unrecognized error %d\n",
574 -status); 574 -status);
575 xprt_disconnect(xprt); 575 xprt_disconnect(xprt);
576 break; 576 break;
@@ -622,7 +622,7 @@ static void xs_close(struct rpc_xprt *xprt)
622 if (!sk) 622 if (!sk)
623 goto clear_close_wait; 623 goto clear_close_wait;
624 624
625 dprintk("RPC: xs_close xprt %p\n", xprt); 625 dprintk("RPC: xs_close xprt %p\n", xprt);
626 626
627 write_lock_bh(&sk->sk_callback_lock); 627 write_lock_bh(&sk->sk_callback_lock);
628 transport->inet = NULL; 628 transport->inet = NULL;
@@ -652,7 +652,7 @@ static void xs_destroy(struct rpc_xprt *xprt)
652{ 652{
653 struct sock_xprt *transport = container_of(xprt, struct sock_xprt, xprt); 653 struct sock_xprt *transport = container_of(xprt, struct sock_xprt, xprt);
654 654
655 dprintk("RPC: xs_destroy xprt %p\n", xprt); 655 dprintk("RPC: xs_destroy xprt %p\n", xprt);
656 656
657 cancel_delayed_work(&transport->connect_worker); 657 cancel_delayed_work(&transport->connect_worker);
658 flush_scheduled_work(); 658 flush_scheduled_work();
@@ -686,7 +686,7 @@ static void xs_udp_data_ready(struct sock *sk, int len)
686 __be32 *xp; 686 __be32 *xp;
687 687
688 read_lock(&sk->sk_callback_lock); 688 read_lock(&sk->sk_callback_lock);
689 dprintk("RPC: xs_udp_data_ready...\n"); 689 dprintk("RPC: xs_udp_data_ready...\n");
690 if (!(xprt = xprt_from_sock(sk))) 690 if (!(xprt = xprt_from_sock(sk)))
691 goto out; 691 goto out;
692 692
@@ -698,7 +698,7 @@ static void xs_udp_data_ready(struct sock *sk, int len)
698 698
699 repsize = skb->len - sizeof(struct udphdr); 699 repsize = skb->len - sizeof(struct udphdr);
700 if (repsize < 4) { 700 if (repsize < 4) {
701 dprintk("RPC: impossible RPC reply size %d!\n", repsize); 701 dprintk("RPC: impossible RPC reply size %d!\n", repsize);
702 goto dropit; 702 goto dropit;
703 } 703 }
704 704
@@ -762,11 +762,11 @@ static inline void xs_tcp_read_fraghdr(struct rpc_xprt *xprt, struct xdr_skb_rea
762 762
763 /* Sanity check of the record length */ 763 /* Sanity check of the record length */
764 if (unlikely(transport->tcp_reclen < 4)) { 764 if (unlikely(transport->tcp_reclen < 4)) {
765 dprintk("RPC: invalid TCP record fragment length\n"); 765 dprintk("RPC: invalid TCP record fragment length\n");
766 xprt_disconnect(xprt); 766 xprt_disconnect(xprt);
767 return; 767 return;
768 } 768 }
769 dprintk("RPC: reading TCP record fragment of length %d\n", 769 dprintk("RPC: reading TCP record fragment of length %d\n",
770 transport->tcp_reclen); 770 transport->tcp_reclen);
771} 771}
772 772
@@ -789,7 +789,7 @@ static inline void xs_tcp_read_xid(struct sock_xprt *transport, struct xdr_skb_r
789 char *p; 789 char *p;
790 790
791 len = sizeof(transport->tcp_xid) - transport->tcp_offset; 791 len = sizeof(transport->tcp_xid) - transport->tcp_offset;
792 dprintk("RPC: reading XID (%Zu bytes)\n", len); 792 dprintk("RPC: reading XID (%Zu bytes)\n", len);
793 p = ((char *) &transport->tcp_xid) + transport->tcp_offset; 793 p = ((char *) &transport->tcp_xid) + transport->tcp_offset;
794 used = xdr_skb_read_bits(desc, p, len); 794 used = xdr_skb_read_bits(desc, p, len);
795 transport->tcp_offset += used; 795 transport->tcp_offset += used;
@@ -798,7 +798,7 @@ static inline void xs_tcp_read_xid(struct sock_xprt *transport, struct xdr_skb_r
798 transport->tcp_flags &= ~TCP_RCV_COPY_XID; 798 transport->tcp_flags &= ~TCP_RCV_COPY_XID;
799 transport->tcp_flags |= TCP_RCV_COPY_DATA; 799 transport->tcp_flags |= TCP_RCV_COPY_DATA;
800 transport->tcp_copied = 4; 800 transport->tcp_copied = 4;
801 dprintk("RPC: reading reply for XID %08x\n", 801 dprintk("RPC: reading reply for XID %08x\n",
802 ntohl(transport->tcp_xid)); 802 ntohl(transport->tcp_xid));
803 xs_tcp_check_fraghdr(transport); 803 xs_tcp_check_fraghdr(transport);
804} 804}
@@ -816,7 +816,7 @@ static inline void xs_tcp_read_request(struct rpc_xprt *xprt, struct xdr_skb_rea
816 req = xprt_lookup_rqst(xprt, transport->tcp_xid); 816 req = xprt_lookup_rqst(xprt, transport->tcp_xid);
817 if (!req) { 817 if (!req) {
818 transport->tcp_flags &= ~TCP_RCV_COPY_DATA; 818 transport->tcp_flags &= ~TCP_RCV_COPY_DATA;
819 dprintk("RPC: XID %08x request not found!\n", 819 dprintk("RPC: XID %08x request not found!\n",
820 ntohl(transport->tcp_xid)); 820 ntohl(transport->tcp_xid));
821 spin_unlock(&xprt->transport_lock); 821 spin_unlock(&xprt->transport_lock);
822 return; 822 return;
@@ -853,19 +853,20 @@ static inline void xs_tcp_read_request(struct rpc_xprt *xprt, struct xdr_skb_rea
853 * be discarded. 853 * be discarded.
854 */ 854 */
855 transport->tcp_flags &= ~TCP_RCV_COPY_DATA; 855 transport->tcp_flags &= ~TCP_RCV_COPY_DATA;
856 dprintk("RPC: XID %08x truncated request\n", 856 dprintk("RPC: XID %08x truncated request\n",
857 ntohl(transport->tcp_xid)); 857 ntohl(transport->tcp_xid));
858 dprintk("RPC: xprt = %p, tcp_copied = %lu, tcp_offset = %u, tcp_reclen = %u\n", 858 dprintk("RPC: xprt = %p, tcp_copied = %lu, "
859 xprt, transport->tcp_copied, transport->tcp_offset, 859 "tcp_offset = %u, tcp_reclen = %u\n",
860 transport->tcp_reclen); 860 xprt, transport->tcp_copied,
861 transport->tcp_offset, transport->tcp_reclen);
861 goto out; 862 goto out;
862 } 863 }
863 864
864 dprintk("RPC: XID %08x read %Zd bytes\n", 865 dprintk("RPC: XID %08x read %Zd bytes\n",
865 ntohl(transport->tcp_xid), r); 866 ntohl(transport->tcp_xid), r);
866 dprintk("RPC: xprt = %p, tcp_copied = %lu, tcp_offset = %u, tcp_reclen = %u\n", 867 dprintk("RPC: xprt = %p, tcp_copied = %lu, tcp_offset = %u, "
867 xprt, transport->tcp_copied, transport->tcp_offset, 868 "tcp_reclen = %u\n", xprt, transport->tcp_copied,
868 transport->tcp_reclen); 869 transport->tcp_offset, transport->tcp_reclen);
869 870
870 if (transport->tcp_copied == req->rq_private_buf.buflen) 871 if (transport->tcp_copied == req->rq_private_buf.buflen)
871 transport->tcp_flags &= ~TCP_RCV_COPY_DATA; 872 transport->tcp_flags &= ~TCP_RCV_COPY_DATA;
@@ -891,7 +892,7 @@ static inline void xs_tcp_read_discard(struct sock_xprt *transport, struct xdr_s
891 desc->count -= len; 892 desc->count -= len;
892 desc->offset += len; 893 desc->offset += len;
893 transport->tcp_offset += len; 894 transport->tcp_offset += len;
894 dprintk("RPC: discarded %Zu bytes\n", len); 895 dprintk("RPC: discarded %Zu bytes\n", len);
895 xs_tcp_check_fraghdr(transport); 896 xs_tcp_check_fraghdr(transport);
896} 897}
897 898
@@ -905,7 +906,7 @@ static int xs_tcp_data_recv(read_descriptor_t *rd_desc, struct sk_buff *skb, uns
905 .count = len, 906 .count = len,
906 }; 907 };
907 908
908 dprintk("RPC: xs_tcp_data_recv started\n"); 909 dprintk("RPC: xs_tcp_data_recv started\n");
909 do { 910 do {
910 /* Read in a new fragment marker if necessary */ 911 /* Read in a new fragment marker if necessary */
911 /* Can we ever really expect to get completely empty fragments? */ 912 /* Can we ever really expect to get completely empty fragments? */
@@ -926,7 +927,7 @@ static int xs_tcp_data_recv(read_descriptor_t *rd_desc, struct sk_buff *skb, uns
926 /* Skip over any trailing bytes on short reads */ 927 /* Skip over any trailing bytes on short reads */
927 xs_tcp_read_discard(transport, &desc); 928 xs_tcp_read_discard(transport, &desc);
928 } while (desc.count); 929 } while (desc.count);
929 dprintk("RPC: xs_tcp_data_recv done\n"); 930 dprintk("RPC: xs_tcp_data_recv done\n");
930 return len - desc.count; 931 return len - desc.count;
931} 932}
932 933
@@ -941,8 +942,9 @@ static void xs_tcp_data_ready(struct sock *sk, int bytes)
941 struct rpc_xprt *xprt; 942 struct rpc_xprt *xprt;
942 read_descriptor_t rd_desc; 943 read_descriptor_t rd_desc;
943 944
945 dprintk("RPC: xs_tcp_data_ready...\n");
946
944 read_lock(&sk->sk_callback_lock); 947 read_lock(&sk->sk_callback_lock);
945 dprintk("RPC: xs_tcp_data_ready...\n");
946 if (!(xprt = xprt_from_sock(sk))) 948 if (!(xprt = xprt_from_sock(sk)))
947 goto out; 949 goto out;
948 if (xprt->shutdown) 950 if (xprt->shutdown)
@@ -968,11 +970,11 @@ static void xs_tcp_state_change(struct sock *sk)
968 read_lock(&sk->sk_callback_lock); 970 read_lock(&sk->sk_callback_lock);
969 if (!(xprt = xprt_from_sock(sk))) 971 if (!(xprt = xprt_from_sock(sk)))
970 goto out; 972 goto out;
971 dprintk("RPC: xs_tcp_state_change client %p...\n", xprt); 973 dprintk("RPC: xs_tcp_state_change client %p...\n", xprt);
972 dprintk("RPC: state %x conn %d dead %d zapped %d\n", 974 dprintk("RPC: state %x conn %d dead %d zapped %d\n",
973 sk->sk_state, xprt_connected(xprt), 975 sk->sk_state, xprt_connected(xprt),
974 sock_flag(sk, SOCK_DEAD), 976 sock_flag(sk, SOCK_DEAD),
975 sock_flag(sk, SOCK_ZAPPED)); 977 sock_flag(sk, SOCK_ZAPPED));
976 978
977 switch (sk->sk_state) { 979 switch (sk->sk_state) {
978 case TCP_ESTABLISHED: 980 case TCP_ESTABLISHED:
@@ -1140,7 +1142,7 @@ static void xs_set_port(struct rpc_xprt *xprt, unsigned short port)
1140{ 1142{
1141 struct sockaddr_in *sap = (struct sockaddr_in *) &xprt->addr; 1143 struct sockaddr_in *sap = (struct sockaddr_in *) &xprt->addr;
1142 1144
1143 dprintk("RPC: setting port for xprt %p to %u\n", xprt, port); 1145 dprintk("RPC: setting port for xprt %p to %u\n", xprt, port);
1144 1146
1145 sap->sin_port = htons(port); 1147 sap->sin_port = htons(port);
1146} 1148}
@@ -1159,7 +1161,7 @@ static int xs_bindresvport(struct sock_xprt *transport, struct socket *sock)
1159 sizeof(myaddr)); 1161 sizeof(myaddr));
1160 if (err == 0) { 1162 if (err == 0) {
1161 transport->port = port; 1163 transport->port = port;
1162 dprintk("RPC: xs_bindresvport bound to port %u\n", 1164 dprintk("RPC: xs_bindresvport bound to port %u\n",
1163 port); 1165 port);
1164 return 0; 1166 return 0;
1165 } 1167 }
@@ -1169,7 +1171,7 @@ static int xs_bindresvport(struct sock_xprt *transport, struct socket *sock)
1169 port--; 1171 port--;
1170 } while (err == -EADDRINUSE && port != transport->port); 1172 } while (err == -EADDRINUSE && port != transport->port);
1171 1173
1172 dprintk("RPC: can't bind to reserved port (%d).\n", -err); 1174 dprintk("RPC: can't bind to reserved port (%d).\n", -err);
1173 return err; 1175 return err;
1174} 1176}
1175 1177
@@ -1223,7 +1225,7 @@ static void xs_udp_connect_worker(struct work_struct *work)
1223 xs_close(xprt); 1225 xs_close(xprt);
1224 1226
1225 if ((err = sock_create_kern(PF_INET, SOCK_DGRAM, IPPROTO_UDP, &sock)) < 0) { 1227 if ((err = sock_create_kern(PF_INET, SOCK_DGRAM, IPPROTO_UDP, &sock)) < 0) {
1226 dprintk("RPC: can't create UDP transport socket (%d).\n", -err); 1228 dprintk("RPC: can't create UDP transport socket (%d).\n", -err);
1227 goto out; 1229 goto out;
1228 } 1230 }
1229 xs_reclassify_socket(sock); 1231 xs_reclassify_socket(sock);
@@ -1233,7 +1235,7 @@ static void xs_udp_connect_worker(struct work_struct *work)
1233 goto out; 1235 goto out;
1234 } 1236 }
1235 1237
1236 dprintk("RPC: worker connecting xprt %p to address: %s\n", 1238 dprintk("RPC: worker connecting xprt %p to address: %s\n",
1237 xprt, xprt->address_strings[RPC_DISPLAY_ALL]); 1239 xprt, xprt->address_strings[RPC_DISPLAY_ALL]);
1238 1240
1239 if (!transport->inet) { 1241 if (!transport->inet) {
@@ -1275,7 +1277,7 @@ static void xs_tcp_reuse_connection(struct rpc_xprt *xprt)
1275 struct sock_xprt *transport = container_of(xprt, struct sock_xprt, xprt); 1277 struct sock_xprt *transport = container_of(xprt, struct sock_xprt, xprt);
1276 struct sockaddr any; 1278 struct sockaddr any;
1277 1279
1278 dprintk("RPC: disconnecting xprt %p to reuse port\n", xprt); 1280 dprintk("RPC: disconnecting xprt %p to reuse port\n", xprt);
1279 1281
1280 /* 1282 /*
1281 * Disconnect the transport socket by doing a connect operation 1283 * Disconnect the transport socket by doing a connect operation
@@ -1285,7 +1287,7 @@ static void xs_tcp_reuse_connection(struct rpc_xprt *xprt)
1285 any.sa_family = AF_UNSPEC; 1287 any.sa_family = AF_UNSPEC;
1286 result = kernel_connect(transport->sock, &any, sizeof(any), 0); 1288 result = kernel_connect(transport->sock, &any, sizeof(any), 0);
1287 if (result) 1289 if (result)
1288 dprintk("RPC: AF_UNSPEC connect return code %d\n", 1290 dprintk("RPC: AF_UNSPEC connect return code %d\n",
1289 result); 1291 result);
1290} 1292}
1291 1293
@@ -1309,7 +1311,8 @@ static void xs_tcp_connect_worker(struct work_struct *work)
1309 if (!sock) { 1311 if (!sock) {
1310 /* start from scratch */ 1312 /* start from scratch */
1311 if ((err = sock_create_kern(PF_INET, SOCK_STREAM, IPPROTO_TCP, &sock)) < 0) { 1313 if ((err = sock_create_kern(PF_INET, SOCK_STREAM, IPPROTO_TCP, &sock)) < 0) {
1312 dprintk("RPC: can't create TCP transport socket (%d).\n", -err); 1314 dprintk("RPC: can't create TCP transport "
1315 "socket (%d).\n", -err);
1313 goto out; 1316 goto out;
1314 } 1317 }
1315 xs_reclassify_socket(sock); 1318 xs_reclassify_socket(sock);
@@ -1322,7 +1325,7 @@ static void xs_tcp_connect_worker(struct work_struct *work)
1322 /* "close" the socket, preserving the local port */ 1325 /* "close" the socket, preserving the local port */
1323 xs_tcp_reuse_connection(xprt); 1326 xs_tcp_reuse_connection(xprt);
1324 1327
1325 dprintk("RPC: worker connecting xprt %p to address: %s\n", 1328 dprintk("RPC: worker connecting xprt %p to address: %s\n",
1326 xprt, xprt->address_strings[RPC_DISPLAY_ALL]); 1329 xprt, xprt->address_strings[RPC_DISPLAY_ALL]);
1327 1330
1328 if (!transport->inet) { 1331 if (!transport->inet) {
@@ -1359,8 +1362,9 @@ static void xs_tcp_connect_worker(struct work_struct *work)
1359 xprt->stat.connect_start = jiffies; 1362 xprt->stat.connect_start = jiffies;
1360 status = kernel_connect(sock, (struct sockaddr *) &xprt->addr, 1363 status = kernel_connect(sock, (struct sockaddr *) &xprt->addr,
1361 xprt->addrlen, O_NONBLOCK); 1364 xprt->addrlen, O_NONBLOCK);
1362 dprintk("RPC: %p connect status %d connected %d sock state %d\n", 1365 dprintk("RPC: %p connect status %d connected %d sock state %d\n",
1363 xprt, -status, xprt_connected(xprt), sock->sk->sk_state); 1366 xprt, -status, xprt_connected(xprt),
1367 sock->sk->sk_state);
1364 if (status < 0) { 1368 if (status < 0) {
1365 switch (status) { 1369 switch (status) {
1366 case -EINPROGRESS: 1370 case -EINPROGRESS:
@@ -1404,7 +1408,8 @@ static void xs_connect(struct rpc_task *task)
1404 return; 1408 return;
1405 1409
1406 if (transport->sock != NULL) { 1410 if (transport->sock != NULL) {
1407 dprintk("RPC: xs_connect delayed xprt %p for %lu seconds\n", 1411 dprintk("RPC: xs_connect delayed xprt %p for %lu "
1412 "seconds\n",
1408 xprt, xprt->reestablish_timeout / HZ); 1413 xprt, xprt->reestablish_timeout / HZ);
1409 schedule_delayed_work(&transport->connect_worker, 1414 schedule_delayed_work(&transport->connect_worker,
1410 xprt->reestablish_timeout); 1415 xprt->reestablish_timeout);
@@ -1412,7 +1417,7 @@ static void xs_connect(struct rpc_task *task)
1412 if (xprt->reestablish_timeout > XS_TCP_MAX_REEST_TO) 1417 if (xprt->reestablish_timeout > XS_TCP_MAX_REEST_TO)
1413 xprt->reestablish_timeout = XS_TCP_MAX_REEST_TO; 1418 xprt->reestablish_timeout = XS_TCP_MAX_REEST_TO;
1414 } else { 1419 } else {
1415 dprintk("RPC: xs_connect scheduled xprt %p\n", xprt); 1420 dprintk("RPC: xs_connect scheduled xprt %p\n", xprt);
1416 schedule_delayed_work(&transport->connect_worker, 0); 1421 schedule_delayed_work(&transport->connect_worker, 0);
1417 1422
1418 /* flush_scheduled_work can sleep... */ 1423 /* flush_scheduled_work can sleep... */
@@ -1507,13 +1512,14 @@ static struct rpc_xprt *xs_setup_xprt(struct sockaddr *addr, size_t addrlen, uns
1507 struct sock_xprt *new; 1512 struct sock_xprt *new;
1508 1513
1509 if (addrlen > sizeof(xprt->addr)) { 1514 if (addrlen > sizeof(xprt->addr)) {
1510 dprintk("RPC: xs_setup_xprt: address too large\n"); 1515 dprintk("RPC: xs_setup_xprt: address too large\n");
1511 return ERR_PTR(-EBADF); 1516 return ERR_PTR(-EBADF);
1512 } 1517 }
1513 1518
1514 new = kzalloc(sizeof(*new), GFP_KERNEL); 1519 new = kzalloc(sizeof(*new), GFP_KERNEL);
1515 if (new == NULL) { 1520 if (new == NULL) {
1516 dprintk("RPC: xs_setup_xprt: couldn't allocate rpc_xprt\n"); 1521 dprintk("RPC: xs_setup_xprt: couldn't allocate "
1522 "rpc_xprt\n");
1517 return ERR_PTR(-ENOMEM); 1523 return ERR_PTR(-ENOMEM);
1518 } 1524 }
1519 xprt = &new->xprt; 1525 xprt = &new->xprt;
@@ -1522,7 +1528,8 @@ static struct rpc_xprt *xs_setup_xprt(struct sockaddr *addr, size_t addrlen, uns
1522 xprt->slot = kcalloc(xprt->max_reqs, sizeof(struct rpc_rqst), GFP_KERNEL); 1528 xprt->slot = kcalloc(xprt->max_reqs, sizeof(struct rpc_rqst), GFP_KERNEL);
1523 if (xprt->slot == NULL) { 1529 if (xprt->slot == NULL) {
1524 kfree(xprt); 1530 kfree(xprt);
1525 dprintk("RPC: xs_setup_xprt: couldn't allocate slot table\n"); 1531 dprintk("RPC: xs_setup_xprt: couldn't allocate slot "
1532 "table\n");
1526 return ERR_PTR(-ENOMEM); 1533 return ERR_PTR(-ENOMEM);
1527 } 1534 }
1528 1535
@@ -1572,7 +1579,7 @@ struct rpc_xprt *xs_setup_udp(struct sockaddr *addr, size_t addrlen, struct rpc_
1572 xprt_set_timeout(&xprt->timeout, 5, 5 * HZ); 1579 xprt_set_timeout(&xprt->timeout, 5, 5 * HZ);
1573 1580
1574 xs_format_peer_addresses(xprt); 1581 xs_format_peer_addresses(xprt);
1575 dprintk("RPC: set up transport to address %s\n", 1582 dprintk("RPC: set up transport to address %s\n",
1576 xprt->address_strings[RPC_DISPLAY_ALL]); 1583 xprt->address_strings[RPC_DISPLAY_ALL]);
1577 1584
1578 return xprt; 1585 return xprt;
@@ -1616,7 +1623,7 @@ struct rpc_xprt *xs_setup_tcp(struct sockaddr *addr, size_t addrlen, struct rpc_
1616 xprt_set_timeout(&xprt->timeout, 2, 60 * HZ); 1623 xprt_set_timeout(&xprt->timeout, 2, 60 * HZ);
1617 1624
1618 xs_format_peer_addresses(xprt); 1625 xs_format_peer_addresses(xprt);
1619 dprintk("RPC: set up transport to address %s\n", 1626 dprintk("RPC: set up transport to address %s\n",
1620 xprt->address_strings[RPC_DISPLAY_ALL]); 1627 xprt->address_strings[RPC_DISPLAY_ALL]);
1621 1628
1622 return xprt; 1629 return xprt;
generated by cgit v1.2.2 (git 2.25.0) at 2025-02-03 14:23:03 -0500