rtai_trace.h

rtai-3.1-test3的源代码(Real-Time Application Interface )

/*
 * include/rtai_trace.h
 *
 * Copyright (C) 2000, Karim Yaghmour ([e-mail])
 *
 * This contains the necessary definitions for the RTAI tracer
 */

#ifndef __RTAI_TRACE_H__
#define __RTAI_TRACE_H__

#if defined(CONFIG_RTAI_TRACE)

#include <linux/trace.h>

/* Is RTAI tracing enabled */

/* The functions to the tracer management code */
int rt_register_tracer
       (tracer_call   /* The tracer function */);
int rt_unregister_tracer
       (tracer_call   /* The tracer function */);
#if 0
int rt_trace_event
       (uint8_t       /* Event ID (as defined in this header file) */,
	void*         /* Structure describing the event */);
#endif
#define rt_trace_event(id,ptr) trace_event(id,ptr)

/* Generic macros */
#define RT_TRACE_EVENT(ID, DATA) rt_trace_event(ID, DATA)

#define TRACE_RTAI_START TRACE_EV_MAX

/* Traced events */
#define TRACE_RTAI_EV_MOUNT              TRACE_RTAI_START +  1   /* The RTAI subsystem was mounted */
#define TRACE_RTAI_EV_UMOUNT             TRACE_RTAI_START +  2   /* The RTAI subsystem was unmounted */
#define TRACE_RTAI_EV_GLOBAL_IRQ_ENTRY   TRACE_RTAI_START +  3   /* Entry in a global IRQ */
#define TRACE_RTAI_EV_GLOBAL_IRQ_EXIT    TRACE_RTAI_START +  4   /* Exit from a global IRQ */
#define TRACE_RTAI_EV_OWN_IRQ_ENTRY      TRACE_RTAI_START +  5   /* Entry in a CPU own IRQ */
#define TRACE_RTAI_EV_OWN_IRQ_EXIT       TRACE_RTAI_START +  6   /* Exit from a CPU own IRQ */
#define TRACE_RTAI_EV_TRAP_ENTRY         TRACE_RTAI_START +  7   /* Entry in a trap */
#define TRACE_RTAI_EV_TRAP_EXIT          TRACE_RTAI_START +  8   /* Exit from a trap */
#define TRACE_RTAI_EV_SRQ_ENTRY          TRACE_RTAI_START +  9   /* Entry in a SRQ */
#define TRACE_RTAI_EV_SRQ_EXIT           TRACE_RTAI_START + 10   /* Exit from a SRQ */
#define TRACE_RTAI_EV_SWITCHTO_LINUX     TRACE_RTAI_START + 11   /* Switch a CPU to Linux */
#define TRACE_RTAI_EV_SWITCHTO_RT        TRACE_RTAI_START + 12   /* Switch a CPU to real-time */
#define TRACE_RTAI_EV_SCHED_CHANGE       TRACE_RTAI_START + 13   /* A scheduling change has occured */
#define TRACE_RTAI_EV_TASK               TRACE_RTAI_START + 14   /* Hit key part of task services */
#define TRACE_RTAI_EV_TIMER              TRACE_RTAI_START + 15   /* Hit key part of timer services */
#define TRACE_RTAI_EV_SEM                TRACE_RTAI_START + 16   /* Hit key part of semaphore services */
#define TRACE_RTAI_EV_MSG                TRACE_RTAI_START + 17   /* Hit key part of message services */
#define TRACE_RTAI_EV_RPC                TRACE_RTAI_START + 18   /* Hit key part of RPC services */
#define TRACE_RTAI_EV_MBX                TRACE_RTAI_START + 19   /* Hit key part of mail box services */
#define TRACE_RTAI_EV_FIFO               TRACE_RTAI_START + 20   /* Hit key part of FIFO services */
#define TRACE_RTAI_EV_SHM                TRACE_RTAI_START + 21   /* Hit key part of shared memory services */
#define TRACE_RTAI_EV_POSIX              TRACE_RTAI_START + 22   /* Hit key part of Posix services */
#define TRACE_RTAI_EV_LXRT               TRACE_RTAI_START + 23   /* Hit key part of LXRT services */
#define TRACE_RTAI_EV_LXRTI              TRACE_RTAI_START + 24   /* Hit key part of LXRT-Informed services */

