scsi_scan.c 54 KB

12345678910111213141516171819202122232425262728293031323334353637383940414243444546474849505152535455565758596061626364656667686970717273747576777879808182838485868788899091929394959697989910010110210310410510610710810911011111211311411511611711811912012112212312412512612712812913013113213313413513613713813914014114214314414514614714814915015115215315415515615715815916016116216316416516616716816917017117217317417517617717817918018118218318418518618718818919019119219319419519619719819920020120220320420520620720820921021121221321421521621721821922022122222322422522622722822923023123223323423523623723823924024124224324424524624724824925025125225325425525625725825926026126226326426526626726826927027127227327427527627727827928028128228328428528628728828929029129229329429529629729829930030130230330430530630730830931031131231331431531631731831932032132232332432532632732832933033133233333433533633733833934034134234334434534634734834935035135235335435535635735835936036136236336436536636736836937037137237337437537637737837938038138238338438538638738838939039139239339439539639739839940040140240340440540640740840941041141241341441541641741841942042142242342442542642742842943043143243343443543643743843944044144244344444544644744844945045145245345445545645745845946046146246346446546646746846947047147247347447547647747847948048148248348448548648748848949049149249349449549649749849950050150250350450550650750850951051151251351451551651751851952052152252352452552652752852953053153253353453553653753853954054154254354454554654754854955055155255355455555655755855956056156256356456556656756856957057157257357457557657757857958058158258358458558658758858959059159259359459559659759859960060160260360460560660760860961061161261361461561661761861962062162262362462562662762862963063163263363463563663763863964064164264364464564664764864965065165265365465565665765865966066166266366466566666766866967067167267367467567667767867968068168268368468568668768868969069169269369469569669769869970070170270370470570670770870971071171271371471571671771871972072172272372472572672772872973073173273373473573673773873974074174274374474574674774874975075175275375475575675775875976076176276376476576676776876977077177277377477577677777877978078178278378478578678778878979079179279379479579679779879980080180280380480580680780880981081181281381481581681781881982082182282382482582682782882983083183283383483583683783883984084184284384484584684784884985085185285385485585685785885986086186286386486586686786886987087187287387487587687787887988088188288388488588688788888989089189289389489589689789889990090190290390490590690790890991091191291391491591691791891992092192292392492592692792892993093193293393493593693793893994094194294394494594694794894995095195295395495595695795895996096196296396496596696796896997097197297397497597697797897998098198298398498598698798898999099199299399499599699799899910001001100210031004100510061007100810091010101110121013101410151016101710181019102010211022102310241025102610271028102910301031103210331034103510361037103810391040104110421043104410451046104710481049105010511052105310541055105610571058105910601061106210631064106510661067106810691070107110721073107410751076107710781079108010811082108310841085108610871088108910901091109210931094109510961097109810991100110111021103110411051106110711081109111011111112111311141115111611171118111911201121112211231124112511261127112811291130113111321133113411351136113711381139114011411142114311441145114611471148114911501151115211531154115511561157115811591160116111621163116411651166116711681169117011711172117311741175117611771178117911801181118211831184118511861187118811891190119111921193119411951196119711981199120012011202120312041205120612071208120912101211121212131214121512161217121812191220122112221223122412251226122712281229123012311232123312341235123612371238123912401241124212431244124512461247124812491250125112521253125412551256125712581259126012611262126312641265126612671268126912701271127212731274127512761277127812791280128112821283128412851286128712881289129012911292129312941295129612971298129913001301130213031304130513061307130813091310131113121313131413151316131713181319132013211322132313241325132613271328132913301331133213331334133513361337133813391340134113421343134413451346134713481349135013511352135313541355135613571358135913601361136213631364136513661367136813691370137113721373137413751376137713781379138013811382138313841385138613871388138913901391139213931394139513961397139813991400140114021403140414051406140714081409141014111412141314141415141614171418141914201421142214231424142514261427142814291430143114321433143414351436143714381439144014411442144314441445144614471448144914501451145214531454145514561457145814591460146114621463146414651466146714681469147014711472147314741475147614771478147914801481148214831484148514861487148814891490149114921493149414951496149714981499150015011502150315041505150615071508150915101511151215131514151515161517151815191520152115221523152415251526152715281529153015311532153315341535153615371538153915401541154215431544154515461547154815491550155115521553155415551556155715581559156015611562156315641565156615671568156915701571157215731574157515761577157815791580158115821583158415851586158715881589159015911592159315941595159615971598159916001601160216031604160516061607160816091610161116121613161416151616161716181619162016211622162316241625162616271628162916301631163216331634163516361637163816391640164116421643164416451646164716481649165016511652165316541655165616571658165916601661166216631664166516661667166816691670167116721673167416751676167716781679168016811682168316841685168616871688168916901691169216931694169516961697169816991700170117021703170417051706170717081709171017111712171317141715171617171718171917201721172217231724172517261727172817291730173117321733173417351736173717381739174017411742174317441745174617471748174917501751175217531754175517561757175817591760176117621763176417651766176717681769177017711772177317741775177617771778177917801781178217831784178517861787178817891790179117921793179417951796179717981799180018011802180318041805180618071808180918101811181218131814181518161817181818191820182118221823182418251826182718281829183018311832183318341835183618371838183918401841184218431844184518461847184818491850185118521853185418551856185718581859186018611862186318641865186618671868186918701871187218731874187518761877187818791880188118821883188418851886188718881889189018911892189318941895189618971898189919001901190219031904190519061907190819091910191119121913191419151916191719181919192019211922192319241925192619271928192919301931193219331934193519361937193819391940194119421943194419451946194719481949
  1. /*
  2. * scsi_scan.c
  3. *
  4. * Copyright (C) 2000 Eric Youngdale,
  5. * Copyright (C) 2002 Patrick Mansfield
  6. *
  7. * The general scanning/probing algorithm is as follows, exceptions are
  8. * made to it depending on device specific flags, compilation options, and
  9. * global variable (boot or module load time) settings.
  10. *
  11. * A specific LUN is scanned via an INQUIRY command; if the LUN has a
  12. * device attached, a scsi_device is allocated and setup for it.
  13. *
  14. * For every id of every channel on the given host:
  15. *
  16. * Scan LUN 0; if the target responds to LUN 0 (even if there is no
  17. * device or storage attached to LUN 0):
  18. *
  19. * If LUN 0 has a device attached, allocate and setup a
  20. * scsi_device for it.
  21. *
  22. * If target is SCSI-3 or up, issue a REPORT LUN, and scan
  23. * all of the LUNs returned by the REPORT LUN; else,
  24. * sequentially scan LUNs up until some maximum is reached,
  25. * or a LUN is seen that cannot have a device attached to it.
  26. */
  27. #include <linux/module.h>
  28. #include <linux/moduleparam.h>
  29. #include <linux/init.h>
  30. #include <linux/blkdev.h>
  31. #include <linux/delay.h>
  32. #include <linux/kthread.h>
  33. #include <linux/spinlock.h>
  34. #include <linux/async.h>
  35. #include <scsi/scsi.h>
  36. #include <scsi/scsi_cmnd.h>
  37. #include <scsi/scsi_device.h>
  38. #include <scsi/scsi_driver.h>
  39. #include <scsi/scsi_devinfo.h>
  40. #include <scsi/scsi_host.h>
  41. #include <scsi/scsi_transport.h>
  42. #include <scsi/scsi_eh.h>
  43. #include "scsi_priv.h"
  44. #include "scsi_logging.h"
  45. #define ALLOC_FAILURE_MSG KERN_ERR "%s: Allocation failure during" \
  46. " SCSI scanning, some SCSI devices might not be configured\n"
  47. /*
  48. * Default timeout
  49. */
  50. #define SCSI_TIMEOUT (2*HZ)
  51. /*
  52. * Prefix values for the SCSI id's (stored in sysfs name field)
  53. */
  54. #define SCSI_UID_SER_NUM 'S'
  55. #define SCSI_UID_UNKNOWN 'Z'
  56. /*
  57. * Return values of some of the scanning functions.
  58. *
  59. * SCSI_SCAN_NO_RESPONSE: no valid response received from the target, this
  60. * includes allocation or general failures preventing IO from being sent.
  61. *
  62. * SCSI_SCAN_TARGET_PRESENT: target responded, but no device is available
  63. * on the given LUN.
  64. *
  65. * SCSI_SCAN_LUN_PRESENT: target responded, and a device is available on a
  66. * given LUN.
  67. */
  68. #define SCSI_SCAN_NO_RESPONSE 0
  69. #define SCSI_SCAN_TARGET_PRESENT 1
  70. #define SCSI_SCAN_LUN_PRESENT 2
  71. static const char *scsi_null_device_strs = "nullnullnullnull";
  72. #define MAX_SCSI_LUNS 512
  73. #ifdef CONFIG_SCSI_MULTI_LUN
  74. static unsigned int max_scsi_luns = MAX_SCSI_LUNS;
  75. #else
  76. static unsigned int max_scsi_luns = 1;
  77. #endif
  78. module_param_named(max_luns, max_scsi_luns, uint, S_IRUGO|S_IWUSR);
  79. MODULE_PARM_DESC(max_luns,
  80. "last scsi LUN (should be between 1 and 2^32-1)");
  81. #ifdef CONFIG_SCSI_SCAN_ASYNC
  82. #define SCSI_SCAN_TYPE_DEFAULT "async"
  83. #else
  84. #define SCSI_SCAN_TYPE_DEFAULT "sync"
  85. #endif
  86. static char scsi_scan_type[6] = SCSI_SCAN_TYPE_DEFAULT;
  87. module_param_string(scan, scsi_scan_type, sizeof(scsi_scan_type), S_IRUGO);
  88. MODULE_PARM_DESC(scan, "sync, async or none");
  89. /*
  90. * max_scsi_report_luns: the maximum number of LUNS that will be
  91. * returned from the REPORT LUNS command. 8 times this value must
  92. * be allocated. In theory this could be up to an 8 byte value, but
  93. * in practice, the maximum number of LUNs suppored by any device
  94. * is about 16k.
  95. */
  96. static unsigned int max_scsi_report_luns = 511;
  97. module_param_named(max_report_luns, max_scsi_report_luns, uint, S_IRUGO|S_IWUSR);
  98. MODULE_PARM_DESC(max_report_luns,
  99. "REPORT LUNS maximum number of LUNS received (should be"
  100. " between 1 and 16384)");
  101. static unsigned int scsi_inq_timeout = SCSI_TIMEOUT/HZ + 18;
  102. module_param_named(inq_timeout, scsi_inq_timeout, uint, S_IRUGO|S_IWUSR);
  103. MODULE_PARM_DESC(inq_timeout,
  104. "Timeout (in seconds) waiting for devices to answer INQUIRY."
  105. " Default is 20. Some devices may need more; most need less.");
  106. /* This lock protects only this list */
  107. static DEFINE_SPINLOCK(async_scan_lock);
  108. static LIST_HEAD(scanning_hosts);
  109. struct async_scan_data {
  110. struct list_head list;
  111. struct Scsi_Host *shost;
  112. struct completion prev_finished;
  113. };
  114. /**
  115. * scsi_complete_async_scans - Wait for asynchronous scans to complete
  116. *
  117. * When this function returns, any host which started scanning before
  118. * this function was called will have finished its scan. Hosts which
  119. * started scanning after this function was called may or may not have
  120. * finished.
  121. */
  122. int scsi_complete_async_scans(void)
  123. {
  124. struct async_scan_data *data;
  125. do {
  126. if (list_empty(&scanning_hosts))
  127. return 0;
  128. /* If we can't get memory immediately, that's OK. Just
  129. * sleep a little. Even if we never get memory, the async
  130. * scans will finish eventually.
  131. */
  132. data = kmalloc(sizeof(*data), GFP_KERNEL);
  133. if (!data)
  134. msleep(1);
  135. } while (!data);
  136. data->shost = NULL;
  137. init_completion(&data->prev_finished);
  138. spin_lock(&async_scan_lock);
  139. /* Check that there's still somebody else on the list */
  140. if (list_empty(&scanning_hosts))
  141. goto done;
  142. list_add_tail(&data->list, &scanning_hosts);
  143. spin_unlock(&async_scan_lock);
  144. printk(KERN_INFO "scsi: waiting for bus probes to complete ...\n");
  145. wait_for_completion(&data->prev_finished);
  146. spin_lock(&async_scan_lock);
  147. list_del(&data->list);
  148. if (!list_empty(&scanning_hosts)) {
  149. struct async_scan_data *next = list_entry(scanning_hosts.next,
  150. struct async_scan_data, list);
  151. complete(&next->prev_finished);
  152. }
  153. done:
  154. spin_unlock(&async_scan_lock);
  155. kfree(data);
  156. return 0;
  157. }
  158. /* Only exported for the benefit of scsi_wait_scan */
  159. EXPORT_SYMBOL_GPL(scsi_complete_async_scans);
  160. #ifndef MODULE
  161. /*
  162. * For async scanning we need to wait for all the scans to complete before
  163. * trying to mount the root fs. Otherwise non-modular drivers may not be ready
  164. * yet.
  165. */
  166. late_initcall(scsi_complete_async_scans);
  167. #endif
  168. /**
  169. * scsi_unlock_floptical - unlock device via a special MODE SENSE command
  170. * @sdev: scsi device to send command to
  171. * @result: area to store the result of the MODE SENSE
  172. *
  173. * Description:
  174. * Send a vendor specific MODE SENSE (not a MODE SELECT) command.
  175. * Called for BLIST_KEY devices.
  176. **/
  177. static void scsi_unlock_floptical(struct scsi_device *sdev,
  178. unsigned char *result)
  179. {
  180. unsigned char scsi_cmd[MAX_COMMAND_SIZE];
  181. printk(KERN_NOTICE "scsi: unlocking floptical drive\n");
  182. scsi_cmd[0] = MODE_SENSE;
  183. scsi_cmd[1] = 0;
  184. scsi_cmd[2] = 0x2e;
  185. scsi_cmd[3] = 0;
  186. scsi_cmd[4] = 0x2a; /* size */
  187. scsi_cmd[5] = 0;
  188. scsi_execute_req(sdev, scsi_cmd, DMA_FROM_DEVICE, result, 0x2a, NULL,
  189. SCSI_TIMEOUT, 3, NULL);
  190. }
  191. /**
  192. * scsi_alloc_sdev - allocate and setup a scsi_Device
  193. * @starget: which target to allocate a &scsi_device for
  194. * @lun: which lun
  195. * @hostdata: usually NULL and set by ->slave_alloc instead
  196. *
  197. * Description:
  198. * Allocate, initialize for io, and return a pointer to a scsi_Device.
  199. * Stores the @shost, @channel, @id, and @lun in the scsi_Device, and
  200. * adds scsi_Device to the appropriate list.
  201. *
  202. * Return value:
  203. * scsi_Device pointer, or NULL on failure.
  204. **/
  205. static struct scsi_device *scsi_alloc_sdev(struct scsi_target *starget,
  206. unsigned int lun, void *hostdata)
  207. {
  208. struct scsi_device *sdev;
  209. int display_failure_msg = 1, ret;
  210. struct Scsi_Host *shost = dev_to_shost(starget->dev.parent);
  211. extern void scsi_evt_thread(struct work_struct *work);
  212. sdev = kzalloc(sizeof(*sdev) + shost->transportt->device_size,
  213. GFP_ATOMIC);
  214. if (!sdev)
  215. goto out;
  216. sdev->vendor = scsi_null_device_strs;
  217. sdev->model = scsi_null_device_strs;
  218. sdev->rev = scsi_null_device_strs;
  219. sdev->host = shost;
  220. sdev->id = starget->id;
  221. sdev->lun = lun;
  222. sdev->channel = starget->channel;
  223. sdev->sdev_state = SDEV_CREATED;
  224. INIT_LIST_HEAD(&sdev->siblings);
  225. INIT_LIST_HEAD(&sdev->same_target_siblings);
  226. INIT_LIST_HEAD(&sdev->cmd_list);
  227. INIT_LIST_HEAD(&sdev->starved_entry);
  228. INIT_LIST_HEAD(&sdev->event_list);
  229. spin_lock_init(&sdev->list_lock);
  230. INIT_WORK(&sdev->event_work, scsi_evt_thread);
  231. sdev->sdev_gendev.parent = get_device(&starget->dev);
  232. sdev->sdev_target = starget;
  233. /* usually NULL and set by ->slave_alloc instead */
  234. sdev->hostdata = hostdata;
  235. /* if the device needs this changing, it may do so in the
  236. * slave_configure function */
  237. sdev->max_device_blocked = SCSI_DEFAULT_DEVICE_BLOCKED;
  238. /*
  239. * Some low level driver could use device->type
  240. */
  241. sdev->type = -1;
  242. /*
  243. * Assume that the device will have handshaking problems,
  244. * and then fix this field later if it turns out it
  245. * doesn't
  246. */
  247. sdev->borken = 1;
  248. sdev->request_queue = scsi_alloc_queue(sdev);
  249. if (!sdev->request_queue) {
  250. /* release fn is set up in scsi_sysfs_device_initialise, so
  251. * have to free and put manually here */
  252. put_device(&starget->dev);
  253. kfree(sdev);
  254. goto out;
  255. }
  256. sdev->request_queue->queuedata = sdev;
  257. scsi_adjust_queue_depth(sdev, 0, sdev->host->cmd_per_lun);
  258. scsi_sysfs_device_initialize(sdev);
  259. if (shost->hostt->slave_alloc) {
  260. ret = shost->hostt->slave_alloc(sdev);
  261. if (ret) {
  262. /*
  263. * if LLDD reports slave not present, don't clutter
  264. * console with alloc failure messages
  265. */
  266. if (ret == -ENXIO)
  267. display_failure_msg = 0;
  268. goto out_device_destroy;
  269. }
  270. }
  271. return sdev;
  272. out_device_destroy:
  273. scsi_device_set_state(sdev, SDEV_DEL);
  274. transport_destroy_device(&sdev->sdev_gendev);
  275. put_device(&sdev->sdev_dev);
  276. put_device(&sdev->sdev_gendev);
  277. out:
  278. if (display_failure_msg)
  279. printk(ALLOC_FAILURE_MSG, __func__);
  280. return NULL;
  281. }
  282. static void scsi_target_destroy(struct scsi_target *starget)
  283. {
  284. struct device *dev = &starget->dev;
  285. struct Scsi_Host *shost = dev_to_shost(dev->parent);
  286. unsigned long flags;
  287. transport_destroy_device(dev);
  288. spin_lock_irqsave(shost->host_lock, flags);
  289. if (shost->hostt->target_destroy)
  290. shost->hostt->target_destroy(starget);
  291. list_del_init(&starget->siblings);
  292. spin_unlock_irqrestore(shost->host_lock, flags);
  293. put_device(dev);
  294. }
  295. static void scsi_target_dev_release(struct device *dev)
  296. {
  297. struct device *parent = dev->parent;
  298. struct scsi_target *starget = to_scsi_target(dev);
  299. kfree(starget);
  300. put_device(parent);
  301. }
  302. static struct device_type scsi_target_type = {
  303. .name = "scsi_target",
  304. .release = scsi_target_dev_release,
  305. };
  306. int scsi_is_target_device(const struct device *dev)
  307. {
  308. return dev->type == &scsi_target_type;
  309. }
  310. EXPORT_SYMBOL(scsi_is_target_device);
  311. static struct scsi_target *__scsi_find_target(struct device *parent,
  312. int channel, uint id)
  313. {
  314. struct scsi_target *starget, *found_starget = NULL;
  315. struct Scsi_Host *shost = dev_to_shost(parent);
  316. /*
  317. * Search for an existing target for this sdev.
  318. */
  319. list_for_each_entry(starget, &shost->__targets, siblings) {
  320. if (starget->id == id &&
  321. starget->channel == channel) {
  322. found_starget = starget;
  323. break;
  324. }
  325. }
  326. if (found_starget)
  327. get_device(&found_starget->dev);
  328. return found_starget;
  329. }
  330. /**
  331. * scsi_alloc_target - allocate a new or find an existing target
  332. * @parent: parent of the target (need not be a scsi host)
  333. * @channel: target channel number (zero if no channels)
  334. * @id: target id number
  335. *
  336. * Return an existing target if one exists, provided it hasn't already
  337. * gone into STARGET_DEL state, otherwise allocate a new target.
  338. *
  339. * The target is returned with an incremented reference, so the caller
  340. * is responsible for both reaping and doing a last put
  341. */
  342. static struct scsi_target *scsi_alloc_target(struct device *parent,
  343. int channel, uint id)
  344. {
  345. struct Scsi_Host *shost = dev_to_shost(parent);
  346. struct device *dev = NULL;
  347. unsigned long flags;
  348. const int size = sizeof(struct scsi_target)
  349. + shost->transportt->target_size;
  350. struct scsi_target *starget;
  351. struct scsi_target *found_target;
  352. int error;
  353. starget = kzalloc(size, GFP_KERNEL);
  354. if (!starget) {
  355. printk(KERN_ERR "%s: allocation failure\n", __func__);
  356. return NULL;
  357. }
  358. dev = &starget->dev;
  359. device_initialize(dev);
  360. starget->reap_ref = 1;
  361. dev->parent = get_device(parent);
  362. dev_set_name(dev, "target%d:%d:%d", shost->host_no, channel, id);
  363. #ifndef CONFIG_SYSFS_DEPRECATED
  364. dev->bus = &scsi_bus_type;
  365. #endif
  366. dev->type = &scsi_target_type;
  367. starget->id = id;
  368. starget->channel = channel;
  369. starget->can_queue = 0;
  370. INIT_LIST_HEAD(&starget->siblings);
  371. INIT_LIST_HEAD(&starget->devices);
  372. starget->state = STARGET_CREATED;
  373. starget->scsi_level = SCSI_2;
  374. starget->max_target_blocked = SCSI_DEFAULT_TARGET_BLOCKED;
  375. retry:
  376. spin_lock_irqsave(shost->host_lock, flags);
  377. found_target = __scsi_find_target(parent, channel, id);
  378. if (found_target)
  379. goto found;
  380. list_add_tail(&starget->siblings, &shost->__targets);
  381. spin_unlock_irqrestore(shost->host_lock, flags);
  382. /* allocate and add */
  383. transport_setup_device(dev);
  384. if (shost->hostt->target_alloc) {
  385. error = shost->hostt->target_alloc(starget);
  386. if(error) {
  387. dev_printk(KERN_ERR, dev, "target allocation failed, error %d\n", error);
  388. /* don't want scsi_target_reap to do the final
  389. * put because it will be under the host lock */
  390. scsi_target_destroy(starget);
  391. return NULL;
  392. }
  393. }
  394. get_device(dev);
  395. return starget;
  396. found:
  397. found_target->reap_ref++;
  398. spin_unlock_irqrestore(shost->host_lock, flags);
  399. if (found_target->state != STARGET_DEL) {
  400. put_device(parent);
  401. kfree(starget);
  402. return found_target;
  403. }
  404. /* Unfortunately, we found a dying target; need to
  405. * wait until it's dead before we can get a new one */
  406. put_device(&found_target->dev);
  407. flush_scheduled_work();
  408. goto retry;
  409. }
  410. static void scsi_target_reap_usercontext(struct work_struct *work)
  411. {
  412. struct scsi_target *starget =
  413. container_of(work, struct scsi_target, ew.work);
  414. transport_remove_device(&starget->dev);
  415. device_del(&starget->dev);
  416. scsi_target_destroy(starget);
  417. }
  418. /**
  419. * scsi_target_reap - check to see if target is in use and destroy if not
  420. * @starget: target to be checked
  421. *
  422. * This is used after removing a LUN or doing a last put of the target
  423. * it checks atomically that nothing is using the target and removes
  424. * it if so.
  425. */
  426. void scsi_target_reap(struct scsi_target *starget)
  427. {
  428. struct Scsi_Host *shost = dev_to_shost(starget->dev.parent);
  429. unsigned long flags;
  430. enum scsi_target_state state;
  431. int empty;
  432. spin_lock_irqsave(shost->host_lock, flags);
  433. state = starget->state;
  434. empty = --starget->reap_ref == 0 &&
  435. list_empty(&starget->devices) ? 1 : 0;
  436. spin_unlock_irqrestore(shost->host_lock, flags);
  437. if (!empty)
  438. return;
  439. BUG_ON(state == STARGET_DEL);
  440. starget->state = STARGET_DEL;
  441. if (state == STARGET_CREATED)
  442. scsi_target_destroy(starget);
  443. else
  444. execute_in_process_context(scsi_target_reap_usercontext,
  445. &starget->ew);
  446. }
  447. /**
  448. * sanitize_inquiry_string - remove non-graphical chars from an INQUIRY result string
  449. * @s: INQUIRY result string to sanitize
  450. * @len: length of the string
  451. *
  452. * Description:
  453. * The SCSI spec says that INQUIRY vendor, product, and revision
  454. * strings must consist entirely of graphic ASCII characters,
  455. * padded on the right with spaces. Since not all devices obey
  456. * this rule, we will replace non-graphic or non-ASCII characters
  457. * with spaces. Exception: a NUL character is interpreted as a
  458. * string terminator, so all the following characters are set to
  459. * spaces.
  460. **/
  461. static void sanitize_inquiry_string(unsigned char *s, int len)
  462. {
  463. int terminated = 0;
  464. for (; len > 0; (--len, ++s)) {
  465. if (*s == 0)
  466. terminated = 1;
  467. if (terminated || *s < 0x20 || *s > 0x7e)
  468. *s = ' ';
  469. }
  470. }
  471. /**
  472. * scsi_probe_lun - probe a single LUN using a SCSI INQUIRY
  473. * @sdev: scsi_device to probe
  474. * @inq_result: area to store the INQUIRY result
  475. * @result_len: len of inq_result
  476. * @bflags: store any bflags found here
  477. *
  478. * Description:
  479. * Probe the lun associated with @req using a standard SCSI INQUIRY;
  480. *
  481. * If the INQUIRY is successful, zero is returned and the
  482. * INQUIRY data is in @inq_result; the scsi_level and INQUIRY length
  483. * are copied to the scsi_device any flags value is stored in *@bflags.
  484. **/
  485. static int scsi_probe_lun(struct scsi_device *sdev, unsigned char *inq_result,
  486. int result_len, int *bflags)
  487. {
  488. unsigned char scsi_cmd[MAX_COMMAND_SIZE];
  489. int first_inquiry_len, try_inquiry_len, next_inquiry_len;
  490. int response_len = 0;
  491. int pass, count, result;
  492. struct scsi_sense_hdr sshdr;
  493. *bflags = 0;
  494. /* Perform up to 3 passes. The first pass uses a conservative
  495. * transfer length of 36 unless sdev->inquiry_len specifies a
  496. * different value. */
  497. first_inquiry_len = sdev->inquiry_len ? sdev->inquiry_len : 36;
  498. try_inquiry_len = first_inquiry_len;
  499. pass = 1;
  500. next_pass:
  501. SCSI_LOG_SCAN_BUS(3, sdev_printk(KERN_INFO, sdev,
  502. "scsi scan: INQUIRY pass %d length %d\n",
  503. pass, try_inquiry_len));
  504. /* Each pass gets up to three chances to ignore Unit Attention */
  505. for (count = 0; count < 3; ++count) {
  506. int resid;
  507. memset(scsi_cmd, 0, 6);
  508. scsi_cmd[0] = INQUIRY;
  509. scsi_cmd[4] = (unsigned char) try_inquiry_len;
  510. memset(inq_result, 0, try_inquiry_len);
  511. result = scsi_execute_req(sdev, scsi_cmd, DMA_FROM_DEVICE,
  512. inq_result, try_inquiry_len, &sshdr,
  513. HZ / 2 + HZ * scsi_inq_timeout, 3,
  514. &resid);
  515. SCSI_LOG_SCAN_BUS(3, printk(KERN_INFO "scsi scan: INQUIRY %s "
  516. "with code 0x%x\n",
  517. result ? "failed" : "successful", result));
  518. if (result) {
  519. /*
  520. * not-ready to ready transition [asc/ascq=0x28/0x0]
  521. * or power-on, reset [asc/ascq=0x29/0x0], continue.
  522. * INQUIRY should not yield UNIT_ATTENTION
  523. * but many buggy devices do so anyway.
  524. */
  525. if ((driver_byte(result) & DRIVER_SENSE) &&
  526. scsi_sense_valid(&sshdr)) {
  527. if ((sshdr.sense_key == UNIT_ATTENTION) &&
  528. ((sshdr.asc == 0x28) ||
  529. (sshdr.asc == 0x29)) &&
  530. (sshdr.ascq == 0))
  531. continue;
  532. }
  533. } else {
  534. /*
  535. * if nothing was transferred, we try
  536. * again. It's a workaround for some USB
  537. * devices.
  538. */
  539. if (resid == try_inquiry_len)
  540. continue;
  541. }
  542. break;
  543. }
  544. if (result == 0) {
  545. sanitize_inquiry_string(&inq_result[8], 8);
  546. sanitize_inquiry_string(&inq_result[16], 16);
  547. sanitize_inquiry_string(&inq_result[32], 4);
  548. response_len = inq_result[4] + 5;
  549. if (response_len > 255)
  550. response_len = first_inquiry_len; /* sanity */
  551. /*
  552. * Get any flags for this device.
  553. *
  554. * XXX add a bflags to scsi_device, and replace the
  555. * corresponding bit fields in scsi_device, so bflags
  556. * need not be passed as an argument.
  557. */
  558. *bflags = scsi_get_device_flags(sdev, &inq_result[8],
  559. &inq_result[16]);
  560. /* When the first pass succeeds we gain information about
  561. * what larger transfer lengths might work. */
  562. if (pass == 1) {
  563. if (BLIST_INQUIRY_36 & *bflags)
  564. next_inquiry_len = 36;
  565. else if (BLIST_INQUIRY_58 & *bflags)
  566. next_inquiry_len = 58;
  567. else if (sdev->inquiry_len)
  568. next_inquiry_len = sdev->inquiry_len;
  569. else
  570. next_inquiry_len = response_len;
  571. /* If more data is available perform the second pass */
  572. if (next_inquiry_len > try_inquiry_len) {
  573. try_inquiry_len = next_inquiry_len;
  574. pass = 2;
  575. goto next_pass;
  576. }
  577. }
  578. } else if (pass == 2) {
  579. printk(KERN_INFO "scsi scan: %d byte inquiry failed. "
  580. "Consider BLIST_INQUIRY_36 for this device\n",
  581. try_inquiry_len);
  582. /* If this pass failed, the third pass goes back and transfers
  583. * the same amount as we successfully got in the first pass. */
  584. try_inquiry_len = first_inquiry_len;
  585. pass = 3;
  586. goto next_pass;
  587. }
  588. /* If the last transfer attempt got an error, assume the
  589. * peripheral doesn't exist or is dead. */
  590. if (result)
  591. return -EIO;
  592. /* Don't report any more data than the device says is valid */
  593. sdev->inquiry_len = min(try_inquiry_len, response_len);
  594. /*
  595. * XXX Abort if the response length is less than 36? If less than
  596. * 32, the lookup of the device flags (above) could be invalid,
  597. * and it would be possible to take an incorrect action - we do
  598. * not want to hang because of a short INQUIRY. On the flip side,
  599. * if the device is spun down or becoming ready (and so it gives a
  600. * short INQUIRY), an abort here prevents any further use of the
  601. * device, including spin up.
  602. *
  603. * On the whole, the best approach seems to be to assume the first
  604. * 36 bytes are valid no matter what the device says. That's
  605. * better than copying < 36 bytes to the inquiry-result buffer
  606. * and displaying garbage for the Vendor, Product, or Revision
  607. * strings.
  608. */
  609. if (sdev->inquiry_len < 36) {
  610. printk(KERN_INFO "scsi scan: INQUIRY result too short (%d),"
  611. " using 36\n", sdev->inquiry_len);
  612. sdev->inquiry_len = 36;
  613. }
  614. /*
  615. * Related to the above issue:
  616. *
  617. * XXX Devices (disk or all?) should be sent a TEST UNIT READY,
  618. * and if not ready, sent a START_STOP to start (maybe spin up) and
  619. * then send the INQUIRY again, since the INQUIRY can change after
  620. * a device is initialized.
  621. *
  622. * Ideally, start a device if explicitly asked to do so. This
  623. * assumes that a device is spun up on power on, spun down on
  624. * request, and then spun up on request.
  625. */
  626. /*
  627. * The scanning code needs to know the scsi_level, even if no
  628. * device is attached at LUN 0 (SCSI_SCAN_TARGET_PRESENT) so
  629. * non-zero LUNs can be scanned.
  630. */
  631. sdev->scsi_level = inq_result[2] & 0x07;
  632. if (sdev->scsi_level >= 2 ||
  633. (sdev->scsi_level == 1 && (inq_result[3] & 0x0f) == 1))
  634. sdev->scsi_level++;
  635. sdev->sdev_target->scsi_level = sdev->scsi_level;
  636. return 0;
  637. }
  638. /**
  639. * scsi_add_lun - allocate and fully initialze a scsi_device
  640. * @sdev: holds information to be stored in the new scsi_device
  641. * @inq_result: holds the result of a previous INQUIRY to the LUN
  642. * @bflags: black/white list flag
  643. * @async: 1 if this device is being scanned asynchronously
  644. *
  645. * Description:
  646. * Initialize the scsi_device @sdev. Optionally set fields based
  647. * on values in *@bflags.
  648. *
  649. * Return:
  650. * SCSI_SCAN_NO_RESPONSE: could not allocate or setup a scsi_device
  651. * SCSI_SCAN_LUN_PRESENT: a new scsi_device was allocated and initialized
  652. **/
  653. static int scsi_add_lun(struct scsi_device *sdev, unsigned char *inq_result,
  654. int *bflags, int async)
  655. {
  656. int ret;
  657. /*
  658. * XXX do not save the inquiry, since it can change underneath us,
  659. * save just vendor/model/rev.
  660. *
  661. * Rather than save it and have an ioctl that retrieves the saved
  662. * value, have an ioctl that executes the same INQUIRY code used
  663. * in scsi_probe_lun, let user level programs doing INQUIRY
  664. * scanning run at their own risk, or supply a user level program
  665. * that can correctly scan.
  666. */
  667. /*
  668. * Copy at least 36 bytes of INQUIRY data, so that we don't
  669. * dereference unallocated memory when accessing the Vendor,
  670. * Product, and Revision strings. Badly behaved devices may set
  671. * the INQUIRY Additional Length byte to a small value, indicating
  672. * these strings are invalid, but often they contain plausible data
  673. * nonetheless. It doesn't matter if the device sent < 36 bytes
  674. * total, since scsi_probe_lun() initializes inq_result with 0s.
  675. */
  676. sdev->inquiry = kmemdup(inq_result,
  677. max_t(size_t, sdev->inquiry_len, 36),
  678. GFP_ATOMIC);
  679. if (sdev->inquiry == NULL)
  680. return SCSI_SCAN_NO_RESPONSE;
  681. sdev->vendor = (char *) (sdev->inquiry + 8);
  682. sdev->model = (char *) (sdev->inquiry + 16);
  683. sdev->rev = (char *) (sdev->inquiry + 32);
  684. if (*bflags & BLIST_ISROM) {
  685. sdev->type = TYPE_ROM;
  686. sdev->removable = 1;
  687. } else {
  688. sdev->type = (inq_result[0] & 0x1f);
  689. sdev->removable = (inq_result[1] & 0x80) >> 7;
  690. }
  691. switch (sdev->type) {
  692. case TYPE_RBC:
  693. case TYPE_TAPE:
  694. case TYPE_DISK:
  695. case TYPE_PRINTER:
  696. case TYPE_MOD:
  697. case TYPE_PROCESSOR:
  698. case TYPE_SCANNER:
  699. case TYPE_MEDIUM_CHANGER:
  700. case TYPE_ENCLOSURE:
  701. case TYPE_COMM:
  702. case TYPE_RAID:
  703. case TYPE_OSD:
  704. sdev->writeable = 1;
  705. break;
  706. case TYPE_ROM:
  707. case TYPE_WORM:
  708. sdev->writeable = 0;
  709. break;
  710. default:
  711. printk(KERN_INFO "scsi: unknown device type %d\n", sdev->type);
  712. }
  713. if (sdev->type == TYPE_RBC || sdev->type == TYPE_ROM) {
  714. /* RBC and MMC devices can return SCSI-3 compliance and yet
  715. * still not support REPORT LUNS, so make them act as
  716. * BLIST_NOREPORTLUN unless BLIST_REPORTLUN2 is
  717. * specifically set */
  718. if ((*bflags & BLIST_REPORTLUN2) == 0)
  719. *bflags |= BLIST_NOREPORTLUN;
  720. }
  721. /*
  722. * For a peripheral qualifier (PQ) value of 1 (001b), the SCSI
  723. * spec says: The device server is capable of supporting the
  724. * specified peripheral device type on this logical unit. However,
  725. * the physical device is not currently connected to this logical
  726. * unit.
  727. *
  728. * The above is vague, as it implies that we could treat 001 and
  729. * 011 the same. Stay compatible with previous code, and create a
  730. * scsi_device for a PQ of 1
  731. *
  732. * Don't set the device offline here; rather let the upper
  733. * level drivers eval the PQ to decide whether they should
  734. * attach. So remove ((inq_result[0] >> 5) & 7) == 1 check.
  735. */
  736. sdev->inq_periph_qual = (inq_result[0] >> 5) & 7;
  737. sdev->lockable = sdev->removable;
  738. sdev->soft_reset = (inq_result[7] & 1) && ((inq_result[3] & 7) == 2);
  739. if (sdev->scsi_level >= SCSI_3 ||
  740. (sdev->inquiry_len > 56 && inq_result[56] & 0x04))
  741. sdev->ppr = 1;
  742. if (inq_result[7] & 0x60)
  743. sdev->wdtr = 1;
  744. if (inq_result[7] & 0x10)
  745. sdev->sdtr = 1;
  746. sdev_printk(KERN_NOTICE, sdev, "%s %.8s %.16s %.4s PQ: %d "
  747. "ANSI: %d%s\n", scsi_device_type(sdev->type),
  748. sdev->vendor, sdev->model, sdev->rev,
  749. sdev->inq_periph_qual, inq_result[2] & 0x07,
  750. (inq_result[3] & 0x0f) == 1 ? " CCS" : "");
  751. if ((sdev->scsi_level >= SCSI_2) && (inq_result[7] & 2) &&
  752. !(*bflags & BLIST_NOTQ))
  753. sdev->tagged_supported = 1;
  754. /*
  755. * Some devices (Texel CD ROM drives) have handshaking problems
  756. * when used with the Seagate controllers. borken is initialized
  757. * to 1, and then set it to 0 here.
  758. */
  759. if ((*bflags & BLIST_BORKEN) == 0)
  760. sdev->borken = 0;
  761. if (*bflags & BLIST_NO_ULD_ATTACH)
  762. sdev->no_uld_attach = 1;
  763. /*
  764. * Apparently some really broken devices (contrary to the SCSI
  765. * standards) need to be selected without asserting ATN
  766. */
  767. if (*bflags & BLIST_SELECT_NO_ATN)
  768. sdev->select_no_atn = 1;
  769. /*
  770. * Maximum 512 sector transfer length
  771. * broken RA4x00 Compaq Disk Array
  772. */
  773. if (*bflags & BLIST_MAX_512)
  774. blk_queue_max_sectors(sdev->request_queue, 512);
  775. /*
  776. * Some devices may not want to have a start command automatically
  777. * issued when a device is added.
  778. */
  779. if (*bflags & BLIST_NOSTARTONADD)
  780. sdev->no_start_on_add = 1;
  781. if (*bflags & BLIST_SINGLELUN)
  782. scsi_target(sdev)->single_lun = 1;
  783. sdev->use_10_for_rw = 1;
  784. if (*bflags & BLIST_MS_SKIP_PAGE_08)
  785. sdev->skip_ms_page_8 = 1;
  786. if (*bflags & BLIST_MS_SKIP_PAGE_3F)
  787. sdev->skip_ms_page_3f = 1;
  788. if (*bflags & BLIST_USE_10_BYTE_MS)
  789. sdev->use_10_for_ms = 1;
  790. /* set the device running here so that slave configure
  791. * may do I/O */
  792. ret = scsi_device_set_state(sdev, SDEV_RUNNING);
  793. if (ret) {
  794. ret = scsi_device_set_state(sdev, SDEV_BLOCK);
  795. if (ret) {
  796. sdev_printk(KERN_ERR, sdev,
  797. "in wrong state %s to complete scan\n",
  798. scsi_device_state_name(sdev->sdev_state));
  799. return SCSI_SCAN_NO_RESPONSE;
  800. }
  801. }
  802. if (*bflags & BLIST_MS_192_BYTES_FOR_3F)
  803. sdev->use_192_bytes_for_3f = 1;
  804. if (*bflags & BLIST_NOT_LOCKABLE)
  805. sdev->lockable = 0;
  806. if (*bflags & BLIST_RETRY_HWERROR)
  807. sdev->retry_hwerror = 1;
  808. transport_configure_device(&sdev->sdev_gendev);
  809. if (sdev->host->hostt->slave_configure) {
  810. ret = sdev->host->hostt->slave_configure(sdev);
  811. if (ret) {
  812. /*
  813. * if LLDD reports slave not present, don't clutter
  814. * console with alloc failure messages
  815. */
  816. if (ret != -ENXIO) {
  817. sdev_printk(KERN_ERR, sdev,
  818. "failed to configure device\n");
  819. }
  820. return SCSI_SCAN_NO_RESPONSE;
  821. }
  822. }
  823. /*
  824. * Ok, the device is now all set up, we can
  825. * register it and tell the rest of the kernel
  826. * about it.
  827. */
  828. if (!async && scsi_sysfs_add_sdev(sdev) != 0)
  829. return SCSI_SCAN_NO_RESPONSE;
  830. return SCSI_SCAN_LUN_PRESENT;
  831. }
  832. static inline void scsi_destroy_sdev(struct scsi_device *sdev)
  833. {
  834. scsi_device_set_state(sdev, SDEV_DEL);
  835. if (sdev->host->hostt->slave_destroy)
  836. sdev->host->hostt->slave_destroy(sdev);
  837. transport_destroy_device(&sdev->sdev_gendev);
  838. put_device(&sdev->sdev_dev);
  839. put_device(&sdev->sdev_gendev);
  840. }
  841. #ifdef CONFIG_SCSI_LOGGING
  842. /**
  843. * scsi_inq_str - print INQUIRY data from min to max index, strip trailing whitespace
  844. * @buf: Output buffer with at least end-first+1 bytes of space
  845. * @inq: Inquiry buffer (input)
  846. * @first: Offset of string into inq
  847. * @end: Index after last character in inq
  848. */
  849. static unsigned char *scsi_inq_str(unsigned char *buf, unsigned char *inq,
  850. unsigned first, unsigned end)
  851. {
  852. unsigned term = 0, idx;
  853. for (idx = 0; idx + first < end && idx + first < inq[4] + 5; idx++) {
  854. if (inq[idx+first] > ' ') {
  855. buf[idx] = inq[idx+first];
  856. term = idx+1;
  857. } else {
  858. buf[idx] = ' ';
  859. }
  860. }
  861. buf[term] = 0;
  862. return buf;
  863. }
  864. #endif
  865. /**
  866. * scsi_probe_and_add_lun - probe a LUN, if a LUN is found add it
  867. * @starget: pointer to target device structure
  868. * @lun: LUN of target device
  869. * @bflagsp: store bflags here if not NULL
  870. * @sdevp: probe the LUN corresponding to this scsi_device
  871. * @rescan: if nonzero skip some code only needed on first scan
  872. * @hostdata: passed to scsi_alloc_sdev()
  873. *
  874. * Description:
  875. * Call scsi_probe_lun, if a LUN with an attached device is found,
  876. * allocate and set it up by calling scsi_add_lun.
  877. *
  878. * Return:
  879. * SCSI_SCAN_NO_RESPONSE: could not allocate or setup a scsi_device
  880. * SCSI_SCAN_TARGET_PRESENT: target responded, but no device is
  881. * attached at the LUN
  882. * SCSI_SCAN_LUN_PRESENT: a new scsi_device was allocated and initialized
  883. **/
  884. static int scsi_probe_and_add_lun(struct scsi_target *starget,
  885. uint lun, int *bflagsp,
  886. struct scsi_device **sdevp, int rescan,
  887. void *hostdata)
  888. {
  889. struct scsi_device *sdev;
  890. unsigned char *result;
  891. int bflags, res = SCSI_SCAN_NO_RESPONSE, result_len = 256;
  892. struct Scsi_Host *shost = dev_to_shost(starget->dev.parent);
  893. /*
  894. * The rescan flag is used as an optimization, the first scan of a
  895. * host adapter calls into here with rescan == 0.
  896. */
  897. sdev = scsi_device_lookup_by_target(starget, lun);
  898. if (sdev) {
  899. if (rescan || !scsi_device_created(sdev)) {
  900. SCSI_LOG_SCAN_BUS(3, printk(KERN_INFO
  901. "scsi scan: device exists on %s\n",
  902. dev_name(&sdev->sdev_gendev)));
  903. if (sdevp)
  904. *sdevp = sdev;
  905. else
  906. scsi_device_put(sdev);
  907. if (bflagsp)
  908. *bflagsp = scsi_get_device_flags(sdev,
  909. sdev->vendor,
  910. sdev->model);
  911. return SCSI_SCAN_LUN_PRESENT;
  912. }
  913. scsi_device_put(sdev);
  914. } else
  915. sdev = scsi_alloc_sdev(starget, lun, hostdata);
  916. if (!sdev)
  917. goto out;
  918. result = kmalloc(result_len, GFP_ATOMIC |
  919. ((shost->unchecked_isa_dma) ? __GFP_DMA : 0));
  920. if (!result)
  921. goto out_free_sdev;
  922. if (scsi_probe_lun(sdev, result, result_len, &bflags))
  923. goto out_free_result;
  924. if (bflagsp)
  925. *bflagsp = bflags;
  926. /*
  927. * result contains valid SCSI INQUIRY data.
  928. */
  929. if (((result[0] >> 5) == 3) && !(bflags & BLIST_ATTACH_PQ3)) {
  930. /*
  931. * For a Peripheral qualifier 3 (011b), the SCSI
  932. * spec says: The device server is not capable of
  933. * supporting a physical device on this logical
  934. * unit.
  935. *
  936. * For disks, this implies that there is no
  937. * logical disk configured at sdev->lun, but there
  938. * is a target id responding.
  939. */
  940. SCSI_LOG_SCAN_BUS(2, sdev_printk(KERN_INFO, sdev, "scsi scan:"
  941. " peripheral qualifier of 3, device not"
  942. " added\n"))
  943. if (lun == 0) {
  944. SCSI_LOG_SCAN_BUS(1, {
  945. unsigned char vend[9];
  946. unsigned char mod[17];
  947. sdev_printk(KERN_INFO, sdev,
  948. "scsi scan: consider passing scsi_mod."
  949. "dev_flags=%s:%s:0x240 or 0x1000240\n",
  950. scsi_inq_str(vend, result, 8, 16),
  951. scsi_inq_str(mod, result, 16, 32));
  952. });
  953. }
  954. res = SCSI_SCAN_TARGET_PRESENT;
  955. goto out_free_result;
  956. }
  957. /*
  958. * Some targets may set slight variations of PQ and PDT to signal
  959. * that no LUN is present, so don't add sdev in these cases.
  960. * Two specific examples are:
  961. * 1) NetApp targets: return PQ=1, PDT=0x1f
  962. * 2) USB UFI: returns PDT=0x1f, with the PQ bits being "reserved"
  963. * in the UFI 1.0 spec (we cannot rely on reserved bits).
  964. *
  965. * References:
  966. * 1) SCSI SPC-3, pp. 145-146
  967. * PQ=1: "A peripheral device having the specified peripheral
  968. * device type is not connected to this logical unit. However, the
  969. * device server is capable of supporting the specified peripheral
  970. * device type on this logical unit."
  971. * PDT=0x1f: "Unknown or no device type"
  972. * 2) USB UFI 1.0, p. 20
  973. * PDT=00h Direct-access device (floppy)
  974. * PDT=1Fh none (no FDD connected to the requested logical unit)
  975. */
  976. if (((result[0] >> 5) == 1 || starget->pdt_1f_for_no_lun) &&
  977. (result[0] & 0x1f) == 0x1f &&
  978. !scsi_is_wlun(lun)) {
  979. SCSI_LOG_SCAN_BUS(3, printk(KERN_INFO
  980. "scsi scan: peripheral device type"
  981. " of 31, no device added\n"));
  982. res = SCSI_SCAN_TARGET_PRESENT;
  983. goto out_free_result;
  984. }
  985. res = scsi_add_lun(sdev, result, &bflags, shost->async_scan);
  986. if (res == SCSI_SCAN_LUN_PRESENT) {
  987. if (bflags & BLIST_KEY) {
  988. sdev->lockable = 0;
  989. scsi_unlock_floptical(sdev, result);
  990. }
  991. }
  992. out_free_result:
  993. kfree(result);
  994. out_free_sdev:
  995. if (res == SCSI_SCAN_LUN_PRESENT) {
  996. if (sdevp) {
  997. if (scsi_device_get(sdev) == 0) {
  998. *sdevp = sdev;
  999. } else {
  1000. __scsi_remove_device(sdev);
  1001. res = SCSI_SCAN_NO_RESPONSE;
  1002. }
  1003. }
  1004. } else
  1005. scsi_destroy_sdev(sdev);
  1006. out:
  1007. return res;
  1008. }
  1009. /**
  1010. * scsi_sequential_lun_scan - sequentially scan a SCSI target
  1011. * @starget: pointer to target structure to scan
  1012. * @bflags: black/white list flag for LUN 0
  1013. * @scsi_level: Which version of the standard does this device adhere to
  1014. * @rescan: passed to scsi_probe_add_lun()
  1015. *
  1016. * Description:
  1017. * Generally, scan from LUN 1 (LUN 0 is assumed to already have been
  1018. * scanned) to some maximum lun until a LUN is found with no device
  1019. * attached. Use the bflags to figure out any oddities.
  1020. *
  1021. * Modifies sdevscan->lun.
  1022. **/
  1023. static void scsi_sequential_lun_scan(struct scsi_target *starget,
  1024. int bflags, int scsi_level, int rescan)
  1025. {
  1026. unsigned int sparse_lun, lun, max_dev_lun;
  1027. struct Scsi_Host *shost = dev_to_shost(starget->dev.parent);
  1028. SCSI_LOG_SCAN_BUS(3, printk(KERN_INFO "scsi scan: Sequential scan of"
  1029. "%s\n", dev_name(&starget->dev)));
  1030. max_dev_lun = min(max_scsi_luns, shost->max_lun);
  1031. /*
  1032. * If this device is known to support sparse multiple units,
  1033. * override the other settings, and scan all of them. Normally,
  1034. * SCSI-3 devices should be scanned via the REPORT LUNS.
  1035. */
  1036. if (bflags & BLIST_SPARSELUN) {
  1037. max_dev_lun = shost->max_lun;
  1038. sparse_lun = 1;
  1039. } else
  1040. sparse_lun = 0;
  1041. /*
  1042. * If less than SCSI_1_CSS, and no special lun scaning, stop
  1043. * scanning; this matches 2.4 behaviour, but could just be a bug
  1044. * (to continue scanning a SCSI_1_CSS device).
  1045. *
  1046. * This test is broken. We might not have any device on lun0 for
  1047. * a sparselun device, and if that's the case then how would we
  1048. * know the real scsi_level, eh? It might make sense to just not
  1049. * scan any SCSI_1 device for non-0 luns, but that check would best
  1050. * go into scsi_alloc_sdev() and just have it return null when asked
  1051. * to alloc an sdev for lun > 0 on an already found SCSI_1 device.
  1052. *
  1053. if ((sdevscan->scsi_level < SCSI_1_CCS) &&
  1054. ((bflags & (BLIST_FORCELUN | BLIST_SPARSELUN | BLIST_MAX5LUN))
  1055. == 0))
  1056. return;
  1057. */
  1058. /*
  1059. * If this device is known to support multiple units, override
  1060. * the other settings, and scan all of them.
  1061. */
  1062. if (bflags & BLIST_FORCELUN)
  1063. max_dev_lun = shost->max_lun;
  1064. /*
  1065. * REGAL CDC-4X: avoid hang after LUN 4
  1066. */
  1067. if (bflags & BLIST_MAX5LUN)
  1068. max_dev_lun = min(5U, max_dev_lun);
  1069. /*
  1070. * Do not scan SCSI-2 or lower device past LUN 7, unless
  1071. * BLIST_LARGELUN.
  1072. */
  1073. if (scsi_level < SCSI_3 && !(bflags & BLIST_LARGELUN))
  1074. max_dev_lun = min(8U, max_dev_lun);
  1075. /*
  1076. * We have already scanned LUN 0, so start at LUN 1. Keep scanning
  1077. * until we reach the max, or no LUN is found and we are not
  1078. * sparse_lun.
  1079. */
  1080. for (lun = 1; lun < max_dev_lun; ++lun)
  1081. if ((scsi_probe_and_add_lun(starget, lun, NULL, NULL, rescan,
  1082. NULL) != SCSI_SCAN_LUN_PRESENT) &&
  1083. !sparse_lun)
  1084. return;
  1085. }
  1086. /**
  1087. * scsilun_to_int: convert a scsi_lun to an int
  1088. * @scsilun: struct scsi_lun to be converted.
  1089. *
  1090. * Description:
  1091. * Convert @scsilun from a struct scsi_lun to a four byte host byte-ordered
  1092. * integer, and return the result. The caller must check for
  1093. * truncation before using this function.
  1094. *
  1095. * Notes:
  1096. * The struct scsi_lun is assumed to be four levels, with each level
  1097. * effectively containing a SCSI byte-ordered (big endian) short; the
  1098. * addressing bits of each level are ignored (the highest two bits).
  1099. * For a description of the LUN format, post SCSI-3 see the SCSI
  1100. * Architecture Model, for SCSI-3 see the SCSI Controller Commands.
  1101. *
  1102. * Given a struct scsi_lun of: 0a 04 0b 03 00 00 00 00, this function returns
  1103. * the integer: 0x0b030a04
  1104. **/
  1105. int scsilun_to_int(struct scsi_lun *scsilun)
  1106. {
  1107. int i;
  1108. unsigned int lun;
  1109. lun = 0;
  1110. for (i = 0; i < sizeof(lun); i += 2)
  1111. lun = lun | (((scsilun->scsi_lun[i] << 8) |
  1112. scsilun->scsi_lun[i + 1]) << (i * 8));
  1113. return lun;
  1114. }
  1115. EXPORT_SYMBOL(scsilun_to_int);
  1116. /**
  1117. * int_to_scsilun: reverts an int into a scsi_lun
  1118. * @lun: integer to be reverted
  1119. * @scsilun: struct scsi_lun to be set.
  1120. *
  1121. * Description:
  1122. * Reverts the functionality of the scsilun_to_int, which packed
  1123. * an 8-byte lun value into an int. This routine unpacks the int
  1124. * back into the lun value.
  1125. * Note: the scsilun_to_int() routine does not truly handle all
  1126. * 8bytes of the lun value. This functions restores only as much
  1127. * as was set by the routine.
  1128. *
  1129. * Notes:
  1130. * Given an integer : 0x0b030a04, this function returns a
  1131. * scsi_lun of : struct scsi_lun of: 0a 04 0b 03 00 00 00 00
  1132. *
  1133. **/
  1134. void int_to_scsilun(unsigned int lun, struct scsi_lun *scsilun)
  1135. {
  1136. int i;
  1137. memset(scsilun->scsi_lun, 0, sizeof(scsilun->scsi_lun));
  1138. for (i = 0; i < sizeof(lun); i += 2) {
  1139. scsilun->scsi_lun[i] = (lun >> 8) & 0xFF;
  1140. scsilun->scsi_lun[i+1] = lun & 0xFF;
  1141. lun = lun >> 16;
  1142. }
  1143. }
  1144. EXPORT_SYMBOL(int_to_scsilun);
  1145. /**
  1146. * scsi_report_lun_scan - Scan using SCSI REPORT LUN results
  1147. * @starget: which target
  1148. * @bflags: Zero or a mix of BLIST_NOLUN, BLIST_REPORTLUN2, or BLIST_NOREPORTLUN
  1149. * @rescan: nonzero if we can skip code only needed on first scan
  1150. *
  1151. * Description:
  1152. * Fast scanning for modern (SCSI-3) devices by sending a REPORT LUN command.
  1153. * Scan the resulting list of LUNs by calling scsi_probe_and_add_lun.
  1154. *
  1155. * If BLINK_REPORTLUN2 is set, scan a target that supports more than 8
  1156. * LUNs even if it's older than SCSI-3.
  1157. * If BLIST_NOREPORTLUN is set, return 1 always.
  1158. * If BLIST_NOLUN is set, return 0 always.
  1159. *
  1160. * Return:
  1161. * 0: scan completed (or no memory, so further scanning is futile)
  1162. * 1: could not scan with REPORT LUN
  1163. **/
  1164. static int scsi_report_lun_scan(struct scsi_target *starget, int bflags,
  1165. int rescan)
  1166. {
  1167. char devname[64];
  1168. unsigned char scsi_cmd[MAX_COMMAND_SIZE];
  1169. unsigned int length;
  1170. unsigned int lun;
  1171. unsigned int num_luns;
  1172. unsigned int retries;
  1173. int result;
  1174. struct scsi_lun *lunp, *lun_data;
  1175. u8 *data;
  1176. struct scsi_sense_hdr sshdr;
  1177. struct scsi_device *sdev;
  1178. struct Scsi_Host *shost = dev_to_shost(&starget->dev);
  1179. int ret = 0;
  1180. /*
  1181. * Only support SCSI-3 and up devices if BLIST_NOREPORTLUN is not set.
  1182. * Also allow SCSI-2 if BLIST_REPORTLUN2 is set and host adapter does
  1183. * support more than 8 LUNs.
  1184. */
  1185. if (bflags & BLIST_NOREPORTLUN)
  1186. return 1;
  1187. if (starget->scsi_level < SCSI_2 &&
  1188. starget->scsi_level != SCSI_UNKNOWN)
  1189. return 1;
  1190. if (starget->scsi_level < SCSI_3 &&
  1191. (!(bflags & BLIST_REPORTLUN2) || shost->max_lun <= 8))
  1192. return 1;
  1193. if (bflags & BLIST_NOLUN)
  1194. return 0;
  1195. if (!(sdev = scsi_device_lookup_by_target(starget, 0))) {
  1196. sdev = scsi_alloc_sdev(starget, 0, NULL);
  1197. if (!sdev)
  1198. return 0;
  1199. if (scsi_device_get(sdev))
  1200. return 0;
  1201. }
  1202. sprintf(devname, "host %d channel %d id %d",
  1203. shost->host_no, sdev->channel, sdev->id);
  1204. /*
  1205. * Allocate enough to hold the header (the same size as one scsi_lun)
  1206. * plus the max number of luns we are requesting.
  1207. *
  1208. * Reallocating and trying again (with the exact amount we need)
  1209. * would be nice, but then we need to somehow limit the size
  1210. * allocated based on the available memory and the limits of
  1211. * kmalloc - we don't want a kmalloc() failure of a huge value to
  1212. * prevent us from finding any LUNs on this target.
  1213. */
  1214. length = (max_scsi_report_luns + 1) * sizeof(struct scsi_lun);
  1215. lun_data = kmalloc(length, GFP_ATOMIC |
  1216. (sdev->host->unchecked_isa_dma ? __GFP_DMA : 0));
  1217. if (!lun_data) {
  1218. printk(ALLOC_FAILURE_MSG, __func__);
  1219. goto out;
  1220. }
  1221. scsi_cmd[0] = REPORT_LUNS;
  1222. /*
  1223. * bytes 1 - 5: reserved, set to zero.
  1224. */
  1225. memset(&scsi_cmd[1], 0, 5);
  1226. /*
  1227. * bytes 6 - 9: length of the command.
  1228. */
  1229. scsi_cmd[6] = (unsigned char) (length >> 24) & 0xff;
  1230. scsi_cmd[7] = (unsigned char) (length >> 16) & 0xff;
  1231. scsi_cmd[8] = (unsigned char) (length >> 8) & 0xff;
  1232. scsi_cmd[9] = (unsigned char) length & 0xff;
  1233. scsi_cmd[10] = 0; /* reserved */
  1234. scsi_cmd[11] = 0; /* control */
  1235. /*
  1236. * We can get a UNIT ATTENTION, for example a power on/reset, so
  1237. * retry a few times (like sd.c does for TEST UNIT READY).
  1238. * Experience shows some combinations of adapter/devices get at
  1239. * least two power on/resets.
  1240. *
  1241. * Illegal requests (for devices that do not support REPORT LUNS)
  1242. * should come through as a check condition, and will not generate
  1243. * a retry.
  1244. */
  1245. for (retries = 0; retries < 3; retries++) {
  1246. SCSI_LOG_SCAN_BUS(3, printk (KERN_INFO "scsi scan: Sending"
  1247. " REPORT LUNS to %s (try %d)\n", devname,
  1248. retries));
  1249. result = scsi_execute_req(sdev, scsi_cmd, DMA_FROM_DEVICE,
  1250. lun_data, length, &sshdr,
  1251. SCSI_TIMEOUT + 4 * HZ, 3, NULL);
  1252. SCSI_LOG_SCAN_BUS(3, printk (KERN_INFO "scsi scan: REPORT LUNS"
  1253. " %s (try %d) result 0x%x\n", result
  1254. ? "failed" : "successful", retries, result));
  1255. if (result == 0)
  1256. break;
  1257. else if (scsi_sense_valid(&sshdr)) {
  1258. if (sshdr.sense_key != UNIT_ATTENTION)
  1259. break;
  1260. }
  1261. }
  1262. if (result) {
  1263. /*
  1264. * The device probably does not support a REPORT LUN command
  1265. */
  1266. ret = 1;
  1267. goto out_err;
  1268. }
  1269. /*
  1270. * Get the length from the first four bytes of lun_data.
  1271. */
  1272. data = (u8 *) lun_data->scsi_lun;
  1273. length = ((data[0] << 24) | (data[1] << 16) |
  1274. (data[2] << 8) | (data[3] << 0));
  1275. num_luns = (length / sizeof(struct scsi_lun));
  1276. if (num_luns > max_scsi_report_luns) {
  1277. printk(KERN_WARNING "scsi: On %s only %d (max_scsi_report_luns)"
  1278. " of %d luns reported, try increasing"
  1279. " max_scsi_report_luns.\n", devname,
  1280. max_scsi_report_luns, num_luns);
  1281. num_luns = max_scsi_report_luns;
  1282. }
  1283. SCSI_LOG_SCAN_BUS(3, sdev_printk (KERN_INFO, sdev,
  1284. "scsi scan: REPORT LUN scan\n"));
  1285. /*
  1286. * Scan the luns in lun_data. The entry at offset 0 is really
  1287. * the header, so start at 1 and go up to and including num_luns.
  1288. */
  1289. for (lunp = &lun_data[1]; lunp <= &lun_data[num_luns]; lunp++) {
  1290. lun = scsilun_to_int(lunp);
  1291. /*
  1292. * Check if the unused part of lunp is non-zero, and so
  1293. * does not fit in lun.
  1294. */
  1295. if (memcmp(&lunp->scsi_lun[sizeof(lun)], "\0\0\0\0", 4)) {
  1296. int i;
  1297. /*
  1298. * Output an error displaying the LUN in byte order,
  1299. * this differs from what linux would print for the
  1300. * integer LUN value.
  1301. */
  1302. printk(KERN_WARNING "scsi: %s lun 0x", devname);
  1303. data = (char *)lunp->scsi_lun;
  1304. for (i = 0; i < sizeof(struct scsi_lun); i++)
  1305. printk("%02x", data[i]);
  1306. printk(" has a LUN larger than currently supported.\n");
  1307. } else if (lun > sdev->host->max_lun) {
  1308. printk(KERN_WARNING "scsi: %s lun%d has a LUN larger"
  1309. " than allowed by the host adapter\n",
  1310. devname, lun);
  1311. } else {
  1312. int res;
  1313. res = scsi_probe_and_add_lun(starget,
  1314. lun, NULL, NULL, rescan, NULL);
  1315. if (res == SCSI_SCAN_NO_RESPONSE) {
  1316. /*
  1317. * Got some results, but now none, abort.
  1318. */
  1319. sdev_printk(KERN_ERR, sdev,
  1320. "Unexpected response"
  1321. " from lun %d while scanning, scan"
  1322. " aborted\n", lun);
  1323. break;
  1324. }
  1325. }
  1326. }
  1327. out_err:
  1328. kfree(lun_data);
  1329. out:
  1330. scsi_device_put(sdev);
  1331. if (scsi_device_created(sdev))
  1332. /*
  1333. * the sdev we used didn't appear in the report luns scan
  1334. */
  1335. scsi_destroy_sdev(sdev);
  1336. return ret;
  1337. }
  1338. struct scsi_device *__scsi_add_device(struct Scsi_Host *shost, uint channel,
  1339. uint id, uint lun, void *hostdata)
  1340. {
  1341. struct scsi_device *sdev = ERR_PTR(-ENODEV);
  1342. struct device *parent = &shost->shost_gendev;
  1343. struct scsi_target *starget;
  1344. if (strncmp(scsi_scan_type, "none", 4) == 0)
  1345. return ERR_PTR(-ENODEV);
  1346. starget = scsi_alloc_target(parent, channel, id);
  1347. if (!starget)
  1348. return ERR_PTR(-ENOMEM);
  1349. mutex_lock(&shost->scan_mutex);
  1350. if (!shost->async_scan)
  1351. scsi_complete_async_scans();
  1352. if (scsi_host_scan_allowed(shost))
  1353. scsi_probe_and_add_lun(starget, lun, NULL, &sdev, 1, hostdata);
  1354. mutex_unlock(&shost->scan_mutex);
  1355. scsi_target_reap(starget);
  1356. put_device(&starget->dev);
  1357. return sdev;
  1358. }
  1359. EXPORT_SYMBOL(__scsi_add_device);
  1360. int scsi_add_device(struct Scsi_Host *host, uint channel,
  1361. uint target, uint lun)
  1362. {
  1363. struct scsi_device *sdev =
  1364. __scsi_add_device(host, channel, target, lun, NULL);
  1365. if (IS_ERR(sdev))
  1366. return PTR_ERR(sdev);
  1367. scsi_device_put(sdev);
  1368. return 0;
  1369. }
  1370. EXPORT_SYMBOL(scsi_add_device);
  1371. void scsi_rescan_device(struct device *dev)
  1372. {
  1373. struct scsi_driver *drv;
  1374. if (!dev->driver)
  1375. return;
  1376. drv = to_scsi_driver(dev->driver);
  1377. if (try_module_get(drv->owner)) {
  1378. if (drv->rescan)
  1379. drv->rescan(dev);
  1380. module_put(drv->owner);
  1381. }
  1382. }
  1383. EXPORT_SYMBOL(scsi_rescan_device);
  1384. static void __scsi_scan_target(struct device *parent, unsigned int channel,
  1385. unsigned int id, unsigned int lun, int rescan)
  1386. {
  1387. struct Scsi_Host *shost = dev_to_shost(parent);
  1388. int bflags = 0;
  1389. int res;
  1390. struct scsi_target *starget;
  1391. if (shost->this_id == id)
  1392. /*
  1393. * Don't scan the host adapter
  1394. */
  1395. return;
  1396. starget = scsi_alloc_target(parent, channel, id);
  1397. if (!starget)
  1398. return;
  1399. if (lun != SCAN_WILD_CARD) {
  1400. /*
  1401. * Scan for a specific host/chan/id/lun.
  1402. */
  1403. scsi_probe_and_add_lun(starget, lun, NULL, NULL, rescan, NULL);
  1404. goto out_reap;
  1405. }
  1406. /*
  1407. * Scan LUN 0, if there is some response, scan further. Ideally, we
  1408. * would not configure LUN 0 until all LUNs are scanned.
  1409. */
  1410. res = scsi_probe_and_add_lun(starget, 0, &bflags, NULL, rescan, NULL);
  1411. if (res == SCSI_SCAN_LUN_PRESENT || res == SCSI_SCAN_TARGET_PRESENT) {
  1412. if (scsi_report_lun_scan(starget, bflags, rescan) != 0)
  1413. /*
  1414. * The REPORT LUN did not scan the target,
  1415. * do a sequential scan.
  1416. */
  1417. scsi_sequential_lun_scan(starget, bflags,
  1418. starget->scsi_level, rescan);
  1419. }
  1420. out_reap:
  1421. /* now determine if the target has any children at all
  1422. * and if not, nuke it */
  1423. scsi_target_reap(starget);
  1424. put_device(&starget->dev);
  1425. }
  1426. /**
  1427. * scsi_scan_target - scan a target id, possibly including all LUNs on the target.
  1428. * @parent: host to scan
  1429. * @channel: channel to scan
  1430. * @id: target id to scan
  1431. * @lun: Specific LUN to scan or SCAN_WILD_CARD
  1432. * @rescan: passed to LUN scanning routines
  1433. *
  1434. * Description:
  1435. * Scan the target id on @parent, @channel, and @id. Scan at least LUN 0,
  1436. * and possibly all LUNs on the target id.
  1437. *
  1438. * First try a REPORT LUN scan, if that does not scan the target, do a
  1439. * sequential scan of LUNs on the target id.
  1440. **/
  1441. void scsi_scan_target(struct device *parent, unsigned int channel,
  1442. unsigned int id, unsigned int lun, int rescan)
  1443. {
  1444. struct Scsi_Host *shost = dev_to_shost(parent);
  1445. if (strncmp(scsi_scan_type, "none", 4) == 0)
  1446. return;
  1447. mutex_lock(&shost->scan_mutex);
  1448. if (!shost->async_scan)
  1449. scsi_complete_async_scans();
  1450. if (scsi_host_scan_allowed(shost))
  1451. __scsi_scan_target(parent, channel, id, lun, rescan);
  1452. mutex_unlock(&shost->scan_mutex);
  1453. }
  1454. EXPORT_SYMBOL(scsi_scan_target);
  1455. static void scsi_scan_channel(struct Scsi_Host *shost, unsigned int channel,
  1456. unsigned int id, unsigned int lun, int rescan)
  1457. {
  1458. uint order_id;
  1459. if (id == SCAN_WILD_CARD)
  1460. for (id = 0; id < shost->max_id; ++id) {
  1461. /*
  1462. * XXX adapter drivers when possible (FCP, iSCSI)
  1463. * could modify max_id to match the current max,
  1464. * not the absolute max.
  1465. *
  1466. * XXX add a shost id iterator, so for example,
  1467. * the FC ID can be the same as a target id
  1468. * without a huge overhead of sparse id's.
  1469. */
  1470. if (shost->reverse_ordering)
  1471. /*
  1472. * Scan from high to low id.
  1473. */
  1474. order_id = shost->max_id - id - 1;
  1475. else
  1476. order_id = id;
  1477. __scsi_scan_target(&shost->shost_gendev, channel,
  1478. order_id, lun, rescan);
  1479. }
  1480. else
  1481. __scsi_scan_target(&shost->shost_gendev, channel,
  1482. id, lun, rescan);
  1483. }
  1484. int scsi_scan_host_selected(struct Scsi_Host *shost, unsigned int channel,
  1485. unsigned int id, unsigned int lun, int rescan)
  1486. {
  1487. SCSI_LOG_SCAN_BUS(3, shost_printk (KERN_INFO, shost,
  1488. "%s: <%u:%u:%u>\n",
  1489. __func__, channel, id, lun));
  1490. if (((channel != SCAN_WILD_CARD) && (channel > shost->max_channel)) ||
  1491. ((id != SCAN_WILD_CARD) && (id >= shost->max_id)) ||
  1492. ((lun != SCAN_WILD_CARD) && (lun > shost->max_lun)))
  1493. return -EINVAL;
  1494. mutex_lock(&shost->scan_mutex);
  1495. if (!shost->async_scan)
  1496. scsi_complete_async_scans();
  1497. if (scsi_host_scan_allowed(shost)) {
  1498. if (channel == SCAN_WILD_CARD)
  1499. for (channel = 0; channel <= shost->max_channel;
  1500. channel++)
  1501. scsi_scan_channel(shost, channel, id, lun,
  1502. rescan);
  1503. else
  1504. scsi_scan_channel(shost, channel, id, lun, rescan);
  1505. }
  1506. mutex_unlock(&shost->scan_mutex);
  1507. return 0;
  1508. }
  1509. static void scsi_sysfs_add_devices(struct Scsi_Host *shost)
  1510. {
  1511. struct scsi_device *sdev;
  1512. shost_for_each_device(sdev, shost) {
  1513. if (!scsi_host_scan_allowed(shost) ||
  1514. scsi_sysfs_add_sdev(sdev) != 0)
  1515. scsi_destroy_sdev(sdev);
  1516. }
  1517. }
  1518. /**
  1519. * scsi_prep_async_scan - prepare for an async scan
  1520. * @shost: the host which will be scanned
  1521. * Returns: a cookie to be passed to scsi_finish_async_scan()
  1522. *
  1523. * Tells the midlayer this host is going to do an asynchronous scan.
  1524. * It reserves the host's position in the scanning list and ensures
  1525. * that other asynchronous scans started after this one won't affect the
  1526. * ordering of the discovered devices.
  1527. */
  1528. static struct async_scan_data *scsi_prep_async_scan(struct Scsi_Host *shost)
  1529. {
  1530. struct async_scan_data *data;
  1531. unsigned long flags;
  1532. if (strncmp(scsi_scan_type, "sync", 4) == 0)
  1533. return NULL;
  1534. if (shost->async_scan) {
  1535. printk("%s called twice for host %d", __func__,
  1536. shost->host_no);
  1537. dump_stack();
  1538. return NULL;
  1539. }
  1540. data = kmalloc(sizeof(*data), GFP_KERNEL);
  1541. if (!data)
  1542. goto err;
  1543. data->shost = scsi_host_get(shost);
  1544. if (!data->shost)
  1545. goto err;
  1546. init_completion(&data->prev_finished);
  1547. mutex_lock(&shost->scan_mutex);
  1548. spin_lock_irqsave(shost->host_lock, flags);
  1549. shost->async_scan = 1;
  1550. spin_unlock_irqrestore(shost->host_lock, flags);
  1551. mutex_unlock(&shost->scan_mutex);
  1552. spin_lock(&async_scan_lock);
  1553. if (list_empty(&scanning_hosts))
  1554. complete(&data->prev_finished);
  1555. list_add_tail(&data->list, &scanning_hosts);
  1556. spin_unlock(&async_scan_lock);
  1557. return data;
  1558. err:
  1559. kfree(data);
  1560. return NULL;
  1561. }
  1562. /**
  1563. * scsi_finish_async_scan - asynchronous scan has finished
  1564. * @data: cookie returned from earlier call to scsi_prep_async_scan()
  1565. *
  1566. * All the devices currently attached to this host have been found.
  1567. * This function announces all the devices it has found to the rest
  1568. * of the system.
  1569. */
  1570. static void scsi_finish_async_scan(struct async_scan_data *data)
  1571. {
  1572. struct Scsi_Host *shost;
  1573. unsigned long flags;
  1574. if (!data)
  1575. return;
  1576. shost = data->shost;
  1577. mutex_lock(&shost->scan_mutex);
  1578. if (!shost->async_scan) {
  1579. printk("%s called twice for host %d", __func__,
  1580. shost->host_no);
  1581. dump_stack();
  1582. mutex_unlock(&shost->scan_mutex);
  1583. return;
  1584. }
  1585. wait_for_completion(&data->prev_finished);
  1586. scsi_sysfs_add_devices(shost);
  1587. spin_lock_irqsave(shost->host_lock, flags);
  1588. shost->async_scan = 0;
  1589. spin_unlock_irqrestore(shost->host_lock, flags);
  1590. mutex_unlock(&shost->scan_mutex);
  1591. spin_lock(&async_scan_lock);
  1592. list_del(&data->list);
  1593. if (!list_empty(&scanning_hosts)) {
  1594. struct async_scan_data *next = list_entry(scanning_hosts.next,
  1595. struct async_scan_data, list);
  1596. complete(&next->prev_finished);
  1597. }
  1598. spin_unlock(&async_scan_lock);
  1599. scsi_host_put(shost);
  1600. kfree(data);
  1601. }
  1602. static void do_scsi_scan_host(struct Scsi_Host *shost)
  1603. {
  1604. if (shost->hostt->scan_finished) {
  1605. unsigned long start = jiffies;
  1606. if (shost->hostt->scan_start)
  1607. shost->hostt->scan_start(shost);
  1608. while (!shost->hostt->scan_finished(shost, jiffies - start))
  1609. msleep(10);
  1610. } else {
  1611. scsi_scan_host_selected(shost, SCAN_WILD_CARD, SCAN_WILD_CARD,
  1612. SCAN_WILD_CARD, 0);
  1613. }
  1614. }
  1615. static int do_scan_async(void *_data)
  1616. {
  1617. struct async_scan_data *data = _data;
  1618. do_scsi_scan_host(data->shost);
  1619. scsi_finish_async_scan(data);
  1620. return 0;
  1621. }
  1622. /**
  1623. * scsi_scan_host - scan the given adapter
  1624. * @shost: adapter to scan
  1625. **/
  1626. void scsi_scan_host(struct Scsi_Host *shost)
  1627. {
  1628. struct task_struct *p;
  1629. struct async_scan_data *data;
  1630. if (strncmp(scsi_scan_type, "none", 4) == 0)
  1631. return;
  1632. data = scsi_prep_async_scan(shost);
  1633. if (!data) {
  1634. do_scsi_scan_host(shost);
  1635. return;
  1636. }
  1637. p = kthread_run(do_scan_async, data, "scsi_scan_%d", shost->host_no);
  1638. if (IS_ERR(p))
  1639. do_scan_async(data);
  1640. }
  1641. EXPORT_SYMBOL(scsi_scan_host);
  1642. void scsi_forget_host(struct Scsi_Host *shost)
  1643. {
  1644. struct scsi_device *sdev;
  1645. unsigned long flags;
  1646. restart:
  1647. spin_lock_irqsave(shost->host_lock, flags);
  1648. list_for_each_entry(sdev, &shost->__devices, siblings) {
  1649. if (sdev->sdev_state == SDEV_DEL)
  1650. continue;
  1651. spin_unlock_irqrestore(shost->host_lock, flags);
  1652. __scsi_remove_device(sdev);
  1653. goto restart;
  1654. }
  1655. spin_unlock_irqrestore(shost->host_lock, flags);
  1656. }
  1657. /*
  1658. * Function: scsi_get_host_dev()
  1659. *
  1660. * Purpose: Create a scsi_device that points to the host adapter itself.
  1661. *
  1662. * Arguments: SHpnt - Host that needs a scsi_device
  1663. *
  1664. * Lock status: None assumed.
  1665. *
  1666. * Returns: The scsi_device or NULL
  1667. *
  1668. * Notes:
  1669. * Attach a single scsi_device to the Scsi_Host - this should
  1670. * be made to look like a "pseudo-device" that points to the
  1671. * HA itself.
  1672. *
  1673. * Note - this device is not accessible from any high-level
  1674. * drivers (including generics), which is probably not
  1675. * optimal. We can add hooks later to attach
  1676. */
  1677. struct scsi_device *scsi_get_host_dev(struct Scsi_Host *shost)
  1678. {
  1679. struct scsi_device *sdev = NULL;
  1680. struct scsi_target *starget;
  1681. mutex_lock(&shost->scan_mutex);
  1682. if (!scsi_host_scan_allowed(shost))
  1683. goto out;
  1684. starget = scsi_alloc_target(&shost->shost_gendev, 0, shost->this_id);
  1685. if (!starget)
  1686. goto out;
  1687. sdev = scsi_alloc_sdev(starget, 0, NULL);
  1688. if (sdev) {
  1689. sdev->sdev_gendev.parent = get_device(&starget->dev);
  1690. sdev->borken = 0;
  1691. } else
  1692. scsi_target_reap(starget);
  1693. put_device(&starget->dev);
  1694. out:
  1695. mutex_unlock(&shost->scan_mutex);
  1696. return sdev;
  1697. }
  1698. EXPORT_SYMBOL(scsi_get_host_dev);
  1699. /*
  1700. * Function: scsi_free_host_dev()
  1701. *
  1702. * Purpose: Free a scsi_device that points to the host adapter itself.
  1703. *
  1704. * Arguments: SHpnt - Host that needs a scsi_device
  1705. *
  1706. * Lock status: None assumed.
  1707. *
  1708. * Returns: Nothing
  1709. *
  1710. * Notes:
  1711. */
  1712. void scsi_free_host_dev(struct scsi_device *sdev)
  1713. {
  1714. BUG_ON(sdev->id != sdev->host->this_id);
  1715. scsi_destroy_sdev(sdev);
  1716. }
  1717. EXPORT_SYMBOL(scsi_free_host_dev);