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

Commit 4d429480 authored by Linus Torvalds's avatar Linus Torvalds
Browse files

Merge branch 'linux-next' of git://git.infradead.org/ubi-2.6 

* 'linux-next' of git://git.infradead.org/ubi-2.6:
  UBI: switch to dynamic printks
  UBI: turn some macros into static inline
  UBI: improve checking in debugging prints
  UBI: fix typo in a message
  UBI: fix minor stylistic issues
  UBI: use __packed instead of __attribute__((packed))
  UBI: cleanup comments around volume properties
  UBI: re-name set volume properties ioctl
  UBI: make the control character device non-seekable
parents eb08d8ff ab50ff68

drivers/mtd/ubi/cdev.c

+7 −7
Original line number Original line Diff line number Diff line
@@ -561,18 +561,18 @@ static long vol_cdev_ioctl(struct file *file, unsigned int cmd, 
	}

	}





	/* Set volume property command */

	/* Set volume property command */

	case UBI_IOCSETPROP:

	case UBI_IOCSETVOLPROP:

	{

	{

		struct ubi_set_prop_req req;

		struct ubi_set_vol_prop_req req;





		err = copy_from_user(&req, argp,

		err = copy_from_user(&req, argp,

				sizeof(struct ubi_set_prop_req));

				     sizeof(struct ubi_set_vol_prop_req));

		if (err) {

		if (err) {

			err = -EFAULT;

			err = -EFAULT;

			break;

			break;

		}

		}

		switch (req.property) {

		switch (req.property) {

		case UBI_PROP_DIRECT_WRITE:

		case UBI_VOL_PROP_DIRECT_WRITE:

			mutex_lock(&ubi->device_mutex);

			mutex_lock(&ubi->device_mutex);

			desc->vol->direct_writes = !!req.value;

			desc->vol->direct_writes = !!req.value;

			mutex_unlock(&ubi->device_mutex);

			mutex_unlock(&ubi->device_mutex);
@@ -1100,5 +1100,5 @@ const struct file_operations ubi_ctrl_cdev_operations = { 
	.owner          = THIS_MODULE,

	.owner          = THIS_MODULE,

	.unlocked_ioctl = ctrl_cdev_ioctl,

	.unlocked_ioctl = ctrl_cdev_ioctl,

	.compat_ioctl   = ctrl_cdev_compat_ioctl,

	.compat_ioctl   = ctrl_cdev_compat_ioctl,

	.llseek		= noop_llseek,

	.llseek		= no_llseek,

};
 
};

drivers/mtd/ubi/debug.c

+9 −12
Original line number Original line Diff line number Diff line
@@ -30,15 +30,12 @@ 
#include <linux/module.h>

#include <linux/module.h>

#include <linux/moduleparam.h>

#include <linux/moduleparam.h>





unsigned int ubi_msg_flags;

unsigned int ubi_chk_flags;

unsigned int ubi_chk_flags;

unsigned int ubi_tst_flags;

unsigned int ubi_tst_flags;





module_param_named(debug_msgs, ubi_msg_flags, uint, S_IRUGO | S_IWUSR);

module_param_named(debug_chks, ubi_chk_flags, uint, S_IRUGO | S_IWUSR);

module_param_named(debug_chks, ubi_chk_flags, uint, S_IRUGO | S_IWUSR);

module_param_named(debug_tsts, ubi_chk_flags, uint, S_IRUGO | S_IWUSR);

module_param_named(debug_tsts, ubi_chk_flags, uint, S_IRUGO | S_IWUSR);





MODULE_PARM_DESC(debug_msgs, "Debug message type flags");

MODULE_PARM_DESC(debug_chks, "Debug check flags");

MODULE_PARM_DESC(debug_chks, "Debug check flags");

MODULE_PARM_DESC(debug_tsts, "Debug special test flags");

MODULE_PARM_DESC(debug_tsts, "Debug special test flags");

drivers/mtd/ubi/debug.h

+82 −79
Original line number Original line Diff line number Diff line
@@ -21,11 +21,17 @@ 
#ifndef __UBI_DEBUG_H__

#ifndef __UBI_DEBUG_H__

#define __UBI_DEBUG_H__

#define __UBI_DEBUG_H__





struct ubi_ec_hdr;

struct ubi_vid_hdr;

struct ubi_volume;

struct ubi_vtbl_record;

struct ubi_scan_volume;

struct ubi_scan_leb;

struct ubi_mkvol_req;



#ifdef CONFIG_MTD_UBI_DEBUG

#ifdef CONFIG_MTD_UBI_DEBUG

#include <linux/random.h>

#include <linux/random.h>





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



#define ubi_assert(expr)  do {                                               \

#define ubi_assert(expr)  do {                                               \

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

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

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

		printk(KERN_CRIT "UBI assert failed in %s at %u (pid %d)\n", \
@@ -34,24 +40,28 @@ 
	}                                                                    \

	}                                                                    \

} while (0)

} while (0)





#define dbg_msg(fmt, ...)                                    \

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

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

	       current->pid, __func__, ##__VA_ARGS__)



