clnt.c revision f5131257f771ad0e84cf0314a2a86b66318755a9
1/* 2 * linux/net/sunrpc/clnt.c 3 * 4 * This file contains the high-level RPC interface. 5 * It is modeled as a finite state machine to support both synchronous 6 * and asynchronous requests. 7 * 8 * - RPC header generation and argument serialization. 9 * - Credential refresh. 10 * - TCP connect handling. 11 * - Retry of operation when it is suspected the operation failed because 12 * of uid squashing on the server, or when the credentials were stale 13 * and need to be refreshed, or when a packet was damaged in transit. 14 * This may be have to be moved to the VFS layer. 15 * 16 * Copyright (C) 1992,1993 Rick Sladkey <jrs@world.std.com> 17 * Copyright (C) 1995,1996 Olaf Kirch <okir@monad.swb.de> 18 */ 19 20#include <asm/system.h> 21 22#include <linux/module.h> 23#include <linux/types.h> 24#include <linux/kallsyms.h> 25#include <linux/mm.h> 26#include <linux/namei.h> 27#include <linux/mount.h> 28#include <linux/slab.h> 29#include <linux/utsname.h> 30#include <linux/workqueue.h> 31#include <linux/in.h> 32#include <linux/in6.h> 33#include <linux/un.h> 34 35#include <linux/sunrpc/clnt.h> 36#include <linux/sunrpc/rpc_pipe_fs.h> 37#include <linux/sunrpc/metrics.h> 38#include <linux/sunrpc/bc_xprt.h> 39 40#include "sunrpc.h" 41#include "netns.h" 42 43#ifdef RPC_DEBUG 44# define RPCDBG_FACILITY RPCDBG_CALL 45#endif 46 47#define dprint_status(t) \ 48 dprintk("RPC: %5u %s (status %d)\n", t->tk_pid, \ 49 __func__, t->tk_status) 50 51/* 52 * All RPC clients are linked into this list 53 */ 54 55static DECLARE_WAIT_QUEUE_HEAD(destroy_wait); 56 57 58static void call_start(struct rpc_task *task); 59static void call_reserve(struct rpc_task *task); 60static void call_reserveresult(struct rpc_task *task); 61static void call_allocate(struct rpc_task *task); 62static void call_decode(struct rpc_task *task); 63static void call_bind(struct rpc_task *task); 64static void call_bind_status(struct rpc_task *task); 65static void call_transmit(struct rpc_task *task); 66#if defined(CONFIG_SUNRPC_BACKCHANNEL) 67static void call_bc_transmit(struct rpc_task *task); 68#endif /* CONFIG_SUNRPC_BACKCHANNEL */ 69static void call_status(struct rpc_task *task); 70static void call_transmit_status(struct rpc_task *task); 71static void call_refresh(struct rpc_task *task); 72static void call_refreshresult(struct rpc_task *task); 73static void call_timeout(struct rpc_task *task); 74static void call_connect(struct rpc_task *task); 75static void call_connect_status(struct rpc_task *task); 76 77static __be32 *rpc_encode_header(struct rpc_task *task); 78static __be32 *rpc_verify_header(struct rpc_task *task); 79static int rpc_ping(struct rpc_clnt *clnt); 80 81static void rpc_register_client(struct rpc_clnt *clnt) 82{ 83 struct sunrpc_net *sn = net_generic(clnt->cl_xprt->xprt_net, sunrpc_net_id); 84 85 spin_lock(&sn->rpc_client_lock); 86 list_add(&clnt->cl_clients, &sn->all_clients); 87 spin_unlock(&sn->rpc_client_lock); 88} 89 90static void rpc_unregister_client(struct rpc_clnt *clnt) 91{ 92 struct sunrpc_net *sn = net_generic(clnt->cl_xprt->xprt_net, sunrpc_net_id); 93 94 spin_lock(&sn->rpc_client_lock); 95 list_del(&clnt->cl_clients); 96 spin_unlock(&sn->rpc_client_lock); 97} 98 99static void __rpc_clnt_remove_pipedir(struct rpc_clnt *clnt) 100{ 101 if (clnt->cl_path.dentry) { 102 if (clnt->cl_auth && clnt->cl_auth->au_ops->pipes_destroy) 103 clnt->cl_auth->au_ops->pipes_destroy(clnt->cl_auth); 104 rpc_remove_client_dir(clnt->cl_path.dentry); 105 } 106 clnt->cl_path.dentry = NULL; 107} 108 109static void rpc_clnt_remove_pipedir(struct rpc_clnt *clnt) 110{ 111 struct super_block *pipefs_sb; 112 int put_mnt = 0; 113 114 pipefs_sb = rpc_get_sb_net(clnt->cl_xprt->xprt_net); 115 if (pipefs_sb) { 116 if (clnt->cl_path.dentry) 117 put_mnt = 1; 118 __rpc_clnt_remove_pipedir(clnt); 119 rpc_put_sb_net(clnt->cl_xprt->xprt_net); 120 } 121 if (put_mnt) 122 rpc_put_mount(); 123} 124 125static struct dentry *rpc_setup_pipedir_sb(struct super_block *sb, 126 struct rpc_clnt *clnt, char *dir_name) 127{ 128 static uint32_t clntid; 129 char name[15]; 130 struct qstr q = { 131 .name = name, 132 }; 133 struct dentry *dir, *dentry; 134 int error; 135 136 dir = rpc_d_lookup_sb(sb, dir_name); 137 if (dir == NULL) 138 return dir; 139 for (;;) { 140 q.len = snprintf(name, sizeof(name), "clnt%x", (unsigned int)clntid++); 141 name[sizeof(name) - 1] = '\0'; 142 q.hash = full_name_hash(q.name, q.len); 143 dentry = rpc_create_client_dir(dir, &q, clnt); 144 if (!IS_ERR(dentry)) 145 break; 146 error = PTR_ERR(dentry); 147 if (error != -EEXIST) { 148 printk(KERN_INFO "RPC: Couldn't create pipefs entry" 149 " %s/%s, error %d\n", 150 dir_name, name, error); 151 break; 152 } 153 } 154 dput(dir); 155 return dentry; 156} 157 158static int 159rpc_setup_pipedir(struct rpc_clnt *clnt, char *dir_name) 160{ 161 struct super_block *pipefs_sb; 162 struct path path; 163 164 clnt->cl_path.mnt = ERR_PTR(-ENOENT); 165 clnt->cl_path.dentry = NULL; 166 if (dir_name == NULL) 167 return 0; 168 169 path.mnt = rpc_get_mount(); 170 if (IS_ERR(path.mnt)) 171 return PTR_ERR(path.mnt); 172 pipefs_sb = rpc_get_sb_net(clnt->cl_xprt->xprt_net); 173 if (!pipefs_sb) { 174 rpc_put_mount(); 175 return -ENOENT; 176 } 177 path.dentry = rpc_setup_pipedir_sb(pipefs_sb, clnt, dir_name); 178 rpc_put_sb_net(clnt->cl_xprt->xprt_net); 179 if (IS_ERR(path.dentry)) { 180 rpc_put_mount(); 181 return PTR_ERR(path.dentry); 182 } 183 clnt->cl_path = path; 184 return 0; 185} 186 187static int __rpc_pipefs_event(struct rpc_clnt *clnt, unsigned long event, 188 struct super_block *sb) 189{ 190 struct dentry *dentry; 191 int err = 0; 192 193 switch (event) { 194 case RPC_PIPEFS_MOUNT: 195 if (clnt->cl_program->pipe_dir_name == NULL) 196 break; 197 dentry = rpc_setup_pipedir_sb(sb, clnt, 198 clnt->cl_program->pipe_dir_name); 199 BUG_ON(dentry == NULL); 200 if (IS_ERR(dentry)) 201 return PTR_ERR(dentry); 202 clnt->cl_path.dentry = dentry; 203 if (clnt->cl_auth->au_ops->pipes_create) { 204 err = clnt->cl_auth->au_ops->pipes_create(clnt->cl_auth); 205 if (err) 206 __rpc_clnt_remove_pipedir(clnt); 207 } 208 break; 209 case RPC_PIPEFS_UMOUNT: 210 __rpc_clnt_remove_pipedir(clnt); 211 break; 212 default: 213 printk(KERN_ERR "%s: unknown event: %ld\n", __func__, event); 214 return -ENOTSUPP; 215 } 216 return err; 217} 218 219static int rpc_pipefs_event(struct notifier_block *nb, unsigned long event, 220 void *ptr) 221{ 222 struct super_block *sb = ptr; 223 struct rpc_clnt *clnt; 224 int error = 0; 225 struct sunrpc_net *sn = net_generic(sb->s_fs_info, sunrpc_net_id); 226 227 spin_lock(&sn->rpc_client_lock); 228 list_for_each_entry(clnt, &sn->all_clients, cl_clients) { 229 error = __rpc_pipefs_event(clnt, event, sb); 230 if (error) 231 break; 232 } 233 spin_unlock(&sn->rpc_client_lock); 234 return error; 235} 236 237static struct notifier_block rpc_clients_block = { 238 .notifier_call = rpc_pipefs_event, 239}; 240 241int rpc_clients_notifier_register(void) 242{ 243 return rpc_pipefs_notifier_register(&rpc_clients_block); 244} 245 246void rpc_clients_notifier_unregister(void) 247{ 248 return rpc_pipefs_notifier_unregister(&rpc_clients_block); 249} 250 251static struct rpc_clnt * rpc_new_client(const struct rpc_create_args *args, struct rpc_xprt *xprt) 252{ 253 struct rpc_program *program = args->program; 254 struct rpc_version *version; 255 struct rpc_clnt *clnt = NULL; 256 struct rpc_auth *auth; 257 int err; 258 size_t len; 259 260 /* sanity check the name before trying to print it */ 261 err = -EINVAL; 262 len = strlen(args->servername); 263 if (len > RPC_MAXNETNAMELEN) 264 goto out_no_rpciod; 265 len++; 266 267 dprintk("RPC: creating %s client for %s (xprt %p)\n", 268 program->name, args->servername, xprt); 269 270 err = rpciod_up(); 271 if (err) 272 goto out_no_rpciod; 273 err = -EINVAL; 274 if (!xprt) 275 goto out_no_xprt; 276 277 if (args->version >= program->nrvers) 278 goto out_err; 279 version = program->version[args->version]; 280 if (version == NULL) 281 goto out_err; 282 283 err = -ENOMEM; 284 clnt = kzalloc(sizeof(*clnt), GFP_KERNEL); 285 if (!clnt) 286 goto out_err; 287 clnt->cl_parent = clnt; 288 289 clnt->cl_server = clnt->cl_inline_name; 290 if (len > sizeof(clnt->cl_inline_name)) { 291 char *buf = kmalloc(len, GFP_KERNEL); 292 if (buf != NULL) 293 clnt->cl_server = buf; 294 else 295 len = sizeof(clnt->cl_inline_name); 296 } 297 strlcpy(clnt->cl_server, args->servername, len); 298 299 clnt->cl_xprt = xprt; 300 clnt->cl_procinfo = version->procs; 301 clnt->cl_maxproc = version->nrprocs; 302 clnt->cl_protname = program->name; 303 clnt->cl_prog = args->prognumber ? : program->number; 304 clnt->cl_vers = version->number; 305 clnt->cl_stats = program->stats; 306 clnt->cl_metrics = rpc_alloc_iostats(clnt); 307 err = -ENOMEM; 308 if (clnt->cl_metrics == NULL) 309 goto out_no_stats; 310 clnt->cl_program = program; 311 INIT_LIST_HEAD(&clnt->cl_tasks); 312 spin_lock_init(&clnt->cl_lock); 313 314 if (!xprt_bound(clnt->cl_xprt)) 315 clnt->cl_autobind = 1; 316 317 clnt->cl_timeout = xprt->timeout; 318 if (args->timeout != NULL) { 319 memcpy(&clnt->cl_timeout_default, args->timeout, 320 sizeof(clnt->cl_timeout_default)); 321 clnt->cl_timeout = &clnt->cl_timeout_default; 322 } 323 324 clnt->cl_rtt = &clnt->cl_rtt_default; 325 rpc_init_rtt(&clnt->cl_rtt_default, clnt->cl_timeout->to_initval); 326 clnt->cl_principal = NULL; 327 if (args->client_name) { 328 clnt->cl_principal = kstrdup(args->client_name, GFP_KERNEL); 329 if (!clnt->cl_principal) 330 goto out_no_principal; 331 } 332 333 atomic_set(&clnt->cl_count, 1); 334 335 err = rpc_setup_pipedir(clnt, program->pipe_dir_name); 336 if (err < 0) 337 goto out_no_path; 338 339 auth = rpcauth_create(args->authflavor, clnt); 340 if (IS_ERR(auth)) { 341 printk(KERN_INFO "RPC: Couldn't create auth handle (flavor %u)\n", 342 args->authflavor); 343 err = PTR_ERR(auth); 344 goto out_no_auth; 345 } 346 347 /* save the nodename */ 348 clnt->cl_nodelen = strlen(init_utsname()->nodename); 349 if (clnt->cl_nodelen > UNX_MAXNODENAME) 350 clnt->cl_nodelen = UNX_MAXNODENAME; 351 memcpy(clnt->cl_nodename, init_utsname()->nodename, clnt->cl_nodelen); 352 rpc_register_client(clnt); 353 return clnt; 354 355out_no_auth: 356 rpc_clnt_remove_pipedir(clnt); 357out_no_path: 358 kfree(clnt->cl_principal); 359out_no_principal: 360 rpc_free_iostats(clnt->cl_metrics); 361out_no_stats: 362 if (clnt->cl_server != clnt->cl_inline_name) 363 kfree(clnt->cl_server); 364 kfree(clnt); 365out_err: 366 xprt_put(xprt); 367out_no_xprt: 368 rpciod_down(); 369out_no_rpciod: 370 return ERR_PTR(err); 371} 372 373/* 374 * rpc_create - create an RPC client and transport with one call 375 * @args: rpc_clnt create argument structure 376 * 377 * Creates and initializes an RPC transport and an RPC client. 378 * 379 * It can ping the server in order to determine if it is up, and to see if 380 * it supports this program and version. RPC_CLNT_CREATE_NOPING disables 381 * this behavior so asynchronous tasks can also use rpc_create. 382 */ 383struct rpc_clnt *rpc_create(struct rpc_create_args *args) 384{ 385 struct rpc_xprt *xprt; 386 struct rpc_clnt *clnt; 387 struct xprt_create xprtargs = { 388 .net = args->net, 389 .ident = args->protocol, 390 .srcaddr = args->saddress, 391 .dstaddr = args->address, 392 .addrlen = args->addrsize, 393 .bc_xprt = args->bc_xprt, 394 }; 395 char servername[48]; 396 397 /* 398 * If the caller chooses not to specify a hostname, whip 399 * up a string representation of the passed-in address. 400 */ 401 if (args->servername == NULL) { 402 struct sockaddr_un *sun = 403 (struct sockaddr_un *)args->address; 404 struct sockaddr_in *sin = 405 (struct sockaddr_in *)args->address; 406 struct sockaddr_in6 *sin6 = 407 (struct sockaddr_in6 *)args->address; 408 409 servername[0] = '\0'; 410 switch (args->address->sa_family) { 411 case AF_LOCAL: 412 snprintf(servername, sizeof(servername), "%s", 413 sun->sun_path); 414 break; 415 case AF_INET: 416 snprintf(servername, sizeof(servername), "%pI4", 417 &sin->sin_addr.s_addr); 418 break; 419 case AF_INET6: 420 snprintf(servername, sizeof(servername), "%pI6", 421 &sin6->sin6_addr); 422 break; 423 default: 424 /* caller wants default server name, but 425 * address family isn't recognized. */ 426 return ERR_PTR(-EINVAL); 427 } 428 args->servername = servername; 429 } 430 431 xprt = xprt_create_transport(&xprtargs); 432 if (IS_ERR(xprt)) 433 return (struct rpc_clnt *)xprt; 434 435 /* 436 * By default, kernel RPC client connects from a reserved port. 437 * CAP_NET_BIND_SERVICE will not be set for unprivileged requesters, 438 * but it is always enabled for rpciod, which handles the connect 439 * operation. 440 */ 441 xprt->resvport = 1; 442 if (args->flags & RPC_CLNT_CREATE_NONPRIVPORT) 443 xprt->resvport = 0; 444 445 clnt = rpc_new_client(args, xprt); 446 if (IS_ERR(clnt)) 447 return clnt; 448 449 if (!(args->flags & RPC_CLNT_CREATE_NOPING)) { 450 int err = rpc_ping(clnt); 451 if (err != 0) { 452 rpc_shutdown_client(clnt); 453 return ERR_PTR(err); 454 } 455 } 456 457 clnt->cl_softrtry = 1; 458 if (args->flags & RPC_CLNT_CREATE_HARDRTRY) 459 clnt->cl_softrtry = 0; 460 461 if (args->flags & RPC_CLNT_CREATE_AUTOBIND) 462 clnt->cl_autobind = 1; 463 if (args->flags & RPC_CLNT_CREATE_DISCRTRY) 464 clnt->cl_discrtry = 1; 465 if (!(args->flags & RPC_CLNT_CREATE_QUIET)) 466 clnt->cl_chatty = 1; 467 468 return clnt; 469} 470EXPORT_SYMBOL_GPL(rpc_create); 471 472/* 473 * This function clones the RPC client structure. It allows us to share the 474 * same transport while varying parameters such as the authentication 475 * flavour. 476 */ 477struct rpc_clnt * 478rpc_clone_client(struct rpc_clnt *clnt) 479{ 480 struct rpc_clnt *new; 481 int err = -ENOMEM; 482 483 new = kmemdup(clnt, sizeof(*new), GFP_KERNEL); 484 if (!new) 485 goto out_no_clnt; 486 new->cl_parent = clnt; 487 /* Turn off autobind on clones */ 488 new->cl_autobind = 0; 489 INIT_LIST_HEAD(&new->cl_tasks); 490 spin_lock_init(&new->cl_lock); 491 rpc_init_rtt(&new->cl_rtt_default, clnt->cl_timeout->to_initval); 492 new->cl_metrics = rpc_alloc_iostats(clnt); 493 if (new->cl_metrics == NULL) 494 goto out_no_stats; 495 if (clnt->cl_principal) { 496 new->cl_principal = kstrdup(clnt->cl_principal, GFP_KERNEL); 497 if (new->cl_principal == NULL) 498 goto out_no_principal; 499 } 500 atomic_set(&new->cl_count, 1); 501 err = rpc_setup_pipedir(new, clnt->cl_program->pipe_dir_name); 502 if (err != 0) 503 goto out_no_path; 504 if (new->cl_auth) 505 atomic_inc(&new->cl_auth->au_count); 506 xprt_get(clnt->cl_xprt); 507 atomic_inc(&clnt->cl_count); 508 rpc_register_client(new); 509 rpciod_up(); 510 return new; 511out_no_path: 512 kfree(new->cl_principal); 513out_no_principal: 514 rpc_free_iostats(new->cl_metrics); 515out_no_stats: 516 kfree(new); 517out_no_clnt: 518 dprintk("RPC: %s: returned error %d\n", __func__, err); 519 return ERR_PTR(err); 520} 521EXPORT_SYMBOL_GPL(rpc_clone_client); 522 523/* 524 * Kill all tasks for the given client. 525 * XXX: kill their descendants as well? 526 */ 527void rpc_killall_tasks(struct rpc_clnt *clnt) 528{ 529 struct rpc_task *rovr; 530 531 532 if (list_empty(&clnt->cl_tasks)) 533 return; 534 dprintk("RPC: killing all tasks for client %p\n", clnt); 535 /* 536 * Spin lock all_tasks to prevent changes... 537 */ 538 spin_lock(&clnt->cl_lock); 539 list_for_each_entry(rovr, &clnt->cl_tasks, tk_task) { 540 if (!RPC_IS_ACTIVATED(rovr)) 541 continue; 542 if (!(rovr->tk_flags & RPC_TASK_KILLED)) { 543 rovr->tk_flags |= RPC_TASK_KILLED; 544 rpc_exit(rovr, -EIO); 545 if (RPC_IS_QUEUED(rovr)) 546 rpc_wake_up_queued_task(rovr->tk_waitqueue, 547 rovr); 548 } 549 } 550 spin_unlock(&clnt->cl_lock); 551} 552EXPORT_SYMBOL_GPL(rpc_killall_tasks); 553 554/* 555 * Properly shut down an RPC client, terminating all outstanding 556 * requests. 557 */ 558void rpc_shutdown_client(struct rpc_clnt *clnt) 559{ 560 dprintk("RPC: shutting down %s client for %s\n", 561 clnt->cl_protname, clnt->cl_server); 562 563 while (!list_empty(&clnt->cl_tasks)) { 564 rpc_killall_tasks(clnt); 565 wait_event_timeout(destroy_wait, 566 list_empty(&clnt->cl_tasks), 1*HZ); 567 } 568 569 rpc_release_client(clnt); 570} 571EXPORT_SYMBOL_GPL(rpc_shutdown_client); 572 573/* 574 * Free an RPC client 575 */ 576static void 577rpc_free_client(struct rpc_clnt *clnt) 578{ 579 dprintk("RPC: destroying %s client for %s\n", 580 clnt->cl_protname, clnt->cl_server); 581 if (clnt->cl_parent != clnt) { 582 rpc_release_client(clnt->cl_parent); 583 goto out_free; 584 } 585 if (clnt->cl_server != clnt->cl_inline_name) 586 kfree(clnt->cl_server); 587out_free: 588 rpc_unregister_client(clnt); 589 rpc_clnt_remove_pipedir(clnt); 590 rpc_free_iostats(clnt->cl_metrics); 591 kfree(clnt->cl_principal); 592 clnt->cl_metrics = NULL; 593 xprt_put(clnt->cl_xprt); 594 rpciod_down(); 595 kfree(clnt); 596} 597 598/* 599 * Free an RPC client 600 */ 601static void 602rpc_free_auth(struct rpc_clnt *clnt) 603{ 604 if (clnt->cl_auth == NULL) { 605 rpc_free_client(clnt); 606 return; 607 } 608 609 /* 610 * Note: RPCSEC_GSS may need to send NULL RPC calls in order to 611 * release remaining GSS contexts. This mechanism ensures 612 * that it can do so safely. 613 */ 614 atomic_inc(&clnt->cl_count); 615 rpcauth_release(clnt->cl_auth); 616 clnt->cl_auth = NULL; 617 if (atomic_dec_and_test(&clnt->cl_count)) 618 rpc_free_client(clnt); 619} 620 621/* 622 * Release reference to the RPC client 623 */ 624void 625rpc_release_client(struct rpc_clnt *clnt) 626{ 627 dprintk("RPC: rpc_release_client(%p)\n", clnt); 628 629 if (list_empty(&clnt->cl_tasks)) 630 wake_up(&destroy_wait); 631 if (atomic_dec_and_test(&clnt->cl_count)) 632 rpc_free_auth(clnt); 633} 634 635/** 636 * rpc_bind_new_program - bind a new RPC program to an existing client 637 * @old: old rpc_client 638 * @program: rpc program to set 639 * @vers: rpc program version 640 * 641 * Clones the rpc client and sets up a new RPC program. This is mainly 642 * of use for enabling different RPC programs to share the same transport. 643 * The Sun NFSv2/v3 ACL protocol can do this. 644 */ 645struct rpc_clnt *rpc_bind_new_program(struct rpc_clnt *old, 646 struct rpc_program *program, 647 u32 vers) 648{ 649 struct rpc_clnt *clnt; 650 struct rpc_version *version; 651 int err; 652 653 BUG_ON(vers >= program->nrvers || !program->version[vers]); 654 version = program->version[vers]; 655 clnt = rpc_clone_client(old); 656 if (IS_ERR(clnt)) 657 goto out; 658 clnt->cl_procinfo = version->procs; 659 clnt->cl_maxproc = version->nrprocs; 660 clnt->cl_protname = program->name; 661 clnt->cl_prog = program->number; 662 clnt->cl_vers = version->number; 663 clnt->cl_stats = program->stats; 664 err = rpc_ping(clnt); 665 if (err != 0) { 666 rpc_shutdown_client(clnt); 667 clnt = ERR_PTR(err); 668 } 669out: 670 return clnt; 671} 672EXPORT_SYMBOL_GPL(rpc_bind_new_program); 673 674void rpc_task_release_client(struct rpc_task *task) 675{ 676 struct rpc_clnt *clnt = task->tk_client; 677 678 if (clnt != NULL) { 679 /* Remove from client task list */ 680 spin_lock(&clnt->cl_lock); 681 list_del(&task->tk_task); 682 spin_unlock(&clnt->cl_lock); 683 task->tk_client = NULL; 684 685 rpc_release_client(clnt); 686 } 687} 688 689static 690void rpc_task_set_client(struct rpc_task *task, struct rpc_clnt *clnt) 691{ 692 if (clnt != NULL) { 693 rpc_task_release_client(task); 694 task->tk_client = clnt; 695 atomic_inc(&clnt->cl_count); 696 if (clnt->cl_softrtry) 697 task->tk_flags |= RPC_TASK_SOFT; 698 /* Add to the client's list of all tasks */ 699 spin_lock(&clnt->cl_lock); 700 list_add_tail(&task->tk_task, &clnt->cl_tasks); 701 spin_unlock(&clnt->cl_lock); 702 } 703} 704 705void rpc_task_reset_client(struct rpc_task *task, struct rpc_clnt *clnt) 706{ 707 rpc_task_release_client(task); 708 rpc_task_set_client(task, clnt); 709} 710EXPORT_SYMBOL_GPL(rpc_task_reset_client); 711 712 713static void 714rpc_task_set_rpc_message(struct rpc_task *task, const struct rpc_message *msg) 715{ 716 if (msg != NULL) { 717 task->tk_msg.rpc_proc = msg->rpc_proc; 718 task->tk_msg.rpc_argp = msg->rpc_argp; 719 task->tk_msg.rpc_resp = msg->rpc_resp; 720 if (msg->rpc_cred != NULL) 721 task->tk_msg.rpc_cred = get_rpccred(msg->rpc_cred); 722 } 723} 724 725/* 726 * Default callback for async RPC calls 727 */ 728static void 729rpc_default_callback(struct rpc_task *task, void *data) 730{ 731} 732 733static const struct rpc_call_ops rpc_default_ops = { 734 .rpc_call_done = rpc_default_callback, 735}; 736 737/** 738 * rpc_run_task - Allocate a new RPC task, then run rpc_execute against it 739 * @task_setup_data: pointer to task initialisation data 740 */ 741struct rpc_task *rpc_run_task(const struct rpc_task_setup *task_setup_data) 742{ 743 struct rpc_task *task; 744 745 task = rpc_new_task(task_setup_data); 746 if (IS_ERR(task)) 747 goto out; 748 749 rpc_task_set_client(task, task_setup_data->rpc_client); 750 rpc_task_set_rpc_message(task, task_setup_data->rpc_message); 751 752 if (task->tk_action == NULL) 753 rpc_call_start(task); 754 755 atomic_inc(&task->tk_count); 756 rpc_execute(task); 757out: 758 return task; 759} 760EXPORT_SYMBOL_GPL(rpc_run_task); 761 762/** 763 * rpc_call_sync - Perform a synchronous RPC call 764 * @clnt: pointer to RPC client 765 * @msg: RPC call parameters 766 * @flags: RPC call flags 767 */ 768int rpc_call_sync(struct rpc_clnt *clnt, const struct rpc_message *msg, int flags) 769{ 770 struct rpc_task *task; 771 struct rpc_task_setup task_setup_data = { 772 .rpc_client = clnt, 773 .rpc_message = msg, 774 .callback_ops = &rpc_default_ops, 775 .flags = flags, 776 }; 777 int status; 778 779 BUG_ON(flags & RPC_TASK_ASYNC); 780 781 task = rpc_run_task(&task_setup_data); 782 if (IS_ERR(task)) 783 return PTR_ERR(task); 784 status = task->tk_status; 785 rpc_put_task(task); 786 return status; 787} 788EXPORT_SYMBOL_GPL(rpc_call_sync); 789 790/** 791 * rpc_call_async - Perform an asynchronous RPC call 792 * @clnt: pointer to RPC client 793 * @msg: RPC call parameters 794 * @flags: RPC call flags 795 * @tk_ops: RPC call ops 796 * @data: user call data 797 */ 798int 799rpc_call_async(struct rpc_clnt *clnt, const struct rpc_message *msg, int flags, 800 const struct rpc_call_ops *tk_ops, void *data) 801{ 802 struct rpc_task *task; 803 struct rpc_task_setup task_setup_data = { 804 .rpc_client = clnt, 805 .rpc_message = msg, 806 .callback_ops = tk_ops, 807 .callback_data = data, 808 .flags = flags|RPC_TASK_ASYNC, 809 }; 810 811 task = rpc_run_task(&task_setup_data); 812 if (IS_ERR(task)) 813 return PTR_ERR(task); 814 rpc_put_task(task); 815 return 0; 816} 817EXPORT_SYMBOL_GPL(rpc_call_async); 818 819#if defined(CONFIG_SUNRPC_BACKCHANNEL) 820/** 821 * rpc_run_bc_task - Allocate a new RPC task for backchannel use, then run 822 * rpc_execute against it 823 * @req: RPC request 824 * @tk_ops: RPC call ops 825 */ 826struct rpc_task *rpc_run_bc_task(struct rpc_rqst *req, 827 const struct rpc_call_ops *tk_ops) 828{ 829 struct rpc_task *task; 830 struct xdr_buf *xbufp = &req->rq_snd_buf; 831 struct rpc_task_setup task_setup_data = { 832 .callback_ops = tk_ops, 833 }; 834 835 dprintk("RPC: rpc_run_bc_task req= %p\n", req); 836 /* 837 * Create an rpc_task to send the data 838 */ 839 task = rpc_new_task(&task_setup_data); 840 if (IS_ERR(task)) { 841 xprt_free_bc_request(req); 842 goto out; 843 } 844 task->tk_rqstp = req; 845 846 /* 847 * Set up the xdr_buf length. 848 * This also indicates that the buffer is XDR encoded already. 849 */ 850 xbufp->len = xbufp->head[0].iov_len + xbufp->page_len + 851 xbufp->tail[0].iov_len; 852 853 task->tk_action = call_bc_transmit; 854 atomic_inc(&task->tk_count); 855 BUG_ON(atomic_read(&task->tk_count) != 2); 856 rpc_execute(task); 857 858out: 859 dprintk("RPC: rpc_run_bc_task: task= %p\n", task); 860 return task; 861} 862#endif /* CONFIG_SUNRPC_BACKCHANNEL */ 863 864void 865rpc_call_start(struct rpc_task *task) 866{ 867 task->tk_action = call_start; 868} 869EXPORT_SYMBOL_GPL(rpc_call_start); 870 871/** 872 * rpc_peeraddr - extract remote peer address from clnt's xprt 873 * @clnt: RPC client structure 874 * @buf: target buffer 875 * @bufsize: length of target buffer 876 * 877 * Returns the number of bytes that are actually in the stored address. 878 */ 879size_t rpc_peeraddr(struct rpc_clnt *clnt, struct sockaddr *buf, size_t bufsize) 880{ 881 size_t bytes; 882 struct rpc_xprt *xprt = clnt->cl_xprt; 883 884 bytes = sizeof(xprt->addr); 885 if (bytes > bufsize) 886 bytes = bufsize; 887 memcpy(buf, &clnt->cl_xprt->addr, bytes); 888 return xprt->addrlen; 889} 890EXPORT_SYMBOL_GPL(rpc_peeraddr); 891 892/** 893 * rpc_peeraddr2str - return remote peer address in printable format 894 * @clnt: RPC client structure 895 * @format: address format 896 * 897 */ 898const char *rpc_peeraddr2str(struct rpc_clnt *clnt, 899 enum rpc_display_format_t format) 900{ 901 struct rpc_xprt *xprt = clnt->cl_xprt; 902 903 if (xprt->address_strings[format] != NULL) 904 return xprt->address_strings[format]; 905 else 906 return "unprintable"; 907} 908EXPORT_SYMBOL_GPL(rpc_peeraddr2str); 909 910void 911rpc_setbufsize(struct rpc_clnt *clnt, unsigned int sndsize, unsigned int rcvsize) 912{ 913 struct rpc_xprt *xprt = clnt->cl_xprt; 914 if (xprt->ops->set_buffer_size) 915 xprt->ops->set_buffer_size(xprt, sndsize, rcvsize); 916} 917EXPORT_SYMBOL_GPL(rpc_setbufsize); 918 919/* 920 * Return size of largest payload RPC client can support, in bytes 921 * 922 * For stream transports, this is one RPC record fragment (see RFC 923 * 1831), as we don't support multi-record requests yet. For datagram 924 * transports, this is the size of an IP packet minus the IP, UDP, and 925 * RPC header sizes. 926 */ 927size_t rpc_max_payload(struct rpc_clnt *clnt) 928{ 929 return clnt->cl_xprt->max_payload; 930} 931EXPORT_SYMBOL_GPL(rpc_max_payload); 932 933/** 934 * rpc_force_rebind - force transport to check that remote port is unchanged 935 * @clnt: client to rebind 936 * 937 */ 938void rpc_force_rebind(struct rpc_clnt *clnt) 939{ 940 if (clnt->cl_autobind) 941 xprt_clear_bound(clnt->cl_xprt); 942} 943EXPORT_SYMBOL_GPL(rpc_force_rebind); 944 945/* 946 * Restart an (async) RPC call from the call_prepare state. 947 * Usually called from within the exit handler. 948 */ 949int 950rpc_restart_call_prepare(struct rpc_task *task) 951{ 952 if (RPC_ASSASSINATED(task)) 953 return 0; 954 task->tk_action = call_start; 955 if (task->tk_ops->rpc_call_prepare != NULL) 956 task->tk_action = rpc_prepare_task; 957 return 1; 958} 959EXPORT_SYMBOL_GPL(rpc_restart_call_prepare); 960 961/* 962 * Restart an (async) RPC call. Usually called from within the 963 * exit handler. 964 */ 965int 966rpc_restart_call(struct rpc_task *task) 967{ 968 if (RPC_ASSASSINATED(task)) 969 return 0; 970 task->tk_action = call_start; 971 return 1; 972} 973EXPORT_SYMBOL_GPL(rpc_restart_call); 974 975#ifdef RPC_DEBUG 976static const char *rpc_proc_name(const struct rpc_task *task) 977{ 978 const struct rpc_procinfo *proc = task->tk_msg.rpc_proc; 979 980 if (proc) { 981 if (proc->p_name) 982 return proc->p_name; 983 else 984 return "NULL"; 985 } else 986 return "no proc"; 987} 988#endif 989 990/* 991 * 0. Initial state 992 * 993 * Other FSM states can be visited zero or more times, but 994 * this state is visited exactly once for each RPC. 995 */ 996static void 997call_start(struct rpc_task *task) 998{ 999 struct rpc_clnt *clnt = task->tk_client; 1000 1001 dprintk("RPC: %5u call_start %s%d proc %s (%s)\n", task->tk_pid, 1002 clnt->cl_protname, clnt->cl_vers, 1003 rpc_proc_name(task), 1004 (RPC_IS_ASYNC(task) ? "async" : "sync")); 1005 1006 /* Increment call count */ 1007 task->tk_msg.rpc_proc->p_count++; 1008 clnt->cl_stats->rpccnt++; 1009 task->tk_action = call_reserve; 1010} 1011 1012/* 1013 * 1. Reserve an RPC call slot 1014 */ 1015static void 1016call_reserve(struct rpc_task *task) 1017{ 1018 dprint_status(task); 1019 1020 task->tk_status = 0; 1021 task->tk_action = call_reserveresult; 1022 xprt_reserve(task); 1023} 1024 1025/* 1026 * 1b. Grok the result of xprt_reserve() 1027 */ 1028static void 1029call_reserveresult(struct rpc_task *task) 1030{ 1031 int status = task->tk_status; 1032 1033 dprint_status(task); 1034 1035 /* 1036 * After a call to xprt_reserve(), we must have either 1037 * a request slot or else an error status. 1038 */ 1039 task->tk_status = 0; 1040 if (status >= 0) { 1041 if (task->tk_rqstp) { 1042 task->tk_action = call_refresh; 1043 return; 1044 } 1045 1046 printk(KERN_ERR "%s: status=%d, but no request slot, exiting\n", 1047 __func__, status); 1048 rpc_exit(task, -EIO); 1049 return; 1050 } 1051 1052 /* 1053 * Even though there was an error, we may have acquired 1054 * a request slot somehow. Make sure not to leak it. 1055 */ 1056 if (task->tk_rqstp) { 1057 printk(KERN_ERR "%s: status=%d, request allocated anyway\n", 1058 __func__, status); 1059 xprt_release(task); 1060 } 1061 1062 switch (status) { 1063 case -EAGAIN: /* woken up; retry */ 1064 task->tk_action = call_reserve; 1065 return; 1066 case -EIO: /* probably a shutdown */ 1067 break; 1068 default: 1069 printk(KERN_ERR "%s: unrecognized error %d, exiting\n", 1070 __func__, status); 1071 break; 1072 } 1073 rpc_exit(task, status); 1074} 1075 1076/* 1077 * 2. Bind and/or refresh the credentials 1078 */ 1079static void 1080call_refresh(struct rpc_task *task) 1081{ 1082 dprint_status(task); 1083 1084 task->tk_action = call_refreshresult; 1085 task->tk_status = 0; 1086 task->tk_client->cl_stats->rpcauthrefresh++; 1087 rpcauth_refreshcred(task); 1088} 1089 1090/* 1091 * 2a. Process the results of a credential refresh 1092 */ 1093static void 1094call_refreshresult(struct rpc_task *task) 1095{ 1096 int status = task->tk_status; 1097 1098 dprint_status(task); 1099 1100 task->tk_status = 0; 1101 task->tk_action = call_refresh; 1102 switch (status) { 1103 case 0: 1104 if (rpcauth_uptodatecred(task)) 1105 task->tk_action = call_allocate; 1106 return; 1107 case -ETIMEDOUT: 1108 rpc_delay(task, 3*HZ); 1109 case -EAGAIN: 1110 status = -EACCES; 1111 if (!task->tk_cred_retry) 1112 break; 1113 task->tk_cred_retry--; 1114 dprintk("RPC: %5u %s: retry refresh creds\n", 1115 task->tk_pid, __func__); 1116 return; 1117 } 1118 dprintk("RPC: %5u %s: refresh creds failed with error %d\n", 1119 task->tk_pid, __func__, status); 1120 rpc_exit(task, status); 1121} 1122 1123/* 1124 * 2b. Allocate the buffer. For details, see sched.c:rpc_malloc. 1125 * (Note: buffer memory is freed in xprt_release). 1126 */ 1127static void 1128call_allocate(struct rpc_task *task) 1129{ 1130 unsigned int slack = task->tk_rqstp->rq_cred->cr_auth->au_cslack; 1131 struct rpc_rqst *req = task->tk_rqstp; 1132 struct rpc_xprt *xprt = task->tk_xprt; 1133 struct rpc_procinfo *proc = task->tk_msg.rpc_proc; 1134 1135 dprint_status(task); 1136 1137 task->tk_status = 0; 1138 task->tk_action = call_bind; 1139 1140 if (req->rq_buffer) 1141 return; 1142 1143 if (proc->p_proc != 0) { 1144 BUG_ON(proc->p_arglen == 0); 1145 if (proc->p_decode != NULL) 1146 BUG_ON(proc->p_replen == 0); 1147 } 1148 1149 /* 1150 * Calculate the size (in quads) of the RPC call 1151 * and reply headers, and convert both values 1152 * to byte sizes. 1153 */ 1154 req->rq_callsize = RPC_CALLHDRSIZE + (slack << 1) + proc->p_arglen; 1155 req->rq_callsize <<= 2; 1156 req->rq_rcvsize = RPC_REPHDRSIZE + slack + proc->p_replen; 1157 req->rq_rcvsize <<= 2; 1158 1159 req->rq_buffer = xprt->ops->buf_alloc(task, 1160 req->rq_callsize + req->rq_rcvsize); 1161 if (req->rq_buffer != NULL) 1162 return; 1163 1164 dprintk("RPC: %5u rpc_buffer allocation failed\n", task->tk_pid); 1165 1166 if (RPC_IS_ASYNC(task) || !fatal_signal_pending(current)) { 1167 task->tk_action = call_allocate; 1168 rpc_delay(task, HZ>>4); 1169 return; 1170 } 1171 1172 rpc_exit(task, -ERESTARTSYS); 1173} 1174 1175static inline int 1176rpc_task_need_encode(struct rpc_task *task) 1177{ 1178 return task->tk_rqstp->rq_snd_buf.len == 0; 1179} 1180 1181static inline void 1182rpc_task_force_reencode(struct rpc_task *task) 1183{ 1184 task->tk_rqstp->rq_snd_buf.len = 0; 1185 task->tk_rqstp->rq_bytes_sent = 0; 1186} 1187 1188static inline void 1189rpc_xdr_buf_init(struct xdr_buf *buf, void *start, size_t len) 1190{ 1191 buf->head[0].iov_base = start; 1192 buf->head[0].iov_len = len; 1193 buf->tail[0].iov_len = 0; 1194 buf->page_len = 0; 1195 buf->flags = 0; 1196 buf->len = 0; 1197 buf->buflen = len; 1198} 1199 1200/* 1201 * 3. Encode arguments of an RPC call 1202 */ 1203static void 1204rpc_xdr_encode(struct rpc_task *task) 1205{ 1206 struct rpc_rqst *req = task->tk_rqstp; 1207 kxdreproc_t encode; 1208 __be32 *p; 1209 1210 dprint_status(task); 1211 1212 rpc_xdr_buf_init(&req->rq_snd_buf, 1213 req->rq_buffer, 1214 req->rq_callsize); 1215 rpc_xdr_buf_init(&req->rq_rcv_buf, 1216 (char *)req->rq_buffer + req->rq_callsize, 1217 req->rq_rcvsize); 1218 1219 p = rpc_encode_header(task); 1220 if (p == NULL) { 1221 printk(KERN_INFO "RPC: couldn't encode RPC header, exit EIO\n"); 1222 rpc_exit(task, -EIO); 1223 return; 1224 } 1225 1226 encode = task->tk_msg.rpc_proc->p_encode; 1227 if (encode == NULL) 1228 return; 1229 1230 task->tk_status = rpcauth_wrap_req(task, encode, req, p, 1231 task->tk_msg.rpc_argp); 1232} 1233 1234/* 1235 * 4. Get the server port number if not yet set 1236 */ 1237static void 1238call_bind(struct rpc_task *task) 1239{ 1240 struct rpc_xprt *xprt = task->tk_xprt; 1241 1242 dprint_status(task); 1243 1244 task->tk_action = call_connect; 1245 if (!xprt_bound(xprt)) { 1246 task->tk_action = call_bind_status; 1247 task->tk_timeout = xprt->bind_timeout; 1248 xprt->ops->rpcbind(task); 1249 } 1250} 1251 1252/* 1253 * 4a. Sort out bind result 1254 */ 1255static void 1256call_bind_status(struct rpc_task *task) 1257{ 1258 int status = -EIO; 1259 1260 if (task->tk_status >= 0) { 1261 dprint_status(task); 1262 task->tk_status = 0; 1263 task->tk_action = call_connect; 1264 return; 1265 } 1266 1267 switch (task->tk_status) { 1268 case -ENOMEM: 1269 dprintk("RPC: %5u rpcbind out of memory\n", task->tk_pid); 1270 rpc_delay(task, HZ >> 2); 1271 goto retry_timeout; 1272 case -EACCES: 1273 dprintk("RPC: %5u remote rpcbind: RPC program/version " 1274 "unavailable\n", task->tk_pid); 1275 /* fail immediately if this is an RPC ping */ 1276 if (task->tk_msg.rpc_proc->p_proc == 0) { 1277 status = -EOPNOTSUPP; 1278 break; 1279 } 1280 if (task->tk_rebind_retry == 0) 1281 break; 1282 task->tk_rebind_retry--; 1283 rpc_delay(task, 3*HZ); 1284 goto retry_timeout; 1285 case -ETIMEDOUT: 1286 dprintk("RPC: %5u rpcbind request timed out\n", 1287 task->tk_pid); 1288 goto retry_timeout; 1289 case -EPFNOSUPPORT: 1290 /* server doesn't support any rpcbind version we know of */ 1291 dprintk("RPC: %5u unrecognized remote rpcbind service\n", 1292 task->tk_pid); 1293 break; 1294 case -EPROTONOSUPPORT: 1295 dprintk("RPC: %5u remote rpcbind version unavailable, retrying\n", 1296 task->tk_pid); 1297 task->tk_status = 0; 1298 task->tk_action = call_bind; 1299 return; 1300 case -ECONNREFUSED: /* connection problems */ 1301 case -ECONNRESET: 1302 case -ENOTCONN: 1303 case -EHOSTDOWN: 1304 case -EHOSTUNREACH: 1305 case -ENETUNREACH: 1306 case -EPIPE: 1307 dprintk("RPC: %5u remote rpcbind unreachable: %d\n", 1308 task->tk_pid, task->tk_status); 1309 if (!RPC_IS_SOFTCONN(task)) { 1310 rpc_delay(task, 5*HZ); 1311 goto retry_timeout; 1312 } 1313 status = task->tk_status; 1314 break; 1315 default: 1316 dprintk("RPC: %5u unrecognized rpcbind error (%d)\n", 1317 task->tk_pid, -task->tk_status); 1318 } 1319 1320 rpc_exit(task, status); 1321 return; 1322 1323retry_timeout: 1324 task->tk_action = call_timeout; 1325} 1326 1327/* 1328 * 4b. Connect to the RPC server 1329 */ 1330static void 1331call_connect(struct rpc_task *task) 1332{ 1333 struct rpc_xprt *xprt = task->tk_xprt; 1334 1335 dprintk("RPC: %5u call_connect xprt %p %s connected\n", 1336 task->tk_pid, xprt, 1337 (xprt_connected(xprt) ? "is" : "is not")); 1338 1339 task->tk_action = call_transmit; 1340 if (!xprt_connected(xprt)) { 1341 task->tk_action = call_connect_status; 1342 if (task->tk_status < 0) 1343 return; 1344 xprt_connect(task); 1345 } 1346} 1347 1348/* 1349 * 4c. Sort out connect result 1350 */ 1351static void 1352call_connect_status(struct rpc_task *task) 1353{ 1354 struct rpc_clnt *clnt = task->tk_client; 1355 int status = task->tk_status; 1356 1357 dprint_status(task); 1358 1359 task->tk_status = 0; 1360 if (status >= 0 || status == -EAGAIN) { 1361 clnt->cl_stats->netreconn++; 1362 task->tk_action = call_transmit; 1363 return; 1364 } 1365 1366 switch (status) { 1367 /* if soft mounted, test if we've timed out */ 1368 case -ETIMEDOUT: 1369 task->tk_action = call_timeout; 1370 break; 1371 default: 1372 rpc_exit(task, -EIO); 1373 } 1374} 1375 1376/* 1377 * 5. Transmit the RPC request, and wait for reply 1378 */ 1379static void 1380call_transmit(struct rpc_task *task) 1381{ 1382 dprint_status(task); 1383 1384 task->tk_action = call_status; 1385 if (task->tk_status < 0) 1386 return; 1387 task->tk_status = xprt_prepare_transmit(task); 1388 if (task->tk_status != 0) 1389 return; 1390 task->tk_action = call_transmit_status; 1391 /* Encode here so that rpcsec_gss can use correct sequence number. */ 1392 if (rpc_task_need_encode(task)) { 1393 BUG_ON(task->tk_rqstp->rq_bytes_sent != 0); 1394 rpc_xdr_encode(task); 1395 /* Did the encode result in an error condition? */ 1396 if (task->tk_status != 0) { 1397 /* Was the error nonfatal? */ 1398 if (task->tk_status == -EAGAIN) 1399 rpc_delay(task, HZ >> 4); 1400 else 1401 rpc_exit(task, task->tk_status); 1402 return; 1403 } 1404 } 1405 xprt_transmit(task); 1406 if (task->tk_status < 0) 1407 return; 1408 /* 1409 * On success, ensure that we call xprt_end_transmit() before sleeping 1410 * in order to allow access to the socket to other RPC requests. 1411 */ 1412 call_transmit_status(task); 1413 if (rpc_reply_expected(task)) 1414 return; 1415 task->tk_action = rpc_exit_task; 1416 rpc_wake_up_queued_task(&task->tk_xprt->pending, task); 1417} 1418 1419/* 1420 * 5a. Handle cleanup after a transmission 1421 */ 1422static void 1423call_transmit_status(struct rpc_task *task) 1424{ 1425 task->tk_action = call_status; 1426 1427 /* 1428 * Common case: success. Force the compiler to put this 1429 * test first. 1430 */ 1431 if (task->tk_status == 0) { 1432 xprt_end_transmit(task); 1433 rpc_task_force_reencode(task); 1434 return; 1435 } 1436 1437 switch (task->tk_status) { 1438 case -EAGAIN: 1439 break; 1440 default: 1441 dprint_status(task); 1442 xprt_end_transmit(task); 1443 rpc_task_force_reencode(task); 1444 break; 1445 /* 1446 * Special cases: if we've been waiting on the 1447 * socket's write_space() callback, or if the 1448 * socket just returned a connection error, 1449 * then hold onto the transport lock. 1450 */ 1451 case -ECONNREFUSED: 1452 case -EHOSTDOWN: 1453 case -EHOSTUNREACH: 1454 case -ENETUNREACH: 1455 if (RPC_IS_SOFTCONN(task)) { 1456 xprt_end_transmit(task); 1457 rpc_exit(task, task->tk_status); 1458 break; 1459 } 1460 case -ECONNRESET: 1461 case -ENOTCONN: 1462 case -EPIPE: 1463 rpc_task_force_reencode(task); 1464 } 1465} 1466 1467#if defined(CONFIG_SUNRPC_BACKCHANNEL) 1468/* 1469 * 5b. Send the backchannel RPC reply. On error, drop the reply. In 1470 * addition, disconnect on connectivity errors. 1471 */ 1472static void 1473call_bc_transmit(struct rpc_task *task) 1474{ 1475 struct rpc_rqst *req = task->tk_rqstp; 1476 1477 BUG_ON(task->tk_status != 0); 1478 task->tk_status = xprt_prepare_transmit(task); 1479 if (task->tk_status == -EAGAIN) { 1480 /* 1481 * Could not reserve the transport. Try again after the 1482 * transport is released. 1483 */ 1484 task->tk_status = 0; 1485 task->tk_action = call_bc_transmit; 1486 return; 1487 } 1488 1489 task->tk_action = rpc_exit_task; 1490 if (task->tk_status < 0) { 1491 printk(KERN_NOTICE "RPC: Could not send backchannel reply " 1492 "error: %d\n", task->tk_status); 1493 return; 1494 } 1495 1496 xprt_transmit(task); 1497 xprt_end_transmit(task); 1498 dprint_status(task); 1499 switch (task->tk_status) { 1500 case 0: 1501 /* Success */ 1502 break; 1503 case -EHOSTDOWN: 1504 case -EHOSTUNREACH: 1505 case -ENETUNREACH: 1506 case -ETIMEDOUT: 1507 /* 1508 * Problem reaching the server. Disconnect and let the 1509 * forechannel reestablish the connection. The server will 1510 * have to retransmit the backchannel request and we'll 1511 * reprocess it. Since these ops are idempotent, there's no 1512 * need to cache our reply at this time. 1513 */ 1514 printk(KERN_NOTICE "RPC: Could not send backchannel reply " 1515 "error: %d\n", task->tk_status); 1516 xprt_conditional_disconnect(task->tk_xprt, 1517 req->rq_connect_cookie); 1518 break; 1519 default: 1520 /* 1521 * We were unable to reply and will have to drop the 1522 * request. The server should reconnect and retransmit. 1523 */ 1524 BUG_ON(task->tk_status == -EAGAIN); 1525 printk(KERN_NOTICE "RPC: Could not send backchannel reply " 1526 "error: %d\n", task->tk_status); 1527 break; 1528 } 1529 rpc_wake_up_queued_task(&req->rq_xprt->pending, task); 1530} 1531#endif /* CONFIG_SUNRPC_BACKCHANNEL */ 1532 1533/* 1534 * 6. Sort out the RPC call status 1535 */ 1536static void 1537call_status(struct rpc_task *task) 1538{ 1539 struct rpc_clnt *clnt = task->tk_client; 1540 struct rpc_rqst *req = task->tk_rqstp; 1541 int status; 1542 1543 if (req->rq_reply_bytes_recvd > 0 && !req->rq_bytes_sent) 1544 task->tk_status = req->rq_reply_bytes_recvd; 1545 1546 dprint_status(task); 1547 1548 status = task->tk_status; 1549 if (status >= 0) { 1550 task->tk_action = call_decode; 1551 return; 1552 } 1553 1554 task->tk_status = 0; 1555 switch(status) { 1556 case -EHOSTDOWN: 1557 case -EHOSTUNREACH: 1558 case -ENETUNREACH: 1559 /* 1560 * Delay any retries for 3 seconds, then handle as if it 1561 * were a timeout. 1562 */ 1563 rpc_delay(task, 3*HZ); 1564 case -ETIMEDOUT: 1565 task->tk_action = call_timeout; 1566 if (task->tk_client->cl_discrtry) 1567 xprt_conditional_disconnect(task->tk_xprt, 1568 req->rq_connect_cookie); 1569 break; 1570 case -ECONNRESET: 1571 case -ECONNREFUSED: 1572 rpc_force_rebind(clnt); 1573 rpc_delay(task, 3*HZ); 1574 case -EPIPE: 1575 case -ENOTCONN: 1576 task->tk_action = call_bind; 1577 break; 1578 case -EAGAIN: 1579 task->tk_action = call_transmit; 1580 break; 1581 case -EIO: 1582 /* shutdown or soft timeout */ 1583 rpc_exit(task, status); 1584 break; 1585 default: 1586 if (clnt->cl_chatty) 1587 printk("%s: RPC call returned error %d\n", 1588 clnt->cl_protname, -status); 1589 rpc_exit(task, status); 1590 } 1591} 1592 1593/* 1594 * 6a. Handle RPC timeout 1595 * We do not release the request slot, so we keep using the 1596 * same XID for all retransmits. 1597 */ 1598static void 1599call_timeout(struct rpc_task *task) 1600{ 1601 struct rpc_clnt *clnt = task->tk_client; 1602 1603 if (xprt_adjust_timeout(task->tk_rqstp) == 0) { 1604 dprintk("RPC: %5u call_timeout (minor)\n", task->tk_pid); 1605 goto retry; 1606 } 1607 1608 dprintk("RPC: %5u call_timeout (major)\n", task->tk_pid); 1609 task->tk_timeouts++; 1610 1611 if (RPC_IS_SOFTCONN(task)) { 1612 rpc_exit(task, -ETIMEDOUT); 1613 return; 1614 } 1615 if (RPC_IS_SOFT(task)) { 1616 if (clnt->cl_chatty) 1617 printk(KERN_NOTICE "%s: server %s not responding, timed out\n", 1618 clnt->cl_protname, clnt->cl_server); 1619 if (task->tk_flags & RPC_TASK_TIMEOUT) 1620 rpc_exit(task, -ETIMEDOUT); 1621 else 1622 rpc_exit(task, -EIO); 1623 return; 1624 } 1625 1626 if (!(task->tk_flags & RPC_CALL_MAJORSEEN)) { 1627 task->tk_flags |= RPC_CALL_MAJORSEEN; 1628 if (clnt->cl_chatty) 1629 printk(KERN_NOTICE "%s: server %s not responding, still trying\n", 1630 clnt->cl_protname, clnt->cl_server); 1631 } 1632 rpc_force_rebind(clnt); 1633 /* 1634 * Did our request time out due to an RPCSEC_GSS out-of-sequence 1635 * event? RFC2203 requires the server to drop all such requests. 1636 */ 1637 rpcauth_invalcred(task); 1638 1639retry: 1640 clnt->cl_stats->rpcretrans++; 1641 task->tk_action = call_bind; 1642 task->tk_status = 0; 1643} 1644 1645/* 1646 * 7. Decode the RPC reply 1647 */ 1648static void 1649call_decode(struct rpc_task *task) 1650{ 1651 struct rpc_clnt *clnt = task->tk_client; 1652 struct rpc_rqst *req = task->tk_rqstp; 1653 kxdrdproc_t decode = task->tk_msg.rpc_proc->p_decode; 1654 __be32 *p; 1655 1656 dprint_status(task); 1657 1658 if (task->tk_flags & RPC_CALL_MAJORSEEN) { 1659 if (clnt->cl_chatty) 1660 printk(KERN_NOTICE "%s: server %s OK\n", 1661 clnt->cl_protname, clnt->cl_server); 1662 task->tk_flags &= ~RPC_CALL_MAJORSEEN; 1663 } 1664 1665 /* 1666 * Ensure that we see all writes made by xprt_complete_rqst() 1667 * before it changed req->rq_reply_bytes_recvd. 1668 */ 1669 smp_rmb(); 1670 req->rq_rcv_buf.len = req->rq_private_buf.len; 1671 1672 /* Check that the softirq receive buffer is valid */ 1673 WARN_ON(memcmp(&req->rq_rcv_buf, &req->rq_private_buf, 1674 sizeof(req->rq_rcv_buf)) != 0); 1675 1676 if (req->rq_rcv_buf.len < 12) { 1677 if (!RPC_IS_SOFT(task)) { 1678 task->tk_action = call_bind; 1679 clnt->cl_stats->rpcretrans++; 1680 goto out_retry; 1681 } 1682 dprintk("RPC: %s: too small RPC reply size (%d bytes)\n", 1683 clnt->cl_protname, task->tk_status); 1684 task->tk_action = call_timeout; 1685 goto out_retry; 1686 } 1687 1688 p = rpc_verify_header(task); 1689 if (IS_ERR(p)) { 1690 if (p == ERR_PTR(-EAGAIN)) 1691 goto out_retry; 1692 return; 1693 } 1694 1695 task->tk_action = rpc_exit_task; 1696 1697 if (decode) { 1698 task->tk_status = rpcauth_unwrap_resp(task, decode, req, p, 1699 task->tk_msg.rpc_resp); 1700 } 1701 dprintk("RPC: %5u call_decode result %d\n", task->tk_pid, 1702 task->tk_status); 1703 return; 1704out_retry: 1705 task->tk_status = 0; 1706 /* Note: rpc_verify_header() may have freed the RPC slot */ 1707 if (task->tk_rqstp == req) { 1708 req->rq_reply_bytes_recvd = req->rq_rcv_buf.len = 0; 1709 if (task->tk_client->cl_discrtry) 1710 xprt_conditional_disconnect(task->tk_xprt, 1711 req->rq_connect_cookie); 1712 } 1713} 1714 1715static __be32 * 1716rpc_encode_header(struct rpc_task *task) 1717{ 1718 struct rpc_clnt *clnt = task->tk_client; 1719 struct rpc_rqst *req = task->tk_rqstp; 1720 __be32 *p = req->rq_svec[0].iov_base; 1721 1722 /* FIXME: check buffer size? */ 1723 1724 p = xprt_skip_transport_header(task->tk_xprt, p); 1725 *p++ = req->rq_xid; /* XID */ 1726 *p++ = htonl(RPC_CALL); /* CALL */ 1727 *p++ = htonl(RPC_VERSION); /* RPC version */ 1728 *p++ = htonl(clnt->cl_prog); /* program number */ 1729 *p++ = htonl(clnt->cl_vers); /* program version */ 1730 *p++ = htonl(task->tk_msg.rpc_proc->p_proc); /* procedure */ 1731 p = rpcauth_marshcred(task, p); 1732 req->rq_slen = xdr_adjust_iovec(&req->rq_svec[0], p); 1733 return p; 1734} 1735 1736static __be32 * 1737rpc_verify_header(struct rpc_task *task) 1738{ 1739 struct kvec *iov = &task->tk_rqstp->rq_rcv_buf.head[0]; 1740 int len = task->tk_rqstp->rq_rcv_buf.len >> 2; 1741 __be32 *p = iov->iov_base; 1742 u32 n; 1743 int error = -EACCES; 1744 1745 if ((task->tk_rqstp->rq_rcv_buf.len & 3) != 0) { 1746 /* RFC-1014 says that the representation of XDR data must be a 1747 * multiple of four bytes 1748 * - if it isn't pointer subtraction in the NFS client may give 1749 * undefined results 1750 */ 1751 dprintk("RPC: %5u %s: XDR representation not a multiple of" 1752 " 4 bytes: 0x%x\n", task->tk_pid, __func__, 1753 task->tk_rqstp->rq_rcv_buf.len); 1754 goto out_eio; 1755 } 1756 if ((len -= 3) < 0) 1757 goto out_overflow; 1758 1759 p += 1; /* skip XID */ 1760 if ((n = ntohl(*p++)) != RPC_REPLY) { 1761 dprintk("RPC: %5u %s: not an RPC reply: %x\n", 1762 task->tk_pid, __func__, n); 1763 goto out_garbage; 1764 } 1765 1766 if ((n = ntohl(*p++)) != RPC_MSG_ACCEPTED) { 1767 if (--len < 0) 1768 goto out_overflow; 1769 switch ((n = ntohl(*p++))) { 1770 case RPC_AUTH_ERROR: 1771 break; 1772 case RPC_MISMATCH: 1773 dprintk("RPC: %5u %s: RPC call version mismatch!\n", 1774 task->tk_pid, __func__); 1775 error = -EPROTONOSUPPORT; 1776 goto out_err; 1777 default: 1778 dprintk("RPC: %5u %s: RPC call rejected, " 1779 "unknown error: %x\n", 1780 task->tk_pid, __func__, n); 1781 goto out_eio; 1782 } 1783 if (--len < 0) 1784 goto out_overflow; 1785 switch ((n = ntohl(*p++))) { 1786 case RPC_AUTH_REJECTEDCRED: 1787 case RPC_AUTH_REJECTEDVERF: 1788 case RPCSEC_GSS_CREDPROBLEM: 1789 case RPCSEC_GSS_CTXPROBLEM: 1790 if (!task->tk_cred_retry) 1791 break; 1792 task->tk_cred_retry--; 1793 dprintk("RPC: %5u %s: retry stale creds\n", 1794 task->tk_pid, __func__); 1795 rpcauth_invalcred(task); 1796 /* Ensure we obtain a new XID! */ 1797 xprt_release(task); 1798 task->tk_action = call_reserve; 1799 goto out_retry; 1800 case RPC_AUTH_BADCRED: 1801 case RPC_AUTH_BADVERF: 1802 /* possibly garbled cred/verf? */ 1803 if (!task->tk_garb_retry) 1804 break; 1805 task->tk_garb_retry--; 1806 dprintk("RPC: %5u %s: retry garbled creds\n", 1807 task->tk_pid, __func__); 1808 task->tk_action = call_bind; 1809 goto out_retry; 1810 case RPC_AUTH_TOOWEAK: 1811 printk(KERN_NOTICE "RPC: server %s requires stronger " 1812 "authentication.\n", task->tk_client->cl_server); 1813 break; 1814 default: 1815 dprintk("RPC: %5u %s: unknown auth error: %x\n", 1816 task->tk_pid, __func__, n); 1817 error = -EIO; 1818 } 1819 dprintk("RPC: %5u %s: call rejected %d\n", 1820 task->tk_pid, __func__, n); 1821 goto out_err; 1822 } 1823 if (!(p = rpcauth_checkverf(task, p))) { 1824 dprintk("RPC: %5u %s: auth check failed\n", 1825 task->tk_pid, __func__); 1826 goto out_garbage; /* bad verifier, retry */ 1827 } 1828 len = p - (__be32 *)iov->iov_base - 1; 1829 if (len < 0) 1830 goto out_overflow; 1831 switch ((n = ntohl(*p++))) { 1832 case RPC_SUCCESS: 1833 return p; 1834 case RPC_PROG_UNAVAIL: 1835 dprintk("RPC: %5u %s: program %u is unsupported by server %s\n", 1836 task->tk_pid, __func__, 1837 (unsigned int)task->tk_client->cl_prog, 1838 task->tk_client->cl_server); 1839 error = -EPFNOSUPPORT; 1840 goto out_err; 1841 case RPC_PROG_MISMATCH: 1842 dprintk("RPC: %5u %s: program %u, version %u unsupported by " 1843 "server %s\n", task->tk_pid, __func__, 1844 (unsigned int)task->tk_client->cl_prog, 1845 (unsigned int)task->tk_client->cl_vers, 1846 task->tk_client->cl_server); 1847 error = -EPROTONOSUPPORT; 1848 goto out_err; 1849 case RPC_PROC_UNAVAIL: 1850 dprintk("RPC: %5u %s: proc %s unsupported by program %u, " 1851 "version %u on server %s\n", 1852 task->tk_pid, __func__, 1853 rpc_proc_name(task), 1854 task->tk_client->cl_prog, 1855 task->tk_client->cl_vers, 1856 task->tk_client->cl_server); 1857 error = -EOPNOTSUPP; 1858 goto out_err; 1859 case RPC_GARBAGE_ARGS: 1860 dprintk("RPC: %5u %s: server saw garbage\n", 1861 task->tk_pid, __func__); 1862 break; /* retry */ 1863 default: 1864 dprintk("RPC: %5u %s: server accept status: %x\n", 1865 task->tk_pid, __func__, n); 1866 /* Also retry */ 1867 } 1868 1869out_garbage: 1870 task->tk_client->cl_stats->rpcgarbage++; 1871 if (task->tk_garb_retry) { 1872 task->tk_garb_retry--; 1873 dprintk("RPC: %5u %s: retrying\n", 1874 task->tk_pid, __func__); 1875 task->tk_action = call_bind; 1876out_retry: 1877 return ERR_PTR(-EAGAIN); 1878 } 1879out_eio: 1880 error = -EIO; 1881out_err: 1882 rpc_exit(task, error); 1883 dprintk("RPC: %5u %s: call failed with error %d\n", task->tk_pid, 1884 __func__, error); 1885 return ERR_PTR(error); 1886out_overflow: 1887 dprintk("RPC: %5u %s: server reply was truncated.\n", task->tk_pid, 1888 __func__); 1889 goto out_garbage; 1890} 1891 1892static void rpcproc_encode_null(void *rqstp, struct xdr_stream *xdr, void *obj) 1893{ 1894} 1895 1896static int rpcproc_decode_null(void *rqstp, struct xdr_stream *xdr, void *obj) 1897{ 1898 return 0; 1899} 1900 1901static struct rpc_procinfo rpcproc_null = { 1902 .p_encode = rpcproc_encode_null, 1903 .p_decode = rpcproc_decode_null, 1904}; 1905 1906static int rpc_ping(struct rpc_clnt *clnt) 1907{ 1908 struct rpc_message msg = { 1909 .rpc_proc = &rpcproc_null, 1910 }; 1911 int err; 1912 msg.rpc_cred = authnull_ops.lookup_cred(NULL, NULL, 0); 1913 err = rpc_call_sync(clnt, &msg, RPC_TASK_SOFT | RPC_TASK_SOFTCONN); 1914 put_rpccred(msg.rpc_cred); 1915 return err; 1916} 1917 1918struct rpc_task *rpc_call_null(struct rpc_clnt *clnt, struct rpc_cred *cred, int flags) 1919{ 1920 struct rpc_message msg = { 1921 .rpc_proc = &rpcproc_null, 1922 .rpc_cred = cred, 1923 }; 1924 struct rpc_task_setup task_setup_data = { 1925 .rpc_client = clnt, 1926 .rpc_message = &msg, 1927 .callback_ops = &rpc_default_ops, 1928 .flags = flags, 1929 }; 1930 return rpc_run_task(&task_setup_data); 1931} 1932EXPORT_SYMBOL_GPL(rpc_call_null); 1933 1934#ifdef RPC_DEBUG 1935static void rpc_show_header(void) 1936{ 1937 printk(KERN_INFO "-pid- flgs status -client- --rqstp- " 1938 "-timeout ---ops--\n"); 1939} 1940 1941static void rpc_show_task(const struct rpc_clnt *clnt, 1942 const struct rpc_task *task) 1943{ 1944 const char *rpc_waitq = "none"; 1945 1946 if (RPC_IS_QUEUED(task)) 1947 rpc_waitq = rpc_qname(task->tk_waitqueue); 1948 1949 printk(KERN_INFO "%5u %04x %6d %8p %8p %8ld %8p %sv%u %s a:%ps q:%s\n", 1950 task->tk_pid, task->tk_flags, task->tk_status, 1951 clnt, task->tk_rqstp, task->tk_timeout, task->tk_ops, 1952 clnt->cl_protname, clnt->cl_vers, rpc_proc_name(task), 1953 task->tk_action, rpc_waitq); 1954} 1955 1956void rpc_show_tasks(struct net *net) 1957{ 1958 struct rpc_clnt *clnt; 1959 struct rpc_task *task; 1960 int header = 0; 1961 struct sunrpc_net *sn = net_generic(net, sunrpc_net_id); 1962 1963 spin_lock(&sn->rpc_client_lock); 1964 list_for_each_entry(clnt, &sn->all_clients, cl_clients) { 1965 spin_lock(&clnt->cl_lock); 1966 list_for_each_entry(task, &clnt->cl_tasks, tk_task) { 1967 if (!header) { 1968 rpc_show_header(); 1969 header++; 1970 } 1971 rpc_show_task(clnt, task); 1972 } 1973 spin_unlock(&clnt->cl_lock); 1974 } 1975 spin_unlock(&sn->rpc_client_lock); 1976} 1977#endif 1978