1 files changed, 77 insertions, 73 deletions

diff --git a/drivers/mtd/ubi/io.c b/drivers/mtd/ubi/io.c
index d36134925d31..396aaa543362 100644
--- a/drivers/mtd/ubi/io.c
+++ b/drivers/mtd/ubi/io.c
@@ -177,19 +177,20 @@ retry:
                          * enabled. A corresponding message will be printed
                          * later, when it is has been scrubbed.
                          */
-                        ubi_msg("fixable bit-flip detected at PEB %d", pnum);
+                        ubi_msg(ubi, "fixable bit-flip detected at PEB %d",
+                                pnum);
                         ubi_assert(len == read);
                         return UBI_IO_BITFLIPS;
                 }
 
                 if (retries++ < UBI_IO_RETRIES) {
-                        ubi_warn("error %d%s while reading %d bytes from PEB %d:%d, read only %zd bytes, retry",
+                        ubi_warn(ubi, "error %d%s while reading %d bytes from PEB %d:%d, read only %zd bytes, retry",
                                  err, errstr, len, pnum, offset, read);
                         yield();
                         goto retry;
                 }
 
-                ubi_err("error %d%s while reading %d bytes from PEB %d:%d, read %zd bytes",
+                ubi_err(ubi, "error %d%s while reading %d bytes from PEB %d:%d, read %zd bytes",
                         err, errstr, len, pnum, offset, read);
                 dump_stack();
 
@@ -246,7 +247,7 @@ int ubi_io_write(struct ubi_device *ubi, const void *buf, int pnum, int offset,
         ubi_assert(len > 0 && len % ubi->hdrs_min_io_size == 0);
 
         if (ubi->ro_mode) {
-                ubi_err("read-only mode");
+                ubi_err(ubi, "read-only mode");
                 return -EROFS;
         }
 
@@ -273,7 +274,7 @@ int ubi_io_write(struct ubi_device *ubi, const void *buf, int pnum, int offset,
         }
 
         if (ubi_dbg_is_write_failure(ubi)) {
-                ubi_err("cannot write %d bytes to PEB %d:%d (emulated)",
+                ubi_err(ubi, "cannot write %d bytes to PEB %d:%d (emulated)",
                         len, pnum, offset);
                 dump_stack();
                 return -EIO;
@@ -282,7 +283,7 @@ int ubi_io_write(struct ubi_device *ubi, const void *buf, int pnum, int offset,
         addr = (loff_t)pnum * ubi->peb_size + offset;
         err = mtd_write(ubi->mtd, addr, len, &written, buf);
         if (err) {
-                ubi_err("error %d while writing %d bytes to PEB %d:%d, written %zd bytes",
+                ubi_err(ubi, "error %d while writing %d bytes to PEB %d:%d, written %zd bytes",
                         err, len, pnum, offset, written);
                 dump_stack();
                 ubi_dump_flash(ubi, pnum, offset, len);
@@ -338,7 +339,7 @@ static int do_sync_erase(struct ubi_device *ubi, int pnum)
         ubi_assert(pnum >= 0 && pnum < ubi->peb_count);
 
         if (ubi->ro_mode) {
-                ubi_err("read-only mode");
+                ubi_err(ubi, "read-only mode");
                 return -EROFS;
         }
 
@@ -355,12 +356,12 @@ retry:
         err = mtd_erase(ubi->mtd, &ei);
         if (err) {
                 if (retries++ < UBI_IO_RETRIES) {
-                        ubi_warn("error %d while erasing PEB %d, retry",
+                        ubi_warn(ubi, "error %d while erasing PEB %d, retry",
                                  err, pnum);
                         yield();
                         goto retry;
                 }
-                ubi_err("cannot erase PEB %d, error %d", pnum, err);
+                ubi_err(ubi, "cannot erase PEB %d, error %d", pnum, err);
                 dump_stack();
                 return err;
         }
@@ -368,17 +369,18 @@ retry:
         err = wait_event_interruptible(wq, ei.state == MTD_ERASE_DONE ||
                                            ei.state == MTD_ERASE_FAILED);
         if (err) {
-                ubi_err("interrupted PEB %d erasure", pnum);
+                ubi_err(ubi, "interrupted PEB %d erasure", pnum);
                 return -EINTR;
         }
 
         if (ei.state == MTD_ERASE_FAILED) {
                 if (retries++ < UBI_IO_RETRIES) {
-                        ubi_warn("error while erasing PEB %d, retry", pnum);
+                        ubi_warn(ubi, "error while erasing PEB %d, retry",
+                                 pnum);
                         yield();
                         goto retry;
                 }
-                ubi_err("cannot erase PEB %d", pnum);
+                ubi_err(ubi, "cannot erase PEB %d", pnum);
                 dump_stack();
                 return -EIO;
         }
@@ -388,7 +390,7 @@ retry:
                 return err;
 
         if (ubi_dbg_is_erase_failure(ubi)) {
-                ubi_err("cannot erase PEB %d (emulated)", pnum);
+                ubi_err(ubi, "cannot erase PEB %d (emulated)", pnum);
                 return -EIO;
         }
 
@@ -411,7 +413,7 @@ static int torture_peb(struct ubi_device *ubi, int pnum)
 {
         int err, i, patt_count;
 
-        ubi_msg("run torture test for PEB %d", pnum);
+        ubi_msg(ubi, "run torture test for PEB %d", pnum);
         patt_count = ARRAY_SIZE(patterns);
         ubi_assert(patt_count > 0);
 
@@ -428,7 +430,7 @@ static int torture_peb(struct ubi_device *ubi, int pnum)
 
                 err = ubi_check_pattern(ubi->peb_buf, 0xFF, ubi->peb_size);
                 if (err == 0) {
-                        ubi_err("erased PEB %d, but a non-0xFF byte found",
+                        ubi_err(ubi, "erased PEB %d, but a non-0xFF byte found",
                                 pnum);
                         err = -EIO;
                         goto out;
@@ -448,7 +450,7 @@ static int torture_peb(struct ubi_device *ubi, int pnum)
                 err = ubi_check_pattern(ubi->peb_buf, patterns[i],
                                         ubi->peb_size);
                 if (err == 0) {
-                        ubi_err("pattern %x checking failed for PEB %d",
+                        ubi_err(ubi, "pattern %x checking failed for PEB %d",
                                 patterns[i], pnum);
                         err = -EIO;
                         goto out;
@@ -456,7 +458,7 @@ static int torture_peb(struct ubi_device *ubi, int pnum)
         }
 
         err = patt_count;
-        ubi_msg("PEB %d passed torture test, do not mark it as bad", pnum);
+        ubi_msg(ubi, "PEB %d passed torture test, do not mark it as bad", pnum);
 
 out:
         mutex_unlock(&ubi->buf_mutex);
@@ -466,7 +468,7 @@ out:
                  * has not passed because it happened on a freshly erased
                  * physical eraseblock which means something is wrong with it.
                  */
-                ubi_err("read problems on freshly erased PEB %d, must be bad",
+                ubi_err(ubi, "read problems on freshly erased PEB %d, must be bad",
                         pnum);
                 err = -EIO;
         }
@@ -542,7 +544,7 @@ error:
          * it. Supposedly the flash media or the driver is screwed up, so
          * return an error.
          */
-        ubi_err("cannot invalidate PEB %d, write returned %d", pnum, err);
+        ubi_err(ubi, "cannot invalidate PEB %d, write returned %d", pnum, err);
         ubi_dump_flash(ubi, pnum, 0, ubi->peb_size);
         return -EIO;
 }
@@ -574,7 +576,7 @@ int ubi_io_sync_erase(struct ubi_device *ubi, int pnum, int torture)
                 return err;
 
         if (ubi->ro_mode) {
-                ubi_err("read-only mode");
+                ubi_err(ubi, "read-only mode");
                 return -EROFS;
         }
 
@@ -616,7 +618,7 @@ int ubi_io_is_bad(const struct ubi_device *ubi, int pnum)
 
                 ret = mtd_block_isbad(mtd, (loff_t)pnum * ubi->peb_size);
                 if (ret < 0)
-                        ubi_err("error %d while checking if PEB %d is bad",
+                        ubi_err(ubi, "error %d while checking if PEB %d is bad",
                                 ret, pnum);
                 else if (ret)
                         dbg_io("PEB %d is bad", pnum);
@@ -642,7 +644,7 @@ int ubi_io_mark_bad(const struct ubi_device *ubi, int pnum)
         ubi_assert(pnum >= 0 && pnum < ubi->peb_count);
 
         if (ubi->ro_mode) {
-                ubi_err("read-only mode");
+                ubi_err(ubi, "read-only mode");
                 return -EROFS;
         }
 
@@ -651,7 +653,7 @@ int ubi_io_mark_bad(const struct ubi_device *ubi, int pnum)
 
         err = mtd_block_markbad(mtd, (loff_t)pnum * ubi->peb_size);
         if (err)
-                ubi_err("cannot mark PEB %d bad, error %d", pnum, err);
+                ubi_err(ubi, "cannot mark PEB %d bad, error %d", pnum, err);
         return err;
 }
 
@@ -674,32 +676,32 @@ static int validate_ec_hdr(const struct ubi_device *ubi,
         leb_start = be32_to_cpu(ec_hdr->data_offset);
 
         if (ec_hdr->version != UBI_VERSION) {
-                ubi_err("node with incompatible UBI version found: this UBI version is %d, image version is %d",
+                ubi_err(ubi, "node with incompatible UBI version found: this UBI version is %d, image version is %d",
                         UBI_VERSION, (int)ec_hdr->version);
                 goto bad;
         }
 
         if (vid_hdr_offset != ubi->vid_hdr_offset) {
-                ubi_err("bad VID header offset %d, expected %d",
+                ubi_err(ubi, "bad VID header offset %d, expected %d",
                         vid_hdr_offset, ubi->vid_hdr_offset);
                 goto bad;
         }
 
         if (leb_start != ubi->leb_start) {
-                ubi_err("bad data offset %d, expected %d",
+                ubi_err(ubi, "bad data offset %d, expected %d",
                         leb_start, ubi->leb_start);
                 goto bad;
         }
 
         if (ec < 0 || ec > UBI_MAX_ERASECOUNTER) {
-                ubi_err("bad erase counter %lld", ec);
+                ubi_err(ubi, "bad erase counter %lld", ec);
                 goto bad;
         }
 
         return 0;
 
 bad:
-        ubi_err("bad EC header");
+        ubi_err(ubi, "bad EC header");
         ubi_dump_ec_hdr(ec_hdr);
         dump_stack();
         return 1;
@@ -765,7 +767,7 @@ int ubi_io_read_ec_hdr(struct ubi_device *ubi, int pnum,
                 if (ubi_check_pattern(ec_hdr, 0xFF, UBI_EC_HDR_SIZE)) {
                         /* The physical eraseblock is supposedly empty */
                         if (verbose)
-                                ubi_warn("no EC header found at PEB %d, only 0xFF bytes",
+                                ubi_warn(ubi, "no EC header found at PEB %d, only 0xFF bytes",
                                          pnum);
                         dbg_bld("no EC header found at PEB %d, only 0xFF bytes",
                                 pnum);
@@ -780,7 +782,7 @@ int ubi_io_read_ec_hdr(struct ubi_device *ubi, int pnum,
                  * 0xFF bytes. Report that the header is corrupted.
                  */
                 if (verbose) {
-                        ubi_warn("bad magic number at PEB %d: %08x instead of %08x",
+                        ubi_warn(ubi, "bad magic number at PEB %d: %08x instead of %08x",
                                  pnum, magic, UBI_EC_HDR_MAGIC);
                         ubi_dump_ec_hdr(ec_hdr);
                 }
@@ -794,7 +796,7 @@ int ubi_io_read_ec_hdr(struct ubi_device *ubi, int pnum,
 
         if (hdr_crc != crc) {
                 if (verbose) {
-                        ubi_warn("bad EC header CRC at PEB %d, calculated %#08x, read %#08x",
+                        ubi_warn(ubi, "bad EC header CRC at PEB %d, calculated %#08x, read %#08x",
                                  pnum, crc, hdr_crc);
                         ubi_dump_ec_hdr(ec_hdr);
                 }
@@ -810,7 +812,7 @@ int ubi_io_read_ec_hdr(struct ubi_device *ubi, int pnum,
         /* And of course validate what has just been read from the media */
         err = validate_ec_hdr(ubi, ec_hdr);
         if (err) {
-                ubi_err("validation failed for PEB %d", pnum);
+                ubi_err(ubi, "validation failed for PEB %d", pnum);
                 return -EINVAL;
         }
 
@@ -884,40 +886,40 @@ static int validate_vid_hdr(const struct ubi_device *ubi,
         int usable_leb_size = ubi->leb_size - data_pad;
 
         if (copy_flag != 0 && copy_flag != 1) {
-                ubi_err("bad copy_flag");
+                ubi_err(ubi, "bad copy_flag");
                 goto bad;
         }
 
         if (vol_id < 0 || lnum < 0 || data_size < 0 || used_ebs < 0 ||
             data_pad < 0) {
-                ubi_err("negative values");
+                ubi_err(ubi, "negative values");
                 goto bad;
         }
 
         if (vol_id >= UBI_MAX_VOLUMES && vol_id < UBI_INTERNAL_VOL_START) {
-                ubi_err("bad vol_id");
+                ubi_err(ubi, "bad vol_id");
                 goto bad;
         }
 
         if (vol_id < UBI_INTERNAL_VOL_START && compat != 0) {
-                ubi_err("bad compat");
+                ubi_err(ubi, "bad compat");
                 goto bad;
         }
 
         if (vol_id >= UBI_INTERNAL_VOL_START && compat != UBI_COMPAT_DELETE &&
             compat != UBI_COMPAT_RO && compat != UBI_COMPAT_PRESERVE &&
             compat != UBI_COMPAT_REJECT) {
-                ubi_err("bad compat");
+                ubi_err(ubi, "bad compat");
                 goto bad;
         }
 
         if (vol_type != UBI_VID_DYNAMIC && vol_type != UBI_VID_STATIC) {
-                ubi_err("bad vol_type");
+                ubi_err(ubi, "bad vol_type");
                 goto bad;
         }
 
         if (data_pad >= ubi->leb_size / 2) {
-                ubi_err("bad data_pad");
+                ubi_err(ubi, "bad data_pad");
                 goto bad;
         }
 
@@ -929,45 +931,45 @@ static int validate_vid_hdr(const struct ubi_device *ubi,
                  * mapped logical eraseblocks.
                  */
                 if (used_ebs == 0) {
-                        ubi_err("zero used_ebs");
+                        ubi_err(ubi, "zero used_ebs");
                         goto bad;
                 }
                 if (data_size == 0) {
-                        ubi_err("zero data_size");
+                        ubi_err(ubi, "zero data_size");
                         goto bad;
                 }
                 if (lnum < used_ebs - 1) {
                         if (data_size != usable_leb_size) {
-                                ubi_err("bad data_size");
+                                ubi_err(ubi, "bad data_size");
                                 goto bad;
                         }
                 } else if (lnum == used_ebs - 1) {
                         if (data_size == 0) {
-                                ubi_err("bad data_size at last LEB");
+                                ubi_err(ubi, "bad data_size at last LEB");
                                 goto bad;
                         }
                 } else {
-                        ubi_err("too high lnum");
+                        ubi_err(ubi, "too high lnum");
                         goto bad;
                 }
         } else {
                 if (copy_flag == 0) {
                         if (data_crc != 0) {
-                                ubi_err("non-zero data CRC");
+                                ubi_err(ubi, "non-zero data CRC");
                                 goto bad;
                         }
                         if (data_size != 0) {
-                                ubi_err("non-zero data_size");
+                                ubi_err(ubi, "non-zero data_size");
                                 goto bad;
                         }
                 } else {
                         if (data_size == 0) {
-                                ubi_err("zero data_size of copy");
+                                ubi_err(ubi, "zero data_size of copy");
                                 goto bad;
                         }
                 }
                 if (used_ebs != 0) {
-                        ubi_err("bad used_ebs");
+                        ubi_err(ubi, "bad used_ebs");
                         goto bad;
                 }
         }
@@ -975,7 +977,7 @@ static int validate_vid_hdr(const struct ubi_device *ubi,
         return 0;
 
 bad:
-        ubi_err("bad VID header");
+        ubi_err(ubi, "bad VID header");
         ubi_dump_vid_hdr(vid_hdr);
         dump_stack();
         return 1;
@@ -1020,7 +1022,7 @@ int ubi_io_read_vid_hdr(struct ubi_device *ubi, int pnum,
 
                 if (ubi_check_pattern(vid_hdr, 0xFF, UBI_VID_HDR_SIZE)) {
                         if (verbose)
-                                ubi_warn("no VID header found at PEB %d, only 0xFF bytes",
+                                ubi_warn(ubi, "no VID header found at PEB %d, only 0xFF bytes",
                                          pnum);
                         dbg_bld("no VID header found at PEB %d, only 0xFF bytes",
                                 pnum);
@@ -1031,7 +1033,7 @@ int ubi_io_read_vid_hdr(struct ubi_device *ubi, int pnum,
                 }
 
                 if (verbose) {
-                        ubi_warn("bad magic number at PEB %d: %08x instead of %08x",
+                        ubi_warn(ubi, "bad magic number at PEB %d: %08x instead of %08x",
                                  pnum, magic, UBI_VID_HDR_MAGIC);
                         ubi_dump_vid_hdr(vid_hdr);
                 }
@@ -1045,7 +1047,7 @@ int ubi_io_read_vid_hdr(struct ubi_device *ubi, int pnum,
 
         if (hdr_crc != crc) {
                 if (verbose) {
-                        ubi_warn("bad CRC at PEB %d, calculated %#08x, read %#08x",
+                        ubi_warn(ubi, "bad CRC at PEB %d, calculated %#08x, read %#08x",
                                  pnum, crc, hdr_crc);
                         ubi_dump_vid_hdr(vid_hdr);
                 }
@@ -1059,7 +1061,7 @@ int ubi_io_read_vid_hdr(struct ubi_device *ubi, int pnum,
 
         err = validate_vid_hdr(ubi, vid_hdr);
         if (err) {
-                ubi_err("validation failed for PEB %d", pnum);
+                ubi_err(ubi, "validation failed for PEB %d", pnum);
                 return -EINVAL;
         }
 
@@ -1129,7 +1131,7 @@ static int self_check_not_bad(const struct ubi_device *ubi, int pnum)
         if (!err)
                 return err;
 
-        ubi_err("self-check failed for PEB %d", pnum);
+        ubi_err(ubi, "self-check failed for PEB %d", pnum);
         dump_stack();
         return err > 0 ? -EINVAL : err;
 }
@@ -1154,14 +1156,14 @@ static int self_check_ec_hdr(const struct ubi_device *ubi, int pnum,
 
         magic = be32_to_cpu(ec_hdr->magic);
         if (magic != UBI_EC_HDR_MAGIC) {
-                ubi_err("bad magic %#08x, must be %#08x",
+                ubi_err(ubi, "bad magic %#08x, must be %#08x",
                         magic, UBI_EC_HDR_MAGIC);
                 goto fail;
         }
 
         err = validate_ec_hdr(ubi, ec_hdr);
         if (err) {
-                ubi_err("self-check failed for PEB %d", pnum);
+                ubi_err(ubi, "self-check failed for PEB %d", pnum);
                 goto fail;
         }
 
@@ -1201,8 +1203,9 @@ static int self_check_peb_ec_hdr(const struct ubi_device *ubi, int pnum)
         crc = crc32(UBI_CRC32_INIT, ec_hdr, UBI_EC_HDR_SIZE_CRC);
         hdr_crc = be32_to_cpu(ec_hdr->hdr_crc);
         if (hdr_crc != crc) {
-                ubi_err("bad CRC, calculated %#08x, read %#08x", crc, hdr_crc);
-                ubi_err("self-check failed for PEB %d", pnum);
+                ubi_err(ubi, "bad CRC, calculated %#08x, read %#08x",
+                        crc, hdr_crc);
+                ubi_err(ubi, "self-check failed for PEB %d", pnum);
                 ubi_dump_ec_hdr(ec_hdr);
                 dump_stack();
                 err = -EINVAL;
@@ -1236,21 +1239,21 @@ static int self_check_vid_hdr(const struct ubi_device *ubi, int pnum,
 
         magic = be32_to_cpu(vid_hdr->magic);
         if (magic != UBI_VID_HDR_MAGIC) {
-                ubi_err("bad VID header magic %#08x at PEB %d, must be %#08x",
+                ubi_err(ubi, "bad VID header magic %#08x at PEB %d, must be %#08x",
                         magic, pnum, UBI_VID_HDR_MAGIC);
                 goto fail;
         }
 
         err = validate_vid_hdr(ubi, vid_hdr);
         if (err) {
-                ubi_err("self-check failed for PEB %d", pnum);
+                ubi_err(ubi, "self-check failed for PEB %d", pnum);
                 goto fail;
         }
 
         return err;
 
 fail:
-        ubi_err("self-check failed for PEB %d", pnum);
+        ubi_err(ubi, "self-check failed for PEB %d", pnum);
         ubi_dump_vid_hdr(vid_hdr);
         dump_stack();
         return -EINVAL;
@@ -1288,9 +1291,9 @@ static int self_check_peb_vid_hdr(const struct ubi_device *ubi, int pnum)
         crc = crc32(UBI_CRC32_INIT, vid_hdr, UBI_EC_HDR_SIZE_CRC);
         hdr_crc = be32_to_cpu(vid_hdr->hdr_crc);
         if (hdr_crc != crc) {
-                ubi_err("bad VID header CRC at PEB %d, calculated %#08x, read %#08x",
+                ubi_err(ubi, "bad VID header CRC at PEB %d, calculated %#08x, read %#08x",
                         pnum, crc, hdr_crc);
-                ubi_err("self-check failed for PEB %d", pnum);
+                ubi_err(ubi, "self-check failed for PEB %d", pnum);
                 ubi_dump_vid_hdr(vid_hdr);
                 dump_stack();
                 err = -EINVAL;
@@ -1329,7 +1332,7 @@ static int self_check_write(struct ubi_device *ubi, const void *buf, int pnum,
 
         buf1 = __vmalloc(len, GFP_NOFS, PAGE_KERNEL);
         if (!buf1) {
-                ubi_err("cannot allocate memory to check writes");
+                ubi_err(ubi, "cannot allocate memory to check writes");
                 return 0;
         }
 
@@ -1345,15 +1348,15 @@ static int self_check_write(struct ubi_device *ubi, const void *buf, int pnum,
                 if (c == c1)
                         continue;
 
-                ubi_err("self-check failed for PEB %d:%d, len %d",
+                ubi_err(ubi, "self-check failed for PEB %d:%d, len %d",
                         pnum, offset, len);
-                ubi_msg("data differ at position %d", i);
+                ubi_msg(ubi, "data differ at position %d", i);
                 dump_len = max_t(int, 128, len - i);
-                ubi_msg("hex dump of the original buffer from %d to %d",
+                ubi_msg(ubi, "hex dump of the original buffer from %d to %d",
                         i, i + dump_len);
                 print_hex_dump(KERN_DEBUG, "", DUMP_PREFIX_OFFSET, 32, 1,
                                buf + i, dump_len, 1);
-                ubi_msg("hex dump of the read buffer from %d to %d",
+                ubi_msg(ubi, "hex dump of the read buffer from %d to %d",
                         i, i + dump_len);
                 print_hex_dump(KERN_DEBUG, "", DUMP_PREFIX_OFFSET, 32, 1,
                                buf1 + i, dump_len, 1);
@@ -1393,20 +1396,20 @@ int ubi_self_check_all_ff(struct ubi_device *ubi, int pnum, int offset, int len)
 
         buf = __vmalloc(len, GFP_NOFS, PAGE_KERNEL);
         if (!buf) {
-                ubi_err("cannot allocate memory to check for 0xFFs");
+                ubi_err(ubi, "cannot allocate memory to check for 0xFFs");
                 return 0;
         }
 
         err = mtd_read(ubi->mtd, addr, len, &read, buf);
         if (err && !mtd_is_bitflip(err)) {
-                ubi_err("error %d while reading %d bytes from PEB %d:%d, read %zd bytes",
+                ubi_err(ubi, "err %d while reading %d bytes from PEB %d:%d, read %zd bytes",
                         err, len, pnum, offset, read);
                 goto error;
         }
 
         err = ubi_check_pattern(buf, 0xFF, len);
         if (err == 0) {
-                ubi_err("flash region at PEB %d:%d, length %d does not contain all 0xFF bytes",
+                ubi_err(ubi, "flash region at PEB %d:%d, length %d does not contain all 0xFF bytes",
                         pnum, offset, len);
                 goto fail;
         }
@@ -1415,8 +1418,9 @@ int ubi_self_check_all_ff(struct ubi_device *ubi, int pnum, int offset, int len)
         return 0;
 
 fail:
-        ubi_err("self-check failed for PEB %d", pnum);
-        ubi_msg("hex dump of the %d-%d region", offset, offset + len);
+        ubi_err(ubi, "self-check failed for PEB %d", pnum);
+        ubi_msg(ubi, "hex dump of the %d-%d region",
+                 offset, offset + len);
         print_hex_dump(KERN_DEBUG, "", DUMP_PREFIX_OFFSET, 32, 1, buf, len, 1);
         err = -EINVAL;
 error: