[apple/xnu.git] / osfmk / kern / etap_macros.h

/*
 * Copyright (c) 2000 Apple Computer, Inc. All rights reserved.
 *
 * @APPLE_LICENSE_HEADER_START@
 * 
 * The contents of this file constitute Original Code as defined in and
 * are subject to the Apple Public Source License Version 1.1 (the
 * "License").  You may not use this file except in compliance with the
 * License.  Please obtain a copy of the License at
 * http://www.apple.com/publicsource and read it before using this file.
 * 
 * This Original Code and all software distributed under the License are
 * distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY KIND, EITHER
 * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
 * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE OR NON-INFRINGEMENT.  Please see the
 * License for the specific language governing rights and limitations
 * under the License.
 * 
 * @APPLE_LICENSE_HEADER_END@
 */
/*
 * @OSF_COPYRIGHT@
 * 
 */
/*
 *	The Event Trace Analysis Package
 *	================================
 *
 *	Function:	Traces micro-kernel events.
 *
 *	Macro Notes:	Several macros are added throughout the lock code.
 *			These macros allow for convenient configuration
 *			and code readability.
 *
 *			The macro prefixes determine a specific trace
 *			configuration operation:
 *
 *			CUM	-  Cumulative trace specific operation.
 *			MON	-  Monitored  trace specific operation.
 *			ETAP	-  Both a cumulative and monitored trace
 *				   operation.
 */


#ifndef _KERN_ETAP_MACROS_H_
#define _KERN_ETAP_MACROS_H_

#include <kern/etap_options.h>
#include <kern/lock.h>
#include <mach/etap.h>
#include <mach/etap_events.h>
#include <kern/etap_pool.h>


#if	ETAP

#include <mach/vm_param.h>
#include <mach/message.h>

#include <kern/macro_help.h>

extern void etap_init_phase1(void);
extern void etap_init_phase2(void);
extern void etap_event_table_assign(struct event_table_chain *, etap_event_t);
extern unsigned int  etap_get_pc(void);
extern event_table_t event_table;
extern subs_table_t subs_table;

/*
 *  Time Macros
 */

#define ETAP_TIMESTAMP(t)		rtc_gettime_interrupts_disabled(&t)
#define ETAP_TIME_SUM(t,sum_me)		t += sum_me
#define ETAP_TIME_SUB(t,stop,start)		\
MACRO_BEGIN					\
	(t) = (stop);				\
	SUB_MACH_TIMESPEC(&(t), &(start));	\
MACRO_END
#define ETAP_TIME_SQR(t,sqr_me)		t += sqr_me*sqr_me
#define ETAP_TIME_DIV(r,n,d)		r = (u_short) n/d
#define ETAP_TIME_IS_ZERO(t)		((t).tv_sec == 0)
#define ETAP_TIME_CLEAR(t)		((t).tv_sec = 0)
#define ETAP_TIME_GREATER(t1,t2)	((t1) > (t2))

#else	/* ETAP */

#define etap_init_phase1()
#define etap_init_phase2()
#define etap_event_table_assign(event)
#define ETAP_TIMESTAMP(t)
#define ETAP_TIME_SUB(t,start,stop)
#define ETAP_TIME_CLEAR(t)

#endif	/* ETAP */


/*
 *  ===================================================
 *  ETAP: cumulative trace specific macros
 *  ===================================================
 */

#if	ETAP_LOCK_ACCUMULATE

extern cbuff_entry_t	etap_cbuff_reserve(event_table_t);
#if MACH_LDEBUG
extern simple_lock_t	cbuff_locks;
#else
extern simple_lock_data_t cbuff_locks;
#endif
extern int		cbuff_width;

/*
 *  If cumulative hold tracing is enabled for the event (i.e., acquired lock),
 *  the CUM_HOLD_ACCUMULATE macro will update the appropriate cumulative buffer
 *  entry with the newly collected hold data.
 */

#define CUM_HOLD_ACCUMULATE(cp,total_time,dynamic,trace)		      \
MACRO_BEGIN								      \
    u_short	_bucket;						      \
    if ((cp) != CBUFF_ENTRY_NULL && ((trace) & CUM_DURATION)) {		      \
       if (dynamic)							      \
	   simple_lock_no_trace(&cbuff_locks[dynamic-1]);		      \
       (cp)->hold.triggered++;						      \
       ETAP_TIME_SUM((cp)->hold.time,(total_time));			      \
       ETAP_TIME_SQR((cp)->hold.time_sq,(total_time));			      \
       if (ETAP_TIME_IS_ZERO((cp)->hold.min_time) ||			      \
	   ETAP_TIME_GREATER((cp)->hold.min_time,(total_time)))		      \
	       (cp)->hold.min_time = (total_time);			      \
       if (ETAP_TIME_GREATER((total_time),(cp)->hold.max_time))		      \
	       (cp)->hold.max_time = (total_time);			      \
       ETAP_TIME_DIV(_bucket,(total_time),cbuff_width);			      \
       if (_bucket >= ETAP_CBUFF_IBUCKETS)				      \
	   (cp)->hold_interval[ETAP_CBUFF_IBUCKETS-1]++;		      \
       else								      \
	   (cp)->hold_interval[_bucket]++;				      \
       if (dynamic)							      \
	   simple_unlock_no_trace(&cbuff_locks[dynamic-1]);		      \
    }									      \
