[thirdparty/xfsprogs-dev.git] / repair / phase4.c

/*
 * Copyright (c) 2000-2002,2005 Silicon Graphics, Inc.
 * All Rights Reserved.
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License as
 * published by the Free Software Foundation.
 *
 * This program is distributed in the hope that it would be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write the Free Software Foundation,
 * Inc.,  51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
 */

#include "libxfs.h"
#include "threads.h"
#include "prefetch.h"
#include "avl.h"
#include "globals.h"
#include "agheader.h"
#include "incore.h"
#include "protos.h"
#include "err_protos.h"
#include "dinode.h"
#include "bmap.h"
#include "versions.h"
#include "dir2.h"
#include "progress.h"


/*
 * null out quota inode fields in sb if they point to non-existent inodes.
 * this isn't as redundant as it looks since it's possible that the sb field
 * might be set but the imap and inode(s) agree that the inode is
 * free in which case they'd never be cleared so the fields wouldn't
 * be cleared by process_dinode().
 */
static void
quotino_check(xfs_mount_t *mp)
{
	ino_tree_node_t *irec;

	if (mp->m_sb.sb_uquotino != NULLFSINO && mp->m_sb.sb_uquotino != 0)  {
		if (verify_inum(mp, mp->m_sb.sb_uquotino))
			irec = NULL;
		else
			irec = find_inode_rec(mp,
				XFS_INO_TO_AGNO(mp, mp->m_sb.sb_uquotino),
				XFS_INO_TO_AGINO(mp, mp->m_sb.sb_uquotino));

		if (irec == NULL || is_inode_free(irec,
				mp->m_sb.sb_uquotino - irec->ino_startnum))  {
			mp->m_sb.sb_uquotino = NULLFSINO;
			lost_uquotino = 1;
		} else
			lost_uquotino = 0;
	}

	if (mp->m_sb.sb_gquotino != NULLFSINO && mp->m_sb.sb_gquotino != 0)  {
		if (verify_inum(mp, mp->m_sb.sb_gquotino))
			irec = NULL;
		else
			irec = find_inode_rec(mp,
				XFS_INO_TO_AGNO(mp, mp->m_sb.sb_gquotino),
				XFS_INO_TO_AGINO(mp, mp->m_sb.sb_gquotino));

		if (irec == NULL || is_inode_free(irec,
				mp->m_sb.sb_gquotino - irec->ino_startnum))  {
			mp->m_sb.sb_gquotino = NULLFSINO;
			lost_gquotino = 1;
		} else
			lost_gquotino = 0;
	}

	if (mp->m_sb.sb_pquotino != NULLFSINO && mp->m_sb.sb_pquotino != 0)  {
		if (verify_inum(mp, mp->m_sb.sb_pquotino))
			irec = NULL;
		else
			irec = find_inode_rec(mp,
				XFS_INO_TO_AGNO(mp, mp->m_sb.sb_pquotino),
				XFS_INO_TO_AGINO(mp, mp->m_sb.sb_pquotino));

		if (irec == NULL || is_inode_free(irec,
				mp->m_sb.sb_pquotino - irec->ino_startnum))  {
			mp->m_sb.sb_pquotino = NULLFSINO;
			lost_pquotino = 1;
		} else
			lost_pquotino = 0;
	}
}

static void
quota_sb_check(xfs_mount_t *mp)
{
	/*
	 * if the sb says we have quotas and we lost both,
	 * signal a superblock downgrade.  that will cause
	 * the quota flags to get zeroed.  (if we only lost
	 * one quota inode, do nothing and complain later.)
	 *
	 * if the sb says we have quotas but we didn't start out
	 * with any quota inodes, signal a superblock downgrade.
	 *
	 * The sb downgrades are so that older systems can mount
	 * the filesystem.
	 *
	 * if the sb says we don't have quotas but it looks like
	 * we do have quota inodes, then signal a superblock upgrade.
	 *
	 * if the sb says we don't have quotas and we have no
	 * quota inodes, then leave will enough alone.
	 */

	if (fs_quotas &&
	    (mp->m_sb.sb_uquotino == NULLFSINO || mp->m_sb.sb_uquotino == 0) &&
	    (mp->m_sb.sb_gquotino == NULLFSINO || mp->m_sb.sb_gquotino == 0) &&
	    (mp->m_sb.sb_pquotino == NULLFSINO || mp->m_sb.sb_pquotino == 0))  {
		lost_quotas = 1;
		fs_quotas = 0;
	} else if (!verify_inum(mp, mp->m_sb.sb_uquotino) &&
			!verify_inum(mp, mp->m_sb.sb_gquotino) &&
			!verify_inum(mp, mp->m_sb.sb_pquotino)) {
		fs_quotas = 1;
	}
}


