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., 59 Temple Place - Suite 330, Boston, MA 02111-1307, 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"
36 #include "gdb_string.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 /* Maximum number of bytes to transfer in a single
60 PTRACE_{READ,WRITE}DATA request. */
61 #define VX_MEMXFER_MAX 4096
63 extern void vx_read_register ();
64 extern void vx_write_register ();
65 extern void symbol_file_command ();
66 extern int stop_soon_quietly
; /* for wait_for_inferior */
68 static int net_step ();
69 static int net_ptrace_clnt_call (); /* Forward decl */
70 static enum clnt_stat
net_clnt_call (); /* Forward decl */
71 extern struct target_ops vx_ops
, vx_run_ops
; /* Forward declaration */
73 /* Saved name of target host and called function for "info files".
77 static char *vx_running
; /* Called function */
79 /* Nonzero means target that is being debugged remotely has a floating
84 /* Default error message when the network is forking up. */
86 static const char rpcerr
[] = "network target debugging: rpc error";
88 CLIENT
*pClient
; /* client used in net debugging */
89 static int ptraceSock
= RPC_ANYSOCK
;
91 enum clnt_stat
net_clnt_call();
92 static void parse_args ();
94 static struct timeval rpcTimeout
= { 10, 0 };
96 static char *skip_white_space ();
97 static char *find_white_space ();
99 /* Tell the VxWorks target system to download a file.
100 The load addresses of the text, data, and bss segments are
101 stored in *pTextAddr, *pDataAddr, and *pBssAddr (respectively).
102 Returns 0 for success, -1 for failure. */
105 net_load (filename
, pTextAddr
, pDataAddr
, pBssAddr
)
107 CORE_ADDR
*pTextAddr
;
108 CORE_ADDR
*pDataAddr
;
111 enum clnt_stat status
;
112 struct ldfile ldstruct
;
113 struct timeval load_timeout
;
115 memset ((char *) &ldstruct
, '\0', sizeof (ldstruct
));
117 /* We invoke clnt_call () here directly, instead of through
118 net_clnt_call (), because we need to set a large timeout value.
119 The load on the target side can take quite a while, easily
120 more than 10 seconds. The user can kill this call by typing
121 CTRL-C if there really is a problem with the load.
123 Do not change the tv_sec value without checking -- select() imposes
124 a limit of 10**8 on it for no good reason that I can see... */
126 load_timeout
.tv_sec
= 99999999; /* A large number, effectively inf. */
127 load_timeout
.tv_usec
= 0;
129 status
= clnt_call (pClient
, VX_LOAD
, xdr_wrapstring
, &filename
, xdr_ldfile
,
130 &ldstruct
, load_timeout
);
132 if (status
== RPC_SUCCESS
)
134 if (*ldstruct
.name
== 0) /* load failed on VxWorks side */
136 *pTextAddr
= ldstruct
.txt_addr
;
137 *pDataAddr
= ldstruct
.data_addr
;
138 *pBssAddr
= ldstruct
.bss_addr
;
145 /* returns 0 if successful, errno if RPC failed or VxWorks complains. */
148 net_break (addr
, procnum
)
152 enum clnt_stat status
;
154 Rptrace ptrace_in
; /* XXX This is stupid. It doesn't need to be a ptrace
155 structure. How about something smaller? */
157 memset ((char *) &ptrace_in
, '\0', sizeof (ptrace_in
));
160 ptrace_in
.addr
= addr
;
161 ptrace_in
.pid
= inferior_pid
;
163 status
= net_clnt_call (procnum
, xdr_rptrace
, &ptrace_in
, xdr_int
,
166 if (status
!= RPC_SUCCESS
)
169 if (break_status
== -1)
171 return break_status
; /* probably (FIXME) zero */
174 /* returns 0 if successful, errno otherwise */
177 vx_insert_breakpoint (addr
)
180 return net_break (addr
, VX_BREAK_ADD
);
183 /* returns 0 if successful, errno otherwise */
186 vx_remove_breakpoint (addr
)
189 return net_break (addr
, VX_BREAK_DELETE
);
192 /* Start an inferior process and sets inferior_pid to its pid.
193 EXEC_FILE is the file to run.
194 ALLARGS is a string containing the arguments to the program.
195 ENV is the environment vector to pass.
196 Returns process id. Errors reported with error().
197 On VxWorks, we ignore exec_file. */
200 vx_create_inferior (exec_file
, args
, env
)
205 enum clnt_stat status
;
207 TASK_START taskStart
;
209 memset ((char *) &passArgs
, '\0', sizeof (passArgs
));
210 memset ((char *) &taskStart
, '\0', sizeof (taskStart
));
212 /* parse arguments, put them in passArgs */
214 parse_args (args
, &passArgs
);
216 if (passArgs
.arg_array_len
== 0)
217 error ("You must specify a function name to run, and arguments if any");
219 status
= net_clnt_call (PROCESS_START
, xdr_arg_array
, &passArgs
,
220 xdr_TASK_START
, &taskStart
);
222 if ((status
!= RPC_SUCCESS
) || (taskStart
.status
== -1))
223 error ("Can't create process on remote target machine");
225 /* Save the name of the running function */
226 vx_running
= savestring (passArgs
.arg_array_val
[0],
227 strlen (passArgs
.arg_array_val
[0]));
229 push_target (&vx_run_ops
);
230 inferior_pid
= taskStart
.pid
;
232 /* We will get a trace trap after one instruction.
233 Insert breakpoints and continue. */
235 init_wait_for_inferior ();
237 /* Set up the "saved terminal modes" of the inferior
238 based on what modes we are starting it with. */
239 target_terminal_init ();
241 /* Install inferior's terminal modes. */
242 target_terminal_inferior ();
244 stop_soon_quietly
= 1;
245 wait_for_inferior (); /* Get the task spawn event */
246 stop_soon_quietly
= 0;
248 /* insert_step_breakpoint (); FIXME, do we need this? */
249 proceed (-1, TARGET_SIGNAL_DEFAULT
, 0);
252 /* Fill ARGSTRUCT in argc/argv form with the arguments from the
253 argument string ARGSTRING. */
256 parse_args (arg_string
, arg_struct
)
257 register char *arg_string
;
258 arg_array
*arg_struct
;
260 register int arg_count
= 0; /* number of arguments */
261 register int arg_index
= 0;
264 memset ((char *) arg_struct
, '\0', sizeof (arg_array
));
266 /* first count how many arguments there are */
271 if (*(p0
= skip_white_space (p0
)) == '\0')
273 p0
= find_white_space (p0
);
277 arg_struct
->arg_array_len
= arg_count
;
278 arg_struct
->arg_array_val
= (char **) xmalloc ((arg_count
+ 1)
281 /* now copy argument strings into arg_struct. */
283 while (*(arg_string
= skip_white_space (arg_string
)))
285 p0
= find_white_space (arg_string
);
286 arg_struct
->arg_array_val
[arg_index
++] = savestring (arg_string
,
291 arg_struct
->arg_array_val
[arg_count
] = NULL
;
294 /* Advance a string pointer across whitespace and return a pointer
295 to the first non-white character. */
301 while (*p
== ' ' || *p
== '\t')
306 /* Search for the first unquoted whitespace character in a string.
307 Returns a pointer to the character, or to the null terminator
308 if no whitespace is found. */
316 while ((c
= *p
) != ' ' && c
!= '\t' && c
)
318 if (c
== '\'' || c
== '"')
320 while (*++p
!= c
&& *p
)
333 /* Poll the VxWorks target system for an event related
334 to the debugged task.
335 Returns -1 if remote wait failed, task status otherwise. */
342 enum clnt_stat status
;
344 memset ((char *) pEvent
, '\0', sizeof (RDB_EVENT
));
347 status
= net_clnt_call (PROCESS_WAIT
, xdr_int
, &pid
, xdr_RDB_EVENT
,
350 /* return (status == RPC_SUCCESS)? pEvent->status: -1; */
351 if (status
== RPC_SUCCESS
)
352 return ((pEvent
->status
) ? 1 : 0);
353 else if (status
== RPC_TIMEDOUT
)
359 /* Suspend the remote task.
360 Returns -1 if suspend fails on target system, 0 otherwise. */
367 enum clnt_stat status
;
371 /* don't let rdbTask suspend itself by passing a pid of 0 */
373 if ((pid
= inferior_pid
) == 0)
376 status
= net_clnt_call (VX_TASK_SUSPEND
, xdr_int
, &pid
, xdr_int
,
379 return (status
== RPC_SUCCESS
)? quit_status
: -1;
382 /* Read a register or registers from the remote system. */
385 net_read_registers (reg_buf
, len
, procnum
)
392 Ptrace_return ptrace_out
;
396 memset ((char *) &ptrace_in
, '\0', sizeof (ptrace_in
));
397 memset ((char *) &ptrace_out
, '\0', sizeof (ptrace_out
));
399 /* Initialize RPC input argument structure. */
401 ptrace_in
.pid
= inferior_pid
;
402 ptrace_in
.info
.ttype
= NOINFO
;
404 /* Initialize RPC return value structure. */
406 out_data
.bytes
= reg_buf
;
408 ptrace_out
.info
.more_data
= (caddr_t
) &out_data
;
410 /* Call RPC; take an error exit if appropriate. */
412 status
= net_ptrace_clnt_call (procnum
, &ptrace_in
, &ptrace_out
);
415 if (ptrace_out
.status
== -1)
417 errno
= ptrace_out
.errno
;
418 sprintf (message
, "reading %s registers", (procnum
== PTRACE_GETREGS
)
421 perror_with_name (message
);
425 /* Write register values to a VxWorks target. REG_BUF points to a buffer
426 containing the raw register values, LEN is the length of REG_BUF in
427 bytes, and PROCNUM is the RPC procedure number (PTRACE_SETREGS or
428 PTRACE_SETFPREGS). An error exit is taken if the RPC call fails or
429 if an error status is returned by the remote debug server. This is
430 a utility routine used by vx_write_register (). */
433 net_write_registers (reg_buf
, len
, procnum
)
440 Ptrace_return ptrace_out
;
444 memset ((char *) &ptrace_in
, '\0', sizeof (ptrace_in
));
445 memset ((char *) &ptrace_out
, '\0', sizeof (ptrace_out
));
447 /* Initialize RPC input argument structure. */
449 in_data
.bytes
= reg_buf
;
452 ptrace_in
.pid
= inferior_pid
;
453 ptrace_in
.info
.ttype
= DATA
;
454 ptrace_in
.info
.more_data
= (caddr_t
) &in_data
;
456 /* Call RPC; take an error exit if appropriate. */
458 status
= net_ptrace_clnt_call (procnum
, &ptrace_in
, &ptrace_out
);
461 if (ptrace_out
.status
== -1)
463 errno
= ptrace_out
.errno
;
464 sprintf (message
, "writing %s registers", (procnum
== PTRACE_SETREGS
)
467 perror_with_name (message
);
471 /* Prepare to store registers. Since we will store all of them,
472 read out their current values now. */
475 vx_prepare_to_store ()
477 /* Fetch all registers, if any of them are not yet fetched. */
478 read_register_bytes (0, NULL
, REGISTER_BYTES
);
481 /* Copy LEN bytes to or from remote inferior's memory starting at MEMADDR
482 to debugger memory starting at MYADDR. WRITE is true if writing to the
484 Result is the number of bytes written or read (zero if error). The
485 protocol allows us to return a negative count, indicating that we can't
486 handle the current address but can handle one N bytes further, but
487 vxworks doesn't give us that information. */
490 vx_xfer_memory (memaddr
, myaddr
, len
, write
, target
)
495 struct target_ops
*target
; /* ignored */
499 Ptrace_return ptrace_out
;
501 enum ptracereq request
;
504 memset ((char *) &ptrace_in
, '\0', sizeof (ptrace_in
));
505 memset ((char *) &ptrace_out
, '\0', sizeof (ptrace_out
));
507 ptrace_in
.pid
= inferior_pid
; /* XXX pid unnecessary for READDATA */
508 ptrace_in
.addr
= (int) memaddr
; /* Where from */
509 ptrace_in
.data
= len
; /* How many bytes */
513 ptrace_in
.info
.ttype
= DATA
;
514 ptrace_in
.info
.more_data
= (caddr_t
) &data
;
516 data
.bytes
= (caddr_t
) myaddr
; /* Where from */
517 data
.len
= len
; /* How many bytes (again, for XDR) */
518 request
= PTRACE_WRITEDATA
;
522 ptrace_out
.info
.more_data
= (caddr_t
) &data
;
523 request
= PTRACE_READDATA
;
525 /* Loop until the entire request has been satisfied, transferring
526 at most VX_MEMXFER_MAX bytes per iteration. Break from the loop
527 if an error status is returned by the remote debug server. */
532 while (nleft
> 0 && status
== 0)
534 nxfer
= min (nleft
, VX_MEMXFER_MAX
);
536 ptrace_in
.addr
= (int) memaddr
;
537 ptrace_in
.data
= nxfer
;
538 data
.bytes
= (caddr_t
) myaddr
;
541 /* Request a block from the remote debug server; if RPC fails,
542 report an error and return to debugger command level. */
544 if (net_ptrace_clnt_call (request
, &ptrace_in
, &ptrace_out
))
547 status
= ptrace_out
.status
;
556 /* A target-side error has ocurred. Set errno to the error
557 code chosen by the target so that a later perror () will
558 say something meaningful. */
560 errno
= ptrace_out
.errno
;
564 /* Return the number of bytes transferred. */
566 return (len
- nleft
);
572 printf_unfiltered ("\tAttached to host `%s'", vx_host
);
573 printf_unfiltered (", which has %sfloating point", target_has_fp
? "": "no ");
574 printf_unfiltered (".\n");
580 printf_unfiltered ("\tRunning %s VxWorks process %s",
581 vx_running
? "child" : "attached",
582 local_hex_string (inferior_pid
));
584 printf_unfiltered (", function `%s'", vx_running
);
585 printf_unfiltered(".\n");
589 vx_resume (pid
, step
, siggnal
)
592 enum target_signal siggnal
;
596 Ptrace_return ptrace_out
;
602 if (siggnal
!= 0 && siggnal
!= stop_signal
)
603 error ("Cannot send signals to VxWorks processes");
605 /* Set CONT_ADDR to the address at which we are continuing,
606 or to 1 if we are continuing from where the program stopped.
607 This conforms to traditional ptrace () usage, but at the same
608 time has special meaning for the VxWorks remote debug server.
609 If the address is not 1, the server knows that the target
610 program is jumping to a new address, which requires special
611 handling if there is a breakpoint at the new address. */
613 cont_addr
= read_register (PC_REGNUM
);
614 if (cont_addr
== stop_pc
)
617 memset ((char *) &ptrace_in
, '\0', sizeof (ptrace_in
));
618 memset ((char *) &ptrace_out
, '\0', sizeof (ptrace_out
));
621 ptrace_in
.addr
= cont_addr
; /* Target side insists on this, or it panics. */
626 status
= net_ptrace_clnt_call (PTRACE_CONT
, &ptrace_in
, &ptrace_out
);
630 if (ptrace_out
.status
== -1)
632 errno
= ptrace_out
.errno
;
633 perror_with_name ("Resuming remote process");
640 pop_target (); /* Pop back to no-child state */
641 generic_mourn_inferior ();
645 static void vx_add_symbols
PARAMS ((char *, int, CORE_ADDR
, CORE_ADDR
,
648 struct find_sect_args
{
649 CORE_ADDR text_start
;
650 CORE_ADDR data_start
;
654 static void find_sect
PARAMS ((bfd
*, asection
*, void *));
657 find_sect (abfd
, sect
, obj
)
662 struct find_sect_args
*args
= (struct find_sect_args
*)obj
;
664 if (bfd_get_section_flags (abfd
, sect
) & (SEC_CODE
& SEC_READONLY
))
665 args
->text_start
= bfd_get_section_vma (abfd
, sect
);
666 else if (bfd_get_section_flags (abfd
, sect
) & SEC_ALLOC
)
668 if (bfd_get_section_flags (abfd
, sect
) & SEC_LOAD
)
670 /* Exclude .ctor and .dtor sections which have SEC_CODE set but not
672 if (bfd_get_section_flags (abfd
, sect
) & SEC_DATA
)
673 args
->data_start
= bfd_get_section_vma (abfd
, sect
);
676 args
->bss_start
= bfd_get_section_vma (abfd
, sect
);
681 vx_add_symbols (name
, from_tty
, text_addr
, data_addr
, bss_addr
)
688 struct section_offsets
*offs
;
689 struct objfile
*objfile
;
690 struct find_sect_args ss
;
692 /* It might be nice to suppress the breakpoint_re_set which happens here
693 because we are going to do one again after the objfile_relocate. */
694 objfile
= symbol_file_add (name
, from_tty
, 0, 0, 0, 0);
696 /* This is a (slightly cheesy) way of superceding the old symbols. A less
697 cheesy way would be to find the objfile with the same name and
699 objfile_to_front (objfile
);
701 offs
= (struct section_offsets
*)
702 alloca (sizeof (struct section_offsets
)
703 + objfile
->num_sections
* sizeof (offs
->offsets
));
704 memcpy (offs
, objfile
->section_offsets
,
705 sizeof (struct section_offsets
)
706 + objfile
->num_sections
* sizeof (offs
->offsets
));
711 bfd_map_over_sections (objfile
->obfd
, find_sect
, &ss
);
713 /* Both COFF and b.out frontends use these SECT_OFF_* values. */
714 ANOFFSET (offs
, SECT_OFF_TEXT
) = text_addr
- ss
.text_start
;
715 ANOFFSET (offs
, SECT_OFF_DATA
) = data_addr
- ss
.data_start
;
716 ANOFFSET (offs
, SECT_OFF_BSS
) = bss_addr
- ss
.bss_start
;
717 objfile_relocate (objfile
, offs
);
720 /* This function allows the addition of incrementally linked object files. */
723 vx_load_command (arg_string
, from_tty
)
732 error ("The load command takes a file name");
734 arg_string
= tilde_expand (arg_string
);
735 make_cleanup (free
, arg_string
);
739 /* Refuse to load the module if a debugged task is running. Doing so
740 can have a number of unpleasant consequences to the running task. */
742 if (inferior_pid
!= 0 && target_has_execution
)
744 if (query ("You may not load a module while the target task is running.\n\
745 Kill the target task? "))
748 error ("Load cancelled.");
753 if (net_load (arg_string
, &text_addr
, &data_addr
, &bss_addr
) == -1)
754 error ("Load failed on target machine");
757 vx_add_symbols (arg_string
, from_tty
, text_addr
, data_addr
, bss_addr
);
759 /* Getting new symbols may change our opinion about what is
761 reinit_frame_cache ();
764 /* Single step the target program at the source or machine level.
765 Takes an error exit if rpc fails.
766 Returns -1 if remote single-step operation fails, else 0. */
771 enum clnt_stat status
;
773 SOURCE_STEP source_step
;
775 source_step
.taskId
= inferior_pid
;
779 source_step
.startAddr
= step_range_start
;
780 source_step
.endAddr
= step_range_end
;
784 source_step
.startAddr
= 0;
785 source_step
.endAddr
= 0;
788 status
= net_clnt_call (VX_SOURCE_STEP
, xdr_SOURCE_STEP
, &source_step
,
789 xdr_int
, &step_status
);
791 if (status
== RPC_SUCCESS
)
797 /* Emulate ptrace using RPC calls to the VxWorks target system.
798 Returns nonzero (-1) if RPC status to VxWorks is bad, 0 otherwise. */
801 net_ptrace_clnt_call (request
, pPtraceIn
, pPtraceOut
)
802 enum ptracereq request
;
804 Ptrace_return
*pPtraceOut
;
806 enum clnt_stat status
;
808 status
= net_clnt_call (request
, xdr_rptrace
, pPtraceIn
, xdr_ptrace_return
,
811 if (status
!= RPC_SUCCESS
)
817 /* Query the target for the name of the file from which VxWorks was
818 booted. pBootFile is the address of a pointer to the buffer to
819 receive the file name; if the pointer pointed to by pBootFile is
820 NULL, memory for the buffer will be allocated by XDR.
821 Returns -1 if rpc failed, 0 otherwise. */
824 net_get_boot_file (pBootFile
)
827 enum clnt_stat status
;
829 status
= net_clnt_call (VX_BOOT_FILE_INQ
, xdr_void
, (char *) 0,
830 xdr_wrapstring
, pBootFile
);
831 return (status
== RPC_SUCCESS
) ? 0 : -1;
834 /* Fetch a list of loaded object modules from the VxWorks target.
835 Returns -1 if rpc failed, 0 otherwise
836 There's no way to check if the returned loadTable is correct.
837 VxWorks doesn't check it. */
840 net_get_symbols (pLoadTable
)
841 ldtabl
*pLoadTable
; /* return pointer to ldtabl here */
843 enum clnt_stat status
;
845 memset ((char *) pLoadTable
, '\0', sizeof (struct ldtabl
));
847 status
= net_clnt_call (VX_STATE_INQ
, xdr_void
, 0, xdr_ldtabl
, pLoadTable
);
848 return (status
== RPC_SUCCESS
) ? 0 : -1;
851 /* Look up a symbol in the VxWorks target's symbol table.
852 Returns status of symbol read on target side (0=success, -1=fail)
853 Returns -1 and complain()s if rpc fails. */
855 struct complaint cant_contact_target
=
856 {"Lost contact with VxWorks target", 0, 0};
859 vx_lookup_symbol (name
, pAddr
)
860 char *name
; /* symbol name */
863 enum clnt_stat status
;
864 SYMBOL_ADDR symbolAddr
;
867 memset ((char *) &symbolAddr
, '\0', sizeof (symbolAddr
));
869 status
= net_clnt_call (VX_SYMBOL_INQ
, xdr_wrapstring
, &name
,
870 xdr_SYMBOL_ADDR
, &symbolAddr
);
871 if (status
!= RPC_SUCCESS
)
873 complain (&cant_contact_target
);
877 *pAddr
= symbolAddr
.addr
;
878 return symbolAddr
.status
;
881 /* Check to see if the VxWorks target has a floating point coprocessor.
882 Returns 1 if target has floating point processor, 0 otherwise.
883 Calls error() if rpc fails. */
888 enum clnt_stat status
;
889 bool_t fp
= 0; /* true if fp processor is present on target board */
891 status
= net_clnt_call (VX_FP_INQUIRE
, xdr_void
, 0, xdr_bool
, &fp
);
892 if (status
!= RPC_SUCCESS
)
898 /* Establish an RPC connection with the VxWorks target system.
899 Calls error () if unable to establish connection. */
905 struct sockaddr_in destAddr
;
906 struct hostent
*destHost
;
909 /* Get the internet address for the given host. Allow a numeric
910 IP address or a hostname. */
912 addr
= inet_addr (host
);
915 destHost
= (struct hostent
*) gethostbyname (host
);
916 if (destHost
== NULL
)
917 /* FIXME: Probably should include hostname here in quotes.
918 For example if the user types "target vxworks vx960 " it should
919 say "Invalid host `vx960 '." not just "Invalid hostname". */
920 error ("Invalid hostname. Couldn't find remote host address.");
921 addr
= * (unsigned long *) destHost
->h_addr
;
924 memset (&destAddr
, '\0', sizeof (destAddr
));
926 destAddr
.sin_addr
.s_addr
= addr
;
927 destAddr
.sin_family
= AF_INET
;
928 destAddr
.sin_port
= 0; /* set to actual port that remote
929 ptrace is listening on. */
931 /* Create a tcp client transport on which to issue
932 calls to the remote ptrace server. */
934 ptraceSock
= RPC_ANYSOCK
;
935 pClient
= clnttcp_create (&destAddr
, RDBPROG
, RDBVERS
, &ptraceSock
, 0, 0);
936 /* FIXME, here is where we deal with different version numbers of the
941 clnt_pcreateerror ("\tnet_connect");
942 error ("Couldn't connect to remote target.");
946 /* Sleep for the specified number of milliseconds
947 * (assumed to be less than 1000).
948 * If select () is interrupted, returns immediately;
949 * takes an error exit if select () fails for some other reason.
956 struct timeval select_timeout
;
959 select_timeout
.tv_sec
= 0;
960 select_timeout
.tv_usec
= ms
* 1000;
962 status
= select (0, (fd_set
*) 0, (fd_set
*) 0, (fd_set
*) 0,
965 if (status
< 0 && errno
!= EINTR
)
966 perror_with_name ("select");
970 vx_wait (pid_to_wait_for
, status
)
972 struct target_waitstatus
*status
;
980 /* If CTRL-C is hit during this loop,
981 suspend the inferior process. */
986 quit_failed
= (net_quit () == -1);
990 /* If a net_quit () or net_wait () call has failed,
991 allow the user to break the connection with the target.
992 We can't simply error () out of this loop, since the
993 data structures representing the state of the inferior
994 are in an inconsistent state. */
996 if (quit_failed
|| net_wait (&rdbEvent
) == -1)
999 if (query ("Can't %s. Disconnect from target system? ",
1000 (quit_failed
) ? "suspend remote task"
1001 : "get status of remote task"))
1003 target_mourn_inferior();
1004 error ("Use the \"target\" command to reconnect.");
1008 terminal_inferior ();
1013 pid
= rdbEvent
.taskId
;
1016 sleep_ms (200); /* FIXME Don't kill the network too badly */
1018 else if (pid
!= inferior_pid
)
1019 fatal ("Bad pid for debugged task: %s\n",
1020 local_hex_string((unsigned long) pid
));
1023 /* The mostly likely kind. */
1024 status
->kind
= TARGET_WAITKIND_STOPPED
;
1026 switch (rdbEvent
.eventType
)
1029 status
->kind
= TARGET_WAITKIND_EXITED
;
1030 /* FIXME is it possible to distinguish between a
1031 normal vs abnormal exit in VxWorks? */
1032 status
->value
.integer
= 0;
1036 /* Task was just started. */
1037 status
->value
.sig
= TARGET_SIGNAL_TRAP
;
1041 status
->value
.sig
= TARGET_SIGNAL_TRAP
;
1042 /* XXX was it stopped by a signal? act accordingly */
1045 case EVENT_BREAK
: /* Breakpoint was hit. */
1046 status
->value
.sig
= TARGET_SIGNAL_TRAP
;
1049 case EVENT_SUSPEND
: /* Task was suspended, probably by ^C. */
1050 status
->value
.sig
= TARGET_SIGNAL_INT
;
1053 case EVENT_BUS_ERR
: /* Task made evil nasty reference. */
1054 status
->value
.sig
= TARGET_SIGNAL_BUS
;
1057 case EVENT_ZERO_DIV
: /* Division by zero */
1058 status
->value
.sig
= TARGET_SIGNAL_FPE
;
1063 status
->value
.sig
= i960_fault_to_signal (rdbEvent
.sigType
);
1065 /* Back in the old days, before enum target_signal, this code used
1066 to add NSIG to the signal number and claim that PRINT_RANDOM_SIGNAL
1067 would take care of it. But PRINT_RANDOM_SIGNAL has never been
1068 defined except on the i960, so I don't really know what we are
1069 supposed to do on other architectures. */
1070 status
->value
.sig
= TARGET_SIGNAL_UNKNOWN
;
1081 symbol_file_command (arg
, 0);
1086 add_symbol_stub (arg
)
1089 struct ldfile
*pLoadFile
= (struct ldfile
*)arg
;
1091 printf_unfiltered("\t%s: ", pLoadFile
->name
);
1092 vx_add_symbols (pLoadFile
->name
, 0, pLoadFile
->txt_addr
,
1093 pLoadFile
->data_addr
, pLoadFile
->bss_addr
);
1094 printf_unfiltered ("ok\n");
1097 /* Target command for VxWorks target systems.
1099 Used in vxgdb. Takes the name of a remote target machine
1100 running vxWorks and connects to it to initialize remote network
1104 vx_open (args
, from_tty
)
1108 extern int close ();
1110 extern char *source_path
;
1111 struct ldtabl loadTable
;
1112 struct ldfile
*pLoadFile
;
1114 extern CLIENT
*pClient
;
1115 int symbols_added
= 0;
1118 error_no_arg ("target machine name");
1120 target_preopen (from_tty
);
1122 unpush_target (&vx_ops
);
1123 printf_unfiltered ("Attaching remote machine across net...\n");
1124 gdb_flush (gdb_stdout
);
1126 /* Allow the user to kill the connect attempt by typing ^C.
1127 Wait until the call to target_has_fp () completes before
1128 disallowing an immediate quit, since even if net_connect ()
1129 is successful, the remote debug server might be hung. */
1134 target_has_fp
= net_check_for_fp ();
1135 printf_filtered ("Connected to %s.\n", args
);
1139 push_target (&vx_ops
);
1141 /* Save a copy of the target host's name. */
1142 vx_host
= savestring (args
, strlen (args
));
1144 /* Find out the name of the file from which the target was booted
1145 and load its symbol table. */
1147 printf_filtered ("Looking in Unix path for all loaded modules:\n");
1149 if (!net_get_boot_file (&bootFile
))
1153 printf_filtered ("\t%s: ", bootFile
);
1154 /* This assumes that the kernel is never relocated. Hope that is an
1155 accurate assumption. */
1159 "Error while reading symbols from boot file:\n",
1161 puts_filtered ("ok\n");
1164 printf_unfiltered ("VxWorks kernel symbols not loaded.\n");
1167 error ("Can't retrieve boot file name from target machine.");
1169 clnt_freeres (pClient
, xdr_wrapstring
, &bootFile
);
1171 if (net_get_symbols (&loadTable
) != 0)
1172 error ("Can't read loaded modules from target machine");
1175 while (++i
< loadTable
.tbl_size
)
1177 QUIT
; /* FIXME, avoids clnt_freeres below: mem leak */
1178 pLoadFile
= &loadTable
.tbl_ent
[i
];
1182 struct cleanup
*old_chain
;
1183 char *fullname
= NULL
;
1185 desc
= openp (source_path
, 0, pLoadFile
->name
, O_RDONLY
, 0, &fullname
);
1187 perror_with_name (pLoadFile
->name
);
1188 old_chain
= make_cleanup (close
, desc
);
1189 add_file_at_addr (fullname
, desc
, pLoadFile
->txt_addr
, pLoadFile
->data_addr
,
1190 pLoadFile
->bss_addr
);
1191 do_cleanups (old_chain
);
1194 /* FIXME: Is there something better to search than the PATH? (probably
1195 not the source path, since source might be in different directories
1198 if (catch_errors (add_symbol_stub
, (char *)pLoadFile
, (char *)0,
1203 printf_filtered ("Done.\n");
1205 clnt_freeres (pClient
, xdr_ldtabl
, &loadTable
);
1207 /* Getting new symbols may change our opinion about what is
1210 reinit_frame_cache ();
1213 /* Takes a task started up outside of gdb and ``attaches'' to it.
1214 This stops it cold in its tracks and allows us to start tracing it. */
1217 vx_attach (args
, from_tty
)
1224 Ptrace_return ptrace_out
;
1228 error_no_arg ("process-id to attach");
1230 pid
= strtoul (args
, &cptr
, 0);
1231 if ((cptr
== args
) || (*cptr
!= '\0'))
1232 error ("Invalid process-id -- give a single number in decimal or 0xhex");
1235 printf_unfiltered ("Attaching pid %s.\n",
1236 local_hex_string((unsigned long) pid
));
1238 memset ((char *)&ptrace_in
, '\0', sizeof (ptrace_in
));
1239 memset ((char *)&ptrace_out
, '\0', sizeof (ptrace_out
));
1240 ptrace_in
.pid
= pid
;
1242 status
= net_ptrace_clnt_call (PTRACE_ATTACH
, &ptrace_in
, &ptrace_out
);
1245 if (ptrace_out
.status
== -1)
1247 errno
= ptrace_out
.errno
;
1248 perror_with_name ("Attaching remote process");
1254 push_target (&vx_run_ops
);
1261 /* detach_command --
1262 takes a program previously attached to and detaches it.
1263 The program resumes execution and will no longer stop
1264 on signals, etc. We better not have left any breakpoints
1265 in the program or it'll die when it hits one. For this
1266 to work, it may be necessary for the process to have been
1267 previously attached. It *might* work if the program was
1268 started via the normal ptrace (PTRACE_TRACEME). */
1271 vx_detach (args
, from_tty
)
1276 Ptrace_return ptrace_out
;
1281 error ("Argument given to VxWorks \"detach\".");
1284 printf_unfiltered ("Detaching pid %s.\n",
1285 local_hex_string((unsigned long) inferior_pid
));
1287 if (args
) /* FIXME, should be possible to leave suspended */
1288 signal
= atoi (args
);
1290 memset ((char *)&ptrace_in
, '\0', sizeof (ptrace_in
));
1291 memset ((char *)&ptrace_out
, '\0', sizeof (ptrace_out
));
1292 ptrace_in
.pid
= inferior_pid
;
1294 status
= net_ptrace_clnt_call (PTRACE_DETACH
, &ptrace_in
, &ptrace_out
);
1297 if (ptrace_out
.status
== -1)
1299 errno
= ptrace_out
.errno
;
1300 perror_with_name ("Detaching VxWorks process");
1304 pop_target (); /* go back to non-executing VxWorks connection */
1307 /* vx_kill -- takes a running task and wipes it out. */
1313 Ptrace_return ptrace_out
;
1316 printf_unfiltered ("Killing pid %s.\n", local_hex_string((unsigned long) inferior_pid
));
1318 memset ((char *)&ptrace_in
, '\0', sizeof (ptrace_in
));
1319 memset ((char *)&ptrace_out
, '\0', sizeof (ptrace_out
));
1320 ptrace_in
.pid
= inferior_pid
;
1322 status
= net_ptrace_clnt_call (PTRACE_KILL
, &ptrace_in
, &ptrace_out
);
1325 else if (ptrace_out
.status
== -1)
1327 errno
= ptrace_out
.errno
;
1328 perror_with_name ("Killing VxWorks process");
1331 /* If it gives good status, the process is *gone*, no events remain.
1332 If the kill failed, assume the process is gone anyhow. */
1334 pop_target (); /* go back to non-executing VxWorks connection */
1337 /* Clean up from the VxWorks process target as it goes away. */
1340 vx_proc_close (quitting
)
1343 inferior_pid
= 0; /* No longer have a process. */
1349 /* Make an RPC call to the VxWorks target.
1350 Returns RPC status. */
1352 static enum clnt_stat
1353 net_clnt_call (procNum
, inProc
, in
, outProc
, out
)
1354 enum ptracereq procNum
;
1360 enum clnt_stat status
;
1362 status
= clnt_call (pClient
, procNum
, inProc
, in
, outProc
, out
, rpcTimeout
);
1364 if (status
!= RPC_SUCCESS
)
1365 clnt_perrno (status
);
1370 /* Clean up before losing control. */
1377 clnt_destroy (pClient
); /* The net connection */
1381 free (vx_host
); /* The hostname */
1385 /* A vxprocess target should be started via "run" not "target". */
1388 vx_proc_open (name
, from_tty
)
1392 error ("Use the \"run\" command to start a VxWorks process.");
1395 /* Target ops structure for accessing memory and such over the net */
1397 struct target_ops vx_ops
= {
1398 "vxworks", "VxWorks target memory via RPC over TCP/IP",
1399 "Use VxWorks target memory. \n\
1400 Specify the name of the machine to connect to.",
1401 vx_open
, vx_close
, vx_attach
, 0, /* vx_detach, */
1402 0, 0, /* resume, wait */
1403 0, 0, /* read_reg, write_reg */
1404 0, /* prep_to_store, */
1405 vx_xfer_memory
, vx_files_info
,
1406 0, 0, /* insert_breakpoint, remove_breakpoint */
1407 0, 0, 0, 0, 0, /* terminal stuff */
1411 vx_create_inferior
, 0, /* mourn_inferior */
1413 0, /* notice_signals */
1414 0, /* thread_alive */
1416 core_stratum
, 0, /* next */
1417 1, 1, 0, 0, 0, /* all mem, mem, stack, regs, exec */
1418 0, 0, /* Section pointers */
1419 OPS_MAGIC
, /* Always the last thing */
1422 /* Target ops structure for accessing VxWorks child processes over the net */
1424 struct target_ops vx_run_ops
= {
1425 "vxprocess", "VxWorks process",
1426 "VxWorks process, started by the \"run\" command.",
1427 vx_proc_open
, vx_proc_close
, 0, vx_detach
, /* vx_attach */
1429 vx_read_register
, vx_write_register
,
1430 vx_prepare_to_store
,
1431 vx_xfer_memory
, vx_run_files_info
,
1432 vx_insert_breakpoint
, vx_remove_breakpoint
,
1433 0, 0, 0, 0, 0, /* terminal stuff */
1437 0, vx_mourn_inferior
,
1439 0, /* notice_signals */
1440 0, /* thread_alive */
1442 process_stratum
, 0, /* next */
1443 0, /* all_mem--off to avoid spurious msg in "i files" */
1444 1, 1, 1, 1, /* mem, stack, regs, exec */
1445 0, 0, /* Section pointers */
1446 OPS_MAGIC
, /* Always the last thing */
1448 /* ==> Remember when reading at end of file, there are two "ops" structs here. */
1454 (add_set_cmd ("vxworks-timeout", class_support
, var_uinteger
,
1455 (char *) &rpcTimeout
.tv_sec
,
1456 "Set seconds to wait for rpc calls to return.\n\
1457 Set the number of seconds to wait for rpc calls to return.", &setlist
),
1460 add_target (&vx_ops
);
1461 add_target (&vx_run_ops
);