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