Code Review / openocd.git / blobdiff
? search:
summary | shortlog | log | commit | commitdiff | review | tree
raw | inline | side by side
FreeRTOS: strip duplicate line returns
[openocd.git] / src / rtos / FreeRTOS.c
diff --git a/src/rtos/FreeRTOS.c b/src/rtos/FreeRTOS.c
index 77c6e79d5414e99025d7cec073dcc8d4f80449ed..ee9b48bb9a807cc19d7efa9da8d040430377420c 100644 (file)
--- a/src/rtos/FreeRTOS.c
+++ b/src/rtos/FreeRTOS.c
@@ -37,6 +37,11 @@
 
 #define FreeRTOS_STRUCT(int_type, ptr_type, list_prev_offset)
 
+/* FIXME: none of the _width parameters are actually observed properly!
+ * you WILL need to edit more if you actually attempt to target a 8/16/64
+ * bit target!
+ */
+
 struct FreeRTOS_params {
        const char *target_name;
        const unsigned char thread_count_width;
@@ -157,9 +162,8 @@ static const struct symbols FreeRTOS_symbol_list[] = {
 
 static int FreeRTOS_update_threads(struct rtos *rtos)
 {
-       int i = 0;
        int retval;
-       int tasks_found = 0;
+       unsigned int tasks_found = 0;
        const struct FreeRTOS_params *param;
 
        if (rtos->rtos_specific_params == NULL)
@@ -177,12 +181,11 @@ static int FreeRTOS_update_threads(struct rtos *rtos)
                return -2;
        }
 
-       int thread_list_size = 0;
-       retval = target_read_buffer(rtos->target,
+       uint32_t thread_list_size = 0;
+       retval = target_read_u32(rtos->target,
                        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",
+                       &thread_list_size);
+       LOG_DEBUG("FreeRTOS: Read uxCurrentNumberOfTasks at 0x%" PRIx64 ", value %" PRIu32,
                                                                                rtos->symbols[FreeRTOS_VAL_uxCurrentNumberOfTasks].address,
                                                                                thread_list_size);
 
@@ -195,15 +198,16 @@ static int FreeRTOS_update_threads(struct rtos *rtos)
        rtos_free_threadlist(rtos);
 
        /* read the current thread */
-       retval = target_read_buffer(rtos->target,
+       uint32_t pointer_casts_are_bad;
+       retval = target_read_u32(rtos->target,
                        rtos->symbols[FreeRTOS_VAL_pxCurrentTCB].address,
-                       param->pointer_width,
-                       (uint8_t *)&rtos->current_thread);
+                       &pointer_casts_are_bad);
        if (retval != ERROR_OK) {
                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->current_thread = pointer_casts_are_bad;
+       LOG_DEBUG("FreeRTOS: Read pxCurrentTCB at 0x%" PRIx64 ", value 0x%" PRIx64,
                                                                                rtos->symbols[FreeRTOS_VAL_pxCurrentTCB].address,
                                                                                rtos->current_thread);
 
@@ -245,32 +249,37 @@ static int FreeRTOS_update_threads(struct rtos *rtos)
                LOG_ERROR("FreeRTOS: uxTopUsedPriority is not defined, consult the OpenOCD manual for a work-around");
                return ERROR_FAIL;
        }
-       int64_t max_used_priority = 0;
-       retval = target_read_buffer(rtos->target,
+       uint32_t top_used_priority = 0;
+       retval = target_read_u32(rtos->target,
                        rtos->symbols[FreeRTOS_VAL_uxTopUsedPriority].address,
-                       param->pointer_width,
-                       (uint8_t *)&max_used_priority);
+                       &top_used_priority);
        if (retval != ERROR_OK)
                return retval;
-       LOG_DEBUG("FreeRTOS: Read uxTopUsedPriority at 0x%" PRIx64 ", value %" PRId64 "\r\n",
+       LOG_DEBUG("FreeRTOS: Read uxTopUsedPriority at 0x%" PRIx64 ", value %" PRIu32,
                                                                                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);
+                                                                               top_used_priority);
+       if (top_used_priority > FREERTOS_MAX_PRIORITIES) {
+               LOG_ERROR("FreeRTOS top used priority is unreasonably big, not proceeding: %" PRIu32,
+                       top_used_priority);
                return ERROR_FAIL;
        }
 
+       /* uxTopUsedPriority was defined as configMAX_PRIORITIES - 1
+        * in old FreeRTOS versions (before V7.5.3)
+        * Use contrib/rtos-helpers/FreeRTOS-openocd.c to get compatible symbol
+        * in newer FreeRTOS versions.
+        * Here we restore the original configMAX_PRIORITIES value */
+       unsigned int config_max_priorities = top_used_priority + 1;
+
        symbol_address_t *list_of_lists =
-               malloc(sizeof(symbol_address_t) *
-                       (max_used_priority + 5));
+               malloc(sizeof(symbol_address_t) * (config_max_priorities + 5));
        if (!list_of_lists) {
-               LOG_ERROR("Error allocating memory for %" PRId64 " priorities", max_used_priority);
+               LOG_ERROR("Error allocating memory for %u priorities", config_max_priorities);
                return ERROR_FAIL;
        }
 
-       int num_lists;
-       for (num_lists = 0; num_lists < max_used_priority; num_lists++)
+       unsigned int num_lists;
+       for (num_lists = 0; num_lists < config_max_priorities; num_lists++)
                list_of_lists[num_lists] = rtos->symbols[FreeRTOS_VAL_pxReadyTasksLists].address +
                        num_lists * param->list_width;
 
@@ -280,40 +289,38 @@ static int FreeRTOS_update_threads(struct rtos *rtos)
        list_of_lists[num_lists++] = rtos->symbols[FreeRTOS_VAL_xSuspendedTaskList].address;
        list_of_lists[num_lists++] = rtos->symbols[FreeRTOS_VAL_xTasksWaitingTermination].address;
 
-       for (i = 0; i < num_lists; i++) {
+       for (unsigned int i = 0; i < num_lists; i++) {
                if (list_of_lists[i] == 0)
                        continue;
 
                /* Read the number of threads in this list */
-               int64_t list_thread_count = 0;
-               retval = target_read_buffer(rtos->target,
+               uint32_t list_thread_count = 0;
+               retval = target_read_u32(rtos->target,
                                list_of_lists[i],
-                               param->thread_count_width,
-                               (uint8_t *)&list_thread_count);
+                               &list_thread_count);
                if (retval != ERROR_OK) {
                        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",
+               LOG_DEBUG("FreeRTOS: Read thread count for list %u at 0x%" PRIx64 ", value %" PRIu32,
                                                                                i, list_of_lists[i], list_thread_count);
 
                if (list_thread_count == 0)
                        continue;
 
                /* Read the location of first list item */
-               uint64_t prev_list_elem_ptr = -1;
-               uint64_t list_elem_ptr = 0;
-               retval = target_read_buffer(rtos->target,
+               uint32_t prev_list_elem_ptr = -1;
+               uint32_t list_elem_ptr = 0;
+               retval = target_read_u32(rtos->target,
                                list_of_lists[i] + param->list_next_offset,
-                               param->pointer_width,
-                               (uint8_t *)&list_elem_ptr);
+                               &list_elem_ptr);
                if (retval != ERROR_OK) {
                        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",
+               LOG_DEBUG("FreeRTOS: Read first item for list %u at 0x%" PRIx64 ", value 0x%" PRIx32,
                                                                                i, list_of_lists[i] + param->list_next_offset, list_elem_ptr);
 
                while ((list_thread_count > 0) && (list_elem_ptr != 0) &&
@@ -321,16 +328,16 @@ static int FreeRTOS_update_threads(struct rtos *rtos)
                                (tasks_found < thread_list_size)) {
                        /* Get the location of the thread structure. */
                        rtos->thread_details[tasks_found].threadid = 0;
-                       retval = target_read_buffer(rtos->target,
+                       retval = target_read_u32(rtos->target,
                                        list_elem_ptr + param->list_elem_content_offset,
-                                       param->pointer_width,
-                                       (uint8_t *)&(rtos->thread_details[tasks_found].threadid));
+                                       &pointer_casts_are_bad);
                        if (retval != ERROR_OK) {
                                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",
+                       rtos->thread_details[tasks_found].threadid = pointer_casts_are_bad;
+                       LOG_DEBUG("FreeRTOS: Read Thread ID at 0x%" PRIx32 ", value 0x%" PRIx64,
                                                                                list_elem_ptr + param->list_elem_content_offset,
                                                                                rtos->thread_details[tasks_found].threadid);
 
@@ -350,7 +357,7 @@ static int FreeRTOS_update_threads(struct rtos *rtos)
                                return retval;
                        }
                        tmp_str[FREERTOS_THREAD_NAME_STR_SIZE-1] = '\x00';
-                       LOG_DEBUG("FreeRTOS: Read Thread Name at 0x%" PRIx64 ", value \"%s\"\r\n",
+                       LOG_DEBUG("FreeRTOS: Read Thread Name at 0x%" PRIx64 ", value '%s'",
                                                                                rtos->thread_details[tasks_found].threadid + param->thread_name_offset,
                                                                                tmp_str);
 
@@ -376,16 +383,15 @@ static int FreeRTOS_update_threads(struct rtos *rtos)
 
                        prev_list_elem_ptr = list_elem_ptr;
                        list_elem_ptr = 0;
-                       retval = target_read_buffer(rtos->target,
+                       retval = target_read_u32(rtos->target,
                                        prev_list_elem_ptr + param->list_elem_next_offset,
-                                       param->pointer_width,
-                                       (uint8_t *)&list_elem_ptr);
+                                       &list_elem_ptr);
                        if (retval != ERROR_OK) {
                                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",
+                       LOG_DEBUG("FreeRTOS: Read next thread location at 0x%" PRIx32 ", value 0x%" PRIx32,
                                                                                prev_list_elem_ptr + param->list_elem_next_offset,
                                                                                list_elem_ptr);
                }
@@ -415,15 +421,16 @@ static int FreeRTOS_get_thread_reg_list(struct rtos *rtos, int64_t thread_id,
        param = (const struct FreeRTOS_params *) rtos->rtos_specific_params;
 
        /* Read the stack pointer */
-       retval = target_read_buffer(rtos->target,
+       uint32_t pointer_casts_are_bad;
+       retval = target_read_u32(rtos->target,
                        thread_id + param->thread_stack_offset,
-                       param->pointer_width,
-                       (uint8_t *)&stack_ptr);
+                       &pointer_casts_are_bad);
        if (retval != ERROR_OK) {
                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",
+       stack_ptr = pointer_casts_are_bad;
+       LOG_DEBUG("FreeRTOS: Read stack pointer at 0x%" PRIx64 ", value 0x%" PRIx64,
                                                                                thread_id + param->thread_stack_offset,
                                                                                stack_ptr);
 
@@ -452,12 +459,11 @@ static int FreeRTOS_get_thread_reg_list(struct rtos *rtos, int64_t thread_id,
        if (cm4_fpu_enabled == 1) {
                /* Read the LR to decide between stacking with or without FPU */
                uint32_t LR_svc = 0;
-               retval = target_read_buffer(rtos->target,
+               retval = target_read_u32(rtos->target,
                                stack_ptr + 0x20,
-                               param->pointer_width,
-                               (uint8_t *)&LR_svc);
+                               &LR_svc);
                if (retval != ERROR_OK) {
-                       LOG_OUTPUT("Error reading stack frame from FreeRTOS thread\r\n");
+                       LOG_OUTPUT("Error reading stack frame from FreeRTOS thread");
                        return retval;
                }
                if ((LR_svc & 0x10) == 0)
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)