add a fix for the block2mtd init
authorFelix Fietkau <nbd@openwrt.org>
Sun, 8 Oct 2006 15:43:13 +0000 (15:43 +0000)
committerFelix Fietkau <nbd@openwrt.org>
Sun, 8 Oct 2006 15:43:13 +0000 (15:43 +0000)
SVN-Revision: 4961

openwrt/target/linux/generic-2.6/patches/205-block2mtd_fix.patch [new file with mode: 0644]
openwrt/target/linux/rb532-2.6/patches/100-rb5xx_support.patch

diff --git a/openwrt/target/linux/generic-2.6/patches/205-block2mtd_fix.patch b/openwrt/target/linux/generic-2.6/patches/205-block2mtd_fix.patch
new file mode 100644 (file)
index 0000000..9aaffc5
--- /dev/null
@@ -0,0 +1,235 @@
+diff -urN linux.old/drivers/mtd/devices/block2mtd.c linux.dev/drivers/mtd/devices/block2mtd.c
+--- linux.old/drivers/mtd/devices/block2mtd.c  2006-07-29 19:53:54.000000000 +0200
++++ linux.dev/drivers/mtd/devices/block2mtd.c  2006-07-29 19:47:03.000000000 +0200
+@@ -4,11 +4,10 @@
+  * block2mtd.c - create an mtd from a block device
+  *
+  * Copyright (C) 2001,2002    Simon Evans <spse@secret.org.uk>
+- * Copyright (C) 2004,2005    Jörn Engel <joern@wh.fh-wedel.de>
++ * Copyright (C) 2004-2006    Jörn Engel <joern@wh.fh-wedel.de>
+  *
+  * Licence: GPL
+  */
+-#include <linux/config.h>
+ #include <linux/module.h>
+ #include <linux/fs.h>
+ #include <linux/blkdev.h>
+@@ -19,6 +18,7 @@ #include <linux/init.h>
+ #include <linux/mtd/mtd.h>
+ #include <linux/buffer_head.h>
+ #include <linux/mutex.h>
++#include <linux/mount.h>
+ #define VERSION "$Revision: 1.30 $"
+@@ -62,10 +61,8 @@
+       read_lock_irq(&mapping->tree_lock);
+       for (i = 0; i < PAGE_READAHEAD; i++) {
+               pagei = index + i;
+-              if (pagei > end_index) {
+-                      INFO("Overrun end of disk in cache readahead\n");
++              if (pagei > end_index)
+                       break;
+-              }
+               page = radix_tree_lookup(&mapping->page_tree, pagei);
+               if (page && (!i))
+                       break;
+@@ -237,6 +237,8 @@ static int _block2mtd_write(struct block
+       }
+       return 0;
+ }
++
++
+ static int block2mtd_write(struct mtd_info *mtd, loff_t to, size_t len,
+               size_t *retlen, const u_char *buf)
+ {
+@@ -300,6 +302,19 @@ static struct block2mtd_dev *add_device(
+       /* Get a handle on the device */
+       bdev = open_bdev_excl(devname, O_RDWR, NULL);
++#ifndef MODULE
++      if (IS_ERR(bdev)) {
++
++              /* We might not have rootfs mounted at this point. Try
++                 to resolve the device name by other means. */
++
++              dev_t dev = name_to_dev_t(devname);
++              if (dev != 0) {
++                      bdev = open_by_devnum(dev, FMODE_WRITE | FMODE_READ);
++              }
++      }
++#endif
++
+       if (IS_ERR(bdev)) {
+               ERROR("error: cannot open device %s", devname);
+               goto devinit_err;
+@@ -331,7 +347,6 @@ static struct block2mtd_dev *add_device(
+       dev->mtd.writev = default_mtd_writev;
+       dev->mtd.sync = block2mtd_sync;
+       dev->mtd.read = block2mtd_read;
+-      dev->mtd.readv = default_mtd_readv;
+       dev->mtd.priv = dev;
+       dev->mtd.owner = THIS_MODULE;
+@@ -351,6 +366,12 @@ devinit_err:
+ }
++/* This function works similar to reguler strtoul.  In addition, it
++ * allows some suffixes for a more human-readable number format:
++ * ki, Ki, kiB, KiB   - multiply result with 1024
++ * Mi, MiB            - multiply result with 1024^2
++ * Gi, GiB            - multiply result with 1024^3
++ */
+ static int ustrtoul(const char *cp, char **endp, unsigned int base)
+ {
+       unsigned long result = simple_strtoul(cp, endp, base);
+@@ -359,11 +380,16 @@ static int ustrtoul(const char *cp, char
+               result *= 1024;
+       case 'M':
+               result *= 1024;
++      case 'K':
+       case 'k':
+               result *= 1024;
+       /* By dwmw2 editorial decree, "ki", "Mi" or "Gi" are to be used. */
+-              if ((*endp)[1] == 'i')
+-                      (*endp) += 2;
++              if ((*endp)[1] == 'i') {
++                      if ((*endp)[2] == 'B')
++                              (*endp) += 3;
++                      else
++                              (*endp) += 2;
++              }
+       }
+       return result;
+ }
+@@ -383,26 +409,6 @@ static int parse_num(size_t *num, const 
+ }
+-static int parse_name(char **pname, const char *token, size_t limit)
+-{
+-      size_t len;
+-      char *name;
+-
+-      len = strlen(token) + 1;
+-      if (len > limit)
+-              return -ENOSPC;
+-
+-      name = kmalloc(len, GFP_KERNEL);
+-      if (!name)
+-              return -ENOMEM;
+-
+-      strcpy(name, token);
+-
+-      *pname = name;
+-      return 0;
+-}
+-
+-
+ static inline void kill_final_newline(char *str)
+ {
+       char *newline = strrchr(str, '\n');
+@@ -416,9 +422,16 @@ #define parse_err(fmt, args...) do {              \
+       return 0;                               \
+ } while (0)
+-static int block2mtd_setup(const char *val, struct kernel_param *kp)
++#ifndef MODULE
++static int block2mtd_init_called = 0;
++static __initdata char block2mtd_paramline[80 + 12]; /* 80 for device, 12 for erase size */
++#endif
++
++
++static int block2mtd_setup2(const char *val)
+ {
+-      char buf[80+12], *str=buf; /* 80 for device, 12 for erase size */
++      char buf[80 + 12]; /* 80 for device, 12 for erase size */
++      char *str = buf;
+       char *token[2];
+       char *name;
+       size_t erase_size = PAGE_SIZE;
+@@ -430,7 +443,7 @@ static int block2mtd_setup(const char *v
+       strcpy(str, val);
+       kill_final_newline(str);
+-      for (i=0; i<2; i++)
++      for (i = 0; i < 2; i++)
+               token[i] = strsep(&str, ",");
+       if (str)
+@@ -439,18 +452,16 @@ static int block2mtd_setup(const char *v
+       if (!token[0])
+               parse_err("no argument");
+-      ret = parse_name(&name, token[0], 80);
+-      if (ret == -ENOMEM)
+-              parse_err("out of memory");
+-      if (ret == -ENOSPC)
+-              parse_err("name too long");
+-      if (ret)
+-              return 0;
++      name = token[0];
++      if (strlen(name) + 1 > 80)
++              parse_err("device name too long");
+       if (token[1]) {
+               ret = parse_num(&erase_size, token[1]);
+-              if (ret)
++              if (ret) {
++                      kfree(name);
+                       parse_err("illegal erase size");
++              }
+       }
+       add_device(name, erase_size);
+@@ -459,13 +470,48 @@ static int block2mtd_setup(const char *v
+ }
++static int block2mtd_setup(const char *val, struct kernel_param *kp)
++{
++#ifdef MODULE
++      return block2mtd_setup2(val);
++#else
++      /* If more parameters are later passed in via
++         /sys/module/block2mtd/parameters/block2mtd
++         and block2mtd_init() has already been called,
++         we can parse the argument now. */
++
++      if (block2mtd_init_called)
++              return block2mtd_setup2(val);
++
++      /* During early boot stage, we only save the parameters
++         here. We must parse them later: if the param passed
++         from kernel boot command line, block2mtd_setup() is
++         called so early that it is not possible to resolve
++         the device (even kmalloc() fails). Deter that work to
++         block2mtd_setup2(). */
++
++      strlcpy(block2mtd_paramline, val, sizeof(block2mtd_paramline));
++
++      return 0;
++#endif
++}
++
++
+ module_param_call(block2mtd, block2mtd_setup, NULL, NULL, 0200);
+ MODULE_PARM_DESC(block2mtd, "Device to use. \"block2mtd=<dev>[,<erasesize>]\"");
+ static int __init block2mtd_init(void)
+ {
++      int ret = 0;
+       INFO("version " VERSION);
+-      return 0;
++
++#ifndef MODULE
++      if (strlen(block2mtd_paramline))
++              ret = block2mtd_setup2(block2mtd_paramline);
++      block2mtd_init_called = 1;
++#endif
++
++      return ret;
+ }
index f3d114e..a8db826 100644 (file)
@@ -1782,18 +1782,6 @@ diff -urN linux.old/drivers/mtd/devices/block2mtd.c linux.dev/drivers/mtd/device
  /* Info for the block device */
  struct block2mtd_dev {
        struct list_head list;
-@@ -62,10 +61,8 @@
-       read_lock_irq(&mapping->tree_lock);
-       for (i = 0; i < PAGE_READAHEAD; i++) {
-               pagei = index + i;
--              if (pagei > end_index) {
--                      INFO("Overrun end of disk in cache readahead\n");
-+              if (pagei > end_index)
-                       break;
--              }
-               page = radix_tree_lookup(&mapping->page_tree, pagei);
-               if (page && (!i))
-                       break;
 @@ -106,7 +103,7 @@
  
        while (pages) {