target/linux/generic-2.6/patches-2.6.22/065-rootfs_split.patch

   1 Index: linux-2.6.22.1/drivers/mtd/Kconfig
   2 ===================================================================
   3 --- linux-2.6.22.1.orig/drivers/mtd/Kconfig     2007-08-19 23:30:07.068115074 +0200
   4 +++ linux-2.6.22.1/drivers/mtd/Kconfig  2007-08-19 23:31:43.961636725 +0200
   5 @@ -47,6 +47,16 @@
   6           devices. Partitioning on NFTL 'devices' is a different - that's the
   7           'normal' form of partitioning used on a block device.
   8
   9 +config MTD_ROOTFS_ROOT_DEV
  10 +       bool "Automatically set 'rootfs' partition to be root filesystem"
  11 +       depends on MTD_PARTITIONS
  12 +       default y
  13 +
  14 +config MTD_ROOTFS_SPLIT
  15 +       bool "Automatically split 'rootfs' partition for squashfs"
  16 +       depends on MTD_PARTITIONS
  17 +       default y
  18 +
  19  config MTD_REDBOOT_PARTS
  20         tristate "RedBoot partition table parsing"
  21         depends on MTD_PARTITIONS
  22 Index: linux-2.6.22.1/drivers/mtd/mtdpart.c
  23 ===================================================================
  24 --- linux-2.6.22.1.orig/drivers/mtd/mtdpart.c   2007-08-19 23:30:07.076115531 +0200
  25 +++ linux-2.6.22.1/drivers/mtd/mtdpart.c        2007-08-19 23:31:44.065642653 +0200
  26 @@ -20,6 +20,8 @@
  27  #include <linux/mtd/mtd.h>
  28  #include <linux/mtd/partitions.h>
  29  #include <linux/mtd/compatmac.h>
  30 +#include <linux/squashfs_fs.h>
  31 +#include <linux/root_dev.h>
  32
  33  /* Our partition linked list */
  34  static LIST_HEAD(mtd_partitions);
  35 @@ -39,7 +41,7 @@
  36   * the pointer to that structure with this macro.
  37   */
  38  #define PART(x)  ((struct mtd_part *)(x))
  39 -
  40 +#define IS_PART(mtd) (mtd->read == part_read)
  41
  42  /*
  43   * MTD methods which simply translate the effective address and pass through
  44 @@ -308,6 +310,312 @@
  45         return 0;
  46  }
  47
  48 +static u_int32_t cur_offset = 0;
  49 +static int add_one_partition(struct mtd_info *master, const struct mtd_partition *part,
  50 +               int i, struct mtd_part **slp)
  51 +{
  52 +       struct mtd_part *slave;
  53 +
  54 +       /* allocate the partition structure */
  55 +       slave = kzalloc (sizeof(*slave), GFP_KERNEL);
  56 +       if (!slave) {
  57 +               printk ("memory allocation error while creating partitions for \"%s\"\n",
  58 +                       master->name);
  59 +               del_mtd_partitions(master);
  60 +               return -ENOMEM;
  61 +       }
  62 +       list_add(&slave->list, &mtd_partitions);
  63 +
  64 +       /* set up the MTD object for this partition */
  65 +       slave->mtd.type = master->type;
  66 +       slave->mtd.flags = master->flags & ~part->mask_flags;
  67 +       slave->mtd.size = part->size;
  68 +       slave->mtd.writesize = master->writesize;
  69 +       slave->mtd.oobsize = master->oobsize;
  70 +       slave->mtd.oobavail = master->oobavail;
  71 +       slave->mtd.subpage_sft = master->subpage_sft;
  72 +
  73 +       slave->mtd.name = part->name;
  74 +       slave->mtd.owner = master->owner;
  75 +
  76 +       slave->mtd.read = part_read;
  77 +       slave->mtd.write = part_write;
  78 +       slave->mtd.refresh_device = part->refresh_partition;
  79 +
  80 +       if(master->point && master->unpoint){
  81 +               slave->mtd.point = part_point;
  82 +               slave->mtd.unpoint = part_unpoint;
  83 +       }
  84 +
  85 +       if (master->read_oob)
  86 +               slave->mtd.read_oob = part_read_oob;
  87 +       if (master->write_oob)
  88 +               slave->mtd.write_oob = part_write_oob;
  89 +       if(master->read_user_prot_reg)
  90 +               slave->mtd.read_user_prot_reg = part_read_user_prot_reg;
  91 +       if(master->read_fact_prot_reg)
  92 +               slave->mtd.read_fact_prot_reg = part_read_fact_prot_reg;
  93 +       if(master->write_user_prot_reg)
  94 +               slave->mtd.write_user_prot_reg = part_write_user_prot_reg;
  95 +       if(master->lock_user_prot_reg)
  96 +               slave->mtd.lock_user_prot_reg = part_lock_user_prot_reg;
  97 +       if(master->get_user_prot_info)
  98 +               slave->mtd.get_user_prot_info = part_get_user_prot_info;
  99 +       if(master->get_fact_prot_info)
 100 +               slave->mtd.get_fact_prot_info = part_get_fact_prot_info;
 101 +       if (master->sync)
 102 +               slave->mtd.sync = part_sync;
 103 +       if (!i && master->suspend && master->resume) {
 104 +                       slave->mtd.suspend = part_suspend;
 105 +                       slave->mtd.resume = part_resume;
 106 +       }
 107 +       if (master->writev)
 108 +               slave->mtd.writev = part_writev;
 109 +       if (master->lock)
 110 +               slave->mtd.lock = part_lock;
 111 +       if (master->unlock)
 112 +               slave->mtd.unlock = part_unlock;
 113 +       if (master->block_isbad)
 114 +               slave->mtd.block_isbad = part_block_isbad;
 115 +       if (master->block_markbad)
 116 +               slave->mtd.block_markbad = part_block_markbad;
 117 +       slave->mtd.erase = part_erase;
 118 +       slave->master = master;
 119 +       slave->offset = part->offset;
 120 +       slave->index = i;
 121 +
 122 +       if (slave->offset == MTDPART_OFS_APPEND)
 123 +               slave->offset = cur_offset;
 124 +       if (slave->offset == MTDPART_OFS_NXTBLK) {
 125 +               slave->offset = cur_offset;
 126 +               if ((cur_offset % master->erasesize) != 0) {
 127 +                       /* Round up to next erasesize */
 128 +                       slave->offset = ((cur_offset / master->erasesize) + 1) * master->erasesize;
 129 +                       printk(KERN_NOTICE "Moving partition %d: "
 130 +                              "0x%08x -> 0x%08x\n", i,
 131 +                              cur_offset, slave->offset);
 132 +               }
 133 +       }
 134 +       if (slave->mtd.size == MTDPART_SIZ_FULL)
 135 +               slave->mtd.size = master->size - slave->offset;
 136 +       cur_offset = slave->offset + slave->mtd.size;
 137 +
 138 +       printk (KERN_NOTICE "0x%08x-0x%08x : \"%s\"\n", slave->offset,
 139 +               slave->offset + slave->mtd.size, slave->mtd.name);
 140 +
 141 +       /* let's do some sanity checks */
 142 +       if (slave->offset >= master->size) {
 143 +                       /* let's register it anyway to preserve ordering */
 144 +               slave->offset = 0;
 145 +               slave->mtd.size = 0;
 146 +               printk ("mtd: partition \"%s\" is out of reach -- disabled\n",
 147 +                       part->name);
 148 +       }
 149 +       if (slave->offset + slave->mtd.size > master->size) {
 150 +               slave->mtd.size = master->size - slave->offset;
 151 +               printk ("mtd: partition \"%s\" extends beyond the end of device \"%s\" -- size truncated to %#x\n",
 152 +                       part->name, master->name, slave->mtd.size);
 153 +       }
 154 +       if (master->numeraseregions>1) {
 155 +               /* Deal with variable erase size stuff */
 156 +               int i;
 157 +               struct mtd_erase_region_info *regions = master->eraseregions;
 158 +
 159 +               /* Find the first erase regions which is part of this partition. */
 160 +               for (i=0; i < master->numeraseregions && slave->offset >= regions[i].offset; i++)
 161 +                       ;
 162 +
 163 +               for (i--; i < master->numeraseregions && slave->offset + slave->mtd.size > regions[i].offset; i++) {
 164 +                       if (slave->mtd.erasesize < regions[i].erasesize) {
 165 +                               slave->mtd.erasesize = regions[i].erasesize;
 166 +                       }
 167 +               }
 168 +       } else {
 169 +               /* Single erase size */
 170 +               slave->mtd.erasesize = master->erasesize;
 171 +       }
 172 +
 173 +       if ((slave->mtd.flags & MTD_WRITEABLE) &&
 174 +           (slave->offset % slave->mtd.erasesize)) {
 175 +               /* Doesn't start on a boundary of major erase size */
 176 +               /* FIXME: Let it be writable if it is on a boundary of _minor_ erase size though */
 177 +               slave->mtd.flags &= ~MTD_WRITEABLE;
 178 +               printk ("mtd: partition \"%s\" doesn't start on an erase block boundary -- force read-only\n",
 179 +                       part->name);
 180 +       }
 181 +       if ((slave->mtd.flags & MTD_WRITEABLE) &&
 182 +           (slave->mtd.size % slave->mtd.erasesize)) {
 183 +               slave->mtd.flags &= ~MTD_WRITEABLE;
 184 +               printk ("mtd: partition \"%s\" doesn't end on an erase block -- force read-only\n",
 185 +                       part->name);
 186 +       }
 187 +
 188 +       slave->mtd.ecclayout = master->ecclayout;
 189 +       if (master->block_isbad) {
 190 +               uint32_t offs = 0;
 191 +
 192 +               while(offs < slave->mtd.size) {
 193 +                       if (master->block_isbad(master,
 194 +                                               offs + slave->offset))
 195 +                               slave->mtd.ecc_stats.badblocks++;
 196 +                       offs += slave->mtd.erasesize;
 197 +               }
 198 +       }
 199 +
 200 +       if(part->mtdp)
 201 +       {       /* store the object pointer (caller may or may not register it */
 202 +               *part->mtdp = &slave->mtd;
 203 +               slave->registered = 0;
 204 +       }
 205 +       else
 206 +       {
 207 +               /* register our partition */
 208 +               add_mtd_device(&slave->mtd);
 209 +               slave->registered = 1;
 210 +       }
 211 +
 212 +       if (slp)
 213 +               *slp = slave;
 214 +
 215 +       return 0;
 216 +}
 217 +
 218 +#ifdef CONFIG_MTD_ROOTFS_SPLIT
 219 +#define ROOTFS_SPLIT_NAME "rootfs_data"
 220 +#define ROOTFS_REMOVED_NAME "<removed>"
 221 +static int split_squashfs(struct mtd_info *master, int offset, int *split_offset)
 222 +{
 223 +       char buf[512];
 224 +       struct squashfs_super_block *sb = (struct squashfs_super_block *) buf;
 225 +       int len, ret;
 226 +
 227 +       ret = master->read(master, offset, sizeof(*sb), &len, buf);
 228 +       if (ret || (len != sizeof(*sb))) {
 229 +               printk(KERN_ALERT "split_squashfs: error occured while reading "
 230 +                       "from \"%s\"\n", master->name);
 231 +               return -EINVAL;
 232 +       }
 233 +
 234 +       if (*((u32 *) buf) != SQUASHFS_MAGIC) {
 235 +               printk(KERN_ALERT "split_squasfs: no squashfs found in \"%s\"\n",
 236 +                       master->name);
 237 +               *split_offset = 0;
 238 +               return 0;
 239 +       }
 240 +
 241 +       if (sb->bytes_used <= 0) {
 242 +               printk(KERN_ALERT "split_squashfs: squashfs is empty in \"%s\"\n",
 243 +                       master->name);
 244 +               *split_offset = 0;
 245 +               return 0;
 246 +       }
 247 +
 248 +       len = (u32) sb->bytes_used;
 249 +       len += (offset & 0x000fffff);
 250 +       len +=  (master->erasesize - 1);
 251 +       len &= ~(master->erasesize - 1);
 252 +       len -= (offset & 0x000fffff);
 253 +       *split_offset = offset + len;
 254 +
 255 +       return 0;
 256 +}
 257 +
 258 +static int split_rootfs_data(struct mtd_info *master, struct mtd_info *rpart, struct mtd_partition *part,
 259 +               int index)
 260 +{
 261 +       struct mtd_partition *dpart;
 262 +       struct mtd_part *slave = NULL;
 263 +       int split_offset = 0;
 264 +       int ret;
 265 +
 266 +       ret = split_squashfs(master, part->offset, &split_offset);
 267 +       if (ret)
 268 +               return ret;
 269 +
 270 +       if (split_offset <= 0)
 271 +               return 0;
 272 +
 273 +       dpart = kmalloc(sizeof(*part)+sizeof(ROOTFS_SPLIT_NAME)+1, GFP_KERNEL);
 274 +       if (dpart == NULL) {
 275 +               printk(KERN_INFO "split_squashfs: no memory for partition \"%s\"\n",
 276 +                       ROOTFS_SPLIT_NAME);
 277 +               return -ENOMEM;
 278 +       }
 279 +
 280 +       memcpy(dpart, part, sizeof(*part));
 281 +       dpart->name = (unsigned char *)&dpart[1];
 282 +       strcpy(dpart->name, ROOTFS_SPLIT_NAME);
 283 +
 284 +       dpart->size -= split_offset - dpart->offset;
 285 +       dpart->offset = split_offset;
 286 +
 287 +       if (dpart == NULL)
 288 +               return 1;
 289 +
 290 +       printk(KERN_INFO "mtd: partition \"%s\" created automatically, ofs=%X, len=%X \n",
 291 +               ROOTFS_SPLIT_NAME, dpart->offset, dpart->size);
 292 +
 293 +       ret = add_one_partition(master, dpart, index, &slave);
 294 +       if (ret)
 295 +               kfree(dpart);
 296 +       else if (slave)
 297 +               rpart->split = &slave->mtd;
 298 +
 299 +       return ret;
 300 +}
 301 +
 302 +static int refresh_rootfs_split(struct mtd_info *mtd)
 303 +{
 304 +       struct mtd_partition tpart;
 305 +       struct mtd_part *part;
 306 +       int index = 0;
 307 +       int offset, size;
 308 +       int ret;
 309 +
 310 +       part = PART(mtd);
 311 +
 312 +       /* check for the new squashfs offset first */
 313 +       ret = split_squashfs(part->master, part->offset, &offset);
 314 +       if (ret)
 315 +               return ret;
 316 +
 317 +       if ((offset > 0) && !mtd->split) {
 318 +               printk(KERN_INFO "%s: creating new split partition for \"%s\"\n", __func__, mtd->name);
 319 +               /* if we don't have a rootfs split partition, create a new one */
 320 +               tpart.name = mtd->name;
 321 +               tpart.size = mtd->size;
 322 +               tpart.offset = part->offset;
 323 +
 324 +               /* find the index of the last partition */
 325 +               if (!list_empty(&mtd_partitions))
 326 +                       index = list_first_entry(&mtd_partitions, struct mtd_part, list)->index + 1;
 327 +
 328 +               return split_rootfs_data(part->master, &part->mtd, &tpart, index);
 329 +       } else if ((offset > 0) && mtd->split) {
 330 +               /* update the offsets of the existing partition */
 331 +               size = mtd->size + part->offset - offset;
 332 +
 333 +               part = PART(mtd->split);
 334 +               part->offset = offset;
 335 +               part->mtd.size = size;
 336 +               printk(KERN_INFO "%s: %s partition \"" ROOTFS_SPLIT_NAME "\", offset: 0x%06x (0x%06x)\n",
 337 +                       __func__, (!strcmp(part->mtd.name, ROOTFS_SPLIT_NAME) ? "updating" : "creating"),
 338 +                       part->offset, part->mtd.size);
 339 +               strcpy(part->mtd.name, ROOTFS_SPLIT_NAME);
 340 +       } else if ((offset <= 0) && mtd->split) {
 341 +               printk(KERN_INFO "%s: removing partition \"%s\"\n", __func__, mtd->split->name);
 342 +
 343 +               /* mark existing partition as removed */
 344 +               part = PART(mtd->split);
 345 +               strcpy(part->mtd.name, ROOTFS_REMOVED_NAME);
 346 +               part->offset = 0;
 347 +               part->mtd.size = 0;
 348 +       }
 349 +
 350 +       return 0;
 351 +}
 352 +#endif /* CONFIG_MTD_ROOTFS_SPLIT */
 353 +
 354  /*
 355   * This function, given a master MTD object and a partition table, creates
 356   * and registers slave MTD objects which are bound to the master according to
 357 @@ -320,168 +628,31 @@
 358                        int nbparts)
 359  {
 360         struct mtd_part *slave;
 361 -       u_int32_t cur_offset = 0;
 362 -       int i;
 363 +       struct mtd_partition *part;
 364 +       int i, j, ret = 0;
 365
 366         printk (KERN_NOTICE "Creating %d MTD partitions on \"%s\":\n", nbparts, master->name);
 367
 368 -       for (i = 0; i < nbparts; i++) {
 369 -
 370 -               /* allocate the partition structure */
 371 -               slave = kzalloc (sizeof(*slave), GFP_KERNEL);
 372 -               if (!slave) {
 373 -                       printk ("memory allocation error while creating partitions for \"%s\"\n",
 374 -                               master->name);
 375 -                       del_mtd_partitions(master);
 376 -                       return -ENOMEM;
 377 -               }
 378 -               list_add(&slave->list, &mtd_partitions);
 379 -
 380 -               /* set up the MTD object for this partition */
 381 -               slave->mtd.type = master->type;
 382 -               slave->mtd.flags = master->flags & ~parts[i].mask_flags;
 383 -               slave->mtd.size = parts[i].size;
 384 -               slave->mtd.writesize = master->writesize;
 385 -               slave->mtd.oobsize = master->oobsize;
 386 -               slave->mtd.oobavail = master->oobavail;
 387 -               slave->mtd.subpage_sft = master->subpage_sft;
 388 -
 389 -               slave->mtd.name = parts[i].name;
 390 -               slave->mtd.owner = master->owner;
 391 -
 392 -               slave->mtd.read = part_read;
 393 -               slave->mtd.write = part_write;
 394 -
 395 -               if(master->point && master->unpoint){
 396 -                       slave->mtd.point = part_point;
 397 -                       slave->mtd.unpoint = part_unpoint;
 398 -               }
 399 -
 400 -               if (master->read_oob)
 401 -                       slave->mtd.read_oob = part_read_oob;
 402 -               if (master->write_oob)
 403 -                       slave->mtd.write_oob = part_write_oob;
 404 -               if(master->read_user_prot_reg)
 405 -                       slave->mtd.read_user_prot_reg = part_read_user_prot_reg;
 406 -               if(master->read_fact_prot_reg)
 407 -                       slave->mtd.read_fact_prot_reg = part_read_fact_prot_reg;
 408 -               if(master->write_user_prot_reg)
 409 -                       slave->mtd.write_user_prot_reg = part_write_user_prot_reg;
 410 -               if(master->lock_user_prot_reg)
 411 -                       slave->mtd.lock_user_prot_reg = part_lock_user_prot_reg;
 412 -               if(master->get_user_prot_info)
 413 -                       slave->mtd.get_user_prot_info = part_get_user_prot_info;
 414 -               if(master->get_fact_prot_info)
 415 -                       slave->mtd.get_fact_prot_info = part_get_fact_prot_info;
 416 -               if (master->sync)
 417 -                       slave->mtd.sync = part_sync;
 418 -               if (!i && master->suspend && master->resume) {
 419 -                               slave->mtd.suspend = part_suspend;
 420 -                               slave->mtd.resume = part_resume;
 421 -               }
 422 -               if (master->writev)
 423 -                       slave->mtd.writev = part_writev;
 424 -               if (master->lock)
 425 -                       slave->mtd.lock = part_lock;
 426 -               if (master->unlock)
 427 -                       slave->mtd.unlock = part_unlock;
 428 -               if (master->block_isbad)
 429 -                       slave->mtd.block_isbad = part_block_isbad;
 430 -               if (master->block_markbad)
 431 -                       slave->mtd.block_markbad = part_block_markbad;
 432 -               slave->mtd.erase = part_erase;
 433 -               slave->master = master;
 434 -               slave->offset = parts[i].offset;
 435 -               slave->index = i;
 436 -
 437 -               if (slave->offset == MTDPART_OFS_APPEND)
 438 -                       slave->offset = cur_offset;
 439 -               if (slave->offset == MTDPART_OFS_NXTBLK) {
 440 -                       slave->offset = cur_offset;
 441 -                       if ((cur_offset % master->erasesize) != 0) {
 442 -                               /* Round up to next erasesize */
 443 -                               slave->offset = ((cur_offset / master->erasesize) + 1) * master->erasesize;
 444 -                               printk(KERN_NOTICE "Moving partition %d: "
 445 -                                      "0x%08x -> 0x%08x\n", i,
 446 -                                      cur_offset, slave->offset);
 447 -                       }
 448 -               }
 449 -               if (slave->mtd.size == MTDPART_SIZ_FULL)
 450 -                       slave->mtd.size = master->size - slave->offset;
 451 -               cur_offset = slave->offset + slave->mtd.size;
 452 -
 453 -               printk (KERN_NOTICE "0x%08x-0x%08x : \"%s\"\n", slave->offset,
 454 -                       slave->offset + slave->mtd.size, slave->mtd.name);
 455 -
 456 -               /* let's do some sanity checks */
 457 -               if (slave->offset >= master->size) {
 458 -                               /* let's register it anyway to preserve ordering */
 459 -                       slave->offset = 0;
 460 -                       slave->mtd.size = 0;
 461 -                       printk ("mtd: partition \"%s\" is out of reach -- disabled\n",
 462 -                               parts[i].name);
 463 -               }
 464 -               if (slave->offset + slave->mtd.size > master->size) {
 465 -                       slave->mtd.size = master->size - slave->offset;
 466 -                       printk ("mtd: partition \"%s\" extends beyond the end of device \"%s\" -- size truncated to %#x\n",
 467 -                               parts[i].name, master->name, slave->mtd.size);
 468 -               }
 469 -               if (master->numeraseregions>1) {
 470 -                       /* Deal with variable erase size stuff */
 471 -                       int i;
 472 -                       struct mtd_erase_region_info *regions = master->eraseregions;
 473 -
 474 -                       /* Find the first erase regions which is part of this partition. */
 475 -                       for (i=0; i < master->numeraseregions && slave->offset >= regions[i].offset; i++)
 476 -                               ;
 477 -
 478 -                       for (i--; i < master->numeraseregions && slave->offset + slave->mtd.size > regions[i].offset; i++) {
 479 -                               if (slave->mtd.erasesize < regions[i].erasesize) {
 480 -                                       slave->mtd.erasesize = regions[i].erasesize;
 481 -                               }
 482 +       for (i = 0, j = 0; i < nbparts; i++) {
 483 +               part = (struct mtd_partition *) &parts[i];
 484 +               ret = add_one_partition(master, part, j, &slave);
 485 +               if (ret)
 486 +                       return ret;
 487 +               j++;
 488 +
 489 +               if (strcmp(part->name, "rootfs") == 0 && slave->registered) {
 490 +#ifdef CONFIG_MTD_ROOTFS_ROOT_DEV
 491 +                       if (ROOT_DEV == 0) {
 492 +                               printk(KERN_NOTICE "mtd: partition \"rootfs\" "
 493 +                                       "set to be root filesystem\n");
 494 +                               ROOT_DEV = MKDEV(MTD_BLOCK_MAJOR, slave->mtd.index);
 495                         }
 496 -               } else {
 497 -                       /* Single erase size */
 498 -                       slave->mtd.erasesize = master->erasesize;
 499 -               }
 500 -
 501 -               if ((slave->mtd.flags & MTD_WRITEABLE) &&
 502 -                   (slave->offset % slave->mtd.erasesize)) {
 503 -                       /* Doesn't start on a boundary of major erase size */
 504 -                       /* FIXME: Let it be writable if it is on a boundary of _minor_ erase size though */
 505 -                       slave->mtd.flags &= ~MTD_WRITEABLE;
 506 -                       printk ("mtd: partition \"%s\" doesn't start on an erase block boundary -- force read-only\n",
 507 -                               parts[i].name);
 508 -               }
 509 -               if ((slave->mtd.flags & MTD_WRITEABLE) &&
 510 -                   (slave->mtd.size % slave->mtd.erasesize)) {
 511 -                       slave->mtd.flags &= ~MTD_WRITEABLE;
 512 -                       printk ("mtd: partition \"%s\" doesn't end on an erase block -- force read-only\n",
 513 -                               parts[i].name);
 514 -               }
 515 -
 516 -               slave->mtd.ecclayout = master->ecclayout;
 517 -               if (master->block_isbad) {
 518 -                       uint32_t offs = 0;
 519 -
 520 -                       while(offs < slave->mtd.size) {
 521 -                               if (master->block_isbad(master,
 522 -                                                       offs + slave->offset))
 523 -                                       slave->mtd.ecc_stats.badblocks++;
 524 -                               offs += slave->mtd.erasesize;
 525 -                       }
 526 -               }
 527 -
 528 -               if(parts[i].mtdp)
 529 -               {       /* store the object pointer (caller may or may not register it */
 530 -                       *parts[i].mtdp = &slave->mtd;
 531 -                       slave->registered = 0;
 532 -               }
 533 -               else
 534 -               {
 535 -                       /* register our partition */
 536 -                       add_mtd_device(&slave->mtd);
 537 -                       slave->registered = 1;
 538 +#endif
 539 +#ifdef CONFIG_MTD_ROOTFS_SPLIT
 540 +                       ret = split_rootfs_data(master, &slave->mtd, part, j);
 541 +                       if (ret == 0)
 542 +                               j++;
 543 +#endif
 544                 }
 545         }
 546
 547 @@ -557,7 +728,33 @@
 548         return ret;
 549  }
 550
 551 +int refresh_mtd_partitions(struct mtd_info *mtd)
 552 +{
 553 +       int ret = 0;
 554 +
 555 +       if (IS_PART(mtd)) {
 556 +               struct mtd_part *part;
 557 +               struct mtd_info *master;
 558 +
 559 +               part = PART(mtd);
 560 +               master = part->master;
 561 +               if (master->refresh_device)
 562 +                       ret = master->refresh_device(master);
 563 +       }
 564 +
 565 +       if (!ret && mtd->refresh_device)
 566 +               ret = mtd->refresh_device(mtd);
 567 +
 568 +#ifdef CONFIG_MTD_ROOTFS_SPLIT
 569 +       if (!ret && IS_PART(mtd) && !strcmp(mtd->name, "rootfs"))
 570 +               refresh_rootfs_split(mtd);
 571 +#endif
 572 +
 573 +       return 0;
 574 +}
 575 +
 576  EXPORT_SYMBOL_GPL(parse_mtd_partitions);
 577 +EXPORT_SYMBOL_GPL(refresh_mtd_partitions);
 578  EXPORT_SYMBOL_GPL(register_mtd_parser);
 579  EXPORT_SYMBOL_GPL(deregister_mtd_parser);
 580
 581 Index: linux-2.6.22.1/drivers/mtd/devices/block2mtd.c
 582 ===================================================================
 583 --- linux-2.6.22.1.orig/drivers/mtd/devices/block2mtd.c 2007-08-19 23:30:49.794549917 +0200
 584 +++ linux-2.6.22.1/drivers/mtd/devices/block2mtd.c      2007-08-19 23:31:44.025640373 +0200
 585 @@ -34,6 +34,8 @@
 586         struct block_device *blkdev;
 587         struct mtd_info mtd;
 588         struct mutex write_mutex;
 589 +       rwlock_t bdev_mutex;
 590 +       char devname[0];
 591  };
 592
 593
 594 @@ -86,6 +88,12 @@
 595         size_t len = instr->len;
 596         int err;
 597
 598 +       read_lock(&dev->bdev_mutex);
 599 +       if (!dev->blkdev) {
 600 +               err = -EINVAL;
 601 +               goto done;
 602 +       }
 603 +
 604         instr->state = MTD_ERASING;
 605         mutex_lock(&dev->write_mutex);
 606         err = _block2mtd_erase(dev, from, len);
 607 @@ -98,6 +106,10 @@
 608
 609         instr->state = MTD_ERASE_DONE;
 610         mtd_erase_callback(instr);
 611 +
 612 +done:
 613 +       read_unlock(&dev->bdev_mutex);
 614 +
 615         return err;
 616  }
 617
 618 @@ -109,10 +121,14 @@
 619         struct page *page;
 620         int index = from >> PAGE_SHIFT;
 621         int offset = from & (PAGE_SIZE-1);
 622 -       int cpylen;
 623 +       int cpylen, err = 0;
 624 +
 625 +       read_lock(&dev->bdev_mutex);
 626 +       if (!dev->blkdev || (from > mtd->size)) {
 627 +               err = -EINVAL;
 628 +               goto done;
 629 +       }
 630
 631 -       if (from > mtd->size)
 632 -               return -EINVAL;
 633         if (from + len > mtd->size)
 634                 len = mtd->size - from;
 635
 636 @@ -127,10 +143,14 @@
 637                 len = len - cpylen;
 638
 639                 page = page_read(dev->blkdev->bd_inode->i_mapping, index);
 640 -               if (!page)
 641 -                       return -ENOMEM;
 642 -               if (IS_ERR(page))
 643 -                       return PTR_ERR(page);
 644 +               if (!page) {
 645 +                       err = -ENOMEM;
 646 +                       goto done;
 647 +               }
 648 +               if (IS_ERR(page)) {
 649 +                       err = PTR_ERR(page);
 650 +                       goto done;
 651 +               }
 652
 653                 memcpy(buf, page_address(page) + offset, cpylen);
 654                 page_cache_release(page);
 655 @@ -141,7 +161,10 @@
 656                 offset = 0;
 657                 index++;
 658         }
 659 -       return 0;
 660 +
 661 +done:
 662 +       read_unlock(&dev->bdev_mutex);
 663 +       return err;
 664  }
 665
 666
 667 @@ -193,12 +216,22 @@
 668                 size_t *retlen, const u_char *buf)
 669  {
 670         struct block2mtd_dev *dev = mtd->priv;
 671 -       int err;
 672 +       int err = 0;
 673 +
 674 +       read_lock(&dev->bdev_mutex);
 675 +       if (!dev->blkdev) {
 676 +               err = -EINVAL;
 677 +               goto done;
 678 +       }
 679
 680         if (!len)
 681 -               return 0;
 682 -       if (to >= mtd->size)
 683 -               return -ENOSPC;
 684 +               goto done;
 685 +
 686 +       if (to >= mtd->size) {
 687 +               err = -ENOSPC;
 688 +               goto done;
 689 +       }
 690 +
 691         if (to + len > mtd->size)
 692                 len = mtd->size - to;
 693
 694 @@ -207,6 +240,9 @@
 695         mutex_unlock(&dev->write_mutex);
 696         if (err > 0)
 697                 err = 0;
 698 +
 699 +done:
 700 +       read_unlock(&dev->bdev_mutex);
 701         return err;
 702  }
 703
 704 @@ -215,51 +251,29 @@
 705  static void block2mtd_sync(struct mtd_info *mtd)
 706  {
 707         struct block2mtd_dev *dev = mtd->priv;
 708 -       sync_blockdev(dev->blkdev);
 709 -       return;
 710 -}
 711 -
 712 -
 713 -static void block2mtd_free_device(struct block2mtd_dev *dev)
 714 -{
 715 -       if (!dev)
 716 -               return;
 717 -
 718 -       kfree(dev->mtd.name);
 719
 720 -       if (dev->blkdev) {
 721 -               invalidate_mapping_pages(dev->blkdev->bd_inode->i_mapping,
 722 -                                       0, -1);
 723 -               close_bdev_excl(dev->blkdev);
 724 -       }
 725 +       read_lock(&dev->bdev_mutex);
 726 +       if (dev->blkdev)
 727 +               sync_blockdev(dev->blkdev);
 728 +       read_unlock(&dev->bdev_mutex);
 729
 730 -       kfree(dev);
 731 +       return;
 732  }
 733
 734
 735 -/* FIXME: ensure that mtd->size % erase_size == 0 */
 736 -static struct block2mtd_dev *add_device(char *devname, int erase_size, char *mtdname)
 737 +static int _open_bdev(struct block2mtd_dev *dev)
 738  {
 739         struct block_device *bdev;
 740 -       struct block2mtd_dev *dev;
 741 -       struct mtd_partition *part;
 742 -
 743 -       if (!devname)
 744 -               return NULL;
 745 -
 746 -       dev = kzalloc(sizeof(struct block2mtd_dev), GFP_KERNEL);
 747 -       if (!dev)
 748 -               return NULL;
 749
 750         /* Get a handle on the device */
 751 -       bdev = open_bdev_excl(devname, O_RDWR, NULL);
 752 +       bdev = open_bdev_excl(dev->devname, O_RDWR, NULL);
 753  #ifndef MODULE
 754         if (IS_ERR(bdev)) {
 755
 756                 /* We might not have rootfs mounted at this point. Try
 757                    to resolve the device name by other means. */
 758
 759 -               dev_t devt = name_to_dev_t(devname);
 760 +               dev_t devt = name_to_dev_t(dev->devname);
 761                 if (devt) {
 762                         bdev = open_by_devnum(devt, FMODE_WRITE | FMODE_READ);
 763                 }
 764 @@ -267,17 +281,96 @@
 765  #endif
 766
 767         if (IS_ERR(bdev)) {
 768 -               ERROR("error: cannot open device %s", devname);
 769 -               goto devinit_err;
 770 +               ERROR("error: cannot open device %s", dev->devname);
 771 +               return 1;
 772         }
 773         dev->blkdev = bdev;
 774
 775         if (MAJOR(bdev->bd_dev) == MTD_BLOCK_MAJOR) {
 776                 ERROR("attempting to use an MTD device as a block device");
 777 -               goto devinit_err;
 778 +               return 1;
 779         }
 780
 781 +       return 0;
 782 +}
 783 +
 784 +static void _close_bdev(struct block2mtd_dev *dev)
 785 +{
 786 +       struct block_device *bdev;
 787 +
 788 +       if (!dev->blkdev)
 789 +               return;
 790 +
 791 +       bdev = dev->blkdev;
 792 +       invalidate_mapping_pages(dev->blkdev->bd_inode->i_mapping, 0, -1);
 793 +       close_bdev_excl(dev->blkdev);
 794 +       dev->blkdev = NULL;
 795 +}
 796 +
 797 +static void block2mtd_free_device(struct block2mtd_dev *dev)
 798 +{
 799 +       if (!dev)
 800 +               return;
 801 +
 802 +       kfree(dev->mtd.name);
 803 +       _close_bdev(dev);
 804 +       kfree(dev);
 805 +}
 806 +
 807 +
 808 +static int block2mtd_refresh(struct mtd_info *mtd)
 809 +{
 810 +       struct block2mtd_dev *dev = mtd->priv;
 811 +       struct block_device *bdev;
 812 +       dev_t devt;
 813 +       int err = 0;
 814 +
 815 +       /* no other mtd function can run at this point */
 816 +       write_lock(&dev->bdev_mutex);
 817 +
 818 +       /* get the device number for the whole disk */
 819 +       devt = MKDEV(MAJOR(dev->blkdev->bd_dev), 0);
 820 +
 821 +       /* close the old block device */
 822 +       _close_bdev(dev);
 823 +
 824 +       /* open the whole disk, issue a partition rescan, then */
 825 +       bdev = open_by_devnum(devt, FMODE_WRITE | FMODE_READ);
 826 +       if (!bdev || !bdev->bd_disk)
 827 +               err = -EINVAL;
 828 +       else {
 829 +               err = rescan_partitions(bdev->bd_disk, bdev);
 830 +       }
 831 +       if (bdev)
 832 +               close_bdev_excl(bdev);
 833 +
 834 +       /* try to open the partition block device again */
 835 +       _open_bdev(dev);
 836 +       write_unlock(&dev->bdev_mutex);
 837 +
 838 +       return err;
 839 +}
 840 +
 841 +/* FIXME: ensure that mtd->size % erase_size == 0 */
 842 +static struct block2mtd_dev *add_device(char *devname, int erase_size, char *mtdname)
 843 +{
 844 +       struct block2mtd_dev *dev;
 845 +       struct mtd_partition *part;
 846 +
 847 +       if (!devname)
 848 +               return NULL;
 849 +
 850 +       dev = kzalloc(sizeof(struct block2mtd_dev) + strlen(devname) + 1, GFP_KERNEL);
 851 +       if (!dev)
 852 +               return NULL;
 853 +
 854 +       strcpy(dev->devname, devname);
 855 +
 856 +       if (_open_bdev(dev))
 857 +               goto devinit_err;
 858 +
 859         mutex_init(&dev->write_mutex);
 860 +       rwlock_init(&dev->bdev_mutex);
 861
 862         /* Setup the MTD structure */
 863         /* make the name contain the block device in */
 864 @@ -304,6 +397,7 @@
 865         dev->mtd.read = block2mtd_read;
 866         dev->mtd.priv = dev;
 867         dev->mtd.owner = THIS_MODULE;
 868 +       dev->mtd.refresh_device = block2mtd_refresh;
 869
 870         part = kzalloc(sizeof(struct mtd_partition), GFP_KERNEL);
 871         part->name = dev->mtd.name;
 872 Index: linux-2.6.22.1/drivers/mtd/mtdchar.c
 873 ===================================================================
 874 --- linux-2.6.22.1.orig/drivers/mtd/mtdchar.c   2007-08-19 23:30:07.096116671 +0200
 875 +++ linux-2.6.22.1/drivers/mtd/mtdchar.c        2007-08-19 23:31:44.041641284 +0200
 876 @@ -16,6 +16,7 @@
 877
 878  #include <linux/mtd/mtd.h>
 879  #include <linux/mtd/compatmac.h>
 880 +#include <linux/mtd/partitions.h>
 881
 882  #include <asm/uaccess.h>
 883
 884 @@ -752,6 +753,13 @@
 885                 file->f_pos = 0;
 886                 break;
 887         }
 888 +#ifdef CONFIG_MTD_PARTITIONS
 889 +       case MTDREFRESH:
 890 +       {
 891 +               ret = refresh_mtd_partitions(mtd);
 892 +               break;
 893 +       }
 894 +#endif
 895
 896         default:
 897                 ret = -ENOTTY;
 898 Index: linux-2.6.22.1/include/linux/mtd/mtd.h
 899 ===================================================================
 900 --- linux-2.6.22.1.orig/include/linux/mtd/mtd.h 2007-08-19 23:30:07.100116893 +0200
 901 +++ linux-2.6.22.1/include/linux/mtd/mtd.h      2007-08-19 23:31:44.105644933 +0200
 902 @@ -98,6 +98,7 @@
 903         uint8_t         *oobbuf;
 904  };
 905
 906 +struct mtd_info;
 907  struct mtd_info {
 908         u_char type;
 909         u_int32_t flags;
 910 @@ -195,6 +196,9 @@
 911         struct module *owner;
 912         int usecount;
 913
 914 +       int (*refresh_device)(struct mtd_info *mtd);
 915 +       struct mtd_info *split;
 916 +
 917         /* If the driver is something smart, like UBI, it may need to maintain
 918          * its own reference counting. The below functions are only for driver.
 919          * The driver may register its callbacks. These callbacks are not
 920 Index: linux-2.6.22.1/include/linux/mtd/partitions.h
 921 ===================================================================
 922 --- linux-2.6.22.1.orig/include/linux/mtd/partitions.h  2007-08-19 23:30:07.112117591 +0200
 923 +++ linux-2.6.22.1/include/linux/mtd/partitions.h       2007-08-19 23:31:44.133646528 +0200
 924 @@ -36,6 +36,7 @@
 925   * erasesize aligned (e.g. use MTDPART_OFS_NEXTBLK).
 926   */
 927
 928 +struct mtd_partition;
 929  struct mtd_partition {
 930         char *name;                     /* identifier string */
 931         u_int32_t size;                 /* partition size */
 932 @@ -43,6 +44,7 @@
 933         u_int32_t mask_flags;           /* master MTD flags to mask out for this partition */
 934         struct nand_ecclayout *ecclayout;       /* out of band layout for this partition (NAND only)*/
 935         struct mtd_info **mtdp;         /* pointer to store the MTD object */
 936 +       int (*refresh_partition)(struct mtd_info *);
 937  };
 938
 939  #define MTDPART_OFS_NXTBLK     (-2)
 940 @@ -52,6 +54,7 @@
 941
 942  int add_mtd_partitions(struct mtd_info *, const struct mtd_partition *, int);
 943  int del_mtd_partitions(struct mtd_info *);
 944 +int refresh_mtd_partitions(struct mtd_info *);
 945
 946  /*
 947   * Functions dealing with the various ways of partitioning the space
 948 Index: linux-2.6.22.1/include/mtd/mtd-abi.h
 949 ===================================================================
 950 --- linux-2.6.22.1.orig/include/mtd/mtd-abi.h   2007-08-19 23:30:07.124118264 +0200
 951 +++ linux-2.6.22.1/include/mtd/mtd-abi.h        2007-08-19 23:31:44.157647897 +0200
 952 @@ -95,6 +95,7 @@
 953  #define ECCGETLAYOUT           _IOR('M', 17, struct nand_ecclayout)
 954  #define ECCGETSTATS            _IOR('M', 18, struct mtd_ecc_stats)
 955  #define MTDFILEMODE            _IO('M', 19)
 956 +#define MTDREFRESH             _IO('M', 23)
 957
 958  /*
 959   * Obsolete legacy interface. Keep it in order not to break userspace