static void
process_ag_func(
	work_queue_t		*wq,
	xfs_agnumber_t 		agno,
	void			*arg)
{
	wait_for_inode_prefetch(arg);
	do_log(_("        - agno = %d\n"), agno);
	process_aginodes(wq->mp, arg, agno, 0, 1, 0);
	cleanup_inode_prefetch(arg);

	/*
	 * now recycle the per-AG duplicate extent records
	 */
	release_dup_extent_tree(agno);
}

static void
process_ags(
	xfs_mount_t		*mp)
{
	do_inode_prefetch(mp, ag_stride, process_ag_func, true, false);
}


void
phase4(xfs_mount_t *mp)
{
	ino_tree_node_t		*irec;
	xfs_rtblock_t		bno;
	xfs_rtblock_t		rt_start;
	xfs_extlen_t		rt_len;
	xfs_agnumber_t		i;
	xfs_agblock_t		j;
	xfs_agblock_t		ag_end;
	xfs_extlen_t		blen;
	int			ag_hdr_len = 4 * mp->m_sb.sb_sectsize;
	int			ag_hdr_block;
	int			bstate;

	ag_hdr_block = howmany(ag_hdr_len, mp->m_sb.sb_blocksize);

	do_log(_("Phase 4 - check for duplicate blocks...\n"));
	do_log(_("        - setting up duplicate extent list...\n"));

	set_progress_msg(PROG_FMT_DUP_EXTENT, (__uint64_t) glob_agcount);

	irec = find_inode_rec(mp, XFS_INO_TO_AGNO(mp, mp->m_sb.sb_rootino),
				XFS_INO_TO_AGINO(mp, mp->m_sb.sb_rootino));

	/*
	 * we always have a root inode, even if it's free...
	 * if the root is free, forget it, lost+found is already gone
	 */
	if (is_inode_free(irec, 0) || !inode_isadir(irec, 0))  {
		need_root_inode = 1;
		if (no_modify)
			do_warn(_("root inode would be lost\n"));
		else
			do_warn(_("root inode lost\n"));
	}

	for (i = 0; i < mp->m_sb.sb_agcount; i++)  {
		ag_end = (i < mp->m_sb.sb_agcount - 1) ? mp->m_sb.sb_agblocks :
			mp->m_sb.sb_dblocks -
				(xfs_rfsblock_t) mp->m_sb.sb_agblocks * i;

		/*
		 * set up duplicate extent list for this ag
		 */
		for (j = ag_hdr_block; j < ag_end; j += blen)  {
			bstate = get_bmap_ext(i, j, ag_end, &blen);
			switch (bstate) {
			case XR_E_BAD_STATE:
			default:
				do_warn(
				_("unknown block state, ag %d, block %d\n"),
					i, j);
				/* fall through .. */
			case XR_E_UNKNOWN:
			case XR_E_FREE1:
			case XR_E_FREE:
			case XR_E_INUSE:
			case XR_E_INUSE_FS:
			case XR_E_INO:
			case XR_E_FS_MAP:
				break;
			case XR_E_MULT:
				add_dup_extent(i, j, blen);
				break;
			}
		}

		PROG_RPT_INC(prog_rpt_done[i], 1);
	}
	print_final_rpt();

	/*
	 * initialize realtime bitmap
	 */
	rt_start = 0;
	rt_len = 0;

	for (bno = 0; bno < mp->m_sb.sb_rextents; bno++)  {
		bstate = get_rtbmap(bno);
		switch (bstate)  {
		case XR_E_BAD_STATE:
		default:
			do_warn(
	_("unknown rt extent state, extent %" PRIu64 "\n"),
				bno);
			/* fall through .. */
		case XR_E_UNKNOWN:
		case XR_E_FREE1:
		case XR_E_FREE:
		case XR_E_INUSE:
		case XR_E_INUSE_FS:
		case XR_E_INO:
		case XR_E_FS_MAP:
			if (rt_start == 0)
				continue;
			else  {
				/*
				 * add extent and reset extent state
				 */
				add_rt_dup_extent(rt_start, rt_len);
				rt_start = 0;
				rt_len = 0;
			}
			break;
		case XR_E_MULT:
			if (rt_start == 0)  {
				rt_start = bno;
				rt_len = 1;
			} else if (rt_len == MAXEXTLEN)  {
				/*
				 * large extent case
				 */
				add_rt_dup_extent(rt_start, rt_len);
				rt_start = bno;
				rt_len = 1;
			} else
				rt_len++;
			break;
		}
	}

	/*
	 * catch tail-case, extent hitting the end of the ag
	 */
	if (rt_start != 0)
		add_rt_dup_extent(rt_start, rt_len);

	/*
	 * initialize bitmaps for all AGs
	 */
	reset_bmaps(mp);

	do_log(_("        - check for inodes claiming duplicate blocks...\n"));
	set_progress_msg(PROG_FMT_DUP_BLOCKS, (__uint64_t) mp->m_sb.sb_icount);

	/*
	 * ok, now process the inodes -- signal 2-pass check per inode.
	 * first pass checks if the inode conflicts with a known
	 * duplicate extent.  if so, the inode is cleared and second
	 * pass is skipped.  second pass sets the block bitmap
	 * for all blocks claimed by the inode.  directory
	 * and attribute processing is turned OFF since we did that
	 * already in phase 3.
	 */
	process_ags(mp);
	print_final_rpt();

	/*
	 * free up memory used to track trealtime duplicate extents
	 */
	if (rt_start != 0)
		free_rt_dup_extent_tree(mp);

	/*
	 * ensure consistency of quota inode pointers in superblock,
	 * make sure they point to real inodes
	 */
	quotino_check(mp);
	quota_sb_check(mp);
}
Commit	Line	Data
2bd0ea18	1	/*
da23017d NS	2	* Copyright (c) 2000-2002,2005 Silicon Graphics, Inc.
da23017d NS	3	* All Rights Reserved.
dfc130f3	4	*
da23017d NS	5	* This program is free software; you can redistribute it and/or
da23017d NS	6	* modify it under the terms of the GNU General Public License as
2bd0ea18	7	* published by the Free Software Foundation.
dfc130f3	8	*
da23017d NS	9	* This program is distributed in the hope that it would be useful,
	10	* but WITHOUT ANY WARRANTY; without even the implied warranty of
	11	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	12	* GNU General Public License for more details.
dfc130f3	13	*
da23017d NS	14	* You should have received a copy of the GNU General Public License
	15	* along with this program; if not, write the Free Software Foundation,
	16	* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
2bd0ea18 NS	17	*/
2bd0ea18 NS	18
6b803e5a	19	#include "libxfs.h"
1164bde5 DC	20	#include "threads.h"
1164bde5 DC	21	#include "prefetch.h"
2bd0ea18 NS	22	#include "avl.h"
	23	#include "globals.h"
	24	#include "agheader.h"
	25	#include "incore.h"
	26	#include "protos.h"
	27	#include "err_protos.h"
	28	#include "dinode.h"
