]>
Commit | Line | Data |
---|---|---|
08bd0ff1 JR |
1 | Index: grub-0.97/stage2/fsys_ext2fs.c |
2 | =================================================================== | |
3 | --- grub-0.97.orig/stage2/fsys_ext2fs.c | |
4 | +++ grub-0.97/stage2/fsys_ext2fs.c | |
5 | @@ -41,6 +41,7 @@ typedef __signed__ short __s16; | |
6 | typedef unsigned short __u16; | |
7 | typedef __signed__ int __s32; | |
8 | typedef unsigned int __u32; | |
9 | +typedef unsigned long long __u64; | |
10 | ||
11 | /* | |
12 | * Constants relative to the data blocks, from ext2_fs.h | |
13 | @@ -51,7 +52,7 @@ typedef unsigned int __u32; | |
14 | #define EXT2_TIND_BLOCK (EXT2_DIND_BLOCK + 1) | |
15 | #define EXT2_N_BLOCKS (EXT2_TIND_BLOCK + 1) | |
16 | ||
17 | -/* include/linux/ext2_fs.h */ | |
18 | +/* lib/ext2fs/ext2_fs.h from e2fsprogs */ | |
19 | struct ext2_super_block | |
20 | { | |
21 | __u32 s_inodes_count; /* Inodes count */ | |
22 | @@ -61,9 +62,9 @@ struct ext2_super_block | |
23 | __u32 s_free_inodes_count; /* Free inodes count */ | |
24 | __u32 s_first_data_block; /* First Data Block */ | |
25 | __u32 s_log_block_size; /* Block size */ | |
26 | - __s32 s_log_frag_size; /* Fragment size */ | |
27 | + __s32 s_obso_log_frag_size; /* Obsoleted Fragment size */ | |
28 | __u32 s_blocks_per_group; /* # Blocks per group */ | |
29 | - __u32 s_frags_per_group; /* # Fragments per group */ | |
30 | + __u32 s_obso_frags_per_group; /* Obsoleted Fragments per group */ | |
31 | __u32 s_inodes_per_group; /* # Inodes per group */ | |
32 | __u32 s_mtime; /* Mount time */ | |
33 | __u32 s_wtime; /* Write time */ | |
34 | @@ -72,7 +73,7 @@ struct ext2_super_block | |
35 | __u16 s_magic; /* Magic signature */ | |
36 | __u16 s_state; /* File system state */ | |
37 | __u16 s_errors; /* Behaviour when detecting errors */ | |
38 | - __u16 s_pad; | |
39 | + __u16 s_minor_rev_level; /* minor revision level */ | |
40 | __u32 s_lastcheck; /* time of last check */ | |
41 | __u32 s_checkinterval; /* max. time between checks */ | |
42 | __u32 s_creator_os; /* OS */ | |
43 | @@ -119,15 +120,29 @@ struct ext2_super_block | |
44 | __u32 s_hash_seed[4]; /* HTREE hash seed */ | |
45 | __u8 s_def_hash_version; /* Default hash version to use */ | |
46 | __u8 s_jnl_backup_type; /* Default type of journal backup */ | |
47 | - __u16 s_reserved_word_pad; | |
48 | + __u16 s_desc_size; /* size of group descriptor */ | |
49 | __u32 s_default_mount_opts; | |
50 | __u32 s_first_meta_bg; /* First metablock group */ | |
51 | __u32 s_mkfs_time; /* When the filesystem was created */ | |
52 | __u32 s_jnl_blocks[17]; /* Backup of the journal inode */ | |
53 | - __u32 s_reserved[172]; /* Padding to the end of the block */ | |
54 | - }; | |
55 | + /* 64bit desc support valid if EXT4_FEATURE_INCOMPAT_64BIT */ | |
56 | + __u32 s_blocks_count_hi; /* Blocks count */ | |
57 | + __u32 s_r_blocks_count_hi; /* Reserved blocks count */ | |
58 | + __u32 s_free_blocks_count_hi; /* Free blocks count */ | |
59 | + __u16 s_min_extra_isize; /* All inodes have at least # bytes */ | |
60 | + __u16 s_max_extra_isize; /* New inodes should reverve # bytes */ | |
61 | + __u32 s_flags; /* Miscellaneous flags */ | |
62 | + __u16 s_raid_stride; /* Raid stride */ | |
63 | + __u16 s_mmp_interval; /* # seconds to wait MMP checking */ | |
64 | + __u64 s_mmp_block; /* Block for multi-mount protection */ | |
65 | + __u32 s_raid_stripe_width; /* Blocks on all data disks (N*stride)*/ | |
66 | + __u8 s_log_groups_per_flex;/* FLEX_BG group size*/ | |
67 | + __u8 s_reserved_char_pad; | |
68 | + __u16 s_reserved_pad; | |
69 | + __u32 s_reserved[162]; /* Padding to the end of the block */ | |
70 | +}; | |
71 | ||
72 | -struct ext2_group_desc | |
73 | +struct ext4_group_desc | |
74 | { | |
75 | __u32 bg_block_bitmap; /* Blocks bitmap block */ | |
76 | __u32 bg_inode_bitmap; /* Inodes bitmap block */ | |
77 | @@ -135,8 +150,18 @@ struct ext2_group_desc | |
78 | __u16 bg_free_blocks_count; /* Free blocks count */ | |
79 | __u16 bg_free_inodes_count; /* Free inodes count */ | |
80 | __u16 bg_used_dirs_count; /* Directories count */ | |
81 | - __u16 bg_pad; | |
82 | - __u32 bg_reserved[3]; | |
83 | + __u16 bg_flags; /* EXT4_BG_flags (INODE_UNINIT, etc) */ | |
84 | + __u32 bg_reserved[2]; /* Likely block/inode bitmap checksum */ | |
85 | + __u16 bg_itable_unused; /* Unused inodes count */ | |
86 | + __u16 bg_checksum; /* crc16(sb_uuid+group+desc) */ | |
87 | + __u32 bg_block_bitmap_hi; /* Blocks bitmap block MSB */ | |
88 | + __u32 bg_inode_bitmap_hi; /* Inodes bitmap block MSB */ | |
89 | + __u32 bg_inode_table_hi; /* Inodes table block MSB */ | |
90 | + __u16 bg_free_blocks_count_hi;/* Free blocks count MSB */ | |
91 | + __u16 bg_free_inodes_count_hi;/* Free inodes count MSB */ | |
92 | + __u16 bg_used_dirs_count_hi; /* Directories count MSB */ | |
93 | + __u16 bg_itable_unused_hi; /* Unused inodes count MSB */ | |
94 | + __u32 bg_reserved2[3]; | |
95 | }; | |
96 | ||
97 | struct ext2_inode | |
98 | @@ -174,22 +199,22 @@ struct ext2_inode | |
99 | __u32 i_block[EXT2_N_BLOCKS]; /* 40: Pointers to blocks */ | |
100 | __u32 i_version; /* File version (for NFS) */ | |
101 | __u32 i_file_acl; /* File ACL */ | |
102 | - __u32 i_dir_acl; /* Directory ACL */ | |
103 | - __u32 i_faddr; /* Fragment address */ | |
104 | + __u32 i_size_high; | |
105 | + __u32 i_obso_faddr; /* Obsoleted fragment address */ | |
106 | union | |
107 | { | |
108 | struct | |
109 | { | |
110 | - __u8 l_i_frag; /* Fragment number */ | |
111 | - __u8 l_i_fsize; /* Fragment size */ | |
112 | - __u16 i_pad1; | |
113 | - __u32 l_i_reserved2[2]; | |
114 | + __u16 l_i_blocks_high; /* were l_i_reserved1 */ | |
115 | + __u16 l_i_file_acl_high; | |
116 | + __u16 l_i_uid_high; /* these 2 fields */ | |
117 | + __u16 l_i_gid_high; /* were reserved2[0] */ | |
118 | + __u32 l_i_reserved2; | |
119 | } | |
120 | linux2; | |
121 | struct | |
122 | { | |
123 | - __u8 h_i_frag; /* Fragment number */ | |
124 | - __u8 h_i_fsize; /* Fragment size */ | |
125 | + __u16 h_i_reserved1; /* Obsoleted fragment number/size which are removed in ext4 */ | |
126 | __u16 h_i_mode_high; | |
127 | __u16 h_i_uid_high; | |
128 | __u16 h_i_gid_high; | |
129 | @@ -198,16 +223,36 @@ struct ext2_inode | |
130 | hurd2; | |
131 | struct | |
132 | { | |
133 | - __u8 m_i_frag; /* Fragment number */ | |
134 | - __u8 m_i_fsize; /* Fragment size */ | |
135 | - __u16 m_pad1; | |
136 | + __u16 h_i_reserved1; /* Obsoleted fragment number/size which are removed in ext4 */ | |
137 | + __u16 m_i_file_acl_high; | |
138 | __u32 m_i_reserved2[2]; | |
139 | } | |
140 | masix2; | |
141 | } | |
142 | osd2; /* OS dependent 2 */ | |
143 | + __u16 i_extra_isize; | |
144 | + __u16 i_pad1; | |
145 | + __u32 i_ctime_extra; /* extra Change time (nsec << 2 | epoch) */ | |
146 | + __u32 i_mtime_extra; /* extra Modification time(nsec << 2 | epoch) */ | |
147 | + __u32 i_atime_extra; /* extra Access time (nsec << 2 | epoch) */ | |
148 | + __u32 i_crtime; /* File Creation time */ | |
149 | + __u32 i_crtime_extra; /* extra FileCreationtime (nsec << 2 | epoch) */ | |
150 | + __u32 i_version_hi; /* high 32 bits for 64-bit version */ | |
151 | }; | |
152 | ||
153 | +#define EXT4_FEATURE_INCOMPAT_EXTENTS 0x0040 /* extents support */ | |
154 | +#define EXT4_FEATURE_INCOMPAT_64BIT 0x0080 /* grub not supported*/ | |
155 | +#define EXT4_FEATURE_INCOMPAT_MMP 0x0100 | |
156 | +#define EXT4_FEATURE_INCOMPAT_FLEX_BG 0x0200 | |
157 | + | |
158 | +#define EXT4_HAS_INCOMPAT_FEATURE(sb,mask) \ | |
159 | + ( sb->s_feature_incompat & mask ) | |
160 | + | |
161 | +#define EXT4_EXTENTS_FL 0x00080000 /* Inode uses extents */ | |
162 | +#define EXT4_HUGE_FILE_FL 0x00040000 /* Set to each huge file */ | |
163 | + | |
164 | +#define EXT4_MIN_DESC_SIZE 32 | |
165 | + | |
166 | /* linux/limits.h */ | |
167 | #define NAME_MAX 255 /* # chars in a file name */ | |
168 | ||
169 | @@ -225,6 +270,57 @@ struct ext2_dir_entry | |
170 | char name[EXT2_NAME_LEN]; /* File name */ | |
171 | }; | |
172 | ||
173 | +/* linux/ext4_fs_extents.h */ | |
174 | +/* This is the extent on-disk structure. | |
175 | + * It's used at the bottom of the tree. | |
176 | + */ | |
177 | +struct ext4_extent | |
178 | + { | |
179 | + __u32 ee_block; /* first logical block extent covers */ | |
180 | + __u16 ee_len; /* number of blocks covered by extent */ | |
181 | + __u16 ee_start_hi; /* high 16 bits of physical block */ | |
182 | + __u32 ee_start_lo; /* low 32 bits of physical block */ | |
183 | + }; | |
184 | + | |
185 | +/* | |
186 | + * This is index on-disk structure. | |
187 | + * It's used at all the levels except the bottom. | |
188 | + */ | |
189 | +struct ext4_extent_idx | |
190 | + { | |
191 | + __u32 ei_block; /* index covers logical blocks from 'block' */ | |
192 | + __u32 ei_leaf_lo; /* pointer to the physical block of the next * | |
193 | + * level. leaf or next index could be there */ | |
194 | + __u16 ei_leaf_hi; /* high 16 bits of physical block */ | |
195 | + __u16 ei_unused; | |
196 | + }; | |
197 | + | |
198 | +/* | |
199 | + * Each block (leaves and indexes), even inode-stored has header. | |
200 | + */ | |
201 | +struct ext4_extent_header | |
202 | + { | |
203 | + __u16 eh_magic; /* probably will support different formats */ | |
204 | + __u16 eh_entries; /* number of valid entries */ | |
205 | + __u16 eh_max; /* capacity of store in entries */ | |
206 | + __u16 eh_depth; /* has tree real underlying blocks? */ | |
207 | + __u32 eh_generation; /* generation of the tree */ | |
208 | + }; | |
209 | + | |
210 | +#define EXT4_EXT_MAGIC (0xf30a) | |
211 | +#define EXT_FIRST_EXTENT(__hdr__) \ | |
212 | + ((struct ext4_extent *) (((char *) (__hdr__)) + \ | |
213 | + sizeof(struct ext4_extent_header))) | |
214 | +#define EXT_FIRST_INDEX(__hdr__) \ | |
215 | + ((struct ext4_extent_idx *) (((char *) (__hdr__)) + \ | |
216 | + sizeof(struct ext4_extent_header))) | |
217 | +#define EXT_LAST_EXTENT(__hdr__) \ | |
218 | + (EXT_FIRST_EXTENT((__hdr__)) + (__u16)((__hdr__)->eh_entries) - 1) | |
219 | +#define EXT_LAST_INDEX(__hdr__) \ | |
220 | + (EXT_FIRST_INDEX((__hdr__)) + (__u16)((__hdr__)->eh_entries) - 1) | |
221 | + | |
222 | + | |
223 | + | |
224 | /* linux/ext2fs.h */ | |
225 | /* | |
226 | * EXT2_DIR_PAD defines the directory entries boundaries | |
227 | @@ -271,8 +367,17 @@ struct ext2_dir_entry | |
228 | /* kind of from ext2/super.c */ | |
229 | #define EXT2_BLOCK_SIZE(s) (1 << EXT2_BLOCK_SIZE_BITS(s)) | |
230 | /* linux/ext2fs.h */ | |
231 | +/* sizeof(struct ext2_group_desc) is changed in ext4 | |
232 | + * in kernel code, ext2/3 uses sizeof(struct ext2_group_desc) to calculate | |
233 | + * number of desc per block, while ext4 uses superblock->s_desc_size in stead | |
234 | + * superblock->s_desc_size is not available in ext2/3 | |
235 | + * */ | |
236 | +#define EXT2_DESC_SIZE(s) \ | |
237 | + (EXT4_HAS_INCOMPAT_FEATURE(s,EXT4_FEATURE_INCOMPAT_64BIT)? \ | |
238 | + s->s_desc_size : EXT4_MIN_DESC_SIZE) | |
239 | #define EXT2_DESC_PER_BLOCK(s) \ | |
240 | - (EXT2_BLOCK_SIZE(s) / sizeof (struct ext2_group_desc)) | |
241 | + (EXT2_BLOCK_SIZE(s) / EXT2_DESC_SIZE(s)) | |
242 | + | |
243 | /* linux/stat.h */ | |
244 | #define S_IFMT 00170000 | |
245 | #define S_IFLNK 0120000 | |
246 | @@ -434,6 +539,122 @@ ext2fs_block_map (int logical_block) | |
247 | [logical_block & (EXT2_ADDR_PER_BLOCK (SUPERBLOCK) - 1)]; | |
248 | } | |
249 | ||
250 | +/* extent binary search index | |
251 | + * find closest index in the current level extent tree | |
252 | + * kind of from ext4_ext_binsearch_idx in ext4/extents.c | |
253 | + */ | |
254 | +static struct ext4_extent_idx* | |
255 | +ext4_ext_binsearch_idx(struct ext4_extent_header* eh, int logical_block) | |
256 | +{ | |
257 | + struct ext4_extent_idx *r, *l, *m; | |
258 | + l = EXT_FIRST_INDEX(eh) + 1; | |
259 | + r = EXT_LAST_INDEX(eh); | |
260 | + while (l <= r) | |
261 | + { | |
262 | + m = l + (r - l) / 2; | |
263 | + if (logical_block < m->ei_block) | |
264 | + r = m - 1; | |
265 | + else | |
266 | + l = m + 1; | |
267 | + } | |
268 | + return (struct ext4_extent_idx*)(l - 1); | |
269 | +} | |
270 | + | |
271 | +/* extent binary search | |
272 | + * find closest extent in the leaf level | |
273 | + * kind of from ext4_ext_binsearch in ext4/extents.c | |
274 | + */ | |
275 | +static struct ext4_extent* | |
276 | +ext4_ext_binsearch(struct ext4_extent_header* eh, int logical_block) | |
277 | +{ | |
278 | + struct ext4_extent *r, *l, *m; | |
279 | + l = EXT_FIRST_EXTENT(eh) + 1; | |
280 | + r = EXT_LAST_EXTENT(eh); | |
281 | + while (l <= r) | |
282 | + { | |
283 | + m = l + (r - l) / 2; | |
284 | + if (logical_block < m->ee_block) | |
285 | + r = m - 1; | |
286 | + else | |
287 | + l = m + 1; | |
288 | + } | |
289 | + return (struct ext4_extent*)(l - 1); | |
290 | +} | |
291 | + | |
292 | +/* Maps extents enabled logical block into physical block via an inode. | |
293 | + * EXT4_HUGE_FILE_FL should be checked before calling this. | |
294 | + */ | |
295 | +static int | |
296 | +ext4fs_block_map (int logical_block) | |
297 | +{ | |
298 | + struct ext4_extent_header *eh; | |
299 | + struct ext4_extent *ex, *extent; | |
300 | + struct ext4_extent_idx *ei, *index; | |
301 | + int depth; | |
302 | + int i; | |
303 | + | |
304 | +#ifdef E2DEBUG | |
305 | + unsigned char *i; | |
306 | + for (i = (unsigned char *) INODE; | |
307 | + i < ((unsigned char *) INODE + sizeof (struct ext2_inode)); | |
308 | + i++) | |
309 | + { | |
310 | + printf ("%c", "0123456789abcdef"[*i >> 4]); | |
311 | + printf ("%c", "0123456789abcdef"[*i % 16]); | |
312 | + if (!((i + 1 - (unsigned char *) INODE) % 16)) | |
313 | + { | |
314 | + printf ("\n"); | |
315 | + } | |
316 | + else | |
317 | + { | |
318 | + printf (" "); | |
319 | + } | |
320 | + } | |
321 | + printf ("logical block %d\n", logical_block); | |
322 | +#endif /* E2DEBUG */ | |
323 | + eh = (struct ext4_extent_header*)INODE->i_block; | |
324 | + if (eh->eh_magic != EXT4_EXT_MAGIC) | |
325 | + { | |
326 | + errnum = ERR_FSYS_CORRUPT; | |
327 | + return -1; | |
328 | + } | |
329 | + while((depth = eh->eh_depth) != 0) | |
330 | + { /* extent index */ | |
331 | + if (eh->eh_magic != EXT4_EXT_MAGIC) | |
332 | + { | |
333 | + errnum = ERR_FSYS_CORRUPT; | |
334 | + return -1; | |
335 | + } | |
336 | + ei = ext4_ext_binsearch_idx(eh, logical_block); | |
337 | + if (ei->ei_leaf_hi) | |
338 | + {/* 64bit physical block number not supported */ | |
339 | + errnum = ERR_FILELENGTH; | |
340 | + return -1; | |
341 | + } | |
342 | + if (!ext2_rdfsb(ei->ei_leaf_lo, DATABLOCK1)) | |
343 | + { | |
344 | + errnum = ERR_FSYS_CORRUPT; | |
345 | + return -1; | |
346 | + } | |
347 | + eh = (struct ext4_extent_header*)DATABLOCK1; | |
348 | + } | |
349 | + | |
350 | + /* depth==0, we come to the leaf */ | |
351 | + ex = ext4_ext_binsearch(eh, logical_block); | |
352 | + if (ex->ee_start_hi) | |
353 | + {/* 64bit physical block number not supported */ | |
354 | + errnum = ERR_FILELENGTH; | |
355 | + return -1; | |
356 | + } | |
357 | + if ((ex->ee_block + ex->ee_len) < logical_block) | |
358 | + { | |
359 | + errnum = ERR_FSYS_CORRUPT; | |
360 | + return -1; | |
361 | + } | |
362 | + return ex->ee_start_lo + logical_block - ex->ee_block; | |
363 | + | |
364 | +} | |
365 | + | |
366 | /* preconditions: all preconds of ext2fs_block_map */ | |
367 | int | |
368 | ext2fs_read (char *buf, int len) | |
369 | @@ -468,6 +689,11 @@ ext2fs_read (char *buf, int len) | |
370 | /* find the (logical) block component of our location */ | |
371 | logical_block = filepos >> EXT2_BLOCK_SIZE_BITS (SUPERBLOCK); | |
372 | offset = filepos & (EXT2_BLOCK_SIZE (SUPERBLOCK) - 1); | |
373 | + /* map extents enabled logical block number to physical fs on-disk block number */ | |
374 | + if (EXT4_HAS_INCOMPAT_FEATURE(SUPERBLOCK,EXT4_FEATURE_INCOMPAT_EXTENTS) | |
375 | + && INODE->i_flags & EXT4_EXTENTS_FL) | |
376 | + map = ext4fs_block_map (logical_block); | |
377 | + else | |
378 | map = ext2fs_block_map (logical_block); | |
379 | #ifdef E2DEBUG | |
380 | printf ("map=%d\n", map); | |
381 | @@ -552,7 +778,7 @@ ext2fs_dir (char *dirname) | |
382 | int desc; /* index within that group */ | |
383 | int ino_blk; /* fs pointer of the inode's information */ | |
384 | int str_chk = 0; /* used to hold the results of a string compare */ | |
385 | - struct ext2_group_desc *gdp; | |
386 | + struct ext4_group_desc *ext4_gdp; | |
387 | struct ext2_inode *raw_inode; /* inode info corresponding to current_ino */ | |
388 | ||
389 | char linkbuf[PATH_MAX]; /* buffer for following symbolic links */ | |
390 | @@ -598,8 +824,15 @@ ext2fs_dir (char *dirname) | |
391 | { | |
392 | return 0; | |
393 | } | |
394 | - gdp = GROUP_DESC; | |
395 | - ino_blk = gdp[desc].bg_inode_table + | |
396 | + ext4_gdp = (struct ext4_group_desc *)( (__u8*)GROUP_DESC + | |
397 | + desc * EXT2_DESC_SIZE(SUPERBLOCK)); | |
398 | + if (EXT4_HAS_INCOMPAT_FEATURE(SUPERBLOCK, EXT4_FEATURE_INCOMPAT_64BIT) | |
399 | + && (! ext4_gdp->bg_inode_table_hi)) | |
400 | + {/* 64bit itable not supported */ | |
401 | + errnum = ERR_FILELENGTH; | |
402 | + return -1; | |
403 | + } | |
404 | + ino_blk = ext4_gdp->bg_inode_table + | |
405 | (((current_ino - 1) % (SUPERBLOCK->s_inodes_per_group)) | |
406 | >> log2 (EXT2_INODES_PER_BLOCK (SUPERBLOCK))); | |
407 | #ifdef E2DEBUG | |
408 | @@ -676,7 +909,10 @@ ext2fs_dir (char *dirname) | |
409 | } | |
410 | linkbuf[filemax + len] = '\0'; | |
411 | ||
412 | - /* Read the symlink data. */ | |
413 | + /* Read the symlink data. | |
414 | + * Slow symlink is extents enabled | |
415 | + * But since grub_read invokes ext2fs_read, nothing to change here | |
416 | + */ | |
417 | if (! ext2_is_fast_symlink ()) | |
418 | { | |
419 | /* Read the necessary blocks, and reset the file pointer. */ | |
420 | @@ -687,7 +923,9 @@ ext2fs_dir (char *dirname) | |
421 | } | |
422 | else | |
423 | { | |
424 | - /* Copy the data directly from the inode. */ | |
425 | + /* Copy the data directly from the inode. | |
426 | + * Fast symlink is not extents enabled | |
427 | + */ | |
428 | len = filemax; | |
429 | memmove (linkbuf, (char *) INODE->i_block, len); | |
430 | } | |
431 | @@ -721,6 +959,13 @@ ext2fs_dir (char *dirname) | |
432 | errnum = ERR_BAD_FILETYPE; | |
433 | return 0; | |
434 | } | |
435 | + /* if file is too large, just stop and report an error*/ | |
436 | + if ( (INODE->i_flags & EXT4_HUGE_FILE_FL) && !(INODE->i_size_high)) | |
437 | + { | |
438 | + /* file too large, stop reading */ | |
439 | + errnum = ERR_FILELENGTH; | |
440 | + return 0; | |
441 | + } | |
442 | ||
443 | filemax = (INODE->i_size); | |
444 | return 1; | |
445 | @@ -775,17 +1020,28 @@ ext2fs_dir (char *dirname) | |
446 | } | |
447 | ||
448 | /* else, find the (logical) block component of our location */ | |
449 | + /* ext4 logical block number the same as ext2/3 */ | |
450 | blk = loc >> EXT2_BLOCK_SIZE_BITS (SUPERBLOCK); | |
451 | ||
452 | /* we know which logical block of the directory entry we are looking | |
453 | for, now we have to translate that to the physical (fs) block on | |
454 | the disk */ | |
455 | + /* map extents enabled logical block number to physical fs on-disk block number */ | |
456 | + if (EXT4_HAS_INCOMPAT_FEATURE(SUPERBLOCK,EXT4_FEATURE_INCOMPAT_EXTENTS) | |
457 | + && INODE->i_flags & EXT4_EXTENTS_FL) | |
458 | + map = ext4fs_block_map (blk); | |
459 | + else | |
460 | map = ext2fs_block_map (blk); | |
461 | #ifdef E2DEBUG | |
462 | printf ("fs block=%d\n", map); | |
463 | #endif /* E2DEBUG */ | |
464 | mapblock2 = -1; | |
465 | - if ((map < 0) || !ext2_rdfsb (map, DATABLOCK2)) | |
466 | + if (map < 0) | |
467 | + { | |
468 | + *rest = ch; | |
469 | + return 0; | |
470 | + } | |
471 | + if (!ext2_rdfsb (map, DATABLOCK2)) | |
472 | { | |
473 | errnum = ERR_FSYS_CORRUPT; | |
474 | *rest = ch; |