cm.c 93 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771772773774775776777778779780781782783784785786787788789790791792793794795796797798799800801802803804805806807808809810811812813814815816817818819820821822823824825826827828829830831832833834835836837838839840841842843844845846847848849850851852853854855856857858859860861862863864865866867868869870871872873874875876877878879880881882883884885886887888889890891892893894895896897898899900901902903904905906907908909910911912913914915916917918919920921922923924925926927928929930931932933934935936937938939940941942943944945946947948949950951952953954955956957958959960961962963964965966967968969970971972973974975976977978979980981982983984985986987988989990991992993994995996997998999100010011002100310041005100610071008100910101011101210131014101510161017101810191020102110221023102410251026102710281029103010311032103310341035103610371038103910401041104210431044104510461047104810491050105110521053105410551056105710581059106010611062106310641065106610671068106910701071107210731074107510761077107810791080108110821083108410851086108710881089109010911092109310941095109610971098109911001101110211031104110511061107110811091110111111121113111411151116111711181119112011211122112311241125112611271128112911301131113211331134113511361137113811391140114111421143114411451146114711481149115011511152115311541155115611571158115911601161116211631164116511661167116811691170117111721173117411751176117711781179118011811182118311841185118611871188118911901191119211931194119511961197119811991200120112021203120412051206120712081209121012111212121312141215121612171218121912201221122212231224122512261227122812291230123112321233123412351236123712381239124012411242124312441245124612471248124912501251125212531254125512561257125812591260126112621263126412651266126712681269127012711272127312741275127612771278127912801281128212831284128512861287128812891290129112921293129412951296129712981299130013011302130313041305130613071308130913101311131213131314131513161317131813191320132113221323132413251326132713281329133013311332133313341335133613371338133913401341134213431344134513461347134813491350135113521353135413551356135713581359136013611362136313641365136613671368136913701371137213731374137513761377137813791380138113821383138413851386138713881389139013911392139313941395139613971398139914001401140214031404140514061407140814091410141114121413141414151416141714181419142014211422142314241425142614271428142914301431143214331434143514361437143814391440144114421443144414451446144714481449145014511452145314541455145614571458145914601461146214631464146514661467146814691470147114721473147414751476147714781479148014811482148314841485148614871488148914901491149214931494149514961497149814991500150115021503150415051506150715081509151015111512151315141515151615171518151915201521152215231524152515261527152815291530153115321533153415351536153715381539154015411542154315441545154615471548154915501551155215531554155515561557155815591560156115621563156415651566156715681569157015711572157315741575157615771578157915801581158215831584158515861587158815891590159115921593159415951596159715981599160016011602160316041605160616071608160916101611161216131614161516161617161816191620162116221623162416251626162716281629163016311632163316341635163616371638163916401641164216431644164516461647164816491650165116521653165416551656165716581659166016611662166316641665166616671668166916701671167216731674167516761677167816791680168116821683168416851686168716881689169016911692169316941695169616971698169917001701170217031704170517061707170817091710171117121713171417151716171717181719172017211722172317241725172617271728172917301731173217331734173517361737173817391740174117421743174417451746174717481749175017511752175317541755175617571758175917601761176217631764176517661767176817691770177117721773177417751776177717781779178017811782178317841785178617871788178917901791179217931794179517961797179817991800180118021803180418051806180718081809181018111812181318141815181618171818181918201821182218231824182518261827182818291830183118321833183418351836183718381839184018411842184318441845184618471848184918501851185218531854185518561857185818591860186118621863186418651866186718681869187018711872187318741875187618771878187918801881188218831884188518861887188818891890189118921893189418951896189718981899190019011902190319041905190619071908190919101911191219131914191519161917191819191920192119221923192419251926192719281929193019311932193319341935193619371938193919401941194219431944194519461947194819491950195119521953195419551956195719581959196019611962196319641965196619671968196919701971197219731974197519761977197819791980198119821983198419851986198719881989199019911992199319941995199619971998199920002001200220032004200520062007200820092010201120122013201420152016201720182019202020212022202320242025202620272028202920302031203220332034203520362037203820392040204120422043204420452046204720482049205020512052205320542055205620572058205920602061206220632064206520662067206820692070207120722073207420752076207720782079208020812082208320842085208620872088208920902091209220932094209520962097209820992100210121022103210421052106210721082109211021112112211321142115211621172118211921202121212221232124212521262127212821292130213121322133213421352136213721382139214021412142214321442145214621472148214921502151215221532154215521562157215821592160216121622163216421652166216721682169217021712172217321742175217621772178217921802181218221832184218521862187218821892190219121922193219421952196219721982199220022012202220322042205220622072208220922102211221222132214221522162217221822192220222122222223222422252226222722282229223022312232223322342235223622372238223922402241224222432244224522462247224822492250225122522253225422552256225722582259226022612262226322642265226622672268226922702271227222732274227522762277227822792280228122822283228422852286228722882289229022912292229322942295229622972298229923002301230223032304230523062307230823092310231123122313231423152316231723182319232023212322232323242325232623272328232923302331233223332334233523362337233823392340234123422343234423452346234723482349235023512352235323542355235623572358235923602361236223632364236523662367236823692370237123722373237423752376237723782379238023812382238323842385238623872388238923902391239223932394239523962397239823992400240124022403240424052406240724082409241024112412241324142415241624172418241924202421242224232424242524262427242824292430243124322433243424352436243724382439244024412442244324442445244624472448244924502451245224532454245524562457245824592460246124622463246424652466246724682469247024712472247324742475247624772478247924802481248224832484248524862487248824892490249124922493249424952496249724982499250025012502250325042505250625072508250925102511251225132514251525162517251825192520252125222523252425252526252725282529253025312532253325342535253625372538253925402541254225432544254525462547254825492550255125522553255425552556255725582559256025612562256325642565256625672568256925702571257225732574257525762577257825792580258125822583258425852586258725882589259025912592259325942595259625972598259926002601260226032604260526062607260826092610261126122613261426152616261726182619262026212622262326242625262626272628262926302631263226332634263526362637263826392640264126422643264426452646264726482649265026512652265326542655265626572658265926602661266226632664266526662667266826692670267126722673267426752676267726782679268026812682268326842685268626872688268926902691269226932694269526962697269826992700270127022703270427052706270727082709271027112712271327142715271627172718271927202721272227232724272527262727272827292730273127322733273427352736273727382739274027412742274327442745274627472748274927502751275227532754275527562757275827592760276127622763276427652766276727682769277027712772277327742775277627772778277927802781278227832784278527862787278827892790279127922793279427952796279727982799280028012802280328042805280628072808280928102811281228132814281528162817281828192820282128222823282428252826282728282829283028312832283328342835283628372838283928402841284228432844284528462847284828492850285128522853285428552856285728582859286028612862286328642865286628672868286928702871287228732874287528762877287828792880288128822883288428852886288728882889289028912892289328942895289628972898289929002901290229032904290529062907290829092910291129122913291429152916291729182919292029212922292329242925292629272928292929302931293229332934293529362937293829392940294129422943294429452946294729482949295029512952295329542955295629572958295929602961296229632964296529662967296829692970297129722973297429752976297729782979298029812982298329842985298629872988298929902991299229932994299529962997299829993000300130023003300430053006300730083009301030113012301330143015301630173018301930203021302230233024302530263027302830293030303130323033303430353036303730383039304030413042304330443045304630473048304930503051305230533054305530563057305830593060306130623063306430653066306730683069307030713072307330743075307630773078307930803081308230833084308530863087308830893090309130923093309430953096309730983099310031013102310331043105310631073108310931103111311231133114311531163117311831193120312131223123312431253126312731283129313031313132313331343135313631373138313931403141314231433144314531463147314831493150315131523153315431553156315731583159316031613162316331643165316631673168316931703171317231733174317531763177317831793180318131823183318431853186318731883189319031913192319331943195319631973198319932003201320232033204320532063207320832093210321132123213321432153216321732183219322032213222322332243225322632273228322932303231323232333234323532363237323832393240324132423243324432453246324732483249325032513252325332543255325632573258325932603261326232633264326532663267326832693270327132723273327432753276327732783279328032813282328332843285328632873288328932903291329232933294329532963297329832993300330133023303330433053306330733083309331033113312331333143315331633173318331933203321332233233324
  1. /*
  2. * Copyright (c) 2004, 2005 Intel Corporation. All rights reserved.
  3. * Copyright (c) 2004 Topspin Corporation. All rights reserved.
  4. * Copyright (c) 2004, 2005 Voltaire Corporation. All rights reserved.
  5. * Copyright (c) 2005 Sun Microsystems, Inc. All rights reserved.
  6. *
  7. * This software is available to you under a choice of one of two
  8. * licenses. You may choose to be licensed under the terms of the GNU
  9. * General Public License (GPL) Version 2, available from the file
  10. * COPYING in the main directory of this source tree, or the
  11. * OpenIB.org BSD license below:
  12. *
  13. * Redistribution and use in source and binary forms, with or
  14. * without modification, are permitted provided that the following
  15. * conditions are met:
  16. *
  17. * - Redistributions of source code must retain the above
  18. * copyright notice, this list of conditions and the following
  19. * disclaimer.
  20. *
  21. * - Redistributions in binary form must reproduce the above
  22. * copyright notice, this list of conditions and the following
  23. * disclaimer in the documentation and/or other materials
  24. * provided with the distribution.
  25. *
  26. * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
  27. * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
  28. * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
  29. * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
  30. * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
  31. * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
  32. * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
  33. * SOFTWARE.
  34. *
  35. * $Id: cm.c 2821 2005-07-08 17:07:28Z sean.hefty $
  36. */
  37. #include <linux/dma-mapping.h>
  38. #include <linux/err.h>
  39. #include <linux/idr.h>
  40. #include <linux/interrupt.h>
  41. #include <linux/pci.h>
  42. #include <linux/rbtree.h>
  43. #include <linux/spinlock.h>
  44. #include <linux/workqueue.h>
  45. #include <ib_cache.h>
  46. #include <ib_cm.h>
  47. #include "cm_msgs.h"
  48. MODULE_AUTHOR("Sean Hefty");
  49. MODULE_DESCRIPTION("InfiniBand CM");
  50. MODULE_LICENSE("Dual BSD/GPL");
  51. static void cm_add_one(struct ib_device *device);
  52. static void cm_remove_one(struct ib_device *device);
  53. static struct ib_client cm_client = {
  54. .name = "cm",
  55. .add = cm_add_one,
  56. .remove = cm_remove_one
  57. };
  58. static struct ib_cm {
  59. spinlock_t lock;
  60. struct list_head device_list;
  61. rwlock_t device_lock;
  62. struct rb_root listen_service_table;
  63. u64 listen_service_id;
  64. /* struct rb_root peer_service_table; todo: fix peer to peer */
  65. struct rb_root remote_qp_table;
  66. struct rb_root remote_id_table;
  67. struct rb_root remote_sidr_table;
  68. struct idr local_id_table;
  69. struct workqueue_struct *wq;
  70. } cm;
  71. struct cm_port {
  72. struct cm_device *cm_dev;
  73. struct ib_mad_agent *mad_agent;
  74. u8 port_num;
  75. };
  76. struct cm_device {
  77. struct list_head list;
  78. struct ib_device *device;
  79. u64 ca_guid;
  80. struct cm_port port[0];
  81. };
  82. struct cm_av {
  83. struct cm_port *port;
  84. union ib_gid dgid;
  85. struct ib_ah_attr ah_attr;
  86. u16 pkey_index;
  87. u8 packet_life_time;
  88. };
  89. struct cm_work {
  90. struct work_struct work;
  91. struct list_head list;
  92. struct cm_port *port;
  93. struct ib_mad_recv_wc *mad_recv_wc; /* Received MADs */
  94. u32 local_id; /* Established / timewait */
  95. u32 remote_id;
  96. struct ib_cm_event cm_event;
  97. struct ib_sa_path_rec path[0];
  98. };
  99. struct cm_timewait_info {
  100. struct cm_work work; /* Must be first. */
  101. struct rb_node remote_qp_node;
  102. struct rb_node remote_id_node;
  103. u64 remote_ca_guid;
  104. u32 remote_qpn;
  105. u8 inserted_remote_qp;
  106. u8 inserted_remote_id;
  107. };
  108. struct cm_id_private {
  109. struct ib_cm_id id;
  110. struct rb_node service_node;
  111. struct rb_node sidr_id_node;
  112. spinlock_t lock;
  113. wait_queue_head_t wait;
  114. atomic_t refcount;
  115. struct ib_mad_send_buf *msg;
  116. struct cm_timewait_info *timewait_info;
  117. /* todo: use alternate port on send failure */
  118. struct cm_av av;
  119. struct cm_av alt_av;
  120. void *private_data;
  121. u64 tid;
  122. u32 local_qpn;
  123. u32 remote_qpn;
  124. u32 sq_psn;
  125. u32 rq_psn;
  126. int timeout_ms;
  127. enum ib_mtu path_mtu;
  128. u8 private_data_len;
  129. u8 max_cm_retries;
  130. u8 peer_to_peer;
  131. u8 responder_resources;
  132. u8 initiator_depth;
  133. u8 local_ack_timeout;
  134. u8 retry_count;
  135. u8 rnr_retry_count;
  136. u8 service_timeout;
  137. struct list_head work_list;
  138. atomic_t work_count;
  139. };
  140. static void cm_work_handler(void *data);
  141. static inline void cm_deref_id(struct cm_id_private *cm_id_priv)
  142. {
  143. if (atomic_dec_and_test(&cm_id_priv->refcount))
  144. wake_up(&cm_id_priv->wait);
  145. }
  146. static int cm_alloc_msg(struct cm_id_private *cm_id_priv,
  147. struct ib_mad_send_buf **msg)
  148. {
  149. struct ib_mad_agent *mad_agent;
  150. struct ib_mad_send_buf *m;
  151. struct ib_ah *ah;
  152. mad_agent = cm_id_priv->av.port->mad_agent;
  153. ah = ib_create_ah(mad_agent->qp->pd, &cm_id_priv->av.ah_attr);
  154. if (IS_ERR(ah))
  155. return PTR_ERR(ah);
  156. m = ib_create_send_mad(mad_agent, 1, cm_id_priv->av.pkey_index,
  157. ah, 0, sizeof(struct ib_mad_hdr),
  158. sizeof(struct ib_mad)-sizeof(struct ib_mad_hdr),
  159. GFP_ATOMIC);
  160. if (IS_ERR(m)) {
  161. ib_destroy_ah(ah);
  162. return PTR_ERR(m);
  163. }
  164. /* Timeout set by caller if response is expected. */
  165. m->send_wr.wr.ud.retries = cm_id_priv->max_cm_retries;
  166. atomic_inc(&cm_id_priv->refcount);
  167. m->context[0] = cm_id_priv;
  168. *msg = m;
  169. return 0;
  170. }
  171. static int cm_alloc_response_msg(struct cm_port *port,
  172. struct ib_mad_recv_wc *mad_recv_wc,
  173. struct ib_mad_send_buf **msg)
  174. {
  175. struct ib_mad_send_buf *m;
  176. struct ib_ah *ah;
  177. ah = ib_create_ah_from_wc(port->mad_agent->qp->pd, mad_recv_wc->wc,
  178. mad_recv_wc->recv_buf.grh, port->port_num);
  179. if (IS_ERR(ah))
  180. return PTR_ERR(ah);
  181. m = ib_create_send_mad(port->mad_agent, 1, mad_recv_wc->wc->pkey_index,
  182. ah, 0, sizeof(struct ib_mad_hdr),
  183. sizeof(struct ib_mad)-sizeof(struct ib_mad_hdr),
  184. GFP_ATOMIC);
  185. if (IS_ERR(m)) {
  186. ib_destroy_ah(ah);
  187. return PTR_ERR(m);
  188. }
  189. *msg = m;
  190. return 0;
  191. }
  192. static void cm_free_msg(struct ib_mad_send_buf *msg)
  193. {
  194. ib_destroy_ah(msg->send_wr.wr.ud.ah);
  195. if (msg->context[0])
  196. cm_deref_id(msg->context[0]);
  197. ib_free_send_mad(msg);
  198. }
  199. static void * cm_copy_private_data(const void *private_data,
  200. u8 private_data_len)
  201. {
  202. void *data;
  203. if (!private_data || !private_data_len)
  204. return NULL;
  205. data = kmalloc(private_data_len, GFP_KERNEL);
  206. if (!data)
  207. return ERR_PTR(-ENOMEM);
  208. memcpy(data, private_data, private_data_len);
  209. return data;
  210. }
  211. static void cm_set_private_data(struct cm_id_private *cm_id_priv,
  212. void *private_data, u8 private_data_len)
  213. {
  214. if (cm_id_priv->private_data && cm_id_priv->private_data_len)
  215. kfree(cm_id_priv->private_data);
  216. cm_id_priv->private_data = private_data;
  217. cm_id_priv->private_data_len = private_data_len;
  218. }
  219. static void cm_set_ah_attr(struct ib_ah_attr *ah_attr, u8 port_num,
  220. u16 dlid, u8 sl, u16 src_path_bits)
  221. {
  222. memset(ah_attr, 0, sizeof ah_attr);
  223. ah_attr->dlid = be16_to_cpu(dlid);
  224. ah_attr->sl = sl;
  225. ah_attr->src_path_bits = src_path_bits;
  226. ah_attr->port_num = port_num;
  227. }
  228. static void cm_init_av_for_response(struct cm_port *port,
  229. struct ib_wc *wc, struct cm_av *av)
  230. {
  231. av->port = port;
  232. av->pkey_index = wc->pkey_index;
  233. cm_set_ah_attr(&av->ah_attr, port->port_num, cpu_to_be16(wc->slid),
  234. wc->sl, wc->dlid_path_bits);
  235. }
  236. static int cm_init_av_by_path(struct ib_sa_path_rec *path, struct cm_av *av)
  237. {
  238. struct cm_device *cm_dev;
  239. struct cm_port *port = NULL;
  240. unsigned long flags;
  241. int ret;
  242. u8 p;
  243. read_lock_irqsave(&cm.device_lock, flags);
  244. list_for_each_entry(cm_dev, &cm.device_list, list) {
  245. if (!ib_find_cached_gid(cm_dev->device, &path->sgid,
  246. &p, NULL)) {
  247. port = &cm_dev->port[p-1];
  248. break;
  249. }
  250. }
  251. read_unlock_irqrestore(&cm.device_lock, flags);
  252. if (!port)
  253. return -EINVAL;
  254. ret = ib_find_cached_pkey(cm_dev->device, port->port_num,
  255. be16_to_cpu(path->pkey), &av->pkey_index);
  256. if (ret)
  257. return ret;
  258. av->port = port;
  259. cm_set_ah_attr(&av->ah_attr, av->port->port_num, path->dlid,
  260. path->sl, path->slid & 0x7F);
  261. av->packet_life_time = path->packet_life_time;
  262. return 0;
  263. }
  264. static int cm_alloc_id(struct cm_id_private *cm_id_priv)
  265. {
  266. unsigned long flags;
  267. int ret;
  268. do {
  269. spin_lock_irqsave(&cm.lock, flags);
  270. ret = idr_get_new_above(&cm.local_id_table, cm_id_priv, 1,
  271. (int *) &cm_id_priv->id.local_id);
  272. spin_unlock_irqrestore(&cm.lock, flags);
  273. } while( (ret == -EAGAIN) && idr_pre_get(&cm.local_id_table, GFP_KERNEL) );
  274. return ret;
  275. }
  276. static void cm_free_id(u32 local_id)
  277. {
  278. unsigned long flags;
  279. spin_lock_irqsave(&cm.lock, flags);
  280. idr_remove(&cm.local_id_table, (int) local_id);
  281. spin_unlock_irqrestore(&cm.lock, flags);
  282. }
  283. static struct cm_id_private * cm_get_id(u32 local_id, u32 remote_id)
  284. {
  285. struct cm_id_private *cm_id_priv;
  286. cm_id_priv = idr_find(&cm.local_id_table, (int) local_id);
  287. if (cm_id_priv) {
  288. if (cm_id_priv->id.remote_id == remote_id)
  289. atomic_inc(&cm_id_priv->refcount);
  290. else
  291. cm_id_priv = NULL;
  292. }
  293. return cm_id_priv;
  294. }
  295. static struct cm_id_private * cm_acquire_id(u32 local_id, u32 remote_id)
  296. {
  297. struct cm_id_private *cm_id_priv;
  298. unsigned long flags;
  299. spin_lock_irqsave(&cm.lock, flags);
  300. cm_id_priv = cm_get_id(local_id, remote_id);
  301. spin_unlock_irqrestore(&cm.lock, flags);
  302. return cm_id_priv;
  303. }
  304. static struct cm_id_private * cm_insert_listen(struct cm_id_private *cm_id_priv)
  305. {
  306. struct rb_node **link = &cm.listen_service_table.rb_node;
  307. struct rb_node *parent = NULL;
  308. struct cm_id_private *cur_cm_id_priv;
  309. u64 service_id = cm_id_priv->id.service_id;
  310. u64 service_mask = cm_id_priv->id.service_mask;
  311. while (*link) {
  312. parent = *link;
  313. cur_cm_id_priv = rb_entry(parent, struct cm_id_private,
  314. service_node);
  315. if ((cur_cm_id_priv->id.service_mask & service_id) ==
  316. (service_mask & cur_cm_id_priv->id.service_id))
  317. return cm_id_priv;
  318. if (service_id < cur_cm_id_priv->id.service_id)
  319. link = &(*link)->rb_left;
  320. else
  321. link = &(*link)->rb_right;
  322. }
  323. rb_link_node(&cm_id_priv->service_node, parent, link);
  324. rb_insert_color(&cm_id_priv->service_node, &cm.listen_service_table);
  325. return NULL;
  326. }
  327. static struct cm_id_private * cm_find_listen(u64 service_id)
  328. {
  329. struct rb_node *node = cm.listen_service_table.rb_node;
  330. struct cm_id_private *cm_id_priv;
  331. while (node) {
  332. cm_id_priv = rb_entry(node, struct cm_id_private, service_node);
  333. if ((cm_id_priv->id.service_mask & service_id) ==
  334. (cm_id_priv->id.service_mask & cm_id_priv->id.service_id))
  335. return cm_id_priv;
  336. if (service_id < cm_id_priv->id.service_id)
  337. node = node->rb_left;
  338. else
  339. node = node->rb_right;
  340. }
  341. return NULL;
  342. }
  343. static struct cm_timewait_info * cm_insert_remote_id(struct cm_timewait_info
  344. *timewait_info)
  345. {
  346. struct rb_node **link = &cm.remote_id_table.rb_node;
  347. struct rb_node *parent = NULL;
  348. struct cm_timewait_info *cur_timewait_info;
  349. u64 remote_ca_guid = timewait_info->remote_ca_guid;
  350. u32 remote_id = timewait_info->work.remote_id;
  351. while (*link) {
  352. parent = *link;
  353. cur_timewait_info = rb_entry(parent, struct cm_timewait_info,
  354. remote_id_node);
  355. if (remote_id < cur_timewait_info->work.remote_id)
  356. link = &(*link)->rb_left;
  357. else if (remote_id > cur_timewait_info->work.remote_id)
  358. link = &(*link)->rb_right;
  359. else if (remote_ca_guid < cur_timewait_info->remote_ca_guid)
  360. link = &(*link)->rb_left;
  361. else if (remote_ca_guid > cur_timewait_info->remote_ca_guid)
  362. link = &(*link)->rb_right;
  363. else
  364. return cur_timewait_info;
  365. }
  366. timewait_info->inserted_remote_id = 1;
  367. rb_link_node(&timewait_info->remote_id_node, parent, link);
  368. rb_insert_color(&timewait_info->remote_id_node, &cm.remote_id_table);
  369. return NULL;
  370. }
  371. static struct cm_timewait_info * cm_find_remote_id(u64 remote_ca_guid,
  372. u32 remote_id)
  373. {
  374. struct rb_node *node = cm.remote_id_table.rb_node;
  375. struct cm_timewait_info *timewait_info;
  376. while (node) {
  377. timewait_info = rb_entry(node, struct cm_timewait_info,
  378. remote_id_node);
  379. if (remote_id < timewait_info->work.remote_id)
  380. node = node->rb_left;
  381. else if (remote_id > timewait_info->work.remote_id)
  382. node = node->rb_right;
  383. else if (remote_ca_guid < timewait_info->remote_ca_guid)
  384. node = node->rb_left;
  385. else if (remote_ca_guid > timewait_info->remote_ca_guid)
  386. node = node->rb_right;
  387. else
  388. return timewait_info;
  389. }
  390. return NULL;
  391. }
  392. static struct cm_timewait_info * cm_insert_remote_qpn(struct cm_timewait_info
  393. *timewait_info)
  394. {
  395. struct rb_node **link = &cm.remote_qp_table.rb_node;
  396. struct rb_node *parent = NULL;
  397. struct cm_timewait_info *cur_timewait_info;
  398. u64 remote_ca_guid = timewait_info->remote_ca_guid;
  399. u32 remote_qpn = timewait_info->remote_qpn;
  400. while (*link) {
  401. parent = *link;
  402. cur_timewait_info = rb_entry(parent, struct cm_timewait_info,
  403. remote_qp_node);
  404. if (remote_qpn < cur_timewait_info->remote_qpn)
  405. link = &(*link)->rb_left;
  406. else if (remote_qpn > cur_timewait_info->remote_qpn)
  407. link = &(*link)->rb_right;
  408. else if (remote_ca_guid < cur_timewait_info->remote_ca_guid)
  409. link = &(*link)->rb_left;
  410. else if (remote_ca_guid > cur_timewait_info->remote_ca_guid)
  411. link = &(*link)->rb_right;
  412. else
  413. return cur_timewait_info;
  414. }
  415. timewait_info->inserted_remote_qp = 1;
  416. rb_link_node(&timewait_info->remote_qp_node, parent, link);
  417. rb_insert_color(&timewait_info->remote_qp_node, &cm.remote_qp_table);
  418. return NULL;
  419. }
  420. static struct cm_id_private * cm_insert_remote_sidr(struct cm_id_private
  421. *cm_id_priv)
  422. {
  423. struct rb_node **link = &cm.remote_sidr_table.rb_node;
  424. struct rb_node *parent = NULL;
  425. struct cm_id_private *cur_cm_id_priv;
  426. union ib_gid *port_gid = &cm_id_priv->av.dgid;
  427. u32 remote_id = cm_id_priv->id.remote_id;
  428. while (*link) {
  429. parent = *link;
  430. cur_cm_id_priv = rb_entry(parent, struct cm_id_private,
  431. sidr_id_node);
  432. if (remote_id < cur_cm_id_priv->id.remote_id)
  433. link = &(*link)->rb_left;
  434. else if (remote_id > cur_cm_id_priv->id.remote_id)
  435. link = &(*link)->rb_right;
  436. else {
  437. int cmp;
  438. cmp = memcmp(port_gid, &cur_cm_id_priv->av.dgid,
  439. sizeof *port_gid);
  440. if (cmp < 0)
  441. link = &(*link)->rb_left;
  442. else if (cmp > 0)
  443. link = &(*link)->rb_right;
  444. else
  445. return cur_cm_id_priv;
  446. }
  447. }
  448. rb_link_node(&cm_id_priv->sidr_id_node, parent, link);
  449. rb_insert_color(&cm_id_priv->sidr_id_node, &cm.remote_sidr_table);
  450. return NULL;
  451. }
  452. static void cm_reject_sidr_req(struct cm_id_private *cm_id_priv,
  453. enum ib_cm_sidr_status status)
  454. {
  455. struct ib_cm_sidr_rep_param param;
  456. memset(&param, 0, sizeof param);
  457. param.status = status;
  458. ib_send_cm_sidr_rep(&cm_id_priv->id, &param);
  459. }
  460. struct ib_cm_id *ib_create_cm_id(ib_cm_handler cm_handler,
  461. void *context)
  462. {
  463. struct cm_id_private *cm_id_priv;
  464. int ret;
  465. cm_id_priv = kmalloc(sizeof *cm_id_priv, GFP_KERNEL);
  466. if (!cm_id_priv)
  467. return ERR_PTR(-ENOMEM);
  468. memset(cm_id_priv, 0, sizeof *cm_id_priv);
  469. cm_id_priv->id.state = IB_CM_IDLE;
  470. cm_id_priv->id.cm_handler = cm_handler;
  471. cm_id_priv->id.context = context;
  472. ret = cm_alloc_id(cm_id_priv);
  473. if (ret)
  474. goto error;
  475. spin_lock_init(&cm_id_priv->lock);
  476. init_waitqueue_head(&cm_id_priv->wait);
  477. INIT_LIST_HEAD(&cm_id_priv->work_list);
  478. atomic_set(&cm_id_priv->work_count, -1);
  479. atomic_set(&cm_id_priv->refcount, 1);
  480. return &cm_id_priv->id;
  481. error:
  482. kfree(cm_id_priv);
  483. return ERR_PTR(-ENOMEM);
  484. }
  485. EXPORT_SYMBOL(ib_create_cm_id);
  486. static struct cm_work * cm_dequeue_work(struct cm_id_private *cm_id_priv)
  487. {
  488. struct cm_work *work;
  489. if (list_empty(&cm_id_priv->work_list))
  490. return NULL;
  491. work = list_entry(cm_id_priv->work_list.next, struct cm_work, list);
  492. list_del(&work->list);
  493. return work;
  494. }
  495. static void cm_free_work(struct cm_work *work)
  496. {
  497. if (work->mad_recv_wc)
  498. ib_free_recv_mad(work->mad_recv_wc);
  499. kfree(work);
  500. }
  501. static inline int cm_convert_to_ms(int iba_time)
  502. {
  503. /* approximate conversion to ms from 4.096us x 2^iba_time */
  504. return 1 << max(iba_time - 8, 0);
  505. }
  506. static void cm_cleanup_timewait(struct cm_timewait_info *timewait_info)
  507. {
  508. unsigned long flags;
  509. if (!timewait_info->inserted_remote_id &&
  510. !timewait_info->inserted_remote_qp)
  511. return;
  512. spin_lock_irqsave(&cm.lock, flags);
  513. if (timewait_info->inserted_remote_id) {
  514. rb_erase(&timewait_info->remote_id_node, &cm.remote_id_table);
  515. timewait_info->inserted_remote_id = 0;
  516. }
  517. if (timewait_info->inserted_remote_qp) {
  518. rb_erase(&timewait_info->remote_qp_node, &cm.remote_qp_table);
  519. timewait_info->inserted_remote_qp = 0;
  520. }
  521. spin_unlock_irqrestore(&cm.lock, flags);
  522. }
  523. static struct cm_timewait_info * cm_create_timewait_info(u32 local_id)
  524. {
  525. struct cm_timewait_info *timewait_info;
  526. timewait_info = kmalloc(sizeof *timewait_info, GFP_KERNEL);
  527. if (!timewait_info)
  528. return ERR_PTR(-ENOMEM);
  529. memset(timewait_info, 0, sizeof *timewait_info);
  530. timewait_info->work.local_id = local_id;
  531. INIT_WORK(&timewait_info->work.work, cm_work_handler,
  532. &timewait_info->work);
  533. timewait_info->work.cm_event.event = IB_CM_TIMEWAIT_EXIT;
  534. return timewait_info;
  535. }
  536. static void cm_enter_timewait(struct cm_id_private *cm_id_priv)
  537. {
  538. int wait_time;
  539. /*
  540. * The cm_id could be destroyed by the user before we exit timewait.
  541. * To protect against this, we search for the cm_id after exiting
  542. * timewait before notifying the user that we've exited timewait.
  543. */
  544. cm_id_priv->id.state = IB_CM_TIMEWAIT;
  545. wait_time = cm_convert_to_ms(cm_id_priv->local_ack_timeout);
  546. queue_delayed_work(cm.wq, &cm_id_priv->timewait_info->work.work,
  547. msecs_to_jiffies(wait_time));
  548. cm_id_priv->timewait_info = NULL;
  549. }
  550. static void cm_reset_to_idle(struct cm_id_private *cm_id_priv)
  551. {
  552. cm_id_priv->id.state = IB_CM_IDLE;
  553. if (cm_id_priv->timewait_info) {
  554. cm_cleanup_timewait(cm_id_priv->timewait_info);
  555. kfree(cm_id_priv->timewait_info);
  556. cm_id_priv->timewait_info = NULL;
  557. }
  558. }
  559. void ib_destroy_cm_id(struct ib_cm_id *cm_id)
  560. {
  561. struct cm_id_private *cm_id_priv;
  562. struct cm_work *work;
  563. unsigned long flags;
  564. cm_id_priv = container_of(cm_id, struct cm_id_private, id);
  565. retest:
  566. spin_lock_irqsave(&cm_id_priv->lock, flags);
  567. switch (cm_id->state) {
  568. case IB_CM_LISTEN:
  569. cm_id->state = IB_CM_IDLE;
  570. spin_unlock_irqrestore(&cm_id_priv->lock, flags);
  571. spin_lock_irqsave(&cm.lock, flags);
  572. rb_erase(&cm_id_priv->service_node, &cm.listen_service_table);
  573. spin_unlock_irqrestore(&cm.lock, flags);
  574. break;
  575. case IB_CM_SIDR_REQ_SENT:
  576. cm_id->state = IB_CM_IDLE;
  577. ib_cancel_mad(cm_id_priv->av.port->mad_agent,
  578. (unsigned long) cm_id_priv->msg);
  579. spin_unlock_irqrestore(&cm_id_priv->lock, flags);
  580. break;
  581. case IB_CM_SIDR_REQ_RCVD:
  582. spin_unlock_irqrestore(&cm_id_priv->lock, flags);
  583. cm_reject_sidr_req(cm_id_priv, IB_SIDR_REJECT);
  584. break;
  585. case IB_CM_REQ_SENT:
  586. case IB_CM_MRA_REQ_RCVD:
  587. case IB_CM_REP_SENT:
  588. case IB_CM_MRA_REP_RCVD:
  589. ib_cancel_mad(cm_id_priv->av.port->mad_agent,
  590. (unsigned long) cm_id_priv->msg);
  591. /* Fall through */
  592. case IB_CM_REQ_RCVD:
  593. case IB_CM_MRA_REQ_SENT:
  594. case IB_CM_REP_RCVD:
  595. case IB_CM_MRA_REP_SENT:
  596. spin_unlock_irqrestore(&cm_id_priv->lock, flags);
  597. ib_send_cm_rej(cm_id, IB_CM_REJ_TIMEOUT,
  598. &cm_id_priv->av.port->cm_dev->ca_guid,
  599. sizeof cm_id_priv->av.port->cm_dev->ca_guid,
  600. NULL, 0);
  601. break;
  602. case IB_CM_ESTABLISHED:
  603. spin_unlock_irqrestore(&cm_id_priv->lock, flags);
  604. ib_send_cm_dreq(cm_id, NULL, 0);
  605. goto retest;
  606. case IB_CM_DREQ_SENT:
  607. ib_cancel_mad(cm_id_priv->av.port->mad_agent,
  608. (unsigned long) cm_id_priv->msg);
  609. cm_enter_timewait(cm_id_priv);
  610. spin_unlock_irqrestore(&cm_id_priv->lock, flags);
  611. break;
  612. case IB_CM_DREQ_RCVD:
  613. spin_unlock_irqrestore(&cm_id_priv->lock, flags);
  614. ib_send_cm_drep(cm_id, NULL, 0);
  615. break;
  616. default:
  617. spin_unlock_irqrestore(&cm_id_priv->lock, flags);
  618. break;
  619. }
  620. cm_free_id(cm_id->local_id);
  621. atomic_dec(&cm_id_priv->refcount);
  622. wait_event(cm_id_priv->wait, !atomic_read(&cm_id_priv->refcount));
  623. while ((work = cm_dequeue_work(cm_id_priv)) != NULL)
  624. cm_free_work(work);
  625. if (cm_id_priv->private_data && cm_id_priv->private_data_len)
  626. kfree(cm_id_priv->private_data);
  627. kfree(cm_id_priv);
  628. }
  629. EXPORT_SYMBOL(ib_destroy_cm_id);
  630. int ib_cm_listen(struct ib_cm_id *cm_id,
  631. u64 service_id,
  632. u64 service_mask)
  633. {
  634. struct cm_id_private *cm_id_priv, *cur_cm_id_priv;
  635. unsigned long flags;
  636. int ret = 0;
  637. service_mask = service_mask ? service_mask : ~0ULL;
  638. service_id &= service_mask;
  639. if ((service_id & IB_SERVICE_ID_AGN_MASK) == IB_CM_ASSIGN_SERVICE_ID &&
  640. (service_id != IB_CM_ASSIGN_SERVICE_ID))
  641. return -EINVAL;
  642. cm_id_priv = container_of(cm_id, struct cm_id_private, id);
  643. BUG_ON(cm_id->state != IB_CM_IDLE);
  644. cm_id->state = IB_CM_LISTEN;
  645. spin_lock_irqsave(&cm.lock, flags);
  646. if (service_id == IB_CM_ASSIGN_SERVICE_ID) {
  647. cm_id->service_id = __cpu_to_be64(cm.listen_service_id++);
  648. cm_id->service_mask = ~0ULL;
  649. } else {
  650. cm_id->service_id = service_id;
  651. cm_id->service_mask = service_mask;
  652. }
  653. cur_cm_id_priv = cm_insert_listen(cm_id_priv);
  654. spin_unlock_irqrestore(&cm.lock, flags);
  655. if (cur_cm_id_priv) {
  656. cm_id->state = IB_CM_IDLE;
  657. ret = -EBUSY;
  658. }
  659. return ret;
  660. }
  661. EXPORT_SYMBOL(ib_cm_listen);
  662. static u64 cm_form_tid(struct cm_id_private *cm_id_priv,
  663. enum cm_msg_sequence msg_seq)
  664. {
  665. u64 hi_tid, low_tid;
  666. hi_tid = ((u64) cm_id_priv->av.port->mad_agent->hi_tid) << 32;
  667. low_tid = (u64) (cm_id_priv->id.local_id | (msg_seq << 30));
  668. return cpu_to_be64(hi_tid | low_tid);
  669. }
  670. static void cm_format_mad_hdr(struct ib_mad_hdr *hdr,
  671. enum cm_msg_attr_id attr_id, u64 tid)
  672. {
  673. hdr->base_version = IB_MGMT_BASE_VERSION;
  674. hdr->mgmt_class = IB_MGMT_CLASS_CM;
  675. hdr->class_version = IB_CM_CLASS_VERSION;
  676. hdr->method = IB_MGMT_METHOD_SEND;
  677. hdr->attr_id = attr_id;
  678. hdr->tid = tid;
  679. }
  680. static void cm_format_req(struct cm_req_msg *req_msg,
  681. struct cm_id_private *cm_id_priv,
  682. struct ib_cm_req_param *param)
  683. {
  684. cm_format_mad_hdr(&req_msg->hdr, CM_REQ_ATTR_ID,
  685. cm_form_tid(cm_id_priv, CM_MSG_SEQUENCE_REQ));
  686. req_msg->local_comm_id = cm_id_priv->id.local_id;
  687. req_msg->service_id = param->service_id;
  688. req_msg->local_ca_guid = cm_id_priv->av.port->cm_dev->ca_guid;
  689. cm_req_set_local_qpn(req_msg, cpu_to_be32(param->qp_num));
  690. cm_req_set_resp_res(req_msg, param->responder_resources);
  691. cm_req_set_init_depth(req_msg, param->initiator_depth);
  692. cm_req_set_remote_resp_timeout(req_msg,
  693. param->remote_cm_response_timeout);
  694. cm_req_set_qp_type(req_msg, param->qp_type);
  695. cm_req_set_flow_ctrl(req_msg, param->flow_control);
  696. cm_req_set_starting_psn(req_msg, cpu_to_be32(param->starting_psn));
  697. cm_req_set_local_resp_timeout(req_msg,
  698. param->local_cm_response_timeout);
  699. cm_req_set_retry_count(req_msg, param->retry_count);
  700. req_msg->pkey = param->primary_path->pkey;
  701. cm_req_set_path_mtu(req_msg, param->primary_path->mtu);
  702. cm_req_set_rnr_retry_count(req_msg, param->rnr_retry_count);
  703. cm_req_set_max_cm_retries(req_msg, param->max_cm_retries);
  704. cm_req_set_srq(req_msg, param->srq);
  705. req_msg->primary_local_lid = param->primary_path->slid;
  706. req_msg->primary_remote_lid = param->primary_path->dlid;
  707. req_msg->primary_local_gid = param->primary_path->sgid;
  708. req_msg->primary_remote_gid = param->primary_path->dgid;
  709. cm_req_set_primary_flow_label(req_msg, param->primary_path->flow_label);
  710. cm_req_set_primary_packet_rate(req_msg, param->primary_path->rate);
  711. req_msg->primary_traffic_class = param->primary_path->traffic_class;
  712. req_msg->primary_hop_limit = param->primary_path->hop_limit;
  713. cm_req_set_primary_sl(req_msg, param->primary_path->sl);
  714. cm_req_set_primary_subnet_local(req_msg, 1); /* local only... */
  715. cm_req_set_primary_local_ack_timeout(req_msg,
  716. min(31, param->primary_path->packet_life_time + 1));
  717. if (param->alternate_path) {
  718. req_msg->alt_local_lid = param->alternate_path->slid;
  719. req_msg->alt_remote_lid = param->alternate_path->dlid;
  720. req_msg->alt_local_gid = param->alternate_path->sgid;
  721. req_msg->alt_remote_gid = param->alternate_path->dgid;
  722. cm_req_set_alt_flow_label(req_msg,
  723. param->alternate_path->flow_label);
  724. cm_req_set_alt_packet_rate(req_msg, param->alternate_path->rate);
  725. req_msg->alt_traffic_class = param->alternate_path->traffic_class;
  726. req_msg->alt_hop_limit = param->alternate_path->hop_limit;
  727. cm_req_set_alt_sl(req_msg, param->alternate_path->sl);
  728. cm_req_set_alt_subnet_local(req_msg, 1); /* local only... */
  729. cm_req_set_alt_local_ack_timeout(req_msg,
  730. min(31, param->alternate_path->packet_life_time + 1));
  731. }
  732. if (param->private_data && param->private_data_len)
  733. memcpy(req_msg->private_data, param->private_data,
  734. param->private_data_len);
  735. }
  736. static inline int cm_validate_req_param(struct ib_cm_req_param *param)
  737. {
  738. /* peer-to-peer not supported */
  739. if (param->peer_to_peer)
  740. return -EINVAL;
  741. if (!param->primary_path)
  742. return -EINVAL;
  743. if (param->qp_type != IB_QPT_RC && param->qp_type != IB_QPT_UC)
  744. return -EINVAL;
  745. if (param->private_data &&
  746. param->private_data_len > IB_CM_REQ_PRIVATE_DATA_SIZE)
  747. return -EINVAL;
  748. if (param->alternate_path &&
  749. (param->alternate_path->pkey != param->primary_path->pkey ||
  750. param->alternate_path->mtu != param->primary_path->mtu))
  751. return -EINVAL;
  752. return 0;
  753. }
  754. int ib_send_cm_req(struct ib_cm_id *cm_id,
  755. struct ib_cm_req_param *param)
  756. {
  757. struct cm_id_private *cm_id_priv;
  758. struct ib_send_wr *bad_send_wr;
  759. struct cm_req_msg *req_msg;
  760. unsigned long flags;
  761. int ret;
  762. ret = cm_validate_req_param(param);
  763. if (ret)
  764. return ret;
  765. /* Verify that we're not in timewait. */
  766. cm_id_priv = container_of(cm_id, struct cm_id_private, id);
  767. spin_lock_irqsave(&cm_id_priv->lock, flags);
  768. if (cm_id->state != IB_CM_IDLE) {
  769. spin_unlock_irqrestore(&cm_id_priv->lock, flags);
  770. ret = -EINVAL;
  771. goto out;
  772. }
  773. spin_unlock_irqrestore(&cm_id_priv->lock, flags);
  774. cm_id_priv->timewait_info = cm_create_timewait_info(cm_id_priv->
  775. id.local_id);
  776. if (IS_ERR(cm_id_priv->timewait_info))
  777. goto out;
  778. ret = cm_init_av_by_path(param->primary_path, &cm_id_priv->av);
  779. if (ret)
  780. goto error1;
  781. if (param->alternate_path) {
  782. ret = cm_init_av_by_path(param->alternate_path,
  783. &cm_id_priv->alt_av);
  784. if (ret)
  785. goto error1;
  786. }
  787. cm_id->service_id = param->service_id;
  788. cm_id->service_mask = ~0ULL;
  789. cm_id_priv->timeout_ms = cm_convert_to_ms(
  790. param->primary_path->packet_life_time) * 2 +
  791. cm_convert_to_ms(
  792. param->remote_cm_response_timeout);
  793. cm_id_priv->max_cm_retries = param->max_cm_retries;
  794. cm_id_priv->initiator_depth = param->initiator_depth;
  795. cm_id_priv->responder_resources = param->responder_resources;
  796. cm_id_priv->retry_count = param->retry_count;
  797. cm_id_priv->path_mtu = param->primary_path->mtu;
  798. ret = cm_alloc_msg(cm_id_priv, &cm_id_priv->msg);
  799. if (ret)
  800. goto error1;
  801. req_msg = (struct cm_req_msg *) cm_id_priv->msg->mad;
  802. cm_format_req(req_msg, cm_id_priv, param);
  803. cm_id_priv->tid = req_msg->hdr.tid;
  804. cm_id_priv->msg->send_wr.wr.ud.timeout_ms = cm_id_priv->timeout_ms;
  805. cm_id_priv->msg->context[1] = (void *) (unsigned long) IB_CM_REQ_SENT;
  806. cm_id_priv->local_qpn = cm_req_get_local_qpn(req_msg);
  807. cm_id_priv->rq_psn = cm_req_get_starting_psn(req_msg);
  808. cm_id_priv->local_ack_timeout =
  809. cm_req_get_primary_local_ack_timeout(req_msg);
  810. spin_lock_irqsave(&cm_id_priv->lock, flags);
  811. ret = ib_post_send_mad(cm_id_priv->av.port->mad_agent,
  812. &cm_id_priv->msg->send_wr, &bad_send_wr);
  813. if (ret) {
  814. spin_unlock_irqrestore(&cm_id_priv->lock, flags);
  815. goto error2;
  816. }
  817. BUG_ON(cm_id->state != IB_CM_IDLE);
  818. cm_id->state = IB_CM_REQ_SENT;
  819. spin_unlock_irqrestore(&cm_id_priv->lock, flags);
  820. return 0;
  821. error2: cm_free_msg(cm_id_priv->msg);
  822. error1: kfree(cm_id_priv->timewait_info);
  823. out: return ret;
  824. }
  825. EXPORT_SYMBOL(ib_send_cm_req);
  826. static int cm_issue_rej(struct cm_port *port,
  827. struct ib_mad_recv_wc *mad_recv_wc,
  828. enum ib_cm_rej_reason reason,
  829. enum cm_msg_response msg_rejected,
  830. void *ari, u8 ari_length)
  831. {
  832. struct ib_mad_send_buf *msg = NULL;
  833. struct ib_send_wr *bad_send_wr;
  834. struct cm_rej_msg *rej_msg, *rcv_msg;
  835. int ret;
  836. ret = cm_alloc_response_msg(port, mad_recv_wc, &msg);
  837. if (ret)
  838. return ret;
  839. /* We just need common CM header information. Cast to any message. */
  840. rcv_msg = (struct cm_rej_msg *) mad_recv_wc->recv_buf.mad;
  841. rej_msg = (struct cm_rej_msg *) msg->mad;
  842. cm_format_mad_hdr(&rej_msg->hdr, CM_REJ_ATTR_ID, rcv_msg->hdr.tid);
  843. rej_msg->remote_comm_id = rcv_msg->local_comm_id;
  844. rej_msg->local_comm_id = rcv_msg->remote_comm_id;
  845. cm_rej_set_msg_rejected(rej_msg, msg_rejected);
  846. rej_msg->reason = reason;
  847. if (ari && ari_length) {
  848. cm_rej_set_reject_info_len(rej_msg, ari_length);
  849. memcpy(rej_msg->ari, ari, ari_length);
  850. }
  851. ret = ib_post_send_mad(port->mad_agent, &msg->send_wr, &bad_send_wr);
  852. if (ret)
  853. cm_free_msg(msg);
  854. return ret;
  855. }
  856. static inline int cm_is_active_peer(u64 local_ca_guid, u64 remote_ca_guid,
  857. u32 local_qpn, u32 remote_qpn)
  858. {
  859. return (be64_to_cpu(local_ca_guid) > be64_to_cpu(remote_ca_guid) ||
  860. ((local_ca_guid == remote_ca_guid) &&
  861. (be32_to_cpu(local_qpn) > be32_to_cpu(remote_qpn))));
  862. }
  863. static inline void cm_format_paths_from_req(struct cm_req_msg *req_msg,
  864. struct ib_sa_path_rec *primary_path,
  865. struct ib_sa_path_rec *alt_path)
  866. {
  867. memset(primary_path, 0, sizeof *primary_path);
  868. primary_path->dgid = req_msg->primary_local_gid;
  869. primary_path->sgid = req_msg->primary_remote_gid;
  870. primary_path->dlid = req_msg->primary_local_lid;
  871. primary_path->slid = req_msg->primary_remote_lid;
  872. primary_path->flow_label = cm_req_get_primary_flow_label(req_msg);
  873. primary_path->hop_limit = req_msg->primary_hop_limit;
  874. primary_path->traffic_class = req_msg->primary_traffic_class;
  875. primary_path->reversible = 1;
  876. primary_path->pkey = req_msg->pkey;
  877. primary_path->sl = cm_req_get_primary_sl(req_msg);
  878. primary_path->mtu_selector = IB_SA_EQ;
  879. primary_path->mtu = cm_req_get_path_mtu(req_msg);
  880. primary_path->rate_selector = IB_SA_EQ;
  881. primary_path->rate = cm_req_get_primary_packet_rate(req_msg);
  882. primary_path->packet_life_time_selector = IB_SA_EQ;
  883. primary_path->packet_life_time =
  884. cm_req_get_primary_local_ack_timeout(req_msg);
  885. primary_path->packet_life_time -= (primary_path->packet_life_time > 0);
  886. if (req_msg->alt_local_lid) {
  887. memset(alt_path, 0, sizeof *alt_path);
  888. alt_path->dgid = req_msg->alt_local_gid;
  889. alt_path->sgid = req_msg->alt_remote_gid;
  890. alt_path->dlid = req_msg->alt_local_lid;
  891. alt_path->slid = req_msg->alt_remote_lid;
  892. alt_path->flow_label = cm_req_get_alt_flow_label(req_msg);
  893. alt_path->hop_limit = req_msg->alt_hop_limit;
  894. alt_path->traffic_class = req_msg->alt_traffic_class;
  895. alt_path->reversible = 1;
  896. alt_path->pkey = req_msg->pkey;
  897. alt_path->sl = cm_req_get_alt_sl(req_msg);
  898. alt_path->mtu_selector = IB_SA_EQ;
  899. alt_path->mtu = cm_req_get_path_mtu(req_msg);
  900. alt_path->rate_selector = IB_SA_EQ;
  901. alt_path->rate = cm_req_get_alt_packet_rate(req_msg);
  902. alt_path->packet_life_time_selector = IB_SA_EQ;
  903. alt_path->packet_life_time =
  904. cm_req_get_alt_local_ack_timeout(req_msg);
  905. alt_path->packet_life_time -= (alt_path->packet_life_time > 0);
  906. }
  907. }
  908. static void cm_format_req_event(struct cm_work *work,
  909. struct cm_id_private *cm_id_priv,
  910. struct ib_cm_id *listen_id)
  911. {
  912. struct cm_req_msg *req_msg;
  913. struct ib_cm_req_event_param *param;
  914. req_msg = (struct cm_req_msg *)work->mad_recv_wc->recv_buf.mad;
  915. param = &work->cm_event.param.req_rcvd;
  916. param->listen_id = listen_id;
  917. param->device = cm_id_priv->av.port->mad_agent->device;
  918. param->port = cm_id_priv->av.port->port_num;
  919. param->primary_path = &work->path[0];
  920. if (req_msg->alt_local_lid)
  921. param->alternate_path = &work->path[1];
  922. else
  923. param->alternate_path = NULL;
  924. param->remote_ca_guid = req_msg->local_ca_guid;
  925. param->remote_qkey = be32_to_cpu(req_msg->local_qkey);
  926. param->remote_qpn = be32_to_cpu(cm_req_get_local_qpn(req_msg));
  927. param->qp_type = cm_req_get_qp_type(req_msg);
  928. param->starting_psn = be32_to_cpu(cm_req_get_starting_psn(req_msg));
  929. param->responder_resources = cm_req_get_init_depth(req_msg);
  930. param->initiator_depth = cm_req_get_resp_res(req_msg);
  931. param->local_cm_response_timeout =
  932. cm_req_get_remote_resp_timeout(req_msg);
  933. param->flow_control = cm_req_get_flow_ctrl(req_msg);
  934. param->remote_cm_response_timeout =
  935. cm_req_get_local_resp_timeout(req_msg);
  936. param->retry_count = cm_req_get_retry_count(req_msg);
  937. param->rnr_retry_count = cm_req_get_rnr_retry_count(req_msg);
  938. param->srq = cm_req_get_srq(req_msg);
  939. work->cm_event.private_data = &req_msg->private_data;
  940. }
  941. static void cm_process_work(struct cm_id_private *cm_id_priv,
  942. struct cm_work *work)
  943. {
  944. unsigned long flags;
  945. int ret;
  946. /* We will typically only have the current event to report. */
  947. ret = cm_id_priv->id.cm_handler(&cm_id_priv->id, &work->cm_event);
  948. cm_free_work(work);
  949. while (!ret && !atomic_add_negative(-1, &cm_id_priv->work_count)) {
  950. spin_lock_irqsave(&cm_id_priv->lock, flags);
  951. work = cm_dequeue_work(cm_id_priv);
  952. spin_unlock_irqrestore(&cm_id_priv->lock, flags);
  953. BUG_ON(!work);
  954. ret = cm_id_priv->id.cm_handler(&cm_id_priv->id,
  955. &work->cm_event);
  956. cm_free_work(work);
  957. }
  958. cm_deref_id(cm_id_priv);
  959. if (ret)
  960. ib_destroy_cm_id(&cm_id_priv->id);
  961. }
  962. static void cm_format_mra(struct cm_mra_msg *mra_msg,
  963. struct cm_id_private *cm_id_priv,
  964. enum cm_msg_response msg_mraed, u8 service_timeout,
  965. const void *private_data, u8 private_data_len)
  966. {
  967. cm_format_mad_hdr(&mra_msg->hdr, CM_MRA_ATTR_ID, cm_id_priv->tid);
  968. cm_mra_set_msg_mraed(mra_msg, msg_mraed);
  969. mra_msg->local_comm_id = cm_id_priv->id.local_id;
  970. mra_msg->remote_comm_id = cm_id_priv->id.remote_id;
  971. cm_mra_set_service_timeout(mra_msg, service_timeout);
  972. if (private_data && private_data_len)
  973. memcpy(mra_msg->private_data, private_data, private_data_len);
  974. }
  975. static void cm_format_rej(struct cm_rej_msg *rej_msg,
  976. struct cm_id_private *cm_id_priv,
  977. enum ib_cm_rej_reason reason,
  978. void *ari,
  979. u8 ari_length,
  980. const void *private_data,
  981. u8 private_data_len)
  982. {
  983. cm_format_mad_hdr(&rej_msg->hdr, CM_REJ_ATTR_ID, cm_id_priv->tid);
  984. rej_msg->remote_comm_id = cm_id_priv->id.remote_id;
  985. switch(cm_id_priv->id.state) {
  986. case IB_CM_REQ_RCVD:
  987. rej_msg->local_comm_id = 0;
  988. cm_rej_set_msg_rejected(rej_msg, CM_MSG_RESPONSE_REQ);
  989. break;
  990. case IB_CM_MRA_REQ_SENT:
  991. rej_msg->local_comm_id = cm_id_priv->id.local_id;
  992. cm_rej_set_msg_rejected(rej_msg, CM_MSG_RESPONSE_REQ);
  993. break;
  994. case IB_CM_REP_RCVD:
  995. case IB_CM_MRA_REP_SENT:
  996. rej_msg->local_comm_id = cm_id_priv->id.local_id;
  997. cm_rej_set_msg_rejected(rej_msg, CM_MSG_RESPONSE_REP);
  998. break;
  999. default:
  1000. rej_msg->local_comm_id = cm_id_priv->id.local_id;
  1001. cm_rej_set_msg_rejected(rej_msg, CM_MSG_RESPONSE_OTHER);
  1002. break;
  1003. }
  1004. rej_msg->reason = reason;
  1005. if (ari && ari_length) {
  1006. cm_rej_set_reject_info_len(rej_msg, ari_length);
  1007. memcpy(rej_msg->ari, ari, ari_length);
  1008. }
  1009. if (private_data && private_data_len)
  1010. memcpy(rej_msg->private_data, private_data, private_data_len);
  1011. }
  1012. static void cm_dup_req_handler(struct cm_work *work,
  1013. struct cm_id_private *cm_id_priv)
  1014. {
  1015. struct ib_mad_send_buf *msg = NULL;
  1016. struct ib_send_wr *bad_send_wr;
  1017. unsigned long flags;
  1018. int ret;
  1019. /* Quick state check to discard duplicate REQs. */
  1020. if (cm_id_priv->id.state == IB_CM_REQ_RCVD)
  1021. return;
  1022. ret = cm_alloc_response_msg(work->port, work->mad_recv_wc, &msg);
  1023. if (ret)
  1024. return;
  1025. spin_lock_irqsave(&cm_id_priv->lock, flags);
  1026. switch (cm_id_priv->id.state) {
  1027. case IB_CM_MRA_REQ_SENT:
  1028. cm_format_mra((struct cm_mra_msg *) msg->mad, cm_id_priv,
  1029. CM_MSG_RESPONSE_REQ, cm_id_priv->service_timeout,
  1030. cm_id_priv->private_data,
  1031. cm_id_priv->private_data_len);
  1032. break;
  1033. case IB_CM_TIMEWAIT:
  1034. cm_format_rej((struct cm_rej_msg *) msg->mad, cm_id_priv,
  1035. IB_CM_REJ_STALE_CONN, NULL, 0, NULL, 0);
  1036. break;
  1037. default:
  1038. goto unlock;
  1039. }
  1040. spin_unlock_irqrestore(&cm_id_priv->lock, flags);
  1041. ret = ib_post_send_mad(cm_id_priv->av.port->mad_agent, &msg->send_wr,
  1042. &bad_send_wr);
  1043. if (ret)
  1044. goto free;
  1045. return;
  1046. unlock: spin_unlock_irqrestore(&cm_id_priv->lock, flags);
  1047. free: cm_free_msg(msg);
  1048. }
  1049. static struct cm_id_private * cm_match_req(struct cm_work *work,
  1050. struct cm_id_private *cm_id_priv)
  1051. {
  1052. struct cm_id_private *listen_cm_id_priv, *cur_cm_id_priv;
  1053. struct cm_timewait_info *timewait_info;
  1054. struct cm_req_msg *req_msg;
  1055. unsigned long flags;
  1056. req_msg = (struct cm_req_msg *)work->mad_recv_wc->recv_buf.mad;
  1057. /* Check for duplicate REQ and stale connections. */
  1058. spin_lock_irqsave(&cm.lock, flags);
  1059. timewait_info = cm_insert_remote_id(cm_id_priv->timewait_info);
  1060. if (!timewait_info)
  1061. timewait_info = cm_insert_remote_qpn(cm_id_priv->timewait_info);
  1062. if (timewait_info) {
  1063. cur_cm_id_priv = cm_get_id(timewait_info->work.local_id,
  1064. timewait_info->work.remote_id);
  1065. spin_unlock_irqrestore(&cm.lock, flags);
  1066. if (cur_cm_id_priv) {
  1067. cm_dup_req_handler(work, cur_cm_id_priv);
  1068. cm_deref_id(cur_cm_id_priv);
  1069. } else
  1070. cm_issue_rej(work->port, work->mad_recv_wc,
  1071. IB_CM_REJ_STALE_CONN, CM_MSG_RESPONSE_REQ,
  1072. NULL, 0);
  1073. goto error;
  1074. }
  1075. /* Find matching listen request. */
  1076. listen_cm_id_priv = cm_find_listen(req_msg->service_id);
  1077. if (!listen_cm_id_priv) {
  1078. spin_unlock_irqrestore(&cm.lock, flags);
  1079. cm_issue_rej(work->port, work->mad_recv_wc,
  1080. IB_CM_REJ_INVALID_SERVICE_ID, CM_MSG_RESPONSE_REQ,
  1081. NULL, 0);
  1082. goto error;
  1083. }
  1084. atomic_inc(&listen_cm_id_priv->refcount);
  1085. atomic_inc(&cm_id_priv->refcount);
  1086. cm_id_priv->id.state = IB_CM_REQ_RCVD;
  1087. atomic_inc(&cm_id_priv->work_count);
  1088. spin_unlock_irqrestore(&cm.lock, flags);
  1089. return listen_cm_id_priv;
  1090. error: cm_cleanup_timewait(cm_id_priv->timewait_info);
  1091. return NULL;
  1092. }
  1093. static int cm_req_handler(struct cm_work *work)
  1094. {
  1095. struct ib_cm_id *cm_id;
  1096. struct cm_id_private *cm_id_priv, *listen_cm_id_priv;
  1097. struct cm_req_msg *req_msg;
  1098. int ret;
  1099. req_msg = (struct cm_req_msg *)work->mad_recv_wc->recv_buf.mad;
  1100. cm_id = ib_create_cm_id(NULL, NULL);
  1101. if (IS_ERR(cm_id))
  1102. return PTR_ERR(cm_id);
  1103. cm_id_priv = container_of(cm_id, struct cm_id_private, id);
  1104. cm_id_priv->id.remote_id = req_msg->local_comm_id;
  1105. cm_init_av_for_response(work->port, work->mad_recv_wc->wc,
  1106. &cm_id_priv->av);
  1107. cm_id_priv->timewait_info = cm_create_timewait_info(cm_id_priv->
  1108. id.local_id);
  1109. if (IS_ERR(cm_id_priv->timewait_info)) {
  1110. ret = PTR_ERR(cm_id_priv->timewait_info);
  1111. goto error1;
  1112. }
  1113. cm_id_priv->timewait_info->work.remote_id = req_msg->local_comm_id;
  1114. cm_id_priv->timewait_info->remote_ca_guid = req_msg->local_ca_guid;
  1115. cm_id_priv->timewait_info->remote_qpn = cm_req_get_local_qpn(req_msg);
  1116. listen_cm_id_priv = cm_match_req(work, cm_id_priv);
  1117. if (!listen_cm_id_priv) {
  1118. ret = -EINVAL;
  1119. goto error2;
  1120. }
  1121. cm_id_priv->id.cm_handler = listen_cm_id_priv->id.cm_handler;
  1122. cm_id_priv->id.context = listen_cm_id_priv->id.context;
  1123. cm_id_priv->id.service_id = req_msg->service_id;
  1124. cm_id_priv->id.service_mask = ~0ULL;
  1125. cm_format_paths_from_req(req_msg, &work->path[0], &work->path[1]);
  1126. ret = cm_init_av_by_path(&work->path[0], &cm_id_priv->av);
  1127. if (ret)
  1128. goto error3;
  1129. if (req_msg->alt_local_lid) {
  1130. ret = cm_init_av_by_path(&work->path[1], &cm_id_priv->alt_av);
  1131. if (ret)
  1132. goto error3;
  1133. }
  1134. cm_id_priv->tid = req_msg->hdr.tid;
  1135. cm_id_priv->timeout_ms = cm_convert_to_ms(
  1136. cm_req_get_local_resp_timeout(req_msg));
  1137. cm_id_priv->max_cm_retries = cm_req_get_max_cm_retries(req_msg);
  1138. cm_id_priv->remote_qpn = cm_req_get_local_qpn(req_msg);
  1139. cm_id_priv->initiator_depth = cm_req_get_resp_res(req_msg);
  1140. cm_id_priv->responder_resources = cm_req_get_init_depth(req_msg);
  1141. cm_id_priv->path_mtu = cm_req_get_path_mtu(req_msg);
  1142. cm_id_priv->sq_psn = cm_req_get_starting_psn(req_msg);
  1143. cm_id_priv->local_ack_timeout =
  1144. cm_req_get_primary_local_ack_timeout(req_msg);
  1145. cm_id_priv->retry_count = cm_req_get_retry_count(req_msg);
  1146. cm_id_priv->rnr_retry_count = cm_req_get_rnr_retry_count(req_msg);
  1147. cm_format_req_event(work, cm_id_priv, &listen_cm_id_priv->id);
  1148. cm_process_work(cm_id_priv, work);
  1149. cm_deref_id(listen_cm_id_priv);
  1150. return 0;
  1151. error3: atomic_dec(&cm_id_priv->refcount);
  1152. cm_deref_id(listen_cm_id_priv);
  1153. cm_cleanup_timewait(cm_id_priv->timewait_info);
  1154. error2: kfree(cm_id_priv->timewait_info);
  1155. error1: ib_destroy_cm_id(&cm_id_priv->id);
  1156. return ret;
  1157. }
  1158. static void cm_format_rep(struct cm_rep_msg *rep_msg,
  1159. struct cm_id_private *cm_id_priv,
  1160. struct ib_cm_rep_param *param)
  1161. {
  1162. cm_format_mad_hdr(&rep_msg->hdr, CM_REP_ATTR_ID, cm_id_priv->tid);
  1163. rep_msg->local_comm_id = cm_id_priv->id.local_id;
  1164. rep_msg->remote_comm_id = cm_id_priv->id.remote_id;
  1165. cm_rep_set_local_qpn(rep_msg, cpu_to_be32(param->qp_num));
  1166. cm_rep_set_starting_psn(rep_msg, cpu_to_be32(param->starting_psn));
  1167. rep_msg->resp_resources = param->responder_resources;
  1168. rep_msg->initiator_depth = param->initiator_depth;
  1169. cm_rep_set_target_ack_delay(rep_msg, param->target_ack_delay);
  1170. cm_rep_set_failover(rep_msg, param->failover_accepted);
  1171. cm_rep_set_flow_ctrl(rep_msg, param->flow_control);
  1172. cm_rep_set_rnr_retry_count(rep_msg, param->rnr_retry_count);
  1173. cm_rep_set_srq(rep_msg, param->srq);
  1174. rep_msg->local_ca_guid = cm_id_priv->av.port->cm_dev->ca_guid;
  1175. if (param->private_data && param->private_data_len)
  1176. memcpy(rep_msg->private_data, param->private_data,
  1177. param->private_data_len);
  1178. }
  1179. int ib_send_cm_rep(struct ib_cm_id *cm_id,
  1180. struct ib_cm_rep_param *param)
  1181. {
  1182. struct cm_id_private *cm_id_priv;
  1183. struct ib_mad_send_buf *msg;
  1184. struct cm_rep_msg *rep_msg;
  1185. struct ib_send_wr *bad_send_wr;
  1186. unsigned long flags;
  1187. int ret;
  1188. if (param->private_data &&
  1189. param->private_data_len > IB_CM_REP_PRIVATE_DATA_SIZE)
  1190. return -EINVAL;
  1191. cm_id_priv = container_of(cm_id, struct cm_id_private, id);
  1192. spin_lock_irqsave(&cm_id_priv->lock, flags);
  1193. if (cm_id->state != IB_CM_REQ_RCVD &&
  1194. cm_id->state != IB_CM_MRA_REQ_SENT) {
  1195. ret = -EINVAL;
  1196. goto out;
  1197. }
  1198. ret = cm_alloc_msg(cm_id_priv, &msg);
  1199. if (ret)
  1200. goto out;
  1201. rep_msg = (struct cm_rep_msg *) msg->mad;
  1202. cm_format_rep(rep_msg, cm_id_priv, param);
  1203. msg->send_wr.wr.ud.timeout_ms = cm_id_priv->timeout_ms;
  1204. msg->context[1] = (void *) (unsigned long) IB_CM_REP_SENT;
  1205. ret = ib_post_send_mad(cm_id_priv->av.port->mad_agent,
  1206. &msg->send_wr, &bad_send_wr);
  1207. if (ret) {
  1208. spin_unlock_irqrestore(&cm_id_priv->lock, flags);
  1209. cm_free_msg(msg);
  1210. return ret;
  1211. }
  1212. cm_id->state = IB_CM_REP_SENT;
  1213. cm_id_priv->msg = msg;
  1214. cm_id_priv->initiator_depth = param->initiator_depth;
  1215. cm_id_priv->responder_resources = param->responder_resources;
  1216. cm_id_priv->rq_psn = cm_rep_get_starting_psn(rep_msg);
  1217. cm_id_priv->local_qpn = cm_rep_get_local_qpn(rep_msg);
  1218. out: spin_unlock_irqrestore(&cm_id_priv->lock, flags);
  1219. return ret;
  1220. }
  1221. EXPORT_SYMBOL(ib_send_cm_rep);
  1222. static void cm_format_rtu(struct cm_rtu_msg *rtu_msg,
  1223. struct cm_id_private *cm_id_priv,
  1224. const void *private_data,
  1225. u8 private_data_len)
  1226. {
  1227. cm_format_mad_hdr(&rtu_msg->hdr, CM_RTU_ATTR_ID, cm_id_priv->tid);
  1228. rtu_msg->local_comm_id = cm_id_priv->id.local_id;
  1229. rtu_msg->remote_comm_id = cm_id_priv->id.remote_id;
  1230. if (private_data && private_data_len)
  1231. memcpy(rtu_msg->private_data, private_data, private_data_len);
  1232. }
  1233. int ib_send_cm_rtu(struct ib_cm_id *cm_id,
  1234. const void *private_data,
  1235. u8 private_data_len)
  1236. {
  1237. struct cm_id_private *cm_id_priv;
  1238. struct ib_mad_send_buf *msg;
  1239. struct ib_send_wr *bad_send_wr;
  1240. unsigned long flags;
  1241. void *data;
  1242. int ret;
  1243. if (private_data && private_data_len > IB_CM_RTU_PRIVATE_DATA_SIZE)
  1244. return -EINVAL;
  1245. data = cm_copy_private_data(private_data, private_data_len);
  1246. if (IS_ERR(data))
  1247. return PTR_ERR(data);
  1248. cm_id_priv = container_of(cm_id, struct cm_id_private, id);
  1249. spin_lock_irqsave(&cm_id_priv->lock, flags);
  1250. if (cm_id->state != IB_CM_REP_RCVD &&
  1251. cm_id->state != IB_CM_MRA_REP_SENT) {
  1252. ret = -EINVAL;
  1253. goto error;
  1254. }
  1255. ret = cm_alloc_msg(cm_id_priv, &msg);
  1256. if (ret)
  1257. goto error;
  1258. cm_format_rtu((struct cm_rtu_msg *) msg->mad, cm_id_priv,
  1259. private_data, private_data_len);
  1260. ret = ib_post_send_mad(cm_id_priv->av.port->mad_agent,
  1261. &msg->send_wr, &bad_send_wr);
  1262. if (ret) {
  1263. spin_unlock_irqrestore(&cm_id_priv->lock, flags);
  1264. cm_free_msg(msg);
  1265. kfree(data);
  1266. return ret;
  1267. }
  1268. cm_id->state = IB_CM_ESTABLISHED;
  1269. cm_set_private_data(cm_id_priv, data, private_data_len);
  1270. spin_unlock_irqrestore(&cm_id_priv->lock, flags);
  1271. return 0;
  1272. error: spin_unlock_irqrestore(&cm_id_priv->lock, flags);
  1273. kfree(data);
  1274. return ret;
  1275. }
  1276. EXPORT_SYMBOL(ib_send_cm_rtu);
  1277. static void cm_format_rep_event(struct cm_work *work)
  1278. {
  1279. struct cm_rep_msg *rep_msg;
  1280. struct ib_cm_rep_event_param *param;
  1281. rep_msg = (struct cm_rep_msg *)work->mad_recv_wc->recv_buf.mad;
  1282. param = &work->cm_event.param.rep_rcvd;
  1283. param->remote_ca_guid = rep_msg->local_ca_guid;
  1284. param->remote_qkey = be32_to_cpu(rep_msg->local_qkey);
  1285. param->remote_qpn = be32_to_cpu(cm_rep_get_local_qpn(rep_msg));
  1286. param->starting_psn = be32_to_cpu(cm_rep_get_starting_psn(rep_msg));
  1287. param->responder_resources = rep_msg->initiator_depth;
  1288. param->initiator_depth = rep_msg->resp_resources;
  1289. param->target_ack_delay = cm_rep_get_target_ack_delay(rep_msg);
  1290. param->failover_accepted = cm_rep_get_failover(rep_msg);
  1291. param->flow_control = cm_rep_get_flow_ctrl(rep_msg);
  1292. param->rnr_retry_count = cm_rep_get_rnr_retry_count(rep_msg);
  1293. param->srq = cm_rep_get_srq(rep_msg);
  1294. work->cm_event.private_data = &rep_msg->private_data;
  1295. }
  1296. static void cm_dup_rep_handler(struct cm_work *work)
  1297. {
  1298. struct cm_id_private *cm_id_priv;
  1299. struct cm_rep_msg *rep_msg;
  1300. struct ib_mad_send_buf *msg = NULL;
  1301. struct ib_send_wr *bad_send_wr;
  1302. unsigned long flags;
  1303. int ret;
  1304. rep_msg = (struct cm_rep_msg *) work->mad_recv_wc->recv_buf.mad;
  1305. cm_id_priv = cm_acquire_id(rep_msg->remote_comm_id,
  1306. rep_msg->local_comm_id);
  1307. if (!cm_id_priv)
  1308. return;
  1309. ret = cm_alloc_response_msg(work->port, work->mad_recv_wc, &msg);
  1310. if (ret)
  1311. goto deref;
  1312. spin_lock_irqsave(&cm_id_priv->lock, flags);
  1313. if (cm_id_priv->id.state == IB_CM_ESTABLISHED)
  1314. cm_format_rtu((struct cm_rtu_msg *) msg->mad, cm_id_priv,
  1315. cm_id_priv->private_data,
  1316. cm_id_priv->private_data_len);
  1317. else if (cm_id_priv->id.state == IB_CM_MRA_REP_SENT)
  1318. cm_format_mra((struct cm_mra_msg *) msg->mad, cm_id_priv,
  1319. CM_MSG_RESPONSE_REP, cm_id_priv->service_timeout,
  1320. cm_id_priv->private_data,
  1321. cm_id_priv->private_data_len);
  1322. else
  1323. goto unlock;
  1324. spin_unlock_irqrestore(&cm_id_priv->lock, flags);
  1325. ret = ib_post_send_mad(cm_id_priv->av.port->mad_agent, &msg->send_wr,
  1326. &bad_send_wr);
  1327. if (ret)
  1328. goto free;
  1329. goto deref;
  1330. unlock: spin_unlock_irqrestore(&cm_id_priv->lock, flags);
  1331. free: cm_free_msg(msg);
  1332. deref: cm_deref_id(cm_id_priv);
  1333. }
  1334. static int cm_rep_handler(struct cm_work *work)
  1335. {
  1336. struct cm_id_private *cm_id_priv;
  1337. struct cm_rep_msg *rep_msg;
  1338. unsigned long flags;
  1339. int ret;
  1340. rep_msg = (struct cm_rep_msg *)work->mad_recv_wc->recv_buf.mad;
  1341. cm_id_priv = cm_acquire_id(rep_msg->remote_comm_id, 0);
  1342. if (!cm_id_priv) {
  1343. cm_dup_rep_handler(work);
  1344. return -EINVAL;
  1345. }
  1346. cm_id_priv->timewait_info->work.remote_id = rep_msg->local_comm_id;
  1347. cm_id_priv->timewait_info->remote_ca_guid = rep_msg->local_ca_guid;
  1348. cm_id_priv->timewait_info->remote_qpn = cm_rep_get_local_qpn(rep_msg);
  1349. spin_lock_irqsave(&cm.lock, flags);
  1350. /* Check for duplicate REP. */
  1351. if (cm_insert_remote_id(cm_id_priv->timewait_info)) {
  1352. spin_unlock_irqrestore(&cm.lock, flags);
  1353. ret = -EINVAL;
  1354. goto error;
  1355. }
  1356. /* Check for a stale connection. */
  1357. if (cm_insert_remote_qpn(cm_id_priv->timewait_info)) {
  1358. spin_unlock_irqrestore(&cm.lock, flags);
  1359. cm_issue_rej(work->port, work->mad_recv_wc,
  1360. IB_CM_REJ_STALE_CONN, CM_MSG_RESPONSE_REP,
  1361. NULL, 0);
  1362. ret = -EINVAL;
  1363. goto error;
  1364. }
  1365. spin_unlock_irqrestore(&cm.lock, flags);
  1366. cm_format_rep_event(work);
  1367. spin_lock_irqsave(&cm_id_priv->lock, flags);
  1368. switch (cm_id_priv->id.state) {
  1369. case IB_CM_REQ_SENT:
  1370. case IB_CM_MRA_REQ_RCVD:
  1371. break;
  1372. default:
  1373. spin_unlock_irqrestore(&cm_id_priv->lock, flags);
  1374. ret = -EINVAL;
  1375. goto error;
  1376. }
  1377. cm_id_priv->id.state = IB_CM_REP_RCVD;
  1378. cm_id_priv->id.remote_id = rep_msg->local_comm_id;
  1379. cm_id_priv->remote_qpn = cm_rep_get_local_qpn(rep_msg);
  1380. cm_id_priv->initiator_depth = rep_msg->resp_resources;
  1381. cm_id_priv->responder_resources = rep_msg->initiator_depth;
  1382. cm_id_priv->sq_psn = cm_rep_get_starting_psn(rep_msg);
  1383. cm_id_priv->rnr_retry_count = cm_rep_get_rnr_retry_count(rep_msg);
  1384. /* todo: handle peer_to_peer */
  1385. ib_cancel_mad(cm_id_priv->av.port->mad_agent,
  1386. (unsigned long) cm_id_priv->msg);
  1387. ret = atomic_inc_and_test(&cm_id_priv->work_count);
  1388. if (!ret)
  1389. list_add_tail(&work->list, &cm_id_priv->work_list);
  1390. spin_unlock_irqrestore(&cm_id_priv->lock, flags);
  1391. if (ret)
  1392. cm_process_work(cm_id_priv, work);
  1393. else
  1394. cm_deref_id(cm_id_priv);
  1395. return 0;
  1396. error: cm_cleanup_timewait(cm_id_priv->timewait_info);
  1397. cm_deref_id(cm_id_priv);
  1398. return ret;
  1399. }
  1400. static int cm_establish_handler(struct cm_work *work)
  1401. {
  1402. struct cm_id_private *cm_id_priv;
  1403. unsigned long flags;
  1404. int ret;
  1405. /* See comment in ib_cm_establish about lookup. */
  1406. cm_id_priv = cm_acquire_id(work->local_id, work->remote_id);
  1407. if (!cm_id_priv)
  1408. return -EINVAL;
  1409. spin_lock_irqsave(&cm_id_priv->lock, flags);
  1410. if (cm_id_priv->id.state != IB_CM_ESTABLISHED) {
  1411. spin_unlock_irqrestore(&cm_id_priv->lock, flags);
  1412. goto out;
  1413. }
  1414. ib_cancel_mad(cm_id_priv->av.port->mad_agent,
  1415. (unsigned long) cm_id_priv->msg);
  1416. ret = atomic_inc_and_test(&cm_id_priv->work_count);
  1417. if (!ret)
  1418. list_add_tail(&work->list, &cm_id_priv->work_list);
  1419. spin_unlock_irqrestore(&cm_id_priv->lock, flags);
  1420. if (ret)
  1421. cm_process_work(cm_id_priv, work);
  1422. else
  1423. cm_deref_id(cm_id_priv);
  1424. return 0;
  1425. out:
  1426. cm_deref_id(cm_id_priv);
  1427. return -EINVAL;
  1428. }
  1429. static int cm_rtu_handler(struct cm_work *work)
  1430. {
  1431. struct cm_id_private *cm_id_priv;
  1432. struct cm_rtu_msg *rtu_msg;
  1433. unsigned long flags;
  1434. int ret;
  1435. rtu_msg = (struct cm_rtu_msg *)work->mad_recv_wc->recv_buf.mad;
  1436. cm_id_priv = cm_acquire_id(rtu_msg->remote_comm_id,
  1437. rtu_msg->local_comm_id);
  1438. if (!cm_id_priv)
  1439. return -EINVAL;
  1440. work->cm_event.private_data = &rtu_msg->private_data;
  1441. spin_lock_irqsave(&cm_id_priv->lock, flags);
  1442. if (cm_id_priv->id.state != IB_CM_REP_SENT &&
  1443. cm_id_priv->id.state != IB_CM_MRA_REP_RCVD) {
  1444. spin_unlock_irqrestore(&cm_id_priv->lock, flags);
  1445. goto out;
  1446. }
  1447. cm_id_priv->id.state = IB_CM_ESTABLISHED;
  1448. ib_cancel_mad(cm_id_priv->av.port->mad_agent,
  1449. (unsigned long) cm_id_priv->msg);
  1450. ret = atomic_inc_and_test(&cm_id_priv->work_count);
  1451. if (!ret)
  1452. list_add_tail(&work->list, &cm_id_priv->work_list);
  1453. spin_unlock_irqrestore(&cm_id_priv->lock, flags);
  1454. if (ret)
  1455. cm_process_work(cm_id_priv, work);
  1456. else
  1457. cm_deref_id(cm_id_priv);
  1458. return 0;
  1459. out:
  1460. cm_deref_id(cm_id_priv);
  1461. return -EINVAL;
  1462. }
  1463. static void cm_format_dreq(struct cm_dreq_msg *dreq_msg,
  1464. struct cm_id_private *cm_id_priv,
  1465. const void *private_data,
  1466. u8 private_data_len)
  1467. {
  1468. cm_format_mad_hdr(&dreq_msg->hdr, CM_DREQ_ATTR_ID,
  1469. cm_form_tid(cm_id_priv, CM_MSG_SEQUENCE_DREQ));
  1470. dreq_msg->local_comm_id = cm_id_priv->id.local_id;
  1471. dreq_msg->remote_comm_id = cm_id_priv->id.remote_id;
  1472. cm_dreq_set_remote_qpn(dreq_msg, cm_id_priv->remote_qpn);
  1473. if (private_data && private_data_len)
  1474. memcpy(dreq_msg->private_data, private_data, private_data_len);
  1475. }
  1476. int ib_send_cm_dreq(struct ib_cm_id *cm_id,
  1477. const void *private_data,
  1478. u8 private_data_len)
  1479. {
  1480. struct cm_id_private *cm_id_priv;
  1481. struct ib_mad_send_buf *msg;
  1482. struct ib_send_wr *bad_send_wr;
  1483. unsigned long flags;
  1484. int ret;
  1485. if (private_data && private_data_len > IB_CM_DREQ_PRIVATE_DATA_SIZE)
  1486. return -EINVAL;
  1487. cm_id_priv = container_of(cm_id, struct cm_id_private, id);
  1488. spin_lock_irqsave(&cm_id_priv->lock, flags);
  1489. if (cm_id->state != IB_CM_ESTABLISHED) {
  1490. ret = -EINVAL;
  1491. goto out;
  1492. }
  1493. ret = cm_alloc_msg(cm_id_priv, &msg);
  1494. if (ret) {
  1495. cm_enter_timewait(cm_id_priv);
  1496. goto out;
  1497. }
  1498. cm_format_dreq((struct cm_dreq_msg *) msg->mad, cm_id_priv,
  1499. private_data, private_data_len);
  1500. msg->send_wr.wr.ud.timeout_ms = cm_id_priv->timeout_ms;
  1501. msg->context[1] = (void *) (unsigned long) IB_CM_DREQ_SENT;
  1502. ret = ib_post_send_mad(cm_id_priv->av.port->mad_agent,
  1503. &msg->send_wr, &bad_send_wr);
  1504. if (ret) {
  1505. cm_enter_timewait(cm_id_priv);
  1506. spin_unlock_irqrestore(&cm_id_priv->lock, flags);
  1507. cm_free_msg(msg);
  1508. return ret;
  1509. }
  1510. cm_id->state = IB_CM_DREQ_SENT;
  1511. cm_id_priv->msg = msg;
  1512. out: spin_unlock_irqrestore(&cm_id_priv->lock, flags);
  1513. return ret;
  1514. }
  1515. EXPORT_SYMBOL(ib_send_cm_dreq);
  1516. static void cm_format_drep(struct cm_drep_msg *drep_msg,
  1517. struct cm_id_private *cm_id_priv,
  1518. const void *private_data,
  1519. u8 private_data_len)
  1520. {
  1521. cm_format_mad_hdr(&drep_msg->hdr, CM_DREP_ATTR_ID, cm_id_priv->tid);
  1522. drep_msg->local_comm_id = cm_id_priv->id.local_id;
  1523. drep_msg->remote_comm_id = cm_id_priv->id.remote_id;
  1524. if (private_data && private_data_len)
  1525. memcpy(drep_msg->private_data, private_data, private_data_len);
  1526. }
  1527. int ib_send_cm_drep(struct ib_cm_id *cm_id,
  1528. const void *private_data,
  1529. u8 private_data_len)
  1530. {
  1531. struct cm_id_private *cm_id_priv;
  1532. struct ib_mad_send_buf *msg;
  1533. struct ib_send_wr *bad_send_wr;
  1534. unsigned long flags;
  1535. void *data;
  1536. int ret;
  1537. if (private_data && private_data_len > IB_CM_DREP_PRIVATE_DATA_SIZE)
  1538. return -EINVAL;
  1539. data = cm_copy_private_data(private_data, private_data_len);
  1540. if (IS_ERR(data))
  1541. return PTR_ERR(data);
  1542. cm_id_priv = container_of(cm_id, struct cm_id_private, id);
  1543. spin_lock_irqsave(&cm_id_priv->lock, flags);
  1544. if (cm_id->state != IB_CM_DREQ_RCVD) {
  1545. spin_unlock_irqrestore(&cm_id_priv->lock, flags);
  1546. kfree(data);
  1547. return -EINVAL;
  1548. }
  1549. cm_set_private_data(cm_id_priv, data, private_data_len);
  1550. cm_enter_timewait(cm_id_priv);
  1551. ret = cm_alloc_msg(cm_id_priv, &msg);
  1552. if (ret)
  1553. goto out;
  1554. cm_format_drep((struct cm_drep_msg *) msg->mad, cm_id_priv,
  1555. private_data, private_data_len);
  1556. ret = ib_post_send_mad(cm_id_priv->av.port->mad_agent, &msg->send_wr,
  1557. &bad_send_wr);
  1558. if (ret) {
  1559. spin_unlock_irqrestore(&cm_id_priv->lock, flags);
  1560. cm_free_msg(msg);
  1561. return ret;
  1562. }
  1563. out: spin_unlock_irqrestore(&cm_id_priv->lock, flags);
  1564. return ret;
  1565. }
  1566. EXPORT_SYMBOL(ib_send_cm_drep);
  1567. static int cm_dreq_handler(struct cm_work *work)
  1568. {
  1569. struct cm_id_private *cm_id_priv;
  1570. struct cm_dreq_msg *dreq_msg;
  1571. struct ib_mad_send_buf *msg = NULL;
  1572. struct ib_send_wr *bad_send_wr;
  1573. unsigned long flags;
  1574. int ret;
  1575. dreq_msg = (struct cm_dreq_msg *)work->mad_recv_wc->recv_buf.mad;
  1576. cm_id_priv = cm_acquire_id(dreq_msg->remote_comm_id,
  1577. dreq_msg->local_comm_id);
  1578. if (!cm_id_priv)
  1579. return -EINVAL;
  1580. work->cm_event.private_data = &dreq_msg->private_data;
  1581. spin_lock_irqsave(&cm_id_priv->lock, flags);
  1582. if (cm_id_priv->local_qpn != cm_dreq_get_remote_qpn(dreq_msg))
  1583. goto unlock;
  1584. switch (cm_id_priv->id.state) {
  1585. case IB_CM_REP_SENT:
  1586. case IB_CM_DREQ_SENT:
  1587. ib_cancel_mad(cm_id_priv->av.port->mad_agent,
  1588. (unsigned long) cm_id_priv->msg);
  1589. break;
  1590. case IB_CM_ESTABLISHED:
  1591. case IB_CM_MRA_REP_RCVD:
  1592. break;
  1593. case IB_CM_TIMEWAIT:
  1594. if (cm_alloc_response_msg(work->port, work->mad_recv_wc, &msg))
  1595. goto unlock;
  1596. cm_format_drep((struct cm_drep_msg *) msg->mad, cm_id_priv,
  1597. cm_id_priv->private_data,
  1598. cm_id_priv->private_data_len);
  1599. spin_unlock_irqrestore(&cm_id_priv->lock, flags);
  1600. if (ib_post_send_mad(cm_id_priv->av.port->mad_agent,
  1601. &msg->send_wr, &bad_send_wr))
  1602. cm_free_msg(msg);
  1603. goto deref;
  1604. default:
  1605. goto unlock;
  1606. }
  1607. cm_id_priv->id.state = IB_CM_DREQ_RCVD;
  1608. cm_id_priv->tid = dreq_msg->hdr.tid;
  1609. ret = atomic_inc_and_test(&cm_id_priv->work_count);
  1610. if (!ret)
  1611. list_add_tail(&work->list, &cm_id_priv->work_list);
  1612. spin_unlock_irqrestore(&cm_id_priv->lock, flags);
  1613. if (ret)
  1614. cm_process_work(cm_id_priv, work);
  1615. else
  1616. cm_deref_id(cm_id_priv);
  1617. return 0;
  1618. unlock: spin_unlock_irqrestore(&cm_id_priv->lock, flags);
  1619. deref: cm_deref_id(cm_id_priv);
  1620. return -EINVAL;
  1621. }
  1622. static int cm_drep_handler(struct cm_work *work)
  1623. {
  1624. struct cm_id_private *cm_id_priv;
  1625. struct cm_drep_msg *drep_msg;
  1626. unsigned long flags;
  1627. int ret;
  1628. drep_msg = (struct cm_drep_msg *)work->mad_recv_wc->recv_buf.mad;
  1629. cm_id_priv = cm_acquire_id(drep_msg->remote_comm_id,
  1630. drep_msg->local_comm_id);
  1631. if (!cm_id_priv)
  1632. return -EINVAL;
  1633. work->cm_event.private_data = &drep_msg->private_data;
  1634. spin_lock_irqsave(&cm_id_priv->lock, flags);
  1635. if (cm_id_priv->id.state != IB_CM_DREQ_SENT &&
  1636. cm_id_priv->id.state != IB_CM_DREQ_RCVD) {
  1637. spin_unlock_irqrestore(&cm_id_priv->lock, flags);
  1638. goto out;
  1639. }
  1640. cm_enter_timewait(cm_id_priv);
  1641. ib_cancel_mad(cm_id_priv->av.port->mad_agent,
  1642. (unsigned long) cm_id_priv->msg);
  1643. ret = atomic_inc_and_test(&cm_id_priv->work_count);
  1644. if (!ret)
  1645. list_add_tail(&work->list, &cm_id_priv->work_list);
  1646. spin_unlock_irqrestore(&cm_id_priv->lock, flags);
  1647. if (ret)
  1648. cm_process_work(cm_id_priv, work);
  1649. else
  1650. cm_deref_id(cm_id_priv);
  1651. return 0;
  1652. out:
  1653. cm_deref_id(cm_id_priv);
  1654. return -EINVAL;
  1655. }
  1656. int ib_send_cm_rej(struct ib_cm_id *cm_id,
  1657. enum ib_cm_rej_reason reason,
  1658. void *ari,
  1659. u8 ari_length,
  1660. const void *private_data,
  1661. u8 private_data_len)
  1662. {
  1663. struct cm_id_private *cm_id_priv;
  1664. struct ib_mad_send_buf *msg;
  1665. struct ib_send_wr *bad_send_wr;
  1666. unsigned long flags;
  1667. int ret;
  1668. if ((private_data && private_data_len > IB_CM_REJ_PRIVATE_DATA_SIZE) ||
  1669. (ari && ari_length > IB_CM_REJ_ARI_LENGTH))
  1670. return -EINVAL;
  1671. cm_id_priv = container_of(cm_id, struct cm_id_private, id);
  1672. spin_lock_irqsave(&cm_id_priv->lock, flags);
  1673. switch (cm_id->state) {
  1674. case IB_CM_REQ_SENT:
  1675. case IB_CM_MRA_REQ_RCVD:
  1676. case IB_CM_REQ_RCVD:
  1677. case IB_CM_MRA_REQ_SENT:
  1678. case IB_CM_REP_RCVD:
  1679. case IB_CM_MRA_REP_SENT:
  1680. ret = cm_alloc_msg(cm_id_priv, &msg);
  1681. if (!ret)
  1682. cm_format_rej((struct cm_rej_msg *) msg->mad,
  1683. cm_id_priv, reason, ari, ari_length,
  1684. private_data, private_data_len);
  1685. cm_reset_to_idle(cm_id_priv);
  1686. break;
  1687. case IB_CM_REP_SENT:
  1688. case IB_CM_MRA_REP_RCVD:
  1689. ret = cm_alloc_msg(cm_id_priv, &msg);
  1690. if (!ret)
  1691. cm_format_rej((struct cm_rej_msg *) msg->mad,
  1692. cm_id_priv, reason, ari, ari_length,
  1693. private_data, private_data_len);
  1694. cm_enter_timewait(cm_id_priv);
  1695. break;
  1696. default:
  1697. ret = -EINVAL;
  1698. goto out;
  1699. }
  1700. if (ret)
  1701. goto out;
  1702. ret = ib_post_send_mad(cm_id_priv->av.port->mad_agent,
  1703. &msg->send_wr, &bad_send_wr);
  1704. if (ret)
  1705. cm_free_msg(msg);
  1706. out: spin_unlock_irqrestore(&cm_id_priv->lock, flags);
  1707. return ret;
  1708. }
  1709. EXPORT_SYMBOL(ib_send_cm_rej);
  1710. static void cm_format_rej_event(struct cm_work *work)
  1711. {
  1712. struct cm_rej_msg *rej_msg;
  1713. struct ib_cm_rej_event_param *param;
  1714. rej_msg = (struct cm_rej_msg *)work->mad_recv_wc->recv_buf.mad;
  1715. param = &work->cm_event.param.rej_rcvd;
  1716. param->ari = rej_msg->ari;
  1717. param->ari_length = cm_rej_get_reject_info_len(rej_msg);
  1718. param->reason = rej_msg->reason;
  1719. work->cm_event.private_data = &rej_msg->private_data;
  1720. }
  1721. static struct cm_id_private * cm_acquire_rejected_id(struct cm_rej_msg *rej_msg)
  1722. {
  1723. struct cm_timewait_info *timewait_info;
  1724. struct cm_id_private *cm_id_priv;
  1725. unsigned long flags;
  1726. u32 remote_id;
  1727. remote_id = rej_msg->local_comm_id;
  1728. if (rej_msg->reason == IB_CM_REJ_TIMEOUT) {
  1729. spin_lock_irqsave(&cm.lock, flags);
  1730. timewait_info = cm_find_remote_id( *((u64 *) rej_msg->ari),
  1731. remote_id);
  1732. if (!timewait_info) {
  1733. spin_unlock_irqrestore(&cm.lock, flags);
  1734. return NULL;
  1735. }
  1736. cm_id_priv = idr_find(&cm.local_id_table,
  1737. (int) timewait_info->work.local_id);
  1738. if (cm_id_priv) {
  1739. if (cm_id_priv->id.remote_id == remote_id)
  1740. atomic_inc(&cm_id_priv->refcount);
  1741. else
  1742. cm_id_priv = NULL;
  1743. }
  1744. spin_unlock_irqrestore(&cm.lock, flags);
  1745. } else if (cm_rej_get_msg_rejected(rej_msg) == CM_MSG_RESPONSE_REQ)
  1746. cm_id_priv = cm_acquire_id(rej_msg->remote_comm_id, 0);
  1747. else
  1748. cm_id_priv = cm_acquire_id(rej_msg->remote_comm_id, remote_id);
  1749. return cm_id_priv;
  1750. }
  1751. static int cm_rej_handler(struct cm_work *work)
  1752. {
  1753. struct cm_id_private *cm_id_priv;
  1754. struct cm_rej_msg *rej_msg;
  1755. unsigned long flags;
  1756. int ret;
  1757. rej_msg = (struct cm_rej_msg *)work->mad_recv_wc->recv_buf.mad;
  1758. cm_id_priv = cm_acquire_rejected_id(rej_msg);
  1759. if (!cm_id_priv)
  1760. return -EINVAL;
  1761. cm_format_rej_event(work);
  1762. spin_lock_irqsave(&cm_id_priv->lock, flags);
  1763. switch (cm_id_priv->id.state) {
  1764. case IB_CM_REQ_SENT:
  1765. case IB_CM_MRA_REQ_RCVD:
  1766. case IB_CM_REP_SENT:
  1767. case IB_CM_MRA_REP_RCVD:
  1768. ib_cancel_mad(cm_id_priv->av.port->mad_agent,
  1769. (unsigned long) cm_id_priv->msg);
  1770. /* fall through */
  1771. case IB_CM_REQ_RCVD:
  1772. case IB_CM_MRA_REQ_SENT:
  1773. if (rej_msg->reason == IB_CM_REJ_STALE_CONN)
  1774. cm_enter_timewait(cm_id_priv);
  1775. else
  1776. cm_reset_to_idle(cm_id_priv);
  1777. break;
  1778. case IB_CM_DREQ_SENT:
  1779. ib_cancel_mad(cm_id_priv->av.port->mad_agent,
  1780. (unsigned long) cm_id_priv->msg);
  1781. /* fall through */
  1782. case IB_CM_REP_RCVD:
  1783. case IB_CM_MRA_REP_SENT:
  1784. case IB_CM_ESTABLISHED:
  1785. cm_enter_timewait(cm_id_priv);
  1786. break;
  1787. default:
  1788. spin_unlock_irqrestore(&cm_id_priv->lock, flags);
  1789. ret = -EINVAL;
  1790. goto out;
  1791. }
  1792. ret = atomic_inc_and_test(&cm_id_priv->work_count);
  1793. if (!ret)
  1794. list_add_tail(&work->list, &cm_id_priv->work_list);
  1795. spin_unlock_irqrestore(&cm_id_priv->lock, flags);
  1796. if (ret)
  1797. cm_process_work(cm_id_priv, work);
  1798. else
  1799. cm_deref_id(cm_id_priv);
  1800. return 0;
  1801. out:
  1802. cm_deref_id(cm_id_priv);
  1803. return -EINVAL;
  1804. }
  1805. int ib_send_cm_mra(struct ib_cm_id *cm_id,
  1806. u8 service_timeout,
  1807. const void *private_data,
  1808. u8 private_data_len)
  1809. {
  1810. struct cm_id_private *cm_id_priv;
  1811. struct ib_mad_send_buf *msg;
  1812. struct ib_send_wr *bad_send_wr;
  1813. void *data;
  1814. unsigned long flags;
  1815. int ret;
  1816. if (private_data && private_data_len > IB_CM_MRA_PRIVATE_DATA_SIZE)
  1817. return -EINVAL;
  1818. data = cm_copy_private_data(private_data, private_data_len);
  1819. if (IS_ERR(data))
  1820. return PTR_ERR(data);
  1821. cm_id_priv = container_of(cm_id, struct cm_id_private, id);
  1822. spin_lock_irqsave(&cm_id_priv->lock, flags);
  1823. switch(cm_id_priv->id.state) {
  1824. case IB_CM_REQ_RCVD:
  1825. ret = cm_alloc_msg(cm_id_priv, &msg);
  1826. if (ret)
  1827. goto error1;
  1828. cm_format_mra((struct cm_mra_msg *) msg->mad, cm_id_priv,
  1829. CM_MSG_RESPONSE_REQ, service_timeout,
  1830. private_data, private_data_len);
  1831. ret = ib_post_send_mad(cm_id_priv->av.port->mad_agent,
  1832. &msg->send_wr, &bad_send_wr);
  1833. if (ret)
  1834. goto error2;
  1835. cm_id->state = IB_CM_MRA_REQ_SENT;
  1836. break;
  1837. case IB_CM_REP_RCVD:
  1838. ret = cm_alloc_msg(cm_id_priv, &msg);
  1839. if (ret)
  1840. goto error1;
  1841. cm_format_mra((struct cm_mra_msg *) msg->mad, cm_id_priv,
  1842. CM_MSG_RESPONSE_REP, service_timeout,
  1843. private_data, private_data_len);
  1844. ret = ib_post_send_mad(cm_id_priv->av.port->mad_agent,
  1845. &msg->send_wr, &bad_send_wr);
  1846. if (ret)
  1847. goto error2;
  1848. cm_id->state = IB_CM_MRA_REP_SENT;
  1849. break;
  1850. case IB_CM_ESTABLISHED:
  1851. ret = cm_alloc_msg(cm_id_priv, &msg);
  1852. if (ret)
  1853. goto error1;
  1854. cm_format_mra((struct cm_mra_msg *) msg->mad, cm_id_priv,
  1855. CM_MSG_RESPONSE_OTHER, service_timeout,
  1856. private_data, private_data_len);
  1857. ret = ib_post_send_mad(cm_id_priv->av.port->mad_agent,
  1858. &msg->send_wr, &bad_send_wr);
  1859. if (ret)
  1860. goto error2;
  1861. cm_id->lap_state = IB_CM_MRA_LAP_SENT;
  1862. break;
  1863. default:
  1864. ret = -EINVAL;
  1865. goto error1;
  1866. }
  1867. cm_id_priv->service_timeout = service_timeout;
  1868. cm_set_private_data(cm_id_priv, data, private_data_len);
  1869. spin_unlock_irqrestore(&cm_id_priv->lock, flags);
  1870. return 0;
  1871. error1: spin_unlock_irqrestore(&cm_id_priv->lock, flags);
  1872. kfree(data);
  1873. return ret;
  1874. error2: spin_unlock_irqrestore(&cm_id_priv->lock, flags);
  1875. kfree(data);
  1876. cm_free_msg(msg);
  1877. return ret;
  1878. }
  1879. EXPORT_SYMBOL(ib_send_cm_mra);
  1880. static struct cm_id_private * cm_acquire_mraed_id(struct cm_mra_msg *mra_msg)
  1881. {
  1882. switch (cm_mra_get_msg_mraed(mra_msg)) {
  1883. case CM_MSG_RESPONSE_REQ:
  1884. return cm_acquire_id(mra_msg->remote_comm_id, 0);
  1885. case CM_MSG_RESPONSE_REP:
  1886. case CM_MSG_RESPONSE_OTHER:
  1887. return cm_acquire_id(mra_msg->remote_comm_id,
  1888. mra_msg->local_comm_id);
  1889. default:
  1890. return NULL;
  1891. }
  1892. }
  1893. static int cm_mra_handler(struct cm_work *work)
  1894. {
  1895. struct cm_id_private *cm_id_priv;
  1896. struct cm_mra_msg *mra_msg;
  1897. unsigned long flags;
  1898. int timeout, ret;
  1899. mra_msg = (struct cm_mra_msg *)work->mad_recv_wc->recv_buf.mad;
  1900. cm_id_priv = cm_acquire_mraed_id(mra_msg);
  1901. if (!cm_id_priv)
  1902. return -EINVAL;
  1903. work->cm_event.private_data = &mra_msg->private_data;
  1904. work->cm_event.param.mra_rcvd.service_timeout =
  1905. cm_mra_get_service_timeout(mra_msg);
  1906. timeout = cm_convert_to_ms(cm_mra_get_service_timeout(mra_msg)) +
  1907. cm_convert_to_ms(cm_id_priv->av.packet_life_time);
  1908. spin_lock_irqsave(&cm_id_priv->lock, flags);
  1909. switch (cm_id_priv->id.state) {
  1910. case IB_CM_REQ_SENT:
  1911. if (cm_mra_get_msg_mraed(mra_msg) != CM_MSG_RESPONSE_REQ ||
  1912. ib_modify_mad(cm_id_priv->av.port->mad_agent,
  1913. (unsigned long) cm_id_priv->msg, timeout))
  1914. goto out;
  1915. cm_id_priv->id.state = IB_CM_MRA_REQ_RCVD;
  1916. break;
  1917. case IB_CM_REP_SENT:
  1918. if (cm_mra_get_msg_mraed(mra_msg) != CM_MSG_RESPONSE_REP ||
  1919. ib_modify_mad(cm_id_priv->av.port->mad_agent,
  1920. (unsigned long) cm_id_priv->msg, timeout))
  1921. goto out;
  1922. cm_id_priv->id.state = IB_CM_MRA_REP_RCVD;
  1923. break;
  1924. case IB_CM_ESTABLISHED:
  1925. if (cm_mra_get_msg_mraed(mra_msg) != CM_MSG_RESPONSE_OTHER ||
  1926. cm_id_priv->id.lap_state != IB_CM_LAP_SENT ||
  1927. ib_modify_mad(cm_id_priv->av.port->mad_agent,
  1928. (unsigned long) cm_id_priv->msg, timeout))
  1929. goto out;
  1930. cm_id_priv->id.lap_state = IB_CM_MRA_LAP_RCVD;
  1931. break;
  1932. default:
  1933. goto out;
  1934. }
  1935. cm_id_priv->msg->context[1] = (void *) (unsigned long)
  1936. cm_id_priv->id.state;
  1937. ret = atomic_inc_and_test(&cm_id_priv->work_count);
  1938. if (!ret)
  1939. list_add_tail(&work->list, &cm_id_priv->work_list);
  1940. spin_unlock_irqrestore(&cm_id_priv->lock, flags);
  1941. if (ret)
  1942. cm_process_work(cm_id_priv, work);
  1943. else
  1944. cm_deref_id(cm_id_priv);
  1945. return 0;
  1946. out:
  1947. spin_unlock_irqrestore(&cm_id_priv->lock, flags);
  1948. cm_deref_id(cm_id_priv);
  1949. return -EINVAL;
  1950. }
  1951. static void cm_format_lap(struct cm_lap_msg *lap_msg,
  1952. struct cm_id_private *cm_id_priv,
  1953. struct ib_sa_path_rec *alternate_path,
  1954. const void *private_data,
  1955. u8 private_data_len)
  1956. {
  1957. cm_format_mad_hdr(&lap_msg->hdr, CM_LAP_ATTR_ID,
  1958. cm_form_tid(cm_id_priv, CM_MSG_SEQUENCE_LAP));
  1959. lap_msg->local_comm_id = cm_id_priv->id.local_id;
  1960. lap_msg->remote_comm_id = cm_id_priv->id.remote_id;
  1961. cm_lap_set_remote_qpn(lap_msg, cm_id_priv->remote_qpn);
  1962. /* todo: need remote CM response timeout */
  1963. cm_lap_set_remote_resp_timeout(lap_msg, 0x1F);
  1964. lap_msg->alt_local_lid = alternate_path->slid;
  1965. lap_msg->alt_remote_lid = alternate_path->dlid;
  1966. lap_msg->alt_local_gid = alternate_path->sgid;
  1967. lap_msg->alt_remote_gid = alternate_path->dgid;
  1968. cm_lap_set_flow_label(lap_msg, alternate_path->flow_label);
  1969. cm_lap_set_traffic_class(lap_msg, alternate_path->traffic_class);
  1970. lap_msg->alt_hop_limit = alternate_path->hop_limit;
  1971. cm_lap_set_packet_rate(lap_msg, alternate_path->rate);
  1972. cm_lap_set_sl(lap_msg, alternate_path->sl);
  1973. cm_lap_set_subnet_local(lap_msg, 1); /* local only... */
  1974. cm_lap_set_local_ack_timeout(lap_msg,
  1975. min(31, alternate_path->packet_life_time + 1));
  1976. if (private_data && private_data_len)
  1977. memcpy(lap_msg->private_data, private_data, private_data_len);
  1978. }
  1979. int ib_send_cm_lap(struct ib_cm_id *cm_id,
  1980. struct ib_sa_path_rec *alternate_path,
  1981. const void *private_data,
  1982. u8 private_data_len)
  1983. {
  1984. struct cm_id_private *cm_id_priv;
  1985. struct ib_mad_send_buf *msg;
  1986. struct ib_send_wr *bad_send_wr;
  1987. unsigned long flags;
  1988. int ret;
  1989. if (private_data && private_data_len > IB_CM_LAP_PRIVATE_DATA_SIZE)
  1990. return -EINVAL;
  1991. cm_id_priv = container_of(cm_id, struct cm_id_private, id);
  1992. spin_lock_irqsave(&cm_id_priv->lock, flags);
  1993. if (cm_id->state != IB_CM_ESTABLISHED ||
  1994. cm_id->lap_state != IB_CM_LAP_IDLE) {
  1995. ret = -EINVAL;
  1996. goto out;
  1997. }
  1998. ret = cm_alloc_msg(cm_id_priv, &msg);
  1999. if (ret)
  2000. goto out;
  2001. cm_format_lap((struct cm_lap_msg *) msg->mad, cm_id_priv,
  2002. alternate_path, private_data, private_data_len);
  2003. msg->send_wr.wr.ud.timeout_ms = cm_id_priv->timeout_ms;
  2004. msg->context[1] = (void *) (unsigned long) IB_CM_ESTABLISHED;
  2005. ret = ib_post_send_mad(cm_id_priv->av.port->mad_agent,
  2006. &msg->send_wr, &bad_send_wr);
  2007. if (ret) {
  2008. spin_unlock_irqrestore(&cm_id_priv->lock, flags);
  2009. cm_free_msg(msg);
  2010. return ret;
  2011. }
  2012. cm_id->lap_state = IB_CM_LAP_SENT;
  2013. cm_id_priv->msg = msg;
  2014. out: spin_unlock_irqrestore(&cm_id_priv->lock, flags);
  2015. return ret;
  2016. }
  2017. EXPORT_SYMBOL(ib_send_cm_lap);
  2018. static void cm_format_path_from_lap(struct ib_sa_path_rec *path,
  2019. struct cm_lap_msg *lap_msg)
  2020. {
  2021. memset(path, 0, sizeof *path);
  2022. path->dgid = lap_msg->alt_local_gid;
  2023. path->sgid = lap_msg->alt_remote_gid;
  2024. path->dlid = lap_msg->alt_local_lid;
  2025. path->slid = lap_msg->alt_remote_lid;
  2026. path->flow_label = cm_lap_get_flow_label(lap_msg);
  2027. path->hop_limit = lap_msg->alt_hop_limit;
  2028. path->traffic_class = cm_lap_get_traffic_class(lap_msg);
  2029. path->reversible = 1;
  2030. /* pkey is same as in REQ */
  2031. path->sl = cm_lap_get_sl(lap_msg);
  2032. path->mtu_selector = IB_SA_EQ;
  2033. /* mtu is same as in REQ */
  2034. path->rate_selector = IB_SA_EQ;
  2035. path->rate = cm_lap_get_packet_rate(lap_msg);
  2036. path->packet_life_time_selector = IB_SA_EQ;
  2037. path->packet_life_time = cm_lap_get_local_ack_timeout(lap_msg);
  2038. path->packet_life_time -= (path->packet_life_time > 0);
  2039. }
  2040. static int cm_lap_handler(struct cm_work *work)
  2041. {
  2042. struct cm_id_private *cm_id_priv;
  2043. struct cm_lap_msg *lap_msg;
  2044. struct ib_cm_lap_event_param *param;
  2045. struct ib_mad_send_buf *msg = NULL;
  2046. struct ib_send_wr *bad_send_wr;
  2047. unsigned long flags;
  2048. int ret;
  2049. /* todo: verify LAP request and send reject APR if invalid. */
  2050. lap_msg = (struct cm_lap_msg *)work->mad_recv_wc->recv_buf.mad;
  2051. cm_id_priv = cm_acquire_id(lap_msg->remote_comm_id,
  2052. lap_msg->local_comm_id);
  2053. if (!cm_id_priv)
  2054. return -EINVAL;
  2055. param = &work->cm_event.param.lap_rcvd;
  2056. param->alternate_path = &work->path[0];
  2057. cm_format_path_from_lap(param->alternate_path, lap_msg);
  2058. work->cm_event.private_data = &lap_msg->private_data;
  2059. spin_lock_irqsave(&cm_id_priv->lock, flags);
  2060. if (cm_id_priv->id.state != IB_CM_ESTABLISHED)
  2061. goto unlock;
  2062. switch (cm_id_priv->id.lap_state) {
  2063. case IB_CM_LAP_IDLE:
  2064. break;
  2065. case IB_CM_MRA_LAP_SENT:
  2066. if (cm_alloc_response_msg(work->port, work->mad_recv_wc, &msg))
  2067. goto unlock;
  2068. cm_format_mra((struct cm_mra_msg *) msg->mad, cm_id_priv,
  2069. CM_MSG_RESPONSE_OTHER,
  2070. cm_id_priv->service_timeout,
  2071. cm_id_priv->private_data,
  2072. cm_id_priv->private_data_len);
  2073. spin_unlock_irqrestore(&cm_id_priv->lock, flags);
  2074. if (ib_post_send_mad(cm_id_priv->av.port->mad_agent,
  2075. &msg->send_wr, &bad_send_wr))
  2076. cm_free_msg(msg);
  2077. goto deref;
  2078. default:
  2079. goto unlock;
  2080. }
  2081. cm_id_priv->id.lap_state = IB_CM_LAP_RCVD;
  2082. cm_id_priv->tid = lap_msg->hdr.tid;
  2083. ret = atomic_inc_and_test(&cm_id_priv->work_count);
  2084. if (!ret)
  2085. list_add_tail(&work->list, &cm_id_priv->work_list);
  2086. spin_unlock_irqrestore(&cm_id_priv->lock, flags);
  2087. if (ret)
  2088. cm_process_work(cm_id_priv, work);
  2089. else
  2090. cm_deref_id(cm_id_priv);
  2091. return 0;
  2092. unlock: spin_unlock_irqrestore(&cm_id_priv->lock, flags);
  2093. deref: cm_deref_id(cm_id_priv);
  2094. return -EINVAL;
  2095. }
  2096. static void cm_format_apr(struct cm_apr_msg *apr_msg,
  2097. struct cm_id_private *cm_id_priv,
  2098. enum ib_cm_apr_status status,
  2099. void *info,
  2100. u8 info_length,
  2101. const void *private_data,
  2102. u8 private_data_len)
  2103. {
  2104. cm_format_mad_hdr(&apr_msg->hdr, CM_APR_ATTR_ID, cm_id_priv->tid);
  2105. apr_msg->local_comm_id = cm_id_priv->id.local_id;
  2106. apr_msg->remote_comm_id = cm_id_priv->id.remote_id;
  2107. apr_msg->ap_status = (u8) status;
  2108. if (info && info_length) {
  2109. apr_msg->info_length = info_length;
  2110. memcpy(apr_msg->info, info, info_length);
  2111. }
  2112. if (private_data && private_data_len)
  2113. memcpy(apr_msg->private_data, private_data, private_data_len);
  2114. }
  2115. int ib_send_cm_apr(struct ib_cm_id *cm_id,
  2116. enum ib_cm_apr_status status,
  2117. void *info,
  2118. u8 info_length,
  2119. const void *private_data,
  2120. u8 private_data_len)
  2121. {
  2122. struct cm_id_private *cm_id_priv;
  2123. struct ib_mad_send_buf *msg;
  2124. struct ib_send_wr *bad_send_wr;
  2125. unsigned long flags;
  2126. int ret;
  2127. if ((private_data && private_data_len > IB_CM_APR_PRIVATE_DATA_SIZE) ||
  2128. (info && info_length > IB_CM_APR_INFO_LENGTH))
  2129. return -EINVAL;
  2130. cm_id_priv = container_of(cm_id, struct cm_id_private, id);
  2131. spin_lock_irqsave(&cm_id_priv->lock, flags);
  2132. if (cm_id->state != IB_CM_ESTABLISHED ||
  2133. (cm_id->lap_state != IB_CM_LAP_RCVD &&
  2134. cm_id->lap_state != IB_CM_MRA_LAP_SENT)) {
  2135. ret = -EINVAL;
  2136. goto out;
  2137. }
  2138. ret = cm_alloc_msg(cm_id_priv, &msg);
  2139. if (ret)
  2140. goto out;
  2141. cm_format_apr((struct cm_apr_msg *) msg->mad, cm_id_priv, status,
  2142. info, info_length, private_data, private_data_len);
  2143. ret = ib_post_send_mad(cm_id_priv->av.port->mad_agent,
  2144. &msg->send_wr, &bad_send_wr);
  2145. if (ret) {
  2146. spin_unlock_irqrestore(&cm_id_priv->lock, flags);
  2147. cm_free_msg(msg);
  2148. return ret;
  2149. }
  2150. cm_id->lap_state = IB_CM_LAP_IDLE;
  2151. out: spin_unlock_irqrestore(&cm_id_priv->lock, flags);
  2152. return ret;
  2153. }
  2154. EXPORT_SYMBOL(ib_send_cm_apr);
  2155. static int cm_apr_handler(struct cm_work *work)
  2156. {
  2157. struct cm_id_private *cm_id_priv;
  2158. struct cm_apr_msg *apr_msg;
  2159. unsigned long flags;
  2160. int ret;
  2161. apr_msg = (struct cm_apr_msg *)work->mad_recv_wc->recv_buf.mad;
  2162. cm_id_priv = cm_acquire_id(apr_msg->remote_comm_id,
  2163. apr_msg->local_comm_id);
  2164. if (!cm_id_priv)
  2165. return -EINVAL; /* Unmatched reply. */
  2166. work->cm_event.param.apr_rcvd.ap_status = apr_msg->ap_status;
  2167. work->cm_event.param.apr_rcvd.apr_info = &apr_msg->info;
  2168. work->cm_event.param.apr_rcvd.info_len = apr_msg->info_length;
  2169. work->cm_event.private_data = &apr_msg->private_data;
  2170. spin_lock_irqsave(&cm_id_priv->lock, flags);
  2171. if (cm_id_priv->id.state != IB_CM_ESTABLISHED ||
  2172. (cm_id_priv->id.lap_state != IB_CM_LAP_SENT &&
  2173. cm_id_priv->id.lap_state != IB_CM_MRA_LAP_RCVD)) {
  2174. spin_unlock_irqrestore(&cm_id_priv->lock, flags);
  2175. goto out;
  2176. }
  2177. cm_id_priv->id.lap_state = IB_CM_LAP_IDLE;
  2178. ib_cancel_mad(cm_id_priv->av.port->mad_agent,
  2179. (unsigned long) cm_id_priv->msg);
  2180. cm_id_priv->msg = NULL;
  2181. ret = atomic_inc_and_test(&cm_id_priv->work_count);
  2182. if (!ret)
  2183. list_add_tail(&work->list, &cm_id_priv->work_list);
  2184. spin_unlock_irqrestore(&cm_id_priv->lock, flags);
  2185. if (ret)
  2186. cm_process_work(cm_id_priv, work);
  2187. else
  2188. cm_deref_id(cm_id_priv);
  2189. return 0;
  2190. out:
  2191. cm_deref_id(cm_id_priv);
  2192. return -EINVAL;
  2193. }
  2194. static int cm_timewait_handler(struct cm_work *work)
  2195. {
  2196. struct cm_timewait_info *timewait_info;
  2197. struct cm_id_private *cm_id_priv;
  2198. unsigned long flags;
  2199. int ret;
  2200. timewait_info = (struct cm_timewait_info *)work;
  2201. cm_cleanup_timewait(timewait_info);
  2202. cm_id_priv = cm_acquire_id(timewait_info->work.local_id,
  2203. timewait_info->work.remote_id);
  2204. if (!cm_id_priv)
  2205. return -EINVAL;
  2206. spin_lock_irqsave(&cm_id_priv->lock, flags);
  2207. if (cm_id_priv->id.state != IB_CM_TIMEWAIT ||
  2208. cm_id_priv->remote_qpn != timewait_info->remote_qpn) {
  2209. spin_unlock_irqrestore(&cm_id_priv->lock, flags);
  2210. goto out;
  2211. }
  2212. cm_id_priv->id.state = IB_CM_IDLE;
  2213. ret = atomic_inc_and_test(&cm_id_priv->work_count);
  2214. if (!ret)
  2215. list_add_tail(&work->list, &cm_id_priv->work_list);
  2216. spin_unlock_irqrestore(&cm_id_priv->lock, flags);
  2217. if (ret)
  2218. cm_process_work(cm_id_priv, work);
  2219. else
  2220. cm_deref_id(cm_id_priv);
  2221. return 0;
  2222. out:
  2223. cm_deref_id(cm_id_priv);
  2224. return -EINVAL;
  2225. }
  2226. static void cm_format_sidr_req(struct cm_sidr_req_msg *sidr_req_msg,
  2227. struct cm_id_private *cm_id_priv,
  2228. struct ib_cm_sidr_req_param *param)
  2229. {
  2230. cm_format_mad_hdr(&sidr_req_msg->hdr, CM_SIDR_REQ_ATTR_ID,
  2231. cm_form_tid(cm_id_priv, CM_MSG_SEQUENCE_SIDR));
  2232. sidr_req_msg->request_id = cm_id_priv->id.local_id;
  2233. sidr_req_msg->pkey = param->pkey;
  2234. sidr_req_msg->service_id = param->service_id;
  2235. if (param->private_data && param->private_data_len)
  2236. memcpy(sidr_req_msg->private_data, param->private_data,
  2237. param->private_data_len);
  2238. }
  2239. int ib_send_cm_sidr_req(struct ib_cm_id *cm_id,
  2240. struct ib_cm_sidr_req_param *param)
  2241. {
  2242. struct cm_id_private *cm_id_priv;
  2243. struct ib_mad_send_buf *msg;
  2244. struct ib_send_wr *bad_send_wr;
  2245. unsigned long flags;
  2246. int ret;
  2247. if (!param->path || (param->private_data &&
  2248. param->private_data_len > IB_CM_SIDR_REQ_PRIVATE_DATA_SIZE))
  2249. return -EINVAL;
  2250. cm_id_priv = container_of(cm_id, struct cm_id_private, id);
  2251. ret = cm_init_av_by_path(param->path, &cm_id_priv->av);
  2252. if (ret)
  2253. goto out;
  2254. cm_id->service_id = param->service_id;
  2255. cm_id->service_mask = ~0ULL;
  2256. cm_id_priv->timeout_ms = param->timeout_ms;
  2257. cm_id_priv->max_cm_retries = param->max_cm_retries;
  2258. ret = cm_alloc_msg(cm_id_priv, &msg);
  2259. if (ret)
  2260. goto out;
  2261. cm_format_sidr_req((struct cm_sidr_req_msg *) msg->mad, cm_id_priv,
  2262. param);
  2263. msg->send_wr.wr.ud.timeout_ms = cm_id_priv->timeout_ms;
  2264. msg->context[1] = (void *) (unsigned long) IB_CM_SIDR_REQ_SENT;
  2265. spin_lock_irqsave(&cm_id_priv->lock, flags);
  2266. if (cm_id->state == IB_CM_IDLE)
  2267. ret = ib_post_send_mad(cm_id_priv->av.port->mad_agent,
  2268. &msg->send_wr, &bad_send_wr);
  2269. else
  2270. ret = -EINVAL;
  2271. if (ret) {
  2272. spin_unlock_irqrestore(&cm_id_priv->lock, flags);
  2273. cm_free_msg(msg);
  2274. goto out;
  2275. }
  2276. cm_id->state = IB_CM_SIDR_REQ_SENT;
  2277. cm_id_priv->msg = msg;
  2278. spin_unlock_irqrestore(&cm_id_priv->lock, flags);
  2279. out:
  2280. return ret;
  2281. }
  2282. EXPORT_SYMBOL(ib_send_cm_sidr_req);
  2283. static void cm_format_sidr_req_event(struct cm_work *work,
  2284. struct ib_cm_id *listen_id)
  2285. {
  2286. struct cm_sidr_req_msg *sidr_req_msg;
  2287. struct ib_cm_sidr_req_event_param *param;
  2288. sidr_req_msg = (struct cm_sidr_req_msg *)
  2289. work->mad_recv_wc->recv_buf.mad;
  2290. param = &work->cm_event.param.sidr_req_rcvd;
  2291. param->pkey = sidr_req_msg->pkey;
  2292. param->listen_id = listen_id;
  2293. param->device = work->port->mad_agent->device;
  2294. param->port = work->port->port_num;
  2295. work->cm_event.private_data = &sidr_req_msg->private_data;
  2296. }
  2297. static int cm_sidr_req_handler(struct cm_work *work)
  2298. {
  2299. struct ib_cm_id *cm_id;
  2300. struct cm_id_private *cm_id_priv, *cur_cm_id_priv;
  2301. struct cm_sidr_req_msg *sidr_req_msg;
  2302. struct ib_wc *wc;
  2303. unsigned long flags;
  2304. cm_id = ib_create_cm_id(NULL, NULL);
  2305. if (IS_ERR(cm_id))
  2306. return PTR_ERR(cm_id);
  2307. cm_id_priv = container_of(cm_id, struct cm_id_private, id);
  2308. /* Record SGID/SLID and request ID for lookup. */
  2309. sidr_req_msg = (struct cm_sidr_req_msg *)
  2310. work->mad_recv_wc->recv_buf.mad;
  2311. wc = work->mad_recv_wc->wc;
  2312. cm_id_priv->av.dgid.global.subnet_prefix = wc->slid;
  2313. cm_id_priv->av.dgid.global.interface_id = 0;
  2314. cm_init_av_for_response(work->port, work->mad_recv_wc->wc,
  2315. &cm_id_priv->av);
  2316. cm_id_priv->id.remote_id = sidr_req_msg->request_id;
  2317. cm_id_priv->id.state = IB_CM_SIDR_REQ_RCVD;
  2318. cm_id_priv->tid = sidr_req_msg->hdr.tid;
  2319. atomic_inc(&cm_id_priv->work_count);
  2320. spin_lock_irqsave(&cm.lock, flags);
  2321. cur_cm_id_priv = cm_insert_remote_sidr(cm_id_priv);
  2322. if (cur_cm_id_priv) {
  2323. spin_unlock_irqrestore(&cm.lock, flags);
  2324. goto out; /* Duplicate message. */
  2325. }
  2326. cur_cm_id_priv = cm_find_listen(sidr_req_msg->service_id);
  2327. if (!cur_cm_id_priv) {
  2328. rb_erase(&cm_id_priv->sidr_id_node, &cm.remote_sidr_table);
  2329. spin_unlock_irqrestore(&cm.lock, flags);
  2330. /* todo: reply with no match */
  2331. goto out; /* No match. */
  2332. }
  2333. atomic_inc(&cur_cm_id_priv->refcount);
  2334. spin_unlock_irqrestore(&cm.lock, flags);
  2335. cm_id_priv->id.cm_handler = cur_cm_id_priv->id.cm_handler;
  2336. cm_id_priv->id.context = cur_cm_id_priv->id.context;
  2337. cm_id_priv->id.service_id = sidr_req_msg->service_id;
  2338. cm_id_priv->id.service_mask = ~0ULL;
  2339. cm_format_sidr_req_event(work, &cur_cm_id_priv->id);
  2340. cm_process_work(cm_id_priv, work);
  2341. cm_deref_id(cur_cm_id_priv);
  2342. return 0;
  2343. out:
  2344. ib_destroy_cm_id(&cm_id_priv->id);
  2345. return -EINVAL;
  2346. }
  2347. static void cm_format_sidr_rep(struct cm_sidr_rep_msg *sidr_rep_msg,
  2348. struct cm_id_private *cm_id_priv,
  2349. struct ib_cm_sidr_rep_param *param)
  2350. {
  2351. cm_format_mad_hdr(&sidr_rep_msg->hdr, CM_SIDR_REP_ATTR_ID,
  2352. cm_id_priv->tid);
  2353. sidr_rep_msg->request_id = cm_id_priv->id.remote_id;
  2354. sidr_rep_msg->status = param->status;
  2355. cm_sidr_rep_set_qpn(sidr_rep_msg, cpu_to_be32(param->qp_num));
  2356. sidr_rep_msg->service_id = cm_id_priv->id.service_id;
  2357. sidr_rep_msg->qkey = cpu_to_be32(param->qkey);
  2358. if (param->info && param->info_length)
  2359. memcpy(sidr_rep_msg->info, param->info, param->info_length);
  2360. if (param->private_data && param->private_data_len)
  2361. memcpy(sidr_rep_msg->private_data, param->private_data,
  2362. param->private_data_len);
  2363. }
  2364. int ib_send_cm_sidr_rep(struct ib_cm_id *cm_id,
  2365. struct ib_cm_sidr_rep_param *param)
  2366. {
  2367. struct cm_id_private *cm_id_priv;
  2368. struct ib_mad_send_buf *msg;
  2369. struct ib_send_wr *bad_send_wr;
  2370. unsigned long flags;
  2371. int ret;
  2372. if ((param->info && param->info_length > IB_CM_SIDR_REP_INFO_LENGTH) ||
  2373. (param->private_data &&
  2374. param->private_data_len > IB_CM_SIDR_REP_PRIVATE_DATA_SIZE))
  2375. return -EINVAL;
  2376. cm_id_priv = container_of(cm_id, struct cm_id_private, id);
  2377. spin_lock_irqsave(&cm_id_priv->lock, flags);
  2378. if (cm_id->state != IB_CM_SIDR_REQ_RCVD) {
  2379. ret = -EINVAL;
  2380. goto error;
  2381. }
  2382. ret = cm_alloc_msg(cm_id_priv, &msg);
  2383. if (ret)
  2384. goto error;
  2385. cm_format_sidr_rep((struct cm_sidr_rep_msg *) msg->mad, cm_id_priv,
  2386. param);
  2387. ret = ib_post_send_mad(cm_id_priv->av.port->mad_agent,
  2388. &msg->send_wr, &bad_send_wr);
  2389. if (ret) {
  2390. spin_unlock_irqrestore(&cm_id_priv->lock, flags);
  2391. cm_free_msg(msg);
  2392. return ret;
  2393. }
  2394. cm_id->state = IB_CM_IDLE;
  2395. spin_unlock_irqrestore(&cm_id_priv->lock, flags);
  2396. spin_lock_irqsave(&cm.lock, flags);
  2397. rb_erase(&cm_id_priv->sidr_id_node, &cm.remote_sidr_table);
  2398. spin_unlock_irqrestore(&cm.lock, flags);
  2399. return 0;
  2400. error: spin_unlock_irqrestore(&cm_id_priv->lock, flags);
  2401. return ret;
  2402. }
  2403. EXPORT_SYMBOL(ib_send_cm_sidr_rep);
  2404. static void cm_format_sidr_rep_event(struct cm_work *work)
  2405. {
  2406. struct cm_sidr_rep_msg *sidr_rep_msg;
  2407. struct ib_cm_sidr_rep_event_param *param;
  2408. sidr_rep_msg = (struct cm_sidr_rep_msg *)
  2409. work->mad_recv_wc->recv_buf.mad;
  2410. param = &work->cm_event.param.sidr_rep_rcvd;
  2411. param->status = sidr_rep_msg->status;
  2412. param->qkey = be32_to_cpu(sidr_rep_msg->qkey);
  2413. param->qpn = be32_to_cpu(cm_sidr_rep_get_qpn(sidr_rep_msg));
  2414. param->info = &sidr_rep_msg->info;
  2415. param->info_len = sidr_rep_msg->info_length;
  2416. work->cm_event.private_data = &sidr_rep_msg->private_data;
  2417. }
  2418. static int cm_sidr_rep_handler(struct cm_work *work)
  2419. {
  2420. struct cm_sidr_rep_msg *sidr_rep_msg;
  2421. struct cm_id_private *cm_id_priv;
  2422. unsigned long flags;
  2423. sidr_rep_msg = (struct cm_sidr_rep_msg *)
  2424. work->mad_recv_wc->recv_buf.mad;
  2425. cm_id_priv = cm_acquire_id(sidr_rep_msg->request_id, 0);
  2426. if (!cm_id_priv)
  2427. return -EINVAL; /* Unmatched reply. */
  2428. spin_lock_irqsave(&cm_id_priv->lock, flags);
  2429. if (cm_id_priv->id.state != IB_CM_SIDR_REQ_SENT) {
  2430. spin_unlock_irqrestore(&cm_id_priv->lock, flags);
  2431. goto out;
  2432. }
  2433. cm_id_priv->id.state = IB_CM_IDLE;
  2434. ib_cancel_mad(cm_id_priv->av.port->mad_agent,
  2435. (unsigned long) cm_id_priv->msg);
  2436. spin_unlock_irqrestore(&cm_id_priv->lock, flags);
  2437. cm_format_sidr_rep_event(work);
  2438. cm_process_work(cm_id_priv, work);
  2439. return 0;
  2440. out:
  2441. cm_deref_id(cm_id_priv);
  2442. return -EINVAL;
  2443. }
  2444. static void cm_process_send_error(struct ib_mad_send_buf *msg,
  2445. enum ib_wc_status wc_status)
  2446. {
  2447. struct cm_id_private *cm_id_priv;
  2448. struct ib_cm_event cm_event;
  2449. enum ib_cm_state state;
  2450. unsigned long flags;
  2451. int ret;
  2452. memset(&cm_event, 0, sizeof cm_event);
  2453. cm_id_priv = msg->context[0];
  2454. /* Discard old sends or ones without a response. */
  2455. spin_lock_irqsave(&cm_id_priv->lock, flags);
  2456. state = (enum ib_cm_state) (unsigned long) msg->context[1];
  2457. if (msg != cm_id_priv->msg || state != cm_id_priv->id.state)
  2458. goto discard;
  2459. switch (state) {
  2460. case IB_CM_REQ_SENT:
  2461. case IB_CM_MRA_REQ_RCVD:
  2462. cm_reset_to_idle(cm_id_priv);
  2463. cm_event.event = IB_CM_REQ_ERROR;
  2464. break;
  2465. case IB_CM_REP_SENT:
  2466. case IB_CM_MRA_REP_RCVD:
  2467. cm_reset_to_idle(cm_id_priv);
  2468. cm_event.event = IB_CM_REP_ERROR;
  2469. break;
  2470. case IB_CM_DREQ_SENT:
  2471. cm_enter_timewait(cm_id_priv);
  2472. cm_event.event = IB_CM_DREQ_ERROR;
  2473. break;
  2474. case IB_CM_SIDR_REQ_SENT:
  2475. cm_id_priv->id.state = IB_CM_IDLE;
  2476. cm_event.event = IB_CM_SIDR_REQ_ERROR;
  2477. break;
  2478. default:
  2479. goto discard;
  2480. }
  2481. spin_unlock_irqrestore(&cm_id_priv->lock, flags);
  2482. cm_event.param.send_status = wc_status;
  2483. /* No other events can occur on the cm_id at this point. */
  2484. ret = cm_id_priv->id.cm_handler(&cm_id_priv->id, &cm_event);
  2485. cm_free_msg(msg);
  2486. if (ret)
  2487. ib_destroy_cm_id(&cm_id_priv->id);
  2488. return;
  2489. discard:
  2490. spin_unlock_irqrestore(&cm_id_priv->lock, flags);
  2491. cm_free_msg(msg);
  2492. }
  2493. static void cm_send_handler(struct ib_mad_agent *mad_agent,
  2494. struct ib_mad_send_wc *mad_send_wc)
  2495. {
  2496. struct ib_mad_send_buf *msg;
  2497. msg = (struct ib_mad_send_buf *)(unsigned long)mad_send_wc->wr_id;
  2498. switch (mad_send_wc->status) {
  2499. case IB_WC_SUCCESS:
  2500. case IB_WC_WR_FLUSH_ERR:
  2501. cm_free_msg(msg);
  2502. break;
  2503. default:
  2504. if (msg->context[0] && msg->context[1])
  2505. cm_process_send_error(msg, mad_send_wc->status);
  2506. else
  2507. cm_free_msg(msg);
  2508. break;
  2509. }
  2510. }
  2511. static void cm_work_handler(void *data)
  2512. {
  2513. struct cm_work *work = data;
  2514. int ret;
  2515. switch (work->cm_event.event) {
  2516. case IB_CM_REQ_RECEIVED:
  2517. ret = cm_req_handler(work);
  2518. break;
  2519. case IB_CM_MRA_RECEIVED:
  2520. ret = cm_mra_handler(work);
  2521. break;
  2522. case IB_CM_REJ_RECEIVED:
  2523. ret = cm_rej_handler(work);
  2524. break;
  2525. case IB_CM_REP_RECEIVED:
  2526. ret = cm_rep_handler(work);
  2527. break;
  2528. case IB_CM_RTU_RECEIVED:
  2529. ret = cm_rtu_handler(work);
  2530. break;
  2531. case IB_CM_USER_ESTABLISHED:
  2532. ret = cm_establish_handler(work);
  2533. break;
  2534. case IB_CM_DREQ_RECEIVED:
  2535. ret = cm_dreq_handler(work);
  2536. break;
  2537. case IB_CM_DREP_RECEIVED:
  2538. ret = cm_drep_handler(work);
  2539. break;
  2540. case IB_CM_SIDR_REQ_RECEIVED:
  2541. ret = cm_sidr_req_handler(work);
  2542. break;
  2543. case IB_CM_SIDR_REP_RECEIVED:
  2544. ret = cm_sidr_rep_handler(work);
  2545. break;
  2546. case IB_CM_LAP_RECEIVED:
  2547. ret = cm_lap_handler(work);
  2548. break;
  2549. case IB_CM_APR_RECEIVED:
  2550. ret = cm_apr_handler(work);
  2551. break;
  2552. case IB_CM_TIMEWAIT_EXIT:
  2553. ret = cm_timewait_handler(work);
  2554. break;
  2555. default:
  2556. ret = -EINVAL;
  2557. break;
  2558. }
  2559. if (ret)
  2560. cm_free_work(work);
  2561. }
  2562. int ib_cm_establish(struct ib_cm_id *cm_id)
  2563. {
  2564. struct cm_id_private *cm_id_priv;
  2565. struct cm_work *work;
  2566. unsigned long flags;
  2567. int ret = 0;
  2568. work = kmalloc(sizeof *work, GFP_ATOMIC);
  2569. if (!work)
  2570. return -ENOMEM;
  2571. cm_id_priv = container_of(cm_id, struct cm_id_private, id);
  2572. spin_lock_irqsave(&cm_id_priv->lock, flags);
  2573. switch (cm_id->state)
  2574. {
  2575. case IB_CM_REP_SENT:
  2576. case IB_CM_MRA_REP_RCVD:
  2577. cm_id->state = IB_CM_ESTABLISHED;
  2578. break;
  2579. case IB_CM_ESTABLISHED:
  2580. ret = -EISCONN;
  2581. break;
  2582. default:
  2583. ret = -EINVAL;
  2584. break;
  2585. }
  2586. spin_unlock_irqrestore(&cm_id_priv->lock, flags);
  2587. if (ret) {
  2588. kfree(work);
  2589. goto out;
  2590. }
  2591. /*
  2592. * The CM worker thread may try to destroy the cm_id before it
  2593. * can execute this work item. To prevent potential deadlock,
  2594. * we need to find the cm_id once we're in the context of the
  2595. * worker thread, rather than holding a reference on it.
  2596. */
  2597. INIT_WORK(&work->work, cm_work_handler, work);
  2598. work->local_id = cm_id->local_id;
  2599. work->remote_id = cm_id->remote_id;
  2600. work->mad_recv_wc = NULL;
  2601. work->cm_event.event = IB_CM_USER_ESTABLISHED;
  2602. queue_work(cm.wq, &work->work);
  2603. out:
  2604. return ret;
  2605. }
  2606. EXPORT_SYMBOL(ib_cm_establish);
  2607. static void cm_recv_handler(struct ib_mad_agent *mad_agent,
  2608. struct ib_mad_recv_wc *mad_recv_wc)
  2609. {
  2610. struct cm_work *work;
  2611. enum ib_cm_event_type event;
  2612. int paths = 0;
  2613. switch (mad_recv_wc->recv_buf.mad->mad_hdr.attr_id) {
  2614. case CM_REQ_ATTR_ID:
  2615. paths = 1 + (((struct cm_req_msg *) mad_recv_wc->recv_buf.mad)->
  2616. alt_local_lid != 0);
  2617. event = IB_CM_REQ_RECEIVED;
  2618. break;
  2619. case CM_MRA_ATTR_ID:
  2620. event = IB_CM_MRA_RECEIVED;
  2621. break;
  2622. case CM_REJ_ATTR_ID:
  2623. event = IB_CM_REJ_RECEIVED;
  2624. break;
  2625. case CM_REP_ATTR_ID:
  2626. event = IB_CM_REP_RECEIVED;
  2627. break;
  2628. case CM_RTU_ATTR_ID:
  2629. event = IB_CM_RTU_RECEIVED;
  2630. break;
  2631. case CM_DREQ_ATTR_ID:
  2632. event = IB_CM_DREQ_RECEIVED;
  2633. break;
  2634. case CM_DREP_ATTR_ID:
  2635. event = IB_CM_DREP_RECEIVED;
  2636. break;
  2637. case CM_SIDR_REQ_ATTR_ID:
  2638. event = IB_CM_SIDR_REQ_RECEIVED;
  2639. break;
  2640. case CM_SIDR_REP_ATTR_ID:
  2641. event = IB_CM_SIDR_REP_RECEIVED;
  2642. break;
  2643. case CM_LAP_ATTR_ID:
  2644. paths = 1;
  2645. event = IB_CM_LAP_RECEIVED;
  2646. break;
  2647. case CM_APR_ATTR_ID:
  2648. event = IB_CM_APR_RECEIVED;
  2649. break;
  2650. default:
  2651. ib_free_recv_mad(mad_recv_wc);
  2652. return;
  2653. }
  2654. work = kmalloc(sizeof *work + sizeof(struct ib_sa_path_rec) * paths,
  2655. GFP_KERNEL);
  2656. if (!work) {
  2657. ib_free_recv_mad(mad_recv_wc);
  2658. return;
  2659. }
  2660. INIT_WORK(&work->work, cm_work_handler, work);
  2661. work->cm_event.event = event;
  2662. work->mad_recv_wc = mad_recv_wc;
  2663. work->port = (struct cm_port *)mad_agent->context;
  2664. queue_work(cm.wq, &work->work);
  2665. }
  2666. static int cm_init_qp_init_attr(struct cm_id_private *cm_id_priv,
  2667. struct ib_qp_attr *qp_attr,
  2668. int *qp_attr_mask)
  2669. {
  2670. unsigned long flags;
  2671. int ret;
  2672. spin_lock_irqsave(&cm_id_priv->lock, flags);
  2673. switch (cm_id_priv->id.state) {
  2674. case IB_CM_REQ_SENT:
  2675. case IB_CM_MRA_REQ_RCVD:
  2676. case IB_CM_REQ_RCVD:
  2677. case IB_CM_MRA_REQ_SENT:
  2678. case IB_CM_REP_RCVD:
  2679. case IB_CM_MRA_REP_SENT:
  2680. case IB_CM_REP_SENT:
  2681. case IB_CM_MRA_REP_RCVD:
  2682. case IB_CM_ESTABLISHED:
  2683. *qp_attr_mask = IB_QP_STATE | IB_QP_ACCESS_FLAGS |
  2684. IB_QP_PKEY_INDEX | IB_QP_PORT;
  2685. qp_attr->qp_access_flags = IB_ACCESS_LOCAL_WRITE;
  2686. if (cm_id_priv->responder_resources)
  2687. qp_attr->qp_access_flags |= IB_ACCESS_REMOTE_WRITE |
  2688. IB_ACCESS_REMOTE_READ;
  2689. qp_attr->pkey_index = cm_id_priv->av.pkey_index;
  2690. qp_attr->port_num = cm_id_priv->av.port->port_num;
  2691. ret = 0;
  2692. break;
  2693. default:
  2694. ret = -EINVAL;
  2695. break;
  2696. }
  2697. spin_unlock_irqrestore(&cm_id_priv->lock, flags);
  2698. return ret;
  2699. }
  2700. static int cm_init_qp_rtr_attr(struct cm_id_private *cm_id_priv,
  2701. struct ib_qp_attr *qp_attr,
  2702. int *qp_attr_mask)
  2703. {
  2704. unsigned long flags;
  2705. int ret;
  2706. spin_lock_irqsave(&cm_id_priv->lock, flags);
  2707. switch (cm_id_priv->id.state) {
  2708. case IB_CM_REQ_RCVD:
  2709. case IB_CM_MRA_REQ_SENT:
  2710. case IB_CM_REP_RCVD:
  2711. case IB_CM_MRA_REP_SENT:
  2712. case IB_CM_REP_SENT:
  2713. case IB_CM_MRA_REP_RCVD:
  2714. case IB_CM_ESTABLISHED:
  2715. *qp_attr_mask = IB_QP_STATE | IB_QP_AV | IB_QP_PATH_MTU |
  2716. IB_QP_DEST_QPN | IB_QP_RQ_PSN |
  2717. IB_QP_MAX_DEST_RD_ATOMIC | IB_QP_MIN_RNR_TIMER;
  2718. qp_attr->ah_attr = cm_id_priv->av.ah_attr;
  2719. qp_attr->path_mtu = cm_id_priv->path_mtu;
  2720. qp_attr->dest_qp_num = be32_to_cpu(cm_id_priv->remote_qpn);
  2721. qp_attr->rq_psn = be32_to_cpu(cm_id_priv->rq_psn);
  2722. qp_attr->max_dest_rd_atomic = cm_id_priv->responder_resources;
  2723. qp_attr->min_rnr_timer = 0;
  2724. if (cm_id_priv->alt_av.ah_attr.dlid) {
  2725. *qp_attr_mask |= IB_QP_ALT_PATH;
  2726. qp_attr->alt_ah_attr = cm_id_priv->alt_av.ah_attr;
  2727. }
  2728. ret = 0;
  2729. break;
  2730. default:
  2731. ret = -EINVAL;
  2732. break;
  2733. }
  2734. spin_unlock_irqrestore(&cm_id_priv->lock, flags);
  2735. return ret;
  2736. }
  2737. static int cm_init_qp_rts_attr(struct cm_id_private *cm_id_priv,
  2738. struct ib_qp_attr *qp_attr,
  2739. int *qp_attr_mask)
  2740. {
  2741. unsigned long flags;
  2742. int ret;
  2743. spin_lock_irqsave(&cm_id_priv->lock, flags);
  2744. switch (cm_id_priv->id.state) {
  2745. case IB_CM_REP_RCVD:
  2746. case IB_CM_MRA_REP_SENT:
  2747. case IB_CM_REP_SENT:
  2748. case IB_CM_MRA_REP_RCVD:
  2749. case IB_CM_ESTABLISHED:
  2750. *qp_attr_mask = IB_QP_STATE | IB_QP_TIMEOUT | IB_QP_RETRY_CNT |
  2751. IB_QP_RNR_RETRY | IB_QP_SQ_PSN |
  2752. IB_QP_MAX_QP_RD_ATOMIC;
  2753. qp_attr->timeout = cm_id_priv->local_ack_timeout;
  2754. qp_attr->retry_cnt = cm_id_priv->retry_count;
  2755. qp_attr->rnr_retry = cm_id_priv->rnr_retry_count;
  2756. qp_attr->sq_psn = be32_to_cpu(cm_id_priv->sq_psn);
  2757. qp_attr->max_rd_atomic = cm_id_priv->initiator_depth;
  2758. if (cm_id_priv->alt_av.ah_attr.dlid) {
  2759. *qp_attr_mask |= IB_QP_PATH_MIG_STATE;
  2760. qp_attr->path_mig_state = IB_MIG_REARM;
  2761. }
  2762. ret = 0;
  2763. break;
  2764. default:
  2765. ret = -EINVAL;
  2766. break;
  2767. }
  2768. spin_unlock_irqrestore(&cm_id_priv->lock, flags);
  2769. return ret;
  2770. }
  2771. int ib_cm_init_qp_attr(struct ib_cm_id *cm_id,
  2772. struct ib_qp_attr *qp_attr,
  2773. int *qp_attr_mask)
  2774. {
  2775. struct cm_id_private *cm_id_priv;
  2776. int ret;
  2777. cm_id_priv = container_of(cm_id, struct cm_id_private, id);
  2778. switch (qp_attr->qp_state) {
  2779. case IB_QPS_INIT:
  2780. ret = cm_init_qp_init_attr(cm_id_priv, qp_attr, qp_attr_mask);
  2781. break;
  2782. case IB_QPS_RTR:
  2783. ret = cm_init_qp_rtr_attr(cm_id_priv, qp_attr, qp_attr_mask);
  2784. break;
  2785. case IB_QPS_RTS:
  2786. ret = cm_init_qp_rts_attr(cm_id_priv, qp_attr, qp_attr_mask);
  2787. break;
  2788. default:
  2789. ret = -EINVAL;
  2790. break;
  2791. }
  2792. return ret;
  2793. }
  2794. EXPORT_SYMBOL(ib_cm_init_qp_attr);
  2795. static u64 cm_get_ca_guid(struct ib_device *device)
  2796. {
  2797. struct ib_device_attr *device_attr;
  2798. u64 guid;
  2799. int ret;
  2800. device_attr = kmalloc(sizeof *device_attr, GFP_KERNEL);
  2801. if (!device_attr)
  2802. return 0;
  2803. ret = ib_query_device(device, device_attr);
  2804. guid = ret ? 0 : device_attr->node_guid;
  2805. kfree(device_attr);
  2806. return guid;
  2807. }
  2808. static void cm_add_one(struct ib_device *device)
  2809. {
  2810. struct cm_device *cm_dev;
  2811. struct cm_port *port;
  2812. struct ib_mad_reg_req reg_req = {
  2813. .mgmt_class = IB_MGMT_CLASS_CM,
  2814. .mgmt_class_version = IB_CM_CLASS_VERSION
  2815. };
  2816. struct ib_port_modify port_modify = {
  2817. .set_port_cap_mask = IB_PORT_CM_SUP
  2818. };
  2819. unsigned long flags;
  2820. int ret;
  2821. u8 i;
  2822. cm_dev = kmalloc(sizeof(*cm_dev) + sizeof(*port) *
  2823. device->phys_port_cnt, GFP_KERNEL);
  2824. if (!cm_dev)
  2825. return;
  2826. cm_dev->device = device;
  2827. cm_dev->ca_guid = cm_get_ca_guid(device);
  2828. if (!cm_dev->ca_guid)
  2829. goto error1;
  2830. set_bit(IB_MGMT_METHOD_SEND, reg_req.method_mask);
  2831. for (i = 1; i <= device->phys_port_cnt; i++) {
  2832. port = &cm_dev->port[i-1];
  2833. port->cm_dev = cm_dev;
  2834. port->port_num = i;
  2835. port->mad_agent = ib_register_mad_agent(device, i,
  2836. IB_QPT_GSI,
  2837. &reg_req,
  2838. 0,
  2839. cm_send_handler,
  2840. cm_recv_handler,
  2841. port);
  2842. if (IS_ERR(port->mad_agent))
  2843. goto error2;
  2844. ret = ib_modify_port(device, i, 0, &port_modify);
  2845. if (ret)
  2846. goto error3;
  2847. }
  2848. ib_set_client_data(device, &cm_client, cm_dev);
  2849. write_lock_irqsave(&cm.device_lock, flags);
  2850. list_add_tail(&cm_dev->list, &cm.device_list);
  2851. write_unlock_irqrestore(&cm.device_lock, flags);
  2852. return;
  2853. error3:
  2854. ib_unregister_mad_agent(port->mad_agent);
  2855. error2:
  2856. port_modify.set_port_cap_mask = 0;
  2857. port_modify.clr_port_cap_mask = IB_PORT_CM_SUP;
  2858. while (--i) {
  2859. port = &cm_dev->port[i-1];
  2860. ib_modify_port(device, port->port_num, 0, &port_modify);
  2861. ib_unregister_mad_agent(port->mad_agent);
  2862. }
  2863. error1:
  2864. kfree(cm_dev);
  2865. }
  2866. static void cm_remove_one(struct ib_device *device)
  2867. {
  2868. struct cm_device *cm_dev;
  2869. struct cm_port *port;
  2870. struct ib_port_modify port_modify = {
  2871. .clr_port_cap_mask = IB_PORT_CM_SUP
  2872. };
  2873. unsigned long flags;
  2874. int i;
  2875. cm_dev = ib_get_client_data(device, &cm_client);
  2876. if (!cm_dev)
  2877. return;
  2878. write_lock_irqsave(&cm.device_lock, flags);
  2879. list_del(&cm_dev->list);
  2880. write_unlock_irqrestore(&cm.device_lock, flags);
  2881. for (i = 1; i <= device->phys_port_cnt; i++) {
  2882. port = &cm_dev->port[i-1];
  2883. ib_modify_port(device, port->port_num, 0, &port_modify);
  2884. ib_unregister_mad_agent(port->mad_agent);
  2885. }
  2886. kfree(cm_dev);
  2887. }
  2888. static int __init ib_cm_init(void)
  2889. {
  2890. int ret;
  2891. memset(&cm, 0, sizeof cm);
  2892. INIT_LIST_HEAD(&cm.device_list);
  2893. rwlock_init(&cm.device_lock);
  2894. spin_lock_init(&cm.lock);
  2895. cm.listen_service_table = RB_ROOT;
  2896. cm.listen_service_id = __constant_be64_to_cpu(IB_CM_ASSIGN_SERVICE_ID);
  2897. cm.remote_id_table = RB_ROOT;
  2898. cm.remote_qp_table = RB_ROOT;
  2899. cm.remote_sidr_table = RB_ROOT;
  2900. idr_init(&cm.local_id_table);
  2901. idr_pre_get(&cm.local_id_table, GFP_KERNEL);
  2902. cm.wq = create_workqueue("ib_cm");
  2903. if (!cm.wq)
  2904. return -ENOMEM;
  2905. ret = ib_register_client(&cm_client);
  2906. if (ret)
  2907. goto error;
  2908. return 0;
  2909. error:
  2910. destroy_workqueue(cm.wq);
  2911. return ret;
  2912. }
  2913. static void __exit ib_cm_cleanup(void)
  2914. {
  2915. flush_workqueue(cm.wq);
  2916. destroy_workqueue(cm.wq);
  2917. ib_unregister_client(&cm_client);
  2918. }
  2919. module_init(ib_cm_init);
  2920. module_exit(ib_cm_cleanup);