mirror of
https://git.kernel.org/pub/scm/linux/kernel/git/stable/linux.git
synced 2024-08-26 19:00:25 +00:00
![Brian Norris](/assets/img/avatar_default.png)
Commit073db4a51e
("mtd: fix: avoid race condition when accessing mtd->usecount") fixed a race condition but due to poor ordering of the mutex acquisition, introduced a potential deadlock. The deadlock can occur, for example, when rmmod'ing the m25p80 module, which will delete one or more MTDs, along with any corresponding mtdblock devices. This could potentially race with an acquisition of the block device as follows. -> blktrans_open() -> mutex_lock(&dev->lock); -> mutex_lock(&mtd_table_mutex); -> del_mtd_device() -> mutex_lock(&mtd_table_mutex); -> blktrans_notify_remove() -> del_mtd_blktrans_dev() -> mutex_lock(&dev->lock); This is a classic (potential) ABBA deadlock, which can be fixed by making the A->B ordering consistent everywhere. There was no real purpose to the ordering in the original patch, AFAIR, so this shouldn't be a problem. This ordering was actually already present in del_mtd_blktrans_dev(), for one, where the function tried to ensure that its caller already held mtd_table_mutex before it acquired &dev->lock: if (mutex_trylock(&mtd_table_mutex)) { mutex_unlock(&mtd_table_mutex); BUG(); } So, reverse the ordering of acquisition of &dev->lock and &mtd_table_mutex so we always acquire mtd_table_mutex first. Snippets of the lockdep output follow: # modprobe -r m25p80 [ 53.419251] [ 53.420838] ====================================================== [ 53.427300] [ INFO: possible circular locking dependency detected ] [ 53.433865] 4.3.0-rc6 #96 Not tainted [ 53.437686] ------------------------------------------------------- [ 53.444220] modprobe/372 is trying to acquire lock: [ 53.449320] (&new->lock){+.+...}, at: [<c043fe4c>] del_mtd_blktrans_dev+0x80/0xdc [ 53.457271] [ 53.457271] but task is already holding lock: [ 53.463372] (mtd_table_mutex){+.+.+.}, at: [<c0439994>] del_mtd_device+0x18/0x100 [ 53.471321] [ 53.471321] which lock already depends on the new lock. [ 53.471321] [ 53.479856] [ 53.479856] the existing dependency chain (in reverse order) is: [ 53.487660] -> #1 (mtd_table_mutex){+.+.+.}: [ 53.492331] [<c043fc5c>] blktrans_open+0x34/0x1a4 [ 53.497879] [<c01afce0>] __blkdev_get+0xc4/0x3b0 [ 53.503364] [<c01b0bb8>] blkdev_get+0x108/0x320 [ 53.508743] [<c01713c0>] do_dentry_open+0x218/0x314 [ 53.514496] [<c0180454>] path_openat+0x4c0/0xf9c [ 53.519959] [<c0182044>] do_filp_open+0x5c/0xc0 [ 53.525336] [<c0172758>] do_sys_open+0xfc/0x1cc [ 53.530716] [<c000f740>] ret_fast_syscall+0x0/0x1c [ 53.536375] -> #0 (&new->lock){+.+...}: [ 53.540587] [<c063f124>] mutex_lock_nested+0x38/0x3cc [ 53.546504] [<c043fe4c>] del_mtd_blktrans_dev+0x80/0xdc [ 53.552606] [<c043f164>] blktrans_notify_remove+0x7c/0x84 [ 53.558891] [<c04399f0>] del_mtd_device+0x74/0x100 [ 53.564544] [<c043c670>] del_mtd_partitions+0x80/0xc8 [ 53.570451] [<c0439aa0>] mtd_device_unregister+0x24/0x48 [ 53.576637] [<c046ce6c>] spi_drv_remove+0x1c/0x34 [ 53.582207] [<c03de0f0>] __device_release_driver+0x88/0x114 [ 53.588663] [<c03de19c>] device_release_driver+0x20/0x2c [ 53.594843] [<c03dd9e8>] bus_remove_device+0xd8/0x108 [ 53.600748] [<c03dacc0>] device_del+0x10c/0x210 [ 53.606127] [<c03dadd0>] device_unregister+0xc/0x20 [ 53.611849] [<c046d878>] __unregister+0x10/0x20 [ 53.617211] [<c03da868>] device_for_each_child+0x50/0x7c [ 53.623387] [<c046eae8>] spi_unregister_master+0x58/0x8c [ 53.629578] [<c03e12f0>] release_nodes+0x15c/0x1c8 [ 53.635223] [<c03de0f8>] __device_release_driver+0x90/0x114 [ 53.641689] [<c03de900>] driver_detach+0xb4/0xb8 [ 53.647147] [<c03ddc78>] bus_remove_driver+0x4c/0xa0 [ 53.652970] [<c00cab50>] SyS_delete_module+0x11c/0x1e4 [ 53.658976] [<c000f740>] ret_fast_syscall+0x0/0x1c [ 53.664621] [ 53.664621] other info that might help us debug this: [ 53.664621] [ 53.672979] Possible unsafe locking scenario: [ 53.672979] [ 53.679169] CPU0 CPU1 [ 53.683900] ---- ---- [ 53.688633] lock(mtd_table_mutex); [ 53.692383] lock(&new->lock); [ 53.698306] lock(mtd_table_mutex); [ 53.704658] lock(&new->lock); [ 53.707946] [ 53.707946] *** DEADLOCK *** Fixes:073db4a51e
("mtd: fix: avoid race condition when accessing mtd->usecount") Reported-by: Felipe Balbi <balbi@ti.com> Tested-by: Felipe Balbi <balbi@ti.com> Signed-off-by: Brian Norris <computersforpeace@gmail.com> Cc: <stable@vger.kernel.org>
599 lines
13 KiB
C
599 lines
13 KiB
C
/*
|
|
* 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/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 = bio_data(req->bio);
|
|
|
|
if (req->cmd_type != REQ_TYPE_FS)
|
|
return -EIO;
|
|
|
|
if (req->cmd_flags & REQ_FLUSH)
|
|
return tr->flush(dev);
|
|
|
|
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);
|
|
|
|
if (rq_data_dir(req) == READ) {
|
|
for (; nsect > 0; nsect--, block++, buf += tr->blksize)
|
|
if (tr->readsect(dev, block, buf))
|
|
return -EIO;
|
|
rq_flush_dcache_pages(req);
|
|
return 0;
|
|
} else {
|
|
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;
|
|
}
|
|
}
|
|
|
|
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;
|
|
}
|
|
|
|
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(&mtd_table_mutex);
|
|
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);
|
|
mutex_unlock(&mtd_table_mutex);
|
|
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);
|
|
mutex_unlock(&mtd_table_mutex);
|
|
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(&mtd_table_mutex);
|
|
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);
|
|
mutex_unlock(&mtd_table_mutex);
|
|
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) : -ENOTTY;
|
|
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, ((u64)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;
|
|
|
|
if (tr->flush)
|
|
blk_queue_flush(new->rq, REQ_FLUSH);
|
|
|
|
new->rq->queuedata = new;
|
|
blk_queue_logical_block_size(new->rq, tr->blksize);
|
|
|
|
queue_flag_set_unlocked(QUEUE_FLAG_NONROT, new->rq);
|
|
queue_flag_clear_unlocked(QUEUE_FLAG_ADD_RANDOM, new->rq);
|
|
|
|
if (tr->discard) {
|
|
queue_flag_set_unlocked(QUEUE_FLAG_DISCARD, new->rq);
|
|
blk_queue_max_discard_sectors(new->rq, 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)
|
|
list_for_each_entry_safe(dev, next, &tr->devs, list)
|
|
if (dev->mtd == mtd)
|
|
tr->remove_dev(dev);
|
|
}
|
|
|
|
static void blktrans_notify_add(struct mtd_info *mtd)
|
|
{
|
|
struct mtd_blktrans_ops *tr;
|
|
|
|
if (mtd->type == MTD_ABSENT)
|
|
return;
|
|
|
|
list_for_each_entry(tr, &blktrans_majors, list)
|
|
tr->add_mtd(tr, mtd);
|
|
}
|
|
|
|
static struct mtd_notifier blktrans_notifier = {
|
|
.add = blktrans_notify_add,
|
|
.remove = blktrans_notify_remove,
|
|
};
|
|
|
|
int register_mtd_blktrans(struct mtd_blktrans_ops *tr)
|
|
{
|
|
struct mtd_info *mtd;
|
|
int ret;
|
|
|
|
/* Register the notifier if/when the first device type is
|
|
registered, to prevent the link/init ordering from fucking
|
|
us over. */
|
|
if (!blktrans_notifier.list.next)
|
|
register_mtd_user(&blktrans_notifier);
|
|
|
|
|
|
mutex_lock(&mtd_table_mutex);
|
|
|
|
ret = register_blkdev(tr->major, tr->name);
|
|
if (ret < 0) {
|
|
printk(KERN_WARNING "Unable to register %s block device on major %d: %d\n",
|
|
tr->name, tr->major, ret);
|
|
mutex_unlock(&mtd_table_mutex);
|
|
return ret;
|
|
}
|
|
|
|
if (ret)
|
|
tr->major = ret;
|
|
|
|
tr->blkshift = ffs(tr->blksize) - 1;
|
|
|
|
INIT_LIST_HEAD(&tr->devs);
|
|
list_add(&tr->list, &blktrans_majors);
|
|
|
|
mtd_for_each_device(mtd)
|
|
if (mtd->type != MTD_ABSENT)
|
|
tr->add_mtd(tr, mtd);
|
|
|
|
mutex_unlock(&mtd_table_mutex);
|
|
return 0;
|
|
}
|
|
|
|
int deregister_mtd_blktrans(struct mtd_blktrans_ops *tr)
|
|
{
|
|
struct mtd_blktrans_dev *dev, *next;
|
|
|
|
mutex_lock(&mtd_table_mutex);
|
|
|
|
/* Remove it from the list of active majors */
|
|
list_del(&tr->list);
|
|
|
|
list_for_each_entry_safe(dev, next, &tr->devs, list)
|
|
tr->remove_dev(dev);
|
|
|
|
unregister_blkdev(tr->major, tr->name);
|
|
mutex_unlock(&mtd_table_mutex);
|
|
|
|
BUG_ON(!list_empty(&tr->devs));
|
|
return 0;
|
|
}
|
|
|
|
static void __exit mtd_blktrans_exit(void)
|
|
{
|
|
/* No race here -- if someone's currently in register_mtd_blktrans
|
|
we're screwed anyway. */
|
|
if (blktrans_notifier.list.next)
|
|
unregister_mtd_user(&blktrans_notifier);
|
|
}
|
|
|
|
module_exit(mtd_blktrans_exit);
|
|
|
|
EXPORT_SYMBOL_GPL(register_mtd_blktrans);
|
|
EXPORT_SYMBOL_GPL(deregister_mtd_blktrans);
|
|
EXPORT_SYMBOL_GPL(add_mtd_blktrans_dev);
|
|
EXPORT_SYMBOL_GPL(del_mtd_blktrans_dev);
|
|
|
|
MODULE_AUTHOR("David Woodhouse <dwmw2@infradead.org>");
|
|
MODULE_LICENSE("GPL");
|
|
MODULE_DESCRIPTION("Common interface to block layer for MTD 'translation layers'");
|