Merge branch 'vhost-net' of git://git.kernel.org/pub/scm/linux/kernel/git/mst/vhost

[~andy/linux] / drivers / mtd / mtdoops.c

diff --git a/drivers/mtd/mtdoops.c b/drivers/mtd/mtdoops.c
index 1e2fa6236705941b9fea37b5f0d5bf4a713e56c7..3ce99e00a49e89f558796c5a426934bb97e91a84 100644 (file)
--- a/drivers/mtd/mtdoops.c
+++ b/drivers/mtd/mtdoops.c
@@ -112,7 +112,7 @@ static int mtdoops_erase_block(struct mtdoops_context *cxt, int offset)
        set_current_state(TASK_INTERRUPTIBLE);
        add_wait_queue(&wait_q, &wait);
 
-       ret = mtd->erase(mtd, &erase);
+       ret = mtd_erase(mtd, &erase);
        if (ret) {
                set_current_state(TASK_RUNNING);
                remove_wait_queue(&wait_q, &wait);
@@ -169,8 +169,8 @@ static void mtdoops_workfunc_erase(struct work_struct *work)
                        cxt->nextpage = 0;
        }
 
-       while (mtd->block_isbad) {
-               ret = mtd->block_isbad(mtd, cxt->nextpage * record_size);
+       while (mtd_can_have_bb(mtd)) {
+               ret = mtd_block_isbad(mtd, cxt->nextpage * record_size);
                if (!ret)
                        break;
                if (ret < 0) {
@@ -199,8 +199,8 @@ badblock:
                return;
        }
 
-       if (mtd->block_markbad && ret == -EIO) {
-               ret = mtd->block_markbad(mtd, cxt->nextpage * record_size);
+       if (mtd_can_have_bb(mtd) && ret == -EIO) {
+               ret = mtd_block_markbad(mtd, cxt->nextpage * record_size);
                if (ret < 0) {
                        printk(KERN_ERR "mtdoops: block_markbad failed, aborting\n");
                        return;
@@ -221,12 +221,16 @@ static void mtdoops_write(struct mtdoops_context *cxt, int panic)
        hdr[0] = cxt->nextcount;
        hdr[1] = MTDOOPS_KERNMSG_MAGIC;
 
-       if (panic)
-               ret = mtd->panic_write(mtd, cxt->nextpage * record_size,
-                                       record_size, &retlen, cxt->oops_buf);
-       else
-               ret = mtd->write(mtd, cxt->nextpage * record_size,
-                                       record_size, &retlen, cxt->oops_buf);
+       if (panic) {
+               ret = mtd_panic_write(mtd, cxt->nextpage * record_size,
+                                     record_size, &retlen, cxt->oops_buf);
+               if (ret == -EOPNOTSUPP) {
+                       printk(KERN_ERR "mtdoops: Cannot write from panic without panic_write\n");
+                       return;
+               }
+       } else
+               ret = mtd_write(mtd, cxt->nextpage * record_size,
+                               record_size, &retlen, cxt->oops_buf);
 
        if (retlen != record_size || ret < 0)
                printk(KERN_ERR "mtdoops: write failure at %ld (%td of %ld written), error %d\n",
@@ -253,10 +257,13 @@ static void find_next_position(struct mtdoops_context *cxt)
        size_t retlen;
 
        for (page = 0; page < cxt->oops_pages; page++) {
+               if (mtd_can_have_bb(mtd) &&
+                   mtd_block_isbad(mtd, page * record_size))
+                       continue;
                /* Assume the page is used */
                mark_page_used(cxt, page);
-               ret = mtd->read(mtd, page * record_size, MTDOOPS_HEADER_SIZE,
-                               &retlen, (u_char *) &count[0]);
+               ret = mtd_read(mtd, page * record_size, MTDOOPS_HEADER_SIZE,
+                              &retlen, (u_char *)&count[0]);
                if (retlen != MTDOOPS_HEADER_SIZE ||
                                (ret < 0 && !mtd_is_bitflip(ret))) {
                        printk(KERN_ERR "mtdoops: read failure at %ld (%td of %d read), err %d\n",
@@ -308,8 +315,7 @@ static void mtdoops_do_dump(struct kmsg_dumper *dumper,
        char *dst;
 
        if (reason != KMSG_DUMP_OOPS &&
-           reason != KMSG_DUMP_PANIC &&
-           reason != KMSG_DUMP_KEXEC)
+           reason != KMSG_DUMP_PANIC)
                return;
 
        /* Only dump oopses if dump_oops is set */
@@ -327,13 +333,8 @@ static void mtdoops_do_dump(struct kmsg_dumper *dumper,
        memcpy(dst + l1_cpy, s2 + s2_start, l2_cpy);
 
        /* Panics must be written immediately */
-       if (reason != KMSG_DUMP_OOPS) {
-               if (!cxt->mtd->panic_write)
-                       printk(KERN_ERR "mtdoops: Cannot write from panic without panic_write\n");
-               else
-                       mtdoops_write(cxt, 1);
-               return;
-       }
+       if (reason != KMSG_DUMP_OOPS)
+               mtdoops_write(cxt, 1);
 
        /* For other cases, schedule work to write it "nicely" */
        schedule_work(&cxt->work_write);
@@ -369,7 +370,7 @@ static void mtdoops_notify_add(struct mtd_info *mtd)
 
        /* oops_page_used is a bit field */
        cxt->oops_page_used = vmalloc(DIV_ROUND_UP(mtdoops_pages,
-                       BITS_PER_LONG));
+                       BITS_PER_LONG) * sizeof(unsigned long));
        if (!cxt->oops_page_used) {
                printk(KERN_ERR "mtdoops: could not allocate page array\n");
                return;