1 files changed, 48 insertions, 48 deletions

diff --git a/drivers/mtd/ubi/fastmap.c b/drivers/mtd/ubi/fastmap.c
index cfd5b5e90156..b56672bf3294 100644
--- a/drivers/mtd/ubi/fastmap.c
+++ b/drivers/mtd/ubi/fastmap.c
@@ -330,7 +330,7 @@ static int process_pool_aeb(struct ubi_device *ubi, struct ubi_attach_info *ai,
         if (found)
                 av = tmp_av;
         else {
-                ubi_err("orphaned volume in fastmap pool!");
+                ubi_err(ubi, "orphaned volume in fastmap pool!");
                 kmem_cache_free(ai->aeb_slab_cache, new_aeb);
                 return UBI_BAD_FASTMAP;
         }
@@ -414,14 +414,14 @@ static int scan_pool(struct ubi_device *ubi, struct ubi_attach_info *ai,
                 pnum = be32_to_cpu(pebs[i]);
 
                 if (ubi_io_is_bad(ubi, pnum)) {
-                        ubi_err("bad PEB in fastmap pool!");
+                        ubi_err(ubi, "bad PEB in fastmap pool!");
                         ret = UBI_BAD_FASTMAP;
                         goto out;
                 }
 
                 err = ubi_io_read_ec_hdr(ubi, pnum, ech, 0);
                 if (err && err != UBI_IO_BITFLIPS) {
-                        ubi_err("unable to read EC header! PEB:%i err:%i",
+                        ubi_err(ubi, "unable to read EC header! PEB:%i err:%i",
                                 pnum, err);
                         ret = err > 0 ? UBI_BAD_FASTMAP : err;
                         goto out;
@@ -435,7 +435,7 @@ static int scan_pool(struct ubi_device *ubi, struct ubi_attach_info *ai,
                 image_seq = be32_to_cpu(ech->image_seq);
 
                 if (image_seq && (image_seq != ubi->image_seq)) {
-                        ubi_err("bad image seq: 0x%x, expected: 0x%x",
+                        ubi_err(ubi, "bad image seq: 0x%x, expected: 0x%x",
                                 be32_to_cpu(ech->image_seq), ubi->image_seq);
                         ret = UBI_BAD_FASTMAP;
                         goto out;
@@ -493,7 +493,7 @@ static int scan_pool(struct ubi_device *ubi, struct ubi_attach_info *ai,
                         }
                 } else {
                         /* We are paranoid and fall back to scanning mode */
-                        ubi_err("fastmap pool PEBs contains damaged PEBs!");
+                        ubi_err(ubi, "fastmap pool PEBs contains damaged PEBs!");
                         ret = err > 0 ? UBI_BAD_FASTMAP : err;
                         goto out;
                 }
@@ -588,7 +588,7 @@ static int ubi_attach_fastmap(struct ubi_device *ubi,
                 goto fail_bad;
 
         if (be32_to_cpu(fmhdr->magic) != UBI_FM_HDR_MAGIC) {
-                ubi_err("bad fastmap header magic: 0x%x, expected: 0x%x",
+                ubi_err(ubi, "bad fastmap header magic: 0x%x, expected: 0x%x",
                         be32_to_cpu(fmhdr->magic), UBI_FM_HDR_MAGIC);
                 goto fail_bad;
         }
@@ -598,7 +598,7 @@ static int ubi_attach_fastmap(struct ubi_device *ubi,
         if (fm_pos >= fm_size)
                 goto fail_bad;
         if (be32_to_cpu(fmpl1->magic) != UBI_FM_POOL_MAGIC) {
-                ubi_err("bad fastmap pool magic: 0x%x, expected: 0x%x",
+                ubi_err(ubi, "bad fastmap pool magic: 0x%x, expected: 0x%x",
                         be32_to_cpu(fmpl1->magic), UBI_FM_POOL_MAGIC);
                 goto fail_bad;
         }
@@ -608,7 +608,7 @@ static int ubi_attach_fastmap(struct ubi_device *ubi,
         if (fm_pos >= fm_size)
                 goto fail_bad;
         if (be32_to_cpu(fmpl2->magic) != UBI_FM_POOL_MAGIC) {
-                ubi_err("bad fastmap pool magic: 0x%x, expected: 0x%x",
+                ubi_err(ubi, "bad fastmap pool magic: 0x%x, expected: 0x%x",
                         be32_to_cpu(fmpl2->magic), UBI_FM_POOL_MAGIC);
                 goto fail_bad;
         }
@@ -619,25 +619,26 @@ static int ubi_attach_fastmap(struct ubi_device *ubi,
         fm->max_wl_pool_size = be16_to_cpu(fmpl2->max_size);
 
         if (pool_size > UBI_FM_MAX_POOL_SIZE || pool_size < 0) {
-                ubi_err("bad pool size: %i", pool_size);
+                ubi_err(ubi, "bad pool size: %i", pool_size);
                 goto fail_bad;
         }
 
         if (wl_pool_size > UBI_FM_MAX_POOL_SIZE || wl_pool_size < 0) {
-                ubi_err("bad WL pool size: %i", wl_pool_size);
+                ubi_err(ubi, "bad WL pool size: %i", wl_pool_size);
                 goto fail_bad;
         }
 
 
         if (fm->max_pool_size > UBI_FM_MAX_POOL_SIZE ||
             fm->max_pool_size < 0) {
-                ubi_err("bad maximal pool size: %i", fm->max_pool_size);
+                ubi_err(ubi, "bad maximal pool size: %i", fm->max_pool_size);
                 goto fail_bad;
         }
 
         if (fm->max_wl_pool_size > UBI_FM_MAX_POOL_SIZE ||
             fm->max_wl_pool_size < 0) {
-                ubi_err("bad maximal WL pool size: %i", fm->max_wl_pool_size);
+                ubi_err(ubi, "bad maximal WL pool size: %i",
+                        fm->max_wl_pool_size);
                 goto fail_bad;
         }
 
@@ -696,8 +697,7 @@ static int ubi_attach_fastmap(struct ubi_device *ubi,
                         goto fail_bad;
 
                 if (be32_to_cpu(fmvhdr->magic) != UBI_FM_VHDR_MAGIC) {
-                        ubi_err("bad fastmap vol header magic: 0x%x, " \
-                                "expected: 0x%x",
+                        ubi_err(ubi, "bad fastmap vol header magic: 0x%x, expected: 0x%x",
                                 be32_to_cpu(fmvhdr->magic), UBI_FM_VHDR_MAGIC);
                         goto fail_bad;
                 }
@@ -722,8 +722,7 @@ static int ubi_attach_fastmap(struct ubi_device *ubi,
                         goto fail_bad;
 
                 if (be32_to_cpu(fm_eba->magic) != UBI_FM_EBA_MAGIC) {
-                        ubi_err("bad fastmap EBA header magic: 0x%x, " \
-                                "expected: 0x%x",
+                        ubi_err(ubi, "bad fastmap EBA header magic: 0x%x, expected: 0x%x",
                                 be32_to_cpu(fm_eba->magic), UBI_FM_EBA_MAGIC);
                         goto fail_bad;
                 }
@@ -788,7 +787,7 @@ static int ubi_attach_fastmap(struct ubi_device *ubi,
                         int err;
 
                         if (ubi_io_is_bad(ubi, tmp_aeb->pnum)) {
-                                ubi_err("bad PEB in fastmap EBA orphan list");
+                                ubi_err(ubi, "bad PEB in fastmap EBA orphan list");
                                 ret = UBI_BAD_FASTMAP;
                                 kfree(ech);
                                 goto fail;
@@ -796,8 +795,8 @@ static int ubi_attach_fastmap(struct ubi_device *ubi,
 
                         err = ubi_io_read_ec_hdr(ubi, tmp_aeb->pnum, ech, 0);
                         if (err && err != UBI_IO_BITFLIPS) {
-                                ubi_err("unable to read EC header! PEB:%i " \
-                                        "err:%i", tmp_aeb->pnum, err);
+                                ubi_err(ubi, "unable to read EC header! PEB:%i err:%i",
+                                        tmp_aeb->pnum, err);
                                 ret = err > 0 ? UBI_BAD_FASTMAP : err;
                                 kfree(ech);
 
@@ -908,14 +907,14 @@ int ubi_scan_fastmap(struct ubi_device *ubi, struct ubi_attach_info *ai,
                 fm->to_be_tortured[0] = 1;
 
         if (be32_to_cpu(fmsb->magic) != UBI_FM_SB_MAGIC) {
-                ubi_err("bad super block magic: 0x%x, expected: 0x%x",
+                ubi_err(ubi, "bad super block magic: 0x%x, expected: 0x%x",
                         be32_to_cpu(fmsb->magic), UBI_FM_SB_MAGIC);
                 ret = UBI_BAD_FASTMAP;
                 goto free_fm_sb;
         }
 
         if (fmsb->version != UBI_FM_FMT_VERSION) {
-                ubi_err("bad fastmap version: %i, expected: %i",
+                ubi_err(ubi, "bad fastmap version: %i, expected: %i",
                         fmsb->version, UBI_FM_FMT_VERSION);
                 ret = UBI_BAD_FASTMAP;
                 goto free_fm_sb;
@@ -923,15 +922,16 @@ int ubi_scan_fastmap(struct ubi_device *ubi, struct ubi_attach_info *ai,
 
         used_blocks = be32_to_cpu(fmsb->used_blocks);
         if (used_blocks > UBI_FM_MAX_BLOCKS || used_blocks < 1) {
-                ubi_err("number of fastmap blocks is invalid: %i", used_blocks);
+                ubi_err(ubi, "number of fastmap blocks is invalid: %i",
+                        used_blocks);
                 ret = UBI_BAD_FASTMAP;
                 goto free_fm_sb;
         }
 
         fm_size = ubi->leb_size * used_blocks;
         if (fm_size != ubi->fm_size) {
-                ubi_err("bad fastmap size: %zi, expected: %zi", fm_size,
-                        ubi->fm_size);
+                ubi_err(ubi, "bad fastmap size: %zi, expected: %zi",
+                        fm_size, ubi->fm_size);
                 ret = UBI_BAD_FASTMAP;
                 goto free_fm_sb;
         }
@@ -960,7 +960,7 @@ int ubi_scan_fastmap(struct ubi_device *ubi, struct ubi_attach_info *ai,
 
                 ret = ubi_io_read_ec_hdr(ubi, pnum, ech, 0);
                 if (ret && ret != UBI_IO_BITFLIPS) {
-                        ubi_err("unable to read fastmap block# %i EC (PEB: %i)",
+                        ubi_err(ubi, "unable to read fastmap block# %i EC (PEB: %i)",
                                 i, pnum);
                         if (ret > 0)
                                 ret = UBI_BAD_FASTMAP;
@@ -977,7 +977,7 @@ int ubi_scan_fastmap(struct ubi_device *ubi, struct ubi_attach_info *ai,
                  * we shouldn't fail if image_seq == 0.
                  */
                 if (image_seq && (image_seq != ubi->image_seq)) {
-                        ubi_err("wrong image seq:%d instead of %d",
+                        ubi_err(ubi, "wrong image seq:%d instead of %d",
                                 be32_to_cpu(ech->image_seq), ubi->image_seq);
                         ret = UBI_BAD_FASTMAP;
                         goto free_hdr;
@@ -985,15 +985,14 @@ int ubi_scan_fastmap(struct ubi_device *ubi, struct ubi_attach_info *ai,
 
                 ret = ubi_io_read_vid_hdr(ubi, pnum, vh, 0);
                 if (ret && ret != UBI_IO_BITFLIPS) {
-                        ubi_err("unable to read fastmap block# %i (PEB: %i)",
+                        ubi_err(ubi, "unable to read fastmap block# %i (PEB: %i)",
                                 i, pnum);
                         goto free_hdr;
                 }
 
                 if (i == 0) {
                         if (be32_to_cpu(vh->vol_id) != UBI_FM_SB_VOLUME_ID) {
-                                ubi_err("bad fastmap anchor vol_id: 0x%x," \
-                                        " expected: 0x%x",
+                                ubi_err(ubi, "bad fastmap anchor vol_id: 0x%x, expected: 0x%x",
                                         be32_to_cpu(vh->vol_id),
                                         UBI_FM_SB_VOLUME_ID);
                                 ret = UBI_BAD_FASTMAP;
@@ -1001,8 +1000,7 @@ int ubi_scan_fastmap(struct ubi_device *ubi, struct ubi_attach_info *ai,
                         }
                 } else {
                         if (be32_to_cpu(vh->vol_id) != UBI_FM_DATA_VOLUME_ID) {
-                                ubi_err("bad fastmap data vol_id: 0x%x," \
-                                        " expected: 0x%x",
+                                ubi_err(ubi, "bad fastmap data vol_id: 0x%x, expected: 0x%x",
                                         be32_to_cpu(vh->vol_id),
                                         UBI_FM_DATA_VOLUME_ID);
                                 ret = UBI_BAD_FASTMAP;
@@ -1016,7 +1014,7 @@ int ubi_scan_fastmap(struct ubi_device *ubi, struct ubi_attach_info *ai,
                 ret = ubi_io_read(ubi, ubi->fm_buf + (ubi->leb_size * i), pnum,
                                   ubi->leb_start, ubi->leb_size);
                 if (ret && ret != UBI_IO_BITFLIPS) {
-                        ubi_err("unable to read fastmap block# %i (PEB: %i, " \
+                        ubi_err(ubi, "unable to read fastmap block# %i (PEB: %i, "
                                 "err: %i)", i, pnum, ret);
                         goto free_hdr;
                 }
@@ -1030,8 +1028,9 @@ int ubi_scan_fastmap(struct ubi_device *ubi, struct ubi_attach_info *ai,
         fmsb2->data_crc = 0;
         crc = crc32(UBI_CRC32_INIT, ubi->fm_buf, fm_size);
         if (crc != tmp_crc) {
-                ubi_err("fastmap data CRC is invalid");
-                ubi_err("CRC should be: 0x%x, calc: 0x%x", tmp_crc, crc);
+                ubi_err(ubi, "fastmap data CRC is invalid");
+                ubi_err(ubi, "CRC should be: 0x%x, calc: 0x%x",
+                        tmp_crc, crc);
                 ret = UBI_BAD_FASTMAP;
                 goto free_hdr;
         }
@@ -1067,9 +1066,10 @@ int ubi_scan_fastmap(struct ubi_device *ubi, struct ubi_attach_info *ai,
         ubi->fm = fm;
         ubi->fm_pool.max_size = ubi->fm->max_pool_size;
         ubi->fm_wl_pool.max_size = ubi->fm->max_wl_pool_size;
-        ubi_msg("attached by fastmap");
-        ubi_msg("fastmap pool size: %d", ubi->fm_pool.max_size);
-        ubi_msg("fastmap WL pool size: %d", ubi->fm_wl_pool.max_size);
+        ubi_msg(ubi, "attached by fastmap");
+        ubi_msg(ubi, "fastmap pool size: %d", ubi->fm_pool.max_size);
+        ubi_msg(ubi, "fastmap WL pool size: %d",
+                ubi->fm_wl_pool.max_size);
         ubi->fm_disabled = 0;
 
         ubi_free_vid_hdr(ubi, vh);
@@ -1077,7 +1077,7 @@ int ubi_scan_fastmap(struct ubi_device *ubi, struct ubi_attach_info *ai,
 out:
         mutex_unlock(&ubi->fm_mutex);
         if (ret == UBI_BAD_FASTMAP)
-                ubi_err("Attach by fastmap failed, doing a full scan!");
+                ubi_err(ubi, "Attach by fastmap failed, doing a full scan!");
         return ret;
 
 free_hdr:
@@ -1273,7 +1273,7 @@ static int ubi_write_fastmap(struct ubi_device *ubi,
         dbg_bld("writing fastmap SB to PEB %i", new_fm->e[0]->pnum);
         ret = ubi_io_write_vid_hdr(ubi, new_fm->e[0]->pnum, avhdr);
         if (ret) {
-                ubi_err("unable to write vid_hdr to fastmap SB!");
+                ubi_err(ubi, "unable to write vid_hdr to fastmap SB!");
                 goto out_kfree;
         }
 
@@ -1293,7 +1293,7 @@ static int ubi_write_fastmap(struct ubi_device *ubi,
                         new_fm->e[i]->pnum, be64_to_cpu(dvhdr->sqnum));
                 ret = ubi_io_write_vid_hdr(ubi, new_fm->e[i]->pnum, dvhdr);
                 if (ret) {
-                        ubi_err("unable to write vid_hdr to PEB %i!",
+                        ubi_err(ubi, "unable to write vid_hdr to PEB %i!",
                                 new_fm->e[i]->pnum);
                         goto out_kfree;
                 }
@@ -1303,7 +1303,7 @@ static int ubi_write_fastmap(struct ubi_device *ubi,
                 ret = ubi_io_write(ubi, fm_raw + (i * ubi->leb_size),
                         new_fm->e[i]->pnum, ubi->leb_start, ubi->leb_size);
                 if (ret) {
-                        ubi_err("unable to write fastmap to PEB %i!",
+                        ubi_err(ubi, "unable to write fastmap to PEB %i!",
                                 new_fm->e[i]->pnum);
                         goto out_kfree;
                 }
@@ -1450,7 +1450,7 @@ int ubi_update_fastmap(struct ubi_device *ubi)
         ubi->fm = NULL;
 
         if (new_fm->used_blocks > UBI_FM_MAX_BLOCKS) {
-                ubi_err("fastmap too large");
+                ubi_err(ubi, "fastmap too large");
                 ret = -ENOSPC;
                 goto err;
         }
@@ -1462,7 +1462,7 @@ int ubi_update_fastmap(struct ubi_device *ubi)
 
                 if (!tmp_e && !old_fm) {
                         int j;
-                        ubi_err("could not get any free erase block");
+                        ubi_err(ubi, "could not get any free erase block");
 
                         for (j = 1; j < i; j++)
                                 ubi_wl_put_fm_peb(ubi, new_fm->e[j], j, 0);
@@ -1478,7 +1478,7 @@ int ubi_update_fastmap(struct ubi_device *ubi)
                                         ubi_wl_put_fm_peb(ubi, new_fm->e[j],
                                                           j, 0);
 
-                                ubi_err("could not erase old fastmap PEB");
+                                ubi_err(ubi, "could not erase old fastmap PEB");
                                 goto err;
                         }
 
@@ -1504,7 +1504,7 @@ int ubi_update_fastmap(struct ubi_device *ubi)
                         ret = erase_block(ubi, old_fm->e[0]->pnum);
                         if (ret < 0) {
                                 int i;
-                                ubi_err("could not erase old anchor PEB");
+                                ubi_err(ubi, "could not erase old anchor PEB");
 
                                 for (i = 1; i < new_fm->used_blocks; i++)
                                         ubi_wl_put_fm_peb(ubi, new_fm->e[i],
@@ -1525,7 +1525,7 @@ int ubi_update_fastmap(struct ubi_device *ubi)
         } else {
                 if (!tmp_e) {
                         int i;
-                        ubi_err("could not find any anchor PEB");
+                        ubi_err(ubi, "could not find any anchor PEB");
 
                         for (i = 1; i < new_fm->used_blocks; i++)
                                 ubi_wl_put_fm_peb(ubi, new_fm->e[i], i, 0);
@@ -1555,13 +1555,13 @@ out_unlock:
 err:
         kfree(new_fm);
 
-        ubi_warn("Unable to write new fastmap, err=%i", ret);
+        ubi_warn(ubi, "Unable to write new fastmap, err=%i", ret);
 
         ret = 0;
         if (old_fm) {
                 ret = invalidate_fastmap(ubi, old_fm);
                 if (ret < 0)
-                        ubi_err("Unable to invalidiate current fastmap!");
+                        ubi_err(ubi, "Unable to invalidiate current fastmap!");
                 else if (ret)
                         ret = 0;
         }