| /* |
| * This file is subject to the terms and conditions of the GNU General Public |
| * License. See the file "COPYING" in the main directory of this archive |
| * for more details. |
| * |
| * Copyright (C) Hewlett-Packard (Paul Bame) paul_bame@hp.com |
| */ |
| /* |
| * This is a set of functions that provides minimal filesystem |
| * functionality to the Linux bootstrapper. All we can do is |
| * open and read files... but that's all we need 8-) |
| * |
| * This file has been ported from the DEC 32-bit Linux version |
| * by David Mosberger (davidm@cs.arizona.edu). |
| */ |
| |
| /* The following defines are necessary to satisfy ext2_fs.h and |
| * things it pulls in. |
| */ |
| |
| #include <asm/byteorder.h> /* for le32_to_cpu et al */ |
| |
| #include <linux/types.h> |
| |
| #include <sys/stat.h> |
| |
| #include "ext2_fs.h" |
| #include "bootloader.h" |
| |
| #define MAX_OPEN_FILES 5 |
| |
| extern struct bootfs ext2fs; |
| |
| static struct ext2_super_block sb; |
| static struct ext2_group_desc *gds; |
| static struct ext2_inode *root_inode = NULL; |
| static int ngroups = 0; |
| static int directlim; /* Maximum direct blkno */ |
| static int ind1lim; /* Maximum single-indir blkno */ |
| static int ind2lim; /* Maximum double-indir blkno */ |
| static int ptrs_per_blk; /* ptrs/indirect block */ |
| static char blkbuf[EXT2_MAX_BLOCK_SIZE]; |
| static int cached_iblkno = -1; |
| static char iblkbuf[EXT2_MAX_BLOCK_SIZE]; |
| static int cached_diblkno = -1; |
| static char diblkbuf[EXT2_MAX_BLOCK_SIZE]; |
| static long dev = -1; |
| static long partition_offset; |
| |
| struct ext2_inode *fd2inode[MAX_FD]; |
| |
| static struct inode_table_entry { |
| struct ext2_inode inode; |
| int inumber; |
| int free; |
| unsigned short old_mode; |
| } inode_table[MAX_OPEN_FILES]; |
| |
| /* to work with existing palo I/O */ |
| #define cons_read(dev, addr, length, seekptr) \ |
| seekread(dev, (void *)addr, length, seekptr) |
| |
| #define inplace(xform, var) (var) = xform((var)) |
| |
| #undef DEBUG |
| #define Debug 0 |
| |
| |
| static void swapsb(struct ext2_super_block *sb) |
| { |
| inplace(__le32_to_cpu, sb->s_inodes_count); |
| inplace(__le32_to_cpu, sb->s_blocks_count); |
| inplace(__le32_to_cpu, sb->s_r_blocks_count); |
| inplace(__le32_to_cpu, sb->s_free_blocks_count); |
| inplace(__le32_to_cpu, sb->s_free_inodes_count); |
| inplace(__le32_to_cpu, sb->s_first_data_block); |
| inplace(__le32_to_cpu, sb->s_log_block_size); |
| inplace(__le32_to_cpu, sb->s_log_frag_size); |
| inplace(__le32_to_cpu, sb->s_blocks_per_group); |
| inplace(__le32_to_cpu, sb->s_frags_per_group); |
| inplace(__le32_to_cpu, sb->s_inodes_per_group); |
| inplace(__le32_to_cpu, sb->s_mtime); |
| inplace(__le32_to_cpu, sb->s_wtime); |
| |
| inplace(__le16_to_cpu, sb->s_mnt_count); |
| inplace(__le16_to_cpu, sb->s_max_mnt_count); |
| inplace(__le16_to_cpu, sb->s_magic); |
| inplace(__le16_to_cpu, sb->s_state); |
| inplace(__le16_to_cpu, sb->s_errors); |
| inplace(__le16_to_cpu, sb->s_minor_rev_level); |
| |
| inplace(__le32_to_cpu, sb->s_lastcheck); |
| inplace(__le32_to_cpu, sb->s_checkinterval); |
| inplace(__le32_to_cpu, sb->s_creator_os); |
| inplace(__le32_to_cpu, sb->s_rev_level); |
| |
| inplace(__le16_to_cpu, sb->s_def_resuid); |
| inplace(__le16_to_cpu, sb->s_def_resgid); |
| |
| inplace(__le32_to_cpu, sb->s_first_ino); |
| |
| inplace(__le16_to_cpu, sb->s_inode_size); |
| inplace(__le16_to_cpu, sb->s_block_group_nr); |
| |
| inplace(__le32_to_cpu, sb->s_feature_compat); |
| inplace(__le32_to_cpu, sb->s_feature_incompat); |
| inplace(__le32_to_cpu, sb->s_feature_ro_compat); |
| inplace(__le32_to_cpu, sb->s_algorithm_usage_bitmap); |
| |
| /* whew! */ |
| } |
| |
| static void swapgrp(struct ext2_group_desc *g) |
| { |
| inplace(__le32_to_cpu, g->bg_block_bitmap); |
| inplace(__le32_to_cpu, g->bg_inode_bitmap); |
| inplace(__le32_to_cpu, g->bg_inode_table); |
| |
| inplace(__le16_to_cpu, g->bg_free_blocks_count); |
| inplace(__le16_to_cpu, g->bg_free_inodes_count); |
| inplace(__le16_to_cpu, g->bg_used_dirs_count); |
| |
| } |
| |
| static void swapino(struct ext2_inode *i) |
| { |
| int n; |
| |
| inplace(__le16_to_cpu, i->i_mode); |
| inplace(__le16_to_cpu, i->i_uid); |
| inplace(__le32_to_cpu, i->i_size); |
| inplace(__le32_to_cpu, i->i_atime); |
| inplace(__le32_to_cpu, i->i_ctime); |
| inplace(__le32_to_cpu, i->i_mtime); |
| inplace(__le32_to_cpu, i->i_dtime); |
| inplace(__le16_to_cpu, i->i_gid); |
| inplace(__le16_to_cpu, i->i_links_count); |
| inplace(__le32_to_cpu, i->i_blocks); |
| inplace(__le32_to_cpu, i->i_flags); |
| /* Don't know how to handle the unions right now -- ignore them */ |
| #if 0 |
| union { |
| struct { |
| __u32 l_i_reserved1; |
| } linux1; |
| struct { |
| __u32 h_i_translator; |
| } hurd1; |
| struct { |
| __u32 m_i_reserved1; |
| } masix1; |
| } osd1; /* OS dependent 1 */ |
| #endif |
| for (n = 0; n < EXT2_N_BLOCKS; n++) { |
| inplace(__le32_to_cpu, i->i_block[n]); |
| } |
| inplace(__le32_to_cpu, i->i_generation); |
| inplace(__le32_to_cpu, i->i_file_acl); |
| inplace(__le32_to_cpu, i->i_dir_acl); |
| inplace(__le32_to_cpu, i->i_faddr); |
| #if 0 |
| union { |
| struct { |
| __u8 l_i_frag; /* Fragment number */ |
| __u8 l_i_fsize; /* Fragment size */ |
| __u16 i_pad1; |
| __u32 l_i_reserved2[2]; |
| } linux2; |
| struct { |
| __u8 h_i_frag; /* Fragment number */ |
| __u8 h_i_fsize; /* Fragment size */ |
| __u16 h_i_mode_high; |
| __u16 h_i_uid_high; |
| __u16 h_i_gid_high; |
| __u32 h_i_author; |
| } hurd2; |
| struct { |
| __u8 m_i_frag; /* Fragment number */ |
| __u8 m_i_fsize; /* Fragment size */ |
| __u16 m_pad1; |
| __u32 m_i_reserved2[2]; |
| } masix2; |
| } osd2; /* OS dependent 2 */ |
| #endif |
| } |
| |
| static void swapde(struct ext2_dir_entry_2 *de) |
| { |
| if (Debug) printf("swapde: 0x%x 0x%x / ", |
| de->inode, de->rec_len); |
| inplace(__le32_to_cpu, de->inode); |
| inplace(__le16_to_cpu, de->rec_len); |
| if (Debug) printf("0x%x 0x%x %d %d %.*s\n", |
| de->inode, de->rec_len, |
| de->name_len, de->file_type, |
| de->name_len, de->name); |
| } |
| |
| /* |
| * Initialize an ext2 partition starting at offset P_OFFSET; this is |
| * sort-of the same idea as "mounting" it. Read in the relevant |
| * control structures and make them available to the user. Returns 0 |
| * if successful, -1 on failure. |
| */ |
| int ext2_mount(long cons_dev, long p_offset, long quiet) |
| { |
| long sb_block = 1; |
| long sb_offset; |
| int i; |
| |
| dev = cons_dev; |
| partition_offset = p_offset; |
| |
| /* initialize the inode table */ |
| for (i = 0; i < MAX_OPEN_FILES; i++) { |
| inode_table[i].free = 1; |
| inode_table[i].inumber = 0; |
| } |
| /* clear the root inode pointer (very important!) */ |
| root_inode = NULL; |
| |
| /* read in the first superblock */ |
| sb_offset = sb_block * EXT2_MIN_BLOCK_SIZE; |
| if (cons_read(dev, (char *)&sb, sizeof(sb), partition_offset + sb_offset) |
| != sizeof(sb)) |
| { |
| printf("ext2 sb read failed\n"); |
| return -1; |
| } |
| |
| if (__le16_to_cpu(sb.s_magic) != EXT2_SUPER_MAGIC) { |
| if (!quiet) { |
| printf("ext2_init: bad magic 0x%x\n", sb.s_magic); |
| } |
| return -1; |
| } |
| |
| swapsb(&sb); |
| |
| ngroups = (sb.s_blocks_count - |
| sb.s_first_data_block + |
| EXT2_BLOCKS_PER_GROUP(&sb) - 1) |
| / EXT2_BLOCKS_PER_GROUP(&sb); |
| |
| gds = (struct ext2_group_desc *) |
| malloc((size_t)(ngroups * sizeof(struct ext2_group_desc))); |
| |
| ext2fs.blocksize = EXT2_BLOCK_SIZE(&sb); |
| if (Debug) printf("ext2 block size %d\n", ext2fs.blocksize); |
| |
| /* read in the group descriptors (immediately follows superblock) */ |
| cons_read(dev, gds, ngroups * sizeof(struct ext2_group_desc), |
| partition_offset + |
| ext2fs.blocksize * (EXT2_MIN_BLOCK_SIZE/ext2fs.blocksize + 1)); |
| for (i = 0; i < ngroups; i++) |
| { |
| swapgrp(&gds[i]); |
| } |
| /* |
| * Calculate direct/indirect block limits for this file system |
| * (blocksize dependent): |
| */ |
| ext2fs.blocksize = EXT2_BLOCK_SIZE(&sb); |
| if (Debug) printf("ext2 block size %d\n", ext2fs.blocksize); |
| |
| directlim = EXT2_NDIR_BLOCKS - 1; |
| ptrs_per_blk = ext2fs.blocksize/sizeof(unsigned int); |
| ind1lim = ptrs_per_blk + directlim; |
| ind2lim = (ptrs_per_blk * ptrs_per_blk) + directlim; |
| |
| return 0; |
| } |
| |
| static void printinode(const char *s, struct ext2_inode *ip) |
| { |
| int i; |
| |
| printf("%s: inode %p mode 0%o uid %d gid %d size %d\n", |
| s, ip, ip->i_mode, ip->i_uid, ip->i_gid, ip->i_size); |
| |
| for (i = 0; i < EXT2_NDIR_BLOCKS; i++) |
| { |
| printf("\tblock %d at %d (0x%x)\n", i, ip->i_block[i], |
| ip->i_block[i]); |
| } |
| } |
| |
| /* |
| * Read the specified inode from the disk and return it to the user. |
| * Returns NULL if the inode can't be read... |
| */ |
| static struct ext2_inode *ext2_iget(int ino) |
| { |
| int i; |
| struct ext2_inode *ip; |
| struct inode_table_entry *itp = 0; |
| int group; |
| long offset; |
| |
| |
| ip = 0; |
| for (i = 0; i < MAX_OPEN_FILES; i++) { |
| #ifdef DEBUG |
| printf("ext2_iget: looping, entry %d inode %d free %d\n", |
| i, inode_table[i].inumber, inode_table[i].free); |
| #endif |
| if (inode_table[i].free) { |
| itp = &inode_table[i]; |
| ip = &itp->inode; |
| break; |
| } |
| } |
| if (!ip) { |
| printf("ext2_iget: no free inodes\n"); |
| return NULL; |
| } |
| |
| group = (ino-1) / sb.s_inodes_per_group; |
| #ifdef DEBUG |
| printf("group is %d\n", group); |
| #endif |
| offset = partition_offset |
| + ((long) gds[group].bg_inode_table * (long)ext2fs.blocksize) |
| + (((ino - 1) % EXT2_INODES_PER_GROUP(&sb)) |
| * EXT2_INODE_SIZE(&sb)); |
| #ifdef DEBUG |
| printf("ext2_iget: reading %ld bytes at offset %ld " |
| "(%ld + (%d * %d) + ((%d) %% %d) * %d) " |
| "(inode %d -> table %d)\n", |
| sizeof(struct ext2_inode), offset, partition_offset, |
| gds[group].bg_inode_table, ext2fs.blocksize, |
| ino - 1, EXT2_INODES_PER_GROUP(&sb), EXT2_INODE_SIZE(&sb), |
| ino, (int) (itp - inode_table)); |
| #endif |
| if (cons_read(dev, ip, sizeof(struct ext2_inode), offset) |
| != sizeof(struct ext2_inode)) |
| { |
| printf("ext2_iget: read error\n"); |
| return NULL; |
| } |
| |
| swapino(ip); |
| if (Debug) printinode("iget", ip); |
| |
| itp->free = 0; |
| itp->inumber = ino; |
| itp->old_mode = ip->i_mode; |
| |
| return ip; |
| } |
| |
| |
| /* |
| * Release our hold on an inode. Since this is a read-only application, |
| * don't worry about putting back any changes... |
| */ |
| static void ext2_iput(struct ext2_inode *ip) |
| { |
| struct inode_table_entry *itp; |
| |
| /* Find and free the inode table slot we used... */ |
| itp = (struct inode_table_entry *)ip; |
| |
| #ifdef DEBUG |
| printf("ext2_iput: inode %d table %d\n", itp->inumber, |
| (int) (itp - inode_table)); |
| #endif |
| itp->inumber = 0; |
| itp->free = 1; |
| } |
| |
| |
| /* |
| * Map a block offset into a file into an absolute block number. |
| * (traverse the indirect blocks if necessary). Note: Double-indirect |
| * blocks allow us to map over 64Mb on a 1k file system. Therefore, for |
| * our purposes, we will NOT bother with triple indirect blocks. |
| * |
| * The "allocate" argument is set if we want to *allocate* a block |
| * and we don't already have one allocated. |
| */ |
| static int ext2_blkno(struct ext2_inode *ip, int blkoff) |
| { |
| unsigned int *lp; |
| unsigned int *ilp; |
| unsigned int *dlp; |
| int blkno; |
| int iblkno; |
| int diblkno; |
| unsigned long offset; |
| |
| ilp = (unsigned int *)iblkbuf; |
| dlp = (unsigned int *)diblkbuf; |
| lp = (unsigned int *)blkbuf; |
| |
| /* If it's a direct block, it's easy! */ |
| if (blkoff <= directlim) { |
| return ip->i_block[blkoff]; |
| } |
| |
| /* Is it a single-indirect? */ |
| if (blkoff <= ind1lim) { |
| iblkno = ip->i_block[EXT2_IND_BLOCK]; |
| |
| if (iblkno == 0) { |
| return 0; |
| } |
| |
| /* Read the indirect block */ |
| if (cached_iblkno != iblkno) { |
| offset = partition_offset + (long)iblkno * (long)ext2fs.blocksize; |
| if (cons_read(dev, iblkbuf, ext2fs.blocksize, offset) |
| != ext2fs.blocksize) |
| { |
| printf("ext2_blkno: error on iblk read\n"); |
| return 0; |
| } |
| cached_iblkno = iblkno; |
| } |
| |
| blkno = ilp[blkoff-(directlim+1)]; |
| inplace(__le32_to_cpu, blkno); |
| |
| return blkno; |
| } |
| |
| /* Is it a double-indirect? */ |
| if (blkoff <= ind2lim) { |
| /* Find the double-indirect block */ |
| diblkno = ip->i_block[EXT2_DIND_BLOCK]; |
| |
| if (diblkno == 0) { |
| return 0; |
| } |
| |
| /* Read in the double-indirect block */ |
| if (cached_diblkno != diblkno) { |
| offset = partition_offset + (long) diblkno * (long) ext2fs.blocksize; |
| if (cons_read(dev, diblkbuf, ext2fs.blocksize, offset) |
| != ext2fs.blocksize) |
| { |
| printf("ext2_blkno: err reading dindr blk\n"); |
| return 0; |
| } |
| cached_diblkno = diblkno; |
| } |
| |
| /* Find the single-indirect block pointer ... */ |
| iblkno = dlp[(blkoff - (ind1lim+1)) / ptrs_per_blk]; |
| inplace(__le32_to_cpu, iblkno); |
| |
| if (iblkno == 0) { |
| return 0; |
| } |
| |
| /* Read the indirect block */ |
| |
| if (cached_iblkno != iblkno) { |
| offset = partition_offset + (long) iblkno * (long) ext2fs.blocksize; |
| if (cons_read(dev, iblkbuf, ext2fs.blocksize, offset) |
| != ext2fs.blocksize) |
| { |
| printf("ext2_blkno: err on iblk read\n"); |
| return 0; |
| } |
| cached_iblkno = iblkno; |
| } |
| |
| /* Find the block itself. */ |
| blkno = ilp[(blkoff-(ind1lim+1)) % ptrs_per_blk]; |
| inplace(__le32_to_cpu, blkno); |
| return blkno; |
| } |
| |
| if (blkoff > ind2lim) { |
| printf("ext2_blkno: block number too large: %d\n", blkoff); |
| return 0; |
| } |
| return -1; |
| } |
| |
| static int print_ext2_blkno(struct ext2_inode *ip, int blkoff) |
| { |
| int r = ext2_blkno(ip, blkoff); |
| if (0) printf("ext2_blkno(%p, blk %d) ==> %d\n", |
| ip, blkoff, r); |
| |
| return r; |
| } |
| |
| |
| static int ext2_breadi(struct ext2_inode *ip, long blkno, long nblks, |
| char *buffer) |
| { |
| long dev_blkno, ncontig, offset, nbytes, tot_bytes; |
| |
| if (Debug) printf("ext2_breadi(%p, %ld, %ld, %p)\n", |
| ip, blkno, nblks, buffer); |
| |
| tot_bytes = 0; |
| if ((blkno+nblks)*ext2fs.blocksize > ip->i_size) |
| nblks = (ip->i_size + ext2fs.blocksize) / ext2fs.blocksize - blkno; |
| |
| if (Debug) printf("nblks = %ld\n", nblks); |
| while (nblks) { |
| /* |
| * Contiguous reads are a lot faster, so we try to group |
| * as many blocks as possible: |
| */ |
| ncontig = 0; nbytes = 0; |
| dev_blkno = print_ext2_blkno(ip, blkno); |
| if (Debug) printf("dev_blkno = %ld\n", dev_blkno); |
| do { |
| ++blkno; ++ncontig; --nblks; |
| nbytes += ext2fs.blocksize; |
| } while (nblks && |
| print_ext2_blkno(ip, blkno) == dev_blkno + ncontig); |
| |
| if (Debug) printf("dev_blkno = %ld\n", dev_blkno); |
| |
| if (dev_blkno == 0) { |
| /* This is a "hole" */ |
| memset(buffer, 0, nbytes); |
| } else { |
| /* Read it for real */ |
| offset = partition_offset + (long) dev_blkno* (long) ext2fs.blocksize; |
| #ifdef DEBUG |
| printf("ext2_bread: reading %ld bytes at offset %ld\n", |
| nbytes, offset); |
| #endif |
| if (cons_read(dev, buffer, nbytes, offset) |
| != nbytes) |
| { |
| printf("ext2_bread: read error\n"); |
| return -1; |
| } |
| |
| if (Debug) blockprint(offset, buffer, 128); |
| } |
| buffer += nbytes; |
| tot_bytes += nbytes; |
| } |
| return tot_bytes; |
| } |
| |
| static struct ext2_dir_entry_2 *ext2_readdiri(struct ext2_inode *dir_inode, |
| int rewind) |
| { |
| struct ext2_dir_entry_2 *dp; |
| static int diroffset = 0, blockoffset = 0; |
| |
| /* Reading a different directory, invalidate previous state */ |
| if (rewind) { |
| diroffset = 0; |
| blockoffset = 0; |
| /* read first block */ |
| if (ext2_breadi(dir_inode, 0, 1, blkbuf) < 0) |
| return NULL; |
| } |
| |
| #ifdef DEBUG |
| printf("ext2_readdiri: blkoffset %d diroffset %d len %d\n", |
| blockoffset, diroffset, dir_inode->i_size); |
| #endif |
| if (blockoffset >= ext2fs.blocksize) { |
| diroffset += ext2fs.blocksize; |
| if (diroffset >= dir_inode->i_size) |
| return NULL; |
| #ifdef DEBUG |
| printf("ext2_readdiri: reading block at %d\n", |
| diroffset); |
| #endif |
| /* assume that this will read the whole block */ |
| if (ext2_breadi(dir_inode, |
| diroffset / ext2fs.blocksize, |
| 1, blkbuf) < 0) |
| return NULL; |
| blockoffset = 0; |
| } |
| |
| dp = (struct ext2_dir_entry_2 *) (blkbuf + blockoffset); |
| swapde(dp); |
| blockoffset += dp->rec_len; |
| #ifdef DEBUG |
| printf("ext2_readdiri: returning %p = %.*s\n", dp, dp->name_len, dp->name); |
| #endif |
| return dp; |
| } |
| |
| static struct ext2_inode *ext2_namei(const char *name) |
| { |
| char namebuf[256]; |
| char *component; |
| struct ext2_inode *dir_inode; |
| struct ext2_dir_entry_2 *dp; |
| int next_ino; |
| |
| /* squirrel away a copy of "namebuf" that we can modify: */ |
| strcpy(namebuf, name); |
| |
| /* start at the root: */ |
| if (!root_inode) |
| root_inode = ext2_iget(EXT2_ROOT_INO); |
| dir_inode = root_inode; |
| if (!dir_inode) |
| return NULL; |
| |
| component = strtok(namebuf, "/"); |
| while (component) { |
| int component_length; |
| int rewind = 0; |
| /* |
| * Search for the specified component in the current |
| * directory inode. |
| */ |
| next_ino = -1; |
| component_length = strlen(component); |
| |
| /* rewind the first time through */ |
| while ((dp = ext2_readdiri(dir_inode, !rewind++))) { |
| if ((dp->name_len == component_length) && |
| (strncmp(component, dp->name, |
| component_length) == 0)) |
| { |
| /* Found it! */ |
| #ifdef DEBUG |
| printf("ext2_namei: found entry %s\n", |
| component); |
| #endif |
| next_ino = dp->inode; |
| break; |
| } |
| #ifdef DEBUG |
| printf("ext2_namei: looping\n"); |
| #endif |
| } |
| |
| #ifdef DEBUG |
| printf("ext2_namei: next_ino = %d\n", next_ino); |
| #endif |
| |
| /* |
| * At this point, we're done with this directory whether |
| * we've succeeded or failed... |
| */ |
| if (dir_inode != root_inode) |
| ext2_iput(dir_inode); |
| |
| /* |
| * If next_ino is negative, then we've failed (gone |
| * all the way through without finding anything) |
| */ |
| if (next_ino < 0) { |
| return NULL; |
| } |
| |
| /* |
| * Otherwise, we can get this inode and find the next |
| * component string... |
| */ |
| dir_inode = ext2_iget(next_ino); |
| if (!dir_inode) |
| return NULL; |
| |
| component = strtok(NULL, "/"); |
| } |
| |
| /* |
| * If we get here, then we got through all the components. |
| * Whatever we got must match up with the last one. |
| */ |
| return dir_inode; |
| } |
| |
| |
| /* |
| * Read block number "blkno" from the specified file. |
| */ |
| static int ext2_bread(int fd, long blkno, long nblks, char *buffer) |
| { |
| struct ext2_inode * ip; |
| ip = &inode_table[fd].inode; |
| return ext2_breadi(ip, blkno, nblks, buffer); |
| } |
| |
| /* |
| * Note: don't mix any kind of file lookup or other I/O with this or |
| * you will lose horribly (as it reuses blkbuf) |
| */ |
| const char * ext2_readdir(int fd, int rewind) |
| { |
| struct ext2_inode * ip = fd2inode[fd]; |
| struct ext2_dir_entry_2 * ent; |
| if (!S_ISDIR(ip->i_mode)) { |
| printf("fd %d (inode %d) is not a directory (mode %x)\n", |
| fd, inode_table[fd].inumber, ip->i_mode); |
| return NULL; |
| } |
| ent = ext2_readdiri(ip, rewind); |
| if (ent) { |
| ent->name[ent->name_len] = '\0'; |
| return ent->name; |
| } else { |
| return NULL; |
| } |
| } |
| |
| int ext2_filesize(int fd) |
| { |
| struct ext2_inode * ip = fd2inode[fd]; |
| |
| return ip->i_size; |
| } |
| |
| #if 0 |
| static int ext2_fstat(int fd, struct stat* buf) |
| { |
| struct ext2_inode * ip = &inode_table[fd].inode; |
| |
| if (fd >= MAX_OPEN_FILES) |
| return -1; |
| memset(buf, 0, sizeof(struct stat)); |
| /* fill in relevant fields */ |
| buf->st_ino = inode_table[fd].inumber; |
| buf->st_mode = ip->i_mode; |
| buf->st_flags = ip->i_flags; |
| buf->st_nlink = ip->i_links_count; |
| buf->st_uid = ip->i_uid; |
| buf->st_gid = ip->i_gid; |
| buf->st_size = ip->i_size; |
| buf->st_blocks = ip->i_blocks; |
| buf->st_atime = ip->i_atime; |
| buf->st_mtime = ip->i_mtime; |
| buf->st_ctime = ip->i_ctime; |
| |
| return 0; /* NOTHING CAN GO WROGN! */ |
| } |
| #endif |
| |
| static struct ext2_inode * ext2_follow_link(struct ext2_inode * from, |
| const char * base) |
| { |
| char *linkto; |
| |
| if (from->i_blocks) { |
| linkto = blkbuf; |
| if (ext2_breadi(from, 0, 1, blkbuf) == -1) |
| return NULL; |
| #ifdef DEBUG |
| printf("long link!\n"); |
| #endif |
| } else { |
| int n; |
| for (n = 0; n < EXT2_N_BLOCKS; n++) { |
| inplace(__le32_to_cpu, from->i_block[n]); |
| } |
| linkto = (char*)from->i_block; |
| } |
| #ifdef DEBUG |
| printf("symlink to %s\n", linkto); |
| #endif |
| |
| /* Resolve relative links */ |
| if (linkto[0] != '/') { |
| char *end = strrchr(base, '/'); |
| if (end) { |
| char fullname[(end - base + 1) + strlen(linkto) + 1]; |
| strncpy(fullname, base, end - base + 1); |
| fullname[end - base + 1] = '\0'; |
| strcat(fullname, linkto); |
| #ifdef DEBUG |
| printf("resolved to %s\n", fullname); |
| #endif |
| return ext2_namei(fullname); |
| } else { |
| /* Assume it's in the root */ |
| return ext2_namei(linkto); |
| } |
| } else { |
| return ext2_namei(linkto); |
| } |
| } |
| |
| static int ext2_read(int fd, char *buf, unsigned count, unsigned devaddr) |
| { |
| struct ext2_inode * ip; |
| ip = fd2inode[fd]; |
| |
| if (Debug) printf("ext2_read(%d, 0x%p, %d, %d)\n", |
| fd, buf, count, devaddr); |
| |
| return ext2_breadi(ip, |
| devaddr / ext2fs.blocksize, |
| count / ext2fs.blocksize, |
| buf); |
| } |
| |
| static void ext2_describe(int fd, int *bufalign, |
| int *blocksize) |
| { |
| describe(dev, bufalign, blocksize); |
| if (blocksize != 0) |
| *blocksize = ext2fs.blocksize; |
| } |
| |
| int ext2_open(const char *filename) |
| { |
| /* |
| * Unix-like open routine. Returns a small integer (actually |
| * an index into the inode table... |
| */ |
| struct ext2_inode * ip; |
| int fd = -1; |
| |
| ip = ext2_namei(filename); |
| if (ip) { |
| while (S_ISLNK(ip->i_mode)) { |
| ip = ext2_follow_link(ip, filename); |
| if (!ip) return -1; |
| } |
| fd = fileio_open(ext2_describe, ext2_read); |
| if (fd >= 0) |
| { |
| fd2inode[fd] = ip; |
| } |
| } |
| |
| return fd; |
| } |
| |
| |
| void ext2_close(int fd) |
| { |
| /* blah, hack, don't close the root inode ever */ |
| if (&inode_table[fd].inode != root_inode) |
| ext2_iput(&inode_table[fd].inode); |
| } |
| |
| |
| struct bootfs ext2fs = { |
| .fs_type = 0, |
| .blocksize = 0, |
| .mount = ext2_mount, |
| .open = ext2_open, |
| .bread = ext2_bread, |
| .close = ext2_close, |
| .readdir = ext2_readdir, |
| /* .fstat = ext2_fstat */ |
| }; |
| /* $Id: ext2.c,v 1.5 2000/09/21 16:47:48 bame Exp $ */ |