[U-Boot] Subject: [PATCH 1/2] ext4fs ls load support
Graeme Russ
graeme.russ at gmail.com
Mon Dec 12 13:12:30 CET 2011
Hi Uma,
On 12/12/11 21:45, uma.shankar at samsung.com wrote:
> From: Uma Shankar <uma.shankar at 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 at samsung.com>, Manjunatha C Achar
> <a.manjunatha at samsung.com>
I think all SoBs belong on their own line
> Signed-off-by: Iqbal Shareef <iqbal.ams at samsung.com>
> Signed-off-by: Hakgoo Lee <goodguy.lee at 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 at samsung.com>
> + * Manjunatha C Achar <a.manjunatha at 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 at samsung.com>
> + * Manjunatha C Achar <a.manjunatha at 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 at samsung.com>
> + * Manjunatha C Achar <a.manjunatha at 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 at samsung.com>
> + * Manjunatha C Achar <a.manjunatha at 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 at 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
More information about the U-Boot
mailing list