Merge tag 'upstream-4.8-rc1' of git://git.infradead.org/linux-ubifs (3a303258) · Commits · 戴 / test

drivers/mtd/ubi/attach.c

+106 −35

Original line number	Diff line number	Diff line
		@@ -174,6 +174,40 @@ static int add_corrupted(struct ubi_attach_info *ai, int pnum, int ec)
		return 0;
		}

		/**
		* add_fastmap - add a Fastmap related physical eraseblock.
		* @ai: attaching information
		* @pnum: physical eraseblock number the VID header came from
		* @vid_hdr: the volume identifier header
		* @ec: erase counter of the physical eraseblock
		*
		* This function allocates a 'struct ubi_ainf_peb' object for a Fastamp
		* physical eraseblock @pnum and adds it to the 'fastmap' list.
		* Such blocks can be Fastmap super and data blocks from both the most
		* recent Fastmap we're attaching from or from old Fastmaps which will
		* be erased.
		*/
		static int add_fastmap(struct ubi_attach_info *ai, int pnum,
		struct ubi_vid_hdr *vid_hdr, int ec)
		{
		struct ubi_ainf_peb *aeb;

		aeb = kmem_cache_alloc(ai->aeb_slab_cache, GFP_KERNEL);
		if (!aeb)
		return -ENOMEM;

		aeb->pnum = pnum;
		aeb->vol_id = be32_to_cpu(vidh->vol_id);
		aeb->sqnum = be64_to_cpu(vidh->sqnum);
		aeb->ec = ec;
		list_add(&aeb->u.list, &ai->fastmap);

		dbg_bld("add to fastmap list: PEB %d, vol_id %d, sqnum: %llu", pnum,
		aeb->vol_id, aeb->sqnum);

		return 0;
		}

		/**
		* validate_vid_hdr - check volume identifier header.
		* @ubi: UBI device description object
		@@ -803,13 +837,26 @@ out_unlock:
		return err;
		}

		static bool vol_ignored(int vol_id)
		{
		switch (vol_id) {
		case UBI_LAYOUT_VOLUME_ID:
		return true;
		}

		#ifdef CONFIG_MTD_UBI_FASTMAP
		return ubi_is_fm_vol(vol_id);
		#else
		return false;
		#endif
		}

		/**
		* scan_peb - scan and process UBI headers of a PEB.
		* @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
		* @fast: true if we're scanning for a Fastmap
		*
		* 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,9 +864,9 @@ 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 vid, unsigned long long sqnum)
		int pnum, bool fast)
		{
		long long uninitialized_var(ec);
		long long ec;
		int err, bitflips = 0, vol_id = -1, ec_err = 0;

		dbg_bld("scan PEB %d", pnum);
		@@ -935,6 +982,20 @@ static int scan_peb(struct ubi_device ubi, struct ubi_attach_info ai,
		*/
		ai->maybe_bad_peb_count += 1;
		case UBI_IO_BAD_HDR:
		/*
		* If we're facing a bad VID header we have to drop all
		* Fastmap data structures we find. The most recent Fastmap
		* could be bad and therefore there is a chance that we attach
		* from an old one. On a fine MTD stack a PEB must not render
		* bad all of a sudden, but the reality is different.
		* So, let's be paranoid and help finding the root cause by
		* falling back to scanning mode instead of attaching with a
		* bad EBA table and cause data corruption which is hard to
		* analyze.
		*/
		if (fast)
		ai->force_full_scan = 1;

		if (ec_err)
		/*
		* Both headers are corrupted. There is a possibility
		@@ -991,21 +1052,15 @@ 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) {
		if (vol_id > UBI_MAX_VOLUMES && !vol_ignored(vol_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(ubi, "\"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)
		@@ -1037,7 +1092,12 @@ static int scan_peb(struct ubi_device ubi, struct ubi_attach_info ai,
		if (ec_err)
		ubi_warn(ubi, "valid VID header but corrupted EC header at PEB %d",
		pnum);

		if (ubi_is_fm_vol(vol_id))
		err = add_fastmap(ai, pnum, vidh, ec);
		else
		err = ubi_add_to_av(ubi, ai, pnum, ec, vidh, bitflips);

		if (err)
		return err;

		@@ -1186,6 +1246,10 @@ static void destroy_ai(struct ubi_attach_info *ai)
		list_del(&aeb->u.list);
		kmem_cache_free(ai->aeb_slab_cache, aeb);
		}
		list_for_each_entry_safe(aeb, aeb_tmp, &ai->fastmap, 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;
		@@ -1245,7 +1309,7 @@ static int scan_all(struct ubi_device ubi, struct ubi_attach_info ai,
		cond_resched();

		dbg_gen("process PEB %d", pnum);
		err = scan_peb(ubi, ai, pnum, NULL, NULL);
		err = scan_peb(ubi, ai, pnum, false);
		if (err < 0)
		goto out_vidh;
		}
		@@ -1311,6 +1375,7 @@ static struct ubi_attach_info *alloc_ai(void)
		INIT_LIST_HEAD(&ai->free);
		INIT_LIST_HEAD(&ai->erase);
		INIT_LIST_HEAD(&ai->alien);
		INIT_LIST_HEAD(&ai->fastmap);
		ai->volumes = RB_ROOT;
		ai->aeb_slab_cache = kmem_cache_create("ubi_aeb_slab_cache",
		sizeof(struct ubi_ainf_peb),
		@@ -1326,7 +1391,7 @@ static struct ubi_attach_info *alloc_ai(void)
		#ifdef CONFIG_MTD_UBI_FASTMAP

		/**
		* scan_fastmap - try to find a fastmap and attach from it.
		* scan_fast - try to find a fastmap and attach from it.
		* @ubi: UBI device description object
		* @ai: attach info object
		*
		@@ -1337,52 +1402,58 @@ static struct ubi_attach_info *alloc_ai(void)
		*/
		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;
		int err, pnum;
		struct ubi_attach_info *scan_ai;

		err = -ENOMEM;

		scan_ai = alloc_ai();
		if (!scan_ai)
		goto out;

		ech = kzalloc(ubi->ec_hdr_alsize, GFP_KERNEL);
		if (!ech)
		goto out;
		goto out_ai;

		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);
		err = scan_peb(ubi, scan_ai, pnum, true);
		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;
		if (scan_ai->force_full_scan)
		err = UBI_NO_FASTMAP;
		else
		err = ubi_scan_fastmap(ubi, *ai, scan_ai);

		if (err) {
		/*
		* Didn't attach via fastmap, do a full scan but reuse what
		* we've aready scanned.
		*/
		destroy_ai(*ai);
		*ai = alloc_ai();
		if (!*ai)
		return -ENOMEM;
		*ai = scan_ai;
		} else
		destroy_ai(scan_ai);

		return ubi_scan_fastmap(ubi, *ai, fm_anchor);
		return err;

		out_vidh:
		ubi_free_vid_hdr(ubi, vidh);
		out_ech:
		kfree(ech);
		out_ai:
		destroy_ai(scan_ai);
		out:
		return err;
		}