MACRO_END

/*
 *  If cumulative wait tracing is enabled for the event (i.e., acquired lock),
 *  the CUM_WAIT_ACCUMULATE macro will update the appropriate cumulative
 *  buffer entry with the newly collected wait data.
 */

#define CUM_WAIT_ACCUMULATE(cp,total_time,dynamic,trace)		      \
MACRO_BEGIN								      \
    u_short    _bucket;							      \
    if ((cp) != CBUFF_ENTRY_NULL && ((trace) & CUM_CONTENTION)) {	      \
       if (dynamic)							      \
	   simple_lock_no_trace(&cbuff_locks[dynamic-1]);		      \
       (cp)->wait.triggered++;						      \
       ETAP_TIME_SUM((cp)->wait.time,(total_time));			      \
       ETAP_TIME_SQR((cp)->wait.time_sq,(total_time));			      \
       if (ETAP_TIME_IS_ZERO((cp)->wait.min_time) ||			      \
	   ETAP_TIME_GREATER((cp)->wait.min_time,(total_time)))		      \
	       (cp)->wait.min_time = (total_time);			      \
       if (ETAP_TIME_GREATER((total_time),(cp)->wait.max_time))		      \
	       (cp)->wait.max_time = (total_time);			      \
       ETAP_TIME_DIV(_bucket,(total_time),cbuff_width);			      \
       if (_bucket >= ETAP_CBUFF_IBUCKETS)				      \
	   (cp)->wait_interval[ETAP_CBUFF_IBUCKETS-1]++;		      \
       else								      \
	   (cp)->wait_interval[_bucket]++;				      \
       if (dynamic)							      \
	   simple_unlock_no_trace(&cbuff_locks[dynamic-1]);		      \
     }									      \
MACRO_END

/*
 *  Initially a lock's cbuff_read pointer is set to CBUFF_ENTRY_NULL. This
 *  saves space in the cumulative buffer in the event that a read lock is
 *  not acquired.  In the case that a read lock is acquired, the
 *  CUM_READ_ENTRY_RESERVE macro is called.  Here a cumulative
 *  record is reserved and initialized.
 */

#define CUM_READ_ENTRY_RESERVE(l,cp,trace)				      \
MACRO_BEGIN								      \
    if ((cp) == CBUFF_ENTRY_NULL && (trace) & ETAP_CUMULATIVE) {	      \
       (cp) = etap_cbuff_reserve(lock_event_table(l));			      \
       if ((cp) != CBUFF_ENTRY_NULL) {					      \
	  (cp)->event = lock_event_table(l)->event;			      \
	  (cp)->instance = (u_int) l;					      \
	  (cp)->kind = READ_LOCK;					      \
       }								      \
    }									      \
MACRO_END

#else  /* ETAP_LOCK_ACCUMULATE */
#define etap_cbuff_reserve(et)
#define CUM_HOLD_ACCUMULATE(cp,t,d,tr)
#define CUM_WAIT_ACCUMULATE(cp,t,d,tr)
#define CUM_READ_ENTRY_RESERVE(l,rep,tr)
#endif /* ETAP_LOCK_ACCUMULATE */

/*
 *  ===============================================
 *  ETAP: monitor trace specific macros
 *  ===============================================
 */

#if	ETAP_MONITOR
extern int			mbuff_entries;
extern monitor_buffer_t		mbuff[];
#endif	/* ETAP_MONITOR */


#if	ETAP_LOCK_MONITOR

/*
 *  If monitor tracing is enabled for the lock, the
 *  MON_DATA_COLLECT macro will write collected lock data to
 *  the next slot in a cpu specific monitor buffer.  Circular
 *  buffer maintenance is also performed here.
 */

#define MON_DATA_COLLECT(l,e,total_time,type,op,trace)			     \
MACRO_BEGIN								     \
	mbuff_entry_t _mp;						     \
	int _cpu, _ent, _s;						     \
	if ((trace) & op) {						     \
	   mp_disable_preemption();					     \
	   _cpu = cpu_number();						     \
	   _s	= splhigh();						     \
	   _ent = mbuff[_cpu]->free;					     \
	   _mp	= &mbuff[_cpu]->entry[_ent];				     \
	   _mp->event	     = lock_event_table(l)->event;		     \
	   _mp->flags	     = ((op) | (type));				     \
	   _mp->instance     = (u_int) (l);				     \
	   _mp->time	     = (total_time);				     \
	   _mp->data[0]	     = (e)->start_pc;				     \
	   _mp->data[1]	     = (e)->end_pc;				     \
	   mbuff[_cpu]->free = (_ent+1) % mbuff_entries;		     \
	   if (mbuff[_cpu]->free == 0)					     \
		mbuff[_cpu]->timestamp++;				     \
	   splx(_s);							     \
	   mp_enable_preemption();					     \
	}								     \
