xprt.c revision e8914c65f7f8d4e8701b8e78a12b714872ea0402
1/* 2 * linux/net/sunrpc/xprt.c 3 * 4 * This is a generic RPC call interface supporting congestion avoidance, 5 * and asynchronous calls. 6 * 7 * The interface works like this: 8 * 9 * - When a process places a call, it allocates a request slot if 10 * one is available. Otherwise, it sleeps on the backlog queue 11 * (xprt_reserve). 12 * - Next, the caller puts together the RPC message, stuffs it into 13 * the request struct, and calls xprt_transmit(). 14 * - xprt_transmit sends the message and installs the caller on the 15 * transport's wait list. At the same time, it installs a timer that 16 * is run after the packet's timeout has expired. 17 * - When a packet arrives, the data_ready handler walks the list of 18 * pending requests for that transport. If a matching XID is found, the 19 * caller is woken up, and the timer removed. 20 * - When no reply arrives within the timeout interval, the timer is 21 * fired by the kernel and runs xprt_timer(). It either adjusts the 22 * timeout values (minor timeout) or wakes up the caller with a status 23 * of -ETIMEDOUT. 24 * - When the caller receives a notification from RPC that a reply arrived, 25 * it should release the RPC slot, and process the reply. 26 * If the call timed out, it may choose to retry the operation by 27 * adjusting the initial timeout value, and simply calling rpc_call 28 * again. 29 * 30 * Support for async RPC is done through a set of RPC-specific scheduling 31 * primitives that `transparently' work for processes as well as async 32 * tasks that rely on callbacks. 33 * 34 * Copyright (C) 1995-1997, Olaf Kirch <okir@monad.swb.de> 35 * 36 * Transport switch API copyright (C) 2005, Chuck Lever <cel@netapp.com> 37 */ 38 39#include <linux/module.h> 40 41#include <linux/types.h> 42#include <linux/interrupt.h> 43#include <linux/workqueue.h> 44#include <linux/net.h> 45 46#include <linux/sunrpc/clnt.h> 47#include <linux/sunrpc/metrics.h> 48 49/* 50 * Local variables 51 */ 52 53#ifdef RPC_DEBUG 54# define RPCDBG_FACILITY RPCDBG_XPRT 55#endif 56 57/* 58 * Local functions 59 */ 60static void xprt_request_init(struct rpc_task *, struct rpc_xprt *); 61static inline void do_xprt_reserve(struct rpc_task *); 62static void xprt_connect_status(struct rpc_task *task); 63static int __xprt_get_cong(struct rpc_xprt *, struct rpc_task *); 64 65static DEFINE_SPINLOCK(xprt_list_lock); 66static LIST_HEAD(xprt_list); 67 68/* 69 * The transport code maintains an estimate on the maximum number of out- 70 * standing RPC requests, using a smoothed version of the congestion 71 * avoidance implemented in 44BSD. This is basically the Van Jacobson 72 * congestion algorithm: If a retransmit occurs, the congestion window is 73 * halved; otherwise, it is incremented by 1/cwnd when 74 * 75 * - a reply is received and 76 * - a full number of requests are outstanding and 77 * - the congestion window hasn't been updated recently. 78 */ 79#define RPC_CWNDSHIFT (8U) 80#define RPC_CWNDSCALE (1U << RPC_CWNDSHIFT) 81#define RPC_INITCWND RPC_CWNDSCALE 82#define RPC_MAXCWND(xprt) ((xprt)->max_reqs << RPC_CWNDSHIFT) 83 84#define RPCXPRT_CONGESTED(xprt) ((xprt)->cong >= (xprt)->cwnd) 85 86/** 87 * xprt_register_transport - register a transport implementation 88 * @transport: transport to register 89 * 90 * If a transport implementation is loaded as a kernel module, it can 91 * call this interface to make itself known to the RPC client. 92 * 93 * Returns: 94 * 0: transport successfully registered 95 * -EEXIST: transport already registered 96 * -EINVAL: transport module being unloaded 97 */ 98int xprt_register_transport(struct xprt_class *transport) 99{ 100 struct xprt_class *t; 101 int result; 102 103 result = -EEXIST; 104 spin_lock(&xprt_list_lock); 105 list_for_each_entry(t, &xprt_list, list) { 106 /* don't register the same transport class twice */ 107 if (t->ident == transport->ident) 108 goto out; 109 } 110 111 result = -EINVAL; 112 if (try_module_get(THIS_MODULE)) { 113 list_add_tail(&transport->list, &xprt_list); 114 printk(KERN_INFO "RPC: Registered %s transport module.\n", 115 transport->name); 116 result = 0; 117 } 118 119out: 120 spin_unlock(&xprt_list_lock); 121 return result; 122} 123EXPORT_SYMBOL_GPL(xprt_register_transport); 124 125/** 126 * xprt_unregister_transport - unregister a transport implementation 127 * transport: transport to unregister 128 * 129 * Returns: 130 * 0: transport successfully unregistered 131 * -ENOENT: transport never registered 132 */ 133int xprt_unregister_transport(struct xprt_class *transport) 134{ 135 struct xprt_class *t; 136 int result; 137 138 result = 0; 139 spin_lock(&xprt_list_lock); 140 list_for_each_entry(t, &xprt_list, list) { 141 if (t == transport) { 142 printk(KERN_INFO 143 "RPC: Unregistered %s transport module.\n", 144 transport->name); 145 list_del_init(&transport->list); 146 module_put(THIS_MODULE); 147 goto out; 148 } 149 } 150 result = -ENOENT; 151 152out: 153 spin_unlock(&xprt_list_lock); 154 return result; 155} 156EXPORT_SYMBOL_GPL(xprt_unregister_transport); 157 158/** 159 * xprt_reserve_xprt - serialize write access to transports 160 * @task: task that is requesting access to the transport 161 * 162 * This prevents mixing the payload of separate requests, and prevents 163 * transport connects from colliding with writes. No congestion control 164 * is provided. 165 */ 166int xprt_reserve_xprt(struct rpc_task *task) 167{ 168 struct rpc_xprt *xprt = task->tk_xprt; 169 struct rpc_rqst *req = task->tk_rqstp; 170 171 if (test_and_set_bit(XPRT_LOCKED, &xprt->state)) { 172 if (task == xprt->snd_task) 173 return 1; 174 if (task == NULL) 175 return 0; 176 goto out_sleep; 177 } 178 xprt->snd_task = task; 179 if (req) { 180 req->rq_bytes_sent = 0; 181 req->rq_ntrans++; 182 } 183 return 1; 184 185out_sleep: 186 dprintk("RPC: %5u failed to lock transport %p\n", 187 task->tk_pid, xprt); 188 task->tk_timeout = 0; 189 task->tk_status = -EAGAIN; 190 if (req && req->rq_ntrans) 191 rpc_sleep_on(&xprt->resend, task, NULL, NULL); 192 else 193 rpc_sleep_on(&xprt->sending, task, NULL, NULL); 194 return 0; 195} 196EXPORT_SYMBOL_GPL(xprt_reserve_xprt); 197 198static void xprt_clear_locked(struct rpc_xprt *xprt) 199{ 200 xprt->snd_task = NULL; 201 if (!test_bit(XPRT_CLOSE_WAIT, &xprt->state) || xprt->shutdown) { 202 smp_mb__before_clear_bit(); 203 clear_bit(XPRT_LOCKED, &xprt->state); 204 smp_mb__after_clear_bit(); 205 } else 206 queue_work(rpciod_workqueue, &xprt->task_cleanup); 207} 208 209/* 210 * xprt_reserve_xprt_cong - serialize write access to transports 211 * @task: task that is requesting access to the transport 212 * 213 * Same as xprt_reserve_xprt, but Van Jacobson congestion control is 214 * integrated into the decision of whether a request is allowed to be 215 * woken up and given access to the transport. 216 */ 217int xprt_reserve_xprt_cong(struct rpc_task *task) 218{ 219 struct rpc_xprt *xprt = task->tk_xprt; 220 struct rpc_rqst *req = task->tk_rqstp; 221 222 if (test_and_set_bit(XPRT_LOCKED, &xprt->state)) { 223 if (task == xprt->snd_task) 224 return 1; 225 goto out_sleep; 226 } 227 if (__xprt_get_cong(xprt, task)) { 228 xprt->snd_task = task; 229 if (req) { 230 req->rq_bytes_sent = 0; 231 req->rq_ntrans++; 232 } 233 return 1; 234 } 235 xprt_clear_locked(xprt); 236out_sleep: 237 dprintk("RPC: %5u failed to lock transport %p\n", task->tk_pid, xprt); 238 task->tk_timeout = 0; 239 task->tk_status = -EAGAIN; 240 if (req && req->rq_ntrans) 241 rpc_sleep_on(&xprt->resend, task, NULL, NULL); 242 else 243 rpc_sleep_on(&xprt->sending, task, NULL, NULL); 244 return 0; 245} 246EXPORT_SYMBOL_GPL(xprt_reserve_xprt_cong); 247 248static inline int xprt_lock_write(struct rpc_xprt *xprt, struct rpc_task *task) 249{ 250 int retval; 251 252 spin_lock_bh(&xprt->transport_lock); 253 retval = xprt->ops->reserve_xprt(task); 254 spin_unlock_bh(&xprt->transport_lock); 255 return retval; 256} 257 258static void __xprt_lock_write_next(struct rpc_xprt *xprt) 259{ 260 struct rpc_task *task; 261 struct rpc_rqst *req; 262 263 if (test_and_set_bit(XPRT_LOCKED, &xprt->state)) 264 return; 265 266 task = rpc_wake_up_next(&xprt->resend); 267 if (!task) { 268 task = rpc_wake_up_next(&xprt->sending); 269 if (!task) 270 goto out_unlock; 271 } 272 273 req = task->tk_rqstp; 274 xprt->snd_task = task; 275 if (req) { 276 req->rq_bytes_sent = 0; 277 req->rq_ntrans++; 278 } 279 return; 280 281out_unlock: 282 xprt_clear_locked(xprt); 283} 284 285static void __xprt_lock_write_next_cong(struct rpc_xprt *xprt) 286{ 287 struct rpc_task *task; 288 289 if (test_and_set_bit(XPRT_LOCKED, &xprt->state)) 290 return; 291 if (RPCXPRT_CONGESTED(xprt)) 292 goto out_unlock; 293 task = rpc_wake_up_next(&xprt->resend); 294 if (!task) { 295 task = rpc_wake_up_next(&xprt->sending); 296 if (!task) 297 goto out_unlock; 298 } 299 if (__xprt_get_cong(xprt, task)) { 300 struct rpc_rqst *req = task->tk_rqstp; 301 xprt->snd_task = task; 302 if (req) { 303 req->rq_bytes_sent = 0; 304 req->rq_ntrans++; 305 } 306 return; 307 } 308out_unlock: 309 xprt_clear_locked(xprt); 310} 311 312/** 313 * xprt_release_xprt - allow other requests to use a transport 314 * @xprt: transport with other tasks potentially waiting 315 * @task: task that is releasing access to the transport 316 * 317 * Note that "task" can be NULL. No congestion control is provided. 318 */ 319void xprt_release_xprt(struct rpc_xprt *xprt, struct rpc_task *task) 320{ 321 if (xprt->snd_task == task) { 322 xprt_clear_locked(xprt); 323 __xprt_lock_write_next(xprt); 324 } 325} 326EXPORT_SYMBOL_GPL(xprt_release_xprt); 327 328/** 329 * xprt_release_xprt_cong - allow other requests to use a transport 330 * @xprt: transport with other tasks potentially waiting 331 * @task: task that is releasing access to the transport 332 * 333 * Note that "task" can be NULL. Another task is awoken to use the 334 * transport if the transport's congestion window allows it. 335 */ 336void xprt_release_xprt_cong(struct rpc_xprt *xprt, struct rpc_task *task) 337{ 338 if (xprt->snd_task == task) { 339 xprt_clear_locked(xprt); 340 __xprt_lock_write_next_cong(xprt); 341 } 342} 343EXPORT_SYMBOL_GPL(xprt_release_xprt_cong); 344 345static inline void xprt_release_write(struct rpc_xprt *xprt, struct rpc_task *task) 346{ 347 spin_lock_bh(&xprt->transport_lock); 348 xprt->ops->release_xprt(xprt, task); 349 spin_unlock_bh(&xprt->transport_lock); 350} 351 352/* 353 * Van Jacobson congestion avoidance. Check if the congestion window 354 * overflowed. Put the task to sleep if this is the case. 355 */ 356static int 357__xprt_get_cong(struct rpc_xprt *xprt, struct rpc_task *task) 358{ 359 struct rpc_rqst *req = task->tk_rqstp; 360 361 if (req->rq_cong) 362 return 1; 363 dprintk("RPC: %5u xprt_cwnd_limited cong = %lu cwnd = %lu\n", 364 task->tk_pid, xprt->cong, xprt->cwnd); 365 if (RPCXPRT_CONGESTED(xprt)) 366 return 0; 367 req->rq_cong = 1; 368 xprt->cong += RPC_CWNDSCALE; 369 return 1; 370} 371 372/* 373 * Adjust the congestion window, and wake up the next task 374 * that has been sleeping due to congestion 375 */ 376static void 377__xprt_put_cong(struct rpc_xprt *xprt, struct rpc_rqst *req) 378{ 379 if (!req->rq_cong) 380 return; 381 req->rq_cong = 0; 382 xprt->cong -= RPC_CWNDSCALE; 383 __xprt_lock_write_next_cong(xprt); 384} 385 386/** 387 * xprt_release_rqst_cong - housekeeping when request is complete 388 * @task: RPC request that recently completed 389 * 390 * Useful for transports that require congestion control. 391 */ 392void xprt_release_rqst_cong(struct rpc_task *task) 393{ 394 __xprt_put_cong(task->tk_xprt, task->tk_rqstp); 395} 396EXPORT_SYMBOL_GPL(xprt_release_rqst_cong); 397 398/** 399 * xprt_adjust_cwnd - adjust transport congestion window 400 * @task: recently completed RPC request used to adjust window 401 * @result: result code of completed RPC request 402 * 403 * We use a time-smoothed congestion estimator to avoid heavy oscillation. 404 */ 405void xprt_adjust_cwnd(struct rpc_task *task, int result) 406{ 407 struct rpc_rqst *req = task->tk_rqstp; 408 struct rpc_xprt *xprt = task->tk_xprt; 409 unsigned long cwnd = xprt->cwnd; 410 411 if (result >= 0 && cwnd <= xprt->cong) { 412 /* The (cwnd >> 1) term makes sure 413 * the result gets rounded properly. */ 414 cwnd += (RPC_CWNDSCALE * RPC_CWNDSCALE + (cwnd >> 1)) / cwnd; 415 if (cwnd > RPC_MAXCWND(xprt)) 416 cwnd = RPC_MAXCWND(xprt); 417 __xprt_lock_write_next_cong(xprt); 418 } else if (result == -ETIMEDOUT) { 419 cwnd >>= 1; 420 if (cwnd < RPC_CWNDSCALE) 421 cwnd = RPC_CWNDSCALE; 422 } 423 dprintk("RPC: cong %ld, cwnd was %ld, now %ld\n", 424 xprt->cong, xprt->cwnd, cwnd); 425 xprt->cwnd = cwnd; 426 __xprt_put_cong(xprt, req); 427} 428EXPORT_SYMBOL_GPL(xprt_adjust_cwnd); 429 430/** 431 * xprt_wake_pending_tasks - wake all tasks on a transport's pending queue 432 * @xprt: transport with waiting tasks 433 * @status: result code to plant in each task before waking it 434 * 435 */ 436void xprt_wake_pending_tasks(struct rpc_xprt *xprt, int status) 437{ 438 if (status < 0) 439 rpc_wake_up_status(&xprt->pending, status); 440 else 441 rpc_wake_up(&xprt->pending); 442} 443EXPORT_SYMBOL_GPL(xprt_wake_pending_tasks); 444 445/** 446 * xprt_wait_for_buffer_space - wait for transport output buffer to clear 447 * @task: task to be put to sleep 448 * 449 */ 450void xprt_wait_for_buffer_space(struct rpc_task *task) 451{ 452 struct rpc_rqst *req = task->tk_rqstp; 453 struct rpc_xprt *xprt = req->rq_xprt; 454 455 task->tk_timeout = req->rq_timeout; 456 rpc_sleep_on(&xprt->pending, task, NULL, NULL); 457} 458EXPORT_SYMBOL_GPL(xprt_wait_for_buffer_space); 459 460/** 461 * xprt_write_space - wake the task waiting for transport output buffer space 462 * @xprt: transport with waiting tasks 463 * 464 * Can be called in a soft IRQ context, so xprt_write_space never sleeps. 465 */ 466void xprt_write_space(struct rpc_xprt *xprt) 467{ 468 if (unlikely(xprt->shutdown)) 469 return; 470 471 spin_lock_bh(&xprt->transport_lock); 472 if (xprt->snd_task) { 473 dprintk("RPC: write space: waking waiting task on " 474 "xprt %p\n", xprt); 475 rpc_wake_up_task(xprt->snd_task); 476 } 477 spin_unlock_bh(&xprt->transport_lock); 478} 479EXPORT_SYMBOL_GPL(xprt_write_space); 480 481/** 482 * xprt_set_retrans_timeout_def - set a request's retransmit timeout 483 * @task: task whose timeout is to be set 484 * 485 * Set a request's retransmit timeout based on the transport's 486 * default timeout parameters. Used by transports that don't adjust 487 * the retransmit timeout based on round-trip time estimation. 488 */ 489void xprt_set_retrans_timeout_def(struct rpc_task *task) 490{ 491 task->tk_timeout = task->tk_rqstp->rq_timeout; 492} 493EXPORT_SYMBOL_GPL(xprt_set_retrans_timeout_def); 494 495/* 496 * xprt_set_retrans_timeout_rtt - set a request's retransmit timeout 497 * @task: task whose timeout is to be set 498 * 499 * Set a request's retransmit timeout using the RTT estimator. 500 */ 501void xprt_set_retrans_timeout_rtt(struct rpc_task *task) 502{ 503 int timer = task->tk_msg.rpc_proc->p_timer; 504 struct rpc_rtt *rtt = task->tk_client->cl_rtt; 505 struct rpc_rqst *req = task->tk_rqstp; 506 unsigned long max_timeout = req->rq_xprt->timeout.to_maxval; 507 508 task->tk_timeout = rpc_calc_rto(rtt, timer); 509 task->tk_timeout <<= rpc_ntimeo(rtt, timer) + req->rq_retries; 510 if (task->tk_timeout > max_timeout || task->tk_timeout == 0) 511 task->tk_timeout = max_timeout; 512} 513EXPORT_SYMBOL_GPL(xprt_set_retrans_timeout_rtt); 514 515static void xprt_reset_majortimeo(struct rpc_rqst *req) 516{ 517 struct rpc_timeout *to = &req->rq_xprt->timeout; 518 519 req->rq_majortimeo = req->rq_timeout; 520 if (to->to_exponential) 521 req->rq_majortimeo <<= to->to_retries; 522 else 523 req->rq_majortimeo += to->to_increment * to->to_retries; 524 if (req->rq_majortimeo > to->to_maxval || req->rq_majortimeo == 0) 525 req->rq_majortimeo = to->to_maxval; 526 req->rq_majortimeo += jiffies; 527} 528 529/** 530 * xprt_adjust_timeout - adjust timeout values for next retransmit 531 * @req: RPC request containing parameters to use for the adjustment 532 * 533 */ 534int xprt_adjust_timeout(struct rpc_rqst *req) 535{ 536 struct rpc_xprt *xprt = req->rq_xprt; 537 struct rpc_timeout *to = &xprt->timeout; 538 int status = 0; 539 540 if (time_before(jiffies, req->rq_majortimeo)) { 541 if (to->to_exponential) 542 req->rq_timeout <<= 1; 543 else 544 req->rq_timeout += to->to_increment; 545 if (to->to_maxval && req->rq_timeout >= to->to_maxval) 546 req->rq_timeout = to->to_maxval; 547 req->rq_retries++; 548 } else { 549 req->rq_timeout = to->to_initval; 550 req->rq_retries = 0; 551 xprt_reset_majortimeo(req); 552 /* Reset the RTT counters == "slow start" */ 553 spin_lock_bh(&xprt->transport_lock); 554 rpc_init_rtt(req->rq_task->tk_client->cl_rtt, to->to_initval); 555 spin_unlock_bh(&xprt->transport_lock); 556 status = -ETIMEDOUT; 557 } 558 559 if (req->rq_timeout == 0) { 560 printk(KERN_WARNING "xprt_adjust_timeout: rq_timeout = 0!\n"); 561 req->rq_timeout = 5 * HZ; 562 } 563 return status; 564} 565 566static void xprt_autoclose(struct work_struct *work) 567{ 568 struct rpc_xprt *xprt = 569 container_of(work, struct rpc_xprt, task_cleanup); 570 571 xprt->ops->close(xprt); 572 clear_bit(XPRT_CLOSE_WAIT, &xprt->state); 573 xprt_release_write(xprt, NULL); 574} 575 576/** 577 * xprt_disconnect_done - mark a transport as disconnected 578 * @xprt: transport to flag for disconnect 579 * 580 */ 581void xprt_disconnect_done(struct rpc_xprt *xprt) 582{ 583 dprintk("RPC: disconnected transport %p\n", xprt); 584 spin_lock_bh(&xprt->transport_lock); 585 xprt_clear_connected(xprt); 586 xprt_wake_pending_tasks(xprt, -ENOTCONN); 587 spin_unlock_bh(&xprt->transport_lock); 588} 589EXPORT_SYMBOL_GPL(xprt_disconnect_done); 590 591/** 592 * xprt_force_disconnect - force a transport to disconnect 593 * @xprt: transport to disconnect 594 * 595 */ 596void xprt_force_disconnect(struct rpc_xprt *xprt) 597{ 598 /* Don't race with the test_bit() in xprt_clear_locked() */ 599 spin_lock_bh(&xprt->transport_lock); 600 set_bit(XPRT_CLOSE_WAIT, &xprt->state); 601 /* Try to schedule an autoclose RPC call */ 602 if (test_and_set_bit(XPRT_LOCKED, &xprt->state) == 0) 603 queue_work(rpciod_workqueue, &xprt->task_cleanup); 604 else if (xprt->snd_task != NULL) 605 rpc_wake_up_task(xprt->snd_task); 606 spin_unlock_bh(&xprt->transport_lock); 607} 608EXPORT_SYMBOL_GPL(xprt_force_disconnect); 609 610static void 611xprt_init_autodisconnect(unsigned long data) 612{ 613 struct rpc_xprt *xprt = (struct rpc_xprt *)data; 614 615 spin_lock(&xprt->transport_lock); 616 if (!list_empty(&xprt->recv) || xprt->shutdown) 617 goto out_abort; 618 if (test_and_set_bit(XPRT_LOCKED, &xprt->state)) 619 goto out_abort; 620 spin_unlock(&xprt->transport_lock); 621 if (xprt_connecting(xprt)) 622 xprt_release_write(xprt, NULL); 623 else 624 queue_work(rpciod_workqueue, &xprt->task_cleanup); 625 return; 626out_abort: 627 spin_unlock(&xprt->transport_lock); 628} 629 630/** 631 * xprt_connect - schedule a transport connect operation 632 * @task: RPC task that is requesting the connect 633 * 634 */ 635void xprt_connect(struct rpc_task *task) 636{ 637 struct rpc_xprt *xprt = task->tk_xprt; 638 639 dprintk("RPC: %5u xprt_connect xprt %p %s connected\n", task->tk_pid, 640 xprt, (xprt_connected(xprt) ? "is" : "is not")); 641 642 if (!xprt_bound(xprt)) { 643 task->tk_status = -EIO; 644 return; 645 } 646 if (!xprt_lock_write(xprt, task)) 647 return; 648 if (xprt_connected(xprt)) 649 xprt_release_write(xprt, task); 650 else { 651 if (task->tk_rqstp) 652 task->tk_rqstp->rq_bytes_sent = 0; 653 654 task->tk_timeout = xprt->connect_timeout; 655 rpc_sleep_on(&xprt->pending, task, xprt_connect_status, NULL); 656 xprt->stat.connect_start = jiffies; 657 xprt->ops->connect(task); 658 } 659 return; 660} 661 662static void xprt_connect_status(struct rpc_task *task) 663{ 664 struct rpc_xprt *xprt = task->tk_xprt; 665 666 if (task->tk_status >= 0) { 667 xprt->stat.connect_count++; 668 xprt->stat.connect_time += (long)jiffies - xprt->stat.connect_start; 669 dprintk("RPC: %5u xprt_connect_status: connection established\n", 670 task->tk_pid); 671 return; 672 } 673 674 switch (task->tk_status) { 675 case -ECONNREFUSED: 676 case -ECONNRESET: 677 dprintk("RPC: %5u xprt_connect_status: server %s refused " 678 "connection\n", task->tk_pid, 679 task->tk_client->cl_server); 680 break; 681 case -ENOTCONN: 682 dprintk("RPC: %5u xprt_connect_status: connection broken\n", 683 task->tk_pid); 684 break; 685 case -ETIMEDOUT: 686 dprintk("RPC: %5u xprt_connect_status: connect attempt timed " 687 "out\n", task->tk_pid); 688 break; 689 default: 690 dprintk("RPC: %5u xprt_connect_status: error %d connecting to " 691 "server %s\n", task->tk_pid, -task->tk_status, 692 task->tk_client->cl_server); 693 xprt_release_write(xprt, task); 694 task->tk_status = -EIO; 695 } 696} 697 698/** 699 * xprt_lookup_rqst - find an RPC request corresponding to an XID 700 * @xprt: transport on which the original request was transmitted 701 * @xid: RPC XID of incoming reply 702 * 703 */ 704struct rpc_rqst *xprt_lookup_rqst(struct rpc_xprt *xprt, __be32 xid) 705{ 706 struct list_head *pos; 707 708 list_for_each(pos, &xprt->recv) { 709 struct rpc_rqst *entry = list_entry(pos, struct rpc_rqst, rq_list); 710 if (entry->rq_xid == xid) 711 return entry; 712 } 713 714 dprintk("RPC: xprt_lookup_rqst did not find xid %08x\n", 715 ntohl(xid)); 716 xprt->stat.bad_xids++; 717 return NULL; 718} 719EXPORT_SYMBOL_GPL(xprt_lookup_rqst); 720 721/** 722 * xprt_update_rtt - update an RPC client's RTT state after receiving a reply 723 * @task: RPC request that recently completed 724 * 725 */ 726void xprt_update_rtt(struct rpc_task *task) 727{ 728 struct rpc_rqst *req = task->tk_rqstp; 729 struct rpc_rtt *rtt = task->tk_client->cl_rtt; 730 unsigned timer = task->tk_msg.rpc_proc->p_timer; 731 732 if (timer) { 733 if (req->rq_ntrans == 1) 734 rpc_update_rtt(rtt, timer, 735 (long)jiffies - req->rq_xtime); 736 rpc_set_timeo(rtt, timer, req->rq_ntrans - 1); 737 } 738} 739EXPORT_SYMBOL_GPL(xprt_update_rtt); 740 741/** 742 * xprt_complete_rqst - called when reply processing is complete 743 * @task: RPC request that recently completed 744 * @copied: actual number of bytes received from the transport 745 * 746 * Caller holds transport lock. 747 */ 748void xprt_complete_rqst(struct rpc_task *task, int copied) 749{ 750 struct rpc_rqst *req = task->tk_rqstp; 751 752 dprintk("RPC: %5u xid %08x complete (%d bytes received)\n", 753 task->tk_pid, ntohl(req->rq_xid), copied); 754 755 task->tk_xprt->stat.recvs++; 756 task->tk_rtt = (long)jiffies - req->rq_xtime; 757 758 list_del_init(&req->rq_list); 759 /* Ensure all writes are done before we update req->rq_received */ 760 smp_wmb(); 761 req->rq_received = req->rq_private_buf.len = copied; 762 rpc_wake_up_task(task); 763} 764EXPORT_SYMBOL_GPL(xprt_complete_rqst); 765 766static void xprt_timer(struct rpc_task *task) 767{ 768 struct rpc_rqst *req = task->tk_rqstp; 769 struct rpc_xprt *xprt = req->rq_xprt; 770 771 dprintk("RPC: %5u xprt_timer\n", task->tk_pid); 772 773 spin_lock(&xprt->transport_lock); 774 if (!req->rq_received) { 775 if (xprt->ops->timer) 776 xprt->ops->timer(task); 777 task->tk_status = -ETIMEDOUT; 778 } 779 task->tk_timeout = 0; 780 rpc_wake_up_task(task); 781 spin_unlock(&xprt->transport_lock); 782} 783 784/** 785 * xprt_prepare_transmit - reserve the transport before sending a request 786 * @task: RPC task about to send a request 787 * 788 */ 789int xprt_prepare_transmit(struct rpc_task *task) 790{ 791 struct rpc_rqst *req = task->tk_rqstp; 792 struct rpc_xprt *xprt = req->rq_xprt; 793 int err = 0; 794 795 dprintk("RPC: %5u xprt_prepare_transmit\n", task->tk_pid); 796 797 spin_lock_bh(&xprt->transport_lock); 798 if (req->rq_received && !req->rq_bytes_sent) { 799 err = req->rq_received; 800 goto out_unlock; 801 } 802 if (!xprt->ops->reserve_xprt(task)) { 803 err = -EAGAIN; 804 goto out_unlock; 805 } 806 807 if (!xprt_connected(xprt)) { 808 err = -ENOTCONN; 809 goto out_unlock; 810 } 811out_unlock: 812 spin_unlock_bh(&xprt->transport_lock); 813 return err; 814} 815 816void xprt_end_transmit(struct rpc_task *task) 817{ 818 xprt_release_write(task->tk_xprt, task); 819} 820 821/** 822 * xprt_transmit - send an RPC request on a transport 823 * @task: controlling RPC task 824 * 825 * We have to copy the iovec because sendmsg fiddles with its contents. 826 */ 827void xprt_transmit(struct rpc_task *task) 828{ 829 struct rpc_rqst *req = task->tk_rqstp; 830 struct rpc_xprt *xprt = req->rq_xprt; 831 int status; 832 833 dprintk("RPC: %5u xprt_transmit(%u)\n", task->tk_pid, req->rq_slen); 834 835 if (!req->rq_received) { 836 if (list_empty(&req->rq_list)) { 837 spin_lock_bh(&xprt->transport_lock); 838 /* Update the softirq receive buffer */ 839 memcpy(&req->rq_private_buf, &req->rq_rcv_buf, 840 sizeof(req->rq_private_buf)); 841 /* Add request to the receive list */ 842 list_add_tail(&req->rq_list, &xprt->recv); 843 spin_unlock_bh(&xprt->transport_lock); 844 xprt_reset_majortimeo(req); 845 /* Turn off autodisconnect */ 846 del_singleshot_timer_sync(&xprt->timer); 847 } 848 } else if (!req->rq_bytes_sent) 849 return; 850 851 status = xprt->ops->send_request(task); 852 if (status == 0) { 853 dprintk("RPC: %5u xmit complete\n", task->tk_pid); 854 spin_lock_bh(&xprt->transport_lock); 855 856 xprt->ops->set_retrans_timeout(task); 857 858 xprt->stat.sends++; 859 xprt->stat.req_u += xprt->stat.sends - xprt->stat.recvs; 860 xprt->stat.bklog_u += xprt->backlog.qlen; 861 862 /* Don't race with disconnect */ 863 if (!xprt_connected(xprt)) 864 task->tk_status = -ENOTCONN; 865 else if (!req->rq_received) 866 rpc_sleep_on(&xprt->pending, task, NULL, xprt_timer); 867 spin_unlock_bh(&xprt->transport_lock); 868 return; 869 } 870 871 /* Note: at this point, task->tk_sleeping has not yet been set, 872 * hence there is no danger of the waking up task being put on 873 * schedq, and being picked up by a parallel run of rpciod(). 874 */ 875 task->tk_status = status; 876 if (status == -ECONNREFUSED) 877 rpc_sleep_on(&xprt->sending, task, NULL, NULL); 878} 879 880static inline void do_xprt_reserve(struct rpc_task *task) 881{ 882 struct rpc_xprt *xprt = task->tk_xprt; 883 884 task->tk_status = 0; 885 if (task->tk_rqstp) 886 return; 887 if (!list_empty(&xprt->free)) { 888 struct rpc_rqst *req = list_entry(xprt->free.next, struct rpc_rqst, rq_list); 889 list_del_init(&req->rq_list); 890 task->tk_rqstp = req; 891 xprt_request_init(task, xprt); 892 return; 893 } 894 dprintk("RPC: waiting for request slot\n"); 895 task->tk_status = -EAGAIN; 896 task->tk_timeout = 0; 897 rpc_sleep_on(&xprt->backlog, task, NULL, NULL); 898} 899 900/** 901 * xprt_reserve - allocate an RPC request slot 902 * @task: RPC task requesting a slot allocation 903 * 904 * If no more slots are available, place the task on the transport's 905 * backlog queue. 906 */ 907void xprt_reserve(struct rpc_task *task) 908{ 909 struct rpc_xprt *xprt = task->tk_xprt; 910 911 task->tk_status = -EIO; 912 spin_lock(&xprt->reserve_lock); 913 do_xprt_reserve(task); 914 spin_unlock(&xprt->reserve_lock); 915} 916 917static inline __be32 xprt_alloc_xid(struct rpc_xprt *xprt) 918{ 919 return xprt->xid++; 920} 921 922static inline void xprt_init_xid(struct rpc_xprt *xprt) 923{ 924 xprt->xid = net_random(); 925} 926 927static void xprt_request_init(struct rpc_task *task, struct rpc_xprt *xprt) 928{ 929 struct rpc_rqst *req = task->tk_rqstp; 930 931 req->rq_timeout = xprt->timeout.to_initval; 932 req->rq_task = task; 933 req->rq_xprt = xprt; 934 req->rq_buffer = NULL; 935 req->rq_xid = xprt_alloc_xid(xprt); 936 req->rq_release_snd_buf = NULL; 937 xprt_reset_majortimeo(req); 938 dprintk("RPC: %5u reserved req %p xid %08x\n", task->tk_pid, 939 req, ntohl(req->rq_xid)); 940} 941 942/** 943 * xprt_release - release an RPC request slot 944 * @task: task which is finished with the slot 945 * 946 */ 947void xprt_release(struct rpc_task *task) 948{ 949 struct rpc_xprt *xprt = task->tk_xprt; 950 struct rpc_rqst *req; 951 952 if (!(req = task->tk_rqstp)) 953 return; 954 rpc_count_iostats(task); 955 spin_lock_bh(&xprt->transport_lock); 956 xprt->ops->release_xprt(xprt, task); 957 if (xprt->ops->release_request) 958 xprt->ops->release_request(task); 959 if (!list_empty(&req->rq_list)) 960 list_del(&req->rq_list); 961 xprt->last_used = jiffies; 962 if (list_empty(&xprt->recv)) 963 mod_timer(&xprt->timer, 964 xprt->last_used + xprt->idle_timeout); 965 spin_unlock_bh(&xprt->transport_lock); 966 xprt->ops->buf_free(req->rq_buffer); 967 task->tk_rqstp = NULL; 968 if (req->rq_release_snd_buf) 969 req->rq_release_snd_buf(req); 970 memset(req, 0, sizeof(*req)); /* mark unused */ 971 972 dprintk("RPC: %5u release request %p\n", task->tk_pid, req); 973 974 spin_lock(&xprt->reserve_lock); 975 list_add(&req->rq_list, &xprt->free); 976 rpc_wake_up_next(&xprt->backlog); 977 spin_unlock(&xprt->reserve_lock); 978} 979 980/** 981 * xprt_set_timeout - set constant RPC timeout 982 * @to: RPC timeout parameters to set up 983 * @retr: number of retries 984 * @incr: amount of increase after each retry 985 * 986 */ 987void xprt_set_timeout(struct rpc_timeout *to, unsigned int retr, unsigned long incr) 988{ 989 to->to_initval = 990 to->to_increment = incr; 991 to->to_maxval = to->to_initval + (incr * retr); 992 to->to_retries = retr; 993 to->to_exponential = 0; 994} 995EXPORT_SYMBOL_GPL(xprt_set_timeout); 996 997/** 998 * xprt_create_transport - create an RPC transport 999 * @args: rpc transport creation arguments 1000 * 1001 */ 1002struct rpc_xprt *xprt_create_transport(struct xprt_create *args) 1003{ 1004 struct rpc_xprt *xprt; 1005 struct rpc_rqst *req; 1006 struct xprt_class *t; 1007 1008 spin_lock(&xprt_list_lock); 1009 list_for_each_entry(t, &xprt_list, list) { 1010 if (t->ident == args->ident) { 1011 spin_unlock(&xprt_list_lock); 1012 goto found; 1013 } 1014 } 1015 spin_unlock(&xprt_list_lock); 1016 printk(KERN_ERR "RPC: transport (%d) not supported\n", args->ident); 1017 return ERR_PTR(-EIO); 1018 1019found: 1020 xprt = t->setup(args); 1021 if (IS_ERR(xprt)) { 1022 dprintk("RPC: xprt_create_transport: failed, %ld\n", 1023 -PTR_ERR(xprt)); 1024 return xprt; 1025 } 1026 1027 kref_init(&xprt->kref); 1028 spin_lock_init(&xprt->transport_lock); 1029 spin_lock_init(&xprt->reserve_lock); 1030 1031 INIT_LIST_HEAD(&xprt->free); 1032 INIT_LIST_HEAD(&xprt->recv); 1033 INIT_WORK(&xprt->task_cleanup, xprt_autoclose); 1034 setup_timer(&xprt->timer, xprt_init_autodisconnect, 1035 (unsigned long)xprt); 1036 xprt->last_used = jiffies; 1037 xprt->cwnd = RPC_INITCWND; 1038 xprt->bind_index = 0; 1039 1040 rpc_init_wait_queue(&xprt->binding, "xprt_binding"); 1041 rpc_init_wait_queue(&xprt->pending, "xprt_pending"); 1042 rpc_init_wait_queue(&xprt->sending, "xprt_sending"); 1043 rpc_init_wait_queue(&xprt->resend, "xprt_resend"); 1044 rpc_init_priority_wait_queue(&xprt->backlog, "xprt_backlog"); 1045 1046 /* initialize free list */ 1047 for (req = &xprt->slot[xprt->max_reqs-1]; req >= &xprt->slot[0]; req--) 1048 list_add(&req->rq_list, &xprt->free); 1049 1050 xprt_init_xid(xprt); 1051 1052 dprintk("RPC: created transport %p with %u slots\n", xprt, 1053 xprt->max_reqs); 1054 1055 return xprt; 1056} 1057 1058/** 1059 * xprt_destroy - destroy an RPC transport, killing off all requests. 1060 * @kref: kref for the transport to destroy 1061 * 1062 */ 1063static void xprt_destroy(struct kref *kref) 1064{ 1065 struct rpc_xprt *xprt = container_of(kref, struct rpc_xprt, kref); 1066 1067 dprintk("RPC: destroying transport %p\n", xprt); 1068 xprt->shutdown = 1; 1069 del_timer_sync(&xprt->timer); 1070 1071 /* 1072 * Tear down transport state and free the rpc_xprt 1073 */ 1074 xprt->ops->destroy(xprt); 1075} 1076 1077/** 1078 * xprt_put - release a reference to an RPC transport. 1079 * @xprt: pointer to the transport 1080 * 1081 */ 1082void xprt_put(struct rpc_xprt *xprt) 1083{ 1084 kref_put(&xprt->kref, xprt_destroy); 1085} 1086 1087/** 1088 * xprt_get - return a reference to an RPC transport. 1089 * @xprt: pointer to the transport 1090 * 1091 */ 1092struct rpc_xprt *xprt_get(struct rpc_xprt *xprt) 1093{ 1094 kref_get(&xprt->kref); 1095 return xprt; 1096} 1097