/* * (C) Copyright 2004 *  esd gmbh <www.esd-electronics.com> *  Reinhard Arlt <reinhard.arlt@esd-electronics.com> * *  based on code from grub2 fs/ext2.c and fs/fshelp.c by * *  GRUB  --  GRand Unified Bootloader *  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. */#include <common.h>#if (CONFIG_COMMANDS & CFG_CMD_EXT2)#include <ext2fs.h>#include <malloc.h>#include <asm/byteorder.h>extern int ext2fs_devread (int sector, int byte_offset, int byte_len,			   char *buf);/* Magic value used to identify an ext2 filesystem.  */#define	EXT2_MAGIC		0xEF53/* Amount of indirect blocks in an inode.  */#define INDIRECT_BLOCKS		12/* Maximum lenght of a pathname.  */#define EXT2_PATH_MAX		4096/* Maximum nesting of symlinks, used to prevent a loop.  */#define	EXT2_MAX_SYMLINKCNT	8/* Filetype used in directory entry.  */#define	FILETYPE_UNKNOWN	0#define	FILETYPE_REG		1#define	FILETYPE_DIRECTORY	2#define	FILETYPE_SYMLINK	7/* Filetype information as used in inodes.  */#define FILETYPE_INO_MASK	0170000#define FILETYPE_INO_REG	0100000#define FILETYPE_INO_DIRECTORY	0040000#define FILETYPE_INO_SYMLINK	0120000/* Bits used as offset in sector */#define DISK_SECTOR_BITS        9/* Log2 size of ext2 block in 512 blocks.  */#define LOG2_EXT2_BLOCK_SIZE(data) (__le32_to_cpu (data->sblock.log2_block_size) + 1)/* Log2 size of ext2 block in bytes.  */#define LOG2_BLOCK_SIZE(data)	   (__le32_to_cpu (data->sblock.log2_block_size) + 10)/* The size of an ext2 block in bytes.  */#define EXT2_BLOCK_SIZE(data)	   (1 << LOG2_BLOCK_SIZE(data))/* The ext2 superblock.  */struct ext2_sblock {	uint32_t total_inodes;	uint32_t total_blocks;	uint32_t reserved_blocks;	uint32_t free_blocks;	uint32_t free_inodes;	uint32_t first_data_block;	uint32_t log2_block_size;	uint32_t log2_fragment_size;	uint32_t blocks_per_group;	uint32_t fragments_per_group;	uint32_t inodes_per_group;	uint32_t mtime;	uint32_t utime;	uint16_t mnt_count;	uint16_t max_mnt_count;	uint16_t magic;	uint16_t fs_state;	uint16_t error_handling;	uint16_t minor_revision_level;	uint32_t lastcheck;	uint32_t checkinterval;	uint32_t creator_os;	uint32_t revision_level;	uint16_t uid_reserved;	uint16_t gid_reserved;	uint32_t first_inode;	uint16_t inode_size;	uint16_t block_group_number;	uint32_t feature_compatibility;	uint32_t feature_incompat;	uint32_t feature_ro_compat;	uint32_t unique_id[4];	char volume_name[16];	char last_mounted_on[64];	uint32_t compression_info;};/* The ext2 blockgroup.  */struct ext2_block_group {	uint32_t block_id;	uint32_t inode_id;	uint32_t inode_table_id;	uint16_t free_blocks;	uint16_t free_inodes;	uint16_t pad;	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;uint32_t *indir1_block = NULL;int indir1_size = 0;int indir1_blkno = -1;uint32_t *indir2_block = NULL;int indir2_size = 0;int indir2_blkno = -1;static int ext2fs_blockgroup	(struct ext2_data *data, int group, struct ext2_block_group *blkgrp) {#ifdef DEBUG	printf ("ext2fs read blockgroup\n");#endif	return (ext2fs_devread		(((__le32_to_cpu (data->sblock.first_data_block) +		   1) << LOG2_EXT2_BLOCK_SIZE (data)),		 group * sizeof (struct ext2_block_group),		 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;	struct ext2_sblock *sblock = &data->sblock;	int inodes_per_block;	int status;	unsigned int blkno;	unsigned int blkoff;	/* It is easier to calculate if the first inode is 0.  */	ino--;#ifdef DEBUG	printf ("ext2fs read inode %d\n", ino);#endif	status = ext2fs_blockgroup (data,				    ino /				    __le32_to_cpu (sblock->inodes_per_group),				    &blkgrp);	if (status == 0) {		return (0);	}	inodes_per_block = EXT2_BLOCK_SIZE (data) / 128;	blkno = (ino % __le32_to_cpu (sblock->inodes_per_group)) /		inodes_per_block;	blkoff = (ino % __le32_to_cpu (sblock->inodes_per_group)) %		inodes_per_block;#ifdef DEBUG	printf ("ext2fs read inode blkno %d blkoff %d\n", blkno, blkoff);#endif	/* Read the inode.  */	status = ext2fs_devread (((__le32_to_cpu (blkgrp.inode_table_id) +				   blkno) << LOG2_EXT2_BLOCK_SIZE (data)),				 sizeof (struct ext2_inode) * blkoff,				 sizeof (struct ext2_inode), (char *) inode);	if (status == 0) {		return (0);	}	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) != indir1_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;	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);	/* 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 = ext2fs_read_block (node, 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 the block number is 0 this block is not stored on disk but		   is zero filled instead.  */		if (blknr) {			int status;			status = ext2fs_devread (blknr, skipfirst, blockend, buf);			if (status == 0) {				return (-1);			}		} else {			memset (buf, blocksize - skipfirst, 0);		}