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>

16 files changed, 69 insertions, 99 deletions

diff --git a/fs/ubifs/debug.c b/fs/ubifs/debug.c
index df83d7b495fc..685a83756b2b 100644
--- a/fs/ubifs/debug.c
+++ b/fs/ubifs/debug.c
@@ -2676,7 +2676,7 @@ static void cut_data(const void *buf, unsigned int len)
 }
 
 int dbg_leb_write(struct ubifs_info *c, int lnum, const void *buf,
-                  int offs, int len, int dtype)
+                  int offs, int len)
 {
         int err, failing;
 
@@ -2686,7 +2686,7 @@ int dbg_leb_write(struct ubifs_info *c, int lnum, const void *buf,
         failing = power_cut_emulated(c, lnum, 1);
         if (failing)
                 cut_data(buf, len);
-        err = ubi_leb_write(c->ubi, lnum, buf, offs, len, dtype);
+        err = ubi_leb_write(c->ubi, lnum, buf, offs, len);
         if (err)
                 return err;
         if (failing)
@@ -2695,7 +2695,7 @@ int dbg_leb_write(struct ubifs_info *c, int lnum, const void *buf,
 }
 
 int dbg_leb_change(struct ubifs_info *c, int lnum, const void *buf,
-                   int len, int dtype)
+                   int len)
 {
         int err;
 
@@ -2703,7 +2703,7 @@ int dbg_leb_change(struct ubifs_info *c, int lnum, const void *buf,
                 return -EROFS;
         if (power_cut_emulated(c, lnum, 1))
                 return -EROFS;
-        err = ubi_leb_change(c->ubi, lnum, buf, len, dtype);
+        err = ubi_leb_change(c->ubi, lnum, buf, len);
         if (err)
                 return err;
         if (power_cut_emulated(c, lnum, 1))
@@ -2727,7 +2727,7 @@ int dbg_leb_unmap(struct ubifs_info *c, int lnum)
         return 0;
 }
 
-int dbg_leb_map(struct ubifs_info *c, int lnum, int dtype)
+int dbg_leb_map(struct ubifs_info *c, int lnum)
 {
         int err;
 
@@ -2735,7 +2735,7 @@ int dbg_leb_map(struct ubifs_info *c, int lnum, int dtype)
                 return -EROFS;
         if (power_cut_emulated(c, lnum, 0))
                 return -EROFS;
-        err = ubi_leb_map(c->ubi, lnum, dtype);
+        err = ubi_leb_map(c->ubi, lnum);
         if (err)
                 return err;
         if (power_cut_emulated(c, lnum, 0))
diff --git a/fs/ubifs/debug.h b/fs/ubifs/debug.h
index 6b3a9e2ee19c..486a8e024fb6 100644
--- a/fs/ubifs/debug.h
+++ b/fs/ubifs/debug.h
@@ -299,11 +299,10 @@ int dbg_check_data_nodes_order(struct ubifs_info *c, struct list_head *head);
 int dbg_check_nondata_nodes_order(struct ubifs_info *c, struct list_head *head);
 
 int dbg_leb_write(struct ubifs_info *c, int lnum, const void *buf, int offs,
-                  int len, int dtype);
-int dbg_leb_change(struct ubifs_info *c, int lnum, const void *buf, int len,
-                   int dtype);
+                  int len);
+int dbg_leb_change(struct ubifs_info *c, int lnum, const void *buf, int len);
 int dbg_leb_unmap(struct ubifs_info *c, int lnum);
-int dbg_leb_map(struct ubifs_info *c, int lnum, int dtype);
+int dbg_leb_map(struct ubifs_info *c, int lnum);
 
 /* Debugfs-related stuff */
 int dbg_debugfs_init(void);
diff --git a/fs/ubifs/gc.c b/fs/ubifs/gc.c
index ded29f6224c2..04dd6f47635e 100644
--- a/fs/ubifs/gc.c
+++ b/fs/ubifs/gc.c
@@ -109,7 +109,7 @@ static int switch_gc_head(struct ubifs_info *c)
                 return err;
 
         c->gc_lnum = -1;
-        err = ubifs_wbuf_seek_nolock(wbuf, gc_lnum, 0, UBI_LONGTERM);
+        err = ubifs_wbuf_seek_nolock(wbuf, gc_lnum, 0);
         return err;
 }
 
diff --git a/fs/ubifs/io.c b/fs/ubifs/io.c
index 21f0835d78c9..e18b9889a51b 100644
--- a/fs/ubifs/io.c
+++ b/fs/ubifs/io.c
@@ -115,7 +115,7 @@ int ubifs_leb_read(const struct ubifs_info *c, int lnum, void *buf, int offs,
 }
 
 int ubifs_leb_write(struct ubifs_info *c, int lnum, const void *buf, int offs,
-                    int len, int dtype)
+                    int len)
 {
         int err;
 
@@ -123,9 +123,9 @@ int ubifs_leb_write(struct ubifs_info *c, int lnum, const void *buf, int offs,
         if (c->ro_error)
                 return -EROFS;
         if (!dbg_is_tst_rcvry(c))
-                err = ubi_leb_write(c->ubi, lnum, buf, offs, len, dtype);
+                err = ubi_leb_write(c->ubi, lnum, buf, offs, len);
         else
-                err = dbg_leb_write(c, lnum, buf, offs, len, dtype);
+                err = dbg_leb_write(c, lnum, buf, offs, len);
         if (err) {
                 ubifs_err("writing %d bytes to LEB %d:%d failed, error %d",
                           len, lnum, offs, err);
@@ -135,8 +135,7 @@ int ubifs_leb_write(struct ubifs_info *c, int lnum, const void *buf, int offs,
         return err;
 }
 
-int ubifs_leb_change(struct ubifs_info *c, int lnum, const void *buf, int len,
-                     int dtype)
+int ubifs_leb_change(struct ubifs_info *c, int lnum, const void *buf, int len)
 {
         int err;
 
@@ -144,9 +143,9 @@ int ubifs_leb_change(struct ubifs_info *c, int lnum, const void *buf, int len,
         if (c->ro_error)
                 return -EROFS;
         if (!dbg_is_tst_rcvry(c))
-                err = ubi_leb_change(c->ubi, lnum, buf, len, dtype);
+                err = ubi_leb_change(c->ubi, lnum, buf, len);
         else
-                err = dbg_leb_change(c, lnum, buf, len, dtype);
+                err = dbg_leb_change(c, lnum, buf, len);
         if (err) {
                 ubifs_err("changing %d bytes in LEB %d failed, error %d",
                           len, lnum, err);
@@ -175,7 +174,7 @@ int ubifs_leb_unmap(struct ubifs_info *c, int lnum)
         return err;
 }
 
-int ubifs_leb_map(struct ubifs_info *c, int lnum, int dtype)
+int ubifs_leb_map(struct ubifs_info *c, int lnum)
 {
         int err;
 
@@ -183,9 +182,9 @@ int ubifs_leb_map(struct ubifs_info *c, int lnum, int dtype)
         if (c->ro_error)
                 return -EROFS;
         if (!dbg_is_tst_rcvry(c))
-                err = ubi_leb_map(c->ubi, lnum, dtype);
+                err = ubi_leb_map(c->ubi, lnum);
         else
-                err = dbg_leb_map(c, lnum, dtype);
+                err = dbg_leb_map(c, lnum);
         if (err) {
                 ubifs_err("mapping LEB %d failed, error %d", lnum, err);
                 ubifs_ro_mode(c, err);
@@ -523,8 +522,7 @@ int ubifs_wbuf_sync_nolock(struct ubifs_wbuf *wbuf)
         dirt = sync_len - wbuf->used;
         if (dirt)
                 ubifs_pad(c, wbuf->buf + wbuf->used, dirt);
-        err = ubifs_leb_write(c, wbuf->lnum, wbuf->buf, wbuf->offs, sync_len,
-                              wbuf->dtype);
+        err = ubifs_leb_write(c, wbuf->lnum, wbuf->buf, wbuf->offs, sync_len);
         if (err)
                 return err;
 
@@ -562,14 +560,12 @@ int ubifs_wbuf_sync_nolock(struct ubifs_wbuf *wbuf)
  * @wbuf: write-buffer
  * @lnum: logical eraseblock number to seek to
  * @offs: logical eraseblock offset to seek to
- * @dtype: data type
  *
  * This function targets the write-buffer to logical eraseblock @lnum:@offs.
  * The write-buffer has to be empty. Returns zero in case of success and a
  * negative error code in case of failure.
  */
-int ubifs_wbuf_seek_nolock(struct ubifs_wbuf *wbuf, int lnum, int offs,
-                           int dtype)
+int ubifs_wbuf_seek_nolock(struct ubifs_wbuf *wbuf, int lnum, int offs)
 {
         const struct ubifs_info *c = wbuf->c;
 
@@ -592,7 +588,6 @@ int ubifs_wbuf_seek_nolock(struct ubifs_wbuf *wbuf, int lnum, int offs,
         wbuf->avail = wbuf->size;
         wbuf->used = 0;
         spin_unlock(&wbuf->lock);
-        wbuf->dtype = dtype;
 
         return 0;
 }
@@ -719,8 +714,7 @@ int ubifs_wbuf_write_nolock(struct ubifs_wbuf *wbuf, void *buf, int len)
                         dbg_io("flush jhead %s wbuf to LEB %d:%d",
                                dbg_jhead(wbuf->jhead), wbuf->lnum, wbuf->offs);
                         err = ubifs_leb_write(c, wbuf->lnum, wbuf->buf,
-                                              wbuf->offs, wbuf->size,
-                                              wbuf->dtype);
+                                              wbuf->offs, wbuf->size);
                         if (err)
                                 goto out;
 
@@ -756,7 +750,7 @@ int ubifs_wbuf_write_nolock(struct ubifs_wbuf *wbuf, void *buf, int len)
                        dbg_jhead(wbuf->jhead), wbuf->lnum, wbuf->offs);
                 memcpy(wbuf->buf + wbuf->used, buf, wbuf->avail);
                 err = ubifs_leb_write(c, wbuf->lnum, wbuf->buf, wbuf->offs,
-                                      wbuf->size, wbuf->dtype);
+                                      wbuf->size);
                 if (err)
                         goto out;
 
@@ -775,7 +769,7 @@ int ubifs_wbuf_write_nolock(struct ubifs_wbuf *wbuf, void *buf, int len)
                 dbg_io("write %d bytes to LEB %d:%d",
                        wbuf->size, wbuf->lnum, wbuf->offs);
                 err = ubifs_leb_write(c, wbuf->lnum, buf, wbuf->offs,
-                                      wbuf->size, wbuf->dtype);
+                                      wbuf->size);
                 if (err)
                         goto out;
 
@@ -797,7 +791,7 @@ int ubifs_wbuf_write_nolock(struct ubifs_wbuf *wbuf, void *buf, int len)
                 dbg_io("write %d bytes to LEB %d:%d", n, wbuf->lnum,
                        wbuf->offs);
                 err = ubifs_leb_write(c, wbuf->lnum, buf + written,
-                                      wbuf->offs, n, wbuf->dtype);
+                                      wbuf->offs, n);
                 if (err)
                         goto out;
                 wbuf->offs += n;
@@ -854,7 +848,6 @@ out:
  * @len: node length
  * @lnum: logical eraseblock number
  * @offs: offset within the logical eraseblock
- * @dtype: node life-time hint (%UBI_LONGTERM, %UBI_SHORTTERM, %UBI_UNKNOWN)
  *
  * This function automatically fills node magic number, assigns sequence
  * number, and calculates node CRC checksum. The length of the @buf buffer has
@@ -863,7 +856,7 @@ out:
  * success and a negative error code in case of failure.
  */
 int ubifs_write_node(struct ubifs_info *c, void *buf, int len, int lnum,
-                     int offs, int dtype)
+                     int offs)
 {
         int err, buf_len = ALIGN(len, c->min_io_size);
 
@@ -879,7 +872,7 @@ int ubifs_write_node(struct ubifs_info *c, void *buf, int len, int lnum,
                 return -EROFS;
 
         ubifs_prepare_node(c, buf, len, 1);
-        err = ubifs_leb_write(c, lnum, buf, offs, buf_len, dtype);
+        err = ubifs_leb_write(c, lnum, buf, offs, buf_len);
         if (err)
                 ubifs_dump_node(c, buf);
 
@@ -1056,7 +1049,6 @@ int ubifs_wbuf_init(struct ubifs_info *c, struct ubifs_wbuf *wbuf)
          */
         size = c->max_write_size - (c->leb_start % c->max_write_size);
         wbuf->avail = wbuf->size = size;
-        wbuf->dtype = UBI_UNKNOWN;
         wbuf->sync_callback = NULL;
         mutex_init(&wbuf->io_mutex);
         spin_lock_init(&wbuf->lock);
diff --git a/fs/ubifs/journal.c b/fs/ubifs/journal.c
index 61cd8535ffd6..12c0f154ca83 100644
--- a/fs/ubifs/journal.c
+++ b/fs/ubifs/journal.c
@@ -214,7 +214,7 @@ out:
         err = ubifs_add_bud_to_log(c, jhead, lnum, offs);
         if (err)
                 goto out_return;
-        err = ubifs_wbuf_seek_nolock(wbuf, lnum, offs, wbuf->dtype);
+        err = ubifs_wbuf_seek_nolock(wbuf, lnum, offs);
         if (err)
                 goto out_unlock;
 
diff --git a/fs/ubifs/log.c b/fs/ubifs/log.c
index 9967b5a21f41..c80b15d6c8de 100644
--- a/fs/ubifs/log.c
+++ b/fs/ubifs/log.c
@@ -258,7 +258,7 @@ int ubifs_add_bud_to_log(struct ubifs_info *c, int jhead, int lnum, int offs)
                  * an unclean reboot, because the target LEB might have been
                  * unmapped, but not yet physically erased.
                  */
-                err = ubifs_leb_map(c, bud->lnum, UBI_SHORTTERM);
+                err = ubifs_leb_map(c, bud->lnum);
                 if (err)
                         goto out_unlock;
         }
@@ -266,7 +266,7 @@ int ubifs_add_bud_to_log(struct ubifs_info *c, int jhead, int lnum, int offs)
         dbg_log("write ref LEB %d:%d",
                 c->lhead_lnum, c->lhead_offs);
         err = ubifs_write_node(c, ref, UBIFS_REF_NODE_SZ, c->lhead_lnum,
-                               c->lhead_offs, UBI_SHORTTERM);
+                               c->lhead_offs);
         if (err)
                 goto out_unlock;
 
@@ -418,7 +418,7 @@ int ubifs_log_start_commit(struct ubifs_info *c, int *ltail_lnum)
 
         len = ALIGN(len, c->min_io_size);
         dbg_log("writing commit start at LEB %d:0, len %d", c->lhead_lnum, len);
-        err = ubifs_leb_write(c, c->lhead_lnum, cs, 0, len, UBI_SHORTTERM);
+        err = ubifs_leb_write(c, c->lhead_lnum, cs, 0, len);
         if (err)
                 goto out;
 
@@ -619,7 +619,7 @@ static int add_node(struct ubifs_info *c, void *buf, int *lnum, int *offs,
                 int sz = ALIGN(*offs, c->min_io_size), err;
 
                 ubifs_pad(c, buf + *offs, sz - *offs);
-                err = ubifs_leb_change(c, *lnum, buf, sz, UBI_SHORTTERM);
+                err = ubifs_leb_change(c, *lnum, buf, sz);
                 if (err)
                         return err;
                 *lnum = ubifs_next_log_lnum(c, *lnum);
@@ -698,7 +698,7 @@ int ubifs_consolidate_log(struct ubifs_info *c)
                 int sz = ALIGN(offs, c->min_io_size);
 
                 ubifs_pad(c, buf + offs, sz - offs);
-                err = ubifs_leb_change(c, write_lnum, buf, sz, UBI_SHORTTERM);
+                err = ubifs_leb_change(c, write_lnum, buf, sz);
                 if (err)
                         goto out_free;
                 offs = ALIGN(offs, c->min_io_size);
diff --git a/fs/ubifs/lpt.c b/fs/ubifs/lpt.c
index b4280c44949c..ce33b2beb151 100644
--- a/fs/ubifs/lpt.c
+++ b/fs/ubifs/lpt.c
@@ -701,8 +701,7 @@ int ubifs_create_dflt_lpt(struct ubifs_info *c, int *main_lebs, int lpt_first,
                         alen = ALIGN(len, c->min_io_size);
                         set_ltab(c, lnum, c->leb_size - alen, alen - len);
                         memset(p, 0xff, alen - len);
-                        err = ubifs_leb_change(c, lnum++, buf, alen,
-                                               UBI_SHORTTERM);
+                        err = ubifs_leb_change(c, lnum++, buf, alen);
                         if (err)
                                 goto out;
                         p = buf;
@@ -732,8 +731,7 @@ int ubifs_create_dflt_lpt(struct ubifs_info *c, int *main_lebs, int lpt_first,
                                 set_ltab(c, lnum, c->leb_size - alen,
                                             alen - len);
                                 memset(p, 0xff, alen - len);
-                                err = ubifs_leb_change(c, lnum++, buf, alen,
-                                                       UBI_SHORTTERM);
+                                err = ubifs_leb_change(c, lnum++, buf, alen);
                                 if (err)
                                         goto out;
                                 p = buf;
@@ -780,8 +778,7 @@ int ubifs_create_dflt_lpt(struct ubifs_info *c, int *main_lebs, int lpt_first,
                         alen = ALIGN(len, c->min_io_size);
                         set_ltab(c, lnum, c->leb_size - alen, alen - len);
                         memset(p, 0xff, alen - len);
-                        err = ubifs_leb_change(c, lnum++, buf, alen,
-                                               UBI_SHORTTERM);
+                        err = ubifs_leb_change(c, lnum++, buf, alen);
                         if (err)
                                 goto out;
                         p = buf;
@@ -806,7 +803,7 @@ int ubifs_create_dflt_lpt(struct ubifs_info *c, int *main_lebs, int lpt_first,
                 alen = ALIGN(len, c->min_io_size);
                 set_ltab(c, lnum, c->leb_size - alen, alen - len);
                 memset(p, 0xff, alen - len);
-                err = ubifs_leb_change(c, lnum++, buf, alen, UBI_SHORTTERM);
+                err = ubifs_leb_change(c, lnum++, buf, alen);
                 if (err)
                         goto out;
                 p = buf;
@@ -826,7 +823,7 @@ int ubifs_create_dflt_lpt(struct ubifs_info *c, int *main_lebs, int lpt_first,
 
         /* Write remaining buffer */
         memset(p, 0xff, alen - len);
-        err = ubifs_leb_change(c, lnum, buf, alen, UBI_SHORTTERM);
+        err = ubifs_leb_change(c, lnum, buf, alen);
         if (err)
                 goto out;
 
diff --git a/fs/ubifs/lpt_commit.c b/fs/ubifs/lpt_commit.c
index 862c4ca98b85..4fa70734e6e7 100644
--- a/fs/ubifs/lpt_commit.c
+++ b/fs/ubifs/lpt_commit.c
@@ -416,7 +416,7 @@ static int write_cnodes(struct ubifs_info *c)
                                 alen = ALIGN(wlen, c->min_io_size);
                                 memset(buf + offs, 0xff, alen - wlen);
                                 err = ubifs_leb_write(c, lnum, buf + from, from,
-                                                       alen, UBI_SHORTTERM);
+                                                       alen);
                                 if (err)
                                         return err;
                         }
@@ -474,8 +474,7 @@ static int write_cnodes(struct ubifs_info *c)
                         wlen = offs - from;
                         alen = ALIGN(wlen, c->min_io_size);
                         memset(buf + offs, 0xff, alen - wlen);
-                        err = ubifs_leb_write(c, lnum, buf + from, from, alen,
-                                              UBI_SHORTTERM);
+                        err = ubifs_leb_write(c, lnum, buf + from, from, alen);
                         if (err)
                                 return err;
                         dbg_chk_lpt_sz(c, 2, c->leb_size - offs);
@@ -501,8 +500,7 @@ static int write_cnodes(struct ubifs_info *c)
                         wlen = offs - from;
                         alen = ALIGN(wlen, c->min_io_size);
                         memset(buf + offs, 0xff, alen - wlen);
-                        err = ubifs_leb_write(c, lnum, buf + from, from, alen,
-                                              UBI_SHORTTERM);
+                        err = ubifs_leb_write(c, lnum, buf + from, from, alen);
                         if (err)
                                 return err;
                         dbg_chk_lpt_sz(c, 2, c->leb_size - offs);
@@ -526,7 +524,7 @@ static int write_cnodes(struct ubifs_info *c)
         wlen = offs - from;
         alen = ALIGN(wlen, c->min_io_size);
         memset(buf + offs, 0xff, alen - wlen);
-        err = ubifs_leb_write(c, lnum, buf + from, from, alen, UBI_SHORTTERM);
+        err = ubifs_leb_write(c, lnum, buf + from, from, alen);
         if (err)
                 return err;
 
diff --git a/fs/ubifs/master.c b/fs/ubifs/master.c
index 9fc282984f94..ab83ace9910a 100644
--- a/fs/ubifs/master.c
+++ b/fs/ubifs/master.c
@@ -379,7 +379,7 @@ int ubifs_write_master(struct ubifs_info *c)
         c->mst_offs = offs;
         c->mst_node->highest_inum = cpu_to_le64(c->highest_inum);
 
-        err = ubifs_write_node(c, c->mst_node, len, lnum, offs, UBI_SHORTTERM);
+        err = ubifs_write_node(c, c->mst_node, len, lnum, offs);
         if (err)
                 return err;
 
@@ -390,7 +390,7 @@ int ubifs_write_master(struct ubifs_info *c)
                 if (err)
                         return err;
         }
-        err = ubifs_write_node(c, c->mst_node, len, lnum, offs, UBI_SHORTTERM);
+        err = ubifs_write_node(c, c->mst_node, len, lnum, offs);
 
         return err;
 }
diff --git a/fs/ubifs/orphan.c b/fs/ubifs/orphan.c
index 95155cc18084..b02734db187c 100644
--- a/fs/ubifs/orphan.c
+++ b/fs/ubifs/orphan.c
@@ -244,8 +244,7 @@ static int do_write_orph_node(struct ubifs_info *c, int len, int atomic)
                 ubifs_assert(c->ohead_offs == 0);
                 ubifs_prepare_node(c, c->orph_buf, len, 1);
                 len = ALIGN(len, c->min_io_size);
-                err = ubifs_leb_change(c, c->ohead_lnum, c->orph_buf, len,
-                                       UBI_SHORTTERM);
+                err = ubifs_leb_change(c, c->ohead_lnum, c->orph_buf, len);
         } else {
                 if (c->ohead_offs == 0) {
                         /* Ensure LEB has been unmapped */
@@ -254,7 +253,7 @@ static int do_write_orph_node(struct ubifs_info *c, int len, int atomic)
                                 return err;
                 }
                 err = ubifs_write_node(c, c->orph_buf, len, c->ohead_lnum,
-                                       c->ohead_offs, UBI_SHORTTERM);
+                                       c->ohead_offs);
         }
         return err;
 }
diff --git a/fs/ubifs/recovery.c b/fs/ubifs/recovery.c
index 01a348dd4587..c30d976b4be8 100644
--- a/fs/ubifs/recovery.c
+++ b/fs/ubifs/recovery.c
@@ -213,10 +213,10 @@ static int write_rcvrd_mst_node(struct ubifs_info *c,
         mst->flags |= cpu_to_le32(UBIFS_MST_RCVRY);
 
         ubifs_prepare_node(c, mst, UBIFS_MST_NODE_SZ, 1);
-        err = ubifs_leb_change(c, lnum, mst, sz, UBI_SHORTTERM);
+        err = ubifs_leb_change(c, lnum, mst, sz);
         if (err)
                 goto out;
-        err = ubifs_leb_change(c, lnum + 1, mst, sz, UBI_SHORTTERM);
+        err = ubifs_leb_change(c, lnum + 1, mst, sz);
         if (err)
                 goto out;
 out:
@@ -555,8 +555,7 @@ static int fix_unclean_leb(struct ubifs_info *c, struct ubifs_scan_leb *sleb,
                                         ubifs_pad(c, buf, pad_len);
                                 }
                         }
-                        err = ubifs_leb_change(c, lnum, sleb->buf, len,
-                                               UBI_UNKNOWN);
+                        err = ubifs_leb_change(c, lnum, sleb->buf, len);
                         if (err)
                                 return err;
                 }
