path: root/fs/xfs/libxfs/xfs_imeta.c

// SPDX-License-Identifier: GPL-2.0-or-later
/*
 * Copyright (C) 2022 Oracle.  All Rights Reserved.
 * Author: Darrick J. Wong <djwong@kernel.org>
 */
#include "xfs.h"
#include "xfs_fs.h"
#include "xfs_shared.h"
#include "xfs_format.h"
#include "xfs_log_format.h"
#include "xfs_trans_resv.h"
#include "xfs_bit.h"
#include "xfs_sb.h"
#include "xfs_mount.h"
#include "xfs_defer.h"
#include "xfs_trans.h"
#include "xfs_imeta.h"
#include "xfs_trace.h"
#include "xfs_inode.h"
#include "xfs_quota.h"
#include "xfs_ialloc.h"
#include "xfs_bmap_btree.h"
#include "xfs_da_format.h"
#include "xfs_da_btree.h"
#include "xfs_trans_space.h"
#include "xfs_dir2.h"
#include "xfs_dir2_priv.h"
#include "xfs_ag.h"
#include "xfs_health.h"
#include "xfs_errortag.h"
#include "xfs_error.h"
#include "xfs_btree.h"
#include "xfs_alloc.h"

/*
 * Metadata Inode Number Management
 * ================================
 *
 * These functions provide an abstraction layer for looking up, creating, and
 * deleting metadata inodes.  These pointers live in the in-core superblock,
 * so the functions moderate access to those fields and take care of logging.
 *
 * For the five existing metadata inodes (real time bitmap & summary; and the
 * user, group, and quotas) we'll continue to maintain the in-core superblock
 * inodes for reads and only require xfs_imeta_create and xfs_imeta_unlink to
 * persist changes.  New metadata inode types must only use the xfs_imeta_*
 * functions.
 *
 * Callers wishing to create or unlink a metadata inode must pass in a
 * xfs_imeta_end structure.  After committing or cancelling the transaction,
 * this structure must be passed to xfs_imeta_end_update to free resources that
 * cannot be freed during the transaction.
 *
 * When the metadata directory tree (metadir) feature is enabled, we can create
 * a complex directory tree in which to store metadata inodes.  Inodes within
 * the metadata directory tree should have the "metadata" inode flag set to
 * prevent them from being exposed to the outside world.
 *
 * Callers are expected to take the IOLOCK of metadata directories when
 * performing lookups or updates to the tree.  They are expected to take the
 * ILOCK of any inode in the metadata directory tree (just like the regular to
 * synchronize access to that inode.  It is not necessary to take the MMAPLOCK
 * since metadata inodes should never be exposed to user space.
 */

/* Static metadata inode paths */
static const char *rtbitmap_path[]	= {"realtime", "bitmap"};
static const char *rtsummary_path[]	= {"realtime", "summary"};
static const char *usrquota_path[]	= {"quota", "user"};
static const char *grpquota_path[]	= {"quota", "group"};
static const char *prjquota_path[]	= {"quota", "project"};

XFS_IMETA_DEFINE_PATH(XFS_IMETA_RTBITMAP,	rtbitmap_path);
XFS_IMETA_DEFINE_PATH(XFS_IMETA_RTSUMMARY,	rtsummary_path);
XFS_IMETA_DEFINE_PATH(XFS_IMETA_USRQUOTA,	usrquota_path);
XFS_IMETA_DEFINE_PATH(XFS_IMETA_GRPQUOTA,	grpquota_path);
XFS_IMETA_DEFINE_PATH(XFS_IMETA_PRJQUOTA,	prjquota_path);

const struct xfs_imeta_path XFS_IMETA_METADIR = {
	.im_depth = 0,
	.im_ftype = XFS_DIR3_FT_DIR,
};

/* Are these two paths equal? */
STATIC bool
xfs_imeta_path_compare(
	const struct xfs_imeta_path	*a,
	const struct xfs_imeta_path	*b)
{
	unsigned int			i;

	if (a == b)
		return true;

	if (a->im_depth != b->im_depth)
		return false;

	for (i = 0; i < a->im_depth; i++)
		if (a->im_path[i] != b->im_path[i] &&
		    strcmp(a->im_path[i], b->im_path[i]))
			return false;

	return true;
}

/* Is this path ok? */
static inline bool
xfs_imeta_path_check(
	const struct xfs_imeta_path	*path)
{
	return path->im_depth <= XFS_IMETA_MAX_DEPTH;
}

/* Functions for storing and retrieving superblock inode values. */

/* Mapping of metadata inode paths to in-core superblock values. */
static const struct xfs_imeta_sbmap {
	const struct xfs_imeta_path	*path;
	unsigned int			offset;
} xfs_imeta_sbmaps[] = {
	{
		.path	= &XFS_IMETA_RTBITMAP,
		.offset	= offsetof(struct xfs_sb, sb_rbmino),
	},
	{
		.path	= &XFS_IMETA_RTSUMMARY,
		.offset	= offsetof(struct xfs_sb, sb_rsumino),
	},
	{
		.path	= &XFS_IMETA_USRQUOTA,
		.offset	= offsetof(struct xfs_sb, sb_uquotino),
	},
	{
		.path	= &XFS_IMETA_GRPQUOTA,
		.offset	= offsetof(struct xfs_sb, sb_gquotino),
	},
	{
		.path	= &XFS_IMETA_PRJQUOTA,
		.offset	= offsetof(struct xfs_sb, sb_pquotino),
	},
	{
		.path	= &XFS_IMETA_METADIR,
		.offset	= offsetof(struct xfs_sb, sb_metadirino),
	},
	{ NULL, 0 },
};

/* Return a pointer to the in-core superblock inode value. */
static inline xfs_ino_t *
xfs_imeta_sbmap_to_inop(
	struct xfs_mount		*mp,
	const struct xfs_imeta_sbmap	*map)
{
	return (xfs_ino_t *)(((char *)&mp->m_sb) + map->offset);
}

