1 /* Memory-access and commands for remote VxWorks processes, for GDB.
2 Copyright (C) 1990-95, 1997-98, 1999 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 */
72 /* Target ops structure for accessing memory and such over the net */
74 static struct target_ops vx_ops
;
76 /* Target ops structure for accessing VxWorks child processes over the net */
78 static struct target_ops vx_run_ops
;
80 /* Saved name of target host and called function for "info files".
84 static char *vx_running
; /* Called function */
86 /* Nonzero means target that is being debugged remotely has a floating
91 /* Default error message when the network is forking up. */
93 static const char rpcerr
[] = "network target debugging: rpc error";
95 CLIENT
*pClient
; /* client used in net debugging */
96 static int ptraceSock
= RPC_ANYSOCK
;
98 enum clnt_stat
net_clnt_call();
99 static void parse_args ();
101 static struct timeval rpcTimeout
= { 10, 0 };
103 static char *skip_white_space ();
104 static char *find_white_space ();
106 /* Tell the VxWorks target system to download a file.
107 The load addresses of the text, data, and bss segments are
108 stored in *pTextAddr, *pDataAddr, and *pBssAddr (respectively).
109 Returns 0 for success, -1 for failure. */
112 net_load (filename
, pTextAddr
, pDataAddr
, pBssAddr
)
114 CORE_ADDR
*pTextAddr
;
115 CORE_ADDR
*pDataAddr
;
118 enum clnt_stat status
;
119 struct ldfile ldstruct
;
120 struct timeval load_timeout
;
122 memset ((char *) &ldstruct
, '\0', sizeof (ldstruct
));
124 /* We invoke clnt_call () here directly, instead of through
125 net_clnt_call (), because we need to set a large timeout value.
126 The load on the target side can take quite a while, easily
127 more than 10 seconds. The user can kill this call by typing
128 CTRL-C if there really is a problem with the load.
130 Do not change the tv_sec value without checking -- select() imposes
131 a limit of 10**8 on it for no good reason that I can see... */
133 load_timeout
.tv_sec
= 99999999; /* A large number, effectively inf. */
134 load_timeout
.tv_usec
= 0;
136 status
= clnt_call (pClient
, VX_LOAD
, xdr_wrapstring
, &filename
, xdr_ldfile
,
137 &ldstruct
, load_timeout
);
139 if (status
== RPC_SUCCESS
)
141 if (*ldstruct
.name
== 0) /* load failed on VxWorks side */
143 *pTextAddr
= ldstruct
.txt_addr
;
144 *pDataAddr
= ldstruct
.data_addr
;
145 *pBssAddr
= ldstruct
.bss_addr
;
152 /* returns 0 if successful, errno if RPC failed or VxWorks complains. */
155 net_break (addr
, procnum
)
159 enum clnt_stat status
;
161 Rptrace ptrace_in
; /* XXX This is stupid. It doesn't need to be a ptrace
162 structure. How about something smaller? */
164 memset ((char *) &ptrace_in
, '\0', sizeof (ptrace_in
));
167 ptrace_in
.addr
= addr
;
168 ptrace_in
.pid
= inferior_pid
;
170 status
= net_clnt_call (procnum
, xdr_rptrace
, &ptrace_in
, xdr_int
,
173 if (status
!= RPC_SUCCESS
)
176 if (break_status
== -1)
178 return break_status
; /* probably (FIXME) zero */
181 /* returns 0 if successful, errno otherwise */
184 vx_insert_breakpoint (addr
)
187 return net_break (addr
, VX_BREAK_ADD
);
190 /* returns 0 if successful, errno otherwise */
193 vx_remove_breakpoint (addr
)
196 return net_break (addr
, VX_BREAK_DELETE
);
199 /* Start an inferior process and sets inferior_pid to its pid.
200 EXEC_FILE is the file to run.
201 ALLARGS is a string containing the arguments to the program.
202 ENV is the environment vector to pass.
203 Returns process id. Errors reported with error().
204 On VxWorks, we ignore exec_file. */
207 vx_create_inferior (exec_file
, args
, env
)
212 enum clnt_stat status
;
214 TASK_START taskStart
;
216 memset ((char *) &passArgs
, '\0', sizeof (passArgs
));
217 memset ((char *) &taskStart
, '\0', sizeof (taskStart
));
219 /* parse arguments, put them in passArgs */
221 parse_args (args
, &passArgs
);
223 if (passArgs
.arg_array_len
== 0)
224 error ("You must specify a function name to run, and arguments if any");
226 status
= net_clnt_call (PROCESS_START
, xdr_arg_array
, &passArgs
,
227 xdr_TASK_START
, &taskStart
);
229 if ((status
!= RPC_SUCCESS
) || (taskStart
.status
== -1))
230 error ("Can't create process on remote target machine");
232 /* Save the name of the running function */
233 vx_running
= savestring (passArgs
.arg_array_val
[0],
234 strlen (passArgs
.arg_array_val
[0]));
236 push_target (&vx_run_ops
);
237 inferior_pid
= taskStart
.pid
;
239 /* We will get a trace trap after one instruction.
240 Insert breakpoints and continue. */
242 init_wait_for_inferior ();
244 /* Set up the "saved terminal modes" of the inferior
245 based on what modes we are starting it with. */
246 target_terminal_init ();
248 /* Install inferior's terminal modes. */
249 target_terminal_inferior ();
251 stop_soon_quietly
= 1;
252 wait_for_inferior (); /* Get the task spawn event */
253 stop_soon_quietly
= 0;
255 /* insert_step_breakpoint (); FIXME, do we need this? */
256 proceed (-1, TARGET_SIGNAL_DEFAULT
, 0);
259 /* Fill ARGSTRUCT in argc/argv form with the arguments from the
260 argument string ARGSTRING. */
263 parse_args (arg_string
, arg_struct
)
264 register char *arg_string
;
265 arg_array
*arg_struct
;
267 register int arg_count
= 0; /* number of arguments */
268 register int arg_index
= 0;
271 memset ((char *) arg_struct
, '\0', sizeof (arg_array
));
273 /* first count how many arguments there are */
278 if (*(p0
= skip_white_space (p0
)) == '\0')
280 p0
= find_white_space (p0
);
284 arg_struct
->arg_array_len
= arg_count
;
285 arg_struct
->arg_array_val
= (char **) xmalloc ((arg_count
+ 1)
288 /* now copy argument strings into arg_struct. */
290 while (*(arg_string
= skip_white_space (arg_string
)))
292 p0
= find_white_space (arg_string
);
293 arg_struct
->arg_array_val
[arg_index
++] = savestring (arg_string
,
298 arg_struct
->arg_array_val
[arg_count
] = NULL
;
301 /* Advance a string pointer across whitespace and return a pointer
302 to the first non-white character. */
308 while (*p
== ' ' || *p
== '\t')
313 /* Search for the first unquoted whitespace character in a string.
314 Returns a pointer to the character, or to the null terminator
315 if no whitespace is found. */
323 while ((c
= *p
) != ' ' && c
!= '\t' && c
)
325 if (c
== '\'' || c
== '"')
327 while (*++p
!= c
&& *p
)
340 /* Poll the VxWorks target system for an event related
341 to the debugged task.
342 Returns -1 if remote wait failed, task status otherwise. */
349 enum clnt_stat status
;
351 memset ((char *) pEvent
, '\0', sizeof (RDB_EVENT
));
354 status
= net_clnt_call (PROCESS_WAIT
, xdr_int
, &pid
, xdr_RDB_EVENT
,
357 /* return (status == RPC_SUCCESS)? pEvent->status: -1; */
358 if (status
== RPC_SUCCESS
)
359 return ((pEvent
->status
) ? 1 : 0);
360 else if (status
== RPC_TIMEDOUT
)
366 /* Suspend the remote task.
367 Returns -1 if suspend fails on target system, 0 otherwise. */
374 enum clnt_stat status
;
378 /* don't let rdbTask suspend itself by passing a pid of 0 */
380 if ((pid
= inferior_pid
) == 0)
383 status
= net_clnt_call (VX_TASK_SUSPEND
, xdr_int
, &pid
, xdr_int
,
386 return (status
== RPC_SUCCESS
)? quit_status
: -1;
389 /* Read a register or registers from the remote system. */
392 net_read_registers (reg_buf
, len
, procnum
)
399 Ptrace_return ptrace_out
;
403 memset ((char *) &ptrace_in
, '\0', sizeof (ptrace_in
));
404 memset ((char *) &ptrace_out
, '\0', sizeof (ptrace_out
));
406 /* Initialize RPC input argument structure. */
408 ptrace_in
.pid
= inferior_pid
;
409 ptrace_in
.info
.ttype
= NOINFO
;
411 /* Initialize RPC return value structure. */
413 out_data
.bytes
= reg_buf
;
415 ptrace_out
.info
.more_data
= (caddr_t
) &out_data
;
417 /* Call RPC; take an error exit if appropriate. */
419 status
= net_ptrace_clnt_call (procnum
, &ptrace_in
, &ptrace_out
);
422 if (ptrace_out
.status
== -1)
424 errno
= ptrace_out
.errno_num
;
425 sprintf (message
, "reading %s registers", (procnum
== PTRACE_GETREGS
)
428 perror_with_name (message
);
432 /* Write register values to a VxWorks target. REG_BUF points to a buffer
433 containing the raw register values, LEN is the length of REG_BUF in
434 bytes, and PROCNUM is the RPC procedure number (PTRACE_SETREGS or
435 PTRACE_SETFPREGS). An error exit is taken if the RPC call fails or
436 if an error status is returned by the remote debug server. This is
437 a utility routine used by vx_write_register (). */
440 net_write_registers (reg_buf
, len
, procnum
)
447 Ptrace_return ptrace_out
;
451 memset ((char *) &ptrace_in
, '\0', sizeof (ptrace_in
));
452 memset ((char *) &ptrace_out
, '\0', sizeof (ptrace_out
));
454 /* Initialize RPC input argument structure. */
456 in_data
.bytes
= reg_buf
;
459 ptrace_in
.pid
= inferior_pid
;
460 ptrace_in
.info
.ttype
= DATA
;
461 ptrace_in
.info
.more_data
= (caddr_t
) &in_data
;
463 /* Call RPC; take an error exit if appropriate. */
465 status
= net_ptrace_clnt_call (procnum
, &ptrace_in
, &ptrace_out
);
468 if (ptrace_out
.status
== -1)
470 errno
= ptrace_out
.errno_num
;
471 sprintf (message
, "writing %s registers", (procnum
== PTRACE_SETREGS
)
474 perror_with_name (message
);
478 /* Prepare to store registers. Since we will store all of them,
479 read out their current values now. */
482 vx_prepare_to_store ()
484 /* Fetch all registers, if any of them are not yet fetched. */
485 read_register_bytes (0, NULL
, REGISTER_BYTES
);
488 /* Copy LEN bytes to or from remote inferior's memory starting at MEMADDR
489 to debugger memory starting at MYADDR. WRITE is true if writing to the
491 Result is the number of bytes written or read (zero if error). The
492 protocol allows us to return a negative count, indicating that we can't
493 handle the current address but can handle one N bytes further, but
494 vxworks doesn't give us that information. */
497 vx_xfer_memory (memaddr
, myaddr
, len
, write
, target
)
502 struct target_ops
*target
; /* ignored */
506 Ptrace_return ptrace_out
;
508 enum ptracereq request
;
511 memset ((char *) &ptrace_in
, '\0', sizeof (ptrace_in
));
512 memset ((char *) &ptrace_out
, '\0', sizeof (ptrace_out
));
514 ptrace_in
.pid
= inferior_pid
; /* XXX pid unnecessary for READDATA */
515 ptrace_in
.addr
= (int) memaddr
; /* Where from */
516 ptrace_in
.data
= len
; /* How many bytes */
520 ptrace_in
.info
.ttype
= DATA
;
521 ptrace_in
.info
.more_data
= (caddr_t
) &data
;
523 data
.bytes
= (caddr_t
) myaddr
; /* Where from */
524 data
.len
= len
; /* How many bytes (again, for XDR) */
525 request
= PTRACE_WRITEDATA
;
529 ptrace_out
.info
.more_data
= (caddr_t
) &data
;
530 request
= PTRACE_READDATA
;
532 /* Loop until the entire request has been satisfied, transferring
533 at most VX_MEMXFER_MAX bytes per iteration. Break from the loop
534 if an error status is returned by the remote debug server. */
539 while (nleft
> 0 && status
== 0)
541 nxfer
= min (nleft
, VX_MEMXFER_MAX
);
543 ptrace_in
.addr
= (int) memaddr
;
544 ptrace_in
.data
= nxfer
;
545 data
.bytes
= (caddr_t
) myaddr
;
548 /* Request a block from the remote debug server; if RPC fails,
549 report an error and return to debugger command level. */
551 if (net_ptrace_clnt_call (request
, &ptrace_in
, &ptrace_out
))
554 status
= ptrace_out
.status
;
563 /* A target-side error has ocurred. Set errno to the error
564 code chosen by the target so that a later perror () will
565 say something meaningful. */
567 errno
= ptrace_out
.errno_num
;
571 /* Return the number of bytes transferred. */
573 return (len
- nleft
);
579 printf_unfiltered ("\tAttached to host `%s'", vx_host
);
580 printf_unfiltered (", which has %sfloating point", target_has_fp
? "": "no ");
581 printf_unfiltered (".\n");
587 printf_unfiltered ("\tRunning %s VxWorks process %s",
588 vx_running
? "child" : "attached",
589 local_hex_string (inferior_pid
));
591 printf_unfiltered (", function `%s'", vx_running
);
592 printf_unfiltered(".\n");
596 vx_resume (pid
, step
, siggnal
)
599 enum target_signal siggnal
;
603 Ptrace_return ptrace_out
;
609 if (siggnal
!= 0 && siggnal
!= stop_signal
)
610 error ("Cannot send signals to VxWorks processes");
612 /* Set CONT_ADDR to the address at which we are continuing,
613 or to 1 if we are continuing from where the program stopped.
614 This conforms to traditional ptrace () usage, but at the same
615 time has special meaning for the VxWorks remote debug server.
616 If the address is not 1, the server knows that the target
617 program is jumping to a new address, which requires special
618 handling if there is a breakpoint at the new address. */
620 cont_addr
= read_register (PC_REGNUM
);
621 if (cont_addr
== stop_pc
)
624 memset ((char *) &ptrace_in
, '\0', sizeof (ptrace_in
));
625 memset ((char *) &ptrace_out
, '\0', sizeof (ptrace_out
));
628 ptrace_in
.addr
= cont_addr
; /* Target side insists on this, or it panics. */
633 status
= net_ptrace_clnt_call (PTRACE_CONT
, &ptrace_in
, &ptrace_out
);
637 if (ptrace_out
.status
== -1)
639 errno
= ptrace_out
.errno_num
;
640 perror_with_name ("Resuming remote process");
647 pop_target (); /* Pop back to no-child state */
648 generic_mourn_inferior ();
652 static void vx_add_symbols
PARAMS ((char *, int, CORE_ADDR
, CORE_ADDR
,
655 struct find_sect_args
{
656 CORE_ADDR text_start
;
657 CORE_ADDR data_start
;
661 static void find_sect
PARAMS ((bfd
*, asection
*, void *));
664 find_sect (abfd
, sect
, obj
)
669 struct find_sect_args
*args
= (struct find_sect_args
*)obj
;
671 if (bfd_get_section_flags (abfd
, sect
) & (SEC_CODE
& SEC_READONLY
))
672 args
->text_start
= bfd_get_section_vma (abfd
, sect
);
673 else if (bfd_get_section_flags (abfd
, sect
) & SEC_ALLOC
)
675 if (bfd_get_section_flags (abfd
, sect
) & SEC_LOAD
)
677 /* Exclude .ctor and .dtor sections which have SEC_CODE set but not
679 if (bfd_get_section_flags (abfd
, sect
) & SEC_DATA
)
680 args
->data_start
= bfd_get_section_vma (abfd
, sect
);
683 args
->bss_start
= bfd_get_section_vma (abfd
, sect
);
688 vx_add_symbols (name
, from_tty
, text_addr
, data_addr
, bss_addr
)
695 struct section_offsets
*offs
;
696 struct objfile
*objfile
;
697 struct find_sect_args ss
;
699 /* It might be nice to suppress the breakpoint_re_set which happens here
700 because we are going to do one again after the objfile_relocate. */
701 objfile
= symbol_file_add (name
, from_tty
, 0, 0, 0, 0, 0, 0);
703 /* This is a (slightly cheesy) way of superceding the old symbols. A less
704 cheesy way would be to find the objfile with the same name and
706 objfile_to_front (objfile
);
708 offs
= (struct section_offsets
*)
709 alloca (sizeof (struct section_offsets
)
710 + objfile
->num_sections
* sizeof (offs
->offsets
));
711 memcpy (offs
, objfile
->section_offsets
,
712 sizeof (struct section_offsets
)
713 + objfile
->num_sections
* sizeof (offs
->offsets
));
718 bfd_map_over_sections (objfile
->obfd
, find_sect
, &ss
);
720 /* Both COFF and b.out frontends use these SECT_OFF_* values. */
721 ANOFFSET (offs
, SECT_OFF_TEXT
) = text_addr
- ss
.text_start
;
722 ANOFFSET (offs
, SECT_OFF_DATA
) = data_addr
- ss
.data_start
;
723 ANOFFSET (offs
, SECT_OFF_BSS
) = bss_addr
- ss
.bss_start
;
724 objfile_relocate (objfile
, offs
);
727 /* This function allows the addition of incrementally linked object files. */
730 vx_load_command (arg_string
, from_tty
)
739 error ("The load command takes a file name");
741 arg_string
= tilde_expand (arg_string
);
742 make_cleanup (free
, arg_string
);
746 /* Refuse to load the module if a debugged task is running. Doing so
747 can have a number of unpleasant consequences to the running task. */
749 if (inferior_pid
!= 0 && target_has_execution
)
751 if (query ("You may not load a module while the target task is running.\n\
752 Kill the target task? "))
755 error ("Load cancelled.");
760 if (net_load (arg_string
, &text_addr
, &data_addr
, &bss_addr
) == -1)
761 error ("Load failed on target machine");
764 vx_add_symbols (arg_string
, from_tty
, text_addr
, data_addr
, bss_addr
);
766 /* Getting new symbols may change our opinion about what is
768 reinit_frame_cache ();
771 /* Single step the target program at the source or machine level.
772 Takes an error exit if rpc fails.
773 Returns -1 if remote single-step operation fails, else 0. */
778 enum clnt_stat status
;
780 SOURCE_STEP source_step
;
782 source_step
.taskId
= inferior_pid
;
786 source_step
.startAddr
= step_range_start
;
787 source_step
.endAddr
= step_range_end
;
791 source_step
.startAddr
= 0;
792 source_step
.endAddr
= 0;
795 status
= net_clnt_call (VX_SOURCE_STEP
, xdr_SOURCE_STEP
, &source_step
,
796 xdr_int
, &step_status
);
798 if (status
== RPC_SUCCESS
)
804 /* Emulate ptrace using RPC calls to the VxWorks target system.
805 Returns nonzero (-1) if RPC status to VxWorks is bad, 0 otherwise. */
808 net_ptrace_clnt_call (request
, pPtraceIn
, pPtraceOut
)
809 enum ptracereq request
;
811 Ptrace_return
*pPtraceOut
;
813 enum clnt_stat status
;
815 status
= net_clnt_call (request
, xdr_rptrace
, pPtraceIn
, xdr_ptrace_return
,
818 if (status
!= RPC_SUCCESS
)
824 /* Query the target for the name of the file from which VxWorks was
825 booted. pBootFile is the address of a pointer to the buffer to
826 receive the file name; if the pointer pointed to by pBootFile is
827 NULL, memory for the buffer will be allocated by XDR.
828 Returns -1 if rpc failed, 0 otherwise. */
831 net_get_boot_file (pBootFile
)
834 enum clnt_stat status
;
836 status
= net_clnt_call (VX_BOOT_FILE_INQ
, xdr_void
, (char *) 0,
837 xdr_wrapstring
, pBootFile
);
838 return (status
== RPC_SUCCESS
) ? 0 : -1;
841 /* Fetch a list of loaded object modules from the VxWorks target.
842 Returns -1 if rpc failed, 0 otherwise
843 There's no way to check if the returned loadTable is correct.
844 VxWorks doesn't check it. */
847 net_get_symbols (pLoadTable
)
848 ldtabl
*pLoadTable
; /* return pointer to ldtabl here */
850 enum clnt_stat status
;
852 memset ((char *) pLoadTable
, '\0', sizeof (struct ldtabl
));
854 status
= net_clnt_call (VX_STATE_INQ
, xdr_void
, 0, xdr_ldtabl
, pLoadTable
);
855 return (status
== RPC_SUCCESS
) ? 0 : -1;
858 /* Look up a symbol in the VxWorks target's symbol table.
859 Returns status of symbol read on target side (0=success, -1=fail)
860 Returns -1 and complain()s if rpc fails. */
862 struct complaint cant_contact_target
=
863 {"Lost contact with VxWorks target", 0, 0};
866 vx_lookup_symbol (name
, pAddr
)
867 char *name
; /* symbol name */
870 enum clnt_stat status
;
871 SYMBOL_ADDR symbolAddr
;
874 memset ((char *) &symbolAddr
, '\0', sizeof (symbolAddr
));
876 status
= net_clnt_call (VX_SYMBOL_INQ
, xdr_wrapstring
, &name
,
877 xdr_SYMBOL_ADDR
, &symbolAddr
);
878 if (status
!= RPC_SUCCESS
)
880 complain (&cant_contact_target
);
884 *pAddr
= symbolAddr
.addr
;
885 return symbolAddr
.status
;
888 /* Check to see if the VxWorks target has a floating point coprocessor.
889 Returns 1 if target has floating point processor, 0 otherwise.
890 Calls error() if rpc fails. */
895 enum clnt_stat status
;
896 bool_t fp
= 0; /* true if fp processor is present on target board */
898 status
= net_clnt_call (VX_FP_INQUIRE
, xdr_void
, 0, xdr_bool
, &fp
);
899 if (status
!= RPC_SUCCESS
)
905 /* Establish an RPC connection with the VxWorks target system.
906 Calls error () if unable to establish connection. */
912 struct sockaddr_in destAddr
;
913 struct hostent
*destHost
;
916 /* Get the internet address for the given host. Allow a numeric
917 IP address or a hostname. */
919 addr
= inet_addr (host
);
922 destHost
= (struct hostent
*) gethostbyname (host
);
923 if (destHost
== NULL
)
924 /* FIXME: Probably should include hostname here in quotes.
925 For example if the user types "target vxworks vx960 " it should
926 say "Invalid host `vx960 '." not just "Invalid hostname". */
927 error ("Invalid hostname. Couldn't find remote host address.");
928 addr
= * (unsigned long *) destHost
->h_addr
;
931 memset (&destAddr
, '\0', sizeof (destAddr
));
933 destAddr
.sin_addr
.s_addr
= addr
;
934 destAddr
.sin_family
= AF_INET
;
935 destAddr
.sin_port
= 0; /* set to actual port that remote
936 ptrace is listening on. */
938 /* Create a tcp client transport on which to issue
939 calls to the remote ptrace server. */
941 ptraceSock
= RPC_ANYSOCK
;
942 pClient
= clnttcp_create (&destAddr
, RDBPROG
, RDBVERS
, &ptraceSock
, 0, 0);
943 /* FIXME, here is where we deal with different version numbers of the
948 clnt_pcreateerror ("\tnet_connect");
949 error ("Couldn't connect to remote target.");
953 /* Sleep for the specified number of milliseconds
954 * (assumed to be less than 1000).
955 * If select () is interrupted, returns immediately;
956 * takes an error exit if select () fails for some other reason.
963 struct timeval select_timeout
;
966 select_timeout
.tv_sec
= 0;
967 select_timeout
.tv_usec
= ms
* 1000;
969 status
= select (0, (fd_set
*) 0, (fd_set
*) 0, (fd_set
*) 0,
972 if (status
< 0 && errno
!= EINTR
)
973 perror_with_name ("select");
977 vx_wait (pid_to_wait_for
, status
)
979 struct target_waitstatus
*status
;
987 /* If CTRL-C is hit during this loop,
988 suspend the inferior process. */
993 quit_failed
= (net_quit () == -1);
997 /* If a net_quit () or net_wait () call has failed,
998 allow the user to break the connection with the target.
999 We can't simply error () out of this loop, since the
1000 data structures representing the state of the inferior
1001 are in an inconsistent state. */
1003 if (quit_failed
|| net_wait (&rdbEvent
) == -1)
1006 if (query ("Can't %s. Disconnect from target system? ",
1007 (quit_failed
) ? "suspend remote task"
1008 : "get status of remote task"))
1010 target_mourn_inferior();
1011 error ("Use the \"target\" command to reconnect.");
1015 terminal_inferior ();
1020 pid
= rdbEvent
.taskId
;
1023 sleep_ms (200); /* FIXME Don't kill the network too badly */
1025 else if (pid
!= inferior_pid
)
1026 fatal ("Bad pid for debugged task: %s\n",
1027 local_hex_string((unsigned long) pid
));
1030 /* The mostly likely kind. */
1031 status
->kind
= TARGET_WAITKIND_STOPPED
;
1033 switch (rdbEvent
.eventType
)
1036 status
->kind
= TARGET_WAITKIND_EXITED
;
1037 /* FIXME is it possible to distinguish between a
1038 normal vs abnormal exit in VxWorks? */
1039 status
->value
.integer
= 0;
1043 /* Task was just started. */
1044 status
->value
.sig
= TARGET_SIGNAL_TRAP
;
1048 status
->value
.sig
= TARGET_SIGNAL_TRAP
;
1049 /* XXX was it stopped by a signal? act accordingly */
1052 case EVENT_BREAK
: /* Breakpoint was hit. */
1053 status
->value
.sig
= TARGET_SIGNAL_TRAP
;
1056 case EVENT_SUSPEND
: /* Task was suspended, probably by ^C. */
1057 status
->value
.sig
= TARGET_SIGNAL_INT
;
1060 case EVENT_BUS_ERR
: /* Task made evil nasty reference. */
1061 status
->value
.sig
= TARGET_SIGNAL_BUS
;
1064 case EVENT_ZERO_DIV
: /* Division by zero */
1065 status
->value
.sig
= TARGET_SIGNAL_FPE
;
1070 status
->value
.sig
= i960_fault_to_signal (rdbEvent
.sigType
);
1072 /* Back in the old days, before enum target_signal, this code used
1073 to add NSIG to the signal number and claim that PRINT_RANDOM_SIGNAL
1074 would take care of it. But PRINT_RANDOM_SIGNAL has never been
1075 defined except on the i960, so I don't really know what we are
1076 supposed to do on other architectures. */
1077 status
->value
.sig
= TARGET_SIGNAL_UNKNOWN
;
1088 symbol_file_command (arg
, 0);
1093 add_symbol_stub (arg
)
1096 struct ldfile
*pLoadFile
= (struct ldfile
*)arg
;
1098 printf_unfiltered("\t%s: ", pLoadFile
->name
);
1099 vx_add_symbols (pLoadFile
->name
, 0, pLoadFile
->txt_addr
,
1100 pLoadFile
->data_addr
, pLoadFile
->bss_addr
);
1101 printf_unfiltered ("ok\n");
1104 /* Target command for VxWorks target systems.
1106 Used in vxgdb. Takes the name of a remote target machine
1107 running vxWorks and connects to it to initialize remote network
1111 vx_open (args
, from_tty
)
1115 extern int close ();
1117 extern char *source_path
;
1118 struct ldtabl loadTable
;
1119 struct ldfile
*pLoadFile
;
1121 extern CLIENT
*pClient
;
1122 int symbols_added
= 0;
1125 error_no_arg ("target machine name");
1127 target_preopen (from_tty
);
1129 unpush_target (&vx_ops
);
1130 printf_unfiltered ("Attaching remote machine across net...\n");
1131 gdb_flush (gdb_stdout
);
1133 /* Allow the user to kill the connect attempt by typing ^C.
1134 Wait until the call to target_has_fp () completes before
1135 disallowing an immediate quit, since even if net_connect ()
1136 is successful, the remote debug server might be hung. */
1141 target_has_fp
= net_check_for_fp ();
1142 printf_filtered ("Connected to %s.\n", args
);
1146 push_target (&vx_ops
);
1148 /* Save a copy of the target host's name. */
1149 vx_host
= savestring (args
, strlen (args
));
1151 /* Find out the name of the file from which the target was booted
1152 and load its symbol table. */
1154 printf_filtered ("Looking in Unix path for all loaded modules:\n");
1156 if (!net_get_boot_file (&bootFile
))
1160 printf_filtered ("\t%s: ", bootFile
);
1161 /* This assumes that the kernel is never relocated. Hope that is an
1162 accurate assumption. */
1166 "Error while reading symbols from boot file:\n",
1168 puts_filtered ("ok\n");
1171 printf_unfiltered ("VxWorks kernel symbols not loaded.\n");
1174 error ("Can't retrieve boot file name from target machine.");
1176 clnt_freeres (pClient
, xdr_wrapstring
, &bootFile
);
1178 if (net_get_symbols (&loadTable
) != 0)
1179 error ("Can't read loaded modules from target machine");
1182 while (++i
< loadTable
.tbl_size
)
1184 QUIT
; /* FIXME, avoids clnt_freeres below: mem leak */
1185 pLoadFile
= &loadTable
.tbl_ent
[i
];
1189 struct cleanup
*old_chain
;
1190 char *fullname
= NULL
;
1192 desc
= openp (source_path
, 0, pLoadFile
->name
, O_RDONLY
, 0, &fullname
);
1194 perror_with_name (pLoadFile
->name
);
1195 old_chain
= make_cleanup (close
, desc
);
1196 add_file_at_addr (fullname
, desc
, pLoadFile
->txt_addr
, pLoadFile
->data_addr
,
1197 pLoadFile
->bss_addr
);
1198 do_cleanups (old_chain
);
1201 /* FIXME: Is there something better to search than the PATH? (probably
1202 not the source path, since source might be in different directories
1205 if (catch_errors (add_symbol_stub
, (char *)pLoadFile
, (char *)0,
1210 printf_filtered ("Done.\n");
1212 clnt_freeres (pClient
, xdr_ldtabl
, &loadTable
);
1214 /* Getting new symbols may change our opinion about what is
1217 reinit_frame_cache ();
1220 /* Takes a task started up outside of gdb and ``attaches'' to it.
1221 This stops it cold in its tracks and allows us to start tracing it. */
1224 vx_attach (args
, from_tty
)
1231 Ptrace_return ptrace_out
;
1235 error_no_arg ("process-id to attach");
1237 pid
= strtoul (args
, &cptr
, 0);
1238 if ((cptr
== args
) || (*cptr
!= '\0'))
1239 error ("Invalid process-id -- give a single number in decimal or 0xhex");
1242 printf_unfiltered ("Attaching pid %s.\n",
1243 local_hex_string((unsigned long) pid
));
1245 memset ((char *)&ptrace_in
, '\0', sizeof (ptrace_in
));
1246 memset ((char *)&ptrace_out
, '\0', sizeof (ptrace_out
));
1247 ptrace_in
.pid
= pid
;
1249 status
= net_ptrace_clnt_call (PTRACE_ATTACH
, &ptrace_in
, &ptrace_out
);
1252 if (ptrace_out
.status
== -1)
1254 errno
= ptrace_out
.errno_num
;
1255 perror_with_name ("Attaching remote process");
1261 push_target (&vx_run_ops
);
1268 /* detach_command --
1269 takes a program previously attached to and detaches it.
1270 The program resumes execution and will no longer stop
1271 on signals, etc. We better not have left any breakpoints
1272 in the program or it'll die when it hits one. For this
1273 to work, it may be necessary for the process to have been
1274 previously attached. It *might* work if the program was
1275 started via the normal ptrace (PTRACE_TRACEME). */
1278 vx_detach (args
, from_tty
)
1283 Ptrace_return ptrace_out
;
1288 error ("Argument given to VxWorks \"detach\".");
1291 printf_unfiltered ("Detaching pid %s.\n",
1292 local_hex_string((unsigned long) inferior_pid
));
1294 if (args
) /* FIXME, should be possible to leave suspended */
1295 signal
= atoi (args
);
1297 memset ((char *)&ptrace_in
, '\0', sizeof (ptrace_in
));
1298 memset ((char *)&ptrace_out
, '\0', sizeof (ptrace_out
));
1299 ptrace_in
.pid
= inferior_pid
;
1301 status
= net_ptrace_clnt_call (PTRACE_DETACH
, &ptrace_in
, &ptrace_out
);
1304 if (ptrace_out
.status
== -1)
1306 errno
= ptrace_out
.errno_num
;
1307 perror_with_name ("Detaching VxWorks process");
1311 pop_target (); /* go back to non-executing VxWorks connection */
1314 /* vx_kill -- takes a running task and wipes it out. */
1320 Ptrace_return ptrace_out
;
1323 printf_unfiltered ("Killing pid %s.\n", local_hex_string((unsigned long) inferior_pid
));
1325 memset ((char *)&ptrace_in
, '\0', sizeof (ptrace_in
));
1326 memset ((char *)&ptrace_out
, '\0', sizeof (ptrace_out
));
1327 ptrace_in
.pid
= inferior_pid
;
1329 status
= net_ptrace_clnt_call (PTRACE_KILL
, &ptrace_in
, &ptrace_out
);
1332 else if (ptrace_out
.status
== -1)
1334 errno
= ptrace_out
.errno_num
;
1335 perror_with_name ("Killing VxWorks process");
1338 /* If it gives good status, the process is *gone*, no events remain.
1339 If the kill failed, assume the process is gone anyhow. */
1341 pop_target (); /* go back to non-executing VxWorks connection */
1344 /* Clean up from the VxWorks process target as it goes away. */
1347 vx_proc_close (quitting
)
1350 inferior_pid
= 0; /* No longer have a process. */
1356 /* Make an RPC call to the VxWorks target.
1357 Returns RPC status. */
1359 static enum clnt_stat
1360 net_clnt_call (procNum
, inProc
, in
, outProc
, out
)
1361 enum ptracereq procNum
;
1367 enum clnt_stat status
;
1369 status
= clnt_call (pClient
, procNum
, inProc
, in
, outProc
, out
, rpcTimeout
);
1371 if (status
!= RPC_SUCCESS
)
1372 clnt_perrno (status
);
1377 /* Clean up before losing control. */
1384 clnt_destroy (pClient
); /* The net connection */
1388 free (vx_host
); /* The hostname */
1392 /* A vxprocess target should be started via "run" not "target". */
1395 vx_proc_open (name
, from_tty
)
1399 error ("Use the \"run\" command to start a VxWorks process.");
1405 vx_ops
.to_shortname
= "vxworks";
1406 vx_ops
.to_longname
= "VxWorks target memory via RPC over TCP/IP";
1407 vx_ops
.to_doc
= "Use VxWorks target memory. \n\
1408 Specify the name of the machine to connect to.";
1409 vx_ops
.to_open
= vx_open
;
1410 vx_ops
.to_close
= vx_close
;
1411 vx_ops
.to_attach
= vx_attach
;
1412 vx_ops
.to_xfer_memory
= vx_xfer_memory
;
1413 vx_ops
.to_files_info
= vx_files_info
;
1414 vx_ops
.to_load
= vx_load_command
;
1415 vx_ops
.to_lookup_symbol
= vx_lookup_symbol
;
1416 vx_ops
.to_create_inferior
= vx_create_inferior
;
1417 vx_ops
.to_stratum
= core_stratum
;
1418 vx_ops
.to_has_all_memory
= 1;
1419 vx_ops
.to_has_memory
= 1;
1420 vx_ops
.to_magic
= OPS_MAGIC
; /* Always the last thing */
1426 vx_run_ops
.to_shortname
= "vxprocess";
1427 vx_run_ops
.to_longname
= "VxWorks process";
1428 vx_run_ops
.to_doc
= "VxWorks process; started by the \"run\" command.";
1429 vx_run_ops
.to_open
= vx_proc_open
;
1430 vx_run_ops
.to_close
= vx_proc_close
;
1431 vx_run_ops
.to_detach
= vx_detach
;
1432 vx_run_ops
.to_resume
= vx_resume
;
1433 vx_run_ops
.to_wait
= vx_wait
;
1434 vx_run_ops
.to_fetch_registers
= vx_read_register
;
1435 vx_run_ops
.to_store_registers
= vx_write_register
;
1436 vx_run_ops
.to_prepare_to_store
= vx_prepare_to_store
;
1437 vx_run_ops
.to_xfer_memory
= vx_xfer_memory
;
1438 vx_run_ops
.to_files_info
= vx_run_files_info
;
1439 vx_run_ops
.to_insert_breakpoint
= vx_insert_breakpoint
;
1440 vx_run_ops
.to_remove_breakpoint
= vx_remove_breakpoint
;
1441 vx_run_ops
.to_kill
= vx_kill
;
1442 vx_run_ops
.to_load
= vx_load_command
;
1443 vx_run_ops
.to_lookup_symbol
= vx_lookup_symbol
;
1444 vx_run_ops
.to_mourn_inferior
= vx_mourn_inferior
;
1445 vx_run_ops
.to_stratum
= process_stratum
;
1446 vx_run_ops
.to_has_memory
= 1;
1447 vx_run_ops
.to_has_stack
= 1;
1448 vx_run_ops
.to_has_registers
= 1;
1449 vx_run_ops
.to_has_execution
= 1;
1450 vx_run_ops
.to_magic
= OPS_MAGIC
;
1457 add_target (&vx_ops
);
1459 add_target (&vx_run_ops
);
1462 (add_set_cmd ("vxworks-timeout", class_support
, var_uinteger
,
1463 (char *) &rpcTimeout
.tv_sec
,
1464 "Set seconds to wait for rpc calls to return.\n\
1465 Set the number of seconds to wait for rpc calls to return.", &setlist
),