[mirror_ubuntu-zesty-kernel.git] / drivers / mtd / tests / mtd_stresstest.c

/*
 * Copyright (C) 2006-2008 Nokia Corporation
 *
 * This program is free software; you can redistribute it and/or modify it
 * under the terms of the GNU General Public License version 2 as published by
 * the Free Software Foundation.
 *
 * This program is distributed in the hope that it will be useful, but WITHOUT
 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
 * more details.
 *
 * You should have received a copy of the GNU General Public License along with
 * this program; see the file COPYING. If not, write to the Free Software
 * Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
 *
 * Test random reads, writes and erases on MTD device.
 *
 * Author: Adrian Hunter <ext-adrian.hunter@nokia.com>
 */

#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt

#include <linux/init.h>
#include <linux/module.h>
#include <linux/moduleparam.h>
#include <linux/err.h>
#include <linux/mtd/mtd.h>
#include <linux/slab.h>
#include <linux/sched.h>
#include <linux/vmalloc.h>
#include <linux/random.h>

static int dev = -EINVAL;
module_param(dev, int, S_IRUGO);
MODULE_PARM_DESC(dev, "MTD device number to use");

static int count = 10000;
module_param(count, int, S_IRUGO);
MODULE_PARM_DESC(count, "Number of operations to do (default is 10000)");

static struct mtd_info *mtd;
static unsigned char *writebuf;
static unsigned char *readbuf;
static unsigned char *bbt;
static int *offsets;

static int pgsize;
static int bufsize;
static int ebcnt;
static int pgcnt;

static int rand_eb(void)
{
	unsigned int eb;

again:
	eb = random32();
	/* Read or write up 2 eraseblocks at a time - hence 'ebcnt - 1' */
	eb %= (ebcnt - 1);
	if (bbt[eb])
		goto again;
	return eb;
}

static int rand_offs(void)
{
	unsigned int offs;

	offs = random32();
	offs %= bufsize;
	return offs;
}

static int rand_len(int offs)
{
	unsigned int len;

	len = random32();
	len %= (bufsize - offs);
	return len;
}

static int erase_eraseblock(int ebnum)
{
	int err;
	struct erase_info ei;
	loff_t addr = ebnum * mtd->erasesize;

	memset(&ei, 0, sizeof(struct erase_info));
	ei.mtd  = mtd;
	ei.addr = addr;
	ei.len  = mtd->erasesize;

	err = mtd_erase(mtd, &ei);
	if (unlikely(err)) {
		pr_err("error %d while erasing EB %d\n", err, ebnum);
		return err;
	}

	if (unlikely(ei.state == MTD_ERASE_FAILED)) {
		pr_err("some erase error occurred at EB %d\n",
		       ebnum);
		return -EIO;
	}

	return 0;
}

static int is_block_bad(int ebnum)
{
	loff_t addr = ebnum * mtd->erasesize;
	int ret;

	ret = mtd_block_isbad(mtd, addr);
	if (ret)
		pr_info("block %d is bad\n", ebnum);
	return ret;
}

static int do_read(void)
{
	size_t read;
	int eb = rand_eb();
	int offs = rand_offs();
	int len = rand_len(offs), err;
	loff_t addr;

	if (bbt[eb + 1]) {
		if (offs >= mtd->erasesize)
			offs -= mtd->erasesize;
		if (offs + len > mtd->erasesize)
			len = mtd->erasesize - offs;
	}
	addr = eb * mtd->erasesize + offs;
	err = mtd_read(mtd, addr, len, &read, readbuf);
	if (mtd_is_bitflip(err))
		err = 0;
	if (unlikely(err || read != len)) {
		pr_err("error: read failed at 0x%llx\n",
		       (long long)addr);
		if (!err)
			err = -EINVAL;
		return err;
	}
	return 0;
}