2bd0ea18 NS	29	#include "bmap.h"
	30	#include "versions.h"
	31	#include "dir2.h"
06fbdda9	32	#include "progress.h"
2bd0ea18 NS	33
2bd0ea18 NS	34
2bd0ea18 NS	35	/*
	36	* null out quota inode fields in sb if they point to non-existent inodes.
	37	* this isn't as redundant as it looks since it's possible that the sb field
	38	* might be set but the imap and inode(s) agree that the inode is
	39	* free in which case they'd never be cleared so the fields wouldn't
	40	* be cleared by process_dinode().
	41	*/
8b8a6b02	42	static void
2bd0ea18 NS	43	quotino_check(xfs_mount_t *mp)
	44	{
	45	ino_tree_node_t *irec;
	46
	47	if (mp->m_sb.sb_uquotino != NULLFSINO && mp->m_sb.sb_uquotino != 0) {
6411f39c BN	48	if (verify_inum(mp, mp->m_sb.sb_uquotino))
	49	irec = NULL;
	50	else
1ae311d5	51	irec = find_inode_rec(mp,
6411f39c BN	52	XFS_INO_TO_AGNO(mp, mp->m_sb.sb_uquotino),
6411f39c BN	53	XFS_INO_TO_AGINO(mp, mp->m_sb.sb_uquotino));
2bd0ea18 NS	54
	55	if (irec == NULL \|\| is_inode_free(irec,
	56	mp->m_sb.sb_uquotino - irec->ino_startnum)) {
	57	mp->m_sb.sb_uquotino = NULLFSINO;
	58	lost_uquotino = 1;
	59	} else
	60	lost_uquotino = 0;
	61	}
	62
b36eef04	63	if (mp->m_sb.sb_gquotino != NULLFSINO && mp->m_sb.sb_gquotino != 0) {
6411f39c BN	64	if (verify_inum(mp, mp->m_sb.sb_gquotino))
	65	irec = NULL;
	66	else
1ae311d5	67	irec = find_inode_rec(mp,
6411f39c BN	68	XFS_INO_TO_AGNO(mp, mp->m_sb.sb_gquotino),
6411f39c BN	69	XFS_INO_TO_AGINO(mp, mp->m_sb.sb_gquotino));
2bd0ea18 NS	70
2bd0ea18 NS	71	if (irec == NULL \|\| is_inode_free(irec,
b36eef04 NS	72	mp->m_sb.sb_gquotino - irec->ino_startnum)) {
b36eef04 NS	73	mp->m_sb.sb_gquotino = NULLFSINO;
0340d706	74	lost_gquotino = 1;
2bd0ea18	75	} else
0340d706 CS	76	lost_gquotino = 0;
	77	}
	78
	79	if (mp->m_sb.sb_pquotino != NULLFSINO && mp->m_sb.sb_pquotino != 0) {
	80	if (verify_inum(mp, mp->m_sb.sb_pquotino))
	81	irec = NULL;
	82	else
	83	irec = find_inode_rec(mp,
	84	XFS_INO_TO_AGNO(mp, mp->m_sb.sb_pquotino),
	85	XFS_INO_TO_AGINO(mp, mp->m_sb.sb_pquotino));
	86
	87	if (irec == NULL \|\| is_inode_free(irec,
	88	mp->m_sb.sb_pquotino - irec->ino_startnum)) {
	89	mp->m_sb.sb_pquotino = NULLFSINO;
	90	lost_pquotino = 1;
	91	} else
	92	lost_pquotino = 0;
2bd0ea18 NS	93	}
	94	}
	95
