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