[linux-2.6-block.git] / fs / xfs / scrub / trace.h

/*
 * Copyright (C) 2017 Oracle.  All Rights Reserved.
 *
 * Author: Darrick J. Wong <darrick.wong@oracle.com>
 *
 * 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; either version 2
 * of the License, or (at your option) any later version.
 *
 * 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.
 */
#undef TRACE_SYSTEM
#define TRACE_SYSTEM xfs_scrub

#if !defined(_TRACE_XFS_SCRUB_TRACE_H) || defined(TRACE_HEADER_MULTI_READ)
#define _TRACE_XFS_SCRUB_TRACE_H

#include <linux/tracepoint.h>
#include "xfs_bit.h"

DECLARE_EVENT_CLASS(xfs_scrub_class,
	TP_PROTO(struct xfs_inode *ip, struct xfs_scrub_metadata *sm,
		 int error),
	TP_ARGS(ip, sm, error),
	TP_STRUCT__entry(
		__field(dev_t, dev)
		__field(xfs_ino_t, ino)
		__field(unsigned int, type)
		__field(xfs_agnumber_t, agno)
		__field(xfs_ino_t, inum)
		__field(unsigned int, gen)
		__field(unsigned int, flags)
		__field(int, error)
	),
	TP_fast_assign(
		__entry->dev = ip->i_mount->m_super->s_dev;
		__entry->ino = ip->i_ino;
		__entry->type = sm->sm_type;
		__entry->agno = sm->sm_agno;
		__entry->inum = sm->sm_ino;
		__entry->gen = sm->sm_gen;
		__entry->flags = sm->sm_flags;
		__entry->error = error;
	),
	TP_printk("dev %d:%d ino 0x%llx type %u agno %u inum %llu gen %u flags 0x%x error %d",
		  MAJOR(__entry->dev), MINOR(__entry->dev),
		  __entry->ino,
		  __entry->type,
		  __entry->agno,
		  __entry->inum,
		  __entry->gen,
		  __entry->flags,
		  __entry->error)
)
#define DEFINE_SCRUB_EVENT(name) \
DEFINE_EVENT(xfs_scrub_class, name, \
	TP_PROTO(struct xfs_inode *ip, struct xfs_scrub_metadata *sm, \
		 int error), \
	TP_ARGS(ip, sm, error))

DEFINE_SCRUB_EVENT(xfs_scrub_start);
DEFINE_SCRUB_EVENT(xfs_scrub_done);
DEFINE_SCRUB_EVENT(xfs_scrub_deadlock_retry);

TRACE_EVENT(xfs_scrub_op_error,
	TP_PROTO(struct xfs_scrub_context *sc, xfs_agnumber_t agno,
		 xfs_agblock_t bno, int error, void *ret_ip),
	TP_ARGS(sc, agno, bno, error, ret_ip),
	TP_STRUCT__entry(
		__field(dev_t, dev)
		__field(unsigned int, type)
		__field(xfs_agnumber_t, agno)
		__field(xfs_agblock_t, bno)
		__field(int, error)
		__field(void *, ret_ip)
	),
	TP_fast_assign(
		__entry->dev = sc->mp->m_super->s_dev;
		__entry->type = sc->sm->sm_type;
		__entry->agno = agno;
		__entry->bno = bno;
		__entry->error = error;
		__entry->ret_ip = ret_ip;
	),
	TP_printk("dev %d:%d type %u agno %u agbno %u error %d ret_ip %pS",
		  MAJOR(__entry->dev), MINOR(__entry->dev),
		  __entry->type,
		  __entry->agno,
		  __entry->bno,
		  __entry->error,
		  __entry->ret_ip)
);

TRACE_EVENT(xfs_scrub_file_op_error,
	TP_PROTO(struct xfs_scrub_context *sc, int whichfork,
		 xfs_fileoff_t offset, int error, void *ret_ip),
	TP_ARGS(sc, whichfork, offset, error, ret_ip),
	TP_STRUCT__entry(
		__field(dev_t, dev)
		__field(xfs_ino_t, ino)
		__field(int, whichfork)
		__field(unsigned int, type)
		__field(xfs_fileoff_t, offset)
		__field(int, error)
		__field(void *, ret_ip)
	),
	TP_fast_assign(
		__entry->dev = sc->ip->i_mount->m_super->s_dev;
		__entry->ino = sc->ip->i_ino;
		__entry->whichfork = whichfork;
		__entry->type = sc->sm->sm_type;
		__entry->offset = offset;
		__entry->error = error;
		__entry->ret_ip = ret_ip;
	),
	TP_printk("dev %d:%d ino 0x%llx fork %d type %u offset %llu error %d ret_ip %pS",
		  MAJOR(__entry->dev), MINOR(__entry->dev),
		  __entry->ino,
		  __entry->whichfork,
		  __entry->type,
		  __entry->offset,
		  __entry->error,
		  __entry->ret_ip)
);

DECLARE_EVENT_CLASS(xfs_scrub_block_error_class,
	TP_PROTO(struct xfs_scrub_context *sc, xfs_daddr_t daddr, void *ret_ip),
	TP_ARGS(sc, daddr, ret_ip),
	TP_STRUCT__entry(
		__field(dev_t, dev)
		__field(unsigned int, type)
		__field(xfs_agnumber_t, agno)
		__field(xfs_agblock_t, bno)
		__field(void *, ret_ip)
	),
	TP_fast_assign(
		xfs_fsblock_t	fsbno;
		xfs_agnumber_t	agno;
		xfs_agblock_t	bno;

		fsbno = XFS_DADDR_TO_FSB(sc->mp, daddr);
		agno = XFS_FSB_TO_AGNO(sc->mp, fsbno);
		bno = XFS_FSB_TO_AGBNO(sc->mp, fsbno);

		__entry->dev = sc->mp->m_super->s_dev;
		__entry->type = sc->sm->sm_type;
		__entry->agno = agno;
		__entry->bno = bno;
		__entry->ret_ip = ret_ip;
	),
	TP_printk("dev %d:%d type %u agno %u agbno %u ret_ip %pS",
		  MAJOR(__entry->dev), MINOR(__entry->dev),
		  __entry->type,
		  __entry->agno,
		  __entry->bno,
		  __entry->ret_ip)
)

