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