From ec8ea0c2815fc0ee62597a6e37cdd7397a289136 Mon Sep 17 00:00:00 2001 From: Andy Green Date: Fri, 28 Nov 2008 10:16:37 +0000 Subject: [PATCH] add-ext2-fs.patch This adds ext2 support from U-Boot and stitches it into the partition stuff. It also upgrades the board definitions so they can define the path to look for in the ext2 filesystem being mounted. I used /boot/uImage.bin because this is already in use by the packaged kernel. We now mount, open and pull the kernel from ext2 in phase2.c if the kernel source defines it. Signed-off-by: Andy Green --- qiboot/Makefile | 3 +- qiboot/include/ext2.h | 80 +++ qiboot/include/image.h | 6 +- qiboot/include/qi.h | 11 +- qiboot/src/drivers/glamo-mmc.c | 25 +- qiboot/src/fs/dev.c | 115 +++++ qiboot/src/fs/ext2.c | 867 +++++++++++++++++++++++++++++++++ qiboot/src/gta02/gta02.c | 5 +- qiboot/src/gta03/gta03.c | 2 +- qiboot/src/phase2.c | 146 ++++-- qiboot/src/start_qi.c | 1 - qiboot/src/utils.c | 81 ++- 12 files changed, 1269 insertions(+), 73 deletions(-) create mode 100644 qiboot/include/ext2.h create mode 100644 qiboot/src/fs/dev.c create mode 100644 qiboot/src/fs/ext2.c diff --git a/qiboot/Makefile b/qiboot/Makefile index 5276ea3..cdb075e 100644 --- a/qiboot/Makefile +++ b/qiboot/Makefile @@ -34,7 +34,8 @@ LDFLAGS = #START = start.o lowlevel_init.o S_SRCS = src/start.S src/lowlevel_init.S S_OBJS = $(patsubst %.S,%.o, $(S_SRCS)) -C_SRCS = $(wildcard src/*.c) $(wildcard src/gt*/*.c) $(wildcard src/drivers/*.c) +C_SRCS = $(wildcard src/*.c) $(wildcard src/gt*/*.c) \ + $(wildcard src/drivers/*.c) $(wildcard src/fs/*.c) C_OBJS = $(patsubst %.c,%.o, $(C_SRCS)) #SRCS := $(START: .o=.S) $(COBJS: .o=.c) diff --git a/qiboot/include/ext2.h b/qiboot/include/ext2.h new file mode 100644 index 0000000..85b0860 --- /dev/null +++ b/qiboot/include/ext2.h @@ -0,0 +1,80 @@ +/* + * GRUB -- GRand Unified Bootloader + * Copyright (C) 2000, 2001 Free Software Foundation, Inc. + * + * (C) Copyright 2003 Sysgo Real-Time Solutions, AG + * Pavel Bartusek + * + * 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. + */ + +/* An implementation for the Ext2FS filesystem ported from GRUB. + * Some parts of this code (mainly the structures and defines) are + * from the original ext2 fs code, as found in the linux kernel. + */ + + +#define SECTOR_SIZE 0x200 +#define SECTOR_BITS 9 + +/* Error codes */ +typedef enum +{ + ERR_NONE = 0, + ERR_BAD_FILENAME, + ERR_BAD_FILETYPE, + ERR_BAD_GZIP_DATA, + ERR_BAD_GZIP_HEADER, + ERR_BAD_PART_TABLE, + ERR_BAD_VERSION, + ERR_BELOW_1MB, + ERR_BOOT_COMMAND, + ERR_BOOT_FAILURE, + ERR_BOOT_FEATURES, + ERR_DEV_FORMAT, + ERR_DEV_VALUES, + ERR_EXEC_FORMAT, + ERR_FILELENGTH, + ERR_FILE_NOT_FOUND, + ERR_FSYS_CORRUPT, + ERR_FSYS_MOUNT, + ERR_GEOM, + ERR_NEED_LX_KERNEL, + ERR_NEED_MB_KERNEL, + ERR_NO_DISK, + ERR_NO_PART, + ERR_NUMBER_PARSING, + ERR_OUTSIDE_PART, + ERR_READ, + ERR_SYMLINK_LOOP, + ERR_UNRECOGNIZED, + ERR_WONT_FIT, + ERR_WRITE, + ERR_BAD_ARGUMENT, + ERR_UNALIGNED, + ERR_PRIVILEGED, + ERR_DEV_NEED_INIT, + ERR_NO_DISK_SPACE, + ERR_NUMBER_OVERFLOW, + + MAX_ERR_NUM +} ext2fs_error_t; + + +extern int ext2fs_ls(char *dirname); +extern int ext2fs_open(const char *filename); +extern int ext2fs_read(char *buf, unsigned len); +extern int ext2fs_mount(void); +extern int ext2fs_close(void); diff --git a/qiboot/include/image.h b/qiboot/include/image.h index 2e3c6ef..af9ecda 100644 --- a/qiboot/include/image.h +++ b/qiboot/include/image.h @@ -33,8 +33,6 @@ #ifndef __IMAGE_H__ #define __IMAGE_H__ -#include - /* * Operating System Codes */ @@ -204,8 +202,8 @@ typedef struct bootm_headers { */ #define CHUNKSZ (64 * 1024) -#define uimage_to_cpu(x) ntohl(x) -#define cpu_to_uimage(x) htonl(x) +#define uimage_to_cpu(x) __be32_to_cpu(x) +#define cpu_to_uimage(x) __cpu_to_be32(x) const char *genimg_get_os_name (uint8_t os); const char *genimg_get_arch_name (uint8_t arch); diff --git a/qiboot/include/qi.h b/qiboot/include/qi.h index 01cf2fa..3429e9b 100644 --- a/qiboot/include/qi.h +++ b/qiboot/include/qi.h @@ -23,11 +23,15 @@ #include #include +#include + #define u32 unsigned int #define u16 unsigned short #define u8 unsigned char typedef unsigned int uint32_t; +typedef unsigned short uint16_t; +typedef unsigned char uint8_t; #define ARRAY_SIZE(x) (sizeof(x) / sizeof(x[0])) @@ -41,11 +45,12 @@ enum filesystem { struct kernel_source { const char *name; /* NULL name means invalid */ + const char *filepath; int (*block_init)(void); int (*block_read)(unsigned char * buf, unsigned long start512, int blocks512); int partition_index; /* -1 means no partition table */ - int offset_if_no_partition; /* used if partition_index is -1 */ + int offset_blocks512_if_no_partition; /* used if partition_index is -1 */ enum filesystem filesystem; const char * commandline; }; @@ -75,6 +80,7 @@ struct board_api { /* this is the board we are running on */ extern struct board_api const * this_board; +extern struct kernel_source const * this_kernel; int printk(const char *fmt, ...); int vsprintf(char *buf, const char *fmt, va_list args); @@ -84,8 +90,7 @@ void print8(unsigned char u); void print32(unsigned int u); void printdec(int n); void hexdump(unsigned char *start, int len); -unsigned int _ntohl(unsigned int n); -unsigned int _letocpu(unsigned int n); + unsigned long crc32(unsigned long crc, const unsigned char *buf, unsigned int len); int nand_read_ll(unsigned char *buf, unsigned long start512, int blocks512); diff --git a/qiboot/src/drivers/glamo-mmc.c b/qiboot/src/drivers/glamo-mmc.c index 4f383dd..051c810 100644 --- a/qiboot/src/drivers/glamo-mmc.c +++ b/qiboot/src/drivers/glamo-mmc.c @@ -316,6 +316,7 @@ static int mmc_cmd(int opcode, int arg, int flags, return 0; if (error) { +#if 0 puts("cmd 0x"); print8(opcode); puts(", arg 0x"); @@ -323,7 +324,6 @@ static int mmc_cmd(int opcode, int arg, int flags, puts(", flags 0x"); print32(flags); puts("\n"); -#if 1 puts("Error after cmd: 0x"); print32(error); puts("\n"); @@ -366,7 +366,7 @@ static int mmc_cmd(int opcode, int arg, int flags, error = -5; if (error) { // printf("cmd 0x%x, arg 0x%x flags 0x%x\n", opcode, arg, flags); -#if 1 +#if 0 puts("Error after resp: 0x"); print32(status); puts("\n"); @@ -530,43 +530,42 @@ static void print_sd_cid(const struct sd_cid *cid) puts(" Card Type: "); switch (card_type) { case CARDTYPE_NONE: - puts("(None)\n"); + puts("(None) / "); break; case CARDTYPE_MMC: - puts("MMC\n"); + puts("MMC / "); break; case CARDTYPE_SD: - puts("SD\n"); + puts("SD / "); break; case CARDTYPE_SD20: - puts("SD 2.0\n"); + puts("SD 2.0 / "); break; case CARDTYPE_SDHC: - puts("SD 2.0 SDHC\n"); + puts("SD 2.0 SDHC / "); break; } - puts(" Manufacturer: 0x"); + puts("Mfr: 0x"); print8(cid->mid); puts(", OEM \""); this_board->putc(cid->oid_0); this_board->putc(cid->oid_1); - puts("\"\n"); + puts("\" / "); - puts(" Product name: \""); this_board->putc(cid->pnm_0); this_board->putc(cid->pnm_1); this_board->putc(cid->pnm_2); this_board->putc(cid->pnm_3); this_board->putc(cid->pnm_4); - puts("\", revision "); + puts("\", rev "); printdec(cid->prv >> 4); puts("."); printdec(cid->prv & 15); - puts("\nSerial number: "); + puts(" / s/n: "); printdec(cid->psn_0 << 24 | cid->psn_1 << 16 | cid->psn_2 << 8 | cid->psn_3); - puts("\n Manf. date: "); + puts(" / date: "); printdec(cid->mdt_1 & 15); puts("/"); printdec(2000 + ((cid->mdt_0 & 15) << 4)+((cid->mdt_1 & 0xf0) >> 4)); diff --git a/qiboot/src/fs/dev.c b/qiboot/src/fs/dev.c new file mode 100644 index 0000000..ebe8d6e --- /dev/null +++ b/qiboot/src/fs/dev.c @@ -0,0 +1,115 @@ +/* + * (C) Copyright 2004 + * esd gmbh + * Reinhard Arlt + * + * based on code of fs/reiserfs/dev.c by + * + * (C) Copyright 2003 - 2004 + * Sysgo AG, , Pavel Bartusek + * + * 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 +#include +#include + +extern unsigned long partition_offset_blocks; +extern unsigned long partition_length_blocks; + + +int ext2fs_devread(int sector, int byte_offset, int byte_len, u8 *buf) +{ + unsigned char sec_buf[SECTOR_SIZE]; + unsigned block_len; + +/* + * Check partition boundaries + */ + if ((sector < 0) + || ((sector + ((byte_offset + byte_len - 1) >> SECTOR_BITS)) >= + partition_length_blocks)) { + /* errnum = ERR_OUTSIDE_PART; */ + puts(" ** ext2fs_devread() read outside partition sector "); + printdec(sector); + puts("\n"); + return 0; + } + +/* + * Get the read to the beginning of a partition. + */ + sector += byte_offset >> SECTOR_BITS; + byte_offset &= SECTOR_SIZE - 1; + + if (byte_offset) { + int minimum = SECTOR_SIZE - byte_offset; + + if (byte_len < minimum) + minimum = byte_len; + + /* read first part which isn't aligned with start of sector */ + if ((this_kernel->block_read)(sec_buf, + partition_offset_blocks + sector, 1) < 0) { + puts(" ** ext2fs_devread() read error **\n"); + return 0; + } + memcpy(buf, sec_buf + byte_offset, + minimum); + buf += minimum; + byte_len -= minimum; + sector++; + } + + if (!byte_len) + return 1; + + /* read sector aligned part */ + block_len = byte_len & ~(SECTOR_SIZE - 1); + + if (block_len == 0) { + u8 p[SECTOR_SIZE]; + + block_len = SECTOR_SIZE; + this_kernel->block_read(p, + partition_offset_blocks + sector, 1); + memcpy(buf, p, byte_len); + return 1; + } + + if (this_kernel->block_read(buf, partition_offset_blocks + sector, + block_len / SECTOR_SIZE) < 0) { + puts(" ** ext2fs_devread() read error - block\n"); + return 0; + } + block_len = byte_len & ~(SECTOR_SIZE - 1); + buf += block_len; + byte_len -= block_len; + sector += block_len / SECTOR_SIZE; + + if (byte_len) { + /* read rest of data which are not in whole sector */ + if (this_kernel->block_read(sec_buf, + partition_offset_blocks + sector, 1) != 1) { + puts(" ** ext2fs_devread() read error - last part\n"); + return 0; + } + memcpy (buf, sec_buf, byte_len); + } + return 1; +} + diff --git a/qiboot/src/fs/ext2.c b/qiboot/src/fs/ext2.c new file mode 100644 index 0000000..25616e5 --- /dev/null +++ b/qiboot/src/fs/ext2.c @@ -0,0 +1,867 @@ +/* + *(C) Copyright 2004 + * esd gmbh + * Reinhard Arlt + * + * 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 + +#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 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 + puts("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 + puts("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 + puts("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); + + return !!status; +} + + +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) { + puts("** 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) { + puts("** 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) { + puts("** 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) { + puts("** 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) { + puts("** 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) { + puts("** 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) { + puts("** 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) { + puts("** 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) { + puts("** 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 { + puts("** 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, 0, blocksize - skipfirst); + + buf += blocksize - skipfirst; + } + return(len); +} + + +static int ext2fs_iterate_dir(ext2fs_node_t dir, char *name, ext2fs_node_t * fnode, int *ftype) +{ + unsigned int fpos = 0; + int status; + struct ext2fs_node *diro =(struct ext2fs_node *) dir; + +#ifdef DEBUG + if (name != NULL) + printf("Iterate dir %s\n", name); +#endif /* of DEBUG */ + if (!diro->inode_read) { + status = ext2fs_read_inode(diro->data, diro->ino, + &diro->inode); + if (status == 0) + return(0); + } + /* Search the file. */ + while (fpos < __le32_to_cpu(diro->inode.size)) { + struct ext2_dirent dirent; + + status = ext2fs_read_file(diro, fpos, + sizeof(struct ext2_dirent), + (char *) &dirent); + if (status < 1) + return 0; + + if (dirent.namelen != 0) { + char filename[256]; + ext2fs_node_t fdiro; + int type = FILETYPE_UNKNOWN; + + status = ext2fs_read_file(diro, + fpos + sizeof(struct ext2_dirent), + dirent.namelen, filename); + if (status < 1) + return(0); + + fdiro = malloc(sizeof(struct ext2fs_node)); + if (!fdiro) + return(0); + + + fdiro->data = diro->data; + fdiro->ino = __le32_to_cpu(dirent.inode); + + filename[dirent.namelen] = '\0'; + + if (dirent.filetype != FILETYPE_UNKNOWN) { + fdiro->inode_read = 0; + + if (dirent.filetype == FILETYPE_DIRECTORY) { + type = FILETYPE_DIRECTORY; + } else if (dirent.filetype == + FILETYPE_SYMLINK) { + type = FILETYPE_SYMLINK; + } else if (dirent.filetype == FILETYPE_REG) { + type = FILETYPE_REG; + } + } else { + /* The filetype can not be read from the dirent, get it from inode */ + + status = ext2fs_read_inode(diro->data, + __le32_to_cpu(dirent.inode), + &fdiro->inode); + if (status == 0) { + free(fdiro); + return(0); + } + fdiro->inode_read = 1; + + if ((__le16_to_cpu(fdiro->inode.mode) & + FILETYPE_INO_MASK) == + FILETYPE_INO_DIRECTORY) { + type = FILETYPE_DIRECTORY; + } else if ((__le16_to_cpu(fdiro->inode.mode) + & FILETYPE_INO_MASK) == + FILETYPE_INO_SYMLINK) { + type = FILETYPE_SYMLINK; + } else if ((__le16_to_cpu(fdiro->inode.mode) + & FILETYPE_INO_MASK) == + FILETYPE_INO_REG) { + type = FILETYPE_REG; + } + } +#ifdef DEBUG + printf("iterate >%s<\n", filename); +#endif /* of DEBUG */ + if ((name != NULL) &&(fnode != NULL) + &&(ftype != NULL)) { + if (strcmp(filename, name) == 0) { + *ftype = type; + *fnode = fdiro; + return 1; + } + } else { + if (fdiro->inode_read == 0) { + status = ext2fs_read_inode(diro->data, + __le32_to_cpu(dirent.inode), + &fdiro->inode); + if (status == 0) { + free(fdiro); + return(0); + } + fdiro->inode_read = 1; + } + switch(type) { + case FILETYPE_DIRECTORY: + puts(" "); + break; + case FILETYPE_SYMLINK: + puts(" "); + break; + case FILETYPE_REG: + puts(" "); + break; + default: + puts("< ? > "); + break; + } + printdec(__le32_to_cpu(fdiro->inode.size)); + puts(" "); + puts(filename); + puts("\n"); + } + free(fdiro); + } + fpos += __le16_to_cpu(dirent.direntlen); + } + return 0; +} + + +static char *ext2fs_read_symlink(ext2fs_node_t node) { + char *symlink; + struct ext2fs_node *diro = node; + int status; + + if (!diro->inode_read) { + status = ext2fs_read_inode(diro->data, diro->ino, + &diro->inode); + if (status == 0) { + return(0); + } + } + symlink = malloc(__le32_to_cpu(diro->inode.size) + 1); + if (!symlink) + return(0); + + /* If the filesize of the symlink is bigger than + 60 the symlink is stored in a separate block, + otherwise it is stored in the inode. */ + if (__le32_to_cpu(diro->inode.size) <= 60) { + strncpy(symlink, diro->inode.b.symlink, + __le32_to_cpu(diro->inode.size)); + } else { + status = ext2fs_read_file(diro, 0, + __le32_to_cpu(diro->inode.size), + symlink); + if (status == 0) { + free(symlink); + return(0); + } + } + symlink[__le32_to_cpu(diro->inode.size)] = '\0'; + return(symlink); +} + + +int ext2fs_find_file1 + (const char *currpath, + ext2fs_node_t currroot, ext2fs_node_t * currfound, int *foundtype) { + char fpath[strlen(currpath) + 1]; + char *name = fpath; + char *next; + int status; + int type = FILETYPE_DIRECTORY; + ext2fs_node_t currnode = currroot; + ext2fs_node_t oldnode = currroot; + + strncpy(fpath, currpath, strlen(currpath) + 1); + + /* Remove all leading slashes. */ + while (*name == '/') + name++; + + if (!*name) { + *currfound = currnode; + return 1; + } + + for(;;) { + int found; + + /* Extract the actual part from the pathname. */ + next = strchr(name, '/'); + if (next) { + /* Remove all leading slashes. */ + while (*next == '/') { + *(next++) = '\0'; + } + } + + /* At this point it is expected that the current node is a directory, check if this is true. */ + if (type != FILETYPE_DIRECTORY) { + ext2fs_free_node(currnode, currroot); + return(0); + } + + oldnode = currnode; + + /* Iterate over the directory. */ + found = ext2fs_iterate_dir(currnode, name, &currnode, &type); + if (found == 0) + return(0); + + if (found == -1) + break; + + /* Read in the symlink and follow it. */ + if (type == FILETYPE_SYMLINK) { + char *symlink; + + /* Test if the symlink does not loop. */ + if (++symlinknest == 8) { + ext2fs_free_node(currnode, currroot); + ext2fs_free_node(oldnode, currroot); + return(0); + } + + symlink = ext2fs_read_symlink(currnode); + ext2fs_free_node(currnode, currroot); + + if (!symlink) { + ext2fs_free_node(oldnode, currroot); + return(0); + } +#ifdef DEBUG + printf("Got symlink >%s<\n", symlink); +#endif /* of DEBUG */ + /* The symlink is an absolute path, go back to the root inode. */ + if (symlink[0] == '/') { + ext2fs_free_node(oldnode, currroot); + oldnode = &ext2fs_root->diropen; + } + + /* Lookup the node the symlink points to. */ + status = ext2fs_find_file1(symlink, oldnode, + &currnode, &type); + + free(symlink); + + if (status == 0) { + ext2fs_free_node(oldnode, currroot); + return(0); + } + } + + ext2fs_free_node(oldnode, currroot); + + /* Found the node! */ + if (!next || *next == '\0') { + *currfound = currnode; + *foundtype = type; + return(1); + } + name = next; + } + return -1; +} + + +int ext2fs_find_file + (const char *path, + ext2fs_node_t rootnode, ext2fs_node_t * foundnode, int expecttype) { + int status; + int foundtype = FILETYPE_DIRECTORY; + + + symlinknest = 0; + if (!path) + return(0); + + status = ext2fs_find_file1(path, rootnode, foundnode, &foundtype); + if (status == 0) + return 0; + + /* Check if the node that was found was of the expected type. */ + if ((expecttype == FILETYPE_REG) &&(foundtype != expecttype)) { + return 0; + } else if ((expecttype == FILETYPE_DIRECTORY) + &&(foundtype != expecttype)) { + return 0; + } + return 1; +} + + +int ext2fs_ls(char *dirname) { + ext2fs_node_t dirnode; + int status; + + if (ext2fs_root == NULL) + return 0; + + status = ext2fs_find_file(dirname, &ext2fs_root->diropen, &dirnode, + FILETYPE_DIRECTORY); + if (status != 1) { + puts("** Can not find directory. **\n"); + return 1; + } + ext2fs_iterate_dir(dirnode, NULL, NULL, NULL); + ext2fs_free_node(dirnode, &ext2fs_root->diropen); + return 0; +} + + +int ext2fs_open(const char *filename) { + ext2fs_node_t fdiro = NULL; + int status; + int len; + + if (ext2fs_root == NULL) + return -1; + + ext2fs_file = NULL; + status = ext2fs_find_file(filename, &ext2fs_root->diropen, &fdiro, + FILETYPE_REG); + if (status == 0) + goto fail; + + if (!fdiro->inode_read) { + status = ext2fs_read_inode(fdiro->data, fdiro->ino, + &fdiro->inode); + if (status == 0) + goto fail; + } + len = __le32_to_cpu(fdiro->inode.size); + ext2fs_file = fdiro; + return(len); + +fail: + ext2fs_free_node(fdiro, &ext2fs_root->diropen); + return -1; +} + + +int ext2fs_close(void + ) { + if ((ext2fs_file != NULL) &&(ext2fs_root != NULL)) { + ext2fs_free_node(ext2fs_file, &ext2fs_root->diropen); + ext2fs_file = NULL; + } + if (ext2fs_root != NULL) { + free(ext2fs_root); + ext2fs_root = NULL; + } + if (indir1_block != NULL) { + free(indir1_block); + indir1_block = NULL; + indir1_size = 0; + indir1_blkno = -1; + } + if (indir2_block != NULL) { + free(indir2_block); + indir2_block = NULL; + indir2_size = 0; + indir2_blkno = -1; + } + return(0); +} + + +int ext2fs_read(char *buf, unsigned len) { + int status; + + if (ext2fs_root == NULL) + return 0; + + if (ext2fs_file == NULL) + return 0; + + status = ext2fs_read_file(ext2fs_file, 0, len, buf); + return status; +} + + +int ext2fs_mount(void) { + struct ext2_data *data; + int status; + + 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) + goto fail; + + /* Make sure this is an ext2 filesystem. */ + if (__le16_to_cpu(data->sblock.magic) != EXT2_MAGIC) + goto fail; + + data->diropen.data = data; + data->diropen.ino = 2; + data->diropen.inode_read = 1; + data->inode = &data->diropen.inode; + + status = ext2fs_read_inode(data, 2, data->inode); + if (status == 0) + goto fail; + + ext2fs_root = data; + + return 1; + +fail: + puts("Failed to mount ext2 filesystem...\n"); + free(data); + ext2fs_root = NULL; + + return 0; +} + diff --git a/qiboot/src/gta02/gta02.c b/qiboot/src/gta02/gta02.c index cda7a2b..fd84329 100644 --- a/qiboot/src/gta02/gta02.c +++ b/qiboot/src/gta02/gta02.c @@ -310,11 +310,12 @@ const struct board_api board_api_gta02 = { /* these are the ways we could boot GTA02 in order to try */ .kernel_source = { [0] = { - .name = "SD Card FAT Kernel", + .name = "SD Card EXT2 Kernel", .block_init = sd_card_init_gta02, .block_read = sd_card_block_read_gta02, .partition_index = 1, .filesystem = FS_EXT2, + .filepath = "boot/uImage.bin", .commandline = "mtdparts=physmap-flash:-(nor);" \ "neo1973-nand:" \ "0x00040000(qi)," \ @@ -333,7 +334,7 @@ const struct board_api board_api_gta02 = { [1] = { .name = "NAND Kernel", .block_read = nand_read_ll, - .offset_if_no_partition = 0x80000 / 512, + .offset_blocks512_if_no_partition = 0x80000 / 512, .filesystem = FS_RAW, .commandline = "mtdparts=physmap-flash:-(nor);" \ "neo1973-nand:" \ diff --git a/qiboot/src/gta03/gta03.c b/qiboot/src/gta03/gta03.c index 90f5908..778fda5 100644 --- a/qiboot/src/gta03/gta03.c +++ b/qiboot/src/gta03/gta03.c @@ -234,7 +234,7 @@ const struct board_api board_api_gta03 = { [0] = { .name = "NAND Kernel", .block_read = nand_read_ll, - .offset_if_no_partition = 0x80000 / 512, + .offset_blocks512_if_no_partition = 0x80000 / 512, .filesystem = FS_RAW, .commandline = "neo1973-nand:" \ "0x00040000(qi)," \ diff --git a/qiboot/src/phase2.c b/qiboot/src/phase2.c index 7543e49..fe8b0ec 100644 --- a/qiboot/src/phase2.c +++ b/qiboot/src/phase2.c @@ -27,9 +27,14 @@ #include #define __ARM__ #include - #include #include "nand_read.h" +#include + +unsigned long partition_offset_blocks = 0; +unsigned long partition_length_blocks = 0; + +struct kernel_source const * this_kernel = 0; void bootloader_second_phase(void) @@ -41,52 +46,57 @@ void bootloader_second_phase(void) /* we try the possible kernels for this board in order */ - while (this_board->kernel_source[kernel].name) { - const char * cmdline = this_board->kernel_source[kernel].commandline; - const char *p = cmdline; + this_kernel = &this_board->kernel_source[kernel++]; + + while (this_kernel->name) { + const char *p; struct tag *params = (struct tag *)this_board->linux_tag_placement; void * kernel_dram = (void *)(TEXT_BASE - (8 * 1024 * 1024)); unsigned long crc; image_header_t *hdr; - unsigned long partition_offset_blocks = 0; - unsigned long partition_length_blocks = 0; + u32 kernel_size; + + partition_offset_blocks = 0; + partition_length_blocks = 0; /* eat leading white space */ - for (p = cmdline; *p == ' '; p++); + for (p = this_kernel->commandline; *p == ' '; p++); - puts("\nTrying kernel: "); - puts(this_board->kernel_source[kernel].name); + puts("\n\nTrying kernel: "); + puts(this_kernel->name); puts("\n"); /* if this device needs initializing, try to init it */ - if (this_board->kernel_source[kernel].block_init) - if ((this_board->kernel_source[kernel].block_init)()) { + if (this_kernel->block_init) + if ((this_kernel->block_init)()) { puts("block device init failed\n"); - kernel++; + this_kernel = &this_board-> + kernel_source[kernel++]; continue; } /* if there's a partition table implied, parse it, otherwise * just use a fixed offset */ - if (this_board->kernel_source[kernel].partition_index) { + if (this_kernel->partition_index) { unsigned char *p = kernel_dram; - if (this_board->kernel_source[kernel].block_read( - kernel_dram, 0, 4) < 0) { + if (this_kernel->block_read(kernel_dram, 0, 4) < 0) { puts("Bad partition read\n"); - kernel++; + this_kernel = &this_board-> + kernel_source[kernel++]; continue; } if ((p[0x1fe] != 0x55) || (p[0x1ff] != 0xaa)) { puts("partition signature missing\n"); - kernel++; + this_kernel = &this_board-> + kernel_source[kernel++]; continue; } - p += 0x1be + 8 + (0x10 * (this_board-> - kernel_source[kernel].partition_index - 1)); + p += 0x1be + 8 + (0x10 * + (this_kernel->partition_index - 1)); partition_offset_blocks = (((u32)p[3]) << 24) | (((u32)p[2]) << 16) | @@ -97,39 +107,89 @@ void bootloader_second_phase(void) (((u32)p[5]) << 8) | p[4]; - } else - partition_offset_blocks = this_board-> - kernel_source[kernel].offset_if_no_partition; + puts(" Partition: "); + printdec(this_kernel->partition_index); + puts(" start +"); + printdec(partition_offset_blocks); + puts(" 512-byte blocks, size "); + printdec(partition_length_blocks / 2048); + puts(" MiB\n"); - if (this_board->kernel_source[kernel].block_read( - kernel_dram, partition_offset_blocks, 8) < 0) { - puts ("Bad kernel header\n"); - kernel++; - continue; + } else + partition_offset_blocks = + this_kernel->offset_blocks512_if_no_partition; + + switch (this_kernel->filesystem) { + case FS_EXT2: + if (!ext2fs_mount()) { + puts("Unable to mount ext2 filesystem\n"); + this_kernel = &this_board-> + kernel_source[kernel++]; + continue; + } + puts(" EXT2 open: "); + puts(this_kernel->filepath); + puts("\n"); + if (ext2fs_open(this_kernel->filepath) < 0) { + puts("Open failed\n"); + this_kernel = &this_board-> + kernel_source[kernel++]; + continue; + } + ext2fs_read(kernel_dram, 4096); + break; + case FS_FAT: + /* FIXME */ + case FS_RAW: + puts(" RAW open: +"); + printdec(partition_offset_blocks); + puts(" 512-byte blocks\n"); + if (this_kernel->block_read(kernel_dram, + partition_offset_blocks, 8) < 0) { + puts ("Bad kernel header\n"); + this_kernel = &this_board-> + kernel_source[kernel++]; + continue; + } + break; } hdr = (image_header_t *)kernel_dram; - if (_ntohl(hdr->ih_magic) != IH_MAGIC) { + if (__be32_to_cpu(hdr->ih_magic) != IH_MAGIC) { puts("bad magic "); print32(hdr->ih_magic); - kernel++; + puts("\n"); + this_kernel = &this_board->kernel_source[kernel++]; continue; } - puts(" Found: "); + puts(" Found: \""); puts((const char *)hdr->ih_name); - puts("\n Size: "); - printdec(_ntohl(hdr->ih_size) >> 10); + puts("\"\n Size: "); + printdec(__be32_to_cpu(hdr->ih_size) >> 10); puts(" KiB\n"); - if ((this_board->kernel_source[kernel].block_read)( - kernel_dram, partition_offset_blocks, - ((_ntohl(hdr->ih_size) + sizeof(image_header_t) + - 2048) & ~(2048 - 1)) >> 9) < 0) { - puts ("Bad kernel read\n"); - kernel++; - continue; + kernel_size = ((__be32_to_cpu(hdr->ih_size) + + sizeof(image_header_t) + 2048) & ~(2048 - 1)); + + switch (this_kernel->filesystem) { + case FS_EXT2: + /* This read API always restarts from beginning */ + ext2fs_read(kernel_dram, kernel_size); + break; + case FS_FAT: + /* FIXME */ + case FS_RAW: + if ((this_kernel->block_read)( + kernel_dram, partition_offset_blocks, + kernel_size >> 9) < 0) { + puts ("Bad kernel read\n"); + this_kernel = &this_board-> + kernel_source[kernel++]; + continue; + } + break; } puts(" Cmdline: "); @@ -142,14 +202,14 @@ void bootloader_second_phase(void) * even though it costs us some time */ crc = crc32(0, kernel_dram + sizeof(image_header_t), - _ntohl(hdr->ih_size)); - if (crc != _ntohl(hdr->ih_dcrc)) { + __be32_to_cpu(hdr->ih_size)); + if (crc != __be32_to_cpu(hdr->ih_dcrc)) { puts("\nKernel CRC ERROR: read 0x"); print32(crc); puts(" vs hdr CRC 0x"); - print32(_ntohl(hdr->ih_dcrc)); + print32(__be32_to_cpu(hdr->ih_dcrc)); puts("\n"); - kernel++; + this_kernel = &this_board->kernel_source[kernel++]; continue; } diff --git a/qiboot/src/start_qi.c b/qiboot/src/start_qi.c index 3d993fd..d4f4905 100644 --- a/qiboot/src/start_qi.c +++ b/qiboot/src/start_qi.c @@ -98,7 +98,6 @@ void start_qi(void) puts(", "); board_variant = (this_board->get_board_variant)(); puts(board_variant->name); - puts("\n"); /* * jump to bootloader_second_phase() running from DRAM copy diff --git a/qiboot/src/utils.c b/qiboot/src/utils.c index 62f7c17..3d72ec2 100644 --- a/qiboot/src/utils.c +++ b/qiboot/src/utils.c @@ -23,6 +23,9 @@ #include #include +static u8 malloc_pool[100 * 1024]; +void * malloc_pointer = &malloc_pool[0]; + int raise(int n) { return 0; @@ -49,15 +52,39 @@ char *strcpy(char *dest, const char *src) return dest_orig; } -unsigned int _ntohl(unsigned int n) { - return ((n & 0xff) << 24) | ((n & 0xff00) << 8) | - ((n & 0xff0000) >> 8) | ((n & 0xff000000) >> 24); +char *strncpy(char *dest, const char *src, size_t n) +{ + char * dest_orig = dest; + + while (*src && n--) + *dest++ = *src++; + + return dest_orig; } -unsigned int _letocpu(unsigned int n) { - return n; + +int strcmp(const char *s1, const char *s2) +{ + while (1) { + if (*s1 != *s2) + return *s1 - *s2; + if (!*s1) + return 0; + s1++; + s2++; + } } +char *strchr(const char *s, int c) +{ + while ((*s) && (*s != c)) + s++; + + if (*s == c) + return (char *)s; + + return NULL; +} int puts(const char *string) { @@ -214,3 +241,47 @@ unsigned long crc32(unsigned long crc, const unsigned char *buf, return crc ^ 0xffffffffL; } + +void *memcpy(void *dest, const void *src, size_t n) +{ + u8 const * ps = src; + u8 * pd = dest; + + while (n--) + *pd++ = *ps++; + + return dest; +} + +void *memset(void *s, int c, size_t n) +{ + u8 * p = s; + + while (n--) + *p++ = c; + + return s; +} + +/* improbably simple malloc and free for small and non-intense allocation + * just moves the allocation ptr forward each time and ignores free + */ + +void *malloc(size_t size) +{ + void *p = malloc_pointer; + + malloc_pointer += size; + + if (((u8 *)malloc_pointer - &malloc_pool[0]) > sizeof(malloc_pool)) { + puts("Ran out of malloc pool\n"); + while (1) + ; + } + + return p; +} + +void free(void *ptr) +{ +}