/* Compute location of metadata inode pointer in the in-core superblock */
static inline xfs_ino_t *
xfs_imeta_path_to_sb_inop(
	struct xfs_mount		*mp,
	const struct xfs_imeta_path	*path)
{
	const struct xfs_imeta_sbmap	*p;

	for (p = xfs_imeta_sbmaps; p->path; p++)
		if (xfs_imeta_path_compare(p->path, path))
			return xfs_imeta_sbmap_to_inop(mp, p);

	return NULL;
}

/* Look up a superblock metadata inode by its path. */
STATIC int
xfs_imeta_sb_lookup(
	struct xfs_mount		*mp,
	const struct xfs_imeta_path	*path,
	xfs_ino_t			*inop)
{
	xfs_ino_t			*sb_inop;

	sb_inop = xfs_imeta_path_to_sb_inop(mp, path);
	if (!sb_inop)
		return -EINVAL;

	trace_xfs_imeta_sb_lookup(mp, sb_inop);
	*inop = *sb_inop;
	return 0;
}

/* Update inode pointers in the superblock. */
static inline void
xfs_imeta_log_sb(
	struct xfs_trans	*tp)
{
	struct xfs_mount	*mp = tp->t_mountp;
	struct xfs_buf		*bp = xfs_trans_getsb(tp);

	/*
	 * Update the inode flags in the ondisk superblock without touching
	 * the summary counters.  We have not quiesced inode chunk allocation,
	 * so we cannot coordinate with updates to the icount and ifree percpu
	 * counters.
	 */
	xfs_sb_to_disk(bp->b_addr, &mp->m_sb);
	xfs_trans_buf_set_type(tp, bp, XFS_BLFT_SB_BUF);
	xfs_trans_log_buf(tp, bp, 0, sizeof(struct xfs_dsb) - 1);
}

/*
 * Create a new metadata inode and set a superblock pointer to this new inode.
 * The superblock field must not already be pointing to an inode.
 */
STATIC int
xfs_imeta_sb_create(
	struct xfs_trans		**tpp,
	const struct xfs_imeta_path	*path,
	umode_t				mode,
	unsigned int			flags,
	struct xfs_inode		**ipp)
{
	struct xfs_icreate_args		args = {
		.nlink			= S_ISDIR(mode) ? 2 : 1,
	};
	struct xfs_mount		*mp = (*tpp)->t_mountp;
	xfs_ino_t			*sb_inop;
	xfs_ino_t			ino;
	int				error;

	xfs_icreate_args_rootfile(&args, mode);

	/* Reject if the sb already points to some inode. */
	sb_inop = xfs_imeta_path_to_sb_inop(mp, path);
	if (!sb_inop)
		return -EINVAL;

	if (*sb_inop != NULLFSINO)
		return -EEXIST;

	/* Create a new inode and set the sb pointer. */
	error = xfs_dialloc(tpp, NULL, mode, &ino);
	if (error)
		return error;
	error = xfs_icreate(*tpp, ino, &args, ipp);
	if (error)
		return error;

	/* Attach dquots to this file.  Caller should have allocated them! */
	if (!(flags & XFS_IMETA_CREATE_NOQUOTA)) {
		error = xfs_qm_dqattach_locked(*ipp, false);
		if (error)
			return error;
		xfs_trans_mod_dquot_byino(*tpp, *ipp, XFS_TRANS_DQ_ICOUNT, 1);
	}

	/* Update superblock pointer. */
	*sb_inop = ino;
	trace_xfs_imeta_sb_create(mp, sb_inop);
	xfs_imeta_log_sb(*tpp);
	return 0;
}

/*
 * Clear the given inode pointer from the superblock and drop the link count
 * of the metadata inode.
 */
STATIC int
xfs_imeta_sb_unlink(
	struct xfs_trans		**tpp,
	const struct xfs_imeta_path	*path,
	struct xfs_inode		*ip)
{
	struct xfs_mount		*mp = (*tpp)->t_mountp;
	xfs_ino_t			*sb_inop;

	sb_inop = xfs_imeta_path_to_sb_inop(mp, path);
	if (!sb_inop)
		return -EINVAL;

	/* Reject if the sb doesn't point to the inode that was passed in. */
	if (*sb_inop != ip->i_ino)
		return -ENOENT;

	*sb_inop = NULLFSINO;
	trace_xfs_imeta_sb_unlink(mp, sb_inop);
	xfs_imeta_log_sb(*tpp);
	return xfs_droplink(*tpp, ip);
}

/* Set the given inode pointer in the superblock. */
STATIC int
xfs_imeta_sb_link(
	struct xfs_trans		*tp,
	const struct xfs_imeta_path	*path,
	struct xfs_inode		*ip)
{
	struct xfs_mount		*mp = tp->t_mountp;
	xfs_ino_t			*sb_inop;

	sb_inop = xfs_imeta_path_to_sb_inop(mp, path);
	if (!sb_inop)
		return -EINVAL;
	if (*sb_inop == NULLFSINO)
		return -EEXIST;

	xfs_ilock(ip, XFS_ILOCK_EXCL);
	xfs_trans_ijoin(tp, ip, XFS_ILOCK_EXCL);

	inc_nlink(VFS_I(ip));
	*sb_inop = ip->i_ino;
	trace_xfs_imeta_sb_link(mp, sb_inop);
	xfs_trans_log_inode(tp, ip, XFS_ILOG_CORE);
	xfs_imeta_log_sb(tp);
	return 0;
}

/* Functions for storing and retrieving metadata directory inode values. */

static inline void
set_xname(
	struct xfs_name			*xname,
	const struct xfs_imeta_path	*path,
	unsigned int			path_idx,
	unsigned char			ftype)
{
	xname->name = (const unsigned char *)path->im_path[path_idx];
	xname->len = strlen(path->im_path[path_idx]);
	xname->type = ftype;
}

