6 files changed, 198 insertions, 74 deletions

diff --git a/drivers/mtd/ubi/build.c b/drivers/mtd/ubi/build.c
index 13b05cb33b08..78ae89488a4f 100644
--- a/drivers/mtd/ubi/build.c
+++ b/drivers/mtd/ubi/build.c
@@ -593,6 +593,7 @@ static int attach_by_scanning(struct ubi_device *ubi)
         ubi->good_peb_count = ubi->peb_count - ubi->bad_peb_count;
         ubi->max_ec = si->max_ec;
         ubi->mean_ec = si->mean_ec;
+        ubi_msg("max. sequence number:       %llu", si->max_sqnum);
 
         err = ubi_read_volume_table(ubi, si);
         if (err)
@@ -981,7 +982,7 @@ int ubi_attach_mtd_dev(struct mtd_info *mtd, int ubi_num, int vid_hdr_offset)
         ubi_msg("number of PEBs reserved for bad PEB handling: %d",
                 ubi->beb_rsvd_pebs);
         ubi_msg("max/mean erase counter: %d/%d", ubi->max_ec, ubi->mean_ec);
-        ubi_msg("image sequence number: %d", ubi->image_seq);
+        ubi_msg("image sequence number:  %d", ubi->image_seq);
 
         /*
          * The below lock makes sure we do not race with 'ubi_thread()' which
diff --git a/drivers/mtd/ubi/eba.c b/drivers/mtd/ubi/eba.c
index 9f87c99189a9..fe74749e0dae 100644
--- a/drivers/mtd/ubi/eba.c
+++ b/drivers/mtd/ubi/eba.c
@@ -418,7 +418,8 @@ retry:
                                  * may try to recover data. FIXME: but this is
                                  * not implemented.
                                  */
-                                if (err == UBI_IO_BAD_VID_HDR) {
+                                if (err == UBI_IO_BAD_HDR_READ ||
+                                    err == UBI_IO_BAD_HDR) {
                                         ubi_warn("corrupted VID header at PEB "
                                                  "%d, LEB %d:%d", pnum, vol_id,
                                                  lnum);
@@ -961,8 +962,8 @@ write_error:
  */
 static int is_error_sane(int err)
 {
-        if (err == -EIO || err == -ENOMEM || err == UBI_IO_BAD_VID_HDR ||
-            err == -ETIMEDOUT)
+        if (err == -EIO || err == -ENOMEM || err == UBI_IO_BAD_HDR ||
+            err == UBI_IO_BAD_HDR_READ || err == -ETIMEDOUT)
                 return 0;
         return 1;
 }
@@ -1165,6 +1166,44 @@ out_unlock_leb:
 }
 
 /**
+ * print_rsvd_warning - warn about not having enough reserved PEBs.
+ * @ubi: UBI device description object
+ *
+ * This is a helper function for 'ubi_eba_init_scan()' which is called when UBI
+ * cannot reserve enough PEBs for bad block handling. This function makes a
+ * decision whether we have to print a warning or not. The algorithm is as
+ * follows:
+ *   o if this is a new UBI image, then just print the warning
+ *   o if this is an UBI image which has already been used for some time, print
+ *     a warning only if we can reserve less than 10% of the expected amount of
+ *     the reserved PEB.
+ *
+ * The idea is that when UBI is used, PEBs become bad, and the reserved pool
+ * of PEBs becomes smaller, which is normal and we do not want to scare users
+ * with a warning every time they attach the MTD device. This was an issue
+ * reported by real users.
+ */
+static void print_rsvd_warning(struct ubi_device *ubi,
+                               struct ubi_scan_info *si)
+{
+        /*
+         * The 1 << 18 (256KiB) number is picked randomly, just a reasonably
+         * large number to distinguish between newly flashed and used images.
+         */
+        if (si->max_sqnum > (1 << 18)) {
+                int min = ubi->beb_rsvd_level / 10;
+
+                if (!min)
+                        min = 1;
+                if (ubi->beb_rsvd_pebs > min)
+                        return;
+        }
+
+        ubi_warn("cannot reserve enough PEBs for bad PEB handling, reserved %d,"
+                 " need %d", ubi->beb_rsvd_pebs, ubi->beb_rsvd_level);
+}
+
+/**
  * ubi_eba_init_scan - initialize the EBA sub-system using scanning information.
  * @ubi: UBI device description object
  * @si: scanning information
@@ -1236,9 +1275,7 @@ int ubi_eba_init_scan(struct ubi_device *ubi, struct ubi_scan_info *si)
                 if (ubi->avail_pebs < ubi->beb_rsvd_level) {
                         /* No enough free physical eraseblocks */
                         ubi->beb_rsvd_pebs = ubi->avail_pebs;
-                        ubi_warn("cannot reserve enough PEBs for bad PEB "
-                                 "handling, reserved %d, need %d",
-                                 ubi->beb_rsvd_pebs, ubi->beb_rsvd_level);
+                        print_rsvd_warning(ubi, si);
                 } else
                         ubi->beb_rsvd_pebs = ubi->beb_rsvd_level;
 
