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