Code Review / openocd.git / blobdiff
? search:
summary | shortlog | log | commit | commitdiff | review | tree
raw | inline | side by side
FreeRTOS: Make optional symbols optional
[openocd.git] / src / rtos / FreeRTOS.c
diff --git a/src/rtos/FreeRTOS.c b/src/rtos/FreeRTOS.c
index 1e4ddc532a51c1c68d905f66548d61f122df718b..e13cc4617bdca5688ed6f41f9b3571a18f6afc0c 100644 (file)
--- a/src/rtos/FreeRTOS.c
+++ b/src/rtos/FreeRTOS.c
@@ -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
@@ -28,6 +28,7 @@
 #include "target/target_type.h"
 #include "rtos.h"
 #include "helper/log.h"
+#include "helper/types.h"
 #include "rtos_standard_stackings.h"
 
 #define FREERTOS_MAX_PRIORITIES        63
@@ -47,9 +48,9 @@ struct FreeRTOS_params {
        const struct rtos_register_stacking *stacking_info;
 };
 
-const struct FreeRTOS_params FreeRTOS_params_list[] = {
+static const struct FreeRTOS_params FreeRTOS_params_list[] = {
        {
-       "cortex_m3",                    /* target_name */
+       "cortex_m",                     /* target_name */
        4,                                              /* thread_count_width; */
        4,                                              /* pointer_width; */
        16,                                             /* list_next_offset; */
@@ -59,7 +60,31 @@ const struct FreeRTOS_params FreeRTOS_params_list[] = {
        0,                                              /* thread_stack_offset; */
        52,                                             /* thread_name_offset; */
        &rtos_standard_Cortex_M3_stacking,      /* stacking_info */
-       }
+       },
+       {
+       "hla_target",                   /* target_name */
+       4,                                              /* thread_count_width; */
+       4,                                              /* pointer_width; */
+       16,                                             /* list_next_offset; */
+       20,                                             /* list_width; */
+       8,                                              /* list_elem_next_offset; */
+       12,                                             /* list_elem_content_offset */
+       0,                                              /* thread_stack_offset; */
+       52,                                             /* thread_name_offset; */
+       &rtos_standard_Cortex_M3_stacking,      /* stacking_info */
+       },
+       {
+       "nds32_v3",                     /* target_name */
+       4,                                              /* thread_count_width; */
+       4,                                              /* pointer_width; */
+       16,                                             /* list_next_offset; */
+       20,                                             /* list_width; */
+       8,                                              /* list_elem_next_offset; */
+       12,                                             /* list_elem_content_offset */
+       0,                                              /* thread_stack_offset; */
+       52,                                             /* thread_name_offset; */
+       &rtos_standard_NDS32_N1068_stacking,    /* stacking_info */
+       },
 };
 
 #define FREERTOS_NUM_PARAMS ((int)(sizeof(FreeRTOS_params_list)/sizeof(struct FreeRTOS_params)))
@@ -94,22 +119,25 @@ enum FreeRTOS_symbol_values {
        FreeRTOS_VAL_uxTopUsedPriority = 10,
 };
 
-static char *FreeRTOS_symbol_list[] = {
-       "pxCurrentTCB",
-       "pxReadyTasksLists",
-       "xDelayedTaskList1",
-       "xDelayedTaskList2",
-       "pxDelayedTaskList",
-       "pxOverflowDelayedTaskList",
-       "xPendingReadyList",
-       "xTasksWaitingTermination",
-       "xSuspendedTaskList",
-       "uxCurrentNumberOfTasks",
-       "uxTopUsedPriority",
-       NULL
+struct symbols {
+       const char *name;
+       bool optional;
 };
 
-#define FREERTOS_NUM_SYMBOLS (sizeof(FreeRTOS_symbol_list)/sizeof(char *))
+static const struct symbols FreeRTOS_symbol_list[] = {
+       { "pxCurrentTCB", false },
+       { "pxReadyTasksLists", false },
+       { "xDelayedTaskList1", false },
+       { "xDelayedTaskList2", false },
+       { "pxDelayedTaskList", false },
+       { "pxOverflowDelayedTaskList", false },
+       { "xPendingReadyList", false },
+       { "xTasksWaitingTermination", true }, /* Only if INCLUDE_vTaskDelete */
+       { "xSuspendedTaskList", true }, /* Only if INCLUDE_vTaskSuspend */
+       { "uxCurrentNumberOfTasks", false },
+       { "uxTopUsedPriority", false },
+       { NULL, false }
+};
 
 /* TODO: */
 /* this is not safe for little endian yet */
@@ -129,12 +157,12 @@ static int FreeRTOS_update_threads(struct rtos *rtos)
        param = (const struct FreeRTOS_params *) rtos->rtos_specific_params;
 
        if (rtos->symbols == NULL) {
-               LOG_OUTPUT("No symbols for FreeRTOS\r\n");
+               LOG_ERROR("No symbols for FreeRTOS");
                return -3;
        }
 
        if (rtos->symbols[FreeRTOS_VAL_uxCurrentNumberOfTasks].address == 0) {
-               LOG_OUTPUT("Don't have the number of threads in FreeRTOS \r\n");
+               LOG_ERROR("Don't have the number of threads in FreeRTOS");
                return -2;
        }
 
@@ -143,32 +171,17 @@ static int FreeRTOS_update_threads(struct rtos *rtos)
                        rtos->symbols[FreeRTOS_VAL_uxCurrentNumberOfTasks].address,
                        param->thread_count_width,
                        (uint8_t *)&thread_list_size);
+       LOG_DEBUG("FreeRTOS: Read uxCurrentNumberOfTasks at 0x%" PRIx64 ", value %d\r\n",
+                                                                               rtos->symbols[FreeRTOS_VAL_uxCurrentNumberOfTasks].address,
+                                                                               thread_list_size);
 
        if (retval != ERROR_OK) {
-               LOG_OUTPUT("Could not read FreeRTOS thread count from target\r\n");
+               LOG_ERROR("Could not read FreeRTOS 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 */
        retval = target_read_buffer(rtos->target,
@@ -176,9 +189,12 @@ static int FreeRTOS_update_threads(struct rtos *rtos)
                        param->pointer_width,
                        (uint8_t *)&rtos->current_thread);
        if (retval != ERROR_OK) {
-               LOG_OUTPUT("Error reading current thread in FreeRTOS thread list\r\n");
+               LOG_ERROR("Error reading current thread in FreeRTOS thread list");
                return retval;
        }
+       LOG_DEBUG("FreeRTOS: Read pxCurrentTCB at 0x%" PRIx64 ", value 0x%" PRIx64 "\r\n",
+                                                                               rtos->symbols[FreeRTOS_VAL_pxCurrentTCB].address,
+                                                                               rtos->current_thread);
 
        if ((thread_list_size  == 0) || (rtos->current_thread == 0)) {
                /* Either : No RTOS threads - there is always at least the current execution though */
@@ -187,7 +203,7 @@ static int FreeRTOS_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);
                if (!rtos->thread_details) {
                        LOG_ERROR("Error allocating memory for %d threads", thread_list_size);
@@ -197,7 +213,7 @@ static int FreeRTOS_update_threads(struct rtos *rtos)
                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 == 1) {
@@ -206,7 +222,7 @@ static int FreeRTOS_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);
                if (!rtos->thread_details) {
                        LOG_ERROR("Error allocating memory for %d threads", thread_list_size);
@@ -222,6 +238,9 @@ static int FreeRTOS_update_threads(struct rtos *rtos)
                        (uint8_t *)&max_used_priority);
        if (retval != ERROR_OK)
                return retval;
+       LOG_DEBUG("FreeRTOS: Read uxTopUsedPriority at 0x%" PRIx64 ", value %" PRId64 "\r\n",
+                                                                               rtos->symbols[FreeRTOS_VAL_uxTopUsedPriority].address,
+                                                                               max_used_priority);
        if (max_used_priority > FREERTOS_MAX_PRIORITIES) {
                LOG_ERROR("FreeRTOS maximum used priority is unreasonably big, not proceeding: %" PRId64 "",
                        max_used_priority);
@@ -229,7 +248,7 @@ static int FreeRTOS_update_threads(struct rtos *rtos)
        }
 
        symbol_address_t *list_of_lists =
-               (symbol_address_t *)malloc(sizeof(symbol_address_t) *
+               malloc(sizeof(symbol_address_t) *
                        (max_used_priority+1 + 5));
        if (!list_of_lists) {
                LOG_ERROR("Error allocating memory for %" PRId64 " priorities", max_used_priority);
@@ -258,10 +277,12 @@ static int FreeRTOS_update_threads(struct rtos *rtos)
                                param->thread_count_width,
                                (uint8_t *)&list_thread_count);
                if (retval != ERROR_OK) {
-                       LOG_OUTPUT("Error reading number of threads in FreeRTOS thread list\r\n");
+                       LOG_ERROR("Error reading number of threads in FreeRTOS thread list");
                        free(list_of_lists);
                        return retval;
                }
+               LOG_DEBUG("FreeRTOS: Read thread count for list %d at 0x%" PRIx64 ", value %" PRId64 "\r\n",
+                                                                               i, list_of_lists[i], list_thread_count);
 
                if (list_thread_count == 0)
                        continue;
@@ -274,10 +295,12 @@ static int FreeRTOS_update_threads(struct rtos *rtos)
                                param->pointer_width,
                                (uint8_t *)&list_elem_ptr);
                if (retval != ERROR_OK) {
-                       LOG_OUTPUT("Error reading first thread item location in FreeRTOS thread list\r\n");
+                       LOG_ERROR("Error reading first thread item location in FreeRTOS thread list");
                        free(list_of_lists);
                        return retval;
                }
+               LOG_DEBUG("FreeRTOS: Read first item for list %d at 0x%" PRIx64 ", value 0x%" PRIx64 "\r\n",
+                                                                               i, list_of_lists[i] + param->list_next_offset, list_elem_ptr);
 
                while ((list_thread_count > 0) && (list_elem_ptr != 0) &&
                                (list_elem_ptr != prev_list_elem_ptr) &&
@@ -289,10 +312,13 @@ static int FreeRTOS_update_threads(struct rtos *rtos)
                                        param->pointer_width,
                                        (uint8_t *)&(rtos->thread_details[tasks_found].threadid));
                        if (retval != ERROR_OK) {
-                               LOG_OUTPUT("Error reading thread list item object in FreeRTOS thread list\r\n");
+                               LOG_ERROR("Error reading thread list item object in FreeRTOS thread list");
                                free(list_of_lists);
                                return retval;
                        }
+                       LOG_DEBUG("FreeRTOS: Read Thread ID at 0x%" PRIx64 ", value 0x%" PRIx64 "\r\n",
+                                                                               list_elem_ptr + param->list_elem_content_offset,
+                                                                               rtos->thread_details[tasks_found].threadid);
 
                        /* get thread name */
 
@@ -305,24 +331,27 @@ static int FreeRTOS_update_threads(struct rtos *rtos)
                                        FREERTOS_THREAD_NAME_STR_SIZE,
                                        (uint8_t *)&tmp_str);
                        if (retval != ERROR_OK) {
-                               LOG_OUTPUT("Error reading first thread item location in FreeRTOS thread list\r\n");
+                               LOG_ERROR("Error reading first thread item location in FreeRTOS thread list");
                                free(list_of_lists);
                                return retval;
                        }
                        tmp_str[FREERTOS_THREAD_NAME_STR_SIZE-1] = '\x00';
+                       LOG_DEBUG("FreeRTOS: Read Thread Name at 0x%" PRIx64 ", value \"%s\"\r\n",
+                                                                               rtos->thread_details[tasks_found].threadid + param->thread_name_offset,
+                                                                               tmp_str);
 
                        if (tmp_str[0] == '\x00')
                                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);
                        rtos->thread_details[tasks_found].display_str = NULL;
                        rtos->thread_details[tasks_found].exists = true;
 
                        if (rtos->thread_details[tasks_found].threadid == rtos->current_thread) {
                                char running_str[] = "Running";
-                               rtos->thread_details[tasks_found].extra_info_str = (char *) malloc(
+                               rtos->thread_details[tasks_found].extra_info_str = malloc(
                                                sizeof(running_str));
                                strcpy(rtos->thread_details[tasks_found].extra_info_str,
                                        running_str);
@@ -339,10 +368,13 @@ static int FreeRTOS_update_threads(struct rtos *rtos)
                                        param->pointer_width,
                                        (uint8_t *)&list_elem_ptr);
                        if (retval != ERROR_OK) {
-                               LOG_OUTPUT("Error reading next thread item location in FreeRTOS thread list\r\n");
+                               LOG_ERROR("Error reading next thread item location in FreeRTOS thread list");
                                free(list_of_lists);
                                return retval;
                        }
+                       LOG_DEBUG("FreeRTOS: Read next thread location at 0x%" PRIx64 ", value 0x%" PRIx64 "\r\n",
+                                                                               prev_list_elem_ptr + param->list_elem_next_offset,
+                                                                               list_elem_ptr);
                }
        }
 
