UBI: Kill data type hint

We do not need this feature and to our shame it even was not working
and there was a bug found very recently.
	-- Artem Bityutskiy

Without the data type hint UBI2 (fastmap) will be easier to implement.

Signed-off-by: Richard Weinberger <richard@nod.at>
Signed-off-by: Artem Bityutskiy <artem.bityutskiy@linux.intel.com>

8 files changed, 36 insertions, 102 deletions

diff --git a/drivers/mtd/ubi/cdev.c b/drivers/mtd/ubi/cdev.c
index ad76592fb2f4..f4061126926b 100644
--- a/drivers/mtd/ubi/cdev.c
+++ b/drivers/mtd/ubi/cdev.c
@@ -334,8 +334,7 @@ static ssize_t vol_cdev_direct_write(struct file *file, const char __user *buf,
                         break;
                 }
 
-                err = ubi_eba_write_leb(ubi, vol, lnum, tbuf, off, len,
-                                        UBI_UNKNOWN);
+                err = ubi_eba_write_leb(ubi, vol, lnum, tbuf, off, len);
                 if (err)
                         break;
 
@@ -477,9 +476,6 @@ static long vol_cdev_ioctl(struct file *file, unsigned int cmd,
                 if (req.lnum < 0 || req.lnum >= vol->reserved_pebs ||
                     req.bytes < 0 || req.lnum >= vol->usable_leb_size)
                         break;
-                if (req.dtype != UBI_LONGTERM && req.dtype != UBI_SHORTTERM &&
-                    req.dtype != UBI_UNKNOWN)
-                        break;
 
                 err = get_exclusive(desc);
                 if (err < 0)
@@ -532,7 +528,7 @@ static long vol_cdev_ioctl(struct file *file, unsigned int cmd,
                         err = -EFAULT;
                         break;
                 }
-                err = ubi_leb_map(desc, req.lnum, req.dtype);
+                err = ubi_leb_map(desc, req.lnum);
                 break;
         }
 
