zfcp_fsf.c 78 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771772773774775776777778779780781782783784785786787788789790791792793794795796797798799800801802803804805806807808809810811812813814815816817818819820821822823824825826827828829830831832833834835836837838839840841842843844845846847848849850851852853854855856857858859860861862863864865866867868869870871872873874875876877878879880881882883884885886887888889890891892893894895896897898899900901902903904905906907908909910911912913914915916917918919920921922923924925926927928929930931932933934935936937938939940941942943944945946947948949950951952953954955956957958959960961962963964965966967968969970971972973974975976977978979980981982983984985986987988989990991992993994995996997998999100010011002100310041005100610071008100910101011101210131014101510161017101810191020102110221023102410251026102710281029103010311032103310341035103610371038103910401041104210431044104510461047104810491050105110521053105410551056105710581059106010611062106310641065106610671068106910701071107210731074107510761077107810791080108110821083108410851086108710881089109010911092109310941095109610971098109911001101110211031104110511061107110811091110111111121113111411151116111711181119112011211122112311241125112611271128112911301131113211331134113511361137113811391140114111421143114411451146114711481149115011511152115311541155115611571158115911601161116211631164116511661167116811691170117111721173117411751176117711781179118011811182118311841185118611871188118911901191119211931194119511961197119811991200120112021203120412051206120712081209121012111212121312141215121612171218121912201221122212231224122512261227122812291230123112321233123412351236123712381239124012411242124312441245124612471248124912501251125212531254125512561257125812591260126112621263126412651266126712681269127012711272127312741275127612771278127912801281128212831284128512861287128812891290129112921293129412951296129712981299130013011302130313041305130613071308130913101311131213131314131513161317131813191320132113221323132413251326132713281329133013311332133313341335133613371338133913401341134213431344134513461347134813491350135113521353135413551356135713581359136013611362136313641365136613671368136913701371137213731374137513761377137813791380138113821383138413851386138713881389139013911392139313941395139613971398139914001401140214031404140514061407140814091410141114121413141414151416141714181419142014211422142314241425142614271428142914301431143214331434143514361437143814391440144114421443144414451446144714481449145014511452145314541455145614571458145914601461146214631464146514661467146814691470147114721473147414751476147714781479148014811482148314841485148614871488148914901491149214931494149514961497149814991500150115021503150415051506150715081509151015111512151315141515151615171518151915201521152215231524152515261527152815291530153115321533153415351536153715381539154015411542154315441545154615471548154915501551155215531554155515561557155815591560156115621563156415651566156715681569157015711572157315741575157615771578157915801581158215831584158515861587158815891590159115921593159415951596159715981599160016011602160316041605160616071608160916101611161216131614161516161617161816191620162116221623162416251626162716281629163016311632163316341635163616371638163916401641164216431644164516461647164816491650165116521653165416551656165716581659166016611662166316641665166616671668166916701671167216731674167516761677167816791680168116821683168416851686168716881689169016911692169316941695169616971698169917001701170217031704170517061707170817091710171117121713171417151716171717181719172017211722172317241725172617271728172917301731173217331734173517361737173817391740174117421743174417451746174717481749175017511752175317541755175617571758175917601761176217631764176517661767176817691770177117721773177417751776177717781779178017811782178317841785178617871788178917901791179217931794179517961797179817991800180118021803180418051806180718081809181018111812181318141815181618171818181918201821182218231824182518261827182818291830183118321833183418351836183718381839184018411842184318441845184618471848184918501851185218531854185518561857185818591860186118621863186418651866186718681869187018711872187318741875187618771878187918801881188218831884188518861887188818891890189118921893189418951896189718981899190019011902190319041905190619071908190919101911191219131914191519161917191819191920192119221923192419251926192719281929193019311932193319341935193619371938193919401941194219431944194519461947194819491950195119521953195419551956195719581959196019611962196319641965196619671968196919701971197219731974197519761977197819791980198119821983198419851986198719881989199019911992199319941995199619971998199920002001200220032004200520062007200820092010201120122013201420152016201720182019202020212022202320242025202620272028202920302031203220332034203520362037203820392040204120422043204420452046204720482049205020512052205320542055205620572058205920602061206220632064206520662067206820692070207120722073207420752076207720782079208020812082208320842085208620872088208920902091209220932094209520962097209820992100210121022103210421052106210721082109211021112112211321142115211621172118211921202121212221232124212521262127212821292130213121322133213421352136213721382139214021412142214321442145214621472148214921502151215221532154215521562157215821592160216121622163216421652166216721682169217021712172217321742175217621772178217921802181218221832184218521862187218821892190219121922193219421952196219721982199220022012202220322042205220622072208220922102211221222132214221522162217221822192220222122222223222422252226222722282229223022312232223322342235223622372238223922402241224222432244224522462247224822492250225122522253225422552256225722582259226022612262226322642265226622672268226922702271227222732274227522762277227822792280228122822283228422852286228722882289229022912292229322942295229622972298229923002301230223032304230523062307230823092310231123122313231423152316231723182319232023212322232323242325232623272328232923302331233223332334233523362337233823392340234123422343234423452346234723482349235023512352235323542355235623572358235923602361236223632364236523662367236823692370237123722373237423752376237723782379238023812382238323842385238623872388238923902391239223932394239523962397239823992400240124022403240424052406240724082409241024112412241324142415241624172418241924202421242224232424242524262427242824292430243124322433243424352436243724382439244024412442244324442445244624472448244924502451245224532454245524562457245824592460246124622463246424652466246724682469247024712472247324742475247624772478247924802481248224832484248524862487248824892490249124922493249424952496249724982499250025012502250325042505250625072508250925102511251225132514251525162517251825192520252125222523252425252526252725282529253025312532253325342535253625372538253925402541254225432544254525462547254825492550255125522553255425552556255725582559256025612562256325642565256625672568256925702571257225732574257525762577257825792580258125822583258425852586258725882589259025912592259325942595259625972598259926002601260226032604260526062607260826092610261126122613261426152616261726182619262026212622262326242625262626272628262926302631263226332634263526362637263826392640264126422643264426452646264726482649265026512652265326542655265626572658265926602661266226632664266526662667266826692670267126722673267426752676267726782679268026812682268326842685268626872688268926902691269226932694269526962697269826992700270127022703270427052706270727082709271027112712271327142715271627172718271927202721272227232724272527262727272827292730273127322733273427352736273727382739274027412742
  1. // SPDX-License-Identifier: GPL-2.0
  2. /*
  3. * zfcp device driver
  4. *
  5. * Implementation of FSF commands.
  6. *
  7. * Copyright IBM Corp. 2002, 2020
  8. */
  9. #define KMSG_COMPONENT "zfcp"
  10. #define pr_fmt(fmt) KMSG_COMPONENT ": " fmt
  11. #include <linux/blktrace_api.h>
  12. #include <linux/jiffies.h>
  13. #include <linux/types.h>
  14. #include <linux/slab.h>
  15. #include <scsi/fc/fc_els.h>
  16. #include "zfcp_ext.h"
  17. #include "zfcp_fc.h"
  18. #include "zfcp_dbf.h"
  19. #include "zfcp_qdio.h"
  20. #include "zfcp_reqlist.h"
  21. #include "zfcp_diag.h"
  22. /* timeout for FSF requests sent during scsi_eh: abort or FCP TMF */
  23. #define ZFCP_FSF_SCSI_ER_TIMEOUT (10*HZ)
  24. /* timeout for: exchange config/port data outside ERP, or open/close WKA port */
  25. #define ZFCP_FSF_REQUEST_TIMEOUT (60*HZ)
  26. struct kmem_cache *zfcp_fsf_qtcb_cache;
  27. static bool ber_stop = true;
  28. module_param(ber_stop, bool, 0600);
  29. MODULE_PARM_DESC(ber_stop,
  30. "Shuts down FCP devices for FCP channels that report a bit-error count in excess of its threshold (default on)");
  31. static void zfcp_fsf_request_timeout_handler(struct timer_list *t)
  32. {
  33. struct zfcp_fsf_req *fsf_req = from_timer(fsf_req, t, timer);
  34. struct zfcp_adapter *adapter = fsf_req->adapter;
  35. zfcp_qdio_siosl(adapter);
  36. zfcp_erp_adapter_reopen(adapter, ZFCP_STATUS_COMMON_ERP_FAILED,
  37. "fsrth_1");
  38. }
  39. static void zfcp_fsf_start_timer(struct zfcp_fsf_req *fsf_req,
  40. unsigned long timeout)
  41. {
  42. fsf_req->timer.function = zfcp_fsf_request_timeout_handler;
  43. fsf_req->timer.expires = jiffies + timeout;
  44. add_timer(&fsf_req->timer);
  45. }
  46. static void zfcp_fsf_start_erp_timer(struct zfcp_fsf_req *fsf_req)
  47. {
  48. BUG_ON(!fsf_req->erp_action);
  49. fsf_req->timer.function = zfcp_erp_timeout_handler;
  50. fsf_req->timer.expires = jiffies + 30 * HZ;
  51. add_timer(&fsf_req->timer);
  52. }
  53. /* association between FSF command and FSF QTCB type */
  54. static u32 fsf_qtcb_type[] = {
  55. [FSF_QTCB_FCP_CMND] = FSF_IO_COMMAND,
  56. [FSF_QTCB_ABORT_FCP_CMND] = FSF_SUPPORT_COMMAND,
  57. [FSF_QTCB_OPEN_PORT_WITH_DID] = FSF_SUPPORT_COMMAND,
  58. [FSF_QTCB_OPEN_LUN] = FSF_SUPPORT_COMMAND,
  59. [FSF_QTCB_CLOSE_LUN] = FSF_SUPPORT_COMMAND,
  60. [FSF_QTCB_CLOSE_PORT] = FSF_SUPPORT_COMMAND,
  61. [FSF_QTCB_CLOSE_PHYSICAL_PORT] = FSF_SUPPORT_COMMAND,
  62. [FSF_QTCB_SEND_ELS] = FSF_SUPPORT_COMMAND,
  63. [FSF_QTCB_SEND_GENERIC] = FSF_SUPPORT_COMMAND,
  64. [FSF_QTCB_EXCHANGE_CONFIG_DATA] = FSF_CONFIG_COMMAND,
  65. [FSF_QTCB_EXCHANGE_PORT_DATA] = FSF_PORT_COMMAND,
  66. [FSF_QTCB_DOWNLOAD_CONTROL_FILE] = FSF_SUPPORT_COMMAND,
  67. [FSF_QTCB_UPLOAD_CONTROL_FILE] = FSF_SUPPORT_COMMAND
  68. };
  69. static void zfcp_fsf_class_not_supp(struct zfcp_fsf_req *req)
  70. {
  71. dev_err(&req->adapter->ccw_device->dev, "FCP device not "
  72. "operational because of an unsupported FC class\n");
  73. zfcp_erp_adapter_shutdown(req->adapter, 0, "fscns_1");
  74. req->status |= ZFCP_STATUS_FSFREQ_ERROR;
  75. }
  76. /**
  77. * zfcp_fsf_req_free - free memory used by fsf request
  78. * @req: pointer to struct zfcp_fsf_req
  79. */
  80. void zfcp_fsf_req_free(struct zfcp_fsf_req *req)
  81. {
  82. if (likely(req->pool)) {
  83. if (likely(!zfcp_fsf_req_is_status_read_buffer(req)))
  84. mempool_free(req->qtcb, req->adapter->pool.qtcb_pool);
  85. mempool_free(req, req->pool);
  86. return;
  87. }
  88. if (likely(!zfcp_fsf_req_is_status_read_buffer(req)))
  89. kmem_cache_free(zfcp_fsf_qtcb_cache, req->qtcb);
  90. kfree(req);
  91. }
  92. static void zfcp_fsf_status_read_port_closed(struct zfcp_fsf_req *req)
  93. {
  94. unsigned long flags;
  95. struct fsf_status_read_buffer *sr_buf = req->data;
  96. struct zfcp_adapter *adapter = req->adapter;
  97. struct zfcp_port *port;
  98. int d_id = ntoh24(sr_buf->d_id);
  99. read_lock_irqsave(&adapter->port_list_lock, flags);
  100. list_for_each_entry(port, &adapter->port_list, list)
  101. if (port->d_id == d_id) {
  102. zfcp_erp_port_reopen(port, 0, "fssrpc1");
  103. break;
  104. }
  105. read_unlock_irqrestore(&adapter->port_list_lock, flags);
  106. }
  107. void zfcp_fsf_fc_host_link_down(struct zfcp_adapter *adapter)
  108. {
  109. struct Scsi_Host *shost = adapter->scsi_host;
  110. adapter->hydra_version = 0;
  111. adapter->peer_wwpn = 0;
  112. adapter->peer_wwnn = 0;
  113. adapter->peer_d_id = 0;
  114. /* if there is no shost yet, we have nothing to zero-out */
  115. if (shost == NULL)
  116. return;
  117. fc_host_port_id(shost) = 0;
  118. fc_host_fabric_name(shost) = 0;
  119. fc_host_speed(shost) = FC_PORTSPEED_UNKNOWN;
  120. fc_host_port_type(shost) = FC_PORTTYPE_UNKNOWN;
  121. snprintf(fc_host_model(shost), FC_SYMBOLIC_NAME_SIZE, "0x%04x", 0);
  122. memset(fc_host_active_fc4s(shost), 0, FC_FC4_LIST_SIZE);
  123. }
  124. static void zfcp_fsf_link_down_info_eval(struct zfcp_fsf_req *req,
  125. struct fsf_link_down_info *link_down)
  126. {
  127. struct zfcp_adapter *adapter = req->adapter;
  128. if (atomic_read(&adapter->status) & ZFCP_STATUS_ADAPTER_LINK_UNPLUGGED)
  129. return;
  130. atomic_or(ZFCP_STATUS_ADAPTER_LINK_UNPLUGGED, &adapter->status);
  131. zfcp_scsi_schedule_rports_block(adapter);
  132. zfcp_fsf_fc_host_link_down(adapter);
  133. if (!link_down)
  134. goto out;
  135. switch (link_down->error_code) {
  136. case FSF_PSQ_LINK_NO_LIGHT:
  137. dev_warn(&req->adapter->ccw_device->dev,
  138. "There is no light signal from the local "
  139. "fibre channel cable\n");
  140. break;
  141. case FSF_PSQ_LINK_WRAP_PLUG:
  142. dev_warn(&req->adapter->ccw_device->dev,
  143. "There is a wrap plug instead of a fibre "
  144. "channel cable\n");
  145. break;
  146. case FSF_PSQ_LINK_NO_FCP:
  147. dev_warn(&req->adapter->ccw_device->dev,
  148. "The adjacent fibre channel node does not "
  149. "support FCP\n");
  150. break;
  151. case FSF_PSQ_LINK_FIRMWARE_UPDATE:
  152. dev_warn(&req->adapter->ccw_device->dev,
  153. "The FCP device is suspended because of a "
  154. "firmware update\n");
  155. break;
  156. case FSF_PSQ_LINK_INVALID_WWPN:
  157. dev_warn(&req->adapter->ccw_device->dev,
  158. "The FCP device detected a WWPN that is "
  159. "duplicate or not valid\n");
  160. break;
  161. case FSF_PSQ_LINK_NO_NPIV_SUPPORT:
  162. dev_warn(&req->adapter->ccw_device->dev,
  163. "The fibre channel fabric does not support NPIV\n");
  164. break;
  165. case FSF_PSQ_LINK_NO_FCP_RESOURCES:
  166. dev_warn(&req->adapter->ccw_device->dev,
  167. "The FCP adapter cannot support more NPIV ports\n");
  168. break;
  169. case FSF_PSQ_LINK_NO_FABRIC_RESOURCES:
  170. dev_warn(&req->adapter->ccw_device->dev,
  171. "The adjacent switch cannot support "
  172. "more NPIV ports\n");
  173. break;
  174. case FSF_PSQ_LINK_FABRIC_LOGIN_UNABLE:
  175. dev_warn(&req->adapter->ccw_device->dev,
  176. "The FCP adapter could not log in to the "
  177. "fibre channel fabric\n");
  178. break;
  179. case FSF_PSQ_LINK_WWPN_ASSIGNMENT_CORRUPTED:
  180. dev_warn(&req->adapter->ccw_device->dev,
  181. "The WWPN assignment file on the FCP adapter "
  182. "has been damaged\n");
  183. break;
  184. case FSF_PSQ_LINK_MODE_TABLE_CURRUPTED:
  185. dev_warn(&req->adapter->ccw_device->dev,
  186. "The mode table on the FCP adapter "
  187. "has been damaged\n");
  188. break;
  189. case FSF_PSQ_LINK_NO_WWPN_ASSIGNMENT:
  190. dev_warn(&req->adapter->ccw_device->dev,
  191. "All NPIV ports on the FCP adapter have "
  192. "been assigned\n");
  193. break;
  194. default:
  195. dev_warn(&req->adapter->ccw_device->dev,
  196. "The link between the FCP adapter and "
  197. "the FC fabric is down\n");
  198. }
  199. out:
  200. zfcp_erp_set_adapter_status(adapter, ZFCP_STATUS_COMMON_ERP_FAILED);
  201. }
  202. static void zfcp_fsf_status_read_link_down(struct zfcp_fsf_req *req)
  203. {
  204. struct fsf_status_read_buffer *sr_buf = req->data;
  205. struct fsf_link_down_info *ldi =
  206. (struct fsf_link_down_info *) &sr_buf->payload;
  207. switch (sr_buf->status_subtype) {
  208. case FSF_STATUS_READ_SUB_NO_PHYSICAL_LINK:
  209. case FSF_STATUS_READ_SUB_FDISC_FAILED:
  210. zfcp_fsf_link_down_info_eval(req, ldi);
  211. break;
  212. case FSF_STATUS_READ_SUB_FIRMWARE_UPDATE:
  213. zfcp_fsf_link_down_info_eval(req, NULL);
  214. }
  215. }
  216. static void zfcp_fsf_status_read_handler(struct zfcp_fsf_req *req)
  217. {
  218. struct zfcp_adapter *adapter = req->adapter;
  219. struct fsf_status_read_buffer *sr_buf = req->data;
  220. if (req->status & ZFCP_STATUS_FSFREQ_DISMISSED) {
  221. zfcp_dbf_hba_fsf_uss("fssrh_1", req);
  222. mempool_free(virt_to_page(sr_buf), adapter->pool.sr_data);
  223. zfcp_fsf_req_free(req);
  224. return;
  225. }
  226. zfcp_dbf_hba_fsf_uss("fssrh_4", req);
  227. switch (sr_buf->status_type) {
  228. case FSF_STATUS_READ_PORT_CLOSED:
  229. zfcp_fsf_status_read_port_closed(req);
  230. break;
  231. case FSF_STATUS_READ_INCOMING_ELS:
  232. zfcp_fc_incoming_els(req);
  233. break;
  234. case FSF_STATUS_READ_SENSE_DATA_AVAIL:
  235. break;
  236. case FSF_STATUS_READ_BIT_ERROR_THRESHOLD:
  237. zfcp_dbf_hba_bit_err("fssrh_3", req);
  238. if (ber_stop) {
  239. dev_warn(&adapter->ccw_device->dev,
  240. "All paths over this FCP device are disused because of excessive bit errors\n");
  241. zfcp_erp_adapter_shutdown(adapter, 0, "fssrh_b");
  242. } else {
  243. dev_warn(&adapter->ccw_device->dev,
  244. "The error threshold for checksum statistics has been exceeded\n");
  245. }
  246. break;
  247. case FSF_STATUS_READ_LINK_DOWN:
  248. zfcp_fsf_status_read_link_down(req);
  249. zfcp_fc_enqueue_event(adapter, FCH_EVT_LINKDOWN, 0);
  250. break;
  251. case FSF_STATUS_READ_LINK_UP:
  252. dev_info(&adapter->ccw_device->dev,
  253. "The local link has been restored\n");
  254. /* All ports should be marked as ready to run again */
  255. zfcp_erp_set_adapter_status(adapter,
  256. ZFCP_STATUS_COMMON_RUNNING);
  257. zfcp_erp_adapter_reopen(adapter,
  258. ZFCP_STATUS_ADAPTER_LINK_UNPLUGGED |
  259. ZFCP_STATUS_COMMON_ERP_FAILED,
  260. "fssrh_2");
  261. zfcp_fc_enqueue_event(adapter, FCH_EVT_LINKUP, 0);
  262. break;
  263. case FSF_STATUS_READ_NOTIFICATION_LOST:
  264. if (sr_buf->status_subtype & FSF_STATUS_READ_SUB_INCOMING_ELS)
  265. zfcp_fc_conditional_port_scan(adapter);
  266. break;
  267. case FSF_STATUS_READ_FEATURE_UPDATE_ALERT:
  268. adapter->adapter_features = sr_buf->payload.word[0];
  269. break;
  270. }
  271. mempool_free(virt_to_page(sr_buf), adapter->pool.sr_data);
  272. zfcp_fsf_req_free(req);
  273. atomic_inc(&adapter->stat_miss);
  274. queue_work(adapter->work_queue, &adapter->stat_work);
  275. }
  276. static void zfcp_fsf_fsfstatus_qual_eval(struct zfcp_fsf_req *req)
  277. {
  278. switch (req->qtcb->header.fsf_status_qual.word[0]) {
  279. case FSF_SQ_FCP_RSP_AVAILABLE:
  280. case FSF_SQ_INVOKE_LINK_TEST_PROCEDURE:
  281. case FSF_SQ_NO_RETRY_POSSIBLE:
  282. case FSF_SQ_ULP_DEPENDENT_ERP_REQUIRED:
  283. return;
  284. case FSF_SQ_COMMAND_ABORTED:
  285. break;
  286. case FSF_SQ_NO_RECOM:
  287. dev_err(&req->adapter->ccw_device->dev,
  288. "The FCP adapter reported a problem "
  289. "that cannot be recovered\n");
  290. zfcp_qdio_siosl(req->adapter);
  291. zfcp_erp_adapter_shutdown(req->adapter, 0, "fsfsqe1");
  292. break;
  293. }
  294. /* all non-return stats set FSFREQ_ERROR*/
  295. req->status |= ZFCP_STATUS_FSFREQ_ERROR;
  296. }
  297. static void zfcp_fsf_fsfstatus_eval(struct zfcp_fsf_req *req)
  298. {
  299. if (unlikely(req->status & ZFCP_STATUS_FSFREQ_ERROR))
  300. return;
  301. switch (req->qtcb->header.fsf_status) {
  302. case FSF_UNKNOWN_COMMAND:
  303. dev_err(&req->adapter->ccw_device->dev,
  304. "The FCP adapter does not recognize the command 0x%x\n",
  305. req->qtcb->header.fsf_command);
  306. zfcp_erp_adapter_shutdown(req->adapter, 0, "fsfse_1");
  307. req->status |= ZFCP_STATUS_FSFREQ_ERROR;
  308. break;
  309. case FSF_ADAPTER_STATUS_AVAILABLE:
  310. zfcp_fsf_fsfstatus_qual_eval(req);
  311. break;
  312. }
  313. }
  314. static void zfcp_fsf_protstatus_eval(struct zfcp_fsf_req *req)
  315. {
  316. struct zfcp_adapter *adapter = req->adapter;
  317. struct fsf_qtcb *qtcb = req->qtcb;
  318. union fsf_prot_status_qual *psq = &qtcb->prefix.prot_status_qual;
  319. zfcp_dbf_hba_fsf_response(req);
  320. if (req->status & ZFCP_STATUS_FSFREQ_DISMISSED) {
  321. req->status |= ZFCP_STATUS_FSFREQ_ERROR;
  322. return;
  323. }
  324. switch (qtcb->prefix.prot_status) {
  325. case FSF_PROT_GOOD:
  326. case FSF_PROT_FSF_STATUS_PRESENTED:
  327. return;
  328. case FSF_PROT_QTCB_VERSION_ERROR:
  329. dev_err(&adapter->ccw_device->dev,
  330. "QTCB version 0x%x not supported by FCP adapter "
  331. "(0x%x to 0x%x)\n", FSF_QTCB_CURRENT_VERSION,
  332. psq->word[0], psq->word[1]);
  333. zfcp_erp_adapter_shutdown(adapter, 0, "fspse_1");
  334. break;
  335. case FSF_PROT_ERROR_STATE:
  336. case FSF_PROT_SEQ_NUMB_ERROR:
  337. zfcp_erp_adapter_reopen(adapter, 0, "fspse_2");
  338. req->status |= ZFCP_STATUS_FSFREQ_ERROR;
  339. break;
  340. case FSF_PROT_UNSUPP_QTCB_TYPE:
  341. dev_err(&adapter->ccw_device->dev,
  342. "The QTCB type is not supported by the FCP adapter\n");
  343. zfcp_erp_adapter_shutdown(adapter, 0, "fspse_3");
  344. break;
  345. case FSF_PROT_HOST_CONNECTION_INITIALIZING:
  346. atomic_or(ZFCP_STATUS_ADAPTER_HOST_CON_INIT,
  347. &adapter->status);
  348. break;
  349. case FSF_PROT_DUPLICATE_REQUEST_ID:
  350. dev_err(&adapter->ccw_device->dev,
  351. "0x%Lx is an ambiguous request identifier\n",
  352. (unsigned long long)qtcb->bottom.support.req_handle);
  353. zfcp_erp_adapter_shutdown(adapter, 0, "fspse_4");
  354. break;
  355. case FSF_PROT_LINK_DOWN:
  356. zfcp_fsf_link_down_info_eval(req, &psq->link_down_info);
  357. /* go through reopen to flush pending requests */
  358. zfcp_erp_adapter_reopen(adapter, 0, "fspse_6");
  359. break;
  360. case FSF_PROT_REEST_QUEUE:
  361. /* All ports should be marked as ready to run again */
  362. zfcp_erp_set_adapter_status(adapter,
  363. ZFCP_STATUS_COMMON_RUNNING);
  364. zfcp_erp_adapter_reopen(adapter,
  365. ZFCP_STATUS_ADAPTER_LINK_UNPLUGGED |
  366. ZFCP_STATUS_COMMON_ERP_FAILED,
  367. "fspse_8");
  368. break;
  369. default:
  370. dev_err(&adapter->ccw_device->dev,
  371. "0x%x is not a valid transfer protocol status\n",
  372. qtcb->prefix.prot_status);
  373. zfcp_qdio_siosl(adapter);
  374. zfcp_erp_adapter_shutdown(adapter, 0, "fspse_9");
  375. }
  376. req->status |= ZFCP_STATUS_FSFREQ_ERROR;
  377. }
  378. /**
  379. * zfcp_fsf_req_complete - process completion of a FSF request
  380. * @req: The FSF request that has been completed.
  381. *
  382. * When a request has been completed either from the FCP adapter,
  383. * or it has been dismissed due to a queue shutdown, this function
  384. * is called to process the completion status and trigger further
  385. * events related to the FSF request.
  386. * Caller must ensure that the request has been removed from
  387. * adapter->req_list, to protect against concurrent modification
  388. * by zfcp_erp_strategy_check_fsfreq().
  389. */
  390. static void zfcp_fsf_req_complete(struct zfcp_fsf_req *req)
  391. {
  392. struct zfcp_erp_action *erp_action;
  393. if (unlikely(zfcp_fsf_req_is_status_read_buffer(req))) {
  394. zfcp_fsf_status_read_handler(req);
  395. return;
  396. }
  397. del_timer_sync(&req->timer);
  398. zfcp_fsf_protstatus_eval(req);
  399. zfcp_fsf_fsfstatus_eval(req);
  400. req->handler(req);
  401. erp_action = req->erp_action;
  402. if (erp_action)
  403. zfcp_erp_notify(erp_action, 0);
  404. if (likely(req->status & ZFCP_STATUS_FSFREQ_CLEANUP))
  405. zfcp_fsf_req_free(req);
  406. else
  407. complete(&req->completion);
  408. }
  409. /**
  410. * zfcp_fsf_req_dismiss_all - dismiss all fsf requests
  411. * @adapter: pointer to struct zfcp_adapter
  412. *
  413. * Never ever call this without shutting down the adapter first.
  414. * Otherwise the adapter would continue using and corrupting s390 storage.
  415. * Included BUG_ON() call to ensure this is done.
  416. * ERP is supposed to be the only user of this function.
  417. */
  418. void zfcp_fsf_req_dismiss_all(struct zfcp_adapter *adapter)
  419. {
  420. struct zfcp_fsf_req *req, *tmp;
  421. LIST_HEAD(remove_queue);
  422. BUG_ON(atomic_read(&adapter->status) & ZFCP_STATUS_ADAPTER_QDIOUP);
  423. zfcp_reqlist_move(adapter->req_list, &remove_queue);
  424. list_for_each_entry_safe(req, tmp, &remove_queue, list) {
  425. list_del(&req->list);
  426. req->status |= ZFCP_STATUS_FSFREQ_DISMISSED;
  427. zfcp_fsf_req_complete(req);
  428. }
  429. }
  430. #define ZFCP_FSF_PORTSPEED_1GBIT (1 << 0)
  431. #define ZFCP_FSF_PORTSPEED_2GBIT (1 << 1)
  432. #define ZFCP_FSF_PORTSPEED_4GBIT (1 << 2)
  433. #define ZFCP_FSF_PORTSPEED_10GBIT (1 << 3)
  434. #define ZFCP_FSF_PORTSPEED_8GBIT (1 << 4)
  435. #define ZFCP_FSF_PORTSPEED_16GBIT (1 << 5)
  436. #define ZFCP_FSF_PORTSPEED_32GBIT (1 << 6)
  437. #define ZFCP_FSF_PORTSPEED_64GBIT (1 << 7)
  438. #define ZFCP_FSF_PORTSPEED_128GBIT (1 << 8)
  439. #define ZFCP_FSF_PORTSPEED_NOT_NEGOTIATED (1 << 15)
  440. u32 zfcp_fsf_convert_portspeed(u32 fsf_speed)
  441. {
  442. u32 fdmi_speed = 0;
  443. if (fsf_speed & ZFCP_FSF_PORTSPEED_1GBIT)
  444. fdmi_speed |= FC_PORTSPEED_1GBIT;
  445. if (fsf_speed & ZFCP_FSF_PORTSPEED_2GBIT)
  446. fdmi_speed |= FC_PORTSPEED_2GBIT;
  447. if (fsf_speed & ZFCP_FSF_PORTSPEED_4GBIT)
  448. fdmi_speed |= FC_PORTSPEED_4GBIT;
  449. if (fsf_speed & ZFCP_FSF_PORTSPEED_10GBIT)
  450. fdmi_speed |= FC_PORTSPEED_10GBIT;
  451. if (fsf_speed & ZFCP_FSF_PORTSPEED_8GBIT)
  452. fdmi_speed |= FC_PORTSPEED_8GBIT;
  453. if (fsf_speed & ZFCP_FSF_PORTSPEED_16GBIT)
  454. fdmi_speed |= FC_PORTSPEED_16GBIT;
  455. if (fsf_speed & ZFCP_FSF_PORTSPEED_32GBIT)
  456. fdmi_speed |= FC_PORTSPEED_32GBIT;
  457. if (fsf_speed & ZFCP_FSF_PORTSPEED_64GBIT)
  458. fdmi_speed |= FC_PORTSPEED_64GBIT;
  459. if (fsf_speed & ZFCP_FSF_PORTSPEED_128GBIT)
  460. fdmi_speed |= FC_PORTSPEED_128GBIT;
  461. if (fsf_speed & ZFCP_FSF_PORTSPEED_NOT_NEGOTIATED)
  462. fdmi_speed |= FC_PORTSPEED_NOT_NEGOTIATED;
  463. return fdmi_speed;
  464. }
  465. static int zfcp_fsf_exchange_config_evaluate(struct zfcp_fsf_req *req)
  466. {
  467. struct fsf_qtcb_bottom_config *bottom = &req->qtcb->bottom.config;
  468. struct zfcp_adapter *adapter = req->adapter;
  469. struct fc_els_flogi *plogi;
  470. /* adjust pointers for missing command code */
  471. plogi = (struct fc_els_flogi *) ((u8 *)&bottom->plogi_payload
  472. - sizeof(u32));
  473. if (req->data)
  474. memcpy(req->data, bottom, sizeof(*bottom));
  475. adapter->timer_ticks = bottom->timer_interval & ZFCP_FSF_TIMER_INT_MASK;
  476. adapter->stat_read_buf_num = max(bottom->status_read_buf_num,
  477. (u16)FSF_STATUS_READS_RECOM);
  478. /* no error return above here, otherwise must fix call chains */
  479. /* do not evaluate invalid fields */
  480. if (req->qtcb->header.fsf_status == FSF_EXCHANGE_CONFIG_DATA_INCOMPLETE)
  481. return 0;
  482. adapter->hydra_version = bottom->adapter_type;
  483. switch (bottom->fc_topology) {
  484. case FSF_TOPO_P2P:
  485. adapter->peer_d_id = ntoh24(bottom->peer_d_id);
  486. adapter->peer_wwpn = be64_to_cpu(plogi->fl_wwpn);
  487. adapter->peer_wwnn = be64_to_cpu(plogi->fl_wwnn);
  488. break;
  489. case FSF_TOPO_FABRIC:
  490. break;
  491. case FSF_TOPO_AL:
  492. default:
  493. dev_err(&adapter->ccw_device->dev,
  494. "Unknown or unsupported arbitrated loop "
  495. "fibre channel topology detected\n");
  496. zfcp_erp_adapter_shutdown(adapter, 0, "fsece_1");
  497. return -EIO;
  498. }
  499. return 0;
  500. }
  501. static void zfcp_fsf_exchange_config_data_handler(struct zfcp_fsf_req *req)
  502. {
  503. struct zfcp_adapter *adapter = req->adapter;
  504. struct zfcp_diag_header *const diag_hdr =
  505. &adapter->diagnostics->config_data.header;
  506. struct fsf_qtcb *qtcb = req->qtcb;
  507. struct fsf_qtcb_bottom_config *bottom = &qtcb->bottom.config;
  508. if (req->status & ZFCP_STATUS_FSFREQ_ERROR)
  509. return;
  510. adapter->fsf_lic_version = bottom->lic_version;
  511. adapter->adapter_features = bottom->adapter_features;
  512. adapter->connection_features = bottom->connection_features;
  513. adapter->peer_wwpn = 0;
  514. adapter->peer_wwnn = 0;
  515. adapter->peer_d_id = 0;
  516. switch (qtcb->header.fsf_status) {
  517. case FSF_GOOD:
  518. /*
  519. * usually we wait with an update till the cache is too old,
  520. * but because we have the data available, update it anyway
  521. */
  522. zfcp_diag_update_xdata(diag_hdr, bottom, false);
  523. zfcp_scsi_shost_update_config_data(adapter, bottom, false);
  524. if (zfcp_fsf_exchange_config_evaluate(req))
  525. return;
  526. if (bottom->max_qtcb_size < sizeof(struct fsf_qtcb)) {
  527. dev_err(&adapter->ccw_device->dev,
  528. "FCP adapter maximum QTCB size (%d bytes) "
  529. "is too small\n",
  530. bottom->max_qtcb_size);
  531. zfcp_erp_adapter_shutdown(adapter, 0, "fsecdh1");
  532. return;
  533. }
  534. atomic_or(ZFCP_STATUS_ADAPTER_XCONFIG_OK,
  535. &adapter->status);
  536. break;
  537. case FSF_EXCHANGE_CONFIG_DATA_INCOMPLETE:
  538. zfcp_diag_update_xdata(diag_hdr, bottom, true);
  539. req->status |= ZFCP_STATUS_FSFREQ_XDATAINCOMPLETE;
  540. /* avoids adapter shutdown to be able to recognize
  541. * events such as LINK UP */
  542. atomic_or(ZFCP_STATUS_ADAPTER_XCONFIG_OK,
  543. &adapter->status);
  544. zfcp_fsf_link_down_info_eval(req,
  545. &qtcb->header.fsf_status_qual.link_down_info);
  546. zfcp_scsi_shost_update_config_data(adapter, bottom, true);
  547. if (zfcp_fsf_exchange_config_evaluate(req))
  548. return;
  549. break;
  550. default:
  551. zfcp_erp_adapter_shutdown(adapter, 0, "fsecdh3");
  552. return;
  553. }
  554. if (adapter->adapter_features & FSF_FEATURE_HBAAPI_MANAGEMENT)
  555. adapter->hardware_version = bottom->hardware_version;
  556. if (FSF_QTCB_CURRENT_VERSION < bottom->low_qtcb_version) {
  557. dev_err(&adapter->ccw_device->dev,
  558. "The FCP adapter only supports newer "
  559. "control block versions\n");
  560. zfcp_erp_adapter_shutdown(adapter, 0, "fsecdh4");
  561. return;
  562. }
  563. if (FSF_QTCB_CURRENT_VERSION > bottom->high_qtcb_version) {
  564. dev_err(&adapter->ccw_device->dev,
  565. "The FCP adapter only supports older "
  566. "control block versions\n");
  567. zfcp_erp_adapter_shutdown(adapter, 0, "fsecdh5");
  568. }
  569. }
  570. /*
  571. * Mapping of FC Endpoint Security flag masks to mnemonics
  572. *
  573. * NOTE: Update macro ZFCP_FSF_MAX_FC_SECURITY_MNEMONIC_LENGTH when making any
  574. * changes.
  575. */
  576. static const struct {
  577. u32 mask;
  578. char *name;
  579. } zfcp_fsf_fc_security_mnemonics[] = {
  580. { FSF_FC_SECURITY_AUTH, "Authentication" },
  581. { FSF_FC_SECURITY_ENC_FCSP2 |
  582. FSF_FC_SECURITY_ENC_ERAS, "Encryption" },
  583. };
  584. /* maximum strlen(zfcp_fsf_fc_security_mnemonics[...].name) + 1 */
  585. #define ZFCP_FSF_MAX_FC_SECURITY_MNEMONIC_LENGTH 15
  586. /**
  587. * zfcp_fsf_scnprint_fc_security() - translate FC Endpoint Security flags into
  588. * mnemonics and place in a buffer
  589. * @buf : the buffer to place the translated FC Endpoint Security flag(s)
  590. * into
  591. * @size : the size of the buffer, including the trailing null space
  592. * @fc_security: one or more FC Endpoint Security flags, or zero
  593. * @fmt : specifies whether a list or a single item is to be put into the
  594. * buffer
  595. *
  596. * The Fibre Channel (FC) Endpoint Security flags are translated into mnemonics.
  597. * If the FC Endpoint Security flags are zero "none" is placed into the buffer.
  598. *
  599. * With ZFCP_FSF_PRINT_FMT_LIST the mnemonics are placed as a list separated by
  600. * a comma followed by a space into the buffer. If one or more FC Endpoint
  601. * Security flags cannot be translated into a mnemonic, as they are undefined
  602. * in zfcp_fsf_fc_security_mnemonics, their bitwise ORed value in hexadecimal
  603. * representation is placed into the buffer.
  604. *
  605. * With ZFCP_FSF_PRINT_FMT_SINGLEITEM only one single mnemonic is placed into
  606. * the buffer. If the FC Endpoint Security flag cannot be translated, as it is
  607. * undefined in zfcp_fsf_fc_security_mnemonics, its value in hexadecimal
  608. * representation is placed into the buffer. If more than one FC Endpoint
  609. * Security flag was specified, their value in hexadecimal representation is
  610. * placed into the buffer. The macro ZFCP_FSF_MAX_FC_SECURITY_MNEMONIC_LENGTH
  611. * can be used to define a buffer that is large enough to hold one mnemonic.
  612. *
  613. * Return: The number of characters written into buf not including the trailing
  614. * '\0'. If size is == 0 the function returns 0.
  615. */
  616. ssize_t zfcp_fsf_scnprint_fc_security(char *buf, size_t size, u32 fc_security,
  617. enum zfcp_fsf_print_fmt fmt)
  618. {
  619. const char *prefix = "";
  620. ssize_t len = 0;
  621. int i;
  622. if (fc_security == 0)
  623. return scnprintf(buf, size, "none");
  624. if (fmt == ZFCP_FSF_PRINT_FMT_SINGLEITEM && hweight32(fc_security) != 1)
  625. return scnprintf(buf, size, "0x%08x", fc_security);
  626. for (i = 0; i < ARRAY_SIZE(zfcp_fsf_fc_security_mnemonics); i++) {
  627. if (!(fc_security & zfcp_fsf_fc_security_mnemonics[i].mask))
  628. continue;
  629. len += scnprintf(buf + len, size - len, "%s%s", prefix,
  630. zfcp_fsf_fc_security_mnemonics[i].name);
  631. prefix = ", ";
  632. fc_security &= ~zfcp_fsf_fc_security_mnemonics[i].mask;
  633. }
  634. if (fc_security != 0)
  635. len += scnprintf(buf + len, size - len, "%s0x%08x",
  636. prefix, fc_security);
  637. return len;
  638. }
  639. static void zfcp_fsf_dbf_adapter_fc_security(struct zfcp_adapter *adapter,
  640. struct zfcp_fsf_req *req)
  641. {
  642. if (adapter->fc_security_algorithms ==
  643. adapter->fc_security_algorithms_old) {
  644. /* no change, no trace */
  645. return;
  646. }
  647. zfcp_dbf_hba_fsf_fces("fsfcesa", req, ZFCP_DBF_INVALID_WWPN,
  648. adapter->fc_security_algorithms_old,
  649. adapter->fc_security_algorithms);
  650. adapter->fc_security_algorithms_old = adapter->fc_security_algorithms;
  651. }
  652. static void zfcp_fsf_exchange_port_evaluate(struct zfcp_fsf_req *req)
  653. {
  654. struct zfcp_adapter *adapter = req->adapter;
  655. struct fsf_qtcb_bottom_port *bottom = &req->qtcb->bottom.port;
  656. if (req->data)
  657. memcpy(req->data, bottom, sizeof(*bottom));
  658. if (adapter->adapter_features & FSF_FEATURE_FC_SECURITY)
  659. adapter->fc_security_algorithms =
  660. bottom->fc_security_algorithms;
  661. else
  662. adapter->fc_security_algorithms = 0;
  663. zfcp_fsf_dbf_adapter_fc_security(adapter, req);
  664. }
  665. static void zfcp_fsf_exchange_port_data_handler(struct zfcp_fsf_req *req)
  666. {
  667. struct zfcp_diag_header *const diag_hdr =
  668. &req->adapter->diagnostics->port_data.header;
  669. struct fsf_qtcb *qtcb = req->qtcb;
  670. struct fsf_qtcb_bottom_port *bottom = &qtcb->bottom.port;
  671. if (req->status & ZFCP_STATUS_FSFREQ_ERROR)
  672. return;
  673. switch (qtcb->header.fsf_status) {
  674. case FSF_GOOD:
  675. /*
  676. * usually we wait with an update till the cache is too old,
  677. * but because we have the data available, update it anyway
  678. */
  679. zfcp_diag_update_xdata(diag_hdr, bottom, false);
  680. zfcp_scsi_shost_update_port_data(req->adapter, bottom);
  681. zfcp_fsf_exchange_port_evaluate(req);
  682. break;
  683. case FSF_EXCHANGE_CONFIG_DATA_INCOMPLETE:
  684. zfcp_diag_update_xdata(diag_hdr, bottom, true);
  685. req->status |= ZFCP_STATUS_FSFREQ_XDATAINCOMPLETE;
  686. zfcp_fsf_link_down_info_eval(req,
  687. &qtcb->header.fsf_status_qual.link_down_info);
  688. zfcp_scsi_shost_update_port_data(req->adapter, bottom);
  689. zfcp_fsf_exchange_port_evaluate(req);
  690. break;
  691. }
  692. }
  693. static struct zfcp_fsf_req *zfcp_fsf_alloc(mempool_t *pool)
  694. {
  695. struct zfcp_fsf_req *req;
  696. if (likely(pool))
  697. req = mempool_alloc(pool, GFP_ATOMIC);
  698. else
  699. req = kmalloc(sizeof(*req), GFP_ATOMIC);
  700. if (unlikely(!req))
  701. return NULL;
  702. memset(req, 0, sizeof(*req));
  703. req->pool = pool;
  704. return req;
  705. }
  706. static struct fsf_qtcb *zfcp_fsf_qtcb_alloc(mempool_t *pool)
  707. {
  708. struct fsf_qtcb *qtcb;
  709. if (likely(pool))
  710. qtcb = mempool_alloc(pool, GFP_ATOMIC);
  711. else
  712. qtcb = kmem_cache_alloc(zfcp_fsf_qtcb_cache, GFP_ATOMIC);
  713. if (unlikely(!qtcb))
  714. return NULL;
  715. memset(qtcb, 0, sizeof(*qtcb));
  716. return qtcb;
  717. }
  718. static struct zfcp_fsf_req *zfcp_fsf_req_create(struct zfcp_qdio *qdio,
  719. u32 fsf_cmd, u8 sbtype,
  720. mempool_t *pool)
  721. {
  722. struct zfcp_adapter *adapter = qdio->adapter;
  723. struct zfcp_fsf_req *req = zfcp_fsf_alloc(pool);
  724. if (unlikely(!req))
  725. return ERR_PTR(-ENOMEM);
  726. if (adapter->req_no == 0)
  727. adapter->req_no++;
  728. INIT_LIST_HEAD(&req->list);
  729. timer_setup(&req->timer, NULL, 0);
  730. init_completion(&req->completion);
  731. req->adapter = adapter;
  732. req->req_id = adapter->req_no;
  733. if (likely(fsf_cmd != FSF_QTCB_UNSOLICITED_STATUS)) {
  734. if (likely(pool))
  735. req->qtcb = zfcp_fsf_qtcb_alloc(
  736. adapter->pool.qtcb_pool);
  737. else
  738. req->qtcb = zfcp_fsf_qtcb_alloc(NULL);
  739. if (unlikely(!req->qtcb)) {
  740. zfcp_fsf_req_free(req);
  741. return ERR_PTR(-ENOMEM);
  742. }
  743. req->qtcb->prefix.req_seq_no = adapter->fsf_req_seq_no;
  744. req->qtcb->prefix.req_id = req->req_id;
  745. req->qtcb->prefix.ulp_info = 26;
  746. req->qtcb->prefix.qtcb_type = fsf_qtcb_type[fsf_cmd];
  747. req->qtcb->prefix.qtcb_version = FSF_QTCB_CURRENT_VERSION;
  748. req->qtcb->header.req_handle = req->req_id;
  749. req->qtcb->header.fsf_command = fsf_cmd;
  750. }
  751. zfcp_qdio_req_init(adapter->qdio, &req->qdio_req, req->req_id, sbtype,
  752. req->qtcb, sizeof(struct fsf_qtcb));
  753. return req;
  754. }
  755. static int zfcp_fsf_req_send(struct zfcp_fsf_req *req)
  756. {
  757. const bool is_srb = zfcp_fsf_req_is_status_read_buffer(req);
  758. struct zfcp_adapter *adapter = req->adapter;
  759. struct zfcp_qdio *qdio = adapter->qdio;
  760. int req_id = req->req_id;
  761. zfcp_reqlist_add(adapter->req_list, req);
  762. req->qdio_req.qdio_outb_usage = atomic_read(&qdio->req_q_free);
  763. req->issued = get_tod_clock();
  764. if (zfcp_qdio_send(qdio, &req->qdio_req)) {
  765. del_timer_sync(&req->timer);
  766. /* lookup request again, list might have changed */
  767. zfcp_reqlist_find_rm(adapter->req_list, req_id);
  768. zfcp_erp_adapter_reopen(adapter, 0, "fsrs__1");
  769. return -EIO;
  770. }
  771. /*
  772. * NOTE: DO NOT TOUCH ASYNC req PAST THIS POINT.
  773. * ONLY TOUCH SYNC req AGAIN ON req->completion.
  774. *
  775. * The request might complete and be freed concurrently at any point
  776. * now. This is not protected by the QDIO-lock (req_q_lock). So any
  777. * uncontrolled access after this might result in an use-after-free bug.
  778. * Only if the request doesn't have ZFCP_STATUS_FSFREQ_CLEANUP set, and
  779. * when it is completed via req->completion, is it safe to use req
  780. * again.
  781. */
  782. /* Don't increase for unsolicited status */
  783. if (!is_srb)
  784. adapter->fsf_req_seq_no++;
  785. adapter->req_no++;
  786. return 0;
  787. }
  788. /**
  789. * zfcp_fsf_status_read - send status read request
  790. * @qdio: pointer to struct zfcp_qdio
  791. * Returns: 0 on success, ERROR otherwise
  792. */
  793. int zfcp_fsf_status_read(struct zfcp_qdio *qdio)
  794. {
  795. struct zfcp_adapter *adapter = qdio->adapter;
  796. struct zfcp_fsf_req *req;
  797. struct fsf_status_read_buffer *sr_buf;
  798. struct page *page;
  799. int retval = -EIO;
  800. spin_lock_irq(&qdio->req_q_lock);
  801. if (zfcp_qdio_sbal_get(qdio))
  802. goto out;
  803. req = zfcp_fsf_req_create(qdio, FSF_QTCB_UNSOLICITED_STATUS,
  804. SBAL_SFLAGS0_TYPE_STATUS,
  805. adapter->pool.status_read_req);
  806. if (IS_ERR(req)) {
  807. retval = PTR_ERR(req);
  808. goto out;
  809. }
  810. page = mempool_alloc(adapter->pool.sr_data, GFP_ATOMIC);
  811. if (!page) {
  812. retval = -ENOMEM;
  813. goto failed_buf;
  814. }
  815. sr_buf = page_address(page);
  816. memset(sr_buf, 0, sizeof(*sr_buf));
  817. req->data = sr_buf;
  818. zfcp_qdio_fill_next(qdio, &req->qdio_req, sr_buf, sizeof(*sr_buf));
  819. zfcp_qdio_set_sbale_last(qdio, &req->qdio_req);
  820. retval = zfcp_fsf_req_send(req);
  821. if (retval)
  822. goto failed_req_send;
  823. /* NOTE: DO NOT TOUCH req PAST THIS POINT! */
  824. goto out;
  825. failed_req_send:
  826. req->data = NULL;
  827. mempool_free(virt_to_page(sr_buf), adapter->pool.sr_data);
  828. failed_buf:
  829. zfcp_dbf_hba_fsf_uss("fssr__1", req);
  830. zfcp_fsf_req_free(req);
  831. out:
  832. spin_unlock_irq(&qdio->req_q_lock);
  833. return retval;
  834. }
  835. static void zfcp_fsf_abort_fcp_command_handler(struct zfcp_fsf_req *req)
  836. {
  837. struct scsi_device *sdev = req->data;
  838. struct zfcp_scsi_dev *zfcp_sdev;
  839. union fsf_status_qual *fsq = &req->qtcb->header.fsf_status_qual;
  840. if (req->status & ZFCP_STATUS_FSFREQ_ERROR)
  841. return;
  842. zfcp_sdev = sdev_to_zfcp(sdev);
  843. switch (req->qtcb->header.fsf_status) {
  844. case FSF_PORT_HANDLE_NOT_VALID:
  845. if (fsq->word[0] == fsq->word[1]) {
  846. zfcp_erp_adapter_reopen(zfcp_sdev->port->adapter, 0,
  847. "fsafch1");
  848. req->status |= ZFCP_STATUS_FSFREQ_ERROR;
  849. }
  850. break;
  851. case FSF_LUN_HANDLE_NOT_VALID:
  852. if (fsq->word[0] == fsq->word[1]) {
  853. zfcp_erp_port_reopen(zfcp_sdev->port, 0, "fsafch2");
  854. req->status |= ZFCP_STATUS_FSFREQ_ERROR;
  855. }
  856. break;
  857. case FSF_FCP_COMMAND_DOES_NOT_EXIST:
  858. req->status |= ZFCP_STATUS_FSFREQ_ABORTNOTNEEDED;
  859. break;
  860. case FSF_PORT_BOXED:
  861. zfcp_erp_set_port_status(zfcp_sdev->port,
  862. ZFCP_STATUS_COMMON_ACCESS_BOXED);
  863. zfcp_erp_port_reopen(zfcp_sdev->port,
  864. ZFCP_STATUS_COMMON_ERP_FAILED, "fsafch3");
  865. req->status |= ZFCP_STATUS_FSFREQ_ERROR;
  866. break;
  867. case FSF_LUN_BOXED:
  868. zfcp_erp_set_lun_status(sdev, ZFCP_STATUS_COMMON_ACCESS_BOXED);
  869. zfcp_erp_lun_reopen(sdev, ZFCP_STATUS_COMMON_ERP_FAILED,
  870. "fsafch4");
  871. req->status |= ZFCP_STATUS_FSFREQ_ERROR;
  872. break;
  873. case FSF_ADAPTER_STATUS_AVAILABLE:
  874. switch (fsq->word[0]) {
  875. case FSF_SQ_INVOKE_LINK_TEST_PROCEDURE:
  876. zfcp_fc_test_link(zfcp_sdev->port);
  877. fallthrough;
  878. case FSF_SQ_ULP_DEPENDENT_ERP_REQUIRED:
  879. req->status |= ZFCP_STATUS_FSFREQ_ERROR;
  880. break;
  881. }
  882. break;
  883. case FSF_GOOD:
  884. req->status |= ZFCP_STATUS_FSFREQ_ABORTSUCCEEDED;
  885. break;
  886. }
  887. }
  888. /**
  889. * zfcp_fsf_abort_fcp_cmnd - abort running SCSI command
  890. * @scmnd: The SCSI command to abort
  891. * Returns: pointer to struct zfcp_fsf_req
  892. */
  893. struct zfcp_fsf_req *zfcp_fsf_abort_fcp_cmnd(struct scsi_cmnd *scmnd)
  894. {
  895. struct zfcp_fsf_req *req = NULL;
  896. struct scsi_device *sdev = scmnd->device;
  897. struct zfcp_scsi_dev *zfcp_sdev = sdev_to_zfcp(sdev);
  898. struct zfcp_qdio *qdio = zfcp_sdev->port->adapter->qdio;
  899. unsigned long old_req_id = (unsigned long) scmnd->host_scribble;
  900. spin_lock_irq(&qdio->req_q_lock);
  901. if (zfcp_qdio_sbal_get(qdio))
  902. goto out;
  903. req = zfcp_fsf_req_create(qdio, FSF_QTCB_ABORT_FCP_CMND,
  904. SBAL_SFLAGS0_TYPE_READ,
  905. qdio->adapter->pool.scsi_abort);
  906. if (IS_ERR(req)) {
  907. req = NULL;
  908. goto out;
  909. }
  910. if (unlikely(!(atomic_read(&zfcp_sdev->status) &
  911. ZFCP_STATUS_COMMON_UNBLOCKED)))
  912. goto out_error_free;
  913. zfcp_qdio_set_sbale_last(qdio, &req->qdio_req);
  914. req->data = sdev;
  915. req->handler = zfcp_fsf_abort_fcp_command_handler;
  916. req->qtcb->header.lun_handle = zfcp_sdev->lun_handle;
  917. req->qtcb->header.port_handle = zfcp_sdev->port->handle;
  918. req->qtcb->bottom.support.req_handle = (u64) old_req_id;
  919. zfcp_fsf_start_timer(req, ZFCP_FSF_SCSI_ER_TIMEOUT);
  920. if (!zfcp_fsf_req_send(req)) {
  921. /* NOTE: DO NOT TOUCH req, UNTIL IT COMPLETES! */
  922. goto out;
  923. }
  924. out_error_free:
  925. zfcp_fsf_req_free(req);
  926. req = NULL;
  927. out:
  928. spin_unlock_irq(&qdio->req_q_lock);
  929. return req;
  930. }
  931. static void zfcp_fsf_send_ct_handler(struct zfcp_fsf_req *req)
  932. {
  933. struct zfcp_adapter *adapter = req->adapter;
  934. struct zfcp_fsf_ct_els *ct = req->data;
  935. struct fsf_qtcb_header *header = &req->qtcb->header;
  936. ct->status = -EINVAL;
  937. if (req->status & ZFCP_STATUS_FSFREQ_ERROR)
  938. goto skip_fsfstatus;
  939. switch (header->fsf_status) {
  940. case FSF_GOOD:
  941. ct->status = 0;
  942. zfcp_dbf_san_res("fsscth2", req);
  943. break;
  944. case FSF_SERVICE_CLASS_NOT_SUPPORTED:
  945. zfcp_fsf_class_not_supp(req);
  946. break;
  947. case FSF_ADAPTER_STATUS_AVAILABLE:
  948. switch (header->fsf_status_qual.word[0]){
  949. case FSF_SQ_INVOKE_LINK_TEST_PROCEDURE:
  950. case FSF_SQ_ULP_DEPENDENT_ERP_REQUIRED:
  951. req->status |= ZFCP_STATUS_FSFREQ_ERROR;
  952. break;
  953. }
  954. break;
  955. case FSF_PORT_BOXED:
  956. req->status |= ZFCP_STATUS_FSFREQ_ERROR;
  957. break;
  958. case FSF_PORT_HANDLE_NOT_VALID:
  959. zfcp_erp_adapter_reopen(adapter, 0, "fsscth1");
  960. fallthrough;
  961. case FSF_GENERIC_COMMAND_REJECTED:
  962. case FSF_PAYLOAD_SIZE_MISMATCH:
  963. case FSF_REQUEST_SIZE_TOO_LARGE:
  964. case FSF_RESPONSE_SIZE_TOO_LARGE:
  965. case FSF_SBAL_MISMATCH:
  966. req->status |= ZFCP_STATUS_FSFREQ_ERROR;
  967. break;
  968. }
  969. skip_fsfstatus:
  970. if (ct->handler)
  971. ct->handler(ct->handler_data);
  972. }
  973. static void zfcp_fsf_setup_ct_els_unchained(struct zfcp_qdio *qdio,
  974. struct zfcp_qdio_req *q_req,
  975. struct scatterlist *sg_req,
  976. struct scatterlist *sg_resp)
  977. {
  978. zfcp_qdio_fill_next(qdio, q_req, sg_virt(sg_req), sg_req->length);
  979. zfcp_qdio_fill_next(qdio, q_req, sg_virt(sg_resp), sg_resp->length);
  980. zfcp_qdio_set_sbale_last(qdio, q_req);
  981. }
  982. static int zfcp_fsf_setup_ct_els_sbals(struct zfcp_fsf_req *req,
  983. struct scatterlist *sg_req,
  984. struct scatterlist *sg_resp)
  985. {
  986. struct zfcp_adapter *adapter = req->adapter;
  987. struct zfcp_qdio *qdio = adapter->qdio;
  988. struct fsf_qtcb *qtcb = req->qtcb;
  989. u32 feat = adapter->adapter_features;
  990. if (zfcp_adapter_multi_buffer_active(adapter)) {
  991. if (zfcp_qdio_sbals_from_sg(qdio, &req->qdio_req, sg_req))
  992. return -EIO;
  993. qtcb->bottom.support.req_buf_length =
  994. zfcp_qdio_real_bytes(sg_req);
  995. if (zfcp_qdio_sbals_from_sg(qdio, &req->qdio_req, sg_resp))
  996. return -EIO;
  997. qtcb->bottom.support.resp_buf_length =
  998. zfcp_qdio_real_bytes(sg_resp);
  999. zfcp_qdio_set_data_div(qdio, &req->qdio_req, sg_nents(sg_req));
  1000. zfcp_qdio_set_sbale_last(qdio, &req->qdio_req);
  1001. zfcp_qdio_set_scount(qdio, &req->qdio_req);
  1002. return 0;
  1003. }
  1004. /* use single, unchained SBAL if it can hold the request */
  1005. if (zfcp_qdio_sg_one_sbale(sg_req) && zfcp_qdio_sg_one_sbale(sg_resp)) {
  1006. zfcp_fsf_setup_ct_els_unchained(qdio, &req->qdio_req,
  1007. sg_req, sg_resp);
  1008. return 0;
  1009. }
  1010. if (!(feat & FSF_FEATURE_ELS_CT_CHAINED_SBALS))
  1011. return -EOPNOTSUPP;
  1012. if (zfcp_qdio_sbals_from_sg(qdio, &req->qdio_req, sg_req))
  1013. return -EIO;
  1014. qtcb->bottom.support.req_buf_length = zfcp_qdio_real_bytes(sg_req);
  1015. zfcp_qdio_set_sbale_last(qdio, &req->qdio_req);
  1016. zfcp_qdio_skip_to_last_sbale(qdio, &req->qdio_req);
  1017. if (zfcp_qdio_sbals_from_sg(qdio, &req->qdio_req, sg_resp))
  1018. return -EIO;
  1019. qtcb->bottom.support.resp_buf_length = zfcp_qdio_real_bytes(sg_resp);
  1020. zfcp_qdio_set_sbale_last(qdio, &req->qdio_req);
  1021. return 0;
  1022. }
  1023. static int zfcp_fsf_setup_ct_els(struct zfcp_fsf_req *req,
  1024. struct scatterlist *sg_req,
  1025. struct scatterlist *sg_resp,
  1026. unsigned int timeout)
  1027. {
  1028. int ret;
  1029. ret = zfcp_fsf_setup_ct_els_sbals(req, sg_req, sg_resp);
  1030. if (ret)
  1031. return ret;
  1032. /* common settings for ct/gs and els requests */
  1033. if (timeout > 255)
  1034. timeout = 255; /* max value accepted by hardware */
  1035. req->qtcb->bottom.support.service_class = FSF_CLASS_3;
  1036. req->qtcb->bottom.support.timeout = timeout;
  1037. zfcp_fsf_start_timer(req, (timeout + 10) * HZ);
  1038. return 0;
  1039. }
  1040. /**
  1041. * zfcp_fsf_send_ct - initiate a Generic Service request (FC-GS)
  1042. * @wka_port: pointer to zfcp WKA port to send CT/GS to
  1043. * @ct: pointer to struct zfcp_send_ct with data for request
  1044. * @pool: if non-null this mempool is used to allocate struct zfcp_fsf_req
  1045. * @timeout: timeout that hardware should use, and a later software timeout
  1046. */
  1047. int zfcp_fsf_send_ct(struct zfcp_fc_wka_port *wka_port,
  1048. struct zfcp_fsf_ct_els *ct, mempool_t *pool,
  1049. unsigned int timeout)
  1050. {
  1051. struct zfcp_qdio *qdio = wka_port->adapter->qdio;
  1052. struct zfcp_fsf_req *req;
  1053. int ret = -EIO;
  1054. spin_lock_irq(&qdio->req_q_lock);
  1055. if (zfcp_qdio_sbal_get(qdio))
  1056. goto out;
  1057. req = zfcp_fsf_req_create(qdio, FSF_QTCB_SEND_GENERIC,
  1058. SBAL_SFLAGS0_TYPE_WRITE_READ, pool);
  1059. if (IS_ERR(req)) {
  1060. ret = PTR_ERR(req);
  1061. goto out;
  1062. }
  1063. req->status |= ZFCP_STATUS_FSFREQ_CLEANUP;
  1064. ret = zfcp_fsf_setup_ct_els(req, ct->req, ct->resp, timeout);
  1065. if (ret)
  1066. goto failed_send;
  1067. req->handler = zfcp_fsf_send_ct_handler;
  1068. req->qtcb->header.port_handle = wka_port->handle;
  1069. ct->d_id = wka_port->d_id;
  1070. req->data = ct;
  1071. zfcp_dbf_san_req("fssct_1", req, wka_port->d_id);
  1072. ret = zfcp_fsf_req_send(req);
  1073. if (ret)
  1074. goto failed_send;
  1075. /* NOTE: DO NOT TOUCH req PAST THIS POINT! */
  1076. goto out;
  1077. failed_send:
  1078. zfcp_fsf_req_free(req);
  1079. out:
  1080. spin_unlock_irq(&qdio->req_q_lock);
  1081. return ret;
  1082. }
  1083. static void zfcp_fsf_send_els_handler(struct zfcp_fsf_req *req)
  1084. {
  1085. struct zfcp_fsf_ct_els *send_els = req->data;
  1086. struct fsf_qtcb_header *header = &req->qtcb->header;
  1087. send_els->status = -EINVAL;
  1088. if (req->status & ZFCP_STATUS_FSFREQ_ERROR)
  1089. goto skip_fsfstatus;
  1090. switch (header->fsf_status) {
  1091. case FSF_GOOD:
  1092. send_els->status = 0;
  1093. zfcp_dbf_san_res("fsselh1", req);
  1094. break;
  1095. case FSF_SERVICE_CLASS_NOT_SUPPORTED:
  1096. zfcp_fsf_class_not_supp(req);
  1097. break;
  1098. case FSF_ADAPTER_STATUS_AVAILABLE:
  1099. switch (header->fsf_status_qual.word[0]){
  1100. case FSF_SQ_INVOKE_LINK_TEST_PROCEDURE:
  1101. case FSF_SQ_ULP_DEPENDENT_ERP_REQUIRED:
  1102. case FSF_SQ_RETRY_IF_POSSIBLE:
  1103. req->status |= ZFCP_STATUS_FSFREQ_ERROR;
  1104. break;
  1105. }
  1106. break;
  1107. case FSF_ELS_COMMAND_REJECTED:
  1108. case FSF_PAYLOAD_SIZE_MISMATCH:
  1109. case FSF_REQUEST_SIZE_TOO_LARGE:
  1110. case FSF_RESPONSE_SIZE_TOO_LARGE:
  1111. break;
  1112. case FSF_SBAL_MISMATCH:
  1113. /* should never occur, avoided in zfcp_fsf_send_els */
  1114. fallthrough;
  1115. default:
  1116. req->status |= ZFCP_STATUS_FSFREQ_ERROR;
  1117. break;
  1118. }
  1119. skip_fsfstatus:
  1120. if (send_els->handler)
  1121. send_els->handler(send_els->handler_data);
  1122. }
  1123. /**
  1124. * zfcp_fsf_send_els - initiate an ELS command (FC-FS)
  1125. * @adapter: pointer to zfcp adapter
  1126. * @d_id: N_Port_ID to send ELS to
  1127. * @els: pointer to struct zfcp_send_els with data for the command
  1128. * @timeout: timeout that hardware should use, and a later software timeout
  1129. */
  1130. int zfcp_fsf_send_els(struct zfcp_adapter *adapter, u32 d_id,
  1131. struct zfcp_fsf_ct_els *els, unsigned int timeout)
  1132. {
  1133. struct zfcp_fsf_req *req;
  1134. struct zfcp_qdio *qdio = adapter->qdio;
  1135. int ret = -EIO;
  1136. spin_lock_irq(&qdio->req_q_lock);
  1137. if (zfcp_qdio_sbal_get(qdio))
  1138. goto out;
  1139. req = zfcp_fsf_req_create(qdio, FSF_QTCB_SEND_ELS,
  1140. SBAL_SFLAGS0_TYPE_WRITE_READ, NULL);
  1141. if (IS_ERR(req)) {
  1142. ret = PTR_ERR(req);
  1143. goto out;
  1144. }
  1145. req->status |= ZFCP_STATUS_FSFREQ_CLEANUP;
  1146. if (!zfcp_adapter_multi_buffer_active(adapter))
  1147. zfcp_qdio_sbal_limit(qdio, &req->qdio_req, 2);
  1148. ret = zfcp_fsf_setup_ct_els(req, els->req, els->resp, timeout);
  1149. if (ret)
  1150. goto failed_send;
  1151. hton24(req->qtcb->bottom.support.d_id, d_id);
  1152. req->handler = zfcp_fsf_send_els_handler;
  1153. els->d_id = d_id;
  1154. req->data = els;
  1155. zfcp_dbf_san_req("fssels1", req, d_id);
  1156. ret = zfcp_fsf_req_send(req);
  1157. if (ret)
  1158. goto failed_send;
  1159. /* NOTE: DO NOT TOUCH req PAST THIS POINT! */
  1160. goto out;
  1161. failed_send:
  1162. zfcp_fsf_req_free(req);
  1163. out:
  1164. spin_unlock_irq(&qdio->req_q_lock);
  1165. return ret;
  1166. }
  1167. int zfcp_fsf_exchange_config_data(struct zfcp_erp_action *erp_action)
  1168. {
  1169. struct zfcp_fsf_req *req;
  1170. struct zfcp_qdio *qdio = erp_action->adapter->qdio;
  1171. int retval = -EIO;
  1172. spin_lock_irq(&qdio->req_q_lock);
  1173. if (zfcp_qdio_sbal_get(qdio))
  1174. goto out;
  1175. req = zfcp_fsf_req_create(qdio, FSF_QTCB_EXCHANGE_CONFIG_DATA,
  1176. SBAL_SFLAGS0_TYPE_READ,
  1177. qdio->adapter->pool.erp_req);
  1178. if (IS_ERR(req)) {
  1179. retval = PTR_ERR(req);
  1180. goto out;
  1181. }
  1182. req->status |= ZFCP_STATUS_FSFREQ_CLEANUP;
  1183. zfcp_qdio_set_sbale_last(qdio, &req->qdio_req);
  1184. req->qtcb->bottom.config.feature_selection =
  1185. FSF_FEATURE_NOTIFICATION_LOST |
  1186. FSF_FEATURE_UPDATE_ALERT |
  1187. FSF_FEATURE_REQUEST_SFP_DATA |
  1188. FSF_FEATURE_FC_SECURITY;
  1189. req->erp_action = erp_action;
  1190. req->handler = zfcp_fsf_exchange_config_data_handler;
  1191. erp_action->fsf_req_id = req->req_id;
  1192. zfcp_fsf_start_erp_timer(req);
  1193. retval = zfcp_fsf_req_send(req);
  1194. if (retval) {
  1195. zfcp_fsf_req_free(req);
  1196. erp_action->fsf_req_id = 0;
  1197. }
  1198. /* NOTE: DO NOT TOUCH req PAST THIS POINT! */
  1199. out:
  1200. spin_unlock_irq(&qdio->req_q_lock);
  1201. return retval;
  1202. }
  1203. /**
  1204. * zfcp_fsf_exchange_config_data_sync() - Request information about FCP channel.
  1205. * @qdio: pointer to the QDIO-Queue to use for sending the command.
  1206. * @data: pointer to the QTCB-Bottom for storing the result of the command,
  1207. * might be %NULL.
  1208. *
  1209. * Returns:
  1210. * * 0 - Exchange Config Data was successful, @data is complete
  1211. * * -EIO - Exchange Config Data was not successful, @data is invalid
  1212. * * -EAGAIN - @data contains incomplete data
  1213. * * -ENOMEM - Some memory allocation failed along the way
  1214. */
  1215. int zfcp_fsf_exchange_config_data_sync(struct zfcp_qdio *qdio,
  1216. struct fsf_qtcb_bottom_config *data)
  1217. {
  1218. struct zfcp_fsf_req *req = NULL;
  1219. int retval = -EIO;
  1220. spin_lock_irq(&qdio->req_q_lock);
  1221. if (zfcp_qdio_sbal_get(qdio))
  1222. goto out_unlock;
  1223. req = zfcp_fsf_req_create(qdio, FSF_QTCB_EXCHANGE_CONFIG_DATA,
  1224. SBAL_SFLAGS0_TYPE_READ, NULL);
  1225. if (IS_ERR(req)) {
  1226. retval = PTR_ERR(req);
  1227. goto out_unlock;
  1228. }
  1229. zfcp_qdio_set_sbale_last(qdio, &req->qdio_req);
  1230. req->handler = zfcp_fsf_exchange_config_data_handler;
  1231. req->qtcb->bottom.config.feature_selection =
  1232. FSF_FEATURE_NOTIFICATION_LOST |
  1233. FSF_FEATURE_UPDATE_ALERT |
  1234. FSF_FEATURE_REQUEST_SFP_DATA |
  1235. FSF_FEATURE_FC_SECURITY;
  1236. if (data)
  1237. req->data = data;
  1238. zfcp_fsf_start_timer(req, ZFCP_FSF_REQUEST_TIMEOUT);
  1239. retval = zfcp_fsf_req_send(req);
  1240. spin_unlock_irq(&qdio->req_q_lock);
  1241. if (!retval) {
  1242. /* NOTE: ONLY TOUCH SYNC req AGAIN ON req->completion. */
  1243. wait_for_completion(&req->completion);
  1244. if (req->status &
  1245. (ZFCP_STATUS_FSFREQ_ERROR | ZFCP_STATUS_FSFREQ_DISMISSED))
  1246. retval = -EIO;
  1247. else if (req->status & ZFCP_STATUS_FSFREQ_XDATAINCOMPLETE)
  1248. retval = -EAGAIN;
  1249. }
  1250. zfcp_fsf_req_free(req);
  1251. return retval;
  1252. out_unlock:
  1253. spin_unlock_irq(&qdio->req_q_lock);
  1254. return retval;
  1255. }
  1256. /**
  1257. * zfcp_fsf_exchange_port_data - request information about local port
  1258. * @erp_action: ERP action for the adapter for which port data is requested
  1259. * Returns: 0 on success, error otherwise
  1260. */
  1261. int zfcp_fsf_exchange_port_data(struct zfcp_erp_action *erp_action)
  1262. {
  1263. struct zfcp_qdio *qdio = erp_action->adapter->qdio;
  1264. struct zfcp_fsf_req *req;
  1265. int retval = -EIO;
  1266. if (!(qdio->adapter->adapter_features & FSF_FEATURE_HBAAPI_MANAGEMENT))
  1267. return -EOPNOTSUPP;
  1268. spin_lock_irq(&qdio->req_q_lock);
  1269. if (zfcp_qdio_sbal_get(qdio))
  1270. goto out;
  1271. req = zfcp_fsf_req_create(qdio, FSF_QTCB_EXCHANGE_PORT_DATA,
  1272. SBAL_SFLAGS0_TYPE_READ,
  1273. qdio->adapter->pool.erp_req);
  1274. if (IS_ERR(req)) {
  1275. retval = PTR_ERR(req);
  1276. goto out;
  1277. }
  1278. req->status |= ZFCP_STATUS_FSFREQ_CLEANUP;
  1279. zfcp_qdio_set_sbale_last(qdio, &req->qdio_req);
  1280. req->handler = zfcp_fsf_exchange_port_data_handler;
  1281. req->erp_action = erp_action;
  1282. erp_action->fsf_req_id = req->req_id;
  1283. zfcp_fsf_start_erp_timer(req);
  1284. retval = zfcp_fsf_req_send(req);
  1285. if (retval) {
  1286. zfcp_fsf_req_free(req);
  1287. erp_action->fsf_req_id = 0;
  1288. }
  1289. /* NOTE: DO NOT TOUCH req PAST THIS POINT! */
  1290. out:
  1291. spin_unlock_irq(&qdio->req_q_lock);
  1292. return retval;
  1293. }
  1294. /**
  1295. * zfcp_fsf_exchange_port_data_sync() - Request information about local port.
  1296. * @qdio: pointer to the QDIO-Queue to use for sending the command.
  1297. * @data: pointer to the QTCB-Bottom for storing the result of the command,
  1298. * might be %NULL.
  1299. *
  1300. * Returns:
  1301. * * 0 - Exchange Port Data was successful, @data is complete
  1302. * * -EIO - Exchange Port Data was not successful, @data is invalid
  1303. * * -EAGAIN - @data contains incomplete data
  1304. * * -ENOMEM - Some memory allocation failed along the way
  1305. * * -EOPNOTSUPP - This operation is not supported
  1306. */
  1307. int zfcp_fsf_exchange_port_data_sync(struct zfcp_qdio *qdio,
  1308. struct fsf_qtcb_bottom_port *data)
  1309. {
  1310. struct zfcp_fsf_req *req = NULL;
  1311. int retval = -EIO;
  1312. if (!(qdio->adapter->adapter_features & FSF_FEATURE_HBAAPI_MANAGEMENT))
  1313. return -EOPNOTSUPP;
  1314. spin_lock_irq(&qdio->req_q_lock);
  1315. if (zfcp_qdio_sbal_get(qdio))
  1316. goto out_unlock;
  1317. req = zfcp_fsf_req_create(qdio, FSF_QTCB_EXCHANGE_PORT_DATA,
  1318. SBAL_SFLAGS0_TYPE_READ, NULL);
  1319. if (IS_ERR(req)) {
  1320. retval = PTR_ERR(req);
  1321. goto out_unlock;
  1322. }
  1323. if (data)
  1324. req->data = data;
  1325. zfcp_qdio_set_sbale_last(qdio, &req->qdio_req);
  1326. req->handler = zfcp_fsf_exchange_port_data_handler;
  1327. zfcp_fsf_start_timer(req, ZFCP_FSF_REQUEST_TIMEOUT);
  1328. retval = zfcp_fsf_req_send(req);
  1329. spin_unlock_irq(&qdio->req_q_lock);
  1330. if (!retval) {
  1331. /* NOTE: ONLY TOUCH SYNC req AGAIN ON req->completion. */
  1332. wait_for_completion(&req->completion);
  1333. if (req->status &
  1334. (ZFCP_STATUS_FSFREQ_ERROR | ZFCP_STATUS_FSFREQ_DISMISSED))
  1335. retval = -EIO;
  1336. else if (req->status & ZFCP_STATUS_FSFREQ_XDATAINCOMPLETE)
  1337. retval = -EAGAIN;
  1338. }
  1339. zfcp_fsf_req_free(req);
  1340. return retval;
  1341. out_unlock:
  1342. spin_unlock_irq(&qdio->req_q_lock);
  1343. return retval;
  1344. }
  1345. static void zfcp_fsf_log_port_fc_security(struct zfcp_port *port,
  1346. struct zfcp_fsf_req *req)
  1347. {
  1348. char mnemonic_old[ZFCP_FSF_MAX_FC_SECURITY_MNEMONIC_LENGTH];
  1349. char mnemonic_new[ZFCP_FSF_MAX_FC_SECURITY_MNEMONIC_LENGTH];
  1350. if (port->connection_info == port->connection_info_old) {
  1351. /* no change, no log nor trace */
  1352. return;
  1353. }
  1354. zfcp_dbf_hba_fsf_fces("fsfcesp", req, port->wwpn,
  1355. port->connection_info_old,
  1356. port->connection_info);
  1357. zfcp_fsf_scnprint_fc_security(mnemonic_old, sizeof(mnemonic_old),
  1358. port->connection_info_old,
  1359. ZFCP_FSF_PRINT_FMT_SINGLEITEM);
  1360. zfcp_fsf_scnprint_fc_security(mnemonic_new, sizeof(mnemonic_new),
  1361. port->connection_info,
  1362. ZFCP_FSF_PRINT_FMT_SINGLEITEM);
  1363. if (strncmp(mnemonic_old, mnemonic_new,
  1364. ZFCP_FSF_MAX_FC_SECURITY_MNEMONIC_LENGTH) == 0) {
  1365. /* no change in string representation, no log */
  1366. goto out;
  1367. }
  1368. if (port->connection_info_old == 0) {
  1369. /* activation */
  1370. dev_info(&port->adapter->ccw_device->dev,
  1371. "FC Endpoint Security of connection to remote port 0x%16llx enabled: %s\n",
  1372. port->wwpn, mnemonic_new);
  1373. } else if (port->connection_info == 0) {
  1374. /* deactivation */
  1375. dev_warn(&port->adapter->ccw_device->dev,
  1376. "FC Endpoint Security of connection to remote port 0x%16llx disabled: was %s\n",
  1377. port->wwpn, mnemonic_old);
  1378. } else {
  1379. /* change */
  1380. dev_warn(&port->adapter->ccw_device->dev,
  1381. "FC Endpoint Security of connection to remote port 0x%16llx changed: from %s to %s\n",
  1382. port->wwpn, mnemonic_old, mnemonic_new);
  1383. }
  1384. out:
  1385. port->connection_info_old = port->connection_info;
  1386. }
  1387. static void zfcp_fsf_log_security_error(const struct device *dev, u32 fsf_sqw0,
  1388. u64 wwpn)
  1389. {
  1390. switch (fsf_sqw0) {
  1391. /*
  1392. * Open Port command error codes
  1393. */
  1394. case FSF_SQ_SECURITY_REQUIRED:
  1395. dev_warn_ratelimited(dev,
  1396. "FC Endpoint Security error: FC security is required but not supported or configured on remote port 0x%016llx\n",
  1397. wwpn);
  1398. break;
  1399. case FSF_SQ_SECURITY_TIMEOUT:
  1400. dev_warn_ratelimited(dev,
  1401. "FC Endpoint Security error: a timeout prevented opening remote port 0x%016llx\n",
  1402. wwpn);
  1403. break;
  1404. case FSF_SQ_SECURITY_KM_UNAVAILABLE:
  1405. dev_warn_ratelimited(dev,
  1406. "FC Endpoint Security error: opening remote port 0x%016llx failed because local and external key manager cannot communicate\n",
  1407. wwpn);
  1408. break;
  1409. case FSF_SQ_SECURITY_RKM_UNAVAILABLE:
  1410. dev_warn_ratelimited(dev,
  1411. "FC Endpoint Security error: opening remote port 0x%016llx failed because it cannot communicate with the external key manager\n",
  1412. wwpn);
  1413. break;
  1414. case FSF_SQ_SECURITY_AUTH_FAILURE:
  1415. dev_warn_ratelimited(dev,
  1416. "FC Endpoint Security error: the device could not verify the identity of remote port 0x%016llx\n",
  1417. wwpn);
  1418. break;
  1419. /*
  1420. * Send FCP command error codes
  1421. */
  1422. case FSF_SQ_SECURITY_ENC_FAILURE:
  1423. dev_warn_ratelimited(dev,
  1424. "FC Endpoint Security error: FC connection to remote port 0x%016llx closed because encryption broke down\n",
  1425. wwpn);
  1426. break;
  1427. /*
  1428. * Unknown error codes
  1429. */
  1430. default:
  1431. dev_warn_ratelimited(dev,
  1432. "FC Endpoint Security error: the device issued an unknown error code 0x%08x related to the FC connection to remote port 0x%016llx\n",
  1433. fsf_sqw0, wwpn);
  1434. }
  1435. }
  1436. static void zfcp_fsf_open_port_handler(struct zfcp_fsf_req *req)
  1437. {
  1438. struct zfcp_adapter *adapter = req->adapter;
  1439. struct zfcp_port *port = req->data;
  1440. struct fsf_qtcb_header *header = &req->qtcb->header;
  1441. struct fsf_qtcb_bottom_support *bottom = &req->qtcb->bottom.support;
  1442. struct fc_els_flogi *plogi;
  1443. if (req->status & ZFCP_STATUS_FSFREQ_ERROR)
  1444. goto out;
  1445. switch (header->fsf_status) {
  1446. case FSF_PORT_ALREADY_OPEN:
  1447. break;
  1448. case FSF_MAXIMUM_NUMBER_OF_PORTS_EXCEEDED:
  1449. dev_warn(&adapter->ccw_device->dev,
  1450. "Not enough FCP adapter resources to open "
  1451. "remote port 0x%016Lx\n",
  1452. (unsigned long long)port->wwpn);
  1453. zfcp_erp_set_port_status(port,
  1454. ZFCP_STATUS_COMMON_ERP_FAILED);
  1455. req->status |= ZFCP_STATUS_FSFREQ_ERROR;
  1456. break;
  1457. case FSF_SECURITY_ERROR:
  1458. zfcp_fsf_log_security_error(&req->adapter->ccw_device->dev,
  1459. header->fsf_status_qual.word[0],
  1460. port->wwpn);
  1461. req->status |= ZFCP_STATUS_FSFREQ_ERROR;
  1462. break;
  1463. case FSF_ADAPTER_STATUS_AVAILABLE:
  1464. switch (header->fsf_status_qual.word[0]) {
  1465. case FSF_SQ_INVOKE_LINK_TEST_PROCEDURE:
  1466. /* no zfcp_fc_test_link() with failed open port */
  1467. fallthrough;
  1468. case FSF_SQ_ULP_DEPENDENT_ERP_REQUIRED:
  1469. case FSF_SQ_NO_RETRY_POSSIBLE:
  1470. req->status |= ZFCP_STATUS_FSFREQ_ERROR;
  1471. break;
  1472. }
  1473. break;
  1474. case FSF_GOOD:
  1475. port->handle = header->port_handle;
  1476. if (adapter->adapter_features & FSF_FEATURE_FC_SECURITY)
  1477. port->connection_info = bottom->connection_info;
  1478. else
  1479. port->connection_info = 0;
  1480. zfcp_fsf_log_port_fc_security(port, req);
  1481. atomic_or(ZFCP_STATUS_COMMON_OPEN |
  1482. ZFCP_STATUS_PORT_PHYS_OPEN, &port->status);
  1483. atomic_andnot(ZFCP_STATUS_COMMON_ACCESS_BOXED,
  1484. &port->status);
  1485. /* check whether D_ID has changed during open */
  1486. /*
  1487. * FIXME: This check is not airtight, as the FCP channel does
  1488. * not monitor closures of target port connections caused on
  1489. * the remote side. Thus, they might miss out on invalidating
  1490. * locally cached WWPNs (and other N_Port parameters) of gone
  1491. * target ports. So, our heroic attempt to make things safe
  1492. * could be undermined by 'open port' response data tagged with
  1493. * obsolete WWPNs. Another reason to monitor potential
  1494. * connection closures ourself at least (by interpreting
  1495. * incoming ELS' and unsolicited status). It just crosses my
  1496. * mind that one should be able to cross-check by means of
  1497. * another GID_PN straight after a port has been opened.
  1498. * Alternately, an ADISC/PDISC ELS should suffice, as well.
  1499. */
  1500. plogi = (struct fc_els_flogi *) bottom->els;
  1501. if (bottom->els1_length >= FSF_PLOGI_MIN_LEN)
  1502. zfcp_fc_plogi_evaluate(port, plogi);
  1503. break;
  1504. case FSF_UNKNOWN_OP_SUBTYPE:
  1505. req->status |= ZFCP_STATUS_FSFREQ_ERROR;
  1506. break;
  1507. }
  1508. out:
  1509. put_device(&port->dev);
  1510. }
  1511. /**
  1512. * zfcp_fsf_open_port - create and send open port request
  1513. * @erp_action: pointer to struct zfcp_erp_action
  1514. * Returns: 0 on success, error otherwise
  1515. */
  1516. int zfcp_fsf_open_port(struct zfcp_erp_action *erp_action)
  1517. {
  1518. struct zfcp_qdio *qdio = erp_action->adapter->qdio;
  1519. struct zfcp_port *port = erp_action->port;
  1520. struct zfcp_fsf_req *req;
  1521. int retval = -EIO;
  1522. spin_lock_irq(&qdio->req_q_lock);
  1523. if (zfcp_qdio_sbal_get(qdio))
  1524. goto out;
  1525. req = zfcp_fsf_req_create(qdio, FSF_QTCB_OPEN_PORT_WITH_DID,
  1526. SBAL_SFLAGS0_TYPE_READ,
  1527. qdio->adapter->pool.erp_req);
  1528. if (IS_ERR(req)) {
  1529. retval = PTR_ERR(req);
  1530. goto out;
  1531. }
  1532. req->status |= ZFCP_STATUS_FSFREQ_CLEANUP;
  1533. zfcp_qdio_set_sbale_last(qdio, &req->qdio_req);
  1534. req->handler = zfcp_fsf_open_port_handler;
  1535. hton24(req->qtcb->bottom.support.d_id, port->d_id);
  1536. req->data = port;
  1537. req->erp_action = erp_action;
  1538. erp_action->fsf_req_id = req->req_id;
  1539. get_device(&port->dev);
  1540. zfcp_fsf_start_erp_timer(req);
  1541. retval = zfcp_fsf_req_send(req);
  1542. if (retval) {
  1543. zfcp_fsf_req_free(req);
  1544. erp_action->fsf_req_id = 0;
  1545. put_device(&port->dev);
  1546. }
  1547. /* NOTE: DO NOT TOUCH req PAST THIS POINT! */
  1548. out:
  1549. spin_unlock_irq(&qdio->req_q_lock);
  1550. return retval;
  1551. }
  1552. static void zfcp_fsf_close_port_handler(struct zfcp_fsf_req *req)
  1553. {
  1554. struct zfcp_port *port = req->data;
  1555. if (req->status & ZFCP_STATUS_FSFREQ_ERROR)
  1556. return;
  1557. switch (req->qtcb->header.fsf_status) {
  1558. case FSF_PORT_HANDLE_NOT_VALID:
  1559. zfcp_erp_adapter_reopen(port->adapter, 0, "fscph_1");
  1560. req->status |= ZFCP_STATUS_FSFREQ_ERROR;
  1561. break;
  1562. case FSF_ADAPTER_STATUS_AVAILABLE:
  1563. break;
  1564. case FSF_GOOD:
  1565. zfcp_erp_clear_port_status(port, ZFCP_STATUS_COMMON_OPEN);
  1566. break;
  1567. }
  1568. }
  1569. /**
  1570. * zfcp_fsf_close_port - create and send close port request
  1571. * @erp_action: pointer to struct zfcp_erp_action
  1572. * Returns: 0 on success, error otherwise
  1573. */
  1574. int zfcp_fsf_close_port(struct zfcp_erp_action *erp_action)
  1575. {
  1576. struct zfcp_qdio *qdio = erp_action->adapter->qdio;
  1577. struct zfcp_fsf_req *req;
  1578. int retval = -EIO;
  1579. spin_lock_irq(&qdio->req_q_lock);
  1580. if (zfcp_qdio_sbal_get(qdio))
  1581. goto out;
  1582. req = zfcp_fsf_req_create(qdio, FSF_QTCB_CLOSE_PORT,
  1583. SBAL_SFLAGS0_TYPE_READ,
  1584. qdio->adapter->pool.erp_req);
  1585. if (IS_ERR(req)) {
  1586. retval = PTR_ERR(req);
  1587. goto out;
  1588. }
  1589. req->status |= ZFCP_STATUS_FSFREQ_CLEANUP;
  1590. zfcp_qdio_set_sbale_last(qdio, &req->qdio_req);
  1591. req->handler = zfcp_fsf_close_port_handler;
  1592. req->data = erp_action->port;
  1593. req->erp_action = erp_action;
  1594. req->qtcb->header.port_handle = erp_action->port->handle;
  1595. erp_action->fsf_req_id = req->req_id;
  1596. zfcp_fsf_start_erp_timer(req);
  1597. retval = zfcp_fsf_req_send(req);
  1598. if (retval) {
  1599. zfcp_fsf_req_free(req);
  1600. erp_action->fsf_req_id = 0;
  1601. }
  1602. /* NOTE: DO NOT TOUCH req PAST THIS POINT! */
  1603. out:
  1604. spin_unlock_irq(&qdio->req_q_lock);
  1605. return retval;
  1606. }
  1607. static void zfcp_fsf_open_wka_port_handler(struct zfcp_fsf_req *req)
  1608. {
  1609. struct zfcp_fc_wka_port *wka_port = req->data;
  1610. struct fsf_qtcb_header *header = &req->qtcb->header;
  1611. if (req->status & ZFCP_STATUS_FSFREQ_ERROR) {
  1612. wka_port->status = ZFCP_FC_WKA_PORT_OFFLINE;
  1613. goto out;
  1614. }
  1615. switch (header->fsf_status) {
  1616. case FSF_MAXIMUM_NUMBER_OF_PORTS_EXCEEDED:
  1617. dev_warn(&req->adapter->ccw_device->dev,
  1618. "Opening WKA port 0x%x failed\n", wka_port->d_id);
  1619. fallthrough;
  1620. case FSF_ADAPTER_STATUS_AVAILABLE:
  1621. req->status |= ZFCP_STATUS_FSFREQ_ERROR;
  1622. wka_port->status = ZFCP_FC_WKA_PORT_OFFLINE;
  1623. break;
  1624. case FSF_GOOD:
  1625. wka_port->handle = header->port_handle;
  1626. fallthrough;
  1627. case FSF_PORT_ALREADY_OPEN:
  1628. wka_port->status = ZFCP_FC_WKA_PORT_ONLINE;
  1629. }
  1630. out:
  1631. wake_up(&wka_port->completion_wq);
  1632. }
  1633. /**
  1634. * zfcp_fsf_open_wka_port - create and send open wka-port request
  1635. * @wka_port: pointer to struct zfcp_fc_wka_port
  1636. * Returns: 0 on success, error otherwise
  1637. */
  1638. int zfcp_fsf_open_wka_port(struct zfcp_fc_wka_port *wka_port)
  1639. {
  1640. struct zfcp_qdio *qdio = wka_port->adapter->qdio;
  1641. struct zfcp_fsf_req *req;
  1642. unsigned long req_id = 0;
  1643. int retval = -EIO;
  1644. spin_lock_irq(&qdio->req_q_lock);
  1645. if (zfcp_qdio_sbal_get(qdio))
  1646. goto out;
  1647. req = zfcp_fsf_req_create(qdio, FSF_QTCB_OPEN_PORT_WITH_DID,
  1648. SBAL_SFLAGS0_TYPE_READ,
  1649. qdio->adapter->pool.erp_req);
  1650. if (IS_ERR(req)) {
  1651. retval = PTR_ERR(req);
  1652. goto out;
  1653. }
  1654. req->status |= ZFCP_STATUS_FSFREQ_CLEANUP;
  1655. zfcp_qdio_set_sbale_last(qdio, &req->qdio_req);
  1656. req->handler = zfcp_fsf_open_wka_port_handler;
  1657. hton24(req->qtcb->bottom.support.d_id, wka_port->d_id);
  1658. req->data = wka_port;
  1659. req_id = req->req_id;
  1660. zfcp_fsf_start_timer(req, ZFCP_FSF_REQUEST_TIMEOUT);
  1661. retval = zfcp_fsf_req_send(req);
  1662. if (retval)
  1663. zfcp_fsf_req_free(req);
  1664. /* NOTE: DO NOT TOUCH req PAST THIS POINT! */
  1665. out:
  1666. spin_unlock_irq(&qdio->req_q_lock);
  1667. if (!retval)
  1668. zfcp_dbf_rec_run_wka("fsowp_1", wka_port, req_id);
  1669. return retval;
  1670. }
  1671. static void zfcp_fsf_close_wka_port_handler(struct zfcp_fsf_req *req)
  1672. {
  1673. struct zfcp_fc_wka_port *wka_port = req->data;
  1674. if (req->qtcb->header.fsf_status == FSF_PORT_HANDLE_NOT_VALID) {
  1675. req->status |= ZFCP_STATUS_FSFREQ_ERROR;
  1676. zfcp_erp_adapter_reopen(wka_port->adapter, 0, "fscwph1");
  1677. }
  1678. wka_port->status = ZFCP_FC_WKA_PORT_OFFLINE;
  1679. wake_up(&wka_port->completion_wq);
  1680. }
  1681. /**
  1682. * zfcp_fsf_close_wka_port - create and send close wka port request
  1683. * @wka_port: WKA port to open
  1684. * Returns: 0 on success, error otherwise
  1685. */
  1686. int zfcp_fsf_close_wka_port(struct zfcp_fc_wka_port *wka_port)
  1687. {
  1688. struct zfcp_qdio *qdio = wka_port->adapter->qdio;
  1689. struct zfcp_fsf_req *req;
  1690. unsigned long req_id = 0;
  1691. int retval = -EIO;
  1692. spin_lock_irq(&qdio->req_q_lock);
  1693. if (zfcp_qdio_sbal_get(qdio))
  1694. goto out;
  1695. req = zfcp_fsf_req_create(qdio, FSF_QTCB_CLOSE_PORT,
  1696. SBAL_SFLAGS0_TYPE_READ,
  1697. qdio->adapter->pool.erp_req);
  1698. if (IS_ERR(req)) {
  1699. retval = PTR_ERR(req);
  1700. goto out;
  1701. }
  1702. req->status |= ZFCP_STATUS_FSFREQ_CLEANUP;
  1703. zfcp_qdio_set_sbale_last(qdio, &req->qdio_req);
  1704. req->handler = zfcp_fsf_close_wka_port_handler;
  1705. req->data = wka_port;
  1706. req->qtcb->header.port_handle = wka_port->handle;
  1707. req_id = req->req_id;
  1708. zfcp_fsf_start_timer(req, ZFCP_FSF_REQUEST_TIMEOUT);
  1709. retval = zfcp_fsf_req_send(req);
  1710. if (retval)
  1711. zfcp_fsf_req_free(req);
  1712. /* NOTE: DO NOT TOUCH req PAST THIS POINT! */
  1713. out:
  1714. spin_unlock_irq(&qdio->req_q_lock);
  1715. if (!retval)
  1716. zfcp_dbf_rec_run_wka("fscwp_1", wka_port, req_id);
  1717. return retval;
  1718. }
  1719. static void zfcp_fsf_close_physical_port_handler(struct zfcp_fsf_req *req)
  1720. {
  1721. struct zfcp_port *port = req->data;
  1722. struct fsf_qtcb_header *header = &req->qtcb->header;
  1723. struct scsi_device *sdev;
  1724. if (req->status & ZFCP_STATUS_FSFREQ_ERROR)
  1725. return;
  1726. switch (header->fsf_status) {
  1727. case FSF_PORT_HANDLE_NOT_VALID:
  1728. zfcp_erp_adapter_reopen(port->adapter, 0, "fscpph1");
  1729. req->status |= ZFCP_STATUS_FSFREQ_ERROR;
  1730. break;
  1731. case FSF_PORT_BOXED:
  1732. /* can't use generic zfcp_erp_modify_port_status because
  1733. * ZFCP_STATUS_COMMON_OPEN must not be reset for the port */
  1734. atomic_andnot(ZFCP_STATUS_PORT_PHYS_OPEN, &port->status);
  1735. shost_for_each_device(sdev, port->adapter->scsi_host)
  1736. if (sdev_to_zfcp(sdev)->port == port)
  1737. atomic_andnot(ZFCP_STATUS_COMMON_OPEN,
  1738. &sdev_to_zfcp(sdev)->status);
  1739. zfcp_erp_set_port_status(port, ZFCP_STATUS_COMMON_ACCESS_BOXED);
  1740. zfcp_erp_port_reopen(port, ZFCP_STATUS_COMMON_ERP_FAILED,
  1741. "fscpph2");
  1742. req->status |= ZFCP_STATUS_FSFREQ_ERROR;
  1743. break;
  1744. case FSF_ADAPTER_STATUS_AVAILABLE:
  1745. switch (header->fsf_status_qual.word[0]) {
  1746. case FSF_SQ_INVOKE_LINK_TEST_PROCEDURE:
  1747. case FSF_SQ_ULP_DEPENDENT_ERP_REQUIRED:
  1748. req->status |= ZFCP_STATUS_FSFREQ_ERROR;
  1749. break;
  1750. }
  1751. break;
  1752. case FSF_GOOD:
  1753. /* can't use generic zfcp_erp_modify_port_status because
  1754. * ZFCP_STATUS_COMMON_OPEN must not be reset for the port
  1755. */
  1756. atomic_andnot(ZFCP_STATUS_PORT_PHYS_OPEN, &port->status);
  1757. shost_for_each_device(sdev, port->adapter->scsi_host)
  1758. if (sdev_to_zfcp(sdev)->port == port)
  1759. atomic_andnot(ZFCP_STATUS_COMMON_OPEN,
  1760. &sdev_to_zfcp(sdev)->status);
  1761. break;
  1762. }
  1763. }
  1764. /**
  1765. * zfcp_fsf_close_physical_port - close physical port
  1766. * @erp_action: pointer to struct zfcp_erp_action
  1767. * Returns: 0 on success
  1768. */
  1769. int zfcp_fsf_close_physical_port(struct zfcp_erp_action *erp_action)
  1770. {
  1771. struct zfcp_qdio *qdio = erp_action->adapter->qdio;
  1772. struct zfcp_fsf_req *req;
  1773. int retval = -EIO;
  1774. spin_lock_irq(&qdio->req_q_lock);
  1775. if (zfcp_qdio_sbal_get(qdio))
  1776. goto out;
  1777. req = zfcp_fsf_req_create(qdio, FSF_QTCB_CLOSE_PHYSICAL_PORT,
  1778. SBAL_SFLAGS0_TYPE_READ,
  1779. qdio->adapter->pool.erp_req);
  1780. if (IS_ERR(req)) {
  1781. retval = PTR_ERR(req);
  1782. goto out;
  1783. }
  1784. req->status |= ZFCP_STATUS_FSFREQ_CLEANUP;
  1785. zfcp_qdio_set_sbale_last(qdio, &req->qdio_req);
  1786. req->data = erp_action->port;
  1787. req->qtcb->header.port_handle = erp_action->port->handle;
  1788. req->erp_action = erp_action;
  1789. req->handler = zfcp_fsf_close_physical_port_handler;
  1790. erp_action->fsf_req_id = req->req_id;
  1791. zfcp_fsf_start_erp_timer(req);
  1792. retval = zfcp_fsf_req_send(req);
  1793. if (retval) {
  1794. zfcp_fsf_req_free(req);
  1795. erp_action->fsf_req_id = 0;
  1796. }
  1797. /* NOTE: DO NOT TOUCH req PAST THIS POINT! */
  1798. out:
  1799. spin_unlock_irq(&qdio->req_q_lock);
  1800. return retval;
  1801. }
  1802. static void zfcp_fsf_open_lun_handler(struct zfcp_fsf_req *req)
  1803. {
  1804. struct zfcp_adapter *adapter = req->adapter;
  1805. struct scsi_device *sdev = req->data;
  1806. struct zfcp_scsi_dev *zfcp_sdev;
  1807. struct fsf_qtcb_header *header = &req->qtcb->header;
  1808. union fsf_status_qual *qual = &header->fsf_status_qual;
  1809. if (req->status & ZFCP_STATUS_FSFREQ_ERROR)
  1810. return;
  1811. zfcp_sdev = sdev_to_zfcp(sdev);
  1812. atomic_andnot(ZFCP_STATUS_COMMON_ACCESS_DENIED |
  1813. ZFCP_STATUS_COMMON_ACCESS_BOXED,
  1814. &zfcp_sdev->status);
  1815. switch (header->fsf_status) {
  1816. case FSF_PORT_HANDLE_NOT_VALID:
  1817. zfcp_erp_adapter_reopen(adapter, 0, "fsouh_1");
  1818. fallthrough;
  1819. case FSF_LUN_ALREADY_OPEN:
  1820. break;
  1821. case FSF_PORT_BOXED:
  1822. zfcp_erp_set_port_status(zfcp_sdev->port,
  1823. ZFCP_STATUS_COMMON_ACCESS_BOXED);
  1824. zfcp_erp_port_reopen(zfcp_sdev->port,
  1825. ZFCP_STATUS_COMMON_ERP_FAILED, "fsouh_2");
  1826. req->status |= ZFCP_STATUS_FSFREQ_ERROR;
  1827. break;
  1828. case FSF_LUN_SHARING_VIOLATION:
  1829. if (qual->word[0])
  1830. dev_warn(&zfcp_sdev->port->adapter->ccw_device->dev,
  1831. "LUN 0x%016Lx on port 0x%016Lx is already in "
  1832. "use by CSS%d, MIF Image ID %x\n",
  1833. zfcp_scsi_dev_lun(sdev),
  1834. (unsigned long long)zfcp_sdev->port->wwpn,
  1835. qual->fsf_queue_designator.cssid,
  1836. qual->fsf_queue_designator.hla);
  1837. zfcp_erp_set_lun_status(sdev,
  1838. ZFCP_STATUS_COMMON_ERP_FAILED |
  1839. ZFCP_STATUS_COMMON_ACCESS_DENIED);
  1840. req->status |= ZFCP_STATUS_FSFREQ_ERROR;
  1841. break;
  1842. case FSF_MAXIMUM_NUMBER_OF_LUNS_EXCEEDED:
  1843. dev_warn(&adapter->ccw_device->dev,
  1844. "No handle is available for LUN "
  1845. "0x%016Lx on port 0x%016Lx\n",
  1846. (unsigned long long)zfcp_scsi_dev_lun(sdev),
  1847. (unsigned long long)zfcp_sdev->port->wwpn);
  1848. zfcp_erp_set_lun_status(sdev, ZFCP_STATUS_COMMON_ERP_FAILED);
  1849. fallthrough;
  1850. case FSF_INVALID_COMMAND_OPTION:
  1851. req->status |= ZFCP_STATUS_FSFREQ_ERROR;
  1852. break;
  1853. case FSF_ADAPTER_STATUS_AVAILABLE:
  1854. switch (header->fsf_status_qual.word[0]) {
  1855. case FSF_SQ_INVOKE_LINK_TEST_PROCEDURE:
  1856. zfcp_fc_test_link(zfcp_sdev->port);
  1857. fallthrough;
  1858. case FSF_SQ_ULP_DEPENDENT_ERP_REQUIRED:
  1859. req->status |= ZFCP_STATUS_FSFREQ_ERROR;
  1860. break;
  1861. }
  1862. break;
  1863. case FSF_GOOD:
  1864. zfcp_sdev->lun_handle = header->lun_handle;
  1865. atomic_or(ZFCP_STATUS_COMMON_OPEN, &zfcp_sdev->status);
  1866. break;
  1867. }
  1868. }
  1869. /**
  1870. * zfcp_fsf_open_lun - open LUN
  1871. * @erp_action: pointer to struct zfcp_erp_action
  1872. * Returns: 0 on success, error otherwise
  1873. */
  1874. int zfcp_fsf_open_lun(struct zfcp_erp_action *erp_action)
  1875. {
  1876. struct zfcp_adapter *adapter = erp_action->adapter;
  1877. struct zfcp_qdio *qdio = adapter->qdio;
  1878. struct zfcp_fsf_req *req;
  1879. int retval = -EIO;
  1880. spin_lock_irq(&qdio->req_q_lock);
  1881. if (zfcp_qdio_sbal_get(qdio))
  1882. goto out;
  1883. req = zfcp_fsf_req_create(qdio, FSF_QTCB_OPEN_LUN,
  1884. SBAL_SFLAGS0_TYPE_READ,
  1885. adapter->pool.erp_req);
  1886. if (IS_ERR(req)) {
  1887. retval = PTR_ERR(req);
  1888. goto out;
  1889. }
  1890. req->status |= ZFCP_STATUS_FSFREQ_CLEANUP;
  1891. zfcp_qdio_set_sbale_last(qdio, &req->qdio_req);
  1892. req->qtcb->header.port_handle = erp_action->port->handle;
  1893. req->qtcb->bottom.support.fcp_lun = zfcp_scsi_dev_lun(erp_action->sdev);
  1894. req->handler = zfcp_fsf_open_lun_handler;
  1895. req->data = erp_action->sdev;
  1896. req->erp_action = erp_action;
  1897. erp_action->fsf_req_id = req->req_id;
  1898. if (!(adapter->connection_features & FSF_FEATURE_NPIV_MODE))
  1899. req->qtcb->bottom.support.option = FSF_OPEN_LUN_SUPPRESS_BOXING;
  1900. zfcp_fsf_start_erp_timer(req);
  1901. retval = zfcp_fsf_req_send(req);
  1902. if (retval) {
  1903. zfcp_fsf_req_free(req);
  1904. erp_action->fsf_req_id = 0;
  1905. }
  1906. /* NOTE: DO NOT TOUCH req PAST THIS POINT! */
  1907. out:
  1908. spin_unlock_irq(&qdio->req_q_lock);
  1909. return retval;
  1910. }
  1911. static void zfcp_fsf_close_lun_handler(struct zfcp_fsf_req *req)
  1912. {
  1913. struct scsi_device *sdev = req->data;
  1914. struct zfcp_scsi_dev *zfcp_sdev;
  1915. if (req->status & ZFCP_STATUS_FSFREQ_ERROR)
  1916. return;
  1917. zfcp_sdev = sdev_to_zfcp(sdev);
  1918. switch (req->qtcb->header.fsf_status) {
  1919. case FSF_PORT_HANDLE_NOT_VALID:
  1920. zfcp_erp_adapter_reopen(zfcp_sdev->port->adapter, 0, "fscuh_1");
  1921. req->status |= ZFCP_STATUS_FSFREQ_ERROR;
  1922. break;
  1923. case FSF_LUN_HANDLE_NOT_VALID:
  1924. zfcp_erp_port_reopen(zfcp_sdev->port, 0, "fscuh_2");
  1925. req->status |= ZFCP_STATUS_FSFREQ_ERROR;
  1926. break;
  1927. case FSF_PORT_BOXED:
  1928. zfcp_erp_set_port_status(zfcp_sdev->port,
  1929. ZFCP_STATUS_COMMON_ACCESS_BOXED);
  1930. zfcp_erp_port_reopen(zfcp_sdev->port,
  1931. ZFCP_STATUS_COMMON_ERP_FAILED, "fscuh_3");
  1932. req->status |= ZFCP_STATUS_FSFREQ_ERROR;
  1933. break;
  1934. case FSF_ADAPTER_STATUS_AVAILABLE:
  1935. switch (req->qtcb->header.fsf_status_qual.word[0]) {
  1936. case FSF_SQ_INVOKE_LINK_TEST_PROCEDURE:
  1937. zfcp_fc_test_link(zfcp_sdev->port);
  1938. fallthrough;
  1939. case FSF_SQ_ULP_DEPENDENT_ERP_REQUIRED:
  1940. req->status |= ZFCP_STATUS_FSFREQ_ERROR;
  1941. break;
  1942. }
  1943. break;
  1944. case FSF_GOOD:
  1945. atomic_andnot(ZFCP_STATUS_COMMON_OPEN, &zfcp_sdev->status);
  1946. break;
  1947. }
  1948. }
  1949. /**
  1950. * zfcp_fsf_close_LUN - close LUN
  1951. * @erp_action: pointer to erp_action triggering the "close LUN"
  1952. * Returns: 0 on success, error otherwise
  1953. */
  1954. int zfcp_fsf_close_lun(struct zfcp_erp_action *erp_action)
  1955. {
  1956. struct zfcp_qdio *qdio = erp_action->adapter->qdio;
  1957. struct zfcp_scsi_dev *zfcp_sdev = sdev_to_zfcp(erp_action->sdev);
  1958. struct zfcp_fsf_req *req;
  1959. int retval = -EIO;
  1960. spin_lock_irq(&qdio->req_q_lock);
  1961. if (zfcp_qdio_sbal_get(qdio))
  1962. goto out;
  1963. req = zfcp_fsf_req_create(qdio, FSF_QTCB_CLOSE_LUN,
  1964. SBAL_SFLAGS0_TYPE_READ,
  1965. qdio->adapter->pool.erp_req);
  1966. if (IS_ERR(req)) {
  1967. retval = PTR_ERR(req);
  1968. goto out;
  1969. }
  1970. req->status |= ZFCP_STATUS_FSFREQ_CLEANUP;
  1971. zfcp_qdio_set_sbale_last(qdio, &req->qdio_req);
  1972. req->qtcb->header.port_handle = erp_action->port->handle;
  1973. req->qtcb->header.lun_handle = zfcp_sdev->lun_handle;
  1974. req->handler = zfcp_fsf_close_lun_handler;
  1975. req->data = erp_action->sdev;
  1976. req->erp_action = erp_action;
  1977. erp_action->fsf_req_id = req->req_id;
  1978. zfcp_fsf_start_erp_timer(req);
  1979. retval = zfcp_fsf_req_send(req);
  1980. if (retval) {
  1981. zfcp_fsf_req_free(req);
  1982. erp_action->fsf_req_id = 0;
  1983. }
  1984. /* NOTE: DO NOT TOUCH req PAST THIS POINT! */
  1985. out:
  1986. spin_unlock_irq(&qdio->req_q_lock);
  1987. return retval;
  1988. }
  1989. static void zfcp_fsf_update_lat(struct zfcp_latency_record *lat_rec, u32 lat)
  1990. {
  1991. lat_rec->sum += lat;
  1992. lat_rec->min = min(lat_rec->min, lat);
  1993. lat_rec->max = max(lat_rec->max, lat);
  1994. }
  1995. static void zfcp_fsf_req_trace(struct zfcp_fsf_req *req, struct scsi_cmnd *scsi)
  1996. {
  1997. struct fsf_qual_latency_info *lat_in;
  1998. struct zfcp_latency_cont *lat = NULL;
  1999. struct zfcp_scsi_dev *zfcp_sdev;
  2000. struct zfcp_blk_drv_data blktrc;
  2001. int ticks = req->adapter->timer_ticks;
  2002. lat_in = &req->qtcb->prefix.prot_status_qual.latency_info;
  2003. blktrc.flags = 0;
  2004. blktrc.magic = ZFCP_BLK_DRV_DATA_MAGIC;
  2005. if (req->status & ZFCP_STATUS_FSFREQ_ERROR)
  2006. blktrc.flags |= ZFCP_BLK_REQ_ERROR;
  2007. blktrc.inb_usage = 0;
  2008. blktrc.outb_usage = req->qdio_req.qdio_outb_usage;
  2009. if (req->adapter->adapter_features & FSF_FEATURE_MEASUREMENT_DATA &&
  2010. !(req->status & ZFCP_STATUS_FSFREQ_ERROR)) {
  2011. zfcp_sdev = sdev_to_zfcp(scsi->device);
  2012. blktrc.flags |= ZFCP_BLK_LAT_VALID;
  2013. blktrc.channel_lat = lat_in->channel_lat * ticks;
  2014. blktrc.fabric_lat = lat_in->fabric_lat * ticks;
  2015. switch (req->qtcb->bottom.io.data_direction) {
  2016. case FSF_DATADIR_DIF_READ_STRIP:
  2017. case FSF_DATADIR_DIF_READ_CONVERT:
  2018. case FSF_DATADIR_READ:
  2019. lat = &zfcp_sdev->latencies.read;
  2020. break;
  2021. case FSF_DATADIR_DIF_WRITE_INSERT:
  2022. case FSF_DATADIR_DIF_WRITE_CONVERT:
  2023. case FSF_DATADIR_WRITE:
  2024. lat = &zfcp_sdev->latencies.write;
  2025. break;
  2026. case FSF_DATADIR_CMND:
  2027. lat = &zfcp_sdev->latencies.cmd;
  2028. break;
  2029. }
  2030. if (lat) {
  2031. spin_lock(&zfcp_sdev->latencies.lock);
  2032. zfcp_fsf_update_lat(&lat->channel, lat_in->channel_lat);
  2033. zfcp_fsf_update_lat(&lat->fabric, lat_in->fabric_lat);
  2034. lat->counter++;
  2035. spin_unlock(&zfcp_sdev->latencies.lock);
  2036. }
  2037. }
  2038. blk_add_driver_data(scsi->request->q, scsi->request, &blktrc,
  2039. sizeof(blktrc));
  2040. }
  2041. /**
  2042. * zfcp_fsf_fcp_handler_common() - FCP response handler common to I/O and TMF.
  2043. * @req: Pointer to FSF request.
  2044. * @sdev: Pointer to SCSI device as request context.
  2045. */
  2046. static void zfcp_fsf_fcp_handler_common(struct zfcp_fsf_req *req,
  2047. struct scsi_device *sdev)
  2048. {
  2049. struct zfcp_scsi_dev *zfcp_sdev;
  2050. struct fsf_qtcb_header *header = &req->qtcb->header;
  2051. if (unlikely(req->status & ZFCP_STATUS_FSFREQ_ERROR))
  2052. return;
  2053. zfcp_sdev = sdev_to_zfcp(sdev);
  2054. switch (header->fsf_status) {
  2055. case FSF_HANDLE_MISMATCH:
  2056. case FSF_PORT_HANDLE_NOT_VALID:
  2057. zfcp_erp_adapter_reopen(req->adapter, 0, "fssfch1");
  2058. req->status |= ZFCP_STATUS_FSFREQ_ERROR;
  2059. break;
  2060. case FSF_FCPLUN_NOT_VALID:
  2061. case FSF_LUN_HANDLE_NOT_VALID:
  2062. zfcp_erp_port_reopen(zfcp_sdev->port, 0, "fssfch2");
  2063. req->status |= ZFCP_STATUS_FSFREQ_ERROR;
  2064. break;
  2065. case FSF_SERVICE_CLASS_NOT_SUPPORTED:
  2066. zfcp_fsf_class_not_supp(req);
  2067. break;
  2068. case FSF_DIRECTION_INDICATOR_NOT_VALID:
  2069. dev_err(&req->adapter->ccw_device->dev,
  2070. "Incorrect direction %d, LUN 0x%016Lx on port "
  2071. "0x%016Lx closed\n",
  2072. req->qtcb->bottom.io.data_direction,
  2073. (unsigned long long)zfcp_scsi_dev_lun(sdev),
  2074. (unsigned long long)zfcp_sdev->port->wwpn);
  2075. zfcp_erp_adapter_shutdown(req->adapter, 0, "fssfch3");
  2076. req->status |= ZFCP_STATUS_FSFREQ_ERROR;
  2077. break;
  2078. case FSF_CMND_LENGTH_NOT_VALID:
  2079. dev_err(&req->adapter->ccw_device->dev,
  2080. "Incorrect FCP_CMND length %d, FCP device closed\n",
  2081. req->qtcb->bottom.io.fcp_cmnd_length);
  2082. zfcp_erp_adapter_shutdown(req->adapter, 0, "fssfch4");
  2083. req->status |= ZFCP_STATUS_FSFREQ_ERROR;
  2084. break;
  2085. case FSF_PORT_BOXED:
  2086. zfcp_erp_set_port_status(zfcp_sdev->port,
  2087. ZFCP_STATUS_COMMON_ACCESS_BOXED);
  2088. zfcp_erp_port_reopen(zfcp_sdev->port,
  2089. ZFCP_STATUS_COMMON_ERP_FAILED, "fssfch5");
  2090. req->status |= ZFCP_STATUS_FSFREQ_ERROR;
  2091. break;
  2092. case FSF_LUN_BOXED:
  2093. zfcp_erp_set_lun_status(sdev, ZFCP_STATUS_COMMON_ACCESS_BOXED);
  2094. zfcp_erp_lun_reopen(sdev, ZFCP_STATUS_COMMON_ERP_FAILED,
  2095. "fssfch6");
  2096. req->status |= ZFCP_STATUS_FSFREQ_ERROR;
  2097. break;
  2098. case FSF_ADAPTER_STATUS_AVAILABLE:
  2099. if (header->fsf_status_qual.word[0] ==
  2100. FSF_SQ_INVOKE_LINK_TEST_PROCEDURE)
  2101. zfcp_fc_test_link(zfcp_sdev->port);
  2102. req->status |= ZFCP_STATUS_FSFREQ_ERROR;
  2103. break;
  2104. case FSF_SECURITY_ERROR:
  2105. zfcp_fsf_log_security_error(&req->adapter->ccw_device->dev,
  2106. header->fsf_status_qual.word[0],
  2107. zfcp_sdev->port->wwpn);
  2108. zfcp_erp_port_forced_reopen(zfcp_sdev->port, 0, "fssfch7");
  2109. req->status |= ZFCP_STATUS_FSFREQ_ERROR;
  2110. break;
  2111. }
  2112. }
  2113. static void zfcp_fsf_fcp_cmnd_handler(struct zfcp_fsf_req *req)
  2114. {
  2115. struct scsi_cmnd *scpnt;
  2116. struct fcp_resp_with_ext *fcp_rsp;
  2117. unsigned long flags;
  2118. read_lock_irqsave(&req->adapter->abort_lock, flags);
  2119. scpnt = req->data;
  2120. if (unlikely(!scpnt)) {
  2121. read_unlock_irqrestore(&req->adapter->abort_lock, flags);
  2122. return;
  2123. }
  2124. zfcp_fsf_fcp_handler_common(req, scpnt->device);
  2125. if (unlikely(req->status & ZFCP_STATUS_FSFREQ_ERROR)) {
  2126. set_host_byte(scpnt, DID_TRANSPORT_DISRUPTED);
  2127. goto skip_fsfstatus;
  2128. }
  2129. switch (req->qtcb->header.fsf_status) {
  2130. case FSF_INCONSISTENT_PROT_DATA:
  2131. case FSF_INVALID_PROT_PARM:
  2132. set_host_byte(scpnt, DID_ERROR);
  2133. goto skip_fsfstatus;
  2134. case FSF_BLOCK_GUARD_CHECK_FAILURE:
  2135. zfcp_scsi_dif_sense_error(scpnt, 0x1);
  2136. goto skip_fsfstatus;
  2137. case FSF_APP_TAG_CHECK_FAILURE:
  2138. zfcp_scsi_dif_sense_error(scpnt, 0x2);
  2139. goto skip_fsfstatus;
  2140. case FSF_REF_TAG_CHECK_FAILURE:
  2141. zfcp_scsi_dif_sense_error(scpnt, 0x3);
  2142. goto skip_fsfstatus;
  2143. }
  2144. BUILD_BUG_ON(sizeof(struct fcp_resp_with_ext) > FSF_FCP_RSP_SIZE);
  2145. fcp_rsp = &req->qtcb->bottom.io.fcp_rsp.iu;
  2146. zfcp_fc_eval_fcp_rsp(fcp_rsp, scpnt);
  2147. skip_fsfstatus:
  2148. zfcp_fsf_req_trace(req, scpnt);
  2149. zfcp_dbf_scsi_result(scpnt, req);
  2150. scpnt->host_scribble = NULL;
  2151. (scpnt->scsi_done) (scpnt);
  2152. /*
  2153. * We must hold this lock until scsi_done has been called.
  2154. * Otherwise we may call scsi_done after abort regarding this
  2155. * command has completed.
  2156. * Note: scsi_done must not block!
  2157. */
  2158. read_unlock_irqrestore(&req->adapter->abort_lock, flags);
  2159. }
  2160. static int zfcp_fsf_set_data_dir(struct scsi_cmnd *scsi_cmnd, u32 *data_dir)
  2161. {
  2162. switch (scsi_get_prot_op(scsi_cmnd)) {
  2163. case SCSI_PROT_NORMAL:
  2164. switch (scsi_cmnd->sc_data_direction) {
  2165. case DMA_NONE:
  2166. *data_dir = FSF_DATADIR_CMND;
  2167. break;
  2168. case DMA_FROM_DEVICE:
  2169. *data_dir = FSF_DATADIR_READ;
  2170. break;
  2171. case DMA_TO_DEVICE:
  2172. *data_dir = FSF_DATADIR_WRITE;
  2173. break;
  2174. case DMA_BIDIRECTIONAL:
  2175. return -EINVAL;
  2176. }
  2177. break;
  2178. case SCSI_PROT_READ_STRIP:
  2179. *data_dir = FSF_DATADIR_DIF_READ_STRIP;
  2180. break;
  2181. case SCSI_PROT_WRITE_INSERT:
  2182. *data_dir = FSF_DATADIR_DIF_WRITE_INSERT;
  2183. break;
  2184. case SCSI_PROT_READ_PASS:
  2185. *data_dir = FSF_DATADIR_DIF_READ_CONVERT;
  2186. break;
  2187. case SCSI_PROT_WRITE_PASS:
  2188. *data_dir = FSF_DATADIR_DIF_WRITE_CONVERT;
  2189. break;
  2190. default:
  2191. return -EINVAL;
  2192. }
  2193. return 0;
  2194. }
  2195. /**
  2196. * zfcp_fsf_fcp_cmnd - initiate an FCP command (for a SCSI command)
  2197. * @scsi_cmnd: scsi command to be sent
  2198. */
  2199. int zfcp_fsf_fcp_cmnd(struct scsi_cmnd *scsi_cmnd)
  2200. {
  2201. struct zfcp_fsf_req *req;
  2202. struct fcp_cmnd *fcp_cmnd;
  2203. u8 sbtype = SBAL_SFLAGS0_TYPE_READ;
  2204. int retval = -EIO;
  2205. struct scsi_device *sdev = scsi_cmnd->device;
  2206. struct zfcp_scsi_dev *zfcp_sdev = sdev_to_zfcp(sdev);
  2207. struct zfcp_adapter *adapter = zfcp_sdev->port->adapter;
  2208. struct zfcp_qdio *qdio = adapter->qdio;
  2209. struct fsf_qtcb_bottom_io *io;
  2210. unsigned long flags;
  2211. if (unlikely(!(atomic_read(&zfcp_sdev->status) &
  2212. ZFCP_STATUS_COMMON_UNBLOCKED)))
  2213. return -EBUSY;
  2214. spin_lock_irqsave(&qdio->req_q_lock, flags);
  2215. if (atomic_read(&qdio->req_q_free) <= 0) {
  2216. atomic_inc(&qdio->req_q_full);
  2217. goto out;
  2218. }
  2219. if (scsi_cmnd->sc_data_direction == DMA_TO_DEVICE)
  2220. sbtype = SBAL_SFLAGS0_TYPE_WRITE;
  2221. req = zfcp_fsf_req_create(qdio, FSF_QTCB_FCP_CMND,
  2222. sbtype, adapter->pool.scsi_req);
  2223. if (IS_ERR(req)) {
  2224. retval = PTR_ERR(req);
  2225. goto out;
  2226. }
  2227. scsi_cmnd->host_scribble = (unsigned char *) req->req_id;
  2228. io = &req->qtcb->bottom.io;
  2229. req->status |= ZFCP_STATUS_FSFREQ_CLEANUP;
  2230. req->data = scsi_cmnd;
  2231. req->handler = zfcp_fsf_fcp_cmnd_handler;
  2232. req->qtcb->header.lun_handle = zfcp_sdev->lun_handle;
  2233. req->qtcb->header.port_handle = zfcp_sdev->port->handle;
  2234. io->service_class = FSF_CLASS_3;
  2235. io->fcp_cmnd_length = FCP_CMND_LEN;
  2236. if (scsi_get_prot_op(scsi_cmnd) != SCSI_PROT_NORMAL) {
  2237. io->data_block_length = scsi_cmnd->device->sector_size;
  2238. io->ref_tag_value = scsi_get_lba(scsi_cmnd) & 0xFFFFFFFF;
  2239. }
  2240. if (zfcp_fsf_set_data_dir(scsi_cmnd, &io->data_direction))
  2241. goto failed_scsi_cmnd;
  2242. BUILD_BUG_ON(sizeof(struct fcp_cmnd) > FSF_FCP_CMND_SIZE);
  2243. fcp_cmnd = &req->qtcb->bottom.io.fcp_cmnd.iu;
  2244. zfcp_fc_scsi_to_fcp(fcp_cmnd, scsi_cmnd);
  2245. if ((scsi_get_prot_op(scsi_cmnd) != SCSI_PROT_NORMAL) &&
  2246. scsi_prot_sg_count(scsi_cmnd)) {
  2247. zfcp_qdio_set_data_div(qdio, &req->qdio_req,
  2248. scsi_prot_sg_count(scsi_cmnd));
  2249. retval = zfcp_qdio_sbals_from_sg(qdio, &req->qdio_req,
  2250. scsi_prot_sglist(scsi_cmnd));
  2251. if (retval)
  2252. goto failed_scsi_cmnd;
  2253. io->prot_data_length = zfcp_qdio_real_bytes(
  2254. scsi_prot_sglist(scsi_cmnd));
  2255. }
  2256. retval = zfcp_qdio_sbals_from_sg(qdio, &req->qdio_req,
  2257. scsi_sglist(scsi_cmnd));
  2258. if (unlikely(retval))
  2259. goto failed_scsi_cmnd;
  2260. zfcp_qdio_set_sbale_last(adapter->qdio, &req->qdio_req);
  2261. if (zfcp_adapter_multi_buffer_active(adapter))
  2262. zfcp_qdio_set_scount(qdio, &req->qdio_req);
  2263. retval = zfcp_fsf_req_send(req);
  2264. if (unlikely(retval))
  2265. goto failed_scsi_cmnd;
  2266. /* NOTE: DO NOT TOUCH req PAST THIS POINT! */
  2267. goto out;
  2268. failed_scsi_cmnd:
  2269. zfcp_fsf_req_free(req);
  2270. scsi_cmnd->host_scribble = NULL;
  2271. out:
  2272. spin_unlock_irqrestore(&qdio->req_q_lock, flags);
  2273. return retval;
  2274. }
  2275. static void zfcp_fsf_fcp_task_mgmt_handler(struct zfcp_fsf_req *req)
  2276. {
  2277. struct scsi_device *sdev = req->data;
  2278. struct fcp_resp_with_ext *fcp_rsp;
  2279. struct fcp_resp_rsp_info *rsp_info;
  2280. zfcp_fsf_fcp_handler_common(req, sdev);
  2281. fcp_rsp = &req->qtcb->bottom.io.fcp_rsp.iu;
  2282. rsp_info = (struct fcp_resp_rsp_info *) &fcp_rsp[1];
  2283. if ((rsp_info->rsp_code != FCP_TMF_CMPL) ||
  2284. (req->status & ZFCP_STATUS_FSFREQ_ERROR))
  2285. req->status |= ZFCP_STATUS_FSFREQ_TMFUNCFAILED;
  2286. }
  2287. /**
  2288. * zfcp_fsf_fcp_task_mgmt() - Send SCSI task management command (TMF).
  2289. * @sdev: Pointer to SCSI device to send the task management command to.
  2290. * @tm_flags: Unsigned byte for task management flags.
  2291. *
  2292. * Return: On success pointer to struct zfcp_fsf_req, %NULL otherwise.
  2293. */
  2294. struct zfcp_fsf_req *zfcp_fsf_fcp_task_mgmt(struct scsi_device *sdev,
  2295. u8 tm_flags)
  2296. {
  2297. struct zfcp_fsf_req *req = NULL;
  2298. struct fcp_cmnd *fcp_cmnd;
  2299. struct zfcp_scsi_dev *zfcp_sdev = sdev_to_zfcp(sdev);
  2300. struct zfcp_qdio *qdio = zfcp_sdev->port->adapter->qdio;
  2301. if (unlikely(!(atomic_read(&zfcp_sdev->status) &
  2302. ZFCP_STATUS_COMMON_UNBLOCKED)))
  2303. return NULL;
  2304. spin_lock_irq(&qdio->req_q_lock);
  2305. if (zfcp_qdio_sbal_get(qdio))
  2306. goto out;
  2307. req = zfcp_fsf_req_create(qdio, FSF_QTCB_FCP_CMND,
  2308. SBAL_SFLAGS0_TYPE_WRITE,
  2309. qdio->adapter->pool.scsi_req);
  2310. if (IS_ERR(req)) {
  2311. req = NULL;
  2312. goto out;
  2313. }
  2314. req->data = sdev;
  2315. req->handler = zfcp_fsf_fcp_task_mgmt_handler;
  2316. req->qtcb->header.lun_handle = zfcp_sdev->lun_handle;
  2317. req->qtcb->header.port_handle = zfcp_sdev->port->handle;
  2318. req->qtcb->bottom.io.data_direction = FSF_DATADIR_CMND;
  2319. req->qtcb->bottom.io.service_class = FSF_CLASS_3;
  2320. req->qtcb->bottom.io.fcp_cmnd_length = FCP_CMND_LEN;
  2321. zfcp_qdio_set_sbale_last(qdio, &req->qdio_req);
  2322. fcp_cmnd = &req->qtcb->bottom.io.fcp_cmnd.iu;
  2323. zfcp_fc_fcp_tm(fcp_cmnd, sdev, tm_flags);
  2324. zfcp_fsf_start_timer(req, ZFCP_FSF_SCSI_ER_TIMEOUT);
  2325. if (!zfcp_fsf_req_send(req)) {
  2326. /* NOTE: DO NOT TOUCH req, UNTIL IT COMPLETES! */
  2327. goto out;
  2328. }
  2329. zfcp_fsf_req_free(req);
  2330. req = NULL;
  2331. out:
  2332. spin_unlock_irq(&qdio->req_q_lock);
  2333. return req;
  2334. }
  2335. /**
  2336. * zfcp_fsf_reqid_check - validate req_id contained in SBAL returned by QDIO
  2337. * @qdio: pointer to struct zfcp_qdio
  2338. * @sbal_idx: response queue index of SBAL to be processed
  2339. */
  2340. void zfcp_fsf_reqid_check(struct zfcp_qdio *qdio, int sbal_idx)
  2341. {
  2342. struct zfcp_adapter *adapter = qdio->adapter;
  2343. struct qdio_buffer *sbal = qdio->res_q[sbal_idx];
  2344. struct qdio_buffer_element *sbale;
  2345. struct zfcp_fsf_req *fsf_req;
  2346. unsigned long req_id;
  2347. int idx;
  2348. for (idx = 0; idx < QDIO_MAX_ELEMENTS_PER_BUFFER; idx++) {
  2349. sbale = &sbal->element[idx];
  2350. req_id = sbale->addr;
  2351. fsf_req = zfcp_reqlist_find_rm(adapter->req_list, req_id);
  2352. if (!fsf_req) {
  2353. /*
  2354. * Unknown request means that we have potentially memory
  2355. * corruption and must stop the machine immediately.
  2356. */
  2357. zfcp_qdio_siosl(adapter);
  2358. panic("error: unknown req_id (%lx) on adapter %s.\n",
  2359. req_id, dev_name(&adapter->ccw_device->dev));
  2360. }
  2361. zfcp_fsf_req_complete(fsf_req);
  2362. if (likely(sbale->eflags & SBAL_EFLAGS_LAST_ENTRY))
  2363. break;
  2364. }
  2365. }