1 files changed, 296 insertions, 43 deletions

diff --git a/drivers/mtd/nand/nandsim.c b/drivers/mtd/nand/nandsim.c
index ae7c57781a68..cd0711b83ac4 100644
--- a/drivers/mtd/nand/nandsim.c
+++ b/drivers/mtd/nand/nandsim.c
@@ -38,6 +38,9 @@
 #include <linux/delay.h>
 #include <linux/list.h>
 #include <linux/random.h>
+#include <linux/sched.h>
+#include <linux/fs.h>
+#include <linux/pagemap.h>
 
 /* Default simulator parameters values */
 #if !defined(CONFIG_NANDSIM_FIRST_ID_BYTE)  || \
@@ -100,6 +103,7 @@ static unsigned int bitflips = 0;
 static char *gravepages = NULL;
 static unsigned int rptwear = 0;
 static unsigned int overridesize = 0;
+static char *cache_file = NULL;
 
 module_param(first_id_byte,  uint, 0400);
 module_param(second_id_byte, uint, 0400);
@@ -122,12 +126,13 @@ module_param(bitflips,       uint, 0400);
 module_param(gravepages,     charp, 0400);
 module_param(rptwear,        uint, 0400);
 module_param(overridesize,   uint, 0400);
+module_param(cache_file,     charp, 0400);
 
 MODULE_PARM_DESC(first_id_byte,  "The first byte returned by NAND Flash 'read ID' command (manufacturer ID)");
 MODULE_PARM_DESC(second_id_byte, "The second byte returned by NAND Flash 'read ID' command (chip ID)");
 MODULE_PARM_DESC(third_id_byte,  "The third byte returned by NAND Flash 'read ID' command");
 MODULE_PARM_DESC(fourth_id_byte, "The fourth byte returned by NAND Flash 'read ID' command");
-MODULE_PARM_DESC(access_delay,   "Initial page access delay (microiseconds)");
+MODULE_PARM_DESC(access_delay,   "Initial page access delay (microseconds)");
 MODULE_PARM_DESC(programm_delay, "Page programm delay (microseconds");
 MODULE_PARM_DESC(erase_delay,    "Sector erase delay (milliseconds)");
 MODULE_PARM_DESC(output_cycle,   "Word output (from flash) time (nanodeconds)");
