Merge branch 'mpi-master' into wip-k-fmlpwip-k-fmlp

Conflicts:
	litmus/sched_cedf.c

1 files changed, 185 insertions, 141 deletions

diff --git a/drivers/mtd/ubi/io.c b/drivers/mtd/ubi/io.c
index 332f992f13d9..8c1b1c7bc4a7 100644
--- a/drivers/mtd/ubi/io.c
+++ b/drivers/mtd/ubi/io.c
@@ -91,7 +91,7 @@
 #include <linux/slab.h>
 #include "ubi.h"
 
-#ifdef CONFIG_MTD_UBI_DEBUG_PARANOID
+#ifdef CONFIG_MTD_UBI_DEBUG
 static int paranoid_check_not_bad(const struct ubi_device *ubi, int pnum);
 static int paranoid_check_peb_ec_hdr(const struct ubi_device *ubi, int pnum);
 static int paranoid_check_ec_hdr(const struct ubi_device *ubi, int pnum,
@@ -146,6 +146,28 @@ int ubi_io_read(const struct ubi_device *ubi, void *buf, int pnum, int offset,
         if (err)
                 return err;
 
+        /*
+         * Deliberately corrupt the buffer to improve robustness. Indeed, if we
+         * do not do this, the following may happen:
+         * 1. The buffer contains data from previous operation, e.g., read from
+         *    another PEB previously. The data looks like expected, e.g., if we
+         *    just do not read anything and return - the caller would not
+         *    notice this. E.g., if we are reading a VID header, the buffer may
+         *    contain a valid VID header from another PEB.
+         * 2. The driver is buggy and returns us success or -EBADMSG or
+         *    -EUCLEAN, but it does not actually put any data to the buffer.
+         *
+         * This may confuse UBI or upper layers - they may think the buffer
+         * contains valid data while in fact it is just old data. This is
+         * especially possible because UBI (and UBIFS) relies on CRC, and
+         * treats data as correct even in case of ECC errors if the CRC is
+         * correct.
+         *
+         * Try to prevent this situation by changing the first byte of the
+         * buffer.
+         */
+        *((uint8_t *)buf) ^= 0xFF;
+
         addr = (loff_t)pnum * ubi->peb_size + offset;
 retry:
         err = ubi->mtd->read(ubi->mtd, addr, len, &read, buf);
@@ -166,9 +188,9 @@ retry:
                         return UBI_IO_BITFLIPS;
                 }
 
-                if (read != len && retries++ < UBI_IO_RETRIES) {
-                        dbg_io("error %d%s while reading %d bytes from PEB %d:%d,"
-                               " read only %zd bytes, retry",
+                if (retries++ < UBI_IO_RETRIES) {
+                        dbg_io("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;
@@ -322,6 +344,12 @@ static int do_sync_erase(struct ubi_device *ubi, int pnum)
         wait_queue_head_t wq;
 
         dbg_io("erase PEB %d", pnum);
+        ubi_assert(pnum >= 0 && pnum < ubi->peb_count);
+
+        if (ubi->ro_mode) {
+                ubi_err("read-only mode");
+                return -EROFS;
+        }
 
 retry:
         init_waitqueue_head(&wq);
@@ -368,7 +396,7 @@ retry:
         if (err)
                 return err;
 
-        if (ubi_dbg_is_erase_failure() && !err) {
+        if (ubi_dbg_is_erase_failure()) {
                 dbg_err("cannot erase PEB %d (emulated)", pnum);
                 return -EIO;
         }
@@ -376,25 +404,6 @@ retry:
         return 0;
 }
 
-/**
- * check_pattern - check if buffer contains only a certain byte pattern.
- * @buf: buffer to check
- * @patt: the pattern to check
- * @size: buffer size in bytes
- *
- * This function returns %1 in there are only @patt bytes in @buf, and %0 if
- * something else was also found.
- */
-static int check_pattern(const void *buf, uint8_t patt, int size)
-{
-        int i;
-
-        for (i = 0; i < size; i++)
-                if (((const uint8_t *)buf)[i] != patt)
-                        return 0;
-        return 1;
-}
-
 /* Patterns to write to a physical eraseblock when torturing it */
 static uint8_t patterns[] = {0xa5, 0x5a, 0x0};
 
@@ -426,7 +435,7 @@ static int torture_peb(struct ubi_device *ubi, int pnum)
                 if (err)
                         goto out;
 
-                err = check_pattern(ubi->peb_buf1, 0xFF, ubi->peb_size);
+                err = ubi_check_pattern(ubi->peb_buf1, 0xFF, ubi->peb_size);
                 if (err == 0) {
                         ubi_err("erased PEB %d, but a non-0xFF byte found",
                                 pnum);
@@ -445,7 +454,8 @@ static int torture_peb(struct ubi_device *ubi, int pnum)
                 if (err)
                         goto out;
 
-                err = check_pattern(ubi->peb_buf1, patterns[i], ubi->peb_size);
+                err = ubi_check_pattern(ubi->peb_buf1, patterns[i],
+                                        ubi->peb_size);
                 if (err == 0) {
                         ubi_err("pattern %x checking failed for PEB %d",
                                 patterns[i], pnum);
@@ -455,7 +465,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 a bad", pnum);
+        ubi_msg("PEB %d passed torture test, do not mark it as bad", pnum);
 
 out:
         mutex_unlock(&ubi->buf_mutex);
@@ -498,12 +508,26 @@ static int nor_erase_prepare(struct ubi_device *ubi, int pnum)
         size_t written;
         loff_t addr;
         uint32_t data = 0;
+        /*
+         * Note, we cannot generally define VID header buffers on stack,
+         * because of the way we deal with these buffers (see the header
+         * comment in this file). But we know this is a NOR-specific piece of
+         * code, so we can do this. But yes, this is error-prone and we should
+         * (pre-)allocate VID header buffer instead.
+         */
         struct ubi_vid_hdr vid_hdr;
 
-        addr = (loff_t)pnum * ubi->peb_size + ubi->vid_hdr_aloffset;
+        /*
+         * It is important to first invalidate the EC header, and then the VID
+         * header. Otherwise a power cut may lead to valid EC header and
+         * invalid VID header, in which case UBI will treat this PEB as
+         * corrupted and will try to preserve it, and print scary warnings (see
+         * the header comment in scan.c for more information).
+         */
+        addr = (loff_t)pnum * ubi->peb_size;
         err = ubi->mtd->write(ubi->mtd, addr, 4, &written, (void *)&data);
         if (!err) {
-                addr -= ubi->vid_hdr_aloffset;
+                addr += ubi->vid_hdr_aloffset;
                 err = ubi->mtd->write(ubi->mtd, addr, 4, &written,
                                       (void *)&data);
                 if (!err)
@@ -512,18 +536,26 @@ static int nor_erase_prepare(struct ubi_device *ubi, int pnum)
 
         /*
          * We failed to write to the media. This was observed with Spansion
-         * S29GL512N NOR flash. Most probably the eraseblock erasure was
-         * interrupted at a very inappropriate moment, so it became unwritable.
-         * In this case we probably anyway have garbage in this PEB.
+         * S29GL512N NOR flash. Most probably the previously eraseblock erasure
+         * was interrupted at a very inappropriate moment, so it became
+         * unwritable. In this case we probably anyway have garbage in this
+         * PEB.
          */
         err1 = ubi_io_read_vid_hdr(ubi, pnum, &vid_hdr, 0);
-        if (err1 == UBI_IO_BAD_HDR_READ || err1 == UBI_IO_BAD_HDR)
-                /*
-                 * The VID header is corrupted, so we can safely erase this
-                 * PEB and not afraid that it will be treated as a valid PEB in
-                 * case of an unclean reboot.
-                 */
-                return 0;
+        if (err1 == UBI_IO_BAD_HDR_EBADMSG || err1 == UBI_IO_BAD_HDR ||
+            err1 == UBI_IO_FF) {
+                struct ubi_ec_hdr ec_hdr;
+
+                err1 = ubi_io_read_ec_hdr(ubi, pnum, &ec_hdr, 0);
+                if (err1 == UBI_IO_BAD_HDR_EBADMSG || err1 == UBI_IO_BAD_HDR ||
+                    err1 == UBI_IO_FF)
+                        /*
+                         * Both VID and EC headers are corrupted, so we can
+                         * safely erase this PEB and not afraid that it will be
+                         * treated as a valid PEB in case of an unclean reboot.
+                         */
+                        return 0;
+        }
 
         /*
          * The PEB contains a valid VID header, but we cannot invalidate it.
@@ -712,55 +744,57 @@ bad:
  *   and corrected by the flash driver; this is harmless but may indicate that
  *   this eraseblock may become bad soon (but may be not);
  * o %UBI_IO_BAD_HDR if the erase counter header is corrupted (a CRC error);
- * o %UBI_IO_PEB_EMPTY if the physical eraseblock is empty;
+ * o %UBI_IO_BAD_HDR_EBADMSG is the same as %UBI_IO_BAD_HDR, but there also was
+ *   a data integrity error (uncorrectable ECC error in case of NAND);
+ * o %UBI_IO_FF if only 0xFF bytes were read (the PEB is supposedly empty)
  * o a negative error code in case of failure.
  */
 int ubi_io_read_ec_hdr(struct ubi_device *ubi, int pnum,
                        struct ubi_ec_hdr *ec_hdr, int verbose)
 {
-        int err, read_err = 0;
+        int err, read_err;
         uint32_t crc, magic, hdr_crc;
 
         dbg_io("read EC header from PEB %d", pnum);
         ubi_assert(pnum >= 0 && pnum < ubi->peb_count);
 
-        err = ubi_io_read(ubi, ec_hdr, pnum, 0, UBI_EC_HDR_SIZE);
-        if (err) {
-                if (err != UBI_IO_BITFLIPS && err != -EBADMSG)
-                        return err;
+        read_err = ubi_io_read(ubi, ec_hdr, pnum, 0, UBI_EC_HDR_SIZE);
+        if (read_err) {
+                if (read_err != UBI_IO_BITFLIPS && read_err != -EBADMSG)
+                        return read_err;
 
                 /*
                  * We read all the data, but either a correctable bit-flip
-                 * occurred, or MTD reported about some data integrity error,
-                 * like an ECC error in case of NAND. The former is harmless,
-                 * the later may mean that the read data is corrupted. But we
-                 * have a CRC check-sum and we will detect this. If the EC
-                 * header is still OK, we just report this as there was a
-                 * bit-flip.
+                 * occurred, or MTD reported a data integrity error
+                 * (uncorrectable ECC error in case of NAND). The former is
+                 * harmless, the later may mean that the read data is
+                 * corrupted. But we have a CRC check-sum and we will detect
+                 * this. If the EC header is still OK, we just report this as
+                 * there was a bit-flip, to force scrubbing.
                  */
-                if (err == -EBADMSG)
-                        read_err = UBI_IO_BAD_HDR_READ;
         }
 
         magic = be32_to_cpu(ec_hdr->magic);
         if (magic != UBI_EC_HDR_MAGIC) {
-                if (read_err)
-                        return read_err;
+                if (read_err == -EBADMSG)
+                        return UBI_IO_BAD_HDR_EBADMSG;
 
                 /*
                  * The magic field is wrong. Let's check if we have read all
                  * 0xFF. If yes, this physical eraseblock is assumed to be
                  * empty.
                  */
-                if (check_pattern(ec_hdr, 0xFF, UBI_EC_HDR_SIZE)) {
+                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", pnum);
-                        else if (UBI_IO_DEBUG)
-                                dbg_msg("no EC header found at PEB %d, "
-                                        "only 0xFF bytes", pnum);
-                        return UBI_IO_PEB_EMPTY;
+                        dbg_bld("no EC header found at PEB %d, "
+                                "only 0xFF bytes", pnum);
+                        if (!read_err)
+                                return UBI_IO_FF;
+                        else
+                                return UBI_IO_FF_BITFLIPS;
                 }
 
                 /*
@@ -771,9 +805,9 @@ int ubi_io_read_ec_hdr(struct ubi_device *ubi, int pnum,
                         ubi_warn("bad magic number at PEB %d: %08x instead of "
                                  "%08x", pnum, magic, UBI_EC_HDR_MAGIC);
                         ubi_dbg_dump_ec_hdr(ec_hdr);
-                } else if (UBI_IO_DEBUG)
-                        dbg_msg("bad magic number at PEB %d: %08x instead of "
-                                "%08x", pnum, magic, UBI_EC_HDR_MAGIC);
+                }
+                dbg_bld("bad magic number at PEB %d: %08x instead of "
+                        "%08x", pnum, magic, UBI_EC_HDR_MAGIC);
                 return UBI_IO_BAD_HDR;
         }
 
@@ -785,10 +819,14 @@ int ubi_io_read_ec_hdr(struct ubi_device *ubi, int pnum,
                         ubi_warn("bad EC header CRC at PEB %d, calculated "
                                  "%#08x, read %#08x", pnum, crc, hdr_crc);
                         ubi_dbg_dump_ec_hdr(ec_hdr);
-                } else if (UBI_IO_DEBUG)
-                        dbg_msg("bad EC header CRC at PEB %d, calculated "
-                                "%#08x, read %#08x", pnum, crc, hdr_crc);
-                return read_err ?: UBI_IO_BAD_HDR;
+                }
+                dbg_bld("bad EC header CRC at PEB %d, calculated "
+                        "%#08x, read %#08x", pnum, crc, hdr_crc);
+
+                if (!read_err)
+                        return UBI_IO_BAD_HDR;
+                else
+                        return UBI_IO_BAD_HDR_EBADMSG;
         }
 
         /* And of course validate what has just been read from the media */
@@ -975,22 +1013,16 @@ bad:
  *
  * This function reads the volume identifier header from physical eraseblock
  * @pnum and stores it in @vid_hdr. It also checks CRC checksum of the read
- * volume identifier header. The following codes may be returned:
+ * volume identifier header. The error codes are the same as in
+ * 'ubi_io_read_ec_hdr()'.
  *
- * o %0 if the CRC checksum is correct and the header was successfully read;
- * o %UBI_IO_BITFLIPS if the CRC is correct, but bit-flips were detected
- *   and corrected by the flash driver; this is harmless but may indicate that
- *   this eraseblock may become bad soon;
- * o %UBI_IO_BAD_HDR if the volume identifier header is corrupted (a CRC
- *   error detected);
- * o %UBI_IO_PEB_FREE if the physical eraseblock is free (i.e., there is no VID
- *   header there);
- * o a negative error code in case of failure.
+ * Note, the implementation of this function is also very similar to
+ * 'ubi_io_read_ec_hdr()', so refer commentaries in 'ubi_io_read_ec_hdr()'.
  */
 int ubi_io_read_vid_hdr(struct ubi_device *ubi, int pnum,
                         struct ubi_vid_hdr *vid_hdr, int verbose)
 {
-        int err, read_err = 0;
+        int err, read_err;
         uint32_t crc, magic, hdr_crc;
         void *p;
 
@@ -998,55 +1030,35 @@ int ubi_io_read_vid_hdr(struct ubi_device *ubi, int pnum,
         ubi_assert(pnum >= 0 &&  pnum < ubi->peb_count);
 
         p = (char *)vid_hdr - ubi->vid_hdr_shift;
-        err = ubi_io_read(ubi, p, pnum, ubi->vid_hdr_aloffset,
+        read_err = ubi_io_read(ubi, p, pnum, ubi->vid_hdr_aloffset,
                           ubi->vid_hdr_alsize);
-        if (err) {
-                if (err != UBI_IO_BITFLIPS && err != -EBADMSG)
-                        return err;
-
-                /*
-                 * We read all the data, but either a correctable bit-flip
-                 * occurred, or MTD reported about some data integrity error,
-                 * like an ECC error in case of NAND. The former is harmless,
-                 * the later may mean the read data is corrupted. But we have a
-                 * CRC check-sum and we will identify this. If the VID header is
-                 * still OK, we just report this as there was a bit-flip.
-                 */
-                if (err == -EBADMSG)
-                        read_err = UBI_IO_BAD_HDR_READ;
-        }
+        if (read_err && read_err != UBI_IO_BITFLIPS && read_err != -EBADMSG)
+                return read_err;
 
         magic = be32_to_cpu(vid_hdr->magic);
         if (magic != UBI_VID_HDR_MAGIC) {
-                if (read_err)
-                        return read_err;
+                if (read_err == -EBADMSG)
+                        return UBI_IO_BAD_HDR_EBADMSG;
 
-                /*
-                 * If we have read all 0xFF bytes, the VID header probably does
-                 * not exist and the physical eraseblock is assumed to be free.
-                 */
-                if (check_pattern(vid_hdr, 0xFF, UBI_VID_HDR_SIZE)) {
-                        /* The physical eraseblock is supposedly free */
+                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", pnum);
-                        else if (UBI_IO_DEBUG)
-                                dbg_msg("no VID header found at PEB %d, "
-                                        "only 0xFF bytes", pnum);
-                        return UBI_IO_PEB_FREE;
+                        dbg_bld("no VID header found at PEB %d, "
+                                "only 0xFF bytes", pnum);
+                        if (!read_err)
+                                return UBI_IO_FF;
+                        else
+                                return UBI_IO_FF_BITFLIPS;
                 }
 
-                /*
-                 * This is not a valid VID header, and these are not 0xFF
-                 * bytes. Report that the header is corrupted.
-                 */
                 if (verbose) {
                         ubi_warn("bad magic number at PEB %d: %08x instead of "
                                  "%08x", pnum, magic, UBI_VID_HDR_MAGIC);
                         ubi_dbg_dump_vid_hdr(vid_hdr);
-                } else if (UBI_IO_DEBUG)
-                        dbg_msg("bad magic number at PEB %d: %08x instead of "
-                                "%08x", pnum, magic, UBI_VID_HDR_MAGIC);
+                }
+                dbg_bld("bad magic number at PEB %d: %08x instead of "
+                        "%08x", pnum, magic, UBI_VID_HDR_MAGIC);
                 return UBI_IO_BAD_HDR;
         }
 
@@ -1058,23 +1070,21 @@ int ubi_io_read_vid_hdr(struct ubi_device *ubi, int pnum,
                         ubi_warn("bad CRC at PEB %d, calculated %#08x, "
                                  "read %#08x", pnum, crc, hdr_crc);
                         ubi_dbg_dump_vid_hdr(vid_hdr);
-                } else if (UBI_IO_DEBUG)
-                        dbg_msg("bad CRC at PEB %d, calculated %#08x, "
-                                "read %#08x", pnum, crc, hdr_crc);
-                return read_err ?: UBI_IO_BAD_HDR;
+                }
+                dbg_bld("bad CRC at PEB %d, calculated %#08x, "
+                        "read %#08x", pnum, crc, hdr_crc);
+                if (!read_err)
+                        return UBI_IO_BAD_HDR;
+                else
+                        return UBI_IO_BAD_HDR_EBADMSG;
         }
 
-        /* Validate the VID header that we have just read */
         err = validate_vid_hdr(ubi, vid_hdr);
         if (err) {
                 ubi_err("validation failed for PEB %d", pnum);
                 return -EINVAL;
         }
 
-        /*
-         * If there was a read error (%-EBADMSG), but the header CRC is still
-         * OK, report about a bit-flip to force scrubbing on this PEB.
-         */
         return read_err ? UBI_IO_BITFLIPS : 0;
 }
 
@@ -1122,7 +1132,7 @@ int ubi_io_write_vid_hdr(struct ubi_device *ubi, int pnum,
         return err;
 }
 
-#ifdef CONFIG_MTD_UBI_DEBUG_PARANOID
+#ifdef CONFIG_MTD_UBI_DEBUG
 
 /**
  * paranoid_check_not_bad - ensure that a physical eraseblock is not bad.
@@ -1136,6 +1146,9 @@ static int paranoid_check_not_bad(const struct ubi_device *ubi, int pnum)
 {
         int err;
 
+        if (!(ubi_chk_flags & UBI_CHK_IO))
+                return 0;
+
         err = ubi_io_is_bad(ubi, pnum);
         if (!err)
                 return err;
@@ -1160,6 +1173,9 @@ static int paranoid_check_ec_hdr(const struct ubi_device *ubi, int pnum,
         int err;
         uint32_t magic;
 
+        if (!(ubi_chk_flags & UBI_CHK_IO))
+                return 0;
+
         magic = be32_to_cpu(ec_hdr->magic);
         if (magic != UBI_EC_HDR_MAGIC) {
                 ubi_err("bad magic %#08x, must be %#08x",
@@ -1195,6 +1211,9 @@ static int paranoid_check_peb_ec_hdr(const struct ubi_device *ubi, int pnum)
         uint32_t crc, hdr_crc;
         struct ubi_ec_hdr *ec_hdr;
 
+        if (!(ubi_chk_flags & UBI_CHK_IO))
+                return 0;
+
         ec_hdr = kzalloc(ubi->ec_hdr_alsize, GFP_NOFS);
         if (!ec_hdr)
                 return -ENOMEM;
@@ -1236,6 +1255,9 @@ static int paranoid_check_vid_hdr(const struct ubi_device *ubi, int pnum,
         int err;
         uint32_t magic;
 
+        if (!(ubi_chk_flags & UBI_CHK_IO))
+                return 0;
+
         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",
@@ -1274,6 +1296,9 @@ static int paranoid_check_peb_vid_hdr(const struct ubi_device *ubi, int pnum)
         struct ubi_vid_hdr *vid_hdr;
         void *p;
 
+        if (!(ubi_chk_flags & UBI_CHK_IO))
+                return 0;
+
         vid_hdr = ubi_zalloc_vid_hdr(ubi, GFP_NOFS);
         if (!vid_hdr)
                 return -ENOMEM;
@@ -1319,15 +1344,26 @@ int ubi_dbg_check_write(struct ubi_device *ubi, const void *buf, int pnum,
                         int offset, int len)
 {
         int err, i;
+        size_t read;
+        void *buf1;
+        loff_t addr = (loff_t)pnum * ubi->peb_size + offset;
 
-        mutex_lock(&ubi->dbg_buf_mutex);
-        err = ubi_io_read(ubi, ubi->dbg_peb_buf, pnum, offset, len);
-        if (err)
-                goto out_unlock;
+        if (!(ubi_chk_flags & UBI_CHK_IO))
+                return 0;
+
+        buf1 = __vmalloc(len, GFP_NOFS, PAGE_KERNEL);
+        if (!buf1) {
+                ubi_err("cannot allocate memory to check writes");
+                return 0;
+        }
+
+        err = ubi->mtd->read(ubi->mtd, addr, len, &read, buf1);
+        if (err && err != -EUCLEAN)
+                goto out_free;
 
         for (i = 0; i < len; i++) {
                 uint8_t c = ((uint8_t *)buf)[i];
-                uint8_t c1 = ((uint8_t *)ubi->dbg_peb_buf)[i];
+                uint8_t c1 = ((uint8_t *)buf1)[i];
                 int dump_len;
 
                 if (c == c1)
@@ -1344,17 +1380,17 @@ int ubi_dbg_check_write(struct ubi_device *ubi, const void *buf, int pnum,
                 ubi_msg("hex dump of the read buffer from %d to %d",
                         i, i + dump_len);
                 print_hex_dump(KERN_DEBUG, "", DUMP_PREFIX_OFFSET, 32, 1,
-                               ubi->dbg_peb_buf + i, dump_len, 1);
+                               buf1 + i, dump_len, 1);
                 ubi_dbg_dump_stack();
                 err = -EINVAL;
-                goto out_unlock;
+                goto out_free;
         }
-        mutex_unlock(&ubi->dbg_buf_mutex);
 
+        vfree(buf1);
         return 0;
 
-out_unlock:
-        mutex_unlock(&ubi->dbg_buf_mutex);
+out_free:
+        vfree(buf1);
         return err;
 }
 
@@ -1373,36 +1409,44 @@ int ubi_dbg_check_all_ff(struct ubi_device *ubi, int pnum, int offset, int len)
 {
         size_t read;
         int err;
+        void *buf;
         loff_t addr = (loff_t)pnum * ubi->peb_size + offset;
 
-        mutex_lock(&ubi->dbg_buf_mutex);
-        err = ubi->mtd->read(ubi->mtd, addr, len, &read, ubi->dbg_peb_buf);
+        if (!(ubi_chk_flags & UBI_CHK_IO))
+                return 0;
+
+        buf = __vmalloc(len, GFP_NOFS, PAGE_KERNEL);
+        if (!buf) {
+                ubi_err("cannot allocate memory to check for 0xFFs");
+                return 0;
+        }
+
+        err = ubi->mtd->read(ubi->mtd, addr, len, &read, buf);
         if (err && err != -EUCLEAN) {
                 ubi_err("error %d while reading %d bytes from PEB %d:%d, "
                         "read %zd bytes", err, len, pnum, offset, read);
                 goto error;
         }
 
-        err = check_pattern(ubi->dbg_peb_buf, 0xFF, len);
+        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", pnum, offset, len);
                 goto fail;
         }
-        mutex_unlock(&ubi->dbg_buf_mutex);
 
+        vfree(buf);
         return 0;
 
 fail:
         ubi_err("paranoid check failed for PEB %d", pnum);
         ubi_msg("hex dump of the %d-%d region", offset, offset + len);
-        print_hex_dump(KERN_DEBUG, "", DUMP_PREFIX_OFFSET, 32, 1,
-                       ubi->dbg_peb_buf, len, 1);
+        print_hex_dump(KERN_DEBUG, "", DUMP_PREFIX_OFFSET, 32, 1, buf, len, 1);
         err = -EINVAL;
 error:
         ubi_dbg_dump_stack();
-        mutex_unlock(&ubi->dbg_buf_mutex);
+        vfree(buf);
         return err;
 }
 
-#endif /* CONFIG_MTD_UBI_DEBUG_PARANOID */
+#endif /* CONFIG_MTD_UBI_DEBUG */