Index: cpukit/libmisc/capture/capture-cli.c
===================================================================
--- cpukit/libmisc/capture/capture-cli.c	(revision 6da06c559f17f33177f59c0f83164bb2d20c8b9f)
+++ cpukit/libmisc/capture/capture-cli.c	(revision 1c18ebf0d637bea1101c4b16e3844103524a5281)
@@ -112,5 +112,5 @@
     return;
 
-  sc = rtems_capture_control (enable);
+  sc = rtems_capture_set_control (enable);
 
   if (sc != RTEMS_SUCCESSFUL)
@@ -162,5 +162,5 @@
   rtems_status_code sc;
 
-  sc = rtems_capture_control (true);
+  sc = rtems_capture_set_control (true);
 
   if (sc != RTEMS_SUCCESSFUL)
@@ -187,5 +187,5 @@
   rtems_status_code sc;
 
-  sc = rtems_capture_control (false);
+  sc = rtems_capture_set_control (false);
 
   if (sc != RTEMS_SUCCESSFUL)
@@ -271,7 +271,7 @@
                              bool                               verbose RC_UNUSED)
 {
-  rtems_capture_time_t  uptime;
-
-  rtems_capture_time (&uptime);
+  rtems_capture_time uptime;
+
+  rtems_capture_get_time (&uptime);
 
   rtems_capture_cli_task_count = 0;
@@ -711,12 +711,12 @@
  * Structure to handle the parsing of the trigger command line.
  */
-typedef struct rtems_capture_cli_triggers_s
-{
-  char const *            name;
-  rtems_capture_trigger_t type;
-  int                     to_only;
-} rtems_capture_cli_triggers_t;
-
-static rtems_capture_cli_triggers_t rtems_capture_cli_triggers[] =
+typedef struct rtems_capture_cli_triggers
+{
+  char const *          name;
+  rtems_capture_trigger type;
+  int                   to_only;
+} rtems_capture_cli_triggers;
+
+static const rtems_capture_cli_triggers rtems_capture_cli_trigger[] =
 {
   { "switch",  rtems_capture_switch,  0 }, /* must be first */
@@ -729,5 +729,5 @@
 };
 
-typedef enum rtems_capture_cli_trig_state_e
+typedef enum rtems_capture_cli_trig_state
 {
   trig_type,
@@ -735,31 +735,31 @@
   trig_from_from,
   trig_from
-} rtems_capture_cli_trig_state_t;
+} rtems_capture_cli_trig_state;
 
 #define RTEMS_CAPTURE_CLI_TRIGGERS_NUM \
-  (sizeof (rtems_capture_cli_triggers) / sizeof (rtems_capture_cli_triggers_t))
+  (sizeof (rtems_capture_cli_trigger) / sizeof (rtems_capture_cli_triggers))
 
 static void
 rtems_capture_cli_trigger_worker (int set, int argc, char** argv)
 {
-  rtems_status_code            sc;
-  int                          arg;
-  int                          trigger = 0; /* switch */
-  rtems_capture_trigger_mode_t trigger_mode = rtems_capture_from_any;
-  bool                         trigger_set = false;
-  bool                         is_from = false;
-  bool                         is_to = false;
-  rtems_name                   name = 0;
-  rtems_id                     id = 0;
-  bool                         valid_name = false;
-  bool                         valid_id = false;
-  rtems_name                   from_name = 0;
-  rtems_id                     from_id = 0;
-  bool                         from_valid_name = false;
-  bool                         from_valid_id = false;
-  rtems_name                   to_name = 0;
-  rtems_id                     to_id = 0;
-  bool                         to_valid_name = false;
-  bool                         to_valid_id = false;
+  rtems_status_code          sc;
+  int                        arg;
+  int                        trigger = 0; /* switch */
+  rtems_capture_trigger_mode trigger_mode = rtems_capture_from_any;
+  bool                       trigger_set = false;
+  bool                       is_from = false;
+  bool                       is_to = false;
+  rtems_name                 name = 0;
+  rtems_id                   id = 0;
+  bool                       valid_name = false;
+  bool                       valid_id = false;
+  rtems_name                 from_name = 0;
+  rtems_id                   from_id = 0;
+  bool                       from_valid_name = false;
+  bool                       from_valid_id = false;
+  rtems_name                 to_name = 0;
+  rtems_id                   to_id = 0;
+  bool                       to_valid_name = false;
+  bool                       to_valid_id = false;
 
   for (arg = 1; arg < argc; arg++)
@@ -786,5 +786,5 @@
 
         for (t = 0; t < RTEMS_CAPTURE_CLI_TRIGGERS_NUM; t++)
-          if (strcmp (argv[arg], rtems_capture_cli_triggers[t].name) == 0)
+          if (strcmp (argv[arg], rtems_capture_cli_trigger[t].name) == 0)
           {
             trigger = t;
@@ -875,8 +875,8 @@
   }
 
-  if (is_from && rtems_capture_cli_triggers[trigger].to_only)
+  if (is_from && rtems_capture_cli_trigger[trigger].to_only)
   {
     fprintf (stdout, "error: a %s trigger can be a TO trigger\n",
-             rtems_capture_cli_triggers[trigger].name);
+             rtems_capture_cli_trigger[trigger].name);
     return;
   }
@@ -891,5 +891,5 @@
   {
     fprintf (stdout, "error: a %s trigger needs a TO name or id\n",
-             rtems_capture_cli_triggers[trigger].name);
+             rtems_capture_cli_trigger[trigger].name);
     return;
   }
@@ -898,5 +898,5 @@
   {
     fprintf (stdout, "error: a %s trigger needs a FROM name or id\n",
-             rtems_capture_cli_triggers[trigger].name);
+             rtems_capture_cli_trigger[trigger].name);
     return;
   }
@@ -912,9 +912,9 @@
     sc = rtems_capture_set_trigger (from_name, from_id, to_name, to_id,
                                     trigger_mode,
-                                    rtems_capture_cli_triggers[trigger].type);
+                                    rtems_capture_cli_trigger[trigger].type);
   else
     sc = rtems_capture_clear_trigger (from_name, from_id, to_name, to_id,
                                       trigger_mode,
-                                      rtems_capture_cli_triggers[trigger].type);
+                                      rtems_capture_cli_trigger[trigger].type);
 
   if (sc != RTEMS_SUCCESSFUL)
