git.gag.com Git - fw/openocd/blob - src/rtos/linux.c

   1 /***************************************************************************
   2  *   Copyright (C) 2011 by STEricsson                                      *
   3  *   Heythem Bouhaja heythem.bouhaja@stericsson.com   : creation           *
   4  *   Michel JAOUEN michel.jaouen@stericsson.com : adaptation to rtos       *
   5  *                                                                         *
   6  *   This program is free software; you can redistribute it and/or modify  *
   7  *   it under the terms of the GNU General Public License as published by  *
   8  *   the Free Software Foundation; either version 2 of the License, or     *
   9  *   (at your option) any later version.                                   *
  10  *                                                                         *
  11  *   This program is distributed in the hope that it will be useful,       *
  12  *   but WITHOUT ANY WARRANTY; without even the implied warranty of        *
  13  *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the         *
  14  *   GNU General Public License for more details.                          *
  15  *                                                                         *
  16  *   You should have received a copy of the GNU General Public License     *
  17  *   along with this program.  If not, see <http://www.gnu.org/licenses/>. *
  18  ***************************************************************************/
  19
  20 #ifdef HAVE_CONFIG_H
  21 #include "config.h"
  22 #endif
  23
  24 #include <helper/time_support.h>
  25 #include <jtag/jtag.h>
  26 #include "target/target.h"
  27 #include "target/target_type.h"
  28 #include "helper/log.h"
  29 #include "helper/types.h"
  30 #include "rtos.h"
  31 #include "rtos_standard_stackings.h"
  32 #include <target/register.h>
  33 #include "server/gdb_server.h"
  34
  35 #define LINUX_USER_KERNEL_BORDER 0xc0000000
  36 #include "linux_header.h"
  37 #define PHYS
  38 #define MAX_THREADS 200
  39 /*  specific task  */
  40 struct linux_os {
  41         const char *name;
  42         uint32_t init_task_addr;
  43         int thread_count;
  44         int threadid_count;
  45         int preupdtate_threadid_count;
  46         int nr_cpus;
  47         int threads_lookup;
  48         int threads_needs_update;
  49         struct current_thread *current_threads;
  50         struct threads *thread_list;
  51         /*  virt2phys parameter */
  52         uint32_t phys_mask;
  53         uint32_t phys_base;
  54 };
  55
  56 struct current_thread {
  57         int64_t threadid;
  58         int32_t core_id;
  59 #ifdef PID_CHECK
  60         uint32_t pid;
  61 #endif
  62         uint32_t TS;
  63         struct current_thread *next;
  64 };
  65
  66 struct threads {
  67         char name[17];
  68         uint32_t base_addr;     /*  address to read magic */
  69         uint32_t state;         /*  magic value : filled only at creation */
  70         uint32_t pid;           /* linux pid : id for identifying a thread */
  71         uint32_t oncpu;         /* content cpu number in current thread */
  72         uint32_t asid;          /*  filled only at creation  */
  73         int64_t threadid;
  74         int status;             /* dead = 1 alive = 2 current = 3 alive and current */
  75         /*  value that should not change during the live of a thread ? */
  76         uint32_t thread_info_addr;      /*  contain latest thread_info_addr computed */
  77         /*  retrieve from thread_info */
  78         struct cpu_context *context;
  79         struct threads *next;
  80 };
  81
  82 struct cpu_context {
  83         uint32_t R4;
  84         uint32_t R5;
  85         uint32_t R6;
  86         uint32_t R7;
  87         uint32_t R8;
  88         uint32_t R9;
  89         uint32_t IP;
  90         uint32_t FP;
  91         uint32_t SP;
  92         uint32_t PC;
  93         uint32_t preempt_count;
  94 };
  95 static struct cpu_context *cpu_context_read(struct target *target, uint32_t base_addr,
  96                                      uint32_t *info_addr);
  97 static int insert_into_threadlist(struct target *target, struct threads *t);
  98
  99 static int linux_os_create(struct target *target);
 100
 101 static int linux_os_dummy_update(struct rtos *rtos)
 102 {
 103         /*  update is done only when thread request come
 104          *  too many thread to do it on each stop */
 105         return 0;
 106 }
 107
 108 static int linux_compute_virt2phys(struct target *target, target_addr_t address)
 109 {
 110         struct linux_os *linux_os = (struct linux_os *)
 111                 target->rtos->rtos_specific_params;
 112         target_addr_t pa = 0;
 113         int retval = target->type->virt2phys(target, address, &pa);
 114         if (retval != ERROR_OK) {
 115                 LOG_ERROR("Cannot compute linux virt2phys translation");
 116                 /*  fixes default address  */
 117                 linux_os->phys_base = 0;
 118                 return ERROR_FAIL;
 119         }
 120
 121         linux_os->init_task_addr = address;
 122         address = address & linux_os->phys_mask;
 123         linux_os->phys_base = pa - address;
 124         return ERROR_OK;
 125 }
 126
 127 static int linux_read_memory(struct target *target,
 128         uint32_t address, uint32_t size, uint32_t count,
 129         uint8_t *buffer)
 130 {
 131 #ifdef PHYS
 132         struct linux_os *linux_os = (struct linux_os *)
 133                 target->rtos->rtos_specific_params;
 134         uint32_t pa = (address & linux_os->phys_mask) + linux_os->phys_base;
 135 #endif
 136         if (address < 0xc000000) {
 137                 LOG_ERROR("linux awareness : address in user space");
 138                 return ERROR_FAIL;
 139         }
 140 #ifdef PHYS
 141         target_read_phys_memory(target, pa, size, count, buffer);
 142 #endif
 143         target_read_memory(target, address, size, count, buffer);
 144         return ERROR_OK;
 145 }
 146
 147 static int fill_buffer(struct target *target, uint32_t addr, uint8_t *buffer)
 148 {
 149
 150         if ((addr & 0xfffffffc) != addr)
 151                 LOG_INFO("unaligned address %" PRIx32 "!!", addr);
 152
 153         int retval = linux_read_memory(target, addr, 4, 1, buffer);
 154         return retval;
 155
 156 }
 157
 158 static uint32_t get_buffer(struct target *target, const uint8_t *buffer)
 159 {
 160         uint32_t value = 0;
 161         const uint8_t *value_ptr = buffer;
 162         value = target_buffer_get_u32(target, value_ptr);
 163         return value;
 164 }
 165
 166 static int linux_os_thread_reg_list(struct rtos *rtos,
 167         int64_t thread_id, struct rtos_reg **reg_list, int *num_regs)
 168 {
 169         struct target *target = rtos->target;
 170         struct linux_os *linux_os = (struct linux_os *)
 171                 target->rtos->rtos_specific_params;
 172         struct current_thread *tmp = linux_os->current_threads;
 173         struct current_thread *next;
 174         int found = 0;
 175         int retval;
 176         /*  check if a current thread is requested  */
 177         next = tmp;
 178
 179         do {
 180                 if (next->threadid == thread_id)
 181                         found = 1;
 182                 else
 183                         next = next->next;
 184         } while ((found == 0) && (next != tmp) && (next));
 185
 186         if (found == 0) {
 187                 LOG_ERROR("could not find thread: %" PRIx64, thread_id);
 188                 return ERROR_FAIL;
 189         }
 190
 191         /*  search target to perform the access  */
 192         struct reg **gdb_reg_list;
 193         struct target_list *head;
 194         head = target->head;
 195         found = 0;
 196         do {
 197                 if (head->target->coreid == next->core_id) {
 198                         target = head->target;
 199                         found = 1;
 200                         break;
 201                 }
 202                 head = head->next;
 203         } while (head);
 204
 205         if (found == 0) {
 206                 LOG_ERROR
 207                 (
 208                         "current thread %" PRIx64 ": no target to perform access of core id %" PRIx32,
 209                         thread_id,
 210                         next->core_id);
 211                 return ERROR_FAIL;
 212         }
 213
 214         /*LOG_INFO("thread %lx current on core %x",thread_id, target->coreid);*/
 215         retval = target_get_gdb_reg_list(target, &gdb_reg_list, num_regs, REG_CLASS_GENERAL);
 216         if (retval != ERROR_OK)
 217                 return retval;
 218
 219         *reg_list = calloc(*num_regs, sizeof(struct rtos_reg));
 220
 221         for (int i = 0; i < *num_regs; ++i) {
 222                 if (!gdb_reg_list[i]->valid)
 223                         gdb_reg_list[i]->type->get(gdb_reg_list[i]);
 224
 225                 (*reg_list)[i].number = gdb_reg_list[i]->number;
 226                 (*reg_list)[i].size = gdb_reg_list[i]->size;
 227
 228                 buf_cpy(gdb_reg_list[i]->value, (*reg_list)[i].value, (*reg_list)[i].size);
 229         }
 230
 231         return ERROR_OK;
 232 }
 233
 234 static bool linux_os_detect(struct target *target)
 235 {
 236         LOG_INFO("should no be called");
 237         return false;
 238 }
 239
 240 static int linux_os_smp_init(struct target *target);
 241 static int linux_os_clean(struct target *target);
 242 #define INIT_TASK 0
 243 static const char * const linux_symbol_list[] = {
 244         "init_task",
 245         NULL
 246 };
 247
 248 static int linux_get_symbol_list_to_lookup(struct symbol_table_elem *symbol_list[])
 249 {
 250         unsigned int i;
 251         *symbol_list = (struct symbol_table_elem *)
 252                 calloc(ARRAY_SIZE(linux_symbol_list), sizeof(struct symbol_table_elem));
 253
 254         for (i = 0; i < ARRAY_SIZE(linux_symbol_list); i++)
 255                 (*symbol_list)[i].symbol_name = linux_symbol_list[i];
 256
 257         return 0;
 258 }
 259
 260 static char *linux_ps_command(struct target *target);
 261
 262 const struct rtos_type linux_rtos = {
 263         .name = "linux",
 264         .detect_rtos = linux_os_detect,
 265         .create = linux_os_create,
 266         .smp_init = linux_os_smp_init,
 267         .update_threads = linux_os_dummy_update,
 268         .get_thread_reg_list = linux_os_thread_reg_list,
 269         .get_symbol_list_to_lookup = linux_get_symbol_list_to_lookup,
 270         .clean = linux_os_clean,
 271         .ps_command = linux_ps_command,
 272 };
 273
 274 static int linux_thread_packet(struct connection *connection, char const *packet,
 275                 int packet_size);
 276 static void linux_identify_current_threads(struct target *target);
 277
 278 #ifdef PID_CHECK
 279 int fill_task_pid(struct target *target, struct threads *t)
 280 {
 281         uint32_t pid_addr = t->base_addr + PID;
 282         uint8_t buffer[4];
 283         int retval = fill_buffer(target, pid_addr, buffer);
 284
 285         if (retval == ERROR_OK) {
 286                 uint32_t val = get_buffer(target, buffer);
 287                 t->pid = val;
 288         } else
 289                 LOG_ERROR("fill_task_pid: unable to read memory");
 290
 291         return retval;
 292 }
 293 #endif
 294
 295 static int fill_task(struct target *target, struct threads *t)
 296 {
 297         int retval;
 298         uint32_t pid_addr = t->base_addr + PID;
 299         uint32_t mem_addr = t->base_addr + MEM;
 300         uint32_t on_cpu = t->base_addr + ONCPU;
 301         uint8_t *buffer = calloc(1, 4);
 302         retval = fill_buffer(target, t->base_addr, buffer);
 303
 304         if (retval == ERROR_OK) {
 305                 uint32_t val = get_buffer(target, buffer);
 306                 t->state = val;
 307         } else
 308                 LOG_ERROR("fill_task: unable to read memory");
 309
 310         retval = fill_buffer(target, pid_addr, buffer);
 311
 312         if (retval == ERROR_OK) {
 313                 uint32_t val = get_buffer(target, buffer);
 314                 t->pid = val;
 315         } else
 316                 LOG_ERROR("fill task: unable to read memory");
 317
 318         retval = fill_buffer(target, on_cpu, buffer);
 319
 320         if (retval == ERROR_OK) {
 321                 uint32_t val = get_buffer(target, buffer);
 322                 t->oncpu = val;
 323         } else
 324                 LOG_ERROR("fill task: unable to read memory");
 325
 326         retval = fill_buffer(target, mem_addr, buffer);
 327
 328         if (retval == ERROR_OK) {
 329                 uint32_t val = get_buffer(target, buffer);
 330
 331                 if (val != 0) {
 332                         uint32_t asid_addr = val + MM_CTX;
 333                         retval = fill_buffer(target, asid_addr, buffer);
 334
 335                         if (retval == ERROR_OK) {
 336                                 val = get_buffer(target, buffer);
 337                                 t->asid = val;
 338                         } else
 339                                 LOG_ERROR
 340                                         ("fill task: unable to read memory -- ASID");
 341                 } else
 342                         t->asid = 0;
 343         } else
 344                 LOG_ERROR("fill task: unable to read memory");
 345
 346         free(buffer);
 347
 348         return retval;
 349 }
 350
 351 static int get_name(struct target *target, struct threads *t)
 352 {
 353         int retval;
 354         uint32_t full_name[4];
 355         uint32_t comm = t->base_addr + COMM;
 356         int i;
 357
 358         for (i = 0; i < 17; i++)
 359                 t->name[i] = 0;
 360
 361         retval = linux_read_memory(target, comm, 4, 4, (uint8_t *) full_name);
 362
 363         if (retval != ERROR_OK) {
 364                 LOG_ERROR("get_name: unable to read memory\n");
 365                 return ERROR_FAIL;
 366         }
 367
 368         uint32_t raw_name = target_buffer_get_u32(target,
 369                         (const uint8_t *)
 370                         &full_name[0]);
 371         t->name[3] = raw_name >> 24;
 372         t->name[2] = raw_name >> 16;
 373         t->name[1] = raw_name >> 8;
 374         t->name[0] = raw_name;
 375         raw_name =
 376                 target_buffer_get_u32(target, (const uint8_t *)&full_name[1]);
 377         t->name[7] = raw_name >> 24;
 378         t->name[6] = raw_name >> 16;
 379         t->name[5] = raw_name >> 8;
 380         t->name[4] = raw_name;
 381         raw_name =
 382                 target_buffer_get_u32(target, (const uint8_t *)&full_name[2]);
 383         t->name[11] = raw_name >> 24;
 384         t->name[10] = raw_name >> 16;
 385         t->name[9] = raw_name >> 8;
 386         t->name[8] = raw_name;
 387         raw_name =
 388                 target_buffer_get_u32(target, (const uint8_t *)&full_name[3]);
 389         t->name[15] = raw_name >> 24;
 390         t->name[14] = raw_name >> 16;
 391         t->name[13] = raw_name >> 8;
 392         t->name[12] = raw_name;
 393         return ERROR_OK;
 394
 395 }
 396
 397 static int get_current(struct target *target, int create)
 398 {
 399         struct target_list *head;
 400         head = target->head;
 401         uint8_t *buf;
 402         uint32_t val;
 403         uint32_t ti_addr;
 404         uint8_t *buffer = calloc(1, 4);
 405         struct linux_os *linux_os = (struct linux_os *)
 406                 target->rtos->rtos_specific_params;
 407         struct current_thread *ctt = linux_os->current_threads;
 408
 409         /*  invalid current threads content */
 410         while (ctt) {
 411                 ctt->threadid = -1;
 412                 ctt->TS = 0xdeadbeef;
 413                 ctt = ctt->next;
 414         }
 415
 416         while (head) {
 417                 struct reg **reg_list;
 418                 int reg_list_size;
 419                 int retval;
 420
 421                 if (target_get_gdb_reg_list(head->target, &reg_list,
 422                                 &reg_list_size, REG_CLASS_GENERAL) != ERROR_OK) {
 423                         free(buffer);
 424                         return ERROR_TARGET_FAILURE;
 425                 }
 426
 427                 if (!reg_list[13]->valid)
 428                         reg_list[13]->type->get(reg_list[13]);
 429
 430                 buf = reg_list[13]->value;
 431                 val = get_buffer(target, buf);
 432                 ti_addr = (val & 0xffffe000);
 433                 uint32_t ts_addr = ti_addr + 0xc;
 434                 retval = fill_buffer(target, ts_addr, buffer);
 435
 436                 if (retval == ERROR_OK) {
 437                         uint32_t TS = get_buffer(target, buffer);
 438                         uint32_t cpu, on_cpu = TS + ONCPU;
 439                         retval = fill_buffer(target, on_cpu, buffer);
 440
 441                         if (retval == ERROR_OK) {
 442                                 /*uint32_t cpu = get_buffer(target, buffer);*/
 443                                 struct current_thread *ct =
 444                                         linux_os->current_threads;
 445                                 cpu = head->target->coreid;
 446
 447                                 while ((ct) && (ct->core_id != (int32_t) cpu))
 448                                         ct = ct->next;
 449
 450                                 if ((ct) && (ct->TS == 0xdeadbeef))
 451                                         ct->TS = TS;
 452                                 else
 453                                         LOG_ERROR
 454                                                 ("error in linux current thread update");
 455
 456                                 if (create && ct) {
 457                                         struct threads *t;
 458                                         t = calloc(1, sizeof(struct threads));
 459                                         t->base_addr = ct->TS;
 460                                         fill_task(target, t);
 461                                         get_name(target, t);
 462                                         t->oncpu = cpu;
 463                                         insert_into_threadlist(target, t);
 464                                         t->status = 3;
 465                                         t->thread_info_addr = 0xdeadbeef;
 466                                         ct->threadid = t->threadid;
 467                                         linux_os->thread_count++;
 468 #ifdef PID_CHECK
 469                                         ct->pid = t->pid;
 470 #endif
 471                                         /*LOG_INFO("Creation of current thread %s",t->name);*/
 472                                 }
 473                         }
 474                 }
 475
 476                 free(reg_list);
 477                 head = head->next;
 478         }
 479
 480         free(buffer);
 481
 482         return ERROR_OK;
 483 }
 484
 485 static struct cpu_context *cpu_context_read(struct target *target, uint32_t base_addr,
 486         uint32_t *thread_info_addr_old)
 487 {
 488         struct cpu_context *context = calloc(1, sizeof(struct cpu_context));
 489         uint32_t preempt_count_addr = 0;
 490         uint32_t registers[10];
 491         uint8_t *buffer = calloc(1, 4);
 492         uint32_t stack = base_addr + QAT;
 493         uint32_t thread_info_addr = 0;
 494         uint32_t thread_info_addr_update = 0;
 495         int retval = ERROR_FAIL;
 496         context->R4 = 0xdeadbeef;
 497         context->R5 = 0xdeadbeef;
 498         context->R6 = 0xdeadbeef;
 499         context->R7 = 0xdeadbeef;
 500         context->R8 = 0xdeadbeef;
 501         context->R9 = 0xdeadbeef;
 502         context->IP = 0xdeadbeef;
 503         context->FP = 0xdeadbeef;
 504         context->SP = 0xdeadbeef;
 505         context->PC = 0xdeadbeef;
 506 retry:
 507
 508         if (*thread_info_addr_old == 0xdeadbeef) {
 509                 retval = fill_buffer(target, stack, buffer);
 510
 511                 if (retval == ERROR_OK)
 512                         thread_info_addr = get_buffer(target, buffer);
 513                 else
 514                         LOG_ERROR("cpu_context: unable to read memory");
 515
 516                 thread_info_addr_update = thread_info_addr;
 517         } else
 518                 thread_info_addr = *thread_info_addr_old;
 519
 520         preempt_count_addr = thread_info_addr + PREEMPT;
 521         retval = fill_buffer(target, preempt_count_addr, buffer);
 522
 523         if (retval == ERROR_OK)
 524                 context->preempt_count = get_buffer(target, buffer);
 525         else {
 526                 if (*thread_info_addr_old != 0xdeadbeef) {
 527                         LOG_ERROR
 528                                 ("cpu_context: cannot read at thread_info_addr");
 529
 530                         if (*thread_info_addr_old < LINUX_USER_KERNEL_BORDER)
 531                                 LOG_INFO
 532                                         ("cpu_context : thread_info_addr in userspace!!!");
 533
 534                         *thread_info_addr_old = 0xdeadbeef;
 535                         goto retry;
 536                 }
 537
 538                 LOG_ERROR("cpu_context: unable to read memory");
 539         }
 540
 541         thread_info_addr += CPU_CONT;
 542
 543         retval = linux_read_memory(target, thread_info_addr, 4, 10,
 544                         (uint8_t *) registers);
 545
 546         if (retval != ERROR_OK) {
 547                 free(buffer);
 548                 LOG_ERROR("cpu_context: unable to read memory\n");
 549                 return context;
 550         }
 551
 552         context->R4 =
 553                 target_buffer_get_u32(target, (const uint8_t *)&registers[0]);
 554         context->R5 =
 555                 target_buffer_get_u32(target, (const uint8_t *)&registers[1]);
 556         context->R6 =
 557                 target_buffer_get_u32(target, (const uint8_t *)&registers[2]);
 558         context->R7 =
 559                 target_buffer_get_u32(target, (const uint8_t *)&registers[3]);
 560         context->R8 =
 561                 target_buffer_get_u32(target, (const uint8_t *)&registers[4]);
 562         context->R9 =
 563                 target_buffer_get_u32(target, (const uint8_t *)&registers[5]);
 564         context->IP =
 565                 target_buffer_get_u32(target, (const uint8_t *)&registers[6]);
 566         context->FP =
 567                 target_buffer_get_u32(target, (const uint8_t *)&registers[7]);
 568         context->SP =
 569                 target_buffer_get_u32(target, (const uint8_t *)&registers[8]);
 570         context->PC =
 571                 target_buffer_get_u32(target, (const uint8_t *)&registers[9]);
 572
 573         if (*thread_info_addr_old == 0xdeadbeef)
 574                 *thread_info_addr_old = thread_info_addr_update;
 575
 576         free(buffer);
 577
 578         return context;
 579 }
 580
 581 static uint32_t next_task(struct target *target, struct threads *t)
 582 {
 583         uint8_t *buffer = calloc(1, 4);
 584         uint32_t next_addr = t->base_addr + NEXT;
 585         int retval = fill_buffer(target, next_addr, buffer);
 586
 587         if (retval == ERROR_OK) {
 588                 uint32_t val = get_buffer(target, buffer);
 589                 val = val - NEXT;
 590                 free(buffer);
 591                 return val;
 592         } else
 593                 LOG_ERROR("next task: unable to read memory");
 594
 595         free(buffer);
 596
 597         return 0;
 598 }
 599
 600 static struct current_thread *add_current_thread(struct current_thread *currents,
 601         struct current_thread *ct)
 602 {
 603         ct->next = NULL;
 604
 605         if (!currents) {
 606                 currents = ct;
 607                 return currents;
 608         } else {
 609                 struct current_thread *temp = currents;
 610
 611                 while (temp->next)
 612                         temp = temp->next;
 613
 614                 temp->next = ct;
 615                 return currents;
 616         }
 617 }
 618
 619 static struct threads *liste_del_task(struct threads *task_list, struct threads **t,
 620         struct threads *prev)
 621 {
 622         LOG_INFO("del task %" PRId64, (*t)->threadid);
 623         if (prev)
 624                 prev->next = (*t)->next;
 625         else
 626                 task_list = (*t)->next;
 627
 628         /*  free content of threads */
 629         free((*t)->context);
 630
 631         free(*t);
 632         *t = prev ? prev : task_list;
 633         return task_list;
 634 }
 635
 636 static struct threads *liste_add_task(struct threads *task_list, struct threads *t,
 637         struct threads **last)
 638 {
 639         t->next = NULL;
 640
 641         if (!*last)
 642                 if (!task_list) {
 643                         task_list = t;
 644                         return task_list;
 645                 } else {
 646                         struct threads *temp = task_list;
 647
 648                         while (temp->next)
 649                                 temp = temp->next;
 650
 651                         temp->next = t;
 652                         *last = t;
 653                         return task_list;
 654                 } else {
 655                 (*last)->next = t;
 656                 *last = t;
 657                 return task_list;
 658         }
 659 }
 660
 661 #ifdef PID_CHECK
 662 static int current_pid(struct linux_os *linux_os, uint32_t pid)
 663 #else
 664 static int current_base_addr(struct linux_os *linux_os, uint32_t base_addr)
 665 #endif
 666 {
 667         struct current_thread *ct = linux_os->current_threads;
 668 #ifdef PID_CHECK
 669
 670         while ((ct) && (ct->pid != pid))
 671 #else
 672         while ((ct) && (ct->TS != base_addr))
 673 #endif
 674                 ct = ct->next;
 675 #ifdef PID_CHECK
 676         if ((ct) && (ct->pid == pid))
 677 #else
 678         if ((ct) && (ct->TS == base_addr))
 679 #endif
 680                 return 1;
 681
 682         return 0;
 683 }
 684
 685 static int linux_get_tasks(struct target *target, int context)
 686 {
 687         int loop = 0;
 688         int retval = 0;
 689         struct linux_os *linux_os = (struct linux_os *)
 690                 target->rtos->rtos_specific_params;
 691         linux_os->thread_list = NULL;
 692         linux_os->thread_count = 0;
 693
 694         if (linux_os->init_task_addr == 0xdeadbeef) {
 695                 LOG_INFO("no init symbol\n");
 696                 return ERROR_FAIL;
 697         }
 698
 699         int64_t start = timeval_ms();
 700
 701         struct threads *t = calloc(1, sizeof(struct threads));
 702         struct threads *last = NULL;
 703         t->base_addr = linux_os->init_task_addr;
 704         /* retrieve the thread id , currently running in the different smp core */
 705         get_current(target, 1);
 706
 707         while (((t->base_addr != linux_os->init_task_addr) &&
 708                 (t->base_addr != 0)) || (loop == 0)) {
 709                 loop++;
 710                 fill_task(target, t);
 711                 retval = get_name(target, t);
 712
 713                 if (loop > MAX_THREADS) {
 714                         free(t);
 715                         LOG_INFO("more than %d threads !!", MAX_THREADS);
 716                         return ERROR_FAIL;
 717                 }
 718
 719                 if (retval != ERROR_OK) {
 720                         free(t);
 721                         return ERROR_FAIL;
 722                 }
 723
 724                 /*  check that this thread is not one the current threads already
 725                  *  created */
 726                 uint32_t base_addr;
 727 #ifdef PID_CHECK
 728
 729                 if (!current_pid(linux_os, t->pid)) {
 730 #else
 731                 if (!current_base_addr(linux_os, t->base_addr)) {
 732 #endif
 733                         t->threadid = linux_os->threadid_count;
 734                         t->status = 1;
 735                         linux_os->threadid_count++;
 736
 737                         linux_os->thread_list =
 738                                 liste_add_task(linux_os->thread_list, t, &last);
 739                         /* no interest to fill the context if it is a current thread. */
 740                         linux_os->thread_count++;
 741                         t->thread_info_addr = 0xdeadbeef;
 742
 743                         if (context)
 744                                 t->context =
 745                                         cpu_context_read(target, t->base_addr,
 746                                                 &t->thread_info_addr);
 747                         base_addr = next_task(target, t);
 748                 } else {
 749                         /*LOG_INFO("thread %s is a current thread already created",t->name); */
 750                         base_addr = next_task(target, t);
 751                         free(t);
 752                 }
 753
 754                 t = calloc(1, sizeof(struct threads));
 755                 t->base_addr = base_addr;
 756         }
 757
 758         linux_os->threads_lookup = 1;
 759         linux_os->threads_needs_update = 0;
 760         linux_os->preupdtate_threadid_count = linux_os->threadid_count - 1;
 761         /*  check that all current threads have been identified  */
 762
 763         LOG_INFO("complete time %" PRId64 ", thread mean %" PRId64 "\n",
 764                 (timeval_ms() - start),
 765                 (timeval_ms() - start) / linux_os->threadid_count);
 766
 767         LOG_INFO("threadid count %d", linux_os->threadid_count);
 768         free(t);
 769
 770         return ERROR_OK;
 771 }
 772
 773 static int clean_threadlist(struct target *target)
 774 {
 775         struct linux_os *linux_os = (struct linux_os *)
 776                 target->rtos->rtos_specific_params;
 777         struct threads *old, *temp = linux_os->thread_list;
 778
 779         while (temp) {
 780                 old = temp;
 781
 782                 free(temp->context);
 783
 784                 temp = temp->next;
 785                 free(old);
 786         }
 787
 788         return ERROR_OK;
 789 }
 790
 791 static int linux_os_clean(struct target *target)
 792 {
 793         struct linux_os *os_linux = (struct linux_os *)
 794                 target->rtos->rtos_specific_params;
 795         clean_threadlist(target);
 796         os_linux->init_task_addr = 0xdeadbeef;
 797         os_linux->name = "linux";
 798         os_linux->thread_list = NULL;
 799         os_linux->thread_count = 0;
 800         os_linux->nr_cpus = 0;
 801         os_linux->threads_lookup = 0;
 802         os_linux->threads_needs_update = 0;
 803         os_linux->threadid_count = 1;
 804         return ERROR_OK;
 805 }
 806
 807 static int insert_into_threadlist(struct target *target, struct threads *t)
 808 {
 809         struct linux_os *linux_os = (struct linux_os *)
 810                 target->rtos->rtos_specific_params;
 811         struct threads *temp = linux_os->thread_list;
 812         t->threadid = linux_os->threadid_count;
 813         linux_os->threadid_count++;
 814         t->status = 1;
 815         t->next = NULL;
 816
 817         if (!temp)
 818                 linux_os->thread_list = t;
 819         else {
 820                 while (temp->next)
 821                         temp = temp->next;
 822
 823                 t->next = NULL;
 824                 temp->next = t;
 825         }
 826
 827         return ERROR_OK;
 828 }
 829
 830 static void linux_identify_current_threads(struct target *target)
 831 {
 832         struct linux_os *linux_os = (struct linux_os *)
 833                 target->rtos->rtos_specific_params;
 834         struct threads *thread_list = linux_os->thread_list;
 835         struct current_thread *ct = linux_os->current_threads;
 836         struct threads *t = NULL;
 837
 838         while ((ct)) {
 839                 if (ct->threadid == -1) {
 840
 841                         /*  un-identified thread */
 842                         int found = 0;
 843                         t = calloc(1, sizeof(struct threads));
 844                         t->base_addr = ct->TS;
 845 #ifdef PID_CHECK
 846
 847                         if (fill_task_pid(target, t) != ERROR_OK) {
 848 error_handling:
 849                                 free(t);
 850                                 LOG_ERROR
 851                                         ("linux identify_current_threads: unable to read pid");
 852                                 return;
 853                         }
 854 #endif
 855
 856                         /* search in the list of threads if pid
 857                            already present */
 858                         while ((thread_list) && (found == 0)) {
 859 #ifdef PID_CHECK
 860                                 if (thread_list->pid == t->pid) {
 861 #else
 862                                 if (thread_list->base_addr == t->base_addr) {
 863 #endif
 864                                         free(t);
 865                                         t = thread_list;
 866                                         found = 1;
 867                                 }
 868                                 thread_list = thread_list->next;
 869                         }
 870
 871                         if (!found) {
 872                                 /*  it is a new thread */
 873                                 if (fill_task(target, t) != ERROR_OK)
 874                                         goto error_handling;
 875
 876                                 get_name(target, t);
 877                                 insert_into_threadlist(target, t);
 878                                 t->thread_info_addr = 0xdeadbeef;
 879                         }
 880
 881                         t->status = 3;
 882                         ct->threadid = t->threadid;
 883 #ifdef PID_CHECK
 884                         ct->pid = t->pid;
 885 #endif
 886                         linux_os->thread_count++;
 887 #if 0
 888                         if (found == 0)
 889                                 LOG_INFO("current thread core %x identified %s",
 890                                         ct->core_id, t->name);
 891                         else
 892                                 LOG_INFO("current thread core %x, reused %s",
 893                                         ct->core_id, t->name);
 894 #endif
 895                 }
 896 #if 0
 897                 else {
 898                         struct threads tmp;
 899                         tmp.base_addr = ct->TS;
 900                         get_name(target, &tmp);
 901                         LOG_INFO("current thread core %x , already identified %s !!!",
 902                                 ct->core_id, tmp.name);
 903                 }
 904 #endif
 905                 ct = ct->next;
 906         }
 907
 908         return;
 909 #ifndef PID_CHECK
 910 error_handling:
 911         free(t);
 912         LOG_ERROR("unable to read pid");
 913         return;
 914
 915 #endif
 916 }
 917
 918 static int linux_task_update(struct target *target, int context)
 919 {
 920         struct linux_os *linux_os = (struct linux_os *)
 921                 target->rtos->rtos_specific_params;
 922         struct threads *thread_list = linux_os->thread_list;
 923         int retval;
 924         int loop = 0;
 925         linux_os->thread_count = 0;
 926
 927         /*thread_list = thread_list->next; skip init_task*/
 928         while (thread_list) {
 929                 thread_list->status = 0;        /*setting all tasks to dead state*/
 930
 931                 free(thread_list->context);
 932                 thread_list->context = NULL;
 933
 934                 thread_list = thread_list->next;
 935         }
 936
 937         int found = 0;
 938
 939         if (linux_os->init_task_addr == 0xdeadbeef) {
 940                 LOG_INFO("no init symbol\n");
 941                 return ERROR_FAIL;
 942         }
 943         int64_t start = timeval_ms();
 944         struct threads *t = calloc(1, sizeof(struct threads));
 945         uint32_t previous = 0xdeadbeef;
 946         t->base_addr = linux_os->init_task_addr;
 947         retval = get_current(target, 0);
 948         /*check that all current threads have been identified  */
 949         linux_identify_current_threads(target);
 950
 951         while (((t->base_addr != linux_os->init_task_addr) &&
 952                 (t->base_addr != previous)) || (loop == 0)) {
 953                 /*  for avoiding any permanent loop for any reason possibly due to
 954                  *  target */
 955                 loop++;
 956                 previous = t->base_addr;
 957                 /*  read only pid */
 958 #ifdef PID_CHECK
 959                 retval = fill_task_pid(target, t);
 960 #endif
 961
 962                 if (retval != ERROR_OK) {
 963                         free(t);
 964                         return ERROR_FAIL;
 965                 }
 966
 967                 thread_list = linux_os->thread_list;
 968
 969                 while (thread_list) {
 970 #ifdef PID_CHECK
 971                         if (t->pid == thread_list->pid) {
 972 #else
 973                         if (t->base_addr == thread_list->base_addr) {
 974 #endif
 975                                 if (!thread_list->status) {
 976 #ifdef PID_CHECK
 977                                         if (t->base_addr != thread_list->base_addr)
 978                                                 LOG_INFO("thread base_addr has changed !!");
 979 #endif
 980                                         /*  this is not a current thread  */
 981                                         thread_list->base_addr = t->base_addr;
 982                                         thread_list->status = 1;
 983
 984                                         /*  we don 't update this field any more */
 985
 986                                         /*thread_list->state = t->state;
 987                                         thread_list->oncpu = t->oncpu;
 988                                         thread_list->asid = t->asid;
 989                                         */
 990                                         if (context)
 991                                                 thread_list->context =
 992                                                         cpu_context_read(target,
 993                                                                 thread_list->base_addr,
 994                                                                 &thread_list->thread_info_addr);
 995                                 } else {
 996                                         /*  it is a current thread no need to read context */
 997                                 }
 998
 999                                 linux_os->thread_count++;
1000                                 found = 1;
1001                                 break;
1002                         } else {
1003                                 found = 0;
1004                                 thread_list = thread_list->next;
1005                         }
1006                 }
1007
1008                 if (found == 0) {
1009                         uint32_t base_addr;
1010                         fill_task(target, t);
1011                         get_name(target, t);
1012                         retval = insert_into_threadlist(target, t);
1013                         t->thread_info_addr = 0xdeadbeef;
1014
1015                         if (context)
1016                                 t->context =
1017                                         cpu_context_read(target, t->base_addr,
1018                                                 &t->thread_info_addr);
1019
1020                         base_addr = next_task(target, t);
1021                         t = calloc(1, sizeof(struct threads));
1022                         t->base_addr = base_addr;
1023                         linux_os->thread_count++;
1024                 } else
1025                         t->base_addr = next_task(target, t);
1026         }
1027
1028         LOG_INFO("update thread done %" PRId64 ", mean%" PRId64 "\n",
1029                 (timeval_ms() - start), (timeval_ms() - start) / loop);
1030         free(t);
1031         linux_os->threads_needs_update = 0;
1032         return ERROR_OK;
1033 }
1034
1035 static int linux_gdb_thread_packet(struct target *target,
1036         struct connection *connection, char const *packet,
1037         int packet_size)
1038 {
1039         int retval;
1040         struct linux_os *linux_os =
1041                 (struct linux_os *)target->rtos->rtos_specific_params;
1042
1043         if (linux_os->init_task_addr == 0xdeadbeef) {
1044                 /* it has not been initialized */
1045                 LOG_INFO("received thread request without init task address");
1046                 gdb_put_packet(connection, "l", 1);
1047                 return ERROR_OK;
1048         }
1049
1050         retval = linux_get_tasks(target, 1);
1051
1052         if (retval != ERROR_OK)
1053                 return ERROR_TARGET_FAILURE;
1054
1055         char *out_str = calloc(MAX_THREADS * 17 + 10, 1);
1056         char *tmp_str = out_str;
1057         tmp_str += sprintf(tmp_str, "m");
1058         struct threads *temp = linux_os->thread_list;
1059
1060         while (temp) {
1061                 tmp_str += sprintf(tmp_str, "%016" PRIx64, temp->threadid);
1062                 temp = temp->next;
1063                 if (temp)
1064                         tmp_str += sprintf(tmp_str, ",");
1065         }
1066
1067         gdb_put_packet(connection, out_str, strlen(out_str));
1068         free(out_str);
1069         return ERROR_OK;
1070 }
1071
1072 static int linux_gdb_thread_update(struct target *target,
1073         struct connection *connection, char const *packet,
1074         int packet_size)
1075 {
1076         int found = 0;
1077         struct linux_os *linux_os = (struct linux_os *)
1078                 target->rtos->rtos_specific_params;
1079         struct threads *temp = linux_os->thread_list;
1080
1081         while (temp) {
1082                 if (temp->threadid == linux_os->preupdtate_threadid_count + 1) {
1083                         /*LOG_INFO("FOUND");*/
1084                         found = 1;
1085                         break;
1086                 } else
1087                         temp = temp->next;
1088         }
1089
1090         if (found == 1) {
1091                 /*LOG_INFO("INTO GDB THREAD UPDATE FOUNDING START TASK");*/
1092                 char *out_strr = calloc(MAX_THREADS * 17 + 10, 1);
1093                 char *tmp_strr = out_strr;
1094                 tmp_strr += sprintf(tmp_strr, "m");
1095                 /*LOG_INFO("CHAR MALLOC & M DONE");*/
1096                 tmp_strr += sprintf(tmp_strr, "%016" PRIx64, temp->threadid);
1097
1098                 temp = temp->next;
1099
1100                 while (temp) {
1101                         /*LOG_INFO("INTO GDB THREAD UPDATE WHILE");*/
1102                         tmp_strr += sprintf(tmp_strr, ",");
1103                         tmp_strr +=
1104                                 sprintf(tmp_strr, "%016" PRIx64, temp->threadid);
1105                         temp = temp->next;
1106                 }
1107
1108                 /*tmp_str[0] = 0;*/
1109                 gdb_put_packet(connection, out_strr, strlen(out_strr));
1110                 linux_os->preupdtate_threadid_count =
1111                         linux_os->threadid_count - 1;
1112                 free(out_strr);
1113         } else
1114                 gdb_put_packet(connection, "l", 1);
1115
1116         return ERROR_OK;
1117 }
1118
1119 static int linux_thread_extra_info(struct target *target,
1120         struct connection *connection, char const *packet,
1121         int packet_size)
1122 {
1123         int64_t threadid = 0;
1124         struct linux_os *linux_os = (struct linux_os *)
1125                 target->rtos->rtos_specific_params;
1126         sscanf(packet, "qThreadExtraInfo,%" SCNx64, &threadid);
1127         /*LOG_INFO("lookup extra info for thread %" SCNx64, threadid);*/
1128         struct threads *temp = linux_os->thread_list;
1129
1130         while (temp) {
1131                 if (temp->threadid == threadid) {
1132                         char *pid = " PID: ";
1133                         char *pid_current = "*PID: ";
1134                         char *name = "Name: ";
1135                         int str_size = strlen(pid) + strlen(name);
1136                         char *tmp_str = calloc(1, str_size + 50);
1137                         char *tmp_str_ptr = tmp_str;
1138
1139                         /*  discriminate current task */
1140                         if (temp->status == 3)
1141                                 tmp_str_ptr += sprintf(tmp_str_ptr, "%s",
1142                                                 pid_current);
1143                         else
1144                                 tmp_str_ptr += sprintf(tmp_str_ptr, "%s", pid);
1145
1146                         tmp_str_ptr += sprintf(tmp_str_ptr, "%d, ", (int)temp->pid);
1147                         sprintf(tmp_str_ptr, "%s", name);
1148                         sprintf(tmp_str_ptr, "%s", temp->name);
1149                         char *hex_str = calloc(1, strlen(tmp_str) * 2 + 1);
1150                         size_t pkt_len = hexify(hex_str, (const uint8_t *)tmp_str,
1151                                 strlen(tmp_str), strlen(tmp_str) * 2 + 1);
1152                         gdb_put_packet(connection, hex_str, pkt_len);
1153                         free(hex_str);
1154                         free(tmp_str);
1155                         return ERROR_OK;
1156                 }
1157
1158                 temp = temp->next;
1159         }
1160
1161         LOG_INFO("thread not found");
1162         return ERROR_OK;
1163 }
1164
1165 static int linux_gdb_t_packet(struct connection *connection,
1166         struct target *target, char const *packet, int packet_size)
1167 {
1168         int64_t threadid;
1169         struct linux_os *linux_os = (struct linux_os *)
1170                 target->rtos->rtos_specific_params;
1171         int retval = ERROR_OK;
1172         sscanf(packet, "T%" SCNx64, &threadid);
1173
1174         if (linux_os->threads_needs_update == 0) {
1175                 struct threads *temp = linux_os->thread_list;
1176                 struct threads *prev = NULL;
1177
1178                 while (temp) {
1179                         if (temp->threadid == threadid) {
1180                                 if (temp->status != 0) {
1181                                         gdb_put_packet(connection, "OK", 2);
1182                                         return ERROR_OK;
1183                                 } else {
1184                                         /* delete item in the list   */
1185                                         linux_os->thread_list =
1186                                                 liste_del_task(linux_os->thread_list,
1187                                                         &temp, prev);
1188                                         linux_os->thread_count--;
1189                                         gdb_put_packet(connection, "E01", 3);
1190                                         return ERROR_OK;
1191                                 }
1192                         }
1193
1194                         /*  for deletion  */
1195                         prev = temp;
1196                         temp = temp->next;
1197                 }
1198
1199                 LOG_INFO("gdb requested status on non existing thread");
1200                 gdb_put_packet(connection, "E01", 3);
1201                 return ERROR_OK;
1202
1203         } else {
1204                 retval = linux_task_update(target, 1);
1205                 struct threads *temp = linux_os->thread_list;
1206
1207                 while (temp) {
1208                         if (temp->threadid == threadid) {
1209                                 if (temp->status == 1) {
1210                                         gdb_put_packet(connection, "OK", 2);
1211                                         return ERROR_OK;
1212                                 } else {
1213                                         gdb_put_packet(connection, "E01", 3);
1214                                         return ERROR_OK;
1215                                 }
1216                         }
1217
1218                         temp = temp->next;
1219                 }
1220         }
1221
1222         return retval;
1223 }
1224
1225 static int linux_gdb_h_packet(struct connection *connection,
1226         struct target *target, char const *packet, int packet_size)
1227 {
1228         struct linux_os *linux_os = (struct linux_os *)
1229                 target->rtos->rtos_specific_params;
1230         struct current_thread *ct = linux_os->current_threads;
1231
1232         /* select to display the current thread of the selected target */
1233         while ((ct) && (ct->core_id != target->coreid))
1234                 ct = ct->next;
1235
1236         int64_t current_gdb_thread_rq;
1237
1238         if (linux_os->threads_lookup == 1) {
1239                 if ((ct) && (ct->threadid == -1)) {
1240                         ct = linux_os->current_threads;
1241
1242                         while ((ct) && (ct->threadid == -1))
1243                                 ct = ct->next;
1244                 }
1245
1246                 if (!ct) {
1247                         /*  no current thread can be identified
1248                          *  any way with smp  */
1249                         LOG_INFO("no current thread identified");
1250                         /* attempt to display the name of the 2 threads identified with
1251                          * get_current */
1252                         struct threads t;
1253                         ct = linux_os->current_threads;
1254
1255                         while ((ct) && (ct->threadid == -1)) {
1256                                 t.base_addr = ct->TS;
1257                                 get_name(target, &t);
1258                                 LOG_INFO("name of unidentified thread %s",
1259                                         t.name);
1260                                 ct = ct->next;
1261                         }
1262
1263                         gdb_put_packet(connection, "OK", 2);
1264                         return ERROR_OK;
1265                 }
1266
1267                 if (packet[1] == 'g') {
1268                         sscanf(packet, "Hg%16" SCNx64, &current_gdb_thread_rq);
1269
1270                         if (current_gdb_thread_rq == 0) {
1271                                 target->rtos->current_threadid = ct->threadid;
1272                                 gdb_put_packet(connection, "OK", 2);
1273                         } else {
1274                                 target->rtos->current_threadid =
1275                                         current_gdb_thread_rq;
1276                                 gdb_put_packet(connection, "OK", 2);
1277                         }
1278                 } else if (packet[1] == 'c') {
1279                         sscanf(packet, "Hc%16" SCNx64, &current_gdb_thread_rq);
1280
1281                         if ((current_gdb_thread_rq == 0) ||
1282                                         (current_gdb_thread_rq == ct->threadid)) {
1283                                 target->rtos->current_threadid = ct->threadid;
1284                                 gdb_put_packet(connection, "OK", 2);
1285                         } else
1286                                 gdb_put_packet(connection, "E01", 3);
1287                 }
1288         } else
1289                 gdb_put_packet(connection, "OK", 2);
1290
1291         return ERROR_OK;
1292 }
1293
1294 static int linux_thread_packet(struct connection *connection, char const *packet,
1295         int packet_size)
1296 {
1297         int retval = ERROR_OK;
1298         struct current_thread *ct;
1299         struct target *target = get_target_from_connection(connection);
1300         struct linux_os *linux_os = (struct linux_os *)
1301                 target->rtos->rtos_specific_params;
1302
1303         switch (packet[0]) {
1304                 case 'T':               /* Is thread alive?*/
1305
1306                         linux_gdb_t_packet(connection, target, packet, packet_size);
1307                         break;
1308                 case 'H':               /* Set current thread */
1309                         /*  ( 'c' for step and continue, 'g' for all other operations )*/
1310                         /*LOG_INFO(" H packet received '%s'", packet);*/
1311                         linux_gdb_h_packet(connection, target, packet, packet_size);
1312                         break;
1313                 case 'q':
1314
1315                         if (strncmp(packet, "qSymbol", 7) == 0) {
1316                                 if (rtos_qsymbol(connection, packet, packet_size) == 1) {
1317                                         linux_compute_virt2phys(target,
1318                                                         target->rtos->symbols[INIT_TASK].address);
1319                                 }
1320
1321                                 break;
1322                         } else if (strncmp(packet, "qfThreadInfo", 12) == 0) {
1323                                 if (!linux_os->thread_list) {
1324                                         retval = linux_gdb_thread_packet(target,
1325                                                         connection,
1326                                                         packet,
1327                                                         packet_size);
1328                                         break;
1329                                 } else {
1330                                         retval = linux_gdb_thread_update(target,
1331                                                         connection,
1332                                                         packet,
1333                                                         packet_size);
1334                                         break;
1335                                 }
1336                         } else if (strncmp(packet, "qsThreadInfo", 12) == 0) {
1337                                 gdb_put_packet(connection, "l", 1);
1338                                 break;
1339                         } else if (strncmp(packet, "qThreadExtraInfo,", 17) == 0) {
1340                                 linux_thread_extra_info(target, connection, packet,
1341                                                 packet_size);
1342                                 break;
1343                         } else {
1344                                 retval = GDB_THREAD_PACKET_NOT_CONSUMED;
1345                                 break;
1346                         }
1347
1348                 case 'Q':
1349                         /* previously response was : thread not found
1350                          * gdb_put_packet(connection, "E01", 3); */
1351                         retval = GDB_THREAD_PACKET_NOT_CONSUMED;
1352                         break;
1353                 case 'c':
1354                 case 's': {
1355                         if (linux_os->threads_lookup == 1) {
1356                                 ct = linux_os->current_threads;
1357
1358                                 while ((ct) && (ct->core_id) != target->coreid)
1359                                         ct = ct->next;
1360
1361                                 if ((ct) && (ct->threadid == -1)) {
1362                                         ct = linux_os->current_threads;
1363
1364                                         while ((ct) && (ct->threadid == -1))
1365                                                 ct = ct->next;
1366                                 }
1367
1368                                 if ((ct) && (ct->threadid !=
1369                                                  target->rtos->current_threadid)
1370                                 && (target->rtos->current_threadid != -1))
1371                                         LOG_WARNING("WARNING! current GDB thread do not match "
1372                                                         "current thread running. "
1373                                                         "Switch thread in GDB to threadid %d",
1374                                                         (int)ct->threadid);
1375
1376                                 LOG_INFO("threads_needs_update = 1");
1377                                 linux_os->threads_needs_update = 1;
1378                         }
1379                 }
1380
1381                 /* if a packet handler returned an error, exit input loop */
1382                 if (retval != ERROR_OK)
1383                         return retval;
1384         }
1385
1386         return retval;
1387 }
1388
1389 static int linux_os_smp_init(struct target *target)
1390 {
1391         struct target_list *head;
1392         /* keep only target->rtos */
1393         struct rtos *rtos = target->rtos;
1394         struct linux_os *os_linux =
1395                 (struct linux_os *)rtos->rtos_specific_params;
1396         struct current_thread *ct;
1397         head = target->head;
1398
1399         while (head) {
1400                 if (head->target->rtos != rtos) {
1401                         struct linux_os *smp_os_linux =
1402                                 (struct linux_os *)head->target->rtos->rtos_specific_params;
1403                         /*  remap smp target on rtos  */
1404                         free(head->target->rtos);
1405                         head->target->rtos = rtos;
1406                         /*  reuse allocated ct */
1407                         ct = smp_os_linux->current_threads;
1408                         ct->threadid = -1;
1409                         ct->TS = 0xdeadbeef;
1410                         ct->core_id = head->target->coreid;
1411                         os_linux->current_threads =
1412                                 add_current_thread(os_linux->current_threads, ct);
1413                         os_linux->nr_cpus++;
1414                         free(smp_os_linux);
1415                 }
1416
1417                 head = head->next;
1418         }
1419
1420         return ERROR_OK;
1421 }
1422
1423 static int linux_os_create(struct target *target)
1424 {
1425         struct linux_os *os_linux = calloc(1, sizeof(struct linux_os));
1426         struct current_thread *ct = calloc(1, sizeof(struct current_thread));
1427         LOG_INFO("linux os creation\n");
1428         os_linux->init_task_addr = 0xdeadbeef;
1429         os_linux->name = "linux";
1430         os_linux->thread_list = NULL;
1431         os_linux->thread_count = 0;
1432         target->rtos->current_threadid = -1;
1433         os_linux->nr_cpus = 1;
1434         os_linux->threads_lookup = 0;
1435         os_linux->threads_needs_update = 0;
1436         os_linux->threadid_count = 1;
1437         os_linux->current_threads = NULL;
1438         target->rtos->rtos_specific_params = os_linux;
1439         ct->core_id = target->coreid;
1440         ct->threadid = -1;
1441         ct->TS = 0xdeadbeef;
1442         os_linux->current_threads =
1443                 add_current_thread(os_linux->current_threads, ct);
1444         /*  overload rtos thread default handler */
1445         target->rtos->gdb_thread_packet = linux_thread_packet;
1446         /*  initialize a default virt 2 phys translation */
1447         os_linux->phys_mask = ~0xc0000000;
1448         os_linux->phys_base = 0x0;
1449         return JIM_OK;
1450 }
1451
1452 static char *linux_ps_command(struct target *target)
1453 {
1454         struct linux_os *linux_os = (struct linux_os *)
1455                 target->rtos->rtos_specific_params;
1456         int retval = ERROR_OK;
1457         char *display;
1458
1459         if (linux_os->threads_lookup == 0)
1460                 retval = linux_get_tasks(target, 1);
1461         else {
1462                 if (linux_os->threads_needs_update != 0)
1463                         retval = linux_task_update(target, 0);
1464         }
1465
1466         if (retval == ERROR_OK) {
1467                 struct threads *temp = linux_os->thread_list;
1468                 char *tmp;
1469                 LOG_INFO("allocation for %d threads line",
1470                         linux_os->thread_count);
1471                 display = calloc((linux_os->thread_count + 2) * 80, 1);
1472
1473                 if (!display)
1474                         goto error;
1475
1476                 tmp = display;
1477                 tmp += sprintf(tmp, "PID\t\tCPU\t\tASID\t\tNAME\n");
1478                 tmp += sprintf(tmp, "---\t\t---\t\t----\t\t----\n");
1479
1480                 while (temp) {
1481                         if (temp->status) {
1482                                 if (temp->context)
1483                                         tmp +=
1484                                                 sprintf(tmp,
1485                                                         "%" PRIu32 "\t\t%" PRIu32 "\t\t%" PRIx32 "\t\t%s\n",
1486                                                         temp->pid, temp->oncpu,
1487                                                         temp->asid, temp->name);
1488                                 else
1489                                         tmp +=
1490                                                 sprintf(tmp,
1491                                                         "%" PRIu32 "\t\t%" PRIu32 "\t\t%" PRIx32 "\t\t%s\n",
1492                                                         temp->pid, temp->oncpu,
1493                                                         temp->asid, temp->name);
1494                         }
1495
1496                         temp = temp->next;
1497                 }
1498
1499                 return display;
1500         }
1501
1502 error:
1503         display = calloc(40, 1);
1504         sprintf(display, "linux_ps_command failed\n");
1505         return display;
1506 }