![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to fsys_ext2fs.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Qemu by Fabrice Bellard] / qemu / roms / openbios / fs / grubfs|
Return to fsys_ext2fs.c CVS log | Up to [Qemu by Fabrice Bellard] / qemu / roms / openbios / fs / grubfs |
1.1 ! root 1: /* ! 2: * GRUB -- GRand Unified Bootloader ! 3: * Copyright (C) 1999, 2001 Free Software Foundation, Inc. ! 4: * ! 5: * This program is free software; you can redistribute it and/or modify ! 6: * it under the terms of the GNU General Public License as published by ! 7: * the Free Software Foundation; either version 2 of the License, or ! 8: * (at your option) any later version. ! 9: * ! 10: * This program is distributed in the hope that it will be useful, ! 11: * but WITHOUT ANY WARRANTY; without even the implied warranty of ! 12: * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the ! 13: * GNU General Public License for more details. ! 14: * ! 15: * You should have received a copy of the GNU General Public License ! 16: * along with this program; if not, write to the Free Software ! 17: * Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, ! 18: * MA 02110-1301, USA. ! 19: */ ! 20: ! 21: #ifdef FSYS_EXT2FS ! 22: ! 23: #include "config.h" ! 24: #include "shared.h" ! 25: #include "filesys.h" ! 26: #include "libc/byteorder.h" ! 27: ! 28: #ifdef CONFIG_DEBUG_EXT2FS ! 29: #define E2DEBUG ! 30: #endif ! 31: ! 32: static int mapblock1, mapblock2; ! 33: ! 34: /* sizes are always in bytes, BLOCK values are always in DEV_BSIZE (sectors) */ ! 35: #define DEV_BSIZE 512 ! 36: ! 37: /* include/linux/fs.h */ ! 38: #define BLOCK_SIZE 1024 /* initial block size for superblock read */ ! 39: /* made up, defaults to 1 but can be passed via mount_opts */ ! 40: #define WHICH_SUPER 1 ! 41: /* kind of from fs/ext2/super.c */ ! 42: #define SBLOCK (WHICH_SUPER * BLOCK_SIZE / DEV_BSIZE) /* = 2 */ ! 43: ! 44: /* include/asm-i386/types.h */ ! 45: typedef __signed__ char __s8; ! 46: typedef unsigned char __u8; ! 47: typedef __signed__ short __s16; ! 48: typedef unsigned short __u16; ! 49: typedef __signed__ int __s32; ! 50: typedef unsigned int __u32; ! 51: ! 52: /* ! 53: * Constants relative to the data blocks, from ext2_fs.h ! 54: */ ! 55: #define EXT2_NDIR_BLOCKS 12 ! 56: #define EXT2_IND_BLOCK EXT2_NDIR_BLOCKS ! 57: #define EXT2_DIND_BLOCK (EXT2_IND_BLOCK + 1) ! 58: #define EXT2_TIND_BLOCK (EXT2_DIND_BLOCK + 1) ! 59: #define EXT2_N_BLOCKS (EXT2_TIND_BLOCK + 1) ! 60: ! 61: /* include/linux/ext2_fs.h */ ! 62: struct ext2_super_block ! 63: { ! 64: __u32 s_inodes_count; /* Inodes count */ ! 65: __u32 s_blocks_count; /* Blocks count */ ! 66: __u32 s_r_blocks_count; /* Reserved blocks count */ ! 67: __u32 s_free_blocks_count; /* Free blocks count */ ! 68: __u32 s_free_inodes_count; /* Free inodes count */ ! 69: __u32 s_first_data_block; /* First Data Block */ ! 70: __u32 s_log_block_size; /* Block size */ ! 71: __s32 s_log_frag_size; /* Fragment size */ ! 72: __u32 s_blocks_per_group; /* # Blocks per group */ ! 73: __u32 s_frags_per_group; /* # Fragments per group */ ! 74: __u32 s_inodes_per_group; /* # Inodes per group */ ! 75: __u32 s_mtime; /* Mount time */ ! 76: __u32 s_wtime; /* Write time */ ! 77: __u16 s_mnt_count; /* Mount count */ ! 78: __s16 s_max_mnt_count; /* Maximal mount count */ ! 79: __u16 s_magic; /* Magic signature */ ! 80: __u16 s_state; /* File system state */ ! 81: __u16 s_errors; /* Behaviour when detecting errors */ ! 82: __u16 s_pad; ! 83: __u32 s_lastcheck; /* time of last check */ ! 84: __u32 s_checkinterval; /* max. time between checks */ ! 85: __u32 s_creator_os; /* OS */ ! 86: __u32 s_rev_level; /* Revision level */ ! 87: __u16 s_def_resuid; /* Default uid for reserved blocks */ ! 88: __u16 s_def_resgid; /* Default gid for reserved blocks */ ! 89: __u32 s_reserved[235]; /* Padding to the end of the block */ ! 90: }; ! 91: ! 92: struct ext2_group_desc ! 93: { ! 94: __u32 bg_block_bitmap; /* Blocks bitmap block */ ! 95: __u32 bg_inode_bitmap; /* Inodes bitmap block */ ! 96: __u32 bg_inode_table; /* Inodes table block */ ! 97: __u16 bg_free_blocks_count; /* Free blocks count */ ! 98: __u16 bg_free_inodes_count; /* Free inodes count */ ! 99: __u16 bg_used_dirs_count; /* Directories count */ ! 100: __u16 bg_pad; ! 101: __u32 bg_reserved[3]; ! 102: }; ! 103: ! 104: struct ext2_inode ! 105: { ! 106: __u16 i_mode; /* File mode */ ! 107: __u16 i_uid; /* Owner Uid */ ! 108: __u32 i_size; /* 4: Size in bytes */ ! 109: __u32 i_atime; /* Access time */ ! 110: __u32 i_ctime; /* 12: Creation time */ ! 111: __u32 i_mtime; /* Modification time */ ! 112: __u32 i_dtime; /* 20: Deletion Time */ ! 113: __u16 i_gid; /* Group Id */ ! 114: __u16 i_links_count; /* 24: Links count */ ! 115: __u32 i_blocks; /* Blocks count */ ! 116: __u32 i_flags; /* 32: File flags */ ! 117: union ! 118: { ! 119: struct ! 120: { ! 121: __u32 l_i_reserved1; ! 122: } ! 123: linux1; ! 124: struct ! 125: { ! 126: __u32 h_i_translator; ! 127: } ! 128: hurd1; ! 129: struct ! 130: { ! 131: __u32 m_i_reserved1; ! 132: } ! 133: masix1; ! 134: } ! 135: osd1; /* OS dependent 1 */ ! 136: __u32 i_block[EXT2_N_BLOCKS]; /* 40: Pointers to blocks */ ! 137: __u32 i_version; /* File version (for NFS) */ ! 138: __u32 i_file_acl; /* File ACL */ ! 139: __u32 i_dir_acl; /* Directory ACL */ ! 140: __u32 i_faddr; /* Fragment address */ ! 141: union ! 142: { ! 143: struct ! 144: { ! 145: __u8 l_i_frag; /* Fragment number */ ! 146: __u8 l_i_fsize; /* Fragment size */ ! 147: __u16 i_pad1; ! 148: __u32 l_i_reserved2[2]; ! 149: } ! 150: linux2; ! 151: struct ! 152: { ! 153: __u8 h_i_frag; /* Fragment number */ ! 154: __u8 h_i_fsize; /* Fragment size */ ! 155: __u16 h_i_mode_high; ! 156: __u16 h_i_uid_high; ! 157: __u16 h_i_gid_high; ! 158: __u32 h_i_author; ! 159: } ! 160: hurd2; ! 161: struct ! 162: { ! 163: __u8 m_i_frag; /* Fragment number */ ! 164: __u8 m_i_fsize; /* Fragment size */ ! 165: __u16 m_pad1; ! 166: __u32 m_i_reserved2[2]; ! 167: } ! 168: masix2; ! 169: } ! 170: osd2; /* OS dependent 2 */ ! 171: }; ! 172: ! 173: /* linux/posix_type.h */ ! 174: typedef long linux_off_t; ! 175: ! 176: /* linux/ext2fs.h */ ! 177: #define EXT2_NAME_LEN 255 ! 178: struct ext2_dir_entry ! 179: { ! 180: __u32 inode; /* Inode number */ ! 181: __u16 rec_len; /* Directory entry length */ ! 182: __u8 name_len; /* Name length */ ! 183: __u8 file_type; ! 184: char name[EXT2_NAME_LEN]; /* File name */ ! 185: }; ! 186: ! 187: /* ext2/super.c */ ! 188: #define EXT2_SUPER_MAGIC 0xEF53 /* include/linux/ext2_fs.h */ ! 189: #define EXT2_ROOT_INO 2 /* include/linux/ext2_fs.h */ ! 190: #define PATH_MAX 1024 /* include/linux/limits.h */ ! 191: #define MAX_LINK_COUNT 5 /* number of symbolic links to follow */ ! 192: ! 193: /* made up, these are pointers into FSYS_BUF */ ! 194: /* read once, always stays there: */ ! 195: #define SUPERBLOCK \ ! 196: ((struct ext2_super_block *)(FSYS_BUF)) ! 197: #define GROUP_DESC \ ! 198: ((struct ext2_group_desc *) \ ! 199: ((char *)SUPERBLOCK + sizeof(struct ext2_super_block))) ! 200: #define INODE \ ! 201: ((struct ext2_inode *)((char *)GROUP_DESC + EXT2_BLOCK_SIZE(SUPERBLOCK))) ! 202: #define DATABLOCK1 \ ! 203: ((char *)((char *)INODE + sizeof(struct ext2_inode))) ! 204: #define DATABLOCK2 \ ! 205: ((char *)((char *)DATABLOCK1 + EXT2_BLOCK_SIZE(SUPERBLOCK))) ! 206: ! 207: /* linux/ext2_fs.h */ ! 208: #define EXT2_ADDR_PER_BLOCK(s) (EXT2_BLOCK_SIZE(s) / sizeof (__u32)) ! 209: #define EXT2_ADDR_PER_BLOCK_BITS(s) (log2(EXT2_ADDR_PER_BLOCK(s))) ! 210: ! 211: /* linux/ext2_fs.h */ ! 212: #define EXT2_BLOCK_SIZE_BITS(s) (__le32_to_cpu((s)->s_log_block_size) + 10) ! 213: /* kind of from ext2/super.c */ ! 214: #define EXT2_BLOCK_SIZE(s) (1 << EXT2_BLOCK_SIZE_BITS(s)) ! 215: /* linux/ext2fs.h */ ! 216: #define EXT2_DESC_PER_BLOCK(s) \ ! 217: (EXT2_BLOCK_SIZE(s) / sizeof (struct ext2_group_desc)) ! 218: /* linux/stat.h */ ! 219: #define S_IFMT 00170000 ! 220: #define S_IFLNK 0120000 ! 221: #define S_IFREG 0100000 ! 222: #define S_IFDIR 0040000 ! 223: #define S_ISLNK(m) (((m) & S_IFMT) == S_IFLNK) ! 224: #define S_ISREG(m) (((m) & S_IFMT) == S_IFREG) ! 225: #define S_ISDIR(m) (((m) & S_IFMT) == S_IFDIR) ! 226: ! 227: #ifdef E2DEBUG ! 228: void ! 229: dump_super(struct ext2_super_block *s) ! 230: { ! 231: printf(" superblock 0x%x:\n", s); ! 232: printf(" inodes=%d\n", __le32_to_cpu(s->s_inodes_count)); ! 233: printf(" blocks=%d\n", __le32_to_cpu(s->s_blocks_count)); ! 234: printf(" reserved=%d\n", __le32_to_cpu(s->s_r_blocks_count)); ! 235: printf(" i_free=%d\n", __le32_to_cpu(s->s_free_inodes_count)); ! 236: printf(" b_free=%d\n", __le32_to_cpu(s->s_free_blocks_count)); ! 237: printf(" first=%d\n", __le32_to_cpu(s->s_first_data_block)); ! 238: printf(" log_b_size=%d, b_size=%d\n", __le32_to_cpu(s->s_log_block_size), EXT2_BLOCK_SIZE(s)); ! 239: printf(" log_f_size=%d\n", __le32_to_cpu(s->s_log_frag_size)); ! 240: printf(" bpg=%d\n", __le32_to_cpu(s->s_blocks_per_group)); ! 241: printf(" fpg=%d\n", __le32_to_cpu(s->s_frags_per_group)); ! 242: printf(" ipg=%d\n", __le32_to_cpu(s->s_inodes_per_group)); ! 243: } ! 244: ! 245: void ! 246: dump_group_desc(struct ext2_group_desc *g) ! 247: { ! 248: printf(" group_desc 0x%x:\n", g); ! 249: printf(" b_bmap block=%d\n", __le32_to_cpu(g->bg_block_bitmap)); ! 250: printf(" i_bmap block=%d\n", __le32_to_cpu(g->bg_inode_bitmap)); ! 251: printf(" i_tab block=%d\n", __le32_to_cpu(g->bg_inode_table)); ! 252: printf(" free_blks=%d\n", __le16_to_cpu(g->bg_free_blocks_count)); ! 253: printf(" free_inodes=%d\n", __le16_to_cpu(g->bg_free_inodes_count)); ! 254: printf(" used_dirs=%d\n", __le16_to_cpu(g->bg_used_dirs_count)); ! 255: } ! 256: ! 257: void ! 258: dump_inode(struct ext2_inode *i) ! 259: { ! 260: printf(" inode 0x%x:\n", i); ! 261: printf(" mode=%o\n", __le16_to_cpu(i->i_mode)); ! 262: printf(" uid=%d\n", __le16_to_cpu(i->i_uid)); ! 263: printf(" gid=%d\n", __le16_to_cpu(i->i_gid)); ! 264: printf(" size=%d\n", __le32_to_cpu(i->i_size)); ! 265: printf(" atime=%d\n", __le32_to_cpu(i->i_atime)); ! 266: printf(" ctime=%d\n", __le32_to_cpu(i->i_ctime)); ! 267: printf(" mtime=%d\n", __le32_to_cpu(i->i_mtime)); ! 268: printf(" dtime=%d\n", __le32_to_cpu(i->i_dtime)); ! 269: printf(" links=%d\n", __le16_to_cpu(i->i_links_count)); ! 270: printf(" blocks=%d\n", __le32_to_cpu(i->i_blocks)); ! 271: printf(" flags=%d\n", __le32_to_cpu(i->i_flags)); ! 272: } ! 273: ! 274: void ! 275: dump_inode_data(unsigned char *inode, int len) ! 276: { ! 277: static char hexdigit[] = "0123456789abcdef"; ! 278: unsigned char *i; ! 279: for (i = inode; ! 280: i < (inode + len); ! 281: i++) ! 282: { ! 283: printf ("%c", hexdigit[*i >> 4]); ! 284: printf ("%c", hexdigit[*i % 16]); ! 285: if (!((i + 1 - inode) % 16)) ! 286: { ! 287: printf ("\n"); ! 288: } ! 289: else ! 290: { ! 291: printf (" "); ! 292: } ! 293: } ! 294: } ! 295: #endif ! 296: ! 297: /* check filesystem types and read superblock into memory buffer */ ! 298: int ! 299: ext2fs_mount (void) ! 300: { ! 301: int retval = 1; ! 302: ! 303: if ((((current_drive & 0x80) || (current_slice != 0)) ! 304: && (current_slice != PC_SLICE_TYPE_EXT2FS) ! 305: && (current_slice != PC_SLICE_TYPE_LINUX_RAID) ! 306: && (! IS_PC_SLICE_TYPE_BSD_WITH_FS (current_slice, FS_EXT2FS)) ! 307: && (! IS_PC_SLICE_TYPE_BSD_WITH_FS (current_slice, FS_OTHER))) ! 308: || part_length < (SBLOCK + (sizeof (struct ext2_super_block) / DEV_BSIZE)) ! 309: || !devread (SBLOCK, 0, sizeof (struct ext2_super_block), ! 310: (char *) SUPERBLOCK) ! 311: || __le16_to_cpu(SUPERBLOCK->s_magic) != EXT2_SUPER_MAGIC) ! 312: retval = 0; ! 313: ! 314: return retval; ! 315: } ! 316: ! 317: /* Takes a file system block number and reads it into BUFFER. */ ! 318: static int ! 319: ext2_rdfsb (int fsblock, char * buffer) ! 320: { ! 321: #ifdef E2DEBUG ! 322: printf ("ext2_rdfsb: fsblock %d, devblock %d, size %d\n", fsblock, ! 323: fsblock * (EXT2_BLOCK_SIZE (SUPERBLOCK) / DEV_BSIZE), ! 324: EXT2_BLOCK_SIZE (SUPERBLOCK)); ! 325: #endif /* E2DEBUG */ ! 326: return devread (fsblock * (EXT2_BLOCK_SIZE (SUPERBLOCK) / DEV_BSIZE), 0, ! 327: EXT2_BLOCK_SIZE (SUPERBLOCK), (char *) buffer); ! 328: } ! 329: ! 330: /* from ! 331: ext2/inode.c:ext2_bmap() ! 332: */ ! 333: /* Maps LOGICAL_BLOCK (the file offset divided by the blocksize) into ! 334: a physical block (the location in the file system) via an inode. */ ! 335: static int ! 336: ext2fs_block_map (int logical_block) ! 337: { ! 338: ! 339: #ifdef E2DEBUG ! 340: printf ("ext2fs_block_map(%d)\n", logical_block); ! 341: #endif /* E2DEBUG */ ! 342: ! 343: /* if it is directly pointed to by the inode, return that physical addr */ ! 344: if (logical_block < EXT2_NDIR_BLOCKS) ! 345: { ! 346: #ifdef E2DEBUG ! 347: printf ("ext2fs_block_map: returning %d\n", __le32_to_cpu(INODE->i_block[logical_block])); ! 348: #endif /* E2DEBUG */ ! 349: return __le32_to_cpu(INODE->i_block[logical_block]); ! 350: } ! 351: /* else */ ! 352: logical_block -= EXT2_NDIR_BLOCKS; ! 353: /* try the indirect block */ ! 354: if (logical_block < EXT2_ADDR_PER_BLOCK (SUPERBLOCK)) ! 355: { ! 356: if (mapblock1 != 1 ! 357: && !ext2_rdfsb (__le32_to_cpu(INODE->i_block[EXT2_IND_BLOCK]), DATABLOCK1)) ! 358: { ! 359: errnum = ERR_FSYS_CORRUPT; ! 360: return -1; ! 361: } ! 362: mapblock1 = 1; ! 363: return __le32_to_cpu(((__u32 *) DATABLOCK1)[logical_block]); ! 364: } ! 365: /* else */ ! 366: logical_block -= EXT2_ADDR_PER_BLOCK (SUPERBLOCK); ! 367: /* now try the double indirect block */ ! 368: if (logical_block < (1 << (EXT2_ADDR_PER_BLOCK_BITS (SUPERBLOCK) * 2))) ! 369: { ! 370: int bnum; ! 371: if (mapblock1 != 2 ! 372: && !ext2_rdfsb (__le32_to_cpu(INODE->i_block[EXT2_DIND_BLOCK]), DATABLOCK1)) ! 373: { ! 374: errnum = ERR_FSYS_CORRUPT; ! 375: return -1; ! 376: } ! 377: mapblock1 = 2; ! 378: if ((bnum = __le32_to_cpu(((__u32 *) DATABLOCK1) ! 379: [logical_block >> EXT2_ADDR_PER_BLOCK_BITS (SUPERBLOCK)])) ! 380: != mapblock2 ! 381: && !ext2_rdfsb (bnum, DATABLOCK2)) ! 382: { ! 383: errnum = ERR_FSYS_CORRUPT; ! 384: return -1; ! 385: } ! 386: mapblock2 = bnum; ! 387: return __le32_to_cpu(((__u32 *) DATABLOCK2) ! 388: [logical_block & (EXT2_ADDR_PER_BLOCK (SUPERBLOCK) - 1)]); ! 389: } ! 390: /* else */ ! 391: mapblock2 = -1; ! 392: logical_block -= (1 << (EXT2_ADDR_PER_BLOCK_BITS (SUPERBLOCK) * 2)); ! 393: if (mapblock1 != 3 ! 394: && !ext2_rdfsb (__le32_to_cpu(INODE->i_block[EXT2_TIND_BLOCK]), DATABLOCK1)) ! 395: { ! 396: errnum = ERR_FSYS_CORRUPT; ! 397: return -1; ! 398: } ! 399: mapblock1 = 3; ! 400: if (!ext2_rdfsb (__le32_to_cpu(((__u32 *) DATABLOCK1) ! 401: [logical_block >> (EXT2_ADDR_PER_BLOCK_BITS (SUPERBLOCK) ! 402: * 2)]), ! 403: DATABLOCK2)) ! 404: { ! 405: errnum = ERR_FSYS_CORRUPT; ! 406: return -1; ! 407: } ! 408: if (!ext2_rdfsb (__le32_to_cpu(((__u32 *) DATABLOCK2) ! 409: [(logical_block >> EXT2_ADDR_PER_BLOCK_BITS (SUPERBLOCK)) ! 410: & (EXT2_ADDR_PER_BLOCK (SUPERBLOCK) - 1)]), ! 411: DATABLOCK2)) ! 412: { ! 413: errnum = ERR_FSYS_CORRUPT; ! 414: return -1; ! 415: } ! 416: return __le32_to_cpu(((__u32 *) DATABLOCK2) ! 417: [logical_block & (EXT2_ADDR_PER_BLOCK (SUPERBLOCK) - 1)]); ! 418: } ! 419: ! 420: /* preconditions: all preconds of ext2fs_block_map */ ! 421: int ! 422: ext2fs_read (char *buf, int len) ! 423: { ! 424: int logical_block; ! 425: int offset; ! 426: int map; ! 427: int ret = 0; ! 428: int size = 0; ! 429: ! 430: #ifdef E2DEBUG ! 431: printf("ext2fs_read(0x%x, %d)\n", buf, len); ! 432: dump_inode(INODE); ! 433: dump_inode_data((unsigned char *)INODE, sizeof (struct ext2_inode)); ! 434: #endif /* E2DEBUG */ ! 435: while (len > 0) ! 436: { ! 437: /* find the (logical) block component of our location */ ! 438: logical_block = filepos >> EXT2_BLOCK_SIZE_BITS (SUPERBLOCK); ! 439: offset = filepos & (EXT2_BLOCK_SIZE (SUPERBLOCK) - 1); ! 440: map = ext2fs_block_map (logical_block); ! 441: #ifdef E2DEBUG ! 442: printf ("map=%d\n", map); ! 443: #endif /* E2DEBUG */ ! 444: if (map < 0) ! 445: break; ! 446: ! 447: size = EXT2_BLOCK_SIZE (SUPERBLOCK); ! 448: size -= offset; ! 449: if (size > len) ! 450: size = len; ! 451: ! 452: disk_read_func = disk_read_hook; ! 453: ! 454: devread (map * (EXT2_BLOCK_SIZE (SUPERBLOCK) / DEV_BSIZE), ! 455: offset, size, buf); ! 456: ! 457: disk_read_func = NULL; ! 458: ! 459: buf += size; ! 460: len -= size; ! 461: filepos += size; ! 462: ret += size; ! 463: } ! 464: ! 465: if (errnum) ! 466: ret = 0; ! 467: ! 468: return ret; ! 469: } ! 470: ! 471: ! 472: /* Based on: ! 473: def_blk_fops points to ! 474: blkdev_open, which calls (I think): ! 475: sys_open() ! 476: do_open() ! 477: open_namei() ! 478: dir_namei() which accesses current->fs->root ! 479: fs->root was set during original mount: ! 480: (something)... which calls (I think): ! 481: ext2_read_super() ! 482: iget() ! 483: __iget() ! 484: read_inode() ! 485: ext2_read_inode() ! 486: uses desc_per_block_bits, which is set in ext2_read_super() ! 487: also uses group descriptors loaded during ext2_read_super() ! 488: lookup() ! 489: ext2_lookup() ! 490: ext2_find_entry() ! 491: ext2_getblk() ! 492: ! 493: */ ! 494: ! 495: /* preconditions: ext2fs_mount already executed, therefore supblk in buffer ! 496: * known as SUPERBLOCK ! 497: * returns: 0 if error, nonzero iff we were able to find the file successfully ! 498: * postconditions: on a nonzero return, buffer known as INODE contains the ! 499: * inode of the file we were trying to look up ! 500: * side effects: messes up GROUP_DESC buffer area ! 501: */ ! 502: int ! 503: ext2fs_dir (char *dirname) ! 504: { ! 505: int current_ino = EXT2_ROOT_INO; /* start at the root */ ! 506: int updir_ino = current_ino; /* the parent of the current directory */ ! 507: int group_id; /* which group the inode is in */ ! 508: int group_desc; /* fs pointer to that group */ ! 509: int desc; /* index within that group */ ! 510: int ino_blk; /* fs pointer of the inode's information */ ! 511: int str_chk = 0; /* used to hold the results of a string compare */ ! 512: struct ext2_group_desc *gdp; ! 513: struct ext2_inode *raw_inode; /* inode info corresponding to current_ino */ ! 514: ! 515: char linkbuf[PATH_MAX]; /* buffer for following symbolic links */ ! 516: int link_count = 0; ! 517: ! 518: char *rest; ! 519: char ch; /* temp char holder */ ! 520: ! 521: int off; /* offset within block of directory entry (off mod blocksize) */ ! 522: int loc; /* location within a directory */ ! 523: int blk; /* which data blk within dir entry (off div blocksize) */ ! 524: long map; /* fs pointer of a particular block from dir entry */ ! 525: struct ext2_dir_entry *dp; /* pointer to directory entry */ ! 526: ! 527: /* loop invariants: ! 528: current_ino = inode to lookup ! 529: dirname = pointer to filename component we are cur looking up within ! 530: the directory known pointed to by current_ino (if any) ! 531: */ ! 532: ! 533: #ifdef E2DEBUG ! 534: printf("****** ext2fs_dir(%s)\n", dirname); ! 535: dump_super(SUPERBLOCK); ! 536: #endif /* E2DEBUG */ ! 537: ! 538: while (1) ! 539: { ! 540: #ifdef E2DEBUG ! 541: printf ("ext2fs_dir: inode %d\n", current_ino); ! 542: printf ("ext2fs_dir: dirname=%s\n", dirname); ! 543: #endif /* E2DEBUG */ ! 544: ! 545: /* look up an inode */ ! 546: group_id = (current_ino - 1) / __le32_to_cpu(SUPERBLOCK->s_inodes_per_group); ! 547: group_desc = group_id >> log2 (EXT2_DESC_PER_BLOCK (SUPERBLOCK)); ! 548: desc = group_id & (EXT2_DESC_PER_BLOCK (SUPERBLOCK) - 1); ! 549: #ifdef E2DEBUG ! 550: printf ("ext2fs_dir: ipg=%d, dpb=%d\n", __le32_to_cpu(SUPERBLOCK->s_inodes_per_group), ! 551: EXT2_DESC_PER_BLOCK (SUPERBLOCK)); ! 552: printf ("ext2fs_dir: group_id=%d group_desc=%d desc=%d\n", group_id, group_desc, desc); ! 553: #endif /* E2DEBUG */ ! 554: if (!ext2_rdfsb ( ! 555: (WHICH_SUPER + group_desc + __le32_to_cpu(SUPERBLOCK->s_first_data_block)), ! 556: (char*) GROUP_DESC)) ! 557: { ! 558: return 0; ! 559: } ! 560: ! 561: #ifdef E2DEBUG ! 562: dump_group_desc(GROUP_DESC); ! 563: #endif /* E2DEBUG */ ! 564: ! 565: gdp = GROUP_DESC; ! 566: ino_blk = __le32_to_cpu(gdp[desc].bg_inode_table) + ! 567: (((current_ino - 1) % __le32_to_cpu(SUPERBLOCK->s_inodes_per_group)) ! 568: >> log2 (EXT2_BLOCK_SIZE (SUPERBLOCK) / sizeof (struct ext2_inode))); ! 569: #ifdef E2DEBUG ! 570: printf ("ext2fs_dir: itab_blk=%d, i_in_grp=%d, log2=%d\n", ! 571: __le32_to_cpu(gdp[desc].bg_inode_table), ! 572: ((current_ino - 1) % __le32_to_cpu(SUPERBLOCK->s_inodes_per_group)), ! 573: log2 (EXT2_BLOCK_SIZE (SUPERBLOCK) / sizeof (struct ext2_inode))); ! 574: printf ("ext2fs_dir: inode table fsblock=%d\n", ino_blk); ! 575: #endif /* E2DEBUG */ ! 576: if (!ext2_rdfsb (ino_blk, (char *)INODE)) ! 577: { ! 578: return 0; ! 579: } ! 580: ! 581: /* reset indirect blocks! */ ! 582: mapblock2 = mapblock1 = -1; ! 583: ! 584: raw_inode = INODE + ! 585: ((current_ino - 1) ! 586: & (EXT2_BLOCK_SIZE (SUPERBLOCK) / sizeof (struct ext2_inode) - 1)); ! 587: #ifdef E2DEBUG ! 588: printf ("ext2fs_dir: ipb=%d, sizeof(inode)=%d\n", ! 589: (EXT2_BLOCK_SIZE (SUPERBLOCK) / sizeof (struct ext2_inode)), ! 590: sizeof (struct ext2_inode)); ! 591: printf ("ext2fs_dir: inode=%x, raw_inode=%x\n", INODE, raw_inode); ! 592: printf ("ext2fs_dir: offset into inode table block=%d\n", (int) raw_inode - (int) INODE); ! 593: dump_inode(raw_inode); ! 594: dump_inode_data((unsigned char *)INODE, EXT2_BLOCK_SIZE(SUPERBLOCK)); ! 595: printf ("ext2fs_dir: first word=%x\n", *((int *) raw_inode)); ! 596: #endif /* E2DEBUG */ ! 597: ! 598: /* copy inode to fixed location */ ! 599: memmove ((void *) INODE, (void *) raw_inode, sizeof (struct ext2_inode)); ! 600: ! 601: #ifdef E2DEBUG ! 602: dump_inode(INODE); ! 603: printf ("ext2fs_dir: first word=%x\n", *((int *) INODE)); ! 604: #endif /* E2DEBUG */ ! 605: ! 606: /* If we've got a symbolic link, then chase it. */ ! 607: if (S_ISLNK (__le16_to_cpu(INODE->i_mode))) ! 608: { ! 609: int len; ! 610: if (++link_count > MAX_LINK_COUNT) ! 611: { ! 612: errnum = ERR_SYMLINK_LOOP; ! 613: return 0; ! 614: } ! 615: ! 616: /* Find out how long our remaining name is. */ ! 617: len = 0; ! 618: while (dirname[len] && !isspace (dirname[len])) ! 619: len++; ! 620: ! 621: /* Get the symlink size. */ ! 622: filemax = __le32_to_cpu(INODE->i_size); ! 623: if (filemax + len > sizeof (linkbuf) - 2) ! 624: { ! 625: errnum = ERR_FILELENGTH; ! 626: return 0; ! 627: } ! 628: ! 629: if (len) ! 630: { ! 631: /* Copy the remaining name to the end of the symlink data. ! 632: Note that DIRNAME and LINKBUF may overlap! */ ! 633: memmove (linkbuf + filemax, dirname, len); ! 634: } ! 635: linkbuf[filemax + len] = '\0'; ! 636: ! 637: /* Read the symlink data. */ ! 638: if (__le32_to_cpu(INODE->i_blocks)) ! 639: { ! 640: /* Read the necessary blocks, and reset the file pointer. */ ! 641: len = file_read (linkbuf, filemax); ! 642: filepos = 0; ! 643: if (!len) ! 644: return 0; ! 645: } ! 646: else ! 647: { ! 648: /* Copy the data directly from the inode. */ ! 649: len = filemax; ! 650: memmove (linkbuf, (char *) INODE->i_block, len); ! 651: } ! 652: ! 653: #ifdef E2DEBUG ! 654: printf ("ext2fs_dir: symlink=%s\n", linkbuf); ! 655: #endif ! 656: ! 657: dirname = linkbuf; ! 658: if (*dirname == '/') ! 659: { ! 660: /* It's an absolute link, so look it up in root. */ ! 661: current_ino = EXT2_ROOT_INO; ! 662: updir_ino = current_ino; ! 663: } ! 664: else ! 665: { ! 666: /* Relative, so look it up in our parent directory. */ ! 667: current_ino = updir_ino; ! 668: } ! 669: ! 670: /* Try again using the new name. */ ! 671: continue; ! 672: } ! 673: ! 674: /* if end of filename, INODE points to the file's inode */ ! 675: if (!*dirname || isspace (*dirname)) ! 676: { ! 677: if (!S_ISREG (__le16_to_cpu(INODE->i_mode))) ! 678: { ! 679: errnum = ERR_BAD_FILETYPE; ! 680: return 0; ! 681: } ! 682: ! 683: filemax = __le32_to_cpu(INODE->i_size); ! 684: return 1; ! 685: } ! 686: ! 687: /* else we have to traverse a directory */ ! 688: updir_ino = current_ino; ! 689: ! 690: /* skip over slashes */ ! 691: while (*dirname == '/') ! 692: dirname++; ! 693: ! 694: /* if this isn't a directory of sufficient size to hold our file, abort */ ! 695: if (!(__le32_to_cpu(INODE->i_size)) || !S_ISDIR (__le16_to_cpu(INODE->i_mode))) ! 696: { ! 697: errnum = ERR_BAD_FILETYPE; ! 698: return 0; ! 699: } ! 700: ! 701: /* skip to next slash or end of filename (space) */ ! 702: for (rest = dirname; (ch = *rest) && !isspace (ch) && ch != '/'; ! 703: rest++); ! 704: ! 705: /* look through this directory and find the next filename component */ ! 706: /* invariant: rest points to slash after the next filename component */ ! 707: *rest = 0; ! 708: loc = 0; ! 709: ! 710: do ! 711: { ! 712: ! 713: #ifdef E2DEBUG ! 714: printf ("ext2fs_dir: dirname=%s, rest=%s, loc=%d\n", dirname, rest, loc); ! 715: #endif /* E2DEBUG */ ! 716: ! 717: /* if our location/byte offset into the directory exceeds the size, ! 718: give up */ ! 719: if (loc >= __le32_to_cpu(INODE->i_size)) ! 720: { ! 721: if (print_possibilities < 0) ! 722: { ! 723: # if 0 ! 724: putchar ('\n'); ! 725: # endif ! 726: } ! 727: else ! 728: { ! 729: errnum = ERR_FILE_NOT_FOUND; ! 730: *rest = ch; ! 731: } ! 732: return (print_possibilities < 0); ! 733: } ! 734: ! 735: /* else, find the (logical) block component of our location */ ! 736: blk = loc >> EXT2_BLOCK_SIZE_BITS (SUPERBLOCK); ! 737: ! 738: /* we know which logical block of the directory entry we are looking ! 739: for, now we have to translate that to the physical (fs) block on ! 740: the disk */ ! 741: map = ext2fs_block_map (blk); ! 742: #ifdef E2DEBUG ! 743: printf ("ext2fs_dir: fs block=%d\n", map); ! 744: #endif /* E2DEBUG */ ! 745: mapblock2 = -1; ! 746: if ((map < 0) || !ext2_rdfsb (map, DATABLOCK2)) ! 747: { ! 748: errnum = ERR_FSYS_CORRUPT; ! 749: *rest = ch; ! 750: return 0; ! 751: } ! 752: off = loc & (EXT2_BLOCK_SIZE (SUPERBLOCK) - 1); ! 753: dp = (struct ext2_dir_entry *) (DATABLOCK2 + off); ! 754: /* advance loc prematurely to next on-disk directory entry */ ! 755: loc += __le16_to_cpu(dp->rec_len); ! 756: ! 757: /* NOTE: ext2fs filenames are NOT null-terminated */ ! 758: ! 759: #ifdef E2DEBUG ! 760: printf ("ext2fs_dir: directory entry ino=%d\n", __le32_to_cpu(dp->inode)); ! 761: if (__le32_to_cpu(dp->inode)) ! 762: printf ("entry=%s\n", dp->name); ! 763: #endif /* E2DEBUG */ ! 764: ! 765: if (__le32_to_cpu(dp->inode)) ! 766: { ! 767: int saved_c = dp->name[dp->name_len]; ! 768: ! 769: dp->name[dp->name_len] = 0; ! 770: str_chk = substring (dirname, dp->name); ! 771: ! 772: # ifndef STAGE1_5 ! 773: if (print_possibilities && ch != '/' ! 774: && (!*dirname || str_chk <= 0)) ! 775: { ! 776: if (print_possibilities > 0) ! 777: print_possibilities = -print_possibilities; ! 778: print_a_completion (dp->name); ! 779: } ! 780: # endif ! 781: ! 782: dp->name[dp->name_len] = saved_c; ! 783: } ! 784: ! 785: } ! 786: while (!__le32_to_cpu(dp->inode) || (str_chk || (print_possibilities && ch != '/'))); ! 787: ! 788: current_ino = __le32_to_cpu(dp->inode); ! 789: *(dirname = rest) = ch; ! 790: } ! 791: /* never get here */ ! 792: } ! 793: ! 794: #endif /* FSYS_EXT2_FS */
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.