scsi_error.c 54 KB

12345678910111213141516171819202122232425262728293031323334353637383940414243444546474849505152535455565758596061626364656667686970717273747576777879808182838485868788899091929394959697989910010110210310410510610710810911011111211311411511611711811912012112212312412512612712812913013113213313413513613713813914014114214314414514614714814915015115215315415515615715815916016116216316416516616716816917017117217317417517617717817918018118218318418518618718818919019119219319419519619719819920020120220320420520620720820921021121221321421521621721821922022122222322422522622722822923023123223323423523623723823924024124224324424524624724824925025125225325425525625725825926026126226326426526626726826927027127227327427527627727827928028128228328428528628728828929029129229329429529629729829930030130230330430530630730830931031131231331431531631731831932032132232332432532632732832933033133233333433533633733833934034134234334434534634734834935035135235335435535635735835936036136236336436536636736836937037137237337437537637737837938038138238338438538638738838939039139239339439539639739839940040140240340440540640740840941041141241341441541641741841942042142242342442542642742842943043143243343443543643743843944044144244344444544644744844945045145245345445545645745845946046146246346446546646746846947047147247347447547647747847948048148248348448548648748848949049149249349449549649749849950050150250350450550650750850951051151251351451551651751851952052152252352452552652752852953053153253353453553653753853954054154254354454554654754854955055155255355455555655755855956056156256356456556656756856957057157257357457557657757857958058158258358458558658758858959059159259359459559659759859960060160260360460560660760860961061161261361461561661761861962062162262362462562662762862963063163263363463563663763863964064164264364464564664764864965065165265365465565665765865966066166266366466566666766866967067167267367467567667767867968068168268368468568668768868969069169269369469569669769869970070170270370470570670770870971071171271371471571671771871972072172272372472572672772872973073173273373473573673773873974074174274374474574674774874975075175275375475575675775875976076176276376476576676776876977077177277377477577677777877978078178278378478578678778878979079179279379479579679779879980080180280380480580680780880981081181281381481581681781881982082182282382482582682782882983083183283383483583683783883984084184284384484584684784884985085185285385485585685785885986086186286386486586686786886987087187287387487587687787887988088188288388488588688788888989089189289389489589689789889990090190290390490590690790890991091191291391491591691791891992092192292392492592692792892993093193293393493593693793893994094194294394494594694794894995095195295395495595695795895996096196296396496596696796896997097197297397497597697797897998098198298398498598698798898999099199299399499599699799899910001001100210031004100510061007100810091010101110121013101410151016101710181019102010211022102310241025102610271028102910301031103210331034103510361037103810391040104110421043104410451046104710481049105010511052105310541055105610571058105910601061106210631064106510661067106810691070107110721073107410751076107710781079108010811082108310841085108610871088108910901091109210931094109510961097109810991100110111021103110411051106110711081109111011111112111311141115111611171118111911201121112211231124112511261127112811291130113111321133113411351136113711381139114011411142114311441145114611471148114911501151115211531154115511561157115811591160116111621163116411651166116711681169117011711172117311741175117611771178117911801181118211831184118511861187118811891190119111921193119411951196119711981199120012011202120312041205120612071208120912101211121212131214121512161217121812191220122112221223122412251226122712281229123012311232123312341235123612371238123912401241124212431244124512461247124812491250125112521253125412551256125712581259126012611262126312641265126612671268126912701271127212731274127512761277127812791280128112821283128412851286128712881289129012911292129312941295129612971298129913001301130213031304130513061307130813091310131113121313131413151316131713181319132013211322132313241325132613271328132913301331133213331334133513361337133813391340134113421343134413451346134713481349135013511352135313541355135613571358135913601361136213631364136513661367136813691370137113721373137413751376137713781379138013811382138313841385138613871388138913901391139213931394139513961397139813991400140114021403140414051406140714081409141014111412141314141415141614171418141914201421142214231424142514261427142814291430143114321433143414351436143714381439144014411442144314441445144614471448144914501451145214531454145514561457145814591460146114621463146414651466146714681469147014711472147314741475147614771478147914801481148214831484148514861487148814891490149114921493149414951496149714981499150015011502150315041505150615071508150915101511151215131514151515161517151815191520152115221523152415251526152715281529153015311532153315341535153615371538153915401541154215431544154515461547154815491550155115521553155415551556155715581559156015611562156315641565156615671568156915701571157215731574157515761577157815791580158115821583158415851586158715881589159015911592159315941595159615971598159916001601160216031604160516061607160816091610161116121613161416151616161716181619162016211622162316241625162616271628162916301631163216331634163516361637163816391640164116421643164416451646164716481649165016511652165316541655165616571658165916601661166216631664166516661667166816691670167116721673167416751676167716781679168016811682168316841685168616871688168916901691169216931694169516961697169816991700170117021703170417051706170717081709171017111712171317141715171617171718171917201721172217231724172517261727172817291730173117321733173417351736173717381739174017411742174317441745174617471748174917501751175217531754175517561757175817591760176117621763176417651766176717681769177017711772177317741775177617771778177917801781178217831784178517861787178817891790179117921793179417951796179717981799180018011802180318041805180618071808180918101811181218131814181518161817181818191820182118221823182418251826182718281829183018311832183318341835183618371838183918401841184218431844184518461847184818491850185118521853185418551856185718581859186018611862186318641865186618671868186918701871187218731874187518761877187818791880188118821883188418851886188718881889189018911892189318941895189618971898189919001901190219031904190519061907190819091910191119121913191419151916191719181919192019211922192319241925192619271928192919301931193219331934193519361937193819391940194119421943194419451946194719481949195019511952195319541955195619571958195919601961196219631964196519661967196819691970197119721973197419751976197719781979198019811982198319841985198619871988198919901991199219931994199519961997199819992000200120022003200420052006200720082009201020112012201320142015201620172018201920202021202220232024202520262027202820292030203120322033203420352036203720382039204020412042
  1. /*
  2. * scsi_error.c Copyright (C) 1997 Eric Youngdale
  3. *
  4. * SCSI error/timeout handling
  5. * Initial versions: Eric Youngdale. Based upon conversations with
  6. * Leonard Zubkoff and David Miller at Linux Expo,
  7. * ideas originating from all over the place.
  8. *
  9. * Restructured scsi_unjam_host and associated functions.
  10. * September 04, 2002 Mike Anderson (andmike@us.ibm.com)
  11. *
  12. * Forward port of Russell King's (rmk@arm.linux.org.uk) changes and
  13. * minor cleanups.
  14. * September 30, 2002 Mike Anderson (andmike@us.ibm.com)
  15. */
  16. #include <linux/module.h>
  17. #include <linux/sched.h>
  18. #include <linux/timer.h>
  19. #include <linux/string.h>
  20. #include <linux/slab.h>
  21. #include <linux/kernel.h>
  22. #include <linux/interrupt.h>
  23. #include <linux/blkdev.h>
  24. #include <linux/delay.h>
  25. #include <scsi/scsi.h>
  26. #include <scsi/scsi_dbg.h>
  27. #include <scsi/scsi_device.h>
  28. #include <scsi/scsi_eh.h>
  29. #include <scsi/scsi_host.h>
  30. #include <scsi/scsi_ioctl.h>
  31. #include <scsi/scsi_request.h>
  32. #include "scsi_priv.h"
  33. #include "scsi_logging.h"
  34. #define SENSE_TIMEOUT (10*HZ)
  35. #define START_UNIT_TIMEOUT (30*HZ)
  36. /*
  37. * These should *probably* be handled by the host itself.
  38. * Since it is allowed to sleep, it probably should.
  39. */
  40. #define BUS_RESET_SETTLE_TIME (10)
  41. #define HOST_RESET_SETTLE_TIME (10)
  42. /* called with shost->host_lock held */
  43. void scsi_eh_wakeup(struct Scsi_Host *shost)
  44. {
  45. if (shost->host_busy == shost->host_failed) {
  46. up(shost->eh_wait);
  47. SCSI_LOG_ERROR_RECOVERY(5,
  48. printk("Waking error handler thread\n"));
  49. }
  50. }
  51. /**
  52. * scsi_eh_scmd_add - add scsi cmd to error handling.
  53. * @scmd: scmd to run eh on.
  54. * @eh_flag: optional SCSI_EH flag.
  55. *
  56. * Return value:
  57. * 0 on failure.
  58. **/
  59. int scsi_eh_scmd_add(struct scsi_cmnd *scmd, int eh_flag)
  60. {
  61. struct Scsi_Host *shost = scmd->device->host;
  62. unsigned long flags;
  63. if (shost->eh_wait == NULL)
  64. return 0;
  65. spin_lock_irqsave(shost->host_lock, flags);
  66. scsi_eh_eflags_set(scmd, eh_flag);
  67. /*
  68. * FIXME: Can we stop setting owner and state.
  69. */
  70. scmd->owner = SCSI_OWNER_ERROR_HANDLER;
  71. scmd->state = SCSI_STATE_FAILED;
  72. list_add_tail(&scmd->eh_entry, &shost->eh_cmd_q);
  73. set_bit(SHOST_RECOVERY, &shost->shost_state);
  74. shost->host_failed++;
  75. scsi_eh_wakeup(shost);
  76. spin_unlock_irqrestore(shost->host_lock, flags);
  77. return 1;
  78. }
  79. /**
  80. * scsi_add_timer - Start timeout timer for a single scsi command.
  81. * @scmd: scsi command that is about to start running.
  82. * @timeout: amount of time to allow this command to run.
  83. * @complete: timeout function to call if timer isn't canceled.
  84. *
  85. * Notes:
  86. * This should be turned into an inline function. Each scsi command
  87. * has its own timer, and as it is added to the queue, we set up the
  88. * timer. When the command completes, we cancel the timer.
  89. **/
  90. void scsi_add_timer(struct scsi_cmnd *scmd, int timeout,
  91. void (*complete)(struct scsi_cmnd *))
  92. {
  93. /*
  94. * If the clock was already running for this command, then
  95. * first delete the timer. The timer handling code gets rather
  96. * confused if we don't do this.
  97. */
  98. if (scmd->eh_timeout.function)
  99. del_timer(&scmd->eh_timeout);
  100. scmd->eh_timeout.data = (unsigned long)scmd;
  101. scmd->eh_timeout.expires = jiffies + timeout;
  102. scmd->eh_timeout.function = (void (*)(unsigned long)) complete;
  103. SCSI_LOG_ERROR_RECOVERY(5, printk("%s: scmd: %p, time:"
  104. " %d, (%p)\n", __FUNCTION__,
  105. scmd, timeout, complete));
  106. add_timer(&scmd->eh_timeout);
  107. }
  108. EXPORT_SYMBOL(scsi_add_timer);
  109. /**
  110. * scsi_delete_timer - Delete/cancel timer for a given function.
  111. * @scmd: Cmd that we are canceling timer for
  112. *
  113. * Notes:
  114. * This should be turned into an inline function.
  115. *
  116. * Return value:
  117. * 1 if we were able to detach the timer. 0 if we blew it, and the
  118. * timer function has already started to run.
  119. **/
  120. int scsi_delete_timer(struct scsi_cmnd *scmd)
  121. {
  122. int rtn;
  123. rtn = del_timer(&scmd->eh_timeout);
  124. SCSI_LOG_ERROR_RECOVERY(5, printk("%s: scmd: %p,"
  125. " rtn: %d\n", __FUNCTION__,
  126. scmd, rtn));
  127. scmd->eh_timeout.data = (unsigned long)NULL;
  128. scmd->eh_timeout.function = NULL;
  129. return rtn;
  130. }
  131. EXPORT_SYMBOL(scsi_delete_timer);
  132. /**
  133. * scsi_times_out - Timeout function for normal scsi commands.
  134. * @scmd: Cmd that is timing out.
  135. *
  136. * Notes:
  137. * We do not need to lock this. There is the potential for a race
  138. * only in that the normal completion handling might run, but if the
  139. * normal completion function determines that the timer has already
  140. * fired, then it mustn't do anything.
  141. **/
  142. void scsi_times_out(struct scsi_cmnd *scmd)
  143. {
  144. scsi_log_completion(scmd, TIMEOUT_ERROR);
  145. if (scmd->device->host->hostt->eh_timed_out)
  146. switch (scmd->device->host->hostt->eh_timed_out(scmd)) {
  147. case EH_HANDLED:
  148. __scsi_done(scmd);
  149. return;
  150. case EH_RESET_TIMER:
  151. /* This allows a single retry even of a command
  152. * with allowed == 0 */
  153. if (scmd->retries++ > scmd->allowed)
  154. break;
  155. scsi_add_timer(scmd, scmd->timeout_per_command,
  156. scsi_times_out);
  157. return;
  158. case EH_NOT_HANDLED:
  159. break;
  160. }
  161. if (unlikely(!scsi_eh_scmd_add(scmd, SCSI_EH_CANCEL_CMD))) {
  162. panic("Error handler thread not present at %p %p %s %d",
  163. scmd, scmd->device->host, __FILE__, __LINE__);
  164. }
  165. }
  166. /**
  167. * scsi_block_when_processing_errors - Prevent cmds from being queued.
  168. * @sdev: Device on which we are performing recovery.
  169. *
  170. * Description:
  171. * We block until the host is out of error recovery, and then check to
  172. * see whether the host or the device is offline.
  173. *
  174. * Return value:
  175. * 0 when dev was taken offline by error recovery. 1 OK to proceed.
  176. **/
  177. int scsi_block_when_processing_errors(struct scsi_device *sdev)
  178. {
  179. int online;
  180. wait_event(sdev->host->host_wait, (!test_bit(SHOST_RECOVERY, &sdev->host->shost_state)));
  181. online = scsi_device_online(sdev);
  182. SCSI_LOG_ERROR_RECOVERY(5, printk("%s: rtn: %d\n", __FUNCTION__,
  183. online));
  184. return online;
  185. }
  186. EXPORT_SYMBOL(scsi_block_when_processing_errors);
  187. #ifdef CONFIG_SCSI_LOGGING
  188. /**
  189. * scsi_eh_prt_fail_stats - Log info on failures.
  190. * @shost: scsi host being recovered.
  191. * @work_q: Queue of scsi cmds to process.
  192. **/
  193. static inline void scsi_eh_prt_fail_stats(struct Scsi_Host *shost,
  194. struct list_head *work_q)
  195. {
  196. struct scsi_cmnd *scmd;
  197. struct scsi_device *sdev;
  198. int total_failures = 0;
  199. int cmd_failed = 0;
  200. int cmd_cancel = 0;
  201. int devices_failed = 0;
  202. shost_for_each_device(sdev, shost) {
  203. list_for_each_entry(scmd, work_q, eh_entry) {
  204. if (scmd->device == sdev) {
  205. ++total_failures;
  206. if (scsi_eh_eflags_chk(scmd,
  207. SCSI_EH_CANCEL_CMD))
  208. ++cmd_cancel;
  209. else
  210. ++cmd_failed;
  211. }
  212. }
  213. if (cmd_cancel || cmd_failed) {
  214. SCSI_LOG_ERROR_RECOVERY(3,
  215. printk("%s: %d:%d:%d:%d cmds failed: %d,"
  216. " cancel: %d\n",
  217. __FUNCTION__, shost->host_no,
  218. sdev->channel, sdev->id, sdev->lun,
  219. cmd_failed, cmd_cancel));
  220. cmd_cancel = 0;
  221. cmd_failed = 0;
  222. ++devices_failed;
  223. }
  224. }
  225. SCSI_LOG_ERROR_RECOVERY(2, printk("Total of %d commands on %d"
  226. " devices require eh work\n",
  227. total_failures, devices_failed));
  228. }
  229. #endif
  230. /**
  231. * scsi_check_sense - Examine scsi cmd sense
  232. * @scmd: Cmd to have sense checked.
  233. *
  234. * Return value:
  235. * SUCCESS or FAILED or NEEDS_RETRY
  236. *
  237. * Notes:
  238. * When a deferred error is detected the current command has
  239. * not been executed and needs retrying.
  240. **/
  241. static int scsi_check_sense(struct scsi_cmnd *scmd)
  242. {
  243. struct scsi_sense_hdr sshdr;
  244. if (! scsi_command_normalize_sense(scmd, &sshdr))
  245. return FAILED; /* no valid sense data */
  246. if (scsi_sense_is_deferred(&sshdr))
  247. return NEEDS_RETRY;
  248. /*
  249. * Previous logic looked for FILEMARK, EOM or ILI which are
  250. * mainly associated with tapes and returned SUCCESS.
  251. */
  252. if (sshdr.response_code == 0x70) {
  253. /* fixed format */
  254. if (scmd->sense_buffer[2] & 0xe0)
  255. return SUCCESS;
  256. } else {
  257. /*
  258. * descriptor format: look for "stream commands sense data
  259. * descriptor" (see SSC-3). Assume single sense data
  260. * descriptor. Ignore ILI from SBC-2 READ LONG and WRITE LONG.
  261. */
  262. if ((sshdr.additional_length > 3) &&
  263. (scmd->sense_buffer[8] == 0x4) &&
  264. (scmd->sense_buffer[11] & 0xe0))
  265. return SUCCESS;
  266. }
  267. switch (sshdr.sense_key) {
  268. case NO_SENSE:
  269. return SUCCESS;
  270. case RECOVERED_ERROR:
  271. return /* soft_error */ SUCCESS;
  272. case ABORTED_COMMAND:
  273. return NEEDS_RETRY;
  274. case NOT_READY:
  275. case UNIT_ATTENTION:
  276. /*
  277. * if we are expecting a cc/ua because of a bus reset that we
  278. * performed, treat this just as a retry. otherwise this is
  279. * information that we should pass up to the upper-level driver
  280. * so that we can deal with it there.
  281. */
  282. if (scmd->device->expecting_cc_ua) {
  283. scmd->device->expecting_cc_ua = 0;
  284. return NEEDS_RETRY;
  285. }
  286. /*
  287. * if the device is in the process of becoming ready, we
  288. * should retry.
  289. */
  290. if ((sshdr.asc == 0x04) && (sshdr.ascq == 0x01))
  291. return NEEDS_RETRY;
  292. /*
  293. * if the device is not started, we need to wake
  294. * the error handler to start the motor
  295. */
  296. if (scmd->device->allow_restart &&
  297. (sshdr.asc == 0x04) && (sshdr.ascq == 0x02))
  298. return FAILED;
  299. return SUCCESS;
  300. /* these three are not supported */
  301. case COPY_ABORTED:
  302. case VOLUME_OVERFLOW:
  303. case MISCOMPARE:
  304. return SUCCESS;
  305. case MEDIUM_ERROR:
  306. return NEEDS_RETRY;
  307. case HARDWARE_ERROR:
  308. if (scmd->device->retry_hwerror)
  309. return NEEDS_RETRY;
  310. else
  311. return SUCCESS;
  312. case ILLEGAL_REQUEST:
  313. case BLANK_CHECK:
  314. case DATA_PROTECT:
  315. default:
  316. return SUCCESS;
  317. }
  318. }
  319. /**
  320. * scsi_eh_completed_normally - Disposition a eh cmd on return from LLD.
  321. * @scmd: SCSI cmd to examine.
  322. *
  323. * Notes:
  324. * This is *only* called when we are examining the status of commands
  325. * queued during error recovery. the main difference here is that we
  326. * don't allow for the possibility of retries here, and we are a lot
  327. * more restrictive about what we consider acceptable.
  328. **/
  329. static int scsi_eh_completed_normally(struct scsi_cmnd *scmd)
  330. {
  331. /*
  332. * first check the host byte, to see if there is anything in there
  333. * that would indicate what we need to do.
  334. */
  335. if (host_byte(scmd->result) == DID_RESET) {
  336. /*
  337. * rats. we are already in the error handler, so we now
  338. * get to try and figure out what to do next. if the sense
  339. * is valid, we have a pretty good idea of what to do.
  340. * if not, we mark it as FAILED.
  341. */
  342. return scsi_check_sense(scmd);
  343. }
  344. if (host_byte(scmd->result) != DID_OK)
  345. return FAILED;
  346. /*
  347. * next, check the message byte.
  348. */
  349. if (msg_byte(scmd->result) != COMMAND_COMPLETE)
  350. return FAILED;
  351. /*
  352. * now, check the status byte to see if this indicates
  353. * anything special.
  354. */
  355. switch (status_byte(scmd->result)) {
  356. case GOOD:
  357. case COMMAND_TERMINATED:
  358. return SUCCESS;
  359. case CHECK_CONDITION:
  360. return scsi_check_sense(scmd);
  361. case CONDITION_GOOD:
  362. case INTERMEDIATE_GOOD:
  363. case INTERMEDIATE_C_GOOD:
  364. /*
  365. * who knows? FIXME(eric)
  366. */
  367. return SUCCESS;
  368. case BUSY:
  369. case QUEUE_FULL:
  370. case RESERVATION_CONFLICT:
  371. default:
  372. return FAILED;
  373. }
  374. return FAILED;
  375. }
  376. /**
  377. * scsi_eh_times_out - timeout function for error handling.
  378. * @scmd: Cmd that is timing out.
  379. *
  380. * Notes:
  381. * During error handling, the kernel thread will be sleeping waiting
  382. * for some action to complete on the device. our only job is to
  383. * record that it timed out, and to wake up the thread.
  384. **/
  385. static void scsi_eh_times_out(struct scsi_cmnd *scmd)
  386. {
  387. scsi_eh_eflags_set(scmd, SCSI_EH_REC_TIMEOUT);
  388. SCSI_LOG_ERROR_RECOVERY(3, printk("%s: scmd:%p\n", __FUNCTION__,
  389. scmd));
  390. up(scmd->device->host->eh_action);
  391. }
  392. /**
  393. * scsi_eh_done - Completion function for error handling.
  394. * @scmd: Cmd that is done.
  395. **/
  396. static void scsi_eh_done(struct scsi_cmnd *scmd)
  397. {
  398. /*
  399. * if the timeout handler is already running, then just set the
  400. * flag which says we finished late, and return. we have no
  401. * way of stopping the timeout handler from running, so we must
  402. * always defer to it.
  403. */
  404. if (del_timer(&scmd->eh_timeout)) {
  405. scmd->request->rq_status = RQ_SCSI_DONE;
  406. scmd->owner = SCSI_OWNER_ERROR_HANDLER;
  407. SCSI_LOG_ERROR_RECOVERY(3, printk("%s scmd: %p result: %x\n",
  408. __FUNCTION__, scmd, scmd->result));
  409. up(scmd->device->host->eh_action);
  410. }
  411. }
  412. /**
  413. * scsi_send_eh_cmnd - send a cmd to a device as part of error recovery.
  414. * @scmd: SCSI Cmd to send.
  415. * @timeout: Timeout for cmd.
  416. *
  417. * Notes:
  418. * The initialization of the structures is quite a bit different in
  419. * this case, and furthermore, there is a different completion handler
  420. * vs scsi_dispatch_cmd.
  421. * Return value:
  422. * SUCCESS or FAILED or NEEDS_RETRY
  423. **/
  424. static int scsi_send_eh_cmnd(struct scsi_cmnd *scmd, int timeout)
  425. {
  426. struct scsi_device *sdev = scmd->device;
  427. struct Scsi_Host *shost = sdev->host;
  428. DECLARE_MUTEX_LOCKED(sem);
  429. unsigned long flags;
  430. int rtn = SUCCESS;
  431. /*
  432. * we will use a queued command if possible, otherwise we will
  433. * emulate the queuing and calling of completion function ourselves.
  434. */
  435. scmd->owner = SCSI_OWNER_LOWLEVEL;
  436. if (sdev->scsi_level <= SCSI_2)
  437. scmd->cmnd[1] = (scmd->cmnd[1] & 0x1f) |
  438. (sdev->lun << 5 & 0xe0);
  439. scsi_add_timer(scmd, timeout, scsi_eh_times_out);
  440. /*
  441. * set up the semaphore so we wait for the command to complete.
  442. */
  443. shost->eh_action = &sem;
  444. scmd->request->rq_status = RQ_SCSI_BUSY;
  445. spin_lock_irqsave(shost->host_lock, flags);
  446. scsi_log_send(scmd);
  447. shost->hostt->queuecommand(scmd, scsi_eh_done);
  448. spin_unlock_irqrestore(shost->host_lock, flags);
  449. down(&sem);
  450. scsi_log_completion(scmd, SUCCESS);
  451. shost->eh_action = NULL;
  452. /*
  453. * see if timeout. if so, tell the host to forget about it.
  454. * in other words, we don't want a callback any more.
  455. */
  456. if (scsi_eh_eflags_chk(scmd, SCSI_EH_REC_TIMEOUT)) {
  457. scsi_eh_eflags_clr(scmd, SCSI_EH_REC_TIMEOUT);
  458. scmd->owner = SCSI_OWNER_LOWLEVEL;
  459. /*
  460. * as far as the low level driver is
  461. * concerned, this command is still active, so
  462. * we must give the low level driver a chance
  463. * to abort it. (db)
  464. *
  465. * FIXME(eric) - we are not tracking whether we could
  466. * abort a timed out command or not. not sure how
  467. * we should treat them differently anyways.
  468. */
  469. if (shost->hostt->eh_abort_handler)
  470. shost->hostt->eh_abort_handler(scmd);
  471. scmd->request->rq_status = RQ_SCSI_DONE;
  472. scmd->owner = SCSI_OWNER_ERROR_HANDLER;
  473. rtn = FAILED;
  474. }
  475. SCSI_LOG_ERROR_RECOVERY(3, printk("%s: scmd: %p, rtn:%x\n",
  476. __FUNCTION__, scmd, rtn));
  477. /*
  478. * now examine the actual status codes to see whether the command
  479. * actually did complete normally.
  480. */
  481. if (rtn == SUCCESS) {
  482. rtn = scsi_eh_completed_normally(scmd);
  483. SCSI_LOG_ERROR_RECOVERY(3,
  484. printk("%s: scsi_eh_completed_normally %x\n",
  485. __FUNCTION__, rtn));
  486. switch (rtn) {
  487. case SUCCESS:
  488. case NEEDS_RETRY:
  489. case FAILED:
  490. break;
  491. default:
  492. rtn = FAILED;
  493. break;
  494. }
  495. }
  496. return rtn;
  497. }
  498. /**
  499. * scsi_request_sense - Request sense data from a particular target.
  500. * @scmd: SCSI cmd for request sense.
  501. *
  502. * Notes:
  503. * Some hosts automatically obtain this information, others require
  504. * that we obtain it on our own. This function will *not* return until
  505. * the command either times out, or it completes.
  506. **/
  507. static int scsi_request_sense(struct scsi_cmnd *scmd)
  508. {
  509. static unsigned char generic_sense[6] =
  510. {REQUEST_SENSE, 0, 0, 0, 252, 0};
  511. unsigned char *scsi_result;
  512. int saved_result;
  513. int rtn;
  514. memcpy(scmd->cmnd, generic_sense, sizeof(generic_sense));
  515. scsi_result = kmalloc(252, GFP_ATOMIC | ((scmd->device->host->hostt->unchecked_isa_dma) ? __GFP_DMA : 0));
  516. if (unlikely(!scsi_result)) {
  517. printk(KERN_ERR "%s: cannot allocate scsi_result.\n",
  518. __FUNCTION__);
  519. return FAILED;
  520. }
  521. /*
  522. * zero the sense buffer. some host adapters automatically always
  523. * request sense, so it is not a good idea that
  524. * scmd->request_buffer and scmd->sense_buffer point to the same
  525. * address (db). 0 is not a valid sense code.
  526. */
  527. memset(scmd->sense_buffer, 0, sizeof(scmd->sense_buffer));
  528. memset(scsi_result, 0, 252);
  529. saved_result = scmd->result;
  530. scmd->request_buffer = scsi_result;
  531. scmd->request_bufflen = 252;
  532. scmd->use_sg = 0;
  533. scmd->cmd_len = COMMAND_SIZE(scmd->cmnd[0]);
  534. scmd->sc_data_direction = DMA_FROM_DEVICE;
  535. scmd->underflow = 0;
  536. rtn = scsi_send_eh_cmnd(scmd, SENSE_TIMEOUT);
  537. /* last chance to have valid sense data */
  538. if(!SCSI_SENSE_VALID(scmd)) {
  539. memcpy(scmd->sense_buffer, scmd->request_buffer,
  540. sizeof(scmd->sense_buffer));
  541. }
  542. kfree(scsi_result);
  543. /*
  544. * when we eventually call scsi_finish, we really wish to complete
  545. * the original request, so let's restore the original data. (db)
  546. */
  547. scsi_setup_cmd_retry(scmd);
  548. scmd->result = saved_result;
  549. return rtn;
  550. }
  551. /**
  552. * scsi_eh_finish_cmd - Handle a cmd that eh is finished with.
  553. * @scmd: Original SCSI cmd that eh has finished.
  554. * @done_q: Queue for processed commands.
  555. *
  556. * Notes:
  557. * We don't want to use the normal command completion while we are are
  558. * still handling errors - it may cause other commands to be queued,
  559. * and that would disturb what we are doing. thus we really want to
  560. * keep a list of pending commands for final completion, and once we
  561. * are ready to leave error handling we handle completion for real.
  562. **/
  563. static void scsi_eh_finish_cmd(struct scsi_cmnd *scmd,
  564. struct list_head *done_q)
  565. {
  566. scmd->device->host->host_failed--;
  567. scmd->state = SCSI_STATE_BHQUEUE;
  568. scsi_eh_eflags_clr_all(scmd);
  569. /*
  570. * set this back so that the upper level can correctly free up
  571. * things.
  572. */
  573. scsi_setup_cmd_retry(scmd);
  574. list_move_tail(&scmd->eh_entry, done_q);
  575. }
  576. /**
  577. * scsi_eh_get_sense - Get device sense data.
  578. * @work_q: Queue of commands to process.
  579. * @done_q: Queue of proccessed commands..
  580. *
  581. * Description:
  582. * See if we need to request sense information. if so, then get it
  583. * now, so we have a better idea of what to do.
  584. *
  585. * Notes:
  586. * This has the unfortunate side effect that if a shost adapter does
  587. * not automatically request sense information, that we end up shutting
  588. * it down before we request it.
  589. *
  590. * All drivers should request sense information internally these days,
  591. * so for now all I have to say is tough noogies if you end up in here.
  592. *
  593. * XXX: Long term this code should go away, but that needs an audit of
  594. * all LLDDs first.
  595. **/
  596. static int scsi_eh_get_sense(struct list_head *work_q,
  597. struct list_head *done_q)
  598. {
  599. struct list_head *lh, *lh_sf;
  600. struct scsi_cmnd *scmd;
  601. int rtn;
  602. list_for_each_safe(lh, lh_sf, work_q) {
  603. scmd = list_entry(lh, struct scsi_cmnd, eh_entry);
  604. if (scsi_eh_eflags_chk(scmd, SCSI_EH_CANCEL_CMD) ||
  605. SCSI_SENSE_VALID(scmd))
  606. continue;
  607. SCSI_LOG_ERROR_RECOVERY(2, printk("%s: requesting sense"
  608. " for id: %d\n",
  609. current->comm,
  610. scmd->device->id));
  611. rtn = scsi_request_sense(scmd);
  612. if (rtn != SUCCESS)
  613. continue;
  614. SCSI_LOG_ERROR_RECOVERY(3, printk("sense requested for %p"
  615. " result %x\n", scmd,
  616. scmd->result));
  617. SCSI_LOG_ERROR_RECOVERY(3, scsi_print_sense("bh", scmd));
  618. rtn = scsi_decide_disposition(scmd);
  619. /*
  620. * if the result was normal, then just pass it along to the
  621. * upper level.
  622. */
  623. if (rtn == SUCCESS)
  624. /* we don't want this command reissued, just
  625. * finished with the sense data, so set
  626. * retries to the max allowed to ensure it
  627. * won't get reissued */
  628. scmd->retries = scmd->allowed;
  629. else if (rtn != NEEDS_RETRY)
  630. continue;
  631. scsi_eh_finish_cmd(scmd, done_q);
  632. }
  633. return list_empty(work_q);
  634. }
  635. /**
  636. * scsi_try_to_abort_cmd - Ask host to abort a running command.
  637. * @scmd: SCSI cmd to abort from Lower Level.
  638. *
  639. * Notes:
  640. * This function will not return until the user's completion function
  641. * has been called. there is no timeout on this operation. if the
  642. * author of the low-level driver wishes this operation to be timed,
  643. * they can provide this facility themselves. helper functions in
  644. * scsi_error.c can be supplied to make this easier to do.
  645. **/
  646. static int scsi_try_to_abort_cmd(struct scsi_cmnd *scmd)
  647. {
  648. if (!scmd->device->host->hostt->eh_abort_handler)
  649. return FAILED;
  650. /*
  651. * scsi_done was called just after the command timed out and before
  652. * we had a chance to process it. (db)
  653. */
  654. if (scmd->serial_number == 0)
  655. return SUCCESS;
  656. scmd->owner = SCSI_OWNER_LOWLEVEL;
  657. return scmd->device->host->hostt->eh_abort_handler(scmd);
  658. }
  659. /**
  660. * scsi_eh_tur - Send TUR to device.
  661. * @scmd: Scsi cmd to send TUR
  662. *
  663. * Return value:
  664. * 0 - Device is ready. 1 - Device NOT ready.
  665. **/
  666. static int scsi_eh_tur(struct scsi_cmnd *scmd)
  667. {
  668. static unsigned char tur_command[6] = {TEST_UNIT_READY, 0, 0, 0, 0, 0};
  669. int retry_cnt = 1, rtn;
  670. int saved_result;
  671. retry_tur:
  672. memcpy(scmd->cmnd, tur_command, sizeof(tur_command));
  673. /*
  674. * zero the sense buffer. the scsi spec mandates that any
  675. * untransferred sense data should be interpreted as being zero.
  676. */
  677. memset(scmd->sense_buffer, 0, sizeof(scmd->sense_buffer));
  678. saved_result = scmd->result;
  679. scmd->request_buffer = NULL;
  680. scmd->request_bufflen = 0;
  681. scmd->use_sg = 0;
  682. scmd->cmd_len = COMMAND_SIZE(scmd->cmnd[0]);
  683. scmd->underflow = 0;
  684. scmd->sc_data_direction = DMA_NONE;
  685. rtn = scsi_send_eh_cmnd(scmd, SENSE_TIMEOUT);
  686. /*
  687. * when we eventually call scsi_finish, we really wish to complete
  688. * the original request, so let's restore the original data. (db)
  689. */
  690. scsi_setup_cmd_retry(scmd);
  691. scmd->result = saved_result;
  692. /*
  693. * hey, we are done. let's look to see what happened.
  694. */
  695. SCSI_LOG_ERROR_RECOVERY(3, printk("%s: scmd %p rtn %x\n",
  696. __FUNCTION__, scmd, rtn));
  697. if (rtn == SUCCESS)
  698. return 0;
  699. else if (rtn == NEEDS_RETRY)
  700. if (retry_cnt--)
  701. goto retry_tur;
  702. return 1;
  703. }
  704. /**
  705. * scsi_eh_abort_cmds - abort canceled commands.
  706. * @shost: scsi host being recovered.
  707. * @eh_done_q: list_head for processed commands.
  708. *
  709. * Decription:
  710. * Try and see whether or not it makes sense to try and abort the
  711. * running command. this only works out to be the case if we have one
  712. * command that has timed out. if the command simply failed, it makes
  713. * no sense to try and abort the command, since as far as the shost
  714. * adapter is concerned, it isn't running.
  715. **/
  716. static int scsi_eh_abort_cmds(struct list_head *work_q,
  717. struct list_head *done_q)
  718. {
  719. struct list_head *lh, *lh_sf;
  720. struct scsi_cmnd *scmd;
  721. int rtn;
  722. list_for_each_safe(lh, lh_sf, work_q) {
  723. scmd = list_entry(lh, struct scsi_cmnd, eh_entry);
  724. if (!scsi_eh_eflags_chk(scmd, SCSI_EH_CANCEL_CMD))
  725. continue;
  726. SCSI_LOG_ERROR_RECOVERY(3, printk("%s: aborting cmd:"
  727. "0x%p\n", current->comm,
  728. scmd));
  729. rtn = scsi_try_to_abort_cmd(scmd);
  730. if (rtn == SUCCESS) {
  731. scsi_eh_eflags_clr(scmd, SCSI_EH_CANCEL_CMD);
  732. if (!scsi_device_online(scmd->device) ||
  733. !scsi_eh_tur(scmd)) {
  734. scsi_eh_finish_cmd(scmd, done_q);
  735. }
  736. } else
  737. SCSI_LOG_ERROR_RECOVERY(3, printk("%s: aborting"
  738. " cmd failed:"
  739. "0x%p\n",
  740. current->comm,
  741. scmd));
  742. }
  743. return list_empty(work_q);
  744. }
  745. /**
  746. * scsi_try_bus_device_reset - Ask host to perform a BDR on a dev
  747. * @scmd: SCSI cmd used to send BDR
  748. *
  749. * Notes:
  750. * There is no timeout for this operation. if this operation is
  751. * unreliable for a given host, then the host itself needs to put a
  752. * timer on it, and set the host back to a consistent state prior to
  753. * returning.
  754. **/
  755. static int scsi_try_bus_device_reset(struct scsi_cmnd *scmd)
  756. {
  757. int rtn;
  758. if (!scmd->device->host->hostt->eh_device_reset_handler)
  759. return FAILED;
  760. scmd->owner = SCSI_OWNER_LOWLEVEL;
  761. rtn = scmd->device->host->hostt->eh_device_reset_handler(scmd);
  762. if (rtn == SUCCESS) {
  763. scmd->device->was_reset = 1;
  764. scmd->device->expecting_cc_ua = 1;
  765. }
  766. return rtn;
  767. }
  768. /**
  769. * scsi_eh_try_stu - Send START_UNIT to device.
  770. * @scmd: Scsi cmd to send START_UNIT
  771. *
  772. * Return value:
  773. * 0 - Device is ready. 1 - Device NOT ready.
  774. **/
  775. static int scsi_eh_try_stu(struct scsi_cmnd *scmd)
  776. {
  777. static unsigned char stu_command[6] = {START_STOP, 0, 0, 0, 1, 0};
  778. int rtn;
  779. int saved_result;
  780. if (!scmd->device->allow_restart)
  781. return 1;
  782. memcpy(scmd->cmnd, stu_command, sizeof(stu_command));
  783. /*
  784. * zero the sense buffer. the scsi spec mandates that any
  785. * untransferred sense data should be interpreted as being zero.
  786. */
  787. memset(scmd->sense_buffer, 0, sizeof(scmd->sense_buffer));
  788. saved_result = scmd->result;
  789. scmd->request_buffer = NULL;
  790. scmd->request_bufflen = 0;
  791. scmd->use_sg = 0;
  792. scmd->cmd_len = COMMAND_SIZE(scmd->cmnd[0]);
  793. scmd->underflow = 0;
  794. scmd->sc_data_direction = DMA_NONE;
  795. rtn = scsi_send_eh_cmnd(scmd, START_UNIT_TIMEOUT);
  796. /*
  797. * when we eventually call scsi_finish, we really wish to complete
  798. * the original request, so let's restore the original data. (db)
  799. */
  800. scsi_setup_cmd_retry(scmd);
  801. scmd->result = saved_result;
  802. /*
  803. * hey, we are done. let's look to see what happened.
  804. */
  805. SCSI_LOG_ERROR_RECOVERY(3, printk("%s: scmd %p rtn %x\n",
  806. __FUNCTION__, scmd, rtn));
  807. if (rtn == SUCCESS)
  808. return 0;
  809. return 1;
  810. }
  811. /**
  812. * scsi_eh_stu - send START_UNIT if needed
  813. * @shost: scsi host being recovered.
  814. * @eh_done_q: list_head for processed commands.
  815. *
  816. * Notes:
  817. * If commands are failing due to not ready, initializing command required,
  818. * try revalidating the device, which will end up sending a start unit.
  819. **/
  820. static int scsi_eh_stu(struct Scsi_Host *shost,
  821. struct list_head *work_q,
  822. struct list_head *done_q)
  823. {
  824. struct list_head *lh, *lh_sf;
  825. struct scsi_cmnd *scmd, *stu_scmd;
  826. struct scsi_device *sdev;
  827. shost_for_each_device(sdev, shost) {
  828. stu_scmd = NULL;
  829. list_for_each_entry(scmd, work_q, eh_entry)
  830. if (scmd->device == sdev && SCSI_SENSE_VALID(scmd) &&
  831. scsi_check_sense(scmd) == FAILED ) {
  832. stu_scmd = scmd;
  833. break;
  834. }
  835. if (!stu_scmd)
  836. continue;
  837. SCSI_LOG_ERROR_RECOVERY(3, printk("%s: Sending START_UNIT to sdev:"
  838. " 0x%p\n", current->comm, sdev));
  839. if (!scsi_eh_try_stu(stu_scmd)) {
  840. if (!scsi_device_online(sdev) ||
  841. !scsi_eh_tur(stu_scmd)) {
  842. list_for_each_safe(lh, lh_sf, work_q) {
  843. scmd = list_entry(lh, struct scsi_cmnd, eh_entry);
  844. if (scmd->device == sdev)
  845. scsi_eh_finish_cmd(scmd, done_q);
  846. }
  847. }
  848. } else {
  849. SCSI_LOG_ERROR_RECOVERY(3,
  850. printk("%s: START_UNIT failed to sdev:"
  851. " 0x%p\n", current->comm, sdev));
  852. }
  853. }
  854. return list_empty(work_q);
  855. }
  856. /**
  857. * scsi_eh_bus_device_reset - send bdr if needed
  858. * @shost: scsi host being recovered.
  859. * @eh_done_q: list_head for processed commands.
  860. *
  861. * Notes:
  862. * Try a bus device reset. still, look to see whether we have multiple
  863. * devices that are jammed or not - if we have multiple devices, it
  864. * makes no sense to try bus_device_reset - we really would need to try
  865. * a bus_reset instead.
  866. **/
  867. static int scsi_eh_bus_device_reset(struct Scsi_Host *shost,
  868. struct list_head *work_q,
  869. struct list_head *done_q)
  870. {
  871. struct list_head *lh, *lh_sf;
  872. struct scsi_cmnd *scmd, *bdr_scmd;
  873. struct scsi_device *sdev;
  874. int rtn;
  875. shost_for_each_device(sdev, shost) {
  876. bdr_scmd = NULL;
  877. list_for_each_entry(scmd, work_q, eh_entry)
  878. if (scmd->device == sdev) {
  879. bdr_scmd = scmd;
  880. break;
  881. }
  882. if (!bdr_scmd)
  883. continue;
  884. SCSI_LOG_ERROR_RECOVERY(3, printk("%s: Sending BDR sdev:"
  885. " 0x%p\n", current->comm,
  886. sdev));
  887. rtn = scsi_try_bus_device_reset(bdr_scmd);
  888. if (rtn == SUCCESS) {
  889. if (!scsi_device_online(sdev) ||
  890. !scsi_eh_tur(bdr_scmd)) {
  891. list_for_each_safe(lh, lh_sf,
  892. work_q) {
  893. scmd = list_entry(lh, struct
  894. scsi_cmnd,
  895. eh_entry);
  896. if (scmd->device == sdev)
  897. scsi_eh_finish_cmd(scmd,
  898. done_q);
  899. }
  900. }
  901. } else {
  902. SCSI_LOG_ERROR_RECOVERY(3, printk("%s: BDR"
  903. " failed sdev:"
  904. "0x%p\n",
  905. current->comm,
  906. sdev));
  907. }
  908. }
  909. return list_empty(work_q);
  910. }
  911. /**
  912. * scsi_try_bus_reset - ask host to perform a bus reset
  913. * @scmd: SCSI cmd to send bus reset.
  914. **/
  915. static int scsi_try_bus_reset(struct scsi_cmnd *scmd)
  916. {
  917. unsigned long flags;
  918. int rtn;
  919. SCSI_LOG_ERROR_RECOVERY(3, printk("%s: Snd Bus RST\n",
  920. __FUNCTION__));
  921. scmd->owner = SCSI_OWNER_LOWLEVEL;
  922. if (!scmd->device->host->hostt->eh_bus_reset_handler)
  923. return FAILED;
  924. spin_lock_irqsave(scmd->device->host->host_lock, flags);
  925. rtn = scmd->device->host->hostt->eh_bus_reset_handler(scmd);
  926. spin_unlock_irqrestore(scmd->device->host->host_lock, flags);
  927. if (rtn == SUCCESS) {
  928. if (!scmd->device->host->hostt->skip_settle_delay)
  929. ssleep(BUS_RESET_SETTLE_TIME);
  930. spin_lock_irqsave(scmd->device->host->host_lock, flags);
  931. scsi_report_bus_reset(scmd->device->host, scmd->device->channel);
  932. spin_unlock_irqrestore(scmd->device->host->host_lock, flags);
  933. }
  934. return rtn;
  935. }
  936. /**
  937. * scsi_try_host_reset - ask host adapter to reset itself
  938. * @scmd: SCSI cmd to send hsot reset.
  939. **/
  940. static int scsi_try_host_reset(struct scsi_cmnd *scmd)
  941. {
  942. unsigned long flags;
  943. int rtn;
  944. SCSI_LOG_ERROR_RECOVERY(3, printk("%s: Snd Host RST\n",
  945. __FUNCTION__));
  946. scmd->owner = SCSI_OWNER_LOWLEVEL;
  947. if (!scmd->device->host->hostt->eh_host_reset_handler)
  948. return FAILED;
  949. spin_lock_irqsave(scmd->device->host->host_lock, flags);
  950. rtn = scmd->device->host->hostt->eh_host_reset_handler(scmd);
  951. spin_unlock_irqrestore(scmd->device->host->host_lock, flags);
  952. if (rtn == SUCCESS) {
  953. if (!scmd->device->host->hostt->skip_settle_delay)
  954. ssleep(HOST_RESET_SETTLE_TIME);
  955. spin_lock_irqsave(scmd->device->host->host_lock, flags);
  956. scsi_report_bus_reset(scmd->device->host, scmd->device->channel);
  957. spin_unlock_irqrestore(scmd->device->host->host_lock, flags);
  958. }
  959. return rtn;
  960. }
  961. /**
  962. * scsi_eh_bus_reset - send a bus reset
  963. * @shost: scsi host being recovered.
  964. * @eh_done_q: list_head for processed commands.
  965. **/
  966. static int scsi_eh_bus_reset(struct Scsi_Host *shost,
  967. struct list_head *work_q,
  968. struct list_head *done_q)
  969. {
  970. struct list_head *lh, *lh_sf;
  971. struct scsi_cmnd *scmd;
  972. struct scsi_cmnd *chan_scmd;
  973. unsigned int channel;
  974. int rtn;
  975. /*
  976. * we really want to loop over the various channels, and do this on
  977. * a channel by channel basis. we should also check to see if any
  978. * of the failed commands are on soft_reset devices, and if so, skip
  979. * the reset.
  980. */
  981. for (channel = 0; channel <= shost->max_channel; channel++) {
  982. chan_scmd = NULL;
  983. list_for_each_entry(scmd, work_q, eh_entry) {
  984. if (channel == scmd->device->channel) {
  985. chan_scmd = scmd;
  986. break;
  987. /*
  988. * FIXME add back in some support for
  989. * soft_reset devices.
  990. */
  991. }
  992. }
  993. if (!chan_scmd)
  994. continue;
  995. SCSI_LOG_ERROR_RECOVERY(3, printk("%s: Sending BRST chan:"
  996. " %d\n", current->comm,
  997. channel));
  998. rtn = scsi_try_bus_reset(chan_scmd);
  999. if (rtn == SUCCESS) {
  1000. list_for_each_safe(lh, lh_sf, work_q) {
  1001. scmd = list_entry(lh, struct scsi_cmnd,
  1002. eh_entry);
  1003. if (channel == scmd->device->channel)
  1004. if (!scsi_device_online(scmd->device) ||
  1005. !scsi_eh_tur(scmd))
  1006. scsi_eh_finish_cmd(scmd,
  1007. done_q);
  1008. }
  1009. } else {
  1010. SCSI_LOG_ERROR_RECOVERY(3, printk("%s: BRST"
  1011. " failed chan: %d\n",
  1012. current->comm,
  1013. channel));
  1014. }
  1015. }
  1016. return list_empty(work_q);
  1017. }
  1018. /**
  1019. * scsi_eh_host_reset - send a host reset
  1020. * @work_q: list_head for processed commands.
  1021. * @done_q: list_head for processed commands.
  1022. **/
  1023. static int scsi_eh_host_reset(struct list_head *work_q,
  1024. struct list_head *done_q)
  1025. {
  1026. int rtn;
  1027. struct list_head *lh, *lh_sf;
  1028. struct scsi_cmnd *scmd;
  1029. if (!list_empty(work_q)) {
  1030. scmd = list_entry(work_q->next,
  1031. struct scsi_cmnd, eh_entry);
  1032. SCSI_LOG_ERROR_RECOVERY(3, printk("%s: Sending HRST\n"
  1033. , current->comm));
  1034. rtn = scsi_try_host_reset(scmd);
  1035. if (rtn == SUCCESS) {
  1036. list_for_each_safe(lh, lh_sf, work_q) {
  1037. scmd = list_entry(lh, struct scsi_cmnd, eh_entry);
  1038. if (!scsi_device_online(scmd->device) ||
  1039. (!scsi_eh_try_stu(scmd) && !scsi_eh_tur(scmd)) ||
  1040. !scsi_eh_tur(scmd))
  1041. scsi_eh_finish_cmd(scmd, done_q);
  1042. }
  1043. } else {
  1044. SCSI_LOG_ERROR_RECOVERY(3, printk("%s: HRST"
  1045. " failed\n",
  1046. current->comm));
  1047. }
  1048. }
  1049. return list_empty(work_q);
  1050. }
  1051. /**
  1052. * scsi_eh_offline_sdevs - offline scsi devices that fail to recover
  1053. * @work_q: list_head for processed commands.
  1054. * @done_q: list_head for processed commands.
  1055. *
  1056. **/
  1057. static void scsi_eh_offline_sdevs(struct list_head *work_q,
  1058. struct list_head *done_q)
  1059. {
  1060. struct list_head *lh, *lh_sf;
  1061. struct scsi_cmnd *scmd;
  1062. list_for_each_safe(lh, lh_sf, work_q) {
  1063. scmd = list_entry(lh, struct scsi_cmnd, eh_entry);
  1064. printk(KERN_INFO "scsi: Device offlined - not"
  1065. " ready after error recovery: host"
  1066. " %d channel %d id %d lun %d\n",
  1067. scmd->device->host->host_no,
  1068. scmd->device->channel,
  1069. scmd->device->id,
  1070. scmd->device->lun);
  1071. scsi_device_set_state(scmd->device, SDEV_OFFLINE);
  1072. if (scsi_eh_eflags_chk(scmd, SCSI_EH_CANCEL_CMD)) {
  1073. /*
  1074. * FIXME: Handle lost cmds.
  1075. */
  1076. }
  1077. scsi_eh_finish_cmd(scmd, done_q);
  1078. }
  1079. return;
  1080. }
  1081. /**
  1082. * scsi_decide_disposition - Disposition a cmd on return from LLD.
  1083. * @scmd: SCSI cmd to examine.
  1084. *
  1085. * Notes:
  1086. * This is *only* called when we are examining the status after sending
  1087. * out the actual data command. any commands that are queued for error
  1088. * recovery (e.g. test_unit_ready) do *not* come through here.
  1089. *
  1090. * When this routine returns failed, it means the error handler thread
  1091. * is woken. In cases where the error code indicates an error that
  1092. * doesn't require the error handler read (i.e. we don't need to
  1093. * abort/reset), this function should return SUCCESS.
  1094. **/
  1095. int scsi_decide_disposition(struct scsi_cmnd *scmd)
  1096. {
  1097. int rtn;
  1098. /*
  1099. * if the device is offline, then we clearly just pass the result back
  1100. * up to the top level.
  1101. */
  1102. if (!scsi_device_online(scmd->device)) {
  1103. SCSI_LOG_ERROR_RECOVERY(5, printk("%s: device offline - report"
  1104. " as SUCCESS\n",
  1105. __FUNCTION__));
  1106. return SUCCESS;
  1107. }
  1108. /*
  1109. * first check the host byte, to see if there is anything in there
  1110. * that would indicate what we need to do.
  1111. */
  1112. switch (host_byte(scmd->result)) {
  1113. case DID_PASSTHROUGH:
  1114. /*
  1115. * no matter what, pass this through to the upper layer.
  1116. * nuke this special code so that it looks like we are saying
  1117. * did_ok.
  1118. */
  1119. scmd->result &= 0xff00ffff;
  1120. return SUCCESS;
  1121. case DID_OK:
  1122. /*
  1123. * looks good. drop through, and check the next byte.
  1124. */
  1125. break;
  1126. case DID_NO_CONNECT:
  1127. case DID_BAD_TARGET:
  1128. case DID_ABORT:
  1129. /*
  1130. * note - this means that we just report the status back
  1131. * to the top level driver, not that we actually think
  1132. * that it indicates SUCCESS.
  1133. */
  1134. return SUCCESS;
  1135. /*
  1136. * when the low level driver returns did_soft_error,
  1137. * it is responsible for keeping an internal retry counter
  1138. * in order to avoid endless loops (db)
  1139. *
  1140. * actually this is a bug in this function here. we should
  1141. * be mindful of the maximum number of retries specified
  1142. * and not get stuck in a loop.
  1143. */
  1144. case DID_SOFT_ERROR:
  1145. goto maybe_retry;
  1146. case DID_IMM_RETRY:
  1147. return NEEDS_RETRY;
  1148. case DID_REQUEUE:
  1149. return ADD_TO_MLQUEUE;
  1150. case DID_ERROR:
  1151. if (msg_byte(scmd->result) == COMMAND_COMPLETE &&
  1152. status_byte(scmd->result) == RESERVATION_CONFLICT)
  1153. /*
  1154. * execute reservation conflict processing code
  1155. * lower down
  1156. */
  1157. break;
  1158. /* fallthrough */
  1159. case DID_BUS_BUSY:
  1160. case DID_PARITY:
  1161. goto maybe_retry;
  1162. case DID_TIME_OUT:
  1163. /*
  1164. * when we scan the bus, we get timeout messages for
  1165. * these commands if there is no device available.
  1166. * other hosts report did_no_connect for the same thing.
  1167. */
  1168. if ((scmd->cmnd[0] == TEST_UNIT_READY ||
  1169. scmd->cmnd[0] == INQUIRY)) {
  1170. return SUCCESS;
  1171. } else {
  1172. return FAILED;
  1173. }
  1174. case DID_RESET:
  1175. return SUCCESS;
  1176. default:
  1177. return FAILED;
  1178. }
  1179. /*
  1180. * next, check the message byte.
  1181. */
  1182. if (msg_byte(scmd->result) != COMMAND_COMPLETE)
  1183. return FAILED;
  1184. /*
  1185. * check the status byte to see if this indicates anything special.
  1186. */
  1187. switch (status_byte(scmd->result)) {
  1188. case QUEUE_FULL:
  1189. /*
  1190. * the case of trying to send too many commands to a
  1191. * tagged queueing device.
  1192. */
  1193. case BUSY:
  1194. /*
  1195. * device can't talk to us at the moment. Should only
  1196. * occur (SAM-3) when the task queue is empty, so will cause
  1197. * the empty queue handling to trigger a stall in the
  1198. * device.
  1199. */
  1200. return ADD_TO_MLQUEUE;
  1201. case GOOD:
  1202. case COMMAND_TERMINATED:
  1203. case TASK_ABORTED:
  1204. return SUCCESS;
  1205. case CHECK_CONDITION:
  1206. rtn = scsi_check_sense(scmd);
  1207. if (rtn == NEEDS_RETRY)
  1208. goto maybe_retry;
  1209. /* if rtn == FAILED, we have no sense information;
  1210. * returning FAILED will wake the error handler thread
  1211. * to collect the sense and redo the decide
  1212. * disposition */
  1213. return rtn;
  1214. case CONDITION_GOOD:
  1215. case INTERMEDIATE_GOOD:
  1216. case INTERMEDIATE_C_GOOD:
  1217. case ACA_ACTIVE:
  1218. /*
  1219. * who knows? FIXME(eric)
  1220. */
  1221. return SUCCESS;
  1222. case RESERVATION_CONFLICT:
  1223. printk(KERN_INFO "scsi: reservation conflict: host"
  1224. " %d channel %d id %d lun %d\n",
  1225. scmd->device->host->host_no, scmd->device->channel,
  1226. scmd->device->id, scmd->device->lun);
  1227. return SUCCESS; /* causes immediate i/o error */
  1228. default:
  1229. return FAILED;
  1230. }
  1231. return FAILED;
  1232. maybe_retry:
  1233. /* we requeue for retry because the error was retryable, and
  1234. * the request was not marked fast fail. Note that above,
  1235. * even if the request is marked fast fail, we still requeue
  1236. * for queue congestion conditions (QUEUE_FULL or BUSY) */
  1237. if ((++scmd->retries) < scmd->allowed
  1238. && !blk_noretry_request(scmd->request)) {
  1239. return NEEDS_RETRY;
  1240. } else {
  1241. /*
  1242. * no more retries - report this one back to upper level.
  1243. */
  1244. return SUCCESS;
  1245. }
  1246. }
  1247. /**
  1248. * scsi_eh_lock_done - done function for eh door lock request
  1249. * @scmd: SCSI command block for the door lock request
  1250. *
  1251. * Notes:
  1252. * We completed the asynchronous door lock request, and it has either
  1253. * locked the door or failed. We must free the command structures
  1254. * associated with this request.
  1255. **/
  1256. static void scsi_eh_lock_done(struct scsi_cmnd *scmd)
  1257. {
  1258. struct scsi_request *sreq = scmd->sc_request;
  1259. scsi_release_request(sreq);
  1260. }
  1261. /**
  1262. * scsi_eh_lock_door - Prevent medium removal for the specified device
  1263. * @sdev: SCSI device to prevent medium removal
  1264. *
  1265. * Locking:
  1266. * We must be called from process context; scsi_allocate_request()
  1267. * may sleep.
  1268. *
  1269. * Notes:
  1270. * We queue up an asynchronous "ALLOW MEDIUM REMOVAL" request on the
  1271. * head of the devices request queue, and continue.
  1272. *
  1273. * Bugs:
  1274. * scsi_allocate_request() may sleep waiting for existing requests to
  1275. * be processed. However, since we haven't kicked off any request
  1276. * processing for this host, this may deadlock.
  1277. *
  1278. * If scsi_allocate_request() fails for what ever reason, we
  1279. * completely forget to lock the door.
  1280. **/
  1281. static void scsi_eh_lock_door(struct scsi_device *sdev)
  1282. {
  1283. struct scsi_request *sreq = scsi_allocate_request(sdev, GFP_KERNEL);
  1284. if (unlikely(!sreq)) {
  1285. printk(KERN_ERR "%s: request allocate failed,"
  1286. "prevent media removal cmd not sent\n", __FUNCTION__);
  1287. return;
  1288. }
  1289. sreq->sr_cmnd[0] = ALLOW_MEDIUM_REMOVAL;
  1290. sreq->sr_cmnd[1] = 0;
  1291. sreq->sr_cmnd[2] = 0;
  1292. sreq->sr_cmnd[3] = 0;
  1293. sreq->sr_cmnd[4] = SCSI_REMOVAL_PREVENT;
  1294. sreq->sr_cmnd[5] = 0;
  1295. sreq->sr_data_direction = DMA_NONE;
  1296. sreq->sr_bufflen = 0;
  1297. sreq->sr_buffer = NULL;
  1298. sreq->sr_allowed = 5;
  1299. sreq->sr_done = scsi_eh_lock_done;
  1300. sreq->sr_timeout_per_command = 10 * HZ;
  1301. sreq->sr_cmd_len = COMMAND_SIZE(sreq->sr_cmnd[0]);
  1302. scsi_insert_special_req(sreq, 1);
  1303. }
  1304. /**
  1305. * scsi_restart_operations - restart io operations to the specified host.
  1306. * @shost: Host we are restarting.
  1307. *
  1308. * Notes:
  1309. * When we entered the error handler, we blocked all further i/o to
  1310. * this device. we need to 'reverse' this process.
  1311. **/
  1312. static void scsi_restart_operations(struct Scsi_Host *shost)
  1313. {
  1314. struct scsi_device *sdev;
  1315. /*
  1316. * If the door was locked, we need to insert a door lock request
  1317. * onto the head of the SCSI request queue for the device. There
  1318. * is no point trying to lock the door of an off-line device.
  1319. */
  1320. shost_for_each_device(sdev, shost) {
  1321. if (scsi_device_online(sdev) && sdev->locked)
  1322. scsi_eh_lock_door(sdev);
  1323. }
  1324. /*
  1325. * next free up anything directly waiting upon the host. this
  1326. * will be requests for character device operations, and also for
  1327. * ioctls to queued block devices.
  1328. */
  1329. SCSI_LOG_ERROR_RECOVERY(3, printk("%s: waking up host to restart\n",
  1330. __FUNCTION__));
  1331. clear_bit(SHOST_RECOVERY, &shost->shost_state);
  1332. wake_up(&shost->host_wait);
  1333. /*
  1334. * finally we need to re-initiate requests that may be pending. we will
  1335. * have had everything blocked while error handling is taking place, and
  1336. * now that error recovery is done, we will need to ensure that these
  1337. * requests are started.
  1338. */
  1339. scsi_run_host_queues(shost);
  1340. }
  1341. /**
  1342. * scsi_eh_ready_devs - check device ready state and recover if not.
  1343. * @shost: host to be recovered.
  1344. * @eh_done_q: list_head for processed commands.
  1345. *
  1346. **/
  1347. static void scsi_eh_ready_devs(struct Scsi_Host *shost,
  1348. struct list_head *work_q,
  1349. struct list_head *done_q)
  1350. {
  1351. if (!scsi_eh_stu(shost, work_q, done_q))
  1352. if (!scsi_eh_bus_device_reset(shost, work_q, done_q))
  1353. if (!scsi_eh_bus_reset(shost, work_q, done_q))
  1354. if (!scsi_eh_host_reset(work_q, done_q))
  1355. scsi_eh_offline_sdevs(work_q, done_q);
  1356. }
  1357. /**
  1358. * scsi_eh_flush_done_q - finish processed commands or retry them.
  1359. * @done_q: list_head of processed commands.
  1360. *
  1361. **/
  1362. static void scsi_eh_flush_done_q(struct list_head *done_q)
  1363. {
  1364. struct list_head *lh, *lh_sf;
  1365. struct scsi_cmnd *scmd;
  1366. list_for_each_safe(lh, lh_sf, done_q) {
  1367. scmd = list_entry(lh, struct scsi_cmnd, eh_entry);
  1368. list_del_init(lh);
  1369. if (scsi_device_online(scmd->device) &&
  1370. !blk_noretry_request(scmd->request) &&
  1371. (++scmd->retries < scmd->allowed)) {
  1372. SCSI_LOG_ERROR_RECOVERY(3, printk("%s: flush"
  1373. " retry cmd: %p\n",
  1374. current->comm,
  1375. scmd));
  1376. scsi_queue_insert(scmd, SCSI_MLQUEUE_EH_RETRY);
  1377. } else {
  1378. /*
  1379. * If just we got sense for the device (called
  1380. * scsi_eh_get_sense), scmd->result is already
  1381. * set, do not set DRIVER_TIMEOUT.
  1382. */
  1383. if (!scmd->result)
  1384. scmd->result |= (DRIVER_TIMEOUT << 24);
  1385. SCSI_LOG_ERROR_RECOVERY(3, printk("%s: flush finish"
  1386. " cmd: %p\n",
  1387. current->comm, scmd));
  1388. scsi_finish_command(scmd);
  1389. }
  1390. }
  1391. }
  1392. /**
  1393. * scsi_unjam_host - Attempt to fix a host which has a cmd that failed.
  1394. * @shost: Host to unjam.
  1395. *
  1396. * Notes:
  1397. * When we come in here, we *know* that all commands on the bus have
  1398. * either completed, failed or timed out. we also know that no further
  1399. * commands are being sent to the host, so things are relatively quiet
  1400. * and we have freedom to fiddle with things as we wish.
  1401. *
  1402. * This is only the *default* implementation. it is possible for
  1403. * individual drivers to supply their own version of this function, and
  1404. * if the maintainer wishes to do this, it is strongly suggested that
  1405. * this function be taken as a template and modified. this function
  1406. * was designed to correctly handle problems for about 95% of the
  1407. * different cases out there, and it should always provide at least a
  1408. * reasonable amount of error recovery.
  1409. *
  1410. * Any command marked 'failed' or 'timeout' must eventually have
  1411. * scsi_finish_cmd() called for it. we do all of the retry stuff
  1412. * here, so when we restart the host after we return it should have an
  1413. * empty queue.
  1414. **/
  1415. static void scsi_unjam_host(struct Scsi_Host *shost)
  1416. {
  1417. unsigned long flags;
  1418. LIST_HEAD(eh_work_q);
  1419. LIST_HEAD(eh_done_q);
  1420. spin_lock_irqsave(shost->host_lock, flags);
  1421. list_splice_init(&shost->eh_cmd_q, &eh_work_q);
  1422. spin_unlock_irqrestore(shost->host_lock, flags);
  1423. SCSI_LOG_ERROR_RECOVERY(1, scsi_eh_prt_fail_stats(shost, &eh_work_q));
  1424. if (!scsi_eh_get_sense(&eh_work_q, &eh_done_q))
  1425. if (!scsi_eh_abort_cmds(&eh_work_q, &eh_done_q))
  1426. scsi_eh_ready_devs(shost, &eh_work_q, &eh_done_q);
  1427. scsi_eh_flush_done_q(&eh_done_q);
  1428. }
  1429. /**
  1430. * scsi_error_handler - Handle errors/timeouts of SCSI cmds.
  1431. * @data: Host for which we are running.
  1432. *
  1433. * Notes:
  1434. * This is always run in the context of a kernel thread. The idea is
  1435. * that we start this thing up when the kernel starts up (one per host
  1436. * that we detect), and it immediately goes to sleep and waits for some
  1437. * event (i.e. failure). When this takes place, we have the job of
  1438. * trying to unjam the bus and restarting things.
  1439. **/
  1440. int scsi_error_handler(void *data)
  1441. {
  1442. struct Scsi_Host *shost = (struct Scsi_Host *) data;
  1443. int rtn;
  1444. DECLARE_MUTEX_LOCKED(sem);
  1445. /*
  1446. * Flush resources
  1447. */
  1448. daemonize("scsi_eh_%d", shost->host_no);
  1449. current->flags |= PF_NOFREEZE;
  1450. shost->eh_wait = &sem;
  1451. shost->ehandler = current;
  1452. /*
  1453. * Wake up the thread that created us.
  1454. */
  1455. SCSI_LOG_ERROR_RECOVERY(3, printk("Wake up parent of"
  1456. " scsi_eh_%d\n",shost->host_no));
  1457. complete(shost->eh_notify);
  1458. while (1) {
  1459. /*
  1460. * If we get a signal, it means we are supposed to go
  1461. * away and die. This typically happens if the user is
  1462. * trying to unload a module.
  1463. */
  1464. SCSI_LOG_ERROR_RECOVERY(1, printk("Error handler"
  1465. " scsi_eh_%d"
  1466. " sleeping\n",shost->host_no));
  1467. /*
  1468. * Note - we always use down_interruptible with the semaphore
  1469. * even if the module was loaded as part of the kernel. The
  1470. * reason is that down() will cause this thread to be counted
  1471. * in the load average as a running process, and down
  1472. * interruptible doesn't. Given that we need to allow this
  1473. * thread to die if the driver was loaded as a module, using
  1474. * semaphores isn't unreasonable.
  1475. */
  1476. down_interruptible(&sem);
  1477. if (shost->eh_kill)
  1478. break;
  1479. SCSI_LOG_ERROR_RECOVERY(1, printk("Error handler"
  1480. " scsi_eh_%d waking"
  1481. " up\n",shost->host_no));
  1482. shost->eh_active = 1;
  1483. /*
  1484. * We have a host that is failing for some reason. Figure out
  1485. * what we need to do to get it up and online again (if we can).
  1486. * If we fail, we end up taking the thing offline.
  1487. */
  1488. if (shost->hostt->eh_strategy_handler)
  1489. rtn = shost->hostt->eh_strategy_handler(shost);
  1490. else
  1491. scsi_unjam_host(shost);
  1492. shost->eh_active = 0;
  1493. /*
  1494. * Note - if the above fails completely, the action is to take
  1495. * individual devices offline and flush the queue of any
  1496. * outstanding requests that may have been pending. When we
  1497. * restart, we restart any I/O to any other devices on the bus
  1498. * which are still online.
  1499. */
  1500. scsi_restart_operations(shost);
  1501. }
  1502. SCSI_LOG_ERROR_RECOVERY(1, printk("Error handler scsi_eh_%d"
  1503. " exiting\n",shost->host_no));
  1504. /*
  1505. * Make sure that nobody tries to wake us up again.
  1506. */
  1507. shost->eh_wait = NULL;
  1508. /*
  1509. * Knock this down too. From this point on, the host is flying
  1510. * without a pilot. If this is because the module is being unloaded,
  1511. * that's fine. If the user sent a signal to this thing, we are
  1512. * potentially in real danger.
  1513. */
  1514. shost->eh_active = 0;
  1515. shost->ehandler = NULL;
  1516. /*
  1517. * If anyone is waiting for us to exit (i.e. someone trying to unload
  1518. * a driver), then wake up that process to let them know we are on
  1519. * the way out the door.
  1520. */
  1521. complete_and_exit(shost->eh_notify, 0);
  1522. return 0;
  1523. }
  1524. /*
  1525. * Function: scsi_report_bus_reset()
  1526. *
  1527. * Purpose: Utility function used by low-level drivers to report that
  1528. * they have observed a bus reset on the bus being handled.
  1529. *
  1530. * Arguments: shost - Host in question
  1531. * channel - channel on which reset was observed.
  1532. *
  1533. * Returns: Nothing
  1534. *
  1535. * Lock status: Host lock must be held.
  1536. *
  1537. * Notes: This only needs to be called if the reset is one which
  1538. * originates from an unknown location. Resets originated
  1539. * by the mid-level itself don't need to call this, but there
  1540. * should be no harm.
  1541. *
  1542. * The main purpose of this is to make sure that a CHECK_CONDITION
  1543. * is properly treated.
  1544. */
  1545. void scsi_report_bus_reset(struct Scsi_Host *shost, int channel)
  1546. {
  1547. struct scsi_device *sdev;
  1548. __shost_for_each_device(sdev, shost) {
  1549. if (channel == sdev->channel) {
  1550. sdev->was_reset = 1;
  1551. sdev->expecting_cc_ua = 1;
  1552. }
  1553. }
  1554. }
  1555. EXPORT_SYMBOL(scsi_report_bus_reset);
  1556. /*
  1557. * Function: scsi_report_device_reset()
  1558. *
  1559. * Purpose: Utility function used by low-level drivers to report that
  1560. * they have observed a device reset on the device being handled.
  1561. *
  1562. * Arguments: shost - Host in question
  1563. * channel - channel on which reset was observed
  1564. * target - target on which reset was observed
  1565. *
  1566. * Returns: Nothing
  1567. *
  1568. * Lock status: Host lock must be held
  1569. *
  1570. * Notes: This only needs to be called if the reset is one which
  1571. * originates from an unknown location. Resets originated
  1572. * by the mid-level itself don't need to call this, but there
  1573. * should be no harm.
  1574. *
  1575. * The main purpose of this is to make sure that a CHECK_CONDITION
  1576. * is properly treated.
  1577. */
  1578. void scsi_report_device_reset(struct Scsi_Host *shost, int channel, int target)
  1579. {
  1580. struct scsi_device *sdev;
  1581. __shost_for_each_device(sdev, shost) {
  1582. if (channel == sdev->channel &&
  1583. target == sdev->id) {
  1584. sdev->was_reset = 1;
  1585. sdev->expecting_cc_ua = 1;
  1586. }
  1587. }
  1588. }
  1589. EXPORT_SYMBOL(scsi_report_device_reset);
  1590. static void
  1591. scsi_reset_provider_done_command(struct scsi_cmnd *scmd)
  1592. {
  1593. }
  1594. /*
  1595. * Function: scsi_reset_provider
  1596. *
  1597. * Purpose: Send requested reset to a bus or device at any phase.
  1598. *
  1599. * Arguments: device - device to send reset to
  1600. * flag - reset type (see scsi.h)
  1601. *
  1602. * Returns: SUCCESS/FAILURE.
  1603. *
  1604. * Notes: This is used by the SCSI Generic driver to provide
  1605. * Bus/Device reset capability.
  1606. */
  1607. int
  1608. scsi_reset_provider(struct scsi_device *dev, int flag)
  1609. {
  1610. struct scsi_cmnd *scmd = scsi_get_command(dev, GFP_KERNEL);
  1611. struct request req;
  1612. int rtn;
  1613. scmd->request = &req;
  1614. memset(&scmd->eh_timeout, 0, sizeof(scmd->eh_timeout));
  1615. scmd->request->rq_status = RQ_SCSI_BUSY;
  1616. scmd->state = SCSI_STATE_INITIALIZING;
  1617. scmd->owner = SCSI_OWNER_MIDLEVEL;
  1618. memset(&scmd->cmnd, '\0', sizeof(scmd->cmnd));
  1619. scmd->scsi_done = scsi_reset_provider_done_command;
  1620. scmd->done = NULL;
  1621. scmd->buffer = NULL;
  1622. scmd->bufflen = 0;
  1623. scmd->request_buffer = NULL;
  1624. scmd->request_bufflen = 0;
  1625. scmd->abort_reason = DID_ABORT;
  1626. scmd->cmd_len = 0;
  1627. scmd->sc_data_direction = DMA_BIDIRECTIONAL;
  1628. scmd->sc_request = NULL;
  1629. scmd->sc_magic = SCSI_CMND_MAGIC;
  1630. init_timer(&scmd->eh_timeout);
  1631. /*
  1632. * Sometimes the command can get back into the timer chain,
  1633. * so use the pid as an identifier.
  1634. */
  1635. scmd->pid = 0;
  1636. switch (flag) {
  1637. case SCSI_TRY_RESET_DEVICE:
  1638. rtn = scsi_try_bus_device_reset(scmd);
  1639. if (rtn == SUCCESS)
  1640. break;
  1641. /* FALLTHROUGH */
  1642. case SCSI_TRY_RESET_BUS:
  1643. rtn = scsi_try_bus_reset(scmd);
  1644. if (rtn == SUCCESS)
  1645. break;
  1646. /* FALLTHROUGH */
  1647. case SCSI_TRY_RESET_HOST:
  1648. rtn = scsi_try_host_reset(scmd);
  1649. break;
  1650. default:
  1651. rtn = FAILED;
  1652. }
  1653. scsi_next_command(scmd);
  1654. return rtn;
  1655. }
  1656. EXPORT_SYMBOL(scsi_reset_provider);
  1657. /**
  1658. * scsi_normalize_sense - normalize main elements from either fixed or
  1659. * descriptor sense data format into a common format.
  1660. *
  1661. * @sense_buffer: byte array containing sense data returned by device
  1662. * @sb_len: number of valid bytes in sense_buffer
  1663. * @sshdr: pointer to instance of structure that common
  1664. * elements are written to.
  1665. *
  1666. * Notes:
  1667. * The "main elements" from sense data are: response_code, sense_key,
  1668. * asc, ascq and additional_length (only for descriptor format).
  1669. *
  1670. * Typically this function can be called after a device has
  1671. * responded to a SCSI command with the CHECK_CONDITION status.
  1672. *
  1673. * Return value:
  1674. * 1 if valid sense data information found, else 0;
  1675. **/
  1676. int scsi_normalize_sense(const u8 *sense_buffer, int sb_len,
  1677. struct scsi_sense_hdr *sshdr)
  1678. {
  1679. if (!sense_buffer || !sb_len || (sense_buffer[0] & 0x70) != 0x70)
  1680. return 0;
  1681. memset(sshdr, 0, sizeof(struct scsi_sense_hdr));
  1682. sshdr->response_code = (sense_buffer[0] & 0x7f);
  1683. if (sshdr->response_code >= 0x72) {
  1684. /*
  1685. * descriptor format
  1686. */
  1687. if (sb_len > 1)
  1688. sshdr->sense_key = (sense_buffer[1] & 0xf);
  1689. if (sb_len > 2)
  1690. sshdr->asc = sense_buffer[2];
  1691. if (sb_len > 3)
  1692. sshdr->ascq = sense_buffer[3];
  1693. if (sb_len > 7)
  1694. sshdr->additional_length = sense_buffer[7];
  1695. } else {
  1696. /*
  1697. * fixed format
  1698. */
  1699. if (sb_len > 2)
  1700. sshdr->sense_key = (sense_buffer[2] & 0xf);
  1701. if (sb_len > 7) {
  1702. sb_len = (sb_len < (sense_buffer[7] + 8)) ?
  1703. sb_len : (sense_buffer[7] + 8);
  1704. if (sb_len > 12)
  1705. sshdr->asc = sense_buffer[12];
  1706. if (sb_len > 13)
  1707. sshdr->ascq = sense_buffer[13];
  1708. }
  1709. }
  1710. return 1;
  1711. }
  1712. EXPORT_SYMBOL(scsi_normalize_sense);
  1713. int scsi_request_normalize_sense(struct scsi_request *sreq,
  1714. struct scsi_sense_hdr *sshdr)
  1715. {
  1716. return scsi_normalize_sense(sreq->sr_sense_buffer,
  1717. sizeof(sreq->sr_sense_buffer), sshdr);
  1718. }
  1719. EXPORT_SYMBOL(scsi_request_normalize_sense);
  1720. int scsi_command_normalize_sense(struct scsi_cmnd *cmd,
  1721. struct scsi_sense_hdr *sshdr)
  1722. {
  1723. return scsi_normalize_sense(cmd->sense_buffer,
  1724. sizeof(cmd->sense_buffer), sshdr);
  1725. }
  1726. EXPORT_SYMBOL(scsi_command_normalize_sense);
  1727. /**
  1728. * scsi_sense_desc_find - search for a given descriptor type in
  1729. * descriptor sense data format.
  1730. *
  1731. * @sense_buffer: byte array of descriptor format sense data
  1732. * @sb_len: number of valid bytes in sense_buffer
  1733. * @desc_type: value of descriptor type to find
  1734. * (e.g. 0 -> information)
  1735. *
  1736. * Notes:
  1737. * only valid when sense data is in descriptor format
  1738. *
  1739. * Return value:
  1740. * pointer to start of (first) descriptor if found else NULL
  1741. **/
  1742. const u8 * scsi_sense_desc_find(const u8 * sense_buffer, int sb_len,
  1743. int desc_type)
  1744. {
  1745. int add_sen_len, add_len, desc_len, k;
  1746. const u8 * descp;
  1747. if ((sb_len < 8) || (0 == (add_sen_len = sense_buffer[7])))
  1748. return NULL;
  1749. if ((sense_buffer[0] < 0x72) || (sense_buffer[0] > 0x73))
  1750. return NULL;
  1751. add_sen_len = (add_sen_len < (sb_len - 8)) ?
  1752. add_sen_len : (sb_len - 8);
  1753. descp = &sense_buffer[8];
  1754. for (desc_len = 0, k = 0; k < add_sen_len; k += desc_len) {
  1755. descp += desc_len;
  1756. add_len = (k < (add_sen_len - 1)) ? descp[1]: -1;
  1757. desc_len = add_len + 2;
  1758. if (descp[0] == desc_type)
  1759. return descp;
  1760. if (add_len < 0) // short descriptor ??
  1761. break;
  1762. }
  1763. return NULL;
  1764. }
  1765. EXPORT_SYMBOL(scsi_sense_desc_find);
  1766. /**
  1767. * scsi_get_sense_info_fld - attempts to get information field from
  1768. * sense data (either fixed or descriptor format)
  1769. *
  1770. * @sense_buffer: byte array of sense data
  1771. * @sb_len: number of valid bytes in sense_buffer
  1772. * @info_out: pointer to 64 integer where 8 or 4 byte information
  1773. * field will be placed if found.
  1774. *
  1775. * Return value:
  1776. * 1 if information field found, 0 if not found.
  1777. **/
  1778. int scsi_get_sense_info_fld(const u8 * sense_buffer, int sb_len,
  1779. u64 * info_out)
  1780. {
  1781. int j;
  1782. const u8 * ucp;
  1783. u64 ull;
  1784. if (sb_len < 7)
  1785. return 0;
  1786. switch (sense_buffer[0] & 0x7f) {
  1787. case 0x70:
  1788. case 0x71:
  1789. if (sense_buffer[0] & 0x80) {
  1790. *info_out = (sense_buffer[3] << 24) +
  1791. (sense_buffer[4] << 16) +
  1792. (sense_buffer[5] << 8) + sense_buffer[6];
  1793. return 1;
  1794. } else
  1795. return 0;
  1796. case 0x72:
  1797. case 0x73:
  1798. ucp = scsi_sense_desc_find(sense_buffer, sb_len,
  1799. 0 /* info desc */);
  1800. if (ucp && (0xa == ucp[1])) {
  1801. ull = 0;
  1802. for (j = 0; j < 8; ++j) {
  1803. if (j > 0)
  1804. ull <<= 8;
  1805. ull |= ucp[4 + j];
  1806. }
  1807. *info_out = ull;
  1808. return 1;
  1809. } else
  1810. return 0;
  1811. default:
  1812. return 0;
  1813. }
  1814. }
  1815. EXPORT_SYMBOL(scsi_get_sense_info_fld);