diff --git a/components/app_trace/Kconfig b/components/app_trace/Kconfig index 88010b882..e0a39f092 100644 --- a/components/app_trace/Kconfig +++ b/components/app_trace/Kconfig @@ -1,19 +1,19 @@ menu "Application Level Tracing" - choice ESP32_APPTRACE_DESTINATION + choice APPTRACE_DESTINATION prompt "Data Destination" - default ESP32_APPTRACE_DEST_NONE + default APPTRACE_DEST_NONE help Select destination for application trace: trace memory or none (to disable). - config ESP32_APPTRACE_DEST_TRAX + config APPTRACE_DEST_TRAX bool "Trace memory" - select ESP32_APPTRACE_ENABLE - config ESP32_APPTRACE_DEST_NONE + select APPTRACE_ENABLE + config APPTRACE_DEST_NONE bool "None" endchoice - config ESP32_APPTRACE_ENABLE + config APPTRACE_ENABLE bool depends on !ESP32_TRAX && !ESP32S2_TRAX select ESP32_MEMMAP_TRACEMEM @@ -24,33 +24,33 @@ menu "Application Level Tracing" help Enables/disable application tracing module. - config ESP32_APPTRACE_LOCK_ENABLE + config APPTRACE_LOCK_ENABLE bool default !SYSVIEW_ENABLE help Enables/disable application tracing module internal sync lock. - config ESP32_APPTRACE_ONPANIC_HOST_FLUSH_TMO + config APPTRACE_ONPANIC_HOST_FLUSH_TMO int "Timeout for flushing last trace data to host on panic" - depends on ESP32_APPTRACE_ENABLE + depends on APPTRACE_ENABLE range -1 5000 default -1 help Timeout for flushing last trace data to host in case of panic. In ms. Use -1 to disable timeout and wait forever. - config ESP32_APPTRACE_POSTMORTEM_FLUSH_THRESH + config APPTRACE_POSTMORTEM_FLUSH_THRESH int "Threshold for flushing last trace data to host on panic" - depends on ESP32_APPTRACE_DEST_TRAX + depends on APPTRACE_DEST_TRAX range 0 16384 default 0 help Threshold for flushing last trace data to host on panic in post-mortem mode. This is minimal amount of data needed to perform flush. In bytes. - config ESP32_APPTRACE_PENDING_DATA_SIZE_MAX + config APPTRACE_PENDING_DATA_SIZE_MAX int "Size of the pending data buffer" - depends on ESP32_APPTRACE_DEST_TRAX + depends on APPTRACE_DEST_TRAX default 0 help Size of the buffer for events in bytes. It is useful for buffering events from @@ -58,10 +58,10 @@ menu "Application Level Tracing" events will be discarded when main HW buffer is full. menu "FreeRTOS SystemView Tracing" - depends on ESP32_APPTRACE_ENABLE + depends on APPTRACE_ENABLE config SYSVIEW_ENABLE bool "SystemView Tracing Enable" - depends on ESP32_APPTRACE_ENABLE + depends on APPTRACE_ENABLE default n help Enables supporrt for SEGGER SystemView tracing functionality. @@ -210,10 +210,11 @@ menu "Application Level Tracing" endmenu - config ESP32_GCOV_ENABLE + config APPTRACE_GCOV_ENABLE bool "GCOV to Host Enable" - depends on ESP32_DEBUG_STUBS_ENABLE && ESP32_APPTRACE_ENABLE && !SYSVIEW_ENABLE - default y + depends on APPTRACE_ENABLE && !SYSVIEW_ENABLE + select ESP_DEBUG_STUBS_ENABLE + default n help Enables support for GCOV data transfer to host. diff --git a/components/app_trace/app_trace.c b/components/app_trace/app_trace.c index 041a3c029..37878924f 100644 --- a/components/app_trace/app_trace.c +++ b/components/app_trace/app_trace.c @@ -76,11 +76,11 @@ // It can happen that system panic occurs when there are very small amount of data which are not exposed to host yet (e.g. crash just after the // TRAX block switch). In this case the previous 16KB of collected data will be dropped and host will see the latest, but very small piece of trace. // It can be insufficient to diagnose the problem. To avoid such situations there is menuconfig option -// CONFIG_ESP32_APPTRACE_POSTMORTEM_FLUSH_THRESH +// CONFIG_APPTRACE_POSTMORTEM_FLUSH_THRESH // which controls the threshold for flushing data in case of panic. // - Streaming mode. Tracing module enters this mode when host connects to target and sets respective bits in control registers (per core). // In this mode before switching the block tracing module waits for the host to read all the data from the previously exposed block. -// On panic tracing module also waits (timeout is configured via menuconfig via CONFIG_ESP32_APPTRACE_ONPANIC_HOST_FLUSH_TMO) for the host to read all data. +// On panic tracing module also waits (timeout is configured via menuconfig via CONFIG_APPTRACE_ONPANIC_HOST_FLUSH_TMO) for the host to read all data. // 4. Communication Protocol // ========================= @@ -114,7 +114,7 @@ // has not completed reading of the previous one yet. So in this case time critical tracing calls (which can not be delayed for too long time due to // the lack of free memory in TRAX block) can be dropped. To avoid such scenarios tracing module implements data buffering. Buffered data will be sent // to the host later when TRAX block switch occurs. The maximum size of the buffered data is controlled by menuconfig option -// CONFIG_ESP32_APPTRACE_PENDING_DATA_SIZE_MAX. +// CONFIG_APPTRACE_PENDING_DATA_SIZE_MAX. // 4.4 Target Connection/Disconnection // ----------------------------------- @@ -167,7 +167,7 @@ #include "freertos/FreeRTOS.h" #include "esp_app_trace.h" -#if CONFIG_ESP32_APPTRACE_ENABLE +#if CONFIG_APPTRACE_ENABLE #define ESP_APPTRACE_MAX_VPRINTF_ARGS 256 #define ESP_APPTRACE_HOST_BUF_SIZE 256 @@ -309,17 +309,17 @@ typedef struct { typedef struct { volatile esp_apptrace_trax_state_t state; // state esp_apptrace_mem_block_t blocks[ESP_APPTRACE_TRAX_BLOCKS_NUM]; // memory blocks -#if CONFIG_ESP32_APPTRACE_PENDING_DATA_SIZE_MAX > 0 +#if CONFIG_APPTRACE_PENDING_DATA_SIZE_MAX > 0 // ring buffer control struct for pending user blocks esp_apptrace_rb_t rb_pend; // storage for pending user blocks - uint8_t pending_data[CONFIG_ESP32_APPTRACE_PENDING_DATA_SIZE_MAX + 1]; -#if CONFIG_ESP32_APPTRACE_PENDING_DATA_SIZE_MAX > ESP_APPTRACE_TRAX_BLOCK_SIZE + uint8_t pending_data[CONFIG_APPTRACE_PENDING_DATA_SIZE_MAX + 1]; +#if CONFIG_APPTRACE_PENDING_DATA_SIZE_MAX > ESP_APPTRACE_TRAX_BLOCK_SIZE // ring buffer control struct for pending user data chunks sizes, // every chunk contains whole number of user blocks and fit into TRAX memory block esp_apptrace_rb_t rb_pend_chunk_sz; // storage for above ring buffer data - uint16_t pending_chunk_sz[CONFIG_ESP32_APPTRACE_PENDING_DATA_SIZE_MAX/ESP_APPTRACE_TRAX_BLOCK_SIZE + 2]; + uint16_t pending_chunk_sz[CONFIG_APPTRACE_PENDING_DATA_SIZE_MAX/ESP_APPTRACE_TRAX_BLOCK_SIZE + 2]; // current (accumulated) pending user data chunk size uint16_t cur_pending_chunk_sz; #endif @@ -397,7 +397,7 @@ static inline void esp_apptrace_log_unlock(void) static inline esp_err_t esp_apptrace_lock_initialize(esp_apptrace_lock_t *lock) { -#if CONFIG_ESP32_APPTRACE_LOCK_ENABLE +#if CONFIG_APPTRACE_LOCK_ENABLE esp_apptrace_lock_init(lock); #endif return ESP_OK; @@ -410,7 +410,7 @@ static inline esp_err_t esp_apptrace_lock_cleanup(void) esp_err_t esp_apptrace_lock(esp_apptrace_tmo_t *tmo) { -#if CONFIG_ESP32_APPTRACE_LOCK_ENABLE +#if CONFIG_APPTRACE_LOCK_ENABLE esp_err_t ret = esp_apptrace_lock_take(&s_trace_buf.lock, tmo); if (ret != ESP_OK) { return ESP_FAIL; @@ -422,13 +422,13 @@ esp_err_t esp_apptrace_lock(esp_apptrace_tmo_t *tmo) esp_err_t esp_apptrace_unlock(void) { esp_err_t ret = ESP_OK; -#if CONFIG_ESP32_APPTRACE_LOCK_ENABLE +#if CONFIG_APPTRACE_LOCK_ENABLE ret = esp_apptrace_lock_give(&s_trace_buf.lock); #endif return ret; } -#if CONFIG_ESP32_APPTRACE_DEST_TRAX +#if CONFIG_APPTRACE_DEST_TRAX static inline void esp_apptrace_trax_select_memory_block(int block_num) { @@ -453,7 +453,7 @@ static void esp_apptrace_trax_init(void) ESP_APPTRACE_LOGI("Initialized TRAX on CPU%d", xPortGetCoreID()); } -#if CONFIG_ESP32_APPTRACE_PENDING_DATA_SIZE_MAX > ESP_APPTRACE_TRAX_BLOCK_SIZE +#if CONFIG_APPTRACE_PENDING_DATA_SIZE_MAX > ESP_APPTRACE_TRAX_BLOCK_SIZE // keep the size of buffered data for copying to TRAX mem block. // Only whole user blocks should be copied from buffer to TRAX block upon the switch static void esp_apptrace_trax_pend_chunk_sz_update(uint16_t size) @@ -544,9 +544,9 @@ static esp_err_t esp_apptrace_trax_block_switch(void) } hdr->block_sz = 0; } -#if CONFIG_ESP32_APPTRACE_PENDING_DATA_SIZE_MAX > 0 +#if CONFIG_APPTRACE_PENDING_DATA_SIZE_MAX > 0 // copy pending data to TRAX block if any -#if CONFIG_ESP32_APPTRACE_PENDING_DATA_SIZE_MAX > ESP_APPTRACE_TRAX_BLOCK_SIZE +#if CONFIG_APPTRACE_PENDING_DATA_SIZE_MAX > ESP_APPTRACE_TRAX_BLOCK_SIZE uint16_t max_chunk_sz = esp_apptrace_trax_pend_chunk_sz_get(); #else uint16_t max_chunk_sz = s_trace_buf.trax.blocks[new_block_num].sz; @@ -554,7 +554,7 @@ static esp_err_t esp_apptrace_trax_block_switch(void) while (s_trace_buf.trax.state.markers[new_block_num] < max_chunk_sz) { uint32_t read_sz = esp_apptrace_rb_read_size_get(&s_trace_buf.trax.rb_pend); if (read_sz == 0) { -#if CONFIG_ESP32_APPTRACE_PENDING_DATA_SIZE_MAX > ESP_APPTRACE_TRAX_BLOCK_SIZE +#if CONFIG_APPTRACE_PENDING_DATA_SIZE_MAX > ESP_APPTRACE_TRAX_BLOCK_SIZE /* theres is a bug: esp_apptrace_trax_pend_chunk_sz_get returned wrong value, it must be greater or equal to one returned by esp_apptrace_rb_read_size_get */ ESP_APPTRACE_LOGE("No pended bytes, must be > 0 and <= %d!", max_chunk_sz); @@ -697,7 +697,7 @@ static inline uint8_t *esp_apptrace_trax_wait4buf(uint16_t size, esp_apptrace_tm return NULL; } // check if we still have pending data -#if CONFIG_ESP32_APPTRACE_PENDING_DATA_SIZE_MAX > 0 +#if CONFIG_APPTRACE_PENDING_DATA_SIZE_MAX > 0 if (esp_apptrace_rb_read_size_get(&s_trace_buf.trax.rb_pend) > 0) { // if after TRAX block switch still have pending data (not all pending data have been pumped to TRAX block) // alloc new pending buffer @@ -711,7 +711,7 @@ static inline uint8_t *esp_apptrace_trax_wait4buf(uint16_t size, esp_apptrace_tm { // update block pointers if (ESP_APPTRACE_TRAX_INBLOCK_MARKER() + size > ESP_APPTRACE_TRAX_INBLOCK_GET()->sz) { -#if CONFIG_ESP32_APPTRACE_PENDING_DATA_SIZE_MAX > 0 +#if CONFIG_APPTRACE_PENDING_DATA_SIZE_MAX > 0 *pended = 1; ptr = esp_apptrace_rb_produce(&s_trace_buf.trax.rb_pend, size); if (ptr == NULL) { @@ -741,7 +741,7 @@ static uint8_t *esp_apptrace_trax_get_buffer(uint32_t size, esp_apptrace_tmo_t * return NULL; } // check for data in the pending buffer -#if CONFIG_ESP32_APPTRACE_PENDING_DATA_SIZE_MAX > 0 +#if CONFIG_APPTRACE_PENDING_DATA_SIZE_MAX > 0 if (esp_apptrace_rb_read_size_get(&s_trace_buf.trax.rb_pend) > 0) { // if we have buffered data try to switch TRAX block esp_apptrace_trax_block_switch(); @@ -756,7 +756,7 @@ static uint8_t *esp_apptrace_trax_get_buffer(uint32_t size, esp_apptrace_tmo_t * buf_ptr = esp_apptrace_trax_wait4buf(ESP_APPTRACE_USR_BLOCK_RAW_SZ(size), tmo, &pended_buf); if (buf_ptr) { if (pended_buf) { -#if CONFIG_ESP32_APPTRACE_PENDING_DATA_SIZE_MAX > ESP_APPTRACE_TRAX_BLOCK_SIZE +#if CONFIG_APPTRACE_PENDING_DATA_SIZE_MAX > ESP_APPTRACE_TRAX_BLOCK_SIZE esp_apptrace_trax_pend_chunk_sz_update(ESP_APPTRACE_USR_BLOCK_RAW_SZ(size)); #endif } else { @@ -766,18 +766,18 @@ static uint8_t *esp_apptrace_trax_get_buffer(uint32_t size, esp_apptrace_tmo_t * } } } else { -#if CONFIG_ESP32_APPTRACE_PENDING_DATA_SIZE_MAX > ESP_APPTRACE_TRAX_BLOCK_SIZE +#if CONFIG_APPTRACE_PENDING_DATA_SIZE_MAX > ESP_APPTRACE_TRAX_BLOCK_SIZE esp_apptrace_trax_pend_chunk_sz_update(ESP_APPTRACE_USR_BLOCK_RAW_SZ(size)); #endif } } else #endif if (ESP_APPTRACE_TRAX_INBLOCK_MARKER() + ESP_APPTRACE_USR_BLOCK_RAW_SZ(size) > ESP_APPTRACE_TRAX_INBLOCK_GET()->sz) { -#if CONFIG_ESP32_APPTRACE_PENDING_DATA_SIZE_MAX > 0 +#if CONFIG_APPTRACE_PENDING_DATA_SIZE_MAX > 0 ESP_APPTRACE_LOGD("TRAX full. Get %d bytes from PEND buffer", size); buf_ptr = esp_apptrace_rb_produce(&s_trace_buf.trax.rb_pend, ESP_APPTRACE_USR_BLOCK_RAW_SZ(size)); if (buf_ptr) { -#if CONFIG_ESP32_APPTRACE_PENDING_DATA_SIZE_MAX > ESP_APPTRACE_TRAX_BLOCK_SIZE +#if CONFIG_APPTRACE_PENDING_DATA_SIZE_MAX > ESP_APPTRACE_TRAX_BLOCK_SIZE esp_apptrace_trax_pend_chunk_sz_update(ESP_APPTRACE_USR_BLOCK_RAW_SZ(size)); #endif } @@ -788,7 +788,7 @@ static uint8_t *esp_apptrace_trax_get_buffer(uint32_t size, esp_apptrace_tmo_t * buf_ptr = esp_apptrace_trax_wait4buf(ESP_APPTRACE_USR_BLOCK_RAW_SZ(size), tmo, &pended_buf); if (buf_ptr) { if (pended_buf) { -#if CONFIG_ESP32_APPTRACE_PENDING_DATA_SIZE_MAX > ESP_APPTRACE_TRAX_BLOCK_SIZE +#if CONFIG_APPTRACE_PENDING_DATA_SIZE_MAX > ESP_APPTRACE_TRAX_BLOCK_SIZE esp_apptrace_trax_pend_chunk_sz_update(ESP_APPTRACE_USR_BLOCK_RAW_SZ(size)); #endif } else { @@ -880,10 +880,10 @@ static esp_err_t esp_apptrace_trax_dest_init(void) s_trace_buf.trax.state.markers[i] = 0; } s_trace_buf.trax.state.in_block = ESP_APPTRACE_TRAX_INBLOCK_START; -#if CONFIG_ESP32_APPTRACE_PENDING_DATA_SIZE_MAX > 0 +#if CONFIG_APPTRACE_PENDING_DATA_SIZE_MAX > 0 esp_apptrace_rb_init(&s_trace_buf.trax.rb_pend, s_trace_buf.trax.pending_data, sizeof(s_trace_buf.trax.pending_data)); -#if CONFIG_ESP32_APPTRACE_PENDING_DATA_SIZE_MAX > ESP_APPTRACE_TRAX_BLOCK_SIZE +#if CONFIG_APPTRACE_PENDING_DATA_SIZE_MAX > ESP_APPTRACE_TRAX_BLOCK_SIZE s_trace_buf.trax.cur_pending_chunk_sz = 0; esp_apptrace_rb_init(&s_trace_buf.trax.rb_pend_chunk_sz, (uint8_t *)s_trace_buf.trax.pending_chunk_sz, sizeof(s_trace_buf.trax.pending_chunk_sz)); @@ -915,7 +915,7 @@ esp_err_t esp_apptrace_init(void) ESP_APPTRACE_LOGE("Failed to init log lock (%d)!", res); return res; } -#if CONFIG_ESP32_APPTRACE_DEST_TRAX +#if CONFIG_APPTRACE_DEST_TRAX res = esp_apptrace_trax_dest_init(); if (res != ESP_OK) { ESP_APPTRACE_LOGE("Failed to init TRAX dest data (%d)!", res); @@ -925,7 +925,7 @@ esp_err_t esp_apptrace_init(void) #endif } -#if CONFIG_ESP32_APPTRACE_DEST_TRAX +#if CONFIG_APPTRACE_DEST_TRAX // init TRAX on this CPU esp_apptrace_trax_init(); #endif @@ -947,7 +947,7 @@ esp_err_t esp_apptrace_read(esp_apptrace_dest_t dest, void *buf, uint32_t *size, esp_apptrace_hw_t *hw = NULL; if (dest == ESP_APPTRACE_DEST_TRAX) { -#if CONFIG_ESP32_APPTRACE_DEST_TRAX +#if CONFIG_APPTRACE_DEST_TRAX hw = ESP_APPTRACE_HW(ESP_APPTRACE_HW_TRAX); #else ESP_APPTRACE_LOGE("Application tracing via TRAX is disabled in menuconfig!"); @@ -984,7 +984,7 @@ uint8_t *esp_apptrace_down_buffer_get(esp_apptrace_dest_t dest, uint32_t *size, esp_apptrace_hw_t *hw = NULL; if (dest == ESP_APPTRACE_DEST_TRAX) { -#if CONFIG_ESP32_APPTRACE_DEST_TRAX +#if CONFIG_APPTRACE_DEST_TRAX hw = ESP_APPTRACE_HW(ESP_APPTRACE_HW_TRAX); #else ESP_APPTRACE_LOGE("Application tracing via TRAX is disabled in menuconfig!"); @@ -1008,7 +1008,7 @@ esp_err_t esp_apptrace_down_buffer_put(esp_apptrace_dest_t dest, uint8_t *ptr, u esp_apptrace_hw_t *hw = NULL; if (dest == ESP_APPTRACE_DEST_TRAX) { -#if CONFIG_ESP32_APPTRACE_DEST_TRAX +#if CONFIG_APPTRACE_DEST_TRAX hw = ESP_APPTRACE_HW(ESP_APPTRACE_HW_TRAX); #else ESP_APPTRACE_LOGE("Application tracing via TRAX is disabled in menuconfig!"); @@ -1033,7 +1033,7 @@ esp_err_t esp_apptrace_write(esp_apptrace_dest_t dest, const void *data, uint32_ esp_apptrace_hw_t *hw = NULL; if (dest == ESP_APPTRACE_DEST_TRAX) { -#if CONFIG_ESP32_APPTRACE_DEST_TRAX +#if CONFIG_APPTRACE_DEST_TRAX hw = ESP_APPTRACE_HW(ESP_APPTRACE_HW_TRAX); #else ESP_APPTRACE_LOGE("Application tracing via TRAX is disabled in menuconfig!"); @@ -1069,7 +1069,7 @@ int esp_apptrace_vprintf_to(esp_apptrace_dest_t dest, uint32_t user_tmo, const c esp_apptrace_hw_t *hw = NULL; if (dest == ESP_APPTRACE_DEST_TRAX) { -#if CONFIG_ESP32_APPTRACE_DEST_TRAX +#if CONFIG_APPTRACE_DEST_TRAX hw = ESP_APPTRACE_HW(ESP_APPTRACE_HW_TRAX); #else ESP_APPTRACE_LOGE("Application tracing via TRAX is disabled in menuconfig!"); @@ -1133,7 +1133,7 @@ uint8_t *esp_apptrace_buffer_get(esp_apptrace_dest_t dest, uint32_t size, uint32 esp_apptrace_hw_t *hw = NULL; if (dest == ESP_APPTRACE_DEST_TRAX) { -#if CONFIG_ESP32_APPTRACE_DEST_TRAX +#if CONFIG_APPTRACE_DEST_TRAX hw = ESP_APPTRACE_HW(ESP_APPTRACE_HW_TRAX); #else ESP_APPTRACE_LOGE("Application tracing via TRAX is disabled in menuconfig!"); @@ -1157,7 +1157,7 @@ esp_err_t esp_apptrace_buffer_put(esp_apptrace_dest_t dest, uint8_t *ptr, uint32 esp_apptrace_hw_t *hw = NULL; if (dest == ESP_APPTRACE_DEST_TRAX) { -#if CONFIG_ESP32_APPTRACE_DEST_TRAX +#if CONFIG_APPTRACE_DEST_TRAX hw = ESP_APPTRACE_HW(ESP_APPTRACE_HW_TRAX); #else ESP_APPTRACE_LOGE("Application tracing via TRAX is disabled in menuconfig!"); @@ -1181,7 +1181,7 @@ esp_err_t esp_apptrace_flush_nolock(esp_apptrace_dest_t dest, uint32_t min_sz, u esp_apptrace_hw_t *hw = NULL; if (dest == ESP_APPTRACE_DEST_TRAX) { -#if CONFIG_ESP32_APPTRACE_DEST_TRAX +#if CONFIG_APPTRACE_DEST_TRAX hw = ESP_APPTRACE_HW(ESP_APPTRACE_HW_TRAX); #else ESP_APPTRACE_LOGE("Application tracing via TRAX is disabled in menuconfig!"); @@ -1225,7 +1225,7 @@ bool esp_apptrace_host_is_connected(esp_apptrace_dest_t dest) esp_apptrace_hw_t *hw = NULL; if (dest == ESP_APPTRACE_DEST_TRAX) { -#if CONFIG_ESP32_APPTRACE_DEST_TRAX +#if CONFIG_APPTRACE_DEST_TRAX hw = ESP_APPTRACE_HW(ESP_APPTRACE_HW_TRAX); #else ESP_APPTRACE_LOGE("Application tracing via TRAX is disabled in menuconfig!"); @@ -1243,7 +1243,7 @@ esp_err_t esp_apptrace_status_reg_set(esp_apptrace_dest_t dest, uint32_t val) esp_apptrace_hw_t *hw = NULL; if (dest == ESP_APPTRACE_DEST_TRAX) { -#if CONFIG_ESP32_APPTRACE_DEST_TRAX +#if CONFIG_APPTRACE_DEST_TRAX hw = ESP_APPTRACE_HW(ESP_APPTRACE_HW_TRAX); #else ESP_APPTRACE_LOGE("Application tracing via TRAX is disabled in menuconfig!"); @@ -1261,7 +1261,7 @@ esp_err_t esp_apptrace_status_reg_get(esp_apptrace_dest_t dest, uint32_t *val) esp_apptrace_hw_t *hw = NULL; if (dest == ESP_APPTRACE_DEST_TRAX) { -#if CONFIG_ESP32_APPTRACE_DEST_TRAX +#if CONFIG_APPTRACE_DEST_TRAX hw = ESP_APPTRACE_HW(ESP_APPTRACE_HW_TRAX); #else ESP_APPTRACE_LOGE("Application tracing via TRAX is disabled in menuconfig!"); diff --git a/components/app_trace/gcov/gcov_rtio.c b/components/app_trace/gcov/gcov_rtio.c index a6008b463..b376643f5 100644 --- a/components/app_trace/gcov/gcov_rtio.c +++ b/components/app_trace/gcov/gcov_rtio.c @@ -23,7 +23,7 @@ #include "esp_private/dbg_stubs.h" #include "hal/timer_ll.h" -#if CONFIG_ESP32_GCOV_ENABLE +#if CONFIG_APPTRACE_GCOV_ENABLE #define ESP_GCOV_DOWN_BUF_SIZE 4200 diff --git a/components/app_trace/host_file_io.c b/components/app_trace/host_file_io.c index b59b837aa..021fe21ac 100644 --- a/components/app_trace/host_file_io.c +++ b/components/app_trace/host_file_io.c @@ -25,7 +25,7 @@ #include #include "esp_app_trace.h" -#if CONFIG_ESP32_APPTRACE_ENABLE +#if CONFIG_APPTRACE_ENABLE #define LOG_LOCAL_LEVEL CONFIG_LOG_DEFAULT_LEVEL #include "esp_log.h" diff --git a/components/app_trace/sdkconfig.rename b/components/app_trace/sdkconfig.rename index 418efcf65..c8f669369 100644 --- a/components/app_trace/sdkconfig.rename +++ b/components/app_trace/sdkconfig.rename @@ -1,4 +1,12 @@ # sdkconfig replacement configurations for deprecated options formatted as # CONFIG_DEPRECATED_OPTION CONFIG_NEW_OPTION -CONFIG_ESP32_APPTRACE_POSTMORTEM_FLUSH_TRAX_THRESH CONFIG_ESP32_APPTRACE_POSTMORTEM_FLUSH_THRESH +CONFIG_ESP32_APPTRACE_DESTINATION CONFIG_APPTRACE_DESTINATION +CONFIG_ESP32_APPTRACE_DEST_NONE CONFIG_APPTRACE_DEST_NONE +CONFIG_ESP32_APPTRACE_DEST_TRAX CONFIG_APPTRACE_DEST_TRAX +CONFIG_ESP32_APPTRACE_ENABLE CONFIG_APPTRACE_ENABLE +CONFIG_ESP32_APPTRACE_LOCK_ENABLE CONFIG_APPTRACE_LOCK_ENABLE +CONFIG_ESP32_APPTRACE_ONPANIC_HOST_FLUSH_TMO CONFIG_APPTRACE_ONPANIC_HOST_FLUSH_TMO +CONFIG_ESP32_APPTRACE_POSTMORTEM_FLUSH_TRAX_THRESH CONFIG_APPTRACE_POSTMORTEM_FLUSH_THRESH +CONFIG_ESP32_APPTRACE_PENDING_DATA_SIZE_MAX CONFIG_APPTRACE_PENDING_DATA_SIZE_MAX +CONFIG_ESP32_GCOV_ENABLE CONFIG_APPTRACE_GCOV_ENABLE \ No newline at end of file diff --git a/components/app_trace/test/test_trace.c b/components/app_trace/test/test_trace.c index 2e19e5808..d44e33fa9 100644 --- a/components/app_trace/test/test_trace.c +++ b/components/app_trace/test/test_trace.c @@ -9,7 +9,7 @@ #include "freertos/FreeRTOS.h" #include "freertos/semphr.h" #include "freertos/task.h" -#if CONFIG_ESP32_APPTRACE_ENABLE == 1 +#if CONFIG_APPTRACE_ENABLE == 1 #include "esp_app_trace.h" #include "esp_app_trace_util.h" diff --git a/components/esp32/Kconfig b/components/esp32/Kconfig index bb5176945..29b71ea96 100644 --- a/components/esp32/Kconfig +++ b/components/esp32/Kconfig @@ -389,14 +389,6 @@ menu "ESP32-specific" The FreeRTOS panic and unhandled exception handers can detect a JTAG OCD debugger and instead of panicking, have the debugger stop on the offending instruction. - config ESP32_DEBUG_STUBS_ENABLE - bool "OpenOCD debug stubs" - default COMPILER_OPTIMIZATION_DEFAULT - depends on !ESP32_TRAX - help - Debug stubs are used by OpenOCD to execute pre-compiled onboard code which does some useful debugging, - e.g. GCOV data dump. - config ESP32_BROWNOUT_DET bool "Hardware brownout detect & reset" default y diff --git a/components/esp32/cpu_start.c b/components/esp32/cpu_start.c index ebea01b62..7f30541ec 100644 --- a/components/esp32/cpu_start.c +++ b/components/esp32/cpu_start.c @@ -372,14 +372,14 @@ void start_cpu0_default(void) #endif esp_timer_init(); esp_set_time_from_rtc(); -#if CONFIG_ESP32_APPTRACE_ENABLE +#if CONFIG_APPTRACE_ENABLE err = esp_apptrace_init(); assert(err == ESP_OK && "Failed to init apptrace module on PRO CPU!"); #endif #if CONFIG_SYSVIEW_ENABLE SEGGER_SYSVIEW_Conf(); #endif -#if CONFIG_ESP32_DEBUG_STUBS_ENABLE +#if CONFIG_ESP_DEBUG_STUBS_ENABLE esp_dbg_stubs_init(); #endif err = esp_pthread_init(); @@ -474,7 +474,7 @@ void start_cpu1_default(void) #if CONFIG_ESP32_TRAX_TWOBANKS trax_start_trace(TRAX_DOWNCOUNT_WORDS); #endif -#if CONFIG_ESP32_APPTRACE_ENABLE +#if CONFIG_APPTRACE_ENABLE esp_err_t err = esp_apptrace_init(); assert(err == ESP_OK && "Failed to init apptrace module on APP CPU!"); #endif diff --git a/components/esp32/panic.c b/components/esp32/panic.c index 2c45ec09f..8ef431a8e 100644 --- a/components/esp32/panic.c +++ b/components/esp32/panic.c @@ -50,10 +50,10 @@ #include "SEGGER_RTT.h" #endif -#if CONFIG_ESP32_APPTRACE_ONPANIC_HOST_FLUSH_TMO == -1 +#if CONFIG_APPTRACE_ONPANIC_HOST_FLUSH_TMO == -1 #define APPTRACE_ONPANIC_HOST_FLUSH_TMO ESP_APPTRACE_TMO_INFINITE #else -#define APPTRACE_ONPANIC_HOST_FLUSH_TMO (1000*CONFIG_ESP32_APPTRACE_ONPANIC_HOST_FLUSH_TMO) +#define APPTRACE_ONPANIC_HOST_FLUSH_TMO (1000*CONFIG_APPTRACE_ONPANIC_HOST_FLUSH_TMO) #endif /* Panic handlers; these get called when an unhandled exception occurs or the assembly-level @@ -144,11 +144,11 @@ static bool abort_called; static __attribute__((noreturn)) inline void invoke_abort(void) { abort_called = true; -#if CONFIG_ESP32_APPTRACE_ENABLE +#if CONFIG_APPTRACE_ENABLE #if CONFIG_SYSVIEW_ENABLE - SEGGER_RTT_ESP32_FlushNoLock(CONFIG_ESP32_APPTRACE_POSTMORTEM_FLUSH_THRESH, APPTRACE_ONPANIC_HOST_FLUSH_TMO); + SEGGER_RTT_ESP32_FlushNoLock(CONFIG_APPTRACE_POSTMORTEM_FLUSH_THRESH, APPTRACE_ONPANIC_HOST_FLUSH_TMO); #else - esp_apptrace_flush_nolock(ESP_APPTRACE_DEST_TRAX, CONFIG_ESP32_APPTRACE_POSTMORTEM_FLUSH_THRESH, + esp_apptrace_flush_nolock(ESP_APPTRACE_DEST_TRAX, CONFIG_APPTRACE_POSTMORTEM_FLUSH_THRESH, APPTRACE_ONPANIC_HOST_FLUSH_TMO); #endif #endif @@ -315,11 +315,11 @@ void panicHandler(XtExcFrame *frame) frame->exccause == PANIC_RSN_INTWDT_CPU1) { timer_group_clr_intr_sta_in_isr(TIMER_GROUP_1, TIMER_INTR_WDT); } -#if CONFIG_ESP32_APPTRACE_ENABLE +#if CONFIG_APPTRACE_ENABLE #if CONFIG_SYSVIEW_ENABLE - SEGGER_RTT_ESP32_FlushNoLock(CONFIG_ESP32_APPTRACE_POSTMORTEM_FLUSH_THRESH, APPTRACE_ONPANIC_HOST_FLUSH_TMO); + SEGGER_RTT_ESP32_FlushNoLock(CONFIG_APPTRACE_POSTMORTEM_FLUSH_THRESH, APPTRACE_ONPANIC_HOST_FLUSH_TMO); #else - esp_apptrace_flush_nolock(ESP_APPTRACE_DEST_TRAX, CONFIG_ESP32_APPTRACE_POSTMORTEM_FLUSH_THRESH, + esp_apptrace_flush_nolock(ESP_APPTRACE_DEST_TRAX, CONFIG_APPTRACE_POSTMORTEM_FLUSH_THRESH, APPTRACE_ONPANIC_HOST_FLUSH_TMO); #endif #endif @@ -348,11 +348,11 @@ void xt_unhandled_exception(XtExcFrame *frame) panicPutStr(" at pc="); panicPutHex(frame->pc); panicPutStr(". Setting bp and returning..\r\n"); -#if CONFIG_ESP32_APPTRACE_ENABLE +#if CONFIG_APPTRACE_ENABLE #if CONFIG_SYSVIEW_ENABLE - SEGGER_RTT_ESP32_FlushNoLock(CONFIG_ESP32_APPTRACE_POSTMORTEM_FLUSH_THRESH, APPTRACE_ONPANIC_HOST_FLUSH_TMO); + SEGGER_RTT_ESP32_FlushNoLock(CONFIG_APPTRACE_POSTMORTEM_FLUSH_THRESH, APPTRACE_ONPANIC_HOST_FLUSH_TMO); #else - esp_apptrace_flush_nolock(ESP_APPTRACE_DEST_TRAX, CONFIG_ESP32_APPTRACE_POSTMORTEM_FLUSH_THRESH, + esp_apptrace_flush_nolock(ESP_APPTRACE_DEST_TRAX, CONFIG_APPTRACE_POSTMORTEM_FLUSH_THRESH, APPTRACE_ONPANIC_HOST_FLUSH_TMO); #endif #endif @@ -597,12 +597,12 @@ static __attribute__((noreturn)) void commonErrorHandler(XtExcFrame *frame) } #endif //!CONFIG_FREERTOS_UNICORE -#if CONFIG_ESP32_APPTRACE_ENABLE +#if CONFIG_APPTRACE_ENABLE disableAllWdts(); #if CONFIG_SYSVIEW_ENABLE - SEGGER_RTT_ESP32_FlushNoLock(CONFIG_ESP32_APPTRACE_POSTMORTEM_FLUSH_THRESH, APPTRACE_ONPANIC_HOST_FLUSH_TMO); + SEGGER_RTT_ESP32_FlushNoLock(CONFIG_APPTRACE_POSTMORTEM_FLUSH_THRESH, APPTRACE_ONPANIC_HOST_FLUSH_TMO); #else - esp_apptrace_flush_nolock(ESP_APPTRACE_DEST_TRAX, CONFIG_ESP32_APPTRACE_POSTMORTEM_FLUSH_THRESH, + esp_apptrace_flush_nolock(ESP_APPTRACE_DEST_TRAX, CONFIG_APPTRACE_POSTMORTEM_FLUSH_THRESH, APPTRACE_ONPANIC_HOST_FLUSH_TMO); #endif reconfigureAllWdts(); diff --git a/components/esp32s2beta/cpu_start.c b/components/esp32s2beta/cpu_start.c index a23b00afe..c1c0a8722 100644 --- a/components/esp32s2beta/cpu_start.c +++ b/components/esp32s2beta/cpu_start.c @@ -294,7 +294,7 @@ void start_cpu0_default(void) #endif esp_timer_init(); esp_set_time_from_rtc(); -#if CONFIG_ESP32_APPTRACE_ENABLE +#if CONFIG_APPTRACE_ENABLE err = esp_apptrace_init(); assert(err == ESP_OK && "Failed to init apptrace module on PRO CPU!"); #endif diff --git a/components/esp32s2beta/panic.c b/components/esp32s2beta/panic.c index 0082e0a85..1e2a82550 100644 --- a/components/esp32s2beta/panic.c +++ b/components/esp32s2beta/panic.c @@ -48,10 +48,10 @@ #include "SEGGER_RTT.h" #endif -#if CONFIG_ESP32_APPTRACE_ONPANIC_HOST_FLUSH_TMO == -1 +#if CONFIG_APPTRACE_ONPANIC_HOST_FLUSH_TMO == -1 #define APPTRACE_ONPANIC_HOST_FLUSH_TMO ESP_APPTRACE_TMO_INFINITE #else -#define APPTRACE_ONPANIC_HOST_FLUSH_TMO (1000*CONFIG_ESP32_APPTRACE_ONPANIC_HOST_FLUSH_TMO) +#define APPTRACE_ONPANIC_HOST_FLUSH_TMO (1000*CONFIG_APPTRACE_ONPANIC_HOST_FLUSH_TMO) #endif /* Panic handlers; these get called when an unhandled exception occurs or the assembly-level @@ -128,11 +128,11 @@ static bool abort_called; static __attribute__((noreturn)) inline void invoke_abort(void) { abort_called = true; -#if CONFIG_ESP32_APPTRACE_ENABLE +#if CONFIG_APPTRACE_ENABLE #if CONFIG_SYSVIEW_ENABLE - SEGGER_RTT_ESP32_FlushNoLock(CONFIG_ESP32_APPTRACE_POSTMORTEM_FLUSH_TRAX_THRESH, APPTRACE_ONPANIC_HOST_FLUSH_TMO); + SEGGER_RTT_ESP32_FlushNoLock(CONFIG_APPTRACE_POSTMORTEM_FLUSH_THRESH, APPTRACE_ONPANIC_HOST_FLUSH_TMO); #else - esp_apptrace_flush_nolock(ESP_APPTRACE_DEST_TRAX, CONFIG_ESP32_APPTRACE_POSTMORTEM_FLUSH_TRAX_THRESH, + esp_apptrace_flush_nolock(ESP_APPTRACE_DEST_TRAX, CONFIG_APPTRACE_POSTMORTEM_FLUSH_THRESH, APPTRACE_ONPANIC_HOST_FLUSH_TMO); #endif #endif @@ -380,11 +380,11 @@ void panicHandler(XtExcFrame *frame) frame->exccause == PANIC_RSN_INTWDT_CPU1) { TIMERG1.int_clr.wdt = 1; } -#if CONFIG_ESP32_APPTRACE_ENABLE +#if CONFIG_APPTRACE_ENABLE #if CONFIG_SYSVIEW_ENABLE - SEGGER_RTT_ESP32_FlushNoLock(CONFIG_ESP32_APPTRACE_POSTMORTEM_FLUSH_TRAX_THRESH, APPTRACE_ONPANIC_HOST_FLUSH_TMO); + SEGGER_RTT_ESP32_FlushNoLock(CONFIG_APPTRACE_POSTMORTEM_FLUSH_THRESH, APPTRACE_ONPANIC_HOST_FLUSH_TMO); #else - esp_apptrace_flush_nolock(ESP_APPTRACE_DEST_TRAX, CONFIG_ESP32_APPTRACE_POSTMORTEM_FLUSH_TRAX_THRESH, + esp_apptrace_flush_nolock(ESP_APPTRACE_DEST_TRAX, CONFIG_APPTRACE_POSTMORTEM_FLUSH_THRESH, APPTRACE_ONPANIC_HOST_FLUSH_TMO); #endif #endif @@ -413,11 +413,11 @@ void xt_unhandled_exception(XtExcFrame *frame) panicPutStr(" at pc="); panicPutHex(frame->pc); panicPutStr(". Setting bp and returning..\r\n"); -#if CONFIG_ESP32_APPTRACE_ENABLE +#if CONFIG_APPTRACE_ENABLE #if CONFIG_SYSVIEW_ENABLE - SEGGER_RTT_ESP32_FlushNoLock(CONFIG_ESP32_APPTRACE_POSTMORTEM_FLUSH_TRAX_THRESH, APPTRACE_ONPANIC_HOST_FLUSH_TMO); + SEGGER_RTT_ESP32_FlushNoLock(CONFIG_APPTRACE_POSTMORTEM_FLUSH_THRESH, APPTRACE_ONPANIC_HOST_FLUSH_TMO); #else - esp_apptrace_flush_nolock(ESP_APPTRACE_DEST_TRAX, CONFIG_ESP32_APPTRACE_POSTMORTEM_FLUSH_TRAX_THRESH, + esp_apptrace_flush_nolock(ESP_APPTRACE_DEST_TRAX, CONFIG_APPTRACE_POSTMORTEM_FLUSH_THRESH, APPTRACE_ONPANIC_HOST_FLUSH_TMO); #endif #endif @@ -625,12 +625,12 @@ static __attribute__((noreturn)) void commonErrorHandler(XtExcFrame *frame) } #endif //!CONFIG_FREERTOS_UNICORE -#if CONFIG_ESP32_APPTRACE_ENABLE +#if CONFIG_APPTRACE_ENABLE disableAllWdts(); #if CONFIG_SYSVIEW_ENABLE - SEGGER_RTT_ESP32_FlushNoLock(CONFIG_ESP32_APPTRACE_POSTMORTEM_FLUSH_TRAX_THRESH, APPTRACE_ONPANIC_HOST_FLUSH_TMO); + SEGGER_RTT_ESP32_FlushNoLock(CONFIG_APPTRACE_POSTMORTEM_FLUSH_THRESH, APPTRACE_ONPANIC_HOST_FLUSH_TMO); #else - esp_apptrace_flush_nolock(ESP_APPTRACE_DEST_TRAX, CONFIG_ESP32_APPTRACE_POSTMORTEM_FLUSH_TRAX_THRESH, + esp_apptrace_flush_nolock(ESP_APPTRACE_DEST_TRAX, CONFIG_APPTRACE_POSTMORTEM_FLUSH_THRESH, APPTRACE_ONPANIC_HOST_FLUSH_TMO); #endif reconfigureAllWdts(); diff --git a/components/esp_common/Kconfig b/components/esp_common/Kconfig index 5028b598c..bbed1dca1 100644 --- a/components/esp_common/Kconfig +++ b/components/esp_common/Kconfig @@ -40,9 +40,9 @@ menu "Common ESP-related" config ESP_IPC_TASK_STACK_SIZE int "Inter-Processor Call (IPC) task stack size" - range 512 65536 if !ESP32_APPTRACE_ENABLE - range 2048 65536 if ESP32_APPTRACE_ENABLE - default 2048 if ESP32_APPTRACE_ENABLE + range 512 65536 if !APPTRACE_ENABLE + range 2048 65536 if APPTRACE_ENABLE + default 2048 if APPTRACE_ENABLE default 1024 help Configure the IPC tasks stack size. One IPC task runs on each core @@ -223,4 +223,12 @@ menu "Common ESP-related" complex issues with crashes while flash cache is disabled (for example, when writing to SPI flash.) + config ESP_DEBUG_STUBS_ENABLE + bool + default COMPILER_OPTIMIZATION_LEVEL_DEBUG + depends on !ESP32_TRAX && !ESP32S2_TRAX + help + Debug stubs are used by OpenOCD to execute pre-compiled onboard code + which does some useful debugging stuff, e.g. GCOV data dump. + endmenu # Common ESP-related diff --git a/components/esp_common/sdkconfig.rename b/components/esp_common/sdkconfig.rename index 9e65f1033..c920da0ef 100644 --- a/components/esp_common/sdkconfig.rename +++ b/components/esp_common/sdkconfig.rename @@ -26,3 +26,4 @@ CONFIG_TASK_WDT_PANIC CONFIG_ESP_TASK_WDT_PANI CONFIG_TASK_WDT_TIMEOUT_S CONFIG_ESP_TASK_WDT_TIMEOUT_S CONFIG_TASK_WDT_CHECK_IDLE_TASK_CPU0 CONFIG_ESP_TASK_WDT_CHECK_IDLE_TASK_CPU0 CONFIG_TASK_WDT_CHECK_IDLE_TASK_CPU1 CONFIG_ESP_TASK_WDT_CHECK_IDLE_TASK_CPU1 +CONFIG_ESP32_DEBUG_STUBS_ENABLE CONFIG_ESP_DEBUG_STUBS_ENABLE diff --git a/components/esp_common/src/dbg_stubs.c b/components/esp_common/src/dbg_stubs.c index b57ef4392..1ee912489 100644 --- a/components/esp_common/src/dbg_stubs.c +++ b/components/esp_common/src/dbg_stubs.c @@ -21,7 +21,7 @@ #include "esp_private/dbg_stubs.h" #include "esp_attr.h" -#if CONFIG_ESP32_DEBUG_STUBS_ENABLE || CONFIG_ESP32S2_DEBUG_STUBS_ENABLE +#if CONFIG_ESP_DEBUG_STUBS_ENABLE /* Debug stubs is actually a table of 4-byte entries. Every entry is equal to zero or must contain meaningfull data. The first entry is a service one and has the followinf format: diff --git a/components/freertos/include/freertos/FreeRTOSConfig.h b/components/freertos/include/freertos/FreeRTOSConfig.h index 884dde32f..139d14a40 100644 --- a/components/freertos/include/freertos/FreeRTOSConfig.h +++ b/components/freertos/include/freertos/FreeRTOSConfig.h @@ -178,7 +178,7 @@ int xt_clock_freq(void) __attribute__((deprecated)); #define configMAX_PRIORITIES ( 25 ) #endif -#ifndef CONFIG_ESP32_APPTRACE_ENABLE +#ifndef CONFIG_APPTRACE_ENABLE #define configMINIMAL_STACK_SIZE 768 #else /* apptrace module requires at least 2KB of stack per task */ diff --git a/docs/en/api-guides/app_trace.rst b/docs/en/api-guides/app_trace.rst index be431a042..71ecdf501 100644 --- a/docs/en/api-guides/app_trace.rst +++ b/docs/en/api-guides/app_trace.rst @@ -31,7 +31,7 @@ The library supports two modes of operation: **Post-mortem mode**. This is the default mode. The mode does not need interaction with the host side. In this mode tracing module does not check whether host has read all the data from *HW UP BUFFER* buffer and overwrites old data with the new ones. This mode is useful when only the latest trace data are interesting to the user, e.g. for analyzing program's behavior just before the crash. Host can read the data later on upon user request, e.g. via special OpenOCD command in case of working via JTAG interface. -**Streaming mode.** Tracing module enters this mode when host connects to ESP32. In this mode before writing new data to *HW UP BUFFER* tracing module checks that there is enough space in it and if necessary waits for the host to read data and free enough memory. Maximum waiting time is controlled via timeout values passed by users to corresponding API routines. So when application tries to write data to trace buffer using finite value of the maximum waiting time it is possible situation that this data will be dropped. Especially this is true for tracing from time critical code (ISRs, OS scheduler code etc.) when infinite timeouts can lead to system malfunction. In order to avoid loss of such critical data developers can enable additional data buffering via menuconfig option :ref:`CONFIG_ESP32_APPTRACE_PENDING_DATA_SIZE_MAX`. This macro specifies the size of data which can be buffered in above conditions. The option can also help to overcome situation when data transfer to the host is temporarily slowed down, e.g due to USB bus congestions etc. But it will not help when average bitrate of trace data stream exceeds HW interface capabilities. +**Streaming mode.** Tracing module enters this mode when host connects to ESP32. In this mode before writing new data to *HW UP BUFFER* tracing module checks that there is enough space in it and if necessary waits for the host to read data and free enough memory. Maximum waiting time is controlled via timeout values passed by users to corresponding API routines. So when application tries to write data to trace buffer using finite value of the maximum waiting time it is possible situation that this data will be dropped. Especially this is true for tracing from time critical code (ISRs, OS scheduler code etc.) when infinite timeouts can lead to system malfunction. In order to avoid loss of such critical data developers can enable additional data buffering via menuconfig option :ref:`CONFIG_APPTRACE_PENDING_DATA_SIZE_MAX`. This macro specifies the size of data which can be buffered in above conditions. The option can also help to overcome situation when data transfer to the host is temporarily slowed down, e.g due to USB bus congestions etc. But it will not help when average bitrate of trace data stream exceeds HW interface capabilities. Configuration Options and Dependencies @@ -40,7 +40,7 @@ Configuration Options and Dependencies Using of this feature depends on two components: 1. **Host side:** Application tracing is done over JTAG, so it needs OpenOCD to be set up and running on host machine. For instructions on how to set it up, please see :doc:`JTAG Debugging <../api-guides/jtag-debugging/index>` for details. -2. **Target side:** Application tracing functionality can be enabled in menuconfig. *Component config > Application Level Tracing* menu allows selecting destination for the trace data (HW interface for transport). Choosing any of the destinations automatically enables ``CONFIG_ESP32_APPTRACE_ENABLE`` option. +2. **Target side:** Application tracing functionality can be enabled in menuconfig. *Component config > Application Level Tracing* menu allows selecting destination for the trace data (HW interface for transport). Choosing any of the destinations automatically enables ``CONFIG_APPTRACE_ENABLE`` option. .. note:: @@ -48,8 +48,8 @@ Using of this feature depends on two components: There are two additional menuconfig options not mentioned above: -1. *Threshold for flushing last trace data to host on panic* (:ref:`CONFIG_ESP32_APPTRACE_POSTMORTEM_FLUSH_THRESH`). This option is necessary due to the nature of working over JTAG. In that mode trace data are exposed to the host in 16 KB blocks. In post-mortem mode when one block is filled it is exposed to the host and the previous one becomes unavailable. In other words trace data are overwritten in 16 KB granularity. On panic the latest data from the current input block are exposed to host and host can read them for post-analysis. System panic may occur when very small amount of data are not exposed to the host yet. In this case the previous 16 KB of collected data will be lost and host will see the latest, but very small piece of the trace. It can be insufficient to diagnose the problem. This menuconfig option allows avoiding such situations. It controls the threshold for flushing data in case of panic. For example user can decide that it needs not less then 512 bytes of the recent trace data, so if there is less then 512 bytes of pending data at the moment of panic they will not be flushed and will not overwrite previous 16 KB. The option is only meaningful in post-mortem mode and when working over JTAG. -2. *Timeout for flushing last trace data to host on panic* (:ref:`CONFIG_ESP32_APPTRACE_ONPANIC_HOST_FLUSH_TMO`). The option is only meaningful in streaming mode and controls the maximum time tracing module will wait for the host to read the last data in case of panic. +1. *Threshold for flushing last trace data to host on panic* (:ref:`CONFIG_APPTRACE_POSTMORTEM_FLUSH_THRESH`). This option is necessary due to the nature of working over JTAG. In that mode trace data are exposed to the host in 16 KB blocks. In post-mortem mode when one block is filled it is exposed to the host and the previous one becomes unavailable. In other words trace data are overwritten in 16 KB granularity. On panic the latest data from the current input block are exposed to host and host can read them for post-analysis. System panic may occur when very small amount of data are not exposed to the host yet. In this case the previous 16 KB of collected data will be lost and host will see the latest, but very small piece of the trace. It can be insufficient to diagnose the problem. This menuconfig option allows avoiding such situations. It controls the threshold for flushing data in case of panic. For example user can decide that it needs not less then 512 bytes of the recent trace data, so if there is less then 512 bytes of pending data at the moment of panic they will not be flushed and will not overwrite previous 16 KB. The option is only meaningful in post-mortem mode and when working over JTAG. +2. *Timeout for flushing last trace data to host on panic* (:ref:`CONFIG_APPTRACE_ONPANIC_HOST_FLUSH_TMO`). The option is only meaningful in streaming mode and controls the maximum time tracing module will wait for the host to read the last data in case of panic. How to use this library @@ -487,8 +487,8 @@ Project Configuration Before building a project with source code coverage, ensure that the following project configuration options are enabled by running ``idf.py menuconfig`` (or ``make menuconfig`` if using the legacy Make build system). -- Enable the application tracing module by choosing *Trace Memory* for the :ref:`CONFIG_ESP32_APPTRACE_DESTINATION` option. -- Enable Gcov to host via the :ref:`CONFIG_ESP32_GCOV_ENABLE` +- Enable the application tracing module by choosing *Trace Memory* for the :ref:`CONFIG_APPTRACE_DESTINATION` option. +- Enable Gcov to host via the :ref:`CONFIG_APPTRACE_GCOV_ENABLE` .. _app_trace-gcov-dumping-data: diff --git a/docs/en/api-reference/system/heap_debug.rst b/docs/en/api-reference/system/heap_debug.rst index 0c49409bb..02aaf3db2 100644 --- a/docs/en/api-reference/system/heap_debug.rst +++ b/docs/en/api-reference/system/heap_debug.rst @@ -218,7 +218,7 @@ Host-Based Mode Once you've identified the code which you think is leaking: - In the project configuration menu, navigate to ``Component settings`` -> ``Heap Memory Debugging`` -> :ref:`CONFIG_HEAP_TRACING_DEST` and select ``Host-Based``. -- In the project configuration menu, navigate to ``Component settings`` -> ``Application Level Tracing`` -> :ref:`CONFIG_ESP32_APPTRACE_DESTINATION` and select ``Trace memory``. +- In the project configuration menu, navigate to ``Component settings`` -> ``Application Level Tracing`` -> :ref:`CONFIG_APPTRACE_DESTINATION` and select ``Trace memory``. - In the project configuration menu, navigate to ``Component settings`` -> ``Application Level Tracing`` -> ``FreeRTOS SystemView Tracing`` and enable :ref:`CONFIG_SYSVIEW_ENABLE`. - Call the function :cpp:func:`heap_trace_init_tohost` early in the program, to initialize JTAG heap tracing module. - Call the function :cpp:func:`heap_trace_start` to begin recording all mallocs/frees in the system. Call this immediately before the piece of code which you suspect is leaking memory. diff --git a/docs/zh_CN/api-guides/app_trace.rst b/docs/zh_CN/api-guides/app_trace.rst index da295ade4..b47d7db99 100644 --- a/docs/zh_CN/api-guides/app_trace.rst +++ b/docs/zh_CN/api-guides/app_trace.rst @@ -30,7 +30,7 @@ **后验模式：** 这是默认的模式，该模式不需要和主机进行交互。在这种模式下，跟踪模块不会检查主机是否已经从 *HW UP BUFFER* 缓冲区读走所有数据，而是直接使用新数据覆盖旧数据。该模式在用户仅对最新的跟踪数据感兴趣时会很有用，例如分析程序在崩溃之前的行为。主机可以稍后根据用户的请求来读取数据，例如通过特殊的 OpenOCD 命令（假如使用了 JTAG 接口）。 -**流模式：** 当主机连接到 ESP32 时，跟踪模块会进入此模式。在这种模式下，跟踪模块在新数据写入 *HW UP BUFFER* 之前会检查其中是否有足够的空间，并在必要的时候等待主机读取数据并释放足够的内存。用户会将最长的等待时间作为超时时间参数传递给相应的 API 函数，如果超时时间是个有限值，那么应用程序有可能会因为超时而将待写的数据丢弃。尤其需要注意，如果在讲究时效的代码中（如中断处理函数，操作系统调度等）指定了无限的超时时间，那么系统会产生故障。为了避免丢失此类关键数据，开发人员可以通过在 menuconfig 中开启 :ref:`CONFIG_ESP32_APPTRACE_PENDING_DATA_SIZE_MAX` 选项来启用额外的数据缓冲区。此宏还指定了在上述条件下可以缓冲的数据大小，它有助于缓解由于 USB 总线拥塞等原因导致的向主机传输数据间歇性减缓的状况。但是，当跟踪数据流的平均比特率超过硬件接口的能力时，它也无能为力。 +**流模式：** 当主机连接到 ESP32 时，跟踪模块会进入此模式。在这种模式下，跟踪模块在新数据写入 *HW UP BUFFER* 之前会检查其中是否有足够的空间，并在必要的时候等待主机读取数据并释放足够的内存。用户会将最长的等待时间作为超时时间参数传递给相应的 API 函数，如果超时时间是个有限值，那么应用程序有可能会因为超时而将待写的数据丢弃。尤其需要注意，如果在讲究时效的代码中（如中断处理函数，操作系统调度等）指定了无限的超时时间，那么系统会产生故障。为了避免丢失此类关键数据，开发人员可以通过在 menuconfig 中开启 :ref:`CONFIG_APPTRACE_PENDING_DATA_SIZE_MAX` 选项来启用额外的数据缓冲区。此宏还指定了在上述条件下可以缓冲的数据大小，它有助于缓解由于 USB 总线拥塞等原因导致的向主机传输数据间歇性减缓的状况。但是，当跟踪数据流的平均比特率超过硬件接口的能力时，它也无能为力。 配置选项与依赖项 @@ -40,7 +40,7 @@ 1. **主机端：** 应用程序跟踪是通过 JTAG 来完成的，因此需要在主机上安装并运行 OpenOCD。相关详细信息请参阅 :doc:`JTAG Debugging <../api-guides/jtag-debugging/index>`。 -2. **目标端：** 在 menuconfig 中开启应用程序跟踪功能。 *Component config > Application Level Tracing* 菜单允许选择跟踪数据的传输目标（具体用于传输的硬件接口），选择任一非 None 的目标都会自动开启 ``CONFIG_ESP32_APPTRACE_ENABLE`` 这个选项。 +2. **目标端：** 在 menuconfig 中开启应用程序跟踪功能。 *Component config > Application Level Tracing* 菜单允许选择跟踪数据的传输目标（具体用于传输的硬件接口），选择任一非 None 的目标都会自动开启 ``CONFIG_APPTRACE_ENABLE`` 这个选项。 .. note:: @@ -48,9 +48,9 @@ 以下为前述未提及的另外两个 menuconfig 选项： -1. *Threshold for flushing last trace data to host on panic* （:ref:`CONFIG_ESP32_APPTRACE_POSTMORTEM_FLUSH_THRESH`）。由于在 JTAG 上工作的性质，此选项是必选项。在该模式下，跟踪数据以 16 KB 数据块的形式曝露给主机。在后验模式中，当一个块被填充时，它会曝露给主机，而之前的块会变得不可用。换句话说，跟踪数据以 16 KB 的粒度进行覆盖。在发生 panic 的时候，当前输入块的最新数据将会被曝露给主机，主机可以读取它们以进行后续分析。如果系统发生 panic 的时候仍有少量数据还没来得及曝光给主机，那么之前收集的 16 KB 的数据将丢失，主机只能看到非常少的最新的跟踪部分，它可能不足以用来诊断问题所在。此 menuconfig 选项允许避免此类情况，它可以控制在发生 panic 时刷新数据的阈值，例如用户可以确定它需要不少于 512 字节的最新跟踪数据，所以如果在发生 panic 时待处理的数据少于 512 字节，它们不会被刷新，也不会覆盖之前的 16 KB。该选项仅在后验模式和 JTAG 工作时有意义。 +1. *Threshold for flushing last trace data to host on panic* （:ref:`CONFIG_APPTRACE_POSTMORTEM_FLUSH_THRESH`）。由于在 JTAG 上工作的性质，此选项是必选项。在该模式下，跟踪数据以 16 KB 数据块的形式曝露给主机。在后验模式中，当一个块被填充时，它会曝露给主机，而之前的块会变得不可用。换句话说，跟踪数据以 16 KB 的粒度进行覆盖。在发生 panic 的时候，当前输入块的最新数据将会被曝露给主机，主机可以读取它们以进行后续分析。如果系统发生 panic 的时候仍有少量数据还没来得及曝光给主机，那么之前收集的 16 KB 的数据将丢失，主机只能看到非常少的最新的跟踪部分，它可能不足以用来诊断问题所在。此 menuconfig 选项允许避免此类情况，它可以控制在发生 panic 时刷新数据的阈值，例如用户可以确定它需要不少于 512 字节的最新跟踪数据，所以如果在发生 panic 时待处理的数据少于 512 字节，它们不会被刷新，也不会覆盖之前的 16 KB。该选项仅在后验模式和 JTAG 工作时有意义。 -2. *Timeout for flushing last trace data to host on panic* （:ref:`CONFIG_ESP32_APPTRACE_ONPANIC_HOST_FLUSH_TMO`）。该选项仅在流模式下才起作用，它控制跟踪模块在发生 panic 时等待主机读取最新数据的最长时间。 +2. *Timeout for flushing last trace data to host on panic* （:ref:`CONFIG_APPTRACE_ONPANIC_HOST_FLUSH_TMO`）。该选项仅在流模式下才起作用，它控制跟踪模块在发生 panic 时等待主机读取最新数据的最长时间。 如何使用这个库 diff --git a/examples/system/app_trace_to_host/sdkconfig.defaults b/examples/system/app_trace_to_host/sdkconfig.defaults index e20d2b786..515d62f4e 100644 --- a/examples/system/app_trace_to_host/sdkconfig.defaults +++ b/examples/system/app_trace_to_host/sdkconfig.defaults @@ -1,5 +1,5 @@ # Enable application tracing by default -CONFIG_ESP32_APPTRACE_DEST_TRAX=y -CONFIG_ESP32_APPTRACE_ENABLE=y +CONFIG_APPTRACE_DEST_TRAX=y +CONFIG_APPTRACE_ENABLE=y # Disable WiFi stack by default CONFIG_WIFI_ENABLED=n \ No newline at end of file diff --git a/examples/system/gcov/sdkconfig.defaults b/examples/system/gcov/sdkconfig.defaults index 332bb1281..5a21ba3a9 100644 --- a/examples/system/gcov/sdkconfig.defaults +++ b/examples/system/gcov/sdkconfig.defaults @@ -1,7 +1,8 @@ -CONFIG_ESP32_APPTRACE_DEST_TRAX=y -# CONFIG_ESP32_APPTRACE_DEST_NONE is not set -CONFIG_ESP32_APPTRACE_ENABLE=y -CONFIG_ESP32_APPTRACE_LOCK_ENABLE=y -CONFIG_ESP32_APPTRACE_ONPANIC_HOST_FLUSH_TMO=-1 -CONFIG_ESP32_APPTRACE_POSTMORTEM_FLUSH_THRESH=0 -CONFIG_ESP32_APPTRACE_PENDING_DATA_SIZE_MAX=0 +CONFIG_APPTRACE_DEST_TRAX=y +# CONFIG_APPTRACE_DEST_NONE is not set +CONFIG_APPTRACE_ENABLE=y +CONFIG_APPTRACE_LOCK_ENABLE=y +CONFIG_APPTRACE_ONPANIC_HOST_FLUSH_TMO=-1 +CONFIG_APPTRACE_POSTMORTEM_FLUSH_THRESH=0 +CONFIG_APPTRACE_PENDING_DATA_SIZE_MAX=0 +CONFIG_APPTRACE_GCOV_ENABLE=y diff --git a/examples/system/sysview_tracing/sdkconfig.defaults b/examples/system/sysview_tracing/sdkconfig.defaults index 21dd3c78f..f0cb3a80b 100644 --- a/examples/system/sysview_tracing/sdkconfig.defaults +++ b/examples/system/sysview_tracing/sdkconfig.defaults @@ -4,8 +4,8 @@ CONFIG_FREERTOS_UNICORE=y # 1ms tick period CONFIG_FREERTOS_HZ=1000 # Enable application tracing by default -CONFIG_ESP32_APPTRACE_DEST_TRAX=y -CONFIG_ESP32_APPTRACE_ENABLE=y +CONFIG_APPTRACE_DEST_TRAX=y +CONFIG_APPTRACE_ENABLE=y # Enable FreeRTOS SystemView Tracing by default CONFIG_SYSVIEW_ENABLE=y CONFIG_SYSVIEW_TS_SOURCE_TIMER_00=y diff --git a/examples/system/sysview_tracing_heap_log/sdkconfig.defaults b/examples/system/sysview_tracing_heap_log/sdkconfig.defaults index 26ca10d1d..4bdfb587c 100644 --- a/examples/system/sysview_tracing_heap_log/sdkconfig.defaults +++ b/examples/system/sysview_tracing_heap_log/sdkconfig.defaults @@ -4,8 +4,8 @@ CONFIG_FREERTOS_UNICORE=y # 1ms tick period CONFIG_FREERTOS_HZ=1000 # Enable application tracing by default -CONFIG_ESP32_APPTRACE_DEST_TRAX=y -CONFIG_ESP32_APPTRACE_ENABLE=y +CONFIG_APPTRACE_DEST_TRAX=y +CONFIG_APPTRACE_ENABLE=y # Enable FreeRTOS SystemView Tracing by default CONFIG_SYSVIEW_ENABLE=y CONFIG_SYSVIEW_TS_SOURCE_TIMER_00=y diff --git a/examples/wifi/simple_sniffer/sdkconfig.defaults b/examples/wifi/simple_sniffer/sdkconfig.defaults index 233796281..a3b47e90e 100644 --- a/examples/wifi/simple_sniffer/sdkconfig.defaults +++ b/examples/wifi/simple_sniffer/sdkconfig.defaults @@ -21,6 +21,6 @@ CONFIG_FATFS_LFN_HEAP=y CONFIG_FATFS_MAX_LFN=31 # App trace -CONFIG_ESP32_APPTRACE_DEST_TRAX=y -CONFIG_ESP32_APPTRACE_ENABLE=y +CONFIG_APPTRACE_DEST_TRAX=y +CONFIG_APPTRACE_ENABLE=y