ib_srp.c 55 KB

1234567891011121314151617181920212223242526272829303132333435363738394041424344454647484950515253545556575859606162636465666768697071727374757677787980818283848586878889909192939495969798991001011021031041051061071081091101111121131141151161171181191201211221231241251261271281291301311321331341351361371381391401411421431441451461471481491501511521531541551561571581591601611621631641651661671681691701711721731741751761771781791801811821831841851861871881891901911921931941951961971981992002012022032042052062072082092102112122132142152162172182192202212222232242252262272282292302312322332342352362372382392402412422432442452462472482492502512522532542552562572582592602612622632642652662672682692702712722732742752762772782792802812822832842852862872882892902912922932942952962972982993003013023033043053063073083093103113123133143153163173183193203213223233243253263273283293303313323333343353363373383393403413423433443453463473483493503513523533543553563573583593603613623633643653663673683693703713723733743753763773783793803813823833843853863873883893903913923933943953963973983994004014024034044054064074084094104114124134144154164174184194204214224234244254264274284294304314324334344354364374384394404414424434444454464474484494504514524534544554564574584594604614624634644654664674684694704714724734744754764774784794804814824834844854864874884894904914924934944954964974984995005015025035045055065075085095105115125135145155165175185195205215225235245255265275285295305315325335345355365375385395405415425435445455465475485495505515525535545555565575585595605615625635645655665675685695705715725735745755765775785795805815825835845855865875885895905915925935945955965975985996006016026036046056066076086096106116126136146156166176186196206216226236246256266276286296306316326336346356366376386396406416426436446456466476486496506516526536546556566576586596606616626636646656666676686696706716726736746756766776786796806816826836846856866876886896906916926936946956966976986997007017027037047057067077087097107117127137147157167177187197207217227237247257267277287297307317327337347357367377387397407417427437447457467477487497507517527537547557567577587597607617627637647657667677687697707717727737747757767777787797807817827837847857867877887897907917927937947957967977987998008018028038048058068078088098108118128138148158168178188198208218228238248258268278288298308318328338348358368378388398408418428438448458468478488498508518528538548558568578588598608618628638648658668678688698708718728738748758768778788798808818828838848858868878888898908918928938948958968978988999009019029039049059069079089099109119129139149159169179189199209219229239249259269279289299309319329339349359369379389399409419429439449459469479489499509519529539549559569579589599609619629639649659669679689699709719729739749759769779789799809819829839849859869879889899909919929939949959969979989991000100110021003100410051006100710081009101010111012101310141015101610171018101910201021102210231024102510261027102810291030103110321033103410351036103710381039104010411042104310441045104610471048104910501051105210531054105510561057105810591060106110621063106410651066106710681069107010711072107310741075107610771078107910801081108210831084108510861087108810891090109110921093109410951096109710981099110011011102110311041105110611071108110911101111111211131114111511161117111811191120112111221123112411251126112711281129113011311132113311341135113611371138113911401141114211431144114511461147114811491150115111521153115411551156115711581159116011611162116311641165116611671168116911701171117211731174117511761177117811791180118111821183118411851186118711881189119011911192119311941195119611971198119912001201120212031204120512061207120812091210121112121213121412151216121712181219122012211222122312241225122612271228122912301231123212331234123512361237123812391240124112421243124412451246124712481249125012511252125312541255125612571258125912601261126212631264126512661267126812691270127112721273127412751276127712781279128012811282128312841285128612871288128912901291129212931294129512961297129812991300130113021303130413051306130713081309131013111312131313141315131613171318131913201321132213231324132513261327132813291330133113321333133413351336133713381339134013411342134313441345134613471348134913501351135213531354135513561357135813591360136113621363136413651366136713681369137013711372137313741375137613771378137913801381138213831384138513861387138813891390139113921393139413951396139713981399140014011402140314041405140614071408140914101411141214131414141514161417141814191420142114221423142414251426142714281429143014311432143314341435143614371438143914401441144214431444144514461447144814491450145114521453145414551456145714581459146014611462146314641465146614671468146914701471147214731474147514761477147814791480148114821483148414851486148714881489149014911492149314941495149614971498149915001501150215031504150515061507150815091510151115121513151415151516151715181519152015211522152315241525152615271528152915301531153215331534153515361537153815391540154115421543154415451546154715481549155015511552155315541555155615571558155915601561156215631564156515661567156815691570157115721573157415751576157715781579158015811582158315841585158615871588158915901591159215931594159515961597159815991600160116021603160416051606160716081609161016111612161316141615161616171618161916201621162216231624162516261627162816291630163116321633163416351636163716381639164016411642164316441645164616471648164916501651165216531654165516561657165816591660166116621663166416651666166716681669167016711672167316741675167616771678167916801681168216831684168516861687168816891690169116921693169416951696169716981699170017011702170317041705170617071708170917101711171217131714171517161717171817191720172117221723172417251726172717281729173017311732173317341735173617371738173917401741174217431744174517461747174817491750175117521753175417551756175717581759176017611762176317641765176617671768176917701771177217731774177517761777177817791780178117821783178417851786178717881789179017911792179317941795179617971798179918001801180218031804180518061807180818091810181118121813181418151816181718181819182018211822182318241825182618271828182918301831183218331834183518361837183818391840184118421843184418451846184718481849185018511852185318541855185618571858185918601861186218631864186518661867186818691870187118721873187418751876187718781879188018811882188318841885188618871888188918901891189218931894189518961897189818991900190119021903190419051906190719081909191019111912191319141915191619171918191919201921192219231924192519261927192819291930193119321933193419351936193719381939194019411942194319441945194619471948194919501951195219531954195519561957195819591960196119621963196419651966196719681969197019711972197319741975197619771978197919801981198219831984198519861987198819891990199119921993199419951996199719981999200020012002200320042005200620072008200920102011201220132014201520162017201820192020202120222023202420252026202720282029203020312032203320342035203620372038203920402041204220432044204520462047204820492050205120522053205420552056205720582059206020612062206320642065206620672068206920702071207220732074207520762077207820792080208120822083208420852086208720882089209020912092209320942095209620972098209921002101210221032104210521062107210821092110211121122113211421152116211721182119212021212122212321242125212621272128212921302131213221332134213521362137213821392140214121422143214421452146214721482149215021512152215321542155215621572158215921602161216221632164216521662167216821692170217121722173217421752176217721782179218021812182218321842185218621872188218921902191219221932194219521962197219821992200
  1. /*
  2. * Copyright (c) 2005 Cisco Systems. All rights reserved.
  3. *
  4. * This software is available to you under a choice of one of two
  5. * licenses. You may choose to be licensed under the terms of the GNU
  6. * General Public License (GPL) Version 2, available from the file
  7. * COPYING in the main directory of this source tree, or the
  8. * OpenIB.org BSD license below:
  9. *
  10. * Redistribution and use in source and binary forms, with or
  11. * without modification, are permitted provided that the following
  12. * conditions are met:
  13. *
  14. * - Redistributions of source code must retain the above
  15. * copyright notice, this list of conditions and the following
  16. * disclaimer.
  17. *
  18. * - Redistributions in binary form must reproduce the above
  19. * copyright notice, this list of conditions and the following
  20. * disclaimer in the documentation and/or other materials
  21. * provided with the distribution.
  22. *
  23. * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
  24. * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
  25. * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
  26. * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
  27. * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
  28. * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
  29. * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
  30. * SOFTWARE.
  31. */
  32. #include <linux/module.h>
  33. #include <linux/init.h>
  34. #include <linux/slab.h>
  35. #include <linux/err.h>
  36. #include <linux/string.h>
  37. #include <linux/parser.h>
  38. #include <linux/random.h>
  39. #include <linux/jiffies.h>
  40. #include <asm/atomic.h>
  41. #include <scsi/scsi.h>
  42. #include <scsi/scsi_device.h>
  43. #include <scsi/scsi_dbg.h>
  44. #include <scsi/srp.h>
  45. #include <scsi/scsi_transport_srp.h>
  46. #include "ib_srp.h"
  47. #define DRV_NAME "ib_srp"
  48. #define PFX DRV_NAME ": "
  49. #define DRV_VERSION "0.2"
  50. #define DRV_RELDATE "November 1, 2005"
  51. MODULE_AUTHOR("Roland Dreier");
  52. MODULE_DESCRIPTION("InfiniBand SCSI RDMA Protocol initiator "
  53. "v" DRV_VERSION " (" DRV_RELDATE ")");
  54. MODULE_LICENSE("Dual BSD/GPL");
  55. static int srp_sg_tablesize = SRP_DEF_SG_TABLESIZE;
  56. static int srp_max_iu_len;
  57. module_param(srp_sg_tablesize, int, 0444);
  58. MODULE_PARM_DESC(srp_sg_tablesize,
  59. "Max number of gather/scatter entries per I/O (default is 12, max 255)");
  60. static int topspin_workarounds = 1;
  61. module_param(topspin_workarounds, int, 0444);
  62. MODULE_PARM_DESC(topspin_workarounds,
  63. "Enable workarounds for Topspin/Cisco SRP target bugs if != 0");
  64. static int mellanox_workarounds = 1;
  65. module_param(mellanox_workarounds, int, 0444);
  66. MODULE_PARM_DESC(mellanox_workarounds,
  67. "Enable workarounds for Mellanox SRP target bugs if != 0");
  68. static void srp_add_one(struct ib_device *device);
  69. static void srp_remove_one(struct ib_device *device);
  70. static void srp_recv_completion(struct ib_cq *cq, void *target_ptr);
  71. static void srp_send_completion(struct ib_cq *cq, void *target_ptr);
  72. static int srp_cm_handler(struct ib_cm_id *cm_id, struct ib_cm_event *event);
  73. static struct scsi_transport_template *ib_srp_transport_template;
  74. static struct ib_client srp_client = {
  75. .name = "srp",
  76. .add = srp_add_one,
  77. .remove = srp_remove_one
  78. };
  79. static struct ib_sa_client srp_sa_client;
  80. static inline struct srp_target_port *host_to_target(struct Scsi_Host *host)
  81. {
  82. return (struct srp_target_port *) host->hostdata;
  83. }
  84. static const char *srp_target_info(struct Scsi_Host *host)
  85. {
  86. return host_to_target(host)->target_name;
  87. }
  88. static int srp_target_is_topspin(struct srp_target_port *target)
  89. {
  90. static const u8 topspin_oui[3] = { 0x00, 0x05, 0xad };
  91. static const u8 cisco_oui[3] = { 0x00, 0x1b, 0x0d };
  92. return topspin_workarounds &&
  93. (!memcmp(&target->ioc_guid, topspin_oui, sizeof topspin_oui) ||
  94. !memcmp(&target->ioc_guid, cisco_oui, sizeof cisco_oui));
  95. }
  96. static int srp_target_is_mellanox(struct srp_target_port *target)
  97. {
  98. static const u8 mellanox_oui[3] = { 0x00, 0x02, 0xc9 };
  99. return mellanox_workarounds &&
  100. !memcmp(&target->ioc_guid, mellanox_oui, sizeof mellanox_oui);
  101. }
  102. static struct srp_iu *srp_alloc_iu(struct srp_host *host, size_t size,
  103. gfp_t gfp_mask,
  104. enum dma_data_direction direction)
  105. {
  106. struct srp_iu *iu;
  107. iu = kmalloc(sizeof *iu, gfp_mask);
  108. if (!iu)
  109. goto out;
  110. iu->buf = kzalloc(size, gfp_mask);
  111. if (!iu->buf)
  112. goto out_free_iu;
  113. iu->dma = ib_dma_map_single(host->srp_dev->dev, iu->buf, size,
  114. direction);
  115. if (ib_dma_mapping_error(host->srp_dev->dev, iu->dma))
  116. goto out_free_buf;
  117. iu->size = size;
  118. iu->direction = direction;
  119. return iu;
  120. out_free_buf:
  121. kfree(iu->buf);
  122. out_free_iu:
  123. kfree(iu);
  124. out:
  125. return NULL;
  126. }
  127. static void srp_free_iu(struct srp_host *host, struct srp_iu *iu)
  128. {
  129. if (!iu)
  130. return;
  131. ib_dma_unmap_single(host->srp_dev->dev, iu->dma, iu->size,
  132. iu->direction);
  133. kfree(iu->buf);
  134. kfree(iu);
  135. }
  136. static void srp_qp_event(struct ib_event *event, void *context)
  137. {
  138. printk(KERN_ERR PFX "QP event %d\n", event->event);
  139. }
  140. static int srp_init_qp(struct srp_target_port *target,
  141. struct ib_qp *qp)
  142. {
  143. struct ib_qp_attr *attr;
  144. int ret;
  145. attr = kmalloc(sizeof *attr, GFP_KERNEL);
  146. if (!attr)
  147. return -ENOMEM;
  148. ret = ib_find_pkey(target->srp_host->srp_dev->dev,
  149. target->srp_host->port,
  150. be16_to_cpu(target->path.pkey),
  151. &attr->pkey_index);
  152. if (ret)
  153. goto out;
  154. attr->qp_state = IB_QPS_INIT;
  155. attr->qp_access_flags = (IB_ACCESS_REMOTE_READ |
  156. IB_ACCESS_REMOTE_WRITE);
  157. attr->port_num = target->srp_host->port;
  158. ret = ib_modify_qp(qp, attr,
  159. IB_QP_STATE |
  160. IB_QP_PKEY_INDEX |
  161. IB_QP_ACCESS_FLAGS |
  162. IB_QP_PORT);
  163. out:
  164. kfree(attr);
  165. return ret;
  166. }
  167. static int srp_new_cm_id(struct srp_target_port *target)
  168. {
  169. struct ib_cm_id *new_cm_id;
  170. new_cm_id = ib_create_cm_id(target->srp_host->srp_dev->dev,
  171. srp_cm_handler, target);
  172. if (IS_ERR(new_cm_id))
  173. return PTR_ERR(new_cm_id);
  174. if (target->cm_id)
  175. ib_destroy_cm_id(target->cm_id);
  176. target->cm_id = new_cm_id;
  177. return 0;
  178. }
  179. static int srp_create_target_ib(struct srp_target_port *target)
  180. {
  181. struct ib_qp_init_attr *init_attr;
  182. int ret;
  183. init_attr = kzalloc(sizeof *init_attr, GFP_KERNEL);
  184. if (!init_attr)
  185. return -ENOMEM;
  186. target->recv_cq = ib_create_cq(target->srp_host->srp_dev->dev,
  187. srp_recv_completion, NULL, target, SRP_RQ_SIZE, 0);
  188. if (IS_ERR(target->recv_cq)) {
  189. ret = PTR_ERR(target->recv_cq);
  190. goto out;
  191. }
  192. target->send_cq = ib_create_cq(target->srp_host->srp_dev->dev,
  193. srp_send_completion, NULL, target, SRP_SQ_SIZE, 0);
  194. if (IS_ERR(target->send_cq)) {
  195. ret = PTR_ERR(target->send_cq);
  196. ib_destroy_cq(target->recv_cq);
  197. goto out;
  198. }
  199. ib_req_notify_cq(target->recv_cq, IB_CQ_NEXT_COMP);
  200. init_attr->event_handler = srp_qp_event;
  201. init_attr->cap.max_send_wr = SRP_SQ_SIZE;
  202. init_attr->cap.max_recv_wr = SRP_RQ_SIZE;
  203. init_attr->cap.max_recv_sge = 1;
  204. init_attr->cap.max_send_sge = 1;
  205. init_attr->sq_sig_type = IB_SIGNAL_ALL_WR;
  206. init_attr->qp_type = IB_QPT_RC;
  207. init_attr->send_cq = target->send_cq;
  208. init_attr->recv_cq = target->recv_cq;
  209. target->qp = ib_create_qp(target->srp_host->srp_dev->pd, init_attr);
  210. if (IS_ERR(target->qp)) {
  211. ret = PTR_ERR(target->qp);
  212. ib_destroy_cq(target->send_cq);
  213. ib_destroy_cq(target->recv_cq);
  214. goto out;
  215. }
  216. ret = srp_init_qp(target, target->qp);
  217. if (ret) {
  218. ib_destroy_qp(target->qp);
  219. ib_destroy_cq(target->send_cq);
  220. ib_destroy_cq(target->recv_cq);
  221. goto out;
  222. }
  223. out:
  224. kfree(init_attr);
  225. return ret;
  226. }
  227. static void srp_free_target_ib(struct srp_target_port *target)
  228. {
  229. int i;
  230. ib_destroy_qp(target->qp);
  231. ib_destroy_cq(target->send_cq);
  232. ib_destroy_cq(target->recv_cq);
  233. for (i = 0; i < SRP_RQ_SIZE; ++i)
  234. srp_free_iu(target->srp_host, target->rx_ring[i]);
  235. for (i = 0; i < SRP_SQ_SIZE + 1; ++i)
  236. srp_free_iu(target->srp_host, target->tx_ring[i]);
  237. }
  238. static void srp_path_rec_completion(int status,
  239. struct ib_sa_path_rec *pathrec,
  240. void *target_ptr)
  241. {
  242. struct srp_target_port *target = target_ptr;
  243. target->status = status;
  244. if (status)
  245. shost_printk(KERN_ERR, target->scsi_host,
  246. PFX "Got failed path rec status %d\n", status);
  247. else
  248. target->path = *pathrec;
  249. complete(&target->done);
  250. }
  251. static int srp_lookup_path(struct srp_target_port *target)
  252. {
  253. target->path.numb_path = 1;
  254. init_completion(&target->done);
  255. target->path_query_id = ib_sa_path_rec_get(&srp_sa_client,
  256. target->srp_host->srp_dev->dev,
  257. target->srp_host->port,
  258. &target->path,
  259. IB_SA_PATH_REC_SERVICE_ID |
  260. IB_SA_PATH_REC_DGID |
  261. IB_SA_PATH_REC_SGID |
  262. IB_SA_PATH_REC_NUMB_PATH |
  263. IB_SA_PATH_REC_PKEY,
  264. SRP_PATH_REC_TIMEOUT_MS,
  265. GFP_KERNEL,
  266. srp_path_rec_completion,
  267. target, &target->path_query);
  268. if (target->path_query_id < 0)
  269. return target->path_query_id;
  270. wait_for_completion(&target->done);
  271. if (target->status < 0)
  272. shost_printk(KERN_WARNING, target->scsi_host,
  273. PFX "Path record query failed\n");
  274. return target->status;
  275. }
  276. static int srp_send_req(struct srp_target_port *target)
  277. {
  278. struct {
  279. struct ib_cm_req_param param;
  280. struct srp_login_req priv;
  281. } *req = NULL;
  282. int status;
  283. req = kzalloc(sizeof *req, GFP_KERNEL);
  284. if (!req)
  285. return -ENOMEM;
  286. req->param.primary_path = &target->path;
  287. req->param.alternate_path = NULL;
  288. req->param.service_id = target->service_id;
  289. req->param.qp_num = target->qp->qp_num;
  290. req->param.qp_type = target->qp->qp_type;
  291. req->param.private_data = &req->priv;
  292. req->param.private_data_len = sizeof req->priv;
  293. req->param.flow_control = 1;
  294. get_random_bytes(&req->param.starting_psn, 4);
  295. req->param.starting_psn &= 0xffffff;
  296. /*
  297. * Pick some arbitrary defaults here; we could make these
  298. * module parameters if anyone cared about setting them.
  299. */
  300. req->param.responder_resources = 4;
  301. req->param.remote_cm_response_timeout = 20;
  302. req->param.local_cm_response_timeout = 20;
  303. req->param.retry_count = 7;
  304. req->param.rnr_retry_count = 7;
  305. req->param.max_cm_retries = 15;
  306. req->priv.opcode = SRP_LOGIN_REQ;
  307. req->priv.tag = 0;
  308. req->priv.req_it_iu_len = cpu_to_be32(srp_max_iu_len);
  309. req->priv.req_buf_fmt = cpu_to_be16(SRP_BUF_FORMAT_DIRECT |
  310. SRP_BUF_FORMAT_INDIRECT);
  311. /*
  312. * In the published SRP specification (draft rev. 16a), the
  313. * port identifier format is 8 bytes of ID extension followed
  314. * by 8 bytes of GUID. Older drafts put the two halves in the
  315. * opposite order, so that the GUID comes first.
  316. *
  317. * Targets conforming to these obsolete drafts can be
  318. * recognized by the I/O Class they report.
  319. */
  320. if (target->io_class == SRP_REV10_IB_IO_CLASS) {
  321. memcpy(req->priv.initiator_port_id,
  322. &target->path.sgid.global.interface_id, 8);
  323. memcpy(req->priv.initiator_port_id + 8,
  324. &target->initiator_ext, 8);
  325. memcpy(req->priv.target_port_id, &target->ioc_guid, 8);
  326. memcpy(req->priv.target_port_id + 8, &target->id_ext, 8);
  327. } else {
  328. memcpy(req->priv.initiator_port_id,
  329. &target->initiator_ext, 8);
  330. memcpy(req->priv.initiator_port_id + 8,
  331. &target->path.sgid.global.interface_id, 8);
  332. memcpy(req->priv.target_port_id, &target->id_ext, 8);
  333. memcpy(req->priv.target_port_id + 8, &target->ioc_guid, 8);
  334. }
  335. /*
  336. * Topspin/Cisco SRP targets will reject our login unless we
  337. * zero out the first 8 bytes of our initiator port ID and set
  338. * the second 8 bytes to the local node GUID.
  339. */
  340. if (srp_target_is_topspin(target)) {
  341. shost_printk(KERN_DEBUG, target->scsi_host,
  342. PFX "Topspin/Cisco initiator port ID workaround "
  343. "activated for target GUID %016llx\n",
  344. (unsigned long long) be64_to_cpu(target->ioc_guid));
  345. memset(req->priv.initiator_port_id, 0, 8);
  346. memcpy(req->priv.initiator_port_id + 8,
  347. &target->srp_host->srp_dev->dev->node_guid, 8);
  348. }
  349. status = ib_send_cm_req(target->cm_id, &req->param);
  350. kfree(req);
  351. return status;
  352. }
  353. static void srp_disconnect_target(struct srp_target_port *target)
  354. {
  355. /* XXX should send SRP_I_LOGOUT request */
  356. init_completion(&target->done);
  357. if (ib_send_cm_dreq(target->cm_id, NULL, 0)) {
  358. shost_printk(KERN_DEBUG, target->scsi_host,
  359. PFX "Sending CM DREQ failed\n");
  360. return;
  361. }
  362. wait_for_completion(&target->done);
  363. }
  364. static void srp_remove_work(struct work_struct *work)
  365. {
  366. struct srp_target_port *target =
  367. container_of(work, struct srp_target_port, work);
  368. spin_lock_irq(target->scsi_host->host_lock);
  369. if (target->state != SRP_TARGET_DEAD) {
  370. spin_unlock_irq(target->scsi_host->host_lock);
  371. return;
  372. }
  373. target->state = SRP_TARGET_REMOVED;
  374. spin_unlock_irq(target->scsi_host->host_lock);
  375. spin_lock(&target->srp_host->target_lock);
  376. list_del(&target->list);
  377. spin_unlock(&target->srp_host->target_lock);
  378. srp_remove_host(target->scsi_host);
  379. scsi_remove_host(target->scsi_host);
  380. ib_destroy_cm_id(target->cm_id);
  381. srp_free_target_ib(target);
  382. scsi_host_put(target->scsi_host);
  383. }
  384. static int srp_connect_target(struct srp_target_port *target)
  385. {
  386. int retries = 3;
  387. int ret;
  388. ret = srp_lookup_path(target);
  389. if (ret)
  390. return ret;
  391. while (1) {
  392. init_completion(&target->done);
  393. ret = srp_send_req(target);
  394. if (ret)
  395. return ret;
  396. wait_for_completion(&target->done);
  397. /*
  398. * The CM event handling code will set status to
  399. * SRP_PORT_REDIRECT if we get a port redirect REJ
  400. * back, or SRP_DLID_REDIRECT if we get a lid/qp
  401. * redirect REJ back.
  402. */
  403. switch (target->status) {
  404. case 0:
  405. return 0;
  406. case SRP_PORT_REDIRECT:
  407. ret = srp_lookup_path(target);
  408. if (ret)
  409. return ret;
  410. break;
  411. case SRP_DLID_REDIRECT:
  412. break;
  413. case SRP_STALE_CONN:
  414. /* Our current CM id was stale, and is now in timewait.
  415. * Try to reconnect with a new one.
  416. */
  417. if (!retries-- || srp_new_cm_id(target)) {
  418. shost_printk(KERN_ERR, target->scsi_host, PFX
  419. "giving up on stale connection\n");
  420. target->status = -ECONNRESET;
  421. return target->status;
  422. }
  423. shost_printk(KERN_ERR, target->scsi_host, PFX
  424. "retrying stale connection\n");
  425. break;
  426. default:
  427. return target->status;
  428. }
  429. }
  430. }
  431. static void srp_unmap_data(struct scsi_cmnd *scmnd,
  432. struct srp_target_port *target,
  433. struct srp_request *req)
  434. {
  435. if (!scsi_sglist(scmnd) ||
  436. (scmnd->sc_data_direction != DMA_TO_DEVICE &&
  437. scmnd->sc_data_direction != DMA_FROM_DEVICE))
  438. return;
  439. if (req->fmr) {
  440. ib_fmr_pool_unmap(req->fmr);
  441. req->fmr = NULL;
  442. }
  443. ib_dma_unmap_sg(target->srp_host->srp_dev->dev, scsi_sglist(scmnd),
  444. scsi_sg_count(scmnd), scmnd->sc_data_direction);
  445. }
  446. static void srp_remove_req(struct srp_target_port *target, struct srp_request *req)
  447. {
  448. srp_unmap_data(req->scmnd, target, req);
  449. list_move_tail(&req->list, &target->free_reqs);
  450. }
  451. static void srp_reset_req(struct srp_target_port *target, struct srp_request *req)
  452. {
  453. req->scmnd->result = DID_RESET << 16;
  454. req->scmnd->scsi_done(req->scmnd);
  455. srp_remove_req(target, req);
  456. }
  457. static int srp_reconnect_target(struct srp_target_port *target)
  458. {
  459. struct ib_qp_attr qp_attr;
  460. struct srp_request *req, *tmp;
  461. struct ib_wc wc;
  462. int ret;
  463. spin_lock_irq(target->scsi_host->host_lock);
  464. if (target->state != SRP_TARGET_LIVE) {
  465. spin_unlock_irq(target->scsi_host->host_lock);
  466. return -EAGAIN;
  467. }
  468. target->state = SRP_TARGET_CONNECTING;
  469. spin_unlock_irq(target->scsi_host->host_lock);
  470. srp_disconnect_target(target);
  471. /*
  472. * Now get a new local CM ID so that we avoid confusing the
  473. * target in case things are really fouled up.
  474. */
  475. ret = srp_new_cm_id(target);
  476. if (ret)
  477. goto err;
  478. qp_attr.qp_state = IB_QPS_RESET;
  479. ret = ib_modify_qp(target->qp, &qp_attr, IB_QP_STATE);
  480. if (ret)
  481. goto err;
  482. ret = srp_init_qp(target, target->qp);
  483. if (ret)
  484. goto err;
  485. while (ib_poll_cq(target->recv_cq, 1, &wc) > 0)
  486. ; /* nothing */
  487. while (ib_poll_cq(target->send_cq, 1, &wc) > 0)
  488. ; /* nothing */
  489. spin_lock_irq(target->scsi_host->host_lock);
  490. list_for_each_entry_safe(req, tmp, &target->req_queue, list)
  491. srp_reset_req(target, req);
  492. spin_unlock_irq(target->scsi_host->host_lock);
  493. target->rx_head = 0;
  494. target->tx_head = 0;
  495. target->tx_tail = 0;
  496. target->qp_in_error = 0;
  497. ret = srp_connect_target(target);
  498. if (ret)
  499. goto err;
  500. spin_lock_irq(target->scsi_host->host_lock);
  501. if (target->state == SRP_TARGET_CONNECTING) {
  502. ret = 0;
  503. target->state = SRP_TARGET_LIVE;
  504. } else
  505. ret = -EAGAIN;
  506. spin_unlock_irq(target->scsi_host->host_lock);
  507. return ret;
  508. err:
  509. shost_printk(KERN_ERR, target->scsi_host,
  510. PFX "reconnect failed (%d), removing target port.\n", ret);
  511. /*
  512. * We couldn't reconnect, so kill our target port off.
  513. * However, we have to defer the real removal because we might
  514. * be in the context of the SCSI error handler now, which
  515. * would deadlock if we call scsi_remove_host().
  516. */
  517. spin_lock_irq(target->scsi_host->host_lock);
  518. if (target->state == SRP_TARGET_CONNECTING) {
  519. target->state = SRP_TARGET_DEAD;
  520. INIT_WORK(&target->work, srp_remove_work);
  521. schedule_work(&target->work);
  522. }
  523. spin_unlock_irq(target->scsi_host->host_lock);
  524. return ret;
  525. }
  526. static int srp_map_fmr(struct srp_target_port *target, struct scatterlist *scat,
  527. int sg_cnt, struct srp_request *req,
  528. struct srp_direct_buf *buf)
  529. {
  530. u64 io_addr = 0;
  531. u64 *dma_pages;
  532. u32 len;
  533. int page_cnt;
  534. int i, j;
  535. int ret;
  536. struct srp_device *dev = target->srp_host->srp_dev;
  537. struct ib_device *ibdev = dev->dev;
  538. struct scatterlist *sg;
  539. if (!dev->fmr_pool)
  540. return -ENODEV;
  541. if (srp_target_is_mellanox(target) &&
  542. (ib_sg_dma_address(ibdev, &scat[0]) & ~dev->fmr_page_mask))
  543. return -EINVAL;
  544. len = page_cnt = 0;
  545. scsi_for_each_sg(req->scmnd, sg, sg_cnt, i) {
  546. unsigned int dma_len = ib_sg_dma_len(ibdev, sg);
  547. if (ib_sg_dma_address(ibdev, sg) & ~dev->fmr_page_mask) {
  548. if (i > 0)
  549. return -EINVAL;
  550. else
  551. ++page_cnt;
  552. }
  553. if ((ib_sg_dma_address(ibdev, sg) + dma_len) &
  554. ~dev->fmr_page_mask) {
  555. if (i < sg_cnt - 1)
  556. return -EINVAL;
  557. else
  558. ++page_cnt;
  559. }
  560. len += dma_len;
  561. }
  562. page_cnt += len >> dev->fmr_page_shift;
  563. if (page_cnt > SRP_FMR_SIZE)
  564. return -ENOMEM;
  565. dma_pages = kmalloc(sizeof (u64) * page_cnt, GFP_ATOMIC);
  566. if (!dma_pages)
  567. return -ENOMEM;
  568. page_cnt = 0;
  569. scsi_for_each_sg(req->scmnd, sg, sg_cnt, i) {
  570. unsigned int dma_len = ib_sg_dma_len(ibdev, sg);
  571. for (j = 0; j < dma_len; j += dev->fmr_page_size)
  572. dma_pages[page_cnt++] =
  573. (ib_sg_dma_address(ibdev, sg) &
  574. dev->fmr_page_mask) + j;
  575. }
  576. req->fmr = ib_fmr_pool_map_phys(dev->fmr_pool,
  577. dma_pages, page_cnt, io_addr);
  578. if (IS_ERR(req->fmr)) {
  579. ret = PTR_ERR(req->fmr);
  580. req->fmr = NULL;
  581. goto out;
  582. }
  583. buf->va = cpu_to_be64(ib_sg_dma_address(ibdev, &scat[0]) &
  584. ~dev->fmr_page_mask);
  585. buf->key = cpu_to_be32(req->fmr->fmr->rkey);
  586. buf->len = cpu_to_be32(len);
  587. ret = 0;
  588. out:
  589. kfree(dma_pages);
  590. return ret;
  591. }
  592. static int srp_map_data(struct scsi_cmnd *scmnd, struct srp_target_port *target,
  593. struct srp_request *req)
  594. {
  595. struct scatterlist *scat;
  596. struct srp_cmd *cmd = req->cmd->buf;
  597. int len, nents, count;
  598. u8 fmt = SRP_DATA_DESC_DIRECT;
  599. struct srp_device *dev;
  600. struct ib_device *ibdev;
  601. if (!scsi_sglist(scmnd) || scmnd->sc_data_direction == DMA_NONE)
  602. return sizeof (struct srp_cmd);
  603. if (scmnd->sc_data_direction != DMA_FROM_DEVICE &&
  604. scmnd->sc_data_direction != DMA_TO_DEVICE) {
  605. shost_printk(KERN_WARNING, target->scsi_host,
  606. PFX "Unhandled data direction %d\n",
  607. scmnd->sc_data_direction);
  608. return -EINVAL;
  609. }
  610. nents = scsi_sg_count(scmnd);
  611. scat = scsi_sglist(scmnd);
  612. dev = target->srp_host->srp_dev;
  613. ibdev = dev->dev;
  614. count = ib_dma_map_sg(ibdev, scat, nents, scmnd->sc_data_direction);
  615. fmt = SRP_DATA_DESC_DIRECT;
  616. len = sizeof (struct srp_cmd) + sizeof (struct srp_direct_buf);
  617. if (count == 1) {
  618. /*
  619. * The midlayer only generated a single gather/scatter
  620. * entry, or DMA mapping coalesced everything to a
  621. * single entry. So a direct descriptor along with
  622. * the DMA MR suffices.
  623. */
  624. struct srp_direct_buf *buf = (void *) cmd->add_data;
  625. buf->va = cpu_to_be64(ib_sg_dma_address(ibdev, scat));
  626. buf->key = cpu_to_be32(dev->mr->rkey);
  627. buf->len = cpu_to_be32(ib_sg_dma_len(ibdev, scat));
  628. } else if (srp_map_fmr(target, scat, count, req,
  629. (void *) cmd->add_data)) {
  630. /*
  631. * FMR mapping failed, and the scatterlist has more
  632. * than one entry. Generate an indirect memory
  633. * descriptor.
  634. */
  635. struct srp_indirect_buf *buf = (void *) cmd->add_data;
  636. struct scatterlist *sg;
  637. u32 datalen = 0;
  638. int i;
  639. fmt = SRP_DATA_DESC_INDIRECT;
  640. len = sizeof (struct srp_cmd) +
  641. sizeof (struct srp_indirect_buf) +
  642. count * sizeof (struct srp_direct_buf);
  643. scsi_for_each_sg(scmnd, sg, count, i) {
  644. unsigned int dma_len = ib_sg_dma_len(ibdev, sg);
  645. buf->desc_list[i].va =
  646. cpu_to_be64(ib_sg_dma_address(ibdev, sg));
  647. buf->desc_list[i].key =
  648. cpu_to_be32(dev->mr->rkey);
  649. buf->desc_list[i].len = cpu_to_be32(dma_len);
  650. datalen += dma_len;
  651. }
  652. if (scmnd->sc_data_direction == DMA_TO_DEVICE)
  653. cmd->data_out_desc_cnt = count;
  654. else
  655. cmd->data_in_desc_cnt = count;
  656. buf->table_desc.va =
  657. cpu_to_be64(req->cmd->dma + sizeof *cmd + sizeof *buf);
  658. buf->table_desc.key =
  659. cpu_to_be32(target->srp_host->srp_dev->mr->rkey);
  660. buf->table_desc.len =
  661. cpu_to_be32(count * sizeof (struct srp_direct_buf));
  662. buf->len = cpu_to_be32(datalen);
  663. }
  664. if (scmnd->sc_data_direction == DMA_TO_DEVICE)
  665. cmd->buf_fmt = fmt << 4;
  666. else
  667. cmd->buf_fmt = fmt;
  668. return len;
  669. }
  670. static void srp_process_rsp(struct srp_target_port *target, struct srp_rsp *rsp)
  671. {
  672. struct srp_request *req;
  673. struct scsi_cmnd *scmnd;
  674. unsigned long flags;
  675. s32 delta;
  676. delta = (s32) be32_to_cpu(rsp->req_lim_delta);
  677. spin_lock_irqsave(target->scsi_host->host_lock, flags);
  678. target->req_lim += delta;
  679. req = &target->req_ring[rsp->tag & ~SRP_TAG_TSK_MGMT];
  680. if (unlikely(rsp->tag & SRP_TAG_TSK_MGMT)) {
  681. if (be32_to_cpu(rsp->resp_data_len) < 4)
  682. req->tsk_status = -1;
  683. else
  684. req->tsk_status = rsp->data[3];
  685. complete(&req->done);
  686. } else {
  687. scmnd = req->scmnd;
  688. if (!scmnd)
  689. shost_printk(KERN_ERR, target->scsi_host,
  690. "Null scmnd for RSP w/tag %016llx\n",
  691. (unsigned long long) rsp->tag);
  692. scmnd->result = rsp->status;
  693. if (rsp->flags & SRP_RSP_FLAG_SNSVALID) {
  694. memcpy(scmnd->sense_buffer, rsp->data +
  695. be32_to_cpu(rsp->resp_data_len),
  696. min_t(int, be32_to_cpu(rsp->sense_data_len),
  697. SCSI_SENSE_BUFFERSIZE));
  698. }
  699. if (rsp->flags & (SRP_RSP_FLAG_DOOVER | SRP_RSP_FLAG_DOUNDER))
  700. scsi_set_resid(scmnd, be32_to_cpu(rsp->data_out_res_cnt));
  701. else if (rsp->flags & (SRP_RSP_FLAG_DIOVER | SRP_RSP_FLAG_DIUNDER))
  702. scsi_set_resid(scmnd, be32_to_cpu(rsp->data_in_res_cnt));
  703. if (!req->tsk_mgmt) {
  704. scmnd->host_scribble = (void *) -1L;
  705. scmnd->scsi_done(scmnd);
  706. srp_remove_req(target, req);
  707. } else
  708. req->cmd_done = 1;
  709. }
  710. spin_unlock_irqrestore(target->scsi_host->host_lock, flags);
  711. }
  712. static void srp_handle_recv(struct srp_target_port *target, struct ib_wc *wc)
  713. {
  714. struct ib_device *dev;
  715. struct srp_iu *iu;
  716. u8 opcode;
  717. iu = target->rx_ring[wc->wr_id];
  718. dev = target->srp_host->srp_dev->dev;
  719. ib_dma_sync_single_for_cpu(dev, iu->dma, target->max_ti_iu_len,
  720. DMA_FROM_DEVICE);
  721. opcode = *(u8 *) iu->buf;
  722. if (0) {
  723. int i;
  724. shost_printk(KERN_ERR, target->scsi_host,
  725. PFX "recv completion, opcode 0x%02x\n", opcode);
  726. for (i = 0; i < wc->byte_len; ++i) {
  727. if (i % 8 == 0)
  728. printk(KERN_ERR " [%02x] ", i);
  729. printk(" %02x", ((u8 *) iu->buf)[i]);
  730. if ((i + 1) % 8 == 0)
  731. printk("\n");
  732. }
  733. if (wc->byte_len % 8)
  734. printk("\n");
  735. }
  736. switch (opcode) {
  737. case SRP_RSP:
  738. srp_process_rsp(target, iu->buf);
  739. break;
  740. case SRP_T_LOGOUT:
  741. /* XXX Handle target logout */
  742. shost_printk(KERN_WARNING, target->scsi_host,
  743. PFX "Got target logout request\n");
  744. break;
  745. default:
  746. shost_printk(KERN_WARNING, target->scsi_host,
  747. PFX "Unhandled SRP opcode 0x%02x\n", opcode);
  748. break;
  749. }
  750. ib_dma_sync_single_for_device(dev, iu->dma, target->max_ti_iu_len,
  751. DMA_FROM_DEVICE);
  752. }
  753. static void srp_recv_completion(struct ib_cq *cq, void *target_ptr)
  754. {
  755. struct srp_target_port *target = target_ptr;
  756. struct ib_wc wc;
  757. ib_req_notify_cq(cq, IB_CQ_NEXT_COMP);
  758. while (ib_poll_cq(cq, 1, &wc) > 0) {
  759. if (wc.status) {
  760. shost_printk(KERN_ERR, target->scsi_host,
  761. PFX "failed receive status %d\n",
  762. wc.status);
  763. target->qp_in_error = 1;
  764. break;
  765. }
  766. srp_handle_recv(target, &wc);
  767. }
  768. }
  769. static void srp_send_completion(struct ib_cq *cq, void *target_ptr)
  770. {
  771. struct srp_target_port *target = target_ptr;
  772. struct ib_wc wc;
  773. while (ib_poll_cq(cq, 1, &wc) > 0) {
  774. if (wc.status) {
  775. shost_printk(KERN_ERR, target->scsi_host,
  776. PFX "failed send status %d\n",
  777. wc.status);
  778. target->qp_in_error = 1;
  779. break;
  780. }
  781. ++target->tx_tail;
  782. }
  783. }
  784. static int __srp_post_recv(struct srp_target_port *target)
  785. {
  786. struct srp_iu *iu;
  787. struct ib_sge list;
  788. struct ib_recv_wr wr, *bad_wr;
  789. unsigned int next;
  790. int ret;
  791. next = target->rx_head & (SRP_RQ_SIZE - 1);
  792. wr.wr_id = next;
  793. iu = target->rx_ring[next];
  794. list.addr = iu->dma;
  795. list.length = iu->size;
  796. list.lkey = target->srp_host->srp_dev->mr->lkey;
  797. wr.next = NULL;
  798. wr.sg_list = &list;
  799. wr.num_sge = 1;
  800. ret = ib_post_recv(target->qp, &wr, &bad_wr);
  801. if (!ret)
  802. ++target->rx_head;
  803. return ret;
  804. }
  805. static int srp_post_recv(struct srp_target_port *target)
  806. {
  807. unsigned long flags;
  808. int ret;
  809. spin_lock_irqsave(target->scsi_host->host_lock, flags);
  810. ret = __srp_post_recv(target);
  811. spin_unlock_irqrestore(target->scsi_host->host_lock, flags);
  812. return ret;
  813. }
  814. /*
  815. * Must be called with target->scsi_host->host_lock held to protect
  816. * req_lim and tx_head. Lock cannot be dropped between call here and
  817. * call to __srp_post_send().
  818. */
  819. static struct srp_iu *__srp_get_tx_iu(struct srp_target_port *target,
  820. enum srp_request_type req_type)
  821. {
  822. s32 min = (req_type == SRP_REQ_TASK_MGMT) ? 1 : 2;
  823. srp_send_completion(target->send_cq, target);
  824. if (target->tx_head - target->tx_tail >= SRP_SQ_SIZE)
  825. return NULL;
  826. if (target->req_lim < min) {
  827. ++target->zero_req_lim;
  828. return NULL;
  829. }
  830. return target->tx_ring[target->tx_head & SRP_SQ_SIZE];
  831. }
  832. /*
  833. * Must be called with target->scsi_host->host_lock held to protect
  834. * req_lim and tx_head.
  835. */
  836. static int __srp_post_send(struct srp_target_port *target,
  837. struct srp_iu *iu, int len)
  838. {
  839. struct ib_sge list;
  840. struct ib_send_wr wr, *bad_wr;
  841. int ret = 0;
  842. list.addr = iu->dma;
  843. list.length = len;
  844. list.lkey = target->srp_host->srp_dev->mr->lkey;
  845. wr.next = NULL;
  846. wr.wr_id = target->tx_head & SRP_SQ_SIZE;
  847. wr.sg_list = &list;
  848. wr.num_sge = 1;
  849. wr.opcode = IB_WR_SEND;
  850. wr.send_flags = IB_SEND_SIGNALED;
  851. ret = ib_post_send(target->qp, &wr, &bad_wr);
  852. if (!ret) {
  853. ++target->tx_head;
  854. --target->req_lim;
  855. }
  856. return ret;
  857. }
  858. static int srp_queuecommand(struct scsi_cmnd *scmnd,
  859. void (*done)(struct scsi_cmnd *))
  860. {
  861. struct srp_target_port *target = host_to_target(scmnd->device->host);
  862. struct srp_request *req;
  863. struct srp_iu *iu;
  864. struct srp_cmd *cmd;
  865. struct ib_device *dev;
  866. int len;
  867. if (target->state == SRP_TARGET_CONNECTING)
  868. goto err;
  869. if (target->state == SRP_TARGET_DEAD ||
  870. target->state == SRP_TARGET_REMOVED) {
  871. scmnd->result = DID_BAD_TARGET << 16;
  872. done(scmnd);
  873. return 0;
  874. }
  875. iu = __srp_get_tx_iu(target, SRP_REQ_NORMAL);
  876. if (!iu)
  877. goto err;
  878. dev = target->srp_host->srp_dev->dev;
  879. ib_dma_sync_single_for_cpu(dev, iu->dma, srp_max_iu_len,
  880. DMA_TO_DEVICE);
  881. req = list_entry(target->free_reqs.next, struct srp_request, list);
  882. scmnd->scsi_done = done;
  883. scmnd->result = 0;
  884. scmnd->host_scribble = (void *) (long) req->index;
  885. cmd = iu->buf;
  886. memset(cmd, 0, sizeof *cmd);
  887. cmd->opcode = SRP_CMD;
  888. cmd->lun = cpu_to_be64((u64) scmnd->device->lun << 48);
  889. cmd->tag = req->index;
  890. memcpy(cmd->cdb, scmnd->cmnd, scmnd->cmd_len);
  891. req->scmnd = scmnd;
  892. req->cmd = iu;
  893. req->cmd_done = 0;
  894. req->tsk_mgmt = NULL;
  895. len = srp_map_data(scmnd, target, req);
  896. if (len < 0) {
  897. shost_printk(KERN_ERR, target->scsi_host,
  898. PFX "Failed to map data\n");
  899. goto err;
  900. }
  901. if (__srp_post_recv(target)) {
  902. shost_printk(KERN_ERR, target->scsi_host, PFX "Recv failed\n");
  903. goto err_unmap;
  904. }
  905. ib_dma_sync_single_for_device(dev, iu->dma, srp_max_iu_len,
  906. DMA_TO_DEVICE);
  907. if (__srp_post_send(target, iu, len)) {
  908. shost_printk(KERN_ERR, target->scsi_host, PFX "Send failed\n");
  909. goto err_unmap;
  910. }
  911. list_move_tail(&req->list, &target->req_queue);
  912. return 0;
  913. err_unmap:
  914. srp_unmap_data(scmnd, target, req);
  915. err:
  916. return SCSI_MLQUEUE_HOST_BUSY;
  917. }
  918. static int srp_alloc_iu_bufs(struct srp_target_port *target)
  919. {
  920. int i;
  921. for (i = 0; i < SRP_RQ_SIZE; ++i) {
  922. target->rx_ring[i] = srp_alloc_iu(target->srp_host,
  923. target->max_ti_iu_len,
  924. GFP_KERNEL, DMA_FROM_DEVICE);
  925. if (!target->rx_ring[i])
  926. goto err;
  927. }
  928. for (i = 0; i < SRP_SQ_SIZE + 1; ++i) {
  929. target->tx_ring[i] = srp_alloc_iu(target->srp_host,
  930. srp_max_iu_len,
  931. GFP_KERNEL, DMA_TO_DEVICE);
  932. if (!target->tx_ring[i])
  933. goto err;
  934. }
  935. return 0;
  936. err:
  937. for (i = 0; i < SRP_RQ_SIZE; ++i) {
  938. srp_free_iu(target->srp_host, target->rx_ring[i]);
  939. target->rx_ring[i] = NULL;
  940. }
  941. for (i = 0; i < SRP_SQ_SIZE + 1; ++i) {
  942. srp_free_iu(target->srp_host, target->tx_ring[i]);
  943. target->tx_ring[i] = NULL;
  944. }
  945. return -ENOMEM;
  946. }
  947. static void srp_cm_rej_handler(struct ib_cm_id *cm_id,
  948. struct ib_cm_event *event,
  949. struct srp_target_port *target)
  950. {
  951. struct Scsi_Host *shost = target->scsi_host;
  952. struct ib_class_port_info *cpi;
  953. int opcode;
  954. switch (event->param.rej_rcvd.reason) {
  955. case IB_CM_REJ_PORT_CM_REDIRECT:
  956. cpi = event->param.rej_rcvd.ari;
  957. target->path.dlid = cpi->redirect_lid;
  958. target->path.pkey = cpi->redirect_pkey;
  959. cm_id->remote_cm_qpn = be32_to_cpu(cpi->redirect_qp) & 0x00ffffff;
  960. memcpy(target->path.dgid.raw, cpi->redirect_gid, 16);
  961. target->status = target->path.dlid ?
  962. SRP_DLID_REDIRECT : SRP_PORT_REDIRECT;
  963. break;
  964. case IB_CM_REJ_PORT_REDIRECT:
  965. if (srp_target_is_topspin(target)) {
  966. /*
  967. * Topspin/Cisco SRP gateways incorrectly send
  968. * reject reason code 25 when they mean 24
  969. * (port redirect).
  970. */
  971. memcpy(target->path.dgid.raw,
  972. event->param.rej_rcvd.ari, 16);
  973. shost_printk(KERN_DEBUG, shost,
  974. PFX "Topspin/Cisco redirect to target port GID %016llx%016llx\n",
  975. (unsigned long long) be64_to_cpu(target->path.dgid.global.subnet_prefix),
  976. (unsigned long long) be64_to_cpu(target->path.dgid.global.interface_id));
  977. target->status = SRP_PORT_REDIRECT;
  978. } else {
  979. shost_printk(KERN_WARNING, shost,
  980. " REJ reason: IB_CM_REJ_PORT_REDIRECT\n");
  981. target->status = -ECONNRESET;
  982. }
  983. break;
  984. case IB_CM_REJ_DUPLICATE_LOCAL_COMM_ID:
  985. shost_printk(KERN_WARNING, shost,
  986. " REJ reason: IB_CM_REJ_DUPLICATE_LOCAL_COMM_ID\n");
  987. target->status = -ECONNRESET;
  988. break;
  989. case IB_CM_REJ_CONSUMER_DEFINED:
  990. opcode = *(u8 *) event->private_data;
  991. if (opcode == SRP_LOGIN_REJ) {
  992. struct srp_login_rej *rej = event->private_data;
  993. u32 reason = be32_to_cpu(rej->reason);
  994. if (reason == SRP_LOGIN_REJ_REQ_IT_IU_LENGTH_TOO_LARGE)
  995. shost_printk(KERN_WARNING, shost,
  996. PFX "SRP_LOGIN_REJ: requested max_it_iu_len too large\n");
  997. else
  998. shost_printk(KERN_WARNING, shost,
  999. PFX "SRP LOGIN REJECTED, reason 0x%08x\n", reason);
  1000. } else
  1001. shost_printk(KERN_WARNING, shost,
  1002. " REJ reason: IB_CM_REJ_CONSUMER_DEFINED,"
  1003. " opcode 0x%02x\n", opcode);
  1004. target->status = -ECONNRESET;
  1005. break;
  1006. case IB_CM_REJ_STALE_CONN:
  1007. shost_printk(KERN_WARNING, shost, " REJ reason: stale connection\n");
  1008. target->status = SRP_STALE_CONN;
  1009. break;
  1010. default:
  1011. shost_printk(KERN_WARNING, shost, " REJ reason 0x%x\n",
  1012. event->param.rej_rcvd.reason);
  1013. target->status = -ECONNRESET;
  1014. }
  1015. }
  1016. static int srp_cm_handler(struct ib_cm_id *cm_id, struct ib_cm_event *event)
  1017. {
  1018. struct srp_target_port *target = cm_id->context;
  1019. struct ib_qp_attr *qp_attr = NULL;
  1020. int attr_mask = 0;
  1021. int comp = 0;
  1022. int opcode = 0;
  1023. switch (event->event) {
  1024. case IB_CM_REQ_ERROR:
  1025. shost_printk(KERN_DEBUG, target->scsi_host,
  1026. PFX "Sending CM REQ failed\n");
  1027. comp = 1;
  1028. target->status = -ECONNRESET;
  1029. break;
  1030. case IB_CM_REP_RECEIVED:
  1031. comp = 1;
  1032. opcode = *(u8 *) event->private_data;
  1033. if (opcode == SRP_LOGIN_RSP) {
  1034. struct srp_login_rsp *rsp = event->private_data;
  1035. target->max_ti_iu_len = be32_to_cpu(rsp->max_ti_iu_len);
  1036. target->req_lim = be32_to_cpu(rsp->req_lim_delta);
  1037. target->scsi_host->can_queue = min(target->req_lim,
  1038. target->scsi_host->can_queue);
  1039. } else {
  1040. shost_printk(KERN_WARNING, target->scsi_host,
  1041. PFX "Unhandled RSP opcode %#x\n", opcode);
  1042. target->status = -ECONNRESET;
  1043. break;
  1044. }
  1045. if (!target->rx_ring[0]) {
  1046. target->status = srp_alloc_iu_bufs(target);
  1047. if (target->status)
  1048. break;
  1049. }
  1050. qp_attr = kmalloc(sizeof *qp_attr, GFP_KERNEL);
  1051. if (!qp_attr) {
  1052. target->status = -ENOMEM;
  1053. break;
  1054. }
  1055. qp_attr->qp_state = IB_QPS_RTR;
  1056. target->status = ib_cm_init_qp_attr(cm_id, qp_attr, &attr_mask);
  1057. if (target->status)
  1058. break;
  1059. target->status = ib_modify_qp(target->qp, qp_attr, attr_mask);
  1060. if (target->status)
  1061. break;
  1062. target->status = srp_post_recv(target);
  1063. if (target->status)
  1064. break;
  1065. qp_attr->qp_state = IB_QPS_RTS;
  1066. target->status = ib_cm_init_qp_attr(cm_id, qp_attr, &attr_mask);
  1067. if (target->status)
  1068. break;
  1069. target->status = ib_modify_qp(target->qp, qp_attr, attr_mask);
  1070. if (target->status)
  1071. break;
  1072. target->status = ib_send_cm_rtu(cm_id, NULL, 0);
  1073. if (target->status)
  1074. break;
  1075. break;
  1076. case IB_CM_REJ_RECEIVED:
  1077. shost_printk(KERN_DEBUG, target->scsi_host, PFX "REJ received\n");
  1078. comp = 1;
  1079. srp_cm_rej_handler(cm_id, event, target);
  1080. break;
  1081. case IB_CM_DREQ_RECEIVED:
  1082. shost_printk(KERN_WARNING, target->scsi_host,
  1083. PFX "DREQ received - connection closed\n");
  1084. if (ib_send_cm_drep(cm_id, NULL, 0))
  1085. shost_printk(KERN_ERR, target->scsi_host,
  1086. PFX "Sending CM DREP failed\n");
  1087. break;
  1088. case IB_CM_TIMEWAIT_EXIT:
  1089. shost_printk(KERN_ERR, target->scsi_host,
  1090. PFX "connection closed\n");
  1091. comp = 1;
  1092. target->status = 0;
  1093. break;
  1094. case IB_CM_MRA_RECEIVED:
  1095. case IB_CM_DREQ_ERROR:
  1096. case IB_CM_DREP_RECEIVED:
  1097. break;
  1098. default:
  1099. shost_printk(KERN_WARNING, target->scsi_host,
  1100. PFX "Unhandled CM event %d\n", event->event);
  1101. break;
  1102. }
  1103. if (comp)
  1104. complete(&target->done);
  1105. kfree(qp_attr);
  1106. return 0;
  1107. }
  1108. static int srp_send_tsk_mgmt(struct srp_target_port *target,
  1109. struct srp_request *req, u8 func)
  1110. {
  1111. struct srp_iu *iu;
  1112. struct srp_tsk_mgmt *tsk_mgmt;
  1113. spin_lock_irq(target->scsi_host->host_lock);
  1114. if (target->state == SRP_TARGET_DEAD ||
  1115. target->state == SRP_TARGET_REMOVED) {
  1116. req->scmnd->result = DID_BAD_TARGET << 16;
  1117. goto out;
  1118. }
  1119. init_completion(&req->done);
  1120. iu = __srp_get_tx_iu(target, SRP_REQ_TASK_MGMT);
  1121. if (!iu)
  1122. goto out;
  1123. tsk_mgmt = iu->buf;
  1124. memset(tsk_mgmt, 0, sizeof *tsk_mgmt);
  1125. tsk_mgmt->opcode = SRP_TSK_MGMT;
  1126. tsk_mgmt->lun = cpu_to_be64((u64) req->scmnd->device->lun << 48);
  1127. tsk_mgmt->tag = req->index | SRP_TAG_TSK_MGMT;
  1128. tsk_mgmt->tsk_mgmt_func = func;
  1129. tsk_mgmt->task_tag = req->index;
  1130. if (__srp_post_send(target, iu, sizeof *tsk_mgmt))
  1131. goto out;
  1132. req->tsk_mgmt = iu;
  1133. spin_unlock_irq(target->scsi_host->host_lock);
  1134. if (!wait_for_completion_timeout(&req->done,
  1135. msecs_to_jiffies(SRP_ABORT_TIMEOUT_MS)))
  1136. return -1;
  1137. return 0;
  1138. out:
  1139. spin_unlock_irq(target->scsi_host->host_lock);
  1140. return -1;
  1141. }
  1142. static int srp_find_req(struct srp_target_port *target,
  1143. struct scsi_cmnd *scmnd,
  1144. struct srp_request **req)
  1145. {
  1146. if (scmnd->host_scribble == (void *) -1L)
  1147. return -1;
  1148. *req = &target->req_ring[(long) scmnd->host_scribble];
  1149. return 0;
  1150. }
  1151. static int srp_abort(struct scsi_cmnd *scmnd)
  1152. {
  1153. struct srp_target_port *target = host_to_target(scmnd->device->host);
  1154. struct srp_request *req;
  1155. int ret = SUCCESS;
  1156. shost_printk(KERN_ERR, target->scsi_host, "SRP abort called\n");
  1157. if (target->qp_in_error)
  1158. return FAILED;
  1159. if (srp_find_req(target, scmnd, &req))
  1160. return FAILED;
  1161. if (srp_send_tsk_mgmt(target, req, SRP_TSK_ABORT_TASK))
  1162. return FAILED;
  1163. spin_lock_irq(target->scsi_host->host_lock);
  1164. if (req->cmd_done) {
  1165. srp_remove_req(target, req);
  1166. scmnd->scsi_done(scmnd);
  1167. } else if (!req->tsk_status) {
  1168. srp_remove_req(target, req);
  1169. scmnd->result = DID_ABORT << 16;
  1170. } else
  1171. ret = FAILED;
  1172. spin_unlock_irq(target->scsi_host->host_lock);
  1173. return ret;
  1174. }
  1175. static int srp_reset_device(struct scsi_cmnd *scmnd)
  1176. {
  1177. struct srp_target_port *target = host_to_target(scmnd->device->host);
  1178. struct srp_request *req, *tmp;
  1179. shost_printk(KERN_ERR, target->scsi_host, "SRP reset_device called\n");
  1180. if (target->qp_in_error)
  1181. return FAILED;
  1182. if (srp_find_req(target, scmnd, &req))
  1183. return FAILED;
  1184. if (srp_send_tsk_mgmt(target, req, SRP_TSK_LUN_RESET))
  1185. return FAILED;
  1186. if (req->tsk_status)
  1187. return FAILED;
  1188. spin_lock_irq(target->scsi_host->host_lock);
  1189. list_for_each_entry_safe(req, tmp, &target->req_queue, list)
  1190. if (req->scmnd->device == scmnd->device)
  1191. srp_reset_req(target, req);
  1192. spin_unlock_irq(target->scsi_host->host_lock);
  1193. return SUCCESS;
  1194. }
  1195. static int srp_reset_host(struct scsi_cmnd *scmnd)
  1196. {
  1197. struct srp_target_port *target = host_to_target(scmnd->device->host);
  1198. int ret = FAILED;
  1199. shost_printk(KERN_ERR, target->scsi_host, PFX "SRP reset_host called\n");
  1200. if (!srp_reconnect_target(target))
  1201. ret = SUCCESS;
  1202. return ret;
  1203. }
  1204. static ssize_t show_id_ext(struct device *dev, struct device_attribute *attr,
  1205. char *buf)
  1206. {
  1207. struct srp_target_port *target = host_to_target(class_to_shost(dev));
  1208. if (target->state == SRP_TARGET_DEAD ||
  1209. target->state == SRP_TARGET_REMOVED)
  1210. return -ENODEV;
  1211. return sprintf(buf, "0x%016llx\n",
  1212. (unsigned long long) be64_to_cpu(target->id_ext));
  1213. }
  1214. static ssize_t show_ioc_guid(struct device *dev, struct device_attribute *attr,
  1215. char *buf)
  1216. {
  1217. struct srp_target_port *target = host_to_target(class_to_shost(dev));
  1218. if (target->state == SRP_TARGET_DEAD ||
  1219. target->state == SRP_TARGET_REMOVED)
  1220. return -ENODEV;
  1221. return sprintf(buf, "0x%016llx\n",
  1222. (unsigned long long) be64_to_cpu(target->ioc_guid));
  1223. }
  1224. static ssize_t show_service_id(struct device *dev,
  1225. struct device_attribute *attr, char *buf)
  1226. {
  1227. struct srp_target_port *target = host_to_target(class_to_shost(dev));
  1228. if (target->state == SRP_TARGET_DEAD ||
  1229. target->state == SRP_TARGET_REMOVED)
  1230. return -ENODEV;
  1231. return sprintf(buf, "0x%016llx\n",
  1232. (unsigned long long) be64_to_cpu(target->service_id));
  1233. }
  1234. static ssize_t show_pkey(struct device *dev, struct device_attribute *attr,
  1235. char *buf)
  1236. {
  1237. struct srp_target_port *target = host_to_target(class_to_shost(dev));
  1238. if (target->state == SRP_TARGET_DEAD ||
  1239. target->state == SRP_TARGET_REMOVED)
  1240. return -ENODEV;
  1241. return sprintf(buf, "0x%04x\n", be16_to_cpu(target->path.pkey));
  1242. }
  1243. static ssize_t show_dgid(struct device *dev, struct device_attribute *attr,
  1244. char *buf)
  1245. {
  1246. struct srp_target_port *target = host_to_target(class_to_shost(dev));
  1247. if (target->state == SRP_TARGET_DEAD ||
  1248. target->state == SRP_TARGET_REMOVED)
  1249. return -ENODEV;
  1250. return sprintf(buf, "%pI6\n", target->path.dgid.raw);
  1251. }
  1252. static ssize_t show_orig_dgid(struct device *dev,
  1253. struct device_attribute *attr, char *buf)
  1254. {
  1255. struct srp_target_port *target = host_to_target(class_to_shost(dev));
  1256. if (target->state == SRP_TARGET_DEAD ||
  1257. target->state == SRP_TARGET_REMOVED)
  1258. return -ENODEV;
  1259. return sprintf(buf, "%pI6\n", target->orig_dgid);
  1260. }
  1261. static ssize_t show_zero_req_lim(struct device *dev,
  1262. struct device_attribute *attr, char *buf)
  1263. {
  1264. struct srp_target_port *target = host_to_target(class_to_shost(dev));
  1265. if (target->state == SRP_TARGET_DEAD ||
  1266. target->state == SRP_TARGET_REMOVED)
  1267. return -ENODEV;
  1268. return sprintf(buf, "%d\n", target->zero_req_lim);
  1269. }
  1270. static ssize_t show_local_ib_port(struct device *dev,
  1271. struct device_attribute *attr, char *buf)
  1272. {
  1273. struct srp_target_port *target = host_to_target(class_to_shost(dev));
  1274. return sprintf(buf, "%d\n", target->srp_host->port);
  1275. }
  1276. static ssize_t show_local_ib_device(struct device *dev,
  1277. struct device_attribute *attr, char *buf)
  1278. {
  1279. struct srp_target_port *target = host_to_target(class_to_shost(dev));
  1280. return sprintf(buf, "%s\n", target->srp_host->srp_dev->dev->name);
  1281. }
  1282. static DEVICE_ATTR(id_ext, S_IRUGO, show_id_ext, NULL);
  1283. static DEVICE_ATTR(ioc_guid, S_IRUGO, show_ioc_guid, NULL);
  1284. static DEVICE_ATTR(service_id, S_IRUGO, show_service_id, NULL);
  1285. static DEVICE_ATTR(pkey, S_IRUGO, show_pkey, NULL);
  1286. static DEVICE_ATTR(dgid, S_IRUGO, show_dgid, NULL);
  1287. static DEVICE_ATTR(orig_dgid, S_IRUGO, show_orig_dgid, NULL);
  1288. static DEVICE_ATTR(zero_req_lim, S_IRUGO, show_zero_req_lim, NULL);
  1289. static DEVICE_ATTR(local_ib_port, S_IRUGO, show_local_ib_port, NULL);
  1290. static DEVICE_ATTR(local_ib_device, S_IRUGO, show_local_ib_device, NULL);
  1291. static struct device_attribute *srp_host_attrs[] = {
  1292. &dev_attr_id_ext,
  1293. &dev_attr_ioc_guid,
  1294. &dev_attr_service_id,
  1295. &dev_attr_pkey,
  1296. &dev_attr_dgid,
  1297. &dev_attr_orig_dgid,
  1298. &dev_attr_zero_req_lim,
  1299. &dev_attr_local_ib_port,
  1300. &dev_attr_local_ib_device,
  1301. NULL
  1302. };
  1303. static struct scsi_host_template srp_template = {
  1304. .module = THIS_MODULE,
  1305. .name = "InfiniBand SRP initiator",
  1306. .proc_name = DRV_NAME,
  1307. .info = srp_target_info,
  1308. .queuecommand = srp_queuecommand,
  1309. .eh_abort_handler = srp_abort,
  1310. .eh_device_reset_handler = srp_reset_device,
  1311. .eh_host_reset_handler = srp_reset_host,
  1312. .can_queue = SRP_SQ_SIZE,
  1313. .this_id = -1,
  1314. .cmd_per_lun = SRP_SQ_SIZE,
  1315. .use_clustering = ENABLE_CLUSTERING,
  1316. .shost_attrs = srp_host_attrs
  1317. };
  1318. static int srp_add_target(struct srp_host *host, struct srp_target_port *target)
  1319. {
  1320. struct srp_rport_identifiers ids;
  1321. struct srp_rport *rport;
  1322. sprintf(target->target_name, "SRP.T10:%016llX",
  1323. (unsigned long long) be64_to_cpu(target->id_ext));
  1324. if (scsi_add_host(target->scsi_host, host->srp_dev->dev->dma_device))
  1325. return -ENODEV;
  1326. memcpy(ids.port_id, &target->id_ext, 8);
  1327. memcpy(ids.port_id + 8, &target->ioc_guid, 8);
  1328. ids.roles = SRP_RPORT_ROLE_TARGET;
  1329. rport = srp_rport_add(target->scsi_host, &ids);
  1330. if (IS_ERR(rport)) {
  1331. scsi_remove_host(target->scsi_host);
  1332. return PTR_ERR(rport);
  1333. }
  1334. spin_lock(&host->target_lock);
  1335. list_add_tail(&target->list, &host->target_list);
  1336. spin_unlock(&host->target_lock);
  1337. target->state = SRP_TARGET_LIVE;
  1338. scsi_scan_target(&target->scsi_host->shost_gendev,
  1339. 0, target->scsi_id, SCAN_WILD_CARD, 0);
  1340. return 0;
  1341. }
  1342. static void srp_release_dev(struct device *dev)
  1343. {
  1344. struct srp_host *host =
  1345. container_of(dev, struct srp_host, dev);
  1346. complete(&host->released);
  1347. }
  1348. static struct class srp_class = {
  1349. .name = "infiniband_srp",
  1350. .dev_release = srp_release_dev
  1351. };
  1352. /*
  1353. * Target ports are added by writing
  1354. *
  1355. * id_ext=<SRP ID ext>,ioc_guid=<SRP IOC GUID>,dgid=<dest GID>,
  1356. * pkey=<P_Key>,service_id=<service ID>
  1357. *
  1358. * to the add_target sysfs attribute.
  1359. */
  1360. enum {
  1361. SRP_OPT_ERR = 0,
  1362. SRP_OPT_ID_EXT = 1 << 0,
  1363. SRP_OPT_IOC_GUID = 1 << 1,
  1364. SRP_OPT_DGID = 1 << 2,
  1365. SRP_OPT_PKEY = 1 << 3,
  1366. SRP_OPT_SERVICE_ID = 1 << 4,
  1367. SRP_OPT_MAX_SECT = 1 << 5,
  1368. SRP_OPT_MAX_CMD_PER_LUN = 1 << 6,
  1369. SRP_OPT_IO_CLASS = 1 << 7,
  1370. SRP_OPT_INITIATOR_EXT = 1 << 8,
  1371. SRP_OPT_ALL = (SRP_OPT_ID_EXT |
  1372. SRP_OPT_IOC_GUID |
  1373. SRP_OPT_DGID |
  1374. SRP_OPT_PKEY |
  1375. SRP_OPT_SERVICE_ID),
  1376. };
  1377. static const match_table_t srp_opt_tokens = {
  1378. { SRP_OPT_ID_EXT, "id_ext=%s" },
  1379. { SRP_OPT_IOC_GUID, "ioc_guid=%s" },
  1380. { SRP_OPT_DGID, "dgid=%s" },
  1381. { SRP_OPT_PKEY, "pkey=%x" },
  1382. { SRP_OPT_SERVICE_ID, "service_id=%s" },
  1383. { SRP_OPT_MAX_SECT, "max_sect=%d" },
  1384. { SRP_OPT_MAX_CMD_PER_LUN, "max_cmd_per_lun=%d" },
  1385. { SRP_OPT_IO_CLASS, "io_class=%x" },
  1386. { SRP_OPT_INITIATOR_EXT, "initiator_ext=%s" },
  1387. { SRP_OPT_ERR, NULL }
  1388. };
  1389. static int srp_parse_options(const char *buf, struct srp_target_port *target)
  1390. {
  1391. char *options, *sep_opt;
  1392. char *p;
  1393. char dgid[3];
  1394. substring_t args[MAX_OPT_ARGS];
  1395. int opt_mask = 0;
  1396. int token;
  1397. int ret = -EINVAL;
  1398. int i;
  1399. options = kstrdup(buf, GFP_KERNEL);
  1400. if (!options)
  1401. return -ENOMEM;
  1402. sep_opt = options;
  1403. while ((p = strsep(&sep_opt, ",")) != NULL) {
  1404. if (!*p)
  1405. continue;
  1406. token = match_token(p, srp_opt_tokens, args);
  1407. opt_mask |= token;
  1408. switch (token) {
  1409. case SRP_OPT_ID_EXT:
  1410. p = match_strdup(args);
  1411. if (!p) {
  1412. ret = -ENOMEM;
  1413. goto out;
  1414. }
  1415. target->id_ext = cpu_to_be64(simple_strtoull(p, NULL, 16));
  1416. kfree(p);
  1417. break;
  1418. case SRP_OPT_IOC_GUID:
  1419. p = match_strdup(args);
  1420. if (!p) {
  1421. ret = -ENOMEM;
  1422. goto out;
  1423. }
  1424. target->ioc_guid = cpu_to_be64(simple_strtoull(p, NULL, 16));
  1425. kfree(p);
  1426. break;
  1427. case SRP_OPT_DGID:
  1428. p = match_strdup(args);
  1429. if (!p) {
  1430. ret = -ENOMEM;
  1431. goto out;
  1432. }
  1433. if (strlen(p) != 32) {
  1434. printk(KERN_WARNING PFX "bad dest GID parameter '%s'\n", p);
  1435. kfree(p);
  1436. goto out;
  1437. }
  1438. for (i = 0; i < 16; ++i) {
  1439. strlcpy(dgid, p + i * 2, 3);
  1440. target->path.dgid.raw[i] = simple_strtoul(dgid, NULL, 16);
  1441. }
  1442. kfree(p);
  1443. memcpy(target->orig_dgid, target->path.dgid.raw, 16);
  1444. break;
  1445. case SRP_OPT_PKEY:
  1446. if (match_hex(args, &token)) {
  1447. printk(KERN_WARNING PFX "bad P_Key parameter '%s'\n", p);
  1448. goto out;
  1449. }
  1450. target->path.pkey = cpu_to_be16(token);
  1451. break;
  1452. case SRP_OPT_SERVICE_ID:
  1453. p = match_strdup(args);
  1454. if (!p) {
  1455. ret = -ENOMEM;
  1456. goto out;
  1457. }
  1458. target->service_id = cpu_to_be64(simple_strtoull(p, NULL, 16));
  1459. target->path.service_id = target->service_id;
  1460. kfree(p);
  1461. break;
  1462. case SRP_OPT_MAX_SECT:
  1463. if (match_int(args, &token)) {
  1464. printk(KERN_WARNING PFX "bad max sect parameter '%s'\n", p);
  1465. goto out;
  1466. }
  1467. target->scsi_host->max_sectors = token;
  1468. break;
  1469. case SRP_OPT_MAX_CMD_PER_LUN:
  1470. if (match_int(args, &token)) {
  1471. printk(KERN_WARNING PFX "bad max cmd_per_lun parameter '%s'\n", p);
  1472. goto out;
  1473. }
  1474. target->scsi_host->cmd_per_lun = min(token, SRP_SQ_SIZE);
  1475. break;
  1476. case SRP_OPT_IO_CLASS:
  1477. if (match_hex(args, &token)) {
  1478. printk(KERN_WARNING PFX "bad IO class parameter '%s' \n", p);
  1479. goto out;
  1480. }
  1481. if (token != SRP_REV10_IB_IO_CLASS &&
  1482. token != SRP_REV16A_IB_IO_CLASS) {
  1483. printk(KERN_WARNING PFX "unknown IO class parameter value"
  1484. " %x specified (use %x or %x).\n",
  1485. token, SRP_REV10_IB_IO_CLASS, SRP_REV16A_IB_IO_CLASS);
  1486. goto out;
  1487. }
  1488. target->io_class = token;
  1489. break;
  1490. case SRP_OPT_INITIATOR_EXT:
  1491. p = match_strdup(args);
  1492. if (!p) {
  1493. ret = -ENOMEM;
  1494. goto out;
  1495. }
  1496. target->initiator_ext = cpu_to_be64(simple_strtoull(p, NULL, 16));
  1497. kfree(p);
  1498. break;
  1499. default:
  1500. printk(KERN_WARNING PFX "unknown parameter or missing value "
  1501. "'%s' in target creation request\n", p);
  1502. goto out;
  1503. }
  1504. }
  1505. if ((opt_mask & SRP_OPT_ALL) == SRP_OPT_ALL)
  1506. ret = 0;
  1507. else
  1508. for (i = 0; i < ARRAY_SIZE(srp_opt_tokens); ++i)
  1509. if ((srp_opt_tokens[i].token & SRP_OPT_ALL) &&
  1510. !(srp_opt_tokens[i].token & opt_mask))
  1511. printk(KERN_WARNING PFX "target creation request is "
  1512. "missing parameter '%s'\n",
  1513. srp_opt_tokens[i].pattern);
  1514. out:
  1515. kfree(options);
  1516. return ret;
  1517. }
  1518. static ssize_t srp_create_target(struct device *dev,
  1519. struct device_attribute *attr,
  1520. const char *buf, size_t count)
  1521. {
  1522. struct srp_host *host =
  1523. container_of(dev, struct srp_host, dev);
  1524. struct Scsi_Host *target_host;
  1525. struct srp_target_port *target;
  1526. int ret;
  1527. int i;
  1528. target_host = scsi_host_alloc(&srp_template,
  1529. sizeof (struct srp_target_port));
  1530. if (!target_host)
  1531. return -ENOMEM;
  1532. target_host->transportt = ib_srp_transport_template;
  1533. target_host->max_lun = SRP_MAX_LUN;
  1534. target_host->max_cmd_len = sizeof ((struct srp_cmd *) (void *) 0L)->cdb;
  1535. target = host_to_target(target_host);
  1536. target->io_class = SRP_REV16A_IB_IO_CLASS;
  1537. target->scsi_host = target_host;
  1538. target->srp_host = host;
  1539. INIT_LIST_HEAD(&target->free_reqs);
  1540. INIT_LIST_HEAD(&target->req_queue);
  1541. for (i = 0; i < SRP_SQ_SIZE; ++i) {
  1542. target->req_ring[i].index = i;
  1543. list_add_tail(&target->req_ring[i].list, &target->free_reqs);
  1544. }
  1545. ret = srp_parse_options(buf, target);
  1546. if (ret)
  1547. goto err;
  1548. ib_query_gid(host->srp_dev->dev, host->port, 0, &target->path.sgid);
  1549. shost_printk(KERN_DEBUG, target->scsi_host, PFX
  1550. "new target: id_ext %016llx ioc_guid %016llx pkey %04x "
  1551. "service_id %016llx dgid %pI6\n",
  1552. (unsigned long long) be64_to_cpu(target->id_ext),
  1553. (unsigned long long) be64_to_cpu(target->ioc_guid),
  1554. be16_to_cpu(target->path.pkey),
  1555. (unsigned long long) be64_to_cpu(target->service_id),
  1556. target->path.dgid.raw);
  1557. ret = srp_create_target_ib(target);
  1558. if (ret)
  1559. goto err;
  1560. ret = srp_new_cm_id(target);
  1561. if (ret)
  1562. goto err_free;
  1563. target->qp_in_error = 0;
  1564. ret = srp_connect_target(target);
  1565. if (ret) {
  1566. shost_printk(KERN_ERR, target->scsi_host,
  1567. PFX "Connection failed\n");
  1568. goto err_cm_id;
  1569. }
  1570. ret = srp_add_target(host, target);
  1571. if (ret)
  1572. goto err_disconnect;
  1573. return count;
  1574. err_disconnect:
  1575. srp_disconnect_target(target);
  1576. err_cm_id:
  1577. ib_destroy_cm_id(target->cm_id);
  1578. err_free:
  1579. srp_free_target_ib(target);
  1580. err:
  1581. scsi_host_put(target_host);
  1582. return ret;
  1583. }
  1584. static DEVICE_ATTR(add_target, S_IWUSR, NULL, srp_create_target);
  1585. static ssize_t show_ibdev(struct device *dev, struct device_attribute *attr,
  1586. char *buf)
  1587. {
  1588. struct srp_host *host = container_of(dev, struct srp_host, dev);
  1589. return sprintf(buf, "%s\n", host->srp_dev->dev->name);
  1590. }
  1591. static DEVICE_ATTR(ibdev, S_IRUGO, show_ibdev, NULL);
  1592. static ssize_t show_port(struct device *dev, struct device_attribute *attr,
  1593. char *buf)
  1594. {
  1595. struct srp_host *host = container_of(dev, struct srp_host, dev);
  1596. return sprintf(buf, "%d\n", host->port);
  1597. }
  1598. static DEVICE_ATTR(port, S_IRUGO, show_port, NULL);
  1599. static struct srp_host *srp_add_port(struct srp_device *device, u8 port)
  1600. {
  1601. struct srp_host *host;
  1602. host = kzalloc(sizeof *host, GFP_KERNEL);
  1603. if (!host)
  1604. return NULL;
  1605. INIT_LIST_HEAD(&host->target_list);
  1606. spin_lock_init(&host->target_lock);
  1607. init_completion(&host->released);
  1608. host->srp_dev = device;
  1609. host->port = port;
  1610. host->dev.class = &srp_class;
  1611. host->dev.parent = device->dev->dma_device;
  1612. dev_set_name(&host->dev, "srp-%s-%d", device->dev->name, port);
  1613. if (device_register(&host->dev))
  1614. goto free_host;
  1615. if (device_create_file(&host->dev, &dev_attr_add_target))
  1616. goto err_class;
  1617. if (device_create_file(&host->dev, &dev_attr_ibdev))
  1618. goto err_class;
  1619. if (device_create_file(&host->dev, &dev_attr_port))
  1620. goto err_class;
  1621. return host;
  1622. err_class:
  1623. device_unregister(&host->dev);
  1624. free_host:
  1625. kfree(host);
  1626. return NULL;
  1627. }
  1628. static void srp_add_one(struct ib_device *device)
  1629. {
  1630. struct srp_device *srp_dev;
  1631. struct ib_device_attr *dev_attr;
  1632. struct ib_fmr_pool_param fmr_param;
  1633. struct srp_host *host;
  1634. int s, e, p;
  1635. dev_attr = kmalloc(sizeof *dev_attr, GFP_KERNEL);
  1636. if (!dev_attr)
  1637. return;
  1638. if (ib_query_device(device, dev_attr)) {
  1639. printk(KERN_WARNING PFX "Query device failed for %s\n",
  1640. device->name);
  1641. goto free_attr;
  1642. }
  1643. srp_dev = kmalloc(sizeof *srp_dev, GFP_KERNEL);
  1644. if (!srp_dev)
  1645. goto free_attr;
  1646. /*
  1647. * Use the smallest page size supported by the HCA, down to a
  1648. * minimum of 512 bytes (which is the smallest sector that a
  1649. * SCSI command will ever carry).
  1650. */
  1651. srp_dev->fmr_page_shift = max(9, ffs(dev_attr->page_size_cap) - 1);
  1652. srp_dev->fmr_page_size = 1 << srp_dev->fmr_page_shift;
  1653. srp_dev->fmr_page_mask = ~((u64) srp_dev->fmr_page_size - 1);
  1654. INIT_LIST_HEAD(&srp_dev->dev_list);
  1655. srp_dev->dev = device;
  1656. srp_dev->pd = ib_alloc_pd(device);
  1657. if (IS_ERR(srp_dev->pd))
  1658. goto free_dev;
  1659. srp_dev->mr = ib_get_dma_mr(srp_dev->pd,
  1660. IB_ACCESS_LOCAL_WRITE |
  1661. IB_ACCESS_REMOTE_READ |
  1662. IB_ACCESS_REMOTE_WRITE);
  1663. if (IS_ERR(srp_dev->mr))
  1664. goto err_pd;
  1665. memset(&fmr_param, 0, sizeof fmr_param);
  1666. fmr_param.pool_size = SRP_FMR_POOL_SIZE;
  1667. fmr_param.dirty_watermark = SRP_FMR_DIRTY_SIZE;
  1668. fmr_param.cache = 1;
  1669. fmr_param.max_pages_per_fmr = SRP_FMR_SIZE;
  1670. fmr_param.page_shift = srp_dev->fmr_page_shift;
  1671. fmr_param.access = (IB_ACCESS_LOCAL_WRITE |
  1672. IB_ACCESS_REMOTE_WRITE |
  1673. IB_ACCESS_REMOTE_READ);
  1674. srp_dev->fmr_pool = ib_create_fmr_pool(srp_dev->pd, &fmr_param);
  1675. if (IS_ERR(srp_dev->fmr_pool))
  1676. srp_dev->fmr_pool = NULL;
  1677. if (device->node_type == RDMA_NODE_IB_SWITCH) {
  1678. s = 0;
  1679. e = 0;
  1680. } else {
  1681. s = 1;
  1682. e = device->phys_port_cnt;
  1683. }
  1684. for (p = s; p <= e; ++p) {
  1685. host = srp_add_port(srp_dev, p);
  1686. if (host)
  1687. list_add_tail(&host->list, &srp_dev->dev_list);
  1688. }
  1689. ib_set_client_data(device, &srp_client, srp_dev);
  1690. goto free_attr;
  1691. err_pd:
  1692. ib_dealloc_pd(srp_dev->pd);
  1693. free_dev:
  1694. kfree(srp_dev);
  1695. free_attr:
  1696. kfree(dev_attr);
  1697. }
  1698. static void srp_remove_one(struct ib_device *device)
  1699. {
  1700. struct srp_device *srp_dev;
  1701. struct srp_host *host, *tmp_host;
  1702. LIST_HEAD(target_list);
  1703. struct srp_target_port *target, *tmp_target;
  1704. srp_dev = ib_get_client_data(device, &srp_client);
  1705. list_for_each_entry_safe(host, tmp_host, &srp_dev->dev_list, list) {
  1706. device_unregister(&host->dev);
  1707. /*
  1708. * Wait for the sysfs entry to go away, so that no new
  1709. * target ports can be created.
  1710. */
  1711. wait_for_completion(&host->released);
  1712. /*
  1713. * Mark all target ports as removed, so we stop queueing
  1714. * commands and don't try to reconnect.
  1715. */
  1716. spin_lock(&host->target_lock);
  1717. list_for_each_entry(target, &host->target_list, list) {
  1718. spin_lock_irq(target->scsi_host->host_lock);
  1719. target->state = SRP_TARGET_REMOVED;
  1720. spin_unlock_irq(target->scsi_host->host_lock);
  1721. }
  1722. spin_unlock(&host->target_lock);
  1723. /*
  1724. * Wait for any reconnection tasks that may have
  1725. * started before we marked our target ports as
  1726. * removed, and any target port removal tasks.
  1727. */
  1728. flush_scheduled_work();
  1729. list_for_each_entry_safe(target, tmp_target,
  1730. &host->target_list, list) {
  1731. srp_remove_host(target->scsi_host);
  1732. scsi_remove_host(target->scsi_host);
  1733. srp_disconnect_target(target);
  1734. ib_destroy_cm_id(target->cm_id);
  1735. srp_free_target_ib(target);
  1736. scsi_host_put(target->scsi_host);
  1737. }
  1738. kfree(host);
  1739. }
  1740. if (srp_dev->fmr_pool)
  1741. ib_destroy_fmr_pool(srp_dev->fmr_pool);
  1742. ib_dereg_mr(srp_dev->mr);
  1743. ib_dealloc_pd(srp_dev->pd);
  1744. kfree(srp_dev);
  1745. }
  1746. static struct srp_function_template ib_srp_transport_functions = {
  1747. };
  1748. static int __init srp_init_module(void)
  1749. {
  1750. int ret;
  1751. if (srp_sg_tablesize > 255) {
  1752. printk(KERN_WARNING PFX "Clamping srp_sg_tablesize to 255\n");
  1753. srp_sg_tablesize = 255;
  1754. }
  1755. ib_srp_transport_template =
  1756. srp_attach_transport(&ib_srp_transport_functions);
  1757. if (!ib_srp_transport_template)
  1758. return -ENOMEM;
  1759. srp_template.sg_tablesize = srp_sg_tablesize;
  1760. srp_max_iu_len = (sizeof (struct srp_cmd) +
  1761. sizeof (struct srp_indirect_buf) +
  1762. srp_sg_tablesize * 16);
  1763. ret = class_register(&srp_class);
  1764. if (ret) {
  1765. printk(KERN_ERR PFX "couldn't register class infiniband_srp\n");
  1766. srp_release_transport(ib_srp_transport_template);
  1767. return ret;
  1768. }
  1769. ib_sa_register_client(&srp_sa_client);
  1770. ret = ib_register_client(&srp_client);
  1771. if (ret) {
  1772. printk(KERN_ERR PFX "couldn't register IB client\n");
  1773. srp_release_transport(ib_srp_transport_template);
  1774. ib_sa_unregister_client(&srp_sa_client);
  1775. class_unregister(&srp_class);
  1776. return ret;
  1777. }
  1778. return 0;
  1779. }
  1780. static void __exit srp_cleanup_module(void)
  1781. {
  1782. ib_unregister_client(&srp_client);
  1783. ib_sa_unregister_client(&srp_sa_client);
  1784. class_unregister(&srp_class);
  1785. srp_release_transport(ib_srp_transport_template);
  1786. }
  1787. module_init(srp_init_module);
  1788. module_exit(srp_cleanup_module);