1 /* Memory-access and commands for remote VxWorks processes, for GDB.
3 Copyright 1990, 1991, 1992, 1993, 1994, 1995, 1997, 1998, 1999,
4 2000, 2001, 2002 Free Software Foundation, Inc.
6 Contributed by Wind River Systems and Cygnus Support.
8 This file is part of GDB.
10 This program is free software; you can redistribute it and/or modify
11 it under the terms of the GNU General Public License as published by
12 the Free Software Foundation; either version 2 of the License, or
13 (at your option) any later version.
15 This program is distributed in the hope that it will be useful,
16 but WITHOUT ANY WARRANTY; without even the implied warranty of
17 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
18 GNU General Public License for more details.
20 You should have received a copy of the GNU General Public License
21 along with this program; if not, write to the Free Software
22 Foundation, Inc., 59 Temple Place - Suite 330,
23 Boston, MA 02111-1307, USA. */
32 #include "complaints.h"
34 #include "bfd.h" /* Required by objfiles.h. */
37 #include "gdb-stabs.h"
40 #include "gdb_string.h"
44 #include <sys/types.h>
45 #include <sys/socket.h>
46 #define malloc bogon_malloc /* Sun claims "char *malloc()" not void * */
47 #define free bogon_free /* Sun claims "int free()" not void */
48 #define realloc bogon_realloc /* Sun claims "char *realloc()", not void * */
53 #include <sys/time.h> /* UTek's <rpc/rpc.h> doesn't #incl this */
55 #include "vx-share/ptrace.h"
56 #include "vx-share/xdr_ptrace.h"
57 #include "vx-share/xdr_ld.h"
58 #include "vx-share/xdr_rdb.h"
59 #include "vx-share/dbgRpcLib.h"
63 /* Maximum number of bytes to transfer in a single
64 PTRACE_{READ,WRITE}DATA request. */
65 #define VX_MEMXFER_MAX 4096
67 extern void vx_read_register ();
68 extern void vx_write_register ();
69 extern void symbol_file_command ();
70 extern enum stop_kind stop_soon
; /* for wait_for_inferior */
72 static int net_step ();
73 static int net_ptrace_clnt_call (); /* Forward decl */
74 static enum clnt_stat
net_clnt_call (); /* Forward decl */
76 /* Target ops structure for accessing memory and such over the net */
78 static struct target_ops vx_ops
;
80 /* Target ops structure for accessing VxWorks child processes over the net */
82 static struct target_ops vx_run_ops
;
84 /* Saved name of target host and called function for "info files".
88 static char *vx_running
; /* Called function */
90 /* Nonzero means target that is being debugged remotely has a floating
95 /* Default error message when the network is forking up. */
97 static const char rpcerr
[] = "network target debugging: rpc error";
99 CLIENT
*pClient
; /* client used in net debugging */
100 static int ptraceSock
= RPC_ANYSOCK
;
102 enum clnt_stat
net_clnt_call ();
103 static void parse_args ();
105 static struct timeval rpcTimeout
=
108 static char *skip_white_space ();
109 static char *find_white_space ();
111 /* Tell the VxWorks target system to download a file.
112 The load addresses of the text, data, and bss segments are
113 stored in *pTextAddr, *pDataAddr, and *pBssAddr (respectively).
114 Returns 0 for success, -1 for failure. */
117 net_load (char *filename
, CORE_ADDR
*pTextAddr
, CORE_ADDR
*pDataAddr
,
120 enum clnt_stat status
;
121 struct ldfile ldstruct
;
122 struct timeval load_timeout
;
124 memset ((char *) &ldstruct
, '\0', sizeof (ldstruct
));
126 /* We invoke clnt_call () here directly, instead of through
127 net_clnt_call (), because we need to set a large timeout value.
128 The load on the target side can take quite a while, easily
129 more than 10 seconds. The user can kill this call by typing
130 CTRL-C if there really is a problem with the load.
132 Do not change the tv_sec value without checking -- select() imposes
133 a limit of 10**8 on it for no good reason that I can see... */
135 load_timeout
.tv_sec
= 99999999; /* A large number, effectively inf. */
136 load_timeout
.tv_usec
= 0;
138 status
= clnt_call (pClient
, VX_LOAD
, xdr_wrapstring
, &filename
, xdr_ldfile
,
139 &ldstruct
, load_timeout
);
141 if (status
== RPC_SUCCESS
)
143 if (*ldstruct
.name
== 0) /* load failed on VxWorks side */
145 *pTextAddr
= ldstruct
.txt_addr
;
146 *pDataAddr
= ldstruct
.data_addr
;
147 *pBssAddr
= ldstruct
.bss_addr
;
154 /* returns 0 if successful, errno if RPC failed or VxWorks complains. */
157 net_break (int addr
, u_long 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
= PIDGET (inferior_ptid
);
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 (int addr
)
186 return net_break (addr
, VX_BREAK_ADD
);
189 /* returns 0 if successful, errno otherwise */
192 vx_remove_breakpoint (int addr
)
194 return net_break (addr
, VX_BREAK_DELETE
);
197 /* Start an inferior process and sets inferior_ptid to its pid.
198 EXEC_FILE is the file to run.
199 ALLARGS is a string containing the arguments to the program.
200 ENV is the environment vector to pass.
201 Returns process id. Errors reported with error().
202 On VxWorks, we ignore exec_file. */
205 vx_create_inferior (char *exec_file
, char *args
, char **env
)
207 enum clnt_stat status
;
209 TASK_START taskStart
;
211 memset ((char *) &passArgs
, '\0', sizeof (passArgs
));
212 memset ((char *) &taskStart
, '\0', sizeof (taskStart
));
214 /* parse arguments, put them in passArgs */
216 parse_args (args
, &passArgs
);
218 if (passArgs
.arg_array_len
== 0)
219 error ("You must specify a function name to run, and arguments if any");
221 status
= net_clnt_call (PROCESS_START
, xdr_arg_array
, &passArgs
,
222 xdr_TASK_START
, &taskStart
);
224 if ((status
!= RPC_SUCCESS
) || (taskStart
.status
== -1))
225 error ("Can't create process on remote target machine");
227 /* Save the name of the running function */
228 vx_running
= savestring (passArgs
.arg_array_val
[0],
229 strlen (passArgs
.arg_array_val
[0]));
231 push_target (&vx_run_ops
);
232 inferior_ptid
= pid_to_ptid (taskStart
.pid
);
234 /* We will get a trace trap after one instruction.
235 Insert breakpoints and continue. */
237 init_wait_for_inferior ();
239 /* Set up the "saved terminal modes" of the inferior
240 based on what modes we are starting it with. */
241 target_terminal_init ();
243 /* Install inferior's terminal modes. */
244 target_terminal_inferior ();
246 stop_soon
= STOP_QUIETLY
;
247 wait_for_inferior (); /* Get the task spawn event */
248 stop_soon
= NO_STOP_QUIETLY
;
250 /* insert_step_breakpoint (); FIXME, do we need this? */
251 proceed (-1, TARGET_SIGNAL_DEFAULT
, 0);
254 /* Fill ARGSTRUCT in argc/argv form with the arguments from the
255 argument string ARGSTRING. */
258 parse_args (register char *arg_string
, 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. */
298 skip_white_space (register char *p
)
300 while (*p
== ' ' || *p
== '\t')
305 /* Search for the first unquoted whitespace character in a string.
306 Returns a pointer to the character, or to the null terminator
307 if no whitespace is found. */
310 find_white_space (register char *p
)
314 while ((c
= *p
) != ' ' && c
!= '\t' && c
)
316 if (c
== '\'' || c
== '"')
318 while (*++p
!= c
&& *p
)
331 /* Poll the VxWorks target system for an event related
332 to the debugged task.
333 Returns -1 if remote wait failed, task status otherwise. */
336 net_wait (RDB_EVENT
*pEvent
)
339 enum clnt_stat status
;
341 memset ((char *) pEvent
, '\0', sizeof (RDB_EVENT
));
343 pid
= PIDGET (inferior_ptid
);
344 status
= net_clnt_call (PROCESS_WAIT
, xdr_int
, &pid
, xdr_RDB_EVENT
,
347 /* return (status == RPC_SUCCESS)? pEvent->status: -1; */
348 if (status
== RPC_SUCCESS
)
349 return ((pEvent
->status
) ? 1 : 0);
350 else if (status
== RPC_TIMEDOUT
)
356 /* Suspend the remote task.
357 Returns -1 if suspend fails on target system, 0 otherwise. */
364 enum clnt_stat status
;
368 /* don't let rdbTask suspend itself by passing a pid of 0 */
370 if ((pid
= PIDGET (inferior_ptid
)) == 0)
373 status
= net_clnt_call (VX_TASK_SUSPEND
, xdr_int
, &pid
, xdr_int
,
376 return (status
== RPC_SUCCESS
) ? quit_status
: -1;
379 /* Read a register or registers from the remote system. */
382 net_read_registers (char *reg_buf
, int len
, u_long procnum
)
386 Ptrace_return ptrace_out
;
390 memset ((char *) &ptrace_in
, '\0', sizeof (ptrace_in
));
391 memset ((char *) &ptrace_out
, '\0', sizeof (ptrace_out
));
393 /* Initialize RPC input argument structure. */
395 ptrace_in
.pid
= PIDGET (inferior_ptid
);
396 ptrace_in
.info
.ttype
= NOINFO
;
398 /* Initialize RPC return value structure. */
400 out_data
.bytes
= reg_buf
;
402 ptrace_out
.info
.more_data
= (caddr_t
) & out_data
;
404 /* Call RPC; take an error exit if appropriate. */
406 status
= net_ptrace_clnt_call (procnum
, &ptrace_in
, &ptrace_out
);
409 if (ptrace_out
.status
== -1)
411 errno
= ptrace_out
.errno_num
;
412 sprintf (message
, "reading %s registers", (procnum
== PTRACE_GETREGS
)
415 perror_with_name (message
);
419 /* Write register values to a VxWorks target. REG_BUF points to a buffer
420 containing the raw register values, LEN is the length of REG_BUF in
421 bytes, and PROCNUM is the RPC procedure number (PTRACE_SETREGS or
422 PTRACE_SETFPREGS). An error exit is taken if the RPC call fails or
423 if an error status is returned by the remote debug server. This is
424 a utility routine used by vx_write_register (). */
427 net_write_registers (char *reg_buf
, int len
, u_long procnum
)
431 Ptrace_return ptrace_out
;
435 memset ((char *) &ptrace_in
, '\0', sizeof (ptrace_in
));
436 memset ((char *) &ptrace_out
, '\0', sizeof (ptrace_out
));
438 /* Initialize RPC input argument structure. */
440 in_data
.bytes
= reg_buf
;
443 ptrace_in
.pid
= PIDGET (inferior_ptid
);
444 ptrace_in
.info
.ttype
= DATA
;
445 ptrace_in
.info
.more_data
= (caddr_t
) & in_data
;
447 /* Call RPC; take an error exit if appropriate. */
449 status
= net_ptrace_clnt_call (procnum
, &ptrace_in
, &ptrace_out
);
452 if (ptrace_out
.status
== -1)
454 errno
= ptrace_out
.errno_num
;
455 sprintf (message
, "writing %s registers", (procnum
== PTRACE_SETREGS
)
458 perror_with_name (message
);
462 /* Prepare to store registers. Since we will store all of them,
463 read out their current values now. */
466 vx_prepare_to_store (void)
468 /* Fetch all registers, if any of them are not yet fetched. */
469 deprecated_read_register_bytes (0, NULL
, REGISTER_BYTES
);
472 /* Copy LEN bytes to or from remote inferior's memory starting at MEMADDR
473 to debugger memory starting at MYADDR. WRITE is true if writing to the
474 inferior. TARGET is unused.
475 Result is the number of bytes written or read (zero if error). The
476 protocol allows us to return a negative count, indicating that we can't
477 handle the current address but can handle one N bytes further, but
478 vxworks doesn't give us that information. */
481 vx_xfer_memory (CORE_ADDR memaddr
, char *myaddr
, int len
, int write
,
482 struct mem_attrib
*attrib
, struct target_ops
*target
)
486 Ptrace_return ptrace_out
;
488 enum ptracereq request
;
491 memset ((char *) &ptrace_in
, '\0', sizeof (ptrace_in
));
492 memset ((char *) &ptrace_out
, '\0', sizeof (ptrace_out
));
494 ptrace_in
.pid
= PIDGET (inferior_ptid
); /* XXX pid unnecessary for READDATA */
495 ptrace_in
.addr
= (int) memaddr
; /* Where from */
496 ptrace_in
.data
= len
; /* How many bytes */
500 ptrace_in
.info
.ttype
= DATA
;
501 ptrace_in
.info
.more_data
= (caddr_t
) & data
;
503 data
.bytes
= (caddr_t
) myaddr
; /* Where from */
504 data
.len
= len
; /* How many bytes (again, for XDR) */
505 request
= PTRACE_WRITEDATA
;
509 ptrace_out
.info
.more_data
= (caddr_t
) & data
;
510 request
= PTRACE_READDATA
;
512 /* Loop until the entire request has been satisfied, transferring
513 at most VX_MEMXFER_MAX bytes per iteration. Break from the loop
514 if an error status is returned by the remote debug server. */
519 while (nleft
> 0 && status
== 0)
521 nxfer
= min (nleft
, VX_MEMXFER_MAX
);
523 ptrace_in
.addr
= (int) memaddr
;
524 ptrace_in
.data
= nxfer
;
525 data
.bytes
= (caddr_t
) myaddr
;
528 /* Request a block from the remote debug server; if RPC fails,
529 report an error and return to debugger command level. */
531 if (net_ptrace_clnt_call (request
, &ptrace_in
, &ptrace_out
))
534 status
= ptrace_out
.status
;
543 /* A target-side error has ocurred. Set errno to the error
544 code chosen by the target so that a later perror () will
545 say something meaningful. */
547 errno
= ptrace_out
.errno_num
;
551 /* Return the number of bytes transferred. */
553 return (len
- nleft
);
559 printf_unfiltered ("\tAttached to host `%s'", vx_host
);
560 printf_unfiltered (", which has %sfloating point", target_has_fp
? "" : "no ");
561 printf_unfiltered (".\n");
565 vx_run_files_info (void)
567 printf_unfiltered ("\tRunning %s VxWorks process %s",
568 vx_running
? "child" : "attached",
569 local_hex_string (PIDGET (inferior_ptid
)));
571 printf_unfiltered (", function `%s'", vx_running
);
572 printf_unfiltered (".\n");
576 vx_resume (ptid_t ptid
, int step
, enum target_signal siggnal
)
580 Ptrace_return ptrace_out
;
583 if (ptid_equal (ptid
, minus_one_ptid
))
584 ptid
= inferior_ptid
;
586 if (siggnal
!= 0 && siggnal
!= stop_signal
)
587 error ("Cannot send signals to VxWorks processes");
589 /* Set CONT_ADDR to the address at which we are continuing,
590 or to 1 if we are continuing from where the program stopped.
591 This conforms to traditional ptrace () usage, but at the same
592 time has special meaning for the VxWorks remote debug server.
593 If the address is not 1, the server knows that the target
594 program is jumping to a new address, which requires special
595 handling if there is a breakpoint at the new address. */
597 cont_addr
= read_register (PC_REGNUM
);
598 if (cont_addr
== stop_pc
)
601 memset ((char *) &ptrace_in
, '\0', sizeof (ptrace_in
));
602 memset ((char *) &ptrace_out
, '\0', sizeof (ptrace_out
));
604 ptrace_in
.pid
= PIDGET (ptid
);
605 ptrace_in
.addr
= cont_addr
; /* Target side insists on this, or it panics. */
608 status
= net_step ();
610 status
= net_ptrace_clnt_call (PTRACE_CONT
, &ptrace_in
, &ptrace_out
);
614 if (ptrace_out
.status
== -1)
616 errno
= ptrace_out
.errno_num
;
617 perror_with_name ("Resuming remote process");
622 vx_mourn_inferior (void)
624 pop_target (); /* Pop back to no-child state */
625 generic_mourn_inferior ();
629 static void vx_add_symbols (char *, int, CORE_ADDR
, CORE_ADDR
, CORE_ADDR
);
631 struct find_sect_args
633 CORE_ADDR text_start
;
634 CORE_ADDR data_start
;
638 static void find_sect (bfd
*, asection
*, void *);
641 find_sect (bfd
*abfd
, asection
*sect
, void *obj
)
643 struct find_sect_args
*args
= (struct find_sect_args
*) obj
;
645 if (bfd_get_section_flags (abfd
, sect
) & (SEC_CODE
& SEC_READONLY
))
646 args
->text_start
= bfd_get_section_vma (abfd
, sect
);
647 else if (bfd_get_section_flags (abfd
, sect
) & SEC_ALLOC
)
649 if (bfd_get_section_flags (abfd
, sect
) & SEC_LOAD
)
651 /* Exclude .ctor and .dtor sections which have SEC_CODE set but not
653 if (bfd_get_section_flags (abfd
, sect
) & SEC_DATA
)
654 args
->data_start
= bfd_get_section_vma (abfd
, sect
);
657 args
->bss_start
= bfd_get_section_vma (abfd
, sect
);
662 vx_add_symbols (char *name
, int from_tty
, CORE_ADDR text_addr
,
663 CORE_ADDR data_addr
, CORE_ADDR bss_addr
)
665 struct section_offsets
*offs
;
666 struct objfile
*objfile
;
667 struct find_sect_args ss
;
669 /* It might be nice to suppress the breakpoint_re_set which happens here
670 because we are going to do one again after the objfile_relocate. */
671 objfile
= symbol_file_add (name
, from_tty
, NULL
, 0, 0);
673 /* This is a (slightly cheesy) way of superceding the old symbols. A less
674 cheesy way would be to find the objfile with the same name and
676 objfile_to_front (objfile
);
678 offs
= (struct section_offsets
*) alloca (SIZEOF_SECTION_OFFSETS
);
679 memcpy (offs
, objfile
->section_offsets
, SIZEOF_SECTION_OFFSETS
);
684 bfd_map_over_sections (objfile
->obfd
, find_sect
, &ss
);
686 /* Both COFF and b.out frontends use these SECT_OFF_* values. */
687 offs
->offsets
[SECT_OFF_TEXT (objfile
)] = text_addr
- ss
.text_start
;
688 offs
->offsets
[SECT_OFF_DATA (objfile
)] = data_addr
- ss
.data_start
;
689 offs
->offsets
[SECT_OFF_BSS (objfile
)] = bss_addr
- ss
.bss_start
;
690 objfile_relocate (objfile
, offs
);
693 /* This function allows the addition of incrementally linked object files. */
696 vx_load_command (char *arg_string
, int from_tty
)
703 error ("The load command takes a file name");
705 arg_string
= tilde_expand (arg_string
);
706 make_cleanup (xfree
, arg_string
);
710 /* Refuse to load the module if a debugged task is running. Doing so
711 can have a number of unpleasant consequences to the running task. */
713 if (PIDGET (inferior_ptid
) != 0 && target_has_execution
)
715 if (query ("You may not load a module while the target task is running.\n\
716 Kill the target task? "))
719 error ("Load canceled.");
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 /* Single step the target program at the source or machine level.
736 Takes an error exit if rpc fails.
737 Returns -1 if remote single-step operation fails, else 0. */
742 enum clnt_stat status
;
744 SOURCE_STEP source_step
;
746 source_step
.taskId
= PIDGET (inferior_ptid
);
750 source_step
.startAddr
= step_range_start
;
751 source_step
.endAddr
= step_range_end
;
755 source_step
.startAddr
= 0;
756 source_step
.endAddr
= 0;
759 status
= net_clnt_call (VX_SOURCE_STEP
, xdr_SOURCE_STEP
, &source_step
,
760 xdr_int
, &step_status
);
762 if (status
== RPC_SUCCESS
)
768 /* Emulate ptrace using RPC calls to the VxWorks target system.
769 Returns nonzero (-1) if RPC status to VxWorks is bad, 0 otherwise. */
772 net_ptrace_clnt_call (enum ptracereq request
, Rptrace
*pPtraceIn
,
773 Ptrace_return
*pPtraceOut
)
775 enum clnt_stat status
;
777 status
= net_clnt_call (request
, xdr_rptrace
, pPtraceIn
, xdr_ptrace_return
,
780 if (status
!= RPC_SUCCESS
)
786 /* Query the target for the name of the file from which VxWorks was
787 booted. pBootFile is the address of a pointer to the buffer to
788 receive the file name; if the pointer pointed to by pBootFile is
789 NULL, memory for the buffer will be allocated by XDR.
790 Returns -1 if rpc failed, 0 otherwise. */
793 net_get_boot_file (char **pBootFile
)
795 enum clnt_stat status
;
797 status
= net_clnt_call (VX_BOOT_FILE_INQ
, xdr_void
, (char *) 0,
798 xdr_wrapstring
, pBootFile
);
799 return (status
== RPC_SUCCESS
) ? 0 : -1;
802 /* Fetch a list of loaded object modules from the VxWorks target
803 and store in PLOADTABLE.
804 Returns -1 if rpc failed, 0 otherwise
805 There's no way to check if the returned loadTable is correct.
806 VxWorks doesn't check it. */
809 net_get_symbols (ldtabl
*pLoadTable
)
811 enum clnt_stat status
;
813 memset ((char *) pLoadTable
, '\0', sizeof (struct ldtabl
));
815 status
= net_clnt_call (VX_STATE_INQ
, xdr_void
, 0, xdr_ldtabl
, pLoadTable
);
816 return (status
== RPC_SUCCESS
) ? 0 : -1;
819 /* Look up a symbol in the VxWorks target's symbol table.
820 Returns status of symbol read on target side (0=success, -1=fail)
821 Returns -1 and complain()s if rpc fails. */
824 vx_lookup_symbol (char *name
, /* symbol name */
827 enum clnt_stat status
;
828 SYMBOL_ADDR symbolAddr
;
831 memset ((char *) &symbolAddr
, '\0', sizeof (symbolAddr
));
833 status
= net_clnt_call (VX_SYMBOL_INQ
, xdr_wrapstring
, &name
,
834 xdr_SYMBOL_ADDR
, &symbolAddr
);
835 if (status
!= RPC_SUCCESS
)
837 complaint (&symfile_complaints
, "Lost contact with VxWorks target");
841 *pAddr
= symbolAddr
.addr
;
842 return symbolAddr
.status
;
845 /* Check to see if the VxWorks target has a floating point coprocessor.
846 Returns 1 if target has floating point processor, 0 otherwise.
847 Calls error() if rpc fails. */
850 net_check_for_fp (void)
852 enum clnt_stat status
;
853 bool_t fp
= 0; /* true if fp processor is present on target board */
855 status
= net_clnt_call (VX_FP_INQUIRE
, xdr_void
, 0, xdr_bool
, &fp
);
856 if (status
!= RPC_SUCCESS
)
862 /* Establish an RPC connection with the VxWorks target system.
863 Calls error () if unable to establish connection. */
866 net_connect (char *host
)
868 struct sockaddr_in destAddr
;
869 struct hostent
*destHost
;
872 /* Get the internet address for the given host. Allow a numeric
873 IP address or a hostname. */
875 addr
= inet_addr (host
);
878 destHost
= (struct hostent
*) gethostbyname (host
);
879 if (destHost
== NULL
)
880 /* FIXME: Probably should include hostname here in quotes.
881 For example if the user types "target vxworks vx960 " it should
882 say "Invalid host `vx960 '." not just "Invalid hostname". */
883 error ("Invalid hostname. Couldn't find remote host address.");
884 addr
= *(unsigned long *) destHost
->h_addr
;
887 memset (&destAddr
, '\0', sizeof (destAddr
));
889 destAddr
.sin_addr
.s_addr
= addr
;
890 destAddr
.sin_family
= AF_INET
;
891 destAddr
.sin_port
= 0; /* set to actual port that remote
892 ptrace is listening on. */
894 /* Create a tcp client transport on which to issue
895 calls to the remote ptrace server. */
897 ptraceSock
= RPC_ANYSOCK
;
898 pClient
= clnttcp_create (&destAddr
, RDBPROG
, RDBVERS
, &ptraceSock
, 0, 0);
899 /* FIXME, here is where we deal with different version numbers of the
904 clnt_pcreateerror ("\tnet_connect");
905 error ("Couldn't connect to remote target.");
909 /* Sleep for the specified number of milliseconds
910 * (assumed to be less than 1000).
911 * If select () is interrupted, returns immediately;
912 * takes an error exit if select () fails for some other reason.
918 struct timeval select_timeout
;
921 select_timeout
.tv_sec
= 0;
922 select_timeout
.tv_usec
= ms
* 1000;
924 status
= select (0, (fd_set
*) 0, (fd_set
*) 0, (fd_set
*) 0,
927 if (status
< 0 && errno
!= EINTR
)
928 perror_with_name ("select");
932 vx_wait (ptid_t ptid_to_wait_for
, struct target_waitstatus
*status
)
940 /* If CTRL-C is hit during this loop,
941 suspend the inferior process. */
946 quit_failed
= (net_quit () == -1);
950 /* If a net_quit () or net_wait () call has failed,
951 allow the user to break the connection with the target.
952 We can't simply error () out of this loop, since the
953 data structures representing the state of the inferior
954 are in an inconsistent state. */
956 if (quit_failed
|| net_wait (&rdbEvent
) == -1)
959 if (query ("Can't %s. Disconnect from target system? ",
960 (quit_failed
) ? "suspend remote task"
961 : "get status of remote task"))
963 target_mourn_inferior ();
964 error ("Use the \"target\" command to reconnect.");
968 terminal_inferior ();
973 pid
= rdbEvent
.taskId
;
976 sleep_ms (200); /* FIXME Don't kill the network too badly */
978 else if (pid
!= PIDGET (inferior_ptid
))
979 internal_error (__FILE__
, __LINE__
,
980 "Bad pid for debugged task: %s\n",
981 local_hex_string ((unsigned long) pid
));
985 /* The mostly likely kind. */
986 status
->kind
= TARGET_WAITKIND_STOPPED
;
988 switch (rdbEvent
.eventType
)
991 status
->kind
= TARGET_WAITKIND_EXITED
;
992 /* FIXME is it possible to distinguish between a
993 normal vs abnormal exit in VxWorks? */
994 status
->value
.integer
= 0;
998 /* Task was just started. */
999 status
->value
.sig
= TARGET_SIGNAL_TRAP
;
1003 status
->value
.sig
= TARGET_SIGNAL_TRAP
;
1004 /* XXX was it stopped by a signal? act accordingly */
1007 case EVENT_BREAK
: /* Breakpoint was hit. */
1008 status
->value
.sig
= TARGET_SIGNAL_TRAP
;
1011 case EVENT_SUSPEND
: /* Task was suspended, probably by ^C. */
1012 status
->value
.sig
= TARGET_SIGNAL_INT
;
1015 case EVENT_BUS_ERR
: /* Task made evil nasty reference. */
1016 status
->value
.sig
= TARGET_SIGNAL_BUS
;
1019 case EVENT_ZERO_DIV
: /* Division by zero */
1020 status
->value
.sig
= TARGET_SIGNAL_FPE
;
1025 status
->value
.sig
= i960_fault_to_signal (rdbEvent
.sigType
);
1027 /* Back in the old days, before enum target_signal, this code used
1028 to add NSIG to the signal number and claim that PRINT_RANDOM_SIGNAL
1029 would take care of it. But PRINT_RANDOM_SIGNAL has never been
1030 defined except on the i960, so I don't really know what we are
1031 supposed to do on other architectures. */
1032 status
->value
.sig
= TARGET_SIGNAL_UNKNOWN
;
1036 return pid_to_ptid (pid
);
1040 symbol_stub (char *arg
)
1042 symbol_file_add_main (arg
, 0);
1047 add_symbol_stub (char *arg
)
1049 struct ldfile
*pLoadFile
= (struct ldfile
*) arg
;
1051 printf_unfiltered ("\t%s: ", pLoadFile
->name
);
1052 vx_add_symbols (pLoadFile
->name
, 0, pLoadFile
->txt_addr
,
1053 pLoadFile
->data_addr
, pLoadFile
->bss_addr
);
1054 printf_unfiltered ("ok\n");
1057 /* Target command for VxWorks target systems.
1059 Used in vxgdb. Takes the name of a remote target machine
1060 running vxWorks and connects to it to initialize remote network
1064 vx_open (char *args
, int from_tty
)
1066 extern int close ();
1068 extern char *source_path
;
1069 struct ldtabl loadTable
;
1070 struct ldfile
*pLoadFile
;
1072 extern CLIENT
*pClient
;
1073 int symbols_added
= 0;
1076 error_no_arg ("target machine name");
1078 target_preopen (from_tty
);
1080 unpush_target (&vx_ops
);
1081 printf_unfiltered ("Attaching remote machine across net...\n");
1082 gdb_flush (gdb_stdout
);
1084 /* Allow the user to kill the connect attempt by typing ^C.
1085 Wait until the call to target_has_fp () completes before
1086 disallowing an immediate quit, since even if net_connect ()
1087 is successful, the remote debug server might be hung. */
1092 target_has_fp
= net_check_for_fp ();
1093 printf_filtered ("Connected to %s.\n", args
);
1097 push_target (&vx_ops
);
1099 /* Save a copy of the target host's name. */
1100 vx_host
= savestring (args
, strlen (args
));
1102 /* Find out the name of the file from which the target was booted
1103 and load its symbol table. */
1105 printf_filtered ("Looking in Unix path for all loaded modules:\n");
1107 if (!net_get_boot_file (&bootFile
))
1111 printf_filtered ("\t%s: ", bootFile
);
1112 /* This assumes that the kernel is never relocated. Hope that is an
1113 accurate assumption. */
1117 "Error while reading symbols from boot file:\n",
1119 puts_filtered ("ok\n");
1122 printf_unfiltered ("VxWorks kernel symbols not loaded.\n");
1125 error ("Can't retrieve boot file name from target machine.");
1127 clnt_freeres (pClient
, xdr_wrapstring
, &bootFile
);
1129 if (net_get_symbols (&loadTable
) != 0)
1130 error ("Can't read loaded modules from target machine");
1133 while (++i
< loadTable
.tbl_size
)
1135 QUIT
; /* FIXME, avoids clnt_freeres below: mem leak */
1136 pLoadFile
= &loadTable
.tbl_ent
[i
];
1140 struct cleanup
*old_chain
;
1141 char *fullname
= NULL
;
1143 desc
= openp (source_path
, 0, pLoadFile
->name
, O_RDONLY
, 0, &fullname
);
1145 perror_with_name (pLoadFile
->name
);
1146 old_chain
= make_cleanup (close
, desc
);
1147 add_file_at_addr (fullname
, desc
, pLoadFile
->txt_addr
, pLoadFile
->data_addr
,
1148 pLoadFile
->bss_addr
);
1149 do_cleanups (old_chain
);
1152 /* FIXME: Is there something better to search than the PATH? (probably
1153 not the source path, since source might be in different directories
1156 if (catch_errors (add_symbol_stub
, (char *) pLoadFile
, (char *) 0,
1161 printf_filtered ("Done.\n");
1163 clnt_freeres (pClient
, xdr_ldtabl
, &loadTable
);
1165 /* Getting new symbols may change our opinion about what is
1168 reinit_frame_cache ();
1171 /* Takes a task started up outside of gdb and ``attaches'' to it.
1172 This stops it cold in its tracks and allows us to start tracing it. */
1175 vx_attach (char *args
, int from_tty
)
1180 Ptrace_return ptrace_out
;
1184 error_no_arg ("process-id to attach");
1186 pid
= strtoul (args
, &cptr
, 0);
1187 if ((cptr
== args
) || (*cptr
!= '\0'))
1188 error ("Invalid process-id -- give a single number in decimal or 0xhex");
1191 printf_unfiltered ("Attaching pid %s.\n",
1192 local_hex_string ((unsigned long) pid
));
1194 memset ((char *) &ptrace_in
, '\0', sizeof (ptrace_in
));
1195 memset ((char *) &ptrace_out
, '\0', sizeof (ptrace_out
));
1196 ptrace_in
.pid
= pid
;
1198 status
= net_ptrace_clnt_call (PTRACE_ATTACH
, &ptrace_in
, &ptrace_out
);
1201 if (ptrace_out
.status
== -1)
1203 errno
= ptrace_out
.errno_num
;
1204 perror_with_name ("Attaching remote process");
1209 inferior_ptid
= pid_to_ptid (pid
);
1210 push_target (&vx_run_ops
);
1217 /* detach_command --
1218 takes a program previously attached to and detaches it.
1219 The program resumes execution and will no longer stop
1220 on signals, etc. We better not have left any breakpoints
1221 in the program or it'll die when it hits one. For this
1222 to work, it may be necessary for the process to have been
1223 previously attached. It *might* work if the program was
1224 started via the normal ptrace (PTRACE_TRACEME). */
1227 vx_detach (char *args
, int from_tty
)
1230 Ptrace_return ptrace_out
;
1235 error ("Argument given to VxWorks \"detach\".");
1238 printf_unfiltered ("Detaching pid %s.\n",
1240 (unsigned long) PIDGET (inferior_ptid
)));
1242 if (args
) /* FIXME, should be possible to leave suspended */
1243 signal
= atoi (args
);
1245 memset ((char *) &ptrace_in
, '\0', sizeof (ptrace_in
));
1246 memset ((char *) &ptrace_out
, '\0', sizeof (ptrace_out
));
1247 ptrace_in
.pid
= PIDGET (inferior_ptid
);
1249 status
= net_ptrace_clnt_call (PTRACE_DETACH
, &ptrace_in
, &ptrace_out
);
1252 if (ptrace_out
.status
== -1)
1254 errno
= ptrace_out
.errno_num
;
1255 perror_with_name ("Detaching VxWorks process");
1258 inferior_ptid
= null_ptid
;
1259 pop_target (); /* go back to non-executing VxWorks connection */
1262 /* vx_kill -- takes a running task and wipes it out. */
1268 Ptrace_return ptrace_out
;
1271 printf_unfiltered ("Killing pid %s.\n", local_hex_string ((unsigned long) PIDGET (inferior_ptid
)));
1273 memset ((char *) &ptrace_in
, '\0', sizeof (ptrace_in
));
1274 memset ((char *) &ptrace_out
, '\0', sizeof (ptrace_out
));
1275 ptrace_in
.pid
= PIDGET (inferior_ptid
);
1277 status
= net_ptrace_clnt_call (PTRACE_KILL
, &ptrace_in
, &ptrace_out
);
1280 else if (ptrace_out
.status
== -1)
1282 errno
= ptrace_out
.errno_num
;
1283 perror_with_name ("Killing VxWorks process");
1286 /* If it gives good status, the process is *gone*, no events remain.
1287 If the kill failed, assume the process is gone anyhow. */
1288 inferior_ptid
= null_ptid
;
1289 pop_target (); /* go back to non-executing VxWorks connection */
1292 /* Clean up from the VxWorks process target as it goes away. */
1295 vx_proc_close (int quitting
)
1297 inferior_ptid
= null_ptid
; /* No longer have a process. */
1303 /* Make an RPC call to the VxWorks target.
1304 Returns RPC status. */
1306 static enum clnt_stat
1307 net_clnt_call (enum ptracereq procNum
, xdrproc_t inProc
, char *in
,
1308 xdrproc_t outProc
, char *out
)
1310 enum clnt_stat status
;
1312 status
= clnt_call (pClient
, procNum
, inProc
, in
, outProc
, out
, rpcTimeout
);
1314 if (status
!= RPC_SUCCESS
)
1315 clnt_perrno (status
);
1320 /* Clean up before losing control. */
1323 vx_close (int quitting
)
1326 clnt_destroy (pClient
); /* The net connection */
1330 xfree (vx_host
); /* The hostname */
1334 /* A vxprocess target should be started via "run" not "target". */
1337 vx_proc_open (char *name
, int from_tty
)
1339 error ("Use the \"run\" command to start a VxWorks process.");
1345 vx_ops
.to_shortname
= "vxworks";
1346 vx_ops
.to_longname
= "VxWorks target memory via RPC over TCP/IP";
1347 vx_ops
.to_doc
= "Use VxWorks target memory. \n\
1348 Specify the name of the machine to connect to.";
1349 vx_ops
.to_open
= vx_open
;
1350 vx_ops
.to_close
= vx_close
;
1351 vx_ops
.to_attach
= vx_attach
;
1352 vx_ops
.to_xfer_memory
= vx_xfer_memory
;
1353 vx_ops
.to_files_info
= vx_files_info
;
1354 vx_ops
.to_load
= vx_load_command
;
1355 vx_ops
.to_lookup_symbol
= vx_lookup_symbol
;
1356 vx_ops
.to_create_inferior
= vx_create_inferior
;
1357 vx_ops
.to_stratum
= core_stratum
;
1358 vx_ops
.to_has_all_memory
= 1;
1359 vx_ops
.to_has_memory
= 1;
1360 vx_ops
.to_magic
= OPS_MAGIC
; /* Always the last thing */
1364 init_vx_run_ops (void)
1366 vx_run_ops
.to_shortname
= "vxprocess";
1367 vx_run_ops
.to_longname
= "VxWorks process";
1368 vx_run_ops
.to_doc
= "VxWorks process; started by the \"run\" command.";
1369 vx_run_ops
.to_open
= vx_proc_open
;
1370 vx_run_ops
.to_close
= vx_proc_close
;
1371 vx_run_ops
.to_detach
= vx_detach
;
1372 vx_run_ops
.to_resume
= vx_resume
;
1373 vx_run_ops
.to_wait
= vx_wait
;
1374 vx_run_ops
.to_fetch_registers
= vx_read_register
;
1375 vx_run_ops
.to_store_registers
= vx_write_register
;
1376 vx_run_ops
.to_prepare_to_store
= vx_prepare_to_store
;
1377 vx_run_ops
.to_xfer_memory
= vx_xfer_memory
;
1378 vx_run_ops
.to_files_info
= vx_run_files_info
;
1379 vx_run_ops
.to_insert_breakpoint
= vx_insert_breakpoint
;
1380 vx_run_ops
.to_remove_breakpoint
= vx_remove_breakpoint
;
1381 vx_run_ops
.to_kill
= vx_kill
;
1382 vx_run_ops
.to_load
= vx_load_command
;
1383 vx_run_ops
.to_lookup_symbol
= vx_lookup_symbol
;
1384 vx_run_ops
.to_mourn_inferior
= vx_mourn_inferior
;
1385 vx_run_ops
.to_stratum
= process_stratum
;
1386 vx_run_ops
.to_has_memory
= 1;
1387 vx_run_ops
.to_has_stack
= 1;
1388 vx_run_ops
.to_has_registers
= 1;
1389 vx_run_ops
.to_has_execution
= 1;
1390 vx_run_ops
.to_magic
= OPS_MAGIC
;
1394 _initialize_vx (void)
1397 add_target (&vx_ops
);
1399 add_target (&vx_run_ops
);
1402 (add_set_cmd ("vxworks-timeout", class_support
, var_uinteger
,
1403 (char *) &rpcTimeout
.tv_sec
,
1404 "Set seconds to wait for rpc calls to return.\n\
1405 Set the number of seconds to wait for rpc calls to return.", &setlist
),
This page took 0.057766 seconds and 4 git commands to generate.