//========================================================================== // // e2fs.c // // RedBoot support for second extended filesystem // //========================================================================== //####ECOSGPLCOPYRIGHTBEGIN#### // ------------------------------------------- // This file is part of eCos, the Embedded Configurable Operating System. // Copyright (C) 1998, 1999, 2000, 2001, 2002 Red Hat, Inc. // Copyright (C) 2003 Gary Thomas // // eCos 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 or (at your option) any later version. // // eCos 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 eCos; if not, write to the Free Software Foundation, Inc., // 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA. // // As a special exception, if other files instantiate templates or use macros // or inline functions from this file, or you compile this file and link it // with other works to produce a work based on this file, this file does not // by itself cause the resulting work to be covered by the GNU General Public // License. However the source code for this file must still be made available // in accordance with section (3) of the GNU General Public License. // // This exception does not invalidate any other reasons why a work based on // this file might be covered by the GNU General Public License. // // Alternative licenses for eCos may be arranged by contacting Red Hat, Inc. // at http://sources.redhat.com/ecos/ecos-license/ // ------------------------------------------- //####ECOSGPLCOPYRIGHTEND#### //========================================================================== //#####DESCRIPTIONBEGIN#### // // Author(s): msalter // Contributors: msalter // Date: 2001-07-14 // Purpose: // Description: // // This code is part of RedBoot (tm). // //####DESCRIPTIONEND#### // //========================================================================== #include #include #include #define DEBUG_E2FS 0 #if DEBUG_E2FS > 4 static void dump_sb(struct e2fs_super_block *s); static void dump_inode(struct e2fs_inode *i); #endif static void *e2fs_open(partition_t *p, const char *path); static int e2fs_read(void *fp, char *buf, cyg_uint32 nbytes); // This structure is the only thing exported by this module. // These filesystem function pointers are attached to disk // partitions in the generic disk handling code. // fs_funs_t redboot_e2fs_funs = { e2fs_open, e2fs_read }; // A single block buffer to be shared carefully. static cyg_uint32 blockbuf[E2FS_MAX_BLOCK_SIZE/sizeof(cyg_uint32)]; #define __READ_BLOCK(n) \ PARTITION_READ(e2fs->part, E2FS_BLOCK_TO_SECTOR(e2fs, (n)), \ blockbuf, e2fs->blocksize/SECTOR_SIZE) // Get a group descriptor. Returns non-zero for success. // static int e2fs_get_gdesc(e2fs_desc_t *e2fs, cyg_uint32 group_nr, e2fs_group_t *gdesc) { cyg_uint32 sec_nr; if (group_nr < e2fs->gdesc_first || group_nr >= (e2fs->gdesc_first + E2FS_GDESC_CACHE_SIZE)) { // cache miss sec_nr = E2FS_BLOCK_TO_SECTOR(e2fs, e2fs->gdesc_block); sec_nr += (group_nr / E2FS_GDESC_PER_SECTOR); #if DEBUG_E2FS > 2 diag_printf("%s: group[%d] cache miss, sec_nr[%d]\n", __FUNCTION__, group_nr, sec_nr); #endif if (!PARTITION_READ(e2fs->part, sec_nr, (cyg_uint32 *)e2fs->gdesc_cache, sizeof(e2fs->gdesc_cache)/SECTOR_SIZE)) return 0; e2fs->gdesc_first = (group_nr / E2FS_GDESC_CACHE_SIZE) * E2FS_GDESC_CACHE_SIZE; } *gdesc = e2fs->gdesc_cache[group_nr - e2fs->gdesc_first]; return 1; } // Read the requested inode from disk. Return non-zero if successful // static int e2fs_get_inode(e2fs_desc_t *e2fs, int ino, e2fs_inode_t *ip) { cyg_uint32 offset, sec_nr, buf[SECTOR_SIZE/sizeof(cyg_uint32)]; e2fs_group_t gdesc; // get descriptor for group which this inode belongs to if (!e2fs_get_gdesc(e2fs, (ino - 1) / e2fs->inodes_per_group, &gdesc)) return 0; if (gdesc.inode_table == 0) return 0; // byte offset within group inode table offset = ((ino - 1) % e2fs->inodes_per_group) * sizeof(struct e2fs_inode); // figure out which sector holds the inode sec_nr = E2FS_BLOCK_TO_SECTOR(e2fs, SWAB_LE32(gdesc.inode_table)); sec_nr += offset / SECTOR_SIZE; // and the offset within that sector. offset %= SECTOR_SIZE; #if DEBUG_E2FS > 0x08 diag_printf("%s: ino[%d], sec_nr[%d] offset[%d]\n", __FUNCTION__, ino, sec_nr, offset); #endif if (!PARTITION_READ(e2fs->part, sec_nr, buf, 1)) return 0; *ip = *(e2fs_inode_t *)((char *)buf + offset); #if DEBUG_E2FS > 0 diag_printf("%s: inode size[%d]\n", __FUNCTION__, SWAB_LE32(ip->size)); #endif return 1; } // Mount an e2fs filesystem on the given partition. // Return 0 if successful. // static int e2fs_mount(partition_t *part, e2fs_desc_t *e2fs) { int sb_block = 1; cyg_uint32 sb_buf[E2FS_MIN_BLOCK_SIZE/sizeof(cyg_uint32)]; struct e2fs_super_block *sb = (struct e2fs_super_block *)sb_buf; e2fs->part = part; if (!PARTITION_READ(part, sb_block*(E2FS_MIN_BLOCK_SIZE/SECTOR_SIZE), (cyg_uint32 *)sb, E2FS_MIN_BLOCK_SIZE/SECTOR_SIZE)) return -1; if (SWAB_LE16(sb->magic) != E2FS_SUPER_MAGIC) { diag_printf("ext2_mount: bad magic 0x%x\n", SWAB_LE16(sb->magic)); return -1; } // save some stuff for easy access e2fs->blocksize = E2FS_BLOCK_SIZE(sb); e2fs->nr_ind_blocks = (e2fs)->blocksize / sizeof(cyg_uint32); e2fs->nr_dind_blocks = e2fs->nr_ind_blocks * ((e2fs)->blocksize / sizeof(cyg_uint32)); e2fs->nr_tind_blocks = e2fs->nr_dind_blocks * ((e2fs)->blocksize / sizeof(cyg_uint32)); e2fs->blocks_per_group = SWAB_LE32(sb->blocks_per_group); e2fs->ngroups = (SWAB_LE32(sb->blocks_count) + e2fs->blocks_per_group - 1) / e2fs->blocks_per_group; e2fs->inodes_per_group = SWAB_LE32(sb->inodes_per_group); // Find the group descriptors which follow superblock e2fs->gdesc_block = ((sb_block * E2FS_MIN_BLOCK_SIZE) / e2fs->blocksize) + 1; e2fs->gdesc_first = 0; // cache group 0 initially if (!PARTITION_READ(part, E2FS_BLOCK_TO_SECTOR(e2fs,e2fs->gdesc_block), (cyg_uint32 *)e2fs->gdesc_cache, 1)) return -1; #if DEBUG_E2FS > 1 diag_printf("E2FS superblock:\n"); diag_printf(" [%d] inodes\n", SWAB_LE32(sb->inodes_count)); diag_printf(" [%d] blocks\n", SWAB_LE32(sb->blocks_count)); diag_printf(" [%d] blocksize\n", e2fs->blocksize); diag_printf(" [%d] blocks per group\n", e2fs->blocks_per_group); diag_printf(" [%d] ngroups\n", e2fs->ngroups); #endif #if DEBUG_E2FS > 4 dump_sb(sb); #endif return 0; } // Convert a block index into inode data into a block_nr. // If successful, store block number in pblknr and return non-zero. // // NB: This needs some block/sector caching to be speedier. But // that takes memory and speed is not too bad now for files // small enough to avoid double and triple indirection. // static int e2fs_inode_block(e2fs_desc_t *e2fs, e2fs_inode_t *inode, cyg_uint32 bindex, cyg_uint32 *pblknr) { if (bindex < E2FS_NR_DIR_BLOCKS) { *pblknr = SWAB_LE32(inode->block[bindex]); return 1; } bindex -= E2FS_NR_DIR_BLOCKS; if (bindex < e2fs->nr_ind_blocks) { // Indirect block if (!__READ_BLOCK(SWAB_LE32(inode->block[E2FS_IND_BLOCK]))) return 0; *pblknr = SWAB_LE32(blockbuf[bindex]); return 1; } bindex -= e2fs->nr_ind_blocks; if (bindex < e2fs->nr_dind_blocks) { // Double indirect block if (!__READ_BLOCK(SWAB_LE32(inode->block[E2FS_DIND_BLOCK]))) return 0; if (!__READ_BLOCK(SWAB_LE32(blockbuf[bindex / e2fs->nr_ind_blocks]))) return 0; *pblknr = SWAB_LE32(blockbuf[bindex % e2fs->nr_ind_blocks]); return 1; } bindex -= e2fs->nr_dind_blocks; // Triple indirect block if (!__READ_BLOCK(SWAB_LE32(inode->block[E2FS_TIND_BLOCK]))) return 0; if (!__READ_BLOCK(SWAB_LE32(blockbuf[bindex / e2fs->nr_dind_blocks]))) return 0; bindex %= e2fs->nr_dind_blocks; if (!__READ_BLOCK(SWAB_LE32(blockbuf[bindex / e2fs->nr_ind_blocks]))) return 0; *pblknr = SWAB_LE32(blockbuf[bindex % e2fs->nr_ind_blocks]); return 1; } // search a single directory block in memory looking for an // entry with the given name. Return pointer to entry if // found, NULL if not. // static e2fs_dir_entry_t * search_dir_block(e2fs_desc_t *e2fs, cyg_uint32 *blkbuf, const char *name, int namelen) { e2fs_dir_entry_t *dir; cyg_uint16 reclen, len; cyg_uint32 offset; #if DEBUG_E2FS > 0 diag_dump_buf(blkbuf, e2fs->blocksize); #endif offset = 0; while (offset < e2fs->blocksize) { dir = (e2fs_dir_entry_t *)((char *)blkbuf + offset); reclen = SWAB_LE16(dir->reclen); offset += reclen; len = dir->namelen; // terminate on anything which doesn't make sense if (reclen < 8 || (len + 8) > reclen || offset > (e2fs->blocksize + 1)) return NULL; if (dir->inode && len == namelen && !strncmp(dir->name, name, len)) return dir; } return NULL; } // Look in the given directory for an entry with the given name. // If found, return a pointer to that entry. Return NULL if not // found. // static e2fs_dir_entry_t * e2fs_dir_lookup(e2fs_desc_t *e2fs, cyg_uint32 dir_ino, const char *name, int namelen) { e2fs_inode_t inode; e2fs_dir_entry_t *dir; cyg_uint32 nblocks, last_block_size, i, block_nr, nbytes; #if DEBUG_E2FS > 0 diag_printf("%s: looking for %s [%d] in ino[%d]\n", __FUNCTION__, name, namelen, dir_ino); #endif if (!e2fs_get_inode(e2fs, dir_ino, &inode)) { #if DEBUG_E2FS > 0 diag_printf("%s: e2fs_get_inode [%d] failed\n", __FUNCTION__, dir_ino); #endif return NULL; } nbytes = SWAB_LE32(inode.size); nblocks = (nbytes + e2fs->blocksize - 1) / e2fs->blocksize; last_block_size = nbytes % e2fs->blocksize; if (last_block_size == 0) last_block_size = e2fs->blocksize; for (i = 0; i < nblocks; i++) { if (!e2fs_inode_block(e2fs, &inode, i, &block_nr)) return NULL; if (block_nr) { if (!__READ_BLOCK(block_nr)) return NULL; } else memset(blockbuf, 0, e2fs->blocksize); dir = search_dir_block(e2fs, blockbuf, name, namelen); if (dir != NULL) return dir; } return NULL; } typedef struct ino_info { cyg_uint32 ino; cyg_uint32 parent_ino; cyg_uint8 filetype; } ino_info_t; static int e2fs_inode_lookup(e2fs_desc_t *e2fs, cyg_uint32 dir_ino, const char *pathname, ino_info_t *info); // Starting from the given directory, find the inode number, filetype, and // parent inode for the file pointed to by the given symbolic link inode. // If successful, fills out ino_info_t and return true. // static int e2fs_follow_symlink(e2fs_desc_t *e2fs, cyg_uint32 dir_ino, cyg_uint32 sym_ino, ino_info_t *info) { #define MAX_SYMLINK_NAME 255 char symlink[MAX_SYMLINK_NAME+1]; int pathlen; cyg_uint32 block_nr; e2fs_inode_t inode; if (!e2fs_get_inode(e2fs, sym_ino, &inode)) { #if DEBUG_E2FS > 0 diag_printf("%s: e2fs_get_inode [%d] failed\n", __FUNCTION__, sym_ino); #endif return 0; } pathlen = SWAB_LE32(inode.size); if (pathlen > MAX_SYMLINK_NAME) return 0; if (inode.blocks) { if (!e2fs_inode_block(e2fs, &inode, 0, &block_nr)) return 0; if (block_nr) { if (!PARTITION_READ(e2fs->part, E2FS_BLOCK_TO_SECTOR(e2fs, block_nr), blockbuf, e2fs->blocksize/SECTOR_SIZE)) return 0; memcpy(symlink, blockbuf, pathlen); } else return 0; } else { // small enough path to fit in inode struct memcpy(symlink, (char *)&inode.block[0], pathlen); } symlink[pathlen] = 0; return e2fs_inode_lookup(e2fs, dir_ino, symlink, info); } // Starting from the given directory, find the inode number, filetype, and // parent inode for the given file pathname. // If successful, fills out ino_info_t and return true. // static int e2fs_inode_lookup(e2fs_desc_t *e2fs, cyg_uint32 dir_ino, const char *pathname, ino_info_t *info) { int len, pathlen; const char *p; e2fs_dir_entry_t *dir = NULL; if (!pathname || (pathlen = strlen(pathname)) == 0) return 0; if (*pathname == '/') { if (--pathlen == 0) { info->ino = info->parent_ino = E2FS_ROOT_INO; info->filetype = E2FS_FTYPE_DIR; return 1; } ++pathname; dir_ino = E2FS_ROOT_INO; } while (pathlen) { // find next delimiter in path. for (p = pathname, len = 0; len < pathlen; len++, p++) { // skip delimiter if found. if (*p == '/') { ++p; --pathlen; break; } } dir = e2fs_dir_lookup(e2fs, dir_ino, pathname, len); if (dir == NULL) return 0; pathlen -= len; pathname = p; switch (dir->filetype) { case E2FS_FTYPE_SYMLINK: // follow the symbolic link (this will cause recursion) if (!e2fs_follow_symlink(e2fs, dir_ino, SWAB_LE32(dir->inode), info)) return 0; if (pathlen == 0) return 1; // must be a dir if we want to continue if (info->filetype != E2FS_FTYPE_DIR) return 0; dir_ino = info->ino; break; case E2FS_FTYPE_DIR: if (pathlen) dir_ino = SWAB_LE32(dir->inode); break; case E2FS_FTYPE_REG_FILE: if (pathlen) return 0; // regular file embedded in middle of path break; case E2FS_FTYPE_UNKNOWN: case E2FS_FTYPE_CHRDEV: case E2FS_FTYPE_BLKDEV: case E2FS_FTYPE_FIFO: case E2FS_FTYPE_SOCK: default: return 0; } } info->ino = SWAB_LE32(dir->inode); info->parent_ino = dir_ino; info->filetype = dir->filetype; return 1; } struct read_info { e2fs_desc_t e2fs_desc; e2fs_inode_t inode; cyg_uint32 fsize; cyg_uint32 fpos; }; static void * e2fs_open(partition_t *p, const char *filepath) { static struct read_info rinfo; ino_info_t ino_info; // mount partition if (e2fs_mount(p, &rinfo.e2fs_desc) != 0) { diag_printf("mount failed.\n"); return NULL; } // find file inode if (!e2fs_inode_lookup(&rinfo.e2fs_desc, E2FS_ROOT_INO, filepath, &ino_info)) { diag_printf("%s: e2fs_inode_lookup failed\n", __FUNCTION__); return NULL; } // read inode if (!e2fs_get_inode(&rinfo.e2fs_desc, ino_info.ino, &rinfo.inode)) { diag_printf("%s: e2fs_get_inode failed for ino[%d]\n", __FUNCTION__, ino_info.ino); return NULL; } rinfo.fsize = SWAB_LE32(rinfo.inode.size); rinfo.fpos = 0; return &rinfo; } static int e2fs_read(void *fp, char *buf, cyg_uint32 nbytes) { struct read_info *info = fp; e2fs_desc_t *e2fs; cyg_uint32 nread = 0, rem, block_nr, bindex, to_read; if ((info->fpos + nbytes) > info->fsize) nbytes = info->fsize - info->fpos; e2fs = &info->e2fs_desc; // see if we need to copy leftover data from last read call rem = e2fs->blocksize - (info->fpos % e2fs->blocksize); if (rem != e2fs->blocksize) { char *p = (char *)blockbuf + e2fs->blocksize - rem; if (rem > nbytes) rem = nbytes; memcpy(buf, p, rem); nread += rem; buf += rem; info->fpos += rem; } // now loop through blocks if we're not done bindex = info->fpos / e2fs->blocksize; while (nread < nbytes) { if (!e2fs_inode_block(e2fs, &info->inode, bindex, &block_nr)) return -1; if (block_nr) { if (!PARTITION_READ(e2fs->part, E2FS_BLOCK_TO_SECTOR(e2fs, block_nr), blockbuf, e2fs->blocksize/SECTOR_SIZE)) return 0; } else memset(blockbuf, 0, e2fs->blocksize); to_read = nbytes - nread; if (to_read > e2fs->blocksize) to_read = e2fs->blocksize; memcpy(buf, blockbuf, to_read); nread += to_read; buf += to_read; info->fpos += to_read; ++bindex; } return nread; } #if DEBUG_E2FS > 4 static void dump_sb(struct e2fs_super_block *s) { diag_printf("inode_count: %d\n", SWAB_LE32(s->inodes_count)); diag_printf("blocks_count: %d\n", SWAB_LE32(s->blocks_count)); diag_printf("r_blocks_count: %d\n", SWAB_LE32(s->r_blocks_count)); diag_printf("free_blocks_count: %d\n", SWAB_LE32(s->free_blocks_count)); diag_printf("free_inodes_count: %d\n", SWAB_LE32(s->free_inodes_count)); diag_printf("first_data_block: %d\n", SWAB_LE32(s->first_data_block)); diag_printf("log_block_size: %d\n", SWAB_LE32(s->log_block_size)); diag_printf("log_frag_size: %d\n", SWAB_LE32(s->log_frag_size)); diag_printf("blocks_per_group: %d\n", SWAB_LE32(s->blocks_per_group)); diag_printf("frags_per_group: %d\n", SWAB_LE32(s->frags_per_group)); diag_printf("inodes_per_group: %d\n", SWAB_LE32(s->inodes_per_group)); diag_printf("mnt_count: %d\n", SWAB_LE16(s->mnt_count)); diag_printf("max_mnt_count: %d\n", SWAB_LE16(s->max_mnt_count)); diag_printf("magic: %d\n", SWAB_LE16(s->magic)); diag_printf("state: %d\n", SWAB_LE16(s->state)); diag_printf("errors: %d\n", SWAB_LE16(s->errors)); diag_printf("minor_rev_level: %d\n", SWAB_LE16(s->minor_rev_level)); diag_printf("lastcheck: %d\n", SWAB_LE32(s->lastcheck)); diag_printf("checkinterval: %d\n", SWAB_LE32(s->checkinterval)); diag_printf("creator_os: %d\n", SWAB_LE32(s->creator_os)); diag_printf("rev_level: %d\n", SWAB_LE32(s->rev_level)); } static void dump_inode(struct e2fs_inode *i) { int j, n; diag_printf("mode: %o\n", SWAB_LE16(i->mode)); diag_printf("uid: %o\n", SWAB_LE16(i->uid)); diag_printf("size: %d\n", SWAB_LE32(i->size)); diag_printf("gid: %o\n", SWAB_LE16(i->gid)); diag_printf("links: %d\n", SWAB_LE16(i->links_count)); diag_printf("blocks: %d\n", SWAB_LE32(i->blocks)); n = i->blocks; if (n > E2FS_N_BLOCKS) n = E2FS_N_BLOCKS; for (j = 0; j < n; j++) diag_printf(" block: %d\n", SWAB_LE32(i->block[j])); } #endif