zfcp_erp.c 52 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771772773774775776777778779780781782783784785786787788789790791792793794795796797798799800801802803804805806807808809810811812813814815816817818819820821822823824825826827828829830831832833834835836837838839840841842843844845846847848849850851852853854855856857858859860861862863864865866867868869870871872873874875876877878879880881882883884885886887888889890891892893894895896897898899900901902903904905906907908909910911912913914915916917918919920921922923924925926927928929930931932933934935936937938939940941942943944945946947948949950951952953954955956957958959960961962963964965966967968969970971972973974975976977978979980981982983984985986987988989990991992993994995996997998999100010011002100310041005100610071008100910101011101210131014101510161017101810191020102110221023102410251026102710281029103010311032103310341035103610371038103910401041104210431044104510461047104810491050105110521053105410551056105710581059106010611062106310641065106610671068106910701071107210731074107510761077107810791080108110821083108410851086108710881089109010911092109310941095109610971098109911001101110211031104110511061107110811091110111111121113111411151116111711181119112011211122112311241125112611271128112911301131113211331134113511361137113811391140114111421143114411451146114711481149115011511152115311541155115611571158115911601161116211631164116511661167116811691170117111721173117411751176117711781179118011811182118311841185118611871188118911901191119211931194119511961197119811991200120112021203120412051206120712081209121012111212121312141215121612171218121912201221122212231224122512261227122812291230123112321233123412351236123712381239124012411242124312441245124612471248124912501251125212531254125512561257125812591260126112621263126412651266126712681269127012711272127312741275127612771278127912801281128212831284128512861287128812891290129112921293129412951296129712981299130013011302130313041305130613071308130913101311131213131314131513161317131813191320132113221323132413251326132713281329133013311332133313341335133613371338133913401341134213431344134513461347134813491350135113521353135413551356135713581359136013611362136313641365136613671368136913701371137213731374137513761377137813791380138113821383138413851386138713881389139013911392139313941395139613971398139914001401140214031404140514061407140814091410141114121413141414151416141714181419142014211422142314241425142614271428142914301431143214331434143514361437143814391440144114421443144414451446144714481449145014511452145314541455145614571458145914601461146214631464146514661467146814691470147114721473147414751476147714781479148014811482148314841485148614871488148914901491149214931494149514961497149814991500150115021503150415051506150715081509151015111512151315141515151615171518151915201521152215231524152515261527152815291530153115321533153415351536153715381539154015411542154315441545154615471548154915501551155215531554155515561557155815591560156115621563156415651566156715681569157015711572157315741575157615771578157915801581158215831584158515861587158815891590159115921593159415951596159715981599160016011602160316041605160616071608160916101611161216131614161516161617161816191620162116221623162416251626162716281629163016311632163316341635163616371638163916401641164216431644164516461647164816491650165116521653165416551656165716581659166016611662166316641665166616671668166916701671167216731674167516761677167816791680168116821683168416851686168716881689169016911692169316941695169616971698169917001701170217031704170517061707170817091710171117121713171417151716171717181719172017211722172317241725172617271728172917301731173217331734173517361737173817391740174117421743174417451746174717481749175017511752175317541755175617571758175917601761176217631764176517661767176817691770177117721773177417751776177717781779178017811782178317841785178617871788178917901791179217931794179517961797179817991800180118021803180418051806180718081809181018111812181318141815181618171818181918201821182218231824182518261827182818291830183118321833183418351836183718381839184018411842184318441845184618471848184918501851185218531854185518561857185818591860186118621863186418651866
  1. // SPDX-License-Identifier: GPL-2.0
  2. /*
  3. * zfcp device driver
  4. *
  5. * Error Recovery Procedures (ERP).
  6. *
  7. * Copyright IBM Corp. 2002, 2020
  8. */
  9. #define KMSG_COMPONENT "zfcp"
  10. #define pr_fmt(fmt) KMSG_COMPONENT ": " fmt
  11. #include <linux/kthread.h>
  12. #include <linux/bug.h>
  13. #include "zfcp_ext.h"
  14. #include "zfcp_reqlist.h"
  15. #include "zfcp_diag.h"
  16. #define ZFCP_MAX_ERPS 3
  17. enum zfcp_erp_act_flags {
  18. ZFCP_STATUS_ERP_TIMEDOUT = 0x10000000,
  19. ZFCP_STATUS_ERP_CLOSE_ONLY = 0x01000000,
  20. ZFCP_STATUS_ERP_DISMISSED = 0x00200000,
  21. ZFCP_STATUS_ERP_LOWMEM = 0x00400000,
  22. ZFCP_STATUS_ERP_NO_REF = 0x00800000,
  23. };
  24. /*
  25. * Eyecatcher pseudo flag to bitwise or-combine with enum zfcp_erp_act_type.
  26. * Used to indicate that an ERP action could not be set up despite a detected
  27. * need for some recovery.
  28. */
  29. #define ZFCP_ERP_ACTION_NONE 0xc0
  30. /*
  31. * Eyecatcher pseudo flag to bitwise or-combine with enum zfcp_erp_act_type.
  32. * Used to indicate that ERP not needed because the object has
  33. * ZFCP_STATUS_COMMON_ERP_FAILED.
  34. */
  35. #define ZFCP_ERP_ACTION_FAILED 0xe0
  36. enum zfcp_erp_act_result {
  37. ZFCP_ERP_SUCCEEDED = 0,
  38. ZFCP_ERP_FAILED = 1,
  39. ZFCP_ERP_CONTINUES = 2,
  40. ZFCP_ERP_EXIT = 3,
  41. ZFCP_ERP_DISMISSED = 4,
  42. ZFCP_ERP_NOMEM = 5,
  43. };
  44. static void zfcp_erp_adapter_block(struct zfcp_adapter *adapter, int mask)
  45. {
  46. zfcp_erp_clear_adapter_status(adapter,
  47. ZFCP_STATUS_COMMON_UNBLOCKED | mask);
  48. }
  49. static bool zfcp_erp_action_is_running(struct zfcp_erp_action *act)
  50. {
  51. struct zfcp_erp_action *curr_act;
  52. list_for_each_entry(curr_act, &act->adapter->erp_running_head, list)
  53. if (act == curr_act)
  54. return true;
  55. return false;
  56. }
  57. static void zfcp_erp_action_ready(struct zfcp_erp_action *act)
  58. {
  59. struct zfcp_adapter *adapter = act->adapter;
  60. list_move(&act->list, &adapter->erp_ready_head);
  61. zfcp_dbf_rec_run("erardy1", act);
  62. wake_up(&adapter->erp_ready_wq);
  63. zfcp_dbf_rec_run("erardy2", act);
  64. }
  65. static void zfcp_erp_action_dismiss(struct zfcp_erp_action *act)
  66. {
  67. act->status |= ZFCP_STATUS_ERP_DISMISSED;
  68. if (zfcp_erp_action_is_running(act))
  69. zfcp_erp_action_ready(act);
  70. }
  71. static void zfcp_erp_action_dismiss_lun(struct scsi_device *sdev)
  72. {
  73. struct zfcp_scsi_dev *zfcp_sdev = sdev_to_zfcp(sdev);
  74. if (atomic_read(&zfcp_sdev->status) & ZFCP_STATUS_COMMON_ERP_INUSE)
  75. zfcp_erp_action_dismiss(&zfcp_sdev->erp_action);
  76. }
  77. static void zfcp_erp_action_dismiss_port(struct zfcp_port *port)
  78. {
  79. struct scsi_device *sdev;
  80. if (atomic_read(&port->status) & ZFCP_STATUS_COMMON_ERP_INUSE)
  81. zfcp_erp_action_dismiss(&port->erp_action);
  82. else {
  83. spin_lock(port->adapter->scsi_host->host_lock);
  84. __shost_for_each_device(sdev, port->adapter->scsi_host)
  85. if (sdev_to_zfcp(sdev)->port == port)
  86. zfcp_erp_action_dismiss_lun(sdev);
  87. spin_unlock(port->adapter->scsi_host->host_lock);
  88. }
  89. }
  90. static void zfcp_erp_action_dismiss_adapter(struct zfcp_adapter *adapter)
  91. {
  92. struct zfcp_port *port;
  93. if (atomic_read(&adapter->status) & ZFCP_STATUS_COMMON_ERP_INUSE)
  94. zfcp_erp_action_dismiss(&adapter->erp_action);
  95. else {
  96. read_lock(&adapter->port_list_lock);
  97. list_for_each_entry(port, &adapter->port_list, list)
  98. zfcp_erp_action_dismiss_port(port);
  99. read_unlock(&adapter->port_list_lock);
  100. }
  101. }
  102. static enum zfcp_erp_act_type zfcp_erp_handle_failed(
  103. enum zfcp_erp_act_type want, struct zfcp_adapter *adapter,
  104. struct zfcp_port *port, struct scsi_device *sdev)
  105. {
  106. enum zfcp_erp_act_type need = want;
  107. struct zfcp_scsi_dev *zsdev;
  108. switch (want) {
  109. case ZFCP_ERP_ACTION_REOPEN_LUN:
  110. zsdev = sdev_to_zfcp(sdev);
  111. if (atomic_read(&zsdev->status) & ZFCP_STATUS_COMMON_ERP_FAILED)
  112. need = 0;
  113. break;
  114. case ZFCP_ERP_ACTION_REOPEN_PORT_FORCED:
  115. if (atomic_read(&port->status) & ZFCP_STATUS_COMMON_ERP_FAILED)
  116. need = 0;
  117. break;
  118. case ZFCP_ERP_ACTION_REOPEN_PORT:
  119. if (atomic_read(&port->status) &
  120. ZFCP_STATUS_COMMON_ERP_FAILED) {
  121. need = 0;
  122. /* ensure propagation of failed status to new devices */
  123. zfcp_erp_set_port_status(
  124. port, ZFCP_STATUS_COMMON_ERP_FAILED);
  125. }
  126. break;
  127. case ZFCP_ERP_ACTION_REOPEN_ADAPTER:
  128. if (atomic_read(&adapter->status) &
  129. ZFCP_STATUS_COMMON_ERP_FAILED) {
  130. need = 0;
  131. /* ensure propagation of failed status to new devices */
  132. zfcp_erp_set_adapter_status(
  133. adapter, ZFCP_STATUS_COMMON_ERP_FAILED);
  134. }
  135. break;
  136. }
  137. return need;
  138. }
  139. static enum zfcp_erp_act_type zfcp_erp_required_act(enum zfcp_erp_act_type want,
  140. struct zfcp_adapter *adapter,
  141. struct zfcp_port *port,
  142. struct scsi_device *sdev)
  143. {
  144. enum zfcp_erp_act_type need = want;
  145. int l_status, p_status, a_status;
  146. struct zfcp_scsi_dev *zfcp_sdev;
  147. switch (want) {
  148. case ZFCP_ERP_ACTION_REOPEN_LUN:
  149. zfcp_sdev = sdev_to_zfcp(sdev);
  150. l_status = atomic_read(&zfcp_sdev->status);
  151. if (l_status & ZFCP_STATUS_COMMON_ERP_INUSE)
  152. return 0;
  153. p_status = atomic_read(&port->status);
  154. if (!(p_status & ZFCP_STATUS_COMMON_RUNNING) ||
  155. p_status & ZFCP_STATUS_COMMON_ERP_FAILED)
  156. return 0;
  157. if (!(p_status & ZFCP_STATUS_COMMON_UNBLOCKED))
  158. need = ZFCP_ERP_ACTION_REOPEN_PORT;
  159. fallthrough;
  160. case ZFCP_ERP_ACTION_REOPEN_PORT_FORCED:
  161. p_status = atomic_read(&port->status);
  162. if (!(p_status & ZFCP_STATUS_COMMON_OPEN))
  163. need = ZFCP_ERP_ACTION_REOPEN_PORT;
  164. fallthrough;
  165. case ZFCP_ERP_ACTION_REOPEN_PORT:
  166. p_status = atomic_read(&port->status);
  167. if (p_status & ZFCP_STATUS_COMMON_ERP_INUSE)
  168. return 0;
  169. a_status = atomic_read(&adapter->status);
  170. if (!(a_status & ZFCP_STATUS_COMMON_RUNNING) ||
  171. a_status & ZFCP_STATUS_COMMON_ERP_FAILED)
  172. return 0;
  173. if (p_status & ZFCP_STATUS_COMMON_NOESC)
  174. return need;
  175. if (!(a_status & ZFCP_STATUS_COMMON_UNBLOCKED))
  176. need = ZFCP_ERP_ACTION_REOPEN_ADAPTER;
  177. fallthrough;
  178. case ZFCP_ERP_ACTION_REOPEN_ADAPTER:
  179. a_status = atomic_read(&adapter->status);
  180. if (a_status & ZFCP_STATUS_COMMON_ERP_INUSE)
  181. return 0;
  182. if (!(a_status & ZFCP_STATUS_COMMON_RUNNING) &&
  183. !(a_status & ZFCP_STATUS_COMMON_OPEN))
  184. return 0; /* shutdown requested for closed adapter */
  185. }
  186. return need;
  187. }
  188. static struct zfcp_erp_action *zfcp_erp_setup_act(enum zfcp_erp_act_type need,
  189. u32 act_status,
  190. struct zfcp_adapter *adapter,
  191. struct zfcp_port *port,
  192. struct scsi_device *sdev)
  193. {
  194. struct zfcp_erp_action *erp_action;
  195. struct zfcp_scsi_dev *zfcp_sdev;
  196. if (WARN_ON_ONCE(need != ZFCP_ERP_ACTION_REOPEN_LUN &&
  197. need != ZFCP_ERP_ACTION_REOPEN_PORT &&
  198. need != ZFCP_ERP_ACTION_REOPEN_PORT_FORCED &&
  199. need != ZFCP_ERP_ACTION_REOPEN_ADAPTER))
  200. return NULL;
  201. switch (need) {
  202. case ZFCP_ERP_ACTION_REOPEN_LUN:
  203. zfcp_sdev = sdev_to_zfcp(sdev);
  204. if (!(act_status & ZFCP_STATUS_ERP_NO_REF))
  205. if (scsi_device_get(sdev))
  206. return NULL;
  207. atomic_or(ZFCP_STATUS_COMMON_ERP_INUSE,
  208. &zfcp_sdev->status);
  209. erp_action = &zfcp_sdev->erp_action;
  210. WARN_ON_ONCE(erp_action->port != port);
  211. WARN_ON_ONCE(erp_action->sdev != sdev);
  212. if (!(atomic_read(&zfcp_sdev->status) &
  213. ZFCP_STATUS_COMMON_RUNNING))
  214. act_status |= ZFCP_STATUS_ERP_CLOSE_ONLY;
  215. break;
  216. case ZFCP_ERP_ACTION_REOPEN_PORT:
  217. case ZFCP_ERP_ACTION_REOPEN_PORT_FORCED:
  218. if (!get_device(&port->dev))
  219. return NULL;
  220. zfcp_erp_action_dismiss_port(port);
  221. atomic_or(ZFCP_STATUS_COMMON_ERP_INUSE, &port->status);
  222. erp_action = &port->erp_action;
  223. WARN_ON_ONCE(erp_action->port != port);
  224. WARN_ON_ONCE(erp_action->sdev != NULL);
  225. if (!(atomic_read(&port->status) & ZFCP_STATUS_COMMON_RUNNING))
  226. act_status |= ZFCP_STATUS_ERP_CLOSE_ONLY;
  227. break;
  228. case ZFCP_ERP_ACTION_REOPEN_ADAPTER:
  229. kref_get(&adapter->ref);
  230. zfcp_erp_action_dismiss_adapter(adapter);
  231. atomic_or(ZFCP_STATUS_COMMON_ERP_INUSE, &adapter->status);
  232. erp_action = &adapter->erp_action;
  233. WARN_ON_ONCE(erp_action->port != NULL);
  234. WARN_ON_ONCE(erp_action->sdev != NULL);
  235. if (!(atomic_read(&adapter->status) &
  236. ZFCP_STATUS_COMMON_RUNNING))
  237. act_status |= ZFCP_STATUS_ERP_CLOSE_ONLY;
  238. break;
  239. }
  240. WARN_ON_ONCE(erp_action->adapter != adapter);
  241. memset(&erp_action->list, 0, sizeof(erp_action->list));
  242. memset(&erp_action->timer, 0, sizeof(erp_action->timer));
  243. erp_action->step = ZFCP_ERP_STEP_UNINITIALIZED;
  244. erp_action->fsf_req_id = 0;
  245. erp_action->type = need;
  246. erp_action->status = act_status;
  247. return erp_action;
  248. }
  249. static void zfcp_erp_action_enqueue(enum zfcp_erp_act_type want,
  250. struct zfcp_adapter *adapter,
  251. struct zfcp_port *port,
  252. struct scsi_device *sdev,
  253. char *dbftag, u32 act_status)
  254. {
  255. enum zfcp_erp_act_type need;
  256. struct zfcp_erp_action *act;
  257. need = zfcp_erp_handle_failed(want, adapter, port, sdev);
  258. if (!need) {
  259. need = ZFCP_ERP_ACTION_FAILED; /* marker for trace */
  260. goto out;
  261. }
  262. if (!adapter->erp_thread) {
  263. need = ZFCP_ERP_ACTION_NONE; /* marker for trace */
  264. goto out;
  265. }
  266. need = zfcp_erp_required_act(want, adapter, port, sdev);
  267. if (!need)
  268. goto out;
  269. act = zfcp_erp_setup_act(need, act_status, adapter, port, sdev);
  270. if (!act) {
  271. need |= ZFCP_ERP_ACTION_NONE; /* marker for trace */
  272. goto out;
  273. }
  274. atomic_or(ZFCP_STATUS_ADAPTER_ERP_PENDING, &adapter->status);
  275. ++adapter->erp_total_count;
  276. list_add_tail(&act->list, &adapter->erp_ready_head);
  277. wake_up(&adapter->erp_ready_wq);
  278. out:
  279. zfcp_dbf_rec_trig(dbftag, adapter, port, sdev, want, need);
  280. }
  281. void zfcp_erp_port_forced_no_port_dbf(char *dbftag,
  282. struct zfcp_adapter *adapter,
  283. u64 port_name, u32 port_id)
  284. {
  285. unsigned long flags;
  286. static /* don't waste stack */ struct zfcp_port tmpport;
  287. write_lock_irqsave(&adapter->erp_lock, flags);
  288. /* Stand-in zfcp port with fields just good enough for
  289. * zfcp_dbf_rec_trig() and zfcp_dbf_set_common().
  290. * Under lock because tmpport is static.
  291. */
  292. atomic_set(&tmpport.status, -1); /* unknown */
  293. tmpport.wwpn = port_name;
  294. tmpport.d_id = port_id;
  295. zfcp_dbf_rec_trig(dbftag, adapter, &tmpport, NULL,
  296. ZFCP_ERP_ACTION_REOPEN_PORT_FORCED,
  297. ZFCP_ERP_ACTION_NONE);
  298. write_unlock_irqrestore(&adapter->erp_lock, flags);
  299. }
  300. static void _zfcp_erp_adapter_reopen(struct zfcp_adapter *adapter,
  301. int clear_mask, char *dbftag)
  302. {
  303. zfcp_erp_adapter_block(adapter, clear_mask);
  304. zfcp_scsi_schedule_rports_block(adapter);
  305. zfcp_erp_action_enqueue(ZFCP_ERP_ACTION_REOPEN_ADAPTER,
  306. adapter, NULL, NULL, dbftag, 0);
  307. }
  308. /**
  309. * zfcp_erp_adapter_reopen - Reopen adapter.
  310. * @adapter: Adapter to reopen.
  311. * @clear: Status flags to clear.
  312. * @dbftag: Tag for debug trace event.
  313. */
  314. void zfcp_erp_adapter_reopen(struct zfcp_adapter *adapter, int clear,
  315. char *dbftag)
  316. {
  317. unsigned long flags;
  318. zfcp_erp_adapter_block(adapter, clear);
  319. zfcp_scsi_schedule_rports_block(adapter);
  320. write_lock_irqsave(&adapter->erp_lock, flags);
  321. zfcp_erp_action_enqueue(ZFCP_ERP_ACTION_REOPEN_ADAPTER, adapter,
  322. NULL, NULL, dbftag, 0);
  323. write_unlock_irqrestore(&adapter->erp_lock, flags);
  324. }
  325. /**
  326. * zfcp_erp_adapter_shutdown - Shutdown adapter.
  327. * @adapter: Adapter to shut down.
  328. * @clear: Status flags to clear.
  329. * @dbftag: Tag for debug trace event.
  330. */
  331. void zfcp_erp_adapter_shutdown(struct zfcp_adapter *adapter, int clear,
  332. char *dbftag)
  333. {
  334. int flags = ZFCP_STATUS_COMMON_RUNNING | ZFCP_STATUS_COMMON_ERP_FAILED;
  335. zfcp_erp_adapter_reopen(adapter, clear | flags, dbftag);
  336. }
  337. /**
  338. * zfcp_erp_port_shutdown - Shutdown port
  339. * @port: Port to shut down.
  340. * @clear: Status flags to clear.
  341. * @dbftag: Tag for debug trace event.
  342. */
  343. void zfcp_erp_port_shutdown(struct zfcp_port *port, int clear, char *dbftag)
  344. {
  345. int flags = ZFCP_STATUS_COMMON_RUNNING | ZFCP_STATUS_COMMON_ERP_FAILED;
  346. zfcp_erp_port_reopen(port, clear | flags, dbftag);
  347. }
  348. static void zfcp_erp_port_block(struct zfcp_port *port, int clear)
  349. {
  350. zfcp_erp_clear_port_status(port,
  351. ZFCP_STATUS_COMMON_UNBLOCKED | clear);
  352. }
  353. static void _zfcp_erp_port_forced_reopen(struct zfcp_port *port, int clear,
  354. char *dbftag)
  355. {
  356. zfcp_erp_port_block(port, clear);
  357. zfcp_scsi_schedule_rport_block(port);
  358. zfcp_erp_action_enqueue(ZFCP_ERP_ACTION_REOPEN_PORT_FORCED,
  359. port->adapter, port, NULL, dbftag, 0);
  360. }
  361. /**
  362. * zfcp_erp_port_forced_reopen - Forced close of port and open again
  363. * @port: Port to force close and to reopen.
  364. * @clear: Status flags to clear.
  365. * @dbftag: Tag for debug trace event.
  366. */
  367. void zfcp_erp_port_forced_reopen(struct zfcp_port *port, int clear,
  368. char *dbftag)
  369. {
  370. unsigned long flags;
  371. struct zfcp_adapter *adapter = port->adapter;
  372. write_lock_irqsave(&adapter->erp_lock, flags);
  373. _zfcp_erp_port_forced_reopen(port, clear, dbftag);
  374. write_unlock_irqrestore(&adapter->erp_lock, flags);
  375. }
  376. static void _zfcp_erp_port_reopen(struct zfcp_port *port, int clear,
  377. char *dbftag)
  378. {
  379. zfcp_erp_port_block(port, clear);
  380. zfcp_scsi_schedule_rport_block(port);
  381. zfcp_erp_action_enqueue(ZFCP_ERP_ACTION_REOPEN_PORT,
  382. port->adapter, port, NULL, dbftag, 0);
  383. }
  384. /**
  385. * zfcp_erp_port_reopen - trigger remote port recovery
  386. * @port: port to recover
  387. * @clear: flags in port status to be cleared
  388. * @dbftag: Tag for debug trace event.
  389. */
  390. void zfcp_erp_port_reopen(struct zfcp_port *port, int clear, char *dbftag)
  391. {
  392. unsigned long flags;
  393. struct zfcp_adapter *adapter = port->adapter;
  394. write_lock_irqsave(&adapter->erp_lock, flags);
  395. _zfcp_erp_port_reopen(port, clear, dbftag);
  396. write_unlock_irqrestore(&adapter->erp_lock, flags);
  397. }
  398. static void zfcp_erp_lun_block(struct scsi_device *sdev, int clear_mask)
  399. {
  400. zfcp_erp_clear_lun_status(sdev,
  401. ZFCP_STATUS_COMMON_UNBLOCKED | clear_mask);
  402. }
  403. static void _zfcp_erp_lun_reopen(struct scsi_device *sdev, int clear,
  404. char *dbftag, u32 act_status)
  405. {
  406. struct zfcp_scsi_dev *zfcp_sdev = sdev_to_zfcp(sdev);
  407. struct zfcp_adapter *adapter = zfcp_sdev->port->adapter;
  408. zfcp_erp_lun_block(sdev, clear);
  409. zfcp_erp_action_enqueue(ZFCP_ERP_ACTION_REOPEN_LUN, adapter,
  410. zfcp_sdev->port, sdev, dbftag, act_status);
  411. }
  412. /**
  413. * zfcp_erp_lun_reopen - initiate reopen of a LUN
  414. * @sdev: SCSI device / LUN to be reopened
  415. * @clear: specifies flags in LUN status to be cleared
  416. * @dbftag: Tag for debug trace event.
  417. *
  418. * Return: 0 on success, < 0 on error
  419. */
  420. void zfcp_erp_lun_reopen(struct scsi_device *sdev, int clear, char *dbftag)
  421. {
  422. unsigned long flags;
  423. struct zfcp_scsi_dev *zfcp_sdev = sdev_to_zfcp(sdev);
  424. struct zfcp_port *port = zfcp_sdev->port;
  425. struct zfcp_adapter *adapter = port->adapter;
  426. write_lock_irqsave(&adapter->erp_lock, flags);
  427. _zfcp_erp_lun_reopen(sdev, clear, dbftag, 0);
  428. write_unlock_irqrestore(&adapter->erp_lock, flags);
  429. }
  430. /**
  431. * zfcp_erp_lun_shutdown - Shutdown LUN
  432. * @sdev: SCSI device / LUN to shut down.
  433. * @clear: Status flags to clear.
  434. * @dbftag: Tag for debug trace event.
  435. */
  436. void zfcp_erp_lun_shutdown(struct scsi_device *sdev, int clear, char *dbftag)
  437. {
  438. int flags = ZFCP_STATUS_COMMON_RUNNING | ZFCP_STATUS_COMMON_ERP_FAILED;
  439. zfcp_erp_lun_reopen(sdev, clear | flags, dbftag);
  440. }
  441. /**
  442. * zfcp_erp_lun_shutdown_wait - Shutdown LUN and wait for erp completion
  443. * @sdev: SCSI device / LUN to shut down.
  444. * @dbftag: Tag for debug trace event.
  445. *
  446. * Do not acquire a reference for the LUN when creating the ERP
  447. * action. It is safe, because this function waits for the ERP to
  448. * complete first. This allows to shutdown the LUN, even when the SCSI
  449. * device is in the state SDEV_DEL when scsi_device_get will fail.
  450. */
  451. void zfcp_erp_lun_shutdown_wait(struct scsi_device *sdev, char *dbftag)
  452. {
  453. unsigned long flags;
  454. struct zfcp_scsi_dev *zfcp_sdev = sdev_to_zfcp(sdev);
  455. struct zfcp_port *port = zfcp_sdev->port;
  456. struct zfcp_adapter *adapter = port->adapter;
  457. int clear = ZFCP_STATUS_COMMON_RUNNING | ZFCP_STATUS_COMMON_ERP_FAILED;
  458. write_lock_irqsave(&adapter->erp_lock, flags);
  459. _zfcp_erp_lun_reopen(sdev, clear, dbftag, ZFCP_STATUS_ERP_NO_REF);
  460. write_unlock_irqrestore(&adapter->erp_lock, flags);
  461. zfcp_erp_wait(adapter);
  462. }
  463. static int zfcp_erp_status_change_set(unsigned long mask, atomic_t *status)
  464. {
  465. return (atomic_read(status) ^ mask) & mask;
  466. }
  467. static void zfcp_erp_adapter_unblock(struct zfcp_adapter *adapter)
  468. {
  469. if (zfcp_erp_status_change_set(ZFCP_STATUS_COMMON_UNBLOCKED,
  470. &adapter->status))
  471. zfcp_dbf_rec_run("eraubl1", &adapter->erp_action);
  472. atomic_or(ZFCP_STATUS_COMMON_UNBLOCKED, &adapter->status);
  473. }
  474. static void zfcp_erp_port_unblock(struct zfcp_port *port)
  475. {
  476. if (zfcp_erp_status_change_set(ZFCP_STATUS_COMMON_UNBLOCKED,
  477. &port->status))
  478. zfcp_dbf_rec_run("erpubl1", &port->erp_action);
  479. atomic_or(ZFCP_STATUS_COMMON_UNBLOCKED, &port->status);
  480. }
  481. static void zfcp_erp_lun_unblock(struct scsi_device *sdev)
  482. {
  483. struct zfcp_scsi_dev *zfcp_sdev = sdev_to_zfcp(sdev);
  484. if (zfcp_erp_status_change_set(ZFCP_STATUS_COMMON_UNBLOCKED,
  485. &zfcp_sdev->status))
  486. zfcp_dbf_rec_run("erlubl1", &sdev_to_zfcp(sdev)->erp_action);
  487. atomic_or(ZFCP_STATUS_COMMON_UNBLOCKED, &zfcp_sdev->status);
  488. }
  489. static void zfcp_erp_action_to_running(struct zfcp_erp_action *erp_action)
  490. {
  491. list_move(&erp_action->list, &erp_action->adapter->erp_running_head);
  492. zfcp_dbf_rec_run("erator1", erp_action);
  493. }
  494. static void zfcp_erp_strategy_check_fsfreq(struct zfcp_erp_action *act)
  495. {
  496. struct zfcp_adapter *adapter = act->adapter;
  497. struct zfcp_fsf_req *req;
  498. if (!act->fsf_req_id)
  499. return;
  500. spin_lock(&adapter->req_list->lock);
  501. req = _zfcp_reqlist_find(adapter->req_list, act->fsf_req_id);
  502. if (req && req->erp_action == act) {
  503. if (act->status & (ZFCP_STATUS_ERP_DISMISSED |
  504. ZFCP_STATUS_ERP_TIMEDOUT)) {
  505. req->status |= ZFCP_STATUS_FSFREQ_DISMISSED;
  506. zfcp_dbf_rec_run("erscf_1", act);
  507. /* lock-free concurrent access with
  508. * zfcp_erp_timeout_handler()
  509. */
  510. WRITE_ONCE(req->erp_action, NULL);
  511. }
  512. if (act->status & ZFCP_STATUS_ERP_TIMEDOUT)
  513. zfcp_dbf_rec_run("erscf_2", act);
  514. if (req->status & ZFCP_STATUS_FSFREQ_DISMISSED)
  515. act->fsf_req_id = 0;
  516. } else
  517. act->fsf_req_id = 0;
  518. spin_unlock(&adapter->req_list->lock);
  519. }
  520. /**
  521. * zfcp_erp_notify - Trigger ERP action.
  522. * @erp_action: ERP action to continue.
  523. * @set_mask: ERP action status flags to set.
  524. */
  525. void zfcp_erp_notify(struct zfcp_erp_action *erp_action, unsigned long set_mask)
  526. {
  527. struct zfcp_adapter *adapter = erp_action->adapter;
  528. unsigned long flags;
  529. write_lock_irqsave(&adapter->erp_lock, flags);
  530. if (zfcp_erp_action_is_running(erp_action)) {
  531. erp_action->status |= set_mask;
  532. zfcp_erp_action_ready(erp_action);
  533. }
  534. write_unlock_irqrestore(&adapter->erp_lock, flags);
  535. }
  536. /**
  537. * zfcp_erp_timeout_handler - Trigger ERP action from timed out ERP request
  538. * @t: timer list entry embedded in zfcp FSF request
  539. */
  540. void zfcp_erp_timeout_handler(struct timer_list *t)
  541. {
  542. struct zfcp_fsf_req *fsf_req = from_timer(fsf_req, t, timer);
  543. struct zfcp_erp_action *act;
  544. if (fsf_req->status & ZFCP_STATUS_FSFREQ_DISMISSED)
  545. return;
  546. /* lock-free concurrent access with zfcp_erp_strategy_check_fsfreq() */
  547. act = READ_ONCE(fsf_req->erp_action);
  548. if (!act)
  549. return;
  550. zfcp_erp_notify(act, ZFCP_STATUS_ERP_TIMEDOUT);
  551. }
  552. static void zfcp_erp_memwait_handler(struct timer_list *t)
  553. {
  554. struct zfcp_erp_action *act = from_timer(act, t, timer);
  555. zfcp_erp_notify(act, 0);
  556. }
  557. static void zfcp_erp_strategy_memwait(struct zfcp_erp_action *erp_action)
  558. {
  559. timer_setup(&erp_action->timer, zfcp_erp_memwait_handler, 0);
  560. erp_action->timer.expires = jiffies + HZ;
  561. add_timer(&erp_action->timer);
  562. }
  563. void zfcp_erp_port_forced_reopen_all(struct zfcp_adapter *adapter,
  564. int clear, char *dbftag)
  565. {
  566. unsigned long flags;
  567. struct zfcp_port *port;
  568. write_lock_irqsave(&adapter->erp_lock, flags);
  569. read_lock(&adapter->port_list_lock);
  570. list_for_each_entry(port, &adapter->port_list, list)
  571. _zfcp_erp_port_forced_reopen(port, clear, dbftag);
  572. read_unlock(&adapter->port_list_lock);
  573. write_unlock_irqrestore(&adapter->erp_lock, flags);
  574. }
  575. static void _zfcp_erp_port_reopen_all(struct zfcp_adapter *adapter,
  576. int clear, char *dbftag)
  577. {
  578. struct zfcp_port *port;
  579. read_lock(&adapter->port_list_lock);
  580. list_for_each_entry(port, &adapter->port_list, list)
  581. _zfcp_erp_port_reopen(port, clear, dbftag);
  582. read_unlock(&adapter->port_list_lock);
  583. }
  584. static void _zfcp_erp_lun_reopen_all(struct zfcp_port *port, int clear,
  585. char *dbftag)
  586. {
  587. struct scsi_device *sdev;
  588. spin_lock(port->adapter->scsi_host->host_lock);
  589. __shost_for_each_device(sdev, port->adapter->scsi_host)
  590. if (sdev_to_zfcp(sdev)->port == port)
  591. _zfcp_erp_lun_reopen(sdev, clear, dbftag, 0);
  592. spin_unlock(port->adapter->scsi_host->host_lock);
  593. }
  594. static void zfcp_erp_strategy_followup_failed(struct zfcp_erp_action *act)
  595. {
  596. switch (act->type) {
  597. case ZFCP_ERP_ACTION_REOPEN_ADAPTER:
  598. _zfcp_erp_adapter_reopen(act->adapter, 0, "ersff_1");
  599. break;
  600. case ZFCP_ERP_ACTION_REOPEN_PORT_FORCED:
  601. _zfcp_erp_port_forced_reopen(act->port, 0, "ersff_2");
  602. break;
  603. case ZFCP_ERP_ACTION_REOPEN_PORT:
  604. _zfcp_erp_port_reopen(act->port, 0, "ersff_3");
  605. break;
  606. case ZFCP_ERP_ACTION_REOPEN_LUN:
  607. _zfcp_erp_lun_reopen(act->sdev, 0, "ersff_4", 0);
  608. break;
  609. }
  610. }
  611. static void zfcp_erp_strategy_followup_success(struct zfcp_erp_action *act)
  612. {
  613. switch (act->type) {
  614. case ZFCP_ERP_ACTION_REOPEN_ADAPTER:
  615. _zfcp_erp_port_reopen_all(act->adapter, 0, "ersfs_1");
  616. break;
  617. case ZFCP_ERP_ACTION_REOPEN_PORT_FORCED:
  618. _zfcp_erp_port_reopen(act->port, 0, "ersfs_2");
  619. break;
  620. case ZFCP_ERP_ACTION_REOPEN_PORT:
  621. _zfcp_erp_lun_reopen_all(act->port, 0, "ersfs_3");
  622. break;
  623. case ZFCP_ERP_ACTION_REOPEN_LUN:
  624. /* NOP */
  625. break;
  626. }
  627. }
  628. static void zfcp_erp_wakeup(struct zfcp_adapter *adapter)
  629. {
  630. unsigned long flags;
  631. read_lock_irqsave(&adapter->erp_lock, flags);
  632. if (list_empty(&adapter->erp_ready_head) &&
  633. list_empty(&adapter->erp_running_head)) {
  634. atomic_andnot(ZFCP_STATUS_ADAPTER_ERP_PENDING,
  635. &adapter->status);
  636. wake_up(&adapter->erp_done_wqh);
  637. }
  638. read_unlock_irqrestore(&adapter->erp_lock, flags);
  639. }
  640. static void zfcp_erp_enqueue_ptp_port(struct zfcp_adapter *adapter)
  641. {
  642. struct zfcp_port *port;
  643. port = zfcp_port_enqueue(adapter, adapter->peer_wwpn, 0,
  644. adapter->peer_d_id);
  645. if (IS_ERR(port)) /* error or port already attached */
  646. return;
  647. zfcp_erp_port_reopen(port, 0, "ereptp1");
  648. }
  649. static enum zfcp_erp_act_result zfcp_erp_adapter_strat_fsf_xconf(
  650. struct zfcp_erp_action *erp_action)
  651. {
  652. int retries;
  653. int sleep = 1;
  654. struct zfcp_adapter *adapter = erp_action->adapter;
  655. atomic_andnot(ZFCP_STATUS_ADAPTER_XCONFIG_OK, &adapter->status);
  656. for (retries = 7; retries; retries--) {
  657. atomic_andnot(ZFCP_STATUS_ADAPTER_HOST_CON_INIT,
  658. &adapter->status);
  659. write_lock_irq(&adapter->erp_lock);
  660. zfcp_erp_action_to_running(erp_action);
  661. write_unlock_irq(&adapter->erp_lock);
  662. if (zfcp_fsf_exchange_config_data(erp_action)) {
  663. atomic_andnot(ZFCP_STATUS_ADAPTER_HOST_CON_INIT,
  664. &adapter->status);
  665. return ZFCP_ERP_FAILED;
  666. }
  667. wait_event(adapter->erp_ready_wq,
  668. !list_empty(&adapter->erp_ready_head));
  669. if (erp_action->status & ZFCP_STATUS_ERP_TIMEDOUT)
  670. break;
  671. if (!(atomic_read(&adapter->status) &
  672. ZFCP_STATUS_ADAPTER_HOST_CON_INIT))
  673. break;
  674. ssleep(sleep);
  675. sleep *= 2;
  676. }
  677. atomic_andnot(ZFCP_STATUS_ADAPTER_HOST_CON_INIT,
  678. &adapter->status);
  679. if (!(atomic_read(&adapter->status) & ZFCP_STATUS_ADAPTER_XCONFIG_OK))
  680. return ZFCP_ERP_FAILED;
  681. return ZFCP_ERP_SUCCEEDED;
  682. }
  683. static void
  684. zfcp_erp_adapter_strategy_open_ptp_port(struct zfcp_adapter *const adapter)
  685. {
  686. if (fc_host_port_type(adapter->scsi_host) == FC_PORTTYPE_PTP)
  687. zfcp_erp_enqueue_ptp_port(adapter);
  688. }
  689. static enum zfcp_erp_act_result zfcp_erp_adapter_strategy_open_fsf_xport(
  690. struct zfcp_erp_action *act)
  691. {
  692. int ret;
  693. struct zfcp_adapter *adapter = act->adapter;
  694. write_lock_irq(&adapter->erp_lock);
  695. zfcp_erp_action_to_running(act);
  696. write_unlock_irq(&adapter->erp_lock);
  697. ret = zfcp_fsf_exchange_port_data(act);
  698. if (ret == -EOPNOTSUPP)
  699. return ZFCP_ERP_SUCCEEDED;
  700. if (ret)
  701. return ZFCP_ERP_FAILED;
  702. zfcp_dbf_rec_run("erasox1", act);
  703. wait_event(adapter->erp_ready_wq,
  704. !list_empty(&adapter->erp_ready_head));
  705. zfcp_dbf_rec_run("erasox2", act);
  706. if (act->status & ZFCP_STATUS_ERP_TIMEDOUT)
  707. return ZFCP_ERP_FAILED;
  708. return ZFCP_ERP_SUCCEEDED;
  709. }
  710. static enum zfcp_erp_act_result
  711. zfcp_erp_adapter_strategy_alloc_shost(struct zfcp_adapter *const adapter)
  712. {
  713. struct zfcp_diag_adapter_config_data *const config_data =
  714. &adapter->diagnostics->config_data;
  715. struct zfcp_diag_adapter_port_data *const port_data =
  716. &adapter->diagnostics->port_data;
  717. unsigned long flags;
  718. int rc;
  719. rc = zfcp_scsi_adapter_register(adapter);
  720. if (rc == -EEXIST)
  721. return ZFCP_ERP_SUCCEEDED;
  722. else if (rc)
  723. return ZFCP_ERP_FAILED;
  724. /*
  725. * We allocated the shost for the first time. Before it was NULL,
  726. * and so we deferred all updates in the xconf- and xport-data
  727. * handlers. We need to make up for that now, and make all the updates
  728. * that would have been done before.
  729. *
  730. * We can be sure that xconf- and xport-data succeeded, because
  731. * otherwise this function is not called. But they might have been
  732. * incomplete.
  733. */
  734. spin_lock_irqsave(&config_data->header.access_lock, flags);
  735. zfcp_scsi_shost_update_config_data(adapter, &config_data->data,
  736. !!config_data->header.incomplete);
  737. spin_unlock_irqrestore(&config_data->header.access_lock, flags);
  738. if (adapter->adapter_features & FSF_FEATURE_HBAAPI_MANAGEMENT) {
  739. spin_lock_irqsave(&port_data->header.access_lock, flags);
  740. zfcp_scsi_shost_update_port_data(adapter, &port_data->data);
  741. spin_unlock_irqrestore(&port_data->header.access_lock, flags);
  742. }
  743. /*
  744. * There is a remote possibility that the 'Exchange Port Data' request
  745. * reports a different connectivity status than 'Exchange Config Data'.
  746. * But any change to the connectivity status of the local optic that
  747. * happens after the initial xconf request is expected to be reported
  748. * to us, as soon as we post Status Read Buffers to the FCP channel
  749. * firmware after this function. So any resulting inconsistency will
  750. * only be momentary.
  751. */
  752. if (config_data->header.incomplete)
  753. zfcp_fsf_fc_host_link_down(adapter);
  754. return ZFCP_ERP_SUCCEEDED;
  755. }
  756. static enum zfcp_erp_act_result zfcp_erp_adapter_strategy_open_fsf(
  757. struct zfcp_erp_action *act)
  758. {
  759. if (zfcp_erp_adapter_strat_fsf_xconf(act) == ZFCP_ERP_FAILED)
  760. return ZFCP_ERP_FAILED;
  761. if (zfcp_erp_adapter_strategy_open_fsf_xport(act) == ZFCP_ERP_FAILED)
  762. return ZFCP_ERP_FAILED;
  763. if (zfcp_erp_adapter_strategy_alloc_shost(act->adapter) ==
  764. ZFCP_ERP_FAILED)
  765. return ZFCP_ERP_FAILED;
  766. zfcp_erp_adapter_strategy_open_ptp_port(act->adapter);
  767. if (mempool_resize(act->adapter->pool.sr_data,
  768. act->adapter->stat_read_buf_num))
  769. return ZFCP_ERP_FAILED;
  770. if (mempool_resize(act->adapter->pool.status_read_req,
  771. act->adapter->stat_read_buf_num))
  772. return ZFCP_ERP_FAILED;
  773. atomic_set(&act->adapter->stat_miss, act->adapter->stat_read_buf_num);
  774. if (zfcp_status_read_refill(act->adapter))
  775. return ZFCP_ERP_FAILED;
  776. return ZFCP_ERP_SUCCEEDED;
  777. }
  778. static void zfcp_erp_adapter_strategy_close(struct zfcp_erp_action *act)
  779. {
  780. struct zfcp_adapter *adapter = act->adapter;
  781. /* close queues to ensure that buffers are not accessed by adapter */
  782. zfcp_qdio_close(adapter->qdio);
  783. zfcp_fsf_req_dismiss_all(adapter);
  784. adapter->fsf_req_seq_no = 0;
  785. zfcp_fc_wka_ports_force_offline(adapter->gs);
  786. /* all ports and LUNs are closed */
  787. zfcp_erp_clear_adapter_status(adapter, ZFCP_STATUS_COMMON_OPEN);
  788. atomic_andnot(ZFCP_STATUS_ADAPTER_XCONFIG_OK |
  789. ZFCP_STATUS_ADAPTER_LINK_UNPLUGGED, &adapter->status);
  790. }
  791. static enum zfcp_erp_act_result zfcp_erp_adapter_strategy_open(
  792. struct zfcp_erp_action *act)
  793. {
  794. struct zfcp_adapter *adapter = act->adapter;
  795. if (zfcp_qdio_open(adapter->qdio)) {
  796. atomic_andnot(ZFCP_STATUS_ADAPTER_XCONFIG_OK |
  797. ZFCP_STATUS_ADAPTER_LINK_UNPLUGGED,
  798. &adapter->status);
  799. return ZFCP_ERP_FAILED;
  800. }
  801. if (zfcp_erp_adapter_strategy_open_fsf(act)) {
  802. zfcp_erp_adapter_strategy_close(act);
  803. return ZFCP_ERP_FAILED;
  804. }
  805. atomic_or(ZFCP_STATUS_COMMON_OPEN, &adapter->status);
  806. return ZFCP_ERP_SUCCEEDED;
  807. }
  808. static enum zfcp_erp_act_result zfcp_erp_adapter_strategy(
  809. struct zfcp_erp_action *act)
  810. {
  811. struct zfcp_adapter *adapter = act->adapter;
  812. if (atomic_read(&adapter->status) & ZFCP_STATUS_COMMON_OPEN) {
  813. zfcp_erp_adapter_strategy_close(act);
  814. if (act->status & ZFCP_STATUS_ERP_CLOSE_ONLY)
  815. return ZFCP_ERP_EXIT;
  816. }
  817. if (zfcp_erp_adapter_strategy_open(act)) {
  818. ssleep(8);
  819. return ZFCP_ERP_FAILED;
  820. }
  821. return ZFCP_ERP_SUCCEEDED;
  822. }
  823. static enum zfcp_erp_act_result zfcp_erp_port_forced_strategy_close(
  824. struct zfcp_erp_action *act)
  825. {
  826. int retval;
  827. retval = zfcp_fsf_close_physical_port(act);
  828. if (retval == -ENOMEM)
  829. return ZFCP_ERP_NOMEM;
  830. act->step = ZFCP_ERP_STEP_PHYS_PORT_CLOSING;
  831. if (retval)
  832. return ZFCP_ERP_FAILED;
  833. return ZFCP_ERP_CONTINUES;
  834. }
  835. static enum zfcp_erp_act_result zfcp_erp_port_forced_strategy(
  836. struct zfcp_erp_action *erp_action)
  837. {
  838. struct zfcp_port *port = erp_action->port;
  839. int status = atomic_read(&port->status);
  840. switch (erp_action->step) {
  841. case ZFCP_ERP_STEP_UNINITIALIZED:
  842. if ((status & ZFCP_STATUS_PORT_PHYS_OPEN) &&
  843. (status & ZFCP_STATUS_COMMON_OPEN))
  844. return zfcp_erp_port_forced_strategy_close(erp_action);
  845. else
  846. return ZFCP_ERP_FAILED;
  847. case ZFCP_ERP_STEP_PHYS_PORT_CLOSING:
  848. if (!(status & ZFCP_STATUS_PORT_PHYS_OPEN))
  849. return ZFCP_ERP_SUCCEEDED;
  850. break;
  851. case ZFCP_ERP_STEP_PORT_CLOSING:
  852. case ZFCP_ERP_STEP_PORT_OPENING:
  853. case ZFCP_ERP_STEP_LUN_CLOSING:
  854. case ZFCP_ERP_STEP_LUN_OPENING:
  855. /* NOP */
  856. break;
  857. }
  858. return ZFCP_ERP_FAILED;
  859. }
  860. static enum zfcp_erp_act_result zfcp_erp_port_strategy_close(
  861. struct zfcp_erp_action *erp_action)
  862. {
  863. int retval;
  864. retval = zfcp_fsf_close_port(erp_action);
  865. if (retval == -ENOMEM)
  866. return ZFCP_ERP_NOMEM;
  867. erp_action->step = ZFCP_ERP_STEP_PORT_CLOSING;
  868. if (retval)
  869. return ZFCP_ERP_FAILED;
  870. return ZFCP_ERP_CONTINUES;
  871. }
  872. static enum zfcp_erp_act_result zfcp_erp_port_strategy_open_port(
  873. struct zfcp_erp_action *erp_action)
  874. {
  875. int retval;
  876. retval = zfcp_fsf_open_port(erp_action);
  877. if (retval == -ENOMEM)
  878. return ZFCP_ERP_NOMEM;
  879. erp_action->step = ZFCP_ERP_STEP_PORT_OPENING;
  880. if (retval)
  881. return ZFCP_ERP_FAILED;
  882. return ZFCP_ERP_CONTINUES;
  883. }
  884. static int zfcp_erp_open_ptp_port(struct zfcp_erp_action *act)
  885. {
  886. struct zfcp_adapter *adapter = act->adapter;
  887. struct zfcp_port *port = act->port;
  888. if (port->wwpn != adapter->peer_wwpn) {
  889. zfcp_erp_set_port_status(port, ZFCP_STATUS_COMMON_ERP_FAILED);
  890. return ZFCP_ERP_FAILED;
  891. }
  892. port->d_id = adapter->peer_d_id;
  893. return zfcp_erp_port_strategy_open_port(act);
  894. }
  895. static enum zfcp_erp_act_result zfcp_erp_port_strategy_open_common(
  896. struct zfcp_erp_action *act)
  897. {
  898. struct zfcp_adapter *adapter = act->adapter;
  899. struct zfcp_port *port = act->port;
  900. int p_status = atomic_read(&port->status);
  901. switch (act->step) {
  902. case ZFCP_ERP_STEP_UNINITIALIZED:
  903. case ZFCP_ERP_STEP_PHYS_PORT_CLOSING:
  904. case ZFCP_ERP_STEP_PORT_CLOSING:
  905. if (fc_host_port_type(adapter->scsi_host) == FC_PORTTYPE_PTP)
  906. return zfcp_erp_open_ptp_port(act);
  907. if (!port->d_id) {
  908. zfcp_fc_trigger_did_lookup(port);
  909. return ZFCP_ERP_EXIT;
  910. }
  911. return zfcp_erp_port_strategy_open_port(act);
  912. case ZFCP_ERP_STEP_PORT_OPENING:
  913. /* D_ID might have changed during open */
  914. if (p_status & ZFCP_STATUS_COMMON_OPEN) {
  915. if (!port->d_id) {
  916. zfcp_fc_trigger_did_lookup(port);
  917. return ZFCP_ERP_EXIT;
  918. }
  919. return ZFCP_ERP_SUCCEEDED;
  920. }
  921. if (port->d_id && !(p_status & ZFCP_STATUS_COMMON_NOESC)) {
  922. port->d_id = 0;
  923. return ZFCP_ERP_FAILED;
  924. }
  925. /* no early return otherwise, continue after switch case */
  926. break;
  927. case ZFCP_ERP_STEP_LUN_CLOSING:
  928. case ZFCP_ERP_STEP_LUN_OPENING:
  929. /* NOP */
  930. break;
  931. }
  932. return ZFCP_ERP_FAILED;
  933. }
  934. static enum zfcp_erp_act_result zfcp_erp_port_strategy(
  935. struct zfcp_erp_action *erp_action)
  936. {
  937. struct zfcp_port *port = erp_action->port;
  938. int p_status = atomic_read(&port->status);
  939. if ((p_status & ZFCP_STATUS_COMMON_NOESC) &&
  940. !(p_status & ZFCP_STATUS_COMMON_OPEN))
  941. goto close_init_done;
  942. switch (erp_action->step) {
  943. case ZFCP_ERP_STEP_UNINITIALIZED:
  944. if (p_status & ZFCP_STATUS_COMMON_OPEN)
  945. return zfcp_erp_port_strategy_close(erp_action);
  946. break;
  947. case ZFCP_ERP_STEP_PORT_CLOSING:
  948. if (p_status & ZFCP_STATUS_COMMON_OPEN)
  949. return ZFCP_ERP_FAILED;
  950. break;
  951. case ZFCP_ERP_STEP_PHYS_PORT_CLOSING:
  952. case ZFCP_ERP_STEP_PORT_OPENING:
  953. case ZFCP_ERP_STEP_LUN_CLOSING:
  954. case ZFCP_ERP_STEP_LUN_OPENING:
  955. /* NOP */
  956. break;
  957. }
  958. close_init_done:
  959. if (erp_action->status & ZFCP_STATUS_ERP_CLOSE_ONLY)
  960. return ZFCP_ERP_EXIT;
  961. return zfcp_erp_port_strategy_open_common(erp_action);
  962. }
  963. static void zfcp_erp_lun_strategy_clearstati(struct scsi_device *sdev)
  964. {
  965. struct zfcp_scsi_dev *zfcp_sdev = sdev_to_zfcp(sdev);
  966. atomic_andnot(ZFCP_STATUS_COMMON_ACCESS_DENIED,
  967. &zfcp_sdev->status);
  968. }
  969. static enum zfcp_erp_act_result zfcp_erp_lun_strategy_close(
  970. struct zfcp_erp_action *erp_action)
  971. {
  972. int retval = zfcp_fsf_close_lun(erp_action);
  973. if (retval == -ENOMEM)
  974. return ZFCP_ERP_NOMEM;
  975. erp_action->step = ZFCP_ERP_STEP_LUN_CLOSING;
  976. if (retval)
  977. return ZFCP_ERP_FAILED;
  978. return ZFCP_ERP_CONTINUES;
  979. }
  980. static enum zfcp_erp_act_result zfcp_erp_lun_strategy_open(
  981. struct zfcp_erp_action *erp_action)
  982. {
  983. int retval = zfcp_fsf_open_lun(erp_action);
  984. if (retval == -ENOMEM)
  985. return ZFCP_ERP_NOMEM;
  986. erp_action->step = ZFCP_ERP_STEP_LUN_OPENING;
  987. if (retval)
  988. return ZFCP_ERP_FAILED;
  989. return ZFCP_ERP_CONTINUES;
  990. }
  991. static enum zfcp_erp_act_result zfcp_erp_lun_strategy(
  992. struct zfcp_erp_action *erp_action)
  993. {
  994. struct scsi_device *sdev = erp_action->sdev;
  995. struct zfcp_scsi_dev *zfcp_sdev = sdev_to_zfcp(sdev);
  996. switch (erp_action->step) {
  997. case ZFCP_ERP_STEP_UNINITIALIZED:
  998. zfcp_erp_lun_strategy_clearstati(sdev);
  999. if (atomic_read(&zfcp_sdev->status) & ZFCP_STATUS_COMMON_OPEN)
  1000. return zfcp_erp_lun_strategy_close(erp_action);
  1001. /* already closed */
  1002. fallthrough;
  1003. case ZFCP_ERP_STEP_LUN_CLOSING:
  1004. if (atomic_read(&zfcp_sdev->status) & ZFCP_STATUS_COMMON_OPEN)
  1005. return ZFCP_ERP_FAILED;
  1006. if (erp_action->status & ZFCP_STATUS_ERP_CLOSE_ONLY)
  1007. return ZFCP_ERP_EXIT;
  1008. return zfcp_erp_lun_strategy_open(erp_action);
  1009. case ZFCP_ERP_STEP_LUN_OPENING:
  1010. if (atomic_read(&zfcp_sdev->status) & ZFCP_STATUS_COMMON_OPEN)
  1011. return ZFCP_ERP_SUCCEEDED;
  1012. break;
  1013. case ZFCP_ERP_STEP_PHYS_PORT_CLOSING:
  1014. case ZFCP_ERP_STEP_PORT_CLOSING:
  1015. case ZFCP_ERP_STEP_PORT_OPENING:
  1016. /* NOP */
  1017. break;
  1018. }
  1019. return ZFCP_ERP_FAILED;
  1020. }
  1021. static enum zfcp_erp_act_result zfcp_erp_strategy_check_lun(
  1022. struct scsi_device *sdev, enum zfcp_erp_act_result result)
  1023. {
  1024. struct zfcp_scsi_dev *zfcp_sdev = sdev_to_zfcp(sdev);
  1025. switch (result) {
  1026. case ZFCP_ERP_SUCCEEDED :
  1027. atomic_set(&zfcp_sdev->erp_counter, 0);
  1028. zfcp_erp_lun_unblock(sdev);
  1029. break;
  1030. case ZFCP_ERP_FAILED :
  1031. atomic_inc(&zfcp_sdev->erp_counter);
  1032. if (atomic_read(&zfcp_sdev->erp_counter) > ZFCP_MAX_ERPS) {
  1033. dev_err(&zfcp_sdev->port->adapter->ccw_device->dev,
  1034. "ERP failed for LUN 0x%016Lx on "
  1035. "port 0x%016Lx\n",
  1036. (unsigned long long)zfcp_scsi_dev_lun(sdev),
  1037. (unsigned long long)zfcp_sdev->port->wwpn);
  1038. zfcp_erp_set_lun_status(sdev,
  1039. ZFCP_STATUS_COMMON_ERP_FAILED);
  1040. }
  1041. break;
  1042. case ZFCP_ERP_CONTINUES:
  1043. case ZFCP_ERP_EXIT:
  1044. case ZFCP_ERP_DISMISSED:
  1045. case ZFCP_ERP_NOMEM:
  1046. /* NOP */
  1047. break;
  1048. }
  1049. if (atomic_read(&zfcp_sdev->status) & ZFCP_STATUS_COMMON_ERP_FAILED) {
  1050. zfcp_erp_lun_block(sdev, 0);
  1051. result = ZFCP_ERP_EXIT;
  1052. }
  1053. return result;
  1054. }
  1055. static enum zfcp_erp_act_result zfcp_erp_strategy_check_port(
  1056. struct zfcp_port *port, enum zfcp_erp_act_result result)
  1057. {
  1058. switch (result) {
  1059. case ZFCP_ERP_SUCCEEDED :
  1060. atomic_set(&port->erp_counter, 0);
  1061. zfcp_erp_port_unblock(port);
  1062. break;
  1063. case ZFCP_ERP_FAILED :
  1064. if (atomic_read(&port->status) & ZFCP_STATUS_COMMON_NOESC) {
  1065. zfcp_erp_port_block(port, 0);
  1066. result = ZFCP_ERP_EXIT;
  1067. }
  1068. atomic_inc(&port->erp_counter);
  1069. if (atomic_read(&port->erp_counter) > ZFCP_MAX_ERPS) {
  1070. dev_err(&port->adapter->ccw_device->dev,
  1071. "ERP failed for remote port 0x%016Lx\n",
  1072. (unsigned long long)port->wwpn);
  1073. zfcp_erp_set_port_status(port,
  1074. ZFCP_STATUS_COMMON_ERP_FAILED);
  1075. }
  1076. break;
  1077. case ZFCP_ERP_CONTINUES:
  1078. case ZFCP_ERP_EXIT:
  1079. case ZFCP_ERP_DISMISSED:
  1080. case ZFCP_ERP_NOMEM:
  1081. /* NOP */
  1082. break;
  1083. }
  1084. if (atomic_read(&port->status) & ZFCP_STATUS_COMMON_ERP_FAILED) {
  1085. zfcp_erp_port_block(port, 0);
  1086. result = ZFCP_ERP_EXIT;
  1087. }
  1088. return result;
  1089. }
  1090. static enum zfcp_erp_act_result zfcp_erp_strategy_check_adapter(
  1091. struct zfcp_adapter *adapter, enum zfcp_erp_act_result result)
  1092. {
  1093. switch (result) {
  1094. case ZFCP_ERP_SUCCEEDED :
  1095. atomic_set(&adapter->erp_counter, 0);
  1096. zfcp_erp_adapter_unblock(adapter);
  1097. break;
  1098. case ZFCP_ERP_FAILED :
  1099. atomic_inc(&adapter->erp_counter);
  1100. if (atomic_read(&adapter->erp_counter) > ZFCP_MAX_ERPS) {
  1101. dev_err(&adapter->ccw_device->dev,
  1102. "ERP cannot recover an error "
  1103. "on the FCP device\n");
  1104. zfcp_erp_set_adapter_status(adapter,
  1105. ZFCP_STATUS_COMMON_ERP_FAILED);
  1106. }
  1107. break;
  1108. case ZFCP_ERP_CONTINUES:
  1109. case ZFCP_ERP_EXIT:
  1110. case ZFCP_ERP_DISMISSED:
  1111. case ZFCP_ERP_NOMEM:
  1112. /* NOP */
  1113. break;
  1114. }
  1115. if (atomic_read(&adapter->status) & ZFCP_STATUS_COMMON_ERP_FAILED) {
  1116. zfcp_erp_adapter_block(adapter, 0);
  1117. result = ZFCP_ERP_EXIT;
  1118. }
  1119. return result;
  1120. }
  1121. static enum zfcp_erp_act_result zfcp_erp_strategy_check_target(
  1122. struct zfcp_erp_action *erp_action, enum zfcp_erp_act_result result)
  1123. {
  1124. struct zfcp_adapter *adapter = erp_action->adapter;
  1125. struct zfcp_port *port = erp_action->port;
  1126. struct scsi_device *sdev = erp_action->sdev;
  1127. switch (erp_action->type) {
  1128. case ZFCP_ERP_ACTION_REOPEN_LUN:
  1129. result = zfcp_erp_strategy_check_lun(sdev, result);
  1130. break;
  1131. case ZFCP_ERP_ACTION_REOPEN_PORT_FORCED:
  1132. case ZFCP_ERP_ACTION_REOPEN_PORT:
  1133. result = zfcp_erp_strategy_check_port(port, result);
  1134. break;
  1135. case ZFCP_ERP_ACTION_REOPEN_ADAPTER:
  1136. result = zfcp_erp_strategy_check_adapter(adapter, result);
  1137. break;
  1138. }
  1139. return result;
  1140. }
  1141. static int zfcp_erp_strat_change_det(atomic_t *target_status, u32 erp_status)
  1142. {
  1143. int status = atomic_read(target_status);
  1144. if ((status & ZFCP_STATUS_COMMON_RUNNING) &&
  1145. (erp_status & ZFCP_STATUS_ERP_CLOSE_ONLY))
  1146. return 1; /* take it online */
  1147. if (!(status & ZFCP_STATUS_COMMON_RUNNING) &&
  1148. !(erp_status & ZFCP_STATUS_ERP_CLOSE_ONLY))
  1149. return 1; /* take it offline */
  1150. return 0;
  1151. }
  1152. static enum zfcp_erp_act_result zfcp_erp_strategy_statechange(
  1153. struct zfcp_erp_action *act, enum zfcp_erp_act_result result)
  1154. {
  1155. enum zfcp_erp_act_type type = act->type;
  1156. struct zfcp_adapter *adapter = act->adapter;
  1157. struct zfcp_port *port = act->port;
  1158. struct scsi_device *sdev = act->sdev;
  1159. struct zfcp_scsi_dev *zfcp_sdev;
  1160. u32 erp_status = act->status;
  1161. switch (type) {
  1162. case ZFCP_ERP_ACTION_REOPEN_ADAPTER:
  1163. if (zfcp_erp_strat_change_det(&adapter->status, erp_status)) {
  1164. _zfcp_erp_adapter_reopen(adapter,
  1165. ZFCP_STATUS_COMMON_ERP_FAILED,
  1166. "ersscg1");
  1167. return ZFCP_ERP_EXIT;
  1168. }
  1169. break;
  1170. case ZFCP_ERP_ACTION_REOPEN_PORT_FORCED:
  1171. case ZFCP_ERP_ACTION_REOPEN_PORT:
  1172. if (zfcp_erp_strat_change_det(&port->status, erp_status)) {
  1173. _zfcp_erp_port_reopen(port,
  1174. ZFCP_STATUS_COMMON_ERP_FAILED,
  1175. "ersscg2");
  1176. return ZFCP_ERP_EXIT;
  1177. }
  1178. break;
  1179. case ZFCP_ERP_ACTION_REOPEN_LUN:
  1180. zfcp_sdev = sdev_to_zfcp(sdev);
  1181. if (zfcp_erp_strat_change_det(&zfcp_sdev->status, erp_status)) {
  1182. _zfcp_erp_lun_reopen(sdev,
  1183. ZFCP_STATUS_COMMON_ERP_FAILED,
  1184. "ersscg3", 0);
  1185. return ZFCP_ERP_EXIT;
  1186. }
  1187. break;
  1188. }
  1189. return result;
  1190. }
  1191. static void zfcp_erp_action_dequeue(struct zfcp_erp_action *erp_action)
  1192. {
  1193. struct zfcp_adapter *adapter = erp_action->adapter;
  1194. struct zfcp_scsi_dev *zfcp_sdev;
  1195. adapter->erp_total_count--;
  1196. if (erp_action->status & ZFCP_STATUS_ERP_LOWMEM) {
  1197. adapter->erp_low_mem_count--;
  1198. erp_action->status &= ~ZFCP_STATUS_ERP_LOWMEM;
  1199. }
  1200. list_del(&erp_action->list);
  1201. zfcp_dbf_rec_run("eractd1", erp_action);
  1202. switch (erp_action->type) {
  1203. case ZFCP_ERP_ACTION_REOPEN_LUN:
  1204. zfcp_sdev = sdev_to_zfcp(erp_action->sdev);
  1205. atomic_andnot(ZFCP_STATUS_COMMON_ERP_INUSE,
  1206. &zfcp_sdev->status);
  1207. break;
  1208. case ZFCP_ERP_ACTION_REOPEN_PORT_FORCED:
  1209. case ZFCP_ERP_ACTION_REOPEN_PORT:
  1210. atomic_andnot(ZFCP_STATUS_COMMON_ERP_INUSE,
  1211. &erp_action->port->status);
  1212. break;
  1213. case ZFCP_ERP_ACTION_REOPEN_ADAPTER:
  1214. atomic_andnot(ZFCP_STATUS_COMMON_ERP_INUSE,
  1215. &erp_action->adapter->status);
  1216. break;
  1217. }
  1218. }
  1219. /**
  1220. * zfcp_erp_try_rport_unblock - unblock rport if no more/new recovery
  1221. * @port: zfcp_port whose fc_rport we should try to unblock
  1222. */
  1223. static void zfcp_erp_try_rport_unblock(struct zfcp_port *port)
  1224. {
  1225. unsigned long flags;
  1226. struct zfcp_adapter *adapter = port->adapter;
  1227. int port_status;
  1228. struct Scsi_Host *shost = adapter->scsi_host;
  1229. struct scsi_device *sdev;
  1230. write_lock_irqsave(&adapter->erp_lock, flags);
  1231. port_status = atomic_read(&port->status);
  1232. if ((port_status & ZFCP_STATUS_COMMON_UNBLOCKED) == 0 ||
  1233. (port_status & (ZFCP_STATUS_COMMON_ERP_INUSE |
  1234. ZFCP_STATUS_COMMON_ERP_FAILED)) != 0) {
  1235. /* new ERP of severity >= port triggered elsewhere meanwhile or
  1236. * local link down (adapter erp_failed but not clear unblock)
  1237. */
  1238. zfcp_dbf_rec_run_lvl(4, "ertru_p", &port->erp_action);
  1239. write_unlock_irqrestore(&adapter->erp_lock, flags);
  1240. return;
  1241. }
  1242. spin_lock(shost->host_lock);
  1243. __shost_for_each_device(sdev, shost) {
  1244. struct zfcp_scsi_dev *zsdev = sdev_to_zfcp(sdev);
  1245. int lun_status;
  1246. if (sdev->sdev_state == SDEV_DEL ||
  1247. sdev->sdev_state == SDEV_CANCEL)
  1248. continue;
  1249. if (zsdev->port != port)
  1250. continue;
  1251. /* LUN under port of interest */
  1252. lun_status = atomic_read(&zsdev->status);
  1253. if ((lun_status & ZFCP_STATUS_COMMON_ERP_FAILED) != 0)
  1254. continue; /* unblock rport despite failed LUNs */
  1255. /* LUN recovery not given up yet [maybe follow-up pending] */
  1256. if ((lun_status & ZFCP_STATUS_COMMON_UNBLOCKED) == 0 ||
  1257. (lun_status & ZFCP_STATUS_COMMON_ERP_INUSE) != 0) {
  1258. /* LUN blocked:
  1259. * not yet unblocked [LUN recovery pending]
  1260. * or meanwhile blocked [new LUN recovery triggered]
  1261. */
  1262. zfcp_dbf_rec_run_lvl(4, "ertru_l", &zsdev->erp_action);
  1263. spin_unlock(shost->host_lock);
  1264. write_unlock_irqrestore(&adapter->erp_lock, flags);
  1265. return;
  1266. }
  1267. }
  1268. /* now port has no child or all children have completed recovery,
  1269. * and no ERP of severity >= port was meanwhile triggered elsewhere
  1270. */
  1271. zfcp_scsi_schedule_rport_register(port);
  1272. spin_unlock(shost->host_lock);
  1273. write_unlock_irqrestore(&adapter->erp_lock, flags);
  1274. }
  1275. static void zfcp_erp_action_cleanup(struct zfcp_erp_action *act,
  1276. enum zfcp_erp_act_result result)
  1277. {
  1278. struct zfcp_adapter *adapter = act->adapter;
  1279. struct zfcp_port *port = act->port;
  1280. struct scsi_device *sdev = act->sdev;
  1281. switch (act->type) {
  1282. case ZFCP_ERP_ACTION_REOPEN_LUN:
  1283. if (!(act->status & ZFCP_STATUS_ERP_NO_REF))
  1284. scsi_device_put(sdev);
  1285. zfcp_erp_try_rport_unblock(port);
  1286. break;
  1287. case ZFCP_ERP_ACTION_REOPEN_PORT:
  1288. /* This switch case might also happen after a forced reopen
  1289. * was successfully done and thus overwritten with a new
  1290. * non-forced reopen at `ersfs_2'. In this case, we must not
  1291. * do the clean-up of the non-forced version.
  1292. */
  1293. if (act->step != ZFCP_ERP_STEP_UNINITIALIZED)
  1294. if (result == ZFCP_ERP_SUCCEEDED)
  1295. zfcp_erp_try_rport_unblock(port);
  1296. fallthrough;
  1297. case ZFCP_ERP_ACTION_REOPEN_PORT_FORCED:
  1298. put_device(&port->dev);
  1299. break;
  1300. case ZFCP_ERP_ACTION_REOPEN_ADAPTER:
  1301. if (result == ZFCP_ERP_SUCCEEDED) {
  1302. register_service_level(&adapter->service_level);
  1303. zfcp_fc_conditional_port_scan(adapter);
  1304. queue_work(adapter->work_queue, &adapter->ns_up_work);
  1305. } else
  1306. unregister_service_level(&adapter->service_level);
  1307. kref_put(&adapter->ref, zfcp_adapter_release);
  1308. break;
  1309. }
  1310. }
  1311. static enum zfcp_erp_act_result zfcp_erp_strategy_do_action(
  1312. struct zfcp_erp_action *erp_action)
  1313. {
  1314. switch (erp_action->type) {
  1315. case ZFCP_ERP_ACTION_REOPEN_ADAPTER:
  1316. return zfcp_erp_adapter_strategy(erp_action);
  1317. case ZFCP_ERP_ACTION_REOPEN_PORT_FORCED:
  1318. return zfcp_erp_port_forced_strategy(erp_action);
  1319. case ZFCP_ERP_ACTION_REOPEN_PORT:
  1320. return zfcp_erp_port_strategy(erp_action);
  1321. case ZFCP_ERP_ACTION_REOPEN_LUN:
  1322. return zfcp_erp_lun_strategy(erp_action);
  1323. }
  1324. return ZFCP_ERP_FAILED;
  1325. }
  1326. static enum zfcp_erp_act_result zfcp_erp_strategy(
  1327. struct zfcp_erp_action *erp_action)
  1328. {
  1329. enum zfcp_erp_act_result result;
  1330. unsigned long flags;
  1331. struct zfcp_adapter *adapter = erp_action->adapter;
  1332. kref_get(&adapter->ref);
  1333. write_lock_irqsave(&adapter->erp_lock, flags);
  1334. zfcp_erp_strategy_check_fsfreq(erp_action);
  1335. if (erp_action->status & ZFCP_STATUS_ERP_DISMISSED) {
  1336. zfcp_erp_action_dequeue(erp_action);
  1337. result = ZFCP_ERP_DISMISSED;
  1338. goto unlock;
  1339. }
  1340. if (erp_action->status & ZFCP_STATUS_ERP_TIMEDOUT) {
  1341. result = ZFCP_ERP_FAILED;
  1342. goto check_target;
  1343. }
  1344. zfcp_erp_action_to_running(erp_action);
  1345. /* no lock to allow for blocking operations */
  1346. write_unlock_irqrestore(&adapter->erp_lock, flags);
  1347. result = zfcp_erp_strategy_do_action(erp_action);
  1348. write_lock_irqsave(&adapter->erp_lock, flags);
  1349. if (erp_action->status & ZFCP_STATUS_ERP_DISMISSED)
  1350. result = ZFCP_ERP_CONTINUES;
  1351. switch (result) {
  1352. case ZFCP_ERP_NOMEM:
  1353. if (!(erp_action->status & ZFCP_STATUS_ERP_LOWMEM)) {
  1354. ++adapter->erp_low_mem_count;
  1355. erp_action->status |= ZFCP_STATUS_ERP_LOWMEM;
  1356. }
  1357. if (adapter->erp_total_count == adapter->erp_low_mem_count)
  1358. _zfcp_erp_adapter_reopen(adapter, 0, "erstgy1");
  1359. else {
  1360. zfcp_erp_strategy_memwait(erp_action);
  1361. result = ZFCP_ERP_CONTINUES;
  1362. }
  1363. goto unlock;
  1364. case ZFCP_ERP_CONTINUES:
  1365. if (erp_action->status & ZFCP_STATUS_ERP_LOWMEM) {
  1366. --adapter->erp_low_mem_count;
  1367. erp_action->status &= ~ZFCP_STATUS_ERP_LOWMEM;
  1368. }
  1369. goto unlock;
  1370. case ZFCP_ERP_SUCCEEDED:
  1371. case ZFCP_ERP_FAILED:
  1372. case ZFCP_ERP_EXIT:
  1373. case ZFCP_ERP_DISMISSED:
  1374. /* NOP */
  1375. break;
  1376. }
  1377. check_target:
  1378. result = zfcp_erp_strategy_check_target(erp_action, result);
  1379. zfcp_erp_action_dequeue(erp_action);
  1380. result = zfcp_erp_strategy_statechange(erp_action, result);
  1381. if (result == ZFCP_ERP_EXIT)
  1382. goto unlock;
  1383. if (result == ZFCP_ERP_SUCCEEDED)
  1384. zfcp_erp_strategy_followup_success(erp_action);
  1385. if (result == ZFCP_ERP_FAILED)
  1386. zfcp_erp_strategy_followup_failed(erp_action);
  1387. unlock:
  1388. write_unlock_irqrestore(&adapter->erp_lock, flags);
  1389. if (result != ZFCP_ERP_CONTINUES)
  1390. zfcp_erp_action_cleanup(erp_action, result);
  1391. kref_put(&adapter->ref, zfcp_adapter_release);
  1392. return result;
  1393. }
  1394. static int zfcp_erp_thread(void *data)
  1395. {
  1396. struct zfcp_adapter *adapter = (struct zfcp_adapter *) data;
  1397. struct zfcp_erp_action *act;
  1398. unsigned long flags;
  1399. for (;;) {
  1400. wait_event_interruptible(adapter->erp_ready_wq,
  1401. !list_empty(&adapter->erp_ready_head) ||
  1402. kthread_should_stop());
  1403. if (kthread_should_stop())
  1404. break;
  1405. write_lock_irqsave(&adapter->erp_lock, flags);
  1406. act = list_first_entry_or_null(&adapter->erp_ready_head,
  1407. struct zfcp_erp_action, list);
  1408. write_unlock_irqrestore(&adapter->erp_lock, flags);
  1409. if (act) {
  1410. /* there is more to come after dismission, no notify */
  1411. if (zfcp_erp_strategy(act) != ZFCP_ERP_DISMISSED)
  1412. zfcp_erp_wakeup(adapter);
  1413. }
  1414. }
  1415. return 0;
  1416. }
  1417. /**
  1418. * zfcp_erp_thread_setup - Start ERP thread for adapter
  1419. * @adapter: Adapter to start the ERP thread for
  1420. *
  1421. * Return: 0 on success, or error code from kthread_run().
  1422. */
  1423. int zfcp_erp_thread_setup(struct zfcp_adapter *adapter)
  1424. {
  1425. struct task_struct *thread;
  1426. thread = kthread_run(zfcp_erp_thread, adapter, "zfcperp%s",
  1427. dev_name(&adapter->ccw_device->dev));
  1428. if (IS_ERR(thread)) {
  1429. dev_err(&adapter->ccw_device->dev,
  1430. "Creating an ERP thread for the FCP device failed.\n");
  1431. return PTR_ERR(thread);
  1432. }
  1433. adapter->erp_thread = thread;
  1434. return 0;
  1435. }
  1436. /**
  1437. * zfcp_erp_thread_kill - Stop ERP thread.
  1438. * @adapter: Adapter where the ERP thread should be stopped.
  1439. *
  1440. * The caller of this routine ensures that the specified adapter has
  1441. * been shut down and that this operation has been completed. Thus,
  1442. * there are no pending erp_actions which would need to be handled
  1443. * here.
  1444. */
  1445. void zfcp_erp_thread_kill(struct zfcp_adapter *adapter)
  1446. {
  1447. kthread_stop(adapter->erp_thread);
  1448. adapter->erp_thread = NULL;
  1449. WARN_ON(!list_empty(&adapter->erp_ready_head));
  1450. WARN_ON(!list_empty(&adapter->erp_running_head));
  1451. }
  1452. /**
  1453. * zfcp_erp_wait - wait for completion of error recovery on an adapter
  1454. * @adapter: adapter for which to wait for completion of its error recovery
  1455. */
  1456. void zfcp_erp_wait(struct zfcp_adapter *adapter)
  1457. {
  1458. wait_event(adapter->erp_done_wqh,
  1459. !(atomic_read(&adapter->status) &
  1460. ZFCP_STATUS_ADAPTER_ERP_PENDING));
  1461. }
  1462. /**
  1463. * zfcp_erp_set_adapter_status - set adapter status bits
  1464. * @adapter: adapter to change the status
  1465. * @mask: status bits to change
  1466. *
  1467. * Changes in common status bits are propagated to attached ports and LUNs.
  1468. */
  1469. void zfcp_erp_set_adapter_status(struct zfcp_adapter *adapter, u32 mask)
  1470. {
  1471. struct zfcp_port *port;
  1472. struct scsi_device *sdev;
  1473. unsigned long flags;
  1474. u32 common_mask = mask & ZFCP_COMMON_FLAGS;
  1475. atomic_or(mask, &adapter->status);
  1476. if (!common_mask)
  1477. return;
  1478. read_lock_irqsave(&adapter->port_list_lock, flags);
  1479. list_for_each_entry(port, &adapter->port_list, list)
  1480. atomic_or(common_mask, &port->status);
  1481. read_unlock_irqrestore(&adapter->port_list_lock, flags);
  1482. /*
  1483. * if `scsi_host` is missing, xconfig/xport data has never completed
  1484. * yet, so we can't access it, but there are also no SDEVs yet
  1485. */
  1486. if (adapter->scsi_host == NULL)
  1487. return;
  1488. spin_lock_irqsave(adapter->scsi_host->host_lock, flags);
  1489. __shost_for_each_device(sdev, adapter->scsi_host)
  1490. atomic_or(common_mask, &sdev_to_zfcp(sdev)->status);
  1491. spin_unlock_irqrestore(adapter->scsi_host->host_lock, flags);
  1492. }
  1493. /**
  1494. * zfcp_erp_clear_adapter_status - clear adapter status bits
  1495. * @adapter: adapter to change the status
  1496. * @mask: status bits to change
  1497. *
  1498. * Changes in common status bits are propagated to attached ports and LUNs.
  1499. */
  1500. void zfcp_erp_clear_adapter_status(struct zfcp_adapter *adapter, u32 mask)
  1501. {
  1502. struct zfcp_port *port;
  1503. struct scsi_device *sdev;
  1504. unsigned long flags;
  1505. u32 common_mask = mask & ZFCP_COMMON_FLAGS;
  1506. u32 clear_counter = mask & ZFCP_STATUS_COMMON_ERP_FAILED;
  1507. atomic_andnot(mask, &adapter->status);
  1508. if (!common_mask)
  1509. return;
  1510. if (clear_counter)
  1511. atomic_set(&adapter->erp_counter, 0);
  1512. read_lock_irqsave(&adapter->port_list_lock, flags);
  1513. list_for_each_entry(port, &adapter->port_list, list) {
  1514. atomic_andnot(common_mask, &port->status);
  1515. if (clear_counter)
  1516. atomic_set(&port->erp_counter, 0);
  1517. }
  1518. read_unlock_irqrestore(&adapter->port_list_lock, flags);
  1519. /*
  1520. * if `scsi_host` is missing, xconfig/xport data has never completed
  1521. * yet, so we can't access it, but there are also no SDEVs yet
  1522. */
  1523. if (adapter->scsi_host == NULL)
  1524. return;
  1525. spin_lock_irqsave(adapter->scsi_host->host_lock, flags);
  1526. __shost_for_each_device(sdev, adapter->scsi_host) {
  1527. atomic_andnot(common_mask, &sdev_to_zfcp(sdev)->status);
  1528. if (clear_counter)
  1529. atomic_set(&sdev_to_zfcp(sdev)->erp_counter, 0);
  1530. }
  1531. spin_unlock_irqrestore(adapter->scsi_host->host_lock, flags);
  1532. }
  1533. /**
  1534. * zfcp_erp_set_port_status - set port status bits
  1535. * @port: port to change the status
  1536. * @mask: status bits to change
  1537. *
  1538. * Changes in common status bits are propagated to attached LUNs.
  1539. */
  1540. void zfcp_erp_set_port_status(struct zfcp_port *port, u32 mask)
  1541. {
  1542. struct scsi_device *sdev;
  1543. u32 common_mask = mask & ZFCP_COMMON_FLAGS;
  1544. unsigned long flags;
  1545. atomic_or(mask, &port->status);
  1546. if (!common_mask)
  1547. return;
  1548. spin_lock_irqsave(port->adapter->scsi_host->host_lock, flags);
  1549. __shost_for_each_device(sdev, port->adapter->scsi_host)
  1550. if (sdev_to_zfcp(sdev)->port == port)
  1551. atomic_or(common_mask,
  1552. &sdev_to_zfcp(sdev)->status);
  1553. spin_unlock_irqrestore(port->adapter->scsi_host->host_lock, flags);
  1554. }
  1555. /**
  1556. * zfcp_erp_clear_port_status - clear port status bits
  1557. * @port: adapter to change the status
  1558. * @mask: status bits to change
  1559. *
  1560. * Changes in common status bits are propagated to attached LUNs.
  1561. */
  1562. void zfcp_erp_clear_port_status(struct zfcp_port *port, u32 mask)
  1563. {
  1564. struct scsi_device *sdev;
  1565. u32 common_mask = mask & ZFCP_COMMON_FLAGS;
  1566. u32 clear_counter = mask & ZFCP_STATUS_COMMON_ERP_FAILED;
  1567. unsigned long flags;
  1568. atomic_andnot(mask, &port->status);
  1569. if (!common_mask)
  1570. return;
  1571. if (clear_counter)
  1572. atomic_set(&port->erp_counter, 0);
  1573. spin_lock_irqsave(port->adapter->scsi_host->host_lock, flags);
  1574. __shost_for_each_device(sdev, port->adapter->scsi_host)
  1575. if (sdev_to_zfcp(sdev)->port == port) {
  1576. atomic_andnot(common_mask,
  1577. &sdev_to_zfcp(sdev)->status);
  1578. if (clear_counter)
  1579. atomic_set(&sdev_to_zfcp(sdev)->erp_counter, 0);
  1580. }
  1581. spin_unlock_irqrestore(port->adapter->scsi_host->host_lock, flags);
  1582. }
  1583. /**
  1584. * zfcp_erp_set_lun_status - set lun status bits
  1585. * @sdev: SCSI device / lun to set the status bits
  1586. * @mask: status bits to change
  1587. */
  1588. void zfcp_erp_set_lun_status(struct scsi_device *sdev, u32 mask)
  1589. {
  1590. struct zfcp_scsi_dev *zfcp_sdev = sdev_to_zfcp(sdev);
  1591. atomic_or(mask, &zfcp_sdev->status);
  1592. }
  1593. /**
  1594. * zfcp_erp_clear_lun_status - clear lun status bits
  1595. * @sdev: SCSi device / lun to clear the status bits
  1596. * @mask: status bits to change
  1597. */
  1598. void zfcp_erp_clear_lun_status(struct scsi_device *sdev, u32 mask)
  1599. {
  1600. struct zfcp_scsi_dev *zfcp_sdev = sdev_to_zfcp(sdev);
  1601. atomic_andnot(mask, &zfcp_sdev->status);
  1602. if (mask & ZFCP_STATUS_COMMON_ERP_FAILED)
  1603. atomic_set(&zfcp_sdev->erp_counter, 0);
  1604. }
  1605. /**
  1606. * zfcp_erp_adapter_reset_sync() - Really reopen adapter and wait.
  1607. * @adapter: Pointer to zfcp_adapter to reopen.
  1608. * @dbftag: Trace tag string of length %ZFCP_DBF_TAG_LEN.
  1609. */
  1610. void zfcp_erp_adapter_reset_sync(struct zfcp_adapter *adapter, char *dbftag)
  1611. {
  1612. zfcp_erp_set_adapter_status(adapter, ZFCP_STATUS_COMMON_RUNNING);
  1613. zfcp_erp_adapter_reopen(adapter, ZFCP_STATUS_COMMON_ERP_FAILED, dbftag);
  1614. zfcp_erp_wait(adapter);
  1615. }