[linux-block.git] / fs / xfs / libxfs / xfs_rmap.h

// SPDX-License-Identifier: GPL-2.0+
/*
 * Copyright (C) 2016 Oracle.  All Rights Reserved.
 * Author: Darrick J. Wong <darrick.wong@oracle.com>
 */
#ifndef __XFS_RMAP_H__
#define __XFS_RMAP_H__

struct xfs_perag;
struct xfs_rtgroup;

static inline void
xfs_rmap_ino_bmbt_owner(
	struct xfs_owner_info	*oi,
	xfs_ino_t		ino,
	int			whichfork)
{
	oi->oi_owner = ino;
	oi->oi_offset = 0;
	oi->oi_flags = XFS_OWNER_INFO_BMBT_BLOCK;
	if (whichfork == XFS_ATTR_FORK)
		oi->oi_flags |= XFS_OWNER_INFO_ATTR_FORK;
}

static inline void
xfs_rmap_ino_owner(
	struct xfs_owner_info	*oi,
	xfs_ino_t		ino,
	int			whichfork,
	xfs_fileoff_t		offset)
{
	oi->oi_owner = ino;
	oi->oi_offset = offset;
	oi->oi_flags = 0;
	if (whichfork == XFS_ATTR_FORK)
		oi->oi_flags |= XFS_OWNER_INFO_ATTR_FORK;
}

static inline bool
xfs_rmap_should_skip_owner_update(
	const struct xfs_owner_info	*oi)
{
	return oi->oi_owner == XFS_RMAP_OWN_NULL;
}

/* Reverse mapping functions. */

struct xfs_buf;

static inline __u64
xfs_rmap_irec_offset_pack(
	const struct xfs_rmap_irec	*irec)
{
	__u64			x;

	x = XFS_RMAP_OFF(irec->rm_offset);
	if (irec->rm_flags & XFS_RMAP_ATTR_FORK)
		x |= XFS_RMAP_OFF_ATTR_FORK;
	if (irec->rm_flags & XFS_RMAP_BMBT_BLOCK)
		x |= XFS_RMAP_OFF_BMBT_BLOCK;
	if (irec->rm_flags & XFS_RMAP_UNWRITTEN)
		x |= XFS_RMAP_OFF_UNWRITTEN;
	return x;
}

static inline xfs_failaddr_t
xfs_rmap_irec_offset_unpack(
	__u64			offset,
	struct xfs_rmap_irec	*irec)
{
	if (offset & ~(XFS_RMAP_OFF_MASK | XFS_RMAP_OFF_FLAGS))
		return __this_address;

	irec->rm_offset = XFS_RMAP_OFF(offset);
	irec->rm_flags = 0;
	if (offset & XFS_RMAP_OFF_ATTR_FORK)
		irec->rm_flags |= XFS_RMAP_ATTR_FORK;
	if (offset & XFS_RMAP_OFF_BMBT_BLOCK)
		irec->rm_flags |= XFS_RMAP_BMBT_BLOCK;
	if (offset & XFS_RMAP_OFF_UNWRITTEN)
		irec->rm_flags |= XFS_RMAP_UNWRITTEN;
	return NULL;
}

static inline void
xfs_owner_info_unpack(
	const struct xfs_owner_info	*oinfo,
	uint64_t			*owner,
	uint64_t			*offset,
	unsigned int			*flags)
{
	unsigned int			r = 0;

	*owner = oinfo->oi_owner;
	*offset = oinfo->oi_offset;
	if (oinfo->oi_flags & XFS_OWNER_INFO_ATTR_FORK)
		r |= XFS_RMAP_ATTR_FORK;
	if (oinfo->oi_flags & XFS_OWNER_INFO_BMBT_BLOCK)
		r |= XFS_RMAP_BMBT_BLOCK;
	*flags = r;
}