@@ -941,7 +940,7 @@ static int recover_head(struct ubifs_info *c, int lnum, int offs, void *sbuf)
                 err = ubifs_leb_read(c, lnum, sbuf, 0, offs, 1);
                 if (err)
                         return err;
-                return ubifs_leb_change(c, lnum, sbuf, offs, UBI_UNKNOWN);
+                return ubifs_leb_change(c, lnum, sbuf, offs);
         }
 
         return 0;
@@ -1071,7 +1070,7 @@ static int clean_an_unclean_leb(struct ubifs_info *c,
         }
 
         /* Write back the LEB atomically */
-        err = ubifs_leb_change(c, lnum, sbuf, len, UBI_UNKNOWN);
+        err = ubifs_leb_change(c, lnum, sbuf, len);
         if (err)
                 return err;
 
@@ -1472,7 +1471,7 @@ static int fix_size_in_place(struct ubifs_info *c, struct size_entry *e)
                 len -= 1;
         len = ALIGN(len + 1, c->min_io_size);
         /* Atomically write the fixed LEB back again */
-        err = ubifs_leb_change(c, lnum, c->sbuf, len, UBI_UNKNOWN);
+        err = ubifs_leb_change(c, lnum, c->sbuf, len);
         if (err)
                 goto out;
         dbg_rcvry("inode %lu at %d:%d size %lld -> %lld",
diff --git a/fs/ubifs/replay.c b/fs/ubifs/replay.c
index 2a2e3ee720fe..3a2da7e476e5 100644
--- a/fs/ubifs/replay.c
+++ b/fs/ubifs/replay.c
@@ -154,8 +154,7 @@ static int set_bud_lprops(struct ubifs_info *c, struct bud_entry *b)
 
         /* Make sure the journal head points to the latest bud */
         err = ubifs_wbuf_seek_nolock(&c->jheads[b->bud->jhead].wbuf,
-                                     b->bud->lnum, c->leb_size - b->free,
-                                     UBI_SHORTTERM);
+                                     b->bud->lnum, c->leb_size - b->free);
 
 out:
         ubifs_release_lprops(c);