diff --git a/drivers/mtd/ubi/io.c b/drivers/mtd/ubi/io.c
index 4b979e34b159..332f992f13d9 100644
--- a/drivers/mtd/ubi/io.c
+++ b/drivers/mtd/ubi/io.c
@@ -150,6 +150,8 @@ int ubi_io_read(const struct ubi_device *ubi, void *buf, int pnum, int offset,
 retry:
         err = ubi->mtd->read(ubi->mtd, addr, len, &read, buf);
         if (err) {
+                const char *errstr = (err == -EBADMSG) ? " (ECC error)" : "";
+
                 if (err == -EUCLEAN) {
                         /*
                          * -EUCLEAN is reported if there was a bit-flip which
@@ -165,15 +167,15 @@ retry:
                 }
 
                 if (read != len && retries++ < UBI_IO_RETRIES) {
-                        dbg_io("error %d while reading %d bytes from PEB %d:%d,"
+                        dbg_io("error %d%s while reading %d bytes from PEB %d:%d,"
                                " read only %zd bytes, retry",
-                               err, len, pnum, offset, read);
+                               err, errstr, len, pnum, offset, read);
                         yield();
                         goto retry;
                 }
 
-                ubi_err("error %d while reading %d bytes from PEB %d:%d, "
-                        "read %zd bytes", err, len, pnum, offset, read);
+                ubi_err("error %d%s while reading %d bytes from PEB %d:%d, "
+                        "read %zd bytes", err, errstr, len, pnum, offset, read);
                 ubi_dbg_dump_stack();
 
                 /*
@@ -515,7 +517,7 @@ static int nor_erase_prepare(struct ubi_device *ubi, int pnum)
          * 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_VID_HDR)
+        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
@@ -709,7 +711,7 @@ bad:
  * 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 (but may be not);
- * o %UBI_IO_BAD_EC_HDR if the erase counter header is corrupted (a CRC error);
+ * 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 a negative error code in case of failure.
  */
@@ -736,23 +738,21 @@ int ubi_io_read_ec_hdr(struct ubi_device *ubi, int pnum,
                  * header is still OK, we just report this as there was a
                  * bit-flip.
                  */
-                read_err = err;
+                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;
+
                 /*
                  * The magic field is wrong. Let's check if we have read all
                  * 0xFF. If yes, this physical eraseblock is assumed to be
                  * empty.
-                 *
-                 * But if there was a read error, we do not test it for all
-                 * 0xFFs. Even if it does contain all 0xFFs, this error
-                 * indicates that something is still wrong with this physical
-                 * eraseblock and we anyway cannot treat it as empty.
                  */
-                if (read_err != -EBADMSG &&
+                if (check_pattern(ec_hdr, 0xFF, UBI_EC_HDR_SIZE)) {