Merge tag 'upstream-4.18-rc1' of git://git.infradead.org/linux-ubifs

Pull UBI and UBIFS updates from Richard Weinberger:

 - the UBI on-disk format header file is now dual licensed

 - new way to detect Fastmap problems during runtime

 - bugfix for Fastmap

 - minor updates for UBIFS (spelling, comments, vm_fault_t, ...)

* tag 'upstream-4.18-rc1' of git://git.infradead.org/linux-ubifs:
  mtd: ubi: Update ubi-media.h to dual license
  ubi: fastmap: Detect EBA mismatches on-the-fly
  ubi: fastmap: Check each mapping only once
  ubi: fastmap: Correctly handle interrupted erasures in EBA
  ubi: fastmap: Cancel work upon detach
  ubifs: lpt: Fix wrong pnode number range in comment
  ubifs: gc: Fix typo
  ubifs: log: Some spelling fixes
  ubifs: Spelling fix someting -> something
  ubifs: journal: Remove wrong comment
  ubifs: remove set but never used variable
  ubifs, xattr: remove misguided quota flags
  fs: ubifs: Adding new return type vm_fault_t

16 files changed, 178 insertions, 46 deletions

diff --git a/drivers/mtd/ubi/build.c b/drivers/mtd/ubi/build.c
index 753494e042d5..d2a726654ff1 100644
--- a/drivers/mtd/ubi/build.c
+++ b/drivers/mtd/ubi/build.c
@@ -526,6 +526,7 @@ void ubi_free_internal_volumes(struct ubi_device *ubi)
         for (i = ubi->vtbl_slots;
              i < ubi->vtbl_slots + UBI_INT_VOL_COUNT; i++) {
                 ubi_eba_replace_table(ubi->volumes[i], NULL);
+                ubi_fastmap_destroy_checkmap(ubi->volumes[i]);
                 kfree(ubi->volumes[i]);
         }
 }
@@ -1091,6 +1092,9 @@ int ubi_detach_mtd_dev(int ubi_num, int anyway)
         if (ubi->bgt_thread)
                 kthread_stop(ubi->bgt_thread);
 
+#ifdef CONFIG_MTD_UBI_FASTMAP
+        cancel_work_sync(&ubi->fm_work);
+#endif
         ubi_debugfs_exit_dev(ubi);
         uif_close(ubi);
 
diff --git a/drivers/mtd/ubi/eba.c b/drivers/mtd/ubi/eba.c
index 250e30fac61b..edb1c8362faa 100644
--- a/drivers/mtd/ubi/eba.c
+++ b/drivers/mtd/ubi/eba.c
@@ -490,6 +490,103 @@ out_unlock:
         return err;
 }
 
