Rahul Dahiya / Mbed OS STM32F7 Ethernet

Important changes to repositories hosted on mbed.com

Mbed hosted mercurial repositories are deprecated and are due to be permanently deleted in July 2026.

To keep a copy of this software download the repository Zip archive or clone locally using Mercurial.

It is also possible to export all your personal repositories from the account settings page.

mbed-os/rtos/Thread.cpp@0:fb8047b156bb, 2020-01-15 (annotated)

Committer:
rahul_dahiya
Date:
Wed Jan 15 15:57:15 2020 +0530
Revision:
0:fb8047b156bb
STM32F7 LWIP

Who changed what in which revision?

UserRevisionLine numberNew contents of line
rahul_dahiya 0:fb8047b156bb 1 /* mbed Microcontroller Library
rahul_dahiya 0:fb8047b156bb 2 * Copyright (c) 2006-2012 ARM Limited
rahul_dahiya 0:fb8047b156bb 3 *
rahul_dahiya 0:fb8047b156bb 4 * Permission is hereby granted, free of charge, to any person obtaining a copy
rahul_dahiya 0:fb8047b156bb 5 * of this software and associated documentation files (the "Software"), to deal
rahul_dahiya 0:fb8047b156bb 6 * in the Software without restriction, including without limitation the rights
rahul_dahiya 0:fb8047b156bb 7 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
rahul_dahiya 0:fb8047b156bb 8 * copies of the Software, and to permit persons to whom the Software is
rahul_dahiya 0:fb8047b156bb 9 * furnished to do so, subject to the following conditions:
rahul_dahiya 0:fb8047b156bb 10 *
rahul_dahiya 0:fb8047b156bb 11 * The above copyright notice and this permission notice shall be included in
rahul_dahiya 0:fb8047b156bb 12 * all copies or substantial portions of the Software.
rahul_dahiya 0:fb8047b156bb 13 *
rahul_dahiya 0:fb8047b156bb 14 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
rahul_dahiya 0:fb8047b156bb 15 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
rahul_dahiya 0:fb8047b156bb 16 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
rahul_dahiya 0:fb8047b156bb 17 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
rahul_dahiya 0:fb8047b156bb 18 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
rahul_dahiya 0:fb8047b156bb 19 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
rahul_dahiya 0:fb8047b156bb 20 * SOFTWARE.
rahul_dahiya 0:fb8047b156bb 21 */
rahul_dahiya 0:fb8047b156bb 22 #include "rtos/Thread.h"
rahul_dahiya 0:fb8047b156bb 23
rahul_dahiya 0:fb8047b156bb 24 #include "mbed.h"
rahul_dahiya 0:fb8047b156bb 25 #include "rtos/rtos_idle.h"
rahul_dahiya 0:fb8047b156bb 26 #include "mbed_assert.h"
rahul_dahiya 0:fb8047b156bb 27
rahul_dahiya 0:fb8047b156bb 28 #define ALIGN_UP(pos, align) ((pos) % (align) ? (pos) + ((align) - (pos) % (align)) : (pos))
rahul_dahiya 0:fb8047b156bb 29 MBED_STATIC_ASSERT(ALIGN_UP(0, 8) == 0, "ALIGN_UP macro error");
rahul_dahiya 0:fb8047b156bb 30 MBED_STATIC_ASSERT(ALIGN_UP(1, 8) == 8, "ALIGN_UP macro error");
rahul_dahiya 0:fb8047b156bb 31
rahul_dahiya 0:fb8047b156bb 32 #define ALIGN_DOWN(pos, align) ((pos) - ((pos) % (align)))
rahul_dahiya 0:fb8047b156bb 33 MBED_STATIC_ASSERT(ALIGN_DOWN(7, 8) == 0, "ALIGN_DOWN macro error");
rahul_dahiya 0:fb8047b156bb 34 MBED_STATIC_ASSERT(ALIGN_DOWN(8, 8) == 8, "ALIGN_DOWN macro error");
rahul_dahiya 0:fb8047b156bb 35
rahul_dahiya 0:fb8047b156bb 36 static void (*terminate_hook)(osThreadId_t id) = 0;
rahul_dahiya 0:fb8047b156bb 37 extern "C" void thread_terminate_hook(osThreadId_t id)
rahul_dahiya 0:fb8047b156bb 38 {
rahul_dahiya 0:fb8047b156bb 39 if (terminate_hook != (void (*)(osThreadId_t))NULL) {
rahul_dahiya 0:fb8047b156bb 40 terminate_hook(id);
rahul_dahiya 0:fb8047b156bb 41 }
rahul_dahiya 0:fb8047b156bb 42 }
rahul_dahiya 0:fb8047b156bb 43
rahul_dahiya 0:fb8047b156bb 44 namespace rtos {
rahul_dahiya 0:fb8047b156bb 45
rahul_dahiya 0:fb8047b156bb 46 void Thread::constructor(osPriority priority,
rahul_dahiya 0:fb8047b156bb 47 uint32_t stack_size, unsigned char *stack_mem, const char *name) {
rahul_dahiya 0:fb8047b156bb 48
rahul_dahiya 0:fb8047b156bb 49 const uintptr_t unaligned_mem = reinterpret_cast<uintptr_t>(stack_mem);
rahul_dahiya 0:fb8047b156bb 50 const uintptr_t aligned_mem = ALIGN_UP(unaligned_mem, 8);
rahul_dahiya 0:fb8047b156bb 51 const uint32_t offset = aligned_mem - unaligned_mem;
rahul_dahiya 0:fb8047b156bb 52 const uint32_t aligned_size = ALIGN_DOWN(stack_size - offset, 8);
rahul_dahiya 0:fb8047b156bb 53
rahul_dahiya 0:fb8047b156bb 54 _tid = 0;
rahul_dahiya 0:fb8047b156bb 55 _dynamic_stack = (stack_mem == NULL);
rahul_dahiya 0:fb8047b156bb 56 _finished = false;
rahul_dahiya 0:fb8047b156bb 57 memset(&_obj_mem, 0, sizeof(_obj_mem));
rahul_dahiya 0:fb8047b156bb 58 memset(&_attr, 0, sizeof(_attr));
rahul_dahiya 0:fb8047b156bb 59 _attr.priority = priority;
rahul_dahiya 0:fb8047b156bb 60 _attr.stack_size = aligned_size;
rahul_dahiya 0:fb8047b156bb 61 _attr.name = name ? name : "application_unnamed_thread";
rahul_dahiya 0:fb8047b156bb 62 _attr.stack_mem = reinterpret_cast<uint32_t*>(aligned_mem);
rahul_dahiya 0:fb8047b156bb 63 }
rahul_dahiya 0:fb8047b156bb 64
rahul_dahiya 0:fb8047b156bb 65 void Thread::constructor(Callback<void()> task,
rahul_dahiya 0:fb8047b156bb 66 osPriority priority, uint32_t stack_size, unsigned char *stack_mem, const char *name) {
rahul_dahiya 0:fb8047b156bb 67 constructor(priority, stack_size, stack_mem, name);
rahul_dahiya 0:fb8047b156bb 68
rahul_dahiya 0:fb8047b156bb 69 switch (start(task)) {
rahul_dahiya 0:fb8047b156bb 70 case osErrorResource:
rahul_dahiya 0:fb8047b156bb 71 error("OS ran out of threads!\n");
rahul_dahiya 0:fb8047b156bb 72 break;
rahul_dahiya 0:fb8047b156bb 73 case osErrorParameter:
rahul_dahiya 0:fb8047b156bb 74 error("Thread already running!\n");
rahul_dahiya 0:fb8047b156bb 75 break;
rahul_dahiya 0:fb8047b156bb 76 case osErrorNoMemory:
rahul_dahiya 0:fb8047b156bb 77 error("Error allocating the stack memory\n");
rahul_dahiya 0:fb8047b156bb 78 default:
rahul_dahiya 0:fb8047b156bb 79 break;
rahul_dahiya 0:fb8047b156bb 80 }
rahul_dahiya 0:fb8047b156bb 81 }
rahul_dahiya 0:fb8047b156bb 82
rahul_dahiya 0:fb8047b156bb 83 osStatus Thread::start(Callback<void()> task) {
rahul_dahiya 0:fb8047b156bb 84 _mutex.lock();
rahul_dahiya 0:fb8047b156bb 85
rahul_dahiya 0:fb8047b156bb 86 if ((_tid != 0) || _finished) {
rahul_dahiya 0:fb8047b156bb 87 _mutex.unlock();
rahul_dahiya 0:fb8047b156bb 88 return osErrorParameter;
rahul_dahiya 0:fb8047b156bb 89 }
rahul_dahiya 0:fb8047b156bb 90
rahul_dahiya 0:fb8047b156bb 91 if (_attr.stack_mem == NULL) {
rahul_dahiya 0:fb8047b156bb 92 _attr.stack_mem = new uint32_t[_attr.stack_size/sizeof(uint32_t)];
rahul_dahiya 0:fb8047b156bb 93 MBED_ASSERT(_attr.stack_mem != NULL);
rahul_dahiya 0:fb8047b156bb 94 }
rahul_dahiya 0:fb8047b156bb 95
rahul_dahiya 0:fb8047b156bb 96 //Fill the stack with a magic word for maximum usage checking
rahul_dahiya 0:fb8047b156bb 97 for (uint32_t i = 0; i < (_attr.stack_size / sizeof(uint32_t)); i++) {
rahul_dahiya 0:fb8047b156bb 98 ((uint32_t *)_attr.stack_mem)[i] = 0xE25A2EA5;
rahul_dahiya 0:fb8047b156bb 99 }
rahul_dahiya 0:fb8047b156bb 100
rahul_dahiya 0:fb8047b156bb 101 memset(&_obj_mem, 0, sizeof(_obj_mem));
rahul_dahiya 0:fb8047b156bb 102 _attr.cb_size = sizeof(_obj_mem);
rahul_dahiya 0:fb8047b156bb 103 _attr.cb_mem = &_obj_mem;
rahul_dahiya 0:fb8047b156bb 104 _task = task;
rahul_dahiya 0:fb8047b156bb 105 _tid = osThreadNew(Thread::_thunk, this, &_attr);
rahul_dahiya 0:fb8047b156bb 106 if (_tid == NULL) {
rahul_dahiya 0:fb8047b156bb 107 if (_dynamic_stack) {
rahul_dahiya 0:fb8047b156bb 108 delete[] (uint32_t *)(_attr.stack_mem);
rahul_dahiya 0:fb8047b156bb 109 _attr.stack_mem = (uint32_t*)NULL;
rahul_dahiya 0:fb8047b156bb 110 }
rahul_dahiya 0:fb8047b156bb 111 _mutex.unlock();
rahul_dahiya 0:fb8047b156bb 112 _join_sem.release();
rahul_dahiya 0:fb8047b156bb 113 return osErrorResource;
rahul_dahiya 0:fb8047b156bb 114 }
rahul_dahiya 0:fb8047b156bb 115
rahul_dahiya 0:fb8047b156bb 116 _mutex.unlock();
rahul_dahiya 0:fb8047b156bb 117 return osOK;
rahul_dahiya 0:fb8047b156bb 118 }
rahul_dahiya 0:fb8047b156bb 119
rahul_dahiya 0:fb8047b156bb 120 osStatus Thread::terminate() {
rahul_dahiya 0:fb8047b156bb 121 osStatus_t ret = osOK;
rahul_dahiya 0:fb8047b156bb 122 _mutex.lock();
rahul_dahiya 0:fb8047b156bb 123
rahul_dahiya 0:fb8047b156bb 124 // Set the Thread's tid to NULL and
rahul_dahiya 0:fb8047b156bb 125 // release the semaphore before terminating
rahul_dahiya 0:fb8047b156bb 126 // since this thread could be terminating itself
rahul_dahiya 0:fb8047b156bb 127 osThreadId_t local_id = _tid;
rahul_dahiya 0:fb8047b156bb 128 _join_sem.release();
rahul_dahiya 0:fb8047b156bb 129 _tid = (osThreadId_t)NULL;
rahul_dahiya 0:fb8047b156bb 130 if (!_finished) {
rahul_dahiya 0:fb8047b156bb 131 _finished = true;
rahul_dahiya 0:fb8047b156bb 132 ret = osThreadTerminate(local_id);
rahul_dahiya 0:fb8047b156bb 133 }
rahul_dahiya 0:fb8047b156bb 134 _mutex.unlock();
rahul_dahiya 0:fb8047b156bb 135 return ret;
rahul_dahiya 0:fb8047b156bb 136 }
rahul_dahiya 0:fb8047b156bb 137
rahul_dahiya 0:fb8047b156bb 138 osStatus Thread::join() {
rahul_dahiya 0:fb8047b156bb 139 int32_t ret = _join_sem.wait();
rahul_dahiya 0:fb8047b156bb 140 if (ret < 0) {
rahul_dahiya 0:fb8047b156bb 141 return osError;
rahul_dahiya 0:fb8047b156bb 142 }
rahul_dahiya 0:fb8047b156bb 143
rahul_dahiya 0:fb8047b156bb 144 // The semaphore has been released so this thread is being
rahul_dahiya 0:fb8047b156bb 145 // terminated or has been terminated. Once the mutex has
rahul_dahiya 0:fb8047b156bb 146 // been locked it is ensured that the thread is deleted.
rahul_dahiya 0:fb8047b156bb 147 _mutex.lock();
rahul_dahiya 0:fb8047b156bb 148 MBED_ASSERT(NULL == _tid);
rahul_dahiya 0:fb8047b156bb 149 _mutex.unlock();
rahul_dahiya 0:fb8047b156bb 150
rahul_dahiya 0:fb8047b156bb 151 // Release sem so any other threads joining this thread wake up
rahul_dahiya 0:fb8047b156bb 152 _join_sem.release();
rahul_dahiya 0:fb8047b156bb 153 return osOK;
rahul_dahiya 0:fb8047b156bb 154 }
rahul_dahiya 0:fb8047b156bb 155
rahul_dahiya 0:fb8047b156bb 156 osStatus Thread::set_priority(osPriority priority) {
rahul_dahiya 0:fb8047b156bb 157 osStatus_t ret;
rahul_dahiya 0:fb8047b156bb 158 _mutex.lock();
rahul_dahiya 0:fb8047b156bb 159
rahul_dahiya 0:fb8047b156bb 160 ret = osThreadSetPriority(_tid, priority);
rahul_dahiya 0:fb8047b156bb 161
rahul_dahiya 0:fb8047b156bb 162 _mutex.unlock();
rahul_dahiya 0:fb8047b156bb 163 return ret;
rahul_dahiya 0:fb8047b156bb 164 }
rahul_dahiya 0:fb8047b156bb 165
rahul_dahiya 0:fb8047b156bb 166 osPriority Thread::get_priority() {
rahul_dahiya 0:fb8047b156bb 167 osPriority_t ret;
rahul_dahiya 0:fb8047b156bb 168 _mutex.lock();
rahul_dahiya 0:fb8047b156bb 169
rahul_dahiya 0:fb8047b156bb 170 ret = osThreadGetPriority(_tid);
rahul_dahiya 0:fb8047b156bb 171
rahul_dahiya 0:fb8047b156bb 172 _mutex.unlock();
rahul_dahiya 0:fb8047b156bb 173 return ret;
rahul_dahiya 0:fb8047b156bb 174 }
rahul_dahiya 0:fb8047b156bb 175
rahul_dahiya 0:fb8047b156bb 176 int32_t Thread::signal_set(int32_t flags) {
rahul_dahiya 0:fb8047b156bb 177 return osThreadFlagsSet(_tid, flags);
rahul_dahiya 0:fb8047b156bb 178 }
rahul_dahiya 0:fb8047b156bb 179
rahul_dahiya 0:fb8047b156bb 180 Thread::State Thread::get_state() {
rahul_dahiya 0:fb8047b156bb 181 uint8_t state = osThreadTerminated;
rahul_dahiya 0:fb8047b156bb 182
rahul_dahiya 0:fb8047b156bb 183 _mutex.lock();
rahul_dahiya 0:fb8047b156bb 184
rahul_dahiya 0:fb8047b156bb 185 if (_tid != NULL) {
rahul_dahiya 0:fb8047b156bb 186 #if defined(MBED_OS_BACKEND_RTX5)
rahul_dahiya 0:fb8047b156bb 187 state = _obj_mem.state;
rahul_dahiya 0:fb8047b156bb 188 #else
rahul_dahiya 0:fb8047b156bb 189 state = osThreadGetState(_tid);
rahul_dahiya 0:fb8047b156bb 190 #endif
rahul_dahiya 0:fb8047b156bb 191 }
rahul_dahiya 0:fb8047b156bb 192
rahul_dahiya 0:fb8047b156bb 193 _mutex.unlock();
rahul_dahiya 0:fb8047b156bb 194
rahul_dahiya 0:fb8047b156bb 195 State user_state;
rahul_dahiya 0:fb8047b156bb 196
rahul_dahiya 0:fb8047b156bb 197 switch(state) {
rahul_dahiya 0:fb8047b156bb 198 case osThreadInactive:
rahul_dahiya 0:fb8047b156bb 199 user_state = Inactive;
rahul_dahiya 0:fb8047b156bb 200 break;
rahul_dahiya 0:fb8047b156bb 201 case osThreadReady:
rahul_dahiya 0:fb8047b156bb 202 user_state = Ready;
rahul_dahiya 0:fb8047b156bb 203 break;
rahul_dahiya 0:fb8047b156bb 204 case osThreadRunning:
rahul_dahiya 0:fb8047b156bb 205 user_state = Running;
rahul_dahiya 0:fb8047b156bb 206 break;
rahul_dahiya 0:fb8047b156bb 207 #if defined(MBED_OS_BACKEND_RTX5)
rahul_dahiya 0:fb8047b156bb 208 case osRtxThreadWaitingDelay:
rahul_dahiya 0:fb8047b156bb 209 user_state = WaitingDelay;
rahul_dahiya 0:fb8047b156bb 210 break;
rahul_dahiya 0:fb8047b156bb 211 case osRtxThreadWaitingJoin:
rahul_dahiya 0:fb8047b156bb 212 user_state = WaitingJoin;
rahul_dahiya 0:fb8047b156bb 213 break;
rahul_dahiya 0:fb8047b156bb 214 case osRtxThreadWaitingThreadFlags:
rahul_dahiya 0:fb8047b156bb 215 user_state = WaitingThreadFlag;
rahul_dahiya 0:fb8047b156bb 216 break;
rahul_dahiya 0:fb8047b156bb 217 case osRtxThreadWaitingEventFlags:
rahul_dahiya 0:fb8047b156bb 218 user_state = WaitingEventFlag;
rahul_dahiya 0:fb8047b156bb 219 break;
rahul_dahiya 0:fb8047b156bb 220 case osRtxThreadWaitingMutex:
rahul_dahiya 0:fb8047b156bb 221 user_state = WaitingMutex;
rahul_dahiya 0:fb8047b156bb 222 break;
rahul_dahiya 0:fb8047b156bb 223 case osRtxThreadWaitingSemaphore:
rahul_dahiya 0:fb8047b156bb 224 user_state = WaitingSemaphore;
rahul_dahiya 0:fb8047b156bb 225 break;
rahul_dahiya 0:fb8047b156bb 226 case osRtxThreadWaitingMemoryPool:
rahul_dahiya 0:fb8047b156bb 227 user_state = WaitingMemoryPool;
rahul_dahiya 0:fb8047b156bb 228 break;
rahul_dahiya 0:fb8047b156bb 229 case osRtxThreadWaitingMessageGet:
rahul_dahiya 0:fb8047b156bb 230 user_state = WaitingMessageGet;
rahul_dahiya 0:fb8047b156bb 231 break;
rahul_dahiya 0:fb8047b156bb 232 case osRtxThreadWaitingMessagePut:
rahul_dahiya 0:fb8047b156bb 233 user_state = WaitingMessagePut;
rahul_dahiya 0:fb8047b156bb 234 break;
rahul_dahiya 0:fb8047b156bb 235 #endif
rahul_dahiya 0:fb8047b156bb 236 case osThreadTerminated:
rahul_dahiya 0:fb8047b156bb 237 default:
rahul_dahiya 0:fb8047b156bb 238 user_state = Deleted;
rahul_dahiya 0:fb8047b156bb 239 break;
rahul_dahiya 0:fb8047b156bb 240 }
rahul_dahiya 0:fb8047b156bb 241
rahul_dahiya 0:fb8047b156bb 242 return user_state;
rahul_dahiya 0:fb8047b156bb 243 }
rahul_dahiya 0:fb8047b156bb 244
rahul_dahiya 0:fb8047b156bb 245 uint32_t Thread::stack_size() {
rahul_dahiya 0:fb8047b156bb 246 uint32_t size = 0;
rahul_dahiya 0:fb8047b156bb 247 _mutex.lock();
rahul_dahiya 0:fb8047b156bb 248
rahul_dahiya 0:fb8047b156bb 249 if (_tid != NULL) {
rahul_dahiya 0:fb8047b156bb 250 size = osThreadGetStackSize(_tid);
rahul_dahiya 0:fb8047b156bb 251 }
rahul_dahiya 0:fb8047b156bb 252
rahul_dahiya 0:fb8047b156bb 253 _mutex.unlock();
rahul_dahiya 0:fb8047b156bb 254 return size;
rahul_dahiya 0:fb8047b156bb 255 }
rahul_dahiya 0:fb8047b156bb 256
rahul_dahiya 0:fb8047b156bb 257 uint32_t Thread::free_stack() {
rahul_dahiya 0:fb8047b156bb 258 uint32_t size = 0;
rahul_dahiya 0:fb8047b156bb 259 _mutex.lock();
rahul_dahiya 0:fb8047b156bb 260
rahul_dahiya 0:fb8047b156bb 261 #if defined(MBED_OS_BACKEND_RTX5)
rahul_dahiya 0:fb8047b156bb 262 if (_tid != NULL) {
rahul_dahiya 0:fb8047b156bb 263 os_thread_t *thread = (os_thread_t *)_tid;
rahul_dahiya 0:fb8047b156bb 264 size = (uint32_t)thread->sp - (uint32_t)thread->stack_mem;
rahul_dahiya 0:fb8047b156bb 265 }
rahul_dahiya 0:fb8047b156bb 266 #endif
rahul_dahiya 0:fb8047b156bb 267
rahul_dahiya 0:fb8047b156bb 268 _mutex.unlock();
rahul_dahiya 0:fb8047b156bb 269 return size;
rahul_dahiya 0:fb8047b156bb 270 }
rahul_dahiya 0:fb8047b156bb 271
rahul_dahiya 0:fb8047b156bb 272 uint32_t Thread::used_stack() {
rahul_dahiya 0:fb8047b156bb 273 uint32_t size = 0;
rahul_dahiya 0:fb8047b156bb 274 _mutex.lock();
rahul_dahiya 0:fb8047b156bb 275
rahul_dahiya 0:fb8047b156bb 276 #if defined(MBED_OS_BACKEND_RTX5)
rahul_dahiya 0:fb8047b156bb 277 if (_tid != NULL) {
rahul_dahiya 0:fb8047b156bb 278 os_thread_t *thread = (os_thread_t *)_tid;
rahul_dahiya 0:fb8047b156bb 279 size = ((uint32_t)thread->stack_mem + thread->stack_size) - thread->sp;
rahul_dahiya 0:fb8047b156bb 280 }
rahul_dahiya 0:fb8047b156bb 281 #endif
rahul_dahiya 0:fb8047b156bb 282
rahul_dahiya 0:fb8047b156bb 283 _mutex.unlock();
rahul_dahiya 0:fb8047b156bb 284 return size;
rahul_dahiya 0:fb8047b156bb 285 }
rahul_dahiya 0:fb8047b156bb 286
rahul_dahiya 0:fb8047b156bb 287 uint32_t Thread::max_stack() {
rahul_dahiya 0:fb8047b156bb 288 uint32_t size = 0;
rahul_dahiya 0:fb8047b156bb 289 _mutex.lock();
rahul_dahiya 0:fb8047b156bb 290
rahul_dahiya 0:fb8047b156bb 291 if (_tid != NULL) {
rahul_dahiya 0:fb8047b156bb 292 #if defined(MBED_OS_BACKEND_RTX5)
rahul_dahiya 0:fb8047b156bb 293 os_thread_t *thread = (os_thread_t *)_tid;
rahul_dahiya 0:fb8047b156bb 294 uint32_t high_mark = 0;
rahul_dahiya 0:fb8047b156bb 295 while (((uint32_t *)(thread->stack_mem))[high_mark] == 0xE25A2EA5)
rahul_dahiya 0:fb8047b156bb 296 high_mark++;
rahul_dahiya 0:fb8047b156bb 297 size = thread->stack_size - (high_mark * sizeof(uint32_t));
rahul_dahiya 0:fb8047b156bb 298 #else
rahul_dahiya 0:fb8047b156bb 299 size = osThreadGetStackSize(_tid) - osThreadGetStackSpace(_tid);
rahul_dahiya 0:fb8047b156bb 300 #endif
rahul_dahiya 0:fb8047b156bb 301 }
rahul_dahiya 0:fb8047b156bb 302
rahul_dahiya 0:fb8047b156bb 303 _mutex.unlock();
rahul_dahiya 0:fb8047b156bb 304 return size;
rahul_dahiya 0:fb8047b156bb 305 }
rahul_dahiya 0:fb8047b156bb 306
rahul_dahiya 0:fb8047b156bb 307 const char *Thread::get_name() {
rahul_dahiya 0:fb8047b156bb 308 return _attr.name;
rahul_dahiya 0:fb8047b156bb 309 }
rahul_dahiya 0:fb8047b156bb 310
rahul_dahiya 0:fb8047b156bb 311 int32_t Thread::signal_clr(int32_t flags) {
rahul_dahiya 0:fb8047b156bb 312 return osThreadFlagsClear(flags);
rahul_dahiya 0:fb8047b156bb 313 }
rahul_dahiya 0:fb8047b156bb 314
rahul_dahiya 0:fb8047b156bb 315 osEvent Thread::signal_wait(int32_t signals, uint32_t millisec) {
rahul_dahiya 0:fb8047b156bb 316 uint32_t res;
rahul_dahiya 0:fb8047b156bb 317 osEvent evt;
rahul_dahiya 0:fb8047b156bb 318 uint32_t options = osFlagsWaitAll;
rahul_dahiya 0:fb8047b156bb 319 if (signals == 0) {
rahul_dahiya 0:fb8047b156bb 320 options = osFlagsWaitAny;
rahul_dahiya 0:fb8047b156bb 321 signals = 0x7FFFFFFF;
rahul_dahiya 0:fb8047b156bb 322 }
rahul_dahiya 0:fb8047b156bb 323 res = osThreadFlagsWait(signals, options, millisec);
rahul_dahiya 0:fb8047b156bb 324 if (res & osFlagsError) {
rahul_dahiya 0:fb8047b156bb 325 switch (res) {
rahul_dahiya 0:fb8047b156bb 326 case osFlagsErrorISR:
rahul_dahiya 0:fb8047b156bb 327 evt.status = osErrorISR;
rahul_dahiya 0:fb8047b156bb 328 break;
rahul_dahiya 0:fb8047b156bb 329 case osFlagsErrorResource:
rahul_dahiya 0:fb8047b156bb 330 evt.status = osOK;
rahul_dahiya 0:fb8047b156bb 331 break;
rahul_dahiya 0:fb8047b156bb 332 case osFlagsErrorTimeout:
rahul_dahiya 0:fb8047b156bb 333 evt.status = (osStatus)osEventTimeout;
rahul_dahiya 0:fb8047b156bb 334 break;
rahul_dahiya 0:fb8047b156bb 335 case osFlagsErrorParameter:
rahul_dahiya 0:fb8047b156bb 336 default:
rahul_dahiya 0:fb8047b156bb 337 evt.status = (osStatus)osErrorValue;
rahul_dahiya 0:fb8047b156bb 338 break;
rahul_dahiya 0:fb8047b156bb 339 }
rahul_dahiya 0:fb8047b156bb 340 } else {
rahul_dahiya 0:fb8047b156bb 341 evt.status = (osStatus)osEventSignal;
rahul_dahiya 0:fb8047b156bb 342 evt.value.signals = res;
rahul_dahiya 0:fb8047b156bb 343 }
rahul_dahiya 0:fb8047b156bb 344
rahul_dahiya 0:fb8047b156bb 345 return evt;
rahul_dahiya 0:fb8047b156bb 346 }
rahul_dahiya 0:fb8047b156bb 347
rahul_dahiya 0:fb8047b156bb 348 osStatus Thread::wait(uint32_t millisec) {
rahul_dahiya 0:fb8047b156bb 349 return osDelay(millisec);
rahul_dahiya 0:fb8047b156bb 350 }
rahul_dahiya 0:fb8047b156bb 351
rahul_dahiya 0:fb8047b156bb 352 osStatus Thread::yield() {
rahul_dahiya 0:fb8047b156bb 353 return osThreadYield();
rahul_dahiya 0:fb8047b156bb 354 }
rahul_dahiya 0:fb8047b156bb 355
rahul_dahiya 0:fb8047b156bb 356 osThreadId Thread::gettid() {
rahul_dahiya 0:fb8047b156bb 357 return osThreadGetId();
rahul_dahiya 0:fb8047b156bb 358 }
rahul_dahiya 0:fb8047b156bb 359
rahul_dahiya 0:fb8047b156bb 360 void Thread::attach_idle_hook(void (*fptr)(void)) {
rahul_dahiya 0:fb8047b156bb 361 rtos_attach_idle_hook(fptr);
rahul_dahiya 0:fb8047b156bb 362 }
rahul_dahiya 0:fb8047b156bb 363
rahul_dahiya 0:fb8047b156bb 364 void Thread::attach_terminate_hook(void (*fptr)(osThreadId_t id)) {
rahul_dahiya 0:fb8047b156bb 365 terminate_hook = fptr;
rahul_dahiya 0:fb8047b156bb 366 }
rahul_dahiya 0:fb8047b156bb 367
rahul_dahiya 0:fb8047b156bb 368 Thread::~Thread() {
rahul_dahiya 0:fb8047b156bb 369 // terminate is thread safe
rahul_dahiya 0:fb8047b156bb 370 terminate();
rahul_dahiya 0:fb8047b156bb 371 if (_dynamic_stack) {
rahul_dahiya 0:fb8047b156bb 372 delete[] (uint32_t*)(_attr.stack_mem);
rahul_dahiya 0:fb8047b156bb 373 _attr.stack_mem = (uint32_t*)NULL;
rahul_dahiya 0:fb8047b156bb 374 }
rahul_dahiya 0:fb8047b156bb 375 }
rahul_dahiya 0:fb8047b156bb 376
rahul_dahiya 0:fb8047b156bb 377 void Thread::_thunk(void * thread_ptr)
rahul_dahiya 0:fb8047b156bb 378 {
rahul_dahiya 0:fb8047b156bb 379 Thread *t = (Thread*)thread_ptr;
rahul_dahiya 0:fb8047b156bb 380 t->_task();
rahul_dahiya 0:fb8047b156bb 381 t->_mutex.lock();
rahul_dahiya 0:fb8047b156bb 382 t->_tid = (osThreadId)NULL;
rahul_dahiya 0:fb8047b156bb 383 t->_finished = true;
rahul_dahiya 0:fb8047b156bb 384 t->_join_sem.release();
rahul_dahiya 0:fb8047b156bb 385 // rtos will release the mutex automatically
rahul_dahiya 0:fb8047b156bb 386 }
rahul_dahiya 0:fb8047b156bb 387
rahul_dahiya 0:fb8047b156bb 388 }