MACRO_END

#define MON_CLEAR_PCS(l)						     \
MACRO_BEGIN								     \
	(l)->start_pc = 0;						     \
	(l)->end_pc   = 0;						     \
MACRO_END

#define MON_ASSIGN_PC(target,source,trace)				     \
	if ((trace) & ETAP_MONITORED) target = source

#else  /* ETAP_LOCK_MONITOR */
#define MON_DATA_COLLECT(l,le,tt,t,o,tr)
#define MON_GET_PC(pc,tr)
#define MON_CLEAR_PCS(l)
#define MON_ASSIGN_PC(t,s,tr)
#endif /* ETAP_LOCK_MONITOR */


#if     ETAP_EVENT_MONITOR

#include <mach/exception_types.h>

#define ETAP_EXCEPTION_PROBE(_f, _th, _ex, _sysnum)             \
        if (_ex == EXC_SYSCALL) {                               \
                ETAP_PROBE_DATA(ETAP_P_SYSCALL_UNIX,            \
                                _f,                             \
                                _th,                            \
                                _sysnum,                        \
                                sizeof(int));                   \
        }
#else   /* ETAP_EVENT_MONITOR */
#define ETAP_EXCEPTION_PROBE(_f, _th, _ex, _sysnum)
#endif  /* ETAP_EVENT_MONITOR */

#if	ETAP_EVENT_MONITOR

#define ETAP_PROBE_DATA_COND(_event, _flags, _thread, _data, _size, _cond)		     \
MACRO_BEGIN								     \
	mbuff_entry_t _mp;						     \
	int _cpu, _ent, _s;						     \
	if (event_table[_event].status && (_cond)) {			     \
	   mp_disable_preemption();					     \
	   _cpu	 = cpu_number();					     \
	   _s	 = splhigh();						     \
	   _ent	 = mbuff[_cpu]->free;					     \
	   _mp = &mbuff[_cpu]->entry[_ent];				     \
	   ETAP_TIMESTAMP(_mp->time);					     \
	   _mp->pc	  = etap_get_pc();				     \
	   _mp->event	  = _event;					     \
	   _mp->flags	  = KERNEL_EVENT | _flags;			     \
	   _mp->instance  = (u_int) _thread;				     \
	   bcopy((char *) _data, (char *) _mp->data, _size);		     \
	   mbuff[_cpu]->free = (_ent+1) % mbuff_entries;		     \
	   if (mbuff[_cpu]->free == 0)					     \
		mbuff[_cpu]->timestamp++;				     \
	   splx(_s);							     \
	   mp_enable_preemption();					     \
	}								     \
MACRO_END

#define ETAP_PROBE(_event, _flags, _thread)				     \
	ETAP_PROBE_DATA_COND(_event, _flags, _thread, 0, 0, 1)

#define ETAP_PROBE_DATA(_event, _flags, _thread, _data, _size)		     \
	ETAP_PROBE_DATA_COND(_event, _flags, _thread, _data, _size,	     \
	(_thread)->etap_trace)

#define ETAP_DATA_LOAD(ed, x)		((ed) = (u_int) (x))
#define ETAP_SET_REASON(_th, _reason)	((_th)->etap_reason = (_reason))

#else	/* ETAP_EVENT_MONITOR */
#define ETAP_PROBE(e,f,th)
#define ETAP_PROBE_DATA(e,f,th,d,s)
#define ETAP_PROBE_DATA_COND(e,f,th,d,s,c)
#define ETAP_DATA_LOAD(d,x);
#define ETAP_SET_REASON(t,r)
#endif	/* ETAP_EVENT_MONITOR */

/*
 *  =================================
 *  ETAP: general lock macros
 *  =================================
 */

#if	ETAP_LOCK_TRACE

#define ETAP_TOTAL_TIME(t,stop,start)	\
	ETAP_TIME_SUB((t),(stop),(start))

#define ETAP_DURATION_TIMESTAMP(e,trace)				\
MACRO_BEGIN								\
	if ((trace) & ETAP_DURATION)					\
	     ETAP_TIMESTAMP((e)->start_hold_time);			\
MACRO_END

#define ETAP_COPY_START_HOLD_TIME(entry,time,trace)			\
MACRO_BEGIN								\
	if ((trace) & ETAP_DURATION)					\
	     (entry)->start_hold_time = time;				\
MACRO_END

#define ETAP_CONTENTION_TIMESTAMP(e,trace)				\
MACRO_BEGIN								\
	if ((trace) & ETAP_CONTENTION)					\
	     ETAP_TIMESTAMP((e)->start_wait_time);			\
MACRO_END

#define ETAP_STAMP(event_table,trace,dynamic)				\
MACRO_BEGIN								\
	if ((event_table) != EVENT_TABLE_NULL) {			\
	    (dynamic) = (event_table)->dynamic;				\
	    (trace)   = (event_table)->status;				\
	}								\
