1/*
2 * e2fsck.c - superblock checks
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
12#ifdef HAVE_ERRNO_H
13#include <errno.h>
14#endif
15
16#ifndef EXT2_SKIP_UUID
17#include "uuid/uuid.h"
18#endif
19#include "e2fsck.h"
20#include "problem.h"
21
22#define MIN_CHECK 1
23#define MAX_CHECK 2
24
25static void check_super_value(e2fsck_t ctx, const char *descr,
26			      unsigned long value, int flags,
27			      unsigned long min_val, unsigned long max_val)
28{
29	struct		problem_context pctx;
30
31	if (((flags & MIN_CHECK) && (value < min_val)) ||
32	    ((flags & MAX_CHECK) && (value > max_val))) {
33		clear_problem_context(&pctx);
34		pctx.num = value;
35		pctx.str = descr;
36		fix_problem(ctx, PR_0_MISC_CORRUPT_SUPER, &pctx);
37		ctx->flags |= E2F_FLAG_ABORT; /* never get here! */
38	}
39}
40
41/*
42 * helper function to release an inode
43 */
44struct process_block_struct {
45	e2fsck_t 	ctx;
46	char 		*buf;
47	struct problem_context *pctx;
48	int		truncating;
49	int		truncate_offset;
50	e2_blkcnt_t	truncate_block;
51	int		truncated_blocks;
52	int		abort;
53	errcode_t	errcode;
54};
55
56static int release_inode_block(ext2_filsys fs,
57			       blk_t	*block_nr,
58			       e2_blkcnt_t blockcnt,
59			       blk_t	ref_blk EXT2FS_ATTR((unused)),
60			       int	ref_offset EXT2FS_ATTR((unused)),
61			       void *priv_data)
62{
63	struct process_block_struct *pb;
64	e2fsck_t 		ctx;
65	struct problem_context	*pctx;
66	blk_t			blk = *block_nr;
67	int			retval = 0;
68
69	pb = (struct process_block_struct *) priv_data;
70	ctx = pb->ctx;
71	pctx = pb->pctx;
72
73	pctx->blk = blk;
74	pctx->blkcount = blockcnt;
75
76	if (HOLE_BLKADDR(blk))
77		return 0;
78
79	if ((blk < fs->super->s_first_data_block) ||
80	    (blk >= fs->super->s_blocks_count)) {
81		fix_problem(ctx, PR_0_ORPHAN_ILLEGAL_BLOCK_NUM, pctx);
82	return_abort:
83		pb->abort = 1;
84		return BLOCK_ABORT;
85	}
86
87	if (!ext2fs_test_block_bitmap(fs->block_map, blk)) {
88		fix_problem(ctx, PR_0_ORPHAN_ALREADY_CLEARED_BLOCK, pctx);
89		goto return_abort;
90	}
91
92	/*
93	 * If we are deleting an orphan, then we leave the fields alone.
94	 * If we are truncating an orphan, then update the inode fields
95	 * and clean up any partial block data.
96	 */
97	if (pb->truncating) {
98		/*
99		 * We only remove indirect blocks if they are
100		 * completely empty.
101		 */
102		if (blockcnt < 0) {
103			int	i, limit;
104			blk_t	*bp;
105
106			pb->errcode = io_channel_read_blk(fs->io, blk, 1,
107							pb->buf);
108			if (pb->errcode)
109				goto return_abort;
110
111			limit = fs->blocksize >> 2;
112			for (i = 0, bp = (blk_t *) pb->buf;
113			     i < limit;	 i++, bp++)
114				if (*bp)
115					return 0;
116		}
117		/*
118		 * We don't remove direct blocks until we've reached
119		 * the truncation block.
120		 */
121		if (blockcnt >= 0 && blockcnt < pb->truncate_block)
122			return 0;
123		/*
124		 * If part of the last block needs truncating, we do
125		 * it here.
126		 */
127		if ((blockcnt == pb->truncate_block) && pb->truncate_offset) {
128			pb->errcode = io_channel_read_blk(fs->io, blk, 1,
129							pb->buf);
130			if (pb->errcode)
131				goto return_abort;
132			memset(pb->buf + pb->truncate_offset, 0,
133			       fs->blocksize - pb->truncate_offset);
134			pb->errcode = io_channel_write_blk(fs->io, blk, 1,
135							 pb->buf);
136			if (pb->errcode)
137				goto return_abort;
138		}
139		pb->truncated_blocks++;
140		*block_nr = 0;
141		retval |= BLOCK_CHANGED;
142	}
143
144	ext2fs_block_alloc_stats(fs, blk, -1);
145	return retval;
146}
147
148/*
149 * This function releases an inode.  Returns 1 if an inconsistency was
150 * found.  If the inode has a link count, then it is being truncated and
151 * not deleted.
152 */
153static int release_inode_blocks(e2fsck_t ctx, ext2_ino_t ino,
154				struct ext2_inode *inode, char *block_buf,
155				struct problem_context *pctx)
156{
157	struct process_block_struct 	pb;
158	ext2_filsys			fs = ctx->fs;
159	errcode_t			retval;
160	__u32				count;
161
162	if (!ext2fs_inode_has_valid_blocks(inode))
163		return 0;
164
165	pb.buf = block_buf + 3 * ctx->fs->blocksize;
166	pb.ctx = ctx;
167	pb.abort = 0;
168	pb.errcode = 0;
169	pb.pctx = pctx;
170	if (inode->i_links_count) {
171		pb.truncating = 1;
172		pb.truncate_block = (e2_blkcnt_t)
173			((((long long)inode->i_size_high << 32) +
174			  inode->i_size + fs->blocksize - 1) /
175			 fs->blocksize);
176		pb.truncate_offset = inode->i_size % fs->blocksize;
177	} else {
178		pb.truncating = 0;
179		pb.truncate_block = 0;
180		pb.truncate_offset = 0;
181	}
182	pb.truncated_blocks = 0;
183	retval = ext2fs_block_iterate2(fs, ino, BLOCK_FLAG_DEPTH_TRAVERSE,
184				      block_buf, release_inode_block, &pb);
185	if (retval) {
186		com_err("release_inode_blocks", retval,
187			_("while calling ext2fs_block_iterate for inode %d"),
188			ino);
189		return 1;
190	}
191	if (pb.abort)
192		return 1;
193
194	/* Refresh the inode since ext2fs_block_iterate may have changed it */
195	e2fsck_read_inode(ctx, ino, inode, "release_inode_blocks");
196
197	if (pb.truncated_blocks)
198		inode->i_blocks -= pb.truncated_blocks *
199			(fs->blocksize / 512);
200
201	if (inode->i_file_acl) {
202		retval = ext2fs_adjust_ea_refcount(fs, inode->i_file_acl,
203						   block_buf, -1, &count);
204		if (retval == EXT2_ET_BAD_EA_BLOCK_NUM) {
205			retval = 0;
206			count = 1;
207		}
208		if (retval) {
209			com_err("release_inode_blocks", retval,
210		_("while calling ext2fs_adjust_ea_refcount for inode %d"),
211				ino);
212			return 1;
213		}
214		if (count == 0)
215			ext2fs_block_alloc_stats(fs, inode->i_file_acl, -1);
216		inode->i_file_acl = 0;
217	}
218	return 0;
219}
220
221/*
222 * This function releases all of the orphan inodes.  It returns 1 if
223 * it hit some error, and 0 on success.
224 */
225static int release_orphan_inodes(e2fsck_t ctx)
226{
227	ext2_filsys fs = ctx->fs;
228	ext2_ino_t	ino, next_ino;
229	struct ext2_inode inode;
230	struct problem_context pctx;
231	char *block_buf;
232
233	if ((ino = fs->super->s_last_orphan) == 0)
234		return 0;
235
236	/*
237	 * Win or lose, we won't be using the head of the orphan inode
238	 * list again.
239	 */
240	fs->super->s_last_orphan = 0;
241	ext2fs_mark_super_dirty(fs);
242
243	/*
244	 * If the filesystem contains errors, don't run the orphan
245	 * list, since the orphan list can't be trusted; and we're
246	 * going to be running a full e2fsck run anyway...
247	 */
248	if (fs->super->s_state & EXT2_ERROR_FS)
249		return 0;
250
251	if ((ino < EXT2_FIRST_INODE(fs->super)) ||
252	    (ino > fs->super->s_inodes_count)) {
253		clear_problem_context(&pctx);
254		pctx.ino = ino;
255		fix_problem(ctx, PR_0_ORPHAN_ILLEGAL_HEAD_INODE, &pctx);
256		return 1;
257	}
258
259	block_buf = (char *) e2fsck_allocate_memory(ctx, fs->blocksize * 4,
260						    "block iterate buffer");
261	e2fsck_read_bitmaps(ctx);
262
263	while (ino) {
264		e2fsck_read_inode(ctx, ino, &inode, "release_orphan_inodes");
265		clear_problem_context(&pctx);
266		pctx.ino = ino;
267		pctx.inode = &inode;
268		pctx.str = inode.i_links_count ? _("Truncating") :
269			_("Clearing");
270
271		fix_problem(ctx, PR_0_ORPHAN_CLEAR_INODE, &pctx);
272
273		next_ino = inode.i_dtime;
274		if (next_ino &&
275		    ((next_ino < EXT2_FIRST_INODE(fs->super)) ||
276		     (next_ino > fs->super->s_inodes_count))) {
277			pctx.ino = next_ino;
278			fix_problem(ctx, PR_0_ORPHAN_ILLEGAL_INODE, &pctx);
279			goto return_abort;
280		}
281
282		if (release_inode_blocks(ctx, ino, &inode, block_buf, &pctx))
283			goto return_abort;
284
285		if (!inode.i_links_count) {
286			ext2fs_inode_alloc_stats2(fs, ino, -1,
287						  LINUX_S_ISDIR(inode.i_mode));
288			inode.i_dtime = ctx->now;
289		} else {
290			inode.i_dtime = 0;
291		}
292		e2fsck_write_inode(ctx, ino, &inode, "delete_file");
293		ino = next_ino;
294	}
295	ext2fs_free_mem(&block_buf);
296	return 0;
297return_abort:
298	ext2fs_free_mem(&block_buf);
299	return 1;
300}
301
302/*
303 * Check the resize inode to make sure it is sane.  We check both for
304 * the case where on-line resizing is not enabled (in which case the
305 * resize inode should be cleared) as well as the case where on-line
306 * resizing is enabled.
307 */
308static void check_resize_inode(e2fsck_t ctx)
309{
310	ext2_filsys fs = ctx->fs;
311	struct ext2_inode inode;
312	struct problem_context	pctx;
313	int		i, gdt_off, ind_off;
314	dgrp_t		j;
315	blk_t		blk, pblk, expect;
316	__u32 		*dind_buf = 0, *ind_buf;
317	errcode_t	retval;
318
319	clear_problem_context(&pctx);
320
321	/*
322	 * If the resize inode feature isn't set, then
323	 * s_reserved_gdt_blocks must be zero.
324	 */
325	if (!(fs->super->s_feature_compat &
326	      EXT2_FEATURE_COMPAT_RESIZE_INODE)) {
327		if (fs->super->s_reserved_gdt_blocks) {
328			pctx.num = fs->super->s_reserved_gdt_blocks;
329			if (fix_problem(ctx, PR_0_NONZERO_RESERVED_GDT_BLOCKS,
330					&pctx)) {
331				fs->super->s_reserved_gdt_blocks = 0;
332				ext2fs_mark_super_dirty(fs);
333			}
334		}
335	}
336
337	/* Read the resize inode */
338	pctx.ino = EXT2_RESIZE_INO;
339	retval = ext2fs_read_inode(fs, EXT2_RESIZE_INO, &inode);
340	if (retval) {
341		if (fs->super->s_feature_compat &
342		    EXT2_FEATURE_COMPAT_RESIZE_INODE)
343			ctx->flags |= E2F_FLAG_RESIZE_INODE;
344		return;
345	}
346
347	/*
348	 * If the resize inode feature isn't set, check to make sure
349	 * the resize inode is cleared; then we're done.
350	 */
351	if (!(fs->super->s_feature_compat &
352	      EXT2_FEATURE_COMPAT_RESIZE_INODE)) {
353		for (i=0; i < EXT2_N_BLOCKS; i++) {
354			if (inode.i_block[i])
355				break;
356		}
357		if ((i < EXT2_N_BLOCKS) &&
358		    fix_problem(ctx, PR_0_CLEAR_RESIZE_INODE, &pctx)) {
359			memset(&inode, 0, sizeof(inode));
360			e2fsck_write_inode(ctx, EXT2_RESIZE_INO, &inode,
361					   "clear_resize");
362		}
363		return;
364	}
365
366	/*
367	 * The resize inode feature is enabled; check to make sure the
368	 * only block in use is the double indirect block
369	 */
370	blk = inode.i_block[EXT2_DIND_BLOCK];
371	for (i=0; i < EXT2_N_BLOCKS; i++) {
372		if (i != EXT2_DIND_BLOCK && inode.i_block[i])
373			break;
374	}
375	if ((i < EXT2_N_BLOCKS) || !blk || !inode.i_links_count ||
376	    !(inode.i_mode & LINUX_S_IFREG) ||
377	    (blk < fs->super->s_first_data_block ||
378	     blk >= fs->super->s_blocks_count)) {
379	resize_inode_invalid:
380		if (fix_problem(ctx, PR_0_RESIZE_INODE_INVALID, &pctx)) {
381			memset(&inode, 0, sizeof(inode));
382			e2fsck_write_inode(ctx, EXT2_RESIZE_INO, &inode,
383					   "clear_resize");
384			ctx->flags |= E2F_FLAG_RESIZE_INODE;
385		}
386		if (!(ctx->options & E2F_OPT_READONLY)) {
387			fs->super->s_state &= ~EXT2_VALID_FS;
388			ext2fs_mark_super_dirty(fs);
389		}
390		goto cleanup;
391	}
392	dind_buf = (__u32 *) e2fsck_allocate_memory(ctx, fs->blocksize * 2,
393						    "resize dind buffer");
394	ind_buf = (__u32 *) ((char *) dind_buf + fs->blocksize);
395
396	retval = ext2fs_read_ind_block(fs, blk, dind_buf);
397	if (retval)
398		goto resize_inode_invalid;
399
400	gdt_off = fs->desc_blocks;
401	pblk = fs->super->s_first_data_block + 1 + fs->desc_blocks;
402	for (i = 0; i < fs->super->s_reserved_gdt_blocks / 4;
403	     i++, gdt_off++, pblk++) {
404		gdt_off %= fs->blocksize/4;
405		if (dind_buf[gdt_off] != pblk)
406			goto resize_inode_invalid;
407		retval = ext2fs_read_ind_block(fs, pblk, ind_buf);
408		if (retval)
409			goto resize_inode_invalid;
410		ind_off = 0;
411		for (j = 1; j < fs->group_desc_count; j++) {
412			if (!ext2fs_bg_has_super(fs, j))
413				continue;
414			expect = pblk + (j * fs->super->s_blocks_per_group);
415			if (ind_buf[ind_off] != expect)
416				goto resize_inode_invalid;
417			ind_off++;
418		}
419	}
420
421cleanup:
422	if (dind_buf)
423		ext2fs_free_mem(&dind_buf);
424
425 }
426
427/*
428 * This function checks the dirhash signed/unsigned hint if necessary.
429 */
430static void e2fsck_fix_dirhash_hint(e2fsck_t ctx)
431{
432	struct ext2_super_block *sb = ctx->fs->super;
433	struct problem_context pctx;
434	char	c;
435
436	if ((ctx->options & E2F_OPT_READONLY) ||
437	    !(sb->s_feature_compat & EXT2_FEATURE_COMPAT_DIR_INDEX) ||
438	    (sb->s_flags & (EXT2_FLAGS_SIGNED_HASH|EXT2_FLAGS_UNSIGNED_HASH)))
439		return;
440
441	c = (char) 255;
442
443	clear_problem_context(&pctx);
444	if (fix_problem(ctx, PR_0_DIRHASH_HINT, &pctx)) {
445		if (((int) c) == -1) {
446			sb->s_flags |= EXT2_FLAGS_SIGNED_HASH;
447		} else {
448			sb->s_flags |= EXT2_FLAGS_UNSIGNED_HASH;
449		}
450		ext2fs_mark_super_dirty(ctx->fs);
451	}
452}
453
454
455void check_super_block(e2fsck_t ctx)
456{
457	ext2_filsys fs = ctx->fs;
458	blk_t	first_block, last_block;
459	struct ext2_super_block *sb = fs->super;
460	struct ext2_group_desc *gd;
461	blk_t	blocks_per_group = fs->super->s_blocks_per_group;
462	blk_t	bpg_max;
463	int	inodes_per_block;
464	int	ipg_max;
465	int	inode_size;
466	int	buggy_init_scripts;
467	dgrp_t	i;
468	blk_t	should_be;
469	struct problem_context	pctx;
470	__u32	free_blocks = 0, free_inodes = 0;
471
472	inodes_per_block = EXT2_INODES_PER_BLOCK(fs->super);
473	ipg_max = inodes_per_block * (blocks_per_group - 4);
474	if (ipg_max > EXT2_MAX_INODES_PER_GROUP(sb))
475		ipg_max = EXT2_MAX_INODES_PER_GROUP(sb);
476	bpg_max = 8 * EXT2_BLOCK_SIZE(sb);
477	if (bpg_max > EXT2_MAX_BLOCKS_PER_GROUP(sb))
478		bpg_max = EXT2_MAX_BLOCKS_PER_GROUP(sb);
479
480	ctx->invalid_inode_bitmap_flag = (int *) e2fsck_allocate_memory(ctx,
481		 sizeof(int) * fs->group_desc_count, "invalid_inode_bitmap");
482	ctx->invalid_block_bitmap_flag = (int *) e2fsck_allocate_memory(ctx,
483		 sizeof(int) * fs->group_desc_count, "invalid_block_bitmap");
484	ctx->invalid_inode_table_flag = (int *) e2fsck_allocate_memory(ctx,
485		sizeof(int) * fs->group_desc_count, "invalid_inode_table");
486
487	clear_problem_context(&pctx);
488
489	/*
490	 * Verify the super block constants...
491	 */
492	check_super_value(ctx, "inodes_count", sb->s_inodes_count,
493			  MIN_CHECK, 1, 0);
494	check_super_value(ctx, "blocks_count", sb->s_blocks_count,
495			  MIN_CHECK, 1, 0);
496	check_super_value(ctx, "first_data_block", sb->s_first_data_block,
497			  MAX_CHECK, 0, sb->s_blocks_count);
498	check_super_value(ctx, "log_block_size", sb->s_log_block_size,
499			  MIN_CHECK | MAX_CHECK, 0,
500			  EXT2_MAX_BLOCK_LOG_SIZE - EXT2_MIN_BLOCK_LOG_SIZE);
501	check_super_value(ctx, "log_frag_size", sb->s_log_frag_size,
502			  MIN_CHECK | MAX_CHECK, 0, sb->s_log_block_size);
503	check_super_value(ctx, "frags_per_group", sb->s_frags_per_group,
504			  MIN_CHECK | MAX_CHECK, sb->s_blocks_per_group,
505			  bpg_max);
506	check_super_value(ctx, "blocks_per_group", sb->s_blocks_per_group,
507			  MIN_CHECK | MAX_CHECK, 8, bpg_max);
508	check_super_value(ctx, "inodes_per_group", sb->s_inodes_per_group,
509			  MIN_CHECK | MAX_CHECK, inodes_per_block, ipg_max);
510	check_super_value(ctx, "r_blocks_count", sb->s_r_blocks_count,
511			  MAX_CHECK, 0, sb->s_blocks_count / 2);
512	check_super_value(ctx, "reserved_gdt_blocks",
513			  sb->s_reserved_gdt_blocks, MAX_CHECK, 0,
514			  fs->blocksize/4);
515	inode_size = EXT2_INODE_SIZE(sb);
516	check_super_value(ctx, "inode_size",
517			  inode_size, MIN_CHECK | MAX_CHECK,
518			  EXT2_GOOD_OLD_INODE_SIZE, fs->blocksize);
519	if (inode_size & (inode_size - 1)) {
520		pctx.num = inode_size;
521		pctx.str = "inode_size";
522		fix_problem(ctx, PR_0_MISC_CORRUPT_SUPER, &pctx);
523		ctx->flags |= E2F_FLAG_ABORT; /* never get here! */
524		return;
525	}
526
527	if ((ctx->flags & E2F_FLAG_GOT_DEVSIZE) &&
528	    (ctx->num_blocks < sb->s_blocks_count)) {
529		pctx.blk = sb->s_blocks_count;
530		pctx.blk2 = ctx->num_blocks;
531		if (fix_problem(ctx, PR_0_FS_SIZE_WRONG, &pctx)) {
532			ctx->flags |= E2F_FLAG_ABORT;
533			return;
534		}
535	}
536
537	if (sb->s_log_block_size != (__u32) sb->s_log_frag_size) {
538		pctx.blk = EXT2_BLOCK_SIZE(sb);
539		pctx.blk2 = EXT2_FRAG_SIZE(sb);
540		fix_problem(ctx, PR_0_NO_FRAGMENTS, &pctx);
541		ctx->flags |= E2F_FLAG_ABORT;
542		return;
543	}
544
545	should_be = sb->s_frags_per_group >>
546		(sb->s_log_block_size - sb->s_log_frag_size);
547	if (sb->s_blocks_per_group != should_be) {
548		pctx.blk = sb->s_blocks_per_group;
549		pctx.blk2 = should_be;
550		fix_problem(ctx, PR_0_BLOCKS_PER_GROUP, &pctx);
551		ctx->flags |= E2F_FLAG_ABORT;
552		return;
553	}
554
555	should_be = (sb->s_log_block_size == 0) ? 1 : 0;
556	if (sb->s_first_data_block != should_be) {
557		pctx.blk = sb->s_first_data_block;
558		pctx.blk2 = should_be;
559		fix_problem(ctx, PR_0_FIRST_DATA_BLOCK, &pctx);
560		ctx->flags |= E2F_FLAG_ABORT;
561		return;
562	}
563
564	should_be = sb->s_inodes_per_group * fs->group_desc_count;
565	if (sb->s_inodes_count != should_be) {
566		pctx.ino = sb->s_inodes_count;
567		pctx.ino2 = should_be;
568		if (fix_problem(ctx, PR_0_INODE_COUNT_WRONG, &pctx)) {
569			sb->s_inodes_count = should_be;
570			ext2fs_mark_super_dirty(fs);
571		}
572	}
573
574	/*
575	 * Verify the group descriptors....
576	 */
577	first_block =  sb->s_first_data_block;
578
579	for (i = 0, gd=fs->group_desc; i < fs->group_desc_count; i++, gd++) {
580		pctx.group = i;
581
582		first_block = ext2fs_group_first_block(fs, i);
583		last_block = ext2fs_group_last_block(fs, i);
584
585		if ((gd->bg_block_bitmap < first_block) ||
586		    (gd->bg_block_bitmap > last_block)) {
587			pctx.blk = gd->bg_block_bitmap;
588			if (fix_problem(ctx, PR_0_BB_NOT_GROUP, &pctx))
589				gd->bg_block_bitmap = 0;
590		}
591		if (gd->bg_block_bitmap == 0) {
592			ctx->invalid_block_bitmap_flag[i]++;
593			ctx->invalid_bitmaps++;
594		}
595		if ((gd->bg_inode_bitmap < first_block) ||
596		    (gd->bg_inode_bitmap > last_block)) {
597			pctx.blk = gd->bg_inode_bitmap;
598			if (fix_problem(ctx, PR_0_IB_NOT_GROUP, &pctx))
599				gd->bg_inode_bitmap = 0;
600		}
601		if (gd->bg_inode_bitmap == 0) {
602			ctx->invalid_inode_bitmap_flag[i]++;
603			ctx->invalid_bitmaps++;
604		}
605		if ((gd->bg_inode_table < first_block) ||
606		    ((gd->bg_inode_table +
607		      fs->inode_blocks_per_group - 1) > last_block)) {
608			pctx.blk = gd->bg_inode_table;
609			if (fix_problem(ctx, PR_0_ITABLE_NOT_GROUP, &pctx))
610				gd->bg_inode_table = 0;
611		}
612		if (gd->bg_inode_table == 0) {
613			ctx->invalid_inode_table_flag[i]++;
614			ctx->invalid_bitmaps++;
615		}
616		free_blocks += gd->bg_free_blocks_count;
617		free_inodes += gd->bg_free_inodes_count;
618
619		if ((gd->bg_free_blocks_count > sb->s_blocks_per_group) ||
620		    (gd->bg_free_inodes_count > sb->s_inodes_per_group) ||
621		    (gd->bg_used_dirs_count > sb->s_inodes_per_group))
622			ext2fs_unmark_valid(fs);
623
624	}
625
626	/*
627	 * Update the global counts from the block group counts.  This
628	 * is needed for an experimental patch which eliminates
629	 * locking the entire filesystem when allocating blocks or
630	 * inodes; if the filesystem is not unmounted cleanly, the
631	 * global counts may not be accurate.
632	 */
633	if ((free_blocks != sb->s_free_blocks_count) ||
634	    (free_inodes != sb->s_free_inodes_count)) {
635		if (ctx->options & E2F_OPT_READONLY)
636			ext2fs_unmark_valid(fs);
637		else {
638			sb->s_free_blocks_count = free_blocks;
639			sb->s_free_inodes_count = free_inodes;
640			ext2fs_mark_super_dirty(fs);
641		}
642	}
643
644	if ((sb->s_free_blocks_count > sb->s_blocks_count) ||
645	    (sb->s_free_inodes_count > sb->s_inodes_count))
646		ext2fs_unmark_valid(fs);
647
648
649	/*
650	 * If we have invalid bitmaps, set the error state of the
651	 * filesystem.
652	 */
653	if (ctx->invalid_bitmaps && !(ctx->options & E2F_OPT_READONLY)) {
654		sb->s_state &= ~EXT2_VALID_FS;
655		ext2fs_mark_super_dirty(fs);
656	}
657
658	clear_problem_context(&pctx);
659
660#ifndef EXT2_SKIP_UUID
661	/*
662	 * If the UUID field isn't assigned, assign it.
663	 */
664	if (!(ctx->options & E2F_OPT_READONLY) && uuid_is_null(sb->s_uuid)) {
665		if (fix_problem(ctx, PR_0_ADD_UUID, &pctx)) {
666			uuid_generate(sb->s_uuid);
667			ext2fs_mark_super_dirty(fs);
668			fs->flags &= ~EXT2_FLAG_MASTER_SB_ONLY;
669		}
670	}
671#endif
672
673	/*
674	 * For the Hurd, check to see if the filetype option is set,
675	 * since it doesn't support it.
676	 */
677	if (!(ctx->options & E2F_OPT_READONLY) &&
678	    fs->super->s_creator_os == EXT2_OS_HURD &&
679	    (fs->super->s_feature_incompat &
680	     EXT2_FEATURE_INCOMPAT_FILETYPE)) {
681		if (fix_problem(ctx, PR_0_HURD_CLEAR_FILETYPE, &pctx)) {
682			fs->super->s_feature_incompat &=
683				~EXT2_FEATURE_INCOMPAT_FILETYPE;
684			ext2fs_mark_super_dirty(fs);
685			fs->flags &= ~EXT2_FLAG_MASTER_SB_ONLY;
686		}
687	}
688
689	/*
690	 * If we have any of the compatibility flags set, we need to have a
691	 * revision 1 filesystem.  Most kernels will not check the flags on
692	 * a rev 0 filesystem and we may have corruption issues because of
693	 * the incompatible changes to the filesystem.
694	 */
695	if (!(ctx->options & E2F_OPT_READONLY) &&
696	    fs->super->s_rev_level == EXT2_GOOD_OLD_REV &&
697	    (fs->super->s_feature_compat ||
698	     fs->super->s_feature_ro_compat ||
699	     fs->super->s_feature_incompat) &&
700	    fix_problem(ctx, PR_0_FS_REV_LEVEL, &pctx)) {
701		ext2fs_update_dynamic_rev(fs);
702		ext2fs_mark_super_dirty(fs);
703		fs->flags &= ~EXT2_FLAG_MASTER_SB_ONLY;
704	}
705
706	check_resize_inode(ctx);
707
708	/*
709	 * Clean up any orphan inodes, if present.
710	 */
711	if (!(ctx->options & E2F_OPT_READONLY) && release_orphan_inodes(ctx)) {
712		fs->super->s_state &= ~EXT2_VALID_FS;
713		ext2fs_mark_super_dirty(fs);
714	}
715
716	/*
717	 * Some buggy distributions (such as Ubuntu) have init scripts
718	 * and/or installers which fail to correctly set the system
719	 * clock before running e2fsck and/or formatting the
720	 * filesystem initially.  Normally this happens because the
721	 * hardware clock is ticking localtime, instead of the more
722	 * proper and less error-prone UTC time.  So while the kernel
723	 * is booting, the system time (which in Linux systems always
724	 * ticks in UTC time) is set from the hardware clock, but
725	 * since the hardware clock is ticking localtime, the system
726	 * time is incorrect.  Unfortunately, some buggy distributions
727	 * do not correct this before running e2fsck.  If this option
728	 * is set to a boolean value of true, we attempt to work
729	 * around this situation by allowing the superblock last write
730	 * time, last mount time, and last check time to be in the
731	 * future by up to 24 hours.
732	 */
733	profile_get_boolean(ctx->profile, "options", "buggy_init_scripts",
734			    0, 0, &buggy_init_scripts);
735	ctx->time_fudge = buggy_init_scripts ? 86400 : 0;
736
737	/*
738	 * Check to see if the superblock last mount time or last
739	 * write time is in the future.
740	 */
741	if (fs->super->s_mtime > (__u32) ctx->now + ctx->time_fudge) {
742		pctx.num = fs->super->s_mtime;
743		if (fix_problem(ctx, PR_0_FUTURE_SB_LAST_MOUNT, &pctx)) {
744			fs->super->s_mtime = ctx->now;
745			ext2fs_mark_super_dirty(fs);
746		}
747	}
748	if (fs->super->s_wtime > (__u32) ctx->now + ctx->time_fudge) {
749		pctx.num = fs->super->s_wtime;
750		if (fix_problem(ctx, PR_0_FUTURE_SB_LAST_WRITE, &pctx)) {
751			fs->super->s_wtime = ctx->now;
752			ext2fs_mark_super_dirty(fs);
753		}
754	}
755
756	/*
757	 * Move the ext3 journal file, if necessary.
758	 */
759	e2fsck_move_ext3_journal(ctx);
760
761	/*
762	 * Fix journal hint, if necessary
763	 */
764	e2fsck_fix_ext3_journal_hint(ctx);
765
766	/*
767	 * Add dirhash hint if necessary
768	 */
769	e2fsck_fix_dirhash_hint(ctx);
770
771	return;
772}
773
774/*
775 * Check to see if we should backup the master sb to the backup super
776 * blocks.  Returns non-zero if the sb should be backed up.
777 */
778
779/*
780 * A few flags are set on the fly by the kernel, but only in the
781 * primary superblock.  This is actually a bad thing, and we should
782 * try to discourage it in the future.  In particular, for the newer
783 * ext4 files, especially EXT4_FEATURE_RO_COMPAT_DIR_NLINK and
784 * EXT3_FEATURE_INCOMPAT_EXTENTS.  So some of these may go away in the
785 * future.
786 *
787 * The kernel will set EXT2_FEATURE_COMPAT_EXT_ATTR, but
788 * unfortunately, we shouldn't ignore it since if it's not set in the
789 * backup, the extended attributes in the filesystem will be stripped
790 * away.
791 */
792#define FEATURE_RO_COMPAT_IGNORE	(EXT2_FEATURE_RO_COMPAT_LARGE_FILE| \
793					 EXT4_FEATURE_RO_COMPAT_DIR_NLINK)
794#define FEATURE_INCOMPAT_IGNORE		(EXT3_FEATURE_INCOMPAT_EXTENTS)
795
796int check_backup_super_block(e2fsck_t ctx)
797{
798	ext2_filsys	fs = ctx->fs;
799	ext2_filsys	tfs = 0;
800	io_manager	io_ptr;
801	errcode_t	retval;
802	dgrp_t		g;
803	blk_t		sb;
804	int		ret = 0;
805
806	/*
807	 * If we are already writing out the backup blocks, then we
808	 * don't need to test.  Also, if the filesystem is invalid, or
809	 * the check was aborted or cancelled, we also don't want to
810	 * do the backup.  If the filesystem was opened read-only then
811	 * we can't do the backup.
812	 */
813	if (((fs->flags & EXT2_FLAG_MASTER_SB_ONLY) == 0) ||
814	    !ext2fs_test_valid(fs) ||
815	    (fs->super->s_state & EXT2_ERROR_FS) ||
816	    (ctx->flags & (E2F_FLAG_ABORT | E2F_FLAG_CANCEL)) ||
817	    (ctx->options & E2F_OPT_READONLY))
818		return 0;
819
820	for (g = 1; g < fs->group_desc_count; g++) {
821		if (!ext2fs_bg_has_super(fs, g))
822			continue;
823
824		sb = fs->super->s_first_data_block +
825			(g * fs->super->s_blocks_per_group);
826
827		retval = ext2fs_open(ctx->filesystem_name, 0,
828				     sb, fs->blocksize,
829				     fs->io->manager, &tfs);
830		if (retval) {
831			tfs = 0;
832			continue;
833		}
834
835#define SUPER_INCOMPAT_DIFFERENT(x)	\
836	(( fs->super->x & ~FEATURE_INCOMPAT_IGNORE) !=	\
837	 (tfs->super->x & ~FEATURE_INCOMPAT_IGNORE))
838#define SUPER_RO_COMPAT_DIFFERENT(x)	\
839	(( fs->super->x & ~FEATURE_RO_COMPAT_IGNORE) !=	\
840	 (tfs->super->x & ~FEATURE_RO_COMPAT_IGNORE))
841#define SUPER_DIFFERENT(x)		\
842	(fs->super->x != tfs->super->x)
843
844		if (SUPER_DIFFERENT(s_feature_compat) ||
845		    SUPER_INCOMPAT_DIFFERENT(s_feature_incompat) ||
846		    SUPER_RO_COMPAT_DIFFERENT(s_feature_ro_compat) ||
847		    SUPER_DIFFERENT(s_blocks_count) ||
848		    SUPER_DIFFERENT(s_inodes_count) ||
849		    memcmp(fs->super->s_uuid, tfs->super->s_uuid,
850			   sizeof(fs->super->s_uuid)))
851			ret = 1;
852		ext2fs_close(tfs);
853		break;
854	}
855	return ret;
856}
857