596 lines · 13.1 KB · C
RawDownload
/* * Interface to Linux block layer for MTD 'translation layers'. * * Copyright © 2003-2010 David Woodhouse <dwmw2@infradead.org> * * This program is free software; you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by * the Free Software Foundation; either version 2 of the License, or * (at your option) any later version. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the * GNU General Public License for more details. * * You should have received a copy of the GNU General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA * */ #include <linux/kernel.h>#include <linux/slab.h>#include <linux/module.h>#include <linux/list.h>#include <linux/fs.h>#include <linux/mtd/blktrans.h>#include <linux/mtd/mtd.h>#include <linux/blkdev.h>#include <linux/blkpg.h>#include <linux/spinlock.h>#include <linux/hdreg.h>#include <linux/init.h>#include <linux/mutex.h>#include <asm/uaccess.h> #include "mtdcore.h" static LIST_HEAD(blktrans_majors);static DEFINE_MUTEX(blktrans_ref_mutex); static void blktrans_dev_release(struct kref *kref){	struct mtd_blktrans_dev *dev =		container_of(kref, struct mtd_blktrans_dev, ref); 	dev->disk->private_data = NULL;	blk_cleanup_queue(dev->rq);	put_disk(dev->disk);	list_del(&dev->list);	kfree(dev);} static struct mtd_blktrans_dev *blktrans_dev_get(struct gendisk *disk){	struct mtd_blktrans_dev *dev; 	mutex_lock(&blktrans_ref_mutex);	dev = disk->private_data; 	if (!dev)		goto unlock;	kref_get(&dev->ref);unlock:	mutex_unlock(&blktrans_ref_mutex);	return dev;} static void blktrans_dev_put(struct mtd_blktrans_dev *dev){	mutex_lock(&blktrans_ref_mutex);	kref_put(&dev->ref, blktrans_dev_release);	mutex_unlock(&blktrans_ref_mutex);}  static int do_blktrans_request(struct mtd_blktrans_ops *tr,			       struct mtd_blktrans_dev *dev,			       struct request *req){	unsigned long block, nsect;	char *buf; 	block = blk_rq_pos(req) << 9 >> tr->blkshift;	nsect = blk_rq_cur_bytes(req) >> tr->blkshift; 	buf = req->buffer; 	if (req->cmd_type != REQ_TYPE_FS)		return -EIO; 	if (blk_rq_pos(req) + blk_rq_cur_sectors(req) >	    get_capacity(req->rq_disk))		return -EIO; 	if (req->cmd_flags & REQ_DISCARD)		return tr->discard(dev, block, nsect); 	switch(rq_data_dir(req)) {	case READ:		for (; nsect > 0; nsect--, block++, buf += tr->blksize)			if (tr->readsect(dev, block, buf))				return -EIO;		rq_flush_dcache_pages(req);		return 0;	case WRITE:		if (!tr->writesect)			return -EIO; 		rq_flush_dcache_pages(req);		for (; nsect > 0; nsect--, block++, buf += tr->blksize)			if (tr->writesect(dev, block, buf))				return -EIO;		return 0;	default:		printk(KERN_NOTICE "Unknown request %u\n", rq_data_dir(req));		return -EIO;	}} int mtd_blktrans_cease_background(struct mtd_blktrans_dev *dev){	return dev->bg_stop;}EXPORT_SYMBOL_GPL(mtd_blktrans_cease_background); static void mtd_blktrans_work(struct work_struct *work){	struct mtd_blktrans_dev *dev =		container_of(work, struct mtd_blktrans_dev, work);	struct mtd_blktrans_ops *tr = dev->tr;	struct request_queue *rq = dev->rq;	struct request *req = NULL;	int background_done = 0; 	spin_lock_irq(rq->queue_lock); 	while (1) {		int res; 		dev->bg_stop = false;		if (!req && !(req = blk_fetch_request(rq))) {			if (tr->background && !background_done) {				spin_unlock_irq(rq->queue_lock);				mutex_lock(&dev->lock);				tr->background(dev);				mutex_unlock(&dev->lock);				spin_lock_irq(rq->queue_lock);				/*				 * Do background processing just once per idle				 * period.				 */				background_done = !dev->bg_stop;				continue;			}			break;		} 		spin_unlock_irq(rq->queue_lock); 		mutex_lock(&dev->lock);		res = do_blktrans_request(dev->tr, dev, req);		mutex_unlock(&dev->lock); 		spin_lock_irq(rq->queue_lock); 		if (!__blk_end_request_cur(req, res))			req = NULL; 		background_done = 0;	} 	if (req)		__blk_end_request_all(req, -EIO); 	spin_unlock_irq(rq->queue_lock);} static void mtd_blktrans_request(struct request_queue *rq){	struct mtd_blktrans_dev *dev;	struct request *req = NULL; 	dev = rq->queuedata; 	if (!dev)		while ((req = blk_fetch_request(rq)) != NULL)			__blk_end_request_all(req, -ENODEV);	else		queue_work(dev->wq, &dev->work);} static int blktrans_open(struct block_device *bdev, fmode_t mode){	struct mtd_blktrans_dev *dev = blktrans_dev_get(bdev->bd_disk);	int ret = 0; 	if (!dev)		return -ERESTARTSYS; /* FIXME: busy loop! -arnd*/ 	mutex_lock(&dev->lock); 	if (dev->open)		goto unlock; 	kref_get(&dev->ref);	__module_get(dev->tr->owner); 	if (!dev->mtd)		goto unlock; 	if (dev->tr->open) {		ret = dev->tr->open(dev);		if (ret)			goto error_put;	} 	ret = __get_mtd_device(dev->mtd);	if (ret)		goto error_release;	dev->file_mode = mode; unlock:	dev->open++;	mutex_unlock(&dev->lock);	blktrans_dev_put(dev);	return ret; error_release:	if (dev->tr->release)		dev->tr->release(dev);error_put:	module_put(dev->tr->owner);	kref_put(&dev->ref, blktrans_dev_release);	mutex_unlock(&dev->lock);	blktrans_dev_put(dev);	return ret;} static void blktrans_release(struct gendisk *disk, fmode_t mode){	struct mtd_blktrans_dev *dev = blktrans_dev_get(disk); 	if (!dev)		return; 	mutex_lock(&dev->lock); 	if (--dev->open)		goto unlock; 	kref_put(&dev->ref, blktrans_dev_release);	module_put(dev->tr->owner); 	if (dev->mtd) {		if (dev->tr->release)			dev->tr->release(dev);		__put_mtd_device(dev->mtd);	}unlock:	mutex_unlock(&dev->lock);	blktrans_dev_put(dev);} static int blktrans_getgeo(struct block_device *bdev, struct hd_geometry *geo){	struct mtd_blktrans_dev *dev = blktrans_dev_get(bdev->bd_disk);	int ret = -ENXIO; 	if (!dev)		return ret; 	mutex_lock(&dev->lock); 	if (!dev->mtd)		goto unlock; 	ret = dev->tr->getgeo ? dev->tr->getgeo(dev, geo) : 0;unlock:	mutex_unlock(&dev->lock);	blktrans_dev_put(dev);	return ret;} static int blktrans_ioctl(struct block_device *bdev, fmode_t mode,			      unsigned int cmd, unsigned long arg){	struct mtd_blktrans_dev *dev = blktrans_dev_get(bdev->bd_disk);	int ret = -ENXIO; 	if (!dev)		return ret; 	mutex_lock(&dev->lock); 	if (!dev->mtd)		goto unlock; 	switch (cmd) {	case BLKFLSBUF:		ret = dev->tr->flush ? dev->tr->flush(dev) : 0;		break;	default:		ret = -ENOTTY;	}unlock:	mutex_unlock(&dev->lock);	blktrans_dev_put(dev);	return ret;} static const struct block_device_operations mtd_block_ops = {	.owner		= THIS_MODULE,	.open		= blktrans_open,	.release	= blktrans_release,	.ioctl		= blktrans_ioctl,	.getgeo		= blktrans_getgeo,}; int add_mtd_blktrans_dev(struct mtd_blktrans_dev *new){	struct mtd_blktrans_ops *tr = new->tr;	struct mtd_blktrans_dev *d;	int last_devnum = -1;	struct gendisk *gd;	int ret; 	if (mutex_trylock(&mtd_table_mutex)) {		mutex_unlock(&mtd_table_mutex);		BUG();	} 	mutex_lock(&blktrans_ref_mutex);	list_for_each_entry(d, &tr->devs, list) {		if (new->devnum == -1) {			/* Use first free number */			if (d->devnum != last_devnum+1) {				/* Found a free devnum. Plug it in here */				new->devnum = last_devnum+1;				list_add_tail(&new->list, &d->list);				goto added;			}		} else if (d->devnum == new->devnum) {			/* Required number taken */			mutex_unlock(&blktrans_ref_mutex);			return -EBUSY;		} else if (d->devnum > new->devnum) {			/* Required number was free */			list_add_tail(&new->list, &d->list);			goto added;		}		last_devnum = d->devnum;	} 	ret = -EBUSY;	if (new->devnum == -1)		new->devnum = last_devnum+1; 	/* Check that the device and any partitions will get valid	 * minor numbers and that the disk naming code below can cope	 * with this number. */	if (new->devnum > (MINORMASK >> tr->part_bits) ||	    (tr->part_bits && new->devnum >= 27 * 26)) {		mutex_unlock(&blktrans_ref_mutex);		goto error1;	} 	list_add_tail(&new->list, &tr->devs); added:	mutex_unlock(&blktrans_ref_mutex); 	mutex_init(&new->lock);	kref_init(&new->ref);	if (!tr->writesect)		new->readonly = 1; 	/* Create gendisk */	ret = -ENOMEM;	gd = alloc_disk(1 << tr->part_bits); 	if (!gd)		goto error2; 	new->disk = gd;	gd->private_data = new;	gd->major = tr->major;	gd->first_minor = (new->devnum) << tr->part_bits;	gd->fops = &mtd_block_ops; 	if (tr->part_bits)		if (new->devnum < 26)			snprintf(gd->disk_name, sizeof(gd->disk_name),				 "%s%c", tr->name, 'a' + new->devnum);		else			snprintf(gd->disk_name, sizeof(gd->disk_name),				 "%s%c%c", tr->name,				 'a' - 1 + new->devnum / 26,				 'a' + new->devnum % 26);	else		snprintf(gd->disk_name, sizeof(gd->disk_name),			 "%s%d", tr->name, new->devnum); 	set_capacity(gd, (new->size * tr->blksize) >> 9); 	/* Create the request queue */	spin_lock_init(&new->queue_lock);	new->rq = blk_init_queue(mtd_blktrans_request, &new->queue_lock); 	if (!new->rq)		goto error3; 	new->rq->queuedata = new;	blk_queue_logical_block_size(new->rq, tr->blksize); 	queue_flag_set_unlocked(QUEUE_FLAG_NONROT, new->rq); 	if (tr->discard) {		queue_flag_set_unlocked(QUEUE_FLAG_DISCARD, new->rq);		new->rq->limits.max_discard_sectors = UINT_MAX;	} 	gd->queue = new->rq; 	/* Create processing workqueue */	new->wq = alloc_workqueue("%s%d", 0, 0,				  tr->name, new->mtd->index);	if (!new->wq)		goto error4;	INIT_WORK(&new->work, mtd_blktrans_work); 	gd->driverfs_dev = &new->mtd->dev; 	if (new->readonly)		set_disk_ro(gd, 1); 	add_disk(gd); 	if (new->disk_attributes) {		ret = sysfs_create_group(&disk_to_dev(gd)->kobj,					new->disk_attributes);		WARN_ON(ret);	}	return 0;error4:	blk_cleanup_queue(new->rq);error3:	put_disk(new->disk);error2:	list_del(&new->list);error1:	return ret;} int del_mtd_blktrans_dev(struct mtd_blktrans_dev *old){	unsigned long flags; 	if (mutex_trylock(&mtd_table_mutex)) {		mutex_unlock(&mtd_table_mutex);		BUG();	} 	if (old->disk_attributes)		sysfs_remove_group(&disk_to_dev(old->disk)->kobj,						old->disk_attributes); 	/* Stop new requests to arrive */	del_gendisk(old->disk); 	/* Stop workqueue. This will perform any pending request. */	destroy_workqueue(old->wq); 	/* Kill current requests */	spin_lock_irqsave(&old->queue_lock, flags);	old->rq->queuedata = NULL;	blk_start_queue(old->rq);	spin_unlock_irqrestore(&old->queue_lock, flags); 	/* If the device is currently open, tell trans driver to close it,		then put mtd device, and don't touch it again */	mutex_lock(&old->lock);	if (old->open) {		if (old->tr->release)			old->tr->release(old);		__put_mtd_device(old->mtd);	} 	old->mtd = NULL; 	mutex_unlock(&old->lock);	blktrans_dev_put(old);	return 0;} static void blktrans_notify_remove(struct mtd_info *mtd){	struct mtd_blktrans_ops *tr;	struct mtd_blktrans_dev *dev, *next; 	list_for_each_entry(tr, &blktrans_majors, list)

Lines 1–500 of 596.

Keyboard shortcuts

General

Show keyboard shortcuts
?
Focus the current search
/

Issues and pull requests

Open filters
f

Issues, pull requests and Inbox

Select next item
j↓
Select previous item
k↑
Open selected item
Enter
Dismiss filters or clear selection
Esc

Repository code

Go to file
t