Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit e9eca4de authored by Linus Torvalds's avatar Linus Torvalds
Browse files

Merge tag 'upstream-3.7-rc1-fastmap' of git://git.infradead.org/linux-ubi 

Pull UBI fastmap changes from Artem Bityutskiy:
 "This pull request contains the UBI fastmap support implemented by
  Richard Weinberger from Linutronix.  Fastmap is designed to address
  UBI's slow scanning issues.  Namely, it introduces a new on-flash
  data-structure called "fastmap", which stores the information about
  logical<->physical eraseblocks mappings.  So now to get this
  information just read the fastmap, instead of doing full scan.  More
  information here can be found in Richard's announcement in LKML
  (Subject: UBI: Fastmap request for inclusion (v19)):

     http://thread.gmane.org/gmane.linux.kernel/1364922/focus=1369109

  One thing I want to explicitly say is that fastmap did not have large
  enough linux-next exposure.  It is partially my fault - I did not
  respond quickly enough.  I _really_ apologize for this.  But it had
  good testing and disabled by default, so I do not expect that we'll
  break anything.

  Fastmap is declared as experimental so far, and it is off by default.
  We did declare that the on-flash format may be changed.  The reason
  for this is that no one used it in real production so far, so there is
  a high risk that something is missing.  Besides, we do not have
  user-space tools supporting fastmap so far.

  Nevertheless, I suggest we merge this feature.  Many people want UBI's
  scanning bottleneck to be fixed and merging fastmap now should
  accelerate its production use.  The plan is to make it bullet-prove,
  somewhat clean-up, and make it the default for UBI.  I do not know how
  many kernel releases will it take.

  Basically, I what I want to do for fastmap is something like Linus did
  for btrfs few years ago."

* tag 'upstream-3.7-rc1-fastmap' of git://git.infradead.org/linux-ubi:
  UBI: Wire-up fastmap
  UBI: Add fastmap core
  UBI: Add fastmap support to the WL sub-system
  UBI: Add fastmap stuff to attach.c
  UBI: Wire-up ->fm_sem
  UBI: Add fastmap bits to build.c
  UBI: Add self_check_eba()
  UBI: Export next_sqnum()
  UBI: Add fastmap stuff to ubi.h
  UBI: Add fastmap on-flash data structures
parents 1929041b 76ac66e4

MAINTAINERS

+6 −0
Original line number Diff line number Diff line
@@ -7457,6 +7457,12 @@ F: drivers/mtd/ubi/ 
F:	include/linux/mtd/ubi.h

F:	include/mtd/ubi-user.h



UNSORTED BLOCK IMAGES (UBI) Fastmap

M:	Richard Weinberger <richard@nod.at>

L:	linux-mtd@lists.infradead.org

S:	Maintained

F:	drivers/mtd/ubi/fastmap.c



USB ACM DRIVER

M:	Oliver Neukum <oliver@neukum.org>

L:	linux-usb@vger.kernel.org

drivers/mtd/ubi/Kconfig

+21 −0
Original line number Diff line number Diff line
@@ -56,6 +56,27 @@ config MTD_UBI_BEB_LIMIT 


	  Leave the default value if unsure.



config MTD_UBI_FASTMAP

	bool "UBI Fastmap (Experimental feature)"

	default n

	help

	   Important: this feature is experimental so far and the on-flash

	   format for fastmap may change in the next kernel versions



	   Fastmap is a mechanism which allows attaching an UBI device

	   in nearly constant time. Instead of scanning the whole MTD device it

	   only has to locate a checkpoint (called fastmap) on the device.

	   The on-flash fastmap contains all information needed to attach

	   the device. Using fastmap makes only sense on large devices where

	   attaching by scanning takes long. UBI will not automatically install

	   a fastmap on old images, but you can set the UBI module parameter

	   fm_autoconvert to 1 if you want so. Please note that fastmap-enabled

	   images are still usable with UBI implementations without

	   fastmap support. On typical flash devices the whole fastmap fits

	   into one PEB. UBI will reserve PEBs to hold two fastmaps.



	   If in doubt, say "N".



config MTD_UBI_GLUEBI

	tristate "MTD devices emulation driver (gluebi)"

	help

drivers/mtd/ubi/Makefile

+1 −0
Original line number Diff line number Diff line
@@ -2,5 +2,6 @@ obj-$(CONFIG_MTD_UBI) += ubi.o 


