diff options
Diffstat (limited to 'target/linux/generic-2.6')
| -rw-r--r-- | target/linux/generic-2.6/config-template | 1 | ||||
| -rw-r--r-- | target/linux/generic-2.6/patches/060-rootfs_split.patch | 414 |
2 files changed, 415 insertions, 0 deletions
diff --git a/target/linux/generic-2.6/config-template b/target/linux/generic-2.6/config-template index 6e653716f7..1f9c1c42e0 100644 --- a/target/linux/generic-2.6/config-template +++ b/target/linux/generic-2.6/config-template @@ -556,6 +556,7 @@ CONFIG_MODULE_UNLOAD=y # CONFIG_MODVERSIONS is not set CONFIG_MSDOS_FS=m CONFIG_MSDOS_PARTITION=y +CONFIG_MTD_SPLIT_ROOTFS=y # CONFIG_MYRI10GE is not set # CONFIG_NCP_FS is not set CONFIG_NET=y diff --git a/target/linux/generic-2.6/patches/060-rootfs_split.patch b/target/linux/generic-2.6/patches/060-rootfs_split.patch new file mode 100644 index 0000000000..e2e52f6def --- /dev/null +++ b/target/linux/generic-2.6/patches/060-rootfs_split.patch @@ -0,0 +1,414 @@ +diff -ur linux.old/drivers/mtd/Kconfig linux.dev/drivers/mtd/Kconfig +--- linux.old/drivers/mtd/Kconfig 2007-01-10 20:10:37.000000000 +0100 ++++ linux.dev/drivers/mtd/Kconfig 2007-02-19 23:00:53.739457000 +0100 +@@ -49,6 +49,11 @@ + devices. Partitioning on NFTL 'devices' is a different - that's the + 'normal' form of partitioning used on a block device. + ++config MTD_SPLIT_ROOTFS ++ bool "Automatically split rootfs partition for squashfs" ++ depends on MTD_PARTITIONS ++ default y ++ + config MTD_REDBOOT_PARTS + tristate "RedBoot partition table parsing" + depends on MTD_PARTITIONS +diff -ur linux.old/drivers/mtd/mtdpart.c linux.dev/drivers/mtd/mtdpart.c +--- linux.old/drivers/mtd/mtdpart.c 2007-01-10 20:10:37.000000000 +0100 ++++ linux.dev/drivers/mtd/mtdpart.c 2007-02-20 00:01:38.587355896 +0100 +@@ -20,6 +20,8 @@ + #include <linux/mtd/mtd.h> + #include <linux/mtd/partitions.h> + #include <linux/mtd/compatmac.h> ++#include <linux/squashfs_fs.h> ++#include <linux/root_dev.h> + + /* Our partition linked list */ + static LIST_HEAD(mtd_partitions); +@@ -303,6 +305,173 @@ + return 0; + } + ++static u_int32_t cur_offset = 0; ++static int add_mtd_partition(struct mtd_info *master, const struct mtd_partition *part, int i) ++{ ++ struct mtd_part *slave; ++ ++ /* allocate the partition structure */ ++ slave = kmalloc (sizeof(*slave), GFP_KERNEL); ++ if (!slave) { ++ printk ("memory allocation error while creating partitions for \"%s\"\n", ++ master->name); ++ del_mtd_partitions(master); ++ return -ENOMEM; ++ } ++ memset(slave, 0, sizeof(*slave)); ++ list_add(&slave->list, &mtd_partitions); ++ ++ /* set up the MTD object for this partition */ ++ slave->mtd.type = master->type; ++ slave->mtd.flags = master->flags & ~part->mask_flags; ++ slave->mtd.size = part->size; ++ slave->mtd.writesize = master->writesize; ++ slave->mtd.oobsize = master->oobsize; ++ slave->mtd.ecctype = master->ecctype; ++ slave->mtd.eccsize = master->eccsize; ++ ++ slave->mtd.name = part->name; ++ slave->mtd.bank_size = master->bank_size; ++ slave->mtd.owner = master->owner; ++ ++ slave->mtd.read = part_read; ++ slave->mtd.write = part_write; ++ ++ if(master->point && master->unpoint){ ++ slave->mtd.point = part_point; ++ slave->mtd.unpoint = part_unpoint; ++ } ++ ++ if (master->read_oob) ++ slave->mtd.read_oob = part_read_oob; ++ if (master->write_oob) ++ slave->mtd.write_oob = part_write_oob; ++ if(master->read_user_prot_reg) ++ slave->mtd.read_user_prot_reg = part_read_user_prot_reg; ++ if(master->read_fact_prot_reg) ++ slave->mtd.read_fact_prot_reg = part_read_fact_prot_reg; ++ if(master->write_user_prot_reg) ++ slave->mtd.write_user_prot_reg = part_write_user_prot_reg; ++ if(master->lock_user_prot_reg) ++ slave->mtd.lock_user_prot_reg = part_lock_user_prot_reg; ++ if(master->get_user_prot_info) ++ slave->mtd.get_user_prot_info = part_get_user_prot_info; ++ if(master->get_fact_prot_info) ++ slave->mtd.get_fact_prot_info = part_get_fact_prot_info; ++ if (master->sync) ++ slave->mtd.sync = part_sync; ++ if (!i && master->suspend && master->resume) { ++ slave->mtd.suspend = part_suspend; ++ slave->mtd.resume = part_resume; ++ } ++ if (master->writev) ++ slave->mtd.writev = part_writev; ++ if (master->lock) ++ slave->mtd.lock = part_lock; ++ if (master->unlock) ++ slave->mtd.unlock = part_unlock; ++ if (master->block_isbad) ++ slave->mtd.block_isbad = part_block_isbad; ++ if (master->block_markbad) ++ slave->mtd.block_markbad = part_block_markbad; ++ slave->mtd.erase = part_erase; ++ slave->master = master; ++ slave->offset = part->offset; ++ slave->index = i; ++ ++ if (slave->offset == MTDPART_OFS_APPEND) ++ slave->offset = cur_offset; ++ if (slave->offset == MTDPART_OFS_NXTBLK) { ++ slave->offset = cur_offset; ++ if ((cur_offset % master->erasesize) != 0) { ++ /* Round up to next erasesize */ ++ slave->offset = ((cur_offset / master->erasesize) + 1) * master->erasesize; ++ printk(KERN_NOTICE "Moving partition %d: " ++ "0x%08x -> 0x%08x\n", i, ++ cur_offset, slave->offset); ++ } ++ } ++ if (slave->mtd.size == MTDPART_SIZ_FULL) ++ slave->mtd.size = master->size - slave->offset; ++ cur_offset = slave->offset + slave->mtd.size; ++ ++ printk (KERN_NOTICE "0x%08x-0x%08x : \"%s\"\n", slave->offset, ++ slave->offset + slave->mtd.size, slave->mtd.name); ++ ++ /* let's do some sanity checks */ ++ if (slave->offset >= master->size) { ++ /* let's register it anyway to preserve ordering */ ++ slave->offset = 0; ++ slave->mtd.size = 0; ++ printk ("mtd: partition \"%s\" is out of reach -- disabled\n", ++ part->name); ++ } ++ if (slave->offset + slave->mtd.size > master->size) { ++ slave->mtd.size = master->size - slave->offset; ++ printk ("mtd: partition \"%s\" extends beyond the end of device \"%s\" -- size truncated to %#x\n", ++ part->name, master->name, slave->mtd.size); ++ } ++ if (master->numeraseregions>1) { ++ /* Deal with variable erase size stuff */ ++ int i; ++ struct mtd_erase_region_info *regions = master->eraseregions; ++ ++ /* Find the first erase regions which is part of this partition. */ ++ for (i=0; i < master->numeraseregions && slave->offset >= regions[i].offset; i++) ++ ; ++ ++ for (i--; i < master->numeraseregions && slave->offset + slave->mtd.size > regions[i].offset; i++) { ++ if (slave->mtd.erasesize < regions[i].erasesize) { ++ slave->mtd.erasesize = regions[i].erasesize; ++ } ++ } ++ } else { ++ /* Single erase size */ ++ slave->mtd.erasesize = master->erasesize; ++ } ++ ++ if ((slave->mtd.flags & MTD_WRITEABLE) && ++ (slave->offset % slave->mtd.erasesize)) { ++ /* Doesn't start on a boundary of major erase size */ ++ /* FIXME: Let it be writable if it is on a boundary of _minor_ erase size though */ ++ slave->mtd.flags &= ~MTD_WRITEABLE; ++ printk ("mtd: partition \"%s\" doesn't start on an erase block boundary -- force read-only\n", ++ part->name); ++ } ++ if ((slave->mtd.flags & MTD_WRITEABLE) && ++ (slave->mtd.size % slave->mtd.erasesize)) { ++ slave->mtd.flags &= ~MTD_WRITEABLE; ++ printk ("mtd: partition \"%s\" doesn't end on an erase block -- force read-only\n", ++ part->name); ++ } ++ ++ slave->mtd.ecclayout = master->ecclayout; ++ if (master->block_isbad) { ++ uint32_t offs = 0; ++ ++ while(offs < slave->mtd.size) { ++ if (master->block_isbad(master, ++ offs + slave->offset)) ++ slave->mtd.ecc_stats.badblocks++; ++ offs += slave->mtd.erasesize; ++ } ++ } ++ ++ if(part->mtdp) ++ { /* store the object pointer (caller may or may not register it */ ++ *part->mtdp = &slave->mtd; ++ slave->registered = 0; ++ } ++ else ++ { ++ /* register our partition */ ++ add_mtd_device(&slave->mtd); ++ slave->registered = 1; ++ } ++ ++ return 0; ++} ++ + /* + * This function, given a master MTD object and a partition table, creates + * and registers slave MTD objects which are bound to the master according to +@@ -314,171 +483,53 @@ + const struct mtd_partition *parts, + int nbparts) + { +- struct mtd_part *slave; +- u_int32_t cur_offset = 0; +- int i; ++ struct mtd_partition *part; ++ int i, ret = 0; + + printk (KERN_NOTICE "Creating %d MTD partitions on \"%s\":\n", nbparts, master->name); + + for (i = 0; i < nbparts; i++) { ++ part = (struct mtd_partition *) &parts[i]; ++ ret = add_mtd_partition(master, part, i); ++ if (ret) ++ return ret; ++ if (strcmp(part->name, "rootfs") == 0) { ++#ifdef CONFIG_MTD_SPLIT_ROOTFS ++ int len; ++ char buf[512]; ++ struct squashfs_super_block *sb = (struct squashfs_super_block *) buf; ++#define ROOTFS_SPLIT_NAME "rootfs_data" ++ if ((master->read(master, part->offset, sizeof(struct squashfs_super_block), &len, buf) == 0) && ++ (len == sizeof(struct squashfs_super_block)) && ++ (*((u32 *) buf) == SQUASHFS_MAGIC) && ++ (sb->bytes_used > 0)) { ++ ++ ++ part = kmalloc(sizeof(struct mtd_partition), GFP_KERNEL); ++ memcpy(part, &parts[i], sizeof(struct mtd_partition)); ++ ++ part->name = kmalloc(sizeof(ROOTFS_SPLIT_NAME) + 1, GFP_KERNEL); ++ strcpy(part->name, ROOTFS_SPLIT_NAME); ++ ++ len = (u32) sb->bytes_used; ++ len += (part->offset & 0x000fffff); ++ len += (master->erasesize - 1); ++ len &= ~(master->erasesize - 1); ++ len -= (part->offset & 0x000fffff); ++ part->offset += len; ++ part->size -= len; ++ ++ if (len + master->erasesize < part->size) ++ ret = add_mtd_partition(master, part, i + 1); ++ else ++ kfree(part->name); ++ if (ret) ++ return ret; + +- /* allocate the partition structure */ +- slave = kmalloc (sizeof(*slave), GFP_KERNEL); +- if (!slave) { +- printk ("memory allocation error while creating partitions for \"%s\"\n", +- master->name); +- del_mtd_partitions(master); +- return -ENOMEM; +- } +- memset(slave, 0, sizeof(*slave)); +- list_add(&slave->list, &mtd_partitions); +- +- /* set up the MTD object for this partition */ +- slave->mtd.type = master->type; +- slave->mtd.flags = master->flags & ~parts[i].mask_flags; +- slave->mtd.size = parts[i].size; +- slave->mtd.writesize = master->writesize; +- slave->mtd.oobsize = master->oobsize; +- slave->mtd.ecctype = master->ecctype; +- slave->mtd.eccsize = master->eccsize; +- +- slave->mtd.name = parts[i].name; +- slave->mtd.bank_size = master->bank_size; +- slave->mtd.owner = master->owner; +- +- slave->mtd.read = part_read; +- slave->mtd.write = part_write; +- +- if(master->point && master->unpoint){ +- slave->mtd.point = part_point; +- slave->mtd.unpoint = part_unpoint; +- } +- +- if (master->read_oob) +- slave->mtd.read_oob = part_read_oob; +- if (master->write_oob) +- slave->mtd.write_oob = part_write_oob; +- if(master->read_user_prot_reg) +- slave->mtd.read_user_prot_reg = part_read_user_prot_reg; +- if(master->read_fact_prot_reg) +- slave->mtd.read_fact_prot_reg = part_read_fact_prot_reg; +- if(master->write_user_prot_reg) +- slave->mtd.write_user_prot_reg = part_write_user_prot_reg; +- if(master->lock_user_prot_reg) +- slave->mtd.lock_user_prot_reg = part_lock_user_prot_reg; +- if(master->get_user_prot_info) +- slave->mtd.get_user_prot_info = part_get_user_prot_info; +- if(master->get_fact_prot_info) +- slave->mtd.get_fact_prot_info = part_get_fact_prot_info; +- if (master->sync) +- slave->mtd.sync = part_sync; +- if (!i && master->suspend && master->resume) { +- slave->mtd.suspend = part_suspend; +- slave->mtd.resume = part_resume; +- } +- if (master->writev) +- slave->mtd.writev = part_writev; +- if (master->lock) +- slave->mtd.lock = part_lock; +- if (master->unlock) +- slave->mtd.unlock = part_unlock; +- if (master->block_isbad) +- slave->mtd.block_isbad = part_block_isbad; +- if (master->block_markbad) +- slave->mtd.block_markbad = part_block_markbad; +- slave->mtd.erase = part_erase; +- slave->master = master; +- slave->offset = parts[i].offset; +- slave->index = i; +- +- if (slave->offset == MTDPART_OFS_APPEND) +- slave->offset = cur_offset; +- if (slave->offset == MTDPART_OFS_NXTBLK) { +- slave->offset = cur_offset; +- if ((cur_offset % master->erasesize) != 0) { +- /* Round up to next erasesize */ +- slave->offset = ((cur_offset / master->erasesize) + 1) * master->erasesize; +- printk(KERN_NOTICE "Moving partition %d: " +- "0x%08x -> 0x%08x\n", i, +- cur_offset, slave->offset); ++ kfree(part); + } +- } +- if (slave->mtd.size == MTDPART_SIZ_FULL) +- slave->mtd.size = master->size - slave->offset; +- cur_offset = slave->offset + slave->mtd.size; +- +- printk (KERN_NOTICE "0x%08x-0x%08x : \"%s\"\n", slave->offset, +- slave->offset + slave->mtd.size, slave->mtd.name); +- +- /* let's do some sanity checks */ +- if (slave->offset >= master->size) { +- /* let's register it anyway to preserve ordering */ +- slave->offset = 0; +- slave->mtd.size = 0; +- printk ("mtd: partition \"%s\" is out of reach -- disabled\n", +- parts[i].name); +- } +- if (slave->offset + slave->mtd.size > master->size) { +- slave->mtd.size = master->size - slave->offset; +- printk ("mtd: partition \"%s\" extends beyond the end of device \"%s\" -- size truncated to %#x\n", +- parts[i].name, master->name, slave->mtd.size); +- } +- if (master->numeraseregions>1) { +- /* Deal with variable erase size stuff */ +- int i; +- struct mtd_erase_region_info *regions = master->eraseregions; +- +- /* Find the first erase regions which is part of this partition. */ +- for (i=0; i < master->numeraseregions && slave->offset >= regions[i].offset; i++) +- ; +- +- for (i--; i < master->numeraseregions && slave->offset + slave->mtd.size > regions[i].offset; i++) { +- if (slave->mtd.erasesize < regions[i].erasesize) { +- slave->mtd.erasesize = regions[i].erasesize; +- } +- } +- } else { +- /* Single erase size */ +- slave->mtd.erasesize = master->erasesize; +- } +- +- if ((slave->mtd.flags & MTD_WRITEABLE) && +- (slave->offset % slave->mtd.erasesize)) { +- /* Doesn't start on a boundary of major erase size */ +- /* FIXME: Let it be writable if it is on a boundary of _minor_ erase size though */ +- slave->mtd.flags &= ~MTD_WRITEABLE; +- printk ("mtd: partition \"%s\" doesn't start on an erase block boundary -- force read-only\n", +- parts[i].name); +- } +- if ((slave->mtd.flags & MTD_WRITEABLE) && +- (slave->mtd.size % slave->mtd.erasesize)) { +- slave->mtd.flags &= ~MTD_WRITEABLE; +- printk ("mtd: partition \"%s\" doesn't end on an erase block -- force read-only\n", +- parts[i].name); +- } +- +- slave->mtd.ecclayout = master->ecclayout; +- if (master->block_isbad) { +- uint32_t offs = 0; +- +- while(offs < slave->mtd.size) { +- if (master->block_isbad(master, +- offs + slave->offset)) +- slave->mtd.ecc_stats.badblocks++; +- offs += slave->mtd.erasesize; +- } +- } +- +- if(parts[i].mtdp) +- { /* store the object pointer (caller may or may not register it */ +- *parts[i].mtdp = &slave->mtd; +- slave->registered = 0; +- } +- else +- { +- /* register our partition */ +- add_mtd_device(&slave->mtd); +- slave->registered = 1; ++#endif /* CONFIG_MTD_SPLIT_ROOTFS */ ++ ROOT_DEV = MKDEV(MTD_BLOCK_MAJOR, i); + } + } + |