#define DEFINE_SCRUB_BLOCK_ERROR_EVENT(name) \
DEFINE_EVENT(xfs_scrub_block_error_class, name, \
	TP_PROTO(struct xfs_scrub_context *sc, xfs_daddr_t daddr, \
		 void *ret_ip), \
	TP_ARGS(sc, daddr, ret_ip))

DEFINE_SCRUB_BLOCK_ERROR_EVENT(xfs_scrub_block_error);
DEFINE_SCRUB_BLOCK_ERROR_EVENT(xfs_scrub_block_preen);

DECLARE_EVENT_CLASS(xfs_scrub_ino_error_class,
	TP_PROTO(struct xfs_scrub_context *sc, xfs_ino_t ino, void *ret_ip),
	TP_ARGS(sc, ino, ret_ip),
	TP_STRUCT__entry(
		__field(dev_t, dev)
		__field(xfs_ino_t, ino)
		__field(unsigned int, type)
		__field(void *, ret_ip)
	),
	TP_fast_assign(
		__entry->dev = sc->mp->m_super->s_dev;
		__entry->ino = ino;
		__entry->type = sc->sm->sm_type;
		__entry->ret_ip = ret_ip;
	),
	TP_printk("dev %d:%d ino 0x%llx type %u ret_ip %pS",
		  MAJOR(__entry->dev), MINOR(__entry->dev),
		  __entry->ino,
		  __entry->type,
		  __entry->ret_ip)
)

#define DEFINE_SCRUB_INO_ERROR_EVENT(name) \
DEFINE_EVENT(xfs_scrub_ino_error_class, name, \
	TP_PROTO(struct xfs_scrub_context *sc, xfs_ino_t ino, \
		 void *ret_ip), \
	TP_ARGS(sc, ino, ret_ip))

DEFINE_SCRUB_INO_ERROR_EVENT(xfs_scrub_ino_error);
DEFINE_SCRUB_INO_ERROR_EVENT(xfs_scrub_ino_preen);
DEFINE_SCRUB_INO_ERROR_EVENT(xfs_scrub_ino_warning);

DECLARE_EVENT_CLASS(xfs_scrub_fblock_error_class,
	TP_PROTO(struct xfs_scrub_context *sc, int whichfork,
		 xfs_fileoff_t offset, void *ret_ip),
	TP_ARGS(sc, whichfork, offset, ret_ip),
	TP_STRUCT__entry(
		__field(dev_t, dev)
		__field(xfs_ino_t, ino)
		__field(int, whichfork)
		__field(unsigned int, type)
		__field(xfs_fileoff_t, offset)
		__field(void *, ret_ip)
	),
	TP_fast_assign(
		__entry->dev = sc->ip->i_mount->m_super->s_dev;
		__entry->ino = sc->ip->i_ino;
		__entry->whichfork = whichfork;
		__entry->type = sc->sm->sm_type;
		__entry->offset = offset;
		__entry->ret_ip = ret_ip;
	),
	TP_printk("dev %d:%d ino 0x%llx fork %d type %u offset %llu ret_ip %pS",
		  MAJOR(__entry->dev), MINOR(__entry->dev),
		  __entry->ino,
		  __entry->whichfork,
		  __entry->type,
		  __entry->offset,
		  __entry->ret_ip)
);

#define DEFINE_SCRUB_FBLOCK_ERROR_EVENT(name) \
DEFINE_EVENT(xfs_scrub_fblock_error_class, name, \
	TP_PROTO(struct xfs_scrub_context *sc, int whichfork, \
		 xfs_fileoff_t offset, void *ret_ip), \
	TP_ARGS(sc, whichfork, offset, ret_ip))

DEFINE_SCRUB_FBLOCK_ERROR_EVENT(xfs_scrub_fblock_error);
DEFINE_SCRUB_FBLOCK_ERROR_EVENT(xfs_scrub_fblock_warning);

TRACE_EVENT(xfs_scrub_incomplete,
	TP_PROTO(struct xfs_scrub_context *sc, void *ret_ip),
	TP_ARGS(sc, ret_ip),
	TP_STRUCT__entry(
		__field(dev_t, dev)
		__field(unsigned int, type)
		__field(void *, ret_ip)
	),
	TP_fast_assign(
		__entry->dev = sc->mp->m_super->s_dev;
		__entry->type = sc->sm->sm_type;
		__entry->ret_ip = ret_ip;
	),
	TP_printk("dev %d:%d type %u ret_ip %pS",
		  MAJOR(__entry->dev), MINOR(__entry->dev),
		  __entry->type,
		  __entry->ret_ip)
);

