git.sur5r.net Git - openocd/blob - src/rtos/uCOS-III.c

   1 /***************************************************************************
   2  *   Copyright (C) 2017 by Square, Inc.                                    *
   3  *   Steven Stallion <stallion@squareup.com>                               *
   4  *                                                                         *
   5  *   This program is free software; you can redistribute it and/or modify  *
   6  *   it under the terms of the GNU General Public License as published by  *
   7  *   the Free Software Foundation; either version 2 of the License, or     *
   8  *   (at your option) any later version.                                   *
   9  *                                                                         *
  10  *   This program is distributed in the hope that it will be useful,       *
  11  *   but WITHOUT ANY WARRANTY; without even the implied warranty of        *
  12  *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the         *
  13  *   GNU General Public License for more details.                          *
  14  *                                                                         *
  15  *   You should have received a copy of the GNU General Public License     *
  16  *   along with this program.  If not, see <http://www.gnu.org/licenses/>. *
  17  ***************************************************************************/
  18
  19 #ifdef HAVE_CONFIG_H
  20 #include "config.h"
  21 #endif
  22
  23 #include <helper/log.h>
  24 #include <helper/time_support.h>
  25 #include <helper/types.h>
  26 #include <rtos/rtos.h>
  27 #include <target/target.h>
  28 #include <target/target_type.h>
  29
  30 #include "rtos_ucos_iii_stackings.h"
  31
  32 #ifndef UCOS_III_MAX_STRLEN
  33 #define UCOS_III_MAX_STRLEN 64
  34 #endif
  35
  36 #ifndef UCOS_III_MAX_THREADS
  37 #define UCOS_III_MAX_THREADS 256
  38 #endif
  39
  40 struct uCOS_III_params {
  41         const char *target_name;
  42         const unsigned char pointer_width;
  43         symbol_address_t thread_stack_offset;
  44         symbol_address_t thread_name_offset;
  45         symbol_address_t thread_state_offset;
  46         symbol_address_t thread_priority_offset;
  47         symbol_address_t thread_prev_offset;
  48         symbol_address_t thread_next_offset;
  49         bool thread_offsets_updated;
  50         size_t threadid_start;
  51         const struct rtos_register_stacking *stacking_info;
  52         size_t num_threads;
  53         symbol_address_t threads[];
  54 };
  55
  56 static const struct uCOS_III_params uCOS_III_params_list[] = {
  57         {
  58                 "cortex_m",                                                     /* target_name */
  59                 sizeof(uint32_t),                                       /* pointer_width */
  60                 0,                                                                      /* thread_stack_offset */
  61                 0,                                                                      /* thread_name_offset */
  62                 0,                                                                      /* thread_state_offset */
  63                 0,                                                                      /* thread_priority_offset */
  64                 0,                                                                      /* thread_prev_offset */
  65                 0,                                                                      /* thread_next_offset */
  66                 false,                                                          /* thread_offsets_updated */
  67                 1,                                                                      /* threadid_start */
  68                 &rtos_uCOS_III_Cortex_M_stacking,       /* stacking_info */
  69                 0,                                                                      /* num_threads */
  70         },
  71         {
  72                 "esirisc",                                                      /* target_name */
  73                 sizeof(uint32_t),                                       /* pointer_width */
  74                 0,                                                                      /* thread_stack_offset */
  75                 0,                                                                      /* thread_name_offset */
  76                 0,                                                                      /* thread_state_offset */
  77                 0,                                                                      /* thread_priority_offset */
  78                 0,                                                                      /* thread_prev_offset */
  79                 0,                                                                      /* thread_next_offset */
  80                 false,                                                          /* thread_offsets_updated */
  81                 1,                                                                      /* threadid_start */
  82                 &rtos_uCOS_III_eSi_RISC_stacking,       /* stacking_info */
  83                 0,                                                                      /* num_threads */
  84         },
  85 };
  86
  87 static const char * const uCOS_III_symbol_list[] = {
  88         "OSRunning",
  89         "OSTCBCurPtr",
  90         "OSTaskDbgListPtr",
  91         "OSTaskQty",
  92
  93         /* also see: contrib/rtos-helpers/uCOS-III-openocd.c */
  94         "openocd_OS_TCB_StkPtr_offset",
  95         "openocd_OS_TCB_NamePtr_offset",
  96         "openocd_OS_TCB_TaskState_offset",
  97         "openocd_OS_TCB_Prio_offset",
  98         "openocd_OS_TCB_DbgPrevPtr_offset",
  99         "openocd_OS_TCB_DbgNextPtr_offset",
 100         NULL
 101 };
 102
 103 enum uCOS_III_symbol_values {
 104         uCOS_III_VAL_OSRunning,
 105         uCOS_III_VAL_OSTCBCurPtr,
 106         uCOS_III_VAL_OSTaskDbgListPtr,
 107         uCOS_III_VAL_OSTaskQty,
 108
 109         /* also see: contrib/rtos-helpers/uCOS-III-openocd.c */
 110         uCOS_III_VAL_OS_TCB_StkPtr_offset,
 111         uCOS_III_VAL_OS_TCB_NamePtr_offset,
 112         uCOS_III_VAL_OS_TCB_TaskState_offset,
 113         uCOS_III_VAL_OS_TCB_Prio_offset,
 114         uCOS_III_VAL_OS_TCB_DbgPrevPtr_offset,
 115         uCOS_III_VAL_OS_TCB_DbgNextPtr_offset,
 116 };
 117
 118 static const char * const uCOS_III_thread_state_list[] = {
 119         "Ready",
 120         "Delay",
 121         "Pend",
 122         "Pend Timeout",
 123         "Suspended",
 124         "Delay Suspended",
 125         "Pend Suspended",
 126         "Pend Timeout Suspended",
 127 };
 128
 129 static int uCOS_III_find_or_create_thread(struct rtos *rtos, symbol_address_t thread_address,
 130                 threadid_t *threadid)
 131 {
 132         struct uCOS_III_params *params = rtos->rtos_specific_params;
 133         size_t thread_index;
 134
 135         for (thread_index = 0; thread_index < params->num_threads; thread_index++)
 136                 if (params->threads[thread_index] == thread_address)
 137                         goto found;
 138
 139         if (params->num_threads == UCOS_III_MAX_THREADS) {
 140                 LOG_WARNING("uCOS-III: too many threads; increase UCOS_III_MAX_THREADS");
 141                 return ERROR_FAIL;
 142         }
 143
 144         params->threads[thread_index] = thread_address;
 145         params->num_threads++;
 146 found:
 147         *threadid = thread_index + params->threadid_start;
 148         return ERROR_OK;
 149 }
 150
 151 static int uCOS_III_find_thread_address(struct rtos *rtos, threadid_t threadid,
 152                 symbol_address_t *thread_address)
 153 {
 154         struct uCOS_III_params *params = rtos->rtos_specific_params;
 155         size_t thread_index;
 156
 157         thread_index = threadid - params->threadid_start;
 158         if (thread_index >= params->num_threads) {
 159                 LOG_ERROR("uCOS-III: failed to find thread address");
 160                 return ERROR_FAIL;
 161         }
 162
 163         *thread_address = params->threads[thread_index];
 164         return ERROR_OK;
 165 }
 166
 167 static int uCOS_III_find_last_thread_address(struct rtos *rtos, symbol_address_t *thread_address)
 168 {
 169         struct uCOS_III_params *params = rtos->rtos_specific_params;
 170         int retval;
 171
 172         /* read the thread list head */
 173         symbol_address_t thread_list_address = 0;
 174
 175         retval = target_read_memory(rtos->target,
 176                         rtos->symbols[uCOS_III_VAL_OSTaskDbgListPtr].address,
 177                         params->pointer_width,
 178                         1,
 179                         (void *)&thread_list_address);
 180         if (retval != ERROR_OK) {
 181                 LOG_ERROR("uCOS-III: failed to read thread list address");
 182                 return retval;
 183         }
 184
 185         /* advance to end of thread list */
 186         do {
 187                 *thread_address = thread_list_address;
 188
 189                 retval = target_read_memory(rtos->target,
 190                                 thread_list_address + params->thread_next_offset,
 191                                 params->pointer_width,
 192                                 1,
 193                                 (void *)&thread_list_address);
 194                 if (retval != ERROR_OK) {
 195                         LOG_ERROR("uCOS-III: failed to read next thread address");
 196                         return retval;
 197                 }
 198         } while (thread_list_address != 0);
 199
 200         return ERROR_OK;
 201 }
 202
 203 static int uCOS_III_update_thread_offsets(struct rtos *rtos)
 204 {
 205         struct uCOS_III_params *params = rtos->rtos_specific_params;
 206
 207         if (params->thread_offsets_updated)
 208                 return ERROR_OK;
 209
 210         const struct thread_offset_map {
 211                 enum uCOS_III_symbol_values symbol_value;
 212                 symbol_address_t *thread_offset;
 213         } thread_offset_maps[] = {
 214                 {
 215                         uCOS_III_VAL_OS_TCB_StkPtr_offset,
 216                         &params->thread_stack_offset,
 217                 },
 218                 {
 219                         uCOS_III_VAL_OS_TCB_NamePtr_offset,
 220                         &params->thread_name_offset,
 221                 },
 222                 {
 223                         uCOS_III_VAL_OS_TCB_TaskState_offset,
 224                         &params->thread_state_offset,
 225                 },
 226                 {
 227                         uCOS_III_VAL_OS_TCB_Prio_offset,
 228                         &params->thread_priority_offset,
 229                 },
 230                 {
 231                         uCOS_III_VAL_OS_TCB_DbgPrevPtr_offset,
 232                         &params->thread_prev_offset,
 233                 },
 234                 {
 235                         uCOS_III_VAL_OS_TCB_DbgNextPtr_offset,
 236                         &params->thread_next_offset,
 237                 },
 238         };
 239
 240         for (size_t i = 0; i < ARRAY_SIZE(thread_offset_maps); i++) {
 241                 const struct thread_offset_map *thread_offset_map = &thread_offset_maps[i];
 242
 243                 int retval = target_read_memory(rtos->target,
 244                                 rtos->symbols[thread_offset_map->symbol_value].address,
 245                                 params->pointer_width,
 246                                 1,
 247                                 (void *)thread_offset_map->thread_offset);
 248                 if (retval != ERROR_OK) {
 249                         LOG_ERROR("uCOS-III: failed to read thread offset");
 250                         return retval;
 251                 }
 252         }
 253
 254         params->thread_offsets_updated = true;
 255         return ERROR_OK;
 256 }
 257
 258 static bool uCOS_III_detect_rtos(struct target *target)
 259 {
 260         return target->rtos->symbols != NULL &&
 261                         target->rtos->symbols[uCOS_III_VAL_OSRunning].address != 0;
 262 }
 263
 264 static int uCOS_III_reset_handler(struct target *target, enum target_reset_mode reset_mode, void *priv)
 265 {
 266         struct uCOS_III_params *params = target->rtos->rtos_specific_params;
 267
 268         params->thread_offsets_updated = false;
 269         params->num_threads = 0;
 270
 271         return ERROR_OK;
 272 }
 273
 274 static int uCOS_III_create(struct target *target)
 275 {
 276         struct uCOS_III_params *params;
 277
 278         for (size_t i = 0; i < ARRAY_SIZE(uCOS_III_params_list); i++)
 279                 if (strcmp(uCOS_III_params_list[i].target_name, target->type->name) == 0) {
 280                         params = malloc(sizeof(*params) + (UCOS_III_MAX_THREADS * sizeof(*params->threads)));
 281                         if (params == NULL) {
 282                                 LOG_ERROR("uCOS-III: out of memory");
 283                                 return ERROR_FAIL;
 284                         }
 285
 286                         memcpy(params, &uCOS_III_params_list[i], sizeof(uCOS_III_params_list[i]));
 287                         target->rtos->rtos_specific_params = (void *)params;
 288
 289                         target_register_reset_callback(uCOS_III_reset_handler, NULL);
 290
 291                         return ERROR_OK;
 292                 }
 293
 294         LOG_ERROR("uCOS-III: target not supported: %s", target->type->name);
 295         return ERROR_FAIL;
 296 }
 297
 298 static int uCOS_III_update_threads(struct rtos *rtos)
 299 {
 300         struct uCOS_III_params *params = rtos->rtos_specific_params;
 301         int retval;
 302
 303         if (rtos->symbols == NULL) {
 304                 LOG_ERROR("uCOS-III: symbol list not loaded");
 305                 return ERROR_FAIL;
 306         }
 307
 308         /* free previous thread details */
 309         rtos_free_threadlist(rtos);
 310
 311         /* verify RTOS is running */
 312         uint8_t rtos_running;
 313
 314         retval = target_read_u8(rtos->target,
 315                         rtos->symbols[uCOS_III_VAL_OSRunning].address,
 316                         &rtos_running);
 317         if (retval != ERROR_OK) {
 318                 LOG_ERROR("uCOS-III: failed to read RTOS running");
 319                 return retval;
 320         }
 321
 322         if (rtos_running != 1 && rtos_running != 0) {
 323                 LOG_ERROR("uCOS-III: invalid RTOS running value");
 324                 return ERROR_FAIL;
 325         }
 326
 327         if (!rtos_running) {
 328                 rtos->thread_details = calloc(1, sizeof(struct thread_detail));
 329                 if (rtos->thread_details == NULL) {
 330                         LOG_ERROR("uCOS-III: out of memory");
 331                         return ERROR_FAIL;
 332                 }
 333
 334                 rtos->thread_count = 1;
 335                 rtos->thread_details->threadid = 0;
 336                 rtos->thread_details->exists = true;
 337                 rtos->current_thread = 0;
 338
 339                 return ERROR_OK;
 340         }
 341
 342         /* update thread offsets */
 343         retval = uCOS_III_update_thread_offsets(rtos);
 344         if (retval != ERROR_OK) {
 345                 LOG_ERROR("uCOS-III: failed to update thread offsets");
 346                 return retval;
 347         }
 348
 349         /* read current thread address */
 350         symbol_address_t current_thread_address = 0;
 351
 352         retval = target_read_memory(rtos->target,
 353                         rtos->symbols[uCOS_III_VAL_OSTCBCurPtr].address,
 354                         params->pointer_width,
 355                         1,
 356                         (void *)&current_thread_address);
 357         if (retval != ERROR_OK) {
 358                 LOG_ERROR("uCOS-III: failed to read current thread address");
 359                 return retval;
 360         }
 361
 362         /* read number of tasks */
 363         retval = target_read_u16(rtos->target,
 364                         rtos->symbols[uCOS_III_VAL_OSTaskQty].address,
 365                         (void *)&rtos->thread_count);
 366         if (retval != ERROR_OK) {
 367                 LOG_ERROR("uCOS-III: failed to read thread count");
 368                 return retval;
 369         }
 370
 371         rtos->thread_details = calloc(rtos->thread_count, sizeof(struct thread_detail));
 372         if (rtos->thread_details == NULL) {
 373                 LOG_ERROR("uCOS-III: out of memory");
 374                 return ERROR_FAIL;
 375         }
 376
 377         /*
 378          * uC/OS-III adds tasks in LIFO order; advance to the end of the
 379          * list and work backwards to preserve the intended order.
 380          */
 381         symbol_address_t thread_address = 0;
 382
 383         retval = uCOS_III_find_last_thread_address(rtos, &thread_address);
 384         if (retval != ERROR_OK) {
 385                 LOG_ERROR("uCOS-III: failed to find last thread address");
 386                 return retval;
 387         }
 388
 389         for (int i = 0; i < rtos->thread_count; i++) {
 390                 struct thread_detail *thread_detail = &rtos->thread_details[i];
 391                 char thread_str_buffer[UCOS_III_MAX_STRLEN + 1];
 392
 393                 /* find or create new threadid */
 394                 retval = uCOS_III_find_or_create_thread(rtos, thread_address, &thread_detail->threadid);
 395                 if (retval != ERROR_OK) {
 396                         LOG_ERROR("uCOS-III: failed to find or create thread");
 397                         return retval;
 398                 }
 399
 400                 if (thread_address == current_thread_address)
 401                         rtos->current_thread = thread_detail->threadid;
 402
 403                 thread_detail->exists = true;
 404
 405                 /* read thread name */
 406                 symbol_address_t thread_name_address = 0;
 407
 408                 retval = target_read_memory(rtos->target,
 409                                 thread_address + params->thread_name_offset,
 410                                 params->pointer_width,
 411                                 1,
 412                                 (void *)&thread_name_address);
 413                 if (retval != ERROR_OK) {
 414                         LOG_ERROR("uCOS-III: failed to name address");
 415                         return retval;
 416                 }
 417
 418                 retval = target_read_buffer(rtos->target,
 419                                 thread_name_address,
 420                                 sizeof(thread_str_buffer),
 421                                 (void *)thread_str_buffer);
 422                 if (retval != ERROR_OK) {
 423                         LOG_ERROR("uCOS-III: failed to read thread name");
 424                         return retval;
 425                 }
 426
 427                 thread_str_buffer[sizeof(thread_str_buffer) - 1] = '\0';
 428                 thread_detail->thread_name_str = strdup(thread_str_buffer);
 429
 430                 /* read thread extra info */
 431                 uint8_t thread_state;
 432                 uint8_t thread_priority;
 433
 434                 retval = target_read_u8(rtos->target,
 435                                 thread_address + params->thread_state_offset,
 436                                 &thread_state);
 437                 if (retval != ERROR_OK) {
 438                         LOG_ERROR("uCOS-III: failed to read thread state");
 439                         return retval;
 440                 }
 441
 442                 retval = target_read_u8(rtos->target,
 443                                 thread_address + params->thread_priority_offset,
 444                                 &thread_priority);
 445                 if (retval != ERROR_OK) {
 446                         LOG_ERROR("uCOS-III: failed to read thread priority");
 447                         return retval;
 448                 }
 449
 450                 const char *thread_state_str;
 451
 452                 if (thread_state < ARRAY_SIZE(uCOS_III_thread_state_list))
 453                         thread_state_str = uCOS_III_thread_state_list[thread_state];
 454                 else
 455                         thread_state_str = "Unknown";
 456
 457                 snprintf(thread_str_buffer, sizeof(thread_str_buffer), "State: %s, Priority: %d",
 458                                 thread_state_str, thread_priority);
 459                 thread_detail->extra_info_str = strdup(thread_str_buffer);
 460
 461                 /* read previous thread address */
 462                 retval = target_read_memory(rtos->target,
 463                                 thread_address + params->thread_prev_offset,
 464                                 params->pointer_width,
 465                                 1,
 466                                 (void *)&thread_address);
 467                 if (retval != ERROR_OK) {
 468                         LOG_ERROR("uCOS-III: failed to read previous thread address");
 469                         return retval;
 470                 }
 471         }
 472
 473         return ERROR_OK;
 474 }
 475
 476 static int uCOS_III_get_thread_reg_list(struct rtos *rtos, threadid_t threadid,
 477                 struct rtos_reg **reg_list, int *num_regs)
 478 {
 479         struct uCOS_III_params *params = rtos->rtos_specific_params;
 480         int retval;
 481
 482         /* find thread address for threadid */
 483         symbol_address_t thread_address = 0;
 484
 485         retval = uCOS_III_find_thread_address(rtos, threadid, &thread_address);
 486         if (retval != ERROR_OK) {
 487                 LOG_ERROR("uCOS-III: failed to find thread address");
 488                 return retval;
 489         }
 490
 491         /* read thread stack address */
 492         symbol_address_t stack_address = 0;
 493
 494         retval = target_read_memory(rtos->target,
 495                         thread_address + params->thread_stack_offset,
 496                         params->pointer_width,
 497                         1,
 498                         (void *)&stack_address);
 499         if (retval != ERROR_OK) {
 500                 LOG_ERROR("uCOS-III: failed to read stack address");
 501                 return retval;
 502         }
 503
 504         return rtos_generic_stack_read(rtos->target,
 505                         params->stacking_info,
 506                         stack_address,
 507                         reg_list,
 508                         num_regs);
 509 }
 510
 511 static int uCOS_III_get_symbol_list_to_lookup(symbol_table_elem_t *symbol_list[])
 512 {
 513         *symbol_list = calloc(ARRAY_SIZE(uCOS_III_symbol_list), sizeof(symbol_table_elem_t));
 514         if (*symbol_list == NULL) {
 515                 LOG_ERROR("uCOS-III: out of memory");
 516                 return ERROR_FAIL;
 517         }
 518
 519         for (size_t i = 0; i < ARRAY_SIZE(uCOS_III_symbol_list); i++)
 520                 (*symbol_list)[i].symbol_name = uCOS_III_symbol_list[i];
 521
 522         return ERROR_OK;
 523 }
 524
 525 const struct rtos_type uCOS_III_rtos = {
 526         .name = "uCOS-III",
 527         .detect_rtos = uCOS_III_detect_rtos,
 528         .create = uCOS_III_create,
 529         .update_threads = uCOS_III_update_threads,
 530         .get_thread_reg_list = uCOS_III_get_thread_reg_list,
 531         .get_symbol_list_to_lookup = uCOS_III_get_symbol_list_to_lookup,
 532 };