mtd_blkdevs.c 11 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475
  1. /*
  2. * $Id: mtd_blkdevs.c,v 1.1.1.1 2007/06/12 07:27:09 eyryu Exp $
  3. *
  4. * (C) 2003 David Woodhouse <dwmw2@infradead.org>
  5. *
  6. * Interface to Linux 2.5 block layer for MTD 'translation layers'.
  7. *
  8. */
  9. #include <linux/kernel.h>
  10. #include <linux/slab.h>
  11. #include <linux/module.h>
  12. #include <linux/list.h>
  13. #include <linux/fs.h>
  14. #include <linux/mtd/blktrans.h>
  15. #include <linux/mtd/mtd.h>
  16. #include <linux/blkdev.h>
  17. #include <linux/blkpg.h>
  18. #include <linux/spinlock.h>
  19. #include <linux/hdreg.h>
  20. #include <linux/init.h>
  21. #include <linux/mutex.h>
  22. #include <asm/uaccess.h>
  23. static LIST_HEAD(blktrans_majors);
  24. extern struct mutex mtd_table_mutex;
  25. extern struct mtd_info *mtd_table[];
  26. struct mtd_blkcore_priv {
  27. struct completion thread_dead;
  28. int exiting;
  29. wait_queue_head_t thread_wq;
  30. struct request_queue *rq;
  31. spinlock_t queue_lock;
  32. };
  33. static int do_blktrans_request(struct mtd_blktrans_ops *tr,
  34. struct mtd_blktrans_dev *dev,
  35. struct request *req)
  36. {
  37. unsigned long block, nsect;
  38. char *buf;
  39. block = req->sector << 9 >> tr->blkshift;
  40. nsect = req->current_nr_sectors << 9 >> tr->blkshift;
  41. buf = req->buffer;
  42. if (!blk_fs_request(req))
  43. return 0;
  44. if (req->sector + req->current_nr_sectors > get_capacity(req->rq_disk))
  45. return 0;
  46. switch(rq_data_dir(req)) {
  47. case READ:
  48. for (; nsect > 0; nsect--, block++, buf += tr->blksize)
  49. if (tr->readsect(dev, block, buf))
  50. return 0;
  51. return 1;
  52. case WRITE:
  53. if (!tr->writesect)
  54. return 0;
  55. for (; nsect > 0; nsect--, block++, buf += tr->blksize)
  56. if (tr->writesect(dev, block, buf))
  57. return 0;
  58. return 1;
  59. default:
  60. printk(KERN_NOTICE "Unknown request %u\n", rq_data_dir(req));
  61. return 0;
  62. }
  63. }
  64. static int mtd_blktrans_thread(void *arg)
  65. {
  66. struct mtd_blktrans_ops *tr = arg;
  67. struct request_queue *rq = tr->blkcore_priv->rq;
  68. /* we might get involved when memory gets low, so use PF_MEMALLOC */
  69. current->flags |= PF_MEMALLOC | PF_NOFREEZE;
  70. daemonize("%sd", tr->name);
  71. /* daemonize() doesn't do this for us since some kernel threads
  72. actually want to deal with signals. We can't just call
  73. exit_sighand() since that'll cause an oops when we finally
  74. do exit. */
  75. spin_lock_irq(&current->sighand->siglock);
  76. sigfillset(&current->blocked);
  77. recalc_sigpending();
  78. spin_unlock_irq(&current->sighand->siglock);
  79. spin_lock_irq(rq->queue_lock);
  80. while (!tr->blkcore_priv->exiting) {
  81. struct request *req;
  82. struct mtd_blktrans_dev *dev;
  83. int res = 0;
  84. DECLARE_WAITQUEUE(wait, current);
  85. req = elv_next_request(rq);
  86. if (!req) {
  87. add_wait_queue(&tr->blkcore_priv->thread_wq, &wait);
  88. set_current_state(TASK_INTERRUPTIBLE);
  89. spin_unlock_irq(rq->queue_lock);
  90. schedule();
  91. remove_wait_queue(&tr->blkcore_priv->thread_wq, &wait);
  92. spin_lock_irq(rq->queue_lock);
  93. continue;
  94. }
  95. dev = req->rq_disk->private_data;
  96. tr = dev->tr;
  97. spin_unlock_irq(rq->queue_lock);
  98. mutex_lock(&dev->lock);
  99. res = do_blktrans_request(tr, dev, req);
  100. mutex_unlock(&dev->lock);
  101. spin_lock_irq(rq->queue_lock);
  102. end_request(req, res);
  103. }
  104. spin_unlock_irq(rq->queue_lock);
  105. complete_and_exit(&tr->blkcore_priv->thread_dead, 0);
  106. }
  107. static void mtd_blktrans_request(struct request_queue *rq)
  108. {
  109. struct mtd_blktrans_ops *tr = rq->queuedata;
  110. wake_up(&tr->blkcore_priv->thread_wq);
  111. }
  112. static int blktrans_open(struct inode *i, struct file *f)
  113. {
  114. struct mtd_blktrans_dev *dev;
  115. struct mtd_blktrans_ops *tr;
  116. int ret = -ENODEV;
  117. dev = i->i_bdev->bd_disk->private_data;
  118. tr = dev->tr;
  119. if (!try_module_get(dev->mtd->owner))
  120. goto out;
  121. if (!try_module_get(tr->owner))
  122. goto out_tr;
  123. /* FIXME: Locking. A hot pluggable device can go away
  124. (del_mtd_device can be called for it) without its module
  125. being unloaded. */
  126. dev->mtd->usecount++;
  127. ret = 0;
  128. if (tr->open && (ret = tr->open(dev))) {
  129. dev->mtd->usecount--;
  130. module_put(dev->mtd->owner);
  131. out_tr:
  132. module_put(tr->owner);
  133. }
  134. out:
  135. return ret;
  136. }
  137. static int blktrans_release(struct inode *i, struct file *f)
  138. {
  139. struct mtd_blktrans_dev *dev;
  140. struct mtd_blktrans_ops *tr;
  141. int ret = 0;
  142. dev = i->i_bdev->bd_disk->private_data;
  143. tr = dev->tr;
  144. if (tr->release)
  145. ret = tr->release(dev);
  146. if (!ret) {
  147. dev->mtd->usecount--;
  148. module_put(dev->mtd->owner);
  149. module_put(tr->owner);
  150. }
  151. return ret;
  152. }
  153. static int blktrans_getgeo(struct block_device *bdev, struct hd_geometry *geo)
  154. {
  155. struct mtd_blktrans_dev *dev = bdev->bd_disk->private_data;
  156. if (dev->tr->getgeo)
  157. return dev->tr->getgeo(dev, geo);
  158. return -ENOTTY;
  159. }
  160. static int blktrans_ioctl(struct inode *inode, struct file *file,
  161. unsigned int cmd, unsigned long arg)
  162. {
  163. struct mtd_blktrans_dev *dev = inode->i_bdev->bd_disk->private_data;
  164. struct mtd_blktrans_ops *tr = dev->tr;
  165. switch (cmd) {
  166. case BLKFLSBUF:
  167. if (tr->flush)
  168. return tr->flush(dev);
  169. /* The core code did the work, we had nothing to do. */
  170. return 0;
  171. default:
  172. return -ENOTTY;
  173. }
  174. }
  175. struct block_device_operations mtd_blktrans_ops = {
  176. .owner = THIS_MODULE,
  177. .open = blktrans_open,
  178. .release = blktrans_release,
  179. .ioctl = blktrans_ioctl,
  180. .getgeo = blktrans_getgeo,
  181. };
  182. int add_mtd_blktrans_dev(struct mtd_blktrans_dev *new)
  183. {
  184. struct mtd_blktrans_ops *tr = new->tr;
  185. struct list_head *this;
  186. int last_devnum = -1;
  187. struct gendisk *gd;
  188. if (!!mutex_trylock(&mtd_table_mutex)) {
  189. mutex_unlock(&mtd_table_mutex);
  190. BUG();
  191. }
  192. list_for_each(this, &tr->devs) {
  193. struct mtd_blktrans_dev *d = list_entry(this, struct mtd_blktrans_dev, list);
  194. if (new->devnum == -1) {
  195. /* Use first free number */
  196. if (d->devnum != last_devnum+1) {
  197. /* Found a free devnum. Plug it in here */
  198. new->devnum = last_devnum+1;
  199. list_add_tail(&new->list, &d->list);
  200. goto added;
  201. }
  202. } else if (d->devnum == new->devnum) {
  203. /* Required number taken */
  204. return -EBUSY;
  205. } else if (d->devnum > new->devnum) {
  206. /* Required number was free */
  207. list_add_tail(&new->list, &d->list);
  208. goto added;
  209. }
  210. last_devnum = d->devnum;
  211. }
  212. if (new->devnum == -1)
  213. new->devnum = last_devnum+1;
  214. if ((new->devnum << tr->part_bits) > 256) {
  215. return -EBUSY;
  216. }
  217. mutex_init(&new->lock);
  218. list_add_tail(&new->list, &tr->devs);
  219. added:
  220. if (!tr->writesect)
  221. new->readonly = 1;
  222. gd = alloc_disk(1 << tr->part_bits);
  223. if (!gd) {
  224. list_del(&new->list);
  225. return -ENOMEM;
  226. }
  227. gd->major = tr->major;
  228. gd->first_minor = (new->devnum) << tr->part_bits;
  229. gd->fops = &mtd_blktrans_ops;
  230. if (tr->part_bits)
  231. if (new->devnum < 26)
  232. snprintf(gd->disk_name, sizeof(gd->disk_name),
  233. "%s%c", tr->name, 'a' + new->devnum);
  234. else
  235. snprintf(gd->disk_name, sizeof(gd->disk_name),
  236. "%s%c%c", tr->name,
  237. 'a' - 1 + new->devnum / 26,
  238. 'a' + new->devnum % 26);
  239. else
  240. snprintf(gd->disk_name, sizeof(gd->disk_name),
  241. "%s%d", tr->name, new->devnum);
  242. /* 2.5 has capacity in units of 512 bytes while still
  243. having BLOCK_SIZE_BITS set to 10. Just to keep us amused. */
  244. set_capacity(gd, (new->size * tr->blksize) >> 9);
  245. gd->private_data = new;
  246. new->blkcore_priv = gd;
  247. gd->queue = tr->blkcore_priv->rq;
  248. if (new->readonly)
  249. set_disk_ro(gd, 1);
  250. add_disk(gd);
  251. return 0;
  252. }
  253. int del_mtd_blktrans_dev(struct mtd_blktrans_dev *old)
  254. {
  255. if (!!mutex_trylock(&mtd_table_mutex)) {
  256. mutex_unlock(&mtd_table_mutex);
  257. BUG();
  258. }
  259. list_del(&old->list);
  260. del_gendisk(old->blkcore_priv);
  261. put_disk(old->blkcore_priv);
  262. return 0;
  263. }
  264. static void blktrans_notify_remove(struct mtd_info *mtd)
  265. {
  266. struct list_head *this, *this2, *next;
  267. list_for_each(this, &blktrans_majors) {
  268. struct mtd_blktrans_ops *tr = list_entry(this, struct mtd_blktrans_ops, list);
  269. list_for_each_safe(this2, next, &tr->devs) {
  270. struct mtd_blktrans_dev *dev = list_entry(this2, struct mtd_blktrans_dev, list);
  271. if (dev->mtd == mtd)
  272. tr->remove_dev(dev);
  273. }
  274. }
  275. }
  276. static void blktrans_notify_add(struct mtd_info *mtd)
  277. {
  278. struct list_head *this;
  279. if (mtd->type == MTD_ABSENT)
  280. return;
  281. list_for_each(this, &blktrans_majors) {
  282. struct mtd_blktrans_ops *tr = list_entry(this, struct mtd_blktrans_ops, list);
  283. tr->add_mtd(tr, mtd);
  284. }
  285. }
  286. static struct mtd_notifier blktrans_notifier = {
  287. .add = blktrans_notify_add,
  288. .remove = blktrans_notify_remove,
  289. };
  290. int register_mtd_blktrans(struct mtd_blktrans_ops *tr)
  291. {
  292. int ret, i;
  293. /* Register the notifier if/when the first device type is
  294. registered, to prevent the link/init ordering from fucking
  295. us over. */
  296. if (!blktrans_notifier.list.next)
  297. register_mtd_user(&blktrans_notifier);
  298. tr->blkcore_priv = kzalloc(sizeof(*tr->blkcore_priv), GFP_KERNEL);
  299. if (!tr->blkcore_priv)
  300. return -ENOMEM;
  301. mutex_lock(&mtd_table_mutex);
  302. ret = register_blkdev(tr->major, tr->name);
  303. if (ret) {
  304. printk(KERN_WARNING "Unable to register %s block device on major %d: %d\n",
  305. tr->name, tr->major, ret);
  306. kfree(tr->blkcore_priv);
  307. mutex_unlock(&mtd_table_mutex);
  308. return ret;
  309. }
  310. spin_lock_init(&tr->blkcore_priv->queue_lock);
  311. init_completion(&tr->blkcore_priv->thread_dead);
  312. init_waitqueue_head(&tr->blkcore_priv->thread_wq);
  313. tr->blkcore_priv->rq = blk_init_queue(mtd_blktrans_request, &tr->blkcore_priv->queue_lock);
  314. if (!tr->blkcore_priv->rq) {
  315. unregister_blkdev(tr->major, tr->name);
  316. kfree(tr->blkcore_priv);
  317. mutex_unlock(&mtd_table_mutex);
  318. return -ENOMEM;
  319. }
  320. tr->blkcore_priv->rq->queuedata = tr;
  321. blk_queue_hardsect_size(tr->blkcore_priv->rq, tr->blksize);
  322. tr->blkshift = ffs(tr->blksize) - 1;
  323. ret = kernel_thread(mtd_blktrans_thread, tr, CLONE_KERNEL);
  324. if (ret < 0) {
  325. blk_cleanup_queue(tr->blkcore_priv->rq);
  326. unregister_blkdev(tr->major, tr->name);
  327. kfree(tr->blkcore_priv);
  328. mutex_unlock(&mtd_table_mutex);
  329. return ret;
  330. }
  331. INIT_LIST_HEAD(&tr->devs);
  332. list_add(&tr->list, &blktrans_majors);
  333. for (i=0; i<MAX_MTD_DEVICES; i++) {
  334. if (mtd_table[i] && mtd_table[i]->type != MTD_ABSENT)
  335. tr->add_mtd(tr, mtd_table[i]);
  336. }
  337. mutex_unlock(&mtd_table_mutex);
  338. return 0;
  339. }
  340. int deregister_mtd_blktrans(struct mtd_blktrans_ops *tr)
  341. {
  342. struct list_head *this, *next;
  343. mutex_lock(&mtd_table_mutex);
  344. /* Clean up the kernel thread */
  345. tr->blkcore_priv->exiting = 1;
  346. wake_up(&tr->blkcore_priv->thread_wq);
  347. wait_for_completion(&tr->blkcore_priv->thread_dead);
  348. /* Remove it from the list of active majors */
  349. list_del(&tr->list);
  350. list_for_each_safe(this, next, &tr->devs) {
  351. struct mtd_blktrans_dev *dev = list_entry(this, struct mtd_blktrans_dev, list);
  352. tr->remove_dev(dev);
  353. }
  354. blk_cleanup_queue(tr->blkcore_priv->rq);
  355. unregister_blkdev(tr->major, tr->name);
  356. mutex_unlock(&mtd_table_mutex);
  357. kfree(tr->blkcore_priv);
  358. BUG_ON(!list_empty(&tr->devs));
  359. return 0;
  360. }
  361. static void __exit mtd_blktrans_exit(void)
  362. {
  363. /* No race here -- if someone's currently in register_mtd_blktrans
  364. we're screwed anyway. */
  365. if (blktrans_notifier.list.next)
  366. unregister_mtd_user(&blktrans_notifier);
  367. }
  368. module_exit(mtd_blktrans_exit);
  369. EXPORT_SYMBOL_GPL(register_mtd_blktrans);
  370. EXPORT_SYMBOL_GPL(deregister_mtd_blktrans);
  371. EXPORT_SYMBOL_GPL(add_mtd_blktrans_dev);
  372. EXPORT_SYMBOL_GPL(del_mtd_blktrans_dev);
  373. MODULE_AUTHOR("David Woodhouse <dwmw2@infradead.org>");
  374. MODULE_LICENSE("GPL");
  375. MODULE_DESCRIPTION("Common interface to block layer for MTD 'translation layers'");