diff options
Diffstat (limited to 'gdb')
| -rw-r--r-- | gdb/config/a29k/a29k-udi.mt | 2 | ||||
| -rw-r--r-- | gdb/config/arc/arc.mt | 4 | ||||
| -rw-r--r-- | gdb/config/i960/vxworks960.mt | 4 | ||||
| -rw-r--r-- | gdb/configure.in | 8 | ||||
| -rw-r--r-- | gdb/remote-nrom.c | 1356 |
5 files changed, 1371 insertions, 3 deletions
diff --git a/gdb/config/a29k/a29k-udi.mt b/gdb/config/a29k/a29k-udi.mt index d0cac1a..6d5d27b 100644 --- a/gdb/config/a29k/a29k-udi.mt +++ b/gdb/config/a29k/a29k-udi.mt @@ -3,6 +3,6 @@ TDEPFILES= a29k-tdep.o remote-udi.o udip2soc.o udr.o udi2go32.o TM_FILE= tm-a29k.h # Disable standard remote support. -REMOTE_O= +REMOTE_OBS= MT_CFLAGS = $(HOST_IPC) diff --git a/gdb/config/arc/arc.mt b/gdb/config/arc/arc.mt index 6b2dc12..6a8379b 100644 --- a/gdb/config/arc/arc.mt +++ b/gdb/config/arc/arc.mt @@ -1,5 +1,7 @@ # Target: arc processor TDEPFILES= arc-tdep.o remote-arc.o TM_FILE= tm-arc.h -REMOTE_O=dcache.o remote-utils.o + +REMOTE_OBS= dcache.o remote-utils.o + SER_HARDWIRE= ser-go32-para.o diff --git a/gdb/config/i960/vxworks960.mt b/gdb/config/i960/vxworks960.mt index 6501f4a..3623804 100644 --- a/gdb/config/i960/vxworks960.mt +++ b/gdb/config/i960/vxworks960.mt @@ -1,8 +1,10 @@ # Target: VxWorks running on an Intel 960 TDEPFILES= i960-tdep.o remote-vx.o remote-vx960.o xdr_ld.o xdr_ptrace.o xdr_rdb.o TM_FILE= tm-vx960.h + # Define this for the vx-share routines, which don't see param.h. MT_CFLAGS= -DI80960 + # Don't use remote.o; it doesn't compile (and won't work) due to lack of # BREAKPOINT. -REMOTE_O=dcache.o remote-utils.o +REMOTE_OBS= dcache.o remote-utils.o diff --git a/gdb/configure.in b/gdb/configure.in index 52cebd8..cf76597 100644 --- a/gdb/configure.in +++ b/gdb/configure.in @@ -466,6 +466,14 @@ ENABLE_CLIBS = $(TCL) $(TK) $(X11_LIB_SWITCHES) $(X11_LIBS) -lm fi # end-sanitize-gdbtk +if [ "${enable_netrom}" = "yes" ] ; then + sed -e '/# End of host and/i\ +\ +NETROM_OBS = remote-nrom.o\ +' < Makefile > Makefile.tem + mv -f Makefile.tem Makefile +fi + sed -e '/^TM_FILE[ ]*=/s,^TM_FILE[ ]*=[ ]*,&config/'"${gdb_target_cpu}"'/, /^XM_FILE[ ]*=/s,^XM_FILE[ ]*=[ ]*,&config/'"${gdb_host_cpu}"'/, /^NAT_FILE[ ]*=/s,^NAT_FILE[ ]*=[ ]*,&config/'"${gdb_host_cpu}"'/,' <Makefile >Makefile.tmp diff --git a/gdb/remote-nrom.c b/gdb/remote-nrom.c new file mode 100644 index 0000000..1699d4c --- /dev/null +++ b/gdb/remote-nrom.c @@ -0,0 +1,1356 @@ +/* Remote debugging with the XLNT Designs, Inc (XDI) NetROM. + Copyright 1990, 1991, 1992, 1995 Free Software Foundation, Inc. + Contributed by: + Roger Moyers + XLNT Designs, Inc. + 15050 Avenue of Science, Suite 106 + San Diego, CA 92128 + (619)487-9320 + roger@xlnt.com + Adapted from work done at Cygnus Support in remote-nindy.c, + later merged in by Stan Shebs at Cygnus. + +This file is part of GDB. + +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, write to the Free Software +Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */ + +#include "defs.h" +#include "gdbcmd.h" +#include <string.h> +#include "inferior.h" +#include "wait.h" +#include "value.h" +#include <ctype.h> +#include <fcntl.h> +#include <signal.h> +#include <errno.h> +#include <stropts.h> +#include <sys/types.h> +#include <sys/socket.h> +#include <sys/ioctl.h> +#include <netinet/in.h> +#include <netdb.h> +#include <unistd.h> +#include "terminal.h" +#include "target.h" +#include "gdbcore.h" + +/* Packet header found on every packet sent to/from GDB. */ + +typedef struct gpkthdr { + unsigned char csum; /* Check sum */ + unsigned char seq_num; /* Sequence number */ + unsigned short len; /* Number of bytes in packet */ + unsigned char cmd; /* GDB command */ + unsigned char pad[3]; + unsigned long addr; /* Address if needed */ + unsigned long datalen; /* # of bytes to read/write */ +} GPKTHDR; + +#define GDB_START_DELIMITER '[' +#define GDB_END_DELIMITER ']' + +/* GDB requests. */ + +#define GDB_QUERY_CMD 0x01 +#define GDB_STATUS 0x02 +#define GDB_READ_REGS 0x03 +#define GDB_WRITE_REGS 0x04 +#define GDB_READ_MEM 0x05 +#define GDB_WRITE_MEM 0x06 +#define GDB_CONTINUE 0x07 +#define GDB_STEP 0x08 + +/* Responses. */ + +#define GDB_ACK 0x11 +#define GDB_NACK 0x12 +#define GDB_READ_REG_RESP 0x13 +#define GDB_READ_MEM_RESP 0x14 +#define GDB_WRITE_REG_RESP 0x15 +#define GDB_WRITE_MEM_RESP 0x16 + +#define GDB_BP_TRAP "05" +#define GDB_BUSERR_TRAP "10" +#define GDB_ILLOP_TRAP "40" + +#define GDB_ACK_VALUE "OK" + +/* Default ports used to talk with the NetROM. */ + +#define DEFAULT_NETROM_TARGET_PORT 1235 +#define DEFAULT_NETROM_LOAD_PORT 1236 +#define DEFAULT_NETROM_CONTROL_PORT 1237 + +#define UC(b) (((long)b)&0xff) + +#define NROM_BUF_SIZE 2048 +#define MAX_SEND_ATTEMPTS 10 +#define READ_BUF_SIZE 2048 + +/* Definitions for filetype. */ + +#define BINARY_FTYPE 0 +#define MOTO_SREC 1 +#define INTEL_HEX 2 + +#if 0 /* for debugging, if anyone cares */ +static char *GCMDTYPE[] = { + "ZERO", + "GDB_QUERY", + "GDB_STATUS", + "GDB_READ_REGS", + "GDB_WRITE_REGS", + "GDB_READ_MEM", + "GDB_WRITE_MEM", + "GDB_CONTINUE", + "GDB_STEP", + "CMD9", + "CMDA", + "CMDB", + "CMDC", + "CMDD", + "CMDE", + "CMDF", + "RESP0", + "GDB_ACK", + "GDB_NACK", + "GDB_READ_REG_RESP", + "GDB_READ_MEM_RESP", + "GDB_WRITE_REG_RESP", + "GDB_WRITE_MEM_RESP" +}; +#endif + +static void nrom_attach PARAMS ((char *, int)); + +static int nrom_can_run PARAMS ((void)); + +static void nrom_close PARAMS ((int)); + +static void nrom_create_inferior PARAMS ((char *, char *, char **)); + +static void nrom_detach PARAMS ((char *, int)); + +static void nrom_fetch_registers PARAMS ((int)); + +static void nrom_files_info PARAMS ((struct target_ops *)); + +static void nrom_kill PARAMS ((void)); + +static void nrom_load PARAMS ((char *, int)); + +static void nrom_mourn PARAMS ((void)); + +static void nrom_open PARAMS ((char *,int)); + +static void nrom_resume PARAMS ((int, int, enum target_signal)); + +static void nrom_prepare_to_store PARAMS ((void)); + +static void nrom_store_registers PARAMS ((int)); + +static int nrom_wait PARAMS ((int pid, struct target_waitstatus *status)); + +static int nrom_xfer_inferior_memory PARAMS ((CORE_ADDR, char *, int, int, + struct target_ops *)); + +static int nrom_write_inferior_memory PARAMS ((CORE_ADDR, char *, int)); + +static int nrom_read_inferior_memory PARAMS ((CORE_ADDR, char *, int)); + +/* New commands. */ + +static void nrom_set_target_port PARAMS ((char *, int)); + +static void nrom_set_control_port PARAMS ((char *, int)); + +static void nrom_set_load_port PARAMS ((char *, int)); + +static void nrom_set_ipaddr PARAMS ((char *, int)); + +static void nrom_set_filetype PARAMS ((char *, int)); + +static void nrom_show_status PARAMS ((char *, int)); + +static void nrom_passthru PARAMS ((char *, int)); + +/* Packet functions. */ + +static void build_pkt PARAMS ((int, unsigned char *, long, + unsigned char *, unsigned long, unsigned long, + int)); + +static int compute_csum PARAMS ((unsigned char *, int)); + +#if 0 +static void dump_pkt PARAMS ((GPKTHDR *, unsigned char *)); +#endif + +static int get_seq_number PARAMS ((void)); + +static char *hex2mem PARAMS ((char *, char *, int)); + +static char *mem2hex PARAMS ((char *, char *, int)); + +static void nrom_send PARAMS ((int, char *, int, long, long, char *)); + +static void send_query_cmd PARAMS ((void)); + +static int send_pkt PARAMS ((int, char *, int, long, int)); + +static int read_pkt PARAMS ((char *)); + +static void send_query_cmd PARAMS ((void)); + +static int tohex PARAMS ((int)); + +static int parse_pkt PARAMS ((unsigned char *, GPKTHDR *, char *)); + +static int writen PARAMS ((int, char *, int)); + +/* Private globals. */ + +/* We talk to the NetROM over these sockets. */ + +static int nrom_load_sock = -1; +static int nrom_targ_sock = -1; +static int nrom_ctrl_sock = -1; + +/* For binding to the socket we ned a sockaddr_in structure. */ + +static struct sockaddr_in nrom_sin; + +/* The IP Address of the NetROM is needed so we know who to talk to. */ + +static unsigned long nrom_ipaddr = 0; + +static int load_port = DEFAULT_NETROM_LOAD_PORT; +static int target_port = DEFAULT_NETROM_TARGET_PORT; +static int control_port = DEFAULT_NETROM_CONTROL_PORT; + +static int nrom_filetype = BINARY_FTYPE; + +static unsigned char host_seq_num = 0; + +static char hexchars[] = "0123456789abcdef"; + +static char freadbuf[READ_BUF_SIZE]; + +static char readbuf[NROM_BUF_SIZE]; +static int bufdata = 0; +static int bufindex = 0; + +static char workbuf[NROM_BUF_SIZE]; +static char sendbuf[NROM_BUF_SIZE]; + +/* Forward data declaration. */ + +extern struct target_ops nrom_ops; + +/* This routine builds a packet to send to gdb running on the host. */ + +static void +build_pkt (cmd, data, datalen, pkt, addr, len, seq) + int cmd; + unsigned char *data; + long datalen; + unsigned char *pkt; + unsigned long addr; + unsigned long len; + int seq; +{ + GPKTHDR phdr; + char *dptr; + char *pktptr; + unsigned char csum; + int plen; + + phdr.csum = 0; + phdr.len = sizeof(GPKTHDR) + datalen; + phdr.seq_num = seq; + phdr.cmd = cmd; + phdr.pad[0] = phdr.pad[1] = phdr.pad[2] = 0; + phdr.addr = addr; + phdr.datalen = len; + /* Convert packet header to ASCII. */ + dptr = mem2hex ((char *) &phdr, pkt, sizeof(GPKTHDR)); + + /* Calculate pkt length now that it is converted. */ + plen = (int) ((unsigned long)dptr - (unsigned long)pkt) + datalen; + /* Put data in packet. */ + if (datalen > 0) + memcpy (dptr, data, datalen); + + /* Compute checksum. For computing checksum we skip first two bytes + since this is where the checksum will go. */ + pktptr = pkt + 2; + csum = compute_csum (pktptr, plen - 2); + *pkt++ = hexchars[csum >> 4]; + *pkt++ = hexchars[csum % 16]; + dptr += datalen; + *dptr = '\0'; +} + +static int +compute_csum (data, len) + unsigned char *data; + int len; +{ + unsigned char csum; + + csum = 0; + while (len > 0) + { + csum += *data++; + --len; + } + return csum; +} + +#if 0 /* for debugging, if anyone cares */ +static void +dump_pkt (hdr, data) + GPKTHDR *hdr; + unsigned char *data; +{ + int i; + + printf_filtered ("PACKET: csum = %x,seq = %d,len = %d\n",hdr->csum,hdr->seq_num, + hdr->len); + + printf_filtered ("cmd = %s,addr = %x, datalen = %d\n", GCMDTYPE[hdr->cmd], + hdr->addr,hdr->datalen); + if (hdr->datalen) + { + for (i = 0; i < hdr->datalen * 2; i++) + printf_filtered ("%x",data[i]); + printf_filtered ("\n"); + } +} +#endif + +static int +get_seq_number() +{ + return host_seq_num++; +} + +int +hex (ch) + int ch; +{ + if ((ch >= 'a') && (ch <= 'f')) + return (ch - 'a' + 10); + if((ch >= 'A') && (ch <= 'F')) + return ((ch - 'A') + 10); + if ((ch >= '0') && (ch <= '9')) + return (ch - '0'); + return 0; +} + +/* Convert the hex array pointed to by buf into binary to be placed in mem + return a pointer to the character AFTER the last byte written. */ + +static char* +hex2mem(buf, mem, count) + char* buf; + char* mem; + int count; +{ + int i; + unsigned char ch; + + for (i = 0; i < count; i++) + { + ch = hex(*buf++) << 4; + ch = ch + hex(*buf++); + *mem++ = ch; + } + return mem; +} + +/* Convert the memory pointed to by mem into hex, placing result in buf + return a pointer to the last char put in buf (null) */ + +static char * +mem2hex (mem, buf, count) + char* mem; + char* buf; + int count; +{ + int i; + unsigned char ch; + + for (i = 0; i < count; i++) + { + ch = *mem++; + *buf++ = hexchars[ch >> 4]; + *buf++ = hexchars[ch % 16]; + } + *buf = 0; + return buf; +} + +static int +nrom_control_send (s, nbytes) + char *s; + int nbytes; +{ + long len; + char buf[10]; + + /* clear leading characters */ + /* FIXME: The ioctl uses here seem bogus to me. -sts */ + len = 1; + while (len > 0) + { + if (ioctl (nrom_ctrl_sock, FIONREAD, &len) < 0) + { + perror ("nrom_control_send ioctl"); + return (-1); + } + if (len > 0) + { + if (read (nrom_ctrl_sock, buf, 1) < 0) + { + perror ("nrom_control_send read"); + return (-1); + } + } + } + + if (remote_debug) + printf_filtered ("nrom_control_send: sending '%s' (%d bytes) to NetROM\n", + s, nbytes); + + if (writen (nrom_ctrl_sock, s, nbytes) < 0) + { + perror ("nrom_control_send"); + return (-1); + } + + /* clear trailing characters */ + len = 1; + while (len > 0) + { + if (ioctl (nrom_ctrl_sock, FIONREAD, &len) < 0) + { + perror ("nrom_control_send ioctl"); + return (-1); + } + if (len > 0) + { + if (read (nrom_ctrl_sock, buf, 1) < 0) + { + perror ("nrom_control_send read"); + return (-1); + } + } + } + return 0; +} + +static void +nrom_kill () +{ +} + +/* Download a file specified in ARGS to the netROM. */ + +static void +nrom_load (args, fromtty) + char *args; + int fromtty; +{ + int fd, rd_amt, fsize; + struct sockaddr_in sin; + bfd *pbfd; + asection *section; + char *downloadstring = "download 0\n"; + + /* Tell the netrom to get ready to download. */ + if (nrom_control_send (downloadstring, strlen (downloadstring)) < 0) + error ("nrom_load: control_send() of `%s' failed", downloadstring); + + /* Wait for the download daemon to start up. */ + sleep (1); + + nrom_load_sock = socket (AF_INET, SOCK_STREAM, 0); + if (nrom_load_sock == -1) + error ("Could not create download socket, error %d", errno); + + memset (&sin, 0, sizeof(struct sockaddr_in)); + sin.sin_family = AF_INET; + sin.sin_port = htons (load_port); + sin.sin_addr.s_addr = htonl (nrom_ipaddr); + + if (connect (nrom_load_sock, &sin, sizeof(sin)) == -1) + error ("Connect failed, error %d", errno); + + pbfd = bfd_openr (args, 0); + + if (pbfd) + { + if (!bfd_check_format (pbfd, bfd_object)) + error ("\"%s\": not in executable format: %s", + args, bfd_errmsg (bfd_get_error ())); + + for (section = pbfd->sections; section; section = section->next) + { + if (bfd_get_section_flags (pbfd, section) & SEC_ALLOC) + { + bfd_vma section_address; + unsigned long section_size; + const char *section_name; + + section_name = bfd_get_section_name (pbfd, section); + section_address = bfd_get_section_vma (pbfd, section); + section_size = bfd_section_size (pbfd, section); + + if (bfd_get_section_flags (pbfd, section) & SEC_LOAD) + { + file_ptr fptr; + + printf_filtered ("[Loading section %s at %x (%d bytes)]\n", + section_name, section_address, + section_size); + + fptr = 0; + + while (section_size > 0) + { + char buffer[1024]; + int count; + + count = min (section_size, 1024); + + bfd_get_section_contents (pbfd, section, buffer, fptr, + count); + + writen (nrom_load_sock, buffer, count); + section_address += count; + fptr += count; + section_size -= count; + } + } + else /* BSS and such */ + { + printf_filtered ("[section %s: not loading]\n", + section_name); + } + } + } + } + else + error ("\"%s\": Could not open", args); + + close (nrom_load_sock); +} + +/* This is called not only when we first attach, but also when the + user types "run" after having attached. */ + +static void +nrom_create_inferior (execfile, args, env) + char *execfile; + char *args; + char **env; +{ +} + +/* Open a connection to the remote NetROM devices. */ + +static void +nrom_open (name, from_tty) + char *name; + int from_tty; +{ + int errn; + + if (name) + nrom_set_ipaddr (name, from_tty); + else if (nrom_ipaddr == 0) + error ( +"To open a NetROM connection, you must specify the hostname\n\ +or IP address of the NetROM device you wish to use."); + + push_target (&nrom_ops); + + /* Create the socket used for talking with the target. */ + nrom_targ_sock = socket (AF_INET, SOCK_STREAM, 0); + + /* Bind the socket. */ + nrom_sin.sin_family = AF_INET; + nrom_sin.sin_port = htons (target_port); + nrom_sin.sin_addr.S_un.S_addr = htonl (nrom_ipaddr); + + /* Connect to the remote host. */ + if (connect (nrom_targ_sock, &nrom_sin, sizeof(nrom_sin)) == -1) + error ("Connect failed, error %d", errno); + + /* Create the socket used for talking with the debugger services. */ + nrom_ctrl_sock = socket (AF_INET, SOCK_STREAM, 0); + + /* Bind the socket. */ + nrom_sin.sin_family = AF_INET; + nrom_sin.sin_port = htons (control_port); + nrom_sin.sin_addr.S_un.S_addr = htonl (nrom_ipaddr); + + /* Connect to the remote host. */ + if (connect (nrom_ctrl_sock, &nrom_sin, sizeof(nrom_sin)) == -1) + { + errn = errno; + close (nrom_targ_sock); + error ("Connect control_socket failed, error %d", errn); + } + + if (from_tty) + { + unsigned char *i; + + printf_filtered ("Connected to NetROM device \"%s\"", name); + i = (unsigned char *) &nrom_ipaddr; + printf_filtered (" (%d.%d.%d.%d)\n", + UC(i[0]), UC(i[1]), UC(i[2]), UC(i[3])); + } +} + +static int +nrom_can_run () +{ + return 1; +} + +/* Close out all files and local state before this target loses control. */ + +static void +nrom_close (quitting) + int quitting; +{ +} + +/* Attach to the target that is already loaded and possibly running */ + +static void +nrom_attach (args, from_tty) + char *args; + int from_tty; +{ + int nwaiting; + char buf[10]; + + if (from_tty) + printf_filtered ("Attaching to NetROM\n"); + + /* clear any pending data on the socket */ + printf_filtered ("Waiting for pending data to arrive... "); + fflush(stdout); + sleep(1); + printf_filtered ("that's long enough!\n"); + while (1) + { + if (ioctl(nrom_targ_sock, FIONREAD, &nwaiting) != 0) + { + /* couldn't determine data left */ + perror("nrom_attach: ioctl FIONREAD"); + break; + } + else if (nwaiting > 0) + { + /* flush incoming data */ + while (nwaiting != 0) + { + if (read (nrom_targ_sock, buf, 1) < 0) + { + perror("nrom_attach: read"); + exit(1); + } + if (remote_debug > 2) + putc(buf[0], stdout); + nwaiting--; + } + } + else + { + /* no more data */ + break; + } + } + printf_filtered ("Pending data removed\n"); + + /* We will get a task spawn event immediately. */ + send_query_cmd (); + target_has_execution = 1; +/* + start_remote(); +*/ +} + +/* Terminate the open connection to the remote debugger. Use this + when you want to detach and do something else with your gdb. */ + +static void +nrom_detach (args, from_tty) + char *args; + int from_tty; +{ + pop_target (); + if (from_tty) + printf_filtered ("Ending remote debugging\n"); +} + +/* Tell the remote machine to resume. */ + +static void +nrom_prepare_to_store() +{ +} + +static void +nrom_resume (pid, step, siggnal) + int pid, step; + enum target_signal siggnal; +{ + if (step) + send_pkt (GDB_STEP, NULL, 0, 0, 0); + else + send_pkt (GDB_CONTINUE, NULL, 0, 0, 0); +} + +/* Wait until the remote machine stops, then return, + storing status in STATUS just as `wait' would. */ + +static int +nrom_wait (pid, status) + int pid; + struct target_waitstatus *status; +{ + static char pkt[NROM_BUF_SIZE], inbuf[NROM_BUF_SIZE]; + GPKTHDR phdr; + + status->kind = TARGET_WAITKIND_EXITED; + status->value.integer = 0; + + while (1) + { + if (read_pkt (pkt) == -1) + continue; + + if (parse_pkt (pkt, &phdr, inbuf) < 0) + { + if (remote_debug) + printf_filtered ("Bad packet in nrom_wait\n"); + send_query_cmd (); + continue; + } + + /* Got good packet. Verify command is right. */ + if (phdr.cmd != GDB_STATUS) + { + /* Wrong response. Resend command. */ + send_query_cmd (); + continue; + } + /* Packet is fine. Exit loop. */ + return inferior_pid; + } +} + +/* Read the remote registers. */ + +static void +nrom_fetch_registers (regno) + int regno; +{ + char buf[NROM_BUF_SIZE]; + char regs[REGISTER_BYTES]; + int i; + +#ifdef DEBUG + printf_filtered ("reg no is %d\n",regno); +#endif + + nrom_send (GDB_READ_REGS, NULL, 0, -1, 0, buf); + memcpy (regs, buf, REGISTER_BYTES); + for (i = 0; i < NUM_REGS; i++) + supply_register (i, ®s[REGISTER_BYTE(i)]); +#ifdef NO_SINGLE_REG + nrom_send (GDB_READ_REGS, NULL, 0, regno, 0, buf); + if (regno != -1) + supply_register(regno,buf); + else + { + memcpy (regs, buf, REGISTER_BYTES); + for (i = 0; i < NUM_REGS; i++) + supply_register (i, ®s[REGISTER_BYTE(i)]); + } +#endif +} + +static void +nrom_send (cmd, data, datalen, addr, len, resp) + int cmd; + char *data; + int datalen; + long addr; + long len; + char *resp; +{ + GPKTHDR phdr; + char inbuf[NROM_BUF_SIZE]; + + while (1) + { + while (send_pkt (cmd, data, datalen, addr, len) < 0) + ; + if (read_pkt (inbuf) != -1) + { + if (parse_pkt (inbuf, &phdr, resp) < 0) + continue; + if (phdr.cmd != GDB_NACK) + return; + } + } +} + +static void +nrom_set_filetype (args, fromtty) + char *args; + int fromtty; +{ + if (args[0] == 'b') + nrom_filetype = BINARY_FTYPE; + else if (args[0] == 'm') + nrom_filetype = MOTO_SREC; + else if (args[0] == 'i') + nrom_filetype = INTEL_HEX; + else + printf_filtered ("Unknown file type\n"); +} + +static void +nrom_set_ipaddr (args, fromtty) + char *args; + int fromtty; +{ + struct hostent *h; + char buf[10]; + int i,j,val; + unsigned long newip = 0; + + /* First do a check to see if they typed in a hostname. */ + if (!(*args)) + error ("Please enter a hostname or IP address"); + + h = gethostbyname (args); + if (h) + { + /* It is a hostname. We just need the ipaddress. */ + memcpy (&nrom_ipaddr, h->h_addr, h->h_length); + } + else + { + /* Better be in decimal dot notation,ie. xx.xx.xx.xx */ + if (isdigit (args[0]) && strchr (args, '.')) + { + j = 4; + while (j) + { + memset (buf, 0, 10); + i = 0; + while((*args) && (*args != '.')) + { + buf[i] = *args++; + i++; + } + if (i) + { + val = (int) strtol (buf, NULL, 10); + + if (val > 255) + error ("Invalid IP address"); + + j--; + newip |= val << (8 * j); + args++; + } + } + } + else + { + error ("Invalid host name/address"); + } + nrom_ipaddr = newip; + } +} + +static void +nrom_set_load_port (args, fromtty) + char *args; + int fromtty; +{ + load_port = (int) strtol (args, NULL, 10); +} + +static void +nrom_set_target_port (args, from_tty) + char *args; + int from_tty; +{ + target_port = (int) strtol (args, NULL, 10); +} + +static void +nrom_set_control_port (args, fromtty) + char *args; + int fromtty; +{ + control_port = (int) strtol (args, NULL, 10); +} + +static void +nrom_show_status (args,from_tty) + char *args; + int from_tty; +{ + unsigned char *i; + + i = (unsigned char *)&nrom_ipaddr; + + printf_filtered ("NetROM target port is %d\n", target_port); + printf_filtered ("NetROM download port is %d\n", load_port); + printf_filtered ("NetROM debug control port is %d\n", control_port); + + printf_filtered ("NetROM IP Address is %d.%d.%d.%d\n", + UC(i[0]), UC(i[1]), UC(i[2]), UC(i[3])); + if (nrom_filetype == BINARY_FTYPE) + printf_filtered ("download filetype is binary\n"); + else if (nrom_filetype == MOTO_SREC) + printf_filtered ("download filetype is moto-srec\n"); + else if (nrom_filetype == INTEL_HEX) + printf_filtered ("download filetype is intel-hex\n"); +} + +/* Pass arguments directly to the NetROM. */ + +static void +nrom_passthru (args, fromtty) + char *args; + int fromtty; +{ + char buf[1024]; + + sprintf(buf, "%s\n", args); + if (nrom_control_send (buf, strlen (buf)) < 0) + error ("nrom_reset: control_send() of `%s'failed", args); +} + +static void +nrom_store_registers (regno) +int regno; +{ + char buf[NROM_BUF_SIZE]; + int i; + char *p; + + p = buf; + for (i = 0; i < REGISTER_BYTES; i++) + { + *p++ = tohex ((registers[i] >> 4) & 0xf); + *p++ = tohex (registers[i] & 0xf); + } + *p = '\0'; + nrom_send (GDB_WRITE_REGS, buf, REGISTER_BYTES * 2, 0, REGISTER_BYTES * 2, + buf); +} + +static int +nrom_xfer_inferior_memory (memaddr, myaddr, len, write, target) + CORE_ADDR memaddr; + char *myaddr; + int len; + int write; + struct target_ops *target; +{ + if (write) + return nrom_write_inferior_memory (memaddr, myaddr, len); + else + return nrom_read_inferior_memory (memaddr, myaddr, len); +} + +/* Copy LEN bytes of data from debugger memory at MYADDR + to inferior's memory at MEMADDR. Returns errno value. */ + +static int +nrom_write_inferior_memory (memaddr, myaddr, len) + CORE_ADDR memaddr; + char *myaddr; + int len; +{ + char buf[NROM_BUF_SIZE],obuf[NROM_BUF_SIZE]; + int i; + char *p; + + p = obuf; + for (i = 0; i < len; i++) + { + *p++ = tohex ((myaddr[i] >> 4) & 0xf); + *p++ = tohex (myaddr[i] & 0xf); + } + *p = '\0'; + nrom_send (GDB_WRITE_MEM, obuf, len * 2, memaddr, len, buf); + + return len; +} + +/* Read LEN bytes from inferior memory at MEMADDR. Put the result + at debugger address MYADDR. Returns errno value. */ + +static int +nrom_read_inferior_memory (memaddr, myaddr, len) + CORE_ADDR memaddr; + char *myaddr; + int len; +{ + char buf[NROM_BUF_SIZE]; + + nrom_send (GDB_READ_MEM, NULL, 0, memaddr, len, buf); + memcpy (myaddr, buf, len); + return len; +} + +static void +nrom_files_info (ignore) + struct target_ops *ignore; +{ +} + +static void +nrom_mourn() +{ + unpush_target (&nrom_ops); + generic_mourn_inferior (); +} + +/* Convert a packet into its parts and verify check sum. */ + +static int +parse_pkt (pkt, hdr, data) + unsigned char *pkt; + GPKTHDR *hdr; + char *data; +{ + unsigned char xcsum; + unsigned char *dptr; + + /* Build packet header from received data. */ + hex2mem (pkt, (char *) hdr, sizeof(GPKTHDR)); + if (remote_debug > 1) + { + printf_filtered ("Packet received: csum = %x,seq number = %x,len = %d\n", + hdr->csum,hdr->seq_num,hdr->len); + printf_filtered ("cmd = %x,addr = %x,datalen = %d\n", + hdr->cmd,hdr->addr,hdr->datalen); + } + /* Skip first two bytes of packet when computing checksum. */ + dptr = (sizeof(GPKTHDR) * 2) + pkt; + pkt += 2; + if (remote_debug > 1) + { + printf_filtered ("Computing checksum over pkt %s\n",pkt); + printf_filtered ("Of length %d\n",strlen(pkt)); + } + xcsum = compute_csum (pkt, strlen (pkt)); + if (xcsum != hdr->csum) + { + if (remote_debug) + printf_filtered ("Checksum failure: computed %x, received %x\n",xcsum, + hdr->csum); + return (-1); + } + + /* Copy data portion to callers data buffer converting from ASCII + to data as we go. */ + hex2mem (dptr, data, hdr->datalen); + return 0; +} + +static int +read_pkt (pkt) + char *pkt; +{ + int n, tries; + struct sockaddr_in from; + int from_len = sizeof(from); + int gotstart; + int total_len; + char *p; + + p = pkt; + total_len = 0; + gotstart = 0; + + while (1) + { + /* Don't let us get wedged if the target is losing. */ + QUIT; + + if (bufdata == 0) + { + bufindex = 0; + n = NROM_BUF_SIZE; + /* Perform read on socket. This will wait. */ + bufdata = recvfrom (nrom_targ_sock, readbuf, n, 0, &from, &from_len); + if (bufdata < 0) + { + printf_filtered ("Error on socket read of %d\n",errno); + return (-1); + } + if (remote_debug > 2) + { + readbuf[bufdata] = '\0'; + printf_filtered ("Received %d bytes. Data is %s\n", + bufdata, readbuf); + } + } + + /* skip stuff between packets */ + while (gotstart == 0 && bufdata != 0 + && readbuf[bufindex] != GDB_START_DELIMITER) + { + bufdata--; + bufindex++; + } + + /* look for a start if we haven't seen one */ + if (gotstart == 0 && bufdata != 0 + && readbuf[bufindex] == GDB_START_DELIMITER) + { + gotstart = 1; + bufindex++; + bufdata--; + } + + /* copy packet data */ + if (gotstart != 0) + { + while (bufdata && readbuf[bufindex] != GDB_END_DELIMITER) + { + *p = readbuf[bufindex]; + p++; + bufdata--; + bufindex++; + total_len++; + if (total_len > NROM_BUF_SIZE) + { + error ("read_pkt: packet length exceeds %d\n", + NROM_BUF_SIZE); + return (-1); + } + } + *p = '\0'; + if (remote_debug > 2) + printf_filtered ("Packet is '%s'\n", pkt); + } + + /* Make sure this is the end of the packet. */ + if (gotstart != 0 && bufdata != 0 + && readbuf[bufindex] == GDB_END_DELIMITER) + { + gotstart = 0; + bufindex++; + bufdata--; + /* Ensure that the packet is terminated. */ + *p = '\0'; + if (remote_debug > 2) + printf_filtered ("Returning '%s'\n", pkt); + return 0; + } + } +} + +static void +send_query_cmd () +{ + while (send_pkt (GDB_QUERY_CMD, NULL, 0, 0, 0) < 0) + ; +} + +static int +send_pkt (cmd, data, datalen, addr, len) + int cmd; + char *data; + int datalen; + long addr; + int len; +{ + char c[2]; + unsigned char seq; + struct sockaddr_in mysin; + int send_cnt; + + while (1) + { + /* Get a sequence number for this packet. */ + seq = get_seq_number (); + /* Build the packet. */ + build_pkt (cmd, data, datalen, workbuf, addr, len, seq); + /* Put delimiters around the pkt. */ + memset (sendbuf, 0, NROM_BUF_SIZE); + sendbuf[0] = GDB_START_DELIMITER; + strcat (sendbuf, workbuf); + c[0] = GDB_END_DELIMITER; + c[1] = '\0'; + strcat (sendbuf, c); + + /* Send the packet out on our socket. */ + if (remote_debug > 1) + printf_filtered ("Sending pkt: %s\n", sendbuf); + mysin.sin_family = AF_INET; + mysin.sin_port = target_port; + mysin.sin_addr.S_un.S_addr = nrom_ipaddr; + + send_cnt = 0; + while (send_cnt < MAX_SEND_ATTEMPTS) + { + if (sendto (nrom_targ_sock, sendbuf, strlen(sendbuf), 0, &mysin, + sizeof(struct sockaddr_in)) < 0) + { + printf_filtered ("sendto error of %d\n", errno); + send_cnt++; + } + else + break; + } + if (send_cnt >= MAX_SEND_ATTEMPTS) + { + printf_filtered ("Socket send failed after %d tries\n", + MAX_SEND_ATTEMPTS); + return (-1); + } + return 1; + } +} + +/* Convert number NIB to a hex digit. */ + +static int +tohex (nib) + int nib; +{ + if (nib < 10) + return '0' + nib; + else + return 'a' + nib - 10; +} + +/* snatched from Stevens, pp279+ */ + +int +writen (sock, ptr, nbytes) + int sock; + char *ptr; + int nbytes; +{ + int nleft, nwritten; + char *buf = ptr; + + nleft = nbytes; + while (nleft > 0) + { + nwritten = write (sock, buf, nleft); + if (nwritten <= 0) + return nwritten; + nleft -= nwritten; + buf += nwritten; + } + return (nbytes - nleft); +} + +/* Define the target vector. */ + +struct target_ops nrom_ops = { + "nrom", /* to_shortname */ + "Remote XDI `NetROM' target", /* to_longname */ + "Remote debug using a NetROM over Ethernet", + nrom_open, /* to_open */ + nrom_close, + nrom_attach, + nrom_detach, + nrom_resume, + nrom_wait, /* to_wait */ + nrom_fetch_registers, /* to_fetch_registers */ + nrom_store_registers, /* to_store_registers */ + nrom_prepare_to_store, /* to_prepare_to_store */ + nrom_xfer_inferior_memory, /* to_xfer_memory */ + nrom_files_info, /* to_files_info */ + NULL, /* to_insert_breakpoint */ + NULL, /* to_remove_breakpoint */ + NULL, + NULL, + NULL, + NULL, + NULL, + nrom_kill, + nrom_load, + NULL, + nrom_create_inferior, /* to_create_inferior */ + nrom_mourn, + nrom_can_run, + 0, /* to_notice_signals */ + 0, + process_stratum, /* to_stratum */ + NULL, /* to_next */ + 1, + 1, + 1, + 1, + 0, /* to_has_execution */ + NULL, /* sections */ + NULL, /* sections_end */ + OPS_MAGIC /* to_magic */ +}; + +void +_initialize_remote_nrom () +{ + add_target (&nrom_ops); + + /* Add some commands for helpers. */ + add_cmd ("nrom_ipaddr", no_class, nrom_set_ipaddr, + "Set the IP Address of the NetROM\n", + &setlist); + add_cmd ("target_port", no_class, nrom_set_target_port, + "Set the Port to use for NetROM target communication\n", + &setlist); + add_cmd ("load_port", no_class, nrom_set_load_port, + "Set the Port to use for NetROM downloads\n", + &setlist); + add_cmd ("control_port", no_class, nrom_set_control_port, + "Set the Port to use for NetROM debugger services\n", + &setlist); + add_cmd ("nrom_filetype", no_class, nrom_set_filetype, + "Set the filetype to use on NetROM downloads", + &setlist); + + add_cmd ("nrom", no_class, nrom_show_status, + "Show the current NetROM status\n", + &showlist); + + add_cmd ("nrom", no_class, nrom_passthru, + "Pass arguments as command to NetROM", + &cmdlist); +} |