diff --git a/drivers/mtd/ubi/eba.c b/drivers/mtd/ubi/eba.c
index 2455d620d96b..bd5fdbf7cb41 100644
--- a/drivers/mtd/ubi/eba.c
+++ b/drivers/mtd/ubi/eba.c
@@ -507,7 +507,7 @@ static int recover_peb(struct ubi_device *ubi, int pnum, int vol_id, int lnum,
                 return -ENOMEM;
 
 retry:
-        new_pnum = ubi_wl_get_peb(ubi, UBI_UNKNOWN);
+        new_pnum = ubi_wl_get_peb(ubi);
         if (new_pnum < 0) {
                 ubi_free_vid_hdr(ubi, vid_hdr);
                 return new_pnum;
@@ -585,7 +585,6 @@ write_error:
  * @buf: the data to write
  * @offset: offset within the logical eraseblock where to write
  * @len: how many bytes to write
- * @dtype: data type
  *
  * This function writes data to logical eraseblock @lnum of a dynamic volume
  * @vol. Returns zero in case of success and a negative error code in case
@@ -593,7 +592,7 @@ write_error:
  * written to the flash media, but may be some garbage.
  */
 int ubi_eba_write_leb(struct ubi_device *ubi, struct ubi_volume *vol, int lnum,
-                      const void *buf, int offset, int len, int dtype)
+                      const void *buf, int offset, int len)
 {
         int err, pnum, tries = 0, vol_id = vol->vol_id;
         struct ubi_vid_hdr *vid_hdr;
@@ -641,7 +640,7 @@ int ubi_eba_write_leb(struct ubi_device *ubi, struct ubi_volume *vol, int lnum,
         vid_hdr->data_pad = cpu_to_be32(vol->data_pad);
 
 retry:
-        pnum = ubi_wl_get_peb(ubi, dtype);
+        pnum = ubi_wl_get_peb(ubi);
         if (pnum < 0) {
                 ubi_free_vid_hdr(ubi, vid_hdr);
                 leb_write_unlock(ubi, vol_id, lnum);
@@ -707,7 +706,6 @@ write_error:
  * @lnum: logical eraseblock number
  * @buf: data to write
  * @len: how many bytes to write
- * @dtype: data type
  * @used_ebs: how many logical eraseblocks will this volume contain
  *
  * This function writes data to logical eraseblock @lnum of static volume
@@ -724,8 +722,7 @@ write_error:
  * code in case of failure.
  */
 int ubi_eba_write_leb_st(struct ubi_device *ubi, struct ubi_volume *vol,
-                         int lnum, const void *buf, int len, int dtype,
-                         int used_ebs)
+                         int lnum, const void *buf, int len, int used_ebs)
 {
         int err, pnum, tries = 0, data_size = len, vol_id = vol->vol_id;
         struct ubi_vid_hdr *vid_hdr;
@@ -763,7 +760,7 @@ int ubi_eba_write_leb_st(struct ubi_device *ubi, struct ubi_volume *vol,
         vid_hdr->data_crc = cpu_to_be32(crc);
 
 retry:
-        pnum = ubi_wl_get_peb(ubi, dtype);
+        pnum = ubi_wl_get_peb(ubi);
         if (pnum < 0) {
                 ubi_free_vid_hdr(ubi, vid_hdr);
                 leb_write_unlock(ubi, vol_id, lnum);
@@ -827,7 +824,6 @@ write_error:
  * @lnum: logical eraseblock number
  * @buf: data to write
  * @len: how many bytes to write
- * @dtype: data type
  *
  * This function changes the contents of a logical eraseblock atomically. @buf
  * has to contain new logical eraseblock data, and @len - the length of the
@@ -839,7 +835,7 @@ write_error:
  * LEB change may be done at a time. This is ensured by @ubi->alc_mutex.
  */
 int ubi_eba_atomic_leb_change(struct ubi_device *ubi, struct ubi_volume *vol,
-                              int lnum, const void *buf, int len, int dtype)
+                              int lnum, const void *buf, int len)
 {
         int err, pnum, tries = 0, vol_id = vol->vol_id;
         struct ubi_vid_hdr *vid_hdr;
@@ -856,7 +852,7 @@ int ubi_eba_atomic_leb_change(struct ubi_device *ubi, struct ubi_volume *vol,
                 err = ubi_eba_unmap_leb(ubi, vol, lnum);
                 if (err)
                         return err;
-                return ubi_eba_write_leb(ubi, vol, lnum, NULL, 0, 0, dtype);
+                return ubi_eba_write_leb(ubi, vol, lnum, NULL, 0, 0);
         }
 
         vid_hdr = ubi_zalloc_vid_hdr(ubi, GFP_NOFS);
@@ -881,7 +877,7 @@ int ubi_eba_atomic_leb_change(struct ubi_device *ubi, struct ubi_volume *vol,
         vid_hdr->data_crc = cpu_to_be32(crc);
 
 retry:
-        pnum = ubi_wl_get_peb(ubi, dtype);
+        pnum = ubi_wl_get_peb(ubi);
         if (pnum < 0) {
                 err = pnum;
                 goto out_leb_unlock;
diff --git a/drivers/mtd/ubi/gluebi.c b/drivers/mtd/ubi/gluebi.c
index 90b98822d9a4..4e44bee4c564 100644
--- a/drivers/mtd/ubi/gluebi.c
+++ b/drivers/mtd/ubi/gluebi.c
@@ -227,7 +227,7 @@ static int gluebi_write(struct mtd_info *mtd, loff_t to, size_t len,
                 if (to_write > total_written)
                         to_write = total_written;
 
-                err = ubi_write(gluebi->desc, lnum, buf, offs, to_write);
+                err = ubi_leb_write(gluebi->desc, lnum, buf, offs, to_write);
                 if (err)
                         break;
 
diff --git a/drivers/mtd/ubi/kapi.c b/drivers/mtd/ubi/kapi.c
index 9fdb35367fe0..33ede23769db 100644
--- a/drivers/mtd/ubi/kapi.c
+++ b/drivers/mtd/ubi/kapi.c
@@ -426,11 +426,9 @@ EXPORT_SYMBOL_GPL(ubi_leb_read);
  * @buf: data to write
  * @offset: offset within the logical eraseblock where to write
  * @len: how many bytes to write
- * @dtype: expected data type
  *
  * This function writes @len bytes of data from @buf to offset @offset of
- * logical eraseblock @lnum. The @dtype argument describes expected lifetime of
- * the data.
+ * logical eraseblock @lnum.
  *
  * This function takes care of physical eraseblock write failures. If write to
  * the physical eraseblock write operation fails, the logical eraseblock is
@@ -447,7 +445,7 @@ EXPORT_SYMBOL_GPL(ubi_leb_read);
  * returns immediately with %-EBADF code.
  */
 int ubi_leb_write(struct ubi_volume_desc *desc, int lnum, const void *buf,
-                  int offset, int len, int dtype)
+                  int offset, int len)
 {
         struct ubi_volume *vol = desc->vol;
         struct ubi_device *ubi = vol->ubi;
@@ -466,17 +464,13 @@ int ubi_leb_write(struct ubi_volume_desc *desc, int lnum, const void *buf,
             offset & (ubi->min_io_size - 1) || len & (ubi->min_io_size - 1))
                 return -EINVAL;
 
-        if (dtype != UBI_LONGTERM && dtype != UBI_SHORTTERM &&
-            dtype != UBI_UNKNOWN)
-                return -EINVAL;
-
         if (vol->upd_marker)
                 return -EBADF;
 
         if (len == 0)
                 return 0;
 
-        return ubi_eba_write_leb(ubi, vol, lnum, buf, offset, len, dtype);
+        return ubi_eba_write_leb(ubi, vol, lnum, buf, offset, len);
 }
 EXPORT_SYMBOL_GPL(ubi_leb_write);
 
@@ -486,7 +480,6 @@ EXPORT_SYMBOL_GPL(ubi_leb_write);
  * @lnum: logical eraseblock number to change
  * @buf: data to write
  * @len: how many bytes to write
- * @dtype: expected data type
  *
  * This function changes the contents of a logical eraseblock atomically. @buf
  * has to contain new logical eraseblock data, and @len - the length of the
@@ -497,7 +490,7 @@ EXPORT_SYMBOL_GPL(ubi_leb_write);
  * code in case of failure.
  */
 int ubi_leb_change(struct ubi_volume_desc *desc, int lnum, const void *buf,
-                   int len, int dtype)
+                   int len)
 {
         struct ubi_volume *vol = desc->vol;
         struct ubi_device *ubi = vol->ubi;
@@ -515,17 +508,13 @@ int ubi_leb_change(struct ubi_volume_desc *desc, int lnum, const void *buf,
             len > vol->usable_leb_size || len & (ubi->min_io_size - 1))
                 return -EINVAL;
 
-        if (dtype != UBI_LONGTERM && dtype != UBI_SHORTTERM &&
-            dtype != UBI_UNKNOWN)
-                return -EINVAL;
-
         if (vol->upd_marker)
                 return -EBADF;
 
         if (len == 0)
                 return 0;
 
-        return ubi_eba_atomic_leb_change(ubi, vol, lnum, buf, len, dtype);
+        return ubi_eba_atomic_leb_change(ubi, vol, lnum, buf, len);
 }
 EXPORT_SYMBOL_GPL(ubi_leb_change);
 
@@ -626,7 +615,6 @@ EXPORT_SYMBOL_GPL(ubi_leb_unmap);
  * ubi_leb_map - map logical eraseblock to a physical eraseblock.
  * @desc: volume descriptor
  * @lnum: logical eraseblock number
- * @dtype: expected data type
  *
  * This function maps an un-mapped logical eraseblock @lnum to a physical
  * eraseblock. This means, that after a successful invocation of this
@@ -639,7 +627,7 @@ EXPORT_SYMBOL_GPL(ubi_leb_unmap);
  * eraseblock is already mapped, and other negative error codes in case of
  * other failures.
  */
-int ubi_leb_map(struct ubi_volume_desc *desc, int lnum, int dtype)
+int ubi_leb_map(struct ubi_volume_desc *desc, int lnum)
 {
         struct ubi_volume *vol = desc->vol;
         struct ubi_device *ubi = vol->ubi;
@@ -652,17 +640,13 @@ int ubi_leb_map(struct ubi_volume_desc *desc, int lnum, int dtype)
         if (lnum < 0 || lnum >= vol->reserved_pebs)
                 return -EINVAL;
 
-        if (dtype != UBI_LONGTERM && dtype != UBI_SHORTTERM &&
-            dtype != UBI_UNKNOWN)
-                return -EINVAL;
-
         if (vol->upd_marker)
                 return -EBADF;
 
         if (vol->eba_tbl[lnum] >= 0)
                 return -EBADMSG;
 
-        return ubi_eba_write_leb(ubi, vol, lnum, NULL, 0, 0, dtype);
+        return ubi_eba_write_leb(ubi, vol, lnum, NULL, 0, 0);
 }
 EXPORT_SYMBOL_GPL(ubi_leb_map);
 
diff --git a/drivers/mtd/ubi/ubi.h b/drivers/mtd/ubi/ubi.h
index 4f5c9f136519..75b9f1c61b78 100644
--- a/drivers/mtd/ubi/ubi.h
+++ b/drivers/mtd/ubi/ubi.h
@@ -222,8 +222,6 @@ struct ubi_volume_desc;
  * @upd_ebs: how many eraseblocks are expected to be updated
  * @ch_lnum: LEB number which is being changing by the atomic LEB change
  *           operation
- * @ch_dtype: data persistency type which is being changing by the atomic LEB
- *            change operation
  * @upd_bytes: how many bytes are expected to be received for volume update or
  *             atomic LEB change
  * @upd_received: how many bytes were already received for volume update or
@@ -270,7 +268,6 @@ struct ubi_volume {
 
         int upd_ebs;
         int ch_lnum;
-        int ch_dtype;
         long long upd_bytes;
         long long upd_received;
         void *upd_buf;
@@ -525,18 +522,17 @@ int ubi_eba_unmap_leb(struct ubi_device *ubi, struct ubi_volume *vol,
 int ubi_eba_read_leb(struct ubi_device *ubi, struct ubi_volume *vol, int lnum,
                      void *buf, int offset, int len, int check);
 int ubi_eba_write_leb(struct ubi_device *ubi, struct ubi_volume *vol, int lnum,
-                      const void *buf, int offset, int len, int dtype);
+                      const void *buf, int offset, int len);
 int ubi_eba_write_leb_st(struct ubi_device *ubi, struct ubi_volume *vol,
-                         int lnum, const void *buf, int len, int dtype,
-                         int used_ebs);
+                         int lnum, const void *buf, int len, int used_ebs);
 int ubi_eba_atomic_leb_change(struct ubi_device *ubi, struct ubi_volume *vol,
-                              int lnum, const void *buf, int len, int dtype);
+                              int lnum, const void *buf, int len);
 int ubi_eba_copy_leb(struct ubi_device *ubi, int from, int to,
                      struct ubi_vid_hdr *vid_hdr);
 int ubi_eba_init_scan(struct ubi_device *ubi, struct ubi_scan_info *si);
 
 /* wl.c */
-int ubi_wl_get_peb(struct ubi_device *ubi, int dtype);
+int ubi_wl_get_peb(struct ubi_device *ubi);
 int ubi_wl_put_peb(struct ubi_device *ubi, int pnum, int torture);
 int ubi_wl_flush(struct ubi_device *ubi);
 int ubi_wl_scrub_peb(struct ubi_device *ubi, int pnum);
diff --git a/drivers/mtd/ubi/upd.c b/drivers/mtd/ubi/upd.c
index 425bf5a3edd4..11a28f9ce0db 100644
--- a/drivers/mtd/ubi/upd.c
+++ b/drivers/mtd/ubi/upd.c
@@ -186,14 +186,12 @@ int ubi_start_leb_change(struct ubi_device *ubi, struct ubi_volume *vol,
         dbg_gen("start changing LEB %d:%d, %u bytes",
                 vol->vol_id, req->lnum, req->bytes);
         if (req->bytes == 0)
-                return ubi_eba_atomic_leb_change(ubi, vol, req->lnum, NULL, 0,
-                                                 req->dtype);
+                return ubi_eba_atomic_leb_change(ubi, vol, req->lnum, NULL, 0);
 
         vol->upd_bytes = req->bytes;
         vol->upd_received = 0;
         vol->changing_leb = 1;
         vol->ch_lnum = req->lnum;
-        vol->ch_dtype = req->dtype;
 
         vol->upd_buf = vmalloc(req->bytes);
         if (!vol->upd_buf)
@@ -246,8 +244,7 @@ static int write_leb(struct ubi_device *ubi, struct ubi_volume *vol, int lnum,
                         return 0;
                 }
 
-                err = ubi_eba_write_leb(ubi, vol, lnum, buf, 0, len,
-                                        UBI_UNKNOWN);
+                err = ubi_eba_write_leb(ubi, vol, lnum, buf, 0, len);
         } else {
                 /*
                  * When writing static volume, and this is the last logical
@@ -259,8 +256,7 @@ static int write_leb(struct ubi_device *ubi, struct ubi_volume *vol, int lnum,
                  * contain zeros, not random trash.
                  */
                 memset(buf + len, 0, vol->usable_leb_size - len);
-                err = ubi_eba_write_leb_st(ubi, vol, lnum, buf, len,
-                                           UBI_UNKNOWN, used_ebs);
+                err = ubi_eba_write_leb_st(ubi, vol, lnum, buf, len, used_ebs);
         }
 
         return err;
@@ -421,7 +417,7 @@ int ubi_more_leb_change_data(struct ubi_device *ubi, struct ubi_volume *vol,
                        len - vol->upd_bytes);
                 len = ubi_calc_data_len(ubi, vol->upd_buf, len);
                 err = ubi_eba_atomic_leb_change(ubi, vol, vol->ch_lnum,
-                                                vol->upd_buf, len, UBI_UNKNOWN);
+                                                vol->upd_buf, len);
                 if (err)
                         return err;
         }
diff --git a/drivers/mtd/ubi/vtbl.c b/drivers/mtd/ubi/vtbl.c
index 17cec0c01544..a6f4b13d8417 100644
--- a/drivers/mtd/ubi/vtbl.c
+++ b/drivers/mtd/ubi/vtbl.c
@@ -106,7 +106,7 @@ int ubi_change_vtbl_record(struct ubi_device *ubi, int idx,
                         return err;
 
                 err = ubi_eba_write_leb(ubi, layout_vol, i, ubi->vtbl, 0,
-                                        ubi->vtbl_size, UBI_LONGTERM);
+                                        ubi->vtbl_size);
                 if (err)
                         return err;
         }
@@ -158,7 +158,7 @@ int ubi_vtbl_rename_volumes(struct ubi_device *ubi,
                         return err;
 
                 err = ubi_eba_write_leb(ubi, layout_vol, i, ubi->vtbl, 0,
-                                        ubi->vtbl_size, UBI_LONGTERM);
+                                        ubi->vtbl_size);
                 if (err)
                         return err;
         }
diff --git a/drivers/mtd/ubi/wl.c b/drivers/mtd/ubi/wl.c
index b0a6d53ef047..f0bc10743bc0 100644
--- a/drivers/mtd/ubi/wl.c
+++ b/drivers/mtd/ubi/wl.c
@@ -383,19 +383,15 @@ static struct ubi_wl_entry *find_wl_entry(struct rb_root *root, int diff)
 /**
  * ubi_wl_get_peb - get a physical eraseblock.
  * @ubi: UBI device description object
- * @dtype: type of data which will be stored in this physical eraseblock
  *
  * This function returns a physical eraseblock in case of success and a
  * negative error code in case of failure. Might sleep.
  */
-int ubi_wl_get_peb(struct ubi_device *ubi, int dtype)
+int ubi_wl_get_peb(struct ubi_device *ubi)
 {
         int err;
         struct ubi_wl_entry *e, *first, *last;
 
-        ubi_assert(dtype == UBI_LONGTERM || dtype == UBI_SHORTTERM ||
-                   dtype == UBI_UNKNOWN);
-
 retry:
         spin_lock(&ubi->wl_lock);
         if (!ubi->free.rb_node) {
@@ -413,43 +409,13 @@ retry:
                 goto retry;
         }
 
-        switch (dtype) {
-        case UBI_LONGTERM:
-                /*
-                 * For long term data we pick a physical eraseblock with high
-                 * erase counter. But the highest erase counter we can pick is
-                 * bounded by the the lowest erase counter plus
-                 * %WL_FREE_MAX_DIFF.
-                 */
-                e = find_wl_entry(&ubi->free, WL_FREE_MAX_DIFF);
-                break;
-        case UBI_UNKNOWN:
-                /*
-                 * For unknown data we pick a physical eraseblock with medium
-                 * erase counter. But we by no means can pick a physical
-                 * eraseblock with erase counter greater or equivalent than the
-                 * lowest erase counter plus %WL_FREE_MAX_DIFF/2.
-                 */
-                first = rb_entry(rb_first(&ubi->free), struct ubi_wl_entry,
-                                        u.rb);
-                last = rb_entry(rb_last(&ubi->free), struct ubi_wl_entry, u.rb);
-
-                if (last->ec - first->ec < WL_FREE_MAX_DIFF)
-                        e = rb_entry(ubi->free.rb_node,
-                                        struct ubi_wl_entry, u.rb);
-                else
-                        e = find_wl_entry(&ubi->free, WL_FREE_MAX_DIFF/2);
-                break;
-        case UBI_SHORTTERM:
-                /*
-                 * For short term data we pick a physical eraseblock with the
-                 * lowest erase counter as we expect it will be erased soon.
-                 */
-                e = rb_entry(rb_first(&ubi->free), struct ubi_wl_entry, u.rb);
-                break;
-        default:
-                BUG();
-        }
+        first = rb_entry(rb_first(&ubi->free), struct ubi_wl_entry, u.rb);
+        last = rb_entry(rb_last(&ubi->free), struct ubi_wl_entry, u.rb);
+
+        if (last->ec - first->ec < WL_FREE_MAX_DIFF)
+                e = rb_entry(ubi->free.rb_node, struct ubi_wl_entry, u.rb);
+        else
+                e = find_wl_entry(&ubi->free, WL_FREE_MAX_DIFF/2);
 
         paranoid_check_in_wl_tree(ubi, e, &ubi->free);