diff --git a/fs/ubifs/sb.c b/fs/ubifs/sb.c
index a880d0c152e5..ef3d1ba6d992 100644
--- a/fs/ubifs/sb.c
+++ b/fs/ubifs/sb.c
@@ -194,7 +194,7 @@ static int create_default_filesystem(struct ubifs_info *c)
         sup->rp_size = cpu_to_le64(tmp64);
         sup->ro_compat_version = cpu_to_le32(UBIFS_RO_COMPAT_VERSION);
 
-        err = ubifs_write_node(c, sup, UBIFS_SB_NODE_SZ, 0, 0, UBI_LONGTERM);
+        err = ubifs_write_node(c, sup, UBIFS_SB_NODE_SZ, 0, 0);
         kfree(sup);
         if (err)
                 return err;
@@ -250,14 +250,13 @@ static int create_default_filesystem(struct ubifs_info *c)
 
         mst->total_used = cpu_to_le64(UBIFS_INO_NODE_SZ);
 
-        err = ubifs_write_node(c, mst, UBIFS_MST_NODE_SZ, UBIFS_MST_LNUM, 0,
-                               UBI_UNKNOWN);
+        err = ubifs_write_node(c, mst, UBIFS_MST_NODE_SZ, UBIFS_MST_LNUM, 0);
         if (err) {
                 kfree(mst);
                 return err;
         }
