path: root/fs/xfs/scrub/parent_repair.c

// SPDX-License-Identifier: GPL-2.0-or-later
/*
 * Copyright (C) 2020 Oracle.  All Rights Reserved.
 * Author: Darrick J. Wong <darrick.wong@oracle.com>
 */
#include "xfs.h"
#include "xfs_fs.h"
#include "xfs_shared.h"
#include "xfs_format.h"
#include "xfs_trans_resv.h"
#include "xfs_mount.h"
#include "xfs_defer.h"
#include "xfs_bit.h"
#include "xfs_log_format.h"
#include "xfs_trans.h"
#include "xfs_sb.h"
#include "xfs_inode.h"
#include "xfs_icache.h"
#include "xfs_da_format.h"
#include "xfs_da_btree.h"
#include "xfs_dir2.h"
#include "xfs_bmap_btree.h"
#include "xfs_dir2_priv.h"
#include "xfs_trans_space.h"
#include "xfs_iwalk.h"
#include "xfs_health.h"
#include "scrub/xfs_scrub.h"
#include "scrub/scrub.h"
#include "scrub/common.h"
#include "scrub/trace.h"
#include "scrub/repair.h"
#include "scrub/parent.h"

/*
 * Scanning Directory Trees for Parent Pointers
 * ============================================
 *
 * Walk the inode table looking for directories.  Scan each directory looking
 * for directory entries that point to the target inode.  Call a function on
 * each match.
 */

struct xrep_parents_scan {
	/* Context for scanning all dentries in a directory. */
	struct dir_context	dc;
	void			*data;
	xrep_parents_iter_fn	fn;

	/* Potential parent of the directory we're scanning. */
	xfs_ino_t		*parent_ino;

	/* This is the inode for which we want to find the parent. */
	xfs_ino_t		target_ino;

	/* Directory that we're scanning. */
	struct xfs_inode	*scan_dir;

	/* Errors encountered during scanning. */
	int			scan_error;
};

/*
 * If this directory entry points to the directory we're rebuilding, then the
 * directory we're scanning is the parent.  Call our function.
 *
 * Note that the vfs readdir functions squash the nonzero codes that we return
 * here into a "short" directory read, so the actual error codes are tracked
 * and returned separately.
 */
STATIC int
xrep_parents_scan_dentry(
	struct dir_context	*dc,
	const char		*name,
	int			namelen,
	loff_t			pos,
	u64			ino,
	unsigned		type)
{
	struct xrep_parents_scan *rps;

	rps = container_of(dc, struct xrep_parents_scan, dc);

	if (ino == rps->target_ino) {
		struct xfs_name	xname = { .name = name, .len = namelen };

		rps->scan_error = rps->fn(rps->scan_dir, &xname, type,
					  rps->data);
		if (rps->scan_error)
			return 1;
	}

	return 0;
}

/* Walk this directory's entries looking for any that point to the target. */
STATIC int
xrep_parents_scan_inode(
	struct xfs_mount	*mp,
	struct xfs_trans	*tp,
	xfs_ino_t		ino,
	void			*data)
{
	struct xrep_parents_scan *rps = data;
	struct xfs_inode	*dp;
	loff_t			oldpos;
	size_t			bufsize;
	unsigned int		lock_mode;
	int			locked;
	int			retries = 20;
	int			error;

	if (ino == rps->target_ino)
		return 0;

	/* Grab inode and lock it so we can scan it. */
	error = xfs_iget(mp, tp, ino, XFS_IGET_UNTRUSTED, 0, &dp);
	if (error)
		return error;

	if (!S_ISDIR(VFS_I(dp)->i_mode))
		goto out_rele;

	/*
	 * Try a few times to take the directory IOLOCK.  We have to use
	 * trylock here to avoid an ABBA deadlock with another thread that
	 * might have a parent locked and is asleep trying to lock our target.
	 * The solution for EDEADLOCK is usually to freeze the fs, so try a
	 * few times to get the inode to avoid that heavyweight solution.
	 */
	while (!(locked = xfs_ilock_nowait(dp, XFS_IOLOCK_SHARED)) && --retries)
		delay(HZ / 10);
	if (!locked) {
		error = -EDEADLOCK;
		goto out_rele;
	}

	/*
	 * If there are any blocks, read-ahead block 0 as we're almost certain
	 * to have the next operation be a read there.  This is how we
	 * guarantee that the directory's extent map has been loaded, if there
	 * is one.
	 */
	lock_mode = xfs_ilock_data_map_shared(dp);
	if (dp->i_d.di_nextents > 0)
		error = xfs_dir3_data_readahead(dp, 0, 0);
	xfs_iunlock(dp, lock_mode);
	if (error)
		goto out_unlock;

	/*
	 * Scan the directory to see if there it contains an entry pointing to
	 * the directory that we are repairing.
	 */
	rps->scan_dir = dp;
	bufsize = (size_t)min_t(loff_t, XFS_READDIR_BUFSIZE, dp->i_d.di_size);
	oldpos = 0;
	while (true) {
		error = xfs_readdir(tp, dp, &rps->dc, bufsize);
		if (error)
			break;
		if (rps->scan_error) {
			error = rps->scan_error;
			break;
		}
		if (oldpos == rps->dc.pos)
			break;
		oldpos = rps->dc.pos;
	}

out_unlock:
	xfs_iunlock(dp, XFS_IOLOCK_SHARED);
out_rele:
	xfs_irele(dp);
	return error;
}