@@ -375,22 +407,26 @@ static int FreeRTOS_get_thread_reg_list(struct rtos *rtos, int64_t thread_id, ch
                        param->pointer_width,
                        (uint8_t *)&stack_ptr);
        if (retval != ERROR_OK) {
-               LOG_OUTPUT("Error reading stack frame from FreeRTOS thread\r\n");
+               LOG_ERROR("Error reading stack frame from FreeRTOS thread");
                return retval;
        }
+       LOG_DEBUG("FreeRTOS: Read stack pointer at 0x%" PRIx64 ", value 0x%" PRIx64 "\r\n",
+                                                                               thread_id + param->thread_stack_offset,
+                                                                               stack_ptr);
 
        return rtos_generic_stack_read(rtos->target, param->stacking_info, stack_ptr, hex_reg_list);
-
 }
 
 static int FreeRTOS_get_symbol_list_to_lookup(symbol_table_elem_t *symbol_list[])
 {
        unsigned int i;
-       *symbol_list = (symbol_table_elem_t *) malloc(
-                       sizeof(symbol_table_elem_t) * FREERTOS_NUM_SYMBOLS);
+       *symbol_list = calloc(
+                       ARRAY_SIZE(FreeRTOS_symbol_list), sizeof(symbol_table_elem_t));
 
-       for (i = 0; i < FREERTOS_NUM_SYMBOLS; i++)
-               (*symbol_list)[i].symbol_name = FreeRTOS_symbol_list[i];
+       for (i = 0; i < ARRAY_SIZE(FreeRTOS_symbol_list); i++) {
+               (*symbol_list)[i].symbol_name = FreeRTOS_symbol_list[i].name;
+               (*symbol_list)[i].optional = FreeRTOS_symbol_list[i].optional;
+       }
 
        return 0;
 }
