clnt.c revision 0c01695dabe508ecf3a619c36f0918e8d24c0d05
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 remote rpcbind service unavailable\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 default: 1073 dprintk("RPC: %5u unrecognized rpcbind error (%d)\n", 1074 task->tk_pid, -task->tk_status); 1075 } 1076 1077 rpc_exit(task, status); 1078 return; 1079 1080retry_timeout: 1081 task->tk_action = call_timeout; 1082} 1083 1084/* 1085 * 4b. Connect to the RPC server 1086 */ 1087static void 1088call_connect(struct rpc_task *task) 1089{ 1090 struct rpc_xprt *xprt = task->tk_xprt; 1091 1092 dprintk("RPC: %5u call_connect xprt %p %s connected\n", 1093 task->tk_pid, xprt, 1094 (xprt_connected(xprt) ? "is" : "is not")); 1095 1096 task->tk_action = call_transmit; 1097 if (!xprt_connected(xprt)) { 1098 task->tk_action = call_connect_status; 1099 if (task->tk_status < 0) 1100 return; 1101 xprt_connect(task); 1102 } 1103} 1104 1105/* 1106 * 4c. Sort out connect result 1107 */ 1108static void 1109call_connect_status(struct rpc_task *task) 1110{ 1111 struct rpc_clnt *clnt = task->tk_client; 1112 int status = task->tk_status; 1113 1114 dprint_status(task); 1115 1116 task->tk_status = 0; 1117 if (status >= 0 || status == -EAGAIN) { 1118 clnt->cl_stats->netreconn++; 1119 task->tk_action = call_transmit; 1120 return; 1121 } 1122 1123 switch (status) { 1124 /* if soft mounted, test if we've timed out */ 1125 case -ETIMEDOUT: 1126 task->tk_action = call_timeout; 1127 break; 1128 default: 1129 rpc_exit(task, -EIO); 1130 } 1131} 1132 1133/* 1134 * 5. Transmit the RPC request, and wait for reply 1135 */ 1136static void 1137call_transmit(struct rpc_task *task) 1138{ 1139 dprint_status(task); 1140 1141 task->tk_action = call_status; 1142 if (task->tk_status < 0) 1143 return; 1144 task->tk_status = xprt_prepare_transmit(task); 1145 if (task->tk_status != 0) 1146 return; 1147 task->tk_action = call_transmit_status; 1148 /* Encode here so that rpcsec_gss can use correct sequence number. */ 1149 if (rpc_task_need_encode(task)) { 1150 BUG_ON(task->tk_rqstp->rq_bytes_sent != 0); 1151 rpc_xdr_encode(task); 1152 /* Did the encode result in an error condition? */ 1153 if (task->tk_status != 0) { 1154 /* Was the error nonfatal? */ 1155 if (task->tk_status == -EAGAIN) 1156 rpc_delay(task, HZ >> 4); 1157 else 1158 rpc_exit(task, task->tk_status); 1159 return; 1160 } 1161 } 1162 xprt_transmit(task); 1163 if (task->tk_status < 0) 1164 return; 1165 /* 1166 * On success, ensure that we call xprt_end_transmit() before sleeping 1167 * in order to allow access to the socket to other RPC requests. 1168 */ 1169 call_transmit_status(task); 1170 if (rpc_reply_expected(task)) 1171 return; 1172 task->tk_action = rpc_exit_task; 1173 rpc_wake_up_queued_task(&task->tk_xprt->pending, task); 1174} 1175 1176/* 1177 * 5a. Handle cleanup after a transmission 1178 */ 1179static void 1180call_transmit_status(struct rpc_task *task) 1181{ 1182 task->tk_action = call_status; 1183 switch (task->tk_status) { 1184 case -EAGAIN: 1185 break; 1186 default: 1187 xprt_end_transmit(task); 1188 /* 1189 * Special cases: if we've been waiting on the 1190 * socket's write_space() callback, or if the 1191 * socket just returned a connection error, 1192 * then hold onto the transport lock. 1193 */ 1194 case -ECONNREFUSED: 1195 case -ECONNRESET: 1196 case -ENOTCONN: 1197 case -EHOSTDOWN: 1198 case -EHOSTUNREACH: 1199 case -ENETUNREACH: 1200 case -EPIPE: 1201 rpc_task_force_reencode(task); 1202 } 1203} 1204 1205#if defined(CONFIG_NFS_V4_1) 1206/* 1207 * 5b. Send the backchannel RPC reply. On error, drop the reply. In 1208 * addition, disconnect on connectivity errors. 1209 */ 1210static void 1211call_bc_transmit(struct rpc_task *task) 1212{ 1213 struct rpc_rqst *req = task->tk_rqstp; 1214 1215 BUG_ON(task->tk_status != 0); 1216 task->tk_status = xprt_prepare_transmit(task); 1217 if (task->tk_status == -EAGAIN) { 1218 /* 1219 * Could not reserve the transport. Try again after the 1220 * transport is released. 1221 */ 1222 task->tk_status = 0; 1223 task->tk_action = call_bc_transmit; 1224 return; 1225 } 1226 1227 task->tk_action = rpc_exit_task; 1228 if (task->tk_status < 0) { 1229 printk(KERN_NOTICE "RPC: Could not send backchannel reply " 1230 "error: %d\n", task->tk_status); 1231 return; 1232 } 1233 1234 xprt_transmit(task); 1235 xprt_end_transmit(task); 1236 dprint_status(task); 1237 switch (task->tk_status) { 1238 case 0: 1239 /* Success */ 1240 break; 1241 case -EHOSTDOWN: 1242 case -EHOSTUNREACH: 1243 case -ENETUNREACH: 1244 case -ETIMEDOUT: 1245 /* 1246 * Problem reaching the server. Disconnect and let the 1247 * forechannel reestablish the connection. The server will 1248 * have to retransmit the backchannel request and we'll 1249 * reprocess it. Since these ops are idempotent, there's no 1250 * need to cache our reply at this time. 1251 */ 1252 printk(KERN_NOTICE "RPC: Could not send backchannel reply " 1253 "error: %d\n", task->tk_status); 1254 xprt_conditional_disconnect(task->tk_xprt, 1255 req->rq_connect_cookie); 1256 break; 1257 default: 1258 /* 1259 * We were unable to reply and will have to drop the 1260 * request. The server should reconnect and retransmit. 1261 */ 1262 BUG_ON(task->tk_status == -EAGAIN); 1263 printk(KERN_NOTICE "RPC: Could not send backchannel reply " 1264 "error: %d\n", task->tk_status); 1265 break; 1266 } 1267 rpc_wake_up_queued_task(&req->rq_xprt->pending, task); 1268} 1269#endif /* CONFIG_NFS_V4_1 */ 1270 1271/* 1272 * 6. Sort out the RPC call status 1273 */ 1274static void 1275call_status(struct rpc_task *task) 1276{ 1277 struct rpc_clnt *clnt = task->tk_client; 1278 struct rpc_rqst *req = task->tk_rqstp; 1279 int status; 1280 1281 if (req->rq_reply_bytes_recvd > 0 && !req->rq_bytes_sent) 1282 task->tk_status = req->rq_reply_bytes_recvd; 1283 1284 dprint_status(task); 1285 1286 status = task->tk_status; 1287 if (status >= 0) { 1288 task->tk_action = call_decode; 1289 return; 1290 } 1291 1292 task->tk_status = 0; 1293 switch(status) { 1294 case -EHOSTDOWN: 1295 case -EHOSTUNREACH: 1296 case -ENETUNREACH: 1297 /* 1298 * Delay any retries for 3 seconds, then handle as if it 1299 * were a timeout. 1300 */ 1301 rpc_delay(task, 3*HZ); 1302 case -ETIMEDOUT: 1303 task->tk_action = call_timeout; 1304 if (task->tk_client->cl_discrtry) 1305 xprt_conditional_disconnect(task->tk_xprt, 1306 req->rq_connect_cookie); 1307 break; 1308 case -ECONNRESET: 1309 case -ECONNREFUSED: 1310 rpc_force_rebind(clnt); 1311 rpc_delay(task, 3*HZ); 1312 case -EPIPE: 1313 case -ENOTCONN: 1314 task->tk_action = call_bind; 1315 break; 1316 case -EAGAIN: 1317 task->tk_action = call_transmit; 1318 break; 1319 case -EIO: 1320 /* shutdown or soft timeout */ 1321 rpc_exit(task, status); 1322 break; 1323 default: 1324 if (clnt->cl_chatty) 1325 printk("%s: RPC call returned error %d\n", 1326 clnt->cl_protname, -status); 1327 rpc_exit(task, status); 1328 } 1329} 1330 1331/* 1332 * 6a. Handle RPC timeout 1333 * We do not release the request slot, so we keep using the 1334 * same XID for all retransmits. 1335 */ 1336static void 1337call_timeout(struct rpc_task *task) 1338{ 1339 struct rpc_clnt *clnt = task->tk_client; 1340 1341 if (xprt_adjust_timeout(task->tk_rqstp) == 0) { 1342 dprintk("RPC: %5u call_timeout (minor)\n", task->tk_pid); 1343 goto retry; 1344 } 1345 1346 dprintk("RPC: %5u call_timeout (major)\n", task->tk_pid); 1347 task->tk_timeouts++; 1348 1349 if (RPC_IS_SOFT(task)) { 1350 if (clnt->cl_chatty) 1351 printk(KERN_NOTICE "%s: server %s not responding, timed out\n", 1352 clnt->cl_protname, clnt->cl_server); 1353 rpc_exit(task, -EIO); 1354 return; 1355 } 1356 1357 if (!(task->tk_flags & RPC_CALL_MAJORSEEN)) { 1358 task->tk_flags |= RPC_CALL_MAJORSEEN; 1359 if (clnt->cl_chatty) 1360 printk(KERN_NOTICE "%s: server %s not responding, still trying\n", 1361 clnt->cl_protname, clnt->cl_server); 1362 } 1363 rpc_force_rebind(clnt); 1364 /* 1365 * Did our request time out due to an RPCSEC_GSS out-of-sequence 1366 * event? RFC2203 requires the server to drop all such requests. 1367 */ 1368 rpcauth_invalcred(task); 1369 1370retry: 1371 clnt->cl_stats->rpcretrans++; 1372 task->tk_action = call_bind; 1373 task->tk_status = 0; 1374} 1375 1376/* 1377 * 7. Decode the RPC reply 1378 */ 1379static void 1380call_decode(struct rpc_task *task) 1381{ 1382 struct rpc_clnt *clnt = task->tk_client; 1383 struct rpc_rqst *req = task->tk_rqstp; 1384 kxdrproc_t decode = task->tk_msg.rpc_proc->p_decode; 1385 __be32 *p; 1386 1387 dprintk("RPC: %5u call_decode (status %d)\n", 1388 task->tk_pid, task->tk_status); 1389 1390 if (task->tk_flags & RPC_CALL_MAJORSEEN) { 1391 if (clnt->cl_chatty) 1392 printk(KERN_NOTICE "%s: server %s OK\n", 1393 clnt->cl_protname, clnt->cl_server); 1394 task->tk_flags &= ~RPC_CALL_MAJORSEEN; 1395 } 1396 1397 /* 1398 * Ensure that we see all writes made by xprt_complete_rqst() 1399 * before it changed req->rq_reply_bytes_recvd. 1400 */ 1401 smp_rmb(); 1402 req->rq_rcv_buf.len = req->rq_private_buf.len; 1403 1404 /* Check that the softirq receive buffer is valid */ 1405 WARN_ON(memcmp(&req->rq_rcv_buf, &req->rq_private_buf, 1406 sizeof(req->rq_rcv_buf)) != 0); 1407 1408 if (req->rq_rcv_buf.len < 12) { 1409 if (!RPC_IS_SOFT(task)) { 1410 task->tk_action = call_bind; 1411 clnt->cl_stats->rpcretrans++; 1412 goto out_retry; 1413 } 1414 dprintk("RPC: %s: too small RPC reply size (%d bytes)\n", 1415 clnt->cl_protname, task->tk_status); 1416 task->tk_action = call_timeout; 1417 goto out_retry; 1418 } 1419 1420 p = rpc_verify_header(task); 1421 if (IS_ERR(p)) { 1422 if (p == ERR_PTR(-EAGAIN)) 1423 goto out_retry; 1424 return; 1425 } 1426 1427 task->tk_action = rpc_exit_task; 1428 1429 if (decode) { 1430 task->tk_status = rpcauth_unwrap_resp(task, decode, req, p, 1431 task->tk_msg.rpc_resp); 1432 } 1433 dprintk("RPC: %5u call_decode result %d\n", task->tk_pid, 1434 task->tk_status); 1435 return; 1436out_retry: 1437 task->tk_status = 0; 1438 /* Note: rpc_verify_header() may have freed the RPC slot */ 1439 if (task->tk_rqstp == req) { 1440 req->rq_reply_bytes_recvd = req->rq_rcv_buf.len = 0; 1441 if (task->tk_client->cl_discrtry) 1442 xprt_conditional_disconnect(task->tk_xprt, 1443 req->rq_connect_cookie); 1444 } 1445} 1446 1447/* 1448 * 8. Refresh the credentials if rejected by the server 1449 */ 1450static void 1451call_refresh(struct rpc_task *task) 1452{ 1453 dprint_status(task); 1454 1455 task->tk_action = call_refreshresult; 1456 task->tk_status = 0; 1457 task->tk_client->cl_stats->rpcauthrefresh++; 1458 rpcauth_refreshcred(task); 1459} 1460 1461/* 1462 * 8a. Process the results of a credential refresh 1463 */ 1464static void 1465call_refreshresult(struct rpc_task *task) 1466{ 1467 int status = task->tk_status; 1468 1469 dprint_status(task); 1470 1471 task->tk_status = 0; 1472 task->tk_action = call_reserve; 1473 if (status >= 0 && rpcauth_uptodatecred(task)) 1474 return; 1475 if (status == -EACCES) { 1476 rpc_exit(task, -EACCES); 1477 return; 1478 } 1479 task->tk_action = call_refresh; 1480 if (status != -ETIMEDOUT) 1481 rpc_delay(task, 3*HZ); 1482 return; 1483} 1484 1485static __be32 * 1486rpc_encode_header(struct rpc_task *task) 1487{ 1488 struct rpc_clnt *clnt = task->tk_client; 1489 struct rpc_rqst *req = task->tk_rqstp; 1490 __be32 *p = req->rq_svec[0].iov_base; 1491 1492 /* FIXME: check buffer size? */ 1493 1494 p = xprt_skip_transport_header(task->tk_xprt, p); 1495 *p++ = req->rq_xid; /* XID */ 1496 *p++ = htonl(RPC_CALL); /* CALL */ 1497 *p++ = htonl(RPC_VERSION); /* RPC version */ 1498 *p++ = htonl(clnt->cl_prog); /* program number */ 1499 *p++ = htonl(clnt->cl_vers); /* program version */ 1500 *p++ = htonl(task->tk_msg.rpc_proc->p_proc); /* procedure */ 1501 p = rpcauth_marshcred(task, p); 1502 req->rq_slen = xdr_adjust_iovec(&req->rq_svec[0], p); 1503 return p; 1504} 1505 1506static __be32 * 1507rpc_verify_header(struct rpc_task *task) 1508{ 1509 struct kvec *iov = &task->tk_rqstp->rq_rcv_buf.head[0]; 1510 int len = task->tk_rqstp->rq_rcv_buf.len >> 2; 1511 __be32 *p = iov->iov_base; 1512 u32 n; 1513 int error = -EACCES; 1514 1515 if ((task->tk_rqstp->rq_rcv_buf.len & 3) != 0) { 1516 /* RFC-1014 says that the representation of XDR data must be a 1517 * multiple of four bytes 1518 * - if it isn't pointer subtraction in the NFS client may give 1519 * undefined results 1520 */ 1521 dprintk("RPC: %5u %s: XDR representation not a multiple of" 1522 " 4 bytes: 0x%x\n", task->tk_pid, __func__, 1523 task->tk_rqstp->rq_rcv_buf.len); 1524 goto out_eio; 1525 } 1526 if ((len -= 3) < 0) 1527 goto out_overflow; 1528 1529 p += 1; /* skip XID */ 1530 if ((n = ntohl(*p++)) != RPC_REPLY) { 1531 dprintk("RPC: %5u %s: not an RPC reply: %x\n", 1532 task->tk_pid, __func__, n); 1533 goto out_garbage; 1534 } 1535 1536 if ((n = ntohl(*p++)) != RPC_MSG_ACCEPTED) { 1537 if (--len < 0) 1538 goto out_overflow; 1539 switch ((n = ntohl(*p++))) { 1540 case RPC_AUTH_ERROR: 1541 break; 1542 case RPC_MISMATCH: 1543 dprintk("RPC: %5u %s: RPC call version " 1544 "mismatch!\n", 1545 task->tk_pid, __func__); 1546 error = -EPROTONOSUPPORT; 1547 goto out_err; 1548 default: 1549 dprintk("RPC: %5u %s: RPC call rejected, " 1550 "unknown error: %x\n", 1551 task->tk_pid, __func__, n); 1552 goto out_eio; 1553 } 1554 if (--len < 0) 1555 goto out_overflow; 1556 switch ((n = ntohl(*p++))) { 1557 case RPC_AUTH_REJECTEDCRED: 1558 case RPC_AUTH_REJECTEDVERF: 1559 case RPCSEC_GSS_CREDPROBLEM: 1560 case RPCSEC_GSS_CTXPROBLEM: 1561 if (!task->tk_cred_retry) 1562 break; 1563 task->tk_cred_retry--; 1564 dprintk("RPC: %5u %s: retry stale creds\n", 1565 task->tk_pid, __func__); 1566 rpcauth_invalcred(task); 1567 /* Ensure we obtain a new XID! */ 1568 xprt_release(task); 1569 task->tk_action = call_refresh; 1570 goto out_retry; 1571 case RPC_AUTH_BADCRED: 1572 case RPC_AUTH_BADVERF: 1573 /* possibly garbled cred/verf? */ 1574 if (!task->tk_garb_retry) 1575 break; 1576 task->tk_garb_retry--; 1577 dprintk("RPC: %5u %s: retry garbled creds\n", 1578 task->tk_pid, __func__); 1579 task->tk_action = call_bind; 1580 goto out_retry; 1581 case RPC_AUTH_TOOWEAK: 1582 printk(KERN_NOTICE "RPC: server %s requires stronger " 1583 "authentication.\n", task->tk_client->cl_server); 1584 break; 1585 default: 1586 dprintk("RPC: %5u %s: unknown auth error: %x\n", 1587 task->tk_pid, __func__, n); 1588 error = -EIO; 1589 } 1590 dprintk("RPC: %5u %s: call rejected %d\n", 1591 task->tk_pid, __func__, n); 1592 goto out_err; 1593 } 1594 if (!(p = rpcauth_checkverf(task, p))) { 1595 dprintk("RPC: %5u %s: auth check failed\n", 1596 task->tk_pid, __func__); 1597 goto out_garbage; /* bad verifier, retry */ 1598 } 1599 len = p - (__be32 *)iov->iov_base - 1; 1600 if (len < 0) 1601 goto out_overflow; 1602 switch ((n = ntohl(*p++))) { 1603 case RPC_SUCCESS: 1604 return p; 1605 case RPC_PROG_UNAVAIL: 1606 dprintk("RPC: %5u %s: program %u is unsupported by server %s\n", 1607 task->tk_pid, __func__, 1608 (unsigned int)task->tk_client->cl_prog, 1609 task->tk_client->cl_server); 1610 error = -EPFNOSUPPORT; 1611 goto out_err; 1612 case RPC_PROG_MISMATCH: 1613 dprintk("RPC: %5u %s: program %u, version %u unsupported by " 1614 "server %s\n", task->tk_pid, __func__, 1615 (unsigned int)task->tk_client->cl_prog, 1616 (unsigned int)task->tk_client->cl_vers, 1617 task->tk_client->cl_server); 1618 error = -EPROTONOSUPPORT; 1619 goto out_err; 1620 case RPC_PROC_UNAVAIL: 1621 dprintk("RPC: %5u %s: proc %s unsupported by program %u, " 1622 "version %u on server %s\n", 1623 task->tk_pid, __func__, 1624 rpc_proc_name(task), 1625 task->tk_client->cl_prog, 1626 task->tk_client->cl_vers, 1627 task->tk_client->cl_server); 1628 error = -EOPNOTSUPP; 1629 goto out_err; 1630 case RPC_GARBAGE_ARGS: 1631 dprintk("RPC: %5u %s: server saw garbage\n", 1632 task->tk_pid, __func__); 1633 break; /* retry */ 1634 default: 1635 dprintk("RPC: %5u %s: server accept status: %x\n", 1636 task->tk_pid, __func__, n); 1637 /* Also retry */ 1638 } 1639 1640out_garbage: 1641 task->tk_client->cl_stats->rpcgarbage++; 1642 if (task->tk_garb_retry) { 1643 task->tk_garb_retry--; 1644 dprintk("RPC: %5u %s: retrying\n", 1645 task->tk_pid, __func__); 1646 task->tk_action = call_bind; 1647out_retry: 1648 return ERR_PTR(-EAGAIN); 1649 } 1650out_eio: 1651 error = -EIO; 1652out_err: 1653 rpc_exit(task, error); 1654 dprintk("RPC: %5u %s: call failed with error %d\n", task->tk_pid, 1655 __func__, error); 1656 return ERR_PTR(error); 1657out_overflow: 1658 dprintk("RPC: %5u %s: server reply was truncated.\n", task->tk_pid, 1659 __func__); 1660 goto out_garbage; 1661} 1662 1663static int rpcproc_encode_null(void *rqstp, __be32 *data, void *obj) 1664{ 1665 return 0; 1666} 1667 1668static int rpcproc_decode_null(void *rqstp, __be32 *data, void *obj) 1669{ 1670 return 0; 1671} 1672 1673static struct rpc_procinfo rpcproc_null = { 1674 .p_encode = rpcproc_encode_null, 1675 .p_decode = rpcproc_decode_null, 1676}; 1677 1678static int rpc_ping(struct rpc_clnt *clnt, int flags) 1679{ 1680 struct rpc_message msg = { 1681 .rpc_proc = &rpcproc_null, 1682 }; 1683 int err; 1684 msg.rpc_cred = authnull_ops.lookup_cred(NULL, NULL, 0); 1685 err = rpc_call_sync(clnt, &msg, flags); 1686 put_rpccred(msg.rpc_cred); 1687 return err; 1688} 1689 1690struct rpc_task *rpc_call_null(struct rpc_clnt *clnt, struct rpc_cred *cred, int flags) 1691{ 1692 struct rpc_message msg = { 1693 .rpc_proc = &rpcproc_null, 1694 .rpc_cred = cred, 1695 }; 1696 struct rpc_task_setup task_setup_data = { 1697 .rpc_client = clnt, 1698 .rpc_message = &msg, 1699 .callback_ops = &rpc_default_ops, 1700 .flags = flags, 1701 }; 1702 return rpc_run_task(&task_setup_data); 1703} 1704EXPORT_SYMBOL_GPL(rpc_call_null); 1705 1706#ifdef RPC_DEBUG 1707static void rpc_show_header(void) 1708{ 1709 printk(KERN_INFO "-pid- flgs status -client- --rqstp- " 1710 "-timeout ---ops--\n"); 1711} 1712 1713static void rpc_show_task(const struct rpc_clnt *clnt, 1714 const struct rpc_task *task) 1715{ 1716 const char *rpc_waitq = "none"; 1717 char *p, action[KSYM_SYMBOL_LEN]; 1718 1719 if (RPC_IS_QUEUED(task)) 1720 rpc_waitq = rpc_qname(task->tk_waitqueue); 1721 1722 /* map tk_action pointer to a function name; then trim off 1723 * the "+0x0 [sunrpc]" */ 1724 sprint_symbol(action, (unsigned long)task->tk_action); 1725 p = strchr(action, '+'); 1726 if (p) 1727 *p = '\0'; 1728 1729 printk(KERN_INFO "%5u %04x %6d %8p %8p %8ld %8p %sv%u %s a:%s q:%s\n", 1730 task->tk_pid, task->tk_flags, task->tk_status, 1731 clnt, task->tk_rqstp, task->tk_timeout, task->tk_ops, 1732 clnt->cl_protname, clnt->cl_vers, rpc_proc_name(task), 1733 action, rpc_waitq); 1734} 1735 1736void rpc_show_tasks(void) 1737{ 1738 struct rpc_clnt *clnt; 1739 struct rpc_task *task; 1740 int header = 0; 1741 1742 spin_lock(&rpc_client_lock); 1743 list_for_each_entry(clnt, &all_clients, cl_clients) { 1744 spin_lock(&clnt->cl_lock); 1745 list_for_each_entry(task, &clnt->cl_tasks, tk_task) { 1746 if (!header) { 1747 rpc_show_header(); 1748 header++; 1749 } 1750 rpc_show_task(clnt, task); 1751 } 1752 spin_unlock(&clnt->cl_lock); 1753 } 1754 spin_unlock(&rpc_client_lock); 1755} 1756#endif 1757