/* * (C) Finite State Machine Labs Inc. 1999-2000 <business@fsmlabs.com> * * Released under the terms of GPL 2. * Open RTLinux makes use of a patented process described in * US Patent 5,995,745. Use of this process is governed * by the Open RTLinux Patent License which can be obtained from * www.fsmlabs.com/PATENT or by sending email to * licensequestions@fsmlabs.com */#define RTL_NOWRAP#include <rtl_conf.h>#ifndef CONFIG_RTL_TRACER#error Please enable CONFIG_RTL_TRACER option and copy new rtl.mk to this directory#endif#include <linux/kernel.h>#include <linux/module.h>#include <rtl_sync.h>#include <rtl_time.h>#include <rtl_core.h>#include <rtl_tracer.h>#include <mbuff.h>static unsigned eventmask;static int timestamp;struct rtl_event_descriptor_struct {	unsigned class;} rtl_event_descriptor[RTL_TRACE_MAX_EVENTS];int rtl_trace_seteventclass (int event, unsigned classmask){	if ((unsigned) event >= RTL_TRACE_MAX_EVENTS) {		return -1;	}	rtl_event_descriptor[event].class = classmask;	return 0;}static struct rtl_trace_eventinfo_struct *rtl_trace_event_info = 0;int rtl_trace_seteventname (int event, char *name){	if ((unsigned) event >= RTL_TRACE_MAX_EVENTS) {		return -1;	}	strncpy(rtl_trace_event_info[event].name, name, RTL_TRACER_NAMELEN - 1);	rtl_trace_event_info[event].name[RTL_TRACER_NAMELEN - 1] = 0;	return 0;}unsigned rtl_trace_settracemask (unsigned mask){	unsigned oldmask = eventmask;	eventmask = mask;	rtl_printf("%x\n", eventmask);	return oldmask;}static struct rtl_trace_buffer *buffers;static struct rtl_trace_buffer *cbuf;#define CBUF (*cbuf)static spinlock_t buffspin;static void (*save_rtl_trace)(int event_id, long event_data, void * eip);static int len;static struct rtl_trace_record *cur;static struct rtl_trace_record *ebp;static struct rtl_trace_record *sbp;int rtl_trace_finalize (int id);/* #include <asm/msr.h> */static void rtl_do_trace(int event_id, long event_data, void *eip){	rtl_irqstate_t flags;	static int in_trace = 0;	int cpu = rtl_getcpuid();/*	if ((unsigned) event_id >= RTL_TRACE_MAX_EVENTS) {		return;	} */	if (event_id == RTL_TRACE_FINALIZE) {		rtl_trace_finalize(1);		return;	}	rtl_no_interrupts(flags);	if (test_and_set_bit (cpu, &in_trace)) {		/* an attempt to call rtl_do_trace recursively */		rtl_restore_interrupts (flags);		return;	}	if (rtl_event_descriptor[event_id].class & eventmask) {		spin_lock (&buffspin);		cur->timestamp = gethrtime();/* 		rdtscll(cur->timestamp); */		cur->event_id = event_id;		cur->eip = (long) eip;		cur->event_data = event_data;		cur->cpu = cpu;		++cur;		if (len < RTL_TNRECORDS) {			len ++;		}		if (cur >= ebp) {			cur = sbp;		}				spin_unlock (&buffspin);	}	clear_bit (cpu, &in_trace);	rtl_restore_interrupts (flags);}static inline void init_current_buffer(void){	struct rtl_trace_buffer *buff = &CBUF;	buff->state = 0;	len = 0;	sbp = cur = &(buff->trace[0]);	ebp = sbp + RTL_TNRECORDS;}/*static void start_trace(void){	if (rtl_trace_buffer != rtl_do_trace) {	}}static void stop_trace(void){	rtl_trace_buffer = save_rtl_trace;}*/int rtl_trace_init (void *start){	int i;	for (i = 0; i < RTL_TRACE_MAX_EVENTS; i ++) {		rtl_trace_seteventclass(i, RTL_TRACE_CLASS_DEFAULT);	}	for (i = RTL_TRACE_HARD_CLI; i < RTL_TRACE_SCHED_IN; i++) {		rtl_trace_seteventclass(i, RTL_TRACE_CLASS_INTERRUPTS);	}	for (i = RTL_TRACE_SCHED_IN; i <= RTL_TRACE_SCHED_CTX_SWITCH; i++) {		rtl_trace_seteventclass(i, RTL_TRACE_CLASS_SCHEDULER);	}	rtl_trace_seteventclass(RTL_TRACE_USER, RTL_TRACE_CLASS_USER);	for (i = 0; i < RTL_TRACE_MAX_EVENTS; i ++) {		rtl_trace_seteventname(i, "unknown");	}	rtl_trace_seteventname(RTL_TRACE_HARD_CLI, "hard cli");	rtl_trace_seteventname(RTL_TRACE_HARD_STI, "hard sti");	rtl_trace_seteventname(RTL_TRACE_HARD_SAVE_FLAGS, "rtl_hard_save_flags");	rtl_trace_seteventname(RTL_TRACE_HARD_RESTORE_FLAGS, "rtl_restore_interrupts");	rtl_trace_seteventname(RTL_TRACE_HARD_SAVEF_AND_CLI, "rtl_no_interrupts");	rtl_trace_seteventname(RTL_TRACE_LOCAL_INTERCEPT, "local_intercept entry");	rtl_trace_seteventname(RTL_TRACE_LOCAL_INTERCEPT_EXIT, "local_intercept exit");	rtl_trace_seteventname(RTL_TRACE_USER, "user");	rtl_trace_seteventname(RTL_TRACE_SPIN_LOCK, "rtl_spin_lock");	rtl_trace_seteventname(RTL_TRACE_SPIN_UNLOCK, "rtl_spin_unlock");	rtl_trace_seteventname(RTL_TRACE_INTERCEPT, "rtl_intercept entry");	rtl_trace_seteventname(RTL_TRACE_INTERCEPT_EXIT, "rtl_intercept exit");	rtl_trace_seteventname(RTL_TRACE_SCHED_IN, "scheduler in");	rtl_trace_seteventname(RTL_TRACE_SCHED_OUT, "scheduler out");	rtl_trace_seteventname(RTL_TRACE_SCHED_CTX_SWITCH, "rtl_switch_to");	rtl_trace_seteventname(RTL_TRACE_FINALIZE, "trace finalize");	eventmask = 0xffffffff;	timestamp = 0;	spin_lock_init (&buffspin);	buffers = (struct rtl_trace_buffer *) start;	for (i = 0; i < RTL_TNBUFFERS; i++) {		buffers [i] . state = 0;	}	cbuf = &buffers[0];	init_current_buffer ();	save_rtl_trace = rtl_trace;	rtl_trace = rtl_do_trace;	return 0;}void rtl_trace_destroy (void){	rtl_trace = save_rtl_trace;}/* fails if no more buffers available */int rtl_trace_finalize (int id){	struct rtl_trace_buffer *b;	rtl_irqstate_t flags;	rtl_no_interrupts (flags);	spin_lock (&buffspin);	++timestamp;	for (b = buffers; b < &buffers[RTL_TNBUFFERS]; b ++) {		if (b != cbuf && !b->state) {			break;		}	}		if (b == &buffers[RTL_TNBUFFERS]) {		init_current_buffer (); /* start all over again */		spin_unlock (&buffspin);		rtl_restore_interrupts (flags);		return -1;	}	CBUF.id = id;	CBUF.timestamp = timestamp;	CBUF.len = len;	CBUF.pos = cur - sbp;	mb();	CBUF.state = 1;	cbuf = b;	init_current_buffer ();	spin_unlock (&buffspin);	rtl_restore_interrupts (flags);	return 0;}#ifdef MODULE/* struct rtl_trace_buffer traces[RTL_TNBUFFERS]; */void * shmem_ptr;int init_module(void){	shmem_ptr = mbuff_alloc (RTL_TRACER_SHMEM, sizeof(struct rtl_trace_buffer) * RTL_TNBUFFERS);	if (!shmem_ptr) {		printk("RTLinux Tracer: failed to allocate trace buffer\n");		return -1;	}	rtl_trace_event_info = (struct rtl_trace_eventinfo_struct *) mbuff_alloc (RTL_TRACER_SHMEM_INFO, sizeof(struct rtl_trace_eventinfo_struct) * RTL_TRACE_MAX_EVENTS);	if (!rtl_trace_event_info) {		printk("RTLinux Tracer: failed to allocate event info buffer\n");		mbuff_free (RTL_TRACER_SHMEM, shmem_ptr);		return -1;	}/* 	printk("%x %d\n", (unsigned) shmem_ptr, sizeof(struct rtl_trace_buffer)); */	rtl_trace_init(shmem_ptr);	return 0;}void cleanup_module(void){	rtl_trace_destroy();	mbuff_free (RTL_TRACER_SHMEM, shmem_ptr);	mbuff_free (RTL_TRACER_SHMEM_INFO, (void *) rtl_trace_event_info);}#endif