/* Look up the inode number and filetype for an exact name in a directory. */
static inline int
xfs_imeta_dir_lookup(
	struct xfs_inode	*dp,
	struct xfs_name		*xname,
	xfs_ino_t		*ino)
{
	struct xfs_da_args	args = {
		.dp		= dp,
		.geo		= dp->i_mount->m_dir_geo,
		.name		= xname->name,
		.namelen	= xname->len,
		.hashval	= xfs_dir2_hashname(dp->i_mount, xname),
		.whichfork	= XFS_DATA_FORK,
		.op_flags	= XFS_DA_OP_OKNOENT,
		.owner		= dp->i_ino,
	};
	unsigned int		lock_mode;
	bool			isblock, isleaf;
	int			error;

	if (xfs_is_shutdown(dp->i_mount))
		return -EIO;

	lock_mode = xfs_ilock_data_map_shared(dp);
	if (dp->i_df.if_format == XFS_DINODE_FMT_LOCAL) {
		error = xfs_dir2_sf_lookup(&args);
		goto out_unlock;
	}

	/* dir2 functions require that the data fork is loaded */
	error = xfs_iread_extents(NULL, dp, XFS_DATA_FORK);
	if (error)
		goto out_unlock;

	error = xfs_dir2_isblock(&args, &isblock);
	if (error)
		goto out_unlock;

	if (isblock) {
		error = xfs_dir2_block_lookup(&args);
		goto out_unlock;
	}

	error = xfs_dir2_isleaf(&args, &isleaf);
	if (error)
		goto out_unlock;

	if (isleaf) {
		error = xfs_dir2_leaf_lookup(&args);
		goto out_unlock;
	}

	error = xfs_dir2_node_lookup(&args);

out_unlock:
	xfs_iunlock(dp, lock_mode);
	if (error == -EEXIST)
		error = 0;
	if (error)
		return error;

	*ino = args.inumber;
	xname->type = args.filetype;
	return 0;
}
/*
 * Given a parent directory @dp, a metadata inode @path and component
 * @path_idx, and the expected file type @ftype of the path component, fill out
 * the @xname and look up the inode number in the directory, returning it in
 * @ino.
 */
static inline int
xfs_imeta_dir_lookup_component(
	struct xfs_inode		*dp,
	struct xfs_name			*xname,
	xfs_ino_t			*ino)
{
	int				type_wanted = xname->type;
	int				error;

	trace_xfs_imeta_dir_lookup_component(dp, xname, NULLFSINO);

	if (!S_ISDIR(VFS_I(dp)->i_mode)) {
		xfs_fs_mark_sick(dp->i_mount, XFS_SICK_FS_METADIR);
		return -EFSCORRUPTED;
	}

	error = xfs_imeta_dir_lookup(dp, xname, ino);
	if (error)
		return error;
	if (!xfs_verify_ino(dp->i_mount, *ino)) {
		xfs_fs_mark_sick(dp->i_mount, XFS_SICK_FS_METADIR);
		return -EFSCORRUPTED;
	}
	if (type_wanted != XFS_DIR3_FT_UNKNOWN && xname->type != type_wanted) {
		xfs_fs_mark_sick(dp->i_mount, XFS_SICK_FS_METADIR);
		return -EFSCORRUPTED;
	}

	trace_xfs_imeta_dir_lookup_found(dp, xname, *ino);
	return 0;
}

/*
 * Traverse a metadata directory tree path, returning the inode corresponding
 * to the parent of the last path component.  If any of the path components do
 * not exist, return -ENOENT.
 */
STATIC int
xfs_imeta_dir_parent(
	struct xfs_mount		*mp,
	const struct xfs_imeta_path	*path,
	struct xfs_inode		**dpp)
{
	struct xfs_name			xname;
	struct xfs_inode		*dp;
	xfs_ino_t			ino;
	unsigned int			i;
	int				error;

	if (mp->m_metadirip == NULL)
		return -ENOENT;

	/* Grab the metadir root. */
	error = xfs_imeta_iget(mp, mp->m_metadirip->i_ino, XFS_DIR3_FT_DIR,
			&dp);
	if (error)
		return error;

	/* Caller wanted the root, we're done! */
	if (path->im_depth == 0) {
		*dpp = dp;
		return 0;
	}

	for (i = 0; i < path->im_depth - 1; i++) {
		struct xfs_inode	*ip = NULL;

		xfs_ilock(dp, XFS_IOLOCK_SHARED);

		/* Look up the name in the current directory. */
		set_xname(&xname, path, i, XFS_DIR3_FT_DIR);
		error = xfs_imeta_dir_lookup_component(dp, &xname, &ino);
		if (error)
			goto out_rele;

		/*
		 * Grab the child inode while we still have the parent
		 * directory locked.
		 */
		error = xfs_imeta_iget(mp, ino, XFS_DIR3_FT_DIR, &ip);
		if (error)
			goto out_rele;

		xfs_iunlock(dp, XFS_IOLOCK_SHARED);
		xfs_imeta_irele(dp);
		dp = ip;
	}

