Add and use rtems_assoc_thread_states_to_string()

cpukit/libcsupport/Makefile.am

@@ -39,6 +39,7 @@ ASSOCIATION_C_FILES = src/assoclocalbyname.c \
     src/assocptrbyremote.c src/assocremotebylocalbitfield.c \
     src/assocremotebylocal.c src/assocremotebyname.c
 ASSOCIATION_C_FILES += src/assoc32tostring.c
+ASSOCIATION_C_FILES += src/assocthreadstatestostring.c
 
 BASE_FS_C_FILES = src/base_fs.c src/mount.c src/unmount.c src/libio.c \
     src/mount-mgr.c src/mount-mktgt.c src/libio_init.c \

cpukit/libcsupport/include/rtems/assoc.h

@@ -181,6 +181,22 @@ size_t rtems_assoc_32_to_string(
   const char                *fallback
 );
 
+/**
+ * @brief Converts the specified thread states into a text representation.
+ *
+ * @param[in] states The thread states to convert.
+ * @param[in] buffer The buffer for the text representation.
+ * @param[in] buffer_size The buffer size in characters.
+ *
+ * @retval The length of the text representation.  May be greater than the
+ * buffer size if truncation occurred.
+ */
+size_t rtems_assoc_thread_states_to_string(
+  uint32_t  states,
+  char     *buffer,
+  size_t    buffer_size
+);
+
 #ifdef __cplusplus
 }
 #endif

cpukit/libcsupport/src/assocthreadstatestostring.c

@@ -0,0 +1,58 @@
+/*
+ * Copyright (c) 2016 embedded brains GmbH.
+ *
+ * The license and distribution terms for this file may be
+ * found in the file LICENSE in this distribution or at
+ * http://www.rtems.org/license/LICENSE.
+ */
+
+#if HAVE_CONFIG_H
+#include "config.h"
+#endif
+
+#include <rtems/assoc.h>
+#include <rtems/score/statesimpl.h>
+
+static const rtems_assoc_32_pair state_pairs[] = {
+  { STATES_THREAD_QUEUE_WITH_IDENTIFIER,   "ID" },
+  { STATES_WAITING_FOR_MUTEX,              "MTX" },
+  { STATES_WAITING_FOR_SEMAPHORE,          "SEM" },
+  { STATES_WAITING_FOR_EVENT,              "EV" },
+  { STATES_WAITING_FOR_SYSTEM_EVENT,       "SYSEV" },
+  { STATES_WAITING_FOR_MESSAGE,            "MSG" },
+  { STATES_WAITING_FOR_CONDITION_VARIABLE, "CV" },
+  { STATES_WAITING_FOR_FUTEX,              "FTX" },
+  { STATES_WAITING_FOR_BSD_WAKEUP,         "WK" },
+  { STATES_WAITING_FOR_TIME,               "TIME" },
+  { STATES_WAITING_FOR_PERIOD,             "PER" },
+  { STATES_WAITING_FOR_SIGNAL,             "SIG" },
+  { STATES_WAITING_FOR_BARRIER,            "BAR" },
+  { STATES_WAITING_FOR_RWLOCK,             "RW" },
+  { STATES_WAITING_FOR_JOIN_AT_EXIT,       "JATX" },
+  { STATES_WAITING_FOR_JOIN,               "JOIN" },
+  { STATES_SUSPENDED,                      "SUSP" },
+  { STATES_WAITING_FOR_SEGMENT,            "SEG" },
+  { STATES_LIFE_IS_CHANGING,               "LIFE" },
+  { STATES_DEBUGGER,                       "DBG" },
+  { STATES_INTERRUPTIBLE_BY_SIGNAL,        "IS" },
+  { STATES_WAITING_FOR_RPC_REPLY,          "RPC" },
+  { STATES_ZOMBIE,                         "ZOMBI" },
+  { STATES_DORMANT,                        "DORM" }
+};
+
+size_t rtems_assoc_thread_states_to_string(
+  uint32_t  states,
+  char     *buffer,
+  size_t    buffer_size
+)
+{
+  return rtems_assoc_32_to_string(
+    states,
+    buffer,
+    buffer_size,
+    state_pairs,
+    RTEMS_ARRAY_SIZE( state_pairs ),
+    ":",
+    "READY"
+  );
+}

cpukit/libdebugger/rtems-debugger-threads.c

@@ -28,7 +28,7 @@
 #include <stdio.h>
 
 #include <rtems.h>
-#include <rtems/score/statesimpl.h>
+#include <rtems/assoc.h>
 #include <rtems/score/threadimpl.h>
 
 #include <rtems/debugger/rtems-debugger-server.h>
