1 files changed, 173 insertions, 148 deletions

diff --git a/drivers/mtd/ubi/eba.c b/drivers/mtd/ubi/eba.c
index 880fa3690352..7ce91ca742b1 100644
--- a/drivers/mtd/ubi/eba.c
+++ b/drivers/mtd/ubi/eba.c
@@ -31,7 +31,7 @@
  * logical eraseblock it is locked for reading or writing. The per-logical
  * eraseblock locking is implemented by means of the lock tree. The lock tree
  * is an RB-tree which refers all the currently locked logical eraseblocks. The
- * lock tree elements are &struct ltree_entry objects. They are indexed by
+ * lock tree elements are &struct ubi_ltree_entry objects. They are indexed by
  * (@vol_id, @lnum) pairs.
  *
  * EBA also maintains the global sequence counter which is incremented each
@@ -50,29 +50,6 @@
 #define EBA_RESERVED_PEBS 1
 
 /**
- * struct ltree_entry - an entry in the lock tree.
- * @rb: links RB-tree nodes
- * @vol_id: volume ID of the locked logical eraseblock
- * @lnum: locked logical eraseblock number
- * @users: how many tasks are using this logical eraseblock or wait for it
- * @mutex: read/write mutex to implement read/write access serialization to
- * the (@vol_id, @lnum) logical eraseblock
- *
- * When a logical eraseblock is being locked - corresponding &struct ltree_entry
- * object is inserted to the lock tree (@ubi->ltree).
- */
-struct ltree_entry {
-        struct rb_node rb;
-        int vol_id;
-        int lnum;
-        int users;
-        struct rw_semaphore mutex;
-};
-
-/* Slab cache for lock-tree entries */
-static struct kmem_cache *ltree_slab;
-
-/**
  * next_sqnum - get next sequence number.
  * @ubi: UBI device description object
  *
@@ -101,7 +78,7 @@ static unsigned long long next_sqnum(struct ubi_device *ubi)
  */
 static int ubi_get_compat(const struct ubi_device *ubi, int vol_id)
 {
-        if (vol_id == UBI_LAYOUT_VOL_ID)
+        if (vol_id == UBI_LAYOUT_VOLUME_ID)
                 return UBI_LAYOUT_VOLUME_COMPAT;
         return 0;
 }
@@ -112,20 +89,20 @@ static int ubi_get_compat(const struct ubi_device *ubi, int vol_id)
  * @vol_id: volume ID
  * @lnum: logical eraseblock number
  *
- * This function returns a pointer to the corresponding &struct ltree_entry
+ * This function returns a pointer to the corresponding &struct ubi_ltree_entry
  * object if the logical eraseblock is locked and %NULL if it is not.
  * @ubi->ltree_lock has to be locked.
  */