	*dpp = dp;
	return 0;

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

/*
 * Look up a metadata inode from the metadata directory.  If the last path
 * component doesn't exist, return NULLFSINO.  If any other part of the path
 * does not exist, return -ENOENT so we can distinguish the two.
 */
STATIC int
xfs_imeta_dir_lookup_int(
	struct xfs_mount		*mp,
	const struct xfs_imeta_path	*path,
	xfs_ino_t			*inop)
{
	struct xfs_name			xname;
	struct xfs_inode		*dp = NULL;
	xfs_ino_t			ino;
	int				error;

	/* metadir ino is recorded in superblock */
	if (xfs_imeta_path_compare(path, &XFS_IMETA_METADIR))
		return xfs_imeta_sb_lookup(mp, path, inop);

	ASSERT(path->im_depth > 0);

	/* Find the parent of the last path component. */
	error = xfs_imeta_dir_parent(mp, path, &dp);
	if (error)
		return error;

	xfs_ilock(dp, XFS_IOLOCK_SHARED);

	/* Look up the name in the current directory. */
	set_xname(&xname, path, path->im_depth - 1, path->im_ftype);
	error = xfs_imeta_dir_lookup_component(dp, &xname, &ino);
	switch (error) {
	case 0:
		*inop = ino;
		break;
	case -ENOENT:
		*inop = NULLFSINO;
		error = 0;
		break;
	}

	xfs_iunlock(dp, XFS_IOLOCK_SHARED);
	xfs_imeta_irele(dp);
	return error;
}

/*
 * Load all the metadata inode pointers that are cached in the in-core
 * superblock but live somewhere in the metadata directory tree.
 */
STATIC int
xfs_imeta_dir_mount(
	struct xfs_mount		*mp)
{
	const struct xfs_imeta_sbmap	*p;
	xfs_ino_t			*sb_inop;
	int				err2;
	int				error = 0;

	for (p = xfs_imeta_sbmaps; p->path && p->path->im_depth > 0; p++) {
		if (p->path == &XFS_IMETA_METADIR)
			continue;
		sb_inop = xfs_imeta_sbmap_to_inop(mp, p);
		err2 = xfs_imeta_dir_lookup_int(mp, p->path, sb_inop);
		if (err2 == -ENOENT) {
			*sb_inop = NULLFSINO;
			continue;
		}
		if (!error && err2)
			error = err2;
	}

	return error;
}

/* Set up an inode to be recognized as a metadata inode. */
void
xfs_imeta_set_metaflag(
	struct xfs_trans	*tp,
	struct xfs_inode	*ip)
{
	VFS_I(ip)->i_mode &= ~0777;
	VFS_I(ip)->i_uid = GLOBAL_ROOT_UID;
	VFS_I(ip)->i_gid = GLOBAL_ROOT_GID;
	ip->i_projid = 0;
	ip->i_diflags |= (XFS_DIFLAG_IMMUTABLE | XFS_DIFLAG_SYNC |
			  XFS_DIFLAG_NOATIME | XFS_DIFLAG_NODUMP |
			  XFS_DIFLAG_NODEFRAG);
	if (S_ISDIR(VFS_I(ip)->i_mode))
		ip->i_diflags |= XFS_DIFLAG_NOSYMLINKS;
	ip->i_diflags2 &= ~XFS_DIFLAG2_DAX;
	ip->i_diflags2 |= XFS_DIFLAG2_METADATA;
	xfs_trans_log_inode(tp, ip, XFS_ILOG_CORE);
}

/*
 * Create a new metadata inode accessible via the given metadata directory path.
 * Callers must ensure that the directory entry does not already exist; a new
 * one will be created.
 */
STATIC int
xfs_imeta_dir_create(
	struct xfs_trans		**tpp,
	const struct xfs_imeta_path	*path,
	umode_t				mode,
	unsigned int			flags,
	struct xfs_inode		**ipp,
	struct xfs_imeta_update		*upd)
{
	struct xfs_icreate_args		args = {
		.nlink			= S_ISDIR(mode) ? 2 : 1,
	};
	struct xfs_name			xname;
	struct xfs_mount		*mp = (*tpp)->t_mountp;
	struct xfs_inode		*dp = upd->dp;
	xfs_ino_t			*sb_inop;
	xfs_ino_t			ino;
	unsigned int			resblks;
	int				error;

	xfs_icreate_args_rootfile(&args, mode);

	/* metadir ino is recorded in superblock; only mkfs gets to do this */
	if (xfs_imeta_path_compare(path, &XFS_IMETA_METADIR)) {
		error = xfs_imeta_sb_create(tpp, path, mode, flags, ipp);
		if (error)
			return error;

		/* Set the metadata iflag, initialize directory. */
		xfs_imeta_set_metaflag(*tpp, *ipp);
		return xfs_dir_init(*tpp, *ipp, *ipp);
	}

	ASSERT(path->im_depth > 0);

	/* Check that the name does not already exist in the directory. */
	set_xname(&xname, path, path->im_depth - 1, XFS_DIR3_FT_UNKNOWN);
	error = xfs_imeta_dir_lookup_component(dp, &xname, &ino);
	switch (error) {
	case -ENOENT:
		break;
	case 0:
		error = -EEXIST;
		fallthrough;
	default:
		return error;
	}

	xfs_ilock(dp, XFS_ILOCK_EXCL | XFS_ILOCK_PARENT);
	args.pip = dp;

	/*
	 * A newly created regular or special file just has one directory
	 * entry pointing to them, but a directory also the "." entry
	 * pointing to itself.
	 */
	error = xfs_dialloc(tpp, dp, mode, &ino);
	if (error)
		goto out_ilock;
	error = xfs_icreate(*tpp, ino, &args, ipp);
	if (error)
		goto out_ilock;
	xfs_imeta_set_metaflag(*tpp, *ipp);

	/*
	 * Once we join the parent directory to the transaction we can't
	 * release it until after the transaction commits or cancels, so we
	 * must defer releasing it to end_update.  This is different from
	 * regular file creation, where the vfs holds the parent dir reference
	 * and will free it.  The caller is always responsible for releasing
	 * ipp, even if we failed.
	 */
	xfs_trans_ijoin(*tpp, dp, XFS_ILOCK_EXCL);

	/* Create the entry. */
	if (S_ISDIR(args.mode))
		resblks = XFS_MKDIR_SPACE_RES(mp, xname.len);
	else
		resblks = XFS_CREATE_SPACE_RES(mp, xname.len);
	xname.type = xfs_mode_to_ftype(args.mode);
	trace_xfs_imeta_dir_try_create(dp, &xname, NULLFSINO);
	error = xfs_dir_create_new_child(*tpp, resblks, dp, &xname, *ipp);
	if (error)
		return error;
	trace_xfs_imeta_dir_created(*ipp, &xname, ino);