static inline void
xfs_owner_info_pack(
	struct xfs_owner_info	*oinfo,
	uint64_t		owner,
	uint64_t		offset,
	unsigned int		flags)
{
	oinfo->oi_owner = owner;
	oinfo->oi_offset = XFS_RMAP_OFF(offset);
	oinfo->oi_flags = 0;
	if (flags & XFS_RMAP_ATTR_FORK)
		oinfo->oi_flags |= XFS_OWNER_INFO_ATTR_FORK;
	if (flags & XFS_RMAP_BMBT_BLOCK)
		oinfo->oi_flags |= XFS_OWNER_INFO_BMBT_BLOCK;
}

int xfs_rmap_alloc(struct xfs_trans *tp, struct xfs_buf *agbp,
		   struct xfs_perag *pag, xfs_agblock_t bno, xfs_extlen_t len,
		   const struct xfs_owner_info *oinfo);
int xfs_rmap_free(struct xfs_trans *tp, struct xfs_buf *agbp,
		  struct xfs_perag *pag, xfs_agblock_t bno, xfs_extlen_t len,
		  const struct xfs_owner_info *oinfo);

int xfs_rmap_lookup_le(struct xfs_btree_cur *cur, xfs_agblock_t bno,
		uint64_t owner, uint64_t offset, unsigned int flags,
		struct xfs_rmap_irec *irec, int *stat);
int xfs_rmap_lookup_eq(struct xfs_btree_cur *cur, xfs_agblock_t bno,
		xfs_extlen_t len, uint64_t owner, uint64_t offset,
		unsigned int flags, int *stat);
int xfs_rmap_insert(struct xfs_btree_cur *rcur, xfs_agblock_t agbno,
		xfs_extlen_t len, uint64_t owner, uint64_t offset,
		unsigned int flags);
int xfs_rmap_get_rec(struct xfs_btree_cur *cur, struct xfs_rmap_irec *irec,
		int *stat);

typedef int (*xfs_rmap_query_range_fn)(
	struct xfs_btree_cur		*cur,
	const struct xfs_rmap_irec	*rec,
	void				*priv);

int xfs_rmap_query_range(struct xfs_btree_cur *cur,
		const struct xfs_rmap_irec *low_rec,
		const struct xfs_rmap_irec *high_rec,
		xfs_rmap_query_range_fn fn, void *priv);
int xfs_rmap_query_all(struct xfs_btree_cur *cur, xfs_rmap_query_range_fn fn,
		void *priv);

enum xfs_rmap_intent_type {
	XFS_RMAP_MAP,
	XFS_RMAP_MAP_SHARED,
	XFS_RMAP_UNMAP,
	XFS_RMAP_UNMAP_SHARED,
	XFS_RMAP_CONVERT,
	XFS_RMAP_CONVERT_SHARED,
	XFS_RMAP_ALLOC,
	XFS_RMAP_FREE,
};

#define XFS_RMAP_INTENT_STRINGS \
	{ XFS_RMAP_MAP,			"map" }, \
	{ XFS_RMAP_MAP_SHARED,		"map_shared" }, \
	{ XFS_RMAP_UNMAP,		"unmap" }, \
	{ XFS_RMAP_UNMAP_SHARED,	"unmap_shared" }, \
	{ XFS_RMAP_CONVERT,		"cvt" }, \
	{ XFS_RMAP_CONVERT_SHARED,	"cvt_shared" }, \
	{ XFS_RMAP_ALLOC,		"alloc" }, \
	{ XFS_RMAP_FREE,		"free" }

struct xfs_rmap_intent {
	struct list_head			ri_list;
	enum xfs_rmap_intent_type		ri_type;
	int					ri_whichfork;
	uint64_t				ri_owner;
	struct xfs_bmbt_irec			ri_bmap;
	struct xfs_group			*ri_group;
	bool					ri_realtime;
};

