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

[Graeme Russ <graeme.russ@gmail.com>]

Hi Uma,

On 12/12/11 21:45, uma.shankar at 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 at denx.de.
> +#
> +# (C) Copyright 2003
> +# Pavel Bartusek, Sysgo Real-Time Solutions AG, pba at 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