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

Commit c8566350 authored by Artem Bityutskiy's avatar Artem Bityutskiy
Browse files

UBI: fix and re-work debugging stuff 



Signed-off-by: default avatarArtem Bityutskiy <Artem.Bityutskiy@nokia.com>
parent 85c6e6e2

drivers/mtd/ubi/build.c

+1 −1
Original line number Diff line number Diff line
@@ -403,7 +403,7 @@ static int uif_init(struct ubi_device *ubi) 


	ubi_assert(MINOR(dev) == 0);

	cdev_init(&ubi->cdev, &ubi_cdev_operations);

	dbg_msg("%s major is %u", ubi->ubi_name, MAJOR(dev));

	dbg_gen("%s major is %u", ubi->ubi_name, MAJOR(dev));

	ubi->cdev.owner = THIS_MODULE;



	err = cdev_add(&ubi->cdev, dev, 1);

drivers/mtd/ubi/cdev.c

+13 −13
Original line number Diff line number Diff line
@@ -116,7 +116,7 @@ static int vol_cdev_open(struct inode *inode, struct file *file) 
	else

		mode = UBI_READONLY;



	dbg_msg("open volume %d, mode %d", vol_id, mode);

	dbg_gen("open volume %d, mode %d", vol_id, mode);



	desc = ubi_open_volume(ubi_num, vol_id, mode);

	unlock_kernel();
