]> git.ipfire.org Git - thirdparty/e2fsprogs.git/blob - e2fsck/pass1.c
projects / thirdparty / e2fsprogs.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
libext2fs: check EA block headers when reading in the block
[thirdparty/e2fsprogs.git] / e2fsck / pass1.c
1 /*
2 * pass1.c -- pass #1 of e2fsck: sequential scan of the inode table
3 *
4 * Copyright (C) 1993, 1994, 1995, 1996, 1997 Theodore Ts'o.
5 *
6 * %Begin-Header%
7 * This file may be redistributed under the terms of the GNU Public
8 * License.
9 * %End-Header%
10 *
11 * Pass 1 of e2fsck iterates over all the inodes in the filesystems,
12 * and applies the following tests to each inode:
13 *
14 * - The mode field of the inode must be legal.
15 * - The size and block count fields of the inode are correct.
16 * - A data block must not be used by another inode
17 *
18 * Pass 1 also gathers the collects the following information:
19 *
20 * - A bitmap of which inodes are in use. (inode_used_map)
21 * - A bitmap of which inodes are directories. (inode_dir_map)
22 * - A bitmap of which inodes are regular files. (inode_reg_map)
23 * - A bitmap of which inodes have bad fields. (inode_bad_map)
24 * - A bitmap of which inodes are in bad blocks. (inode_bb_map)
25 * - A bitmap of which inodes are imagic inodes. (inode_imagic_map)
26 * - A bitmap of which blocks are in use. (block_found_map)
27 * - A bitmap of which blocks are in use by two inodes (block_dup_map)
28 * - The data blocks of the directory inodes. (dir_map)
29 *
30 * Pass 1 is designed to stash away enough information so that the
31 * other passes should not need to read in the inode information
32 * during the normal course of a filesystem check. (Althogh if an
33 * inconsistency is detected, other passes may need to read in an
34 * inode to fix it.)
35 *
36 * Note that pass 1B will be invoked if there are any duplicate blocks
37 * found.
38 */
39
40 #define _GNU_SOURCE 1 /* get strnlen() */
41 #include "config.h"
42 #include <string.h>
43 #include <time.h>
44 #ifdef HAVE_ERRNO_H
45 #include <errno.h>
46 #endif
47
48 #include "e2fsck.h"
49 #include <ext2fs/ext2_ext_attr.h>
50
51 #include "problem.h"
52
53 #ifdef NO_INLINE_FUNCS
54 #define _INLINE_
55 #else
56 #define _INLINE_ inline
57 #endif
58
59 static int process_block(ext2_filsys fs, blk64_t *blocknr,
60 e2_blkcnt_t blockcnt, blk64_t ref_blk,
61 int ref_offset, void *priv_data);
62 static int process_bad_block(ext2_filsys fs, blk64_t *block_nr,
63 e2_blkcnt_t blockcnt, blk64_t ref_blk,
64 int ref_offset, void *priv_data);
65 static void check_blocks(e2fsck_t ctx, struct problem_context *pctx,
66 char *block_buf);
67 static void mark_table_blocks(e2fsck_t ctx);
68 static void alloc_bb_map(e2fsck_t ctx);
69 static void alloc_imagic_map(e2fsck_t ctx);
70 static void mark_inode_bad(e2fsck_t ctx, ino_t ino);
71 static void handle_fs_bad_blocks(e2fsck_t ctx);
72 static void process_inodes(e2fsck_t ctx, char *block_buf);
73 static EXT2_QSORT_TYPE process_inode_cmp(const void *a, const void *b);
74 static errcode_t scan_callback(ext2_filsys fs, ext2_inode_scan scan,
75 dgrp_t group, void * priv_data);
76 static void adjust_extattr_refcount(e2fsck_t ctx, ext2_refcount_t refcount,
77 char *block_buf, int adjust_sign);
78 /* static char *describe_illegal_block(ext2_filsys fs, blk64_t block); */
79
80 struct process_block_struct {
81 ext2_ino_t ino;
82 unsigned is_dir:1, is_reg:1, clear:1, suppress:1,
83 fragmented:1, compressed:1, bbcheck:1,
84 inode_modified:1;
85 blk64_t num_blocks;
86 blk64_t max_blocks;
87 e2_blkcnt_t last_block;
88 e2_blkcnt_t last_init_lblock;
89 e2_blkcnt_t last_db_block;
90 int num_illegal_blocks;
91 blk64_t previous_block;
92 struct ext2_inode *inode;
93 struct problem_context *pctx;
94 ext2fs_block_bitmap fs_meta_blocks;
95 e2fsck_t ctx;
96 blk64_t bad_ref;
97 };
98
99 struct process_inode_block {
100 ext2_ino_t ino;
101 struct ext2_inode inode;
102 };
103
104 struct scan_callback_struct {
105 e2fsck_t ctx;
106 char *block_buf;
107 };
108
109 /*
110 * For the inodes to process list.
111 */
112 static struct process_inode_block *inodes_to_process;
113 static int process_inode_count;
114
115 static __u64 ext2_max_sizes[EXT2_MAX_BLOCK_LOG_SIZE -
116 EXT2_MIN_BLOCK_LOG_SIZE + 1];
117
118 /*
119 * Free all memory allocated by pass1 in preparation for restarting
120 * things.
121 */
122 static void unwind_pass1(ext2_filsys fs EXT2FS_ATTR((unused)))
123 {
124 ext2fs_free_mem(&inodes_to_process);
125 inodes_to_process = 0;
126 }
127
128 /*
129 * Check to make sure a device inode is real. Returns 1 if the device
130 * checks out, 0 if not.
131 *
132 * Note: this routine is now also used to check FIFO's and Sockets,
133 * since they have the same requirement; the i_block fields should be
134 * zero.
135 */
136 int e2fsck_pass1_check_device_inode(ext2_filsys fs EXT2FS_ATTR((unused)),
137 struct ext2_inode *inode)
138 {
139 int i;
140
141 /*
142 * If the index flag is set, then this is a bogus
143 * device/fifo/socket
144 */
145 if (inode->i_flags & EXT2_INDEX_FL)
146 return 0;
147
148 /*
149 * We should be able to do the test below all the time, but
150 * because the kernel doesn't forcibly clear the device
151 * inode's additional i_block fields, there are some rare
152 * occasions when a legitimate device inode will have non-zero
153 * additional i_block fields. So for now, we only complain
154 * when the immutable flag is set, which should never happen
155 * for devices. (And that's when the problem is caused, since
156 * you can't set or clear immutable flags for devices.) Once
157 * the kernel has been fixed we can change this...
158 */
159 if (inode->i_flags & (EXT2_IMMUTABLE_FL | EXT2_APPEND_FL)) {
160 for (i=4; i < EXT2_N_BLOCKS; i++)
161 if (inode->i_block[i])
162 return 0;
163 }
164 return 1;
165 }
166
167 /*
168 * Check to make sure a symlink inode is real. Returns 1 if the symlink
169 * checks out, 0 if not.
170 */
171 int e2fsck_pass1_check_symlink(ext2_filsys fs, ext2_ino_t ino,
172 struct ext2_inode *inode, char *buf)
173 {
174 unsigned int len;
175 int i;
176 blk64_t blocks;
177 ext2_extent_handle_t handle;
178 struct ext2_extent_info info;
179 struct ext2fs_extent extent;
180
181 if ((inode->i_size_high || inode->i_size == 0) ||
182 (inode->i_flags & EXT2_INDEX_FL))
183 return 0;
184
185 if (inode->i_flags & EXT4_EXTENTS_FL) {
186 if (inode->i_size > fs->blocksize)
187 return 0;
188 if (ext2fs_extent_open2(fs, ino, inode, &handle))
189 return 0;
190 i = 0;
191 if (ext2fs_extent_get_info(handle, &info) ||
192 (info.num_entries != 1) ||
193 (info.max_depth != 0))
194 goto exit_extent;
195 if (ext2fs_extent_get(handle, EXT2_EXTENT_ROOT, &extent) ||
196 (extent.e_lblk != 0) ||
197 (extent.e_len != 1) ||
198 (extent.e_pblk < fs->super->s_first_data_block) ||
199 (extent.e_pblk >= ext2fs_blocks_count(fs->super)))
200 goto exit_extent;
201 i = 1;
202 exit_extent:
203 ext2fs_extent_free(handle);
204 return i;
205 }
206
207 if (inode->i_flags & EXT4_INLINE_DATA_FL) {
208 size_t inline_size;
209
210 if (ext2fs_inline_data_size(fs, ino, &inline_size))
211 return 0;
212 if (inode->i_size != inline_size)
213 return 0;
214
215 return 1;
216 }
217
218 blocks = ext2fs_inode_data_blocks2(fs, inode);
219 if (blocks) {
220 if ((inode->i_size >= fs->blocksize) ||
221 (blocks != fs->blocksize >> 9) ||
222 (inode->i_block[0] < fs->super->s_first_data_block) ||
223 (inode->i_block[0] >= ext2fs_blocks_count(fs->super)))
224 return 0;
225
226 for (i = 1; i < EXT2_N_BLOCKS; i++)
227 if (inode->i_block[i])
228 return 0;
229
230 if (io_channel_read_blk64(fs->io, inode->i_block[0], 1, buf))
231 return 0;
232
233 len = strnlen(buf, fs->blocksize);
234 if (len == fs->blocksize)
235 return 0;
236 } else {
237 if (inode->i_size >= sizeof(inode->i_block))
238 return 0;
239
240 len = strnlen((char *)inode->i_block, sizeof(inode->i_block));
241 if (len == sizeof(inode->i_block))
242 return 0;
243 }
244 if (len != inode->i_size)
245 return 0;
246 return 1;
247 }
248
249 /*
250 * If the immutable (or append-only) flag is set on the inode, offer
251 * to clear it.
252 */
253 #define BAD_SPECIAL_FLAGS (EXT2_IMMUTABLE_FL | EXT2_APPEND_FL)
254 static void check_immutable(e2fsck_t ctx, struct problem_context *pctx)
255 {
256 if (!(pctx->inode->i_flags & BAD_SPECIAL_FLAGS))
257 return;
258
259 if (!fix_problem(ctx, PR_1_SET_IMMUTABLE, pctx))
260 return;
261
262 pctx->inode->i_flags &= ~BAD_SPECIAL_FLAGS;
263 e2fsck_write_inode(ctx, pctx->ino, pctx->inode, "pass1");
264 }
265
266 /*
267 * If device, fifo or socket, check size is zero -- if not offer to
268 * clear it
269 */
270 static void check_size(e2fsck_t ctx, struct problem_context *pctx)
271 {
272 struct ext2_inode *inode = pctx->inode;
273
274 if (EXT2_I_SIZE(inode) == 0)
275 return;
276
277 if (!fix_problem(ctx, PR_1_SET_NONZSIZE, pctx))
278 return;
279
280 ext2fs_inode_size_set(ctx->fs, inode, 0);
281 e2fsck_write_inode(ctx, pctx->ino, pctx->inode, "pass1");
282 }
283
284 static void check_ea_in_inode(e2fsck_t ctx, struct problem_context *pctx)
285 {
286 struct ext2_super_block *sb = ctx->fs->super;
287 struct ext2_inode_large *inode;
288 struct ext2_ext_attr_entry *entry;
289 char *start;
290 unsigned int storage_size, remain;
291 problem_t problem = 0;
292
293 inode = (struct ext2_inode_large *) pctx->inode;
294 storage_size = EXT2_INODE_SIZE(ctx->fs->super) - EXT2_GOOD_OLD_INODE_SIZE -
295 inode->i_extra_isize;
296 start = ((char *) inode) + EXT2_GOOD_OLD_INODE_SIZE +
297 inode->i_extra_isize + sizeof(__u32);
298 entry = (struct ext2_ext_attr_entry *) start;
299
300 /* scan all entry's headers first */
301
302 /* take finish entry 0UL into account */
303 remain = storage_size - sizeof(__u32);
304
305 while (!EXT2_EXT_IS_LAST_ENTRY(entry)) {
306 __u32 hash;
307
308 /* header eats this space */
309 remain -= sizeof(struct ext2_ext_attr_entry);
310
311 /* is attribute name valid? */
312 if (EXT2_EXT_ATTR_SIZE(entry->e_name_len) > remain) {
313 pctx->num = entry->e_name_len;
314 problem = PR_1_ATTR_NAME_LEN;
315 goto fix;
316 }
317
318 /* attribute len eats this space */
319 remain -= EXT2_EXT_ATTR_SIZE(entry->e_name_len);
320
321 /* check value size */
322 if (entry->e_value_size > remain) {
323 pctx->num = entry->e_value_size;
324 problem = PR_1_ATTR_VALUE_SIZE;
325 goto fix;
326 }
327
328 /* e_value_block must be 0 in inode's ea */
329 if (entry->e_value_block != 0) {
330 pctx->num = entry->e_value_block;
331 problem = PR_1_ATTR_VALUE_BLOCK;
332 goto fix;
333 }
334
335 hash = ext2fs_ext_attr_hash_entry(entry,
336 start + entry->e_value_offs);
337
338 /* e_hash may be 0 in older inode's ea */
339 if (entry->e_hash != 0 && entry->e_hash != hash) {
340 pctx->num = entry->e_hash;
341 problem = PR_1_ATTR_HASH;
342 goto fix;
343 }
344
345 remain -= entry->e_value_size;
346
347 entry = EXT2_EXT_ATTR_NEXT(entry);
348 }
349 fix:
350 /*
351 * it seems like a corruption. it's very unlikely we could repair
352 * EA(s) in automatic fashion -bzzz
353 */
354 if (problem == 0 || !fix_problem(ctx, problem, pctx))
355 return;
356
357 /* simply remove all possible EA(s) */
358 *((__u32 *)start) = 0UL;
359 e2fsck_write_inode_full(ctx, pctx->ino, pctx->inode,
360 EXT2_INODE_SIZE(sb), "pass1");
361 }
362
363 static void check_inode_extra_space(e2fsck_t ctx, struct problem_context *pctx)
364 {
365 struct ext2_super_block *sb = ctx->fs->super;
366 struct ext2_inode_large *inode;
367 __u32 *eamagic;
368 int min, max;
369
370 inode = (struct ext2_inode_large *) pctx->inode;
371 if (EXT2_INODE_SIZE(sb) == EXT2_GOOD_OLD_INODE_SIZE) {
372 /* this isn't large inode. so, nothing to check */
373 return;
374 }
375
376 #if 0
377 printf("inode #%u, i_extra_size %d\n", pctx->ino,
378 inode->i_extra_isize);
379 #endif
380 /* i_extra_isize must cover i_extra_isize + i_checksum_hi at least */
381 min = sizeof(inode->i_extra_isize) + sizeof(inode->i_checksum_hi);
382 max = EXT2_INODE_SIZE(sb) - EXT2_GOOD_OLD_INODE_SIZE;
383 /*
384 * For now we will allow i_extra_isize to be 0, but really
385 * implementations should never allow i_extra_isize to be 0
386 */
387 if (inode->i_extra_isize &&
388 (inode->i_extra_isize < min || inode->i_extra_isize > max)) {
389 if (!fix_problem(ctx, PR_1_EXTRA_ISIZE, pctx))
390 return;
391 inode->i_extra_isize = min;
392 e2fsck_write_inode_full(ctx, pctx->ino, pctx->inode,
393 EXT2_INODE_SIZE(sb), "pass1");
394 return;
395 }
396
397 eamagic = (__u32 *) (((char *) inode) + EXT2_GOOD_OLD_INODE_SIZE +
398 inode->i_extra_isize);
399 if (*eamagic == EXT2_EXT_ATTR_MAGIC) {
400 /* it seems inode has an extended attribute(s) in body */
401 check_ea_in_inode(ctx, pctx);
402 }
403 }
404
405 /*
406 * Check to see if the inode might really be a directory, despite i_mode
407 *
408 * This is a lot of complexity for something for which I'm not really
409 * convinced happens frequently in the wild. If for any reason this
410 * causes any problems, take this code out.
411 * [tytso:20070331.0827EDT]
412 */
413 static void check_is_really_dir(e2fsck_t ctx, struct problem_context *pctx,
414 char *buf)
415 {
416 struct ext2_inode *inode = pctx->inode;
417 struct ext2_dir_entry *dirent;
418 errcode_t retval;
419 blk64_t blk;
420 unsigned int i, rec_len, not_device = 0;
421 int extent_fs;
422 int inlinedata_fs;
423
424 /*
425 * If the mode looks OK, we believe it. If the first block in
426 * the i_block array is 0, this cannot be a directory. If the
427 * inode is extent-mapped, it is still the case that the latter
428 * cannot be 0 - the magic number in the extent header would make
429 * it nonzero.
430 */
431 if (LINUX_S_ISDIR(inode->i_mode) || LINUX_S_ISREG(inode->i_mode) ||
432 LINUX_S_ISLNK(inode->i_mode) || inode->i_block[0] == 0)
433 return;
434
435 /*
436 * Check the block numbers in the i_block array for validity:
437 * zero blocks are skipped (but the first one cannot be zero -
438 * see above), other blocks are checked against the first and
439 * max data blocks (from the the superblock) and against the
440 * block bitmap. Any invalid block found means this cannot be
441 * a directory.
442 *
443 * If there are non-zero blocks past the fourth entry, then
444 * this cannot be a device file: we remember that for the next
445 * check.
446 *
447 * For extent mapped files, we don't do any sanity checking:
448 * just try to get the phys block of logical block 0 and run
449 * with it.
450 *
451 * For inline data files, we just try to get the size of inline
452 * data. If it's true, we will treat it as a directory.
453 */
454
455 extent_fs = (ctx->fs->super->s_feature_incompat &
456 EXT3_FEATURE_INCOMPAT_EXTENTS);
457 inlinedata_fs = (ctx->fs->super->s_feature_incompat &
458 EXT4_FEATURE_INCOMPAT_INLINE_DATA);
459 if (inlinedata_fs && (inode->i_flags & EXT4_INLINE_DATA_FL)) {
460 size_t size;
461
462 if (ext2fs_inline_data_size(ctx->fs, pctx->ino, &size))
463 return;
464 /* device files never have a "system.data" entry */
465 goto isdir;
466 } else if (extent_fs && (inode->i_flags & EXT4_EXTENTS_FL)) {
467 /* extent mapped */
468 if (ext2fs_bmap2(ctx->fs, pctx->ino, inode, 0, 0, 0, 0,
469 &blk))
470 return;
471 /* device files are never extent mapped */
472 not_device++;
473 } else {
474 for (i=0; i < EXT2_N_BLOCKS; i++) {
475 blk = inode->i_block[i];
476 if (!blk)
477 continue;
478 if (i >= 4)
479 not_device++;
480
481 if (blk < ctx->fs->super->s_first_data_block ||
482 blk >= ext2fs_blocks_count(ctx->fs->super) ||
483 ext2fs_fast_test_block_bitmap2(ctx->block_found_map,
484 blk))
485 return; /* Invalid block, can't be dir */
486 }
487 blk = inode->i_block[0];
488 }
489
490 /*
491 * If the mode says this is a device file and the i_links_count field
492 * is sane and we have not ruled it out as a device file previously,
493 * we declare it a device file, not a directory.
494 */
495 if ((LINUX_S_ISCHR(inode->i_mode) || LINUX_S_ISBLK(inode->i_mode)) &&
496 (inode->i_links_count == 1) && !not_device)
497 return;
498
499 /* read the first block */
500 ehandler_operation(_("reading directory block"));
501 retval = ext2fs_read_dir_block4(ctx->fs, blk, buf, 0, pctx->ino);
502 ehandler_operation(0);
503 if (retval)
504 return;
505
506 dirent = (struct ext2_dir_entry *) buf;
507 retval = ext2fs_get_rec_len(ctx->fs, dirent, &rec_len);
508 if (retval)
509 return;
510 if ((ext2fs_dirent_name_len(dirent) != 1) ||
511 (dirent->name[0] != '.') ||
512 (dirent->inode != pctx->ino) ||
513 (rec_len < 12) ||
514 (rec_len % 4) ||
515 (rec_len >= ctx->fs->blocksize - 12))
516 return;
517
518 dirent = (struct ext2_dir_entry *) (buf + rec_len);
519 retval = ext2fs_get_rec_len(ctx->fs, dirent, &rec_len);
520 if (retval)
521 return;
522 if ((ext2fs_dirent_name_len(dirent) != 2) ||
523 (dirent->name[0] != '.') ||
524 (dirent->name[1] != '.') ||
525 (rec_len < 12) ||
526 (rec_len % 4))
527 return;
528
529 isdir:
530 if (fix_problem(ctx, PR_1_TREAT_AS_DIRECTORY, pctx)) {
531 inode->i_mode = (inode->i_mode & 07777) | LINUX_S_IFDIR;
532 e2fsck_write_inode_full(ctx, pctx->ino, inode,
533 EXT2_INODE_SIZE(ctx->fs->super),
534 "check_is_really_dir");
535 }
536 }
537
538 void e2fsck_setup_tdb_icount(e2fsck_t ctx, int flags,
539 ext2_icount_t *ret)
540 {
541 unsigned int threshold;
542 ext2_ino_t num_dirs;
543 errcode_t retval;
544 char *tdb_dir;
545 int enable;
546
547 *ret = 0;
548
549 profile_get_string(ctx->profile, "scratch_files", "directory", 0, 0,
550 &tdb_dir);
551 profile_get_uint(ctx->profile, "scratch_files",
552 "numdirs_threshold", 0, 0, &threshold);
553 profile_get_boolean(ctx->profile, "scratch_files",
554 "icount", 0, 1, &enable);
555
556 retval = ext2fs_get_num_dirs(ctx->fs, &num_dirs);
557 if (retval)
558 num_dirs = 1024; /* Guess */
559
560 if (!enable || !tdb_dir || access(tdb_dir, W_OK) ||
561 (threshold && num_dirs <= threshold))
562 return;
563
564 retval = ext2fs_create_icount_tdb(ctx->fs, tdb_dir, flags, ret);
565 if (retval)
566 *ret = 0;
567 }
568
569 static errcode_t recheck_bad_inode_checksum(ext2_filsys fs, ext2_ino_t ino,
570 e2fsck_t ctx,
571 struct problem_context *pctx)
572 {
573 errcode_t retval;
574 struct ext2_inode_large inode;
575
576 /*
577 * Reread inode. If we don't see checksum error, then this inode
578 * has been fixed elsewhere.
579 */
580 retval = ext2fs_read_inode_full(fs, ino, (struct ext2_inode *)&inode,
581 sizeof(inode));
582 if (retval && retval != EXT2_ET_INODE_CSUM_INVALID)
583 return retval;
584 if (!retval)
585 return 0;
586
587 /*
588 * Checksum still doesn't match. That implies that the inode passes
589 * all the sanity checks, so maybe the checksum is simply corrupt.
590 * See if the user will go for fixing that.
591 */
592 if (!fix_problem(ctx, PR_1_INODE_ONLY_CSUM_INVALID, pctx))
593 return 0;
594
595 retval = ext2fs_write_inode_full(fs, ino, (struct ext2_inode *)&inode,
596 sizeof(inode));
597 if (retval)
598 return retval;
599
600 return 0;
601 }
602
603 static void reserve_block_for_root_repair(e2fsck_t ctx)
604 {
605 blk64_t blk = 0;
606 errcode_t err;
607 ext2_filsys fs = ctx->fs;
608
609 ctx->root_repair_block = 0;
610 if (ext2fs_test_inode_bitmap2(ctx->inode_used_map, EXT2_ROOT_INO))
611 return;
612
613 err = ext2fs_new_block2(fs, 0, ctx->block_found_map, &blk);
614 if (err)
615 return;
616 ext2fs_mark_block_bitmap2(ctx->block_found_map, blk);
617 ctx->root_repair_block = blk;
618 }
619
620 static void reserve_block_for_lnf_repair(e2fsck_t ctx)
621 {
622 blk64_t blk = 0;
623 errcode_t err;
624 ext2_filsys fs = ctx->fs;
625 static const char name[] = "lost+found";
626 ext2_ino_t ino;
627
628 ctx->lnf_repair_block = 0;
629 if (!ext2fs_lookup(fs, EXT2_ROOT_INO, name, sizeof(name)-1, 0, &ino))
630 return;
631
632 err = ext2fs_new_block2(fs, 0, ctx->block_found_map, &blk);
633 if (err)
634 return;
635 ext2fs_mark_block_bitmap2(ctx->block_found_map, blk);
636 ctx->lnf_repair_block = blk;
637 }
638
639 void e2fsck_pass1(e2fsck_t ctx)
640 {
641 int i;
642 __u64 max_sizes;
643 ext2_filsys fs = ctx->fs;
644 ext2_ino_t ino = 0;
645 struct ext2_inode *inode = NULL;
646 ext2_inode_scan scan = NULL;
647 char *block_buf = NULL;
648 #ifdef RESOURCE_TRACK
649 struct resource_track rtrack;
650 #endif
651 unsigned char frag, fsize;
652 struct problem_context pctx;
653 struct scan_callback_struct scan_struct;
654 struct ext2_super_block *sb = ctx->fs->super;
655 const char *old_op;
656 unsigned int save_type;
657 int imagic_fs, extent_fs, inlinedata_fs;
658 int low_dtime_check = 1;
659 int inode_size;
660 int failed_csum = 0;
661
662 init_resource_track(&rtrack, ctx->fs->io);
663 clear_problem_context(&pctx);
664
665 if (!(ctx->options & E2F_OPT_PREEN))
666 fix_problem(ctx, PR_1_PASS_HEADER, &pctx);
667
668 if ((fs->super->s_feature_compat & EXT2_FEATURE_COMPAT_DIR_INDEX) &&
669 !(ctx->options & E2F_OPT_NO)) {
670 if (ext2fs_u32_list_create(&ctx->dirs_to_hash, 50))
671 ctx->dirs_to_hash = 0;
672 }
673
674 #ifdef MTRACE
675 mtrace_print("Pass 1");
676 #endif
677
678 #define EXT2_BPP(bits) (1ULL << ((bits) - 2))
679
680 for (i = EXT2_MIN_BLOCK_LOG_SIZE; i <= EXT2_MAX_BLOCK_LOG_SIZE; i++) {
681 max_sizes = EXT2_NDIR_BLOCKS + EXT2_BPP(i);
682 max_sizes = max_sizes + EXT2_BPP(i) * EXT2_BPP(i);
683 max_sizes = max_sizes + EXT2_BPP(i) * EXT2_BPP(i) * EXT2_BPP(i);
684 max_sizes = (max_sizes * (1UL << i));
685 ext2_max_sizes[i - EXT2_MIN_BLOCK_LOG_SIZE] = max_sizes;
686 }
687 #undef EXT2_BPP
688
689 imagic_fs = (sb->s_feature_compat & EXT2_FEATURE_COMPAT_IMAGIC_INODES);
690 extent_fs = (sb->s_feature_incompat & EXT3_FEATURE_INCOMPAT_EXTENTS);
691 inlinedata_fs = (sb->s_feature_incompat &
692 EXT4_FEATURE_INCOMPAT_INLINE_DATA);
693
694 /*
695 * Allocate bitmaps structures
696 */
697 pctx.errcode = e2fsck_allocate_inode_bitmap(fs, _("in-use inode map"),
698 EXT2FS_BMAP64_RBTREE,
699 "inode_used_map",
700 &ctx->inode_used_map);
701 if (pctx.errcode) {
702 pctx.num = 1;
703 fix_problem(ctx, PR_1_ALLOCATE_IBITMAP_ERROR, &pctx);
704 ctx->flags |= E2F_FLAG_ABORT;
705 return;
706 }
707 pctx.errcode = e2fsck_allocate_inode_bitmap(fs,
708 _("directory inode map"),
709 EXT2FS_BMAP64_AUTODIR,
710 "inode_dir_map", &ctx->inode_dir_map);
711 if (pctx.errcode) {
712 pctx.num = 2;
713 fix_problem(ctx, PR_1_ALLOCATE_IBITMAP_ERROR, &pctx);
714 ctx->flags |= E2F_FLAG_ABORT;
715 return;
716 }
717 pctx.errcode = e2fsck_allocate_inode_bitmap(fs,
718 _("regular file inode map"), EXT2FS_BMAP64_RBTREE,
719 "inode_reg_map", &ctx->inode_reg_map);
720 if (pctx.errcode) {
721 pctx.num = 6;
722 fix_problem(ctx, PR_1_ALLOCATE_IBITMAP_ERROR, &pctx);
723 ctx->flags |= E2F_FLAG_ABORT;
724 return;
725 }
726 pctx.errcode = e2fsck_allocate_subcluster_bitmap(fs,
727 _("in-use block map"), EXT2FS_BMAP64_RBTREE,
728 "block_found_map", &ctx->block_found_map);
729 if (pctx.errcode) {
730 pctx.num = 1;
731 fix_problem(ctx, PR_1_ALLOCATE_BBITMAP_ERROR, &pctx);
732 ctx->flags |= E2F_FLAG_ABORT;
733 return;
734 }
735 pctx.errcode = e2fsck_allocate_block_bitmap(fs,
736 _("metadata block map"), EXT2FS_BMAP64_RBTREE,
737 "block_metadata_map", &ctx->block_metadata_map);
738 if (pctx.errcode) {
739 pctx.num = 1;
740 fix_problem(ctx, PR_1_ALLOCATE_BBITMAP_ERROR, &pctx);
741 ctx->flags |= E2F_FLAG_ABORT;
742 return;
743 }
744 e2fsck_setup_tdb_icount(ctx, 0, &ctx->inode_link_info);
745 if (!ctx->inode_link_info) {
746 e2fsck_set_bitmap_type(fs, EXT2FS_BMAP64_RBTREE,
747 "inode_link_info", &save_type);
748 pctx.errcode = ext2fs_create_icount2(fs, 0, 0, 0,
749 &ctx->inode_link_info);
750 fs->default_bitmap_type = save_type;
751 }
752
753 if (pctx.errcode) {
754 fix_problem(ctx, PR_1_ALLOCATE_ICOUNT, &pctx);
755 ctx->flags |= E2F_FLAG_ABORT;
756 return;
757 }
758 inode_size = EXT2_INODE_SIZE(fs->super);
759 inode = (struct ext2_inode *)
760 e2fsck_allocate_memory(ctx, inode_size, "scratch inode");
761
762 inodes_to_process = (struct process_inode_block *)
763 e2fsck_allocate_memory(ctx,
764 (ctx->process_inode_size *
765 sizeof(struct process_inode_block)),
766 "array of inodes to process");
767 process_inode_count = 0;
768
769 pctx.errcode = ext2fs_init_dblist(fs, 0);
770 if (pctx.errcode) {
771 fix_problem(ctx, PR_1_ALLOCATE_DBCOUNT, &pctx);
772 ctx->flags |= E2F_FLAG_ABORT;
773 goto endit;
774 }
775
776 /*
777 * If the last orphan field is set, clear it, since the pass1
778 * processing will automatically find and clear the orphans.
779 * In the future, we may want to try using the last_orphan
780 * linked list ourselves, but for now, we clear it so that the
781 * ext3 mount code won't get confused.
782 */
783 if (!(ctx->options & E2F_OPT_READONLY)) {
784 if (fs->super->s_last_orphan) {
785 fs->super->s_last_orphan = 0;
786 ext2fs_mark_super_dirty(fs);
787 }
788 }
789
790 mark_table_blocks(ctx);
791 pctx.errcode = ext2fs_convert_subcluster_bitmap(fs,
792 &ctx->block_found_map);
793 if (pctx.errcode) {
794 fix_problem(ctx, PR_1_CONVERT_SUBCLUSTER, &pctx);
795 ctx->flags |= E2F_FLAG_ABORT;
796 goto endit;
797 }
798 block_buf = (char *) e2fsck_allocate_memory(ctx, fs->blocksize * 3,
799 "block interate buffer");
800 if (EXT2_INODE_SIZE(fs->super) == EXT2_GOOD_OLD_INODE_SIZE)
801 e2fsck_use_inode_shortcuts(ctx, 1);
802 e2fsck_intercept_block_allocations(ctx);
803 old_op = ehandler_operation(_("opening inode scan"));
804 pctx.errcode = ext2fs_open_inode_scan(fs, ctx->inode_buffer_blocks,
805 &scan);
806 ehandler_operation(old_op);
807 if (pctx.errcode) {
808 fix_problem(ctx, PR_1_ISCAN_ERROR, &pctx);
809 ctx->flags |= E2F_FLAG_ABORT;
810 goto endit;
811 }
812 ext2fs_inode_scan_flags(scan, EXT2_SF_SKIP_MISSING_ITABLE, 0);
813 ctx->stashed_inode = inode;
814 scan_struct.ctx = ctx;
815 scan_struct.block_buf = block_buf;
816 ext2fs_set_inode_callback(scan, scan_callback, &scan_struct);
817 if (ctx->progress && ((ctx->progress)(ctx, 1, 0,
818 ctx->fs->group_desc_count)))
819 goto endit;
820 if ((fs->super->s_wtime < fs->super->s_inodes_count) ||
821 (fs->super->s_mtime < fs->super->s_inodes_count) ||
822 (fs->super->s_mkfs_time &&
823 fs->super->s_mkfs_time < fs->super->s_inodes_count))
824 low_dtime_check = 0;
825
826 if ((fs->super->s_feature_incompat & EXT4_FEATURE_INCOMPAT_MMP) &&
827 fs->super->s_mmp_block > fs->super->s_first_data_block &&
828 fs->super->s_mmp_block < ext2fs_blocks_count(fs->super))
829 ext2fs_mark_block_bitmap2(ctx->block_found_map,
830 fs->super->s_mmp_block);
831
832 /* Set up ctx->lost_and_found if possible */
833 (void) e2fsck_get_lost_and_found(ctx, 0);
834
835 while (1) {
836 if (ino % (fs->super->s_inodes_per_group * 4) == 1) {
837 if (e2fsck_mmp_update(fs))
838 fatal_error(ctx, 0);
839 }
840 old_op = ehandler_operation(_("getting next inode from scan"));
841 pctx.errcode = ext2fs_get_next_inode_full(scan, &ino,
842 inode, inode_size);
843 ehandler_operation(old_op);
844 if (ctx->flags & E2F_FLAG_SIGNAL_MASK)
845 return;
846 if (pctx.errcode == EXT2_ET_BAD_BLOCK_IN_INODE_TABLE) {
847 if (!ctx->inode_bb_map)
848 alloc_bb_map(ctx);
849 ext2fs_mark_inode_bitmap2(ctx->inode_bb_map, ino);
850 ext2fs_mark_inode_bitmap2(ctx->inode_used_map, ino);
851 continue;
852 }
853 if (pctx.errcode &&
854 pctx.errcode != EXT2_ET_INODE_CSUM_INVALID) {
855 fix_problem(ctx, PR_1_ISCAN_ERROR, &pctx);
856 ctx->flags |= E2F_FLAG_ABORT;
857 goto endit;
858 }
859 if (!ino)
860 break;
861 pctx.ino = ino;
862 pctx.inode = inode;
863 ctx->stashed_ino = ino;
864
865 /* Clear corrupt inode? */
866 if (pctx.errcode == EXT2_ET_INODE_CSUM_INVALID) {
867 if (fix_problem(ctx, PR_1_INODE_CSUM_INVALID, &pctx))
868 goto clear_inode;
869 failed_csum = 1;
870 }
871
872 if (inode->i_links_count) {
873 pctx.errcode = ext2fs_icount_store(ctx->inode_link_info,
874 ino, inode->i_links_count);
875 if (pctx.errcode) {
876 pctx.num = inode->i_links_count;
877 fix_problem(ctx, PR_1_ICOUNT_STORE, &pctx);
878 ctx->flags |= E2F_FLAG_ABORT;
879 goto endit;
880 }
881 }
882
883 /* Test for incorrect inline_data flags settings. */
884 if ((inode->i_flags & EXT4_INLINE_DATA_FL) && !inlinedata_fs &&
885 (ino >= EXT2_FIRST_INODE(fs->super))) {
886 size_t size = 0;
887
888 pctx.errcode = ext2fs_inline_data_size(fs, ino, &size);
889 if (!pctx.errcode && size &&
890 !fix_problem(ctx, PR_1_INLINE_DATA_FEATURE, &pctx)) {
891 sb->s_feature_incompat |=
892 EXT4_FEATURE_INCOMPAT_INLINE_DATA;
893 ext2fs_mark_super_dirty(fs);
894 inlinedata_fs = 1;
895 } else if (!fix_problem(ctx, PR_1_INLINE_DATA_SET, &pctx)) {
896 e2fsck_clear_inode(ctx, ino, inode, 0, "pass1");
897 continue;
898 }
899 }
900
901 /*
902 * Test for incorrect extent flag settings.
903 *
904 * On big-endian machines we must be careful:
905 * When the inode is read, the i_block array is not swapped
906 * if the extent flag is set. Therefore if we are testing
907 * for or fixing a wrongly-set flag, we must potentially
908 * (un)swap before testing, or after fixing.
909 */
910
911 /*
912 * In this case the extents flag was set when read, so
913 * extent_header_verify is ok. If the inode is cleared,
914 * no need to swap... so no extra swapping here.
915 */
916 if ((inode->i_flags & EXT4_EXTENTS_FL) && !extent_fs &&
917 (inode->i_links_count || (ino == EXT2_BAD_INO) ||
918 (ino == EXT2_ROOT_INO) || (ino == EXT2_JOURNAL_INO))) {
919 if ((ext2fs_extent_header_verify(inode->i_block,
920 sizeof(inode->i_block)) == 0) &&
921 fix_problem(ctx, PR_1_EXTENT_FEATURE, &pctx)) {
922 sb->s_feature_incompat |= EXT3_FEATURE_INCOMPAT_EXTENTS;
923 ext2fs_mark_super_dirty(fs);
924 extent_fs = 1;
925 } else if (fix_problem(ctx, PR_1_EXTENTS_SET, &pctx)) {
926 clear_inode:
927 e2fsck_clear_inode(ctx, ino, inode, 0, "pass1");
928 if (ino == EXT2_BAD_INO)
929 ext2fs_mark_inode_bitmap2(ctx->inode_used_map,
930 ino);
931 continue;
932 }
933 }
934
935 /*
936 * For big-endian machines:
937 * If the inode didn't have the extents flag set when it
938 * was read, then the i_blocks array was swapped. To test
939 * as an extents header, we must swap it back first.
940 * IF we then set the extents flag, the entire i_block
941 * array must be un/re-swapped to make it proper extents data.
942 */
943 if (extent_fs && !(inode->i_flags & EXT4_EXTENTS_FL) &&
944 (inode->i_links_count || (ino == EXT2_BAD_INO) ||
945 (ino == EXT2_ROOT_INO) || (ino == EXT2_JOURNAL_INO)) &&
946 (LINUX_S_ISREG(inode->i_mode) ||
947 LINUX_S_ISDIR(inode->i_mode))) {
948 void *ehp;
949 #ifdef WORDS_BIGENDIAN
950 __u32 tmp_block[EXT2_N_BLOCKS];
951
952 for (i = 0; i < EXT2_N_BLOCKS; i++)
953 tmp_block[i] = ext2fs_swab32(inode->i_block[i]);
954 ehp = tmp_block;
955 #else
956 ehp = inode->i_block;
957 #endif
958 if ((ext2fs_extent_header_verify(ehp,
959 sizeof(inode->i_block)) == 0) &&
960 (fix_problem(ctx, PR_1_UNSET_EXTENT_FL, &pctx))) {
961 inode->i_flags |= EXT4_EXTENTS_FL;
962 #ifdef WORDS_BIGENDIAN
963 memcpy(inode->i_block, tmp_block,
964 sizeof(inode->i_block));
965 #endif
966 e2fsck_write_inode(ctx, ino, inode, "pass1");
967 }
968 }
969
970 if (ino == EXT2_BAD_INO) {
971 struct process_block_struct pb;
972
973 if ((failed_csum || inode->i_mode || inode->i_uid ||
974 inode->i_gid || inode->i_links_count ||
975 (inode->i_flags & EXT4_INLINE_DATA_FL) ||
976 inode->i_file_acl) &&
977 fix_problem(ctx, PR_1_INVALID_BAD_INODE, &pctx)) {
978 memset(inode, 0, sizeof(struct ext2_inode));
979 e2fsck_write_inode(ctx, ino, inode,
980 "clear bad inode");
981 }
982
983 pctx.errcode = ext2fs_copy_bitmap(ctx->block_found_map,
984 &pb.fs_meta_blocks);
985 if (pctx.errcode) {
986 pctx.num = 4;
987 fix_problem(ctx, PR_1_ALLOCATE_BBITMAP_ERROR, &pctx);
988 ctx->flags |= E2F_FLAG_ABORT;
989 goto endit;
990 }
991 pb.ino = EXT2_BAD_INO;
992 pb.num_blocks = pb.last_block = 0;
993 pb.last_db_block = -1;
994 pb.num_illegal_blocks = 0;
995 pb.suppress = 0; pb.clear = 0; pb.is_dir = 0;
996 pb.is_reg = 0; pb.fragmented = 0; pb.bbcheck = 0;
997 pb.inode = inode;
998 pb.pctx = &pctx;
999 pb.ctx = ctx;
1000 pctx.errcode = ext2fs_block_iterate3(fs, ino, 0,
1001 block_buf, process_bad_block, &pb);
1002 ext2fs_free_block_bitmap(pb.fs_meta_blocks);
1003 if (pctx.errcode) {
1004 fix_problem(ctx, PR_1_BLOCK_ITERATE, &pctx);
1005 ctx->flags |= E2F_FLAG_ABORT;
1006 goto endit;
1007 }
1008 if (pb.bbcheck)
1009 if (!fix_problem(ctx, PR_1_BBINODE_BAD_METABLOCK_PROMPT, &pctx)) {
1010 ctx->flags |= E2F_FLAG_ABORT;
1011 goto endit;
1012 }
1013 ext2fs_mark_inode_bitmap2(ctx->inode_used_map, ino);
1014 clear_problem_context(&pctx);
1015 continue;
1016 } else if (ino == EXT2_ROOT_INO) {
1017 /*
1018 * Make sure the root inode is a directory; if
1019 * not, offer to clear it. It will be
1020 * regnerated in pass #3.
1021 */
1022 if (!LINUX_S_ISDIR(inode->i_mode)) {
1023 if (fix_problem(ctx, PR_1_ROOT_NO_DIR, &pctx))
1024 goto clear_inode;
1025 }
1026 /*
1027 * If dtime is set, offer to clear it. mke2fs
1028 * version 0.2b created filesystems with the
1029 * dtime field set for the root and lost+found
1030 * directories. We won't worry about
1031 * /lost+found, since that can be regenerated
1032 * easily. But we will fix the root directory
1033 * as a special case.
1034 */
1035 if (inode->i_dtime && inode->i_links_count) {
1036 if (fix_problem(ctx, PR_1_ROOT_DTIME, &pctx)) {
1037 inode->i_dtime = 0;
1038 e2fsck_write_inode(ctx, ino, inode,
1039 "pass1");
1040 }
1041 }
1042 } else if (ino == EXT2_JOURNAL_INO) {
1043 ext2fs_mark_inode_bitmap2(ctx->inode_used_map, ino);
1044 if (fs->super->s_journal_inum == EXT2_JOURNAL_INO) {
1045 if (!LINUX_S_ISREG(inode->i_mode) &&
1046 fix_problem(ctx, PR_1_JOURNAL_BAD_MODE,
1047 &pctx)) {
1048 inode->i_mode = LINUX_S_IFREG;
1049 e2fsck_write_inode(ctx, ino, inode,
1050 "pass1");
1051 }
1052 check_blocks(ctx, &pctx, block_buf);
1053 continue;
1054 }
1055 if ((inode->i_links_count ||
1056 inode->i_blocks || inode->i_block[0]) &&
1057 fix_problem(ctx, PR_1_JOURNAL_INODE_NOT_CLEAR,
1058 &pctx)) {
1059 memset(inode, 0, inode_size);
1060 ext2fs_icount_store(ctx->inode_link_info,
1061 ino, 0);
1062 e2fsck_write_inode_full(ctx, ino, inode,
1063 inode_size, "pass1");
1064 }
1065 } else if ((ino == EXT4_USR_QUOTA_INO) ||
1066 (ino == EXT4_GRP_QUOTA_INO)) {
1067 ext2fs_mark_inode_bitmap2(ctx->inode_used_map, ino);
1068 if ((fs->super->s_feature_ro_compat &
1069 EXT4_FEATURE_RO_COMPAT_QUOTA) &&
1070 ((fs->super->s_usr_quota_inum == ino) ||
1071 (fs->super->s_grp_quota_inum == ino))) {
1072 if (!LINUX_S_ISREG(inode->i_mode) &&
1073 fix_problem(ctx, PR_1_QUOTA_BAD_MODE,
1074 &pctx)) {
1075 inode->i_mode = LINUX_S_IFREG;
1076 e2fsck_write_inode(ctx, ino, inode,
1077 "pass1");
1078 }
1079 check_blocks(ctx, &pctx, block_buf);
1080 continue;
1081 }
1082 if ((inode->i_links_count ||
1083 inode->i_blocks || inode->i_block[0]) &&
1084 fix_problem(ctx, PR_1_QUOTA_INODE_NOT_CLEAR,
1085 &pctx)) {
1086 memset(inode, 0, inode_size);
1087 ext2fs_icount_store(ctx->inode_link_info,
1088 ino, 0);
1089 e2fsck_write_inode_full(ctx, ino, inode,
1090 inode_size, "pass1");
1091 }
1092 } else if (ino < EXT2_FIRST_INODE(fs->super)) {
1093 problem_t problem = 0;
1094
1095 ext2fs_mark_inode_bitmap2(ctx->inode_used_map, ino);
1096 if (ino == EXT2_BOOT_LOADER_INO) {
1097 if (LINUX_S_ISDIR(inode->i_mode))
1098 problem = PR_1_RESERVED_BAD_MODE;
1099 } else if (ino == EXT2_RESIZE_INO) {
1100 if (inode->i_mode &&
1101 !LINUX_S_ISREG(inode->i_mode))
1102 problem = PR_1_RESERVED_BAD_MODE;
1103 } else {
1104 if (inode->i_mode != 0)
1105 problem = PR_1_RESERVED_BAD_MODE;
1106 }
1107 if (problem) {
1108 if (fix_problem(ctx, problem, &pctx)) {
1109 inode->i_mode = 0;
1110 e2fsck_write_inode(ctx, ino, inode,
1111 "pass1");
1112 }
1113 }
1114 check_blocks(ctx, &pctx, block_buf);
1115 continue;
1116 }
1117
1118 /*
1119 * Check for inodes who might have been part of the
1120 * orphaned list linked list. They should have gotten
1121 * dealt with by now, unless the list had somehow been
1122 * corrupted.
1123 *
1124 * FIXME: In the future, inodes which are still in use
1125 * (and which are therefore) pending truncation should
1126 * be handled specially. Right now we just clear the
1127 * dtime field, and the normal e2fsck handling of
1128 * inodes where i_size and the inode blocks are
1129 * inconsistent is to fix i_size, instead of releasing
1130 * the extra blocks. This won't catch the inodes that
1131 * was at the end of the orphan list, but it's better
1132 * than nothing. The right answer is that there
1133 * shouldn't be any bugs in the orphan list handling. :-)
1134 */
1135 if (inode->i_dtime && low_dtime_check &&
1136 inode->i_dtime < ctx->fs->super->s_inodes_count) {
1137 if (fix_problem(ctx, PR_1_LOW_DTIME, &pctx)) {
1138 inode->i_dtime = inode->i_links_count ?
1139 0 : ctx->now;
1140 e2fsck_write_inode(ctx, ino, inode,
1141 "pass1");
1142 }
1143 }
1144
1145 /*
1146 * This code assumes that deleted inodes have
1147 * i_links_count set to 0.
1148 */
1149 if (!inode->i_links_count) {
1150 if (!inode->i_dtime && inode->i_mode) {
1151 if (fix_problem(ctx,
1152 PR_1_ZERO_DTIME, &pctx)) {
1153 inode->i_dtime = ctx->now;
1154 e2fsck_write_inode(ctx, ino, inode,
1155 "pass1");
1156 }
1157 }
1158 continue;
1159 }
1160 /*
1161 * n.b. 0.3c ext2fs code didn't clear i_links_count for
1162 * deleted files. Oops.
1163 *
1164 * Since all new ext2 implementations get this right,
1165 * we now assume that the case of non-zero
1166 * i_links_count and non-zero dtime means that we
1167 * should keep the file, not delete it.
1168 *
1169 */
1170 if (inode->i_dtime) {
1171 if (fix_problem(ctx, PR_1_SET_DTIME, &pctx)) {
1172 inode->i_dtime = 0;
1173 e2fsck_write_inode(ctx, ino, inode, "pass1");
1174 }
1175 }
1176
1177 ext2fs_mark_inode_bitmap2(ctx->inode_used_map, ino);
1178 switch (fs->super->s_creator_os) {
1179 case EXT2_OS_HURD:
1180 frag = inode->osd2.hurd2.h_i_frag;
1181 fsize = inode->osd2.hurd2.h_i_fsize;
1182 break;
1183 default:
1184 frag = fsize = 0;
1185 }
1186
1187 if (inode->i_faddr || frag || fsize ||
1188 (LINUX_S_ISDIR(inode->i_mode) && inode->i_dir_acl))
1189 mark_inode_bad(ctx, ino);
1190 if (!(fs->super->s_feature_incompat &
1191 EXT4_FEATURE_INCOMPAT_64BIT) &&
1192 inode->osd2.linux2.l_i_file_acl_high != 0)
1193 mark_inode_bad(ctx, ino);
1194 if ((fs->super->s_creator_os == EXT2_OS_LINUX) &&
1195 !(fs->super->s_feature_ro_compat &
1196 EXT4_FEATURE_RO_COMPAT_HUGE_FILE) &&
1197 (inode->osd2.linux2.l_i_blocks_hi != 0))
1198 mark_inode_bad(ctx, ino);
1199 if (inode->i_flags & EXT2_IMAGIC_FL) {
1200 if (imagic_fs) {
1201 if (!ctx->inode_imagic_map)
1202 alloc_imagic_map(ctx);
1203 ext2fs_mark_inode_bitmap2(ctx->inode_imagic_map,
1204 ino);
1205 } else {
1206 if (fix_problem(ctx, PR_1_SET_IMAGIC, &pctx)) {
1207 inode->i_flags &= ~EXT2_IMAGIC_FL;
1208 e2fsck_write_inode(ctx, ino,
1209 inode, "pass1");
1210 }
1211 }
1212 }
1213
1214 check_inode_extra_space(ctx, &pctx);
1215 check_is_really_dir(ctx, &pctx, block_buf);
1216
1217 /*
1218 * ext2fs_inode_has_valid_blocks2 does not actually look
1219 * at i_block[] values, so not endian-sensitive here.
1220 */
1221 if (extent_fs && (inode->i_flags & EXT4_EXTENTS_FL) &&
1222 LINUX_S_ISLNK(inode->i_mode) &&
1223 !ext2fs_inode_has_valid_blocks2(fs, inode) &&
1224 fix_problem(ctx, PR_1_FAST_SYMLINK_EXTENT_FL, &pctx)) {
1225 inode->i_flags &= ~EXT4_EXTENTS_FL;
1226 e2fsck_write_inode(ctx, ino, inode, "pass1");
1227 }
1228
1229 if (LINUX_S_ISDIR(inode->i_mode)) {
1230 ext2fs_mark_inode_bitmap2(ctx->inode_dir_map, ino);
1231 e2fsck_add_dir_info(ctx, ino, 0);
1232 ctx->fs_directory_count++;
1233 } else if (LINUX_S_ISREG (inode->i_mode)) {
1234 ext2fs_mark_inode_bitmap2(ctx->inode_reg_map, ino);
1235 ctx->fs_regular_count++;
1236 } else if (LINUX_S_ISCHR (inode->i_mode) &&
1237 e2fsck_pass1_check_device_inode(fs, inode)) {
1238 check_immutable(ctx, &pctx);
1239 check_size(ctx, &pctx);
1240 ctx->fs_chardev_count++;
1241 } else if (LINUX_S_ISBLK (inode->i_mode) &&
1242 e2fsck_pass1_check_device_inode(fs, inode)) {
1243 check_immutable(ctx, &pctx);
1244 check_size(ctx, &pctx);
1245 ctx->fs_blockdev_count++;
1246 } else if (LINUX_S_ISLNK (inode->i_mode) &&
1247 e2fsck_pass1_check_symlink(fs, ino, inode,
1248 block_buf)) {
1249 check_immutable(ctx, &pctx);
1250 ctx->fs_symlinks_count++;
1251 if (inode->i_flags & EXT4_INLINE_DATA_FL) {
1252 continue;
1253 } else if (ext2fs_inode_data_blocks(fs, inode) == 0) {
1254 ctx->fs_fast_symlinks_count++;
1255 check_blocks(ctx, &pctx, block_buf);
1256 continue;
1257 }
1258 }
1259 else if (LINUX_S_ISFIFO (inode->i_mode) &&
1260 e2fsck_pass1_check_device_inode(fs, inode)) {
1261 check_immutable(ctx, &pctx);
1262 check_size(ctx, &pctx);
1263 ctx->fs_fifo_count++;
1264 } else if ((LINUX_S_ISSOCK (inode->i_mode)) &&
1265 e2fsck_pass1_check_device_inode(fs, inode)) {
1266 check_immutable(ctx, &pctx);
1267 check_size(ctx, &pctx);
1268 ctx->fs_sockets_count++;
1269 } else
1270 mark_inode_bad(ctx, ino);
1271 if (!(inode->i_flags & EXT4_EXTENTS_FL) &&
1272 !(inode->i_flags & EXT4_INLINE_DATA_FL)) {
1273 if (inode->i_block[EXT2_IND_BLOCK])
1274 ctx->fs_ind_count++;
1275 if (inode->i_block[EXT2_DIND_BLOCK])
1276 ctx->fs_dind_count++;
1277 if (inode->i_block[EXT2_TIND_BLOCK])
1278 ctx->fs_tind_count++;
1279 }
1280 if (!(inode->i_flags & EXT4_EXTENTS_FL) &&
1281 !(inode->i_flags & EXT4_INLINE_DATA_FL) &&
1282 (inode->i_block[EXT2_IND_BLOCK] ||
1283 inode->i_block[EXT2_DIND_BLOCK] ||
1284 inode->i_block[EXT2_TIND_BLOCK] ||
1285 ext2fs_file_acl_block(fs, inode))) {
1286 inodes_to_process[process_inode_count].ino = ino;
1287 inodes_to_process[process_inode_count].inode = *inode;
1288 process_inode_count++;
1289 } else
1290 check_blocks(ctx, &pctx, block_buf);
1291
1292 /*
1293 * If the inode failed the checksum and the user didn't
1294 * clear the inode, test the checksum again -- if it still
1295 * fails, ask the user if the checksum should be corrected.
1296 */
1297 if (failed_csum) {
1298 pctx.errcode = recheck_bad_inode_checksum(fs, ino, ctx,
1299 &pctx);
1300 if (pctx.errcode) {
1301 ctx->flags |= E2F_FLAG_ABORT;
1302 return;
1303 }
1304 }
1305
1306 if (ctx->flags & E2F_FLAG_SIGNAL_MASK)
1307 goto endit;
1308
1309 if (process_inode_count >= ctx->process_inode_size) {
1310 process_inodes(ctx, block_buf);
1311
1312 if (ctx->flags & E2F_FLAG_SIGNAL_MASK)
1313 goto endit;
1314 }
1315 }
1316 process_inodes(ctx, block_buf);
1317 ext2fs_close_inode_scan(scan);
1318 scan = NULL;
1319
1320 reserve_block_for_root_repair(ctx);
1321 reserve_block_for_lnf_repair(ctx);
1322
1323 /*
1324 * If any extended attribute blocks' reference counts need to
1325 * be adjusted, either up (ctx->refcount_extra), or down
1326 * (ctx->refcount), then fix them.
1327 */
1328 if (ctx->refcount) {
1329 adjust_extattr_refcount(ctx, ctx->refcount, block_buf, -1);
1330 ea_refcount_free(ctx->refcount);
1331 ctx->refcount = 0;
1332 }
1333 if (ctx->refcount_extra) {
1334 adjust_extattr_refcount(ctx, ctx->refcount_extra,
1335 block_buf, +1);
1336 ea_refcount_free(ctx->refcount_extra);
1337 ctx->refcount_extra = 0;
1338 }
1339
1340 if (ctx->invalid_bitmaps)
1341 handle_fs_bad_blocks(ctx);
1342
1343 /* We don't need the block_ea_map any more */
1344 if (ctx->block_ea_map) {
1345 ext2fs_free_block_bitmap(ctx->block_ea_map);
1346 ctx->block_ea_map = 0;
1347 }
1348
1349 if (ctx->flags & E2F_FLAG_RESIZE_INODE) {
1350 clear_problem_context(&pctx);
1351 pctx.errcode = ext2fs_create_resize_inode(fs);
1352 if (pctx.errcode) {
1353 if (!fix_problem(ctx, PR_1_RESIZE_INODE_CREATE,
1354 &pctx)) {
1355 ctx->flags |= E2F_FLAG_ABORT;
1356 goto endit;
1357 }
1358 pctx.errcode = 0;
1359 }
1360 if (!pctx.errcode) {
1361 e2fsck_read_inode(ctx, EXT2_RESIZE_INO, inode,
1362 "recreate inode");
1363 inode->i_mtime = ctx->now;
1364 e2fsck_write_inode(ctx, EXT2_RESIZE_INO, inode,
1365 "recreate inode");
1366 }
1367 ctx->flags &= ~E2F_FLAG_RESIZE_INODE;
1368 }
1369
1370 if (ctx->flags & E2F_FLAG_RESTART) {
1371 /*
1372 * Only the master copy of the superblock and block
1373 * group descriptors are going to be written during a
1374 * restart, so set the superblock to be used to be the
1375 * master superblock.
1376 */
1377 ctx->use_superblock = 0;
1378 unwind_pass1(fs);
1379 goto endit;
1380 }
1381
1382 if (ctx->block_dup_map) {
1383 if (ctx->options & E2F_OPT_PREEN) {
1384 clear_problem_context(&pctx);
1385 fix_problem(ctx, PR_1_DUP_BLOCKS_PREENSTOP, &pctx);
1386 }
1387 e2fsck_pass1_dupblocks(ctx, block_buf);
1388 }
1389 ext2fs_free_mem(&inodes_to_process);
1390 endit:
1391 e2fsck_use_inode_shortcuts(ctx, 0);
1392
1393 if (scan)
1394 ext2fs_close_inode_scan(scan);
1395 if (block_buf)
1396 ext2fs_free_mem(&block_buf);
1397 if (inode)
1398 ext2fs_free_mem(&inode);
1399
1400 /*
1401 * The l+f inode may have been cleared, so zap it now and
1402 * later passes will recalculate it if necessary
1403 */
1404 ctx->lost_and_found = 0;
1405
1406 if ((ctx->flags & E2F_FLAG_SIGNAL_MASK) == 0)
1407 print_resource_track(ctx, _("Pass 1"), &rtrack, ctx->fs->io);
1408 }
1409
1410 /*
1411 * When the inode_scan routines call this callback at the end of the
1412 * glock group, call process_inodes.
1413 */
1414 static errcode_t scan_callback(ext2_filsys fs,
1415 ext2_inode_scan scan EXT2FS_ATTR((unused)),
1416 dgrp_t group, void * priv_data)
1417 {
1418 struct scan_callback_struct *scan_struct;
1419 e2fsck_t ctx;
1420
1421 scan_struct = (struct scan_callback_struct *) priv_data;
1422 ctx = scan_struct->ctx;
1423
1424 process_inodes((e2fsck_t) fs->priv_data, scan_struct->block_buf);
1425
1426 if (ctx->progress)
1427 if ((ctx->progress)(ctx, 1, group+1,
1428 ctx->fs->group_desc_count))
1429 return EXT2_ET_CANCEL_REQUESTED;
1430
1431 return 0;
1432 }
1433
1434 /*
1435 * Process the inodes in the "inodes to process" list.
1436 */
1437 static void process_inodes(e2fsck_t ctx, char *block_buf)
1438 {
1439 int i;
1440 struct ext2_inode *old_stashed_inode;
1441 ext2_ino_t old_stashed_ino;
1442 const char *old_operation;
1443 char buf[80];
1444 struct problem_context pctx;
1445
1446 #if 0
1447 printf("begin process_inodes: ");
1448 #endif
1449 if (process_inode_count == 0)
1450 return;
1451 old_operation = ehandler_operation(0);
1452 old_stashed_inode = ctx->stashed_inode;
1453 old_stashed_ino = ctx->stashed_ino;
1454 qsort(inodes_to_process, process_inode_count,
1455 sizeof(struct process_inode_block), process_inode_cmp);
1456 clear_problem_context(&pctx);
1457 for (i=0; i < process_inode_count; i++) {
1458 pctx.inode = ctx->stashed_inode = &inodes_to_process[i].inode;
1459 pctx.ino = ctx->stashed_ino = inodes_to_process[i].ino;
1460
1461 #if 0
1462 printf("%u ", pctx.ino);
1463 #endif
1464 sprintf(buf, _("reading indirect blocks of inode %u"),
1465 pctx.ino);
1466 ehandler_operation(buf);
1467 check_blocks(ctx, &pctx, block_buf);
1468 if (ctx->flags & E2F_FLAG_SIGNAL_MASK)
1469 break;
1470 }
1471 ctx->stashed_inode = old_stashed_inode;
1472 ctx->stashed_ino = old_stashed_ino;
1473 process_inode_count = 0;
1474 #if 0
1475 printf("end process inodes\n");
1476 #endif
1477 ehandler_operation(old_operation);
1478 }
1479
1480 static EXT2_QSORT_TYPE process_inode_cmp(const void *a, const void *b)
1481 {
1482 const struct process_inode_block *ib_a =
1483 (const struct process_inode_block *) a;
1484 const struct process_inode_block *ib_b =
1485 (const struct process_inode_block *) b;
1486 int ret;
1487
1488 ret = (ib_a->inode.i_block[EXT2_IND_BLOCK] -
1489 ib_b->inode.i_block[EXT2_IND_BLOCK]);
1490 if (ret == 0)
1491 /*
1492 * We only call process_inodes() for non-extent
1493 * inodes, so it's OK to pass NULL to
1494 * ext2fs_file_acl_block() here.
1495 */
1496 ret = ext2fs_file_acl_block(0, &(ib_a->inode)) -
1497 ext2fs_file_acl_block(0, &(ib_b->inode));
1498 if (ret == 0)
1499 ret = ib_a->ino - ib_b->ino;
1500 return ret;
1501 }
1502
1503 /*
1504 * Mark an inode as being bad in some what
1505 */
1506 static void mark_inode_bad(e2fsck_t ctx, ino_t ino)
1507 {
1508 struct problem_context pctx;
1509
1510 if (!ctx->inode_bad_map) {
1511 clear_problem_context(&pctx);
1512
1513 pctx.errcode = e2fsck_allocate_inode_bitmap(ctx->fs,
1514 _("bad inode map"), EXT2FS_BMAP64_RBTREE,
1515 "inode_bad_map", &ctx->inode_bad_map);
1516 if (pctx.errcode) {
1517 pctx.num = 3;
1518 fix_problem(ctx, PR_1_ALLOCATE_IBITMAP_ERROR, &pctx);
1519 /* Should never get here */
1520 ctx->flags |= E2F_FLAG_ABORT;
1521 return;
1522 }
1523 }
1524 ext2fs_mark_inode_bitmap2(ctx->inode_bad_map, ino);
1525 }
1526
1527
1528 /*
1529 * This procedure will allocate the inode "bb" (badblock) map table
1530 */
1531 static void alloc_bb_map(e2fsck_t ctx)
1532 {
1533 struct problem_context pctx;
1534
1535 clear_problem_context(&pctx);
1536 pctx.errcode = e2fsck_allocate_inode_bitmap(ctx->fs,
1537 _("inode in bad block map"), EXT2FS_BMAP64_RBTREE,
1538 "inode_bb_map", &ctx->inode_bb_map);
1539 if (pctx.errcode) {
1540 pctx.num = 4;
1541 fix_problem(ctx, PR_1_ALLOCATE_IBITMAP_ERROR, &pctx);
1542 /* Should never get here */
1543 ctx->flags |= E2F_FLAG_ABORT;
1544 return;
1545 }
1546 }
1547
1548 /*
1549 * This procedure will allocate the inode imagic table
1550 */
1551 static void alloc_imagic_map(e2fsck_t ctx)
1552 {
1553 struct problem_context pctx;
1554
1555 clear_problem_context(&pctx);
1556 pctx.errcode = e2fsck_allocate_inode_bitmap(ctx->fs,
1557 _("imagic inode map"), EXT2FS_BMAP64_RBTREE,
1558 "inode_imagic_map", &ctx->inode_imagic_map);
1559 if (pctx.errcode) {
1560 pctx.num = 5;
1561 fix_problem(ctx, PR_1_ALLOCATE_IBITMAP_ERROR, &pctx);
1562 /* Should never get here */
1563 ctx->flags |= E2F_FLAG_ABORT;
1564 return;
1565 }
1566 }
1567
1568 /*
1569 * Marks a block as in use, setting the dup_map if it's been set
1570 * already. Called by process_block and process_bad_block.
1571 *
1572 * WARNING: Assumes checks have already been done to make sure block
1573 * is valid. This is true in both process_block and process_bad_block.
1574 */
1575 static _INLINE_ void mark_block_used(e2fsck_t ctx, blk64_t block)
1576 {
1577 struct problem_context pctx;
1578
1579 clear_problem_context(&pctx);
1580
1581 if (ext2fs_fast_test_block_bitmap2(ctx->block_found_map, block)) {
1582 if (!ctx->block_dup_map) {
1583 pctx.errcode = e2fsck_allocate_block_bitmap(ctx->fs,
1584 _("multiply claimed block map"),
1585 EXT2FS_BMAP64_RBTREE, "block_dup_map",
1586 &ctx->block_dup_map);
1587 if (pctx.errcode) {
1588 pctx.num = 3;
1589 fix_problem(ctx, PR_1_ALLOCATE_BBITMAP_ERROR,
1590 &pctx);
1591 /* Should never get here */
1592 ctx->flags |= E2F_FLAG_ABORT;
1593 return;
1594 }
1595 }
1596 ext2fs_fast_mark_block_bitmap2(ctx->block_dup_map, block);
1597 } else {
1598 ext2fs_fast_mark_block_bitmap2(ctx->block_found_map, block);
1599 }
1600 }
1601
1602 static _INLINE_ void mark_blocks_used(e2fsck_t ctx, blk64_t block,
1603 unsigned int num)
1604 {
1605 if (ext2fs_test_block_bitmap_range2(ctx->block_found_map, block, num))
1606 ext2fs_mark_block_bitmap_range2(ctx->block_found_map, block, num);
1607 else
1608 while (num--)
1609 mark_block_used(ctx, block++);
1610 }
1611
1612 /*
1613 * Adjust the extended attribute block's reference counts at the end
1614 * of pass 1, either by subtracting out references for EA blocks that
1615 * are still referenced in ctx->refcount, or by adding references for
1616 * EA blocks that had extra references as accounted for in
1617 * ctx->refcount_extra.
1618 */
1619 static void adjust_extattr_refcount(e2fsck_t ctx, ext2_refcount_t refcount,
1620 char *block_buf, int adjust_sign)
1621 {
1622 struct ext2_ext_attr_header *header;
1623 struct problem_context pctx;
1624 ext2_filsys fs = ctx->fs;
1625 blk64_t blk;
1626 __u32 should_be;
1627 int count;
1628
1629 clear_problem_context(&pctx);
1630
1631 ea_refcount_intr_begin(refcount);
1632 while (1) {
1633 if ((blk = ea_refcount_intr_next(refcount, &count)) == 0)
1634 break;
1635 pctx.blk = blk;
1636 pctx.errcode = ext2fs_read_ext_attr3(fs, blk, block_buf,
1637 pctx.ino);
1638 if (pctx.errcode) {
1639 fix_problem(ctx, PR_1_EXTATTR_READ_ABORT, &pctx);
1640 return;
1641 }
1642 header = (struct ext2_ext_attr_header *) block_buf;
1643 pctx.blkcount = header->h_refcount;
1644 should_be = header->h_refcount + adjust_sign * count;
1645 pctx.num = should_be;
1646 if (fix_problem(ctx, PR_1_EXTATTR_REFCOUNT, &pctx)) {
1647 header->h_refcount = should_be;
1648 pctx.errcode = ext2fs_write_ext_attr3(fs, blk,
1649 block_buf,
1650 pctx.ino);
1651 if (pctx.errcode) {
1652 fix_problem(ctx, PR_1_EXTATTR_WRITE_ABORT,
1653 &pctx);
1654 continue;
1655 }
1656 }
1657 }
1658 }
1659
1660 /*
1661 * Handle processing the extended attribute blocks
1662 */
1663 static int check_ext_attr(e2fsck_t ctx, struct problem_context *pctx,
1664 char *block_buf)
1665 {
1666 ext2_filsys fs = ctx->fs;
1667 ext2_ino_t ino = pctx->ino;
1668 struct ext2_inode *inode = pctx->inode;
1669 blk64_t blk;
1670 char * end;
1671 struct ext2_ext_attr_header *header;
1672 struct ext2_ext_attr_entry *entry;
1673 int count;
1674 region_t region = 0;
1675 int failed_csum = 0;
1676
1677 blk = ext2fs_file_acl_block(fs, inode);
1678 if (blk == 0)
1679 return 0;
1680
1681 /*
1682 * If the Extended attribute flag isn't set, then a non-zero
1683 * file acl means that the inode is corrupted.
1684 *
1685 * Or if the extended attribute block is an invalid block,
1686 * then the inode is also corrupted.
1687 */
1688 if (!(fs->super->s_feature_compat & EXT2_FEATURE_COMPAT_EXT_ATTR) ||
1689 (blk < fs->super->s_first_data_block) ||
1690 (blk >= ext2fs_blocks_count(fs->super))) {
1691 mark_inode_bad(ctx, ino);
1692 return 0;
1693 }
1694
1695 /* If ea bitmap hasn't been allocated, create it */
1696 if (!ctx->block_ea_map) {
1697 pctx->errcode = e2fsck_allocate_block_bitmap(fs,
1698 _("ext attr block map"),
1699 EXT2FS_BMAP64_RBTREE, "block_ea_map",
1700 &ctx->block_ea_map);
1701 if (pctx->errcode) {
1702 pctx->num = 2;
1703 fix_problem(ctx, PR_1_ALLOCATE_BBITMAP_ERROR, pctx);
1704 ctx->flags |= E2F_FLAG_ABORT;
1705 return 0;
1706 }
1707 }
1708
1709 /* Create the EA refcount structure if necessary */
1710 if (!ctx->refcount) {
1711 pctx->errcode = ea_refcount_create(0, &ctx->refcount);
1712 if (pctx->errcode) {
1713 pctx->num = 1;
1714 fix_problem(ctx, PR_1_ALLOCATE_REFCOUNT, pctx);
1715 ctx->flags |= E2F_FLAG_ABORT;
1716 return 0;
1717 }
1718 }
1719
1720 #if 0
1721 /* Debugging text */
1722 printf("Inode %u has EA block %u\n", ino, blk);
1723 #endif
1724
1725 /* Have we seen this EA block before? */
1726 if (ext2fs_fast_test_block_bitmap2(ctx->block_ea_map, blk)) {
1727 if (ea_refcount_decrement(ctx->refcount, blk, 0) == 0)
1728 return 1;
1729 /* Ooops, this EA was referenced more than it stated */
1730 if (!ctx->refcount_extra) {
1731 pctx->errcode = ea_refcount_create(0,
1732 &ctx->refcount_extra);
1733 if (pctx->errcode) {
1734 pctx->num = 2;
1735 fix_problem(ctx, PR_1_ALLOCATE_REFCOUNT, pctx);
1736 ctx->flags |= E2F_FLAG_ABORT;
1737 return 0;
1738 }
1739 }
1740 ea_refcount_increment(ctx->refcount_extra, blk, 0);
1741 return 1;
1742 }
1743
1744 /*
1745 * OK, we haven't seen this EA block yet. So we need to
1746 * validate it
1747 */
1748 pctx->blk = blk;
1749 pctx->errcode = ext2fs_read_ext_attr3(fs, blk, block_buf, pctx->ino);
1750 if (pctx->errcode == EXT2_ET_EXT_ATTR_CSUM_INVALID) {
1751 pctx->errcode = 0;
1752 failed_csum = 1;
1753 } else if (pctx->errcode == EXT2_ET_BAD_EA_HEADER)
1754 pctx->errcode = 0;
1755
1756 if (pctx->errcode &&
1757 fix_problem(ctx, PR_1_READ_EA_BLOCK, pctx)) {
1758 pctx->errcode = 0;
1759 goto clear_extattr;
1760 }
1761 header = (struct ext2_ext_attr_header *) block_buf;
1762 pctx->blk = ext2fs_file_acl_block(fs, inode);
1763 if (((ctx->ext_attr_ver == 1) &&
1764 (header->h_magic != EXT2_EXT_ATTR_MAGIC_v1)) ||
1765 ((ctx->ext_attr_ver == 2) &&
1766 (header->h_magic != EXT2_EXT_ATTR_MAGIC))) {
1767 if (fix_problem(ctx, PR_1_BAD_EA_BLOCK, pctx))
1768 goto clear_extattr;
1769 }
1770
1771 if (header->h_blocks != 1) {
1772 if (fix_problem(ctx, PR_1_EA_MULTI_BLOCK, pctx))
1773 goto clear_extattr;
1774 }
1775
1776 if (pctx->errcode && fix_problem(ctx, PR_1_READ_EA_BLOCK, pctx))
1777 goto clear_extattr;
1778
1779 region = region_create(0, fs->blocksize);
1780 if (!region) {
1781 fix_problem(ctx, PR_1_EA_ALLOC_REGION_ABORT, pctx);
1782 ctx->flags |= E2F_FLAG_ABORT;
1783 return 0;
1784 }
1785 if (region_allocate(region, 0, sizeof(struct ext2_ext_attr_header))) {
1786 if (fix_problem(ctx, PR_1_EA_ALLOC_COLLISION, pctx))
1787 goto clear_extattr;
1788 }
1789
1790 entry = (struct ext2_ext_attr_entry *)(header+1);
1791 end = block_buf + fs->blocksize;
1792 while ((char *)entry < end && *(__u32 *)entry) {
1793 __u32 hash;
1794
1795 if (region_allocate(region, (char *)entry - (char *)header,
1796 EXT2_EXT_ATTR_LEN(entry->e_name_len))) {
1797 if (fix_problem(ctx, PR_1_EA_ALLOC_COLLISION, pctx))
1798 goto clear_extattr;
1799 break;
1800 }
1801 if ((ctx->ext_attr_ver == 1 &&
1802 (entry->e_name_len == 0 || entry->e_name_index != 0)) ||
1803 (ctx->ext_attr_ver == 2 &&
1804 entry->e_name_index == 0)) {
1805 if (fix_problem(ctx, PR_1_EA_BAD_NAME, pctx))
1806 goto clear_extattr;
1807 break;
1808 }
1809 if (entry->e_value_block != 0) {
1810 if (fix_problem(ctx, PR_1_EA_BAD_VALUE, pctx))
1811 goto clear_extattr;
1812 }
1813 if (entry->e_value_offs + entry->e_value_size > fs->blocksize) {
1814 if (fix_problem(ctx, PR_1_EA_BAD_VALUE, pctx))
1815 goto clear_extattr;
1816 break;
1817 }
1818 if (entry->e_value_size &&
1819 region_allocate(region, entry->e_value_offs,
1820 EXT2_EXT_ATTR_SIZE(entry->e_value_size))) {
1821 if (fix_problem(ctx, PR_1_EA_ALLOC_COLLISION, pctx))
1822 goto clear_extattr;
1823 }
1824
1825 hash = ext2fs_ext_attr_hash_entry(entry, block_buf +
1826 entry->e_value_offs);
1827
1828 if (entry->e_hash != hash) {
1829 pctx->num = entry->e_hash;
1830 if (fix_problem(ctx, PR_1_ATTR_HASH, pctx))
1831 goto clear_extattr;
1832 entry->e_hash = hash;
1833 }
1834
1835 entry = EXT2_EXT_ATTR_NEXT(entry);
1836 }
1837 if (region_allocate(region, (char *)entry - (char *)header, 4)) {
1838 if (fix_problem(ctx, PR_1_EA_ALLOC_COLLISION, pctx))
1839 goto clear_extattr;
1840 }
1841 region_free(region);
1842
1843 /*
1844 * We only get here if there was no other errors that were fixed.
1845 * If there was a checksum fail, ask to correct it.
1846 */
1847 if (failed_csum &&
1848 fix_problem(ctx, PR_1_EA_BLOCK_ONLY_CSUM_INVALID, pctx)) {
1849 pctx->errcode = ext2fs_write_ext_attr3(fs, blk, block_buf,
1850 pctx->ino);
1851 if (pctx->errcode)
1852 return 0;
1853 }
1854
1855 count = header->h_refcount - 1;
1856 if (count)
1857 ea_refcount_store(ctx->refcount, blk, count);
1858 mark_block_used(ctx, blk);
1859 ext2fs_fast_mark_block_bitmap2(ctx->block_ea_map, blk);
1860 return 1;
1861
1862 clear_extattr:
1863 if (region)
1864 region_free(region);
1865 ext2fs_file_acl_block_set(fs, inode, 0);
1866 e2fsck_write_inode(ctx, ino, inode, "check_ext_attr");
1867 return 0;
1868 }
1869
1870 /* Returns 1 if bad htree, 0 if OK */
1871 static int handle_htree(e2fsck_t ctx, struct problem_context *pctx,
1872 ext2_ino_t ino, struct ext2_inode *inode,
1873 char *block_buf)
1874 {
1875 struct ext2_dx_root_info *root;
1876 ext2_filsys fs = ctx->fs;
1877 errcode_t retval;
1878 blk64_t blk;
1879
1880 if ((!LINUX_S_ISDIR(inode->i_mode) &&
1881 fix_problem(ctx, PR_1_HTREE_NODIR, pctx)) ||
1882 (!(fs->super->s_feature_compat & EXT2_FEATURE_COMPAT_DIR_INDEX) &&
1883 fix_problem(ctx, PR_1_HTREE_SET, pctx)))
1884 return 1;
1885
1886 pctx->errcode = ext2fs_bmap2(fs, ino, inode, 0, 0, 0, 0, &blk);
1887
1888 if ((pctx->errcode) ||
1889 (blk == 0) ||
1890 (blk < fs->super->s_first_data_block) ||
1891 (blk >= ext2fs_blocks_count(fs->super))) {
1892 if (fix_problem(ctx, PR_1_HTREE_BADROOT, pctx))
1893 return 1;
1894 else
1895 return 0;
1896 }
1897
1898 retval = io_channel_read_blk64(fs->io, blk, 1, block_buf);
1899 if (retval && fix_problem(ctx, PR_1_HTREE_BADROOT, pctx))
1900 return 1;
1901
1902 /* XXX should check that beginning matches a directory */
1903 root = (struct ext2_dx_root_info *) (block_buf + 24);
1904
1905 if ((root->reserved_zero || root->info_length < 8) &&
1906 fix_problem(ctx, PR_1_HTREE_BADROOT, pctx))
1907 return 1;
1908
1909 pctx->num = root->hash_version;
1910 if ((root->hash_version != EXT2_HASH_LEGACY) &&
1911 (root->hash_version != EXT2_HASH_HALF_MD4) &&
1912 (root->hash_version != EXT2_HASH_TEA) &&
1913 fix_problem(ctx, PR_1_HTREE_HASHV, pctx))
1914 return 1;
1915
1916 if ((root->unused_flags & EXT2_HASH_FLAG_INCOMPAT) &&
1917 fix_problem(ctx, PR_1_HTREE_INCOMPAT, pctx))
1918 return 1;
1919
1920 pctx->num = root->indirect_levels;
1921 if ((root->indirect_levels > 1) &&
1922 fix_problem(ctx, PR_1_HTREE_DEPTH, pctx))
1923 return 1;
1924
1925 return 0;
1926 }
1927
1928 void e2fsck_clear_inode(e2fsck_t ctx, ext2_ino_t ino,
1929 struct ext2_inode *inode, int restart_flag,
1930 const char *source)
1931 {
1932 inode->i_flags = 0;
1933 inode->i_links_count = 0;
1934 ext2fs_icount_store(ctx->inode_link_info, ino, 0);
1935 inode->i_dtime = ctx->now;
1936
1937 ext2fs_unmark_inode_bitmap2(ctx->inode_dir_map, ino);
1938 ext2fs_unmark_inode_bitmap2(ctx->inode_used_map, ino);
1939 if (ctx->inode_reg_map)
1940 ext2fs_unmark_inode_bitmap2(ctx->inode_reg_map, ino);
1941 if (ctx->inode_bad_map)
1942 ext2fs_unmark_inode_bitmap2(ctx->inode_bad_map, ino);
1943
1944 /*
1945 * If the inode was partially accounted for before processing
1946 * was aborted, we need to restart the pass 1 scan.
1947 */
1948 ctx->flags |= restart_flag;
1949
1950 if (ino == EXT2_BAD_INO)
1951 memset(inode, 0, sizeof(struct ext2_inode));
1952
1953 e2fsck_write_inode(ctx, ino, inode, source);
1954 }
1955
1956 /*
1957 * Use the multiple-blocks reclamation code to fix alignment problems in
1958 * a bigalloc filesystem. We want a logical cluster to map to *only* one
1959 * physical cluster, and we want the block offsets within that cluster to
1960 * line up.
1961 */
1962 static int has_unaligned_cluster_map(e2fsck_t ctx,
1963 blk64_t last_pblk, e2_blkcnt_t last_lblk,
1964 blk64_t pblk, blk64_t lblk)
1965 {
1966 blk64_t cluster_mask;
1967
1968 if (!ctx->fs->cluster_ratio_bits)
1969 return 0;
1970 cluster_mask = EXT2FS_CLUSTER_MASK(ctx->fs);
1971
1972 /*
1973 * If the block in the logical cluster doesn't align with the block in
1974 * the physical cluster...
1975 */
1976 if ((lblk & cluster_mask) != (pblk & cluster_mask))
1977 return 1;
1978
1979 /*
1980 * If we cross a physical cluster boundary within a logical cluster...
1981 */
1982 if (last_pblk && (lblk & cluster_mask) != 0 &&
1983 EXT2FS_B2C(ctx->fs, lblk) == EXT2FS_B2C(ctx->fs, last_lblk) &&
1984 EXT2FS_B2C(ctx->fs, pblk) != EXT2FS_B2C(ctx->fs, last_pblk))
1985 return 1;
1986
1987 return 0;
1988 }
1989
1990 static void scan_extent_node(e2fsck_t ctx, struct problem_context *pctx,
1991 struct process_block_struct *pb,
1992 blk64_t start_block, blk64_t end_block,
1993 blk64_t eof_block,
1994 ext2_extent_handle_t ehandle,
1995 int try_repairs)
1996 {
1997 struct ext2fs_extent extent;
1998 blk64_t blk, last_lblk;
1999 e2_blkcnt_t blockcnt;
2000 unsigned int i;
2001 int is_dir, is_leaf;
2002 problem_t problem;
2003 struct ext2_extent_info info;
2004 int failed_csum;
2005
2006 pctx->errcode = ext2fs_extent_get_info(ehandle, &info);
2007 if (pctx->errcode)
2008 return;
2009
2010 pctx->errcode = ext2fs_extent_get(ehandle, EXT2_EXTENT_FIRST_SIB,
2011 &extent);
2012 while ((pctx->errcode == 0 ||
2013 pctx->errcode == EXT2_ET_EXTENT_CSUM_INVALID) &&
2014 info.num_entries-- > 0) {
2015 failed_csum = 0;
2016 is_leaf = extent.e_flags & EXT2_EXTENT_FLAGS_LEAF;
2017 is_dir = LINUX_S_ISDIR(pctx->inode->i_mode);
2018 last_lblk = extent.e_lblk + extent.e_len - 1;
2019
2020 problem = 0;
2021 pctx->blk = extent.e_pblk;
2022 pctx->blk2 = extent.e_lblk;
2023 pctx->num = extent.e_len;
2024 pctx->blkcount = extent.e_lblk + extent.e_len;
2025
2026 /* Ask to clear a corrupt extent block */
2027 if (try_repairs &&
2028 pctx->errcode == EXT2_ET_EXTENT_CSUM_INVALID) {
2029 problem = PR_1_EXTENT_CSUM_INVALID;
2030 if (fix_problem(ctx, problem, pctx))
2031 goto fix_problem_now;
2032 failed_csum = 1;
2033 }
2034
2035 if (extent.e_pblk == 0 ||
2036 extent.e_pblk < ctx->fs->super->s_first_data_block ||
2037 extent.e_pblk >= ext2fs_blocks_count(ctx->fs->super))
2038 problem = PR_1_EXTENT_BAD_START_BLK;
2039 else if (extent.e_lblk < start_block)
2040 problem = PR_1_OUT_OF_ORDER_EXTENTS;
2041 else if ((end_block && last_lblk > end_block) &&
2042 (!(extent.e_flags & EXT2_EXTENT_FLAGS_UNINIT &&
2043 last_lblk > eof_block)))
2044 problem = PR_1_EXTENT_END_OUT_OF_BOUNDS;
2045 else if (is_leaf && extent.e_len == 0)
2046 problem = PR_1_EXTENT_LENGTH_ZERO;
2047 else if (is_leaf &&
2048 (extent.e_pblk + extent.e_len) >
2049 ext2fs_blocks_count(ctx->fs->super))
2050 problem = PR_1_EXTENT_ENDS_BEYOND;
2051 else if (is_leaf && is_dir &&
2052 ((extent.e_lblk + extent.e_len) >
2053 (1 << (21 - ctx->fs->super->s_log_block_size))))
2054 problem = PR_1_TOOBIG_DIR;
2055
2056 /*
2057 * Uninitialized blocks in a directory? Clear the flag and
2058 * we'll interpret the blocks later.
2059 */
2060 if (try_repairs && is_dir && problem == 0 &&
2061 (extent.e_flags & EXT2_EXTENT_FLAGS_UNINIT) &&
2062 fix_problem(ctx, PR_1_UNINIT_DBLOCK, pctx)) {
2063 extent.e_flags &= ~EXT2_EXTENT_FLAGS_UNINIT;
2064 pb->inode_modified = 1;
2065 pctx->errcode = ext2fs_extent_replace(ehandle, 0,
2066 &extent);
2067 if (pctx->errcode)
2068 return;
2069 failed_csum = 0;
2070 }
2071
2072 /* Failed csum but passes checks? Ask to fix checksum. */
2073 if (try_repairs && failed_csum && problem == 0 &&
2074 fix_problem(ctx, PR_1_EXTENT_ONLY_CSUM_INVALID, pctx)) {
2075 pb->inode_modified = 1;
2076 pctx->errcode = ext2fs_extent_replace(ehandle,
2077 0, &extent);
2078 if (pctx->errcode)
2079 return;
2080 }
2081
2082 if (try_repairs && problem) {
2083 report_problem:
2084 if (fix_problem(ctx, problem, pctx)) {
2085 fix_problem_now:
2086 if (ctx->invalid_bitmaps) {
2087 /*
2088 * If fsck knows the bitmaps are bad,
2089 * skip to the next extent and
2090 * try to clear this extent again
2091 * after fixing the bitmaps, by
2092 * restarting fsck.
2093 */
2094 pctx->errcode = ext2fs_extent_get(
2095 ehandle,
2096 EXT2_EXTENT_NEXT_SIB,
2097 &extent);
2098 ctx->flags |= E2F_FLAG_RESTART_LATER;
2099 if (pctx->errcode ==
2100 EXT2_ET_NO_CURRENT_NODE) {
2101 pctx->errcode = 0;
2102 break;
2103 }
2104 continue;
2105 }
2106 e2fsck_read_bitmaps(ctx);
2107 pb->inode_modified = 1;
2108 pctx->errcode =
2109 ext2fs_extent_delete(ehandle, 0);
2110 if (pctx->errcode) {
2111 pctx->str = "ext2fs_extent_delete";
2112 return;
2113 }
2114 pctx->errcode = ext2fs_extent_fix_parents(ehandle);
2115 if (pctx->errcode &&
2116 pctx->errcode != EXT2_ET_NO_CURRENT_NODE) {
2117 pctx->str = "ext2fs_extent_fix_parents";
2118 return;
2119 }
2120 pctx->errcode = ext2fs_extent_get(ehandle,
2121 EXT2_EXTENT_CURRENT,
2122 &extent);
2123 if (pctx->errcode == EXT2_ET_NO_CURRENT_NODE) {
2124 pctx->errcode = 0;
2125 break;
2126 }
2127 continue;
2128 }
2129 goto next;
2130 }
2131
2132 if (!is_leaf) {
2133 blk64_t lblk = extent.e_lblk;
2134 int next_try_repairs = 1;
2135
2136 blk = extent.e_pblk;
2137
2138 /*
2139 * If this lower extent block collides with critical
2140 * metadata, don't try to repair the damage. Pass 1b
2141 * will reallocate the block; then we can try again.
2142 */
2143 if (pb->ino != EXT2_RESIZE_INO &&
2144 ext2fs_test_block_bitmap2(ctx->block_metadata_map,
2145 extent.e_pblk)) {
2146 next_try_repairs = 0;
2147 pctx->blk = blk;
2148 fix_problem(ctx,
2149 PR_1_CRITICAL_METADATA_COLLISION,
2150 pctx);
2151 ctx->flags |= E2F_FLAG_RESTART_LATER;
2152 }
2153 pctx->errcode = ext2fs_extent_get(ehandle,
2154 EXT2_EXTENT_DOWN, &extent);
2155 if (pctx->errcode) {
2156 pctx->str = "EXT2_EXTENT_DOWN";
2157 problem = PR_1_EXTENT_HEADER_INVALID;
2158 if (!next_try_repairs)
2159 return;
2160 if (pctx->errcode ==
2161 EXT2_ET_EXTENT_HEADER_BAD ||
2162 pctx->errcode ==
2163 EXT2_ET_EXTENT_CSUM_INVALID)
2164 goto report_problem;
2165 return;
2166 }
2167 /* The next extent should match this index's logical start */
2168 if (extent.e_lblk != lblk) {
2169 struct ext2_extent_info e_info;
2170
2171 ext2fs_extent_get_info(ehandle, &e_info);
2172 pctx->blk = lblk;
2173 pctx->blk2 = extent.e_lblk;
2174 pctx->num = e_info.curr_level - 1;
2175 problem = PR_1_EXTENT_INDEX_START_INVALID;
2176 if (fix_problem(ctx, problem, pctx)) {
2177 pb->inode_modified = 1;
2178 pctx->errcode =
2179 ext2fs_extent_fix_parents(ehandle);
2180 if (pctx->errcode) {
2181 pctx->str = "ext2fs_extent_fix_parents";
2182 return;
2183 }
2184 }
2185 }
2186 scan_extent_node(ctx, pctx, pb, extent.e_lblk,
2187 last_lblk, eof_block, ehandle,
2188 next_try_repairs);
2189 if (pctx->errcode)
2190 return;
2191 pctx->errcode = ext2fs_extent_get(ehandle,
2192 EXT2_EXTENT_UP, &extent);
2193 if (pctx->errcode) {
2194 pctx->str = "EXT2_EXTENT_UP";
2195 return;
2196 }
2197 mark_block_used(ctx, blk);
2198 pb->num_blocks++;
2199 goto next;
2200 }
2201
2202 if ((pb->previous_block != 0) &&
2203 (pb->previous_block+1 != extent.e_pblk)) {
2204 if (ctx->options & E2F_OPT_FRAGCHECK) {
2205 char type = '?';
2206
2207 if (pb->is_dir)
2208 type = 'd';
2209 else if (pb->is_reg)
2210 type = 'f';
2211
2212 printf(("%6lu(%c): expecting %6lu "
2213 "actual extent "
2214 "phys %6lu log %lu len %lu\n"),
2215 (unsigned long) pctx->ino, type,
2216 (unsigned long) pb->previous_block+1,
2217 (unsigned long) extent.e_pblk,
2218 (unsigned long) extent.e_lblk,
2219 (unsigned long) extent.e_len);
2220 }
2221 pb->fragmented = 1;
2222 }
2223 /*
2224 * If we notice a gap in the logical block mappings of an
2225 * extent-mapped directory, offer to close the hole by
2226 * moving the logical block down, otherwise we'll go mad in
2227 * pass 3 allocating empty directory blocks to fill the hole.
2228 */
2229 if (try_repairs && is_dir &&
2230 pb->last_block + 1 < (e2_blkcnt_t)extent.e_lblk) {
2231 blk64_t new_lblk;
2232
2233 new_lblk = pb->last_block + 1;
2234 if (EXT2FS_CLUSTER_RATIO(ctx->fs) > 1)
2235 new_lblk = ((new_lblk +
2236 EXT2FS_CLUSTER_RATIO(ctx->fs)) &
2237 EXT2FS_CLUSTER_MASK(ctx->fs)) |
2238 (extent.e_lblk &
2239 EXT2FS_CLUSTER_MASK(ctx->fs));
2240 pctx->blk = extent.e_lblk;
2241 pctx->blk2 = new_lblk;
2242 if (fix_problem(ctx, PR_1_COLLAPSE_DBLOCK, pctx)) {
2243 extent.e_lblk = new_lblk;
2244 pb->inode_modified = 1;
2245 pctx->errcode = ext2fs_extent_replace(ehandle,
2246 0, &extent);
2247 if (pctx->errcode) {
2248 pctx->errcode = 0;
2249 goto alloc_later;
2250 }
2251 pctx->errcode = ext2fs_extent_fix_parents(ehandle);
2252 if (pctx->errcode)
2253 goto failed_add_dir_block;
2254 pctx->errcode = ext2fs_extent_goto(ehandle,
2255 extent.e_lblk);
2256 if (pctx->errcode)
2257 goto failed_add_dir_block;
2258 last_lblk = extent.e_lblk + extent.e_len - 1;
2259 }
2260 }
2261 alloc_later:
2262 while (is_dir && (++pb->last_db_block <
2263 (e2_blkcnt_t) extent.e_lblk)) {
2264 pctx->errcode = ext2fs_add_dir_block2(ctx->fs->dblist,
2265 pb->ino, 0,
2266 pb->last_db_block);
2267 if (pctx->errcode) {
2268 pctx->blk = 0;
2269 pctx->num = pb->last_db_block;
2270 goto failed_add_dir_block;
2271 }
2272 }
2273 if (!ctx->fs->cluster_ratio_bits) {
2274 mark_blocks_used(ctx, extent.e_pblk, extent.e_len);
2275 pb->num_blocks += extent.e_len;
2276 }
2277 for (blk = extent.e_pblk, blockcnt = extent.e_lblk, i = 0;
2278 i < extent.e_len;
2279 blk++, blockcnt++, i++) {
2280 if (ctx->fs->cluster_ratio_bits &&
2281 !(pb->previous_block &&
2282 (EXT2FS_B2C(ctx->fs, blk) ==
2283 EXT2FS_B2C(ctx->fs, pb->previous_block)) &&
2284 (blk & EXT2FS_CLUSTER_MASK(ctx->fs)) ==
2285 ((unsigned) blockcnt & EXT2FS_CLUSTER_MASK(ctx->fs)))) {
2286 mark_block_used(ctx, blk);
2287 pb->num_blocks++;
2288 }
2289 if (has_unaligned_cluster_map(ctx, pb->previous_block,
2290 pb->last_block, blk,
2291 blockcnt)) {
2292 pctx->blk = blockcnt;
2293 pctx->blk2 = blk;
2294 fix_problem(ctx, PR_1_MISALIGNED_CLUSTER, pctx);
2295 mark_block_used(ctx, blk);
2296 mark_block_used(ctx, blk);
2297 }
2298 pb->last_block = blockcnt;
2299 pb->previous_block = blk;
2300
2301 if (is_dir) {
2302 pctx->errcode = ext2fs_add_dir_block2(ctx->fs->dblist, pctx->ino, blk, blockcnt);
2303 if (pctx->errcode) {
2304 pctx->blk = blk;
2305 pctx->num = blockcnt;
2306 failed_add_dir_block:
2307 fix_problem(ctx, PR_1_ADD_DBLOCK, pctx);
2308 /* Should never get here */
2309 ctx->flags |= E2F_FLAG_ABORT;
2310 return;
2311 }
2312 }
2313 }
2314 if (is_dir && extent.e_len > 0)
2315 pb->last_db_block = blockcnt - 1;
2316 pb->previous_block = extent.e_pblk + extent.e_len - 1;
2317 start_block = pb->last_block = last_lblk;
2318 if (is_leaf && !is_dir &&
2319 !(extent.e_flags & EXT2_EXTENT_FLAGS_UNINIT))
2320 pb->last_init_lblock = last_lblk;
2321 next:
2322 pctx->errcode = ext2fs_extent_get(ehandle,
2323 EXT2_EXTENT_NEXT_SIB,
2324 &extent);
2325 }
2326 if (pctx->errcode == EXT2_ET_EXTENT_NO_NEXT)
2327 pctx->errcode = 0;
2328 }
2329
2330 static void check_blocks_extents(e2fsck_t ctx, struct problem_context *pctx,
2331 struct process_block_struct *pb)
2332 {
2333 struct ext2_extent_info info;
2334 struct ext2_inode *inode = pctx->inode;
2335 ext2_extent_handle_t ehandle;
2336 ext2_filsys fs = ctx->fs;
2337 ext2_ino_t ino = pctx->ino;
2338 errcode_t retval;
2339 blk64_t eof_lblk;
2340
2341 pctx->errcode = ext2fs_extent_open2(fs, ino, inode, &ehandle);
2342 if (pctx->errcode) {
2343 if (fix_problem(ctx, PR_1_READ_EXTENT, pctx))
2344 e2fsck_clear_inode(ctx, ino, inode, 0,
2345 "check_blocks_extents");
2346 pctx->errcode = 0;
2347 return;
2348 }
2349
2350 retval = ext2fs_extent_get_info(ehandle, &info);
2351 if (retval == 0) {
2352 if (info.max_depth >= MAX_EXTENT_DEPTH_COUNT)
2353 info.max_depth = MAX_EXTENT_DEPTH_COUNT-1;
2354 ctx->extent_depth_count[info.max_depth]++;
2355 }
2356
2357 eof_lblk = ((EXT2_I_SIZE(inode) + fs->blocksize - 1) >>
2358 EXT2_BLOCK_SIZE_BITS(fs->super)) - 1;
2359 scan_extent_node(ctx, pctx, pb, 0, 0, eof_lblk, ehandle, 1);
2360 if (pctx->errcode &&
2361 fix_problem(ctx, PR_1_EXTENT_ITERATE_FAILURE, pctx)) {
2362 pb->num_blocks = 0;
2363 inode->i_blocks = 0;
2364 e2fsck_clear_inode(ctx, ino, inode, E2F_FLAG_RESTART,
2365 "check_blocks_extents");
2366 pctx->errcode = 0;
2367 }
2368 ext2fs_extent_free(ehandle);
2369 }
2370
2371 /*
2372 * In fact we don't need to check blocks for an inode with inline data
2373 * because this inode doesn't have any blocks. In this function all
2374 * we need to do is add this inode into dblist when it is a directory.
2375 */
2376 static void check_blocks_inline_data(e2fsck_t ctx, struct problem_context *pctx,
2377 struct process_block_struct *pb)
2378 {
2379 if (!pb->is_dir) {
2380 pctx->errcode = 0;
2381 return;
2382 }
2383
2384 pctx->errcode = ext2fs_add_dir_block2(ctx->fs->dblist, pb->ino, 0, 0);
2385 if (pctx->errcode) {
2386 pctx->blk = 0;
2387 pctx->num = 0;
2388 fix_problem(ctx, PR_1_ADD_DBLOCK, pctx);
2389 ctx->flags |= E2F_FLAG_ABORT;
2390 }
2391 }
2392
2393 /*
2394 * This subroutine is called on each inode to account for all of the
2395 * blocks used by that inode.
2396 */
2397 static void check_blocks(e2fsck_t ctx, struct problem_context *pctx,
2398 char *block_buf)
2399 {
2400 ext2_filsys fs = ctx->fs;
2401 struct process_block_struct pb;
2402 ext2_ino_t ino = pctx->ino;
2403 struct ext2_inode *inode = pctx->inode;
2404 unsigned bad_size = 0;
2405 int dirty_inode = 0;
2406 int extent_fs;
2407 int inlinedata_fs;
2408 __u64 size;
2409
2410 pb.ino = ino;
2411 pb.num_blocks = 0;
2412 pb.last_block = -1;
2413 pb.last_init_lblock = -1;
2414 pb.last_db_block = -1;
2415 pb.num_illegal_blocks = 0;
2416 pb.suppress = 0; pb.clear = 0;
2417 pb.fragmented = 0;
2418 pb.compressed = 0;
2419 pb.previous_block = 0;
2420 pb.is_dir = LINUX_S_ISDIR(inode->i_mode);
2421 pb.is_reg = LINUX_S_ISREG(inode->i_mode);
2422 pb.max_blocks = 1 << (31 - fs->super->s_log_block_size);
2423 pb.inode = inode;
2424 pb.pctx = pctx;
2425 pb.ctx = ctx;
2426 pb.inode_modified = 0;
2427 pb.bad_ref = 0;
2428 pctx->ino = ino;
2429 pctx->errcode = 0;
2430
2431 extent_fs = (ctx->fs->super->s_feature_incompat &
2432 EXT3_FEATURE_INCOMPAT_EXTENTS);
2433 inlinedata_fs = (ctx->fs->super->s_feature_incompat &
2434 EXT4_FEATURE_INCOMPAT_INLINE_DATA);
2435
2436 if (inode->i_flags & EXT2_COMPRBLK_FL) {
2437 if (fs->super->s_feature_incompat &
2438 EXT2_FEATURE_INCOMPAT_COMPRESSION)
2439 pb.compressed = 1;
2440 else {
2441 if (fix_problem(ctx, PR_1_COMPR_SET, pctx)) {
2442 inode->i_flags &= ~EXT2_COMPRBLK_FL;
2443 dirty_inode++;
2444 }
2445 }
2446 }
2447
2448 if (check_ext_attr(ctx, pctx, block_buf)) {
2449 if (ctx->flags & E2F_FLAG_SIGNAL_MASK)
2450 goto out;
2451 pb.num_blocks++;
2452 }
2453
2454 if (ext2fs_inode_has_valid_blocks2(fs, inode)) {
2455 if (extent_fs && (inode->i_flags & EXT4_EXTENTS_FL))
2456 check_blocks_extents(ctx, pctx, &pb);
2457 else {
2458 /*
2459 * If we've modified the inode, write it out before
2460 * iterate() tries to use it.
2461 */
2462 if (dirty_inode) {
2463 e2fsck_write_inode(ctx, ino, inode,
2464 "check_blocks");
2465 dirty_inode = 0;
2466 }
2467 fs->flags |= EXT2_FLAG_IGNORE_CSUM_ERRORS;
2468 pctx->errcode = ext2fs_block_iterate3(fs, ino,
2469 pb.is_dir ? BLOCK_FLAG_HOLE : 0,
2470 block_buf, process_block, &pb);
2471 /*
2472 * We do not have uninitialized extents in non extent
2473 * files.
2474 */
2475 pb.last_init_lblock = pb.last_block;
2476 /*
2477 * If iterate() changed a block mapping, we have to
2478 * re-read the inode. If we decide to clear the
2479 * inode after clearing some stuff, we'll re-write the
2480 * bad mappings into the inode!
2481 */
2482 if (pb.inode_modified)
2483 e2fsck_read_inode(ctx, ino, inode,
2484 "check_blocks");
2485 fs->flags &= ~EXT2_FLAG_IGNORE_CSUM_ERRORS;
2486 }
2487 } else {
2488 /* check inline data */
2489 if (inlinedata_fs && (inode->i_flags & EXT4_INLINE_DATA_FL))
2490 check_blocks_inline_data(ctx, pctx, &pb);
2491 }
2492 end_problem_latch(ctx, PR_LATCH_BLOCK);
2493 end_problem_latch(ctx, PR_LATCH_TOOBIG);
2494 if (ctx->flags & E2F_FLAG_SIGNAL_MASK)
2495 goto out;
2496 if (pctx->errcode)
2497 fix_problem(ctx, PR_1_BLOCK_ITERATE, pctx);
2498
2499 if (pb.fragmented && pb.num_blocks < fs->super->s_blocks_per_group) {
2500 if (LINUX_S_ISDIR(inode->i_mode))
2501 ctx->fs_fragmented_dir++;
2502 else
2503 ctx->fs_fragmented++;
2504 }
2505
2506 if (pb.clear) {
2507 e2fsck_clear_inode(ctx, ino, inode, E2F_FLAG_RESTART,
2508 "check_blocks");
2509 return;
2510 }
2511
2512 if (inode->i_flags & EXT2_INDEX_FL) {
2513 if (handle_htree(ctx, pctx, ino, inode, block_buf)) {
2514 inode->i_flags &= ~EXT2_INDEX_FL;
2515 dirty_inode++;
2516 } else {
2517 #ifdef ENABLE_HTREE
2518 e2fsck_add_dx_dir(ctx, ino, pb.last_block+1);
2519 #endif
2520 }
2521 }
2522
2523 if (!pb.num_blocks && pb.is_dir &&
2524 !(inode->i_flags & EXT4_INLINE_DATA_FL)) {
2525 if (fix_problem(ctx, PR_1_ZERO_LENGTH_DIR, pctx)) {
2526 e2fsck_clear_inode(ctx, ino, inode, 0, "check_blocks");
2527 ctx->fs_directory_count--;
2528 return;
2529 }
2530 }
2531
2532 if (ino == EXT2_ROOT_INO || ino >= EXT2_FIRST_INODE(ctx->fs->super)) {
2533 quota_data_add(ctx->qctx, inode, ino,
2534 pb.num_blocks * fs->blocksize);
2535 quota_data_inodes(ctx->qctx, inode, ino, +1);
2536 }
2537
2538 if (!(fs->super->s_feature_ro_compat &
2539 EXT4_FEATURE_RO_COMPAT_HUGE_FILE) ||
2540 !(inode->i_flags & EXT4_HUGE_FILE_FL))
2541 pb.num_blocks *= (fs->blocksize / 512);
2542 pb.num_blocks *= EXT2FS_CLUSTER_RATIO(fs);
2543 #if 0
2544 printf("inode %u, i_size = %u, last_block = %lld, i_blocks=%llu, num_blocks = %llu\n",
2545 ino, inode->i_size, pb.last_block, ext2fs_inode_i_blocks(fs, inode),
2546 pb.num_blocks);
2547 #endif
2548 if (pb.is_dir) {
2549 int nblock = inode->i_size >> EXT2_BLOCK_SIZE_BITS(fs->super);
2550 if (inode->i_flags & EXT4_INLINE_DATA_FL) {
2551 size_t size;
2552
2553 if (ext2fs_inline_data_size(ctx->fs, pctx->ino, &size))
2554 bad_size = 5;
2555 if (size != inode->i_size)
2556 bad_size = 5;
2557 } else if (inode->i_size & (fs->blocksize - 1))
2558 bad_size = 5;
2559 else if (nblock > (pb.last_block + 1))
2560 bad_size = 1;
2561 else if (nblock < (pb.last_block + 1)) {
2562 if (((pb.last_block + 1) - nblock) >
2563 fs->super->s_prealloc_dir_blocks)
2564 bad_size = 2;
2565 }
2566 } else {
2567 e2_blkcnt_t blkpg = ctx->blocks_per_page;
2568
2569 size = EXT2_I_SIZE(inode);
2570 if ((pb.last_init_lblock >= 0) &&
2571 /* allow allocated blocks to end of PAGE_SIZE */
2572 (size < (__u64)pb.last_init_lblock * fs->blocksize) &&
2573 (pb.last_init_lblock / blkpg * blkpg != pb.last_init_lblock ||
2574 size < (__u64)(pb.last_init_lblock & ~(blkpg-1)) *
2575 fs->blocksize))
2576 bad_size = 3;
2577 else if (!(extent_fs && (inode->i_flags & EXT4_EXTENTS_FL)) &&
2578 size > ext2_max_sizes[fs->super->s_log_block_size])
2579 /* too big for a direct/indirect-mapped file */
2580 bad_size = 4;
2581 else if ((extent_fs && (inode->i_flags & EXT4_EXTENTS_FL)) &&
2582 size >
2583 ((1ULL << (32 + EXT2_BLOCK_SIZE_BITS(fs->super))) - 1))
2584 /* too big for an extent-based file - 32bit ee_block */
2585 bad_size = 6;
2586 }
2587 /* i_size for symlinks is checked elsewhere */
2588 if (bad_size && !LINUX_S_ISLNK(inode->i_mode)) {
2589 pctx->num = (pb.last_block+1) * fs->blocksize;
2590 pctx->group = bad_size;
2591 if (fix_problem(ctx, PR_1_BAD_I_SIZE, pctx)) {
2592 if (LINUX_S_ISDIR(inode->i_mode))
2593 pctx->num &= 0xFFFFFFFFULL;
2594 ext2fs_inode_size_set(fs, inode, pctx->num);
2595 dirty_inode++;
2596 }
2597 pctx->num = 0;
2598 }
2599 if (LINUX_S_ISREG(inode->i_mode) &&
2600 ext2fs_needs_large_file_feature(EXT2_I_SIZE(inode)))
2601 ctx->large_files++;
2602 if ((pb.num_blocks != ext2fs_inode_i_blocks(fs, inode)) ||
2603 ((fs->super->s_feature_ro_compat &
2604 EXT4_FEATURE_RO_COMPAT_HUGE_FILE) &&
2605 (inode->i_flags & EXT4_HUGE_FILE_FL) &&
2606 (inode->osd2.linux2.l_i_blocks_hi != 0))) {
2607 pctx->num = pb.num_blocks;
2608 if (fix_problem(ctx, PR_1_BAD_I_BLOCKS, pctx)) {
2609 inode->i_blocks = pb.num_blocks;
2610 inode->osd2.linux2.l_i_blocks_hi = pb.num_blocks >> 32;
2611 dirty_inode++;
2612 }
2613 pctx->num = 0;
2614 }
2615
2616 if (ctx->dirs_to_hash && pb.is_dir &&
2617 !(ctx->lost_and_found && ctx->lost_and_found == ino) &&
2618 !(inode->i_flags & EXT2_INDEX_FL) &&
2619 ((inode->i_size / fs->blocksize) >= 3))
2620 e2fsck_rehash_dir_later(ctx, ino);
2621
2622 out:
2623 if (dirty_inode)
2624 e2fsck_write_inode(ctx, ino, inode, "check_blocks");
2625 }
2626
2627 #if 0
2628 /*
2629 * Helper function called by process block when an illegal block is
2630 * found. It returns a description about why the block is illegal
2631 */
2632 static char *describe_illegal_block(ext2_filsys fs, blk64_t block)
2633 {
2634 blk64_t super;
2635 int i;
2636 static char problem[80];
2637
2638 super = fs->super->s_first_data_block;
2639 strcpy(problem, "PROGRAMMING ERROR: Unknown reason for illegal block");
2640 if (block < super) {
2641 sprintf(problem, "< FIRSTBLOCK (%u)", super);
2642 return(problem);
2643 } else if (block >= ext2fs_blocks_count(fs->super)) {
2644 sprintf(problem, "> BLOCKS (%u)", ext2fs_blocks_count(fs->super));
2645 return(problem);
2646 }
2647 for (i = 0; i < fs->group_desc_count; i++) {
2648 if (block == super) {
2649 sprintf(problem, "is the superblock in group %d", i);
2650 break;
2651 }
2652 if (block > super &&
2653 block <= (super + fs->desc_blocks)) {
2654 sprintf(problem, "is in the group descriptors "
2655 "of group %d", i);
2656 break;
2657 }
2658 if (block == ext2fs_block_bitmap_loc(fs, i)) {
2659 sprintf(problem, "is the block bitmap of group %d", i);
2660 break;
2661 }
2662 if (block == ext2fs_inode_bitmap_loc(fs, i)) {
2663 sprintf(problem, "is the inode bitmap of group %d", i);
2664 break;
2665 }
2666 if (block >= ext2fs_inode_table_loc(fs, i) &&
2667 (block < ext2fs_inode_table_loc(fs, i)
2668 + fs->inode_blocks_per_group)) {
2669 sprintf(problem, "is in the inode table of group %d",
2670 i);
2671 break;
2672 }
2673 super += fs->super->s_blocks_per_group;
2674 }
2675 return(problem);
2676 }
2677 #endif
2678
2679 /*
2680 * This is a helper function for check_blocks().
2681 */
2682 static int process_block(ext2_filsys fs,
2683 blk64_t *block_nr,
2684 e2_blkcnt_t blockcnt,
2685 blk64_t ref_block EXT2FS_ATTR((unused)),
2686 int ref_offset EXT2FS_ATTR((unused)),
2687 void *priv_data)
2688 {
2689 struct process_block_struct *p;
2690 struct problem_context *pctx;
2691 blk64_t blk = *block_nr;
2692 int ret_code = 0;
2693 problem_t problem = 0;
2694 e2fsck_t ctx;
2695
2696 p = (struct process_block_struct *) priv_data;
2697 pctx = p->pctx;
2698 ctx = p->ctx;
2699
2700 if (p->compressed && (blk == EXT2FS_COMPRESSED_BLKADDR)) {
2701 /* todo: Check that the comprblk_fl is high, that the
2702 blkaddr pattern looks right (all non-holes up to
2703 first EXT2FS_COMPRESSED_BLKADDR, then all
2704 EXT2FS_COMPRESSED_BLKADDR up to end of cluster),
2705 that the feature_incompat bit is high, and that the
2706 inode is a regular file. If we're doing a "full
2707 check" (a concept introduced to e2fsck by e2compr,
2708 meaning that we look at data blocks as well as
2709 metadata) then call some library routine that
2710 checks the compressed data. I'll have to think
2711 about this, because one particularly important
2712 problem to be able to fix is to recalculate the
2713 cluster size if necessary. I think that perhaps
2714 we'd better do most/all e2compr-specific checks
2715 separately, after the non-e2compr checks. If not
2716 doing a full check, it may be useful to test that
2717 the personality is linux; e.g. if it isn't then
2718 perhaps this really is just an illegal block. */
2719 return 0;
2720 }
2721
2722 /*
2723 * For a directory, add logical block zero for processing even if it's
2724 * not mapped or we'll be perennially stuck with broken "." and ".."
2725 * entries.
2726 */
2727 if (p->is_dir && blockcnt == 0 && blk == 0) {
2728 pctx->errcode = ext2fs_add_dir_block2(fs->dblist, p->ino, 0, 0);
2729 if (pctx->errcode) {
2730 pctx->blk = blk;
2731 pctx->num = blockcnt;
2732 goto failed_add_dir_block;
2733 }
2734 p->last_db_block++;
2735 }
2736
2737 if (blk == 0)
2738 return 0;
2739
2740 #if 0
2741 printf("Process_block, inode %lu, block %u, #%d\n", p->ino, blk,
2742 blockcnt);
2743 #endif
2744
2745 /*
2746 * Simplistic fragmentation check. We merely require that the
2747 * file be contiguous. (Which can never be true for really
2748 * big files that are greater than a block group.)
2749 */
2750 if (!HOLE_BLKADDR(p->previous_block) && p->ino != EXT2_RESIZE_INO) {
2751 if (p->previous_block+1 != blk) {
2752 if (ctx->options & E2F_OPT_FRAGCHECK) {
2753 char type = '?';
2754
2755 if (p->is_dir)
2756 type = 'd';
2757 else if (p->is_reg)
2758 type = 'f';
2759
2760 printf(_("%6lu(%c): expecting %6lu "
2761 "got phys %6lu (blkcnt %lld)\n"),
2762 (unsigned long) pctx->ino, type,
2763 (unsigned long) p->previous_block+1,
2764 (unsigned long) blk,
2765 blockcnt);
2766 }
2767 p->fragmented = 1;
2768 }
2769 }
2770
2771 if (p->is_dir && blockcnt > (1 << (21 - fs->super->s_log_block_size)))
2772 problem = PR_1_TOOBIG_DIR;
2773 if (p->is_reg && p->num_blocks+1 >= p->max_blocks)
2774 problem = PR_1_TOOBIG_REG;
2775 if (!p->is_dir && !p->is_reg && blockcnt > 0)
2776 problem = PR_1_TOOBIG_SYMLINK;
2777
2778 if (blk < fs->super->s_first_data_block ||
2779 blk >= ext2fs_blocks_count(fs->super))
2780 problem = PR_1_ILLEGAL_BLOCK_NUM;
2781
2782 /*
2783 * If this IND/DIND/TIND block is squatting atop some critical metadata
2784 * (group descriptors, superblock, bitmap, inode table), any write to
2785 * "fix" mapping problems will destroy the metadata. We'll let pass 1b
2786 * fix that and restart fsck.
2787 */
2788 if (blockcnt < 0 &&
2789 p->ino != EXT2_RESIZE_INO &&
2790 ext2fs_test_block_bitmap2(ctx->block_metadata_map, blk)) {
2791 p->bad_ref = blk;
2792 pctx->blk = blk;
2793 fix_problem(ctx, PR_1_CRITICAL_METADATA_COLLISION, pctx);
2794 ctx->flags |= E2F_FLAG_RESTART_LATER;
2795 }
2796
2797 if (problem) {
2798 p->num_illegal_blocks++;
2799 /*
2800 * A bit of subterfuge here -- we're trying to fix a block
2801 * mapping, but know that the IND/DIND/TIND block has collided
2802 * with some critical metadata. So, fix the in-core mapping so
2803 * iterate won't go insane, but return 0 instead of
2804 * BLOCK_CHANGED so that it won't write the remapping out to
2805 * our multiply linked block.
2806 */
2807 if (p->bad_ref && ref_block == p->bad_ref) {
2808 *block_nr = 0;
2809 return 0;
2810 }
2811 if (!p->suppress && (p->num_illegal_blocks % 12) == 0) {
2812 if (fix_problem(ctx, PR_1_TOO_MANY_BAD_BLOCKS, pctx)) {
2813 p->clear = 1;
2814 return BLOCK_ABORT;
2815 }
2816 if (fix_problem(ctx, PR_1_SUPPRESS_MESSAGES, pctx)) {
2817 p->suppress = 1;
2818 set_latch_flags(PR_LATCH_BLOCK,
2819 PRL_SUPPRESS, 0);
2820 }
2821 }
2822 pctx->blk = blk;
2823 pctx->blkcount = blockcnt;
2824 if (fix_problem(ctx, problem, pctx)) {
2825 blk = *block_nr = 0;
2826 ret_code = BLOCK_CHANGED;
2827 p->inode_modified = 1;
2828 /*
2829 * If the directory block is too big and is beyond the
2830 * end of the FS, don't bother trying to add it for
2831 * processing -- the kernel would never have created a
2832 * directory this large, and we risk an ENOMEM abort.
2833 * In any case, the toobig handler for extent-based
2834 * directories also doesn't feed toobig blocks to
2835 * pass 2.
2836 */
2837 if (problem == PR_1_TOOBIG_DIR)
2838 return ret_code;
2839 goto mark_dir;
2840 } else
2841 return 0;
2842 }
2843
2844 if (p->ino == EXT2_RESIZE_INO) {
2845 /*
2846 * The resize inode has already be sanity checked
2847 * during pass #0 (the superblock checks). All we
2848 * have to do is mark the double indirect block as
2849 * being in use; all of the other blocks are handled
2850 * by mark_table_blocks()).
2851 */
2852 if (blockcnt == BLOCK_COUNT_DIND)
2853 mark_block_used(ctx, blk);
2854 p->num_blocks++;
2855 } else if (!(ctx->fs->cluster_ratio_bits &&
2856 p->previous_block &&
2857 (EXT2FS_B2C(ctx->fs, blk) ==
2858 EXT2FS_B2C(ctx->fs, p->previous_block)) &&
2859 (blk & EXT2FS_CLUSTER_MASK(ctx->fs)) ==
2860 ((unsigned) blockcnt & EXT2FS_CLUSTER_MASK(ctx->fs)))) {
2861 mark_block_used(ctx, blk);
2862 p->num_blocks++;
2863 } else if (has_unaligned_cluster_map(ctx, p->previous_block,
2864 p->last_block, blk, blockcnt)) {
2865 pctx->blk = blockcnt;
2866 pctx->blk2 = blk;
2867 fix_problem(ctx, PR_1_MISALIGNED_CLUSTER, pctx);
2868 mark_block_used(ctx, blk);
2869 mark_block_used(ctx, blk);
2870 }
2871 if (blockcnt >= 0)
2872 p->last_block = blockcnt;
2873 p->previous_block = blk;
2874 mark_dir:
2875 if (p->is_dir && (blockcnt >= 0)) {
2876 while (++p->last_db_block < blockcnt) {
2877 pctx->errcode = ext2fs_add_dir_block2(fs->dblist,
2878 p->ino, 0,
2879 p->last_db_block);
2880 if (pctx->errcode) {
2881 pctx->blk = 0;
2882 pctx->num = p->last_db_block;
2883 goto failed_add_dir_block;
2884 }
2885 }
2886 pctx->errcode = ext2fs_add_dir_block2(fs->dblist, p->ino,
2887 blk, blockcnt);
2888 if (pctx->errcode) {
2889 pctx->blk = blk;
2890 pctx->num = blockcnt;
2891 failed_add_dir_block:
2892 fix_problem(ctx, PR_1_ADD_DBLOCK, pctx);
2893 /* Should never get here */
2894 ctx->flags |= E2F_FLAG_ABORT;
2895 return BLOCK_ABORT;
2896 }
2897 }
2898 return ret_code;
2899 }
2900
2901 static int process_bad_block(ext2_filsys fs,
2902 blk64_t *block_nr,
2903 e2_blkcnt_t blockcnt,
2904 blk64_t ref_block EXT2FS_ATTR((unused)),
2905 int ref_offset EXT2FS_ATTR((unused)),
2906 void *priv_data)
2907 {
2908 struct process_block_struct *p;
2909 blk64_t blk = *block_nr;
2910 blk64_t first_block;
2911 dgrp_t i;
2912 struct problem_context *pctx;
2913 e2fsck_t ctx;
2914
2915 /*
2916 * Note: This function processes blocks for the bad blocks
2917 * inode, which is never compressed. So we don't use HOLE_BLKADDR().
2918 */
2919
2920 if (!blk)
2921 return 0;
2922
2923 p = (struct process_block_struct *) priv_data;
2924 ctx = p->ctx;
2925 pctx = p->pctx;
2926
2927 pctx->ino = EXT2_BAD_INO;
2928 pctx->blk = blk;
2929 pctx->blkcount = blockcnt;
2930
2931 if ((blk < fs->super->s_first_data_block) ||
2932 (blk >= ext2fs_blocks_count(fs->super))) {
2933 if (fix_problem(ctx, PR_1_BB_ILLEGAL_BLOCK_NUM, pctx)) {
2934 *block_nr = 0;
2935 return BLOCK_CHANGED;
2936 } else
2937 return 0;
2938 }
2939
2940 if (blockcnt < 0) {
2941 if (ext2fs_test_block_bitmap2(p->fs_meta_blocks, blk)) {
2942 p->bbcheck = 1;
2943 if (fix_problem(ctx, PR_1_BB_FS_BLOCK, pctx)) {
2944 *block_nr = 0;
2945 return BLOCK_CHANGED;
2946 }
2947 } else if (ext2fs_test_block_bitmap2(ctx->block_found_map,
2948 blk)) {
2949 p->bbcheck = 1;
2950 if (fix_problem(ctx, PR_1_BBINODE_BAD_METABLOCK,
2951 pctx)) {
2952 *block_nr = 0;
2953 return BLOCK_CHANGED;
2954 }
2955 if (ctx->flags & E2F_FLAG_SIGNAL_MASK)
2956 return BLOCK_ABORT;
2957 } else
2958 mark_block_used(ctx, blk);
2959 return 0;
2960 }
2961 #if 0
2962 printf ("DEBUG: Marking %u as bad.\n", blk);
2963 #endif
2964 ctx->fs_badblocks_count++;
2965 /*
2966 * If the block is not used, then mark it as used and return.
2967 * If it is already marked as found, this must mean that
2968 * there's an overlap between the filesystem table blocks
2969 * (bitmaps and inode table) and the bad block list.
2970 */
2971 if (!ext2fs_test_block_bitmap2(ctx->block_found_map, blk)) {
2972 ext2fs_mark_block_bitmap2(ctx->block_found_map, blk);
2973 return 0;
2974 }
2975 /*
2976 * Try to find the where the filesystem block was used...
2977 */
2978 first_block = fs->super->s_first_data_block;
2979
2980 for (i = 0; i < fs->group_desc_count; i++ ) {
2981 pctx->group = i;
2982 pctx->blk = blk;
2983 if (!ext2fs_bg_has_super(fs, i))
2984 goto skip_super;
2985 if (blk == first_block) {
2986 if (i == 0) {
2987 if (fix_problem(ctx,
2988 PR_1_BAD_PRIMARY_SUPERBLOCK,
2989 pctx)) {
2990 *block_nr = 0;
2991 return BLOCK_CHANGED;
2992 }
2993 return 0;
2994 }
2995 fix_problem(ctx, PR_1_BAD_SUPERBLOCK, pctx);
2996 return 0;
2997 }
2998 if ((blk > first_block) &&
2999 (blk <= first_block + fs->desc_blocks)) {
3000 if (i == 0) {
3001 pctx->blk = *block_nr;
3002 if (fix_problem(ctx,
3003 PR_1_BAD_PRIMARY_GROUP_DESCRIPTOR, pctx)) {
3004 *block_nr = 0;
3005 return BLOCK_CHANGED;
3006 }
3007 return 0;
3008 }
3009 fix_problem(ctx, PR_1_BAD_GROUP_DESCRIPTORS, pctx);
3010 return 0;
3011 }
3012 skip_super:
3013 if (blk == ext2fs_block_bitmap_loc(fs, i)) {
3014 if (fix_problem(ctx, PR_1_BB_BAD_BLOCK, pctx)) {
3015 ctx->invalid_block_bitmap_flag[i]++;
3016 ctx->invalid_bitmaps++;
3017 }
3018 return 0;
3019 }
3020 if (blk == ext2fs_inode_bitmap_loc(fs, i)) {
3021 if (fix_problem(ctx, PR_1_IB_BAD_BLOCK, pctx)) {
3022 ctx->invalid_inode_bitmap_flag[i]++;
3023 ctx->invalid_bitmaps++;
3024 }
3025 return 0;
3026 }
3027 if ((blk >= ext2fs_inode_table_loc(fs, i)) &&
3028 (blk < (ext2fs_inode_table_loc(fs, i) +
3029 fs->inode_blocks_per_group))) {
3030 /*
3031 * If there are bad blocks in the inode table,
3032 * the inode scan code will try to do
3033 * something reasonable automatically.
3034 */
3035 return 0;
3036 }
3037 first_block += fs->super->s_blocks_per_group;
3038 }
3039 /*
3040 * If we've gotten to this point, then the only
3041 * possibility is that the bad block inode meta data
3042 * is using a bad block.
3043 */
3044 if ((blk == p->inode->i_block[EXT2_IND_BLOCK]) ||
3045 (blk == p->inode->i_block[EXT2_DIND_BLOCK]) ||
3046 (blk == p->inode->i_block[EXT2_TIND_BLOCK])) {
3047 p->bbcheck = 1;
3048 if (fix_problem(ctx, PR_1_BBINODE_BAD_METABLOCK, pctx)) {
3049 *block_nr = 0;
3050 return BLOCK_CHANGED;
3051 }
3052 if (ctx->flags & E2F_FLAG_SIGNAL_MASK)
3053 return BLOCK_ABORT;
3054 return 0;
3055 }
3056
3057 pctx->group = -1;
3058
3059 /* Warn user that the block wasn't claimed */
3060 fix_problem(ctx, PR_1_PROGERR_CLAIMED_BLOCK, pctx);
3061
3062 return 0;
3063 }
3064
3065 static void new_table_block(e2fsck_t ctx, blk64_t first_block, dgrp_t group,
3066 const char *name, int num, blk64_t *new_block)
3067 {
3068 ext2_filsys fs = ctx->fs;
3069 dgrp_t last_grp;
3070 blk64_t old_block = *new_block;
3071 blk64_t last_block;
3072 dgrp_t flexbg;
3073 unsigned flexbg_size;
3074 int i, is_flexbg;
3075 char *buf;
3076 struct problem_context pctx;
3077
3078 clear_problem_context(&pctx);
3079
3080 pctx.group = group;
3081 pctx.blk = old_block;
3082 pctx.str = name;
3083
3084 /*
3085 * For flex_bg filesystems, first try to allocate the metadata
3086 * within the flex_bg, and if that fails then try finding the
3087 * space anywhere in the filesystem.
3088 */
3089 is_flexbg = EXT2_HAS_INCOMPAT_FEATURE(fs->super,
3090 EXT4_FEATURE_INCOMPAT_FLEX_BG);
3091 if (is_flexbg) {
3092 flexbg_size = 1 << fs->super->s_log_groups_per_flex;
3093 flexbg = group / flexbg_size;
3094 first_block = ext2fs_group_first_block2(fs,
3095 flexbg_size * flexbg);
3096 last_grp = group | (flexbg_size - 1);
3097 if (last_grp >= fs->group_desc_count)
3098 last_grp = fs->group_desc_count - 1;
3099 last_block = ext2fs_group_last_block2(fs, last_grp);
3100 } else
3101 last_block = ext2fs_group_last_block2(fs, group);
3102 pctx.errcode = ext2fs_get_free_blocks2(fs, first_block, last_block,
3103 num, ctx->block_found_map,
3104 new_block);
3105 if (is_flexbg && (pctx.errcode == EXT2_ET_BLOCK_ALLOC_FAIL))
3106 pctx.errcode = ext2fs_get_free_blocks2(fs,
3107 fs->super->s_first_data_block,
3108 ext2fs_blocks_count(fs->super),
3109 num, ctx->block_found_map, new_block);
3110 if (pctx.errcode) {
3111 pctx.num = num;
3112 fix_problem(ctx, PR_1_RELOC_BLOCK_ALLOCATE, &pctx);
3113 ext2fs_unmark_valid(fs);
3114 ctx->flags |= E2F_FLAG_ABORT;
3115 return;
3116 }
3117 pctx.errcode = ext2fs_get_mem(fs->blocksize, &buf);
3118 if (pctx.errcode) {
3119 fix_problem(ctx, PR_1_RELOC_MEMORY_ALLOCATE, &pctx);
3120 ext2fs_unmark_valid(fs);
3121 ctx->flags |= E2F_FLAG_ABORT;
3122 return;
3123 }
3124 ext2fs_mark_super_dirty(fs);
3125 fs->flags &= ~EXT2_FLAG_MASTER_SB_ONLY;
3126 pctx.blk2 = *new_block;
3127 fix_problem(ctx, (old_block ? PR_1_RELOC_FROM_TO :
3128 PR_1_RELOC_TO), &pctx);
3129 pctx.blk2 = 0;
3130 for (i = 0; i < num; i++) {
3131 pctx.blk = i;
3132 ext2fs_mark_block_bitmap2(ctx->block_found_map, (*new_block)+i);
3133 if (old_block) {
3134 pctx.errcode = io_channel_read_blk64(fs->io,
3135 old_block + i, 1, buf);
3136 if (pctx.errcode)
3137 fix_problem(ctx, PR_1_RELOC_READ_ERR, &pctx);
3138 } else
3139 memset(buf, 0, fs->blocksize);
3140
3141 pctx.blk = (*new_block) + i;
3142 pctx.errcode = io_channel_write_blk64(fs->io, pctx.blk,
3143 1, buf);
3144 if (pctx.errcode)
3145 fix_problem(ctx, PR_1_RELOC_WRITE_ERR, &pctx);
3146 }
3147 ext2fs_free_mem(&buf);
3148 }
3149
3150 /*
3151 * This routine gets called at the end of pass 1 if bad blocks are
3152 * detected in the superblock, group descriptors, inode_bitmaps, or
3153 * block bitmaps. At this point, all of the blocks have been mapped
3154 * out, so we can try to allocate new block(s) to replace the bad
3155 * blocks.
3156 */
3157 static void handle_fs_bad_blocks(e2fsck_t ctx)
3158 {
3159 ext2_filsys fs = ctx->fs;
3160 dgrp_t i;
3161 blk64_t first_block;
3162 blk64_t new_blk;
3163
3164 for (i = 0; i < fs->group_desc_count; i++) {
3165 first_block = ext2fs_group_first_block2(fs, i);
3166
3167 if (ctx->invalid_block_bitmap_flag[i]) {
3168 new_blk = ext2fs_block_bitmap_loc(fs, i);
3169 new_table_block(ctx, first_block, i, _("block bitmap"),
3170 1, &new_blk);
3171 ext2fs_block_bitmap_loc_set(fs, i, new_blk);
3172 }
3173 if (ctx->invalid_inode_bitmap_flag[i]) {
3174 new_blk = ext2fs_inode_bitmap_loc(fs, i);
3175 new_table_block(ctx, first_block, i, _("inode bitmap"),
3176 1, &new_blk);
3177 ext2fs_inode_bitmap_loc_set(fs, i, new_blk);
3178 }
3179 if (ctx->invalid_inode_table_flag[i]) {
3180 new_blk = ext2fs_inode_table_loc(fs, i);
3181 new_table_block(ctx, first_block, i, _("inode table"),
3182 fs->inode_blocks_per_group,
3183 &new_blk);
3184 ext2fs_inode_table_loc_set(fs, i, new_blk);
3185 ctx->flags |= E2F_FLAG_RESTART;
3186 }
3187 }
3188 ctx->invalid_bitmaps = 0;
3189 }
3190
3191 /*
3192 * This routine marks all blocks which are used by the superblock,
3193 * group descriptors, inode bitmaps, and block bitmaps.
3194 */
3195 static void mark_table_blocks(e2fsck_t ctx)
3196 {
3197 ext2_filsys fs = ctx->fs;
3198 blk64_t b;
3199 dgrp_t i;
3200 unsigned int j;
3201 struct problem_context pctx;
3202
3203 clear_problem_context(&pctx);
3204
3205 for (i = 0; i < fs->group_desc_count; i++) {
3206 pctx.group = i;
3207
3208 ext2fs_reserve_super_and_bgd(fs, i, ctx->block_found_map);
3209 ext2fs_reserve_super_and_bgd(fs, i, ctx->block_metadata_map);
3210
3211 /*
3212 * Mark the blocks used for the inode table
3213 */
3214 if (ext2fs_inode_table_loc(fs, i)) {
3215 for (j = 0, b = ext2fs_inode_table_loc(fs, i);
3216 j < fs->inode_blocks_per_group;
3217 j++, b++) {
3218 if (ext2fs_test_block_bitmap2(ctx->block_found_map,
3219 b)) {
3220 pctx.blk = b;
3221 if (!ctx->invalid_inode_table_flag[i] &&
3222 fix_problem(ctx,
3223 PR_1_ITABLE_CONFLICT, &pctx)) {
3224 ctx->invalid_inode_table_flag[i]++;
3225 ctx->invalid_bitmaps++;
3226 }
3227 } else {
3228 ext2fs_mark_block_bitmap2(
3229 ctx->block_found_map, b);
3230 ext2fs_mark_block_bitmap2(
3231 ctx->block_metadata_map, b);
3232 }
3233 }
3234 }
3235
3236 /*
3237 * Mark block used for the block bitmap
3238 */
3239 if (ext2fs_block_bitmap_loc(fs, i)) {
3240 if (ext2fs_test_block_bitmap2(ctx->block_found_map,
3241 ext2fs_block_bitmap_loc(fs, i))) {
3242 pctx.blk = ext2fs_block_bitmap_loc(fs, i);
3243 if (fix_problem(ctx, PR_1_BB_CONFLICT, &pctx)) {
3244 ctx->invalid_block_bitmap_flag[i]++;
3245 ctx->invalid_bitmaps++;
3246 }
3247 } else {
3248 ext2fs_mark_block_bitmap2(ctx->block_found_map,
3249 ext2fs_block_bitmap_loc(fs, i));
3250 ext2fs_mark_block_bitmap2(ctx->block_metadata_map,
3251 ext2fs_block_bitmap_loc(fs, i));
3252 }
3253 }
3254 /*
3255 * Mark block used for the inode bitmap
3256 */
3257 if (ext2fs_inode_bitmap_loc(fs, i)) {
3258 if (ext2fs_test_block_bitmap2(ctx->block_found_map,
3259 ext2fs_inode_bitmap_loc(fs, i))) {
3260 pctx.blk = ext2fs_inode_bitmap_loc(fs, i);
3261 if (fix_problem(ctx, PR_1_IB_CONFLICT, &pctx)) {
3262 ctx->invalid_inode_bitmap_flag[i]++;
3263 ctx->invalid_bitmaps++;
3264 }
3265 } else {
3266 ext2fs_mark_block_bitmap2(ctx->block_metadata_map,
3267 ext2fs_inode_bitmap_loc(fs, i));
3268 ext2fs_mark_block_bitmap2(ctx->block_found_map,
3269 ext2fs_inode_bitmap_loc(fs, i));
3270 }
3271 }
3272 }
3273 }
3274
3275 /*
3276 * Thes subroutines short circuits ext2fs_get_blocks and
3277 * ext2fs_check_directory; we use them since we already have the inode
3278 * structure, so there's no point in letting the ext2fs library read
3279 * the inode again.
3280 */
3281 static errcode_t pass1_get_blocks(ext2_filsys fs, ext2_ino_t ino,
3282 blk_t *blocks)
3283 {
3284 e2fsck_t ctx = (e2fsck_t) fs->priv_data;
3285 int i;
3286
3287 if ((ino != ctx->stashed_ino) || !ctx->stashed_inode)
3288 return EXT2_ET_CALLBACK_NOTHANDLED;
3289
3290 for (i=0; i < EXT2_N_BLOCKS; i++)
3291 blocks[i] = ctx->stashed_inode->i_block[i];
3292 return 0;
3293 }
3294
3295 static errcode_t pass1_read_inode(ext2_filsys fs, ext2_ino_t ino,
3296 struct ext2_inode *inode)
3297 {
3298 e2fsck_t ctx = (e2fsck_t) fs->priv_data;
3299
3300 if ((ino != ctx->stashed_ino) || !ctx->stashed_inode)
3301 return EXT2_ET_CALLBACK_NOTHANDLED;
3302 *inode = *ctx->stashed_inode;
3303 return 0;
3304 }
3305
3306 static errcode_t pass1_write_inode(ext2_filsys fs, ext2_ino_t ino,
3307 struct ext2_inode *inode)
3308 {
3309 e2fsck_t ctx = (e2fsck_t) fs->priv_data;
3310
3311 if ((ino == ctx->stashed_ino) && ctx->stashed_inode &&
3312 (inode != ctx->stashed_inode))
3313 *ctx->stashed_inode = *inode;
3314 return EXT2_ET_CALLBACK_NOTHANDLED;
3315 }
3316
3317 static errcode_t pass1_check_directory(ext2_filsys fs, ext2_ino_t ino)
3318 {
3319 e2fsck_t ctx = (e2fsck_t) fs->priv_data;
3320
3321 if ((ino != ctx->stashed_ino) || !ctx->stashed_inode)
3322 return EXT2_ET_CALLBACK_NOTHANDLED;
3323
3324 if (!LINUX_S_ISDIR(ctx->stashed_inode->i_mode))
3325 return EXT2_ET_NO_DIRECTORY;
3326 return 0;
3327 }
3328
3329 static errcode_t e2fsck_get_alloc_block(ext2_filsys fs, blk64_t goal,
3330 blk64_t *ret)
3331 {
3332 e2fsck_t ctx = (e2fsck_t) fs->priv_data;
3333 errcode_t retval;
3334 blk64_t new_block;
3335
3336 if (ctx->block_found_map) {
3337 retval = ext2fs_new_block2(fs, goal, ctx->block_found_map,
3338 &new_block);
3339 if (retval)
3340 return retval;
3341 if (fs->block_map) {
3342 ext2fs_mark_block_bitmap2(fs->block_map, new_block);
3343 ext2fs_mark_bb_dirty(fs);
3344 }
3345 } else {
3346 if (!fs->block_map) {
3347 retval = ext2fs_read_block_bitmap(fs);
3348 if (retval)
3349 return retval;
3350 }
3351
3352 retval = ext2fs_new_block2(fs, goal, 0, &new_block);
3353 if (retval)
3354 return retval;
3355 }
3356
3357 *ret = new_block;
3358 return (0);
3359 }
3360
3361 static void e2fsck_block_alloc_stats(ext2_filsys fs, blk64_t blk, int inuse)
3362 {
3363 e2fsck_t ctx = (e2fsck_t) fs->priv_data;
3364
3365 /* Never free a critical metadata block */
3366 if (ctx->block_found_map &&
3367 ctx->block_metadata_map &&
3368 inuse < 0 &&
3369 ext2fs_test_block_bitmap2(ctx->block_metadata_map, blk))
3370 return;
3371
3372 if (ctx->block_found_map) {
3373 if (inuse > 0)
3374 ext2fs_mark_block_bitmap2(ctx->block_found_map, blk);
3375 else
3376 ext2fs_unmark_block_bitmap2(ctx->block_found_map, blk);
3377 }
3378 }
3379
3380 void e2fsck_use_inode_shortcuts(e2fsck_t ctx, int use_shortcuts)
3381 {
3382 ext2_filsys fs = ctx->fs;
3383
3384 if (use_shortcuts) {
3385 fs->get_blocks = pass1_get_blocks;
3386 fs->check_directory = pass1_check_directory;
3387 fs->read_inode = pass1_read_inode;
3388 fs->write_inode = pass1_write_inode;
3389 ctx->stashed_ino = 0;
3390 } else {
3391 fs->get_blocks = 0;
3392 fs->check_directory = 0;
3393 fs->read_inode = 0;
3394 fs->write_inode = 0;
3395 }
3396 }
3397
3398 void e2fsck_intercept_block_allocations(e2fsck_t ctx)
3399 {
3400 ext2fs_set_alloc_block_callback(ctx->fs, e2fsck_get_alloc_block, 0);
3401 ext2fs_set_block_alloc_stats_callback(ctx->fs,
3402 e2fsck_block_alloc_stats, 0);
3403 }
Unnamed repository; edit this file 'description' to name the repository.