mad_rmpp.c 28 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771772773774775776777778779780781782783784785786787788789790791792793794795796797798799800801802803804805806807808809810811812813814815816817818819820821822823824825826827828829830831832833834835836837838839840841842843844845846847848849850851852853854855856857858859860861862863864865866867868869870871872873874875876877878879880881882883884885886887888889890891892893894895896897898899900901902903904905906907908909910911912913914915916917918919920921922923924925926927928929930931932933934935936937938939940941942943944945946947948949950951952953954955956957958959960
  1. /*
  2. * Copyright (c) 2005 Intel Inc. All rights reserved.
  3. * Copyright (c) 2005-2006 Voltaire, Inc. All rights reserved.
  4. * Copyright (c) 2014 Intel Corporation. All rights reserved.
  5. *
  6. * This software is available to you under a choice of one of two
  7. * licenses. You may choose to be licensed under the terms of the GNU
  8. * General Public License (GPL) Version 2, available from the file
  9. * COPYING in the main directory of this source tree, or the
  10. * OpenIB.org BSD license below:
  11. *
  12. * Redistribution and use in source and binary forms, with or
  13. * without modification, are permitted provided that the following
  14. * conditions are met:
  15. *
  16. * - Redistributions of source code must retain the above
  17. * copyright notice, this list of conditions and the following
  18. * disclaimer.
  19. *
  20. * - Redistributions in binary form must reproduce the above
  21. * copyright notice, this list of conditions and the following
  22. * disclaimer in the documentation and/or other materials
  23. * provided with the distribution.
  24. *
  25. * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
  26. * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
  27. * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
  28. * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
  29. * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
  30. * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
  31. * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
  32. * SOFTWARE.
  33. */
  34. #include <linux/slab.h>
  35. #include "mad_priv.h"
  36. #include "mad_rmpp.h"
  37. enum rmpp_state {
  38. RMPP_STATE_ACTIVE,
  39. RMPP_STATE_TIMEOUT,
  40. RMPP_STATE_COMPLETE
  41. };
  42. struct mad_rmpp_recv {
  43. struct ib_mad_agent_private *agent;
  44. struct list_head list;
  45. struct delayed_work timeout_work;
  46. struct delayed_work cleanup_work;
  47. struct completion comp;
  48. enum rmpp_state state;
  49. spinlock_t lock;
  50. refcount_t refcount;
  51. struct ib_ah *ah;
  52. struct ib_mad_recv_wc *rmpp_wc;
  53. struct ib_mad_recv_buf *cur_seg_buf;
  54. int last_ack;
  55. int seg_num;
  56. int newwin;
  57. int repwin;
  58. __be64 tid;
  59. u32 src_qp;
  60. u32 slid;
  61. u8 mgmt_class;
  62. u8 class_version;
  63. u8 method;
  64. u8 base_version;
  65. };
  66. static inline void deref_rmpp_recv(struct mad_rmpp_recv *rmpp_recv)
  67. {
  68. if (refcount_dec_and_test(&rmpp_recv->refcount))
  69. complete(&rmpp_recv->comp);
  70. }
  71. static void destroy_rmpp_recv(struct mad_rmpp_recv *rmpp_recv)
  72. {
  73. deref_rmpp_recv(rmpp_recv);
  74. wait_for_completion(&rmpp_recv->comp);
  75. rdma_destroy_ah(rmpp_recv->ah, RDMA_DESTROY_AH_SLEEPABLE);
  76. kfree(rmpp_recv);
  77. }
  78. void ib_cancel_rmpp_recvs(struct ib_mad_agent_private *agent)
  79. {
  80. struct mad_rmpp_recv *rmpp_recv, *temp_rmpp_recv;
  81. unsigned long flags;
  82. spin_lock_irqsave(&agent->lock, flags);
  83. list_for_each_entry(rmpp_recv, &agent->rmpp_list, list) {
  84. cancel_delayed_work(&rmpp_recv->timeout_work);
  85. cancel_delayed_work(&rmpp_recv->cleanup_work);
  86. }
  87. spin_unlock_irqrestore(&agent->lock, flags);
  88. flush_workqueue(agent->qp_info->port_priv->wq);
  89. list_for_each_entry_safe(rmpp_recv, temp_rmpp_recv,
  90. &agent->rmpp_list, list) {
  91. list_del(&rmpp_recv->list);
  92. if (rmpp_recv->state != RMPP_STATE_COMPLETE)
  93. ib_free_recv_mad(rmpp_recv->rmpp_wc);
  94. destroy_rmpp_recv(rmpp_recv);
  95. }
  96. }
  97. static void format_ack(struct ib_mad_send_buf *msg,
  98. struct ib_rmpp_mad *data,
  99. struct mad_rmpp_recv *rmpp_recv)
  100. {
  101. struct ib_rmpp_mad *ack = msg->mad;
  102. unsigned long flags;
  103. memcpy(ack, &data->mad_hdr, msg->hdr_len);
  104. ack->mad_hdr.method ^= IB_MGMT_METHOD_RESP;
  105. ack->rmpp_hdr.rmpp_type = IB_MGMT_RMPP_TYPE_ACK;
  106. ib_set_rmpp_flags(&ack->rmpp_hdr, IB_MGMT_RMPP_FLAG_ACTIVE);
  107. spin_lock_irqsave(&rmpp_recv->lock, flags);
  108. rmpp_recv->last_ack = rmpp_recv->seg_num;
  109. ack->rmpp_hdr.seg_num = cpu_to_be32(rmpp_recv->seg_num);
  110. ack->rmpp_hdr.paylen_newwin = cpu_to_be32(rmpp_recv->newwin);
  111. spin_unlock_irqrestore(&rmpp_recv->lock, flags);
  112. }
  113. static void ack_recv(struct mad_rmpp_recv *rmpp_recv,
  114. struct ib_mad_recv_wc *recv_wc)
  115. {
  116. struct ib_mad_send_buf *msg;
  117. int ret, hdr_len;
  118. hdr_len = ib_get_mad_data_offset(recv_wc->recv_buf.mad->mad_hdr.mgmt_class);
  119. msg = ib_create_send_mad(&rmpp_recv->agent->agent, recv_wc->wc->src_qp,
  120. recv_wc->wc->pkey_index, 1, hdr_len,
  121. 0, GFP_KERNEL,
  122. IB_MGMT_BASE_VERSION);
  123. if (IS_ERR(msg))
  124. return;
  125. format_ack(msg, (struct ib_rmpp_mad *) recv_wc->recv_buf.mad, rmpp_recv);
  126. msg->ah = rmpp_recv->ah;
  127. ret = ib_post_send_mad(msg, NULL);
  128. if (ret)
  129. ib_free_send_mad(msg);
  130. }
  131. static struct ib_mad_send_buf *alloc_response_msg(struct ib_mad_agent *agent,
  132. struct ib_mad_recv_wc *recv_wc)
  133. {
  134. struct ib_mad_send_buf *msg;
  135. struct ib_ah *ah;
  136. int hdr_len;
  137. ah = ib_create_ah_from_wc(agent->qp->pd, recv_wc->wc,
  138. recv_wc->recv_buf.grh, agent->port_num);
  139. if (IS_ERR(ah))
  140. return (void *) ah;
  141. hdr_len = ib_get_mad_data_offset(recv_wc->recv_buf.mad->mad_hdr.mgmt_class);
  142. msg = ib_create_send_mad(agent, recv_wc->wc->src_qp,
  143. recv_wc->wc->pkey_index, 1,
  144. hdr_len, 0, GFP_KERNEL,
  145. IB_MGMT_BASE_VERSION);
  146. if (IS_ERR(msg))
  147. rdma_destroy_ah(ah, RDMA_DESTROY_AH_SLEEPABLE);
  148. else {
  149. msg->ah = ah;
  150. msg->context[0] = ah;
  151. }
  152. return msg;
  153. }
  154. static void ack_ds_ack(struct ib_mad_agent_private *agent,
  155. struct ib_mad_recv_wc *recv_wc)
  156. {
  157. struct ib_mad_send_buf *msg;
  158. struct ib_rmpp_mad *rmpp_mad;
  159. int ret;
  160. msg = alloc_response_msg(&agent->agent, recv_wc);
  161. if (IS_ERR(msg))
  162. return;
  163. rmpp_mad = msg->mad;
  164. memcpy(rmpp_mad, recv_wc->recv_buf.mad, msg->hdr_len);
  165. rmpp_mad->mad_hdr.method ^= IB_MGMT_METHOD_RESP;
  166. ib_set_rmpp_flags(&rmpp_mad->rmpp_hdr, IB_MGMT_RMPP_FLAG_ACTIVE);
  167. rmpp_mad->rmpp_hdr.seg_num = 0;
  168. rmpp_mad->rmpp_hdr.paylen_newwin = cpu_to_be32(1);
  169. ret = ib_post_send_mad(msg, NULL);
  170. if (ret) {
  171. rdma_destroy_ah(msg->ah, RDMA_DESTROY_AH_SLEEPABLE);
  172. ib_free_send_mad(msg);
  173. }
  174. }
  175. void ib_rmpp_send_handler(struct ib_mad_send_wc *mad_send_wc)
  176. {
  177. if (mad_send_wc->send_buf->context[0] == mad_send_wc->send_buf->ah)
  178. rdma_destroy_ah(mad_send_wc->send_buf->ah,
  179. RDMA_DESTROY_AH_SLEEPABLE);
  180. ib_free_send_mad(mad_send_wc->send_buf);
  181. }
  182. static void nack_recv(struct ib_mad_agent_private *agent,
  183. struct ib_mad_recv_wc *recv_wc, u8 rmpp_status)
  184. {
  185. struct ib_mad_send_buf *msg;
  186. struct ib_rmpp_mad *rmpp_mad;
  187. int ret;
  188. msg = alloc_response_msg(&agent->agent, recv_wc);
  189. if (IS_ERR(msg))
  190. return;
  191. rmpp_mad = msg->mad;
  192. memcpy(rmpp_mad, recv_wc->recv_buf.mad, msg->hdr_len);
  193. rmpp_mad->mad_hdr.method ^= IB_MGMT_METHOD_RESP;
  194. rmpp_mad->rmpp_hdr.rmpp_version = IB_MGMT_RMPP_VERSION;
  195. rmpp_mad->rmpp_hdr.rmpp_type = IB_MGMT_RMPP_TYPE_ABORT;
  196. ib_set_rmpp_flags(&rmpp_mad->rmpp_hdr, IB_MGMT_RMPP_FLAG_ACTIVE);
  197. rmpp_mad->rmpp_hdr.rmpp_status = rmpp_status;
  198. rmpp_mad->rmpp_hdr.seg_num = 0;
  199. rmpp_mad->rmpp_hdr.paylen_newwin = 0;
  200. ret = ib_post_send_mad(msg, NULL);
  201. if (ret) {
  202. rdma_destroy_ah(msg->ah, RDMA_DESTROY_AH_SLEEPABLE);
  203. ib_free_send_mad(msg);
  204. }
  205. }
  206. static void recv_timeout_handler(struct work_struct *work)
  207. {
  208. struct mad_rmpp_recv *rmpp_recv =
  209. container_of(work, struct mad_rmpp_recv, timeout_work.work);
  210. struct ib_mad_recv_wc *rmpp_wc;
  211. unsigned long flags;
  212. spin_lock_irqsave(&rmpp_recv->agent->lock, flags);
  213. if (rmpp_recv->state != RMPP_STATE_ACTIVE) {
  214. spin_unlock_irqrestore(&rmpp_recv->agent->lock, flags);
  215. return;
  216. }
  217. rmpp_recv->state = RMPP_STATE_TIMEOUT;
  218. list_del(&rmpp_recv->list);
  219. spin_unlock_irqrestore(&rmpp_recv->agent->lock, flags);
  220. rmpp_wc = rmpp_recv->rmpp_wc;
  221. nack_recv(rmpp_recv->agent, rmpp_wc, IB_MGMT_RMPP_STATUS_T2L);
  222. destroy_rmpp_recv(rmpp_recv);
  223. ib_free_recv_mad(rmpp_wc);
  224. }
  225. static void recv_cleanup_handler(struct work_struct *work)
  226. {
  227. struct mad_rmpp_recv *rmpp_recv =
  228. container_of(work, struct mad_rmpp_recv, cleanup_work.work);
  229. unsigned long flags;
  230. spin_lock_irqsave(&rmpp_recv->agent->lock, flags);
  231. list_del(&rmpp_recv->list);
  232. spin_unlock_irqrestore(&rmpp_recv->agent->lock, flags);
  233. destroy_rmpp_recv(rmpp_recv);
  234. }
  235. static struct mad_rmpp_recv *
  236. create_rmpp_recv(struct ib_mad_agent_private *agent,
  237. struct ib_mad_recv_wc *mad_recv_wc)
  238. {
  239. struct mad_rmpp_recv *rmpp_recv;
  240. struct ib_mad_hdr *mad_hdr;
  241. rmpp_recv = kmalloc(sizeof *rmpp_recv, GFP_KERNEL);
  242. if (!rmpp_recv)
  243. return NULL;
  244. rmpp_recv->ah = ib_create_ah_from_wc(agent->agent.qp->pd,
  245. mad_recv_wc->wc,
  246. mad_recv_wc->recv_buf.grh,
  247. agent->agent.port_num);
  248. if (IS_ERR(rmpp_recv->ah))
  249. goto error;
  250. rmpp_recv->agent = agent;
  251. init_completion(&rmpp_recv->comp);
  252. INIT_DELAYED_WORK(&rmpp_recv->timeout_work, recv_timeout_handler);
  253. INIT_DELAYED_WORK(&rmpp_recv->cleanup_work, recv_cleanup_handler);
  254. spin_lock_init(&rmpp_recv->lock);
  255. rmpp_recv->state = RMPP_STATE_ACTIVE;
  256. refcount_set(&rmpp_recv->refcount, 1);
  257. rmpp_recv->rmpp_wc = mad_recv_wc;
  258. rmpp_recv->cur_seg_buf = &mad_recv_wc->recv_buf;
  259. rmpp_recv->newwin = 1;
  260. rmpp_recv->seg_num = 1;
  261. rmpp_recv->last_ack = 0;
  262. rmpp_recv->repwin = 1;
  263. mad_hdr = &mad_recv_wc->recv_buf.mad->mad_hdr;
  264. rmpp_recv->tid = mad_hdr->tid;
  265. rmpp_recv->src_qp = mad_recv_wc->wc->src_qp;
  266. rmpp_recv->slid = mad_recv_wc->wc->slid;
  267. rmpp_recv->mgmt_class = mad_hdr->mgmt_class;
  268. rmpp_recv->class_version = mad_hdr->class_version;
  269. rmpp_recv->method = mad_hdr->method;
  270. rmpp_recv->base_version = mad_hdr->base_version;
  271. return rmpp_recv;
  272. error: kfree(rmpp_recv);
  273. return NULL;
  274. }
  275. static struct mad_rmpp_recv *
  276. find_rmpp_recv(struct ib_mad_agent_private *agent,
  277. struct ib_mad_recv_wc *mad_recv_wc)
  278. {
  279. struct mad_rmpp_recv *rmpp_recv;
  280. struct ib_mad_hdr *mad_hdr = &mad_recv_wc->recv_buf.mad->mad_hdr;
  281. list_for_each_entry(rmpp_recv, &agent->rmpp_list, list) {
  282. if (rmpp_recv->tid == mad_hdr->tid &&
  283. rmpp_recv->src_qp == mad_recv_wc->wc->src_qp &&
  284. rmpp_recv->slid == mad_recv_wc->wc->slid &&
  285. rmpp_recv->mgmt_class == mad_hdr->mgmt_class &&
  286. rmpp_recv->class_version == mad_hdr->class_version &&
  287. rmpp_recv->method == mad_hdr->method)
  288. return rmpp_recv;
  289. }
  290. return NULL;
  291. }
  292. static struct mad_rmpp_recv *
  293. acquire_rmpp_recv(struct ib_mad_agent_private *agent,
  294. struct ib_mad_recv_wc *mad_recv_wc)
  295. {
  296. struct mad_rmpp_recv *rmpp_recv;
  297. unsigned long flags;
  298. spin_lock_irqsave(&agent->lock, flags);
  299. rmpp_recv = find_rmpp_recv(agent, mad_recv_wc);
  300. if (rmpp_recv)
  301. refcount_inc(&rmpp_recv->refcount);
  302. spin_unlock_irqrestore(&agent->lock, flags);
  303. return rmpp_recv;
  304. }
  305. static struct mad_rmpp_recv *
  306. insert_rmpp_recv(struct ib_mad_agent_private *agent,
  307. struct mad_rmpp_recv *rmpp_recv)
  308. {
  309. struct mad_rmpp_recv *cur_rmpp_recv;
  310. cur_rmpp_recv = find_rmpp_recv(agent, rmpp_recv->rmpp_wc);
  311. if (!cur_rmpp_recv)
  312. list_add_tail(&rmpp_recv->list, &agent->rmpp_list);
  313. return cur_rmpp_recv;
  314. }
  315. static inline int get_last_flag(struct ib_mad_recv_buf *seg)
  316. {
  317. struct ib_rmpp_mad *rmpp_mad;
  318. rmpp_mad = (struct ib_rmpp_mad *) seg->mad;
  319. return ib_get_rmpp_flags(&rmpp_mad->rmpp_hdr) & IB_MGMT_RMPP_FLAG_LAST;
  320. }
  321. static inline int get_seg_num(struct ib_mad_recv_buf *seg)
  322. {
  323. struct ib_rmpp_mad *rmpp_mad;
  324. rmpp_mad = (struct ib_rmpp_mad *) seg->mad;
  325. return be32_to_cpu(rmpp_mad->rmpp_hdr.seg_num);
  326. }
  327. static inline struct ib_mad_recv_buf * get_next_seg(struct list_head *rmpp_list,
  328. struct ib_mad_recv_buf *seg)
  329. {
  330. if (seg->list.next == rmpp_list)
  331. return NULL;
  332. return container_of(seg->list.next, struct ib_mad_recv_buf, list);
  333. }
  334. static inline int window_size(struct ib_mad_agent_private *agent)
  335. {
  336. return max(agent->qp_info->recv_queue.max_active >> 3, 1);
  337. }
  338. static struct ib_mad_recv_buf * find_seg_location(struct list_head *rmpp_list,
  339. int seg_num)
  340. {
  341. struct ib_mad_recv_buf *seg_buf;
  342. int cur_seg_num;
  343. list_for_each_entry_reverse(seg_buf, rmpp_list, list) {
  344. cur_seg_num = get_seg_num(seg_buf);
  345. if (seg_num > cur_seg_num)
  346. return seg_buf;
  347. if (seg_num == cur_seg_num)
  348. break;
  349. }
  350. return NULL;
  351. }
  352. static void update_seg_num(struct mad_rmpp_recv *rmpp_recv,
  353. struct ib_mad_recv_buf *new_buf)
  354. {
  355. struct list_head *rmpp_list = &rmpp_recv->rmpp_wc->rmpp_list;
  356. while (new_buf && (get_seg_num(new_buf) == rmpp_recv->seg_num + 1)) {
  357. rmpp_recv->cur_seg_buf = new_buf;
  358. rmpp_recv->seg_num++;
  359. new_buf = get_next_seg(rmpp_list, new_buf);
  360. }
  361. }
  362. static inline int get_mad_len(struct mad_rmpp_recv *rmpp_recv)
  363. {
  364. struct ib_rmpp_mad *rmpp_mad;
  365. int hdr_size, data_size, pad;
  366. bool opa = rdma_cap_opa_mad(rmpp_recv->agent->qp_info->port_priv->device,
  367. rmpp_recv->agent->qp_info->port_priv->port_num);
  368. rmpp_mad = (struct ib_rmpp_mad *)rmpp_recv->cur_seg_buf->mad;
  369. hdr_size = ib_get_mad_data_offset(rmpp_mad->mad_hdr.mgmt_class);
  370. if (opa && rmpp_recv->base_version == OPA_MGMT_BASE_VERSION) {
  371. data_size = sizeof(struct opa_rmpp_mad) - hdr_size;
  372. pad = OPA_MGMT_RMPP_DATA - be32_to_cpu(rmpp_mad->rmpp_hdr.paylen_newwin);
  373. if (pad > OPA_MGMT_RMPP_DATA || pad < 0)
  374. pad = 0;
  375. } else {
  376. data_size = sizeof(struct ib_rmpp_mad) - hdr_size;
  377. pad = IB_MGMT_RMPP_DATA - be32_to_cpu(rmpp_mad->rmpp_hdr.paylen_newwin);
  378. if (pad > IB_MGMT_RMPP_DATA || pad < 0)
  379. pad = 0;
  380. }
  381. return hdr_size + rmpp_recv->seg_num * data_size - pad;
  382. }
  383. static struct ib_mad_recv_wc * complete_rmpp(struct mad_rmpp_recv *rmpp_recv)
  384. {
  385. struct ib_mad_recv_wc *rmpp_wc;
  386. ack_recv(rmpp_recv, rmpp_recv->rmpp_wc);
  387. if (rmpp_recv->seg_num > 1)
  388. cancel_delayed_work(&rmpp_recv->timeout_work);
  389. rmpp_wc = rmpp_recv->rmpp_wc;
  390. rmpp_wc->mad_len = get_mad_len(rmpp_recv);
  391. /* 10 seconds until we can find the packet lifetime */
  392. queue_delayed_work(rmpp_recv->agent->qp_info->port_priv->wq,
  393. &rmpp_recv->cleanup_work, msecs_to_jiffies(10000));
  394. return rmpp_wc;
  395. }
  396. static struct ib_mad_recv_wc *
  397. continue_rmpp(struct ib_mad_agent_private *agent,
  398. struct ib_mad_recv_wc *mad_recv_wc)
  399. {
  400. struct mad_rmpp_recv *rmpp_recv;
  401. struct ib_mad_recv_buf *prev_buf;
  402. struct ib_mad_recv_wc *done_wc;
  403. int seg_num;
  404. unsigned long flags;
  405. rmpp_recv = acquire_rmpp_recv(agent, mad_recv_wc);
  406. if (!rmpp_recv)
  407. goto drop1;
  408. seg_num = get_seg_num(&mad_recv_wc->recv_buf);
  409. spin_lock_irqsave(&rmpp_recv->lock, flags);
  410. if ((rmpp_recv->state == RMPP_STATE_TIMEOUT) ||
  411. (seg_num > rmpp_recv->newwin))
  412. goto drop3;
  413. if ((seg_num <= rmpp_recv->last_ack) ||
  414. (rmpp_recv->state == RMPP_STATE_COMPLETE)) {
  415. spin_unlock_irqrestore(&rmpp_recv->lock, flags);
  416. ack_recv(rmpp_recv, mad_recv_wc);
  417. goto drop2;
  418. }
  419. prev_buf = find_seg_location(&rmpp_recv->rmpp_wc->rmpp_list, seg_num);
  420. if (!prev_buf)
  421. goto drop3;
  422. done_wc = NULL;
  423. list_add(&mad_recv_wc->recv_buf.list, &prev_buf->list);
  424. if (rmpp_recv->cur_seg_buf == prev_buf) {
  425. update_seg_num(rmpp_recv, &mad_recv_wc->recv_buf);
  426. if (get_last_flag(rmpp_recv->cur_seg_buf)) {
  427. rmpp_recv->state = RMPP_STATE_COMPLETE;
  428. spin_unlock_irqrestore(&rmpp_recv->lock, flags);
  429. done_wc = complete_rmpp(rmpp_recv);
  430. goto out;
  431. } else if (rmpp_recv->seg_num == rmpp_recv->newwin) {
  432. rmpp_recv->newwin += window_size(agent);
  433. spin_unlock_irqrestore(&rmpp_recv->lock, flags);
  434. ack_recv(rmpp_recv, mad_recv_wc);
  435. goto out;
  436. }
  437. }
  438. spin_unlock_irqrestore(&rmpp_recv->lock, flags);
  439. out:
  440. deref_rmpp_recv(rmpp_recv);
  441. return done_wc;
  442. drop3: spin_unlock_irqrestore(&rmpp_recv->lock, flags);
  443. drop2: deref_rmpp_recv(rmpp_recv);
  444. drop1: ib_free_recv_mad(mad_recv_wc);
  445. return NULL;
  446. }
  447. static struct ib_mad_recv_wc *
  448. start_rmpp(struct ib_mad_agent_private *agent,
  449. struct ib_mad_recv_wc *mad_recv_wc)
  450. {
  451. struct mad_rmpp_recv *rmpp_recv;
  452. unsigned long flags;
  453. rmpp_recv = create_rmpp_recv(agent, mad_recv_wc);
  454. if (!rmpp_recv) {
  455. ib_free_recv_mad(mad_recv_wc);
  456. return NULL;
  457. }
  458. spin_lock_irqsave(&agent->lock, flags);
  459. if (insert_rmpp_recv(agent, rmpp_recv)) {
  460. spin_unlock_irqrestore(&agent->lock, flags);
  461. /* duplicate first MAD */
  462. destroy_rmpp_recv(rmpp_recv);
  463. return continue_rmpp(agent, mad_recv_wc);
  464. }
  465. refcount_inc(&rmpp_recv->refcount);
  466. if (get_last_flag(&mad_recv_wc->recv_buf)) {
  467. rmpp_recv->state = RMPP_STATE_COMPLETE;
  468. spin_unlock_irqrestore(&agent->lock, flags);
  469. complete_rmpp(rmpp_recv);
  470. } else {
  471. spin_unlock_irqrestore(&agent->lock, flags);
  472. /* 40 seconds until we can find the packet lifetimes */
  473. queue_delayed_work(agent->qp_info->port_priv->wq,
  474. &rmpp_recv->timeout_work,
  475. msecs_to_jiffies(40000));
  476. rmpp_recv->newwin += window_size(agent);
  477. ack_recv(rmpp_recv, mad_recv_wc);
  478. mad_recv_wc = NULL;
  479. }
  480. deref_rmpp_recv(rmpp_recv);
  481. return mad_recv_wc;
  482. }
  483. static int send_next_seg(struct ib_mad_send_wr_private *mad_send_wr)
  484. {
  485. struct ib_rmpp_mad *rmpp_mad;
  486. int timeout;
  487. u32 paylen = 0;
  488. rmpp_mad = mad_send_wr->send_buf.mad;
  489. ib_set_rmpp_flags(&rmpp_mad->rmpp_hdr, IB_MGMT_RMPP_FLAG_ACTIVE);
  490. rmpp_mad->rmpp_hdr.seg_num = cpu_to_be32(++mad_send_wr->seg_num);
  491. if (mad_send_wr->seg_num == 1) {
  492. rmpp_mad->rmpp_hdr.rmpp_rtime_flags |= IB_MGMT_RMPP_FLAG_FIRST;
  493. paylen = (mad_send_wr->send_buf.seg_count *
  494. mad_send_wr->send_buf.seg_rmpp_size) -
  495. mad_send_wr->pad;
  496. }
  497. if (mad_send_wr->seg_num == mad_send_wr->send_buf.seg_count) {
  498. rmpp_mad->rmpp_hdr.rmpp_rtime_flags |= IB_MGMT_RMPP_FLAG_LAST;
  499. paylen = mad_send_wr->send_buf.seg_rmpp_size - mad_send_wr->pad;
  500. }
  501. rmpp_mad->rmpp_hdr.paylen_newwin = cpu_to_be32(paylen);
  502. /* 2 seconds for an ACK until we can find the packet lifetime */
  503. timeout = mad_send_wr->send_buf.timeout_ms;
  504. if (!timeout || timeout > 2000)
  505. mad_send_wr->timeout = msecs_to_jiffies(2000);
  506. return ib_send_mad(mad_send_wr);
  507. }
  508. static void abort_send(struct ib_mad_agent_private *agent,
  509. struct ib_mad_recv_wc *mad_recv_wc, u8 rmpp_status)
  510. {
  511. struct ib_mad_send_wr_private *mad_send_wr;
  512. struct ib_mad_send_wc wc;
  513. unsigned long flags;
  514. spin_lock_irqsave(&agent->lock, flags);
  515. mad_send_wr = ib_find_send_mad(agent, mad_recv_wc);
  516. if (!mad_send_wr)
  517. goto out; /* Unmatched send */
  518. if ((mad_send_wr->last_ack == mad_send_wr->send_buf.seg_count) ||
  519. (!mad_send_wr->timeout) || (mad_send_wr->status != IB_WC_SUCCESS))
  520. goto out; /* Send is already done */
  521. ib_mark_mad_done(mad_send_wr);
  522. spin_unlock_irqrestore(&agent->lock, flags);
  523. wc.status = IB_WC_REM_ABORT_ERR;
  524. wc.vendor_err = rmpp_status;
  525. wc.send_buf = &mad_send_wr->send_buf;
  526. ib_mad_complete_send_wr(mad_send_wr, &wc);
  527. return;
  528. out:
  529. spin_unlock_irqrestore(&agent->lock, flags);
  530. }
  531. static inline void adjust_last_ack(struct ib_mad_send_wr_private *wr,
  532. int seg_num)
  533. {
  534. struct list_head *list;
  535. wr->last_ack = seg_num;
  536. list = &wr->last_ack_seg->list;
  537. list_for_each_entry(wr->last_ack_seg, list, list)
  538. if (wr->last_ack_seg->num == seg_num)
  539. break;
  540. }
  541. static void process_ds_ack(struct ib_mad_agent_private *agent,
  542. struct ib_mad_recv_wc *mad_recv_wc, int newwin)
  543. {
  544. struct mad_rmpp_recv *rmpp_recv;
  545. rmpp_recv = find_rmpp_recv(agent, mad_recv_wc);
  546. if (rmpp_recv && rmpp_recv->state == RMPP_STATE_COMPLETE)
  547. rmpp_recv->repwin = newwin;
  548. }
  549. static void process_rmpp_ack(struct ib_mad_agent_private *agent,
  550. struct ib_mad_recv_wc *mad_recv_wc)
  551. {
  552. struct ib_mad_send_wr_private *mad_send_wr;
  553. struct ib_rmpp_mad *rmpp_mad;
  554. unsigned long flags;
  555. int seg_num, newwin, ret;
  556. rmpp_mad = (struct ib_rmpp_mad *)mad_recv_wc->recv_buf.mad;
  557. if (rmpp_mad->rmpp_hdr.rmpp_status) {
  558. abort_send(agent, mad_recv_wc, IB_MGMT_RMPP_STATUS_BAD_STATUS);
  559. nack_recv(agent, mad_recv_wc, IB_MGMT_RMPP_STATUS_BAD_STATUS);
  560. return;
  561. }
  562. seg_num = be32_to_cpu(rmpp_mad->rmpp_hdr.seg_num);
  563. newwin = be32_to_cpu(rmpp_mad->rmpp_hdr.paylen_newwin);
  564. if (newwin < seg_num) {
  565. abort_send(agent, mad_recv_wc, IB_MGMT_RMPP_STATUS_W2S);
  566. nack_recv(agent, mad_recv_wc, IB_MGMT_RMPP_STATUS_W2S);
  567. return;
  568. }
  569. spin_lock_irqsave(&agent->lock, flags);
  570. mad_send_wr = ib_find_send_mad(agent, mad_recv_wc);
  571. if (!mad_send_wr) {
  572. if (!seg_num)
  573. process_ds_ack(agent, mad_recv_wc, newwin);
  574. goto out; /* Unmatched or DS RMPP ACK */
  575. }
  576. if ((mad_send_wr->last_ack == mad_send_wr->send_buf.seg_count) &&
  577. (mad_send_wr->timeout)) {
  578. spin_unlock_irqrestore(&agent->lock, flags);
  579. ack_ds_ack(agent, mad_recv_wc);
  580. return; /* Repeated ACK for DS RMPP transaction */
  581. }
  582. if ((mad_send_wr->last_ack == mad_send_wr->send_buf.seg_count) ||
  583. (!mad_send_wr->timeout) || (mad_send_wr->status != IB_WC_SUCCESS))
  584. goto out; /* Send is already done */
  585. if (seg_num > mad_send_wr->send_buf.seg_count ||
  586. seg_num > mad_send_wr->newwin) {
  587. spin_unlock_irqrestore(&agent->lock, flags);
  588. abort_send(agent, mad_recv_wc, IB_MGMT_RMPP_STATUS_S2B);
  589. nack_recv(agent, mad_recv_wc, IB_MGMT_RMPP_STATUS_S2B);
  590. return;
  591. }
  592. if (newwin < mad_send_wr->newwin || seg_num < mad_send_wr->last_ack)
  593. goto out; /* Old ACK */
  594. if (seg_num > mad_send_wr->last_ack) {
  595. adjust_last_ack(mad_send_wr, seg_num);
  596. mad_send_wr->retries_left = mad_send_wr->max_retries;
  597. }
  598. mad_send_wr->newwin = newwin;
  599. if (mad_send_wr->last_ack == mad_send_wr->send_buf.seg_count) {
  600. /* If no response is expected, the ACK completes the send */
  601. if (!mad_send_wr->send_buf.timeout_ms) {
  602. struct ib_mad_send_wc wc;
  603. ib_mark_mad_done(mad_send_wr);
  604. spin_unlock_irqrestore(&agent->lock, flags);
  605. wc.status = IB_WC_SUCCESS;
  606. wc.vendor_err = 0;
  607. wc.send_buf = &mad_send_wr->send_buf;
  608. ib_mad_complete_send_wr(mad_send_wr, &wc);
  609. return;
  610. }
  611. if (mad_send_wr->refcount == 1)
  612. ib_reset_mad_timeout(mad_send_wr,
  613. mad_send_wr->send_buf.timeout_ms);
  614. spin_unlock_irqrestore(&agent->lock, flags);
  615. ack_ds_ack(agent, mad_recv_wc);
  616. return;
  617. } else if (mad_send_wr->refcount == 1 &&
  618. mad_send_wr->seg_num < mad_send_wr->newwin &&
  619. mad_send_wr->seg_num < mad_send_wr->send_buf.seg_count) {
  620. /* Send failure will just result in a timeout/retry */
  621. ret = send_next_seg(mad_send_wr);
  622. if (ret)
  623. goto out;
  624. mad_send_wr->refcount++;
  625. list_move_tail(&mad_send_wr->agent_list,
  626. &mad_send_wr->mad_agent_priv->send_list);
  627. }
  628. out:
  629. spin_unlock_irqrestore(&agent->lock, flags);
  630. }
  631. static struct ib_mad_recv_wc *
  632. process_rmpp_data(struct ib_mad_agent_private *agent,
  633. struct ib_mad_recv_wc *mad_recv_wc)
  634. {
  635. struct ib_rmpp_hdr *rmpp_hdr;
  636. u8 rmpp_status;
  637. rmpp_hdr = &((struct ib_rmpp_mad *)mad_recv_wc->recv_buf.mad)->rmpp_hdr;
  638. if (rmpp_hdr->rmpp_status) {
  639. rmpp_status = IB_MGMT_RMPP_STATUS_BAD_STATUS;
  640. goto bad;
  641. }
  642. if (rmpp_hdr->seg_num == cpu_to_be32(1)) {
  643. if (!(ib_get_rmpp_flags(rmpp_hdr) & IB_MGMT_RMPP_FLAG_FIRST)) {
  644. rmpp_status = IB_MGMT_RMPP_STATUS_BAD_SEG;
  645. goto bad;
  646. }
  647. return start_rmpp(agent, mad_recv_wc);
  648. } else {
  649. if (ib_get_rmpp_flags(rmpp_hdr) & IB_MGMT_RMPP_FLAG_FIRST) {
  650. rmpp_status = IB_MGMT_RMPP_STATUS_BAD_SEG;
  651. goto bad;
  652. }
  653. return continue_rmpp(agent, mad_recv_wc);
  654. }
  655. bad:
  656. nack_recv(agent, mad_recv_wc, rmpp_status);
  657. ib_free_recv_mad(mad_recv_wc);
  658. return NULL;
  659. }
  660. static void process_rmpp_stop(struct ib_mad_agent_private *agent,
  661. struct ib_mad_recv_wc *mad_recv_wc)
  662. {
  663. struct ib_rmpp_mad *rmpp_mad;
  664. rmpp_mad = (struct ib_rmpp_mad *)mad_recv_wc->recv_buf.mad;
  665. if (rmpp_mad->rmpp_hdr.rmpp_status != IB_MGMT_RMPP_STATUS_RESX) {
  666. abort_send(agent, mad_recv_wc, IB_MGMT_RMPP_STATUS_BAD_STATUS);
  667. nack_recv(agent, mad_recv_wc, IB_MGMT_RMPP_STATUS_BAD_STATUS);
  668. } else
  669. abort_send(agent, mad_recv_wc, rmpp_mad->rmpp_hdr.rmpp_status);
  670. }
  671. static void process_rmpp_abort(struct ib_mad_agent_private *agent,
  672. struct ib_mad_recv_wc *mad_recv_wc)
  673. {
  674. struct ib_rmpp_mad *rmpp_mad;
  675. rmpp_mad = (struct ib_rmpp_mad *)mad_recv_wc->recv_buf.mad;
  676. if (rmpp_mad->rmpp_hdr.rmpp_status < IB_MGMT_RMPP_STATUS_ABORT_MIN ||
  677. rmpp_mad->rmpp_hdr.rmpp_status > IB_MGMT_RMPP_STATUS_ABORT_MAX) {
  678. abort_send(agent, mad_recv_wc, IB_MGMT_RMPP_STATUS_BAD_STATUS);
  679. nack_recv(agent, mad_recv_wc, IB_MGMT_RMPP_STATUS_BAD_STATUS);
  680. } else
  681. abort_send(agent, mad_recv_wc, rmpp_mad->rmpp_hdr.rmpp_status);
  682. }
  683. struct ib_mad_recv_wc *
  684. ib_process_rmpp_recv_wc(struct ib_mad_agent_private *agent,
  685. struct ib_mad_recv_wc *mad_recv_wc)
  686. {
  687. struct ib_rmpp_mad *rmpp_mad;
  688. rmpp_mad = (struct ib_rmpp_mad *)mad_recv_wc->recv_buf.mad;
  689. if (!(rmpp_mad->rmpp_hdr.rmpp_rtime_flags & IB_MGMT_RMPP_FLAG_ACTIVE))
  690. return mad_recv_wc;
  691. if (rmpp_mad->rmpp_hdr.rmpp_version != IB_MGMT_RMPP_VERSION) {
  692. abort_send(agent, mad_recv_wc, IB_MGMT_RMPP_STATUS_UNV);
  693. nack_recv(agent, mad_recv_wc, IB_MGMT_RMPP_STATUS_UNV);
  694. goto out;
  695. }
  696. switch (rmpp_mad->rmpp_hdr.rmpp_type) {
  697. case IB_MGMT_RMPP_TYPE_DATA:
  698. return process_rmpp_data(agent, mad_recv_wc);
  699. case IB_MGMT_RMPP_TYPE_ACK:
  700. process_rmpp_ack(agent, mad_recv_wc);
  701. break;
  702. case IB_MGMT_RMPP_TYPE_STOP:
  703. process_rmpp_stop(agent, mad_recv_wc);
  704. break;
  705. case IB_MGMT_RMPP_TYPE_ABORT:
  706. process_rmpp_abort(agent, mad_recv_wc);
  707. break;
  708. default:
  709. abort_send(agent, mad_recv_wc, IB_MGMT_RMPP_STATUS_BADT);
  710. nack_recv(agent, mad_recv_wc, IB_MGMT_RMPP_STATUS_BADT);
  711. break;
  712. }
  713. out:
  714. ib_free_recv_mad(mad_recv_wc);
  715. return NULL;
  716. }
  717. static int init_newwin(struct ib_mad_send_wr_private *mad_send_wr)
  718. {
  719. struct ib_mad_agent_private *agent = mad_send_wr->mad_agent_priv;
  720. struct ib_mad_hdr *mad_hdr = mad_send_wr->send_buf.mad;
  721. struct mad_rmpp_recv *rmpp_recv;
  722. struct rdma_ah_attr ah_attr;
  723. unsigned long flags;
  724. int newwin = 1;
  725. if (!(mad_hdr->method & IB_MGMT_METHOD_RESP))
  726. goto out;
  727. spin_lock_irqsave(&agent->lock, flags);
  728. list_for_each_entry(rmpp_recv, &agent->rmpp_list, list) {
  729. if (rmpp_recv->tid != mad_hdr->tid ||
  730. rmpp_recv->mgmt_class != mad_hdr->mgmt_class ||
  731. rmpp_recv->class_version != mad_hdr->class_version ||
  732. (rmpp_recv->method & IB_MGMT_METHOD_RESP))
  733. continue;
  734. if (rdma_query_ah(mad_send_wr->send_buf.ah, &ah_attr))
  735. continue;
  736. if (rmpp_recv->slid == rdma_ah_get_dlid(&ah_attr)) {
  737. newwin = rmpp_recv->repwin;
  738. break;
  739. }
  740. }
  741. spin_unlock_irqrestore(&agent->lock, flags);
  742. out:
  743. return newwin;
  744. }
  745. int ib_send_rmpp_mad(struct ib_mad_send_wr_private *mad_send_wr)
  746. {
  747. struct ib_rmpp_mad *rmpp_mad;
  748. int ret;
  749. rmpp_mad = mad_send_wr->send_buf.mad;
  750. if (!(ib_get_rmpp_flags(&rmpp_mad->rmpp_hdr) &
  751. IB_MGMT_RMPP_FLAG_ACTIVE))
  752. return IB_RMPP_RESULT_UNHANDLED;
  753. if (rmpp_mad->rmpp_hdr.rmpp_type != IB_MGMT_RMPP_TYPE_DATA) {
  754. mad_send_wr->seg_num = 1;
  755. return IB_RMPP_RESULT_INTERNAL;
  756. }
  757. mad_send_wr->newwin = init_newwin(mad_send_wr);
  758. /* We need to wait for the final ACK even if there isn't a response */
  759. mad_send_wr->refcount += (mad_send_wr->timeout == 0);
  760. ret = send_next_seg(mad_send_wr);
  761. if (!ret)
  762. return IB_RMPP_RESULT_CONSUMED;
  763. return ret;
  764. }
  765. int ib_process_rmpp_send_wc(struct ib_mad_send_wr_private *mad_send_wr,
  766. struct ib_mad_send_wc *mad_send_wc)
  767. {
  768. struct ib_rmpp_mad *rmpp_mad;
  769. int ret;
  770. rmpp_mad = mad_send_wr->send_buf.mad;
  771. if (!(ib_get_rmpp_flags(&rmpp_mad->rmpp_hdr) &
  772. IB_MGMT_RMPP_FLAG_ACTIVE))
  773. return IB_RMPP_RESULT_UNHANDLED; /* RMPP not active */
  774. if (rmpp_mad->rmpp_hdr.rmpp_type != IB_MGMT_RMPP_TYPE_DATA)
  775. return IB_RMPP_RESULT_INTERNAL; /* ACK, STOP, or ABORT */
  776. if (mad_send_wc->status != IB_WC_SUCCESS ||
  777. mad_send_wr->status != IB_WC_SUCCESS)
  778. return IB_RMPP_RESULT_PROCESSED; /* Canceled or send error */
  779. if (!mad_send_wr->timeout)
  780. return IB_RMPP_RESULT_PROCESSED; /* Response received */
  781. if (mad_send_wr->last_ack == mad_send_wr->send_buf.seg_count) {
  782. mad_send_wr->timeout =
  783. msecs_to_jiffies(mad_send_wr->send_buf.timeout_ms);
  784. return IB_RMPP_RESULT_PROCESSED; /* Send done */
  785. }
  786. if (mad_send_wr->seg_num == mad_send_wr->newwin ||
  787. mad_send_wr->seg_num == mad_send_wr->send_buf.seg_count)
  788. return IB_RMPP_RESULT_PROCESSED; /* Wait for ACK */
  789. ret = send_next_seg(mad_send_wr);
  790. if (ret) {
  791. mad_send_wc->status = IB_WC_GENERAL_ERR;
  792. return IB_RMPP_RESULT_PROCESSED;
  793. }
  794. return IB_RMPP_RESULT_CONSUMED;
  795. }
  796. int ib_retry_rmpp(struct ib_mad_send_wr_private *mad_send_wr)
  797. {
  798. struct ib_rmpp_mad *rmpp_mad;
  799. int ret;
  800. rmpp_mad = mad_send_wr->send_buf.mad;
  801. if (!(ib_get_rmpp_flags(&rmpp_mad->rmpp_hdr) &
  802. IB_MGMT_RMPP_FLAG_ACTIVE))
  803. return IB_RMPP_RESULT_UNHANDLED; /* RMPP not active */
  804. if (mad_send_wr->last_ack == mad_send_wr->send_buf.seg_count)
  805. return IB_RMPP_RESULT_PROCESSED;
  806. mad_send_wr->seg_num = mad_send_wr->last_ack;
  807. mad_send_wr->cur_seg = mad_send_wr->last_ack_seg;
  808. ret = send_next_seg(mad_send_wr);
  809. if (ret)
  810. return IB_RMPP_RESULT_PROCESSED;
  811. return IB_RMPP_RESULT_CONSUMED;
  812. }