sas_scsi_host.c 28 KB

12345678910111213141516171819202122232425262728293031323334353637383940414243444546474849505152535455565758596061626364656667686970717273747576777879808182838485868788899091929394959697989910010110210310410510610710810911011111211311411511611711811912012112212312412512612712812913013113213313413513613713813914014114214314414514614714814915015115215315415515615715815916016116216316416516616716816917017117217317417517617717817918018118218318418518618718818919019119219319419519619719819920020120220320420520620720820921021121221321421521621721821922022122222322422522622722822923023123223323423523623723823924024124224324424524624724824925025125225325425525625725825926026126226326426526626726826927027127227327427527627727827928028128228328428528628728828929029129229329429529629729829930030130230330430530630730830931031131231331431531631731831932032132232332432532632732832933033133233333433533633733833934034134234334434534634734834935035135235335435535635735835936036136236336436536636736836937037137237337437537637737837938038138238338438538638738838939039139239339439539639739839940040140240340440540640740840941041141241341441541641741841942042142242342442542642742842943043143243343443543643743843944044144244344444544644744844945045145245345445545645745845946046146246346446546646746846947047147247347447547647747847948048148248348448548648748848949049149249349449549649749849950050150250350450550650750850951051151251351451551651751851952052152252352452552652752852953053153253353453553653753853954054154254354454554654754854955055155255355455555655755855956056156256356456556656756856957057157257357457557657757857958058158258358458558658758858959059159259359459559659759859960060160260360460560660760860961061161261361461561661761861962062162262362462562662762862963063163263363463563663763863964064164264364464564664764864965065165265365465565665765865966066166266366466566666766866967067167267367467567667767867968068168268368468568668768868969069169269369469569669769869970070170270370470570670770870971071171271371471571671771871972072172272372472572672772872973073173273373473573673773873974074174274374474574674774874975075175275375475575675775875976076176276376476576676776876977077177277377477577677777877978078178278378478578678778878979079179279379479579679779879980080180280380480580680780880981081181281381481581681781881982082182282382482582682782882983083183283383483583683783883984084184284384484584684784884985085185285385485585685785885986086186286386486586686786886987087187287387487587687787887988088188288388488588688788888989089189289389489589689789889990090190290390490590690790890991091191291391491591691791891992092192292392492592692792892993093193293393493593693793893994094194294394494594694794894995095195295395495595695795895996096196296396496596696796896997097197297397497597697797897998098198298398498598698798898999099199299399499599699799899910001001100210031004100510061007100810091010101110121013101410151016101710181019102010211022102310241025102610271028102910301031103210331034103510361037103810391040104110421043104410451046104710481049105010511052105310541055105610571058105910601061106210631064106510661067106810691070107110721073107410751076107710781079108010811082108310841085
  1. /*
  2. * Serial Attached SCSI (SAS) class SCSI Host glue.
  3. *
  4. * Copyright (C) 2005 Adaptec, Inc. All rights reserved.
  5. * Copyright (C) 2005 Luben Tuikov <luben_tuikov@adaptec.com>
  6. *
  7. * This file is licensed under GPLv2.
  8. *
  9. * This program is free software; you can redistribute it and/or
  10. * modify it under the terms of the GNU General Public License as
  11. * published by the Free Software Foundation; either version 2 of the
  12. * License, or (at your option) any later version.
  13. *
  14. * This program is distributed in the hope that it will be useful, but
  15. * WITHOUT ANY WARRANTY; without even the implied warranty of
  16. * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
  17. * General Public License for more details.
  18. *
  19. * You should have received a copy of the GNU General Public License
  20. * along with this program; if not, write to the Free Software
  21. * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307
  22. * USA
  23. *
  24. */
  25. #include <linux/kthread.h>
  26. #include "sas_internal.h"
  27. #include <scsi/scsi_host.h>
  28. #include <scsi/scsi_device.h>
  29. #include <scsi/scsi_tcq.h>
  30. #include <scsi/scsi.h>
  31. #include <scsi/scsi_eh.h>
  32. #include <scsi/scsi_transport.h>
  33. #include <scsi/scsi_transport_sas.h>
  34. #include <scsi/sas_ata.h>
  35. #include "../scsi_sas_internal.h"
  36. #include "../scsi_transport_api.h"
  37. #include "../scsi_priv.h"
  38. #include <linux/err.h>
  39. #include <linux/blkdev.h>
  40. #include <linux/freezer.h>
  41. #include <linux/scatterlist.h>
  42. #include <linux/libata.h>
  43. /* ---------- SCSI Host glue ---------- */
  44. static void sas_scsi_task_done(struct sas_task *task)
  45. {
  46. struct task_status_struct *ts = &task->task_status;
  47. struct scsi_cmnd *sc = task->uldd_task;
  48. int hs = 0, stat = 0;
  49. if (unlikely(task->task_state_flags & SAS_TASK_STATE_ABORTED)) {
  50. /* Aborted tasks will be completed by the error handler */
  51. SAS_DPRINTK("task done but aborted\n");
  52. return;
  53. }
  54. if (unlikely(!sc)) {
  55. SAS_DPRINTK("task_done called with non existing SCSI cmnd!\n");
  56. list_del_init(&task->list);
  57. sas_free_task(task);
  58. return;
  59. }
  60. if (ts->resp == SAS_TASK_UNDELIVERED) {
  61. /* transport error */
  62. hs = DID_NO_CONNECT;
  63. } else { /* ts->resp == SAS_TASK_COMPLETE */
  64. /* task delivered, what happened afterwards? */
  65. switch (ts->stat) {
  66. case SAS_DEV_NO_RESPONSE:
  67. case SAS_INTERRUPTED:
  68. case SAS_PHY_DOWN:
  69. case SAS_NAK_R_ERR:
  70. case SAS_OPEN_TO:
  71. hs = DID_NO_CONNECT;
  72. break;
  73. case SAS_DATA_UNDERRUN:
  74. scsi_set_resid(sc, ts->residual);
  75. if (scsi_bufflen(sc) - scsi_get_resid(sc) < sc->underflow)
  76. hs = DID_ERROR;
  77. break;
  78. case SAS_DATA_OVERRUN:
  79. hs = DID_ERROR;
  80. break;
  81. case SAS_QUEUE_FULL:
  82. hs = DID_SOFT_ERROR; /* retry */
  83. break;
  84. case SAS_DEVICE_UNKNOWN:
  85. hs = DID_BAD_TARGET;
  86. break;
  87. case SAS_SG_ERR:
  88. hs = DID_PARITY;
  89. break;
  90. case SAS_OPEN_REJECT:
  91. if (ts->open_rej_reason == SAS_OREJ_RSVD_RETRY)
  92. hs = DID_SOFT_ERROR; /* retry */
  93. else
  94. hs = DID_ERROR;
  95. break;
  96. case SAS_PROTO_RESPONSE:
  97. SAS_DPRINTK("LLDD:%s sent SAS_PROTO_RESP for an SSP "
  98. "task; please report this\n",
  99. task->dev->port->ha->sas_ha_name);
  100. break;
  101. case SAS_ABORTED_TASK:
  102. hs = DID_ABORT;
  103. break;
  104. case SAM_CHECK_COND:
  105. memcpy(sc->sense_buffer, ts->buf,
  106. min(SCSI_SENSE_BUFFERSIZE, ts->buf_valid_size));
  107. stat = SAM_CHECK_COND;
  108. break;
  109. default:
  110. stat = ts->stat;
  111. break;
  112. }
  113. }
  114. ASSIGN_SAS_TASK(sc, NULL);
  115. sc->result = (hs << 16) | stat;
  116. list_del_init(&task->list);
  117. sas_free_task(task);
  118. sc->scsi_done(sc);
  119. }
  120. static enum task_attribute sas_scsi_get_task_attr(struct scsi_cmnd *cmd)
  121. {
  122. enum task_attribute ta = TASK_ATTR_SIMPLE;
  123. if (cmd->request && blk_rq_tagged(cmd->request)) {
  124. if (cmd->device->ordered_tags &&
  125. (cmd->request->cmd_flags & REQ_HARDBARRIER))
  126. ta = TASK_ATTR_ORDERED;
  127. }
  128. return ta;
  129. }
  130. static struct sas_task *sas_create_task(struct scsi_cmnd *cmd,
  131. struct domain_device *dev,
  132. gfp_t gfp_flags)
  133. {
  134. struct sas_task *task = sas_alloc_task(gfp_flags);
  135. struct scsi_lun lun;
  136. if (!task)
  137. return NULL;
  138. task->uldd_task = cmd;
  139. ASSIGN_SAS_TASK(cmd, task);
  140. task->dev = dev;
  141. task->task_proto = task->dev->tproto; /* BUG_ON(!SSP) */
  142. task->ssp_task.retry_count = 1;
  143. int_to_scsilun(cmd->device->lun, &lun);
  144. memcpy(task->ssp_task.LUN, &lun.scsi_lun, 8);
  145. task->ssp_task.task_attr = sas_scsi_get_task_attr(cmd);
  146. memcpy(task->ssp_task.cdb, cmd->cmnd, 16);
  147. task->scatter = scsi_sglist(cmd);
  148. task->num_scatter = scsi_sg_count(cmd);
  149. task->total_xfer_len = scsi_bufflen(cmd);
  150. task->data_dir = cmd->sc_data_direction;
  151. task->task_done = sas_scsi_task_done;
  152. return task;
  153. }
  154. int sas_queue_up(struct sas_task *task)
  155. {
  156. struct sas_ha_struct *sas_ha = task->dev->port->ha;
  157. struct scsi_core *core = &sas_ha->core;
  158. unsigned long flags;
  159. LIST_HEAD(list);
  160. spin_lock_irqsave(&core->task_queue_lock, flags);
  161. if (sas_ha->lldd_queue_size < core->task_queue_size + 1) {
  162. spin_unlock_irqrestore(&core->task_queue_lock, flags);
  163. return -SAS_QUEUE_FULL;
  164. }
  165. list_add_tail(&task->list, &core->task_queue);
  166. core->task_queue_size += 1;
  167. spin_unlock_irqrestore(&core->task_queue_lock, flags);
  168. wake_up_process(core->queue_thread);
  169. return 0;
  170. }
  171. /**
  172. * sas_queuecommand -- Enqueue a command for processing
  173. * @parameters: See SCSI Core documentation
  174. *
  175. * Note: XXX: Remove the host unlock/lock pair when SCSI Core can
  176. * call us without holding an IRQ spinlock...
  177. */
  178. int sas_queuecommand(struct scsi_cmnd *cmd,
  179. void (*scsi_done)(struct scsi_cmnd *))
  180. __releases(host->host_lock)
  181. __acquires(dev->sata_dev.ap->lock)
  182. __releases(dev->sata_dev.ap->lock)
  183. __acquires(host->host_lock)
  184. {
  185. int res = 0;
  186. struct domain_device *dev = cmd_to_domain_dev(cmd);
  187. struct Scsi_Host *host = cmd->device->host;
  188. struct sas_internal *i = to_sas_internal(host->transportt);
  189. spin_unlock_irq(host->host_lock);
  190. {
  191. struct sas_ha_struct *sas_ha = dev->port->ha;
  192. struct sas_task *task;
  193. if (dev_is_sata(dev)) {
  194. unsigned long flags;
  195. spin_lock_irqsave(dev->sata_dev.ap->lock, flags);
  196. res = ata_sas_queuecmd(cmd, scsi_done,
  197. dev->sata_dev.ap);
  198. spin_unlock_irqrestore(dev->sata_dev.ap->lock, flags);
  199. goto out;
  200. }
  201. res = -ENOMEM;
  202. task = sas_create_task(cmd, dev, GFP_ATOMIC);
  203. if (!task)
  204. goto out;
  205. cmd->scsi_done = scsi_done;
  206. /* Queue up, Direct Mode or Task Collector Mode. */
  207. if (sas_ha->lldd_max_execute_num < 2)
  208. res = i->dft->lldd_execute_task(task, 1, GFP_ATOMIC);
  209. else
  210. res = sas_queue_up(task);
  211. /* Examine */
  212. if (res) {
  213. SAS_DPRINTK("lldd_execute_task returned: %d\n", res);
  214. ASSIGN_SAS_TASK(cmd, NULL);
  215. sas_free_task(task);
  216. if (res == -SAS_QUEUE_FULL) {
  217. cmd->result = DID_SOFT_ERROR << 16; /* retry */
  218. res = 0;
  219. scsi_done(cmd);
  220. }
  221. goto out;
  222. }
  223. }
  224. out:
  225. spin_lock_irq(host->host_lock);
  226. return res;
  227. }
  228. static void sas_eh_finish_cmd(struct scsi_cmnd *cmd)
  229. {
  230. struct sas_task *task = TO_SAS_TASK(cmd);
  231. struct sas_ha_struct *sas_ha = SHOST_TO_SAS_HA(cmd->device->host);
  232. /* remove the aborted task flag to allow the task to be
  233. * completed now. At this point, we only get called following
  234. * an actual abort of the task, so we should be guaranteed not
  235. * to be racing with any completions from the LLD (hence we
  236. * don't need the task state lock to clear the flag) */
  237. task->task_state_flags &= ~SAS_TASK_STATE_ABORTED;
  238. /* Now call task_done. However, task will be free'd after
  239. * this */
  240. task->task_done(task);
  241. /* now finish the command and move it on to the error
  242. * handler done list, this also takes it off the
  243. * error handler pending list */
  244. scsi_eh_finish_cmd(cmd, &sas_ha->eh_done_q);
  245. }
  246. static void sas_scsi_clear_queue_lu(struct list_head *error_q, struct scsi_cmnd *my_cmd)
  247. {
  248. struct scsi_cmnd *cmd, *n;
  249. list_for_each_entry_safe(cmd, n, error_q, eh_entry) {
  250. if (cmd == my_cmd)
  251. sas_eh_finish_cmd(cmd);
  252. }
  253. }
  254. static void sas_scsi_clear_queue_I_T(struct list_head *error_q,
  255. struct domain_device *dev)
  256. {
  257. struct scsi_cmnd *cmd, *n;
  258. list_for_each_entry_safe(cmd, n, error_q, eh_entry) {
  259. struct domain_device *x = cmd_to_domain_dev(cmd);
  260. if (x == dev)
  261. sas_eh_finish_cmd(cmd);
  262. }
  263. }
  264. static void sas_scsi_clear_queue_port(struct list_head *error_q,
  265. struct asd_sas_port *port)
  266. {
  267. struct scsi_cmnd *cmd, *n;
  268. list_for_each_entry_safe(cmd, n, error_q, eh_entry) {
  269. struct domain_device *dev = cmd_to_domain_dev(cmd);
  270. struct asd_sas_port *x = dev->port;
  271. if (x == port)
  272. sas_eh_finish_cmd(cmd);
  273. }
  274. }
  275. enum task_disposition {
  276. TASK_IS_DONE,
  277. TASK_IS_ABORTED,
  278. TASK_IS_AT_LU,
  279. TASK_IS_NOT_AT_LU,
  280. TASK_ABORT_FAILED,
  281. };
  282. static enum task_disposition sas_scsi_find_task(struct sas_task *task)
  283. {
  284. struct sas_ha_struct *ha = task->dev->port->ha;
  285. unsigned long flags;
  286. int i, res;
  287. struct sas_internal *si =
  288. to_sas_internal(task->dev->port->ha->core.shost->transportt);
  289. if (ha->lldd_max_execute_num > 1) {
  290. struct scsi_core *core = &ha->core;
  291. struct sas_task *t, *n;
  292. spin_lock_irqsave(&core->task_queue_lock, flags);
  293. list_for_each_entry_safe(t, n, &core->task_queue, list) {
  294. if (task == t) {
  295. list_del_init(&t->list);
  296. spin_unlock_irqrestore(&core->task_queue_lock,
  297. flags);
  298. SAS_DPRINTK("%s: task 0x%p aborted from "
  299. "task_queue\n",
  300. __FUNCTION__, task);
  301. return TASK_IS_ABORTED;
  302. }
  303. }
  304. spin_unlock_irqrestore(&core->task_queue_lock, flags);
  305. }
  306. for (i = 0; i < 5; i++) {
  307. SAS_DPRINTK("%s: aborting task 0x%p\n", __FUNCTION__, task);
  308. res = si->dft->lldd_abort_task(task);
  309. spin_lock_irqsave(&task->task_state_lock, flags);
  310. if (task->task_state_flags & SAS_TASK_STATE_DONE) {
  311. spin_unlock_irqrestore(&task->task_state_lock, flags);
  312. SAS_DPRINTK("%s: task 0x%p is done\n", __FUNCTION__,
  313. task);
  314. return TASK_IS_DONE;
  315. }
  316. spin_unlock_irqrestore(&task->task_state_lock, flags);
  317. if (res == TMF_RESP_FUNC_COMPLETE) {
  318. SAS_DPRINTK("%s: task 0x%p is aborted\n",
  319. __FUNCTION__, task);
  320. return TASK_IS_ABORTED;
  321. } else if (si->dft->lldd_query_task) {
  322. SAS_DPRINTK("%s: querying task 0x%p\n",
  323. __FUNCTION__, task);
  324. res = si->dft->lldd_query_task(task);
  325. switch (res) {
  326. case TMF_RESP_FUNC_SUCC:
  327. SAS_DPRINTK("%s: task 0x%p at LU\n",
  328. __FUNCTION__, task);
  329. return TASK_IS_AT_LU;
  330. case TMF_RESP_FUNC_COMPLETE:
  331. SAS_DPRINTK("%s: task 0x%p not at LU\n",
  332. __FUNCTION__, task);
  333. return TASK_IS_NOT_AT_LU;
  334. case TMF_RESP_FUNC_FAILED:
  335. SAS_DPRINTK("%s: task 0x%p failed to abort\n",
  336. __FUNCTION__, task);
  337. return TASK_ABORT_FAILED;
  338. }
  339. }
  340. }
  341. return res;
  342. }
  343. static int sas_recover_lu(struct domain_device *dev, struct scsi_cmnd *cmd)
  344. {
  345. int res = TMF_RESP_FUNC_FAILED;
  346. struct scsi_lun lun;
  347. struct sas_internal *i =
  348. to_sas_internal(dev->port->ha->core.shost->transportt);
  349. int_to_scsilun(cmd->device->lun, &lun);
  350. SAS_DPRINTK("eh: device %llx LUN %x has the task\n",
  351. SAS_ADDR(dev->sas_addr),
  352. cmd->device->lun);
  353. if (i->dft->lldd_abort_task_set)
  354. res = i->dft->lldd_abort_task_set(dev, lun.scsi_lun);
  355. if (res == TMF_RESP_FUNC_FAILED) {
  356. if (i->dft->lldd_clear_task_set)
  357. res = i->dft->lldd_clear_task_set(dev, lun.scsi_lun);
  358. }
  359. if (res == TMF_RESP_FUNC_FAILED) {
  360. if (i->dft->lldd_lu_reset)
  361. res = i->dft->lldd_lu_reset(dev, lun.scsi_lun);
  362. }
  363. return res;
  364. }
  365. static int sas_recover_I_T(struct domain_device *dev)
  366. {
  367. int res = TMF_RESP_FUNC_FAILED;
  368. struct sas_internal *i =
  369. to_sas_internal(dev->port->ha->core.shost->transportt);
  370. SAS_DPRINTK("I_T nexus reset for dev %016llx\n",
  371. SAS_ADDR(dev->sas_addr));
  372. if (i->dft->lldd_I_T_nexus_reset)
  373. res = i->dft->lldd_I_T_nexus_reset(dev);
  374. return res;
  375. }
  376. /* Find the sas_phy that's attached to this device */
  377. static struct sas_phy *find_local_sas_phy(struct domain_device *dev)
  378. {
  379. struct domain_device *pdev = dev->parent;
  380. struct ex_phy *exphy = NULL;
  381. int i;
  382. /* Directly attached device */
  383. if (!pdev)
  384. return dev->port->phy;
  385. /* Otherwise look in the expander */
  386. for (i = 0; i < pdev->ex_dev.num_phys; i++)
  387. if (!memcmp(dev->sas_addr,
  388. pdev->ex_dev.ex_phy[i].attached_sas_addr,
  389. SAS_ADDR_SIZE)) {
  390. exphy = &pdev->ex_dev.ex_phy[i];
  391. break;
  392. }
  393. BUG_ON(!exphy);
  394. return exphy->phy;
  395. }
  396. /* Attempt to send a LUN reset message to a device */
  397. int sas_eh_device_reset_handler(struct scsi_cmnd *cmd)
  398. {
  399. struct domain_device *dev = cmd_to_domain_dev(cmd);
  400. struct sas_internal *i =
  401. to_sas_internal(dev->port->ha->core.shost->transportt);
  402. struct scsi_lun lun;
  403. int res;
  404. int_to_scsilun(cmd->device->lun, &lun);
  405. if (!i->dft->lldd_lu_reset)
  406. return FAILED;
  407. res = i->dft->lldd_lu_reset(dev, lun.scsi_lun);
  408. if (res == TMF_RESP_FUNC_SUCC || res == TMF_RESP_FUNC_COMPLETE)
  409. return SUCCESS;
  410. return FAILED;
  411. }
  412. /* Attempt to send a phy (bus) reset */
  413. int sas_eh_bus_reset_handler(struct scsi_cmnd *cmd)
  414. {
  415. struct domain_device *dev = cmd_to_domain_dev(cmd);
  416. struct sas_phy *phy = find_local_sas_phy(dev);
  417. int res;
  418. res = sas_phy_reset(phy, 1);
  419. if (res)
  420. SAS_DPRINTK("Bus reset of %s failed 0x%x\n",
  421. kobject_name(&phy->dev.kobj),
  422. res);
  423. if (res == TMF_RESP_FUNC_SUCC || res == TMF_RESP_FUNC_COMPLETE)
  424. return SUCCESS;
  425. return FAILED;
  426. }
  427. /* Try to reset a device */
  428. static int try_to_reset_cmd_device(struct Scsi_Host *shost,
  429. struct scsi_cmnd *cmd)
  430. {
  431. int res;
  432. if (!shost->hostt->eh_device_reset_handler)
  433. goto try_bus_reset;
  434. res = shost->hostt->eh_device_reset_handler(cmd);
  435. if (res == SUCCESS)
  436. return res;
  437. try_bus_reset:
  438. if (shost->hostt->eh_bus_reset_handler)
  439. return shost->hostt->eh_bus_reset_handler(cmd);
  440. return FAILED;
  441. }
  442. static int sas_eh_handle_sas_errors(struct Scsi_Host *shost,
  443. struct list_head *work_q,
  444. struct list_head *done_q)
  445. {
  446. struct scsi_cmnd *cmd, *n;
  447. enum task_disposition res = TASK_IS_DONE;
  448. int tmf_resp, need_reset;
  449. struct sas_internal *i = to_sas_internal(shost->transportt);
  450. unsigned long flags;
  451. struct sas_ha_struct *ha = SHOST_TO_SAS_HA(shost);
  452. Again:
  453. list_for_each_entry_safe(cmd, n, work_q, eh_entry) {
  454. struct sas_task *task = TO_SAS_TASK(cmd);
  455. if (!task)
  456. continue;
  457. list_del_init(&cmd->eh_entry);
  458. spin_lock_irqsave(&task->task_state_lock, flags);
  459. need_reset = task->task_state_flags & SAS_TASK_NEED_DEV_RESET;
  460. spin_unlock_irqrestore(&task->task_state_lock, flags);
  461. SAS_DPRINTK("trying to find task 0x%p\n", task);
  462. res = sas_scsi_find_task(task);
  463. cmd->eh_eflags = 0;
  464. switch (res) {
  465. case TASK_IS_DONE:
  466. SAS_DPRINTK("%s: task 0x%p is done\n", __FUNCTION__,
  467. task);
  468. sas_eh_finish_cmd(cmd);
  469. if (need_reset)
  470. try_to_reset_cmd_device(shost, cmd);
  471. continue;
  472. case TASK_IS_ABORTED:
  473. SAS_DPRINTK("%s: task 0x%p is aborted\n",
  474. __FUNCTION__, task);
  475. sas_eh_finish_cmd(cmd);
  476. if (need_reset)
  477. try_to_reset_cmd_device(shost, cmd);
  478. continue;
  479. case TASK_IS_AT_LU:
  480. SAS_DPRINTK("task 0x%p is at LU: lu recover\n", task);
  481. tmf_resp = sas_recover_lu(task->dev, cmd);
  482. if (tmf_resp == TMF_RESP_FUNC_COMPLETE) {
  483. SAS_DPRINTK("dev %016llx LU %x is "
  484. "recovered\n",
  485. SAS_ADDR(task->dev),
  486. cmd->device->lun);
  487. sas_eh_finish_cmd(cmd);
  488. if (need_reset)
  489. try_to_reset_cmd_device(shost, cmd);
  490. sas_scsi_clear_queue_lu(work_q, cmd);
  491. goto Again;
  492. }
  493. /* fallthrough */
  494. case TASK_IS_NOT_AT_LU:
  495. case TASK_ABORT_FAILED:
  496. SAS_DPRINTK("task 0x%p is not at LU: I_T recover\n",
  497. task);
  498. tmf_resp = sas_recover_I_T(task->dev);
  499. if (tmf_resp == TMF_RESP_FUNC_COMPLETE) {
  500. SAS_DPRINTK("I_T %016llx recovered\n",
  501. SAS_ADDR(task->dev->sas_addr));
  502. sas_eh_finish_cmd(cmd);
  503. if (need_reset)
  504. try_to_reset_cmd_device(shost, cmd);
  505. sas_scsi_clear_queue_I_T(work_q, task->dev);
  506. goto Again;
  507. }
  508. /* Hammer time :-) */
  509. if (i->dft->lldd_clear_nexus_port) {
  510. struct asd_sas_port *port = task->dev->port;
  511. SAS_DPRINTK("clearing nexus for port:%d\n",
  512. port->id);
  513. res = i->dft->lldd_clear_nexus_port(port);
  514. if (res == TMF_RESP_FUNC_COMPLETE) {
  515. SAS_DPRINTK("clear nexus port:%d "
  516. "succeeded\n", port->id);
  517. sas_eh_finish_cmd(cmd);
  518. if (need_reset)
  519. try_to_reset_cmd_device(shost, cmd);
  520. sas_scsi_clear_queue_port(work_q,
  521. port);
  522. goto Again;
  523. }
  524. }
  525. if (i->dft->lldd_clear_nexus_ha) {
  526. SAS_DPRINTK("clear nexus ha\n");
  527. res = i->dft->lldd_clear_nexus_ha(ha);
  528. if (res == TMF_RESP_FUNC_COMPLETE) {
  529. SAS_DPRINTK("clear nexus ha "
  530. "succeeded\n");
  531. sas_eh_finish_cmd(cmd);
  532. if (need_reset)
  533. try_to_reset_cmd_device(shost, cmd);
  534. goto clear_q;
  535. }
  536. }
  537. /* If we are here -- this means that no amount
  538. * of effort could recover from errors. Quite
  539. * possibly the HA just disappeared.
  540. */
  541. SAS_DPRINTK("error from device %llx, LUN %x "
  542. "couldn't be recovered in any way\n",
  543. SAS_ADDR(task->dev->sas_addr),
  544. cmd->device->lun);
  545. sas_eh_finish_cmd(cmd);
  546. if (need_reset)
  547. try_to_reset_cmd_device(shost, cmd);
  548. goto clear_q;
  549. }
  550. }
  551. return list_empty(work_q);
  552. clear_q:
  553. SAS_DPRINTK("--- Exit %s -- clear_q\n", __FUNCTION__);
  554. list_for_each_entry_safe(cmd, n, work_q, eh_entry)
  555. sas_eh_finish_cmd(cmd);
  556. return list_empty(work_q);
  557. }
  558. void sas_scsi_recover_host(struct Scsi_Host *shost)
  559. {
  560. struct sas_ha_struct *ha = SHOST_TO_SAS_HA(shost);
  561. unsigned long flags;
  562. LIST_HEAD(eh_work_q);
  563. spin_lock_irqsave(shost->host_lock, flags);
  564. list_splice_init(&shost->eh_cmd_q, &eh_work_q);
  565. spin_unlock_irqrestore(shost->host_lock, flags);
  566. SAS_DPRINTK("Enter %s\n", __FUNCTION__);
  567. /*
  568. * Deal with commands that still have SAS tasks (i.e. they didn't
  569. * complete via the normal sas_task completion mechanism)
  570. */
  571. if (sas_eh_handle_sas_errors(shost, &eh_work_q, &ha->eh_done_q))
  572. goto out;
  573. /*
  574. * Now deal with SCSI commands that completed ok but have a an error
  575. * code (and hopefully sense data) attached. This is roughly what
  576. * scsi_unjam_host does, but we skip scsi_eh_abort_cmds because any
  577. * command we see here has no sas_task and is thus unknown to the HA.
  578. */
  579. if (!scsi_eh_get_sense(&eh_work_q, &ha->eh_done_q))
  580. scsi_eh_ready_devs(shost, &eh_work_q, &ha->eh_done_q);
  581. out:
  582. scsi_eh_flush_done_q(&ha->eh_done_q);
  583. SAS_DPRINTK("--- Exit %s\n", __FUNCTION__);
  584. return;
  585. }
  586. enum scsi_eh_timer_return sas_scsi_timed_out(struct scsi_cmnd *cmd)
  587. {
  588. struct sas_task *task = TO_SAS_TASK(cmd);
  589. unsigned long flags;
  590. if (!task) {
  591. cmd->timeout_per_command /= 2;
  592. SAS_DPRINTK("command 0x%p, task 0x%p, gone: %s\n",
  593. cmd, task, (cmd->timeout_per_command ?
  594. "EH_RESET_TIMER" : "EH_NOT_HANDLED"));
  595. if (!cmd->timeout_per_command)
  596. return EH_NOT_HANDLED;
  597. return EH_RESET_TIMER;
  598. }
  599. spin_lock_irqsave(&task->task_state_lock, flags);
  600. BUG_ON(task->task_state_flags & SAS_TASK_STATE_ABORTED);
  601. if (task->task_state_flags & SAS_TASK_STATE_DONE) {
  602. spin_unlock_irqrestore(&task->task_state_lock, flags);
  603. SAS_DPRINTK("command 0x%p, task 0x%p, timed out: EH_HANDLED\n",
  604. cmd, task);
  605. return EH_HANDLED;
  606. }
  607. if (!(task->task_state_flags & SAS_TASK_AT_INITIATOR)) {
  608. spin_unlock_irqrestore(&task->task_state_lock, flags);
  609. SAS_DPRINTK("command 0x%p, task 0x%p, not at initiator: "
  610. "EH_RESET_TIMER\n",
  611. cmd, task);
  612. return EH_RESET_TIMER;
  613. }
  614. task->task_state_flags |= SAS_TASK_STATE_ABORTED;
  615. spin_unlock_irqrestore(&task->task_state_lock, flags);
  616. SAS_DPRINTK("command 0x%p, task 0x%p, timed out: EH_NOT_HANDLED\n",
  617. cmd, task);
  618. return EH_NOT_HANDLED;
  619. }
  620. int sas_ioctl(struct scsi_device *sdev, int cmd, void __user *arg)
  621. {
  622. struct domain_device *dev = sdev_to_domain_dev(sdev);
  623. if (dev_is_sata(dev))
  624. return ata_scsi_ioctl(sdev, cmd, arg);
  625. return -EINVAL;
  626. }
  627. struct domain_device *sas_find_dev_by_rphy(struct sas_rphy *rphy)
  628. {
  629. struct Scsi_Host *shost = dev_to_shost(rphy->dev.parent);
  630. struct sas_ha_struct *ha = SHOST_TO_SAS_HA(shost);
  631. struct domain_device *found_dev = NULL;
  632. int i;
  633. unsigned long flags;
  634. spin_lock_irqsave(&ha->phy_port_lock, flags);
  635. for (i = 0; i < ha->num_phys; i++) {
  636. struct asd_sas_port *port = ha->sas_port[i];
  637. struct domain_device *dev;
  638. spin_lock(&port->dev_list_lock);
  639. list_for_each_entry(dev, &port->dev_list, dev_list_node) {
  640. if (rphy == dev->rphy) {
  641. found_dev = dev;
  642. spin_unlock(&port->dev_list_lock);
  643. goto found;
  644. }
  645. }
  646. spin_unlock(&port->dev_list_lock);
  647. }
  648. found:
  649. spin_unlock_irqrestore(&ha->phy_port_lock, flags);
  650. return found_dev;
  651. }
  652. static inline struct domain_device *sas_find_target(struct scsi_target *starget)
  653. {
  654. struct sas_rphy *rphy = dev_to_rphy(starget->dev.parent);
  655. return sas_find_dev_by_rphy(rphy);
  656. }
  657. int sas_target_alloc(struct scsi_target *starget)
  658. {
  659. struct domain_device *found_dev = sas_find_target(starget);
  660. int res;
  661. if (!found_dev)
  662. return -ENODEV;
  663. if (dev_is_sata(found_dev)) {
  664. res = sas_ata_init_host_and_port(found_dev, starget);
  665. if (res)
  666. return res;
  667. }
  668. starget->hostdata = found_dev;
  669. return 0;
  670. }
  671. #define SAS_DEF_QD 32
  672. #define SAS_MAX_QD 64
  673. int sas_slave_configure(struct scsi_device *scsi_dev)
  674. {
  675. struct domain_device *dev = sdev_to_domain_dev(scsi_dev);
  676. struct sas_ha_struct *sas_ha;
  677. BUG_ON(dev->rphy->identify.device_type != SAS_END_DEVICE);
  678. if (dev_is_sata(dev)) {
  679. ata_sas_slave_configure(scsi_dev, dev->sata_dev.ap);
  680. return 0;
  681. }
  682. sas_ha = dev->port->ha;
  683. sas_read_port_mode_page(scsi_dev);
  684. if (scsi_dev->tagged_supported) {
  685. scsi_set_tag_type(scsi_dev, MSG_SIMPLE_TAG);
  686. scsi_activate_tcq(scsi_dev, SAS_DEF_QD);
  687. } else {
  688. SAS_DPRINTK("device %llx, LUN %x doesn't support "
  689. "TCQ\n", SAS_ADDR(dev->sas_addr),
  690. scsi_dev->lun);
  691. scsi_dev->tagged_supported = 0;
  692. scsi_set_tag_type(scsi_dev, 0);
  693. scsi_deactivate_tcq(scsi_dev, 1);
  694. }
  695. scsi_dev->allow_restart = 1;
  696. return 0;
  697. }
  698. void sas_slave_destroy(struct scsi_device *scsi_dev)
  699. {
  700. struct domain_device *dev = sdev_to_domain_dev(scsi_dev);
  701. if (dev_is_sata(dev))
  702. ata_port_disable(dev->sata_dev.ap);
  703. }
  704. int sas_change_queue_depth(struct scsi_device *scsi_dev, int new_depth)
  705. {
  706. int res = min(new_depth, SAS_MAX_QD);
  707. if (scsi_dev->tagged_supported)
  708. scsi_adjust_queue_depth(scsi_dev, scsi_get_tag_type(scsi_dev),
  709. res);
  710. else {
  711. struct domain_device *dev = sdev_to_domain_dev(scsi_dev);
  712. sas_printk("device %llx LUN %x queue depth changed to 1\n",
  713. SAS_ADDR(dev->sas_addr),
  714. scsi_dev->lun);
  715. scsi_adjust_queue_depth(scsi_dev, 0, 1);
  716. res = 1;
  717. }
  718. return res;
  719. }
  720. int sas_change_queue_type(struct scsi_device *scsi_dev, int qt)
  721. {
  722. if (!scsi_dev->tagged_supported)
  723. return 0;
  724. scsi_deactivate_tcq(scsi_dev, 1);
  725. scsi_set_tag_type(scsi_dev, qt);
  726. scsi_activate_tcq(scsi_dev, scsi_dev->queue_depth);
  727. return qt;
  728. }
  729. int sas_bios_param(struct scsi_device *scsi_dev,
  730. struct block_device *bdev,
  731. sector_t capacity, int *hsc)
  732. {
  733. hsc[0] = 255;
  734. hsc[1] = 63;
  735. sector_div(capacity, 255*63);
  736. hsc[2] = capacity;
  737. return 0;
  738. }
  739. /* ---------- Task Collector Thread implementation ---------- */
  740. static void sas_queue(struct sas_ha_struct *sas_ha)
  741. {
  742. struct scsi_core *core = &sas_ha->core;
  743. unsigned long flags;
  744. LIST_HEAD(q);
  745. int can_queue;
  746. int res;
  747. struct sas_internal *i = to_sas_internal(core->shost->transportt);
  748. spin_lock_irqsave(&core->task_queue_lock, flags);
  749. while (!kthread_should_stop() &&
  750. !list_empty(&core->task_queue)) {
  751. can_queue = sas_ha->lldd_queue_size - core->task_queue_size;
  752. if (can_queue >= 0) {
  753. can_queue = core->task_queue_size;
  754. list_splice_init(&core->task_queue, &q);
  755. } else {
  756. struct list_head *a, *n;
  757. can_queue = sas_ha->lldd_queue_size;
  758. list_for_each_safe(a, n, &core->task_queue) {
  759. list_move_tail(a, &q);
  760. if (--can_queue == 0)
  761. break;
  762. }
  763. can_queue = sas_ha->lldd_queue_size;
  764. }
  765. core->task_queue_size -= can_queue;
  766. spin_unlock_irqrestore(&core->task_queue_lock, flags);
  767. {
  768. struct sas_task *task = list_entry(q.next,
  769. struct sas_task,
  770. list);
  771. list_del_init(&q);
  772. res = i->dft->lldd_execute_task(task, can_queue,
  773. GFP_KERNEL);
  774. if (unlikely(res))
  775. __list_add(&q, task->list.prev, &task->list);
  776. }
  777. spin_lock_irqsave(&core->task_queue_lock, flags);
  778. if (res) {
  779. list_splice_init(&q, &core->task_queue); /*at head*/
  780. core->task_queue_size += can_queue;
  781. }
  782. }
  783. spin_unlock_irqrestore(&core->task_queue_lock, flags);
  784. }
  785. /**
  786. * sas_queue_thread -- The Task Collector thread
  787. * @_sas_ha: pointer to struct sas_ha
  788. */
  789. static int sas_queue_thread(void *_sas_ha)
  790. {
  791. struct sas_ha_struct *sas_ha = _sas_ha;
  792. while (1) {
  793. set_current_state(TASK_INTERRUPTIBLE);
  794. schedule();
  795. sas_queue(sas_ha);
  796. if (kthread_should_stop())
  797. break;
  798. }
  799. return 0;
  800. }
  801. int sas_init_queue(struct sas_ha_struct *sas_ha)
  802. {
  803. struct scsi_core *core = &sas_ha->core;
  804. spin_lock_init(&core->task_queue_lock);
  805. core->task_queue_size = 0;
  806. INIT_LIST_HEAD(&core->task_queue);
  807. core->queue_thread = kthread_run(sas_queue_thread, sas_ha,
  808. "sas_queue_%d", core->shost->host_no);
  809. if (IS_ERR(core->queue_thread))
  810. return PTR_ERR(core->queue_thread);
  811. return 0;
  812. }
  813. void sas_shutdown_queue(struct sas_ha_struct *sas_ha)
  814. {
  815. unsigned long flags;
  816. struct scsi_core *core = &sas_ha->core;
  817. struct sas_task *task, *n;
  818. kthread_stop(core->queue_thread);
  819. if (!list_empty(&core->task_queue))
  820. SAS_DPRINTK("HA: %llx: scsi core task queue is NOT empty!?\n",
  821. SAS_ADDR(sas_ha->sas_addr));
  822. spin_lock_irqsave(&core->task_queue_lock, flags);
  823. list_for_each_entry_safe(task, n, &core->task_queue, list) {
  824. struct scsi_cmnd *cmd = task->uldd_task;
  825. list_del_init(&task->list);
  826. ASSIGN_SAS_TASK(cmd, NULL);
  827. sas_free_task(task);
  828. cmd->result = DID_ABORT << 16;
  829. cmd->scsi_done(cmd);
  830. }
  831. spin_unlock_irqrestore(&core->task_queue_lock, flags);
  832. }
  833. /*
  834. * Call the LLDD task abort routine directly. This function is intended for
  835. * use by upper layers that need to tell the LLDD to abort a task.
  836. */
  837. int __sas_task_abort(struct sas_task *task)
  838. {
  839. struct sas_internal *si =
  840. to_sas_internal(task->dev->port->ha->core.shost->transportt);
  841. unsigned long flags;
  842. int res;
  843. spin_lock_irqsave(&task->task_state_lock, flags);
  844. if (task->task_state_flags & SAS_TASK_STATE_ABORTED ||
  845. task->task_state_flags & SAS_TASK_STATE_DONE) {
  846. spin_unlock_irqrestore(&task->task_state_lock, flags);
  847. SAS_DPRINTK("%s: Task %p already finished.\n", __FUNCTION__,
  848. task);
  849. return 0;
  850. }
  851. task->task_state_flags |= SAS_TASK_STATE_ABORTED;
  852. spin_unlock_irqrestore(&task->task_state_lock, flags);
  853. if (!si->dft->lldd_abort_task)
  854. return -ENODEV;
  855. res = si->dft->lldd_abort_task(task);
  856. spin_lock_irqsave(&task->task_state_lock, flags);
  857. if ((task->task_state_flags & SAS_TASK_STATE_DONE) ||
  858. (res == TMF_RESP_FUNC_COMPLETE))
  859. {
  860. spin_unlock_irqrestore(&task->task_state_lock, flags);
  861. task->task_done(task);
  862. return 0;
  863. }
  864. if (!(task->task_state_flags & SAS_TASK_STATE_DONE))
  865. task->task_state_flags &= ~SAS_TASK_STATE_ABORTED;
  866. spin_unlock_irqrestore(&task->task_state_lock, flags);
  867. return -EAGAIN;
  868. }
  869. /*
  870. * Tell an upper layer that it needs to initiate an abort for a given task.
  871. * This should only ever be called by an LLDD.
  872. */
  873. void sas_task_abort(struct sas_task *task)
  874. {
  875. struct scsi_cmnd *sc = task->uldd_task;
  876. /* Escape for libsas internal commands */
  877. if (!sc) {
  878. if (!del_timer(&task->timer))
  879. return;
  880. task->timer.function(task->timer.data);
  881. return;
  882. }
  883. if (dev_is_sata(task->dev)) {
  884. sas_ata_task_abort(task);
  885. return;
  886. }
  887. scsi_req_abort_cmd(sc);
  888. scsi_schedule_eh(sc->device->host);
  889. }
  890. int sas_slave_alloc(struct scsi_device *scsi_dev)
  891. {
  892. struct domain_device *dev = sdev_to_domain_dev(scsi_dev);
  893. if (dev_is_sata(dev))
  894. return ata_sas_port_init(dev->sata_dev.ap);
  895. return 0;
  896. }
  897. void sas_target_destroy(struct scsi_target *starget)
  898. {
  899. struct domain_device *found_dev = sas_find_target(starget);
  900. if (!found_dev)
  901. return;
  902. if (dev_is_sata(found_dev))
  903. ata_sas_port_destroy(found_dev->sata_dev.ap);
  904. return;
  905. }
  906. EXPORT_SYMBOL_GPL(sas_queuecommand);
  907. EXPORT_SYMBOL_GPL(sas_target_alloc);
  908. EXPORT_SYMBOL_GPL(sas_slave_configure);
  909. EXPORT_SYMBOL_GPL(sas_slave_destroy);
  910. EXPORT_SYMBOL_GPL(sas_change_queue_depth);
  911. EXPORT_SYMBOL_GPL(sas_change_queue_type);
  912. EXPORT_SYMBOL_GPL(sas_bios_param);
  913. EXPORT_SYMBOL_GPL(__sas_task_abort);
  914. EXPORT_SYMBOL_GPL(sas_task_abort);
  915. EXPORT_SYMBOL_GPL(sas_phy_reset);
  916. EXPORT_SYMBOL_GPL(sas_phy_enable);
  917. EXPORT_SYMBOL_GPL(sas_eh_device_reset_handler);
  918. EXPORT_SYMBOL_GPL(sas_eh_bus_reset_handler);
  919. EXPORT_SYMBOL_GPL(sas_slave_alloc);
  920. EXPORT_SYMBOL_GPL(sas_target_destroy);
  921. EXPORT_SYMBOL_GPL(sas_ioctl);