diff -urN rtai-1.6/Makefile rtai-1.6+trace/Makefile --- rtai-1.6/Makefile Fri Jan 12 07:45:12 2001 +++ rtai-1.6+trace/Makefile Thu Mar 22 12:46:24 2001 @@ -14,7 +14,8 @@ upscheduler smpscheduler mupscheduler \ newfifos \ lxrt lxrt-informed posix shmem \ - utils examples + utils examples \ + trace # The following don't get made any more and are being phased out TO_BE_REMOVED = portable_shm portable_shm/test oldfifos diff -urN rtai-1.6/include/rtai_sched.h rtai-1.6+trace/include/rtai_sched.h --- rtai-1.6/include/rtai_sched.h Tue Nov 21 04:03:30 2000 +++ rtai-1.6+trace/include/rtai_sched.h Thu Mar 22 12:38:20 2001 @@ -74,6 +74,9 @@ int state; unsigned long runnable_on_cpus; int *stack_bottom; +#if 1 + int tid; +#endif int priority; int base_priority; RTIME period; diff -urN rtai-1.6/include/rtai_trace.h rtai-1.6+trace/include/rtai_trace.h --- rtai-1.6/include/rtai_trace.h Wed Dec 31 18:00:00 1969 +++ rtai-1.6+trace/include/rtai_trace.h Thu Mar 22 12:38:20 2001 @@ -0,0 +1,559 @@ +/* + * include/rtai_trace.h + * + * Copyright (C) 2000, Karim Yaghmour (karym@opersys.com) + * + * This contains the necessary definitions for the RTAI tracer + */ + +#include + +/* Is RTAI tracing enabled */ +#if defined(CONFIG_RTAI_TRACE) + +/* 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 */); +int rt_trace_event + (uint8_t /* Event ID (as defined in this header file) */, + void* /* Structure describing the event */); + +/* Generic macros */ +#define RT_TRACE_EVENT(ID, DATA) rt_trace_event(ID, DATA) + +/* Traced events */ +#define TRACE_RTAI_EV_MOUNT TRACE_EV_MAX + 1 /* The RTAI subsystem was mounted */ +#define TRACE_RTAI_EV_UMOUNT TRACE_EV_MAX + 2 /* The RTAI subsystem was unmounted */ +#define TRACE_RTAI_EV_GLOBAL_IRQ_ENTRY TRACE_EV_MAX + 3 /* Entry in a global IRQ */ +#define TRACE_RTAI_EV_GLOBAL_IRQ_EXIT TRACE_EV_MAX + 4 /* Exit from a global IRQ */ +#define TRACE_RTAI_EV_OWN_IRQ_ENTRY TRACE_EV_MAX + 5 /* Entry in a CPU own IRQ */ +#define TRACE_RTAI_EV_OWN_IRQ_EXIT TRACE_EV_MAX + 6 /* Exit from a CPU own IRQ */ +#define TRACE_RTAI_EV_TRAP_ENTRY TRACE_EV_MAX + 7 /* Entry in a trap */ +#define TRACE_RTAI_EV_TRAP_EXIT TRACE_EV_MAX + 8 /* Exit from a trap */ +#define TRACE_RTAI_EV_SRQ_ENTRY TRACE_EV_MAX + 9 /* Entry in a SRQ */ +#define TRACE_RTAI_EV_SRQ_EXIT TRACE_EV_MAX + 10 /* Exit from a SRQ */ +#define TRACE_RTAI_EV_SWITCHTO_LINUX TRACE_EV_MAX + 11 /* Switch a CPU to Linux */ +#define TRACE_RTAI_EV_SWITCHTO_RT TRACE_EV_MAX + 12 /* Switch a CPU to real-time */ +#define TRACE_RTAI_EV_SCHED_CHANGE TRACE_EV_MAX + 13 /* A scheduling change has occured */ +#define TRACE_RTAI_EV_TASK TRACE_EV_MAX + 14 /* Hit key part of task services */ +#define TRACE_RTAI_EV_TIMER TRACE_EV_MAX + 15 /* Hit key part of timer services */ +#define TRACE_RTAI_EV_SEM TRACE_EV_MAX + 16 /* Hit key part of semaphore services */ +#define TRACE_RTAI_EV_MSG TRACE_EV_MAX + 17 /* Hit key part of message services */ +#define TRACE_RTAI_EV_RPC TRACE_EV_MAX + 18 /* Hit key part of RPC services */ +#define TRACE_RTAI_EV_MBX TRACE_EV_MAX + 19 /* Hit key part of mail box services */ +#define TRACE_RTAI_EV_FIFO TRACE_EV_MAX + 20 /* Hit key part of FIFO services */ +#define TRACE_RTAI_EV_SHM TRACE_EV_MAX + 21 /* Hit key part of shared memory services */ +#define TRACE_RTAI_EV_POSIX TRACE_EV_MAX + 22 /* Hit key part of Posix services */ +#define TRACE_RTAI_EV_LXRT TRACE_EV_MAX + 23 /* Hit key part of LXRT services */ +#define TRACE_RTAI_EV_LXRTI TRACE_EV_MAX + 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 : 6; /* IRQ number 2^6 = 64 */ + uint8_t unused : 1; /* This isn't used for now */ + uint8_t kernel : 1; /* Are we executing kernel code */ +} trace_rtai_global_irq_entry; +#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); + +/* 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 : 6; /* IRQ number 2^6 = 64 */ + uint8_t unused : 1; /* This isn't used for now */ + uint8_t kernel : 1; /* Are we executing kernel code */ +} trace_rtai_own_irq_entry; +#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); + +/* 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 */ +} trace_rtai_trap_entry; +#define TRACE_RTAI_TRAP_ENTRY(ID) \ + do \ + {\ + trace_rtai_trap_entry trap_event;\ + trap_event.trap_id = ID;\ + trap_event.address = 0; \ + rt_trace_event(TRACE_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 : 6; /* SRQ number 2^6 = 64 */ + uint8_t unused : 1; /* This isn't used for now */ + uint8_t kernel : 1; /* Are we executing kernel code */ +} trace_rtai_srq_entry; +#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); + +/* 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 */ +} 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 */ +} 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 */ +} 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 */ +} 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 */ +} 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 */ +} trace_rtai_sem; +#define TRACE_RTAI_SEM(ID, DATA1, DATA2) \ + do \ + {\ + trace_rtai_sem sem_event; \ + sem_event.event_sub_id = (uint8_t) ID; \ + sem_event.event_data1 = (uint32_t) DATA1; \ + sem_event.event_data2 = (uint64_t) DATA2; \ + rt_trace_event(TRACE_RTAI_EV_SEM, &sem_event); \ + } while(0); + +/* TRACE_RTAI_MSG */ +#define TRACE_RTAI_EV_MSG_SEND 1 /* Send a message */ +#define TRACE_RTAI_EV_MSG_SEND_IF 2 /* Send if possible */ +#define TRACE_RTAI_EV_MSG_SEND_UNTIL 3 /* Try sending until a certain time */ +#define TRACE_RTAI_EV_MSG_RECV 4 /* Receive a message */ +#define TRACE_RTAI_EV_MSG_RECV_IF 5 /* Receive if possible */ +#define TRACE_RTAI_EV_MSG_RECV_UNTIL 6 /* Try receiving until a certain time */ +typedef struct _trace_rtai_msg +{ + uint8_t event_sub_id; /* Message event ID */ + uint32_t event_data1; /* Event data 1 */ + uint32_t event_data2; /* Event data 2 */ + uint64_t event_data3; /* Event data 3 */ +} trace_rtai_msg; +#define TRACE_RTAI_MSG(ID, DATA1, DATA2, DATA3) \ + do \ + {\ + trace_rtai_msg msg_event; \ + msg_event.event_sub_id = (uint8_t) ID; \ + msg_event.event_data1 = (uint32_t) DATA1; \ + msg_event.event_data2 = (uint32_t) DATA2; \ + msg_event.event_data3 = (uint64_t) DATA3; \ + rt_trace_event(TRACE_RTAI_EV_MSG, &msg_event); \ + } while(0); + +/* TRACE_RTAI_RPC */ +#define TRACE_RTAI_EV_RPC_MAKE 1 /* Make a remote procedure call */ +#define TRACE_RTAI_EV_RPC_MAKE_IF 2 /* Make RPC if receiver is ready */ +#define TRACE_RTAI_EV_RPC_MAKE_UNTIL 3 /* Try making an RPC until a certain time */ +#define TRACE_RTAI_EV_RPC_RETURN 4 /* Send result of RPC back to caller */ +typedef struct _trace_rtai_rpc +{ + uint8_t event_sub_id; /* RPC event ID */ + uint32_t event_data1; /* Event data 1 */ + uint32_t event_data2; /* Event data 2 */ + uint64_t event_data3; /* Event data 3 */ +} trace_rtai_rpc; +#define TRACE_RTAI_RPC(ID, DATA1, DATA2, DATA3) \ + do \ + {\ + trace_rtai_rpc rpc_event; \ + rpc_event.event_sub_id = (uint8_t) ID; \ + rpc_event.event_data1 = (uint32_t) DATA1; \ + rpc_event.event_data2 = (uint32_t) DATA2; \ + rpc_event.event_data3 = (uint64_t) DATA3; \ + rt_trace_event(TRACE_RTAI_EV_RPC, &rpc_event); \ + } while(0); + +/* TRACE_RTAI_MBX */ +#define TRACE_RTAI_EV_MBX_INIT 1 /* Initialize Message BoX */ +#define TRACE_RTAI_EV_MBX_DELETE 2 /* Delete message box */ +#define TRACE_RTAI_EV_MBX_SEND 3 /* Send a message to a message box */ +#define TRACE_RTAI_EV_MBX_SEND_WP 4 /* Send as many bytes as possible */ +#define TRACE_RTAI_EV_MBX_SEND_IF 5 /* Send a message if possible */ +#define TRACE_RTAI_EV_MBX_SEND_UNTIL 6 /* Try sending until a certain time */ +#define TRACE_RTAI_EV_MBX_RECV 7 /* Receive a message */ +#define TRACE_RTAI_EV_MBX_RECV_WP 8 /* Receive as many bytes as possible */ +#define TRACE_RTAI_EV_MBX_RECV_IF 9 /* Receive a message if available */ +#define TRACE_RTAI_EV_MBX_RECV_UNTIL 10 /* Try receiving until a certain time */ +typedef struct _trace_rtai_mbx +{ + uint8_t event_sub_id; /* Message Box event ID */ + uint32_t event_data1; /* Event data 1 */ + uint32_t event_data2; /* Event data 2 */ + uint64_t event_data3; /* Event data 3 */ +} trace_rtai_mbx; +#define TRACE_RTAI_MBX(ID, DATA1, DATA2, DATA3) \ + do \ + {\ + trace_rtai_mbx mbx_event; \ + mbx_event.event_sub_id = (uint8_t) ID; \ + mbx_event.event_data1 = (uint32_t) DATA1; \ + mbx_event.event_data2 = (uint32_t) DATA2; \ + mbx_event.event_data3 = (uint64_t) DATA3; \ + rt_trace_event(TRACE_RTAI_EV_MBX, &mbx_event); \ + } while(0); + +/* TRACE_RTAI_FIFO */ +#define TRACE_RTAI_EV_FIFO_CREATE 1 /* Create FIFO */ +#define TRACE_RTAI_EV_FIFO_DESTROY 2 /* Destroy FIFO */ +#define TRACE_RTAI_EV_FIFO_RESET 3 /* Reset FIFO */ +#define TRACE_RTAI_EV_FIFO_RESIZE 4 /* Resize FIFO */ +#define TRACE_RTAI_EV_FIFO_PUT 5 /* Write data to FIFO */ +#define TRACE_RTAI_EV_FIFO_GET 6 /* Get data from FIFO */ +#define TRACE_RTAI_EV_FIFO_CREATE_HANDLER 7 /* Install FIFO handler */ +#define TRACE_RTAI_EV_FIFO_OPEN 8 /* Open FIFO */ +#define TRACE_RTAI_EV_FIFO_RELEASE 9 /* Release FIFO */ +#define TRACE_RTAI_EV_FIFO_READ 10 /* Read from FIFO */ +#define TRACE_RTAI_EV_FIFO_WRITE 11 /* Write to FIFO */ +#define TRACE_RTAI_EV_FIFO_READ_TIMED 12 /* Read with time limit */ +#define TRACE_RTAI_EV_FIFO_WRITE_TIMED 13 /* Write with time limit */ +#define TRACE_RTAI_EV_FIFO_READ_ALLATONCE 14 /* Read all the data from FIFO */ +#define TRACE_RTAI_EV_FIFO_LLSEEK 15 /* Seek position into FIFO */ +#define TRACE_RTAI_EV_FIFO_FASYNC 16 /* Asynchronous notification */ +#define TRACE_RTAI_EV_FIFO_IOCTL 17 /* IO control on FIFO */ +#define TRACE_RTAI_EV_FIFO_POLL 18 /* Poll FIFO */ +#define TRACE_RTAI_EV_FIFO_SUSPEND_TIMED 19 /* Suspend task for given period */ +#define TRACE_RTAI_EV_FIFO_SET_ASYNC_SIG 20 /* Set asynchrounous signal */ +#define TRACE_RTAI_EV_FIFO_SEM_INIT 21 /* Initialize semaphore */ +#define TRACE_RTAI_EV_FIFO_SEM_POST 22 /* Post semaphore */ +#define TRACE_RTAI_EV_FIFO_SEM_WAIT 23 /* Wait on semaphore */ +#define TRACE_RTAI_EV_FIFO_SEM_TRY_WAIT 24 /* Try waiting on semaphore */ +#define TRACE_RTAI_EV_FIFO_SEM_TIMED_WAIT 25 /* Wait on semaphore until a certain time */ +#define TRACE_RTAI_EV_FIFO_SEM_DESTROY 26 /* Destroy semaphore */ +typedef struct _trace_rtai_fifo +{ + uint8_t event_sub_id; /* FIFO event ID */ + uint32_t event_data1; /* Event data 1 */ + uint32_t event_data2; /* Event data 2 */ +} trace_rtai_fifo; +#define TRACE_RTAI_FIFO(ID, DATA1, DATA2) \ + do \ + {\ + trace_rtai_fifo fifo_event; \ + fifo_event.event_sub_id = (uint8_t) ID; \ + fifo_event.event_data1 = (uint32_t) DATA1; \ + fifo_event.event_data2 = (uint32_t) DATA2; \ + rt_trace_event(TRACE_RTAI_EV_FIFO, &fifo_event); \ + } while(0); + +/* TRACE_RTAI_SHM */ +#define TRACE_RTAI_EV_SHM_MALLOC 1 /* Allocate shared memory */ +#define TRACE_RTAI_EV_SHM_KMALLOC 2 /* Allocate shared memory in kernel space */ +#define TRACE_RTAI_EV_SHM_GET_SIZE 3 /* Get the size of the shared memory area */ +#define TRACE_RTAI_EV_SHM_FREE 4 /* Free shared memory */ +#define TRACE_RTAI_EV_SHM_KFREE 5 /* Free kernel space shared memory */ +typedef struct _trace_rtai_shm +{ + uint8_t event_sub_id; /* SHared Memory event ID */ + uint32_t event_data1; /* Event data 1 */ + uint32_t event_data2; /* Event data 2 */ + uint32_t event_data3; /* Event data 3 */ +} trace_rtai_shm; +#define TRACE_RTAI_SHM(ID, DATA1, DATA2, DATA3) \ + do \ + {\ + trace_rtai_shm shm_event; \ + shm_event.event_sub_id = (uint8_t) ID; \ + shm_event.event_data1 = (uint32_t) DATA1; \ + shm_event.event_data2 = (uint32_t) DATA2; \ + shm_event.event_data3 = (uint32_t) DATA3; \ + rt_trace_event(TRACE_RTAI_EV_SHM, &shm_event); \ + } while(0); + +/* TRACE_RTAI_POSIX */ +#define TRACE_RTAI_EV_POSIX_MQ_OPEN 1 /* Open/create message queue */ +#define TRACE_RTAI_EV_POSIX_MQ_CLOSE 2 /* Close message queue */ +#define TRACE_RTAI_EV_POSIX_MQ_SEND 3 /* Send message to queue */ +#define TRACE_RTAI_EV_POSIX_MQ_RECV 4 /* Receive message from queue */ +#define TRACE_RTAI_EV_POSIX_MQ_GET_ATTR 5 /* Get message queue attributes */ +#define TRACE_RTAI_EV_POSIX_MQ_SET_ATTR 6 /* Set message queue attributes */ +#define TRACE_RTAI_EV_POSIX_MQ_NOTIFY 7 /* Register to be notified of message arrival */ +#define TRACE_RTAI_EV_POSIX_MQ_UNLINK 8 /* Destroy message queue */ +#define TRACE_RTAI_EV_POSIX_PTHREAD_CREATE 9 /* Create RT task */ +#define TRACE_RTAI_EV_POSIX_PTHREAD_EXIT 10 /* Terminate calling thread */ +#define TRACE_RTAI_EV_POSIX_PTHREAD_SELF 11 /* Get thread ID */ +#define TRACE_RTAI_EV_POSIX_PTHREAD_ATTR_INIT 12 /* Initialize thread attribute */ +#define TRACE_RTAI_EV_POSIX_PTHREAD_ATTR_DESTROY 13 /* Destroy thread attribute */ +#define TRACE_RTAI_EV_POSIX_PTHREAD_ATTR_SETDETACHSTATE 14 /* Set detach state of thread */ +#define TRACE_RTAI_EV_POSIX_PTHREAD_ATTR_GETDETACHSTATE 15 /* Get detach state of thread */ +#define TRACE_RTAI_EV_POSIX_PTHREAD_ATTR_SETSCHEDPARAM 16 /* Set thread scheduling parameters */ +#define TRACE_RTAI_EV_POSIX_PTHREAD_ATTR_GETSCHEDPARAM 17 /* Get thread scheduling parameters */ +#define TRACE_RTAI_EV_POSIX_PTHREAD_ATTR_SETSCHEDPOLICY 18 /* Set thread scheduling policy */ +#define TRACE_RTAI_EV_POSIX_PTHREAD_ATTR_GETSCHEDPOLICY 19 /* Get thread scheduling policy */ +#define TRACE_RTAI_EV_POSIX_PTHREAD_ATTR_SETINHERITSCHED 20 /* Set thread scheduling inheritance */ +#define TRACE_RTAI_EV_POSIX_PTHREAD_ATTR_GETINHERITSCHED 21 /* Get thread scheduling inheritance */ +#define TRACE_RTAI_EV_POSIX_PTHREAD_ATTR_SETSCOPE 22 /* Set thread scheduling scope */ +#define TRACE_RTAI_EV_POSIX_PTHREAD_ATTR_GETSCOPE 23 /* Get thread scheduling scope */ +#define TRACE_RTAI_EV_POSIX_PTHREAD_SCHED_YIELD 24 /* Yield processor control */ +#define TRACE_RTAI_EV_POSIX_PTHREAD_CLOCK_GETTIME 25 /* Get current clock count */ +#define TRACE_RTAI_EV_POSIX_PTHREAD_MUTEX_INIT 26 /* Initialize mutex */ +#define TRACE_RTAI_EV_POSIX_PTHREAD_MUTEX_DESTROY 27 /* Destroy mutex */ +#define TRACE_RTAI_EV_POSIX_PTHREAD_MUTEXATTR_INIT 28 /* Initiatize mutex attribute */ +#define TRACE_RTAI_EV_POSIX_PTHREAD_MUTEXATTR_DESTROY 29 /* Destroy mutex attribute */ +#define TRACE_RTAI_EV_POSIX_PTHREAD_MUTEXATTR_SETKIND_NP 30 /* Set kind of attribute */ +#define TRACE_RTAI_EV_POSIX_PTHREAD_MUTEXATTR_GETKIND_NP 31 /* Get kind of attribute */ +#define TRACE_RTAI_EV_POSIX_PTHREAD_SETSCHEDPARAM 32 /* Set scheduling parameters */ +#define TRACE_RTAI_EV_POSIX_PTHREAD_GETSCHEDPARAM 33 /* Get scheduling parameters */ +#define TRACE_RTAI_EV_POSIX_PTHREAD_MUTEX_TRY_LOCK 34 /* Non-blocking mutex lock */ +#define TRACE_RTAI_EV_POSIX_PTHREAD_MUTEX_LOCK 35 /* Blocking mutex lock */ +#define TRACE_RTAI_EV_POSIX_PTHREAD_MUTEX_UNLOCK 36 /* Mutex unlock */ +#define TRACE_RTAI_EV_POSIX_PTHREAD_COND_INIT 37 /* Initialize conditionnal variable */ +#define TRACE_RTAI_EV_POSIX_PTHREAD_COND_DESTROY 38 /* Destroy cond. variable */ +#define TRACE_RTAI_EV_POSIX_PTHREAD_CONDATTR_INIT 39 /* Initialize cond. attribute variable */ +#define TRACE_RTAI_EV_POSIX_PTHREAD_CONDATTR_DESTROY 40 /* Destroy cond. attribute variable */ +#define TRACE_RTAI_EV_POSIX_PTHREAD_COND_WAIT 41 /* Wait for cond. variable to be signaled */ +#define TRACE_RTAI_EV_POSIX_PTHREAD_COND_TIMEDWAIT 42 /* Wait for a certain time */ +#define TRACE_RTAI_EV_POSIX_PTHREAD_COND_SIGNAL 43 /* Signal a waiting thread */ +#define TRACE_RTAI_EV_POSIX_PTHREAD_COND_BROADCAST 44 /* Signal all waiting threads */ +typedef struct _trace_rtai_posix +{ + uint8_t event_sub_id; /* POSIX event ID */ + uint32_t event_data1; /* Event data 1 */ + uint32_t event_data2; /* Event data 2 */ + uint32_t event_data3; /* Event data 3 */ +} trace_rtai_posix; +#define TRACE_RTAI_POSIX(ID, DATA1, DATA2, DATA3) \ + do \ + {\ + trace_rtai_posix posix_event; \ + posix_event.event_sub_id = (uint8_t) ID; \ + posix_event.event_data1 = (uint32_t) DATA1; \ + posix_event.event_data2 = (uint32_t) DATA2; \ + posix_event.event_data3 = (uint32_t) DATA3; \ + rt_trace_event(TRACE_RTAI_EV_POSIX, &posix_event); \ + } while(0); + +/* TRACE_RTAI_LXRT */ +#define TRACE_RTAI_EV_LXRT_RTAI_SYSCALL_ENTRY 1 /* Entry in LXRT syscall */ +#define TRACE_RTAI_EV_LXRT_RTAI_SYSCALL_EXIT 2 /* Exit from LXRT syscall */ +#define TRACE_RTAI_EV_LXRT_SCHED_CHANGE 3 /* Scheduling change */ +#define TRACE_RTAI_EV_LXRT_STEAL_TASK 4 /* Take task control from Linux */ +#define TRACE_RTAI_EV_LXRT_GIVE_BACK_TASK 5 /* Give task control back to Linux */ +#define TRACE_RTAI_EV_LXRT_SUSPEND 6 /* Suspend a task */ +#define TRACE_RTAI_EV_LXRT_RESUME 7 /* Resume task's execution */ +#define TRACE_RTAI_EV_LXRT_HANDLE 8 /* Handle a request for an RTAI service */ +typedef struct _trace_rtai_lxrt +{ + uint8_t event_sub_id; /* LXRT event ID */ + uint32_t event_data1; /* Event data 1 */ + uint32_t event_data2; /* Event data 2 */ + uint32_t event_data3; /* Event data 3 */ +} trace_rtai_lxrt; +#define TRACE_RTAI_LXRT(ID, DATA1, DATA2, DATA3) \ + do \ + {\ + trace_rtai_lxrt lxrt_event; \ + lxrt_event.event_sub_id = (uint8_t) ID; \ + lxrt_event.event_data1 = (uint32_t) DATA1; \ + lxrt_event.event_data2 = (uint32_t) DATA2; \ + lxrt_event.event_data3 = (uint32_t) DATA3; \ + rt_trace_event(TRACE_RTAI_EV_LXRT, &lxrt_event); \ + } while(0); + +/* TRACE_RTAI_LXRTI */ +#define TRACE_RTAI_EV_LXRTI_NAME_ATTACH 1 /* Register current process as name */ +#define TRACE_RTAI_EV_LXRTI_NAME_LOCATE 2 /* Locate a given process usint it's name */ +#define TRACE_RTAI_EV_LXRTI_NAME_DETACH 3 /* Detach process from name */ +#define TRACE_RTAI_EV_LXRTI_SEND 4 /* Send message to PID */ +#define TRACE_RTAI_EV_LXRTI_RECV 5 /* Receive message */ +#define TRACE_RTAI_EV_LXRTI_CRECV 6 /* Non-blocking receive */ +#define TRACE_RTAI_EV_LXRTI_REPLY 7 /* Reply to message received */ +#define TRACE_RTAI_EV_LXRTI_PROXY_ATTACH 8 /* Attach proxy to process */ +#define TRACE_RTAI_EV_LXRTI_PROXY_DETACH 9 /* Detach proxy from process */ +#define TRACE_RTAI_EV_LXRTI_TRIGGER 10 /* Trigger proxy */ +typedef struct _trace_rtai_lxrti +{ + uint8_t event_sub_id; /* LXRT event ID */ + uint32_t event_data1; /* Event data 1 */ + uint32_t event_data2; /* Event data 2 */ + uint64_t event_data3; /* Event data 3 */ +} trace_rtai_lxrti; +#define TRACE_RTAI_LXRTI(ID, DATA1, DATA2, DATA3) \ + do \ + {\ + trace_rtai_lxrti lxrti_event; \ + lxrti_event.event_sub_id = (uint8_t) ID; \ + lxrti_event.event_data1 = (uint32_t) DATA1; \ + lxrti_event.event_data2 = (uint32_t) DATA2; \ + lxrti_event.event_data3 = (uint64_t) DATA3; \ + rt_trace_event(TRACE_RTAI_EV_LXRTI, &lxrti_event); \ + } while(0); + +#else /* RTAI is configured without tracing */ +#define RT_TRACE_EVENT(ID, DATA) +#define TRACE_RTAI_MOUNT() +#define TRACE_RTAI_UMOUNT() +#define TRACE_RTAI_GLOBAL_IRQ_ENTRY(ID) +#define TRACE_RTAI_GLOBAL_IRQ_EXIT() +#define TRACE_RTAI_OWN_IRQ_ENTRY(ID) +#define TRACE_RTAI_OWN_IRQ_EXIT() +#define TRACE_RTAI_TRAP_ENTRY(ID) +#define TRACE_RTAI_TRAP_EXIT() +#define TRACE_RTAI_SRQ_ENTRY() +#define TRACE_RTAI_SRQ_EXIT() +#define TRACE_RTAI_SWITCHTO_LINUX(ID) +#define TRACE_RTAI_SWITCHTO_RT(ID) +#define TRACE_RTAI_SCHED_CHANGE(OUT, IN, OUT_STATE) +#define TRACE_RTAI_TASK(ID, DATA1, DATA2, DATA3) +#define TRACE_RTAI_TIMER(ID, DATA1, DATA2) +#define TRACE_RTAI_SEM(ID, DATA1, DATA2) +#define TRACE_RTAI_MSG(ID, DATA1, DATA2, DATA3) +#define TRACE_RTAI_RPC(ID, DATA1, DATA2, DATA3) +#define TRACE_RTAI_MBX(ID, DATA1, DATA2, DATA3) +#define TRACE_RTAI_FIFO(ID, DATA1, DATA2) +#define TRACE_RTAI_SHM(ID, DATA1, DATA2, DATA3) +#define TRACE_RTAI_POSIX(ID, DATA1, DATA2, DATA3) +#define TRACE_RTAI_LXRT(ID, DATA1, DATA2, DATA3) +#define TRACE_RTAI_LXRTI(ID, DATA1, DATA2, DATA3) +#endif diff -urN rtai-1.6/lxrt/lxrt.c rtai-1.6+trace/lxrt/lxrt.c --- rtai-1.6/lxrt/lxrt.c Tue Nov 21 03:40:13 2000 +++ rtai-1.6+trace/lxrt/lxrt.c Thu Mar 22 12:38:20 2001 @@ -41,6 +41,8 @@ #include #include "rtai_lxrt.h" +#include + #define __STR(x) #x #define STR(x) __STR(x) @@ -283,6 +285,19 @@ // we are doing and there will be no problem going MUP. Note that the SMP-MUP // choice here is completly independent from the RTAI MP scheduler in use. // Whatever the final choice UP operation will not be effected. + +/****************************************************************************/ +/* Trace functions. These functions have to be used rather than insert +the macros as-is. Otherwise the system crashes ... You've been warned. K.Y. */ +void trace_true_lxrt_rtai_syscall_entry(void) +{ + TRACE_RTAI_LXRT(TRACE_RTAI_EV_LXRT_RTAI_SYSCALL_ENTRY, 0, 0, 0); +} +void trace_true_lxrt_rtai_syscall_exit(void) +{ + TRACE_RTAI_LXRT(TRACE_RTAI_EV_LXRT_RTAI_SYSCALL_EXIT, 0, 0, 0); +} +/****************************************************************************/ static void rtai_lxrt_handler(void) { @@ -291,12 +306,16 @@ cld; pushl %es; pushl %ds; pushl %eax; pushl %ebp;\n\t \ pushl %edi; pushl %esi; pushl %edx; pushl %ecx;\n\t \ pushl %ebx; pushl %edx; pushl %eax;\n\t \ - movl $" STR(__KERNEL_DS) ",%ebx; mov %bx,%ds; mov %bx,%es\n\t \ - call "SYMBOL_NAME_STR(lxrt_handler)"\n\t \ - addl $8,%esp; movl %edx,8(%esp); movl %eax,24(%esp)"); + movl $" STR(__KERNEL_DS) ",%ebx; mov %bx,%ds; mov %bx,%es"); + + __asm__ __volatile__ ("call "SYMBOL_NAME_STR(trace_true_lxrt_rtai_syscall_entry)); + __asm__ __volatile__ ("call "SYMBOL_NAME_STR(lxrt_handler)); + __asm__ __volatile__ ("addl $8,%esp; movl %edx,8(%esp); movl %eax,24(%esp)"); + + __asm__ __volatile__ ("call "SYMBOL_NAME_STR(trace_true_lxrt_rtai_syscall_exit)); __asm__ __volatile__ (" \ - testl %%eax,%%eax; jz 1f; popl %%ebx; popl %%ecx;\n\t \ + testl %%eax,%%eax; jz 1f; popl %%ebx; popl %%ecx;\n\t \ popl %%edx; popl %%esi; popl %%edi; popl %%ebp;\n\t \ popl %%eax; popl %%ds; popl %%es; addl $4,%%esp; iret;\n\t \ 1: jmp *"SYMBOL_NAME_STR(rthal + 60) @@ -346,6 +365,10 @@ new_task->run_on = 1 << cpuid; } // if (new_task->lnxtsk.task) { + TRACE_RTAI_LXRT(TRACE_RTAI_EV_LXRT_SCHED_CHANGE, + prev->pid, + new_task->lnxtsk.task->pid, + prev->state); my_switch_to(prev, new_task->lnxtsk.task, prev); // } else { // rtai_print_to_screen("SCHEDNULL\n"); @@ -448,8 +471,12 @@ if ((rt_task->lnxtsk.task)->state == TASK_LXRT_OWNED) { return; } + exec_sigfun = 1; rt_global_cli(); + + TRACE_RTAI_LXRT(TRACE_RTAI_EV_LXRT_STEAL_TASK, rt_task->lnxtsk.task->pid, 0, 0); + if (!nr_linux_rt_process++) { rthal.lxrt_cli = linux_lxrt_cli; } @@ -507,11 +534,15 @@ if ((rt_task->lnxtsk.task)->state != TASK_LXRT_OWNED) { return; } + // lxrt_tq_giveb.next = 0; // lxrt_tq_giveb.sync = 0; // lxrt_tq_giveb.routine = lxrt_do_give_back; lxrt_tq_giveb.data = rt_task; rt_global_cli(); + + TRACE_RTAI_LXRT(TRACE_RTAI_EV_LXRT_GIVE_BACK_TASK, rt_task->lnxtsk.task->pid, 0, 0); + if (nr_linux_rt_process > 0) { nr_linux_rt_process--; } @@ -557,6 +588,9 @@ __asm__ __volatile__ ("" : "=A" (rt_task->retval) ); rt_global_cli(); + + TRACE_RTAI_LXRT(TRACE_RTAI_EV_LXRT_SUSPEND, rt_task->lnxtsk.task->pid, 0, 0); + state = (rt_task->lnxtsk.task)->state; if (state == TASK_LXRT_OWNED) { rt_task->pstate = READY; @@ -587,6 +621,15 @@ memcpy(rt_task->stack_top, arg, narg*sizeof(int)); + if(rt_task->lnxtsk.task != NULL) + { + TRACE_RTAI_LXRT(TRACE_RTAI_EV_LXRT_RESUME, rt_task->lnxtsk.task->pid, type, 0); + } + else + { + TRACE_RTAI_LXRT(TRACE_RTAI_EV_LXRT_RESUME, -1, type, 0); + } + /* Here type > 0 means any messaging with the need of copying from/to user space. My knowledge of Linux memory menagment has led to this mess. Whoever can do it better is warmly welcomed. */ @@ -636,6 +679,8 @@ union {unsigned long name; RT_TASK *rt_task; SEM *sem; MBX *mbx; } arg0; unsigned long name; int srq; + + TRACE_RTAI_LXRT(TRACE_RTAI_EV_LXRT_HANDLE, SRQ(lxsrq), 0, 0); arg0.name = *((unsigned long *)arg); diff -urN rtai-1.6/lxrt-informed/lxrt-inf.c rtai-1.6+trace/lxrt-informed/lxrt-inf.c --- rtai-1.6/lxrt-informed/lxrt-inf.c Fri Jun 30 12:27:03 2000 +++ rtai-1.6+trace/lxrt-informed/lxrt-inf.c Thu Mar 22 12:38:20 2001 @@ -35,6 +35,8 @@ #include #include +#include + #include "names.h" #include "proxies.h" #include "msg.h" @@ -67,6 +69,19 @@ * */ +/****************************************************************************/ +/* Trace functions. These functions have to be used rather than insert +the macros as-is. Otherwise the system crashes ... You've been warned. K.Y. */ +void trace_true_lxrt_rtai_syscall_entry(void) +{ + TRACE_RTAI_LXRT(TRACE_RTAI_EV_LXRT_RTAI_SYSCALL_ENTRY, 0, 0, 0); +} +void trace_true_lxrt_rtai_syscall_exit(void) +{ + TRACE_RTAI_LXRT(TRACE_RTAI_EV_LXRT_RTAI_SYSCALL_EXIT, 0, 0, 0); +} +/****************************************************************************/ + static void rtai_lxrt_handler(void) { __asm__ __volatile__ (" \ @@ -76,11 +91,14 @@ pushl %ebx; pushl %edx; pushl %eax;\n\t \ movl $" STR(__KERNEL_DS) ",%ebx; mov %bx,%ds; mov %bx,%es"); + __asm__ __volatile__ ("call "SYMBOL_NAME_STR(trace_true_lxrt_rtai_syscall_entry)); __asm__ __volatile__ ("call "SYMBOL_NAME_STR(lxrt_handler)); - __asm__ __volatile__ (" \ - addl $8,%esp; movl %edx,8(%esp); movl %eax,24(%esp);\n\t \ - jmp *"SYMBOL_NAME_STR(rthal + 60)); + __asm__ __volatile__ ("addl $8,%esp; movl %edx,8(%esp); movl %eax,24(%esp)"); + + __asm__ __volatile__ ("call "SYMBOL_NAME_STR(trace_true_lxrt_rtai_syscall_exit)); + + __asm__ __volatile__ ("jmp *"SYMBOL_NAME_STR(rthal + 60)); } /* The macro below must be >= the max number of all objects to be @@ -257,9 +275,12 @@ static void lxrt_suspend(ARGS args) { #define rt_task ((RT_TASK *)(args.args[MAX_ARGS - 1])) + __asm__ __volatile__ ("" : "=A" (rt_task->retval) ); rt_global_cli(); + TRACE_RTAI_LXRT(TRACE_RTAI_EV_LXRT_SUSPEND, rt_task->lnxtsk.task->pid, 0, 0); + if ((rt_task->lnxtsk.task)->state == TASK_INTERRUPTIBLE) { // The Linux system call was suspended. sysrq.waitq[sysrq.in] = &(rt_task->waitq); @@ -289,6 +310,16 @@ // copy the arguments on the stack of the RTAI task copy_from_user(rt_task->stack_top, arg, (narg - 1)*sizeof(int)); + + if(rt_task->lnxtsk.task != NULL) + { + TRACE_RTAI_LXRT(TRACE_RTAI_EV_LXRT_RESUME, rt_task->lnxtsk.task->pid, type, 0); + } + else + { + TRACE_RTAI_LXRT(TRACE_RTAI_EV_LXRT_RESUME, -1, type, 0); + } + /* * Next: type > 0 means any messaging with the need to copying from/to user * space. @@ -418,6 +449,8 @@ union {unsigned long name; RT_TASK *rt_task; SEM *sem; MBX *mbx;} arg0; unsigned long name; int srq, err=0; + + TRACE_RTAI_LXRT(TRACE_RTAI_EV_LXRT_HANDLE, SRQ(lxsrq), 0, 0); get_user(arg0.name, (unsigned long *)arg); if ((srq = SRQ(lxsrq)) < GET_ADR) { diff -urN rtai-1.6/lxrt-informed/msg.c rtai-1.6+trace/lxrt-informed/msg.c --- rtai-1.6/lxrt-informed/msg.c Fri Jun 30 12:27:04 2000 +++ rtai-1.6+trace/lxrt-informed/msg.c Thu Mar 22 12:38:20 2001 @@ -28,6 +28,8 @@ #include #include +#include + #include "mmgr.h" #include "proxies.h" #include "msg.h" @@ -41,6 +43,8 @@ task = pid2rttask(pid); if(!task) return -ESRCH; +TRACE_RTAI_LXRTI(TRACE_RTAI_EV_LXRTI_SEND, pid, ssize, rsize); + cb.sbuf = smsg; cb.rbuf = rmsg; cb.sbytes = ssize; @@ -60,6 +64,8 @@ unsigned int pt; MSGCB *cb; +TRACE_RTAI_LXRTI(TRACE_RTAI_EV_LXRTI_RECV, pid, maxsize, 0); + task = pid ? pid2rttask(pid) : 0 ; task = rt_receive(task, &pt); @@ -81,6 +87,8 @@ unsigned int pt; MSGCB *cb; +TRACE_RTAI_LXRTI(TRACE_RTAI_EV_LXRTI_CRECV, pid, maxsize, delay); + task = pid ? pid2rttask(pid) : 0 ; if( !delay ) @@ -105,6 +113,8 @@ MSGCB *cb; unsigned int len; +TRACE_RTAI_LXRTI(TRACE_RTAI_EV_LXRTI_REPLY, pid, size, 0); + task = pid2rttask(pid); if(!task) return -ESRCH; @@ -150,6 +160,8 @@ { RT_TASK *task; +TRACE_RTAI_LXRTI(TRACE_RTAI_EV_LXRTI_PROXY_ATTACH, pid, nbytes, priority); + task = pid ? pid2rttask(pid) : 0 ; task = __rt_proxy_attach(Proxy_Task, task, msg, nbytes, priority); @@ -169,6 +181,8 @@ { RT_TASK *proxy; +TRACE_RTAI_LXRTI(TRACE_RTAI_EV_LXRTI_PROXY_DETACH, pid, 0, 0); + proxy = pid2rttask(pid); release_vc(pid); @@ -183,6 +197,8 @@ pid_t rt_Trigger(pid_t pid) { RT_TASK *proxy, *rcv; + +TRACE_RTAI_LXRTI(TRACE_RTAI_EV_LXRTI_TRIGGER, pid, 0, 0); proxy = pid2rttask(pid); if(!proxy) return -ESRCH; diff -urN rtai-1.6/lxrt-informed/names.c rtai-1.6+trace/lxrt-informed/names.c --- rtai-1.6/lxrt-informed/names.c Fri Jun 30 12:27:05 2000 +++ rtai-1.6+trace/lxrt-informed/names.c Thu Mar 22 12:38:20 2001 @@ -10,6 +10,8 @@ #include #include +#include + #include "rtai_lxrt.h" #include "mmgr.h" #include "msg.h" @@ -34,6 +36,8 @@ my_pid = assign_pid(me); if(!my_pid) return -EAGAIN; +TRACE_RTAI_LXRTI(TRACE_RTAI_EV_LXRTI_NAME_ATTACH, my_pid, nam2num(name), 0); + pt = (char *) name; len = strlen(name); if( len > 6 ) { @@ -86,6 +90,8 @@ if(!name || !host || host[0]) return -EINVAL; // network stuff to do later +TRACE_RTAI_LXRTI(TRACE_RTAI_EV_LXRTI_NAME_LOCATE, 0, nam2num(name), 0); + pt = (char *) name; len = strlen(name); if( len > 6 ) pt = ((char *)name) + (len - 6); @@ -98,6 +104,8 @@ int rt_Name_detach(pid_t pid) { RT_TASK *me, *owner; + +TRACE_RTAI_LXRTI(TRACE_RTAI_EV_LXRTI_NAME_DETACH, pid, 0, 0); me = rt_whoami(); owner = pid2rttask(pid); diff -urN rtai-1.6/newfifos/rtai_fifos.c rtai-1.6+trace/newfifos/rtai_fifos.c --- rtai-1.6/newfifos/rtai_fifos.c Thu Jan 11 17:08:00 2001 +++ rtai-1.6+trace/newfifos/rtai_fifos.c Thu Mar 22 12:59:32 2001 @@ -53,6 +53,8 @@ #include "rtai_fifos.h" #include "rt_compat.h" +#include + typedef struct lx_queue { struct lx_queue *prev; struct lx_queue *next; @@ -594,6 +596,9 @@ { F_MBX *mbx; VALID_FIFO; + + TRACE_RTAI_FIFO(TRACE_RTAI_EV_FIFO_RESET, minor, 0); + if (mbx_delete(mbx = &(fifo[minor].mbx))) { return -EFAULT; } @@ -608,6 +613,9 @@ F_MBX *mbx; VALID_FIFO; + + TRACE_RTAI_FIFO(TRACE_RTAI_EV_FIFO_RESIZE, minor, size); + malloc_type = fifo[minor].malloc_type; if (size <= PAGE_SIZE*32) { if (!(bufadr = kmalloc(size, GFP_KERNEL))) { @@ -643,6 +651,9 @@ if (minor >= MAX_FIFOS) { return -ENODEV; } + + TRACE_RTAI_FIFO(TRACE_RTAI_EV_FIFO_CREATE, minor, size); + rtf_save_flags_and_cli(flags); if (!(fifo[minor].opncnt)) { if (size <= PAGE_SIZE*32) { @@ -680,6 +691,9 @@ int rtf_destroy(unsigned int minor) { VALID_FIFO; + + TRACE_RTAI_FIFO(TRACE_RTAI_EV_FIFO_DESTROY, minor, 0); + MOD_DEC_USE_COUNT; (fifo[minor].opncnt)--; if(!(fifo[minor].opncnt)) { @@ -704,6 +718,9 @@ if (minor >= MAX_FIFOS || !handler) { return -EINVAL; } + + TRACE_RTAI_FIFO(TRACE_RTAI_EV_FIFO_CREATE_HANDLER, minor, handler); + fifo[minor].handler = handler; return 0; } @@ -711,6 +728,9 @@ int rtf_put(unsigned int minor, void *buf, int count) { VALID_FIFO; + + TRACE_RTAI_FIFO(TRACE_RTAI_EV_FIFO_PUT, minor, count); + count -= mbx_send_wp(&(fifo[minor].mbx), buf, count, 0); return count; } @@ -718,6 +738,9 @@ int rtf_get(unsigned int minor, void *buf, int count) { VALID_FIFO; + + TRACE_RTAI_FIFO(TRACE_RTAI_EV_FIFO_GET, minor, count); + count -= mbx_receive_wp(&(fifo[minor].mbx), buf, count, 0); return count; } @@ -725,6 +748,9 @@ int rtf_sem_init(unsigned int minor, int value) { VALID_FIFO; + + TRACE_RTAI_FIFO(TRACE_RTAI_EV_FIFO_SEM_INIT, minor, value); + mbx_sem_init(&(fifo[minor].sem), value); return 0; } @@ -732,6 +758,9 @@ int rtf_sem_post(unsigned int minor) { VALID_FIFO; + + TRACE_RTAI_FIFO(TRACE_RTAI_EV_FIFO_SEM_POST, minor, 0); + mbx_sem_signal(&(fifo[minor].sem), 0); return 0; } @@ -739,18 +768,26 @@ int rtf_sem_trywait(unsigned int minor) { VALID_FIFO; + + TRACE_RTAI_FIFO(TRACE_RTAI_EV_FIFO_SEM_TRY_WAIT, minor, 0); + return mbx_sem_wait_if(&(fifo[minor].sem)); } int rtf_sem_delete(unsigned int minor) { VALID_FIFO; + + TRACE_RTAI_FIFO(TRACE_RTAI_EV_FIFO_SEM_DESTROY, minor, 0); + return mbx_sem_delete(&(fifo[minor].sem)); } static int rtf_open(struct inode *inode, struct file *filp) { #define DEFAULT_SIZE 1000 + TRACE_RTAI_FIFO(TRACE_RTAI_EV_FIFO_OPEN, MINOR(inode->i_rdev), DEFAULT_SIZE); + return rtf_create(MINOR(inode->i_rdev), DEFAULT_SIZE); } @@ -758,6 +795,9 @@ { int minor; minor = MINOR((filp->f_dentry->d_inode)->i_rdev); + + TRACE_RTAI_FIFO(TRACE_RTAI_EV_FIFO_FASYNC, minor, fd); + return fasync_helper(fd, filp, mode, &(fifo[minor].asynq)); if (!mode) { fifo[minor].asynq = 0; @@ -768,6 +808,9 @@ { int minor; minor = MINOR(inode->i_rdev); + + TRACE_RTAI_FIFO(TRACE_RTAI_EV_FIFO_RELEASE, minor, 0); + wake_up_interruptible(&(fifo[minor].pollq)); rtf_fasync(-1, filp, 0); return rtf_destroy(minor); @@ -779,6 +822,8 @@ unsigned int minor = MINOR(inode->i_rdev); int handler_ret; + TRACE_RTAI_FIFO(TRACE_RTAI_EV_FIFO_READ, minor, count); + if (filp->f_flags & O_NONBLOCK) { count -= mbx_receive_wp(&(fifo[minor].mbx), buf, count, 1); if (!count) { @@ -807,6 +852,8 @@ unsigned int minor = MINOR(inode->i_rdev); int handler_ret; + TRACE_RTAI_FIFO(TRACE_RTAI_EV_FIFO_WRITE, minor, count); + if (filp->f_flags & O_NONBLOCK) { count -= mbx_send_wp(&(fifo[minor].mbx), (char *)buf, count, 1); if (!count) { @@ -832,6 +879,8 @@ unsigned int minor; FIFO *fifop; + TRACE_RTAI_FIFO(TRACE_RTAI_EV_FIFO_IOCTL, minor, cmd); + fifop = fifo + (minor = MINOR(inode->i_rdev)); switch(cmd) { case RESET: { @@ -841,6 +890,7 @@ return rtf_resize(minor, arg); } case SUSPEND_TIMED: { + TRACE_RTAI_FIFO(TRACE_RTAI_EV_FIFO_SUSPEND_TIMED, DELAY(arg), 0); current->state = TASK_INTERRUPTIBLE; schedule_timeout(DELAY(arg)); if (check_blocked(current->signal, current->blocked)) { @@ -854,6 +904,7 @@ case READ_ALL_AT_ONCE: { struct { char *buf; int count; } args; int handler_ret; + TRACE_RTAI_FIFO(TRACE_RTAI_EV_FIFO_READ_ALLATONCE, 0, 0); copy_from_user(&args, (void *)arg, sizeof(args)); args.count -= mbx_receive(&(fifop->mbx), args.buf, args.count, 1); if (args.count) { @@ -870,6 +921,7 @@ struct { char *buf; int count, delay; } args; int handler_ret; copy_from_user(&args, (void *)arg, sizeof(args)); + TRACE_RTAI_FIFO(TRACE_RTAI_EV_FIFO_READ_TIMED, args.count, DELAY(args.delay)); if (!args.delay) { args.count -= mbx_receive_wp(&(fifop->mbx), args.buf, args.count, 1); if (!args.count) { @@ -892,6 +944,7 @@ struct { char *buf; int count, delay; } args; int handler_ret; copy_from_user(&args, (void *)arg, sizeof(args)); + TRACE_RTAI_FIFO(TRACE_RTAI_EV_FIFO_WRITE_TIMED, args.count, DELAY(args.delay)); if (!args.delay) { args.count -= mbx_send_wp(&(fifop->mbx), args.buf, args.count, 1); if (!args.count) { @@ -908,27 +961,34 @@ return args.count; } case RTF_SEM_INIT: { + TRACE_RTAI_FIFO(TRACE_RTAI_EV_FIFO_SEM_INIT, minor, arg); mbx_sem_init(&(fifop->sem), arg); return 0; } case RTF_SEM_WAIT: { + TRACE_RTAI_FIFO(TRACE_RTAI_EV_FIFO_SEM_WAIT, minor, 0); return mbx_sem_wait(&(fifop->sem)); } case RTF_SEM_TRYWAIT: { + TRACE_RTAI_FIFO(TRACE_RTAI_EV_FIFO_SEM_TRY_WAIT, minor, 0); return mbx_sem_wait_if(&(fifop->sem)); } case RTF_SEM_TIMED_WAIT: { + TRACE_RTAI_FIFO(TRACE_RTAI_EV_FIFO_SEM_TIMED_WAIT, minor, DELAY(arg)); return mbx_sem_wait_timed(&(fifop->sem), DELAY(arg)); } case RTF_SEM_POST: { + TRACE_RTAI_FIFO(TRACE_RTAI_EV_FIFO_SEM_POST, minor, 0); mbx_sem_signal(&(fifop->sem), 0); return 0; } case RTF_SEM_DESTROY: { + TRACE_RTAI_FIFO(TRACE_RTAI_EV_FIFO_SEM_DESTROY, minor, 0); mbx_sem_delete(&(fifop->sem)); return 0; } case SET_ASYNC_SIG: { + TRACE_RTAI_FIFO(TRACE_RTAI_EV_FIFO_SET_ASYNC_SIG, arg, 0); async_sig = arg; return 0; } @@ -990,6 +1050,9 @@ retval = 0; minor = MINOR((filp->f_dentry->d_inode)->i_rdev); poll_wait(filp, &(fifo[minor].pollq), wait); + + TRACE_RTAI_FIFO(TRACE_RTAI_EV_FIFO_POLL, minor, 0); + if (fifo[minor].mbx.avbs) { retval |= POLLIN | POLLRDNORM; } @@ -1001,6 +1064,8 @@ static loff_t rtf_llseek(struct file *filp, loff_t offset, int origin) { + TRACE_RTAI_FIFO(TRACE_RTAI_EV_FIFO_LLSEEK, MINOR((filp->f_dentry->d_inode)->i_rdev), offset); + return rtf_reset(MINOR((filp->f_dentry->d_inode)->i_rdev)); } diff -urN rtai-1.6/portable_shm/rtai_shm.c rtai-1.6+trace/portable_shm/rtai_shm.c --- rtai-1.6/portable_shm/rtai_shm.c Fri Jun 30 12:27:48 2000 +++ rtai-1.6+trace/portable_shm/rtai_shm.c Thu Mar 22 12:38:20 2001 @@ -36,6 +36,8 @@ #include #include +#include "../include/rtai_trace.h" + #include "rtai_shm.h" #include "kvmem.h" @@ -153,6 +155,9 @@ if (size <= 0) { return 0; } + + TRACE_RTAI_SHM(TRACE_RTAI_EV_SHM_KMALLOC, name, size, pid); + spin_lock_irqsave(&shm_lock, flags); if ((slot = find_name_and_reg(name, pid))) { shm_list[slot].count++; @@ -186,6 +191,9 @@ unsigned long flags; int slot, size; void *adr; + + TRACE_RTAI_SHM(TRACE_RTAI_EV_SHM_KFREE, name, 0, pid); + spin_lock_irqsave(&shm_lock, flags); if ((slot = find_name_and_drg(name, pid))) { MOD_DEC_USE_COUNT; @@ -209,6 +217,7 @@ long long name_pid; switch (srq) { case 1: + TRACE_RTAI_SHM(TRACE_RTAI_EV_SHM_MALLOC, name, srq, current->pid); if (rtai_kmalloc_f(((unsigned long *)name)[0], ((unsigned long *)name)[1], current->pid)) { return shm_list[find_name(((unsigned long *)name)[0])].size; } @@ -216,6 +225,7 @@ case 2: NAME(name_pid) = name; PID(name_pid) = current->pid; + TRACE_RTAI_SHM(TRACE_RTAI_EV_SHM_GET_SIZE, name, srq, current->pid); for (owner = 1; owner <= MAX_OWNERS; owner++) { if (name_pid_list[owner] == name_pid) { if (vmarea[owner] && (vmarea[owner]->vm_ops)->close == rtai_shm_vm_close) { @@ -230,6 +240,7 @@ } return 0; case 3: + TRACE_RTAI_SHM(TRACE_RTAI_EV_SHM_FREE, name, srq, current->pid); rtai_kfree_f(name, current->pid); return 0; } diff -urN rtai-1.6/posix/rtai_pqueue.c rtai-1.6+trace/posix/rtai_pqueue.c --- rtai-1.6/posix/rtai_pqueue.c Mon Aug 7 23:57:23 2000 +++ rtai-1.6+trace/posix/rtai_pqueue.c Thu Mar 22 12:38:20 2001 @@ -39,6 +39,8 @@ #include #include +#include + #define MAX_RT_TASKS 128 /////////////////////////////////////////////////////////////////////////////// @@ -707,6 +709,8 @@ } // End if, else if, else - creating or opening + TRACE_RTAI_POSIX(TRACE_RTAI_EV_POSIX_MQ_OPEN, rt_pqueue_descr[q_index].q_id, 0, 0); + //Return the message queue's id and mark it as open DBG("queue %s, id %d opened\n", rt_pqueue_descr[q_index].q_name, rt_pqueue_descr[q_index].q_id); @@ -728,6 +732,8 @@ DBG("\n"); + TRACE_RTAI_POSIX(TRACE_RTAI_EV_POSIX_MQ_RECV, mq, buflen, 0); + //Check that the supplied queue id is valid if ( 0 <= q_index && q_index < MAX_PQUEUES) { @@ -829,6 +835,8 @@ DBG("\n"); + TRACE_RTAI_POSIX(TRACE_RTAI_EV_POSIX_MQ_SEND, mq, msglen, msgprio); + //Check that the supplied queue id is valid if ( 0 <= q_index && q_index < MAX_PQUEUES) { @@ -947,6 +955,8 @@ DBG("\n"); + TRACE_RTAI_POSIX(TRACE_RTAI_EV_POSIX_MQ_CLOSE, mq, 0, 0); + //Check that the supplied queue id is valid if ( 0 <= q_index && q_index < MAX_PQUEUES) { @@ -1011,6 +1021,8 @@ DBG("\n"); + TRACE_RTAI_POSIX(TRACE_RTAI_EV_POSIX_MQ_GET_ATTR, mq, 0, 0); + //Check that the supplied queue id is valid if ( 0 <= q_index && q_index < MAX_PQUEUES) { @@ -1038,6 +1050,8 @@ DBG("\n"); + TRACE_RTAI_POSIX(TRACE_RTAI_EV_POSIX_MQ_SET_ATTR, mq, 0, 0); + //Check that the supplied queue id is valid if ( 0 <= q_index && q_index < MAX_PQUEUES) { @@ -1091,6 +1105,8 @@ DBG("\n"); + TRACE_RTAI_POSIX(TRACE_RTAI_EV_POSIX_MQ_NOTIFY, mq, 0, 0); + //Check that the supplied queue id is valid if ( 0 <= q_index && q_index < MAX_PQUEUES) { @@ -1132,6 +1148,8 @@ int q_index, rtn; DBG("\n"); + + TRACE_RTAI_POSIX(TRACE_RTAI_EV_POSIX_MQ_UNLINK, mq_name, 0, 0); // Check the queue exists pthread_mutex_lock(&pqueue_mutex); diff -urN rtai-1.6/posix/rtai_pthread.c rtai-1.6+trace/posix/rtai_pthread.c --- rtai-1.6/posix/rtai_pthread.c Mon Nov 20 02:57:58 2000 +++ rtai-1.6+trace/posix/rtai_pthread.c Thu Mar 22 13:02:09 2001 @@ -37,6 +37,8 @@ #include "rtai_utils.h" +#include + #define RUNNABLE_ON_CPUS 3 #define RUN_ON_CPUS (smp_num_cpus > 1 ? RUNNABLE_ON_CPUS : 1) @@ -163,6 +165,11 @@ } rt_pthread_descr[j].p_start_args.schedpolicy = SCHED_OTHER; + TRACE_RTAI_POSIX(TRACE_RTAI_EV_POSIX_PTHREAD_CREATE, + start_routine, + rt_pthread_descr[j].p_tid, + 0); + // Initialise the scheduling parameters for the new thread. if(attr != NULL && attr->schedpolicy != SCHED_OTHER) { switch(attr->inheritsched) { @@ -273,6 +280,8 @@ Z_APPS *zapps_ptr = NULL; + TRACE_RTAI_POSIX(TRACE_RTAI_EV_POSIX_PTHREAD_EXIT, 0, 0, 0); + rt_task_ptr = rt_whoami(); // ****TPW zapps_ptr = (Z_APPS*)rt_task_ptr->system_data_ptr; @@ -290,6 +299,7 @@ int sched_yield(void) { + TRACE_RTAI_POSIX(TRACE_RTAI_EV_POSIX_PTHREAD_SCHED_YIELD, 0, 0, 0); rt_task_yield(); return(0); @@ -309,6 +319,9 @@ thread_ptr = (pthread_descr)zapps_ptr->pthreads; //thread_ptr = (pthread_descr)rt_task_ptr->system_data_ptr; // ***TPW + + TRACE_RTAI_POSIX(TRACE_RTAI_EV_POSIX_PTHREAD_SELF, thread_ptr->p_tid, 0, 0); + return(thread_ptr->p_tid); } // End function - pthread_self @@ -320,6 +333,8 @@ int pthread_attr_init(pthread_attr_t *attr) { + TRACE_RTAI_POSIX(TRACE_RTAI_EV_POSIX_PTHREAD_ATTR_INIT, attr, 0, 0); + attr->detachstate = PTHREAD_CREATE_JOINABLE; attr->schedpolicy = SCHED_OTHER; attr->schedparam.sched_priority = 0; @@ -332,6 +347,8 @@ int pthread_attr_destroy(pthread_attr_t *attr) { + TRACE_RTAI_POSIX(TRACE_RTAI_EV_POSIX_PTHREAD_ATTR_DESTROY, attr, 0, 0); + return(0); } // End function - pthread_attr_destroy @@ -339,6 +356,8 @@ int pthread_attr_setdetachstate(pthread_attr_t *attr, int detachstate) { + TRACE_RTAI_POSIX(TRACE_RTAI_EV_POSIX_PTHREAD_ATTR_SETDETACHSTATE, attr, detachstate, 0); + if (detachstate < PTHREAD_CREATE_JOINABLE || detachstate > PTHREAD_CREATE_DETACHED) return(EINVAL); @@ -350,6 +369,8 @@ int pthread_attr_getdetachstate(const pthread_attr_t *attr, int *detachstate) { + TRACE_RTAI_POSIX(TRACE_RTAI_EV_POSIX_PTHREAD_ATTR_GETDETACHSTATE, attr, attr->detachstate, 0); + *detachstate = attr->detachstate; return(0); @@ -362,6 +383,8 @@ int max_prio = get_max_priority(attr->schedpolicy); int min_prio = get_min_priority(attr->schedpolicy); + TRACE_RTAI_POSIX(TRACE_RTAI_EV_POSIX_PTHREAD_ATTR_SETSCHEDPARAM, attr, 0, 0); + if(param->sched_priority < min_prio || param->sched_priority > max_prio) { return(EINVAL); } @@ -374,6 +397,8 @@ int pthread_attr_getschedparam(const pthread_attr_t *attr, struct sched_param *param) { + TRACE_RTAI_POSIX(TRACE_RTAI_EV_POSIX_PTHREAD_ATTR_GETSCHEDPARAM, attr, 0, 0); + *param = attr->schedparam; return(0); @@ -382,6 +407,8 @@ int pthread_attr_setschedpolicy(pthread_attr_t *attr, int policy) { + TRACE_RTAI_POSIX(TRACE_RTAI_EV_POSIX_PTHREAD_ATTR_SETSCHEDPOLICY, attr, policy, 0); + if(policy != SCHED_OTHER && policy != SCHED_FIFO && policy != SCHED_RR) { return(EINVAL); } @@ -393,6 +420,8 @@ int pthread_attr_getschedpolicy(const pthread_attr_t *attr, int *policy) { + TRACE_RTAI_POSIX(TRACE_RTAI_EV_POSIX_PTHREAD_ATTR_GETSCHEDPOLICY, attr, attr->schedpolicy, 0); + *policy = attr->schedpolicy; return(0); @@ -401,6 +430,8 @@ int pthread_attr_setinheritsched(pthread_attr_t *attr, int inherit) { + TRACE_RTAI_POSIX(TRACE_RTAI_EV_POSIX_PTHREAD_ATTR_SETINHERITSCHED, attr, inherit, 0); + if(inherit != PTHREAD_INHERIT_SCHED && inherit != PTHREAD_EXPLICIT_SCHED) { return(EINVAL); } @@ -412,6 +443,8 @@ int pthread_attr_getinheritsched(const pthread_attr_t *attr, int *inherit) { + TRACE_RTAI_POSIX(TRACE_RTAI_EV_POSIX_PTHREAD_ATTR_SETINHERITSCHED, attr, attr->inheritsched, 0); + *inherit = attr->inheritsched; return(0); @@ -420,6 +453,8 @@ int pthread_attr_setscope(pthread_attr_t *attr, int scope) { + TRACE_RTAI_POSIX(TRACE_RTAI_EV_POSIX_PTHREAD_ATTR_SETSCOPE, attr, scope, 0); + switch (scope) { case PTHREAD_SCOPE_SYSTEM: attr->scope = scope; @@ -435,6 +470,8 @@ int pthread_attr_getscope(const pthread_attr_t *attr, int *scope) { + TRACE_RTAI_POSIX(TRACE_RTAI_EV_POSIX_PTHREAD_ATTR_GETSCOPE, attr, attr->scope, 0); + *scope = attr->scope; return(0); @@ -461,6 +498,8 @@ return(ESRCH); } + TRACE_RTAI_POSIX(TRACE_RTAI_EV_POSIX_PTHREAD_SETSCHEDPARAM, pthread_handle->p_tid, policy, 0); + max_prio = get_max_priority(policy); min_prio = get_min_priority(policy); @@ -495,6 +534,11 @@ return(ESRCH); } + TRACE_RTAI_POSIX(TRACE_RTAI_EV_POSIX_PTHREAD_GETSCHEDPARAM, + pthread_handle->p_tid, + pthread_handle->p_policy, + 0); + // Get the new scheduling parameters for the thread. *policy = pthread_handle->p_policy; param->sched_priority = pthread_handle->p_priority; @@ -510,6 +554,7 @@ void clock_gettime(int clockid, struct timespec *current_time) { + TRACE_RTAI_POSIX(TRACE_RTAI_EV_POSIX_PTHREAD_CLOCK_GETTIME, clockid, 0, 0); if(clockid != CLOCK_REALTIME) { current_time->tv_sec = 0; @@ -638,6 +683,8 @@ QUEUE *rt_q; + TRACE_RTAI_POSIX(TRACE_RTAI_EV_POSIX_PTHREAD_MUTEX_INIT, mutex, 0, 0); + mutex->m_owner = 0; mutex->m_kind = mutex_attr == NULL ? PTHREAD_MUTEX_FAST_NP : mutex_attr->mutexkind; @@ -658,6 +705,8 @@ unsigned long flags; QUEUE *rt_q; + TRACE_RTAI_POSIX(TRACE_RTAI_EV_POSIX_PTHREAD_MUTEX_DESTROY, mutex, 0, 0); + if(mutex->m_semaphore.magic != RT_SEM_MAGIC) { return(EINVAL); } @@ -684,6 +733,8 @@ int pthread_mutexattr_init(pthread_mutexattr_t *attr) { + TRACE_RTAI_POSIX(TRACE_RTAI_EV_POSIX_PTHREAD_MUTEXATTR_INIT, attr, 0, 0); + attr->mutexkind = PTHREAD_MUTEX_FAST_NP; return(0); @@ -693,6 +744,8 @@ int pthread_mutexattr_destroy(pthread_mutexattr_t *attr) { + TRACE_RTAI_POSIX(TRACE_RTAI_EV_POSIX_PTHREAD_MUTEXATTR_DESTROY, attr, 0, 0); + return(0); } // End function - pthread_mutex_attr_destroy @@ -700,6 +753,8 @@ int pthread_mutexattr_setkind_np(pthread_mutexattr_t *attr, int kind) { + TRACE_RTAI_POSIX(TRACE_RTAI_EV_POSIX_PTHREAD_MUTEXATTR_SETKIND_NP, attr, kind, 0); + if (kind != PTHREAD_MUTEX_FAST_NP && kind != PTHREAD_MUTEX_RECURSIVE_NP && kind != PTHREAD_MUTEX_ERRORCHECK_NP) @@ -712,6 +767,8 @@ int pthread_mutexattr_getkind_np(const pthread_mutexattr_t *attr, int *kind) { + TRACE_RTAI_POSIX(TRACE_RTAI_EV_POSIX_PTHREAD_MUTEXATTR_SETKIND_NP, attr, kind, 0); + *kind = attr->mutexkind; return(0); @@ -727,6 +784,9 @@ if(mutex->m_semaphore.magic != RT_SEM_MAGIC) { return(EINVAL); } + + TRACE_RTAI_POSIX(TRACE_RTAI_EV_POSIX_PTHREAD_MUTEX_TRY_LOCK, mutex, 0, 0); + flags = rt_global_save_flags_and_cli(); self = rt_whoami(); switch(mutex->m_kind) { @@ -777,6 +837,9 @@ if(mutex->m_semaphore.magic != RT_SEM_MAGIC) { return(EINVAL); } + + TRACE_RTAI_POSIX(TRACE_RTAI_EV_POSIX_PTHREAD_MUTEX_LOCK, mutex, 0, 0); + flags = rt_global_save_flags_and_cli(); current_task = rt_whoami(); switch(mutex->m_kind) { @@ -862,6 +925,8 @@ unsigned long flags; RT_TASK *current_task; + TRACE_RTAI_POSIX(TRACE_RTAI_EV_POSIX_PTHREAD_MUTEX_UNLOCK, mutex, 0, 0); + flags = rt_global_save_flags_and_cli(); current_task = rt_whoami(); if(mutex->m_semaphore.magic != RT_SEM_MAGIC || @@ -943,6 +1008,8 @@ QUEUE *rt_q; + TRACE_RTAI_POSIX(TRACE_RTAI_EV_POSIX_PTHREAD_COND_INIT, cond, 0, 0); + cond->c_waiting.magic = RT_SEM_MAGIC; rt_q = &(cond->c_waiting.queue); rt_q->prev = &(cond->c_waiting.queue); @@ -959,6 +1026,8 @@ int return_code; QUEUE *rt_q; + TRACE_RTAI_POSIX(TRACE_RTAI_EV_POSIX_PTHREAD_COND_DESTROY, cond, 0, 0); + rt_q = &(cond->c_waiting.queue); flags = rt_global_save_flags_and_cli(); if( (rt_q->next != &(cond->c_waiting.queue)) && @@ -978,6 +1047,8 @@ int pthread_condattr_init(pthread_condattr_t *attr) { + TRACE_RTAI_POSIX(TRACE_RTAI_EV_POSIX_PTHREAD_CONDATTR_INIT, attr, 0, 0); + return(0); } // End function - pthread_condattr_init @@ -986,6 +1057,8 @@ int pthread_condattr_destroy(pthread_condattr_t *attr) { + TRACE_RTAI_POSIX(TRACE_RTAI_EV_POSIX_PTHREAD_CONDATTR_DESTROY, attr, 0, 0); + return(0); } // End function - pthread_condattr_destroy @@ -996,6 +1069,8 @@ unsigned long flags; RT_TASK *current_task; + TRACE_RTAI_POSIX(TRACE_RTAI_EV_POSIX_PTHREAD_COND_WAIT, cond, mutex, 0); + flags = rt_global_save_flags_and_cli(); current_task = rt_whoami(); current_task->state |= SEMAPHORE; @@ -1017,6 +1092,8 @@ RTIME time; RT_TASK *current_task; + TRACE_RTAI_POSIX(TRACE_RTAI_EV_POSIX_PTHREAD_COND_TIMEDWAIT, cond, mutex, 0); + semret = 0; time = nano2count((1000000000LL)*abstime->tv_sec + abstime->tv_nsec); current_task = rt_whoami(); @@ -1045,6 +1122,8 @@ unsigned long flags; RT_TASK *next_task; + TRACE_RTAI_POSIX(TRACE_RTAI_EV_POSIX_PTHREAD_COND_SIGNAL, cond, 0, 0); + flags = rt_global_save_flags_and_cli(); if(cond->c_waiting.queue.next != &(cond->c_waiting.queue) && cond->c_waiting.queue.next != NULL && cond->c_waiting.queue.prev != NULL) { @@ -1068,6 +1147,8 @@ unsigned long flags; RT_TASK *next_task; + + TRACE_RTAI_POSIX(TRACE_RTAI_EV_POSIX_PTHREAD_COND_BROADCAST, cond, 0, 0); flags = rt_global_save_flags_and_cli(); if(cond->c_waiting.queue.next != NULL && cond->c_waiting.queue.prev != NULL) { diff -urN rtai-1.6/rtai/rtai.c rtai-1.6+trace/rtai/rtai.c --- rtai-1.6/rtai/rtai.c Tue Oct 17 11:34:43 2000 +++ rtai-1.6+trace/rtai/rtai.c Thu Mar 22 13:07:45 2001 @@ -63,6 +63,8 @@ #include "rtai.h" #include "rtai_srq.h" +#include + // proc filesystem additions. static int rtai_proc_register(void); static void rtai_proc_unregister(void); @@ -100,10 +102,49 @@ #define GLOBAL_IRQ_FNAME(y) y##_interrupt(void) #define GLOBAL_IRQ_NAME(y) GLOBAL_IRQ_FNAME(GLOBAL##y) +/****************************************************************************/ +/* Trace functions. These functions have to be used rather than insert +the macros as-is. Otherwise the system crashes ... You've been warned. K.Y. */ +void trace_true_global_irq_entry(struct fill_t fill, int irq) +{ + TRACE_RTAI_GLOBAL_IRQ_ENTRY(irq); +} +void trace_true_global_irq_exit(void) +{ + TRACE_RTAI_GLOBAL_IRQ_EXIT(); +} +void trace_true_own_irq_entry(struct fill_t fill, int irq) +{ + TRACE_RTAI_OWN_IRQ_ENTRY(irq); +} +void trace_true_own_irq_exit(void) +{ + TRACE_RTAI_OWN_IRQ_EXIT(); +} +void trace_true_trap_entry(int err) +{ + TRACE_RTAI_TRAP_ENTRY(err); +} +void trace_true_trap_exit(void) +{ + TRACE_RTAI_TRAP_EXIT(); +} +void trace_true_srq_entry(unsigned int srq, unsigned int whatever) +{ + TRACE_RTAI_SRQ_ENTRY(srq); +} +void trace_true_srq_exit(void) +{ + TRACE_RTAI_SRQ_EXIT(); +} +/****************************************************************************/ + #define BUILD_GLOBAL_IRQ(irq) static void GLOBAL_IRQ_NAME(irq) \ { \ SAVE_REG(irq); \ + __asm__ __volatile__ ("call "SYMBOL_NAME_STR(trace_true_global_irq_entry)); \ __asm__ __volatile__ ("call "SYMBOL_NAME_STR(dispatch_global_irq)); \ + __asm__ __volatile__ ("call "SYMBOL_NAME_STR(trace_true_global_irq_exit)); \ RSTR_REG; \ } @@ -113,7 +154,9 @@ #define BUILD_CPU_OWN_IRQ(irq) static void CPU_OWN_IRQ_NAME(irq) \ { \ SAVE_REG(irq); \ + __asm__ __volatile__ ("call "SYMBOL_NAME_STR(trace_true_own_irq_entry)); \ __asm__ __volatile__ ("call "SYMBOL_NAME_STR(dispatch_cpu_own_irq)); \ + __asm__ __volatile__ ("call "SYMBOL_NAME_STR(trace_true_own_irq_exit)); \ RSTR_REG; \ } @@ -133,7 +176,9 @@ #define BUILD_TRAP(vec) static void TRAP_NAME(vec) \ { \ TRAP_SAVE_REG(vec); \ + __asm__ __volatile__ ("call "SYMBOL_NAME_STR(trace_true_trap_entry)); \ __asm__ __volatile__ ("call "SYMBOL_NAME_STR(dispatch_trap)); \ + __asm__ __volatile__ ("call "SYMBOL_NAME_STR(trace_true_trap_exit)); \ TRAP_RSTR_REG(vec); \ } @@ -145,7 +190,9 @@ pushl %ebx; pushl %edx; pushl %eax;\n\t \ movl $" STR(__KERNEL_DS) ",%ebx; mov %bx,%ds; mov %bx,%es"); + __asm__ __volatile__ ("call "SYMBOL_NAME_STR(trace_true_srq_entry)); __asm__ __volatile__ ("call "SYMBOL_NAME_STR(dispatch_srq)); + __asm__ __volatile__ ("call "SYMBOL_NAME_STR(trace_true_srq_exit)); __asm__ __volatile__ (" \ addl $8,%esp; popl %ebx; popl %ecx; popl %esi;\n\t \ @@ -1111,12 +1158,14 @@ void rt_switch_to_linux(int cpuid) { + TRACE_RTAI_SWITCHTO_LINUX(cpuid); set_bit(cpuid, &global.used_by_linux); processor[cpuid].intr_flag = processor[cpuid].linux_intr_flag; } void rt_switch_to_real_time(int cpuid) { + TRACE_RTAI_SWITCHTO_RT(cpuid); processor[cpuid].linux_intr_flag = processor[cpuid].intr_flag; processor[cpuid].intr_flag = 0; clear_bit(cpuid, &global.used_by_linux); @@ -1270,6 +1319,7 @@ rt_spin_lock(&rtai_mount_lock); rtai_mounted++; + TRACE_RTAI_MOUNT(); if (rtai_mounted == 1) { rt_spin_lock_irq(&(global.hard_lock)); @@ -1337,6 +1387,7 @@ rt_spin_lock(&rtai_mount_lock); rtai_mounted--; + TRACE_RTAI_UMOUNT(); if (!rtai_mounted) { flags = hard_lock_all(); @@ -1688,6 +1739,9 @@ int count; unsigned long flags; + + TRACE_RTAI_TIMER(TRACE_RTAI_EV_TIMER_REQUEST, handler, tick); + used_local_apic = use_local_apic = apic; flags = hard_lock_all(); do { @@ -1746,6 +1800,9 @@ void rt_free_timer(void) { unsigned long flags; + + TRACE_RTAI_TIMER(TRACE_RTAI_EV_TIMER_FREE, 0, 0); + rt_free_linux_irq(TIMER_8254_IRQ, broadcast_to_local_timers); flags = hard_lock_all(); if (use_local_apic) { @@ -1774,6 +1831,8 @@ struct apic_timer_setup_data *p; volatile struct rt_times *rt_times; + TRACE_RTAI_TIMER(TRACE_RTAI_EV_TIMER_REQUEST_APIC, handler, 0); + flags = hard_lock_all(); global.hard_lock_all_service = 1; do { @@ -1825,6 +1884,8 @@ void rt_free_apic_timers(void) { unsigned long flags; + + TRACE_RTAI_TIMER(TRACE_RTAI_EV_TIMER_APIC_FREE, 0, 0); rt_free_linux_irq(TIMER_8254_IRQ, broadcast_to_local_timers); flags = hard_lock_all(); diff -urN rtai-1.6/shmem/rtai_shm.c rtai-1.6+trace/shmem/rtai_shm.c --- rtai-1.6/shmem/rtai_shm.c Fri Jun 30 12:28:42 2000 +++ rtai-1.6+trace/shmem/rtai_shm.c Thu Mar 22 12:38:20 2001 @@ -36,6 +36,8 @@ #include #include +#include "../include/rtai_trace.h" + #include #include #include "kvmem.h" @@ -172,6 +174,9 @@ if (size <= 0) { return 0; } + + TRACE_RTAI_SHM(TRACE_RTAI_EV_SHM_KMALLOC, name, size, pid); + spin_lock_irqsave(&shm_lock, flags); if ((slot = find_name_and_reg(name, pid))) { shm_list[slot].count++; @@ -205,6 +210,9 @@ unsigned long flags; int slot, size; void *adr; + + TRACE_RTAI_SHM(TRACE_RTAI_EV_SHM_KFREE, name, 0, pid); + spin_lock_irqsave(&shm_lock, flags); if ((slot = find_name_and_drg(name, pid))) { MOD_DEC_USE_COUNT; @@ -228,6 +236,7 @@ long long name_pid; switch (srq) { case 1: + TRACE_RTAI_SHM(TRACE_RTAI_EV_SHM_MALLOC, name, srq, current->pid); if (rtai_kmalloc_f(((unsigned long *)name)[0], ((unsigned long *)name)[1], current->pid)) { return shm_list[find_name(((unsigned long *)name)[0])].size; } @@ -235,6 +244,7 @@ case 2: NAME(name_pid) = name; PID(name_pid) = current->pid; + TRACE_RTAI_SHM(TRACE_RTAI_EV_SHM_GET_SIZE, name, srq, current->pid); for (owner = 1; owner <= MAX_OWNERS; owner++) { if (name_pid_list[owner] == name_pid) { if (vmarea[owner] && (vmarea[owner]->vm_ops)->close == rtai_shm_vm_close) { @@ -249,6 +259,7 @@ } return 0; case 3: + TRACE_RTAI_SHM(TRACE_RTAI_EV_SHM_FREE, name, srq, current->pid); rtai_kfree_f(name, current->pid); return 0; } diff -urN rtai-1.6/trace/Makefile rtai-1.6+trace/trace/Makefile --- rtai-1.6/trace/Makefile Wed Dec 31 18:00:00 1969 +++ rtai-1.6+trace/trace/Makefile Thu Mar 22 12:38:20 2001 @@ -0,0 +1,9 @@ + +TOPDIR = .. +EXTRA_CFLAGS = $(MODFLAGS) +TARGS = rtai_trace.o + +include $(TOPDIR)/Rules.make + +all:: $(TARGS) + cd $(TOPDIR)/modules;ln -sf ../trace/$^ diff -urN rtai-1.6/trace/rtai_trace.c rtai-1.6+trace/trace/rtai_trace.c --- rtai-1.6/trace/rtai_trace.c Wed Dec 31 18:00:00 1969 +++ rtai-1.6+trace/trace/rtai_trace.c Thu Mar 22 12:38:20 2001 @@ -0,0 +1,128 @@ +/***************************************************************** + * File : rtai_tracer.c + * Description : + * Contains the code for the RTAI tracing driver. + * Author : + * Karim Yaghmour (karym@opersys.com) + * Date : + * 16/05/00, Initial typing. + * Note : + *****************************************************************/ + +#include +#include +#include +#include + +/* Local variables */ +static int rt_tracer_registered = 0; /* Is there a tracer registered */ +tracer_call rt_tracer = NULL; /* The registered tracer */ + +/**************************************************** + * Function: rt_register_tracer() + * Description: + * Register the tracer to RTAI + * Return values : + * 0, all is OK + * -1, tracer already registered + ****************************************************/ +int rt_register_tracer(tracer_call pmTraceFunction) +{ + /* Is there a tracer already registered */ + if(rt_tracer_registered == 1) + return -1; + + /* Set the tracer to the one being passed by the caller */ + rt_tracer = pmTraceFunction; + + /* Remember that a tracer is now registered */ + rt_tracer_registered = 1; + + /* Tell the caller that everything went fine */ + return 0; +} + +/*************************************************** + * Function: rt_unregister_tracer() + * Description: + * Unregister the currently registered tracer. + * Return values : + * 0, all is OK + * -ENOMEDIUM, there isn't a registered tracer + * -ENXIO, unregestering wrong tracer + ***************************************************/ +int rt_unregister_tracer(tracer_call pmTraceFunction) +{ + /* Is there a tracer already registered */ + if(rt_tracer_registered == 0) + /* Nothing to unregister */ + return -ENOMEDIUM; + + /* Is it the tracer that was registered */ + if(rt_tracer == pmTraceFunction) + /* There isn't any tracer in here */ + rt_tracer_registered = 0; + else + return -ENXIO; + + /* Reset tracer function */ + rt_tracer = NULL; + + /* Reset the registered flag */ + rt_tracer_registered = 0; + + /* Tell the caller that everything went OK */ + return 0; +} + +/******************************************************* + * Function: rt_trace_event() + * Description: + * Trace an event + * Parameters : + * pmEventID, the event's ID (check out rtai_trace.h) + * pmEventStruct, the structure describing the event + * Return values : + * 0, all is OK + * -ENOMEDIUM, there isn't a registered tracer + * -EBUSY, tracing hasn't started yet + *******************************************************/ +int rt_trace_event(uint8_t pmEventID, + void* pmEventStruct) +{ + /* Is there a tracer registered */ + if(rt_tracer_registered != 1) + return -ENOMEDIUM; + + /* Call the tracer */ + return (rt_tracer(pmEventID, pmEventStruct)); +} + +/******************************************************* + * Function: init_module() + * Description: + * Initializes the RTAI trace module + * Parameters : + * NONE + * Return values : + * 0, all is OK + *******************************************************/ +int init_module(void) +{ + printk("RTAI-TRACE: Initilialization complete \n"); + return 0; +} + +/******************************************************* + * Function: cleanup_module() + * Description: + * Cleans-up the RTAI trace module + * Parameters : + * NONE + * Return values : + * NONE + *******************************************************/ +void cleanup_module(void) +{ + printk("RTAI-TRACE: Trace facility removed \n"); +} --- rtai-1.6/upscheduler/up_sched.c Mon Nov 27 18:34:32 2000 +++ rtai-1.6+trace/upscheduler/up_sched.c Thu Mar 22 14:41:26 2001 @@ -76,6 +76,8 @@ #include #include +#include + #define RT_TASK_MAGIC 0x754d2774 #define RT_SEM_MAGIC 0xaabcdeff @@ -145,6 +147,8 @@ #define MAX_SRQ 64 static struct { int srq, in, out; void *mp[MAX_SRQ]; } mmsrq; +static int rt_next_tid = 1; /* Next task ID */ + /* ++++++++++++++++++++++++++++++++ TASKS ++++++++++++++++++++++++++++++++++ */ static void nointr(void) { hard_sti(); } @@ -187,6 +191,9 @@ task->rprev = task->rnext = task; task->blocked_on.task = NOTHING; task->signal = signal; + task->tid = rt_next_tid++; + + TRACE_RTAI_TASK(TRACE_RTAI_EV_TASK_INIT, task->tid, (uint32_t)rt_thread, priority); *(task->stack - 1) = (int)task; *(task->stack - 2) = data; @@ -334,6 +341,9 @@ rt_switch_to_linux(0); restore_cr0(linux_cr0); } + + TRACE_RTAI_SCHED_CHANGE(rt_current->tid, new_task->tid, rt_current->state); + rt_switch_to(new_task); if (rt_current->signal) { (*rt_current->signal)(); @@ -351,6 +361,8 @@ return -EINVAL; } + TRACE_RTAI_TASK(TRACE_RTAI_EV_TASK_DELETE, task->tid, 0, 0); + hard_save_flags_and_cli(flags); if (task->state & SEMAPHORE) { (task->blocked_on.sem)->count++; @@ -401,6 +413,8 @@ RTIME now; int prio, delay, preempt; + TRACE_RTAI_TIMER(TRACE_RTAI_EV_TIMER_HANDLE_EXPIRY, 0, 0); + rt_times.tick_time = rt_times.intr_time; rt_time_h = rt_times.tick_time + rt_half_tick; if (rt_times.tick_time >= rt_times.linux_time) { @@ -463,6 +477,9 @@ restore_fpenv(fpu_task->fpu_reg); } } + + TRACE_RTAI_SCHED_CHANGE(rt_current->tid, new_task->tid, rt_current->state); + rt_switch_to(new_task); if (rt_current->signal) { (*rt_current->signal)(); @@ -587,6 +604,9 @@ if (task->magic != RT_TASK_MAGIC) { return -EINVAL; } + + TRACE_RTAI_TASK(TRACE_RTAI_EV_TASK_SIG_HANDLER, task->tid, (uint32_t) handler, 0); + task->signal = handler; return 0; } @@ -876,6 +896,8 @@ { unsigned long flags; + TRACE_RTAI_TASK(TRACE_RTAI_EV_TASK_YIELD, 0, 0, 0); + hard_save_flags_and_cli(flags); if (rt_current->next) { (rt_current->prev)->next = rt_current->next; @@ -898,6 +920,8 @@ return -EINVAL; } + TRACE_RTAI_TASK(TRACE_RTAI_EV_TASK_SUSPEND, task->tid, 0, 0); + hard_save_flags_and_cli(flags); task->state |= SUSPENDED; if (task == rt_current) { @@ -916,6 +940,8 @@ return -EINVAL; } + TRACE_RTAI_TASK(TRACE_RTAI_EV_TASK_RESUME, task->tid, 0, 0); + hard_save_flags_and_cli(flags); if (((task->state &= ~SUSPENDED) & ~DELAYED) == READY) { rt_schedule(); @@ -932,6 +958,9 @@ if (task->magic != RT_TASK_MAGIC) { return -EINVAL; } + + TRACE_RTAI_TASK(TRACE_RTAI_EV_TASK_MAKE_PERIOD_RELATIVE, task->tid, start_delay, period); + start_delay = nano2count(start_delay); period = nano2count(period); flags = rt_global_save_flags_and_cli(); @@ -951,6 +980,9 @@ if (task->magic != RT_TASK_MAGIC) { return -EINVAL; } + + TRACE_RTAI_TASK(TRACE_RTAI_EV_TASK_MAKE_PERIOD, task->tid, start_time, period); + hard_save_flags_and_cli(flags); task->resume_time = start_time; task->period = period; @@ -965,6 +997,8 @@ { unsigned long flags; + TRACE_RTAI_TASK(TRACE_RTAI_EV_TASK_WAIT_PERIOD, 0, 0, 0); + hard_save_flags_and_cli(flags); if ((rt_current->resume_time += rt_current->period) > rt_time_h) { rt_current->state |= DELAYED; @@ -983,6 +1017,9 @@ void rt_busy_sleep(int ns) { RTIME end_time; + + TRACE_RTAI_TASK(TRACE_RTAI_EV_TASK_BUSY_SLEEP, ns, 0, 0); + end_time = rdtsc() + llimd(ns, tuned.cpu_freq, NANO); while (rdtsc() < end_time); } @@ -991,6 +1028,9 @@ void rt_sleep(RTIME delay) { unsigned long flags; + + TRACE_RTAI_TASK(TRACE_RTAI_EV_TASK_SLEEP, 0, delay, 0); + hard_save_flags_and_cli(flags); if ((rt_current->resume_time = (oneshot_timer ? rdtsc(): rt_times.tick_time) + delay) > rt_time_h) { rt_current->state |= DELAYED; @@ -1003,6 +1043,9 @@ void rt_sleep_until(RTIME time) { unsigned long flags; + + TRACE_RTAI_TASK(TRACE_RTAI_EV_TASK_SLEEP_UNTIL, 0, time, 0); + hard_save_flags_and_cli(flags); if ((rt_current->resume_time = time) > rt_time_h) { rt_current->state |= DELAYED; @@ -1015,6 +1058,9 @@ void rt_sem_init(SEM *sem, int value) { + + TRACE_RTAI_SEM(TRACE_RTAI_EV_SEM_INIT, sem, value); + sem->type = 0; sem->count = value; sem->magic = RT_SEM_MAGIC; @@ -1044,6 +1090,8 @@ return SEM_ERR; } + TRACE_RTAI_SEM(TRACE_RTAI_EV_SEM_DELETE, sem, 0); + hard_save_flags_and_cli(flags); sem->magic = 0; q = &(sem->queue); @@ -1064,6 +1112,8 @@ return SEM_ERR; } + TRACE_RTAI_SEM(TRACE_RTAI_EV_SEM_SIGNAL, sem, 0); + hard_save_flags_and_cli(flags); if ((sem->count)++ < 0) { if ((task = (sem->queue.next)->task)) { @@ -1124,6 +1174,8 @@ return SEM_ERR; } + TRACE_RTAI_SEM(TRACE_RTAI_EV_SEM_WAIT, sem, 0); + hard_save_flags_and_cli(flags); count = sem->count; if (--(sem->count) < 0) { @@ -1159,6 +1211,8 @@ return SEM_ERR; } + TRACE_RTAI_SEM(TRACE_RTAI_EV_SEM_WAIT_IF, sem, 0); + hard_save_flags_and_cli(flags); if ((count = sem->count) > 0) { sem->count--; @@ -1178,6 +1232,8 @@ return SEM_ERR; } + TRACE_RTAI_SEM(TRACE_RTAI_EV_SEM_WAIT_UNTIL, sem, time); + hard_save_flags_and_cli(flags); count = sem->count; if (--(sem->count) < 0) { @@ -1230,6 +1286,8 @@ return MSG_ERR; } + TRACE_RTAI_MSG(TRACE_RTAI_EV_MSG_SEND, task->tid, msg, 0); + hard_save_flags_and_cli(flags); if ((task->state & RECEIVE) && (!task->msg_queue.task || task->msg_queue.task == rt_current)) { @@ -1274,6 +1332,8 @@ return MSG_ERR; } + TRACE_RTAI_MSG(TRACE_RTAI_EV_MSG_SEND_IF, task->tid, msg, 0); + hard_save_flags_and_cli(flags); if ((task->state & RECEIVE) && (!task->msg_queue.task || task->msg_queue.task == rt_current)) { @@ -1304,6 +1364,8 @@ return MSG_ERR; } + TRACE_RTAI_MSG(TRACE_RTAI_EV_MSG_SEND_UNTIL, task->tid, msg, time); + hard_save_flags_and_cli(flags); if ((task->state & RECEIVE) && (!task->msg_queue.task || task->msg_queue.task == rt_current)) { @@ -1359,6 +1421,8 @@ return MSG_ERR; } + TRACE_RTAI_RPC(TRACE_RTAI_EV_RPC_MAKE, task->tid, to_do, 0); + hard_save_flags_and_cli(flags); if ((task->state & RECEIVE) && (!task->msg_queue.task || task->msg_queue.task == rt_current)) { @@ -1403,6 +1467,9 @@ if (task->magic != RT_TASK_MAGIC) { return MSG_ERR; } + + TRACE_RTAI_RPC(TRACE_RTAI_EV_RPC_MAKE_IF, task->tid, to_do, 0); + hard_save_flags_and_cli(flags); if ((task->state & RECEIVE) && (!task->msg_queue.task || task->msg_queue.task == rt_current)) { @@ -1436,6 +1503,8 @@ return MSG_ERR; } + TRACE_RTAI_RPC(TRACE_RTAI_EV_RPC_MAKE_UNTIL, task->tid, to_do, time); + hard_save_flags_and_cli(flags); if ((task->state & RECEIVE) && (!task->msg_queue.task || task->msg_queue.task == rt_current)) { @@ -1498,6 +1567,8 @@ return MSG_ERR; } + TRACE_RTAI_RPC(TRACE_RTAI_EV_RPC_RETURN, task->tid, result, 0); + hard_save_flags_and_cli(flags); if ((task->state & RETURN) && task->msg_queue.task == rt_current) { (task->queue.next)->prev = task->queue.prev; @@ -1525,6 +1596,9 @@ return MSG_ERR; } + if(!task) { TRACE_RTAI_MSG(TRACE_RTAI_EV_MSG_RECV, 0, 0, 0);} + else { TRACE_RTAI_MSG(TRACE_RTAI_EV_MSG_RECV, task->tid, 0, 0);} + hard_save_flags_and_cli(flags); if (!task) task = (rt_current->msg_queue.next)->task; @@ -1584,6 +1658,9 @@ return MSG_ERR; } + if(!task) { TRACE_RTAI_MSG(TRACE_RTAI_EV_MSG_RECV_IF, 0, 0, 0); } + else { TRACE_RTAI_MSG(TRACE_RTAI_EV_MSG_RECV_IF, task->tid, 0, 0); } + hard_save_flags_and_cli(flags); if (!task) task = (rt_current->msg_queue.next)->task; @@ -1636,6 +1713,9 @@ return MSG_ERR; } + if(!task) { TRACE_RTAI_MSG(TRACE_RTAI_EV_MSG_RECV_UNTIL, 0, 0, time); } + else { TRACE_RTAI_MSG(TRACE_RTAI_EV_MSG_RECV_UNTIL, task->tid, 0, time); } + hard_save_flags_and_cli(flags); if (!task) task = (rt_current->msg_queue.next)->task; @@ -1888,6 +1968,9 @@ if (!(mbx->bufadr = kmalloc(size, GFP_KERNEL))) { return -ENOMEM; } + + TRACE_RTAI_MBX(TRACE_RTAI_EV_MBX_INIT, mbx, size, 0); + rt_sem_init(&(mbx->sndsem), 1); rt_sem_init(&(mbx->rcvsem), 1); mbx->magic = RT_MBX_MAGIC; @@ -1902,6 +1985,9 @@ int rt_mbx_delete(MBX *mbx) { CHK_MBX_MAGIC; + + TRACE_RTAI_MBX(TRACE_RTAI_EV_MBX_DELETE, mbx, 0, 0); + mbx->magic = 0; if (rt_sem_delete(&(mbx->sndsem)) || rt_sem_delete(&(mbx->rcvsem))) { return -EFAULT; @@ -1914,6 +2000,9 @@ int rt_mbx_send(MBX *mbx, void *msg, int msg_size) { CHK_MBX_MAGIC; + + TRACE_RTAI_MBX(TRACE_RTAI_EV_MBX_SEND, mbx, msg_size, 0); + if (mbx_sem_wait(&(mbx->sndsem))) { return msg_size; } @@ -1934,6 +2023,9 @@ unsigned long flags; CHK_MBX_MAGIC; + + TRACE_RTAI_MBX(TRACE_RTAI_EV_MBX_SEND_WP, mbx, msg_size, 0); + hard_save_flags_and_cli(flags); if (mbx->sndsem.count && mbx->frbs) { mbx->sndsem.count = 0; @@ -1953,6 +2045,9 @@ unsigned long flags; CHK_MBX_MAGIC; + + TRACE_RTAI_MBX(TRACE_RTAI_EV_MBX_SEND_IF, mbx, msg_size, 0); + hard_save_flags_and_cli(flags); if (mbx->sndsem.count && msg_size <= mbx->frbs) { mbx->sndsem.count = 0; @@ -1970,6 +2065,9 @@ int rt_mbx_send_until(MBX *mbx, void *msg, int msg_size, RTIME time) { CHK_MBX_MAGIC; + + TRACE_RTAI_MBX(TRACE_RTAI_EV_MBX_SEND_UNTIL, mbx, msg_size, time); + if (mbx_sem_wait_until(&(mbx->sndsem), time)) { return msg_size; } @@ -1995,6 +2093,9 @@ { CHK_MBX_MAGIC; + + TRACE_RTAI_MBX(TRACE_RTAI_EV_MBX_RECV, mbx, msg_size, 0); + if (mbx_sem_wait(&(mbx->rcvsem))) { return msg_size; } @@ -2015,6 +2116,9 @@ unsigned long flags; CHK_MBX_MAGIC; + + TRACE_RTAI_MBX(TRACE_RTAI_EV_MBX_RECV_WP, mbx, msg_size, 0); + hard_save_flags_and_cli(flags); if (mbx->rcvsem.count && mbx->avbs) { mbx->rcvsem.count = 0; @@ -2034,6 +2138,9 @@ unsigned long flags; CHK_MBX_MAGIC; + + TRACE_RTAI_MBX(TRACE_RTAI_EV_MBX_RECV_IF, mbx, msg_size, 0); + hard_save_flags_and_cli(flags); if (mbx->rcvsem.count && msg_size <= mbx->avbs) { mbx->rcvsem.count = 0; @@ -2051,6 +2158,9 @@ int rt_mbx_receive_until(MBX *mbx, void *msg, int msg_size, RTIME time) { CHK_MBX_MAGIC; + + TRACE_RTAI_MBX(TRACE_RTAI_EV_MBX_RECV_UNTIL, mbx, msg_size, time); + if (mbx_sem_wait_until(&(mbx->rcvsem), time)) { return msg_size; }