	/* Attach dquots to this file.  Caller should have allocated them! */
	if (!(flags & XFS_IMETA_CREATE_NOQUOTA)) {
		error = xfs_qm_dqattach_locked(*ipp, false);
		if (error)
			return error;
		xfs_trans_mod_dquot_byino(*tpp, *ipp, XFS_TRANS_DQ_ICOUNT, 1);
	}

	/* Update the in-core superblock value if there is one. */
	sb_inop = xfs_imeta_path_to_sb_inop(mp, path);
	if (sb_inop)
		*sb_inop = ino;
	return 0;

out_ilock:
	xfs_iunlock(dp, XFS_ILOCK_EXCL);
	return error;
}

/*
 * Remove the given entry from the metadata directory and drop the link count
 * of the metadata inode.
 */
STATIC int
xfs_imeta_dir_unlink(
	struct xfs_trans		**tpp,
	const struct xfs_imeta_path	*path,
	struct xfs_inode		*ip,
	struct xfs_imeta_update		*upd)
{
	struct xfs_name			xname;
	struct xfs_mount		*mp = (*tpp)->t_mountp;
	struct xfs_inode		*dp = upd->dp;
	xfs_ino_t			*sb_inop;
	xfs_ino_t			ino;
	unsigned int			resblks;
	int				error;

	/* Metadata directory root cannot be unlinked. */
	if (xfs_imeta_path_compare(path, &XFS_IMETA_METADIR)) {
		ASSERT(0);
		xfs_fs_mark_sick(mp, XFS_SICK_FS_METADIR);
		return -EFSCORRUPTED;
	}

	ASSERT(path->im_depth > 0);

	/* Look up the name in the current directory. */
	set_xname(&xname, path, path->im_depth - 1,
			xfs_mode_to_ftype(VFS_I(ip)->i_mode));
	error = xfs_imeta_dir_lookup_component(dp, &xname, &ino);
	switch (error) {
	case 0:
		if (ino != ip->i_ino)
			error = -ENOENT;
		break;
	case -ENOENT:
		xfs_fs_mark_sick(mp, XFS_SICK_FS_METADIR);
		error = -EFSCORRUPTED;
		break;
	}
	if (error)
		return error;

	xfs_lock_two_inodes(dp, XFS_ILOCK_EXCL, ip, XFS_ILOCK_EXCL);

	/*
	 * Once we join the parent directory to the transaction we can't
	 * release it until after the transaction commits or cancels, so we
	 * must defer releasing it to end_update.  This is different from
	 * regular file removal, where the vfs holds the parent dir reference
	 * and will free it.  The unlink caller is always responsible for
	 * releasing ip, so we don't need to take care of that.
	 */
	xfs_trans_ijoin(*tpp, dp, XFS_ILOCK_EXCL);
	xfs_trans_ijoin(*tpp, ip, XFS_ILOCK_EXCL);

	resblks = XFS_REMOVE_SPACE_RES(mp);
	error = xfs_dir_remove_child(*tpp, resblks, dp, &xname, ip);
	if (error)
		return error;
	trace_xfs_imeta_dir_unlinked(dp, &xname, ip->i_ino);

	/* Update the in-core superblock value if there is one. */
	sb_inop = xfs_imeta_path_to_sb_inop(mp, path);
	if (sb_inop)
		*sb_inop = NULLFSINO;
	return 0;
}

/* Set the given path in the metadata directory to point to an inode. */
STATIC int
xfs_imeta_dir_link(
	struct xfs_trans		*tp,
	const struct xfs_imeta_path	*path,
	struct xfs_inode		*ip,
	struct xfs_imeta_update		*upd)
{
	struct xfs_name			xname;
	struct xfs_mount		*mp = tp->t_mountp;
	struct xfs_inode		*dp = upd->dp;
	xfs_ino_t			*sb_inop;
	xfs_ino_t			ino;
	unsigned int			resblks;
	int				error;

	/* Metadata directory root cannot be linked. */
	if (xfs_imeta_path_compare(path, &XFS_IMETA_METADIR)) {
		ASSERT(0);
		xfs_fs_mark_sick(mp, XFS_SICK_FS_METADIR);
		return -EFSCORRUPTED;
	}

	ASSERT(path->im_depth > 0);

	/* Look up the name in the current directory. */
	set_xname(&xname, path, path->im_depth - 1,
			xfs_mode_to_ftype(VFS_I(ip)->i_mode));
	error = xfs_imeta_dir_lookup_component(dp, &xname, &ino);
	switch (error) {
	case -ENOENT:
		break;
	case 0:
		error = -EEXIST;
		fallthrough;
	default:
		return error;
	}

	xfs_lock_two_inodes(ip, XFS_ILOCK_EXCL, dp, XFS_ILOCK_EXCL);

	/*
	 * Once we join the parent directory to the transaction we can't
	 * release it until after the transaction commits or cancels, so we
	 * must defer releasing it to end_update.  This is different from
	 * regular file removal, where the vfs holds the parent dir reference
	 * and will free it.  The link caller is always responsible for
	 * releasing ip, so we don't need to take care of that.
	 */
	xfs_trans_ijoin(tp, ip, XFS_ILOCK_EXCL);
	xfs_trans_ijoin(tp, dp, XFS_ILOCK_EXCL);

	resblks = XFS_LINK_SPACE_RES(mp, target_name->len);
	error = xfs_dir_link_existing_child(tp, resblks, dp, &xname, ip);
	if (error)
		return error;

	trace_xfs_imeta_dir_link(dp, &xname, ip->i_ino);