@@ -153,6 +158,7 @@ MODULE_PARM_DESC(rptwear,        "Number of erases inbetween reporting wear, if
 MODULE_PARM_DESC(overridesize,   "Specifies the NAND Flash size overriding the ID bytes. "
                                  "The size is specified in erase blocks and as the exponent of a power of two"
                                  " e.g. 5 means a size of 32 erase blocks");
+MODULE_PARM_DESC(cache_file,     "File to use to cache nand pages instead of memory");
 
 /* The largest possible page size */
 #define NS_LARGEST_PAGE_SIZE    2048
@@ -266,6 +272,9 @@ MODULE_PARM_DESC(overridesize,   "Specifies the NAND Flash size overriding the I
  */
 #define NS_MAX_PREVSTATES 1
 
+/* Maximum page cache pages needed to read or write a NAND page to the cache_file */
+#define NS_MAX_HELD_PAGES 16
+
 /*
  * A union to represent flash memory contents and flash buffer.
  */
@@ -295,6 +304,9 @@ struct nandsim {
         /* The simulated NAND flash pages array */
         union ns_mem *pages;
 
+        /* Slab allocator for nand pages */
+        struct kmem_cache *nand_pages_slab;
+
         /* Internal buffer of page + OOB size bytes */
         union ns_mem buf;
 
@@ -335,6 +347,13 @@ struct nandsim {
                 int ale; /* address Latch Enable */
                 int wp;  /* write Protect */
         } lines;
+
+        /* Fields needed when using a cache file */
+        struct file *cfile; /* Open file */
+        unsigned char *pages_written; /* Which pages have been written */
+        void *file_buf;
+        struct page *held_pages[NS_MAX_HELD_PAGES];
+        int held_cnt;
 };
 
 /*
@@ -420,25 +439,69 @@ static struct mtd_info *nsmtd;
 static u_char ns_verify_buf[NS_LARGEST_PAGE_SIZE];
 
 /*
- * Allocate array of page pointers and initialize the array to NULL
- * pointers.
+ * Allocate array of page pointers, create slab allocation for an array
+ * and initialize the array by NULL pointers.
  *
  * RETURNS: 0 if success, -ENOMEM if memory alloc fails.
  */
 static int alloc_device(struct nandsim *ns)
 {
-        int i;
+        struct file *cfile;
+        int i, err;
+
+        if (cache_file) {
+                cfile = filp_open(cache_file, O_CREAT | O_RDWR | O_LARGEFILE, 0600);
+                if (IS_ERR(cfile))
+                        return PTR_ERR(cfile);
+                if (!cfile->f_op || (!cfile->f_op->read && !cfile->f_op->aio_read)) {
+                        NS_ERR("alloc_device: cache file not readable\n");
+                        err = -EINVAL;
+                        goto err_close;
+                }
+                if (!cfile->f_op->write && !cfile->f_op->aio_write) {
+                        NS_ERR("alloc_device: cache file not writeable\n");
+                        err = -EINVAL;
+                        goto err_close;
+                }
+                ns->pages_written = vmalloc(ns->geom.pgnum);
+                if (!ns->pages_written) {
+                        NS_ERR("alloc_device: unable to allocate pages written array\n");
+                        err = -ENOMEM;
+                        goto err_close;
+                }
+                ns->file_buf = kmalloc(ns->geom.pgszoob, GFP_KERNEL);
+                if (!ns->file_buf) {
+                        NS_ERR("alloc_device: unable to allocate file buf\n");
+                        err = -ENOMEM;
+                        goto err_free;
+                }
+                ns->cfile = cfile;
+                memset(ns->pages_written, 0, ns->geom.pgnum);
+                return 0;
+        }
 
         ns->pages = vmalloc(ns->geom.pgnum * sizeof(union ns_mem));
         if (!ns->pages) {
-                NS_ERR("alloc_map: unable to allocate page array\n");
+                NS_ERR("alloc_device: unable to allocate page array\n");
                 return -ENOMEM;
         }
         for (i = 0; i < ns->geom.pgnum; i++) {
                 ns->pages[i].byte = NULL;
         }
+        ns->nand_pages_slab = kmem_cache_create("nandsim",
+                                                ns->geom.pgszoob, 0, 0, NULL);
+        if (!ns->nand_pages_slab) {
+                NS_ERR("cache_create: unable to create kmem_cache\n");
+                return -ENOMEM;
+        }
 
         return 0;
+
+err_free:
+        vfree(ns->pages_written);
+err_close:
+        filp_close(cfile, NULL);
+        return err;
 }
 
 /*
@@ -448,11 +511,20 @@ static void free_device(struct nandsim *ns)
 {
         int i;
 
+        if (ns->cfile) {
+                kfree(ns->file_buf);
+                vfree(ns->pages_written);
+                filp_close(ns->cfile, NULL);
+                return;
+        }
+
         if (ns->pages) {
                 for (i = 0; i < ns->geom.pgnum; i++) {
                         if (ns->pages[i].byte)
-                                kfree(ns->pages[i].byte);
+                                kmem_cache_free(ns->nand_pages_slab,
+                                                ns->pages[i].byte);
                 }
+                kmem_cache_destroy(ns->nand_pages_slab);
                 vfree(ns->pages);
         }
 }
@@ -464,7 +536,7 @@ static char *get_partition_name(int i)
         return kstrdup(buf, GFP_KERNEL);
 }
 
-static u_int64_t divide(u_int64_t n, u_int32_t d)
+static uint64_t divide(uint64_t n, uint32_t d)
 {
         do_div(n, d);
         return n;
@@ -480,8 +552,8 @@ static int init_nandsim(struct mtd_info *mtd)
         struct nand_chip *chip = (struct nand_chip *)mtd->priv;
         struct nandsim   *ns   = (struct nandsim *)(chip->priv);
         int i, ret = 0;
-        u_int64_t remains;
-        u_int64_t next_offset;
+        uint64_t remains;
+        uint64_t next_offset;
 
         if (NS_IS_INITIALIZED(ns)) {
                 NS_ERR("init_nandsim: nandsim is already initialized\n");
@@ -548,7 +620,7 @@ static int init_nandsim(struct mtd_info *mtd)
         remains = ns->geom.totsz;
         next_offset = 0;
         for (i = 0; i < parts_num; ++i) {
-                u_int64_t part_sz = (u_int64_t)parts[i] * ns->geom.secsz;
+                uint64_t part_sz = (uint64_t)parts[i] * ns->geom.secsz;
 
                 if (!part_sz || part_sz > remains) {
                         NS_ERR("bad partition size.\n");
@@ -1211,6 +1283,97 @@ static int find_operation(struct nandsim *ns, uint32_t flag)
         return -1;
 }
 
+static void put_pages(struct nandsim *ns)
+{
+        int i;
+
+        for (i = 0; i < ns->held_cnt; i++)
+                page_cache_release(ns->held_pages[i]);
+}
+
+/* Get page cache pages in advance to provide NOFS memory allocation */
+static int get_pages(struct nandsim *ns, struct file *file, size_t count, loff_t pos)
+{
+        pgoff_t index, start_index, end_index;
+        struct page *page;
+        struct address_space *mapping = file->f_mapping;
+
+        start_index = pos >> PAGE_CACHE_SHIFT;
+        end_index = (pos + count - 1) >> PAGE_CACHE_SHIFT;
+        if (end_index - start_index + 1 > NS_MAX_HELD_PAGES)
+                return -EINVAL;
+        ns->held_cnt = 0;
+        for (index = start_index; index <= end_index; index++) {
+                page = find_get_page(mapping, index);
+                if (page == NULL) {
+                        page = find_or_create_page(mapping, index, GFP_NOFS);
+                        if (page == NULL) {
+                                write_inode_now(mapping->host, 1);
+                                page = find_or_create_page(mapping, index, GFP_NOFS);
+                        }
+                        if (page == NULL) {
+                                put_pages(ns);
+                                return -ENOMEM;
+                        }
+                        unlock_page(page);
+                }
+                ns->held_pages[ns->held_cnt++] = page;
+        }
+        return 0;
+}
+
+static int set_memalloc(void)
+{
+        if (current->flags & PF_MEMALLOC)
+                return 0;
+        current->flags |= PF_MEMALLOC;
+        return 1;
+}
+
+static void clear_memalloc(int memalloc)
+{
+        if (memalloc)
+                current->flags &= ~PF_MEMALLOC;
+}
+
+static ssize_t read_file(struct nandsim *ns, struct file *file, void *buf, size_t count, loff_t *pos)
+{
+        mm_segment_t old_fs;
+        ssize_t tx;
+        int err, memalloc;
+
+        err = get_pages(ns, file, count, *pos);
+        if (err)
+                return err;
+        old_fs = get_fs();
+        set_fs(get_ds());
+        memalloc = set_memalloc();
+        tx = vfs_read(file, (char __user *)buf, count, pos);
+        clear_memalloc(memalloc);
+        set_fs(old_fs);
+        put_pages(ns);
+        return tx;
+}
+
+static ssize_t write_file(struct nandsim *ns, struct file *file, void *buf, size_t count, loff_t *pos)
+{
+        mm_segment_t old_fs;
+        ssize_t tx;
+        int err, memalloc;
+
+        err = get_pages(ns, file, count, *pos);
+        if (err)
+                return err;
+        old_fs = get_fs();
+        set_fs(get_ds());
+        memalloc = set_memalloc();
+        tx = vfs_write(file, (char __user *)buf, count, pos);
+        clear_memalloc(memalloc);
+        set_fs(old_fs);
+        put_pages(ns);
+        return tx;
+}
+
 /*
  * Returns a pointer to the current page.
  */
@@ -1227,6 +1390,38 @@ static inline u_char *NS_PAGE_BYTE_OFF(struct nandsim *ns)
         return NS_GET_PAGE(ns)->byte + ns->regs.column + ns->regs.off;
 }
 
+int do_read_error(struct nandsim *ns, int num)
+{
+        unsigned int page_no = ns->regs.row;
+
+        if (read_error(page_no)) {
+                int i;
+                memset(ns->buf.byte, 0xFF, num);
+                for (i = 0; i < num; ++i)
+                        ns->buf.byte[i] = random32();
+                NS_WARN("simulating read error in page %u\n", page_no);
+                return 1;
+        }
+        return 0;
+}
+
+void do_bit_flips(struct nandsim *ns, int num)
+{
+        if (bitflips && random32() < (1 << 22)) {
+                int flips = 1;
+                if (bitflips > 1)
+                        flips = (random32() % (int) bitflips) + 1;
+                while (flips--) {
+                        int pos = random32() % (num * 8);
+                        ns->buf.byte[pos / 8] ^= (1 << (pos % 8));
+                        NS_WARN("read_page: flipping bit %d in page %d "
+                                "reading from %d ecc: corrected=%u failed=%u\n",
+                                pos, ns->regs.row, ns->regs.column + ns->regs.off,
+                                nsmtd->ecc_stats.corrected, nsmtd->ecc_stats.failed);
+                }
+        }
+}
+
 /*
  * Fill the NAND buffer with data read from the specified page.
  */
@@ -1234,36 +1429,40 @@ static void read_page(struct nandsim *ns, int num)
 {
         union ns_mem *mypage;
 
+        if (ns->cfile) {
+                if (!ns->pages_written[ns->regs.row]) {
+                        NS_DBG("read_page: page %d not written\n", ns->regs.row);
+                        memset(ns->buf.byte, 0xFF, num);
+                } else {
+                        loff_t pos;
+                        ssize_t tx;
+
+                        NS_DBG("read_page: page %d written, reading from %d\n",
+                                ns->regs.row, ns->regs.column + ns->regs.off);
+                        if (do_read_error(ns, num))
+                                return;
+                        pos = (loff_t)ns->regs.row * ns->geom.pgszoob + ns->regs.column + ns->regs.off;
+                        tx = read_file(ns, ns->cfile, ns->buf.byte, num, &pos);
+                        if (tx != num) {
+                                NS_ERR("read_page: read error for page %d ret %ld\n", ns->regs.row, (long)tx);
+                                return;
+                        }
+                        do_bit_flips(ns, num);
+                }
+                return;
+        }
+
         mypage = NS_GET_PAGE(ns);
         if (mypage->byte == NULL) {
                 NS_DBG("read_page: page %d not allocated\n", ns->regs.row);
                 memset(ns->buf.byte, 0xFF, num);
         } else {
-                unsigned int page_no = ns->regs.row;
                 NS_DBG("read_page: page %d allocated, reading from %d\n",
                         ns->regs.row, ns->regs.column + ns->regs.off);
-                if (read_error(page_no)) {
-                        int i;
-                        memset(ns->buf.byte, 0xFF, num);
-                        for (i = 0; i < num; ++i)
-                                ns->buf.byte[i] = random32();
-                        NS_WARN("simulating read error in page %u\n", page_no);
+                if (do_read_error(ns, num))
                         return;
-                }
                 memcpy(ns->buf.byte, NS_PAGE_BYTE_OFF(ns), num);
-                if (bitflips && random32() < (1 << 22)) {
-                        int flips = 1;
-                        if (bitflips > 1)
-                                flips = (random32() % (int) bitflips) + 1;
-                        while (flips--) {
-                                int pos = random32() % (num * 8);
-                                ns->buf.byte[pos / 8] ^= (1 << (pos % 8));
-                                NS_WARN("read_page: flipping bit %d in page %d "
-                                        "reading from %d ecc: corrected=%u failed=%u\n",
-                                        pos, ns->regs.row, ns->regs.column + ns->regs.off,
-                                        nsmtd->ecc_stats.corrected, nsmtd->ecc_stats.failed);
-                        }
-                }
+                do_bit_flips(ns, num);
         }
 }
 
@@ -1275,11 +1474,20 @@ static void erase_sector(struct nandsim *ns)
         union ns_mem *mypage;
         int i;
 
+        if (ns->cfile) {
+                for (i = 0; i < ns->geom.pgsec; i++)
+                        if (ns->pages_written[ns->regs.row + i]) {
+                                NS_DBG("erase_sector: freeing page %d\n", ns->regs.row + i);
+                                ns->pages_written[ns->regs.row + i] = 0;
+                        }
+                return;
+        }
+
         mypage = NS_GET_PAGE(ns);
         for (i = 0; i < ns->geom.pgsec; i++) {
                 if (mypage->byte != NULL) {
                         NS_DBG("erase_sector: freeing page %d\n", ns->regs.row+i);
-                        kfree(mypage->byte);
+                        kmem_cache_free(ns->nand_pages_slab, mypage->byte);
                         mypage->byte = NULL;
                 }
                 mypage++;
@@ -1295,16 +1503,57 @@ static int prog_page(struct nandsim *ns, int num)
         union ns_mem *mypage;
         u_char *pg_off;
 
+        if (ns->cfile) {
+                loff_t off, pos;
+                ssize_t tx;
+                int all;
+
+                NS_DBG("prog_page: writing page %d\n", ns->regs.row);
+                pg_off = ns->file_buf + ns->regs.column + ns->regs.off;
+                off = (loff_t)ns->regs.row * ns->geom.pgszoob + ns->regs.column + ns->regs.off;
+                if (!ns->pages_written[ns->regs.row]) {
+                        all = 1;
+                        memset(ns->file_buf, 0xff, ns->geom.pgszoob);
+                } else {
+                        all = 0;
+                        pos = off;
+                        tx = read_file(ns, ns->cfile, pg_off, num, &pos);
+                        if (tx != num) {
+                                NS_ERR("prog_page: read error for page %d ret %ld\n", ns->regs.row, (long)tx);
+                                return -1;
+                        }
+                }
+                for (i = 0; i < num; i++)
+                        pg_off[i] &= ns->buf.byte[i];
+                if (all) {
+                        pos = (loff_t)ns->regs.row * ns->geom.pgszoob;
+                        tx = write_file(ns, ns->cfile, ns->file_buf, ns->geom.pgszoob, &pos);
+                        if (tx != ns->geom.pgszoob) {
+                                NS_ERR("prog_page: write error for page %d ret %ld\n", ns->regs.row, (long)tx);
+                                return -1;
+                        }
+                        ns->pages_written[ns->regs.row] = 1;
+                } else {
+                        pos = off;
+                        tx = write_file(ns, ns->cfile, pg_off, num, &pos);
+                        if (tx != num) {
+                                NS_ERR("prog_page: write error for page %d ret %ld\n", ns->regs.row, (long)tx);
+                                return -1;
+                        }
+                }
+                return 0;
+        }
+
         mypage = NS_GET_PAGE(ns);
         if (mypage->byte == NULL) {
                 NS_DBG("prog_page: allocating page %d\n", ns->regs.row);
                 /*
                  * We allocate memory with GFP_NOFS because a flash FS may
                  * utilize this. If it is holding an FS lock, then gets here,
-                 * then kmalloc runs writeback which goes to the FS again
-                 * and deadlocks. This was seen in practice.
+                 * then kernel memory alloc runs writeback which goes to the FS
+                 * again and deadlocks. This was seen in practice.
                  */
-                mypage->byte = kmalloc(ns->geom.pgszoob, GFP_NOFS);
+                mypage->byte = kmem_cache_alloc(ns->nand_pages_slab, GFP_NOFS);
                 if (mypage->byte == NULL) {
                         NS_ERR("prog_page: error allocating memory for page %d\n", ns->regs.row);
                         return -1;
@@ -1736,13 +1985,17 @@ static void ns_nand_write_byte(struct mtd_info *mtd, u_char byte)
 
                 /* Check if chip is expecting command */
                 if (NS_STATE(ns->nxstate) != STATE_UNKNOWN && !(ns->nxstate & STATE_CMD_MASK)) {
-                        /*
-                         * We are in situation when something else (not command)
-                         * was expected but command was input. In this case ignore
-                         * previous command(s)/state(s) and accept the last one.
-                         */
-                        NS_WARN("write_byte: command (%#x) wasn't expected, expected state is %s, "
-                                "ignore previous states\n", (uint)byte, get_state_name(ns->nxstate));
+                        /* Do not warn if only 2 id bytes are read */
+                        if (!(ns->regs.command == NAND_CMD_READID &&
+                            NS_STATE(ns->state) == STATE_DATAOUT_ID && ns->regs.count == 2)) {
+                                /*
+                                 * We are in situation when something else (not command)
+                                 * was expected but command was input. In this case ignore
+                                 * previous command(s)/state(s) and accept the last one.
+                                 */
+                                NS_WARN("write_byte: command (%#x) wasn't expected, expected state is %s, "
+                                        "ignore previous states\n", (uint)byte, get_state_name(ns->nxstate));
+                        }
                         switch_to_ready_state(ns, NS_STATUS_FAILED(ns));
                 }
 
@@ -2044,7 +2297,7 @@ static int __init ns_init_module(void)
         }
 
         if (overridesize) {
-                u_int64_t new_size = (u_int64_t)nsmtd->erasesize << overridesize;
+                uint64_t new_size = (uint64_t)nsmtd->erasesize << overridesize;
                 if (new_size >> overridesize != nsmtd->erasesize) {
                         NS_ERR("overridesize is too big\n");
                         goto err_exit;