TRACE_EVENT(xfs_scrub_btree_op_error,
	TP_PROTO(struct xfs_scrub_context *sc, struct xfs_btree_cur *cur,
		 int level, int error, void *ret_ip),
	TP_ARGS(sc, cur, level, error, ret_ip),
	TP_STRUCT__entry(
		__field(dev_t, dev)
		__field(unsigned int, type)
		__field(xfs_btnum_t, btnum)
		__field(int, level)
		__field(xfs_agnumber_t, agno)
		__field(xfs_agblock_t, bno)
		__field(int, ptr);
		__field(int, error)
		__field(void *, ret_ip)
	),
	TP_fast_assign(
		xfs_fsblock_t fsbno = xfs_scrub_btree_cur_fsbno(cur, level);

		__entry->dev = sc->mp->m_super->s_dev;
		__entry->type = sc->sm->sm_type;
		__entry->btnum = cur->bc_btnum;
		__entry->level = level;
		__entry->agno = XFS_FSB_TO_AGNO(cur->bc_mp, fsbno);
		__entry->bno = XFS_FSB_TO_AGBNO(cur->bc_mp, fsbno);
		__entry->ptr = cur->bc_ptrs[level];
		__entry->error = error;
		__entry->ret_ip = ret_ip;
	),
	TP_printk("dev %d:%d type %u btnum %d level %d ptr %d agno %u agbno %u error %d ret_ip %pS",
		  MAJOR(__entry->dev), MINOR(__entry->dev),
		  __entry->type,
		  __entry->btnum,
		  __entry->level,
		  __entry->ptr,
		  __entry->agno,
		  __entry->bno,
		  __entry->error,
		  __entry->ret_ip)
);

TRACE_EVENT(xfs_scrub_ifork_btree_op_error,
	TP_PROTO(struct xfs_scrub_context *sc, struct xfs_btree_cur *cur,
		 int level, int error, void *ret_ip),
	TP_ARGS(sc, cur, level, error, ret_ip),
	TP_STRUCT__entry(
		__field(dev_t, dev)
		__field(xfs_ino_t, ino)
		__field(int, whichfork)
		__field(unsigned int, type)
		__field(xfs_btnum_t, btnum)
		__field(int, level)
		__field(int, ptr)
		__field(xfs_agnumber_t, agno)
		__field(xfs_agblock_t, bno)
		__field(int, error)
		__field(void *, ret_ip)
	),
	TP_fast_assign(
		xfs_fsblock_t fsbno = xfs_scrub_btree_cur_fsbno(cur, level);
		__entry->dev = sc->mp->m_super->s_dev;
		__entry->ino = sc->ip->i_ino;
		__entry->whichfork = cur->bc_private.b.whichfork;
		__entry->type = sc->sm->sm_type;
		__entry->btnum = cur->bc_btnum;
		__entry->level = level;
		__entry->ptr = cur->bc_ptrs[level];
		__entry->agno = XFS_FSB_TO_AGNO(cur->bc_mp, fsbno);
		__entry->bno = XFS_FSB_TO_AGBNO(cur->bc_mp, fsbno);
		__entry->error = error;
		__entry->ret_ip = ret_ip;
	),
	TP_printk("dev %d:%d ino 0x%llx fork %d type %u btnum %d level %d ptr %d agno %u agbno %u error %d ret_ip %pS",
		  MAJOR(__entry->dev), MINOR(__entry->dev),
		  __entry->ino,
		  __entry->whichfork,
		  __entry->type,
		  __entry->btnum,
		  __entry->level,
		  __entry->ptr,
		  __entry->agno,
		  __entry->bno,
		  __entry->error,
		  __entry->ret_ip)
);

TRACE_EVENT(xfs_scrub_btree_error,
	TP_PROTO(struct xfs_scrub_context *sc, struct xfs_btree_cur *cur,
		 int level, void *ret_ip),
	TP_ARGS(sc, cur, level, ret_ip),
	TP_STRUCT__entry(
		__field(dev_t, dev)
		__field(unsigned int, type)
		__field(xfs_btnum_t, btnum)
		__field(int, level)
		__field(xfs_agnumber_t, agno)
		__field(xfs_agblock_t, bno)
		__field(int, ptr);
		__field(void *, ret_ip)
	),
	TP_fast_assign(
		xfs_fsblock_t fsbno = xfs_scrub_btree_cur_fsbno(cur, level);
		__entry->dev = sc->mp->m_super->s_dev;
		__entry->type = sc->sm->sm_type;
		__entry->btnum = cur->bc_btnum;
		__entry->level = level;
		__entry->agno = XFS_FSB_TO_AGNO(cur->bc_mp, fsbno);
		__entry->bno = XFS_FSB_TO_AGBNO(cur->bc_mp, fsbno);
		__entry->ptr = cur->bc_ptrs[level];
		__entry->ret_ip = ret_ip;
	),
	TP_printk("dev %d:%d type %u btnum %d level %d ptr %d agno %u agbno %u ret_ip %pS",
		  MAJOR(__entry->dev), MINOR(__entry->dev),
		  __entry->type,
		  __entry->btnum,
		  __entry->level,
		  __entry->ptr,
		  __entry->agno,
		  __entry->bno,
		  __entry->ret_ip)
);

TRACE_EVENT(xfs_scrub_ifork_btree_error,
	TP_PROTO(struct xfs_scrub_context *sc, struct xfs_btree_cur *cur,
		 int level, void *ret_ip),
	TP_ARGS(sc, cur, level, ret_ip),
	TP_STRUCT__entry(
		__field(dev_t, dev)
		__field(xfs_ino_t, ino)
		__field(int, whichfork)
		__field(unsigned int, type)
		__field(xfs_btnum_t, btnum)
		__field(int, level)
		__field(xfs_agnumber_t, agno)
		__field(xfs_agblock_t, bno)
		__field(int, ptr);
		__field(void *, ret_ip)
	),
	TP_fast_assign(
		xfs_fsblock_t fsbno = xfs_scrub_btree_cur_fsbno(cur, level);
		__entry->dev = sc->mp->m_super->s_dev;
		__entry->ino = sc->ip->i_ino;
		__entry->whichfork = cur->bc_private.b.whichfork;
		__entry->type = sc->sm->sm_type;
		__entry->btnum = cur->bc_btnum;
		__entry->level = level;
		__entry->agno = XFS_FSB_TO_AGNO(cur->bc_mp, fsbno);
		__entry->bno = XFS_FSB_TO_AGBNO(cur->bc_mp, fsbno);
		__entry->ptr = cur->bc_ptrs[level];
		__entry->ret_ip = ret_ip;
	),
	TP_printk("dev %d:%d ino 0x%llx fork %d type %u btnum %d level %d ptr %d agno %u agbno %u ret_ip %pS",
		  MAJOR(__entry->dev), MINOR(__entry->dev),
		  __entry->ino,
		  __entry->whichfork,
		  __entry->type,
		  __entry->btnum,
		  __entry->level,
		  __entry->ptr,
		  __entry->agno,
		  __entry->bno,
		  __entry->ret_ip)
);

