LXR 6.1/​cpukit/​libmisc/​capture/​capture_support.c	Source navigation Diff markup Identifier search General search
	Version: 6.1 Revert   Change

File indexing completed on 2025-05-11 08:24:18

 /* SPDX-License-Identifier: BSD-2-Clause */
 
 /**
  * @file
  *
  * @brief RTEMS Performance Monitoring and Measurement Framework.
  *
  * This is a set of print support routines that may be shared between
  * the RTEMS monitor and direct callers of the capture engine.
  */
 
 /*
  * Copyright 2002, 2015 Chris Johns <chrisj@rtems.org>
  * All rights reserved.
  *
  * COPYRIGHT (c) 1989-2014.
  * On-Line Applications Research Corporation (OAR).
  *
  * 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.
  */
 
 #ifdef HAVE_CONFIG_H
 #include "config.h"
 #endif
 
 #include <ctype.h>
 #include <stdlib.h>
 #include <stdio.h>
 #include <string.h>
 #include <inttypes.h>
 
 #include <rtems.h>
 #include <rtems/monitor.h>
 #include <rtems/captureimpl.h>
 
 /*
  * Structure used during printing of the capture records.
  */
 
 typedef struct
 {
   const void*          recs;      /**< Next record to be read. */
   size_t               read;      /**< Number of records read. */
   size_t               printed;   /**< Records been printed. */
   bool                 rec_valid; /**< The record is valid. */
   rtems_capture_record rec;       /**< The record, copied out. */
 } ctrace_per_cpu;
 
 /*
  * Task block size.
  */
 #define CTRACE_TASK_BLOCK_SIZE (64)
 
 /**
  * Task details from the task records used to print task names.
  */
 typedef struct
 {
   rtems_name name;
   rtems_id   id;
 } ctrace_task_name;
 
 /**
  * Structure to hold the tasks variables.
  */
 typedef struct
 {
   ctrace_task_name* tasks;
   size_t            size;
   size_t            count;
 } ctrace_tasks;
 
 /*
  * Global so the records can span more than one trace.
  */
 static ctrace_tasks tasks;
 
 /*
  * Add a name.
  */
 static void
 ctrace_task_name_add (rtems_id id, const rtems_name name)
 {
   if (tasks.tasks == NULL)
   {
     tasks.size = CTRACE_TASK_BLOCK_SIZE;
     tasks.tasks = calloc (tasks.size, sizeof (ctrace_task_name));
   }
   if (tasks.tasks != NULL)
   {
     if (rtems_object_id_get_api(id) != OBJECTS_POSIX_API)
     {
       size_t t;
       for (t = 0; t < tasks.count; ++t)
       {
         if (tasks.tasks[t].id == id)
         {
           tasks.tasks[t].name = name;
           break;
         }
       }
       if (t == tasks.count)
       {
         if (tasks.count >= tasks.size)
         {
           tasks.size += CTRACE_TASK_BLOCK_SIZE;
           tasks.tasks = realloc (tasks.tasks,
                                  tasks.size * sizeof (ctrace_task_name));
         }
         if (tasks.tasks != NULL)
         {
           tasks.tasks[tasks.count].name = name;
           tasks.tasks[tasks.count].id = id;
           ++tasks.count;
         }
       }
     }
   }
 }
 
 /*
  * Remove a task name.
  */
 static void
 ctrace_task_name_remove (rtems_id id)
 {
   size_t t;
   for (t = 0; t < tasks.count; ++t)
   {
     if (tasks.tasks[t].id == id)
     {
       size_t count = tasks.count - t - 1;
       if (count != 0)
         memmove (&tasks.tasks[t],
                  &tasks.tasks[t + 1],
                  sizeof (ctrace_task_name) * count);
       --tasks.count;
       break;
     }
   }
 }
 
 /*
  * Find a name.
  */
 static void
 ctrace_task_name_find (rtems_id id, const rtems_name** name)
 {
   size_t t;
   *name = NULL;
   for (t = 0; t < tasks.count; ++t)
   {
     if (tasks.tasks[t].id == id)
     {
       *name = &tasks.tasks[t].name;
       break;
     }
   }
 }
 
 /*
  * rtems_catpure_print_uptime
  *
  * This function prints the nanosecond uptime to stdout.
  */
 void
 rtems_capture_print_timestamp (uint64_t uptime)
 {
   uint32_t hours;
   uint32_t minutes;
   uint32_t seconds;
   uint32_t nanosecs;
   uint64_t up_secs;
 
   up_secs  = uptime / 1000000000LLU;
   minutes  = up_secs / 60;
   hours    = minutes / 60;
   minutes  = minutes % 60;
   seconds  = up_secs % 60;
   nanosecs = uptime % 1000000000;
 
   fprintf (stdout, "%5" PRIu32 ":%02" PRIu32 ":%02" PRIu32".%09" PRIu32,
              hours, minutes, seconds, nanosecs);
 }
 
 void
 rtems_capture_print_record_task (int                              cpu,
                                  const rtems_capture_record*      rec,
                                  const rtems_capture_task_record* task_rec)
 {
   fprintf(stdout,"%2i ", cpu);
   rtems_capture_print_timestamp (rec->time);
   fprintf (stdout, "              ");
   rtems_monitor_dump_id (rec->task_id);
   if (rtems_object_id_get_api(rec->task_id) != OBJECTS_POSIX_API)
   {
     fprintf (stdout, " %c%c%c%c",
              (char) (task_rec->name >> 24) & 0xff,
              (char) (task_rec->name >> 16) & 0xff,
              (char) (task_rec->name >> 8) & 0xff,
              (char) (task_rec->name >> 0) & 0xff);
   }
   else
   {
     fprintf (stdout, " ____");
   }
   fprintf(stdout, " %3" PRId32 " %3" PRId32 " ",
              (rec->events >> RTEMS_CAPTURE_REAL_PRIORITY_EVENT) & 0xff,
              (rec->events >> RTEMS_CAPTURE_CURR_PRIORITY_EVENT) & 0xff);
    fprintf (stdout, "%3" PRId32   " %6" PRId32 "  TASK_RECORD\n",
             task_rec->start_priority,
             task_rec->stack_size);
 }
 
 void
 rtems_capture_print_record_capture(int                         cpu,
                                    const rtems_capture_record* rec,
                                    uint64_t                    diff,
                                    const rtems_name*           name)
 {
   uint32_t event;
   int      e;
 
   event = rec->events >> RTEMS_CAPTURE_EVENT_START;
   for (e = RTEMS_CAPTURE_EVENT_START; e < RTEMS_CAPTURE_EVENT_END; e++)
   {
     if (event & 1)
     {
       fprintf(stdout,"%2i ", cpu);
       rtems_capture_print_timestamp (rec->time);
       fprintf (stdout, " %12" PRId32 " ", (uint32_t) diff);
       rtems_monitor_dump_id (rec->task_id);
       if (name != NULL)
       {
         fprintf (stdout, " %c%c%c%c",
                  (char) (*name >> 24) & 0xff,
                  (char) (*name >> 16) & 0xff,
                  (char) (*name >> 8) & 0xff,
                  (char) (*name >> 0) & 0xff);
       }
       else
       {
         fprintf(stdout, "     ");
       }
       fprintf(stdout, " %3" PRId32 " %3" PRId32 "             %s\n",
              (rec->events >> RTEMS_CAPTURE_REAL_PRIORITY_EVENT) & 0xff,
              (rec->events >> RTEMS_CAPTURE_CURR_PRIORITY_EVENT) & 0xff,
              rtems_capture_event_text (e));
     }
     event >>= 1;
   }
 }
 
 /*
  * rtems_capture_print_trace_records
  *
  * This function is a monitor command that dumps trace records.
  */
 
 void
 rtems_capture_print_trace_records (int total, bool csv)
 {
   ctrace_per_cpu*    per_cpu;
   ctrace_per_cpu*    cpu;
   int                cpus;
   rtems_capture_time last_time = 0;
   int                i;
 
   cpus = rtems_scheduler_get_processor_maximum ();
 
   per_cpu = calloc (cpus, sizeof(*per_cpu));
   if (per_cpu == NULL)
   {
     fprintf(stdout, "error: no memory\n");
     return;
   }
 
   while (total)
   {
     const rtems_capture_record* rec_out = NULL;
     int                         cpu_out = -1;
     rtems_capture_time          this_time = 0;
 
     /* Prime the per_cpu data */
     for (i = 0; i < cpus; i++) {
       cpu = &per_cpu[i];
 
       if (cpu->read == 0)
       {
         rtems_status_code sc;
         sc = rtems_capture_read (i, &cpu->read, &cpu->recs);
         if (sc != RTEMS_SUCCESSFUL)
         {
           fprintf (stdout,
                    "error: trace read failed: %s\n", rtems_status_text (sc));
           rtems_capture_flush (0);
           free (per_cpu);
           return;
         }
         /* Release the buffer if there are no records to read */
         if (cpu->read == 0)
           rtems_capture_release (i, 0);
       }
 
       /* Read the record out from the capture buffer */
       if (!cpu->rec_valid && (cpu->read != 0))
       {
         cpu->recs = rtems_capture_record_extract (cpu->recs,
                                                   &cpu->rec,
                                                   sizeof (cpu->rec));
         cpu->rec_valid = true;
       }
 
       /* Find the next record to print, the earliest recond on any core */
       if ((cpu->rec_valid) && ((this_time == 0) || (cpu->rec.time < this_time)))
       {
         rec_out = &cpu->rec;
         cpu_out = i;
         this_time = rec_out->time;
       }
     }
 
     /*  If we have read all the records abort. */
     if (rec_out == NULL)
       break;
 
     cpu = &per_cpu[cpu_out];
 
     /* Print the record */
     if (csv)
     {
       fprintf(stdout,
               "%03i,%08" PRIu32 ",%03" PRIu32
               ",%03" PRIu32 ",%04" PRIx32 ",%" PRId64 "\n",
               cpu_out,
               (uint32_t) rec_out->task_id,
               (rec_out->events >> RTEMS_CAPTURE_REAL_PRIORITY_EVENT) & 0xff,
               (rec_out->events >> RTEMS_CAPTURE_CURR_PRIORITY_EVENT) & 0xff,
               (rec_out->events >> RTEMS_CAPTURE_EVENT_START),
               (uint64_t) rec_out->time);
     }
     else
     {
       if ((rec_out->events >> RTEMS_CAPTURE_EVENT_START) == 0)
       {
         rtems_capture_task_record task_rec;
         cpu->recs = rtems_capture_record_extract (cpu->recs,
                                                   &task_rec,
                                                   sizeof (task_rec));
         ctrace_task_name_add (rec_out->task_id, task_rec.name);
         rtems_capture_print_record_task (cpu_out, rec_out, &task_rec);
       }
       else
       {
         rtems_capture_time diff;
         const rtems_name*  name = NULL;
         if (last_time != 0)
           diff = rec_out->time - last_time;
         else
           diff = 0;
         last_time = rec_out->time;
         ctrace_task_name_find (rec_out->task_id, &name);
         rtems_capture_print_record_capture (cpu_out, rec_out, diff, name);
         if ((rec_out->events &
              (RTEMS_CAPTURE_DELETED_BY_EVENT | RTEMS_CAPTURE_DELETED_EVENT)) != 0)
           ctrace_task_name_remove (rec_out->task_id);
       }
     }
 
     /*
      * If we have not printed all the records read increment to the next
      * record. If we have printed all records release the records printed.
      */
     cpu->rec_valid = false;
     ++cpu->printed;
     if (cpu->printed == cpu->read)
     {
       rtems_capture_release (cpu_out, cpu->printed);
       cpu->recs = NULL;
       cpu->read = 0;
       cpu->printed = 0;
     }
 
     --total;
   }
 
   /* Finished so release all the records that were printed. */
   for (i = 0; i < cpus; i++)
   {
     cpu = &per_cpu[i];
     if (cpu->read != 0)
     {
       rtems_capture_release (i, cpu->printed);
     }
   }
 
   free(per_cpu);
 }
 
 void
 rtems_capture_print_watch_list (void)
 {
   rtems_capture_control* control = rtems_capture_get_control_list ();
   rtems_task_priority    ceiling = rtems_capture_watch_get_ceiling ();
   rtems_task_priority    floor = rtems_capture_watch_get_floor ();
 
   fprintf (stdout, "watch priority ceiling is %" PRId32 "\n", ceiling);
   fprintf (stdout, "watch priority floor is %" PRId32 "\n", floor);
   fprintf (stdout, "global watch is %s\n",
           rtems_capture_watch_global_on () ? "enabled" : "disabled");
   fprintf (stdout, "total %" PRId32 "\n", rtems_capture_control_count ());
 
   while (control)
   {
     uint32_t flags;
     int      f;
     int      fshowed;
     int      lf;
 
     fprintf (stdout, " ");
     rtems_monitor_dump_id (rtems_capture_control_id (control));
     fprintf (stdout, " ");
     rtems_monitor_dump_name (rtems_capture_control_name (control));
     flags = rtems_capture_control_flags (control);
     fprintf (stdout, " %c%c ",
              rtems_capture_watch_global_on () ? 'g' : '-',
              flags & RTEMS_CAPTURE_WATCH ? 'w' : '-');
     flags = rtems_capture_control_to_triggers (control);
     fprintf (stdout, " T:%c%c%c%c%c%c%c",
              flags & RTEMS_CAPTURE_SWITCH    ? 'S' : '-',
              flags & RTEMS_CAPTURE_CREATE ? 'C' : '-',
              flags & RTEMS_CAPTURE_START ? 'S' : '-',
              flags & RTEMS_CAPTURE_RESTART ? 'R' : '-',
              flags & RTEMS_CAPTURE_DELETE ? 'D' : '-',
              flags & RTEMS_CAPTURE_BEGIN ? 'B' : '-',
              flags & RTEMS_CAPTURE_EXITTED ? 'E' : '-');
     flags = rtems_capture_control_from_triggers (control);
     fprintf (stdout, " F:%c%c%c%c%c",
              flags & RTEMS_CAPTURE_SWITCH  ? 'S' : '-',
              flags & RTEMS_CAPTURE_CREATE  ? 'C' : '-',
              flags & RTEMS_CAPTURE_START   ? 'S' : '-',
              flags & RTEMS_CAPTURE_RESTART ? 'R' : '-',
              flags & RTEMS_CAPTURE_DELETE  ? 'D' : '-');
 
     for (f = 0, fshowed = 0, lf = 1; f < RTEMS_CAPTURE_TRIGGER_TASKS; f++)
     {
       if (rtems_capture_control_by_valid (control, f))
       {
         if (lf && ((fshowed % 3) == 0))
         {
           fprintf (stdout, "\n");
           lf = 0;
         }
 
         fprintf (stdout, "  %2i:", f);
         rtems_monitor_dump_name (rtems_capture_control_by_name (control, f));
         fprintf (stdout, "/");
         rtems_monitor_dump_id (rtems_capture_control_by_id (control, f));
         flags = rtems_capture_control_by_triggers (control, f);
         fprintf (stdout, ":%c%c%c%c%c",
                  flags & RTEMS_CAPTURE_SWITCH  ? 'S' : '-',
                  flags & RTEMS_CAPTURE_CREATE  ? 'C' : '-',
                  flags & RTEMS_CAPTURE_START   ? 'S' : '-',
                  flags & RTEMS_CAPTURE_RESTART ? 'R' : '-',
                  flags & RTEMS_CAPTURE_DELETE  ? 'D' : '-');
         fshowed++;
         lf = 1;
       }
     }
 
     if (lf)
       fprintf (stdout, "\n");
 
     control = rtems_capture_next_control (control);
   }
 }

This page was automatically generated by the 2.3.7 LXR engine. The LXR team