@@ -1193,5 +1193,5 @@
        cmd < sizeof (rtems_capture_cli_cmds) / sizeof (rtems_monitor_command_entry_t);
        cmd++)
-      rtems_monitor_insert_cmd (&rtems_capture_cli_cmds[cmd]);
+    rtems_monitor_insert_cmd (&rtems_capture_cli_cmds[cmd]);
 
   return RTEMS_SUCCESSFUL;
Index: cpukit/libmisc/capture/capture.c
===================================================================
--- cpukit/libmisc/capture/capture.c	(revision 6da06c559f17f33177f59c0f83164bb2d20c8b9f)
+++ cpukit/libmisc/capture/capture.c	(revision 1c18ebf0d637bea1101c4b16e3844103524a5281)
@@ -57,19 +57,19 @@
 
 typedef struct {
-  rtems_capture_buffer_t   records;
-  uint32_t                 count;
-  rtems_id                 reader;
-  rtems_interrupt_lock     lock;
-  uint32_t                 flags;
+  rtems_capture_buffer records;
+  uint32_t             count;
+  rtems_id             reader;
+  rtems_interrupt_lock lock;
+  uint32_t             flags;
 } rtems_capture_per_cpu_data;
 
 typedef struct {
-  uint32_t                 flags;
-  rtems_capture_control_t* controls;
-  int                      extension_index;
-  rtems_capture_timestamp  timestamp;
-  rtems_task_priority      ceiling;
-  rtems_task_priority      floor;
-  rtems_interrupt_lock     lock;
+  uint32_t                flags;
+  rtems_capture_control*  controls;
+  int                     extension_index;
+  rtems_capture_timestamp timestamp;
+  rtems_task_priority     ceiling;
+  rtems_task_priority     floor;
+  rtems_interrupt_lock    lock;
 } rtems_capture_global_data;
 
@@ -146,5 +146,5 @@
  */
 void
