UBI: bugfix: protect from volume removal

When the WL worker is moving an LEB, the volume might go away
occasionally. UBI does not handle these situations correctly.

This patch introduces a new mutex which serializes wear-levelling
worker and the the 'ubi_wl_put_peb()' function. Now, if one puts
an LEB, and its PEB is being moved, it will wait on the mutex.
And because we unmap all LEBs when removing volumes, this will make
the volume remove function to wait while the LEB movement
finishes.

Below is an example of an oops which should be fixed by this patch:

Pid: 9167, comm: io_paral Not tainted (2.6.24-rc5-ubi-2.6.git #2)
EIP: 0060:[<f884a379>] EFLAGS: 00010246 CPU: 0
EIP is at prot_tree_del+0x2a/0x63 [ubi]
EAX: f39a90e0 EBX: 00000000 ECX: 00000000 EDX: 00000134
ESI: f39a90e0 EDI: f39a90e0 EBP: f2d55ddc ESP: f2d55dd4
 DS: 007b ES: 007b FS: 00d8 GS: 0033 SS: 0068
Process io_paral (pid: 9167, ti=f2d54000 task=f72a8030 task.ti=f2d54000)
Stack: f39a95f8 ef6aae50 f2d55e08 f884a511 f88538e1 f884ecea 00000134 00000000
       f39a9604 f39a95f0 efea8280 00000000 f39a90e0 f2d55e40 f8847261 f8850c3c
       f884eaad 00000001 000000b9 00000134 00000172 000000b9 00000134 00000001
Call Trace:
 [<c0105227>] show_trace_log_lvl+0x1a/0x30
 [<c01052e2>] show_stack_log_lvl+0xa5/0xca
 [<c01053d6>] show_registers+0xcf/0x21b
 [<c0105648>] die+0x126/0x224
 [<c0119a62>] do_page_fault+0x27f/0x60d
 [<c037dd62>] error_code+0x72/0x78
 [<f884a511>] ubi_wl_put_peb+0xf0/0x191 [ubi]
 [<f8847261>] ubi_eba_unmap_leb+0xaf/0xcc [ubi]
 [<f8843c21>] ubi_remove_volume+0x102/0x1e8 [ubi]
 [<f8846077>] ubi_cdev_ioctl+0x22a/0x383 [ubi]
 [<c017d768>] do_ioctl+0x68/0x71
 [<c017d7c6>] vfs_ioctl+0x55/0x271
 [<c017da15>] sys_ioctl+0x33/0x52
 [<c0104152>] sysenter_past_esp+0x5f/0xa5
 =======================

Signed-off-by: Artem Bityutskiy <Artem.Bityutskiy@nokia.com>

1 files changed, 133 insertions, 86 deletions

diff --git a/drivers/mtd/ubi/wl.c b/drivers/mtd/ubi/wl.c
index 36aa097203f9..a60f9425ab13 100644
--- a/drivers/mtd/ubi/wl.c
+++ b/drivers/mtd/ubi/wl.c
@@ -249,6 +249,8 @@ static int do_work(struct ubi_device *ubi)
         int err;
         struct ubi_work *wrk;
 
+        cond_resched();
+
         spin_lock(&ubi->wl_lock);
 
         if (list_empty(&ubi->works)) {
@@ -531,8 +533,12 @@ retry:
  * prot_tree_del - remove a physical eraseblock from the protection trees
  * @ubi: UBI device description object
  * @pnum: the physical eraseblock to remove
+ *
+ * This function returns PEB @pnum from the protection trees and returns zero
+ * in case of success and %-ENODEV if the PEB was not found in the protection
+ * trees.
  */
-static void prot_tree_del(struct ubi_device *ubi, int pnum)
+static int prot_tree_del(struct ubi_device *ubi, int pnum)
 {
         struct rb_node *p;
         struct ubi_wl_prot_entry *pe = NULL;
@@ -543,7 +549,7 @@ static void prot_tree_del(struct ubi_device *ubi, int pnum)
                 pe = rb_entry(p, struct ubi_wl_prot_entry, rb_pnum);
 
                 if (pnum == pe->e->pnum)
-                        break;
+                        goto found;
 
                 if (pnum < pe->e->pnum)
                         p = p->rb_left;
@@ -551,10 +557,14 @@ static void prot_tree_del(struct ubi_device *ubi, int pnum)
                         p = p->rb_right;
         }
 
+        return -ENODEV;
+
+found:
         ubi_assert(pe->e->pnum == pnum);
         rb_erase(&pe->rb_aec, &ubi->prot.aec);
         rb_erase(&pe->rb_pnum, &ubi->prot.pnum);
         kfree(pe);
+        return 0;
 }
 
 /**
@@ -726,7 +736,8 @@ static int schedule_erase(struct ubi_device *ubi, struct ubi_wl_entry *e,
 static int wear_leveling_worker(struct ubi_device *ubi, struct ubi_work *wrk,
                                 int cancel)
 {
-        int err, put = 0;
+        int err, put = 0, scrubbing = 0, protect = 0;
+        struct ubi_wl_prot_entry *pe;
         struct ubi_wl_entry *e1, *e2;
         struct ubi_vid_hdr *vid_hdr;
 
@@ -739,21 +750,17 @@ static int wear_leveling_worker(struct ubi_device *ubi, struct ubi_work *wrk,
         if (!vid_hdr)
                 return -ENOMEM;
 
+        mutex_lock(&ubi->move_mutex);
         spin_lock(&ubi->wl_lock);
+        ubi_assert(!ubi->move_from && !ubi->move_to);
+        ubi_assert(!ubi->move_to_put);
 
-        /*
-         * Only one WL worker at a time is supported at this implementation, so
-         * make sure a PEB is not being moved already.
-         */
-        if (ubi->move_to || !ubi->free.rb_node ||
+        if (!ubi->free.rb_node ||
             (!ubi->used.rb_node && !ubi->scrub.rb_node)) {
                 /*
-                 * Only one WL worker at a time is supported at this
-                 * implementation, so if a LEB is already being moved, cancel.
-                 *
-                 * No free physical eraseblocks? Well, we cancel wear-leveling
-                 * then. It will be triggered again when a free physical
-                 * eraseblock appears.
+                 * No free physical eraseblocks? Well, they must be waiting in
+                 * the queue to be erased. Cancel movement - it will be
+                 * triggered again when a free physical eraseblock appears.
                  *
                  * No used physical eraseblocks? They must be temporarily
                  * protected from being moved. They will be moved to the
@@ -762,10 +769,7 @@ static int wear_leveling_worker(struct ubi_device *ubi, struct ubi_work *wrk,
                  */
                 dbg_wl("cancel WL, a list is empty: free %d, used %d",
                        !ubi->free.rb_node, !ubi->used.rb_node);
-                ubi->wl_scheduled = 0;
-                spin_unlock(&ubi->wl_lock);
-                ubi_free_vid_hdr(ubi, vid_hdr);
-                return 0;
+                goto out_cancel;
         }
 
         if (!ubi->scrub.rb_node) {
@@ -780,16 +784,15 @@ static int wear_leveling_worker(struct ubi_device *ubi, struct ubi_work *wrk,
                 if (!(e2->ec - e1->ec >= UBI_WL_THRESHOLD)) {
                         dbg_wl("no WL needed: min used EC %d, max free EC %d",
                                e1->ec, e2->ec);
-                        ubi->wl_scheduled = 0;
-                        spin_unlock(&ubi->wl_lock);
-                        ubi_free_vid_hdr(ubi, vid_hdr);
-                        return 0;
+                        goto out_cancel;
                 }
                 paranoid_check_in_wl_tree(e1, &ubi->used);
                 rb_erase(&e1->rb, &ubi->used);
                 dbg_wl("move PEB %d EC %d to PEB %d EC %d",
                        e1->pnum, e1->ec, e2->pnum, e2->ec);
         } else {
+                /* Perform scrubbing */
+                scrubbing = 1;
                 e1 = rb_entry(rb_first(&ubi->scrub), struct ubi_wl_entry, rb);
                 e2 = find_wl_entry(&ubi->free, WL_FREE_MAX_DIFF);
                 paranoid_check_in_wl_tree(e1, &ubi->scrub);
@@ -799,8 +802,6 @@ static int wear_leveling_worker(struct ubi_device *ubi, struct ubi_work *wrk,
 
         paranoid_check_in_wl_tree(e2, &ubi->free);
         rb_erase(&e2->rb, &ubi->free);
-        ubi_assert(!ubi->move_from && !ubi->move_to);
-        ubi_assert(!ubi->move_to_put && !ubi->move_from_put);
         ubi->move_from = e1;
         ubi->move_to = e2;
         spin_unlock(&ubi->wl_lock);
@@ -810,6 +811,10 @@ static int wear_leveling_worker(struct ubi_device *ubi, struct ubi_work *wrk,
          * We so far do not know which logical eraseblock our physical
          * eraseblock (@e1) belongs to. We have to read the volume identifier
          * header first.
+         *
+         * Note, we are protected from this PEB being unmapped and erased. The
+         * 'ubi_wl_put_peb()' would wait for moving to be finished if the PEB
+         * which is being moved was unmapped.
          */
 
         err = ubi_io_read_vid_hdr(ubi, e1->pnum, vid_hdr, 0);
@@ -824,32 +829,51 @@ static int wear_leveling_worker(struct ubi_device *ubi, struct ubi_work *wrk,
                          * likely have the VID header in place.
                          */
                         dbg_wl("PEB %d has no VID header", e1->pnum);
-                        err = 0;
-                } else {
-                        ubi_err("error %d while reading VID header from PEB %d",
-                                err, e1->pnum);
-                        if (err > 0)
-                                err = -EIO;
+                        goto out_not_moved;
                 }
-                goto error;
+
+                ubi_err("error %d while reading VID header from PEB %d",
+                        err, e1->pnum);
+                if (err > 0)
+                        err = -EIO;
+                goto out_error;
         }
 
         err = ubi_eba_copy_leb(ubi, e1->pnum, e2->pnum, vid_hdr);
         if (err) {
-                if (err == UBI_IO_BITFLIPS)
-                        err = 0;
-                goto error;
+
+                if (err < 0)
+                        goto out_error;
+                if (err == 1)
+                        goto out_not_moved;
+
+                /*
+                 * For some reason the LEB was not moved - it might be because
+                 * the volume is being deleted. We should prevent this PEB from
+                 * being selected for wear-levelling movement for some "time",
+                 * so put it to the protection tree.
+                 */
+
+                dbg_wl("cancelled moving PEB %d", e1->pnum);
+                pe = kmalloc(sizeof(struct ubi_wl_prot_entry), GFP_NOFS);
+                if (!pe) {
+                        err = -ENOMEM;
+                        goto out_error;
+                }
+
+                protect = 1;
         }
 
         ubi_free_vid_hdr(ubi, vid_hdr);
         spin_lock(&ubi->wl_lock);
+        if (protect)
+                prot_tree_add(ubi, e1, pe, protect);
         if (!ubi->move_to_put)
                 wl_tree_add(e2, &ubi->used);
         else
                 put = 1;
         ubi->move_from = ubi->move_to = NULL;
-        ubi->move_from_put = ubi->move_to_put = 0;
-        ubi->wl_scheduled = 0;
+        ubi->move_to_put = ubi->wl_scheduled = 0;
         spin_unlock(&ubi->wl_lock);
 
         if (put) {
@@ -859,62 +883,67 @@ static int wear_leveling_worker(struct ubi_device *ubi, struct ubi_work *wrk,
                  */
                 dbg_wl("PEB %d was put meanwhile, erase", e2->pnum);
                 err = schedule_erase(ubi, e2, 0);
-                if (err) {
-                        kmem_cache_free(ubi_wl_entry_slab, e2);
-                        ubi_ro_mode(ubi);
-                }
+                if (err)
+                        goto out_error;
         }
 
-        err = schedule_erase(ubi, e1, 0);
-        if (err) {
-                kmem_cache_free(ubi_wl_entry_slab, e1);
-                ubi_ro_mode(ubi);
+        if (!protect) {
+                err = schedule_erase(ubi, e1, 0);
+                if (err)
+                        goto out_error;
         }
 
+
         dbg_wl("done");
-        return err;
+        mutex_unlock(&ubi->move_mutex);
+        return 0;
 
         /*
-         * Some error occurred. @e1 was not changed, so return it back. @e2
-         * might be changed, schedule it for erasure.
+         * For some reasons the LEB was not moved, might be an error, might be
+         * something else. @e1 was not changed, so return it back. @e2 might
+         * be changed, schedule it for erasure.
          */
-error:
-        if (err)
-                dbg_wl("error %d occurred, cancel operation", err);
-        ubi_assert(err <= 0);
-
+out_not_moved:
         ubi_free_vid_hdr(ubi, vid_hdr);
         spin_lock(&ubi->wl_lock);
-        ubi->wl_scheduled = 0;
-        if (ubi->move_from_put)
-                put = 1;
+        if (scrubbing)
+                wl_tree_add(e1, &ubi->scrub);
         else
                 wl_tree_add(e1, &ubi->used);
         ubi->move_from = ubi->move_to = NULL;
-        ubi->move_from_put = ubi->move_to_put = 0;
+        ubi->move_to_put = ubi->wl_scheduled = 0;
         spin_unlock(&ubi->wl_lock);
 
-        if (put) {
-                /*
-                 * Well, the target PEB was put meanwhile, schedule it for
-                 * erasure.
-                 */
-                dbg_wl("PEB %d was put meanwhile, erase", e1->pnum);
-                err = schedule_erase(ubi, e1, 0);
-                if (err) {
-                        kmem_cache_free(ubi_wl_entry_slab, e1);
-                        ubi_ro_mode(ubi);
-                }
-        }
-
         err = schedule_erase(ubi, e2, 0);
-        if (err) {
-                kmem_cache_free(ubi_wl_entry_slab, e2);
-                ubi_ro_mode(ubi);
-        }
+        if (err)
+                goto out_error;
+
+        mutex_unlock(&ubi->move_mutex);
+        return 0;
+
+out_error:
+        ubi_err("error %d while moving PEB %d to PEB %d",
+                err, e1->pnum, e2->pnum);
 
-        yield();
+        ubi_free_vid_hdr(ubi, vid_hdr);
+        spin_lock(&ubi->wl_lock);
+        ubi->move_from = ubi->move_to = NULL;
+        ubi->move_to_put = ubi->wl_scheduled = 0;
+        spin_unlock(&ubi->wl_lock);
+
+        kmem_cache_free(ubi_wl_entry_slab, e1);
+        kmem_cache_free(ubi_wl_entry_slab, e2);
+        ubi_ro_mode(ubi);
+
+        mutex_unlock(&ubi->move_mutex);
         return err;
+
+out_cancel:
+        ubi->wl_scheduled = 0;
+        spin_unlock(&ubi->wl_lock);
+        mutex_unlock(&ubi->move_mutex);
+        ubi_free_vid_hdr(ubi, vid_hdr);
+        return 0;
 }
 
 /**
@@ -1101,8 +1130,7 @@ out_ro:
 }
 
 /**
- * ubi_wl_put_peb - return a physical eraseblock to the wear-leveling
- * unit.
+ * ubi_wl_put_peb - return a physical eraseblock to the wear-leveling unit.
  * @ubi: UBI device description object
  * @pnum: physical eraseblock to return
  * @torture: if this physical eraseblock has to be tortured
@@ -1110,7 +1138,7 @@ out_ro:
  * This function is called to return physical eraseblock @pnum to the pool of
  * free physical eraseblocks. The @torture flag has to be set if an I/O error
  * occurred to this @pnum and it has to be tested. This function returns zero
- * in case of success and a negative error code in case of failure.
+ * in case of success, and a negative error code in case of failure.
  */
 int ubi_wl_put_peb(struct ubi_device *ubi, int pnum, int torture)
 {
@@ -1121,8 +1149,8 @@ int ubi_wl_put_peb(struct ubi_device *ubi, int pnum, int torture)
         ubi_assert(pnum >= 0);
         ubi_assert(pnum < ubi->peb_count);
 
+retry:
         spin_lock(&ubi->wl_lock);
-
         e = ubi->lookuptbl[pnum];
         if (e == ubi->move_from) {
                 /*
@@ -1130,11 +1158,13 @@ int ubi_wl_put_peb(struct ubi_device *ubi, int pnum, int torture)
                  * be moved. It will be scheduled for erasure in the
                  * wear-leveling worker.
                  */
-                dbg_wl("PEB %d is being moved", pnum);
-                ubi_assert(!ubi->move_from_put);
-                ubi->move_from_put = 1;
+                dbg_wl("PEB %d is being moved, wait", pnum);
                 spin_unlock(&ubi->wl_lock);
-                return 0;
+
+                /* Wait for the WL worker by taking the @ubi->move_mutex */
+                mutex_lock(&ubi->move_mutex);
+                mutex_unlock(&ubi->move_mutex);
+                goto retry;
         } else if (e == ubi->move_to) {
                 /*
                  * User is putting the physical eraseblock which was selected
@@ -1157,8 +1187,15 @@ int ubi_wl_put_peb(struct ubi_device *ubi, int pnum, int torture)
                 } else if (in_wl_tree(e, &ubi->scrub)) {
                         paranoid_check_in_wl_tree(e, &ubi->scrub);
                         rb_erase(&e->rb, &ubi->scrub);
-                } else
-                        prot_tree_del(ubi, e->pnum);
+                } else {
+                        err = prot_tree_del(ubi, e->pnum);
+                        if (err) {
+                                ubi_err("PEB %d not found", pnum);
+                                ubi_ro_mode(ubi);
+                                spin_unlock(&ubi->wl_lock);
+                                return err;
+                        }
+                }
         }
         spin_unlock(&ubi->wl_lock);
 
@@ -1212,8 +1249,17 @@ retry:
         if (in_wl_tree(e, &ubi->used)) {
                 paranoid_check_in_wl_tree(e, &ubi->used);
                 rb_erase(&e->rb, &ubi->used);
-        } else
-                prot_tree_del(ubi, pnum);
+        } else {
+                int err;
+
+                err = prot_tree_del(ubi, e->pnum);
+                if (err) {
+                        ubi_err("PEB %d not found", pnum);
+                        ubi_ro_mode(ubi);
+                        spin_unlock(&ubi->wl_lock);
+                        return err;
+                }
+        }
 
         wl_tree_add(e, &ubi->scrub);
         spin_unlock(&ubi->wl_lock);
@@ -1379,6 +1425,7 @@ int ubi_wl_init_scan(struct ubi_device *ubi, struct ubi_scan_info *si)
         ubi->used = ubi->free = ubi->scrub = RB_ROOT;
         ubi->prot.pnum = ubi->prot.aec = RB_ROOT;
         spin_lock_init(&ubi->wl_lock);
+        mutex_init(&ubi->move_mutex);
         ubi->max_ec = si->max_ec;
         INIT_LIST_HEAD(&ubi->works);