	/* Update the in-core superblock value if there is one. */
	sb_inop = xfs_imeta_path_to_sb_inop(mp, path);
	if (sb_inop)
		*sb_inop = ip->i_ino;
	return 0;
}

/* General functions for managing metadata inode pointers */

/*
 * Is this metadata inode pointer ok?  We allow the fields to be set to
 * NULLFSINO if the metadata structure isn't present, and we don't allow
 * obviously incorrect inode pointers.
 */
static inline bool
xfs_imeta_verify(
	struct xfs_mount	*mp,
	xfs_ino_t		ino)
{
	if (ino == NULLFSINO)
		return true;
	return xfs_verify_ino(mp, ino);
}

/* Look up a metadata inode by its path. */
int
xfs_imeta_lookup(
	struct xfs_mount		*mp,
	const struct xfs_imeta_path	*path,
	xfs_ino_t			*inop)
{
	xfs_ino_t			ino;
	int				error;

	ASSERT(xfs_imeta_path_check(path));

	if (xfs_has_metadir(mp)) {
		error = xfs_imeta_dir_lookup_int(mp, path, &ino);
		if (error == -ENOENT) {
			xfs_fs_mark_sick(mp, XFS_SICK_FS_METADIR);
			return -EFSCORRUPTED;
		}
	} else {
		error = xfs_imeta_sb_lookup(mp, path, &ino);
	}
	if (error)
		return error;

	if (!xfs_imeta_verify(mp, ino)) {
		xfs_fs_mark_sick(mp, XFS_SICK_FS_METADIR);
		return -EFSCORRUPTED;
	}

	*inop = ino;
	return 0;
}

/*
 * Create a metadata inode with the given @mode, and insert it into the
 * metadata directory tree at the given @path.  The path (up to the final
 * component) must already exist.  The new metadata inode @ipp will be ijoined
 * and logged to @tpp, with the ILOCK held until the next transaction commit.
 * The caller must provide a @upd structure.
 *
 * Callers must ensure that the root dquots are allocated, if applicable.
 *
 * NOTE: This function may pass a child inode @ipp back to the caller even if
 * it returns a negative error code.  If an inode is passed back, the caller
 * must finish setting up the incore inode before releasing it.
 */
int
xfs_imeta_create(
	struct xfs_trans		**tpp,
	const struct xfs_imeta_path	*path,
	umode_t				mode,
	unsigned int			flags,
	struct xfs_inode		**ipp,
	struct xfs_imeta_update		*upd)
{
	struct xfs_mount		*mp = (*tpp)->t_mountp;

	ASSERT(xfs_imeta_path_check(path));
	*ipp = NULL;

	if (xfs_has_metadir(mp))
		return xfs_imeta_dir_create(tpp, path, mode, flags, ipp,
				upd);
	return xfs_imeta_sb_create(tpp, path, mode, flags, ipp);
}

/* Free a file from the metadata directory tree. */
STATIC int
xfs_imeta_ifree(
	struct xfs_trans	*tp,
	struct xfs_inode	*ip)
{
	struct xfs_mount	*mp = ip->i_mount;
	struct xfs_perag	*pag;
	struct xfs_icluster	xic = { 0 };
	int			error;

	ASSERT(xfs_isilocked(ip, XFS_ILOCK_EXCL));
	ASSERT(VFS_I(ip)->i_nlink == 0);
	ASSERT(ip->i_df.if_nextents == 0);
	ASSERT(ip->i_disk_size == 0 || !S_ISREG(VFS_I(ip)->i_mode));
	ASSERT(ip->i_nblocks == 0);

	pag = xfs_perag_get(mp, XFS_INO_TO_AGNO(mp, ip->i_ino));

	error = xfs_dir_ifree(tp, pag, ip, &xic);
	if (error)
		goto out;

	/* Metadata files do not support ownership changes or DMAPI. */

	if (xic.deleted)
		error = xfs_ifree_cluster(tp, pag, ip, &xic);
out:
	xfs_perag_put(pag);
	return error;
}

/*
 * Unlink a metadata inode @ip from the metadata directory given by @path.  The
 * metadata inode must not be ILOCKed.  Upon return, the inode will be ijoined
 * and logged to @tpp, and returned with reduced link count, ready to be
 * released.  The caller must provide a @upd structure.
 */
int
xfs_imeta_unlink(
	struct xfs_trans		**tpp,
	const struct xfs_imeta_path	*path,
	struct xfs_inode		*ip,
	struct xfs_imeta_update		*upd)
{
	struct xfs_mount		*mp = (*tpp)->t_mountp;
	int				error;

	ASSERT(xfs_imeta_path_check(path));
	ASSERT(xfs_imeta_verify((*tpp)->t_mountp, ip->i_ino));

	if (xfs_has_metadir(mp))
		error = xfs_imeta_dir_unlink(tpp, path, ip, upd);
	else
		error = xfs_imeta_sb_unlink(tpp, path, ip);
	if (error)
		return error;

	/*
	 * Metadata files require explicit resource cleanup.  In other words,
	 * the inactivation system will not touch these files, so we must free
	 * the ondisk inode by ourselves if warranted.
	 */
	if (VFS_I(ip)->i_nlink > 0)
		return 0;

	return xfs_imeta_ifree(*tpp, ip);
}

/*
 * Link the metadata directory given by @path point to the given inode number.
 * The path must not already exist.  The caller must not hold the ILOCK, and
 * the function will return with the inode joined to the transaction.
 */
int
xfs_imeta_link(
	struct xfs_trans		*tp,
	const struct xfs_imeta_path	*path,
	struct xfs_inode		*ip,
	struct xfs_imeta_update		*upd)
{
	struct xfs_mount		*mp = tp->t_mountp;

	ASSERT(xfs_imeta_path_check(path));

