1 files changed, 42 insertions, 38 deletions

diff --git a/drivers/mtd/ubi/wl.c b/drivers/mtd/ubi/wl.c
index 6654f191868e..834f6fe1f5fa 100644
--- a/drivers/mtd/ubi/wl.c
+++ b/drivers/mtd/ubi/wl.c
@@ -253,7 +253,7 @@ static int do_work(struct ubi_device *ubi)
          */
         err = wrk->func(ubi, wrk, 0);
         if (err)
-                ubi_err("work failed with error code %d", err);
+                ubi_err(ubi, "work failed with error code %d", err);
         up_read(&ubi->work_sem);
 
         return err;
@@ -470,8 +470,11 @@ struct ubi_wl_entry *ubi_wl_get_fm_peb(struct ubi_device *ubi, int anchor)
 {
         struct ubi_wl_entry *e = NULL;
 
-        if (!ubi->free.rb_node || (ubi->free_count - ubi->beb_rsvd_pebs < 1))
+        if (!ubi->free.rb_node || (ubi->free_count - ubi->beb_rsvd_pebs < 1)) {
+                ubi_warn(ubi, "Can't get peb for fastmap:anchor=%d, free_cnt=%d, reserved=%d",
+                         anchor, ubi->free_count, ubi->beb_rsvd_pebs);
                 goto out;
+        }
 
         if (anchor)
                 e = find_anchor_wl_entry(&ubi->free);
@@ -507,7 +510,7 @@ static int __wl_get_peb(struct ubi_device *ubi)
 retry:
         if (!ubi->free.rb_node) {
                 if (ubi->works_count == 0) {
-                        ubi_err("no free eraseblocks");
+                        ubi_err(ubi, "no free eraseblocks");
                         ubi_assert(list_empty(&ubi->works));
                         return -ENOSPC;
                 }
@@ -520,7 +523,7 @@ retry:
 
         e = find_mean_wl_entry(ubi, &ubi->free);
         if (!e) {
-                ubi_err("no free eraseblocks");
+                ubi_err(ubi, "no free eraseblocks");
                 return -ENOSPC;
         }
 
@@ -692,7 +695,8 @@ int ubi_wl_get_peb(struct ubi_device *ubi)
         err = ubi_self_check_all_ff(ubi, peb, ubi->vid_hdr_aloffset,
                                     ubi->peb_size - ubi->vid_hdr_aloffset);
         if (err) {
-                ubi_err("new PEB %d does not contain all 0xFF bytes", peb);
+                ubi_err(ubi, "new PEB %d does not contain all 0xFF bytes",
+                        peb);
                 return err;
         }
 
@@ -760,7 +764,7 @@ static int sync_erase(struct ubi_device *ubi, struct ubi_wl_entry *e,
                  * Erase counter overflow. Upgrade UBI and use 64-bit
                  * erase counters internally.
                  */
-                ubi_err("erase counter overflow at PEB %d, EC %llu",
+                ubi_err(ubi, "erase counter overflow at PEB %d, EC %llu",
                         e->pnum, ec);
                 err = -EINVAL;
                 goto out_free;
@@ -1137,7 +1141,7 @@ static int wear_leveling_worker(struct ubi_device *ubi, struct ubi_work *wrk,
                         goto out_not_moved;
                 }
 
-                ubi_err("error %d while reading VID header from PEB %d",
+                ubi_err(ubi, "error %d while reading VID header from PEB %d",
                         err, e1->pnum);
                 goto out_error;
         }
@@ -1181,7 +1185,7 @@ static int wear_leveling_worker(struct ubi_device *ubi, struct ubi_work *wrk,
                          * UBI from trying to move it over and over again.
                          */
                         if (ubi->erroneous_peb_count > ubi->max_erroneous) {
-                                ubi_err("too many erroneous eraseblocks (%d)",
+                                ubi_err(ubi, "too many erroneous eraseblocks (%d)",
                                         ubi->erroneous_peb_count);
                                 goto out_error;
                         }
@@ -1197,7 +1201,7 @@ static int wear_leveling_worker(struct ubi_device *ubi, struct ubi_work *wrk,
 
         /* The PEB has been successfully moved */
         if (scrubbing)
-                ubi_msg("scrubbed PEB %d (LEB %d:%d), data moved to PEB %d",
+                ubi_msg(ubi, "scrubbed PEB %d (LEB %d:%d), data moved to PEB %d",
                         e1->pnum, vol_id, lnum, e2->pnum);
         ubi_free_vid_hdr(ubi, vid_hdr);
 
@@ -1212,7 +1216,6 @@ static int wear_leveling_worker(struct ubi_device *ubi, struct ubi_work *wrk,
 
         err = do_sync_erase(ubi, e1, vol_id, lnum, 0);
         if (err) {
-                kmem_cache_free(ubi_wl_entry_slab, e1);
                 if (e2)
                         kmem_cache_free(ubi_wl_entry_slab, e2);
                 goto out_ro;
@@ -1226,10 +1229,8 @@ static int wear_leveling_worker(struct ubi_device *ubi, struct ubi_work *wrk,
                 dbg_wl("PEB %d (LEB %d:%d) was put meanwhile, erase",
                        e2->pnum, vol_id, lnum);
                 err = do_sync_erase(ubi, e2, vol_id, lnum, 0);
-                if (err) {
-                        kmem_cache_free(ubi_wl_entry_slab, e2);
+                if (err)
                         goto out_ro;
-                }
         }
 
         dbg_wl("done");
@@ -1265,19 +1266,18 @@ out_not_moved:
 
         ubi_free_vid_hdr(ubi, vid_hdr);
         err = do_sync_erase(ubi, e2, vol_id, lnum, torture);
-        if (err) {
-                kmem_cache_free(ubi_wl_entry_slab, e2);
+        if (err)
                 goto out_ro;
-        }
+
         mutex_unlock(&ubi->move_mutex);
         return 0;
 
 out_error:
         if (vol_id != -1)
-                ubi_err("error %d while moving PEB %d to PEB %d",
+                ubi_err(ubi, "error %d while moving PEB %d to PEB %d",
                         err, e1->pnum, e2->pnum);
         else
-                ubi_err("error %d while moving PEB %d (LEB %d:%d) to PEB %d",
+                ubi_err(ubi, "error %d while moving PEB %d (LEB %d:%d) to PEB %d",
                         err, e1->pnum, vol_id, lnum, e2->pnum);
         spin_lock(&ubi->wl_lock);
         ubi->move_from = ubi->move_to = NULL;
@@ -1458,7 +1458,7 @@ static int erase_worker(struct ubi_device *ubi, struct ubi_work *wl_wrk,
                 return err;
         }
 
-        ubi_err("failed to erase PEB %d, error %d", pnum, err);
+        ubi_err(ubi, "failed to erase PEB %d, error %d", pnum, err);
         kfree(wl_wrk);
 
         if (err == -EINTR || err == -ENOMEM || err == -EAGAIN ||
@@ -1486,7 +1486,7 @@ static int erase_worker(struct ubi_device *ubi, struct ubi_work *wl_wrk,
         /* It is %-EIO, the PEB went bad */
 
         if (!ubi->bad_allowed) {
-                ubi_err("bad physical eraseblock %d detected", pnum);
+                ubi_err(ubi, "bad physical eraseblock %d detected", pnum);
                 goto out_ro;
         }
 
@@ -1494,7 +1494,7 @@ static int erase_worker(struct ubi_device *ubi, struct ubi_work *wl_wrk,
         if (ubi->beb_rsvd_pebs == 0) {
                 if (ubi->avail_pebs == 0) {
                         spin_unlock(&ubi->volumes_lock);
-                        ubi_err("no reserved/available physical eraseblocks");
+                        ubi_err(ubi, "no reserved/available physical eraseblocks");
                         goto out_ro;
                 }
                 ubi->avail_pebs -= 1;
@@ -1502,7 +1502,7 @@ static int erase_worker(struct ubi_device *ubi, struct ubi_work *wl_wrk,
         }
         spin_unlock(&ubi->volumes_lock);
 
-        ubi_msg("mark PEB %d as bad", pnum);
+        ubi_msg(ubi, "mark PEB %d as bad", pnum);
         err = ubi_io_mark_bad(ubi, pnum);
         if (err)
                 goto out_ro;
@@ -1523,11 +1523,12 @@ static int erase_worker(struct ubi_device *ubi, struct ubi_work *wl_wrk,
         ubi->good_peb_count -= 1;
         ubi_calculate_reserved(ubi);
         if (available_consumed)
-                ubi_warn("no PEBs in the reserved pool, used an available PEB");
+                ubi_warn(ubi, "no PEBs in the reserved pool, used an available PEB");
         else if (ubi->beb_rsvd_pebs)
-                ubi_msg("%d PEBs left in the reserve", ubi->beb_rsvd_pebs);
+                ubi_msg(ubi, "%d PEBs left in the reserve",
+                        ubi->beb_rsvd_pebs);
         else
-                ubi_warn("last PEB from the reserve was used");
+                ubi_warn(ubi, "last PEB from the reserve was used");
         spin_unlock(&ubi->volumes_lock);
 
         return err;
@@ -1613,7 +1614,7 @@ retry:
                 } else {
                         err = prot_queue_del(ubi, e->pnum);
                         if (err) {
-                                ubi_err("PEB %d not found", pnum);
+                                ubi_err(ubi, "PEB %d not found", pnum);
                                 ubi_ro_mode(ubi);
                                 spin_unlock(&ubi->wl_lock);
                                 return err;
@@ -1646,7 +1647,7 @@ int ubi_wl_scrub_peb(struct ubi_device *ubi, int pnum)
 {
         struct ubi_wl_entry *e;
 
-        ubi_msg("schedule PEB %d for scrubbing", pnum);
+        ubi_msg(ubi, "schedule PEB %d for scrubbing", pnum);
 
 retry:
         spin_lock(&ubi->wl_lock);
@@ -1678,7 +1679,7 @@ retry:
 
                 err = prot_queue_del(ubi, e->pnum);
                 if (err) {
-                        ubi_err("PEB %d not found", pnum);
+                        ubi_err(ubi, "PEB %d not found", pnum);
                         ubi_ro_mode(ubi);
                         spin_unlock(&ubi->wl_lock);
                         return err;
@@ -1798,15 +1799,18 @@ int ubi_thread(void *u)
         int failures = 0;
         struct ubi_device *ubi = u;
 
-        ubi_msg("background thread \"%s\" started, PID %d",
+        ubi_msg(ubi, "background thread \"%s\" started, PID %d",
                 ubi->bgt_name, task_pid_nr(current));
 
         set_freezable();
         for (;;) {
                 int err;
 
-                if (kthread_should_stop())
+                if (kthread_should_stop()) {
+                        ubi_msg(ubi, "background thread \"%s\" should stop, PID %d",
+                                ubi->bgt_name, task_pid_nr(current));
                         break;
+                }
 
                 if (try_to_freeze())
                         continue;
@@ -1823,14 +1827,14 @@ int ubi_thread(void *u)
 
                 err = do_work(ubi);
                 if (err) {
-                        ubi_err("%s: work failed with error code %d",
+                        ubi_err(ubi, "%s: work failed with error code %d",
                                 ubi->bgt_name, err);
                         if (failures++ > WL_MAX_FAILURES) {
                                 /*
                                  * Too many failures, disable the thread and
                                  * switch to read-only mode.
                                  */
-                                ubi_msg("%s: %d consecutive failures",
+                                ubi_msg(ubi, "%s: %d consecutive failures",
                                         ubi->bgt_name, WL_MAX_FAILURES);
                                 ubi_ro_mode(ubi);
                                 ubi->thread_enabled = 0;
@@ -1981,10 +1985,10 @@ int ubi_wl_init(struct ubi_device *ubi, struct ubi_attach_info *ai)
 #endif
 
         if (ubi->avail_pebs < reserved_pebs) {
-                ubi_err("no enough physical eraseblocks (%d, need %d)",
+                ubi_err(ubi, "no enough physical eraseblocks (%d, need %d)",
                         ubi->avail_pebs, reserved_pebs);
                 if (ubi->corr_peb_count)
-                        ubi_err("%d PEBs are corrupted and not used",
+                        ubi_err(ubi, "%d PEBs are corrupted and not used",
                                 ubi->corr_peb_count);
                 goto out_free;
         }
@@ -2072,8 +2076,8 @@ static int self_check_ec(struct ubi_device *ubi, int pnum, int ec)
 
         read_ec = be64_to_cpu(ec_hdr->ec);
         if (ec != read_ec && read_ec - ec > 1) {
-                ubi_err("self-check failed for PEB %d", pnum);
-                ubi_err("read EC is %lld, should be %d", read_ec, ec);
+                ubi_err(ubi, "self-check failed for PEB %d", pnum);
+                ubi_err(ubi, "read EC is %lld, should be %d", read_ec, ec);
                 dump_stack();
                 err = 1;
         } else
@@ -2102,7 +2106,7 @@ static int self_check_in_wl_tree(const struct ubi_device *ubi,
         if (in_wl_tree(e, root))
                 return 0;
 
-        ubi_err("self-check failed for PEB %d, EC %d, RB-tree %p ",
+        ubi_err(ubi, "self-check failed for PEB %d, EC %d, RB-tree %p ",
                 e->pnum, e->ec, root);
         dump_stack();
         return -EINVAL;
@@ -2130,7 +2134,7 @@ static int self_check_in_pq(const struct ubi_device *ubi,
                         if (p == e)
                                 return 0;
 
-        ubi_err("self-check failed for PEB %d, EC %d, Protect queue",
+        ubi_err(ubi, "self-check failed for PEB %d, EC %d, Protect queue",
                 e->pnum, e->ec);
         dump_stack();
         return -EINVAL;