static int do_write(void)
{
	int eb = rand_eb(), offs, err, len;
	size_t written;
	loff_t addr;

	offs = offsets[eb];
	if (offs >= mtd->erasesize) {
		err = erase_eraseblock(eb);
		if (err)
			return err;
		offs = offsets[eb] = 0;
	}
	len = rand_len(offs);
	len = ((len + pgsize - 1) / pgsize) * pgsize;
	if (offs + len > mtd->erasesize) {
		if (bbt[eb + 1])
			len = mtd->erasesize - offs;
		else {
			err = erase_eraseblock(eb + 1);
			if (err)
				return err;
			offsets[eb + 1] = 0;
		}
	}
	addr = eb * mtd->erasesize + offs;
	err = mtd_write(mtd, addr, len, &written, writebuf);
	if (unlikely(err || written != len)) {
		pr_err("error: write failed at 0x%llx\n",
		       (long long)addr);
		if (!err)
			err = -EINVAL;
		return err;
	}
	offs += len;
	while (offs > mtd->erasesize) {
		offsets[eb++] = mtd->erasesize;
		offs -= mtd->erasesize;
	}
	offsets[eb] = offs;
	return 0;
}

static int do_operation(void)
{
	if (random32() & 1)
		return do_read();
	else
		return do_write();
}

static int scan_for_bad_eraseblocks(void)
{
	int i, bad = 0;

	bbt = kzalloc(ebcnt, GFP_KERNEL);
	if (!bbt) {
		pr_err("error: cannot allocate memory\n");
		return -ENOMEM;
	}

	if (!mtd_can_have_bb(mtd))
		return 0;

	pr_info("scanning for bad eraseblocks\n");
	for (i = 0; i < ebcnt; ++i) {
		bbt[i] = is_block_bad(i) ? 1 : 0;
		if (bbt[i])
			bad += 1;
		cond_resched();
	}
	pr_info("scanned %d eraseblocks, %d are bad\n", i, bad);
	return 0;
}

static int __init mtd_stresstest_init(void)
{
	int err;
	int i, op;
	uint64_t tmp;

	printk(KERN_INFO "\n");
	printk(KERN_INFO "=================================================\n");

	if (dev < 0) {
		pr_info("Please specify a valid mtd-device via module parameter\n");
		pr_crit("CAREFUL: This test wipes all data on the specified MTD device!\n");
		return -EINVAL;
	}

	pr_info("MTD device: %d\n", dev);

	mtd = get_mtd_device(NULL, dev);
	if (IS_ERR(mtd)) {
		err = PTR_ERR(mtd);
		pr_err("error: cannot get MTD device\n");
		return err;
	}

	if (mtd->writesize == 1) {
		pr_info("not NAND flash, assume page size is 512 "
		       "bytes.\n");
		pgsize = 512;
	} else
		pgsize = mtd->writesize;

	tmp = mtd->size;
	do_div(tmp, mtd->erasesize);
	ebcnt = tmp;
	pgcnt = mtd->erasesize / pgsize;

	pr_info("MTD device size %llu, eraseblock size %u, "
	       "page size %u, count of eraseblocks %u, pages per "
	       "eraseblock %u, OOB size %u\n",
	       (unsigned long long)mtd->size, mtd->erasesize,
	       pgsize, ebcnt, pgcnt, mtd->oobsize);

	if (ebcnt < 2) {
		pr_err("error: need at least 2 eraseblocks\n");
		err = -ENOSPC;
		goto out_put_mtd;
	}

	/* Read or write up 2 eraseblocks at a time */
	bufsize = mtd->erasesize * 2;

	err = -ENOMEM;
	readbuf = vmalloc(bufsize);
	writebuf = vmalloc(bufsize);
	offsets = kmalloc(ebcnt * sizeof(int), GFP_KERNEL);
	if (!readbuf || !writebuf || !offsets) {
		pr_err("error: cannot allocate memory\n");
		goto out;
	}
	for (i = 0; i < ebcnt; i++)
		offsets[i] = mtd->erasesize;
	for (i = 0; i < bufsize; i++)
		writebuf[i] = random32();

	err = scan_for_bad_eraseblocks();
	if (err)
		goto out;

	/* Do operations */
	pr_info("doing operations\n");
	for (op = 0; op < count; op++) {
		if ((op & 1023) == 0)
			pr_info("%d operations done\n", op);
		err = do_operation();
		if (err)
			goto out;
		cond_resched();
	}
	pr_info("finished, %d operations done\n", op);

out:
	kfree(offsets);
	kfree(bbt);
	vfree(writebuf);
	vfree(readbuf);
out_put_mtd:
	put_mtd_device(mtd);
	if (err)
		pr_info("error %d occurred\n", err);
	printk(KERN_INFO "=================================================\n");
	return err;
}
module_init(mtd_stresstest_init);