/* functions for updating the rmapbt based on bmbt map/unmap operations */
void xfs_rmap_map_extent(struct xfs_trans *tp, struct xfs_inode *ip,
		int whichfork, struct xfs_bmbt_irec *imap);
void xfs_rmap_unmap_extent(struct xfs_trans *tp, struct xfs_inode *ip,
		int whichfork, struct xfs_bmbt_irec *imap);
void xfs_rmap_convert_extent(struct xfs_mount *mp, struct xfs_trans *tp,
		struct xfs_inode *ip, int whichfork,
		struct xfs_bmbt_irec *imap);
void xfs_rmap_alloc_extent(struct xfs_trans *tp, bool isrt, xfs_fsblock_t fsbno,
		xfs_extlen_t len, uint64_t owner);
void xfs_rmap_free_extent(struct xfs_trans *tp, bool isrt, xfs_fsblock_t fsbno,
		xfs_extlen_t len, uint64_t owner);

int xfs_rmap_finish_one(struct xfs_trans *tp, struct xfs_rmap_intent *ri,
		struct xfs_btree_cur **pcur);
int __xfs_rmap_finish_intent(struct xfs_btree_cur *rcur,
		enum xfs_rmap_intent_type op, xfs_agblock_t bno,
		xfs_extlen_t len, const struct xfs_owner_info *oinfo,
		bool unwritten);

int xfs_rmap_lookup_le_range(struct xfs_btree_cur *cur, xfs_agblock_t bno,
		uint64_t owner, uint64_t offset, unsigned int flags,
		struct xfs_rmap_irec *irec, int	*stat);
int xfs_rmap_compare(const struct xfs_rmap_irec *a,
		const struct xfs_rmap_irec *b);
union xfs_btree_rec;
xfs_failaddr_t xfs_rmap_btrec_to_irec(const union xfs_btree_rec *rec,
		struct xfs_rmap_irec *irec);
xfs_failaddr_t xfs_rmap_check_irec(struct xfs_perag *pag,
		const struct xfs_rmap_irec *irec);
xfs_failaddr_t xfs_rtrmap_check_irec(struct xfs_rtgroup *rtg,
		const struct xfs_rmap_irec *irec);

int xfs_rmap_has_records(struct xfs_btree_cur *cur, xfs_agblock_t bno,
		xfs_extlen_t len, enum xbtree_recpacking *outcome);

struct xfs_rmap_matches {
	/* Number of owner matches. */
	unsigned long long	matches;

	/* Number of non-owner matches. */
	unsigned long long	non_owner_matches;

	/* Number of non-owner matches that conflict with the owner matches. */
	unsigned long long	bad_non_owner_matches;
};

int xfs_rmap_count_owners(struct xfs_btree_cur *cur, xfs_agblock_t bno,
		xfs_extlen_t len, const struct xfs_owner_info *oinfo,
		struct xfs_rmap_matches *rmatch);
int xfs_rmap_has_other_keys(struct xfs_btree_cur *cur, xfs_agblock_t bno,
		xfs_extlen_t len, const struct xfs_owner_info *oinfo,
		bool *has_other);
int xfs_rmap_map_raw(struct xfs_btree_cur *cur, struct xfs_rmap_irec *rmap);

extern const struct xfs_owner_info XFS_RMAP_OINFO_SKIP_UPDATE;
extern const struct xfs_owner_info XFS_RMAP_OINFO_ANY_OWNER;
extern const struct xfs_owner_info XFS_RMAP_OINFO_FS;
extern const struct xfs_owner_info XFS_RMAP_OINFO_LOG;
extern const struct xfs_owner_info XFS_RMAP_OINFO_AG;
extern const struct xfs_owner_info XFS_RMAP_OINFO_INOBT;
extern const struct xfs_owner_info XFS_RMAP_OINFO_INODES;
extern const struct xfs_owner_info XFS_RMAP_OINFO_REFC;
extern const struct xfs_owner_info XFS_RMAP_OINFO_COW;