drivers/mtd/ubi/build.c

+8 −5

Original line number	Diff line number	Diff line
		@@ -874,7 +874,7 @@ int ubi_attach_mtd_dev(struct mtd_info *mtd, int ubi_num,
		for (i = 0; i < UBI_MAX_DEVICES; i++) {
		ubi = ubi_devices[i];
		if (ubi && mtd->index == ubi->mtd->index) {
		ubi_err(ubi, "mtd%d is already attached to ubi%d",
		pr_err("ubi: mtd%d is already attached to ubi%d",
		mtd->index, i);
		return -EEXIST;
		}
		@@ -889,7 +889,7 @@ int ubi_attach_mtd_dev(struct mtd_info *mtd, int ubi_num,
		* no sense to attach emulated MTD devices, so we prohibit this.
		*/
		if (mtd->type == MTD_UBIVOLUME) {
		ubi_err(ubi, "refuse attaching mtd%d - it is already emulated on top of UBI",
		pr_err("ubi: refuse attaching mtd%d - it is already emulated on top of UBI",
		mtd->index);
		return -EINVAL;
		}
		@@ -900,7 +900,7 @@ int ubi_attach_mtd_dev(struct mtd_info *mtd, int ubi_num,
		if (!ubi_devices[ubi_num])
		break;
		if (ubi_num == UBI_MAX_DEVICES) {
		ubi_err(ubi, "only %d UBI devices may be created",
		pr_err("ubi: only %d UBI devices may be created",
		UBI_MAX_DEVICES);
		return -ENFILE;
		}
		@@ -910,7 +910,7 @@ int ubi_attach_mtd_dev(struct mtd_info *mtd, int ubi_num,

		/* Make sure ubi_num is not busy */
		if (ubi_devices[ubi_num]) {
		ubi_err(ubi, "already exists");
		pr_err("ubi: ubi%i already exists", ubi_num);
		return -EEXIST;
		}
		}
		@@ -992,6 +992,9 @@ int ubi_attach_mtd_dev(struct mtd_info *mtd, int ubi_num,
		goto out_detach;
		}

		/* Make device "available" before it becomes accessible via sysfs */
		ubi_devices[ubi_num] = ubi;

		err = uif_init(ubi, &ref);
		if (err)
		goto out_detach;
		@@ -1036,7 +1039,6 @@ int ubi_attach_mtd_dev(struct mtd_info *mtd, int ubi_num,
		wake_up_process(ubi->bgt_thread);
		spin_unlock(&ubi->wl_lock);

		ubi_devices[ubi_num] = ubi;
		ubi_notify_all(ubi, UBI_VOLUME_ADDED, NULL);
		return ubi_num;

		@@ -1047,6 +1049,7 @@ out_uif:
		ubi_assert(ref);
		uif_close(ubi);
		out_detach:
		ubi_devices[ubi_num] = NULL;
		ubi_wl_close(ubi);
		ubi_free_internal_volumes(ubi);
		vfree(ubi->vtbl);

drivers/mtd/ubi/fastmap.c

+52 −13

Original line number	Diff line number	Diff line
		@@ -15,20 +15,22 @@
		*/

		#include <linux/crc32.h>
		#include <linux/bitmap.h>
		#include "ubi.h"

		/**
		* init_seen - allocate memory for used for debugging.
		* @ubi: UBI device description object
		*/
		static inline int init_seen(struct ubi_device ubi)
		static inline unsigned long init_seen(struct ubi_device ubi)
		{
		int *ret;
		unsigned long *ret;

		if (!ubi_dbg_chk_fastmap(ubi))
		return NULL;

		ret = kcalloc(ubi->peb_count, sizeof(int), GFP_KERNEL);
		ret = kcalloc(BITS_TO_LONGS(ubi->peb_count), sizeof(unsigned long),
		GFP_KERNEL);
		if (!ret)
		return ERR_PTR(-ENOMEM);

		@@ -39,7 +41,7 @@ static inline int init_seen(struct ubi_device ubi)
		* free_seen - free the seen logic integer array.
		* @seen: integer array of @ubi->peb_count size
		*/
		static inline void free_seen(int *seen)
		static inline void free_seen(unsigned long *seen)
		{
		kfree(seen);
		}
		@@ -50,12 +52,12 @@ static inline void free_seen(int *seen)
		* @pnum: The PEB to be makred as seen
		* @seen: integer array of @ubi->peb_count size
		*/
		static inline void set_seen(struct ubi_device ubi, int pnum, int seen)
		static inline void set_seen(struct ubi_device ubi, int pnum, unsigned long seen)
		{
		if (!ubi_dbg_chk_fastmap(ubi) \|\| !seen)
		return;

		seen[pnum] = 1;
		set_bit(pnum, seen);
		}

		/**
		@@ -63,7 +65,7 @@ static inline void set_seen(struct ubi_device ubi, int pnum, int seen)
		* @ubi: UBI device description object
		* @seen: integer array of @ubi->peb_count size
		*/
		static int self_check_seen(struct ubi_device ubi, int seen)
		static int self_check_seen(struct ubi_device ubi, unsigned long seen)
		{
		int pnum, ret = 0;

		@@ -71,7 +73,7 @@ static int self_check_seen(struct ubi_device ubi, int seen)
		return 0;

		for (pnum = 0; pnum < ubi->peb_count; pnum++) {
		if (!seen[pnum] && ubi->lookuptbl[pnum]) {
		if (test_bit(pnum, seen) && ubi->lookuptbl[pnum]) {
		ubi_err(ubi, "self-check failed for PEB %d, fastmap didn't see it", pnum);
		ret = -EINVAL;
		}
		@@ -849,28 +851,58 @@ fail:
		return ret;
		}

		/**
		* find_fm_anchor - find the most recent Fastmap superblock (anchor)
		* @ai: UBI attach info to be filled
		*/
		static int find_fm_anchor(struct ubi_attach_info *ai)
		{
		int ret = -1;
		struct ubi_ainf_peb *aeb;
		unsigned long long max_sqnum = 0;

		list_for_each_entry(aeb, &ai->fastmap, u.list) {
		if (aeb->vol_id == UBI_FM_SB_VOLUME_ID && aeb->sqnum > max_sqnum) {
		max_sqnum = aeb->sqnum;
		ret = aeb->pnum;
		}
		}

		return ret;
		}

		/**
		* ubi_scan_fastmap - scan the fastmap.
		* @ubi: UBI device object
		* @ai: UBI attach info to be filled
		* @fm_anchor: The fastmap starts at this PEB
		* @scan_ai: UBI attach info from the first 64 PEBs,
		* used to find the most recent Fastmap data structure
		*
		* Returns 0 on success, UBI_NO_FASTMAP if no fastmap was found,
		* UBI_BAD_FASTMAP if one was found but is not usable.
		* < 0 indicates an internal error.
		*/
		int ubi_scan_fastmap(struct ubi_device ubi, struct ubi_attach_info ai,
		int fm_anchor)
		struct ubi_attach_info *scan_ai)
		{
		struct ubi_fm_sb fmsb, fmsb2;
		struct ubi_vid_hdr *vh;
		struct ubi_ec_hdr *ech;
		struct ubi_fastmap_layout *fm;
		int i, used_blocks, pnum, ret = 0;
		struct ubi_ainf_peb tmp_aeb, aeb;
		int i, used_blocks, pnum, fm_anchor, ret = 0;
		size_t fm_size;
		__be32 crc, tmp_crc;
		unsigned long long sqnum = 0;

		fm_anchor = find_fm_anchor(scan_ai);
		if (fm_anchor < 0)
		return UBI_NO_FASTMAP;

		/* Move all (possible) fastmap blocks into our new attach structure. */
		list_for_each_entry_safe(aeb, tmp_aeb, &scan_ai->fastmap, u.list)
		list_move_tail(&aeb->u.list, &ai->fastmap);

		down_write(&ubi->fm_protect);
		memset(ubi->fm_buf, 0, ubi->fm_size);

		@@ -945,6 +977,13 @@ int ubi_scan_fastmap(struct ubi_device ubi, struct ubi_attach_info ai,
		goto free_hdr;
		}

		if (i == 0 && pnum != fm_anchor) {
		ubi_err(ubi, "Fastmap anchor PEB mismatch: PEB: %i vs. %i",
		pnum, fm_anchor);
		ret = UBI_BAD_FASTMAP;
		goto free_hdr;
		}

		ret = ubi_io_read_ec_hdr(ubi, pnum, ech, 0);
		if (ret && ret != UBI_IO_BITFLIPS) {
		ubi_err(ubi, "unable to read fastmap block# %i EC (PEB: %i)",
		@@ -1102,7 +1141,7 @@ static int ubi_write_fastmap(struct ubi_device *ubi,
		struct rb_node *tmp_rb;
		int ret, i, j, free_peb_count, used_peb_count, vol_count;
		int scrub_peb_count, erase_peb_count;
		int *seen_pebs = NULL;
		unsigned long *seen_pebs = NULL;

		fm_raw = ubi->fm_buf;
		memset(ubi->fm_buf, 0, ubi->fm_size);

drivers/mtd/ubi/gluebi.c

+0 −5

Original line number	Diff line number	Diff line
		@@ -99,9 +99,6 @@ static int gluebi_get_device(struct mtd_info *mtd)
		struct gluebi_device *gluebi;
		int ubi_mode = UBI_READONLY;

		if (!try_module_get(THIS_MODULE))
		return -ENODEV;

		if (mtd->flags & MTD_WRITEABLE)
		ubi_mode = UBI_READWRITE;

		@@ -129,7 +126,6 @@ static int gluebi_get_device(struct mtd_info *mtd)
		ubi_mode);
		if (IS_ERR(gluebi->desc)) {
		mutex_unlock(&devices_mutex);
		module_put(THIS_MODULE);
		return PTR_ERR(gluebi->desc);
		}
		gluebi->refcnt += 1;
		@@ -153,7 +149,6 @@ static void gluebi_put_device(struct mtd_info *mtd)
		gluebi->refcnt -= 1;
		if (gluebi->refcnt == 0)
		ubi_close_volume(gluebi->desc);
		module_put(THIS_MODULE);
		mutex_unlock(&devices_mutex);
		}

drivers/mtd/ubi/io.c

+1 −1

Original line number	Diff line number	Diff line
		@@ -1019,7 +1019,7 @@ int ubi_io_read_vid_hdr(struct ubi_device *ubi, int pnum,

		p = (char *)vid_hdr - ubi->vid_hdr_shift;
		read_err = ubi_io_read(ubi, p, pnum, ubi->vid_hdr_aloffset,
		ubi->vid_hdr_alsize);
		ubi->vid_hdr_shift + UBI_VID_HDR_SIZE);
		if (read_err && read_err != UBI_IO_BITFLIPS && !mtd_is_eccerr(read_err))
		return read_err;

Admin message