Patchwork [U-Boot] Subject: [PATCH 1/2] ext4fs ls load support

login
register
mail settings
Submitter uma.shankar@samsung.com
Date Dec. 12, 2011, 10:45 a.m.
Message ID <8DCC78758C8A458F900F9F5885BA589A@sisodomain.com>
Download mbox | patch
Permalink /patch/130694/
State Changes Requested
Headers show

Comments

uma.shankar@samsung.com - Dec. 12, 2011, 10:45 a.m.
From: Uma Shankar <uma.shankar@samsung.com>
Date: Mon, 12 Dec 2011 12:01:22 +0530
Subject: [PATCH 1/2] ext4fs ls load support

Signed-off-by: Uma Shankar <uma.shankar@samsung.com>, Manjunatha C Achar 
<a.manjunatha@samsung.com>
Signed-off-by: Iqbal Shareef <iqbal.ams@samsung.com>
Signed-off-by: Hakgoo Lee <goodguy.lee@samsung.com>
---
 Makefile              |    2 +-
 common/Makefile       |    1 +
 common/cmd_ext4.c     |  255 ++++++++++++++++++++++
 fs/Makefile           |    1 +
 fs/ext2/ext2fs.c      |  303 +--------------------------
 fs/ext4/Makefile      |   51 +++++
 fs/ext4/ext4_common.c |  572 
+++++++++++++++++++++++++++++++++++++++++++++++++
 fs/ext4/ext4_common.h |   44 ++++
 fs/ext4/ext4fs.c      |  215 ++++++++++++++++++
 include/ext2fs.h      |  177 +++++++++++++++-
 include/ext4fs.h      |  164 ++++++++++++++
 11 files changed, 1478 insertions(+), 307 deletions(-)
 create mode 100644 common/cmd_ext4.c
 create mode 100644 fs/ext4/Makefile
 create mode 100644 fs/ext4/ext4_common.c
 create mode 100644 fs/ext4/ext4_common.h
 create mode 100644 fs/ext4/ext4fs.c
 create mode 100644 include/ext4fs.h

+#endif
Graeme Russ - Dec. 12, 2011, 12:12 p.m.
Hi Uma,

On 12/12/11 21:45, uma.shankar@samsung.com wrote:
> From: Uma Shankar <uma.shankar@samsung.com>
> Date: Mon, 12 Dec 2011 12:01:22 +0530
> Subject: [PATCH 1/2] ext4fs ls load support
> 
> Signed-off-by: Uma Shankar <uma.shankar@samsung.com>, Manjunatha C Achar
> <a.manjunatha@samsung.com>

I think all SoBs belong on their own line

> Signed-off-by: Iqbal Shareef <iqbal.ams@samsung.com>
> Signed-off-by: Hakgoo Lee <goodguy.lee@samsung.com>
> ---
> Makefile              |    2 +-
> common/Makefile       |    1 +
> common/cmd_ext4.c     |  255 ++++++++++++++++++++++
> fs/Makefile           |    1 +
> fs/ext2/ext2fs.c      |  303 +--------------------------
> fs/ext4/Makefile      |   51 +++++
> fs/ext4/ext4_common.c |  572 +++++++++++++++++++++++++++++++++++++++++++++++++
> fs/ext4/ext4_common.h |   44 ++++
> fs/ext4/ext4fs.c      |  215 ++++++++++++++++++
> include/ext2fs.h      |  177 +++++++++++++++-
> include/ext4fs.h      |  164 ++++++++++++++
> 11 files changed, 1478 insertions(+), 307 deletions(-)
> create mode 100644 common/cmd_ext4.c
> create mode 100644 fs/ext4/Makefile
> create mode 100644 fs/ext4/ext4_common.c
> create mode 100644 fs/ext4/ext4_common.h
> create mode 100644 fs/ext4/ext4fs.c
> create mode 100644 include/ext4fs.h
> 
> diff --git a/Makefile b/Makefile
> index fb658f4..5f29812 100644
> --- a/Makefile
> +++ b/Makefile
> @@ -235,7 +235,7 @@ LIBS += dts/libdts.o
> endif
> LIBS += arch/$(ARCH)/lib/lib$(ARCH).o
> LIBS += fs/cramfs/libcramfs.o fs/fat/libfat.o fs/fdos/libfdos.o
> fs/jffs2/libjffs2.o \
> - fs/reiserfs/libreiserfs.o fs/ext2/libext2fs.o fs/yaffs2/libyaffs2.o \
> + fs/reiserfs/libreiserfs.o fs/ext2/libext2fs.o fs/ext4/libext4fs.o
> fs/yaffs2/libyaffs2.o \
>  fs/ubifs/libubifs.o
> LIBS += net/libnet.o
> LIBS += disk/libdisk.o
> diff --git a/common/Makefile b/common/Makefile
> index 1b672ad..d7fd4a8 100644
> --- a/common/Makefile
> +++ b/common/Makefile
> @@ -90,6 +90,7 @@ COBJS-$(CONFIG_CMD_EEPROM) += cmd_eeprom.o
> COBJS-$(CONFIG_CMD_ELF) += cmd_elf.o
> COBJS-$(CONFIG_SYS_HUSH_PARSER) += cmd_exit.o
> COBJS-$(CONFIG_CMD_EXT2) += cmd_ext2.o
> +COBJS-$(CONFIG_CMD_EXT4) += cmd_ext4.o
> COBJS-$(CONFIG_CMD_FAT) += cmd_fat.o
> COBJS-$(CONFIG_CMD_FDC)$(CONFIG_CMD_FDOS) += cmd_fdc.o
> COBJS-$(CONFIG_OF_LIBFDT) += cmd_fdt.o fdt_support.o
> diff --git a/common/cmd_ext4.c b/common/cmd_ext4.c
> new file mode 100644
> index 0000000..b223443
> --- /dev/null
> +++ b/common/cmd_ext4.c
> @@ -0,0 +1,255 @@
> +/*
> + * (C) Copyright 2011 Samsung Electronics
> + * EXT4 filesystem implementation in Uboot by
> + * Uma Shankar <uma.shankar@samsung.com>
> + * Manjunatha C Achar <a.manjunatha@samsung.com>
> + *
> + * This program is free software; you can redistribute it and/or
> + * modify it under the terms of the GNU General Public License as
> + * published by the Free Software Foundation; either version 2 of
> + * the License, or (at your option) any later version.
> + *
> + * This program is distributed in the hope that it will be useful,
> + * but WITHOUT ANY WARRANTY; without even the implied warranty of
> + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
> + * GNU General Public License for more details.
> + *
> + * You should have received a copy of the GNU General Public License
> + * along with this program; if not, write to the Free Software
> + * Foundation, Inc., 59 Temple Place, Suite 330, Boston,
> + * MA 02111-1307 USA
> + *
> + */
> +
> +/*
> + * Ext4fs support
> + * made from existing cmd_ext2.c file of Uboot
> + */
> +#include <common.h>
> +#include <part.h>
> +#include <config.h>
> +#include <command.h>
> +#include <image.h>
> +#include <linux/ctype.h>
> +#include <asm/byteorder.h>
> +#include <ext2fs.h>
> +#include <ext4fs.h>
> +#include <linux/stat.h>
> +#include "../disk/part_dos.h"

Don't use relative include paths

> +#include <malloc.h>
> +
> +#if defined(CONFIG_CMD_USB) && defined(CONFIG_USB_STORAGE)
> +#include <usb.h>
> +#endif
> +
> +#if !defined(CONFIG_DOS_PARTITION) && !defined(CONFIG_EFI_PARTITION)
> +#error DOS or EFI partition support must be selected
> +#endif
> +
> +uint64_t total_sector;
> +uint64_t part_offset;
> +static uint64_t part_size;
> +static uint16_t cur_part = 1;
> +
> +#define DOS_PART_MAGIC_OFFSET  0x1fe
> +#define DOS_FS_TYPE_OFFSET  0x36
> +#define DOS_FS32_TYPE_OFFSET  0x52
> +
> +int do_ext4_load(cmd_tbl_t *cmdtp, int flag, int argc, char *const argv[])
> +{
> + char *filename = NULL;

Wrong indent style - use tabs

> + char *ep;
> + int dev, part = 1;
> + ulong addr = 0, part_length;

I've never been a fan of multiple declarations on the same line (especially
if some are assigned a value and some not) - I'll defer to others for an
'official' position on this

> + int filelen;
> + disk_partition_t info;
> + ExtFileSystem *fs;

No camel case

> + char buf[12];
> + unsigned long count;
> + char *addr_str;
> +
> + switch (argc) {
> + case 3:
> +  addr_str = getenv("loadaddr");
> +  if (addr_str != NULL)
> +   addr = strict_strtoul(addr_str, NULL, 16);
> +  else
> +   addr = CONFIG_SYS_LOAD_ADDR;
> +
> +  filename = getenv("bootfile");
> +  count = 0;
> +  break;
> + case 4:
> +  addr = strict_strtoul(argv[3], NULL, 16);
> +  filename = getenv("bootfile");
> +  count = 0;
> +  break;
> + case 5:
> +  addr = strict_strtoul(argv[3], NULL, 16);
> +  filename = argv[4];
> +  count = 0;
> +  break;
> + case 6:
> +  addr = strict_strtoul(argv[3], NULL, 16);
> +  filename = argv[4];
> +  count = strict_strtoul(argv[5], NULL, 16);
> +  break;
> +
> + default:
> +  return cmd_usage(cmdtp);
> + }
> +
> + if (!filename) {
> +  puts("** No boot file defined **\n");

Nice to see you used puts() instead of printf() - One day we'll tidy this
up globally :)

> +  return 1;
> + }
> +
> + dev = (int)strict_strtoul(argv[2], &ep, 16);
> + ext4_dev_desc = get_dev(argv[1], dev);
> + if (ext4_dev_desc == NULL) {
> +  printf("** Block device %s %d not supported\n", argv[1], dev);
> +  return 1;
> + }
> + if (init_fs(ext4_dev_desc))
> +  return 1;
> +
> + fs = get_fs();
> + if (*ep) {
> +  if (*ep != ':') {
> +   puts("** Invalid boot device, use `dev[:part]' **\n");
> +   return 1;
> +  }
> +  part = (int)strict_strtoul(++ep, NULL, 16);
> + }
> +
> + if (part != 0) {
> +  if (get_partition_info(fs->dev_desc, part, &info)) {
> +   printf("** Bad partition %d **\n", part);
> +   return 1;
> +  }
> +
> +  if (strncmp((char *)info.type, BOOT_PART_TYPE,
> +       sizeof(info.type)) != 0) {
> +   printf("** Invalid partition type \"%.32s\""
> +          " (expect \"" BOOT_PART_TYPE "\")\n", info.type);
> +   return 1;
> +  }
> +  printf("Loading file \"%s\" "
> +         "from %s device %d:%d (%.32s)\n",
> +         filename, argv[1], dev, part, info.name);
> + } else {
> +  printf("Loading file \"%s\" from %s device %d\n",
> +         filename, argv[1], dev);
> + }
> +
> + part_length = ext2fs_set_blk_dev(fs->dev_desc, part);
> + if (part_length == 0) {
> +  printf("**Bad partition - %s %d:%d **\n", argv[1], dev, part);
> +  ext4fs_close();
> +  return 1;
> + }
> +
> + if (!ext4fs_mount(part_length)) {
> +  printf("** Bad ext2 partition or disk - %s %d:%d **\n",
> +         argv[1], dev, part);
> +  ext4fs_close();
> +  return 1;
> + }
> +
> + filelen = ext4fs_open(filename);
> + if (filelen < 0) {
> +  printf("** File not found %s\n", filename);
> +  ext4fs_close();
> +  return 1;
> + }
> + if ((count < filelen) && (count != 0))
> +  filelen = count;
> +
> + if (ext4fs_read((char *)addr, filelen) != filelen) {
> +  printf("** Unable to read \"%s\" from %s %d:%d **\n",
> +         filename, argv[1], dev, part);
> +  ext4fs_close();
> +  return 1;
> + }
> +
> + ext4fs_close();
> + deinit_fs(fs->dev_desc);
> + /* Loading ok, update default load address */
> + load_addr = addr;
> +
> + printf("%d bytes read\n", filelen);
> + sprintf(buf, "%X", filelen);
> + setenv("filesize", buf);
> +
> + return 0;
> +}
> +
> +int do_ext4_ls(cmd_tbl_t *cmdtp, int flag, int argc, char *const argv[])
> +{
> + char *filename = "/";
> + int dev = 0;
> + int part = 1;
> + char *ep;
> + ExtFileSystem *fs;
> + int part_length;
> +
> + if (argc < 3)
> +  return cmd_usage(cmdtp);
> +
> + dev = (int)strict_strtoul(argv[2], &ep, 16);
> + ext4_dev_desc = get_dev(argv[1], dev);
> +
> + if (ext4_dev_desc == NULL) {
> +  printf("\n** Block device %s %d not supported\n", argv[1], dev);
> +  return 1;
> + }
> +
> + if (init_fs(ext4_dev_desc))
> +  return 1;
> +
> + fs = get_fs();
> + if (*ep) {
> +  if (*ep != ':') {
> +   puts("\n** Invalid boot device, use `dev[:part]' **\n");
> +   return 1;
> +  }
> +  part = (int)strict_strtoul(++ep, NULL, 16);
> + }
> +
> + if (argc == 4)
> +  filename = argv[3];
> +
> + part_length = ext2fs_set_blk_dev(fs->dev_desc, part);
> + if (part_length == 0) {
> +  printf("** Bad partition - %s %d:%d **\n", argv[1], dev, part);
> +  ext4fs_close();
> +  return 1;
> + }
> +
> + if (!ext4fs_mount(part_length)) {
> +  printf("** Bad ext2 partition or disk - %s %d:%d **\n",
> +         argv[1], dev, part);
> +  ext4fs_close();
> +  return 1;
> + }
> + if (ext4fs_ls(filename)) {
> +  printf("** Error ext2fs_ls() **\n");
> +  ext4fs_close();
> +  return 1;
> + };
> +
> + ext4fs_close();
> + deinit_fs(fs->dev_desc);
> + return 0;
> +}
> +
> +U_BOOT_CMD(ext4ls, 4, 1, do_ext4_ls,
> +    "list files in a directory (default /)",
> +    "<interface> <dev[:part]> [directory]\n"
> +    "   - list files from 'dev' on 'interface' in a 'directory'");
> +
> +U_BOOT_CMD(ext4load, 6, 0, do_ext4_load,
> +    "load binary file from a Ext2 filesystem",
> +    "<interface> <dev[:part]> [addr] [filename] [bytes]\n"
> +    "   - load binary file 'filename' from 'dev' on 'interface'\n"
> +    "   to address 'addr' from ext2 filesystem");
> diff --git a/fs/Makefile b/fs/Makefile
> index 22aad12..27330d4 100644
> --- a/fs/Makefile
> +++ b/fs/Makefile
> @@ -24,6 +24,7 @@
> 
> subdirs-$(CONFIG_CMD_CRAMFS) := cramfs
> subdirs-$(CONFIG_CMD_EXT2) += ext2
> +subdirs-$(CONFIG_CMD_EXT4) += ext4
> subdirs-$(CONFIG_CMD_FAT) += fat
> subdirs-$(CONFIG_CMD_FDOS) += fdos
> subdirs-$(CONFIG_CMD_JFFS2) += jffs2
> diff --git a/fs/ext2/ext2fs.c b/fs/ext2/ext2fs.c
> index e119e13..058b650 100644
> --- a/fs/ext2/ext2fs.c
> +++ b/fs/ext2/ext2fs.c
> @@ -25,150 +25,10 @@
> 
> #include <common.h>
> #include <ext2fs.h>
> +#include <ext4fs.h>

Hmm, seems odd to include an ext4fs include in ext2fs - I understand what
you are doing, but should there be an extfs_common.h which holds the common
defines?