-        err = ubifs_write_node(c, mst, UBIFS_MST_NODE_SZ, UBIFS_MST_LNUM + 1, 0,
-                               UBI_UNKNOWN);
+        err = ubifs_write_node(c, mst, UBIFS_MST_NODE_SZ, UBIFS_MST_LNUM + 1,
+                               0);
         kfree(mst);
         if (err)
                 return err;
@@ -280,8 +279,7 @@ static int create_default_filesystem(struct ubifs_info *c)
         key_write_idx(c, &key, &br->key);
         br->lnum = cpu_to_le32(main_first + DEFAULT_DATA_LEB);
         br->len  = cpu_to_le32(UBIFS_INO_NODE_SZ);
-        err = ubifs_write_node(c, idx, tmp, main_first + DEFAULT_IDX_LEB, 0,
-                               UBI_UNKNOWN);
+        err = ubifs_write_node(c, idx, tmp, main_first + DEFAULT_IDX_LEB, 0);
         kfree(idx);
         if (err)
                 return err;
@@ -313,8 +311,7 @@ static int create_default_filesystem(struct ubifs_info *c)
         ino->flags = cpu_to_le32(UBIFS_COMPR_FL);
 
         err = ubifs_write_node(c, ino, UBIFS_INO_NODE_SZ,
-                               main_first + DEFAULT_DATA_LEB, 0,
-                               UBI_UNKNOWN);
+                               main_first + DEFAULT_DATA_LEB, 0);
         kfree(ino);
         if (err)
                 return err;