@@ -506,57 +506,10 @@ rtems_debugger_thread_state(rtems_debugger_thread* thread)
 
 int
 rtems_debugger_thread_state_str(rtems_debugger_thread* thread,
-                                char*                  buffer,
+                                char*                  buf,
                                 size_t                 size)
 {
-  struct mapper {
+  rtems_assoc_thread_states_to_string(thread->tcb->current_state, buf, size);
-    const char const* label;
-    DB_UINT           mask;
-  };
-  const struct mapper map[] = {
-    { "DORM",   STATES_DORMANT },
-    { "LIFE",   STATES_LIFE_IS_CHANGING },
-    { "SUSP",   STATES_SUSPENDED },
-    { "Wbar",   STATES_WAITING_FOR_BARRIER },
-    { "Wcvar",  STATES_WAITING_FOR_CONDITION_VARIABLE },
-    { "Wevnt",  STATES_WAITING_FOR_EVENT },
-    { "ISIG" ,  STATES_INTERRUPTIBLE_BY_SIGNAL },
-    { "Wjatx",  STATES_WAITING_FOR_JOIN_AT_EXIT },
-    { "Wjoin",  STATES_WAITING_FOR_JOIN },
-    { "Wmsg" ,  STATES_WAITING_FOR_MESSAGE },
-    { "Wmutex", STATES_WAITING_FOR_MUTEX },
-    { "WRATE",  STATES_WAITING_FOR_PERIOD },
-    { "Wrpc",   STATES_WAITING_FOR_RPC_REPLY },
-    { "Wrwlk",  STATES_WAITING_FOR_RWLOCK },
-    { "Wseg",   STATES_WAITING_FOR_SEGMENT },
-    { "Wsem",   STATES_WAITING_FOR_SEMAPHORE },
-    { "Wsig",   STATES_WAITING_FOR_SIGNAL },
-    { "Wfutex", STATES_WAITING_FOR_FUTEX },
-    { "TQID",   STATES_THREAD_QUEUE_WITH_IDENTIFIER },
-    { "Wsysev", STATES_WAITING_FOR_SYSTEM_EVENT },
-    { "Wtime",  STATES_WAITING_FOR_TIME },
-    { "Wwkup",  STATES_WAITING_FOR_BSD_WAKEUP },
-    { "ZOMBI",  STATES_ZOMBIE },
-  };
-  DB_UINT state = thread->tcb->current_state;
-  if (state == STATES_READY) {
-    strcpy(buffer, "READY");
-  }
-  else {
-    char*  start = buffer;
-    size_t i;
-    buffer[0] = '\0';
-    buffer[size - 1] = '\0';
-    for (i = 0; size > 0 && i < RTEMS_DEBUGGER_NUMOF(map); ++i) {
-      if ((map[i].mask & state) != 0) {
-        size_t l = snprintf(buffer, size - 1, "%s ", map[i].label);
-        buffer += l;
-        size -= l;
-      }
-    }
-    if (buffer != start)
-      *(buffer - 1) = '\0';
-  }
   return 0;
 }
 

cpukit/libmisc/monitor/mon-prmisc.c

@@ -12,7 +12,6 @@
 #include <rtems.h>
 #include <rtems/monitor.h>
 #include <rtems/assoc.h>
-#include <rtems/score/statesimpl.h>
 
 #include <stdio.h>
 #include <ctype.h>
@@ -112,49 +111,13 @@ rtems_monitor_dump_priority(rtems_task_priority priority)
     return fprintf(stdout,"%3" PRId32, priority);
 }
 
-#define WITH_ID(state) (STATES_THREAD_QUEUE_WITH_IDENTIFIER | state)
-
-static const rtems_assoc_t rtems_monitor_state_assoc[] = {
-    { "DORM",   STATES_DORMANT, 0 },
-    { "LIFE",   STATES_LIFE_IS_CHANGING, 0 },
-    { "SUSP",   STATES_SUSPENDED, 0 },
-    { "Wbar",   WITH_ID(STATES_WAITING_FOR_BARRIER), 0 },
-    { "Wcvar",  WITH_ID(STATES_WAITING_FOR_CONDITION_VARIABLE), 0 },
-    { "Wevnt",  STATES_WAITING_FOR_EVENT, 0 },
-    { "Wisig",  STATES_INTERRUPTIBLE_BY_SIGNAL, 0 },
-    { "Wjatx",  STATES_WAITING_FOR_JOIN_AT_EXIT, 0 },
-    { "Wjoin",  STATES_WAITING_FOR_JOIN, 0 },
-    { "Wmsg" ,  WITH_ID(STATES_WAITING_FOR_MESSAGE), 0 },
-    { "Wmutex", WITH_ID(STATES_WAITING_FOR_MUTEX), 0 },
-    { "WRATE",  STATES_WAITING_FOR_PERIOD, 0 },
-    { "Wrpc",   STATES_WAITING_FOR_RPC_REPLY, 0 },
-    { "Wrwlk",  WITH_ID(STATES_WAITING_FOR_RWLOCK), 0 },
-    { "Wseg",   STATES_WAITING_FOR_SEGMENT, 0 },
-    { "Wsem",   WITH_ID(STATES_WAITING_FOR_SEMAPHORE), 0 },
-    { "Wsig",   STATES_WAITING_FOR_SIGNAL, 0 },
-    { "Wcvar",  STATES_WAITING_FOR_CONDITION_VARIABLE, 0 },
-    { "Wfutex", STATES_WAITING_FOR_FUTEX, 0 },
-    { "Wmutex", STATES_WAITING_FOR_MUTEX, 0 },
-    { "Wsem",   STATES_WAITING_FOR_SEMAPHORE, 0 },
-    { "Wsysev", STATES_WAITING_FOR_SYSTEM_EVENT, 0 },
-    { "Wtime",  STATES_WAITING_FOR_TIME, 0 },
-    { "Wwkup",  STATES_WAITING_FOR_BSD_WAKEUP, 0 },
-    { "ZOMBI",  STATES_ZOMBIE, 0 },
-    { 0, 0, 0 },
-};
-
 int
 rtems_monitor_dump_state(States_Control state)
 {
-    int   length = 0;
+    char buf[16];
 
-    if (state == STATES_READY)  /* assoc doesn't deal with this as it is 0 */
+    rtems_assoc_thread_states_to_string(state, buf, sizeof(buf));
-        length += fprintf(stdout,"READY");
+    return fprintf(stdout, "%s", buf);
-
-    length += rtems_monitor_dump_assoc_bitfield(rtems_monitor_state_assoc,
-                                                ":",
-                                                state);
-    return length;
 }
 
 static const rtems_assoc_t rtems_monitor_attribute_assoc[] = {