Merge tag 'ubifs-for-linus-7.3-rc1' of git://git.kernel.org/pub/scm/linux/kernel/git/rw/ubifs

Pull UBI and UBIFS updates from Richard Weinberger: "UBI: - Support for a per-device wear-leveling threshold - Various fixes and cleanups of error paths - Correctly preserve torture flag up wear-leveling UBIFS: - Various fixes and cleanups of error paths and kernel-doc" * tag 'ubifs-for-linus-7.3-rc1' of git://git.kernel.org/pub/scm/linux/kernel/git/rw/ubifs: UBI: support per-device wear-leveling threshold UBI: fix two issues in the ubi.mtd MODULE_PARM_DESC mtd: ubi: Release device reference on busy detach ubi: Fix rollback for explicit UBI device numbers ubifs: fix out-of-bounds read in signature length check UBI: fastmap: Pass to_be_tortured when reusing old fastmap PEBs UBI: Preserve torture flag when rescheduling failed erasures ubifs: ubifs.h: clean up kernel-doc comments ubifs: key.h: use correct function parameter name ubifs: debug.h: fix kernel-doc struct prototypes

Linus Torvalds committed 2 months ago

Commit ce727a02 parents 115bd36 a5e005513 files · +122 −74Browse files

Unified · Split

13 files

drivers/mtd/ubi/attach.c +2 −2
drivers/mtd/ubi/build.c +39 −9
drivers/mtd/ubi/cdev.c +1 −1
drivers/mtd/ubi/fastmap-wl.c +4 −4
drivers/mtd/ubi/fastmap.c +4 −2
drivers/mtd/ubi/io.c +7 −4
drivers/mtd/ubi/ubi.h +22 −3
drivers/mtd/ubi/wl.c +18 −36
fs/ubifs/auth.c +1 −1
fs/ubifs/debug.h +2 −2
fs/ubifs/key.h +1 −1
fs/ubifs/ubifs.h +12 −8
include/uapi/mtd/ubi-user.h +9 −1

drivers/mtd/ubi/attach.c+2−2