#define dbg_do_msg(typ, fmt, ...) do {                       \

	if (ubi_msg_flags & typ)                             \

		dbg_msg(fmt, ##__VA_ARGS__);                 \

} while (0)





#define ubi_dbg_dump_stack() dump_stack()

#define ubi_dbg_dump_stack() dump_stack()





struct ubi_ec_hdr;

#define ubi_dbg_print_hex_dump(l, ps, pt, r, g, b, len, a)  \

struct ubi_vid_hdr;

		print_hex_dump(l, ps, pt, r, g, b, len, a)

struct ubi_volume;



struct ubi_vtbl_record;

#define ubi_dbg_msg(type, fmt, ...) \

struct ubi_scan_volume;

	pr_debug("UBI DBG " type ": " fmt "\n", ##__VA_ARGS__)

struct ubi_scan_leb;



struct ubi_mkvol_req;

/* Just a debugging messages not related to any specific UBI subsystem */

#define dbg_msg(fmt, ...) ubi_dbg_msg("msg", fmt, ##__VA_ARGS__)

/* General debugging messages */

#define dbg_gen(fmt, ...) ubi_dbg_msg("gen", fmt, ##__VA_ARGS__)

/* Messages from the eraseblock association sub-system */

#define dbg_eba(fmt, ...) ubi_dbg_msg("eba", fmt, ##__VA_ARGS__)

/* Messages from the wear-leveling sub-system */

#define dbg_wl(fmt, ...)  ubi_dbg_msg("wl", fmt, ##__VA_ARGS__)

/* Messages from the input/output sub-system */

#define dbg_io(fmt, ...)  ubi_dbg_msg("io", fmt, ##__VA_ARGS__)

/* Initialization and build messages */

#define dbg_bld(fmt, ...) ubi_dbg_msg("bld", fmt, ##__VA_ARGS__)





void ubi_dbg_dump_ec_hdr(const struct ubi_ec_hdr *ec_hdr);

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);

void ubi_dbg_dump_vid_hdr(const struct ubi_vid_hdr *vid_hdr);
@@ -62,43 +72,6 @@ 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);

void ubi_dbg_dump_mkvol_req(const struct ubi_mkvol_req *req);

void ubi_dbg_dump_flash(struct ubi_device *ubi, int pnum, int offset, int len);

void ubi_dbg_dump_flash(struct ubi_device *ubi, int pnum, int offset, int len);





extern unsigned int ubi_msg_flags;



/*

 * Debugging message type flags (must match msg_type_names in debug.c).

 *

 * UBI_MSG_GEN: general messages

 * UBI_MSG_EBA: journal messages

 * UBI_MSG_WL: mount messages

 * UBI_MSG_IO: commit messages

 * UBI_MSG_BLD: LEB find messages

 */

enum {

	UBI_MSG_GEN  = 0x1,

	UBI_MSG_EBA  = 0x2,

	UBI_MSG_WL   = 0x4,

	UBI_MSG_IO   = 0x8,

	UBI_MSG_BLD  = 0x10,

};



#define ubi_dbg_print_hex_dump(l, ps, pt, r, g, b, len, a)  \

		print_hex_dump(l, ps, pt, r, g, b, len, a)



/* General debugging messages */

#define dbg_gen(fmt, ...) dbg_do_msg(UBI_MSG_GEN, fmt, ##__VA_ARGS__)



/* Messages from the eraseblock association sub-system */

#define dbg_eba(fmt, ...) dbg_do_msg(UBI_MSG_EBA, fmt, ##__VA_ARGS__)



/* Messages from the wear-leveling sub-system */

#define dbg_wl(fmt, ...) dbg_do_msg(UBI_MSG_WL, fmt, ##__VA_ARGS__)



/* Messages from the input/output sub-system */

#define dbg_io(fmt, ...) dbg_do_msg(UBI_MSG_IO, fmt, ##__VA_ARGS__)



/* Initialization and build messages */

#define dbg_bld(fmt, ...) dbg_do_msg(UBI_MSG_BLD, fmt, ##__VA_ARGS__)



extern unsigned int ubi_chk_flags;

extern unsigned int ubi_chk_flags;





/*

/*
@@ -184,31 +157,61 @@ static inline int ubi_dbg_is_erase_failure(void) 




#else

#else





#define ubi_assert(expr)                 ({})

/* Use "if (0)" to make compiler check arguments even if debugging is off */

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

#define ubi_assert(expr)  do {                                               \

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

	if (0) {                                                             \

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

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

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

		       __func__, __LINE__, current->pid);                    \

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

	}                                                                    \

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

} while (0)

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



#define ubi_dbg_dump_stack()             ({})

#define dbg_err(fmt, ...) do {                                               \

#define ubi_dbg_dump_ec_hdr(ec_hdr)      ({})

	if (0)                                                               \

#define ubi_dbg_dump_vid_hdr(vid_hdr)    ({})

		ubi_err(fmt, ##__VA_ARGS__);                                 \

#define ubi_dbg_dump_vol_info(vol)       ({})

} while (0)

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



#define ubi_dbg_dump_sv(sv)              ({})

