]> git.ipfire.org Git - thirdparty/e2fsprogs.git/blob - e2fsck/pass2.c
projects / thirdparty / e2fsprogs.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
Add configure --disable-tdb which disables e2fsck's scratch_files feature
[thirdparty/e2fsprogs.git] / e2fsck / pass2.c
1 /*
2 * pass2.c --- check directory structure
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 2 of e2fsck iterates through all active directory inodes, and
12 * applies to following tests to each directory entry in the directory
13 * blocks in the inodes:
14 *
15 * - The length of the directory entry (rec_len) should be at
16 * least 8 bytes, and no more than the remaining space
17 * left in the directory block.
18 * - The length of the name in the directory entry (name_len)
19 * should be less than (rec_len - 8).
20 * - The inode number in the directory entry should be within
21 * legal bounds.
22 * - The inode number should refer to a in-use inode.
23 * - The first entry should be '.', and its inode should be
24 * the inode of the directory.
25 * - The second entry should be '..'.
26 *
27 * To minimize disk seek time, the directory blocks are processed in
28 * sorted order of block numbers.
29 *
30 * Pass 2 also collects the following information:
31 * - The inode numbers of the subdirectories for each directory.
32 *
33 * Pass 2 relies on the following information from previous passes:
34 * - The directory information collected in pass 1.
35 * - The inode_used_map bitmap
36 * - The inode_bad_map bitmap
37 * - The inode_dir_map bitmap
38 *
39 * Pass 2 frees the following data structures
40 * - The inode_bad_map bitmap
41 * - The inode_reg_map bitmap
42 */
43
44 #define _GNU_SOURCE 1 /* get strnlen() */
45 #include "config.h"
46 #include <string.h>
47
48 #include "e2fsck.h"
49 #include "problem.h"
50 #include "support/dict.h"
51
52 #ifdef NO_INLINE_FUNCS
53 #define _INLINE_
54 #else
55 #define _INLINE_ inline
56 #endif
57
58 /* #define DX_DEBUG */
59
60 /*
61 * Keeps track of how many times an inode is referenced.
62 */
63 static void deallocate_inode(e2fsck_t ctx, ext2_ino_t ino, char* block_buf);
64 static int check_dir_block2(ext2_filsys fs,
65 struct ext2_db_entry2 *dir_blocks_info,
66 void *priv_data);
67 static int check_dir_block(ext2_filsys fs,
68 struct ext2_db_entry2 *dir_blocks_info,
69 void *priv_data);
70 static int allocate_dir_block(e2fsck_t ctx,
71 struct ext2_db_entry2 *dir_blocks_info,
72 char *buf, struct problem_context *pctx);
73 static void clear_htree(e2fsck_t ctx, ext2_ino_t ino);
74 static int htree_depth(struct dx_dir_info *dx_dir,
75 struct dx_dirblock_info *dx_db);
76 static EXT2_QSORT_TYPE special_dir_block_cmp(const void *a, const void *b);
77
78 struct check_dir_struct {
79 char *buf;
80 struct problem_context pctx;
81 int count, max;
82 e2fsck_t ctx;
83 unsigned long long list_offset;
84 unsigned long long ra_entries;
85 unsigned long long next_ra_off;
86 };
87
88 void e2fsck_pass2(e2fsck_t ctx)
89 {
90 struct ext2_super_block *sb = ctx->fs->super;
91 struct problem_context pctx;
92 ext2_filsys fs = ctx->fs;
93 char *buf;
94 #ifdef RESOURCE_TRACK
95 struct resource_track rtrack;
96 #endif
97 struct check_dir_struct cd;
98 struct dx_dir_info *dx_dir;
99 struct dx_dirblock_info *dx_db, *dx_parent;
100 int b;
101 int i, depth;
102 problem_t code;
103 int bad_dir;
104 int (*check_dir_func)(ext2_filsys fs,
105 struct ext2_db_entry2 *dir_blocks_info,
106 void *priv_data);
107
108 init_resource_track(&rtrack, ctx->fs->io);
109 clear_problem_context(&cd.pctx);
110
111 #ifdef MTRACE
112 mtrace_print("Pass 2");
113 #endif
114
115 if (!(ctx->options & E2F_OPT_PREEN))
116 fix_problem(ctx, PR_2_PASS_HEADER, &cd.pctx);
117
118 cd.pctx.errcode = e2fsck_setup_icount(ctx, "inode_count",
119 EXT2_ICOUNT_OPT_INCREMENT,
120 ctx->inode_link_info, &ctx->inode_count);
121 if (cd.pctx.errcode) {
122 fix_problem(ctx, PR_2_ALLOCATE_ICOUNT, &cd.pctx);
123 ctx->flags |= E2F_FLAG_ABORT;
124 return;
125 }
126 buf = (char *) e2fsck_allocate_memory(ctx, 2*fs->blocksize,
127 "directory scan buffer");
128
129 /*
130 * Set up the parent pointer for the root directory, if
131 * present. (If the root directory is not present, we will
132 * create it in pass 3.)
133 */
134 (void) e2fsck_dir_info_set_parent(ctx, EXT2_ROOT_INO, EXT2_ROOT_INO);
135
136 cd.buf = buf;
137 cd.ctx = ctx;
138 cd.count = 1;
139 cd.max = ext2fs_dblist_count2(fs->dblist);
140 cd.list_offset = 0;
141 cd.ra_entries = ctx->readahead_kb * 1024 / ctx->fs->blocksize;
142 cd.next_ra_off = 0;
143
144 if (ctx->progress)
145 (void) (ctx->progress)(ctx, 2, 0, cd.max);
146
147 if (ext2fs_has_feature_dir_index(fs->super))
148 ext2fs_dblist_sort2(fs->dblist, special_dir_block_cmp);
149
150 check_dir_func = cd.ra_entries ? check_dir_block2 : check_dir_block;
151 cd.pctx.errcode = ext2fs_dblist_iterate2(fs->dblist, check_dir_func,
152 &cd);
153 if (ctx->flags & E2F_FLAG_RESTART_LATER) {
154 ctx->flags |= E2F_FLAG_RESTART;
155 ctx->flags &= ~E2F_FLAG_RESTART_LATER;
156 }
157
158 if (ctx->flags & E2F_FLAG_RUN_RETURN)
159 return;
160
161 if (cd.pctx.errcode) {
162 fix_problem(ctx, PR_2_DBLIST_ITERATE, &cd.pctx);
163 ctx->flags |= E2F_FLAG_ABORT;
164 return;
165 }
166
167 for (i=0; (dx_dir = e2fsck_dx_dir_info_iter(ctx, &i)) != 0;) {
168 if (ctx->flags & E2F_FLAG_SIGNAL_MASK)
169 return;
170 if (e2fsck_dir_will_be_rehashed(ctx, dx_dir->ino) ||
171 dx_dir->numblocks == 0)
172 continue;
173 clear_problem_context(&pctx);
174 bad_dir = 0;
175 pctx.dir = dx_dir->ino;
176 dx_db = dx_dir->dx_block;
177 if (dx_db->flags & DX_FLAG_REFERENCED)
178 dx_db->flags |= DX_FLAG_DUP_REF;
179 else
180 dx_db->flags |= DX_FLAG_REFERENCED;
181 /*
182 * Find all of the first and last leaf blocks, and
183 * update their parent's min and max hash values
184 */
185 for (b=0, dx_db = dx_dir->dx_block;
186 b < dx_dir->numblocks;
187 b++, dx_db++) {
188 if ((dx_db->type != DX_DIRBLOCK_LEAF) ||
189 !(dx_db->flags & (DX_FLAG_FIRST | DX_FLAG_LAST)))
190 continue;
191 dx_parent = &dx_dir->dx_block[dx_db->parent];
192 /*
193 * XXX Make sure dx_parent->min_hash > dx_db->min_hash
194 */
195 if (dx_db->flags & DX_FLAG_FIRST)
196 dx_parent->min_hash = dx_db->min_hash;
197 /*
198 * XXX Make sure dx_parent->max_hash < dx_db->max_hash
199 */
200 if (dx_db->flags & DX_FLAG_LAST)
201 dx_parent->max_hash = dx_db->max_hash;
202 }
203
204 for (b=0, dx_db = dx_dir->dx_block;
205 b < dx_dir->numblocks;
206 b++, dx_db++) {
207 pctx.blkcount = b;
208 pctx.group = dx_db->parent;
209 code = 0;
210 if (!(dx_db->flags & DX_FLAG_FIRST) &&
211 (dx_db->min_hash < dx_db->node_min_hash)) {
212 pctx.blk = dx_db->min_hash;
213 pctx.blk2 = dx_db->node_min_hash;
214 code = PR_2_HTREE_MIN_HASH;
215 fix_problem(ctx, code, &pctx);
216 bad_dir++;
217 }
218 if (dx_db->type == DX_DIRBLOCK_LEAF) {
219 depth = htree_depth(dx_dir, dx_db);
220 if (depth != dx_dir->depth) {
221 pctx.num = dx_dir->depth;
222 code = PR_2_HTREE_BAD_DEPTH;
223 fix_problem(ctx, code, &pctx);
224 bad_dir++;
225 }
226 }
227 /*
228 * This test doesn't apply for the root block
229 * at block #0
230 */
231 if (b &&
232 (dx_db->max_hash > dx_db->node_max_hash)) {
233 pctx.blk = dx_db->max_hash;
234 pctx.blk2 = dx_db->node_max_hash;
235 code = PR_2_HTREE_MAX_HASH;
236 fix_problem(ctx, code, &pctx);
237 bad_dir++;
238 }
239 if (!(dx_db->flags & DX_FLAG_REFERENCED)) {
240 code = PR_2_HTREE_NOTREF;
241 fix_problem(ctx, code, &pctx);
242 bad_dir++;
243 } else if (dx_db->flags & DX_FLAG_DUP_REF) {
244 code = PR_2_HTREE_DUPREF;
245 fix_problem(ctx, code, &pctx);
246 bad_dir++;
247 }
248 }
249 if (bad_dir && fix_problem(ctx, PR_2_HTREE_CLEAR, &pctx)) {
250 clear_htree(ctx, dx_dir->ino);
251 dx_dir->numblocks = 0;
252 }
253 }
254 e2fsck_free_dx_dir_info(ctx);
255
256 ext2fs_free_mem(&buf);
257 ext2fs_free_dblist(fs->dblist);
258
259 if (ctx->inode_bad_map) {
260 ext2fs_free_inode_bitmap(ctx->inode_bad_map);
261 ctx->inode_bad_map = 0;
262 }
263 if (ctx->inode_reg_map) {
264 ext2fs_free_inode_bitmap(ctx->inode_reg_map);
265 ctx->inode_reg_map = 0;
266 }
267 if (ctx->encrypted_dirs) {
268 ext2fs_u32_list_free(ctx->encrypted_dirs);
269 ctx->encrypted_dirs = 0;
270 }
271
272 clear_problem_context(&pctx);
273 if (ctx->large_files) {
274 if (!ext2fs_has_feature_large_file(sb) &&
275 fix_problem(ctx, PR_2_FEATURE_LARGE_FILES, &pctx)) {
276 ext2fs_set_feature_large_file(sb);
277 fs->flags &= ~EXT2_FLAG_MASTER_SB_ONLY;
278 ext2fs_mark_super_dirty(fs);
279 }
280 if (sb->s_rev_level == EXT2_GOOD_OLD_REV &&
281 fix_problem(ctx, PR_1_FS_REV_LEVEL, &pctx)) {
282 ext2fs_update_dynamic_rev(fs);
283 ext2fs_mark_super_dirty(fs);
284 }
285 }
286
287 print_resource_track(ctx, _("Pass 2"), &rtrack, fs->io);
288 }
289
290 #define MAX_DEPTH 32000
291 static int htree_depth(struct dx_dir_info *dx_dir,
292 struct dx_dirblock_info *dx_db)
293 {
294 int depth = 0;
295
296 while (dx_db->type != DX_DIRBLOCK_ROOT && depth < MAX_DEPTH) {
297 dx_db = &dx_dir->dx_block[dx_db->parent];
298 depth++;
299 }
300 return depth;
301 }
302
303 static int dict_de_cmp(const void *a, const void *b)
304 {
305 const struct ext2_dir_entry *de_a, *de_b;
306 int a_len, b_len;
307
308 de_a = (const struct ext2_dir_entry *) a;
309 a_len = ext2fs_dirent_name_len(de_a);
310 de_b = (const struct ext2_dir_entry *) b;
311 b_len = ext2fs_dirent_name_len(de_b);
312
313 if (a_len != b_len)
314 return (a_len - b_len);
315
316 return memcmp(de_a->name, de_b->name, a_len);
317 }
318
319 /*
320 * This is special sort function that makes sure that directory blocks
321 * with a dirblock of zero are sorted to the beginning of the list.
322 * This guarantees that the root node of the htree directories are
323 * processed first, so we know what hash version to use.
324 */
325 static EXT2_QSORT_TYPE special_dir_block_cmp(const void *a, const void *b)
326 {
327 const struct ext2_db_entry2 *db_a =
328 (const struct ext2_db_entry2 *) a;
329 const struct ext2_db_entry2 *db_b =
330 (const struct ext2_db_entry2 *) b;
331
332 if (db_a->blockcnt && !db_b->blockcnt)
333 return 1;
334
335 if (!db_a->blockcnt && db_b->blockcnt)
336 return -1;
337
338 if (db_a->blk != db_b->blk)
339 return (int) (db_a->blk - db_b->blk);
340
341 if (db_a->ino != db_b->ino)
342 return (int) (db_a->ino - db_b->ino);
343
344 return (int) (db_a->blockcnt - db_b->blockcnt);
345 }
346
347
348 /*
349 * Make sure the first entry in the directory is '.', and that the
350 * directory entry is sane.
351 */
352 static int check_dot(e2fsck_t ctx,
353 struct ext2_dir_entry *dirent,
354 ext2_ino_t ino, struct problem_context *pctx)
355 {
356 struct ext2_dir_entry *nextdir;
357 unsigned int rec_len, new_len;
358 int status = 0;
359 int created = 0;
360 problem_t problem = 0;
361
362 if (!dirent->inode)
363 problem = PR_2_MISSING_DOT;
364 else if ((ext2fs_dirent_name_len(dirent) != 1) ||
365 (dirent->name[0] != '.'))
366 problem = PR_2_1ST_NOT_DOT;
367 else if (dirent->name[1] != '\0')
368 problem = PR_2_DOT_NULL_TERM;
369
370 (void) ext2fs_get_rec_len(ctx->fs, dirent, &rec_len);
371 if (problem) {
372 if (fix_problem(ctx, problem, pctx)) {
373 if (rec_len < 12)
374 rec_len = dirent->rec_len = 12;
375 dirent->inode = ino;
376 ext2fs_dirent_set_name_len(dirent, 1);
377 ext2fs_dirent_set_file_type(dirent, EXT2_FT_UNKNOWN);
378 dirent->name[0] = '.';
379 dirent->name[1] = '\0';
380 status = 1;
381 created = 1;
382 }
383 }
384 if (dirent->inode != ino) {
385 if (fix_problem(ctx, PR_2_BAD_INODE_DOT, pctx)) {
386 dirent->inode = ino;
387 status = 1;
388 }
389 }
390 if (rec_len > 12) {
391 new_len = rec_len - 12;
392 if (new_len > 12) {
393 if (created ||
394 fix_problem(ctx, PR_2_SPLIT_DOT, pctx)) {
395 nextdir = (struct ext2_dir_entry *)
396 ((char *) dirent + 12);
397 dirent->rec_len = 12;
398 (void) ext2fs_set_rec_len(ctx->fs, new_len,
399 nextdir);
400 nextdir->inode = 0;
401 ext2fs_dirent_set_name_len(nextdir, 0);
402 ext2fs_dirent_set_file_type(nextdir,
403 EXT2_FT_UNKNOWN);
404 status = 1;
405 }
406 }
407 }
408 return status;
409 }
410
411 /*
412 * Make sure the second entry in the directory is '..', and that the
413 * directory entry is sane. We do not check the inode number of '..'
414 * here; this gets done in pass 3.
415 */
416 static int check_dotdot(e2fsck_t ctx,
417 struct ext2_dir_entry *dirent,
418 ext2_ino_t ino, struct problem_context *pctx)
419 {
420 problem_t problem = 0;
421 unsigned int rec_len;
422
423 if (!dirent->inode)
424 problem = PR_2_MISSING_DOT_DOT;
425 else if ((ext2fs_dirent_name_len(dirent) != 2) ||
426 (dirent->name[0] != '.') ||
427 (dirent->name[1] != '.'))
428 problem = PR_2_2ND_NOT_DOT_DOT;
429 else if (dirent->name[2] != '\0')
430 problem = PR_2_DOT_DOT_NULL_TERM;
431
432 (void) ext2fs_get_rec_len(ctx->fs, dirent, &rec_len);
433 if (problem) {
434 if (fix_problem(ctx, problem, pctx)) {
435 if (rec_len < 12)
436 dirent->rec_len = 12;
437 /*
438 * Note: we don't have the parent inode just
439 * yet, so we will fill it in with the root
440 * inode. This will get fixed in pass 3.
441 */
442 dirent->inode = EXT2_ROOT_INO;
443 ext2fs_dirent_set_name_len(dirent, 2);
444 ext2fs_dirent_set_file_type(dirent, EXT2_FT_UNKNOWN);
445 dirent->name[0] = '.';
446 dirent->name[1] = '.';
447 dirent->name[2] = '\0';
448 return 1;
449 }
450 return 0;
451 }
452 if (e2fsck_dir_info_set_dotdot(ctx, ino, dirent->inode)) {
453 fix_problem(ctx, PR_2_NO_DIRINFO, pctx);
454 return -1;
455 }
456 return 0;
457 }
458
459 /*
460 * Check to make sure a directory entry doesn't contain any illegal
461 * characters.
462 */
463 static int check_name(e2fsck_t ctx,
464 struct ext2_dir_entry *dirent,
465 struct problem_context *pctx)
466 {
467 int i;
468 int fixup = -1;
469 int ret = 0;
470
471 for ( i = 0; i < ext2fs_dirent_name_len(dirent); i++) {
472 if (dirent->name[i] != '/' && dirent->name[i] != '\0')
473 continue;
474 if (fixup < 0)
475 fixup = fix_problem(ctx, PR_2_BAD_NAME, pctx);
476 if (fixup == 0)
477 return 0;
478 dirent->name[i] = '.';
479 ret = 1;
480 }
481 return ret;
482 }
483
484 static int encrypted_check_name(e2fsck_t ctx,
485 struct ext2_dir_entry *dirent,
486 struct problem_context *pctx)
487 {
488 if (ext2fs_dirent_name_len(dirent) < EXT4_CRYPTO_BLOCK_SIZE) {
489 if (fix_problem(ctx, PR_2_BAD_ENCRYPTED_NAME, pctx)) {
490 dirent->inode = 0;
491 return 1;
492 }
493 ext2fs_unmark_valid(ctx->fs);
494 }
495 return 0;
496 }
497
498 /*
499 * Check the directory filetype (if present)
500 */
501 static _INLINE_ int check_filetype(e2fsck_t ctx,
502 struct ext2_dir_entry *dirent,
503 ext2_ino_t dir_ino EXT2FS_ATTR((unused)),
504 struct problem_context *pctx)
505 {
506 int filetype = ext2fs_dirent_file_type(dirent);
507 int should_be = EXT2_FT_UNKNOWN;
508 struct ext2_inode inode;
509
510 if (!ext2fs_has_feature_filetype(ctx->fs->super)) {
511 if (filetype == 0 ||
512 !fix_problem(ctx, PR_2_CLEAR_FILETYPE, pctx))
513 return 0;
514 ext2fs_dirent_set_file_type(dirent, EXT2_FT_UNKNOWN);
515 return 1;
516 }
517
518 if (ext2fs_test_inode_bitmap2(ctx->inode_dir_map, dirent->inode)) {
519 should_be = EXT2_FT_DIR;
520 } else if (ext2fs_test_inode_bitmap2(ctx->inode_reg_map,
521 dirent->inode)) {
522 should_be = EXT2_FT_REG_FILE;
523 } else if (ctx->inode_bad_map &&
524 ext2fs_test_inode_bitmap2(ctx->inode_bad_map,
525 dirent->inode))
526 should_be = 0;
527 else {
528 e2fsck_read_inode(ctx, dirent->inode, &inode,
529 "check_filetype");
530 should_be = ext2_file_type(inode.i_mode);
531 }
532 if (filetype == should_be)
533 return 0;
534 pctx->num = should_be;
535
536 if (fix_problem(ctx, filetype ? PR_2_BAD_FILETYPE : PR_2_SET_FILETYPE,
537 pctx) == 0)
538 return 0;
539
540 ext2fs_dirent_set_file_type(dirent, should_be);
541 return 1;
542 }
543
544 static void parse_int_node(ext2_filsys fs,
545 struct ext2_db_entry2 *db,
546 struct check_dir_struct *cd,
547 struct dx_dir_info *dx_dir,
548 char *block_buf, int failed_csum)
549 {
550 struct ext2_dx_root_info *root;
551 struct ext2_dx_entry *ent;
552 struct ext2_dx_countlimit *limit;
553 struct dx_dirblock_info *dx_db;
554 int i, expect_limit, count;
555 blk_t blk;
556 ext2_dirhash_t min_hash = 0xffffffff;
557 ext2_dirhash_t max_hash = 0;
558 ext2_dirhash_t hash = 0, prev_hash;
559 int csum_size = 0;
560
561 if (db->blockcnt == 0) {
562 root = (struct ext2_dx_root_info *) (block_buf + 24);
563
564 #ifdef DX_DEBUG
565 printf("Root node dump:\n");
566 printf("\t Reserved zero: %u\n", root->reserved_zero);
567 printf("\t Hash Version: %d\n", root->hash_version);
568 printf("\t Info length: %d\n", root->info_length);
569 printf("\t Indirect levels: %d\n", root->indirect_levels);
570 printf("\t Flags: %d\n", root->unused_flags);
571 #endif
572
573 ent = (struct ext2_dx_entry *) (block_buf + 24 + root->info_length);
574
575 if (failed_csum &&
576 (e2fsck_dir_will_be_rehashed(cd->ctx, cd->pctx.ino) ||
577 fix_problem(cd->ctx, PR_2_HTREE_ROOT_CSUM_INVALID,
578 &cd->pctx)))
579 goto clear_and_exit;
580 } else {
581 ent = (struct ext2_dx_entry *) (block_buf+8);
582
583 if (failed_csum &&
584 (e2fsck_dir_will_be_rehashed(cd->ctx, cd->pctx.ino) ||
585 fix_problem(cd->ctx, PR_2_HTREE_NODE_CSUM_INVALID,
586 &cd->pctx)))
587 goto clear_and_exit;
588 }
589
590 limit = (struct ext2_dx_countlimit *) ent;
591
592 #ifdef DX_DEBUG
593 printf("Number of entries (count): %d\n",
594 ext2fs_le16_to_cpu(limit->count));
595 printf("Number of entries (limit): %d\n",
596 ext2fs_le16_to_cpu(limit->limit));
597 #endif
598
599 count = ext2fs_le16_to_cpu(limit->count);
600 if (ext2fs_has_feature_metadata_csum(fs->super))
601 csum_size = sizeof(struct ext2_dx_tail);
602 expect_limit = (fs->blocksize -
603 (csum_size + ((char *) ent - block_buf))) /
604 sizeof(struct ext2_dx_entry);
605 if (ext2fs_le16_to_cpu(limit->limit) != expect_limit) {
606 cd->pctx.num = ext2fs_le16_to_cpu(limit->limit);
607 if (fix_problem(cd->ctx, PR_2_HTREE_BAD_LIMIT, &cd->pctx))
608 goto clear_and_exit;
609 }
610 if (count > expect_limit) {
611 cd->pctx.num = count;
612 if (fix_problem(cd->ctx, PR_2_HTREE_BAD_COUNT, &cd->pctx))
613 goto clear_and_exit;
614 count = expect_limit;
615 }
616
617 for (i=0; i < count; i++) {
618 prev_hash = hash;
619 hash = i ? (ext2fs_le32_to_cpu(ent[i].hash) & ~1) : 0;
620 #ifdef DX_DEBUG
621 printf("Entry #%d: Hash 0x%08x, block %u\n", i,
622 hash, ext2fs_le32_to_cpu(ent[i].block));
623 #endif
624 blk = ext2fs_le32_to_cpu(ent[i].block) & 0x0ffffff;
625 /* Check to make sure the block is valid */
626 if (blk >= (blk_t) dx_dir->numblocks) {
627 cd->pctx.blk = blk;
628 if (fix_problem(cd->ctx, PR_2_HTREE_BADBLK,
629 &cd->pctx))
630 goto clear_and_exit;
631 continue;
632 }
633 if (hash < prev_hash &&
634 fix_problem(cd->ctx, PR_2_HTREE_HASH_ORDER, &cd->pctx))
635 goto clear_and_exit;
636 dx_db = &dx_dir->dx_block[blk];
637 if (dx_db->flags & DX_FLAG_REFERENCED) {
638 dx_db->flags |= DX_FLAG_DUP_REF;
639 } else {
640 dx_db->flags |= DX_FLAG_REFERENCED;
641 dx_db->parent = db->blockcnt;
642 }
643 if (hash < min_hash)
644 min_hash = hash;
645 if (hash > max_hash)
646 max_hash = hash;
647 dx_db->node_min_hash = hash;
648 if ((i+1) < count)
649 dx_db->node_max_hash =
650 ext2fs_le32_to_cpu(ent[i+1].hash) & ~1;
651 else {
652 dx_db->node_max_hash = 0xfffffffe;
653 dx_db->flags |= DX_FLAG_LAST;
654 }
655 if (i == 0)
656 dx_db->flags |= DX_FLAG_FIRST;
657 }
658 #ifdef DX_DEBUG
659 printf("Blockcnt = %d, min hash 0x%08x, max hash 0x%08x\n",
660 db->blockcnt, min_hash, max_hash);
661 #endif
662 dx_db = &dx_dir->dx_block[db->blockcnt];
663 dx_db->min_hash = min_hash;
664 dx_db->max_hash = max_hash;
665 return;
666
667 clear_and_exit:
668 clear_htree(cd->ctx, cd->pctx.ino);
669 dx_dir->numblocks = 0;
670 e2fsck_rehash_dir_later(cd->ctx, cd->pctx.ino);
671 }
672
673 /*
674 * Given a busted directory, try to salvage it somehow.
675 *
676 */
677 static void salvage_directory(ext2_filsys fs,
678 struct ext2_dir_entry *dirent,
679 struct ext2_dir_entry *prev,
680 unsigned int *offset,
681 unsigned int block_len)
682 {
683 char *cp = (char *) dirent;
684 int left;
685 unsigned int rec_len, prev_rec_len;
686 unsigned int name_len;
687
688 /*
689 * If the space left for the entry is too small to be an entry,
690 * we can't access dirent's fields, so plumb in the values needed
691 * so that the previous entry absorbs this one.
692 */
693 if (block_len - *offset < EXT2_DIR_ENTRY_HEADER_LEN) {
694 name_len = 0;
695 rec_len = block_len - *offset;
696 } else {
697 name_len = ext2fs_dirent_name_len(dirent);
698 (void) ext2fs_get_rec_len(fs, dirent, &rec_len);
699 }
700 left = block_len - *offset - rec_len;
701
702 /*
703 * Special case of directory entry of size 8: copy what's left
704 * of the directory block up to cover up the invalid hole.
705 */
706 if ((left >= 12) && (rec_len == EXT2_DIR_ENTRY_HEADER_LEN)) {
707 memmove(cp, cp+EXT2_DIR_ENTRY_HEADER_LEN, left);
708 memset(cp + left, 0, EXT2_DIR_ENTRY_HEADER_LEN);
709 return;
710 }
711 /*
712 * If the directory entry overruns the end of the directory
713 * block, and the name is small enough to fit, then adjust the
714 * record length.
715 */
716 if ((left < 0) &&
717 ((int) rec_len + left > EXT2_DIR_ENTRY_HEADER_LEN) &&
718 ((int) name_len + EXT2_DIR_ENTRY_HEADER_LEN <= (int) rec_len + left) &&
719 dirent->inode <= fs->super->s_inodes_count &&
720 strnlen(dirent->name, name_len) == name_len) {
721 (void) ext2fs_set_rec_len(fs, (int) rec_len + left, dirent);
722 return;
723 }
724 /*
725 * If the record length of the directory entry is a multiple
726 * of four, and not too big, such that it is valid, let the
727 * previous directory entry absorb the invalid one.
728 */
729 if (prev && rec_len && (rec_len % 4) == 0 &&
730 (*offset + rec_len <= block_len)) {
731 (void) ext2fs_get_rec_len(fs, prev, &prev_rec_len);
732 prev_rec_len += rec_len;
733 (void) ext2fs_set_rec_len(fs, prev_rec_len, prev);
734 *offset += rec_len;
735 return;
736 }
737 /*
738 * Default salvage method --- kill all of the directory
739 * entries for the rest of the block. We will either try to
740 * absorb it into the previous directory entry, or create a
741 * new empty directory entry the rest of the directory block.
742 */
743 if (prev) {
744 (void) ext2fs_get_rec_len(fs, prev, &prev_rec_len);
745 prev_rec_len += block_len - *offset;
746 (void) ext2fs_set_rec_len(fs, prev_rec_len, prev);
747 *offset = fs->blocksize;
748 } else {
749 rec_len = block_len - *offset;
750 (void) ext2fs_set_rec_len(fs, rec_len, dirent);
751 ext2fs_dirent_set_name_len(dirent, 0);
752 ext2fs_dirent_set_file_type(dirent, EXT2_FT_UNKNOWN);
753 dirent->inode = 0;
754 }
755 }
756
757 #define NEXT_DIRENT(d) ((void *)((char *)(d) + (d)->rec_len))
758 static errcode_t insert_dirent_tail(ext2_filsys fs, void *dirbuf)
759 {
760 struct ext2_dir_entry *d;
761 void *top;
762 struct ext2_dir_entry_tail *t;
763
764 d = dirbuf;
765 top = EXT2_DIRENT_TAIL(dirbuf, fs->blocksize);
766
767 while (d->rec_len && !(d->rec_len & 0x3) && NEXT_DIRENT(d) <= top)
768 d = NEXT_DIRENT(d);
769
770 if (d != top) {
771 unsigned int min_size = EXT2_DIR_REC_LEN(
772 ext2fs_dirent_name_len(dirbuf));
773 if (min_size > (char *)top - (char *)d)
774 return EXT2_ET_DIR_NO_SPACE_FOR_CSUM;
775 d->rec_len = (char *)top - (char *)d;
776 }
777
778 t = (struct ext2_dir_entry_tail *)top;
779 if (t->det_reserved_zero1 ||
780 t->det_rec_len != sizeof(struct ext2_dir_entry_tail) ||
781 t->det_reserved_name_len != EXT2_DIR_NAME_LEN_CSUM)
782 ext2fs_initialize_dirent_tail(fs, t);
783
784 return 0;
785 }
786 #undef NEXT_DIRENT
787
788 static errcode_t fix_inline_dir_size(e2fsck_t ctx, ext2_ino_t ino,
789 size_t *inline_data_size,
790 struct problem_context *pctx,
791 char *buf)
792 {
793 ext2_filsys fs = ctx->fs;
794 struct ext2_inode inode;
795 size_t new_size, old_size;
796 errcode_t retval;
797
798 old_size = *inline_data_size;
799 /*
800 * If there's not enough bytes to start the "second" dir block
801 * (in the EA space) then truncate everything to the first block.
802 */
803 if (old_size > EXT4_MIN_INLINE_DATA_SIZE &&
804 old_size < EXT4_MIN_INLINE_DATA_SIZE +
805 EXT2_DIR_REC_LEN(1)) {
806 old_size = EXT4_MIN_INLINE_DATA_SIZE;
807 new_size = old_size;
808 } else
809 /* Increase to the next four-byte boundary for salvaging */
810 new_size = old_size + (4 - (old_size & 3));
811 memset(buf + old_size, 0, new_size - old_size);
812 retval = ext2fs_inline_data_set(fs, ino, 0, buf, new_size);
813 if (retval == EXT2_ET_INLINE_DATA_NO_SPACE) {
814 /* Or we can't, so truncate. */
815 new_size -= 4;
816 retval = ext2fs_inline_data_set(fs, ino, 0, buf, new_size);
817 if (retval) {
818 if (fix_problem(ctx, PR_2_FIX_INLINE_DIR_FAILED,
819 pctx)) {
820 new_size = 0;
821 goto write_inode;
822 }
823 goto err;
824 }
825 } else if (retval) {
826 if (fix_problem(ctx, PR_2_FIX_INLINE_DIR_FAILED,
827 pctx)) {
828 new_size = 0;
829 goto write_inode;
830 }
831 goto err;
832 }
833
834 write_inode:
835 retval = ext2fs_read_inode(fs, ino, &inode);
836 if (retval)
837 goto err;
838
839 retval = ext2fs_inode_size_set(fs, &inode, new_size);
840 if (retval)
841 goto err;
842 if (new_size == 0)
843 inode.i_flags &= ~EXT4_INLINE_DATA_FL;
844 retval = ext2fs_write_inode(fs, ino, &inode);
845 if (retval)
846 goto err;
847 *inline_data_size = new_size;
848
849 err:
850 return retval;
851 }
852
853 static int check_dir_block2(ext2_filsys fs,
854 struct ext2_db_entry2 *db,
855 void *priv_data)
856 {
857 int err;
858 struct check_dir_struct *cd = priv_data;
859
860 if (cd->ra_entries && cd->list_offset >= cd->next_ra_off) {
861 err = e2fsck_readahead_dblist(fs,
862 E2FSCK_RA_DBLIST_IGNORE_BLOCKCNT,
863 fs->dblist,
864 cd->list_offset + cd->ra_entries / 8,
865 cd->ra_entries);
866 if (err)
867 cd->ra_entries = 0;
868 cd->next_ra_off = cd->list_offset + (cd->ra_entries * 7 / 8);
869 }
870
871 err = check_dir_block(fs, db, priv_data);
872 cd->list_offset++;
873 return err;
874 }
875
876 static int check_dir_block(ext2_filsys fs,
877 struct ext2_db_entry2 *db,
878 void *priv_data)
879 {
880 struct dx_dir_info *dx_dir;
881 struct dx_dirblock_info *dx_db = 0;
882 struct ext2_dir_entry *dirent, *prev, dot, dotdot;
883 ext2_dirhash_t hash;
884 unsigned int offset = 0;
885 int dir_modified = 0;
886 int dot_state;
887 unsigned int rec_len;
888 blk64_t block_nr = db->blk;
889 ext2_ino_t ino = db->ino;
890 ext2_ino_t subdir_parent;
891 __u16 links;
892 struct check_dir_struct *cd;
893 char *buf, *ibuf;
894 e2fsck_t ctx;
895 problem_t problem;
896 struct ext2_dx_root_info *root;
897 struct ext2_dx_countlimit *limit;
898 static dict_t de_dict;
899 struct problem_context pctx;
900 int dups_found = 0;
901 int ret;
902 int dx_csum_size = 0, de_csum_size = 0;
903 int failed_csum = 0;
904 int is_leaf = 1;
905 size_t inline_data_size = 0;
906 int filetype = 0;
907 int encrypted = 0;
908 size_t max_block_size;
909
910 cd = (struct check_dir_struct *) priv_data;
911 ibuf = buf = cd->buf;
912 ctx = cd->ctx;
913
914 if (ctx->flags & E2F_FLAG_RUN_RETURN)
915 return DIRENT_ABORT;
916
917 if (ctx->progress && (ctx->progress)(ctx, 2, cd->count++, cd->max))
918 return DIRENT_ABORT;
919
920 if (ext2fs_has_feature_metadata_csum(fs->super)) {
921 dx_csum_size = sizeof(struct ext2_dx_tail);
922 de_csum_size = sizeof(struct ext2_dir_entry_tail);
923 }
924
925 if (ext2fs_has_feature_filetype(fs->super))
926 filetype = EXT2_FT_DIR << 8;
927
928 /*
929 * Make sure the inode is still in use (could have been
930 * deleted in the duplicate/bad blocks pass.
931 */
932 if (!(ext2fs_test_inode_bitmap2(ctx->inode_used_map, ino)))
933 return 0;
934
935 cd->pctx.ino = ino;
936 cd->pctx.blk = block_nr;
937 cd->pctx.blkcount = db->blockcnt;
938 cd->pctx.ino2 = 0;
939 cd->pctx.dirent = 0;
940 cd->pctx.num = 0;
941
942 if (ext2fs_has_feature_inline_data(fs->super)) {
943 errcode_t ec;
944
945 ec = ext2fs_inline_data_size(fs, ino, &inline_data_size);
946 if (ec && ec != EXT2_ET_NO_INLINE_DATA)
947 return DIRENT_ABORT;
948 }
949
950 if (db->blk == 0 && !inline_data_size) {
951 if (allocate_dir_block(ctx, db, buf, &cd->pctx))
952 return 0;
953 block_nr = db->blk;
954 }
955
956 if (db->blockcnt)
957 dot_state = 2;
958 else
959 dot_state = 0;
960
961 if (ctx->dirs_to_hash &&
962 ext2fs_u32_list_test(ctx->dirs_to_hash, ino))
963 dups_found++;
964
965 #if 0
966 printf("In process_dir_block block %lu, #%d, inode %lu\n", block_nr,
967 db->blockcnt, ino);
968 #endif
969
970 ehandler_operation(_("reading directory block"));
971 if (inline_data_size) {
972 memset(buf, 0, fs->blocksize - inline_data_size);
973 cd->pctx.errcode = ext2fs_inline_data_get(fs, ino, 0, buf, 0);
974 if (cd->pctx.errcode)
975 goto inline_read_fail;
976 #ifdef WORDS_BIGENDIAN
977 if (db->blockcnt)
978 goto skip_first_read_swab;
979 *((__u32 *)buf) = ext2fs_le32_to_cpu(*((__u32 *)buf));
980 cd->pctx.errcode = ext2fs_dirent_swab_in2(fs,
981 buf + EXT4_INLINE_DATA_DOTDOT_SIZE,
982 EXT4_MIN_INLINE_DATA_SIZE - EXT4_INLINE_DATA_DOTDOT_SIZE,
983 0);
984 if (cd->pctx.errcode)
985 goto inline_read_fail;
986 skip_first_read_swab:
987 if (inline_data_size <= EXT4_MIN_INLINE_DATA_SIZE ||
988 !db->blockcnt)
989 goto inline_read_fail;
990 cd->pctx.errcode = ext2fs_dirent_swab_in2(fs,
991 buf + EXT4_MIN_INLINE_DATA_SIZE,
992 inline_data_size - EXT4_MIN_INLINE_DATA_SIZE,
993 0);
994 #endif
995 } else
996 cd->pctx.errcode = ext2fs_read_dir_block4(fs, block_nr,
997 buf, 0, ino);
998 inline_read_fail:
999 pctx.ino = ino;
1000 pctx.num = inline_data_size;
1001 if (((inline_data_size & 3) ||
1002 (inline_data_size > EXT4_MIN_INLINE_DATA_SIZE &&
1003 inline_data_size < EXT4_MIN_INLINE_DATA_SIZE +
1004 EXT2_DIR_REC_LEN(1))) &&
1005 fix_problem(ctx, PR_2_BAD_INLINE_DIR_SIZE, &pctx)) {
1006 errcode_t err = fix_inline_dir_size(ctx, ino,
1007 &inline_data_size, &pctx,
1008 buf);
1009 if (err)
1010 return DIRENT_ABORT;
1011
1012 }
1013 ehandler_operation(0);
1014 if (cd->pctx.errcode == EXT2_ET_DIR_CORRUPTED)
1015 cd->pctx.errcode = 0; /* We'll handle this ourselves */
1016 else if (cd->pctx.errcode == EXT2_ET_DIR_CSUM_INVALID) {
1017 cd->pctx.errcode = 0; /* We'll handle this ourselves */
1018 failed_csum = 1;
1019 }
1020 if (cd->pctx.errcode) {
1021 char *buf2;
1022 if (!fix_problem(ctx, PR_2_READ_DIRBLOCK, &cd->pctx)) {
1023 ctx->flags |= E2F_FLAG_ABORT;
1024 return DIRENT_ABORT;
1025 }
1026 ext2fs_new_dir_block(fs, db->blockcnt == 0 ? ino : 0,
1027 EXT2_ROOT_INO, &buf2);
1028 memcpy(buf, buf2, fs->blocksize);
1029 ext2fs_free_mem(&buf2);
1030 }
1031 dx_dir = e2fsck_get_dx_dir_info(ctx, ino);
1032 if (dx_dir && dx_dir->numblocks) {
1033 if (db->blockcnt >= dx_dir->numblocks) {
1034 pctx.dir = ino;
1035 if (fix_problem(ctx, PR_2_UNEXPECTED_HTREE_BLOCK,
1036 &pctx)) {
1037 clear_htree(ctx, ino);
1038 dx_dir->numblocks = 0;
1039 dx_db = 0;
1040 goto out_htree;
1041 }
1042 fatal_error(ctx, _("Can not continue."));
1043 }
1044 dx_db = &dx_dir->dx_block[db->blockcnt];
1045 dx_db->type = DX_DIRBLOCK_LEAF;
1046 dx_db->phys = block_nr;
1047 dx_db->min_hash = ~0;
1048 dx_db->max_hash = 0;
1049
1050 dirent = (struct ext2_dir_entry *) buf;
1051 (void) ext2fs_get_rec_len(fs, dirent, &rec_len);
1052 limit = (struct ext2_dx_countlimit *) (buf+8);
1053 if (db->blockcnt == 0) {
1054 root = (struct ext2_dx_root_info *) (buf + 24);
1055 dx_db->type = DX_DIRBLOCK_ROOT;
1056 dx_db->flags |= DX_FLAG_FIRST | DX_FLAG_LAST;
1057 if ((root->reserved_zero ||
1058 root->info_length < 8 ||
1059 root->indirect_levels > 1) &&
1060 fix_problem(ctx, PR_2_HTREE_BAD_ROOT, &cd->pctx)) {
1061 clear_htree(ctx, ino);
1062 dx_dir->numblocks = 0;
1063 dx_db = 0;
1064 }
1065 dx_dir->hashversion = root->hash_version;
1066 if ((dx_dir->hashversion <= EXT2_HASH_TEA) &&
1067 (fs->super->s_flags & EXT2_FLAGS_UNSIGNED_HASH))
1068 dx_dir->hashversion += 3;
1069 dx_dir->depth = root->indirect_levels + 1;
1070 } else if ((dirent->inode == 0) &&
1071 (rec_len == fs->blocksize) &&
1072 (ext2fs_dirent_name_len(dirent) == 0) &&
1073 (ext2fs_le16_to_cpu(limit->limit) ==
1074 ((fs->blocksize - (8 + dx_csum_size)) /
1075 sizeof(struct ext2_dx_entry))))
1076 dx_db->type = DX_DIRBLOCK_NODE;
1077 is_leaf = (dx_db->type == DX_DIRBLOCK_LEAF);
1078 }
1079 out_htree:
1080
1081 /* Leaf node with no space for csum? Rebuild dirs in pass 3A. */
1082 if (is_leaf && !inline_data_size && failed_csum &&
1083 !ext2fs_dirent_has_tail(fs, (struct ext2_dir_entry *)buf)) {
1084 de_csum_size = 0;
1085 if (e2fsck_dir_will_be_rehashed(ctx, ino)) {
1086 failed_csum = 0;
1087 goto skip_checksum;
1088 }
1089 if (!fix_problem(cd->ctx, PR_2_LEAF_NODE_MISSING_CSUM,
1090 &cd->pctx))
1091 goto skip_checksum;
1092 e2fsck_rehash_dir_later(ctx, ino);
1093 failed_csum = 0;
1094 goto skip_checksum;
1095 }
1096 /* htree nodes don't use fake dirents to store checksums */
1097 if (!is_leaf)
1098 de_csum_size = 0;
1099
1100 skip_checksum:
1101 if (inline_data_size) {
1102 if (db->blockcnt) {
1103 buf += EXT4_MIN_INLINE_DATA_SIZE;
1104 max_block_size = inline_data_size - EXT4_MIN_INLINE_DATA_SIZE;
1105 /* Zero-length second block, just exit */
1106 if (max_block_size == 0)
1107 return 0;
1108 } else {
1109 max_block_size = EXT4_MIN_INLINE_DATA_SIZE;
1110 }
1111 } else
1112 max_block_size = fs->blocksize - de_csum_size;
1113
1114 if (ctx->encrypted_dirs)
1115 encrypted = ext2fs_u32_list_test(ctx->encrypted_dirs, ino);
1116
1117 dict_init(&de_dict, DICTCOUNT_T_MAX, dict_de_cmp);
1118 prev = 0;
1119 do {
1120 dgrp_t group;
1121 ext2_ino_t first_unused_inode;
1122 unsigned int name_len;
1123
1124 problem = 0;
1125 if (!inline_data_size || dot_state > 1) {
1126 dirent = (struct ext2_dir_entry *) (buf + offset);
1127 /*
1128 * If there's not even space for the entry header,
1129 * force salvaging this dir.
1130 */
1131 if (max_block_size - offset < EXT2_DIR_ENTRY_HEADER_LEN)
1132 rec_len = EXT2_DIR_REC_LEN(1);
1133 else
1134 (void) ext2fs_get_rec_len(fs, dirent, &rec_len);
1135 cd->pctx.dirent = dirent;
1136 cd->pctx.num = offset;
1137 if ((offset + rec_len > max_block_size) ||
1138 (rec_len < 12) ||
1139 ((rec_len % 4) != 0) ||
1140 (((unsigned) ext2fs_dirent_name_len(dirent) + EXT2_DIR_ENTRY_HEADER_LEN) > rec_len)) {
1141 if (fix_problem(ctx, PR_2_DIR_CORRUPTED,
1142 &cd->pctx)) {
1143 #ifdef WORDS_BIGENDIAN
1144 /*
1145 * On big-endian systems, if the dirent
1146 * swap routine finds a rec_len that it
1147 * doesn't like, it continues
1148 * processing the block as if rec_len
1149 * == EXT2_DIR_ENTRY_HEADER_LEN. This means that the name
1150 * field gets byte swapped, which means
1151 * that salvage will not detect the
1152 * correct name length (unless the name
1153 * has a length that's an exact
1154 * multiple of four bytes), and it'll
1155 * discard the entry (unnecessarily)
1156 * and the rest of the dirent block.
1157 * Therefore, swap the rest of the
1158 * block back to disk order, run
1159 * salvage, and re-swap anything after
1160 * the salvaged dirent.
1161 */
1162 int need_reswab = 0;
1163 if (rec_len < EXT2_DIR_ENTRY_HEADER_LEN || rec_len % 4) {
1164 need_reswab = 1;
1165 ext2fs_dirent_swab_in2(fs,
1166 ((char *)dirent) + EXT2_DIR_ENTRY_HEADER_LEN,
1167 max_block_size - offset - EXT2_DIR_ENTRY_HEADER_LEN,
1168 0);
1169 }
1170 #endif
1171 salvage_directory(fs, dirent, prev,
1172 &offset,
1173 max_block_size);
1174 #ifdef WORDS_BIGENDIAN
1175 if (need_reswab) {
1176 (void) ext2fs_get_rec_len(fs,
1177 dirent, &rec_len);
1178 ext2fs_dirent_swab_in2(fs,
1179 ((char *)dirent) + offset + rec_len,
1180 max_block_size - offset - rec_len,
1181 0);
1182 }
1183 #endif
1184 dir_modified++;
1185 continue;
1186 } else
1187 goto abort_free_dict;
1188 }
1189 } else {
1190 if (dot_state == 0) {
1191 memset(&dot, 0, sizeof(dot));
1192 dirent = &dot;
1193 dirent->inode = ino;
1194 dirent->rec_len = EXT2_DIR_REC_LEN(1);
1195 dirent->name_len = 1 | filetype;
1196 dirent->name[0] = '.';
1197 } else if (dot_state == 1) {
1198 memset(&dotdot, 0, sizeof(dotdot));
1199 dirent = &dotdot;
1200 dirent->inode =
1201 ((struct ext2_dir_entry *)buf)->inode;
1202 dirent->rec_len = EXT2_DIR_REC_LEN(2);
1203 dirent->name_len = 2 | filetype;
1204 dirent->name[0] = '.';
1205 dirent->name[1] = '.';
1206 } else {
1207 fatal_error(ctx, _("Can not continue."));
1208 }
1209 cd->pctx.dirent = dirent;
1210 cd->pctx.num = offset;
1211 }
1212
1213 if (dot_state == 0) {
1214 if (check_dot(ctx, dirent, ino, &cd->pctx))
1215 dir_modified++;
1216 } else if (dot_state == 1) {
1217 ret = check_dotdot(ctx, dirent, ino, &cd->pctx);
1218 if (ret < 0)
1219 goto abort_free_dict;
1220 if (ret)
1221 dir_modified++;
1222 } else if (dirent->inode == ino) {
1223 problem = PR_2_LINK_DOT;
1224 if (fix_problem(ctx, PR_2_LINK_DOT, &cd->pctx)) {
1225 dirent->inode = 0;
1226 dir_modified++;
1227 goto next;
1228 }
1229 }
1230 if (!dirent->inode)
1231 goto next;
1232
1233 /*
1234 * Make sure the inode listed is a legal one.
1235 */
1236 name_len = ext2fs_dirent_name_len(dirent);
1237 if (((dirent->inode != EXT2_ROOT_INO) &&
1238 (dirent->inode < EXT2_FIRST_INODE(fs->super))) ||
1239 (dirent->inode > fs->super->s_inodes_count)) {
1240 problem = PR_2_BAD_INO;
1241 } else if (ctx->inode_bb_map &&
1242 (ext2fs_test_inode_bitmap2(ctx->inode_bb_map,
1243 dirent->inode))) {
1244 /*
1245 * If the inode is in a bad block, offer to
1246 * clear it.
1247 */
1248 problem = PR_2_BB_INODE;
1249 } else if ((dot_state > 1) && (name_len == 1) &&
1250 (dirent->name[0] == '.')) {
1251 /*
1252 * If there's a '.' entry in anything other
1253 * than the first directory entry, it's a
1254 * duplicate entry that should be removed.
1255 */
1256 problem = PR_2_DUP_DOT;
1257 } else if ((dot_state > 1) && (name_len == 2) &&
1258 (dirent->name[0] == '.') &&
1259 (dirent->name[1] == '.')) {
1260 /*
1261 * If there's a '..' entry in anything other
1262 * than the second directory entry, it's a
1263 * duplicate entry that should be removed.
1264 */
1265 problem = PR_2_DUP_DOT_DOT;
1266 } else if ((dot_state > 1) &&
1267 (dirent->inode == EXT2_ROOT_INO)) {
1268 /*
1269 * Don't allow links to the root directory.
1270 * We check this specially to make sure we
1271 * catch this error case even if the root
1272 * directory hasn't been created yet.
1273 */
1274 problem = PR_2_LINK_ROOT;
1275 } else if ((dot_state > 1) && (name_len == 0)) {
1276 /*
1277 * Don't allow zero-length directory names.
1278 */
1279 problem = PR_2_NULL_NAME;
1280 }
1281
1282 if (problem) {
1283 if (fix_problem(ctx, problem, &cd->pctx)) {
1284 dirent->inode = 0;
1285 dir_modified++;
1286 goto next;
1287 } else {
1288 ext2fs_unmark_valid(fs);
1289 if (problem == PR_2_BAD_INO)
1290 goto next;
1291 }
1292 }
1293
1294 /*
1295 * If the inode was marked as having bad fields in
1296 * pass1, process it and offer to fix/clear it.
1297 * (We wait until now so that we can display the
1298 * pathname to the user.)
1299 */
1300 if (ctx->inode_bad_map &&
1301 ext2fs_test_inode_bitmap2(ctx->inode_bad_map,
1302 dirent->inode)) {
1303 if (e2fsck_process_bad_inode(ctx, ino,
1304 dirent->inode,
1305 buf + fs->blocksize)) {
1306 dirent->inode = 0;
1307 dir_modified++;
1308 goto next;
1309 }
1310 if (ctx->flags & E2F_FLAG_SIGNAL_MASK)
1311 return DIRENT_ABORT;
1312 }
1313
1314 group = ext2fs_group_of_ino(fs, dirent->inode);
1315 first_unused_inode = group * fs->super->s_inodes_per_group +
1316 1 + fs->super->s_inodes_per_group -
1317 ext2fs_bg_itable_unused(fs, group);
1318 cd->pctx.group = group;
1319
1320 /*
1321 * Check if the inode was missed out because
1322 * _INODE_UNINIT flag was set or bg_itable_unused was
1323 * incorrect. If so, clear the _INODE_UNINIT flag and
1324 * restart e2fsck. In the future it would be nice if
1325 * we could call a function in pass1.c that checks the
1326 * newly visible inodes.
1327 */
1328 if (ext2fs_bg_flags_test(fs, group, EXT2_BG_INODE_UNINIT)) {
1329 pctx.num = dirent->inode;
1330 if (fix_problem(ctx, PR_2_INOREF_BG_INO_UNINIT,
1331 &cd->pctx)){
1332 ext2fs_bg_flags_clear(fs, group,
1333 EXT2_BG_INODE_UNINIT);
1334 ext2fs_mark_super_dirty(fs);
1335 ctx->flags |= E2F_FLAG_RESTART_LATER;
1336 } else {
1337 ext2fs_unmark_valid(fs);
1338 if (problem == PR_2_BAD_INO)
1339 goto next;
1340 }
1341 } else if (dirent->inode >= first_unused_inode) {
1342 pctx.num = dirent->inode;
1343 if (fix_problem(ctx, PR_2_INOREF_IN_UNUSED, &cd->pctx)){
1344 ext2fs_bg_itable_unused_set(fs, group, 0);
1345 ext2fs_mark_super_dirty(fs);
1346 ctx->flags |= E2F_FLAG_RESTART_LATER;
1347 } else {
1348 ext2fs_unmark_valid(fs);
1349 if (problem == PR_2_BAD_INO)
1350 goto next;
1351 }
1352 }
1353
1354 /*
1355 * Offer to clear unused inodes; if we are going to be
1356 * restarting the scan due to bg_itable_unused being
1357 * wrong, then don't clear any inodes to avoid zapping
1358 * inodes that were skipped during pass1 due to an
1359 * incorrect bg_itable_unused; we'll get any real
1360 * problems after we restart.
1361 */
1362 if (!(ctx->flags & E2F_FLAG_RESTART_LATER) &&
1363 !(ext2fs_test_inode_bitmap2(ctx->inode_used_map,
1364 dirent->inode)))
1365 problem = PR_2_UNUSED_INODE;
1366
1367 if (problem) {
1368 if (fix_problem(ctx, problem, &cd->pctx)) {
1369 dirent->inode = 0;
1370 dir_modified++;
1371 goto next;
1372 } else {
1373 ext2fs_unmark_valid(fs);
1374 if (problem == PR_2_BAD_INO)
1375 goto next;
1376 }
1377 }
1378
1379 if (!encrypted && check_name(ctx, dirent, &cd->pctx))
1380 dir_modified++;
1381
1382 if (encrypted && (dot_state) > 1 &&
1383 encrypted_check_name(ctx, dirent, &cd->pctx)) {
1384 dir_modified++;
1385 goto next;
1386 }
1387
1388 if (check_filetype(ctx, dirent, ino, &cd->pctx))
1389 dir_modified++;
1390
1391 if (dx_db) {
1392 ext2fs_dirhash(dx_dir->hashversion, dirent->name,
1393 ext2fs_dirent_name_len(dirent),
1394 fs->super->s_hash_seed, &hash, 0);
1395 if (hash < dx_db->min_hash)
1396 dx_db->min_hash = hash;
1397 if (hash > dx_db->max_hash)
1398 dx_db->max_hash = hash;
1399 }
1400
1401 /*
1402 * If this is a directory, then mark its parent in its
1403 * dir_info structure. If the parent field is already
1404 * filled in, then this directory has more than one
1405 * hard link. We assume the first link is correct,
1406 * and ask the user if he/she wants to clear this one.
1407 */
1408 if ((dot_state > 1) &&
1409 (ext2fs_test_inode_bitmap2(ctx->inode_dir_map,
1410 dirent->inode))) {
1411 if (e2fsck_dir_info_get_parent(ctx, dirent->inode,
1412 &subdir_parent)) {
1413 cd->pctx.ino = dirent->inode;
1414 fix_problem(ctx, PR_2_NO_DIRINFO, &cd->pctx);
1415 goto abort_free_dict;
1416 }
1417 if (subdir_parent) {
1418 cd->pctx.ino2 = subdir_parent;
1419 if (fix_problem(ctx, PR_2_LINK_DIR,
1420 &cd->pctx)) {
1421 dirent->inode = 0;
1422 dir_modified++;
1423 goto next;
1424 }
1425 cd->pctx.ino2 = 0;
1426 } else {
1427 (void) e2fsck_dir_info_set_parent(ctx,
1428 dirent->inode, ino);
1429 }
1430 }
1431
1432 if (dups_found) {
1433 ;
1434 } else if (dict_lookup(&de_dict, dirent)) {
1435 clear_problem_context(&pctx);
1436 pctx.ino = ino;
1437 pctx.dirent = dirent;
1438 fix_problem(ctx, PR_2_REPORT_DUP_DIRENT, &pctx);
1439 e2fsck_rehash_dir_later(ctx, ino);
1440 dups_found++;
1441 } else
1442 dict_alloc_insert(&de_dict, dirent, dirent);
1443
1444 ext2fs_icount_increment(ctx->inode_count, dirent->inode,
1445 &links);
1446 if (links > 1)
1447 ctx->fs_links_count++;
1448 ctx->fs_total_count++;
1449 next:
1450 prev = dirent;
1451 if (dir_modified)
1452 (void) ext2fs_get_rec_len(fs, dirent, &rec_len);
1453 if (!inline_data_size || dot_state > 1) {
1454 offset += rec_len;
1455 } else {
1456 if (dot_state == 1) {
1457 offset = 4;
1458 /*
1459 * If we get here, we're checking an inline
1460 * directory and we've just checked a (fake)
1461 * dotdot entry that we created on the stack.
1462 * Therefore set 'prev' to NULL so that if we
1463 * call salvage_directory on the next entry,
1464 * it won't try to absorb the next entry into
1465 * the on-stack dotdot entry.
1466 */
1467 prev = NULL;
1468 }
1469 }
1470 dot_state++;
1471 } while (offset < max_block_size);
1472 #if 0
1473 printf("\n");
1474 #endif
1475 if (dx_db) {
1476 #ifdef DX_DEBUG
1477 printf("db_block %d, type %d, min_hash 0x%0x, max_hash 0x%0x\n",
1478 db->blockcnt, dx_db->type,
1479 dx_db->min_hash, dx_db->max_hash);
1480 #endif
1481 cd->pctx.dir = cd->pctx.ino;
1482 if ((dx_db->type == DX_DIRBLOCK_ROOT) ||
1483 (dx_db->type == DX_DIRBLOCK_NODE))
1484 parse_int_node(fs, db, cd, dx_dir, buf, failed_csum);
1485 }
1486
1487 if (offset != max_block_size) {
1488 cd->pctx.num = rec_len + offset - max_block_size;
1489 if (fix_problem(ctx, PR_2_FINAL_RECLEN, &cd->pctx)) {
1490 dirent->rec_len = cd->pctx.num;
1491 dir_modified++;
1492 }
1493 }
1494 if (dir_modified) {
1495 int flags, will_rehash;
1496 /* leaf block with no tail? Rehash dirs later. */
1497 if (ext2fs_has_feature_metadata_csum(fs->super) &&
1498 is_leaf &&
1499 !inline_data_size &&
1500 !ext2fs_dirent_has_tail(fs, (struct ext2_dir_entry *)buf)) {
1501 if (insert_dirent_tail(fs, buf) == 0)
1502 goto write_and_fix;
1503 e2fsck_rehash_dir_later(ctx, ino);
1504 }
1505
1506 write_and_fix:
1507 will_rehash = e2fsck_dir_will_be_rehashed(ctx, ino);
1508 if (will_rehash) {
1509 flags = ctx->fs->flags;
1510 ctx->fs->flags |= EXT2_FLAG_IGNORE_CSUM_ERRORS;
1511 }
1512 if (inline_data_size) {
1513 buf = ibuf;
1514 #ifdef WORDS_BIGENDIAN
1515 if (db->blockcnt)
1516 goto skip_first_write_swab;
1517 *((__u32 *)buf) = ext2fs_le32_to_cpu(*((__u32 *)buf));
1518 cd->pctx.errcode = ext2fs_dirent_swab_out2(fs,
1519 buf + EXT4_INLINE_DATA_DOTDOT_SIZE,
1520 EXT4_MIN_INLINE_DATA_SIZE -
1521 EXT4_INLINE_DATA_DOTDOT_SIZE,
1522 0);
1523 if (cd->pctx.errcode)
1524 goto skip_second_write_swab;
1525 skip_first_write_swab:
1526 if (inline_data_size <= EXT4_MIN_INLINE_DATA_SIZE ||
1527 !db->blockcnt)
1528 goto skip_second_write_swab;
1529 cd->pctx.errcode = ext2fs_dirent_swab_out2(fs,
1530 buf + EXT4_MIN_INLINE_DATA_SIZE,
1531 inline_data_size -
1532 EXT4_MIN_INLINE_DATA_SIZE,
1533 0);
1534 skip_second_write_swab:
1535 if (cd->pctx.errcode &&
1536 !fix_problem(ctx, PR_2_WRITE_DIRBLOCK, &cd->pctx))
1537 goto abort_free_dict;
1538 #endif
1539 cd->pctx.errcode =
1540 ext2fs_inline_data_set(fs, ino, 0, buf,
1541 inline_data_size);
1542 } else
1543 cd->pctx.errcode = ext2fs_write_dir_block4(fs, block_nr,
1544 buf, 0, ino);
1545 if (will_rehash)
1546 ctx->fs->flags = (flags &
1547 EXT2_FLAG_IGNORE_CSUM_ERRORS) |
1548 (ctx->fs->flags &
1549 ~EXT2_FLAG_IGNORE_CSUM_ERRORS);
1550 if (cd->pctx.errcode) {
1551 if (!fix_problem(ctx, PR_2_WRITE_DIRBLOCK,
1552 &cd->pctx))
1553 goto abort_free_dict;
1554 }
1555 ext2fs_mark_changed(fs);
1556 } else if (is_leaf && failed_csum && !dir_modified) {
1557 /*
1558 * If a leaf node that fails csum makes it this far without
1559 * alteration, ask the user if the checksum should be fixed.
1560 */
1561 if (fix_problem(ctx, PR_2_LEAF_NODE_ONLY_CSUM_INVALID,
1562 &cd->pctx))
1563 goto write_and_fix;
1564 }
1565 dict_free_nodes(&de_dict);
1566 return 0;
1567 abort_free_dict:
1568 ctx->flags |= E2F_FLAG_ABORT;
1569 dict_free_nodes(&de_dict);
1570 return DIRENT_ABORT;
1571 }
1572
1573 struct del_block {
1574 e2fsck_t ctx;
1575 e2_blkcnt_t num;
1576 };
1577
1578 /*
1579 * This function is called to deallocate a block, and is an interator
1580 * functioned called by deallocate inode via ext2fs_iterate_block().
1581 */
1582 static int deallocate_inode_block(ext2_filsys fs,
1583 blk64_t *block_nr,
1584 e2_blkcnt_t blockcnt EXT2FS_ATTR((unused)),
1585 blk64_t ref_block EXT2FS_ATTR((unused)),
1586 int ref_offset EXT2FS_ATTR((unused)),
1587 void *priv_data)
1588 {
1589 struct del_block *p = priv_data;
1590
1591 if (*block_nr == 0)
1592 return 0;
1593 if ((*block_nr < fs->super->s_first_data_block) ||
1594 (*block_nr >= ext2fs_blocks_count(fs->super)))
1595 return 0;
1596 if ((*block_nr % EXT2FS_CLUSTER_RATIO(fs)) == 0)
1597 ext2fs_block_alloc_stats2(fs, *block_nr, -1);
1598 p->num++;
1599 return 0;
1600 }
1601
1602 /*
1603 * This fuction deallocates an inode
1604 */
1605 static void deallocate_inode(e2fsck_t ctx, ext2_ino_t ino, char* block_buf)
1606 {
1607 ext2_filsys fs = ctx->fs;
1608 struct ext2_inode inode;
1609 struct problem_context pctx;
1610 __u32 count;
1611 struct del_block del_block;
1612
1613 e2fsck_read_inode(ctx, ino, &inode, "deallocate_inode");
1614 clear_problem_context(&pctx);
1615 pctx.ino = ino;
1616
1617 /*
1618 * Fix up the bitmaps...
1619 */
1620 e2fsck_read_bitmaps(ctx);
1621 ext2fs_inode_alloc_stats2(fs, ino, -1, LINUX_S_ISDIR(inode.i_mode));
1622
1623 if (ext2fs_file_acl_block(fs, &inode) &&
1624 ext2fs_has_feature_xattr(fs->super)) {
1625 pctx.errcode = ext2fs_adjust_ea_refcount3(fs,
1626 ext2fs_file_acl_block(fs, &inode),
1627 block_buf, -1, &count, ino);
1628 if (pctx.errcode == EXT2_ET_BAD_EA_BLOCK_NUM) {
1629 pctx.errcode = 0;
1630 count = 1;
1631 }
1632 if (pctx.errcode) {
1633 pctx.blk = ext2fs_file_acl_block(fs, &inode);
1634 fix_problem(ctx, PR_2_ADJ_EA_REFCOUNT, &pctx);
1635 ctx->flags |= E2F_FLAG_ABORT;
1636 return;
1637 }
1638 if (count == 0) {
1639 ext2fs_block_alloc_stats2(fs,
1640 ext2fs_file_acl_block(fs, &inode), -1);
1641 }
1642 ext2fs_file_acl_block_set(fs, &inode, 0);
1643 }
1644
1645 if (!ext2fs_inode_has_valid_blocks2(fs, &inode))
1646 goto clear_inode;
1647
1648 /* Inline data inodes don't have blocks to iterate */
1649 if (inode.i_flags & EXT4_INLINE_DATA_FL)
1650 goto clear_inode;
1651
1652 if (LINUX_S_ISREG(inode.i_mode) &&
1653 ext2fs_needs_large_file_feature(EXT2_I_SIZE(&inode)))
1654 ctx->large_files--;
1655
1656 del_block.ctx = ctx;
1657 del_block.num = 0;
1658 pctx.errcode = ext2fs_block_iterate3(fs, ino, 0, block_buf,
1659 deallocate_inode_block,
1660 &del_block);
1661 if (pctx.errcode) {
1662 fix_problem(ctx, PR_2_DEALLOC_INODE, &pctx);
1663 ctx->flags |= E2F_FLAG_ABORT;
1664 return;
1665 }
1666 clear_inode:
1667 /* Inode may have changed by block_iterate, so reread it */
1668 e2fsck_read_inode(ctx, ino, &inode, "deallocate_inode");
1669 e2fsck_clear_inode(ctx, ino, &inode, 0, "deallocate_inode");
1670 }
1671
1672 /*
1673 * This fuction clears the htree flag on an inode
1674 */
1675 static void clear_htree(e2fsck_t ctx, ext2_ino_t ino)
1676 {
1677 struct ext2_inode inode;
1678
1679 e2fsck_read_inode(ctx, ino, &inode, "clear_htree");
1680 inode.i_flags = inode.i_flags & ~EXT2_INDEX_FL;
1681 e2fsck_write_inode(ctx, ino, &inode, "clear_htree");
1682 if (ctx->dirs_to_hash)
1683 ext2fs_u32_list_add(ctx->dirs_to_hash, ino);
1684 }
1685
1686
1687 int e2fsck_process_bad_inode(e2fsck_t ctx, ext2_ino_t dir,
1688 ext2_ino_t ino, char *buf)
1689 {
1690 ext2_filsys fs = ctx->fs;
1691 struct ext2_inode inode;
1692 int inode_modified = 0;
1693 int not_fixed = 0;
1694 unsigned char *frag, *fsize;
1695 struct problem_context pctx;
1696 problem_t problem = 0;
1697
1698 e2fsck_read_inode(ctx, ino, &inode, "process_bad_inode");
1699
1700 clear_problem_context(&pctx);
1701 pctx.ino = ino;
1702 pctx.dir = dir;
1703 pctx.inode = &inode;
1704
1705 if (ext2fs_file_acl_block(fs, &inode) &&
1706 !ext2fs_has_feature_xattr(fs->super)) {
1707 if (fix_problem(ctx, PR_2_FILE_ACL_ZERO, &pctx)) {
1708 ext2fs_file_acl_block_set(fs, &inode, 0);
1709 inode_modified++;
1710 } else
1711 not_fixed++;
1712 }
1713
1714 if (!LINUX_S_ISDIR(inode.i_mode) && !LINUX_S_ISREG(inode.i_mode) &&
1715 !LINUX_S_ISCHR(inode.i_mode) && !LINUX_S_ISBLK(inode.i_mode) &&
1716 !LINUX_S_ISLNK(inode.i_mode) && !LINUX_S_ISFIFO(inode.i_mode) &&
1717 !(LINUX_S_ISSOCK(inode.i_mode)))
1718 problem = PR_2_BAD_MODE;
1719 else if (LINUX_S_ISCHR(inode.i_mode)
1720 && !e2fsck_pass1_check_device_inode(fs, &inode))
1721 problem = PR_2_BAD_CHAR_DEV;
1722 else if (LINUX_S_ISBLK(inode.i_mode)
1723 && !e2fsck_pass1_check_device_inode(fs, &inode))
1724 problem = PR_2_BAD_BLOCK_DEV;
1725 else if (LINUX_S_ISFIFO(inode.i_mode)
1726 && !e2fsck_pass1_check_device_inode(fs, &inode))
1727 problem = PR_2_BAD_FIFO;
1728 else if (LINUX_S_ISSOCK(inode.i_mode)
1729 && !e2fsck_pass1_check_device_inode(fs, &inode))
1730 problem = PR_2_BAD_SOCKET;
1731 else if (LINUX_S_ISLNK(inode.i_mode)
1732 && !e2fsck_pass1_check_symlink(fs, ino, &inode, buf)) {
1733 problem = PR_2_INVALID_SYMLINK;
1734 }
1735
1736 if (problem) {
1737 if (fix_problem(ctx, problem, &pctx)) {
1738 deallocate_inode(ctx, ino, 0);
1739 if (ctx->flags & E2F_FLAG_SIGNAL_MASK)
1740 return 0;
1741 return 1;
1742 } else
1743 not_fixed++;
1744 problem = 0;
1745 }
1746
1747 if (inode.i_faddr) {
1748 if (fix_problem(ctx, PR_2_FADDR_ZERO, &pctx)) {
1749 inode.i_faddr = 0;
1750 inode_modified++;
1751 } else
1752 not_fixed++;
1753 }
1754
1755 switch (fs->super->s_creator_os) {
1756 case EXT2_OS_HURD:
1757 frag = &inode.osd2.hurd2.h_i_frag;
1758 fsize = &inode.osd2.hurd2.h_i_fsize;
1759 break;
1760 default:
1761 frag = fsize = 0;
1762 }
1763 if (frag && *frag) {
1764 pctx.num = *frag;
1765 if (fix_problem(ctx, PR_2_FRAG_ZERO, &pctx)) {
1766 *frag = 0;
1767 inode_modified++;
1768 } else
1769 not_fixed++;
1770 pctx.num = 0;
1771 }
1772 if (fsize && *fsize) {
1773 pctx.num = *fsize;
1774 if (fix_problem(ctx, PR_2_FSIZE_ZERO, &pctx)) {
1775 *fsize = 0;
1776 inode_modified++;
1777 } else
1778 not_fixed++;
1779 pctx.num = 0;
1780 }
1781
1782 if ((fs->super->s_creator_os == EXT2_OS_LINUX) &&
1783 !ext2fs_has_feature_huge_file(fs->super) &&
1784 (inode.osd2.linux2.l_i_blocks_hi != 0)) {
1785 pctx.num = inode.osd2.linux2.l_i_blocks_hi;
1786 if (fix_problem(ctx, PR_2_BLOCKS_HI_ZERO, &pctx)) {
1787 inode.osd2.linux2.l_i_blocks_hi = 0;
1788 inode_modified++;
1789 }
1790 }
1791
1792 if ((fs->super->s_creator_os == EXT2_OS_LINUX) &&
1793 !ext2fs_has_feature_64bit(fs->super) &&
1794 inode.osd2.linux2.l_i_file_acl_high != 0) {
1795 pctx.num = inode.osd2.linux2.l_i_file_acl_high;
1796 if (fix_problem(ctx, PR_2_I_FILE_ACL_HI_ZERO, &pctx)) {
1797 inode.osd2.linux2.l_i_file_acl_high = 0;
1798 inode_modified++;
1799 } else
1800 not_fixed++;
1801 }
1802
1803 if (ext2fs_file_acl_block(fs, &inode) &&
1804 ((ext2fs_file_acl_block(fs, &inode) < fs->super->s_first_data_block) ||
1805 (ext2fs_file_acl_block(fs, &inode) >= ext2fs_blocks_count(fs->super)))) {
1806 if (fix_problem(ctx, PR_2_FILE_ACL_BAD, &pctx)) {
1807 ext2fs_file_acl_block_set(fs, &inode, 0);
1808 inode_modified++;
1809 } else
1810 not_fixed++;
1811 }
1812 if (inode.i_dir_acl &&
1813 LINUX_S_ISDIR(inode.i_mode)) {
1814 if (fix_problem(ctx, PR_2_DIR_ACL_ZERO, &pctx)) {
1815 inode.i_dir_acl = 0;
1816 inode_modified++;
1817 } else
1818 not_fixed++;
1819 }
1820
1821 if (inode_modified)
1822 e2fsck_write_inode(ctx, ino, &inode, "process_bad_inode");
1823 if (!not_fixed && ctx->inode_bad_map)
1824 ext2fs_unmark_inode_bitmap2(ctx->inode_bad_map, ino);
1825 return 0;
1826 }
1827
1828 /*
1829 * allocate_dir_block --- this function allocates a new directory
1830 * block for a particular inode; this is done if a directory has
1831 * a "hole" in it, or if a directory has a illegal block number
1832 * that was zeroed out and now needs to be replaced.
1833 */
1834 static int allocate_dir_block(e2fsck_t ctx,
1835 struct ext2_db_entry2 *db,
1836 char *buf EXT2FS_ATTR((unused)),
1837 struct problem_context *pctx)
1838 {
1839 ext2_filsys fs = ctx->fs;
1840 blk64_t blk = 0;
1841 char *block;
1842 struct ext2_inode inode;
1843
1844 if (fix_problem(ctx, PR_2_DIRECTORY_HOLE, pctx) == 0)
1845 return 1;
1846
1847 /*
1848 * Read the inode and block bitmaps in; we'll be messing with
1849 * them.
1850 */
1851 e2fsck_read_bitmaps(ctx);
1852
1853 /*
1854 * First, find a free block
1855 */
1856 e2fsck_read_inode(ctx, db->ino, &inode, "allocate_dir_block");
1857 pctx->errcode = ext2fs_map_cluster_block(fs, db->ino, &inode,
1858 db->blockcnt, &blk);
1859 if (pctx->errcode || blk == 0) {
1860 blk = ext2fs_find_inode_goal(fs, db->ino, &inode, db->blockcnt);
1861 pctx->errcode = ext2fs_new_block2(fs, blk,
1862 ctx->block_found_map, &blk);
1863 if (pctx->errcode) {
1864 pctx->str = "ext2fs_new_block";
1865 fix_problem(ctx, PR_2_ALLOC_DIRBOCK, pctx);
1866 return 1;
1867 }
1868 }
1869 ext2fs_mark_block_bitmap2(ctx->block_found_map, blk);
1870 ext2fs_mark_block_bitmap2(fs->block_map, blk);
1871 ext2fs_mark_bb_dirty(fs);
1872
1873 /*
1874 * Now let's create the actual data block for the inode
1875 */
1876 if (db->blockcnt)
1877 pctx->errcode = ext2fs_new_dir_block(fs, 0, 0, &block);
1878 else
1879 pctx->errcode = ext2fs_new_dir_block(fs, db->ino,
1880 EXT2_ROOT_INO, &block);
1881
1882 if (pctx->errcode) {
1883 pctx->str = "ext2fs_new_dir_block";
1884 fix_problem(ctx, PR_2_ALLOC_DIRBOCK, pctx);
1885 return 1;
1886 }
1887
1888 pctx->errcode = ext2fs_write_dir_block4(fs, blk, block, 0, db->ino);
1889 ext2fs_free_mem(&block);
1890 if (pctx->errcode) {
1891 pctx->str = "ext2fs_write_dir_block";
1892 fix_problem(ctx, PR_2_ALLOC_DIRBOCK, pctx);
1893 return 1;
1894 }
1895
1896 /*
1897 * Update the inode block count
1898 */
1899 ext2fs_iblk_add_blocks(fs, &inode, 1);
1900 if (EXT2_I_SIZE(&inode) < ((__u64) db->blockcnt+1) * fs->blocksize) {
1901 pctx->errcode = ext2fs_inode_size_set(fs, &inode,
1902 (db->blockcnt+1) * fs->blocksize);
1903 if (pctx->errcode) {
1904 pctx->str = "ext2fs_inode_size_set";
1905 fix_problem(ctx, PR_2_ALLOC_DIRBOCK, pctx);
1906 return 1;
1907 }
1908 }
1909 e2fsck_write_inode(ctx, db->ino, &inode, "allocate_dir_block");
1910
1911 /*
1912 * Finally, update the block pointers for the inode
1913 */
1914 db->blk = blk;
1915 pctx->errcode = ext2fs_bmap2(fs, db->ino, &inode, 0, BMAP_SET,
1916 db->blockcnt, 0, &blk);
1917 if (pctx->errcode) {
1918 pctx->str = "ext2fs_block_iterate";
1919 fix_problem(ctx, PR_2_ALLOC_DIRBOCK, pctx);
1920 return 1;
1921 }
1922
1923 return 0;
1924 }
Unnamed repository; edit this file 'description' to name the repository.