From patchwork Mon Dec 12 10:45:37 2011 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: uma.shankar@samsung.com X-Patchwork-Id: 130694 Return-Path: X-Original-To: incoming@patchwork.ozlabs.org Delivered-To: patchwork-incoming@bilbo.ozlabs.org Received: from theia.denx.de (theia.denx.de [85.214.87.163]) by ozlabs.org (Postfix) with ESMTP id 451301007D1 for ; Mon, 12 Dec 2011 21:46:00 +1100 (EST) Received: from localhost (localhost [127.0.0.1]) by theia.denx.de (Postfix) with ESMTP id E5D18282B9; Mon, 12 Dec 2011 11:45:57 +0100 (CET) X-Virus-Scanned: Debian amavisd-new at theia.denx.de Received: from theia.denx.de ([127.0.0.1]) by localhost (theia.denx.de [127.0.0.1]) (amavisd-new, port 10024) with ESMTP id 4k9LvUcmcgKo; Mon, 12 Dec 2011 11:45:57 +0100 (CET) Received: from theia.denx.de (localhost [127.0.0.1]) by theia.denx.de (Postfix) with ESMTP id 31737282BA; Mon, 12 Dec 2011 11:45:55 +0100 (CET) Received: from localhost (localhost [127.0.0.1]) by theia.denx.de (Postfix) with ESMTP id E9DA4282BA for ; Mon, 12 Dec 2011 11:45:49 +0100 (CET) X-Virus-Scanned: Debian amavisd-new at theia.denx.de Received: from theia.denx.de ([127.0.0.1]) by localhost (theia.denx.de [127.0.0.1]) (amavisd-new, port 10024) with ESMTP id 95tF1zOWjML7 for ; Mon, 12 Dec 2011 11:45:47 +0100 (CET) X-policyd-weight: NOT_IN_SBL_XBL_SPAMHAUS=-1.5 NOT_IN_SPAMCOP=-1.5 NOT_IN_BL_NJABL=-1.5 (only DNSBL check requested) Received: from mailout1.samsung.com (mailout1.samsung.com [203.254.224.24]) by theia.denx.de (Postfix) with ESMTP id 5DDD8282B9 for ; Mon, 12 Dec 2011 11:45:44 +0100 (CET) Received: from epcpsbgm1.samsung.com (mailout1.samsung.com [203.254.224.24]) by mailout1.samsung.com (Oracle Communications Messaging Exchange Server 7u4-19.01 64bit (built Sep 7 2010)) with ESMTP id <0LW3000N277S5LM0@mailout1.samsung.com> for u-boot@lists.denx.de; Mon, 12 Dec 2011 19:45:42 +0900 (KST) X-AuditID: cbfee61a-b7b89ae000001a15-23-4ee5db5580fa Received: from epmmp2 ( [203.254.227.17]) by epcpsbgm1.samsung.com (MMPCPMTA) with SMTP id 48.05.06677.55BD5EE4; Mon, 12 Dec 2011 19:45:41 +0900 (KST) Received: from umashankar ([107.108.219.137]) by mmp2.samsung.com (Oracle Communications Messaging Exchange Server 7u4-19.01 64bit (built Sep 7 2010)) with ESMTPA id <0LW300DSQ7816O60@mmp2.samsung.com> for u-boot@lists.denx.de; Mon, 12 Dec 2011 19:45:41 +0900 (KST) Message-id: <8DCC78758C8A458F900F9F5885BA589A@sisodomain.com> From: uma.shankar@samsung.com To: u-boot@lists.denx.de, iqbal.ams@samsung.com, a.manjunatha@samsung.com, goodguy.lee@samsung.com, wd@denx.de Date: Mon, 12 Dec 2011 16:15:37 +0530 MIME-version: 1.0 X-Priority: 3 X-MSMail-priority: Normal Importance: Normal X-Mailer: Microsoft Windows Live Mail 14.0.8117.416 X-MIMEOLE: Produced By Microsoft MimeOLE V14.0.8117.416 X-Brightmail-Tracker: AAAAAA== Subject: [U-Boot] Subject: [PATCH 1/2] ext4fs ls load support X-BeenThere: u-boot@lists.denx.de X-Mailman-Version: 2.1.11 Precedence: list List-Id: U-Boot discussion List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Sender: u-boot-bounces@lists.denx.de Errors-To: u-boot-bounces@lists.denx.de From: Uma Shankar Date: Mon, 12 Dec 2011 12:01:22 +0530 Subject: [PATCH 1/2] ext4fs ls load support Signed-off-by: Uma Shankar , Manjunatha C Achar Signed-off-by: Iqbal Shareef Signed-off-by: Hakgoo Lee --- Makefile | 2 +- common/Makefile | 1 + common/cmd_ext4.c | 255 ++++++++++++++++++++++ fs/Makefile | 1 + fs/ext2/ext2fs.c | 303 +-------------------------- fs/ext4/Makefile | 51 +++++ fs/ext4/ext4_common.c | 572 +++++++++++++++++++++++++++++++++++++++++++++++++ fs/ext4/ext4_common.h | 44 ++++ fs/ext4/ext4fs.c | 215 ++++++++++++++++++ include/ext2fs.h | 177 +++++++++++++++- include/ext4fs.h | 164 ++++++++++++++ 11 files changed, 1478 insertions(+), 307 deletions(-) create mode 100644 common/cmd_ext4.c create mode 100644 fs/ext4/Makefile create mode 100644 fs/ext4/ext4_common.c create mode 100644 fs/ext4/ext4_common.h create mode 100644 fs/ext4/ext4fs.c create mode 100644 include/ext4fs.h +#endif 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 + * Manjunatha C Achar + * + * 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 +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include "../disk/part_dos.h" +#include + +#if defined(CONFIG_CMD_USB) && defined(CONFIG_USB_STORAGE) +#include +#endif + +#if !defined(CONFIG_DOS_PARTITION) && !defined(CONFIG_EFI_PARTITION) +#error DOS or EFI partition support must be selected +#endif + +uint64_t total_sector; +uint64_t part_offset; +static uint64_t part_size; +static uint16_t cur_part = 1; + +#define DOS_PART_MAGIC_OFFSET 0x1fe +#define DOS_FS_TYPE_OFFSET 0x36 +#define DOS_FS32_TYPE_OFFSET 0x52 + +int do_ext4_load(cmd_tbl_t *cmdtp, int flag, int argc, char *const argv[]) +{ + char *filename = NULL; + char *ep; + int dev, part = 1; + ulong addr = 0, part_length; + int filelen; + disk_partition_t info; + ExtFileSystem *fs; + char buf[12]; + unsigned long count; + char *addr_str; + + switch (argc) { + case 3: + addr_str = getenv("loadaddr"); + if (addr_str != NULL) + addr = strict_strtoul(addr_str, NULL, 16); + else + addr = CONFIG_SYS_LOAD_ADDR; + + filename = getenv("bootfile"); + count = 0; + break; + case 4: + addr = strict_strtoul(argv[3], NULL, 16); + filename = getenv("bootfile"); + count = 0; + break; + case 5: + addr = strict_strtoul(argv[3], NULL, 16); + filename = argv[4]; + count = 0; + break; + case 6: + addr = strict_strtoul(argv[3], NULL, 16); + filename = argv[4]; + count = strict_strtoul(argv[5], NULL, 16); + break; + + default: + return cmd_usage(cmdtp); + } + + if (!filename) { + puts("** No boot file defined **\n"); + return 1; + } + + dev = (int)strict_strtoul(argv[2], &ep, 16); + ext4_dev_desc = get_dev(argv[1], dev); + if (ext4_dev_desc == NULL) { + printf("** Block device %s %d not supported\n", argv[1], dev); + return 1; + } + if (init_fs(ext4_dev_desc)) + return 1; + + fs = get_fs(); + if (*ep) { + if (*ep != ':') { + puts("** Invalid boot device, use `dev[:part]' **\n"); + return 1; + } + part = (int)strict_strtoul(++ep, NULL, 16); + } + + if (part != 0) { + if (get_partition_info(fs->dev_desc, part, &info)) { + printf("** Bad partition %d **\n", part); + return 1; + } + + if (strncmp((char *)info.type, BOOT_PART_TYPE, + sizeof(info.type)) != 0) { + printf("** Invalid partition type \"%.32s\"" + " (expect \"" BOOT_PART_TYPE "\")\n", info.type); + return 1; + } + printf("Loading file \"%s\" " + "from %s device %d:%d (%.32s)\n", + filename, argv[1], dev, part, info.name); + } else { + printf("Loading file \"%s\" from %s device %d\n", + filename, argv[1], dev); + } + + part_length = ext2fs_set_blk_dev(fs->dev_desc, part); + if (part_length == 0) { + printf("**Bad partition - %s %d:%d **\n", argv[1], dev, part); + ext4fs_close(); + return 1; + } + + if (!ext4fs_mount(part_length)) { + printf("** Bad ext2 partition or disk - %s %d:%d **\n", + argv[1], dev, part); + ext4fs_close(); + return 1; + } + + filelen = ext4fs_open(filename); + if (filelen < 0) { + printf("** File not found %s\n", filename); + ext4fs_close(); + return 1; + } + if ((count < filelen) && (count != 0)) + filelen = count; + + if (ext4fs_read((char *)addr, filelen) != filelen) { + printf("** Unable to read \"%s\" from %s %d:%d **\n", + filename, argv[1], dev, part); + ext4fs_close(); + return 1; + } + + ext4fs_close(); + deinit_fs(fs->dev_desc); + /* Loading ok, update default load address */ + load_addr = addr; + + printf("%d bytes read\n", filelen); + sprintf(buf, "%X", filelen); + setenv("filesize", buf); + + return 0; +} + +int do_ext4_ls(cmd_tbl_t *cmdtp, int flag, int argc, char *const argv[]) +{ + char *filename = "/"; + int dev = 0; + int part = 1; + char *ep; + ExtFileSystem *fs; + int part_length; + + if (argc < 3) + return cmd_usage(cmdtp); + + dev = (int)strict_strtoul(argv[2], &ep, 16); + ext4_dev_desc = get_dev(argv[1], dev); + + if (ext4_dev_desc == NULL) { + printf("\n** Block device %s %d not supported\n", argv[1], dev); + return 1; + } + + if (init_fs(ext4_dev_desc)) + return 1; + + fs = get_fs(); + if (*ep) { + if (*ep != ':') { + puts("\n** Invalid boot device, use `dev[:part]' **\n"); + return 1; + } + part = (int)strict_strtoul(++ep, NULL, 16); + } + + if (argc == 4) + filename = argv[3]; + + part_length = ext2fs_set_blk_dev(fs->dev_desc, part); + if (part_length == 0) { + printf("** Bad partition - %s %d:%d **\n", argv[1], dev, part); + ext4fs_close(); + return 1; + } + + if (!ext4fs_mount(part_length)) { + printf("** Bad ext2 partition or disk - %s %d:%d **\n", + argv[1], dev, part); + ext4fs_close(); + return 1; + } + if (ext4fs_ls(filename)) { + printf("** Error ext2fs_ls() **\n"); + ext4fs_close(); + return 1; + }; + + ext4fs_close(); + deinit_fs(fs->dev_desc); + return 0; +} + +U_BOOT_CMD(ext4ls, 4, 1, do_ext4_ls, + "list files in a directory (default /)", + " [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", + " [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 #include +#include #include #include -extern int ext2fs_devread (int sector, int byte_offset, int byte_len, - char *buf); - -/* Magic value used to identify an ext2 filesystem. */ -#define EXT2_MAGIC 0xEF53 -/* Amount of indirect blocks in an inode. */ -#define INDIRECT_BLOCKS 12 -/* Maximum lenght of a pathname. */ -#define EXT2_PATH_MAX 4096 -/* Maximum nesting of symlinks, used to prevent a loop. */ -#define EXT2_MAX_SYMLINKCNT 8 - -/* Filetype used in directory entry. */ -#define FILETYPE_UNKNOWN 0 -#define FILETYPE_REG 1 -#define FILETYPE_DIRECTORY 2 -#define FILETYPE_SYMLINK 7 - -/* Filetype information as used in inodes. */ -#define FILETYPE_INO_MASK 0170000 -#define FILETYPE_INO_REG 0100000 -#define FILETYPE_INO_DIRECTORY 0040000 -#define FILETYPE_INO_SYMLINK 0120000 - -/* Bits used as offset in sector */ -#define DISK_SECTOR_BITS 9 - -/* Log2 size of ext2 block in 512 blocks. */ -#define LOG2_EXT2_BLOCK_SIZE(data) (__le32_to_cpu (data->sblock.log2_block_size) + 1) - -/* Log2 size of ext2 block in bytes. */ -#define LOG2_BLOCK_SIZE(data) (__le32_to_cpu (data->sblock.log2_block_size) + 10) - -/* The size of an ext2 block in bytes. */ -#define EXT2_BLOCK_SIZE(data) (1 << LOG2_BLOCK_SIZE(data)) - -/* The ext2 superblock. */ -struct ext2_sblock { - uint32_t total_inodes; - uint32_t total_blocks; - uint32_t reserved_blocks; - uint32_t free_blocks; - uint32_t free_inodes; - uint32_t first_data_block; - uint32_t log2_block_size; - uint32_t log2_fragment_size; - uint32_t blocks_per_group; - uint32_t fragments_per_group; - uint32_t inodes_per_group; - uint32_t mtime; - uint32_t utime; - uint16_t mnt_count; - uint16_t max_mnt_count; - uint16_t magic; - uint16_t fs_state; - uint16_t error_handling; - uint16_t minor_revision_level; - uint32_t lastcheck; - uint32_t checkinterval; - uint32_t creator_os; - uint32_t revision_level; - uint16_t uid_reserved; - uint16_t gid_reserved; - uint32_t first_inode; - uint16_t inode_size; - uint16_t block_group_number; - uint32_t feature_compatibility; - uint32_t feature_incompat; - uint32_t feature_ro_compat; - uint32_t unique_id[4]; - char volume_name[16]; - char last_mounted_on[64]; - uint32_t compression_info; -}; - -/* The ext2 blockgroup. */ -struct ext2_block_group { - uint32_t block_id; - uint32_t inode_id; - uint32_t inode_table_id; - uint16_t free_blocks; - uint16_t free_inodes; - uint16_t used_dir_cnt; - uint32_t reserved[3]; -}; - -/* The ext2 inode. */ -struct ext2_inode { - uint16_t mode; - uint16_t uid; - uint32_t size; - uint32_t atime; - uint32_t ctime; - uint32_t mtime; - uint32_t dtime; - uint16_t gid; - uint16_t nlinks; - uint32_t blockcnt; /* Blocks of 512 bytes!! */ - uint32_t flags; - uint32_t osd1; - union { - struct datablocks { - uint32_t dir_blocks[INDIRECT_BLOCKS]; - uint32_t indir_block; - uint32_t double_indir_block; - uint32_t tripple_indir_block; - } blocks; - char symlink[60]; - } b; - uint32_t version; - uint32_t acl; - uint32_t dir_acl; - uint32_t fragment_addr; - uint32_t osd2[3]; -}; - -/* The header of an ext2 directory entry. */ -struct ext2_dirent { - uint32_t inode; - uint16_t direntlen; - uint8_t namelen; - uint8_t filetype; -}; - -struct ext2fs_node { - struct ext2_data *data; - struct ext2_inode inode; - int ino; - int inode_read; -}; - -/* Information about a "mounted" ext2 filesystem. */ -struct ext2_data { - struct ext2_sblock sblock; - struct ext2_inode *inode; - struct ext2fs_node diropen; -}; - - -typedef struct ext2fs_node *ext2fs_node_t; - struct ext2_data *ext2fs_root = NULL; ext2fs_node_t ext2fs_file = NULL; int symlinknest = 0; @@ -180,7 +40,6 @@ int indir2_size = 0; int indir2_blkno = -1; static unsigned int inode_size; - static int ext2fs_blockgroup (struct ext2_data *data, int group, struct ext2_block_group *blkgrp) { unsigned int blkno; @@ -198,10 +57,8 @@ static int ext2fs_blockgroup #endif return (ext2fs_devread (blkno << LOG2_EXT2_BLOCK_SIZE(data), blkoff, sizeof(struct ext2_block_group), (char *)blkgrp)); - } - static int ext2fs_read_inode (struct ext2_data *data, int ino, struct ext2_inode *inode) { struct ext2_block_group blkgrp; @@ -242,153 +99,12 @@ static int ext2fs_read_inode return (1); } - void ext2fs_free_node (ext2fs_node_t node, ext2fs_node_t currroot) { if ((node != &ext2fs_root->diropen) && (node != currroot)) { free (node); } } - -static int ext2fs_read_block (ext2fs_node_t node, int fileblock) { - struct ext2_data *data = node->data; - struct ext2_inode *inode = &node->inode; - int blknr; - int blksz = EXT2_BLOCK_SIZE (data); - int log2_blksz = LOG2_EXT2_BLOCK_SIZE (data); - int status; - - /* Direct blocks. */ - if (fileblock < INDIRECT_BLOCKS) { - blknr = __le32_to_cpu (inode->b.blocks.dir_blocks[fileblock]); - } - /* Indirect. */ - else if (fileblock < (INDIRECT_BLOCKS + (blksz / 4))) { - if (indir1_block == NULL) { - indir1_block = (uint32_t *) malloc (blksz); - if (indir1_block == NULL) { - printf ("** ext2fs read block (indir 1) malloc failed. **\n"); - return (-1); - } - indir1_size = blksz; - indir1_blkno = -1; - } - if (blksz != indir1_size) { - free (indir1_block); - indir1_block = NULL; - indir1_size = 0; - indir1_blkno = -1; - indir1_block = (uint32_t *) malloc (blksz); - if (indir1_block == NULL) { - printf ("** ext2fs read block (indir 1) malloc failed. **\n"); - return (-1); - } - indir1_size = blksz; - } - if ((__le32_to_cpu (inode->b.blocks.indir_block) << - log2_blksz) != indir1_blkno) { - status = ext2fs_devread (__le32_to_cpu(inode->b.blocks.indir_block) << log2_blksz, - 0, blksz, - (char *) indir1_block); - if (status == 0) { - printf ("** ext2fs read block (indir 1) failed. **\n"); - return (0); - } - indir1_blkno = - __le32_to_cpu (inode->b.blocks. - indir_block) << log2_blksz; - } - blknr = __le32_to_cpu (indir1_block - [fileblock - INDIRECT_BLOCKS]); - } - /* Double indirect. */ - else if (fileblock < - (INDIRECT_BLOCKS + (blksz / 4 * (blksz / 4 + 1)))) { - unsigned int perblock = blksz / 4; - unsigned int rblock = fileblock - (INDIRECT_BLOCKS - + blksz / 4); - - if (indir1_block == NULL) { - indir1_block = (uint32_t *) malloc (blksz); - if (indir1_block == NULL) { - printf ("** ext2fs read block (indir 2 1) malloc failed. **\n"); - return (-1); - } - indir1_size = blksz; - indir1_blkno = -1; - } - if (blksz != indir1_size) { - free (indir1_block); - indir1_block = NULL; - indir1_size = 0; - indir1_blkno = -1; - indir1_block = (uint32_t *) malloc (blksz); - if (indir1_block == NULL) { - printf ("** ext2fs read block (indir 2 1) malloc failed. **\n"); - return (-1); - } - indir1_size = blksz; - } - if ((__le32_to_cpu (inode->b.blocks.double_indir_block) << - log2_blksz) != indir1_blkno) { - status = ext2fs_devread (__le32_to_cpu(inode->b.blocks.double_indir_block) << log2_blksz, - 0, blksz, - (char *) indir1_block); - if (status == 0) { - printf ("** ext2fs read block (indir 2 1) failed. **\n"); - return (-1); - } - indir1_blkno = - __le32_to_cpu (inode->b.blocks.double_indir_block) << log2_blksz; - } - - if (indir2_block == NULL) { - indir2_block = (uint32_t *) malloc (blksz); - if (indir2_block == NULL) { - printf ("** ext2fs read block (indir 2 2) malloc failed. **\n"); - return (-1); - } - indir2_size = blksz; - indir2_blkno = -1; - } - if (blksz != indir2_size) { - free (indir2_block); - indir2_block = NULL; - indir2_size = 0; - indir2_blkno = -1; - indir2_block = (uint32_t *) malloc (blksz); - if (indir2_block == NULL) { - printf ("** ext2fs read block (indir 2 2) malloc failed. **\n"); - return (-1); - } - indir2_size = blksz; - } - if ((__le32_to_cpu (indir1_block[rblock / perblock]) << - log2_blksz) != indir2_blkno) { - status = ext2fs_devread (__le32_to_cpu(indir1_block[rblock / perblock]) << log2_blksz, - 0, blksz, - (char *) indir2_block); - if (status == 0) { - printf ("** ext2fs read block (indir 2 2) failed. **\n"); - return (-1); - } - indir2_blkno = - __le32_to_cpu (indir1_block[rblock / perblock]) << log2_blksz; - } - blknr = __le32_to_cpu (indir2_block[rblock % perblock]); - } - /* Tripple indirect. */ - else { - printf ("** ext2fs doesn't support tripple indirect blocks. **\n"); - return (-1); - } -#ifdef DEBUG - printf ("ext2fs_read_block %08x\n", blknr); -#endif - return (blknr); -} - - int ext2fs_read_file (ext2fs_node_t node, int pos, unsigned int len, char *buf) { int i; @@ -409,8 +125,7 @@ int ext2fs_read_file int blockend = blocksize; int skipfirst = 0; - - blknr = ext2fs_read_block (node, i); + blknr = read_allocated_block(&(node->inode), i); if (blknr < 0) { return (-1); } @@ -449,8 +164,8 @@ int ext2fs_read_file return (len); } - -static int ext2fs_iterate_dir (ext2fs_node_t dir, char *name, ext2fs_node_t * fnode, int *ftype) +int ext2fs_iterate_dir(ext2fs_node_t dir, char *name, + ext2fs_node_t *fnode, int *ftype) { unsigned int fpos = 0; int status; @@ -581,7 +296,6 @@ static int ext2fs_iterate_dir (ext2fs_node_t dir, char *name, ext2fs_node_t * fn return (0); } - static char *ext2fs_read_symlink (ext2fs_node_t node) { char *symlink; struct ext2fs_node *diro = node; @@ -617,7 +331,6 @@ static char *ext2fs_read_symlink (ext2fs_node_t node) { return (symlink); } - int ext2fs_find_file1 (const char *currpath, ext2fs_node_t currroot, ext2fs_node_t * currfound, int *foundtype) { @@ -721,7 +434,6 @@ int ext2fs_find_file1 return (-1); } - int ext2fs_find_file (const char *path, ext2fs_node_t rootnode, ext2fs_node_t * foundnode, int expecttype) { @@ -748,7 +460,6 @@ int ext2fs_find_file return (1); } - int ext2fs_ls (const char *dirname) { ext2fs_node_t dirnode; int status; @@ -768,7 +479,6 @@ int ext2fs_ls (const char *dirname) { return (0); } - int ext2fs_open (const char *filename) { ext2fs_node_t fdiro = NULL; int status; @@ -799,7 +509,6 @@ fail: return (-1); } - int ext2fs_close (void ) { if ((ext2fs_file != NULL) && (ext2fs_root != NULL)) { @@ -825,7 +534,6 @@ int ext2fs_close (void return (0); } - int ext2fs_read (char *buf, unsigned len) { int status; @@ -836,12 +544,10 @@ int ext2fs_read (char *buf, unsigned len) { if (ext2fs_file == NULL) { return (0); } - status = ext2fs_read_file (ext2fs_file, 0, len, buf); return (status); } - int ext2fs_mount (unsigned part_length) { struct ext2_data *data; int status; @@ -880,7 +586,6 @@ int ext2fs_mount (unsigned part_length) { } ext2fs_root = data; - return (1); fail: diff --git a/fs/ext4/Makefile b/fs/ext4/Makefile new file mode 100644 index 0000000..850f821 --- /dev/null +++ b/fs/ext4/Makefile @@ -0,0 +1,51 @@ +# +# (C) Copyright 2006 +# Wolfgang Denk, DENX Software Engineering, wd@denx.de. +# +# (C) Copyright 2003 +# Pavel Bartusek, Sysgo Real-Time Solutions AG, pba@sysgo.de +# +# +# See file CREDITS for list of people who contributed to this +# project. +# +# This program is free software; you can redistribute it and/or +# modify it under the terms of the GNU General Public License as +# published by the Free Software Foundation; either version 2 of +# the License, or (at your option) any later version. +# +# This program is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +# GNU General Public License for more details. +# +# You should have received a copy of the GNU General Public License +# along with this program; if not, write to the Free Software +# Foundation, Inc., 59 Temple Place, Suite 330, Boston, +# MA 02111-1307 USA +# + +include $(TOPDIR)/config.mk + +LIB = $(obj)libext4fs.o + +AOBJS = +COBJS-$(CONFIG_CMD_EXT4) := ext4fs.o ext4_common.o + +SRCS := $(AOBJS:.o=.S) $(COBJS-y:.o=.c) +OBJS := $(addprefix $(obj),$(AOBJS) $(COBJS-y)) + + +all: $(LIB) $(AOBJS) + +$(LIB): $(obj).depend $(OBJS) + $(call cmd_link_o_target, $(OBJS)) + +######################################################################### + +# defines $(obj).depend target +include $(SRCTREE)/rules.mk + +sinclude $(obj).depend + +######################################################################### diff --git a/fs/ext4/ext4_common.c b/fs/ext4/ext4_common.c new file mode 100644 index 0000000..39321f6 --- /dev/null +++ b/fs/ext4/ext4_common.c @@ -0,0 +1,572 @@ +/* + * (C) Copyright 2011 Samsung Electronics + * EXT4 filesystem implementation in Uboot by + * Uma Shankar + * Manjunatha C Achar + * + * 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 +#include +#include +#include +#include +#include +#include +#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 + * Manjunatha C Achar + * + * 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 +#include + +#define YES 1 +#define NO 0 +#define TRUE 1 +#define FALSE 0 +#define RECOVER 1 +#define SCAN 0 + +#define S_IFLNK 0120000 /* symbolic link */ +#define BLOCK_NO_ONE 1 +#define SUPERBLOCK_SECTOR 2 +#define SUPERBLOCK_SIZE 1024 +#define F_FILE 1 + +extern unsigned long part_offset; +int ext4fs_read_inode(struct ext2_data *data, int ino, + struct ext4_inode *inode); +#endif diff --git a/fs/ext4/ext4fs.c b/fs/ext4/ext4fs.c new file mode 100644 index 0000000..890aaf3 --- /dev/null +++ b/fs/ext4/ext4fs.c @@ -0,0 +1,215 @@ +/* + * (C) Copyright 2011 Samsung Electronics + * EXT4 filesystem implementation in Uboot by + * Uma Shankar + * Manjunatha C Achar + * + * 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 +#include +#include +#include +#include +#include +#include +#include "ext4_common.h" + +int ext4fs_symlinknest; +block_dev_desc_t *ext4_dev_desc; + +ExtFileSystem *get_fs(void) +{ + if (ext4_dev_desc == NULL || ext4_dev_desc->priv == NULL) + printf("Invalid Input Arguments %s\n", __func__); + return (ExtFileSystem *)ext4_dev_desc->priv; +} + +int init_fs(block_dev_desc_t *dev_desc) +{ + ExtFileSystem *fs; + if (dev_desc == NULL) { + printf("Invalid Input Arguments %s\n", __func__); + return -1; + } + + fs = (ExtFileSystem *)xzalloc(sizeof(ExtFileSystem)); + if (fs == NULL) { + printf("malloc failed: %s\n", __func__); + return -1; + } + + fs->dev_desc = dev_desc; + dev_desc->priv = fs; + return 0; +} + +void deinit_fs(block_dev_desc_t *dev_desc) +{ + if (dev_desc == NULL) { + printf("Invalid Input Arguments %s\n", __func__); + return; + } + if (dev_desc->priv) + free(dev_desc->priv); + return; +} + +void ext4fs_free_node(ext2fs_node_t node, ext2fs_node_t currroot) +{ + if ((node != &ext4fs_root->diropen) && (node != currroot)) + free(node); +} + +/* Taken from openmoko-kernel mailing list: By Andy green +* Optimized read file API : collects and defers contiguous sector +* reads into one potentially more efficient larger sequential read action +*/ +int ext4fs_read_file(ext2fs_node_t node, int pos, unsigned int len, char *buf) +{ + int i; + int blockcnt; + int log2blocksize = LOG2_EXT2_BLOCK_SIZE(node->data); + int blocksize = 1 << (log2blocksize + DISK_SECTOR_BITS); + unsigned int filesize = __le32_to_cpu(node->inode.size); + int previous_block_number = -1; + int delayed_start = 0; + int delayed_extent = 0; + int delayed_skipfirst = 0; + int delayed_next = 0; + char *delayed_buf = NULL; + short status; + + /* Adjust len so it we can't read past the end of the file. */ + if (len > filesize) + len = filesize; + + blockcnt = ((len + pos) + blocksize - 1) / blocksize; + + for (i = pos / blocksize; i < blockcnt; i++) { + int blknr; + int blockoff = pos % blocksize; + int blockend = blocksize; + int skipfirst = 0; + blknr = read_allocated_block((struct ext4_inode *) + &(node->inode), i); + if (blknr < 0) + return -1; + + blknr = blknr << log2blocksize; + + /* Last block. */ + if (i == blockcnt - 1) { + blockend = (len + pos) % blocksize; + + /* The last portion is exactly blocksize. */ + if (!blockend) + blockend = blocksize; + } + + /* First block. */ + if (i == pos / blocksize) { + skipfirst = blockoff; + blockend -= skipfirst; + } + if (blknr) { + int status; + + if (previous_block_number != -1) { + if (delayed_next == blknr) { + delayed_extent += blockend; + delayed_next += blockend >> SECTOR_BITS; + } else { /* spill */ + status = ext2fs_devread(delayed_start, + delayed_skipfirst, + delayed_extent, + delayed_buf); + if (status == 0) + return -1; + previous_block_number = blknr; + delayed_start = blknr; + delayed_extent = blockend; + delayed_skipfirst = skipfirst; + delayed_buf = buf; + delayed_next = blknr + + (blockend >> SECTOR_BITS); + } + } else { + previous_block_number = blknr; + delayed_start = blknr; + delayed_extent = blockend; + delayed_skipfirst = skipfirst; + delayed_buf = buf; + delayed_next = blknr + + (blockend >> SECTOR_BITS); + } + } else { + if (previous_block_number != -1) { + /* spill */ + status = ext2fs_devread(delayed_start, + delayed_skipfirst, + delayed_extent, + delayed_buf); + if (status == 0) + return -1; + previous_block_number = -1; + } + memset(buf, 0, blocksize - skipfirst); + } + buf += blocksize - skipfirst; + } + if (previous_block_number != -1) { + /* spill */ + status = ext2fs_devread(delayed_start, + delayed_skipfirst, delayed_extent, + delayed_buf); + if (status == 0) + return -1; + previous_block_number = -1; + } + return len; +} + +int ext4fs_ls(const char *dirname) +{ + ext2fs_node_t dirnode; + int status; + + if (dirname == NULL) + return 0; + + status = ext2fs_find_file(dirname, &ext4fs_root->diropen, &dirnode, + FILETYPE_DIRECTORY); + if (status != 1) { + printf("** Can not find directory. **\n"); + return 1; + } + + ext2fs_iterate_dir(dirnode, NULL, NULL, NULL); + ext4fs_free_node(dirnode, &ext4fs_root->diropen); + return 0; +} + +int ext4fs_read(char *buf, unsigned len) +{ + if (ext4fs_root == NULL || ext4fs_file == NULL) + return 0; + return ext4fs_read_file(ext4fs_file, 0, len, buf); +} diff --git a/include/ext2fs.h b/include/ext2fs.h index 163a9bb..de58d0a 100644 --- a/include/ext2fs.h +++ b/include/ext2fs.h @@ -25,6 +25,8 @@ * from the original ext2 fs code, as found in the linux kernel. */ +#ifndef __EXT2__ +#define __EXT2__ #define SECTOR_SIZE 0x200 #define SECTOR_BITS 9 @@ -68,14 +70,175 @@ typedef enum ERR_DEV_NEED_INIT, ERR_NO_DISK_SPACE, ERR_NUMBER_OVERFLOW, - MAX_ERR_NUM } ext2fs_error_t; +/* Magic value used to identify an ext2 filesystem. */ +#define EXT2_MAGIC 0xEF53 +/* Amount of indirect blocks in an inode. */ +#define INDIRECT_BLOCKS 12 +/* Maximum lenght of a pathname. */ +#define EXT2_PATH_MAX 4096 +/* Maximum nesting of symlinks, used to prevent a loop. */ +#define EXT2_MAX_SYMLINKCNT 8 + +/* Filetype used in directory entry. */ +#define FILETYPE_UNKNOWN 0 +#define FILETYPE_REG 1 +#define FILETYPE_DIRECTORY 2 +#define FILETYPE_SYMLINK 7 + +/* Filetype information as used in inodes. */ +#define FILETYPE_INO_MASK 0170000 +#define FILETYPE_INO_REG 0100000 +#define FILETYPE_INO_DIRECTORY 0040000 +#define FILETYPE_INO_SYMLINK 0120000 +#define EXT2_ROOT_INO 2 /* Root inode */ + +/* Bits used as offset in sector */ +#define DISK_SECTOR_BITS 9 +/* The size of an ext2 block in bytes. */ +#define EXT2_BLOCK_SIZE(data) (1 << LOG2_BLOCK_SIZE(data)) + +/* Log2 size of ext2 block in 512 blocks. */ +#define LOG2_EXT2_BLOCK_SIZE(data) (__le32_to_cpu \ + (data->sblock.log2_block_size) + 1) + +/* Log2 size of ext2 block in bytes. */ +#define LOG2_BLOCK_SIZE(data) (__le32_to_cpu \ + (data->sblock.log2_block_size) + 10) +#define INODE_SIZE_FILESYSTEM(data) (__le32_to_cpu \ + (data->sblock.inode_size)) + +#define EXT2_FT_DIR 2 +#define SUCCESS 1 +/* + * Macro-instructions used to manage several block sizes + */ +#define EXT2_MIN_BLOCK_LOG_SIZE 10 /* 1024 */ +#define EXT2_MAX_BLOCK_LOG_SIZE 16 /* 65536 */ +#define EXT2_MIN_BLOCK_SIZE (1 << EXT2_MIN_BLOCK_LOG_SIZE) +#define EXT2_MAX_BLOCK_SIZE (1 << EXT2_MAX_BLOCK_LOG_SIZE) + +/* The ext2 superblock. */ +struct ext2_sblock { + uint32_t total_inodes; + uint32_t total_blocks; + uint32_t reserved_blocks; + uint32_t free_blocks; + uint32_t free_inodes; + uint32_t first_data_block; + uint32_t log2_block_size; + uint32_t log2_fragment_size; + uint32_t blocks_per_group; + uint32_t fragments_per_group; + uint32_t inodes_per_group; + uint32_t mtime; + uint32_t utime; + uint16_t mnt_count; + uint16_t max_mnt_count; + uint16_t magic; + uint16_t fs_state; + uint16_t error_handling; + uint16_t minor_revision_level; + uint32_t lastcheck; + uint32_t checkinterval; + uint32_t creator_os; + uint32_t revision_level; + uint16_t uid_reserved; + uint16_t gid_reserved; + uint32_t first_inode; + uint16_t inode_size; + uint16_t block_group_number; + uint32_t feature_compatibility; + uint32_t feature_incompat; + uint32_t feature_ro_compat; + uint32_t unique_id[4]; + char volume_name[16]; + char last_mounted_on[64]; + uint32_t compression_info; +}; + +struct ext2_block_group { + __u32 block_id; /* Blocks bitmap block */ + __u32 inode_id; /* Inodes bitmap block */ + __u32 inode_table_id; /* Inodes table block */ + __u16 free_blocks; /* Free blocks count */ + __u16 free_inodes; /* Free inodes count */ + __u16 used_dir_cnt; /* Directories count */ + __u16 bg_flags; + __u32 bg_reserved[2]; + __u16 bg_itable_unused; /* Unused inodes count */ + __u16 bg_checksum; /* crc16(s_uuid+grouo_num+group_desc)*/ +}; + +/* The ext2 inode. */ +struct ext2_inode { + uint16_t mode; + uint16_t uid; + uint32_t size; + uint32_t atime; + uint32_t ctime; + uint32_t mtime; + uint32_t dtime; + uint16_t gid; + uint16_t nlinks; + uint32_t blockcnt; /* Blocks of 512 bytes!! */ + uint32_t flags; + uint32_t osd1; + union { + struct datablocks { + uint32_t dir_blocks[INDIRECT_BLOCKS]; + uint32_t indir_block; + uint32_t double_indir_block; + uint32_t tripple_indir_block; + } blocks; + char symlink[60]; + } b; + uint32_t version; + uint32_t acl; + uint32_t dir_acl; + uint32_t fragment_addr; + uint32_t osd2[3]; +}; + +/* The header of an ext2 directory entry. */ +struct ext2_dirent { + uint32_t inode; + uint16_t direntlen; + uint8_t namelen; + uint8_t filetype; +}; + +struct ext2fs_node { + struct ext2_data *data; + struct ext2_inode inode; + int ino; + int inode_read; +}; + +/* Information about a "mounted" ext2 filesystem. */ +struct ext2_data { + struct ext2_sblock sblock; + struct ext2_inode *inode; + struct ext2fs_node diropen; +}; + +typedef struct ext2fs_node *ext2fs_node_t; +extern int ext2fs_iterate_dir(ext2fs_node_t dir, char *name, + ext2fs_node_t *fnode, int *ftype); +extern int ext2fs_find_file(const char *path, + ext2fs_node_t rootnode, ext2fs_node_t *foundnode, int expecttype); -extern int ext2fs_set_blk_dev(block_dev_desc_t *rbdd, int part); -extern int ext2fs_ls (const char *dirname); -extern int ext2fs_open (const char *filename); -extern int ext2fs_read (char *buf, unsigned len); -extern int ext2fs_mount (unsigned part_length); -extern int ext2fs_close(void); +int ext2fs_set_blk_dev(block_dev_desc_t *rbdd, int part); +int ext2fs_ls(const char *dirname); +int ext2fs_open(const char *filename); +int ext2fs_read(char *buf, unsigned len); +int ext2fs_mount(unsigned part_length); +int ext2fs_close(void); +int ext2_register_device(block_dev_desc_t *dev_desc, int part_no); +extern int ext2fs_devread(int sector, int byte_offset, int byte_len, char *buf); +uint32_t div_roundup(uint32_t size, uint32_t n); +void *xmalloc(size_t size); +void *xzalloc(size_t size); +#endif diff --git a/include/ext4fs.h b/include/ext4fs.h new file mode 100644 index 0000000..168acba --- /dev/null +++ b/include/ext4fs.h @@ -0,0 +1,164 @@ +/* + * (C) Copyright 2011 Samsung Electronics + * EXT4 filesystem implementation in Uboot by + * Uma Shankar + * + * 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);