extern struct kmem_cache	*xfs_rmap_intent_cache;

int __init xfs_rmap_intent_init_cache(void);
void xfs_rmap_intent_destroy_cache(void);

/*
 * Parameters for tracking reverse mapping changes.  The hook function arg
 * parameter is enum xfs_rmap_intent_type, and the rest is below.
 */
struct xfs_rmap_update_params {
	xfs_agblock_t			startblock;
	xfs_extlen_t			blockcount;
	struct xfs_owner_info		oinfo;
	bool				unwritten;
};

#ifdef CONFIG_XFS_LIVE_HOOKS

struct xfs_rmap_hook {
	struct xfs_hook			rmap_hook;
};

void xfs_rmap_hook_disable(void);
void xfs_rmap_hook_enable(void);

int xfs_rmap_hook_add(struct xfs_group *xg, struct xfs_rmap_hook *hook);
void xfs_rmap_hook_del(struct xfs_group *xg, struct xfs_rmap_hook *hook);
void xfs_rmap_hook_setup(struct xfs_rmap_hook *hook, notifier_fn_t mod_fn);
#endif

#endif	/* __XFS_RMAP_H__ */
Commit	Line	Data
	1	// SPDX-License-Identifier: GPL-2.0+
	2	/*
	3	* Copyright (C) 2016 Oracle. All Rights Reserved.
	4	* Author: Darrick J. Wong <darrick.wong@oracle.com>
	5	*/
	6	#ifndef __XFS_RMAP_H__
	7	#define __XFS_RMAP_H__
	8
	9	struct xfs_perag;
	10	struct xfs_rtgroup;
	11
	12	static inline void
	13	xfs_rmap_ino_bmbt_owner(
	14	struct xfs_owner_info *oi,
	15	xfs_ino_t ino,
	16	int whichfork)
	17	{
	18	oi->oi_owner = ino;
	19	oi->oi_offset = 0;
	20	oi->oi_flags = XFS_OWNER_INFO_BMBT_BLOCK;
	21	if (whichfork == XFS_ATTR_FORK)
	22	oi->oi_flags \|= XFS_OWNER_INFO_ATTR_FORK;
	23	}
	24
	25	static inline void
	26	xfs_rmap_ino_owner(
	27	struct xfs_owner_info *oi,
	28	xfs_ino_t ino,
	29	int whichfork,
	30	xfs_fileoff_t offset)
	31	{
	32	oi->oi_owner = ino;
	33	oi->oi_offset = offset;
	34	oi->oi_flags = 0;
	35	if (whichfork == XFS_ATTR_FORK)
	36	oi->oi_flags \|= XFS_OWNER_INFO_ATTR_FORK;
	37	}
	38
	39	static inline bool
	40	xfs_rmap_should_skip_owner_update(
	41	const struct xfs_owner_info *oi)
	42	{
	43	return oi->oi_owner == XFS_RMAP_OWN_NULL;
	44	}
	45
	46	/* Reverse mapping functions. */
	47
	48	struct xfs_buf;
	49
	50	static inline __u64
	51	xfs_rmap_irec_offset_pack(
	52	const struct xfs_rmap_irec *irec)
	53	{
	54	__u64 x;
	55
	56	x = XFS_RMAP_OFF(irec->rm_offset);
	57	if (irec->rm_flags & XFS_RMAP_ATTR_FORK)
	58	x \|= XFS_RMAP_OFF_ATTR_FORK;
	59	if (irec->rm_flags & XFS_RMAP_BMBT_BLOCK)
	60	x \|= XFS_RMAP_OFF_BMBT_BLOCK;
	61	if (irec->rm_flags & XFS_RMAP_UNWRITTEN)
	62	x \|= XFS_RMAP_OFF_UNWRITTEN;
	63	return x;
	64	}
	65
	66	static inline xfs_failaddr_t
	67	xfs_rmap_irec_offset_unpack(
	68	__u64 offset,
	69	struct xfs_rmap_irec *irec)
	70	{
	71	if (offset & ~(XFS_RMAP_OFF_MASK \| XFS_RMAP_OFF_FLAGS))
	72	return __this_address;
	73
	74	irec->rm_offset = XFS_RMAP_OFF(offset);
	75	irec->rm_flags = 0;
	76	if (offset & XFS_RMAP_OFF_ATTR_FORK)
	77	irec->rm_flags \|= XFS_RMAP_ATTR_FORK;
	78	if (offset & XFS_RMAP_OFF_BMBT_BLOCK)
	79	irec->rm_flags \|= XFS_RMAP_BMBT_BLOCK;
	80	if (offset & XFS_RMAP_OFF_UNWRITTEN)
	81	irec->rm_flags \|= XFS_RMAP_UNWRITTEN;
	82	return NULL;
	83	}
	84
	85	static inline void
	86	xfs_owner_info_unpack(
	87	const struct xfs_owner_info *oinfo,
	88	uint64_t *owner,
	89	uint64_t *offset,
	90	unsigned int *flags)
	91	{
	92	unsigned int r = 0;
	93
	94	*owner = oinfo->oi_owner;
	95	*offset = oinfo->oi_offset;
	96	if (oinfo->oi_flags & XFS_OWNER_INFO_ATTR_FORK)
	97	r \|= XFS_RMAP_ATTR_FORK;
	98	if (oinfo->oi_flags & XFS_OWNER_INFO_BMBT_BLOCK)
	99	r \|= XFS_RMAP_BMBT_BLOCK;
	100	*flags = r;
	101	}
	102
	103	static inline void
	104	xfs_owner_info_pack(
	105	struct xfs_owner_info *oinfo,
	106	uint64_t owner,
	107	uint64_t offset,
	108	unsigned int flags)
	109	{
	110	oinfo->oi_owner = owner;
	111	oinfo->oi_offset = XFS_RMAP_OFF(offset);
	112	oinfo->oi_flags = 0;
	113	if (flags & XFS_RMAP_ATTR_FORK)
	114	oinfo->oi_flags \|= XFS_OWNER_INFO_ATTR_FORK;
	115	if (flags & XFS_RMAP_BMBT_BLOCK)
	116	oinfo->oi_flags \|= XFS_OWNER_INFO_BMBT_BLOCK;
	117	}
	118
	119	int xfs_rmap_alloc(struct xfs_trans tp, struct xfs_buf agbp,
	120	struct xfs_perag *pag, xfs_agblock_t bno, xfs_extlen_t len,
	121	const struct xfs_owner_info *oinfo);
	122	int xfs_rmap_free(struct xfs_trans tp, struct xfs_buf agbp,
	123	struct xfs_perag *pag, xfs_agblock_t bno, xfs_extlen_t len,
	124	const struct xfs_owner_info *oinfo);
	125
	126	int xfs_rmap_lookup_le(struct xfs_btree_cur *cur, xfs_agblock_t bno,
	127	uint64_t owner, uint64_t offset, unsigned int flags,
	128	struct xfs_rmap_irec irec, int stat);
	129	int xfs_rmap_lookup_eq(struct xfs_btree_cur *cur, xfs_agblock_t bno,
	130	xfs_extlen_t len, uint64_t owner, uint64_t offset,
	131	unsigned int flags, int *stat);
	132	int xfs_rmap_insert(struct xfs_btree_cur *rcur, xfs_agblock_t agbno,
	133	xfs_extlen_t len, uint64_t owner, uint64_t offset,
	134	unsigned int flags);
	135	int xfs_rmap_get_rec(struct xfs_btree_cur cur, struct xfs_rmap_irec irec,
	136	int *stat);
	137
	138	typedef int (*xfs_rmap_query_range_fn)(
	139	struct xfs_btree_cur *cur,
	140	const struct xfs_rmap_irec *rec,
	141	void *priv);
	142
	143	int xfs_rmap_query_range(struct xfs_btree_cur *cur,
	144	const struct xfs_rmap_irec *low_rec,
	145	const struct xfs_rmap_irec *high_rec,
	146	xfs_rmap_query_range_fn fn, void *priv);
	147	int xfs_rmap_query_all(struct xfs_btree_cur *cur, xfs_rmap_query_range_fn fn,
	148	void *priv);
	149
	150	enum xfs_rmap_intent_type {
	151	XFS_RMAP_MAP,
	152	XFS_RMAP_MAP_SHARED,
	153	XFS_RMAP_UNMAP,
	154	XFS_RMAP_UNMAP_SHARED,
	155	XFS_RMAP_CONVERT,
	156	XFS_RMAP_CONVERT_SHARED,
	157	XFS_RMAP_ALLOC,
	158	XFS_RMAP_FREE,
	159	};
	160
	161	#define XFS_RMAP_INTENT_STRINGS \
	162	{ XFS_RMAP_MAP, "map" }, \
	163	{ XFS_RMAP_MAP_SHARED, "map_shared" }, \
	164	{ XFS_RMAP_UNMAP, "unmap" }, \
	165	{ XFS_RMAP_UNMAP_SHARED, "unmap_shared" }, \
	166	{ XFS_RMAP_CONVERT, "cvt" }, \
	167	{ XFS_RMAP_CONVERT_SHARED, "cvt_shared" }, \
	168	{ XFS_RMAP_ALLOC, "alloc" }, \
	169	{ XFS_RMAP_FREE, "free" }
	170
	171	struct xfs_rmap_intent {
	172	struct list_head ri_list;
	173	enum xfs_rmap_intent_type ri_type;
	174	int ri_whichfork;
	175	uint64_t ri_owner;
	176	struct xfs_bmbt_irec ri_bmap;
	177	struct xfs_group *ri_group;
	178	bool ri_realtime;
	179	};
	180
	181	/* functions for updating the rmapbt based on bmbt map/unmap operations */
	182	void xfs_rmap_map_extent(struct xfs_trans tp, struct xfs_inode ip,
	183	int whichfork, struct xfs_bmbt_irec *imap);
	184	void xfs_rmap_unmap_extent(struct xfs_trans tp, struct xfs_inode ip,
	185	int whichfork, struct xfs_bmbt_irec *imap);
	186	void xfs_rmap_convert_extent(struct xfs_mount mp, struct xfs_trans tp,
	187	struct xfs_inode *ip, int whichfork,
	188	struct xfs_bmbt_irec *imap);
	189	void xfs_rmap_alloc_extent(struct xfs_trans *tp, bool isrt, xfs_fsblock_t fsbno,
	190	xfs_extlen_t len, uint64_t owner);
	191	void xfs_rmap_free_extent(struct xfs_trans *tp, bool isrt, xfs_fsblock_t fsbno,
	192	xfs_extlen_t len, uint64_t owner);
	193
	194	int xfs_rmap_finish_one(struct xfs_trans tp, struct xfs_rmap_intent ri,
	195	struct xfs_btree_cur **pcur);
	196	int __xfs_rmap_finish_intent(struct xfs_btree_cur *rcur,
	197	enum xfs_rmap_intent_type op, xfs_agblock_t bno,
	198	xfs_extlen_t len, const struct xfs_owner_info *oinfo,
	199	bool unwritten);
	200
	201	int xfs_rmap_lookup_le_range(struct xfs_btree_cur *cur, xfs_agblock_t bno,
	202	uint64_t owner, uint64_t offset, unsigned int flags,
	203	struct xfs_rmap_irec irec, int stat);
	204	int xfs_rmap_compare(const struct xfs_rmap_irec *a,
	205	const struct xfs_rmap_irec *b);
	206	union xfs_btree_rec;
	207	xfs_failaddr_t xfs_rmap_btrec_to_irec(const union xfs_btree_rec *rec,
	208	struct xfs_rmap_irec *irec);
	209	xfs_failaddr_t xfs_rmap_check_irec(struct xfs_perag *pag,
	210	const struct xfs_rmap_irec *irec);
	211	xfs_failaddr_t xfs_rtrmap_check_irec(struct xfs_rtgroup *rtg,
	212	const struct xfs_rmap_irec *irec);
	213
	214	int xfs_rmap_has_records(struct xfs_btree_cur *cur, xfs_agblock_t bno,
	215	xfs_extlen_t len, enum xbtree_recpacking *outcome);
	216
	217	struct xfs_rmap_matches {
	218	/* Number of owner matches. */
	219	unsigned long long matches;
	220
	221	/* Number of non-owner matches. */
	222	unsigned long long non_owner_matches;
	223
	224	/* Number of non-owner matches that conflict with the owner matches. */
	225	unsigned long long bad_non_owner_matches;
	226	};
	227
	228	int xfs_rmap_count_owners(struct xfs_btree_cur *cur, xfs_agblock_t bno,
	229	xfs_extlen_t len, const struct xfs_owner_info *oinfo,
	230	struct xfs_rmap_matches *rmatch);
	231	int xfs_rmap_has_other_keys(struct xfs_btree_cur *cur, xfs_agblock_t bno,
	232	xfs_extlen_t len, const struct xfs_owner_info *oinfo,
	233	bool *has_other);
	234	int xfs_rmap_map_raw(struct xfs_btree_cur cur, struct xfs_rmap_irec rmap);
	235
	236	extern const struct xfs_owner_info XFS_RMAP_OINFO_SKIP_UPDATE;
	237	extern const struct xfs_owner_info XFS_RMAP_OINFO_ANY_OWNER;
	238	extern const struct xfs_owner_info XFS_RMAP_OINFO_FS;
	239	extern const struct xfs_owner_info XFS_RMAP_OINFO_LOG;
	240	extern const struct xfs_owner_info XFS_RMAP_OINFO_AG;
	241	extern const struct xfs_owner_info XFS_RMAP_OINFO_INOBT;
	242	extern const struct xfs_owner_info XFS_RMAP_OINFO_INODES;
	243	extern const struct xfs_owner_info XFS_RMAP_OINFO_REFC;
	244	extern const struct xfs_owner_info XFS_RMAP_OINFO_COW;
	245
	246	extern struct kmem_cache *xfs_rmap_intent_cache;
	247
	248	int __init xfs_rmap_intent_init_cache(void);
	249	void xfs_rmap_intent_destroy_cache(void);
	250
	251	/*
	252	* Parameters for tracking reverse mapping changes. The hook function arg
	253	* parameter is enum xfs_rmap_intent_type, and the rest is below.
	254	*/
	255	struct xfs_rmap_update_params {
	256	xfs_agblock_t startblock;
	257	xfs_extlen_t blockcount;
	258	struct xfs_owner_info oinfo;
	259	bool unwritten;
	260	};
	261
	262	#ifdef CONFIG_XFS_LIVE_HOOKS
	263
	264	struct xfs_rmap_hook {
	265	struct xfs_hook rmap_hook;
	266	};
	267
	268	void xfs_rmap_hook_disable(void);
	269	void xfs_rmap_hook_enable(void);
	270
	271	int xfs_rmap_hook_add(struct xfs_group xg, struct xfs_rmap_hook hook);
	272	void xfs_rmap_hook_del(struct xfs_group xg, struct xfs_rmap_hook hook);
	273	void xfs_rmap_hook_setup(struct xfs_rmap_hook *hook, notifier_fn_t mod_fn);
	274	#endif
	275
	276	#endif /* __XFS_RMAP_H__ */