DECLARE_EVENT_CLASS(xfs_scrub_sbtree_class,
	TP_PROTO(struct xfs_scrub_context *sc, struct xfs_btree_cur *cur,
		 int level),
	TP_ARGS(sc, cur, level),
	TP_STRUCT__entry(
		__field(dev_t, dev)
		__field(int, type)
		__field(xfs_btnum_t, btnum)
		__field(xfs_agnumber_t, agno)
		__field(xfs_agblock_t, bno)
		__field(int, level)
		__field(int, nlevels)
		__field(int, ptr)
	),
	TP_fast_assign(
		xfs_fsblock_t fsbno = xfs_scrub_btree_cur_fsbno(cur, level);

		__entry->dev = sc->mp->m_super->s_dev;
		__entry->type = sc->sm->sm_type;
		__entry->btnum = cur->bc_btnum;
		__entry->agno = XFS_FSB_TO_AGNO(cur->bc_mp, fsbno);
		__entry->bno = XFS_FSB_TO_AGBNO(cur->bc_mp, fsbno);
		__entry->level = level;
		__entry->nlevels = cur->bc_nlevels;
		__entry->ptr = cur->bc_ptrs[level];
	),
	TP_printk("dev %d:%d type %u btnum %d agno %u agbno %u level %d nlevels %d ptr %d",
		  MAJOR(__entry->dev), MINOR(__entry->dev),
		  __entry->type,
		  __entry->btnum,
		  __entry->agno,
		  __entry->bno,
		  __entry->level,
		  __entry->nlevels,
		  __entry->ptr)
)
#define DEFINE_SCRUB_SBTREE_EVENT(name) \
DEFINE_EVENT(xfs_scrub_sbtree_class, name, \
	TP_PROTO(struct xfs_scrub_context *sc, struct xfs_btree_cur *cur, \
		 int level), \
	TP_ARGS(sc, cur, level))

DEFINE_SCRUB_SBTREE_EVENT(xfs_scrub_btree_rec);
DEFINE_SCRUB_SBTREE_EVENT(xfs_scrub_btree_key);

TRACE_EVENT(xfs_scrub_xref_error,
	TP_PROTO(struct xfs_scrub_context *sc, int error, void *ret_ip),
	TP_ARGS(sc, error, ret_ip),
	TP_STRUCT__entry(
		__field(dev_t, dev)
		__field(int, type)
		__field(int, error)
		__field(void *, ret_ip)
	),
	TP_fast_assign(
		__entry->dev = sc->mp->m_super->s_dev;
		__entry->type = sc->sm->sm_type;
		__entry->error = error;
		__entry->ret_ip = ret_ip;
	),
	TP_printk("dev %d:%d type %u xref error %d ret_ip %pF",
		  MAJOR(__entry->dev), MINOR(__entry->dev),
		  __entry->type,
		  __entry->error,
		  __entry->ret_ip)
);

#endif /* _TRACE_XFS_SCRUB_TRACE_H */

#undef TRACE_INCLUDE_PATH
#define TRACE_INCLUDE_PATH .
#define TRACE_INCLUDE_FILE scrub/trace
#include <trace/define_trace.h>
Commit	Line	Data
36fd6e86 DW	1	/*
	2	* Copyright (C) 2017 Oracle. All Rights Reserved.
	3	*
	4	* Author: Darrick J. Wong <darrick.wong@oracle.com>
	5	*
	6	* This program is free software; you can redistribute it and/or
	7	* modify it under the terms of the GNU General Public License
	8	* as published by the Free Software Foundation; either version 2
	9	* of the License, or (at your option) any later version.
	10	*
	11	* This program is distributed in the hope that it would be useful,
	12	* but WITHOUT ANY WARRANTY; without even the implied warranty of
	13	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	14	* GNU General Public License for more details.
	15	*
	16	* You should have received a copy of the GNU General Public License
	17	* along with this program; if not, write the Free Software Foundation,
	18	* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA.
	19	*/
	20	#undef TRACE_SYSTEM
	21	#define TRACE_SYSTEM xfs_scrub
	22
	23	#if !defined(_TRACE_XFS_SCRUB_TRACE_H) \|\| defined(TRACE_HEADER_MULTI_READ)
	24	#define _TRACE_XFS_SCRUB_TRACE_H
	25
	26	#include <linux/tracepoint.h>
