[people/ms/linux.git] / fs / xfs / xfs_notify_failure.c

// SPDX-License-Identifier: GPL-2.0
/*
 * Copyright (c) 2022 Fujitsu.  All Rights Reserved.
 */

#include "xfs.h"
#include "xfs_shared.h"
#include "xfs_format.h"
#include "xfs_log_format.h"
#include "xfs_trans_resv.h"
#include "xfs_mount.h"
#include "xfs_alloc.h"
#include "xfs_bit.h"
#include "xfs_btree.h"
#include "xfs_inode.h"
#include "xfs_icache.h"
#include "xfs_rmap.h"
#include "xfs_rmap_btree.h"
#include "xfs_rtalloc.h"
#include "xfs_trans.h"
#include "xfs_ag.h"

#include <linux/mm.h>
#include <linux/dax.h>

struct failure_info {
	xfs_agblock_t		startblock;
	xfs_extlen_t		blockcount;
	int			mf_flags;
};

static pgoff_t
xfs_failure_pgoff(
	struct xfs_mount		*mp,
	const struct xfs_rmap_irec	*rec,
	const struct failure_info	*notify)
{
	loff_t				pos = XFS_FSB_TO_B(mp, rec->rm_offset);

	if (notify->startblock > rec->rm_startblock)
		pos += XFS_FSB_TO_B(mp,
				notify->startblock - rec->rm_startblock);
	return pos >> PAGE_SHIFT;
}

static unsigned long
xfs_failure_pgcnt(
	struct xfs_mount		*mp,
	const struct xfs_rmap_irec	*rec,
	const struct failure_info	*notify)
{
	xfs_agblock_t			end_rec;
	xfs_agblock_t			end_notify;
	xfs_agblock_t			start_cross;
	xfs_agblock_t			end_cross;

	start_cross = max(rec->rm_startblock, notify->startblock);

	end_rec = rec->rm_startblock + rec->rm_blockcount;
	end_notify = notify->startblock + notify->blockcount;
	end_cross = min(end_rec, end_notify);

	return XFS_FSB_TO_B(mp, end_cross - start_cross) >> PAGE_SHIFT;
}

static int
xfs_dax_failure_fn(
	struct xfs_btree_cur		*cur,
	const struct xfs_rmap_irec	*rec,
	void				*data)
{
	struct xfs_mount		*mp = cur->bc_mp;
	struct xfs_inode		*ip;
	struct failure_info		*notify = data;
	int				error = 0;

	if (XFS_RMAP_NON_INODE_OWNER(rec->rm_owner) ||
	    (rec->rm_flags & (XFS_RMAP_ATTR_FORK | XFS_RMAP_BMBT_BLOCK))) {
		xfs_force_shutdown(mp, SHUTDOWN_CORRUPT_ONDISK);
		return -EFSCORRUPTED;
	}

	/* Get files that incore, filter out others that are not in use. */
	error = xfs_iget(mp, cur->bc_tp, rec->rm_owner, XFS_IGET_INCORE,
			 0, &ip);
	/* Continue the rmap query if the inode isn't incore */
	if (error == -ENODATA)
		return 0;
	if (error)
		return error;

	error = mf_dax_kill_procs(VFS_I(ip)->i_mapping,
				  xfs_failure_pgoff(mp, rec, notify),
				  xfs_failure_pgcnt(mp, rec, notify),
				  notify->mf_flags);
	xfs_irele(ip);
	return error;
}

