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