MACRO_END

#define ETAP_WHOLE_OP(l)	\
	(!(ETAP_TIME_IS_ZERO((l)->u.s.start_hold_time)))
#define ETAP_DURATION_ENABLED(trace)	((trace) & ETAP_DURATION)
#define ETAP_CONTENTION_ENABLED(trace)	((trace) & ETAP_CONTENTION)

/*
 *  The ETAP_CLEAR_TRACE_DATA macro sets the etap specific fields
 *  of the simple_lock_t structure to zero.
 *
 *  This is always done just before a simple lock is released.
 */

#define ETAP_CLEAR_TRACE_DATA(l)		\
MACRO_BEGIN					\
	ETAP_TIME_CLEAR((l)->u.s.start_hold_time);	\
	MON_CLEAR_PCS((l));			\
MACRO_END


/* ==================================================
 *  The ETAP_XXX_ENTRY macros manipulate the locks
 *  start_list (a linked list of start data).
 * ==================================================
 */

#define ETAP_CREATE_ENTRY(entry,trace)					   \
MACRO_BEGIN								   \
	if ((trace) & ETAP_TRACE_ON)					   \
	    (entry) = get_start_data_node();				   \
MACRO_END

#define ETAP_LINK_ENTRY(l,entry,trace)					   \
MACRO_BEGIN								   \
	if ((trace) & ETAP_TRACE_ON) {					   \
		(entry)->next = (l)->u.s.start_list;			   \
		(l)->u.s.start_list = (entry);				   \
		(entry)->thread_id = (u_int) current_thread();		   \
		ETAP_TIME_CLEAR((entry)->start_wait_time);		   \
	}								   \
MACRO_END

#define ETAP_FIND_ENTRY(l,entry,trace)					   \
MACRO_BEGIN								   \
	u_int _ct;							   \
	_ct = (u_int) current_thread();					   \
	(entry) = (l)->u.s.start_list;					   \
	while ((entry) != SD_ENTRY_NULL && (entry)->thread_id != _ct)	   \
	      (entry) = (entry)->next;					   \
	if ((entry) == SD_ENTRY_NULL)					   \
	      (trace) = 0;						   \
MACRO_END

#define ETAP_UNLINK_ENTRY(l,entry)					   \
MACRO_BEGIN								   \
	boolean_t	  _first = TRUE;				   \
	start_data_node_t _prev;					   \
	u_int		  _ct;						   \
	_ct = (u_int) current_thread();					   \
	(entry) = (l)->u.s.start_list;					   \
	while ((entry) != SD_ENTRY_NULL && (entry)->thread_id != _ct){	   \
	    _prev = (entry);						   \
	    (entry) = (entry)->next;					   \
	    _first = FALSE;						   \
	}								   \
	if (entry != SD_ENTRY_NULL) {					   \
	    if (_first)							   \
		(l)->u.s.start_list = (entry)->next;			   \
	    else							   \
		_prev->next = (entry)->next;				   \
	    (entry)->next = SD_ENTRY_NULL;				   \
	}								   \
MACRO_END

#define ETAP_DESTROY_ENTRY(entry)					   \
MACRO_BEGIN								   \
	if ((entry) != SD_ENTRY_NULL)					   \
	   free_start_data_node ((entry));				   \
MACRO_END

#else	/* ETAP_LOCK_TRACE */
#define ETAP_TOTAL_TIME(t,stop,start)
#define ETAP_DURATION_TIMESTAMP(le,tr)
#define ETAP_CONTENTION_TIMESTAMP(le,tr)
#define ETAP_COPY_START_HOLD_TIME(le,t,tr)
#define ETAP_STAMP(tt,tr,d)
#define ETAP_DURATION_ENABLED(tr)     (0)  /* always fails */
#define ETAP_CONTENTION_ENABLED(tr)   (0)  /* always fails */
#define ETAP_CLEAR_TRACE_DATA(l)
#define ETAP_CREATE_ENTRY(e,tr)
#define ETAP_LINK_ENTRY(l,e,tr)
#define ETAP_FIND_ENTRY(l,e,tr)
#define ETAP_UNLINK_ENTRY(l,e)
#define ETAP_DESTROY_ENTRY(e)
#endif	/* ETAP_LOCK_TRACE */

