rtos: constify symbol names and lists
[fw/openocd] / src / rtos / ThreadX.c
index 714c6fef5df8ca98ccca9afcf35e48f1bffe3352..88470b62ff198c6a83ace509a08286bbc41edb23 100644 (file)
@@ -15,7 +15,7 @@
  *   You should have received a copy of the GNU General Public License     *
  *   along with this program; if not, write to the                         *
  *   Free Software Foundation, Inc.,                                       *
- *   59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.             *
+ *   51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.           *
  ***************************************************************************/
 
 #ifdef HAVE_CONFIG_H
@@ -39,10 +39,10 @@ static int ThreadX_get_symbol_list_to_lookup(symbol_table_elem_t *symbol_list[])
 
 struct ThreadX_thread_state {
        int value;
-       char *desc;
+       const char *desc;
 };
 
-struct ThreadX_thread_state ThreadX_thread_states[] = {
+static const struct ThreadX_thread_state ThreadX_thread_states[] = {
        { 0,  "Ready" },
        { 1,  "Completed" },
        { 2,  "Terminated" },
@@ -62,7 +62,7 @@ struct ThreadX_thread_state ThreadX_thread_states[] = {
 #define THREADX_NUM_STATES (sizeof(ThreadX_thread_states)/sizeof(struct ThreadX_thread_state))
 
 struct ThreadX_params {
-       char *target_name;
+       const char *target_name;
        unsigned char pointer_width;
        unsigned char thread_stack_offset;
        unsigned char thread_name_offset;
@@ -71,9 +71,9 @@ struct ThreadX_params {
        const struct rtos_register_stacking *stacking_info;
 };
 
-const struct ThreadX_params ThreadX_params_list[] = {
+static const struct ThreadX_params ThreadX_params_list[] = {
        {
-       "cortex_m3",                            /* target_name */
+       "cortex_m",                             /* target_name */
        4,                                                      /* pointer_width; */
        8,                                                      /* thread_stack_offset; */
        40,                                                     /* thread_name_offset; */
@@ -100,7 +100,7 @@ enum ThreadX_symbol_values {
        ThreadX_VAL_tx_thread_created_count = 2,
 };
 
-static char *ThreadX_symbol_list[] = {
+static const char * const ThreadX_symbol_list[] = {
        "_tx_thread_current_ptr",
        "_tx_thread_created_ptr",
        "_tx_thread_created_count",
@@ -115,7 +115,6 @@ const struct rtos_type ThreadX_rtos = {
        .update_threads = ThreadX_update_threads,
        .get_thread_reg_list = ThreadX_get_thread_reg_list,
        .get_symbol_list_to_lookup = ThreadX_get_symbol_list_to_lookup,
-
 };
 
 static int ThreadX_update_threads(struct rtos *rtos)
@@ -134,12 +133,12 @@ static int ThreadX_update_threads(struct rtos *rtos)
        param = (const struct ThreadX_params *) rtos->rtos_specific_params;
 
        if (rtos->symbols == NULL) {
-               LOG_OUTPUT("No symbols for ThreadX\r\n");
+               LOG_ERROR("No symbols for ThreadX");
                return -4;
        }
 
        if (rtos->symbols[ThreadX_VAL_tx_thread_created_count].address == 0) {
-               LOG_OUTPUT("Don't have the number of threads in ThreadX \r\n");
+               LOG_ERROR("Don't have the number of threads in ThreadX");
                return -2;
        }
 
@@ -150,30 +149,12 @@ static int ThreadX_update_threads(struct rtos *rtos)
                        (uint8_t *)&thread_list_size);
 
        if (retval != ERROR_OK) {
-               LOG_OUTPUT("Could not read ThreadX thread count from target\r\n");
+               LOG_ERROR("Could not read ThreadX thread count from target");
                return retval;
        }
 
        /* wipe out previous thread details if any */
-       if (rtos->thread_details != NULL) {
-               int j;
-               for (j = 0; j < rtos->thread_count; j++) {
-                       if (rtos->thread_details[j].display_str != NULL) {
-                               free(rtos->thread_details[j].display_str);
-                               rtos->thread_details[j].display_str = NULL;
-                       }
-                       if (rtos->thread_details[j].thread_name_str != NULL) {
-                               free(rtos->thread_details[j].thread_name_str);
-                               rtos->thread_details[j].thread_name_str = NULL;
-                       }
-                       if (rtos->thread_details[j].extra_info_str != NULL) {
-                               free(rtos->thread_details[j].extra_info_str);
-                               rtos->thread_details[j].extra_info_str = NULL;
-                       }
-               }
-               free(rtos->thread_details);
-               rtos->thread_details = NULL;
-       }
+       rtos_free_threadlist(rtos);
 
        /* read the current thread id */
        retval = target_read_buffer(rtos->target,
@@ -182,7 +163,7 @@ static int ThreadX_update_threads(struct rtos *rtos)
                        (uint8_t *)&rtos->current_thread);
 
        if (retval != ERROR_OK) {
-               LOG_OUTPUT("Could not read ThreadX current thread from target\r\n");
+               LOG_ERROR("Could not read ThreadX current thread from target");
                return retval;
        }
 
@@ -193,13 +174,13 @@ static int ThreadX_update_threads(struct rtos *rtos)
                char tmp_str[] = "Current Execution";
                thread_list_size++;
                tasks_found++;
-               rtos->thread_details = (struct thread_detail *) malloc(
+               rtos->thread_details = malloc(
                                sizeof(struct thread_detail) * thread_list_size);
                rtos->thread_details->threadid = 1;
                rtos->thread_details->exists = true;
                rtos->thread_details->display_str = NULL;
                rtos->thread_details->extra_info_str = NULL;
-               rtos->thread_details->thread_name_str = (char *) malloc(sizeof(tmp_str));
+               rtos->thread_details->thread_name_str = malloc(sizeof(tmp_str));
                strcpy(rtos->thread_details->thread_name_str, tmp_str);
 
                if (thread_list_size == 0) {
@@ -208,7 +189,7 @@ static int ThreadX_update_threads(struct rtos *rtos)
                }
        } else {
                /* create space for new thread details */
-               rtos->thread_details = (struct thread_detail *) malloc(
+               rtos->thread_details = malloc(
                                sizeof(struct thread_detail) * thread_list_size);
        }
 
@@ -219,7 +200,7 @@ static int ThreadX_update_threads(struct rtos *rtos)
                        param->pointer_width,
                        (uint8_t *)&thread_ptr);
        if (retval != ERROR_OK) {
-               LOG_OUTPUT("Could not read ThreadX thread location from target\r\n");
+               LOG_ERROR("Could not read ThreadX thread location from target");
                return retval;
        }
 
@@ -241,7 +222,7 @@ static int ThreadX_update_threads(struct rtos *rtos)
                                param->pointer_width,
                                (uint8_t *)&name_ptr);
                if (retval != ERROR_OK) {
-                       LOG_OUTPUT("Could not read ThreadX thread name pointer from target\r\n");
+                       LOG_ERROR("Could not read ThreadX thread name pointer from target");
                        return retval;
                }
 
@@ -252,7 +233,7 @@ static int ThreadX_update_threads(struct rtos *rtos)
                                THREADX_THREAD_NAME_STR_SIZE,
                                (uint8_t *)&tmp_str);
                if (retval != ERROR_OK) {
-                       LOG_OUTPUT("Error reading thread name from ThreadX target\r\n");
+                       LOG_ERROR("Error reading thread name from ThreadX target");
                        return retval;
                }
                tmp_str[THREADX_THREAD_NAME_STR_SIZE-1] = '\x00';
@@ -261,7 +242,7 @@ static int ThreadX_update_threads(struct rtos *rtos)
                        strcpy(tmp_str, "No Name");
 
                rtos->thread_details[tasks_found].thread_name_str =
-                       (char *)malloc(strlen(tmp_str)+1);
+                       malloc(strlen(tmp_str)+1);
                strcpy(rtos->thread_details[tasks_found].thread_name_str, tmp_str);
 
                /* Read the thread status */
@@ -271,7 +252,7 @@ static int ThreadX_update_threads(struct rtos *rtos)
                                4,
                                (uint8_t *)&thread_status);
                if (retval != ERROR_OK) {
-                       LOG_OUTPUT("Error reading thread state from ThreadX target\r\n");
+                       LOG_ERROR("Error reading thread state from ThreadX target");
                        return retval;
                }
 
@@ -280,13 +261,13 @@ static int ThreadX_update_threads(struct rtos *rtos)
                        /* empty */
                }
 
-               char *state_desc;
+               const char *state_desc;
                if  (i < THREADX_NUM_STATES)
                        state_desc = ThreadX_thread_states[i].desc;
                else
                        state_desc = "Unknown state";
 
-               rtos->thread_details[tasks_found].extra_info_str = (char *)malloc(strlen(
+               rtos->thread_details[tasks_found].extra_info_str = malloc(strlen(
                                        state_desc)+1);
                strcpy(rtos->thread_details[tasks_found].extra_info_str, state_desc);
 
@@ -304,7 +285,7 @@ static int ThreadX_update_threads(struct rtos *rtos)
                                param->pointer_width,
                                (uint8_t *) &thread_ptr);
                if (retval != ERROR_OK) {
-                       LOG_OUTPUT("Error reading next thread pointer in ThreadX thread list\r\n");
+                       LOG_ERROR("Error reading next thread pointer in ThreadX thread list");
                        return retval;
                }
        }
@@ -339,7 +320,7 @@ static int ThreadX_get_thread_reg_list(struct rtos *rtos, int64_t thread_id, cha
                        param->pointer_width,
                        (uint8_t *)&stack_ptr);
        if (retval != ERROR_OK) {
-               LOG_OUTPUT("Error reading stack frame from ThreadX thread\r\n");
+               LOG_ERROR("Error reading stack frame from ThreadX thread");
                return retval;
        }
 
@@ -349,7 +330,7 @@ static int ThreadX_get_thread_reg_list(struct rtos *rtos, int64_t thread_id, cha
 static int ThreadX_get_symbol_list_to_lookup(symbol_table_elem_t *symbol_list[])
 {
        unsigned int i;
-       *symbol_list = (symbol_table_elem_t *) malloc(
+       *symbol_list = malloc(
                        sizeof(symbol_table_elem_t) * ARRAY_SIZE(ThreadX_symbol_list));
 
        for (i = 0; i < ARRAY_SIZE(ThreadX_symbol_list); i++)
@@ -399,7 +380,7 @@ static int ThreadX_get_thread_detail(struct rtos *rtos,
        param = (const struct ThreadX_params *) rtos->rtos_specific_params;
 
        if (rtos->symbols == NULL) {
-               LOG_OUTPUT("No symbols for ThreadX\r\n");
+               LOG_ERROR("No symbols for ThreadX");
                return -3;
        }
 
@@ -412,7 +393,7 @@ static int ThreadX_get_thread_detail(struct rtos *rtos,
                        param->pointer_width,
                        (uint8_t *)&name_ptr);
        if (retval != ERROR_OK) {
-               LOG_OUTPUT("Could not read ThreadX thread name pointer from target\r\n");
+               LOG_ERROR("Could not read ThreadX thread name pointer from target");
                return retval;
        }
 
@@ -422,7 +403,7 @@ static int ThreadX_get_thread_detail(struct rtos *rtos,
                        THREADX_THREAD_NAME_STR_SIZE,
                        (uint8_t *)&tmp_str);
        if (retval != ERROR_OK) {
-               LOG_OUTPUT("Error reading thread name from ThreadX target\r\n");
+               LOG_ERROR("Error reading thread name from ThreadX target");
                return retval;
        }
        tmp_str[THREADX_THREAD_NAME_STR_SIZE-1] = '\x00';
@@ -430,7 +411,7 @@ static int ThreadX_get_thread_detail(struct rtos *rtos,
        if (tmp_str[0] == '\x00')
                strcpy(tmp_str, "No Name");
 
-       detail->thread_name_str = (char *)malloc(strlen(tmp_str)+1);
+       detail->thread_name_str = malloc(strlen(tmp_str)+1);
 
        /* Read the thread status */
        int64_t thread_status = 0;
@@ -440,7 +421,7 @@ static int ThreadX_get_thread_detail(struct rtos *rtos,
                        4,
                        (uint8_t *)&thread_status);
        if (retval != ERROR_OK) {
-               LOG_OUTPUT("Error reading thread state from ThreadX target\r\n");
+               LOG_ERROR("Error reading thread state from ThreadX target");
                return retval;
        }
 
@@ -455,7 +436,7 @@ static int ThreadX_get_thread_detail(struct rtos *rtos,
        else
                state_desc = "Unknown state";
 
-       detail->extra_info_str = (char *)malloc(strlen(state_desc)+1);
+       detail->extra_info_str = malloc(strlen(state_desc)+1);
 
        detail->exists = true;
 
@@ -474,7 +455,7 @@ static int ThreadX_create(struct target *target)
                i++;
        }
        if (i >= THREADX_NUM_PARAMS) {
-               LOG_OUTPUT("Could not find target in ThreadX compatibility list\r\n");
+               LOG_ERROR("Could not find target in ThreadX compatibility list");
                return -1;
        }