tree da875d4f7802d6ca8a7db9f2cdba57b74d6c3672
parent a863862257b7dd08d855bafcb0aedd9ad848ed91
author Maxim Levitsky <maximlevitsky@gmail.com> 1266863970 +0200
committer David Woodhouse <David.Woodhouse@intel.com> 1267203926 +0000

mtd: blktrans: Hotplug fixes

* Add locking where it was missing.

* Don't do a get_mtd_device in blktrans_open because it would lead to a
  deadlock; instead do that in add_mtd_blktrans_dev.

* Only free the mtd_blktrans_dev structure when the last user exits.

* Flush request queue on device removal.

* Track users, and call tr->release in del_mtd_blktrans_dev
  Due to that ->open and release aren't called more that once.

Now it is safe to call del_mtd_blktrans_dev while the device is still in use.

Signed-off-by: Maxim Levitsky <maximlevitsky@gmail.com>
Signed-off-by: David Woodhouse <David.Woodhouse@intel.com>