static int
xfs_dax_notify_ddev_failure(
	struct xfs_mount	*mp,
	xfs_daddr_t		daddr,
	xfs_daddr_t		bblen,
	int			mf_flags)
{
	struct xfs_trans	*tp = NULL;
	struct xfs_btree_cur	*cur = NULL;
	struct xfs_buf		*agf_bp = NULL;
	int			error = 0;
	xfs_fsblock_t		fsbno = XFS_DADDR_TO_FSB(mp, daddr);
	xfs_agnumber_t		agno = XFS_FSB_TO_AGNO(mp, fsbno);
	xfs_fsblock_t		end_fsbno = XFS_DADDR_TO_FSB(mp, daddr + bblen);
	xfs_agnumber_t		end_agno = XFS_FSB_TO_AGNO(mp, end_fsbno);

	error = xfs_trans_alloc_empty(mp, &tp);
	if (error)
		return error;

	for (; agno <= end_agno; agno++) {
		struct xfs_rmap_irec	ri_low = { };
		struct xfs_rmap_irec	ri_high;
		struct failure_info	notify;
		struct xfs_agf		*agf;
		xfs_agblock_t		agend;
		struct xfs_perag	*pag;

		pag = xfs_perag_get(mp, agno);
		error = xfs_alloc_read_agf(pag, tp, 0, &agf_bp);
		if (error) {
			xfs_perag_put(pag);
			break;
		}

		cur = xfs_rmapbt_init_cursor(mp, tp, agf_bp, pag);

		/*
		 * Set the rmap range from ri_low to ri_high, which represents
		 * a [start, end] where we looking for the files or metadata.
		 */
		memset(&ri_high, 0xFF, sizeof(ri_high));
		ri_low.rm_startblock = XFS_FSB_TO_AGBNO(mp, fsbno);
		if (agno == end_agno)
			ri_high.rm_startblock = XFS_FSB_TO_AGBNO(mp, end_fsbno);

		agf = agf_bp->b_addr;
		agend = min(be32_to_cpu(agf->agf_length),
				ri_high.rm_startblock);
		notify.startblock = ri_low.rm_startblock;
		notify.blockcount = agend - ri_low.rm_startblock;

		error = xfs_rmap_query_range(cur, &ri_low, &ri_high,
				xfs_dax_failure_fn, &notify);
		xfs_btree_del_cursor(cur, error);
		xfs_trans_brelse(tp, agf_bp);
		xfs_perag_put(pag);
		if (error)
			break;

		fsbno = XFS_AGB_TO_FSB(mp, agno + 1, 0);
	}

	xfs_trans_cancel(tp);
	return error;
}

static int
xfs_dax_notify_failure(
	struct dax_device	*dax_dev,
	u64			offset,
	u64			len,
	int			mf_flags)
{
	struct xfs_mount	*mp = dax_holder(dax_dev);
	u64			ddev_start;
	u64			ddev_end;

	if (!(mp->m_sb.sb_flags & SB_BORN)) {
		xfs_warn(mp, "filesystem is not ready for notify_failure()!");
		return -EIO;
	}

	if (mp->m_rtdev_targp && mp->m_rtdev_targp->bt_daxdev == dax_dev) {
		xfs_warn(mp,
			 "notify_failure() not supported on realtime device!");
		return -EOPNOTSUPP;
	}

	if (mp->m_logdev_targp && mp->m_logdev_targp->bt_daxdev == dax_dev &&
	    mp->m_logdev_targp != mp->m_ddev_targp) {
		xfs_err(mp, "ondisk log corrupt, shutting down fs!");
		xfs_force_shutdown(mp, SHUTDOWN_CORRUPT_ONDISK);
		return -EFSCORRUPTED;
	}

	if (!xfs_has_rmapbt(mp)) {
		xfs_warn(mp, "notify_failure() needs rmapbt enabled!");
		return -EOPNOTSUPP;
	}

	ddev_start = mp->m_ddev_targp->bt_dax_part_off;
	ddev_end = ddev_start + bdev_nr_bytes(mp->m_ddev_targp->bt_bdev) - 1;

	/* Ignore the range out of filesystem area */
	if (offset + len < ddev_start)
		return -ENXIO;
	if (offset > ddev_end)
		return -ENXIO;

	/* Calculate the real range when it touches the boundary */
	if (offset > ddev_start)
		offset -= ddev_start;
	else {
		len -= ddev_start - offset;
		offset = 0;
	}
	if (offset + len > ddev_end)
		len -= ddev_end - offset;

	return xfs_dax_notify_ddev_failure(mp, BTOBB(offset), BTOBB(len),
			mf_flags);
}

const struct dax_holder_operations xfs_dax_holder_operations = {
	.notify_failure		= xfs_dax_notify_failure,
};
Commit	Line	Data
6f643c57 SR	1	// SPDX-License-Identifier: GPL-2.0
	2	/*
	3	* Copyright (c) 2022 Fujitsu. All Rights Reserved.
	4	*/
	5
	6	#include "xfs.h"
	7	#include "xfs_shared.h"
	8	#include "xfs_format.h"
	9	#include "xfs_log_format.h"
	10	#include "xfs_trans_resv.h"
	11	#include "xfs_mount.h"
	12	#include "xfs_alloc.h"
	13	#include "xfs_bit.h"
	14	#include "xfs_btree.h"
	15	#include "xfs_inode.h"
	16	#include "xfs_icache.h"
	17	#include "xfs_rmap.h"
	18	#include "xfs_rmap_btree.h"
	19	#include "xfs_rtalloc.h"
	20	#include "xfs_trans.h"