4700d229	27	#include "xfs_bit.h"
36fd6e86	28
a5637186 DW	29	DECLARE_EVENT_CLASS(xfs_scrub_class,
	30	TP_PROTO(struct xfs_inode ip, struct xfs_scrub_metadata sm,
	31	int error),
	32	TP_ARGS(ip, sm, error),
	33	TP_STRUCT__entry(
	34	__field(dev_t, dev)
	35	__field(xfs_ino_t, ino)
	36	__field(unsigned int, type)
	37	__field(xfs_agnumber_t, agno)
	38	__field(xfs_ino_t, inum)
	39	__field(unsigned int, gen)
	40	__field(unsigned int, flags)
	41	__field(int, error)
	42	),
	43	TP_fast_assign(
	44	__entry->dev = ip->i_mount->m_super->s_dev;
	45	__entry->ino = ip->i_ino;
	46	__entry->type = sm->sm_type;
	47	__entry->agno = sm->sm_agno;
	48	__entry->inum = sm->sm_ino;
	49	__entry->gen = sm->sm_gen;
	50	__entry->flags = sm->sm_flags;
	51	__entry->error = error;
	52	),
67a3f6d0	53	TP_printk("dev %d:%d ino 0x%llx type %u agno %u inum %llu gen %u flags 0x%x error %d",
a5637186 DW	54	MAJOR(__entry->dev), MINOR(__entry->dev),
	55	__entry->ino,
	56	__entry->type,
	57	__entry->agno,
	58	__entry->inum,
	59	__entry->gen,
	60	__entry->flags,
	61	__entry->error)
	62	)
	63	#define DEFINE_SCRUB_EVENT(name) \
	64	DEFINE_EVENT(xfs_scrub_class, name, \
	65	TP_PROTO(struct xfs_inode ip, struct xfs_scrub_metadata sm, \
	66	int error), \
	67	TP_ARGS(ip, sm, error))
	68
	69	DEFINE_SCRUB_EVENT(xfs_scrub_start);
	70	DEFINE_SCRUB_EVENT(xfs_scrub_done);