+#ifdef CONFIG_MTD_UBI_FASTMAP
+/**
+ * check_mapping - check and fixup a mapping
+ * @ubi: UBI device description object
+ * @vol: volume description object
+ * @lnum: logical eraseblock number
+ * @pnum: physical eraseblock number
+ *
+ * Checks whether a given mapping is valid. Fastmap cannot track LEB unmap
+ * operations, if such an operation is interrupted the mapping still looks
+ * good, but upon first read an ECC is reported to the upper layer.
+ * Normaly during the full-scan at attach time this is fixed, for Fastmap
+ * we have to deal with it while reading.
+ * If the PEB behind a LEB shows this symthom we change the mapping to
+ * %UBI_LEB_UNMAPPED and schedule the PEB for erasure.
+ *
+ * Returns 0 on success, negative error code in case of failure.
+ */
+static int check_mapping(struct ubi_device *ubi, struct ubi_volume *vol, int lnum,
+                         int *pnum)
+{
+        int err;
+        struct ubi_vid_io_buf *vidb;
+        struct ubi_vid_hdr *vid_hdr;
+
+        if (!ubi->fast_attach)
+                return 0;
+
+        if (!vol->checkmap || test_bit(lnum, vol->checkmap))
+                return 0;
+
+        vidb = ubi_alloc_vid_buf(ubi, GFP_NOFS);
+        if (!vidb)
+                return -ENOMEM;
+
+        err = ubi_io_read_vid_hdr(ubi, *pnum, vidb, 0);
+        if (err > 0 && err != UBI_IO_BITFLIPS) {
+                int torture = 0;
+
+                switch (err) {
+                        case UBI_IO_FF:
+                        case UBI_IO_FF_BITFLIPS:
+                        case UBI_IO_BAD_HDR:
+                        case UBI_IO_BAD_HDR_EBADMSG:
+                                break;
+                        default:
+                                ubi_assert(0);
+                }
+
+                if (err == UBI_IO_BAD_HDR_EBADMSG || err == UBI_IO_FF_BITFLIPS)
+                        torture = 1;
+
+                down_read(&ubi->fm_eba_sem);
+                vol->eba_tbl->entries[lnum].pnum = UBI_LEB_UNMAPPED;
+                up_read(&ubi->fm_eba_sem);
+                ubi_wl_put_peb(ubi, vol->vol_id, lnum, *pnum, torture);
+
+                *pnum = UBI_LEB_UNMAPPED;
+        } else if (err < 0) {
+                ubi_err(ubi, "unable to read VID header back from PEB %i: %i",
+                        *pnum, err);
+
+                goto out_free;
+        } else {
+                int found_vol_id, found_lnum;
+
+                ubi_assert(err == 0 || err == UBI_IO_BITFLIPS);
+
+                vid_hdr = ubi_get_vid_hdr(vidb);
+                found_vol_id = be32_to_cpu(vid_hdr->vol_id);
+                found_lnum = be32_to_cpu(vid_hdr->lnum);
+
+                if (found_lnum != lnum || found_vol_id != vol->vol_id) {
+                        ubi_err(ubi, "EBA mismatch! PEB %i is LEB %i:%i instead of LEB %i:%i",
+                                *pnum, found_vol_id, found_lnum, vol->vol_id, lnum);
+                        ubi_ro_mode(ubi);
+                        err = -EINVAL;
+                        goto out_free;
+                }
+        }
+
+        set_bit(lnum, vol->checkmap);
+        err = 0;
+
+out_free:
+        ubi_free_vid_buf(vidb);
+
+        return err;
+}
+#else
+static int check_mapping(struct ubi_device *ubi, struct ubi_volume *vol, int lnum,
+                  int *pnum)
+{
+        return 0;
+}
+#endif
+
 /**
  * ubi_eba_read_leb - read data.
  * @ubi: UBI device description object
@@ -522,7 +619,13 @@ int ubi_eba_read_leb(struct ubi_device *ubi, struct ubi_volume *vol, int lnum,
                 return err;
 
         pnum = vol->eba_tbl->entries[lnum].pnum;
-        if (pnum < 0) {
+        if (pnum >= 0) {
+                err = check_mapping(ubi, vol, lnum, &pnum);
+                if (err < 0)
+                        goto out_unlock;
+        }
+
+        if (pnum == UBI_LEB_UNMAPPED) {
                 /*
                  * The logical eraseblock is not mapped, fill the whole buffer
                  * with 0xFF bytes. The exception is static volumes for which
@@ -931,6 +1034,12 @@ int ubi_eba_write_leb(struct ubi_device *ubi, struct ubi_volume *vol, int lnum,
 
         pnum = vol->eba_tbl->entries[lnum].pnum;
         if (pnum >= 0) {
+                err = check_mapping(ubi, vol, lnum, &pnum);
+                if (err < 0)
+                        goto out;
+        }
+
+        if (pnum >= 0) {
                 dbg_eba("write %d bytes at offset %d of LEB %d:%d, PEB %d",
                         len, offset, vol_id, lnum, pnum);
 
diff --git a/drivers/mtd/ubi/fastmap.c b/drivers/mtd/ubi/fastmap.c
index 91705962ba73..462526a10537 100644
--- a/drivers/mtd/ubi/fastmap.c
+++ b/drivers/mtd/ubi/fastmap.c
@@ -1100,6 +1100,26 @@ free_fm_sb:
         goto out;
 }
 
+int ubi_fastmap_init_checkmap(struct ubi_volume *vol, int leb_count)
+{
+        struct ubi_device *ubi = vol->ubi;
+
+        if (!ubi->fast_attach)
+                return 0;
+
+        vol->checkmap = kcalloc(BITS_TO_LONGS(leb_count), sizeof(unsigned long),
+                                GFP_KERNEL);
+        if (!vol->checkmap)
+                return -ENOMEM;
+
+        return 0;
+}