-rtems_capture_get_time (rtems_capture_time_t* time)
+rtems_capture_get_time (rtems_capture_time* time)
 {
   if (capture_timestamp)
@@ -222,7 +222,7 @@
  */
 static inline bool
-rtems_capture_by_in_to (uint32_t                 events,
-                        rtems_tcb*               by,
-                        rtems_capture_control_t* to)
+rtems_capture_by_in_to (uint32_t               events,
+                        rtems_tcb*             by,
+                        rtems_capture_control* to)
 {
   uint32_t valid_mask = RTEMS_CAPTURE_CONTROL_FROM_MASK (0);
@@ -266,8 +266,8 @@
  * This function searches for a trigger given a name.
  */
-static inline rtems_capture_control_t*
+static inline rtems_capture_control*
 rtems_capture_find_control (rtems_name name, rtems_id id)
 {
-  rtems_capture_control_t* control;
+  rtems_capture_control* control;
   for (control = capture_controls; control != NULL; control = control->next)
     if (rtems_capture_match_name_id (name, id, control->name, control->id))
@@ -285,7 +285,7 @@
   if (tcb->Capture.control == NULL)
   {
-    rtems_name               name = rtems_build_name(0, 0, 0, 0);
-    rtems_id                 id;
-    rtems_capture_control_t* control;
+    rtems_name             name = rtems_build_name(0, 0, 0, 0);
+    rtems_id               id;
+    rtems_capture_control* control;
 
     /*
@@ -308,9 +308,9 @@
 }
 
-static rtems_capture_control_t*
+static rtems_capture_control*
 rtems_capture_create_control (rtems_name name, rtems_id id)
 {
   rtems_interrupt_lock_context lock_context;
-  rtems_capture_control_t*     control;
+  rtems_capture_control*       control;
 
   if ((name == 0) && (id == 0))
@@ -376,5 +376,5 @@
   uint8_t*                    ptr;
 
-  size += sizeof (rtems_capture_record_t);
+  size += sizeof (rtems_capture_record);
 
   cpu = capture_per_cpu_get (rtems_get_current_processor ());
@@ -385,5 +385,5 @@
   if (ptr != NULL)
   {
-    rtems_capture_record_t in;
+    rtems_capture_record in;
 
     ++cpu->count;
@@ -420,5 +420,5 @@
 rtems_capture_initialize_task( rtems_tcb* tcb )
 {
-  rtems_capture_control_t*     control;
+  rtems_capture_control*       control;
   rtems_name                   name = rtems_build_name(0, 0, 0, 0);
   rtems_id                     id = rtems_capture_task_id (tcb);
@@ -450,5 +450,5 @@
   rtems_name                        name = rtems_build_name (0, 0, 0, 0);
   rtems_id                          id = rtems_capture_task_id (tcb);
-  rtems_capture_task_record_t       rec;
+  rtems_capture_task_record         rec;
   void*                             ptr;
   rtems_interrupt_lock_context      lock_context;
@@ -487,5 +487,5 @@
        RTEMS_CAPTURE_TRIGGERED))
   {
-    rtems_capture_control_t* control;
+    rtems_capture_control* control;
 
     control = tcb->Capture.control;
@@ -514,5 +514,5 @@
  */
 bool
-rtems_capture_trigger (rtems_tcb* ft, rtems_tcb* tt, uint32_t events)
+rtems_capture_trigger_fired (rtems_tcb* ft, rtems_tcb* tt, uint32_t events)
 {
   /*
@@ -521,9 +521,9 @@
   if (!(capture_flags_global & RTEMS_CAPTURE_TRIGGERED))
   {
-    rtems_capture_control_t* fc = NULL;
-    rtems_capture_control_t* tc = NULL;
-    uint32_t                 from_events = 0;
-    uint32_t                 to_events = 0;
-    uint32_t                 from_to_events = 0;
+    rtems_capture_control* fc = NULL;
+    rtems_capture_control* tc = NULL;
+    uint32_t               from_events = 0;
+    uint32_t               to_events = 0;
+    uint32_t               from_to_events = 0;
 
     if (ft)
@@ -583,8 +583,8 @@
 rtems_capture_open (uint32_t   size, rtems_capture_timestamp timestamp RTEMS_UNUSED)
 {
-  rtems_status_code       sc = RTEMS_SUCCESSFUL;
-  size_t                  count;
-  uint32_t                i;
-  rtems_capture_buffer_t* buff;
+  rtems_status_code     sc = RTEMS_SUCCESSFUL;
+  size_t                count;
+  uint32_t              i;
+  rtems_capture_buffer* buff;
 
   /*
@@ -640,5 +640,5 @@
 {
   rtems_interrupt_lock_context lock_context;
-  rtems_capture_control_t*     control;
+  rtems_capture_control*       control;
   rtems_status_code            sc;
   uint32_t                     cpu;
@@ -677,5 +677,5 @@
   while (control)
   {
-    rtems_capture_control_t* delete = control;
+    rtems_capture_control* delete = control;
     control = control->next;
     free (delete);
@@ -697,5 +697,5 @@
 
 rtems_status_code
-rtems_capture_control (bool enable)
+rtems_capture_set_control (bool enable)
 {
   rtems_interrupt_lock_context lock_context;
@@ -725,5 +725,5 @@
  */
 rtems_status_code
-rtems_capture_monitor (bool enable)
+rtems_capture_set_monitor (bool enable)
 {
   rtems_interrupt_lock_context lock_context;
@@ -812,5 +812,5 @@
 rtems_capture_watch_add (rtems_name name, rtems_id id)
 {
-  rtems_capture_control_t* control;
+  rtems_capture_control* control;
 
   if ( (capture_flags_global & RTEMS_CAPTURE_ON) != 0 )
@@ -844,6 +844,6 @@
 {
   rtems_interrupt_lock_context lock_context;
-  rtems_capture_control_t*     control;
-  rtems_capture_control_t**    prev_control;
+  rtems_capture_control*       control;
+  rtems_capture_control**      prev_control;
   bool                         found = false;
 
@@ -893,5 +893,5 @@
 {
   rtems_interrupt_lock_context lock_context;
-  rtems_capture_control_t*     control;
+  rtems_capture_control*       control;
   bool                         found = false;
 
@@ -1009,5 +1009,5 @@
  */
 static uint32_t
-rtems_capture_map_trigger (rtems_capture_trigger_t trigger)
+rtems_capture_map_trigger (rtems_capture_trigger trigger)
 {
   /*
@@ -1050,13 +1050,13 @@
  */
 rtems_status_code
-rtems_capture_set_trigger (rtems_name                   from_name,
-                           rtems_id                     from_id,
-                           rtems_name                   to_name,
-                           rtems_id                     to_id,
-                           rtems_capture_trigger_mode_t mode,
-                           rtems_capture_trigger_t      trigger)
-{
-  rtems_capture_control_t* control;
-  uint32_t                 flags;
+rtems_capture_set_trigger (rtems_name                 from_name,
+                           rtems_id                   from_id,
+                           rtems_name                 to_name,
+                           rtems_id                   to_id,
+                           rtems_capture_trigger_mode mode,
+                           rtems_capture_trigger      trigger)
+{
+  rtems_capture_control* control;
+  uint32_t               flags;
 
   flags = rtems_capture_map_trigger (trigger);
@@ -1128,13 +1128,13 @@
  */
 rtems_status_code
-rtems_capture_clear_trigger (rtems_name                   from_name,
-                             rtems_id                     from_id,
-                             rtems_name                   to_name,
-                             rtems_id                     to_id,
-                             rtems_capture_trigger_mode_t mode,
-                             rtems_capture_trigger_t      trigger)
-{
-  rtems_capture_control_t* control;
-  uint32_t                 flags;
+rtems_capture_clear_trigger (rtems_name                 from_name,
+                             rtems_id                   from_id,
+                             rtems_name                 to_name,
+                             rtems_id                   to_id,
+                             rtems_capture_trigger_mode mode,
+                             rtems_capture_trigger      trigger)
+{
+  rtems_capture_control* control;
+  uint32_t               flags;
 
   flags = rtems_capture_map_trigger (trigger);
@@ -1203,5 +1203,5 @@
   while (bytes < size)
   {
-    const rtems_capture_record_t* rec = (const rtems_capture_record_t*) ptr;
+    const rtems_capture_record* rec = (const rtems_capture_record*) ptr;
     recs++;
     ptr += rec->size;
@@ -1235,5 +1235,5 @@
     rtems_interrupt_lock_context lock_context;
     size_t                       recs_size = 0;
-    rtems_capture_buffer_t*      records;
+    rtems_capture_buffer*        records;
     uint32_t*                    flags;
 
@@ -1288,10 +1288,10 @@
     rtems_interrupt_lock_context lock_context;
     uint8_t*                     ptr;
-    rtems_capture_record_t*      rec;
+    rtems_capture_record*        rec;
     uint32_t                     counted;
     size_t                       ptr_size = 0;
     size_t                       rel_size = 0;
     RTEMS_INTERRUPT_LOCK_REFERENCE( lock, &(capture_lock_on_cpu( cpu )) )
-    rtems_capture_buffer_t*      records = &(capture_records_on_cpu( cpu ));
+    rtems_capture_buffer*        records = &(capture_records_on_cpu( cpu ));
     uint32_t*                    flags = &(capture_flags_on_cpu( cpu ));
     uint32_t*                    total = &(capture_count_on_cpu( cpu ));
@@ -1317,5 +1317,5 @@
     rel_size = 0;
     while (counted--) {
-      rec = (rtems_capture_record_t*) ptr;
+      rec = (rtems_capture_record*) ptr;
       rel_size += rec->size;
       _Assert( rel_size <= ptr_size );
@@ -1343,14 +1343,4 @@
 
 /*
- * This function returns the current time. If a handler is provided
- * by the user get the time from that.
- */
-void
-rtems_capture_time (rtems_capture_time_t* uptime)
-{
-  rtems_capture_get_time(uptime);
-}
-
-/*
  * This function returns a string for an event based on the bit in the
  * event. The functions takes the bit offset as a number not the bit
@@ -1369,5 +1359,5 @@
  * capture engine.
  */
-rtems_capture_control_t*
+rtems_capture_control*
 rtems_capture_get_control_list (void)
 {
Index: cpukit/libmisc/capture/capture.h
===================================================================
--- cpukit/libmisc/capture/capture.h	(revision 6da06c559f17f33177f59c0f83164bb2d20c8b9f)
+++ cpukit/libmisc/capture/capture.h	(revision 1c18ebf0d637bea1101c4b16e3844103524a5281)
@@ -76,5 +76,5 @@
  * This is a nanosecond capture timestamp
  */
-typedef uint64_t rtems_capture_time_t;
+typedef uint64_t rtems_capture_time;
 
 /**
@@ -87,10 +87,10 @@
  * structure has the specific *_BY bit set.
  */
-typedef struct rtems_capture_from_s
+typedef struct rtems_capture_from
 {
   rtems_name name;
   rtems_id   id;
   uint32_t   trigger;
-} rtems_capture_from_t;
+} rtems_capture_from;
 
 /**
@@ -105,16 +105,16 @@
  * in by are valid.
  */
-typedef struct rtems_capture_control_s
-{
-  rtems_name                      name;
-  rtems_id                        id;
-  uint32_t                        flags;
-  uint32_t                        to_triggers;
-  uint32_t                        from_triggers;
-  uint32_t                        by_triggers;
-  uint32_t                        by_valid;
-  rtems_capture_from_t            by[RTEMS_CAPTURE_TRIGGER_TASKS];
-  struct rtems_capture_control_s* next;
-} rtems_capture_control_t;
+typedef struct rtems_capture_control
+{
+  rtems_name                    name;
+  rtems_id                      id;
+  uint32_t                      flags;
+  uint32_t                      to_triggers;
+  uint32_t                      from_triggers;
+  uint32_t                      by_triggers;
+  uint32_t                      by_valid;
+  rtems_capture_from            by[RTEMS_CAPTURE_TRIGGER_TASKS];
+  struct rtems_capture_control* next;
+} rtems_capture_control;
 
 /**
@@ -169,11 +169,11 @@
  * at the time of the context switch.
  */
-typedef struct rtems_capture_record_s
-{
-  size_t                size;
-  uint32_t              events;
-  rtems_capture_time_t  time;
-  rtems_id              task_id;
-} RTEMS_PACKED rtems_capture_record_t;
+typedef struct rtems_capture_record
+{
+  size_t             size;
+  uint32_t           events;
+  rtems_capture_time time;
+  rtems_id           task_id;
+} RTEMS_PACKED rtems_capture_record;
 
 /*
@@ -184,10 +184,10 @@
  * at the time of the context switch.
  */
-typedef struct rtems_capture_task_record_s
+typedef struct rtems_capture_task_record
 {
   rtems_name          name;
   rtems_task_priority start_priority;
   uint32_t            stack_size;
-} RTEMS_PACKED rtems_capture_task_record_t;
+} RTEMS_PACKED rtems_capture_task_record;
 
 /**
@@ -220,10 +220,10 @@
  * The types of trigger modes that exist.
  */
-typedef enum rtems_capture_trigger_mode_e
+typedef enum rtems_capture_trigger_mode
 {
   rtems_capture_to_any,
   rtems_capture_from_any,
   rtems_capture_from_to
-} rtems_capture_trigger_mode_t;
+} rtems_capture_trigger_mode;
 
 /**
@@ -232,5 +232,5 @@
  * The types of triggers that exist.
  */
-typedef enum rtems_capture_trigger_e
+typedef enum rtems_capture_trigger
 {
   rtems_capture_switch,
@@ -242,5 +242,5 @@
   rtems_capture_exitted,
   rtems_capture_terminated
-} rtems_capture_trigger_t;
+} rtems_capture_trigger;
 
 /**
@@ -252,5 +252,5 @@
  */
 
-typedef void (*rtems_capture_timestamp)(rtems_capture_time_t* time);
+typedef void (*rtems_capture_timestamp)(rtems_capture_time* time);
 
 /**
@@ -314,5 +314,5 @@
  *         source of the error.
  */
-rtems_status_code rtems_capture_control (bool enable);
+rtems_status_code rtems_capture_set_control (bool enable);
 
 /**
@@ -329,5 +329,5 @@
  *         source of the error.
  */
-rtems_status_code rtems_capture_monitor (bool enable);
+rtems_status_code rtems_capture_set_monitor (bool enable);
 
 /*
@@ -504,10 +504,10 @@
  */
 rtems_status_code
-rtems_capture_set_trigger (rtems_name                   from_name,
-                           rtems_id                     from_id,
-                           rtems_name                   to_name,
-                           rtems_id                     to_id,
-                           rtems_capture_trigger_mode_t mode,
-                           rtems_capture_trigger_t      trigger);
+rtems_capture_set_trigger (rtems_name                 from_name,
+                           rtems_id                   from_id,
+                           rtems_name                 to_name,
+                           rtems_id                   to_id,
+                           rtems_capture_trigger_mode mode,
+                           rtems_capture_trigger      trigger);
 
 /**
@@ -530,10 +530,10 @@
  */
 rtems_status_code
-rtems_capture_clear_trigger (rtems_name                   from_name,
-                             rtems_id                     from_id,
-                             rtems_name                   to_name,
-                             rtems_id                     to_id,
-                             rtems_capture_trigger_mode_t mode,
-                             rtems_capture_trigger_t      trigger);
+rtems_capture_clear_trigger (rtems_name                 from_name,
+                             rtems_id                   from_id,
+                             rtems_name                 to_name,
+                             rtems_id                   to_id,
+                             rtems_capture_trigger_mode mode,
+                             rtems_capture_trigger      trigger);
 
 /**
@@ -579,13 +579,4 @@
 rtems_status_code rtems_capture_release (uint32_t cpu, uint32_t count);
 
-/*
- * @brief Capture nano-second time period.
- *
- * This function returns the time period in nano-seconds.
- *
- * @param[out] uptime The nano-second time period.
- */
-void rtems_capture_time (rtems_capture_time_t* uptime);
-
 /**
  * @brief Capture filter
@@ -613,5 +604,5 @@
  * is provided.  Otherwise, it returns a resolution defined by the handler.
  */
-void rtems_capture_get_time (rtems_capture_time_t* time);
+void rtems_capture_get_time (rtems_capture_time* time);
 
 /**
@@ -635,5 +626,5 @@
  * @param[in] tcb is the task control block for the task
  */
-void rtems_capture_initialize_task( rtems_tcb* tcb );
+void rtems_capture_initialize_task (rtems_tcb* tcb);
 
 /**
@@ -644,5 +635,5 @@
  * @param[in] tcb is the task control block for the task
  */
-void rtems_capture_record_task( rtems_tcb* tcb );
+void rtems_capture_record_task (rtems_tcb* tcb);
 
 /**
@@ -740,6 +731,6 @@
  * @param[in] tcb is the task control block for the task
  */
-static inline bool rtems_capture_task_recorded( rtems_tcb* tcb ) {
-  return ( (tcb->Capture.flags & RTEMS_CAPTURE_RECORD_TASK) != 0 );
+static inline bool rtems_capture_task_recorded (rtems_tcb* tcb) {
+  return ((tcb->Capture.flags & RTEMS_CAPTURE_RECORD_TASK) != 0);
 }
 
@@ -752,6 +743,6 @@
  * @param[in] tcb is the task control block for the task
  */
-static inline bool rtems_capture_task_initialized( rtems_tcb* tcb ) {
-  return ( (tcb->Capture.flags & RTEMS_CAPTURE_INIT_TASK) != 0 );
+static inline bool rtems_capture_task_initialized (rtems_tcb* tcb) {
+  return ((tcb->Capture.flags & RTEMS_CAPTURE_INIT_TASK) != 0);
 }
 
@@ -844,5 +835,5 @@
  * @retval This function returns the task control if present.
  */
-static inline rtems_capture_control_t*
+static inline rtems_capture_control*
 rtems_capture_task_control (rtems_tcb* tcb)
 {
@@ -862,5 +853,5 @@
 rtems_capture_task_control_flags (rtems_tcb* tcb)
 {
-  rtems_capture_control_t*  control = tcb->Capture.control;
+  rtems_capture_control*  control = tcb->Capture.control;
   if (!control)
     return 0;
@@ -925,5 +916,5 @@
  * capture engine.
  */
-rtems_capture_control_t*
+rtems_capture_control*
 rtems_capture_get_control_list (void);
 
@@ -939,6 +930,6 @@
  * pointer NULL terminates the list.
  */
-static inline rtems_capture_control_t*
-rtems_capture_next_control (rtems_capture_control_t* control)
+static inline rtems_capture_control*
+rtems_capture_next_control (rtems_capture_control* control)
 {
   return control->next;
@@ -955,5 +946,5 @@
  */
 static inline rtems_id
-rtems_capture_control_id (rtems_capture_control_t* control)
+rtems_capture_control_id (rtems_capture_control* control)
 {
   return control->id;
@@ -970,5 +961,5 @@
  */
 static inline rtems_name
-rtems_capture_control_name (rtems_capture_control_t* control)
+rtems_capture_control_name (rtems_capture_control* control)
 {
   return control->name;
@@ -985,5 +976,5 @@
  */
 static inline uint32_t
-rtems_capture_control_flags (rtems_capture_control_t* control)
+rtems_capture_control_flags (rtems_capture_control* control)
 {
   return control->flags;
@@ -1000,5 +991,5 @@
  */
 static inline uint32_t
-rtems_capture_control_to_triggers (rtems_capture_control_t* control)
+rtems_capture_control_to_triggers (rtems_capture_control* control)
 {
   return control->to_triggers;
@@ -1015,5 +1006,5 @@
  */
 static inline uint32_t
-rtems_capture_control_from_triggers (rtems_capture_control_t* control)
+rtems_capture_control_from_triggers (rtems_capture_control* control)
 {
   return control->from_triggers;
@@ -1030,5 +1021,5 @@
  */
 static inline uint32_t
-rtems_capture_control_all_by_triggers (rtems_capture_control_t* control)
+rtems_capture_control_all_by_triggers (rtems_capture_control* control)
 {
   return control->by_triggers;
@@ -1046,5 +1037,5 @@
  */
 static inline int
-rtems_capture_control_by_valid (rtems_capture_control_t* control, int slot)
+rtems_capture_control_by_valid (rtems_capture_control* control, int slot)
 {
   return control->by_valid & RTEMS_CAPTURE_CONTROL_FROM_MASK (slot);
@@ -1062,5 +1053,5 @@
  */
 static inline rtems_name
-rtems_capture_control_by_name (rtems_capture_control_t* control, int by)
+rtems_capture_control_by_name (rtems_capture_control* control, int by)
 {
   if (by < RTEMS_CAPTURE_TRIGGER_TASKS)
@@ -1077,5 +1068,5 @@
  */
 static inline rtems_id
-rtems_capture_control_by_id (rtems_capture_control_t* control, int by)
+rtems_capture_control_by_id (rtems_capture_control* control, int by)
 {
   if (by < RTEMS_CAPTURE_TRIGGER_TASKS)
@@ -1092,5 +1083,5 @@
  */
 static inline uint32_t
-rtems_capture_control_by_triggers (rtems_capture_control_t* control,
+rtems_capture_control_by_triggers (rtems_capture_control* control,
                                    int                      by)
 {
@@ -1112,6 +1103,6 @@
 rtems_capture_control_count (void)
 {
-  rtems_capture_control_t* control = rtems_capture_get_control_list ();
-  uint32_t                 count = 0;
+  rtems_capture_control* control = rtems_capture_get_control_list ();
+  uint32_t               count = 0;
 
   while (control)
Index: cpukit/libmisc/capture/capture_buffer.c
===================================================================
--- cpukit/libmisc/capture/capture_buffer.c	(revision 6da06c559f17f33177f59c0f83164bb2d20c8b9f)
+++ cpukit/libmisc/capture/capture_buffer.c	(revision 1c18ebf0d637bea1101c4b16e3844103524a5281)
@@ -28,5 +28,5 @@
 
 void*
-rtems_capture_buffer_allocate (rtems_capture_buffer_t* buffer, size_t size)
+rtems_capture_buffer_allocate (rtems_capture_buffer* buffer, size_t size)
 {
   void* ptr = NULL;
@@ -96,9 +96,9 @@
 
 void*
-rtems_capture_buffer_free (rtems_capture_buffer_t* buffer, size_t size)
+rtems_capture_buffer_free (rtems_capture_buffer* buffer, size_t size)
 {
-  void   *ptr;
-  size_t  next;
-  size_t  buff_size;
+  void*  ptr;
+  size_t next;
+  size_t buff_size;
 
   if (size == 0)
Index: cpukit/libmisc/capture/capture_buffer.h
===================================================================
--- cpukit/libmisc/capture/capture_buffer.h	(revision 6da06c559f17f33177f59c0f83164bb2d20c8b9f)
+++ cpukit/libmisc/capture/capture_buffer.h	(revision 1c18ebf0d637bea1101c4b16e3844103524a5281)
@@ -37,5 +37,5 @@
  * Capture buffer. There is one per CPU.
  */
-typedef struct {
+typedef struct rtems_capture_buffer {
   uint8_t* buffer;       /**< The per cpu buffer. */
   size_t   size;         /**< The size of the buffer in bytes. */
@@ -45,8 +45,8 @@
   size_t   end;          /**< Buffer current end, it may move in. */
   size_t   max_rec;      /**< The largest record in the buffer. */
-} rtems_capture_buffer_t;
+} rtems_capture_buffer;
 
 static inline void
-rtems_capture_buffer_flush (rtems_capture_buffer_t* buffer)
+rtems_capture_buffer_flush (rtems_capture_buffer* buffer)
 {
   buffer->end = buffer->size;
@@ -57,5 +57,5 @@
 
 static inline void
-rtems_capture_buffer_create (rtems_capture_buffer_t* buffer, size_t size)
+rtems_capture_buffer_create (rtems_capture_buffer* buffer, size_t size)
 {
   buffer->buffer = malloc(size);
@@ -65,5 +65,5 @@
 
 static inline void
-rtems_capture_buffer_destroy (rtems_capture_buffer_t*  buffer)
+rtems_capture_buffer_destroy (rtems_capture_buffer*  buffer)
 {
   rtems_capture_buffer_flush (buffer);
@@ -73,5 +73,5 @@
 
 static inline bool
-rtems_capture_buffer_is_empty (rtems_capture_buffer_t* buffer)
+rtems_capture_buffer_is_empty (rtems_capture_buffer* buffer)
 {
    return buffer->count == 0;
@@ -79,5 +79,5 @@
 
 static inline bool
-rtems_capture_buffer_is_full (rtems_capture_buffer_t* buffer)
+rtems_capture_buffer_is_full (rtems_capture_buffer* buffer)
 {
    return buffer->count == buffer->size;
@@ -85,5 +85,5 @@
 
 static inline bool
-rtems_capture_buffer_has_wrapped (rtems_capture_buffer_t* buffer)
+rtems_capture_buffer_has_wrapped (rtems_capture_buffer* buffer)
 {
   if (buffer->tail > buffer->head)
@@ -94,5 +94,5 @@
 
 static inline void*
-rtems_capture_buffer_peek (rtems_capture_buffer_t* buffer, size_t* size)
+rtems_capture_buffer_peek (rtems_capture_buffer* buffer, size_t* size)
 {
   if (rtems_capture_buffer_is_empty (buffer))
@@ -110,7 +110,7 @@
 }
 
-void* rtems_capture_buffer_allocate (rtems_capture_buffer_t* buffer, size_t size);
+void* rtems_capture_buffer_allocate (rtems_capture_buffer* buffer, size_t size);
 
-void* rtems_capture_buffer_free (rtems_capture_buffer_t* buffer, size_t size);
+void* rtems_capture_buffer_free (rtems_capture_buffer* buffer, size_t size);
 
 #ifdef __cplusplus
Index: cpukit/libmisc/capture/capture_support.c
===================================================================
--- cpukit/libmisc/capture/capture_support.c	(revision 6da06c559f17f33177f59c0f83164bb2d20c8b9f)
+++ cpukit/libmisc/capture/capture_support.c	(revision 1c18ebf0d637bea1101c4b16e3844103524a5281)
@@ -42,10 +42,10 @@
 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_t rec;       /**< The record, copied out. */
-} ctrace_per_cpu_t;
+  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;
 
 /*
@@ -187,7 +187,7 @@
 
 void
-rtems_capture_print_record_task (int                                cpu,
-                                 const rtems_capture_record_t*      rec,
-                                 const rtems_capture_task_record_t* task_rec)
+rtems_capture_print_record_task (int                              cpu,
+                                 const rtems_capture_record*      rec,
+                                 const rtems_capture_task_record* task_rec)
 {
   fprintf(stdout,"%2i ", cpu);
@@ -216,8 +216,8 @@
 
 void
-rtems_capture_print_record_capture(int                           cpu,
-                                   const rtems_capture_record_t* rec,
-                                   uint64_t                      diff,
-                                   const rtems_name*             name)
+rtems_capture_print_record_capture(int                         cpu,
+                                   const rtems_capture_record* rec,
+                                   uint64_t                    diff,
+                                   const rtems_name*           name)
 {
   uint32_t event;
@@ -263,9 +263,9 @@
 rtems_capture_print_trace_records (int total, bool csv)
 {
-  ctrace_per_cpu_t*    per_cpu;
-  ctrace_per_cpu_t*    cpu;
-  int                  cpus;
-  rtems_capture_time_t last_time = 0;
-  int                  i;
+  ctrace_per_cpu*    per_cpu;
+  ctrace_per_cpu*    cpu;
+  int                cpus;
+  rtems_capture_time last_time = 0;
+  int                i;
 
   cpus = rtems_get_processor_count ();
@@ -280,7 +280,7 @@
   while (total)
   {
-    const rtems_capture_record_t* rec_out = NULL;
-    int                           cpu_out = -1;
-    rtems_capture_time_t          this_time = 0;
+    const rtems_capture_record* rec_out = NULL;
+    int                         cpu_out = -1;
+    rtems_capture_time          this_time = 0;
 
     /* Prime the per_cpu data */
@@ -346,5 +346,5 @@
       if ((rec_out->events >> RTEMS_CAPTURE_EVENT_START) == 0)
       {
-        rtems_capture_task_record_t task_rec;
+        rtems_capture_task_record task_rec;
         cpu->recs = rtems_capture_record_extract (cpu->recs,
                                                   &task_rec,
@@ -355,6 +355,6 @@
       else
       {
-        rtems_capture_time_t diff;
-        const rtems_name*    name = NULL;
+        rtems_capture_time diff;
+        const rtems_name*  name = NULL;
         if (last_time != 0)
           diff = rec_out->time - last_time;
@@ -403,7 +403,7 @@
 rtems_capture_print_watch_list (void)
 {
-  rtems_capture_control_t* control = rtems_capture_get_control_list ();
-  rtems_task_priority      ceiling = rtems_capture_watch_get_ceiling ();
-  rtems_task_priority      floor = rtems_capture_watch_get_floor ();
+  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);
Index: cpukit/libmisc/capture/capture_user_extension.c
===================================================================
--- cpukit/libmisc/capture/capture_user_extension.c	(revision 6da06c559f17f33177f59c0f83164bb2d20c8b9f)
+++ cpukit/libmisc/capture/capture_user_extension.c	(revision 1c18ebf0d637bea1101c4b16e3844103524a5281)
@@ -79,5 +79,5 @@
 };
 
-static inline void rtems_capture_record (rtems_tcb* tcb, uint32_t events)
+static inline void capture_record (rtems_tcb* tcb, uint32_t events)
 {
   rtems_capture_record_lock_context rec_context;
@@ -141,8 +141,8 @@
   rtems_capture_initialize_task (nt);
 
-  if (rtems_capture_trigger (ct, nt, RTEMS_CAPTURE_CREATE))
-  {
-    rtems_capture_record (ct, RTEMS_CAPTURE_CREATED_BY_EVENT);
-    rtems_capture_record (nt, RTEMS_CAPTURE_CREATED_EVENT);
+  if (rtems_capture_trigger_fired (ct, nt, RTEMS_CAPTURE_CREATE))
+  {
+    capture_record (ct, RTEMS_CAPTURE_CREATED_BY_EVENT);
+    capture_record (nt, RTEMS_CAPTURE_CREATED_EVENT);
   }
 
@@ -168,8 +168,8 @@
     rtems_capture_initialize_task (st);
 
-  if (rtems_capture_trigger (ct, st, RTEMS_CAPTURE_START))
-  {
-    rtems_capture_record (ct, RTEMS_CAPTURE_STARTED_BY_EVENT);
-    rtems_capture_record (st, RTEMS_CAPTURE_STARTED_EVENT);
+  if (rtems_capture_trigger_fired (ct, st, RTEMS_CAPTURE_START))
+  {
+    capture_record (ct, RTEMS_CAPTURE_STARTED_BY_EVENT);
+    capture_record (st, RTEMS_CAPTURE_STARTED_EVENT);
   }
 }
@@ -192,8 +192,8 @@
     rtems_capture_initialize_task (rt);
 
-  if (rtems_capture_trigger (ct, rt, RTEMS_CAPTURE_RESTART))
-  {
-    rtems_capture_record (ct, RTEMS_CAPTURE_RESTARTED_BY_EVENT);
-    rtems_capture_record (rt, RTEMS_CAPTURE_RESTARTED_EVENT);
+  if (rtems_capture_trigger_fired (ct, rt, RTEMS_CAPTURE_RESTART))
+  {
+    capture_record (ct, RTEMS_CAPTURE_RESTARTED_BY_EVENT);
+    capture_record (rt, RTEMS_CAPTURE_RESTARTED_EVENT);
   }
 }
@@ -212,8 +212,8 @@
     rtems_capture_initialize_task (dt);
 
-  if (rtems_capture_trigger (ct, dt, RTEMS_CAPTURE_DELETE))
-  {
-    rtems_capture_record (ct, RTEMS_CAPTURE_DELETED_BY_EVENT);
-    rtems_capture_record (dt, RTEMS_CAPTURE_DELETED_EVENT);
+  if (rtems_capture_trigger_fired (ct, dt, RTEMS_CAPTURE_DELETE))
+  {
+    capture_record (ct, RTEMS_CAPTURE_DELETED_BY_EVENT);
+    capture_record (dt, RTEMS_CAPTURE_DELETED_EVENT);
   }
 }
@@ -233,6 +233,6 @@
     rtems_capture_initialize_task (bt);
 
-  if (rtems_capture_trigger (NULL, bt, RTEMS_CAPTURE_BEGIN))
-    rtems_capture_record (bt, RTEMS_CAPTURE_BEGIN_EVENT);
+  if (rtems_capture_trigger_fired (NULL, bt, RTEMS_CAPTURE_BEGIN))
+    capture_record (bt, RTEMS_CAPTURE_BEGIN_EVENT);
 }
 
@@ -252,6 +252,6 @@
     rtems_capture_initialize_task (et);
 
-  if (rtems_capture_trigger (NULL, et, RTEMS_CAPTURE_EXITTED))
-    rtems_capture_record (et, RTEMS_CAPTURE_EXITTED_EVENT);
+  if (rtems_capture_trigger_fired (NULL, et, RTEMS_CAPTURE_EXITTED))
+    capture_record (et, RTEMS_CAPTURE_EXITTED_EVENT);
 }
 
@@ -270,6 +270,6 @@
     rtems_capture_initialize_task (tt);
 
-  if (rtems_capture_trigger (NULL, tt, RTEMS_CAPTURE_TERMINATED))
-    rtems_capture_record (tt, RTEMS_CAPTURE_TERMINATED_EVENT);
+  if (rtems_capture_trigger_fired (NULL, tt, RTEMS_CAPTURE_TERMINATED))
+    capture_record (tt, RTEMS_CAPTURE_TERMINATED_EVENT);
 }
 
@@ -289,5 +289,5 @@
   if (flags & RTEMS_CAPTURE_ON)
   {
-    rtems_capture_time_t time;
+    rtems_capture_time time;
     if (!rtems_capture_task_initialized (ct))
       rtems_capture_initialize_task (ct);
@@ -302,8 +302,8 @@
     rtems_capture_get_time (&time);
 
-    if (rtems_capture_trigger (ct, ht, RTEMS_CAPTURE_SWITCH))
+    if (rtems_capture_trigger_fired (ct, ht, RTEMS_CAPTURE_SWITCH))
     {
-      rtems_capture_record (ct, RTEMS_CAPTURE_SWITCHED_OUT_EVENT);
-      rtems_capture_record (ht, RTEMS_CAPTURE_SWITCHED_IN_EVENT);
+      capture_record (ct, RTEMS_CAPTURE_SWITCHED_OUT_EVENT);
+      capture_record (ht, RTEMS_CAPTURE_SWITCHED_IN_EVENT);
     }
   }
Index: cpukit/libmisc/capture/captureimpl.h
===================================================================
--- cpukit/libmisc/capture/captureimpl.h	(revision 6da06c559f17f33177f59c0f83164bb2d20c8b9f)
+++ cpukit/libmisc/capture/captureimpl.h	(revision 1c18ebf0d637bea1101c4b16e3844103524a5281)
@@ -103,5 +103,5 @@
 
 /**
- * @brief Capture trigger.
+ * @brief Capture check trigger.
  *
  * This function checks if we have triggered or if this event is a
@@ -115,7 +115,7 @@
  * if the event is a cause of a trigger.
  */
-bool rtems_capture_trigger (rtems_tcb* ft,
-                            rtems_tcb* tt,
-                            uint32_t   events);
+bool rtems_capture_trigger_fired (rtems_tcb* ft,
+                                  rtems_tcb* tt,
+                                  uint32_t   events);
 
 /**
@@ -150,7 +150,7 @@
  * @param[in] rec specifies the task record.
  */
-void rtems_capture_print_record_task(int                                cpu,
-                                     const rtems_capture_record_t*      rec,
-                                     const rtems_capture_task_record_t* task_rec);
+void rtems_capture_print_record_task(int                              cpu,
+                                     const rtems_capture_record*      rec,
+                                     const rtems_capture_task_record* task_rec);
 
 /**
@@ -166,8 +166,8 @@
  * @param[in] task_count number of tasks to search for.
  */
-void rtems_capture_print_record_capture(int                           cpu,
-                                        const rtems_capture_record_t* rec,
-                                        uint64_t                      diff,
-                                        const rtems_name*             name);
+void rtems_capture_print_record_capture(int                         cpu,
+                                        const rtems_capture_record* rec,
+                                        uint64_t                    diff,
+                                        const rtems_name*           name);
 
 /**
Index: testsuites/libtests/capture01/init.c
===================================================================
--- testsuites/libtests/capture01/init.c	(revision 6da06c559f17f33177f59c0f83164bb2d20c8b9f)
+++ testsuites/libtests/capture01/init.c	(revision 1c18ebf0d637bea1101c4b16e3844103524a5281)
@@ -79,10 +79,10 @@
   rtems_capture_print_watch_list();
 
-  sc = rtems_capture_control (true);
+  sc = rtems_capture_set_control (true);
   ASSERT_SC(sc);
 
   capture_test_1();
 
-  sc = rtems_capture_control (false);
+  sc = rtems_capture_set_control (false);
   ASSERT_SC(sc);
 
Index: testsuites/smptests/smpcapture01/init.c
===================================================================
--- testsuites/smptests/smpcapture01/init.c	(revision 6da06c559f17f33177f59c0f83164bb2d20c8b9f)
+++ testsuites/smptests/smpcapture01/init.c	(revision 1c18ebf0d637bea1101c4b16e3844103524a5281)
@@ -233,10 +233,10 @@
   }
 
-  sc = rtems_capture_control (true);
+  sc = rtems_capture_set_control (true);
   rtems_test_assert(sc == RTEMS_SUCCESSFUL);
 
   test();
 
-  sc = rtems_capture_control (false);
+  sc = rtems_capture_set_control (false);
   rtems_test_assert(sc == RTEMS_SUCCESSFUL);
 
Index: testsuites/smptests/smpcapture02/init.c
===================================================================
--- testsuites/smptests/smpcapture02/init.c	(revision 6da06c559f17f33177f59c0f83164bb2d20c8b9f)
+++ testsuites/smptests/smpcapture02/init.c	(revision 1c18ebf0d637bea1101c4b16e3844103524a5281)
@@ -39,5 +39,5 @@
   rtems_id task_sem;
   rtems_id prev_sem;
-} task_data_t;
+} per_cpu_task_data;
 
 typedef struct {
@@ -50,5 +50,5 @@
 
 static rtems_id finished_sem;
-static task_data_t task_data[ TASKS_PER_CPU * TASKS_PER_CPU ];
+static per_cpu_task_data task_data[ TASKS_PER_CPU * TASKS_PER_CPU ];
 static rtems_interrupt_handler org_clock_handler;
 
@@ -66,13 +66,13 @@
   uint32_t a;
   uint32_t b;
-} RTEMS_PACKED enter_add_number_record_t;
+} RTEMS_PACKED enter_add_number_record;
 
 typedef struct {
   uint32_t res;
-} RTEMS_PACKED exit_add_number_record_t;
+} RTEMS_PACKED exit_add_number_record;
 
 typedef struct {
   void *arg;
-} RTEMS_PACKED clock_tick_record_t;
+} RTEMS_PACKED clock_tick_record;
 
 /*
@@ -98,6 +98,6 @@
 {
   rtems_capture_record_lock_context lock;
-  enter_add_number_record_t enter_rec;
-  exit_add_number_record_t exit_rec;
+  enter_add_number_record enter_rec;
+  exit_add_number_record exit_rec;
   cap_rec_type id;
   uint32_t res;
@@ -289,8 +289,8 @@
   const void *recs;
   cap_rec_type id;
-  rtems_capture_record_t rec;
-  rtems_capture_record_t prev_rec;
-  enter_add_number_record_t enter_rec;
-  exit_add_number_record_t exit_rec;
+  rtems_capture_record rec;
+  rtems_capture_record prev_rec;
+  enter_add_number_record enter_rec;
+  exit_add_number_record exit_rec;
   clock_interrupt_handler cih = {.found = 0};
 
@@ -310,5 +310,5 @@
   rtems_test_assert(sc == RTEMS_SUCCESSFUL);
 
-  sc = rtems_capture_control(true);
+  sc = rtems_capture_set_control(true);
   rtems_test_assert(sc == RTEMS_SUCCESSFUL);
 
@@ -338,5 +338,5 @@
 
   /* Disable capturing */
-  sc = rtems_capture_control(false);
+  sc = rtems_capture_set_control(false);
   rtems_test_assert(sc == RTEMS_SUCCESSFUL);
 
