Changeset 15251


Ignore:
Timestamp:
2009-04-18T19:04:16+02:00 (8 years ago)
Author:
nbd
Message:

add generic 2.6.29 patches and config (squashfs still untested, user space mkfs still missing)

Location:
trunk/target/linux/generic-2.6
Files:
94 added
1 edited

Legend:

Unmodified
Added
Removed
  • trunk/target/linux/generic-2.6/patches-2.6.29/065-rootfs_split.patch

    r14822 r15251  
    1 diff -ruN linux-2.6.29-rc3.orig/drivers/mtd/devices/block2mtd.c linux-2.6.29-rc3/drivers/mtd/devices/block2mtd.c 
    2 --- linux-2.6.29-rc3.orig/drivers/mtd/devices/block2mtd.c       2009-03-09 05:13:51.000000000 +0100 
    3 +++ linux-2.6.29-rc3/drivers/mtd/devices/block2mtd.c    2009-03-09 18:18:49.000000000 +0100 
    4 @@ -28,6 +28,8 @@ 
    5         struct block_device *blkdev; 
    6         struct mtd_info mtd; 
    7         struct mutex write_mutex; 
    8 +       rwlock_t bdev_mutex; 
    9 +       char devname[0]; 
    10  }; 
    11   
    12   
    13 @@ -80,6 +82,12 @@ 
    14         size_t len = instr->len; 
    15         int err; 
    16   
    17 +       read_lock(&dev->bdev_mutex); 
    18 +       if (!dev->blkdev) { 
    19 +               err = -EINVAL; 
    20 +               goto done; 
    21 +       } 
    22 + 
    23         instr->state = MTD_ERASING; 
    24         mutex_lock(&dev->write_mutex); 
    25         err = _block2mtd_erase(dev, from, len); 
    26 @@ -92,6 +100,10 @@ 
    27   
    28         instr->state = MTD_ERASE_DONE; 
    29         mtd_erase_callback(instr); 
    30 + 
    31 +done: 
    32 +       read_unlock(&dev->bdev_mutex); 
    33 + 
    34         return err; 
    35  } 
    36   
    37 @@ -103,10 +115,14 @@ 
    38         struct page *page; 
    39         int index = from >> PAGE_SHIFT; 
    40         int offset = from & (PAGE_SIZE-1); 
    41 -       int cpylen; 
    42 +       int cpylen, err = 0; 
    43 + 
    44 +       read_lock(&dev->bdev_mutex); 
    45 +       if (!dev->blkdev || (from > mtd->size)) { 
    46 +               err = -EINVAL; 
    47 +               goto done; 
    48 +       } 
    49   
    50 -       if (from > mtd->size) 
    51 -               return -EINVAL; 
    52         if (from + len > mtd->size) 
    53                 len = mtd->size - from; 
    54   
    55 @@ -121,10 +137,14 @@ 
    56                 len = len - cpylen; 
    57   
    58                 page = page_read(dev->blkdev->bd_inode->i_mapping, index); 
    59 -               if (!page) 
    60 -                       return -ENOMEM; 
    61 -               if (IS_ERR(page)) 
    62 -                       return PTR_ERR(page); 
    63 +               if (!page) { 
    64 +                       err = -ENOMEM; 
    65 +                       goto done; 
    66 +               } 
    67 +               if (IS_ERR(page)) { 
    68 +                       err = PTR_ERR(page); 
    69 +                       goto done; 
    70 +               } 
    71   
    72                 memcpy(buf, page_address(page) + offset, cpylen); 
    73                 page_cache_release(page); 
    74 @@ -135,7 +155,10 @@ 
    75                 offset = 0; 
    76                 index++; 
    77         } 
    78 -       return 0; 
    79 + 
    80 +done: 
    81 +       read_unlock(&dev->bdev_mutex); 
    82 +       return err; 
    83  } 
    84   
    85   
    86 @@ -187,12 +210,22 @@ 
    87                 size_t *retlen, const u_char *buf) 
    88  { 
    89         struct block2mtd_dev *dev = mtd->priv; 
    90 -       int err; 
    91 +       int err = 0; 
    92 + 
    93 +       read_lock(&dev->bdev_mutex); 
    94 +       if (!dev->blkdev) { 
    95 +               err = -EINVAL; 
    96 +               goto done; 
    97 +       } 
    98   
    99         if (!len) 
    100 -               return 0; 
    101 -       if (to >= mtd->size) 
    102 -               return -ENOSPC; 
    103 +               goto done; 
    104 + 
    105 +       if (to >= mtd->size) { 
    106 +               err = -ENOSPC; 
    107 +               goto done; 
    108 +       } 
    109 + 
    110         if (to + len > mtd->size) 
    111                 len = mtd->size - to; 
    112   
    113 @@ -201,6 +234,9 @@ 
    114         mutex_unlock(&dev->write_mutex); 
    115         if (err > 0) 
    116                 err = 0; 
    117 + 
    118 +done: 
    119 +       read_unlock(&dev->bdev_mutex); 
    120         return err; 
    121  } 
    122   
    123 @@ -209,30 +245,15 @@ 
    124  static void block2mtd_sync(struct mtd_info *mtd) 
    125  { 
    126         struct block2mtd_dev *dev = mtd->priv; 
    127 -       sync_blockdev(dev->blkdev); 
    128 -       return; 
    129 -} 
    130 - 
    131 +       read_lock(&dev->bdev_mutex); 
    132 +       if (dev->blkdev) 
    133 +               sync_blockdev(dev->blkdev); 
    134 +       read_unlock(&dev->bdev_mutex); 
    135   
    136 -static void block2mtd_free_device(struct block2mtd_dev *dev) 
    137 -{ 
    138 -       if (!dev) 
    139 -               return; 
    140 - 
    141 -       kfree(dev->mtd.name); 
    142 - 
    143 -       if (dev->blkdev) { 
    144 -               invalidate_mapping_pages(dev->blkdev->bd_inode->i_mapping, 
    145 -                                       0, -1); 
    146 -               close_bdev_exclusive(dev->blkdev, FMODE_READ|FMODE_WRITE); 
    147 -       } 
    148 - 
    149 -       kfree(dev); 
    150 +       return; 
    151  } 
    152   
    153 - 
    154 -/* FIXME: ensure that mtd->size % erase_size == 0 */ 
    155 -static struct block2mtd_dev *add_device(char *devname, int erase_size) 
    156 +static int _open_bdev(struct block2mtd_dev *dev) 
    157  { 
    158         struct block_device *bdev; 
    159         struct block2mtd_dev *dev; 
    160 @@ -246,14 +267,14 @@ 
    161                 return NULL; 
    162   
    163         /* Get a handle on the device */ 
    164 -       bdev = open_bdev_exclusive(devname, FMODE_READ|FMODE_WRITE, NULL); 
    165 +       bdev = open_bdev_exclusive(dev->devname, FMODE_READ|FMODE_WRITE, NULL); 
    166  #ifndef MODULE 
    167         if (IS_ERR(bdev)) { 
    168   
    169                 /* We might not have rootfs mounted at this point. Try 
    170                    to resolve the device name by other means. */ 
    171   
    172 -               dev_t devt = name_to_dev_t(devname); 
    173 +               dev_t devt = name_to_dev_t(dev->devname); 
    174                 if (devt) { 
    175                         bdev = open_by_devnum(devt, FMODE_WRITE | FMODE_READ); 
    176                 } 
    177 @@ -261,17 +282,97 @@ 
    178  #endif 
    179   
    180         if (IS_ERR(bdev)) { 
    181 -               ERROR("error: cannot open device %s", devname); 
    182 -               goto devinit_err; 
    183 +               ERROR("error: cannot open device %s", dev->devname); 
    184 +               return 1; 
    185         } 
    186         dev->blkdev = bdev; 
    187   
    188         if (MAJOR(bdev->bd_dev) == MTD_BLOCK_MAJOR) { 
    189                 ERROR("attempting to use an MTD device as a block device"); 
    190 -               goto devinit_err; 
    191 +               return 1; 
    192         } 
    193   
    194 +       return 0; 
    195 +} 
    196 + 
    197 +static void _close_bdev(struct block2mtd_dev *dev) 
    198 +{ 
    199 +       struct block_device *bdev; 
    200 + 
    201 +       if (!dev->blkdev) 
    202 +               return; 
    203 + 
    204 +       bdev = dev->blkdev; 
    205 +       invalidate_mapping_pages(dev->blkdev->bd_inode->i_mapping, 0, -1); 
    206 +       close_bdev_exclusive(dev->blkdev, FMODE_READ|FMODE_WRITE); 
    207 +       dev->blkdev = NULL; 
    208 +} 
    209 + 
    210 +static void block2mtd_free_device(struct block2mtd_dev *dev) 
    211 +{ 
    212 +       if (!dev) 
    213 +               return; 
    214 + 
    215 +       kfree(dev->mtd.name); 
    216 +       _close_bdev(dev); 
    217 +       kfree(dev); 
    218 +} 
    219 + 
    220 + 
    221 +static int block2mtd_refresh(struct mtd_info *mtd) 
    222 +{ 
    223 +       struct block2mtd_dev *dev = mtd->priv; 
    224 +       struct block_device *bdev; 
    225 +       dev_t devt; 
    226 +       int err = 0; 
    227 + 
    228 +       /* no other mtd function can run at this point */ 
    229 +       write_lock(&dev->bdev_mutex); 
    230 + 
    231 +       /* get the device number for the whole disk */ 
    232 +       devt = MKDEV(MAJOR(dev->blkdev->bd_dev), 0); 
    233 + 
    234 +       /* close the old block device */ 
    235 +       _close_bdev(dev); 
    236 + 
    237 +       /* open the whole disk, issue a partition rescan, then */ 
    238 +       bdev = open_by_devnum(devt, FMODE_WRITE | FMODE_READ); 
    239 +       if (!bdev || !bdev->bd_disk) 
    240 +               err = -EINVAL; 
    241 +       else { 
    242 +               err = rescan_partitions(bdev->bd_disk, bdev); 
    243 +       } 
    244 +       if (bdev) 
    245 +               close_bdev_exclusive(bdev, FMODE_READ|FMODE_WRITE); 
    246 + 
    247 +       /* try to open the partition block device again */ 
    248 +       _open_bdev(dev); 
    249 +       write_unlock(&dev->bdev_mutex); 
    250 + 
    251 +       return err; 
    252 +} 
    253 + 
    254 +/* FIXME: ensure that mtd->size % erase_size == 0 */ 
    255 +static struct block2mtd_dev *add_device(char *devname, int erase_size, char *mtdname) 
    256 +{ 
    257 +       struct block2mtd_dev *dev; 
    258 +       struct mtd_partition *part; 
    259 +       char *name; 
    260 + 
    261 +       if (!devname) 
    262 +               return NULL; 
    263 + 
    264 +       dev = kzalloc(sizeof(struct block2mtd_dev) + strlen(devname) + 1, GFP_KERNEL); 
    265 +       if (!dev) 
    266 +               return NULL; 
    267 + 
    268 +       strcpy(dev->devname, devname); 
    269 + 
    270 +       if (_open_bdev(dev)) 
    271 +               goto devinit_err; 
    272 + 
    273         mutex_init(&dev->write_mutex); 
    274 +       rwlock_init(&dev->bdev_mutex); 
    275   
    276         /* Setup the MTD structure */ 
    277         /* make the name contain the block device in */ 
    278 @@ -295,6 +396,7 @@ 
    279         dev->mtd.read = block2mtd_read; 
    280         dev->mtd.priv = dev; 
    281         dev->mtd.owner = THIS_MODULE; 
    282 +       dev->mtd.refresh_device = block2mtd_refresh; 
    283   
    284         if (add_mtd_device(&dev->mtd)) { 
    285                 /* Device didnt get added, so free the entry */ 
    286 diff -ruN linux-2.6.29-rc3.orig/drivers/mtd/Kconfig linux-2.6.29-rc3/drivers/mtd/Kconfig 
    287 --- linux-2.6.29-rc3.orig/drivers/mtd/Kconfig   2009-03-09 05:13:51.000000000 +0100 
    288 +++ linux-2.6.29-rc3/drivers/mtd/Kconfig        2009-03-09 18:10:48.000000000 +0100 
    289 @@ -53,6 +53,16 @@ 
     1--- a/drivers/mtd/Kconfig 
     2+++ b/drivers/mtd/Kconfig 
     3@@ -53,6 +53,16 @@ config MTD_TESTS 
    2904          should normally be compiled as kernel modules. The modules perform 
    2915          various checks and verifications when loaded. 
     
    30418        tristate "RedBoot partition table parsing" 
    30519        depends on MTD_PARTITIONS 
    306 diff -ruN linux-2.6.29-rc3.orig/drivers/mtd/mtdchar.c linux-2.6.29-rc3/drivers/mtd/mtdchar.c 
    307 --- linux-2.6.29-rc3.orig/drivers/mtd/mtdchar.c 2009-03-09 05:13:51.000000000 +0100 
    308 +++ linux-2.6.29-rc3/drivers/mtd/mtdchar.c      2009-03-09 18:10:48.000000000 +0100 
    309 @@ -16,6 +16,7 @@ 
    310   
    311  #include <linux/mtd/mtd.h> 
    312  #include <linux/mtd/compatmac.h> 
    313 +#include <linux/mtd/partitions.h> 
    314   
    315  #include <asm/uaccess.h> 
    316   
    317 @@ -773,6 +774,13 @@ 
    318                 file->f_pos = 0; 
    319                 break; 
    320         } 
    321 +#ifdef CONFIG_MTD_PARTITIONS 
    322 +       case MTDREFRESH: 
    323 +       { 
    324 +               ret = refresh_mtd_partitions(mtd); 
    325 +               break; 
    326 +       } 
    327 +#endif 
    328   
    329         default: 
    330                 ret = -ENOTTY; 
    331 diff -ruN linux-2.6.29-rc3.orig/drivers/mtd/mtdpart.c linux-2.6.29-rc3/drivers/mtd/mtdpart.c 
    332 --- linux-2.6.29-rc3.orig/drivers/mtd/mtdpart.c 2009-03-09 05:13:51.000000000 +0100 
    333 +++ linux-2.6.29-rc3/drivers/mtd/mtdpart.c      2009-03-09 18:29:58.000000000 +0100 
     20--- a/drivers/mtd/mtdpart.c 
     21+++ b/drivers/mtd/mtdpart.c 
    33422@@ -18,6 +18,8 @@ 
    33523 #include <linux/mtd/mtd.h> 
    33624 #include <linux/mtd/partitions.h> 
    33725 #include <linux/mtd/compatmac.h> 
    338 +#include <linux/squashfs_fs.h> 
    33926+#include <linux/root_dev.h> 
     27+#include <linux/magic.h> 
    34028  
    34129 /* Our partition linked list */ 
    34230 static LIST_HEAD(mtd_partitions); 
    343 @@ -37,7 +39,7 @@ 
     31@@ -37,7 +39,7 @@ struct mtd_part { 
    34432  * the pointer to that structure with this macro. 
    34533  */ 
     
    35038 /* 
    35139  * MTD methods which simply translate the effective address and pass through 
    352 @@ -489,6 +491,148 @@ 
     40@@ -489,6 +491,156 @@ out_register: 
    35341        return slave; 
    35442 } 
     
    35745+#define ROOTFS_SPLIT_NAME "rootfs_data" 
    35846+#define ROOTFS_REMOVED_NAME "<removed>" 
     47+ 
     48+struct squashfs_super_block { 
     49+       __le32 s_magic; 
     50+       __le32 pad0[9]; 
     51+       __le64 bytes_used; 
     52+}; 
     53+ 
     54+ 
    35955+static int split_squashfs(struct mtd_info *master, int offset, int *split_offset) 
    36056+{ 
     
    426122+               return 1; 
    427123+ 
    428 +       printk(KERN_INFO "mtd: partition \"%s\" created automatically, ofs=%X, len=%X \n", 
     124+       printk(KERN_INFO "mtd: partition \"%s\" created automatically, ofs=%llX, len=%llX \n", 
    429125+               ROOTFS_SPLIT_NAME, dpart->offset, dpart->size); 
    430126+ 
     
    476172+               printk(KERN_INFO "%s: %s partition \"" ROOTFS_SPLIT_NAME "\", offset: 0x%06x (0x%06x)\n", 
    477173+                       __func__, (!strcmp(part->mtd.name, ROOTFS_SPLIT_NAME) ? "updating" : "creating"), 
    478 +                       part->offset, part->mtd.size); 
     174+                       (u32) part->offset, (u32) part->mtd.size); 
    479175+               name = kmalloc(sizeof(ROOTFS_SPLIT_NAME) + 1, GFP_KERNEL); 
    480176+               strcpy(name, ROOTFS_SPLIT_NAME); 
     
    499195  * This function, given a master MTD object and a partition table, creates 
    500196  * and registers slave MTD objects which are bound to the master according to 
    501 @@ -502,14 +646,29 @@ 
     197@@ -502,14 +654,29 @@ int add_mtd_partitions(struct mtd_info * 
    502198 { 
    503199        struct mtd_part *slave; 
    504200        uint64_t cur_offset = 0; 
    505201-       int i; 
    506 +    int i, j, ret; 
     202+       int i, j, ret; 
    507203  
    508204        printk(KERN_NOTICE "Creating %d MTD partitions on \"%s\":\n", nbparts, master->name); 
     
    532228        } 
    533229  
    534 @@ -517,6 +676,32 @@ 
     230@@ -517,6 +684,32 @@ int add_mtd_partitions(struct mtd_info * 
    535231 } 
    536232 EXPORT_SYMBOL(add_mtd_partitions); 
     
    565261 static LIST_HEAD(part_parsers); 
    566262  
    567 diff -ruN linux-2.6.29-rc3.orig/include/linux/mtd/mtd.h linux-2.6.29-rc3/include/linux/mtd/mtd.h 
    568 --- linux-2.6.29-rc3.orig/include/linux/mtd/mtd.h       2009-03-09 05:13:58.000000000 +0100 
    569 +++ linux-2.6.29-rc3/include/linux/mtd/mtd.h    2009-03-09 18:10:48.000000000 +0100 
    570 @@ -100,6 +100,7 @@ 
     263--- a/drivers/mtd/devices/block2mtd.c 
     264+++ b/drivers/mtd/devices/block2mtd.c 
     265@@ -29,6 +29,8 @@ struct block2mtd_dev { 
     266        struct block_device *blkdev; 
     267        struct mtd_info mtd; 
     268        struct mutex write_mutex; 
     269+       rwlock_t bdev_mutex; 
     270+       char devname[0]; 
     271 }; 
     272  
     273  
     274@@ -81,6 +83,12 @@ static int block2mtd_erase(struct mtd_in 
     275        size_t len = instr->len; 
     276        int err; 
     277  
     278+       read_lock(&dev->bdev_mutex); 
     279+       if (!dev->blkdev) { 
     280+               err = -EINVAL; 
     281+               goto done; 
     282+       } 
     283+ 
     284        instr->state = MTD_ERASING; 
     285        mutex_lock(&dev->write_mutex); 
     286        err = _block2mtd_erase(dev, from, len); 
     287@@ -93,6 +101,10 @@ static int block2mtd_erase(struct mtd_in 
     288  
     289        instr->state = MTD_ERASE_DONE; 
     290        mtd_erase_callback(instr); 
     291+ 
     292+done: 
     293+       read_unlock(&dev->bdev_mutex); 
     294+ 
     295        return err; 
     296 } 
     297  
     298@@ -104,10 +116,14 @@ static int block2mtd_read(struct mtd_inf 
     299        struct page *page; 
     300        int index = from >> PAGE_SHIFT; 
     301        int offset = from & (PAGE_SIZE-1); 
     302-       int cpylen; 
     303+       int cpylen, err = 0; 
     304+ 
     305+       read_lock(&dev->bdev_mutex); 
     306+       if (!dev->blkdev || (from > mtd->size)) { 
     307+               err = -EINVAL; 
     308+               goto done; 
     309+       } 
     310  
     311-       if (from > mtd->size) 
     312-               return -EINVAL; 
     313        if (from + len > mtd->size) 
     314                len = mtd->size - from; 
     315  
     316@@ -122,10 +138,14 @@ static int block2mtd_read(struct mtd_inf 
     317                len = len - cpylen; 
     318  
     319                page = page_read(dev->blkdev->bd_inode->i_mapping, index); 
     320-               if (!page) 
     321-                       return -ENOMEM; 
     322-               if (IS_ERR(page)) 
     323-                       return PTR_ERR(page); 
     324+               if (!page) { 
     325+                       err = -ENOMEM; 
     326+                       goto done; 
     327+               } 
     328+               if (IS_ERR(page)) { 
     329+                       err = PTR_ERR(page); 
     330+                       goto done; 
     331+               } 
     332  
     333                memcpy(buf, page_address(page) + offset, cpylen); 
     334                page_cache_release(page); 
     335@@ -136,7 +156,10 @@ static int block2mtd_read(struct mtd_inf 
     336                offset = 0; 
     337                index++; 
     338        } 
     339-       return 0; 
     340+ 
     341+done: 
     342+       read_unlock(&dev->bdev_mutex); 
     343+       return err; 
     344 } 
     345  
     346  
     347@@ -188,12 +211,22 @@ static int block2mtd_write(struct mtd_in 
     348                size_t *retlen, const u_char *buf) 
     349 { 
     350        struct block2mtd_dev *dev = mtd->priv; 
     351-       int err; 
     352+       int err = 0; 
     353+ 
     354+       read_lock(&dev->bdev_mutex); 
     355+       if (!dev->blkdev) { 
     356+               err = -EINVAL; 
     357+               goto done; 
     358+       } 
     359  
     360        if (!len) 
     361-               return 0; 
     362-       if (to >= mtd->size) 
     363-               return -ENOSPC; 
     364+               goto done; 
     365+ 
     366+       if (to >= mtd->size) { 
     367+               err = -ENOSPC; 
     368+               goto done; 
     369+       } 
     370+ 
     371        if (to + len > mtd->size) 
     372                len = mtd->size - to; 
     373  
     374@@ -202,6 +235,9 @@ static int block2mtd_write(struct mtd_in 
     375        mutex_unlock(&dev->write_mutex); 
     376        if (err > 0) 
     377                err = 0; 
     378+ 
     379+done: 
     380+       read_unlock(&dev->bdev_mutex); 
     381        return err; 
     382 } 
     383  
     384@@ -210,52 +246,29 @@ static int block2mtd_write(struct mtd_in 
     385 static void block2mtd_sync(struct mtd_info *mtd) 
     386 { 
     387        struct block2mtd_dev *dev = mtd->priv; 
     388-       sync_blockdev(dev->blkdev); 
     389-       return; 
     390-} 
     391- 
     392- 
     393-static void block2mtd_free_device(struct block2mtd_dev *dev) 
     394-{ 
     395-       if (!dev) 
     396-               return; 
     397- 
     398-       kfree(dev->mtd.name); 
     399  
     400-       if (dev->blkdev) { 
     401-               invalidate_mapping_pages(dev->blkdev->bd_inode->i_mapping, 
     402-                                       0, -1); 
     403-               close_bdev_exclusive(dev->blkdev, FMODE_READ|FMODE_WRITE); 
     404-       } 
     405+       read_lock(&dev->bdev_mutex); 
     406+       if (dev->blkdev) 
     407+               sync_blockdev(dev->blkdev); 
     408+       read_unlock(&dev->bdev_mutex); 
     409  
     410-       kfree(dev); 
     411+       return; 
     412 } 
     413  
     414  
     415-/* FIXME: ensure that mtd->size % erase_size == 0 */ 
     416-static struct block2mtd_dev *add_device(char *devname, int erase_size, const char *mtdname) 
     417+static int _open_bdev(struct block2mtd_dev *dev) 
     418 { 
     419        struct block_device *bdev; 
     420-       struct block2mtd_dev *dev; 
     421-       struct mtd_partition *part; 
     422-       char *name; 
     423- 
     424-       if (!devname) 
     425-               return NULL; 
     426- 
     427-       dev = kzalloc(sizeof(struct block2mtd_dev), GFP_KERNEL); 
     428-       if (!dev) 
     429-               return NULL; 
     430  
     431        /* Get a handle on the device */ 
     432-       bdev = open_bdev_exclusive(devname, FMODE_READ|FMODE_WRITE, NULL); 
     433+       bdev = open_bdev_exclusive(dev->devname, FMODE_READ|FMODE_WRITE, NULL); 
     434 #ifndef MODULE 
     435        if (IS_ERR(bdev)) { 
     436  
     437                /* We might not have rootfs mounted at this point. Try 
     438                   to resolve the device name by other means. */ 
     439  
     440-               dev_t devt = name_to_dev_t(devname); 
     441+               dev_t devt = name_to_dev_t(dev->devname); 
     442                if (devt) { 
     443                        bdev = open_by_devnum(devt, FMODE_WRITE | FMODE_READ); 
     444                } 
     445@@ -263,17 +276,97 @@ static struct block2mtd_dev *add_device( 
     446 #endif 
     447  
     448        if (IS_ERR(bdev)) { 
     449-               ERROR("error: cannot open device %s", devname); 
     450-               goto devinit_err; 
     451+               ERROR("error: cannot open device %s", dev->devname); 
     452+               return 1; 
     453        } 
     454        dev->blkdev = bdev; 
     455  
     456        if (MAJOR(bdev->bd_dev) == MTD_BLOCK_MAJOR) { 
     457                ERROR("attempting to use an MTD device as a block device"); 
     458-               goto devinit_err; 
     459+               return 1; 
     460        } 
     461  
     462+       return 0; 
     463+} 
     464+ 
     465+static void _close_bdev(struct block2mtd_dev *dev) 
     466+{ 
     467+       struct block_device *bdev; 
     468+ 
     469+       if (!dev->blkdev) 
     470+               return; 
     471+ 
     472+       bdev = dev->blkdev; 
     473+       invalidate_mapping_pages(dev->blkdev->bd_inode->i_mapping, 0, -1); 
     474+       close_bdev_exclusive(dev->blkdev, FMODE_READ|FMODE_WRITE); 
     475+       dev->blkdev = NULL; 
     476+} 
     477+ 
     478+static void block2mtd_free_device(struct block2mtd_dev *dev) 
     479+{ 
     480+       if (!dev) 
     481+               return; 
     482+ 
     483+       kfree(dev->mtd.name); 
     484+       _close_bdev(dev); 
     485+       kfree(dev); 
     486+} 
     487+ 
     488+ 
     489+static int block2mtd_refresh(struct mtd_info *mtd) 
     490+{ 
     491+       struct block2mtd_dev *dev = mtd->priv; 
     492+       struct block_device *bdev; 
     493+       dev_t devt; 
     494+       int err = 0; 
     495+ 
     496+       /* no other mtd function can run at this point */ 
     497+       write_lock(&dev->bdev_mutex); 
     498+ 
     499+       /* get the device number for the whole disk */ 
     500+       devt = MKDEV(MAJOR(dev->blkdev->bd_dev), 0); 
     501+ 
     502+       /* close the old block device */ 
     503+       _close_bdev(dev); 
     504+ 
     505+       /* open the whole disk, issue a partition rescan, then */ 
     506+       bdev = open_by_devnum(devt, FMODE_WRITE | FMODE_READ); 
     507+       if (!bdev || !bdev->bd_disk) 
     508+               err = -EINVAL; 
     509+       else { 
     510+               err = rescan_partitions(bdev->bd_disk, bdev); 
     511+       } 
     512+       if (bdev) 
     513+               close_bdev_exclusive(bdev, FMODE_READ|FMODE_WRITE); 
     514+ 
     515+       /* try to open the partition block device again */ 
     516+       _open_bdev(dev); 
     517+       write_unlock(&dev->bdev_mutex); 
     518+ 
     519+       return err; 
     520+} 
     521+ 
     522+/* FIXME: ensure that mtd->size % erase_size == 0 */ 
     523+static struct block2mtd_dev *add_device(char *devname, int erase_size, char *mtdname) 
     524+{ 
     525+       struct block2mtd_dev *dev; 
     526+       struct mtd_partition *part; 
     527+       char *name; 
     528+ 
     529+       if (!devname) 
     530+               return NULL; 
     531+ 
     532+       dev = kzalloc(sizeof(struct block2mtd_dev) + strlen(devname) + 1, GFP_KERNEL); 
     533+       if (!dev) 
     534+               return NULL; 
     535+ 
     536+       strcpy(dev->devname, devname); 
     537+ 
     538+       if (_open_bdev(dev)) 
     539+               goto devinit_err; 
     540+ 
     541        mutex_init(&dev->write_mutex); 
     542+       rwlock_init(&dev->bdev_mutex); 
     543  
     544        if (!mtdname) 
     545                mtdname = devname; 
     546@@ -297,6 +390,7 @@ static struct block2mtd_dev *add_device( 
     547        dev->mtd.read = block2mtd_read; 
     548        dev->mtd.priv = dev; 
     549        dev->mtd.owner = THIS_MODULE; 
     550+       dev->mtd.refresh_device = block2mtd_refresh; 
     551  
     552        part = kzalloc(sizeof(struct mtd_partition), GFP_KERNEL); 
     553        part->name = dev->mtd.name; 
     554--- a/drivers/mtd/mtdchar.c 
     555+++ b/drivers/mtd/mtdchar.c 
     556@@ -16,6 +16,7 @@ 
     557  
     558 #include <linux/mtd/mtd.h> 
     559 #include <linux/mtd/compatmac.h> 
     560+#include <linux/mtd/partitions.h> 
     561  
     562 #include <asm/uaccess.h> 
     563  
     564@@ -773,6 +774,13 @@ static int mtd_ioctl(struct inode *inode 
     565                file->f_pos = 0; 
     566                break; 
     567        } 
     568+#ifdef CONFIG_MTD_PARTITIONS 
     569+       case MTDREFRESH: 
     570+       { 
     571+               ret = refresh_mtd_partitions(mtd); 
     572+               break; 
     573+       } 
     574+#endif 
     575  
     576        default: 
     577                ret = -ENOTTY; 
     578--- a/include/linux/mtd/mtd.h 
     579+++ b/include/linux/mtd/mtd.h 
     580@@ -100,6 +100,7 @@ struct mtd_oob_ops { 
    571581        uint8_t         *oobbuf; 
    572582 }; 
     
    576586        u_char type; 
    577587        uint32_t flags; 
    578 @@ -225,6 +226,9 @@ 
     588@@ -225,6 +226,9 @@ struct mtd_info { 
    579589        struct module *owner; 
    580590        int usecount; 
     
    586596         * its own reference counting. The below functions are only for driver. 
    587597         * The driver may register its callbacks. These callbacks are not 
    588 diff -ruN linux-2.6.29-rc3.orig/include/linux/mtd/partitions.h linux-2.6.29-rc3/include/linux/mtd/partitions.h 
    589 --- linux-2.6.29-rc3.orig/include/linux/mtd/partitions.h        2009-03-09 05:13:58.000000000 +0100 
    590 +++ linux-2.6.29-rc3/include/linux/mtd/partitions.h     2009-03-09 18:10:48.000000000 +0100 
     598--- a/include/linux/mtd/partitions.h 
     599+++ b/include/linux/mtd/partitions.h 
    591600@@ -34,6 +34,7 @@ 
    592601  * erasesize aligned (e.g. use MTDPART_OFS_NEXTBLK). 
     
    597606        char *name;                     /* identifier string */ 
    598607        uint64_t size;                  /* partition size */ 
    599 @@ -41,6 +42,7 @@ 
     608@@ -41,6 +42,7 @@ struct mtd_partition { 
    600609        uint32_t mask_flags;            /* master MTD flags to mask out for this partition */ 
    601610        struct nand_ecclayout *ecclayout;       /* out of band layout for this partition (NAND only)*/ 
     
    605614  
    606615 #define MTDPART_OFS_NXTBLK     (-2) 
    607 @@ -50,6 +52,7 @@ 
     616@@ -50,6 +52,7 @@ struct mtd_partition { 
    608617  
    609618 int add_mtd_partitions(struct mtd_info *, const struct mtd_partition *, int); 
     
    613622 /* 
    614623  * Functions dealing with the various ways of partitioning the space 
    615 diff -ruN linux-2.6.29-rc3.orig/include/mtd/mtd-abi.h linux-2.6.29-rc3/include/mtd/mtd-abi.h 
    616 --- linux-2.6.29-rc3.orig/include/mtd/mtd-abi.h 2009-03-09 05:13:57.000000000 +0100 
    617 +++ linux-2.6.29-rc3/include/mtd/mtd-abi.h      2009-03-09 18:10:48.000000000 +0100 
    618 @@ -93,6 +93,7 @@ 
     624--- a/include/mtd/mtd-abi.h 
     625+++ b/include/mtd/mtd-abi.h 
     626@@ -93,6 +93,7 @@ struct otp_info { 
    619627 #define ECCGETLAYOUT           _IOR('M', 17, struct nand_ecclayout) 
    620628 #define ECCGETSTATS            _IOR('M', 18, struct mtd_ecc_stats) 
Note: See TracChangeset for help on using the changeset viewer.