#endif	/* _KERN_ETAP_MACROS_H_ */
Commit	Line	Data
1c79356b A	1	/*
	2	* Copyright (c) 2000 Apple Computer, Inc. All rights reserved.
	3	*
	4	* @APPLE_LICENSE_HEADER_START@
	5	*
de355530 A	6	* The contents of this file constitute Original Code as defined in and
	7	* are subject to the Apple Public Source License Version 1.1 (the
	8	* "License"). You may not use this file except in compliance with the
	9	* License. Please obtain a copy of the License at
	10	* http://www.apple.com/publicsource and read it before using this file.
1c79356b	11	*
de355530 A	12	* This Original Code and all software distributed under the License are
de355530 A	13	* distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY KIND, EITHER
1c79356b A	14	* EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
1c79356b A	15	* INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
de355530 A	16	* FITNESS FOR A PARTICULAR PURPOSE OR NON-INFRINGEMENT. Please see the
	17	* License for the specific language governing rights and limitations
	18	* under the License.
1c79356b A	19	*
	20	* @APPLE_LICENSE_HEADER_END@
	21	*/
	22	/*
	23	* @OSF_COPYRIGHT@
	24	*
	25	*/
	26	/*
	27	* The Event Trace Analysis Package
	28	* ================================
	29	*
	30	* Function: Traces micro-kernel events.
	31	*
	32	* Macro Notes: Several macros are added throughout the lock code.
	33	* These macros allow for convenient configuration
	34	* and code readability.
	35	*
	36	* The macro prefixes determine a specific trace
	37	* configuration operation:
	38	*
	39	* CUM - Cumulative trace specific operation.
	40	* MON - Monitored trace specific operation.
	41	* ETAP - Both a cumulative and monitored trace
	42	* operation.
	43	*/
	44
	45
	46	#ifndef _KERN_ETAP_MACROS_H_
	47	#define _KERN_ETAP_MACROS_H_
	48
	49	#include <kern/etap_options.h>
	50	#include <kern/lock.h>
	51	#include <mach/etap.h>
	52	#include <mach/etap_events.h>
	53	#include <kern/etap_pool.h>
	54
	55
	56	#if ETAP
	57
