smc_llc.c 54 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771772773774775776777778779780781782783784785786787788789790791792793794795796797798799800801802803804805806807808809810811812813814815816817818819820821822823824825826827828829830831832833834835836837838839840841842843844845846847848849850851852853854855856857858859860861862863864865866867868869870871872873874875876877878879880881882883884885886887888889890891892893894895896897898899900901902903904905906907908909910911912913914915916917918919920921922923924925926927928929930931932933934935936937938939940941942943944945946947948949950951952953954955956957958959960961962963964965966967968969970971972973974975976977978979980981982983984985986987988989990991992993994995996997998999100010011002100310041005100610071008100910101011101210131014101510161017101810191020102110221023102410251026102710281029103010311032103310341035103610371038103910401041104210431044104510461047104810491050105110521053105410551056105710581059106010611062106310641065106610671068106910701071107210731074107510761077107810791080108110821083108410851086108710881089109010911092109310941095109610971098109911001101110211031104110511061107110811091110111111121113111411151116111711181119112011211122112311241125112611271128112911301131113211331134113511361137113811391140114111421143114411451146114711481149115011511152115311541155115611571158115911601161116211631164116511661167116811691170117111721173117411751176117711781179118011811182118311841185118611871188118911901191119211931194119511961197119811991200120112021203120412051206120712081209121012111212121312141215121612171218121912201221122212231224122512261227122812291230123112321233123412351236123712381239124012411242124312441245124612471248124912501251125212531254125512561257125812591260126112621263126412651266126712681269127012711272127312741275127612771278127912801281128212831284128512861287128812891290129112921293129412951296129712981299130013011302130313041305130613071308130913101311131213131314131513161317131813191320132113221323132413251326132713281329133013311332133313341335133613371338133913401341134213431344134513461347134813491350135113521353135413551356135713581359136013611362136313641365136613671368136913701371137213731374137513761377137813791380138113821383138413851386138713881389139013911392139313941395139613971398139914001401140214031404140514061407140814091410141114121413141414151416141714181419142014211422142314241425142614271428142914301431143214331434143514361437143814391440144114421443144414451446144714481449145014511452145314541455145614571458145914601461146214631464146514661467146814691470147114721473147414751476147714781479148014811482148314841485148614871488148914901491149214931494149514961497149814991500150115021503150415051506150715081509151015111512151315141515151615171518151915201521152215231524152515261527152815291530153115321533153415351536153715381539154015411542154315441545154615471548154915501551155215531554155515561557155815591560156115621563156415651566156715681569157015711572157315741575157615771578157915801581158215831584158515861587158815891590159115921593159415951596159715981599160016011602160316041605160616071608160916101611161216131614161516161617161816191620162116221623162416251626162716281629163016311632163316341635163616371638163916401641164216431644164516461647164816491650165116521653165416551656165716581659166016611662166316641665166616671668166916701671167216731674167516761677167816791680168116821683168416851686168716881689169016911692169316941695169616971698169917001701170217031704170517061707170817091710171117121713171417151716171717181719172017211722172317241725172617271728172917301731173217331734173517361737173817391740174117421743174417451746174717481749175017511752175317541755175617571758175917601761176217631764176517661767176817691770177117721773177417751776177717781779178017811782178317841785178617871788178917901791179217931794179517961797179817991800180118021803180418051806180718081809181018111812181318141815181618171818181918201821182218231824182518261827182818291830183118321833183418351836183718381839184018411842184318441845184618471848184918501851185218531854185518561857185818591860186118621863186418651866186718681869187018711872187318741875187618771878187918801881188218831884188518861887188818891890189118921893189418951896189718981899190019011902190319041905190619071908190919101911191219131914191519161917191819191920192119221923192419251926192719281929193019311932193319341935193619371938193919401941194219431944194519461947194819491950195119521953195419551956195719581959196019611962196319641965196619671968196919701971197219731974
  1. // SPDX-License-Identifier: GPL-2.0
  2. /*
  3. * Shared Memory Communications over RDMA (SMC-R) and RoCE
  4. *
  5. * Link Layer Control (LLC)
  6. *
  7. * Copyright IBM Corp. 2016
  8. *
  9. * Author(s): Klaus Wacker <Klaus.Wacker@de.ibm.com>
  10. * Ursula Braun <ubraun@linux.vnet.ibm.com>
  11. */
  12. #include <net/tcp.h>
  13. #include <rdma/ib_verbs.h>
  14. #include "smc.h"
  15. #include "smc_core.h"
  16. #include "smc_clc.h"
  17. #include "smc_llc.h"
  18. #include "smc_pnet.h"
  19. #define SMC_LLC_DATA_LEN 40
  20. struct smc_llc_hdr {
  21. struct smc_wr_rx_hdr common;
  22. u8 length; /* 44 */
  23. #if defined(__BIG_ENDIAN_BITFIELD)
  24. u8 reserved:4,
  25. add_link_rej_rsn:4;
  26. #elif defined(__LITTLE_ENDIAN_BITFIELD)
  27. u8 add_link_rej_rsn:4,
  28. reserved:4;
  29. #endif
  30. u8 flags;
  31. };
  32. #define SMC_LLC_FLAG_NO_RMBE_EYEC 0x03
  33. struct smc_llc_msg_confirm_link { /* type 0x01 */
  34. struct smc_llc_hdr hd;
  35. u8 sender_mac[ETH_ALEN];
  36. u8 sender_gid[SMC_GID_SIZE];
  37. u8 sender_qp_num[3];
  38. u8 link_num;
  39. u8 link_uid[SMC_LGR_ID_SIZE];
  40. u8 max_links;
  41. u8 reserved[9];
  42. };
  43. #define SMC_LLC_FLAG_ADD_LNK_REJ 0x40
  44. #define SMC_LLC_REJ_RSN_NO_ALT_PATH 1
  45. #define SMC_LLC_ADD_LNK_MAX_LINKS 2
  46. struct smc_llc_msg_add_link { /* type 0x02 */
  47. struct smc_llc_hdr hd;
  48. u8 sender_mac[ETH_ALEN];
  49. u8 reserved2[2];
  50. u8 sender_gid[SMC_GID_SIZE];
  51. u8 sender_qp_num[3];
  52. u8 link_num;
  53. #if defined(__BIG_ENDIAN_BITFIELD)
  54. u8 reserved3 : 4,
  55. qp_mtu : 4;
  56. #elif defined(__LITTLE_ENDIAN_BITFIELD)
  57. u8 qp_mtu : 4,
  58. reserved3 : 4;
  59. #endif
  60. u8 initial_psn[3];
  61. u8 reserved[8];
  62. };
  63. struct smc_llc_msg_add_link_cont_rt {
  64. __be32 rmb_key;
  65. __be32 rmb_key_new;
  66. __be64 rmb_vaddr_new;
  67. };
  68. #define SMC_LLC_RKEYS_PER_CONT_MSG 2
  69. struct smc_llc_msg_add_link_cont { /* type 0x03 */
  70. struct smc_llc_hdr hd;
  71. u8 link_num;
  72. u8 num_rkeys;
  73. u8 reserved2[2];
  74. struct smc_llc_msg_add_link_cont_rt rt[SMC_LLC_RKEYS_PER_CONT_MSG];
  75. u8 reserved[4];
  76. } __packed; /* format defined in RFC7609 */
  77. #define SMC_LLC_FLAG_DEL_LINK_ALL 0x40
  78. #define SMC_LLC_FLAG_DEL_LINK_ORDERLY 0x20
  79. struct smc_llc_msg_del_link { /* type 0x04 */
  80. struct smc_llc_hdr hd;
  81. u8 link_num;
  82. __be32 reason;
  83. u8 reserved[35];
  84. } __packed; /* format defined in RFC7609 */
  85. struct smc_llc_msg_test_link { /* type 0x07 */
  86. struct smc_llc_hdr hd;
  87. u8 user_data[16];
  88. u8 reserved[24];
  89. };
  90. struct smc_rmb_rtoken {
  91. union {
  92. u8 num_rkeys; /* first rtoken byte of CONFIRM LINK msg */
  93. /* is actually the num of rtokens, first */
  94. /* rtoken is always for the current link */
  95. u8 link_id; /* link id of the rtoken */
  96. };
  97. __be32 rmb_key;
  98. __be64 rmb_vaddr;
  99. } __packed; /* format defined in RFC7609 */
  100. #define SMC_LLC_RKEYS_PER_MSG 3
  101. struct smc_llc_msg_confirm_rkey { /* type 0x06 */
  102. struct smc_llc_hdr hd;
  103. struct smc_rmb_rtoken rtoken[SMC_LLC_RKEYS_PER_MSG];
  104. u8 reserved;
  105. };
  106. #define SMC_LLC_DEL_RKEY_MAX 8
  107. #define SMC_LLC_FLAG_RKEY_RETRY 0x10
  108. #define SMC_LLC_FLAG_RKEY_NEG 0x20
  109. struct smc_llc_msg_delete_rkey { /* type 0x09 */
  110. struct smc_llc_hdr hd;
  111. u8 num_rkeys;
  112. u8 err_mask;
  113. u8 reserved[2];
  114. __be32 rkey[8];
  115. u8 reserved2[4];
  116. };
  117. union smc_llc_msg {
  118. struct smc_llc_msg_confirm_link confirm_link;
  119. struct smc_llc_msg_add_link add_link;
  120. struct smc_llc_msg_add_link_cont add_link_cont;
  121. struct smc_llc_msg_del_link delete_link;
  122. struct smc_llc_msg_confirm_rkey confirm_rkey;
  123. struct smc_llc_msg_delete_rkey delete_rkey;
  124. struct smc_llc_msg_test_link test_link;
  125. struct {
  126. struct smc_llc_hdr hdr;
  127. u8 data[SMC_LLC_DATA_LEN];
  128. } raw;
  129. };
  130. #define SMC_LLC_FLAG_RESP 0x80
  131. struct smc_llc_qentry {
  132. struct list_head list;
  133. struct smc_link *link;
  134. union smc_llc_msg msg;
  135. };
  136. static void smc_llc_enqueue(struct smc_link *link, union smc_llc_msg *llc);
  137. struct smc_llc_qentry *smc_llc_flow_qentry_clr(struct smc_llc_flow *flow)
  138. {
  139. struct smc_llc_qentry *qentry = flow->qentry;
  140. flow->qentry = NULL;
  141. return qentry;
  142. }
  143. void smc_llc_flow_qentry_del(struct smc_llc_flow *flow)
  144. {
  145. struct smc_llc_qentry *qentry;
  146. if (flow->qentry) {
  147. qentry = flow->qentry;
  148. flow->qentry = NULL;
  149. kfree(qentry);
  150. }
  151. }
  152. static inline void smc_llc_flow_qentry_set(struct smc_llc_flow *flow,
  153. struct smc_llc_qentry *qentry)
  154. {
  155. flow->qentry = qentry;
  156. }
  157. static void smc_llc_flow_parallel(struct smc_link_group *lgr, u8 flow_type,
  158. struct smc_llc_qentry *qentry)
  159. {
  160. u8 msg_type = qentry->msg.raw.hdr.common.type;
  161. if ((msg_type == SMC_LLC_ADD_LINK || msg_type == SMC_LLC_DELETE_LINK) &&
  162. flow_type != msg_type && !lgr->delayed_event) {
  163. lgr->delayed_event = qentry;
  164. return;
  165. }
  166. /* drop parallel or already-in-progress llc requests */
  167. if (flow_type != msg_type)
  168. pr_warn_once("smc: SMC-R lg %*phN dropped parallel "
  169. "LLC msg: msg %d flow %d role %d\n",
  170. SMC_LGR_ID_SIZE, &lgr->id,
  171. qentry->msg.raw.hdr.common.type,
  172. flow_type, lgr->role);
  173. kfree(qentry);
  174. }
  175. /* try to start a new llc flow, initiated by an incoming llc msg */
  176. static bool smc_llc_flow_start(struct smc_llc_flow *flow,
  177. struct smc_llc_qentry *qentry)
  178. {
  179. struct smc_link_group *lgr = qentry->link->lgr;
  180. spin_lock_bh(&lgr->llc_flow_lock);
  181. if (flow->type) {
  182. /* a flow is already active */
  183. smc_llc_flow_parallel(lgr, flow->type, qentry);
  184. spin_unlock_bh(&lgr->llc_flow_lock);
  185. return false;
  186. }
  187. switch (qentry->msg.raw.hdr.common.type) {
  188. case SMC_LLC_ADD_LINK:
  189. flow->type = SMC_LLC_FLOW_ADD_LINK;
  190. break;
  191. case SMC_LLC_DELETE_LINK:
  192. flow->type = SMC_LLC_FLOW_DEL_LINK;
  193. break;
  194. case SMC_LLC_CONFIRM_RKEY:
  195. case SMC_LLC_DELETE_RKEY:
  196. flow->type = SMC_LLC_FLOW_RKEY;
  197. break;
  198. default:
  199. flow->type = SMC_LLC_FLOW_NONE;
  200. }
  201. smc_llc_flow_qentry_set(flow, qentry);
  202. spin_unlock_bh(&lgr->llc_flow_lock);
  203. return true;
  204. }
  205. /* start a new local llc flow, wait till current flow finished */
  206. int smc_llc_flow_initiate(struct smc_link_group *lgr,
  207. enum smc_llc_flowtype type)
  208. {
  209. enum smc_llc_flowtype allowed_remote = SMC_LLC_FLOW_NONE;
  210. int rc;
  211. /* all flows except confirm_rkey and delete_rkey are exclusive,
  212. * confirm/delete rkey flows can run concurrently (local and remote)
  213. */
  214. if (type == SMC_LLC_FLOW_RKEY)
  215. allowed_remote = SMC_LLC_FLOW_RKEY;
  216. again:
  217. if (list_empty(&lgr->list))
  218. return -ENODEV;
  219. spin_lock_bh(&lgr->llc_flow_lock);
  220. if (lgr->llc_flow_lcl.type == SMC_LLC_FLOW_NONE &&
  221. (lgr->llc_flow_rmt.type == SMC_LLC_FLOW_NONE ||
  222. lgr->llc_flow_rmt.type == allowed_remote)) {
  223. lgr->llc_flow_lcl.type = type;
  224. spin_unlock_bh(&lgr->llc_flow_lock);
  225. return 0;
  226. }
  227. spin_unlock_bh(&lgr->llc_flow_lock);
  228. rc = wait_event_timeout(lgr->llc_flow_waiter, (list_empty(&lgr->list) ||
  229. (lgr->llc_flow_lcl.type == SMC_LLC_FLOW_NONE &&
  230. (lgr->llc_flow_rmt.type == SMC_LLC_FLOW_NONE ||
  231. lgr->llc_flow_rmt.type == allowed_remote))),
  232. SMC_LLC_WAIT_TIME * 10);
  233. if (!rc)
  234. return -ETIMEDOUT;
  235. goto again;
  236. }
  237. /* finish the current llc flow */
  238. void smc_llc_flow_stop(struct smc_link_group *lgr, struct smc_llc_flow *flow)
  239. {
  240. spin_lock_bh(&lgr->llc_flow_lock);
  241. memset(flow, 0, sizeof(*flow));
  242. flow->type = SMC_LLC_FLOW_NONE;
  243. spin_unlock_bh(&lgr->llc_flow_lock);
  244. if (!list_empty(&lgr->list) && lgr->delayed_event &&
  245. flow == &lgr->llc_flow_lcl)
  246. schedule_work(&lgr->llc_event_work);
  247. else
  248. wake_up(&lgr->llc_flow_waiter);
  249. }
  250. /* lnk is optional and used for early wakeup when link goes down, useful in
  251. * cases where we wait for a response on the link after we sent a request
  252. */
  253. struct smc_llc_qentry *smc_llc_wait(struct smc_link_group *lgr,
  254. struct smc_link *lnk,
  255. int time_out, u8 exp_msg)
  256. {
  257. struct smc_llc_flow *flow = &lgr->llc_flow_lcl;
  258. u8 rcv_msg;
  259. wait_event_timeout(lgr->llc_msg_waiter,
  260. (flow->qentry ||
  261. (lnk && !smc_link_usable(lnk)) ||
  262. list_empty(&lgr->list)),
  263. time_out);
  264. if (!flow->qentry ||
  265. (lnk && !smc_link_usable(lnk)) || list_empty(&lgr->list)) {
  266. smc_llc_flow_qentry_del(flow);
  267. goto out;
  268. }
  269. rcv_msg = flow->qentry->msg.raw.hdr.common.type;
  270. if (exp_msg && rcv_msg != exp_msg) {
  271. if (exp_msg == SMC_LLC_ADD_LINK &&
  272. rcv_msg == SMC_LLC_DELETE_LINK) {
  273. /* flow_start will delay the unexpected msg */
  274. smc_llc_flow_start(&lgr->llc_flow_lcl,
  275. smc_llc_flow_qentry_clr(flow));
  276. return NULL;
  277. }
  278. pr_warn_once("smc: SMC-R lg %*phN dropped unexpected LLC msg: "
  279. "msg %d exp %d flow %d role %d flags %x\n",
  280. SMC_LGR_ID_SIZE, &lgr->id, rcv_msg, exp_msg,
  281. flow->type, lgr->role,
  282. flow->qentry->msg.raw.hdr.flags);
  283. smc_llc_flow_qentry_del(flow);
  284. }
  285. out:
  286. return flow->qentry;
  287. }
  288. /********************************** send *************************************/
  289. struct smc_llc_tx_pend {
  290. };
  291. /* handler for send/transmission completion of an LLC msg */
  292. static void smc_llc_tx_handler(struct smc_wr_tx_pend_priv *pend,
  293. struct smc_link *link,
  294. enum ib_wc_status wc_status)
  295. {
  296. /* future work: handle wc_status error for recovery and failover */
  297. }
  298. /**
  299. * smc_llc_add_pending_send() - add LLC control message to pending WQE transmits
  300. * @link: Pointer to SMC link used for sending LLC control message.
  301. * @wr_buf: Out variable returning pointer to work request payload buffer.
  302. * @pend: Out variable returning pointer to private pending WR tracking.
  303. * It's the context the transmit complete handler will get.
  304. *
  305. * Reserves and pre-fills an entry for a pending work request send/tx.
  306. * Used by mid-level smc_llc_send_msg() to prepare for later actual send/tx.
  307. * Can sleep due to smc_get_ctrl_buf (if not in softirq context).
  308. *
  309. * Return: 0 on success, otherwise an error value.
  310. */
  311. static int smc_llc_add_pending_send(struct smc_link *link,
  312. struct smc_wr_buf **wr_buf,
  313. struct smc_wr_tx_pend_priv **pend)
  314. {
  315. int rc;
  316. rc = smc_wr_tx_get_free_slot(link, smc_llc_tx_handler, wr_buf, NULL,
  317. pend);
  318. if (rc < 0)
  319. return rc;
  320. BUILD_BUG_ON_MSG(
  321. sizeof(union smc_llc_msg) > SMC_WR_BUF_SIZE,
  322. "must increase SMC_WR_BUF_SIZE to at least sizeof(struct smc_llc_msg)");
  323. BUILD_BUG_ON_MSG(
  324. sizeof(union smc_llc_msg) != SMC_WR_TX_SIZE,
  325. "must adapt SMC_WR_TX_SIZE to sizeof(struct smc_llc_msg); if not all smc_wr upper layer protocols use the same message size any more, must start to set link->wr_tx_sges[i].length on each individual smc_wr_tx_send()");
  326. BUILD_BUG_ON_MSG(
  327. sizeof(struct smc_llc_tx_pend) > SMC_WR_TX_PEND_PRIV_SIZE,
  328. "must increase SMC_WR_TX_PEND_PRIV_SIZE to at least sizeof(struct smc_llc_tx_pend)");
  329. return 0;
  330. }
  331. /* high-level API to send LLC confirm link */
  332. int smc_llc_send_confirm_link(struct smc_link *link,
  333. enum smc_llc_reqresp reqresp)
  334. {
  335. struct smc_llc_msg_confirm_link *confllc;
  336. struct smc_wr_tx_pend_priv *pend;
  337. struct smc_wr_buf *wr_buf;
  338. int rc;
  339. if (!smc_wr_tx_link_hold(link))
  340. return -ENOLINK;
  341. rc = smc_llc_add_pending_send(link, &wr_buf, &pend);
  342. if (rc)
  343. goto put_out;
  344. confllc = (struct smc_llc_msg_confirm_link *)wr_buf;
  345. memset(confllc, 0, sizeof(*confllc));
  346. confllc->hd.common.type = SMC_LLC_CONFIRM_LINK;
  347. confllc->hd.length = sizeof(struct smc_llc_msg_confirm_link);
  348. confllc->hd.flags |= SMC_LLC_FLAG_NO_RMBE_EYEC;
  349. if (reqresp == SMC_LLC_RESP)
  350. confllc->hd.flags |= SMC_LLC_FLAG_RESP;
  351. memcpy(confllc->sender_mac, link->smcibdev->mac[link->ibport - 1],
  352. ETH_ALEN);
  353. memcpy(confllc->sender_gid, link->gid, SMC_GID_SIZE);
  354. hton24(confllc->sender_qp_num, link->roce_qp->qp_num);
  355. confllc->link_num = link->link_id;
  356. memcpy(confllc->link_uid, link->link_uid, SMC_LGR_ID_SIZE);
  357. confllc->max_links = SMC_LLC_ADD_LNK_MAX_LINKS;
  358. /* send llc message */
  359. rc = smc_wr_tx_send(link, pend);
  360. put_out:
  361. smc_wr_tx_link_put(link);
  362. return rc;
  363. }
  364. /* send LLC confirm rkey request */
  365. static int smc_llc_send_confirm_rkey(struct smc_link *send_link,
  366. struct smc_buf_desc *rmb_desc)
  367. {
  368. struct smc_llc_msg_confirm_rkey *rkeyllc;
  369. struct smc_wr_tx_pend_priv *pend;
  370. struct smc_wr_buf *wr_buf;
  371. struct smc_link *link;
  372. int i, rc, rtok_ix;
  373. if (!smc_wr_tx_link_hold(send_link))
  374. return -ENOLINK;
  375. rc = smc_llc_add_pending_send(send_link, &wr_buf, &pend);
  376. if (rc)
  377. goto put_out;
  378. rkeyllc = (struct smc_llc_msg_confirm_rkey *)wr_buf;
  379. memset(rkeyllc, 0, sizeof(*rkeyllc));
  380. rkeyllc->hd.common.type = SMC_LLC_CONFIRM_RKEY;
  381. rkeyllc->hd.length = sizeof(struct smc_llc_msg_confirm_rkey);
  382. rtok_ix = 1;
  383. for (i = 0; i < SMC_LINKS_PER_LGR_MAX; i++) {
  384. link = &send_link->lgr->lnk[i];
  385. if (smc_link_active(link) && link != send_link) {
  386. rkeyllc->rtoken[rtok_ix].link_id = link->link_id;
  387. rkeyllc->rtoken[rtok_ix].rmb_key =
  388. htonl(rmb_desc->mr_rx[link->link_idx]->rkey);
  389. rkeyllc->rtoken[rtok_ix].rmb_vaddr = cpu_to_be64(
  390. (u64)sg_dma_address(
  391. rmb_desc->sgt[link->link_idx].sgl));
  392. rtok_ix++;
  393. }
  394. }
  395. /* rkey of send_link is in rtoken[0] */
  396. rkeyllc->rtoken[0].num_rkeys = rtok_ix - 1;
  397. rkeyllc->rtoken[0].rmb_key =
  398. htonl(rmb_desc->mr_rx[send_link->link_idx]->rkey);
  399. rkeyllc->rtoken[0].rmb_vaddr = cpu_to_be64(
  400. (u64)sg_dma_address(rmb_desc->sgt[send_link->link_idx].sgl));
  401. /* send llc message */
  402. rc = smc_wr_tx_send(send_link, pend);
  403. put_out:
  404. smc_wr_tx_link_put(send_link);
  405. return rc;
  406. }
  407. /* send LLC delete rkey request */
  408. static int smc_llc_send_delete_rkey(struct smc_link *link,
  409. struct smc_buf_desc *rmb_desc)
  410. {
  411. struct smc_llc_msg_delete_rkey *rkeyllc;
  412. struct smc_wr_tx_pend_priv *pend;
  413. struct smc_wr_buf *wr_buf;
  414. int rc;
  415. if (!smc_wr_tx_link_hold(link))
  416. return -ENOLINK;
  417. rc = smc_llc_add_pending_send(link, &wr_buf, &pend);
  418. if (rc)
  419. goto put_out;
  420. rkeyllc = (struct smc_llc_msg_delete_rkey *)wr_buf;
  421. memset(rkeyllc, 0, sizeof(*rkeyllc));
  422. rkeyllc->hd.common.type = SMC_LLC_DELETE_RKEY;
  423. rkeyllc->hd.length = sizeof(struct smc_llc_msg_delete_rkey);
  424. rkeyllc->num_rkeys = 1;
  425. rkeyllc->rkey[0] = htonl(rmb_desc->mr_rx[link->link_idx]->rkey);
  426. /* send llc message */
  427. rc = smc_wr_tx_send(link, pend);
  428. put_out:
  429. smc_wr_tx_link_put(link);
  430. return rc;
  431. }
  432. /* send ADD LINK request or response */
  433. int smc_llc_send_add_link(struct smc_link *link, u8 mac[], u8 gid[],
  434. struct smc_link *link_new,
  435. enum smc_llc_reqresp reqresp)
  436. {
  437. struct smc_llc_msg_add_link *addllc;
  438. struct smc_wr_tx_pend_priv *pend;
  439. struct smc_wr_buf *wr_buf;
  440. int rc;
  441. if (!smc_wr_tx_link_hold(link))
  442. return -ENOLINK;
  443. rc = smc_llc_add_pending_send(link, &wr_buf, &pend);
  444. if (rc)
  445. goto put_out;
  446. addllc = (struct smc_llc_msg_add_link *)wr_buf;
  447. memset(addllc, 0, sizeof(*addllc));
  448. addllc->hd.common.type = SMC_LLC_ADD_LINK;
  449. addllc->hd.length = sizeof(struct smc_llc_msg_add_link);
  450. if (reqresp == SMC_LLC_RESP)
  451. addllc->hd.flags |= SMC_LLC_FLAG_RESP;
  452. memcpy(addllc->sender_mac, mac, ETH_ALEN);
  453. memcpy(addllc->sender_gid, gid, SMC_GID_SIZE);
  454. if (link_new) {
  455. addllc->link_num = link_new->link_id;
  456. hton24(addllc->sender_qp_num, link_new->roce_qp->qp_num);
  457. hton24(addllc->initial_psn, link_new->psn_initial);
  458. if (reqresp == SMC_LLC_REQ)
  459. addllc->qp_mtu = link_new->path_mtu;
  460. else
  461. addllc->qp_mtu = min(link_new->path_mtu,
  462. link_new->peer_mtu);
  463. }
  464. /* send llc message */
  465. rc = smc_wr_tx_send(link, pend);
  466. put_out:
  467. smc_wr_tx_link_put(link);
  468. return rc;
  469. }
  470. /* send DELETE LINK request or response */
  471. int smc_llc_send_delete_link(struct smc_link *link, u8 link_del_id,
  472. enum smc_llc_reqresp reqresp, bool orderly,
  473. u32 reason)
  474. {
  475. struct smc_llc_msg_del_link *delllc;
  476. struct smc_wr_tx_pend_priv *pend;
  477. struct smc_wr_buf *wr_buf;
  478. int rc;
  479. if (!smc_wr_tx_link_hold(link))
  480. return -ENOLINK;
  481. rc = smc_llc_add_pending_send(link, &wr_buf, &pend);
  482. if (rc)
  483. goto put_out;
  484. delllc = (struct smc_llc_msg_del_link *)wr_buf;
  485. memset(delllc, 0, sizeof(*delllc));
  486. delllc->hd.common.type = SMC_LLC_DELETE_LINK;
  487. delllc->hd.length = sizeof(struct smc_llc_msg_del_link);
  488. if (reqresp == SMC_LLC_RESP)
  489. delllc->hd.flags |= SMC_LLC_FLAG_RESP;
  490. if (orderly)
  491. delllc->hd.flags |= SMC_LLC_FLAG_DEL_LINK_ORDERLY;
  492. if (link_del_id)
  493. delllc->link_num = link_del_id;
  494. else
  495. delllc->hd.flags |= SMC_LLC_FLAG_DEL_LINK_ALL;
  496. delllc->reason = htonl(reason);
  497. /* send llc message */
  498. rc = smc_wr_tx_send(link, pend);
  499. put_out:
  500. smc_wr_tx_link_put(link);
  501. return rc;
  502. }
  503. /* send LLC test link request */
  504. static int smc_llc_send_test_link(struct smc_link *link, u8 user_data[16])
  505. {
  506. struct smc_llc_msg_test_link *testllc;
  507. struct smc_wr_tx_pend_priv *pend;
  508. struct smc_wr_buf *wr_buf;
  509. int rc;
  510. if (!smc_wr_tx_link_hold(link))
  511. return -ENOLINK;
  512. rc = smc_llc_add_pending_send(link, &wr_buf, &pend);
  513. if (rc)
  514. goto put_out;
  515. testllc = (struct smc_llc_msg_test_link *)wr_buf;
  516. memset(testllc, 0, sizeof(*testllc));
  517. testllc->hd.common.type = SMC_LLC_TEST_LINK;
  518. testllc->hd.length = sizeof(struct smc_llc_msg_test_link);
  519. memcpy(testllc->user_data, user_data, sizeof(testllc->user_data));
  520. /* send llc message */
  521. rc = smc_wr_tx_send(link, pend);
  522. put_out:
  523. smc_wr_tx_link_put(link);
  524. return rc;
  525. }
  526. /* schedule an llc send on link, may wait for buffers */
  527. static int smc_llc_send_message(struct smc_link *link, void *llcbuf)
  528. {
  529. struct smc_wr_tx_pend_priv *pend;
  530. struct smc_wr_buf *wr_buf;
  531. int rc;
  532. if (!smc_wr_tx_link_hold(link))
  533. return -ENOLINK;
  534. rc = smc_llc_add_pending_send(link, &wr_buf, &pend);
  535. if (rc)
  536. goto put_out;
  537. memcpy(wr_buf, llcbuf, sizeof(union smc_llc_msg));
  538. rc = smc_wr_tx_send(link, pend);
  539. put_out:
  540. smc_wr_tx_link_put(link);
  541. return rc;
  542. }
  543. /* schedule an llc send on link, may wait for buffers,
  544. * and wait for send completion notification.
  545. * @return 0 on success
  546. */
  547. static int smc_llc_send_message_wait(struct smc_link *link, void *llcbuf)
  548. {
  549. struct smc_wr_tx_pend_priv *pend;
  550. struct smc_wr_buf *wr_buf;
  551. int rc;
  552. if (!smc_wr_tx_link_hold(link))
  553. return -ENOLINK;
  554. rc = smc_llc_add_pending_send(link, &wr_buf, &pend);
  555. if (rc)
  556. goto put_out;
  557. memcpy(wr_buf, llcbuf, sizeof(union smc_llc_msg));
  558. rc = smc_wr_tx_send_wait(link, pend, SMC_LLC_WAIT_TIME);
  559. put_out:
  560. smc_wr_tx_link_put(link);
  561. return rc;
  562. }
  563. /********************************* receive ***********************************/
  564. static int smc_llc_alloc_alt_link(struct smc_link_group *lgr,
  565. enum smc_lgr_type lgr_new_t)
  566. {
  567. int i;
  568. if (lgr->type == SMC_LGR_SYMMETRIC ||
  569. (lgr->type != SMC_LGR_SINGLE &&
  570. (lgr_new_t == SMC_LGR_ASYMMETRIC_LOCAL ||
  571. lgr_new_t == SMC_LGR_ASYMMETRIC_PEER)))
  572. return -EMLINK;
  573. if (lgr_new_t == SMC_LGR_ASYMMETRIC_LOCAL ||
  574. lgr_new_t == SMC_LGR_ASYMMETRIC_PEER) {
  575. for (i = SMC_LINKS_PER_LGR_MAX - 1; i >= 0; i--)
  576. if (lgr->lnk[i].state == SMC_LNK_UNUSED)
  577. return i;
  578. } else {
  579. for (i = 0; i < SMC_LINKS_PER_LGR_MAX; i++)
  580. if (lgr->lnk[i].state == SMC_LNK_UNUSED)
  581. return i;
  582. }
  583. return -EMLINK;
  584. }
  585. /* return first buffer from any of the next buf lists */
  586. static struct smc_buf_desc *_smc_llc_get_next_rmb(struct smc_link_group *lgr,
  587. int *buf_lst)
  588. {
  589. struct smc_buf_desc *buf_pos;
  590. while (*buf_lst < SMC_RMBE_SIZES) {
  591. buf_pos = list_first_entry_or_null(&lgr->rmbs[*buf_lst],
  592. struct smc_buf_desc, list);
  593. if (buf_pos)
  594. return buf_pos;
  595. (*buf_lst)++;
  596. }
  597. return NULL;
  598. }
  599. /* return next rmb from buffer lists */
  600. static struct smc_buf_desc *smc_llc_get_next_rmb(struct smc_link_group *lgr,
  601. int *buf_lst,
  602. struct smc_buf_desc *buf_pos)
  603. {
  604. struct smc_buf_desc *buf_next;
  605. if (!buf_pos || list_is_last(&buf_pos->list, &lgr->rmbs[*buf_lst])) {
  606. (*buf_lst)++;
  607. return _smc_llc_get_next_rmb(lgr, buf_lst);
  608. }
  609. buf_next = list_next_entry(buf_pos, list);
  610. return buf_next;
  611. }
  612. static struct smc_buf_desc *smc_llc_get_first_rmb(struct smc_link_group *lgr,
  613. int *buf_lst)
  614. {
  615. *buf_lst = 0;
  616. return smc_llc_get_next_rmb(lgr, buf_lst, NULL);
  617. }
  618. /* send one add_link_continue msg */
  619. static int smc_llc_add_link_cont(struct smc_link *link,
  620. struct smc_link *link_new, u8 *num_rkeys_todo,
  621. int *buf_lst, struct smc_buf_desc **buf_pos)
  622. {
  623. struct smc_llc_msg_add_link_cont *addc_llc;
  624. struct smc_link_group *lgr = link->lgr;
  625. int prim_lnk_idx, lnk_idx, i, rc;
  626. struct smc_wr_tx_pend_priv *pend;
  627. struct smc_wr_buf *wr_buf;
  628. struct smc_buf_desc *rmb;
  629. u8 n;
  630. if (!smc_wr_tx_link_hold(link))
  631. return -ENOLINK;
  632. rc = smc_llc_add_pending_send(link, &wr_buf, &pend);
  633. if (rc)
  634. goto put_out;
  635. addc_llc = (struct smc_llc_msg_add_link_cont *)wr_buf;
  636. memset(addc_llc, 0, sizeof(*addc_llc));
  637. prim_lnk_idx = link->link_idx;
  638. lnk_idx = link_new->link_idx;
  639. addc_llc->link_num = link_new->link_id;
  640. addc_llc->num_rkeys = *num_rkeys_todo;
  641. n = *num_rkeys_todo;
  642. for (i = 0; i < min_t(u8, n, SMC_LLC_RKEYS_PER_CONT_MSG); i++) {
  643. if (!*buf_pos) {
  644. addc_llc->num_rkeys = addc_llc->num_rkeys -
  645. *num_rkeys_todo;
  646. *num_rkeys_todo = 0;
  647. break;
  648. }
  649. rmb = *buf_pos;
  650. addc_llc->rt[i].rmb_key = htonl(rmb->mr_rx[prim_lnk_idx]->rkey);
  651. addc_llc->rt[i].rmb_key_new = htonl(rmb->mr_rx[lnk_idx]->rkey);
  652. addc_llc->rt[i].rmb_vaddr_new =
  653. cpu_to_be64((u64)sg_dma_address(rmb->sgt[lnk_idx].sgl));
  654. (*num_rkeys_todo)--;
  655. *buf_pos = smc_llc_get_next_rmb(lgr, buf_lst, *buf_pos);
  656. while (*buf_pos && !(*buf_pos)->used)
  657. *buf_pos = smc_llc_get_next_rmb(lgr, buf_lst, *buf_pos);
  658. }
  659. addc_llc->hd.common.type = SMC_LLC_ADD_LINK_CONT;
  660. addc_llc->hd.length = sizeof(struct smc_llc_msg_add_link_cont);
  661. if (lgr->role == SMC_CLNT)
  662. addc_llc->hd.flags |= SMC_LLC_FLAG_RESP;
  663. rc = smc_wr_tx_send(link, pend);
  664. put_out:
  665. smc_wr_tx_link_put(link);
  666. return rc;
  667. }
  668. static int smc_llc_cli_rkey_exchange(struct smc_link *link,
  669. struct smc_link *link_new)
  670. {
  671. struct smc_llc_msg_add_link_cont *addc_llc;
  672. struct smc_link_group *lgr = link->lgr;
  673. u8 max, num_rkeys_send, num_rkeys_recv;
  674. struct smc_llc_qentry *qentry;
  675. struct smc_buf_desc *buf_pos;
  676. int buf_lst;
  677. int rc = 0;
  678. int i;
  679. mutex_lock(&lgr->rmbs_lock);
  680. num_rkeys_send = lgr->conns_num;
  681. buf_pos = smc_llc_get_first_rmb(lgr, &buf_lst);
  682. do {
  683. qentry = smc_llc_wait(lgr, NULL, SMC_LLC_WAIT_TIME,
  684. SMC_LLC_ADD_LINK_CONT);
  685. if (!qentry) {
  686. rc = -ETIMEDOUT;
  687. break;
  688. }
  689. addc_llc = &qentry->msg.add_link_cont;
  690. num_rkeys_recv = addc_llc->num_rkeys;
  691. max = min_t(u8, num_rkeys_recv, SMC_LLC_RKEYS_PER_CONT_MSG);
  692. for (i = 0; i < max; i++) {
  693. smc_rtoken_set(lgr, link->link_idx, link_new->link_idx,
  694. addc_llc->rt[i].rmb_key,
  695. addc_llc->rt[i].rmb_vaddr_new,
  696. addc_llc->rt[i].rmb_key_new);
  697. num_rkeys_recv--;
  698. }
  699. smc_llc_flow_qentry_del(&lgr->llc_flow_lcl);
  700. rc = smc_llc_add_link_cont(link, link_new, &num_rkeys_send,
  701. &buf_lst, &buf_pos);
  702. if (rc)
  703. break;
  704. } while (num_rkeys_send || num_rkeys_recv);
  705. mutex_unlock(&lgr->rmbs_lock);
  706. return rc;
  707. }
  708. /* prepare and send an add link reject response */
  709. static int smc_llc_cli_add_link_reject(struct smc_llc_qentry *qentry)
  710. {
  711. qentry->msg.raw.hdr.flags |= SMC_LLC_FLAG_RESP;
  712. qentry->msg.raw.hdr.flags |= SMC_LLC_FLAG_ADD_LNK_REJ;
  713. qentry->msg.raw.hdr.add_link_rej_rsn = SMC_LLC_REJ_RSN_NO_ALT_PATH;
  714. return smc_llc_send_message(qentry->link, &qentry->msg);
  715. }
  716. static int smc_llc_cli_conf_link(struct smc_link *link,
  717. struct smc_init_info *ini,
  718. struct smc_link *link_new,
  719. enum smc_lgr_type lgr_new_t)
  720. {
  721. struct smc_link_group *lgr = link->lgr;
  722. struct smc_llc_qentry *qentry = NULL;
  723. int rc = 0;
  724. /* receive CONFIRM LINK request over RoCE fabric */
  725. qentry = smc_llc_wait(lgr, NULL, SMC_LLC_WAIT_FIRST_TIME, 0);
  726. if (!qentry) {
  727. rc = smc_llc_send_delete_link(link, link_new->link_id,
  728. SMC_LLC_REQ, false,
  729. SMC_LLC_DEL_LOST_PATH);
  730. return -ENOLINK;
  731. }
  732. if (qentry->msg.raw.hdr.common.type != SMC_LLC_CONFIRM_LINK) {
  733. /* received DELETE_LINK instead */
  734. qentry->msg.raw.hdr.flags |= SMC_LLC_FLAG_RESP;
  735. smc_llc_send_message(link, &qentry->msg);
  736. smc_llc_flow_qentry_del(&lgr->llc_flow_lcl);
  737. return -ENOLINK;
  738. }
  739. smc_llc_save_peer_uid(qentry);
  740. smc_llc_flow_qentry_del(&lgr->llc_flow_lcl);
  741. rc = smc_ib_modify_qp_rts(link_new);
  742. if (rc) {
  743. smc_llc_send_delete_link(link, link_new->link_id, SMC_LLC_REQ,
  744. false, SMC_LLC_DEL_LOST_PATH);
  745. return -ENOLINK;
  746. }
  747. smc_wr_remember_qp_attr(link_new);
  748. rc = smcr_buf_reg_lgr(link_new);
  749. if (rc) {
  750. smc_llc_send_delete_link(link, link_new->link_id, SMC_LLC_REQ,
  751. false, SMC_LLC_DEL_LOST_PATH);
  752. return -ENOLINK;
  753. }
  754. /* send CONFIRM LINK response over RoCE fabric */
  755. rc = smc_llc_send_confirm_link(link_new, SMC_LLC_RESP);
  756. if (rc) {
  757. smc_llc_send_delete_link(link, link_new->link_id, SMC_LLC_REQ,
  758. false, SMC_LLC_DEL_LOST_PATH);
  759. return -ENOLINK;
  760. }
  761. smc_llc_link_active(link_new);
  762. if (lgr_new_t == SMC_LGR_ASYMMETRIC_LOCAL ||
  763. lgr_new_t == SMC_LGR_ASYMMETRIC_PEER)
  764. smcr_lgr_set_type_asym(lgr, lgr_new_t, link_new->link_idx);
  765. else
  766. smcr_lgr_set_type(lgr, lgr_new_t);
  767. return 0;
  768. }
  769. static void smc_llc_save_add_link_info(struct smc_link *link,
  770. struct smc_llc_msg_add_link *add_llc)
  771. {
  772. link->peer_qpn = ntoh24(add_llc->sender_qp_num);
  773. memcpy(link->peer_gid, add_llc->sender_gid, SMC_GID_SIZE);
  774. memcpy(link->peer_mac, add_llc->sender_mac, ETH_ALEN);
  775. link->peer_psn = ntoh24(add_llc->initial_psn);
  776. link->peer_mtu = add_llc->qp_mtu;
  777. }
  778. /* as an SMC client, process an add link request */
  779. int smc_llc_cli_add_link(struct smc_link *link, struct smc_llc_qentry *qentry)
  780. {
  781. struct smc_llc_msg_add_link *llc = &qentry->msg.add_link;
  782. enum smc_lgr_type lgr_new_t = SMC_LGR_SYMMETRIC;
  783. struct smc_link_group *lgr = smc_get_lgr(link);
  784. struct smc_link *lnk_new = NULL;
  785. struct smc_init_info ini;
  786. int lnk_idx, rc = 0;
  787. if (!llc->qp_mtu)
  788. goto out_reject;
  789. ini.vlan_id = lgr->vlan_id;
  790. smc_pnet_find_alt_roce(lgr, &ini, link->smcibdev);
  791. if (!memcmp(llc->sender_gid, link->peer_gid, SMC_GID_SIZE) &&
  792. !memcmp(llc->sender_mac, link->peer_mac, ETH_ALEN)) {
  793. if (!ini.ib_dev)
  794. goto out_reject;
  795. lgr_new_t = SMC_LGR_ASYMMETRIC_PEER;
  796. }
  797. if (!ini.ib_dev) {
  798. lgr_new_t = SMC_LGR_ASYMMETRIC_LOCAL;
  799. ini.ib_dev = link->smcibdev;
  800. ini.ib_port = link->ibport;
  801. }
  802. lnk_idx = smc_llc_alloc_alt_link(lgr, lgr_new_t);
  803. if (lnk_idx < 0)
  804. goto out_reject;
  805. lnk_new = &lgr->lnk[lnk_idx];
  806. rc = smcr_link_init(lgr, lnk_new, lnk_idx, &ini);
  807. if (rc)
  808. goto out_reject;
  809. smc_llc_save_add_link_info(lnk_new, llc);
  810. lnk_new->link_id = llc->link_num; /* SMC server assigns link id */
  811. smc_llc_link_set_uid(lnk_new);
  812. rc = smc_ib_ready_link(lnk_new);
  813. if (rc)
  814. goto out_clear_lnk;
  815. rc = smcr_buf_map_lgr(lnk_new);
  816. if (rc)
  817. goto out_clear_lnk;
  818. rc = smc_llc_send_add_link(link,
  819. lnk_new->smcibdev->mac[ini.ib_port - 1],
  820. lnk_new->gid, lnk_new, SMC_LLC_RESP);
  821. if (rc)
  822. goto out_clear_lnk;
  823. rc = smc_llc_cli_rkey_exchange(link, lnk_new);
  824. if (rc) {
  825. rc = 0;
  826. goto out_clear_lnk;
  827. }
  828. rc = smc_llc_cli_conf_link(link, &ini, lnk_new, lgr_new_t);
  829. if (!rc)
  830. goto out;
  831. out_clear_lnk:
  832. lnk_new->state = SMC_LNK_INACTIVE;
  833. smcr_link_clear(lnk_new, false);
  834. out_reject:
  835. smc_llc_cli_add_link_reject(qentry);
  836. out:
  837. kfree(qentry);
  838. return rc;
  839. }
  840. /* as an SMC client, invite server to start the add_link processing */
  841. static void smc_llc_cli_add_link_invite(struct smc_link *link,
  842. struct smc_llc_qentry *qentry)
  843. {
  844. struct smc_link_group *lgr = smc_get_lgr(link);
  845. struct smc_init_info ini;
  846. if (lgr->type == SMC_LGR_SYMMETRIC ||
  847. lgr->type == SMC_LGR_ASYMMETRIC_PEER)
  848. goto out;
  849. ini.vlan_id = lgr->vlan_id;
  850. smc_pnet_find_alt_roce(lgr, &ini, link->smcibdev);
  851. if (!ini.ib_dev)
  852. goto out;
  853. smc_llc_send_add_link(link, ini.ib_dev->mac[ini.ib_port - 1],
  854. ini.ib_gid, NULL, SMC_LLC_REQ);
  855. out:
  856. kfree(qentry);
  857. }
  858. static bool smc_llc_is_empty_llc_message(union smc_llc_msg *llc)
  859. {
  860. int i;
  861. for (i = 0; i < ARRAY_SIZE(llc->raw.data); i++)
  862. if (llc->raw.data[i])
  863. return false;
  864. return true;
  865. }
  866. static bool smc_llc_is_local_add_link(union smc_llc_msg *llc)
  867. {
  868. if (llc->raw.hdr.common.type == SMC_LLC_ADD_LINK &&
  869. smc_llc_is_empty_llc_message(llc))
  870. return true;
  871. return false;
  872. }
  873. static void smc_llc_process_cli_add_link(struct smc_link_group *lgr)
  874. {
  875. struct smc_llc_qentry *qentry;
  876. qentry = smc_llc_flow_qentry_clr(&lgr->llc_flow_lcl);
  877. mutex_lock(&lgr->llc_conf_mutex);
  878. if (smc_llc_is_local_add_link(&qentry->msg))
  879. smc_llc_cli_add_link_invite(qentry->link, qentry);
  880. else
  881. smc_llc_cli_add_link(qentry->link, qentry);
  882. mutex_unlock(&lgr->llc_conf_mutex);
  883. }
  884. static int smc_llc_active_link_count(struct smc_link_group *lgr)
  885. {
  886. int i, link_count = 0;
  887. for (i = 0; i < SMC_LINKS_PER_LGR_MAX; i++) {
  888. if (!smc_link_active(&lgr->lnk[i]))
  889. continue;
  890. link_count++;
  891. }
  892. return link_count;
  893. }
  894. /* find the asymmetric link when 3 links are established */
  895. static struct smc_link *smc_llc_find_asym_link(struct smc_link_group *lgr)
  896. {
  897. int asym_idx = -ENOENT;
  898. int i, j, k;
  899. bool found;
  900. /* determine asymmetric link */
  901. found = false;
  902. for (i = 0; i < SMC_LINKS_PER_LGR_MAX; i++) {
  903. for (j = i + 1; j < SMC_LINKS_PER_LGR_MAX; j++) {
  904. if (!smc_link_usable(&lgr->lnk[i]) ||
  905. !smc_link_usable(&lgr->lnk[j]))
  906. continue;
  907. if (!memcmp(lgr->lnk[i].gid, lgr->lnk[j].gid,
  908. SMC_GID_SIZE)) {
  909. found = true; /* asym_lnk is i or j */
  910. break;
  911. }
  912. }
  913. if (found)
  914. break;
  915. }
  916. if (!found)
  917. goto out; /* no asymmetric link */
  918. for (k = 0; k < SMC_LINKS_PER_LGR_MAX; k++) {
  919. if (!smc_link_usable(&lgr->lnk[k]))
  920. continue;
  921. if (k != i &&
  922. !memcmp(lgr->lnk[i].peer_gid, lgr->lnk[k].peer_gid,
  923. SMC_GID_SIZE)) {
  924. asym_idx = i;
  925. break;
  926. }
  927. if (k != j &&
  928. !memcmp(lgr->lnk[j].peer_gid, lgr->lnk[k].peer_gid,
  929. SMC_GID_SIZE)) {
  930. asym_idx = j;
  931. break;
  932. }
  933. }
  934. out:
  935. return (asym_idx < 0) ? NULL : &lgr->lnk[asym_idx];
  936. }
  937. static void smc_llc_delete_asym_link(struct smc_link_group *lgr)
  938. {
  939. struct smc_link *lnk_new = NULL, *lnk_asym;
  940. struct smc_llc_qentry *qentry;
  941. int rc;
  942. lnk_asym = smc_llc_find_asym_link(lgr);
  943. if (!lnk_asym)
  944. return; /* no asymmetric link */
  945. if (!smc_link_downing(&lnk_asym->state))
  946. return;
  947. lnk_new = smc_switch_conns(lgr, lnk_asym, false);
  948. smc_wr_tx_wait_no_pending_sends(lnk_asym);
  949. if (!lnk_new)
  950. goto out_free;
  951. /* change flow type from ADD_LINK into DEL_LINK */
  952. lgr->llc_flow_lcl.type = SMC_LLC_FLOW_DEL_LINK;
  953. rc = smc_llc_send_delete_link(lnk_new, lnk_asym->link_id, SMC_LLC_REQ,
  954. true, SMC_LLC_DEL_NO_ASYM_NEEDED);
  955. if (rc) {
  956. smcr_link_down_cond(lnk_new);
  957. goto out_free;
  958. }
  959. qentry = smc_llc_wait(lgr, lnk_new, SMC_LLC_WAIT_TIME,
  960. SMC_LLC_DELETE_LINK);
  961. if (!qentry) {
  962. smcr_link_down_cond(lnk_new);
  963. goto out_free;
  964. }
  965. smc_llc_flow_qentry_del(&lgr->llc_flow_lcl);
  966. out_free:
  967. smcr_link_clear(lnk_asym, true);
  968. }
  969. static int smc_llc_srv_rkey_exchange(struct smc_link *link,
  970. struct smc_link *link_new)
  971. {
  972. struct smc_llc_msg_add_link_cont *addc_llc;
  973. struct smc_link_group *lgr = link->lgr;
  974. u8 max, num_rkeys_send, num_rkeys_recv;
  975. struct smc_llc_qentry *qentry = NULL;
  976. struct smc_buf_desc *buf_pos;
  977. int buf_lst;
  978. int rc = 0;
  979. int i;
  980. mutex_lock(&lgr->rmbs_lock);
  981. num_rkeys_send = lgr->conns_num;
  982. buf_pos = smc_llc_get_first_rmb(lgr, &buf_lst);
  983. do {
  984. smc_llc_add_link_cont(link, link_new, &num_rkeys_send,
  985. &buf_lst, &buf_pos);
  986. qentry = smc_llc_wait(lgr, link, SMC_LLC_WAIT_TIME,
  987. SMC_LLC_ADD_LINK_CONT);
  988. if (!qentry) {
  989. rc = -ETIMEDOUT;
  990. goto out;
  991. }
  992. addc_llc = &qentry->msg.add_link_cont;
  993. num_rkeys_recv = addc_llc->num_rkeys;
  994. max = min_t(u8, num_rkeys_recv, SMC_LLC_RKEYS_PER_CONT_MSG);
  995. for (i = 0; i < max; i++) {
  996. smc_rtoken_set(lgr, link->link_idx, link_new->link_idx,
  997. addc_llc->rt[i].rmb_key,
  998. addc_llc->rt[i].rmb_vaddr_new,
  999. addc_llc->rt[i].rmb_key_new);
  1000. num_rkeys_recv--;
  1001. }
  1002. smc_llc_flow_qentry_del(&lgr->llc_flow_lcl);
  1003. } while (num_rkeys_send || num_rkeys_recv);
  1004. out:
  1005. mutex_unlock(&lgr->rmbs_lock);
  1006. return rc;
  1007. }
  1008. static int smc_llc_srv_conf_link(struct smc_link *link,
  1009. struct smc_link *link_new,
  1010. enum smc_lgr_type lgr_new_t)
  1011. {
  1012. struct smc_link_group *lgr = link->lgr;
  1013. struct smc_llc_qentry *qentry = NULL;
  1014. int rc;
  1015. /* send CONFIRM LINK request over the RoCE fabric */
  1016. rc = smc_llc_send_confirm_link(link_new, SMC_LLC_REQ);
  1017. if (rc)
  1018. return -ENOLINK;
  1019. /* receive CONFIRM LINK response over the RoCE fabric */
  1020. qentry = smc_llc_wait(lgr, link, SMC_LLC_WAIT_FIRST_TIME, 0);
  1021. if (!qentry ||
  1022. qentry->msg.raw.hdr.common.type != SMC_LLC_CONFIRM_LINK) {
  1023. /* send DELETE LINK */
  1024. smc_llc_send_delete_link(link, link_new->link_id, SMC_LLC_REQ,
  1025. false, SMC_LLC_DEL_LOST_PATH);
  1026. if (qentry)
  1027. smc_llc_flow_qentry_del(&lgr->llc_flow_lcl);
  1028. return -ENOLINK;
  1029. }
  1030. smc_llc_save_peer_uid(qentry);
  1031. smc_llc_link_active(link_new);
  1032. if (lgr_new_t == SMC_LGR_ASYMMETRIC_LOCAL ||
  1033. lgr_new_t == SMC_LGR_ASYMMETRIC_PEER)
  1034. smcr_lgr_set_type_asym(lgr, lgr_new_t, link_new->link_idx);
  1035. else
  1036. smcr_lgr_set_type(lgr, lgr_new_t);
  1037. smc_llc_flow_qentry_del(&lgr->llc_flow_lcl);
  1038. return 0;
  1039. }
  1040. int smc_llc_srv_add_link(struct smc_link *link)
  1041. {
  1042. enum smc_lgr_type lgr_new_t = SMC_LGR_SYMMETRIC;
  1043. struct smc_link_group *lgr = link->lgr;
  1044. struct smc_llc_msg_add_link *add_llc;
  1045. struct smc_llc_qentry *qentry = NULL;
  1046. struct smc_link *link_new;
  1047. struct smc_init_info ini;
  1048. int lnk_idx, rc = 0;
  1049. /* ignore client add link recommendation, start new flow */
  1050. ini.vlan_id = lgr->vlan_id;
  1051. smc_pnet_find_alt_roce(lgr, &ini, link->smcibdev);
  1052. if (!ini.ib_dev) {
  1053. lgr_new_t = SMC_LGR_ASYMMETRIC_LOCAL;
  1054. ini.ib_dev = link->smcibdev;
  1055. ini.ib_port = link->ibport;
  1056. }
  1057. lnk_idx = smc_llc_alloc_alt_link(lgr, lgr_new_t);
  1058. if (lnk_idx < 0)
  1059. return 0;
  1060. rc = smcr_link_init(lgr, &lgr->lnk[lnk_idx], lnk_idx, &ini);
  1061. if (rc)
  1062. return rc;
  1063. link_new = &lgr->lnk[lnk_idx];
  1064. rc = smc_llc_send_add_link(link,
  1065. link_new->smcibdev->mac[ini.ib_port - 1],
  1066. link_new->gid, link_new, SMC_LLC_REQ);
  1067. if (rc)
  1068. goto out_err;
  1069. /* receive ADD LINK response over the RoCE fabric */
  1070. qentry = smc_llc_wait(lgr, link, SMC_LLC_WAIT_TIME, SMC_LLC_ADD_LINK);
  1071. if (!qentry) {
  1072. rc = -ETIMEDOUT;
  1073. goto out_err;
  1074. }
  1075. add_llc = &qentry->msg.add_link;
  1076. if (add_llc->hd.flags & SMC_LLC_FLAG_ADD_LNK_REJ) {
  1077. smc_llc_flow_qentry_del(&lgr->llc_flow_lcl);
  1078. rc = -ENOLINK;
  1079. goto out_err;
  1080. }
  1081. if (lgr->type == SMC_LGR_SINGLE &&
  1082. (!memcmp(add_llc->sender_gid, link->peer_gid, SMC_GID_SIZE) &&
  1083. !memcmp(add_llc->sender_mac, link->peer_mac, ETH_ALEN))) {
  1084. lgr_new_t = SMC_LGR_ASYMMETRIC_PEER;
  1085. }
  1086. smc_llc_save_add_link_info(link_new, add_llc);
  1087. smc_llc_flow_qentry_del(&lgr->llc_flow_lcl);
  1088. rc = smc_ib_ready_link(link_new);
  1089. if (rc)
  1090. goto out_err;
  1091. rc = smcr_buf_map_lgr(link_new);
  1092. if (rc)
  1093. goto out_err;
  1094. rc = smcr_buf_reg_lgr(link_new);
  1095. if (rc)
  1096. goto out_err;
  1097. rc = smc_llc_srv_rkey_exchange(link, link_new);
  1098. if (rc)
  1099. goto out_err;
  1100. rc = smc_llc_srv_conf_link(link, link_new, lgr_new_t);
  1101. if (rc)
  1102. goto out_err;
  1103. return 0;
  1104. out_err:
  1105. link_new->state = SMC_LNK_INACTIVE;
  1106. smcr_link_clear(link_new, false);
  1107. return rc;
  1108. }
  1109. static void smc_llc_process_srv_add_link(struct smc_link_group *lgr)
  1110. {
  1111. struct smc_link *link = lgr->llc_flow_lcl.qentry->link;
  1112. int rc;
  1113. smc_llc_flow_qentry_del(&lgr->llc_flow_lcl);
  1114. mutex_lock(&lgr->llc_conf_mutex);
  1115. rc = smc_llc_srv_add_link(link);
  1116. if (!rc && lgr->type == SMC_LGR_SYMMETRIC) {
  1117. /* delete any asymmetric link */
  1118. smc_llc_delete_asym_link(lgr);
  1119. }
  1120. mutex_unlock(&lgr->llc_conf_mutex);
  1121. }
  1122. /* enqueue a local add_link req to trigger a new add_link flow */
  1123. void smc_llc_add_link_local(struct smc_link *link)
  1124. {
  1125. struct smc_llc_msg_add_link add_llc = {};
  1126. add_llc.hd.length = sizeof(add_llc);
  1127. add_llc.hd.common.type = SMC_LLC_ADD_LINK;
  1128. /* no dev and port needed */
  1129. smc_llc_enqueue(link, (union smc_llc_msg *)&add_llc);
  1130. }
  1131. /* worker to process an add link message */
  1132. static void smc_llc_add_link_work(struct work_struct *work)
  1133. {
  1134. struct smc_link_group *lgr = container_of(work, struct smc_link_group,
  1135. llc_add_link_work);
  1136. if (list_empty(&lgr->list)) {
  1137. /* link group is terminating */
  1138. smc_llc_flow_qentry_del(&lgr->llc_flow_lcl);
  1139. goto out;
  1140. }
  1141. if (lgr->role == SMC_CLNT)
  1142. smc_llc_process_cli_add_link(lgr);
  1143. else
  1144. smc_llc_process_srv_add_link(lgr);
  1145. out:
  1146. smc_llc_flow_stop(lgr, &lgr->llc_flow_lcl);
  1147. }
  1148. /* enqueue a local del_link msg to trigger a new del_link flow,
  1149. * called only for role SMC_SERV
  1150. */
  1151. void smc_llc_srv_delete_link_local(struct smc_link *link, u8 del_link_id)
  1152. {
  1153. struct smc_llc_msg_del_link del_llc = {};
  1154. del_llc.hd.length = sizeof(del_llc);
  1155. del_llc.hd.common.type = SMC_LLC_DELETE_LINK;
  1156. del_llc.link_num = del_link_id;
  1157. del_llc.reason = htonl(SMC_LLC_DEL_LOST_PATH);
  1158. del_llc.hd.flags |= SMC_LLC_FLAG_DEL_LINK_ORDERLY;
  1159. smc_llc_enqueue(link, (union smc_llc_msg *)&del_llc);
  1160. }
  1161. static void smc_llc_process_cli_delete_link(struct smc_link_group *lgr)
  1162. {
  1163. struct smc_link *lnk_del = NULL, *lnk_asym, *lnk;
  1164. struct smc_llc_msg_del_link *del_llc;
  1165. struct smc_llc_qentry *qentry;
  1166. int active_links;
  1167. int lnk_idx;
  1168. qentry = smc_llc_flow_qentry_clr(&lgr->llc_flow_lcl);
  1169. lnk = qentry->link;
  1170. del_llc = &qentry->msg.delete_link;
  1171. if (del_llc->hd.flags & SMC_LLC_FLAG_DEL_LINK_ALL) {
  1172. smc_lgr_terminate_sched(lgr);
  1173. goto out;
  1174. }
  1175. mutex_lock(&lgr->llc_conf_mutex);
  1176. /* delete single link */
  1177. for (lnk_idx = 0; lnk_idx < SMC_LINKS_PER_LGR_MAX; lnk_idx++) {
  1178. if (lgr->lnk[lnk_idx].link_id != del_llc->link_num)
  1179. continue;
  1180. lnk_del = &lgr->lnk[lnk_idx];
  1181. break;
  1182. }
  1183. del_llc->hd.flags |= SMC_LLC_FLAG_RESP;
  1184. if (!lnk_del) {
  1185. /* link was not found */
  1186. del_llc->reason = htonl(SMC_LLC_DEL_NOLNK);
  1187. smc_llc_send_message(lnk, &qentry->msg);
  1188. goto out_unlock;
  1189. }
  1190. lnk_asym = smc_llc_find_asym_link(lgr);
  1191. del_llc->reason = 0;
  1192. smc_llc_send_message(lnk, &qentry->msg); /* response */
  1193. if (smc_link_downing(&lnk_del->state))
  1194. smc_switch_conns(lgr, lnk_del, false);
  1195. smcr_link_clear(lnk_del, true);
  1196. active_links = smc_llc_active_link_count(lgr);
  1197. if (lnk_del == lnk_asym) {
  1198. /* expected deletion of asym link, don't change lgr state */
  1199. } else if (active_links == 1) {
  1200. smcr_lgr_set_type(lgr, SMC_LGR_SINGLE);
  1201. } else if (!active_links) {
  1202. smcr_lgr_set_type(lgr, SMC_LGR_NONE);
  1203. smc_lgr_terminate_sched(lgr);
  1204. }
  1205. out_unlock:
  1206. mutex_unlock(&lgr->llc_conf_mutex);
  1207. out:
  1208. kfree(qentry);
  1209. }
  1210. /* try to send a DELETE LINK ALL request on any active link,
  1211. * waiting for send completion
  1212. */
  1213. void smc_llc_send_link_delete_all(struct smc_link_group *lgr, bool ord, u32 rsn)
  1214. {
  1215. struct smc_llc_msg_del_link delllc = {};
  1216. int i;
  1217. delllc.hd.common.type = SMC_LLC_DELETE_LINK;
  1218. delllc.hd.length = sizeof(delllc);
  1219. if (ord)
  1220. delllc.hd.flags |= SMC_LLC_FLAG_DEL_LINK_ORDERLY;
  1221. delllc.hd.flags |= SMC_LLC_FLAG_DEL_LINK_ALL;
  1222. delllc.reason = htonl(rsn);
  1223. for (i = 0; i < SMC_LINKS_PER_LGR_MAX; i++) {
  1224. if (!smc_link_sendable(&lgr->lnk[i]))
  1225. continue;
  1226. if (!smc_llc_send_message_wait(&lgr->lnk[i], &delllc))
  1227. break;
  1228. }
  1229. }
  1230. static void smc_llc_process_srv_delete_link(struct smc_link_group *lgr)
  1231. {
  1232. struct smc_llc_msg_del_link *del_llc;
  1233. struct smc_link *lnk, *lnk_del;
  1234. struct smc_llc_qentry *qentry;
  1235. int active_links;
  1236. int i;
  1237. mutex_lock(&lgr->llc_conf_mutex);
  1238. qentry = smc_llc_flow_qentry_clr(&lgr->llc_flow_lcl);
  1239. lnk = qentry->link;
  1240. del_llc = &qentry->msg.delete_link;
  1241. if (qentry->msg.delete_link.hd.flags & SMC_LLC_FLAG_DEL_LINK_ALL) {
  1242. /* delete entire lgr */
  1243. smc_llc_send_link_delete_all(lgr, true, ntohl(
  1244. qentry->msg.delete_link.reason));
  1245. smc_lgr_terminate_sched(lgr);
  1246. goto out;
  1247. }
  1248. /* delete single link */
  1249. lnk_del = NULL;
  1250. for (i = 0; i < SMC_LINKS_PER_LGR_MAX; i++) {
  1251. if (lgr->lnk[i].link_id == del_llc->link_num) {
  1252. lnk_del = &lgr->lnk[i];
  1253. break;
  1254. }
  1255. }
  1256. if (!lnk_del)
  1257. goto out; /* asymmetric link already deleted */
  1258. if (smc_link_downing(&lnk_del->state)) {
  1259. if (smc_switch_conns(lgr, lnk_del, false))
  1260. smc_wr_tx_wait_no_pending_sends(lnk_del);
  1261. }
  1262. if (!list_empty(&lgr->list)) {
  1263. /* qentry is either a request from peer (send it back to
  1264. * initiate the DELETE_LINK processing), or a locally
  1265. * enqueued DELETE_LINK request (forward it)
  1266. */
  1267. if (!smc_llc_send_message(lnk, &qentry->msg)) {
  1268. struct smc_llc_qentry *qentry2;
  1269. qentry2 = smc_llc_wait(lgr, lnk, SMC_LLC_WAIT_TIME,
  1270. SMC_LLC_DELETE_LINK);
  1271. if (qentry2)
  1272. smc_llc_flow_qentry_del(&lgr->llc_flow_lcl);
  1273. }
  1274. }
  1275. smcr_link_clear(lnk_del, true);
  1276. active_links = smc_llc_active_link_count(lgr);
  1277. if (active_links == 1) {
  1278. smcr_lgr_set_type(lgr, SMC_LGR_SINGLE);
  1279. } else if (!active_links) {
  1280. smcr_lgr_set_type(lgr, SMC_LGR_NONE);
  1281. smc_lgr_terminate_sched(lgr);
  1282. }
  1283. if (lgr->type == SMC_LGR_SINGLE && !list_empty(&lgr->list)) {
  1284. /* trigger setup of asymm alt link */
  1285. smc_llc_add_link_local(lnk);
  1286. }
  1287. out:
  1288. mutex_unlock(&lgr->llc_conf_mutex);
  1289. kfree(qentry);
  1290. }
  1291. static void smc_llc_delete_link_work(struct work_struct *work)
  1292. {
  1293. struct smc_link_group *lgr = container_of(work, struct smc_link_group,
  1294. llc_del_link_work);
  1295. if (list_empty(&lgr->list)) {
  1296. /* link group is terminating */
  1297. smc_llc_flow_qentry_del(&lgr->llc_flow_lcl);
  1298. goto out;
  1299. }
  1300. if (lgr->role == SMC_CLNT)
  1301. smc_llc_process_cli_delete_link(lgr);
  1302. else
  1303. smc_llc_process_srv_delete_link(lgr);
  1304. out:
  1305. smc_llc_flow_stop(lgr, &lgr->llc_flow_lcl);
  1306. }
  1307. /* process a confirm_rkey request from peer, remote flow */
  1308. static void smc_llc_rmt_conf_rkey(struct smc_link_group *lgr)
  1309. {
  1310. struct smc_llc_msg_confirm_rkey *llc;
  1311. struct smc_llc_qentry *qentry;
  1312. struct smc_link *link;
  1313. int num_entries;
  1314. int rk_idx;
  1315. int i;
  1316. qentry = lgr->llc_flow_rmt.qentry;
  1317. llc = &qentry->msg.confirm_rkey;
  1318. link = qentry->link;
  1319. num_entries = llc->rtoken[0].num_rkeys;
  1320. /* first rkey entry is for receiving link */
  1321. rk_idx = smc_rtoken_add(link,
  1322. llc->rtoken[0].rmb_vaddr,
  1323. llc->rtoken[0].rmb_key);
  1324. if (rk_idx < 0)
  1325. goto out_err;
  1326. for (i = 1; i <= min_t(u8, num_entries, SMC_LLC_RKEYS_PER_MSG - 1); i++)
  1327. smc_rtoken_set2(lgr, rk_idx, llc->rtoken[i].link_id,
  1328. llc->rtoken[i].rmb_vaddr,
  1329. llc->rtoken[i].rmb_key);
  1330. /* max links is 3 so there is no need to support conf_rkey_cont msgs */
  1331. goto out;
  1332. out_err:
  1333. llc->hd.flags |= SMC_LLC_FLAG_RKEY_NEG;
  1334. llc->hd.flags |= SMC_LLC_FLAG_RKEY_RETRY;
  1335. out:
  1336. llc->hd.flags |= SMC_LLC_FLAG_RESP;
  1337. smc_llc_send_message(link, &qentry->msg);
  1338. smc_llc_flow_qentry_del(&lgr->llc_flow_rmt);
  1339. }
  1340. /* process a delete_rkey request from peer, remote flow */
  1341. static void smc_llc_rmt_delete_rkey(struct smc_link_group *lgr)
  1342. {
  1343. struct smc_llc_msg_delete_rkey *llc;
  1344. struct smc_llc_qentry *qentry;
  1345. struct smc_link *link;
  1346. u8 err_mask = 0;
  1347. int i, max;
  1348. qentry = lgr->llc_flow_rmt.qentry;
  1349. llc = &qentry->msg.delete_rkey;
  1350. link = qentry->link;
  1351. max = min_t(u8, llc->num_rkeys, SMC_LLC_DEL_RKEY_MAX);
  1352. for (i = 0; i < max; i++) {
  1353. if (smc_rtoken_delete(link, llc->rkey[i]))
  1354. err_mask |= 1 << (SMC_LLC_DEL_RKEY_MAX - 1 - i);
  1355. }
  1356. if (err_mask) {
  1357. llc->hd.flags |= SMC_LLC_FLAG_RKEY_NEG;
  1358. llc->err_mask = err_mask;
  1359. }
  1360. llc->hd.flags |= SMC_LLC_FLAG_RESP;
  1361. smc_llc_send_message(link, &qentry->msg);
  1362. smc_llc_flow_qentry_del(&lgr->llc_flow_rmt);
  1363. }
  1364. static void smc_llc_protocol_violation(struct smc_link_group *lgr, u8 type)
  1365. {
  1366. pr_warn_ratelimited("smc: SMC-R lg %*phN LLC protocol violation: "
  1367. "llc_type %d\n", SMC_LGR_ID_SIZE, &lgr->id, type);
  1368. smc_llc_set_termination_rsn(lgr, SMC_LLC_DEL_PROT_VIOL);
  1369. smc_lgr_terminate_sched(lgr);
  1370. }
  1371. /* flush the llc event queue */
  1372. static void smc_llc_event_flush(struct smc_link_group *lgr)
  1373. {
  1374. struct smc_llc_qentry *qentry, *q;
  1375. spin_lock_bh(&lgr->llc_event_q_lock);
  1376. list_for_each_entry_safe(qentry, q, &lgr->llc_event_q, list) {
  1377. list_del_init(&qentry->list);
  1378. kfree(qentry);
  1379. }
  1380. spin_unlock_bh(&lgr->llc_event_q_lock);
  1381. }
  1382. static void smc_llc_event_handler(struct smc_llc_qentry *qentry)
  1383. {
  1384. union smc_llc_msg *llc = &qentry->msg;
  1385. struct smc_link *link = qentry->link;
  1386. struct smc_link_group *lgr = link->lgr;
  1387. if (!smc_link_usable(link))
  1388. goto out;
  1389. switch (llc->raw.hdr.common.type) {
  1390. case SMC_LLC_TEST_LINK:
  1391. llc->test_link.hd.flags |= SMC_LLC_FLAG_RESP;
  1392. smc_llc_send_message(link, llc);
  1393. break;
  1394. case SMC_LLC_ADD_LINK:
  1395. if (list_empty(&lgr->list))
  1396. goto out; /* lgr is terminating */
  1397. if (lgr->role == SMC_CLNT) {
  1398. if (smc_llc_is_local_add_link(llc)) {
  1399. if (lgr->llc_flow_lcl.type ==
  1400. SMC_LLC_FLOW_ADD_LINK)
  1401. break; /* add_link in progress */
  1402. if (smc_llc_flow_start(&lgr->llc_flow_lcl,
  1403. qentry)) {
  1404. schedule_work(&lgr->llc_add_link_work);
  1405. }
  1406. return;
  1407. }
  1408. if (lgr->llc_flow_lcl.type == SMC_LLC_FLOW_ADD_LINK &&
  1409. !lgr->llc_flow_lcl.qentry) {
  1410. /* a flow is waiting for this message */
  1411. smc_llc_flow_qentry_set(&lgr->llc_flow_lcl,
  1412. qentry);
  1413. wake_up(&lgr->llc_msg_waiter);
  1414. } else if (smc_llc_flow_start(&lgr->llc_flow_lcl,
  1415. qentry)) {
  1416. schedule_work(&lgr->llc_add_link_work);
  1417. }
  1418. } else if (smc_llc_flow_start(&lgr->llc_flow_lcl, qentry)) {
  1419. /* as smc server, handle client suggestion */
  1420. schedule_work(&lgr->llc_add_link_work);
  1421. }
  1422. return;
  1423. case SMC_LLC_CONFIRM_LINK:
  1424. case SMC_LLC_ADD_LINK_CONT:
  1425. if (lgr->llc_flow_lcl.type != SMC_LLC_FLOW_NONE) {
  1426. /* a flow is waiting for this message */
  1427. smc_llc_flow_qentry_set(&lgr->llc_flow_lcl, qentry);
  1428. wake_up(&lgr->llc_msg_waiter);
  1429. return;
  1430. }
  1431. break;
  1432. case SMC_LLC_DELETE_LINK:
  1433. if (lgr->llc_flow_lcl.type == SMC_LLC_FLOW_ADD_LINK &&
  1434. !lgr->llc_flow_lcl.qentry) {
  1435. /* DEL LINK REQ during ADD LINK SEQ */
  1436. smc_llc_flow_qentry_set(&lgr->llc_flow_lcl, qentry);
  1437. wake_up(&lgr->llc_msg_waiter);
  1438. } else if (smc_llc_flow_start(&lgr->llc_flow_lcl, qentry)) {
  1439. schedule_work(&lgr->llc_del_link_work);
  1440. }
  1441. return;
  1442. case SMC_LLC_CONFIRM_RKEY:
  1443. /* new request from remote, assign to remote flow */
  1444. if (smc_llc_flow_start(&lgr->llc_flow_rmt, qentry)) {
  1445. /* process here, does not wait for more llc msgs */
  1446. smc_llc_rmt_conf_rkey(lgr);
  1447. smc_llc_flow_stop(lgr, &lgr->llc_flow_rmt);
  1448. }
  1449. return;
  1450. case SMC_LLC_CONFIRM_RKEY_CONT:
  1451. /* not used because max links is 3, and 3 rkeys fit into
  1452. * one CONFIRM_RKEY message
  1453. */
  1454. break;
  1455. case SMC_LLC_DELETE_RKEY:
  1456. /* new request from remote, assign to remote flow */
  1457. if (smc_llc_flow_start(&lgr->llc_flow_rmt, qentry)) {
  1458. /* process here, does not wait for more llc msgs */
  1459. smc_llc_rmt_delete_rkey(lgr);
  1460. smc_llc_flow_stop(lgr, &lgr->llc_flow_rmt);
  1461. }
  1462. return;
  1463. default:
  1464. smc_llc_protocol_violation(lgr, llc->raw.hdr.common.type);
  1465. break;
  1466. }
  1467. out:
  1468. kfree(qentry);
  1469. }
  1470. /* worker to process llc messages on the event queue */
  1471. static void smc_llc_event_work(struct work_struct *work)
  1472. {
  1473. struct smc_link_group *lgr = container_of(work, struct smc_link_group,
  1474. llc_event_work);
  1475. struct smc_llc_qentry *qentry;
  1476. if (!lgr->llc_flow_lcl.type && lgr->delayed_event) {
  1477. qentry = lgr->delayed_event;
  1478. lgr->delayed_event = NULL;
  1479. if (smc_link_usable(qentry->link))
  1480. smc_llc_event_handler(qentry);
  1481. else
  1482. kfree(qentry);
  1483. }
  1484. again:
  1485. spin_lock_bh(&lgr->llc_event_q_lock);
  1486. if (!list_empty(&lgr->llc_event_q)) {
  1487. qentry = list_first_entry(&lgr->llc_event_q,
  1488. struct smc_llc_qentry, list);
  1489. list_del_init(&qentry->list);
  1490. spin_unlock_bh(&lgr->llc_event_q_lock);
  1491. smc_llc_event_handler(qentry);
  1492. goto again;
  1493. }
  1494. spin_unlock_bh(&lgr->llc_event_q_lock);
  1495. }
  1496. /* process llc responses in tasklet context */
  1497. static void smc_llc_rx_response(struct smc_link *link,
  1498. struct smc_llc_qentry *qentry)
  1499. {
  1500. enum smc_llc_flowtype flowtype = link->lgr->llc_flow_lcl.type;
  1501. struct smc_llc_flow *flow = &link->lgr->llc_flow_lcl;
  1502. u8 llc_type = qentry->msg.raw.hdr.common.type;
  1503. switch (llc_type) {
  1504. case SMC_LLC_TEST_LINK:
  1505. if (smc_link_active(link))
  1506. complete(&link->llc_testlink_resp);
  1507. break;
  1508. case SMC_LLC_ADD_LINK:
  1509. case SMC_LLC_ADD_LINK_CONT:
  1510. case SMC_LLC_CONFIRM_LINK:
  1511. if (flowtype != SMC_LLC_FLOW_ADD_LINK || flow->qentry)
  1512. break; /* drop out-of-flow response */
  1513. goto assign;
  1514. case SMC_LLC_DELETE_LINK:
  1515. if (flowtype != SMC_LLC_FLOW_DEL_LINK || flow->qentry)
  1516. break; /* drop out-of-flow response */
  1517. goto assign;
  1518. case SMC_LLC_CONFIRM_RKEY:
  1519. case SMC_LLC_DELETE_RKEY:
  1520. if (flowtype != SMC_LLC_FLOW_RKEY || flow->qentry)
  1521. break; /* drop out-of-flow response */
  1522. goto assign;
  1523. case SMC_LLC_CONFIRM_RKEY_CONT:
  1524. /* not used because max links is 3 */
  1525. break;
  1526. default:
  1527. smc_llc_protocol_violation(link->lgr, llc_type);
  1528. break;
  1529. }
  1530. kfree(qentry);
  1531. return;
  1532. assign:
  1533. /* assign responses to the local flow, we requested them */
  1534. smc_llc_flow_qentry_set(&link->lgr->llc_flow_lcl, qentry);
  1535. wake_up(&link->lgr->llc_msg_waiter);
  1536. }
  1537. static void smc_llc_enqueue(struct smc_link *link, union smc_llc_msg *llc)
  1538. {
  1539. struct smc_link_group *lgr = link->lgr;
  1540. struct smc_llc_qentry *qentry;
  1541. unsigned long flags;
  1542. qentry = kmalloc(sizeof(*qentry), GFP_ATOMIC);
  1543. if (!qentry)
  1544. return;
  1545. qentry->link = link;
  1546. INIT_LIST_HEAD(&qentry->list);
  1547. memcpy(&qentry->msg, llc, sizeof(union smc_llc_msg));
  1548. /* process responses immediately */
  1549. if (llc->raw.hdr.flags & SMC_LLC_FLAG_RESP) {
  1550. smc_llc_rx_response(link, qentry);
  1551. return;
  1552. }
  1553. /* add requests to event queue */
  1554. spin_lock_irqsave(&lgr->llc_event_q_lock, flags);
  1555. list_add_tail(&qentry->list, &lgr->llc_event_q);
  1556. spin_unlock_irqrestore(&lgr->llc_event_q_lock, flags);
  1557. queue_work(system_highpri_wq, &lgr->llc_event_work);
  1558. }
  1559. /* copy received msg and add it to the event queue */
  1560. static void smc_llc_rx_handler(struct ib_wc *wc, void *buf)
  1561. {
  1562. struct smc_link *link = (struct smc_link *)wc->qp->qp_context;
  1563. union smc_llc_msg *llc = buf;
  1564. if (wc->byte_len < sizeof(*llc))
  1565. return; /* short message */
  1566. if (llc->raw.hdr.length != sizeof(*llc))
  1567. return; /* invalid message */
  1568. smc_llc_enqueue(link, llc);
  1569. }
  1570. /***************************** worker, utils *********************************/
  1571. static void smc_llc_testlink_work(struct work_struct *work)
  1572. {
  1573. struct smc_link *link = container_of(to_delayed_work(work),
  1574. struct smc_link, llc_testlink_wrk);
  1575. unsigned long next_interval;
  1576. unsigned long expire_time;
  1577. u8 user_data[16] = { 0 };
  1578. int rc;
  1579. if (!smc_link_active(link))
  1580. return; /* don't reschedule worker */
  1581. expire_time = link->wr_rx_tstamp + link->llc_testlink_time;
  1582. if (time_is_after_jiffies(expire_time)) {
  1583. next_interval = expire_time - jiffies;
  1584. goto out;
  1585. }
  1586. reinit_completion(&link->llc_testlink_resp);
  1587. smc_llc_send_test_link(link, user_data);
  1588. /* receive TEST LINK response over RoCE fabric */
  1589. rc = wait_for_completion_interruptible_timeout(&link->llc_testlink_resp,
  1590. SMC_LLC_WAIT_TIME);
  1591. if (!smc_link_active(link))
  1592. return; /* link state changed */
  1593. if (rc <= 0) {
  1594. smcr_link_down_cond_sched(link);
  1595. return;
  1596. }
  1597. next_interval = link->llc_testlink_time;
  1598. out:
  1599. schedule_delayed_work(&link->llc_testlink_wrk, next_interval);
  1600. }
  1601. void smc_llc_lgr_init(struct smc_link_group *lgr, struct smc_sock *smc)
  1602. {
  1603. struct net *net = sock_net(smc->clcsock->sk);
  1604. INIT_WORK(&lgr->llc_event_work, smc_llc_event_work);
  1605. INIT_WORK(&lgr->llc_add_link_work, smc_llc_add_link_work);
  1606. INIT_WORK(&lgr->llc_del_link_work, smc_llc_delete_link_work);
  1607. INIT_LIST_HEAD(&lgr->llc_event_q);
  1608. spin_lock_init(&lgr->llc_event_q_lock);
  1609. spin_lock_init(&lgr->llc_flow_lock);
  1610. init_waitqueue_head(&lgr->llc_flow_waiter);
  1611. init_waitqueue_head(&lgr->llc_msg_waiter);
  1612. mutex_init(&lgr->llc_conf_mutex);
  1613. lgr->llc_testlink_time = net->ipv4.sysctl_tcp_keepalive_time;
  1614. }
  1615. /* called after lgr was removed from lgr_list */
  1616. void smc_llc_lgr_clear(struct smc_link_group *lgr)
  1617. {
  1618. smc_llc_event_flush(lgr);
  1619. wake_up_all(&lgr->llc_flow_waiter);
  1620. wake_up_all(&lgr->llc_msg_waiter);
  1621. cancel_work_sync(&lgr->llc_event_work);
  1622. cancel_work_sync(&lgr->llc_add_link_work);
  1623. cancel_work_sync(&lgr->llc_del_link_work);
  1624. if (lgr->delayed_event) {
  1625. kfree(lgr->delayed_event);
  1626. lgr->delayed_event = NULL;
  1627. }
  1628. }
  1629. int smc_llc_link_init(struct smc_link *link)
  1630. {
  1631. init_completion(&link->llc_testlink_resp);
  1632. INIT_DELAYED_WORK(&link->llc_testlink_wrk, smc_llc_testlink_work);
  1633. return 0;
  1634. }
  1635. void smc_llc_link_active(struct smc_link *link)
  1636. {
  1637. pr_warn_ratelimited("smc: SMC-R lg %*phN link added: id %*phN, "
  1638. "peerid %*phN, ibdev %s, ibport %d\n",
  1639. SMC_LGR_ID_SIZE, &link->lgr->id,
  1640. SMC_LGR_ID_SIZE, &link->link_uid,
  1641. SMC_LGR_ID_SIZE, &link->peer_link_uid,
  1642. link->smcibdev->ibdev->name, link->ibport);
  1643. link->state = SMC_LNK_ACTIVE;
  1644. if (link->lgr->llc_testlink_time) {
  1645. link->llc_testlink_time = link->lgr->llc_testlink_time;
  1646. schedule_delayed_work(&link->llc_testlink_wrk,
  1647. link->llc_testlink_time);
  1648. }
  1649. }
  1650. /* called in worker context */
  1651. void smc_llc_link_clear(struct smc_link *link, bool log)
  1652. {
  1653. if (log)
  1654. pr_warn_ratelimited("smc: SMC-R lg %*phN link removed: id %*phN"
  1655. ", peerid %*phN, ibdev %s, ibport %d\n",
  1656. SMC_LGR_ID_SIZE, &link->lgr->id,
  1657. SMC_LGR_ID_SIZE, &link->link_uid,
  1658. SMC_LGR_ID_SIZE, &link->peer_link_uid,
  1659. link->smcibdev->ibdev->name, link->ibport);
  1660. complete(&link->llc_testlink_resp);
  1661. cancel_delayed_work_sync(&link->llc_testlink_wrk);
  1662. }
  1663. /* register a new rtoken at the remote peer (for all links) */
  1664. int smc_llc_do_confirm_rkey(struct smc_link *send_link,
  1665. struct smc_buf_desc *rmb_desc)
  1666. {
  1667. struct smc_link_group *lgr = send_link->lgr;
  1668. struct smc_llc_qentry *qentry = NULL;
  1669. int rc = 0;
  1670. rc = smc_llc_send_confirm_rkey(send_link, rmb_desc);
  1671. if (rc)
  1672. goto out;
  1673. /* receive CONFIRM RKEY response from server over RoCE fabric */
  1674. qentry = smc_llc_wait(lgr, send_link, SMC_LLC_WAIT_TIME,
  1675. SMC_LLC_CONFIRM_RKEY);
  1676. if (!qentry || (qentry->msg.raw.hdr.flags & SMC_LLC_FLAG_RKEY_NEG))
  1677. rc = -EFAULT;
  1678. out:
  1679. if (qentry)
  1680. smc_llc_flow_qentry_del(&lgr->llc_flow_lcl);
  1681. return rc;
  1682. }
  1683. /* unregister an rtoken at the remote peer */
  1684. int smc_llc_do_delete_rkey(struct smc_link_group *lgr,
  1685. struct smc_buf_desc *rmb_desc)
  1686. {
  1687. struct smc_llc_qentry *qentry = NULL;
  1688. struct smc_link *send_link;
  1689. int rc = 0;
  1690. send_link = smc_llc_usable_link(lgr);
  1691. if (!send_link)
  1692. return -ENOLINK;
  1693. /* protected by llc_flow control */
  1694. rc = smc_llc_send_delete_rkey(send_link, rmb_desc);
  1695. if (rc)
  1696. goto out;
  1697. /* receive DELETE RKEY response from server over RoCE fabric */
  1698. qentry = smc_llc_wait(lgr, send_link, SMC_LLC_WAIT_TIME,
  1699. SMC_LLC_DELETE_RKEY);
  1700. if (!qentry || (qentry->msg.raw.hdr.flags & SMC_LLC_FLAG_RKEY_NEG))
  1701. rc = -EFAULT;
  1702. out:
  1703. if (qentry)
  1704. smc_llc_flow_qentry_del(&lgr->llc_flow_lcl);
  1705. return rc;
  1706. }
  1707. void smc_llc_link_set_uid(struct smc_link *link)
  1708. {
  1709. __be32 link_uid;
  1710. link_uid = htonl(*((u32 *)link->lgr->id) + link->link_id);
  1711. memcpy(link->link_uid, &link_uid, SMC_LGR_ID_SIZE);
  1712. }
  1713. /* save peers link user id, used for debug purposes */
  1714. void smc_llc_save_peer_uid(struct smc_llc_qentry *qentry)
  1715. {
  1716. memcpy(qentry->link->peer_link_uid, qentry->msg.confirm_link.link_uid,
  1717. SMC_LGR_ID_SIZE);
  1718. }
  1719. /* evaluate confirm link request or response */
  1720. int smc_llc_eval_conf_link(struct smc_llc_qentry *qentry,
  1721. enum smc_llc_reqresp type)
  1722. {
  1723. if (type == SMC_LLC_REQ) { /* SMC server assigns link_id */
  1724. qentry->link->link_id = qentry->msg.confirm_link.link_num;
  1725. smc_llc_link_set_uid(qentry->link);
  1726. }
  1727. if (!(qentry->msg.raw.hdr.flags & SMC_LLC_FLAG_NO_RMBE_EYEC))
  1728. return -ENOTSUPP;
  1729. return 0;
  1730. }
  1731. /***************************** init, exit, misc ******************************/
  1732. static struct smc_wr_rx_handler smc_llc_rx_handlers[] = {
  1733. {
  1734. .handler = smc_llc_rx_handler,
  1735. .type = SMC_LLC_CONFIRM_LINK
  1736. },
  1737. {
  1738. .handler = smc_llc_rx_handler,
  1739. .type = SMC_LLC_TEST_LINK
  1740. },
  1741. {
  1742. .handler = smc_llc_rx_handler,
  1743. .type = SMC_LLC_ADD_LINK
  1744. },
  1745. {
  1746. .handler = smc_llc_rx_handler,
  1747. .type = SMC_LLC_ADD_LINK_CONT
  1748. },
  1749. {
  1750. .handler = smc_llc_rx_handler,
  1751. .type = SMC_LLC_DELETE_LINK
  1752. },
  1753. {
  1754. .handler = smc_llc_rx_handler,
  1755. .type = SMC_LLC_CONFIRM_RKEY
  1756. },
  1757. {
  1758. .handler = smc_llc_rx_handler,
  1759. .type = SMC_LLC_CONFIRM_RKEY_CONT
  1760. },
  1761. {
  1762. .handler = smc_llc_rx_handler,
  1763. .type = SMC_LLC_DELETE_RKEY
  1764. },
  1765. {
  1766. .handler = NULL,
  1767. }
  1768. };
  1769. int __init smc_llc_init(void)
  1770. {
  1771. struct smc_wr_rx_handler *handler;
  1772. int rc = 0;
  1773. for (handler = smc_llc_rx_handlers; handler->handler; handler++) {
  1774. INIT_HLIST_NODE(&handler->list);
  1775. rc = smc_wr_rx_register_handler(handler);
  1776. if (rc)
  1777. break;
  1778. }
  1779. return rc;
  1780. }