![[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.