zfcp_scsi.c 29 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771772773774775776777778779780781782783784785786787788789790791792793794795796797798799800801802803804805806807808809810811812813814815816817818819820821822823824825826827828829830831832833834835836837838839840841842843844845846847848849850851852853854855856857858859860861862863864865866867868869870871872873874875876877878879880881882883884885886887888889890891892893894895896897898899900901902903904905906907908909910911912913914915916917918919920921922923924925926927928929930931932933934935936937938939940941942943944945946947948949950951952953954955956957958959960961962963964965966967968969970971972973974975976977978979980981982983984985986987988989990991
  1. // SPDX-License-Identifier: GPL-2.0
  2. /*
  3. * zfcp device driver
  4. *
  5. * Interface to Linux SCSI midlayer.
  6. *
  7. * Copyright IBM Corp. 2002, 2020
  8. */
  9. #define KMSG_COMPONENT "zfcp"
  10. #define pr_fmt(fmt) KMSG_COMPONENT ": " fmt
  11. #include <linux/module.h>
  12. #include <linux/types.h>
  13. #include <linux/slab.h>
  14. #include <scsi/fc/fc_fcp.h>
  15. #include <scsi/scsi_eh.h>
  16. #include <linux/atomic.h>
  17. #include "zfcp_ext.h"
  18. #include "zfcp_dbf.h"
  19. #include "zfcp_fc.h"
  20. #include "zfcp_reqlist.h"
  21. static unsigned int default_depth = 32;
  22. module_param_named(queue_depth, default_depth, uint, 0600);
  23. MODULE_PARM_DESC(queue_depth, "Default queue depth for new SCSI devices");
  24. static bool enable_dif;
  25. module_param_named(dif, enable_dif, bool, 0400);
  26. MODULE_PARM_DESC(dif, "Enable DIF data integrity support (default off)");
  27. bool zfcp_experimental_dix;
  28. module_param_named(dix, zfcp_experimental_dix, bool, 0400);
  29. MODULE_PARM_DESC(dix, "Enable experimental DIX (data integrity extension) support which implies DIF support (default off)");
  30. static bool allow_lun_scan = true;
  31. module_param(allow_lun_scan, bool, 0600);
  32. MODULE_PARM_DESC(allow_lun_scan, "For NPIV, scan and attach all storage LUNs");
  33. static void zfcp_scsi_slave_destroy(struct scsi_device *sdev)
  34. {
  35. struct zfcp_scsi_dev *zfcp_sdev = sdev_to_zfcp(sdev);
  36. /* if previous slave_alloc returned early, there is nothing to do */
  37. if (!zfcp_sdev->port)
  38. return;
  39. zfcp_erp_lun_shutdown_wait(sdev, "scssd_1");
  40. put_device(&zfcp_sdev->port->dev);
  41. }
  42. static int zfcp_scsi_slave_configure(struct scsi_device *sdp)
  43. {
  44. if (sdp->tagged_supported)
  45. scsi_change_queue_depth(sdp, default_depth);
  46. return 0;
  47. }
  48. static void zfcp_scsi_command_fail(struct scsi_cmnd *scpnt, int result)
  49. {
  50. set_host_byte(scpnt, result);
  51. zfcp_dbf_scsi_fail_send(scpnt);
  52. scpnt->scsi_done(scpnt);
  53. }
  54. static
  55. int zfcp_scsi_queuecommand(struct Scsi_Host *shost, struct scsi_cmnd *scpnt)
  56. {
  57. struct zfcp_scsi_dev *zfcp_sdev = sdev_to_zfcp(scpnt->device);
  58. struct fc_rport *rport = starget_to_rport(scsi_target(scpnt->device));
  59. int status, scsi_result, ret;
  60. /* reset the status for this request */
  61. scpnt->result = 0;
  62. scpnt->host_scribble = NULL;
  63. scsi_result = fc_remote_port_chkready(rport);
  64. if (unlikely(scsi_result)) {
  65. scpnt->result = scsi_result;
  66. zfcp_dbf_scsi_fail_send(scpnt);
  67. scpnt->scsi_done(scpnt);
  68. return 0;
  69. }
  70. status = atomic_read(&zfcp_sdev->status);
  71. if (unlikely(status & ZFCP_STATUS_COMMON_ERP_FAILED) &&
  72. !(atomic_read(&zfcp_sdev->port->status) &
  73. ZFCP_STATUS_COMMON_ERP_FAILED)) {
  74. /* only LUN access denied, but port is good
  75. * not covered by FC transport, have to fail here */
  76. zfcp_scsi_command_fail(scpnt, DID_ERROR);
  77. return 0;
  78. }
  79. if (unlikely(!(status & ZFCP_STATUS_COMMON_UNBLOCKED))) {
  80. /* This could be
  81. * call to rport_delete pending: mimic retry from
  82. * fc_remote_port_chkready until rport is BLOCKED
  83. */
  84. zfcp_scsi_command_fail(scpnt, DID_IMM_RETRY);
  85. return 0;
  86. }
  87. ret = zfcp_fsf_fcp_cmnd(scpnt);
  88. if (unlikely(ret == -EBUSY))
  89. return SCSI_MLQUEUE_DEVICE_BUSY;
  90. else if (unlikely(ret < 0))
  91. return SCSI_MLQUEUE_HOST_BUSY;
  92. return ret;
  93. }
  94. static int zfcp_scsi_slave_alloc(struct scsi_device *sdev)
  95. {
  96. struct fc_rport *rport = starget_to_rport(scsi_target(sdev));
  97. struct zfcp_adapter *adapter =
  98. (struct zfcp_adapter *) sdev->host->hostdata[0];
  99. struct zfcp_scsi_dev *zfcp_sdev = sdev_to_zfcp(sdev);
  100. struct zfcp_port *port;
  101. struct zfcp_unit *unit;
  102. int npiv = adapter->connection_features & FSF_FEATURE_NPIV_MODE;
  103. zfcp_sdev->erp_action.adapter = adapter;
  104. zfcp_sdev->erp_action.sdev = sdev;
  105. port = zfcp_get_port_by_wwpn(adapter, rport->port_name);
  106. if (!port)
  107. return -ENXIO;
  108. zfcp_sdev->erp_action.port = port;
  109. mutex_lock(&zfcp_sysfs_port_units_mutex);
  110. if (zfcp_sysfs_port_is_removing(port)) {
  111. /* port is already gone */
  112. mutex_unlock(&zfcp_sysfs_port_units_mutex);
  113. put_device(&port->dev); /* undo zfcp_get_port_by_wwpn() */
  114. return -ENXIO;
  115. }
  116. mutex_unlock(&zfcp_sysfs_port_units_mutex);
  117. unit = zfcp_unit_find(port, zfcp_scsi_dev_lun(sdev));
  118. if (unit)
  119. put_device(&unit->dev);
  120. if (!unit && !(allow_lun_scan && npiv)) {
  121. put_device(&port->dev);
  122. return -ENXIO;
  123. }
  124. zfcp_sdev->port = port;
  125. zfcp_sdev->latencies.write.channel.min = 0xFFFFFFFF;
  126. zfcp_sdev->latencies.write.fabric.min = 0xFFFFFFFF;
  127. zfcp_sdev->latencies.read.channel.min = 0xFFFFFFFF;
  128. zfcp_sdev->latencies.read.fabric.min = 0xFFFFFFFF;
  129. zfcp_sdev->latencies.cmd.channel.min = 0xFFFFFFFF;
  130. zfcp_sdev->latencies.cmd.fabric.min = 0xFFFFFFFF;
  131. spin_lock_init(&zfcp_sdev->latencies.lock);
  132. zfcp_erp_set_lun_status(sdev, ZFCP_STATUS_COMMON_RUNNING);
  133. zfcp_erp_lun_reopen(sdev, 0, "scsla_1");
  134. zfcp_erp_wait(port->adapter);
  135. return 0;
  136. }
  137. static int zfcp_scsi_eh_abort_handler(struct scsi_cmnd *scpnt)
  138. {
  139. struct Scsi_Host *scsi_host = scpnt->device->host;
  140. struct zfcp_adapter *adapter =
  141. (struct zfcp_adapter *) scsi_host->hostdata[0];
  142. struct zfcp_fsf_req *old_req, *abrt_req;
  143. unsigned long flags;
  144. unsigned long old_reqid = (unsigned long) scpnt->host_scribble;
  145. int retval = SUCCESS, ret;
  146. int retry = 3;
  147. char *dbf_tag;
  148. /* avoid race condition between late normal completion and abort */
  149. write_lock_irqsave(&adapter->abort_lock, flags);
  150. old_req = zfcp_reqlist_find(adapter->req_list, old_reqid);
  151. if (!old_req) {
  152. write_unlock_irqrestore(&adapter->abort_lock, flags);
  153. zfcp_dbf_scsi_abort("abrt_or", scpnt, NULL);
  154. return FAILED; /* completion could be in progress */
  155. }
  156. old_req->data = NULL;
  157. /* don't access old fsf_req after releasing the abort_lock */
  158. write_unlock_irqrestore(&adapter->abort_lock, flags);
  159. while (retry--) {
  160. abrt_req = zfcp_fsf_abort_fcp_cmnd(scpnt);
  161. if (abrt_req)
  162. break;
  163. zfcp_dbf_scsi_abort("abrt_wt", scpnt, NULL);
  164. zfcp_erp_wait(adapter);
  165. ret = fc_block_scsi_eh(scpnt);
  166. if (ret) {
  167. zfcp_dbf_scsi_abort("abrt_bl", scpnt, NULL);
  168. return ret;
  169. }
  170. if (!(atomic_read(&adapter->status) &
  171. ZFCP_STATUS_COMMON_RUNNING)) {
  172. zfcp_dbf_scsi_abort("abrt_ru", scpnt, NULL);
  173. return SUCCESS;
  174. }
  175. }
  176. if (!abrt_req) {
  177. zfcp_dbf_scsi_abort("abrt_ar", scpnt, NULL);
  178. return FAILED;
  179. }
  180. wait_for_completion(&abrt_req->completion);
  181. if (abrt_req->status & ZFCP_STATUS_FSFREQ_ABORTSUCCEEDED)
  182. dbf_tag = "abrt_ok";
  183. else if (abrt_req->status & ZFCP_STATUS_FSFREQ_ABORTNOTNEEDED)
  184. dbf_tag = "abrt_nn";
  185. else {
  186. dbf_tag = "abrt_fa";
  187. retval = FAILED;
  188. }
  189. zfcp_dbf_scsi_abort(dbf_tag, scpnt, abrt_req);
  190. zfcp_fsf_req_free(abrt_req);
  191. return retval;
  192. }
  193. struct zfcp_scsi_req_filter {
  194. u8 tmf_scope;
  195. u32 lun_handle;
  196. u32 port_handle;
  197. };
  198. static void zfcp_scsi_forget_cmnd(struct zfcp_fsf_req *old_req, void *data)
  199. {
  200. struct zfcp_scsi_req_filter *filter =
  201. (struct zfcp_scsi_req_filter *)data;
  202. /* already aborted - prevent side-effects - or not a SCSI command */
  203. if (old_req->data == NULL ||
  204. zfcp_fsf_req_is_status_read_buffer(old_req) ||
  205. old_req->qtcb->header.fsf_command != FSF_QTCB_FCP_CMND)
  206. return;
  207. /* (tmf_scope == FCP_TMF_TGT_RESET || tmf_scope == FCP_TMF_LUN_RESET) */
  208. if (old_req->qtcb->header.port_handle != filter->port_handle)
  209. return;
  210. if (filter->tmf_scope == FCP_TMF_LUN_RESET &&
  211. old_req->qtcb->header.lun_handle != filter->lun_handle)
  212. return;
  213. zfcp_dbf_scsi_nullcmnd((struct scsi_cmnd *)old_req->data, old_req);
  214. old_req->data = NULL;
  215. }
  216. static void zfcp_scsi_forget_cmnds(struct zfcp_scsi_dev *zsdev, u8 tm_flags)
  217. {
  218. struct zfcp_adapter *adapter = zsdev->port->adapter;
  219. struct zfcp_scsi_req_filter filter = {
  220. .tmf_scope = FCP_TMF_TGT_RESET,
  221. .port_handle = zsdev->port->handle,
  222. };
  223. unsigned long flags;
  224. if (tm_flags == FCP_TMF_LUN_RESET) {
  225. filter.tmf_scope = FCP_TMF_LUN_RESET;
  226. filter.lun_handle = zsdev->lun_handle;
  227. }
  228. /*
  229. * abort_lock secures against other processings - in the abort-function
  230. * and normal cmnd-handler - of (struct zfcp_fsf_req *)->data
  231. */
  232. write_lock_irqsave(&adapter->abort_lock, flags);
  233. zfcp_reqlist_apply_for_all(adapter->req_list, zfcp_scsi_forget_cmnd,
  234. &filter);
  235. write_unlock_irqrestore(&adapter->abort_lock, flags);
  236. }
  237. /**
  238. * zfcp_scsi_task_mgmt_function() - Send a task management function (sync).
  239. * @sdev: Pointer to SCSI device to send the task management command to.
  240. * @tm_flags: Task management flags,
  241. * here we only handle %FCP_TMF_TGT_RESET or %FCP_TMF_LUN_RESET.
  242. */
  243. static int zfcp_scsi_task_mgmt_function(struct scsi_device *sdev, u8 tm_flags)
  244. {
  245. struct zfcp_scsi_dev *zfcp_sdev = sdev_to_zfcp(sdev);
  246. struct zfcp_adapter *adapter = zfcp_sdev->port->adapter;
  247. struct fc_rport *rport = starget_to_rport(scsi_target(sdev));
  248. struct zfcp_fsf_req *fsf_req = NULL;
  249. int retval = SUCCESS, ret;
  250. int retry = 3;
  251. while (retry--) {
  252. fsf_req = zfcp_fsf_fcp_task_mgmt(sdev, tm_flags);
  253. if (fsf_req)
  254. break;
  255. zfcp_dbf_scsi_devreset("wait", sdev, tm_flags, NULL);
  256. zfcp_erp_wait(adapter);
  257. ret = fc_block_rport(rport);
  258. if (ret) {
  259. zfcp_dbf_scsi_devreset("fiof", sdev, tm_flags, NULL);
  260. return ret;
  261. }
  262. if (!(atomic_read(&adapter->status) &
  263. ZFCP_STATUS_COMMON_RUNNING)) {
  264. zfcp_dbf_scsi_devreset("nres", sdev, tm_flags, NULL);
  265. return SUCCESS;
  266. }
  267. }
  268. if (!fsf_req) {
  269. zfcp_dbf_scsi_devreset("reqf", sdev, tm_flags, NULL);
  270. return FAILED;
  271. }
  272. wait_for_completion(&fsf_req->completion);
  273. if (fsf_req->status & ZFCP_STATUS_FSFREQ_TMFUNCFAILED) {
  274. zfcp_dbf_scsi_devreset("fail", sdev, tm_flags, fsf_req);
  275. retval = FAILED;
  276. } else {
  277. zfcp_dbf_scsi_devreset("okay", sdev, tm_flags, fsf_req);
  278. zfcp_scsi_forget_cmnds(zfcp_sdev, tm_flags);
  279. }
  280. zfcp_fsf_req_free(fsf_req);
  281. return retval;
  282. }
  283. static int zfcp_scsi_eh_device_reset_handler(struct scsi_cmnd *scpnt)
  284. {
  285. struct scsi_device *sdev = scpnt->device;
  286. return zfcp_scsi_task_mgmt_function(sdev, FCP_TMF_LUN_RESET);
  287. }
  288. static int zfcp_scsi_eh_target_reset_handler(struct scsi_cmnd *scpnt)
  289. {
  290. struct scsi_target *starget = scsi_target(scpnt->device);
  291. struct fc_rport *rport = starget_to_rport(starget);
  292. struct Scsi_Host *shost = rport_to_shost(rport);
  293. struct scsi_device *sdev = NULL, *tmp_sdev;
  294. struct zfcp_adapter *adapter =
  295. (struct zfcp_adapter *)shost->hostdata[0];
  296. int ret;
  297. shost_for_each_device(tmp_sdev, shost) {
  298. if (tmp_sdev->id == starget->id) {
  299. sdev = tmp_sdev;
  300. break;
  301. }
  302. }
  303. if (!sdev) {
  304. ret = FAILED;
  305. zfcp_dbf_scsi_eh("tr_nosd", adapter, starget->id, ret);
  306. return ret;
  307. }
  308. ret = zfcp_scsi_task_mgmt_function(sdev, FCP_TMF_TGT_RESET);
  309. /* release reference from above shost_for_each_device */
  310. if (sdev)
  311. scsi_device_put(tmp_sdev);
  312. return ret;
  313. }
  314. static int zfcp_scsi_eh_host_reset_handler(struct scsi_cmnd *scpnt)
  315. {
  316. struct zfcp_scsi_dev *zfcp_sdev = sdev_to_zfcp(scpnt->device);
  317. struct zfcp_adapter *adapter = zfcp_sdev->port->adapter;
  318. int ret = SUCCESS, fc_ret;
  319. if (!(adapter->connection_features & FSF_FEATURE_NPIV_MODE)) {
  320. zfcp_erp_port_forced_reopen_all(adapter, 0, "schrh_p");
  321. zfcp_erp_wait(adapter);
  322. }
  323. zfcp_erp_adapter_reopen(adapter, 0, "schrh_1");
  324. zfcp_erp_wait(adapter);
  325. fc_ret = fc_block_scsi_eh(scpnt);
  326. if (fc_ret)
  327. ret = fc_ret;
  328. zfcp_dbf_scsi_eh("schrh_r", adapter, ~0, ret);
  329. return ret;
  330. }
  331. /**
  332. * zfcp_scsi_sysfs_host_reset() - Support scsi_host sysfs attribute host_reset.
  333. * @shost: Pointer to Scsi_Host to perform action on.
  334. * @reset_type: We support %SCSI_ADAPTER_RESET but not %SCSI_FIRMWARE_RESET.
  335. *
  336. * Return: 0 on %SCSI_ADAPTER_RESET, -%EOPNOTSUPP otherwise.
  337. *
  338. * This is similar to zfcp_sysfs_adapter_failed_store().
  339. */
  340. static int zfcp_scsi_sysfs_host_reset(struct Scsi_Host *shost, int reset_type)
  341. {
  342. struct zfcp_adapter *adapter =
  343. (struct zfcp_adapter *)shost->hostdata[0];
  344. int ret = 0;
  345. if (reset_type != SCSI_ADAPTER_RESET) {
  346. ret = -EOPNOTSUPP;
  347. zfcp_dbf_scsi_eh("scshr_n", adapter, ~0, ret);
  348. return ret;
  349. }
  350. zfcp_erp_adapter_reset_sync(adapter, "scshr_y");
  351. return ret;
  352. }
  353. struct scsi_transport_template *zfcp_scsi_transport_template;
  354. static struct scsi_host_template zfcp_scsi_host_template = {
  355. .module = THIS_MODULE,
  356. .name = "zfcp",
  357. .queuecommand = zfcp_scsi_queuecommand,
  358. .eh_timed_out = fc_eh_timed_out,
  359. .eh_abort_handler = zfcp_scsi_eh_abort_handler,
  360. .eh_device_reset_handler = zfcp_scsi_eh_device_reset_handler,
  361. .eh_target_reset_handler = zfcp_scsi_eh_target_reset_handler,
  362. .eh_host_reset_handler = zfcp_scsi_eh_host_reset_handler,
  363. .slave_alloc = zfcp_scsi_slave_alloc,
  364. .slave_configure = zfcp_scsi_slave_configure,
  365. .slave_destroy = zfcp_scsi_slave_destroy,
  366. .change_queue_depth = scsi_change_queue_depth,
  367. .host_reset = zfcp_scsi_sysfs_host_reset,
  368. .proc_name = "zfcp",
  369. .can_queue = 4096,
  370. .this_id = -1,
  371. .sg_tablesize = (((QDIO_MAX_ELEMENTS_PER_BUFFER - 1)
  372. * ZFCP_QDIO_MAX_SBALS_PER_REQ) - 2),
  373. /* GCD, adjusted later */
  374. .max_sectors = (((QDIO_MAX_ELEMENTS_PER_BUFFER - 1)
  375. * ZFCP_QDIO_MAX_SBALS_PER_REQ) - 2) * 8,
  376. /* GCD, adjusted later */
  377. /* report size limit per scatter-gather segment */
  378. .max_segment_size = ZFCP_QDIO_SBALE_LEN,
  379. .dma_boundary = ZFCP_QDIO_SBALE_LEN - 1,
  380. .shost_attrs = zfcp_sysfs_shost_attrs,
  381. .sdev_attrs = zfcp_sysfs_sdev_attrs,
  382. .track_queue_depth = 1,
  383. .supported_mode = MODE_INITIATOR,
  384. };
  385. /**
  386. * zfcp_scsi_adapter_register() - Allocate and register SCSI and FC host with
  387. * SCSI midlayer
  388. * @adapter: The zfcp adapter to register with the SCSI midlayer
  389. *
  390. * Allocates the SCSI host object for the given adapter, sets basic properties
  391. * (such as the transport template, QDIO limits, ...), and registers it with
  392. * the midlayer.
  393. *
  394. * During registration with the midlayer the corresponding FC host object for
  395. * the referenced transport class is also implicitely allocated.
  396. *
  397. * Upon success adapter->scsi_host is set, and upon failure it remains NULL. If
  398. * adapter->scsi_host is already set, nothing is done.
  399. *
  400. * Return:
  401. * * 0 - Allocation and registration was successful
  402. * * -EEXIST - SCSI and FC host did already exist, nothing was done, nothing
  403. * was changed
  404. * * -EIO - Allocation or registration failed
  405. */
  406. int zfcp_scsi_adapter_register(struct zfcp_adapter *adapter)
  407. {
  408. struct ccw_dev_id dev_id;
  409. if (adapter->scsi_host)
  410. return -EEXIST;
  411. ccw_device_get_id(adapter->ccw_device, &dev_id);
  412. /* register adapter as SCSI host with mid layer of SCSI stack */
  413. adapter->scsi_host = scsi_host_alloc(&zfcp_scsi_host_template,
  414. sizeof (struct zfcp_adapter *));
  415. if (!adapter->scsi_host)
  416. goto err_out;
  417. /* tell the SCSI stack some characteristics of this adapter */
  418. adapter->scsi_host->max_id = 511;
  419. adapter->scsi_host->max_lun = 0xFFFFFFFF;
  420. adapter->scsi_host->max_channel = 0;
  421. adapter->scsi_host->unique_id = dev_id.devno;
  422. adapter->scsi_host->max_cmd_len = 16; /* in struct fcp_cmnd */
  423. adapter->scsi_host->transportt = zfcp_scsi_transport_template;
  424. /* make all basic properties known at registration time */
  425. zfcp_qdio_shost_update(adapter, adapter->qdio);
  426. zfcp_scsi_set_prot(adapter);
  427. adapter->scsi_host->hostdata[0] = (unsigned long) adapter;
  428. if (scsi_add_host(adapter->scsi_host, &adapter->ccw_device->dev)) {
  429. scsi_host_put(adapter->scsi_host);
  430. goto err_out;
  431. }
  432. return 0;
  433. err_out:
  434. adapter->scsi_host = NULL;
  435. dev_err(&adapter->ccw_device->dev,
  436. "Registering the FCP device with the SCSI stack failed\n");
  437. return -EIO;
  438. }
  439. /**
  440. * zfcp_scsi_adapter_unregister - Unregister SCSI and FC host from SCSI midlayer
  441. * @adapter: The zfcp adapter to unregister.
  442. */
  443. void zfcp_scsi_adapter_unregister(struct zfcp_adapter *adapter)
  444. {
  445. struct Scsi_Host *shost;
  446. struct zfcp_port *port;
  447. shost = adapter->scsi_host;
  448. if (!shost)
  449. return;
  450. read_lock_irq(&adapter->port_list_lock);
  451. list_for_each_entry(port, &adapter->port_list, list)
  452. port->rport = NULL;
  453. read_unlock_irq(&adapter->port_list_lock);
  454. fc_remove_host(shost);
  455. scsi_remove_host(shost);
  456. scsi_host_put(shost);
  457. adapter->scsi_host = NULL;
  458. }
  459. static struct fc_host_statistics*
  460. zfcp_scsi_init_fc_host_stats(struct zfcp_adapter *adapter)
  461. {
  462. struct fc_host_statistics *fc_stats;
  463. if (!adapter->fc_stats) {
  464. fc_stats = kmalloc(sizeof(*fc_stats), GFP_KERNEL);
  465. if (!fc_stats)
  466. return NULL;
  467. adapter->fc_stats = fc_stats; /* freed in adapter_release */
  468. }
  469. memset(adapter->fc_stats, 0, sizeof(*adapter->fc_stats));
  470. return adapter->fc_stats;
  471. }
  472. static void zfcp_scsi_adjust_fc_host_stats(struct fc_host_statistics *fc_stats,
  473. struct fsf_qtcb_bottom_port *data,
  474. struct fsf_qtcb_bottom_port *old)
  475. {
  476. fc_stats->seconds_since_last_reset =
  477. data->seconds_since_last_reset - old->seconds_since_last_reset;
  478. fc_stats->tx_frames = data->tx_frames - old->tx_frames;
  479. fc_stats->tx_words = data->tx_words - old->tx_words;
  480. fc_stats->rx_frames = data->rx_frames - old->rx_frames;
  481. fc_stats->rx_words = data->rx_words - old->rx_words;
  482. fc_stats->lip_count = data->lip - old->lip;
  483. fc_stats->nos_count = data->nos - old->nos;
  484. fc_stats->error_frames = data->error_frames - old->error_frames;
  485. fc_stats->dumped_frames = data->dumped_frames - old->dumped_frames;
  486. fc_stats->link_failure_count = data->link_failure - old->link_failure;
  487. fc_stats->loss_of_sync_count = data->loss_of_sync - old->loss_of_sync;
  488. fc_stats->loss_of_signal_count =
  489. data->loss_of_signal - old->loss_of_signal;
  490. fc_stats->prim_seq_protocol_err_count =
  491. data->psp_error_counts - old->psp_error_counts;
  492. fc_stats->invalid_tx_word_count =
  493. data->invalid_tx_words - old->invalid_tx_words;
  494. fc_stats->invalid_crc_count = data->invalid_crcs - old->invalid_crcs;
  495. fc_stats->fcp_input_requests =
  496. data->input_requests - old->input_requests;
  497. fc_stats->fcp_output_requests =
  498. data->output_requests - old->output_requests;
  499. fc_stats->fcp_control_requests =
  500. data->control_requests - old->control_requests;
  501. fc_stats->fcp_input_megabytes = data->input_mb - old->input_mb;
  502. fc_stats->fcp_output_megabytes = data->output_mb - old->output_mb;
  503. }
  504. static void zfcp_scsi_set_fc_host_stats(struct fc_host_statistics *fc_stats,
  505. struct fsf_qtcb_bottom_port *data)
  506. {
  507. fc_stats->seconds_since_last_reset = data->seconds_since_last_reset;
  508. fc_stats->tx_frames = data->tx_frames;
  509. fc_stats->tx_words = data->tx_words;
  510. fc_stats->rx_frames = data->rx_frames;
  511. fc_stats->rx_words = data->rx_words;
  512. fc_stats->lip_count = data->lip;
  513. fc_stats->nos_count = data->nos;
  514. fc_stats->error_frames = data->error_frames;
  515. fc_stats->dumped_frames = data->dumped_frames;
  516. fc_stats->link_failure_count = data->link_failure;
  517. fc_stats->loss_of_sync_count = data->loss_of_sync;
  518. fc_stats->loss_of_signal_count = data->loss_of_signal;
  519. fc_stats->prim_seq_protocol_err_count = data->psp_error_counts;
  520. fc_stats->invalid_tx_word_count = data->invalid_tx_words;
  521. fc_stats->invalid_crc_count = data->invalid_crcs;
  522. fc_stats->fcp_input_requests = data->input_requests;
  523. fc_stats->fcp_output_requests = data->output_requests;
  524. fc_stats->fcp_control_requests = data->control_requests;
  525. fc_stats->fcp_input_megabytes = data->input_mb;
  526. fc_stats->fcp_output_megabytes = data->output_mb;
  527. }
  528. static struct fc_host_statistics *
  529. zfcp_scsi_get_fc_host_stats(struct Scsi_Host *host)
  530. {
  531. struct zfcp_adapter *adapter;
  532. struct fc_host_statistics *fc_stats;
  533. struct fsf_qtcb_bottom_port *data;
  534. int ret;
  535. adapter = (struct zfcp_adapter *)host->hostdata[0];
  536. fc_stats = zfcp_scsi_init_fc_host_stats(adapter);
  537. if (!fc_stats)
  538. return NULL;
  539. data = kzalloc(sizeof(*data), GFP_KERNEL);
  540. if (!data)
  541. return NULL;
  542. ret = zfcp_fsf_exchange_port_data_sync(adapter->qdio, data);
  543. if (ret != 0 && ret != -EAGAIN) {
  544. kfree(data);
  545. return NULL;
  546. }
  547. if (adapter->stats_reset &&
  548. ((jiffies/HZ - adapter->stats_reset) <
  549. data->seconds_since_last_reset))
  550. zfcp_scsi_adjust_fc_host_stats(fc_stats, data,
  551. adapter->stats_reset_data);
  552. else
  553. zfcp_scsi_set_fc_host_stats(fc_stats, data);
  554. kfree(data);
  555. return fc_stats;
  556. }
  557. static void zfcp_scsi_reset_fc_host_stats(struct Scsi_Host *shost)
  558. {
  559. struct zfcp_adapter *adapter;
  560. struct fsf_qtcb_bottom_port *data;
  561. int ret;
  562. adapter = (struct zfcp_adapter *)shost->hostdata[0];
  563. data = kzalloc(sizeof(*data), GFP_KERNEL);
  564. if (!data)
  565. return;
  566. ret = zfcp_fsf_exchange_port_data_sync(adapter->qdio, data);
  567. if (ret != 0 && ret != -EAGAIN)
  568. kfree(data);
  569. else {
  570. adapter->stats_reset = jiffies/HZ;
  571. kfree(adapter->stats_reset_data);
  572. adapter->stats_reset_data = data; /* finally freed in
  573. adapter_release */
  574. }
  575. }
  576. static void zfcp_scsi_get_host_port_state(struct Scsi_Host *shost)
  577. {
  578. struct zfcp_adapter *adapter =
  579. (struct zfcp_adapter *)shost->hostdata[0];
  580. int status = atomic_read(&adapter->status);
  581. if ((status & ZFCP_STATUS_COMMON_RUNNING) &&
  582. !(status & ZFCP_STATUS_ADAPTER_LINK_UNPLUGGED))
  583. fc_host_port_state(shost) = FC_PORTSTATE_ONLINE;
  584. else if (status & ZFCP_STATUS_ADAPTER_LINK_UNPLUGGED)
  585. fc_host_port_state(shost) = FC_PORTSTATE_LINKDOWN;
  586. else if (status & ZFCP_STATUS_COMMON_ERP_FAILED)
  587. fc_host_port_state(shost) = FC_PORTSTATE_ERROR;
  588. else
  589. fc_host_port_state(shost) = FC_PORTSTATE_UNKNOWN;
  590. }
  591. static void zfcp_scsi_set_rport_dev_loss_tmo(struct fc_rport *rport,
  592. u32 timeout)
  593. {
  594. rport->dev_loss_tmo = timeout;
  595. }
  596. /**
  597. * zfcp_scsi_terminate_rport_io - Terminate all I/O on a rport
  598. * @rport: The FC rport where to teminate I/O
  599. *
  600. * Abort all pending SCSI commands for a port by closing the
  601. * port. Using a reopen avoids a conflict with a shutdown
  602. * overwriting a reopen. The "forced" ensures that a disappeared port
  603. * is not opened again as valid due to the cached plogi data in
  604. * non-NPIV mode.
  605. */
  606. static void zfcp_scsi_terminate_rport_io(struct fc_rport *rport)
  607. {
  608. struct zfcp_port *port;
  609. struct Scsi_Host *shost = rport_to_shost(rport);
  610. struct zfcp_adapter *adapter =
  611. (struct zfcp_adapter *)shost->hostdata[0];
  612. port = zfcp_get_port_by_wwpn(adapter, rport->port_name);
  613. if (port) {
  614. zfcp_erp_port_forced_reopen(port, 0, "sctrpi1");
  615. put_device(&port->dev);
  616. } else {
  617. zfcp_erp_port_forced_no_port_dbf(
  618. "sctrpin", adapter,
  619. rport->port_name /* zfcp_scsi_rport_register */,
  620. rport->port_id /* zfcp_scsi_rport_register */);
  621. }
  622. }
  623. static void zfcp_scsi_rport_register(struct zfcp_port *port)
  624. {
  625. struct fc_rport_identifiers ids;
  626. struct fc_rport *rport;
  627. if (port->rport)
  628. return;
  629. ids.node_name = port->wwnn;
  630. ids.port_name = port->wwpn;
  631. ids.port_id = port->d_id;
  632. ids.roles = FC_RPORT_ROLE_FCP_TARGET;
  633. zfcp_dbf_rec_trig_lock("scpaddy", port->adapter, port, NULL,
  634. ZFCP_PSEUDO_ERP_ACTION_RPORT_ADD,
  635. ZFCP_PSEUDO_ERP_ACTION_RPORT_ADD);
  636. rport = fc_remote_port_add(port->adapter->scsi_host, 0, &ids);
  637. if (!rport) {
  638. dev_err(&port->adapter->ccw_device->dev,
  639. "Registering port 0x%016Lx failed\n",
  640. (unsigned long long)port->wwpn);
  641. return;
  642. }
  643. rport->maxframe_size = port->maxframe_size;
  644. rport->supported_classes = port->supported_classes;
  645. port->rport = rport;
  646. port->starget_id = rport->scsi_target_id;
  647. zfcp_unit_queue_scsi_scan(port);
  648. }
  649. static void zfcp_scsi_rport_block(struct zfcp_port *port)
  650. {
  651. struct fc_rport *rport = port->rport;
  652. if (rport) {
  653. zfcp_dbf_rec_trig_lock("scpdely", port->adapter, port, NULL,
  654. ZFCP_PSEUDO_ERP_ACTION_RPORT_DEL,
  655. ZFCP_PSEUDO_ERP_ACTION_RPORT_DEL);
  656. fc_remote_port_delete(rport);
  657. port->rport = NULL;
  658. }
  659. }
  660. void zfcp_scsi_schedule_rport_register(struct zfcp_port *port)
  661. {
  662. get_device(&port->dev);
  663. port->rport_task = RPORT_ADD;
  664. if (!queue_work(port->adapter->work_queue, &port->rport_work))
  665. put_device(&port->dev);
  666. }
  667. void zfcp_scsi_schedule_rport_block(struct zfcp_port *port)
  668. {
  669. get_device(&port->dev);
  670. port->rport_task = RPORT_DEL;
  671. if (port->rport && queue_work(port->adapter->work_queue,
  672. &port->rport_work))
  673. return;
  674. put_device(&port->dev);
  675. }
  676. void zfcp_scsi_schedule_rports_block(struct zfcp_adapter *adapter)
  677. {
  678. unsigned long flags;
  679. struct zfcp_port *port;
  680. read_lock_irqsave(&adapter->port_list_lock, flags);
  681. list_for_each_entry(port, &adapter->port_list, list)
  682. zfcp_scsi_schedule_rport_block(port);
  683. read_unlock_irqrestore(&adapter->port_list_lock, flags);
  684. }
  685. void zfcp_scsi_rport_work(struct work_struct *work)
  686. {
  687. struct zfcp_port *port = container_of(work, struct zfcp_port,
  688. rport_work);
  689. set_worker_desc("zrp%c-%16llx",
  690. (port->rport_task == RPORT_ADD) ? 'a' : 'd',
  691. port->wwpn); /* < WORKER_DESC_LEN=24 */
  692. while (port->rport_task) {
  693. if (port->rport_task == RPORT_ADD) {
  694. port->rport_task = RPORT_NONE;
  695. zfcp_scsi_rport_register(port);
  696. } else {
  697. port->rport_task = RPORT_NONE;
  698. zfcp_scsi_rport_block(port);
  699. }
  700. }
  701. put_device(&port->dev);
  702. }
  703. /**
  704. * zfcp_scsi_set_prot - Configure DIF/DIX support in scsi_host
  705. * @adapter: The adapter where to configure DIF/DIX for the SCSI host
  706. */
  707. void zfcp_scsi_set_prot(struct zfcp_adapter *adapter)
  708. {
  709. unsigned int mask = 0;
  710. unsigned int data_div;
  711. struct Scsi_Host *shost = adapter->scsi_host;
  712. data_div = atomic_read(&adapter->status) &
  713. ZFCP_STATUS_ADAPTER_DATA_DIV_ENABLED;
  714. if ((enable_dif || zfcp_experimental_dix) &&
  715. adapter->adapter_features & FSF_FEATURE_DIF_PROT_TYPE1)
  716. mask |= SHOST_DIF_TYPE1_PROTECTION;
  717. if (zfcp_experimental_dix && data_div &&
  718. adapter->adapter_features & FSF_FEATURE_DIX_PROT_TCPIP) {
  719. mask |= SHOST_DIX_TYPE1_PROTECTION;
  720. scsi_host_set_guard(shost, SHOST_DIX_GUARD_IP);
  721. shost->sg_prot_tablesize = adapter->qdio->max_sbale_per_req / 2;
  722. shost->sg_tablesize = adapter->qdio->max_sbale_per_req / 2;
  723. shost->max_sectors = shost->sg_tablesize * 8;
  724. }
  725. scsi_host_set_prot(shost, mask);
  726. }
  727. /**
  728. * zfcp_scsi_dif_sense_error - Report DIF/DIX error as driver sense error
  729. * @scmd: The SCSI command to report the error for
  730. * @ascq: The ASCQ to put in the sense buffer
  731. *
  732. * See the error handling in sd_done for the sense codes used here.
  733. * Set DID_SOFT_ERROR to retry the request, if possible.
  734. */
  735. void zfcp_scsi_dif_sense_error(struct scsi_cmnd *scmd, int ascq)
  736. {
  737. scsi_build_sense_buffer(1, scmd->sense_buffer,
  738. ILLEGAL_REQUEST, 0x10, ascq);
  739. set_driver_byte(scmd, DRIVER_SENSE);
  740. scmd->result |= SAM_STAT_CHECK_CONDITION;
  741. set_host_byte(scmd, DID_SOFT_ERROR);
  742. }
  743. void zfcp_scsi_shost_update_config_data(
  744. struct zfcp_adapter *const adapter,
  745. const struct fsf_qtcb_bottom_config *const bottom,
  746. const bool bottom_incomplete)
  747. {
  748. struct Scsi_Host *const shost = adapter->scsi_host;
  749. const struct fc_els_flogi *nsp, *plogi;
  750. if (shost == NULL)
  751. return;
  752. snprintf(fc_host_firmware_version(shost), FC_VERSION_STRING_SIZE,
  753. "0x%08x", bottom->lic_version);
  754. if (adapter->adapter_features & FSF_FEATURE_HBAAPI_MANAGEMENT) {
  755. snprintf(fc_host_hardware_version(shost),
  756. FC_VERSION_STRING_SIZE,
  757. "0x%08x", bottom->hardware_version);
  758. memcpy(fc_host_serial_number(shost), bottom->serial_number,
  759. min(FC_SERIAL_NUMBER_SIZE, 17));
  760. EBCASC(fc_host_serial_number(shost),
  761. min(FC_SERIAL_NUMBER_SIZE, 17));
  762. }
  763. /* adjust pointers for missing command code */
  764. nsp = (struct fc_els_flogi *) ((u8 *)&bottom->nport_serv_param
  765. - sizeof(u32));
  766. plogi = (struct fc_els_flogi *) ((u8 *)&bottom->plogi_payload
  767. - sizeof(u32));
  768. snprintf(fc_host_manufacturer(shost), FC_SERIAL_NUMBER_SIZE, "%s",
  769. "IBM");
  770. fc_host_port_name(shost) = be64_to_cpu(nsp->fl_wwpn);
  771. fc_host_node_name(shost) = be64_to_cpu(nsp->fl_wwnn);
  772. fc_host_supported_classes(shost) = FC_COS_CLASS2 | FC_COS_CLASS3;
  773. zfcp_scsi_set_prot(adapter);
  774. /* do not evaluate invalid fields */
  775. if (bottom_incomplete)
  776. return;
  777. fc_host_port_id(shost) = ntoh24(bottom->s_id);
  778. fc_host_speed(shost) =
  779. zfcp_fsf_convert_portspeed(bottom->fc_link_speed);
  780. snprintf(fc_host_model(shost), FC_SYMBOLIC_NAME_SIZE, "0x%04x",
  781. bottom->adapter_type);
  782. switch (bottom->fc_topology) {
  783. case FSF_TOPO_P2P:
  784. fc_host_port_type(shost) = FC_PORTTYPE_PTP;
  785. fc_host_fabric_name(shost) = 0;
  786. break;
  787. case FSF_TOPO_FABRIC:
  788. fc_host_fabric_name(shost) = be64_to_cpu(plogi->fl_wwnn);
  789. if (bottom->connection_features & FSF_FEATURE_NPIV_MODE)
  790. fc_host_port_type(shost) = FC_PORTTYPE_NPIV;
  791. else
  792. fc_host_port_type(shost) = FC_PORTTYPE_NPORT;
  793. break;
  794. case FSF_TOPO_AL:
  795. fc_host_port_type(shost) = FC_PORTTYPE_NLPORT;
  796. fallthrough;
  797. default:
  798. fc_host_fabric_name(shost) = 0;
  799. break;
  800. }
  801. }
  802. void zfcp_scsi_shost_update_port_data(
  803. struct zfcp_adapter *const adapter,
  804. const struct fsf_qtcb_bottom_port *const bottom)
  805. {
  806. struct Scsi_Host *const shost = adapter->scsi_host;
  807. if (shost == NULL)
  808. return;
  809. fc_host_permanent_port_name(shost) = bottom->wwpn;
  810. fc_host_maxframe_size(shost) = bottom->maximum_frame_size;
  811. fc_host_supported_speeds(shost) =
  812. zfcp_fsf_convert_portspeed(bottom->supported_speed);
  813. memcpy(fc_host_supported_fc4s(shost), bottom->supported_fc4_types,
  814. FC_FC4_LIST_SIZE);
  815. memcpy(fc_host_active_fc4s(shost), bottom->active_fc4_types,
  816. FC_FC4_LIST_SIZE);
  817. }
  818. struct fc_function_template zfcp_transport_functions = {
  819. .show_starget_port_id = 1,
  820. .show_starget_port_name = 1,
  821. .show_starget_node_name = 1,
  822. .show_rport_supported_classes = 1,
  823. .show_rport_maxframe_size = 1,
  824. .show_rport_dev_loss_tmo = 1,
  825. .show_host_node_name = 1,
  826. .show_host_port_name = 1,
  827. .show_host_permanent_port_name = 1,
  828. .show_host_supported_classes = 1,
  829. .show_host_supported_fc4s = 1,
  830. .show_host_supported_speeds = 1,
  831. .show_host_maxframe_size = 1,
  832. .show_host_serial_number = 1,
  833. .show_host_manufacturer = 1,
  834. .show_host_model = 1,
  835. .show_host_hardware_version = 1,
  836. .show_host_firmware_version = 1,
  837. .get_fc_host_stats = zfcp_scsi_get_fc_host_stats,
  838. .reset_fc_host_stats = zfcp_scsi_reset_fc_host_stats,
  839. .set_rport_dev_loss_tmo = zfcp_scsi_set_rport_dev_loss_tmo,
  840. .get_host_port_state = zfcp_scsi_get_host_port_state,
  841. .terminate_rport_io = zfcp_scsi_terminate_rport_io,
  842. .show_host_port_state = 1,
  843. .show_host_active_fc4s = 1,
  844. .bsg_request = zfcp_fc_exec_bsg_job,
  845. .bsg_timeout = zfcp_fc_timeout_bsg_job,
  846. /* no functions registered for following dynamic attributes but
  847. directly set by LLDD */
  848. .show_host_port_type = 1,
  849. .show_host_symbolic_name = 1,
  850. .show_host_speed = 1,
  851. .show_host_port_id = 1,
  852. .show_host_fabric_name = 1,
  853. .dd_bsg_size = sizeof(struct zfcp_fsf_ct_els),
  854. };