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