	if (xfs_has_metadir(mp))
		return xfs_imeta_dir_link(tp, path, ip, upd);
	return xfs_imeta_sb_link(tp, path, ip);
}

/*
 * Clean up after committing (or cancelling) a metadata inode creation or
 * removal.
 */
void
xfs_imeta_end_update(
	struct xfs_mount		*mp,
	struct xfs_imeta_update		*upd,
	int				error)
{
	trace_xfs_imeta_end_update(mp, error, __return_address);

	if (upd->dp) {
		if (upd->lock_mode)
			xfs_iunlock(upd->dp, upd->lock_mode);
		xfs_imeta_irele(upd->dp);
	}
	upd->lock_mode = 0;
	upd->dp = NULL;
}

/* Start setting up for a metadata directory tree operation. */
int
xfs_imeta_start_update(
	struct xfs_mount		*mp,
	const struct xfs_imeta_path	*path,
	struct xfs_imeta_update		*upd)
{
	int				error;

	trace_xfs_imeta_start_update(mp, 0, __return_address);

	memset(upd, 0, sizeof(struct xfs_imeta_update));

	/* Metadir root directory does not have a parent. */
	if (!xfs_has_metadir(mp) ||
	    xfs_imeta_path_compare(path, &XFS_IMETA_METADIR))
		return 0;

	ASSERT(path->im_depth > 0);

	/*
	 * Find the parent of the last path component.  If the parent path does
	 * not exist, we consider this corruption because paths are supposed
	 * to exist.
	 */
	error = xfs_imeta_dir_parent(mp, path, &upd->dp);
	if (error == -ENOENT) {
		xfs_fs_mark_sick(mp, XFS_SICK_FS_METADIR);
		return -EFSCORRUPTED;
	}
	if (error)
		return error;

	xfs_ilock(upd->dp, XFS_IOLOCK_EXCL | XFS_IOLOCK_PARENT);
	upd->lock_mode = XFS_IOLOCK_EXCL;
	return 0;
}

/* Does this inode number refer to a static metadata inode? */
bool
xfs_is_static_meta_ino(
	struct xfs_mount		*mp,
	xfs_ino_t			ino)
{
	const struct xfs_imeta_sbmap	*p;

	if (ino == NULLFSINO)
		return false;

	for (p = xfs_imeta_sbmaps; p->path; p++)
		if (ino == *xfs_imeta_sbmap_to_inop(mp, p))
			return true;

	return false;
}

/* Ensure that the in-core superblock has all the values that it should. */
int
xfs_imeta_mount(
	struct xfs_mount	*mp)
{
	if (xfs_has_metadir(mp))
		return xfs_imeta_dir_mount(mp);

	return 0;
}

/* Calculate the log block reservation to create a metadata inode. */
unsigned int
xfs_imeta_create_space_res(
	struct xfs_mount	*mp)
{
	if (xfs_has_metadir(mp))
		return max(XFS_MKDIR_SPACE_RES(mp, NAME_MAX),
			   XFS_CREATE_SPACE_RES(mp, NAME_MAX));
	return XFS_IALLOC_SPACE_RES(mp);
}

/* Calculate the log block reservation to unlink a metadata inode. */
unsigned int
xfs_imeta_unlink_space_res(
	struct xfs_mount	*mp)
{
	return XFS_REMOVE_SPACE_RES(mp);
}

/* Clear the metadata iflag if we're unlinking this inode. */
void
xfs_imeta_droplink(
	struct xfs_inode	*ip)
{
	if (VFS_I(ip)->i_nlink == 0 &&
	    xfs_has_metadir(ip->i_mount) &&
	    xfs_is_metadata_inode(ip))
		ip->i_diflags2 &= ~XFS_DIFLAG2_METADATA;
}

/*
 * Given a metadata directory update, look up the inode number of the last
 * component in the path.
 */
int
xfs_imeta_lookup_update(
	struct xfs_mount		*mp,
	const struct xfs_imeta_path	*path,
	struct xfs_imeta_update		*upd,
	xfs_ino_t			*inop)
{
	struct xfs_name			xname;
	xfs_ino_t			ino;
	int				error;

	ASSERT(xfs_isilocked(upd->dp, XFS_IOLOCK_SHARED | XFS_IOLOCK_EXCL));

	/* metadir ino is recorded in superblock */
	if (!xfs_has_metadir(mp) ||
	    xfs_imeta_path_compare(path, &XFS_IMETA_METADIR))
		return xfs_imeta_sb_lookup(mp, path, inop);

	ASSERT(path->im_depth > 0);

	/* Check that the name does not already exist in the directory. */
	set_xname(&xname, path, path->im_depth - 1, XFS_DIR3_FT_UNKNOWN);
	error = xfs_imeta_dir_lookup_component(upd->dp, &xname, &ino);
	switch (error) {
	case 0:
		*inop = ino;
		break;
	case -ENOENT:
		*inop = NULLFSINO;
		error = 0;
		break;
	}

	return error;
}

/* Create a path to a file within the metadata directory tree. */
int
xfs_imeta_create_file_path(
	struct xfs_mount	*mp,
	unsigned int		nr_components,
	struct xfs_imeta_path	**pathp)
{
	struct xfs_imeta_path	*p;
	char			**components;

	p = kmalloc(sizeof(struct xfs_imeta_path), GFP_KERNEL);
	if (!p)
		return -ENOMEM;

	components = kvcalloc(nr_components, sizeof(char *), GFP_KERNEL);
	if (!components) {
		kfree(p);
		return -ENOMEM;
	}

	p->im_depth = nr_components;
	p->im_path = (const char **)components;
	p->im_ftype = XFS_DIR3_FT_REG_FILE;
	p->im_dynamicmask = 0;
	*pathp = p;
	return 0;
}

/* Free a metadata directory tree path. */
void
xfs_imeta_free_path(
	struct xfs_imeta_path	*path)
{
	unsigned int		i;