/* Max number of traced events */
#define TRACE_RTAI_EV_MAX               TRACE_RTAI_EV_LXRTI

/* Structures and macros for traced events */
/*  TRACE_RTAI_MOUNT */
#define TRACE_RTAI_MOUNT()    rt_trace_event(TRACE_RTAI_EV_MOUNT, NULL)

/*  TRACE_RTAI_UMOUNT */
#define TRACE_RTAI_UMOUNT()   rt_trace_event(TRACE_RTAI_EV_UMOUNT, NULL)

/*  TRACE_RTAI_GLOBAL_IRQ_ENTRY */
typedef struct _trace_rtai_global_irq_entry
{
  uint8_t  irq_id;      /* IRQ number */
  uint8_t  kernel;      /* Are we executing kernel code */
} LTT_PACKED_STRUCT trace_rtai_global_irq_entry;
#if CONFIG_X86
#define TRACE_RTAI_GLOBAL_IRQ_ENTRY(ID) \
           do \
           {\
           uint32_t                    eflags, xcs; \
           trace_rtai_global_irq_entry irq_entry;\
           irq_entry.irq_id = ID;\
           __asm__ __volatile__("pushfl; pop %0": "=g" (eflags)); \
           __asm__ __volatile__("pushl %%cs; pop %0": "=g" (xcs)); \
           irq_entry.kernel = !((VM_MASK & eflags) || (3 & xcs));\
           rt_trace_event(TRACE_RTAI_EV_GLOBAL_IRQ_ENTRY, &irq_entry);\
           } while(0)
#endif
#if CONFIG_PPC
#define TRACE_RTAI_GLOBAL_IRQ_ENTRY(ID, KERNEL) \
           do \
           {\
           trace_rtai_global_irq_entry irq_entry;\
           irq_entry.irq_id = ID;\
           irq_entry.kernel = KERNEL;\
           rt_trace_event(TRACE_RTAI_EV_GLOBAL_IRQ_ENTRY, &irq_entry);\
           } while(0)
#endif

/*  TRACE_RTAI_GLOBAL_IRQ_EXIT */
#define TRACE_RTAI_GLOBAL_IRQ_EXIT() rt_trace_event(TRACE_RTAI_EV_GLOBAL_IRQ_EXIT, NULL)

/*  TRACE_RTAI_OWN_IRQ_ENTRY */
typedef struct _trace_rtai_own_irq_entry
{
  uint8_t  irq_id;      /* IRQ number */
  uint8_t  kernel;      /* Are we executing kernel code */
} LTT_PACKED_STRUCT trace_rtai_own_irq_entry;
#if CONFIG_X86
#define TRACE_RTAI_OWN_IRQ_ENTRY(ID) \
           do \
           {\
           uint32_t                 eflags, xcs; \
           trace_rtai_own_irq_entry irq_entry;\
           irq_entry.irq_id = ID;\
           __asm__ __volatile__("pushfl; pop %0": "=g" (eflags)); \
           __asm__ __volatile__("pushl %%cs; pop %0": "=g" (xcs)); \
           irq_entry.kernel = !((VM_MASK & eflags) || (3 & xcs));\
           rt_trace_event(TRACE_RTAI_EV_OWN_IRQ_ENTRY, &irq_entry);\
           } while(0)
#endif
#if CONFIG_PPC
#define TRACE_RTAI_OWN_IRQ_ENTRY(ID, KERNEL) \
           do \
           {\
           trace_rtai_own_irq_entry irq_entry;\
           irq_entry.irq_id = ID;\
           irq_entry.kernel = KERNEL;\
           rt_trace_event(TRACE_RTAI_EV_OWN_IRQ_ENTRY, &irq_entry);\
           } while(0)
#endif

/*  TRACE_RTAI_OWN_IRQ_EXIT */
#define TRACE_RTAI_OWN_IRQ_EXIT() rt_trace_event(TRACE_RTAI_EV_OWN_IRQ_EXIT, NULL)

/*  TRACE_RTAI_TRAP_ENTRY */
typedef struct _trace_rtai_trap_entry
{
  uint8_t   trap_id;        /* Trap number */
  uint32_t  address;        /* Address where trap occured */
} LTT_PACKED_STRUCT trace_rtai_trap_entry;
#define TRACE_RTAI_TRAP_ENTRY(ID,ADDR) \
           do \
           {\
           trace_rtai_trap_entry trap_event;\
           trap_event.trap_id = ID;\
           trap_event.address = ADDR; \
           rt_trace_event(TRACE_RTAI_EV_TRAP_ENTRY, &trap_event);\
	   } while(0)
