mtd/tests/speedtest.c

0001 // SPDX-License-Identifier: GPL-2.0-only
0002 /*
0003  * Copyright (C) 2007 Nokia Corporation
0004  *
0005  * Test read and write speed of a MTD device.
0006  *
0007  * Author: Adrian Hunter <adrian.hunter@nokia.com>
0008  */
0009
0010 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
0011
0012 #include <linux/init.h>
0013 #include <linux/ktime.h>
0014 #include <linux/module.h>
0015 #include <linux/moduleparam.h>
0016 #include <linux/err.h>
0017 #include <linux/mtd/mtd.h>
0018 #include <linux/slab.h>
0019 #include <linux/sched.h>
0020 #include <linux/random.h>
0021
0022 #include "mtd_test.h"
0023
0024 static int dev = -EINVAL;
0025 module_param(dev, int, S_IRUGO);
0026 MODULE_PARM_DESC(dev, "MTD device number to use");
0027
0028 static int count;
0029 module_param(count, int, S_IRUGO);
0030 MODULE_PARM_DESC(count, "Maximum number of eraseblocks to use "
0031             "(0 means use all)");
0032
0033 static struct mtd_info *mtd;
0034 static unsigned char *iobuf;
0035 static unsigned char *bbt;
0036
0037 static int pgsize;
0038 static int ebcnt;
0039 static int pgcnt;
0040 static int goodebcnt;
0041 static ktime_t start, finish;
0042
0043 static int multiblock_erase(int ebnum, int blocks)
0044 {
0045     int err;
0046     struct erase_info ei;
0047     loff_t addr = (loff_t)ebnum * mtd->erasesize;
0048
0049     memset(&ei, 0, sizeof(struct erase_info));
0050     ei.addr = addr;
0051     ei.len  = mtd->erasesize * blocks;
0052
0053     err = mtd_erase(mtd, &ei);
0054     if (err) {
0055         pr_err("error %d while erasing EB %d, blocks %d\n",
0056                err, ebnum, blocks);
0057         return err;
0058     }
0059
0060     return 0;
0061 }
0062
0063 static int write_eraseblock(int ebnum)
0064 {
0065     loff_t addr = (loff_t)ebnum * mtd->erasesize;
0066
0067     return mtdtest_write(mtd, addr, mtd->erasesize, iobuf);
0068 }
0069
0070 static int write_eraseblock_by_page(int ebnum)
0071 {
0072     int i, err = 0;
0073     loff_t addr = (loff_t)ebnum * mtd->erasesize;
0074     void *buf = iobuf;
0075
0076     for (i = 0; i < pgcnt; i++) {
0077         err = mtdtest_write(mtd, addr, pgsize, buf);
0078         if (err)
0079             break;
0080         addr += pgsize;
0081         buf += pgsize;
0082     }
0083
0084     return err;
0085 }
0086
0087 static int write_eraseblock_by_2pages(int ebnum)
0088 {
0089     size_t sz = pgsize * 2;
0090     int i, n = pgcnt / 2, err = 0;
0091     loff_t addr = (loff_t)ebnum * mtd->erasesize;
0092     void *buf = iobuf;
0093
0094     for (i = 0; i < n; i++) {
0095         err = mtdtest_write(mtd, addr, sz, buf);
0096         if (err)
0097             return err;
0098         addr += sz;
0099         buf += sz;
0100     }
0101     if (pgcnt % 2)
0102         err = mtdtest_write(mtd, addr, pgsize, buf);
0103
0104     return err;
0105 }
0106
0107 static int read_eraseblock(int ebnum)
0108 {
0109     loff_t addr = (loff_t)ebnum * mtd->erasesize;
0110
0111     return mtdtest_read(mtd, addr, mtd->erasesize, iobuf);
0112 }
0113
0114 static int read_eraseblock_by_page(int ebnum)
0115 {
0116     int i, err = 0;
0117     loff_t addr = (loff_t)ebnum * mtd->erasesize;
0118     void *buf = iobuf;
0119
0120     for (i = 0; i < pgcnt; i++) {
0121         err = mtdtest_read(mtd, addr, pgsize, buf);
0122         if (err)
0123             break;
0124         addr += pgsize;
0125         buf += pgsize;
0126     }
0127
0128     return err;
0129 }
0130
0131 static int read_eraseblock_by_2pages(int ebnum)
0132 {
0133     size_t sz = pgsize * 2;
0134     int i, n = pgcnt / 2, err = 0;
0135     loff_t addr = (loff_t)ebnum * mtd->erasesize;
0136     void *buf = iobuf;
0137
0138     for (i = 0; i < n; i++) {
0139         err = mtdtest_read(mtd, addr, sz, buf);
0140         if (err)
0141             return err;
0142         addr += sz;
0143         buf += sz;
0144     }
0145     if (pgcnt % 2)
0146         err = mtdtest_read(mtd, addr, pgsize, buf);
0147
0148     return err;
0149 }
0150
0151 static inline void start_timing(void)
0152 {
0153     start = ktime_get();
0154 }
0155
0156 static inline void stop_timing(void)
0157 {
0158     finish = ktime_get();
0159 }
0160
0161 static long calc_speed(void)
0162 {
0163     uint64_t k, us;
0164
0165     us = ktime_us_delta(finish, start);
0166     if (us == 0)
0167         return 0;
0168     k = (uint64_t)goodebcnt * (mtd->erasesize / 1024) * 1000000;
0169     do_div(k, us);
0170     return k;
0171 }
0172
0173 static int __init mtd_speedtest_init(void)
0174 {
0175     int err, i, blocks, j, k;
0176     long speed;
0177     uint64_t tmp;
0178
0179     printk(KERN_INFO "\n");
0180     printk(KERN_INFO "=================================================\n");
0181
0182     if (dev < 0) {
0183         pr_info("Please specify a valid mtd-device via module parameter\n");
0184         pr_crit("CAREFUL: This test wipes all data on the specified MTD device!\n");
0185         return -EINVAL;
0186     }
0187
0188     if (count)
0189         pr_info("MTD device: %d    count: %d\n", dev, count);
0190     else
0191         pr_info("MTD device: %d\n", dev);
0192
0193     mtd = get_mtd_device(NULL, dev);
0194     if (IS_ERR(mtd)) {
0195         err = PTR_ERR(mtd);
0196         pr_err("error: cannot get MTD device\n");
0197         return err;
0198     }
0199
0200     if (mtd->writesize == 1) {
0201         pr_info("not NAND flash, assume page size is 512 "
0202                "bytes.\n");
0203         pgsize = 512;
0204     } else
0205         pgsize = mtd->writesize;
0206
0207     tmp = mtd->size;
0208     do_div(tmp, mtd->erasesize);
0209     ebcnt = tmp;
0210     pgcnt = mtd->erasesize / pgsize;
0211
0212     pr_info("MTD device size %llu, eraseblock size %u, "
0213            "page size %u, count of eraseblocks %u, pages per "
0214            "eraseblock %u, OOB size %u\n",
0215            (unsigned long long)mtd->size, mtd->erasesize,
0216            pgsize, ebcnt, pgcnt, mtd->oobsize);
0217
0218     if (count > 0 && count < ebcnt)
0219         ebcnt = count;
0220
0221     err = -ENOMEM;
0222     iobuf = kmalloc(mtd->erasesize, GFP_KERNEL);
0223     if (!iobuf)
0224         goto out;
0225
0226     prandom_bytes(iobuf, mtd->erasesize);
0227
0228     bbt = kzalloc(ebcnt, GFP_KERNEL);
0229     if (!bbt)
0230         goto out;
0231     err = mtdtest_scan_for_bad_eraseblocks(mtd, bbt, 0, ebcnt);
0232     if (err)
0233         goto out;
0234     for (i = 0; i < ebcnt; i++) {
0235         if (!bbt[i])
0236             goodebcnt++;
0237     }
0238
0239     err = mtdtest_erase_good_eraseblocks(mtd, bbt, 0, ebcnt);
0240     if (err)
0241         goto out;
0242
0243     /* Write all eraseblocks, 1 eraseblock at a time */
0244     pr_info("testing eraseblock write speed\n");
0245     start_timing();
0246     for (i = 0; i < ebcnt; ++i) {
0247         if (bbt[i])
0248             continue;
0249         err = write_eraseblock(i);
0250         if (err)
0251             goto out;
0252
0253         err = mtdtest_relax();
0254         if (err)
0255             goto out;
0256     }
0257     stop_timing();
0258     speed = calc_speed();
0259     pr_info("eraseblock write speed is %ld KiB/s\n", speed);
0260
0261     /* Read all eraseblocks, 1 eraseblock at a time */
0262     pr_info("testing eraseblock read speed\n");
0263     start_timing();
0264     for (i = 0; i < ebcnt; ++i) {
0265         if (bbt[i])
0266             continue;
0267         err = read_eraseblock(i);
0268         if (err)
0269             goto out;
0270
0271         err = mtdtest_relax();
0272         if (err)
0273             goto out;
0274     }
0275     stop_timing();
0276     speed = calc_speed();
0277     pr_info("eraseblock read speed is %ld KiB/s\n", speed);
0278
0279     err = mtdtest_erase_good_eraseblocks(mtd, bbt, 0, ebcnt);
0280     if (err)
0281         goto out;
0282
0283     /* Write all eraseblocks, 1 page at a time */
0284     pr_info("testing page write speed\n");
0285     start_timing();
0286     for (i = 0; i < ebcnt; ++i) {
0287         if (bbt[i])
0288             continue;
0289         err = write_eraseblock_by_page(i);
0290         if (err)
0291             goto out;
0292
0293         err = mtdtest_relax();
0294         if (err)
0295             goto out;
0296     }
0297     stop_timing();
0298     speed = calc_speed();
0299     pr_info("page write speed is %ld KiB/s\n", speed);
0300
0301     /* Read all eraseblocks, 1 page at a time */
0302     pr_info("testing page read speed\n");
0303     start_timing();
0304     for (i = 0; i < ebcnt; ++i) {
0305         if (bbt[i])
0306             continue;
0307         err = read_eraseblock_by_page(i);
0308         if (err)
0309             goto out;
0310
0311         err = mtdtest_relax();
0312         if (err)
0313             goto out;
0314     }
0315     stop_timing();
0316     speed = calc_speed();
0317     pr_info("page read speed is %ld KiB/s\n", speed);
0318
0319     err = mtdtest_erase_good_eraseblocks(mtd, bbt, 0, ebcnt);
0320     if (err)
0321         goto out;
0322
0323     /* Write all eraseblocks, 2 pages at a time */
0324     pr_info("testing 2 page write speed\n");
0325     start_timing();
0326     for (i = 0; i < ebcnt; ++i) {
0327         if (bbt[i])
0328             continue;
0329         err = write_eraseblock_by_2pages(i);
0330         if (err)
0331             goto out;
0332
0333         err = mtdtest_relax();
0334         if (err)
0335             goto out;
0336     }
0337     stop_timing();
0338     speed = calc_speed();
0339     pr_info("2 page write speed is %ld KiB/s\n", speed);
0340
0341     /* Read all eraseblocks, 2 pages at a time */
0342     pr_info("testing 2 page read speed\n");
0343     start_timing();
0344     for (i = 0; i < ebcnt; ++i) {
0345         if (bbt[i])
0346             continue;
0347         err = read_eraseblock_by_2pages(i);
0348         if (err)
0349             goto out;
0350
0351         err = mtdtest_relax();
0352         if (err)
0353             goto out;
0354     }
0355     stop_timing();
0356     speed = calc_speed();
0357     pr_info("2 page read speed is %ld KiB/s\n", speed);
0358
0359     /* Erase all eraseblocks */
0360     pr_info("Testing erase speed\n");
0361     start_timing();
0362     err = mtdtest_erase_good_eraseblocks(mtd, bbt, 0, ebcnt);
0363     if (err)
0364         goto out;
0365     stop_timing();
0366     speed = calc_speed();
0367     pr_info("erase speed is %ld KiB/s\n", speed);
0368
0369     /* Multi-block erase all eraseblocks */
0370     for (k = 1; k < 7; k++) {
0371         blocks = 1 << k;
0372         pr_info("Testing %dx multi-block erase speed\n",
0373                blocks);
0374         start_timing();
0375         for (i = 0; i < ebcnt; ) {
0376             for (j = 0; j < blocks && (i + j) < ebcnt; j++)
0377                 if (bbt[i + j])
0378                     break;
0379             if (j < 1) {
0380                 i++;
0381                 continue;
0382             }
0383             err = multiblock_erase(i, j);
0384             if (err)
0385                 goto out;
0386
0387             err = mtdtest_relax();
0388             if (err)
0389                 goto out;
0390
0391             i += j;
0392         }
0393         stop_timing();
0394         speed = calc_speed();
0395         pr_info("%dx multi-block erase speed is %ld KiB/s\n",
0396                blocks, speed);
0397     }
0398     pr_info("finished\n");
0399 out:
0400     kfree(iobuf);
0401     kfree(bbt);
0402     put_mtd_device(mtd);
0403     if (err)
0404         pr_info("error %d occurred\n", err);
0405     printk(KERN_INFO "=================================================\n");
0406     return err;
0407 }
0408 module_init(mtd_speedtest_init);
0409
0410 static void __exit mtd_speedtest_exit(void)
0411 {
0412     return;
0413 }
0414 module_exit(mtd_speedtest_exit);
0415
0416 MODULE_DESCRIPTION("Speed test module");
0417 MODULE_AUTHOR("Adrian Hunter");
0418 MODULE_LICENSE("GPL");