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 /* It might be nice to suppress the breakpoint_re_set which happens here
673 because we are going to do one again after the objfile_relocate. */
674 objfile
= symbol_file_add (name
, from_tty
, 0, 0, 0, 0);
676 /* This is a (slightly cheesy) way of superceding the old symbols. A less
677 cheesy way would be to find the objfile with the same name and
679 objfile_to_front (objfile
);
681 offs
= (struct section_offsets
*)
682 alloca (sizeof (struct section_offsets
)
683 + objfile
->num_sections
* sizeof (offs
->offsets
));
684 memcpy (offs
, objfile
->section_offsets
,
685 sizeof (struct section_offsets
)
686 + objfile
->num_sections
* sizeof (offs
->offsets
));
691 bfd_map_over_sections (objfile
->obfd
, find_sect
, &ss
);
693 /* Both COFF and b.out frontends use these SECT_OFF_* values. */
694 ANOFFSET (offs
, SECT_OFF_TEXT
) = text_addr
- ss
.text_start
;
695 ANOFFSET (offs
, SECT_OFF_DATA
) = data_addr
- ss
.data_start
;
696 ANOFFSET (offs
, SECT_OFF_BSS
) = bss_addr
- ss
.bss_start
;
697 objfile_relocate (objfile
, offs
);
699 /* Need to do this *after* things are relocated. */
700 breakpoint_re_set ();
703 /* This function allows the addition of incrementally linked object files. */
706 vx_load_command (arg_string
, from_tty
)
715 error ("The load command takes a file name");
717 arg_string
= tilde_expand (arg_string
);
718 make_cleanup (free
, arg_string
);
724 if (net_load (arg_string
, &text_addr
, &data_addr
, &bss_addr
) == -1)
725 error ("Load failed on target machine");
728 vx_add_symbols (arg_string
, from_tty
, text_addr
, data_addr
, bss_addr
);
730 /* Getting new symbols may change our opinion about what is
732 reinit_frame_cache ();
735 #ifdef FIXME /* Not ready for prime time */
736 /* Single step the target program at the source or machine level.
737 Takes an error exit if rpc fails.
738 Returns -1 if remote single-step operation fails, else 0. */
743 enum clnt_stat status
;
745 SOURCE_STEP source_step
;
747 source_step
.taskId
= inferior_pid
;
751 source_step
.startAddr
= step_range_start
;
752 source_step
.endAddr
= step_range_end
;
756 source_step
.startAddr
= 0;
757 source_step
.endAddr
= 0;
760 status
= net_clnt_call (VX_SOURCE_STEP
, xdr_SOURCE_STEP
, &source_step
,
761 xdr_int
, &step_status
);
763 if (status
== RPC_SUCCESS
)
770 /* Emulate ptrace using RPC calls to the VxWorks target system.
771 Returns nonzero (-1) if RPC status to VxWorks is bad, 0 otherwise. */
774 net_ptrace_clnt_call (request
, pPtraceIn
, pPtraceOut
)
775 enum ptracereq request
;
777 Ptrace_return
*pPtraceOut
;
779 enum clnt_stat status
;
781 status
= net_clnt_call (request
, xdr_rptrace
, pPtraceIn
, xdr_ptrace_return
,
784 if (status
!= RPC_SUCCESS
)
790 /* Query the target for the name of the file from which VxWorks was
791 booted. pBootFile is the address of a pointer to the buffer to
792 receive the file name; if the pointer pointed to by pBootFile is
793 NULL, memory for the buffer will be allocated by XDR.
794 Returns -1 if rpc failed, 0 otherwise. */
797 net_get_boot_file (pBootFile
)
800 enum clnt_stat status
;
802 status
= net_clnt_call (VX_BOOT_FILE_INQ
, xdr_void
, (char *) 0,
803 xdr_wrapstring
, pBootFile
);
804 return (status
== RPC_SUCCESS
) ? 0 : -1;
807 /* Fetch a list of loaded object modules from the VxWorks target.
808 Returns -1 if rpc failed, 0 otherwise
809 There's no way to check if the returned loadTable is correct.
810 VxWorks doesn't check it. */
813 net_get_symbols (pLoadTable
)
814 ldtabl
*pLoadTable
; /* return pointer to ldtabl here */
816 enum clnt_stat status
;
818 memset ((char *) pLoadTable
, '\0', sizeof (struct ldtabl
));
820 status
= net_clnt_call (VX_STATE_INQ
, xdr_void
, 0, xdr_ldtabl
, pLoadTable
);
821 return (status
== RPC_SUCCESS
) ? 0 : -1;
824 /* Look up a symbol in the VxWorks target's symbol table.
825 Returns status of symbol read on target side (0=success, -1=fail)
826 Returns -1 and complain()s if rpc fails. */
828 struct complaint cant_contact_target
=
829 {"Lost contact with VxWorks target", 0, 0};
832 vx_lookup_symbol (name
, pAddr
)
833 char *name
; /* symbol name */
836 enum clnt_stat status
;
837 SYMBOL_ADDR symbolAddr
;
840 memset ((char *) &symbolAddr
, '\0', sizeof (symbolAddr
));
842 status
= net_clnt_call (VX_SYMBOL_INQ
, xdr_wrapstring
, &name
,
843 xdr_SYMBOL_ADDR
, &symbolAddr
);
844 if (status
!= RPC_SUCCESS
)
846 complain (&cant_contact_target
);
850 *pAddr
= symbolAddr
.addr
;
851 return symbolAddr
.status
;
854 /* Check to see if the VxWorks target has a floating point coprocessor.
855 Returns 1 if target has floating point processor, 0 otherwise.
856 Calls error() if rpc fails. */
861 enum clnt_stat status
;
862 bool_t fp
= 0; /* true if fp processor is present on target board */
864 status
= net_clnt_call (VX_FP_INQUIRE
, xdr_void
, 0, xdr_bool
, &fp
);
865 if (status
!= RPC_SUCCESS
)
871 /* Establish an RPC connection with the VxWorks target system.
872 Calls error () if unable to establish connection. */
878 struct sockaddr_in destAddr
;
879 struct hostent
*destHost
;
882 /* Get the internet address for the given host. Allow a numeric
883 IP address or a hostname. */
885 addr
= inet_addr (host
);
888 destHost
= (struct hostent
*) gethostbyname (host
);
889 if (destHost
== NULL
)
890 /* FIXME: Probably should include hostname here in quotes.
891 For example if the user types "target vxworks vx960 " it should
892 say "Invalid host `vx960 '." not just "Invalid hostname". */
893 error ("Invalid hostname. Couldn't find remote host address.");
894 addr
= * (unsigned long *) destHost
->h_addr
;
897 memset (&destAddr
, '\0', sizeof (destAddr
));
899 destAddr
.sin_addr
.s_addr
= addr
;
900 destAddr
.sin_family
= AF_INET
;
901 destAddr
.sin_port
= 0; /* set to actual port that remote
902 ptrace is listening on. */
904 /* Create a tcp client transport on which to issue
905 calls to the remote ptrace server. */
907 ptraceSock
= RPC_ANYSOCK
;
908 pClient
= clnttcp_create (&destAddr
, RDBPROG
, RDBVERS
, &ptraceSock
, 0, 0);
909 /* FIXME, here is where we deal with different version numbers of the
914 clnt_pcreateerror ("\tnet_connect");
915 error ("Couldn't connect to remote target.");
919 /* Sleep for the specified number of milliseconds
920 * (assumed to be less than 1000).
921 * If select () is interrupted, returns immediately;
922 * takes an error exit if select () fails for some other reason.
929 struct timeval select_timeout
;
932 select_timeout
.tv_sec
= 0;
933 select_timeout
.tv_usec
= ms
* 1000;
935 status
= select (0, (fd_set
*) 0, (fd_set
*) 0, (fd_set
*) 0,
938 if (status
< 0 && errno
!= EINTR
)
939 perror_with_name ("select");
943 vx_wait (pid_to_wait_for
, status
)
945 struct target_waitstatus
*status
;
953 /* If CTRL-C is hit during this loop,
954 suspend the inferior process. */
959 quit_failed
= (net_quit () == -1);
963 /* If a net_quit () or net_wait () call has failed,
964 allow the user to break the connection with the target.
965 We can't simply error () out of this loop, since the
966 data structures representing the state of the inferior
967 are in an inconsistent state. */
969 if (quit_failed
|| net_wait (&rdbEvent
) == -1)
972 if (query ("Can't %s. Disconnect from target system? ",
973 (quit_failed
) ? "suspend remote task"
974 : "get status of remote task"))
976 target_mourn_inferior();
977 error ("Use the \"target\" command to reconnect.");
981 terminal_inferior ();
986 pid
= rdbEvent
.taskId
;
989 sleep_ms (200); /* FIXME Don't kill the network too badly */
991 else if (pid
!= inferior_pid
)
992 fatal ("Bad pid for debugged task: %s\n",
993 local_hex_string((unsigned long) pid
));
996 /* The mostly likely kind. */
997 status
->kind
= TARGET_WAITKIND_STOPPED
;
999 switch (rdbEvent
.eventType
)
1002 status
->kind
= TARGET_WAITKIND_EXITED
;
1003 /* FIXME is it possible to distinguish between a
1004 normal vs abnormal exit in VxWorks? */
1005 status
->value
.integer
= 0;
1009 /* Task was just started. */
1010 status
->value
.sig
= TARGET_SIGNAL_TRAP
;
1014 status
->value
.sig
= TARGET_SIGNAL_TRAP
;
1015 /* XXX was it stopped by a signal? act accordingly */
1018 case EVENT_BREAK
: /* Breakpoint was hit. */
1019 status
->value
.sig
= TARGET_SIGNAL_TRAP
;
1022 case EVENT_SUSPEND
: /* Task was suspended, probably by ^C. */
1023 status
->value
.sig
= TARGET_SIGNAL_INT
;
1026 case EVENT_BUS_ERR
: /* Task made evil nasty reference. */
1027 status
->value
.sig
= TARGET_SIGNAL_BUS
;
1030 case EVENT_ZERO_DIV
: /* Division by zero */
1031 status
->value
.sig
= TARGET_SIGNAL_FPE
;
1036 status
->value
.sig
= i960_fault_to_signal (rdbEvent
.sigType
);
1038 /* Back in the old days, before enum target_signal, this code used
1039 to add NSIG to the signal number and claim that PRINT_RANDOM_SIGNAL
1040 would take care of it. But PRINT_RANDOM_SIGNAL has never been
1041 defined except on the i960, so I don't really know what we are
1042 supposed to do on other architectures. */
1043 status
->value
.sig
= TARGET_SIGNAL_UNKNOWN
;
1054 symbol_file_command (arg
, 0);
1059 add_symbol_stub (arg
)
1062 struct ldfile
*pLoadFile
= (struct ldfile
*)arg
;
1064 printf_unfiltered("\t%s: ", pLoadFile
->name
);
1065 vx_add_symbols (pLoadFile
->name
, 0, pLoadFile
->txt_addr
,
1066 pLoadFile
->data_addr
, pLoadFile
->bss_addr
);
1067 printf_unfiltered ("ok\n");
1070 /* Target command for VxWorks target systems.
1072 Used in vxgdb. Takes the name of a remote target machine
1073 running vxWorks and connects to it to initialize remote network
1077 vx_open (args
, from_tty
)
1081 extern int close ();
1083 extern char *source_path
;
1084 struct ldtabl loadTable
;
1085 struct ldfile
*pLoadFile
;
1087 extern CLIENT
*pClient
;
1088 int symbols_added
= 0;
1091 error_no_arg ("target machine name");
1093 target_preopen (from_tty
);
1095 unpush_target (&vx_ops
);
1096 printf_unfiltered ("Attaching remote machine across net...\n");
1097 gdb_flush (gdb_stdout
);
1099 /* Allow the user to kill the connect attempt by typing ^C.
1100 Wait until the call to target_has_fp () completes before
1101 disallowing an immediate quit, since even if net_connect ()
1102 is successful, the remote debug server might be hung. */
1107 target_has_fp
= net_check_for_fp ();
1108 printf_filtered ("Connected to %s.\n", args
);
1112 push_target (&vx_ops
);
1114 /* Save a copy of the target host's name. */
1115 vx_host
= savestring (args
, strlen (args
));
1117 /* Find out the name of the file from which the target was booted
1118 and load its symbol table. */
1120 printf_filtered ("Looking in Unix path for all loaded modules:\n");
1122 if (!net_get_boot_file (&bootFile
))
1126 printf_filtered ("\t%s: ", bootFile
);
1127 /* This assumes that the kernel is never relocated. Hope that is an
1128 accurate assumption. */
1132 "Error while reading symbols from boot file:\n",
1134 puts_filtered ("ok\n");
1137 printf_unfiltered ("VxWorks kernel symbols not loaded.\n");
1140 error ("Can't retrieve boot file name from target machine.");
1142 clnt_freeres (pClient
, xdr_wrapstring
, &bootFile
);
1144 if (net_get_symbols (&loadTable
) != 0)
1145 error ("Can't read loaded modules from target machine");
1148 while (++i
< loadTable
.tbl_size
)
1150 QUIT
; /* FIXME, avoids clnt_freeres below: mem leak */
1151 pLoadFile
= &loadTable
.tbl_ent
[i
];
1155 struct cleanup
*old_chain
;
1156 char *fullname
= NULL
;
1158 desc
= openp (source_path
, 0, pLoadFile
->name
, O_RDONLY
, 0, &fullname
);
1160 perror_with_name (pLoadFile
->name
);
1161 old_chain
= make_cleanup (close
, desc
);
1162 add_file_at_addr (fullname
, desc
, pLoadFile
->txt_addr
, pLoadFile
->data_addr
,
1163 pLoadFile
->bss_addr
);
1164 do_cleanups (old_chain
);
1167 /* FIXME: Is there something better to search than the PATH? (probably
1168 not the source path, since source might be in different directories
1171 if (catch_errors (add_symbol_stub
, (char *)pLoadFile
, (char *)0,
1176 printf_filtered ("Done.\n");
1178 clnt_freeres (pClient
, xdr_ldtabl
, &loadTable
);
1180 /* Getting new symbols may change our opinion about what is
1183 reinit_frame_cache ();
1186 /* Takes a task started up outside of gdb and ``attaches'' to it.
1187 This stops it cold in its tracks and allows us to start tracing it. */
1190 vx_attach (args
, from_tty
)
1197 Ptrace_return ptrace_out
;
1201 error_no_arg ("process-id to attach");
1203 pid
= strtoul (args
, &cptr
, 0);
1204 if ((cptr
== args
) || (*cptr
!= '\0'))
1205 error ("Invalid process-id -- give a single number in decimal or 0xhex");
1208 printf_unfiltered ("Attaching pid %s.\n",
1209 local_hex_string((unsigned long) pid
));
1211 memset ((char *)&ptrace_in
, '\0', sizeof (ptrace_in
));
1212 memset ((char *)&ptrace_out
, '\0', sizeof (ptrace_out
));
1213 ptrace_in
.pid
= pid
;
1215 status
= net_ptrace_clnt_call (PTRACE_ATTACH
, &ptrace_in
, &ptrace_out
);
1218 if (ptrace_out
.status
== -1)
1220 errno
= ptrace_out
.errno
;
1221 perror_with_name ("Attaching remote process");
1225 push_target (&vx_run_ops
);
1226 /* The unsigned long pid will get turned into a signed int here,
1227 but it doesn't seem to matter. inferior_pid must be signed
1228 in order for other parts of GDB to work correctly. */
1234 /* detach_command --
1235 takes a program previously attached to and detaches it.
1236 The program resumes execution and will no longer stop
1237 on signals, etc. We better not have left any breakpoints
1238 in the program or it'll die when it hits one. For this
1239 to work, it may be necessary for the process to have been
1240 previously attached. It *might* work if the program was
1241 started via the normal ptrace (PTRACE_TRACEME). */
1244 vx_detach (args
, from_tty
)
1249 Ptrace_return ptrace_out
;
1254 error ("Argument given to VxWorks \"detach\".");
1257 printf_unfiltered ("Detaching pid %s.\n",
1258 local_hex_string((unsigned long) inferior_pid
));
1260 if (args
) /* FIXME, should be possible to leave suspended */
1261 signal
= atoi (args
);
1263 memset ((char *)&ptrace_in
, '\0', sizeof (ptrace_in
));
1264 memset ((char *)&ptrace_out
, '\0', sizeof (ptrace_out
));
1265 ptrace_in
.pid
= inferior_pid
;
1267 status
= net_ptrace_clnt_call (PTRACE_DETACH
, &ptrace_in
, &ptrace_out
);
1270 if (ptrace_out
.status
== -1)
1272 errno
= ptrace_out
.errno
;
1273 perror_with_name ("Detaching VxWorks process");
1277 pop_target (); /* go back to non-executing VxWorks connection */
1280 /* vx_kill -- takes a running task and wipes it out. */
1286 Ptrace_return ptrace_out
;
1289 printf_unfiltered ("Killing pid %s.\n", local_hex_string((unsigned long) inferior_pid
));
1291 memset ((char *)&ptrace_in
, '\0', sizeof (ptrace_in
));
1292 memset ((char *)&ptrace_out
, '\0', sizeof (ptrace_out
));
1293 ptrace_in
.pid
= inferior_pid
;
1295 status
= net_ptrace_clnt_call (PTRACE_KILL
, &ptrace_in
, &ptrace_out
);
1298 else if (ptrace_out
.status
== -1)
1300 errno
= ptrace_out
.errno
;
1301 perror_with_name ("Killing VxWorks process");
1304 /* If it gives good status, the process is *gone*, no events remain.
1305 If the kill failed, assume the process is gone anyhow. */
1307 pop_target (); /* go back to non-executing VxWorks connection */
1310 /* Clean up from the VxWorks process target as it goes away. */
1313 vx_proc_close (quitting
)
1316 inferior_pid
= 0; /* No longer have a process. */
1322 /* Make an RPC call to the VxWorks target.
1323 Returns RPC status. */
1325 static enum clnt_stat
1326 net_clnt_call (procNum
, inProc
, in
, outProc
, out
)
1327 enum ptracereq procNum
;
1333 enum clnt_stat status
;
1335 status
= clnt_call (pClient
, procNum
, inProc
, in
, outProc
, out
, rpcTimeout
);
1337 if (status
!= RPC_SUCCESS
)
1338 clnt_perrno (status
);
1343 /* Clean up before losing control. */
1350 clnt_destroy (pClient
); /* The net connection */
1354 free (vx_host
); /* The hostname */
1358 /* A vxprocess target should be started via "run" not "target". */
1361 vx_proc_open (name
, from_tty
)
1365 error ("Use the \"run\" command to start a VxWorks process.");
1368 /* Target ops structure for accessing memory and such over the net */
1370 struct target_ops vx_ops
= {
1371 "vxworks", "VxWorks target memory via RPC over TCP/IP",
1372 "Use VxWorks target memory. \n\
1373 Specify the name of the machine to connect to.",
1374 vx_open
, vx_close
, vx_attach
, 0, /* vx_detach, */
1375 0, 0, /* resume, wait */
1376 0, 0, /* read_reg, write_reg */
1377 0, /* prep_to_store, */
1378 vx_xfer_memory
, vx_files_info
,
1379 0, 0, /* insert_breakpoint, remove_breakpoint */
1380 0, 0, 0, 0, 0, /* terminal stuff */
1384 vx_create_inferior
, 0, /* mourn_inferior */
1386 0, /* notice_signals */
1388 core_stratum
, 0, /* next */
1389 1, 1, 0, 0, 0, /* all mem, mem, stack, regs, exec */
1390 0, 0, /* Section pointers */
1391 OPS_MAGIC
, /* Always the last thing */
1394 /* Target ops structure for accessing VxWorks child processes over the net */
1396 struct target_ops vx_run_ops
= {
1397 "vxprocess", "VxWorks process",
1398 "VxWorks process, started by the \"run\" command.",
1399 vx_proc_open
, vx_proc_close
, 0, vx_detach
, /* vx_attach */
1401 vx_read_register
, vx_write_register
,
1402 vx_prepare_to_store
,
1403 vx_xfer_memory
, vx_run_files_info
,
1404 vx_insert_breakpoint
, vx_remove_breakpoint
,
1405 0, 0, 0, 0, 0, /* terminal stuff */
1409 0, vx_mourn_inferior
,
1411 0, /* notice_signals */
1413 process_stratum
, 0, /* next */
1414 0, /* all_mem--off to avoid spurious msg in "i files" */
1415 1, 1, 1, 1, /* mem, stack, regs, exec */
1416 0, 0, /* Section pointers */
1417 OPS_MAGIC
, /* Always the last thing */
1419 /* ==> Remember when reading at end of file, there are two "ops" structs here. */
1425 (add_set_cmd ("vxworks-timeout", class_support
, var_uinteger
,
1426 (char *) &rpcTimeout
.tv_sec
,
1427 "Set seconds to wait for rpc calls to return.\n\
1428 Set the number of seconds to wait for rpc calls to return.", &setlist
),
1431 add_target (&vx_ops
);
1432 add_target (&vx_run_ops
);