@@ -132,7 +132,7 @@ static int vol_cdev_release(struct inode *inode, struct file *file) 
	struct ubi_volume_desc *desc = file->private_data;

	struct ubi_volume *vol = desc->vol;



	dbg_msg("release volume %d, mode %d", vol->vol_id, desc->mode);

	dbg_gen("release volume %d, mode %d", vol->vol_id, desc->mode);



	if (vol->updating) {

		ubi_warn("update of volume %d not finished, volume is damaged",
@@ -141,7 +141,7 @@ static int vol_cdev_release(struct inode *inode, struct file *file) 
		vol->updating = 0;

		vfree(vol->upd_buf);

	} else if (vol->changing_leb) {

		dbg_msg("only %lld of %lld bytes received for atomic LEB change"

		dbg_gen("only %lld of %lld bytes received for atomic LEB change"

			" for volume %d:%d, cancel", vol->upd_received,

			vol->upd_bytes, vol->ubi->ubi_num, vol->vol_id);

		vol->changing_leb = 0;
@@ -183,7 +183,7 @@ static loff_t vol_cdev_llseek(struct file *file, loff_t offset, int origin) 
		return -EINVAL;

	}



	dbg_msg("seek volume %d, offset %lld, origin %d, new offset %lld",

	dbg_gen("seek volume %d, offset %lld, origin %d, new offset %lld",

		vol->vol_id, offset, origin, new_offset);



	file->f_pos = new_offset;
@@ -201,7 +201,7 @@ static ssize_t vol_cdev_read(struct file *file, __user char *buf, size_t count, 
	void *tbuf;

	uint64_t tmp;



	dbg_msg("read %zd bytes from offset %lld of volume %d",

	dbg_gen("read %zd bytes from offset %lld of volume %d",

		count, *offp, vol->vol_id);



	if (vol->updating) {
@@ -216,7 +216,7 @@ static ssize_t vol_cdev_read(struct file *file, __user char *buf, size_t count, 
		return 0;



	if (vol->corrupted)

		dbg_msg("read from corrupted volume %d", vol->vol_id);

		dbg_gen("read from corrupted volume %d", vol->vol_id);



	if (*offp + count > vol->used_bytes)

		count_save = count = vol->used_bytes - *offp;
@@ -285,7 +285,7 @@ static ssize_t vol_cdev_direct_write(struct file *file, const char __user *buf, 
	char *tbuf;

	uint64_t tmp;



	dbg_msg("requested: write %zd bytes to offset %lld of volume %u",

	dbg_gen("requested: write %zd bytes to offset %lld of volume %u",

		count, *offp, vol->vol_id);



	if (vol->vol_type == UBI_STATIC_VOLUME)
@@ -514,7 +514,7 @@ static int vol_cdev_ioctl(struct inode *inode, struct file *file, 
			break;

		}



		dbg_msg("erase LEB %d:%d", vol->vol_id, lnum);

		dbg_gen("erase LEB %d:%d", vol->vol_id, lnum);

		err = ubi_eba_unmap_leb(ubi, vol, lnum);

		if (err)

			break;
@@ -626,7 +626,7 @@ static int ubi_cdev_ioctl(struct inode *inode, struct file *file, 
	{

		struct ubi_mkvol_req req;



		dbg_msg("create volume");

		dbg_gen("create volume");

		err = copy_from_user(&req, argp, sizeof(struct ubi_mkvol_req));

		if (err) {

			err = -EFAULT;
@@ -656,7 +656,7 @@ static int ubi_cdev_ioctl(struct inode *inode, struct file *file, 
	{

		int vol_id;



		dbg_msg("remove volume");

		dbg_gen("remove volume");

		err = get_user(vol_id, (__user int32_t *)argp);

		if (err) {

			err = -EFAULT;
@@ -689,7 +689,7 @@ static int ubi_cdev_ioctl(struct inode *inode, struct file *file, 
		uint64_t tmp;

		struct ubi_rsvol_req req;



		dbg_msg("re-size volume");

		dbg_gen("re-size volume");

		err = copy_from_user(&req, argp, sizeof(struct ubi_rsvol_req));

		if (err) {

			err = -EFAULT;
@@ -742,7 +742,7 @@ static int ctrl_cdev_ioctl(struct inode *inode, struct file *file, 
		struct ubi_attach_req req;

		struct mtd_info *mtd;



		dbg_msg("attach MTD device");

		dbg_gen("attach MTD device");

		err = copy_from_user(&req, argp, sizeof(struct ubi_attach_req));

		if (err) {

			err = -EFAULT;
@@ -782,7 +782,7 @@ static int ctrl_cdev_ioctl(struct inode *inode, struct file *file, 
	{

		int ubi_num;



		dbg_msg("dettach MTD device");

		dbg_gen("dettach MTD device");

		err = get_user(ubi_num, (__user int32_t *)argp);

		if (err) {

			err = -EFAULT;

drivers/mtd/ubi/debug.c

+84 −76
Original line number Diff line number Diff line
@@ -24,7 +24,7 @@ 
 * changes.

 */



#ifdef CONFIG_MTD_UBI_DEBUG_MSG

#ifdef CONFIG_MTD_UBI_DEBUG



#include "ubi.h"
@@ -34,14 +34,19 @@ 
 */

void ubi_dbg_dump_ec_hdr(const struct ubi_ec_hdr *ec_hdr)

{

	dbg_msg("erase counter header dump:");

	dbg_msg("magic          %#08x", be32_to_cpu(ec_hdr->magic));

	dbg_msg("version        %d",    (int)ec_hdr->version);

	dbg_msg("ec             %llu",  (long long)be64_to_cpu(ec_hdr->ec));

	dbg_msg("vid_hdr_offset %d",    be32_to_cpu(ec_hdr->vid_hdr_offset));

	dbg_msg("data_offset    %d",    be32_to_cpu(ec_hdr->data_offset));

	dbg_msg("hdr_crc        %#08x", be32_to_cpu(ec_hdr->hdr_crc));

	dbg_msg("erase counter header hexdump:");

	printk(KERN_DEBUG "Erase counter header dump:\n");

	printk(KERN_DEBUG "\tmagic          %#08x\n",

	       be32_to_cpu(ec_hdr->magic));

	printk(KERN_DEBUG "\tversion        %d\n", (int)ec_hdr->version);

	printk(KERN_DEBUG "\tec             %llu\n",

	       (long long)be64_to_cpu(ec_hdr->ec));

	printk(KERN_DEBUG "\tvid_hdr_offset %d\n",

	       be32_to_cpu(ec_hdr->vid_hdr_offset));

	printk(KERN_DEBUG "\tdata_offset    %d\n",

	       be32_to_cpu(ec_hdr->data_offset));

	printk(KERN_DEBUG "\thdr_crc        %#08x\n",

	       be32_to_cpu(ec_hdr->hdr_crc));

	printk(KERN_DEBUG "erase counter header hexdump:\n");

	print_hex_dump(KERN_DEBUG, "", DUMP_PREFIX_OFFSET, 32, 1,

		       ec_hdr, UBI_EC_HDR_SIZE, 1);

}
@@ -52,22 +57,24 @@ void ubi_dbg_dump_ec_hdr(const struct ubi_ec_hdr *ec_hdr) 
 */

void ubi_dbg_dump_vid_hdr(const struct ubi_vid_hdr *vid_hdr)

{

	dbg_msg("volume identifier header dump:");

	dbg_msg("magic     %08x", be32_to_cpu(vid_hdr->magic));

	dbg_msg("version   %d",   (int)vid_hdr->version);

	dbg_msg("vol_type  %d",   (int)vid_hdr->vol_type);

	dbg_msg("copy_flag %d",   (int)vid_hdr->copy_flag);

	dbg_msg("compat    %d",   (int)vid_hdr->compat);

	dbg_msg("vol_id    %d",   be32_to_cpu(vid_hdr->vol_id));

	dbg_msg("lnum      %d",   be32_to_cpu(vid_hdr->lnum));

	dbg_msg("leb_ver   %u",   be32_to_cpu(vid_hdr->leb_ver));

	dbg_msg("data_size %d",   be32_to_cpu(vid_hdr->data_size));

	dbg_msg("used_ebs  %d",   be32_to_cpu(vid_hdr->used_ebs));

	dbg_msg("data_pad  %d",   be32_to_cpu(vid_hdr->data_pad));

	dbg_msg("sqnum     %llu",

	printk(KERN_DEBUG "Volume identifier header dump:\n");

	printk(KERN_DEBUG "\tmagic     %08x\n", be32_to_cpu(vid_hdr->magic));

	printk(KERN_DEBUG "\tversion   %d\n",   (int)vid_hdr->version);

	printk(KERN_DEBUG "\tvol_type  %d\n",   (int)vid_hdr->vol_type);

	printk(KERN_DEBUG "\tcopy_flag %d\n",   (int)vid_hdr->copy_flag);

	printk(KERN_DEBUG "\tcompat    %d\n",   (int)vid_hdr->compat);

	printk(KERN_DEBUG "\tvol_id    %d\n",   be32_to_cpu(vid_hdr->vol_id));

	printk(KERN_DEBUG "\tlnum      %d\n",   be32_to_cpu(vid_hdr->lnum));

	printk(KERN_DEBUG "\tleb_ver   %u\n",   be32_to_cpu(vid_hdr->leb_ver));

	printk(KERN_DEBUG "\tdata_size %d\n",   be32_to_cpu(vid_hdr->data_size));

	printk(KERN_DEBUG "\tused_ebs  %d\n",   be32_to_cpu(vid_hdr->used_ebs));

	printk(KERN_DEBUG "\tdata_pad  %d\n",   be32_to_cpu(vid_hdr->data_pad));

	printk(KERN_DEBUG "\tsqnum     %llu\n",

		(unsigned long long)be64_to_cpu(vid_hdr->sqnum));

	dbg_msg("hdr_crc   %08x", be32_to_cpu(vid_hdr->hdr_crc));

	dbg_msg("volume identifier header hexdump:");

	printk(KERN_DEBUG "\thdr_crc   %08x\n", be32_to_cpu(vid_hdr->hdr_crc));

	printk(KERN_DEBUG "Volume identifier header hexdump:\n");

	print_hex_dump(KERN_DEBUG, "", DUMP_PREFIX_OFFSET, 32, 1,

		       vid_hdr, UBI_VID_HDR_SIZE, 1);

}



/**
@@ -76,25 +83,25 @@ void ubi_dbg_dump_vid_hdr(const struct ubi_vid_hdr *vid_hdr) 
 */

void ubi_dbg_dump_vol_info(const struct ubi_volume *vol)

{

	dbg_msg("volume information dump:");

	dbg_msg("vol_id          %d", vol->vol_id);

	dbg_msg("reserved_pebs   %d", vol->reserved_pebs);

	dbg_msg("alignment       %d", vol->alignment);

	dbg_msg("data_pad        %d", vol->data_pad);

	dbg_msg("vol_type        %d", vol->vol_type);

	dbg_msg("name_len        %d", vol->name_len);

	dbg_msg("usable_leb_size %d", vol->usable_leb_size);

	dbg_msg("used_ebs        %d", vol->used_ebs);

	dbg_msg("used_bytes      %lld", vol->used_bytes);

	dbg_msg("last_eb_bytes   %d", vol->last_eb_bytes);

	dbg_msg("corrupted       %d", vol->corrupted);

	dbg_msg("upd_marker      %d", vol->upd_marker);

	printk(KERN_DEBUG "Volume information dump:\n");

	printk(KERN_DEBUG "\tvol_id          %d\n", vol->vol_id);

	printk(KERN_DEBUG "\treserved_pebs   %d\n", vol->reserved_pebs);

	printk(KERN_DEBUG "\talignment       %d\n", vol->alignment);

	printk(KERN_DEBUG "\tdata_pad        %d\n", vol->data_pad);

	printk(KERN_DEBUG "\tvol_type        %d\n", vol->vol_type);

	printk(KERN_DEBUG "\tname_len        %d\n", vol->name_len);

	printk(KERN_DEBUG "\tusable_leb_size %d\n", vol->usable_leb_size);

	printk(KERN_DEBUG "\tused_ebs        %d\n", vol->used_ebs);

	printk(KERN_DEBUG "\tused_bytes      %lld\n", vol->used_bytes);

	printk(KERN_DEBUG "\tlast_eb_bytes   %d\n", vol->last_eb_bytes);

	printk(KERN_DEBUG "\tcorrupted       %d\n", vol->corrupted);

	printk(KERN_DEBUG "\tupd_marker      %d\n", vol->upd_marker);



	if (vol->name_len <= UBI_VOL_NAME_MAX &&

	    strnlen(vol->name, vol->name_len + 1) == vol->name_len) {

		dbg_msg("name            %s", vol->name);

		printk(KERN_DEBUG "\tname            %s\n", vol->name);

	} else {

		dbg_msg("the 1st 5 characters of the name: %c%c%c%c%c",

		printk(KERN_DEBUG "\t1st 5 characters of name: %c%c%c%c%c\n",

		       vol->name[0], vol->name[1], vol->name[2],

		       vol->name[3], vol->name[4]);

	}
@@ -109,28 +116,29 @@ void ubi_dbg_dump_vtbl_record(const struct ubi_vtbl_record *r, int idx) 
{

	int name_len = be16_to_cpu(r->name_len);



	dbg_msg("volume table record %d dump:", idx);

	dbg_msg("reserved_pebs   %d", be32_to_cpu(r->reserved_pebs));

	dbg_msg("alignment       %d", be32_to_cpu(r->alignment));

	dbg_msg("data_pad        %d", be32_to_cpu(r->data_pad));

	dbg_msg("vol_type        %d", (int)r->vol_type);

	dbg_msg("upd_marker      %d", (int)r->upd_marker);

	dbg_msg("name_len        %d", name_len);

	printk(KERN_DEBUG "Volume table record %d dump:\n", idx);

	printk(KERN_DEBUG "\treserved_pebs   %d\n",

	       be32_to_cpu(r->reserved_pebs));

	printk(KERN_DEBUG "\talignment       %d\n", be32_to_cpu(r->alignment));

	printk(KERN_DEBUG "\tdata_pad        %d\n", be32_to_cpu(r->data_pad));

	printk(KERN_DEBUG "\tvol_type        %d\n", (int)r->vol_type);

	printk(KERN_DEBUG "\tupd_marker      %d\n", (int)r->upd_marker);

	printk(KERN_DEBUG "\tname_len        %d\n", name_len);



	if (r->name[0] == '\0') {

		dbg_msg("name            NULL");

		printk(KERN_DEBUG "\tname            NULL\n");

		return;

	}



	if (name_len <= UBI_VOL_NAME_MAX &&

	    strnlen(&r->name[0], name_len + 1) == name_len) {

		dbg_msg("name            %s", &r->name[0]);

		printk(KERN_DEBUG "\tname            %s\n", &r->name[0]);

	} else {

		dbg_msg("1st 5 characters of the name: %c%c%c%c%c",

		printk(KERN_DEBUG "\t1st 5 characters of name: %c%c%c%c%c\n",

			r->name[0], r->name[1], r->name[2], r->name[3],

			r->name[4]);

	}

	dbg_msg("crc             %#08x", be32_to_cpu(r->crc));

	printk(KERN_DEBUG "\tcrc             %#08x\n", be32_to_cpu(r->crc));

}



/**
@@ -139,15 +147,15 @@ void ubi_dbg_dump_vtbl_record(const struct ubi_vtbl_record *r, int idx) 
 */

void ubi_dbg_dump_sv(const struct ubi_scan_volume *sv)

{

	dbg_msg("volume scanning information dump:");

	dbg_msg("vol_id         %d", sv->vol_id);

	dbg_msg("highest_lnum   %d", sv->highest_lnum);

	dbg_msg("leb_count      %d", sv->leb_count);

	dbg_msg("compat         %d", sv->compat);

	dbg_msg("vol_type       %d", sv->vol_type);

	dbg_msg("used_ebs       %d", sv->used_ebs);

	dbg_msg("last_data_size %d", sv->last_data_size);

	dbg_msg("data_pad       %d", sv->data_pad);

	printk(KERN_DEBUG "Volume scanning information dump:\n");

	printk(KERN_DEBUG "\tvol_id         %d\n", sv->vol_id);

	printk(KERN_DEBUG "\thighest_lnum   %d\n", sv->highest_lnum);

	printk(KERN_DEBUG "\tleb_count      %d\n", sv->leb_count);

	printk(KERN_DEBUG "\tcompat         %d\n", sv->compat);

	printk(KERN_DEBUG "\tvol_type       %d\n", sv->vol_type);

	printk(KERN_DEBUG "\tused_ebs       %d\n", sv->used_ebs);

	printk(KERN_DEBUG "\tlast_data_size %d\n", sv->last_data_size);

	printk(KERN_DEBUG "\tdata_pad       %d\n", sv->data_pad);

}



/**
@@ -157,14 +165,14 @@ void ubi_dbg_dump_sv(const struct ubi_scan_volume *sv) 
 */

void ubi_dbg_dump_seb(const struct ubi_scan_leb *seb, int type)

{

	dbg_msg("eraseblock scanning information dump:");

	dbg_msg("ec       %d", seb->ec);

	dbg_msg("pnum     %d", seb->pnum);

	printk(KERN_DEBUG "eraseblock scanning information dump:\n");

	printk(KERN_DEBUG "\tec       %d\n", seb->ec);

	printk(KERN_DEBUG "\tpnum     %d\n", seb->pnum);

	if (type == 0) {

		dbg_msg("lnum     %d", seb->lnum);

		dbg_msg("scrub    %d", seb->scrub);

		dbg_msg("sqnum    %llu", seb->sqnum);

		dbg_msg("leb_ver  %u", seb->leb_ver);

		printk(KERN_DEBUG "\tlnum     %d\n", seb->lnum);

		printk(KERN_DEBUG "\tscrub    %d\n", seb->scrub);

		printk(KERN_DEBUG "\tsqnum    %llu\n", seb->sqnum);

		printk(KERN_DEBUG "\tleb_ver  %u\n", seb->leb_ver);

	}

}
@@ -176,16 +184,16 @@ void ubi_dbg_dump_mkvol_req(const struct ubi_mkvol_req *req) 
{

	char nm[17];



	dbg_msg("volume creation request dump:");

	dbg_msg("vol_id    %d",   req->vol_id);

	dbg_msg("alignment %d",   req->alignment);

	dbg_msg("bytes     %lld", (long long)req->bytes);

	dbg_msg("vol_type  %d",   req->vol_type);

	dbg_msg("name_len  %d",   req->name_len);

	printk(KERN_DEBUG "Volume creation request dump:\n");

	printk(KERN_DEBUG "\tvol_id    %d\n",   req->vol_id);

	printk(KERN_DEBUG "\talignment %d\n",   req->alignment);

	printk(KERN_DEBUG "\tbytes     %lld\n", (long long)req->bytes);

	printk(KERN_DEBUG "\tvol_type  %d\n",   req->vol_type);

	printk(KERN_DEBUG "\tname_len  %d\n",   req->name_len);



	memcpy(nm, req->name, 16);

	nm[16] = 0;

	dbg_msg("the 1st 16 characters of the name: %s", nm);

	printk(KERN_DEBUG "\t1st 16 characters of name: %s\n", nm);

}



#endif /* CONFIG_MTD_UBI_DEBUG_MSG */
 
#endif /* CONFIG_MTD_UBI_DEBUG */

drivers/mtd/ubi/debug.h

+44 −24
Original line number Diff line number Diff line
@@ -24,21 +24,16 @@ 
#ifdef CONFIG_MTD_UBI_DEBUG

#include <linux/random.h>



#define ubi_assert(expr)  BUG_ON(!(expr))

#define dbg_err(fmt, ...) ubi_err(fmt, ##__VA_ARGS__)

#else

#define ubi_assert(expr)  ({})

#define dbg_err(fmt, ...) ({})

#endif



#ifdef CONFIG_MTD_UBI_DEBUG_DISABLE_BGT

#define DBG_DISABLE_BGT 1

#else

#define DBG_DISABLE_BGT 0

#endif

#define ubi_assert(expr)  do {                                               \

        if (unlikely(!(expr))) {                                             \

                printk(KERN_CRIT "UBI assert failed in %s at %u (pid %d)\n", \

                       __func__, __LINE__, current->pid);                    \

                ubi_dbg_dump_stack();                                        \

        }                                                                    \

} while (0)



#ifdef CONFIG_MTD_UBI_DEBUG_MSG

/* Generic debugging message */

#define dbg_msg(fmt, ...)                                    \

	printk(KERN_DEBUG "UBI DBG (pid %d): %s: " fmt "\n", \

	       current->pid, __func__, ##__VA_ARGS__)
@@ -61,19 +56,12 @@ void ubi_dbg_dump_sv(const struct ubi_scan_volume *sv); 
void ubi_dbg_dump_seb(const struct ubi_scan_leb *seb, int type);

void ubi_dbg_dump_mkvol_req(const struct ubi_mkvol_req *req);



#ifdef CONFIG_MTD_UBI_DEBUG_MSG

/* General debugging messages */

#define dbg_gen(fmt, ...) dbg_msg(fmt, ##__VA_ARGS__)

#else



#define dbg_msg(fmt, ...)    ({})

#define ubi_dbg_dump_stack() ({})

#define ubi_dbg_dump_ec_hdr(ec_hdr)      ({})

#define ubi_dbg_dump_vid_hdr(vid_hdr)    ({})

#define ubi_dbg_dump_vol_info(vol)       ({})

#define ubi_dbg_dump_vtbl_record(r, idx) ({})

#define ubi_dbg_dump_sv(sv)              ({})

#define ubi_dbg_dump_seb(seb, type)      ({})

#define ubi_dbg_dump_mkvol_req(req)      ({})



#endif /* CONFIG_MTD_UBI_DEBUG_MSG */

#define dbg_gen(fmt, ...) ({})

#endif



#ifdef CONFIG_MTD_UBI_DEBUG_MSG_EBA

/* Messages from the eraseblock association sub-system */
@@ -105,6 +93,12 @@ void ubi_dbg_dump_mkvol_req(const struct ubi_mkvol_req *req); 
#define UBI_IO_DEBUG 0

#endif



#ifdef CONFIG_MTD_UBI_DEBUG_DISABLE_BGT

#define DBG_DISABLE_BGT 1

#else

#define DBG_DISABLE_BGT 0

#endif



#ifdef CONFIG_MTD_UBI_DEBUG_EMULATE_BITFLIPS

/**

 * ubi_dbg_is_bitflip - if it is time to emulate a bit-flip.
@@ -149,4 +143,30 @@ static inline int ubi_dbg_is_erase_failure(void) 
#define ubi_dbg_is_erase_failure() 0

#endif



#else



#define ubi_assert(expr)                 ({})

#define dbg_err(fmt, ...)                ({})

#define dbg_msg(fmt, ...)                ({})

#define dbg_gen(fmt, ...)                ({})

#define dbg_eba(fmt, ...)                ({})

#define dbg_wl(fmt, ...)                 ({})

#define dbg_io(fmt, ...)                 ({})

#define dbg_bld(fmt, ...)                ({})

#define ubi_dbg_dump_stack()             ({})

#define ubi_dbg_dump_ec_hdr(ec_hdr)      ({})

#define ubi_dbg_dump_vid_hdr(vid_hdr)    ({})

#define ubi_dbg_dump_vol_info(vol)       ({})

#define ubi_dbg_dump_vtbl_record(r, idx) ({})

#define ubi_dbg_dump_sv(sv)              ({})

#define ubi_dbg_dump_seb(seb, type)      ({})

#define ubi_dbg_dump_mkvol_req(req)      ({})



#define UBI_IO_DEBUG               0

#define DBG_DISABLE_BGT            0

#define ubi_dbg_is_bitflip()       0

#define ubi_dbg_is_write_failure() 0

#define ubi_dbg_is_erase_failure() 0



#endif /* !CONFIG_MTD_UBI_DEBUG */

#endif /* !__UBI_DEBUG_H__ */

drivers/mtd/ubi/gluebi.c

+5 −5
Original line number Diff line number Diff line
@@ -111,7 +111,7 @@ static int gluebi_read(struct mtd_info *mtd, loff_t from, size_t len, 
	struct ubi_device *ubi;

	uint64_t tmp = from;



	dbg_msg("read %zd bytes from offset %lld", len, from);

	dbg_gen("read %zd bytes from offset %lld", len, from);



	if (len < 0 || from < 0 || from + len > mtd->size)

		return -EINVAL;
@@ -162,7 +162,7 @@ static int gluebi_write(struct mtd_info *mtd, loff_t to, size_t len, 
	struct ubi_device *ubi;

	uint64_t tmp = to;



	dbg_msg("write %zd bytes to offset %lld", len, to);

	dbg_gen("write %zd bytes to offset %lld", len, to);



	if (len < 0 || to < 0 || len + to > mtd->size)

		return -EINVAL;
@@ -215,7 +215,7 @@ static int gluebi_erase(struct mtd_info *mtd, struct erase_info *instr) 
	struct ubi_volume *vol;

	struct ubi_device *ubi;



	dbg_msg("erase %u bytes at offset %u", instr->len, instr->addr);

	dbg_gen("erase %u bytes at offset %u", instr->len, instr->addr);



	if (instr->addr < 0 || instr->addr > mtd->size - mtd->erasesize)

		return -EINVAL;
@@ -304,7 +304,7 @@ int ubi_create_gluebi(struct ubi_device *ubi, struct ubi_volume *vol) 
		return -ENFILE;

	}



	dbg_msg("added mtd%d (\"%s\"), size %u, EB size %u",

	dbg_gen("added mtd%d (\"%s\"), size %u, EB size %u",

		mtd->index, mtd->name, mtd->size, mtd->erasesize);

	return 0;

}
@@ -322,7 +322,7 @@ int ubi_destroy_gluebi(struct ubi_volume *vol) 
	int err;

	struct mtd_info *mtd = &vol->gluebi_mtd;



	dbg_msg("remove mtd%d", mtd->index);

	dbg_gen("remove mtd%d", mtd->index);

	err = del_mtd_device(mtd);

	if (err)

		return err;