4700d229 DW	71	DEFINE_SCRUB_EVENT(xfs_scrub_deadlock_retry);
	72
	73	TRACE_EVENT(xfs_scrub_op_error,
	74	TP_PROTO(struct xfs_scrub_context *sc, xfs_agnumber_t agno,
	75	xfs_agblock_t bno, int error, void *ret_ip),
	76	TP_ARGS(sc, agno, bno, error, ret_ip),
	77	TP_STRUCT__entry(
	78	__field(dev_t, dev)
	79	__field(unsigned int, type)
	80	__field(xfs_agnumber_t, agno)
	81	__field(xfs_agblock_t, bno)
	82	__field(int, error)
	83	__field(void *, ret_ip)
	84	),
	85	TP_fast_assign(
	86	__entry->dev = sc->mp->m_super->s_dev;
	87	__entry->type = sc->sm->sm_type;
	88	__entry->agno = agno;
	89	__entry->bno = bno;
	90	__entry->error = error;
	91	__entry->ret_ip = ret_ip;
	92	),
aff68a55	93	TP_printk("dev %d:%d type %u agno %u agbno %u error %d ret_ip %pS",
4700d229 DW	94	MAJOR(__entry->dev), MINOR(__entry->dev),
	95	__entry->type,
	96	__entry->agno,
	97	__entry->bno,
	98	__entry->error,
	99	__entry->ret_ip)
	100	);
	101
	102	TRACE_EVENT(xfs_scrub_file_op_error,
	103	TP_PROTO(struct xfs_scrub_context *sc, int whichfork,
	104	xfs_fileoff_t offset, int error, void *ret_ip),
	105	TP_ARGS(sc, whichfork, offset, error, ret_ip),
	106	TP_STRUCT__entry(
	107	__field(dev_t, dev)
	108	__field(xfs_ino_t, ino)
	109	__field(int, whichfork)
	110	__field(unsigned int, type)
	111	__field(xfs_fileoff_t, offset)
	112	__field(int, error)
	113	__field(void *, ret_ip)
	114	),
	115	TP_fast_assign(
	116	__entry->dev = sc->ip->i_mount->m_super->s_dev;
	117	__entry->ino = sc->ip->i_ino;
	118	__entry->whichfork = whichfork;
	119	__entry->type = sc->sm->sm_type;
	120	__entry->offset = offset;
	121	__entry->error = error;
	122	__entry->ret_ip = ret_ip;
	123	),
67a3f6d0	124	TP_printk("dev %d:%d ino 0x%llx fork %d type %u offset %llu error %d ret_ip %pS",
4700d229 DW	125	MAJOR(__entry->dev), MINOR(__entry->dev),
	126	__entry->ino,
	127	__entry->whichfork,
	128	__entry->type,
	129	__entry->offset,
	130	__entry->error,
	131	__entry->ret_ip)
	132	);
	133
	134	DECLARE_EVENT_CLASS(xfs_scrub_block_error_class,
	135	TP_PROTO(struct xfs_scrub_context sc, xfs_daddr_t daddr, void ret_ip),
	136	TP_ARGS(sc, daddr, ret_ip),
	137	TP_STRUCT__entry(
	138	__field(dev_t, dev)
	139	__field(unsigned int, type)
	140	__field(xfs_agnumber_t, agno)
	141	__field(xfs_agblock_t, bno)
	142	__field(void *, ret_ip)
	143	),
	144	TP_fast_assign(
	145	xfs_fsblock_t fsbno;
	146	xfs_agnumber_t agno;
	147	xfs_agblock_t bno;
	148
	149	fsbno = XFS_DADDR_TO_FSB(sc->mp, daddr);
	150	agno = XFS_FSB_TO_AGNO(sc->mp, fsbno);
	151	bno = XFS_FSB_TO_AGBNO(sc->mp, fsbno);
	152
	153	__entry->dev = sc->mp->m_super->s_dev;
	154	__entry->type = sc->sm->sm_type;
	155	__entry->agno = agno;
	156	__entry->bno = bno;
	157	__entry->ret_ip = ret_ip;
	158	),
aff68a55	159	TP_printk("dev %d:%d type %u agno %u agbno %u ret_ip %pS",
4700d229 DW	160	MAJOR(__entry->dev), MINOR(__entry->dev),
	161	__entry->type,
	162	__entry->agno,
	163	__entry->bno,
	164	__entry->ret_ip)
	165	)
	166
	167	#define DEFINE_SCRUB_BLOCK_ERROR_EVENT(name) \
	168	DEFINE_EVENT(xfs_scrub_block_error_class, name, \
	169	TP_PROTO(struct xfs_scrub_context *sc, xfs_daddr_t daddr, \
	170	void *ret_ip), \
	171	TP_ARGS(sc, daddr, ret_ip))
	172
	173	DEFINE_SCRUB_BLOCK_ERROR_EVENT(xfs_scrub_block_error);
	174	DEFINE_SCRUB_BLOCK_ERROR_EVENT(xfs_scrub_block_preen);
	175
	176	DECLARE_EVENT_CLASS(xfs_scrub_ino_error_class,
7e56d9ea DW	177	TP_PROTO(struct xfs_scrub_context sc, xfs_ino_t ino, void ret_ip),
7e56d9ea DW	178	TP_ARGS(sc, ino, ret_ip),
4700d229 DW	179	TP_STRUCT__entry(
	180	__field(dev_t, dev)
	181	__field(xfs_ino_t, ino)
	182	__field(unsigned int, type)
4700d229 DW	183	__field(void *, ret_ip)
	184	),
	185	TP_fast_assign(
4700d229 DW	186	__entry->dev = sc->mp->m_super->s_dev;
	187	__entry->ino = ino;
	188	__entry->type = sc->sm->sm_type;
4700d229 DW	189	__entry->ret_ip = ret_ip;
4700d229 DW	190	),
7e56d9ea	191	TP_printk("dev %d:%d ino 0x%llx type %u ret_ip %pS",
4700d229 DW	192	MAJOR(__entry->dev), MINOR(__entry->dev),
	193	__entry->ino,
	194	__entry->type,
4700d229 DW	195	__entry->ret_ip)
	196	)
	197
	198	#define DEFINE_SCRUB_INO_ERROR_EVENT(name) \
	199	DEFINE_EVENT(xfs_scrub_ino_error_class, name, \
	200	TP_PROTO(struct xfs_scrub_context *sc, xfs_ino_t ino, \
7e56d9ea DW	201	void *ret_ip), \
7e56d9ea DW	202	TP_ARGS(sc, ino, ret_ip))
4700d229 DW	203
	204	DEFINE_SCRUB_INO_ERROR_EVENT(xfs_scrub_ino_error);
	205	DEFINE_SCRUB_INO_ERROR_EVENT(xfs_scrub_ino_preen);
	206	DEFINE_SCRUB_INO_ERROR_EVENT(xfs_scrub_ino_warning);
	207
	208	DECLARE_EVENT_CLASS(xfs_scrub_fblock_error_class,
	209	TP_PROTO(struct xfs_scrub_context *sc, int whichfork,
	210	xfs_fileoff_t offset, void *ret_ip),
	211	TP_ARGS(sc, whichfork, offset, ret_ip),
	212	TP_STRUCT__entry(
	213	__field(dev_t, dev)
	214	__field(xfs_ino_t, ino)
	215	__field(int, whichfork)
	216	__field(unsigned int, type)
	217	__field(xfs_fileoff_t, offset)
	218	__field(void *, ret_ip)
	219	),
	220	TP_fast_assign(
	221	__entry->dev = sc->ip->i_mount->m_super->s_dev;
	222	__entry->ino = sc->ip->i_ino;
	223	__entry->whichfork = whichfork;
	224	__entry->type = sc->sm->sm_type;
	225	__entry->offset = offset;
	226	__entry->ret_ip = ret_ip;
	227	),
67a3f6d0	228	TP_printk("dev %d:%d ino 0x%llx fork %d type %u offset %llu ret_ip %pS",
4700d229 DW	229	MAJOR(__entry->dev), MINOR(__entry->dev),
	230	__entry->ino,
	231	__entry->whichfork,
	232	__entry->type,
	233	__entry->offset,
	234	__entry->ret_ip)
	235	);
	236
	237	#define DEFINE_SCRUB_FBLOCK_ERROR_EVENT(name) \
	238	DEFINE_EVENT(xfs_scrub_fblock_error_class, name, \
	239	TP_PROTO(struct xfs_scrub_context *sc, int whichfork, \
	240	xfs_fileoff_t offset, void *ret_ip), \
	241	TP_ARGS(sc, whichfork, offset, ret_ip))
	242
	243	DEFINE_SCRUB_FBLOCK_ERROR_EVENT(xfs_scrub_fblock_error);
	244	DEFINE_SCRUB_FBLOCK_ERROR_EVENT(xfs_scrub_fblock_warning);
	245
	246	TRACE_EVENT(xfs_scrub_incomplete,
	247	TP_PROTO(struct xfs_scrub_context sc, void ret_ip),
	248	TP_ARGS(sc, ret_ip),
	249	TP_STRUCT__entry(
	250	__field(dev_t, dev)
	251	__field(unsigned int, type)
	252	__field(void *, ret_ip)
	253	),
	254	TP_fast_assign(
	255	__entry->dev = sc->mp->m_super->s_dev;
	256	__entry->type = sc->sm->sm_type;
	257	__entry->ret_ip = ret_ip;
	258	),
aff68a55	259	TP_printk("dev %d:%d type %u ret_ip %pS",
4700d229 DW	260	MAJOR(__entry->dev), MINOR(__entry->dev),
	261	__entry->type,
	262	__entry->ret_ip)
	263	);