static void __exit mtd_stresstest_exit(void)
{
	return;
}
module_exit(mtd_stresstest_exit);

MODULE_DESCRIPTION("Stress test module");
MODULE_AUTHOR("Adrian Hunter");
MODULE_LICENSE("GPL");
Commit	Line	Data
7163cea1 AB	1	/*
	2	* Copyright (C) 2006-2008 Nokia Corporation
	3	*
	4	* This program is free software; you can redistribute it and/or modify it
	5	* under the terms of the GNU General Public License version 2 as published by
	6	* the Free Software Foundation.
	7	*
	8	* This program is distributed in the hope that it will be useful, but WITHOUT
	9	* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
	10	* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
	11	* more details.
	12	*
	13	* You should have received a copy of the GNU General Public License along with
	14	* this program; see the file COPYING. If not, write to the Free Software
	15	* Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
	16	*
	17	* Test random reads, writes and erases on MTD device.
	18	*
	19	* Author: Adrian Hunter <ext-adrian.hunter@nokia.com>
	20	*/
	21
ae0086cf VN	22	#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
ae0086cf VN	23
7163cea1 AB	24	#include <linux/init.h>
	25	#include <linux/module.h>
	26	#include <linux/moduleparam.h>
	27	#include <linux/err.h>
	28	#include <linux/mtd/mtd.h>
5a0e3ad6	29	#include <linux/slab.h>
7163cea1 AB	30	#include <linux/sched.h>
7163cea1 AB	31	#include <linux/vmalloc.h>
bfea1d4e	32	#include <linux/random.h>
7163cea1	33
7406060e	34	static int dev = -EINVAL;
7163cea1 AB	35	module_param(dev, int, S_IRUGO);
	36	MODULE_PARM_DESC(dev, "MTD device number to use");
	37
	38	static int count = 10000;
	39	module_param(count, int, S_IRUGO);
	40	MODULE_PARM_DESC(count, "Number of operations to do (default is 10000)");
	41
	42	static struct mtd_info *mtd;
	43	static unsigned char *writebuf;
	44	static unsigned char *readbuf;
	45	static unsigned char *bbt;
	46	static int *offsets;
	47
	48	static int pgsize;
	49	static int bufsize;
	50	static int ebcnt;
	51	static int pgcnt;