@@ -427,7 +463,7 @@ static int FreeRTOS_get_thread_ascii_info(struct rtos *rtos, threadid_t thread_i
                        FREERTOS_THREAD_NAME_STR_SIZE,
                        (uint8_t *)&tmp_str);
        if (retval != ERROR_OK) {
-               LOG_OUTPUT("Error reading first thread item location in FreeRTOS thread list\r\n");
+               LOG_ERROR("Error reading first thread item location in FreeRTOS thread list");
                return retval;
        }
        tmp_str[FREERTOS_THREAD_NAME_STR_SIZE-1] = '\x00';
@@ -435,7 +471,7 @@ static int FreeRTOS_get_thread_ascii_info(struct rtos *rtos, threadid_t thread_i
        if (tmp_str[0] == '\x00')
                strcpy(tmp_str, "No Name");
 
-       *info = (char *)malloc(strlen(tmp_str)+1);
+       *info = malloc(strlen(tmp_str)+1);
        strcpy(*info, tmp_str);
        return 0;
 }
@@ -460,7 +496,7 @@ static int FreeRTOS_create(struct target *target)
                i++;
        }
        if (i >= FREERTOS_NUM_PARAMS) {
-               LOG_OUTPUT("Could not find target in FreeRTOS compatibility list\r\n");
+               LOG_ERROR("Could not find target in FreeRTOS compatibility list");
                return -1;
        }
 
