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