hosts.c 14 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585
  1. /*
  2. * hosts.c Copyright (C) 1992 Drew Eckhardt
  3. * Copyright (C) 1993, 1994, 1995 Eric Youngdale
  4. * Copyright (C) 2002-2003 Christoph Hellwig
  5. *
  6. * mid to lowlevel SCSI driver interface
  7. * Initial versions: Drew Eckhardt
  8. * Subsequent revisions: Eric Youngdale
  9. *
  10. * <drew@colorado.edu>
  11. *
  12. * Jiffies wrap fixes (host->resetting), 3 Dec 1998 Andrea Arcangeli
  13. * Added QLOGIC QLA1280 SCSI controller kernel host support.
  14. * August 4, 1999 Fred Lewis, Intel DuPont
  15. *
  16. * Updated to reflect the new initialization scheme for the higher
  17. * level of scsi drivers (sd/sr/st)
  18. * September 17, 2000 Torben Mathiasen <tmm@image.dk>
  19. *
  20. * Restructured scsi_host lists and associated functions.
  21. * September 04, 2002 Mike Anderson (andmike@us.ibm.com)
  22. */
  23. #include <linux/module.h>
  24. #include <linux/blkdev.h>
  25. #include <linux/kernel.h>
  26. #include <linux/slab.h>
  27. #include <linux/kthread.h>
  28. #include <linux/string.h>
  29. #include <linux/mm.h>
  30. #include <linux/init.h>
  31. #include <linux/completion.h>
  32. #include <linux/transport_class.h>
  33. #include <linux/platform_device.h>
  34. #include <linux/pm_runtime.h>
  35. #include <scsi/scsi_device.h>
  36. #include <scsi/scsi_host.h>
  37. #include <scsi/scsi_transport.h>
  38. #include "scsi_priv.h"
  39. #include "scsi_logging.h"
  40. static atomic_t scsi_host_next_hn; /* host_no for next new host */
  41. static void scsi_host_cls_release(struct device *dev)
  42. {
  43. put_device(&class_to_shost(dev)->shost_gendev);
  44. }
  45. static struct class shost_class = {
  46. .name = "scsi_host",
  47. .dev_release = scsi_host_cls_release,
  48. };
  49. /**
  50. * scsi_host_set_state - Take the given host through the host state model.
  51. * @shost: scsi host to change the state of.
  52. * @state: state to change to.
  53. *
  54. * Returns zero if unsuccessful or an error if the requested
  55. * transition is illegal.
  56. **/
  57. int scsi_host_set_state(struct Scsi_Host *shost, enum scsi_host_state state)
  58. {
  59. enum scsi_host_state oldstate = shost->shost_state;
  60. if (state == oldstate)
  61. return 0;
  62. switch (state) {
  63. case SHOST_CREATED:
  64. /* There are no legal states that come back to
  65. * created. This is the manually initialised start
  66. * state */
  67. goto illegal;
  68. case SHOST_RUNNING:
  69. switch (oldstate) {
  70. case SHOST_CREATED:
  71. case SHOST_RECOVERY:
  72. break;
  73. default:
  74. goto illegal;
  75. }
  76. break;
  77. case SHOST_RECOVERY:
  78. switch (oldstate) {
  79. case SHOST_RUNNING:
  80. break;
  81. default:
  82. goto illegal;
  83. }
  84. break;
  85. case SHOST_CANCEL:
  86. switch (oldstate) {
  87. case SHOST_CREATED:
  88. case SHOST_RUNNING:
  89. case SHOST_CANCEL_RECOVERY:
  90. break;
  91. default:
  92. goto illegal;
  93. }
  94. break;
  95. case SHOST_DEL:
  96. switch (oldstate) {
  97. case SHOST_CANCEL:
  98. case SHOST_DEL_RECOVERY:
  99. break;
  100. default:
  101. goto illegal;
  102. }
  103. break;
  104. case SHOST_CANCEL_RECOVERY:
  105. switch (oldstate) {
  106. case SHOST_CANCEL:
  107. case SHOST_RECOVERY:
  108. break;
  109. default:
  110. goto illegal;
  111. }
  112. break;
  113. case SHOST_DEL_RECOVERY:
  114. switch (oldstate) {
  115. case SHOST_CANCEL_RECOVERY:
  116. break;
  117. default:
  118. goto illegal;
  119. }
  120. break;
  121. }
  122. shost->shost_state = state;
  123. return 0;
  124. illegal:
  125. SCSI_LOG_ERROR_RECOVERY(1,
  126. shost_printk(KERN_ERR, shost,
  127. "Illegal host state transition"
  128. "%s->%s\n",
  129. scsi_host_state_name(oldstate),
  130. scsi_host_state_name(state)));
  131. return -EINVAL;
  132. }
  133. EXPORT_SYMBOL(scsi_host_set_state);
  134. /**
  135. * scsi_remove_host - remove a scsi host
  136. * @shost: a pointer to a scsi host to remove
  137. **/
  138. void scsi_remove_host(struct Scsi_Host *shost)
  139. {
  140. unsigned long flags;
  141. mutex_lock(&shost->scan_mutex);
  142. spin_lock_irqsave(shost->host_lock, flags);
  143. if (scsi_host_set_state(shost, SHOST_CANCEL))
  144. if (scsi_host_set_state(shost, SHOST_CANCEL_RECOVERY)) {
  145. spin_unlock_irqrestore(shost->host_lock, flags);
  146. mutex_unlock(&shost->scan_mutex);
  147. return;
  148. }
  149. spin_unlock_irqrestore(shost->host_lock, flags);
  150. scsi_autopm_get_host(shost);
  151. scsi_forget_host(shost);
  152. mutex_unlock(&shost->scan_mutex);
  153. scsi_proc_host_rm(shost);
  154. spin_lock_irqsave(shost->host_lock, flags);
  155. if (scsi_host_set_state(shost, SHOST_DEL))
  156. BUG_ON(scsi_host_set_state(shost, SHOST_DEL_RECOVERY));
  157. spin_unlock_irqrestore(shost->host_lock, flags);
  158. transport_unregister_device(&shost->shost_gendev);
  159. device_unregister(&shost->shost_dev);
  160. device_del(&shost->shost_gendev);
  161. }
  162. EXPORT_SYMBOL(scsi_remove_host);
  163. /**
  164. * scsi_add_host_with_dma - add a scsi host with dma device
  165. * @shost: scsi host pointer to add
  166. * @dev: a struct device of type scsi class
  167. * @dma_dev: dma device for the host
  168. *
  169. * Note: You rarely need to worry about this unless you're in a
  170. * virtualised host environments, so use the simpler scsi_add_host()
  171. * function instead.
  172. *
  173. * Return value:
  174. * 0 on success / != 0 for error
  175. **/
  176. int scsi_add_host_with_dma(struct Scsi_Host *shost, struct device *dev,
  177. struct device *dma_dev)
  178. {
  179. struct scsi_host_template *sht = shost->hostt;
  180. int error = -EINVAL;
  181. printk(KERN_INFO "scsi%d : %s\n", shost->host_no,
  182. sht->info ? sht->info(shost) : sht->name);
  183. if (!shost->can_queue) {
  184. printk(KERN_ERR "%s: can_queue = 0 no longer supported\n",
  185. sht->name);
  186. goto fail;
  187. }
  188. error = scsi_setup_command_freelist(shost);
  189. if (error)
  190. goto fail;
  191. if (!shost->shost_gendev.parent)
  192. shost->shost_gendev.parent = dev ? dev : &platform_bus;
  193. if (!dma_dev)
  194. dma_dev = shost->shost_gendev.parent;
  195. shost->dma_dev = dma_dev;
  196. error = device_add(&shost->shost_gendev);
  197. if (error)
  198. goto out;
  199. pm_runtime_set_active(&shost->shost_gendev);
  200. pm_runtime_enable(&shost->shost_gendev);
  201. device_enable_async_suspend(&shost->shost_gendev);
  202. scsi_host_set_state(shost, SHOST_RUNNING);
  203. get_device(shost->shost_gendev.parent);
  204. device_enable_async_suspend(&shost->shost_dev);
  205. error = device_add(&shost->shost_dev);
  206. if (error)
  207. goto out_del_gendev;
  208. get_device(&shost->shost_gendev);
  209. if (shost->transportt->host_size) {
  210. shost->shost_data = kzalloc(shost->transportt->host_size,
  211. GFP_KERNEL);
  212. if (shost->shost_data == NULL) {
  213. error = -ENOMEM;
  214. goto out_del_dev;
  215. }
  216. }
  217. if (shost->transportt->create_work_queue) {
  218. snprintf(shost->work_q_name, sizeof(shost->work_q_name),
  219. "scsi_wq_%d", shost->host_no);
  220. shost->work_q = create_singlethread_workqueue(
  221. shost->work_q_name);
  222. if (!shost->work_q) {
  223. error = -EINVAL;
  224. goto out_free_shost_data;
  225. }
  226. }
  227. error = scsi_sysfs_add_host(shost);
  228. if (error)
  229. goto out_destroy_host;
  230. scsi_proc_host_add(shost);
  231. return error;
  232. out_destroy_host:
  233. if (shost->work_q)
  234. destroy_workqueue(shost->work_q);
  235. out_free_shost_data:
  236. kfree(shost->shost_data);
  237. out_del_dev:
  238. device_del(&shost->shost_dev);
  239. out_del_gendev:
  240. device_del(&shost->shost_gendev);
  241. out:
  242. scsi_destroy_command_freelist(shost);
  243. fail:
  244. return error;
  245. }
  246. EXPORT_SYMBOL(scsi_add_host_with_dma);
  247. static void scsi_host_dev_release(struct device *dev)
  248. {
  249. struct Scsi_Host *shost = dev_to_shost(dev);
  250. struct device *parent = dev->parent;
  251. struct request_queue *q;
  252. scsi_proc_hostdir_rm(shost->hostt);
  253. if (shost->ehandler)
  254. kthread_stop(shost->ehandler);
  255. if (shost->work_q)
  256. destroy_workqueue(shost->work_q);
  257. q = shost->uspace_req_q;
  258. if (q) {
  259. kfree(q->queuedata);
  260. q->queuedata = NULL;
  261. scsi_free_queue(q);
  262. }
  263. scsi_destroy_command_freelist(shost);
  264. if (shost->bqt)
  265. blk_free_tags(shost->bqt);
  266. kfree(shost->shost_data);
  267. if (parent)
  268. put_device(parent);
  269. kfree(shost);
  270. }
  271. static struct device_type scsi_host_type = {
  272. .name = "scsi_host",
  273. .release = scsi_host_dev_release,
  274. };
  275. /**
  276. * scsi_host_alloc - register a scsi host adapter instance.
  277. * @sht: pointer to scsi host template
  278. * @privsize: extra bytes to allocate for driver
  279. *
  280. * Note:
  281. * Allocate a new Scsi_Host and perform basic initialization.
  282. * The host is not published to the scsi midlayer until scsi_add_host
  283. * is called.
  284. *
  285. * Return value:
  286. * Pointer to a new Scsi_Host
  287. **/
  288. struct Scsi_Host *scsi_host_alloc(struct scsi_host_template *sht, int privsize)
  289. {
  290. struct Scsi_Host *shost;
  291. gfp_t gfp_mask = GFP_KERNEL;
  292. if (sht->unchecked_isa_dma && privsize)
  293. gfp_mask |= __GFP_DMA;
  294. shost = kzalloc(sizeof(struct Scsi_Host) + privsize, gfp_mask);
  295. if (!shost)
  296. return NULL;
  297. shost->host_lock = &shost->default_lock;
  298. spin_lock_init(shost->host_lock);
  299. shost->shost_state = SHOST_CREATED;
  300. INIT_LIST_HEAD(&shost->__devices);
  301. INIT_LIST_HEAD(&shost->__targets);
  302. INIT_LIST_HEAD(&shost->eh_cmd_q);
  303. INIT_LIST_HEAD(&shost->starved_list);
  304. init_waitqueue_head(&shost->host_wait);
  305. mutex_init(&shost->scan_mutex);
  306. /*
  307. * subtract one because we increment first then return, but we need to
  308. * know what the next host number was before increment
  309. */
  310. shost->host_no = atomic_inc_return(&scsi_host_next_hn) - 1;
  311. shost->dma_channel = 0xff;
  312. /* These three are default values which can be overridden */
  313. shost->max_channel = 0;
  314. shost->max_id = 8;
  315. shost->max_lun = 8;
  316. /* Give each shost a default transportt */
  317. shost->transportt = &blank_transport_template;
  318. /*
  319. * All drivers right now should be able to handle 12 byte
  320. * commands. Every so often there are requests for 16 byte
  321. * commands, but individual low-level drivers need to certify that
  322. * they actually do something sensible with such commands.
  323. */
  324. shost->max_cmd_len = 12;
  325. shost->hostt = sht;
  326. shost->this_id = sht->this_id;
  327. shost->can_queue = sht->can_queue;
  328. shost->sg_tablesize = sht->sg_tablesize;
  329. shost->sg_prot_tablesize = sht->sg_prot_tablesize;
  330. shost->cmd_per_lun = sht->cmd_per_lun;
  331. shost->unchecked_isa_dma = sht->unchecked_isa_dma;
  332. shost->use_clustering = sht->use_clustering;
  333. shost->ordered_tag = sht->ordered_tag;
  334. if (sht->supported_mode == MODE_UNKNOWN)
  335. /* means we didn't set it ... default to INITIATOR */
  336. shost->active_mode = MODE_INITIATOR;
  337. else
  338. shost->active_mode = sht->supported_mode;
  339. if (sht->max_host_blocked)
  340. shost->max_host_blocked = sht->max_host_blocked;
  341. else
  342. shost->max_host_blocked = SCSI_DEFAULT_HOST_BLOCKED;
  343. /*
  344. * If the driver imposes no hard sector transfer limit, start at
  345. * machine infinity initially.
  346. */
  347. if (sht->max_sectors)
  348. shost->max_sectors = sht->max_sectors;
  349. else
  350. shost->max_sectors = SCSI_DEFAULT_MAX_SECTORS;
  351. /*
  352. * assume a 4GB boundary, if not set
  353. */
  354. if (sht->dma_boundary)
  355. shost->dma_boundary = sht->dma_boundary;
  356. else
  357. shost->dma_boundary = 0xffffffff;
  358. device_initialize(&shost->shost_gendev);
  359. dev_set_name(&shost->shost_gendev, "host%d", shost->host_no);
  360. shost->shost_gendev.bus = &scsi_bus_type;
  361. shost->shost_gendev.type = &scsi_host_type;
  362. device_initialize(&shost->shost_dev);
  363. shost->shost_dev.parent = &shost->shost_gendev;
  364. shost->shost_dev.class = &shost_class;
  365. dev_set_name(&shost->shost_dev, "host%d", shost->host_no);
  366. shost->shost_dev.groups = scsi_sysfs_shost_attr_groups;
  367. shost->ehandler = kthread_run(scsi_error_handler, shost,
  368. "scsi_eh_%d", shost->host_no);
  369. if (IS_ERR(shost->ehandler)) {
  370. printk(KERN_WARNING "scsi%d: error handler thread failed to spawn, error = %ld\n",
  371. shost->host_no, PTR_ERR(shost->ehandler));
  372. goto fail_kfree;
  373. }
  374. scsi_proc_hostdir_add(shost->hostt);
  375. return shost;
  376. fail_kfree:
  377. kfree(shost);
  378. return NULL;
  379. }
  380. EXPORT_SYMBOL(scsi_host_alloc);
  381. struct Scsi_Host *scsi_register(struct scsi_host_template *sht, int privsize)
  382. {
  383. struct Scsi_Host *shost = scsi_host_alloc(sht, privsize);
  384. if (!sht->detect) {
  385. printk(KERN_WARNING "scsi_register() called on new-style "
  386. "template for driver %s\n", sht->name);
  387. dump_stack();
  388. }
  389. if (shost)
  390. list_add_tail(&shost->sht_legacy_list, &sht->legacy_hosts);
  391. return shost;
  392. }
  393. EXPORT_SYMBOL(scsi_register);
  394. void scsi_unregister(struct Scsi_Host *shost)
  395. {
  396. list_del(&shost->sht_legacy_list);
  397. scsi_host_put(shost);
  398. }
  399. EXPORT_SYMBOL(scsi_unregister);
  400. static int __scsi_host_match(struct device *dev, void *data)
  401. {
  402. struct Scsi_Host *p;
  403. unsigned short *hostnum = (unsigned short *)data;
  404. p = class_to_shost(dev);
  405. return p->host_no == *hostnum;
  406. }
  407. /**
  408. * scsi_host_lookup - get a reference to a Scsi_Host by host no
  409. * @hostnum: host number to locate
  410. *
  411. * Return value:
  412. * A pointer to located Scsi_Host or NULL.
  413. *
  414. * The caller must do a scsi_host_put() to drop the reference
  415. * that scsi_host_get() took. The put_device() below dropped
  416. * the reference from class_find_device().
  417. **/
  418. struct Scsi_Host *scsi_host_lookup(unsigned short hostnum)
  419. {
  420. struct device *cdev;
  421. struct Scsi_Host *shost = NULL;
  422. cdev = class_find_device(&shost_class, NULL, &hostnum,
  423. __scsi_host_match);
  424. if (cdev) {
  425. shost = scsi_host_get(class_to_shost(cdev));
  426. put_device(cdev);
  427. }
  428. return shost;
  429. }
  430. EXPORT_SYMBOL(scsi_host_lookup);
  431. /**
  432. * scsi_host_get - inc a Scsi_Host ref count
  433. * @shost: Pointer to Scsi_Host to inc.
  434. **/
  435. struct Scsi_Host *scsi_host_get(struct Scsi_Host *shost)
  436. {
  437. if ((shost->shost_state == SHOST_DEL) ||
  438. !get_device(&shost->shost_gendev))
  439. return NULL;
  440. return shost;
  441. }
  442. EXPORT_SYMBOL(scsi_host_get);
  443. /**
  444. * scsi_host_put - dec a Scsi_Host ref count
  445. * @shost: Pointer to Scsi_Host to dec.
  446. **/
  447. void scsi_host_put(struct Scsi_Host *shost)
  448. {
  449. put_device(&shost->shost_gendev);
  450. }
  451. EXPORT_SYMBOL(scsi_host_put);
  452. int scsi_init_hosts(void)
  453. {
  454. return class_register(&shost_class);
  455. }
  456. void scsi_exit_hosts(void)
  457. {
  458. class_unregister(&shost_class);
  459. }
  460. int scsi_is_host_device(const struct device *dev)
  461. {
  462. return dev->type == &scsi_host_type;
  463. }
  464. EXPORT_SYMBOL(scsi_is_host_device);
  465. /**
  466. * scsi_queue_work - Queue work to the Scsi_Host workqueue.
  467. * @shost: Pointer to Scsi_Host.
  468. * @work: Work to queue for execution.
  469. *
  470. * Return value:
  471. * 1 - work queued for execution
  472. * 0 - work is already queued
  473. * -EINVAL - work queue doesn't exist
  474. **/
  475. int scsi_queue_work(struct Scsi_Host *shost, struct work_struct *work)
  476. {
  477. if (unlikely(!shost->work_q)) {
  478. printk(KERN_ERR
  479. "ERROR: Scsi host '%s' attempted to queue scsi-work, "
  480. "when no workqueue created.\n", shost->hostt->name);
  481. dump_stack();
  482. return -EINVAL;
  483. }
  484. return queue_work(shost->work_q, work);
  485. }
  486. EXPORT_SYMBOL_GPL(scsi_queue_work);
  487. /**
  488. * scsi_flush_work - Flush a Scsi_Host's workqueue.
  489. * @shost: Pointer to Scsi_Host.
  490. **/
  491. void scsi_flush_work(struct Scsi_Host *shost)
  492. {
  493. if (!shost->work_q) {
  494. printk(KERN_ERR
  495. "ERROR: Scsi host '%s' attempted to flush scsi-work, "
  496. "when no workqueue created.\n", shost->hostt->name);
  497. dump_stack();
  498. return;
  499. }
  500. flush_workqueue(shost->work_q);
  501. }
  502. EXPORT_SYMBOL_GPL(scsi_flush_work);