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