Open On-Chip Debugger

Linking to existing account procedure

If you already have an account and want to add another login method you MUST first sign in with your existing account and then change URL to read https://review.openocd.org/login/?link to get to this page again but this time it'll work for linking. Thank you.

SSH host keys fingerprints

1024 SHA256:YKx8b7u5ZWdcbp7/4AeXNaqElP49m6QrwfXaqQGJAOk gerrit-code-review@openocd.zylin.com (DSA)
384 SHA256:jHIbSQa4REvwCFG4cq5LBlBLxmxSqelQPem/EXIrxjk gerrit-code-review@openocd.org (ECDSA)
521 SHA256:UAOPYkU9Fjtcao0Ul/Rrlnj/OsQvt+pgdYSZ4jOYdgs gerrit-code-review@openocd.org (ECDSA)
256 SHA256:A13M5QlnozFOvTllybRZH6vm7iSt0XLxbA48yfc2yfY gerrit-code-review@openocd.org (ECDSA)
256 SHA256:spYMBqEYoAOtK7yZBrcwE8ZpYt6b68Cfh9yEVetvbXg gerrit-code-review@openocd.org (ED25519)
+--[ED25519 256]--+
|=..              |
|+o..   .         |
|*.o   . .        |
|+B . . .         |
|Bo. = o S        |
|Oo.+ + =         |
|oB=.* = . o      |
| =+=.+   + E     |
|. .=o   . o      |
+----[SHA256]-----+
2048 SHA256:0Onrb7/PHjpo6iVZ7xQX2riKN83FJ3KGU0TvI0TaFG4 gerrit-code-review@openocd.zylin.com (RSA)