xprt.c 29 KB

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