UBI: remove bogus debugging checks

The 'paranoid_check_empty()' is bogus because, which is easilly
seen on NOR flash, which has long erase cycles, and which may
easilly end-up with half-erased eraseblocks. In this case the
paranoid check fails. I is just wrong to assume that PEBs which
do not have EC headers always contain all 0xFF. Such assumption
should not be made on the I/O level, which is quite low.

Thus, just kill the check.

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

diff --git a/drivers/mtd/ubi/debug.h b/drivers/mtd/ubi/debug.h
index 6fc7fda2ab91794ae19bc1332c7637da6092b492..a4da7a09b949b75f5e259837da31190b31874bbc 100644 (file)
--- a/drivers/mtd/ubi/debug.h
+++ b/drivers/mtd/ubi/debug.h
@@ -173,6 +173,7 @@ static inline int ubi_dbg_is_erase_failure(void)
 #define ubi_dbg_is_bitflip()       0
 #define ubi_dbg_is_write_failure() 0
 #define ubi_dbg_is_erase_failure() 0
+#define ubi_dbg_check_all_ff(ubi, pnum, offset, len) 0
 
 #endif /* !CONFIG_MTD_UBI_DEBUG */
 #endif /* !__UBI_DEBUG_H__ */

diff --git a/drivers/mtd/ubi/io.c b/drivers/mtd/ubi/io.c
index 6c5441e8791da4bfa101f3420f67be335287f6c2..c8edbfd09b64b96ee5784669fd2f75b5fdbccc92 100644 (file)
--- a/drivers/mtd/ubi/io.c
+++ b/drivers/mtd/ubi/io.c
@@ -98,14 +98,12 @@ static int paranoid_check_ec_hdr(const struct ubi_device *ubi, int pnum,
 static int paranoid_check_peb_vid_hdr(const struct ubi_device *ubi, int pnum);
 static int paranoid_check_vid_hdr(const struct ubi_device *ubi, int pnum,
                                  const struct ubi_vid_hdr *vid_hdr);
-static int paranoid_check_empty(struct ubi_device *ubi, int pnum);
 #else
 #define paranoid_check_not_bad(ubi, pnum) 0
 #define paranoid_check_peb_ec_hdr(ubi, pnum)  0
 #define paranoid_check_ec_hdr(ubi, pnum, ec_hdr)  0
 #define paranoid_check_peb_vid_hdr(ubi, pnum) 0
 #define paranoid_check_vid_hdr(ubi, pnum, vid_hdr) 0
-#define paranoid_check_empty(ubi, pnum) 0
 #endif
 
 /**
@@ -669,10 +667,6 @@ int ubi_io_read_ec_hdr(struct ubi_device *ubi, int pnum,
                if (read_err != -EBADMSG &&
                    check_pattern(ec_hdr, 0xFF, UBI_EC_HDR_SIZE)) {
                        /* The physical eraseblock is supposedly empty */
-                       err = ubi_dbg_check_all_ff(ubi, pnum, 0, ubi->peb_size);
-                       if (err)
-                               return err > 0 ? UBI_IO_BAD_EC_HDR : err;
-
                        if (verbose)
                                ubi_warn("no EC header found at PEB %d, "
                                         "only 0xFF bytes", pnum);
@@ -943,15 +937,6 @@ int ubi_io_read_vid_hdr(struct ubi_device *ubi, int pnum,
                if (read_err != -EBADMSG &&
                    check_pattern(vid_hdr, 0xFF, UBI_VID_HDR_SIZE)) {
                        /* The physical eraseblock is supposedly free */
-
-                       /*
-                        * The below is just a paranoid check, it has to be
-                        * compiled out if paranoid checks are disabled.
-                        */
-                       err = paranoid_check_empty(ubi, pnum);
-                       if (err)
-                               return err > 0 ? UBI_IO_BAD_VID_HDR : err;
-
                        if (verbose)
                                ubi_warn("no VID header found at PEB %d, "
                                         "only 0xFF bytes", pnum);
@@ -1241,8 +1226,6 @@ int ubi_dbg_check_all_ff(struct ubi_device *ubi, int pnum, int offset, int len)
        int err;
        loff_t addr = (loff_t)pnum * ubi->peb_size + offset;
 
-       ubi_assert(!mutex_is_locked(&ubi->dbg_buf_mutex));
-
        mutex_lock(&ubi->dbg_buf_mutex);
        err = ubi->mtd->read(ubi->mtd, addr, len, &read, ubi->dbg_peb_buf);
        if (err && err != -EUCLEAN) {
@@ -1273,74 +1256,4 @@ error:
        return err;
 }
 
-/**
- * paranoid_check_empty - whether a PEB is empty.
- * @ubi: UBI device description object
- * @pnum: the physical eraseblock number to check
- *
- * This function makes sure PEB @pnum is empty, which means it contains only
- * %0xFF data bytes. Returns zero if the PEB is empty, %1 if not, and a
- * negative error code in case of failure.
- *
- * Empty PEBs have the EC header, and do not have the VID header. The caller of
- * this function should have already made sure the PEB does not have the VID
- * header. However, this function re-checks that, because it is possible that
- * the header and data has already been written to the PEB.
- *
- * Let's consider a possible scenario. Suppose there are 2 tasks - A and B.
- * Task A is in 'wear_leveling_worker()'. It is reading VID header of PEB X to
- * find which LEB it corresponds to. PEB X is currently unmapped, and has no
- * VID header. Task B is trying to write to PEB X.
- *
- * Task A: in 'ubi_io_read_vid_hdr()': reads the VID header from PEB X. The
- *         read data contain all 0xFF bytes;
- * Task B: writes VID header and some data to PEB X;
- * Task A: assumes PEB X is empty, calls 'paranoid_check_empty()'. And if we
- *         do not re-read the VID header, and do not cancel the checking if it
- *         is there, we fail.
- */
-static int paranoid_check_empty(struct ubi_device *ubi, int pnum)
-{
-       int err, offs = ubi->vid_hdr_aloffset, len = ubi->vid_hdr_alsize;
-       size_t read;
-       uint32_t magic;
-       const struct ubi_vid_hdr *vid_hdr;
-
-       mutex_lock(&ubi->dbg_buf_mutex);
-       err = ubi->mtd->read(ubi->mtd, offs, len, &read, ubi->dbg_peb_buf);
-       if (err && err != -EUCLEAN) {
-               ubi_err("error %d while reading %d bytes from PEB %d:%d, "
-                       "read %zd bytes", err, len, pnum, offs, read);
-               goto error;
-       }
-
-       vid_hdr = ubi->dbg_peb_buf;
-       magic = be32_to_cpu(vid_hdr->magic);
-       if (magic == UBI_VID_HDR_MAGIC)
-               /* The PEB contains VID header, so it is not empty */
-               goto out;
-
-       err = check_pattern(ubi->dbg_peb_buf, 0xFF, len);
-       if (err == 0) {
-               ubi_err("flash region at PEB %d:%d, length %d does not "
-                       "contain all 0xFF bytes", pnum, offs, len);
-               goto fail;
-       }
-
-out:
-       mutex_unlock(&ubi->dbg_buf_mutex);
-       return 0;
-
-fail:
-       ubi_err("paranoid check failed for PEB %d", pnum);
-       ubi_msg("hex dump of the %d-%d region", offs, offs + len);
-       print_hex_dump(KERN_DEBUG, "", DUMP_PREFIX_OFFSET, 32, 1,
-                      ubi->dbg_peb_buf, len, 1);
-       err = 1;
-error:
-       ubi_dbg_dump_stack();
-       mutex_unlock(&ubi->dbg_buf_mutex);
-       return err;
-}
-
 #endif /* CONFIG_MTD_UBI_DEBUG_PARANOID */

diff --git a/drivers/mtd/ubi/wl.c b/drivers/mtd/ubi/wl.c
index e4be446e05ed61d29dfb6cdf04e0fd0174c40765..600c7229d5cf21b0d959ca2d7c1a86ccc676e4af 100644 (file)
--- a/drivers/mtd/ubi/wl.c
+++ b/drivers/mtd/ubi/wl.c
@@ -463,7 +463,7 @@ retry:
        err = ubi_dbg_check_all_ff(ubi, e->pnum, ubi->vid_hdr_aloffset,
                                   ubi->peb_size - ubi->vid_hdr_aloffset);
        if (err) {
-               dbg_err("new PEB does not contain all 0xFF bytes");
+               ubi_err("new PEB %d does not contain all 0xFF bytes", e->pnum);
                return err > 0 ? -EINVAL : err;
        }