a5637186	264
537964bc DW	265	TRACE_EVENT(xfs_scrub_btree_op_error,
	266	TP_PROTO(struct xfs_scrub_context sc, struct xfs_btree_cur cur,
	267	int level, int error, void *ret_ip),
	268	TP_ARGS(sc, cur, level, error, ret_ip),
	269	TP_STRUCT__entry(
	270	__field(dev_t, dev)
	271	__field(unsigned int, type)
	272	__field(xfs_btnum_t, btnum)
	273	__field(int, level)
	274	__field(xfs_agnumber_t, agno)
	275	__field(xfs_agblock_t, bno)
	276	__field(int, ptr);
	277	__field(int, error)
	278	__field(void *, ret_ip)
	279	),
	280	TP_fast_assign(
	281	xfs_fsblock_t fsbno = xfs_scrub_btree_cur_fsbno(cur, level);
	282
	283	__entry->dev = sc->mp->m_super->s_dev;
	284	__entry->type = sc->sm->sm_type;
	285	__entry->btnum = cur->bc_btnum;
	286	__entry->level = level;
	287	__entry->agno = XFS_FSB_TO_AGNO(cur->bc_mp, fsbno);
	288	__entry->bno = XFS_FSB_TO_AGBNO(cur->bc_mp, fsbno);
	289	__entry->ptr = cur->bc_ptrs[level];
	290	__entry->error = error;
	291	__entry->ret_ip = ret_ip;
	292	),
aff68a55	293	TP_printk("dev %d:%d type %u btnum %d level %d ptr %d agno %u agbno %u error %d ret_ip %pS",
537964bc DW	294	MAJOR(__entry->dev), MINOR(__entry->dev),
	295	__entry->type,
	296	__entry->btnum,
	297	__entry->level,
	298	__entry->ptr,
	299	__entry->agno,
	300	__entry->bno,
	301	__entry->error,
	302	__entry->ret_ip)
	303	);
	304
	305	TRACE_EVENT(xfs_scrub_ifork_btree_op_error,
	306	TP_PROTO(struct xfs_scrub_context sc, struct xfs_btree_cur cur,
	307	int level, int error, void *ret_ip),
	308	TP_ARGS(sc, cur, level, error, ret_ip),
	309	TP_STRUCT__entry(
	310	__field(dev_t, dev)
	311	__field(xfs_ino_t, ino)
	312	__field(int, whichfork)
	313	__field(unsigned int, type)
	314	__field(xfs_btnum_t, btnum)
	315	__field(int, level)
	316	__field(int, ptr)
	317	__field(xfs_agnumber_t, agno)
	318	__field(xfs_agblock_t, bno)
	319	__field(int, error)
	320	__field(void *, ret_ip)
	321	),
	322	TP_fast_assign(
	323	xfs_fsblock_t fsbno = xfs_scrub_btree_cur_fsbno(cur, level);
	324	__entry->dev = sc->mp->m_super->s_dev;
	325	__entry->ino = sc->ip->i_ino;
	326	__entry->whichfork = cur->bc_private.b.whichfork;
	327	__entry->type = sc->sm->sm_type;
	328	__entry->btnum = cur->bc_btnum;
	329	__entry->level = level;
	330	__entry->ptr = cur->bc_ptrs[level];
	331	__entry->agno = XFS_FSB_TO_AGNO(cur->bc_mp, fsbno);
	332	__entry->bno = XFS_FSB_TO_AGBNO(cur->bc_mp, fsbno);
	333	__entry->error = error;
	334	__entry->ret_ip = ret_ip;
	335	),
67a3f6d0	336	TP_printk("dev %d:%d ino 0x%llx fork %d type %u btnum %d level %d ptr %d agno %u agbno %u error %d ret_ip %pS",
537964bc DW	337	MAJOR(__entry->dev), MINOR(__entry->dev),
	338	__entry->ino,
	339	__entry->whichfork,
	340	__entry->type,
	341	__entry->btnum,
	342	__entry->level,
	343	__entry->ptr,
	344	__entry->agno,
	345	__entry->bno,
	346	__entry->error,
	347	__entry->ret_ip)
	348	);
	349
	350	TRACE_EVENT(xfs_scrub_btree_error,
	351	TP_PROTO(struct xfs_scrub_context sc, struct xfs_btree_cur cur,
	352	int level, void *ret_ip),
	353	TP_ARGS(sc, cur, level, ret_ip),
	354	TP_STRUCT__entry(
	355	__field(dev_t, dev)
	356	__field(unsigned int, type)
	357	__field(xfs_btnum_t, btnum)
	358	__field(int, level)
	359	__field(xfs_agnumber_t, agno)
	360	__field(xfs_agblock_t, bno)
	361	__field(int, ptr);
	362	__field(void *, ret_ip)
	363	),
	364	TP_fast_assign(
	365	xfs_fsblock_t fsbno = xfs_scrub_btree_cur_fsbno(cur, level);
	366	__entry->dev = sc->mp->m_super->s_dev;
	367	__entry->type = sc->sm->sm_type;
	368	__entry->btnum = cur->bc_btnum;
	369	__entry->level = level;
	370	__entry->agno = XFS_FSB_TO_AGNO(cur->bc_mp, fsbno);
	371	__entry->bno = XFS_FSB_TO_AGBNO(cur->bc_mp, fsbno);
	372	__entry->ptr = cur->bc_ptrs[level];
	373	__entry->ret_ip = ret_ip;
	374	),
aff68a55	375	TP_printk("dev %d:%d type %u btnum %d level %d ptr %d agno %u agbno %u ret_ip %pS",
537964bc DW	376	MAJOR(__entry->dev), MINOR(__entry->dev),
	377	__entry->type,
	378	__entry->btnum,
	379	__entry->level,
	380	__entry->ptr,
	381	__entry->agno,
	382	__entry->bno,
	383	__entry->ret_ip)
	384	);
	385
	386	TRACE_EVENT(xfs_scrub_ifork_btree_error,
	387	TP_PROTO(struct xfs_scrub_context sc, struct xfs_btree_cur cur,
	388	int level, void *ret_ip),
	389	TP_ARGS(sc, cur, level, ret_ip),
	390	TP_STRUCT__entry(
	391	__field(dev_t, dev)
	392	__field(xfs_ino_t, ino)
	393	__field(int, whichfork)
	394	__field(unsigned int, type)
	395	__field(xfs_btnum_t, btnum)
	396	__field(int, level)
	397	__field(xfs_agnumber_t, agno)
	398	__field(xfs_agblock_t, bno)
	399	__field(int, ptr);
	400	__field(void *, ret_ip)
	401	),
	402	TP_fast_assign(
	403	xfs_fsblock_t fsbno = xfs_scrub_btree_cur_fsbno(cur, level);
	404	__entry->dev = sc->mp->m_super->s_dev;
	405	__entry->ino = sc->ip->i_ino;
	406	__entry->whichfork = cur->bc_private.b.whichfork;
	407	__entry->type = sc->sm->sm_type;
	408	__entry->btnum = cur->bc_btnum;
	409	__entry->level = level;
	410	__entry->agno = XFS_FSB_TO_AGNO(cur->bc_mp, fsbno);
	411	__entry->bno = XFS_FSB_TO_AGBNO(cur->bc_mp, fsbno);
	412	__entry->ptr = cur->bc_ptrs[level];
	413	__entry->ret_ip = ret_ip;
	414	),
67a3f6d0	415	TP_printk("dev %d:%d ino 0x%llx fork %d type %u btnum %d level %d ptr %d agno %u agbno %u ret_ip %pS",
537964bc DW	416	MAJOR(__entry->dev), MINOR(__entry->dev),
	417	__entry->ino,
	418	__entry->whichfork,
	419	__entry->type,
	420	__entry->btnum,
	421	__entry->level,
	422	__entry->ptr,
	423	__entry->agno,
	424	__entry->bno,
	425	__entry->ret_ip)
	426	);
	427