#define ubi_dbg_msg(fmt, ...) do {                                           \

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

	if (0)                                                               \

#define ubi_dbg_dump_mkvol_req(req)      ({})

		pr_debug(fmt "\n", ##__VA_ARGS__);                           \

#define ubi_dbg_dump_flash(ubi, pnum, offset, len) ({})

} while (0)

#define ubi_dbg_print_hex_dump(l, ps, pt, r, g, b, len, a)  ({})





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

#define ubi_dbg_is_bgt_disabled()  0

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

#define ubi_dbg_is_bitflip()       0

#define dbg_eba(fmt, ...)  ubi_dbg_msg(fmt, ##__VA_ARGS__)

#define ubi_dbg_is_write_failure() 0

#define dbg_wl(fmt, ...)   ubi_dbg_msg(fmt, ##__VA_ARGS__)

#define ubi_dbg_is_erase_failure() 0

#define dbg_io(fmt, ...)   ubi_dbg_msg(fmt, ##__VA_ARGS__)

#define ubi_dbg_check_all_ff(ubi, pnum, offset, len) 0

#define dbg_bld(fmt, ...)  ubi_dbg_msg(fmt, ##__VA_ARGS__)

#define ubi_dbg_check_write(ubi, buf, pnum, offset, len) 0



static inline void ubi_dbg_dump_stack(void)                          { return; }

static inline void

ubi_dbg_dump_ec_hdr(const struct ubi_ec_hdr *ec_hdr)                 { return; }

static inline void

ubi_dbg_dump_vid_hdr(const struct ubi_vid_hdr *vid_hdr)              { return; }

static inline void

ubi_dbg_dump_vol_info(const struct ubi_volume *vol)                  { return; }

static inline void

ubi_dbg_dump_vtbl_record(const struct ubi_vtbl_record *r, int idx)   { return; }

static inline void ubi_dbg_dump_sv(const struct ubi_scan_volume *sv) { return; }

static inline void ubi_dbg_dump_seb(const struct ubi_scan_leb *seb,

				    int type)                        { return; }

static inline void

ubi_dbg_dump_mkvol_req(const struct ubi_mkvol_req *req)              { return; }

static inline void ubi_dbg_dump_flash(struct ubi_device *ubi,

				      int pnum, int offset, int len) { return; }

static inline void

ubi_dbg_print_hex_dump(const char *l, const char *ps, int pt, int r,

		       int g, const void *b, size_t len, bool a)     { return; }



static inline int ubi_dbg_is_bgt_disabled(void)                    { return 0; }

static inline int ubi_dbg_is_bitflip(void)                         { return 0; }

static inline int ubi_dbg_is_write_failure(void)                   { return 0; }

static inline int ubi_dbg_is_erase_failure(void)                   { return 0; }

static inline int ubi_dbg_check_all_ff(struct ubi_device *ubi,

				       int pnum, int offset,

				       int len)                    { return 0; }

static inline int ubi_dbg_check_write(struct ubi_device *ubi,

				      const void *buf, int pnum,

				      int offset, int len)         { return 0; }





#endif /* !CONFIG_MTD_UBI_DEBUG */

#endif /* !CONFIG_MTD_UBI_DEBUG */

#endif /* !__UBI_DEBUG_H__ */
 
#endif /* !__UBI_DEBUG_H__ */

drivers/mtd/ubi/io.c

+3 −3
Original line number Original line Diff line number Diff line
@@ -189,8 +189,8 @@ retry: 
		}

		}





		if (retries++ < UBI_IO_RETRIES) {

		if (retries++ < UBI_IO_RETRIES) {

			dbg_io("error %d%s while reading %d bytes from PEB %d:%d,"

			dbg_io("error %d%s while reading %d bytes from PEB "

			       " read only %zd bytes, retry",

			       "%d:%d, read only %zd bytes, retry",

			       err, errstr, len, pnum, offset, read);

			       err, errstr, len, pnum, offset, read);

			yield();

			yield();

			goto retry;

			goto retry;
@@ -465,7 +465,7 @@ static int torture_peb(struct ubi_device *ubi, int pnum) 
	}

	}





	err = patt_count;

	err = patt_count;

	ubi_msg("PEB %d passed torture test, do not mark it a bad", pnum);

	ubi_msg("PEB %d passed torture test, do not mark it as bad", pnum);





out:

out:

	mutex_unlock(&ubi->buf_mutex);

	mutex_unlock(&ubi->buf_mutex);

drivers/mtd/ubi/scan.c

+1 −1
Original line number Original line Diff line number Diff line
@@ -1103,7 +1103,7 @@ static int check_what_we_have(struct ubi_device *ubi, struct ubi_scan_info *si) 
		 * otherwise, only print a warning.

		 * otherwise, only print a warning.

		 */

		 */

		if (si->corr_peb_count >= max_corr) {

		if (si->corr_peb_count >= max_corr) {

			ubi_err("too many corrupted PEBs, refusing this device");

			ubi_err("too many corrupted PEBs, refusing");

			return -EINVAL;

			return -EINVAL;

		}

		}

	}

	}