1c79356b	58	#include <mach/vm_param.h>
1c79356b A	59	#include <mach/message.h>
1c79356b A	60
9bccf70c A	61	#include <kern/macro_help.h>
9bccf70c A	62
1c79356b A	63	extern void etap_init_phase1(void);
	64	extern void etap_init_phase2(void);
	65	extern void etap_event_table_assign(struct event_table_chain *, etap_event_t);
	66	extern unsigned int etap_get_pc(void);
	67	extern event_table_t event_table;
	68	extern subs_table_t subs_table;
	69
	70	/*
	71	* Time Macros
	72	*/
	73
	74	#define ETAP_TIMESTAMP(t) rtc_gettime_interrupts_disabled(&t)
	75	#define ETAP_TIME_SUM(t,sum_me) t += sum_me
	76	#define ETAP_TIME_SUB(t,stop,start) \
	77	MACRO_BEGIN \
	78	(t) = (stop); \
	79	SUB_MACH_TIMESPEC(&(t), &(start)); \
	80	MACRO_END
	81	#define ETAP_TIME_SQR(t,sqr_me) t += sqr_me*sqr_me
	82	#define ETAP_TIME_DIV(r,n,d) r = (u_short) n/d
	83	#define ETAP_TIME_IS_ZERO(t) ((t).tv_sec == 0)
	84	#define ETAP_TIME_CLEAR(t) ((t).tv_sec = 0)
	85	#define ETAP_TIME_GREATER(t1,t2) ((t1) > (t2))
	86
	87	#else /* ETAP */
	88
	89	#define etap_init_phase1()
	90	#define etap_init_phase2()
	91	#define etap_event_table_assign(event)
	92	#define ETAP_TIMESTAMP(t)
	93	#define ETAP_TIME_SUB(t,start,stop)
	94	#define ETAP_TIME_CLEAR(t)
	95
	96	#endif /* ETAP */
	97
	98
	99	/*
	100	* ===================================================
	101	* ETAP: cumulative trace specific macros
	102	* ===================================================
	103	*/
	104
	105	#if ETAP_LOCK_ACCUMULATE
	106
	107	extern cbuff_entry_t etap_cbuff_reserve(event_table_t);
	108	#if MACH_LDEBUG
	109	extern simple_lock_t cbuff_locks;
	110	#else
	111	extern simple_lock_data_t cbuff_locks;
	112	#endif
	113	extern int cbuff_width;
	114
	115	/*
	116	* If cumulative hold tracing is enabled for the event (i.e., acquired lock),
	117	* the CUM_HOLD_ACCUMULATE macro will update the appropriate cumulative buffer
	118	* entry with the newly collected hold data.
	119	*/
	120
	121	#define CUM_HOLD_ACCUMULATE(cp,total_time,dynamic,trace) \
	122	MACRO_BEGIN \
	123	u_short _bucket; \
	124	if ((cp) != CBUFF_ENTRY_NULL && ((trace) & CUM_DURATION)) { \
	125	if (dynamic) \
	126	simple_lock_no_trace(&cbuff_locks[dynamic-1]); \
127	(cp)->hold.triggered++; \
128	ETAP_TIME_SUM((cp)->hold.time,(total_time)); \
129	ETAP_TIME_SQR((cp)->hold.time_sq,(total_time)); \
130	if (ETAP_TIME_IS_ZERO((cp)->hold.min_time) \|\| \
131	ETAP_TIME_GREATER((cp)->hold.min_time,(total_time))) \
132	(cp)->hold.min_time = (total_time); \
133	if (ETAP_TIME_GREATER((total_time),(cp)->hold.max_time)) \
134	(cp)->hold.max_time = (total_time); \
135	ETAP_TIME_DIV(_bucket,(total_time),cbuff_width); \
136	if (_bucket >= ETAP_CBUFF_IBUCKETS) \
137	(cp)->hold_interval[ETAP_CBUFF_IBUCKETS-1]++; \
138	else \
139	(cp)->hold_interval[_bucket]++; \
140	if (dynamic) \
141	simple_unlock_no_trace(&cbuff_locks[dynamic-1]); \
142	} \
143	MACRO_END
144
145	/*
146	* If cumulative wait tracing is enabled for the event (i.e., acquired lock),
147	* the CUM_WAIT_ACCUMULATE macro will update the appropriate cumulative
148	* buffer entry with the newly collected wait data.
149	*/
150
151	#define CUM_WAIT_ACCUMULATE(cp,total_time,dynamic,trace) \
152	MACRO_BEGIN \
153	u_short _bucket; \
154	if ((cp) != CBUFF_ENTRY_NULL && ((trace) & CUM_CONTENTION)) { \
155	if (dynamic) \
156	simple_lock_no_trace(&cbuff_locks[dynamic-1]); \
157	(cp)->wait.triggered++; \
158	ETAP_TIME_SUM((cp)->wait.time,(total_time)); \
159	ETAP_TIME_SQR((cp)->wait.time_sq,(total_time)); \
160	if (ETAP_TIME_IS_ZERO((cp)->wait.min_time) \|\| \
161	ETAP_TIME_GREATER((cp)->wait.min_time,(total_time))) \
162	(cp)->wait.min_time = (total_time); \
163	if (ETAP_TIME_GREATER((total_time),(cp)->wait.max_time)) \
164	(cp)->wait.max_time = (total_time); \
165	ETAP_TIME_DIV(_bucket,(total_time),cbuff_width); \
166	if (_bucket >= ETAP_CBUFF_IBUCKETS) \
167	(cp)->wait_interval[ETAP_CBUFF_IBUCKETS-1]++; \
168	else \
169	(cp)->wait_interval[_bucket]++; \
170	if (dynamic) \
171	simple_unlock_no_trace(&cbuff_locks[dynamic-1]); \
172	} \
173	MACRO_END
174
175	/*
176	* Initially a lock's cbuff_read pointer is set to CBUFF_ENTRY_NULL. This
177	* saves space in the cumulative buffer in the event that a read lock is
178	* not acquired. In the case that a read lock is acquired, the
179	* CUM_READ_ENTRY_RESERVE macro is called. Here a cumulative
180	* record is reserved and initialized.
181	*/
182
183	#define CUM_READ_ENTRY_RESERVE(l,cp,trace) \
184	MACRO_BEGIN \
185	if ((cp) == CBUFF_ENTRY_NULL && (trace) & ETAP_CUMULATIVE) { \
186	(cp) = etap_cbuff_reserve(lock_event_table(l)); \
187	if ((cp) != CBUFF_ENTRY_NULL) { \
188	(cp)->event = lock_event_table(l)->event; \
189	(cp)->instance = (u_int) l; \
190	(cp)->kind = READ_LOCK; \
191	} \
192	} \
193	MACRO_END
194
195	#else /* ETAP_LOCK_ACCUMULATE */
196	#define etap_cbuff_reserve(et)
197	#define CUM_HOLD_ACCUMULATE(cp,t,d,tr)
198	#define CUM_WAIT_ACCUMULATE(cp,t,d,tr)
199	#define CUM_READ_ENTRY_RESERVE(l,rep,tr)
200	#endif /* ETAP_LOCK_ACCUMULATE */
201
202	/*
203	* ===============================================
204	* ETAP: monitor trace specific macros
205	* ===============================================
206	*/
207
208	#if ETAP_MONITOR
209	extern int mbuff_entries;
210	extern monitor_buffer_t mbuff[];
211	#endif /* ETAP_MONITOR */
212
213
214	#if ETAP_LOCK_MONITOR
215
216	/*
217	* If monitor tracing is enabled for the lock, the
218	* MON_DATA_COLLECT macro will write collected lock data to
219	* the next slot in a cpu specific monitor buffer. Circular
220	* buffer maintenance is also performed here.
221	*/
222
223	#define MON_DATA_COLLECT(l,e,total_time,type,op,trace) \
224	MACRO_BEGIN \
225	mbuff_entry_t _mp; \
226	int _cpu, _ent, _s; \
227	if ((trace) & op) { \
228	mp_disable_preemption(); \
229	_cpu = cpu_number(); \
230	_s = splhigh(); \
231	_ent = mbuff[_cpu]->free; \
232	_mp = &mbuff[_cpu]->entry[_ent]; \
233	_mp->event = lock_event_table(l)->event; \
234	_mp->flags = ((op) \| (type)); \
235	_mp->instance = (u_int) (l); \
236	_mp->time = (total_time); \
237	_mp->data[0] = (e)->start_pc; \
238	_mp->data[1] = (e)->end_pc; \
239	mbuff[_cpu]->free = (_ent+1) % mbuff_entries; \
240	if (mbuff[_cpu]->free == 0) \
241	mbuff[_cpu]->timestamp++; \
242	splx(_s); \
243	mp_enable_preemption(); \
244	} \
245	MACRO_END
246
247	#define MON_CLEAR_PCS(l) \
248	MACRO_BEGIN \
249	(l)->start_pc = 0; \
250	(l)->end_pc = 0; \
251	MACRO_END
252
253	#define MON_ASSIGN_PC(target,source,trace) \
254	if ((trace) & ETAP_MONITORED) target = source
255
256	#else /* ETAP_LOCK_MONITOR */
257	#define MON_DATA_COLLECT(l,le,tt,t,o,tr)
258	#define MON_GET_PC(pc,tr)
259	#define MON_CLEAR_PCS(l)
260	#define MON_ASSIGN_PC(t,s,tr)
261	#endif /* ETAP_LOCK_MONITOR */
262
263
9bccf70c A	264	#if ETAP_EVENT_MONITOR
	265
	266	#include <mach/exception_types.h>
	267
	268	#define ETAP_EXCEPTION_PROBE(_f, _th, _ex, _sysnum) \
	269	if (_ex == EXC_SYSCALL) { \
	270	ETAP_PROBE_DATA(ETAP_P_SYSCALL_UNIX, \
	271	_f, \
	272	_th, \
	273	_sysnum, \
	274	sizeof(int)); \
	275	}
	276	#else /* ETAP_EVENT_MONITOR */
	277	#define ETAP_EXCEPTION_PROBE(_f, _th, _ex, _sysnum)
	278	#endif /* ETAP_EVENT_MONITOR */
	279