@@ -771,7 +771,7 @@ void ubi_remove_av(struct ubi_attach_info ai, struct ubi_ainf_volume av) · 770 unmodified lines
771	static int early_erase_peb(struct ubi_device *ubi,	771	static int early_erase_peb(struct ubi_device *ubi,
772	const struct ubi_attach_info *ai, int pnum, int ec)	772	const struct ubi_attach_info *ai, int pnum, int ec)
773	{	773	{
774	int err;	774	int err, torture = 0;
775	struct ubi_ec_hdr *ec_hdr;	775	struct ubi_ec_hdr *ec_hdr;
776		776
777	if ((long long)ec >= UBI_MAX_ERASECOUNTER) {	777	if ((long long)ec >= UBI_MAX_ERASECOUNTER) {
@@ -790,7 +790,7 @@ static int early_erase_peb(struct ubi_device *ubi, · 12 unmodified lines
790		790
791	ec_hdr->ec = cpu_to_be64(ec);	791	ec_hdr->ec = cpu_to_be64(ec);
792		792
793	err = ubi_io_sync_erase(ubi, pnum, 0);	793	err = ubi_io_sync_erase(ubi, pnum, &torture);
794	if (err < 0)	794	if (err < 0)
795	goto out_free;	795	goto out_free;
796		796

drivers/mtd/ubi/build.c+39−9

 #define MTD_PARAM_LEN_MAX 64
 /* Maximum number of comma-separated items in the 'mtd=' parameter */
-#define MTD_PARAM_MAX_COUNT 6
+#define MTD_PARAM_MAX_COUNT 7
 /* Maximum value for the number of bad PEBs per 1024 PEBs */
 #define MAX_MTD_UBI_BEB_LIMIT 768
  * @max_beb_per1024: maximum expected number of bad PEBs per 1024 PEBs
  * @enable_fm: enable fastmap when value is non-zero
  * @need_resv_pool: reserve pool->max_size pebs when value is none-zero
+ * @wl_threshold: wear-leveling threshold, 0 means use CONFIG_MTD_UBI_WL_THRESHOLD
  */
 struct mtd_dev_param {
 	char name[MTD_PARAM_LEN_MAX];
 	int max_beb_per1024;
 	int enable_fm;
 	int need_resv_pool;
+	int wl_threshold;
 };
 /* Numbers of elements set in the @mtd_dev_param array */
  * @max_beb_per1024: maximum expected number of bad PEB per 1024 PEBs
  * @disable_fm: whether disable fastmap
  * @need_resv_pool: whether reserve pebs to fill fm_pool
+ * @wl_threshold: wear-leveling threshold for this UBI device; 0 means use
+ *		   %CONFIG_MTD_UBI_WL_THRESHOLD; accepted range is 2-65536
  *
  * This function attaches MTD device @mtd_dev to UBI and assign @ubi_num number
  * to the newly created UBI device, unless @ubi_num is %UBI_DEV_NUM_AUTO, in
  */
 int ubi_attach_mtd_dev(struct mtd_info *mtd, int ubi_num,
 		       int vid_hdr_offset, int max_beb_per1024, bool disable_fm,
-		       bool need_resv_pool)
+		       bool need_resv_pool, int wl_threshold)
 {
 	struct ubi_device *ubi;
 	int i, err;
 	if (!max_beb_per1024)
 		max_beb_per1024 = CONFIG_MTD_UBI_BEB_LIMIT;
+	if (!wl_threshold)
+		wl_threshold = CONFIG_MTD_UBI_WL_THRESHOLD;
+	if (wl_threshold < 2 || wl_threshold > 65536) {
+		pr_err("ubi: bad wear-leveling threshold %d\n",
+		       wl_threshold);
+		return -EINVAL;
+	}
 	/*
 	 * Check if we already have the same MTD device attached.
 	 *
 	ubi->ubi_num = ubi_num;
 	ubi->vid_hdr_offset = vid_hdr_offset;
 	ubi->autoresize_vol_id = -1;
+	ubi->wl_threshold = wl_threshold;
+	ubi->wl_free_max_diff = wl_threshold * 2;
 #ifdef CONFIG_MTD_UBI_FASTMAP
 	ubi->fm_pool.used = ubi->fm_pool.size = 0;
 		ubi->vol_count - UBI_INT_VOL_COUNT, UBI_INT_VOL_COUNT,
 		ubi->vtbl_slots);
 	ubi_msg(ubi, "max/mean erase counter: %d/%d, WL threshold: %d, image sequence number: %u",
-		ubi->max_ec, ubi->mean_ec, CONFIG_MTD_UBI_WL_THRESHOLD,
+		ubi->max_ec, ubi->mean_ec, ubi->wl_threshold,
 		ubi->image_seq);
 	ubi_msg(ubi, "available PEBs: %d, total reserved PEBs: %d, PEBs reserved for bad PEB handling: %d",
 		ubi->avail_pebs, ubi->rsvd_pebs, ubi->beb_rsvd_pebs);
 	ubi->ref_count -= 1;
 	if (ubi->ref_count) {
 		if (!anyway) {
+			put_device(&ubi->dev);
 			spin_unlock(&ubi_devices_lock);
 			return -EBUSY;
 		}
 	/* called while holding mtd_table_mutex */
 	mutex_lock_nested(&ubi_devices_mutex, SINGLE_DEPTH_NESTING);
-	err = ubi_attach_mtd_dev(mtd, UBI_DEV_NUM_AUTO, 0, 0, false, false);
+	err = ubi_attach_mtd_dev(mtd, UBI_DEV_NUM_AUTO, 0, 0, false, false, 0);
 	mutex_unlock(&ubi_devices_mutex);
 	if (err < 0)
 		__put_mtd_device(mtd);
 		err = ubi_attach_mtd_dev(mtd, p->ubi_num,
 					 p->vid_hdr_offs, p->max_beb_per1024,
 					 p->enable_fm == 0,
-					 p->need_resv_pool != 0);
+					 p->need_resv_pool != 0,
+					 p->wl_threshold);
 		mutex_unlock(&ubi_devices_mutex);
 		if (err < 0) {
 			pr_err("UBI error: cannot attach mtd%d\n",
 	return 0;
 out_detach:
-	for (k = 0; k < i; k++)
+	for (k = 0; k < UBI_MAX_DEVICES; k++)
 		if (ubi_devices[k]) {
 			mutex_lock(&ubi_devices_mutex);
-			ubi_detach_mtd_dev(ubi_devices[k]->ubi_num, 1);
+			ubi_detach_mtd_dev(k, 1);
 			mutex_unlock(&ubi_devices_mutex);
 		}
 	return err;
 	} else
 		p->need_resv_pool = 0;
+	token = tokens[6];
+	if (token) {
+		int err = kstrtoint(token, 10, &p->wl_threshold);
+		if (err) {
+			pr_err("UBI error: bad value for wl_threshold parameter: %s\n",
+				token);
+			return -EINVAL;
+		}
+	} else
+		p->wl_threshold = 0;
 	mtd_devs += 1;
 	return 0;
 }
 module_param_call(mtd, ubi_mtd_param_parse, NULL, NULL, 0400);
-MODULE_PARM_DESC(mtd, "MTD devices to attach. Parameter format: mtd=<name|num|path>[,<vid_hdr_offs>[,max_beb_per1024[,ubi_num]]].\n"
+MODULE_PARM_DESC(mtd, "MTD devices to attach. Parameter format: mtd=<name|num|path>[,<vid_hdr_offs>[,max_beb_per1024[,ubi_num[,enable_fm[,need_resv_pool[,wl_threshold]]]]]].\n"
 		      "Multiple \"mtd\" parameters may be specified.\n"
 		      "MTD devices may be specified by their number, name, or path to the MTD character device node.\n"
 		      "Optional \"vid_hdr_offs\" parameter specifies UBI VID header position to be used by UBI. (default value if 0)\n"
 		      "Example 1: mtd=/dev/mtd0 - attach MTD device /dev/mtd0.\n"
 		      "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).\n"
 		      "Example 4: mtd=/dev/mtd1,0,0,5 - attach MTD device /dev/mtd1 to UBI 5 and using default values for the other fields.\n"
 		      "example 5: mtd=1,0,0,5 mtd=2,0,0,6,1 - attach MTD device /dev/mtd1 to UBI 5 and disable fastmap; attach MTD device /dev/mtd2 to UBI 6 and enable fastmap.(only works when fastmap is enabled and fm_autoconvert=Y).\n"
-		      "\t(e.g. if the NAND *chipset* has 4096 PEB, 100 will be reserved for this UBI device).");
+		      "Example 6: mtd=/dev/mtd0,0,0,0,0,0,256 mtd=/dev/mtd1,0,0,0,0,0,4096 - attach MTD device /dev/mtd0 with wear-leveling threshold 256, and MTD device /dev/mtd1 with threshold 4096.\n");
 #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.");

drivers/mtd/ubi/cdev.c+1−1

@@ -1112,7 +1112,7 @@ static long ctrl_cdev_ioctl(struct file *file, unsigned int cmd, · 1111 unmodified lines
1112	mutex_lock(&ubi_devices_mutex);	1112	mutex_lock(&ubi_devices_mutex);
1113	err = ubi_attach_mtd_dev(mtd, req.ubi_num, req.vid_hdr_offset,	1113	err = ubi_attach_mtd_dev(mtd, req.ubi_num, req.vid_hdr_offset,
1114	req.max_beb_per1024, !!req.disable_fm,	1114	req.max_beb_per1024, !!req.disable_fm,
1115	!!req.need_resv_pool);	1115	!!req.need_resv_pool, req.wl_threshold);
1116	mutex_unlock(&ubi_devices_mutex);	1116	mutex_unlock(&ubi_devices_mutex);
1117	if (err < 0)	1117	if (err < 0)
1118	put_mtd_device(mtd);	1118	put_mtd_device(mtd);

drivers/mtd/ubi/fastmap-wl.c+4−4

@@ -238,7 +238,7 @@ void ubi_refill_pools_and_lock(struct ubi_device *ubi) · 237 unmodified lines
238	if (left_free <= 0)	238	if (left_free <= 0)
239	break;	239	break;
240		240
241	e = find_wl_entry(ubi, &ubi->free, WL_FREE_MAX_DIFF,	241	e = find_wl_entry(ubi, &ubi->free, ubi->wl_free_max_diff,
242	!can_fill_pools(ubi, left_free));	242	!can_fill_pools(ubi, left_free));
243	self_check_in_wl_tree(ubi, e, &ubi->free);	243	self_check_in_wl_tree(ubi, e, &ubi->free);
244	rb_erase(&e->u.rb, &ubi->free);	244	rb_erase(&e->u.rb, &ubi->free);
@@ -392,18 +392,18 @@ static bool need_wear_leveling(struct ubi_device *ubi) · 147 unmodified lines
392	if (!e) {	392	if (!e) {
393	if (!ubi->free.rb_node)	393	if (!ubi->free.rb_node)
394	return false;	394	return false;
395	e = find_wl_entry(ubi, &ubi->free, WL_FREE_MAX_DIFF, 0);	395	e = find_wl_entry(ubi, &ubi->free, ubi->wl_free_max_diff, 0);
396	ec = e->ec;	396	ec = e->ec;
397	} else {	397	} else {
398	ec = e->ec;	398	ec = e->ec;
399	if (ubi->free.rb_node) {	399	if (ubi->free.rb_node) {
400	e = find_wl_entry(ubi, &ubi->free, WL_FREE_MAX_DIFF, 0);	400	e = find_wl_entry(ubi, &ubi->free, ubi->wl_free_max_diff, 0);
401	ec = max(ec, e->ec);	401	ec = max(ec, e->ec);
402	}	402	}
403	}	403	}
404	e = rb_entry(rb_first(&ubi->used), struct ubi_wl_entry, u.rb);	404	e = rb_entry(rb_first(&ubi->used), struct ubi_wl_entry, u.rb);
405		405
406	return ec - e->ec >= UBI_WL_THRESHOLD;	406	return ec - e->ec >= ubi->wl_threshold;
407	}	407	}
408		408
409	/* get_peb_for_wl - returns a PEB to be used internally by the WL sub-system.	409	/* get_peb_for_wl - returns a PEB to be used internally by the WL sub-system.

drivers/mtd/ubi/fastmap.c+4−2

 		if (!tmp_e) {
 			if (old_fm && old_fm->e[i]) {
-				ret = ubi_sync_erase(ubi, old_fm->e[i], 0);
+				ret = ubi_sync_erase(ubi, old_fm->e[i],
+						    &old_fm->to_be_tortured[i]);
 				if (ret < 0) {
 					ubi_err(ubi, "could not erase old fastmap PEB");
 	if (old_fm) {
 		/* no fresh anchor PEB was found, reuse the old one */
 		if (!tmp_e) {
-			ret = ubi_sync_erase(ubi, old_fm->e[0], 0);
+			ret = ubi_sync_erase(ubi, old_fm->e[0],
+					     &old_fm->to_be_tortured[0]);
 			if (ret < 0) {
 				ubi_err(ubi, "could not erase old anchor PEB");

drivers/mtd/ubi/io.c+7−4

 /**
  * ubi_io_sync_erase - synchronously erase a physical eraseblock.
  * @ubi: UBI device description object
- * @pnum: physical eraseblock number to erase
+ * @pnum: the physical eraseblock number to erase
- * @torture: if this physical eraseblock has to be tortured
+ * @torture: if this physical eraseblock has to be tortured; cleared to zero
+ *           once the torture test has completed successfully so that a retry
+ *           of the erase does not torture the physical eraseblock again
  *
  * This function synchronously erases physical eraseblock @pnum. If @torture
  * flag is not zero, the physical eraseblock is checked by means of writing
  * codes in case of other errors. Note, %-EIO means that the physical
  * eraseblock is bad.
  */
-int ubi_io_sync_erase(struct ubi_device *ubi, int pnum, int torture)
+int ubi_io_sync_erase(struct ubi_device *ubi, int pnum, int *torture)
 {
 	int err, ret = 0;
 			return err;
 	}
-	if (torture) {
+	if (*torture) {
 		ret = torture_peb(ubi, pnum);
 		if (ret < 0)
 			return ret;
+		*torture = 0;
 	}
 	err = do_sync_erase(ubi, pnum);

drivers/mtd/ubi/ubi.h+22−3

  * @bgt_thread: background thread description object
  * @thread_enabled: if the background thread is enabled
  * @bgt_name: background thread name
+ * @wl_threshold: Maximum difference between two erase counters. If this
+ *		   threshold is exceeded, the WL sub-system starts moving
+ *		   data from used physical eraseblocks with low erase
+ *		   counter to free physical eraseblocks with high erase counter.
+ * @wl_free_max_diff: When a physical eraseblock is moved, the WL sub-system
+ *		       has to pick the target physical eraseblock to move to.
+ *		       The simplest way would be just to pick the one with the
+ *		       highest erase counter. But in certain workloads this
+ *		       could lead to an unlimited wear of one or few physical
+ *		       eraseblock. Indeed, imagine a situation when the picked
+ *		       physical eraseblock is constantly erased after the
+ *		       data is written to it. So, we have a constant which
+ *		       limits the highest erase counter of the free physical
+ *		       eraseblock to pick. Namely, the WL sub-system does not
+ *		       pick eraseblocks with erase counter greater than the
+ *		       lowest erase counter plus @wl_free_max_diff.
  *
  * @flash_size: underlying MTD device size (in bytes)
  * @peb_count: count of physical eraseblocks on the MTD device
 	struct task_struct *bgt_thread;
 	int thread_enabled;
 	char bgt_name[sizeof(UBI_BGT_NAME_PATTERN)+2];
+	int wl_threshold;
+	int wl_free_max_diff;
 	/* I/O sub-system's stuff */
 	long long flash_size;
 		   struct ubi_attach_info *ai_scan);
 /* wl.c */
-int ubi_sync_erase(struct ubi_device *ubi, struct ubi_wl_entry *e, int torture);
+int ubi_sync_erase(struct ubi_device *ubi, struct ubi_wl_entry *e, int *torture);
 int ubi_wl_get_peb(struct ubi_device *ubi);
 int ubi_wl_put_peb(struct ubi_device *ubi, int vol_id, int lnum,
 		   int pnum, int torture);
 		int len);
 int ubi_io_write(struct ubi_device *ubi, const void *buf, int pnum, int offset,
 		 int len);
-int ubi_io_sync_erase(struct ubi_device *ubi, int pnum, int torture);
+int ubi_io_sync_erase(struct ubi_device *ubi, int pnum, int *torture);
 int ubi_io_is_bad(const struct ubi_device *ubi, int pnum);
 int ubi_io_mark_bad(const struct ubi_device *ubi, int pnum);
 int ubi_io_read_ec_hdr(struct ubi_device *ubi, int pnum,
 /* build.c */
 int ubi_attach_mtd_dev(struct mtd_info *mtd, int ubi_num,
 		       int vid_hdr_offset, int max_beb_per1024,
-		       bool disable_fm, bool need_resv_pool);
+		       bool disable_fm, bool need_resv_pool,
+		       int wl_threshold);
 int ubi_detach_mtd_dev(int ubi_num, int anyway);
 struct ubi_device *ubi_get_device(int ubi_num);
 void ubi_put_device(struct ubi_device *ubi);

drivers/mtd/ubi/wl.c+18−36

 /* Number of physical eraseblocks reserved for wear-leveling purposes */
 #define WL_RESERVED_PEBS 1
-/*
- * Maximum difference between two erase counters. If this threshold is
- * exceeded, the WL sub-system starts moving data from used physical
- * eraseblocks with low erase counter to free physical eraseblocks with high
- * erase counter.
- */
-#define UBI_WL_THRESHOLD CONFIG_MTD_UBI_WL_THRESHOLD
-/*
- * When a physical eraseblock is moved, the WL sub-system has to pick the target
- * physical eraseblock to move to. The simplest way would be just to pick the
- * one with the highest erase counter. But in certain workloads this could lead
- * to an unlimited wear of one or few physical eraseblock. Indeed, imagine a
- * situation when the picked physical eraseblock is constantly erased after the
- * data is written to it. So, we have a constant which limits the highest erase
- * counter of the free physical eraseblock to pick. Namely, the WL sub-system
- * does not pick eraseblocks with erase counter greater than the lowest erase
- * counter plus %WL_FREE_MAX_DIFF.
- */
-#define WL_FREE_MAX_DIFF (2*UBI_WL_THRESHOLD)
 /*
  * Maximum number of consecutive background thread failures which is enough to
  * switch to read-only mode.
  *
  * This function looks for a wear leveling entry with medium erase counter,
  * but not greater or equivalent than the lowest erase counter plus
- * %WL_FREE_MAX_DIFF/2.
+ * @ubi->wl_free_max_diff/2.
  */
 static struct ubi_wl_entry *find_mean_wl_entry(struct ubi_device *ubi,
 					       struct rb_root *root)
 	first = rb_entry(rb_first(root), struct ubi_wl_entry, u.rb);
 	last = rb_entry(rb_last(root), struct ubi_wl_entry, u.rb);
-	if (last->ec - first->ec < WL_FREE_MAX_DIFF) {
+	if (last->ec - first->ec < ubi->wl_free_max_diff) {
 		e = rb_entry(root->rb_node, struct ubi_wl_entry, u.rb);
 		/*
 		 */
 		e = may_reserve_for_fm(ubi, e, root);
 	} else
-		e = find_wl_entry(ubi, root, WL_FREE_MAX_DIFF/2, 0);
+		e = find_wl_entry(ubi, root, ubi->wl_free_max_diff/2, 0);
 	return e;
 }
  * ubi_sync_erase - synchronously erase a physical eraseblock.
  * @ubi: UBI device description object
  * @e: the physical eraseblock to erase
- * @torture: if the physical eraseblock has to be tortured
+ * @torture: if the physical eraseblock has to be tortured; cleared to zero
+ *           once the torture test has completed successfully so that a retry
+ *           of the erase does not torture the physical eraseblock again
  *
  * This function returns zero in case of success and a negative error code in
  * case of failure.
  */
-int ubi_sync_erase(struct ubi_device *ubi, struct ubi_wl_entry *e, int torture)
+int ubi_sync_erase(struct ubi_device *ubi, struct ubi_wl_entry *e, int *torture)
 {
 	int err;
 	struct ubi_ec_hdr *ec_hdr;
 #ifdef CONFIG_MTD_UBI_FASTMAP
 	e1 = find_anchor_wl_entry(&ubi->used);
 	if (e1 && ubi->fm_anchor &&
-	    (ubi->fm_anchor->ec - e1->ec >= UBI_WL_THRESHOLD)) {
+	    (ubi->fm_anchor->ec - e1->ec >= ubi->wl_threshold)) {
 		ubi->fm_do_produce_anchor = 1;
 		/*
 		 * fm_anchor is no longer considered a good anchor.
 		if (!e2)
 			goto out_cancel;
-		if (!(e2->ec - e1->ec >= UBI_WL_THRESHOLD)) {
+		if (!(e2->ec - e1->ec >= ubi->wl_threshold)) {
 			dbg_wl("no WL needed: min used EC %d, max free EC %d",
 			       e1->ec, e2->ec);
 		 * We schedule wear-leveling only if the difference between the
 		 * lowest erase counter of used physical eraseblocks and a high
 		 * erase counter of free physical eraseblocks is greater than
-		 * %UBI_WL_THRESHOLD.
+		 * @ubi->wl_threshold.
 		 */
 		e1 = rb_entry(rb_first(&ubi->used), struct ubi_wl_entry, u.rb);
-		e2 = find_wl_entry(ubi, &ubi->free, WL_FREE_MAX_DIFF, 0);
+		e2 = find_wl_entry(ubi, &ubi->free, ubi->wl_free_max_diff, 0);
-		if (!(e2->ec - e1->ec >= UBI_WL_THRESHOLD))
+		if (!(e2->ec - e1->ec >= ubi->wl_threshold))
 			goto out_unlock;
 #endif
 		dbg_wl("schedule wear-leveling");
 	dbg_wl("erase PEB %d EC %d LEB %d:%d",
 	       pnum, e->ec, wl_wrk->vol_id, wl_wrk->lnum);
-	err = ubi_sync_erase(ubi, e, wl_wrk->torture);
+	err = ubi_sync_erase(ubi, e, &wl_wrk->torture);
 	if (!err) {
 		spin_lock(&ubi->wl_lock);
 		int err1;
 		/* Re-schedule the LEB for erasure */
-		err1 = schedule_erase(ubi, e, vol_id, lnum, 0, true);
+		err1 = schedule_erase(ubi, e, vol_id, lnum, wl_wrk->torture,
+				      true);
 		if (err1) {
 			spin_lock(&ubi->wl_lock);
 			wl_entry_destroy(ubi, e);
 static int erase_aeb(struct ubi_device *ubi, struct ubi_ainf_peb *aeb, bool sync)
 {
 	struct ubi_wl_entry *e;
-	int err;
+	int err, torture = 0;
 	e = kmem_cache_alloc(ubi_wl_entry_slab, GFP_KERNEL);
 	if (!e)
 	ubi->lookuptbl[e->pnum] = e;
 	if (sync) {
-		err = ubi_sync_erase(ubi, e, false);
+		err = ubi_sync_erase(ubi, e, &torture);
 		if (err)
 			goto out_free;
 {
 	struct ubi_wl_entry *e;
-	e = find_wl_entry(ubi, &ubi->free, WL_FREE_MAX_DIFF, 0);
+	e = find_wl_entry(ubi, &ubi->free, ubi->wl_free_max_diff, 0);
 	self_check_in_wl_tree(ubi, e, &ubi->free);
 	ubi->free_count--;
 	ubi_assert(ubi->free_count >= 0);

fs/ubifs/auth.c+1−1

@@ -217,7 +217,7 @@ int ubifs_sb_verify_signature(struct ubifs_info *c, · 216 unmodified lines
217		217
218	signode = snod->node;	218	signode = snod->node;
219		219
220	if (le32_to_cpu(signode->len) > snod->len + sizeof(struct ubifs_sig_node)) {	220	if (le32_to_cpu(signode->len) > snod->len - sizeof(struct ubifs_sig_node)) {
221	ubifs_err(c, "invalid signature len %d", le32_to_cpu(signode->len));	221	ubifs_err(c, "invalid signature len %d", le32_to_cpu(signode->len));
222	err = -EINVAL;	222	err = -EINVAL;
223	goto out_destroy;	223	goto out_destroy;

fs/ubifs/debug.h+2−2

@@ -26,7 +26,7 @@ typedef int (dbg_znode_callback)(struct ubifs_info c, · 25 unmodified lines
26	#define UBIFS_DFS_DIR_LEN (3 + 1 + 2 + 3 + 1)	26	#define UBIFS_DFS_DIR_LEN (3 + 1 + 2 + 3 + 1)
27		27
28	/**	28	/**
29	* ubifs_debug_info - per-FS debugging information.	29	* struct ubifs_debug_info - per-FS debugging information.
30	* @old_zroot: old index root - used by 'dbg_check_old_index()'	30	* @old_zroot: old index root - used by 'dbg_check_old_index()'
31	* @old_zroot_level: old index root level - used by 'dbg_check_old_index()'	31	* @old_zroot_level: old index root level - used by 'dbg_check_old_index()'
32	* @old_zroot_sqnum: old index root sqnum - used by 'dbg_check_old_index()'	32	* @old_zroot_sqnum: old index root sqnum - used by 'dbg_check_old_index()'
@@ -119,7 +119,7 @@ struct ubifs_debug_info { · 86 unmodified lines
119	};	119	};
120		120
121	/**	121	/**
122	* ubifs_global_debug_info - global (not per-FS) UBIFS debugging information.	122	* struct ubifs_global_debug_info - global (not per-FS) UBIFS debugging information.
123	*	123	*
124	* @chk_gen: if general extra checks are enabled	124	* @chk_gen: if general extra checks are enabled
125	* @chk_index: if index xtra checks are enabled	125	* @chk_index: if index xtra checks are enabled

fs/ubifs/key.h+1−1

@@ -33,7 +33,7 @@ · 32 unmodified lines
33		33
34	/**	34	/**
35	* key_mask_hash - mask a valid hash value.	35	* key_mask_hash - mask a valid hash value.
36	* @val: value to be masked	36	* @hash: value to be masked
37	*	37	*
38	* We use hash values as offset in directories, so values %0 and %1 are	38	* We use hash values as offset in directories, so values %0 and %1 are
39	* reserved for "." and "..". %2 is reserved for "end of readdir" marker. This	39	* reserved for "." and "..". %2 is reserved for "end of readdir" marker. This

fs/ubifs/ubifs.h+12−8

  * struct ubifs_zbranch - key/coordinate/length branch stored in znodes.
  * @key: key
  * @znode: znode address in memory
+ * @leaf: leaf node
  * @lnum: LEB number of the target node (indexing node or data node)
  * @offs: target node offset within @lnum
  * @len: target node length
  * @gc_seq: GC sequence number to detect races with GC
  * @cnt: number of data nodes for bulk read
  * @blk_cnt: number of data blocks including holes
- * @oef: end of file reached
+ * @eof: end of file reached
  */
 struct bu_info {
 	union ubifs_key key;
 };
 /**
- * ubifs_stats_info - per-FS statistics information.
+ * struct ubifs_stats_info - per-FS statistics information.
  * @magic_errors: number of bad magic numbers (will be reset with a new mount).
  * @node_errors: number of bad nodes (will be reset with a new mount).
  * @crc_errors: number of bad crcs (will be reset with a new mount).
  * @rw_incompat: the media is not R/W compatible
  * @assert_action: action to take when a ubifs_assert() fails
  * @authenticated: flag indigating the FS is mounted in authenticated mode
+ * @superblock_need_write: superblock node needs to be written
  *
  * @tnc_mutex: protects the Tree Node Cache (TNC), @zroot, @cnext, @enext, and
  *             @calc_idx_sz
  * @expected: first hash
  * @got: second hash
  *
- * Compare two hashes @expected and @got. Returns 0 when they are equal, a
+ * Compare two hashes @expected and @got.
- * negative error code otherwise.
+ *
+ * Returns: 0 when they are equal, a negative error code otherwise.
  */
 static inline int ubifs_check_hash(const struct ubifs_info *c,
 				   const u8 *expected, const u8 *got)
  * @expected: first HMAC
  * @got: second HMAC
  *
- * Compare two hashes @expected and @got. Returns 0 when they are equal, a
+ * Compare two hashes @expected and @got.
- * negative error code otherwise.
+ *
+ * Returns: 0 when they are equal, a negative error code otherwise.
  */
 static inline int ubifs_check_hmac(const struct ubifs_info *c,
 				   const u8 *expected, const u8 *got)
  * @c: UBIFS file-system description object
  * @br: branch to get the hash from
  *
- * This returns a pointer to the hash of a branch. Since the key already is a
+ * Returns: a pointer to the hash of a branch. Since the key already is a
  * dynamically sized object we cannot use a struct member here.
  */
 static inline u8 *ubifs_branch_hash(struct ubifs_info *c,
  * ubifs_auth_node_sz - returns the size of an authentication node
  * @c: UBIFS file-system description object
  *
- * This function returns the size of an authentication node which can
+ * Returns: the size of an authentication node which can
  * be 0 for unauthenticated filesystems or the real size of an auth node
  * authentication is enabled.
  */

include/uapi/mtd/ubi-user.h+9−1

  * If @disable_fm is not zero, ubi doesn't create new fastmap even the module
  * param 'fm_autoconvert' is set, and existed old fastmap will be destroyed
  * after doing full scanning.
+ *
+ * The @wl_threshold defines the maximum difference between the highest and the
+ * lowest erase counter value of eraseblocks of this UBI device. When this
+ * threshold is exceeded, UBI starts performing wear leveling by means of
+ * moving data from eraseblock with low erase counter to eraseblocks with high
+ * erase counter. If @wl_threshold is zero, the default kernel value of
+ * %CONFIG_MTD_UBI_WL_THRESHOLD is used. The accepted range is 2-65536.
  */
 struct ubi_attach_req {
 	__s32 ubi_num;
 	__s16 max_beb_per1024;
 	__s8 disable_fm;
 	__s8 need_resv_pool;
-	__s8 padding[8];
+	__s32 wl_threshold;
+	__s8 padding[4];
 };
 /*

Merge tag 'ubifs-for-linus-7.3-rc1' of git://git.kernel.org/pub/scm/linux/kernel/git/rw/ubifs

Keyboard shortcuts

General

Issues and pull requests

Issues, pull requests and Inbox

Repository code