1 /* Memory-access and commands for remote VxWorks processes, for GDB.
2 Copyright 1990, 1991, 1992 Free Software Foundation, Inc.
3 Contributed by Wind River Systems and Cygnus Support.
5 This file is part of GDB.
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 2 of the License, or
10 (at your option) any later version.
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with this program; if not, write to the Free Software
19 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */
29 #include "symfile.h" /* for struct complaint */
35 #include <sys/types.h>
37 #include <sys/socket.h>
38 #define malloc bogon_malloc /* Sun claims "char *malloc()" not void * */
39 #define free bogon_free /* Sun claims "int free()" not void */
40 #define realloc bogon_realloc /* Sun claims "char *realloc()", not void * */
45 #include <sys/time.h> /* UTek's <rpc/rpc.h> doesn't #incl this */
47 #include "vx-share/ptrace.h"
48 #include "vx-share/xdr_ptrace.h"
49 #include "vx-share/xdr_ld.h"
50 #include "vx-share/xdr_rdb.h"
51 #include "vx-share/dbgRpcLib.h"
52 #include "vx-share/reg.h"
56 extern void symbol_file_command ();
57 extern int stop_soon_quietly
; /* for wait_for_inferior */
59 static int net_ptrace_clnt_call (); /* Forward decl */
60 static enum clnt_stat
net_clnt_call (); /* Forward decl */
61 extern struct target_ops vx_ops
, vx_run_ops
; /* Forward declaration */
63 /* Saved name of target host and called function for "info files".
67 static char *vx_running
; /* Called function */
69 /* Nonzero means target that is being debugged remotely has a floating
72 static int target_has_fp
;
74 /* Default error message when the network is forking up. */
76 static const char rpcerr
[] = "network target debugging: rpc error";
78 CLIENT
*pClient
; /* client used in net debugging */
79 static int ptraceSock
= RPC_ANYSOCK
;
81 enum clnt_stat
net_clnt_call();
82 static void parse_args ();
84 static struct timeval rpcTimeout
= { 10, 0 };
86 static char *skip_white_space ();
87 static char *find_white_space ();
89 /* Tell the VxWorks target system to download a file.
90 The load addresses of the text, data, and bss segments are
91 stored in *pTextAddr, *pDataAddr, and *pBssAddr (respectively).
92 Returns 0 for success, -1 for failure. */
95 net_load (filename
, pTextAddr
, pDataAddr
, pBssAddr
)
101 enum clnt_stat status
;
102 struct ldfile ldstruct
;
103 struct timeval load_timeout
;
105 bzero ((char *) &ldstruct
, sizeof (ldstruct
));
107 /* We invoke clnt_call () here directly, instead of through
108 net_clnt_call (), because we need to set a large timeout value.
109 The load on the target side can take quite a while, easily
110 more than 10 seconds. The user can kill this call by typing
111 CTRL-C if there really is a problem with the load.
113 Do not change the tv_sec value without checking -- select() imposes
114 a limit of 10**8 on it for no good reason that I can see... */
116 load_timeout
.tv_sec
= 99999999; /* A large number, effectively inf. */
117 load_timeout
.tv_usec
= 0;
119 status
= clnt_call (pClient
, VX_LOAD
, xdr_wrapstring
, &filename
, xdr_ldfile
,
120 &ldstruct
, load_timeout
);
122 if (status
== RPC_SUCCESS
)
124 if (*ldstruct
.name
== 0) /* load failed on VxWorks side */
126 *pTextAddr
= ldstruct
.txt_addr
;
127 *pDataAddr
= ldstruct
.data_addr
;
128 *pBssAddr
= ldstruct
.bss_addr
;
135 /* returns 0 if successful, errno if RPC failed or VxWorks complains. */
138 net_break (addr
, procnum
)
142 enum clnt_stat status
;
144 Rptrace ptrace_in
; /* XXX This is stupid. It doesn't need to be a ptrace
145 structure. How about something smaller? */
147 bzero ((char *) &ptrace_in
, sizeof (ptrace_in
));
150 ptrace_in
.addr
= addr
;
151 ptrace_in
.pid
= inferior_pid
;
153 status
= net_clnt_call (procnum
, xdr_rptrace
, &ptrace_in
, xdr_int
,
156 if (status
!= RPC_SUCCESS
)
159 if (break_status
== -1)
161 return break_status
; /* probably (FIXME) zero */
164 /* returns 0 if successful, errno otherwise */
167 vx_insert_breakpoint (addr
)
170 return net_break (addr
, VX_BREAK_ADD
);
173 /* returns 0 if successful, errno otherwise */
176 vx_remove_breakpoint (addr
)
179 return net_break (addr
, VX_BREAK_DELETE
);
182 /* Start an inferior process and sets inferior_pid to its pid.
183 EXEC_FILE is the file to run.
184 ALLARGS is a string containing the arguments to the program.
185 ENV is the environment vector to pass.
186 Returns process id. Errors reported with error().
187 On VxWorks, we ignore exec_file. */
190 vx_create_inferior (exec_file
, args
, env
)
195 enum clnt_stat status
;
197 TASK_START taskStart
;
199 bzero ((char *) &passArgs
, sizeof (passArgs
));
200 bzero ((char *) &taskStart
, sizeof (taskStart
));
202 /* parse arguments, put them in passArgs */
204 parse_args (args
, &passArgs
);
206 if (passArgs
.arg_array_len
== 0)
207 error ("You must specify a function name to run, and arguments if any");
209 status
= net_clnt_call (PROCESS_START
, xdr_arg_array
, &passArgs
,
210 xdr_TASK_START
, &taskStart
);
212 if ((status
!= RPC_SUCCESS
) || (taskStart
.status
== -1))
213 error ("Can't create process on remote target machine");
215 /* Save the name of the running function */
216 vx_running
= savestring (passArgs
.arg_array_val
[0],
217 strlen (passArgs
.arg_array_val
[0]));
219 #ifdef CREATE_INFERIOR_HOOK
220 CREATE_INFERIOR_HOOK (pid
);
223 push_target (&vx_run_ops
);
224 inferior_pid
= taskStart
.pid
;
226 /* We will get a trace trap after one instruction.
227 Insert breakpoints and continue. */
229 init_wait_for_inferior ();
231 /* Set up the "saved terminal modes" of the inferior
232 based on what modes we are starting it with. */
233 target_terminal_init ();
235 /* Install inferior's terminal modes. */
236 target_terminal_inferior ();
238 stop_soon_quietly
= 1;
239 wait_for_inferior (); /* Get the task spawn event */
240 stop_soon_quietly
= 0;
242 /* insert_step_breakpoint (); FIXME, do we need this? */
246 /* Fill ARGSTRUCT in argc/argv form with the arguments from the
247 argument string ARGSTRING. */
250 parse_args (arg_string
, arg_struct
)
251 register char *arg_string
;
252 arg_array
*arg_struct
;
254 register int arg_count
= 0; /* number of arguments */
255 register int arg_index
= 0;
258 bzero ((char *) arg_struct
, sizeof (arg_array
));
260 /* first count how many arguments there are */
265 if (*(p0
= skip_white_space (p0
)) == '\0')
267 p0
= find_white_space (p0
);
271 arg_struct
->arg_array_len
= arg_count
;
272 arg_struct
->arg_array_val
= (char **) xmalloc ((arg_count
+ 1)
275 /* now copy argument strings into arg_struct. */
277 while (*(arg_string
= skip_white_space (arg_string
)))
279 p0
= find_white_space (arg_string
);
280 arg_struct
->arg_array_val
[arg_index
++] = savestring (arg_string
,
285 arg_struct
->arg_array_val
[arg_count
] = NULL
;
288 /* Advance a string pointer across whitespace and return a pointer
289 to the first non-white character. */
295 while (*p
== ' ' || *p
== '\t')
300 /* Search for the first unquoted whitespace character in a string.
301 Returns a pointer to the character, or to the null terminator
302 if no whitespace is found. */
310 while ((c
= *p
) != ' ' && c
!= '\t' && c
)
312 if (c
== '\'' || c
== '"')
314 while (*++p
!= c
&& *p
)
327 /* Poll the VxWorks target system for an event related
328 to the debugged task.
329 Returns -1 if remote wait failed, task status otherwise. */
336 enum clnt_stat status
;
338 bzero ((char *) pEvent
, sizeof (RDB_EVENT
));
341 status
= net_clnt_call (PROCESS_WAIT
, xdr_int
, &pid
, xdr_RDB_EVENT
, pEvent
);
343 return (status
== RPC_SUCCESS
)? pEvent
->status
: -1;
346 /* Suspend the remote task.
347 Returns -1 if suspend fails on target system, 0 otherwise. */
354 enum clnt_stat status
;
358 /* don't let rdbTask suspend itself by passing a pid of 0 */
360 if ((pid
= inferior_pid
) == 0)
363 status
= net_clnt_call (VX_TASK_SUSPEND
, xdr_int
, &pid
, xdr_int
,
366 return (status
== RPC_SUCCESS
)? quit_status
: -1;
369 /* Read a register or registers from the remote system. */
372 vx_read_register (regno
)
377 Ptrace_return ptrace_out
;
380 extern char registers
[];
382 bzero ((char *) &ptrace_in
, sizeof (ptrace_in
));
383 bzero ((char *) &ptrace_out
, sizeof (ptrace_out
));
385 /* FIXME, eventually only get the ones we need. */
386 registers_fetched ();
388 ptrace_in
.pid
= inferior_pid
;
389 ptrace_out
.info
.more_data
= (caddr_t
) &out_data
;
391 out_data
.len
= 18 * REGISTER_RAW_SIZE (0); /* FIXME 68k hack */
393 out_data
.len
= (16 + 16 + 3) * REGISTER_RAW_SIZE (0);
395 out_data
.bytes
= (caddr_t
) registers
;
397 status
= net_ptrace_clnt_call (PTRACE_GETREGS
, &ptrace_in
, &ptrace_out
);
400 if (ptrace_out
.status
== -1)
402 errno
= ptrace_out
.errno
;
403 perror_with_name ("net_ptrace_clnt_call(PTRACE_GETREGS)");
409 /* If the target has floating point registers, fetch them.
410 Otherwise, zero the floating point register values in
411 registers[] for good measure, even though we might not
413 /* @@ Can't use this -- the rdb library for the 960 target
414 doesn't support setting or retrieving FP regs. KR */
416 struct fp_status inferior_fp_registers
;
420 ptrace_in
.pid
= inferior_pid
;
421 ptrace_out
.info
.more_data
= (caddr_t
) &inferior_fp_registers
;
422 status
= net_ptrace_clnt_call (PTRACE_GETFPREGS
,
423 &ptrace_in
, &ptrace_out
);
426 if (ptrace_out
.status
== -1)
428 errno
= ptrace_out
.errno
;
429 perror_with_name ("net_ptrace_clnt_call(PTRACE_GETFPREGS)");
432 bcopy (&inferior_fp_registers
, ®isters
[REGISTER_BYTE (FP0_REGNUM
)],
433 REGISTER_RAW_SIZE (FP0_REGNUM
) * 4);
437 bzero ((char *) ®isters
[REGISTER_BYTE (FP0_REGNUM
)],
438 REGISTER_RAW_SIZE (FP0_REGNUM
) * 4);
442 #else /* not 960, thus must be 68000: FIXME! */
446 ptrace_in
.pid
= inferior_pid
;
447 ptrace_out
.info
.more_data
= (caddr_t
) &out_data
;
448 out_data
.len
= 8 * REGISTER_RAW_SIZE (FP0_REGNUM
) /* FIXME */
449 + (3 * sizeof (REGISTER_TYPE
));
450 out_data
.bytes
= (caddr_t
) ®isters
[REGISTER_BYTE (FP0_REGNUM
)];
452 status
= net_ptrace_clnt_call (PTRACE_GETFPREGS
, &ptrace_in
, &ptrace_out
);
455 if (ptrace_out
.status
== -1)
457 errno
= ptrace_out
.errno
;
458 perror_with_name ("net_ptrace_clnt_call(PTRACE_GETFPREGS)");
463 bzero (®isters
[REGISTER_BYTE (FP0_REGNUM
)],
464 8 * REGISTER_RAW_SIZE (FP0_REGNUM
));
465 bzero (®isters
[REGISTER_BYTE (FPC_REGNUM
)],
466 3 * sizeof (REGISTER_TYPE
));
468 #endif /* various architectures */
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
);
482 /* Store our register values back into the inferior.
483 If REGNO is -1, do this for all registers.
484 Otherwise, REGNO specifies which register (so we can save time). */
485 /* FIXME, look at REGNO to save time here */
488 vx_write_register (regno
)
493 extern char registers
[];
496 Ptrace_return ptrace_out
;
498 bzero ((char *) &ptrace_in
, sizeof (ptrace_in
));
499 bzero ((char *) &ptrace_out
, sizeof (ptrace_out
));
501 ptrace_in
.pid
= inferior_pid
;
502 ptrace_in
.info
.ttype
= DATA
;
503 ptrace_in
.info
.more_data
= (caddr_t
) &in_data
;
505 in_data
.bytes
= registers
;
509 in_data
.len
= (16 + 16 + 3) * sizeof (REGISTER_TYPE
);
511 #else /* not 960 -- assume 68k -- FIXME */
513 in_data
.len
= 18 * sizeof (REGISTER_TYPE
);
515 #endif /* Different register sets */
517 /* XXX change second param to be a proc number */
518 status
= net_ptrace_clnt_call (PTRACE_SETREGS
, &ptrace_in
, &ptrace_out
);
521 if (ptrace_out
.status
== -1)
523 errno
= ptrace_out
.errno
;
524 perror_with_name ("net_ptrace_clnt_call(PTRACE_SETREGS)");
527 /* Store floating point registers if the target has them. */
531 ptrace_in
.pid
= inferior_pid
;
532 ptrace_in
.info
.ttype
= DATA
;
533 ptrace_in
.info
.more_data
= (caddr_t
) &in_data
;
537 #if 0 /* @@ Not supported by target. */
538 in_data
.bytes
= ®isters
[REGISTER_BYTE (FP0_REGNUM
)];
539 in_data
.len
= 4 * REGISTER_RAW_SIZE (FP0_REGNUM
);
541 #else /* not 960 -- assume 68k -- FIXME */
543 in_data
.bytes
= ®isters
[REGISTER_BYTE (FP0_REGNUM
)];
544 in_data
.len
= (8 * REGISTER_RAW_SIZE (FP0_REGNUM
)
545 + (3 * sizeof (REGISTER_TYPE
)));
547 #endif /* Different register sets */
549 status
= net_ptrace_clnt_call (PTRACE_SETFPREGS
, &ptrace_in
, &ptrace_out
);
552 if (ptrace_out
.status
== -1)
554 errno
= ptrace_out
.errno
;
555 perror_with_name ("net_ptrace_clnt_call(PTRACE_SETFPREGS)");
560 /* Copy LEN bytes to or from remote inferior's memory starting at MEMADDR
561 to debugger memory starting at MYADDR. WRITE is true if writing to the
563 Result is the number of bytes written or read (zero if error). The
564 protocol allows us to return a negative count, indicating that we can't
565 handle the current address but can handle one N bytes further, but
566 vxworks doesn't give us that information. */
569 vx_xfer_memory (memaddr
, myaddr
, len
, write
, target
)
574 struct target_ops
*target
; /* ignored */
578 Ptrace_return ptrace_out
;
581 bzero ((char *) &ptrace_in
, sizeof (ptrace_in
));
582 bzero ((char *) &ptrace_out
, sizeof (ptrace_out
));
584 ptrace_in
.pid
= inferior_pid
; /* XXX pid unnecessary for READDATA */
585 ptrace_in
.addr
= (int) memaddr
; /* Where from */
586 ptrace_in
.data
= len
; /* How many bytes */
590 ptrace_in
.info
.ttype
= DATA
;
591 ptrace_in
.info
.more_data
= (caddr_t
) &data
;
593 data
.bytes
= (caddr_t
) myaddr
; /* Where from */
594 data
.len
= len
; /* How many bytes (again, for XDR) */
596 /* XXX change second param to be a proc number */
597 status
= net_ptrace_clnt_call (PTRACE_WRITEDATA
, &ptrace_in
, &ptrace_out
);
601 ptrace_out
.info
.more_data
= (caddr_t
) &data
;
602 data
.bytes
= myaddr
; /* Where to */
603 data
.len
= len
; /* How many (again, for XDR) */
605 /* XXX change second param to be a proc number */
606 status
= net_ptrace_clnt_call (PTRACE_READDATA
, &ptrace_in
, &ptrace_out
);
611 if (ptrace_out
.status
== -1)
613 return 0; /* No bytes moved */
615 return len
; /* Moved *all* the bytes */
621 printf ("\tAttached to host `%s'", vx_host
);
622 printf (", which has %sfloating point", target_has_fp
? "": "no ");
629 printf ("\tRunning %s VxWorks process %s",
630 vx_running
? "child": "attached",
631 local_hex_string(inferior_pid
));
633 printf (", function `%s'", vx_running
);
638 vx_resume (step
, siggnal
)
644 Ptrace_return ptrace_out
;
646 if (siggnal
!= 0 && siggnal
!= stop_signal
)
647 error ("Cannot send signals to VxWorks processes");
649 bzero ((char *) &ptrace_in
, sizeof (ptrace_in
));
650 bzero ((char *) &ptrace_out
, sizeof (ptrace_out
));
652 ptrace_in
.pid
= inferior_pid
;
653 ptrace_in
.addr
= 1; /* Target side insists on this, or it panics. */
655 /* XXX change second param to be a proc number */
656 status
= net_ptrace_clnt_call (step
? PTRACE_SINGLESTEP
: PTRACE_CONT
,
657 &ptrace_in
, &ptrace_out
);
660 if (ptrace_out
.status
== -1)
662 errno
= ptrace_out
.errno
;
663 perror_with_name ("Resuming remote process");
670 pop_target (); /* Pop back to no-child state */
671 generic_mourn_inferior ();
675 /* This function allows the addition of incrementally linked object files. */
678 vx_load_command (arg_string
, from_tty
)
687 error ("The load command takes a file name");
689 arg_string
= tilde_expand (arg_string
);
690 make_cleanup (free
, arg_string
);
696 if (net_load (arg_string
, &text_addr
, &data_addr
, &bss_addr
) == -1)
697 error ("Load failed on target machine");
700 /* FIXME, for now we ignore data_addr and bss_addr. */
701 symbol_file_add (arg_string
, from_tty
, text_addr
, 0, 0, 0);
704 #ifdef FIXME /* Not ready for prime time */
705 /* Single step the target program at the source or machine level.
706 Takes an error exit if rpc fails.
707 Returns -1 if remote single-step operation fails, else 0. */
712 enum clnt_stat status
;
714 SOURCE_STEP source_step
;
716 source_step
.taskId
= inferior_pid
;
720 source_step
.startAddr
= step_range_start
;
721 source_step
.endAddr
= step_range_end
;
725 source_step
.startAddr
= 0;
726 source_step
.endAddr
= 0;
729 status
= net_clnt_call (VX_SOURCE_STEP
, xdr_SOURCE_STEP
, &source_step
,
730 xdr_int
, &step_status
);
732 if (status
== RPC_SUCCESS
)
739 /* Emulate ptrace using RPC calls to the VxWorks target system.
740 Returns nonzero (-1) if RPC status to VxWorks is bad, 0 otherwise. */
743 net_ptrace_clnt_call (request
, pPtraceIn
, pPtraceOut
)
744 enum ptracereq request
;
746 Ptrace_return
*pPtraceOut
;
748 enum clnt_stat status
;
750 status
= net_clnt_call (request
, xdr_rptrace
, pPtraceIn
, xdr_ptrace_return
,
753 if (status
!= RPC_SUCCESS
)
759 /* Query the target for the name of the file from which VxWorks was
760 booted. pBootFile is the address of a pointer to the buffer to
761 receive the file name; if the pointer pointed to by pBootFile is
762 NULL, memory for the buffer will be allocated by XDR.
763 Returns -1 if rpc failed, 0 otherwise. */
766 net_get_boot_file (pBootFile
)
769 enum clnt_stat status
;
771 status
= net_clnt_call (VX_BOOT_FILE_INQ
, xdr_void
, (char *) 0,
772 xdr_wrapstring
, pBootFile
);
773 return (status
== RPC_SUCCESS
) ? 0 : -1;
776 /* Fetch a list of loaded object modules from the VxWorks target.
777 Returns -1 if rpc failed, 0 otherwise
778 There's no way to check if the returned loadTable is correct.
779 VxWorks doesn't check it. */
782 net_get_symbols (pLoadTable
)
783 ldtabl
*pLoadTable
; /* return pointer to ldtabl here */
785 enum clnt_stat status
;
787 bzero ((char *) pLoadTable
, sizeof (struct ldtabl
));
789 status
= net_clnt_call (VX_STATE_INQ
, xdr_void
, 0, xdr_ldtabl
, pLoadTable
);
790 return (status
== RPC_SUCCESS
) ? 0 : -1;
793 /* Look up a symbol in the VxWorks target's symbol table.
794 Returns status of symbol read on target side (0=success, -1=fail)
795 Returns -1 and complain()s if rpc fails. */
797 struct complaint cant_contact_target
=
798 {"Lost contact with VxWorks target", 0, 0};
801 vx_lookup_symbol (name
, pAddr
)
802 char *name
; /* symbol name */
805 enum clnt_stat status
;
806 SYMBOL_ADDR symbolAddr
;
809 bzero ((char *) &symbolAddr
, sizeof (symbolAddr
));
811 status
= net_clnt_call (VX_SYMBOL_INQ
, xdr_wrapstring
, &name
,
812 xdr_SYMBOL_ADDR
, &symbolAddr
);
813 if (status
!= RPC_SUCCESS
) {
814 complain (&cant_contact_target
, 0);
818 *pAddr
= symbolAddr
.addr
;
819 return symbolAddr
.status
;
822 /* Check to see if the VxWorks target has a floating point coprocessor.
823 Returns 1 if target has floating point processor, 0 otherwise.
824 Calls error() if rpc fails. */
829 enum clnt_stat status
;
830 bool_t fp
= 0; /* true if fp processor is present on target board */
832 status
= net_clnt_call (VX_FP_INQUIRE
, xdr_void
, 0, xdr_bool
, &fp
);
833 if (status
!= RPC_SUCCESS
)
839 /* Establish an RPC connection with the VxWorks target system.
840 Calls error () if unable to establish connection. */
846 struct sockaddr_in destAddr
;
847 struct hostent
*destHost
;
849 /* get the internet address for the given host */
851 if ((destHost
= (struct hostent
*) gethostbyname (host
)) == NULL
)
852 error ("Invalid hostname. Couldn't find remote host address.");
854 bzero (&destAddr
, sizeof (destAddr
));
856 destAddr
.sin_addr
.s_addr
= * (u_long
*) destHost
->h_addr
;
857 destAddr
.sin_family
= AF_INET
;
858 destAddr
.sin_port
= 0; /* set to actual port that remote
859 ptrace is listening on. */
861 /* Create a tcp client transport on which to issue
862 calls to the remote ptrace server. */
864 ptraceSock
= RPC_ANYSOCK
;
865 pClient
= clnttcp_create (&destAddr
, RDBPROG
, RDBVERS
, &ptraceSock
, 0, 0);
866 /* FIXME, here is where we deal with different version numbers of the proto */
870 clnt_pcreateerror ("\tnet_connect");
871 error ("Couldn't connect to remote target.");
875 /* Sleep for the specified number of milliseconds
876 * (assumed to be less than 1000).
877 * If select () is interrupted, returns immediately;
878 * takes an error exit if select () fails for some other reason.
885 struct timeval select_timeout
;
888 select_timeout
.tv_sec
= 0;
889 select_timeout
.tv_usec
= ms
* 1000;
891 status
= select (0, (fd_set
*) 0, (fd_set
*) 0, (fd_set
*) 0, &select_timeout
);
893 if (status
< 0 && errno
!= EINTR
)
894 perror_with_name ("select");
897 /* Wait for control to return from inferior to debugger.
898 If inferior gets a signal, we may decide to start it up again
899 instead of returning. That is why there is a loop in this function.
900 When this function actually returns it means the inferior
901 should be left stopped and GDB should read more commands. */
903 /* For network debugging with VxWorks.
904 * VxWorks knows when tasks hit breakpoints, receive signals, exit, etc,
905 * so vx_wait() receives this information directly from
906 * VxWorks instead of trying to figure out what happenned via a wait() call.
920 /* If CTRL-C is hit during this loop,
921 suspend the inferior process. */
926 quit_failed
= (net_quit () == -1);
930 /* If a net_quit () or net_wait () call has failed,
931 allow the user to break the connection with the target.
932 We can't simply error () out of this loop, since the
933 data structures representing the state of the inferior
934 are in an inconsistent state. */
936 if (quit_failed
|| net_wait (&rdbEvent
) == -1)
939 if (query ("Can't %s. Disconnect from target system? ",
940 (quit_failed
) ? "suspend remote task"
941 : "get status of remote task"))
943 target_mourn_inferior();
944 error ("Use the \"target\" command to reconnect.");
948 terminal_inferior ();
953 pid
= rdbEvent
.taskId
;
956 sleep_ms (200); /* FIXME Don't kill the network too badly */
958 else if (pid
!= inferior_pid
)
959 fatal ("Bad pid for debugged task: %s\n", local_hex_string(pid
));
962 /* FIXME, eventually do more then SIGTRAP on everything... */
963 switch (rdbEvent
.eventType
)
967 /* FIXME is it possible to distinguish between a
968 XXX normal vs abnormal exit in VxWorks? */
971 case EVENT_START
: /* Task was just started. */
972 WSETSTOP (w
, SIGTRAP
);
976 WSETSTOP (w
, SIGTRAP
);
977 /* XXX was it stopped by a signal? act accordingly */
980 case EVENT_BREAK
: /* Breakpoint was hit. */
981 WSETSTOP (w
, SIGTRAP
);
984 case EVENT_SUSPEND
: /* Task was suspended, probably by ^C. */
985 WSETSTOP (w
, SIGINT
);
988 case EVENT_BUS_ERR
: /* Task made evil nasty reference. */
989 WSETSTOP (w
, SIGBUS
);
992 case EVENT_ZERO_DIV
: /* Division by zero */
993 WSETSTOP (w
, SIGFPE
); /* Like Unix, call it a float exception. */
997 /* The target is not running Unix, and its
998 faults/traces do not map nicely into Unix signals.
999 Make sure they do not get confused with Unix signals
1000 by numbering them with values higher than the highest
1001 legal Unix signal. code in the arch-dependent PRINT_RANDOM_SIGNAL
1002 routine will interpret the value for wait_for_inferior. */
1003 WSETSTOP (w
, rdbEvent
.sigType
+ NSIG
);
1006 *status
= *(int *)&w
; /* Grumble union wait crap Grumble */
1014 symbol_file_command (arg
, 0);
1019 add_symbol_stub (arg
)
1022 struct ldfile
*pLoadFile
= (struct ldfile
*)arg
;
1024 printf("\t%s: ", pLoadFile
->name
);
1025 symbol_file_add (pLoadFile
->name
, 0, pLoadFile
->txt_addr
, 0, 0, 0);
1029 /* Target command for VxWorks target systems.
1031 Used in vxgdb. Takes the name of a remote target machine
1032 running vxWorks and connects to it to initialize remote network
1036 vx_open (args
, from_tty
)
1040 extern int close ();
1042 extern char *source_path
;
1043 struct ldtabl loadTable
;
1044 struct ldfile
*pLoadFile
;
1046 extern CLIENT
*pClient
;
1049 error_no_arg ("target machine name");
1051 target_preopen (from_tty
);
1053 unpush_target (&vx_ops
);
1054 printf ("Attaching remote machine across net...\n");
1057 /* Allow the user to kill the connect attempt by typing ^C.
1058 Wait until the call to target_has_fp () completes before
1059 disallowing an immediate quit, since even if net_connect ()
1060 is successful, the remote debug server might be hung. */
1065 target_has_fp
= net_check_for_fp ();
1066 printf_filtered ("Connected to %s.\n", args
);
1070 push_target (&vx_ops
);
1072 /* Save a copy of the target host's name. */
1073 vx_host
= savestring (args
, strlen (args
));
1075 /* Find out the name of the file from which the target was booted
1076 and load its symbol table. */
1078 printf_filtered ("Looking in Unix path for all loaded modules:\n");
1080 if (!net_get_boot_file (&bootFile
))
1083 printf_filtered ("\t%s: ", bootFile
);
1084 if (catch_errors (symbol_stub
, bootFile
,
1085 "Error while reading symbols from boot file:\n"))
1086 puts_filtered ("ok\n");
1087 } else if (from_tty
)
1088 printf ("VxWorks kernel symbols not loaded.\n");
1091 error ("Can't retrieve boot file name from target machine.");
1093 clnt_freeres (pClient
, xdr_wrapstring
, &bootFile
);
1095 if (net_get_symbols (&loadTable
) != 0)
1096 error ("Can't read loaded modules from target machine");
1099 while (++i
< loadTable
.tbl_size
)
1101 QUIT
; /* FIXME, avoids clnt_freeres below: mem leak */
1102 pLoadFile
= &loadTable
.tbl_ent
[i
];
1106 struct cleanup
*old_chain
;
1107 char *fullname
= NULL
;
1109 desc
= openp (source_path
, 0, pLoadFile
->name
, O_RDONLY
, 0, &fullname
);
1111 perror_with_name (pLoadFile
->name
);
1112 old_chain
= make_cleanup (close
, desc
);
1113 add_file_at_addr (fullname
, desc
, pLoadFile
->txt_addr
, pLoadFile
->data_addr
,
1114 pLoadFile
->bss_addr
);
1115 do_cleanups (old_chain
);
1119 (1) Searches the PATH, not the source path.
1120 (2) data and bss are assumed to be at the usual offsets from text. */
1121 catch_errors (add_symbol_stub
, (char *)pLoadFile
, (char *)0);
1124 printf_filtered ("Done.\n");
1126 clnt_freeres (pClient
, xdr_ldtabl
, &loadTable
);
1129 /* attach_command --
1130 takes a task started up outside of gdb and ``attaches'' to it.
1131 This stops it cold in its tracks and allows us to start tracing it. */
1134 vx_attach (args
, from_tty
)
1141 Ptrace_return ptrace_out
;
1147 error_no_arg ("process-id to attach");
1149 pid
= strtol (args
, &cptr
, 0);
1150 if ((cptr
== args
) || (*cptr
!= '\0'))
1151 error ("Invalid process-id -- give a single number in decimal or 0xhex");
1154 printf ("Attaching pid %s.\n", local_hex_string(pid
));
1156 bzero ((char *)&ptrace_in
, sizeof (ptrace_in
));
1157 bzero ((char *)&ptrace_out
, sizeof (ptrace_out
));
1158 ptrace_in
.pid
= pid
;
1160 status
= net_ptrace_clnt_call (PTRACE_ATTACH
, &ptrace_in
, &ptrace_out
);
1163 if (ptrace_out
.status
== -1)
1165 errno
= ptrace_out
.errno
;
1166 perror_with_name ("Attaching remote process");
1170 push_target (&vx_run_ops
);
1174 mark_breakpoints_out ();
1176 /* Set up the "saved terminal modes" of the inferior
1177 based on what modes we are starting it with. */
1178 target_terminal_init ();
1180 /* Install inferior's terminal modes. */
1181 target_terminal_inferior ();
1183 /* We will get a task spawn event immediately. */
1184 init_wait_for_inferior ();
1185 clear_proceed_status ();
1186 stop_soon_quietly
= 1;
1187 wait_for_inferior ();
1188 stop_soon_quietly
= 0;
1193 /* detach_command --
1194 takes a program previously attached to and detaches it.
1195 The program resumes execution and will no longer stop
1196 on signals, etc. We better not have left any breakpoints
1197 in the program or it'll die when it hits one. For this
1198 to work, it may be necessary for the process to have been
1199 previously attached. It *might* work if the program was
1200 started via the normal ptrace (PTRACE_TRACEME). */
1203 vx_detach (args
, from_tty
)
1208 Ptrace_return ptrace_out
;
1213 error ("Argument given to VxWorks \"detach\".");
1216 printf ("Detaching pid %s.\n", local_hex_string(inferior_pid
));
1218 if (args
) /* FIXME, should be possible to leave suspended */
1219 signal
= atoi (args
);
1221 bzero ((char *)&ptrace_in
, sizeof (ptrace_in
));
1222 bzero ((char *)&ptrace_out
, sizeof (ptrace_out
));
1223 ptrace_in
.pid
= inferior_pid
;
1225 status
= net_ptrace_clnt_call (PTRACE_DETACH
, &ptrace_in
, &ptrace_out
);
1228 if (ptrace_out
.status
== -1)
1230 errno
= ptrace_out
.errno
;
1231 perror_with_name ("Detaching VxWorks process");
1235 pop_target (); /* go back to non-executing VxWorks connection */
1238 /* vx_kill -- takes a running task and wipes it out. */
1244 Ptrace_return ptrace_out
;
1247 printf ("Killing pid %s.\n", local_hex_string(inferior_pid
));
1249 bzero ((char *)&ptrace_in
, sizeof (ptrace_in
));
1250 bzero ((char *)&ptrace_out
, sizeof (ptrace_out
));
1251 ptrace_in
.pid
= inferior_pid
;
1253 status
= net_ptrace_clnt_call (PTRACE_KILL
, &ptrace_in
, &ptrace_out
);
1256 if (ptrace_out
.status
== -1)
1258 errno
= ptrace_out
.errno
;
1259 perror_with_name ("Killing VxWorks process");
1262 /* If it gives good status, the process is *gone*, no events remain. */
1264 pop_target (); /* go back to non-executing VxWorks connection */
1267 /* Clean up from the VxWorks process target as it goes away. */
1270 vx_proc_close (quitting
)
1273 inferior_pid
= 0; /* No longer have a process. */
1279 /* Make an RPC call to the VxWorks target.
1280 Returns RPC status. */
1282 static enum clnt_stat
1283 net_clnt_call (procNum
, inProc
, in
, outProc
, out
)
1284 enum ptracereq procNum
;
1290 enum clnt_stat status
;
1292 status
= clnt_call (pClient
, procNum
, inProc
, in
, outProc
, out
, rpcTimeout
);
1294 if (status
!= RPC_SUCCESS
)
1295 clnt_perrno (status
);
1300 /* Clean up before losing control. */
1307 clnt_destroy (pClient
); /* The net connection */
1311 free (vx_host
); /* The hostname */
1315 /* A vxprocess target should be started via "run" not "target". */
1318 vx_proc_open (name
, from_tty
)
1322 error ("Use the \"run\" command to start a VxWorks process.");
1325 /* Target ops structure for accessing memory and such over the net */
1327 struct target_ops vx_ops
= {
1328 "vxworks", "VxWorks target memory via RPC over TCP/IP",
1329 "Use VxWorks target memory. \n\
1330 Specify the name of the machine to connect to.",
1331 vx_open
, vx_close
, vx_attach
, 0, /* vx_detach, */
1332 0, 0, /* resume, wait */
1333 0, 0, /* read_reg, write_reg */
1334 0, /* prep_to_store, */
1335 vx_xfer_memory
, vx_files_info
,
1336 0, 0, /* insert_breakpoint, remove_breakpoint */
1337 0, 0, 0, 0, 0, /* terminal stuff */
1341 vx_create_inferior
, 0, /* mourn_inferior */
1342 core_stratum
, 0, /* next */
1343 1, 1, 0, 0, 0, /* all mem, mem, stack, regs, exec */
1344 0, 0, /* Section pointers */
1345 OPS_MAGIC
, /* Always the last thing */
1348 /* Target ops structure for accessing VxWorks child processes over the net */
1350 struct target_ops vx_run_ops
= {
1351 "vxprocess", "VxWorks process",
1352 "VxWorks process, started by the \"run\" command.",
1353 vx_proc_open
, vx_proc_close
, 0, vx_detach
, /* vx_attach */
1355 vx_read_register
, vx_write_register
,
1356 vx_prepare_to_store
,
1357 vx_xfer_memory
, vx_run_files_info
,
1358 vx_insert_breakpoint
, vx_remove_breakpoint
,
1359 0, 0, 0, 0, 0, /* terminal stuff */
1363 0, vx_mourn_inferior
,
1364 process_stratum
, 0, /* next */
1365 0, 1, 1, 1, 1, /* all mem, mem, stack, regs, exec */
1366 /* all_mem is off to avoid spurious msg in "i files" */
1367 0, 0, /* Section pointers */
1368 OPS_MAGIC
, /* Always the last thing */
1370 /* ==> Remember when reading at end of file, there are two "ops" structs here. */
1375 add_target (&vx_ops
);
1376 add_target (&vx_run_ops
);