1c79356b A	280	#if ETAP_EVENT_MONITOR
	281
	282	#define ETAP_PROBE_DATA_COND(_event, _flags, _thread, _data, _size, _cond) \
	283	MACRO_BEGIN \
	284	mbuff_entry_t _mp; \
	285	int _cpu, _ent, _s; \
	286	if (event_table[_event].status && (_cond)) { \
	287	mp_disable_preemption(); \
	288	_cpu = cpu_number(); \
	289	_s = splhigh(); \
	290	_ent = mbuff[_cpu]->free; \
	291	_mp = &mbuff[_cpu]->entry[_ent]; \
	292	ETAP_TIMESTAMP(_mp->time); \
	293	_mp->pc = etap_get_pc(); \
	294	_mp->event = _event; \
	295	_mp->flags = KERNEL_EVENT \| _flags; \
	296	_mp->instance = (u_int) _thread; \
	297	bcopy((char ) _data, (char ) _mp->data, _size); \
	298	mbuff[_cpu]->free = (_ent+1) % mbuff_entries; \
	299	if (mbuff[_cpu]->free == 0) \
	300	mbuff[_cpu]->timestamp++; \
	301	splx(_s); \
	302	mp_enable_preemption(); \
	303	} \
	304	MACRO_END
	305
	306	#define ETAP_PROBE(_event, _flags, _thread) \
	307	ETAP_PROBE_DATA_COND(_event, _flags, _thread, 0, 0, 1)
	308
	309	#define ETAP_PROBE_DATA(_event, _flags, _thread, _data, _size) \
	310	ETAP_PROBE_DATA_COND(_event, _flags, _thread, _data, _size, \
	311	(_thread)->etap_trace)
	312
	313	#define ETAP_DATA_LOAD(ed, x) ((ed) = (u_int) (x))
	314	#define ETAP_SET_REASON(_th, _reason) ((_th)->etap_reason = (_reason))
	315
	316	#else /* ETAP_EVENT_MONITOR */
	317	#define ETAP_PROBE(e,f,th)
	318	#define ETAP_PROBE_DATA(e,f,th,d,s)
	319	#define ETAP_PROBE_DATA_COND(e,f,th,d,s,c)
	320	#define ETAP_DATA_LOAD(d,x);
	321	#define ETAP_SET_REASON(t,r)
	322	#endif /* ETAP_EVENT_MONITOR */
	323
	324	/*
	325	* =================================
	326	* ETAP: general lock macros
	327	* =================================
	328	*/
	329
	330	#if ETAP_LOCK_TRACE
	331
	332	#define ETAP_TOTAL_TIME(t,stop,start) \
	333	ETAP_TIME_SUB((t),(stop),(start))
	334
	335	#define ETAP_DURATION_TIMESTAMP(e,trace) \
	336	MACRO_BEGIN \
	337	if ((trace) & ETAP_DURATION) \
	338	ETAP_TIMESTAMP((e)->start_hold_time); \
	339	MACRO_END
	340
	341	#define ETAP_COPY_START_HOLD_TIME(entry,time,trace) \
	342	MACRO_BEGIN \
	343	if ((trace) & ETAP_DURATION) \