@@ -333,8 +330,7 @@ static int create_default_filesystem(struct ubifs_info *c)
                 return -ENOMEM;
 
         cs->ch.node_type = UBIFS_CS_NODE;
-        err = ubifs_write_node(c, cs, UBIFS_CS_NODE_SZ, UBIFS_LOG_LNUM,
-                               0, UBI_UNKNOWN);
+        err = ubifs_write_node(c, cs, UBIFS_CS_NODE_SZ, UBIFS_LOG_LNUM, 0);
         kfree(cs);
 
         ubifs_msg("default file-system created");
@@ -516,7 +512,7 @@ int ubifs_write_sb_node(struct ubifs_info *c, struct ubifs_sb_node *sup)
         int len = ALIGN(UBIFS_SB_NODE_SZ, c->min_io_size);
 
         ubifs_prepare_node(c, sup, UBIFS_SB_NODE_SZ, 1);
-        return ubifs_leb_change(c, UBIFS_SB_LNUM, sup, len, UBI_LONGTERM);
+        return ubifs_leb_change(c, UBIFS_SB_LNUM, sup, len);
 }
 
 /**
@@ -689,7 +685,7 @@ static int fixup_leb(struct ubifs_info *c, int lnum, int len)
         if (err)
                 return err;
 
-        return ubifs_leb_change(c, lnum, c->sbuf, len, UBI_UNKNOWN);
+        return ubifs_leb_change(c, lnum, c->sbuf, len);
 }
 
 /**
diff --git a/fs/ubifs/super.c b/fs/ubifs/super.c
index 675b781b4699..d7cbf7aabdb7 100644
--- a/fs/ubifs/super.c
+++ b/fs/ubifs/super.c
@@ -813,13 +813,11 @@ static int alloc_wbufs(struct ubifs_info *c)
                 c->jheads[i].grouped = 1;
         }
 
-        c->jheads[BASEHD].wbuf.dtype = UBI_SHORTTERM;
         /*
          * Garbage Collector head likely contains long-term data and
          * does not need to be synchronized by timer. Also GC head nodes are
          * not grouped.
          */
