1/* Remote debugging interface for Tandem ST2000 phone switch, for GDB. 2 3 Copyright 1990, 1991, 1992, 1993, 1994, 1995, 1998, 1999, 2000, 4 2001, 2002 Free Software Foundation, Inc. 5 6 Contributed by Cygnus Support. Written by Jim Kingdon for Cygnus. 7 8 This file is part of GDB. 9 10 This program is free software; you can redistribute it and/or modify 11 it under the terms of the GNU General Public License as published by 12 the Free Software Foundation; either version 2 of the License, or 13 (at your option) any later version. 14 15 This program is distributed in the hope that it will be useful, 16 but WITHOUT ANY WARRANTY; without even the implied warranty of 17 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 18 GNU General Public License for more details. 19 20 You should have received a copy of the GNU General Public License 21 along with this program; if not, write to the Free Software 22 Foundation, Inc., 59 Temple Place - Suite 330, 23 Boston, MA 02111-1307, USA. */ 24 25/* This file was derived from remote-eb.c, which did a similar job, but for 26 an AMD-29K running EBMON. That file was in turn derived from remote.c 27 as mentioned in the following comment (left in for comic relief): 28 29 "This is like remote.c but is for an esoteric situation-- 30 having an a29k board in a PC hooked up to a unix machine with 31 a serial line, and running ctty com1 on the PC, through which 32 the unix machine can run ebmon. Not to mention that the PC 33 has PC/NFS, so it can access the same executables that gdb can, 34 over the net in real time." 35 36 In reality, this module talks to a debug monitor called 'STDEBUG', which 37 runs in a phone switch. We communicate with STDEBUG via either a direct 38 serial line, or a TCP (or possibly TELNET) stream to a terminal multiplexor, 39 which in turn talks to the phone switch. */ 40 41#include "defs.h" 42#include "gdbcore.h" 43#include "target.h" 44#include "gdb_string.h" 45#include <sys/types.h> 46#include "serial.h" 47#include "regcache.h" 48 49extern struct target_ops st2000_ops; /* Forward declaration */ 50 51static void st2000_close (); 52static void st2000_fetch_register (); 53static void st2000_store_register (); 54 55#define LOG_FILE "st2000.log" 56#if defined (LOG_FILE) 57FILE *log_file; 58#endif 59 60static int timeout = 24; 61 62/* Descriptor for I/O to remote machine. Initialize it to -1 so that 63 st2000_open knows that we don't have a file open when the program 64 starts. */ 65 66static struct serial *st2000_desc; 67 68/* Send data to stdebug. Works just like printf. */ 69 70static void 71printf_stdebug (char *pattern,...) 72{ 73 va_list args; 74 char buf[200]; 75 76 va_start (args, pattern); 77 78 vsprintf (buf, pattern, args); 79 va_end (args); 80 81 if (serial_write (st2000_desc, buf, strlen (buf))) 82 fprintf_unfiltered (gdb_stderr, "serial_write failed: %s\n", 83 safe_strerror (errno)); 84} 85 86/* Read a character from the remote system, doing all the fancy timeout 87 stuff. */ 88 89static int 90readchar (int timeout) 91{ 92 int c; 93 94 c = serial_readchar (st2000_desc, timeout); 95 96#ifdef LOG_FILE 97 putc (c & 0x7f, log_file); 98#endif 99 100 if (c >= 0) 101 return c & 0x7f; 102 103 if (c == SERIAL_TIMEOUT) 104 { 105 if (timeout == 0) 106 return c; /* Polls shouldn't generate timeout errors */ 107 108 error ("Timeout reading from remote system."); 109 } 110 111 perror_with_name ("remote-st2000"); 112} 113 114/* Scan input from the remote system, until STRING is found. If DISCARD is 115 non-zero, then discard non-matching input, else print it out. 116 Let the user break out immediately. */ 117static void 118expect (char *string, int discard) 119{ 120 char *p = string; 121 int c; 122 123 immediate_quit++; 124 while (1) 125 { 126 c = readchar (timeout); 127 if (c == *p++) 128 { 129 if (*p == '\0') 130 { 131 immediate_quit--; 132 return; 133 } 134 } 135 else 136 { 137 if (!discard) 138 { 139 fwrite (string, 1, (p - 1) - string, stdout); 140 putchar ((char) c); 141 fflush (stdout); 142 } 143 p = string; 144 } 145 } 146} 147 148/* Keep discarding input until we see the STDEBUG prompt. 149 150 The convention for dealing with the prompt is that you 151 o give your command 152 o *then* wait for the prompt. 153 154 Thus the last thing that a procedure does with the serial line 155 will be an expect_prompt(). Exception: st2000_resume does not 156 wait for the prompt, because the terminal is being handed over 157 to the inferior. However, the next thing which happens after that 158 is a st2000_wait which does wait for the prompt. 159 Note that this includes abnormal exit, e.g. error(). This is 160 necessary to prevent getting into states from which we can't 161 recover. */ 162static void 163expect_prompt (int discard) 164{ 165#if defined (LOG_FILE) 166 /* This is a convenient place to do this. The idea is to do it often 167 enough that we never lose much data if we terminate abnormally. */ 168 fflush (log_file); 169#endif 170 expect ("dbug> ", discard); 171} 172 173/* Get a hex digit from the remote system & return its value. 174 If ignore_space is nonzero, ignore spaces (not newline, tab, etc). */ 175static int 176get_hex_digit (int ignore_space) 177{ 178 int ch; 179 while (1) 180 { 181 ch = readchar (timeout); 182 if (ch >= '0' && ch <= '9') 183 return ch - '0'; 184 else if (ch >= 'A' && ch <= 'F') 185 return ch - 'A' + 10; 186 else if (ch >= 'a' && ch <= 'f') 187 return ch - 'a' + 10; 188 else if (ch == ' ' && ignore_space) 189 ; 190 else 191 { 192 expect_prompt (1); 193 error ("Invalid hex digit from remote system."); 194 } 195 } 196} 197 198/* Get a byte from stdebug and put it in *BYT. Accept any number 199 leading spaces. */ 200static void 201get_hex_byte (char *byt) 202{ 203 int val; 204 205 val = get_hex_digit (1) << 4; 206 val |= get_hex_digit (0); 207 *byt = val; 208} 209 210/* Get N 32-bit words from remote, each preceded by a space, 211 and put them in registers starting at REGNO. */ 212static void 213get_hex_regs (int n, int regno) 214{ 215 long val; 216 int i; 217 218 for (i = 0; i < n; i++) 219 { 220 int j; 221 222 val = 0; 223 for (j = 0; j < 8; j++) 224 val = (val << 4) + get_hex_digit (j == 0); 225 supply_register (regno++, (char *) &val); 226 } 227} 228 229/* This is called not only when we first attach, but also when the 230 user types "run" after having attached. */ 231static void 232st2000_create_inferior (char *execfile, char *args, char **env) 233{ 234 int entry_pt; 235 236 if (args && *args) 237 error ("Can't pass arguments to remote STDEBUG process"); 238 239 if (execfile == 0 || exec_bfd == 0) 240 error ("No executable file specified"); 241 242 entry_pt = (int) bfd_get_start_address (exec_bfd); 243 244/* The "process" (board) is already stopped awaiting our commands, and 245 the program is already downloaded. We just set its PC and go. */ 246 247 clear_proceed_status (); 248 249 /* Tell wait_for_inferior that we've started a new process. */ 250 init_wait_for_inferior (); 251 252 /* Set up the "saved terminal modes" of the inferior 253 based on what modes we are starting it with. */ 254 target_terminal_init (); 255 256 /* Install inferior's terminal modes. */ 257 target_terminal_inferior (); 258 259 /* insert_step_breakpoint (); FIXME, do we need this? */ 260 /* Let 'er rip... */ 261 proceed ((CORE_ADDR) entry_pt, TARGET_SIGNAL_DEFAULT, 0); 262} 263 264/* Open a connection to a remote debugger. 265 NAME is the filename used for communication. */ 266 267static int baudrate = 9600; 268static char dev_name[100]; 269 270static void 271st2000_open (char *args, int from_tty) 272{ 273 int n; 274 char junk[100]; 275 276 target_preopen (from_tty); 277 278 n = sscanf (args, " %s %d %s", dev_name, &baudrate, junk); 279 280 if (n != 2) 281 error ("Bad arguments. Usage: target st2000 <device> <speed>\n\ 282or target st2000 <host> <port>\n"); 283 284 st2000_close (0); 285 286 st2000_desc = serial_open (dev_name); 287 288 if (!st2000_desc) 289 perror_with_name (dev_name); 290 291 if (serial_setbaudrate (st2000_desc, baudrate)) 292 { 293 serial_close (dev_name); 294 perror_with_name (dev_name); 295 } 296 297 serial_raw (st2000_desc); 298 299 push_target (&st2000_ops); 300 301#if defined (LOG_FILE) 302 log_file = fopen (LOG_FILE, "w"); 303 if (log_file == NULL) 304 perror_with_name (LOG_FILE); 305#endif 306 307 /* Hello? Are you there? */ 308 printf_stdebug ("\003"); /* ^C wakes up dbug */ 309 310 expect_prompt (1); 311 312 if (from_tty) 313 printf ("Remote %s connected to %s\n", target_shortname, 314 dev_name); 315} 316 317/* Close out all files and local state before this target loses control. */ 318 319static void 320st2000_close (int quitting) 321{ 322 serial_close (st2000_desc); 323 324#if defined (LOG_FILE) 325 if (log_file) 326 { 327 if (ferror (log_file)) 328 fprintf_unfiltered (gdb_stderr, "Error writing log file.\n"); 329 if (fclose (log_file) != 0) 330 fprintf_unfiltered (gdb_stderr, "Error closing log file.\n"); 331 } 332#endif 333} 334 335/* Terminate the open connection to the remote debugger. 336 Use this when you want to detach and do something else 337 with your gdb. */ 338static void 339st2000_detach (int from_tty) 340{ 341 pop_target (); /* calls st2000_close to do the real work */ 342 if (from_tty) 343 printf ("Ending remote %s debugging\n", target_shortname); 344} 345 346/* Tell the remote machine to resume. */ 347 348static void 349st2000_resume (ptid_t ptid, int step, enum target_signal sig) 350{ 351 if (step) 352 { 353 printf_stdebug ("ST\r"); 354 /* Wait for the echo. */ 355 expect ("ST\r", 1); 356 } 357 else 358 { 359 printf_stdebug ("GO\r"); 360 /* Swallow the echo. */ 361 expect ("GO\r", 1); 362 } 363} 364 365/* Wait until the remote machine stops, then return, 366 storing status in STATUS just as `wait' would. */ 367 368static ptid_t 369st2000_wait (ptid_t ptid, struct target_waitstatus *status) 370{ 371 int old_timeout = timeout; 372 373 status->kind = TARGET_WAITKIND_EXITED; 374 status->value.integer = 0; 375 376 timeout = 0; /* Don't time out -- user program is running. */ 377 378 expect_prompt (0); /* Wait for prompt, outputting extraneous text */ 379 380 status->kind = TARGET_WAITKIND_STOPPED; 381 status->value.sig = TARGET_SIGNAL_TRAP; 382 383 timeout = old_timeout; 384 385 return inferior_ptid; 386} 387 388/* Return the name of register number REGNO in the form input and 389 output by STDEBUG. Currently, REGISTER_NAME just happens return 390 exactly what STDEBUG wants. Lets take advantage of that just as 391 long as possible! */ 392 393static char * 394get_reg_name (int regno) 395{ 396 static char buf[50]; 397 const char *p; 398 char *b; 399 400 b = buf; 401 402 for (p = REGISTER_NAME (regno); *p; p++) 403 *b++ = toupper (*p); 404 *b = '\000'; 405 406 return buf; 407} 408 409/* Read the remote registers into the block REGS. */ 410 411static void 412st2000_fetch_registers (void) 413{ 414 int regno; 415 416 /* Yeah yeah, I know this is horribly inefficient. But it isn't done 417 very often... I'll clean it up later. */ 418 419 for (regno = 0; regno <= PC_REGNUM; regno++) 420 st2000_fetch_register (regno); 421} 422 423/* Fetch register REGNO, or all registers if REGNO is -1. 424 Returns errno value. */ 425static void 426st2000_fetch_register (int regno) 427{ 428 if (regno == -1) 429 st2000_fetch_registers (); 430 else 431 { 432 char *name = get_reg_name (regno); 433 printf_stdebug ("DR %s\r", name); 434 expect (name, 1); 435 expect (" : ", 1); 436 get_hex_regs (1, regno); 437 expect_prompt (1); 438 } 439 return; 440} 441 442/* Store the remote registers from the contents of the block REGS. */ 443 444static void 445st2000_store_registers (void) 446{ 447 int regno; 448 449 for (regno = 0; regno <= PC_REGNUM; regno++) 450 st2000_store_register (regno); 451 452 registers_changed (); 453} 454 455/* Store register REGNO, or all if REGNO == 0. 456 Return errno value. */ 457static void 458st2000_store_register (int regno) 459{ 460 if (regno == -1) 461 st2000_store_registers (); 462 else 463 { 464 printf_stdebug ("PR %s %x\r", get_reg_name (regno), 465 read_register (regno)); 466 467 expect_prompt (1); 468 } 469} 470 471/* Get ready to modify the registers array. On machines which store 472 individual registers, this doesn't need to do anything. On machines 473 which store all the registers in one fell swoop, this makes sure 474 that registers contains all the registers from the program being 475 debugged. */ 476 477static void 478st2000_prepare_to_store (void) 479{ 480 /* Do nothing, since we can store individual regs */ 481} 482 483static void 484st2000_files_info (void) 485{ 486 printf ("\tAttached to %s at %d baud.\n", 487 dev_name, baudrate); 488} 489 490/* Copy LEN bytes of data from debugger memory at MYADDR 491 to inferior's memory at MEMADDR. Returns length moved. */ 492static int 493st2000_write_inferior_memory (CORE_ADDR memaddr, unsigned char *myaddr, int len) 494{ 495 int i; 496 497 for (i = 0; i < len; i++) 498 { 499 printf_stdebug ("PM.B %x %x\r", memaddr + i, myaddr[i]); 500 expect_prompt (1); 501 } 502 return len; 503} 504 505/* Read LEN bytes from inferior memory at MEMADDR. Put the result 506 at debugger address MYADDR. Returns length moved. */ 507static int 508st2000_read_inferior_memory (CORE_ADDR memaddr, char *myaddr, int len) 509{ 510 int i; 511 512 /* Number of bytes read so far. */ 513 int count; 514 515 /* Starting address of this pass. */ 516 unsigned long startaddr; 517 518 /* Number of bytes to read in this pass. */ 519 int len_this_pass; 520 521 /* Note that this code works correctly if startaddr is just less 522 than UINT_MAX (well, really CORE_ADDR_MAX if there was such a 523 thing). That is, something like 524 st2000_read_bytes (CORE_ADDR_MAX - 4, foo, 4) 525 works--it never adds len to memaddr and gets 0. */ 526 /* However, something like 527 st2000_read_bytes (CORE_ADDR_MAX - 3, foo, 4) 528 doesn't need to work. Detect it and give up if there's an attempt 529 to do that. */ 530 if (((memaddr - 1) + len) < memaddr) 531 { 532 errno = EIO; 533 return 0; 534 } 535 536 startaddr = memaddr; 537 count = 0; 538 while (count < len) 539 { 540 len_this_pass = 16; 541 if ((startaddr % 16) != 0) 542 len_this_pass -= startaddr % 16; 543 if (len_this_pass > (len - count)) 544 len_this_pass = (len - count); 545 546 printf_stdebug ("DI.L %x %x\r", startaddr, len_this_pass); 547 expect (": ", 1); 548 549 for (i = 0; i < len_this_pass; i++) 550 get_hex_byte (&myaddr[count++]); 551 552 expect_prompt (1); 553 554 startaddr += len_this_pass; 555 } 556 return len; 557} 558 559/* Transfer LEN bytes between GDB address MYADDR and target address 560 MEMADDR. If WRITE is non-zero, transfer them to the target, 561 otherwise transfer them from the target. TARGET is unused. 562 563 Returns the number of bytes transferred. */ 564 565static int 566st2000_xfer_inferior_memory (CORE_ADDR memaddr, char *myaddr, int len, 567 int write, struct mem_attrib *attrib, 568 struct target_ops *target) 569{ 570 if (write) 571 return st2000_write_inferior_memory (memaddr, myaddr, len); 572 else 573 return st2000_read_inferior_memory (memaddr, myaddr, len); 574} 575 576static void 577st2000_kill (char *args, int from_tty) 578{ 579 return; /* Ignore attempts to kill target system */ 580} 581 582/* Clean up when a program exits. 583 584 The program actually lives on in the remote processor's RAM, and may be 585 run again without a download. Don't leave it full of breakpoint 586 instructions. */ 587 588static void 589st2000_mourn_inferior (void) 590{ 591 remove_breakpoints (); 592 unpush_target (&st2000_ops); 593 generic_mourn_inferior (); /* Do all the proper things now */ 594} 595 596#define MAX_STDEBUG_BREAKPOINTS 16 597 598static CORE_ADDR breakaddr[MAX_STDEBUG_BREAKPOINTS] = 599{0}; 600 601static int 602st2000_insert_breakpoint (CORE_ADDR addr, char *shadow) 603{ 604 int i; 605 CORE_ADDR bp_addr = addr; 606 int bp_size = 0; 607 608 BREAKPOINT_FROM_PC (&bp_addr, &bp_size); 609 610 for (i = 0; i <= MAX_STDEBUG_BREAKPOINTS; i++) 611 if (breakaddr[i] == 0) 612 { 613 breakaddr[i] = addr; 614 615 st2000_read_inferior_memory (bp_addr, shadow, bp_size); 616 printf_stdebug ("BR %x H\r", addr); 617 expect_prompt (1); 618 return 0; 619 } 620 621 fprintf_unfiltered (gdb_stderr, "Too many breakpoints (> 16) for STDBUG\n"); 622 return 1; 623} 624 625static int 626st2000_remove_breakpoint (CORE_ADDR addr, char *shadow) 627{ 628 int i; 629 630 for (i = 0; i < MAX_STDEBUG_BREAKPOINTS; i++) 631 if (breakaddr[i] == addr) 632 { 633 breakaddr[i] = 0; 634 635 printf_stdebug ("CB %d\r", i); 636 expect_prompt (1); 637 return 0; 638 } 639 640 fprintf_unfiltered (gdb_stderr, 641 "Can't find breakpoint associated with 0x%x\n", addr); 642 return 1; 643} 644 645 646/* Put a command string, in args, out to STDBUG. Output from STDBUG is placed 647 on the users terminal until the prompt is seen. */ 648 649static void 650st2000_command (char *args, int fromtty) 651{ 652 if (!st2000_desc) 653 error ("st2000 target not open."); 654 655 if (!args) 656 error ("Missing command."); 657 658 printf_stdebug ("%s\r", args); 659 expect_prompt (0); 660} 661 662/* Connect the user directly to STDBUG. This command acts just like the 663 'cu' or 'tip' command. Use <CR>~. or <CR>~^D to break out. */ 664 665/*static struct ttystate ttystate; */ 666 667static void 668cleanup_tty (void) 669{ 670 printf ("\r\n[Exiting connect mode]\r\n"); 671/* serial_restore(0, &ttystate); */ 672} 673 674#if 0 675/* This all should now be in serial.c */ 676 677static void 678connect_command (char *args, int fromtty) 679{ 680 fd_set readfds; 681 int numfds; 682 int c; 683 char cur_esc = 0; 684 685 dont_repeat (); 686 687 if (st2000_desc < 0) 688 error ("st2000 target not open."); 689 690 if (args) 691 fprintf ("This command takes no args. They have been ignored.\n"); 692 693 printf ("[Entering connect mode. Use ~. or ~^D to escape]\n"); 694 695 serial_raw (0, &ttystate); 696 697 make_cleanup (cleanup_tty, 0); 698 699 FD_ZERO (&readfds); 700 701 while (1) 702 { 703 do 704 { 705 FD_SET (0, &readfds); 706 FD_SET (deprecated_serial_fd (st2000_desc), &readfds); 707 numfds = select (sizeof (readfds) * 8, &readfds, 0, 0, 0); 708 } 709 while (numfds == 0); 710 711 if (numfds < 0) 712 perror_with_name ("select"); 713 714 if (FD_ISSET (0, &readfds)) 715 { /* tty input, send to stdebug */ 716 c = getchar (); 717 if (c < 0) 718 perror_with_name ("connect"); 719 720 printf_stdebug ("%c", c); 721 switch (cur_esc) 722 { 723 case 0: 724 if (c == '\r') 725 cur_esc = c; 726 break; 727 case '\r': 728 if (c == '~') 729 cur_esc = c; 730 else 731 cur_esc = 0; 732 break; 733 case '~': 734 if (c == '.' || c == '\004') 735 return; 736 else 737 cur_esc = 0; 738 } 739 } 740 741 if (FD_ISSET (deprecated_serial_fd (st2000_desc), &readfds)) 742 { 743 while (1) 744 { 745 c = readchar (0); 746 if (c < 0) 747 break; 748 putchar (c); 749 } 750 fflush (stdout); 751 } 752 } 753} 754#endif /* 0 */ 755 756/* Define the target subroutine names */ 757 758struct target_ops st2000_ops; 759 760static void 761init_st2000_ops (void) 762{ 763 st2000_ops.to_shortname = "st2000"; 764 st2000_ops.to_longname = "Remote serial Tandem ST2000 target"; 765 st2000_ops.to_doc = "Use a remote computer running STDEBUG connected by a serial line;\n\ 766or a network connection.\n\ 767Arguments are the name of the device for the serial line,\n\ 768the speed to connect at in bits per second."; 769 st2000_ops.to_open = st2000_open; 770 st2000_ops.to_close = st2000_close; 771 st2000_ops.to_detach = st2000_detach; 772 st2000_ops.to_resume = st2000_resume; 773 st2000_ops.to_wait = st2000_wait; 774 st2000_ops.to_fetch_registers = st2000_fetch_register; 775 st2000_ops.to_store_registers = st2000_store_register; 776 st2000_ops.to_prepare_to_store = st2000_prepare_to_store; 777 st2000_ops.to_xfer_memory = st2000_xfer_inferior_memory; 778 st2000_ops.to_files_info = st2000_files_info; 779 st2000_ops.to_insert_breakpoint = st2000_insert_breakpoint; 780 st2000_ops.to_remove_breakpoint = st2000_remove_breakpoint; /* Breakpoints */ 781 st2000_ops.to_kill = st2000_kill; 782 st2000_ops.to_create_inferior = st2000_create_inferior; 783 st2000_ops.to_mourn_inferior = st2000_mourn_inferior; 784 st2000_ops.to_stratum = process_stratum; 785 st2000_ops.to_has_all_memory = 1; 786 st2000_ops.to_has_memory = 1; 787 st2000_ops.to_has_stack = 1; 788 st2000_ops.to_has_registers = 1; 789 st2000_ops.to_has_execution = 1; /* all mem, mem, stack, regs, exec */ 790 st2000_ops.to_magic = OPS_MAGIC; /* Always the last thing */ 791}; 792 793void 794_initialize_remote_st2000 (void) 795{ 796 init_st2000_ops (); 797 add_target (&st2000_ops); 798 add_com ("st2000 <command>", class_obscure, st2000_command, 799 "Send a command to the STDBUG monitor."); 800 add_com ("connect", class_obscure, connect_command, 801 "Connect the terminal directly up to the STDBUG command monitor.\n\ 802Use <CR>~. or <CR>~^D to break out."); 803} 804