1 /* Memory-access and commands for remote VxWorks processes, for GDB.
2 Copyright 1990, 1991, 1992 Free Software Foundation, Inc.
3 Contributed by Wind River Systems and Cygnus Support.
5 This file is part of GDB.
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 2 of the License, or
10 (at your option) any later version.
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with this program; if not, write to the Free Software
19 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */
29 #include "complaints.h"
31 #include "bfd.h" /* Required by objfiles.h. */
32 #include "symfile.h" /* Required by objfiles.h. */
34 #include "gdb-stabs.h"
40 #include <sys/types.h>
41 #include <sys/socket.h>
42 #define malloc bogon_malloc /* Sun claims "char *malloc()" not void * */
43 #define free bogon_free /* Sun claims "int free()" not void */
44 #define realloc bogon_realloc /* Sun claims "char *realloc()", not void * */
49 #include <sys/time.h> /* UTek's <rpc/rpc.h> doesn't #incl this */
51 #include "vx-share/ptrace.h"
52 #include "vx-share/xdr_ptrace.h"
53 #include "vx-share/xdr_ld.h"
54 #include "vx-share/xdr_rdb.h"
55 #include "vx-share/dbgRpcLib.h"
59 extern void symbol_file_command ();
60 extern int stop_soon_quietly; /* for wait_for_inferior */
62 static int net_ptrace_clnt_call (); /* Forward decl */
63 static enum clnt_stat net_clnt_call (); /* Forward decl */
64 extern struct target_ops vx_ops, vx_run_ops; /* Forward declaration */
66 /* Saved name of target host and called function for "info files".
70 static char *vx_running; /* Called function */
72 /* Nonzero means target that is being debugged remotely has a floating
75 static int target_has_fp;
77 /* Default error message when the network is forking up. */
79 static const char rpcerr[] = "network target debugging: rpc error";
81 CLIENT *pClient; /* client used in net debugging */
82 static int ptraceSock = RPC_ANYSOCK;
84 enum clnt_stat net_clnt_call();
85 static void parse_args ();
87 static struct timeval rpcTimeout = { 10, 0 };
89 static char *skip_white_space ();
90 static char *find_white_space ();
92 /* Tell the VxWorks target system to download a file.
93 The load addresses of the text, data, and bss segments are
94 stored in *pTextAddr, *pDataAddr, and *pBssAddr (respectively).
95 Returns 0 for success, -1 for failure. */
98 net_load (filename, pTextAddr, pDataAddr, pBssAddr)
100 CORE_ADDR *pTextAddr;
101 CORE_ADDR *pDataAddr;
104 enum clnt_stat status;
105 struct ldfile ldstruct;
106 struct timeval load_timeout;
108 memset ((char *) &ldstruct, '\0', sizeof (ldstruct));
110 /* We invoke clnt_call () here directly, instead of through
111 net_clnt_call (), because we need to set a large timeout value.
112 The load on the target side can take quite a while, easily
113 more than 10 seconds. The user can kill this call by typing
114 CTRL-C if there really is a problem with the load.
116 Do not change the tv_sec value without checking -- select() imposes
117 a limit of 10**8 on it for no good reason that I can see... */
119 load_timeout.tv_sec = 99999999; /* A large number, effectively inf. */
120 load_timeout.tv_usec = 0;
122 status = clnt_call (pClient, VX_LOAD, xdr_wrapstring, &filename, xdr_ldfile,
123 &ldstruct, load_timeout);
125 if (status == RPC_SUCCESS)
127 if (*ldstruct.name == 0) /* load failed on VxWorks side */
129 *pTextAddr = ldstruct.txt_addr;
130 *pDataAddr = ldstruct.data_addr;
131 *pBssAddr = ldstruct.bss_addr;
138 /* returns 0 if successful, errno if RPC failed or VxWorks complains. */
141 net_break (addr, procnum)
145 enum clnt_stat status;
147 Rptrace ptrace_in; /* XXX This is stupid. It doesn't need to be a ptrace
148 structure. How about something smaller? */
150 memset ((char *) &ptrace_in, '\0', sizeof (ptrace_in));
153 ptrace_in.addr = addr;
154 ptrace_in.pid = inferior_pid;
156 status = net_clnt_call (procnum, xdr_rptrace, &ptrace_in, xdr_int,
159 if (status != RPC_SUCCESS)
162 if (break_status == -1)
164 return break_status; /* probably (FIXME) zero */
167 /* returns 0 if successful, errno otherwise */
170 vx_insert_breakpoint (addr)
173 return net_break (addr, VX_BREAK_ADD);
176 /* returns 0 if successful, errno otherwise */
179 vx_remove_breakpoint (addr)
182 return net_break (addr, VX_BREAK_DELETE);
185 /* Start an inferior process and sets inferior_pid to its pid.
186 EXEC_FILE is the file to run.
187 ALLARGS is a string containing the arguments to the program.
188 ENV is the environment vector to pass.
189 Returns process id. Errors reported with error().
190 On VxWorks, we ignore exec_file. */
193 vx_create_inferior (exec_file, args, env)
198 enum clnt_stat status;
200 TASK_START taskStart;
202 memset ((char *) &passArgs, '\0', sizeof (passArgs));
203 memset ((char *) &taskStart, '\0', sizeof (taskStart));
205 /* parse arguments, put them in passArgs */
207 parse_args (args, &passArgs);
209 if (passArgs.arg_array_len == 0)
210 error ("You must specify a function name to run, and arguments if any");
212 status = net_clnt_call (PROCESS_START, xdr_arg_array, &passArgs,
213 xdr_TASK_START, &taskStart);
215 if ((status != RPC_SUCCESS) || (taskStart.status == -1))
216 error ("Can't create process on remote target machine");
218 /* Save the name of the running function */
219 vx_running = savestring (passArgs.arg_array_val[0],
220 strlen (passArgs.arg_array_val[0]));
222 push_target (&vx_run_ops);
223 inferior_pid = taskStart.pid;
225 /* We will get a trace trap after one instruction.
226 Insert breakpoints and continue. */
228 init_wait_for_inferior ();
230 /* Set up the "saved terminal modes" of the inferior
231 based on what modes we are starting it with. */
232 target_terminal_init ();
234 /* Install inferior's terminal modes. */
235 target_terminal_inferior ();
237 stop_soon_quietly = 1;
238 wait_for_inferior (); /* Get the task spawn event */
239 stop_soon_quietly = 0;
241 /* insert_step_breakpoint (); FIXME, do we need this? */
242 proceed (-1, TARGET_SIGNAL_DEFAULT, 0);
245 /* Fill ARGSTRUCT in argc/argv form with the arguments from the
246 argument string ARGSTRING. */
249 parse_args (arg_string, arg_struct)
250 register char *arg_string;
251 arg_array *arg_struct;
253 register int arg_count = 0; /* number of arguments */
254 register int arg_index = 0;
257 memset ((char *) arg_struct, '\0', sizeof (arg_array));
259 /* first count how many arguments there are */
264 if (*(p0 = skip_white_space (p0)) == '\0')
266 p0 = find_white_space (p0);
270 arg_struct->arg_array_len = arg_count;
271 arg_struct->arg_array_val = (char **) xmalloc ((arg_count + 1)
274 /* now copy argument strings into arg_struct. */
276 while (*(arg_string = skip_white_space (arg_string)))
278 p0 = find_white_space (arg_string);
279 arg_struct->arg_array_val[arg_index++] = savestring (arg_string,
284 arg_struct->arg_array_val[arg_count] = NULL;
287 /* Advance a string pointer across whitespace and return a pointer
288 to the first non-white character. */
294 while (*p == ' ' || *p == '\t')
299 /* Search for the first unquoted whitespace character in a string.
300 Returns a pointer to the character, or to the null terminator
301 if no whitespace is found. */
309 while ((c = *p) != ' ' && c != '\t' && c)
311 if (c == '\'' || c == '"')
313 while (*++p != c && *p)
326 /* Poll the VxWorks target system for an event related
327 to the debugged task.
328 Returns -1 if remote wait failed, task status otherwise. */
335 enum clnt_stat status;
337 memset ((char *) pEvent, '\0', sizeof (RDB_EVENT));
340 status = net_clnt_call (PROCESS_WAIT, xdr_int, &pid, xdr_RDB_EVENT,
343 return (status == RPC_SUCCESS)? pEvent->status: -1;
346 /* Suspend the remote task.
347 Returns -1 if suspend fails on target system, 0 otherwise. */
354 enum clnt_stat status;
358 /* don't let rdbTask suspend itself by passing a pid of 0 */
360 if ((pid = inferior_pid) == 0)
363 status = net_clnt_call (VX_TASK_SUSPEND, xdr_int, &pid, xdr_int,
366 return (status == RPC_SUCCESS)? quit_status: -1;
369 /* Read a register or registers from the remote system. */
372 vx_read_register (regno)
377 Ptrace_return ptrace_out;
380 extern char registers[];
382 memset ((char *) &ptrace_in, '\0', sizeof (ptrace_in));
383 memset ((char *) &ptrace_out, '\0', sizeof (ptrace_out));
385 /* FIXME, eventually only get the ones we need. */
386 registers_fetched ();
388 ptrace_in.pid = inferior_pid;
389 ptrace_out.info.more_data = (caddr_t) &out_data;
390 out_data.len = VX_NUM_REGS * REGISTER_RAW_SIZE (0);
391 out_data.bytes = (caddr_t) registers;
393 status = net_ptrace_clnt_call (PTRACE_GETREGS, &ptrace_in, &ptrace_out);
396 if (ptrace_out.status == -1)
398 errno = ptrace_out.errno;
399 perror_with_name ("net_ptrace_clnt_call(PTRACE_GETREGS)");
402 #ifdef VX_SIZE_FPREGS
403 /* If the target has floating point registers, fetch them.
404 Otherwise, zero the floating point register values in
405 registers[] for good measure, even though we might not
410 ptrace_in.pid = inferior_pid;
411 ptrace_out.info.more_data = (caddr_t) &out_data;
412 out_data.len = VX_SIZE_FPREGS;
413 out_data.bytes = (caddr_t) ®isters[REGISTER_BYTE (FP0_REGNUM)];
415 status = net_ptrace_clnt_call (PTRACE_GETFPREGS, &ptrace_in, &ptrace_out);
418 if (ptrace_out.status == -1)
420 errno = ptrace_out.errno;
421 perror_with_name ("net_ptrace_clnt_call(PTRACE_GETFPREGS)");
426 memset (®isters[REGISTER_BYTE (FP0_REGNUM)], '\0', VX_SIZE_FPREGS);
428 #endif /* VX_SIZE_FPREGS */
431 /* Prepare to store registers. Since we will store all of them,
432 read out their current values now. */
435 vx_prepare_to_store ()
437 /* Fetch all registers, if any of them are not yet fetched. */
438 read_register_bytes (0, NULL, REGISTER_BYTES);
442 /* Store our register values back into the inferior.
443 If REGNO is -1, do this for all registers.
444 Otherwise, REGNO specifies which register (so we can save time). */
445 /* FIXME, look at REGNO to save time here */
448 vx_write_register (regno)
453 extern char registers[];
456 Ptrace_return ptrace_out;
458 memset ((char *) &ptrace_in, '\0', sizeof (ptrace_in));
459 memset ((char *) &ptrace_out, '\0', sizeof (ptrace_out));
461 ptrace_in.pid = inferior_pid;
462 ptrace_in.info.ttype = DATA;
463 ptrace_in.info.more_data = (caddr_t) &in_data;
465 in_data.bytes = registers;
467 in_data.len = VX_NUM_REGS * REGISTER_SIZE;
469 /* XXX change second param to be a proc number */
470 status = net_ptrace_clnt_call (PTRACE_SETREGS, &ptrace_in, &ptrace_out);
473 if (ptrace_out.status == -1)
475 errno = ptrace_out.errno;
476 perror_with_name ("net_ptrace_clnt_call(PTRACE_SETREGS)");
479 #ifdef VX_SIZE_FPREGS
480 /* Store floating point registers if the target has them. */
484 ptrace_in.pid = inferior_pid;
485 ptrace_in.info.ttype = DATA;
486 ptrace_in.info.more_data = (caddr_t) &in_data;
489 in_data.bytes = ®isters[REGISTER_BYTE (FP0_REGNUM)];
490 in_data.len = VX_SIZE_FPREGS;
492 status = net_ptrace_clnt_call (PTRACE_SETFPREGS, &ptrace_in,
496 if (ptrace_out.status == -1)
498 errno = ptrace_out.errno;
499 perror_with_name ("net_ptrace_clnt_call(PTRACE_SETFPREGS)");
502 #endif /* VX_SIZE_FPREGS */
505 /* Copy LEN bytes to or from remote inferior's memory starting at MEMADDR
506 to debugger memory starting at MYADDR. WRITE is true if writing to the
508 Result is the number of bytes written or read (zero if error). The
509 protocol allows us to return a negative count, indicating that we can't
510 handle the current address but can handle one N bytes further, but
511 vxworks doesn't give us that information. */
514 vx_xfer_memory (memaddr, myaddr, len, write, target)
519 struct target_ops *target; /* ignored */
523 Ptrace_return ptrace_out;
526 memset ((char *) &ptrace_in, '\0', sizeof (ptrace_in));
527 memset ((char *) &ptrace_out, '\0', sizeof (ptrace_out));
529 ptrace_in.pid = inferior_pid; /* XXX pid unnecessary for READDATA */
530 ptrace_in.addr = (int) memaddr; /* Where from */
531 ptrace_in.data = len; /* How many bytes */
535 ptrace_in.info.ttype = DATA;
536 ptrace_in.info.more_data = (caddr_t) &data;
538 data.bytes = (caddr_t) myaddr; /* Where from */
539 data.len = len; /* How many bytes (again, for XDR) */
541 /* XXX change second param to be a proc number */
542 status = net_ptrace_clnt_call (PTRACE_WRITEDATA, &ptrace_in,
547 ptrace_out.info.more_data = (caddr_t) &data;
548 data.bytes = myaddr; /* Where to */
549 data.len = len; /* How many (again, for XDR) */
551 /* XXX change second param to be a proc number */
552 status = net_ptrace_clnt_call (PTRACE_READDATA, &ptrace_in, &ptrace_out);
557 if (ptrace_out.status == -1)
559 return 0; /* No bytes moved */
561 return len; /* Moved *all* the bytes */
567 printf_unfiltered ("\tAttached to host `%s'", vx_host);
568 printf_unfiltered (", which has %sfloating point", target_has_fp? "": "no ");
569 printf_unfiltered (".\n");
575 printf_unfiltered ("\tRunning %s VxWorks process %s",
576 vx_running ? "child" : "attached",
577 local_hex_string (inferior_pid));
579 printf_unfiltered (", function `%s'", vx_running);
580 printf_unfiltered(".\n");
584 vx_resume (pid, step, siggnal)
587 enum target_signal siggnal;
591 Ptrace_return ptrace_out;
596 if (siggnal != 0 && siggnal != stop_signal)
597 error ("Cannot send signals to VxWorks processes");
599 memset ((char *) &ptrace_in, '\0', sizeof (ptrace_in));
600 memset ((char *) &ptrace_out, '\0', sizeof (ptrace_out));
603 ptrace_in.addr = 1; /* Target side insists on this, or it panics. */
605 /* XXX change second param to be a proc number */
606 status = net_ptrace_clnt_call (step? PTRACE_SINGLESTEP: PTRACE_CONT,
607 &ptrace_in, &ptrace_out);
610 if (ptrace_out.status == -1)
612 errno = ptrace_out.errno;
613 perror_with_name ("Resuming remote process");
620 pop_target (); /* Pop back to no-child state */
621 generic_mourn_inferior ();
625 static void vx_add_symbols PARAMS ((char *, int, CORE_ADDR, CORE_ADDR,
628 struct find_sect_args {
629 CORE_ADDR text_start;
630 CORE_ADDR data_start;
634 static void find_sect PARAMS ((bfd *, asection *, void *));
637 find_sect (abfd, sect, obj)
642 struct find_sect_args *args = (struct find_sect_args *)obj;
644 if (bfd_get_section_flags (abfd, sect) & (SEC_CODE & SEC_READONLY))
645 args->text_start = bfd_get_section_vma (abfd, sect);
646 else if (bfd_get_section_flags (abfd, sect) & SEC_ALLOC)
648 if (bfd_get_section_flags (abfd, sect) & SEC_LOAD)
650 /* Exclude .ctor and .dtor sections which have SEC_CODE set but not
652 if (bfd_get_section_flags (abfd, sect) & SEC_DATA)
653 args->data_start = bfd_get_section_vma (abfd, sect);
656 args->bss_start = bfd_get_section_vma (abfd, sect);
661 vx_add_symbols (name, from_tty, text_addr, data_addr, bss_addr)
668 struct section_offsets *offs;
669 struct objfile *objfile;
670 struct find_sect_args ss;
672 objfile = symbol_file_add (name, from_tty, 0, 0, 0, 0);
673 offs = (struct section_offsets *)
674 alloca (sizeof (struct section_offsets)
675 + objfile->num_sections * sizeof (offs->offsets));
676 memcpy (offs, objfile->section_offsets,
677 sizeof (struct section_offsets)
678 + objfile->num_sections * sizeof (offs->offsets));
683 bfd_map_over_sections (objfile->obfd, find_sect, &ss);
685 /* Both COFF and b.out frontends use these SECT_OFF_* values. */
686 ANOFFSET (offs, SECT_OFF_TEXT) = text_addr - ss.text_start;
687 ANOFFSET (offs, SECT_OFF_DATA) = data_addr - ss.data_start;
688 ANOFFSET (offs, SECT_OFF_BSS) = bss_addr - ss.bss_start;
689 objfile_relocate (objfile, offs);
692 /* This function allows the addition of incrementally linked object files. */
695 vx_load_command (arg_string, from_tty)
704 error ("The load command takes a file name");
706 arg_string = tilde_expand (arg_string);
707 make_cleanup (free, arg_string);
713 if (net_load (arg_string, &text_addr, &data_addr, &bss_addr) == -1)
714 error ("Load failed on target machine");
717 vx_add_symbols (arg_string, from_tty, text_addr, data_addr, bss_addr);
719 /* Getting new symbols may change our opinion about what is
721 reinit_frame_cache ();
724 #ifdef FIXME /* Not ready for prime time */
725 /* Single step the target program at the source or machine level.
726 Takes an error exit if rpc fails.
727 Returns -1 if remote single-step operation fails, else 0. */
732 enum clnt_stat status;
734 SOURCE_STEP source_step;
736 source_step.taskId = inferior_pid;
740 source_step.startAddr = step_range_start;
741 source_step.endAddr = step_range_end;
745 source_step.startAddr = 0;
746 source_step.endAddr = 0;
749 status = net_clnt_call (VX_SOURCE_STEP, xdr_SOURCE_STEP, &source_step,
750 xdr_int, &step_status);
752 if (status == RPC_SUCCESS)
759 /* Emulate ptrace using RPC calls to the VxWorks target system.
760 Returns nonzero (-1) if RPC status to VxWorks is bad, 0 otherwise. */
763 net_ptrace_clnt_call (request, pPtraceIn, pPtraceOut)
764 enum ptracereq request;
766 Ptrace_return *pPtraceOut;
768 enum clnt_stat status;
770 status = net_clnt_call (request, xdr_rptrace, pPtraceIn, xdr_ptrace_return,
773 if (status != RPC_SUCCESS)
779 /* Query the target for the name of the file from which VxWorks was
780 booted. pBootFile is the address of a pointer to the buffer to
781 receive the file name; if the pointer pointed to by pBootFile is
782 NULL, memory for the buffer will be allocated by XDR.
783 Returns -1 if rpc failed, 0 otherwise. */
786 net_get_boot_file (pBootFile)
789 enum clnt_stat status;
791 status = net_clnt_call (VX_BOOT_FILE_INQ, xdr_void, (char *) 0,
792 xdr_wrapstring, pBootFile);
793 return (status == RPC_SUCCESS) ? 0 : -1;
796 /* Fetch a list of loaded object modules from the VxWorks target.
797 Returns -1 if rpc failed, 0 otherwise
798 There's no way to check if the returned loadTable is correct.
799 VxWorks doesn't check it. */
802 net_get_symbols (pLoadTable)
803 ldtabl *pLoadTable; /* return pointer to ldtabl here */
805 enum clnt_stat status;
807 memset ((char *) pLoadTable, '\0', sizeof (struct ldtabl));
809 status = net_clnt_call (VX_STATE_INQ, xdr_void, 0, xdr_ldtabl, pLoadTable);
810 return (status == RPC_SUCCESS) ? 0 : -1;
813 /* Look up a symbol in the VxWorks target's symbol table.
814 Returns status of symbol read on target side (0=success, -1=fail)
815 Returns -1 and complain()s if rpc fails. */
817 struct complaint cant_contact_target =
818 {"Lost contact with VxWorks target", 0, 0};
821 vx_lookup_symbol (name, pAddr)
822 char *name; /* symbol name */
825 enum clnt_stat status;
826 SYMBOL_ADDR symbolAddr;
829 memset ((char *) &symbolAddr, '\0', sizeof (symbolAddr));
831 status = net_clnt_call (VX_SYMBOL_INQ, xdr_wrapstring, &name,
832 xdr_SYMBOL_ADDR, &symbolAddr);
833 if (status != RPC_SUCCESS)
835 complain (&cant_contact_target);
839 *pAddr = symbolAddr.addr;
840 return symbolAddr.status;
843 /* Check to see if the VxWorks target has a floating point coprocessor.
844 Returns 1 if target has floating point processor, 0 otherwise.
845 Calls error() if rpc fails. */
850 enum clnt_stat status;
851 bool_t fp = 0; /* true if fp processor is present on target board */
853 status = net_clnt_call (VX_FP_INQUIRE, xdr_void, 0, xdr_bool, &fp);
854 if (status != RPC_SUCCESS)
860 /* Establish an RPC connection with the VxWorks target system.
861 Calls error () if unable to establish connection. */
867 struct sockaddr_in destAddr;
868 struct hostent *destHost;
871 /* Get the internet address for the given host. Allow a numeric
872 IP address or a hostname. */
874 addr = inet_addr (host);
877 destHost = (struct hostent *) gethostbyname (host);
878 if (destHost == NULL)
879 /* FIXME: Probably should include hostname here in quotes.
880 For example if the user types "target vxworks vx960 " it should
881 say "Invalid host `vx960 '." not just "Invalid hostname". */
882 error ("Invalid hostname. Couldn't find remote host address.");
883 addr = * (unsigned long *) destHost->h_addr;
886 memset (&destAddr, '\0', sizeof (destAddr));
888 destAddr.sin_addr.s_addr = addr;
889 destAddr.sin_family = AF_INET;
890 destAddr.sin_port = 0; /* set to actual port that remote
891 ptrace is listening on. */
893 /* Create a tcp client transport on which to issue
894 calls to the remote ptrace server. */
896 ptraceSock = RPC_ANYSOCK;
897 pClient = clnttcp_create (&destAddr, RDBPROG, RDBVERS, &ptraceSock, 0, 0);
898 /* FIXME, here is where we deal with different version numbers of the
903 clnt_pcreateerror ("\tnet_connect");
904 error ("Couldn't connect to remote target.");
908 /* Sleep for the specified number of milliseconds
909 * (assumed to be less than 1000).
910 * If select () is interrupted, returns immediately;
911 * takes an error exit if select () fails for some other reason.
918 struct timeval select_timeout;
921 select_timeout.tv_sec = 0;
922 select_timeout.tv_usec = ms * 1000;
924 status = select (0, (fd_set *) 0, (fd_set *) 0, (fd_set *) 0,
927 if (status < 0 && errno != EINTR)
928 perror_with_name ("select");
932 vx_wait (pid_to_wait_for, status)
934 struct target_waitstatus *status;
942 /* If CTRL-C is hit during this loop,
943 suspend the inferior process. */
948 quit_failed = (net_quit () == -1);
952 /* If a net_quit () or net_wait () call has failed,
953 allow the user to break the connection with the target.
954 We can't simply error () out of this loop, since the
955 data structures representing the state of the inferior
956 are in an inconsistent state. */
958 if (quit_failed || net_wait (&rdbEvent) == -1)
961 if (query ("Can't %s. Disconnect from target system? ",
962 (quit_failed) ? "suspend remote task"
963 : "get status of remote task"))
965 target_mourn_inferior();
966 error ("Use the \"target\" command to reconnect.");
970 terminal_inferior ();
975 pid = rdbEvent.taskId;
978 sleep_ms (200); /* FIXME Don't kill the network too badly */
980 else if (pid != inferior_pid)
981 fatal ("Bad pid for debugged task: %s\n",
982 local_hex_string((unsigned long) pid));
985 /* The mostly likely kind. */
986 status->kind = TARGET_WAITKIND_STOPPED;
988 switch (rdbEvent.eventType)
991 status->kind = TARGET_WAITKIND_EXITED;
992 /* FIXME is it possible to distinguish between a
993 normal vs abnormal exit in VxWorks? */
994 status->value.integer = 0;
998 /* Task was just started. */
999 status->value.sig = TARGET_SIGNAL_TRAP;
1003 status->value.sig = TARGET_SIGNAL_TRAP;
1004 /* XXX was it stopped by a signal? act accordingly */
1007 case EVENT_BREAK: /* Breakpoint was hit. */
1008 status->value.sig = TARGET_SIGNAL_TRAP;
1011 case EVENT_SUSPEND: /* Task was suspended, probably by ^C. */
1012 status->value.sig = TARGET_SIGNAL_INT;
1015 case EVENT_BUS_ERR: /* Task made evil nasty reference. */
1016 status->value.sig = TARGET_SIGNAL_BUS;
1019 case EVENT_ZERO_DIV: /* Division by zero */
1020 status->value.sig = TARGET_SIGNAL_FPE;
1025 status->value.sig = i960_fault_to_signal (rdbEvent.sigType);
1027 /* Back in the old days, before enum target_signal, this code used
1028 to add NSIG to the signal number and claim that PRINT_RANDOM_SIGNAL
1029 would take care of it. But PRINT_RANDOM_SIGNAL has never been
1030 defined except on the i960, so I don't really know what we are
1031 supposed to do on other architectures. */
1032 status->value.sig = TARGET_SIGNAL_UNKNOWN;
1043 symbol_file_command (arg, 0);
1048 add_symbol_stub (arg)
1051 struct ldfile *pLoadFile = (struct ldfile *)arg;
1053 printf_unfiltered("\t%s: ", pLoadFile->name);
1054 vx_add_symbols (pLoadFile->name, 0, pLoadFile->txt_addr,
1055 pLoadFile->data_addr, pLoadFile->bss_addr);
1056 printf_unfiltered ("ok\n");
1059 /* Target command for VxWorks target systems.
1061 Used in vxgdb. Takes the name of a remote target machine
1062 running vxWorks and connects to it to initialize remote network
1066 vx_open (args, from_tty)
1070 extern int close ();
1072 extern char *source_path;
1073 struct ldtabl loadTable;
1074 struct ldfile *pLoadFile;
1076 extern CLIENT *pClient;
1077 int symbols_added = 0;
1080 error_no_arg ("target machine name");
1082 target_preopen (from_tty);
1084 unpush_target (&vx_ops);
1085 printf_unfiltered ("Attaching remote machine across net...\n");
1086 gdb_flush (gdb_stdout);
1088 /* Allow the user to kill the connect attempt by typing ^C.
1089 Wait until the call to target_has_fp () completes before
1090 disallowing an immediate quit, since even if net_connect ()
1091 is successful, the remote debug server might be hung. */
1096 target_has_fp = net_check_for_fp ();
1097 printf_filtered ("Connected to %s.\n", args);
1101 push_target (&vx_ops);
1103 /* Save a copy of the target host's name. */
1104 vx_host = savestring (args, strlen (args));
1106 /* Find out the name of the file from which the target was booted
1107 and load its symbol table. */
1109 printf_filtered ("Looking in Unix path for all loaded modules:\n");
1111 if (!net_get_boot_file (&bootFile))
1115 printf_filtered ("\t%s: ", bootFile);
1116 /* This assumes that the kernel is never relocated. Hope that is an
1117 accurate assumption. */
1121 "Error while reading symbols from boot file:\n",
1123 puts_filtered ("ok\n");
1126 printf_unfiltered ("VxWorks kernel symbols not loaded.\n");
1129 error ("Can't retrieve boot file name from target machine.");
1131 clnt_freeres (pClient, xdr_wrapstring, &bootFile);
1133 if (net_get_symbols (&loadTable) != 0)
1134 error ("Can't read loaded modules from target machine");
1137 while (++i < loadTable.tbl_size)
1139 QUIT; /* FIXME, avoids clnt_freeres below: mem leak */
1140 pLoadFile = &loadTable.tbl_ent [i];
1144 struct cleanup *old_chain;
1145 char *fullname = NULL;
1147 desc = openp (source_path, 0, pLoadFile->name, O_RDONLY, 0, &fullname);
1149 perror_with_name (pLoadFile->name);
1150 old_chain = make_cleanup (close, desc);
1151 add_file_at_addr (fullname, desc, pLoadFile->txt_addr, pLoadFile->data_addr,
1152 pLoadFile->bss_addr);
1153 do_cleanups (old_chain);
1156 /* FIXME: Is there something better to search than the PATH? (probably
1157 not the source path, since source might be in different directories
1160 if (catch_errors (add_symbol_stub, (char *)pLoadFile, (char *)0,
1165 printf_filtered ("Done.\n");
1167 clnt_freeres (pClient, xdr_ldtabl, &loadTable);
1169 /* Getting new symbols may change our opinion about what is
1172 reinit_frame_cache ();
1175 /* Takes a task started up outside of gdb and ``attaches'' to it.
1176 This stops it cold in its tracks and allows us to start tracing it. */
1179 vx_attach (args, from_tty)
1186 Ptrace_return ptrace_out;
1190 error_no_arg ("process-id to attach");
1192 pid = strtoul (args, &cptr, 0);
1193 if ((cptr == args) || (*cptr != '\0'))
1194 error ("Invalid process-id -- give a single number in decimal or 0xhex");
1197 printf_unfiltered ("Attaching pid %s.\n",
1198 local_hex_string((unsigned long) pid));
1200 memset ((char *)&ptrace_in, '\0', sizeof (ptrace_in));
1201 memset ((char *)&ptrace_out, '\0', sizeof (ptrace_out));
1202 ptrace_in.pid = pid;
1204 status = net_ptrace_clnt_call (PTRACE_ATTACH, &ptrace_in, &ptrace_out);
1207 if (ptrace_out.status == -1)
1209 errno = ptrace_out.errno;
1210 perror_with_name ("Attaching remote process");
1214 push_target (&vx_run_ops);
1215 /* The unsigned long pid will get turned into a signed int here,
1216 but it doesn't seem to matter. inferior_pid must be signed
1217 in order for other parts of GDB to work correctly. */
1223 /* detach_command --
1224 takes a program previously attached to and detaches it.
1225 The program resumes execution and will no longer stop
1226 on signals, etc. We better not have left any breakpoints
1227 in the program or it'll die when it hits one. For this
1228 to work, it may be necessary for the process to have been
1229 previously attached. It *might* work if the program was
1230 started via the normal ptrace (PTRACE_TRACEME). */
1233 vx_detach (args, from_tty)
1238 Ptrace_return ptrace_out;
1243 error ("Argument given to VxWorks \"detach\".");
1246 printf_unfiltered ("Detaching pid %s.\n",
1247 local_hex_string((unsigned long) inferior_pid));
1249 if (args) /* FIXME, should be possible to leave suspended */
1250 signal = atoi (args);
1252 memset ((char *)&ptrace_in, '\0', sizeof (ptrace_in));
1253 memset ((char *)&ptrace_out, '\0', sizeof (ptrace_out));
1254 ptrace_in.pid = inferior_pid;
1256 status = net_ptrace_clnt_call (PTRACE_DETACH, &ptrace_in, &ptrace_out);
1259 if (ptrace_out.status == -1)
1261 errno = ptrace_out.errno;
1262 perror_with_name ("Detaching VxWorks process");
1266 pop_target (); /* go back to non-executing VxWorks connection */
1269 /* vx_kill -- takes a running task and wipes it out. */
1275 Ptrace_return ptrace_out;
1278 printf_unfiltered ("Killing pid %s.\n", local_hex_string((unsigned long) inferior_pid));
1280 memset ((char *)&ptrace_in, '\0', sizeof (ptrace_in));
1281 memset ((char *)&ptrace_out, '\0', sizeof (ptrace_out));
1282 ptrace_in.pid = inferior_pid;
1284 status = net_ptrace_clnt_call (PTRACE_KILL, &ptrace_in, &ptrace_out);
1287 else if (ptrace_out.status == -1)
1289 errno = ptrace_out.errno;
1290 perror_with_name ("Killing VxWorks process");
1293 /* If it gives good status, the process is *gone*, no events remain.
1294 If the kill failed, assume the process is gone anyhow. */
1296 pop_target (); /* go back to non-executing VxWorks connection */
1299 /* Clean up from the VxWorks process target as it goes away. */
1302 vx_proc_close (quitting)
1305 inferior_pid = 0; /* No longer have a process. */
1311 /* Make an RPC call to the VxWorks target.
1312 Returns RPC status. */
1314 static enum clnt_stat
1315 net_clnt_call (procNum, inProc, in, outProc, out)
1316 enum ptracereq procNum;
1322 enum clnt_stat status;
1324 status = clnt_call (pClient, procNum, inProc, in, outProc, out, rpcTimeout);
1326 if (status != RPC_SUCCESS)
1327 clnt_perrno (status);
1332 /* Clean up before losing control. */
1339 clnt_destroy (pClient); /* The net connection */
1343 free (vx_host); /* The hostname */
1347 /* A vxprocess target should be started via "run" not "target". */
1350 vx_proc_open (name, from_tty)
1354 error ("Use the \"run\" command to start a VxWorks process.");
1357 /* Target ops structure for accessing memory and such over the net */
1359 struct target_ops vx_ops = {
1360 "vxworks", "VxWorks target memory via RPC over TCP/IP",
1361 "Use VxWorks target memory. \n\
1362 Specify the name of the machine to connect to.",
1363 vx_open, vx_close, vx_attach, 0, /* vx_detach, */
1364 0, 0, /* resume, wait */
1365 0, 0, /* read_reg, write_reg */
1366 0, /* prep_to_store, */
1367 vx_xfer_memory, vx_files_info,
1368 0, 0, /* insert_breakpoint, remove_breakpoint */
1369 0, 0, 0, 0, 0, /* terminal stuff */
1373 vx_create_inferior, 0, /* mourn_inferior */
1375 0, /* notice_signals */
1376 core_stratum, 0, /* next */
1377 1, 1, 0, 0, 0, /* all mem, mem, stack, regs, exec */
1378 0, 0, /* Section pointers */
1379 OPS_MAGIC, /* Always the last thing */
1382 /* Target ops structure for accessing VxWorks child processes over the net */
1384 struct target_ops vx_run_ops = {
1385 "vxprocess", "VxWorks process",
1386 "VxWorks process, started by the \"run\" command.",
1387 vx_proc_open, vx_proc_close, 0, vx_detach, /* vx_attach */
1389 vx_read_register, vx_write_register,
1390 vx_prepare_to_store,
1391 vx_xfer_memory, vx_run_files_info,
1392 vx_insert_breakpoint, vx_remove_breakpoint,
1393 0, 0, 0, 0, 0, /* terminal stuff */
1397 0, vx_mourn_inferior,
1399 0, /* notice_signals */
1400 process_stratum, 0, /* next */
1401 0, /* all_mem--off to avoid spurious msg in "i files" */
1402 1, 1, 1, 1, /* mem, stack, regs, exec */
1403 0, 0, /* Section pointers */
1404 OPS_MAGIC, /* Always the last thing */
1406 /* ==> Remember when reading at end of file, there are two "ops" structs here. */
1412 (add_set_cmd ("vxworks-timeout", class_support, var_uinteger,
1413 (char *) &rpcTimeout.tv_sec,
1414 "Set seconds to wait for rpc calls to return.\n\
1415 Set the number of seconds to wait for rpc calls to return.", &setlist),
1418 add_target (&vx_ops);
1419 add_target (&vx_run_ops);