-        c->jheads[GCHD].wbuf.dtype = UBI_LONGTERM;
         c->jheads[GCHD].wbuf.no_timer = 1;
         c->jheads[GCHD].grouped = 0;
 
diff --git a/fs/ubifs/tnc_commit.c b/fs/ubifs/tnc_commit.c
index ef5df1e24dca..523bbad69c0c 100644
--- a/fs/ubifs/tnc_commit.c
+++ b/fs/ubifs/tnc_commit.c
@@ -320,8 +320,7 @@ static int layout_leb_in_gaps(struct ubifs_info *c, int *p)
                                   0, 0, 0);
         if (err)
                 return err;
-        err = ubifs_leb_change(c, lnum, c->ileb_buf, c->ileb_len,
-                               UBI_SHORTTERM);
+        err = ubifs_leb_change(c, lnum, c->ileb_buf, c->ileb_len);
         if (err)
                 return err;
         dbg_gc("LEB %d wrote %d index nodes", lnum, tot_written);
@@ -951,8 +950,7 @@ static int write_index(struct ubifs_info *c)
                 }
 
                 /* The buffer is full or there are no more znodes to do */
-                err = ubifs_leb_write(c, lnum, c->cbuf, buf_offs, blen,
-                                      UBI_SHORTTERM);
+                err = ubifs_leb_write(c, lnum, c->cbuf, buf_offs, blen);
                 if (err)
                         return err;
                 buf_offs += blen;
