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 <string.h>
42 #include <time.h>
43 #ifdef HAVE_ERRNO_H
44 #include <errno.h>
45 #endif
46
47 #include "e2fsck.h"
48 #include <ext2fs/ext2_ext_attr.h>
49
50 #include "problem.h"
51
52 #ifdef NO_INLINE_FUNCS
53 #define _INLINE_
54 #else
55 #define _INLINE_ inline
56 #endif
57
58 static int process_block(ext2_filsys fs, blk_t *blocknr,
59 e2_blkcnt_t blockcnt, blk_t ref_blk,
60 int ref_offset, void *priv_data);
61 static int process_bad_block(ext2_filsys fs, blk_t *block_nr,
62 e2_blkcnt_t blockcnt, blk_t ref_blk,
63 int ref_offset, void *priv_data);
64 static void check_blocks(e2fsck_t ctx, struct problem_context *pctx,
65 char *block_buf);
66 static void mark_table_blocks(e2fsck_t ctx);
67 static void alloc_bb_map(e2fsck_t ctx);
68 static void alloc_imagic_map(e2fsck_t ctx);
69 static void mark_inode_bad(e2fsck_t ctx, ino_t ino);
70 static void handle_fs_bad_blocks(e2fsck_t ctx);
71 static void process_inodes(e2fsck_t ctx, char *block_buf);
72 static EXT2_QSORT_TYPE process_inode_cmp(const void *a, const void *b);
73 static errcode_t scan_callback(ext2_filsys fs, ext2_inode_scan scan,
74 dgrp_t group, void * priv_data);
75 static void adjust_extattr_refcount(e2fsck_t ctx, ext2_refcount_t refcount,
76 char *block_buf, int adjust_sign);
77 /* static char *describe_illegal_block(ext2_filsys fs, blk_t block); */
78
79 struct process_block_struct {
80 ext2_ino_t ino;
81 unsigned is_dir:1, is_reg:1, clear:1, suppress:1,
82 fragmented:1, compressed:1, bbcheck:1;
83 blk_t num_blocks;
84 blk_t max_blocks;
85 e2_blkcnt_t last_block;
86 int num_illegal_blocks;
87 blk_t previous_block;
88 struct ext2_inode *inode;
89 struct problem_context *pctx;
90 ext2fs_block_bitmap fs_meta_blocks;
91 e2fsck_t ctx;
92 };
93
94 struct process_inode_block {
95 ext2_ino_t ino;
96 struct ext2_inode inode;
97 };
98
99 struct scan_callback_struct {
100 e2fsck_t ctx;
101 char *block_buf;
102 };
103
104 /*
105 * For the inodes to process list.
106 */
107 static struct process_inode_block *inodes_to_process;
108 static int process_inode_count;
109
110 static __u64 ext2_max_sizes[EXT2_MAX_BLOCK_LOG_SIZE -
111 EXT2_MIN_BLOCK_LOG_SIZE + 1];
112
113 /*
114 * Free all memory allocated by pass1 in preparation for restarting
115 * things.
116 */
unwind_pass1(ext2_filsys fs EXT2FS_ATTR ((unused)))117 static void unwind_pass1(ext2_filsys fs EXT2FS_ATTR((unused)))
118 {
119 ext2fs_free_mem(&inodes_to_process);
120 inodes_to_process = 0;
121 }
122
123 /*
124 * Check to make sure a device inode is real. Returns 1 if the device
125 * checks out, 0 if not.
126 *
127 * Note: this routine is now also used to check FIFO's and Sockets,
128 * since they have the same requirement; the i_block fields should be
129 * zero.
130 */
e2fsck_pass1_check_device_inode(ext2_filsys fs EXT2FS_ATTR ((unused)),struct ext2_inode * inode)131 int e2fsck_pass1_check_device_inode(ext2_filsys fs EXT2FS_ATTR((unused)),
132 struct ext2_inode *inode)
133 {
134 int i;
135
136 /*
137 * If the index flag is set, then this is a bogus
138 * device/fifo/socket
139 */
140 if (inode->i_flags & EXT2_INDEX_FL)
141 return 0;
142
143 /*
144 * We should be able to do the test below all the time, but
145 * because the kernel doesn't forcibly clear the device
146 * inode's additional i_block fields, there are some rare
147 * occasions when a legitimate device inode will have non-zero
148 * additional i_block fields. So for now, we only complain
149 * when the immutable flag is set, which should never happen
150 * for devices. (And that's when the problem is caused, since
151 * you can't set or clear immutable flags for devices.) Once
152 * the kernel has been fixed we can change this...
153 */
154 if (inode->i_flags & (EXT2_IMMUTABLE_FL | EXT2_APPEND_FL)) {
155 for (i=4; i < EXT2_N_BLOCKS; i++)
156 if (inode->i_block[i])
157 return 0;
158 }
159 return 1;
160 }
161
162 /*
163 * Check to make sure a symlink inode is real. Returns 1 if the symlink
164 * checks out, 0 if not.
165 */
e2fsck_pass1_check_symlink(ext2_filsys fs,struct ext2_inode * inode,char * buf)166 int e2fsck_pass1_check_symlink(ext2_filsys fs, struct ext2_inode *inode,
167 char *buf)
168 {
169 unsigned int len;
170 int i;
171 blk_t blocks;
172
173 if ((inode->i_size_high || inode->i_size == 0) ||
174 (inode->i_flags & EXT2_INDEX_FL))
175 return 0;
176
177 blocks = ext2fs_inode_data_blocks(fs, inode);
178 if (blocks) {
179 if ((inode->i_size >= fs->blocksize) ||
180 (blocks != fs->blocksize >> 9) ||
181 (inode->i_block[0] < fs->super->s_first_data_block) ||
182 (inode->i_block[0] >= fs->super->s_blocks_count))
183 return 0;
184
185 for (i = 1; i < EXT2_N_BLOCKS; i++)
186 if (inode->i_block[i])
187 return 0;
188
189 if (io_channel_read_blk(fs->io, inode->i_block[0], 1, buf))
190 return 0;
191
192 len = strnlen(buf, fs->blocksize);
193 if (len == fs->blocksize)
194 return 0;
195 } else {
196 if (inode->i_size >= sizeof(inode->i_block))
197 return 0;
198
199 len = strnlen((char *)inode->i_block, sizeof(inode->i_block));
200 if (len == sizeof(inode->i_block))
201 return 0;
202 }
203 if (len != inode->i_size)
204 return 0;
205 return 1;
206 }
207
208 /*
209 * If the immutable (or append-only) flag is set on the inode, offer
210 * to clear it.
211 */
212 #define BAD_SPECIAL_FLAGS (EXT2_IMMUTABLE_FL | EXT2_APPEND_FL)
check_immutable(e2fsck_t ctx,struct problem_context * pctx)213 static void check_immutable(e2fsck_t ctx, struct problem_context *pctx)
214 {
215 if (!(pctx->inode->i_flags & BAD_SPECIAL_FLAGS))
216 return;
217
218 if (!fix_problem(ctx, PR_1_SET_IMMUTABLE, pctx))
219 return;
220
221 pctx->inode->i_flags &= ~BAD_SPECIAL_FLAGS;
222 e2fsck_write_inode(ctx, pctx->ino, pctx->inode, "pass1");
223 }
224
225 /*
226 * If device, fifo or socket, check size is zero -- if not offer to
227 * clear it
228 */
check_size(e2fsck_t ctx,struct problem_context * pctx)229 static void check_size(e2fsck_t ctx, struct problem_context *pctx)
230 {
231 struct ext2_inode *inode = pctx->inode;
232
233 if ((inode->i_size == 0) && (inode->i_size_high == 0))
234 return;
235
236 if (!fix_problem(ctx, PR_1_SET_NONZSIZE, pctx))
237 return;
238
239 inode->i_size = 0;
240 inode->i_size_high = 0;
241 e2fsck_write_inode(ctx, pctx->ino, pctx->inode, "pass1");
242 }
243
check_ea_in_inode(e2fsck_t ctx,struct problem_context * pctx)244 static void check_ea_in_inode(e2fsck_t ctx, struct problem_context *pctx)
245 {
246 struct ext2_super_block *sb = ctx->fs->super;
247 struct ext2_inode_large *inode;
248 struct ext2_ext_attr_entry *entry;
249 char *start, *end;
250 unsigned int storage_size, remain;
251 int problem = 0;
252
253 inode = (struct ext2_inode_large *) pctx->inode;
254 storage_size = EXT2_INODE_SIZE(ctx->fs->super) - EXT2_GOOD_OLD_INODE_SIZE -
255 inode->i_extra_isize;
256 start = ((char *) inode) + EXT2_GOOD_OLD_INODE_SIZE +
257 inode->i_extra_isize + sizeof(__u32);
258 end = (char *) inode + EXT2_INODE_SIZE(ctx->fs->super);
259 entry = (struct ext2_ext_attr_entry *) start;
260
261 /* scan all entry's headers first */
262
263 /* take finish entry 0UL into account */
264 remain = storage_size - sizeof(__u32);
265
266 while (!EXT2_EXT_IS_LAST_ENTRY(entry)) {
267
268 /* header eats this space */
269 remain -= sizeof(struct ext2_ext_attr_entry);
270
271 /* is attribute name valid? */
272 if (EXT2_EXT_ATTR_SIZE(entry->e_name_len) > remain) {
273 pctx->num = entry->e_name_len;
274 problem = PR_1_ATTR_NAME_LEN;
275 goto fix;
276 }
277
278 /* attribute len eats this space */
279 remain -= EXT2_EXT_ATTR_SIZE(entry->e_name_len);
280
281 /* check value size */
282 if (entry->e_value_size == 0 || entry->e_value_size > remain) {
283 pctx->num = entry->e_value_size;
284 problem = PR_1_ATTR_VALUE_SIZE;
285 goto fix;
286 }
287
288 /* e_value_block must be 0 in inode's ea */
289 if (entry->e_value_block != 0) {
290 pctx->num = entry->e_value_block;
291 problem = PR_1_ATTR_VALUE_BLOCK;
292 goto fix;
293 }
294
295 /* e_hash must be 0 in inode's ea */
296 if (entry->e_hash != 0) {
297 pctx->num = entry->e_hash;
298 problem = PR_1_ATTR_HASH;
299 goto fix;
300 }
301
302 remain -= entry->e_value_size;
303
304 entry = EXT2_EXT_ATTR_NEXT(entry);
305 }
306 fix:
307 /*
308 * it seems like a corruption. it's very unlikely we could repair
309 * EA(s) in automatic fashion -bzzz
310 */
311 #if 0
312 problem = PR_1_ATTR_HASH;
313 #endif
314 if (problem == 0 || !fix_problem(ctx, problem, pctx))
315 return;
316
317 /* simple remove all possible EA(s) */
318 *((__u32 *)start) = 0UL;
319 e2fsck_write_inode_full(ctx, pctx->ino, (struct ext2_inode *) inode,
320 EXT2_INODE_SIZE(sb), "pass1");
321 }
322
check_inode_extra_space(e2fsck_t ctx,struct problem_context * pctx)323 static void check_inode_extra_space(e2fsck_t ctx, struct problem_context *pctx)
324 {
325 struct ext2_super_block *sb = ctx->fs->super;
326 struct ext2_inode_large *inode;
327 __u32 *eamagic;
328 int min, max;
329
330 inode = (struct ext2_inode_large *) pctx->inode;
331 if (EXT2_INODE_SIZE(sb) == EXT2_GOOD_OLD_INODE_SIZE) {
332 /* this isn't large inode. so, nothing to check */
333 return;
334 }
335
336 #if 0
337 printf("inode #%u, i_extra_size %d\n", pctx->ino,
338 inode->i_extra_isize);
339 #endif
340 /* i_extra_isize must cover i_extra_isize + i_pad1 at least */
341 min = sizeof(inode->i_extra_isize) + sizeof(inode->i_pad1);
342 max = EXT2_INODE_SIZE(sb) - EXT2_GOOD_OLD_INODE_SIZE;
343 /*
344 * For now we will allow i_extra_isize to be 0, but really
345 * implementations should never allow i_extra_isize to be 0
346 */
347 if (inode->i_extra_isize &&
348 (inode->i_extra_isize < min || inode->i_extra_isize > max)) {
349 if (!fix_problem(ctx, PR_1_EXTRA_ISIZE, pctx))
350 return;
351 inode->i_extra_isize = min;
352 e2fsck_write_inode_full(ctx, pctx->ino, pctx->inode,
353 EXT2_INODE_SIZE(sb), "pass1");
354 return;
355 }
356
357 eamagic = (__u32 *) (((char *) inode) + EXT2_GOOD_OLD_INODE_SIZE +
358 inode->i_extra_isize);
359 if (*eamagic == EXT2_EXT_ATTR_MAGIC) {
360 /* it seems inode has an extended attribute(s) in body */
361 check_ea_in_inode(ctx, pctx);
362 }
363 }
364
365 /*
366 * Check to see if the inode might really be a directory, despite i_mode
367 *
368 * This is a lot of complexity for something for which I'm not really
369 * convinced happens frequently in the wild. If for any reason this
370 * causes any problems, take this code out.
371 * [tytso:20070331.0827EDT]
372 */
check_is_really_dir(e2fsck_t ctx,struct problem_context * pctx,char * buf)373 static void check_is_really_dir(e2fsck_t ctx, struct problem_context *pctx,
374 char *buf)
375 {
376 struct ext2_inode *inode = pctx->inode;
377 struct ext2_dir_entry *dirent;
378 const char *old_op;
379 errcode_t retval;
380 blk_t blk;
381 int i, not_device = 0;
382
383 if (LINUX_S_ISDIR(inode->i_mode) || LINUX_S_ISREG(inode->i_mode) ||
384 LINUX_S_ISLNK(inode->i_mode) || inode->i_block[0] == 0)
385 return;
386
387 for (i=0; i < EXT2_N_BLOCKS; i++) {
388 blk = inode->i_block[i];
389 if (!blk)
390 continue;
391 if (i >= 4)
392 not_device++;
393
394 if (blk < ctx->fs->super->s_first_data_block ||
395 blk >= ctx->fs->super->s_blocks_count ||
396 ext2fs_fast_test_block_bitmap(ctx->block_found_map, blk))
397 return; /* Invalid block, can't be dir */
398 }
399
400 if ((LINUX_S_ISCHR(inode->i_mode) || LINUX_S_ISBLK(inode->i_mode)) &&
401 (inode->i_links_count == 1) && !not_device)
402 return;
403
404 old_op = ehandler_operation(_("reading directory block"));
405 retval = ext2fs_read_dir_block(ctx->fs, inode->i_block[0], buf);
406 ehandler_operation(0);
407 if (retval)
408 return;
409
410 dirent = (struct ext2_dir_entry *) buf;
411 if (((dirent->name_len & 0xFF) != 1) ||
412 (dirent->name[0] != '.') ||
413 (dirent->inode != pctx->ino) ||
414 (dirent->rec_len < 12) ||
415 (dirent->rec_len % 4) ||
416 (dirent->rec_len >= ctx->fs->blocksize - 12))
417 return;
418
419 dirent = (struct ext2_dir_entry *) (buf + dirent->rec_len);
420 if (((dirent->name_len & 0xFF) != 2) ||
421 (dirent->name[0] != '.') ||
422 (dirent->name[1] != '.') ||
423 (dirent->rec_len < 12) ||
424 (dirent->rec_len % 4))
425 return;
426
427 if (fix_problem(ctx, PR_1_TREAT_AS_DIRECTORY, pctx)) {
428 inode->i_mode = (inode->i_mode & 07777) | LINUX_S_IFDIR;
429 e2fsck_write_inode_full(ctx, pctx->ino, inode,
430 EXT2_INODE_SIZE(ctx->fs->super),
431 "check_is_really_dir");
432 }
433 }
434
e2fsck_setup_tdb_icount(e2fsck_t ctx,int flags,ext2_icount_t * ret)435 extern void e2fsck_setup_tdb_icount(e2fsck_t ctx, int flags,
436 ext2_icount_t *ret)
437 {
438 unsigned int threshold;
439 ext2_ino_t num_dirs;
440 errcode_t retval;
441 char *tdb_dir;
442 int enable;
443
444 *ret = 0;
445
446 profile_get_string(ctx->profile, "scratch_files", "directory", 0, 0,
447 &tdb_dir);
448 profile_get_uint(ctx->profile, "scratch_files",
449 "numdirs_threshold", 0, 0, &threshold);
450 profile_get_boolean(ctx->profile, "scratch_files",
451 "icount", 0, 1, &enable);
452
453 retval = ext2fs_get_num_dirs(ctx->fs, &num_dirs);
454 if (retval)
455 num_dirs = 1024; /* Guess */
456
457 if (!enable || !tdb_dir || access(tdb_dir, W_OK) ||
458 (threshold && num_dirs <= threshold))
459 return;
460
461 retval = ext2fs_create_icount_tdb(ctx->fs, tdb_dir, flags, ret);
462 if (retval)
463 *ret = 0;
464 }
465
e2fsck_pass1(e2fsck_t ctx)466 void e2fsck_pass1(e2fsck_t ctx)
467 {
468 int i;
469 __u64 max_sizes;
470 ext2_filsys fs = ctx->fs;
471 ext2_ino_t ino;
472 struct ext2_inode *inode;
473 ext2_inode_scan scan;
474 char *block_buf;
475 #ifdef RESOURCE_TRACK
476 struct resource_track rtrack;
477 #endif
478 unsigned char frag, fsize;
479 struct problem_context pctx;
480 struct scan_callback_struct scan_struct;
481 struct ext2_super_block *sb = ctx->fs->super;
482 const char *old_op;
483 int imagic_fs;
484 int busted_fs_time = 0;
485 int inode_size;
486
487 #ifdef RESOURCE_TRACK
488 init_resource_track(&rtrack);
489 #endif
490 clear_problem_context(&pctx);
491
492 if (!(ctx->options & E2F_OPT_PREEN))
493 fix_problem(ctx, PR_1_PASS_HEADER, &pctx);
494
495 if ((fs->super->s_feature_compat & EXT2_FEATURE_COMPAT_DIR_INDEX) &&
496 !(ctx->options & E2F_OPT_NO)) {
497 if (ext2fs_u32_list_create(&ctx->dirs_to_hash, 50))
498 ctx->dirs_to_hash = 0;
499 }
500
501 #ifdef MTRACE
502 mtrace_print("Pass 1");
503 #endif
504
505 #define EXT2_BPP(bits) (1ULL << ((bits) - 2))
506
507 for (i = EXT2_MIN_BLOCK_LOG_SIZE; i <= EXT2_MAX_BLOCK_LOG_SIZE; i++) {
508 max_sizes = EXT2_NDIR_BLOCKS + EXT2_BPP(i);
509 max_sizes = max_sizes + EXT2_BPP(i) * EXT2_BPP(i);
510 max_sizes = max_sizes + EXT2_BPP(i) * EXT2_BPP(i) * EXT2_BPP(i);
511 max_sizes = (max_sizes * (1UL << i)) - 1;
512 ext2_max_sizes[i - EXT2_MIN_BLOCK_LOG_SIZE] = max_sizes;
513 }
514 #undef EXT2_BPP
515
516 imagic_fs = (sb->s_feature_compat & EXT2_FEATURE_COMPAT_IMAGIC_INODES);
517
518 /*
519 * Allocate bitmaps structures
520 */
521 pctx.errcode = ext2fs_allocate_inode_bitmap(fs, _("in-use inode map"),
522 &ctx->inode_used_map);
523 if (pctx.errcode) {
524 pctx.num = 1;
525 fix_problem(ctx, PR_1_ALLOCATE_IBITMAP_ERROR, &pctx);
526 ctx->flags |= E2F_FLAG_ABORT;
527 return;
528 }
529 pctx.errcode = ext2fs_allocate_inode_bitmap(fs,
530 _("directory inode map"), &ctx->inode_dir_map);
531 if (pctx.errcode) {
532 pctx.num = 2;
533 fix_problem(ctx, PR_1_ALLOCATE_IBITMAP_ERROR, &pctx);
534 ctx->flags |= E2F_FLAG_ABORT;
535 return;
536 }
537 pctx.errcode = ext2fs_allocate_inode_bitmap(fs,
538 _("regular file inode map"), &ctx->inode_reg_map);
539 if (pctx.errcode) {
540 pctx.num = 6;
541 fix_problem(ctx, PR_1_ALLOCATE_IBITMAP_ERROR, &pctx);
542 ctx->flags |= E2F_FLAG_ABORT;
543 return;
544 }
545 pctx.errcode = ext2fs_allocate_block_bitmap(fs, _("in-use block map"),
546 &ctx->block_found_map);
547 if (pctx.errcode) {
548 pctx.num = 1;
549 fix_problem(ctx, PR_1_ALLOCATE_BBITMAP_ERROR, &pctx);
550 ctx->flags |= E2F_FLAG_ABORT;
551 return;
552 }
553 e2fsck_setup_tdb_icount(ctx, 0, &ctx->inode_link_info);
554 if (!ctx->inode_link_info)
555 pctx.errcode = ext2fs_create_icount2(fs, 0, 0, 0,
556 &ctx->inode_link_info);
557 if (pctx.errcode) {
558 fix_problem(ctx, PR_1_ALLOCATE_ICOUNT, &pctx);
559 ctx->flags |= E2F_FLAG_ABORT;
560 return;
561 }
562 inode_size = EXT2_INODE_SIZE(fs->super);
563 inode = (struct ext2_inode *)
564 e2fsck_allocate_memory(ctx, inode_size, "scratch inode");
565
566 inodes_to_process = (struct process_inode_block *)
567 e2fsck_allocate_memory(ctx,
568 (ctx->process_inode_size *
569 sizeof(struct process_inode_block)),
570 "array of inodes to process");
571 process_inode_count = 0;
572
573 pctx.errcode = ext2fs_init_dblist(fs, 0);
574 if (pctx.errcode) {
575 fix_problem(ctx, PR_1_ALLOCATE_DBCOUNT, &pctx);
576 ctx->flags |= E2F_FLAG_ABORT;
577 ext2fs_free_mem(&inode);
578 return;
579 }
580
581 /*
582 * If the last orphan field is set, clear it, since the pass1
583 * processing will automatically find and clear the orphans.
584 * In the future, we may want to try using the last_orphan
585 * linked list ourselves, but for now, we clear it so that the
586 * ext3 mount code won't get confused.
587 */
588 if (!(ctx->options & E2F_OPT_READONLY)) {
589 if (fs->super->s_last_orphan) {
590 fs->super->s_last_orphan = 0;
591 ext2fs_mark_super_dirty(fs);
592 }
593 }
594
595 mark_table_blocks(ctx);
596 block_buf = (char *) e2fsck_allocate_memory(ctx, fs->blocksize * 3,
597 "block interate buffer");
598 e2fsck_use_inode_shortcuts(ctx, 1);
599 old_op = ehandler_operation(_("opening inode scan"));
600 pctx.errcode = ext2fs_open_inode_scan(fs, ctx->inode_buffer_blocks,
601 &scan);
602 ehandler_operation(old_op);
603 if (pctx.errcode) {
604 fix_problem(ctx, PR_1_ISCAN_ERROR, &pctx);
605 ctx->flags |= E2F_FLAG_ABORT;
606 ext2fs_free_mem(&block_buf);
607 ext2fs_free_mem(&inode);
608 return;
609 }
610 ext2fs_inode_scan_flags(scan, EXT2_SF_SKIP_MISSING_ITABLE, 0);
611 ctx->stashed_inode = inode;
612 scan_struct.ctx = ctx;
613 scan_struct.block_buf = block_buf;
614 ext2fs_set_inode_callback(scan, scan_callback, &scan_struct);
615 if (ctx->progress)
616 if ((ctx->progress)(ctx, 1, 0, ctx->fs->group_desc_count))
617 return;
618 if ((fs->super->s_wtime < fs->super->s_inodes_count) ||
619 (fs->super->s_mtime < fs->super->s_inodes_count))
620 busted_fs_time = 1;
621
622 while (1) {
623 old_op = ehandler_operation(_("getting next inode from scan"));
624 pctx.errcode = ext2fs_get_next_inode_full(scan, &ino,
625 inode, inode_size);
626 ehandler_operation(old_op);
627 if (ctx->flags & E2F_FLAG_SIGNAL_MASK)
628 return;
629 if (pctx.errcode == EXT2_ET_BAD_BLOCK_IN_INODE_TABLE) {
630 if (!ctx->inode_bb_map)
631 alloc_bb_map(ctx);
632 ext2fs_mark_inode_bitmap(ctx->inode_bb_map, ino);
633 ext2fs_mark_inode_bitmap(ctx->inode_used_map, ino);
634 continue;
635 }
636 if (pctx.errcode) {
637 fix_problem(ctx, PR_1_ISCAN_ERROR, &pctx);
638 ctx->flags |= E2F_FLAG_ABORT;
639 return;
640 }
641 if (!ino)
642 break;
643 pctx.ino = ino;
644 pctx.inode = inode;
645 ctx->stashed_ino = ino;
646 if (inode->i_links_count) {
647 pctx.errcode = ext2fs_icount_store(ctx->inode_link_info,
648 ino, inode->i_links_count);
649 if (pctx.errcode) {
650 pctx.num = inode->i_links_count;
651 fix_problem(ctx, PR_1_ICOUNT_STORE, &pctx);
652 ctx->flags |= E2F_FLAG_ABORT;
653 return;
654 }
655 }
656 if (ino == EXT2_BAD_INO) {
657 struct process_block_struct pb;
658
659 pctx.errcode = ext2fs_copy_bitmap(ctx->block_found_map,
660 &pb.fs_meta_blocks);
661 if (pctx.errcode) {
662 pctx.num = 4;
663 fix_problem(ctx, PR_1_ALLOCATE_BBITMAP_ERROR, &pctx);
664 ctx->flags |= E2F_FLAG_ABORT;
665 return;
666 }
667 pb.ino = EXT2_BAD_INO;
668 pb.num_blocks = pb.last_block = 0;
669 pb.num_illegal_blocks = 0;
670 pb.suppress = 0; pb.clear = 0; pb.is_dir = 0;
671 pb.is_reg = 0; pb.fragmented = 0; pb.bbcheck = 0;
672 pb.inode = inode;
673 pb.pctx = &pctx;
674 pb.ctx = ctx;
675 pctx.errcode = ext2fs_block_iterate2(fs, ino, 0,
676 block_buf, process_bad_block, &pb);
677 ext2fs_free_block_bitmap(pb.fs_meta_blocks);
678 if (pctx.errcode) {
679 fix_problem(ctx, PR_1_BLOCK_ITERATE, &pctx);
680 ctx->flags |= E2F_FLAG_ABORT;
681 return;
682 }
683 if (pb.bbcheck)
684 if (!fix_problem(ctx, PR_1_BBINODE_BAD_METABLOCK_PROMPT, &pctx)) {
685 ctx->flags |= E2F_FLAG_ABORT;
686 return;
687 }
688 ext2fs_mark_inode_bitmap(ctx->inode_used_map, ino);
689 clear_problem_context(&pctx);
690 continue;
691 } else if (ino == EXT2_ROOT_INO) {
692 /*
693 * Make sure the root inode is a directory; if
694 * not, offer to clear it. It will be
695 * regnerated in pass #3.
696 */
697 if (!LINUX_S_ISDIR(inode->i_mode)) {
698 if (fix_problem(ctx, PR_1_ROOT_NO_DIR, &pctx)) {
699 inode->i_dtime = ctx->now;
700 inode->i_links_count = 0;
701 ext2fs_icount_store(ctx->inode_link_info,
702 ino, 0);
703 e2fsck_write_inode(ctx, ino, inode,
704 "pass1");
705 }
706
707 }
708 /*
709 * If dtime is set, offer to clear it. mke2fs
710 * version 0.2b created filesystems with the
711 * dtime field set for the root and lost+found
712 * directories. We won't worry about
713 * /lost+found, since that can be regenerated
714 * easily. But we will fix the root directory
715 * as a special case.
716 */
717 if (inode->i_dtime && inode->i_links_count) {
718 if (fix_problem(ctx, PR_1_ROOT_DTIME, &pctx)) {
719 inode->i_dtime = 0;
720 e2fsck_write_inode(ctx, ino, inode,
721 "pass1");
722 }
723 }
724 } else if (ino == EXT2_JOURNAL_INO) {
725 ext2fs_mark_inode_bitmap(ctx->inode_used_map, ino);
726 if (fs->super->s_journal_inum == EXT2_JOURNAL_INO) {
727 if (!LINUX_S_ISREG(inode->i_mode) &&
728 fix_problem(ctx, PR_1_JOURNAL_BAD_MODE,
729 &pctx)) {
730 inode->i_mode = LINUX_S_IFREG;
731 e2fsck_write_inode(ctx, ino, inode,
732 "pass1");
733 }
734 check_blocks(ctx, &pctx, block_buf);
735 continue;
736 }
737 if ((inode->i_links_count || inode->i_blocks ||
738 inode->i_blocks || inode->i_block[0]) &&
739 fix_problem(ctx, PR_1_JOURNAL_INODE_NOT_CLEAR,
740 &pctx)) {
741 memset(inode, 0, inode_size);
742 ext2fs_icount_store(ctx->inode_link_info,
743 ino, 0);
744 e2fsck_write_inode_full(ctx, ino, inode,
745 inode_size, "pass1");
746 }
747 } else if (ino < EXT2_FIRST_INODE(fs->super)) {
748 int problem = 0;
749
750 ext2fs_mark_inode_bitmap(ctx->inode_used_map, ino);
751 if (ino == EXT2_BOOT_LOADER_INO) {
752 if (LINUX_S_ISDIR(inode->i_mode))
753 problem = PR_1_RESERVED_BAD_MODE;
754 } else if (ino == EXT2_RESIZE_INO) {
755 if (inode->i_mode &&
756 !LINUX_S_ISREG(inode->i_mode))
757 problem = PR_1_RESERVED_BAD_MODE;
758 } else {
759 if (inode->i_mode != 0)
760 problem = PR_1_RESERVED_BAD_MODE;
761 }
762 if (problem) {
763 if (fix_problem(ctx, problem, &pctx)) {
764 inode->i_mode = 0;
765 e2fsck_write_inode(ctx, ino, inode,
766 "pass1");
767 }
768 }
769 check_blocks(ctx, &pctx, block_buf);
770 continue;
771 }
772 /*
773 * Check for inodes who might have been part of the
774 * orphaned list linked list. They should have gotten
775 * dealt with by now, unless the list had somehow been
776 * corrupted.
777 *
778 * FIXME: In the future, inodes which are still in use
779 * (and which are therefore) pending truncation should
780 * be handled specially. Right now we just clear the
781 * dtime field, and the normal e2fsck handling of
782 * inodes where i_size and the inode blocks are
783 * inconsistent is to fix i_size, instead of releasing
784 * the extra blocks. This won't catch the inodes that
785 * was at the end of the orphan list, but it's better
786 * than nothing. The right answer is that there
787 * shouldn't be any bugs in the orphan list handling. :-)
788 */
789 if (inode->i_dtime && !busted_fs_time &&
790 inode->i_dtime < ctx->fs->super->s_inodes_count) {
791 if (fix_problem(ctx, PR_1_LOW_DTIME, &pctx)) {
792 inode->i_dtime = inode->i_links_count ?
793 0 : ctx->now;
794 e2fsck_write_inode(ctx, ino, inode,
795 "pass1");
796 }
797 }
798
799 /*
800 * This code assumes that deleted inodes have
801 * i_links_count set to 0.
802 */
803 if (!inode->i_links_count) {
804 if (!inode->i_dtime && inode->i_mode) {
805 if (fix_problem(ctx,
806 PR_1_ZERO_DTIME, &pctx)) {
807 inode->i_dtime = ctx->now;
808 e2fsck_write_inode(ctx, ino, inode,
809 "pass1");
810 }
811 }
812 continue;
813 }
814 /*
815 * n.b. 0.3c ext2fs code didn't clear i_links_count for
816 * deleted files. Oops.
817 *
818 * Since all new ext2 implementations get this right,
819 * we now assume that the case of non-zero
820 * i_links_count and non-zero dtime means that we
821 * should keep the file, not delete it.
822 *
823 */
824 if (inode->i_dtime) {
825 if (fix_problem(ctx, PR_1_SET_DTIME, &pctx)) {
826 inode->i_dtime = 0;
827 e2fsck_write_inode(ctx, ino, inode, "pass1");
828 }
829 }
830
831 ext2fs_mark_inode_bitmap(ctx->inode_used_map, ino);
832 switch (fs->super->s_creator_os) {
833 case EXT2_OS_HURD:
834 frag = inode->osd2.hurd2.h_i_frag;
835 fsize = inode->osd2.hurd2.h_i_fsize;
836 break;
837 case EXT2_OS_MASIX:
838 frag = inode->osd2.masix2.m_i_frag;
839 fsize = inode->osd2.masix2.m_i_fsize;
840 break;
841 default:
842 frag = fsize = 0;
843 }
844
845 if (inode->i_faddr || frag || fsize ||
846 (LINUX_S_ISDIR(inode->i_mode) && inode->i_dir_acl))
847 mark_inode_bad(ctx, ino);
848 if ((fs->super->s_creator_os == EXT2_OS_LINUX) &&
849 !(fs->super->s_feature_ro_compat &
850 EXT4_FEATURE_RO_COMPAT_HUGE_FILE) &&
851 (inode->osd2.linux2.l_i_blocks_hi != 0))
852 mark_inode_bad(ctx, ino);
853 if (inode->i_flags & EXT2_IMAGIC_FL) {
854 if (imagic_fs) {
855 if (!ctx->inode_imagic_map)
856 alloc_imagic_map(ctx);
857 ext2fs_mark_inode_bitmap(ctx->inode_imagic_map,
858 ino);
859 } else {
860 if (fix_problem(ctx, PR_1_SET_IMAGIC, &pctx)) {
861 inode->i_flags &= ~EXT2_IMAGIC_FL;
862 e2fsck_write_inode(ctx, ino,
863 inode, "pass1");
864 }
865 }
866 }
867
868 check_inode_extra_space(ctx, &pctx);
869 check_is_really_dir(ctx, &pctx, block_buf);
870
871 if (LINUX_S_ISDIR(inode->i_mode)) {
872 ext2fs_mark_inode_bitmap(ctx->inode_dir_map, ino);
873 e2fsck_add_dir_info(ctx, ino, 0);
874 ctx->fs_directory_count++;
875 } else if (LINUX_S_ISREG (inode->i_mode)) {
876 ext2fs_mark_inode_bitmap(ctx->inode_reg_map, ino);
877 ctx->fs_regular_count++;
878 } else if (LINUX_S_ISCHR (inode->i_mode) &&
879 e2fsck_pass1_check_device_inode(fs, inode)) {
880 check_immutable(ctx, &pctx);
881 check_size(ctx, &pctx);
882 ctx->fs_chardev_count++;
883 } else if (LINUX_S_ISBLK (inode->i_mode) &&
884 e2fsck_pass1_check_device_inode(fs, inode)) {
885 check_immutable(ctx, &pctx);
886 check_size(ctx, &pctx);
887 ctx->fs_blockdev_count++;
888 } else if (LINUX_S_ISLNK (inode->i_mode) &&
889 e2fsck_pass1_check_symlink(fs, inode, block_buf)) {
890 check_immutable(ctx, &pctx);
891 ctx->fs_symlinks_count++;
892 if (ext2fs_inode_data_blocks(fs, inode) == 0) {
893 ctx->fs_fast_symlinks_count++;
894 check_blocks(ctx, &pctx, block_buf);
895 continue;
896 }
897 }
898 else if (LINUX_S_ISFIFO (inode->i_mode) &&
899 e2fsck_pass1_check_device_inode(fs, inode)) {
900 check_immutable(ctx, &pctx);
901 check_size(ctx, &pctx);
902 ctx->fs_fifo_count++;
903 } else if ((LINUX_S_ISSOCK (inode->i_mode)) &&
904 e2fsck_pass1_check_device_inode(fs, inode)) {
905 check_immutable(ctx, &pctx);
906 check_size(ctx, &pctx);
907 ctx->fs_sockets_count++;
908 } else
909 mark_inode_bad(ctx, ino);
910 if (inode->i_block[EXT2_IND_BLOCK])
911 ctx->fs_ind_count++;
912 if (inode->i_block[EXT2_DIND_BLOCK])
913 ctx->fs_dind_count++;
914 if (inode->i_block[EXT2_TIND_BLOCK])
915 ctx->fs_tind_count++;
916 if (inode->i_block[EXT2_IND_BLOCK] ||
917 inode->i_block[EXT2_DIND_BLOCK] ||
918 inode->i_block[EXT2_TIND_BLOCK] ||
919 inode->i_file_acl) {
920 inodes_to_process[process_inode_count].ino = ino;
921 inodes_to_process[process_inode_count].inode = *inode;
922 process_inode_count++;
923 } else
924 check_blocks(ctx, &pctx, block_buf);
925
926 if (ctx->flags & E2F_FLAG_SIGNAL_MASK)
927 return;
928
929 if (process_inode_count >= ctx->process_inode_size) {
930 process_inodes(ctx, block_buf);
931
932 if (ctx->flags & E2F_FLAG_SIGNAL_MASK)
933 return;
934 }
935 }
936 process_inodes(ctx, block_buf);
937 ext2fs_close_inode_scan(scan);
938
939 /*
940 * If any extended attribute blocks' reference counts need to
941 * be adjusted, either up (ctx->refcount_extra), or down
942 * (ctx->refcount), then fix them.
943 */
944 if (ctx->refcount) {
945 adjust_extattr_refcount(ctx, ctx->refcount, block_buf, -1);
946 ea_refcount_free(ctx->refcount);
947 ctx->refcount = 0;
948 }
949 if (ctx->refcount_extra) {
950 adjust_extattr_refcount(ctx, ctx->refcount_extra,
951 block_buf, +1);
952 ea_refcount_free(ctx->refcount_extra);
953 ctx->refcount_extra = 0;
954 }
955
956 if (ctx->invalid_bitmaps)
957 handle_fs_bad_blocks(ctx);
958
959 /* We don't need the block_ea_map any more */
960 if (ctx->block_ea_map) {
961 ext2fs_free_block_bitmap(ctx->block_ea_map);
962 ctx->block_ea_map = 0;
963 }
964
965 if (ctx->flags & E2F_FLAG_RESIZE_INODE) {
966 ext2fs_block_bitmap save_bmap;
967
968 save_bmap = fs->block_map;
969 fs->block_map = ctx->block_found_map;
970 clear_problem_context(&pctx);
971 pctx.errcode = ext2fs_create_resize_inode(fs);
972 if (pctx.errcode) {
973 fix_problem(ctx, PR_1_RESIZE_INODE_CREATE, &pctx);
974 /* Should never get here */
975 ctx->flags |= E2F_FLAG_ABORT;
976 return;
977 }
978 e2fsck_read_inode(ctx, EXT2_RESIZE_INO, inode,
979 "recreate inode");
980 inode->i_mtime = ctx->now;
981 e2fsck_write_inode(ctx, EXT2_RESIZE_INO, inode,
982 "recreate inode");
983 fs->block_map = save_bmap;
984 ctx->flags &= ~E2F_FLAG_RESIZE_INODE;
985 }
986
987 if (ctx->flags & E2F_FLAG_RESTART) {
988 /*
989 * Only the master copy of the superblock and block
990 * group descriptors are going to be written during a
991 * restart, so set the superblock to be used to be the
992 * master superblock.
993 */
994 ctx->use_superblock = 0;
995 unwind_pass1(fs);
996 goto endit;
997 }
998
999 if (ctx->block_dup_map) {
1000 if (ctx->options & E2F_OPT_PREEN) {
1001 clear_problem_context(&pctx);
1002 fix_problem(ctx, PR_1_DUP_BLOCKS_PREENSTOP, &pctx);
1003 }
1004 e2fsck_pass1_dupblocks(ctx, block_buf);
1005 }
1006 ext2fs_free_mem(&inodes_to_process);
1007 endit:
1008 e2fsck_use_inode_shortcuts(ctx, 0);
1009
1010 ext2fs_free_mem(&block_buf);
1011 ext2fs_free_mem(&inode);
1012
1013 #ifdef RESOURCE_TRACK
1014 if (ctx->options & E2F_OPT_TIME2) {
1015 e2fsck_clear_progbar(ctx);
1016 print_resource_track(_("Pass 1"), &rtrack);
1017 }
1018 #endif
1019 }
1020
1021 /*
1022 * When the inode_scan routines call this callback at the end of the
1023 * glock group, call process_inodes.
1024 */
scan_callback(ext2_filsys fs,ext2_inode_scan scan EXT2FS_ATTR ((unused)),dgrp_t group,void * priv_data)1025 static errcode_t scan_callback(ext2_filsys fs,
1026 ext2_inode_scan scan EXT2FS_ATTR((unused)),
1027 dgrp_t group, void * priv_data)
1028 {
1029 struct scan_callback_struct *scan_struct;
1030 e2fsck_t ctx;
1031
1032 scan_struct = (struct scan_callback_struct *) priv_data;
1033 ctx = scan_struct->ctx;
1034
1035 process_inodes((e2fsck_t) fs->priv_data, scan_struct->block_buf);
1036
1037 if (ctx->progress)
1038 if ((ctx->progress)(ctx, 1, group+1,
1039 ctx->fs->group_desc_count))
1040 return EXT2_ET_CANCEL_REQUESTED;
1041
1042 return 0;
1043 }
1044
1045 /*
1046 * Process the inodes in the "inodes to process" list.
1047 */
process_inodes(e2fsck_t ctx,char * block_buf)1048 static void process_inodes(e2fsck_t ctx, char *block_buf)
1049 {
1050 int i;
1051 struct ext2_inode *old_stashed_inode;
1052 ext2_ino_t old_stashed_ino;
1053 const char *old_operation;
1054 char buf[80];
1055 struct problem_context pctx;
1056
1057 #if 0
1058 printf("begin process_inodes: ");
1059 #endif
1060 if (process_inode_count == 0)
1061 return;
1062 old_operation = ehandler_operation(0);
1063 old_stashed_inode = ctx->stashed_inode;
1064 old_stashed_ino = ctx->stashed_ino;
1065 qsort(inodes_to_process, process_inode_count,
1066 sizeof(struct process_inode_block), process_inode_cmp);
1067 clear_problem_context(&pctx);
1068 for (i=0; i < process_inode_count; i++) {
1069 pctx.inode = ctx->stashed_inode = &inodes_to_process[i].inode;
1070 pctx.ino = ctx->stashed_ino = inodes_to_process[i].ino;
1071
1072 #if 0
1073 printf("%u ", pctx.ino);
1074 #endif
1075 sprintf(buf, _("reading indirect blocks of inode %u"),
1076 pctx.ino);
1077 ehandler_operation(buf);
1078 check_blocks(ctx, &pctx, block_buf);
1079 if (ctx->flags & E2F_FLAG_SIGNAL_MASK)
1080 break;
1081 }
1082 ctx->stashed_inode = old_stashed_inode;
1083 ctx->stashed_ino = old_stashed_ino;
1084 process_inode_count = 0;
1085 #if 0
1086 printf("end process inodes\n");
1087 #endif
1088 ehandler_operation(old_operation);
1089 }
1090
process_inode_cmp(const void * a,const void * b)1091 static EXT2_QSORT_TYPE process_inode_cmp(const void *a, const void *b)
1092 {
1093 const struct process_inode_block *ib_a =
1094 (const struct process_inode_block *) a;
1095 const struct process_inode_block *ib_b =
1096 (const struct process_inode_block *) b;
1097 int ret;
1098
1099 ret = (ib_a->inode.i_block[EXT2_IND_BLOCK] -
1100 ib_b->inode.i_block[EXT2_IND_BLOCK]);
1101 if (ret == 0)
1102 ret = ib_a->inode.i_file_acl - ib_b->inode.i_file_acl;
1103 return ret;
1104 }
1105
1106 /*
1107 * Mark an inode as being bad in some what
1108 */
mark_inode_bad(e2fsck_t ctx,ino_t ino)1109 static void mark_inode_bad(e2fsck_t ctx, ino_t ino)
1110 {
1111 struct problem_context pctx;
1112
1113 if (!ctx->inode_bad_map) {
1114 clear_problem_context(&pctx);
1115
1116 pctx.errcode = ext2fs_allocate_inode_bitmap(ctx->fs,
1117 _("bad inode map"), &ctx->inode_bad_map);
1118 if (pctx.errcode) {
1119 pctx.num = 3;
1120 fix_problem(ctx, PR_1_ALLOCATE_IBITMAP_ERROR, &pctx);
1121 /* Should never get here */
1122 ctx->flags |= E2F_FLAG_ABORT;
1123 return;
1124 }
1125 }
1126 ext2fs_mark_inode_bitmap(ctx->inode_bad_map, ino);
1127 }
1128
1129
1130 /*
1131 * This procedure will allocate the inode "bb" (badblock) map table
1132 */
alloc_bb_map(e2fsck_t ctx)1133 static void alloc_bb_map(e2fsck_t ctx)
1134 {
1135 struct problem_context pctx;
1136
1137 clear_problem_context(&pctx);
1138 pctx.errcode = ext2fs_allocate_inode_bitmap(ctx->fs,
1139 _("inode in bad block map"),
1140 &ctx->inode_bb_map);
1141 if (pctx.errcode) {
1142 pctx.num = 4;
1143 fix_problem(ctx, PR_1_ALLOCATE_IBITMAP_ERROR, &pctx);
1144 /* Should never get here */
1145 ctx->flags |= E2F_FLAG_ABORT;
1146 return;
1147 }
1148 }
1149
1150 /*
1151 * This procedure will allocate the inode imagic table
1152 */
alloc_imagic_map(e2fsck_t ctx)1153 static void alloc_imagic_map(e2fsck_t ctx)
1154 {
1155 struct problem_context pctx;
1156
1157 clear_problem_context(&pctx);
1158 pctx.errcode = ext2fs_allocate_inode_bitmap(ctx->fs,
1159 _("imagic inode map"),
1160 &ctx->inode_imagic_map);
1161 if (pctx.errcode) {
1162 pctx.num = 5;
1163 fix_problem(ctx, PR_1_ALLOCATE_IBITMAP_ERROR, &pctx);
1164 /* Should never get here */
1165 ctx->flags |= E2F_FLAG_ABORT;
1166 return;
1167 }
1168 }
1169
1170 /*
1171 * Marks a block as in use, setting the dup_map if it's been set
1172 * already. Called by process_block and process_bad_block.
1173 *
1174 * WARNING: Assumes checks have already been done to make sure block
1175 * is valid. This is true in both process_block and process_bad_block.
1176 */
mark_block_used(e2fsck_t ctx,blk_t block)1177 static _INLINE_ void mark_block_used(e2fsck_t ctx, blk_t block)
1178 {
1179 struct problem_context pctx;
1180
1181 clear_problem_context(&pctx);
1182
1183 if (ext2fs_fast_test_block_bitmap(ctx->block_found_map, block)) {
1184 if (!ctx->block_dup_map) {
1185 pctx.errcode = ext2fs_allocate_block_bitmap(ctx->fs,
1186 _("multiply claimed block map"),
1187 &ctx->block_dup_map);
1188 if (pctx.errcode) {
1189 pctx.num = 3;
1190 fix_problem(ctx, PR_1_ALLOCATE_BBITMAP_ERROR,
1191 &pctx);
1192 /* Should never get here */
1193 ctx->flags |= E2F_FLAG_ABORT;
1194 return;
1195 }
1196 }
1197 ext2fs_fast_mark_block_bitmap(ctx->block_dup_map, block);
1198 } else {
1199 ext2fs_fast_mark_block_bitmap(ctx->block_found_map, block);
1200 }
1201 }
1202
1203 /*
1204 * Adjust the extended attribute block's reference counts at the end
1205 * of pass 1, either by subtracting out references for EA blocks that
1206 * are still referenced in ctx->refcount, or by adding references for
1207 * EA blocks that had extra references as accounted for in
1208 * ctx->refcount_extra.
1209 */
adjust_extattr_refcount(e2fsck_t ctx,ext2_refcount_t refcount,char * block_buf,int adjust_sign)1210 static void adjust_extattr_refcount(e2fsck_t ctx, ext2_refcount_t refcount,
1211 char *block_buf, int adjust_sign)
1212 {
1213 struct ext2_ext_attr_header *header;
1214 struct problem_context pctx;
1215 ext2_filsys fs = ctx->fs;
1216 blk_t blk;
1217 __u32 should_be;
1218 int count;
1219
1220 clear_problem_context(&pctx);
1221
1222 ea_refcount_intr_begin(refcount);
1223 while (1) {
1224 if ((blk = ea_refcount_intr_next(refcount, &count)) == 0)
1225 break;
1226 pctx.blk = blk;
1227 pctx.errcode = ext2fs_read_ext_attr(fs, blk, block_buf);
1228 if (pctx.errcode) {
1229 fix_problem(ctx, PR_1_EXTATTR_READ_ABORT, &pctx);
1230 return;
1231 }
1232 header = (struct ext2_ext_attr_header *) block_buf;
1233 pctx.blkcount = header->h_refcount;
1234 should_be = header->h_refcount + adjust_sign * count;
1235 pctx.num = should_be;
1236 if (fix_problem(ctx, PR_1_EXTATTR_REFCOUNT, &pctx)) {
1237 header->h_refcount = should_be;
1238 pctx.errcode = ext2fs_write_ext_attr(fs, blk,
1239 block_buf);
1240 if (pctx.errcode) {
1241 fix_problem(ctx, PR_1_EXTATTR_WRITE, &pctx);
1242 continue;
1243 }
1244 }
1245 }
1246 }
1247
1248 /*
1249 * Handle processing the extended attribute blocks
1250 */
check_ext_attr(e2fsck_t ctx,struct problem_context * pctx,char * block_buf)1251 static int check_ext_attr(e2fsck_t ctx, struct problem_context *pctx,
1252 char *block_buf)
1253 {
1254 ext2_filsys fs = ctx->fs;
1255 ext2_ino_t ino = pctx->ino;
1256 struct ext2_inode *inode = pctx->inode;
1257 blk_t blk;
1258 char * end;
1259 struct ext2_ext_attr_header *header;
1260 struct ext2_ext_attr_entry *entry;
1261 int count;
1262 region_t region = 0;
1263
1264 blk = inode->i_file_acl;
1265 if (blk == 0)
1266 return 0;
1267
1268 /*
1269 * If the Extended attribute flag isn't set, then a non-zero
1270 * file acl means that the inode is corrupted.
1271 *
1272 * Or if the extended attribute block is an invalid block,
1273 * then the inode is also corrupted.
1274 */
1275 if (!(fs->super->s_feature_compat & EXT2_FEATURE_COMPAT_EXT_ATTR) ||
1276 (blk < fs->super->s_first_data_block) ||
1277 (blk >= fs->super->s_blocks_count)) {
1278 mark_inode_bad(ctx, ino);
1279 return 0;
1280 }
1281
1282 /* If ea bitmap hasn't been allocated, create it */
1283 if (!ctx->block_ea_map) {
1284 pctx->errcode = ext2fs_allocate_block_bitmap(fs,
1285 _("ext attr block map"),
1286 &ctx->block_ea_map);
1287 if (pctx->errcode) {
1288 pctx->num = 2;
1289 fix_problem(ctx, PR_1_ALLOCATE_BBITMAP_ERROR, pctx);
1290 ctx->flags |= E2F_FLAG_ABORT;
1291 return 0;
1292 }
1293 }
1294
1295 /* Create the EA refcount structure if necessary */
1296 if (!ctx->refcount) {
1297 pctx->errcode = ea_refcount_create(0, &ctx->refcount);
1298 if (pctx->errcode) {
1299 pctx->num = 1;
1300 fix_problem(ctx, PR_1_ALLOCATE_REFCOUNT, pctx);
1301 ctx->flags |= E2F_FLAG_ABORT;
1302 return 0;
1303 }
1304 }
1305
1306 #if 0
1307 /* Debugging text */
1308 printf("Inode %u has EA block %u\n", ino, blk);
1309 #endif
1310
1311 /* Have we seen this EA block before? */
1312 if (ext2fs_fast_test_block_bitmap(ctx->block_ea_map, blk)) {
1313 if (ea_refcount_decrement(ctx->refcount, blk, 0) == 0)
1314 return 1;
1315 /* Ooops, this EA was referenced more than it stated */
1316 if (!ctx->refcount_extra) {
1317 pctx->errcode = ea_refcount_create(0,
1318 &ctx->refcount_extra);
1319 if (pctx->errcode) {
1320 pctx->num = 2;
1321 fix_problem(ctx, PR_1_ALLOCATE_REFCOUNT, pctx);
1322 ctx->flags |= E2F_FLAG_ABORT;
1323 return 0;
1324 }
1325 }
1326 ea_refcount_increment(ctx->refcount_extra, blk, 0);
1327 return 1;
1328 }
1329
1330 /*
1331 * OK, we haven't seen this EA block yet. So we need to
1332 * validate it
1333 */
1334 pctx->blk = blk;
1335 pctx->errcode = ext2fs_read_ext_attr(fs, blk, block_buf);
1336 if (pctx->errcode && fix_problem(ctx, PR_1_READ_EA_BLOCK, pctx))
1337 goto clear_extattr;
1338 header = (struct ext2_ext_attr_header *) block_buf;
1339 pctx->blk = inode->i_file_acl;
1340 if (((ctx->ext_attr_ver == 1) &&
1341 (header->h_magic != EXT2_EXT_ATTR_MAGIC_v1)) ||
1342 ((ctx->ext_attr_ver == 2) &&
1343 (header->h_magic != EXT2_EXT_ATTR_MAGIC))) {
1344 if (fix_problem(ctx, PR_1_BAD_EA_BLOCK, pctx))
1345 goto clear_extattr;
1346 }
1347
1348 if (header->h_blocks != 1) {
1349 if (fix_problem(ctx, PR_1_EA_MULTI_BLOCK, pctx))
1350 goto clear_extattr;
1351 }
1352
1353 region = region_create(0, fs->blocksize);
1354 if (!region) {
1355 fix_problem(ctx, PR_1_EA_ALLOC_REGION, pctx);
1356 ctx->flags |= E2F_FLAG_ABORT;
1357 return 0;
1358 }
1359 if (region_allocate(region, 0, sizeof(struct ext2_ext_attr_header))) {
1360 if (fix_problem(ctx, PR_1_EA_ALLOC_COLLISION, pctx))
1361 goto clear_extattr;
1362 }
1363
1364 entry = (struct ext2_ext_attr_entry *)(header+1);
1365 end = block_buf + fs->blocksize;
1366 while ((char *)entry < end && *(__u32 *)entry) {
1367 if (region_allocate(region, (char *)entry - (char *)header,
1368 EXT2_EXT_ATTR_LEN(entry->e_name_len))) {
1369 if (fix_problem(ctx, PR_1_EA_ALLOC_COLLISION, pctx))
1370 goto clear_extattr;
1371 }
1372 if ((ctx->ext_attr_ver == 1 &&
1373 (entry->e_name_len == 0 || entry->e_name_index != 0)) ||
1374 (ctx->ext_attr_ver == 2 &&
1375 entry->e_name_index == 0)) {
1376 if (fix_problem(ctx, PR_1_EA_BAD_NAME, pctx))
1377 goto clear_extattr;
1378 }
1379 if (entry->e_value_block != 0) {
1380 if (fix_problem(ctx, PR_1_EA_BAD_VALUE, pctx))
1381 goto clear_extattr;
1382 }
1383 if (entry->e_value_offs + entry->e_value_size > fs->blocksize) {
1384 if (fix_problem(ctx, PR_1_EA_BAD_VALUE, pctx))
1385 goto clear_extattr;
1386 break;
1387 }
1388 if (entry->e_value_size &&
1389 region_allocate(region, entry->e_value_offs,
1390 EXT2_EXT_ATTR_SIZE(entry->e_value_size))) {
1391 if (fix_problem(ctx, PR_1_EA_ALLOC_COLLISION, pctx))
1392 goto clear_extattr;
1393 }
1394 entry = EXT2_EXT_ATTR_NEXT(entry);
1395 }
1396 if (region_allocate(region, (char *)entry - (char *)header, 4)) {
1397 if (fix_problem(ctx, PR_1_EA_ALLOC_COLLISION, pctx))
1398 goto clear_extattr;
1399 }
1400 region_free(region);
1401
1402 count = header->h_refcount - 1;
1403 if (count)
1404 ea_refcount_store(ctx->refcount, blk, count);
1405 mark_block_used(ctx, blk);
1406 ext2fs_fast_mark_block_bitmap(ctx->block_ea_map, blk);
1407 return 1;
1408
1409 clear_extattr:
1410 if (region)
1411 region_free(region);
1412 inode->i_file_acl = 0;
1413 e2fsck_write_inode(ctx, ino, inode, "check_ext_attr");
1414 return 0;
1415 }
1416
1417 /* Returns 1 if bad htree, 0 if OK */
handle_htree(e2fsck_t ctx,struct problem_context * pctx,ext2_ino_t ino EXT2FS_ATTR ((unused)),struct ext2_inode * inode,char * block_buf)1418 static int handle_htree(e2fsck_t ctx, struct problem_context *pctx,
1419 ext2_ino_t ino EXT2FS_ATTR((unused)),
1420 struct ext2_inode *inode,
1421 char *block_buf)
1422 {
1423 struct ext2_dx_root_info *root;
1424 ext2_filsys fs = ctx->fs;
1425 errcode_t retval;
1426 blk_t blk;
1427
1428 if ((!LINUX_S_ISDIR(inode->i_mode) &&
1429 fix_problem(ctx, PR_1_HTREE_NODIR, pctx)) ||
1430 (!(fs->super->s_feature_compat & EXT2_FEATURE_COMPAT_DIR_INDEX) &&
1431 fix_problem(ctx, PR_1_HTREE_SET, pctx)))
1432 return 1;
1433
1434 blk = inode->i_block[0];
1435 if (((blk == 0) ||
1436 (blk < fs->super->s_first_data_block) ||
1437 (blk >= fs->super->s_blocks_count)) &&
1438 fix_problem(ctx, PR_1_HTREE_BADROOT, pctx))
1439 return 1;
1440
1441 retval = io_channel_read_blk(fs->io, blk, 1, block_buf);
1442 if (retval && fix_problem(ctx, PR_1_HTREE_BADROOT, pctx))
1443 return 1;
1444
1445 /* XXX should check that beginning matches a directory */
1446 root = (struct ext2_dx_root_info *) (block_buf + 24);
1447
1448 if ((root->reserved_zero || root->info_length < 8) &&
1449 fix_problem(ctx, PR_1_HTREE_BADROOT, pctx))
1450 return 1;
1451
1452 pctx->num = root->hash_version;
1453 if ((root->hash_version != EXT2_HASH_LEGACY) &&
1454 (root->hash_version != EXT2_HASH_HALF_MD4) &&
1455 (root->hash_version != EXT2_HASH_TEA) &&
1456 fix_problem(ctx, PR_1_HTREE_HASHV, pctx))
1457 return 1;
1458
1459 if ((root->unused_flags & EXT2_HASH_FLAG_INCOMPAT) &&
1460 fix_problem(ctx, PR_1_HTREE_INCOMPAT, pctx))
1461 return 1;
1462
1463 pctx->num = root->indirect_levels;
1464 if ((root->indirect_levels > 1) &&
1465 fix_problem(ctx, PR_1_HTREE_DEPTH, pctx))
1466 return 1;
1467
1468 return 0;
1469 }
1470
1471 /*
1472 * This subroutine is called on each inode to account for all of the
1473 * blocks used by that inode.
1474 */
check_blocks(e2fsck_t ctx,struct problem_context * pctx,char * block_buf)1475 static void check_blocks(e2fsck_t ctx, struct problem_context *pctx,
1476 char *block_buf)
1477 {
1478 ext2_filsys fs = ctx->fs;
1479 struct process_block_struct pb;
1480 ext2_ino_t ino = pctx->ino;
1481 struct ext2_inode *inode = pctx->inode;
1482 int bad_size = 0;
1483 int dirty_inode = 0;
1484 __u64 size;
1485
1486 pb.ino = ino;
1487 pb.num_blocks = 0;
1488 pb.last_block = -1;
1489 pb.num_illegal_blocks = 0;
1490 pb.suppress = 0; pb.clear = 0;
1491 pb.fragmented = 0;
1492 pb.compressed = 0;
1493 pb.previous_block = 0;
1494 pb.is_dir = LINUX_S_ISDIR(inode->i_mode);
1495 pb.is_reg = LINUX_S_ISREG(inode->i_mode);
1496 pb.max_blocks = 1 << (31 - fs->super->s_log_block_size);
1497 pb.inode = inode;
1498 pb.pctx = pctx;
1499 pb.ctx = ctx;
1500 pctx->ino = ino;
1501 pctx->errcode = 0;
1502
1503 if (inode->i_flags & EXT2_COMPRBLK_FL) {
1504 if (fs->super->s_feature_incompat &
1505 EXT2_FEATURE_INCOMPAT_COMPRESSION)
1506 pb.compressed = 1;
1507 else {
1508 if (fix_problem(ctx, PR_1_COMPR_SET, pctx)) {
1509 inode->i_flags &= ~EXT2_COMPRBLK_FL;
1510 dirty_inode++;
1511 }
1512 }
1513 }
1514
1515 if (inode->i_file_acl && check_ext_attr(ctx, pctx, block_buf))
1516 pb.num_blocks++;
1517
1518 if (ext2fs_inode_has_valid_blocks(inode))
1519 pctx->errcode = ext2fs_block_iterate2(fs, ino,
1520 pb.is_dir ? BLOCK_FLAG_HOLE : 0,
1521 block_buf, process_block, &pb);
1522 end_problem_latch(ctx, PR_LATCH_BLOCK);
1523 end_problem_latch(ctx, PR_LATCH_TOOBIG);
1524 if (ctx->flags & E2F_FLAG_SIGNAL_MASK)
1525 goto out;
1526 if (pctx->errcode)
1527 fix_problem(ctx, PR_1_BLOCK_ITERATE, pctx);
1528
1529 if (pb.fragmented && pb.num_blocks < fs->super->s_blocks_per_group)
1530 ctx->fs_fragmented++;
1531
1532 if (pb.clear) {
1533 inode->i_links_count = 0;
1534 ext2fs_icount_store(ctx->inode_link_info, ino, 0);
1535 inode->i_dtime = ctx->now;
1536 dirty_inode++;
1537 ext2fs_unmark_inode_bitmap(ctx->inode_dir_map, ino);
1538 ext2fs_unmark_inode_bitmap(ctx->inode_reg_map, ino);
1539 ext2fs_unmark_inode_bitmap(ctx->inode_used_map, ino);
1540 /*
1541 * The inode was probably partially accounted for
1542 * before processing was aborted, so we need to
1543 * restart the pass 1 scan.
1544 */
1545 ctx->flags |= E2F_FLAG_RESTART;
1546 goto out;
1547 }
1548
1549 if (pb.is_dir) {
1550 while (1) {
1551 struct ext2_db_entry *entry;
1552
1553 if (ext2fs_dblist_get_last(fs->dblist, &entry) ||
1554 (entry->ino != ino) ||
1555 (entry->blk != 0) ||
1556 (entry->blockcnt == 0))
1557 break;
1558 /* printf("Dropping ino %lu blk %lu blockcnt %d\n",
1559 entry->ino, entry->blk, entry->blockcnt); */
1560 ext2fs_dblist_drop_last(fs->dblist);
1561 if (ext2fs_dblist_get_last(fs->dblist, &entry) ||
1562 (entry->ino != ino))
1563 pb.last_block--;
1564 else
1565 pb.last_block = entry->blockcnt;
1566 }
1567 }
1568
1569 if (inode->i_flags & EXT2_INDEX_FL) {
1570 if (handle_htree(ctx, pctx, ino, inode, block_buf)) {
1571 inode->i_flags &= ~EXT2_INDEX_FL;
1572 dirty_inode++;
1573 } else {
1574 #ifdef ENABLE_HTREE
1575 e2fsck_add_dx_dir(ctx, ino, pb.last_block+1);
1576 #endif
1577 }
1578 }
1579 if (ctx->dirs_to_hash && pb.is_dir &&
1580 !(inode->i_flags & EXT2_INDEX_FL) &&
1581 ((inode->i_size / fs->blocksize) >= 3))
1582 ext2fs_u32_list_add(ctx->dirs_to_hash, ino);
1583
1584 if (!pb.num_blocks && pb.is_dir) {
1585 if (fix_problem(ctx, PR_1_ZERO_LENGTH_DIR, pctx)) {
1586 inode->i_links_count = 0;
1587 ext2fs_icount_store(ctx->inode_link_info, ino, 0);
1588 inode->i_dtime = ctx->now;
1589 dirty_inode++;
1590 ext2fs_unmark_inode_bitmap(ctx->inode_dir_map, ino);
1591 ext2fs_unmark_inode_bitmap(ctx->inode_reg_map, ino);
1592 ext2fs_unmark_inode_bitmap(ctx->inode_used_map, ino);
1593 ctx->fs_directory_count--;
1594 goto out;
1595 }
1596 }
1597
1598 pb.num_blocks *= (fs->blocksize / 512);
1599 #if 0
1600 printf("inode %u, i_size = %lu, last_block = %lld, i_blocks=%lu, num_blocks = %lu\n",
1601 ino, inode->i_size, pb.last_block, inode->i_blocks,
1602 pb.num_blocks);
1603 #endif
1604 if (pb.is_dir) {
1605 int nblock = inode->i_size >> EXT2_BLOCK_SIZE_BITS(fs->super);
1606 if (inode->i_size & (fs->blocksize - 1))
1607 bad_size = 5;
1608 else if (nblock > (pb.last_block + 1))
1609 bad_size = 1;
1610 else if (nblock < (pb.last_block + 1)) {
1611 if (((pb.last_block + 1) - nblock) >
1612 fs->super->s_prealloc_dir_blocks)
1613 bad_size = 2;
1614 }
1615 } else {
1616 e2_blkcnt_t blkpg = ctx->blocks_per_page;
1617
1618 size = EXT2_I_SIZE(inode);
1619 if ((pb.last_block >= 0) &&
1620 /* allow allocated blocks to end of PAGE_SIZE */
1621 (size < (__u64)pb.last_block * fs->blocksize) &&
1622 (pb.last_block / blkpg * blkpg != pb.last_block ||
1623 size < (__u64)(pb.last_block & ~(blkpg-1)) *fs->blocksize))
1624 bad_size = 3;
1625 else if (size > ext2_max_sizes[fs->super->s_log_block_size])
1626 bad_size = 4;
1627 }
1628 /* i_size for symlinks is checked elsewhere */
1629 if (bad_size && !LINUX_S_ISLNK(inode->i_mode)) {
1630 pctx->num = (pb.last_block+1) * fs->blocksize;
1631 if (fix_problem(ctx, PR_1_BAD_I_SIZE, pctx)) {
1632 inode->i_size = pctx->num;
1633 if (!LINUX_S_ISDIR(inode->i_mode))
1634 inode->i_size_high = pctx->num >> 32;
1635 dirty_inode++;
1636 }
1637 pctx->num = 0;
1638 }
1639 if (LINUX_S_ISREG(inode->i_mode) &&
1640 (inode->i_size_high || inode->i_size & 0x80000000UL))
1641 ctx->large_files++;
1642 if (pb.num_blocks != inode->i_blocks) {
1643 pctx->num = pb.num_blocks;
1644 if (fix_problem(ctx, PR_1_BAD_I_BLOCKS, pctx)) {
1645 inode->i_blocks = pb.num_blocks;
1646 dirty_inode++;
1647 }
1648 pctx->num = 0;
1649 }
1650 out:
1651 if (dirty_inode)
1652 e2fsck_write_inode(ctx, ino, inode, "check_blocks");
1653 }
1654
1655 #if 0
1656 /*
1657 * Helper function called by process block when an illegal block is
1658 * found. It returns a description about why the block is illegal
1659 */
1660 static char *describe_illegal_block(ext2_filsys fs, blk_t block)
1661 {
1662 blk_t super;
1663 int i;
1664 static char problem[80];
1665
1666 super = fs->super->s_first_data_block;
1667 strcpy(problem, "PROGRAMMING ERROR: Unknown reason for illegal block");
1668 if (block < super) {
1669 sprintf(problem, "< FIRSTBLOCK (%u)", super);
1670 return(problem);
1671 } else if (block >= fs->super->s_blocks_count) {
1672 sprintf(problem, "> BLOCKS (%u)", fs->super->s_blocks_count);
1673 return(problem);
1674 }
1675 for (i = 0; i < fs->group_desc_count; i++) {
1676 if (block == super) {
1677 sprintf(problem, "is the superblock in group %d", i);
1678 break;
1679 }
1680 if (block > super &&
1681 block <= (super + fs->desc_blocks)) {
1682 sprintf(problem, "is in the group descriptors "
1683 "of group %d", i);
1684 break;
1685 }
1686 if (block == fs->group_desc[i].bg_block_bitmap) {
1687 sprintf(problem, "is the block bitmap of group %d", i);
1688 break;
1689 }
1690 if (block == fs->group_desc[i].bg_inode_bitmap) {
1691 sprintf(problem, "is the inode bitmap of group %d", i);
1692 break;
1693 }
1694 if (block >= fs->group_desc[i].bg_inode_table &&
1695 (block < fs->group_desc[i].bg_inode_table
1696 + fs->inode_blocks_per_group)) {
1697 sprintf(problem, "is in the inode table of group %d",
1698 i);
1699 break;
1700 }
1701 super += fs->super->s_blocks_per_group;
1702 }
1703 return(problem);
1704 }
1705 #endif
1706
1707 /*
1708 * This is a helper function for check_blocks().
1709 */
process_block(ext2_filsys fs,blk_t * block_nr,e2_blkcnt_t blockcnt,blk_t ref_block EXT2FS_ATTR ((unused)),int ref_offset EXT2FS_ATTR ((unused)),void * priv_data)1710 static int process_block(ext2_filsys fs,
1711 blk_t *block_nr,
1712 e2_blkcnt_t blockcnt,
1713 blk_t ref_block EXT2FS_ATTR((unused)),
1714 int ref_offset EXT2FS_ATTR((unused)),
1715 void *priv_data)
1716 {
1717 struct process_block_struct *p;
1718 struct problem_context *pctx;
1719 blk_t blk = *block_nr;
1720 int ret_code = 0;
1721 int problem = 0;
1722 e2fsck_t ctx;
1723
1724 p = (struct process_block_struct *) priv_data;
1725 pctx = p->pctx;
1726 ctx = p->ctx;
1727
1728 if (p->compressed && (blk == EXT2FS_COMPRESSED_BLKADDR)) {
1729 /* todo: Check that the comprblk_fl is high, that the
1730 blkaddr pattern looks right (all non-holes up to
1731 first EXT2FS_COMPRESSED_BLKADDR, then all
1732 EXT2FS_COMPRESSED_BLKADDR up to end of cluster),
1733 that the feature_incompat bit is high, and that the
1734 inode is a regular file. If we're doing a "full
1735 check" (a concept introduced to e2fsck by e2compr,
1736 meaning that we look at data blocks as well as
1737 metadata) then call some library routine that
1738 checks the compressed data. I'll have to think
1739 about this, because one particularly important
1740 problem to be able to fix is to recalculate the
1741 cluster size if necessary. I think that perhaps
1742 we'd better do most/all e2compr-specific checks
1743 separately, after the non-e2compr checks. If not
1744 doing a full check, it may be useful to test that
1745 the personality is linux; e.g. if it isn't then
1746 perhaps this really is just an illegal block. */
1747 return 0;
1748 }
1749
1750 if (blk == 0) {
1751 if (p->is_dir == 0) {
1752 /*
1753 * Should never happen, since only directories
1754 * get called with BLOCK_FLAG_HOLE
1755 */
1756 #if DEBUG_E2FSCK
1757 printf("process_block() called with blk == 0, "
1758 "blockcnt=%d, inode %lu???\n",
1759 blockcnt, p->ino);
1760 #endif
1761 return 0;
1762 }
1763 if (blockcnt < 0)
1764 return 0;
1765 if (blockcnt * fs->blocksize < p->inode->i_size) {
1766 #if 0
1767 printf("Missing block (#%d) in directory inode %lu!\n",
1768 blockcnt, p->ino);
1769 #endif
1770 p->last_block = blockcnt;
1771 goto mark_dir;
1772 }
1773 return 0;
1774 }
1775
1776 #if 0
1777 printf("Process_block, inode %lu, block %u, #%d\n", p->ino, blk,
1778 blockcnt);
1779 #endif
1780
1781 /*
1782 * Simplistic fragmentation check. We merely require that the
1783 * file be contiguous. (Which can never be true for really
1784 * big files that are greater than a block group.)
1785 */
1786 if (!HOLE_BLKADDR(p->previous_block)) {
1787 if (p->previous_block+1 != blk)
1788 p->fragmented = 1;
1789 }
1790 p->previous_block = blk;
1791
1792 if (p->is_dir && blockcnt > (1 << (21 - fs->super->s_log_block_size)))
1793 problem = PR_1_TOOBIG_DIR;
1794 if (p->is_reg && p->num_blocks+1 >= p->max_blocks)
1795 problem = PR_1_TOOBIG_REG;
1796 if (!p->is_dir && !p->is_reg && blockcnt > 0)
1797 problem = PR_1_TOOBIG_SYMLINK;
1798
1799 if (blk < fs->super->s_first_data_block ||
1800 blk >= fs->super->s_blocks_count)
1801 problem = PR_1_ILLEGAL_BLOCK_NUM;
1802
1803 if (problem) {
1804 p->num_illegal_blocks++;
1805 if (!p->suppress && (p->num_illegal_blocks % 12) == 0) {
1806 if (fix_problem(ctx, PR_1_TOO_MANY_BAD_BLOCKS, pctx)) {
1807 p->clear = 1;
1808 return BLOCK_ABORT;
1809 }
1810 if (fix_problem(ctx, PR_1_SUPPRESS_MESSAGES, pctx)) {
1811 p->suppress = 1;
1812 set_latch_flags(PR_LATCH_BLOCK,
1813 PRL_SUPPRESS, 0);
1814 }
1815 }
1816 pctx->blk = blk;
1817 pctx->blkcount = blockcnt;
1818 if (fix_problem(ctx, problem, pctx)) {
1819 blk = *block_nr = 0;
1820 ret_code = BLOCK_CHANGED;
1821 goto mark_dir;
1822 } else
1823 return 0;
1824 }
1825
1826 if (p->ino == EXT2_RESIZE_INO) {
1827 /*
1828 * The resize inode has already be sanity checked
1829 * during pass #0 (the superblock checks). All we
1830 * have to do is mark the double indirect block as
1831 * being in use; all of the other blocks are handled
1832 * by mark_table_blocks()).
1833 */
1834 if (blockcnt == BLOCK_COUNT_DIND)
1835 mark_block_used(ctx, blk);
1836 } else
1837 mark_block_used(ctx, blk);
1838 p->num_blocks++;
1839 if (blockcnt >= 0)
1840 p->last_block = blockcnt;
1841 mark_dir:
1842 if (p->is_dir && (blockcnt >= 0)) {
1843 pctx->errcode = ext2fs_add_dir_block(fs->dblist, p->ino,
1844 blk, blockcnt);
1845 if (pctx->errcode) {
1846 pctx->blk = blk;
1847 pctx->num = blockcnt;
1848 fix_problem(ctx, PR_1_ADD_DBLOCK, pctx);
1849 /* Should never get here */
1850 ctx->flags |= E2F_FLAG_ABORT;
1851 return BLOCK_ABORT;
1852 }
1853 }
1854 return ret_code;
1855 }
1856
process_bad_block(ext2_filsys fs,blk_t * block_nr,e2_blkcnt_t blockcnt,blk_t ref_block EXT2FS_ATTR ((unused)),int ref_offset EXT2FS_ATTR ((unused)),void * priv_data)1857 static int process_bad_block(ext2_filsys fs,
1858 blk_t *block_nr,
1859 e2_blkcnt_t blockcnt,
1860 blk_t ref_block EXT2FS_ATTR((unused)),
1861 int ref_offset EXT2FS_ATTR((unused)),
1862 void *priv_data)
1863 {
1864 struct process_block_struct *p;
1865 blk_t blk = *block_nr;
1866 blk_t first_block;
1867 dgrp_t i;
1868 struct problem_context *pctx;
1869 e2fsck_t ctx;
1870
1871 /*
1872 * Note: This function processes blocks for the bad blocks
1873 * inode, which is never compressed. So we don't use HOLE_BLKADDR().
1874 */
1875
1876 if (!blk)
1877 return 0;
1878
1879 p = (struct process_block_struct *) priv_data;
1880 ctx = p->ctx;
1881 pctx = p->pctx;
1882
1883 pctx->ino = EXT2_BAD_INO;
1884 pctx->blk = blk;
1885 pctx->blkcount = blockcnt;
1886
1887 if ((blk < fs->super->s_first_data_block) ||
1888 (blk >= fs->super->s_blocks_count)) {
1889 if (fix_problem(ctx, PR_1_BB_ILLEGAL_BLOCK_NUM, pctx)) {
1890 *block_nr = 0;
1891 return BLOCK_CHANGED;
1892 } else
1893 return 0;
1894 }
1895
1896 if (blockcnt < 0) {
1897 if (ext2fs_test_block_bitmap(p->fs_meta_blocks, blk)) {
1898 p->bbcheck = 1;
1899 if (fix_problem(ctx, PR_1_BB_FS_BLOCK, pctx)) {
1900 *block_nr = 0;
1901 return BLOCK_CHANGED;
1902 }
1903 } else if (ext2fs_test_block_bitmap(ctx->block_found_map,
1904 blk)) {
1905 p->bbcheck = 1;
1906 if (fix_problem(ctx, PR_1_BBINODE_BAD_METABLOCK,
1907 pctx)) {
1908 *block_nr = 0;
1909 return BLOCK_CHANGED;
1910 }
1911 if (ctx->flags & E2F_FLAG_SIGNAL_MASK)
1912 return BLOCK_ABORT;
1913 } else
1914 mark_block_used(ctx, blk);
1915 return 0;
1916 }
1917 #if 0
1918 printf ("DEBUG: Marking %u as bad.\n", blk);
1919 #endif
1920 ctx->fs_badblocks_count++;
1921 /*
1922 * If the block is not used, then mark it as used and return.
1923 * If it is already marked as found, this must mean that
1924 * there's an overlap between the filesystem table blocks
1925 * (bitmaps and inode table) and the bad block list.
1926 */
1927 if (!ext2fs_test_block_bitmap(ctx->block_found_map, blk)) {
1928 ext2fs_mark_block_bitmap(ctx->block_found_map, blk);
1929 return 0;
1930 }
1931 /*
1932 * Try to find the where the filesystem block was used...
1933 */
1934 first_block = fs->super->s_first_data_block;
1935
1936 for (i = 0; i < fs->group_desc_count; i++ ) {
1937 pctx->group = i;
1938 pctx->blk = blk;
1939 if (!ext2fs_bg_has_super(fs, i))
1940 goto skip_super;
1941 if (blk == first_block) {
1942 if (i == 0) {
1943 if (fix_problem(ctx,
1944 PR_1_BAD_PRIMARY_SUPERBLOCK,
1945 pctx)) {
1946 *block_nr = 0;
1947 return BLOCK_CHANGED;
1948 }
1949 return 0;
1950 }
1951 fix_problem(ctx, PR_1_BAD_SUPERBLOCK, pctx);
1952 return 0;
1953 }
1954 if ((blk > first_block) &&
1955 (blk <= first_block + fs->desc_blocks)) {
1956 if (i == 0) {
1957 pctx->blk = *block_nr;
1958 if (fix_problem(ctx,
1959 PR_1_BAD_PRIMARY_GROUP_DESCRIPTOR, pctx)) {
1960 *block_nr = 0;
1961 return BLOCK_CHANGED;
1962 }
1963 return 0;
1964 }
1965 fix_problem(ctx, PR_1_BAD_GROUP_DESCRIPTORS, pctx);
1966 return 0;
1967 }
1968 skip_super:
1969 if (blk == fs->group_desc[i].bg_block_bitmap) {
1970 if (fix_problem(ctx, PR_1_BB_BAD_BLOCK, pctx)) {
1971 ctx->invalid_block_bitmap_flag[i]++;
1972 ctx->invalid_bitmaps++;
1973 }
1974 return 0;
1975 }
1976 if (blk == fs->group_desc[i].bg_inode_bitmap) {
1977 if (fix_problem(ctx, PR_1_IB_BAD_BLOCK, pctx)) {
1978 ctx->invalid_inode_bitmap_flag[i]++;
1979 ctx->invalid_bitmaps++;
1980 }
1981 return 0;
1982 }
1983 if ((blk >= fs->group_desc[i].bg_inode_table) &&
1984 (blk < (fs->group_desc[i].bg_inode_table +
1985 fs->inode_blocks_per_group))) {
1986 /*
1987 * If there are bad blocks in the inode table,
1988 * the inode scan code will try to do
1989 * something reasonable automatically.
1990 */
1991 return 0;
1992 }
1993 first_block += fs->super->s_blocks_per_group;
1994 }
1995 /*
1996 * If we've gotten to this point, then the only
1997 * possibility is that the bad block inode meta data
1998 * is using a bad block.
1999 */
2000 if ((blk == p->inode->i_block[EXT2_IND_BLOCK]) ||
2001 (blk == p->inode->i_block[EXT2_DIND_BLOCK]) ||
2002 (blk == p->inode->i_block[EXT2_TIND_BLOCK])) {
2003 p->bbcheck = 1;
2004 if (fix_problem(ctx, PR_1_BBINODE_BAD_METABLOCK, pctx)) {
2005 *block_nr = 0;
2006 return BLOCK_CHANGED;
2007 }
2008 if (ctx->flags & E2F_FLAG_SIGNAL_MASK)
2009 return BLOCK_ABORT;
2010 return 0;
2011 }
2012
2013 pctx->group = -1;
2014
2015 /* Warn user that the block wasn't claimed */
2016 fix_problem(ctx, PR_1_PROGERR_CLAIMED_BLOCK, pctx);
2017
2018 return 0;
2019 }
2020
new_table_block(e2fsck_t ctx,blk_t first_block,int group,const char * name,int num,blk_t * new_block)2021 static void new_table_block(e2fsck_t ctx, blk_t first_block, int group,
2022 const char *name, int num, blk_t *new_block)
2023 {
2024 ext2_filsys fs = ctx->fs;
2025 blk_t old_block = *new_block;
2026 blk_t last_block;
2027 int i;
2028 char *buf;
2029 struct problem_context pctx;
2030
2031 clear_problem_context(&pctx);
2032
2033 pctx.group = group;
2034 pctx.blk = old_block;
2035 pctx.str = name;
2036
2037 last_block = ext2fs_group_last_block(fs, group);
2038 pctx.errcode = ext2fs_get_free_blocks(fs, first_block, last_block,
2039 num, ctx->block_found_map, new_block);
2040 if (pctx.errcode) {
2041 pctx.num = num;
2042 fix_problem(ctx, PR_1_RELOC_BLOCK_ALLOCATE, &pctx);
2043 ext2fs_unmark_valid(fs);
2044 return;
2045 }
2046 pctx.errcode = ext2fs_get_mem(fs->blocksize, &buf);
2047 if (pctx.errcode) {
2048 fix_problem(ctx, PR_1_RELOC_MEMORY_ALLOCATE, &pctx);
2049 ext2fs_unmark_valid(fs);
2050 return;
2051 }
2052 ext2fs_mark_super_dirty(fs);
2053 fs->flags &= ~EXT2_FLAG_MASTER_SB_ONLY;
2054 pctx.blk2 = *new_block;
2055 fix_problem(ctx, (old_block ? PR_1_RELOC_FROM_TO :
2056 PR_1_RELOC_TO), &pctx);
2057 pctx.blk2 = 0;
2058 for (i = 0; i < num; i++) {
2059 pctx.blk = i;
2060 ext2fs_mark_block_bitmap(ctx->block_found_map, (*new_block)+i);
2061 if (old_block) {
2062 pctx.errcode = io_channel_read_blk(fs->io,
2063 old_block + i, 1, buf);
2064 if (pctx.errcode)
2065 fix_problem(ctx, PR_1_RELOC_READ_ERR, &pctx);
2066 } else
2067 memset(buf, 0, fs->blocksize);
2068
2069 pctx.blk = (*new_block) + i;
2070 pctx.errcode = io_channel_write_blk(fs->io, pctx.blk,
2071 1, buf);
2072 if (pctx.errcode)
2073 fix_problem(ctx, PR_1_RELOC_WRITE_ERR, &pctx);
2074 }
2075 ext2fs_free_mem(&buf);
2076 }
2077
2078 /*
2079 * This routine gets called at the end of pass 1 if bad blocks are
2080 * detected in the superblock, group descriptors, inode_bitmaps, or
2081 * block bitmaps. At this point, all of the blocks have been mapped
2082 * out, so we can try to allocate new block(s) to replace the bad
2083 * blocks.
2084 */
handle_fs_bad_blocks(e2fsck_t ctx)2085 static void handle_fs_bad_blocks(e2fsck_t ctx)
2086 {
2087 ext2_filsys fs = ctx->fs;
2088 dgrp_t i;
2089 blk_t first_block;
2090
2091 for (i = 0; i < fs->group_desc_count; i++) {
2092 first_block = ext2fs_group_first_block(fs, i);
2093
2094 if (ctx->invalid_block_bitmap_flag[i]) {
2095 new_table_block(ctx, first_block, i, _("block bitmap"),
2096 1, &fs->group_desc[i].bg_block_bitmap);
2097 }
2098 if (ctx->invalid_inode_bitmap_flag[i]) {
2099 new_table_block(ctx, first_block, i, _("inode bitmap"),
2100 1, &fs->group_desc[i].bg_inode_bitmap);
2101 }
2102 if (ctx->invalid_inode_table_flag[i]) {
2103 new_table_block(ctx, first_block, i, _("inode table"),
2104 fs->inode_blocks_per_group,
2105 &fs->group_desc[i].bg_inode_table);
2106 ctx->flags |= E2F_FLAG_RESTART;
2107 }
2108 }
2109 ctx->invalid_bitmaps = 0;
2110 }
2111
2112 /*
2113 * This routine marks all blocks which are used by the superblock,
2114 * group descriptors, inode bitmaps, and block bitmaps.
2115 */
mark_table_blocks(e2fsck_t ctx)2116 static void mark_table_blocks(e2fsck_t ctx)
2117 {
2118 ext2_filsys fs = ctx->fs;
2119 blk_t b;
2120 dgrp_t i;
2121 int j;
2122 struct problem_context pctx;
2123
2124 clear_problem_context(&pctx);
2125
2126 for (i = 0; i < fs->group_desc_count; i++) {
2127 pctx.group = i;
2128
2129 ext2fs_reserve_super_and_bgd(fs, i, ctx->block_found_map);
2130
2131 /*
2132 * Mark the blocks used for the inode table
2133 */
2134 if (fs->group_desc[i].bg_inode_table) {
2135 for (j = 0, b = fs->group_desc[i].bg_inode_table;
2136 j < fs->inode_blocks_per_group;
2137 j++, b++) {
2138 if (ext2fs_test_block_bitmap(ctx->block_found_map,
2139 b)) {
2140 pctx.blk = b;
2141 if (fix_problem(ctx,
2142 PR_1_ITABLE_CONFLICT, &pctx)) {
2143 ctx->invalid_inode_table_flag[i]++;
2144 ctx->invalid_bitmaps++;
2145 }
2146 } else {
2147 ext2fs_mark_block_bitmap(ctx->block_found_map,
2148 b);
2149 }
2150 }
2151 }
2152
2153 /*
2154 * Mark block used for the block bitmap
2155 */
2156 if (fs->group_desc[i].bg_block_bitmap) {
2157 if (ext2fs_test_block_bitmap(ctx->block_found_map,
2158 fs->group_desc[i].bg_block_bitmap)) {
2159 pctx.blk = fs->group_desc[i].bg_block_bitmap;
2160 if (fix_problem(ctx, PR_1_BB_CONFLICT, &pctx)) {
2161 ctx->invalid_block_bitmap_flag[i]++;
2162 ctx->invalid_bitmaps++;
2163 }
2164 } else {
2165 ext2fs_mark_block_bitmap(ctx->block_found_map,
2166 fs->group_desc[i].bg_block_bitmap);
2167 }
2168
2169 }
2170 /*
2171 * Mark block used for the inode bitmap
2172 */
2173 if (fs->group_desc[i].bg_inode_bitmap) {
2174 if (ext2fs_test_block_bitmap(ctx->block_found_map,
2175 fs->group_desc[i].bg_inode_bitmap)) {
2176 pctx.blk = fs->group_desc[i].bg_inode_bitmap;
2177 if (fix_problem(ctx, PR_1_IB_CONFLICT, &pctx)) {
2178 ctx->invalid_inode_bitmap_flag[i]++;
2179 ctx->invalid_bitmaps++;
2180 }
2181 } else {
2182 ext2fs_mark_block_bitmap(ctx->block_found_map,
2183 fs->group_desc[i].bg_inode_bitmap);
2184 }
2185 }
2186 }
2187 }
2188
2189 /*
2190 * Thes subroutines short circuits ext2fs_get_blocks and
2191 * ext2fs_check_directory; we use them since we already have the inode
2192 * structure, so there's no point in letting the ext2fs library read
2193 * the inode again.
2194 */
pass1_get_blocks(ext2_filsys fs,ext2_ino_t ino,blk_t * blocks)2195 static errcode_t pass1_get_blocks(ext2_filsys fs, ext2_ino_t ino,
2196 blk_t *blocks)
2197 {
2198 e2fsck_t ctx = (e2fsck_t) fs->priv_data;
2199 int i;
2200
2201 if ((ino != ctx->stashed_ino) || !ctx->stashed_inode)
2202 return EXT2_ET_CALLBACK_NOTHANDLED;
2203
2204 for (i=0; i < EXT2_N_BLOCKS; i++)
2205 blocks[i] = ctx->stashed_inode->i_block[i];
2206 return 0;
2207 }
2208
pass1_read_inode(ext2_filsys fs,ext2_ino_t ino,struct ext2_inode * inode)2209 static errcode_t pass1_read_inode(ext2_filsys fs, ext2_ino_t ino,
2210 struct ext2_inode *inode)
2211 {
2212 e2fsck_t ctx = (e2fsck_t) fs->priv_data;
2213
2214 if ((ino != ctx->stashed_ino) || !ctx->stashed_inode)
2215 return EXT2_ET_CALLBACK_NOTHANDLED;
2216 *inode = *ctx->stashed_inode;
2217 return 0;
2218 }
2219
pass1_write_inode(ext2_filsys fs,ext2_ino_t ino,struct ext2_inode * inode)2220 static errcode_t pass1_write_inode(ext2_filsys fs, ext2_ino_t ino,
2221 struct ext2_inode *inode)
2222 {
2223 e2fsck_t ctx = (e2fsck_t) fs->priv_data;
2224
2225 if ((ino == ctx->stashed_ino) && ctx->stashed_inode &&
2226 (inode != ctx->stashed_inode))
2227 *ctx->stashed_inode = *inode;
2228 return EXT2_ET_CALLBACK_NOTHANDLED;
2229 }
2230
pass1_check_directory(ext2_filsys fs,ext2_ino_t ino)2231 static errcode_t pass1_check_directory(ext2_filsys fs, ext2_ino_t ino)
2232 {
2233 e2fsck_t ctx = (e2fsck_t) fs->priv_data;
2234
2235 if ((ino != ctx->stashed_ino) || !ctx->stashed_inode)
2236 return EXT2_ET_CALLBACK_NOTHANDLED;
2237
2238 if (!LINUX_S_ISDIR(ctx->stashed_inode->i_mode))
2239 return EXT2_ET_NO_DIRECTORY;
2240 return 0;
2241 }
2242
e2fsck_use_inode_shortcuts(e2fsck_t ctx,int bool)2243 void e2fsck_use_inode_shortcuts(e2fsck_t ctx, int bool)
2244 {
2245 ext2_filsys fs = ctx->fs;
2246
2247 if (bool) {
2248 fs->get_blocks = pass1_get_blocks;
2249 fs->check_directory = pass1_check_directory;
2250 fs->read_inode = pass1_read_inode;
2251 fs->write_inode = pass1_write_inode;
2252 ctx->stashed_ino = 0;
2253 } else {
2254 fs->get_blocks = 0;
2255 fs->check_directory = 0;
2256 fs->read_inode = 0;
2257 fs->write_inode = 0;
2258 }
2259 }
2260