344	(entry)->start_hold_time = time; \
345	MACRO_END
346
347	#define ETAP_CONTENTION_TIMESTAMP(e,trace) \
348	MACRO_BEGIN \
349	if ((trace) & ETAP_CONTENTION) \
350	ETAP_TIMESTAMP((e)->start_wait_time); \
351	MACRO_END
352
353	#define ETAP_STAMP(event_table,trace,dynamic) \
354	MACRO_BEGIN \
355	if ((event_table) != EVENT_TABLE_NULL) { \
356	(dynamic) = (event_table)->dynamic; \
357	(trace) = (event_table)->status; \
358	} \
359	MACRO_END
360
361	#define ETAP_WHOLE_OP(l) \
362	(!(ETAP_TIME_IS_ZERO((l)->u.s.start_hold_time)))
363	#define ETAP_DURATION_ENABLED(trace) ((trace) & ETAP_DURATION)
364	#define ETAP_CONTENTION_ENABLED(trace) ((trace) & ETAP_CONTENTION)
365
366	/*
367	* The ETAP_CLEAR_TRACE_DATA macro sets the etap specific fields
368	* of the simple_lock_t structure to zero.
369	*
370	* This is always done just before a simple lock is released.
371	*/
372
373	#define ETAP_CLEAR_TRACE_DATA(l) \
374	MACRO_BEGIN \
375	ETAP_TIME_CLEAR((l)->u.s.start_hold_time); \
376	MON_CLEAR_PCS((l)); \
377	MACRO_END
378
379
380	/* ==================================================
381	* The ETAP_XXX_ENTRY macros manipulate the locks
382	* start_list (a linked list of start data).
383	* ==================================================
384	*/
385
386	#define ETAP_CREATE_ENTRY(entry,trace) \
387	MACRO_BEGIN \
388	if ((trace) & ETAP_TRACE_ON) \
389	(entry) = get_start_data_node(); \
390	MACRO_END
391
392	#define ETAP_LINK_ENTRY(l,entry,trace) \
393	MACRO_BEGIN \
394	if ((trace) & ETAP_TRACE_ON) { \
395	(entry)->next = (l)->u.s.start_list; \
396	(l)->u.s.start_list = (entry); \
397	(entry)->thread_id = (u_int) current_thread(); \
398	ETAP_TIME_CLEAR((entry)->start_wait_time); \
399	} \
400	MACRO_END
401
402	#define ETAP_FIND_ENTRY(l,entry,trace) \
403	MACRO_BEGIN \
404	u_int _ct; \
405	_ct = (u_int) current_thread(); \
406	(entry) = (l)->u.s.start_list; \
407	while ((entry) != SD_ENTRY_NULL && (entry)->thread_id != _ct) \
408	(entry) = (entry)->next; \
409	if ((entry) == SD_ENTRY_NULL) \
410	(trace) = 0; \
411	MACRO_END
412
413	#define ETAP_UNLINK_ENTRY(l,entry) \
414	MACRO_BEGIN \
415	boolean_t _first = TRUE; \
416	start_data_node_t _prev; \
417	u_int _ct; \
418	_ct = (u_int) current_thread(); \
419	(entry) = (l)->u.s.start_list; \
420	while ((entry) != SD_ENTRY_NULL && (entry)->thread_id != _ct){ \
421	_prev = (entry); \
422	(entry) = (entry)->next; \
423	_first = FALSE; \
424	} \
425	if (entry != SD_ENTRY_NULL) { \
426	if (_first) \
427	(l)->u.s.start_list = (entry)->next; \
428	else \
429	_prev->next = (entry)->next; \
430	(entry)->next = SD_ENTRY_NULL; \
431	} \
432	MACRO_END
433
434	#define ETAP_DESTROY_ENTRY(entry) \
435	MACRO_BEGIN \
436	if ((entry) != SD_ENTRY_NULL) \
437	free_start_data_node ((entry)); \
438	MACRO_END
439
440	#else /* ETAP_LOCK_TRACE */
441	#define ETAP_TOTAL_TIME(t,stop,start)
442	#define ETAP_DURATION_TIMESTAMP(le,tr)
443	#define ETAP_CONTENTION_TIMESTAMP(le,tr)
444	#define ETAP_COPY_START_HOLD_TIME(le,t,tr)
445	#define ETAP_STAMP(tt,tr,d)
446	#define ETAP_DURATION_ENABLED(tr) (0) /* always fails */
447	#define ETAP_CONTENTION_ENABLED(tr) (0) /* always fails */
448	#define ETAP_CLEAR_TRACE_DATA(l)
449	#define ETAP_CREATE_ENTRY(e,tr)
450	#define ETAP_LINK_ENTRY(l,e,tr)
451	#define ETAP_FIND_ENTRY(l,e,tr)
452	#define ETAP_UNLINK_ENTRY(l,e)
453	#define ETAP_DESTROY_ENTRY(e)
454	#endif /* ETAP_LOCK_TRACE */
455
456	#endif /* _KERN_ETAP_MACROS_H_ */