From 4721cf1ecb949b37c98b6fce79163541711de2e5 Mon Sep 17 00:00:00 2001 From: Joel Sherrill Date: Thu, 3 Dec 1998 23:54:14 +0000 Subject: Patch from Emmanuel Raguet to add remote debug server and RPC support to RTEMS. Thanks. :) Email follows: Hello, For Xmas, here is the Remote Debugger on RTEMS ! Here are 2 patches for the Remote Debugger on RTEMS for pc386 from Linux host : - one for RTEMS it self, - one for GDB-4.17. 1/ RTEMS patch -------------- This patch adds 2 libraries : - a simplified SUN RPC library - the Remote Debugger library The configuration command is the following : ../rtems4/configure --target=i386-rtemself --enable-rtemsbsp=pc386 --enable-rdbg The SUN RPC library is built only if networking is set. The RDBG library is built if networking and enable-rdbg are set. The function used to initialize the debugger is : rtems_rdbg_initialize (); A special function has been created to force a task to be in a "debug" state : enterRdbg(). The use of this function is not mandatory. 2/ GDB-4.17 patch ----------------- This patch create a new RTEMS target for GDB-4.17. The configuration command is the following : ./configure --enable-shared --target=i386RTEMS To connect to a target, use : target rtems [your_site_address] Then, attach the target using : attach 1 And... Debug ;) You can obtain the original GDB-4.17 on ftp://ftp.debian.org/debian/dists/stable/main/source/devel/gdb_4.17.orig.tar.gz This has been tested from a Debian 2.0.1 linux host. --- c/src/lib/include/rdbg/servrpc.h | 268 +++++++++++++++++++++++++++++++++++++++ 1 file changed, 268 insertions(+) create mode 100644 c/src/lib/include/rdbg/servrpc.h (limited to 'c/src/lib/include/rdbg/servrpc.h') diff --git a/c/src/lib/include/rdbg/servrpc.h b/c/src/lib/include/rdbg/servrpc.h new file mode 100644 index 0000000000..71198d4d1f --- /dev/null +++ b/c/src/lib/include/rdbg/servrpc.h @@ -0,0 +1,268 @@ + +#ifndef SERVRPC_H +#define SERVRPC_H + + +#include +#include + +#include +#include +#include +#include + +#include +#include +#include +#include + +extern int CONN_LIST_INC; +extern int PID_LIST_INC; +extern int TSP_RETRIES; +extern int BackPort; +extern char ActName[]; +extern int getId(); + + +#ifdef DDEBUG +int rdb_debug; /* True if env var RDB_DEBUG defined */ +extern const char* PtraceNames[]; /* list of ptrace requests for debug out */ +extern const char* BmsgNames[]; /* list of BMSG_xxx names */ +extern const char* PtraceName(int req); + +# define DPRINTF(a) (rdb_debug ? printk ("%d >>> ", getId()), printk a : 0) +#else +# define DPRINTF(a) /* suppress */ +#endif + + /* Macros for analyzing/creating process status values. Presently do + not need to be separated per target. Could even use WIF... */ + +#define STS_SIGNALLED(status) (((status) & 0xFF) == 0x7F) +#define STS_TERMONSIG(status) (((status) & 0xFF) && !STS_SIGNALLED(status)) +#define STS_TERMGETSIG(status) ((status) & 0x7F) +#define STS_MAKESIG(sig) (((sig) << 8) | 0x7f) +#define STS_GETSIG(status) ((status) >> 8) +#define STS_GETCODE(status) ((status) >> 8) + + +/* now define base types */ +#ifndef UCHAR_DEFINED +#define UCHAR_DEFINED /* to handle duplicate typedes */ +typedef unsigned char UCHAR; +typedef unsigned char UINT8; +typedef char INT8; +typedef unsigned short UINT16; +typedef short INT16; +typedef unsigned long UINT32; +typedef long INT32; +#endif /* UCHAR_DEFINED */ + +typedef long PID; /* generalized process id */ + +#ifndef True +# define True 1 +# define False 0 +typedef char Boolean; +#endif + +#define MAX_FILENAME 1024 /* largest filename with path */ +#define MAX_SEND 5 /* up to 5 pended outbound messages */ + +#define SERVER_VERS 1 + +typedef enum +{ /* message types */ + BMSG_WARM=1, /* warm test for network connection */ + BMSG_WAIT, /* wait change (stopped/started) */ + BMSG_BREAK, /* breakpoint changed */ + BMSG_EXEC_FAIL, /* exec failed from spawn */ + BMSG_DETACH, /* process detached from server */ + BMSG_KILLED, /* killed by server */ + BMSG_NOT_PRIM, /* no longer the primary owner */ + BMSG_NEW_PID /* the process was restart with new pid (in + context). Same ownership rules. */ +} BACK_MSG; + +typedef struct +{ /* this is the break_list[0] entry of pid */ + UCHAR clr_step; /* true if step off break in last_break */ + UCHAR pad1; /* Set if STEPEMUL breakpoints exist */ + UINT16 last_break; /* last breakpoint we stopped on (if break) */ + UINT32 range_start; /* start address of range */ + UINT32 range_end; /* end address inclusive */ +} BASE_BREAK; + +enum +{ /* last start values */ + LAST_NONE, /* stopped already */ + LAST_STEP, /* did a step last - do not send to prim */ + LAST_CONT, /* did a continue last */ + LAST_RANGE, /* in the middle of step-in-range */ + LAST_STEPOFF, /* stepped off break, now need to cont */ + LAST_KILLED, /* was killed by ptrace */ + LAST_DETACHED /* was detached by ptrace */ +}; +#define LAST_START 0x80 /* first execed. This is to handle MiX + bug where we need to start again */ + +typedef struct +{ /* one per open process */ + PID pid; /* process id (or 0 if free) */ + int state; /* status from last wait if stopped */ + UCHAR running; /* True if running, else stopped/term */ + /* now connection control over process */ + UCHAR owners; /* count of owners for notify and term release */ + UCHAR primary_conn; /* primary owner connection or 255=none */ + + UCHAR filler; /* Preserve alignment */ + + /* now break control and support */ + UINT8 last_start; /* LAST_xx start info for wait() */ + UINT8 flags; /* PIDFLG_xxx flags */ + UINT16 break_alloc; /* number of entries in break_list */ + xdr_break *break_list; /* list of breakpoints ([0] is BASE_BREAK) */ + /* now registers and other save information */ + xdr_regs regs; /* saved registers when stopped */ + int is_step; /* Was break or step (regs ambiguous often) */ + int stop_wanted; /* Don't ignore next stop */ + UINT32 thread; /* current stopped thread or -1 if none */ + char *name; /* full pathname or NULL if not known */ + INT32 child; /* child pid that manages the pid */ + UINT32 textStart; /* for relocating breakpoints at restart */ +} PID_LIST; +PID_LIST *pid_list; /* array of processes being managed */ +int pid_list_cnt; /* number of entries allocated */ +UINT16 last_break; /* unique handle generator for breaks */ +#define NO_PRIMARY ((UCHAR)-1) + +typedef union +{ /* an opaque net address */ + unsigned long l[4]; + unsigned char c[16]; /* corresponds to IP, enough for ChIPC */ +} NET_OPAQUE; + +typedef struct +{ /* one per connection */ + UCHAR in_use; /* True if in use */ + UCHAR debug_type; /* type of connection */ + UINT16 flags; /* flags for connection (CFLG_xxx) */ + NET_OPAQUE sender; /* opaque address for transport compare */ + NET_OPAQUE back_port; /* opaque address for transport event msgs */ + NET_OPAQUE route; /* optional route address */ + UINT32 pid_map[10]; /* map of pids owned relative to pid list */ + /* this allows up to 320 pids to be managed */ + UCHAR last_msg_num; /* msg number used last to handle multi-send */ + /* next field associated with UDP send messages */ + UCHAR retry; /* count of retries. If 0, ok. If not 0, we + are in active wait for reply to an event */ + UCHAR send_idx; /* current number of send's pended */ + struct SEND_LIST + { /* holds pending msgs */ + UCHAR send_type; /* BMSG_xxx type of message */ + UCHAR retry; /* number of times to retry */ + UINT16 spec; /* spec field */ + PID pid; /* pid if applies */ + UINT32 context; /* additional context if needed */ + } send_list[MAX_SEND]; /* pended list of messages being sent */ + char user_name[NAMEMAX]; /* name of user connecting in */ + /* next fields are managed at runtime to handle lists, command upload, and + command download. */ + enum {LST_NONE, LST_SPAWN, LST_INFO, LST_CMD_DOWN} list_type; + char *list; /* curr list we are sending/getting (malloced) */ + UINT16 list_sz; /* size of current list (string len) */ + UINT16 list_num; /* number of current list or position */ + UINT16 list_alloc; /* amount allocated so far */ + UINT16 list_save; /* used internally */ +} CONN_LIST; +CONN_LIST *conn_list; /* an array of connections */ +int conn_list_cnt; /* number allocated */ + + /* Operations over the PID map. Each indexes into long and then bit */ + /* 5 is log2 of 32, the number of bits in an int */ +#define PIDMAP_TEST(conn,idx) \ + (conn_list [conn].pid_map [(idx) >> 5] & (1 << ((idx) & 31))) + +#define PIDMAP_SET(conn,idx) \ + (conn_list [conn].pid_map [(idx) >> 5] |= 1 << ((idx) & 31)) + +#define PIDMAP_CLEAR(conn,idx) \ + (conn_list [conn].pid_map [(idx) >> 5] &= ~(1 << ((idx) &31))) + +#define PROC_TERMINATED(plst) \ + (!(plst)->running && !STS_SIGNALLED ((plst)->state)) + + +/* first define the Connection routines exported from servcon.c */ + +int ConnCreate (struct svc_req *rqstp, open_in *in); +void ConnDelete (int conn_idx, struct svc_req *rqstp, close_control control); + +void TspInit (int rpc_io_channel); +Boolean TspTranslateRpcAddr (struct svc_req *rqstp, NET_OPAQUE *opaque); +Boolean TspValidateAddr (NET_OPAQUE *opaque, NET_OPAQUE *sender); +int TspConnGetIndex (struct svc_req *rqstp); + +void TspSendWaitChange (int conn_idx, BACK_MSG msg, UINT16 spec, PID pid, + UINT32 context, Boolean force); +void TspSendMessage (int conn_idx, Boolean resend); +void TspMessageReceive (int conn_idx, PID pid); +char* TspGetHostName (int conn_idx); +void TgtCreateNew (PID pid, int conn_idx, INT32 child, + char *name, Boolean spawn); +Boolean TgtAttach (int conn_idx, PID pid); +void TgtNotifyWaitChange(PID pid, int status, Boolean exclude); +void TgtNotifyAll (int pid_idx, BACK_MSG msg, UINT16 spec, + UINT32 context, int exclude_conn, Boolean force); +void TgtDelete (PID_LIST*, int conn_idx, BACK_MSG notify); +int TgtKillAndDelete (PID_LIST *plst, struct svc_req *rqstp, Boolean term); +void TgtDetachCon (int conn_idx, int pid_idx, Boolean delete); +int TgtThreadList (PID_LIST*, unsigned* buf, unsigned int size); +int TgtGetThreadName (PID_LIST*, unsigned thLi, char* name); +int TgtPtrace (int req, PID pid, char *addr, int data, void *addr2); +int TgtRealPtrace (int req, PID pid, char *addr, int data, void *addr2); +Boolean TgtHandleChildChange(PID pid, int* status, int* unexp, + CPU_Exception_frame *ctx); +#ifdef DDEBUG + /* TgtDbgPtrace is a wrapper for RealPtrace() doing traces */ +int TgtDbgPtrace (int req, PID pid, char *addr, int data, void *addr2); +#endif + + +/* Information stored in "handle" */ +#define BKPT_INACTIVE 1 /* bkpt inactive for this execution */ +#define BKPT_ACTIVE 0 /* bkpt active for this execution */ + +int BreakOverwrite (const PID_LIST* plst,const char* addr, + unsigned int size); +int BreakSet (PID_LIST*, int conn_idx, xdr_break*); +int BreakSetAt (PID_LIST*, int conn_idx, unsigned long addr,break_type); +int BreakClear (PID_LIST*, int conn_idx, int handle); +int BreakGetIndex (PID_LIST*, void* addr); +int BreakGet (const PID_LIST*, int data, xdr_break*); +void BreakHide (const PID_LIST*, void*, int, void*); +int BreakStepOff (const PID_LIST*, void** paddr2); +void BreakSteppedOff (PID_LIST*); +int BreakRespawn (PID_LIST*); +int BreakIdentify (PID_LIST*, int adjust, int thread); +void BreakPcChanged (PID_LIST*); +int BreakStepRange (PID_LIST*, void* addr, int len); +void BreaksDisable (int pid); +void BreaksEnable (int pid); + +int TgtBreakRestoreOrig (int pid, void* addr, void* addr2); +void TgtBreakCancelStep (PID_LIST* plst); + +Boolean ListAlloc (char *buff, CONN_LIST *clst); +int FindPidEntry (int pid); + +open_out* RPCGENSRVNAME(open_connex_2_svc) (open_in *in, + struct svc_req *rqstp); +signal_out* RPCGENSRVNAME(send_signal_2_svc) (signal_in *in, + struct svc_req *rqstp); +ptrace_out* RPCGENSRVNAME(ptrace_2_svc) (ptrace_in *in, + struct svc_req *rqstp); +wait_out* RPCGENSRVNAME(wait_info_2_svc) (wait_in *in, + struct svc_req *rqstp); +#endif /* !SERVRPC_H */ + -- cgit v1.2.3