On 18 Jul 2003 17:55:30 -0700, Steven Dake <[EMAIL PROTECTED]> wrote: >While we are dreaming :) complete source level debugging would be very >useful. I was thinking this would best be done over serial or ethernet >with a kdb engine running in the target kernel. This would allow a >debugger to use the kdb commands to symbolicly debug a running kernel.
We tried it once[1], using a gdb 4 stub that talked to kdb. We could never get it to talk to gdb properly, in particular when the kernel was already in kdb, gdb would not reliably connect to the stub. The code was put to one side, with the aim of looking at it again once gdb 5 was more widespread, gdb 5 has a better stub interface. Are there any gdb experts on this list who want to pick up this code and get it working? [1] https://external-lists.vasoftware.com/archives/linux-ia64/2002-April/003451.html /***********************************************************\ * Copyright (C) 2000 SGI * Released under the terms of GNU Public License v.2 * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * Project: GDB-KDB interface * Module: GDB remote debugging protocol * File: skdb.c * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * $Id: skdb.c,v 1.1 2000/11/08 23:42:49 max Exp max $ \***********************************************************/ #include <stdio.h> #include <stdlib.h> #include <string.h> #include <unistd.h> #include <signal.h> #include <errno.h> #include <fcntl.h> #include <sys/types.h> #include <sys/time.h> #include <termios.h> #include <sys/ioctl.h> #include <sys/stat.h> #include <netdb.h> #include <sys/socket.h> #include <netinet/in.h> #include <arpa/inet.h> #define TELOPTS #define TELCMDS #include <arpa/telnet.h> #define SKDB_MAX_REQSIZ (16384) /* Debug flags - options should match 1 << name */ char * dopt[] = {"all", "serial", "telnet", "remote", NULL}; unsigned int debug = 0; #define SKDB_DBG_SERIAL 2 #define SKDB_DBG_TELNET 4 #define SKDB_DBG_REMOTE 8 int pfork (int, char **); char * getgdbpkt (char * inqueue, char ** pkt); int putgdbpkt (int fd, char * data); char * kdb_request (int, const char *); unsigned long * breakaddrs = NULL; int breaks = 0; int telnetmode = 0; int isRunning = 1; /* This is the order in which gdb knows x86 regs. */ static const char * regnames[] = { "eax", "ecx", "edx", "ebx", "esp", "ebp", "esi", "edi", "eip", "eflags", "cs", "ss", "ds", "es", "fs", "gs", NULL}; /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * *\ * Function: getgdbpkt * Find something which looks, smells and sounds like a gdb * packet (i.e, it starts with $ and ends with #XX), check * the control sum and return the pointer to the end of * the packet to the caller. Pointer to the start of the packet * is returned via the 'pkt' parameter * Parameters: * inqueue - input buffer which may contain the packet * pkt - pointer * Returns: * pointer of the last charcter in the input buffer, which is not * in the packet to be processed, on success or NULL on error. If * packet has not been found, pkt is left unmolested. \* * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ char * getgdbpkt (char * inqueue, char ** pkt) { while (*inqueue != '$' && *inqueue != '\0' ) { inqueue++; } if ( *inqueue == '\0' ) { /* No $ - no packets, skip the whole lot */ return inqueue; } else { char * start = ++inqueue; while ( *inqueue != '#' && *inqueue != '\0' ) { inqueue++; } if ( *inqueue == '\0' ) { /* We've seen the start of the packet but not the end of it */ return start; } /* Check for the obsolete sequence id and reject the packet if * there is one */ if ( (inqueue - start) > 3 && isxdigit (start[0]) && isxdigit (start[1]) && (start[2] == ':')) { return (NULL); } else { /* End of the packet - calculate checksum */ char * p = start; unsigned int chksum = 0; char s[3] = {inqueue[1], inqueue[2], '\0'}; int ctrlsum = strtol (s, NULL, 16); while ( p != inqueue ) { chksum = (chksum + *p++ ) & 0xFFU; } if ( ctrlsum != chksum ) { fprintf (stderr, "\nskdb: Bad Checksum: %d != %d\n", ctrlsum, chksum); return (NULL); } if ( pkt != NULL ) { *pkt = start; } inqueue += 3; } } return (inqueue); } /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * *\ * Function: putgdbpkt * Form a kosher gdb packet and send it down to gdb using * file descriptor provided * Parameters: * fd - file descriptor which gdb can be reached thru * data - pointer to the content of the packet to be sent * Returns: * number of bytes send to gdb on success or -1 on error \* * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ int putgdbpkt (int fd, char * data) { char * pkt = malloc (strlen(data)+5); if ( pkt != NULL ) { unsigned int chksum = 0; int sz = 0; pkt[sz++] = '$'; while ( *data != '\0' ) { pkt[sz++] = *data; chksum = (chksum + *data++) & 0xFFU; } sprintf (pkt+sz, "#%02X", chksum); if ( write (fd, pkt, sz+3) != sz+3 ) { extern int errno; fprintf (stderr, "putgdbpkt: write (%d, ... , %d) - %s", fd, sz+3, strerror (errno)); return (-1); } free (pkt); return (sz); } return (-1); } /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * *\ * Function: find_kdb_prompt * Telnetd will sent NULs for CR (see rfc1184 or * its successor), so we have to work around them * here. * Parameters: * reply - stuff we've got back from kdb * sz - how much have we got? * Returns: * Pointer to the start of the prompt on success or NULL * if there is no prompt. \* * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ char * find_kdb_prompt (char * reply, int sz ) { char * l; for ( l = reply; l < reply + sz; l += strlen (l)+1 ) { char * prompt = strstr (l, "kdb> "); if ( prompt != NULL ) { return (prompt); } } return (NULL); } /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * *\ * Function: kdb_request * Send kdb interrupt key, send simple request, i.e one * kdb command, wait for the result, send go and return * the result. * Parameters: * fd - file descriptor to reach kdb * req - request * Returns: * pointer to the dynamically allocated region of memory * on success or NULL on error \* * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ char * kdb_request (int fd, const char * req) { char buf[SKDB_MAX_REQSIZ]; int bc = 0, seek = 1; fd_set fds; struct timeval tv; FD_ZERO (&fds); if ( isRunning ) { write (fd, "\1", 1); /* KDB attention key */ } else { write (fd, "\n\r", 2); } /* Wait for kdb prompt */ while ( seek ) { FD_SET (fd, &fds); tv.tv_sec = 15; tv.tv_usec = 0; if ( select (fd+1, &fds, NULL, NULL, &tv) > 0 ) { int nb = read (fd, buf+bc, SKDB_MAX_REQSIZ-bc-1); if ( nb > 0 && ((bc + nb) < SKDB_MAX_REQSIZ)) { bc += nb; buf[bc+1] = '\0'; if ( find_kdb_prompt (buf, bc) != NULL ) { seek = 0; bc = 0; isRunning = 0; } } else { fputs ("\nskdb: Request is too big\n", stderr); fflush (stderr); return (NULL); } } else { fputs ("\nskdb: Timed out while trying to get kdb attention\n", stderr); fflush (stderr); return (NULL); } } /* Check if we have smth to request or if it was just an interrupt */ if ( req[0] ) { /* Send request */ write (fd, req, strlen (req)); write (fd, "\n\r", 2); /* Read reply until we find a second prompt, unless it's a 'go' - * in this case we just return */ if ( strncmp (req, "go", 2) ) { seek = 1; while ( seek ) { FD_SET (fd, &fds); tv.tv_sec = 5; tv.tv_usec = 0; if ( select (fd+1, &fds, NULL, NULL, &tv) > 0 ) { int nb = read (fd, buf+bc, SKDB_MAX_REQSIZ-bc-1); if ( nb > 0 && ((bc + nb) < SKDB_MAX_REQSIZ) ) { char * pstart; bc += nb; buf[bc+1] = '\0'; if ( (pstart = find_kdb_prompt(buf, bc)) != NULL ) { char * nl; if ( telnetmode ) { char * nul; while ((nul=memchr (buf, '\0', bc)) != NULL) { memmove (nul, nul+1, buf+bc-nul-1); bc--; } } *pstart = '\0'; if ( (nl = strrchr (buf, '\n')) != NULL ) { seek = 0; *pstart = 'k'; bc = nl - buf; *nl = '\0'; } } } else { return (NULL); } } else { return (NULL); } } } else { isRunning = 1; return (strdup ("")); } } else { return (strdup ("")); } return (strdup (buf)); } /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * *\ * Function: gdb_process * Process one gdb packet. One gdb packet my result to zero, * one or no requests to kdb. * Parameters: * pm - file descriptor to talk to gdb * kdb - file descriptor to talk to kdb * pkt - gdb packet sense control sum \* * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ void gdb_process (int pm, int kdb, char * pkt) { char * start = NULL, *end; if ( ((end = getgdbpkt (pkt, &start)) != NULL) && (start != NULL) ) { unsigned long bpaddr; int i; char reply[SKDB_MAX_REQSIZ] = ""; char * sep; write (pm, "+", 1); /* ACK the packet */ switch ( *start ) { case 'c': /* Continue - do nothing, just ACK the packet. The rest * will come from the kdb */ free (kdb_request (kdb, "go")); break; case 'D': /* GDB doesn't want to play no more but it still * wants a reply regardless of what is said in the * manual */ free (kdb_request (kdb, "go")); putgdbpkt (pm, "OK"); break; case 's': free (kdb_request (kdb, "ss")); putgdbpkt (pm, "S00"); break; case 'H': putgdbpkt (pm, "OK"); break; case 'm': /* Memory read */ if ( (sep = strchr (start+1, ',')) == NULL ) { strcpy (reply, "E01"); } else { char * aend; unsigned long addr = strtoul (start+1, &aend, 16); if ( aend != sep ) { strcpy (reply, "E01"); } else { int sz = atoi (sep+1); char * res; sprintf (reply, "mdr 0x%x %d", addr, sz); if ( (res = kdb_request (kdb, reply)) == NULL ) { putgdbpkt (pm, "E02"); } else { char * nl = strrchr (res, '\n'); if ( nl == NULL ) { putgdbpkt (pm, "E02"); } else { int i; for (i = strlen (nl)-1; i>0; i-- ) { if ( ! isxdigit (nl[i]) ) { break; } } if ( i ) { /* Wrong address */ putgdbpkt (pm, "E03"); } else { putgdbpkt (pm, nl+1); } } free (res); } } } break; case 'P': /* Set register */ if ( (sep = strchr (start+1, '=')) == NULL ) { strcpy (reply, "E01"); } else { char * aend; unsigned long rn = strtoul (start+1, &aend, 16); if ( aend != sep ) { strcpy (reply, "E01"); } else if ( rn > sizeof (regnames) / sizeof (regnames[0]) ) { strcpy (reply, "E04"); } else { int i; char * res; unsigned long rv = strtoul (sep+1, NULL, 16); sprintf (reply, "rm %%%s ", regnames[rn]); for ( i=0; i < sizeof (int); i++ ) { char x2[3]; sprintf (x2, "%02x", rv & 0xFFU); rv >>= 8; strcat (reply, x2); } if ( (res = kdb_request (kdb, reply)) == NULL ) { putgdbpkt (pm, "E02"); } else { if ( strstr (res, "diag:") != 0 ) { /* We don't expect anything back, so it's * an error */ putgdbpkt (pm, "E03"); } else { putgdbpkt (pm, "OK"); } free (res); } } } break; case 'g': if ( start[1] != '#' ) { putgdbpkt (pm, "E01"); } else { char * res = kdb_request (kdb, "rd"); if ( res == NULL ) { putgdbpkt (pm, "E02"); } else { int r; for ( r=0; regnames[r] != NULL; r++ ) { char * p = strstr (res, regnames[r]); if ( p != NULL && isspace (p[-1])){ int b = strlen(regnames[r])+2; unsigned long rv = strtoul (p+b, NULL, 0); for ( b=0; b < sizeof (int); b++ ) { char x2[3]; sprintf (x2, "%02x", (rv & 0xFFU)); strcat (reply, x2); rv >>= 8; } } else { strcat (reply, "xxxxxxxx"); } } putgdbpkt (pm, reply); free (res); } } break; case 'q': /* Query packet - needs further processing */ switch ( start[1] ) { case 'C': putgdbpkt (pm, "QC0"); break; case 'O': /* We don't use any special offsets, so whatever * is in the elf, should be fine. */ putgdbpkt (pm, "Text=00000000;Data=00000000;Bss=00000000;"); break; case 'R': /* Remote Command */ if ( (sep = strchr (start, ',')) == NULL ) { putgdbpkt (pm, "E01"); } else { int i; for ( i=0,sep++; sep[0] != '#' && sep < end; sep+=2,i++ ) { if ( isxdigit (sep[0]) && isxdigit (sep[1]) ) { char x2[3] = {sep[0], sep[1], '\0'}; unsigned long ch = strtoul (x2, NULL, 16); reply[i] = (ch & 0xFFU); } else { i = -1; break; } } if ( i < 0 ) { putgdbpkt (pm, "E02"); } else { const char * xchars = "0123456789ABCDEF"; char * res = kdb_request (kdb, reply); if ( res != NULL ) { for (i=0; res[i] && (i*2 < SKDB_MAX_REQSIZ); i++) { reply[i*2] = xchars[(res[i] >> 4) & 0xFU]; reply[i*2+1] = xchars[(res[i] & 0xFU)]; } reply[i*2] = '\0'; strcat (reply, "0A0D"); i += 2; if ( i*2 > 256 ) { /* Have to break the reply as gdb * cannot cope with the big packets */ char part[256]; int j; for ( j=0; j < (i*2)-254; j += 254 ) { part[0] = 'O'; memcpy (part+1, reply + j, 254); part[255] = '\0'; putgdbpkt (pm, part); } putgdbpkt (pm, reply+j); } else { putgdbpkt (pm, reply); } free (res); } else { putgdbpkt (pm, "E02"); } } } break; default: putgdbpkt (pm, "E33"); break; } break; case 'z': /* Clear a break/watch point */ bpaddr = strtoul (start+3, NULL, 16); for ( i=0; i < breaks; i++ ) { if ( breakaddrs[i] == bpaddr ) { char * res; sprintf (reply, "bc %d", i); if ( (res = kdb_request (kdb, reply)) != NULL ) { bpaddr = 0; putgdbpkt (pm, "OK"); free (res); } else { putgdbpkt (pm, "E05"); } break; } } if ( i >= breaks ) { putgdbpkt (pm, "E06"); } break; case 'Z': /* Breakpoint/watchpoint - Z<type>,<addr>,<length> */ bpaddr = strtoul (start+3, NULL, 16); switch ( start[1] ) { case '0': /* Software breakpoint */ for ( i=0; i < breaks; i++ ) { if ( breakaddrs[i] == bpaddr ) { putgdbpkt (pm, "OK"); break; } } if ( i >= breaks ) { char * res; sprintf (reply, "bp 0x%x", bpaddr); if ( (res = kdb_request (kdb, reply)) != NULL ) { char * bpnum; if ( (bpnum = strstr (res, "BP #")) == NULL ) { putgdbpkt (pm, "E03"); } else { int bp = strtol (bpnum+4, NULL, 0); if ( breaks <= bp) { unsigned long * nb; if ( (nb = realloc (breakaddrs, sizeof (int)*(bp+1))) != NULL ) { breakaddrs = nb; for ( i=breaks+1; i < bp; i++ ) { breakaddrs[i] = 0; } breaks = bp+1; breakaddrs[bp] = bpaddr; putgdbpkt (pm, "OK"); } else { putgdbpkt (pm, "E05"); } } free (res); } } else { putgdbpkt (pm, "E02"); } } break; case '1': /* Hardware breakpoint */ sprintf (reply, "bph 0x%8.8s", start+3); if ( kdb_request (kdb, reply) != NULL ) { putgdbpkt (pm, "OK"); } else { putgdbpkt (pm, "E02"); } break; default: putgdbpkt (pm, "E34"); break; } break; case '?': putgdbpkt (pm, "S05"); break; default: putgdbpkt (pm, "E35"); break; } } } /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * *\ * Function: pfork * Create a master/slave pty pair, fork and exec gdb with * -x fudged to point it to the slave pty in the parent * process space. Child will do the real work. * Parameters: * argc - number of gdb command line parameters * args - gdb's command line parameters * Returns: * file descriptor for master PTY on success or -1 on error \* * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ int pfork (int argc, char ** args) { int pt; if ( (pt = open ("/dev/ptmx", O_RDWR)) >= 0 ) { if ( grantpt (pt) != -1 ) { if ( unlockpt (pt) != -1 ) { FILE * tf; char * tname = strdup (tmpnam (NULL)); pid_t child; if ( tname == NULL ) { puts ("Oops!"); return -1; } else if ( (tf = fopen (tname, "w")) == NULL ) { perror (tname); free (tname); return -1; } fprintf (tf, "shell rm %s\n" "set remotedebug %d\n" "set serialdebug %d\n" "target remote %s\n" "define lsmod\n" "set $mod = (struct module*)module_list\n" "while $mod != &kernel_module\n" "printf \"%%p\t%%s\\n\", (long)$mod, ($mod)->name\n" "set $mod = $mod->next\n" "end\nend\n", tname, ((debug & SKDB_DBG_REMOTE) != 0), ((debug & SKDB_DBG_SERIAL) != 0), ptsname(pt)); fflush (tf); if ( (child = fork ()) > 0 ) { int i; char **gargs = calloc (argc+5, sizeof (char *)); if ( gargs == NULL ) { kill (child, SIGTERM); exit (1); } else { gargs[0] = "gdb"; gargs[1] = "-q"; gargs[2] = "-x"; gargs[3] = tname; close (pt); for ( i=0; i < argc ; i++ ) { gargs[i+4] = args[i]; } gargs[i+4] = NULL; execvp ("gdb", gargs); kill (child, SIGTERM); exit (1); } /*NOTREACHED*/ } else if ( child < 0 ) { perror ("fork"); close (pt); pt = -1; } fclose (tf); free (tname); return (pt); } else { perror ("unlockpt"); } } else { perror ("grantpt"); } close (pt); } return (-1); } static void usage (char * pname) { printf ("USAGE: %s [-Dall,serial,telnet] [-k] [-l tty] -- [gdb-args]\n", pname); puts ("Options:"); puts ("-k target is already in kdb, don't break in"); puts ("-l tty tty:speed or host:port to get access to"); puts (" a target"); } int main (int argc, char * argv[]) { int c, pm, kdb; char * line = "/dev/ttyS0"; int speed = B38400; char * delim; struct stat st; if ( argc == 2 && argv[1][0] == '-' && argv[1][1] == '?' ) { usage (argv[0]); exit (0); } while ( (c = getopt (argc, argv, "D:kl:")) > 0 ) { switch ( c ) { case 'k': isRunning = 0; break; case 'l': line = optarg; break; case 'D': delim = optarg; do { char * nextcomma; int i; if ( (nextcomma = strchr (delim, ',')) == NULL ) { nextcomma = delim + strlen (delim); } for ( i=0; dopt[i] != NULL; i++ ) { if ( ! strncmp (delim, dopt[i], nextcomma-delim)) { if ( i ) { debug |= 1 << i; } else { debug = 0xffffffffUL; } break; } } if ( dopt[i] == NULL ) { fprintf (stderr, "Unknown debug option: %s\n", delim); exit (1); } delim = nextcomma+1; } while ( (delim - optarg) < strlen (optarg) ); break; default: usage (argv[0]); exit (1); } } if ( (delim = strchr (line, ':')) != NULL ) { *delim++ = '\0'; } /* Try to guess if we're dealing with real line or with a host name */ if ( (stat (line, &st) >= 0) && S_ISCHR (st.st_mode) ) { if ( (kdb = open (line, O_RDWR)) < 0 ) { perror (line); exit (1); } else { struct termios tio; if ( tcgetattr (kdb, & tio) < 0 ) { perror ("tcgetattr"); return (1); } else { tio.c_lflag &= ~(ECHO | ICANON | IEXTEN | ISIG); tio.c_cflag &= ~(CBAUD | CSIZE | PARENB | CSTOPB | CRTSCTS ); tio.c_cflag |= B38400 | CS8 | CREAD | HUPCL; tio.c_iflag &= ~(BRKINT | ICRNL |INPCK | ISTRIP); tio.c_iflag |= IXON |IXOFF; tio.c_oflag &= ~OPOST; cfsetispeed (& tio, B38400); cfsetospeed (& tio, B38400); tio.c_cc[VMIN] = 1; tio.c_cc[VTIME] = 0; if ( tcsetattr (kdb, TCSANOW, & tio) < 0 ) { perror ("tcsetattr"); exit (1); } } } } else { /* Must be a host name - try to resolve it. Note, that host must * have a port number - defaulting to a telnet port isn't going to do * us much good here */ if ( delim == NULL ) { fputs ("Host specification requires a port number\n", stderr); exit (1); } else { static struct sockaddr_in sa; struct servent * sp; struct hostent * he; char **p; memset ( & sa, 0, sizeof (sa)); sa.sin_family = AF_INET; if ( (sp = getservbyname (delim, "tcp")) != NULL ) { sa.sin_port = htons (sp->s_port); } else { /* Lookup fails. Check if it's a number */ char * err = NULL; sa.sin_port = htons ((short int)strtol (delim, & err, 0)); if ( (err == NULL) || (*err != '\0') ) { fprintf (stderr, "Cannot find port number for port %s\n", delim); exit (1); } } if ( (he = gethostbyname (line)) == NULL ) { fprintf (stderr,"No address information for %s\n", line); exit (1); } else { memcpy (& sa.sin_addr.s_addr, * he->h_addr_list, sizeof (sa.sin_addr.s_addr)); } if ( (kdb = socket (AF_INET, SOCK_STREAM, 0)) < 0 ) { perror ("socket"); exit (1); } else { if ( connect (kdb, (struct sockaddr *)&sa, sizeof (sa)) < 0 ) { fprintf (stderr, "Cannot connect to %s - %s\n", line, strerror (errno)); exit (1); } else { /* Assume telnetd connection and try to negotiate: * reply WONT to any DOs, reply DONT to any WILL * except WILL ECHO. First non-escaped charachter stops * negotiation */ int negotiate = 1; int echo = 0; telnetmode = 1; while ( negotiate ) { fd_set fds; struct timeval tv; unsigned char negbuf[512]; int bc = 0; FD_ZERO (&fds); FD_SET (kdb, &fds); tv.tv_sec = 1; tv.tv_usec = 0; if ( select (kdb+1, &fds, NULL, NULL, &tv) > 0 ) { int nb = read (kdb, negbuf+bc, 511-bc); unsigned char rep[512], * prep = rep; int i; if ( nb > 0 && ((bc + nb) < 512)) { bc += nb; for (i=0; i < bc-2; i+= 3 ) { if ( negbuf[i] == IAC ) { switch ( negbuf[i+1] ) { case DO: if ( debug & SKDB_DBG_TELNET ) { printf ("RECV DO %s\n", telopts[negbuf[i+2]]); } prep[0] = IAC; prep[1] = WONT; prep[2] = negbuf[i+2]; prep += 3; break; case WILL: if ( debug & SKDB_DBG_TELNET ) { printf ("RECV WILL %s\n", telopts[negbuf[i+2]]); } prep[0] = IAC; prep[2] = negbuf[i+2]; if ( negbuf[i+2] != TELOPT_ECHO ) { prep[1] = DONT; } else { if ( echo ) { prep -= 3; } else { echo = 1; prep[1] = DO; } } prep += 3; break; } } else { negotiate = 0; break; } } if ( ! echo ) { prep[0] = IAC; prep[1] = DO; prep[2] = TELOPT_ECHO; prep += 3; echo = 1; } if ( debug & SKDB_DBG_TELNET ) { for ( i=0; i < prep - rep; i += 3 ) { printf ("SEND %s %s\n", TELCMD((rep[i+1])), TELOPT(rep[i+2])); } } write (kdb, rep, prep - rep); } else { fputs ("Connection closed by remote host\n", stderr); exit (1); } } else { /* Timeout - other end doesn't want * to negotiate no more */ negotiate = 0; } } } } } } if ( (pm = pfork (argc-optind, argv+optind)) >= 0 ) { int maxfd = (pm > kdb) ? pm : kdb; int bc = 0; char kdbpkt[SKDB_MAX_REQSIZ]; signal (SIGINT, SIG_IGN); while ( 1 ) { fd_set fds; FD_SET(pm, &fds); FD_SET(kdb, &fds); if (select (maxfd+1, &fds, NULL, NULL, NULL) < 0 ) { close (pm); break; } else { int i, sz; if ( FD_ISSET (pm, &fds) ) { char pkt[SKDB_MAX_REQSIZ]; if ( (sz = read (pm, pkt, SKDB_MAX_REQSIZ)) <= 0 ) { break; } pkt[sz] = '\0'; /* Sometimes gdb doesn't play by the rules and * doesn't sent packets but sends Ctrl-C instead, * which is naughty but it does it, so we check * for this case before we start processing good * packets */ if ( pkt[0] == '\3' ) { /* GDB sent us an interrupt */ kdb_request (kdb, ""); putgdbpkt (pm, "S02"); } else { gdb_process (pm, kdb, pkt); } } if ( FD_ISSET (kdb, &fds) ) { if ( (sz = read (kdb, kdbpkt+bc, SKDB_MAX_REQSIZ - bc)) >= 0 ) { char * prompt; bc += sz; kdbpkt[bc] = '\0'; if ( telnetmode ) { char * nul; while ((nul=memchr (kdbpkt, '\0', bc)) != NULL) { memmove (nul, nul+1, kdbpkt+bc-nul-1); bc--; } } if ( (prompt = strstr (kdbpkt, "kdb> ")) != NULL ) { isRunning = 0; if ( strstr (kdbpkt, "due to Keyboard Entry") != NULL ) putgdbpkt (pm, "S02"); else if ( strstr (kdbpkt, "due to Breakpoint") != NULL ) putgdbpkt (pm, "S05"); else putgdbpkt (pm, "S00"); bc -= prompt+5 - kdbpkt; memmove (kdbpkt, prompt+5, bc); } else { if ( (SKDB_MAX_REQSIZ - bc) < 5 ) { memmove (kdbpkt, kdbpkt+bc-5, 5); bc = 5; } } } } } } } close (pm); close (kdb); return (0); }