/*
           uint32_t              eip; \
           __asm__ __volatile__("pushl %%ip; pop %0": "=g" (eip)); \
           trap_event.address = eip;\
*/

/*  TRACE_RTAI_TRAP_EXIT */
#define TRACE_RTAI_TRAP_EXIT() rt_trace_event(TRACE_RTAI_EV_TRAP_EXIT, NULL)

/*  TRACE_RTAI_SRQ_ENTRY */
typedef struct _trace_rtai_srq_entry
{
  uint8_t  srq_id;      /* SRQ number */
  uint8_t  kernel;      /* Are we executing kernel code */
} LTT_PACKED_STRUCT trace_rtai_srq_entry;
#if CONFIG_X86
#define TRACE_RTAI_SRQ_ENTRY(ID) \
           do \
           {\
           uint32_t             eflags, xcs; \
           trace_rtai_srq_entry srq_entry;\
           srq_entry.srq_id = ID;\
           __asm__ __volatile__("pushfl; pop %0": "=g" (eflags)); \
           __asm__ __volatile__("pushl %%cs; pop %0": "=g" (xcs)); \
           srq_entry.kernel = !((VM_MASK & eflags) || (3 & xcs));\
           rt_trace_event(TRACE_RTAI_EV_SRQ_ENTRY, &srq_entry);\
           } while(0)
#endif
#if CONFIG_PPC
#define TRACE_RTAI_SRQ_ENTRY(ID) \
           do \
           {\
           trace_rtai_srq_entry srq_entry;\
           srq_entry.srq_id = ID;\
           rt_trace_event(TRACE_RTAI_EV_SRQ_ENTRY, &srq_entry);\
           } while(0)
#endif

/*  TRACE_RTAI_SRQ_EXIT */
#define TRACE_RTAI_SRQ_EXIT() rt_trace_event(TRACE_RTAI_EV_SRQ_EXIT, NULL)

/*  TRACE_RTAI_SWITCHTO_LINUX */
typedef struct _trace_rtai_switchto_linux
{
  uint8_t   cpu_id;         /* The CPUID being switched to Linux */
} LTT_PACKED_STRUCT trace_rtai_switchto_linux;
#define TRACE_RTAI_SWITCHTO_LINUX(ID) \
           do \
           {\
           trace_rtai_switchto_linux switch_event; \
           switch_event.cpu_id = (uint8_t) ID; \
           rt_trace_event(TRACE_RTAI_EV_SWITCHTO_LINUX, &switch_event); \
           } while(0)

/*  TRACE_RTAI_SWITCHTO_RT */
typedef struct _trace_rtai_switchto_rt
{
  uint8_t   cpu_id;         /* The CPUID being switched to RT */
} LTT_PACKED_STRUCT trace_rtai_switchto_rt;
#define TRACE_RTAI_SWITCHTO_RT(ID) \
           do \
           {\
           trace_rtai_switchto_rt switch_event; \
           switch_event.cpu_id = (uint8_t) ID; \
           rt_trace_event(TRACE_RTAI_EV_SWITCHTO_RT, &switch_event); \
           } while(0)

/*  TRACE_RTAI_SCHED_CHANGE */ 
typedef struct _trace_rtai_sched_change
{
  uint32_t  out;         /* Outgoing process */
  uint32_t  in;          /* Incoming process */
  uint32_t  out_state;   /* Outgoing process' state */
} LTT_PACKED_STRUCT trace_rtai_sched_change;
#define TRACE_RTAI_SCHED_CHANGE(OUT, IN, OUT_STATE) \
           do \
           {\
           trace_rtai_sched_change sched_event;\
           sched_event.out       = (uint32_t) OUT;\
           sched_event.in        = (uint32_t) IN;\
           sched_event.out_state = (uint32_t) OUT_STATE; \
           rt_trace_event(TRACE_RTAI_EV_SCHED_CHANGE, &sched_event);\
           } while(0)

