1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
|
/***************************************************************************
* Copyright (C) 2011 by Broadcom Corporation *
* Evan Hunter - ehunter@broadcom.com *
* *
* This program is free software; you can redistribute it and/or modify *
* it under the terms of the GNU General Public License as published by *
* the Free Software Foundation; either version 2 of the License, or *
* (at your option) any later version. *
* *
* This program is distributed in the hope that it will be useful, *
* but WITHOUT ANY WARRANTY; without even the implied warranty of *
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
* GNU General Public License for more details. *
* *
* You should have received a copy of the GNU General Public License *
* along with this program. If not, see <http://www.gnu.org/licenses/>. *
***************************************************************************/
#ifndef OPENOCD_RTOS_RTOS_H
#define OPENOCD_RTOS_RTOS_H
#include "server/server.h"
#include "target/target.h"
#include <jim-nvp.h>
typedef int64_t threadid_t;
typedef int64_t symbol_address_t;
struct reg;
/**
* Table should be terminated by an element with NULL in symbol_name
*/
struct symbol_table_elem {
const char *symbol_name;
symbol_address_t address;
bool optional;
};
struct thread_detail {
threadid_t threadid;
bool exists;
char *thread_name_str;
char *extra_info_str;
};
struct rtos {
const struct rtos_type *type;
struct symbol_table_elem *symbols;
struct target *target;
/* add a context variable instead of global variable */
/* The thread currently selected by gdb. */
int64_t current_threadid;
/* The currently selected thread according to the target. */
threadid_t current_thread;
struct thread_detail *thread_details;
int thread_count;
int (*gdb_thread_packet)(struct connection *connection, char const *packet, int packet_size);
int (*gdb_v_packet)(struct connection *connection, char const *packet, int packet_size);
int (*gdb_target_for_threadid)(struct connection *connection, threadid_t thread_id, struct target **p_target);
void *rtos_specific_params;
/* Populated in rtos.c, so that individual RTOSes can register commands. */
struct command_context *cmd_ctx;
};
struct rtos_reg {
uint32_t number;
uint32_t size;
uint8_t value[16];
/* WARNING: rtos_get_gdb_reg() relies on the fact that value is the last
* element of this struct. Any new fields should be added *before* value. */
};
struct rtos_type {
const char *name;
bool (*detect_rtos)(struct target *target);
int (*create)(struct target *target);
int (*smp_init)(struct target *target);
int (*update_threads)(struct rtos *rtos);
/** Return a list of general registers, with their values filled out. */
int (*get_thread_reg_list)(struct rtos *rtos, threadid_t thread_id,
struct rtos_reg **reg_list, int *num_regs);
/** Return the size and value of the specified reg_num. The value is
* allocated by the callee and freed by the caller. */
int (*get_thread_reg_value)(struct rtos *rtos, threadid_t thread_id,
uint32_t reg_num, uint32_t *size, uint8_t **value);
int (*get_symbol_list_to_lookup)(struct symbol_table_elem *symbol_list[]);
int (*clean)(struct target *target);
char * (*ps_command)(struct target *target);
int (*set_reg)(struct rtos *rtos, uint32_t reg_num, uint8_t *reg_value);
/**
* Possibly work around an annoying gdb behaviour: when the current thread
* is changed in gdb, it assumes that the target can follow and also make
* the thread current. This is an assumption that cannot hold for a real
* target running a multi-threading OS. If an RTOS can do this, override
* needs_fake_step(). */
bool (*needs_fake_step)(struct target *target, threadid_t thread_id);
/* Implement these if different threads in the RTOS can see memory
* differently (for instance because address translation might be different
* for each thread). */
int (*read_buffer)(struct rtos *rtos, target_addr_t address, uint32_t size,
uint8_t *buffer);
int (*write_buffer)(struct rtos *rtos, target_addr_t address, uint32_t size,
const uint8_t *buffer);
};
struct stack_register_offset {
unsigned short number; /* register number */
signed short offset; /* offset in bytes from stack head, or -1 to indicate
* register is not stacked, or -2 to indicate this is the
* stack pointer register */
unsigned short width_bits;
};
struct rtos_register_stacking {
unsigned stack_registers_size;
int stack_growth_direction;
/* The number of gdb general registers, in order. */
unsigned char num_output_registers;
/* Some targets require evaluating the stack to determine the
* actual stack pointer for a process. If this field is NULL,
* just use stacking->stack_registers_size * stack_growth_direction
* to calculate adjustment.
*/
target_addr_t (*calculate_process_stack)(struct target *target,
const uint8_t *stack_data,
const struct rtos_register_stacking *stacking,
target_addr_t stack_ptr);
const struct stack_register_offset *register_offsets;
/* Total number of registers on the stack, including the general ones. This
* may be 0 if there are no additional registers on the stack beyond the
* general ones. */
unsigned total_register_count;
};
#define GDB_THREAD_PACKET_NOT_CONSUMED (-40)
int rtos_create(struct jim_getopt_info *goi, struct target *target);
void rtos_destroy(struct target *target);
int rtos_set_reg(struct connection *connection, int reg_num,
uint8_t *reg_value);
int rtos_generic_stack_read(struct target *target,
const struct rtos_register_stacking *stacking,
target_addr_t stack_ptr,
struct rtos_reg **reg_list,
int *num_regs);
int rtos_generic_stack_read_reg(struct target *target,
const struct rtos_register_stacking *stacking,
target_addr_t stack_ptr,
uint32_t reg_num, struct rtos_reg *reg);
int rtos_generic_stack_write_reg(struct target *target,
const struct rtos_register_stacking *stacking,
target_addr_t stack_ptr,
uint32_t reg_num, uint8_t *reg_value);
int gdb_thread_packet(struct connection *connection, char const *packet, int packet_size);
int rtos_get_gdb_reg(struct connection *connection, int reg_num);
int rtos_get_gdb_reg_list(struct connection *connection);
int rtos_update_threads(struct target *target);
void rtos_free_threadlist(struct rtos *rtos);
int rtos_smp_init(struct target *target);
/* function for handling symbol access */
int rtos_qsymbol(struct connection *connection, char const *packet, int packet_size);
bool rtos_needs_fake_step(struct target *target, threadid_t thread_id);
int rtos_read_buffer(struct target *target, target_addr_t address,
uint32_t size, uint8_t *buffer);
int rtos_write_buffer(struct target *target, target_addr_t address,
uint32_t size, const uint8_t *buffer);
#endif /* OPENOCD_RTOS_RTOS_H */
|