8b8a6b02	96	static void
2bd0ea18 NS	97	quota_sb_check(xfs_mount_t *mp)
	98	{
	99	/*
	100	* if the sb says we have quotas and we lost both,
	101	* signal a superblock downgrade. that will cause
	102	* the quota flags to get zeroed. (if we only lost
	103	* one quota inode, do nothing and complain later.)
	104	*
	105	* if the sb says we have quotas but we didn't start out
	106	* with any quota inodes, signal a superblock downgrade.
	107	*
	108	* The sb downgrades are so that older systems can mount
	109	* the filesystem.
	110	*
	111	* if the sb says we don't have quotas but it looks like
	112	* we do have quota inodes, then signal a superblock upgrade.
	113	*
	114	* if the sb says we don't have quotas and we have no
	115	* quota inodes, then leave will enough alone.
	116	*/
	117
	118	if (fs_quotas &&
	119	(mp->m_sb.sb_uquotino == NULLFSINO \|\| mp->m_sb.sb_uquotino == 0) &&
0340d706 CS	120	(mp->m_sb.sb_gquotino == NULLFSINO \|\| mp->m_sb.sb_gquotino == 0) &&
0340d706 CS	121	(mp->m_sb.sb_pquotino == NULLFSINO \|\| mp->m_sb.sb_pquotino == 0)) {
2bd0ea18 NS	122	lost_quotas = 1;
	123	fs_quotas = 0;
	124	} else if (!verify_inum(mp, mp->m_sb.sb_uquotino) &&
0340d706 CS	125	!verify_inum(mp, mp->m_sb.sb_gquotino) &&
0340d706 CS	126	!verify_inum(mp, mp->m_sb.sb_pquotino)) {
2bd0ea18 NS	127	fs_quotas = 1;
	128	}
	129	}
	130
	131