/* Is this an acceptable parent for the inode we're scrubbing? */
bool
xrep_parent_acceptable(
	struct xfs_scrub	*sc,
	xfs_ino_t		ino)
{
	return ino != NULLFSINO && ino != 0 && ino != sc->ip->i_ino &&
		xfs_verify_dir_ino(sc->mp, ino);
}

/*
 * Scan the directory tree to find the directory entries that point to this
 * inode.
 */
int
xrep_scan_for_parents(
	struct xfs_scrub	*sc,
	xfs_ino_t		target_ino,
	xrep_parents_iter_fn	fn,
	void			*data)
{
	struct xrep_parents_scan rps = {
		.dc.actor	= xrep_parents_scan_dentry,
		.data		= data,
		.fn		= fn,
		.target_ino	= target_ino,
	};

	return xfs_iwalk(sc->mp, sc->tp, 0, 0, xrep_parents_scan_inode, 0,
			&rps);
}

/*
 * Repairing Parent Pointers
 * =========================
 *
 * Currently, only directories support parent pointers (in the form of '..'
 * entries), so we simply scan the filesystem and update the '..' entry.
 *
 * Note that because the only parent pointer is the dotdot entry, we won't
 * touch an unhealthy directory, since the directory repair code is perfectly
 * capable of rebuilding a directory with the proper parent inode.
 */
struct xrep_parent {
	struct xfs_scrub	*sc;

	/* Potential parent pointer. */
	xfs_ino_t		parent_ino;
};

/*
 * If this directory entry points to the directory we're rebuilding, then the
 * directory we're scanning is the parent.  Remember the parent.
 */
STATIC int
xrep_parent_absorb(
	struct xfs_inode	*dp,
	struct xfs_name		*name,
	unsigned int		dtype,
	void			*data)
{
	struct xrep_parent	*rp = data;
	int			error = 0;

	/* Uhoh, more than one parent for a dir? */
	if (rp->parent_ino != NULLFSINO)
		return -EFSCORRUPTED;

	if (xchk_should_terminate(rp->sc, &error))
		return error;

	/* We found a potential parent; remember this. */
	rp->parent_ino = dp->i_ino;
	return 0;
}

int
xrep_parent(
	struct xfs_scrub	*sc)
{
	struct xrep_parent	rp = {
		.sc		= sc,
		.parent_ino	= NULLFSINO,
	};
	unsigned int		sick, checked;
	unsigned int		spaceres;
	int			error;

	/*
	 * Avoid sick directories.  The parent pointer scrubber dropped the
	 * ILOCK, but we still hold IOLOCK_EXCL on the directory, so there
	 * shouldn't be anyone else clearing the directory's sick status.
	 */
	xfs_inode_measure_sickness(sc->ip, &sick, &checked);
	if (sick & XFS_SICK_INO_DIR)
		return -EFSCORRUPTED;

	/* Scan the entire directory tree for the directory's parent. */
	error = xrep_scan_for_parents(sc, sc->ip->i_ino, xrep_parent_absorb,
			&rp);
	if (error)
		return error;

	/* If we still don't have a parent, bail out. */
	if (!xrep_parent_acceptable(sc, rp.parent_ino))
		return 0;

	trace_xrep_parent_dir(sc->ip, rp.parent_ino);

	/* Reserve more space just in case we have to expand the dir. */
	spaceres = XFS_RENAME_SPACE_RES(sc->mp, 2);
	error = xfs_trans_reserve_more(sc->tp, spaceres, 0);
	if (error)
		return error;

	/* Re-take the ILOCK, we're going to need it to modify the dir. */
	sc->ilock_flags |= XFS_ILOCK_EXCL;
	xfs_ilock(sc->ip, XFS_ILOCK_EXCL);

	/* Replace the dotdot entry. */
	xfs_trans_ijoin(sc->tp, sc->ip, 0);
	return xfs_dir_replace(sc->tp, sc->ip, &xfs_name_dotdot, rp.parent_ino,
			spaceres);
}