6614a3c3	21	#include "xfs_ag.h"
6f643c57 SR	22
	23	#include <linux/mm.h>
	24	#include <linux/dax.h>
	25
	26	struct failure_info {
	27	xfs_agblock_t startblock;
	28	xfs_extlen_t blockcount;
	29	int mf_flags;
	30	};
	31
	32	static pgoff_t
	33	xfs_failure_pgoff(
	34	struct xfs_mount *mp,
	35	const struct xfs_rmap_irec *rec,
	36	const struct failure_info *notify)
	37	{
	38	loff_t pos = XFS_FSB_TO_B(mp, rec->rm_offset);
	39
	40	if (notify->startblock > rec->rm_startblock)
	41	pos += XFS_FSB_TO_B(mp,
	42	notify->startblock - rec->rm_startblock);
	43	return pos >> PAGE_SHIFT;
	44	}
	45
	46	static unsigned long
	47	xfs_failure_pgcnt(
	48	struct xfs_mount *mp,
	49	const struct xfs_rmap_irec *rec,
	50	const struct failure_info *notify)
	51	{
	52	xfs_agblock_t end_rec;
	53	xfs_agblock_t end_notify;
	54	xfs_agblock_t start_cross;
	55	xfs_agblock_t end_cross;
	56
	57	start_cross = max(rec->rm_startblock, notify->startblock);
	58
	59	end_rec = rec->rm_startblock + rec->rm_blockcount;
	60	end_notify = notify->startblock + notify->blockcount;
	61	end_cross = min(end_rec, end_notify);
	62
	63	return XFS_FSB_TO_B(mp, end_cross - start_cross) >> PAGE_SHIFT;
	64	}
	65
	66	static int
	67	xfs_dax_failure_fn(
	68	struct xfs_btree_cur *cur,
	69	const struct xfs_rmap_irec *rec,
	70	void *data)
	71	{
	72	struct xfs_mount *mp = cur->bc_mp;
	73	struct xfs_inode *ip;
	74	struct failure_info *notify = data;
	75	int error = 0;
	76
	77	if (XFS_RMAP_NON_INODE_OWNER(rec->rm_owner) \|\|
	78	(rec->rm_flags & (XFS_RMAP_ATTR_FORK \| XFS_RMAP_BMBT_BLOCK))) {
	79	xfs_force_shutdown(mp, SHUTDOWN_CORRUPT_ONDISK);
	80	return -EFSCORRUPTED;
	81	}
	82
	83	/* Get files that incore, filter out others that are not in use. */
	84	error = xfs_iget(mp, cur->bc_tp, rec->rm_owner, XFS_IGET_INCORE,
	85	0, &ip);
86	/* Continue the rmap query if the inode isn't incore */
87	if (error == -ENODATA)
88	return 0;
89	if (error)
90	return error;
91
92	error = mf_dax_kill_procs(VFS_I(ip)->i_mapping,
93	xfs_failure_pgoff(mp, rec, notify),
94	xfs_failure_pgcnt(mp, rec, notify),
95	notify->mf_flags);
96	xfs_irele(ip);
97	return error;
98	}
99
100	static int
101	xfs_dax_notify_ddev_failure(
102	struct xfs_mount *mp,
103	xfs_daddr_t daddr,
104	xfs_daddr_t bblen,
105	int mf_flags)
106	{
107	struct xfs_trans *tp = NULL;
108	struct xfs_btree_cur *cur = NULL;
109	struct xfs_buf *agf_bp = NULL;
110	int error = 0;
111	xfs_fsblock_t fsbno = XFS_DADDR_TO_FSB(mp, daddr);
112	xfs_agnumber_t agno = XFS_FSB_TO_AGNO(mp, fsbno);
113	xfs_fsblock_t end_fsbno = XFS_DADDR_TO_FSB(mp, daddr + bblen);
114	xfs_agnumber_t end_agno = XFS_FSB_TO_AGNO(mp, end_fsbno);
115
116	error = xfs_trans_alloc_empty(mp, &tp);
117	if (error)
118	return error;
119
120	for (; agno <= end_agno; agno++) {
121	struct xfs_rmap_irec ri_low = { };
122	struct xfs_rmap_irec ri_high;
123	struct failure_info notify;
124	struct xfs_agf *agf;
125	xfs_agblock_t agend;
6614a3c3	126	struct xfs_perag *pag;
6f643c57	127
6614a3c3 LT	128	pag = xfs_perag_get(mp, agno);
	129	error = xfs_alloc_read_agf(pag, tp, 0, &agf_bp);
	130	if (error) {
	131	xfs_perag_put(pag);
6f643c57	132	break;
6614a3c3	133	}
6f643c57	134
6614a3c3	135	cur = xfs_rmapbt_init_cursor(mp, tp, agf_bp, pag);
6f643c57 SR	136
	137	/*
	138	* Set the rmap range from ri_low to ri_high, which represents
	139	* a [start, end] where we looking for the files or metadata.
	140	*/
	141	memset(&ri_high, 0xFF, sizeof(ri_high));
	142	ri_low.rm_startblock = XFS_FSB_TO_AGBNO(mp, fsbno);
	143	if (agno == end_agno)
	144	ri_high.rm_startblock = XFS_FSB_TO_AGBNO(mp, end_fsbno);
	145
	146	agf = agf_bp->b_addr;
	147	agend = min(be32_to_cpu(agf->agf_length),
	148	ri_high.rm_startblock);
	149	notify.startblock = ri_low.rm_startblock;
	150	notify.blockcount = agend - ri_low.rm_startblock;
	151
	152	error = xfs_rmap_query_range(cur, &ri_low, &ri_high,
	153	xfs_dax_failure_fn, &notify);
	154	xfs_btree_del_cursor(cur, error);
	155	xfs_trans_brelse(tp, agf_bp);
6614a3c3	156	xfs_perag_put(pag);
6f643c57 SR	157	if (error)
	158	break;
	159
	160	fsbno = XFS_AGB_TO_FSB(mp, agno + 1, 0);
	161	}
	162
	163	xfs_trans_cancel(tp);
	164	return error;
	165	}
	166
	167	static int
	168	xfs_dax_notify_failure(
	169	struct dax_device *dax_dev,
	170	u64 offset,
	171	u64 len,
	172	int mf_flags)
	173	{
	174	struct xfs_mount *mp = dax_holder(dax_dev);
	175	u64 ddev_start;
	176	u64 ddev_end;
	177
	178	if (!(mp->m_sb.sb_flags & SB_BORN)) {
	179	xfs_warn(mp, "filesystem is not ready for notify_failure()!");
	180	return -EIO;
	181	}
	182
	183	if (mp->m_rtdev_targp && mp->m_rtdev_targp->bt_daxdev == dax_dev) {
	184	xfs_warn(mp,
	185	"notify_failure() not supported on realtime device!");
	186	return -EOPNOTSUPP;
	187	}
	188
	189	if (mp->m_logdev_targp && mp->m_logdev_targp->bt_daxdev == dax_dev &&
	190	mp->m_logdev_targp != mp->m_ddev_targp) {
	191	xfs_err(mp, "ondisk log corrupt, shutting down fs!");
	192	xfs_force_shutdown(mp, SHUTDOWN_CORRUPT_ONDISK);
	193	return -EFSCORRUPTED;
	194	}
	195
	196	if (!xfs_has_rmapbt(mp)) {
	197	xfs_warn(mp, "notify_failure() needs rmapbt enabled!");
	198	return -EOPNOTSUPP;
	199	}
	200
	201	ddev_start = mp->m_ddev_targp->bt_dax_part_off;
	202	ddev_end = ddev_start + bdev_nr_bytes(mp->m_ddev_targp->bt_bdev) - 1;
	203
	204	/* Ignore the range out of filesystem area */
	205	if (offset + len < ddev_start)
	206	return -ENXIO;
	207	if (offset > ddev_end)
	208	return -ENXIO;
	209
	210	/* Calculate the real range when it touches the boundary */
	211	if (offset > ddev_start)
	212	offset -= ddev_start;
	213	else {
	214	len -= ddev_start - offset;
	215	offset = 0;
	216	}
	217	if (offset + len > ddev_end)
	218	len -= ddev_end - offset;
	219
	220	return xfs_dax_notify_ddev_failure(mp, BTOBB(offset), BTOBB(len),
221	mf_flags);
222	}
223
224	const struct dax_holder_operations xfs_dax_holder_operations = {
225	.notify_failure = xfs_dax_notify_failure,
226	};