UBI: remove duplicate IO error codes

The 'UBI_IO_PEB_EMPTY' and 'UBI_IO_PEB_FREE' are essentially the same
and mean that there are only 0xFF bytes instead of headers. Simplify
UBI a little by turning them into a single 'UBI_IO_FF' error code.

Also, stop maintaining commentaries in 'ubi_io_read_vid_hdr()' which are
almost identical to commentaries in 'ubi_io_read_ec_hdr()'.

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

diff --git a/drivers/mtd/ubi/io.c b/drivers/mtd/ubi/io.c
index 05774da4abcae7ff843f11fb08a15112f9ebca09..1677a215af647f5ae0063e61cc5edb44eda168b0 100644 (file)
--- a/drivers/mtd/ubi/io.c
+++ b/drivers/mtd/ubi/io.c
@@ -714,7 +714,7 @@ bad:
  * o %UBI_IO_BAD_HDR if the erase counter header is corrupted (a CRC error);
  * 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_PEB_EMPTY if the physical eraseblock is empty;
+ * 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,
@@ -762,7 +762,7 @@ int ubi_io_read_ec_hdr(struct ubi_device *ubi, int pnum,
                        else if (UBI_IO_DEBUG)
                                dbg_msg("no EC header found at PEB %d, "
                                        "only 0xFF bytes", pnum);
-                       return UBI_IO_PEB_EMPTY;
+                       return UBI_IO_FF;
                }
 
                /*
@@ -977,19 +977,11 @@ 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_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_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)
@@ -1008,15 +1000,6 @@ int ubi_io_read_vid_hdr(struct ubi_device *ubi, int pnum,
                if (err != UBI_IO_BITFLIPS && err != -EBADMSG)
                        return err;
 
-               /*
-                * We read all the data, but either a correctable 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 VID 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_EBADMSG;
        }
@@ -1026,25 +1009,16 @@ int ubi_io_read_vid_hdr(struct ubi_device *ubi, int pnum,
                if (read_err)
                        return read_err;
 
-               /*
-                * 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 (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;
+                       return UBI_IO_FF;
                }
 
-               /*
-                * 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);
@@ -1069,17 +1043,12 @@ int ubi_io_read_vid_hdr(struct ubi_device *ubi, int pnum,
                return read_err ?: UBI_IO_BAD_HDR;
        }
 
-       /* 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;
 }
 

diff --git a/drivers/mtd/ubi/scan.c b/drivers/mtd/ubi/scan.c
index 7e7c56d162ecd79bd7fa7d54755c3497f2d9e07e..37cb18ff10c6e0971a83db677e0a34bf2adbe677 100644 (file)
--- a/drivers/mtd/ubi/scan.c
+++ b/drivers/mtd/ubi/scan.c
@@ -748,7 +748,7 @@ static int process_eb(struct ubi_device *ubi, struct ubi_scan_info *si,
                return err;
        else if (err == UBI_IO_BITFLIPS)
                bitflips = 1;
-       else if (err == UBI_IO_PEB_EMPTY)
+       else if (err == UBI_IO_FF)
                return add_to_list(si, pnum, UBI_SCAN_UNKNOWN_EC, &si->erase);
        else if (err == UBI_IO_BAD_HDR_EBADMSG || err == UBI_IO_BAD_HDR) {
                /*
@@ -817,7 +817,7 @@ static int process_eb(struct ubi_device *ubi, struct ubi_scan_info *si,
        else if (err == UBI_IO_BITFLIPS)
                bitflips = 1;
        else if (err == UBI_IO_BAD_HDR_EBADMSG || err == UBI_IO_BAD_HDR ||
-                (err == UBI_IO_PEB_FREE && ec_corr)) {
+                (err == UBI_IO_FF && ec_corr)) {
                /* VID header is corrupted */
                if (err == UBI_IO_BAD_HDR_EBADMSG ||
                    ec_corr == UBI_IO_BAD_HDR_EBADMSG)
@@ -826,7 +826,7 @@ static int process_eb(struct ubi_device *ubi, struct ubi_scan_info *si,
                if (err)
                        return err;
                goto adjust_mean_ec;
-       } else if (err == UBI_IO_PEB_FREE) {
+       } else if (err == UBI_IO_FF) {
                /* No VID header - the physical eraseblock is free */
                err = add_to_list(si, pnum, ec, &si->free);
                if (err)

diff --git a/drivers/mtd/ubi/ubi.h b/drivers/mtd/ubi/ubi.h
index 24a7c7647cb70f90eb701b3a0b8ff341ae2b2103..774bdcad6a076e3ca6884c587c907dbf60b5fa3f 100644 (file)
--- a/drivers/mtd/ubi/ubi.h
+++ b/drivers/mtd/ubi/ubi.h
@@ -85,10 +85,7 @@
 /*
  * Error codes returned by the I/O sub-system.
  *
- * UBI_IO_PEB_EMPTY: the physical eraseblock is empty, i.e. it contains only
- *                   %0xFF bytes
- * UBI_IO_PEB_FREE: the physical eraseblock is free, i.e. it contains only a
- *                  valid erase counter header, and the rest are %0xFF bytes
+ * UBI_IO_FF: the read region of flash contains only 0xFFs
  * UBI_IO_BAD_HDR: the EC or VID header is corrupted (bad magic or CRC)
  * UBI_IO_BAD_HDR_EBADMSG: the same as %UBI_IO_BAD_HDR, but also there was a
  *                         data integrity error reported by the MTD driver
@@ -96,8 +93,7 @@
  * UBI_IO_BITFLIPS: bit-flips were detected and corrected
  */
 enum {
-       UBI_IO_PEB_EMPTY = 1,
-       UBI_IO_PEB_FREE,
+       UBI_IO_FF = 1,
        UBI_IO_BAD_HDR,
        UBI_IO_BAD_HDR_EBADMSG,
        UBI_IO_BITFLIPS

diff --git a/drivers/mtd/ubi/wl.c b/drivers/mtd/ubi/wl.c
index 97a435672eafac554bd76eeb0a8efe4422602a5e..a9e7c9eed703e8e008e320c29f6d70fb2bb65c88 100644 (file)
--- a/drivers/mtd/ubi/wl.c
+++ b/drivers/mtd/ubi/wl.c
@@ -745,7 +745,7 @@ static int wear_leveling_worker(struct ubi_device *ubi, struct ubi_work *wrk,
 
        err = ubi_io_read_vid_hdr(ubi, e1->pnum, vid_hdr, 0);
        if (err && err != UBI_IO_BITFLIPS) {
-               if (err == UBI_IO_PEB_FREE) {
+               if (err == UBI_IO_FF) {
                        /*
                         * We are trying to move PEB without a VID header. UBI
                         * always write VID headers shortly after the PEB was