[PATCH 1/5] capture: Removal of capture task tracking.
Jennifer Averett
Jennifer.Averett at OARcorp.com
Tue Sep 23 12:29:48 UTC 2014
I tried to limit how much functionality I removed from the capture engine with this
set of patches and limit it to what had to be removed in order to support removal of
capture tasks. I have no problem with it moving to cpuuse, but I think it would need to
be modified to use a printk plugin and account for __RTEMS_USE_TICKS_FOR_STATISTICS__ .
jennifer
> -----Original Message-----
> From: devel [mailto:devel-bounces at rtems.org] On Behalf Of Chris Johns
> Sent: Monday, September 22, 2014 4:57 PM
> To: devel at rtems.org
> Subject: Re: [PATCH 1/5] capture: Removal of capture task tracking.
>
> On 23/09/2014 12:00 am, Jennifer Averett wrote:
> > This patch removes functionality for stack checking from
> > the capture engine and requiresi the use of existing rtems
> > functions for this information. It modifies ctload to use
> > functionality similar to rtems cpuusage. It removes the
> > capture task and stores a new capture task record the first
> > time the task is seen. The per task data that was still
> > needed is scaled down and stored in the tcb.
>
> If the capture engine is not needed for ctload to work why not move that
> code out of here and into the cpuuse command ? It would appear more
> available to users.
>
> > ---
> > cpukit/libmisc/capture/capture-cli.c | 383 ++++++++++++++----------
> > cpukit/libmisc/capture/capture.c | 367 ++++++-----------------
> > cpukit/libmisc/capture/capture.h | 295 ++++--------------
> > cpukit/libmisc/capture/capture_user_extension.c | 219 +++-----------
> > cpukit/libmisc/capture/captureimpl.h | 53 +---
> > 5 files changed, 420 insertions(+), 897 deletions(-)
> >
> > diff --git a/cpukit/libmisc/capture/capture-cli.c
> b/cpukit/libmisc/capture/capture-cli.c
> > index 2aa7c9c..6fe7e6c 100644
> > --- a/cpukit/libmisc/capture/capture-cli.c
> > +++ b/cpukit/libmisc/capture/capture-cli.c
> > @@ -35,12 +35,28 @@
> > #include <rtems.h>
> > #include <rtems/capture-cli.h>
> > #include <rtems/monitor.h>
> > -
> > +#include <rtems/cpuuse.h>
> > +#
> > #define RC_UNUSED __attribute__((unused))
> >
> > #define RTEMS_CAPTURE_CLI_MAX_LOAD_TASKS (20)
> >
> > /*
> > + * Counter used to count the number of active tasks.
> > + */
> > +static int rtems_capture_cli_task_count = 0;
> > +
> > +/*
> > + * Array of tasks sorted by load.
> > + */
> > +static rtems_tcb*
> rtems_capture_cli_load_tasks[RTEMS_CAPTURE_CLI_MAX_LOAD_TASKS +
> 1];
> > +
> > +/*
> > + * The load for each tcb at the moment rtems_capture_cli_load_tasks was
> generated.
> > + */
> > +static unsigned long long
> rtems_capture_cli_load[RTEMS_CAPTURE_CLI_MAX_LOAD_TASKS + 1];
> > +
> > +/*
> > * The user capture timestamper.
> > */
> > static rtems_capture_timestamp capture_timestamp;
> > @@ -233,6 +249,104 @@ rtems_capture_cli_print_timestamp (uint64_t
> uptime)
> > fprintf (stdout, "%5lu:%02lu:%02lu.%09lu", hours, minutes, seconds,
> nanosecs);
> > }
> >
> > +static void
> > +rtems_capture_cli_print_task (rtems_tcb *tcb)
> > +{
> > + rtems_task_priority ceiling = rtems_capture_watch_get_ceiling ();
> > + rtems_task_priority floor = rtems_capture_watch_get_floor ();
> > + rtems_task_priority priority;
> > + int length;
> > +
> > + priority = rtems_capture_task_real_priority (tcb);
> > +
> > + fprintf (stdout, " ");
> > + rtems_monitor_dump_id (rtems_capture_task_id (tcb));
> > + fprintf (stdout, " ");
> > + rtems_monitor_dump_name (rtems_capture_task_id (tcb));
> > + fprintf (stdout, " ");
> > + rtems_monitor_dump_priority (rtems_capture_task_start_priority
> (tcb));
> > + fprintf (stdout, " ");
> > + rtems_monitor_dump_priority (rtems_capture_task_real_priority (tcb));
> > + fprintf (stdout, " ");
> > + rtems_monitor_dump_priority (rtems_capture_task_curr_priority
> (tcb));
> > + fprintf (stdout, " ");
> > + length = rtems_monitor_dump_state (rtems_capture_task_state (tcb));
> > + fprintf (stdout, "%*c", 14 - length, ' ');
> > + fprintf (stdout, " %c%c",
> > + 'a',
> > + rtems_capture_task_flags (tcb) & RTEMS_CAPTURE_TRACED ? 't' : '-
> ');
> > +
> > + if ((floor > ceiling) && (ceiling > priority))
> > + fprintf (stdout, "--");
> > + else
> > + {
> > + uint32_t flags = rtems_capture_task_control_flags (tcb);
> > + fprintf (stdout, "%c%c",
> > + rtems_capture_task_control (tcb) ?
> > + (flags & RTEMS_CAPTURE_WATCH ? 'w' : '+') : '-',
> > + rtems_capture_watch_global_on () ? 'g' : '-');
> > + }
> > + fprintf (stdout, "\n");
> > +}
> > +static void
> > +rtems_caputure_cli_print_record_std(rtems_capture_record_t* rec,
> uint64_t diff)
> > +{
> > + uint32_t event;
> > + int e;
> > +
> > + event = rec->events >> RTEMS_CAPTURE_EVENT_START;
> > +
> > + for (e = RTEMS_CAPTURE_EVENT_START; e <
> RTEMS_CAPTURE_EVENT_END; e++)
> > + {
> > + if (event & 1)
> > + {
> > + rtems_capture_cli_print_timestamp (rec->time);
> > + fprintf (stdout, " %9" PRId64 " ", diff);
> > + rtems_monitor_dump_id (rec->task_id);
> > + fprintf(stdout, " %3" PRId32 " %3" PRId32 " %s\n",
> > + (rec->events >> RTEMS_CAPTURE_REAL_PRIORITY_EVENT) & 0xff,
> > + (rec->events >> RTEMS_CAPTURE_CURR_PRIORITY_EVENT) & 0xff,
> > + rtems_capture_event_text (e));
> > + }
> > + event >>= 1;
> > + }
> > +}
> > +
> > +static void
> > +rtems_caputre_cli_print_record_task(rtems_capture_record_t* rec)
> > +{
> > + rtems_capture_task_record_t* task_rec =
> (rtems_capture_task_record_t*) rec;
> > +
> > + rtems_capture_cli_print_timestamp (rec->time);
> > + fprintf (stdout, " ");
> > + rtems_monitor_dump_id (rec->task_id);
> > + fprintf (stdout, " %c%c%c%c",
> > + (char) (task_rec->name >> 24) & 0xff,
> > + (char) (task_rec->name >> 16) & 0xff,
> > + (char) (task_rec->name >> 8) & 0xff,
> > + (char) (task_rec->name >> 0) & 0xff);
> > + fprintf (stdout, " %3" PRId32 " %3" PRId32 "\n",
> > + task_rec->start_priority,
> > + task_rec->stack_size);
> > +}
> > +
> > +/*
> > + * rtems_capture_cli_count_tasks
> > + *
> > + * DESCRIPTION:
> > + *
> > + * This function is called for each tcb and counts the
> > + * number of tasks.
> > + *
> > + */
> > +
> > +static void
> > +rtems_capture_cli_count_tasks (rtems_tcb *tcb)
> > +{
> > + rtems_capture_cli_task_count++;
> > +}
> > +
> > +
> > /*
> > * rtems_capture_cli_task_list
> > *
> > @@ -248,71 +362,49 @@ rtems_capture_cli_task_list (int
> argc RC_UNUSED,
> > const rtems_monitor_command_arg_t* command_arg
> RC_UNUSED,
> > bool verbose RC_UNUSED)
> > {
> > - rtems_task_priority ceiling = rtems_capture_watch_get_ceiling ();
> > - rtems_task_priority floor = rtems_capture_watch_get_floor ();
> > - rtems_capture_task_t* task = rtems_capture_get_task_list ();
> > - int count = rtems_capture_task_count ();
> > rtems_capture_time_t uptime;
> >
> > rtems_capture_time (&uptime);
> >
> > + rtems_capture_cli_task_count = 0;
> > + rtems_iterate_over_all_threads (rtems_capture_cli_count_tasks);
> > +
> > fprintf (stdout, "uptime: ");
> > rtems_capture_cli_print_timestamp (uptime);
> > - fprintf (stdout, "\ntotal %i\n", count);
> > -
> > - while (task)
> > - {
> > - rtems_task_priority priority;
> > - int32_t stack_used;
> > - int32_t time_used;
> > - int length;
> > + fprintf (stdout, "\ntotal %i\n", rtems_capture_cli_task_count);
> > + rtems_iterate_over_all_threads (rtems_capture_cli_print_task);
> > +}
> >
> > - stack_used = rtems_capture_task_stack_usage (task);
> > - if (stack_used)
> > - stack_used = (stack_used * 100) / rtems_capture_task_stack_size
> (task);
> > +static void
> > +rtems_capture_cli_task_sort (rtems_tcb* tcb)
> > +{
> > + int i;
> > + int j;
> >
> > - if (stack_used > 100)
> > - stack_used = 100;
> > + if (tcb)
> > + {
> > + rtems_capture_time_t l = tcb->cpu_time_used;
> >
> > - time_used = (rtems_capture_task_time (task) * 100) / uptime;
> > + rtems_capture_cli_task_count++;
> >
> > - if (time_used > 100)
> > - time_used = 100;
> > + for (i = 0; i < RTEMS_CAPTURE_CLI_MAX_LOAD_TASKS; i++)
> > + {
> > + if (rtems_capture_cli_load_tasks[i])
> > + {
> > + if ((l == 0) || (l < rtems_capture_cli_load[i]))
> > + continue;
> >
> > - priority = rtems_capture_task_real_priority (task);
> > + for (j = (RTEMS_CAPTURE_CLI_MAX_LOAD_TASKS - 1); j >= i; j--)
> > + {
> > + rtems_capture_cli_load_tasks[j + 1] =
> rtems_capture_cli_load_tasks[j];
> > + rtems_capture_cli_load[j + 1] = rtems_capture_cli_load[j];
> > + }
> > + }
> >
> > - fprintf (stdout, " ");
> > - rtems_monitor_dump_id (rtems_capture_task_id (task));
> > - fprintf (stdout, " ");
> > - rtems_monitor_dump_name (rtems_capture_task_id (task));
> > - fprintf (stdout, " ");
> > - rtems_monitor_dump_priority (rtems_capture_task_start_priority
> (task));
> > - fprintf (stdout, " ");
> > - rtems_monitor_dump_priority (rtems_capture_task_real_priority
> (task));
> > - fprintf (stdout, " ");
> > - rtems_monitor_dump_priority (rtems_capture_task_curr_priority
> (task));
> > - fprintf (stdout, " ");
> > - length = rtems_monitor_dump_state (rtems_capture_task_state
> (task));
> > - fprintf (stdout, "%*c", 14 - length, ' ');
> > - fprintf (stdout, " %c%c",
> > - rtems_capture_task_valid (task) ? 'a' : 'd',
> > - rtems_capture_task_flags (task) & RTEMS_CAPTURE_TRACED ? 't' :
> '-');
> > -
> > - if ((floor > ceiling) && (ceiling > priority))
> > - fprintf (stdout, "--");
> > - else
> > - {
> > - uint32_t flags = rtems_capture_task_control_flags (task);
> > - fprintf (stdout, "%c%c",
> > - rtems_capture_task_control (task) ?
> > - (flags & RTEMS_CAPTURE_WATCH ? 'w' : '+') : '-',
> > - rtems_capture_watch_global_on () ? 'g' : '-');
> > + rtems_capture_cli_load_tasks[i] = tcb;
> > + rtems_capture_cli_load[i] = l;
> > + break;
> > }
> > - fprintf (stdout, " %3" PRId32 "%% %3" PRId32 "%% ", stack_used,
> time_used);
> > - rtems_capture_cli_print_timestamp (rtems_capture_task_time (task));
> > - fprintf (stdout, "\n");
> > -
> > - task = rtems_capture_next_task (task);
> > }
> > }
> >
> > @@ -328,26 +420,22 @@ rtems_capture_cli_task_list (int
> argc RC_UNUSED,
> > static void
> > rtems_capture_cli_task_load_thread (rtems_task_argument arg)
> > {
> > + rtems_tcb* tcb;
> > rtems_task_priority ceiling = rtems_capture_watch_get_ceiling ();
> > rtems_task_priority floor = rtems_capture_watch_get_floor ();
> > int last_count = 0;
> > FILE* pstdout = (FILE*) arg;
> > + int i;
> > + int j;
> >
> > fileno(stdout);
> > stdout = pstdout;
> >
> > while (true)
> > {
> > - rtems_capture_task_t*
> tasks[RTEMS_CAPTURE_CLI_MAX_LOAD_TASKS + 1];
> > - unsigned long long load[RTEMS_CAPTURE_CLI_MAX_LOAD_TASKS +
> 1];
> > - rtems_capture_task_t* task;
> > - rtems_capture_time_t uptime;
> > - rtems_capture_time_t total_time;
> > - int count = 0;
> > - int i;
> > - int j;
> > -
> > - rtems_capture_time (&uptime);
> > + Timestamp_Control uptime, total, ran, uptime_at_last_reset;
> > + uint32_t seconds, nanoseconds;
> > + size_t size;
> >
> > cli_load_thread_active = 1;
> >
> > @@ -356,114 +444,98 @@ rtems_capture_cli_task_load_thread
> (rtems_task_argument arg)
> > * into our local arrays. We only handle a limited number of
> > * tasks.
> > */
> > + size = sizeof (rtems_capture_cli_load_tasks);
> > + memset (rtems_capture_cli_load_tasks, 0, size);
> > + memset (rtems_capture_cli_load, 0, sizeof (rtems_capture_cli_load));
> >
> > - memset (tasks, 0, sizeof (tasks));
> > - memset (load, 0, sizeof (load));
> > + _Timestamp_Set_to_zero( &total );
> > + uptime_at_last_reset = CPU_usage_Uptime_at_last_reset;
> > + _TOD_Get_uptime( &uptime );
> > + seconds = _Timestamp_Get_seconds( &uptime );
> > + nanoseconds = _Timestamp_Get_nanoseconds( &uptime ) /
> > + TOD_NANOSECONDS_PER_MICROSECOND;
> >
> > - task = rtems_capture_get_task_list ();
> > -
> > - total_time = 0;
> > -
> > - while (task)
> > - {
> > - if (rtems_capture_task_valid (task))
> > - {
> > - rtems_capture_time_t l = rtems_capture_task_delta_time (task);
> > -
> > - count++;
> > -
> > - total_time += l;
> > -
> > - for (i = 0; i < RTEMS_CAPTURE_CLI_MAX_LOAD_TASKS; i++)
> > - {
> > - if (tasks[i])
> > - {
> > - if ((l == 0) || (l < load[i]))
> > - continue;
> > -
> > - for (j = (RTEMS_CAPTURE_CLI_MAX_LOAD_TASKS - 1); j >= i; j--)
> > - {
> > - tasks[j + 1] = tasks[j];
> > - load[j + 1] = load[j];
> > - }
> > - }
> > -
> > - tasks[i] = task;
> > - load[i] = l;
> > - break;
> > - }
> > - }
> > - task = rtems_capture_next_task (task);
> > - }
> > + rtems_iterate_over_all_threads (rtems_capture_cli_task_sort);
> >
> > fprintf (stdout, "\x1b[H\x1b[J Press ENTER to exit.\n\n");
> > fprintf (stdout, "uptime: ");
> > - rtems_capture_cli_print_timestamp (uptime);
> > + fprintf (stdout, "%7" PRIu32 ".%06" PRIu32 "\n", seconds,
> nanoseconds);
> > fprintf (stdout,
> > "\n\n"
> > - " PID NAME RPRI CPRI STATE %%CPU %%STK FLGS EXEC
> TIME\n");
> > + " PID NAME RPRI CPRI STATE EXEC TIME %%CPU\n");
> >
> > - if (count > last_count)
> > - j = count;
> > + if (rtems_capture_cli_task_count > last_count)
> > + j = rtems_capture_cli_task_count;
> > else
> > j = last_count;
> >
> > for (i = 0; i < RTEMS_CAPTURE_CLI_MAX_LOAD_TASKS; i++)
> > {
> > rtems_task_priority priority;
> > - int stack_used;
> > - int task_load;
> > - int k;
> > -
> > - if (!tasks[i])
> > + Timestamp_Control last;
> > + uint32_t ival, fval;
> > +
> > + if (!rtems_capture_cli_load_tasks[i])
> > break;
> >
> > j--;
> >
> > - stack_used = rtems_capture_task_stack_usage (tasks[i]);
> > - if (stack_used)
> > - stack_used = (stack_used * 100) / rtems_capture_task_stack_size
> (tasks[i]);
> > -
> > - if (stack_used > 100)
> > - stack_used = 100;
> > -
> > - task_load = (int) ((load[i] * 100000) / total_time);
> > -
> > - priority = rtems_capture_task_real_priority (tasks[i]);
> > + /*
> > + * If this is the currently executing thread, account for time
> > + * since the last context switch.
> > + */
> > + tcb = rtems_capture_cli_load_tasks[i];
> > + ran = rtems_capture_cli_load[i];
> > + if ( _Thread_is_executing_on_a_core( tcb, &last ) ) {
> > + Timestamp_Control used;
> > + _TOD_Get_uptime( &uptime );
> > + _Timestamp_Subtract( &last, &uptime, &used );
> > + _Timestamp_Add_to( &ran, &used );
> > + } else {
> > + _TOD_Get_uptime( &uptime );
> > + }
> > + _Timestamp_Subtract( &uptime_at_last_reset, &uptime, &total );
> > + _Timestamp_Divide( &ran, &total, &ival, &fval );
> > + seconds = _Timestamp_Get_seconds( &ran );
> > + nanoseconds = _Timestamp_Get_nanoseconds( &ran ) /
> > + TOD_NANOSECONDS_PER_MICROSECOND;
> > +
> > + priority = rtems_capture_task_real_priority (tcb);
> >
> > fprintf (stdout, "\x1b[K");
> > - rtems_monitor_dump_id (rtems_capture_task_id (tasks[i]));
> > + rtems_monitor_dump_id (rtems_capture_task_id (tcb));
> > fprintf (stdout, " ");
> > - rtems_monitor_dump_name (rtems_capture_task_id (tasks[i]));
> > + rtems_monitor_dump_name (rtems_capture_task_id (tcb));
> > fprintf (stdout, " ");
> > rtems_monitor_dump_priority (priority);
> > fprintf (stdout, " ");
> > - rtems_monitor_dump_priority (rtems_capture_task_curr_priority
> (tasks[i]));
> > + rtems_monitor_dump_priority (rtems_capture_task_curr_priority
> (tcb));
> > fprintf (stdout, " ");
> > - k = rtems_monitor_dump_state (rtems_capture_task_state (tasks[i]));
> > - fprintf (stdout, "%*c %3i.%03i%% ", 14 - k, ' ',
> > - task_load / 1000, task_load % 1000);
> > - fprintf (stdout, "%3i%% %c%c", stack_used,
> > - rtems_capture_task_valid (tasks[i]) ? 'a' : 'd',
> > - rtems_capture_task_flags (tasks[i]) & RTEMS_CAPTURE_TRACED ?
> 't' : '-');
> > + rtems_monitor_dump_state (rtems_capture_task_state (tcb));
> > + fprintf (stdout,
> > + "%7" PRIu32 ".%06" PRIu32 " |%4" PRIu32 ".%03" PRIu32 ,
> > + seconds, nanoseconds, ival, fval
> > + );
> > + fprintf (stdout, " %c%c",
> > + 'a',
> > + rtems_capture_task_flags (tcb) & RTEMS_CAPTURE_TRACED ? 't' :
> '-');
> >
> > if ((floor > ceiling) && (ceiling > priority))
> > fprintf (stdout, "--");
> > else
> > fprintf (stdout, "%c%c",
> > - rtems_capture_task_control (tasks[i]) ?
> > - (rtems_capture_task_control_flags (tasks[i]) &
> > + rtems_capture_task_control (tcb) ?
> > + (rtems_capture_task_control_flags (tcb) &
> > RTEMS_CAPTURE_WATCH ? 'w' : '+') : '-',
> > rtems_capture_watch_global_on () ? 'g' : '-');
> >
> > fprintf (stdout, " ");
> > - rtems_capture_cli_print_timestamp (rtems_capture_task_time
> (tasks[i]));
> > fprintf (stdout, "\n");
> > }
> >
> > - if (count < RTEMS_CAPTURE_CLI_MAX_LOAD_TASKS)
> > + if (rtems_capture_cli_task_count <
> RTEMS_CAPTURE_CLI_MAX_LOAD_TASKS)
> > {
> > - j = RTEMS_CAPTURE_CLI_MAX_LOAD_TASKS - count;
> > + j = RTEMS_CAPTURE_CLI_MAX_LOAD_TASKS -
> rtems_capture_cli_task_count;
> > while (j > 0)
> > {
> > fprintf (stdout, "\x1b[K\n");
> > @@ -471,7 +543,7 @@ rtems_capture_cli_task_load_thread
> (rtems_task_argument arg)
> > }
> > }
> >
> > - last_count = count;
> > + last_count = rtems_capture_cli_task_count;
> >
> > cli_load_thread_active = 0;
> >
> > @@ -1415,42 +1487,23 @@ rtems_capture_cli_trace_records (int
> argc,
> > rec = (rtems_capture_record_t*) ptr;
> >
> > if (csv)
> > - fprintf (stdout, "%08" PRIxPTR ",%03" PRIu32
> > + fprintf (stdout, "%08" PRIu32 ",%03" PRIu32
> > ",%03" PRIu32 ",%04" PRIx32 ",%" PRId64 "\n",
> > - (uintptr_t) rec->task,
> > + rec->task_id,
> > (rec->events >> RTEMS_CAPTURE_REAL_PRIORITY_EVENT) &
> 0xff,
> > (rec->events >> RTEMS_CAPTURE_CURR_PRIORITY_EVENT) &
> 0xff,
> > (rec->events >> RTEMS_CAPTURE_EVENT_START),
> > (uint64_t) rec->time);
> > - else
> > - {
> > - uint64_t diff = 0;
> > - uint32_t event;
> > - int e;
> > -
> > - event = rec->events >> RTEMS_CAPTURE_EVENT_START;
> > -
> > - for (e = RTEMS_CAPTURE_EVENT_START; e <
> RTEMS_CAPTURE_EVENT_END; e++)
> > - {
> > - if (event & 1)
> > - {
> > - rtems_capture_cli_print_timestamp (rec->time);
> > - if (last_t)
> > - diff = rec->time - last_t;
> > - last_t = rec->time;
> > - fprintf (stdout, " %9" PRId64 " ", diff);
> > - rtems_monitor_dump_id (rtems_capture_task_id (rec->task));
> > - fprintf (stdout, " %c%c%c%c",
> > - (char) (rec->task->name >> 24) & 0xff,
> > - (char) (rec->task->name >> 16) & 0xff,
> > - (char) (rec->task->name >> 8) & 0xff,
> > - (char) (rec->task->name >> 0) & 0xff);
> > - fprintf (stdout, " %3" PRId32 " %3" PRId32 " %s\n",
> > - (rec->events >> RTEMS_CAPTURE_REAL_PRIORITY_EVENT) &
> 0xff,
> > - (rec->events >> RTEMS_CAPTURE_CURR_PRIORITY_EVENT) &
> 0xff,
> > - rtems_capture_event_text (e));
> > - }
> > - event >>= 1;
> > + else {
> > + if ((rec->events >> RTEMS_CAPTURE_EVENT_START) == 0)
> > + rtems_caputre_cli_print_record_task( rec );
> > + else {
> > + uint64_t diff = 0;
> > + if (last_t)
> > + diff = rec->time - last_t;
> > + last_t = rec->time;
> > +
> > + rtems_caputure_cli_print_record_std( rec, diff );
> > }
> > }
> > ptr += rec->size;
> > diff --git a/cpukit/libmisc/capture/capture.c
> b/cpukit/libmisc/capture/capture.c
> > index 64d2699..6c839d9 100644
> > --- a/cpukit/libmisc/capture/capture.c
> > +++ b/cpukit/libmisc/capture/capture.c
> > @@ -27,7 +27,6 @@
> >
> > #include <stdlib.h>
> > #include <string.h>
> > -#include <rtems/rtems/tasksimpl.h>
> >
> > #include "captureimpl.h"
> > #include "capture_buffer.h"
> > @@ -64,10 +63,9 @@
> > /*
> > * RTEMS Capture Data.
> > */
> > -static rtems_capture_buffer_t capture_records = {NULL, 0, 0, 0, 0, 0};
> > +static rtems_capture_buffer_t capture_records = {NULL, 0, 0, 0, 0, 0};
> > static uint32_t capture_count;
> > static uint32_t capture_flags;
> > -static rtems_capture_task_t* capture_tasks;
> > static rtems_capture_control_t* capture_controls;
> > static int capture_extension_index;
> > static rtems_capture_timestamp capture_timestamp;
> > @@ -118,18 +116,6 @@ void rtems_capture_set_flags(uint32_t mask)
> > capture_flags |= mask;
> > }
> >
> > -
> > -rtems_capture_task_t* rtems_capture_find_capture_task( rtems_id
> ct_id )
> > -{
> > - rtems_capture_task_t* ct;
> > -
> > - for (ct = capture_tasks; ct; ct = ct->forw) {
> > - if (ct->id == ct_id)
> > - break;
> > - }
> > - return ct;
> > -}
> > -
> > /*
> > * This function returns the current time. If a handler is provided
> > * by the user get the time from that.
> > @@ -207,7 +193,7 @@ rtems_capture_dup_name (rtems_name* dst,
> rtems_name src)
> > */
> > static inline bool
> > rtems_capture_by_in_to (uint32_t events,
> > - rtems_capture_task_t* by,
> > + rtems_tcb* by,
> > rtems_capture_control_t* to)
> > {
> > uint32_t valid_mask = RTEMS_CAPTURE_CONTROL_FROM_MASK (0);
> > @@ -235,7 +221,8 @@ rtems_capture_by_in_to (uint32_t events,
> > * not set.
> > */
> > if (rtems_capture_match_name_id (to->by[i].name, to->by[i].id,
> > - by->name, by->id))
> > + rtems_capture_task_name( by ),
> > + by->Object.id))
> > return 1;
> > }
> >
> > @@ -247,47 +234,6 @@ rtems_capture_by_in_to (uint32_t events,
> > }
> >
> > /*
> > - * This function raises the reference count.
> > - */
> > -static inline void
> > -rtems_capture_refcount_up (rtems_capture_task_t* task)
> > -{
> > - task->refcount++;
> > -}
> > -
> > -/*
> > - * This function lowers the reference count and if the count
> > - * reaches 0 the task control block is returned to the heap.
> > - */
> > -static inline void
> > -rtems_capture_refcount_down (rtems_capture_task_t* task)
> > -{
> > - if (task->refcount)
> > - task->refcount--;
> > -}
> > -
> > -/*
> > - * This function setups a stack so its usage can be monitored.
> > - */
> > -void
> > -rtems_capture_init_stack_usage (rtems_capture_task_t* task)
> > -{
> > - if (task->tcb)
> > - {
> > - uint32_t* s;
> > - uint32_t i;
> > -
> > - task->stack_size = task->tcb->Start.Initial_stack.size;
> > - task->stack_clean = task->stack_size;
> > -
> > - s = task->tcb->Start.Initial_stack.area;
> > -
> > - for (i = 0; i < (task->stack_size - 128); i += 4)
> > - *(s++) = 0xdeaddead;
> > - }
> > -}
> > -
> > -/*
> > * This function searches for a trigger given a name.
> > */
> > static inline rtems_capture_control_t*
> > @@ -302,6 +248,27 @@ rtems_capture_find_control (rtems_name name,
> rtems_id id)
> > }
> >
> > /*
> > + * This function checks if a new control structure matches
> > + * the given task and sets the control if it does.
> > + */
> > +static void
> > +rtems_capture_initialize_control (rtems_tcb *tcb)
> > +{
> > + rtems_name name;
> > + rtems_capture_control_t* control;
> > +
> > + /*
> > + * We need to scan the default control list to initialise
> > + * this control.
> > + */
> > + rtems_object_get_classic_name( tcb->Object.id, &name );
> > + control = capture_controls;
> > + if (rtems_capture_match_name_id (control->name, control->id,
> > + name, tcb->Object.id))
> > + tcb->capture.control = control;
> > +}
> > +
> > +/*
> > * This function creates a capture control for the capture engine.
> > */
> > static inline rtems_capture_control_t*
> > @@ -309,7 +276,6 @@ rtems_capture_create_control (rtems_name name,
> rtems_id id)
> > {
> > rtems_interrupt_lock_context lock_context;
> > rtems_capture_control_t* control;
> > - rtems_capture_task_t* task;
> >
> > if ((name == 0) && (id == 0))
> > return NULL;
> > @@ -339,14 +305,7 @@ rtems_capture_create_control (rtems_name
> name, rtems_id id)
> >
> > control->next = capture_controls;
> > capture_controls = control;
> > -
> > - /*
> > - * We need to scan the task list as set the control to the
> > - * tasks.
> > - */
> > - for (task = capture_tasks; task != NULL; task = task->forw)
> > - if (rtems_capture_match_name_id (name, id, task->name, task->id))
> > - task->control = control;
> > + rtems_iterate_over_all_threads (rtems_capture_initialize_control);
> >
> > rtems_interrupt_lock_release (&capture_lock, &lock_context);
> > }
> > @@ -354,130 +313,73 @@ rtems_capture_create_control (rtems_name
> name, rtems_id id)
> > return control;
> > }
> >
> > -/*
> > - * This function create the task control.
> > - */
> > -rtems_capture_task_t*
> > -rtems_capture_create_capture_task (rtems_tcb* new_task)
> > +void rtems_capture_record_task( rtems_tcb* tcb )
> > {
> > - rtems_interrupt_lock_context lock_context;
> > - rtems_capture_task_t* task;
> > - rtems_capture_control_t* control;
> > - rtems_name name;
> > - rtems_capture_time_t time;
> > - bool ok;
> > -
> > - ok = rtems_workspace_allocate (sizeof (*task), (void **) &task);
> > -
> > - if (!ok)
> > - {
> > - capture_flags |= RTEMS_CAPTURE_NO_MEMORY;
> > - return NULL;
> > - }
> > -
> > - /*
> > - * Get the current time.
> > - */
> > - rtems_capture_get_time (&time);
> > + rtems_capture_control_t* control;
> > + rtems_capture_task_record_t rec;
> > + void* ptr;
> >
> > + rtems_object_get_classic_name( tcb->Object.id, &rec.name );
> > +
> > /*
> > - * Check the type of name the object has.
> > + * We need to scan the default control list to initialise
> > + * this control if it is a new task.
> > */
> >
> > - rtems_object_get_classic_name( new_task->Object.id, &name );
> > -
> > - rtems_capture_dup_name (&task->name, name);
> > -
> > - task->id = new_task->Object.id;
> > - task->flags = 0;
> > - task->in = 0;
> > - task->refcount = 0;
> > - task->out = 0;
> > - task->tcb = new_task;
> > - task->time = 0;
> > - task->time_in = time;
> > - task->control = 0;
> > - task->last_time = 0;
> > -
> > - task->tcb->extensions[capture_extension_index] = task;
> > -
> > - task->start_priority = _RTEMS_tasks_Priority_from_Core(
> > - new_task->Start.initial_priority
> > - );
> > - task->stack_size = new_task->Start.Initial_stack.size;
> > - task->stack_clean = task->stack_size;
> > -
> > - rtems_interrupt_lock_acquire (&capture_lock, &lock_context);
> > -
> > - task->forw = capture_tasks;
> > - if (task->forw)
> > - task->forw->back = task;
> > - task->back = NULL;
> > - capture_tasks = task;
> > + if (tcb->capture.control == NULL) {
> > + for (control = capture_controls; control != NULL; control = control-
> >next)
> > + if (rtems_capture_match_name_id (control->name, control->id,
> > + rec.name, tcb->Object.id))
> > + tcb->capture.control = control;
> > + }
> >
> > - rtems_interrupt_lock_release (&capture_lock, &lock_context);
> > + rec.stack_size = tcb->Start.Initial_stack.size;
> > + rec.start_priority = _RTEMS_tasks_Priority_from_Core(
> > + tcb->Start.initial_priority
> > + );
> >
> > + tcb->capture.flags |= RTEMS_CAPTURE_RECORD_TASK;
> > +
> > /*
> > - * We need to scan the default control list to initialise
> > - * this control.
> > + * Log the task information. The first time a task is
> > + * seen a record is logged. This record can be identified
> > + * by a 0 in the event identifier.
> > */
> >
> > - for (control = capture_controls; control != NULL; control = control->next)
> > - if (rtems_capture_match_name_id (control->name, control->id,
> > - task->name, task->id))
> > - task->control = control;
> > -
> > - return task;
> > -}
> > -
> > -/*
> > - * This function destroy the task structure if the reference count
> > - * is 0 and the tcb has been cleared signalling the task has been
> > - * deleted.
> > - */
> > -void
> > -rtems_capture_destroy_capture_task (rtems_capture_task_t* task)
> > -{
> > - if (task)
> > - {
> > - rtems_interrupt_lock_context lock_context;
> > -
> > - rtems_interrupt_lock_acquire (&capture_lock, &lock_context);
> > -
> > - if (task->tcb || task->refcount)
> > - task = 0;
> > -
> > - if (task)
> > - {
> > - if (task->forw)
> > - task->forw->back = task->back;
> > - if (task->back)
> > - task->back->forw = task->forw;
> > - else
> > - capture_tasks = task->forw;
> > - }
> > -
> > - rtems_interrupt_lock_release (&capture_lock, &lock_context);
> > -
> > - rtems_workspace_free (task);
> > - }
> > + rtems_capture_begin_add_record (tcb, 0, sizeof(rec), &ptr);
> > + ptr = rtems_capture_append_to_record(
> > + ptr,
> > + &rec.name,
> > + sizeof( rec.name )
> > + );
> > + ptr = rtems_capture_append_to_record(
> > + ptr,
> > + &rec.start_priority,
> > + sizeof( rec.start_priority)
> > + );
> > + ptr = rtems_capture_append_to_record(
> > + ptr,
> > + &rec.stack_size,
> > + sizeof( rec.stack_size)
> > + );
> > + rtems_capture_end_add_record ( ptr );
> > }
> >
> > /*
> > * This function indicates if data should be filtered from the
> > * log.
> > */
> > -bool rtems_capture_filter( rtems_capture_task_t* task,
> > +bool rtems_capture_filter( rtems_tcb* tcb,
> > uint32_t events)
> > {
> > - if (task &&
> > + if (tcb &&
> > ((capture_flags &
> > (RTEMS_CAPTURE_TRIGGERED |
> RTEMS_CAPTURE_ONLY_MONITOR)) ==
> > RTEMS_CAPTURE_TRIGGERED))
> > {
> > rtems_capture_control_t* control;
> >
> > - control = task->control;
> > + control = tcb->capture.control;
> >
> > /*
> > * Capture the record if we have an event that is always
> > @@ -485,8 +387,8 @@ bool rtems_capture_filter( rtems_capture_task_t*
> task,
> > * watch ceiling, and the global watch or task watch is enabled.
> > */
> > if ((events & RTEMS_CAPTURE_RECORD_EVENTS) ||
> > - ((task->tcb->real_priority >= capture_ceiling) &&
> > - (task->tcb->real_priority <= capture_floor) &&
> > + ((tcb->real_priority >= capture_ceiling) &&
> > + (tcb->real_priority <= capture_floor) &&
> > ((capture_flags & RTEMS_CAPTURE_GLOBAL_WATCH) ||
> > (control && (control->flags & RTEMS_CAPTURE_WATCH)))))
> > {
> > @@ -501,7 +403,7 @@ bool rtems_capture_filter( rtems_capture_task_t*
> task,
> > * This function records a capture record into the capture buffer.
> > */
> > void *
> > -rtems_capture_record_open (rtems_capture_task_t* task,
> > +rtems_capture_record_open (rtems_tcb* tcb,
> > uint32_t events,
> > size_t size,
> > rtems_interrupt_lock_context* lock_context)
> > @@ -516,18 +418,17 @@ rtems_capture_record_open
> (rtems_capture_task_t* task,
> > if ( capture_in )
> > {
> > capture_count++;
> > - capture_in->size = size;
> > - capture_in->task = task;
> > - capture_in->events = (events |
> > - (task->tcb->real_priority) |
> > - (task->tcb->current_priority << 8));
> > + capture_in->size = size;
> > + capture_in->task_id = tcb->Object.id;
> > + capture_in->events = (events |
> > + (tcb->real_priority) |
> > + (tcb->current_priority << 8));
> >
> > if ((events & RTEMS_CAPTURE_RECORD_EVENTS) == 0)
> > - task->flags |= RTEMS_CAPTURE_TRACED;
> > + tcb->capture.flags |= RTEMS_CAPTURE_TRACED;
> >
> > rtems_capture_get_time (&capture_in->time);
> >
> > - rtems_capture_refcount_up (task);
> > ptr = ptr + sizeof(*capture_in);
> > }
> > else
> > @@ -546,10 +447,11 @@ void rtems_capture_record_close( void *rec,
> rtems_interrupt_lock_context* lock_c
> > * cause of a trigger.
> > */
> > bool
> > -rtems_capture_trigger (rtems_capture_task_t* ft,
> > - rtems_capture_task_t* tt,
> > - uint32_t events)
> > +rtems_capture_trigger (rtems_tcb* ft,
> > + rtems_tcb* tt,
> > + uint32_t events)
> > {
> > +
> > /*
> > * If we have not triggered then see if this is a trigger condition.
> > */
> > @@ -563,18 +465,18 @@ rtems_capture_trigger (rtems_capture_task_t*
> ft,
> >
> > if (ft)
> > {
> > - fc = ft->control;
> > + fc = ft->capture.control;
> > if (fc)
> > from_events = fc->from_triggers & events;
> > }
> >
> > if (tt)
> > {
> > - tc = tt->control;
> > + tc = tt->capture.control;
> > if (tc)
> > {
> > to_events = tc->to_triggers & events;
> > - if (ft && tc->by_valid)
> > + if (ft && tc->by_valid)
> > from_to_events = tc->by_triggers & events;
> > }
> > }
> > @@ -633,7 +535,6 @@ rtems_capture_open (uint32_t size,
> rtems_capture_timestamp timestamp __attribu
> >
> > capture_count = 0;
> > capture_flags = 0;
> > - capture_tasks = NULL;
> > capture_ceiling = 0;
> > capture_floor = 255;
> >
> > @@ -659,7 +560,6 @@ rtems_status_code
> > rtems_capture_close (void)
> > {
> > rtems_interrupt_lock_context lock_context;
> > - rtems_capture_task_t* task;
> > rtems_capture_control_t* control;
> > rtems_status_code sc;
> >
> > @@ -685,17 +585,6 @@ rtems_capture_close (void)
> > if (sc != RTEMS_SUCCESSFUL)
> > return sc;
> >
> > - task = capture_tasks;
> > -
> > - while (task)
> > - {
> > - rtems_capture_task_t* delete = task;
> > - task = task->forw;
> > - rtems_workspace_free (delete);
> > - }
> > -
> > - capture_tasks = NULL;
> > -
> > control = capture_controls;
> >
> > while (control)
> > @@ -715,15 +604,6 @@ rtems_capture_close (void)
> > return RTEMS_SUCCESSFUL;
> > }
> >
> > -/*
> > - * This function allows control of tracing at a global level.
> > - */
> > -static void
> > -rtems_capture_task_setup (Thread_Control *tcb)
> > -{
> > - rtems_capture_create_capture_task (tcb);
> > -}
> > -
> > rtems_status_code
> > rtems_capture_control (bool enable)
> > {
> > @@ -742,8 +622,6 @@ rtems_capture_control (bool enable)
> > else
> > capture_flags &= ~RTEMS_CAPTURE_ON;
> >
> > - rtems_iterate_over_all_threads (rtems_capture_task_setup);
> > -
> > rtems_interrupt_lock_release (&capture_lock, &lock_context);
> >
> > return RTEMS_SUCCESSFUL;
> > @@ -778,6 +656,16 @@ rtems_capture_monitor (bool enable)
> > }
> >
> > /*
> > + * This function clears the capture trace flag in the tcb.
> > + */
> > +static void
> > +rtems_capture_flush_tcb (rtems_tcb *tcb)
> > +{
> > + tcb->capture.flags &= ~RTEMS_CAPTURE_TRACED;
> > +}
> > +
> > +
> > +/*
> > * This function flushes the capture buffer. The prime parameter allows
> the
> > * capture engine to also be primed again.
> > */
> > @@ -785,15 +673,10 @@ rtems_status_code
> > rtems_capture_flush (bool prime)
> > {
> > rtems_interrupt_lock_context lock_context;
> > - rtems_capture_task_t* task;
> >
> > rtems_interrupt_lock_acquire (&capture_lock, &lock_context);
> >
> > - for (task = capture_tasks; task != NULL; task = task->forw)
> > - {
> > - task->flags &= ~RTEMS_CAPTURE_TRACED;
> > - task->refcount = 0;
> > - }
> > + rtems_iterate_over_all_threads (rtems_capture_flush_tcb);
> >
> > if (prime)
> > capture_flags &= ~(RTEMS_CAPTURE_TRIGGERED |
> RTEMS_CAPTURE_OVERFLOW);
> > @@ -805,15 +688,6 @@ rtems_capture_flush (bool prime)
> >
> > rtems_interrupt_lock_release (&capture_lock, &lock_context);
> >
> > - task = capture_tasks;
> > -
> > - while (task)
> > - {
> > - rtems_capture_task_t* check = task;
> > - task = task->forw;
> > - rtems_capture_destroy_capture_task (check);
> > - }
> > -
> > return RTEMS_SUCCESSFUL;
> > }
> >
> > @@ -856,7 +730,6 @@ rtems_capture_watch_del (rtems_name name,
> rtems_id id)
> > rtems_interrupt_lock_context lock_context;
> > rtems_capture_control_t* control;
> > rtems_capture_control_t** prev_control;
> > - rtems_capture_task_t* task;
> > bool found = false;
> >
> > /*
> > @@ -870,10 +743,6 @@ rtems_capture_watch_del (rtems_name name,
> rtems_id id)
> > {
> > rtems_interrupt_lock_acquire (&capture_lock, &lock_context);
> >
> > - for (task = capture_tasks; task != NULL; task = task->forw)
> > - if (task->control == control)
> > - task->control = 0;
> > -
> > *prev_control = control->next;
> >
> > rtems_interrupt_lock_release (&capture_lock, &lock_context);
> > @@ -1373,8 +1242,6 @@ rtems_capture_release (uint32_t count)
> > {
> > rec = (rtems_capture_record_t*) ptr;
> > ptr_size += rec->size;
> > - rtems_capture_refcount_down (rec->task);
> > - rtems_capture_destroy_capture_task (rec->task);
> > ptr += rec->size;
> > }
> >
> > @@ -1416,48 +1283,6 @@ rtems_capture_event_text (int event)
> > }
> >
> > /*
> > - * This function returns the head of the list of tasks that the
> > - * capture engine has detected.
> > - */
> > -rtems_capture_task_t*
> > -rtems_capture_get_task_list (void)
> > -{
> > - return capture_tasks;
> > -}
> > -
> > -/*
> > - * This function updates the stack usage. The task control block
> > - * is updated.
> > - */
> > -uint32_t
> > -rtems_capture_task_stack_usage (rtems_capture_task_t* task)
> > -{
> > - if (task->tcb)
> > - {
> > - uint32_t* st;
> > - uint32_t* s;
> > -
> > - /*
> > - * @todo: Assumes all stacks move the same way.
> > - */
> > - st = task->tcb->Start.Initial_stack.area + task->stack_size;
> > - s = task->tcb->Start.Initial_stack.area;
> > -
> > - while (s < st)
> > - {
> > - if (*s != 0xdeaddead)
> > - break;
> > - s++;
> > - }
> > -
> > - task->stack_clean =
> > - s - (uint32_t*) task->tcb->Start.Initial_stack.area;
> > - }
> > -
> > - return task->stack_clean;
> > -}
> > -
> > -/*
> > * This function returns the head of the list of control in the
> > * capture engine.
> > */
> > diff --git a/cpukit/libmisc/capture/capture.h
> b/cpukit/libmisc/capture/capture.h
> > index 8bc2fc3..bd07922 100644
> > --- a/cpukit/libmisc/capture/capture.h
> > +++ b/cpukit/libmisc/capture/capture.h
> > @@ -46,6 +46,7 @@ extern "C" {
> > #endif
> >
> > #include <rtems.h>
> > +#include <rtems/rtems/tasksimpl.h>
> >
> > /**
> > * The number of tasks in a trigger group.
> > @@ -137,47 +138,10 @@ typedef struct rtems_capture_control_s
> > RTEMS_CAPTURE_EXITTED)
> >
> > /**
> > - * @brief Catpure task control
> > - *
> > - * RTEMS capture control provdes the information about a task, along
> > - * with its trigger state. The control is referenced by each
> > - * capture record. This is information neeed by the decoder. The
> > - * capture record cannot assume the task will exist when the record is
> > - * dumped via the target interface so task info needed for tracing is
> > - * copied and held here. Once the references in the trace buffer
> > - * have been removed and the task is deleted this structure is
> > - * released back to the heap.
> > - *
> > - * The inline helper functions provide more details about the info
> > - * contained in this structure.
> > - *
> > - * Note, the tracer code exploits the fact an rtems_name is a
> > - * 32bit value.
> > - */
> > -typedef struct rtems_capture_task_s
> > -{
> > - rtems_name name;
> > - rtems_id id;
> > - uint32_t flags;
> > - uint32_t refcount;
> > - rtems_tcb* tcb;
> > - uint32_t in;
> > - uint32_t out;
> > - rtems_task_priority start_priority;
> > - uint32_t stack_size;
> > - uint32_t stack_clean;
> > - rtems_capture_time_t time;
> > - rtems_capture_time_t time_in;
> > - rtems_capture_time_t last_time;
> > - rtems_capture_control_t* control;
> > - struct rtems_capture_task_s* forw;
> > - struct rtems_capture_task_s* back;
> > -} rtems_capture_task_t;
> > -
> > -/**
> > * Task flags.
> > */
> > -#define RTEMS_CAPTURE_TRACED (1U << 0)
> > +#define RTEMS_CAPTURE_TRACED (1U << 0)
> > +#define RTEMS_CAPTURE_RECORD_TASK (1U << 1)
> >
> > /*
> > * @brief Capture record.
> > @@ -188,12 +152,27 @@ typedef struct rtems_capture_task_s
> > */
> > typedef struct rtems_capture_record_s
> > {
> > - rtems_capture_task_t* task;
> > uint32_t events;
> > rtems_capture_time_t time;
> > size_t size;
> > + rtems_id task_id;
> > } rtems_capture_record_t;
> >
> > +/*
> > + * @brief Capture task record.
> > + *
> > + * This is a record that is written into
> > + * the buffer. The events includes the priority of the task
> > + * at the time of the context switch.
> > + */
> > +typedef struct rtems_capture_task_record_s
> > +{
> > + rtems_capture_record_t rec;
> > + rtems_name name;
> > + rtems_task_priority start_priority;
> > + uint32_t stack_size;
> > +} rtems_capture_task_record_t;
> > +
> > /**
> > * The capture record event flags.
> > */
> > @@ -619,49 +598,24 @@ const char*
> > rtems_capture_event_text (int event);
> >
> > /**
> > - * @brief Capture get task list.
> > - *
> > - * This function returns the head of the list of tasks that the
> > - * capture engine has detected.
> > - *
> > - * @retval This function returns the head of the list of tasks that
> > - * the capture engine has detected.
> > - */
> > -rtems_capture_task_t*
> > -rtems_capture_get_task_list (void);
> > -
> > -/**
> > - * @brief Capture get next task in list.
> > - *
> > - * This function returns the pointer to the next task in the list. The
> > - * pointer NULL terminates the list.
> > - *
> > - * @param[in] task The capture task to get the next entry from.
> > + * @brief Capture record task.
> > *
> > - * @retval This function returns the pointer to the next task in the list. The
> > - * pointer NULL terminates the list.
> > + * This function records a new capture task record.
> > + *
> > + * @param[in] tcb is the task control block for the task
> > */
> > -static inline rtems_capture_task_t*
> > -rtems_capture_next_task (rtems_capture_task_t* task)
> > -{
> > - return task->forw;
> > -}
> > +void rtems_capture_record_task( rtems_tcb* tcb );
> >
> > /**
> > - * @brief Capture is valid task control block
> > + * @brief Capture task recorded
> > *
> > - * This function returns true if the task control block points to
> > - * a valid task.
> > + * This function returns true if this task information has been
> > + * recorded.
> > *
> > - * @param[in] task The capture task.
> > - *
> > - * @retval This function returns true if the task control block points to
> > - * a valid task. Otherwise, it returns false.
> > + * @param[in] tcb is the task control block for the task
> > */
> > -static inline bool
> > -rtems_capture_task_valid (rtems_capture_task_t* task)
> > -{
> > - return task->tcb != NULL;
> > +static inline bool rtems_capture_task_recorded( rtems_tcb* tcb ) {
> > + return ( (tcb->capture.flags & RTEMS_CAPTURE_RECORD_TASK) != 0 );
> > }
> >
> > /**
> > @@ -674,9 +628,9 @@ rtems_capture_task_valid (rtems_capture_task_t*
> task)
> > * @retval This function returns the task id.
> > */
> > static inline rtems_id
> > -rtems_capture_task_id (rtems_capture_task_t* task)
> > +rtems_capture_task_id (rtems_tcb* tcb)
> > {
> > - return task->id;
> > + return tcb->Object.id;
> > }
> >
> > /**
> > @@ -689,10 +643,10 @@ rtems_capture_task_id (rtems_capture_task_t*
> task)
> > * @retval This function returns the task state.
> > */
> > static inline States_Control
> > -rtems_capture_task_state (rtems_capture_task_t* task)
> > +rtems_capture_task_state (rtems_tcb* tcb)
> > {
> > - if (rtems_capture_task_valid (task))
> > - return task->tcb->current_state;
> > + if (tcb)
> > + return tcb->current_state;
> > return 0;
> > }
> >
> > @@ -706,9 +660,11 @@ rtems_capture_task_state
> (rtems_capture_task_t* task)
> > * @retval This function returns the task name.
> > */
> > static inline rtems_name
> > -rtems_capture_task_name (rtems_capture_task_t* task)
> > +rtems_capture_task_name (rtems_tcb* tcb)
> > {
> > - return task->name;
> > + rtems_name name;
> > + rtems_object_get_classic_name( tcb->Object.id, &name );
> > + return name;
> > }
> >
> > /**
> > @@ -721,9 +677,9 @@ rtems_capture_task_name
> (rtems_capture_task_t* task)
> > * @retval This function returns the task flags.
> > */
> > static inline uint32_t
> > -rtems_capture_task_flags (rtems_capture_task_t* task)
> > +rtems_capture_task_flags (rtems_tcb* tcb)
> > {
> > - return task->flags;
> > + return tcb->capture.flags;
> > }
> >
> > /**
> > @@ -736,9 +692,9 @@ rtems_capture_task_flags (rtems_capture_task_t*
> task)
> > * @retval This function returns the task control if present.
> > */
> > static inline rtems_capture_control_t*
> > -rtems_capture_task_control (rtems_capture_task_t* task)
> > +rtems_capture_task_control (rtems_tcb* tcb)
> > {
> > - return task->control;
> > + return tcb->capture.control;
> > }
> >
> > /**
> > @@ -751,45 +707,12 @@ rtems_capture_task_control
> (rtems_capture_task_t* task)
> > * @retval This function returns the task control flags if a control is
> present.
> > */
> > static inline uint32_t
> > -rtems_capture_task_control_flags (rtems_capture_task_t* task)
> > +rtems_capture_task_control_flags (rtems_tcb* tcb)
> > {
> > - if (!task->control)
> > + rtems_capture_control_t* control = tcb->capture.control;
> > + if (!control)
> > return 0;
> > - return task->control->flags;
> > -}
> > -
> > -/**
> > - * @brief Capture get number of times task switched in.
> > - *
> > - * This function returns the number of times the task has
> > - * been switched into context.
> > - *
> > - * @param[in] task The capture task.
> > - *
> > - * @retval This function returns the number of times the task has
> > - * been switched into context.
> > - */
> > -static inline uint32_t
> > -rtems_capture_task_switched_in (rtems_capture_task_t* task)
> > -{
> > - return task->in;
> > -}
> > -
> > -/**
> > - * @brief Capture get number of times task switched out.
> > - *
> > - * This function returns the number of times the task has
> > - * been switched out of context.
> > - *
> > - * @param[in] task The capture task.
> > - *
> > - * @retval This function returns the number of times the task has
> > - * been switched out of context.
> > - */
> > -static inline uint32_t
> > -rtems_capture_task_switched_out (rtems_capture_task_t* task)
> > -{
> > - return task->out;
> > + return control->flags;
> > }
> >
> > /**
> > @@ -804,9 +727,11 @@ rtems_capture_task_switched_out
> (rtems_capture_task_t* task)
> > * to track where the task's priority goes.
> > */
> > static inline rtems_task_priority
> > -rtems_capture_task_start_priority (rtems_capture_task_t* task)
> > +rtems_capture_task_start_priority (rtems_tcb* tcb)
> > {
> > - return task->start_priority;
> > + return _RTEMS_tasks_Priority_from_Core(
> > + tcb->Start.initial_priority
> > + );
> > }
> >
> > /**
> > @@ -819,11 +744,9 @@ rtems_capture_task_start_priority
> (rtems_capture_task_t* task)
> > * @retval This function returns the tasks real priority.
> > */
> > static inline rtems_task_priority
> > -rtems_capture_task_real_priority (rtems_capture_task_t* task)
> > +rtems_capture_task_real_priority (rtems_tcb* tcb)
> > {
> > - if (rtems_capture_task_valid (task))
> > - return task->tcb->real_priority;
> > - return 0;
> > + return tcb->real_priority;
> > }
> >
> > /**
> > @@ -836,113 +759,9 @@ rtems_capture_task_real_priority
> (rtems_capture_task_t* task)
> > * @retval This function returns the tasks current priority.
> > */
> > static inline rtems_task_priority
> > -rtems_capture_task_curr_priority (rtems_capture_task_t* task)
> > +rtems_capture_task_curr_priority (rtems_tcb* tcb)
> > {
> > - if (rtems_capture_task_valid (task))
> > - return task->tcb->current_priority;
> > - return 0;
> > -}
> > -
> > -/**
> > - * @brief Capture update stack usage.
> > - *
> > - * This function updates the stack usage. The task control block
> > - * is updated.
> > - *
> > - * @param[in] task The capture task.
> > - *
> > - * @retval This function updates the stack usage. The task control block
> > - * is updated.
> > - */
> > -uint32_t
> > -rtems_capture_task_stack_usage (rtems_capture_task_t* task);
> > -
> > -/**
> > - * @brief Capture get stack size.
> > - *
> > - * This function returns the task's stack size.
> > - *
> > - * @param[in] task The capture task.
> > - *
> > - * @retval This function returns the task's stack size.
> > - */
> > -static inline uint32_t
> > -rtems_capture_task_stack_size (rtems_capture_task_t* task)
> > -{
> > - return task->stack_size;
> > -}
> > -
> > -/**
> > - * @brief Capture get stack used.
> > - *
> > - * This function returns the amount of stack used.
> > - *
> > - * @param[in] task The capture task.
> > - *
> > - * @retval This function returns the amount of stack used.
> > - */
> > -static inline uint32_t
> > -rtems_capture_task_stack_used (rtems_capture_task_t* task)
> > -{
> > - return task->stack_size - task->stack_clean;
> > -}
> > -
> > -/**
> > - * @brief Capture get task execution time.
> > - *
> > - * This function returns the current execution time.
> > - *
> > - * @param[in] task The capture task.
> > - *
> > - * @retval This function returns the current execution time.
> > - */
> > -static inline uint64_t
> > -rtems_capture_task_time (rtems_capture_task_t* task)
> > -{
> > - return task->time;
> > -}
> > -
> > -/**
> > - * @brief Capture get delta in execution time.
> > - *
> > - * This function returns the execution time as a different between the
> > - * last time the detla time was and now.
> > - *
> > - * @param[in] task The capture task.
> > - *
> > - * @retval This function returns the execution time as a different between
> the
> > - * last time the detla time was and now.
> > - */
> > -static inline uint64_t
> > -rtems_capture_task_delta_time (rtems_capture_task_t* task)
> > -{
> > - uint64_t t = task->time - task->last_time;
> > - task->last_time = task->time;
> > - return t;
> > -}
> > -
> > -/**
> > - * @brief Capture get task count.
> > - *
> > - * This function returns the number of tasks the capture
> > - * engine knows about.
> > - *
> > - * @retval This function returns the number of tasks the capture
> > - * engine knows about.
> > - */
> > -static inline uint32_t
> > -rtems_capture_task_count (void)
> > -{
> > - rtems_capture_task_t* task = rtems_capture_get_task_list ();
> > - uint32_t count = 0;
> > -
> > - while (task)
> > - {
> > - count++;
> > - task = rtems_capture_next_task (task);
> > - }
> > -
> > - return count;
> > + return tcb->current_priority;
> > }
> >
> > /**
> > @@ -1070,7 +889,7 @@ rtems_capture_control_all_by_triggers
> (rtems_capture_control_t* control)
> > * This function returns the control valid BY flags.
> > *
> > * @param[in] control The capture control.
> > - * @param[in] slot The XXX.
> > + * @param[in] slot The slot.
> > *
> > * @retval This function returns the control valid BY flags.
> > */
> > @@ -1086,7 +905,7 @@ rtems_capture_control_by_valid
> (rtems_capture_control_t* control, int slot)
> > * This function returns the control @a by task name.
> > *
> > * @param[in] control The capture control.
> > - * @param[in] by The XXX.
> > + * @param[in] by The by index.
> > *
> > * @retval This function returns the control @a by task name.
> > */
> > diff --git a/cpukit/libmisc/capture/capture_user_extension.c
> b/cpukit/libmisc/capture/capture_user_extension.c
> > index 4236d8c..4c7bc1d 100644
> > --- a/cpukit/libmisc/capture/capture_user_extension.c
> > +++ b/cpukit/libmisc/capture/capture_user_extension.c
> > @@ -84,20 +84,20 @@ static const rtems_extensions_table
> capture_extensions = {
> > .thread_terminate = rtems_capture_terminated_task
> > };
> >
> > -
> > static inline void rtems_capture_record (
> > - rtems_capture_task_t* task,
> > - uint32_t events
> > + rtems_tcb* tcb,
> > + uint32_t events
> > )
> > {
> > rtems_capture_record_t* rec;
> > + void* ptr;
> > + size_t size = sizeof(*rec);
> >
> > - if (rtems_capture_filter( task, events) )
> > + if (rtems_capture_filter( tcb, events) )
> > return;
> > -
> > - rtems_capture_begin_add_record (task, events, sizeof(*rec), &rec);
> >
> > - rtems_capture_end_add_record ( rec );
> > + rtems_capture_begin_add_record (tcb, events, size, &ptr);
> > + rtems_capture_end_add_record ( ptr );
> > }
> >
> >
> > @@ -133,27 +133,21 @@ rtems_status_code
> rtems_capture_user_extension_close(void)
> > * This function is called when a task is created.
> > */
> > static bool
> > -rtems_capture_create_task (rtems_tcb* current_task,
> > - rtems_tcb* new_task)
> > +rtems_capture_create_task (rtems_tcb* ct,
> > + rtems_tcb* nt)
>
> Any specific reason to shorten the names ?
>
> > {
> > - rtems_capture_task_t* ct;
> > - rtems_capture_task_t* nt;
> > - int index = rtems_capture_get_extension_index();
> > -
> > - ct = current_task->extensions[index];
> > -
> > /*
> > * The task pointers may not be known as the task may have
> > * been created before the capture engine was open. Add them.
> > */
> >
> > - if (ct == NULL)
> > - ct = rtems_capture_create_capture_task (current_task);
> > + if (!rtems_capture_task_recorded (ct))
> > + rtems_capture_record_task (ct);
> >
> > /*
> > * Create the new task's capture control block.
> > */
> > - nt = rtems_capture_create_capture_task (new_task);
> > + rtems_capture_record_task (nt);
> >
> > if (rtems_capture_trigger (ct, nt, RTEMS_CAPTURE_CREATE))
> > {
> > @@ -168,147 +162,85 @@ rtems_capture_create_task (rtems_tcb*
> current_task,
> > * This function is called when a task is started.
> > */
> > static void
> > -rtems_capture_start_task (rtems_tcb* current_task,
> > - rtems_tcb* started_task)
> > +rtems_capture_start_task (rtems_tcb* ct,
> > + rtems_tcb* st)
> > {
> > /*
> > - * Get the capture task control block so we can trace this
> > - * event.
> > - */
> > - rtems_capture_task_t* ct;
> > - rtems_capture_task_t* st;
> > - int index = rtems_capture_get_extension_index();
> > -
> > - ct = current_task->extensions[index];
> > - st = started_task->extensions[index];
> > -
> > - /*
> > * The task pointers may not be known as the task may have
> > * been created before the capture engine was open. Add them.
> > */
> >
> > - if (ct == NULL)
> > - ct = rtems_capture_create_capture_task (current_task);
> > + if (!rtems_capture_task_recorded (ct))
> > + rtems_capture_record_task (ct);
> >
> > if (st == NULL)
> > - st = rtems_capture_create_capture_task (started_task);
> > + rtems_capture_record_task (st);
> >
> > if (rtems_capture_trigger (ct, st, RTEMS_CAPTURE_START))
> > {
> > rtems_capture_record (ct, RTEMS_CAPTURE_STARTED_BY_EVENT);
> > rtems_capture_record (st, RTEMS_CAPTURE_STARTED_EVENT);
> > }
> > -
> > - rtems_capture_init_stack_usage (st);
> > }
> >
> > /*
> > * This function is called when a task is restarted.
> > */
> > static void
> > -rtems_capture_restart_task (rtems_tcb* current_task,
> > - rtems_tcb* restarted_task)
> > +rtems_capture_restart_task (rtems_tcb* ct,
> > + rtems_tcb* rt)
> > {
> > /*
> > - * Get the capture task control block so we can trace this
> > - * event.
> > - */
> > - rtems_capture_task_t* ct;
> > - rtems_capture_task_t* rt;
> > - int index = rtems_capture_get_extension_index();
> > -
> > - ct = current_task->extensions[index];
> > - rt = restarted_task->extensions[index];
> > -
> > - /*
> > * The task pointers may not be known as the task may have
> > * been created before the capture engine was open. Add them.
> > */
> >
> > - if (ct == NULL)
> > - ct = rtems_capture_create_capture_task (current_task);
> > + if (!rtems_capture_task_recorded (ct))
> > + rtems_capture_record_task (ct);
> >
> > - if (rt == NULL)
> > - rt = rtems_capture_create_capture_task (restarted_task);
> > + if (!rtems_capture_task_recorded (rt))
> > + rtems_capture_record_task (rt);
> >
> > if (rtems_capture_trigger (ct, rt, RTEMS_CAPTURE_RESTART))
> > {
> > rtems_capture_record (ct, RTEMS_CAPTURE_RESTARTED_BY_EVENT);
> > rtems_capture_record (rt, RTEMS_CAPTURE_RESTARTED_EVENT);
> > }
> > -
> > - rtems_capture_task_stack_usage (rt);
> > - rtems_capture_init_stack_usage (rt);
> > }
> >
> > /*
> > * This function is called when a task is deleted.
> > */
> > static void
> > -rtems_capture_delete_task (rtems_tcb* current_task,
> > - rtems_tcb* deleted_task)
> > +rtems_capture_delete_task (rtems_tcb* ct,
> > + rtems_tcb* dt)
> > {
> > - /*
> > - * Get the capture task control block so we can trace this
> > - * event.
> > - */
> > - rtems_capture_task_t* ct;
> > - rtems_capture_task_t* dt;
> > - int index = rtems_capture_get_extension_index();
> > -
> > - /*
> > - * The task pointers may not be known as the task may have
> > - * been created before the capture engine was open. Add them.
> > - */
> > -
> > - ct = current_task->extensions[index];
> > - dt = deleted_task->extensions[index];
> > + if (!rtems_capture_task_recorded (ct))
> > + rtems_capture_record_task (ct);
> >
> > - if (ct == NULL)
> > - ct = rtems_capture_create_capture_task (current_task);
> > -
> > - if (dt == NULL)
> > - dt = rtems_capture_create_capture_task (deleted_task);
> > + if (!rtems_capture_task_recorded (dt))
> > + rtems_capture_record_task (dt);
> >
> > if (rtems_capture_trigger (ct, dt, RTEMS_CAPTURE_DELETE))
> > {
> > rtems_capture_record (ct, RTEMS_CAPTURE_DELETED_BY_EVENT);
> > rtems_capture_record (dt, RTEMS_CAPTURE_DELETED_EVENT);
> > }
> > -
> > - rtems_capture_task_stack_usage (dt);
> > -
> > - /*
> > - * This task's tcb will be invalid. This signals the
> > - * task has been deleted.
> > - */
> > - dt->tcb = 0;
> > -
> > - rtems_capture_destroy_capture_task (dt);
> > }
> >
> > /*
> > * This function is called when a task is begun.
> > */
> > static void
> > -rtems_capture_begin_task (rtems_tcb* begin_task)
> > +rtems_capture_begin_task (rtems_tcb* bt)
> > {
> > /*
> > - * Get the capture task control block so we can trace this
> > - * event.
> > - */
> > - rtems_capture_task_t* bt;
> > - int index = rtems_capture_get_extension_index();
> > -
> > - bt = begin_task->extensions[index];
> > -
> > - /*
> > * The task pointers may not be known as the task may have
> > * been created before the capture engine was open. Add them.
> > */
> >
> > - if (bt == NULL)
> > - bt = rtems_capture_create_capture_task (begin_task);
> > + if (!rtems_capture_task_recorded (bt))
> > + rtems_capture_record_task (bt);
> >
> > if (rtems_capture_trigger (NULL, bt, RTEMS_CAPTURE_BEGIN))
> > rtems_capture_record (bt, RTEMS_CAPTURE_BEGIN_EVENT);
> > @@ -319,69 +251,46 @@ rtems_capture_begin_task (rtems_tcb*
> begin_task)
> > * returned rather than was deleted.
> > */
> > static void
> > -rtems_capture_exitted_task (rtems_tcb* exitted_task)
> > +rtems_capture_exitted_task (rtems_tcb* et)
> > {
> > /*
> > - * Get the capture task control block so we can trace this
> > - * event.
> > - */
> > - rtems_capture_task_t* et;
> > - int index = rtems_capture_get_extension_index();
> > -
> > - et = exitted_task->extensions[index];
> > -
> > - /*
> > * The task pointers may not be known as the task may have
> > * been created before the capture engine was open. Add them.
> > */
> >
> > - if (et == NULL)
> > - et = rtems_capture_create_capture_task (exitted_task);
> > + if (!rtems_capture_task_recorded (et))
> > + rtems_capture_record_task (et);
> >
> > if (rtems_capture_trigger (NULL, et, RTEMS_CAPTURE_EXITTED))
> > rtems_capture_record (et, RTEMS_CAPTURE_EXITTED_EVENT);
> > -
> > - rtems_capture_task_stack_usage (et);
> > }
> >
> > /*
> > * This function is called when a termination request is identified.
> > */
> > static void
> > -rtems_capture_terminated_task (rtems_tcb* terminated_task)
> > +rtems_capture_terminated_task (rtems_tcb* tt)
> > {
> > /*
> > - * Get the capture task control block so we can trace this
> > - * event.
> > - */
> > - rtems_capture_task_t* tt;
> > - int index = rtems_capture_get_extension_index();
> > -
> > - tt = terminated_task->extensions[index];
> > -
> > - /*
> > * The task pointers may not be known as the task may have
> > * been created before the capture engine was open. Add them.
> > */
> >
> > - if (tt == NULL)
> > - tt = rtems_capture_create_capture_task (terminated_task);
> > + if (!rtems_capture_task_recorded (tt))
> > + rtems_capture_record_task (tt);
> >
> > if (rtems_capture_trigger (NULL, tt, RTEMS_CAPTURE_TERMINATED))
> > rtems_capture_record (tt, RTEMS_CAPTURE_TERMINATED_EVENT);
> > -
> > - rtems_capture_task_stack_usage (tt);
> > }
> >
> > /*
> > * This function is called when a context is switched.
> > */
> > static void
> > -rtems_capture_switch_task (rtems_tcb* current_task,
> > - rtems_tcb* heir_task)
> > +rtems_capture_switch_task (rtems_tcb* ct,
> > + rtems_tcb* ht)
> > {
> > uint32_t flags = rtems_capture_get_flags();
> > - int index = rtems_capture_get_extension_index();
> >
> > /*
> > * Only perform context switch trace processing if tracing is
> > @@ -391,33 +300,11 @@ rtems_capture_switch_task (rtems_tcb*
> current_task,
> > {
> > rtems_capture_time_t time;
> >
> > - /*
> > - * Get the cpature task control block so we can update the
> > - * reference and perform any watch or trigger functions.
> > - * The task pointers may not be known as the task may have
> > - * been created before the capture engine was open. Add them.
> > - */
> > - rtems_capture_task_t* ct;
> > - rtems_capture_task_t* ht;
> > -
> > + if (!rtems_capture_task_recorded (ct))
> > + rtems_capture_record_task (ct);
> >
> > - if (_States_Is_dormant (current_task->current_state))
> > - {
> > - rtems_id ct_id = current_task->Object.id;
> > - ct = rtems_capture_find_capture_task( ct_id );
> > - }
> > - else
> > - {
> > - ct = current_task->extensions[index];
> > -
> > - if (ct == NULL)
> > - ct = rtems_capture_create_capture_task (current_task);
> > - }
> > -
> > - ht = heir_task->extensions[index];
> > -
> > - if (ht == NULL)
> > - ht = rtems_capture_create_capture_task (heir_task);
> > + if (!rtems_capture_task_recorded (ht))
> > + rtems_capture_record_task (ht);
> >
> > /*
> > * Update the execution time. Assume the time will not overflow
> > @@ -425,24 +312,6 @@ rtems_capture_switch_task (rtems_tcb*
> current_task,
> > */
> > rtems_capture_get_time (&time);
> >
> > - /*
> > - * We could end up with null pointers for both the current task
> > - * and the heir task.
> > - */
> > -
> > - if (ht)
> > - {
> > - ht->in++;
> > - ht->time_in = time;
> > - }
> > -
> > - if (ct)
> > - {
> > - ct->out++;
> > - if (ct->time_in)
> > - ct->time += time - ct->time_in;
> > - }
> > -
> > if (rtems_capture_trigger (ct, ht, RTEMS_CAPTURE_SWITCH))
> > {
> > rtems_capture_record (ct,
> RTEMS_CAPTURE_SWITCHED_OUT_EVENT);
> > diff --git a/cpukit/libmisc/capture/captureimpl.h
> b/cpukit/libmisc/capture/captureimpl.h
> > index fa36688..3c2f6c3 100644
> > --- a/cpukit/libmisc/capture/captureimpl.h
> > +++ b/cpukit/libmisc/capture/captureimpl.h
> > @@ -116,29 +116,6 @@ rtems_status_code
> rtems_capture_user_extension_open(void);
> > rtems_status_code rtems_capture_user_extension_close(void);
> >
> > /**
> > - * @brief Capture find capture task.
> > - *
> > - * This function finds the capture task control block
> > - *
> > - * @param[in] ct_id specifies the task_id
> > - *
> > - * @retval This method returns the capture task control block associated
> > - * with the given task id.
> > - */
> > -rtems_capture_task_t* rtems_capture_find_capture_task( rtems_id
> ct_id );
> > -
> > -/**
> > - * @brief Capture create capture task control block.
> > - *
> > - * This function create the capture task control block
> > - *
> > - * @param[in] new_task specifies the rtems thread control block
> > - *
> > - * @retval This method returns a capture task control block.
> > - */
> > -rtems_capture_task_t* rtems_capture_create_capture_task (rtems_tcb*
> new_task);
> > -
> > -/**
> > * @brief Capture trigger.
> > *
> > * This function checks if we have triggered or if this event is a
> > @@ -151,9 +128,9 @@ rtems_capture_task_t*
> rtems_capture_create_capture_task (rtems_tcb* new_task);
> > * @retval This method returns true if we have triggered or
> > * if the event is a cause of a trigger.
> > */
> > -bool rtems_capture_trigger (rtems_capture_task_t* ft,
> > - rtems_capture_task_t* tt,
> > - uint32_t events);
> > +bool rtems_capture_trigger (rtems_tcb* ft,
> > + rtems_tcb* tt,
> > + uint32_t events);
> >
> > /**
> > * @brief Capture append to record
> > @@ -188,7 +165,7 @@ static void
> *rtems_capture_append_to_record(void* rec,
> > * filtered from the log. It returns false if this data
> > * should be logged.
> > */
> > -bool rtems_capture_filter( rtems_capture_task_t* task,
> > +bool rtems_capture_filter( rtems_tcb* task,
> > uint32_t events);
> > /**
> > * @brief Capture begin add record.
> > @@ -238,26 +215,6 @@ static inline void
> *rtems_capture_append_to_record(void* rec,
> > } while (0)
> >
> > /**
> > - * @brief Capture initialize stack usage
> > - *
> > - * This function setups a stack so its usage can be monitored.
> > - *
> > - * @param[in] task specifies the capture task block
> > - */
> > -void rtems_capture_init_stack_usage (rtems_capture_task_t* task);
> > -
> > -/**
> > - * @brief Capture destroy task.
> > - *
> > - * This function destroy the task structure if the reference count
> > - * is 0 and the tcb has been cleared signalling the task has been
> > - * deleted.
> > - *
> > - * @param[in] task specifies the capture task block
> > - */
> > -void rtems_capture_destroy_capture_task (rtems_capture_task_t* task);
> > -
> > -/**
> > * @brief .
> > *
> > * This function returns the current time. If a handler is provided
> > @@ -287,7 +244,7 @@ void rtems_capture_get_time
> (rtems_capture_time_t* time);
> > * @retval This method returns a pointer to the next location in
> > * the capture record to store data.
> > */
> > -void* rtems_capture_record_open (rtems_capture_task_t* task,
> > +void* rtems_capture_record_open (rtems_tcb* task,
> > uint32_t events,
> > size_t size,
> > rtems_interrupt_lock_context* lock_context);
> >
> _______________________________________________
> devel mailing list
> devel at rtems.org
> http://lists.rtems.org/mailman/listinfo/devel
More information about the devel
mailing list