/*  TRACE_RTAI_TASK */
#define TRACE_RTAI_EV_TASK_INIT                    1     /* Initialize task */
#define TRACE_RTAI_EV_TASK_DELETE                  2     /* Delete task */
#define TRACE_RTAI_EV_TASK_SIG_HANDLER             3     /* Set signal handler */
#define TRACE_RTAI_EV_TASK_YIELD                   4     /* Yield CPU control */
#define TRACE_RTAI_EV_TASK_SUSPEND                 5     /* Suspend task */
#define TRACE_RTAI_EV_TASK_RESUME                  6     /* Resume task */
#define TRACE_RTAI_EV_TASK_MAKE_PERIOD_RELATIVE    7     /* Make task periodic relative in nanoseconds */
#define TRACE_RTAI_EV_TASK_MAKE_PERIOD             8     /* Make task periodic */
#define TRACE_RTAI_EV_TASK_WAIT_PERIOD             9     /* Wait until the next period */
#define TRACE_RTAI_EV_TASK_BUSY_SLEEP             10     /* Busy sleep */
#define TRACE_RTAI_EV_TASK_SLEEP                  11     /* Sleep */
#define TRACE_RTAI_EV_TASK_SLEEP_UNTIL            12     /* Sleep until */
typedef struct _trace_rtai_task
{
  uint8_t   event_sub_id;  /* Task event ID */
  uint32_t  event_data1;   /* Event data */
  uint64_t  event_data2;   /* Event data 2 */
  uint64_t  event_data3;   /* Event data 3 */
} LTT_PACKED_STRUCT trace_rtai_task;
#define TRACE_RTAI_TASK(ID, DATA1, DATA2, DATA3) \
           do \
           {\
           trace_rtai_task task_event;\
           task_event.event_sub_id = (uint8_t)  ID;\
           task_event.event_data1  = (uint32_t) DATA1; \
           task_event.event_data2  = (uint64_t) DATA2; \
           task_event.event_data3  = (uint64_t) DATA3; \
           rt_trace_event(TRACE_RTAI_EV_TASK, &task_event);\
           } while(0)

/*  TRACE_RTAI_TIMER */
#define TRACE_RTAI_EV_TIMER_REQUEST                1     /* Request timer */
#define TRACE_RTAI_EV_TIMER_FREE                   2     /* Free timer */
#define TRACE_RTAI_EV_TIMER_REQUEST_APIC           3     /* Request APIC timers */
#define TRACE_RTAI_EV_TIMER_APIC_FREE              4     /* Free APIC timers */
#define TRACE_RTAI_EV_TIMER_HANDLE_EXPIRY          5     /* Handle timer expiry */
typedef struct _trace_rtai_timer
{
  uint8_t   event_sub_id;  /* Timer event ID */
  uint32_t  event_data1;   /* Event data 1 */
  uint32_t  event_data2;   /* Event data 2 */
} LTT_PACKED_STRUCT trace_rtai_timer;
#define TRACE_RTAI_TIMER(ID, DATA1, DATA2) \
           do \
           {\
           trace_rtai_timer timer_event; \
           timer_event.event_sub_id = (uint8_t)  ID; \
           timer_event.event_data1  = (uint32_t) DATA1; \
           timer_event.event_data2  = (uint32_t) DATA2; \
           rt_trace_event(TRACE_RTAI_EV_TIMER, &timer_event); \
           } while(0)

/*  TRACE_RTAI_SEM */
#define TRACE_RTAI_EV_SEM_INIT                     1     /* Initialize semaphore */
#define TRACE_RTAI_EV_SEM_DELETE                   2     /* Delete semaphore */
#define TRACE_RTAI_EV_SEM_SIGNAL                   3     /* Signal semaphore */
#define TRACE_RTAI_EV_SEM_WAIT                     4     /* Wait on semaphore */
#define TRACE_RTAI_EV_SEM_WAIT_IF                  5     /* Take semaphore if possible */
#define TRACE_RTAI_EV_SEM_WAIT_UNTIL               6     /* Wait on semaphore until a certain time */
typedef struct _trace_rtai_sem
{
  uint8_t   event_sub_id;  /* Semaphore event ID */
  uint32_t  event_data1;   /* Event data 1 */
  uint64_t  event_data2;   /* Event data 2 */
} LTT_PACKED_STRUCT trace_rtai_sem;
#define TRACE_RTAI_SEM(ID, DATA1, DATA2) \
           do \