ubi-y += vtbl.o vmt.o upd.o build.o cdev.o kapi.o eba.o io.o wl.o attach.o

ubi-y += misc.o debug.o

ubi-$(CONFIG_MTD_UBI_FASTMAP) += fastmap.o



obj-$(CONFIG_MTD_UBI_GLUEBI) += gluebi.o

drivers/mtd/ubi/attach.c

+258 −128
Original line number Diff line number Diff line
@@ -300,7 +300,7 @@ static struct ubi_ainf_volume *add_volume(struct ubi_attach_info *ai, 
}



/**

 * compare_lebs - find out which logical eraseblock is newer.

 * ubi_compare_lebs - find out which logical eraseblock is newer.

 * @ubi: UBI device description object

 * @aeb: first logical eraseblock to compare

 * @pnum: physical eraseblock number of the second logical eraseblock to
@@ -319,7 +319,7 @@ static struct ubi_ainf_volume *add_volume(struct ubi_attach_info *ai, 
 *     o bit 2 is cleared: the older LEB is not corrupted;

 *     o bit 2 is set: the older LEB is corrupted.

 */

static int compare_lebs(struct ubi_device *ubi, const struct ubi_ainf_peb *aeb,

int ubi_compare_lebs(struct ubi_device *ubi, const struct ubi_ainf_peb *aeb,

			int pnum, const struct ubi_vid_hdr *vid_hdr)

{

	void *buf;
@@ -337,7 +337,7 @@ static int compare_lebs(struct ubi_device *ubi, const struct ubi_ainf_peb *aeb, 
		 * support these images anymore. Well, those images still work,

		 * but only if no unclean reboots happened.

		 */

		ubi_err("unsupported on-flash UBI format\n");

		ubi_err("unsupported on-flash UBI format");

		return -EINVAL;

	}
@@ -507,7 +507,7 @@ int ubi_add_to_av(struct ubi_device *ubi, struct ubi_attach_info *ai, int pnum, 
		 * sequence numbers. We still can attach these images, unless

		 * there is a need to distinguish between old and new

		 * eraseblocks, in which case we'll refuse the image in

		 * 'compare_lebs()'. In other words, we attach old clean

		 * 'ubi_compare_lebs()'. In other words, we attach old clean

		 * images, but refuse attaching old images with duplicated

		 * logical eraseblocks because there was an unclean reboot.

		 */
@@ -523,7 +523,7 @@ int ubi_add_to_av(struct ubi_device *ubi, struct ubi_attach_info *ai, int pnum, 
		 * Now we have to drop the older one and preserve the newer

		 * one.

		 */

		cmp_res = compare_lebs(ubi, aeb, pnum, vid_hdr);

		cmp_res = ubi_compare_lebs(ubi, aeb, pnum, vid_hdr);

		if (cmp_res < 0)

			return cmp_res;
@@ -748,7 +748,7 @@ struct ubi_ainf_peb *ubi_early_get_peb(struct ubi_device *ubi, 
/**

 * check_corruption - check the data area of PEB.

 * @ubi: UBI device description object

 * @vid_hrd: the (corrupted) VID header of this PEB

 * @vid_hdr: the (corrupted) VID header of this PEB

 * @pnum: the physical eraseblock number to check

 *

 * This is a helper function which is used to distinguish between VID header
@@ -810,6 +810,8 @@ out_unlock: 
 * @ubi: UBI device description object

 * @ai: attaching information

 * @pnum: the physical eraseblock number

 * @vid: The volume ID of the found volume will be stored in this pointer

 * @sqnum: The sqnum of the found volume will be stored in this pointer

 *

 * This function reads UBI headers of PEB @pnum, checks them, and adds

 * information about this PEB to the corresponding list or RB-tree in the
@@ -817,10 +819,10 @@ out_unlock: 
 * successfully handled and a negative error code in case of failure.

 */

static int scan_peb(struct ubi_device *ubi, struct ubi_attach_info *ai,

		    int pnum)

		    int pnum, int *vid, unsigned long long *sqnum)

{

	long long uninitialized_var(ec);

	int err, bitflips = 0, vol_id, ec_err = 0;

	int err, bitflips = 0, vol_id = -1, ec_err = 0;



	dbg_bld("scan PEB %d", pnum);
@@ -991,14 +993,21 @@ static int scan_peb(struct ubi_device *ubi, struct ubi_attach_info *ai, 
	}



	vol_id = be32_to_cpu(vidh->vol_id);

	if (vid)

		*vid = vol_id;

	if (sqnum)

		*sqnum = be64_to_cpu(vidh->sqnum);

	if (vol_id > UBI_MAX_VOLUMES && vol_id != UBI_LAYOUT_VOLUME_ID) {

		int lnum = be32_to_cpu(vidh->lnum);



		/* Unsupported internal volume */

		switch (vidh->compat) {

		case UBI_COMPAT_DELETE:

			if (vol_id != UBI_FM_SB_VOLUME_ID

			    && vol_id != UBI_FM_DATA_VOLUME_ID) {

				ubi_msg("\"delete\" compatible internal volume %d:%d found, will remove it",

					vol_id, lnum);

			}

			err = add_to_list(ai, pnum, vol_id, lnum,

					  ec, 1, &ai->erase);

			if (err)
@@ -1120,52 +1129,127 @@ static int late_analysis(struct ubi_device *ubi, struct ubi_attach_info *ai) 
	return 0;

}



/**

 * destroy_av - free volume attaching information.

 * @av: volume attaching information

 * @ai: attaching information

 *

 * This function destroys the volume attaching information.

 */

static void destroy_av(struct ubi_attach_info *ai, struct ubi_ainf_volume *av)

{

	struct ubi_ainf_peb *aeb;

	struct rb_node *this = av->root.rb_node;



	while (this) {

		if (this->rb_left)

			this = this->rb_left;

		else if (this->rb_right)

			this = this->rb_right;

		else {

			aeb = rb_entry(this, struct ubi_ainf_peb, u.rb);

			this = rb_parent(this);

			if (this) {

				if (this->rb_left == &aeb->u.rb)

					this->rb_left = NULL;

				else

					this->rb_right = NULL;

			}



			kmem_cache_free(ai->aeb_slab_cache, aeb);

		}

	}

	kfree(av);

}



/**

 * destroy_ai - destroy attaching information.

 * @ai: attaching information

 */

static void destroy_ai(struct ubi_attach_info *ai)

{

	struct ubi_ainf_peb *aeb, *aeb_tmp;

	struct ubi_ainf_volume *av;

	struct rb_node *rb;



	list_for_each_entry_safe(aeb, aeb_tmp, &ai->alien, u.list) {

		list_del(&aeb->u.list);

		kmem_cache_free(ai->aeb_slab_cache, aeb);

	}

	list_for_each_entry_safe(aeb, aeb_tmp, &ai->erase, u.list) {

		list_del(&aeb->u.list);

		kmem_cache_free(ai->aeb_slab_cache, aeb);

	}

	list_for_each_entry_safe(aeb, aeb_tmp, &ai->corr, u.list) {

		list_del(&aeb->u.list);

		kmem_cache_free(ai->aeb_slab_cache, aeb);

	}

	list_for_each_entry_safe(aeb, aeb_tmp, &ai->free, u.list) {

		list_del(&aeb->u.list);

		kmem_cache_free(ai->aeb_slab_cache, aeb);

	}



	/* Destroy the volume RB-tree */

	rb = ai->volumes.rb_node;

	while (rb) {

		if (rb->rb_left)

			rb = rb->rb_left;

		else if (rb->rb_right)

			rb = rb->rb_right;

		else {

			av = rb_entry(rb, struct ubi_ainf_volume, rb);



			rb = rb_parent(rb);

			if (rb) {

				if (rb->rb_left == &av->rb)

					rb->rb_left = NULL;

				else

					rb->rb_right = NULL;

			}



			destroy_av(ai, av);

		}

	}



	if (ai->aeb_slab_cache)

		kmem_cache_destroy(ai->aeb_slab_cache);



	kfree(ai);

}



/**

 * scan_all - scan entire MTD device.

 * @ubi: UBI device description object

 * @ai: attach info object

 * @start: start scanning at this PEB

 *

 * This function does full scanning of an MTD device and returns complete

 * information about it in form of a "struct ubi_attach_info" object. In case

 * of failure, an error code is returned.

 */

static struct ubi_attach_info *scan_all(struct ubi_device *ubi)

static int scan_all(struct ubi_device *ubi, struct ubi_attach_info *ai,

		    int start)

{

	int err, pnum;

	struct rb_node *rb1, *rb2;

	struct ubi_ainf_volume *av;

	struct ubi_ainf_peb *aeb;

	struct ubi_attach_info *ai;



	ai = kzalloc(sizeof(struct ubi_attach_info), GFP_KERNEL);

	if (!ai)

		return ERR_PTR(-ENOMEM);



	INIT_LIST_HEAD(&ai->corr);

	INIT_LIST_HEAD(&ai->free);

	INIT_LIST_HEAD(&ai->erase);

	INIT_LIST_HEAD(&ai->alien);

	ai->volumes = RB_ROOT;



	err = -ENOMEM;

	ai->aeb_slab_cache = kmem_cache_create("ubi_aeb_slab_cache",

					       sizeof(struct ubi_ainf_peb),

					       0, 0, NULL);

	if (!ai->aeb_slab_cache)

		goto out_ai;



	ech = kzalloc(ubi->ec_hdr_alsize, GFP_KERNEL);

	if (!ech)

		goto out_ai;

		return err;



	vidh = ubi_zalloc_vid_hdr(ubi, GFP_KERNEL);

	if (!vidh)

		goto out_ech;



	for (pnum = 0; pnum < ubi->peb_count; pnum++) {

	for (pnum = start; pnum < ubi->peb_count; pnum++) {

		cond_resched();



		dbg_gen("process PEB %d", pnum);

		err = scan_peb(ubi, ai, pnum);

		err = scan_peb(ubi, ai, pnum, NULL, NULL);

		if (err < 0)

			goto out_vidh;

	}
@@ -1210,32 +1294,144 @@ static struct ubi_attach_info *scan_all(struct ubi_device *ubi) 
	ubi_free_vid_hdr(ubi, vidh);

	kfree(ech);



	return ai;

	return 0;



out_vidh:

	ubi_free_vid_hdr(ubi, vidh);

out_ech:

	kfree(ech);

out_ai:

	ubi_destroy_ai(ai);

	return ERR_PTR(err);

	return err;

}



#ifdef CONFIG_MTD_UBI_FASTMAP



/**

 * scan_fastmap - try to find a fastmap and attach from it.

 * @ubi: UBI device description object

 * @ai: attach info object

 *

 * Returns 0 on success, negative return values indicate an internal

 * error.

 * UBI_NO_FASTMAP denotes that no fastmap was found.

 * UBI_BAD_FASTMAP denotes that the found fastmap was invalid.

 */

static int scan_fast(struct ubi_device *ubi, struct ubi_attach_info *ai)

{

	int err, pnum, fm_anchor = -1;

	unsigned long long max_sqnum = 0;



	err = -ENOMEM;



	ech = kzalloc(ubi->ec_hdr_alsize, GFP_KERNEL);

	if (!ech)

		goto out;



	vidh = ubi_zalloc_vid_hdr(ubi, GFP_KERNEL);

	if (!vidh)

		goto out_ech;



	for (pnum = 0; pnum < UBI_FM_MAX_START; pnum++) {

		int vol_id = -1;

		unsigned long long sqnum = -1;

		cond_resched();



		dbg_gen("process PEB %d", pnum);

		err = scan_peb(ubi, ai, pnum, &vol_id, &sqnum);

		if (err < 0)

			goto out_vidh;



		if (vol_id == UBI_FM_SB_VOLUME_ID && sqnum > max_sqnum) {

			max_sqnum = sqnum;

			fm_anchor = pnum;

		}

	}



	ubi_free_vid_hdr(ubi, vidh);

	kfree(ech);



	if (fm_anchor < 0)

		return UBI_NO_FASTMAP;



	return ubi_scan_fastmap(ubi, ai, fm_anchor);



out_vidh:

	ubi_free_vid_hdr(ubi, vidh);

out_ech:

	kfree(ech);

out:

	return err;

}



#endif



static struct ubi_attach_info *alloc_ai(const char *slab_name)

{

	struct ubi_attach_info *ai;



	ai = kzalloc(sizeof(struct ubi_attach_info), GFP_KERNEL);

	if (!ai)

		return ai;



	INIT_LIST_HEAD(&ai->corr);

	INIT_LIST_HEAD(&ai->free);

	INIT_LIST_HEAD(&ai->erase);

	INIT_LIST_HEAD(&ai->alien);

	ai->volumes = RB_ROOT;

	ai->aeb_slab_cache = kmem_cache_create(slab_name,

					       sizeof(struct ubi_ainf_peb),

					       0, 0, NULL);

	if (!ai->aeb_slab_cache) {

		kfree(ai);

		ai = NULL;

	}



	return ai;

}



/**

 * ubi_attach - attach an MTD device.

 * @ubi: UBI device descriptor

 * @force_scan: if set to non-zero attach by scanning

 *

 * This function returns zero in case of success and a negative error code in

 * case of failure.

 */

int ubi_attach(struct ubi_device *ubi)

int ubi_attach(struct ubi_device *ubi, int force_scan)

{

	int err;

	struct ubi_attach_info *ai;



	ai = scan_all(ubi);

	if (IS_ERR(ai))

		return PTR_ERR(ai);

	ai = alloc_ai("ubi_aeb_slab_cache");

	if (!ai)

		return -ENOMEM;



#ifdef CONFIG_MTD_UBI_FASTMAP

	/* On small flash devices we disable fastmap in any case. */

	if ((int)mtd_div_by_eb(ubi->mtd->size, ubi->mtd) <= UBI_FM_MAX_START) {

		ubi->fm_disabled = 1;

		force_scan = 1;

	}



	if (force_scan)

		err = scan_all(ubi, ai, 0);

	else {

		err = scan_fast(ubi, ai);

		if (err > 0) {

			if (err != UBI_NO_FASTMAP) {

				destroy_ai(ai);

				ai = alloc_ai("ubi_aeb_slab_cache2");

				if (!ai)

					return -ENOMEM;

			}



			err = scan_all(ubi, ai, UBI_FM_MAX_START);

		}

	}

#else

	err = scan_all(ubi, ai, 0);

#endif

	if (err)

		goto out_ai;



	ubi->bad_peb_count = ai->bad_peb_count;

	ubi->good_peb_count = ubi->peb_count - ubi->bad_peb_count;
@@ -1256,7 +1452,29 @@ int ubi_attach(struct ubi_device *ubi) 
	if (err)

		goto out_wl;



	ubi_destroy_ai(ai);

#ifdef CONFIG_MTD_UBI_FASTMAP

	if (ubi->fm && ubi->dbg->chk_gen) {

		struct ubi_attach_info *scan_ai;



		scan_ai = alloc_ai("ubi_ckh_aeb_slab_cache");

		if (!scan_ai)

			goto out_wl;



		err = scan_all(ubi, scan_ai, 0);

		if (err) {

			destroy_ai(scan_ai);

			goto out_wl;

		}



		err = self_check_eba(ubi, ai, scan_ai);

		destroy_ai(scan_ai);



		if (err)

			goto out_wl;

	}

#endif



	destroy_ai(ai);

	return 0;



out_wl:
@@ -1265,98 +1483,10 @@ out_vtbl: 
	ubi_free_internal_volumes(ubi);

	vfree(ubi->vtbl);

out_ai:

	ubi_destroy_ai(ai);

	destroy_ai(ai);

	return err;

}



/**

 * destroy_av - free volume attaching information.

 * @av: volume attaching information

 * @ai: attaching information

 *

 * This function destroys the volume attaching information.

 */

static void destroy_av(struct ubi_attach_info *ai, struct ubi_ainf_volume *av)

{

	struct ubi_ainf_peb *aeb;

	struct rb_node *this = av->root.rb_node;



	while (this) {

		if (this->rb_left)

			this = this->rb_left;

		else if (this->rb_right)

			this = this->rb_right;

		else {

			aeb = rb_entry(this, struct ubi_ainf_peb, u.rb);

			this = rb_parent(this);

			if (this) {

				if (this->rb_left == &aeb->u.rb)

					this->rb_left = NULL;

				else

					this->rb_right = NULL;

			}



			kmem_cache_free(ai->aeb_slab_cache, aeb);

		}

	}

	kfree(av);

}



/**

 * ubi_destroy_ai - destroy attaching information.

 * @ai: attaching information

 */

void ubi_destroy_ai(struct ubi_attach_info *ai)

{

	struct ubi_ainf_peb *aeb, *aeb_tmp;

	struct ubi_ainf_volume *av;

	struct rb_node *rb;



	list_for_each_entry_safe(aeb, aeb_tmp, &ai->alien, u.list) {

		list_del(&aeb->u.list);

		kmem_cache_free(ai->aeb_slab_cache, aeb);

	}

	list_for_each_entry_safe(aeb, aeb_tmp, &ai->erase, u.list) {

		list_del(&aeb->u.list);

		kmem_cache_free(ai->aeb_slab_cache, aeb);

	}

	list_for_each_entry_safe(aeb, aeb_tmp, &ai->corr, u.list) {

		list_del(&aeb->u.list);

		kmem_cache_free(ai->aeb_slab_cache, aeb);

	}

	list_for_each_entry_safe(aeb, aeb_tmp, &ai->free, u.list) {

		list_del(&aeb->u.list);

		kmem_cache_free(ai->aeb_slab_cache, aeb);

	}



	/* Destroy the volume RB-tree */

	rb = ai->volumes.rb_node;

	while (rb) {

		if (rb->rb_left)

			rb = rb->rb_left;

		else if (rb->rb_right)

			rb = rb->rb_right;

		else {

			av = rb_entry(rb, struct ubi_ainf_volume, rb);



			rb = rb_parent(rb);

			if (rb) {

				if (rb->rb_left == &av->rb)

					rb->rb_left = NULL;

				else

					rb->rb_right = NULL;

			}



			destroy_av(ai, av);

		}

	}



	if (ai->aeb_slab_cache)

		kmem_cache_destroy(ai->aeb_slab_cache);



	kfree(ai);

}



/**

 * self_check_ai - check the attaching information.

 * @ubi: UBI device description object

drivers/mtd/ubi/build.c

+66 −4
Original line number Diff line number Diff line
@@ -76,7 +76,10 @@ static int __initdata mtd_devs; 


/* MTD devices specification parameters */

static struct mtd_dev_param __initdata mtd_dev_param[UBI_MAX_DEVICES];



#ifdef CONFIG_MTD_UBI_FASTMAP

/* UBI module parameter to enable fastmap automatically on non-fastmap images */

static bool fm_autoconvert;

#endif

/* Root UBI "class" object (corresponds to '/<sysfs>/class/ubi/') */

struct class *ubi_class;
@@ -153,6 +156,19 @@ int ubi_volume_notify(struct ubi_device *ubi, struct ubi_volume *vol, int ntype) 


	ubi_do_get_device_info(ubi, &nt.di);

	ubi_do_get_volume_info(ubi, vol, &nt.vi);



#ifdef CONFIG_MTD_UBI_FASTMAP

	switch (ntype) {

	case UBI_VOLUME_ADDED:

	case UBI_VOLUME_REMOVED:

	case UBI_VOLUME_RESIZED:

	case UBI_VOLUME_RENAMED:

		if (ubi_update_fastmap(ubi)) {

			ubi_err("Unable to update fastmap!");

			ubi_ro_mode(ubi);

		}

	}

#endif

	return blocking_notifier_call_chain(&ubi_notifiers, ntype, &nt);

}
@@ -918,10 +934,40 @@ int ubi_attach_mtd_dev(struct mtd_info *mtd, int ubi_num, 
	ubi->vid_hdr_offset = vid_hdr_offset;

	ubi->autoresize_vol_id = -1;



#ifdef CONFIG_MTD_UBI_FASTMAP

	ubi->fm_pool.used = ubi->fm_pool.size = 0;

	ubi->fm_wl_pool.used = ubi->fm_wl_pool.size = 0;



	/*

	 * fm_pool.max_size is 5% of the total number of PEBs but it's also

	 * between UBI_FM_MAX_POOL_SIZE and UBI_FM_MIN_POOL_SIZE.

	 */

	ubi->fm_pool.max_size = min(((int)mtd_div_by_eb(ubi->mtd->size,

		ubi->mtd) / 100) * 5, UBI_FM_MAX_POOL_SIZE);

	if (ubi->fm_pool.max_size < UBI_FM_MIN_POOL_SIZE)

		ubi->fm_pool.max_size = UBI_FM_MIN_POOL_SIZE;



	ubi->fm_wl_pool.max_size = UBI_FM_WL_POOL_SIZE;

	ubi->fm_disabled = !fm_autoconvert;



	if (!ubi->fm_disabled && (int)mtd_div_by_eb(ubi->mtd->size, ubi->mtd)

	    <= UBI_FM_MAX_START) {

		ubi_err("More than %i PEBs are needed for fastmap, sorry.",

			UBI_FM_MAX_START);

		ubi->fm_disabled = 1;

	}



	ubi_msg("default fastmap pool size: %d", ubi->fm_pool.max_size);

	ubi_msg("default fastmap WL pool size: %d", ubi->fm_wl_pool.max_size);

#else

	ubi->fm_disabled = 1;

#endif

	mutex_init(&ubi->buf_mutex);

	mutex_init(&ubi->ckvol_mutex);

	mutex_init(&ubi->device_mutex);

	spin_lock_init(&ubi->volumes_lock);

	mutex_init(&ubi->fm_mutex);

	init_rwsem(&ubi->fm_sem);



	ubi_msg("attaching mtd%d to ubi%d", mtd->index, ubi_num);
@@ -934,11 +980,17 @@ int ubi_attach_mtd_dev(struct mtd_info *mtd, int ubi_num, 
	if (!ubi->peb_buf)

		goto out_free;



#ifdef CONFIG_MTD_UBI_FASTMAP

	ubi->fm_size = ubi_calc_fm_size(ubi);

	ubi->fm_buf = vzalloc(ubi->fm_size);

	if (!ubi->fm_buf)

		goto out_free;

#endif

	err = ubi_debugging_init_dev(ubi);

	if (err)

		goto out_free;



	err = ubi_attach(ubi);

	err = ubi_attach(ubi, 0);

	if (err) {

		ubi_err("failed to attach mtd%d, error %d", mtd->index, err);

		goto out_debugging;
@@ -1012,6 +1064,7 @@ out_debugging: 
	ubi_debugging_exit_dev(ubi);

out_free:

	vfree(ubi->peb_buf);

	vfree(ubi->fm_buf);

	if (ref)

		put_device(&ubi->dev);

	else
@@ -1061,7 +1114,11 @@ int ubi_detach_mtd_dev(int ubi_num, int anyway) 
	ubi_assert(ubi_num == ubi->ubi_num);

	ubi_notify_all(ubi, UBI_VOLUME_REMOVED, NULL);

	ubi_msg("detaching mtd%d from ubi%d", ubi->mtd->index, ubi_num);



#ifdef CONFIG_MTD_UBI_FASTMAP

	/* If we don't write a new fastmap at detach time we lose all

	 * EC updates that have been made since the last written fastmap. */

	ubi_update_fastmap(ubi);

#endif

	/*

	 * Before freeing anything, we have to stop the background thread to

	 * prevent it from doing anything on this device while we are freeing.
@@ -1077,12 +1134,14 @@ int ubi_detach_mtd_dev(int ubi_num, int anyway) 


	ubi_debugfs_exit_dev(ubi);

	uif_close(ubi);



	ubi_wl_close(ubi);

	ubi_free_internal_volumes(ubi);

	vfree(ubi->vtbl);

	put_mtd_device(ubi->mtd);

	ubi_debugging_exit_dev(ubi);

	vfree(ubi->peb_buf);

	vfree(ubi->fm_buf);

	ubi_msg("mtd%d is detached from ubi%d", ubi->mtd->index, ubi->ubi_num);

	put_device(&ubi->dev);

	return 0;
@@ -1404,7 +1463,10 @@ MODULE_PARM_DESC(mtd, "MTD devices to attach. Parameter format: mtd=<name|num|pa 
		      "Example 2: mtd=content,1984 mtd=4 - attach MTD device with name \"content\" using VID header offset 1984, and MTD device number 4 with default VID header offset.\n"

		      "Example 3: mtd=/dev/mtd1,0,25 - attach MTD device /dev/mtd1 using default VID header offset and reserve 25*nand_size_in_blocks/1024 erase blocks for bad block handling.\n"

		      "\t(e.g. if the NAND *chipset* has 4096 PEB, 100 will be reserved for this UBI device).");



#ifdef CONFIG_MTD_UBI_FASTMAP

module_param(fm_autoconvert, bool, 0644);

MODULE_PARM_DESC(fm_autoconvert, "Set this parameter to enable fastmap automatically on images without a fastmap.");

#endif

MODULE_VERSION(__stringify(UBI_VERSION));

MODULE_DESCRIPTION("UBI - Unsorted Block Images");

MODULE_AUTHOR("Artem Bityutskiy");