2602 lines
65 KiB
C
2602 lines
65 KiB
C
/* GDB stub for Itanium OpenVMS
|
|
Copyright (C) 2012-2020 Free Software Foundation, Inc.
|
|
|
|
Contributed by Tristan Gingold, AdaCore.
|
|
|
|
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 3 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/>. */
|
|
|
|
/* On VMS, the debugger (in our case the stub) is loaded in the process and
|
|
executed (via SYS$IMGSTA) before the main entry point of the executable.
|
|
In UNIX parlance, this is like using LD_PRELOAD and debug via installing
|
|
SIGTRAP, SIGSEGV... handlers.
|
|
|
|
This is currently a partial implementation. In particular, modifying
|
|
registers is currently not implemented, as well as inferior procedure
|
|
calls.
|
|
|
|
This is written in very low-level C, in order not to use the C runtime,
|
|
because it may have weird consequences on the program being debugged.
|
|
*/
|
|
|
|
#if __INITIAL_POINTER_SIZE != 64
|
|
#error "Must be compiled with 64 bit pointers"
|
|
#endif
|
|
|
|
#define __NEW_STARLET 1
|
|
#include <descrip.h>
|
|
#include <iledef.h>
|
|
#include <efndef.h>
|
|
#include <in.h>
|
|
#include <inet.h>
|
|
#include <iodef.h>
|
|
#include <ssdef.h>
|
|
#include <starlet.h>
|
|
#include <stsdef.h>
|
|
#include <tcpip$inetdef.h>
|
|
|
|
#include <lib$routines.h>
|
|
#include <ots$routines.h>
|
|
#include <str$routines.h>
|
|
#include <libdef.h>
|
|
#include <clidef.h>
|
|
#include <iosbdef.h>
|
|
#include <dvidef.h>
|
|
#include <lnmdef.h>
|
|
#include <builtins.h>
|
|
#include <prtdef.h>
|
|
#include <psldef.h>
|
|
#include <chfdef.h>
|
|
|
|
#include <lib_c/imcbdef.h>
|
|
#include <lib_c/ldrimgdef.h>
|
|
#include <lib_c/intstkdef.h>
|
|
#include <lib_c/psrdef.h>
|
|
#include <lib_c/ifddef.h>
|
|
#include <lib_c/eihddef.h>
|
|
|
|
#include <stdarg.h>
|
|
#include <pthread_debug.h>
|
|
|
|
#define VMS_PAGE_SIZE 0x2000
|
|
#define VMS_PAGE_MASK (VMS_PAGE_SIZE - 1)
|
|
|
|
/* Declared in lib$ots. */
|
|
extern void ots$fill (void *addr, size_t len, unsigned char b);
|
|
extern void ots$move (void *dst, size_t len, const void *src);
|
|
extern int ots$strcmp_eql (const void *str1, size_t str1len,
|
|
const void *str2, size_t str2len);
|
|
|
|
/* Stub port number. */
|
|
static unsigned int serv_port = 1234;
|
|
|
|
/* DBGEXT structure. Not declared in any header. */
|
|
struct dbgext_control_block
|
|
{
|
|
unsigned short dbgext$w_function_code;
|
|
#define DBGEXT$K_NEXT_TASK 3
|
|
#define DBGEXT$K_STOP_ALL_OTHER_TASKS 31
|
|
#define DBGEXT$K_GET_REGS 33
|
|
unsigned short dbgext$w_facility_id;
|
|
#define CMA$_FACILITY 64
|
|
unsigned int dbgext$l_status;
|
|
unsigned int dbgext$l_flags;
|
|
unsigned int dbgext$l_print_routine;
|
|
unsigned int dbgext$l_evnt_code;
|
|
unsigned int dbgext$l_evnt_name;
|
|
unsigned int dbgext$l_evnt_entry;
|
|
unsigned int dbgext$l_task_value;
|
|
unsigned int dbgext$l_task_number;
|
|
unsigned int dbgext$l_ada_flags;
|
|
unsigned int dbgext$l_stop_value;
|
|
#define dbgext$l_priority dbgext$l_stop_value;
|
|
#define dbgext$l_symb_addr dbgext$l_stop_value;
|
|
#define dbgext$l_time_slice dbgext$l_stop_value;
|
|
unsigned int dbgext$l_active_registers;
|
|
};
|
|
|
|
#pragma pointer_size save
|
|
#pragma pointer_size 32
|
|
|
|
/* Pthread handler. */
|
|
static int (*dbgext_func) (struct dbgext_control_block *blk);
|
|
|
|
#pragma pointer_size restore
|
|
|
|
/* Set to 1 if thread-aware. */
|
|
static int has_threads;
|
|
|
|
/* Current thread. */
|
|
static pthread_t selected_thread;
|
|
static pthreadDebugId_t selected_id;
|
|
|
|
/* Internal debugging flags. */
|
|
struct debug_flag
|
|
{
|
|
/* Name of the flag (as a string descriptor). */
|
|
const struct dsc$descriptor_s name;
|
|
/* Value. */
|
|
int val;
|
|
};
|
|
|
|
/* Macro to define a debugging flag. */
|
|
#define DEBUG_FLAG_ENTRY(str) \
|
|
{ { sizeof (str) - 1, DSC$K_DTYPE_T, DSC$K_CLASS_S, str }, 0}
|
|
|
|
static struct debug_flag debug_flags[] =
|
|
{
|
|
/* Disp packets exchanged with gdb. */
|
|
DEBUG_FLAG_ENTRY("packets"),
|
|
#define trace_pkt (debug_flags[0].val)
|
|
/* Display entry point informations. */
|
|
DEBUG_FLAG_ENTRY("entry"),
|
|
#define trace_entry (debug_flags[1].val)
|
|
/* Be verbose about exceptions. */
|
|
DEBUG_FLAG_ENTRY("excp"),
|
|
#define trace_excp (debug_flags[2].val)
|
|
/* Be verbose about unwinding. */
|
|
DEBUG_FLAG_ENTRY("unwind"),
|
|
#define trace_unwind (debug_flags[3].val)
|
|
/* Display image at startup. */
|
|
DEBUG_FLAG_ENTRY("images"),
|
|
#define trace_images (debug_flags[4].val)
|
|
/* Display pthread_debug info. */
|
|
DEBUG_FLAG_ENTRY("pthreaddbg")
|
|
#define trace_pthreaddbg (debug_flags[5].val)
|
|
};
|
|
|
|
#define NBR_DEBUG_FLAGS (sizeof (debug_flags) / sizeof (debug_flags[0]))
|
|
|
|
/* Connect inet device I/O channel. */
|
|
static unsigned short conn_channel;
|
|
|
|
/* Widely used hex digit to ascii. */
|
|
static const char hex[] = "0123456789abcdef";
|
|
|
|
/* Socket characteristics. Apparently, there are no declaration for it in
|
|
standard headers. */
|
|
struct sockchar
|
|
{
|
|
unsigned short prot;
|
|
unsigned char type;
|
|
unsigned char af;
|
|
};
|
|
|
|
/* Chain of images loaded. */
|
|
extern IMCB* ctl$gl_imglstptr;
|
|
|
|
/* IA64 integer register representation. */
|
|
union ia64_ireg
|
|
{
|
|
unsigned __int64 v;
|
|
unsigned char b[8];
|
|
};
|
|
|
|
/* IA64 register numbers, as defined by ia64-tdep.h. */
|
|
#define IA64_GR0_REGNUM 0
|
|
#define IA64_GR32_REGNUM (IA64_GR0_REGNUM + 32)
|
|
|
|
/* Floating point registers; 128 82-bit wide registers. */
|
|
#define IA64_FR0_REGNUM 128
|
|
|
|
/* Predicate registers; There are 64 of these one bit registers. It'd
|
|
be more convenient (implementation-wise) to use a single 64 bit
|
|
word with all of these register in them. Note that there's also a
|
|
IA64_PR_REGNUM below which contains all the bits and is used for
|
|
communicating the actual values to the target. */
|
|
#define IA64_PR0_REGNUM 256
|
|
|
|
/* Branch registers: 8 64-bit registers for holding branch targets. */
|
|
#define IA64_BR0_REGNUM 320
|
|
|
|
/* Virtual frame pointer; this matches IA64_FRAME_POINTER_REGNUM in
|
|
gcc/config/ia64/ia64.h. */
|
|
#define IA64_VFP_REGNUM 328
|
|
|
|
/* Virtual return address pointer; this matches
|
|
IA64_RETURN_ADDRESS_POINTER_REGNUM in gcc/config/ia64/ia64.h. */
|
|
#define IA64_VRAP_REGNUM 329
|
|
|
|
/* Predicate registers: There are 64 of these 1-bit registers. We
|
|
define a single register which is used to communicate these values
|
|
to/from the target. We will somehow contrive to make it appear
|
|
that IA64_PR0_REGNUM thru IA64_PR63_REGNUM hold the actual values. */
|
|
#define IA64_PR_REGNUM 330
|
|
|
|
/* Instruction pointer: 64 bits wide. */
|
|
#define IA64_IP_REGNUM 331
|
|
|
|
/* Process Status Register. */
|
|
#define IA64_PSR_REGNUM 332
|
|
|
|
/* Current Frame Marker (raw form may be the cr.ifs). */
|
|
#define IA64_CFM_REGNUM 333
|
|
|
|
/* Application registers; 128 64-bit wide registers possible, but some
|
|
of them are reserved. */
|
|
#define IA64_AR0_REGNUM 334
|
|
#define IA64_KR0_REGNUM (IA64_AR0_REGNUM + 0)
|
|
#define IA64_KR7_REGNUM (IA64_KR0_REGNUM + 7)
|
|
|
|
#define IA64_RSC_REGNUM (IA64_AR0_REGNUM + 16)
|
|
#define IA64_BSP_REGNUM (IA64_AR0_REGNUM + 17)
|
|
#define IA64_BSPSTORE_REGNUM (IA64_AR0_REGNUM + 18)
|
|
#define IA64_RNAT_REGNUM (IA64_AR0_REGNUM + 19)
|
|
#define IA64_FCR_REGNUM (IA64_AR0_REGNUM + 21)
|
|
#define IA64_EFLAG_REGNUM (IA64_AR0_REGNUM + 24)
|
|
#define IA64_CSD_REGNUM (IA64_AR0_REGNUM + 25)
|
|
#define IA64_SSD_REGNUM (IA64_AR0_REGNUM + 26)
|
|
#define IA64_CFLG_REGNUM (IA64_AR0_REGNUM + 27)
|
|
#define IA64_FSR_REGNUM (IA64_AR0_REGNUM + 28)
|
|
#define IA64_FIR_REGNUM (IA64_AR0_REGNUM + 29)
|
|
#define IA64_FDR_REGNUM (IA64_AR0_REGNUM + 30)
|
|
#define IA64_CCV_REGNUM (IA64_AR0_REGNUM + 32)
|
|
#define IA64_UNAT_REGNUM (IA64_AR0_REGNUM + 36)
|
|
#define IA64_FPSR_REGNUM (IA64_AR0_REGNUM + 40)
|
|
#define IA64_ITC_REGNUM (IA64_AR0_REGNUM + 44)
|
|
#define IA64_PFS_REGNUM (IA64_AR0_REGNUM + 64)
|
|
#define IA64_LC_REGNUM (IA64_AR0_REGNUM + 65)
|
|
#define IA64_EC_REGNUM (IA64_AR0_REGNUM + 66)
|
|
|
|
/* NAT (Not A Thing) Bits for the general registers; there are 128 of
|
|
these. */
|
|
#define IA64_NAT0_REGNUM 462
|
|
|
|
/* Process registers when a condition is caught. */
|
|
struct ia64_all_regs
|
|
{
|
|
union ia64_ireg gr[32];
|
|
union ia64_ireg br[8];
|
|
union ia64_ireg ip;
|
|
union ia64_ireg psr;
|
|
union ia64_ireg bsp;
|
|
union ia64_ireg cfm;
|
|
union ia64_ireg pfs;
|
|
union ia64_ireg pr;
|
|
};
|
|
|
|
static struct ia64_all_regs excp_regs;
|
|
static struct ia64_all_regs sel_regs;
|
|
static pthread_t sel_regs_pthread;
|
|
|
|
/* IO channel for the terminal. */
|
|
static unsigned short term_chan;
|
|
|
|
/* Output buffer and length. */
|
|
static char term_buf[128];
|
|
static int term_buf_len;
|
|
|
|
/* Buffer for communication with gdb. */
|
|
static unsigned char gdb_buf[sizeof (struct ia64_all_regs) * 2 + 64];
|
|
static unsigned int gdb_blen;
|
|
|
|
/* Previous primary handler. */
|
|
static void *prevhnd;
|
|
|
|
/* Entry point address and bundle. */
|
|
static unsigned __int64 entry_pc;
|
|
static unsigned char entry_saved[16];
|
|
|
|
/* Write on the terminal. */
|
|
|
|
static void
|
|
term_raw_write (const char *str, unsigned int len)
|
|
{
|
|
unsigned short status;
|
|
struct _iosb iosb;
|
|
|
|
status = sys$qiow (EFN$C_ENF, /* Event flag. */
|
|
term_chan, /* I/O channel. */
|
|
IO$_WRITEVBLK, /* I/O function code. */
|
|
&iosb, /* I/O status block. */
|
|
0, /* Ast service routine. */
|
|
0, /* Ast parameter. */
|
|
(char *)str, /* P1 - buffer address. */
|
|
len, /* P2 - buffer length. */
|
|
0, 0, 0, 0);
|
|
|
|
if (status & STS$M_SUCCESS)
|
|
status = iosb.iosb$w_status;
|
|
if (!(status & STS$M_SUCCESS))
|
|
LIB$SIGNAL (status);
|
|
}
|
|
|
|
/* Flush ther term buffer. */
|
|
|
|
static void
|
|
term_flush (void)
|
|
{
|
|
if (term_buf_len != 0)
|
|
{
|
|
term_raw_write (term_buf, term_buf_len);
|
|
term_buf_len = 0;
|
|
}
|
|
}
|
|
|
|
/* Write a single character, without translation. */
|
|
|
|
static void
|
|
term_raw_putchar (char c)
|
|
{
|
|
if (term_buf_len == sizeof (term_buf))
|
|
term_flush ();
|
|
term_buf[term_buf_len++] = c;
|
|
}
|
|
|
|
/* Write character C. Translate '\n' to '\n\r'. */
|
|
|
|
static void
|
|
term_putc (char c)
|
|
{
|
|
if (c < 32)
|
|
switch (c)
|
|
{
|
|
case '\r':
|
|
case '\n':
|
|
break;
|
|
default:
|
|
c = '.';
|
|
break;
|
|
}
|
|
term_raw_putchar (c);
|
|
if (c == '\n')
|
|
{
|
|
term_raw_putchar ('\r');
|
|
term_flush ();
|
|
}
|
|
}
|
|
|
|
/* Write a C string. */
|
|
|
|
static void
|
|
term_puts (const char *str)
|
|
{
|
|
while (*str)
|
|
term_putc (*str++);
|
|
}
|
|
|
|
/* Write LEN bytes from STR. */
|
|
|
|
static void
|
|
term_write (const char *str, unsigned int len)
|
|
{
|
|
for (; len > 0; len--)
|
|
term_putc (*str++);
|
|
}
|
|
|
|
/* Write using FAO formatting. */
|
|
|
|
static void
|
|
term_fao (const char *str, unsigned int str_len, ...)
|
|
{
|
|
int cnt;
|
|
va_list vargs;
|
|
int i;
|
|
__int64 *args;
|
|
int status;
|
|
struct dsc$descriptor_s dstr =
|
|
{ str_len, DSC$K_DTYPE_T, DSC$K_CLASS_S, (__char_ptr32)str };
|
|
char buf[128];
|
|
$DESCRIPTOR (buf_desc, buf);
|
|
|
|
va_start (vargs, str_len);
|
|
va_count (cnt);
|
|
args = (__int64 *) __ALLOCA (cnt * sizeof (__int64));
|
|
cnt -= 2;
|
|
for (i = 0; i < cnt; i++)
|
|
args[i] = va_arg (vargs, __int64);
|
|
|
|
status = sys$faol_64 (&dstr, &buf_desc.dsc$w_length, &buf_desc, args);
|
|
if (status & 1)
|
|
{
|
|
/* FAO !/ already insert a line feed. */
|
|
for (i = 0; i < buf_desc.dsc$w_length; i++)
|
|
{
|
|
term_raw_putchar (buf[i]);
|
|
if (buf[i] == '\n')
|
|
term_flush ();
|
|
}
|
|
}
|
|
|
|
va_end (vargs);
|
|
}
|
|
|
|
#define TERM_FAO(STR, ...) term_fao (STR, sizeof (STR) - 1, __VA_ARGS__)
|
|
|
|
/* New line. */
|
|
|
|
static void
|
|
term_putnl (void)
|
|
{
|
|
term_putc ('\n');
|
|
}
|
|
|
|
/* Initialize terminal. */
|
|
|
|
static void
|
|
term_init (void)
|
|
{
|
|
unsigned int status,i;
|
|
unsigned short len;
|
|
char resstring[LNM$C_NAMLENGTH];
|
|
static const $DESCRIPTOR (tabdesc, "LNM$FILE_DEV");
|
|
static const $DESCRIPTOR (logdesc, "SYS$OUTPUT");
|
|
$DESCRIPTOR (term_desc, resstring);
|
|
ILE3 item_lst[2];
|
|
|
|
item_lst[0].ile3$w_length = LNM$C_NAMLENGTH;
|
|
item_lst[0].ile3$w_code = LNM$_STRING;
|
|
item_lst[0].ile3$ps_bufaddr = resstring;
|
|
item_lst[0].ile3$ps_retlen_addr = &len;
|
|
item_lst[1].ile3$w_length = 0;
|
|
item_lst[1].ile3$w_code = 0;
|
|
|
|
/* Translate the logical name. */
|
|
status = SYS$TRNLNM (0, /* Attr of the logical name. */
|
|
(void *) &tabdesc, /* Logical name table. */
|
|
(void *) &logdesc, /* Logical name. */
|
|
0, /* Access mode. */
|
|
item_lst); /* Item list. */
|
|
if (!(status & STS$M_SUCCESS))
|
|
LIB$SIGNAL (status);
|
|
|
|
term_desc.dsc$w_length = len;
|
|
|
|
/* Examine 4-byte header. Skip escape sequence. */
|
|
if (resstring[0] == 0x1B)
|
|
{
|
|
term_desc.dsc$w_length -= 4;
|
|
term_desc.dsc$a_pointer += 4;
|
|
}
|
|
|
|
/* Assign a channel. */
|
|
status = sys$assign (&term_desc, /* Device name. */
|
|
&term_chan, /* I/O channel. */
|
|
0, /* Access mode. */
|
|
0);
|
|
if (!(status & STS$M_SUCCESS))
|
|
LIB$SIGNAL (status);
|
|
}
|
|
|
|
/* Convert from native endianness to network endianness (and vice-versa). */
|
|
|
|
static unsigned int
|
|
wordswap (unsigned int v)
|
|
{
|
|
return ((v & 0xff) << 8) | ((v >> 8) & 0xff);
|
|
}
|
|
|
|
/* Initialize the socket connection, and wait for a client. */
|
|
|
|
static void
|
|
sock_init (void)
|
|
{
|
|
struct _iosb iosb;
|
|
unsigned int status;
|
|
|
|
/* Listen channel and characteristics. */
|
|
unsigned short listen_channel;
|
|
struct sockchar listen_sockchar;
|
|
|
|
/* Client address. */
|
|
unsigned short cli_addrlen;
|
|
struct sockaddr_in cli_addr;
|
|
ILE3 cli_itemlst;
|
|
|
|
/* Our address. */
|
|
struct sockaddr_in serv_addr;
|
|
ILE2 serv_itemlst;
|
|
|
|
/* Reuseaddr option value (on). */
|
|
int optval = 1;
|
|
ILE2 sockopt_itemlst;
|
|
ILE2 reuseaddr_itemlst;
|
|
|
|
/* TCP/IP network pseudodevice. */
|
|
static const $DESCRIPTOR (inet_device, "TCPIP$DEVICE:");
|
|
|
|
/* Initialize socket characteristics. */
|
|
listen_sockchar.prot = TCPIP$C_TCP;
|
|
listen_sockchar.type = TCPIP$C_STREAM;
|
|
listen_sockchar.af = TCPIP$C_AF_INET;
|
|
|
|
/* Assign I/O channels to network device. */
|
|
status = sys$assign ((void *) &inet_device, &listen_channel, 0, 0);
|
|
if (status & STS$M_SUCCESS)
|
|
status = sys$assign ((void *) &inet_device, &conn_channel, 0, 0);
|
|
if (!(status & STS$M_SUCCESS))
|
|
{
|
|
term_puts ("Failed to assign I/O channel(s)\n");
|
|
LIB$SIGNAL (status);
|
|
}
|
|
|
|
/* Create a listen socket. */
|
|
status = sys$qiow (EFN$C_ENF, /* Event flag. */
|
|
listen_channel, /* I/O channel. */
|
|
IO$_SETMODE, /* I/O function code. */
|
|
&iosb, /* I/O status block. */
|
|
0, /* Ast service routine. */
|
|
0, /* Ast parameter. */
|
|
&listen_sockchar, /* P1 - socket characteristics. */
|
|
0, 0, 0, 0, 0);
|
|
if (status & STS$M_SUCCESS)
|
|
status = iosb.iosb$w_status;
|
|
if (!(status & STS$M_SUCCESS))
|
|
{
|
|
term_puts ("Failed to create socket\n");
|
|
LIB$SIGNAL (status);
|
|
}
|
|
|
|
/* Set reuse address option. */
|
|
/* Initialize reuseaddr's item-list element. */
|
|
reuseaddr_itemlst.ile2$w_length = sizeof (optval);
|
|
reuseaddr_itemlst.ile2$w_code = TCPIP$C_REUSEADDR;
|
|
reuseaddr_itemlst.ile2$ps_bufaddr = &optval;
|
|
|
|
/* Initialize setsockopt's item-list descriptor. */
|
|
sockopt_itemlst.ile2$w_length = sizeof (reuseaddr_itemlst);
|
|
sockopt_itemlst.ile2$w_code = TCPIP$C_SOCKOPT;
|
|
sockopt_itemlst.ile2$ps_bufaddr = &reuseaddr_itemlst;
|
|
|
|
status = sys$qiow (EFN$C_ENF, /* Event flag. */
|
|
listen_channel, /* I/O channel. */
|
|
IO$_SETMODE, /* I/O function code. */
|
|
&iosb, /* I/O status block. */
|
|
0, /* Ast service routine. */
|
|
0, /* Ast parameter. */
|
|
0, /* P1. */
|
|
0, /* P2. */
|
|
0, /* P3. */
|
|
0, /* P4. */
|
|
(__int64) &sockopt_itemlst, /* P5 - socket options. */
|
|
0);
|
|
if (status & STS$M_SUCCESS)
|
|
status = iosb.iosb$w_status;
|
|
if (!(status & STS$M_SUCCESS))
|
|
{
|
|
term_puts ("Failed to set socket option\n");
|
|
LIB$SIGNAL (status);
|
|
}
|
|
|
|
/* Bind server's ip address and port number to listen socket. */
|
|
/* Initialize server's socket address structure. */
|
|
ots$fill (&serv_addr, sizeof (serv_addr), 0);
|
|
serv_addr.sin_family = TCPIP$C_AF_INET;
|
|
serv_addr.sin_port = wordswap (serv_port);
|
|
serv_addr.sin_addr.s_addr = TCPIP$C_INADDR_ANY;
|
|
|
|
/* Initialize server's item-list descriptor. */
|
|
serv_itemlst.ile2$w_length = sizeof (serv_addr);
|
|
serv_itemlst.ile2$w_code = TCPIP$C_SOCK_NAME;
|
|
serv_itemlst.ile2$ps_bufaddr = &serv_addr;
|
|
|
|
status = sys$qiow (EFN$C_ENF, /* Event flag. */
|
|
listen_channel, /* I/O channel. */
|
|
IO$_SETMODE, /* I/O function code. */
|
|
&iosb, /* I/O status block. */
|
|
0, /* Ast service routine. */
|
|
0, /* Ast parameter. */
|
|
0, /* P1. */
|
|
0, /* P2. */
|
|
(__int64) &serv_itemlst, /* P3 - local socket name. */
|
|
0, 0, 0);
|
|
if (status & STS$M_SUCCESS)
|
|
status = iosb.iosb$w_status;
|
|
if (!(status & STS$M_SUCCESS))
|
|
{
|
|
term_puts ("Failed to bind socket\n");
|
|
LIB$SIGNAL (status);
|
|
}
|
|
|
|
/* Set socket as a listen socket. */
|
|
status = sys$qiow (EFN$C_ENF, /* Event flag. */
|
|
listen_channel, /* I/O channel. */
|
|
IO$_SETMODE, /* I/O function code. */
|
|
&iosb, /* I/O status block. */
|
|
0, /* Ast service routine. */
|
|
0, /* Ast parameter. */
|
|
0, /* P1. */
|
|
0, /* P2. */
|
|
0, /* P3. */
|
|
1, /* P4 - connection backlog. */
|
|
0, 0);
|
|
if (status & STS$M_SUCCESS)
|
|
status = iosb.iosb$w_status;
|
|
if (!(status & STS$M_SUCCESS))
|
|
{
|
|
term_puts ("Failed to set socket passive\n");
|
|
LIB$SIGNAL (status);
|
|
}
|
|
|
|
/* Accept connection from a client. */
|
|
TERM_FAO ("Waiting for a client connection on port: !ZW!/",
|
|
wordswap (serv_addr.sin_port));
|
|
|
|
status = sys$qiow (EFN$C_ENF, /* Event flag. */
|
|
listen_channel, /* I/O channel. */
|
|
IO$_ACCESS|IO$M_ACCEPT, /* I/O function code. */
|
|
&iosb, /* I/O status block. */
|
|
0, /* Ast service routine. */
|
|
0, /* Ast parameter. */
|
|
0, /* P1. */
|
|
0, /* P2. */
|
|
0, /* P3. */
|
|
(__int64) &conn_channel, /* P4 - I/O channel for conn. */
|
|
0, 0);
|
|
|
|
if (status & STS$M_SUCCESS)
|
|
status = iosb.iosb$w_status;
|
|
if (!(status & STS$M_SUCCESS))
|
|
{
|
|
term_puts ("Failed to accept client connection\n");
|
|
LIB$SIGNAL (status);
|
|
}
|
|
|
|
/* Log client connection request. */
|
|
cli_itemlst.ile3$w_length = sizeof (cli_addr);
|
|
cli_itemlst.ile3$w_code = TCPIP$C_SOCK_NAME;
|
|
cli_itemlst.ile3$ps_bufaddr = &cli_addr;
|
|
cli_itemlst.ile3$ps_retlen_addr = &cli_addrlen;
|
|
ots$fill (&cli_addr, sizeof(cli_addr), 0);
|
|
status = sys$qiow (EFN$C_ENF, /* Event flag. */
|
|
conn_channel, /* I/O channel. */
|
|
IO$_SENSEMODE, /* I/O function code. */
|
|
&iosb, /* I/O status block. */
|
|
0, /* Ast service routine. */
|
|
0, /* Ast parameter. */
|
|
0, /* P1. */
|
|
0, /* P2. */
|
|
0, /* P3. */
|
|
(__int64) &cli_itemlst, /* P4 - peer socket name. */
|
|
0, 0);
|
|
if (status & STS$M_SUCCESS)
|
|
status = iosb.iosb$w_status;
|
|
if (!(status & STS$M_SUCCESS))
|
|
{
|
|
term_puts ("Failed to get client name\n");
|
|
LIB$SIGNAL (status);
|
|
}
|
|
|
|
TERM_FAO ("Accepted connection from host: !UB.!UB,!UB.!UB, port: !UW!/",
|
|
(cli_addr.sin_addr.s_addr >> 0) & 0xff,
|
|
(cli_addr.sin_addr.s_addr >> 8) & 0xff,
|
|
(cli_addr.sin_addr.s_addr >> 16) & 0xff,
|
|
(cli_addr.sin_addr.s_addr >> 24) & 0xff,
|
|
wordswap (cli_addr.sin_port));
|
|
}
|
|
|
|
/* Close the socket. */
|
|
|
|
static void
|
|
sock_close (void)
|
|
{
|
|
struct _iosb iosb;
|
|
unsigned int status;
|
|
|
|
/* Close socket. */
|
|
status = sys$qiow (EFN$C_ENF, /* Event flag. */
|
|
conn_channel, /* I/O channel. */
|
|
IO$_DEACCESS, /* I/O function code. */
|
|
&iosb, /* I/O status block. */
|
|
0, /* Ast service routine. */
|
|
0, /* Ast parameter. */
|
|
0, 0, 0, 0, 0, 0);
|
|
|
|
if (status & STS$M_SUCCESS)
|
|
status = iosb.iosb$w_status;
|
|
if (!(status & STS$M_SUCCESS))
|
|
{
|
|
term_puts ("Failed to close socket\n");
|
|
LIB$SIGNAL (status);
|
|
}
|
|
|
|
/* Deassign I/O channel to network device. */
|
|
status = sys$dassgn (conn_channel);
|
|
|
|
if (!(status & STS$M_SUCCESS))
|
|
{
|
|
term_puts ("Failed to deassign I/O channel\n");
|
|
LIB$SIGNAL (status);
|
|
}
|
|
}
|
|
|
|
/* Mark a page as R/W. Return old rights. */
|
|
|
|
static unsigned int
|
|
page_set_rw (unsigned __int64 startva, unsigned __int64 len,
|
|
unsigned int *oldprot)
|
|
{
|
|
unsigned int status;
|
|
unsigned __int64 retva;
|
|
unsigned __int64 retlen;
|
|
|
|
status = SYS$SETPRT_64 ((void *)startva, len, PSL$C_USER, PRT$C_UW,
|
|
(void *)&retva, &retlen, oldprot);
|
|
return status;
|
|
}
|
|
|
|
/* Restore page rights. */
|
|
|
|
static void
|
|
page_restore_rw (unsigned __int64 startva, unsigned __int64 len,
|
|
unsigned int prot)
|
|
{
|
|
unsigned int status;
|
|
unsigned __int64 retva;
|
|
unsigned __int64 retlen;
|
|
unsigned int oldprot;
|
|
|
|
status = SYS$SETPRT_64 ((void *)startva, len, PSL$C_USER, prot,
|
|
(void *)&retva, &retlen, &oldprot);
|
|
if (!(status & STS$M_SUCCESS))
|
|
LIB$SIGNAL (status);
|
|
}
|
|
|
|
/* Get the TEB (thread environment block). */
|
|
|
|
static pthread_t
|
|
get_teb (void)
|
|
{
|
|
return (pthread_t)__getReg (_IA64_REG_TP);
|
|
}
|
|
|
|
/* Enable thread scheduling if VAL is true. */
|
|
|
|
static unsigned int
|
|
set_thread_scheduling (int val)
|
|
{
|
|
struct dbgext_control_block blk;
|
|
unsigned int status;
|
|
|
|
if (!dbgext_func)
|
|
return 0;
|
|
|
|
blk.dbgext$w_function_code = DBGEXT$K_STOP_ALL_OTHER_TASKS;
|
|
blk.dbgext$w_facility_id = CMA$_FACILITY;
|
|
blk.dbgext$l_stop_value = val;
|
|
|
|
status = dbgext_func (&blk);
|
|
if (!(status & STS$M_SUCCESS))
|
|
{
|
|
TERM_FAO ("set_thread_scheduling error, val=!SL, status=!XL!/",
|
|
val, blk.dbgext$l_status);
|
|
lib$signal (status);
|
|
}
|
|
|
|
return blk.dbgext$l_stop_value;
|
|
}
|
|
|
|
/* Get next thead (after THR). Start with 0. */
|
|
|
|
static unsigned int
|
|
thread_next (unsigned int thr)
|
|
{
|
|
struct dbgext_control_block blk;
|
|
unsigned int status;
|
|
|
|
if (!dbgext_func)
|
|
return 0;
|
|
|
|
blk.dbgext$w_function_code = DBGEXT$K_NEXT_TASK;
|
|
blk.dbgext$w_facility_id = CMA$_FACILITY;
|
|
blk.dbgext$l_ada_flags = 0;
|
|
blk.dbgext$l_task_value = thr;
|
|
|
|
status = dbgext_func (&blk);
|
|
if (!(status & STS$M_SUCCESS))
|
|
lib$signal (status);
|
|
|
|
return blk.dbgext$l_task_value;
|
|
}
|
|
|
|
/* Pthread Debug callbacks. */
|
|
|
|
static int
|
|
read_callback (pthreadDebugClient_t context,
|
|
pthreadDebugTargetAddr_t addr,
|
|
pthreadDebugAddr_t buf,
|
|
size_t size)
|
|
{
|
|
if (trace_pthreaddbg)
|
|
TERM_FAO ("read_callback (!XH, !XH, !SL)!/", addr, buf, size);
|
|
ots$move (buf, size, addr);
|
|
return 0;
|
|
}
|
|
|
|
static int
|
|
write_callback (pthreadDebugClient_t context,
|
|
pthreadDebugTargetAddr_t addr,
|
|
pthreadDebugLongConstAddr_t buf,
|
|
size_t size)
|
|
{
|
|
if (trace_pthreaddbg)
|
|
TERM_FAO ("write_callback (!XH, !XH, !SL)!/", addr, buf, size);
|
|
ots$move (addr, size, buf);
|
|
return 0;
|
|
}
|
|
|
|
static int
|
|
suspend_callback (pthreadDebugClient_t context)
|
|
{
|
|
/* Always suspended. */
|
|
return 0;
|
|
}
|
|
|
|
static int
|
|
resume_callback (pthreadDebugClient_t context)
|
|
{
|
|
/* So no need to resume. */
|
|
return 0;
|
|
}
|
|
|
|
static int
|
|
kthdinfo_callback (pthreadDebugClient_t context,
|
|
pthreadDebugKId_t kid,
|
|
pthreadDebugKThreadInfo_p thread_info)
|
|
{
|
|
if (trace_pthreaddbg)
|
|
term_puts ("kthinfo_callback");
|
|
return ENOSYS;
|
|
}
|
|
|
|
static int
|
|
hold_callback (pthreadDebugClient_t context,
|
|
pthreadDebugKId_t kid)
|
|
{
|
|
if (trace_pthreaddbg)
|
|
term_puts ("hold_callback");
|
|
return ENOSYS;
|
|
}
|
|
|
|
static int
|
|
unhold_callback (pthreadDebugClient_t context,
|
|
pthreadDebugKId_t kid)
|
|
{
|
|
if (trace_pthreaddbg)
|
|
term_puts ("unhold_callback");
|
|
return ENOSYS;
|
|
}
|
|
|
|
static int
|
|
getfreg_callback (pthreadDebugClient_t context,
|
|
pthreadDebugFregs_t *reg,
|
|
pthreadDebugKId_t kid)
|
|
{
|
|
if (trace_pthreaddbg)
|
|
term_puts ("getfreg_callback");
|
|
return ENOSYS;
|
|
}
|
|
|
|
static int
|
|
setfreg_callback (pthreadDebugClient_t context,
|
|
const pthreadDebugFregs_t *reg,
|
|
pthreadDebugKId_t kid)
|
|
{
|
|
if (trace_pthreaddbg)
|
|
term_puts ("setfreg_callback");
|
|
return ENOSYS;
|
|
}
|
|
|
|
static int
|
|
getreg_callback (pthreadDebugClient_t context,
|
|
pthreadDebugRegs_t *reg,
|
|
pthreadDebugKId_t kid)
|
|
{
|
|
if (trace_pthreaddbg)
|
|
term_puts ("getreg_callback");
|
|
return ENOSYS;
|
|
}
|
|
|
|
static int
|
|
setreg_callback (pthreadDebugClient_t context,
|
|
const pthreadDebugRegs_t *reg,
|
|
pthreadDebugKId_t kid)
|
|
{
|
|
if (trace_pthreaddbg)
|
|
term_puts ("setreg_callback");
|
|
return ENOSYS;
|
|
}
|
|
|
|
static int
|
|
output_callback (pthreadDebugClient_t context,
|
|
pthreadDebugConstString_t line)
|
|
{
|
|
term_puts (line);
|
|
term_putnl ();
|
|
return 0;
|
|
}
|
|
|
|
static int
|
|
error_callback (pthreadDebugClient_t context,
|
|
pthreadDebugConstString_t line)
|
|
{
|
|
term_puts (line);
|
|
term_putnl ();
|
|
return 0;
|
|
}
|
|
|
|
static pthreadDebugAddr_t
|
|
malloc_callback (pthreadDebugClient_t caller_context, size_t size)
|
|
{
|
|
unsigned int status;
|
|
unsigned int res;
|
|
int len;
|
|
|
|
len = size + 16;
|
|
status = lib$get_vm (&len, &res, 0);
|
|
if (!(status & STS$M_SUCCESS))
|
|
LIB$SIGNAL (status);
|
|
if (trace_pthreaddbg)
|
|
TERM_FAO ("malloc_callback (!UL) -> !XA!/", size, res);
|
|
*(unsigned int *)res = len;
|
|
return (char *)res + 16;
|
|
}
|
|
|
|
static void
|
|
free_callback (pthreadDebugClient_t caller_context, pthreadDebugAddr_t address)
|
|
{
|
|
unsigned int status;
|
|
unsigned int res;
|
|
int len;
|
|
|
|
res = (unsigned int)address - 16;
|
|
len = *(unsigned int *)res;
|
|
if (trace_pthreaddbg)
|
|
TERM_FAO ("free_callback (!XA)!/", address);
|
|
status = lib$free_vm (&len, &res, 0);
|
|
if (!(status & STS$M_SUCCESS))
|
|
LIB$SIGNAL (status);
|
|
}
|
|
|
|
static int
|
|
speckthd_callback (pthreadDebugClient_t caller_context,
|
|
pthreadDebugSpecialType_t type,
|
|
pthreadDebugKId_t *kernel_tid)
|
|
{
|
|
return ENOTSUP;
|
|
}
|
|
|
|
static pthreadDebugCallbacks_t pthread_debug_callbacks = {
|
|
PTHREAD_DEBUG_VERSION,
|
|
read_callback,
|
|
write_callback,
|
|
suspend_callback,
|
|
resume_callback,
|
|
kthdinfo_callback,
|
|
hold_callback,
|
|
unhold_callback,
|
|
getfreg_callback,
|
|
setfreg_callback,
|
|
getreg_callback,
|
|
setreg_callback,
|
|
output_callback,
|
|
error_callback,
|
|
malloc_callback,
|
|
free_callback,
|
|
speckthd_callback
|
|
};
|
|
|
|
/* Name of the pthread shared library. */
|
|
static const $DESCRIPTOR (pthread_rtl_desc, "PTHREAD$RTL");
|
|
|
|
/* List of symbols to extract from pthread debug library. */
|
|
struct pthread_debug_entry
|
|
{
|
|
const unsigned int namelen;
|
|
const __char_ptr32 name;
|
|
__void_ptr32 func;
|
|
};
|
|
|
|
#define DEBUG_ENTRY(str) { sizeof(str) - 1, str, 0 }
|
|
|
|
static struct pthread_debug_entry pthread_debug_entries[] = {
|
|
DEBUG_ENTRY("pthreadDebugContextInit"),
|
|
DEBUG_ENTRY("pthreadDebugThdSeqInit"),
|
|
DEBUG_ENTRY("pthreadDebugThdSeqNext"),
|
|
DEBUG_ENTRY("pthreadDebugThdSeqDestroy"),
|
|
DEBUG_ENTRY("pthreadDebugThdGetInfo"),
|
|
DEBUG_ENTRY("pthreadDebugThdGetInfoAddr"),
|
|
DEBUG_ENTRY("pthreadDebugThdGetReg"),
|
|
DEBUG_ENTRY("pthreadDebugCmd")
|
|
};
|
|
|
|
/* Pthread debug context. */
|
|
static pthreadDebugContext_t debug_context;
|
|
|
|
/* Wrapper around pthread debug entry points. */
|
|
|
|
static int
|
|
pthread_debug_thd_seq_init (pthreadDebugId_t *id)
|
|
{
|
|
return ((int (*)())pthread_debug_entries[1].func)
|
|
(debug_context, id);
|
|
}
|
|
|
|
static int
|
|
pthread_debug_thd_seq_next (pthreadDebugId_t *id)
|
|
{
|
|
return ((int (*)())pthread_debug_entries[2].func)
|
|
(debug_context, id);
|
|
}
|
|
|
|
static int
|
|
pthread_debug_thd_seq_destroy (void)
|
|
{
|
|
return ((int (*)())pthread_debug_entries[3].func)
|
|
(debug_context);
|
|
}
|
|
|
|
static int
|
|
pthread_debug_thd_get_info (pthreadDebugId_t id,
|
|
pthreadDebugThreadInfo_t *info)
|
|
{
|
|
return ((int (*)())pthread_debug_entries[4].func)
|
|
(debug_context, id, info);
|
|
}
|
|
|
|
static int
|
|
pthread_debug_thd_get_info_addr (pthread_t thr,
|
|
pthreadDebugThreadInfo_t *info)
|
|
{
|
|
return ((int (*)())pthread_debug_entries[5].func)
|
|
(debug_context, thr, info);
|
|
}
|
|
|
|
static int
|
|
pthread_debug_thd_get_reg (pthreadDebugId_t thr,
|
|
pthreadDebugRegs_t *regs)
|
|
{
|
|
return ((int (*)())pthread_debug_entries[6].func)
|
|
(debug_context, thr, regs);
|
|
}
|
|
|
|
static int
|
|
stub_pthread_debug_cmd (const char *cmd)
|
|
{
|
|
return ((int (*)())pthread_debug_entries[7].func)
|
|
(debug_context, cmd);
|
|
}
|
|
|
|
/* Show all the threads. */
|
|
|
|
static void
|
|
threads_show (void)
|
|
{
|
|
pthreadDebugId_t id;
|
|
pthreadDebugThreadInfo_t info;
|
|
int res;
|
|
|
|
res = pthread_debug_thd_seq_init (&id);
|
|
if (res != 0)
|
|
{
|
|
TERM_FAO ("seq init failed, res=!SL!/", res);
|
|
return;
|
|
}
|
|
while (1)
|
|
{
|
|
if (pthread_debug_thd_get_info (id, &info) != 0)
|
|
{
|
|
TERM_FAO ("thd_get_info !SL failed!/", id);
|
|
break;
|
|
}
|
|
if (pthread_debug_thd_seq_next (&id) != 0)
|
|
break;
|
|
}
|
|
pthread_debug_thd_seq_destroy ();
|
|
}
|
|
|
|
/* Initialize pthread support. */
|
|
|
|
static void
|
|
threads_init (void)
|
|
{
|
|
static const $DESCRIPTOR (dbgext_desc, "PTHREAD$DBGEXT");
|
|
static const $DESCRIPTOR (pthread_debug_desc, "PTHREAD$DBGSHR");
|
|
static const $DESCRIPTOR (dbgsymtable_desc, "PTHREAD_DBG_SYMTABLE");
|
|
int pthread_dbgext;
|
|
int status;
|
|
void *dbg_symtable;
|
|
int i;
|
|
void *caller_context = 0;
|
|
|
|
status = lib$find_image_symbol
|
|
((void *) &pthread_rtl_desc, (void *) &dbgext_desc,
|
|
(int *) &dbgext_func);
|
|
if (!(status & STS$M_SUCCESS))
|
|
LIB$SIGNAL (status);
|
|
|
|
status = lib$find_image_symbol
|
|
((void *) &pthread_rtl_desc, (void *) &dbgsymtable_desc,
|
|
(int *) &dbg_symtable);
|
|
if (!(status & STS$M_SUCCESS))
|
|
LIB$SIGNAL (status);
|
|
|
|
/* Find entry points in pthread_debug. */
|
|
for (i = 0;
|
|
i < sizeof (pthread_debug_entries) / sizeof (pthread_debug_entries[0]);
|
|
i++)
|
|
{
|
|
struct dsc$descriptor_s sym =
|
|
{ pthread_debug_entries[i].namelen,
|
|
DSC$K_DTYPE_T, DSC$K_CLASS_S,
|
|
pthread_debug_entries[i].name };
|
|
status = lib$find_image_symbol
|
|
((void *) &pthread_debug_desc, (void *) &sym,
|
|
(int *) &pthread_debug_entries[i].func);
|
|
if (!(status & STS$M_SUCCESS))
|
|
lib$signal (status);
|
|
}
|
|
|
|
if (trace_pthreaddbg)
|
|
TERM_FAO ("debug symtable: !XH!/", dbg_symtable);
|
|
status = ((int (*)()) pthread_debug_entries[0].func)
|
|
(&caller_context, &pthread_debug_callbacks, dbg_symtable, &debug_context);
|
|
if (status != 0)
|
|
TERM_FAO ("cannot initialize pthread_debug: !UL!/", status);
|
|
TERM_FAO ("pthread debug done!/", 0);
|
|
}
|
|
|
|
/* Convert an hexadecimal character to a nibble. Return -1 in case of
|
|
error. */
|
|
|
|
static int
|
|
hex2nibble (unsigned char h)
|
|
{
|
|
if (h >= '0' && h <= '9')
|
|
return h - '0';
|
|
if (h >= 'A' && h <= 'F')
|
|
return h - 'A' + 10;
|
|
if (h >= 'a' && h <= 'f')
|
|
return h - 'a' + 10;
|
|
return -1;
|
|
}
|
|
|
|
/* Convert an hexadecimal 2 character string to a byte. Return -1 in case
|
|
of error. */
|
|
|
|
static int
|
|
hex2byte (const unsigned char *p)
|
|
{
|
|
int h, l;
|
|
|
|
h = hex2nibble (p[0]);
|
|
l = hex2nibble (p[1]);
|
|
if (h == -1 || l == -1)
|
|
return -1;
|
|
return (h << 4) | l;
|
|
}
|
|
|
|
/* Convert a byte V to a 2 character strings P. */
|
|
|
|
static void
|
|
byte2hex (unsigned char *p, unsigned char v)
|
|
{
|
|
p[0] = hex[v >> 4];
|
|
p[1] = hex[v & 0xf];
|
|
}
|
|
|
|
/* Convert a quadword V to a 16 character strings P. */
|
|
|
|
static void
|
|
quad2hex (unsigned char *p, unsigned __int64 v)
|
|
{
|
|
int i;
|
|
for (i = 0; i < 16; i++)
|
|
{
|
|
p[i] = hex[v >> 60];
|
|
v <<= 4;
|
|
}
|
|
}
|
|
|
|
static void
|
|
long2pkt (unsigned int v)
|
|
{
|
|
int i;
|
|
|
|
for (i = 0; i < 8; i++)
|
|
{
|
|
gdb_buf[gdb_blen + i] = hex[(v >> 28) & 0x0f];
|
|
v <<= 4;
|
|
}
|
|
gdb_blen += 8;
|
|
}
|
|
|
|
/* Generate an error packet. */
|
|
|
|
static void
|
|
packet_error (unsigned int err)
|
|
{
|
|
gdb_buf[1] = 'E';
|
|
byte2hex (gdb_buf + 2, err);
|
|
gdb_blen = 4;
|
|
}
|
|
|
|
/* Generate an OK packet. */
|
|
|
|
static void
|
|
packet_ok (void)
|
|
{
|
|
gdb_buf[1] = 'O';
|
|
gdb_buf[2] = 'K';
|
|
gdb_blen = 3;
|
|
}
|
|
|
|
/* Append a register to the packet. */
|
|
|
|
static void
|
|
ireg2pkt (const unsigned char *p)
|
|
{
|
|
int i;
|
|
|
|
for (i = 0; i < 8; i++)
|
|
{
|
|
byte2hex (gdb_buf + gdb_blen, p[i]);
|
|
gdb_blen += 2;
|
|
}
|
|
}
|
|
|
|
/* Append a C string (ASCIZ) to the packet. */
|
|
|
|
static void
|
|
str2pkt (const char *str)
|
|
{
|
|
while (*str)
|
|
gdb_buf[gdb_blen++] = *str++;
|
|
}
|
|
|
|
/* Extract a number fro the packet. */
|
|
|
|
static unsigned __int64
|
|
pkt2val (const unsigned char *pkt, unsigned int *pos)
|
|
{
|
|
unsigned __int64 res = 0;
|
|
unsigned int i;
|
|
|
|
while (1)
|
|
{
|
|
int r = hex2nibble (pkt[*pos]);
|
|
|
|
if (r < 0)
|
|
return res;
|
|
res = (res << 4) | r;
|
|
(*pos)++;
|
|
}
|
|
}
|
|
|
|
/* Append LEN bytes from B to the current gdb packet (encode in binary). */
|
|
|
|
static void
|
|
mem2bin (const unsigned char *b, unsigned int len)
|
|
{
|
|
unsigned int i;
|
|
for (i = 0; i < len; i++)
|
|
switch (b[i])
|
|
{
|
|
case '#':
|
|
case '$':
|
|
case '}':
|
|
case '*':
|
|
case 0:
|
|
gdb_buf[gdb_blen++] = '}';
|
|
gdb_buf[gdb_blen++] = b[i] ^ 0x20;
|
|
break;
|
|
default:
|
|
gdb_buf[gdb_blen++] = b[i];
|
|
break;
|
|
}
|
|
}
|
|
|
|
/* Append LEN bytes from B to the current gdb packet (encode in hex). */
|
|
|
|
static void
|
|
mem2hex (const unsigned char *b, unsigned int len)
|
|
{
|
|
unsigned int i;
|
|
for (i = 0; i < len; i++)
|
|
{
|
|
byte2hex (gdb_buf + gdb_blen, b[i]);
|
|
gdb_blen += 2;
|
|
}
|
|
}
|
|
|
|
/* Handle the 'q' packet. */
|
|
|
|
static void
|
|
handle_q_packet (const unsigned char *pkt, unsigned int pktlen)
|
|
{
|
|
/* For qfThreadInfo and qsThreadInfo. */
|
|
static unsigned int first_thread;
|
|
static unsigned int last_thread;
|
|
|
|
static const char xfer_uib[] = "qXfer:uib:read:";
|
|
#define XFER_UIB_LEN (sizeof (xfer_uib) - 1)
|
|
static const char qfthreadinfo[] = "qfThreadInfo";
|
|
#define QFTHREADINFO_LEN (sizeof (qfthreadinfo) - 1)
|
|
static const char qsthreadinfo[] = "qsThreadInfo";
|
|
#define QSTHREADINFO_LEN (sizeof (qsthreadinfo) - 1)
|
|
static const char qthreadextrainfo[] = "qThreadExtraInfo,";
|
|
#define QTHREADEXTRAINFO_LEN (sizeof (qthreadextrainfo) - 1)
|
|
static const char qsupported[] = "qSupported:";
|
|
#define QSUPPORTED_LEN (sizeof (qsupported) - 1)
|
|
|
|
if (pktlen == 2 && pkt[1] == 'C')
|
|
{
|
|
/* Current thread. */
|
|
gdb_buf[0] = '$';
|
|
gdb_buf[1] = 'Q';
|
|
gdb_buf[2] = 'C';
|
|
gdb_blen = 3;
|
|
if (has_threads)
|
|
long2pkt ((unsigned long) get_teb ());
|
|
return;
|
|
}
|
|
else if (pktlen > XFER_UIB_LEN
|
|
&& ots$strcmp_eql (pkt, XFER_UIB_LEN, xfer_uib, XFER_UIB_LEN))
|
|
{
|
|
/* Get unwind information block. */
|
|
unsigned __int64 pc;
|
|
unsigned int pos = XFER_UIB_LEN;
|
|
unsigned int off;
|
|
unsigned int len;
|
|
union
|
|
{
|
|
unsigned char bytes[32];
|
|
struct
|
|
{
|
|
unsigned __int64 code_start_va;
|
|
unsigned __int64 code_end_va;
|
|
unsigned __int64 uib_start_va;
|
|
unsigned __int64 gp_value;
|
|
} data;
|
|
} uei;
|
|
int res;
|
|
int i;
|
|
|
|
packet_error (0);
|
|
|
|
pc = pkt2val (pkt, &pos);
|
|
if (pkt[pos] != ':')
|
|
return;
|
|
pos++;
|
|
off = pkt2val (pkt, &pos);
|
|
if (pkt[pos] != ',' || off != 0)
|
|
return;
|
|
pos++;
|
|
len = pkt2val (pkt, &pos);
|
|
if (pkt[pos] != '#' || len != 0x20)
|
|
return;
|
|
|
|
res = SYS$GET_UNWIND_ENTRY_INFO (pc, &uei.data, 0);
|
|
if (res == SS$_NODATA || res != SS$_NORMAL)
|
|
ots$fill (uei.bytes, sizeof (uei.bytes), 0);
|
|
|
|
if (trace_unwind)
|
|
{
|
|
TERM_FAO ("Unwind request for !XH, status=!XL, uib=!XQ, GP=!XQ!/",
|
|
pc, res, uei.data.uib_start_va, uei.data.gp_value);
|
|
}
|
|
|
|
gdb_buf[0] = '$';
|
|
gdb_buf[1] = 'l';
|
|
gdb_blen = 2;
|
|
mem2bin (uei.bytes, sizeof (uei.bytes));
|
|
}
|
|
else if (pktlen == QFTHREADINFO_LEN
|
|
&& ots$strcmp_eql (pkt, QFTHREADINFO_LEN,
|
|
qfthreadinfo, QFTHREADINFO_LEN))
|
|
{
|
|
/* Get first thread(s). */
|
|
gdb_buf[0] = '$';
|
|
gdb_buf[1] = 'm';
|
|
gdb_blen = 2;
|
|
|
|
if (!has_threads)
|
|
{
|
|
gdb_buf[1] = 'l';
|
|
return;
|
|
}
|
|
first_thread = thread_next (0);
|
|
last_thread = first_thread;
|
|
long2pkt (first_thread);
|
|
}
|
|
else if (pktlen == QSTHREADINFO_LEN
|
|
&& ots$strcmp_eql (pkt, QSTHREADINFO_LEN,
|
|
qsthreadinfo, QSTHREADINFO_LEN))
|
|
{
|
|
/* Get subsequent threads. */
|
|
gdb_buf[0] = '$';
|
|
gdb_buf[1] = 'm';
|
|
gdb_blen = 2;
|
|
while (dbgext_func)
|
|
{
|
|
unsigned int res;
|
|
res = thread_next (last_thread);
|
|
if (res == first_thread)
|
|
break;
|
|
if (gdb_blen > 2)
|
|
gdb_buf[gdb_blen++] = ',';
|
|
long2pkt (res);
|
|
last_thread = res;
|
|
if (gdb_blen > sizeof (gdb_buf) - 16)
|
|
break;
|
|
}
|
|
|
|
if (gdb_blen == 2)
|
|
gdb_buf[1] = 'l';
|
|
}
|
|
else if (pktlen > QTHREADEXTRAINFO_LEN
|
|
&& ots$strcmp_eql (pkt, QTHREADEXTRAINFO_LEN,
|
|
qthreadextrainfo, QTHREADEXTRAINFO_LEN))
|
|
{
|
|
/* Get extra info about a thread. */
|
|
pthread_t thr;
|
|
unsigned int pos = QTHREADEXTRAINFO_LEN;
|
|
pthreadDebugThreadInfo_t info;
|
|
int res;
|
|
|
|
packet_error (0);
|
|
if (!has_threads)
|
|
return;
|
|
|
|
thr = (pthread_t) pkt2val (pkt, &pos);
|
|
if (pkt[pos] != '#')
|
|
return;
|
|
res = pthread_debug_thd_get_info_addr (thr, &info);
|
|
if (res != 0)
|
|
{
|
|
TERM_FAO ("qThreadExtraInfo (!XH) failed: !SL!/", thr, res);
|
|
return;
|
|
}
|
|
gdb_buf[0] = '$';
|
|
gdb_blen = 1;
|
|
mem2hex ((const unsigned char *)"VMS-thread", 11);
|
|
}
|
|
else if (pktlen > QSUPPORTED_LEN
|
|
&& ots$strcmp_eql (pkt, QSUPPORTED_LEN,
|
|
qsupported, QSUPPORTED_LEN))
|
|
{
|
|
/* Get supported features. */
|
|
pthread_t thr;
|
|
unsigned int pos = QSUPPORTED_LEN;
|
|
pthreadDebugThreadInfo_t info;
|
|
int res;
|
|
|
|
/* Ignore gdb features. */
|
|
gdb_buf[0] = '$';
|
|
gdb_blen = 1;
|
|
|
|
str2pkt ("qXfer:uib:read+");
|
|
return;
|
|
}
|
|
else
|
|
{
|
|
if (trace_pkt)
|
|
{
|
|
term_puts ("unknown <: ");
|
|
term_write ((char *)pkt, pktlen);
|
|
term_putnl ();
|
|
}
|
|
return;
|
|
}
|
|
}
|
|
|
|
/* Handle the 'v' packet. */
|
|
|
|
static int
|
|
handle_v_packet (const unsigned char *pkt, unsigned int pktlen)
|
|
{
|
|
static const char vcontq[] = "vCont?";
|
|
#define VCONTQ_LEN (sizeof (vcontq) - 1)
|
|
|
|
if (pktlen == VCONTQ_LEN
|
|
&& ots$strcmp_eql (pkt, VCONTQ_LEN, vcontq, VCONTQ_LEN))
|
|
{
|
|
gdb_buf[0] = '$';
|
|
gdb_blen = 1;
|
|
|
|
str2pkt ("vCont;c;s");
|
|
return 0;
|
|
}
|
|
else
|
|
{
|
|
if (trace_pkt)
|
|
{
|
|
term_puts ("unknown <: ");
|
|
term_write ((char *)pkt, pktlen);
|
|
term_putnl ();
|
|
}
|
|
return 0;
|
|
}
|
|
}
|
|
|
|
/* Get regs for the selected thread. */
|
|
|
|
static struct ia64_all_regs *
|
|
get_selected_regs (void)
|
|
{
|
|
pthreadDebugRegs_t regs;
|
|
int res;
|
|
|
|
if (selected_thread == 0 || selected_thread == get_teb ())
|
|
return &excp_regs;
|
|
|
|
if (selected_thread == sel_regs_pthread)
|
|
return &sel_regs;
|
|
|
|
/* Read registers. */
|
|
res = pthread_debug_thd_get_reg (selected_id, ®s);
|
|
if (res != 0)
|
|
{
|
|
/* FIXME: return NULL ? */
|
|
return &excp_regs;
|
|
}
|
|
sel_regs_pthread = selected_thread;
|
|
sel_regs.gr[1].v = regs.gp;
|
|
sel_regs.gr[4].v = regs.r4;
|
|
sel_regs.gr[5].v = regs.r5;
|
|
sel_regs.gr[6].v = regs.r6;
|
|
sel_regs.gr[7].v = regs.r7;
|
|
sel_regs.gr[12].v = regs.sp;
|
|
sel_regs.br[0].v = regs.rp;
|
|
sel_regs.br[1].v = regs.b1;
|
|
sel_regs.br[2].v = regs.b2;
|
|
sel_regs.br[3].v = regs.b3;
|
|
sel_regs.br[4].v = regs.b4;
|
|
sel_regs.br[5].v = regs.b5;
|
|
sel_regs.ip.v = regs.ip;
|
|
sel_regs.bsp.v = regs.bspstore; /* FIXME: it is correct ? */
|
|
sel_regs.pfs.v = regs.pfs;
|
|
sel_regs.pr.v = regs.pr;
|
|
return &sel_regs;
|
|
}
|
|
|
|
/* Create a status packet. */
|
|
|
|
static void
|
|
packet_status (void)
|
|
{
|
|
gdb_blen = 0;
|
|
if (has_threads)
|
|
{
|
|
str2pkt ("$T05thread:");
|
|
long2pkt ((unsigned long) get_teb ());
|
|
gdb_buf[gdb_blen++] = ';';
|
|
}
|
|
else
|
|
str2pkt ("$S05");
|
|
}
|
|
|
|
/* Return 1 to continue. */
|
|
|
|
static int
|
|
handle_packet (unsigned char *pkt, unsigned int len)
|
|
{
|
|
unsigned int pos;
|
|
|
|
/* By default, reply unsupported. */
|
|
gdb_buf[0] = '$';
|
|
gdb_blen = 1;
|
|
|
|
pos = 1;
|
|
switch (pkt[0])
|
|
{
|
|
case '?':
|
|
if (len == 1)
|
|
{
|
|
packet_status ();
|
|
return 0;
|
|
}
|
|
break;
|
|
case 'c':
|
|
if (len == 1)
|
|
{
|
|
/* Clear psr.ss. */
|
|
excp_regs.psr.v &= ~(unsigned __int64)PSR$M_SS;
|
|
return 1;
|
|
}
|
|
else
|
|
packet_error (0);
|
|
break;
|
|
case 'g':
|
|
if (len == 1)
|
|
{
|
|
unsigned int i;
|
|
struct ia64_all_regs *regs = get_selected_regs ();
|
|
unsigned char *p = regs->gr[0].b;
|
|
|
|
for (i = 0; i < 8 * 32; i++)
|
|
byte2hex (gdb_buf + 1 + 2 * i, p[i]);
|
|
gdb_blen += 2 * 8 * 32;
|
|
return 0;
|
|
}
|
|
break;
|
|
case 'H':
|
|
if (pkt[1] == 'g')
|
|
{
|
|
int res;
|
|
unsigned __int64 val;
|
|
pthreadDebugThreadInfo_t info;
|
|
|
|
pos++;
|
|
val = pkt2val (pkt, &pos);
|
|
if (pos != len)
|
|
{
|
|
packet_error (0);
|
|
return 0;
|
|
}
|
|
if (val == 0)
|
|
{
|
|
/* Default one. */
|
|
selected_thread = get_teb ();
|
|
selected_id = 0;
|
|
}
|
|
else if (!has_threads)
|
|
{
|
|
packet_error (0);
|
|
return 0;
|
|
}
|
|
else
|
|
{
|
|
res = pthread_debug_thd_get_info_addr ((pthread_t) val, &info);
|
|
if (res != 0)
|
|
{
|
|
TERM_FAO ("qThreadExtraInfo (!XH) failed: !SL!/", val, res);
|
|
packet_error (0);
|
|
return 0;
|
|
}
|
|
selected_thread = info.teb;
|
|
selected_id = info.sequence;
|
|
}
|
|
packet_ok ();
|
|
break;
|
|
}
|
|
else if (pkt[1] == 'c'
|
|
&& ((pkt[2] == '-' && pkt[3] == '1' && len == 4)
|
|
|| (pkt[2] == '0' && len == 3)))
|
|
{
|
|
/* Silently accept 'Hc0' and 'Hc-1'. */
|
|
packet_ok ();
|
|
break;
|
|
}
|
|
else
|
|
{
|
|
packet_error (0);
|
|
return 0;
|
|
}
|
|
case 'k':
|
|
SYS$EXIT (SS$_NORMAL);
|
|
break;
|
|
case 'm':
|
|
{
|
|
unsigned __int64 addr;
|
|
unsigned __int64 paddr;
|
|
unsigned int l;
|
|
unsigned int i;
|
|
|
|
addr = pkt2val (pkt, &pos);
|
|
if (pkt[pos] != ',')
|
|
{
|
|
packet_error (0);
|
|
return 0;
|
|
}
|
|
pos++;
|
|
l = pkt2val (pkt, &pos);
|
|
if (pkt[pos] != '#')
|
|
{
|
|
packet_error (0);
|
|
return 0;
|
|
}
|
|
|
|
/* Check access. */
|
|
i = l + (addr & VMS_PAGE_MASK);
|
|
paddr = addr & ~VMS_PAGE_MASK;
|
|
while (1)
|
|
{
|
|
if (__prober (paddr, 0) != 1)
|
|
{
|
|
packet_error (2);
|
|
return 0;
|
|
}
|
|
if (i < VMS_PAGE_SIZE)
|
|
break;
|
|
i -= VMS_PAGE_SIZE;
|
|
paddr += VMS_PAGE_SIZE;
|
|
}
|
|
|
|
/* Transfer. */
|
|
for (i = 0; i < l; i++)
|
|
byte2hex (gdb_buf + 1 + 2 * i, ((unsigned char *)addr)[i]);
|
|
gdb_blen += 2 * l;
|
|
}
|
|
break;
|
|
case 'M':
|
|
{
|
|
unsigned __int64 addr;
|
|
unsigned __int64 paddr;
|
|
unsigned int l;
|
|
unsigned int i;
|
|
unsigned int oldprot;
|
|
|
|
addr = pkt2val (pkt, &pos);
|
|
if (pkt[pos] != ',')
|
|
{
|
|
packet_error (0);
|
|
return 0;
|
|
}
|
|
pos++;
|
|
l = pkt2val (pkt, &pos);
|
|
if (pkt[pos] != ':')
|
|
{
|
|
packet_error (0);
|
|
return 0;
|
|
}
|
|
pos++;
|
|
page_set_rw (addr, l, &oldprot);
|
|
|
|
/* Check access. */
|
|
i = l + (addr & VMS_PAGE_MASK);
|
|
paddr = addr & ~VMS_PAGE_MASK;
|
|
while (1)
|
|
{
|
|
if (__probew (paddr, 0) != 1)
|
|
{
|
|
page_restore_rw (addr, l, oldprot);
|
|
return 0;
|
|
}
|
|
if (i < VMS_PAGE_SIZE)
|
|
break;
|
|
i -= VMS_PAGE_SIZE;
|
|
paddr += VMS_PAGE_SIZE;
|
|
}
|
|
|
|
/* Write. */
|
|
for (i = 0; i < l; i++)
|
|
{
|
|
int v = hex2byte (pkt + pos);
|
|
pos += 2;
|
|
((unsigned char *)addr)[i] = v;
|
|
}
|
|
|
|
/* Sync caches. */
|
|
for (i = 0; i < l; i += 15)
|
|
__fc (addr + i);
|
|
__fc (addr + l);
|
|
|
|
page_restore_rw (addr, l, oldprot);
|
|
packet_ok ();
|
|
}
|
|
break;
|
|
case 'p':
|
|
{
|
|
unsigned int num = 0;
|
|
unsigned int i;
|
|
struct ia64_all_regs *regs = get_selected_regs ();
|
|
|
|
num = pkt2val (pkt, &pos);
|
|
if (pos != len)
|
|
{
|
|
packet_error (0);
|
|
return 0;
|
|
}
|
|
|
|
switch (num)
|
|
{
|
|
case IA64_IP_REGNUM:
|
|
ireg2pkt (regs->ip.b);
|
|
break;
|
|
case IA64_BR0_REGNUM:
|
|
ireg2pkt (regs->br[0].b);
|
|
break;
|
|
case IA64_PSR_REGNUM:
|
|
ireg2pkt (regs->psr.b);
|
|
break;
|
|
case IA64_BSP_REGNUM:
|
|
ireg2pkt (regs->bsp.b);
|
|
break;
|
|
case IA64_CFM_REGNUM:
|
|
ireg2pkt (regs->cfm.b);
|
|
break;
|
|
case IA64_PFS_REGNUM:
|
|
ireg2pkt (regs->pfs.b);
|
|
break;
|
|
case IA64_PR_REGNUM:
|
|
ireg2pkt (regs->pr.b);
|
|
break;
|
|
default:
|
|
TERM_FAO ("gdbserv: unhandled reg !UW!/", num);
|
|
packet_error (0);
|
|
return 0;
|
|
}
|
|
}
|
|
break;
|
|
case 'q':
|
|
handle_q_packet (pkt, len);
|
|
break;
|
|
case 's':
|
|
if (len == 1)
|
|
{
|
|
/* Set psr.ss. */
|
|
excp_regs.psr.v |= (unsigned __int64)PSR$M_SS;
|
|
return 1;
|
|
}
|
|
else
|
|
packet_error (0);
|
|
break;
|
|
case 'T':
|
|
/* Thread status. */
|
|
if (!has_threads)
|
|
{
|
|
packet_ok ();
|
|
break;
|
|
}
|
|
else
|
|
{
|
|
int res;
|
|
unsigned __int64 val;
|
|
unsigned int fthr, thr;
|
|
|
|
val = pkt2val (pkt, &pos);
|
|
/* Default is error (but only after parsing is complete). */
|
|
packet_error (0);
|
|
if (pos != len)
|
|
break;
|
|
|
|
/* Follow the list. This makes a O(n2) algorithm, but we don't really
|
|
have the choice. Note that pthread_debug_thd_get_info_addr
|
|
doesn't look reliable. */
|
|
fthr = thread_next (0);
|
|
thr = fthr;
|
|
do
|
|
{
|
|
if (val == thr)
|
|
{
|
|
packet_ok ();
|
|
break;
|
|
}
|
|
thr = thread_next (thr);
|
|
}
|
|
while (thr != fthr);
|
|
}
|
|
break;
|
|
case 'v':
|
|
return handle_v_packet (pkt, len);
|
|
break;
|
|
case 'V':
|
|
if (len > 3 && pkt[1] == 'M' && pkt[2] == 'S' && pkt[3] == ' ')
|
|
{
|
|
/* Temporary extension. */
|
|
if (has_threads)
|
|
{
|
|
pkt[len] = 0;
|
|
stub_pthread_debug_cmd ((char *)pkt + 4);
|
|
packet_ok ();
|
|
}
|
|
else
|
|
packet_error (0);
|
|
}
|
|
break;
|
|
default:
|
|
if (trace_pkt)
|
|
{
|
|
term_puts ("unknown <: ");
|
|
term_write ((char *)pkt, len);
|
|
term_putnl ();
|
|
}
|
|
break;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
/* Raw write to gdb. */
|
|
|
|
static void
|
|
sock_write (const unsigned char *buf, int len)
|
|
{
|
|
struct _iosb iosb;
|
|
unsigned int status;
|
|
|
|
/* Write data to connection. */
|
|
status = sys$qiow (EFN$C_ENF, /* Event flag. */
|
|
conn_channel, /* I/O channel. */
|
|
IO$_WRITEVBLK, /* I/O function code. */
|
|
&iosb, /* I/O status block. */
|
|
0, /* Ast service routine. */
|
|
0, /* Ast parameter. */
|
|
(char *)buf, /* P1 - buffer address. */
|
|
len, /* P2 - buffer length. */
|
|
0, 0, 0, 0);
|
|
if (status & STS$M_SUCCESS)
|
|
status = iosb.iosb$w_status;
|
|
if (!(status & STS$M_SUCCESS))
|
|
{
|
|
term_puts ("Failed to write data to gdb\n");
|
|
LIB$SIGNAL (status);
|
|
}
|
|
}
|
|
|
|
/* Compute the checksum and send the packet. */
|
|
|
|
static void
|
|
send_pkt (void)
|
|
{
|
|
unsigned char chksum = 0;
|
|
unsigned int i;
|
|
|
|
for (i = 1; i < gdb_blen; i++)
|
|
chksum += gdb_buf[i];
|
|
|
|
gdb_buf[gdb_blen] = '#';
|
|
byte2hex (gdb_buf + gdb_blen + 1, chksum);
|
|
|
|
sock_write (gdb_buf, gdb_blen + 3);
|
|
|
|
if (trace_pkt > 1)
|
|
{
|
|
term_puts (">: ");
|
|
term_write ((char *)gdb_buf, gdb_blen + 3);
|
|
term_putnl ();
|
|
}
|
|
}
|
|
|
|
/* Read and handle one command. Return 1 is execution must resume. */
|
|
|
|
static int
|
|
one_command (void)
|
|
{
|
|
struct _iosb iosb;
|
|
unsigned int status;
|
|
unsigned int off;
|
|
unsigned int dollar_off = 0;
|
|
unsigned int sharp_off = 0;
|
|
unsigned int cmd_off;
|
|
unsigned int cmd_len;
|
|
|
|
/* Wait for a packet. */
|
|
while (1)
|
|
{
|
|
off = 0;
|
|
while (1)
|
|
{
|
|
/* Read data from connection. */
|
|
status = sys$qiow (EFN$C_ENF, /* Event flag. */
|
|
conn_channel, /* I/O channel. */
|
|
IO$_READVBLK, /* I/O function code. */
|
|
&iosb, /* I/O status block. */
|
|
0, /* Ast service routine. */
|
|
0, /* Ast parameter. */
|
|
gdb_buf + off, /* P1 - buffer address. */
|
|
sizeof (gdb_buf) - off, /* P2 - buffer leng. */
|
|
0, 0, 0, 0);
|
|
if (status & STS$M_SUCCESS)
|
|
status = iosb.iosb$w_status;
|
|
if (!(status & STS$M_SUCCESS))
|
|
{
|
|
term_puts ("Failed to read data from connection\n" );
|
|
LIB$SIGNAL (status);
|
|
}
|
|
|
|
#ifdef RAW_DUMP
|
|
term_puts ("{: ");
|
|
term_write ((char *)gdb_buf + off, iosb.iosb$w_bcnt);
|
|
term_putnl ();
|
|
#endif
|
|
|
|
gdb_blen = off + iosb.iosb$w_bcnt;
|
|
|
|
if (off == 0)
|
|
{
|
|
/* Search for '$'. */
|
|
for (dollar_off = 0; dollar_off < gdb_blen; dollar_off++)
|
|
if (gdb_buf[dollar_off] == '$')
|
|
break;
|
|
if (dollar_off >= gdb_blen)
|
|
{
|
|
/* Not found, discard the data. */
|
|
off = 0;
|
|
continue;
|
|
}
|
|
/* Search for '#'. */
|
|
for (sharp_off = dollar_off + 1;
|
|
sharp_off < gdb_blen;
|
|
sharp_off++)
|
|
if (gdb_buf[sharp_off] == '#')
|
|
break;
|
|
}
|
|
else if (sharp_off >= off)
|
|
{
|
|
/* Search for '#'. */
|
|
for (; sharp_off < gdb_blen; sharp_off++)
|
|
if (gdb_buf[sharp_off] == '#')
|
|
break;
|
|
}
|
|
|
|
/* Got packet with checksum. */
|
|
if (sharp_off + 2 <= gdb_blen)
|
|
break;
|
|
|
|
off = gdb_blen;
|
|
if (gdb_blen == sizeof (gdb_buf))
|
|
{
|
|
/* Packet too large, discard. */
|
|
off = 0;
|
|
}
|
|
}
|
|
|
|
/* Validate and acknowledge a packet. */
|
|
{
|
|
unsigned char chksum = 0;
|
|
unsigned int i;
|
|
int v;
|
|
|
|
for (i = dollar_off + 1; i < sharp_off; i++)
|
|
chksum += gdb_buf[i];
|
|
v = hex2byte (gdb_buf + sharp_off + 1);
|
|
if (v != chksum)
|
|
{
|
|
term_puts ("Discard bad checksum packet\n");
|
|
continue;
|
|
}
|
|
else
|
|
{
|
|
sock_write ((const unsigned char *)"+", 1);
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
if (trace_pkt > 1)
|
|
{
|
|
term_puts ("<: ");
|
|
term_write ((char *)gdb_buf + dollar_off, sharp_off - dollar_off + 1);
|
|
term_putnl ();
|
|
}
|
|
|
|
cmd_off = dollar_off + 1;
|
|
cmd_len = sharp_off - dollar_off - 1;
|
|
|
|
if (handle_packet (gdb_buf + dollar_off + 1, sharp_off - dollar_off - 1) == 1)
|
|
return 1;
|
|
|
|
send_pkt ();
|
|
return 0;
|
|
}
|
|
|
|
/* Display the condition given by SIG64. */
|
|
|
|
static void
|
|
display_excp (struct chf64$signal_array *sig64, struct chf$mech_array *mech)
|
|
{
|
|
unsigned int status;
|
|
char msg[160];
|
|
unsigned short msglen;
|
|
$DESCRIPTOR (msg_desc, msg);
|
|
unsigned char outadr[4];
|
|
|
|
status = SYS$GETMSG (sig64->chf64$q_sig_name, &msglen, &msg_desc, 0, outadr);
|
|
if (status & STS$M_SUCCESS)
|
|
{
|
|
char msg2[160];
|
|
unsigned short msg2len;
|
|
struct dsc$descriptor_s msg2_desc =
|
|
{ sizeof (msg2), DSC$K_DTYPE_T, DSC$K_CLASS_S, msg2};
|
|
msg_desc.dsc$w_length = msglen;
|
|
status = SYS$FAOL_64 (&msg_desc, &msg2len, &msg2_desc,
|
|
&sig64->chf64$q_sig_arg1);
|
|
if (status & STS$M_SUCCESS)
|
|
term_write (msg2, msg2len);
|
|
}
|
|
else
|
|
term_puts ("no message");
|
|
term_putnl ();
|
|
|
|
if (trace_excp > 1)
|
|
{
|
|
TERM_FAO (" Frame: !XH, Depth: !4SL, Esf: !XH!/",
|
|
mech->chf$q_mch_frame, mech->chf$q_mch_depth,
|
|
mech->chf$q_mch_esf_addr);
|
|
}
|
|
}
|
|
|
|
/* Get all registers from current thread. */
|
|
|
|
static void
|
|
read_all_registers (struct chf$mech_array *mech)
|
|
{
|
|
struct _intstk *intstk =
|
|
(struct _intstk *)mech->chf$q_mch_esf_addr;
|
|
struct chf64$signal_array *sig64 =
|
|
(struct chf64$signal_array *)mech->chf$ph_mch_sig64_addr;
|
|
unsigned int cnt = sig64->chf64$w_sig_arg_count;
|
|
unsigned __int64 pc = (&sig64->chf64$q_sig_name)[cnt - 2];
|
|
|
|
excp_regs.ip.v = pc;
|
|
excp_regs.psr.v = intstk->intstk$q_ipsr;
|
|
/* GDB and linux expects bsp to point after the current register frame.
|
|
Adjust. */
|
|
{
|
|
unsigned __int64 bsp = intstk->intstk$q_bsp;
|
|
unsigned int sof = intstk->intstk$q_ifs & 0x7f;
|
|
unsigned int delta = ((bsp >> 3) & 0x3f) + sof;
|
|
excp_regs.bsp.v = bsp + ((sof + delta / 0x3f) << 3);
|
|
}
|
|
excp_regs.cfm.v = intstk->intstk$q_ifs & 0x3fffffffff;
|
|
excp_regs.pfs.v = intstk->intstk$q_pfs;
|
|
excp_regs.pr.v = intstk->intstk$q_preds;
|
|
excp_regs.gr[0].v = 0;
|
|
excp_regs.gr[1].v = intstk->intstk$q_gp;
|
|
excp_regs.gr[2].v = intstk->intstk$q_r2;
|
|
excp_regs.gr[3].v = intstk->intstk$q_r3;
|
|
excp_regs.gr[4].v = intstk->intstk$q_r4;
|
|
excp_regs.gr[5].v = intstk->intstk$q_r5;
|
|
excp_regs.gr[6].v = intstk->intstk$q_r6;
|
|
excp_regs.gr[7].v = intstk->intstk$q_r7;
|
|
excp_regs.gr[8].v = intstk->intstk$q_r8;
|
|
excp_regs.gr[9].v = intstk->intstk$q_r9;
|
|
excp_regs.gr[10].v = intstk->intstk$q_r10;
|
|
excp_regs.gr[11].v = intstk->intstk$q_r11;
|
|
excp_regs.gr[12].v = (unsigned __int64)intstk + intstk->intstk$l_stkalign;
|
|
excp_regs.gr[13].v = intstk->intstk$q_r13;
|
|
excp_regs.gr[14].v = intstk->intstk$q_r14;
|
|
excp_regs.gr[15].v = intstk->intstk$q_r15;
|
|
excp_regs.gr[16].v = intstk->intstk$q_r16;
|
|
excp_regs.gr[17].v = intstk->intstk$q_r17;
|
|
excp_regs.gr[18].v = intstk->intstk$q_r18;
|
|
excp_regs.gr[19].v = intstk->intstk$q_r19;
|
|
excp_regs.gr[20].v = intstk->intstk$q_r20;
|
|
excp_regs.gr[21].v = intstk->intstk$q_r21;
|
|
excp_regs.gr[22].v = intstk->intstk$q_r22;
|
|
excp_regs.gr[23].v = intstk->intstk$q_r23;
|
|
excp_regs.gr[24].v = intstk->intstk$q_r24;
|
|
excp_regs.gr[25].v = intstk->intstk$q_r25;
|
|
excp_regs.gr[26].v = intstk->intstk$q_r26;
|
|
excp_regs.gr[27].v = intstk->intstk$q_r27;
|
|
excp_regs.gr[28].v = intstk->intstk$q_r28;
|
|
excp_regs.gr[29].v = intstk->intstk$q_r29;
|
|
excp_regs.gr[30].v = intstk->intstk$q_r30;
|
|
excp_regs.gr[31].v = intstk->intstk$q_r31;
|
|
excp_regs.br[0].v = intstk->intstk$q_b0;
|
|
excp_regs.br[1].v = intstk->intstk$q_b1;
|
|
excp_regs.br[2].v = intstk->intstk$q_b2;
|
|
excp_regs.br[3].v = intstk->intstk$q_b3;
|
|
excp_regs.br[4].v = intstk->intstk$q_b4;
|
|
excp_regs.br[5].v = intstk->intstk$q_b5;
|
|
excp_regs.br[6].v = intstk->intstk$q_b6;
|
|
excp_regs.br[7].v = intstk->intstk$q_b7;
|
|
}
|
|
|
|
/* Write all registers to current thread. FIXME: not yet complete. */
|
|
|
|
static void
|
|
write_all_registers (struct chf$mech_array *mech)
|
|
{
|
|
struct _intstk *intstk =
|
|
(struct _intstk *)mech->chf$q_mch_esf_addr;
|
|
|
|
intstk->intstk$q_ipsr = excp_regs.psr.v;
|
|
}
|
|
|
|
/* Do debugging. Report status to gdb and execute commands. */
|
|
|
|
static void
|
|
do_debug (struct chf$mech_array *mech)
|
|
{
|
|
struct _intstk *intstk =
|
|
(struct _intstk *)mech->chf$q_mch_esf_addr;
|
|
unsigned int old_ast;
|
|
unsigned int old_sch;
|
|
unsigned int status;
|
|
|
|
/* Disable ast. */
|
|
status = sys$setast (0);
|
|
switch (status)
|
|
{
|
|
case SS$_WASCLR:
|
|
old_ast = 0;
|
|
break;
|
|
case SS$_WASSET:
|
|
old_ast = 1;
|
|
break;
|
|
default:
|
|
/* Should never happen! */
|
|
lib$signal (status);
|
|
}
|
|
|
|
/* Disable thread scheduling. */
|
|
if (has_threads)
|
|
old_sch = set_thread_scheduling (0);
|
|
|
|
read_all_registers (mech);
|
|
|
|
/* Send stop reply packet. */
|
|
packet_status ();
|
|
send_pkt ();
|
|
|
|
while (one_command () == 0)
|
|
;
|
|
|
|
write_all_registers (mech);
|
|
|
|
/* Re-enable scheduling. */
|
|
if (has_threads)
|
|
set_thread_scheduling (old_sch);
|
|
|
|
/* Re-enable AST. */
|
|
status = sys$setast (old_ast);
|
|
if (!(status & STS$M_SUCCESS))
|
|
LIB$SIGNAL (status);
|
|
}
|
|
|
|
/* The condition handler. That's the core of the stub. */
|
|
|
|
static int
|
|
excp_handler (struct chf$signal_array *sig,
|
|
struct chf$mech_array *mech)
|
|
{
|
|
struct chf64$signal_array *sig64 =
|
|
(struct chf64$signal_array *)mech->chf$ph_mch_sig64_addr;
|
|
unsigned int code = sig->chf$l_sig_name & STS$M_COND_ID;
|
|
unsigned int cnt = sig64->chf64$w_sig_arg_count;
|
|
unsigned __int64 pc;
|
|
unsigned int ret;
|
|
/* Self protection. FIXME: Should be per thread ? */
|
|
static int in_handler = 0;
|
|
|
|
/* Completely ignore some conditions (signaled indirectly by this stub). */
|
|
switch (code)
|
|
{
|
|
case LIB$_KEYNOTFOU & STS$M_COND_ID:
|
|
return SS$_RESIGNAL_64;
|
|
default:
|
|
break;
|
|
}
|
|
|
|
/* Protect against recursion. */
|
|
in_handler++;
|
|
if (in_handler > 1)
|
|
{
|
|
if (in_handler == 2)
|
|
TERM_FAO ("gdbstub: exception in handler (pc=!XH)!!!/",
|
|
(&sig64->chf64$q_sig_name)[cnt - 2]);
|
|
sys$exit (sig->chf$l_sig_name);
|
|
}
|
|
|
|
pc = (&sig64->chf64$q_sig_name)[cnt - 2];
|
|
if (trace_excp)
|
|
TERM_FAO ("excp_handler: code: !XL, pc=!XH!/", code, pc);
|
|
|
|
/* If break on the entry point, restore the bundle. */
|
|
if (code == (SS$_BREAK & STS$M_COND_ID)
|
|
&& pc == entry_pc
|
|
&& entry_pc != 0)
|
|
{
|
|
static unsigned int entry_prot;
|
|
|
|
if (trace_entry)
|
|
term_puts ("initial entry breakpoint\n");
|
|
page_set_rw (entry_pc, 16, &entry_prot);
|
|
|
|
ots$move ((void *)entry_pc, 16, entry_saved);
|
|
__fc (entry_pc);
|
|
page_restore_rw (entry_pc, 16, entry_prot);
|
|
}
|
|
|
|
switch (code)
|
|
{
|
|
case SS$_ACCVIO & STS$M_COND_ID:
|
|
if (trace_excp <= 1)
|
|
display_excp (sig64, mech);
|
|
/* Fall through. */
|
|
case SS$_BREAK & STS$M_COND_ID:
|
|
case SS$_OPCDEC & STS$M_COND_ID:
|
|
case SS$_TBIT & STS$M_COND_ID:
|
|
case SS$_DEBUG & STS$M_COND_ID:
|
|
if (trace_excp > 1)
|
|
{
|
|
int i;
|
|
struct _intstk *intstk =
|
|
(struct _intstk *)mech->chf$q_mch_esf_addr;
|
|
|
|
display_excp (sig64, mech);
|
|
|
|
TERM_FAO (" intstk: !XH!/", intstk);
|
|
for (i = 0; i < cnt + 1; i++)
|
|
TERM_FAO (" !XH!/", ((unsigned __int64 *)sig64)[i]);
|
|
}
|
|
do_debug (mech);
|
|
ret = SS$_CONTINUE_64;
|
|
break;
|
|
|
|
default:
|
|
display_excp (sig64, mech);
|
|
ret = SS$_RESIGNAL_64;
|
|
break;
|
|
}
|
|
|
|
in_handler--;
|
|
/* Discard selected thread registers. */
|
|
sel_regs_pthread = 0;
|
|
return ret;
|
|
}
|
|
|
|
/* Setup internal trace flags according to GDBSTUB$TRACE logical. */
|
|
|
|
static void
|
|
trace_init (void)
|
|
{
|
|
unsigned int status, i, start;
|
|
unsigned short len;
|
|
char resstring[LNM$C_NAMLENGTH];
|
|
static const $DESCRIPTOR (tabdesc, "LNM$DCL_LOGICAL");
|
|
static const $DESCRIPTOR (logdesc, "GDBSTUB$TRACE");
|
|
$DESCRIPTOR (sub_desc, resstring);
|
|
ILE3 item_lst[2];
|
|
|
|
item_lst[0].ile3$w_length = LNM$C_NAMLENGTH;
|
|
item_lst[0].ile3$w_code = LNM$_STRING;
|
|
item_lst[0].ile3$ps_bufaddr = resstring;
|
|
item_lst[0].ile3$ps_retlen_addr = &len;
|
|
item_lst[1].ile3$w_length = 0;
|
|
item_lst[1].ile3$w_code = 0;
|
|
|
|
/* Translate the logical name. */
|
|
status = SYS$TRNLNM (0, /* Attributes of the logical name. */
|
|
(void *)&tabdesc, /* Logical name table. */
|
|
(void *)&logdesc, /* Logical name. */
|
|
0, /* Access mode. */
|
|
&item_lst); /* Item list. */
|
|
if (status == SS$_NOLOGNAM)
|
|
return;
|
|
if (!(status & STS$M_SUCCESS))
|
|
LIB$SIGNAL (status);
|
|
|
|
start = 0;
|
|
for (i = 0; i <= len; i++)
|
|
{
|
|
if ((i == len || resstring[i] == ',' || resstring[i] == ';')
|
|
&& i != start)
|
|
{
|
|
int j;
|
|
|
|
sub_desc.dsc$a_pointer = resstring + start;
|
|
sub_desc.dsc$w_length = i - start;
|
|
|
|
for (j = 0; j < NBR_DEBUG_FLAGS; j++)
|
|
if (str$case_blind_compare (&sub_desc,
|
|
(void *)&debug_flags[j].name) == 0)
|
|
{
|
|
debug_flags[j].val++;
|
|
break;
|
|
}
|
|
if (j == NBR_DEBUG_FLAGS)
|
|
TERM_FAO ("GDBSTUB$TRACE: unknown directive !AS!/", &sub_desc);
|
|
|
|
start = i + 1;
|
|
}
|
|
}
|
|
|
|
TERM_FAO ("GDBSTUB$TRACE=!AD ->", len, resstring);
|
|
for (i = 0; i < NBR_DEBUG_FLAGS; i++)
|
|
if (debug_flags[i].val > 0)
|
|
TERM_FAO (" !AS=!ZL", &debug_flags[i].name, debug_flags[i].val);
|
|
term_putnl ();
|
|
}
|
|
|
|
|
|
/* Entry point. */
|
|
|
|
static int
|
|
stub_start (unsigned __int64 *progxfer, void *cli_util,
|
|
EIHD *imghdr, IFD *imgfile,
|
|
unsigned int linkflag, unsigned int cliflag)
|
|
{
|
|
static int initialized;
|
|
int i;
|
|
int cnt;
|
|
int is_attached;
|
|
IMCB *imcb;
|
|
if (initialized)
|
|
term_puts ("gdbstub: re-entry\n");
|
|
else
|
|
initialized = 1;
|
|
|
|
/* When attached (through SS$_DEBUG condition), the number of arguments
|
|
is 4 and PROGXFER is the PC at interruption. */
|
|
va_count (cnt);
|
|
is_attached = cnt == 4;
|
|
|
|
term_init ();
|
|
|
|
/* Hello banner. */
|
|
term_puts ("Hello from gdb stub\n");
|
|
|
|
trace_init ();
|
|
|
|
if (trace_entry && !is_attached)
|
|
{
|
|
TERM_FAO ("xfer: !XH, imghdr: !XH, ifd: !XH!/",
|
|
progxfer, imghdr, imgfile);
|
|
for (i = -2; i < 8; i++)
|
|
TERM_FAO (" at !2SW: !XH!/", i, progxfer[i]);
|
|
}
|
|
|
|
/* Search for entry point. */
|
|
if (!is_attached)
|
|
{
|
|
entry_pc = 0;
|
|
for (i = 0; progxfer[i]; i++)
|
|
entry_pc = progxfer[i];
|
|
|
|
if (trace_entry)
|
|
{
|
|
if (entry_pc == 0)
|
|
{
|
|
term_puts ("No entry point\n");
|
|
return 0;
|
|
}
|
|
else
|
|
TERM_FAO ("Entry: !XH!/",entry_pc);
|
|
}
|
|
}
|
|
else
|
|
entry_pc = progxfer[0];
|
|
|
|
has_threads = 0;
|
|
for (imcb = ctl$gl_imglstptr->imcb$l_flink;
|
|
imcb != ctl$gl_imglstptr;
|
|
imcb = imcb->imcb$l_flink)
|
|
{
|
|
if (ots$strcmp_eql (pthread_rtl_desc.dsc$a_pointer,
|
|
pthread_rtl_desc.dsc$w_length,
|
|
imcb->imcb$t_log_image_name + 1,
|
|
imcb->imcb$t_log_image_name[0]))
|
|
has_threads = 1;
|
|
|
|
if (trace_images)
|
|
{
|
|
unsigned int j;
|
|
LDRIMG *ldrimg = imcb->imcb$l_ldrimg;
|
|
LDRISD *ldrisd;
|
|
|
|
TERM_FAO ("!XA-!XA ",
|
|
imcb->imcb$l_starting_address,
|
|
imcb->imcb$l_end_address);
|
|
|
|
switch (imcb->imcb$b_act_code)
|
|
{
|
|
case IMCB$K_MAIN_PROGRAM:
|
|
term_puts ("prog");
|
|
break;
|
|
case IMCB$K_MERGED_IMAGE:
|
|
term_puts ("mrge");
|
|
break;
|
|
case IMCB$K_GLOBAL_IMAGE_SECTION:
|
|
term_puts ("glob");
|
|
break;
|
|
default:
|
|
term_puts ("????");
|
|
}
|
|
TERM_FAO (" !AD !40AC!/",
|
|
1, "KESU" + (imcb->imcb$b_access_mode & 3),
|
|
imcb->imcb$t_log_image_name);
|
|
|
|
if ((long) ldrimg < 0 || trace_images < 2)
|
|
continue;
|
|
ldrisd = ldrimg->ldrimg$l_segments;
|
|
for (j = 0; j < ldrimg->ldrimg$l_segcount; j++)
|
|
{
|
|
unsigned int flags = ldrisd[j].ldrisd$i_flags;
|
|
term_puts (" ");
|
|
term_putc (flags & 0x04 ? 'R' : '-');
|
|
term_putc (flags & 0x02 ? 'W' : '-');
|
|
term_putc (flags & 0x01 ? 'X' : '-');
|
|
term_puts (flags & 0x01000000 ? " Prot" : " ");
|
|
term_puts (flags & 0x04000000 ? " Shrt" : " ");
|
|
term_puts (flags & 0x08000000 ? " Shrd" : " ");
|
|
TERM_FAO (" !XA-!XA!/",
|
|
ldrisd[j].ldrisd$p_base,
|
|
(unsigned __int64) ldrisd[j].ldrisd$p_base
|
|
+ ldrisd[j].ldrisd$i_len - 1);
|
|
}
|
|
ldrisd = ldrimg->ldrimg$l_dyn_seg;
|
|
if (ldrisd)
|
|
TERM_FAO (" dynamic !XA-!XA!/",
|
|
ldrisd->ldrisd$p_base,
|
|
(unsigned __int64) ldrisd->ldrisd$p_base
|
|
+ ldrisd->ldrisd$i_len - 1);
|
|
}
|
|
}
|
|
|
|
if (has_threads)
|
|
threads_init ();
|
|
|
|
/* Wait for connection. */
|
|
sock_init ();
|
|
|
|
/* Set primary exception vector. */
|
|
{
|
|
unsigned int status;
|
|
status = sys$setexv (0, excp_handler, PSL$C_USER, (__void_ptr32) &prevhnd);
|
|
if (!(status & STS$M_SUCCESS))
|
|
LIB$SIGNAL (status);
|
|
}
|
|
|
|
if (is_attached)
|
|
{
|
|
return excp_handler ((struct chf$signal_array *) progxfer[2],
|
|
(struct chf$mech_array *) progxfer[3]);
|
|
}
|
|
|
|
/* Change first instruction to set a breakpoint. */
|
|
{
|
|
/*
|
|
01 08 00 40 00 00 [MII] break.m 0x80001
|
|
00 00 00 02 00 00 nop.i 0x0
|
|
00 00 04 00 nop.i 0x0;;
|
|
*/
|
|
static const unsigned char initbp[16] =
|
|
{ 0x01, 0x08, 0x00, 0x40, 0x00, 0x00,
|
|
0x00, 0x00, 0x00, 0x02, 0x00, 0x00,
|
|
0x00, 0x00, 0x04, 0x00 };
|
|
unsigned int entry_prot;
|
|
unsigned int status;
|
|
|
|
status = page_set_rw (entry_pc, 16, &entry_prot);
|
|
|
|
if (!(status & STS$M_SUCCESS))
|
|
{
|
|
if ((status & STS$M_COND_ID) == (SS$_NOT_PROCESS_VA & STS$M_COND_ID))
|
|
{
|
|
/* Cannot write here. This can happen when pthreads are
|
|
used. */
|
|
entry_pc = 0;
|
|
term_puts ("gdbstub: cannot set breakpoint on entry\n");
|
|
}
|
|
else
|
|
LIB$SIGNAL (status);
|
|
}
|
|
|
|
if (entry_pc != 0)
|
|
{
|
|
ots$move (entry_saved, 16, (void *)entry_pc);
|
|
ots$move ((void *)entry_pc, 16, (void *)initbp);
|
|
__fc (entry_pc);
|
|
page_restore_rw (entry_pc, 16, entry_prot);
|
|
}
|
|
}
|
|
|
|
/* If it wasn't possible to set a breakpoint on the entry point,
|
|
accept gdb commands now. Note that registers are not updated. */
|
|
if (entry_pc == 0)
|
|
{
|
|
while (one_command () == 0)
|
|
;
|
|
}
|
|
|
|
/* We will see! */
|
|
return SS$_CONTINUE;
|
|
}
|
|
|
|
/* Declare the entry point of this relocatable module. */
|
|
|
|
struct xfer_vector
|
|
{
|
|
__int64 impure_start;
|
|
__int64 impure_end;
|
|
int (*entry) ();
|
|
};
|
|
|
|
#pragma __extern_model save
|
|
#pragma __extern_model strict_refdef "XFER_PSECT"
|
|
struct xfer_vector xfer_vector = {0, 0, stub_start};
|
|
#pragma __extern_model restore
|