summaryrefslogtreecommitdiffstats
path: root/cpukit/libtrace/record/record-client.c
diff options
context:
space:
mode:
Diffstat (limited to 'cpukit/libtrace/record/record-client.c')
-rw-r--r--cpukit/libtrace/record/record-client.c448
1 files changed, 448 insertions, 0 deletions
diff --git a/cpukit/libtrace/record/record-client.c b/cpukit/libtrace/record/record-client.c
new file mode 100644
index 0000000000..585aa3895d
--- /dev/null
+++ b/cpukit/libtrace/record/record-client.c
@@ -0,0 +1,448 @@
+/*
+ * 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 <rtems/recordclient.h>
+
+#include <string.h>
+
+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
+)
+{
+ uint32_t seconds;
+ uint32_t nanosec;
+
+ seconds = (uint32_t) ( bt >> 32 );
+ nanosec = (uint32_t) ( ( UINT64_C( 1000000000 ) * (uint32_t) bt ) >> 32 );
+
+ return ( *ctx->handler )(
+ seconds,
+ nanosec,
+ ctx->cpu,
+ event,
+ data,
+ ctx->handler_arg
+ );
+}
+
+static void check_overflow(
+ const rtems_record_client_context *ctx,
+ const rtems_record_client_per_cpu *per_cpu,
+ uint32_t new_head
+)
+{
+ uint32_t last_tail;
+ uint32_t last_head;
+ uint32_t capacity;
+ uint32_t new_content;
+ uint64_t bt;
+
+ last_tail = per_cpu->tail[ per_cpu->index ];
+ last_head = per_cpu->head[ per_cpu->index ];
+
+ if ( last_tail == last_head ) {
+ return;
+ }
+
+ capacity = ( last_tail - last_head - 1 ) & ( ctx->count - 1 );
+ new_content = new_head - last_head;
+
+ if ( new_content <= capacity ) {
+ return;
+ }
+
+ bt = ( per_cpu->uptime.time_accumulated * ctx->to_bt_scaler ) >> 31;
+ bt += per_cpu->uptime.bt;
+
+ call_handler(
+ ctx,
+ bt,
+ RTEMS_RECORD_OVERFLOW,
+ new_content - capacity
+ );
+}
+
+static rtems_record_client_status visit( rtems_record_client_context *ctx )
+{
+ rtems_record_client_per_cpu *per_cpu;
+ uint32_t time;
+ rtems_record_event event;
+ uint64_t data;
+ uint64_t bt;
+
+ per_cpu = &ctx->per_cpu[ ctx->cpu ];
+ time = RTEMS_RECORD_GET_TIME( ctx->event );
+ event = RTEMS_RECORD_GET_EVENT( ctx->event );
+ data = ctx->data;
+
+ switch ( event ) {
+ case RTEMS_RECORD_PROCESSOR:
+ if ( data >= RTEMS_RECORD_CLIENT_MAXIMUM_CPU_COUNT ) {
+ return 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 += (int64_t) data << 32;
+ time = 0;
+ break;
+ case RTEMS_RECORD_TAIL:
+ per_cpu->tail[ per_cpu->index ] = (uint32_t) data;
+ break;
+ case RTEMS_RECORD_HEAD:
+ per_cpu->head[ per_cpu->index ]= (uint32_t) data;
+ per_cpu->index ^= 1;
+ check_overflow( ctx, per_cpu, (uint32_t) data );
+ break;
+ case RTEMS_RECORD_COUNT:
+ ctx->count = (uint32_t) data;
+ 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 RTEMS_RECORD_CLIENT_ERROR_UNSUPPORTED_VERSION;
+ }
+
+ break;
+ default:
+ break;
+ }
+
+ if ( time != 0 ) {
+ uint32_t delta;
+
+ delta = ( time - per_cpu->uptime.time_last )
+ & ( ( UINT32_C( 1 ) << RTEMS_RECORD_TIME_BITS ) - 1 );
+ 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 call_handler( ctx, bt, 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;
+ ctx->event = ctx->item.format_32.event;
+ ctx->data = ctx->item.format_32.data;
+
+ status = visit( ctx );
+
+ 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;
+ ctx->event = ctx->item.format_64.event;
+ ctx->data = ctx->item.format_64.data;
+
+ status = visit( ctx );
+
+ 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;
+ ctx->event = __builtin_bswap32( ctx->item.format_32.event );
+ ctx->data = __builtin_bswap32( ctx->item.format_32.data );
+
+ status = visit( ctx );
+
+ 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;
+ ctx->event = __builtin_bswap32( ctx->item.format_64.event );
+ ctx->data = __builtin_bswap64( ctx->item.format_64.data );
+
+ status = visit( ctx );
+
+ 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 RTEMS_RECORD_CLIENT_ERROR_UNKNOWN_FORMAT;
+ }
+
+ if ( magic != RTEMS_RECORD_MAGIC ) {
+ return 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 );
+}
generated by cgit v1.2.3 (git 2.25.1) at 2024-05-02 11:13:06 +0000