/* IBM_PROLOG_BEGIN_TAG                                                   */
/* This is an automatically generated prolog.                             */
/*                                                                        */
/* bos72Q src/bos/kernel/sys/ras_trace.h 1.29.2.1                         */
/*                                                                        */
/* Licensed Materials - Property of IBM                                   */
/*                                                                        */
/* Restricted Materials of IBM                                            */
/*                                                                        */
/* COPYRIGHT International Business Machines Corp. 2005,2019              */
/* All Rights Reserved                                                    */
/*                                                                        */
/* US Government Users Restricted Rights - Use, duplication or            */
/* disclosure restricted by GSA ADP Schedule Contract with IBM Corp.      */
/*                                                                        */
/* IBM_PROLOG_END_TAG                                                     */
/* @(#)71	1.29.2.1  src/bos/kernel/sys/ras_trace.h, systrace, bos72Q, q2019_13A4 2/6/19 00:42:24 */
#ifndef _H_RAS_TRACE
#define _H_RAS_TRACE

#include <sys/ras.h>

#include <sys/types.h>
#include <sys/trcmacros.h>

#ifdef __cplusplus
extern "C" {
#endif

#ifdef _KERNEL

/* Macros to retrieve rasr_block_t values.
 */

#define rasrb_trace_private(__rasb) \
	(((const rasr_block_t *)(__rasb))->rrb_trace_private)

#define rasrb_trace_memlevel(__rasb) \
	(((const rasr_block_t *)(__rasb))->rrb_trace_memlevel)

#define rasrb_trace_syslevel(__rasb) \
	(((const rasr_block_t *)(__rasb))->rrb_trace_syslevel)

#define rasrb_trace_level_summary(__rasb) \
	(((const rasr_block_t *)(__rasb))->rrb_trace_level_summary)

#define rasrb_trace_privlevel(__rasb) \
	(((const rasr_block_t *)(__rasb))->rrb_trace_privlevel)

#endif	/* _KERNEL */

/* Available levels of trace for both system and memory mode */
enum {
    CT_LEVEL_0,
    CT_LEVEL_1,
    CT_LEVEL_2,
    CT_LEVEL_3,
    CT_LEVEL_4,
    CT_LEVEL_5,
    CT_LEVEL_6,
    CT_LEVEL_7,
    CT_LEVEL_8,
    CT_LEVEL_9
};

#define CT_LVL_MINIMAL CT_LEVEL_1
#define CT_LVL_NORMAL  CT_LEVEL_3
#define CT_LVL_DETAIL  CT_LEVEL_7
#define CT_LVL_MAXIMAL CT_LEVEL_9

/* Default memtrc level. */
#define CT_LVL_DEFAULT CT_LVL_NORMAL

/* Default systrc level. */
#define CT_SYSTRC_LVL_DEFAULT CT_LVL_NORMAL

/* Flags */

/*
 * rst_flags values:
 */
#define CT_MEMTRC_SUSPEND     0x1   /* The memory trace mode is suspended */
#define CT_SYSTRC_ON          0x20  /* The system trace mode is on */
#define CT_MEMTRC_NOBUFFER    0x80000000 /* The component has no private buffer
				       	    allocated (used only by
					    rasp_trace_stat and ctctrl) */
#define CT_UNMANAGED          0x400 /* Memory trace buffer is unmanaged */
#define CT_UNMANAGED_BUFFER   0x800 /* Unmanaged trace buffer is allocated */

#ifdef _KERNSYS
/* These flags are internal only. */
#define CT_MEMTRC_TURNING_ON	0x2   /* Memory trace mode is being turned on */
#define CT_MEMTRC_TURNING_OFF	0x4   /* Memory trace mode is being turned off*/
#define CT_MEMTRC_SAVE		0x8   /* Private memory buffer is being saved */
#define CT_MEMTRC_RESIZE	0x10  /* Private memory buf is being resized*/
#define CT_SERIALIZED		0x40  /* Component Trace must serialize trace
					 entries */
#define CT_CUSTOMIZED		0x80  /* The component has been customized */
#define CT_MEMTRC_ALLOC		0x100 /* Private memory buf is being alloc'ed*/
#define CT_MEMTRC_RESUMING	0x200 /* SYNC state for resume in
					 rasp_trace_control() */
#define	RTE_TRACE_USERFLAGS (CT_MEMTRC_SUSPEND|CT_SYSTRC_ON|CT_UNMANAGED)

#endif /* _KERNSYS */

/* This structure must not be larger than ras_stat_domain_t. */
struct rstat_trace {
    unsigned long long rst_filltime; /* The estimated time to fill the buffer */
    short	rst_memlvl;	/* The level of trace for memory trace mode */
    short	rst_syslvl;	/* The level of trace for system trace mode */
    uint_t	rst_flags;	/* Trace flags */
    uint_t	rst_bufsize;	/* The current size of the memory buffer */

    int rstat_trace_reserved[27];
};
typedef struct rstat_trace rstat_trace_t;

/*
 * Error-checking-domain-specific information for persistent customizations.
 */
typedef struct rasp_ptrace_stat
{
    char	rst_flags;
    signed	rst_memtrc_on_off	: 2;
    signed	rst_systrc_on_off	: 2;
    unsigned	: 4;
    short	rst_length;	/* Length of structure for extensibility */
    uint_t	rst_bufsize;
    short	rst_mem_level;
    short	rst_sys_level;
} rpstat_trace_t;


/* Command basis */
enum {
	_CT_MEMTRC_ON = 1,
	_CT_MEMTRC_OFF,
	_CT_MEMTRC_SUSPEND,
	_CT_MEMTRC_RESUME,
	_CT_SYSTRC_ON,
	_CT_SYSTRC_OFF,
	_CT_MEMTRC_LVL,
	_CT_SYSTRC_LVL,
	_CT_MEMBUFSIZE,
	_CT_DR_MEM,
	_CT_PASS_THROUGH,
	_CT_SERIALIZED,
	_CT_GETBUFFER,
	_CT_ALLOC_BUFFER,
	_CT_FREE_BUFFER,
	_CT_MEMTRC_DISABLE,
	_CT_MEMTRC_ENABLE,
	_CT_BUFXDBYTETRC_LVL,
	_CT_UNMANAGED,
	_CT_GET_UNMANAGED_BUF,
	_CT_GET_UNMANAGED_BUF_END,
	/* 4094 reserved for internal use */
	CT_NOCMD = 4095
};

/* Callback commands */
#define RASCT_MEMTRC_ON		RASC_COMMAND(RASD_TRACE, _CT_MEMTRC_ON)
#define RASCT_MEMTRC_OFF	RASC_COMMAND(RASD_TRACE, _CT_MEMTRC_OFF)
#define RASCT_MEMTRC_SUSPEND	RASC_COMMAND(RASD_TRACE, _CT_MEMTRC_SUSPEND)
#define RASCT_MEMTRC_RESUME	RASC_COMMAND(RASD_TRACE, _CT_MEMTRC_RESUME)
#define RASCT_SYSTRC_ON		RASC_COMMAND(RASD_TRACE, _CT_SYSTRC_ON)
#define RASCT_SYSTRC_OFF	RASC_COMMAND(RASD_TRACE, _CT_SYSTRC_OFF)
#define RASCT_MEMTRC_LVL	RASC_COMMAND(RASD_TRACE, _CT_MEMTRC_LVL)
#define RASCT_SYSTRC_LVL	RASC_COMMAND(RASD_TRACE, _CT_SYSTRC_LVL)
#define RASCT_MEMBUFSIZE	RASC_COMMAND(RASD_TRACE, _CT_MEMBUFSIZE)
#define RASCT_DR_MEM		RASC_COMMAND(RASD_TRACE, _CT_DR_MEM)
#define RASCT_PASS_THROUGH	RASC_COMMAND(RASD_TRACE, _CT_PASS_THROUGH)
#define RASCT_BUFXDBYTETRC_LVL	RASC_COMMAND(RASD_TRACE, _CT_BUFXDBYTETRC_LVL)

/* Special commands to (1) use buffer for multiple RAS attributes;
 * (2) delete persistent attribute customizations;
 * (3) query persistent customizations.
 */
#define RASCT_MULTI  (RASC_COMMAND(RASD_TRACE, CT_NOCMD)| RAS_BUFFER)
#define RASCT_DELETE (RASC_COMMAND(RASD_TRACE, CT_NOCMD)| RAS_DELETE)
#define RASCT_QUERY  (RASC_COMMAND(RASD_TRACE, CT_NOCMD)| RAS_QUERY)

/*
 * Global commands for krascntl().
 */
#define RASCT_MEMTRC_DISABLE       RASC_COMMAND(RASD_TRACE, _CT_MEMTRC_DISABLE)
#define RASCT_MEMTRC_ENABLE        RASC_COMMAND(RASD_TRACE, _CT_MEMTRC_ENABLE)

/* This command is a private command and must not be called from the component*/
#define RASCT_GETBUFFER	       		\
		RASC_COMMAND(RASD_TRACE, _CT_GETBUFFER|NOCALLBACK)

#ifdef _KERNEL

#define RASCT_SET_MEMTRC_SUSPEND	\
		RASC_COMMAND(RASD_TRACE, _CT_MEMTRC_SUSPEND | NOCALLBACK)
#define RASCT_SET_MEMTRC_RESUME		\
		RASC_COMMAND(RASD_TRACE, _CT_MEMTRC_RESUME  | NOCALLBACK)
#define RASCT_SET_SYSTRC_ON     	\
		RASC_COMMAND(RASD_TRACE, _CT_SYSTRC_ON |NOCALLBACK)
#define RASCT_SET_SYSTRC_OFF    	\
		RASC_COMMAND(RASD_TRACE, _CT_SYSTRC_OFF|NOCALLBACK)
#define RASCT_SET_MEMTRC_LVL    	\
		RASC_COMMAND(RASD_TRACE, _CT_MEMTRC_LVL|NOCALLBACK)
#define RASCT_SET_SYSTRC_LVL    	\
		RASC_COMMAND(RASD_TRACE, _CT_SYSTRC_LVL|NOCALLBACK)
#define RASCT_SET_MEMBUFSIZE    	\
		RASC_COMMAND(RASD_TRACE, _CT_MEMBUFSIZE|NOCALLBACK)
#define RASCT_SET_CT_SERIALIZED 	\
		RASC_COMMAND(RASD_TRACE, _CT_SERIALIZED|NOCALLBACK)
#define RASCT_SET_ALLOC_BUFFER 		\
		RASC_COMMAND(RASD_TRACE, _CT_ALLOC_BUFFER|NOCALLBACK)
#define RASCT_SET_FREE_BUFFER  		\
		RASC_COMMAND(RASD_TRACE, _CT_FREE_BUFFER |NOCALLBACK)
#define RASCT_SET_UNMANAGED		\
		RASC_COMMAND(RASD_TRACE, _CT_UNMANAGED|NOCALLBACK)
#define RASCT_GET_UNMANAGED_BUF		\
		RASC_COMMAND(RASD_TRACE, _CT_GET_UNMANAGED_BUF|NOCALLBACK)
#define RASCT_GET_UNMANAGED_BUF_END	\
		RASC_COMMAND(RASD_TRACE, _CT_GET_UNMANAGED_BUF_END|NOCALLBACK)

RAS_COMMAND_CHECK(RASCT_MEMTRC_ON,		0x5200000000000101ull);
RAS_COMMAND_CHECK(RASCT_MEMTRC_OFF,		0x5200000000000201ull);
RAS_COMMAND_CHECK(RASCT_MEMTRC_SUSPEND,		0x5200000000000301ull);
RAS_COMMAND_CHECK(RASCT_MEMTRC_RESUME,		0x5200000000000401ull);
RAS_COMMAND_CHECK(RASCT_SYSTRC_ON,		0x5200000000000501ull);
RAS_COMMAND_CHECK(RASCT_SYSTRC_OFF,		0x5200000000000601ull);
RAS_COMMAND_CHECK(RASCT_MEMTRC_LVL,		0x5200000000000701ull);
RAS_COMMAND_CHECK(RASCT_SYSTRC_LVL,		0x5200000000000801ull);
RAS_COMMAND_CHECK(RASCT_MEMBUFSIZE,		0x5200000000000901ull);
RAS_COMMAND_CHECK(RASCT_DR_MEM,			0x5200000000000A01ull);
RAS_COMMAND_CHECK(RASCT_PASS_THROUGH,		0x5200000000000B01ull);

RAS_COMMAND_CHECK(RASCT_MEMTRC_DISABLE,		0x5200000000001001ull);
RAS_COMMAND_CHECK(RASCT_MEMTRC_ENABLE,		0x5200000000001101ull);

RAS_COMMAND_CHECK(RASCT_BUFXDBYTETRC_LVL,	0x5200000000001201ull);

RAS_COMMAND_CHECK(RASCT_SET_MEMTRC_SUSPEND,	0x5200000001000301ull);
RAS_COMMAND_CHECK(RASCT_SET_MEMTRC_RESUME,	0x5200000001000401ull);
RAS_COMMAND_CHECK(RASCT_SET_SYSTRC_ON,		0x5200000001000501ull);
RAS_COMMAND_CHECK(RASCT_SET_SYSTRC_OFF,		0x5200000001000601ull);
RAS_COMMAND_CHECK(RASCT_SET_MEMTRC_LVL,		0x5200000001000701ull);
RAS_COMMAND_CHECK(RASCT_SET_SYSTRC_LVL,		0x5200000001000801ull);
RAS_COMMAND_CHECK(RASCT_SET_MEMBUFSIZE,		0x5200000001000901ull);
RAS_COMMAND_CHECK(RASCT_SET_CT_SERIALIZED,	0x5200000001000C01ull);

RAS_COMMAND_CHECK(RASCT_GETBUFFER,		0x5200000001000D01ull);
RAS_COMMAND_CHECK(RASCT_SET_ALLOC_BUFFER,	0x5200000001000E01ull);
RAS_COMMAND_CHECK(RASCT_SET_FREE_BUFFER,	0x5200000001000F01ull);
RAS_COMMAND_CHECK(RASCT_SET_UNMANAGED,		0x5200000001001301ull);
RAS_COMMAND_CHECK(RASCT_GET_UNMANAGED_BUF,	0x5200000001001401ull);
RAS_COMMAND_CHECK(RASCT_GET_UNMANAGED_BUF_END,	0x5200000001001501ull);

/* Memory destination flags */
/* The trace is stored in the rare buffer of Lightweight Memory Trace */
#define MT_RARE    0x1
/* The trace is stored in the common buffer of Lightweight Memory Trace */
#define MT_COMMON  0x2
/* The trace is stored in private buffer of the component */
#define MT_PRIV    0x4
/* The trace may be stored in the system trace */
#define MT_SYSTEM  0x8

/*
 * structure argument used for RASCT_SET_UNMANAGED command.
 */
struct ras_unmanaged {
	unsigned long u_eyec;	/* unique eye catcher for this structure */
#define EYEC_CT_UNMANAGED __EYEC8('r','a','s','u','n','b','u','f')/* rasunbuf */
	unsigned long u_ctype;	/* trace entry conversion routine type */
#define CT_ADJUNCT_CTYPE_1 0x1	/* rasp_copyout_adjunct_buffer routine */
	unsigned long reserved1; /* reserved for future use */
	unsigned long reserved2; /* reserved for future use */
};
typedef struct ras_unmanaged ras_unmanaged_t;

/*
 * structure argument used for RASCT_GET_UNMANAGED_BUF command.
 */
struct ras_ct_ubuf {
	unsigned long gub_eyec;	/* eye catcher for this structure */
#define EYEC_CT_GET_UBUF __EYEC8('r','a','s','g','u','b','u','f') /* rasgubuf */
	void *gub_buf;		/* pointer to the trace buffer */
	unsigned long gub_len;	/* size of trace buffer in bytes */
	void *gub_inptr;	/* pointer to last entry logged */
	unsigned long gub_reserved1; /* reserved for future use */
	unsigned long gub_reserved2; /* reserved for future use */
};
typedef struct ras_ct_ubuf ras_ct_ubuf_t;

/* non-generic trace function prototypes */
void ct_hook0(ras_block_t cb, ulong_t hkwd);
void ct_hook1(ras_block_t cb, ulong_t hkwd, ulong_t d1);
void ct_hook2(ras_block_t cb, ulong_t hkwd, ulong_t d1, ulong_t d2);
void ct_hook3(ras_block_t cb, ulong_t hkwd, ulong_t d1, ulong_t d2, ulong_t d3);
void ct_hook4(ras_block_t cb, ulong_t hkwd, ulong_t d1, ulong_t d2, ulong_t d3,
	      ulong_t d4);
void ct_hook5(ras_block_t cb, ulong_t hkwd, ulong_t d1, ulong_t d2, ulong_t d3,
	      ulong_t d4, ulong_t d5);

void ctcs_hook0(ras_block_t cb, ulong_t hkwd);
void ctcs_hook1(ras_block_t cb, ulong_t hkwd, ulong_t d1);
void ctcs_hook2(ras_block_t cb, ulong_t hkwd, ulong_t d1, ulong_t d2);
void ctcs_hook3(ras_block_t cb, ulong_t hkwd, ulong_t d1, ulong_t d2,
		ulong_t d3);
void ctcs_hook4(ras_block_t cb, ulong_t hkwd, ulong_t d1, ulong_t d2,
		ulong_t d3, ulong_t d4);
void ctcs_hook5(ras_block_t cb, ulong_t hkwd, ulong_t d1, ulong_t d2,
		ulong_t d3, ulong_t d4, ulong_t d5);

#if __IBMC__
#pragma isolated_call(ct_hook0)
#pragma isolated_call(ct_hook1)
#pragma isolated_call(ct_hook2)
#pragma isolated_call(ct_hook3)
#pragma isolated_call(ct_hook4)
#pragma isolated_call(ct_hook5)
#pragma isolated_call(ctcs_hook0)
#pragma isolated_call(ctcs_hook1)
#pragma isolated_call(ctcs_hook2)
#pragma isolated_call(ctcs_hook3)
#pragma isolated_call(ctcs_hook4)
#pragma isolated_call(ctcs_hook5)
#endif

/* ctfunc_hookx trace function prototypes */
void ctfunc_hook0(ras_block_t cb, ulong hwlvldest);
void ctfunc_hook1(ras_block_t cb, ulong hwlvldest, ulong d1);
void ctfunc_hook2(ras_block_t cb, ulong hwlvldest, ulong d1, ulong d2);
void ctfunc_hook3(ras_block_t cb, ulong hwlvldest, ulong d1, ulong d2,
	ulong d3);
void ctfunc_hook4(ras_block_t cb, ulong hwlvldest, ulong d1, ulong d2,
	ulong d3, ulong d4);
void ctfunc_hook5(ras_block_t cb, ulong hwlvldest, ulong d1, ulong d2,
	ulong d3, ulong d4, ulong d5);

#if __IBMC__
#pragma isolated_call(ctfunc_hook0)
#pragma isolated_call(ctfunc_hook1)
#pragma isolated_call(ctfunc_hook2)
#pragma isolated_call(ctfunc_hook3)
#pragma isolated_call(ctfunc_hook4)
#pragma isolated_call(ctfunc_hook5)
#endif

/* trace a generic entry */
void rasp_trcgen(
	ras_block_t cb,
	ulong_t hkwd,
	ulong_t d1,
	uint len,
	char *buf);

/* CT_HOOKx - CT_GEN macros */

#define CT_HOOK0(cb, level, mem_dest, hw)				\
    do {								\
	if (((mem_dest) & MT_RARE) && ((short)(level)			\
					<= rasrb_trace_memlevel((cb))))	\
	   mtrchook0(HKWD64_EXPAND((hw),0) | HKWD64_TMASK, MTRC_RARE);	\
									\
	if (((mem_dest) & MT_COMMON)					\
	    && ((short)(level) <= rasrb_trace_memlevel((cb))))		\
	   mtrchook0(HKWD64_EXPAND((hw),0) | HKWD64_TMASK, MTRC_COMMON);\
									\
	if (((mem_dest) & MT_PRIV) && ((short)(level)			\
					<= rasrb_trace_privlevel((cb))))\
	   ct_hook0((cb), HKWD64_EXPAND((hw),0)|HKWD64_TMASK);		\
									\
	if (((mem_dest) & MT_SYSTEM)					\
	    && ((short)(level) <= rasrb_trace_syslevel((cb)))) {	\
	    __INFREQUENT;						\
	    __TRCHOOK(HKWD64_EXPAND((hw),0) | HKWD64_TMASK);		\
	}								\
     } while (0)

#define CT_HOOK1(cb, level, mem_dest, hw, d1)				\
    do {								\
	if (((mem_dest) & MT_RARE) && ((short)(level)			\
					<= rasrb_trace_memlevel((cb))))	\
	   mtrchook1(HKWD64_EXPAND((hw),8) | HKWD64_TMASK, (ulong_t) (d1),\
			MTRC_RARE);					\
									\
	if (((mem_dest) & MT_COMMON)					\
	    && ((short)(level) <= rasrb_trace_memlevel((cb))))		\
	   mtrchook1(HKWD64_EXPAND((hw),8) | HKWD64_TMASK, (ulong_t) (d1),\
			MTRC_COMMON);					\
									\
	if (((mem_dest) & MT_PRIV) && ((short)(level)			\
					<= rasrb_trace_privlevel((cb))))\
	   ct_hook1((cb), HKWD64_EXPAND((hw),8)|HKWD64_TMASK,		\
		       (ulong_t) (d1));					\
									\
	if (((mem_dest) & MT_SYSTEM)					\
	    && ((short)(level) <= rasrb_trace_syslevel((cb)))) {	\
	    __INFREQUENT;						\
	    __TRCHOOK(HKWD64_EXPAND((hw),8) | HKWD64_TMASK,		\
			(ulong_t) (d1));				\
	}								\
     } while (0)

#define CT_HOOK2(cb, level, mem_dest, hw, d1, d2)			\
  do {									\
	if (((mem_dest) & MT_RARE) && ((short)(level)			\
					<= rasrb_trace_memlevel((cb))))	\
	   mtrchook2(HKWD64_EXPAND((hw),16) | HKWD64_TMASK,		\
		     (ulong_t) (d1), (ulong_t) (d2), MTRC_RARE);	\
									\
	if (((mem_dest) & MT_COMMON)					\
	    && ((short)(level) <= rasrb_trace_memlevel((cb))))		\
	   mtrchook2(HKWD64_EXPAND((hw),16) | HKWD64_TMASK,		\
		     (ulong_t) (d1), (ulong_t) (d2), MTRC_COMMON);	\
									\
	if (((mem_dest) & MT_PRIV) && ((short)(level)			\
					<= rasrb_trace_privlevel((cb))))\
	   ct_hook2((cb), HKWD64_EXPAND((hw),16)|HKWD64_TMASK,		\
		       (ulong_t) (d1), (ulong_t) (d2));			\
									\
	if (((mem_dest) & MT_SYSTEM)					\
	    && ((short)(level) <= rasrb_trace_syslevel((cb)))) {	\
	    __INFREQUENT;						\
	    __TRCHOOK(HKWD64_EXPAND((hw),16) | HKWD64_TMASK,		\
		      (ulong_t) (d1), (ulong_t) (d2));			\
	}								\
     } while (0)

#define CT_HOOK3(cb, level, mem_dest, hw, d1, d2, d3)			\
  do {									\
	if (((mem_dest) & MT_RARE) && ((short)(level)			\
					<= rasrb_trace_memlevel((cb))))	\
	   mtrchook3(HKWD64_EXPAND((hw),24) | HKWD64_TMASK,		\
		     (ulong_t) (d1), (ulong_t) (d2), (ulong_t) (d3),	\
			MTRC_RARE);					\
									\
	if (((mem_dest) & MT_COMMON)					\
	    && ((short)(level) <= rasrb_trace_memlevel((cb))))		\
	   mtrchook3(HKWD64_EXPAND((hw),24) | HKWD64_TMASK,		\
		     (ulong_t) (d1), (ulong_t) (d2), (ulong_t) (d3),	\
			MTRC_COMMON);					\
									\
	if (((mem_dest) & MT_PRIV) && ((short)(level)			\
					<= rasrb_trace_privlevel((cb))))\
	   ct_hook3((cb), HKWD64_EXPAND((hw),24)|HKWD64_TMASK,		\
		       (ulong_t) (d1), (ulong_t) (d2), (ulong_t) (d3));	\
									\
	if (((mem_dest) & MT_SYSTEM)					\
	    && ((short)(level) <= rasrb_trace_syslevel((cb)))) {	\
	    __INFREQUENT;						\
	    __TRCHOOK(HKWD64_EXPAND((hw),24) | HKWD64_TMASK,		\
		     (ulong_t) (d1), (ulong_t) (d2), (ulong_t) (d3));	\
	}								\
     } while (0)

#define CT_HOOK4(cb, level, mem_dest, hw, d1, d2, d3, d4)		\
  do {									\
	if (((mem_dest) & MT_RARE) && ((short)(level)			\
					<= rasrb_trace_memlevel((cb))))	\
	   mtrchook4(HKWD64_EXPAND((hw),32) | HKWD64_TMASK,		\
		     (ulong_t) (d1), (ulong_t) (d2), (ulong_t) (d3),	\
			(ulong_t) (d4), MTRC_RARE);			\
									\
	if (((mem_dest) & MT_COMMON)					\
	    && ((short)(level) <= rasrb_trace_memlevel((cb))))		\
	   mtrchook4(HKWD64_EXPAND((hw),32) | HKWD64_TMASK,		\
		     (ulong_t) (d1), (ulong_t) (d2), (ulong_t) (d3),	\
			(ulong_t) (d4), MTRC_COMMON);			\
									\
	if (((mem_dest) & MT_PRIV) && ((short)(level)			\
					<= rasrb_trace_privlevel((cb))))\
	   ct_hook4((cb), HKWD64_EXPAND((hw),32)|HKWD64_TMASK,		\
		       (ulong_t) (d1), (ulong_t) (d2), (ulong_t) (d3),	\
			(ulong_t) (d4));				\
									\
	if (((mem_dest) & MT_SYSTEM)					\
	    && ((short)(level) <= rasrb_trace_syslevel((cb)))) {	\
	    __INFREQUENT;						\
	    __TRCHOOK(HKWD64_EXPAND((hw),32) | HKWD64_TMASK,		\
		     (ulong_t) (d1), (ulong_t) (d2), (ulong_t) (d3),	\
			(ulong_t) (d4));				\
	}								\
     } while (0)

#define CT_HOOK5(cb, level, mem_dest, hw, d1, d2, d3, d4, d5)		\
  do {									\
	if (((mem_dest) & MT_RARE) && ((short)(level)			\
					<= rasrb_trace_memlevel((cb))))	\
	   mtrchook5(HKWD64_EXPAND((hw),40) | HKWD64_TMASK,		\
		     (ulong_t) (d1), (ulong_t) (d2), (ulong_t) (d3),	\
			(ulong_t) (d4), (ulong_t) (d5), MTRC_RARE);	\
									\
	if (((mem_dest) & MT_COMMON)					\
	    && ((short)(level) <= rasrb_trace_memlevel((cb))))		\
	   mtrchook5(HKWD64_EXPAND((hw),40) | HKWD64_TMASK,		\
		     (ulong_t) (d1), (ulong_t) (d2), (ulong_t) (d3),	\
			(ulong_t) (d4), (ulong_t) (d5), MTRC_COMMON);	\
									\
	if (((mem_dest) & MT_PRIV) && ((short)(level)			\
					<= rasrb_trace_privlevel((cb))))\
	   ct_hook5((cb), HKWD64_EXPAND((hw),40)|HKWD64_TMASK,		\
		       (ulong_t) (d1), (ulong_t) (d2), (ulong_t) (d3),	\
			(ulong_t) (d4), (ulong_t) (d5));		\
									\
	if (((mem_dest) & MT_SYSTEM)					\
	    && ((short)(level) <= rasrb_trace_syslevel((cb)))) {	\
	    __INFREQUENT;						\
	    __TRCHOOK(HKWD64_EXPAND((hw),40) | HKWD64_TMASK,		\
		     (ulong_t) (d1), (ulong_t) (d2), (ulong_t) (d3),	\
			(ulong_t) (d4), (ulong_t) (d5));		\
	}								\
     } while (0)


#define CT_GEN(cb, level, hkwd, d1, len, buf)				\
  do {									\
	if ((short)(level) <= rasrb_trace_privlevel((cb)))		\
	   rasp_trcgen((cb), HKWD64_EXPAND((hkwd),(len))		\
			     |HKWD64_TMASK|HKWD64_GMASK|HKWD64_PMASK,	\
		       (ulong_t) (d1), (uint) (len), (void *) (buf));	\
	if ((short)(level) <= rasrb_trace_syslevel((cb)))		\
		trcgenkt(0, (hkwd), (ulong_t)(d1), (uint)(len), (void *)(buf));\
     } while (0)

/* CTCS_HOOKx macros */
#define CTCS_HOOK0(cb, level, mem_dest, hw)				\
    do {								\
	if (((mem_dest) & MT_RARE) && ((short)(level)			\
					<= rasrb_trace_memlevel((cb))))	\
	   mtrchook0(HKWD64_EXPAND((hw),0) | HKWD64_TMASK, MTRC_RARE);	\
									\
	if (((mem_dest) & MT_COMMON)					\
	    && ((short)(level) <= rasrb_trace_memlevel((cb))))		\
	   mtrchook0(HKWD64_EXPAND((hw),0) | HKWD64_TMASK, MTRC_COMMON);\
									\
	if (((mem_dest) & MT_PRIV) && ((short)(level)			\
					<= rasrb_trace_privlevel((cb))))\
	   ctcs_hook0((cb), HKWD64_EXPAND((hw),0)|HKWD64_TMASK);	\
									\
	if (((mem_dest) & MT_SYSTEM)					\
	    && ((short)(level) <= rasrb_trace_syslevel((cb)))) {	\
	    __INFREQUENT;						\
	    __TRCHOOK(HKWD64_EXPAND((hw),0) | HKWD64_TMASK);		\
	}								\
     } while (0)

#define CTCS_HOOK1(cb, level, mem_dest, hw, d1)				\
    do {								\
	if (((mem_dest) & MT_RARE) && ((short)(level)			\
					<= rasrb_trace_memlevel((cb))))	\
	   mtrchook1(HKWD64_EXPAND((hw),8) | HKWD64_TMASK, (ulong_t) (d1),\
			MTRC_RARE);					\
									\
	if (((mem_dest) & MT_COMMON)					\
	    && ((short)(level) <= rasrb_trace_memlevel((cb))))		\
	   mtrchook1(HKWD64_EXPAND((hw),8) | HKWD64_TMASK, (ulong_t) (d1),\
			MTRC_COMMON);					\
									\
	if (((mem_dest) & MT_PRIV) && ((short)(level)			\
					<= rasrb_trace_privlevel((cb))))\
	   ctcs_hook1((cb), HKWD64_EXPAND((hw),8)|HKWD64_TMASK,		\
		       (ulong_t) (d1));					\
									\
	if (((mem_dest) & MT_SYSTEM)					\
	    && ((short)(level) <= rasrb_trace_syslevel((cb)))) {	\
	    __INFREQUENT;						\
	    __TRCHOOK(HKWD64_EXPAND((hw),8) | HKWD64_TMASK,		\
			(ulong_t) (d1));				\
	}								\
     } while (0)

#define CTCS_HOOK2(cb, level, mem_dest, hw, d1, d2)			\
  do {									\
	if (((mem_dest) & MT_RARE) && ((short)(level)			\
					<= rasrb_trace_memlevel((cb))))	\
	   mtrchook2(HKWD64_EXPAND((hw),16) | HKWD64_TMASK,		\
		     (ulong_t) (d1), (ulong_t) (d2), MTRC_RARE);	\
									\
	if (((mem_dest) & MT_COMMON)					\
	    && ((short)(level) <= rasrb_trace_memlevel((cb))))		\
	   mtrchook2(HKWD64_EXPAND((hw),16) | HKWD64_TMASK,		\
		     (ulong_t) (d1), (ulong_t) (d2), MTRC_COMMON);	\
									\
	if (((mem_dest) & MT_PRIV) && ((short)(level)			\
					<= rasrb_trace_privlevel((cb))))\
	   ctcs_hook2((cb), HKWD64_EXPAND((hw),16)|HKWD64_TMASK,	\
		       (ulong_t) (d1), (ulong_t) (d2));			\
									\
	if (((mem_dest) & MT_SYSTEM)					\
	    && ((short)(level) <= rasrb_trace_syslevel((cb)))) {	\
	    __INFREQUENT;						\
	    __TRCHOOK(HKWD64_EXPAND((hw),16) | HKWD64_TMASK,		\
		      (ulong_t) (d1), (ulong_t) (d2));			\
	}								\
     } while (0)

#define CTCS_HOOK3(cb, level, mem_dest, hw, d1, d2, d3)			\
  do {									\
	if (((mem_dest) & MT_RARE) && ((short)(level)			\
					<= rasrb_trace_memlevel((cb))))	\
	   mtrchook3(HKWD64_EXPAND((hw),24) | HKWD64_TMASK,		\
		     (ulong_t) (d1), (ulong_t) (d2), (ulong_t) (d3),	\
			MTRC_RARE);					\
									\
	if (((mem_dest) & MT_COMMON)					\
	    && ((short)(level) <= rasrb_trace_memlevel((cb))))		\
	   mtrchook3(HKWD64_EXPAND((hw),24) | HKWD64_TMASK,		\
		     (ulong_t) (d1), (ulong_t) (d2), (ulong_t) (d3),	\
			MTRC_COMMON);					\
									\
	if (((mem_dest) & MT_PRIV) && ((short)(level)			\
					<= rasrb_trace_privlevel((cb))))\
	   ctcs_hook3((cb), HKWD64_EXPAND((hw),24)|HKWD64_TMASK,	\
		       (ulong_t) (d1), (ulong_t) (d2), (ulong_t) (d3));	\
									\
	if (((mem_dest) & MT_SYSTEM)					\
	    && ((short)(level) <= rasrb_trace_syslevel((cb)))) {	\
	    __INFREQUENT;						\
	    __TRCHOOK(HKWD64_EXPAND((hw),24) | HKWD64_TMASK,		\
		     (ulong_t) (d1), (ulong_t) (d2), (ulong_t) (d3));	\
	}								\
     } while (0)

#define CTCS_HOOK4(cb, level, mem_dest, hw, d1, d2, d3, d4)		\
  do {									\
	if (((mem_dest) & MT_RARE) && ((short)(level)			\
					<= rasrb_trace_memlevel((cb))))	\
	   mtrchook4(HKWD64_EXPAND((hw),32) | HKWD64_TMASK,		\
		     (ulong_t) (d1), (ulong_t) (d2), (ulong_t) (d3),	\
			(ulong_t) (d4), MTRC_RARE);			\
									\
	if (((mem_dest) & MT_COMMON)					\
	    && ((short)(level) <= rasrb_trace_memlevel((cb))))		\
	   mtrchook4(HKWD64_EXPAND((hw),32) | HKWD64_TMASK,		\
		     (ulong_t) (d1), (ulong_t) (d2), (ulong_t) (d3),	\
			(ulong_t) (d4), MTRC_COMMON);			\
									\
	if (((mem_dest) & MT_PRIV) && ((short)(level)			\
					<= rasrb_trace_privlevel((cb))))\
	   ctcs_hook4((cb), HKWD64_EXPAND((hw),32)|HKWD64_TMASK,	\
		       (ulong_t) (d1), (ulong_t) (d2), (ulong_t) (d3),	\
			(ulong_t) (d4));				\
									\
	if (((mem_dest) & MT_SYSTEM)					\
	    && ((short)(level) <= rasrb_trace_syslevel((cb)))) {	\
	    __INFREQUENT;						\
	    __TRCHOOK(HKWD64_EXPAND((hw),32) | HKWD64_TMASK,		\
		     (ulong_t) (d1), (ulong_t) (d2), (ulong_t) (d3),	\
			(ulong_t) (d4));				\
	}								\
     } while (0)

#define CTCS_HOOK5(cb, level, mem_dest, hw, d1, d2, d3, d4, d5)		\
  do {									\
	if (((mem_dest) & MT_RARE) && ((short)(level)			\
					<= rasrb_trace_memlevel((cb))))	\
	   mtrchook5(HKWD64_EXPAND((hw),40) | HKWD64_TMASK,		\
		     (ulong_t) (d1), (ulong_t) (d2), (ulong_t) (d3),	\
			(ulong_t) (d4), (ulong_t) (d5), MTRC_RARE);	\
									\
	if (((mem_dest) & MT_COMMON)					\
	    && ((short)(level) <= rasrb_trace_memlevel((cb))))		\
	   mtrchook5(HKWD64_EXPAND((hw),40) | HKWD64_TMASK,		\
		     (ulong_t) (d1), (ulong_t) (d2), (ulong_t) (d3),	\
			(ulong_t) (d4), (ulong_t) (d5), MTRC_COMMON);	\
									\
	if (((mem_dest) & MT_PRIV) && ((short)(level)			\
					<= rasrb_trace_privlevel((cb))))\
	   ctcs_hook5((cb), HKWD64_EXPAND((hw),40)|HKWD64_TMASK,	\
		       (ulong_t) (d1), (ulong_t) (d2), (ulong_t) (d3),	\
			(ulong_t) (d4), (ulong_t) (d5));		\
									\
	if (((mem_dest) & MT_SYSTEM)					\
	    && ((short)(level) <= rasrb_trace_syslevel((cb)))) {	\
	    __INFREQUENT;						\
	    __TRCHOOK(HKWD64_EXPAND((hw),40) | HKWD64_TMASK,		\
		     (ulong_t) (d1), (ulong_t) (d2), (ulong_t) (d3),	\
			(ulong_t) (d4), (ulong_t) (d5));		\
	}								\
     } while (0)

#define CT_TRCON(cb, level) ((short)(level) <= rasrb_trace_level_summary((cb)))

#define CTF_MD_SHIFT	32
#define CTF_LVL_SHIFT	40

#define CTF_COMBINE(lvl, md, hw)\
	(((ulong) (lvl) << CTF_LVL_SHIFT) |	\
	 ((ulong) (md)  << CTF_MD_SHIFT)  |	\
	  (hw))

#define CTFUNC_HOOK0(cb, lvl, mem_dest, hw)				\
	ctfunc_hook0(cb, CTF_COMBINE((lvl), (mem_dest), (hw)));
#define CTFUNC_HOOK1(cb, lvl, mem_dest, hw, d1)				\
	ctfunc_hook1(cb, CTF_COMBINE((lvl), (mem_dest), (hw)),		\
		(d1));
#define CTFUNC_HOOK2(cb, lvl, mem_dest, hw, d1, d2)			\
	ctfunc_hook2(cb, CTF_COMBINE((lvl), (mem_dest), (hw)),		\
		(d1), (d2));
#define CTFUNC_HOOK3(cb, lvl, mem_dest, hw, d1, d2, d3)			\
	ctfunc_hook3(cb, CTF_COMBINE((lvl), (mem_dest), (hw)),		\
		(d1), (d2), (d3));
#define CTFUNC_HOOK4(cb, lvl, mem_dest, hw, d1, d2, d3, d4)		\
	ctfunc_hook4(cb, CTF_COMBINE((lvl), (mem_dest), (hw)),		\
		(d1), (d2), (d3), (d4));
#define CTFUNC_HOOK5(cb, lvl, mem_dest, hw, d1, d2, d3, d4, d5)		\
	ctfunc_hook5(cb, CTF_COMBINE((lvl), (mem_dest), (hw)),		\
		(d1), (d2), (d3), (d4), (d5));

/* The following macros have no level or functional checks. It is assumed that
 * any appropriate checks have already been made.
 *
 * Theses macros are meant specifically for performance sensitive areas.
 *
 * The CT_HOOKx_PRIV macros record only to an allocated and non-suspend 
 * Component Trace private buffer.
 *
 * The CT_HOOKx_COMMON macros record only to the LMT common buffer.
 *
 * The CT_HOOKx_RARE macros record only to the LMT are buffer.
 *
 * The CT_HOOKx_SYSTEM macros record only to a system trace buffer.
 *
 * Use with caution.
 */
#define CT_HOOK0_PRIV(cb, hw)\
	ct_hook0((cb), HKWD64_EXPAND((hw),0)|HKWD64_TMASK);
#define CT_HOOK1_PRIV(cb, hw, d1)\
	ct_hook1((cb), HKWD64_EXPAND((hw),8)|HKWD64_TMASK,\
			(ulong_t) (d1));
#define CT_HOOK2_PRIV(cb, hw, d1, d2)\
	ct_hook2((cb), HKWD64_EXPAND((hw),16)|HKWD64_TMASK,\
			(ulong_t) (d1), (ulong_t) (d2));
#define CT_HOOK3_PRIV(cb, hw, d1, d2, d3)\
	ct_hook3((cb), HKWD64_EXPAND((hw),24)|HKWD64_TMASK,\
		(ulong_t) (d1), (ulong_t) (d2), (ulong_t) (d3));
#define CT_HOOK4_PRIV(cb, hw, d1, d2, d3, d4)\
	ct_hook4((cb), HKWD64_EXPAND((hw),32)|HKWD64_TMASK,\
		(ulong_t) (d1), (ulong_t) (d2), (ulong_t) (d3), (ulong_t) (d4));
#define CT_HOOK5_PRIV(cb, hw, d1, d2, d3, d4, d5)\
	ct_hook5((cb), HKWD64_EXPAND((hw),40)|HKWD64_TMASK,\
		(ulong_t) (d1), (ulong_t) (d2), (ulong_t) (d3), (ulong_t) (d4),\
		(ulong_t) (d5));

#define CTCS_HOOK0_PRIV(cb, hw)\
	ctcs_hook0((cb), HKWD64_EXPAND((hw),0)|HKWD64_TMASK);
#define CTCS_HOOK1_PRIV(cb, hw, d1)\
	ctcs_hook1((cb), HKWD64_EXPAND((hw),8)|HKWD64_TMASK,\
			(ulong_t) (d1));
#define CTCS_HOOK2_PRIV(cb, hw, d1, d2)\
	ctcs_hook2((cb), HKWD64_EXPAND((hw),16)|HKWD64_TMASK,\
			(ulong_t) (d1), (ulong_t) (d2));
#define CTCS_HOOK3_PRIV(cb, hw, d1, d2, d3)\
	ctcs_hook3((cb), HKWD64_EXPAND((hw),24)|HKWD64_TMASK,\
		(ulong_t) (d1), (ulong_t) (d2), (ulong_t) (d3));
#define CTCS_HOOK4_PRIV(cb, hw, d1, d2, d3, d4)\
	ctcs_hook4((cb), HKWD64_EXPAND((hw),32)|HKWD64_TMASK,\
		(ulong_t) (d1), (ulong_t) (d2), (ulong_t) (d3), (ulong_t) (d4));
#define CTCS_HOOK5_PRIV(cb, hw, d1, d2, d3, d4, d5)\
	ctcs_hook5((cb), HKWD64_EXPAND((hw),40)|HKWD64_TMASK,\
		(ulong_t) (d1), (ulong_t) (d2), (ulong_t) (d3), (ulong_t) (d4),\
		(ulong_t) (d5));

#define CT_HOOK0_COMMON(hw)\
	mtrchook0(HKWD64_EXPAND((hw),0) | HKWD64_TMASK, MTRC_COMMON);
#define CT_HOOK1_COMMON(hw, d1)\
	mtrchook1(HKWD64_EXPAND((hw),8) | HKWD64_TMASK,\
		(ulong_t) (d1), MTRC_COMMON);
#define CT_HOOK2_COMMON(hw, d1, d2)\
	mtrchook2(HKWD64_EXPAND((hw),16) | HKWD64_TMASK,\
		(ulong_t) (d1), (ulong_t) (d2), MTRC_COMMON);
#define CT_HOOK3_COMMON(hw, d1, d2, d3)\
	 mtrchook3(HKWD64_EXPAND((hw),24) | HKWD64_TMASK,\
		(ulong_t) (d1), (ulong_t) (d2), (ulong_t) (d3), MTRC_COMMON);
#define CT_HOOK4_COMMON(hw, d1, d2, d3, d4)\
	mtrchook4(HKWD64_EXPAND((hw),32) | HKWD64_TMASK,\
		(ulong_t) (d1), (ulong_t) (d2), (ulong_t) (d3), (ulong_t) (d4),\
		MTRC_COMMON);
#define CT_HOOK5_COMMON(hw, d1, d2, d3, d4, d5)\
	mtrchook5(HKWD64_EXPAND((hw),40) | HKWD64_TMASK,\
		(ulong_t) (d1), (ulong_t) (d2), (ulong_t) (d3), (ulong_t) (d4),\
		(ulong_t) (d5), MTRC_COMMON);

#define CT_HOOK0_RARE(hw)\
	mtrchook0(HKWD64_EXPAND((hw),0) | HKWD64_TMASK, MTRC_RARE);
#define CT_HOOK1_RARE(hw, d1)\
	mtrchook1(HKWD64_EXPAND((hw),8) | HKWD64_TMASK,\
		(ulong_t) (d1), MTRC_RARE);
#define CT_HOOK2_RARE(hw, d1, d2)\
	mtrchook2(HKWD64_EXPAND((hw),16) | HKWD64_TMASK,\
		(ulong_t) (d1), (ulong_t) (d2), MTRC_RARE);
#define CT_HOOK3_RARE(hw, d1, d2, d3)\
	mtrchook3(HKWD64_EXPAND((hw),24) | HKWD64_TMASK,\
		(ulong_t) (d1), (ulong_t) (d2), (ulong_t) (d3), MTRC_RARE);
#define CT_HOOK4_RARE(hw, d1, d2, d3, d4)\
	mtrchook4(HKWD64_EXPAND((hw),32) | HKWD64_TMASK,\
		(ulong_t) (d1), (ulong_t) (d2), (ulong_t) (d3), (ulong_t) (d4),\
		MTRC_RARE);
#define CT_HOOK5_RARE(hw, d1, d2, d3, d4, d5)\
	mtrchook5(HKWD64_EXPAND((hw),40) | HKWD64_TMASK,\
		(ulong_t) (d1), (ulong_t) (d2), (ulong_t) (d3), (ulong_t) (d4),\
		(ulong_t) (d5), MTRC_RARE);

#define CT_HOOK0_SYSTEM(hw)\
        __TRCHOOK(HKWD64_EXPAND((hw),0) | HKWD64_TMASK);
#define CT_HOOK1_SYSTEM(hw, d1)\
        __TRCHOOK(HKWD64_EXPAND((hw),8) | HKWD64_TMASK, (d1));
#define CT_HOOK2_SYSTEM(hw, d1, d2)\
        __TRCHOOK(HKWD64_EXPAND((hw),16) | HKWD64_TMASK, (d1), (d2));
#define CT_HOOK3_SYSTEM(hw, d1, d2, d3)\
        __TRCHOOK(HKWD64_EXPAND((hw),24) | HKWD64_TMASK, (d1), (d2), (d3));
#define CT_HOOK4_SYSTEM(hw, d1, d2, d3, d4)\
        __TRCHOOK(HKWD64_EXPAND((hw),32) | HKWD64_TMASK,\
                        (d1), (d2), (d3), (d4));
#define CT_HOOK5_SYSTEM(hw, d1, d2, d3, d4, d5)\
        __TRCHOOK(HKWD64_EXPAND((hw),40) | HKWD64_TMASK,\
                        (d1), (d2), (d3), (d4), (d5));

#endif /* _KERNEL */

#ifdef __cplusplus
}
#endif

#endif /* _H_RAS_TRACE */