	for (i = 0; i < path->im_depth; i++) {
		if ((path->im_dynamicmask & (1ULL << i)) && path->im_path[i])
			kfree(path->im_path[i]);
	}
	kfree(path->im_path);
	kfree(path);
}

/*
 * Is the amount of space that could be allocated towards a given metadata
 * file at or beneath a certain threshold?
 */
static inline bool
xfs_imeta_resv_can_cover(
	struct xfs_inode	*ip,
	int64_t			rhs)
{
	/*
	 * The amount of space that can be allocated to this metadata file is
	 * the remaining reservation for the particular metadata file + the
	 * global free block count.  Take care of the first case to avoid
	 * touching the per-cpu counter.
	 */
	if (ip->i_delayed_blks >= rhs)
		return true;

	/*
	 * There aren't enough blocks left in the inode's reservation, but it
	 * isn't critical unless there also isn't enough free space.
	 */
	return __percpu_counter_compare(&ip->i_mount->m_fdblocks,
			rhs - ip->i_delayed_blks, 2048) >= 0;
}

/*
 * Is this metadata file critically low on blocks?  For now we'll define that
 * as the number of blocks we can get our hands on being less than 10% of what
 * we reserved or less than some arbitrary number (maximum btree height).
 */
bool
xfs_imeta_resv_critical(
	struct xfs_inode	*ip)
{
	uint64_t		asked_low_water;

	if (!ip)
		return false;

	ASSERT(xfs_is_metadata_inode(ip));
	trace_xfs_imeta_resv_critical(ip, 0);

	if (!xfs_imeta_resv_can_cover(ip, ip->i_mount->m_rtbtree_maxlevels))
		return true;

	asked_low_water = div_u64(ip->i_meta_resv_asked, 10);
	if (!xfs_imeta_resv_can_cover(ip, asked_low_water))
		return true;

	return XFS_TEST_ERROR(false, ip->i_mount,
			XFS_ERRTAG_IMETA_RESV_CRITICAL);
}

/* Allocate a block from the metadata file's reservation. */
void
xfs_imeta_resv_alloc_extent(
	struct xfs_inode	*ip,
	struct xfs_alloc_arg	*args)
{
	int64_t			len = args->len;

	ASSERT(xfs_is_metadata_inode(ip));
	ASSERT(args->resv == XFS_AG_RESV_IMETA);

	trace_xfs_imeta_resv_alloc_extent(ip, args->len);

	/*
	 * Allocate the blocks from the metadata inode's block reservation
	 * and update the ondisk sb counter.
	 */
	if (ip->i_delayed_blks > 0) {
		int64_t		from_resv;

		from_resv = min_t(int64_t, len, ip->i_delayed_blks);
		ip->i_delayed_blks -= from_resv;
		xfs_mod_delalloc(ip->i_mount, -from_resv);
		xfs_trans_mod_sb(args->tp, XFS_TRANS_SB_RES_FDBLOCKS,
				-from_resv);
		len -= from_resv;
	}

	/*
	 * Any allocation in excess of the reservation requires in-core and
	 * on-disk fdblocks updates.
	 */
	if (len)
		xfs_trans_mod_sb(args->tp, XFS_TRANS_SB_FDBLOCKS, -len);

	ip->i_nblocks += args->len;
}

/* Free a block to the metadata file's reservation. */
void
xfs_imeta_resv_free_extent(
	struct xfs_inode	*ip,
	struct xfs_trans	*tp,
	xfs_filblks_t		len)
{
	int64_t			to_resv;

	ASSERT(xfs_is_metadata_inode(ip));
	trace_xfs_imeta_resv_free_extent(ip, len);

	ip->i_nblocks -= len;

	/*
	 * Add the freed blocks back into the inode's delalloc reservation
	 * until it reaches the maximum size.  Update the ondisk fdblocks only.
	 */
	to_resv = ip->i_meta_resv_asked - (ip->i_nblocks + ip->i_delayed_blks);
	if (to_resv > 0) {
		to_resv = min_t(int64_t, to_resv, len);
		ip->i_delayed_blks += to_resv;
		xfs_mod_delalloc(ip->i_mount, to_resv);
		xfs_trans_mod_sb(tp, XFS_TRANS_SB_RES_FDBLOCKS, to_resv);
		len -= to_resv;
	}

	/*
	 * Everything else goes back to the filesystem, so update the in-core
	 * and on-disk counters.
	 */
	if (len)
		xfs_trans_mod_sb(tp, XFS_TRANS_SB_FDBLOCKS, len);
}

/* Release a metadata file's space reservation. */
void
xfs_imeta_resv_free_inode(
	struct xfs_inode	*ip)
{
	if (!ip)
		return;

	ASSERT(xfs_is_metadata_inode(ip));
	trace_xfs_imeta_resv_free(ip, 0);

	xfs_mod_delalloc(ip->i_mount, -ip->i_delayed_blks);
	xfs_mod_fdblocks(ip->i_mount, ip->i_delayed_blks, true);
	ip->i_delayed_blks = 0;
	ip->i_meta_resv_asked = 0;
}

/* Set up a metadata file's space reservation. */
int
xfs_imeta_resv_init_inode(
	struct xfs_inode	*ip,
	xfs_filblks_t		ask)
{
	xfs_filblks_t		hidden_space;
	xfs_filblks_t		used;
	int			error;

	if (!ip || ip->i_meta_resv_asked > 0)
		return 0;

	ASSERT(xfs_is_metadata_inode(ip));

	/*
	 * Space taken by all other metadata btrees are accounted on-disk as
	 * used space.  We therefore only hide the space that is reserved but
	 * not used by the trees.
	 */
	used = ip->i_nblocks;
	if (used > ask)
		ask = used;
	hidden_space = ask - used;

	error = xfs_mod_fdblocks(ip->i_mount, -(int64_t)hidden_space, true);
	if (error) {
		trace_xfs_imeta_resv_init_error(ip, error, _RET_IP_);
		return error;
	}

	xfs_mod_delalloc(ip->i_mount, hidden_space);
	ip->i_delayed_blks = hidden_space;
	ip->i_meta_resv_asked = ask;

	trace_xfs_imeta_resv_init(ip, ask);
	return 0;
}