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