> #include <malloc.h>
> #include <asm/byteorder.h>
> 
> -extern int ext2fs_devread (int sector, int byte_offset, int byte_len,
> -      char *buf);
> -
> -/* Magic value used to identify an ext2 filesystem.  */
> -#define EXT2_MAGIC  0xEF53
> -/* Amount of indirect blocks in an inode.  */
> -#define INDIRECT_BLOCKS  12
> -/* Maximum lenght of a pathname.  */
> -#define EXT2_PATH_MAX  4096
> -/* Maximum nesting of symlinks, used to prevent a loop.  */
> -#define EXT2_MAX_SYMLINKCNT 8
> -
> -/* Filetype used in directory entry.  */
> -#define FILETYPE_UNKNOWN 0
> -#define FILETYPE_REG  1
> -#define FILETYPE_DIRECTORY 2
> -#define FILETYPE_SYMLINK 7
> -
> -/* Filetype information as used in inodes.  */
> -#define FILETYPE_INO_MASK 0170000
> -#define FILETYPE_INO_REG 0100000
> -#define FILETYPE_INO_DIRECTORY 0040000
> -#define FILETYPE_INO_SYMLINK 0120000
> -
> -/* Bits used as offset in sector */
> -#define DISK_SECTOR_BITS        9
> -
> -/* Log2 size of ext2 block in 512 blocks.  */
> -#define LOG2_EXT2_BLOCK_SIZE(data) (__le32_to_cpu
> (data->sblock.log2_block_size) + 1)
> -
> -/* Log2 size of ext2 block in bytes.  */
> -#define LOG2_BLOCK_SIZE(data)    (__le32_to_cpu
> (data->sblock.log2_block_size) + 10)
> -
> -/* The size of an ext2 block in bytes.  */
> -#define EXT2_BLOCK_SIZE(data)    (1 << LOG2_BLOCK_SIZE(data))
> -
> -/* The ext2 superblock.  */
> -struct ext2_sblock {
> - uint32_t total_inodes;
> - uint32_t total_blocks;
> - uint32_t reserved_blocks;
> - uint32_t free_blocks;
> - uint32_t free_inodes;
> - uint32_t first_data_block;
> - uint32_t log2_block_size;
> - uint32_t log2_fragment_size;
> - uint32_t blocks_per_group;
> - uint32_t fragments_per_group;
> - uint32_t inodes_per_group;
> - uint32_t mtime;
> - uint32_t utime;
> - uint16_t mnt_count;
> - uint16_t max_mnt_count;
> - uint16_t magic;
> - uint16_t fs_state;
> - uint16_t error_handling;
> - uint16_t minor_revision_level;
> - uint32_t lastcheck;
> - uint32_t checkinterval;
> - uint32_t creator_os;
> - uint32_t revision_level;
> - uint16_t uid_reserved;
> - uint16_t gid_reserved;
> - uint32_t first_inode;
> - uint16_t inode_size;
> - uint16_t block_group_number;
> - uint32_t feature_compatibility;
> - uint32_t feature_incompat;
> - uint32_t feature_ro_compat;
> - uint32_t unique_id[4];
> - char volume_name[16];
> - char last_mounted_on[64];
> - uint32_t compression_info;
> -};
> -
> -/* The ext2 blockgroup.  */
> -struct ext2_block_group {
> - uint32_t block_id;
> - uint32_t inode_id;
> - uint32_t inode_table_id;
> - uint16_t free_blocks;
> - uint16_t free_inodes;
> - uint16_t used_dir_cnt;
> - uint32_t reserved[3];
> -};
> -
> -/* The ext2 inode.  */
> -struct ext2_inode {
> - uint16_t mode;
> - uint16_t uid;
> - uint32_t size;
> - uint32_t atime;
> - uint32_t ctime;
> - uint32_t mtime;
> - uint32_t dtime;
> - uint16_t gid;
> - uint16_t nlinks;
> - uint32_t blockcnt; /* Blocks of 512 bytes!! */
> - uint32_t flags;
> - uint32_t osd1;
> - union {
> -  struct datablocks {
> -   uint32_t dir_blocks[INDIRECT_BLOCKS];
> -   uint32_t indir_block;
> -   uint32_t double_indir_block;
> -   uint32_t tripple_indir_block;
> -  } blocks;
> -  char symlink[60];
> - } b;
> - uint32_t version;
> - uint32_t acl;
> - uint32_t dir_acl;
> - uint32_t fragment_addr;
> - uint32_t osd2[3];
> -};
> -
> -/* The header of an ext2 directory entry.  */
> -struct ext2_dirent {
> - uint32_t inode;
> - uint16_t direntlen;
> - uint8_t namelen;
> - uint8_t filetype;
> -};
> -
> -struct ext2fs_node {
> - struct ext2_data *data;
> - struct ext2_inode inode;
> - int ino;
> - int inode_read;
> -};
> -
> -/* Information about a "mounted" ext2 filesystem.  */
> -struct ext2_data {
> - struct ext2_sblock sblock;
> - struct ext2_inode *inode;
> - struct ext2fs_node diropen;
> -};
> -
> -
> -typedef struct ext2fs_node *ext2fs_node_t;
> -
> struct ext2_data *ext2fs_root = NULL;
> ext2fs_node_t ext2fs_file = NULL;
> int symlinknest = 0;
> @@ -180,7 +40,6 @@ int indir2_size = 0;
> int indir2_blkno = -1;
> static unsigned int inode_size;
> 
> -
> static int ext2fs_blockgroup
>  (struct ext2_data *data, int group, struct ext2_block_group *blkgrp) {
>  unsigned int blkno;
> @@ -198,10 +57,8 @@ static int ext2fs_blockgroup
> #endif
>  return (ext2fs_devread (blkno << LOG2_EXT2_BLOCK_SIZE(data),
>   blkoff, sizeof(struct ext2_block_group), (char *)blkgrp));
> -
> }
> 
> -
> static int ext2fs_read_inode
>  (struct ext2_data *data, int ino, struct ext2_inode *inode) {
>  struct ext2_block_group blkgrp;
> @@ -242,153 +99,12 @@ static int ext2fs_read_inode
>  return (1);
> }
> 
> -
> void ext2fs_free_node (ext2fs_node_t node, ext2fs_node_t currroot) {
>  if ((node != &ext2fs_root->diropen) && (node != currroot)) {
>   free (node);
>  }
> }
> 
> -
> -static int ext2fs_read_block (ext2fs_node_t node, int fileblock) {
> - struct ext2_data *data = node->data;
> - struct ext2_inode *inode = &node->inode;
> - int blknr;
> - int blksz = EXT2_BLOCK_SIZE (data);
> - int log2_blksz = LOG2_EXT2_BLOCK_SIZE (data);
> - int status;
> -
> - /* Direct blocks.  */
> - if (fileblock < INDIRECT_BLOCKS) {
> -  blknr = __le32_to_cpu (inode->b.blocks.dir_blocks[fileblock]);
> - }
> - /* Indirect.  */
> - else if (fileblock < (INDIRECT_BLOCKS + (blksz / 4))) {
> -  if (indir1_block == NULL) {
> -   indir1_block = (uint32_t *) malloc (blksz);
> -   if (indir1_block == NULL) {
> -    printf ("** ext2fs read block (indir 1) malloc failed. **\n");
> -    return (-1);
> -   }
> -   indir1_size = blksz;
> -   indir1_blkno = -1;
> -  }
> -  if (blksz != indir1_size) {
> -   free (indir1_block);
> -   indir1_block = NULL;
> -   indir1_size = 0;
> -   indir1_blkno = -1;
> -   indir1_block = (uint32_t *) malloc (blksz);
> -   if (indir1_block == NULL) {
> -    printf ("** ext2fs read block (indir 1) malloc failed. **\n");
> -    return (-1);
> -   }
> -   indir1_size = blksz;
> -  }
> -  if ((__le32_to_cpu (inode->b.blocks.indir_block) <<
> -       log2_blksz) != indir1_blkno) {
> -   status = ext2fs_devread (__le32_to_cpu(inode->b.blocks.indir_block) <<
> log2_blksz,
> -       0, blksz,
> -       (char *) indir1_block);
> -   if (status == 0) {
> -    printf ("** ext2fs read block (indir 1) failed. **\n");
> -    return (0);
> -   }
> -   indir1_blkno =
> -    __le32_to_cpu (inode->b.blocks.
> -            indir_block) << log2_blksz;
> -  }
> -  blknr = __le32_to_cpu (indir1_block
> -           [fileblock - INDIRECT_BLOCKS]);
> - }
> - /* Double indirect.  */
> - else if (fileblock <
> -   (INDIRECT_BLOCKS + (blksz / 4 * (blksz / 4 + 1)))) {
> -  unsigned int perblock = blksz / 4;
> -  unsigned int rblock = fileblock - (INDIRECT_BLOCKS
> -         + blksz / 4);
> -
> -  if (indir1_block == NULL) {
> -   indir1_block = (uint32_t *) malloc (blksz);
> -   if (indir1_block == NULL) {
> -    printf ("** ext2fs read block (indir 2 1) malloc failed. **\n");
> -    return (-1);
> -   }
> -   indir1_size = blksz;
> -   indir1_blkno = -1;
> -  }
> -  if (blksz != indir1_size) {
> -   free (indir1_block);
> -   indir1_block = NULL;
> -   indir1_size = 0;
> -   indir1_blkno = -1;
> -   indir1_block = (uint32_t *) malloc (blksz);
> -   if (indir1_block == NULL) {
> -    printf ("** ext2fs read block (indir 2 1) malloc failed. **\n");
> -    return (-1);
> -   }
> -   indir1_size = blksz;
> -  }
> -  if ((__le32_to_cpu (inode->b.blocks.double_indir_block) <<
> -       log2_blksz) != indir1_blkno) {
> -   status = ext2fs_devread
> (__le32_to_cpu(inode->b.blocks.double_indir_block) << log2_blksz,
> -      0, blksz,
> -      (char *) indir1_block);
> -   if (status == 0) {
> -    printf ("** ext2fs read block (indir 2 1) failed. **\n");
> -    return (-1);
> -   }
> -   indir1_blkno =
> -    __le32_to_cpu (inode->b.blocks.double_indir_block) << log2_blksz;
> -  }
> -
> -  if (indir2_block == NULL) {
> -   indir2_block = (uint32_t *) malloc (blksz);
> -   if (indir2_block == NULL) {
> -    printf ("** ext2fs read block (indir 2 2) malloc failed. **\n");
> -    return (-1);
> -   }
> -   indir2_size = blksz;
> -   indir2_blkno = -1;
> -  }
> -  if (blksz != indir2_size) {
> -   free (indir2_block);
> -   indir2_block = NULL;
> -   indir2_size = 0;
> -   indir2_blkno = -1;
> -   indir2_block = (uint32_t *) malloc (blksz);
> -   if (indir2_block == NULL) {
> -    printf ("** ext2fs read block (indir 2 2) malloc failed. **\n");
> -    return (-1);
> -   }
> -   indir2_size = blksz;
> -  }
> -  if ((__le32_to_cpu (indir1_block[rblock / perblock]) <<
> -       log2_blksz) != indir2_blkno) {
> -   status = ext2fs_devread (__le32_to_cpu(indir1_block[rblock / perblock])
> << log2_blksz,
> -       0, blksz,
> -       (char *) indir2_block);
> -   if (status == 0) {
> -    printf ("** ext2fs read block (indir 2 2) failed. **\n");
> -    return (-1);
> -   }
> -   indir2_blkno =
> -    __le32_to_cpu (indir1_block[rblock / perblock]) << log2_blksz;
> -  }
> -  blknr = __le32_to_cpu (indir2_block[rblock % perblock]);
> - }
> - /* Tripple indirect.  */
> - else {
> -  printf ("** ext2fs doesn't support tripple indirect blocks. **\n");
> -  return (-1);
> - }
> -#ifdef DEBUG
> - printf ("ext2fs_read_block %08x\n", blknr);
> -#endif
> - return (blknr);
> -}
> -
> -
> int ext2fs_read_file
>  (ext2fs_node_t node, int pos, unsigned int len, char *buf) {
>  int i;
> @@ -409,8 +125,7 @@ int ext2fs_read_file
>   int blockend = blocksize;
> 
>   int skipfirst = 0;
> -
> -  blknr = ext2fs_read_block (node, i);
> +  blknr = read_allocated_block(&(node->inode), i);
>   if (blknr < 0) {
>    return (-1);
>   }
> @@ -449,8 +164,8 @@ int ext2fs_read_file
>  return (len);
> }
> 
> -
> -static int ext2fs_iterate_dir (ext2fs_node_t dir, char *name,
> ext2fs_node_t * fnode, int *ftype)
> +int ext2fs_iterate_dir(ext2fs_node_t dir, char *name,
> +     ext2fs_node_t *fnode, int *ftype)
> {
>  unsigned int fpos = 0;
>  int status;
> @@ -581,7 +296,6 @@ static int ext2fs_iterate_dir (ext2fs_node_t dir, char
> *name, ext2fs_node_t * fn
>  return (0);
> }
> 
> -
> static char *ext2fs_read_symlink (ext2fs_node_t node) {
>  char *symlink;
>  struct ext2fs_node *diro = node;
> @@ -617,7 +331,6 @@ static char *ext2fs_read_symlink (ext2fs_node_t node) {
>  return (symlink);
> }
> 
> -
> int ext2fs_find_file1
>  (const char *currpath,
>   ext2fs_node_t currroot, ext2fs_node_t * currfound, int *foundtype) {
> @@ -721,7 +434,6 @@ int ext2fs_find_file1
>  return (-1);
> }
> 
> -
> int ext2fs_find_file
>  (const char *path,
>   ext2fs_node_t rootnode, ext2fs_node_t * foundnode, int expecttype) {
> @@ -748,7 +460,6 @@ int ext2fs_find_file
>  return (1);
> }
> 
> -
> int ext2fs_ls (const char *dirname) {
>  ext2fs_node_t dirnode;
>  int status;
> @@ -768,7 +479,6 @@ int ext2fs_ls (const char *dirname) {
>  return (0);
> }
> 
> -
> int ext2fs_open (const char *filename) {
>  ext2fs_node_t fdiro = NULL;
>  int status;
> @@ -799,7 +509,6 @@ fail:
>  return (-1);
> }
> 
> -
> int ext2fs_close (void
>  ) {
>  if ((ext2fs_file != NULL) && (ext2fs_root != NULL)) {
> @@ -825,7 +534,6 @@ int ext2fs_close (void
>  return (0);
> }
> 
> -
> int ext2fs_read (char *buf, unsigned len) {
>  int status;
> 
> @@ -836,12 +544,10 @@ int ext2fs_read (char *buf, unsigned len) {
>  if (ext2fs_file == NULL) {
>   return (0);
>  }
> -
>  status = ext2fs_read_file (ext2fs_file, 0, len, buf);
>  return (status);
> }
> 
> -
> int ext2fs_mount (unsigned part_length) {
>  struct ext2_data *data;
>  int status;
> @@ -880,7 +586,6 @@ int ext2fs_mount (unsigned part_length) {
>  }
> 
>  ext2fs_root = data;
> -
>  return (1);
> 
> fail:
> diff --git a/fs/ext4/Makefile b/fs/ext4/Makefile
> new file mode 100644
> index 0000000..850f821
> --- /dev/null
> +++ b/fs/ext4/Makefile
> @@ -0,0 +1,51 @@
> +#
> +# (C) Copyright 2006
> +# Wolfgang Denk, DENX Software Engineering, wd@denx.de.
> +#
> +# (C) Copyright 2003
> +# Pavel Bartusek, Sysgo Real-Time Solutions AG, pba@sysgo.de
> +#
> +#
> +# See file CREDITS for list of people who contributed to this
> +# project.
> +#
> +# This program is free software; you can redistribute it and/or
> +# modify it under the terms of the GNU General Public License as
> +# published by the Free Software Foundation; either version 2 of
> +# the License, or (at your option) any later version.
> +#
> +# This program is distributed in the hope that it will be useful,
> +# but WITHOUT ANY WARRANTY; without even the implied warranty of
> +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
> +# GNU General Public License for more details.
> +#
> +# You should have received a copy of the GNU General Public License
> +# along with this program; if not, write to the Free Software
> +# Foundation, Inc., 59 Temple Place, Suite 330, Boston,
> +# MA 02111-1307 USA
> +#
> +
> +include $(TOPDIR)/config.mk
> +
> +LIB = $(obj)libext4fs.o
> +
> +AOBJS =
> +COBJS-$(CONFIG_CMD_EXT4) := ext4fs.o ext4_common.o
> +
> +SRCS := $(AOBJS:.o=.S) $(COBJS-y:.o=.c)
> +OBJS := $(addprefix $(obj),$(AOBJS) $(COBJS-y))
> +
> +
> +all: $(LIB) $(AOBJS)
> +
> +$(LIB): $(obj).depend $(OBJS)
> + $(call cmd_link_o_target, $(OBJS))
> +
> +#########################################################################
> +
> +# defines $(obj).depend target
> +include $(SRCTREE)/rules.mk
> +
> +sinclude $(obj).depend
> +
> +#########################################################################
> diff --git a/fs/ext4/ext4_common.c b/fs/ext4/ext4_common.c
> new file mode 100644
> index 0000000..39321f6
> --- /dev/null
> +++ b/fs/ext4/ext4_common.c
> @@ -0,0 +1,572 @@
> +/*
> + * (C) Copyright 2011 Samsung Electronics
> + * EXT4 filesystem implementation in Uboot by
> + * Uma Shankar <uma.shankar@samsung.com>
> + * Manjunatha C Achar <a.manjunatha@samsung.com>
> + *
> + *  Copyright (C) 2003, 2004  Free Software Foundation, Inc.
> + *  This program is free software; you can redistribute it and/or modify
> + *  it under the terms of the GNU General Public License as published by
> + *  the Free Software Foundation; either version 2 of the License, or
> + *  (at your option) any later version.
> + *
> + *  This program is distributed in the hope that it will be useful,
> + *  but WITHOUT ANY WARRANTY; without even the implied warranty of
> + *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
> + *  GNU General Public License for more details.
> + *
> + *  You should have received a copy of the GNU General Public License
> + *  along with this program; if not, write to the Free Software
> + *  Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
> + */
> +
> +/*
> + *  ext4load - based on code from GRUB2  fs/ext2.c
> +*/

'*' should all be aligned

I'm concerned about the licensing here - GRUB is currently GPLv3+, U-Boot
is GPLv2+...

> +#include <common.h>
> +#include <ext2fs.h>
> +#include <ext4fs.h>
> +#include <malloc.h>
> +#include <asm/byteorder.h>
> +#include <linux/stat.h>
> +#include <linux/time.h>
> +#include "ext4_common.h"
> +
> +struct ext2_data *ext4fs_root;
> +ext2fs_node_t ext4fs_file;
> +uint32_t *ext4fs_indir1_block;
> +int ext4fs_indir1_size;
> +int ext4fs_indir1_blkno = -1;
> +uint32_t *ext4fs_indir2_block;
> +int ext4fs_indir2_size;
> +int ext4fs_indir2_blkno = -1;
> +
> +uint32_t *ext4fs_indir3_block;
> +int ext4fs_indir3_size;
> +int ext4fs_indir3_blkno = -1;
> +struct ext4_inode *g_parent_inode;
> +
> +#ifndef offsetof
> +#define offsetof(TYPE, MEMBER) ((size_t) &((TYPE *)0)->MEMBER)
> +#endif
> +
> +void *xmalloc(size_t size)
> +{
> + void *ptr = malloc(size);
> + if (ptr == NULL && size != 0)
> +  printf("bb_msg_memory_exhausted\n");
> + return ptr;
> +}
> +
> +void *xzalloc(size_t size)
> +{
> + void *ptr = xmalloc(size);
> + memset(ptr, 0, size);
> + return ptr;
> +}
> +
> +static struct ext4_extent_header *ext4fs_find_leaf(struct ext2_data *data,
> + char *buf, struct ext4_extent_header *ext_block, uint32_t fileblock)
> +{
> + struct ext4_extent_idx *index;
> + unsigned long long block;
> + int i;
> +
> + while (1) {
> +  index = (struct ext4_extent_idx *)(ext_block + 1);
> +
> +  if (le32_to_cpu(ext_block->magic) != EXT4_EXT_MAGIC)
> +   return 0;
> +
> +  if (ext_block->depth == 0)
> +   return ext_block;
> +
> +  for (i = 0; i < le32_to_cpu(ext_block->entries); i++) {
> +   if (fileblock < le32_to_cpu(index[i].block))
> +    break;
> +  }
> +
> +  if (--i < 0)
> +   return 0;
> +
> +  block = le32_to_cpu(index[i].leaf_hi);
> +  block = (block << 32) + le32_to_cpu(index[i].leaf);
> +
> +  if (ext2fs_devread(block << LOG2_EXT2_BLOCK_SIZE(data),
> +       0, EXT2_BLOCK_SIZE(data), buf)) {
> +   ext_block = (struct ext4_extent_header *)buf;
> +   return ext_block;
> +  } else
> +   return 0;
> + }
> +}
> +
> +static int ext4fs_blockgroup
> + (struct ext2_data *data, int group, struct ext2_block_group *blkgrp)
> +{
> + long int blkno;
> + unsigned int blkoff, desc_per_blk;
> +
> + desc_per_blk = EXT2_BLOCK_SIZE(data) / sizeof(struct ext2_block_group);
> +
> + blkno = __le32_to_cpu(data->sblock.first_data_block) + 1
> +     + group / desc_per_blk;
> + blkoff = (group % desc_per_blk) * sizeof(struct ext2_block_group);
> +
> + debug("ext4fs read %d group descriptor (blkno %ld blkoff %u)\n",
> +       group, blkno, blkoff);
> +
> + return ext2fs_devread(blkno << LOG2_EXT2_BLOCK_SIZE(data),
> +  blkoff, sizeof(struct ext2_block_group), (char *)blkgrp);
> +}
> +
> +int ext4fs_read_inode(struct ext2_data *data, int ino, struct ext4_inode
> *inode)
> +{
> + struct ext2_block_group blkgrp;
> + struct ext2_sblock *sblock = &data->sblock;
> + ExtFileSystem *fs = get_fs();
> + int inodes_per_block, status;
> + long int blkno;
> + unsigned int blkoff;
> +
> + /* It is easier to calculate if the first inode is 0.  */
> + ino--;
> + status = ext4fs_blockgroup(data, ino / __le32_to_cpu
> +       (sblock->inodes_per_group), &blkgrp);
> +
> + if (status == 0)
> +  return 0;
> +
> + inodes_per_block = EXT2_BLOCK_SIZE(data) / fs->inodesz;
> +
> + blkno = __le32_to_cpu(blkgrp.inode_table_id) +
> +     (ino % __le32_to_cpu(sblock->inodes_per_group))
> +     / inodes_per_block;
> + blkoff = (ino % inodes_per_block) * fs->inodesz;
> + /* Read the inode.  */
> + status = ext2fs_devread(blkno << LOG2_EXT2_BLOCK_SIZE(data), blkoff,
> +    sizeof(struct ext4_inode), (char *)inode);
> + if (status == 0)
> +  return 0;
> +
> + return 1;
> +}
> +
> +long int read_allocated_block(struct ext4_inode *inode, int fileblock)
> +{
> + long int blknr;
> + int blksz;
> + int log2_blksz;
> + int status;
> + long int rblock;
> + long int perblock_parent;
> + long int perblock_child;
> + unsigned long long start;
> + /*get the blocksize of the filesystem */
> + blksz = EXT2_BLOCK_SIZE(ext4fs_root);
> + log2_blksz = LOG2_EXT2_BLOCK_SIZE(ext4fs_root);
> +
> + if (le32_to_cpu(inode->flags) & EXT4_EXTENTS_FLAG) {
> +  char buf[EXT2_BLOCK_SIZE(ext4fs_root)];
> +  struct ext4_extent_header *leaf;
> +  struct ext4_extent *ext;
> +  int i;
> +
> +  leaf = ext4fs_find_leaf(ext4fs_root, buf,
> +     (struct ext4_extent_header *)inode->
> +     b.blocks.dir_blocks, fileblock);
> +  if (!leaf) {
> +   printf("invalid extent\n");
> +   return -1;
> +  }
> +
> +  ext = (struct ext4_extent *)(leaf + 1);
> +
> +  for (i = 0; i < le32_to_cpu(leaf->entries); i++) {
> +   if (fileblock < le32_to_cpu(ext[i].block))
> +    break;
> +  }
> +
> +  if (--i >= 0) {
> +   fileblock -= le32_to_cpu(ext[i].block);
> +   if (fileblock >= le32_to_cpu(ext[i].len)) {
> +    return 0;
> +   } else {
> +    start = le32_to_cpu(ext[i].start_hi);
> +    start = (start << 32) +
> +        le32_to_cpu(ext[i].start);
> +    return fileblock + start;
> +   }
> +  } else {
> +   printf("something wrong with extent\n");
> +   return -1;
> +  }
> + }
> +
> + /* Direct blocks.  */
> + if (fileblock < INDIRECT_BLOCKS)
> +  blknr = __le32_to_cpu(inode->b.blocks.dir_blocks[fileblock]);
> +
> + /* Indirect.  */
> + else if (fileblock < (INDIRECT_BLOCKS + (blksz / 4))) {
> +  if (ext4fs_indir1_block == NULL) {
> +   ext4fs_indir1_block = (uint32_t *) malloc(blksz);
> +   if (ext4fs_indir1_block == NULL) {
> +    printf("** SI ext2fs read block (indir 1) \
> +     malloc failed. **\n");
> +    return -1;
> +   }
> +   ext4fs_indir1_size = blksz;
> +   ext4fs_indir1_blkno = -1;
> +  }
> +  if (blksz != ext4fs_indir1_size) {
> +   free(ext4fs_indir1_block);
> +   ext4fs_indir1_block = NULL;
> +   ext4fs_indir1_size = 0;
> +   ext4fs_indir1_blkno = -1;
> +   ext4fs_indir1_block = (uint32_t *) malloc(blksz);
> +   if (ext4fs_indir1_block == NULL) {
> +    printf("** SI ext2fs read block (indir 1) \
> +     malloc failed. **\n");
> +    return -1;
> +   }
> +   ext4fs_indir1_size = blksz;
> +  }
> +  if ((__le32_to_cpu(inode->b.blocks.indir_block) <<
> +       log2_blksz) != ext4fs_indir1_blkno) {
> +   status = ext2fs_devread(__le32_to_cpu(inode->b.blocks.
> +     indir_block) << log2_blksz, 0, blksz,
> +      (char *) ext4fs_indir1_block);
> +   if (status == 0) {
> +    printf("** SI ext2fs read block (indir 1) \
> +     failed. **\n");
> +    return 0;
> +   }
> +   ext4fs_indir1_blkno =
> +    __le32_to_cpu(inode->b.blocks.
> +            indir_block) << log2_blksz;
> +  }
> +  blknr = __le32_to_cpu(ext4fs_indir1_block
> +          [fileblock - INDIRECT_BLOCKS]);
> + }
> + /* Double indirect.  */
> + else if (fileblock <
> +   (INDIRECT_BLOCKS + (blksz / 4 * (blksz / 4 + 1)))) {
> +
> +  long int perblock = blksz / 4;
> +  long int rblock = fileblock - (INDIRECT_BLOCKS + blksz / 4);
> +
> +  if (ext4fs_indir1_block == NULL) {
> +   ext4fs_indir1_block = (uint32_t *) malloc(blksz);
> +   if (ext4fs_indir1_block == NULL) {
> +    printf("** DI ext2fs read block (indir 2 1) \
> +     malloc failed. **\n");
> +    return -1;
> +   }
> +   ext4fs_indir1_size = blksz;
> +   ext4fs_indir1_blkno = -1;
> +  }
> +  if (blksz != ext4fs_indir1_size) {
> +   free(ext4fs_indir1_block);
> +   ext4fs_indir1_block = NULL;
> +   ext4fs_indir1_size = 0;
> +   ext4fs_indir1_blkno = -1;
> +   ext4fs_indir1_block = (uint32_t *) malloc(blksz);
> +   if (ext4fs_indir1_block == NULL) {
> +    printf("** DI ext2fs read block (indir 2 1) \
> +     malloc failed. **\n");
> +    return -1;
> +   }
> +   ext4fs_indir1_size = blksz;
> +  }
> +  if ((__le32_to_cpu(inode->b.blocks.double_indir_block) <<
> +       log2_blksz) != ext4fs_indir1_blkno) {
> +   status = ext2fs_devread(__le32_to_cpu(inode->b.blocks.
> +   double_indir_block) << log2_blksz, 0, blksz,
> +    (char *) ext4fs_indir1_block);
> +   if (status == 0) {
> +    printf("** DI ext2fs read block (indir 2 1) \
> +     failed. **\n");
> +    return -1;
> +   }
> +   ext4fs_indir1_blkno =
> +   __le32_to_cpu(inode->b.blocks.
> +   double_indir_block) << log2_blksz;
> +  }
> +
> +  if (ext4fs_indir2_block == NULL) {
> +   ext4fs_indir2_block = (uint32_t *) malloc(blksz);
> +   if (ext4fs_indir2_block == NULL) {
> +    printf("** DI ext2fs read block (indir 2 2) \
> +     malloc failed. **\n");
> +    return -1;
> +   }
> +   ext4fs_indir2_size = blksz;
> +   ext4fs_indir2_blkno = -1;
> +  }
> +  if (blksz != ext4fs_indir2_size) {
> +   free(ext4fs_indir2_block);
> +   ext4fs_indir2_block = NULL;
> +   ext4fs_indir2_size = 0;
> +   ext4fs_indir2_blkno = -1;
> +   ext4fs_indir2_block = (uint32_t *) malloc(blksz);
> +   if (ext4fs_indir2_block == NULL) {
> +    printf("** DI ext2fs read block (indir 2 2) \
> +     malloc failed. **\n");
> +    return -1;
> +   }
> +   ext4fs_indir2_size = blksz;
> +  }
> +  if ((__le32_to_cpu(ext4fs_indir1_block[rblock / perblock]) <<
> +       log2_blksz) != ext4fs_indir2_blkno) {
> +   status = ext2fs_devread(__le32_to_cpu
> +      (ext4fs_indir1_block
> +   [rblock / perblock]) << log2_blksz,
> +   0, blksz, (char *) ext4fs_indir2_block);
> +   if (status == 0) {
> +    printf("** DI ext2fs read block (indir 2 2) \
> +     failed. **\n");
> +    return -1;
> +   }
> +   ext4fs_indir2_blkno =
> +   __le32_to_cpu(ext4fs_indir1_block[rblock
> +   / perblock]) << log2_blksz;
> +  }
> +  blknr = __le32_to_cpu(ext4fs_indir2_block[rblock % perblock]);
> + }
> + /* Tripple indirect.  */
> + else {
> +  rblock = fileblock - (INDIRECT_BLOCKS + blksz / 4 +
> +          (blksz / 4 * blksz / 4));
> +  perblock_child = blksz / 4;
> +  perblock_parent = ((blksz / 4) * (blksz / 4));
> +
> +  if (ext4fs_indir1_block == NULL) {
> +   ext4fs_indir1_block = (uint32_t *) malloc(blksz);
> +   if (ext4fs_indir1_block == NULL) {
> +    printf("** TI ext2fs read block (indir 2 1) \
> +     malloc failed. **\n");
> +    return -1;
> +   }
> +   ext4fs_indir1_size = blksz;
> +   ext4fs_indir1_blkno = -1;
> +  }
> +  if (blksz != ext4fs_indir1_size) {
> +   free(ext4fs_indir1_block);
> +   ext4fs_indir1_block = NULL;
> +   ext4fs_indir1_size = 0;
> +   ext4fs_indir1_blkno = -1;
> +   ext4fs_indir1_block = (uint32_t *) malloc(blksz);
> +   if (ext4fs_indir1_block == NULL) {
> +    printf("** TI ext2fs read block (indir 2 1) \
> +     malloc failed. **\n");
> +    return -1;
> +   }
> +   ext4fs_indir1_size = blksz;
> +  }
> +  if ((__le32_to_cpu(inode->b.blocks.tripple_indir_block) <<
> +       log2_blksz) != ext4fs_indir1_blkno) {
> +   status = ext2fs_devread
> +   (__le32_to_cpu(inode->b.blocks.
> +   tripple_indir_block) << log2_blksz,
> +   0, blksz, (char *) ext4fs_indir1_block);
> +   if (status == 0) {
> +    printf("** TI ext2fs read block (indir 2 1) \
> +     failed. **\n");
> +    return -1;
> +   }
> +   ext4fs_indir1_blkno =
> +    __le32_to_cpu(inode->b.blocks.
> +    tripple_indir_block) << log2_blksz;
> +  }
> +
> +  if (ext4fs_indir2_block == NULL) {
> +   ext4fs_indir2_block = (uint32_t *) malloc(blksz);
> +   if (ext4fs_indir2_block == NULL) {
> +    printf("** TI ext2fs read block (indir 2 2) \
> +     malloc failed. **\n");
> +    return -1;
> +   }
> +   ext4fs_indir2_size = blksz;
> +   ext4fs_indir2_blkno = -1;
> +  }
> +  if (blksz != ext4fs_indir2_size) {
> +   free(ext4fs_indir2_block);
> +   ext4fs_indir2_block = NULL;
> +   ext4fs_indir2_size = 0;
> +   ext4fs_indir2_blkno = -1;
> +   ext4fs_indir2_block = (uint32_t *) malloc(blksz);
> +   if (ext4fs_indir2_block == NULL) {
> +    printf("** TI ext2fs read block (indir 2 2) \
> +     malloc failed. **\n");
> +    return -1;
> +   }
> +   ext4fs_indir2_size = blksz;
> +  }
> +  if ((__le32_to_cpu(ext4fs_indir1_block[rblock /
> +   perblock_parent]) << log2_blksz)
> +      != ext4fs_indir2_blkno) {
> +   status = ext2fs_devread(__le32_to_cpu
> +      (ext4fs_indir1_block
> +   [rblock / perblock_parent]) << log2_blksz,
> +   0, blksz, (char *) ext4fs_indir2_block);
> +   if (status == 0) {
> +    printf("** TI ext2fs read block (indir 2 2) \
> +     failed. **\n");
> +    return -1;
> +   }
> +   ext4fs_indir2_blkno =
> +   __le32_to_cpu(ext4fs_indir1_block[rblock /
> +    perblock_parent]) << log2_blksz;
> +  }
> +
> +  if (ext4fs_indir3_block == NULL) {
> +   ext4fs_indir3_block = (uint32_t *) malloc(blksz);
> +   if (ext4fs_indir3_block == NULL) {
> +    printf("** TI ext2fs read block (indir 2 2) \
> +     malloc failed. **\n");
> +    return -1;
> +   }
> +   ext4fs_indir3_size = blksz;
> +   ext4fs_indir3_blkno = -1;
> +  }
> +  if (blksz != ext4fs_indir3_size) {
> +   free(ext4fs_indir3_block);
> +   ext4fs_indir3_block = NULL;
> +   ext4fs_indir3_size = 0;
> +   ext4fs_indir3_blkno = -1;
> +   ext4fs_indir3_block = (uint32_t *) malloc(blksz);
> +   if (ext4fs_indir3_block == NULL) {
> +    printf("** TI ext2fs read block (indir 2 2) \
> +     malloc failed. **\n");
> +    return -1;
> +   }
> +   ext4fs_indir3_size = blksz;
> +  }
> +  if ((__le32_to_cpu(ext4fs_indir2_block[rblock
> +  / perblock_child]) << log2_blksz) != ext4fs_indir3_blkno){
> +   status = ext2fs_devread(__le32_to_cpu
> +   (ext4fs_indir2_block[(rblock / perblock_child)
> +   % (blksz / 4)]) << log2_blksz,
> +   0, blksz, (char *) ext4fs_indir3_block);
> +   if (status == 0) {
> +    printf("** TI ext2fs read block (indir 2 2) \
> +     failed. **\n");
> +    return -1;
> +   }
> +   ext4fs_indir3_blkno =
> +       __le32_to_cpu(ext4fs_indir2_block[(rblock /
> +   perblock_child) % (blksz / 4)]) << log2_blksz;
> +  }
> +
> +  blknr = __le32_to_cpu(ext4fs_indir3_block
> +          [rblock % perblock_child]);
> + }
> + debug("ext4fs_read_block %08x\n", blknr);
> + return blknr;
> +}
> +
> +int ext4fs_close(void)
> +{
> + if ((ext4fs_file != NULL) && (ext4fs_root != NULL)) {
> +  ext4fs_free_node(ext4fs_file, &ext4fs_root->diropen);
> +  ext4fs_file = NULL;
> + }
> + if (ext4fs_root != NULL) {
> +  free(ext4fs_root);
> +  ext4fs_root = NULL;
> + }
> + if (ext4fs_indir1_block != NULL) {
> +  free(ext4fs_indir1_block);
> +  ext4fs_indir1_block = NULL;
> +  ext4fs_indir1_size = 0;
> +  ext4fs_indir1_blkno = -1;
> + }
> + if (ext4fs_indir2_block != NULL) {
> +  free(ext4fs_indir2_block);
> +  ext4fs_indir2_block = NULL;
> +  ext4fs_indir2_size = 0;
> +  ext4fs_indir2_blkno = -1;
> + }
> + return 0;
> +}
> +
> +int ext4fs_open(const char *filename)
> +{
> + ext2fs_node_t fdiro = NULL;
> + int status;
> + int len;
> +
> + if (ext4fs_root == NULL)
> +  return -1;
> +
> + ext4fs_file = NULL;
> + status = ext2fs_find_file(filename, &ext4fs_root->diropen, &fdiro,
> +      FILETYPE_REG);
> + if (status == 0)
> +  goto fail;
> +
> + if (!fdiro->inode_read) {
> +  status = ext4fs_read_inode(fdiro->data, fdiro->ino,
> +        (struct ext4_inode *)&fdiro->inode);
> +  if (status == 0)
> +   goto fail;
> + }
> + len = __le32_to_cpu(fdiro->inode.size);
> + ext4fs_file = fdiro;
> + return len;
> +
> +fail:
> + ext4fs_free_node(fdiro, &ext4fs_root->diropen);
> + return -1;
> +}
> +
> +int ext4fs_mount(unsigned part_length)
> +{
> + struct ext2_data *data;
> + int status;
> + ExtFileSystem *fs = get_fs();
> + data = malloc(sizeof(struct ext2_data));
> + if (!data)
> +  return 0;
> +
> + /* Read the superblock.  */
> + status = ext2fs_devread(1 * 2, 0, sizeof(struct ext2_sblock),
> +    (char *)&data->sblock);
> +
> + if (status == 0)
> +  goto fail;
> +
> + /* Make sure this is an ext2 filesystem.  */
> + if (__le16_to_cpu(data->sblock.magic) != EXT2_MAGIC)
> +  goto fail;
> +
> + if (__le32_to_cpu(data->sblock.revision_level == 0))
> +  fs->inodesz = 128;
> + else
> +  fs->inodesz = __le16_to_cpu(data->sblock.inode_size);
> +
> +#ifdef DEBUG
> + printf("EXT2 rev %d, inode_size %d\n",
> +        __le32_to_cpu(data->sblock.revision_level), fs->inodesz);
> +#endif
> + data->diropen.data = data;
> + data->diropen.ino = 2;
> + data->diropen.inode_read = 1;
> + data->inode = &data->diropen.inode;
> +
> + status = ext4fs_read_inode(data, 2, (struct ext4_inode *)data->inode);
> + if (status == 0)
> +  goto fail;
> +
> + ext4fs_root = data;
> + ext2fs_mount(part_length);
> + return 1;
> +
> +fail:
> + printf("Failed to mount ext2 filesystem...\n");
> + free(data);
> +
> + ext4fs_root = NULL;
> + return 0;
> +}
> diff --git a/fs/ext4/ext4_common.h b/fs/ext4/ext4_common.h
> new file mode 100644
> index 0000000..2014298
> --- /dev/null
> +++ b/fs/ext4/ext4_common.h
> @@ -0,0 +1,44 @@
> +/*
> + * (C) Copyright 2011 Samsung Electronics
> + * EXT4 filesystem implementation in Uboot by
> + * Uma Shankar <uma.shankar@samsung.com>
> + * Manjunatha C Achar <a.manjunatha@samsung.com>
> + *
> + *  Copyright (C) 2003, 2004  Free Software Foundation, Inc.
> + *  This program is free software; you can redistribute it and/or modify
> + *  it under the terms of the GNU General Public License as published by
> + *  the Free Software Foundation; either version 2 of the License, or
> + *  (at your option) any later version.
> + *
> + *  This program is distributed in the hope that it will be useful,
> + *  but WITHOUT ANY WARRANTY; without even the implied warranty of
> + *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
> + *  GNU General Public License for more details.
> + *
> + *  You should have received a copy of the GNU General Public License
> + *  along with this program; if not, write to the Free Software
> + *  Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
> + */
> +
> +#ifndef __EXT4_COMMON__
> +#define __EXT4_COMMON__
> +#include <ext2fs.h>
> +#include <ext4fs.h>
> +
> +#define YES  1
> +#define NO  0
> +#define TRUE  1
> +#define FALSE  0
> +#define RECOVER  1
> +#define SCAN  0
> +
> +#define S_IFLNK   0120000 /* symbolic link */
> +#define BLOCK_NO_ONE  1
> +#define SUPERBLOCK_SECTOR 2
> +#define SUPERBLOCK_SIZE  1024
> +#define F_FILE   1

Can you fix the alignments so the defines are all nicely aligned (using tabs)

> +
> +extern unsigned long part_offset;
> +int ext4fs_read_inode(struct ext2_data *data, int ino,
> +        struct ext4_inode *inode);
> +#endif
> diff --git a/fs/ext4/ext4fs.c b/fs/ext4/ext4fs.c
> new file mode 100644
> index 0000000..890aaf3
> --- /dev/null
> +++ b/fs/ext4/ext4fs.c
> @@ -0,0 +1,215 @@
> +/*
> + * (C) Copyright 2011 Samsung Electronics
> + * EXT4 filesystem implementation in Uboot by
> + * Uma Shankar <uma.shankar@samsung.com>
> + * Manjunatha C Achar <a.manjunatha@samsung.com>
> + *
> + *  Copyright (C) 2003, 2004  Free Software Foundation, Inc.
> + *  This program is free software; you can redistribute it and/or modify
> + *  it under the terms of the GNU General Public License as published by
> + *  the Free Software Foundation; either version 2 of the License, or
> + *  (at your option) any later version.
> + *
> + *  This program is distributed in the hope that it will be useful,
> + *  but WITHOUT ANY WARRANTY; without even the implied warranty of
> + *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
> + *  GNU General Public License for more details.
> + *
> + *  You should have received a copy of the GNU General Public License
> + *  along with this program; if not, write to the Free Software
> + *  Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
> + */
> +
> +/*
> + *  ext4load - based on code from GRUB2  fs/ext2.c
> +*/
> +#include <common.h>
> +#include <malloc.h>
> +#include <asm/byteorder.h>
> +#include <linux/stat.h>
> +#include <linux/time.h>
> +#include <ext2fs.h>
> +#include <ext4fs.h>
> +#include "ext4_common.h"
> +
> +int ext4fs_symlinknest;
> +block_dev_desc_t *ext4_dev_desc;
> +
> +ExtFileSystem *get_fs(void)

Again, no camel case please

> +{
> + if (ext4_dev_desc == NULL || ext4_dev_desc->priv == NULL)
> +  printf("Invalid Input Arguments %s\n", __func__);
> + return (ExtFileSystem *)ext4_dev_desc->priv;
> +}
> +
> +int init_fs(block_dev_desc_t *dev_desc)
> +{
> + ExtFileSystem *fs;
> + if (dev_desc == NULL) {
> +  printf("Invalid Input Arguments %s\n", __func__);
> +  return -1;
> + }
> +
> + fs = (ExtFileSystem *)xzalloc(sizeof(ExtFileSystem));
> + if (fs == NULL) {
> +  printf("malloc failed: %s\n", __func__);
> +  return -1;
> + }
> +
> + fs->dev_desc = dev_desc;
> + dev_desc->priv = fs;
> + return 0;
> +}
> +
> +void deinit_fs(block_dev_desc_t *dev_desc)
> +{
> + if (dev_desc == NULL) {
> +  printf("Invalid Input Arguments %s\n", __func__);
> +  return;
> + }
> + if (dev_desc->priv)
> +  free(dev_desc->priv);
> + return;
> +}
> +
> +void ext4fs_free_node(ext2fs_node_t node, ext2fs_node_t currroot)
> +{
> + if ((node != &ext4fs_root->diropen) && (node != currroot))
> +  free(node);
> +}
> +
> +/* Taken from openmoko-kernel mailing list: By Andy green
> +* Optimized read file API : collects and defers contiguous sector
> +* reads into one potentially more efficient larger sequential read action
> +*/
> +int ext4fs_read_file(ext2fs_node_t node, int pos, unsigned int len, char
> *buf)
> +{
> + int i;
> + int blockcnt;
> + int log2blocksize = LOG2_EXT2_BLOCK_SIZE(node->data);
> + int blocksize = 1 << (log2blocksize + DISK_SECTOR_BITS);
> + unsigned int filesize = __le32_to_cpu(node->inode.size);
> + int previous_block_number = -1;
> + int delayed_start = 0;
> + int delayed_extent = 0;
> + int delayed_skipfirst = 0;
> + int delayed_next = 0;
> + char *delayed_buf = NULL;
> + short status;
> +
> + /* Adjust len so it we can't read past the end of the file.  */
> + if (len > filesize)
> +  len = filesize;
> +
> + blockcnt = ((len + pos) + blocksize - 1) / blocksize;
> +
> + for (i = pos / blocksize; i < blockcnt; i++) {
> +  int blknr;
> +  int blockoff = pos % blocksize;
> +  int blockend = blocksize;
> +  int skipfirst = 0;
> +  blknr = read_allocated_block((struct ext4_inode *)
> +          &(node->inode), i);
> +  if (blknr < 0)
> +   return -1;
> +
> +  blknr = blknr << log2blocksize;
> +
> +  /* Last block.  */
> +  if (i == blockcnt - 1) {
> +   blockend = (len + pos) % blocksize;
> +
> +   /* The last portion is exactly blocksize.  */
> +   if (!blockend)
> +    blockend = blocksize;
> +  }
> +
> +  /* First block.  */
> +  if (i == pos / blocksize) {
> +   skipfirst = blockoff;
> +   blockend -= skipfirst;
> +  }
> +  if (blknr) {
> +   int status;
> +
> +   if (previous_block_number != -1) {
> +    if (delayed_next == blknr) {
> +     delayed_extent += blockend;
> +     delayed_next += blockend >> SECTOR_BITS;
> +    } else { /* spill */
> +     status = ext2fs_devread(delayed_start,
> +       delayed_skipfirst,
> +       delayed_extent,
> +       delayed_buf);
> +     if (status == 0)
> +      return -1;
> +     previous_block_number = blknr;
> +     delayed_start = blknr;
> +     delayed_extent = blockend;
> +     delayed_skipfirst = skipfirst;
> +     delayed_buf = buf;
> +     delayed_next = blknr +
> +      (blockend >> SECTOR_BITS);
> +    }
> +   } else {
> +    previous_block_number = blknr;
> +    delayed_start = blknr;
> +    delayed_extent = blockend;
> +    delayed_skipfirst = skipfirst;
> +    delayed_buf = buf;
> +    delayed_next = blknr +
> +     (blockend >> SECTOR_BITS);
> +   }
> +  } else {
> +   if (previous_block_number != -1) {
> +    /* spill */
> +    status = ext2fs_devread(delayed_start,
> +       delayed_skipfirst,
> +       delayed_extent,
> +       delayed_buf);
> +    if (status == 0)
> +     return -1;
> +    previous_block_number = -1;
> +   }
> +   memset(buf, 0, blocksize - skipfirst);
> +  }
> +  buf += blocksize - skipfirst;
> + }
> + if (previous_block_number != -1) {
> +  /* spill */
> +  status = ext2fs_devread(delayed_start,
> +     delayed_skipfirst, delayed_extent,
> +     delayed_buf);
> +  if (status == 0)
> +   return -1;
> +  previous_block_number = -1;
> + }
> + return len;
> +}
> +
> +int ext4fs_ls(const char *dirname)
> +{
> + ext2fs_node_t dirnode;
> + int status;
> +
> + if (dirname == NULL)
> +  return 0;
> +
> + status = ext2fs_find_file(dirname, &ext4fs_root->diropen, &dirnode,
> +  FILETYPE_DIRECTORY);
> + if (status != 1) {
> +  printf("** Can not find directory. **\n");
> +  return 1;
> + }
> +
> + ext2fs_iterate_dir(dirnode, NULL, NULL, NULL);
> + ext4fs_free_node(dirnode, &ext4fs_root->diropen);
> + return 0;
> +}
> +
> +int ext4fs_read(char *buf, unsigned len)
> +{
> + if (ext4fs_root == NULL || ext4fs_file == NULL)
> +  return 0;
> + return  ext4fs_read_file(ext4fs_file, 0, len, buf);
> +}
> diff --git a/include/ext2fs.h b/include/ext2fs.h
> index 163a9bb..de58d0a 100644
> --- a/include/ext2fs.h
> +++ b/include/ext2fs.h
> @@ -25,6 +25,8 @@
>  * from the original ext2 fs code, as found in the linux kernel.
>  */
> 
> +#ifndef __EXT2__
> +#define __EXT2__
> 
> #define SECTOR_SIZE  0x200
> #define SECTOR_BITS  9
> @@ -68,14 +70,175 @@ typedef enum
>   ERR_DEV_NEED_INIT,
>   ERR_NO_DISK_SPACE,
>   ERR_NUMBER_OVERFLOW,
> -
>   MAX_ERR_NUM
> } ext2fs_error_t;
> 
> +/* Magic value used to identify an ext2 filesystem.  */
> +#define EXT2_MAGIC    0xEF53
> +/* Amount of indirect blocks in an inode.  */
> +#define INDIRECT_BLOCKS    12
> +/* Maximum lenght of a pathname.  */
> +#define EXT2_PATH_MAX    4096
> +/* Maximum nesting of symlinks, used to prevent a loop.  */
> +#define EXT2_MAX_SYMLINKCNT   8
> +
> +/* Filetype used in directory entry.  */
> +#define FILETYPE_UNKNOWN   0
> +#define FILETYPE_REG    1
> +#define FILETYPE_DIRECTORY   2
> +#define FILETYPE_SYMLINK   7
> +
> +/* Filetype information as used in inodes.  */
> +#define FILETYPE_INO_MASK   0170000
> +#define FILETYPE_INO_REG   0100000
> +#define FILETYPE_INO_DIRECTORY   0040000
> +#define FILETYPE_INO_SYMLINK   0120000
> +#define EXT2_ROOT_INO    2 /* Root inode */

Again, make defines are all nicely aligned (using tabs)

> +
> +/* Bits used as offset in sector */
> +#define DISK_SECTOR_BITS   9
> +/* The size of an ext2 block in bytes.  */
> +#define EXT2_BLOCK_SIZE(data)    (1 << LOG2_BLOCK_SIZE(data))
> +
> +/* Log2 size of ext2 block in 512 blocks.  */
> +#define LOG2_EXT2_BLOCK_SIZE(data) (__le32_to_cpu \
> +    (data->sblock.log2_block_size) + 1)
> +
> +/* Log2 size of ext2 block in bytes.  */
> +#define LOG2_BLOCK_SIZE(data)    (__le32_to_cpu \
> +  (data->sblock.log2_block_size) + 10)
> +#define INODE_SIZE_FILESYSTEM(data) (__le32_to_cpu \
> +   (data->sblock.inode_size))
> +
> +#define EXT2_FT_DIR  2
> +#define SUCCESS   1
> +/*
> + * Macro-instructions used to manage several block sizes
> + */
> +#define EXT2_MIN_BLOCK_LOG_SIZE   10 /* 1024 */
> +#define EXT2_MAX_BLOCK_LOG_SIZE   16 /* 65536 */
> +#define EXT2_MIN_BLOCK_SIZE   (1 << EXT2_MIN_BLOCK_LOG_SIZE)
> +#define EXT2_MAX_BLOCK_SIZE   (1 << EXT2_MAX_BLOCK_LOG_SIZE)
> +
> +/* The ext2 superblock.  */
> +struct ext2_sblock {
> + uint32_t total_inodes;
> + uint32_t total_blocks;
> + uint32_t reserved_blocks;
> + uint32_t free_blocks;
> + uint32_t free_inodes;
> + uint32_t first_data_block;
> + uint32_t log2_block_size;
> + uint32_t log2_fragment_size;
> + uint32_t blocks_per_group;
> + uint32_t fragments_per_group;
> + uint32_t inodes_per_group;
> + uint32_t mtime;
> + uint32_t utime;
> + uint16_t mnt_count;
> + uint16_t max_mnt_count;
> + uint16_t magic;
> + uint16_t fs_state;
> + uint16_t error_handling;
> + uint16_t minor_revision_level;
> + uint32_t lastcheck;
> + uint32_t checkinterval;
> + uint32_t creator_os;
> + uint32_t revision_level;
> + uint16_t uid_reserved;
> + uint16_t gid_reserved;
> + uint32_t first_inode;
> + uint16_t inode_size;
> + uint16_t block_group_number;
> + uint32_t feature_compatibility;
> + uint32_t feature_incompat;
> + uint32_t feature_ro_compat;
> + uint32_t unique_id[4];
> + char volume_name[16];
> + char last_mounted_on[64];
> + uint32_t compression_info;
> +};
> +
> +struct ext2_block_group {
> + __u32 block_id; /* Blocks bitmap block */
> + __u32 inode_id; /* Inodes bitmap block */
> + __u32 inode_table_id; /* Inodes table block */
> + __u16 free_blocks; /* Free blocks count */
> + __u16 free_inodes; /* Free inodes count */
> + __u16 used_dir_cnt; /* Directories count */
> + __u16 bg_flags;
> + __u32 bg_reserved[2];
> + __u16 bg_itable_unused; /* Unused inodes count */
> + __u16 bg_checksum; /* crc16(s_uuid+grouo_num+group_desc)*/
> +};
> +
> +/* The ext2 inode.  */
> +struct ext2_inode {
> + uint16_t mode;
> + uint16_t uid;
> + uint32_t size;
> + uint32_t atime;
> + uint32_t ctime;
> + uint32_t mtime;
> + uint32_t dtime;
> + uint16_t gid;
> + uint16_t nlinks;
> + uint32_t blockcnt; /* Blocks of 512 bytes!! */
> + uint32_t flags;
> + uint32_t osd1;
> + union {
> +  struct datablocks {
> +   uint32_t dir_blocks[INDIRECT_BLOCKS];
> +   uint32_t indir_block;
> +   uint32_t double_indir_block;
> +   uint32_t tripple_indir_block;
> +  } blocks;
> +  char symlink[60];
> + } b;
> + uint32_t version;
> + uint32_t acl;
> + uint32_t dir_acl;
> + uint32_t fragment_addr;
> + uint32_t osd2[3];
> +};
> +
> +/* The header of an ext2 directory entry.  */
> +struct ext2_dirent {
> + uint32_t inode;
> + uint16_t direntlen;
> + uint8_t namelen;
> + uint8_t filetype;
> +};
> +
> +struct ext2fs_node {
> + struct ext2_data *data;
> + struct ext2_inode inode;
> + int ino;
> + int inode_read;
> +};
> +
> +/* Information about a "mounted" ext2 filesystem.  */
> +struct ext2_data {
> + struct ext2_sblock sblock;
> + struct ext2_inode *inode;
> + struct ext2fs_node diropen;
> +};
> +
> +typedef struct ext2fs_node *ext2fs_node_t;
> +extern int ext2fs_iterate_dir(ext2fs_node_t dir, char *name,
> +   ext2fs_node_t *fnode, int *ftype);
> +extern int ext2fs_find_file(const char *path,
> +  ext2fs_node_t rootnode, ext2fs_node_t *foundnode, int expecttype);
> 
> -extern int ext2fs_set_blk_dev(block_dev_desc_t *rbdd, int part);
> -extern int ext2fs_ls (const char *dirname);
> -extern int ext2fs_open (const char *filename);
> -extern int ext2fs_read (char *buf, unsigned len);
> -extern int ext2fs_mount (unsigned part_length);
> -extern int ext2fs_close(void);
> +int ext2fs_set_blk_dev(block_dev_desc_t *rbdd, int part);
> +int ext2fs_ls(const char *dirname);
> +int ext2fs_open(const char *filename);
> +int ext2fs_read(char *buf, unsigned len);
> +int ext2fs_mount(unsigned part_length);
> +int ext2fs_close(void);
> +int ext2_register_device(block_dev_desc_t *dev_desc, int part_no);
> +extern int ext2fs_devread(int sector, int byte_offset, int byte_len, char
> *buf);
> +uint32_t div_roundup(uint32_t size, uint32_t n);
> +void *xmalloc(size_t size);
> +void *xzalloc(size_t size);
> +#endif
> diff --git a/include/ext4fs.h b/include/ext4fs.h
> new file mode 100644
> index 0000000..168acba
> --- /dev/null
> +++ b/include/ext4fs.h
> @@ -0,0 +1,164 @@
> +/*
> + * (C) Copyright 2011 Samsung Electronics
> + * EXT4 filesystem implementation in Uboot by
> + * Uma Shankar <uma.shankar@samsung.com>
> + *
> + *  This program is free software; you can redistribute it and/or modify
> + *  it under the terms of the GNU General Public License as published by
> + *  the Free Software Foundation; either version 2 of the License, or
> + *  (at your option) any later version.
> + *
> + *  This program is distributed in the hope that it will be useful,
> + *  but WITHOUT ANY WARRANTY; without even the implied warranty of
> + *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
> + *  GNU General Public License for more details.
> + *
> + *  You should have received a copy of the GNU General Public License
> + *  along with this program; if not, write to the Free Software
> + *  Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
> + *
> + * Some parts of this code (mainly the structures and defines) are
> + * from the original ext4 fs code, as found in the linux kernel.
> + * Reference for ext4load and ls features have ben taken from GRUB
> + */
> +
> +#ifndef __EXT4__
> +#define __EXT4__
> +
> +#define EXT4_EXTENTS_FLAG      0x80000
> +#define EXT4_EXT_MAGIC       0xf30a
> +#define EXT4_FEATURE_RO_COMPAT_GDT_CSUM 0x0010
> +#define EXT4_FEATURE_INCOMPAT_EXTENTS  0x0040
> +#define EXT4_INDIRECT_BLOCKS     12
> +
> +#define EXT4_BG_INODE_UNINIT  0x0001
> +#define EXT4_BG_BLOCK_UNINIT  0x0002
> +#define EXT4_BG_INODE_ZEROED  0x0004
> +
> +/* The ext4 inode.  */
> +struct ext4_inode {
> + uint16_t mode;
> + uint16_t uid;
> + uint32_t size;
> + uint32_t atime;
> + uint32_t ctime;
> + uint32_t mtime;
> + uint32_t dtime;
> + uint16_t gid;
> + uint16_t nlinks;
> + uint32_t blockcnt; /* Blocks of 512 bytes!! */
> + uint32_t flags;
> + uint32_t osd1;
> + union {
> +  struct data_blocks {
> +   uint32_t dir_blocks[EXT4_INDIRECT_BLOCKS];
> +   uint32_t indir_block;
> +   uint32_t double_indir_block;
> +   uint32_t tripple_indir_block;
> +  } blocks;
> +  char symlink[60];
> + } b;
> + uint32_t version;
> + uint32_t acl;
> + uint32_t dir_acl;
> + uint32_t fragment_addr;
> + uint32_t osd2[3];
> +};
> +
> +/* All fields are little-endian */
> +struct ext4_dir {
> + uint32_t inode1;
> + uint16_t rec_len1;
> + uint8_t name_len1;
> + uint8_t file_type1;
> + char name1[4];
> + uint32_t inode2;
> + uint16_t rec_len2;
> + uint8_t name_len2;
> + uint8_t file_type2;
> + char name2[4];
> + uint32_t inode3;
> + uint16_t rec_len3;
> + uint8_t name_len3;
> + uint8_t file_type3;
> + char name3[12];
> +};
> +
> +struct ext4_extent_header {
> + uint16_t magic;
> + uint16_t entries;
> + uint16_t max;
> + uint16_t depth;
> + uint32_t generation;
> +};
> +
> +struct ext4_extent {
> + uint32_t block;
> + uint16_t len;
> + uint16_t start_hi;
> + uint32_t start;
> +};
> +
> +struct ext4_extent_idx {
> + uint32_t block;
> + uint32_t leaf;
> + uint16_t leaf_hi;
> + uint16_t unused;
> +};
> +
> +typedef struct _ExtFileSystem {
> + /*Total Sector of partition */
> + uint64_t total_sect;
> + /*Block size  of partition */
> + uint32_t blksz;
> + /*Inode size of partition */
> + uint32_t inodesz;
> + /*Sectors per Block */
> + uint32_t sect_perblk;
> + /*Group Descriptor Block Number */
> + uint32_t gdtable_blkno;
> + /*Total block groups of partition */
> + uint32_t no_blkgrp;
> + /*No of blocks required for bgdtable */
> + uint32_t no_blk_pergdt;
> + /*superblock */
> + struct ext2_sblock *sb;
> + /*block group descritpor table */
> + struct ext2_block_group *gd;
> + char *gdtable;
> +
> + /*Block Bitmap Related */
> + unsigned char **blk_bmaps;
> + long int curr_blkno;
> + uint16_t first_pass_bbmap;
> +
> + /*Inode Bitmap Related */
> + unsigned char **inode_bmaps;
> + int curr_inode_no;
> + uint16_t first_pass_ibmap;
> +
> + /*Journal Related */
> +
> + /*Block Device Descriptor */
> + block_dev_desc_t *dev_desc;
> +} ExtFileSystem;
> +
> +/*############################*/
> +extern block_dev_desc_t *ext4_dev_desc;
> +/*#########################*/
> +
> +extern struct ext2_data *ext4fs_root;
> +extern ext2fs_node_t ext4fs_file;
> +ExtFileSystem *get_fs(void);
> +int init_fs(block_dev_desc_t *);
> +void deinit_fs(block_dev_desc_t *);
> +int ext4fs_open(const char *filename);
> +int ext4fs_read(char *buf, unsigned len);
> +int ext4fs_mount(unsigned part_length);
> +int ext4fs_close(void);
> +int ext4fs_ls(const char *dirname);
> +long int read_allocated_block(struct ext4_inode *inode, int fileblock);
> +void ext4fs_free_node(ext2fs_node_t node, ext2fs_node_t currroot);
> +extern int ext2fs_devread(int sector, int byte_offset, int byte_len, char
> *buf);
> +extern void *xzalloc(size_t size);
> +#endif

Regards,

Graeme

Patch

diff --git a/Makefile b/Makefile
index fb658f4..5f29812 100644
--- a/Makefile
+++ b/Makefile
@@ -235,7 +235,7 @@  LIBS += dts/libdts.o
 endif
 LIBS += arch/$(ARCH)/lib/lib$(ARCH).o
 LIBS += fs/cramfs/libcramfs.o fs/fat/libfat.o fs/fdos/libfdos.o 
fs/jffs2/libjffs2.o \
- fs/reiserfs/libreiserfs.o fs/ext2/libext2fs.o fs/yaffs2/libyaffs2.o \
+ fs/reiserfs/libreiserfs.o fs/ext2/libext2fs.o fs/ext4/libext4fs.o 
fs/yaffs2/libyaffs2.o \
  fs/ubifs/libubifs.o
 LIBS += net/libnet.o
 LIBS += disk/libdisk.o
diff --git a/common/Makefile b/common/Makefile
index 1b672ad..d7fd4a8 100644
--- a/common/Makefile
+++ b/common/Makefile
@@ -90,6 +90,7 @@  COBJS-$(CONFIG_CMD_EEPROM) += cmd_eeprom.o
 COBJS-$(CONFIG_CMD_ELF) += cmd_elf.o
 COBJS-$(CONFIG_SYS_HUSH_PARSER) += cmd_exit.o
 COBJS-$(CONFIG_CMD_EXT2) += cmd_ext2.o
+COBJS-$(CONFIG_CMD_EXT4) += cmd_ext4.o
 COBJS-$(CONFIG_CMD_FAT) += cmd_fat.o
 COBJS-$(CONFIG_CMD_FDC)$(CONFIG_CMD_FDOS) += cmd_fdc.o
 COBJS-$(CONFIG_OF_LIBFDT) += cmd_fdt.o fdt_support.o
diff --git a/common/cmd_ext4.c b/common/cmd_ext4.c
new file mode 100644
index 0000000..b223443
--- /dev/null
+++ b/common/cmd_ext4.c
@@ -0,0 +1,255 @@ 
+/*
+ * (C) Copyright 2011 Samsung Electronics
+ * EXT4 filesystem implementation in Uboot by
+ * Uma Shankar <uma.shankar@samsung.com>
+ * Manjunatha C Achar <a.manjunatha@samsung.com>
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License as
+ * published by the Free Software Foundation; either version 2 of
+ * the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston,
+ * MA 02111-1307 USA
+ *
+ */
+
+/*
+ * Ext4fs support
+ * made from existing cmd_ext2.c file of Uboot
+ */
+#include <common.h>
+#include <part.h>
+#include <config.h>
+#include <command.h>
+#include <image.h>
+#include <linux/ctype.h>
+#include <asm/byteorder.h>
+#include <ext2fs.h>
+#include <ext4fs.h>
+#include <linux/stat.h>
+#include "../disk/part_dos.h"
+#include <malloc.h>
+
+#if defined(CONFIG_CMD_USB) && defined(CONFIG_USB_STORAGE)
+#include <usb.h>
+#endif
+
+#if !defined(CONFIG_DOS_PARTITION) && !defined(CONFIG_EFI_PARTITION)
+#error DOS or EFI partition support must be selected
+#endif
+
+uint64_t total_sector;
+uint64_t part_offset;
+static uint64_t part_size;
+static uint16_t cur_part = 1;
+
+#define DOS_PART_MAGIC_OFFSET  0x1fe
+#define DOS_FS_TYPE_OFFSET  0x36
+#define DOS_FS32_TYPE_OFFSET  0x52
+
+int do_ext4_load(cmd_tbl_t *cmdtp, int flag, int argc, char *const argv[])
+{
+ char *filename = NULL;
+ char *ep;
+ int dev, part = 1;
+ ulong addr = 0, part_length;
+ int filelen;
+ disk_partition_t info;
+ ExtFileSystem *fs;
+ char buf[12];
+ unsigned long count;
+ char *addr_str;
+
+ switch (argc) {
+ case 3:
+  addr_str = getenv("loadaddr");
+  if (addr_str != NULL)
+   addr = strict_strtoul(addr_str, NULL, 16);
+  else
+   addr = CONFIG_SYS_LOAD_ADDR;
+
+  filename = getenv("bootfile");
+  count = 0;
+  break;
+ case 4:
+  addr = strict_strtoul(argv[3], NULL, 16);
+  filename = getenv("bootfile");
+  count = 0;
+  break;
+ case 5:
+  addr = strict_strtoul(argv[3], NULL, 16);
+  filename = argv[4];
+  count = 0;
+  break;
+ case 6:
+  addr = strict_strtoul(argv[3], NULL, 16);
+  filename = argv[4];
+  count = strict_strtoul(argv[5], NULL, 16);
+  break;
+
+ default:
+  return cmd_usage(cmdtp);
+ }
+
+ if (!filename) {
+  puts("** No boot file defined **\n");
+  return 1;
+ }
+
+ dev = (int)strict_strtoul(argv[2], &ep, 16);
+ ext4_dev_desc = get_dev(argv[1], dev);
+ if (ext4_dev_desc == NULL) {
+  printf("** Block device %s %d not supported\n", argv[1], dev);
+  return 1;
+ }
+ if (init_fs(ext4_dev_desc))
+  return 1;
+
+ fs = get_fs();
+ if (*ep) {
+  if (*ep != ':') {
+   puts("** Invalid boot device, use `dev[:part]' **\n");
+   return 1;
+  }
+  part = (int)strict_strtoul(++ep, NULL, 16);
+ }
+
+ if (part != 0) {
+  if (get_partition_info(fs->dev_desc, part, &info)) {
+   printf("** Bad partition %d **\n", part);
+   return 1;
+  }
+
+  if (strncmp((char *)info.type, BOOT_PART_TYPE,
+       sizeof(info.type)) != 0) {
+   printf("** Invalid partition type \"%.32s\""
+          " (expect \"" BOOT_PART_TYPE "\")\n", info.type);
+   return 1;
+  }
+  printf("Loading file \"%s\" "
+         "from %s device %d:%d (%.32s)\n",
+         filename, argv[1], dev, part, info.name);
+ } else {
+  printf("Loading file \"%s\" from %s device %d\n",
+         filename, argv[1], dev);
+ }
+
+ part_length = ext2fs_set_blk_dev(fs->dev_desc, part);
+ if (part_length == 0) {
+  printf("**Bad partition - %s %d:%d **\n", argv[1], dev, part);
+  ext4fs_close();
+  return 1;
+ }
+
+ if (!ext4fs_mount(part_length)) {
+  printf("** Bad ext2 partition or disk - %s %d:%d **\n",
+         argv[1], dev, part);
+  ext4fs_close();
+  return 1;
+ }
+
+ filelen = ext4fs_open(filename);
+ if (filelen < 0) {
+  printf("** File not found %s\n", filename);
+  ext4fs_close();
+  return 1;
+ }
+ if ((count < filelen) && (count != 0))
+  filelen = count;
+
+ if (ext4fs_read((char *)addr, filelen) != filelen) {
+  printf("** Unable to read \"%s\" from %s %d:%d **\n",
+         filename, argv[1], dev, part);
+  ext4fs_close();
+  return 1;
+ }
+
+ ext4fs_close();
+ deinit_fs(fs->dev_desc);
+ /* Loading ok, update default load address */
+ load_addr = addr;
+
+ printf("%d bytes read\n", filelen);
+ sprintf(buf, "%X", filelen);
+ setenv("filesize", buf);
+
+ return 0;
+}
+
+int do_ext4_ls(cmd_tbl_t *cmdtp, int flag, int argc, char *const argv[])
+{
+ char *filename = "/";
+ int dev = 0;
+ int part = 1;
+ char *ep;
+ ExtFileSystem *fs;
+ int part_length;
+
+ if (argc < 3)
+  return cmd_usage(cmdtp);
+
+ dev = (int)strict_strtoul(argv[2], &ep, 16);
+ ext4_dev_desc = get_dev(argv[1], dev);
+
+ if (ext4_dev_desc == NULL) {
+  printf("\n** Block device %s %d not supported\n", argv[1], dev);
+  return 1;
+ }
+
+ if (init_fs(ext4_dev_desc))
+  return 1;
+
+ fs = get_fs();
+ if (*ep) {
+  if (*ep != ':') {
+   puts("\n** Invalid boot device, use `dev[:part]' **\n");
+   return 1;
+  }
+  part = (int)strict_strtoul(++ep, NULL, 16);
+ }
+
+ if (argc == 4)
+  filename = argv[3];
+
+ part_length = ext2fs_set_blk_dev(fs->dev_desc, part);
+ if (part_length == 0) {
+  printf("** Bad partition - %s %d:%d **\n", argv[1], dev, part);
+  ext4fs_close();
+  return 1;
+ }
+
+ if (!ext4fs_mount(part_length)) {
+  printf("** Bad ext2 partition or disk - %s %d:%d **\n",
+         argv[1], dev, part);
+  ext4fs_close();
+  return 1;
+ }
+ if (ext4fs_ls(filename)) {
+  printf("** Error ext2fs_ls() **\n");
+  ext4fs_close();
+  return 1;
+ };
+
+ ext4fs_close();
+ deinit_fs(fs->dev_desc);
+ return 0;
+}
+
+U_BOOT_CMD(ext4ls, 4, 1, do_ext4_ls,
+    "list files in a directory (default /)",
+    "<interface> <dev[:part]> [directory]\n"
+    "   - list files from 'dev' on 'interface' in a 'directory'");
+
+U_BOOT_CMD(ext4load, 6, 0, do_ext4_load,
+    "load binary file from a Ext2 filesystem",
+    "<interface> <dev[:part]> [addr] [filename] [bytes]\n"
+    "   - load binary file 'filename' from 'dev' on 'interface'\n"
+    "   to address 'addr' from ext2 filesystem");
diff --git a/fs/Makefile b/fs/Makefile
index 22aad12..27330d4 100644
--- a/fs/Makefile
+++ b/fs/Makefile
@@ -24,6 +24,7 @@ 

 subdirs-$(CONFIG_CMD_CRAMFS) := cramfs
 subdirs-$(CONFIG_CMD_EXT2) += ext2
+subdirs-$(CONFIG_CMD_EXT4) += ext4
 subdirs-$(CONFIG_CMD_FAT) += fat
 subdirs-$(CONFIG_CMD_FDOS) += fdos
 subdirs-$(CONFIG_CMD_JFFS2) += jffs2
diff --git a/fs/ext2/ext2fs.c b/fs/ext2/ext2fs.c
index e119e13..058b650 100644
--- a/fs/ext2/ext2fs.c
+++ b/fs/ext2/ext2fs.c
@@ -25,150 +25,10 @@ 

 #include <common.h>
 #include <ext2fs.h>
+#include <ext4fs.h>
 #include <malloc.h>
 #include <asm/byteorder.h>

-extern int ext2fs_devread (int sector, int byte_offset, int byte_len,
-      char *buf);
-
-/* Magic value used to identify an ext2 filesystem.  */
-#define EXT2_MAGIC  0xEF53
-/* Amount of indirect blocks in an inode.  */
-#define INDIRECT_BLOCKS  12
-/* Maximum lenght of a pathname.  */
-#define EXT2_PATH_MAX  4096
-/* Maximum nesting of symlinks, used to prevent a loop.  */
-#define EXT2_MAX_SYMLINKCNT 8
-
-/* Filetype used in directory entry.  */
-#define FILETYPE_UNKNOWN 0
-#define FILETYPE_REG  1
-#define FILETYPE_DIRECTORY 2
-#define FILETYPE_SYMLINK 7
-
-/* Filetype information as used in inodes.  */
-#define FILETYPE_INO_MASK 0170000
-#define FILETYPE_INO_REG 0100000
-#define FILETYPE_INO_DIRECTORY 0040000
-#define FILETYPE_INO_SYMLINK 0120000
-
-/* Bits used as offset in sector */
-#define DISK_SECTOR_BITS        9
-
-/* Log2 size of ext2 block in 512 blocks.  */
-#define LOG2_EXT2_BLOCK_SIZE(data) (__le32_to_cpu 
(data->sblock.log2_block_size) + 1)
-
-/* Log2 size of ext2 block in bytes.  */
-#define LOG2_BLOCK_SIZE(data)    (__le32_to_cpu 
(data->sblock.log2_block_size) + 10)
-
-/* The size of an ext2 block in bytes.  */
-#define EXT2_BLOCK_SIZE(data)    (1 << LOG2_BLOCK_SIZE(data))
-
-/* The ext2 superblock.  */
-struct ext2_sblock {
- uint32_t total_inodes;
- uint32_t total_blocks;
- uint32_t reserved_blocks;
- uint32_t free_blocks;
- uint32_t free_inodes;
- uint32_t first_data_block;
- uint32_t log2_block_size;
- uint32_t log2_fragment_size;
- uint32_t blocks_per_group;
- uint32_t fragments_per_group;
- uint32_t inodes_per_group;
- uint32_t mtime;
- uint32_t utime;
- uint16_t mnt_count;
- uint16_t max_mnt_count;
- uint16_t magic;
- uint16_t fs_state;
- uint16_t error_handling;
- uint16_t minor_revision_level;
- uint32_t lastcheck;
- uint32_t checkinterval;
- uint32_t creator_os;
- uint32_t revision_level;
- uint16_t uid_reserved;
- uint16_t gid_reserved;
- uint32_t first_inode;
- uint16_t inode_size;
- uint16_t block_group_number;
- uint32_t feature_compatibility;
- uint32_t feature_incompat;
- uint32_t feature_ro_compat;
- uint32_t unique_id[4];
- char volume_name[16];
- char last_mounted_on[64];
- uint32_t compression_info;
-};
-
-/* The ext2 blockgroup.  */
-struct ext2_block_group {
- uint32_t block_id;
- uint32_t inode_id;
- uint32_t inode_table_id;
- uint16_t free_blocks;
- uint16_t free_inodes;
- uint16_t used_dir_cnt;
- uint32_t reserved[3];
-};
-
-/* The ext2 inode.  */
-struct ext2_inode {
- uint16_t mode;
- uint16_t uid;
- uint32_t size;
- uint32_t atime;
- uint32_t ctime;
- uint32_t mtime;
- uint32_t dtime;
- uint16_t gid;
- uint16_t nlinks;
- uint32_t blockcnt; /* Blocks of 512 bytes!! */
- uint32_t flags;
- uint32_t osd1;
- union {
-  struct datablocks {
-   uint32_t dir_blocks[INDIRECT_BLOCKS];
-   uint32_t indir_block;
-   uint32_t double_indir_block;
-   uint32_t tripple_indir_block;
-  } blocks;
-  char symlink[60];
- } b;
- uint32_t version;
- uint32_t acl;
- uint32_t dir_acl;
- uint32_t fragment_addr;
- uint32_t osd2[3];
-};
-
-/* The header of an ext2 directory entry.  */
-struct ext2_dirent {
- uint32_t inode;
- uint16_t direntlen;
- uint8_t namelen;
- uint8_t filetype;
-};
-
-struct ext2fs_node {
- struct ext2_data *data;
- struct ext2_inode inode;
- int ino;
- int inode_read;
-};
-
-/* Information about a "mounted" ext2 filesystem.  */
-struct ext2_data {
- struct ext2_sblock sblock;
- struct ext2_inode *inode;
- struct ext2fs_node diropen;
-};
-
-
-typedef struct ext2fs_node *ext2fs_node_t;
-
 struct ext2_data *ext2fs_root = NULL;
 ext2fs_node_t ext2fs_file = NULL;
 int symlinknest = 0;
@@ -180,7 +40,6 @@  int indir2_size = 0;
 int indir2_blkno = -1;
 static unsigned int inode_size;

-
 static int ext2fs_blockgroup
  (struct ext2_data *data, int group, struct ext2_block_group *blkgrp) {
  unsigned int blkno;
@@ -198,10 +57,8 @@  static int ext2fs_blockgroup
 #endif
  return (ext2fs_devread (blkno << LOG2_EXT2_BLOCK_SIZE(data),
   blkoff, sizeof(struct ext2_block_group), (char *)blkgrp));
-
 }

-
 static int ext2fs_read_inode
  (struct ext2_data *data, int ino, struct ext2_inode *inode) {
  struct ext2_block_group blkgrp;
@@ -242,153 +99,12 @@  static int ext2fs_read_inode
  return (1);
 }

-
 void ext2fs_free_node (ext2fs_node_t node, ext2fs_node_t currroot) {
  if ((node != &ext2fs_root->diropen) && (node != currroot)) {
   free (node);
  }
 }

-
-static int ext2fs_read_block (ext2fs_node_t node, int fileblock) {
- struct ext2_data *data = node->data;
- struct ext2_inode *inode = &node->inode;
- int blknr;
- int blksz = EXT2_BLOCK_SIZE (data);
- int log2_blksz = LOG2_EXT2_BLOCK_SIZE (data);
- int status;
-
- /* Direct blocks.  */
- if (fileblock < INDIRECT_BLOCKS) {
-  blknr = __le32_to_cpu (inode->b.blocks.dir_blocks[fileblock]);
- }
- /* Indirect.  */
- else if (fileblock < (INDIRECT_BLOCKS + (blksz / 4))) {
-  if (indir1_block == NULL) {
-   indir1_block = (uint32_t *) malloc (blksz);
-   if (indir1_block == NULL) {
-    printf ("** ext2fs read block (indir 1) malloc failed. **\n");
-    return (-1);
-   }
-   indir1_size = blksz;
-   indir1_blkno = -1;
-  }
-  if (blksz != indir1_size) {
-   free (indir1_block);
-   indir1_block = NULL;
-   indir1_size = 0;
-   indir1_blkno = -1;
-   indir1_block = (uint32_t *) malloc (blksz);
-   if (indir1_block == NULL) {
-    printf ("** ext2fs read block (indir 1) malloc failed. **\n");
-    return (-1);
-   }
-   indir1_size = blksz;
-  }
-  if ((__le32_to_cpu (inode->b.blocks.indir_block) <<
-       log2_blksz) != indir1_blkno) {
-   status = ext2fs_devread (__le32_to_cpu(inode->b.blocks.indir_block) << 
log2_blksz,
-       0, blksz,
-       (char *) indir1_block);
-   if (status == 0) {
-    printf ("** ext2fs read block (indir 1) failed. **\n");
-    return (0);
-   }
-   indir1_blkno =
-    __le32_to_cpu (inode->b.blocks.
-            indir_block) << log2_blksz;
-  }
-  blknr = __le32_to_cpu (indir1_block
-           [fileblock - INDIRECT_BLOCKS]);
- }
- /* Double indirect.  */
- else if (fileblock <
-   (INDIRECT_BLOCKS + (blksz / 4 * (blksz / 4 + 1)))) {
-  unsigned int perblock = blksz / 4;
-  unsigned int rblock = fileblock - (INDIRECT_BLOCKS
-         + blksz / 4);
-
-  if (indir1_block == NULL) {
-   indir1_block = (uint32_t *) malloc (blksz);
-   if (indir1_block == NULL) {
-    printf ("** ext2fs read block (indir 2 1) malloc failed. **\n");
-    return (-1);
-   }
-   indir1_size = blksz;
-   indir1_blkno = -1;
-  }
-  if (blksz != indir1_size) {
-   free (indir1_block);
-   indir1_block = NULL;
-   indir1_size = 0;
-   indir1_blkno = -1;
-   indir1_block = (uint32_t *) malloc (blksz);
-   if (indir1_block == NULL) {
-    printf ("** ext2fs read block (indir 2 1) malloc failed. **\n");
-    return (-1);
-   }
-   indir1_size = blksz;
-  }
-  if ((__le32_to_cpu (inode->b.blocks.double_indir_block) <<
-       log2_blksz) != indir1_blkno) {
-   status = ext2fs_devread 
(__le32_to_cpu(inode->b.blocks.double_indir_block) << log2_blksz,
-      0, blksz,
-      (char *) indir1_block);
-   if (status == 0) {
-    printf ("** ext2fs read block (indir 2 1) failed. **\n");
-    return (-1);
-   }
-   indir1_blkno =
-    __le32_to_cpu (inode->b.blocks.double_indir_block) << log2_blksz;
-  }
-
-  if (indir2_block == NULL) {
-   indir2_block = (uint32_t *) malloc (blksz);
-   if (indir2_block == NULL) {
-    printf ("** ext2fs read block (indir 2 2) malloc failed. **\n");
-    return (-1);
-   }
-   indir2_size = blksz;
-   indir2_blkno = -1;
-  }
-  if (blksz != indir2_size) {
-   free (indir2_block);
-   indir2_block = NULL;
-   indir2_size = 0;
-   indir2_blkno = -1;
-   indir2_block = (uint32_t *) malloc (blksz);
-   if (indir2_block == NULL) {
-    printf ("** ext2fs read block (indir 2 2) malloc failed. **\n");
-    return (-1);
-   }
-   indir2_size = blksz;
-  }
-  if ((__le32_to_cpu (indir1_block[rblock / perblock]) <<
-       log2_blksz) != indir2_blkno) {
-   status = ext2fs_devread (__le32_to_cpu(indir1_block[rblock / perblock]) 
<< log2_blksz,
-       0, blksz,
-       (char *) indir2_block);
-   if (status == 0) {
-    printf ("** ext2fs read block (indir 2 2) failed. **\n");
-    return (-1);
-   }
-   indir2_blkno =
-    __le32_to_cpu (indir1_block[rblock / perblock]) << log2_blksz;
-  }
-  blknr = __le32_to_cpu (indir2_block[rblock % perblock]);
- }
- /* Tripple indirect.  */
- else {
-  printf ("** ext2fs doesn't support tripple indirect blocks. **\n");
-  return (-1);
- }
-#ifdef DEBUG
- printf ("ext2fs_read_block %08x\n", blknr);
-#endif
- return (blknr);
-}
-
-
 int ext2fs_read_file
  (ext2fs_node_t node, int pos, unsigned int len, char *buf) {
  int i;
@@ -409,8 +125,7 @@  int ext2fs_read_file
   int blockend = blocksize;

   int skipfirst = 0;
-
-  blknr = ext2fs_read_block (node, i);
+  blknr = read_allocated_block(&(node->inode), i);
   if (blknr < 0) {
    return (-1);
   }
@@ -449,8 +164,8 @@  int ext2fs_read_file
  return (len);
 }

-
-static int ext2fs_iterate_dir (ext2fs_node_t dir, char *name, ext2fs_node_t 
* fnode, int *ftype)
+int ext2fs_iterate_dir(ext2fs_node_t dir, char *name,
+     ext2fs_node_t *fnode, int *ftype)
 {
  unsigned int fpos = 0;
  int status;
@@ -581,7 +296,6 @@  static int ext2fs_iterate_dir (ext2fs_node_t dir, char 
*name, ext2fs_node_t * fn
  return (0);
 }

-
 static char *ext2fs_read_symlink (ext2fs_node_t node) {
  char *symlink;
  struct ext2fs_node *diro = node;
@@ -617,7 +331,6 @@  static char *ext2fs_read_symlink (ext2fs_node_t node) {
  return (symlink);
 }

-
 int ext2fs_find_file1
  (const char *currpath,
   ext2fs_node_t currroot, ext2fs_node_t * currfound, int *foundtype) {
@@ -721,7 +434,6 @@  int ext2fs_find_file1
  return (-1);
 }

-
 int ext2fs_find_file
  (const char *path,
   ext2fs_node_t rootnode, ext2fs_node_t * foundnode, int expecttype) {
@@ -748,7 +460,6 @@  int ext2fs_find_file
  return (1);
 }

-
 int ext2fs_ls (const char *dirname) {
  ext2fs_node_t dirnode;
  int status;
@@ -768,7 +479,6 @@  int ext2fs_ls (const char *dirname) {
  return (0);
 }

-
 int ext2fs_open (const char *filename) {
  ext2fs_node_t fdiro = NULL;
  int status;
@@ -799,7 +509,6 @@  fail:
  return (-1);
 }

-
 int ext2fs_close (void
  ) {
  if ((ext2fs_file != NULL) && (ext2fs_root != NULL)) {
@@ -825,7 +534,6 @@  int ext2fs_close (void
  return (0);
 }

-
 int ext2fs_read (char *buf, unsigned len) {
  int status;

@@ -836,12 +544,10 @@  int ext2fs_read (char *buf, unsigned len) {
  if (ext2fs_file == NULL) {
   return (0);
  }
-
  status = ext2fs_read_file (ext2fs_file, 0, len, buf);
  return (status);
 }

-
 int ext2fs_mount (unsigned part_length) {
  struct ext2_data *data;
  int status;
@@ -880,7 +586,6 @@  int ext2fs_mount (unsigned part_length) {
  }

  ext2fs_root = data;
-
  return (1);

 fail:
diff --git a/fs/ext4/Makefile b/fs/ext4/Makefile
new file mode 100644
index 0000000..850f821
--- /dev/null
+++ b/fs/ext4/Makefile
@@ -0,0 +1,51 @@ 
+#
+# (C) Copyright 2006
+# Wolfgang Denk, DENX Software Engineering, wd@denx.de.
+#
+# (C) Copyright 2003
+# Pavel Bartusek, Sysgo Real-Time Solutions AG, pba@sysgo.de
+#
+#
+# See file CREDITS for list of people who contributed to this
+# project.
+#
+# This program is free software; you can redistribute it and/or
+# modify it under the terms of the GNU General Public License as
+# published by the Free Software Foundation; either version 2 of
+# the License, or (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program; if not, write to the Free Software
+# Foundation, Inc., 59 Temple Place, Suite 330, Boston,
+# MA 02111-1307 USA
+#
+
+include $(TOPDIR)/config.mk
+
+LIB = $(obj)libext4fs.o
+
+AOBJS =
+COBJS-$(CONFIG_CMD_EXT4) := ext4fs.o ext4_common.o
+
+SRCS := $(AOBJS:.o=.S) $(COBJS-y:.o=.c)
+OBJS := $(addprefix $(obj),$(AOBJS) $(COBJS-y))
+
+
+all: $(LIB) $(AOBJS)
+
+$(LIB): $(obj).depend $(OBJS)
+ $(call cmd_link_o_target, $(OBJS))
+
+#########################################################################
+
+# defines $(obj).depend target
+include $(SRCTREE)/rules.mk
+
+sinclude $(obj).depend
+
+#########################################################################
diff --git a/fs/ext4/ext4_common.c b/fs/ext4/ext4_common.c
new file mode 100644
index 0000000..39321f6
--- /dev/null
+++ b/fs/ext4/ext4_common.c
@@ -0,0 +1,572 @@ 
+/*
+ * (C) Copyright 2011 Samsung Electronics
+ * EXT4 filesystem implementation in Uboot by
+ * Uma Shankar <uma.shankar@samsung.com>
+ * Manjunatha C Achar <a.manjunatha@samsung.com>
+ *
+ *  Copyright (C) 2003, 2004  Free Software Foundation, Inc.
+ *  This program is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation; either version 2 of the License, or
+ *  (at your option) any later version.
+ *
+ *  This program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with this program; if not, write to the Free Software
+ *  Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+/*
+ *  ext4load - based on code from GRUB2  fs/ext2.c
+*/
+#include <common.h>
+#include <ext2fs.h>
+#include <ext4fs.h>
+#include <malloc.h>
+#include <asm/byteorder.h>
+#include <linux/stat.h>
+#include <linux/time.h>
+#include "ext4_common.h"
+
+struct ext2_data *ext4fs_root;
+ext2fs_node_t ext4fs_file;
+uint32_t *ext4fs_indir1_block;
+int ext4fs_indir1_size;
+int ext4fs_indir1_blkno = -1;
+uint32_t *ext4fs_indir2_block;
+int ext4fs_indir2_size;
+int ext4fs_indir2_blkno = -1;
+
+uint32_t *ext4fs_indir3_block;
+int ext4fs_indir3_size;
+int ext4fs_indir3_blkno = -1;
+struct ext4_inode *g_parent_inode;
+
+#ifndef offsetof
+#define offsetof(TYPE, MEMBER) ((size_t) &((TYPE *)0)->MEMBER)
+#endif
+
+void *xmalloc(size_t size)
+{
+ void *ptr = malloc(size);
+ if (ptr == NULL && size != 0)
+  printf("bb_msg_memory_exhausted\n");
+ return ptr;
+}
+
+void *xzalloc(size_t size)
+{
+ void *ptr = xmalloc(size);
+ memset(ptr, 0, size);
+ return ptr;
+}
+
+static struct ext4_extent_header *ext4fs_find_leaf(struct ext2_data *data,
+ char *buf, struct ext4_extent_header *ext_block, uint32_t fileblock)
+{
+ struct ext4_extent_idx *index;
+ unsigned long long block;
+ int i;
+
+ while (1) {
+  index = (struct ext4_extent_idx *)(ext_block + 1);
+
+  if (le32_to_cpu(ext_block->magic) != EXT4_EXT_MAGIC)
+   return 0;
+
+  if (ext_block->depth == 0)
+   return ext_block;
+
+  for (i = 0; i < le32_to_cpu(ext_block->entries); i++) {
+   if (fileblock < le32_to_cpu(index[i].block))
+    break;
+  }
+
+  if (--i < 0)
+   return 0;
+
+  block = le32_to_cpu(index[i].leaf_hi);
+  block = (block << 32) + le32_to_cpu(index[i].leaf);
+
+  if (ext2fs_devread(block << LOG2_EXT2_BLOCK_SIZE(data),
+       0, EXT2_BLOCK_SIZE(data), buf)) {
+   ext_block = (struct ext4_extent_header *)buf;
+   return ext_block;
+  } else
+   return 0;
+ }
+}
+
+static int ext4fs_blockgroup
+ (struct ext2_data *data, int group, struct ext2_block_group *blkgrp)
+{
+ long int blkno;
+ unsigned int blkoff, desc_per_blk;
+
+ desc_per_blk = EXT2_BLOCK_SIZE(data) / sizeof(struct ext2_block_group);
+
+ blkno = __le32_to_cpu(data->sblock.first_data_block) + 1
+     + group / desc_per_blk;
+ blkoff = (group % desc_per_blk) * sizeof(struct ext2_block_group);
+
+ debug("ext4fs read %d group descriptor (blkno %ld blkoff %u)\n",
+       group, blkno, blkoff);
+
+ return ext2fs_devread(blkno << LOG2_EXT2_BLOCK_SIZE(data),
+  blkoff, sizeof(struct ext2_block_group), (char *)blkgrp);
+}
+
+int ext4fs_read_inode(struct ext2_data *data, int ino, struct ext4_inode 
*inode)
+{
+ struct ext2_block_group blkgrp;
+ struct ext2_sblock *sblock = &data->sblock;
+ ExtFileSystem *fs = get_fs();
+ int inodes_per_block, status;
+ long int blkno;
+ unsigned int blkoff;
+
+ /* It is easier to calculate if the first inode is 0.  */
+ ino--;
+ status = ext4fs_blockgroup(data, ino / __le32_to_cpu
+       (sblock->inodes_per_group), &blkgrp);
+
+ if (status == 0)
+  return 0;
+
+ inodes_per_block = EXT2_BLOCK_SIZE(data) / fs->inodesz;
+
+ blkno = __le32_to_cpu(blkgrp.inode_table_id) +
+     (ino % __le32_to_cpu(sblock->inodes_per_group))
+     / inodes_per_block;
+ blkoff = (ino % inodes_per_block) * fs->inodesz;
+ /* Read the inode.  */
+ status = ext2fs_devread(blkno << LOG2_EXT2_BLOCK_SIZE(data), blkoff,
+    sizeof(struct ext4_inode), (char *)inode);
+ if (status == 0)
+  return 0;
+
+ return 1;
+}
+
+long int read_allocated_block(struct ext4_inode *inode, int fileblock)
+{
+ long int blknr;
+ int blksz;
+ int log2_blksz;
+ int status;
+ long int rblock;
+ long int perblock_parent;
+ long int perblock_child;
+ unsigned long long start;
+ /*get the blocksize of the filesystem */
+ blksz = EXT2_BLOCK_SIZE(ext4fs_root);
+ log2_blksz = LOG2_EXT2_BLOCK_SIZE(ext4fs_root);
+
+ if (le32_to_cpu(inode->flags) & EXT4_EXTENTS_FLAG) {
+  char buf[EXT2_BLOCK_SIZE(ext4fs_root)];
+  struct ext4_extent_header *leaf;
+  struct ext4_extent *ext;
+  int i;
+
+  leaf = ext4fs_find_leaf(ext4fs_root, buf,
+     (struct ext4_extent_header *)inode->
+     b.blocks.dir_blocks, fileblock);
+  if (!leaf) {
+   printf("invalid extent\n");
+   return -1;
+  }
+
+  ext = (struct ext4_extent *)(leaf + 1);
+
+  for (i = 0; i < le32_to_cpu(leaf->entries); i++) {
+   if (fileblock < le32_to_cpu(ext[i].block))
+    break;
+  }
+
+  if (--i >= 0) {
+   fileblock -= le32_to_cpu(ext[i].block);
+   if (fileblock >= le32_to_cpu(ext[i].len)) {
+    return 0;
+   } else {
+    start = le32_to_cpu(ext[i].start_hi);
+    start = (start << 32) +
+        le32_to_cpu(ext[i].start);
+    return fileblock + start;
+   }
+  } else {
+   printf("something wrong with extent\n");
+   return -1;
+  }
+ }
+
+ /* Direct blocks.  */
+ if (fileblock < INDIRECT_BLOCKS)
+  blknr = __le32_to_cpu(inode->b.blocks.dir_blocks[fileblock]);
+
+ /* Indirect.  */
+ else if (fileblock < (INDIRECT_BLOCKS + (blksz / 4))) {
+  if (ext4fs_indir1_block == NULL) {
+   ext4fs_indir1_block = (uint32_t *) malloc(blksz);
+   if (ext4fs_indir1_block == NULL) {
+    printf("** SI ext2fs read block (indir 1) \
+     malloc failed. **\n");
+    return -1;
+   }
+   ext4fs_indir1_size = blksz;
+   ext4fs_indir1_blkno = -1;
+  }
+  if (blksz != ext4fs_indir1_size) {
+   free(ext4fs_indir1_block);
+   ext4fs_indir1_block = NULL;
+   ext4fs_indir1_size = 0;
+   ext4fs_indir1_blkno = -1;
+   ext4fs_indir1_block = (uint32_t *) malloc(blksz);
+   if (ext4fs_indir1_block == NULL) {
+    printf("** SI ext2fs read block (indir 1) \
+     malloc failed. **\n");
+    return -1;
+   }
+   ext4fs_indir1_size = blksz;
+  }
+  if ((__le32_to_cpu(inode->b.blocks.indir_block) <<
+       log2_blksz) != ext4fs_indir1_blkno) {
+   status = ext2fs_devread(__le32_to_cpu(inode->b.blocks.
+     indir_block) << log2_blksz, 0, blksz,
+      (char *) ext4fs_indir1_block);
+   if (status == 0) {
+    printf("** SI ext2fs read block (indir 1) \
+     failed. **\n");
+    return 0;
+   }
+   ext4fs_indir1_blkno =
+    __le32_to_cpu(inode->b.blocks.
+            indir_block) << log2_blksz;
+  }
+  blknr = __le32_to_cpu(ext4fs_indir1_block
+          [fileblock - INDIRECT_BLOCKS]);
+ }
+ /* Double indirect.  */
+ else if (fileblock <
+   (INDIRECT_BLOCKS + (blksz / 4 * (blksz / 4 + 1)))) {
+
+  long int perblock = blksz / 4;
+  long int rblock = fileblock - (INDIRECT_BLOCKS + blksz / 4);
+
+  if (ext4fs_indir1_block == NULL) {
+   ext4fs_indir1_block = (uint32_t *) malloc(blksz);
+   if (ext4fs_indir1_block == NULL) {
+    printf("** DI ext2fs read block (indir 2 1) \
+     malloc failed. **\n");
+    return -1;
+   }
+   ext4fs_indir1_size = blksz;
+   ext4fs_indir1_blkno = -1;
+  }
+  if (blksz != ext4fs_indir1_size) {
+   free(ext4fs_indir1_block);
+   ext4fs_indir1_block = NULL;
+   ext4fs_indir1_size = 0;
+   ext4fs_indir1_blkno = -1;
+   ext4fs_indir1_block = (uint32_t *) malloc(blksz);
+   if (ext4fs_indir1_block == NULL) {
+    printf("** DI ext2fs read block (indir 2 1) \
+     malloc failed. **\n");
+    return -1;
+   }
+   ext4fs_indir1_size = blksz;
+  }
+  if ((__le32_to_cpu(inode->b.blocks.double_indir_block) <<
+       log2_blksz) != ext4fs_indir1_blkno) {
+   status = ext2fs_devread(__le32_to_cpu(inode->b.blocks.
+   double_indir_block) << log2_blksz, 0, blksz,
+    (char *) ext4fs_indir1_block);
+   if (status == 0) {
+    printf("** DI ext2fs read block (indir 2 1) \
+     failed. **\n");
+    return -1;
+   }
+   ext4fs_indir1_blkno =
+   __le32_to_cpu(inode->b.blocks.
+   double_indir_block) << log2_blksz;
+  }
+
+  if (ext4fs_indir2_block == NULL) {
+   ext4fs_indir2_block = (uint32_t *) malloc(blksz);
+   if (ext4fs_indir2_block == NULL) {
+    printf("** DI ext2fs read block (indir 2 2) \
+     malloc failed. **\n");
+    return -1;
+   }
+   ext4fs_indir2_size = blksz;
+   ext4fs_indir2_blkno = -1;
+  }
+  if (blksz != ext4fs_indir2_size) {
+   free(ext4fs_indir2_block);
+   ext4fs_indir2_block = NULL;
+   ext4fs_indir2_size = 0;
+   ext4fs_indir2_blkno = -1;
+   ext4fs_indir2_block = (uint32_t *) malloc(blksz);
+   if (ext4fs_indir2_block == NULL) {
+    printf("** DI ext2fs read block (indir 2 2) \
+     malloc failed. **\n");
+    return -1;
+   }
+   ext4fs_indir2_size = blksz;
+  }
+  if ((__le32_to_cpu(ext4fs_indir1_block[rblock / perblock]) <<
+       log2_blksz) != ext4fs_indir2_blkno) {
+   status = ext2fs_devread(__le32_to_cpu
+      (ext4fs_indir1_block
+   [rblock / perblock]) << log2_blksz,
+   0, blksz, (char *) ext4fs_indir2_block);
+   if (status == 0) {
+    printf("** DI ext2fs read block (indir 2 2) \
+     failed. **\n");
+    return -1;
+   }
+   ext4fs_indir2_blkno =
+   __le32_to_cpu(ext4fs_indir1_block[rblock
+   / perblock]) << log2_blksz;
+  }
+  blknr = __le32_to_cpu(ext4fs_indir2_block[rblock % perblock]);
+ }
+ /* Tripple indirect.  */
+ else {
+  rblock = fileblock - (INDIRECT_BLOCKS + blksz / 4 +
+          (blksz / 4 * blksz / 4));
+  perblock_child = blksz / 4;
+  perblock_parent = ((blksz / 4) * (blksz / 4));
+
+  if (ext4fs_indir1_block == NULL) {
+   ext4fs_indir1_block = (uint32_t *) malloc(blksz);
+   if (ext4fs_indir1_block == NULL) {
+    printf("** TI ext2fs read block (indir 2 1) \
+     malloc failed. **\n");
+    return -1;
+   }
+   ext4fs_indir1_size = blksz;
+   ext4fs_indir1_blkno = -1;
+  }
+  if (blksz != ext4fs_indir1_size) {
+   free(ext4fs_indir1_block);
+   ext4fs_indir1_block = NULL;
+   ext4fs_indir1_size = 0;
+   ext4fs_indir1_blkno = -1;
+   ext4fs_indir1_block = (uint32_t *) malloc(blksz);
+   if (ext4fs_indir1_block == NULL) {
+    printf("** TI ext2fs read block (indir 2 1) \
+     malloc failed. **\n");
+    return -1;
+   }
+   ext4fs_indir1_size = blksz;
+  }
+  if ((__le32_to_cpu(inode->b.blocks.tripple_indir_block) <<
+       log2_blksz) != ext4fs_indir1_blkno) {
+   status = ext2fs_devread
+   (__le32_to_cpu(inode->b.blocks.
+   tripple_indir_block) << log2_blksz,
+   0, blksz, (char *) ext4fs_indir1_block);
+   if (status == 0) {
+    printf("** TI ext2fs read block (indir 2 1) \
+     failed. **\n");
+    return -1;
+   }
+   ext4fs_indir1_blkno =
+    __le32_to_cpu(inode->b.blocks.
+    tripple_indir_block) << log2_blksz;
+  }
+
+  if (ext4fs_indir2_block == NULL) {
+   ext4fs_indir2_block = (uint32_t *) malloc(blksz);
+   if (ext4fs_indir2_block == NULL) {
+    printf("** TI ext2fs read block (indir 2 2) \
+     malloc failed. **\n");
+    return -1;
+   }
+   ext4fs_indir2_size = blksz;
+   ext4fs_indir2_blkno = -1;
+  }
+  if (blksz != ext4fs_indir2_size) {
+   free(ext4fs_indir2_block);
+   ext4fs_indir2_block = NULL;
+   ext4fs_indir2_size = 0;
+   ext4fs_indir2_blkno = -1;
+   ext4fs_indir2_block = (uint32_t *) malloc(blksz);
+   if (ext4fs_indir2_block == NULL) {
+    printf("** TI ext2fs read block (indir 2 2) \
+     malloc failed. **\n");
+    return -1;
+   }
+   ext4fs_indir2_size = blksz;
+  }
+  if ((__le32_to_cpu(ext4fs_indir1_block[rblock /
+   perblock_parent]) << log2_blksz)
+      != ext4fs_indir2_blkno) {
+   status = ext2fs_devread(__le32_to_cpu
+      (ext4fs_indir1_block
+   [rblock / perblock_parent]) << log2_blksz,
+   0, blksz, (char *) ext4fs_indir2_block);
+   if (status == 0) {
+    printf("** TI ext2fs read block (indir 2 2) \
+     failed. **\n");
+    return -1;
+   }
+   ext4fs_indir2_blkno =
+   __le32_to_cpu(ext4fs_indir1_block[rblock /
+    perblock_parent]) << log2_blksz;
+  }
+
+  if (ext4fs_indir3_block == NULL) {
+   ext4fs_indir3_block = (uint32_t *) malloc(blksz);
+   if (ext4fs_indir3_block == NULL) {
+    printf("** TI ext2fs read block (indir 2 2) \
+     malloc failed. **\n");
+    return -1;
+   }
+   ext4fs_indir3_size = blksz;
+   ext4fs_indir3_blkno = -1;
+  }
+  if (blksz != ext4fs_indir3_size) {
+   free(ext4fs_indir3_block);
+   ext4fs_indir3_block = NULL;
+   ext4fs_indir3_size = 0;
+   ext4fs_indir3_blkno = -1;
+   ext4fs_indir3_block = (uint32_t *) malloc(blksz);
+   if (ext4fs_indir3_block == NULL) {
+    printf("** TI ext2fs read block (indir 2 2) \
+     malloc failed. **\n");
+    return -1;
+   }
+   ext4fs_indir3_size = blksz;
+  }
+  if ((__le32_to_cpu(ext4fs_indir2_block[rblock
+  / perblock_child]) << log2_blksz) != ext4fs_indir3_blkno){
+   status = ext2fs_devread(__le32_to_cpu
+   (ext4fs_indir2_block[(rblock / perblock_child)
+   % (blksz / 4)]) << log2_blksz,
+   0, blksz, (char *) ext4fs_indir3_block);
+   if (status == 0) {
+    printf("** TI ext2fs read block (indir 2 2) \
+     failed. **\n");
+    return -1;
+   }
+   ext4fs_indir3_blkno =
+       __le32_to_cpu(ext4fs_indir2_block[(rblock /
+   perblock_child) % (blksz / 4)]) << log2_blksz;
+  }
+
+  blknr = __le32_to_cpu(ext4fs_indir3_block
+          [rblock % perblock_child]);
+ }
+ debug("ext4fs_read_block %08x\n", blknr);
+ return blknr;
+}
+
+int ext4fs_close(void)
+{
+ if ((ext4fs_file != NULL) && (ext4fs_root != NULL)) {
+  ext4fs_free_node(ext4fs_file, &ext4fs_root->diropen);
+  ext4fs_file = NULL;
+ }
+ if (ext4fs_root != NULL) {
+  free(ext4fs_root);
+  ext4fs_root = NULL;
+ }
+ if (ext4fs_indir1_block != NULL) {
+  free(ext4fs_indir1_block);
+  ext4fs_indir1_block = NULL;
+  ext4fs_indir1_size = 0;
+  ext4fs_indir1_blkno = -1;
+ }
+ if (ext4fs_indir2_block != NULL) {
+  free(ext4fs_indir2_block);
+  ext4fs_indir2_block = NULL;
+  ext4fs_indir2_size = 0;
+  ext4fs_indir2_blkno = -1;
+ }
+ return 0;
+}
+
+int ext4fs_open(const char *filename)
+{
+ ext2fs_node_t fdiro = NULL;
+ int status;
+ int len;
+
+ if (ext4fs_root == NULL)
+  return -1;
+
+ ext4fs_file = NULL;
+ status = ext2fs_find_file(filename, &ext4fs_root->diropen, &fdiro,
+      FILETYPE_REG);
+ if (status == 0)
+  goto fail;
+
+ if (!fdiro->inode_read) {
+  status = ext4fs_read_inode(fdiro->data, fdiro->ino,
+        (struct ext4_inode *)&fdiro->inode);
+  if (status == 0)
+   goto fail;
+ }
+ len = __le32_to_cpu(fdiro->inode.size);
+ ext4fs_file = fdiro;
+ return len;
+
+fail:
+ ext4fs_free_node(fdiro, &ext4fs_root->diropen);
+ return -1;
+}
+
+int ext4fs_mount(unsigned part_length)
+{
+ struct ext2_data *data;
+ int status;
+ ExtFileSystem *fs = get_fs();
+ data = malloc(sizeof(struct ext2_data));
+ if (!data)
+  return 0;
+
+ /* Read the superblock.  */
+ status = ext2fs_devread(1 * 2, 0, sizeof(struct ext2_sblock),
+    (char *)&data->sblock);
+
+ if (status == 0)
+  goto fail;
+
+ /* Make sure this is an ext2 filesystem.  */
+ if (__le16_to_cpu(data->sblock.magic) != EXT2_MAGIC)
+  goto fail;
+
+ if (__le32_to_cpu(data->sblock.revision_level == 0))
+  fs->inodesz = 128;
+ else
+  fs->inodesz = __le16_to_cpu(data->sblock.inode_size);
+
+#ifdef DEBUG
+ printf("EXT2 rev %d, inode_size %d\n",
+        __le32_to_cpu(data->sblock.revision_level), fs->inodesz);
+#endif
+ data->diropen.data = data;
+ data->diropen.ino = 2;
+ data->diropen.inode_read = 1;
+ data->inode = &data->diropen.inode;
+
+ status = ext4fs_read_inode(data, 2, (struct ext4_inode *)data->inode);
+ if (status == 0)
+  goto fail;
+
+ ext4fs_root = data;
+ ext2fs_mount(part_length);
+ return 1;
+
+fail:
+ printf("Failed to mount ext2 filesystem...\n");
+ free(data);
+
+ ext4fs_root = NULL;
+ return 0;
+}
diff --git a/fs/ext4/ext4_common.h b/fs/ext4/ext4_common.h
new file mode 100644
index 0000000..2014298
--- /dev/null
+++ b/fs/ext4/ext4_common.h
@@ -0,0 +1,44 @@ 
+/*
+ * (C) Copyright 2011 Samsung Electronics
+ * EXT4 filesystem implementation in Uboot by
+ * Uma Shankar <uma.shankar@samsung.com>
+ * Manjunatha C Achar <a.manjunatha@samsung.com>
+ *
+ *  Copyright (C) 2003, 2004  Free Software Foundation, Inc.
+ *  This program is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation; either version 2 of the License, or
+ *  (at your option) any later version.
+ *
+ *  This program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with this program; if not, write to the Free Software
+ *  Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+#ifndef __EXT4_COMMON__
+#define __EXT4_COMMON__
+#include <ext2fs.h>
+#include <ext4fs.h>
+
+#define YES  1
+#define NO  0
+#define TRUE  1
+#define FALSE  0
+#define RECOVER  1
+#define SCAN  0
+
+#define S_IFLNK   0120000 /* symbolic link */
+#define BLOCK_NO_ONE  1
+#define SUPERBLOCK_SECTOR 2
+#define SUPERBLOCK_SIZE  1024
+#define F_FILE   1
+
+extern unsigned long part_offset;
+int ext4fs_read_inode(struct ext2_data *data, int ino,
+        struct ext4_inode *inode);
+#endif
diff --git a/fs/ext4/ext4fs.c b/fs/ext4/ext4fs.c
new file mode 100644
index 0000000..890aaf3
--- /dev/null
+++ b/fs/ext4/ext4fs.c
@@ -0,0 +1,215 @@ 
+/*
+ * (C) Copyright 2011 Samsung Electronics
+ * EXT4 filesystem implementation in Uboot by
+ * Uma Shankar <uma.shankar@samsung.com>
+ * Manjunatha C Achar <a.manjunatha@samsung.com>
+ *
+ *  Copyright (C) 2003, 2004  Free Software Foundation, Inc.
+ *  This program is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation; either version 2 of the License, or
+ *  (at your option) any later version.
+ *
+ *  This program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with this program; if not, write to the Free Software
+ *  Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+/*
+ *  ext4load - based on code from GRUB2  fs/ext2.c
+*/
+#include <common.h>
+#include <malloc.h>
+#include <asm/byteorder.h>
+#include <linux/stat.h>
+#include <linux/time.h>
+#include <ext2fs.h>
+#include <ext4fs.h>
+#include "ext4_common.h"
+
+int ext4fs_symlinknest;
+block_dev_desc_t *ext4_dev_desc;
+
+ExtFileSystem *get_fs(void)
+{
+ if (ext4_dev_desc == NULL || ext4_dev_desc->priv == NULL)
+  printf("Invalid Input Arguments %s\n", __func__);
+ return (ExtFileSystem *)ext4_dev_desc->priv;
+}
+
+int init_fs(block_dev_desc_t *dev_desc)
+{
+ ExtFileSystem *fs;
+ if (dev_desc == NULL) {
+  printf("Invalid Input Arguments %s\n", __func__);
+  return -1;
+ }
+
+ fs = (ExtFileSystem *)xzalloc(sizeof(ExtFileSystem));
+ if (fs == NULL) {
+  printf("malloc failed: %s\n", __func__);
+  return -1;
+ }
+
+ fs->dev_desc = dev_desc;
+ dev_desc->priv = fs;
+ return 0;
+}
+
+void deinit_fs(block_dev_desc_t *dev_desc)
+{
+ if (dev_desc == NULL) {
+  printf("Invalid Input Arguments %s\n", __func__);
+  return;
+ }
+ if (dev_desc->priv)
+  free(dev_desc->priv);
+ return;
+}
+
+void ext4fs_free_node(ext2fs_node_t node, ext2fs_node_t currroot)
+{
+ if ((node != &ext4fs_root->diropen) && (node != currroot))
+  free(node);
+}
+
+/* Taken from openmoko-kernel mailing list: By Andy green
+* Optimized read file API : collects and defers contiguous sector
+* reads into one potentially more efficient larger sequential read action
+*/
+int ext4fs_read_file(ext2fs_node_t node, int pos, unsigned int len, char 
*buf)
+{
+ int i;
+ int blockcnt;
+ int log2blocksize = LOG2_EXT2_BLOCK_SIZE(node->data);
+ int blocksize = 1 << (log2blocksize + DISK_SECTOR_BITS);
+ unsigned int filesize = __le32_to_cpu(node->inode.size);
+ int previous_block_number = -1;
+ int delayed_start = 0;
+ int delayed_extent = 0;
+ int delayed_skipfirst = 0;
+ int delayed_next = 0;
+ char *delayed_buf = NULL;
+ short status;
+
+ /* Adjust len so it we can't read past the end of the file.  */
+ if (len > filesize)
+  len = filesize;
+
+ blockcnt = ((len + pos) + blocksize - 1) / blocksize;
+
+ for (i = pos / blocksize; i < blockcnt; i++) {
+  int blknr;
+  int blockoff = pos % blocksize;
+  int blockend = blocksize;
+  int skipfirst = 0;
+  blknr = read_allocated_block((struct ext4_inode *)
+          &(node->inode), i);
+  if (blknr < 0)
+   return -1;
+
+  blknr = blknr << log2blocksize;
+
+  /* Last block.  */
+  if (i == blockcnt - 1) {
+   blockend = (len + pos) % blocksize;
+
+   /* The last portion is exactly blocksize.  */
+   if (!blockend)
+    blockend = blocksize;
+  }
+
+  /* First block.  */
+  if (i == pos / blocksize) {
+   skipfirst = blockoff;
+   blockend -= skipfirst;
+  }
+  if (blknr) {
+   int status;
+
+   if (previous_block_number != -1) {
+    if (delayed_next == blknr) {
+     delayed_extent += blockend;
+     delayed_next += blockend >> SECTOR_BITS;
+    } else { /* spill */
+     status = ext2fs_devread(delayed_start,
+       delayed_skipfirst,
+       delayed_extent,
+       delayed_buf);
+     if (status == 0)
+      return -1;
+     previous_block_number = blknr;
+     delayed_start = blknr;
+     delayed_extent = blockend;
+     delayed_skipfirst = skipfirst;
+     delayed_buf = buf;
+     delayed_next = blknr +
+      (blockend >> SECTOR_BITS);
+    }
+   } else {
+    previous_block_number = blknr;
+    delayed_start = blknr;
+    delayed_extent = blockend;
+    delayed_skipfirst = skipfirst;
+    delayed_buf = buf;
+    delayed_next = blknr +
+     (blockend >> SECTOR_BITS);
+   }
+  } else {
+   if (previous_block_number != -1) {
+    /* spill */
+    status = ext2fs_devread(delayed_start,
+       delayed_skipfirst,
+       delayed_extent,
+       delayed_buf);
+    if (status == 0)
+     return -1;
+    previous_block_number = -1;
+   }
+   memset(buf, 0, blocksize - skipfirst);
+  }
+  buf += blocksize - skipfirst;
+ }
+ if (previous_block_number != -1) {
+  /* spill */
+  status = ext2fs_devread(delayed_start,
+     delayed_skipfirst, delayed_extent,
+     delayed_buf);
+  if (status == 0)
+   return -1;
+  previous_block_number = -1;
+ }
+ return len;
+}
+
+int ext4fs_ls(const char *dirname)
+{
+ ext2fs_node_t dirnode;
+ int status;
+
+ if (dirname == NULL)
+  return 0;
+
+ status = ext2fs_find_file(dirname, &ext4fs_root->diropen, &dirnode,
+  FILETYPE_DIRECTORY);
+ if (status != 1) {
+  printf("** Can not find directory. **\n");
+  return 1;
+ }
+
+ ext2fs_iterate_dir(dirnode, NULL, NULL, NULL);
+ ext4fs_free_node(dirnode, &ext4fs_root->diropen);
+ return 0;
+}
+
+int ext4fs_read(char *buf, unsigned len)
+{
+ if (ext4fs_root == NULL || ext4fs_file == NULL)
+  return 0;
+ return  ext4fs_read_file(ext4fs_file, 0, len, buf);
+}
diff --git a/include/ext2fs.h b/include/ext2fs.h
index 163a9bb..de58d0a 100644
--- a/include/ext2fs.h
+++ b/include/ext2fs.h
@@ -25,6 +25,8 @@ 
  * from the original ext2 fs code, as found in the linux kernel.
  */

+#ifndef __EXT2__
+#define __EXT2__

 #define SECTOR_SIZE  0x200
 #define SECTOR_BITS  9
@@ -68,14 +70,175 @@  typedef enum
   ERR_DEV_NEED_INIT,
   ERR_NO_DISK_SPACE,
   ERR_NUMBER_OVERFLOW,
-
   MAX_ERR_NUM
 } ext2fs_error_t;

+/* Magic value used to identify an ext2 filesystem.  */
+#define EXT2_MAGIC    0xEF53
+/* Amount of indirect blocks in an inode.  */
+#define INDIRECT_BLOCKS    12
+/* Maximum lenght of a pathname.  */
+#define EXT2_PATH_MAX    4096
+/* Maximum nesting of symlinks, used to prevent a loop.  */
+#define EXT2_MAX_SYMLINKCNT   8
+
+/* Filetype used in directory entry.  */
+#define FILETYPE_UNKNOWN   0
+#define FILETYPE_REG    1
+#define FILETYPE_DIRECTORY   2
+#define FILETYPE_SYMLINK   7
+
+/* Filetype information as used in inodes.  */
+#define FILETYPE_INO_MASK   0170000
+#define FILETYPE_INO_REG   0100000
+#define FILETYPE_INO_DIRECTORY   0040000
+#define FILETYPE_INO_SYMLINK   0120000
+#define EXT2_ROOT_INO    2 /* Root inode */
+
+/* Bits used as offset in sector */
+#define DISK_SECTOR_BITS   9
+/* The size of an ext2 block in bytes.  */
+#define EXT2_BLOCK_SIZE(data)    (1 << LOG2_BLOCK_SIZE(data))
+
+/* Log2 size of ext2 block in 512 blocks.  */
+#define LOG2_EXT2_BLOCK_SIZE(data) (__le32_to_cpu \
+    (data->sblock.log2_block_size) + 1)
+
+/* Log2 size of ext2 block in bytes.  */
+#define LOG2_BLOCK_SIZE(data)    (__le32_to_cpu \
+  (data->sblock.log2_block_size) + 10)
+#define INODE_SIZE_FILESYSTEM(data) (__le32_to_cpu \
+   (data->sblock.inode_size))
+
+#define EXT2_FT_DIR  2
+#define SUCCESS   1
+/*
+ * Macro-instructions used to manage several block sizes
+ */
+#define EXT2_MIN_BLOCK_LOG_SIZE   10 /* 1024 */
+#define EXT2_MAX_BLOCK_LOG_SIZE   16 /* 65536 */
+#define EXT2_MIN_BLOCK_SIZE   (1 << EXT2_MIN_BLOCK_LOG_SIZE)
+#define EXT2_MAX_BLOCK_SIZE   (1 << EXT2_MAX_BLOCK_LOG_SIZE)
+
+/* The ext2 superblock.  */
+struct ext2_sblock {
+ uint32_t total_inodes;
+ uint32_t total_blocks;
+ uint32_t reserved_blocks;
+ uint32_t free_blocks;
+ uint32_t free_inodes;
+ uint32_t first_data_block;
+ uint32_t log2_block_size;
+ uint32_t log2_fragment_size;
+ uint32_t blocks_per_group;
+ uint32_t fragments_per_group;
+ uint32_t inodes_per_group;
+ uint32_t mtime;
+ uint32_t utime;
+ uint16_t mnt_count;
+ uint16_t max_mnt_count;
+ uint16_t magic;
+ uint16_t fs_state;
+ uint16_t error_handling;
+ uint16_t minor_revision_level;
+ uint32_t lastcheck;
+ uint32_t checkinterval;
+ uint32_t creator_os;
+ uint32_t revision_level;
+ uint16_t uid_reserved;
+ uint16_t gid_reserved;
+ uint32_t first_inode;
+ uint16_t inode_size;
+ uint16_t block_group_number;
+ uint32_t feature_compatibility;
+ uint32_t feature_incompat;
+ uint32_t feature_ro_compat;
+ uint32_t unique_id[4];
+ char volume_name[16];
+ char last_mounted_on[64];
+ uint32_t compression_info;
+};
+
+struct ext2_block_group {
+ __u32 block_id; /* Blocks bitmap block */
+ __u32 inode_id; /* Inodes bitmap block */
+ __u32 inode_table_id; /* Inodes table block */
+ __u16 free_blocks; /* Free blocks count */
+ __u16 free_inodes; /* Free inodes count */
+ __u16 used_dir_cnt; /* Directories count */
+ __u16 bg_flags;
+ __u32 bg_reserved[2];
+ __u16 bg_itable_unused; /* Unused inodes count */
+ __u16 bg_checksum; /* crc16(s_uuid+grouo_num+group_desc)*/
+};
+
+/* The ext2 inode.  */
+struct ext2_inode {
+ uint16_t mode;
+ uint16_t uid;
+ uint32_t size;
+ uint32_t atime;
+ uint32_t ctime;
+ uint32_t mtime;
+ uint32_t dtime;
+ uint16_t gid;
+ uint16_t nlinks;
+ uint32_t blockcnt; /* Blocks of 512 bytes!! */
+ uint32_t flags;
+ uint32_t osd1;
+ union {
+  struct datablocks {
+   uint32_t dir_blocks[INDIRECT_BLOCKS];
+   uint32_t indir_block;
+   uint32_t double_indir_block;
+   uint32_t tripple_indir_block;
+  } blocks;
+  char symlink[60];
+ } b;
+ uint32_t version;
+ uint32_t acl;
+ uint32_t dir_acl;
+ uint32_t fragment_addr;
+ uint32_t osd2[3];
+};
+
+/* The header of an ext2 directory entry.  */
+struct ext2_dirent {
+ uint32_t inode;
+ uint16_t direntlen;
+ uint8_t namelen;
+ uint8_t filetype;
+};
+
+struct ext2fs_node {
+ struct ext2_data *data;
+ struct ext2_inode inode;
+ int ino;
+ int inode_read;
+};
+
+/* Information about a "mounted" ext2 filesystem.  */
+struct ext2_data {
+ struct ext2_sblock sblock;
+ struct ext2_inode *inode;
+ struct ext2fs_node diropen;
+};
+
+typedef struct ext2fs_node *ext2fs_node_t;
+extern int ext2fs_iterate_dir(ext2fs_node_t dir, char *name,
+   ext2fs_node_t *fnode, int *ftype);
+extern int ext2fs_find_file(const char *path,
+  ext2fs_node_t rootnode, ext2fs_node_t *foundnode, int expecttype);

-extern int ext2fs_set_blk_dev(block_dev_desc_t *rbdd, int part);
-extern int ext2fs_ls (const char *dirname);
-extern int ext2fs_open (const char *filename);
-extern int ext2fs_read (char *buf, unsigned len);
-extern int ext2fs_mount (unsigned part_length);
-extern int ext2fs_close(void);
+int ext2fs_set_blk_dev(block_dev_desc_t *rbdd, int part);
+int ext2fs_ls(const char *dirname);
+int ext2fs_open(const char *filename);
+int ext2fs_read(char *buf, unsigned len);
+int ext2fs_mount(unsigned part_length);
+int ext2fs_close(void);
+int ext2_register_device(block_dev_desc_t *dev_desc, int part_no);
+extern int ext2fs_devread(int sector, int byte_offset, int byte_len, char 
*buf);
+uint32_t div_roundup(uint32_t size, uint32_t n);
+void *xmalloc(size_t size);
+void *xzalloc(size_t size);
+#endif
diff --git a/include/ext4fs.h b/include/ext4fs.h
new file mode 100644
index 0000000..168acba
--- /dev/null
+++ b/include/ext4fs.h
@@ -0,0 +1,164 @@ 
+/*
+ * (C) Copyright 2011 Samsung Electronics
+ * EXT4 filesystem implementation in Uboot by
+ * Uma Shankar <uma.shankar@samsung.com>
+ *
+ *  This program is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation; either version 2 of the License, or
+ *  (at your option) any later version.
+ *
+ *  This program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with this program; if not, write to the Free Software
+ *  Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ *
+ * Some parts of this code (mainly the structures and defines) are
+ * from the original ext4 fs code, as found in the linux kernel.
+ * Reference for ext4load and ls features have ben taken from GRUB
+ */
+
+#ifndef __EXT4__
+#define __EXT4__
+
+#define EXT4_EXTENTS_FLAG      0x80000
+#define EXT4_EXT_MAGIC       0xf30a
+#define EXT4_FEATURE_RO_COMPAT_GDT_CSUM 0x0010
+#define EXT4_FEATURE_INCOMPAT_EXTENTS  0x0040
+#define EXT4_INDIRECT_BLOCKS     12
+
+#define EXT4_BG_INODE_UNINIT  0x0001
+#define EXT4_BG_BLOCK_UNINIT  0x0002
+#define EXT4_BG_INODE_ZEROED  0x0004
+
+/* The ext4 inode.  */
+struct ext4_inode {
+ uint16_t mode;
+ uint16_t uid;
+ uint32_t size;
+ uint32_t atime;
+ uint32_t ctime;
+ uint32_t mtime;
+ uint32_t dtime;
+ uint16_t gid;
+ uint16_t nlinks;
+ uint32_t blockcnt; /* Blocks of 512 bytes!! */
+ uint32_t flags;
+ uint32_t osd1;
+ union {
+  struct data_blocks {
+   uint32_t dir_blocks[EXT4_INDIRECT_BLOCKS];
+   uint32_t indir_block;
+   uint32_t double_indir_block;
+   uint32_t tripple_indir_block;
+  } blocks;
+  char symlink[60];
+ } b;
+ uint32_t version;
+ uint32_t acl;
+ uint32_t dir_acl;
+ uint32_t fragment_addr;
+ uint32_t osd2[3];
+};
+
+/* All fields are little-endian */
+struct ext4_dir {
+ uint32_t inode1;
+ uint16_t rec_len1;
+ uint8_t name_len1;
+ uint8_t file_type1;
+ char name1[4];
+ uint32_t inode2;
+ uint16_t rec_len2;
+ uint8_t name_len2;
+ uint8_t file_type2;
+ char name2[4];
+ uint32_t inode3;
+ uint16_t rec_len3;
+ uint8_t name_len3;
+ uint8_t file_type3;
+ char name3[12];
+};
+
+struct ext4_extent_header {
+ uint16_t magic;
+ uint16_t entries;
+ uint16_t max;
+ uint16_t depth;
+ uint32_t generation;
+};
+
+struct ext4_extent {
+ uint32_t block;
+ uint16_t len;
+ uint16_t start_hi;
+ uint32_t start;
+};
+
+struct ext4_extent_idx {
+ uint32_t block;
+ uint32_t leaf;
+ uint16_t leaf_hi;
+ uint16_t unused;
+};
+
+typedef struct _ExtFileSystem {
+ /*Total Sector of partition */
+ uint64_t total_sect;
+ /*Block size  of partition */
+ uint32_t blksz;
+ /*Inode size of partition */
+ uint32_t inodesz;
+ /*Sectors per Block */
+ uint32_t sect_perblk;
+ /*Group Descriptor Block Number */
+ uint32_t gdtable_blkno;
+ /*Total block groups of partition */
+ uint32_t no_blkgrp;
+ /*No of blocks required for bgdtable */
+ uint32_t no_blk_pergdt;
+ /*superblock */
+ struct ext2_sblock *sb;
+ /*block group descritpor table */
+ struct ext2_block_group *gd;
+ char *gdtable;
+
+ /*Block Bitmap Related */
+ unsigned char **blk_bmaps;
+ long int curr_blkno;
+ uint16_t first_pass_bbmap;
+
+ /*Inode Bitmap Related */
+ unsigned char **inode_bmaps;
+ int curr_inode_no;
+ uint16_t first_pass_ibmap;
+
+ /*Journal Related */
+
+ /*Block Device Descriptor */
+ block_dev_desc_t *dev_desc;
+} ExtFileSystem;
+
+/*############################*/
+extern block_dev_desc_t *ext4_dev_desc;
+/*#########################*/
+
+extern struct ext2_data *ext4fs_root;
+extern ext2fs_node_t ext4fs_file;
+ExtFileSystem *get_fs(void);
+int init_fs(block_dev_desc_t *);
+void deinit_fs(block_dev_desc_t *);
+int ext4fs_open(const char *filename);
+int ext4fs_read(char *buf, unsigned len);
+int ext4fs_mount(unsigned part_length);
+int ext4fs_close(void);
+int ext4fs_ls(const char *dirname);
+long int read_allocated_block(struct ext4_inode *inode, int fileblock);
+void ext4fs_free_node(ext2fs_node_t node, ext2fs_node_t currroot);
+extern int ext2fs_devread(int sector, int byte_offset, int byte_len, char 
*buf);
+extern void *xzalloc(size_t size);