1 /*
2 * SPDX-FileCopyrightText: 2017-2021 Espressif Systems (Shanghai) CO LTD
3 *
4 * SPDX-License-Identifier: Apache-2.0
5 */
6 //
7 #include "freertos/FreeRTOS.h"
8 #include "freertos/task.h"
9 #include "esp_app_trace_util.h"
10 #include "sdkconfig.h"
11
12 ///////////////////////////////////////////////////////////////////////////////
13 ///////////////////////////////// Locks /////////////////////////////////////
14 ///////////////////////////////////////////////////////////////////////////////
15
16 #if ESP_APPTRACE_PRINT_LOCK
17 static esp_apptrace_lock_t s_log_lock = {.irq_stat = 0, .portmux = portMUX_INITIALIZER_UNLOCKED};
18 #endif
19
esp_apptrace_log_lock(void)20 int esp_apptrace_log_lock(void)
21 {
22 #if ESP_APPTRACE_PRINT_LOCK
23 esp_apptrace_tmo_t tmo;
24 esp_apptrace_tmo_init(&tmo, ESP_APPTRACE_TMO_INFINITE);
25 int ret = esp_apptrace_lock_take(&s_log_lock, &tmo);
26 return ret;
27 #else
28 return 0;
29 #endif
30 }
31
esp_apptrace_log_unlock(void)32 void esp_apptrace_log_unlock(void)
33 {
34 #if ESP_APPTRACE_PRINT_LOCK
35 esp_apptrace_lock_give(&s_log_lock);
36 #endif
37 }
38
39 ///////////////////////////////////////////////////////////////////////////////
40 ///////////////////////////////// TIMEOUT /////////////////////////////////////
41 ///////////////////////////////////////////////////////////////////////////////
42
esp_apptrace_tmo_check(esp_apptrace_tmo_t * tmo)43 esp_err_t esp_apptrace_tmo_check(esp_apptrace_tmo_t *tmo)
44 {
45 if (tmo->tmo != (int64_t)-1) {
46 tmo->elapsed = esp_timer_get_time() - tmo->start;
47 if (tmo->elapsed >= tmo->tmo) {
48 return ESP_ERR_TIMEOUT;
49 }
50 }
51 return ESP_OK;
52 }
53
54 ///////////////////////////////////////////////////////////////////////////////
55 ///////////////////////////////// LOCK ////////////////////////////////////////
56 ///////////////////////////////////////////////////////////////////////////////
57
esp_apptrace_lock_take(esp_apptrace_lock_t * lock,esp_apptrace_tmo_t * tmo)58 esp_err_t esp_apptrace_lock_take(esp_apptrace_lock_t *lock, esp_apptrace_tmo_t *tmo)
59 {
60 int res;
61
62 while (1) {
63 //Todo: Replace the current locking mechanism and int_state with portTRY_ENTER_CRITICAL() instead.
64 // do not overwrite lock->int_state before we actually acquired the mux
65 unsigned int_state = portSET_INTERRUPT_MASK_FROM_ISR();
66 bool success = vPortCPUAcquireMutexTimeout(&lock->mux, 0);
67 if (success) {
68 lock->int_state = int_state;
69 return ESP_OK;
70 }
71 portCLEAR_INTERRUPT_MASK_FROM_ISR(int_state);
72 // we can be preempted from this place till the next call (above) to portSET_INTERRUPT_MASK_FROM_ISR()
73 res = esp_apptrace_tmo_check(tmo);
74 if (res != ESP_OK) {
75 break;
76 }
77 }
78 return res;
79 }
80
esp_apptrace_lock_give(esp_apptrace_lock_t * lock)81 esp_err_t esp_apptrace_lock_give(esp_apptrace_lock_t *lock)
82 {
83 // save lock's irq state value for this CPU
84 unsigned int_state = lock->int_state;
85 // after call to the following func we can not be sure that lock->int_state
86 // is not overwritten by other CPU who has acquired the mux just after we released it. See esp_apptrace_lock_take().
87 vPortCPUReleaseMutex(&lock->mux);
88 portCLEAR_INTERRUPT_MASK_FROM_ISR(int_state);
89 return ESP_OK;
90 }
91
92 ///////////////////////////////////////////////////////////////////////////////
93 ////////////////////////////// RING BUFFER ////////////////////////////////////
94 ///////////////////////////////////////////////////////////////////////////////
95
esp_apptrace_rb_produce(esp_apptrace_rb_t * rb,uint32_t size)96 uint8_t *esp_apptrace_rb_produce(esp_apptrace_rb_t *rb, uint32_t size)
97 {
98 uint8_t *ptr = rb->data + rb->wr;
99 // check for avalable space
100 if (rb->rd <= rb->wr) {
101 // |?R......W??|
102 if (rb->wr + size >= rb->size) {
103 if (rb->rd == 0) {
104 return NULL; // cannot wrap wr
105 }
106 if (rb->wr + size == rb->size) {
107 rb->wr = 0;
108 } else {
109 // check if we can wrap wr earlier to get space for requested size
110 if (size > rb->rd - 1) {
111 return NULL; // cannot wrap wr
112 }
113 // shrink buffer a bit, full size will be restored at rd wrapping
114 rb->cur_size = rb->wr;
115 rb->wr = 0;
116 ptr = rb->data;
117 if (rb->rd == rb->cur_size) {
118 rb->rd = 0;
119 if (rb->cur_size < rb->size) {
120 rb->cur_size = rb->size;
121 }
122 }
123 rb->wr += size;
124 }
125 } else {
126 rb->wr += size;
127 }
128 } else {
129 // |?W......R??|
130 if (size > rb->rd - rb->wr - 1) {
131 return NULL;
132 }
133 rb->wr += size;
134 }
135 return ptr;
136 }
137
esp_apptrace_rb_consume(esp_apptrace_rb_t * rb,uint32_t size)138 uint8_t *esp_apptrace_rb_consume(esp_apptrace_rb_t *rb, uint32_t size)
139 {
140 uint8_t *ptr = rb->data + rb->rd;
141 if (rb->rd <= rb->wr) {
142 // |?R......W??|
143 if (rb->rd + size > rb->wr) {
144 return NULL;
145 }
146 rb->rd += size;
147 } else {
148 // |?W......R??|
149 if (rb->rd + size > rb->cur_size) {
150 return NULL;
151 } else if (rb->rd + size == rb->cur_size) {
152 // restore full size usage
153 if (rb->cur_size < rb->size) {
154 rb->cur_size = rb->size;
155 }
156 rb->rd = 0;
157 } else {
158 rb->rd += size;
159 }
160 }
161 return ptr;
162 }
163
esp_apptrace_rb_read_size_get(esp_apptrace_rb_t * rb)164 uint32_t esp_apptrace_rb_read_size_get(esp_apptrace_rb_t *rb)
165 {
166 uint32_t size = 0;
167 if (rb->rd <= rb->wr) {
168 // |?R......W??|
169 size = rb->wr - rb->rd;
170 } else {
171 // |?W......R??|
172 size = rb->cur_size - rb->rd;
173 }
174 return size;
175 }
176
esp_apptrace_rb_write_size_get(esp_apptrace_rb_t * rb)177 uint32_t esp_apptrace_rb_write_size_get(esp_apptrace_rb_t *rb)
178 {
179 uint32_t size = 0;
180 if (rb->rd <= rb->wr) {
181 // |?R......W??|
182 size = rb->size - rb->wr;
183 if (size && rb->rd == 0) {
184 size--;
185 }
186 } else {
187 // |?W......R??|
188 size = rb->rd - rb->wr - 1;
189 }
190 return size;
191 }
192