2556c98b BN	132	static void
	133	process_ag_func(
	134	work_queue_t *wq,
	135	xfs_agnumber_t agno,
	136	void *arg)
3b6ac903	137	{
2556c98b	138	wait_for_inode_prefetch(arg);
3b6ac903	139	do_log(_(" - agno = %d\n"), agno);
2556c98b BN	140	process_aginodes(wq->mp, arg, agno, 0, 1, 0);
2556c98b BN	141	cleanup_inode_prefetch(arg);
3b6ac903 MV	142
	143	/*
	144	* now recycle the per-AG duplicate extent records
	145	*/
	146	release_dup_extent_tree(agno);
	147	}
	148
2556c98b BN	149	static void
	150	process_ags(
	151	xfs_mount_t *mp)
	152	{
1164bde5	153	do_inode_prefetch(mp, ag_stride, process_ag_func, true, false);
2556c98b BN	154	}
	155
	156
2bd0ea18 NS	157	void
	158	phase4(xfs_mount_t *mp)
	159	{
	160	ino_tree_node_t *irec;
5a35bf2c DC	161	xfs_rtblock_t bno;
5a35bf2c DC	162	xfs_rtblock_t rt_start;
2bd0ea18 NS	163	xfs_extlen_t rt_len;
	164	xfs_agnumber_t i;
	165	xfs_agblock_t j;
	166	xfs_agblock_t ag_end;
8961bfde	167	xfs_extlen_t blen;
2bd0ea18 NS	168	int ag_hdr_len = 4 * mp->m_sb.sb_sectsize;
	169	int ag_hdr_block;
	170	int bstate;
dfc130f3	171
2bd0ea18 NS	172	ag_hdr_block = howmany(ag_hdr_len, mp->m_sb.sb_blocksize);
2bd0ea18 NS	173
507f4e33 NS	174	do_log(_("Phase 4 - check for duplicate blocks...\n"));
507f4e33 NS	175	do_log(_(" - setting up duplicate extent list...\n"));
2bd0ea18	176
06fbdda9 MV	177	set_progress_msg(PROG_FMT_DUP_EXTENT, (__uint64_t) glob_agcount);
06fbdda9 MV	178
1ae311d5	179	irec = find_inode_rec(mp, XFS_INO_TO_AGNO(mp, mp->m_sb.sb_rootino),
2bd0ea18 NS	180	XFS_INO_TO_AGINO(mp, mp->m_sb.sb_rootino));
	181
	182	/*
	183	* we always have a root inode, even if it's free...
	184	* if the root is free, forget it, lost+found is already gone
	185	*/
	186	if (is_inode_free(irec, 0) \|\| !inode_isadir(irec, 0)) {
	187	need_root_inode = 1;
	188	if (no_modify)
507f4e33	189	do_warn(_("root inode would be lost\n"));
2bd0ea18	190	else
507f4e33	191	do_warn(_("root inode lost\n"));
2bd0ea18 NS	192	}
2bd0ea18 NS	193
2bd0ea18 NS	194	for (i = 0; i < mp->m_sb.sb_agcount; i++) {
	195	ag_end = (i < mp->m_sb.sb_agcount - 1) ? mp->m_sb.sb_agblocks :
	196	mp->m_sb.sb_dblocks -
5a35bf2c	197	(xfs_rfsblock_t) mp->m_sb.sb_agblocks * i;
8961bfde	198
2bd0ea18 NS	199	/*
	200	* set up duplicate extent list for this ag
	201	*/
8961bfde BN	202	for (j = ag_hdr_block; j < ag_end; j += blen) {
	203	bstate = get_bmap_ext(i, j, ag_end, &blen);
	204	switch (bstate) {
2bd0ea18 NS	205	case XR_E_BAD_STATE:
2bd0ea18 NS	206	default:
507f4e33 NS	207	do_warn(
507f4e33 NS	208	_("unknown block state, ag %d, block %d\n"),
2bd0ea18 NS	209	i, j);
	210	/* fall through .. */
	211	case XR_E_UNKNOWN:
	212	case XR_E_FREE1:
	213	case XR_E_FREE:
	214	case XR_E_INUSE:
	215	case XR_E_INUSE_FS:
	216	case XR_E_INO:
	217	case XR_E_FS_MAP:
2bd0ea18 NS	218	break;
2bd0ea18 NS	219	case XR_E_MULT:
8961bfde	220	add_dup_extent(i, j, blen);
2bd0ea18 NS	221	break;
	222	}
	223	}
8961bfde	224
06fbdda9	225	PROG_RPT_INC(prog_rpt_done[i], 1);
2bd0ea18	226	}
06fbdda9	227	print_final_rpt();
2bd0ea18 NS	228
	229	/*
	230	* initialize realtime bitmap
	231	*/
	232	rt_start = 0;
	233	rt_len = 0;
	234
	235	for (bno = 0; bno < mp->m_sb.sb_rextents; bno++) {
95650c4d	236	bstate = get_rtbmap(bno);
2bd0ea18 NS	237	switch (bstate) {
	238	case XR_E_BAD_STATE:
	239	default:
5d1b7f0f CH	240	do_warn(
5d1b7f0f CH	241	_("unknown rt extent state, extent %" PRIu64 "\n"),
507f4e33	242	bno);
2bd0ea18 NS	243	/* fall through .. */
	244	case XR_E_UNKNOWN:
	245	case XR_E_FREE1:
	246	case XR_E_FREE:
	247	case XR_E_INUSE:
	248	case XR_E_INUSE_FS:
	249	case XR_E_INO:
	250	case XR_E_FS_MAP:
	251	if (rt_start == 0)
	252	continue;
	253	else {
	254	/*
	255	* add extent and reset extent state
	256	*/
	257	add_rt_dup_extent(rt_start, rt_len);
	258	rt_start = 0;
	259	rt_len = 0;
	260	}
	261	break;
	262	case XR_E_MULT:
	263	if (rt_start == 0) {
	264	rt_start = bno;
	265	rt_len = 1;
	266	} else if (rt_len == MAXEXTLEN) {
	267	/*
	268	* large extent case
	269	*/
	270	add_rt_dup_extent(rt_start, rt_len);
	271	rt_start = bno;
	272	rt_len = 1;
	273	} else
	274	rt_len++;
	275	break;
	276	}
	277	}
	278
	279	/*
	280	* catch tail-case, extent hitting the end of the ag
	281	*/
	282	if (rt_start != 0)
	283	add_rt_dup_extent(rt_start, rt_len);
	284
	285	/*
	286	* initialize bitmaps for all AGs
	287	*/
c1f7a46c	288	reset_bmaps(mp);
2bd0ea18	289
507f4e33	290	do_log(_(" - check for inodes claiming duplicate blocks...\n"));
06fbdda9	291	set_progress_msg(PROG_FMT_DUP_BLOCKS, (__uint64_t) mp->m_sb.sb_icount);
add3cb90 BN	292
	293	/*
	294	* ok, now process the inodes -- signal 2-pass check per inode.
	295	* first pass checks if the inode conflicts with a known
	296	* duplicate extent. if so, the inode is cleared and second
	297	* pass is skipped. second pass sets the block bitmap
	298	* for all blocks claimed by the inode. directory
	299	* and attribute processing is turned OFF since we did that
	300	* already in phase 3.
	301	*/
2556c98b	302	process_ags(mp);
06fbdda9	303	print_final_rpt();
2bd0ea18 NS	304
	305	/*
	306	* free up memory used to track trealtime duplicate extents
	307	*/
	308	if (rt_start != 0)
	309	free_rt_dup_extent_tree(mp);
	310
	311	/*
	312	* ensure consistency of quota inode pointers in superblock,
	313	* make sure they point to real inodes
	314	*/
	315	quotino_check(mp);
	316	quota_sb_check(mp);
	317	}