diff --git a/fs/ubifs/ubifs.h b/fs/ubifs/ubifs.h
index c2cf509e14db..1e5a08623d11 100644
--- a/fs/ubifs/ubifs.h
+++ b/fs/ubifs/ubifs.h
@@ -650,8 +650,6 @@ typedef int (*ubifs_lpt_scan_callback)(struct ubifs_info *c,
  * @avail: number of bytes available in the write-buffer
  * @used:  number of used bytes in the write-buffer
  * @size: write-buffer size (in [@c->min_io_size, @c->max_write_size] range)
- * @dtype: type of data stored in this LEB (%UBI_LONGTERM, %UBI_SHORTTERM,
- * %UBI_UNKNOWN)
  * @jhead: journal head the mutex belongs to (note, needed only to shut lockdep
  *         up by 'mutex_lock_nested()).
  * @sync_callback: write-buffer synchronization callback
@@ -685,7 +683,6 @@ struct ubifs_wbuf {
         int avail;
         int used;
         int size;
-        int dtype;
         int jhead;
         int (*sync_callback)(struct ubifs_info *c, int lnum, int free, int pad);
         struct mutex io_mutex;
@@ -1469,22 +1466,20 @@ void ubifs_ro_mode(struct ubifs_info *c, int err);
 int ubifs_leb_read(const struct ubifs_info *c, int lnum, void *buf, int offs,
                    int len, int even_ebadmsg);
 int ubifs_leb_write(struct ubifs_info *c, int lnum, const void *buf, int offs,
-                    int len, int dtype);
-int ubifs_leb_change(struct ubifs_info *c, int lnum, const void *buf, int len,
-                     int dtype);
+                    int len);
+int ubifs_leb_change(struct ubifs_info *c, int lnum, const void *buf, int len);
 int ubifs_leb_unmap(struct ubifs_info *c, int lnum);
-int ubifs_leb_map(struct ubifs_info *c, int lnum, int dtype);
+int ubifs_leb_map(struct ubifs_info *c, int lnum);
 int ubifs_is_mapped(const struct ubifs_info *c, int lnum);
 int ubifs_wbuf_write_nolock(struct ubifs_wbuf *wbuf, void *buf, int len);
-int ubifs_wbuf_seek_nolock(struct ubifs_wbuf *wbuf, int lnum, int offs,
-                           int dtype);
+int ubifs_wbuf_seek_nolock(struct ubifs_wbuf *wbuf, int lnum, int offs);
 int ubifs_wbuf_init(struct ubifs_info *c, struct ubifs_wbuf *wbuf);
 int ubifs_read_node(const struct ubifs_info *c, void *buf, int type, int len,
                     int lnum, int offs);
 int ubifs_read_node_wbuf(struct ubifs_wbuf *wbuf, void *buf, int type, int len,
                          int lnum, int offs);
 int ubifs_write_node(struct ubifs_info *c, void *node, int len, int lnum,
-                     int offs, int dtype);
+                     int offs);
 int ubifs_check_node(const struct ubifs_info *c, const void *buf, int lnum,
                      int offs, int quiet, int must_chk_crc);
 void ubifs_prepare_node(struct ubifs_info *c, void *buf, int len, int pad);