37f3fa7f DW	428	DECLARE_EVENT_CLASS(xfs_scrub_sbtree_class,
	429	TP_PROTO(struct xfs_scrub_context sc, struct xfs_btree_cur cur,
	430	int level),
	431	TP_ARGS(sc, cur, level),
	432	TP_STRUCT__entry(
	433	__field(dev_t, dev)
	434	__field(int, type)
	435	__field(xfs_btnum_t, btnum)
	436	__field(xfs_agnumber_t, agno)
	437	__field(xfs_agblock_t, bno)
	438	__field(int, level)
	439	__field(int, nlevels)
	440	__field(int, ptr)
	441	),
	442	TP_fast_assign(
	443	xfs_fsblock_t fsbno = xfs_scrub_btree_cur_fsbno(cur, level);
	444
	445	__entry->dev = sc->mp->m_super->s_dev;
	446	__entry->type = sc->sm->sm_type;
	447	__entry->btnum = cur->bc_btnum;
	448	__entry->agno = XFS_FSB_TO_AGNO(cur->bc_mp, fsbno);
	449	__entry->bno = XFS_FSB_TO_AGBNO(cur->bc_mp, fsbno);
	450	__entry->level = level;
	451	__entry->nlevels = cur->bc_nlevels;
	452	__entry->ptr = cur->bc_ptrs[level];
	453	),
	454	TP_printk("dev %d:%d type %u btnum %d agno %u agbno %u level %d nlevels %d ptr %d",
	455	MAJOR(__entry->dev), MINOR(__entry->dev),
	456	__entry->type,
	457	__entry->btnum,
	458	__entry->agno,
	459	__entry->bno,
	460	__entry->level,
	461	__entry->nlevels,
	462	__entry->ptr)
	463	)
	464	#define DEFINE_SCRUB_SBTREE_EVENT(name) \
	465	DEFINE_EVENT(xfs_scrub_sbtree_class, name, \
	466	TP_PROTO(struct xfs_scrub_context sc, struct xfs_btree_cur cur, \
	467	int level), \
	468	TP_ARGS(sc, cur, level))
	469
	470	DEFINE_SCRUB_SBTREE_EVENT(xfs_scrub_btree_rec);
	471	DEFINE_SCRUB_SBTREE_EVENT(xfs_scrub_btree_key);
	472
64b12563 DW	473	TRACE_EVENT(xfs_scrub_xref_error,
	474	TP_PROTO(struct xfs_scrub_context sc, int error, void ret_ip),
	475	TP_ARGS(sc, error, ret_ip),
	476	TP_STRUCT__entry(
	477	__field(dev_t, dev)
	478	__field(int, type)
	479	__field(int, error)
	480	__field(void *, ret_ip)
	481	),
	482	TP_fast_assign(
	483	__entry->dev = sc->mp->m_super->s_dev;
	484	__entry->type = sc->sm->sm_type;
	485	__entry->error = error;
	486	__entry->ret_ip = ret_ip;
	487	),
	488	TP_printk("dev %d:%d type %u xref error %d ret_ip %pF",
	489	MAJOR(__entry->dev), MINOR(__entry->dev),
	490	__entry->type,
	491	__entry->error,
	492	__entry->ret_ip)
	493	);
	494
36fd6e86 DW	495	#endif /* _TRACE_XFS_SCRUB_TRACE_H */
	496
	497	#undef TRACE_INCLUDE_PATH
	498	#define TRACE_INCLUDE_PATH .
	499	#define TRACE_INCLUDE_FILE scrub/trace
	500	#include <trace/define_trace.h>