7163cea1 AB	52
	53	static int rand_eb(void)
	54	{
bfea1d4e	55	unsigned int eb;
7163cea1 AB	56
7163cea1 AB	57	again:
bfea1d4e	58	eb = random32();
7163cea1 AB	59	/* Read or write up 2 eraseblocks at a time - hence 'ebcnt - 1' */
	60	eb %= (ebcnt - 1);
	61	if (bbt[eb])
	62	goto again;
	63	return eb;
	64	}
	65
	66	static int rand_offs(void)
	67	{
bfea1d4e	68	unsigned int offs;
7163cea1	69
bfea1d4e	70	offs = random32();
7163cea1 AB	71	offs %= bufsize;
	72	return offs;
	73	}
	74
	75	static int rand_len(int offs)
	76	{
bfea1d4e	77	unsigned int len;
7163cea1	78
bfea1d4e	79	len = random32();
7163cea1 AB	80	len %= (bufsize - offs);
	81	return len;
	82	}
	83
	84	static int erase_eraseblock(int ebnum)
	85	{
	86	int err;
	87	struct erase_info ei;
	88	loff_t addr = ebnum * mtd->erasesize;
	89
	90	memset(&ei, 0, sizeof(struct erase_info));
	91	ei.mtd = mtd;
	92	ei.addr = addr;
	93	ei.len = mtd->erasesize;
	94
7e1f0dc0	95	err = mtd_erase(mtd, &ei);
7163cea1	96	if (unlikely(err)) {
ae0086cf	97	pr_err("error %d while erasing EB %d\n", err, ebnum);
7163cea1 AB	98	return err;
	99	}
	100
	101	if (unlikely(ei.state == MTD_ERASE_FAILED)) {
ae0086cf	102	pr_err("some erase error occurred at EB %d\n",
7163cea1 AB	103	ebnum);
	104	return -EIO;
	105	}
	106
	107	return 0;
	108	}
	109
	110	static int is_block_bad(int ebnum)
	111	{
	112	loff_t addr = ebnum * mtd->erasesize;
	113	int ret;
	114
7086c19d	115	ret = mtd_block_isbad(mtd, addr);
7163cea1	116	if (ret)
ae0086cf	117	pr_info("block %d is bad\n", ebnum);
7163cea1 AB	118	return ret;
	119	}
	120
	121	static int do_read(void)
	122	{
30fa9848	123	size_t read;
7163cea1 AB	124	int eb = rand_eb();
	125	int offs = rand_offs();
	126	int len = rand_len(offs), err;
	127	loff_t addr;
	128
	129	if (bbt[eb + 1]) {
	130	if (offs >= mtd->erasesize)
	131	offs -= mtd->erasesize;
	132	if (offs + len > mtd->erasesize)
	133	len = mtd->erasesize - offs;
	134	}
	135	addr = eb * mtd->erasesize + offs;
329ad399	136	err = mtd_read(mtd, addr, len, &read, readbuf);
d57f4054	137	if (mtd_is_bitflip(err))
7163cea1 AB	138	err = 0;
7163cea1 AB	139	if (unlikely(err \|\| read != len)) {
ae0086cf	140	pr_err("error: read failed at 0x%llx\n",
7163cea1 AB	141	(long long)addr);
	142	if (!err)
	143	err = -EINVAL;
	144	return err;
	145	}
	146	return 0;
	147	}
	148
	149	static int do_write(void)
	150	{
	151	int eb = rand_eb(), offs, err, len;
30fa9848	152	size_t written;
7163cea1 AB	153	loff_t addr;
	154
	155	offs = offsets[eb];
	156	if (offs >= mtd->erasesize) {
	157	err = erase_eraseblock(eb);
	158	if (err)
	159	return err;
	160	offs = offsets[eb] = 0;
	161	}
	162	len = rand_len(offs);
	163	len = ((len + pgsize - 1) / pgsize) * pgsize;
	164	if (offs + len > mtd->erasesize) {
	165	if (bbt[eb + 1])
	166	len = mtd->erasesize - offs;
	167	else {
	168	err = erase_eraseblock(eb + 1);
	169	if (err)
	170	return err;
	171	offsets[eb + 1] = 0;
	172	}
	173	}
	174	addr = eb * mtd->erasesize + offs;
eda95cbf	175	err = mtd_write(mtd, addr, len, &written, writebuf);
7163cea1	176	if (unlikely(err \|\| written != len)) {
ae0086cf	177	pr_err("error: write failed at 0x%llx\n",
7163cea1 AB	178	(long long)addr);
	179	if (!err)
	180	err = -EINVAL;
	181	return err;
	182	}
	183	offs += len;
	184	while (offs > mtd->erasesize) {
	185	offsets[eb++] = mtd->erasesize;
	186	offs -= mtd->erasesize;
	187	}
	188	offsets[eb] = offs;
	189	return 0;
	190	}
	191
	192	static int do_operation(void)
	193	{
bfea1d4e	194	if (random32() & 1)
7163cea1 AB	195	return do_read();
	196	else
	197	return do_write();
	198	}
	199
	200	static int scan_for_bad_eraseblocks(void)
	201	{
	202	int i, bad = 0;
	203
2bfefa4c	204	bbt = kzalloc(ebcnt, GFP_KERNEL);
7163cea1	205	if (!bbt) {
ae0086cf	206	pr_err("error: cannot allocate memory\n");
7163cea1 AB	207	return -ENOMEM;
7163cea1 AB	208	}
7163cea1	209
8f461a73	210	if (!mtd_can_have_bb(mtd))
f5e2bae0 MTS	211	return 0;
f5e2bae0 MTS	212
ae0086cf	213	pr_info("scanning for bad eraseblocks\n");
7163cea1 AB	214	for (i = 0; i < ebcnt; ++i) {
	215	bbt[i] = is_block_bad(i) ? 1 : 0;
	216	if (bbt[i])
	217	bad += 1;
	218	cond_resched();
	219	}
ae0086cf	220	pr_info("scanned %d eraseblocks, %d are bad\n", i, bad);
7163cea1 AB	221	return 0;
	222	}
	223
	224	static int __init mtd_stresstest_init(void)
	225	{
	226	int err;
	227	int i, op;
	228	uint64_t tmp;
	229
	230	printk(KERN_INFO "\n");
	231	printk(KERN_INFO "=================================================\n");
7406060e WS	232
7406060e WS	233	if (dev < 0) {
064a7694	234	pr_info("Please specify a valid mtd-device via module parameter\n");
ae0086cf	235	pr_crit("CAREFUL: This test wipes all data on the specified MTD device!\n");
7406060e WS	236	return -EINVAL;
	237	}
	238
ae0086cf	239	pr_info("MTD device: %d\n", dev);
7163cea1 AB	240
	241	mtd = get_mtd_device(NULL, dev);
	242	if (IS_ERR(mtd)) {
	243	err = PTR_ERR(mtd);
ae0086cf	244	pr_err("error: cannot get MTD device\n");
7163cea1 AB	245	return err;
	246	}
	247
	248	if (mtd->writesize == 1) {
ae0086cf	249	pr_info("not NAND flash, assume page size is 512 "
7163cea1 AB	250	"bytes.\n");
	251	pgsize = 512;
	252	} else
	253	pgsize = mtd->writesize;
	254
	255	tmp = mtd->size;
	256	do_div(tmp, mtd->erasesize);
	257	ebcnt = tmp;
f5e2bae0	258	pgcnt = mtd->erasesize / pgsize;
7163cea1	259
ae0086cf	260	pr_info("MTD device size %llu, eraseblock size %u, "
7163cea1 AB	261	"page size %u, count of eraseblocks %u, pages per "
	262	"eraseblock %u, OOB size %u\n",
	263	(unsigned long long)mtd->size, mtd->erasesize,
	264	pgsize, ebcnt, pgcnt, mtd->oobsize);
	265
2f4478cc	266	if (ebcnt < 2) {
ae0086cf	267	pr_err("error: need at least 2 eraseblocks\n");
2f4478cc WS	268	err = -ENOSPC;
	269	goto out_put_mtd;
	270	}
	271
7163cea1 AB	272	/* Read or write up 2 eraseblocks at a time */
	273	bufsize = mtd->erasesize * 2;
	274
	275	err = -ENOMEM;
	276	readbuf = vmalloc(bufsize);
	277	writebuf = vmalloc(bufsize);
	278	offsets = kmalloc(ebcnt * sizeof(int), GFP_KERNEL);
	279	if (!readbuf \|\| !writebuf \|\| !offsets) {
ae0086cf	280	pr_err("error: cannot allocate memory\n");
7163cea1 AB	281	goto out;
	282	}
	283	for (i = 0; i < ebcnt; i++)
	284	offsets[i] = mtd->erasesize;
7163cea1	285	for (i = 0; i < bufsize; i++)
bfea1d4e	286	writebuf[i] = random32();
7163cea1 AB	287
	288	err = scan_for_bad_eraseblocks();
	289	if (err)
	290	goto out;
	291
	292	/* Do operations */
ae0086cf	293	pr_info("doing operations\n");
7163cea1 AB	294	for (op = 0; op < count; op++) {
7163cea1 AB	295	if ((op & 1023) == 0)
ae0086cf	296	pr_info("%d operations done\n", op);
7163cea1 AB	297	err = do_operation();
	298	if (err)
	299	goto out;
	300	cond_resched();
	301	}
ae0086cf	302	pr_info("finished, %d operations done\n", op);
7163cea1 AB	303
	304	out:
	305	kfree(offsets);
	306	kfree(bbt);
	307	vfree(writebuf);
	308	vfree(readbuf);
2f4478cc	309	out_put_mtd:
7163cea1 AB	310	put_mtd_device(mtd);
7163cea1 AB	311	if (err)
ae0086cf	312	pr_info("error %d occurred\n", err);
7163cea1 AB	313	printk(KERN_INFO "=================================================\n");
	314	return err;
	315	}
	316	module_init(mtd_stresstest_init);
	317
	318	static void __exit mtd_stresstest_exit(void)
	319	{
	320	return;
	321	}
	322	module_exit(mtd_stresstest_exit);
	323
	324	MODULE_DESCRIPTION("Stress test module");
	325	MODULE_AUTHOR("Adrian Hunter");
	326	MODULE_LICENSE("GPL");