-static struct ltree_entry *ltree_lookup(struct ubi_device *ubi, int vol_id,
-                                        int lnum)
+static struct ubi_ltree_entry *ltree_lookup(struct ubi_device *ubi, int vol_id,
+                                            int lnum)
 {
         struct rb_node *p;
 
         p = ubi->ltree.rb_node;
         while (p) {
-                struct ltree_entry *le;
+                struct ubi_ltree_entry *le;
 
-                le = rb_entry(p, struct ltree_entry, rb);
+                le = rb_entry(p, struct ubi_ltree_entry, rb);
 
                 if (vol_id < le->vol_id)
                         p = p->rb_left;
@@ -155,15 +132,17 @@ static struct ltree_entry *ltree_lookup(struct ubi_device *ubi, int vol_id,
  * Returns pointer to the lock tree entry or %-ENOMEM if memory allocation
  * failed.
  */
-static struct ltree_entry *ltree_add_entry(struct ubi_device *ubi, int vol_id,
-                                           int lnum)
+static struct ubi_ltree_entry *ltree_add_entry(struct ubi_device *ubi,
+                                               int vol_id, int lnum)
 {
-        struct ltree_entry *le, *le1, *le_free;
+        struct ubi_ltree_entry *le, *le1, *le_free;
 
-        le = kmem_cache_alloc(ltree_slab, GFP_NOFS);
+        le = kmalloc(sizeof(struct ubi_ltree_entry), GFP_NOFS);
         if (!le)
                 return ERR_PTR(-ENOMEM);
 
+        le->users = 0;
+        init_rwsem(&le->mutex);
         le->vol_id = vol_id;
         le->lnum = lnum;
 
@@ -189,7 +168,7 @@ static struct ltree_entry *ltree_add_entry(struct ubi_device *ubi, int vol_id,
                 p = &ubi->ltree.rb_node;
                 while (*p) {
                         parent = *p;
-                        le1 = rb_entry(parent, struct ltree_entry, rb);
+                        le1 = rb_entry(parent, struct ubi_ltree_entry, rb);
 
                         if (vol_id < le1->vol_id)
                                 p = &(*p)->rb_left;
@@ -211,7 +190,7 @@ static struct ltree_entry *ltree_add_entry(struct ubi_device *ubi, int vol_id,
         spin_unlock(&ubi->ltree_lock);
 
         if (le_free)
-                kmem_cache_free(ltree_slab, le_free);
+                kfree(le_free);
 
         return le;
 }
@@ -227,7 +206,7 @@ static struct ltree_entry *ltree_add_entry(struct ubi_device *ubi, int vol_id,
  */
 static int leb_read_lock(struct ubi_device *ubi, int vol_id, int lnum)
 {
-        struct ltree_entry *le;
+        struct ubi_ltree_entry *le;
 
         le = ltree_add_entry(ubi, vol_id, lnum);
         if (IS_ERR(le))
@@ -245,7 +224,7 @@ static int leb_read_lock(struct ubi_device *ubi, int vol_id, int lnum)
 static void leb_read_unlock(struct ubi_device *ubi, int vol_id, int lnum)
 {
         int free = 0;
-        struct ltree_entry *le;
+        struct ubi_ltree_entry *le;
 
         spin_lock(&ubi->ltree_lock);
         le = ltree_lookup(ubi, vol_id, lnum);
@@ -259,7 +238,7 @@ static void leb_read_unlock(struct ubi_device *ubi, int vol_id, int lnum)
 
         up_read(&le->mutex);
         if (free)
-                kmem_cache_free(ltree_slab, le);
+                kfree(le);
 }
 
 /**
@@ -273,7 +252,7 @@ static void leb_read_unlock(struct ubi_device *ubi, int vol_id, int lnum)
  */
 static int leb_write_lock(struct ubi_device *ubi, int vol_id, int lnum)
 {
-        struct ltree_entry *le;
+        struct ubi_ltree_entry *le;
 
         le = ltree_add_entry(ubi, vol_id, lnum);
         if (IS_ERR(le))
@@ -283,6 +262,44 @@ static int leb_write_lock(struct ubi_device *ubi, int vol_id, int lnum)
 }
 
 /**
+ * leb_write_lock - lock logical eraseblock for writing.
+ * @ubi: UBI device description object
+ * @vol_id: volume ID
+ * @lnum: logical eraseblock number
+ *
+ * This function locks a logical eraseblock for writing if there is no
+ * contention and does nothing if there is contention. Returns %0 in case of
+ * success, %1 in case of contention, and and a negative error code in case of
+ * failure.
+ */
+static int leb_write_trylock(struct ubi_device *ubi, int vol_id, int lnum)
+{
+        int free;
+        struct ubi_ltree_entry *le;
+
+        le = ltree_add_entry(ubi, vol_id, lnum);
+        if (IS_ERR(le))
+                return PTR_ERR(le);
+        if (down_write_trylock(&le->mutex))
+                return 0;
+
+        /* Contention, cancel */
+        spin_lock(&ubi->ltree_lock);
+        le->users -= 1;
+        ubi_assert(le->users >= 0);
+        if (le->users == 0) {
+                rb_erase(&le->rb, &ubi->ltree);
+                free = 1;
+        } else
+                free = 0;
+        spin_unlock(&ubi->ltree_lock);
+        if (free)
+                kfree(le);
+
+        return 1;
+}
+
+/**
  * leb_write_unlock - unlock logical eraseblock.
  * @ubi: UBI device description object
  * @vol_id: volume ID
@@ -291,7 +308,7 @@ static int leb_write_lock(struct ubi_device *ubi, int vol_id, int lnum)
 static void leb_write_unlock(struct ubi_device *ubi, int vol_id, int lnum)
 {
         int free;
-        struct ltree_entry *le;
+        struct ubi_ltree_entry *le;
 
         spin_lock(&ubi->ltree_lock);
         le = ltree_lookup(ubi, vol_id, lnum);
@@ -306,23 +323,23 @@ static void leb_write_unlock(struct ubi_device *ubi, int vol_id, int lnum)
 
         up_write(&le->mutex);
         if (free)
-                kmem_cache_free(ltree_slab, le);
+                kfree(le);
 }
 
 /**
  * ubi_eba_unmap_leb - un-map logical eraseblock.
  * @ubi: UBI device description object
- * @vol_id: volume ID
+ * @vol: volume description object
  * @lnum: logical eraseblock number
  *
  * This function un-maps logical eraseblock @lnum and schedules corresponding
  * physical eraseblock for erasure. Returns zero in case of success and a
  * negative error code in case of failure.
  */
-int ubi_eba_unmap_leb(struct ubi_device *ubi, int vol_id, int lnum)
+int ubi_eba_unmap_leb(struct ubi_device *ubi, struct ubi_volume *vol,
+                      int lnum)
 {
-        int idx = vol_id2idx(ubi, vol_id), err, pnum;
-        struct ubi_volume *vol = ubi->volumes[idx];
+        int err, pnum, vol_id = vol->vol_id;
 
         if (ubi->ro_mode)
                 return -EROFS;
@@ -349,7 +366,7 @@ out_unlock:
 /**
  * ubi_eba_read_leb - read data.
  * @ubi: UBI device description object
- * @vol_id: volume ID
+ * @vol: volume description object
  * @lnum: logical eraseblock number
  * @buf: buffer to store the read data
  * @offset: offset from where to read
@@ -365,12 +382,11 @@ out_unlock:
  * returned for any volume type if an ECC error was detected by the MTD device
  * driver. Other negative error cored may be returned in case of other errors.
  */
-int ubi_eba_read_leb(struct ubi_device *ubi, int vol_id, int lnum, void *buf,
-                     int offset, int len, int check)
+int ubi_eba_read_leb(struct ubi_device *ubi, struct ubi_volume *vol, int lnum,
+                     void *buf, int offset, int len, int check)
 {
-        int err, pnum, scrub = 0, idx = vol_id2idx(ubi, vol_id);
+        int err, pnum, scrub = 0, vol_id = vol->vol_id;
         struct ubi_vid_hdr *vid_hdr;
-        struct ubi_volume *vol = ubi->volumes[idx];
         uint32_t uninitialized_var(crc);
 
         err = leb_read_lock(ubi, vol_id, lnum);
@@ -578,7 +594,7 @@ write_error:
 /**
  * ubi_eba_write_leb - write data to dynamic volume.
  * @ubi: UBI device description object
- * @vol_id: volume ID
+ * @vol: volume description object
  * @lnum: logical eraseblock number
  * @buf: the data to write
  * @offset: offset within the logical eraseblock where to write
@@ -586,15 +602,14 @@ write_error:
  * @dtype: data type
  *
  * This function writes data to logical eraseblock @lnum of a dynamic volume
- * @vol_id. Returns zero in case of success and a negative error code in case
+ * @vol. Returns zero in case of success and a negative error code in case
  * of failure. In case of error, it is possible that something was still
  * written to the flash media, but may be some garbage.
  */
-int ubi_eba_write_leb(struct ubi_device *ubi, int vol_id, int lnum,
+int ubi_eba_write_leb(struct ubi_device *ubi, struct ubi_volume *vol, int lnum,
                       const void *buf, int offset, int len, int dtype)
 {
-        int idx = vol_id2idx(ubi, vol_id), err, pnum, tries = 0;
-        struct ubi_volume *vol = ubi->volumes[idx];
+        int err, pnum, tries = 0, vol_id = vol->vol_id;
         struct ubi_vid_hdr *vid_hdr;
 
         if (ubi->ro_mode)
@@ -613,7 +628,8 @@ int ubi_eba_write_leb(struct ubi_device *ubi, int vol_id, int lnum,
                 if (err) {
                         ubi_warn("failed to write data to PEB %d", pnum);
                         if (err == -EIO && ubi->bad_allowed)
-                                err = recover_peb(ubi, pnum, vol_id, lnum, buf, offset, len);
+                                err = recover_peb(ubi, pnum, vol_id, lnum, buf,
+                                                  offset, len);
                         if (err)
                                 ubi_ro_mode(ubi);
                 }
@@ -656,11 +672,14 @@ retry:
                 goto write_error;
         }
 
-        err = ubi_io_write_data(ubi, buf, pnum, offset, len);
-        if (err) {
-                ubi_warn("failed to write %d bytes at offset %d of LEB %d:%d, "
-                         "PEB %d", len, offset, vol_id, lnum, pnum);
-                goto write_error;
+        if (len) {
+                err = ubi_io_write_data(ubi, buf, pnum, offset, len);
+                if (err) {
+                        ubi_warn("failed to write %d bytes at offset %d of "
+                                 "LEB %d:%d, PEB %d", len, offset, vol_id,
+                                 lnum, pnum);
+                        goto write_error;
+                }
         }
 
         vol->eba_tbl[lnum] = pnum;
@@ -698,7 +717,7 @@ write_error:
 /**
  * ubi_eba_write_leb_st - write data to static volume.
  * @ubi: UBI device description object
- * @vol_id: volume ID
+ * @vol: volume description object
  * @lnum: logical eraseblock number
  * @buf: data to write
  * @len: how many bytes to write
@@ -706,7 +725,7 @@ write_error:
  * @used_ebs: how many logical eraseblocks will this volume contain
  *
  * This function writes data to logical eraseblock @lnum of static volume
- * @vol_id. The @used_ebs argument should contain total number of logical
+ * @vol. The @used_ebs argument should contain total number of logical
  * eraseblock in this static volume.
  *
  * When writing to the last logical eraseblock, the @len argument doesn't have
@@ -718,12 +737,11 @@ write_error:
  * volumes. This function returns zero in case of success and a negative error
  * code in case of failure.
  */
-int ubi_eba_write_leb_st(struct ubi_device *ubi, int vol_id, int lnum,
-                         const void *buf, int len, int dtype, int used_ebs)
+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 err, pnum, tries = 0, data_size = len;
-        int idx = vol_id2idx(ubi, vol_id);
-        struct ubi_volume *vol = ubi->volumes[idx];
+        int err, pnum, tries = 0, data_size = len, vol_id = vol->vol_id;
         struct ubi_vid_hdr *vid_hdr;
         uint32_t crc;
 
@@ -819,7 +837,7 @@ write_error:
 /*
  * ubi_eba_atomic_leb_change - change logical eraseblock atomically.
  * @ubi: UBI device description object
- * @vol_id: volume ID
+ * @vol: volume description object
  * @lnum: logical eraseblock number
  * @buf: data to write
  * @len: how many bytes to write
@@ -834,17 +852,27 @@ write_error:
  * UBI reserves one LEB for the "atomic LEB change" operation, so only one
  * 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, int vol_id, int lnum,
-                              const void *buf, int len, int dtype)
+int ubi_eba_atomic_leb_change(struct ubi_device *ubi, struct ubi_volume *vol,
+                              int lnum, const void *buf, int len, int dtype)
 {
-        int err, pnum, tries = 0, idx = vol_id2idx(ubi, vol_id);
-        struct ubi_volume *vol = ubi->volumes[idx];
+        int err, pnum, tries = 0, vol_id = vol->vol_id;
         struct ubi_vid_hdr *vid_hdr;
         uint32_t crc;
 
         if (ubi->ro_mode)
                 return -EROFS;
 
+        if (len == 0) {
+                /*
+                 * Special case when data length is zero. In this case the LEB
+                 * has to be unmapped and mapped somewhere else.
+                 */
+                err = ubi_eba_unmap_leb(ubi, vol, lnum);
+                if (err)
+                        return err;
+                return ubi_eba_write_leb(ubi, vol, lnum, NULL, 0, 0, dtype);
+        }
+
         vid_hdr = ubi_zalloc_vid_hdr(ubi, GFP_NOFS);
         if (!vid_hdr)
                 return -ENOMEM;
@@ -928,20 +956,6 @@ write_error:
 }
 
 /**
- * ltree_entry_ctor - lock tree entries slab cache constructor.
- * @obj: the lock-tree entry to construct
- * @cache: the lock tree entry slab cache
- * @flags: constructor flags
- */
-static void ltree_entry_ctor(struct kmem_cache *cache, void *obj)
-{
-        struct ltree_entry *le = obj;
-
-        le->users = 0;
-        init_rwsem(&le->mutex);
-}
-
-/**
  * ubi_eba_copy_leb - copy logical eraseblock.
  * @ubi: UBI device description object
  * @from: physical eraseblock number from where to copy
@@ -950,14 +964,16 @@ static void ltree_entry_ctor(struct kmem_cache *cache, void *obj)
  *
  * This function copies logical eraseblock from physical eraseblock @from to
  * physical eraseblock @to. The @vid_hdr buffer may be changed by this
- * function. Returns zero in case of success, %UBI_IO_BITFLIPS if the operation
- * was canceled because bit-flips were detected at the target PEB, and a
- * negative error code in case of failure.
+ * function. Returns:
+ *   o %0  in case of success;
+ *   o %1 if the operation was canceled and should be tried later (e.g.,
+ *     because a bit-flip was detected at the target PEB);
+ *   o %2 if the volume is being deleted and this LEB should not be moved.
  */
 int ubi_eba_copy_leb(struct ubi_device *ubi, int from, int to,
                      struct ubi_vid_hdr *vid_hdr)
 {
-        int err, vol_id, lnum, data_size, aldata_size, pnum, idx;
+        int err, vol_id, lnum, data_size, aldata_size, idx;
         struct ubi_volume *vol;
         uint32_t crc;
 
@@ -973,51 +989,67 @@ int ubi_eba_copy_leb(struct ubi_device *ubi, int from, int to,
                 data_size = aldata_size =
                             ubi->leb_size - be32_to_cpu(vid_hdr->data_pad);
 
-        /*
-         * We do not want anybody to write to this logical eraseblock while we
-         * are moving it, so we lock it.
-         */
-        err = leb_write_lock(ubi, vol_id, lnum);
-        if (err)
-                return err;
-
-        mutex_lock(&ubi->buf_mutex);
-
-        /*
-         * But the logical eraseblock might have been put by this time.
-         * Cancel if it is true.
-         */
         idx = vol_id2idx(ubi, vol_id);
-
+        spin_lock(&ubi->volumes_lock);
         /*
-         * We may race with volume deletion/re-size, so we have to hold
-         * @ubi->volumes_lock.
+         * Note, we may race with volume deletion, which means that the volume
+         * this logical eraseblock belongs to might be being deleted. Since the
+         * volume deletion unmaps all the volume's logical eraseblocks, it will
+         * be locked in 'ubi_wl_put_peb()' and wait for the WL worker to finish.
          */
-        spin_lock(&ubi->volumes_lock);
         vol = ubi->volumes[idx];
         if (!vol) {
-                dbg_eba("volume %d was removed meanwhile", vol_id);
+                /* No need to do further work, cancel */
+                dbg_eba("volume %d is being removed, cancel", vol_id);
                 spin_unlock(&ubi->volumes_lock);
-                goto out_unlock;
+                return 2;
         }
+        spin_unlock(&ubi->volumes_lock);
 
-        pnum = vol->eba_tbl[lnum];
-        if (pnum != from) {
-                dbg_eba("LEB %d:%d is no longer mapped to PEB %d, mapped to "
-                        "PEB %d, cancel", vol_id, lnum, from, pnum);
-                spin_unlock(&ubi->volumes_lock);
-                goto out_unlock;
+        /*
+         * We do not want anybody to write to this logical eraseblock while we
+         * are moving it, so lock it.
+         *
+         * Note, we are using non-waiting locking here, because we cannot sleep
+         * on the LEB, since it may cause deadlocks. Indeed, imagine a task is
+         * unmapping the LEB which is mapped to the PEB we are going to move
+         * (@from). This task locks the LEB and goes sleep in the
+         * 'ubi_wl_put_peb()' function on the @ubi->move_mutex. In turn, we are
+         * holding @ubi->move_mutex and go sleep on the LEB lock. So, if the
+         * LEB is already locked, we just do not move it and return %1.
+         */
+        err = leb_write_trylock(ubi, vol_id, lnum);
+        if (err) {
+                dbg_eba("contention on LEB %d:%d, cancel", vol_id, lnum);
+                return err;
         }
-        spin_unlock(&ubi->volumes_lock);
 
-        /* OK, now the LEB is locked and we can safely start moving it */
+        /*
+         * The LEB might have been put meanwhile, and the task which put it is
+         * probably waiting on @ubi->move_mutex. No need to continue the work,
+         * cancel it.
+         */
+        if (vol->eba_tbl[lnum] != from) {
+                dbg_eba("LEB %d:%d is no longer mapped to PEB %d, mapped to "
+                        "PEB %d, cancel", vol_id, lnum, from,
+                        vol->eba_tbl[lnum]);
+                err = 1;
+                goto out_unlock_leb;
+        }
 
+        /*
+         * OK, now the LEB is locked and we can safely start moving iy. Since
+         * this function utilizes thie @ubi->peb1_buf buffer which is shared
+         * with some other functions, so lock the buffer by taking the
+         * @ubi->buf_mutex.
+         */
+        mutex_lock(&ubi->buf_mutex);
         dbg_eba("read %d bytes of data", aldata_size);
         err = ubi_io_read_data(ubi, ubi->peb_buf1, from, 0, aldata_size);
         if (err && err != UBI_IO_BITFLIPS) {
                 ubi_warn("error %d while reading data from PEB %d",
                          err, from);
-                goto out_unlock;
+                goto out_unlock_buf;
         }
 
         /*
@@ -1053,7 +1085,7 @@ int ubi_eba_copy_leb(struct ubi_device *ubi, int from, int to,
 
         err = ubi_io_write_vid_hdr(ubi, to, vid_hdr);
         if (err)
-                goto out_unlock;
+                goto out_unlock_buf;
 
         cond_resched();
 
@@ -1062,13 +1094,15 @@ int ubi_eba_copy_leb(struct ubi_device *ubi, int from, int to,
         if (err) {
                 if (err != UBI_IO_BITFLIPS)
                         ubi_warn("cannot read VID header back from PEB %d", to);
-                goto out_unlock;
+                else
+                        err = 1;
+                goto out_unlock_buf;
         }
 
         if (data_size > 0) {
                 err = ubi_io_write_data(ubi, ubi->peb_buf1, to, 0, aldata_size);
                 if (err)
-                        goto out_unlock;
+                        goto out_unlock_buf;
 
                 cond_resched();
 
@@ -1082,7 +1116,9 @@ int ubi_eba_copy_leb(struct ubi_device *ubi, int from, int to,
                         if (err != UBI_IO_BITFLIPS)
                                 ubi_warn("cannot read data back from PEB %d",
                                          to);
-                        goto out_unlock;
+                        else
+                                err = 1;
+                        goto out_unlock_buf;
                 }
 
                 cond_resched();
@@ -1090,15 +1126,16 @@ int ubi_eba_copy_leb(struct ubi_device *ubi, int from, int to,
                 if (memcmp(ubi->peb_buf1, ubi->peb_buf2, aldata_size)) {
                         ubi_warn("read data back from PEB %d - it is different",
                                  to);
-                        goto out_unlock;
+                        goto out_unlock_buf;
                 }
         }
 
         ubi_assert(vol->eba_tbl[lnum] == from);
         vol->eba_tbl[lnum] = to;
 
-out_unlock:
+out_unlock_buf:
         mutex_unlock(&ubi->buf_mutex);
+out_unlock_leb:
         leb_write_unlock(ubi, vol_id, lnum);
         return err;
 }
@@ -1125,14 +1162,6 @@ int ubi_eba_init_scan(struct ubi_device *ubi, struct ubi_scan_info *si)
         mutex_init(&ubi->alc_mutex);
         ubi->ltree = RB_ROOT;
 
-        if (ubi_devices_cnt == 0) {
-                ltree_slab = kmem_cache_create("ubi_ltree_slab",
-                                               sizeof(struct ltree_entry), 0,
-                                               0, &ltree_entry_ctor);
-                if (!ltree_slab)
-                        return -ENOMEM;
-        }
-
         ubi->global_sqnum = si->max_sqnum + 1;
         num_volumes = ubi->vtbl_slots + UBI_INT_VOL_COUNT;
 
@@ -1168,6 +1197,15 @@ int ubi_eba_init_scan(struct ubi_device *ubi, struct ubi_scan_info *si)
                 }
         }
 
+        if (ubi->avail_pebs < EBA_RESERVED_PEBS) {
+                ubi_err("no enough physical eraseblocks (%d, need %d)",
+                        ubi->avail_pebs, EBA_RESERVED_PEBS);
+                err = -ENOSPC;
+                goto out_free;
+        }
+        ubi->avail_pebs -= EBA_RESERVED_PEBS;
+        ubi->rsvd_pebs += EBA_RESERVED_PEBS;
+
         if (ubi->bad_allowed) {
                 ubi_calculate_reserved(ubi);
 
@@ -1184,15 +1222,6 @@ int ubi_eba_init_scan(struct ubi_device *ubi, struct ubi_scan_info *si)
                 ubi->rsvd_pebs  += ubi->beb_rsvd_pebs;
         }
 
-        if (ubi->avail_pebs < EBA_RESERVED_PEBS) {
-                ubi_err("no enough physical eraseblocks (%d, need %d)",
-                        ubi->avail_pebs, EBA_RESERVED_PEBS);
-                err = -ENOSPC;
-                goto out_free;
-        }
-        ubi->avail_pebs -= EBA_RESERVED_PEBS;
-        ubi->rsvd_pebs += EBA_RESERVED_PEBS;
-
         dbg_eba("EBA unit is initialized");
         return 0;
 
@@ -1202,8 +1231,6 @@ out_free:
                         continue;
                 kfree(ubi->volumes[i]->eba_tbl);
         }
-        if (ubi_devices_cnt == 0)
-                kmem_cache_destroy(ltree_slab);
         return err;
 }
 
@@ -1222,6 +1249,4 @@ void ubi_eba_close(const struct ubi_device *ubi)
                         continue;
                 kfree(ubi->volumes[i]->eba_tbl);
         }
-        if (ubi_devices_cnt == 1)
-                kmem_cache_destroy(ltree_slab);
 }