From f9dce02507347a061e4ad221a5babf54265f91e0 Mon Sep 17 00:00:00 2001 From: Sebastian Huber Date: Mon, 14 Jan 2019 13:28:31 +0100 Subject: record: New program Update #3665. --- trace/record/record-client.c | 688 +++++++++++++++++++++ trace/record/record-main-lttng.c | 198 ++++++ trace/record/record-text.c | 1071 +++++++++++++++++++++++++++++++++ trace/record/rtems/recordclient.h | 239 ++++++++ trace/record/rtems/recorddata.h | 1204 +++++++++++++++++++++++++++++++++++++ trace/wscript | 67 +++ 6 files changed, 3467 insertions(+) create mode 100644 trace/record/record-client.c create mode 100644 trace/record/record-main-lttng.c create mode 100644 trace/record/record-text.c create mode 100644 trace/record/rtems/recordclient.h create mode 100644 trace/record/rtems/recorddata.h create mode 100644 trace/wscript (limited to 'trace') diff --git a/trace/record/record-client.c b/trace/record/record-client.c new file mode 100644 index 0000000..cfe05fd --- /dev/null +++ b/trace/record/record-client.c @@ -0,0 +1,688 @@ +/* + * SPDX-License-Identifier: BSD-2-Clause + * + * Copyright (C) 2018, 2019 embedded brains GmbH + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" + * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE + * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR + * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF + * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS + * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN + * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) + * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE + * POSSIBILITY OF SUCH DAMAGE. + */ + +/* + * This file must be compatible to general purpose POSIX system, e.g. Linux, + * FreeBSD. It may be used for utility programs. + */ + +#if HAVE_CONFIG_H +#include "config.h" +#endif + +#include + +#include +#include + +#define TIME_MASK ( ( UINT32_C( 1 ) << RTEMS_RECORD_TIME_BITS ) - 1 ) + +static rtems_record_client_status visit( + rtems_record_client_context *ctx, + uint32_t time_event, + uint64_t data +); + +static rtems_record_client_status consume_error( + rtems_record_client_context *ctx, + const void *buf, + size_t n +) +{ + (void) buf; + (void) n; + + return ctx->status; +} + +static rtems_record_client_status error( + rtems_record_client_context *ctx, + rtems_record_client_status status +) +{ + ctx->status = status; + ctx->consume = consume_error; + + return status; +} + +static void set_to_bt_scaler( + rtems_record_client_context *ctx, + uint32_t frequency +) +{ + uint64_t bin_per_s; + + bin_per_s = UINT64_C( 1 ) << 32; + ctx->to_bt_scaler = ( ( bin_per_s << 31 ) + frequency - 1 ) / frequency; +} + +static rtems_record_client_status call_handler( + const rtems_record_client_context *ctx, + uint64_t bt, + rtems_record_event event, + uint64_t data +) +{ + return ( *ctx->handler )( + bt, + ctx->cpu, + event, + data, + ctx->handler_arg + ); +} + +static void signal_overflow( + const rtems_record_client_context *ctx, + rtems_record_client_per_cpu *per_cpu, + uint32_t data +) +{ + per_cpu->hold_back = true; + per_cpu->item_index = 0; + call_handler( ctx, 0, RTEMS_RECORD_PER_CPU_OVERFLOW, data ); +} + +static void resolve_hold_back( + rtems_record_client_context *ctx, + rtems_record_client_per_cpu *per_cpu +) +{ + if ( per_cpu->hold_back ) { + uint32_t last_head; + uint32_t new_head; + uint32_t overwritten; + uint32_t index; + uint32_t first; + uint32_t last; + uint32_t delta; + uint64_t uptime; + + per_cpu->hold_back = false; + + last_head = per_cpu->head[ per_cpu->tail_head_index ]; + new_head = per_cpu->head[ per_cpu->tail_head_index ^ 1 ]; + overwritten = new_head - last_head; + + if ( overwritten >= per_cpu->item_index ) { + return; + } + + if ( overwritten > 0 ) { + call_handler( ctx, 0, RTEMS_RECORD_PER_CPU_OVERFLOW, overwritten ); + } + + first = RTEMS_RECORD_GET_TIME( per_cpu->items[ overwritten ].event ); + last = first; + delta = 0; + uptime = 0; + + for ( index = overwritten; index < per_cpu->item_index; ++index ) { + const rtems_record_item_64 *item; + rtems_record_event event; + uint32_t time; + + item = &per_cpu->items[ index ]; + event = RTEMS_RECORD_GET_EVENT( item->event ); + time = RTEMS_RECORD_GET_TIME( item->event ); + delta += ( time - last ) & TIME_MASK; + last = time; + + if ( + event == RTEMS_RECORD_UPTIME_LOW + && index + 1 < per_cpu->item_index + && RTEMS_RECORD_GET_EVENT( ( item + 1 )->event ) + == RTEMS_RECORD_UPTIME_HIGH + ) { + uptime = (uint32_t) item->data; + uptime += ( item + 1 )->data << 32; + break; + } + } + + per_cpu->uptime.bt = uptime - ( ( delta * ctx->to_bt_scaler ) >> 31 ); + per_cpu->uptime.time_at_bt = first; + per_cpu->uptime.time_last = first; + per_cpu->uptime.time_accumulated = 0; + + for ( index = overwritten; index < per_cpu->item_index; ++index ) { + const rtems_record_item_64 *item; + + item = &per_cpu->items[ index ]; + visit( ctx, item->event, item->data ); + } + } +} + +static void process_per_cpu_head( + rtems_record_client_context *ctx, + rtems_record_client_per_cpu *per_cpu, + uint64_t data +) +{ + uint32_t new_head; + uint32_t last_tail; + uint32_t last_head; + uint32_t capacity; + uint32_t new_content; + uint32_t produced; + + new_head = (uint32_t) data; + produced = new_head - per_cpu->tail[ per_cpu->tail_head_index ]; + per_cpu->head[ per_cpu->tail_head_index ]= new_head; + per_cpu->tail_head_index ^= 1; + + if ( produced >= ctx->count ) { + signal_overflow( ctx, per_cpu, produced - ctx->count + 1 ); + return; + } + + last_tail = per_cpu->tail[ per_cpu->tail_head_index ]; + last_head = per_cpu->head[ per_cpu->tail_head_index ]; + + if ( last_tail == last_head ) { + if ( per_cpu->uptime.bt == 0 ) { + per_cpu->hold_back = true; + } else { + resolve_hold_back( ctx, per_cpu ); + } + + return; + } + + capacity = ( last_tail - last_head - 1 ) & ( ctx->count - 1 ); + new_content = new_head - last_head; + + if ( new_content <= capacity ) { + resolve_hold_back( ctx, per_cpu ); + return; + } + + signal_overflow( ctx, per_cpu, new_content - capacity ); +} + +static rtems_record_client_status process_per_cpu_count( + rtems_record_client_context *ctx, + uint64_t data +) +{ + size_t per_cpu_items; + rtems_record_item_64 *items; + uint32_t cpu; + + if ( ctx->count != 0 ) { + return error( ctx, RTEMS_RECORD_CLIENT_ERROR_DOUBLE_PER_CPU_COUNT ); + } + + if ( ctx->cpu_count == 0 ) { + return error( ctx, RTEMS_RECORD_CLIENT_ERROR_NO_CPU_MAX ); + } + + ctx->count = (uint32_t) data; + + /* + * The ring buffer capacity plus two items for RTEMS_RECORD_PROCESSOR and + * RTEMS_RECORD_PER_CPU_TAIL. + */ + per_cpu_items = ctx->count + 1; + + items = malloc( per_cpu_items * ctx->cpu_count * sizeof( *items ) ); + + if ( items == NULL ) { + return error( ctx, RTEMS_RECORD_CLIENT_ERROR_NO_MEMORY ); + } + + for ( cpu = 0; cpu < ctx->cpu_count; ++cpu ) { + ctx->per_cpu[ cpu ].items = items; + items += per_cpu_items; + } + + return RTEMS_RECORD_CLIENT_SUCCESS; +} + +static rtems_record_client_status hold_back( + rtems_record_client_context *ctx, + rtems_record_client_per_cpu *per_cpu, + uint32_t time_event, + rtems_record_event event, + uint64_t data +) +{ + if ( event != RTEMS_RECORD_PER_CPU_HEAD ) { + uint32_t item_index; + + item_index = per_cpu->item_index; + + if ( item_index <= ctx->count ) { + per_cpu->items[ item_index ].event = time_event; + per_cpu->items[ item_index ].data = data; + per_cpu->item_index = item_index + 1; + } else { + return error( ctx, RTEMS_RECORD_CLIENT_ERROR_PER_CPU_ITEMS_OVERFLOW ); + } + } else { + return call_handler( ctx, 0, RTEMS_RECORD_GET_EVENT( time_event ), data ); + } + + return RTEMS_RECORD_CLIENT_SUCCESS; +} + +static uint64_t time_bt( + const rtems_record_client_context *ctx, + rtems_record_client_per_cpu *per_cpu, + uint32_t time +) +{ + uint64_t bt; + + if ( time != 0 ) { + uint32_t delta; + + delta = ( time - per_cpu->uptime.time_last ) & TIME_MASK; + per_cpu->uptime.time_last = time; + per_cpu->uptime.time_accumulated += delta; + bt = ( per_cpu->uptime.time_accumulated * ctx->to_bt_scaler ) >> 31; + bt += per_cpu->uptime.bt; + } else { + bt = 0; + } + + return bt; +} + +static rtems_record_client_status visit( + rtems_record_client_context *ctx, + uint32_t time_event, + uint64_t data +) +{ + rtems_record_client_per_cpu *per_cpu; + uint32_t time; + rtems_record_event event; + rtems_record_client_status status; + + per_cpu = &ctx->per_cpu[ ctx->cpu ]; + time = RTEMS_RECORD_GET_TIME( time_event ); + event = RTEMS_RECORD_GET_EVENT( time_event ); + + switch ( event ) { + case RTEMS_RECORD_PROCESSOR: + if ( data >= ctx->cpu_count ) { + return error( ctx, RTEMS_RECORD_CLIENT_ERROR_UNSUPPORTED_CPU ); + } + + ctx->cpu = (uint32_t) data; + per_cpu = &ctx->per_cpu[ ctx->cpu ]; + break; + case RTEMS_RECORD_UPTIME_LOW: + per_cpu->uptime.bt = (uint32_t) data; + per_cpu->uptime.time_at_bt = time; + per_cpu->uptime.time_last = time; + per_cpu->uptime.time_accumulated = 0; + time = 0; + break; + case RTEMS_RECORD_UPTIME_HIGH: + per_cpu->uptime.bt += data << 32; + time = 0; + break; + case RTEMS_RECORD_PER_CPU_TAIL: + per_cpu->tail[ per_cpu->tail_head_index ] = (uint32_t) data; + break; + case RTEMS_RECORD_PER_CPU_HEAD: + process_per_cpu_head( ctx, per_cpu, data ); + break; + case RTEMS_RECORD_PROCESSOR_MAXIMUM: + if ( data >= RTEMS_RECORD_CLIENT_MAXIMUM_CPU_COUNT ) { + return error( ctx, RTEMS_RECORD_CLIENT_ERROR_UNSUPPORTED_CPU_MAX ); + } + + if ( ctx->cpu_count != 0 ) { + return error( ctx, RTEMS_RECORD_CLIENT_ERROR_DOUBLE_CPU_MAX ); + } + + ctx->cpu_count = (uint32_t) data + 1; + break; + case RTEMS_RECORD_PER_CPU_COUNT: + status = process_per_cpu_count( ctx, data ); + + if ( status != RTEMS_RECORD_CLIENT_SUCCESS ) { + return status; + } + + break; + case RTEMS_RECORD_FREQUENCY: + set_to_bt_scaler( ctx, (uint32_t) data ); + break; + case RTEMS_RECORD_VERSION: + if ( data != RTEMS_RECORD_THE_VERSION ) { + return error( ctx, RTEMS_RECORD_CLIENT_ERROR_UNSUPPORTED_VERSION ); + } + + break; + default: + break; + } + + if ( per_cpu->hold_back ) { + return hold_back( ctx, per_cpu, time_event, event, data ); + } + + return call_handler( ctx, time_bt( ctx, per_cpu, time ), event, data ); +} + +static rtems_record_client_status consume_32( + rtems_record_client_context *ctx, + const void *buf, + size_t n +) +{ + while ( n > 0 ) { + size_t m; + char *pos; + + m = ctx->todo < n ? ctx->todo : n; + pos = ctx->pos; + pos = memcpy( pos, buf, m ); + n -= m; + buf = (char *) buf + m; + + if ( m == ctx->todo ) { + rtems_record_client_status status; + + ctx->todo = sizeof( ctx->item.format_32 ); + ctx->pos = &ctx->item.format_32; + + status = visit( + ctx, + ctx->item.format_32.event, + ctx->item.format_32.data + ); + + if ( status != RTEMS_RECORD_CLIENT_SUCCESS ) { + return status; + } + } else { + ctx->todo -= m; + ctx->pos = pos + m; + } + } + + return RTEMS_RECORD_CLIENT_SUCCESS; +} + +static rtems_record_client_status consume_64( + rtems_record_client_context *ctx, + const void *buf, + size_t n +) +{ + while ( n > 0 ) { + size_t m; + char *pos; + + m = ctx->todo < n ? ctx->todo : n; + pos = ctx->pos; + pos = memcpy( pos, buf, m ); + n -= m; + buf = (char *) buf + m; + + if ( m == ctx->todo ) { + rtems_record_client_status status; + + ctx->todo = sizeof( ctx->item.format_64 ); + ctx->pos = &ctx->item.format_64; + + status = visit( + ctx, + ctx->item.format_64.event, + ctx->item.format_64.data + ); + + if ( status != RTEMS_RECORD_CLIENT_SUCCESS ) { + return status; + } + } else { + ctx->todo -= m; + ctx->pos = pos + m; + } + } + + return RTEMS_RECORD_CLIENT_SUCCESS; +} + +static rtems_record_client_status consume_swap_32( + rtems_record_client_context *ctx, + const void *buf, + size_t n +) +{ + while ( n > 0 ) { + size_t m; + char *pos; + + m = ctx->todo < n ? ctx->todo : n; + pos = ctx->pos; + pos = memcpy( pos, buf, m ); + n -= m; + buf = (char *) buf + m; + + if ( m == ctx->todo ) { + rtems_record_client_status status; + + ctx->todo = sizeof( ctx->item.format_32 ); + ctx->pos = &ctx->item.format_32; + + status = visit( + ctx, + __builtin_bswap32( ctx->item.format_32.event ), + __builtin_bswap32( ctx->item.format_32.data ) + ); + + if ( status != RTEMS_RECORD_CLIENT_SUCCESS ) { + return status; + } + } else { + ctx->todo -= m; + ctx->pos = pos + m; + } + } + + return RTEMS_RECORD_CLIENT_SUCCESS; +} + +static rtems_record_client_status consume_swap_64( + rtems_record_client_context *ctx, + const void *buf, + size_t n +) +{ + while ( n > 0 ) { + size_t m; + char *pos; + + m = ctx->todo < n ? ctx->todo : n; + pos = ctx->pos; + pos = memcpy( pos, buf, m ); + n -= m; + buf = (char *) buf + m; + + if ( m == ctx->todo ) { + rtems_record_client_status status; + + ctx->todo = sizeof( ctx->item.format_64 ); + ctx->pos = &ctx->item.format_64; + + status = visit( + ctx, + __builtin_bswap32( ctx->item.format_64.event ), + __builtin_bswap64( ctx->item.format_64.data ) + ); + + if ( status != RTEMS_RECORD_CLIENT_SUCCESS ) { + return status; + } + } else { + ctx->todo -= m; + ctx->pos = pos + m; + } + } + + return RTEMS_RECORD_CLIENT_SUCCESS; +} + +static rtems_record_client_status consume_init( + rtems_record_client_context *ctx, + const void *buf, + size_t n +) +{ + while ( n > 0 ) { + size_t m; + char *pos; + + m = ctx->todo < n ? ctx->todo : n; + pos = ctx->pos; + pos = memcpy( pos, buf, m ); + n -= m; + buf = (char *) buf + m; + + if ( m == ctx->todo ) { + uint32_t magic; + + magic = ctx->header[ 1 ]; + + switch ( ctx->header[ 0 ] ) { +#if __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__ + case RTEMS_RECORD_FORMAT_LE_32: + ctx->todo = sizeof( ctx->item.format_32 ); + ctx->pos = &ctx->item.format_32; + ctx->consume = consume_32; + break; + case RTEMS_RECORD_FORMAT_LE_64: + ctx->todo = sizeof( ctx->item.format_64 ); + ctx->pos = &ctx->item.format_64; + ctx->consume = consume_64; + break; + case RTEMS_RECORD_FORMAT_BE_32: + ctx->todo = sizeof( ctx->item.format_32 ); + ctx->pos = &ctx->item.format_32; + ctx->consume = consume_swap_32; + magic = __builtin_bswap32( magic ); + break; + case RTEMS_RECORD_FORMAT_BE_64: + ctx->todo = sizeof( ctx->item.format_64 ); + ctx->pos = &ctx->item.format_64; + ctx->consume = consume_swap_64; + magic = __builtin_bswap32( magic ); + break; +#elif __BYTE_ORDER__ == __ORDER_BIG_ENDIAN__ + case RTEMS_RECORD_FORMAT_LE_32: + ctx->todo = sizeof( ctx->item.format_32 ); + ctx->pos = &ctx->item.format_32; + ctx->consume = consume_swap_32; + magic = __builtin_bswap32( magic ); + break; + case RTEMS_RECORD_FORMAT_LE_64: + ctx->todo = sizeof( ctx->item.format_64 ); + ctx->pos = &ctx->item.format_64; + ctx->consume = consume_swap_64; + magic = __builtin_bswap32( magic ); + break; + case RTEMS_RECORD_FORMAT_BE_32: + ctx->todo = sizeof( ctx->item.format_32 ); + ctx->pos = &ctx->item.format_32; + ctx->consume = consume_32; + break; + case RTEMS_RECORD_FORMAT_BE_64: + ctx->todo = sizeof( ctx->item.format_64 ); + ctx->pos = &ctx->item.format_64; + ctx->consume = consume_64; + break; +#else +#error "unexpected __BYTE_ORDER__" +#endif + default: + return error( ctx, RTEMS_RECORD_CLIENT_ERROR_UNKNOWN_FORMAT ); + } + + if ( magic != RTEMS_RECORD_MAGIC ) { + return error( ctx, RTEMS_RECORD_CLIENT_ERROR_INVALID_MAGIC ); + } + + return rtems_record_client_run( ctx, buf, n ); + } else { + ctx->todo -= m; + ctx->pos = pos + m; + } + } + + return RTEMS_RECORD_CLIENT_SUCCESS; +} + +void rtems_record_client_init( + rtems_record_client_context *ctx, + rtems_record_client_handler handler, + void *arg +) +{ + ctx = memset( ctx, 0, sizeof( *ctx ) ); + ctx->to_bt_scaler = UINT64_C( 1 ) << 31; + ctx->handler = handler; + ctx->handler_arg = arg; + ctx->todo = sizeof( ctx->header ); + ctx->pos = &ctx->header; + ctx->consume = consume_init; +} + +rtems_record_client_status rtems_record_client_run( + rtems_record_client_context *ctx, + const void *buf, + size_t n +) +{ + return ( *ctx->consume )( ctx, buf, n ); +} + +void rtems_record_client_destroy( + rtems_record_client_context *ctx +) +{ + uint32_t cpu; + + for ( cpu = 0; cpu < ctx->cpu_count; ++cpu ) { + rtems_record_client_per_cpu *per_cpu; + + ctx->cpu = cpu; + per_cpu = &ctx->per_cpu[ cpu ]; + per_cpu->head[ per_cpu->tail_head_index ^ 1 ] = + per_cpu->head[ per_cpu->tail_head_index ]; + resolve_hold_back( ctx, per_cpu ); + } + + free( ctx->per_cpu[ 0 ].items ); +} diff --git a/trace/record/record-main-lttng.c b/trace/record/record-main-lttng.c new file mode 100644 index 0000000..570e748 --- /dev/null +++ b/trace/record/record-main-lttng.c @@ -0,0 +1,198 @@ +/* + * SPDX-License-Identifier: BSD-2-Clause + * + * Copyright (C) 2018, 2019 embedded brains GmbH + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" + * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE + * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR + * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF + * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS + * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN + * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) + * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE + * POSSIBILITY OF SUCH DAMAGE. + */ + +#include +#include + +#include +#include + +#include +#include +#include +#include +#include +#include +#include +#include + +#include +#include + +static const struct option longopts[] = { + { "help", 0, NULL, 'h' }, + { "host", 1, NULL, 'H' }, + { "port", 1, NULL, 'p' }, + { NULL, 0, NULL, 0 } +}; + +typedef struct client_item { + uint64_t ns; + uint32_t cpu; + rtems_record_event event; + uint64_t data; +} client_item; + +typedef struct client_context { + int dummy; +} client_context; + +static void usage( char **argv ) +{ + printf( + "%s [--host=HOST] [--port=PORT]\n" + "\n" + "Mandatory arguments to long options are mandatory for short options too.\n" + " -h, --help print this help text\n" + " -H, --host=HOST the host IPv4 address of the record server\n" + " -p, --port=PORT the TCP port of the record server\n" + argv[ 0 ] + ); +} + +static int connect_client( const char *host, uint16_t port ) +{ + struct sockaddr_in in_addr; + int fd; + int rv; + + fd = socket( PF_INET, SOCK_STREAM, 0 ); + assert( fd >= 0 ); + + memset( &in_addr, 0, sizeof( in_addr ) ); + in_addr.sin_family = AF_INET; + in_addr.sin_port = htons( port ); + in_addr.sin_addr.s_addr = inet_addr( host ); + rv = connect( fd, (struct sockaddr *) &in_addr, sizeof( in_addr ) ); + assert( rv == 0 ); + + return fd; +} + +static void print_item( FILE *f, const client_item *item ) +{ + if ( item->ns != 0 ) { + uint32_t seconds; + uint32_t nanoseconds; + + seconds = (uint32_t) ( item->ns / 1000000000 ); + nanoseconds = (uint32_t) ( item->ns % 1000000000 ); + fprintf( f, "%" PRIu32 ".%09" PRIu32 ":", seconds, nanoseconds ); + } else { + fprintf( f, "*:" ); + } + + fprintf( + f, + "%" PRIu32 ":%s:%" PRIx64 "\n", + item->cpu, + rtems_record_event_text( item->event ), + item->data + ); +} + +static rtems_record_client_status handler( + uint64_t bt, + uint32_t cpu, + rtems_record_event event, + uint64_t data, + void *arg +) +{ + client_context *cctx; + client_item item; + + cctx = arg; + (void) cctx; + + item.ns = rtems_record_client_bintime_to_nanoseconds( bt ); + item.cpu = cpu; + item.event = event; + item.data = data; + + print_item( stdout, &item ); + + return RTEMS_RECORD_CLIENT_SUCCESS; +} + +int main( int argc, char **argv ) +{ + rtems_record_client_context ctx; + client_context cctx; + const char *host; + uint16_t port; + int fd; + int rv; + int opt; + int longindex; + + host = "127.0.0.1"; + port = 1234; + + while ( + ( opt = getopt_long( argc, argv, "hH:p:", &longopts[0], &longindex ) ) + != -1 + ) { + switch ( opt ) { + case 'h': + usage( argv ); + exit( EXIT_SUCCESS ); + break; + case 'H': + host = optarg; + break; + case 'p': + port = (uint16_t) strtoul( optarg, NULL, 10 ); + break; + default: + exit( EXIT_FAILURE ); + break; + } + } + + memset( &cctx, 0, sizeof( cctx ) ); + + fd = connect_client( host, port ); + rtems_record_client_init( &ctx, handler, &cctx ); + + while ( true ) { + int buf[ 8192 ]; + ssize_t n; + + n = recv( fd, buf, sizeof( buf ), 0 ); + if ( n >= 0 ) { + rtems_record_client_run( &ctx, buf, (size_t) n ); + } else { + break; + } + } + + rv = close( fd ); + assert( rv == 0 ); + + return 0; +} diff --git a/trace/record/record-text.c b/trace/record/record-text.c new file mode 100644 index 0000000..5652ab0 --- /dev/null +++ b/trace/record/record-text.c @@ -0,0 +1,1071 @@ +/* + * SPDX-License-Identifier: BSD-2-Clause + * + * Copyright (C) 2018, 2019 embedded brains GmbH + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" + * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE + * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR + * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF + * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS + * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN + * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) + * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE + * POSSIBILITY OF SUCH DAMAGE. + */ + +/* + * This file must be compatible to general purpose POSIX system, e.g. Linux, + * FreeBSD. It may be used for utility programs. + */ + +#if HAVE_CONFIG_H +#include "config.h" +#endif + +#include + +#include + +static const char * const event_text[] = { + [ RTEMS_RECORD_EMPTY ] = "EMPTY", + [ RTEMS_RECORD_VERSION ] = "VERSION", + [ RTEMS_RECORD_ACCEPT_ENTRY ] = "ACCEPT_ENTRY", + [ RTEMS_RECORD_ACCEPT_EXIT ] = "ACCEPT_EXIT", + [ RTEMS_RECORD_BIND_ENTRY ] = "BIND_ENTRY", + [ RTEMS_RECORD_BIND_EXIT ] = "BIND_EXIT", + [ RTEMS_RECORD_BUFFER ] = "BUFFER", + [ RTEMS_RECORD_CHOWN_ENTRY ] = "CHOWN_ENTRY", + [ RTEMS_RECORD_CHOWN_EXIT ] = "CHOWN_EXIT", + [ RTEMS_RECORD_CLOSE_ENTRY ] = "CLOSE_ENTRY", + [ RTEMS_RECORD_CLOSE_EXIT ] = "CLOSE_EXIT", + [ RTEMS_RECORD_CONNECT_ENTRY ] = "CONNECT_ENTRY", + [ RTEMS_RECORD_CONNECT_EXIT ] = "CONNECT_EXIT", + [ RTEMS_RECORD_ETHER_INPUT ] = "ETHER_INPUT", + [ RTEMS_RECORD_ETHER_OUTPUT ] = "ETHER_OUTPUT", + [ RTEMS_RECORD_FCHMOD_ENTRY ] = "FCHMOD_ENTRY", + [ RTEMS_RECORD_FCHMOD_EXIT ] = "FCHMOD_EXIT", + [ RTEMS_RECORD_FCNTL_ENTRY ] = "FCNTL_ENTRY", + [ RTEMS_RECORD_FCNTL_EXIT ] = "FCNTL_EXIT", + [ RTEMS_RECORD_FDATASYNC_ENTRY ] = "FDATASYNC_ENTRY", + [ RTEMS_RECORD_FDATASYNC_EXIT ] = "FDATASYNC_EXIT", + [ RTEMS_RECORD_FREQUENCY ] = "FREQUENCY", + [ RTEMS_RECORD_FSTAT_ENTRY ] = "FSTAT_ENTRY", + [ RTEMS_RECORD_FSTAT_EXIT ] = "FSTAT_EXIT", + [ RTEMS_RECORD_FSYNC_ENTRY ] = "FSYNC_ENTRY", + [ RTEMS_RECORD_FSYNC_EXIT ] = "FSYNC_EXIT", + [ RTEMS_RECORD_FTRUNCATE_ENTRY ] = "FTRUNCATE_ENTRY", + [ RTEMS_RECORD_FTRUNCATE_EXIT ] = "FTRUNCATE_EXIT", + [ RTEMS_RECORD_GETSOCKOPT_ENTRY ] = "GETSOCKOPT_ENTRY", + [ RTEMS_RECORD_GETSOCKOPT_EXIT ] = "GETSOCKOPT_EXIT", + [ RTEMS_RECORD_GIT_HASH ] = "GIT_HASH", + [ RTEMS_RECORD_HEAP_ALLOC ] = "HEAP_ALLOC", + [ RTEMS_RECORD_HEAP_FREE ] = "HEAP_FREE", + [ RTEMS_RECORD_HEAP_SIZE ] = "HEAP_SIZE", + [ RTEMS_RECORD_HEAP_USAGE ] = "HEAP_USAGE", + [ RTEMS_RECORD_INTERRUPT_ENTRY ] = "INTERRUPT_ENTRY", + [ RTEMS_RECORD_INTERRUPT_EXIT ] = "INTERRUPT_EXIT", + [ RTEMS_RECORD_INTERRUPT_INSTALL ] = "INTERRUPT_INSTALL", + [ RTEMS_RECORD_INTERRUPT_REMOVE ] = "INTERRUPT_REMOVE", + [ RTEMS_RECORD_INTERRUPT_SERVER_ENTRY ] = "INTERRUPT_SERVER_ENTRY", + [ RTEMS_RECORD_INTERRUPT_SERVER_EXIT ] = "INTERRUPT_SERVER_EXIT", + [ RTEMS_RECORD_INTERRUPT_SERVER_INSTALL ] = "INTERRUPT_SERVER_INSTALL", + [ RTEMS_RECORD_INTERRUPT_SERVER_MOVE ] = "INTERRUPT_SERVER_MOVE", + [ RTEMS_RECORD_INTERRUPT_SERVER_REMOVE ] = "INTERRUPT_SERVER_REMOVE", + [ RTEMS_RECORD_INTERRUPT_SERVER_TRIGGER ] = "INTERRUPT_SERVER_TRIGGER", + [ RTEMS_RECORD_IOCTL_ENTRY ] = "IOCTL_ENTRY", + [ RTEMS_RECORD_IOCTL_EXIT ] = "IOCTL_EXIT", + [ RTEMS_RECORD_IP6_INPUT ] = "IP6_INPUT", + [ RTEMS_RECORD_IP6_OUTPUT ] = "IP6_OUTPUT", + [ RTEMS_RECORD_IP_INPUT ] = "IP_INPUT", + [ RTEMS_RECORD_IP_OUTPUT ] = "IP_OUTPUT", + [ RTEMS_RECORD_KEVENT_ENTRY ] = "KEVENT_ENTRY", + [ RTEMS_RECORD_KEVENT_EXIT ] = "KEVENT_EXIT", + [ RTEMS_RECORD_KQUEUE_ENTRY ] = "KQUEUE_ENTRY", + [ RTEMS_RECORD_KQUEUE_EXIT ] = "KQUEUE_EXIT", + [ RTEMS_RECORD_LENGTH ] = "LENGTH", + [ RTEMS_RECORD_LINK_ENTRY ] = "LINK_ENTRY", + [ RTEMS_RECORD_LINK_EXIT ] = "LINK_EXIT", + [ RTEMS_RECORD_LISTEN_ENTRY ] = "LISTEN_ENTRY", + [ RTEMS_RECORD_LISTEN_EXIT ] = "LISTEN_EXIT", + [ RTEMS_RECORD_LSEEK_ENTRY ] = "LSEEK_ENTRY", + [ RTEMS_RECORD_LSEEK_EXIT ] = "LSEEK_EXIT", + [ RTEMS_RECORD_MKNOD_ENTRY ] = "MKNOD_ENTRY", + [ RTEMS_RECORD_MKNOD_EXIT ] = "MKNOD_EXIT", + [ RTEMS_RECORD_MMAP_ENTRY ] = "MMAP_ENTRY", + [ RTEMS_RECORD_MMAP_EXIT ] = "MMAP_EXIT", + [ RTEMS_RECORD_MOUNT_ENTRY ] = "MOUNT_ENTRY", + [ RTEMS_RECORD_MOUNT_EXIT ] = "MOUNT_EXIT", + [ RTEMS_RECORD_OPEN_ENTRY ] = "OPEN_ENTRY", + [ RTEMS_RECORD_OPEN_EXIT ] = "OPEN_EXIT", + [ RTEMS_RECORD_PAGE_ALLOC ] = "PAGE_ALLOC", + [ RTEMS_RECORD_PAGE_FREE ] = "PAGE_FREE", + [ RTEMS_RECORD_PER_CPU_COUNT ] = "PER_CPU_COUNT", + [ RTEMS_RECORD_PER_CPU_HEAD ] = "PER_CPU_HEAD", + [ RTEMS_RECORD_PER_CPU_OVERFLOW ] = "PER_CPU_OVERFLOW", + [ RTEMS_RECORD_PER_CPU_TAIL ] = "PER_CPU_TAIL", + [ RTEMS_RECORD_POLL_ENTRY ] = "POLL_ENTRY", + [ RTEMS_RECORD_POLL_EXIT ] = "POLL_EXIT", + [ RTEMS_RECORD_PROCESSOR ] = "PROCESSOR", + [ RTEMS_RECORD_PROCESSOR_MAXIMUM ] = "PROCESSOR_MAXIMUM", + [ RTEMS_RECORD_READ_ENTRY ] = "READ_ENTRY", + [ RTEMS_RECORD_READ_EXIT ] = "READ_EXIT", + [ RTEMS_RECORD_READLINK_ENTRY ] = "READLINK_ENTRY", + [ RTEMS_RECORD_READLINK_EXIT ] = "READLINK_EXIT", + [ RTEMS_RECORD_READV_ENTRY ] = "READV_ENTRY", + [ RTEMS_RECORD_READV_EXIT ] = "READV_EXIT", + [ RTEMS_RECORD_RECV_ENTRY ] = "RECV_ENTRY", + [ RTEMS_RECORD_RECV_EXIT ] = "RECV_EXIT", + [ RTEMS_RECORD_RECVFROM_ENTRY ] = "RECVFROM_ENTRY", + [ RTEMS_RECORD_RECVFROM_EXIT ] = "RECVFROM_EXIT", + [ RTEMS_RECORD_RECVMSG_ENTRY ] = "RECVMSG_ENTRY", + [ RTEMS_RECORD_RECVMSG_EXIT ] = "RECVMSG_EXIT", + [ RTEMS_RECORD_RENAME_ENTRY ] = "RENAME_ENTRY", + [ RTEMS_RECORD_RENAME_EXIT ] = "RENAME_EXIT", + [ RTEMS_RECORD_RTEMS_BARRIER_CREATE ] = "RTEMS_BARRIER_CREATE", + [ RTEMS_RECORD_RTEMS_BARRIER_DELETE ] = "RTEMS_BARRIER_DELETE", + [ RTEMS_RECORD_RTEMS_BARRIER_RELEASE ] = "RTEMS_BARRIER_RELEASE", + [ RTEMS_RECORD_RTEMS_BARRIER_WAIT ] = "RTEMS_BARRIER_WAIT", + [ RTEMS_RECORD_RTEMS_EVENT_RECEIVE ] = "RTEMS_EVENT_RECEIVE", + [ RTEMS_RECORD_RTEMS_EVENT_SEND ] = "RTEMS_EVENT_SEND", + [ RTEMS_RECORD_RTEMS_EVENT_SYSTEM_RECEIVE ] = "RTEMS_EVENT_SYSTEM_RECEIVE", + [ RTEMS_RECORD_RTEMS_EVENT_SYSTEM_SEND ] = "RTEMS_EVENT_SYSTEM_SEND", + [ RTEMS_RECORD_RTEMS_MESSAGE_QUEUE_BROADCAST ] = "RTEMS_MESSAGE_QUEUE_BROADCAST", + [ RTEMS_RECORD_RTEMS_MESSAGE_QUEUE_CREATE ] = "RTEMS_MESSAGE_QUEUE_CREATE", + [ RTEMS_RECORD_RTEMS_MESSAGE_QUEUE_DELETE ] = "RTEMS_MESSAGE_QUEUE_DELETE", + [ RTEMS_RECORD_RTEMS_MESSAGE_QUEUE_FLUSH ] = "RTEMS_MESSAGE_QUEUE_FLUSH", + [ RTEMS_RECORD_RTEMS_MESSAGE_QUEUE_RECEIVE ] = "RTEMS_MESSAGE_QUEUE_RECEIVE", + [ RTEMS_RECORD_RTEMS_MESSAGE_QUEUE_SEND ] = "RTEMS_MESSAGE_QUEUE_SEND", + [ RTEMS_RECORD_RTEMS_MESSAGE_QUEUE_URGENT ] = "RTEMS_MESSAGE_QUEUE_URGENT", + [ RTEMS_RECORD_RTEMS_PARTITION_CREATE ] = "RTEMS_PARTITION_CREATE", + [ RTEMS_RECORD_RTEMS_PARTITION_DELETE ] = "RTEMS_PARTITION_DELETE", + [ RTEMS_RECORD_RTEMS_PARTITION_GET_BUFFER ] = "RTEMS_PARTITION_GET_BUFFER", + [ RTEMS_RECORD_RTEMS_PARTITION_RETURN_BUFFER ] = "RTEMS_PARTITION_RETURN_BUFFER", + [ RTEMS_RECORD_RTEMS_RATE_MONOTONIC_CANCEL ] = "RTEMS_RATE_MONOTONIC_CANCEL", + [ RTEMS_RECORD_RTEMS_RATE_MONOTONIC_CREATE ] = "RTEMS_RATE_MONOTONIC_CREATE", + [ RTEMS_RECORD_RTEMS_RATE_MONOTONIC_DELETE ] = "RTEMS_RATE_MONOTONIC_DELETE", + [ RTEMS_RECORD_RTEMS_RATE_MONOTONIC_PERIOD ] = "RTEMS_RATE_MONOTONIC_PERIOD", + [ RTEMS_RECORD_RTEMS_SEMAPHORE_CREATE ] = "RTEMS_SEMAPHORE_CREATE", + [ RTEMS_RECORD_RTEMS_SEMAPHORE_DELETE ] = "RTEMS_SEMAPHORE_DELETE", + [ RTEMS_RECORD_RTEMS_SEMAPHORE_FLUSH ] = "RTEMS_SEMAPHORE_FLUSH", + [ RTEMS_RECORD_RTEMS_SEMAPHORE_OBTAIN ] = "RTEMS_SEMAPHORE_OBTAIN", + [ RTEMS_RECORD_RTEMS_SEMAPHORE_RELEASE ] = "RTEMS_SEMAPHORE_RELEASE", + [ RTEMS_RECORD_RTEMS_TIMER_CANCEL ] = "RTEMS_TIMER_CANCEL", + [ RTEMS_RECORD_RTEMS_TIMER_CREATE ] = "RTEMS_TIMER_CREATE", + [ RTEMS_RECORD_RTEMS_TIMER_DELETE ] = "RTEMS_TIMER_DELETE", + [ RTEMS_RECORD_RTEMS_TIMER_FIRE_AFTER ] = "RTEMS_TIMER_FIRE_AFTER", + [ RTEMS_RECORD_RTEMS_TIMER_FIRE_WHEN ] = "RTEMS_TIMER_FIRE_WHEN", + [ RTEMS_RECORD_RTEMS_TIMER_RESET ] = "RTEMS_TIMER_RESET", + [ RTEMS_RECORD_RTEMS_TIMER_SERVER_FIRE_AFTER ] = "RTEMS_TIMER_SERVER_FIRE_AFTER", + [ RTEMS_RECORD_RTEMS_TIMER_SERVER_FIRE_WHEN ] = "RTEMS_TIMER_SERVER_FIRE_WHEN", + [ RTEMS_RECORD_SBWAIT_ENTRY ] = "SBWAIT_ENTRY", + [ RTEMS_RECORD_SBWAIT_EXIT ] = "SBWAIT_EXIT", + [ RTEMS_RECORD_SBWAKEUP_ENTRY ] = "SBWAKEUP_ENTRY", + [ RTEMS_RECORD_SBWAKEUP_EXIT ] = "SBWAKEUP_EXIT", + [ RTEMS_RECORD_SELECT_ENTRY ] = "SELECT_ENTRY", + [ RTEMS_RECORD_SELECT_EXIT ] = "SELECT_EXIT", + [ RTEMS_RECORD_SEND_ENTRY ] = "SEND_ENTRY", + [ RTEMS_RECORD_SEND_EXIT ] = "SEND_EXIT", + [ RTEMS_RECORD_SENDMSG_ENTRY ] = "SENDMSG_ENTRY", + [ RTEMS_RECORD_SENDMSG_EXIT ] = "SENDMSG_EXIT", + [ RTEMS_RECORD_SENDTO_ENTRY ] = "SENDTO_ENTRY", + [ RTEMS_RECORD_SENDTO_EXIT ] = "SENDTO_EXIT", + [ RTEMS_RECORD_SETSOCKOPT_ENTRY ] = "SETSOCKOPT_ENTRY", + [ RTEMS_RECORD_SETSOCKOPT_EXIT ] = "SETSOCKOPT_EXIT", + [ RTEMS_RECORD_SHUTDOWN_ENTRY ] = "SHUTDOWN_ENTRY", + [ RTEMS_RECORD_SHUTDOWN_EXIT ] = "SHUTDOWN_EXIT", + [ RTEMS_RECORD_SOABORT_ENTRY ] = "SOABORT_ENTRY", + [ RTEMS_RECORD_SOABORT_EXIT ] = "SOABORT_EXIT", + [ RTEMS_RECORD_SOACCEPT_ENTRY ] = "SOACCEPT_ENTRY", + [ RTEMS_RECORD_SOACCEPT_EXIT ] = "SOACCEPT_EXIT", + [ RTEMS_RECORD_SOALLOC_ENTRY ] = "SOALLOC_ENTRY", + [ RTEMS_RECORD_SOALLOC_EXIT ] = "SOALLOC_EXIT", + [ RTEMS_RECORD_SOBINDAT_ENTRY ] = "SOBINDAT_ENTRY", + [ RTEMS_RECORD_SOBINDAT_EXIT ] = "SOBINDAT_EXIT", + [ RTEMS_RECORD_SOBIND_ENTRY ] = "SOBIND_ENTRY", + [ RTEMS_RECORD_SOBIND_EXIT ] = "SOBIND_EXIT", + [ RTEMS_RECORD_SOCKET_ENTRY ] = "SOCKET_ENTRY", + [ RTEMS_RECORD_SOCKET_EXIT ] = "SOCKET_EXIT", + [ RTEMS_RECORD_SOCLOSE_ENTRY ] = "SOCLOSE_ENTRY", + [ RTEMS_RECORD_SOCLOSE_EXIT ] = "SOCLOSE_EXIT", + [ RTEMS_RECORD_SOCONNECT2_ENTRY ] = "SOCONNECT2_ENTRY", + [ RTEMS_RECORD_SOCONNECT2_EXIT ] = "SOCONNECT2_EXIT", + [ RTEMS_RECORD_SOCONNECTAT_ENTRY ] = "SOCONNECTAT_ENTRY", + [ RTEMS_RECORD_SOCONNECTAT_EXIT ] = "SOCONNECTAT_EXIT", + [ RTEMS_RECORD_SOCREATE_ENTRY ] = "SOCREATE_ENTRY", + [ RTEMS_RECORD_SOCREATE_EXIT ] = "SOCREATE_EXIT", + [ RTEMS_RECORD_SODEALLOC_ENTRY ] = "SODEALLOC_ENTRY", + [ RTEMS_RECORD_SODEALLOC_EXIT ] = "SODEALLOC_EXIT", + [ RTEMS_RECORD_SODISCONNECT_ENTRY ] = "SODISCONNECT_ENTRY", + [ RTEMS_RECORD_SODISCONNECT_EXIT ] = "SODISCONNECT_EXIT", + [ RTEMS_RECORD_SOFREE_ENTRY ] = "SOFREE_ENTRY", + [ RTEMS_RECORD_SOFREE_EXIT ] = "SOFREE_EXIT", + [ RTEMS_RECORD_SOLISTEN_ENTRY ] = "SOLISTEN_ENTRY", + [ RTEMS_RECORD_SOLISTEN_EXIT ] = "SOLISTEN_EXIT", + [ RTEMS_RECORD_SONEWCONN_ENTRY ] = "SONEWCONN_ENTRY", + [ RTEMS_RECORD_SONEWCONN_EXIT ] = "SONEWCONN_EXIT", + [ RTEMS_RECORD_SORECEIVE_ENTRY ] = "SORECEIVE_ENTRY", + [ RTEMS_RECORD_SORECEIVE_EXIT ] = "SORECEIVE_EXIT", + [ RTEMS_RECORD_SORFLUSH_ENTRY ] = "SORFLUSH_ENTRY", + [ RTEMS_RECORD_SORFLUSH_EXIT ] = "SORFLUSH_EXIT", + [ RTEMS_RECORD_SOSEND_ENTRY ] = "SOSEND_ENTRY", + [ RTEMS_RECORD_SOSEND_EXIT ] = "SOSEND_EXIT", + [ RTEMS_RECORD_SOSHUTDOWN_ENTRY ] = "SOSHUTDOWN_ENTRY", + [ RTEMS_RECORD_SOSHUTDOWN_EXIT ] = "SOSHUTDOWN_EXIT", + [ RTEMS_RECORD_STATVFS_ENTRY ] = "STATVFS_ENTRY", + [ RTEMS_RECORD_STATVFS_EXIT ] = "STATVFS_EXIT", + [ RTEMS_RECORD_SYMLINK_ENTRY ] = "SYMLINK_ENTRY", + [ RTEMS_RECORD_SYMLINK_EXIT ] = "SYMLINK_EXIT", + [ RTEMS_RECORD_TCP_CLOSE ] = "TCP_CLOSE", + [ RTEMS_RECORD_TCP_INPUT ] = "TCP_INPUT", + [ RTEMS_RECORD_TCP_OUTPUT ] = "TCP_OUTPUT", + [ RTEMS_RECORD_THREAD_BEGIN ] = "THREAD_BEGIN", + [ RTEMS_RECORD_THREAD_CREATE ] = "THREAD_CREATE", + [ RTEMS_RECORD_THREAD_DELETE ] = "THREAD_DELETE", + [ RTEMS_RECORD_THREAD_EXIT ] = "THREAD_EXIT", + [ RTEMS_RECORD_THREAD_EXITTED ] = "THREAD_EXITTED", + [ RTEMS_RECORD_THREAD_ID ] = "THREAD_ID", + [ RTEMS_RECORD_THREAD_NAME ] = "THREAD_NAME", + [ RTEMS_RECORD_THREAD_PRIO_CURRENT_HIGH ] = "THREAD_PRIO_CURRENT_HIGH", + [ RTEMS_RECORD_THREAD_PRIO_CURRENT_LOW ] = "THREAD_PRIO_CURRENT_LOW", + [ RTEMS_RECORD_THREAD_PRIO_REAL_HIGH ] = "THREAD_PRIO_REAL_HIGH", + [ RTEMS_RECORD_THREAD_PRIO_REAL_LOW ] = "THREAD_PRIO_REAL_LOW", + [ RTEMS_RECORD_THREAD_QUEUE_ENQUEUE ] = "THREAD_QUEUE_ENQUEUE", + [ RTEMS_RECORD_THREAD_QUEUE_ENQUEUE_STICKY ] = "THREAD_QUEUE_ENQUEUE_STICKY", + [ RTEMS_RECORD_THREAD_QUEUE_EXTRACT ] = "THREAD_QUEUE_EXTRACT", + [ RTEMS_RECORD_THREAD_QUEUE_SURRENDER ] = "THREAD_QUEUE_SURRENDER", + [ RTEMS_RECORD_THREAD_QUEUE_SURRENDER_STICKY ] = "THREAD_QUEUE_SURRENDER_STICKY", + [ RTEMS_RECORD_THREAD_RESOURCE_OBTAIN ] = "THREAD_RESOURCE_OBTAIN", + [ RTEMS_RECORD_THREAD_RESOURCE_RELEASE ] = "THREAD_RESOURCE_RELEASE", + [ RTEMS_RECORD_THREAD_RESTART ] = "THREAD_RESTART", + [ RTEMS_RECORD_THREAD_STACK_CURRENT ] = "THREAD_STACK_CURRENT", + [ RTEMS_RECORD_THREAD_STACK_SIZE ] = "THREAD_STACK_SIZE", + [ RTEMS_RECORD_THREAD_STACK_USAGE ] = "THREAD_STACK_USAGE", + [ RTEMS_RECORD_THREAD_START ] = "THREAD_START", + [ RTEMS_RECORD_THREAD_STATE_CLEAR ] = "THREAD_STATE_CLEAR", + [ RTEMS_RECORD_THREAD_STATE_SET ] = "THREAD_STATE_SET", + [ RTEMS_RECORD_THREAD_SWITCH_IN ] = "THREAD_SWITCH_IN", + [ RTEMS_RECORD_THREAD_SWITCH_OUT ] = "THREAD_SWITCH_OUT", + [ RTEMS_RECORD_THREAD_TERMINATE ] = "THREAD_TERMINATE", + [ RTEMS_RECORD_UDP_INPUT ] = "UDP_INPUT", + [ RTEMS_RECORD_UDP_OUTPUT ] = "UDP_OUTPUT", + [ RTEMS_RECORD_UMA_ALLOC_PTR ] = "UMA_ALLOC_PTR", + [ RTEMS_RECORD_UMA_ALLOC_ZONE ] = "UMA_ALLOC_ZONE", + [ RTEMS_RECORD_UMA_FREE_PTR ] = "UMA_FREE_PTR", + [ RTEMS_RECORD_UMA_FREE_ZONE ] = "UMA_FREE_ZONE", + [ RTEMS_RECORD_UNLINK_ENTRY ] = "UNLINK_ENTRY", + [ RTEMS_RECORD_UNLINK_EXIT ] = "UNLINK_EXIT", + [ RTEMS_RECORD_UNMOUNT_ENTRY ] = "UNMOUNT_ENTRY", + [ RTEMS_RECORD_UNMOUNT_EXIT ] = "UNMOUNT_EXIT", + [ RTEMS_RECORD_UPTIME_HIGH ] = "UPTIME_HIGH", + [ RTEMS_RECORD_UPTIME_LOW ] = "UPTIME_LOW", + [ RTEMS_RECORD_WORKSPACE_ALLOC ] = "WORKSPACE_ALLOC", + [ RTEMS_RECORD_WORKSPACE_FREE ] = "WORKSPACE_FREE", + [ RTEMS_RECORD_WORKSPACE_SIZE ] = "WORKSPACE_SIZE", + [ RTEMS_RECORD_WORKSPACE_USAGE ] = "WORKSPACE_USAGE", + [ RTEMS_RECORD_WRITE_ENTRY ] = "WRITE_ENTRY", + [ RTEMS_RECORD_WRITE_EXIT ] = "WRITE_EXIT", + [ RTEMS_RECORD_WRITEV_ENTRY ] = "WRITEV_ENTRY", + [ RTEMS_RECORD_WRITEV_EXIT ] = "WRITEV_EXIT", + [ RTEMS_RECORD_SYSTEM_238 ] = "SYSTEM_238", + [ RTEMS_RECORD_SYSTEM_239 ] = "SYSTEM_239", + [ RTEMS_RECORD_SYSTEM_240 ] = "SYSTEM_240", + [ RTEMS_RECORD_SYSTEM_241 ] = "SYSTEM_241", + [ RTEMS_RECORD_SYSTEM_242 ] = "SYSTEM_242", + [ RTEMS_RECORD_SYSTEM_243 ] = "SYSTEM_243", + [ RTEMS_RECORD_SYSTEM_244 ] = "SYSTEM_244", + [ RTEMS_RECORD_SYSTEM_245 ] = "SYSTEM_245", + [ RTEMS_RECORD_SYSTEM_246 ] = "SYSTEM_246", + [ RTEMS_RECORD_SYSTEM_247 ] = "SYSTEM_247", + [ RTEMS_RECORD_SYSTEM_248 ] = "SYSTEM_248", + [ RTEMS_RECORD_SYSTEM_249 ] = "SYSTEM_249", + [ RTEMS_RECORD_SYSTEM_250 ] = "SYSTEM_250", + [ RTEMS_RECORD_SYSTEM_251 ] = "SYSTEM_251", + [ RTEMS_RECORD_SYSTEM_252 ] = "SYSTEM_252", + [ RTEMS_RECORD_SYSTEM_253 ] = "SYSTEM_253", + [ RTEMS_RECORD_SYSTEM_254 ] = "SYSTEM_254", + [ RTEMS_RECORD_SYSTEM_255 ] = "SYSTEM_255", + [ RTEMS_RECORD_SYSTEM_256 ] = "SYSTEM_256", + [ RTEMS_RECORD_SYSTEM_257 ] = "SYSTEM_257", + [ RTEMS_RECORD_SYSTEM_258 ] = "SYSTEM_258", + [ RTEMS_RECORD_SYSTEM_259 ] = "SYSTEM_259", + [ RTEMS_RECORD_SYSTEM_260 ] = "SYSTEM_260", + [ RTEMS_RECORD_SYSTEM_261 ] = "SYSTEM_261", + [ RTEMS_RECORD_SYSTEM_262 ] = "SYSTEM_262", + [ RTEMS_RECORD_SYSTEM_263 ] = "SYSTEM_263", + [ RTEMS_RECORD_SYSTEM_264 ] = "SYSTEM_264", + [ RTEMS_RECORD_SYSTEM_265 ] = "SYSTEM_265", + [ RTEMS_RECORD_SYSTEM_266 ] = "SYSTEM_266", + [ RTEMS_RECORD_SYSTEM_267 ] = "SYSTEM_267", + [ RTEMS_RECORD_SYSTEM_268 ] = "SYSTEM_268", + [ RTEMS_RECORD_SYSTEM_269 ] = "SYSTEM_269", + [ RTEMS_RECORD_SYSTEM_270 ] = "SYSTEM_270", + [ RTEMS_RECORD_SYSTEM_271 ] = "SYSTEM_271", + [ RTEMS_RECORD_SYSTEM_272 ] = "SYSTEM_272", + [ RTEMS_RECORD_SYSTEM_273 ] = "SYSTEM_273", + [ RTEMS_RECORD_SYSTEM_274 ] = "SYSTEM_274", + [ RTEMS_RECORD_SYSTEM_275 ] = "SYSTEM_275", + [ RTEMS_RECORD_SYSTEM_276 ] = "SYSTEM_276", + [ RTEMS_RECORD_SYSTEM_277 ] = "SYSTEM_277", + [ RTEMS_RECORD_SYSTEM_278 ] = "SYSTEM_278", + [ RTEMS_RECORD_SYSTEM_279 ] = "SYSTEM_279", + [ RTEMS_RECORD_SYSTEM_280 ] = "SYSTEM_280", + [ RTEMS_RECORD_SYSTEM_281 ] = "SYSTEM_281", + [ RTEMS_RECORD_SYSTEM_282 ] = "SYSTEM_282", + [ RTEMS_RECORD_SYSTEM_283 ] = "SYSTEM_283", + [ RTEMS_RECORD_SYSTEM_284 ] = "SYSTEM_284", + [ RTEMS_RECORD_SYSTEM_285 ] = "SYSTEM_285", + [ RTEMS_RECORD_SYSTEM_286 ] = "SYSTEM_286", + [ RTEMS_RECORD_SYSTEM_287 ] = "SYSTEM_287", + [ RTEMS_RECORD_SYSTEM_288 ] = "SYSTEM_288", + [ RTEMS_RECORD_SYSTEM_289 ] = "SYSTEM_289", + [ RTEMS_RECORD_SYSTEM_290 ] = "SYSTEM_290", + [ RTEMS_RECORD_SYSTEM_291 ] = "SYSTEM_291", + [ RTEMS_RECORD_SYSTEM_292 ] = "SYSTEM_292", + [ RTEMS_RECORD_SYSTEM_293 ] = "SYSTEM_293", + [ RTEMS_RECORD_SYSTEM_294 ] = "SYSTEM_294", + [ RTEMS_RECORD_SYSTEM_295 ] = "SYSTEM_295", + [ RTEMS_RECORD_SYSTEM_296 ] = "SYSTEM_296", + [ RTEMS_RECORD_SYSTEM_297 ] = "SYSTEM_297", + [ RTEMS_RECORD_SYSTEM_298 ] = "SYSTEM_298", + [ RTEMS_RECORD_SYSTEM_299 ] = "SYSTEM_299", + [ RTEMS_RECORD_SYSTEM_300 ] = "SYSTEM_300", + [ RTEMS_RECORD_SYSTEM_301 ] = "SYSTEM_301", + [ RTEMS_RECORD_SYSTEM_302 ] = "SYSTEM_302", + [ RTEMS_RECORD_SYSTEM_303 ] = "SYSTEM_303", + [ RTEMS_RECORD_SYSTEM_304 ] = "SYSTEM_304", + [ RTEMS_RECORD_SYSTEM_305 ] = "SYSTEM_305", + [ RTEMS_RECORD_SYSTEM_306 ] = "SYSTEM_306", + [ RTEMS_RECORD_SYSTEM_307 ] = "SYSTEM_307", + [ RTEMS_RECORD_SYSTEM_308 ] = "SYSTEM_308", + [ RTEMS_RECORD_SYSTEM_309 ] = "SYSTEM_309", + [ RTEMS_RECORD_SYSTEM_310 ] = "SYSTEM_310", + [ RTEMS_RECORD_SYSTEM_311 ] = "SYSTEM_311", + [ RTEMS_RECORD_SYSTEM_312 ] = "SYSTEM_312", + [ RTEMS_RECORD_SYSTEM_313 ] = "SYSTEM_313", + [ RTEMS_RECORD_SYSTEM_314 ] = "SYSTEM_314", + [ RTEMS_RECORD_SYSTEM_315 ] = "SYSTEM_315", + [ RTEMS_RECORD_SYSTEM_316 ] = "SYSTEM_316", + [ RTEMS_RECORD_SYSTEM_317 ] = "SYSTEM_317", + [ RTEMS_RECORD_SYSTEM_318 ] = "SYSTEM_318", + [ RTEMS_RECORD_SYSTEM_319 ] = "SYSTEM_319", + [ RTEMS_RECORD_SYSTEM_320 ] = "SYSTEM_320", + [ RTEMS_RECORD_SYSTEM_321 ] = "SYSTEM_321", + [ RTEMS_RECORD_SYSTEM_322 ] = "SYSTEM_322", + [ RTEMS_RECORD_SYSTEM_323 ] = "SYSTEM_323", + [ RTEMS_RECORD_SYSTEM_324 ] = "SYSTEM_324", + [ RTEMS_RECORD_SYSTEM_325 ] = "SYSTEM_325", + [ RTEMS_RECORD_SYSTEM_326 ] = "SYSTEM_326", + [ RTEMS_RECORD_SYSTEM_327 ] = "SYSTEM_327", + [ RTEMS_RECORD_SYSTEM_328 ] = "SYSTEM_328", + [ RTEMS_RECORD_SYSTEM_329 ] = "SYSTEM_329", + [ RTEMS_RECORD_SYSTEM_330 ] = "SYSTEM_330", + [ RTEMS_RECORD_SYSTEM_331 ] = "SYSTEM_331", + [ RTEMS_RECORD_SYSTEM_332 ] = "SYSTEM_332", + [ RTEMS_RECORD_SYSTEM_333 ] = "SYSTEM_333", + [ RTEMS_RECORD_SYSTEM_334 ] = "SYSTEM_334", + [ RTEMS_RECORD_SYSTEM_335 ] = "SYSTEM_335", + [ RTEMS_RECORD_SYSTEM_336 ] = "SYSTEM_336", + [ RTEMS_RECORD_SYSTEM_337 ] = "SYSTEM_337", + [ RTEMS_RECORD_SYSTEM_338 ] = "SYSTEM_338", + [ RTEMS_RECORD_SYSTEM_339 ] = "SYSTEM_339", + [ RTEMS_RECORD_SYSTEM_340 ] = "SYSTEM_340", + [ RTEMS_RECORD_SYSTEM_341 ] = "SYSTEM_341", + [ RTEMS_RECORD_SYSTEM_342 ] = "SYSTEM_342", + [ RTEMS_RECORD_SYSTEM_343 ] = "SYSTEM_343", + [ RTEMS_RECORD_SYSTEM_344 ] = "SYSTEM_344", + [ RTEMS_RECORD_SYSTEM_345 ] = "SYSTEM_345", + [ RTEMS_RECORD_SYSTEM_346 ] = "SYSTEM_346", + [ RTEMS_RECORD_SYSTEM_347 ] = "SYSTEM_347", + [ RTEMS_RECORD_SYSTEM_348 ] = "SYSTEM_348", + [ RTEMS_RECORD_SYSTEM_349 ] = "SYSTEM_349", + [ RTEMS_RECORD_SYSTEM_350 ] = "SYSTEM_350", + [ RTEMS_RECORD_SYSTEM_351 ] = "SYSTEM_351", + [ RTEMS_RECORD_SYSTEM_352 ] = "SYSTEM_352", + [ RTEMS_RECORD_SYSTEM_353 ] = "SYSTEM_353", + [ RTEMS_RECORD_SYSTEM_354 ] = "SYSTEM_354", + [ RTEMS_RECORD_SYSTEM_355 ] = "SYSTEM_355", + [ RTEMS_RECORD_SYSTEM_356 ] = "SYSTEM_356", + [ RTEMS_RECORD_SYSTEM_357 ] = "SYSTEM_357", + [ RTEMS_RECORD_SYSTEM_358 ] = "SYSTEM_358", + [ RTEMS_RECORD_SYSTEM_359 ] = "SYSTEM_359", + [ RTEMS_RECORD_SYSTEM_360 ] = "SYSTEM_360", + [ RTEMS_RECORD_SYSTEM_361 ] = "SYSTEM_361", + [ RTEMS_RECORD_SYSTEM_362 ] = "SYSTEM_362", + [ RTEMS_RECORD_SYSTEM_363 ] = "SYSTEM_363", + [ RTEMS_RECORD_SYSTEM_364 ] = "SYSTEM_364", + [ RTEMS_RECORD_SYSTEM_365 ] = "SYSTEM_365", + [ RTEMS_RECORD_SYSTEM_366 ] = "SYSTEM_366", + [ RTEMS_RECORD_SYSTEM_367 ] = "SYSTEM_367", + [ RTEMS_RECORD_SYSTEM_368 ] = "SYSTEM_368", + [ RTEMS_RECORD_SYSTEM_369 ] = "SYSTEM_369", + [ RTEMS_RECORD_SYSTEM_370 ] = "SYSTEM_370", + [ RTEMS_RECORD_SYSTEM_371 ] = "SYSTEM_371", + [ RTEMS_RECORD_SYSTEM_372 ] = "SYSTEM_372", + [ RTEMS_RECORD_SYSTEM_373 ] = "SYSTEM_373", + [ RTEMS_RECORD_SYSTEM_374 ] = "SYSTEM_374", + [ RTEMS_RECORD_SYSTEM_375 ] = "SYSTEM_375", + [ RTEMS_RECORD_SYSTEM_376 ] = "SYSTEM_376", + [ RTEMS_RECORD_SYSTEM_377 ] = "SYSTEM_377", + [ RTEMS_RECORD_SYSTEM_378 ] = "SYSTEM_378", + [ RTEMS_RECORD_SYSTEM_379 ] = "SYSTEM_379", + [ RTEMS_RECORD_SYSTEM_380 ] = "SYSTEM_380", + [ RTEMS_RECORD_SYSTEM_381 ] = "SYSTEM_381", + [ RTEMS_RECORD_SYSTEM_382 ] = "SYSTEM_382", + [ RTEMS_RECORD_SYSTEM_383 ] = "SYSTEM_383", + [ RTEMS_RECORD_SYSTEM_384 ] = "SYSTEM_384", + [ RTEMS_RECORD_SYSTEM_385 ] = "SYSTEM_385", + [ RTEMS_RECORD_SYSTEM_386 ] = "SYSTEM_386", + [ RTEMS_RECORD_SYSTEM_387 ] = "SYSTEM_387", + [ RTEMS_RECORD_SYSTEM_388 ] = "SYSTEM_388", + [ RTEMS_RECORD_SYSTEM_389 ] = "SYSTEM_389", + [ RTEMS_RECORD_SYSTEM_390 ] = "SYSTEM_390", + [ RTEMS_RECORD_SYSTEM_391 ] = "SYSTEM_391", + [ RTEMS_RECORD_SYSTEM_392 ] = "SYSTEM_392", + [ RTEMS_RECORD_SYSTEM_393 ] = "SYSTEM_393", + [ RTEMS_RECORD_SYSTEM_394 ] = "SYSTEM_394", + [ RTEMS_RECORD_SYSTEM_395 ] = "SYSTEM_395", + [ RTEMS_RECORD_SYSTEM_396 ] = "SYSTEM_396", + [ RTEMS_RECORD_SYSTEM_397 ] = "SYSTEM_397", + [ RTEMS_RECORD_SYSTEM_398 ] = "SYSTEM_398", + [ RTEMS_RECORD_SYSTEM_399 ] = "SYSTEM_399", + [ RTEMS_RECORD_SYSTEM_400 ] = "SYSTEM_400", + [ RTEMS_RECORD_SYSTEM_401 ] = "SYSTEM_401", + [ RTEMS_RECORD_SYSTEM_402 ] = "SYSTEM_402", + [ RTEMS_RECORD_SYSTEM_403 ] = "SYSTEM_403", + [ RTEMS_RECORD_SYSTEM_404 ] = "SYSTEM_404", + [ RTEMS_RECORD_SYSTEM_405 ] = "SYSTEM_405", + [ RTEMS_RECORD_SYSTEM_406 ] = "SYSTEM_406", + [ RTEMS_RECORD_SYSTEM_407 ] = "SYSTEM_407", + [ RTEMS_RECORD_SYSTEM_408 ] = "SYSTEM_408", + [ RTEMS_RECORD_SYSTEM_409 ] = "SYSTEM_409", + [ RTEMS_RECORD_SYSTEM_410 ] = "SYSTEM_410", + [ RTEMS_RECORD_SYSTEM_411 ] = "SYSTEM_411", + [ RTEMS_RECORD_SYSTEM_412 ] = "SYSTEM_412", + [ RTEMS_RECORD_SYSTEM_413 ] = "SYSTEM_413", + [ RTEMS_RECORD_SYSTEM_414 ] = "SYSTEM_414", + [ RTEMS_RECORD_SYSTEM_415 ] = "SYSTEM_415", + [ RTEMS_RECORD_SYSTEM_416 ] = "SYSTEM_416", + [ RTEMS_RECORD_SYSTEM_417 ] = "SYSTEM_417", + [ RTEMS_RECORD_SYSTEM_418 ] = "SYSTEM_418", + [ RTEMS_RECORD_SYSTEM_419 ] = "SYSTEM_419", + [ RTEMS_RECORD_SYSTEM_420 ] = "SYSTEM_420", + [ RTEMS_RECORD_SYSTEM_421 ] = "SYSTEM_421", + [ RTEMS_RECORD_SYSTEM_422 ] = "SYSTEM_422", + [ RTEMS_RECORD_SYSTEM_423 ] = "SYSTEM_423", + [ RTEMS_RECORD_SYSTEM_424 ] = "SYSTEM_424", + [ RTEMS_RECORD_SYSTEM_425 ] = "SYSTEM_425", + [ RTEMS_RECORD_SYSTEM_426 ] = "SYSTEM_426", + [ RTEMS_RECORD_SYSTEM_427 ] = "SYSTEM_427", + [ RTEMS_RECORD_SYSTEM_428 ] = "SYSTEM_428", + [ RTEMS_RECORD_SYSTEM_429 ] = "SYSTEM_429", + [ RTEMS_RECORD_SYSTEM_430 ] = "SYSTEM_430", + [ RTEMS_RECORD_SYSTEM_431 ] = "SYSTEM_431", + [ RTEMS_RECORD_SYSTEM_432 ] = "SYSTEM_432", + [ RTEMS_RECORD_SYSTEM_433 ] = "SYSTEM_433", + [ RTEMS_RECORD_SYSTEM_434 ] = "SYSTEM_434", + [ RTEMS_RECORD_SYSTEM_435 ] = "SYSTEM_435", + [ RTEMS_RECORD_SYSTEM_436 ] = "SYSTEM_436", + [ RTEMS_RECORD_SYSTEM_437 ] = "SYSTEM_437", + [ RTEMS_RECORD_SYSTEM_438 ] = "SYSTEM_438", + [ RTEMS_RECORD_SYSTEM_439 ] = "SYSTEM_439", + [ RTEMS_RECORD_SYSTEM_440 ] = "SYSTEM_440", + [ RTEMS_RECORD_SYSTEM_441 ] = "SYSTEM_441", + [ RTEMS_RECORD_SYSTEM_442 ] = "SYSTEM_442", + [ RTEMS_RECORD_SYSTEM_443 ] = "SYSTEM_443", + [ RTEMS_RECORD_SYSTEM_444 ] = "SYSTEM_444", + [ RTEMS_RECORD_SYSTEM_445 ] = "SYSTEM_445", + [ RTEMS_RECORD_SYSTEM_446 ] = "SYSTEM_446", + [ RTEMS_RECORD_SYSTEM_447 ] = "SYSTEM_447", + [ RTEMS_RECORD_SYSTEM_448 ] = "SYSTEM_448", + [ RTEMS_RECORD_SYSTEM_449 ] = "SYSTEM_449", + [ RTEMS_RECORD_SYSTEM_450 ] = "SYSTEM_450", + [ RTEMS_RECORD_SYSTEM_451 ] = "SYSTEM_451", + [ RTEMS_RECORD_SYSTEM_452 ] = "SYSTEM_452", + [ RTEMS_RECORD_SYSTEM_453 ] = "SYSTEM_453", + [ RTEMS_RECORD_SYSTEM_454 ] = "SYSTEM_454", + [ RTEMS_RECORD_SYSTEM_455 ] = "SYSTEM_455", + [ RTEMS_RECORD_SYSTEM_456 ] = "SYSTEM_456", + [ RTEMS_RECORD_SYSTEM_457 ] = "SYSTEM_457", + [ RTEMS_RECORD_SYSTEM_458 ] = "SYSTEM_458", + [ RTEMS_RECORD_SYSTEM_459 ] = "SYSTEM_459", + [ RTEMS_RECORD_SYSTEM_460 ] = "SYSTEM_460", + [ RTEMS_RECORD_SYSTEM_461 ] = "SYSTEM_461", + [ RTEMS_RECORD_SYSTEM_462 ] = "SYSTEM_462", + [ RTEMS_RECORD_SYSTEM_463 ] = "SYSTEM_463", + [ RTEMS_RECORD_SYSTEM_464 ] = "SYSTEM_464", + [ RTEMS_RECORD_SYSTEM_465 ] = "SYSTEM_465", + [ RTEMS_RECORD_SYSTEM_466 ] = "SYSTEM_466", + [ RTEMS_RECORD_SYSTEM_467 ] = "SYSTEM_467", + [ RTEMS_RECORD_SYSTEM_468 ] = "SYSTEM_468", + [ RTEMS_RECORD_SYSTEM_469 ] = "SYSTEM_469", + [ RTEMS_RECORD_SYSTEM_470 ] = "SYSTEM_470", + [ RTEMS_RECORD_SYSTEM_471 ] = "SYSTEM_471", + [ RTEMS_RECORD_SYSTEM_472 ] = "SYSTEM_472", + [ RTEMS_RECORD_SYSTEM_473 ] = "SYSTEM_473", + [ RTEMS_RECORD_SYSTEM_474 ] = "SYSTEM_474", + [ RTEMS_RECORD_SYSTEM_475 ] = "SYSTEM_475", + [ RTEMS_RECORD_SYSTEM_476 ] = "SYSTEM_476", + [ RTEMS_RECORD_SYSTEM_477 ] = "SYSTEM_477", + [ RTEMS_RECORD_SYSTEM_478 ] = "SYSTEM_478", + [ RTEMS_RECORD_SYSTEM_479 ] = "SYSTEM_479", + [ RTEMS_RECORD_SYSTEM_480 ] = "SYSTEM_480", + [ RTEMS_RECORD_SYSTEM_481 ] = "SYSTEM_481", + [ RTEMS_RECORD_SYSTEM_482 ] = "SYSTEM_482", + [ RTEMS_RECORD_SYSTEM_483 ] = "SYSTEM_483", + [ RTEMS_RECORD_SYSTEM_484 ] = "SYSTEM_484", + [ RTEMS_RECORD_SYSTEM_485 ] = "SYSTEM_485", + [ RTEMS_RECORD_SYSTEM_486 ] = "SYSTEM_486", + [ RTEMS_RECORD_SYSTEM_487 ] = "SYSTEM_487", + [ RTEMS_RECORD_SYSTEM_488 ] = "SYSTEM_488", + [ RTEMS_RECORD_SYSTEM_489 ] = "SYSTEM_489", + [ RTEMS_RECORD_SYSTEM_490 ] = "SYSTEM_490", + [ RTEMS_RECORD_SYSTEM_491 ] = "SYSTEM_491", + [ RTEMS_RECORD_SYSTEM_492 ] = "SYSTEM_492", + [ RTEMS_RECORD_SYSTEM_493 ] = "SYSTEM_493", + [ RTEMS_RECORD_SYSTEM_494 ] = "SYSTEM_494", + [ RTEMS_RECORD_SYSTEM_495 ] = "SYSTEM_495", + [ RTEMS_RECORD_SYSTEM_496 ] = "SYSTEM_496", + [ RTEMS_RECORD_SYSTEM_497 ] = "SYSTEM_497", + [ RTEMS_RECORD_SYSTEM_498 ] = "SYSTEM_498", + [ RTEMS_RECORD_SYSTEM_499 ] = "SYSTEM_499", + [ RTEMS_RECORD_SYSTEM_500 ] = "SYSTEM_500", + [ RTEMS_RECORD_SYSTEM_501 ] = "SYSTEM_501", + [ RTEMS_RECORD_SYSTEM_502 ] = "SYSTEM_502", + [ RTEMS_RECORD_SYSTEM_503 ] = "SYSTEM_503", + [ RTEMS_RECORD_SYSTEM_504 ] = "SYSTEM_504", + [ RTEMS_RECORD_SYSTEM_505 ] = "SYSTEM_505", + [ RTEMS_RECORD_SYSTEM_506 ] = "SYSTEM_506", + [ RTEMS_RECORD_SYSTEM_507 ] = "SYSTEM_507", + [ RTEMS_RECORD_SYSTEM_508 ] = "SYSTEM_508", + [ RTEMS_RECORD_SYSTEM_509 ] = "SYSTEM_509", + [ RTEMS_RECORD_SYSTEM_510 ] = "SYSTEM_510", + [ RTEMS_RECORD_USER_0 ] = "USER_0", + [ RTEMS_RECORD_USER_1 ] = "USER_1", + [ RTEMS_RECORD_USER_2 ] = "USER_2", + [ RTEMS_RECORD_USER_3 ] = "USER_3", + [ RTEMS_RECORD_USER_4 ] = "USER_4", + [ RTEMS_RECORD_USER_5 ] = "USER_5", + [ RTEMS_RECORD_USER_6 ] = "USER_6", + [ RTEMS_RECORD_USER_7 ] = "USER_7", + [ RTEMS_RECORD_USER_8 ] = "USER_8", + [ RTEMS_RECORD_USER_9 ] = "USER_9", + [ RTEMS_RECORD_USER_10 ] = "USER_10", + [ RTEMS_RECORD_USER_11 ] = "USER_11", + [ RTEMS_RECORD_USER_12 ] = "USER_12", + [ RTEMS_RECORD_USER_13 ] = "USER_13", + [ RTEMS_RECORD_USER_14 ] = "USER_14", + [ RTEMS_RECORD_USER_15 ] = "USER_15", + [ RTEMS_RECORD_USER_16 ] = "USER_16", + [ RTEMS_RECORD_USER_17 ] = "USER_17", + [ RTEMS_RECORD_USER_18 ] = "USER_18", + [ RTEMS_RECORD_USER_19 ] = "USER_19", + [ RTEMS_RECORD_USER_20 ] = "USER_20", + [ RTEMS_RECORD_USER_21 ] = "USER_21", + [ RTEMS_RECORD_USER_22 ] = "USER_22", + [ RTEMS_RECORD_USER_23 ] = "USER_23", + [ RTEMS_RECORD_USER_24 ] = "USER_24", + [ RTEMS_RECORD_USER_25 ] = "USER_25", + [ RTEMS_RECORD_USER_26 ] = "USER_26", + [ RTEMS_RECORD_USER_27 ] = "USER_27", + [ RTEMS_RECORD_USER_28 ] = "USER_28", + [ RTEMS_RECORD_USER_29 ] = "USER_29", + [ RTEMS_RECORD_USER_30 ] = "USER_30", + [ RTEMS_RECORD_USER_31 ] = "USER_31", + [ RTEMS_RECORD_USER_32 ] = "USER_32", + [ RTEMS_RECORD_USER_33 ] = "USER_33", + [ RTEMS_RECORD_USER_34 ] = "USER_34", + [ RTEMS_RECORD_USER_35 ] = "USER_35", + [ RTEMS_RECORD_USER_36 ] = "USER_36", + [ RTEMS_RECORD_USER_37 ] = "USER_37", + [ RTEMS_RECORD_USER_38 ] = "USER_38", + [ RTEMS_RECORD_USER_39 ] = "USER_39", + [ RTEMS_RECORD_USER_40 ] = "USER_40", + [ RTEMS_RECORD_USER_41 ] = "USER_41", + [ RTEMS_RECORD_USER_42 ] = "USER_42", + [ RTEMS_RECORD_USER_43 ] = "USER_43", + [ RTEMS_RECORD_USER_44 ] = "USER_44", + [ RTEMS_RECORD_USER_45 ] = "USER_45", + [ RTEMS_RECORD_USER_46 ] = "USER_46", + [ RTEMS_RECORD_USER_47 ] = "USER_47", + [ RTEMS_RECORD_USER_48 ] = "USER_48", + [ RTEMS_RECORD_USER_49 ] = "USER_49", + [ RTEMS_RECORD_USER_50 ] = "USER_50", + [ RTEMS_RECORD_USER_51 ] = "USER_51", + [ RTEMS_RECORD_USER_52 ] = "USER_52", + [ RTEMS_RECORD_USER_53 ] = "USER_53", + [ RTEMS_RECORD_USER_54 ] = "USER_54", + [ RTEMS_RECORD_USER_55 ] = "USER_55", + [ RTEMS_RECORD_USER_56 ] = "USER_56", + [ RTEMS_RECORD_USER_57 ] = "USER_57", + [ RTEMS_RECORD_USER_58 ] = "USER_58", + [ RTEMS_RECORD_USER_59 ] = "USER_59", + [ RTEMS_RECORD_USER_60 ] = "USER_60", + [ RTEMS_RECORD_USER_61 ] = "USER_61", + [ RTEMS_RECORD_USER_62 ] = "USER_62", + [ RTEMS_RECORD_USER_63 ] = "USER_63", + [ RTEMS_RECORD_USER_64 ] = "USER_64", + [ RTEMS_RECORD_USER_65 ] = "USER_65", + [ RTEMS_RECORD_USER_66 ] = "USER_66", + [ RTEMS_RECORD_USER_67 ] = "USER_67", + [ RTEMS_RECORD_USER_68 ] = "USER_68", + [ RTEMS_RECORD_USER_69 ] = "USER_69", + [ RTEMS_RECORD_USER_70 ] = "USER_70", + [ RTEMS_RECORD_USER_71 ] = "USER_71", + [ RTEMS_RECORD_USER_72 ] = "USER_72", + [ RTEMS_RECORD_USER_73 ] = "USER_73", + [ RTEMS_RECORD_USER_74 ] = "USER_74", + [ RTEMS_RECORD_USER_75 ] = "USER_75", + [ RTEMS_RECORD_USER_76 ] = "USER_76", + [ RTEMS_RECORD_USER_77 ] = "USER_77", + [ RTEMS_RECORD_USER_78 ] = "USER_78", + [ RTEMS_RECORD_USER_79 ] = "USER_79", + [ RTEMS_RECORD_USER_80 ] = "USER_80", + [ RTEMS_RECORD_USER_81 ] = "USER_81", + [ RTEMS_RECORD_USER_82 ] = "USER_82", + [ RTEMS_RECORD_USER_83 ] = "USER_83", + [ RTEMS_RECORD_USER_84 ] = "USER_84", + [ RTEMS_RECORD_USER_85 ] = "USER_85", + [ RTEMS_RECORD_USER_86 ] = "USER_86", + [ RTEMS_RECORD_USER_87 ] = "USER_87", + [ RTEMS_RECORD_USER_88 ] = "USER_88", + [ RTEMS_RECORD_USER_89 ] = "USER_89", + [ RTEMS_RECORD_USER_90 ] = "USER_90", + [ RTEMS_RECORD_USER_91 ] = "USER_91", + [ RTEMS_RECORD_USER_92 ] = "USER_92", + [ RTEMS_RECORD_USER_93 ] = "USER_93", + [ RTEMS_RECORD_USER_94 ] = "USER_94", + [ RTEMS_RECORD_USER_95 ] = "USER_95", + [ RTEMS_RECORD_USER_96 ] = "USER_96", + [ RTEMS_RECORD_USER_97 ] = "USER_97", + [ RTEMS_RECORD_USER_98 ] = "USER_98", + [ RTEMS_RECORD_USER_99 ] = "USER_99", + [ RTEMS_RECORD_USER_100 ] = "USER_100", + [ RTEMS_RECORD_USER_101 ] = "USER_101", + [ RTEMS_RECORD_USER_102 ] = "USER_102", + [ RTEMS_RECORD_USER_103 ] = "USER_103", + [ RTEMS_RECORD_USER_104 ] = "USER_104", + [ RTEMS_RECORD_USER_105 ] = "USER_105", + [ RTEMS_RECORD_USER_106 ] = "USER_106", + [ RTEMS_RECORD_USER_107 ] = "USER_107", + [ RTEMS_RECORD_USER_108 ] = "USER_108", + [ RTEMS_RECORD_USER_109 ] = "USER_109", + [ RTEMS_RECORD_USER_110 ] = "USER_110", + [ RTEMS_RECORD_USER_111 ] = "USER_111", + [ RTEMS_RECORD_USER_112 ] = "USER_112", + [ RTEMS_RECORD_USER_113 ] = "USER_113", + [ RTEMS_RECORD_USER_114 ] = "USER_114", + [ RTEMS_RECORD_USER_115 ] = "USER_115", + [ RTEMS_RECORD_USER_116 ] = "USER_116", + [ RTEMS_RECORD_USER_117 ] = "USER_117", + [ RTEMS_RECORD_USER_118 ] = "USER_118", + [ RTEMS_RECORD_USER_119 ] = "USER_119", + [ RTEMS_RECORD_USER_120 ] = "USER_120", + [ RTEMS_RECORD_USER_121 ] = "USER_121", + [ RTEMS_RECORD_USER_122 ] = "USER_122", + [ RTEMS_RECORD_USER_123 ] = "USER_123", + [ RTEMS_RECORD_USER_124 ] = "USER_124", + [ RTEMS_RECORD_USER_125 ] = "USER_125", + [ RTEMS_RECORD_USER_126 ] = "USER_126", + [ RTEMS_RECORD_USER_127 ] = "USER_127", + [ RTEMS_RECORD_USER_128 ] = "USER_128", + [ RTEMS_RECORD_USER_129 ] = "USER_129", + [ RTEMS_RECORD_USER_130 ] = "USER_130", + [ RTEMS_RECORD_USER_131 ] = "USER_131", + [ RTEMS_RECORD_USER_132 ] = "USER_132", + [ RTEMS_RECORD_USER_133 ] = "USER_133", + [ RTEMS_RECORD_USER_134 ] = "USER_134", + [ RTEMS_RECORD_USER_135 ] = "USER_135", + [ RTEMS_RECORD_USER_136 ] = "USER_136", + [ RTEMS_RECORD_USER_137 ] = "USER_137", + [ RTEMS_RECORD_USER_138 ] = "USER_138", + [ RTEMS_RECORD_USER_139 ] = "USER_139", + [ RTEMS_RECORD_USER_140 ] = "USER_140", + [ RTEMS_RECORD_USER_141 ] = "USER_141", + [ RTEMS_RECORD_USER_142 ] = "USER_142", + [ RTEMS_RECORD_USER_143 ] = "USER_143", + [ RTEMS_RECORD_USER_144 ] = "USER_144", + [ RTEMS_RECORD_USER_145 ] = "USER_145", + [ RTEMS_RECORD_USER_146 ] = "USER_146", + [ RTEMS_RECORD_USER_147 ] = "USER_147", + [ RTEMS_RECORD_USER_148 ] = "USER_148", + [ RTEMS_RECORD_USER_149 ] = "USER_149", + [ RTEMS_RECORD_USER_150 ] = "USER_150", + [ RTEMS_RECORD_USER_151 ] = "USER_151", + [ RTEMS_RECORD_USER_152 ] = "USER_152", + [ RTEMS_RECORD_USER_153 ] = "USER_153", + [ RTEMS_RECORD_USER_154 ] = "USER_154", + [ RTEMS_RECORD_USER_155 ] = "USER_155", + [ RTEMS_RECORD_USER_156 ] = "USER_156", + [ RTEMS_RECORD_USER_157 ] = "USER_157", + [ RTEMS_RECORD_USER_158 ] = "USER_158", + [ RTEMS_RECORD_USER_159 ] = "USER_159", + [ RTEMS_RECORD_USER_160 ] = "USER_160", + [ RTEMS_RECORD_USER_161 ] = "USER_161", + [ RTEMS_RECORD_USER_162 ] = "USER_162", + [ RTEMS_RECORD_USER_163 ] = "USER_163", + [ RTEMS_RECORD_USER_164 ] = "USER_164", + [ RTEMS_RECORD_USER_165 ] = "USER_165", + [ RTEMS_RECORD_USER_166 ] = "USER_166", + [ RTEMS_RECORD_USER_167 ] = "USER_167", + [ RTEMS_RECORD_USER_168 ] = "USER_168", + [ RTEMS_RECORD_USER_169 ] = "USER_169", + [ RTEMS_RECORD_USER_170 ] = "USER_170", + [ RTEMS_RECORD_USER_171 ] = "USER_171", + [ RTEMS_RECORD_USER_172 ] = "USER_172", + [ RTEMS_RECORD_USER_173 ] = "USER_173", + [ RTEMS_RECORD_USER_174 ] = "USER_174", + [ RTEMS_RECORD_USER_175 ] = "USER_175", + [ RTEMS_RECORD_USER_176 ] = "USER_176", + [ RTEMS_RECORD_USER_177 ] = "USER_177", + [ RTEMS_RECORD_USER_178 ] = "USER_178", + [ RTEMS_RECORD_USER_179 ] = "USER_179", + [ RTEMS_RECORD_USER_180 ] = "USER_180", + [ RTEMS_RECORD_USER_181 ] = "USER_181", + [ RTEMS_RECORD_USER_182 ] = "USER_182", + [ RTEMS_RECORD_USER_183 ] = "USER_183", + [ RTEMS_RECORD_USER_184 ] = "USER_184", + [ RTEMS_RECORD_USER_185 ] = "USER_185", + [ RTEMS_RECORD_USER_186 ] = "USER_186", + [ RTEMS_RECORD_USER_187 ] = "USER_187", + [ RTEMS_RECORD_USER_188 ] = "USER_188", + [ RTEMS_RECORD_USER_189 ] = "USER_189", + [ RTEMS_RECORD_USER_190 ] = "USER_190", + [ RTEMS_RECORD_USER_191 ] = "USER_191", + [ RTEMS_RECORD_USER_192 ] = "USER_192", + [ RTEMS_RECORD_USER_193 ] = "USER_193", + [ RTEMS_RECORD_USER_194 ] = "USER_194", + [ RTEMS_RECORD_USER_195 ] = "USER_195", + [ RTEMS_RECORD_USER_196 ] = "USER_196", + [ RTEMS_RECORD_USER_197 ] = "USER_197", + [ RTEMS_RECORD_USER_198 ] = "USER_198", + [ RTEMS_RECORD_USER_199 ] = "USER_199", + [ RTEMS_RECORD_USER_200 ] = "USER_200", + [ RTEMS_RECORD_USER_201 ] = "USER_201", + [ RTEMS_RECORD_USER_202 ] = "USER_202", + [ RTEMS_RECORD_USER_203 ] = "USER_203", + [ RTEMS_RECORD_USER_204 ] = "USER_204", + [ RTEMS_RECORD_USER_205 ] = "USER_205", + [ RTEMS_RECORD_USER_206 ] = "USER_206", + [ RTEMS_RECORD_USER_207 ] = "USER_207", + [ RTEMS_RECORD_USER_208 ] = "USER_208", + [ RTEMS_RECORD_USER_209 ] = "USER_209", + [ RTEMS_RECORD_USER_210 ] = "USER_210", + [ RTEMS_RECORD_USER_211 ] = "USER_211", + [ RTEMS_RECORD_USER_212 ] = "USER_212", + [ RTEMS_RECORD_USER_213 ] = "USER_213", + [ RTEMS_RECORD_USER_214 ] = "USER_214", + [ RTEMS_RECORD_USER_215 ] = "USER_215", + [ RTEMS_RECORD_USER_216 ] = "USER_216", + [ RTEMS_RECORD_USER_217 ] = "USER_217", + [ RTEMS_RECORD_USER_218 ] = "USER_218", + [ RTEMS_RECORD_USER_219 ] = "USER_219", + [ RTEMS_RECORD_USER_220 ] = "USER_220", + [ RTEMS_RECORD_USER_221 ] = "USER_221", + [ RTEMS_RECORD_USER_222 ] = "USER_222", + [ RTEMS_RECORD_USER_223 ] = "USER_223", + [ RTEMS_RECORD_USER_224 ] = "USER_224", + [ RTEMS_RECORD_USER_225 ] = "USER_225", + [ RTEMS_RECORD_USER_226 ] = "USER_226", + [ RTEMS_RECORD_USER_227 ] = "USER_227", + [ RTEMS_RECORD_USER_228 ] = "USER_228", + [ RTEMS_RECORD_USER_229 ] = "USER_229", + [ RTEMS_RECORD_USER_230 ] = "USER_230", + [ RTEMS_RECORD_USER_231 ] = "USER_231", + [ RTEMS_RECORD_USER_232 ] = "USER_232", + [ RTEMS_RECORD_USER_233 ] = "USER_233", + [ RTEMS_RECORD_USER_234 ] = "USER_234", + [ RTEMS_RECORD_USER_235 ] = "USER_235", + [ RTEMS_RECORD_USER_236 ] = "USER_236", + [ RTEMS_RECORD_USER_237 ] = "USER_237", + [ RTEMS_RECORD_USER_238 ] = "USER_238", + [ RTEMS_RECORD_USER_239 ] = "USER_239", + [ RTEMS_RECORD_USER_240 ] = "USER_240", + [ RTEMS_RECORD_USER_241 ] = "USER_241", + [ RTEMS_RECORD_USER_242 ] = "USER_242", + [ RTEMS_RECORD_USER_243 ] = "USER_243", + [ RTEMS_RECORD_USER_244 ] = "USER_244", + [ RTEMS_RECORD_USER_245 ] = "USER_245", + [ RTEMS_RECORD_USER_246 ] = "USER_246", + [ RTEMS_RECORD_USER_247 ] = "USER_247", + [ RTEMS_RECORD_USER_248 ] = "USER_248", + [ RTEMS_RECORD_USER_249 ] = "USER_249", + [ RTEMS_RECORD_USER_250 ] = "USER_250", + [ RTEMS_RECORD_USER_251 ] = "USER_251", + [ RTEMS_RECORD_USER_252 ] = "USER_252", + [ RTEMS_RECORD_USER_253 ] = "USER_253", + [ RTEMS_RECORD_USER_254 ] = "USER_254", + [ RTEMS_RECORD_USER_255 ] = "USER_255", + [ RTEMS_RECORD_USER_256 ] = "USER_256", + [ RTEMS_RECORD_USER_257 ] = "USER_257", + [ RTEMS_RECORD_USER_258 ] = "USER_258", + [ RTEMS_RECORD_USER_259 ] = "USER_259", + [ RTEMS_RECORD_USER_260 ] = "USER_260", + [ RTEMS_RECORD_USER_261 ] = "USER_261", + [ RTEMS_RECORD_USER_262 ] = "USER_262", + [ RTEMS_RECORD_USER_263 ] = "USER_263", + [ RTEMS_RECORD_USER_264 ] = "USER_264", + [ RTEMS_RECORD_USER_265 ] = "USER_265", + [ RTEMS_RECORD_USER_266 ] = "USER_266", + [ RTEMS_RECORD_USER_267 ] = "USER_267", + [ RTEMS_RECORD_USER_268 ] = "USER_268", + [ RTEMS_RECORD_USER_269 ] = "USER_269", + [ RTEMS_RECORD_USER_270 ] = "USER_270", + [ RTEMS_RECORD_USER_271 ] = "USER_271", + [ RTEMS_RECORD_USER_272 ] = "USER_272", + [ RTEMS_RECORD_USER_273 ] = "USER_273", + [ RTEMS_RECORD_USER_274 ] = "USER_274", + [ RTEMS_RECORD_USER_275 ] = "USER_275", + [ RTEMS_RECORD_USER_276 ] = "USER_276", + [ RTEMS_RECORD_USER_277 ] = "USER_277", + [ RTEMS_RECORD_USER_278 ] = "USER_278", + [ RTEMS_RECORD_USER_279 ] = "USER_279", + [ RTEMS_RECORD_USER_280 ] = "USER_280", + [ RTEMS_RECORD_USER_281 ] = "USER_281", + [ RTEMS_RECORD_USER_282 ] = "USER_282", + [ RTEMS_RECORD_USER_283 ] = "USER_283", + [ RTEMS_RECORD_USER_284 ] = "USER_284", + [ RTEMS_RECORD_USER_285 ] = "USER_285", + [ RTEMS_RECORD_USER_286 ] = "USER_286", + [ RTEMS_RECORD_USER_287 ] = "USER_287", + [ RTEMS_RECORD_USER_288 ] = "USER_288", + [ RTEMS_RECORD_USER_289 ] = "USER_289", + [ RTEMS_RECORD_USER_290 ] = "USER_290", + [ RTEMS_RECORD_USER_291 ] = "USER_291", + [ RTEMS_RECORD_USER_292 ] = "USER_292", + [ RTEMS_RECORD_USER_293 ] = "USER_293", + [ RTEMS_RECORD_USER_294 ] = "USER_294", + [ RTEMS_RECORD_USER_295 ] = "USER_295", + [ RTEMS_RECORD_USER_296 ] = "USER_296", + [ RTEMS_RECORD_USER_297 ] = "USER_297", + [ RTEMS_RECORD_USER_298 ] = "USER_298", + [ RTEMS_RECORD_USER_299 ] = "USER_299", + [ RTEMS_RECORD_USER_300 ] = "USER_300", + [ RTEMS_RECORD_USER_301 ] = "USER_301", + [ RTEMS_RECORD_USER_302 ] = "USER_302", + [ RTEMS_RECORD_USER_303 ] = "USER_303", + [ RTEMS_RECORD_USER_304 ] = "USER_304", + [ RTEMS_RECORD_USER_305 ] = "USER_305", + [ RTEMS_RECORD_USER_306 ] = "USER_306", + [ RTEMS_RECORD_USER_307 ] = "USER_307", + [ RTEMS_RECORD_USER_308 ] = "USER_308", + [ RTEMS_RECORD_USER_309 ] = "USER_309", + [ RTEMS_RECORD_USER_310 ] = "USER_310", + [ RTEMS_RECORD_USER_311 ] = "USER_311", + [ RTEMS_RECORD_USER_312 ] = "USER_312", + [ RTEMS_RECORD_USER_313 ] = "USER_313", + [ RTEMS_RECORD_USER_314 ] = "USER_314", + [ RTEMS_RECORD_USER_315 ] = "USER_315", + [ RTEMS_RECORD_USER_316 ] = "USER_316", + [ RTEMS_RECORD_USER_317 ] = "USER_317", + [ RTEMS_RECORD_USER_318 ] = "USER_318", + [ RTEMS_RECORD_USER_319 ] = "USER_319", + [ RTEMS_RECORD_USER_320 ] = "USER_320", + [ RTEMS_RECORD_USER_321 ] = "USER_321", + [ RTEMS_RECORD_USER_322 ] = "USER_322", + [ RTEMS_RECORD_USER_323 ] = "USER_323", + [ RTEMS_RECORD_USER_324 ] = "USER_324", + [ RTEMS_RECORD_USER_325 ] = "USER_325", + [ RTEMS_RECORD_USER_326 ] = "USER_326", + [ RTEMS_RECORD_USER_327 ] = "USER_327", + [ RTEMS_RECORD_USER_328 ] = "USER_328", + [ RTEMS_RECORD_USER_329 ] = "USER_329", + [ RTEMS_RECORD_USER_330 ] = "USER_330", + [ RTEMS_RECORD_USER_331 ] = "USER_331", + [ RTEMS_RECORD_USER_332 ] = "USER_332", + [ RTEMS_RECORD_USER_333 ] = "USER_333", + [ RTEMS_RECORD_USER_334 ] = "USER_334", + [ RTEMS_RECORD_USER_335 ] = "USER_335", + [ RTEMS_RECORD_USER_336 ] = "USER_336", + [ RTEMS_RECORD_USER_337 ] = "USER_337", + [ RTEMS_RECORD_USER_338 ] = "USER_338", + [ RTEMS_RECORD_USER_339 ] = "USER_339", + [ RTEMS_RECORD_USER_340 ] = "USER_340", + [ RTEMS_RECORD_USER_341 ] = "USER_341", + [ RTEMS_RECORD_USER_342 ] = "USER_342", + [ RTEMS_RECORD_USER_343 ] = "USER_343", + [ RTEMS_RECORD_USER_344 ] = "USER_344", + [ RTEMS_RECORD_USER_345 ] = "USER_345", + [ RTEMS_RECORD_USER_346 ] = "USER_346", + [ RTEMS_RECORD_USER_347 ] = "USER_347", + [ RTEMS_RECORD_USER_348 ] = "USER_348", + [ RTEMS_RECORD_USER_349 ] = "USER_349", + [ RTEMS_RECORD_USER_350 ] = "USER_350", + [ RTEMS_RECORD_USER_351 ] = "USER_351", + [ RTEMS_RECORD_USER_352 ] = "USER_352", + [ RTEMS_RECORD_USER_353 ] = "USER_353", + [ RTEMS_RECORD_USER_354 ] = "USER_354", + [ RTEMS_RECORD_USER_355 ] = "USER_355", + [ RTEMS_RECORD_USER_356 ] = "USER_356", + [ RTEMS_RECORD_USER_357 ] = "USER_357", + [ RTEMS_RECORD_USER_358 ] = "USER_358", + [ RTEMS_RECORD_USER_359 ] = "USER_359", + [ RTEMS_RECORD_USER_360 ] = "USER_360", + [ RTEMS_RECORD_USER_361 ] = "USER_361", + [ RTEMS_RECORD_USER_362 ] = "USER_362", + [ RTEMS_RECORD_USER_363 ] = "USER_363", + [ RTEMS_RECORD_USER_364 ] = "USER_364", + [ RTEMS_RECORD_USER_365 ] = "USER_365", + [ RTEMS_RECORD_USER_366 ] = "USER_366", + [ RTEMS_RECORD_USER_367 ] = "USER_367", + [ RTEMS_RECORD_USER_368 ] = "USER_368", + [ RTEMS_RECORD_USER_369 ] = "USER_369", + [ RTEMS_RECORD_USER_370 ] = "USER_370", + [ RTEMS_RECORD_USER_371 ] = "USER_371", + [ RTEMS_RECORD_USER_372 ] = "USER_372", + [ RTEMS_RECORD_USER_373 ] = "USER_373", + [ RTEMS_RECORD_USER_374 ] = "USER_374", + [ RTEMS_RECORD_USER_375 ] = "USER_375", + [ RTEMS_RECORD_USER_376 ] = "USER_376", + [ RTEMS_RECORD_USER_377 ] = "USER_377", + [ RTEMS_RECORD_USER_378 ] = "USER_378", + [ RTEMS_RECORD_USER_379 ] = "USER_379", + [ RTEMS_RECORD_USER_380 ] = "USER_380", + [ RTEMS_RECORD_USER_381 ] = "USER_381", + [ RTEMS_RECORD_USER_382 ] = "USER_382", + [ RTEMS_RECORD_USER_383 ] = "USER_383", + [ RTEMS_RECORD_USER_384 ] = "USER_384", + [ RTEMS_RECORD_USER_385 ] = "USER_385", + [ RTEMS_RECORD_USER_386 ] = "USER_386", + [ RTEMS_RECORD_USER_387 ] = "USER_387", + [ RTEMS_RECORD_USER_388 ] = "USER_388", + [ RTEMS_RECORD_USER_389 ] = "USER_389", + [ RTEMS_RECORD_USER_390 ] = "USER_390", + [ RTEMS_RECORD_USER_391 ] = "USER_391", + [ RTEMS_RECORD_USER_392 ] = "USER_392", + [ RTEMS_RECORD_USER_393 ] = "USER_393", + [ RTEMS_RECORD_USER_394 ] = "USER_394", + [ RTEMS_RECORD_USER_395 ] = "USER_395", + [ RTEMS_RECORD_USER_396 ] = "USER_396", + [ RTEMS_RECORD_USER_397 ] = "USER_397", + [ RTEMS_RECORD_USER_398 ] = "USER_398", + [ RTEMS_RECORD_USER_399 ] = "USER_399", + [ RTEMS_RECORD_USER_400 ] = "USER_400", + [ RTEMS_RECORD_USER_401 ] = "USER_401", + [ RTEMS_RECORD_USER_402 ] = "USER_402", + [ RTEMS_RECORD_USER_403 ] = "USER_403", + [ RTEMS_RECORD_USER_404 ] = "USER_404", + [ RTEMS_RECORD_USER_405 ] = "USER_405", + [ RTEMS_RECORD_USER_406 ] = "USER_406", + [ RTEMS_RECORD_USER_407 ] = "USER_407", + [ RTEMS_RECORD_USER_408 ] = "USER_408", + [ RTEMS_RECORD_USER_409 ] = "USER_409", + [ RTEMS_RECORD_USER_410 ] = "USER_410", + [ RTEMS_RECORD_USER_411 ] = "USER_411", + [ RTEMS_RECORD_USER_412 ] = "USER_412", + [ RTEMS_RECORD_USER_413 ] = "USER_413", + [ RTEMS_RECORD_USER_414 ] = "USER_414", + [ RTEMS_RECORD_USER_415 ] = "USER_415", + [ RTEMS_RECORD_USER_416 ] = "USER_416", + [ RTEMS_RECORD_USER_417 ] = "USER_417", + [ RTEMS_RECORD_USER_418 ] = "USER_418", + [ RTEMS_RECORD_USER_419 ] = "USER_419", + [ RTEMS_RECORD_USER_420 ] = "USER_420", + [ RTEMS_RECORD_USER_421 ] = "USER_421", + [ RTEMS_RECORD_USER_422 ] = "USER_422", + [ RTEMS_RECORD_USER_423 ] = "USER_423", + [ RTEMS_RECORD_USER_424 ] = "USER_424", + [ RTEMS_RECORD_USER_425 ] = "USER_425", + [ RTEMS_RECORD_USER_426 ] = "USER_426", + [ RTEMS_RECORD_USER_427 ] = "USER_427", + [ RTEMS_RECORD_USER_428 ] = "USER_428", + [ RTEMS_RECORD_USER_429 ] = "USER_429", + [ RTEMS_RECORD_USER_430 ] = "USER_430", + [ RTEMS_RECORD_USER_431 ] = "USER_431", + [ RTEMS_RECORD_USER_432 ] = "USER_432", + [ RTEMS_RECORD_USER_433 ] = "USER_433", + [ RTEMS_RECORD_USER_434 ] = "USER_434", + [ RTEMS_RECORD_USER_435 ] = "USER_435", + [ RTEMS_RECORD_USER_436 ] = "USER_436", + [ RTEMS_RECORD_USER_437 ] = "USER_437", + [ RTEMS_RECORD_USER_438 ] = "USER_438", + [ RTEMS_RECORD_USER_439 ] = "USER_439", + [ RTEMS_RECORD_USER_440 ] = "USER_440", + [ RTEMS_RECORD_USER_441 ] = "USER_441", + [ RTEMS_RECORD_USER_442 ] = "USER_442", + [ RTEMS_RECORD_USER_443 ] = "USER_443", + [ RTEMS_RECORD_USER_444 ] = "USER_444", + [ RTEMS_RECORD_USER_445 ] = "USER_445", + [ RTEMS_RECORD_USER_446 ] = "USER_446", + [ RTEMS_RECORD_USER_447 ] = "USER_447", + [ RTEMS_RECORD_USER_448 ] = "USER_448", + [ RTEMS_RECORD_USER_449 ] = "USER_449", + [ RTEMS_RECORD_USER_450 ] = "USER_450", + [ RTEMS_RECORD_USER_451 ] = "USER_451", + [ RTEMS_RECORD_USER_452 ] = "USER_452", + [ RTEMS_RECORD_USER_453 ] = "USER_453", + [ RTEMS_RECORD_USER_454 ] = "USER_454", + [ RTEMS_RECORD_USER_455 ] = "USER_455", + [ RTEMS_RECORD_USER_456 ] = "USER_456", + [ RTEMS_RECORD_USER_457 ] = "USER_457", + [ RTEMS_RECORD_USER_458 ] = "USER_458", + [ RTEMS_RECORD_USER_459 ] = "USER_459", + [ RTEMS_RECORD_USER_460 ] = "USER_460", + [ RTEMS_RECORD_USER_461 ] = "USER_461", + [ RTEMS_RECORD_USER_462 ] = "USER_462", + [ RTEMS_RECORD_USER_463 ] = "USER_463", + [ RTEMS_RECORD_USER_464 ] = "USER_464", + [ RTEMS_RECORD_USER_465 ] = "USER_465", + [ RTEMS_RECORD_USER_466 ] = "USER_466", + [ RTEMS_RECORD_USER_467 ] = "USER_467", + [ RTEMS_RECORD_USER_468 ] = "USER_468", + [ RTEMS_RECORD_USER_469 ] = "USER_469", + [ RTEMS_RECORD_USER_470 ] = "USER_470", + [ RTEMS_RECORD_USER_471 ] = "USER_471", + [ RTEMS_RECORD_USER_472 ] = "USER_472", + [ RTEMS_RECORD_USER_473 ] = "USER_473", + [ RTEMS_RECORD_USER_474 ] = "USER_474", + [ RTEMS_RECORD_USER_475 ] = "USER_475", + [ RTEMS_RECORD_USER_476 ] = "USER_476", + [ RTEMS_RECORD_USER_477 ] = "USER_477", + [ RTEMS_RECORD_USER_478 ] = "USER_478", + [ RTEMS_RECORD_USER_479 ] = "USER_479", + [ RTEMS_RECORD_USER_480 ] = "USER_480", + [ RTEMS_RECORD_USER_481 ] = "USER_481", + [ RTEMS_RECORD_USER_482 ] = "USER_482", + [ RTEMS_RECORD_USER_483 ] = "USER_483", + [ RTEMS_RECORD_USER_484 ] = "USER_484", + [ RTEMS_RECORD_USER_485 ] = "USER_485", + [ RTEMS_RECORD_USER_486 ] = "USER_486", + [ RTEMS_RECORD_USER_487 ] = "USER_487", + [ RTEMS_RECORD_USER_488 ] = "USER_488", + [ RTEMS_RECORD_USER_489 ] = "USER_489", + [ RTEMS_RECORD_USER_490 ] = "USER_490", + [ RTEMS_RECORD_USER_491 ] = "USER_491", + [ RTEMS_RECORD_USER_492 ] = "USER_492", + [ RTEMS_RECORD_USER_493 ] = "USER_493", + [ RTEMS_RECORD_USER_494 ] = "USER_494", + [ RTEMS_RECORD_USER_495 ] = "USER_495", + [ RTEMS_RECORD_USER_496 ] = "USER_496", + [ RTEMS_RECORD_USER_497 ] = "USER_497", + [ RTEMS_RECORD_USER_498 ] = "USER_498", + [ RTEMS_RECORD_USER_499 ] = "USER_499", + [ RTEMS_RECORD_USER_500 ] = "USER_500", + [ RTEMS_RECORD_USER_501 ] = "USER_501", + [ RTEMS_RECORD_USER_502 ] = "USER_502", + [ RTEMS_RECORD_USER_503 ] = "USER_503", + [ RTEMS_RECORD_USER_504 ] = "USER_504", + [ RTEMS_RECORD_USER_505 ] = "USER_505", + [ RTEMS_RECORD_USER_506 ] = "USER_506", + [ RTEMS_RECORD_USER_507 ] = "USER_507", + [ RTEMS_RECORD_USER_508 ] = "USER_508", + [ RTEMS_RECORD_USER_509 ] = "USER_509", + [ RTEMS_RECORD_USER_510 ] = "USER_510", + [ RTEMS_RECORD_USER_511 ] = "USER_511" +}; + +const char *rtems_record_event_text( rtems_record_event event ) +{ + return event_text[ event ]; +} diff --git a/trace/record/rtems/recordclient.h b/trace/record/rtems/recordclient.h new file mode 100644 index 0000000..2509ba5 --- /dev/null +++ b/trace/record/rtems/recordclient.h @@ -0,0 +1,239 @@ +/* + * SPDX-License-Identifier: BSD-2-Clause + * + * Copyright (C) 2018, 2019 embedded brains GmbH + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" + * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE + * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR + * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF + * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS + * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN + * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) + * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE + * POSSIBILITY OF SUCH DAMAGE. + */ + +/* + * This file must be compatible to general purpose POSIX system, e.g. Linux, + * FreeBSD. It may be used for utility programs. + */ + +#ifndef _RTEMS_RECORDCLIENT_H +#define _RTEMS_RECORDCLIENT_H + +#include "recorddata.h" + +#include +#include + +#ifdef __cplusplus +extern "C" { +#endif /* __cplusplus */ + +/** + * @addtogroup RTEMSRecord + * + * @{ + */ + +#define RTEMS_RECORD_CLIENT_MAXIMUM_CPU_COUNT 32 + +typedef enum { + RTEMS_RECORD_CLIENT_SUCCESS, + RTEMS_RECORD_CLIENT_ERROR_INVALID_MAGIC, + RTEMS_RECORD_CLIENT_ERROR_UNKNOWN_FORMAT, + RTEMS_RECORD_CLIENT_ERROR_UNSUPPORTED_VERSION, + RTEMS_RECORD_CLIENT_ERROR_UNSUPPORTED_CPU, + RTEMS_RECORD_CLIENT_ERROR_UNSUPPORTED_CPU_MAX, + RTEMS_RECORD_CLIENT_ERROR_DOUBLE_CPU_MAX, + RTEMS_RECORD_CLIENT_ERROR_DOUBLE_PER_CPU_COUNT, + RTEMS_RECORD_CLIENT_ERROR_NO_CPU_MAX, + RTEMS_RECORD_CLIENT_ERROR_NO_MEMORY, + RTEMS_RECORD_CLIENT_ERROR_PER_CPU_ITEMS_OVERFLOW +} rtems_record_client_status; + +typedef rtems_record_client_status ( *rtems_record_client_handler )( + uint64_t bt, + uint32_t cpu, + rtems_record_event event, + uint64_t data, + void *arg +); + +typedef struct { + /** + * @brief Event time to uptime maintenance. + */ + struct { + uint64_t bt; + uint32_t time_at_bt; + uint32_t time_last; + uint32_t time_accumulated; + } uptime; + + /** + * @brief The current or previous ring buffer tail. + * + * Indexed by the tail_head_index member. + */ + uint32_t tail[ 2 ]; + + /** + * @brief The current or previous ring buffer head. + * + * Indexed by the tail_head_index member. + */ + uint32_t head[ 2 ]; + + /** + * @brief The index of the tail and head members. + * + * This index is used to maintain the current and previous tail/head + * positions to detect ring buffer overflows. + */ + size_t tail_head_index; + + /** + * @brief If true, then hold back items for overflow or initial ramp up + * processing. + */ + bool hold_back; + + /** + * @brief Storage for hold back items. + * + * In case of a ring buffer overflow, the rtems_record_drain() will push the + * complete ring buffer content to the client. While the items are processed + * by the client, new items may overwrite some items being processed. The + * overwritten items can be detected in the following iteration once the next + * tail/head information is pushed to the client. + * + * In case of the initial ramp up, the items are stored in the hold back + * buffer to determine the uptime of the first event. + */ + rtems_record_item_64 *items; + + /** + * @brief The index for the next hold back item. + */ + size_t item_index; +} rtems_record_client_per_cpu; + +typedef struct rtems_record_client_context { + uint64_t to_bt_scaler; + rtems_record_client_per_cpu per_cpu[ RTEMS_RECORD_CLIENT_MAXIMUM_CPU_COUNT ]; + uint32_t cpu; + uint32_t cpu_count; + uint32_t count; + union { + rtems_record_item_32 format_32; + rtems_record_item_64 format_64; + } item; + size_t todo; + void *pos; + rtems_record_client_status ( *consume )( + struct rtems_record_client_context *, + const void *, + size_t + ); + rtems_record_client_handler handler; + void *handler_arg; + uint32_t header[ 2 ]; + rtems_record_client_status status; +} rtems_record_client_context; + +/** + * @brief Initializes a record client. + * + * The record client consumes a record item stream produces by the record + * server. + * + * @param ctx The record client context to initialize. + * @param handler The handler is invoked for each received record item. + * @param arg The handler argument. + */ +void rtems_record_client_init( + rtems_record_client_context *ctx, + rtems_record_client_handler handler, + void *arg +); + +/** + * @brief Runs the record client to consume new stream data. + * + * @param ctx The record client context. + * @param buf The buffer with new stream data. + * @param n The size of the buffer. + */ +rtems_record_client_status rtems_record_client_run( + rtems_record_client_context *ctx, + const void *buf, + size_t n +); + +/** + * @brief Drains all internal buffers and frees the allocated resources. + * + * The client context must not be used afterwards. It can be re-initialized + * via rtems_record_client_init(). + * + * @param ctx The record client context. + */ +void rtems_record_client_destroy( + rtems_record_client_context *ctx +); + +static inline void rtems_record_client_set_handler( + rtems_record_client_context *ctx, + rtems_record_client_handler handler +) +{ + ctx->handler = handler; +} + +static inline uint64_t rtems_record_client_bintime_to_nanoseconds( + uint64_t bt +) +{ + uint64_t ns_per_sec; + uint64_t nanoseconds; + + ns_per_sec = 1000000000ULL; + nanoseconds = ns_per_sec * ( (uint32_t) ( bt >> 32 ) ); + nanoseconds += ( ns_per_sec * (uint32_t) bt ) >> 32; + + return nanoseconds; +} + +static inline void rtems_record_client_bintime_to_seconds_and_nanoseconds( + uint64_t bt, + uint32_t *seconds, + uint32_t *nanoseconds +) +{ + uint64_t ns_per_sec; + + ns_per_sec = 1000000000ULL; + *seconds = (uint32_t) ( bt >> 32 ); + *nanoseconds = (uint32_t) ( ( ns_per_sec * (uint32_t) bt ) >> 32 ); +} + +/** @} */ + +#ifdef __cplusplus +} +#endif /* __cplusplus */ + +#endif /* _RTEMS_RECORDCLIENT_H */ diff --git a/trace/record/rtems/recorddata.h b/trace/record/rtems/recorddata.h new file mode 100644 index 0000000..607955c --- /dev/null +++ b/trace/record/rtems/recorddata.h @@ -0,0 +1,1204 @@ +/* + * SPDX-License-Identifier: BSD-2-Clause + * + * Copyright (C) 2018, 2019 embedded brains GmbH + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" + * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE + * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR + * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF + * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS + * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN + * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) + * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE + * POSSIBILITY OF SUCH DAMAGE. + */ + +/* + * This file must be compatible to general purpose POSIX system, e.g. Linux, + * FreeBSD. It may be used for utility programs. + */ + +#ifndef _RTEMS_RECORDDATA_H +#define _RTEMS_RECORDDATA_H + +#include + +#ifdef __cplusplus +extern "C" { +#endif /* __cplusplus */ + +/** + * @defgroup RTEMSRecord Event Recording + * + * @ingroup RTEMSAPITracing + * + * @brief Low-level event recording support. + * + * @{ + */ + +/** + * @brief The record version. + * + * The record version reflects the record event definitions. It is reported by + * the RTEMS_RECORD_VERSION event. + */ +#define RTEMS_RECORD_THE_VERSION 5 + +/** + * @brief The items are in 32-bit little-endian format. + */ +#define RTEMS_RECORD_FORMAT_LE_32 0x11111111 + +/** + * @brief The items are in 64-bit little-endian format. + */ +#define RTEMS_RECORD_FORMAT_LE_64 0x22222222 + +/** + * @brief The items are in 32-bit big-endian format. + */ +#define RTEMS_RECORD_FORMAT_BE_32 0x33333333 + +/** + * @brief The items are in 64-bit big-endian format. + */ +#define RTEMS_RECORD_FORMAT_BE_64 0x44444444 + +/** + * @brief Magic number to identify a record item stream. + * + * This is a random number. + */ +#define RTEMS_RECORD_MAGIC 0x82e14ec1 + +/** + * @brief The record events. + */ +typedef enum { + /* There are 512 events reserved for the system */ + RTEMS_RECORD_EMPTY, + RTEMS_RECORD_VERSION, + + /* + * Keep the following system events in lexicographical order, increment + * RTEMS_RECORD_THE_VERSION after each change. + */ + RTEMS_RECORD_ACCEPT_ENTRY, + RTEMS_RECORD_ACCEPT_EXIT, + RTEMS_RECORD_BIND_ENTRY, + RTEMS_RECORD_BIND_EXIT, + RTEMS_RECORD_BUFFER, + RTEMS_RECORD_CHOWN_ENTRY, + RTEMS_RECORD_CHOWN_EXIT, + RTEMS_RECORD_CLOSE_ENTRY, + RTEMS_RECORD_CLOSE_EXIT, + RTEMS_RECORD_CONNECT_ENTRY, + RTEMS_RECORD_CONNECT_EXIT, + RTEMS_RECORD_ETHER_INPUT, + RTEMS_RECORD_ETHER_OUTPUT, + RTEMS_RECORD_FCHMOD_ENTRY, + RTEMS_RECORD_FCHMOD_EXIT, + RTEMS_RECORD_FCNTL_ENTRY, + RTEMS_RECORD_FCNTL_EXIT, + RTEMS_RECORD_FDATASYNC_ENTRY, + RTEMS_RECORD_FDATASYNC_EXIT, + RTEMS_RECORD_FREQUENCY, + RTEMS_RECORD_FSTAT_ENTRY, + RTEMS_RECORD_FSTAT_EXIT, + RTEMS_RECORD_FSYNC_ENTRY, + RTEMS_RECORD_FSYNC_EXIT, + RTEMS_RECORD_FTRUNCATE_ENTRY, + RTEMS_RECORD_FTRUNCATE_EXIT, + RTEMS_RECORD_GETSOCKOPT_ENTRY, + RTEMS_RECORD_GETSOCKOPT_EXIT, + RTEMS_RECORD_GIT_HASH, + RTEMS_RECORD_HEAP_ALLOC, + RTEMS_RECORD_HEAP_FREE, + RTEMS_RECORD_HEAP_SIZE, + RTEMS_RECORD_HEAP_USAGE, + RTEMS_RECORD_INTERRUPT_ENTRY, + RTEMS_RECORD_INTERRUPT_EXIT, + RTEMS_RECORD_INTERRUPT_INSTALL, + RTEMS_RECORD_INTERRUPT_REMOVE, + RTEMS_RECORD_INTERRUPT_SERVER_ENTRY, + RTEMS_RECORD_INTERRUPT_SERVER_EXIT, + RTEMS_RECORD_INTERRUPT_SERVER_INSTALL, + RTEMS_RECORD_INTERRUPT_SERVER_MOVE, + RTEMS_RECORD_INTERRUPT_SERVER_REMOVE, + RTEMS_RECORD_INTERRUPT_SERVER_TRIGGER, + RTEMS_RECORD_IOCTL_ENTRY, + RTEMS_RECORD_IOCTL_EXIT, + RTEMS_RECORD_IP6_INPUT, + RTEMS_RECORD_IP6_OUTPUT, + RTEMS_RECORD_IP_INPUT, + RTEMS_RECORD_IP_OUTPUT, + RTEMS_RECORD_KEVENT_ENTRY, + RTEMS_RECORD_KEVENT_EXIT, + RTEMS_RECORD_KQUEUE_ENTRY, + RTEMS_RECORD_KQUEUE_EXIT, + RTEMS_RECORD_LENGTH, + RTEMS_RECORD_LINK_ENTRY, + RTEMS_RECORD_LINK_EXIT, + RTEMS_RECORD_LISTEN_ENTRY, + RTEMS_RECORD_LISTEN_EXIT, + RTEMS_RECORD_LSEEK_ENTRY, + RTEMS_RECORD_LSEEK_EXIT, + RTEMS_RECORD_MKNOD_ENTRY, + RTEMS_RECORD_MKNOD_EXIT, + RTEMS_RECORD_MMAP_ENTRY, + RTEMS_RECORD_MMAP_EXIT, + RTEMS_RECORD_MOUNT_ENTRY, + RTEMS_RECORD_MOUNT_EXIT, + RTEMS_RECORD_OPEN_ENTRY, + RTEMS_RECORD_OPEN_EXIT, + RTEMS_RECORD_PAGE_ALLOC, + RTEMS_RECORD_PAGE_FREE, + RTEMS_RECORD_PER_CPU_COUNT, + RTEMS_RECORD_PER_CPU_HEAD, + RTEMS_RECORD_PER_CPU_OVERFLOW, + RTEMS_RECORD_PER_CPU_TAIL, + RTEMS_RECORD_POLL_ENTRY, + RTEMS_RECORD_POLL_EXIT, + RTEMS_RECORD_PROCESSOR, + RTEMS_RECORD_PROCESSOR_MAXIMUM, + RTEMS_RECORD_READ_ENTRY, + RTEMS_RECORD_READ_EXIT, + RTEMS_RECORD_READLINK_ENTRY, + RTEMS_RECORD_READLINK_EXIT, + RTEMS_RECORD_READV_ENTRY, + RTEMS_RECORD_READV_EXIT, + RTEMS_RECORD_RECV_ENTRY, + RTEMS_RECORD_RECV_EXIT, + RTEMS_RECORD_RECVFROM_ENTRY, + RTEMS_RECORD_RECVFROM_EXIT, + RTEMS_RECORD_RECVMSG_ENTRY, + RTEMS_RECORD_RECVMSG_EXIT, + RTEMS_RECORD_RENAME_ENTRY, + RTEMS_RECORD_RENAME_EXIT, + RTEMS_RECORD_RTEMS_BARRIER_CREATE, + RTEMS_RECORD_RTEMS_BARRIER_DELETE, + RTEMS_RECORD_RTEMS_BARRIER_RELEASE, + RTEMS_RECORD_RTEMS_BARRIER_WAIT, + RTEMS_RECORD_RTEMS_EVENT_RECEIVE, + RTEMS_RECORD_RTEMS_EVENT_SEND, + RTEMS_RECORD_RTEMS_EVENT_SYSTEM_RECEIVE, + RTEMS_RECORD_RTEMS_EVENT_SYSTEM_SEND, + RTEMS_RECORD_RTEMS_MESSAGE_QUEUE_BROADCAST, + RTEMS_RECORD_RTEMS_MESSAGE_QUEUE_CREATE, + RTEMS_RECORD_RTEMS_MESSAGE_QUEUE_DELETE, + RTEMS_RECORD_RTEMS_MESSAGE_QUEUE_FLUSH, + RTEMS_RECORD_RTEMS_MESSAGE_QUEUE_RECEIVE, + RTEMS_RECORD_RTEMS_MESSAGE_QUEUE_SEND, + RTEMS_RECORD_RTEMS_MESSAGE_QUEUE_URGENT, + RTEMS_RECORD_RTEMS_PARTITION_CREATE, + RTEMS_RECORD_RTEMS_PARTITION_DELETE, + RTEMS_RECORD_RTEMS_PARTITION_GET_BUFFER, + RTEMS_RECORD_RTEMS_PARTITION_RETURN_BUFFER, + RTEMS_RECORD_RTEMS_RATE_MONOTONIC_CANCEL, + RTEMS_RECORD_RTEMS_RATE_MONOTONIC_CREATE, + RTEMS_RECORD_RTEMS_RATE_MONOTONIC_DELETE, + RTEMS_RECORD_RTEMS_RATE_MONOTONIC_PERIOD, + RTEMS_RECORD_RTEMS_SEMAPHORE_CREATE, + RTEMS_RECORD_RTEMS_SEMAPHORE_DELETE, + RTEMS_RECORD_RTEMS_SEMAPHORE_FLUSH, + RTEMS_RECORD_RTEMS_SEMAPHORE_OBTAIN, + RTEMS_RECORD_RTEMS_SEMAPHORE_RELEASE, + RTEMS_RECORD_RTEMS_TIMER_CANCEL, + RTEMS_RECORD_RTEMS_TIMER_CREATE, + RTEMS_RECORD_RTEMS_TIMER_DELETE, + RTEMS_RECORD_RTEMS_TIMER_FIRE_AFTER, + RTEMS_RECORD_RTEMS_TIMER_FIRE_WHEN, + RTEMS_RECORD_RTEMS_TIMER_RESET, + RTEMS_RECORD_RTEMS_TIMER_SERVER_FIRE_AFTER, + RTEMS_RECORD_RTEMS_TIMER_SERVER_FIRE_WHEN, + RTEMS_RECORD_SBWAIT_ENTRY, + RTEMS_RECORD_SBWAIT_EXIT, + RTEMS_RECORD_SBWAKEUP_ENTRY, + RTEMS_RECORD_SBWAKEUP_EXIT, + RTEMS_RECORD_SELECT_ENTRY, + RTEMS_RECORD_SELECT_EXIT, + RTEMS_RECORD_SEND_ENTRY, + RTEMS_RECORD_SEND_EXIT, + RTEMS_RECORD_SENDMSG_ENTRY, + RTEMS_RECORD_SENDMSG_EXIT, + RTEMS_RECORD_SENDTO_ENTRY, + RTEMS_RECORD_SENDTO_EXIT, + RTEMS_RECORD_SETSOCKOPT_ENTRY, + RTEMS_RECORD_SETSOCKOPT_EXIT, + RTEMS_RECORD_SHUTDOWN_ENTRY, + RTEMS_RECORD_SHUTDOWN_EXIT, + RTEMS_RECORD_SOABORT_ENTRY, + RTEMS_RECORD_SOABORT_EXIT, + RTEMS_RECORD_SOACCEPT_ENTRY, + RTEMS_RECORD_SOACCEPT_EXIT, + RTEMS_RECORD_SOALLOC_ENTRY, + RTEMS_RECORD_SOALLOC_EXIT, + RTEMS_RECORD_SOBINDAT_ENTRY, + RTEMS_RECORD_SOBINDAT_EXIT, + RTEMS_RECORD_SOBIND_ENTRY, + RTEMS_RECORD_SOBIND_EXIT, + RTEMS_RECORD_SOCKET_ENTRY, + RTEMS_RECORD_SOCKET_EXIT, + RTEMS_RECORD_SOCLOSE_ENTRY, + RTEMS_RECORD_SOCLOSE_EXIT, + RTEMS_RECORD_SOCONNECT2_ENTRY, + RTEMS_RECORD_SOCONNECT2_EXIT, + RTEMS_RECORD_SOCONNECTAT_ENTRY, + RTEMS_RECORD_SOCONNECTAT_EXIT, + RTEMS_RECORD_SOCREATE_ENTRY, + RTEMS_RECORD_SOCREATE_EXIT, + RTEMS_RECORD_SODEALLOC_ENTRY, + RTEMS_RECORD_SODEALLOC_EXIT, + RTEMS_RECORD_SODISCONNECT_ENTRY, + RTEMS_RECORD_SODISCONNECT_EXIT, + RTEMS_RECORD_SOFREE_ENTRY, + RTEMS_RECORD_SOFREE_EXIT, + RTEMS_RECORD_SOLISTEN_ENTRY, + RTEMS_RECORD_SOLISTEN_EXIT, + RTEMS_RECORD_SONEWCONN_ENTRY, + RTEMS_RECORD_SONEWCONN_EXIT, + RTEMS_RECORD_SORECEIVE_ENTRY, + RTEMS_RECORD_SORECEIVE_EXIT, + RTEMS_RECORD_SORFLUSH_ENTRY, + RTEMS_RECORD_SORFLUSH_EXIT, + RTEMS_RECORD_SOSEND_ENTRY, + RTEMS_RECORD_SOSEND_EXIT, + RTEMS_RECORD_SOSHUTDOWN_ENTRY, + RTEMS_RECORD_SOSHUTDOWN_EXIT, + RTEMS_RECORD_STATVFS_ENTRY, + RTEMS_RECORD_STATVFS_EXIT, + RTEMS_RECORD_SYMLINK_ENTRY, + RTEMS_RECORD_SYMLINK_EXIT, + RTEMS_RECORD_TCP_CLOSE, + RTEMS_RECORD_TCP_INPUT, + RTEMS_RECORD_TCP_OUTPUT, + RTEMS_RECORD_THREAD_BEGIN, + RTEMS_RECORD_THREAD_CREATE, + RTEMS_RECORD_THREAD_DELETE, + RTEMS_RECORD_THREAD_EXIT, + RTEMS_RECORD_THREAD_EXITTED, + RTEMS_RECORD_THREAD_ID, + RTEMS_RECORD_THREAD_NAME, + RTEMS_RECORD_THREAD_PRIO_CURRENT_HIGH, + RTEMS_RECORD_THREAD_PRIO_CURRENT_LOW, + RTEMS_RECORD_THREAD_PRIO_REAL_HIGH, + RTEMS_RECORD_THREAD_PRIO_REAL_LOW, + RTEMS_RECORD_THREAD_QUEUE_ENQUEUE, + RTEMS_RECORD_THREAD_QUEUE_ENQUEUE_STICKY, + RTEMS_RECORD_THREAD_QUEUE_EXTRACT, + RTEMS_RECORD_THREAD_QUEUE_SURRENDER, + RTEMS_RECORD_THREAD_QUEUE_SURRENDER_STICKY, + RTEMS_RECORD_THREAD_RESOURCE_OBTAIN, + RTEMS_RECORD_THREAD_RESOURCE_RELEASE, + RTEMS_RECORD_THREAD_RESTART, + RTEMS_RECORD_THREAD_STACK_CURRENT, + RTEMS_RECORD_THREAD_STACK_SIZE, + RTEMS_RECORD_THREAD_STACK_USAGE, + RTEMS_RECORD_THREAD_START, + RTEMS_RECORD_THREAD_STATE_CLEAR, + RTEMS_RECORD_THREAD_STATE_SET, + RTEMS_RECORD_THREAD_SWITCH_IN, + RTEMS_RECORD_THREAD_SWITCH_OUT, + RTEMS_RECORD_THREAD_TERMINATE, + RTEMS_RECORD_UDP_INPUT, + RTEMS_RECORD_UDP_OUTPUT, + RTEMS_RECORD_UMA_ALLOC_PTR, + RTEMS_RECORD_UMA_ALLOC_ZONE, + RTEMS_RECORD_UMA_FREE_PTR, + RTEMS_RECORD_UMA_FREE_ZONE, + RTEMS_RECORD_UNLINK_ENTRY, + RTEMS_RECORD_UNLINK_EXIT, + RTEMS_RECORD_UNMOUNT_ENTRY, + RTEMS_RECORD_UNMOUNT_EXIT, + RTEMS_RECORD_UPTIME_HIGH, + RTEMS_RECORD_UPTIME_LOW, + RTEMS_RECORD_WORKSPACE_ALLOC, + RTEMS_RECORD_WORKSPACE_FREE, + RTEMS_RECORD_WORKSPACE_SIZE, + RTEMS_RECORD_WORKSPACE_USAGE, + RTEMS_RECORD_WRITE_ENTRY, + RTEMS_RECORD_WRITE_EXIT, + RTEMS_RECORD_WRITEV_ENTRY, + RTEMS_RECORD_WRITEV_EXIT, + + /* Unused system events */ + RTEMS_RECORD_SYSTEM_238, + RTEMS_RECORD_SYSTEM_239, + RTEMS_RECORD_SYSTEM_240, + RTEMS_RECORD_SYSTEM_241, + RTEMS_RECORD_SYSTEM_242, + RTEMS_RECORD_SYSTEM_243, + RTEMS_RECORD_SYSTEM_244, + RTEMS_RECORD_SYSTEM_245, + RTEMS_RECORD_SYSTEM_246, + RTEMS_RECORD_SYSTEM_247, + RTEMS_RECORD_SYSTEM_248, + RTEMS_RECORD_SYSTEM_249, + RTEMS_RECORD_SYSTEM_250, + RTEMS_RECORD_SYSTEM_251, + RTEMS_RECORD_SYSTEM_252, + RTEMS_RECORD_SYSTEM_253, + RTEMS_RECORD_SYSTEM_254, + RTEMS_RECORD_SYSTEM_255, + RTEMS_RECORD_SYSTEM_256, + RTEMS_RECORD_SYSTEM_257, + RTEMS_RECORD_SYSTEM_258, + RTEMS_RECORD_SYSTEM_259, + RTEMS_RECORD_SYSTEM_260, + RTEMS_RECORD_SYSTEM_261, + RTEMS_RECORD_SYSTEM_262, + RTEMS_RECORD_SYSTEM_263, + RTEMS_RECORD_SYSTEM_264, + RTEMS_RECORD_SYSTEM_265, + RTEMS_RECORD_SYSTEM_266, + RTEMS_RECORD_SYSTEM_267, + RTEMS_RECORD_SYSTEM_268, + RTEMS_RECORD_SYSTEM_269, + RTEMS_RECORD_SYSTEM_270, + RTEMS_RECORD_SYSTEM_271, + RTEMS_RECORD_SYSTEM_272, + RTEMS_RECORD_SYSTEM_273, + RTEMS_RECORD_SYSTEM_274, + RTEMS_RECORD_SYSTEM_275, + RTEMS_RECORD_SYSTEM_276, + RTEMS_RECORD_SYSTEM_277, + RTEMS_RECORD_SYSTEM_278, + RTEMS_RECORD_SYSTEM_279, + RTEMS_RECORD_SYSTEM_280, + RTEMS_RECORD_SYSTEM_281, + RTEMS_RECORD_SYSTEM_282, + RTEMS_RECORD_SYSTEM_283, + RTEMS_RECORD_SYSTEM_284, + RTEMS_RECORD_SYSTEM_285, + RTEMS_RECORD_SYSTEM_286, + RTEMS_RECORD_SYSTEM_287, + RTEMS_RECORD_SYSTEM_288, + RTEMS_RECORD_SYSTEM_289, + RTEMS_RECORD_SYSTEM_290, + RTEMS_RECORD_SYSTEM_291, + RTEMS_RECORD_SYSTEM_292, + RTEMS_RECORD_SYSTEM_293, + RTEMS_RECORD_SYSTEM_294, + RTEMS_RECORD_SYSTEM_295, + RTEMS_RECORD_SYSTEM_296, + RTEMS_RECORD_SYSTEM_297, + RTEMS_RECORD_SYSTEM_298, + RTEMS_RECORD_SYSTEM_299, + RTEMS_RECORD_SYSTEM_300, + RTEMS_RECORD_SYSTEM_301, + RTEMS_RECORD_SYSTEM_302, + RTEMS_RECORD_SYSTEM_303, + RTEMS_RECORD_SYSTEM_304, + RTEMS_RECORD_SYSTEM_305, + RTEMS_RECORD_SYSTEM_306, + RTEMS_RECORD_SYSTEM_307, + RTEMS_RECORD_SYSTEM_308, + RTEMS_RECORD_SYSTEM_309, + RTEMS_RECORD_SYSTEM_310, + RTEMS_RECORD_SYSTEM_311, + RTEMS_RECORD_SYSTEM_312, + RTEMS_RECORD_SYSTEM_313, + RTEMS_RECORD_SYSTEM_314, + RTEMS_RECORD_SYSTEM_315, + RTEMS_RECORD_SYSTEM_316, + RTEMS_RECORD_SYSTEM_317, + RTEMS_RECORD_SYSTEM_318, + RTEMS_RECORD_SYSTEM_319, + RTEMS_RECORD_SYSTEM_320, + RTEMS_RECORD_SYSTEM_321, + RTEMS_RECORD_SYSTEM_322, + RTEMS_RECORD_SYSTEM_323, + RTEMS_RECORD_SYSTEM_324, + RTEMS_RECORD_SYSTEM_325, + RTEMS_RECORD_SYSTEM_326, + RTEMS_RECORD_SYSTEM_327, + RTEMS_RECORD_SYSTEM_328, + RTEMS_RECORD_SYSTEM_329, + RTEMS_RECORD_SYSTEM_330, + RTEMS_RECORD_SYSTEM_331, + RTEMS_RECORD_SYSTEM_332, + RTEMS_RECORD_SYSTEM_333, + RTEMS_RECORD_SYSTEM_334, + RTEMS_RECORD_SYSTEM_335, + RTEMS_RECORD_SYSTEM_336, + RTEMS_RECORD_SYSTEM_337, + RTEMS_RECORD_SYSTEM_338, + RTEMS_RECORD_SYSTEM_339, + RTEMS_RECORD_SYSTEM_340, + RTEMS_RECORD_SYSTEM_341, + RTEMS_RECORD_SYSTEM_342, + RTEMS_RECORD_SYSTEM_343, + RTEMS_RECORD_SYSTEM_344, + RTEMS_RECORD_SYSTEM_345, + RTEMS_RECORD_SYSTEM_346, + RTEMS_RECORD_SYSTEM_347, + RTEMS_RECORD_SYSTEM_348, + RTEMS_RECORD_SYSTEM_349, + RTEMS_RECORD_SYSTEM_350, + RTEMS_RECORD_SYSTEM_351, + RTEMS_RECORD_SYSTEM_352, + RTEMS_RECORD_SYSTEM_353, + RTEMS_RECORD_SYSTEM_354, + RTEMS_RECORD_SYSTEM_355, + RTEMS_RECORD_SYSTEM_356, + RTEMS_RECORD_SYSTEM_357, + RTEMS_RECORD_SYSTEM_358, + RTEMS_RECORD_SYSTEM_359, + RTEMS_RECORD_SYSTEM_360, + RTEMS_RECORD_SYSTEM_361, + RTEMS_RECORD_SYSTEM_362, + RTEMS_RECORD_SYSTEM_363, + RTEMS_RECORD_SYSTEM_364, + RTEMS_RECORD_SYSTEM_365, + RTEMS_RECORD_SYSTEM_366, + RTEMS_RECORD_SYSTEM_367, + RTEMS_RECORD_SYSTEM_368, + RTEMS_RECORD_SYSTEM_369, + RTEMS_RECORD_SYSTEM_370, + RTEMS_RECORD_SYSTEM_371, + RTEMS_RECORD_SYSTEM_372, + RTEMS_RECORD_SYSTEM_373, + RTEMS_RECORD_SYSTEM_374, + RTEMS_RECORD_SYSTEM_375, + RTEMS_RECORD_SYSTEM_376, + RTEMS_RECORD_SYSTEM_377, + RTEMS_RECORD_SYSTEM_378, + RTEMS_RECORD_SYSTEM_379, + RTEMS_RECORD_SYSTEM_380, + RTEMS_RECORD_SYSTEM_381, + RTEMS_RECORD_SYSTEM_382, + RTEMS_RECORD_SYSTEM_383, + RTEMS_RECORD_SYSTEM_384, + RTEMS_RECORD_SYSTEM_385, + RTEMS_RECORD_SYSTEM_386, + RTEMS_RECORD_SYSTEM_387, + RTEMS_RECORD_SYSTEM_388, + RTEMS_RECORD_SYSTEM_389, + RTEMS_RECORD_SYSTEM_390, + RTEMS_RECORD_SYSTEM_391, + RTEMS_RECORD_SYSTEM_392, + RTEMS_RECORD_SYSTEM_393, + RTEMS_RECORD_SYSTEM_394, + RTEMS_RECORD_SYSTEM_395, + RTEMS_RECORD_SYSTEM_396, + RTEMS_RECORD_SYSTEM_397, + RTEMS_RECORD_SYSTEM_398, + RTEMS_RECORD_SYSTEM_399, + RTEMS_RECORD_SYSTEM_400, + RTEMS_RECORD_SYSTEM_401, + RTEMS_RECORD_SYSTEM_402, + RTEMS_RECORD_SYSTEM_403, + RTEMS_RECORD_SYSTEM_404, + RTEMS_RECORD_SYSTEM_405, + RTEMS_RECORD_SYSTEM_406, + RTEMS_RECORD_SYSTEM_407, + RTEMS_RECORD_SYSTEM_408, + RTEMS_RECORD_SYSTEM_409, + RTEMS_RECORD_SYSTEM_410, + RTEMS_RECORD_SYSTEM_411, + RTEMS_RECORD_SYSTEM_412, + RTEMS_RECORD_SYSTEM_413, + RTEMS_RECORD_SYSTEM_414, + RTEMS_RECORD_SYSTEM_415, + RTEMS_RECORD_SYSTEM_416, + RTEMS_RECORD_SYSTEM_417, + RTEMS_RECORD_SYSTEM_418, + RTEMS_RECORD_SYSTEM_419, + RTEMS_RECORD_SYSTEM_420, + RTEMS_RECORD_SYSTEM_421, + RTEMS_RECORD_SYSTEM_422, + RTEMS_RECORD_SYSTEM_423, + RTEMS_RECORD_SYSTEM_424, + RTEMS_RECORD_SYSTEM_425, + RTEMS_RECORD_SYSTEM_426, + RTEMS_RECORD_SYSTEM_427, + RTEMS_RECORD_SYSTEM_428, + RTEMS_RECORD_SYSTEM_429, + RTEMS_RECORD_SYSTEM_430, + RTEMS_RECORD_SYSTEM_431, + RTEMS_RECORD_SYSTEM_432, + RTEMS_RECORD_SYSTEM_433, + RTEMS_RECORD_SYSTEM_434, + RTEMS_RECORD_SYSTEM_435, + RTEMS_RECORD_SYSTEM_436, + RTEMS_RECORD_SYSTEM_437, + RTEMS_RECORD_SYSTEM_438, + RTEMS_RECORD_SYSTEM_439, + RTEMS_RECORD_SYSTEM_440, + RTEMS_RECORD_SYSTEM_441, + RTEMS_RECORD_SYSTEM_442, + RTEMS_RECORD_SYSTEM_443, + RTEMS_RECORD_SYSTEM_444, + RTEMS_RECORD_SYSTEM_445, + RTEMS_RECORD_SYSTEM_446, + RTEMS_RECORD_SYSTEM_447, + RTEMS_RECORD_SYSTEM_448, + RTEMS_RECORD_SYSTEM_449, + RTEMS_RECORD_SYSTEM_450, + RTEMS_RECORD_SYSTEM_451, + RTEMS_RECORD_SYSTEM_452, + RTEMS_RECORD_SYSTEM_453, + RTEMS_RECORD_SYSTEM_454, + RTEMS_RECORD_SYSTEM_455, + RTEMS_RECORD_SYSTEM_456, + RTEMS_RECORD_SYSTEM_457, + RTEMS_RECORD_SYSTEM_458, + RTEMS_RECORD_SYSTEM_459, + RTEMS_RECORD_SYSTEM_460, + RTEMS_RECORD_SYSTEM_461, + RTEMS_RECORD_SYSTEM_462, + RTEMS_RECORD_SYSTEM_463, + RTEMS_RECORD_SYSTEM_464, + RTEMS_RECORD_SYSTEM_465, + RTEMS_RECORD_SYSTEM_466, + RTEMS_RECORD_SYSTEM_467, + RTEMS_RECORD_SYSTEM_468, + RTEMS_RECORD_SYSTEM_469, + RTEMS_RECORD_SYSTEM_470, + RTEMS_RECORD_SYSTEM_471, + RTEMS_RECORD_SYSTEM_472, + RTEMS_RECORD_SYSTEM_473, + RTEMS_RECORD_SYSTEM_474, + RTEMS_RECORD_SYSTEM_475, + RTEMS_RECORD_SYSTEM_476, + RTEMS_RECORD_SYSTEM_477, + RTEMS_RECORD_SYSTEM_478, + RTEMS_RECORD_SYSTEM_479, + RTEMS_RECORD_SYSTEM_480, + RTEMS_RECORD_SYSTEM_481, + RTEMS_RECORD_SYSTEM_482, + RTEMS_RECORD_SYSTEM_483, + RTEMS_RECORD_SYSTEM_484, + RTEMS_RECORD_SYSTEM_485, + RTEMS_RECORD_SYSTEM_486, + RTEMS_RECORD_SYSTEM_487, + RTEMS_RECORD_SYSTEM_488, + RTEMS_RECORD_SYSTEM_489, + RTEMS_RECORD_SYSTEM_490, + RTEMS_RECORD_SYSTEM_491, + RTEMS_RECORD_SYSTEM_492, + RTEMS_RECORD_SYSTEM_493, + RTEMS_RECORD_SYSTEM_494, + RTEMS_RECORD_SYSTEM_495, + RTEMS_RECORD_SYSTEM_496, + RTEMS_RECORD_SYSTEM_497, + RTEMS_RECORD_SYSTEM_498, + RTEMS_RECORD_SYSTEM_499, + RTEMS_RECORD_SYSTEM_500, + RTEMS_RECORD_SYSTEM_501, + RTEMS_RECORD_SYSTEM_502, + RTEMS_RECORD_SYSTEM_503, + RTEMS_RECORD_SYSTEM_504, + RTEMS_RECORD_SYSTEM_505, + RTEMS_RECORD_SYSTEM_506, + RTEMS_RECORD_SYSTEM_507, + RTEMS_RECORD_SYSTEM_508, + RTEMS_RECORD_SYSTEM_509, + RTEMS_RECORD_SYSTEM_510, + + /* There are 512 events reserved for the user */ + RTEMS_RECORD_USER_0, + RTEMS_RECORD_USER_1, + RTEMS_RECORD_USER_2, + RTEMS_RECORD_USER_3, + RTEMS_RECORD_USER_4, + RTEMS_RECORD_USER_5, + RTEMS_RECORD_USER_6, + RTEMS_RECORD_USER_7, + RTEMS_RECORD_USER_8, + RTEMS_RECORD_USER_9, + RTEMS_RECORD_USER_10, + RTEMS_RECORD_USER_11, + RTEMS_RECORD_USER_12, + RTEMS_RECORD_USER_13, + RTEMS_RECORD_USER_14, + RTEMS_RECORD_USER_15, + RTEMS_RECORD_USER_16, + RTEMS_RECORD_USER_17, + RTEMS_RECORD_USER_18, + RTEMS_RECORD_USER_19, + RTEMS_RECORD_USER_20, + RTEMS_RECORD_USER_21, + RTEMS_RECORD_USER_22, + RTEMS_RECORD_USER_23, + RTEMS_RECORD_USER_24, + RTEMS_RECORD_USER_25, + RTEMS_RECORD_USER_26, + RTEMS_RECORD_USER_27, + RTEMS_RECORD_USER_28, + RTEMS_RECORD_USER_29, + RTEMS_RECORD_USER_30, + RTEMS_RECORD_USER_31, + RTEMS_RECORD_USER_32, + RTEMS_RECORD_USER_33, + RTEMS_RECORD_USER_34, + RTEMS_RECORD_USER_35, + RTEMS_RECORD_USER_36, + RTEMS_RECORD_USER_37, + RTEMS_RECORD_USER_38, + RTEMS_RECORD_USER_39, + RTEMS_RECORD_USER_40, + RTEMS_RECORD_USER_41, + RTEMS_RECORD_USER_42, + RTEMS_RECORD_USER_43, + RTEMS_RECORD_USER_44, + RTEMS_RECORD_USER_45, + RTEMS_RECORD_USER_46, + RTEMS_RECORD_USER_47, + RTEMS_RECORD_USER_48, + RTEMS_RECORD_USER_49, + RTEMS_RECORD_USER_50, + RTEMS_RECORD_USER_51, + RTEMS_RECORD_USER_52, + RTEMS_RECORD_USER_53, + RTEMS_RECORD_USER_54, + RTEMS_RECORD_USER_55, + RTEMS_RECORD_USER_56, + RTEMS_RECORD_USER_57, + RTEMS_RECORD_USER_58, + RTEMS_RECORD_USER_59, + RTEMS_RECORD_USER_60, + RTEMS_RECORD_USER_61, + RTEMS_RECORD_USER_62, + RTEMS_RECORD_USER_63, + RTEMS_RECORD_USER_64, + RTEMS_RECORD_USER_65, + RTEMS_RECORD_USER_66, + RTEMS_RECORD_USER_67, + RTEMS_RECORD_USER_68, + RTEMS_RECORD_USER_69, + RTEMS_RECORD_USER_70, + RTEMS_RECORD_USER_71, + RTEMS_RECORD_USER_72, + RTEMS_RECORD_USER_73, + RTEMS_RECORD_USER_74, + RTEMS_RECORD_USER_75, + RTEMS_RECORD_USER_76, + RTEMS_RECORD_USER_77, + RTEMS_RECORD_USER_78, + RTEMS_RECORD_USER_79, + RTEMS_RECORD_USER_80, + RTEMS_RECORD_USER_81, + RTEMS_RECORD_USER_82, + RTEMS_RECORD_USER_83, + RTEMS_RECORD_USER_84, + RTEMS_RECORD_USER_85, + RTEMS_RECORD_USER_86, + RTEMS_RECORD_USER_87, + RTEMS_RECORD_USER_88, + RTEMS_RECORD_USER_89, + RTEMS_RECORD_USER_90, + RTEMS_RECORD_USER_91, + RTEMS_RECORD_USER_92, + RTEMS_RECORD_USER_93, + RTEMS_RECORD_USER_94, + RTEMS_RECORD_USER_95, + RTEMS_RECORD_USER_96, + RTEMS_RECORD_USER_97, + RTEMS_RECORD_USER_98, + RTEMS_RECORD_USER_99, + RTEMS_RECORD_USER_100, + RTEMS_RECORD_USER_101, + RTEMS_RECORD_USER_102, + RTEMS_RECORD_USER_103, + RTEMS_RECORD_USER_104, + RTEMS_RECORD_USER_105, + RTEMS_RECORD_USER_106, + RTEMS_RECORD_USER_107, + RTEMS_RECORD_USER_108, + RTEMS_RECORD_USER_109, + RTEMS_RECORD_USER_110, + RTEMS_RECORD_USER_111, + RTEMS_RECORD_USER_112, + RTEMS_RECORD_USER_113, + RTEMS_RECORD_USER_114, + RTEMS_RECORD_USER_115, + RTEMS_RECORD_USER_116, + RTEMS_RECORD_USER_117, + RTEMS_RECORD_USER_118, + RTEMS_RECORD_USER_119, + RTEMS_RECORD_USER_120, + RTEMS_RECORD_USER_121, + RTEMS_RECORD_USER_122, + RTEMS_RECORD_USER_123, + RTEMS_RECORD_USER_124, + RTEMS_RECORD_USER_125, + RTEMS_RECORD_USER_126, + RTEMS_RECORD_USER_127, + RTEMS_RECORD_USER_128, + RTEMS_RECORD_USER_129, + RTEMS_RECORD_USER_130, + RTEMS_RECORD_USER_131, + RTEMS_RECORD_USER_132, + RTEMS_RECORD_USER_133, + RTEMS_RECORD_USER_134, + RTEMS_RECORD_USER_135, + RTEMS_RECORD_USER_136, + RTEMS_RECORD_USER_137, + RTEMS_RECORD_USER_138, + RTEMS_RECORD_USER_139, + RTEMS_RECORD_USER_140, + RTEMS_RECORD_USER_141, + RTEMS_RECORD_USER_142, + RTEMS_RECORD_USER_143, + RTEMS_RECORD_USER_144, + RTEMS_RECORD_USER_145, + RTEMS_RECORD_USER_146, + RTEMS_RECORD_USER_147, + RTEMS_RECORD_USER_148, + RTEMS_RECORD_USER_149, + RTEMS_RECORD_USER_150, + RTEMS_RECORD_USER_151, + RTEMS_RECORD_USER_152, + RTEMS_RECORD_USER_153, + RTEMS_RECORD_USER_154, + RTEMS_RECORD_USER_155, + RTEMS_RECORD_USER_156, + RTEMS_RECORD_USER_157, + RTEMS_RECORD_USER_158, + RTEMS_RECORD_USER_159, + RTEMS_RECORD_USER_160, + RTEMS_RECORD_USER_161, + RTEMS_RECORD_USER_162, + RTEMS_RECORD_USER_163, + RTEMS_RECORD_USER_164, + RTEMS_RECORD_USER_165, + RTEMS_RECORD_USER_166, + RTEMS_RECORD_USER_167, + RTEMS_RECORD_USER_168, + RTEMS_RECORD_USER_169, + RTEMS_RECORD_USER_170, + RTEMS_RECORD_USER_171, + RTEMS_RECORD_USER_172, + RTEMS_RECORD_USER_173, + RTEMS_RECORD_USER_174, + RTEMS_RECORD_USER_175, + RTEMS_RECORD_USER_176, + RTEMS_RECORD_USER_177, + RTEMS_RECORD_USER_178, + RTEMS_RECORD_USER_179, + RTEMS_RECORD_USER_180, + RTEMS_RECORD_USER_181, + RTEMS_RECORD_USER_182, + RTEMS_RECORD_USER_183, + RTEMS_RECORD_USER_184, + RTEMS_RECORD_USER_185, + RTEMS_RECORD_USER_186, + RTEMS_RECORD_USER_187, + RTEMS_RECORD_USER_188, + RTEMS_RECORD_USER_189, + RTEMS_RECORD_USER_190, + RTEMS_RECORD_USER_191, + RTEMS_RECORD_USER_192, + RTEMS_RECORD_USER_193, + RTEMS_RECORD_USER_194, + RTEMS_RECORD_USER_195, + RTEMS_RECORD_USER_196, + RTEMS_RECORD_USER_197, + RTEMS_RECORD_USER_198, + RTEMS_RECORD_USER_199, + RTEMS_RECORD_USER_200, + RTEMS_RECORD_USER_201, + RTEMS_RECORD_USER_202, + RTEMS_RECORD_USER_203, + RTEMS_RECORD_USER_204, + RTEMS_RECORD_USER_205, + RTEMS_RECORD_USER_206, + RTEMS_RECORD_USER_207, + RTEMS_RECORD_USER_208, + RTEMS_RECORD_USER_209, + RTEMS_RECORD_USER_210, + RTEMS_RECORD_USER_211, + RTEMS_RECORD_USER_212, + RTEMS_RECORD_USER_213, + RTEMS_RECORD_USER_214, + RTEMS_RECORD_USER_215, + RTEMS_RECORD_USER_216, + RTEMS_RECORD_USER_217, + RTEMS_RECORD_USER_218, + RTEMS_RECORD_USER_219, + RTEMS_RECORD_USER_220, + RTEMS_RECORD_USER_221, + RTEMS_RECORD_USER_222, + RTEMS_RECORD_USER_223, + RTEMS_RECORD_USER_224, + RTEMS_RECORD_USER_225, + RTEMS_RECORD_USER_226, + RTEMS_RECORD_USER_227, + RTEMS_RECORD_USER_228, + RTEMS_RECORD_USER_229, + RTEMS_RECORD_USER_230, + RTEMS_RECORD_USER_231, + RTEMS_RECORD_USER_232, + RTEMS_RECORD_USER_233, + RTEMS_RECORD_USER_234, + RTEMS_RECORD_USER_235, + RTEMS_RECORD_USER_236, + RTEMS_RECORD_USER_237, + RTEMS_RECORD_USER_238, + RTEMS_RECORD_USER_239, + RTEMS_RECORD_USER_240, + RTEMS_RECORD_USER_241, + RTEMS_RECORD_USER_242, + RTEMS_RECORD_USER_243, + RTEMS_RECORD_USER_244, + RTEMS_RECORD_USER_245, + RTEMS_RECORD_USER_246, + RTEMS_RECORD_USER_247, + RTEMS_RECORD_USER_248, + RTEMS_RECORD_USER_249, + RTEMS_RECORD_USER_250, + RTEMS_RECORD_USER_251, + RTEMS_RECORD_USER_252, + RTEMS_RECORD_USER_253, + RTEMS_RECORD_USER_254, + RTEMS_RECORD_USER_255, + RTEMS_RECORD_USER_256, + RTEMS_RECORD_USER_257, + RTEMS_RECORD_USER_258, + RTEMS_RECORD_USER_259, + RTEMS_RECORD_USER_260, + RTEMS_RECORD_USER_261, + RTEMS_RECORD_USER_262, + RTEMS_RECORD_USER_263, + RTEMS_RECORD_USER_264, + RTEMS_RECORD_USER_265, + RTEMS_RECORD_USER_266, + RTEMS_RECORD_USER_267, + RTEMS_RECORD_USER_268, + RTEMS_RECORD_USER_269, + RTEMS_RECORD_USER_270, + RTEMS_RECORD_USER_271, + RTEMS_RECORD_USER_272, + RTEMS_RECORD_USER_273, + RTEMS_RECORD_USER_274, + RTEMS_RECORD_USER_275, + RTEMS_RECORD_USER_276, + RTEMS_RECORD_USER_277, + RTEMS_RECORD_USER_278, + RTEMS_RECORD_USER_279, + RTEMS_RECORD_USER_280, + RTEMS_RECORD_USER_281, + RTEMS_RECORD_USER_282, + RTEMS_RECORD_USER_283, + RTEMS_RECORD_USER_284, + RTEMS_RECORD_USER_285, + RTEMS_RECORD_USER_286, + RTEMS_RECORD_USER_287, + RTEMS_RECORD_USER_288, + RTEMS_RECORD_USER_289, + RTEMS_RECORD_USER_290, + RTEMS_RECORD_USER_291, + RTEMS_RECORD_USER_292, + RTEMS_RECORD_USER_293, + RTEMS_RECORD_USER_294, + RTEMS_RECORD_USER_295, + RTEMS_RECORD_USER_296, + RTEMS_RECORD_USER_297, + RTEMS_RECORD_USER_298, + RTEMS_RECORD_USER_299, + RTEMS_RECORD_USER_300, + RTEMS_RECORD_USER_301, + RTEMS_RECORD_USER_302, + RTEMS_RECORD_USER_303, + RTEMS_RECORD_USER_304, + RTEMS_RECORD_USER_305, + RTEMS_RECORD_USER_306, + RTEMS_RECORD_USER_307, + RTEMS_RECORD_USER_308, + RTEMS_RECORD_USER_309, + RTEMS_RECORD_USER_310, + RTEMS_RECORD_USER_311, + RTEMS_RECORD_USER_312, + RTEMS_RECORD_USER_313, + RTEMS_RECORD_USER_314, + RTEMS_RECORD_USER_315, + RTEMS_RECORD_USER_316, + RTEMS_RECORD_USER_317, + RTEMS_RECORD_USER_318, + RTEMS_RECORD_USER_319, + RTEMS_RECORD_USER_320, + RTEMS_RECORD_USER_321, + RTEMS_RECORD_USER_322, + RTEMS_RECORD_USER_323, + RTEMS_RECORD_USER_324, + RTEMS_RECORD_USER_325, + RTEMS_RECORD_USER_326, + RTEMS_RECORD_USER_327, + RTEMS_RECORD_USER_328, + RTEMS_RECORD_USER_329, + RTEMS_RECORD_USER_330, + RTEMS_RECORD_USER_331, + RTEMS_RECORD_USER_332, + RTEMS_RECORD_USER_333, + RTEMS_RECORD_USER_334, + RTEMS_RECORD_USER_335, + RTEMS_RECORD_USER_336, + RTEMS_RECORD_USER_337, + RTEMS_RECORD_USER_338, + RTEMS_RECORD_USER_339, + RTEMS_RECORD_USER_340, + RTEMS_RECORD_USER_341, + RTEMS_RECORD_USER_342, + RTEMS_RECORD_USER_343, + RTEMS_RECORD_USER_344, + RTEMS_RECORD_USER_345, + RTEMS_RECORD_USER_346, + RTEMS_RECORD_USER_347, + RTEMS_RECORD_USER_348, + RTEMS_RECORD_USER_349, + RTEMS_RECORD_USER_350, + RTEMS_RECORD_USER_351, + RTEMS_RECORD_USER_352, + RTEMS_RECORD_USER_353, + RTEMS_RECORD_USER_354, + RTEMS_RECORD_USER_355, + RTEMS_RECORD_USER_356, + RTEMS_RECORD_USER_357, + RTEMS_RECORD_USER_358, + RTEMS_RECORD_USER_359, + RTEMS_RECORD_USER_360, + RTEMS_RECORD_USER_361, + RTEMS_RECORD_USER_362, + RTEMS_RECORD_USER_363, + RTEMS_RECORD_USER_364, + RTEMS_RECORD_USER_365, + RTEMS_RECORD_USER_366, + RTEMS_RECORD_USER_367, + RTEMS_RECORD_USER_368, + RTEMS_RECORD_USER_369, + RTEMS_RECORD_USER_370, + RTEMS_RECORD_USER_371, + RTEMS_RECORD_USER_372, + RTEMS_RECORD_USER_373, + RTEMS_RECORD_USER_374, + RTEMS_RECORD_USER_375, + RTEMS_RECORD_USER_376, + RTEMS_RECORD_USER_377, + RTEMS_RECORD_USER_378, + RTEMS_RECORD_USER_379, + RTEMS_RECORD_USER_380, + RTEMS_RECORD_USER_381, + RTEMS_RECORD_USER_382, + RTEMS_RECORD_USER_383, + RTEMS_RECORD_USER_384, + RTEMS_RECORD_USER_385, + RTEMS_RECORD_USER_386, + RTEMS_RECORD_USER_387, + RTEMS_RECORD_USER_388, + RTEMS_RECORD_USER_389, + RTEMS_RECORD_USER_390, + RTEMS_RECORD_USER_391, + RTEMS_RECORD_USER_392, + RTEMS_RECORD_USER_393, + RTEMS_RECORD_USER_394, + RTEMS_RECORD_USER_395, + RTEMS_RECORD_USER_396, + RTEMS_RECORD_USER_397, + RTEMS_RECORD_USER_398, + RTEMS_RECORD_USER_399, + RTEMS_RECORD_USER_400, + RTEMS_RECORD_USER_401, + RTEMS_RECORD_USER_402, + RTEMS_RECORD_USER_403, + RTEMS_RECORD_USER_404, + RTEMS_RECORD_USER_405, + RTEMS_RECORD_USER_406, + RTEMS_RECORD_USER_407, + RTEMS_RECORD_USER_408, + RTEMS_RECORD_USER_409, + RTEMS_RECORD_USER_410, + RTEMS_RECORD_USER_411, + RTEMS_RECORD_USER_412, + RTEMS_RECORD_USER_413, + RTEMS_RECORD_USER_414, + RTEMS_RECORD_USER_415, + RTEMS_RECORD_USER_416, + RTEMS_RECORD_USER_417, + RTEMS_RECORD_USER_418, + RTEMS_RECORD_USER_419, + RTEMS_RECORD_USER_420, + RTEMS_RECORD_USER_421, + RTEMS_RECORD_USER_422, + RTEMS_RECORD_USER_423, + RTEMS_RECORD_USER_424, + RTEMS_RECORD_USER_425, + RTEMS_RECORD_USER_426, + RTEMS_RECORD_USER_427, + RTEMS_RECORD_USER_428, + RTEMS_RECORD_USER_429, + RTEMS_RECORD_USER_430, + RTEMS_RECORD_USER_431, + RTEMS_RECORD_USER_432, + RTEMS_RECORD_USER_433, + RTEMS_RECORD_USER_434, + RTEMS_RECORD_USER_435, + RTEMS_RECORD_USER_436, + RTEMS_RECORD_USER_437, + RTEMS_RECORD_USER_438, + RTEMS_RECORD_USER_439, + RTEMS_RECORD_USER_440, + RTEMS_RECORD_USER_441, + RTEMS_RECORD_USER_442, + RTEMS_RECORD_USER_443, + RTEMS_RECORD_USER_444, + RTEMS_RECORD_USER_445, + RTEMS_RECORD_USER_446, + RTEMS_RECORD_USER_447, + RTEMS_RECORD_USER_448, + RTEMS_RECORD_USER_449, + RTEMS_RECORD_USER_450, + RTEMS_RECORD_USER_451, + RTEMS_RECORD_USER_452, + RTEMS_RECORD_USER_453, + RTEMS_RECORD_USER_454, + RTEMS_RECORD_USER_455, + RTEMS_RECORD_USER_456, + RTEMS_RECORD_USER_457, + RTEMS_RECORD_USER_458, + RTEMS_RECORD_USER_459, + RTEMS_RECORD_USER_460, + RTEMS_RECORD_USER_461, + RTEMS_RECORD_USER_462, + RTEMS_RECORD_USER_463, + RTEMS_RECORD_USER_464, + RTEMS_RECORD_USER_465, + RTEMS_RECORD_USER_466, + RTEMS_RECORD_USER_467, + RTEMS_RECORD_USER_468, + RTEMS_RECORD_USER_469, + RTEMS_RECORD_USER_470, + RTEMS_RECORD_USER_471, + RTEMS_RECORD_USER_472, + RTEMS_RECORD_USER_473, + RTEMS_RECORD_USER_474, + RTEMS_RECORD_USER_475, + RTEMS_RECORD_USER_476, + RTEMS_RECORD_USER_477, + RTEMS_RECORD_USER_478, + RTEMS_RECORD_USER_479, + RTEMS_RECORD_USER_480, + RTEMS_RECORD_USER_481, + RTEMS_RECORD_USER_482, + RTEMS_RECORD_USER_483, + RTEMS_RECORD_USER_484, + RTEMS_RECORD_USER_485, + RTEMS_RECORD_USER_486, + RTEMS_RECORD_USER_487, + RTEMS_RECORD_USER_488, + RTEMS_RECORD_USER_489, + RTEMS_RECORD_USER_490, + RTEMS_RECORD_USER_491, + RTEMS_RECORD_USER_492, + RTEMS_RECORD_USER_493, + RTEMS_RECORD_USER_494, + RTEMS_RECORD_USER_495, + RTEMS_RECORD_USER_496, + RTEMS_RECORD_USER_497, + RTEMS_RECORD_USER_498, + RTEMS_RECORD_USER_499, + RTEMS_RECORD_USER_500, + RTEMS_RECORD_USER_501, + RTEMS_RECORD_USER_502, + RTEMS_RECORD_USER_503, + RTEMS_RECORD_USER_504, + RTEMS_RECORD_USER_505, + RTEMS_RECORD_USER_506, + RTEMS_RECORD_USER_507, + RTEMS_RECORD_USER_508, + RTEMS_RECORD_USER_509, + RTEMS_RECORD_USER_510, + RTEMS_RECORD_USER_511 +} rtems_record_event; + +#define RTEMS_RECORD_LAST RTEMS_RECORD_USER_511 + +#define RTEMS_RECORD_USER( index ) ( RTEMS_RECORD_USER_0 + ( index ) ) + +/** + * @brief Bits in the record item event member reserved for the actual event. + */ +#define RTEMS_RECORD_EVENT_BITS 10 + +/** + * @brief Bits in the record item event member reserved for the time of the + * event. + */ +#define RTEMS_RECORD_TIME_BITS 22 + +/** + * @brief Builds a time event for the specified time stamp and event. + * + * The events are stored in the record item with a time stamp. There are 22 + * bits allocated to the time stamp and 10 bits allocated to the event. The 22 + * bits are enough to get reliable time stamps on a system with a 4GHz CPU + * counter and a 1000Hz clock tick. + */ +#define RTEMS_RECORD_TIME_EVENT( time, event ) \ + ( ( ( time ) << RTEMS_RECORD_EVENT_BITS ) | ( event ) ) + +/** + * @brief Gets the time of a time event. + */ +#define RTEMS_RECORD_GET_TIME( time_event ) \ + ( ( time_event ) >> RTEMS_RECORD_EVENT_BITS ) + +/** + * @brief Gets the event of a time event. + */ +#define RTEMS_RECORD_GET_EVENT( time_event ) \ + ( ( time_event ) & ( ( 1U << RTEMS_RECORD_EVENT_BITS ) - 1U ) ) + +/** + * @brief The record data integer type. + * + * It is big enough to store 32-bit integers and pointers. + */ +typedef unsigned long rtems_record_data; + +/** + * @brief The native record item. + */ +typedef struct __attribute__((__packed__)) { + uint32_t event; + rtems_record_data data; +} rtems_record_item; + +/** + * @brief The 32-bit format record item. + */ +typedef struct { + uint32_t event; + uint32_t data; +} rtems_record_item_32; + +/** + * @brief The 64-bit format record item. + */ +typedef struct __attribute__((__packed__)) { + uint32_t event; + uint64_t data; +} rtems_record_item_64; + +const char *rtems_record_event_text( rtems_record_event event ); + +/** @} */ + +#ifdef __cplusplus +} +#endif /* __cplusplus */ + +#endif /* _RTEMS_RECORDDATA_H */ diff --git a/trace/wscript b/trace/wscript new file mode 100644 index 0000000..8b98bd6 --- /dev/null +++ b/trace/wscript @@ -0,0 +1,67 @@ +# +# RTEMS Tools Project (http://www.rtems.org/) +# Copyright 2014-2016 Chris Johns (chrisj@rtems.org) +# Copyright 2019 embedded brains GmbH +# All rights reserved. +# +# This file is part of the RTEMS Tools package in 'rtems-tools'. +# +# Permission to use, copy, modify, and/or distribute this software for any +# purpose with or without fee is hereby granted, provided that the above +# copyright notice and this permission notice appear in all copies. +# +# THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES +# WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF +# MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR +# ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES +# WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN +# ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF +# OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. +# + +# +# RTEMS miscellaneous build script. +# +import sys + +def init(ctx): + pass + +def options(opt): + opt.load('compiler_c') + +def configure(conf): + conf.load('compiler_c') + +def build(bld): + # + # The local configuration. + # + conf = {} + + # + # Build flags. + # + conf['warningflags'] = ['-Wall', '-Wextra', '-pedantic'] + conf['optflags'] = bld.env.C_OPTS + conf['cflags'] = ['-pipe', '-g'] + conf['optflags'] + conf['linkflags'] = ['-g'] + + # + # The list of defines + # + defines = ['RTEMS_VERSION=\"%s\"' % (bld.env.RTEMS_VERSION), + 'RTEMS_RELEASE=\"%s\"' % (bld.env.RTEMS_RELEASE)] + + # + # Build rtems-record-lttng + # + bld.program(target = 'rtems-record-lttng', + source = ['record/record-client.c', 'record/record-main-lttng.c', 'record/record-text.c'], + includes = ['record'], + defines = defines, + cflags = conf['cflags'] + conf['warningflags'], + linkflags = conf['linkflags']) + +def tags(ctx): + ctx.exec_command('etags $(find . -name \*.[sSch])', shell = True) -- cgit v1.2.3