1 /* Memory-access and commands for remote VxWorks processes, for GDB.
2 Copyright 1990, 1991, 1992 Free Software Foundation, Inc.
3 Contributed by Wind River Systems and Cygnus Support.
5 This file is part of GDB.
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 2 of the License, or
10 (at your option) any later version.
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with this program; if not, write to the Free Software
19 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */
29 #include "complaints.h"
36 #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"
55 extern void symbol_file_command ();
56 extern int stop_soon_quietly
; /* for wait_for_inferior */
58 static int net_ptrace_clnt_call (); /* Forward decl */
59 static enum clnt_stat
net_clnt_call (); /* Forward decl */
60 extern struct target_ops vx_ops
, vx_run_ops
; /* Forward declaration */
62 /* Saved name of target host and called function for "info files".
66 static char *vx_running
; /* Called function */
68 /* Nonzero means target that is being debugged remotely has a floating
71 static int target_has_fp
;
73 /* Default error message when the network is forking up. */
75 static const char rpcerr
[] = "network target debugging: rpc error";
77 CLIENT
*pClient
; /* client used in net debugging */
78 static int ptraceSock
= RPC_ANYSOCK
;
80 enum clnt_stat
net_clnt_call();
81 static void parse_args ();
83 static struct timeval rpcTimeout
= { 10, 0 };
85 static char *skip_white_space ();
86 static char *find_white_space ();
88 /* Tell the VxWorks target system to download a file.
89 The load addresses of the text, data, and bss segments are
90 stored in *pTextAddr, *pDataAddr, and *pBssAddr (respectively).
91 Returns 0 for success, -1 for failure. */
94 net_load (filename
, pTextAddr
, pDataAddr
, pBssAddr
)
100 enum clnt_stat status
;
101 struct ldfile ldstruct
;
102 struct timeval load_timeout
;
104 memset ((char *) &ldstruct
, '\0', sizeof (ldstruct
));
106 /* We invoke clnt_call () here directly, instead of through
107 net_clnt_call (), because we need to set a large timeout value.
108 The load on the target side can take quite a while, easily
109 more than 10 seconds. The user can kill this call by typing
110 CTRL-C if there really is a problem with the load.
112 Do not change the tv_sec value without checking -- select() imposes
113 a limit of 10**8 on it for no good reason that I can see... */
115 load_timeout
.tv_sec
= 99999999; /* A large number, effectively inf. */
116 load_timeout
.tv_usec
= 0;
118 status
= clnt_call (pClient
, VX_LOAD
, xdr_wrapstring
, &filename
, xdr_ldfile
,
119 &ldstruct
, load_timeout
);
121 if (status
== RPC_SUCCESS
)
123 if (*ldstruct
.name
== 0) /* load failed on VxWorks side */
125 *pTextAddr
= ldstruct
.txt_addr
;
126 *pDataAddr
= ldstruct
.data_addr
;
127 *pBssAddr
= ldstruct
.bss_addr
;
134 /* returns 0 if successful, errno if RPC failed or VxWorks complains. */
137 net_break (addr
, procnum
)
141 enum clnt_stat status
;
143 Rptrace ptrace_in
; /* XXX This is stupid. It doesn't need to be a ptrace
144 structure. How about something smaller? */
146 memset ((char *) &ptrace_in
, '\0', sizeof (ptrace_in
));
149 ptrace_in
.addr
= addr
;
150 ptrace_in
.pid
= inferior_pid
;
152 status
= net_clnt_call (procnum
, xdr_rptrace
, &ptrace_in
, xdr_int
,
155 if (status
!= RPC_SUCCESS
)
158 if (break_status
== -1)
160 return break_status
; /* probably (FIXME) zero */
163 /* returns 0 if successful, errno otherwise */
166 vx_insert_breakpoint (addr
)
169 return net_break (addr
, VX_BREAK_ADD
);
172 /* returns 0 if successful, errno otherwise */
175 vx_remove_breakpoint (addr
)
178 return net_break (addr
, VX_BREAK_DELETE
);
181 /* Start an inferior process and sets inferior_pid to its pid.
182 EXEC_FILE is the file to run.
183 ALLARGS is a string containing the arguments to the program.
184 ENV is the environment vector to pass.
185 Returns process id. Errors reported with error().
186 On VxWorks, we ignore exec_file. */
189 vx_create_inferior (exec_file
, args
, env
)
194 enum clnt_stat status
;
196 TASK_START taskStart
;
198 memset ((char *) &passArgs
, '\0', sizeof (passArgs
));
199 memset ((char *) &taskStart
, '\0', sizeof (taskStart
));
201 /* parse arguments, put them in passArgs */
203 parse_args (args
, &passArgs
);
205 if (passArgs
.arg_array_len
== 0)
206 error ("You must specify a function name to run, and arguments if any");
208 status
= net_clnt_call (PROCESS_START
, xdr_arg_array
, &passArgs
,
209 xdr_TASK_START
, &taskStart
);
211 if ((status
!= RPC_SUCCESS
) || (taskStart
.status
== -1))
212 error ("Can't create process on remote target machine");
214 /* Save the name of the running function */
215 vx_running
= savestring (passArgs
.arg_array_val
[0],
216 strlen (passArgs
.arg_array_val
[0]));
218 #ifdef CREATE_INFERIOR_HOOK
219 CREATE_INFERIOR_HOOK (pid
);
222 push_target (&vx_run_ops
);
223 inferior_pid
= taskStart
.pid
;
225 /* We will get a trace trap after one instruction.
226 Insert breakpoints and continue. */
228 init_wait_for_inferior ();
230 /* Set up the "saved terminal modes" of the inferior
231 based on what modes we are starting it with. */
232 target_terminal_init ();
234 /* Install inferior's terminal modes. */
235 target_terminal_inferior ();
237 stop_soon_quietly
= 1;
238 wait_for_inferior (); /* Get the task spawn event */
239 stop_soon_quietly
= 0;
241 /* insert_step_breakpoint (); FIXME, do we need this? */
245 /* Fill ARGSTRUCT in argc/argv form with the arguments from the
246 argument string ARGSTRING. */
249 parse_args (arg_string
, arg_struct
)
250 register char *arg_string
;
251 arg_array
*arg_struct
;
253 register int arg_count
= 0; /* number of arguments */
254 register int arg_index
= 0;
257 memset ((char *) arg_struct
, '\0', sizeof (arg_array
));
259 /* first count how many arguments there are */
264 if (*(p0
= skip_white_space (p0
)) == '\0')
266 p0
= find_white_space (p0
);
270 arg_struct
->arg_array_len
= arg_count
;
271 arg_struct
->arg_array_val
= (char **) xmalloc ((arg_count
+ 1)
274 /* now copy argument strings into arg_struct. */
276 while (*(arg_string
= skip_white_space (arg_string
)))
278 p0
= find_white_space (arg_string
);
279 arg_struct
->arg_array_val
[arg_index
++] = savestring (arg_string
,
284 arg_struct
->arg_array_val
[arg_count
] = NULL
;
287 /* Advance a string pointer across whitespace and return a pointer
288 to the first non-white character. */
294 while (*p
== ' ' || *p
== '\t')
299 /* Search for the first unquoted whitespace character in a string.
300 Returns a pointer to the character, or to the null terminator
301 if no whitespace is found. */
309 while ((c
= *p
) != ' ' && c
!= '\t' && c
)
311 if (c
== '\'' || c
== '"')
313 while (*++p
!= c
&& *p
)
326 /* Poll the VxWorks target system for an event related
327 to the debugged task.
328 Returns -1 if remote wait failed, task status otherwise. */
335 enum clnt_stat status
;
337 memset ((char *) pEvent
, '\0', sizeof (RDB_EVENT
));
340 status
= net_clnt_call (PROCESS_WAIT
, xdr_int
, &pid
, xdr_RDB_EVENT
, pEvent
);
342 return (status
== RPC_SUCCESS
)? pEvent
->status
: -1;
345 /* Suspend the remote task.
346 Returns -1 if suspend fails on target system, 0 otherwise. */
353 enum clnt_stat status
;
357 /* don't let rdbTask suspend itself by passing a pid of 0 */
359 if ((pid
= inferior_pid
) == 0)
362 status
= net_clnt_call (VX_TASK_SUSPEND
, xdr_int
, &pid
, xdr_int
,
365 return (status
== RPC_SUCCESS
)? quit_status
: -1;
368 /* Read a register or registers from the remote system. */
371 vx_read_register (regno
)
376 Ptrace_return ptrace_out
;
379 extern char registers
[];
381 memset ((char *) &ptrace_in
, '\0', sizeof (ptrace_in
));
382 memset ((char *) &ptrace_out
, '\0', sizeof (ptrace_out
));
384 /* FIXME, eventually only get the ones we need. */
385 registers_fetched ();
387 ptrace_in
.pid
= inferior_pid
;
388 ptrace_out
.info
.more_data
= (caddr_t
) &out_data
;
389 out_data
.len
= VX_NUM_REGS
* REGISTER_RAW_SIZE (0);
390 out_data
.bytes
= (caddr_t
) registers
;
392 status
= net_ptrace_clnt_call (PTRACE_GETREGS
, &ptrace_in
, &ptrace_out
);
395 if (ptrace_out
.status
== -1)
397 errno
= ptrace_out
.errno
;
398 perror_with_name ("net_ptrace_clnt_call(PTRACE_GETREGS)");
401 #ifdef VX_SIZE_FPREGS
402 /* If the target has floating point registers, fetch them.
403 Otherwise, zero the floating point register values in
404 registers[] for good measure, even though we might not
409 ptrace_in
.pid
= inferior_pid
;
410 ptrace_out
.info
.more_data
= (caddr_t
) &out_data
;
411 out_data
.len
= VX_SIZE_FPREGS
;
412 out_data
.bytes
= (caddr_t
) ®isters
[REGISTER_BYTE (FP0_REGNUM
)];
414 status
= net_ptrace_clnt_call (PTRACE_GETFPREGS
, &ptrace_in
, &ptrace_out
);
417 if (ptrace_out
.status
== -1)
419 errno
= ptrace_out
.errno
;
420 perror_with_name ("net_ptrace_clnt_call(PTRACE_GETFPREGS)");
425 memset (®isters
[REGISTER_BYTE (FP0_REGNUM
)], '\0', VX_SIZE_FPREGS
);
427 #endif /* VX_SIZE_FPREGS */
430 /* Prepare to store registers. Since we will store all of them,
431 read out their current values now. */
434 vx_prepare_to_store ()
436 /* Fetch all registers, if any of them are not yet fetched. */
437 read_register_bytes (0, NULL
, REGISTER_BYTES
);
441 /* Store our register values back into the inferior.
442 If REGNO is -1, do this for all registers.
443 Otherwise, REGNO specifies which register (so we can save time). */
444 /* FIXME, look at REGNO to save time here */
447 vx_write_register (regno
)
452 extern char registers
[];
455 Ptrace_return ptrace_out
;
457 memset ((char *) &ptrace_in
, '\0', sizeof (ptrace_in
));
458 memset ((char *) &ptrace_out
, '\0', sizeof (ptrace_out
));
460 ptrace_in
.pid
= inferior_pid
;
461 ptrace_in
.info
.ttype
= DATA
;
462 ptrace_in
.info
.more_data
= (caddr_t
) &in_data
;
464 in_data
.bytes
= registers
;
466 in_data
.len
= VX_NUM_REGS
* sizeof (REGISTER_TYPE
);
468 /* XXX change second param to be a proc number */
469 status
= net_ptrace_clnt_call (PTRACE_SETREGS
, &ptrace_in
, &ptrace_out
);
472 if (ptrace_out
.status
== -1)
474 errno
= ptrace_out
.errno
;
475 perror_with_name ("net_ptrace_clnt_call(PTRACE_SETREGS)");
478 #ifdef VX_SIZE_FPREGS
479 /* Store floating point registers if the target has them. */
483 ptrace_in
.pid
= inferior_pid
;
484 ptrace_in
.info
.ttype
= DATA
;
485 ptrace_in
.info
.more_data
= (caddr_t
) &in_data
;
488 in_data
.bytes
= ®isters
[REGISTER_BYTE (FP0_REGNUM
)];
489 in_data
.len
= VX_SIZE_FPREGS
;
491 status
= net_ptrace_clnt_call (PTRACE_SETFPREGS
, &ptrace_in
, &ptrace_out
);
494 if (ptrace_out
.status
== -1)
496 errno
= ptrace_out
.errno
;
497 perror_with_name ("net_ptrace_clnt_call(PTRACE_SETFPREGS)");
500 #endif /* VX_SIZE_FPREGS */
503 /* Copy LEN bytes to or from remote inferior's memory starting at MEMADDR
504 to debugger memory starting at MYADDR. WRITE is true if writing to the
506 Result is the number of bytes written or read (zero if error). The
507 protocol allows us to return a negative count, indicating that we can't
508 handle the current address but can handle one N bytes further, but
509 vxworks doesn't give us that information. */
512 vx_xfer_memory (memaddr
, myaddr
, len
, write
, target
)
517 struct target_ops
*target
; /* ignored */
521 Ptrace_return ptrace_out
;
524 memset ((char *) &ptrace_in
, '\0', sizeof (ptrace_in
));
525 memset ((char *) &ptrace_out
, '\0', sizeof (ptrace_out
));
527 ptrace_in
.pid
= inferior_pid
; /* XXX pid unnecessary for READDATA */
528 ptrace_in
.addr
= (int) memaddr
; /* Where from */
529 ptrace_in
.data
= len
; /* How many bytes */
533 ptrace_in
.info
.ttype
= DATA
;
534 ptrace_in
.info
.more_data
= (caddr_t
) &data
;
536 data
.bytes
= (caddr_t
) myaddr
; /* Where from */
537 data
.len
= len
; /* How many bytes (again, for XDR) */
539 /* XXX change second param to be a proc number */
540 status
= net_ptrace_clnt_call (PTRACE_WRITEDATA
, &ptrace_in
, &ptrace_out
);
544 ptrace_out
.info
.more_data
= (caddr_t
) &data
;
545 data
.bytes
= myaddr
; /* Where to */
546 data
.len
= len
; /* How many (again, for XDR) */
548 /* XXX change second param to be a proc number */
549 status
= net_ptrace_clnt_call (PTRACE_READDATA
, &ptrace_in
, &ptrace_out
);
554 if (ptrace_out
.status
== -1)
556 return 0; /* No bytes moved */
558 return len
; /* Moved *all* the bytes */
564 printf ("\tAttached to host `%s'", vx_host
);
565 printf (", which has %sfloating point", target_has_fp
? "": "no ");
572 printf ("\tRunning %s VxWorks process %s",
573 vx_running
? "child": "attached",
574 local_hex_string((unsigned long) inferior_pid
));
576 printf (", function `%s'", vx_running
);
581 vx_resume (pid
, step
, siggnal
)
588 Ptrace_return ptrace_out
;
590 if (siggnal
!= 0 && siggnal
!= stop_signal
)
591 error ("Cannot send signals to VxWorks processes");
593 memset ((char *) &ptrace_in
, '\0', sizeof (ptrace_in
));
594 memset ((char *) &ptrace_out
, '\0', sizeof (ptrace_out
));
597 ptrace_in
.addr
= 1; /* Target side insists on this, or it panics. */
599 /* XXX change second param to be a proc number */
600 status
= net_ptrace_clnt_call (step
? PTRACE_SINGLESTEP
: PTRACE_CONT
,
601 &ptrace_in
, &ptrace_out
);
604 if (ptrace_out
.status
== -1)
606 errno
= ptrace_out
.errno
;
607 perror_with_name ("Resuming remote process");
614 pop_target (); /* Pop back to no-child state */
615 generic_mourn_inferior ();
619 /* This function allows the addition of incrementally linked object files. */
622 vx_load_command (arg_string
, from_tty
)
631 error ("The load command takes a file name");
633 arg_string
= tilde_expand (arg_string
);
634 make_cleanup (free
, arg_string
);
640 if (net_load (arg_string
, &text_addr
, &data_addr
, &bss_addr
) == -1)
641 error ("Load failed on target machine");
644 /* FIXME, for now we ignore data_addr and bss_addr. */
645 symbol_file_add (arg_string
, from_tty
, text_addr
, 0, 0, 0);
648 #ifdef FIXME /* Not ready for prime time */
649 /* Single step the target program at the source or machine level.
650 Takes an error exit if rpc fails.
651 Returns -1 if remote single-step operation fails, else 0. */
656 enum clnt_stat status
;
658 SOURCE_STEP source_step
;
660 source_step
.taskId
= inferior_pid
;
664 source_step
.startAddr
= step_range_start
;
665 source_step
.endAddr
= step_range_end
;
669 source_step
.startAddr
= 0;
670 source_step
.endAddr
= 0;
673 status
= net_clnt_call (VX_SOURCE_STEP
, xdr_SOURCE_STEP
, &source_step
,
674 xdr_int
, &step_status
);
676 if (status
== RPC_SUCCESS
)
683 /* Emulate ptrace using RPC calls to the VxWorks target system.
684 Returns nonzero (-1) if RPC status to VxWorks is bad, 0 otherwise. */
687 net_ptrace_clnt_call (request
, pPtraceIn
, pPtraceOut
)
688 enum ptracereq request
;
690 Ptrace_return
*pPtraceOut
;
692 enum clnt_stat status
;
694 status
= net_clnt_call (request
, xdr_rptrace
, pPtraceIn
, xdr_ptrace_return
,
697 if (status
!= RPC_SUCCESS
)
703 /* Query the target for the name of the file from which VxWorks was
704 booted. pBootFile is the address of a pointer to the buffer to
705 receive the file name; if the pointer pointed to by pBootFile is
706 NULL, memory for the buffer will be allocated by XDR.
707 Returns -1 if rpc failed, 0 otherwise. */
710 net_get_boot_file (pBootFile
)
713 enum clnt_stat status
;
715 status
= net_clnt_call (VX_BOOT_FILE_INQ
, xdr_void
, (char *) 0,
716 xdr_wrapstring
, pBootFile
);
717 return (status
== RPC_SUCCESS
) ? 0 : -1;
720 /* Fetch a list of loaded object modules from the VxWorks target.
721 Returns -1 if rpc failed, 0 otherwise
722 There's no way to check if the returned loadTable is correct.
723 VxWorks doesn't check it. */
726 net_get_symbols (pLoadTable
)
727 ldtabl
*pLoadTable
; /* return pointer to ldtabl here */
729 enum clnt_stat status
;
731 memset ((char *) pLoadTable
, '\0', sizeof (struct ldtabl
));
733 status
= net_clnt_call (VX_STATE_INQ
, xdr_void
, 0, xdr_ldtabl
, pLoadTable
);
734 return (status
== RPC_SUCCESS
) ? 0 : -1;
737 /* Look up a symbol in the VxWorks target's symbol table.
738 Returns status of symbol read on target side (0=success, -1=fail)
739 Returns -1 and complain()s if rpc fails. */
741 struct complaint cant_contact_target
=
742 {"Lost contact with VxWorks target", 0, 0};
745 vx_lookup_symbol (name
, pAddr
)
746 char *name
; /* symbol name */
749 enum clnt_stat status
;
750 SYMBOL_ADDR symbolAddr
;
753 memset ((char *) &symbolAddr
, '\0', sizeof (symbolAddr
));
755 status
= net_clnt_call (VX_SYMBOL_INQ
, xdr_wrapstring
, &name
,
756 xdr_SYMBOL_ADDR
, &symbolAddr
);
757 if (status
!= RPC_SUCCESS
) {
758 complain (&cant_contact_target
);
762 *pAddr
= symbolAddr
.addr
;
763 return symbolAddr
.status
;
766 /* Check to see if the VxWorks target has a floating point coprocessor.
767 Returns 1 if target has floating point processor, 0 otherwise.
768 Calls error() if rpc fails. */
773 enum clnt_stat status
;
774 bool_t fp
= 0; /* true if fp processor is present on target board */
776 status
= net_clnt_call (VX_FP_INQUIRE
, xdr_void
, 0, xdr_bool
, &fp
);
777 if (status
!= RPC_SUCCESS
)
783 /* Establish an RPC connection with the VxWorks target system.
784 Calls error () if unable to establish connection. */
790 struct sockaddr_in destAddr
;
791 struct hostent
*destHost
;
794 /* Get the internet address for the given host. Allow a numeric
795 IP address or a hostname. */
797 addr
= inet_addr (host
);
800 destHost
= (struct hostent
*) gethostbyname (host
);
801 if (destHost
== NULL
)
802 error ("Invalid hostname. Couldn't find remote host address.");
803 addr
= * (unsigned long *) destHost
->h_addr
;
806 memset (&destAddr
, '\0', sizeof (destAddr
));
808 destAddr
.sin_addr
.s_addr
= addr
;
809 destAddr
.sin_family
= AF_INET
;
810 destAddr
.sin_port
= 0; /* set to actual port that remote
811 ptrace is listening on. */
813 /* Create a tcp client transport on which to issue
814 calls to the remote ptrace server. */
816 ptraceSock
= RPC_ANYSOCK
;
817 pClient
= clnttcp_create (&destAddr
, RDBPROG
, RDBVERS
, &ptraceSock
, 0, 0);
818 /* FIXME, here is where we deal with different version numbers of the proto */
822 clnt_pcreateerror ("\tnet_connect");
823 error ("Couldn't connect to remote target.");
827 /* Sleep for the specified number of milliseconds
828 * (assumed to be less than 1000).
829 * If select () is interrupted, returns immediately;
830 * takes an error exit if select () fails for some other reason.
837 struct timeval select_timeout
;
840 select_timeout
.tv_sec
= 0;
841 select_timeout
.tv_usec
= ms
* 1000;
843 status
= select (0, (fd_set
*) 0, (fd_set
*) 0, (fd_set
*) 0, &select_timeout
);
845 if (status
< 0 && errno
!= EINTR
)
846 perror_with_name ("select");
849 /* Wait for control to return from inferior to debugger.
850 If inferior gets a signal, we may decide to start it up again
851 instead of returning. That is why there is a loop in this function.
852 When this function actually returns it means the inferior
853 should be left stopped and GDB should read more commands. */
855 /* For network debugging with VxWorks.
856 * VxWorks knows when tasks hit breakpoints, receive signals, exit, etc,
857 * so vx_wait() receives this information directly from
858 * VxWorks instead of trying to figure out what happenned via a wait() call.
872 /* If CTRL-C is hit during this loop,
873 suspend the inferior process. */
878 quit_failed
= (net_quit () == -1);
882 /* If a net_quit () or net_wait () call has failed,
883 allow the user to break the connection with the target.
884 We can't simply error () out of this loop, since the
885 data structures representing the state of the inferior
886 are in an inconsistent state. */
888 if (quit_failed
|| net_wait (&rdbEvent
) == -1)
891 if (query ("Can't %s. Disconnect from target system? ",
892 (quit_failed
) ? "suspend remote task"
893 : "get status of remote task"))
895 target_mourn_inferior();
896 error ("Use the \"target\" command to reconnect.");
900 terminal_inferior ();
905 pid
= rdbEvent
.taskId
;
908 sleep_ms (200); /* FIXME Don't kill the network too badly */
910 else if (pid
!= inferior_pid
)
911 fatal ("Bad pid for debugged task: %s\n",
912 local_hex_string((unsigned long) pid
));
915 /* FIXME, eventually do more then SIGTRAP on everything... */
916 switch (rdbEvent
.eventType
)
920 /* FIXME is it possible to distinguish between a
921 XXX normal vs abnormal exit in VxWorks? */
924 case EVENT_START
: /* Task was just started. */
925 WSETSTOP (w
, SIGTRAP
);
929 WSETSTOP (w
, SIGTRAP
);
930 /* XXX was it stopped by a signal? act accordingly */
933 case EVENT_BREAK
: /* Breakpoint was hit. */
934 WSETSTOP (w
, SIGTRAP
);
937 case EVENT_SUSPEND
: /* Task was suspended, probably by ^C. */
938 WSETSTOP (w
, SIGINT
);
941 case EVENT_BUS_ERR
: /* Task made evil nasty reference. */
942 WSETSTOP (w
, SIGBUS
);
945 case EVENT_ZERO_DIV
: /* Division by zero */
946 WSETSTOP (w
, SIGFPE
); /* Like Unix, call it a float exception. */
950 /* The target is not running Unix, and its
951 faults/traces do not map nicely into Unix signals.
952 Make sure they do not get confused with Unix signals
953 by numbering them with values higher than the highest
954 legal Unix signal. code in the arch-dependent PRINT_RANDOM_SIGNAL
955 routine will interpret the value for wait_for_inferior. */
956 WSETSTOP (w
, rdbEvent
.sigType
+ NSIG
);
959 *status
= *(int *)&w
; /* Grumble union wait crap Grumble */
967 symbol_file_command (arg
, 0);
972 add_symbol_stub (arg
)
975 struct ldfile
*pLoadFile
= (struct ldfile
*)arg
;
977 printf("\t%s: ", pLoadFile
->name
);
978 symbol_file_add (pLoadFile
->name
, 0, pLoadFile
->txt_addr
, 0, 0, 0);
982 /* Target command for VxWorks target systems.
984 Used in vxgdb. Takes the name of a remote target machine
985 running vxWorks and connects to it to initialize remote network
989 vx_open (args
, from_tty
)
995 extern char *source_path
;
996 struct ldtabl loadTable
;
997 struct ldfile
*pLoadFile
;
999 extern CLIENT
*pClient
;
1002 error_no_arg ("target machine name");
1004 target_preopen (from_tty
);
1006 unpush_target (&vx_ops
);
1007 printf ("Attaching remote machine across net...\n");
1010 /* Allow the user to kill the connect attempt by typing ^C.
1011 Wait until the call to target_has_fp () completes before
1012 disallowing an immediate quit, since even if net_connect ()
1013 is successful, the remote debug server might be hung. */
1018 target_has_fp
= net_check_for_fp ();
1019 printf_filtered ("Connected to %s.\n", args
);
1023 push_target (&vx_ops
);
1025 /* Save a copy of the target host's name. */
1026 vx_host
= savestring (args
, strlen (args
));
1028 /* Find out the name of the file from which the target was booted
1029 and load its symbol table. */
1031 printf_filtered ("Looking in Unix path for all loaded modules:\n");
1033 if (!net_get_boot_file (&bootFile
))
1036 printf_filtered ("\t%s: ", bootFile
);
1038 (symbol_stub
, bootFile
,
1039 "Error while reading symbols from boot file:\n", RETURN_MASK_ALL
))
1040 puts_filtered ("ok\n");
1041 } else if (from_tty
)
1042 printf ("VxWorks kernel symbols not loaded.\n");
1045 error ("Can't retrieve boot file name from target machine.");
1047 clnt_freeres (pClient
, xdr_wrapstring
, &bootFile
);
1049 if (net_get_symbols (&loadTable
) != 0)
1050 error ("Can't read loaded modules from target machine");
1053 while (++i
< loadTable
.tbl_size
)
1055 QUIT
; /* FIXME, avoids clnt_freeres below: mem leak */
1056 pLoadFile
= &loadTable
.tbl_ent
[i
];
1060 struct cleanup
*old_chain
;
1061 char *fullname
= NULL
;
1063 desc
= openp (source_path
, 0, pLoadFile
->name
, O_RDONLY
, 0, &fullname
);
1065 perror_with_name (pLoadFile
->name
);
1066 old_chain
= make_cleanup (close
, desc
);
1067 add_file_at_addr (fullname
, desc
, pLoadFile
->txt_addr
, pLoadFile
->data_addr
,
1068 pLoadFile
->bss_addr
);
1069 do_cleanups (old_chain
);
1073 (1) Searches the PATH, not the source path.
1074 (2) data and bss are assumed to be at the usual offsets from text. */
1075 catch_errors (add_symbol_stub
, (char *)pLoadFile
, (char *)0,
1079 printf_filtered ("Done.\n");
1081 clnt_freeres (pClient
, xdr_ldtabl
, &loadTable
);
1084 /* Takes a task started up outside of gdb and ``attaches'' to it.
1085 This stops it cold in its tracks and allows us to start tracing it. */
1088 vx_attach (args
, from_tty
)
1095 Ptrace_return ptrace_out
;
1099 error_no_arg ("process-id to attach");
1101 pid
= strtol (args
, &cptr
, 0);
1102 if ((cptr
== args
) || (*cptr
!= '\0'))
1103 error ("Invalid process-id -- give a single number in decimal or 0xhex");
1106 printf ("Attaching pid %s.\n",
1107 local_hex_string((unsigned long) pid
));
1109 memset ((char *)&ptrace_in
, '\0', sizeof (ptrace_in
));
1110 memset ((char *)&ptrace_out
, '\0', sizeof (ptrace_out
));
1111 ptrace_in
.pid
= pid
;
1113 status
= net_ptrace_clnt_call (PTRACE_ATTACH
, &ptrace_in
, &ptrace_out
);
1116 if (ptrace_out
.status
== -1)
1118 errno
= ptrace_out
.errno
;
1119 perror_with_name ("Attaching remote process");
1123 push_target (&vx_run_ops
);
1129 /* detach_command --
1130 takes a program previously attached to and detaches it.
1131 The program resumes execution and will no longer stop
1132 on signals, etc. We better not have left any breakpoints
1133 in the program or it'll die when it hits one. For this
1134 to work, it may be necessary for the process to have been
1135 previously attached. It *might* work if the program was
1136 started via the normal ptrace (PTRACE_TRACEME). */
1139 vx_detach (args
, from_tty
)
1144 Ptrace_return ptrace_out
;
1149 error ("Argument given to VxWorks \"detach\".");
1152 printf ("Detaching pid %s.\n",
1153 local_hex_string((unsigned long) inferior_pid
));
1155 if (args
) /* FIXME, should be possible to leave suspended */
1156 signal
= atoi (args
);
1158 memset ((char *)&ptrace_in
, '\0', sizeof (ptrace_in
));
1159 memset ((char *)&ptrace_out
, '\0', sizeof (ptrace_out
));
1160 ptrace_in
.pid
= inferior_pid
;
1162 status
= net_ptrace_clnt_call (PTRACE_DETACH
, &ptrace_in
, &ptrace_out
);
1165 if (ptrace_out
.status
== -1)
1167 errno
= ptrace_out
.errno
;
1168 perror_with_name ("Detaching VxWorks process");
1172 pop_target (); /* go back to non-executing VxWorks connection */
1175 /* vx_kill -- takes a running task and wipes it out. */
1181 Ptrace_return ptrace_out
;
1184 printf ("Killing pid %s.\n", local_hex_string((unsigned long) inferior_pid
));
1186 memset ((char *)&ptrace_in
, '\0', sizeof (ptrace_in
));
1187 memset ((char *)&ptrace_out
, '\0', sizeof (ptrace_out
));
1188 ptrace_in
.pid
= inferior_pid
;
1190 status
= net_ptrace_clnt_call (PTRACE_KILL
, &ptrace_in
, &ptrace_out
);
1193 else if (ptrace_out
.status
== -1)
1195 errno
= ptrace_out
.errno
;
1196 perror_with_name ("Killing VxWorks process");
1199 /* If it gives good status, the process is *gone*, no events remain.
1200 If the kill failed, assume the process is gone anyhow. */
1202 pop_target (); /* go back to non-executing VxWorks connection */
1205 /* Clean up from the VxWorks process target as it goes away. */
1208 vx_proc_close (quitting
)
1211 inferior_pid
= 0; /* No longer have a process. */
1217 /* Make an RPC call to the VxWorks target.
1218 Returns RPC status. */
1220 static enum clnt_stat
1221 net_clnt_call (procNum
, inProc
, in
, outProc
, out
)
1222 enum ptracereq procNum
;
1228 enum clnt_stat status
;
1230 status
= clnt_call (pClient
, procNum
, inProc
, in
, outProc
, out
, rpcTimeout
);
1232 if (status
!= RPC_SUCCESS
)
1233 clnt_perrno (status
);
1238 /* Clean up before losing control. */
1245 clnt_destroy (pClient
); /* The net connection */
1249 free (vx_host
); /* The hostname */
1253 /* A vxprocess target should be started via "run" not "target". */
1256 vx_proc_open (name
, from_tty
)
1260 error ("Use the \"run\" command to start a VxWorks process.");
1263 /* Target ops structure for accessing memory and such over the net */
1265 struct target_ops vx_ops
= {
1266 "vxworks", "VxWorks target memory via RPC over TCP/IP",
1267 "Use VxWorks target memory. \n\
1268 Specify the name of the machine to connect to.",
1269 vx_open
, vx_close
, vx_attach
, 0, /* vx_detach, */
1270 0, 0, /* resume, wait */
1271 0, 0, /* read_reg, write_reg */
1272 0, /* prep_to_store, */
1273 vx_xfer_memory
, vx_files_info
,
1274 0, 0, /* insert_breakpoint, remove_breakpoint */
1275 0, 0, 0, 0, 0, /* terminal stuff */
1279 vx_create_inferior
, 0, /* mourn_inferior */
1281 0, /* notice_signals */
1282 core_stratum
, 0, /* next */
1283 1, 1, 0, 0, 0, /* all mem, mem, stack, regs, exec */
1284 0, 0, /* Section pointers */
1285 OPS_MAGIC
, /* Always the last thing */
1288 /* Target ops structure for accessing VxWorks child processes over the net */
1290 struct target_ops vx_run_ops
= {
1291 "vxprocess", "VxWorks process",
1292 "VxWorks process, started by the \"run\" command.",
1293 vx_proc_open
, vx_proc_close
, 0, vx_detach
, /* vx_attach */
1295 vx_read_register
, vx_write_register
,
1296 vx_prepare_to_store
,
1297 vx_xfer_memory
, vx_run_files_info
,
1298 vx_insert_breakpoint
, vx_remove_breakpoint
,
1299 0, 0, 0, 0, 0, /* terminal stuff */
1303 0, vx_mourn_inferior
,
1305 0, /* notice_signals */
1306 process_stratum
, 0, /* next */
1307 0, 1, 1, 1, 1, /* all mem, mem, stack, regs, exec */
1308 /* all_mem is off to avoid spurious msg in "i files" */
1309 0, 0, /* Section pointers */
1310 OPS_MAGIC
, /* Always the last thing */
1312 /* ==> Remember when reading at end of file, there are two "ops" structs here. */
1319 (add_set_cmd ("vxworks-timeout", class_support
, var_uinteger
,
1320 (char *) &rpcTimeout
.tv_sec
,
1321 "Set seconds to wait for rpc calls to return.\n\
1322 Set the number of seconds to wait for rpc calls to return.", &setlist
),
1325 add_target (&vx_ops
);
1326 add_target (&vx_run_ops
);