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 free bogon_free /* Sun claims "int free()" not void */
41 #include <sys/time.h> /* UTek's <rpc/rpc.h> doesn't #incl this */
43 #include "vx-share/ptrace.h"
44 #include "vx-share/xdr_ptrace.h"
45 #include "vx-share/xdr_ld.h"
46 #include "vx-share/xdr_rdb.h"
47 #include "vx-share/dbgRpcLib.h"
48 #include "vx-share/reg.h"
52 extern void symbol_file_command ();
53 extern int stop_soon_quietly
; /* for wait_for_inferior */
54 extern void host_convert_to_virtual ();
55 extern void host_convert_from_virtual ();
57 static int net_ptrace_clnt_call (); /* Forward decl */
58 static enum clnt_stat
net_clnt_call (); /* Forward decl */
59 extern struct target_ops vx_ops
, vx_run_ops
; /* Forward declaration */
61 /* Saved name of target host and called function for "info files".
65 static char *vx_running
; /* Called function */
67 /* Nonzero means target that is being debugged remotely has a floating
70 static int target_has_fp
;
72 /* Default error message when the network is forking up. */
74 static const char rpcerr
[] = "network target debugging: rpc error";
76 CLIENT
*pClient
; /* client used in net debugging */
77 static int ptraceSock
= RPC_ANYSOCK
;
79 enum clnt_stat
net_clnt_call();
80 static void parse_args ();
82 static struct timeval rpcTimeout
= { 10, 0 };
84 static char *skip_white_space ();
85 static char *find_white_space ();
87 /* Tell the VxWorks target system to download a file.
88 The load addresses of the text, data, and bss segments are
89 stored in *pTextAddr, *pDataAddr, and *pBssAddr (respectively).
90 Returns 0 for success, -1 for failure. */
93 net_load (filename
, pTextAddr
, pDataAddr
, pBssAddr
)
99 enum clnt_stat status
;
100 struct ldfile ldstruct
;
101 struct timeval load_timeout
;
103 bzero ((char *) &ldstruct
, sizeof (ldstruct
));
105 /* We invoke clnt_call () here directly, instead of through
106 net_clnt_call (), because we need to set a large timeout value.
107 The load on the target side can take quite a while, easily
108 more than 10 seconds. The user can kill this call by typing
109 CTRL-C if there really is a problem with the load.
111 Do not change the tv_sec value without checking -- select() imposes
112 a limit of 10**8 on it for no good reason that I can see... */
114 load_timeout
.tv_sec
= 99999999; /* A large number, effectively inf. */
115 load_timeout
.tv_usec
= 0;
117 status
= clnt_call (pClient
, VX_LOAD
, xdr_wrapstring
, &filename
, xdr_ldfile
,
118 &ldstruct
, load_timeout
);
120 if (status
== RPC_SUCCESS
)
122 if (*ldstruct
.name
== 0) /* load failed on VxWorks side */
124 *pTextAddr
= ldstruct
.txt_addr
;
125 *pDataAddr
= ldstruct
.data_addr
;
126 *pBssAddr
= ldstruct
.bss_addr
;
133 /* returns 0 if successful, errno if RPC failed or VxWorks complains. */
136 net_break (addr
, procnum
)
140 enum clnt_stat status
;
142 Rptrace ptrace_in
; /* XXX This is stupid. It doesn't need to be a ptrace
143 structure. How about something smaller? */
145 bzero ((char *) &ptrace_in
, sizeof (ptrace_in
));
148 ptrace_in
.addr
= addr
;
149 ptrace_in
.pid
= inferior_pid
;
151 status
= net_clnt_call (procnum
, xdr_rptrace
, &ptrace_in
, xdr_int
,
154 if (status
!= RPC_SUCCESS
)
157 if (break_status
== -1)
159 return break_status
; /* probably (FIXME) zero */
162 /* returns 0 if successful, errno otherwise */
165 vx_insert_breakpoint (addr
)
168 return net_break (addr
, VX_BREAK_ADD
);
171 /* returns 0 if successful, errno otherwise */
174 vx_remove_breakpoint (addr
)
177 return net_break (addr
, VX_BREAK_DELETE
);
180 /* Start an inferior process and sets inferior_pid to its pid.
181 EXEC_FILE is the file to run.
182 ALLARGS is a string containing the arguments to the program.
183 ENV is the environment vector to pass.
184 Returns process id. Errors reported with error().
185 On VxWorks, we ignore exec_file. */
188 vx_create_inferior (exec_file
, args
, env
)
193 enum clnt_stat status
;
195 TASK_START taskStart
;
197 bzero ((char *) &passArgs
, sizeof (passArgs
));
198 bzero ((char *) &taskStart
, sizeof (taskStart
));
200 /* parse arguments, put them in passArgs */
202 parse_args (args
, &passArgs
);
204 if (passArgs
.arg_array_len
== 0)
205 error ("You must specify a function name to run, and arguments if any");
207 status
= net_clnt_call (PROCESS_START
, xdr_arg_array
, &passArgs
,
208 xdr_TASK_START
, &taskStart
);
210 if ((status
!= RPC_SUCCESS
) || (taskStart
.status
== -1))
211 error ("Can't create process on remote target machine");
213 /* Save the name of the running function */
214 vx_running
= savestring (passArgs
.arg_array_val
[0],
215 strlen (passArgs
.arg_array_val
[0]));
217 #ifdef CREATE_INFERIOR_HOOK
218 CREATE_INFERIOR_HOOK (pid
);
221 push_target (&vx_run_ops
);
222 inferior_pid
= taskStart
.pid
;
224 /* We will get a trace trap after one instruction.
225 Insert breakpoints and continue. */
227 init_wait_for_inferior ();
229 /* Set up the "saved terminal modes" of the inferior
230 based on what modes we are starting it with. */
231 target_terminal_init ();
233 /* Install inferior's terminal modes. */
234 target_terminal_inferior ();
236 stop_soon_quietly
= 1;
237 wait_for_inferior (); /* Get the task spawn event */
238 stop_soon_quietly
= 0;
240 /* insert_step_breakpoint (); FIXME, do we need this? */
244 /* Fill ARGSTRUCT in argc/argv form with the arguments from the
245 argument string ARGSTRING. */
248 parse_args (arg_string
, arg_struct
)
249 register char *arg_string
;
250 arg_array
*arg_struct
;
252 register int arg_count
= 0; /* number of arguments */
253 register int arg_index
= 0;
256 bzero ((char *) arg_struct
, sizeof (arg_array
));
258 /* first count how many arguments there are */
263 if (*(p0
= skip_white_space (p0
)) == '\0')
265 p0
= find_white_space (p0
);
269 arg_struct
->arg_array_len
= arg_count
;
270 arg_struct
->arg_array_val
= (char **) xmalloc ((arg_count
+ 1)
273 /* now copy argument strings into arg_struct. */
275 while (*(arg_string
= skip_white_space (arg_string
)))
277 p0
= find_white_space (arg_string
);
278 arg_struct
->arg_array_val
[arg_index
++] = savestring (arg_string
,
283 arg_struct
->arg_array_val
[arg_count
] = NULL
;
286 /* Advance a string pointer across whitespace and return a pointer
287 to the first non-white character. */
293 while (*p
== ' ' || *p
== '\t')
298 /* Search for the first unquoted whitespace character in a string.
299 Returns a pointer to the character, or to the null terminator
300 if no whitespace is found. */
308 while ((c
= *p
) != ' ' && c
!= '\t' && c
)
310 if (c
== '\'' || c
== '"')
312 while (*++p
!= c
&& *p
)
325 /* Poll the VxWorks target system for an event related
326 to the debugged task.
327 Returns -1 if remote wait failed, task status otherwise. */
334 enum clnt_stat status
;
336 bzero ((char *) pEvent
, sizeof (RDB_EVENT
));
339 status
= net_clnt_call (PROCESS_WAIT
, xdr_int
, &pid
, xdr_RDB_EVENT
, pEvent
);
341 return (status
== RPC_SUCCESS
)? pEvent
->status
: -1;
344 /* Suspend the remote task.
345 Returns -1 if suspend fails on target system, 0 otherwise. */
352 enum clnt_stat status
;
356 /* don't let rdbTask suspend itself by passing a pid of 0 */
358 if ((pid
= inferior_pid
) == 0)
361 status
= net_clnt_call (VX_TASK_SUSPEND
, xdr_int
, &pid
, xdr_int
,
364 return (status
== RPC_SUCCESS
)? quit_status
: -1;
367 /* Read a register or registers from the remote system. */
370 vx_read_register (regno
)
375 Ptrace_return ptrace_out
;
378 extern char registers
[];
380 bzero ((char *) &ptrace_in
, sizeof (ptrace_in
));
381 bzero ((char *) &ptrace_out
, sizeof (ptrace_out
));
383 /* FIXME, eventually only get the ones we need. */
384 registers_fetched ();
386 ptrace_in
.pid
= inferior_pid
;
387 ptrace_out
.info
.more_data
= (caddr_t
) &out_data
;
389 out_data
.len
= 18 * REGISTER_RAW_SIZE (0); /* FIXME 68k hack */
391 out_data
.len
= (16 + 16 + 3) * REGISTER_RAW_SIZE (0);
393 out_data
.bytes
= (caddr_t
) registers
;
395 status
= net_ptrace_clnt_call (PTRACE_GETREGS
, &ptrace_in
, &ptrace_out
);
398 if (ptrace_out
.status
== -1)
400 errno
= ptrace_out
.errno
;
401 perror_with_name ("net_ptrace_clnt_call(PTRACE_GETREGS)");
407 /* If the target has floating point registers, fetch them.
408 Otherwise, zero the floating point register values in
409 registers[] for good measure, even though we might not
411 /* @@ Can't use this -- the rdb library for the 960 target
412 doesn't support setting or retrieving FP regs. KR */
414 struct fp_status inferior_fp_registers
;
418 ptrace_in
.pid
= inferior_pid
;
419 ptrace_out
.info
.more_data
= (caddr_t
) &inferior_fp_registers
;
420 status
= net_ptrace_clnt_call (PTRACE_GETFPREGS
,
421 &ptrace_in
, &ptrace_out
);
424 if (ptrace_out
.status
== -1)
426 errno
= ptrace_out
.errno
;
427 perror_with_name ("net_ptrace_clnt_call(PTRACE_GETFPREGS)");
430 bcopy (&inferior_fp_registers
, ®isters
[REGISTER_BYTE (FP0_REGNUM
)],
431 REGISTER_RAW_SIZE (FP0_REGNUM
) * 4);
435 bzero ((char *) ®isters
[REGISTER_BYTE (FP0_REGNUM
)],
436 REGISTER_RAW_SIZE (FP0_REGNUM
) * 4);
440 #else /* not 960, thus must be 68000: FIXME! */
444 ptrace_in
.pid
= inferior_pid
;
445 ptrace_out
.info
.more_data
= (caddr_t
) &out_data
;
446 out_data
.len
= 8 * REGISTER_RAW_SIZE (FP0_REGNUM
) /* FIXME */
447 + (3 * sizeof (REGISTER_TYPE
));
448 out_data
.bytes
= (caddr_t
) ®isters
[REGISTER_BYTE (FP0_REGNUM
)];
450 status
= net_ptrace_clnt_call (PTRACE_GETFPREGS
, &ptrace_in
, &ptrace_out
);
453 if (ptrace_out
.status
== -1)
455 errno
= ptrace_out
.errno
;
456 perror_with_name ("net_ptrace_clnt_call(PTRACE_GETFPREGS)");
461 bzero (®isters
[REGISTER_BYTE (FP0_REGNUM
)],
462 8 * REGISTER_RAW_SIZE (FP0_REGNUM
));
463 bzero (®isters
[REGISTER_BYTE (FPC_REGNUM
)],
464 3 * sizeof (REGISTER_TYPE
));
466 #endif /* various architectures */
469 /* Prepare to store registers. Since we will store all of them,
470 read out their current values now. */
473 vx_prepare_to_store ()
475 vx_read_register (-1);
479 /* Store our register values back into the inferior.
480 If REGNO is -1, do this for all registers.
481 Otherwise, REGNO specifies which register (so we can save time). */
482 /* FIXME, look at REGNO to save time here */
485 vx_write_register (regno
)
490 extern char registers
[];
493 Ptrace_return ptrace_out
;
495 bzero ((char *) &ptrace_in
, sizeof (ptrace_in
));
496 bzero ((char *) &ptrace_out
, sizeof (ptrace_out
));
498 ptrace_in
.pid
= inferior_pid
;
499 ptrace_in
.info
.ttype
= DATA
;
500 ptrace_in
.info
.more_data
= (caddr_t
) &in_data
;
502 in_data
.bytes
= registers
;
506 in_data
.len
= (16 + 16 + 3) * sizeof (REGISTER_TYPE
);
508 #else /* not 960 -- assume 68k -- FIXME */
510 in_data
.len
= 18 * sizeof (REGISTER_TYPE
);
512 #endif /* Different register sets */
514 /* XXX change second param to be a proc number */
515 status
= net_ptrace_clnt_call (PTRACE_SETREGS
, &ptrace_in
, &ptrace_out
);
518 if (ptrace_out
.status
== -1)
520 errno
= ptrace_out
.errno
;
521 perror_with_name ("net_ptrace_clnt_call(PTRACE_SETREGS)");
524 /* Store floating point registers if the target has them. */
528 ptrace_in
.pid
= inferior_pid
;
529 ptrace_in
.info
.ttype
= DATA
;
530 ptrace_in
.info
.more_data
= (caddr_t
) &in_data
;
534 #if 0 /* @@ Not supported by target. */
535 in_data
.bytes
= ®isters
[REGISTER_BYTE (FP0_REGNUM
)];
536 in_data
.len
= 4 * REGISTER_RAW_SIZE (FP0_REGNUM
);
538 #else /* not 960 -- assume 68k -- FIXME */
540 in_data
.bytes
= ®isters
[REGISTER_BYTE (FP0_REGNUM
)];
541 in_data
.len
= (8 * REGISTER_RAW_SIZE (FP0_REGNUM
)
542 + (3 * sizeof (REGISTER_TYPE
)));
544 #endif /* Different register sets */
546 status
= net_ptrace_clnt_call (PTRACE_SETFPREGS
, &ptrace_in
, &ptrace_out
);
549 if (ptrace_out
.status
== -1)
551 errno
= ptrace_out
.errno
;
552 perror_with_name ("net_ptrace_clnt_call(PTRACE_SETFPREGS)");
557 /* Copy LEN bytes to or from remote inferior's memory starting at MEMADDR
558 to debugger memory starting at MYADDR. WRITE is true if writing to the
560 Result is the number of bytes written or read (zero if error). The
561 protocol allows us to return a negative count, indicating that we can't
562 handle the current address but can handle one N bytes further, but
563 vxworks doesn't give us that information. */
566 vx_xfer_memory (memaddr
, myaddr
, len
, write
, target
)
571 struct target_ops
*target
; /* ignored */
575 Ptrace_return ptrace_out
;
578 bzero ((char *) &ptrace_in
, sizeof (ptrace_in
));
579 bzero ((char *) &ptrace_out
, sizeof (ptrace_out
));
581 ptrace_in
.pid
= inferior_pid
; /* XXX pid unnecessary for READDATA */
582 ptrace_in
.addr
= (int) memaddr
; /* Where from */
583 ptrace_in
.data
= len
; /* How many bytes */
587 ptrace_in
.info
.ttype
= DATA
;
588 ptrace_in
.info
.more_data
= (caddr_t
) &data
;
590 data
.bytes
= (caddr_t
) myaddr
; /* Where from */
591 data
.len
= len
; /* How many bytes (again, for XDR) */
593 /* XXX change second param to be a proc number */
594 status
= net_ptrace_clnt_call (PTRACE_WRITEDATA
, &ptrace_in
, &ptrace_out
);
598 ptrace_out
.info
.more_data
= (caddr_t
) &data
;
599 data
.bytes
= myaddr
; /* Where to */
600 data
.len
= len
; /* How many (again, for XDR) */
602 /* XXX change second param to be a proc number */
603 status
= net_ptrace_clnt_call (PTRACE_READDATA
, &ptrace_in
, &ptrace_out
);
608 if (ptrace_out
.status
== -1)
610 return 0; /* No bytes moved */
612 return len
; /* Moved *all* the bytes */
618 printf ("\tAttached to host `%s'", vx_host
);
619 printf (", which has %sfloating point", target_has_fp
? "": "no ");
626 printf ("\tRunning %s VxWorks process %s",
627 vx_running
? "child": "attached",
628 local_hex_string(inferior_pid
));
630 printf (", function `%s'", vx_running
);
635 vx_resume (step
, siggnal
)
641 Ptrace_return ptrace_out
;
643 if (siggnal
!= 0 && siggnal
!= stop_signal
)
644 error ("Cannot send signals to VxWorks processes");
646 bzero ((char *) &ptrace_in
, sizeof (ptrace_in
));
647 bzero ((char *) &ptrace_out
, sizeof (ptrace_out
));
649 ptrace_in
.pid
= inferior_pid
;
650 ptrace_in
.addr
= 1; /* Target side insists on this, or it panics. */
652 /* XXX change second param to be a proc number */
653 status
= net_ptrace_clnt_call (step
? PTRACE_SINGLESTEP
: PTRACE_CONT
,
654 &ptrace_in
, &ptrace_out
);
657 if (ptrace_out
.status
== -1)
659 errno
= ptrace_out
.errno
;
660 perror_with_name ("Resuming remote process");
667 pop_target (); /* Pop back to no-child state */
668 generic_mourn_inferior ();
672 /* This function allows the addition of incrementally linked object files. */
675 vx_load_command (arg_string
, from_tty
)
684 error ("The load command takes a file name");
686 arg_string
= tilde_expand (arg_string
);
687 make_cleanup (free
, arg_string
);
693 if (net_load (arg_string
, &text_addr
, &data_addr
, &bss_addr
) == -1)
694 error ("Load failed on target machine");
697 /* FIXME, for now we ignore data_addr and bss_addr. */
698 symbol_file_add (arg_string
, from_tty
, text_addr
, 0, 0, 0);
701 #ifdef FIXME /* Not ready for prime time */
702 /* Single step the target program at the source or machine level.
703 Takes an error exit if rpc fails.
704 Returns -1 if remote single-step operation fails, else 0. */
709 enum clnt_stat status
;
711 SOURCE_STEP source_step
;
713 source_step
.taskId
= inferior_pid
;
717 source_step
.startAddr
= step_range_start
;
718 source_step
.endAddr
= step_range_end
;
722 source_step
.startAddr
= 0;
723 source_step
.endAddr
= 0;
726 status
= net_clnt_call (VX_SOURCE_STEP
, xdr_SOURCE_STEP
, &source_step
,
727 xdr_int
, &step_status
);
729 if (status
== RPC_SUCCESS
)
736 /* Emulate ptrace using RPC calls to the VxWorks target system.
737 Returns nonzero (-1) if RPC status to VxWorks is bad, 0 otherwise. */
740 net_ptrace_clnt_call (request
, pPtraceIn
, pPtraceOut
)
741 enum ptracereq request
;
743 Ptrace_return
*pPtraceOut
;
745 enum clnt_stat status
;
747 status
= net_clnt_call (request
, xdr_rptrace
, pPtraceIn
, xdr_ptrace_return
,
750 if (status
!= RPC_SUCCESS
)
756 /* Query the target for the name of the file from which VxWorks was
757 booted. pBootFile is the address of a pointer to the buffer to
758 receive the file name; if the pointer pointed to by pBootFile is
759 NULL, memory for the buffer will be allocated by XDR.
760 Returns -1 if rpc failed, 0 otherwise. */
763 net_get_boot_file (pBootFile
)
766 enum clnt_stat status
;
768 status
= net_clnt_call (VX_BOOT_FILE_INQ
, xdr_void
, (char *) 0,
769 xdr_wrapstring
, pBootFile
);
770 return (status
== RPC_SUCCESS
) ? 0 : -1;
773 /* Fetch a list of loaded object modules from the VxWorks target.
774 Returns -1 if rpc failed, 0 otherwise
775 There's no way to check if the returned loadTable is correct.
776 VxWorks doesn't check it. */
779 net_get_symbols (pLoadTable
)
780 ldtabl
*pLoadTable
; /* return pointer to ldtabl here */
782 enum clnt_stat status
;
784 bzero ((char *) pLoadTable
, sizeof (struct ldtabl
));
786 status
= net_clnt_call (VX_STATE_INQ
, xdr_void
, 0, xdr_ldtabl
, pLoadTable
);
787 return (status
== RPC_SUCCESS
) ? 0 : -1;
790 /* Look up a symbol in the VxWorks target's symbol table.
791 Returns status of symbol read on target side (0=success, -1=fail)
792 Returns -1 and complain()s if rpc fails. */
794 struct complaint cant_contact_target
=
795 {"Lost contact with VxWorks target", 0, 0};
798 vx_lookup_symbol (name
, pAddr
)
799 char *name
; /* symbol name */
802 enum clnt_stat status
;
803 SYMBOL_ADDR symbolAddr
;
806 bzero ((char *) &symbolAddr
, sizeof (symbolAddr
));
808 status
= net_clnt_call (VX_SYMBOL_INQ
, xdr_wrapstring
, &name
,
809 xdr_SYMBOL_ADDR
, &symbolAddr
);
810 if (status
!= RPC_SUCCESS
) {
811 complain (&cant_contact_target
, 0);
815 *pAddr
= symbolAddr
.addr
;
816 return symbolAddr
.status
;
819 /* Check to see if the VxWorks target has a floating point coprocessor.
820 Returns 1 if target has floating point processor, 0 otherwise.
821 Calls error() if rpc fails. */
826 enum clnt_stat status
;
827 bool_t fp
= 0; /* true if fp processor is present on target board */
829 status
= net_clnt_call (VX_FP_INQUIRE
, xdr_void
, 0, xdr_bool
, &fp
);
830 if (status
!= RPC_SUCCESS
)
836 /* Establish an RPC connection with the VxWorks target system.
837 Calls error () if unable to establish connection. */
843 struct sockaddr_in destAddr
;
844 struct hostent
*destHost
;
846 /* get the internet address for the given host */
848 if ((destHost
= (struct hostent
*) gethostbyname (host
)) == NULL
)
849 error ("Invalid hostname. Couldn't find remote host address.");
851 bzero (&destAddr
, sizeof (destAddr
));
853 destAddr
.sin_addr
.s_addr
= * (u_long
*) destHost
->h_addr
;
854 destAddr
.sin_family
= AF_INET
;
855 destAddr
.sin_port
= 0; /* set to actual port that remote
856 ptrace is listening on. */
858 /* Create a tcp client transport on which to issue
859 calls to the remote ptrace server. */
861 ptraceSock
= RPC_ANYSOCK
;
862 pClient
= clnttcp_create (&destAddr
, RDBPROG
, RDBVERS
, &ptraceSock
, 0, 0);
863 /* FIXME, here is where we deal with different version numbers of the proto */
867 clnt_pcreateerror ("\tnet_connect");
868 error ("Couldn't connect to remote target.");
872 /* Sleep for the specified number of milliseconds
873 * (assumed to be less than 1000).
874 * If select () is interrupted, returns immediately;
875 * takes an error exit if select () fails for some other reason.
882 struct timeval select_timeout
;
885 select_timeout
.tv_sec
= 0;
886 select_timeout
.tv_usec
= ms
* 1000;
888 status
= select (0, (fd_set
*) 0, (fd_set
*) 0, (fd_set
*) 0, &select_timeout
);
890 if (status
< 0 && errno
!= EINTR
)
891 perror_with_name ("select");
894 /* Wait for control to return from inferior to debugger.
895 If inferior gets a signal, we may decide to start it up again
896 instead of returning. That is why there is a loop in this function.
897 When this function actually returns it means the inferior
898 should be left stopped and GDB should read more commands. */
900 /* For network debugging with VxWorks.
901 * VxWorks knows when tasks hit breakpoints, receive signals, exit, etc,
902 * so vx_wait() receives this information directly from
903 * VxWorks instead of trying to figure out what happenned via a wait() call.
917 /* If CTRL-C is hit during this loop,
918 suspend the inferior process. */
923 quit_failed
= (net_quit () == -1);
927 /* If a net_quit () or net_wait () call has failed,
928 allow the user to break the connection with the target.
929 We can't simply error () out of this loop, since the
930 data structures representing the state of the inferior
931 are in an inconsistent state. */
933 if (quit_failed
|| net_wait (&rdbEvent
) == -1)
936 if (query ("Can't %s. Disconnect from target system? ",
937 (quit_failed
) ? "suspend remote task"
938 : "get status of remote task"))
940 target_mourn_inferior();
941 error ("Use the \"target\" command to reconnect.");
945 terminal_inferior ();
950 pid
= rdbEvent
.taskId
;
953 sleep_ms (200); /* FIXME Don't kill the network too badly */
955 else if (pid
!= inferior_pid
)
956 fatal ("Bad pid for debugged task: %s\n", local_hex_string(pid
));
959 /* FIXME, eventually do more then SIGTRAP on everything... */
960 switch (rdbEvent
.eventType
)
964 /* FIXME is it possible to distinguish between a
965 XXX normal vs abnormal exit in VxWorks? */
968 case EVENT_START
: /* Task was just started. */
969 WSETSTOP (w
, SIGTRAP
);
973 WSETSTOP (w
, SIGTRAP
);
974 /* XXX was it stopped by a signal? act accordingly */
977 case EVENT_BREAK
: /* Breakpoint was hit. */
978 WSETSTOP (w
, SIGTRAP
);
981 case EVENT_SUSPEND
: /* Task was suspended, probably by ^C. */
982 WSETSTOP (w
, SIGINT
);
985 case EVENT_BUS_ERR
: /* Task made evil nasty reference. */
986 WSETSTOP (w
, SIGBUS
);
989 case EVENT_ZERO_DIV
: /* Division by zero */
990 WSETSTOP (w
, SIGFPE
); /* Like Unix, call it a float exception. */
994 /* The target is not running Unix, and its
995 faults/traces do not map nicely into Unix signals.
996 Make sure they do not get confused with Unix signals
997 by numbering them with values higher than the highest
998 legal Unix signal. code in the arch-dependent PRINT_RANDOM_SIGNAL
999 routine will interpret the value for wait_for_inferior. */
1000 WSETSTOP (w
, rdbEvent
.sigType
+ NSIG
);
1003 *status
= *(int *)&w
; /* Grumble union wait crap Grumble */
1011 symbol_file_command (arg
, 0);
1016 add_symbol_stub (arg
)
1019 struct ldfile
*pLoadFile
= (struct ldfile
*)arg
;
1021 printf("\t%s: ", pLoadFile
->name
);
1022 symbol_file_add (pLoadFile
->name
, 0, pLoadFile
->txt_addr
, 0, 0, 0);
1026 /* Target command for VxWorks target systems.
1028 Used in vxgdb. Takes the name of a remote target machine
1029 running vxWorks and connects to it to initialize remote network
1033 vx_open (args
, from_tty
)
1037 extern int close ();
1039 extern char *source_path
;
1040 struct ldtabl loadTable
;
1041 struct ldfile
*pLoadFile
;
1043 extern CLIENT
*pClient
;
1046 error_no_arg ("target machine name");
1048 target_preopen (from_tty
);
1050 unpush_target (&vx_ops
);
1051 printf ("Attaching remote machine across net...\n");
1054 /* Allow the user to kill the connect attempt by typing ^C.
1055 Wait until the call to target_has_fp () completes before
1056 disallowing an immediate quit, since even if net_connect ()
1057 is successful, the remote debug server might be hung. */
1062 target_has_fp
= net_check_for_fp ();
1063 printf_filtered ("Connected to %s.\n", args
);
1067 push_target (&vx_ops
);
1069 /* Save a copy of the target host's name. */
1070 vx_host
= savestring (args
, strlen (args
));
1072 /* Find out the name of the file from which the target was booted
1073 and load its symbol table. */
1075 printf_filtered ("Looking in Unix path for all loaded modules:\n");
1077 if (!net_get_boot_file (&bootFile
))
1080 printf_filtered ("\t%s: ", bootFile
);
1081 if (catch_errors (symbol_stub
, bootFile
,
1082 "Error while reading symbols from boot file:\n"))
1083 puts_filtered ("ok\n");
1084 } else if (from_tty
)
1085 printf ("VxWorks kernel symbols not loaded.\n");
1088 error ("Can't retrieve boot file name from target machine.");
1090 clnt_freeres (pClient
, xdr_wrapstring
, &bootFile
);
1092 if (net_get_symbols (&loadTable
) != 0)
1093 error ("Can't read loaded modules from target machine");
1096 while (++i
< loadTable
.tbl_size
)
1098 QUIT
; /* FIXME, avoids clnt_freeres below: mem leak */
1099 pLoadFile
= &loadTable
.tbl_ent
[i
];
1103 struct cleanup
*old_chain
;
1104 char *fullname
= NULL
;
1106 desc
= openp (source_path
, 0, pLoadFile
->name
, O_RDONLY
, 0, &fullname
);
1108 perror_with_name (pLoadFile
->name
);
1109 old_chain
= make_cleanup (close
, desc
);
1110 add_file_at_addr (fullname
, desc
, pLoadFile
->txt_addr
, pLoadFile
->data_addr
,
1111 pLoadFile
->bss_addr
);
1112 do_cleanups (old_chain
);
1116 (1) Searches the PATH, not the source path.
1117 (2) data and bss are assumed to be at the usual offsets from text. */
1118 catch_errors (add_symbol_stub
, (char *)pLoadFile
, (char *)0);
1121 printf_filtered ("Done.\n");
1123 clnt_freeres (pClient
, xdr_ldtabl
, &loadTable
);
1126 /* attach_command --
1127 takes a task started up outside of gdb and ``attaches'' to it.
1128 This stops it cold in its tracks and allows us to start tracing it. */
1131 vx_attach (args
, from_tty
)
1138 Ptrace_return ptrace_out
;
1144 error_no_arg ("process-id to attach");
1146 pid
= strtol (args
, &cptr
, 0);
1147 if ((cptr
== args
) || (*cptr
!= '\0'))
1148 error ("Invalid process-id -- give a single number in decimal or 0xhex");
1151 printf ("Attaching pid %s.\n", local_hex_string(pid
));
1153 bzero ((char *)&ptrace_in
, sizeof (ptrace_in
));
1154 bzero ((char *)&ptrace_out
, sizeof (ptrace_out
));
1155 ptrace_in
.pid
= pid
;
1157 status
= net_ptrace_clnt_call (PTRACE_ATTACH
, &ptrace_in
, &ptrace_out
);
1160 if (ptrace_out
.status
== -1)
1162 errno
= ptrace_out
.errno
;
1163 perror_with_name ("Attaching remote process");
1167 push_target (&vx_run_ops
);
1171 mark_breakpoints_out ();
1173 /* Set up the "saved terminal modes" of the inferior
1174 based on what modes we are starting it with. */
1175 target_terminal_init ();
1177 /* Install inferior's terminal modes. */
1178 target_terminal_inferior ();
1180 /* We will get a task spawn event immediately. */
1181 init_wait_for_inferior ();
1182 clear_proceed_status ();
1183 stop_soon_quietly
= 1;
1184 wait_for_inferior ();
1185 stop_soon_quietly
= 0;
1190 /* detach_command --
1191 takes a program previously attached to and detaches it.
1192 The program resumes execution and will no longer stop
1193 on signals, etc. We better not have left any breakpoints
1194 in the program or it'll die when it hits one. For this
1195 to work, it may be necessary for the process to have been
1196 previously attached. It *might* work if the program was
1197 started via the normal ptrace (PTRACE_TRACEME). */
1200 vx_detach (args
, from_tty
)
1205 Ptrace_return ptrace_out
;
1210 error ("Argument given to VxWorks \"detach\".");
1213 printf ("Detaching pid %s.\n", local_hex_string(inferior_pid
));
1215 if (args
) /* FIXME, should be possible to leave suspended */
1216 signal
= atoi (args
);
1218 bzero ((char *)&ptrace_in
, sizeof (ptrace_in
));
1219 bzero ((char *)&ptrace_out
, sizeof (ptrace_out
));
1220 ptrace_in
.pid
= inferior_pid
;
1222 status
= net_ptrace_clnt_call (PTRACE_DETACH
, &ptrace_in
, &ptrace_out
);
1225 if (ptrace_out
.status
== -1)
1227 errno
= ptrace_out
.errno
;
1228 perror_with_name ("Detaching VxWorks process");
1232 pop_target (); /* go back to non-executing VxWorks connection */
1235 /* vx_kill -- takes a running task and wipes it out. */
1241 Ptrace_return ptrace_out
;
1244 printf ("Killing pid %s.\n", local_hex_string(inferior_pid
));
1246 bzero ((char *)&ptrace_in
, sizeof (ptrace_in
));
1247 bzero ((char *)&ptrace_out
, sizeof (ptrace_out
));
1248 ptrace_in
.pid
= inferior_pid
;
1250 status
= net_ptrace_clnt_call (PTRACE_KILL
, &ptrace_in
, &ptrace_out
);
1253 if (ptrace_out
.status
== -1)
1255 errno
= ptrace_out
.errno
;
1256 perror_with_name ("Killing VxWorks process");
1259 /* If it gives good status, the process is *gone*, no events remain. */
1261 pop_target (); /* go back to non-executing VxWorks connection */
1264 /* Clean up from the VxWorks process target as it goes away. */
1267 vx_proc_close (quitting
)
1270 inferior_pid
= 0; /* No longer have a process. */
1276 /* Make an RPC call to the VxWorks target.
1277 Returns RPC status. */
1279 static enum clnt_stat
1280 net_clnt_call (procNum
, inProc
, in
, outProc
, out
)
1281 enum ptracereq procNum
;
1287 enum clnt_stat status
;
1289 status
= clnt_call (pClient
, procNum
, inProc
, in
, outProc
, out
, rpcTimeout
);
1291 if (status
!= RPC_SUCCESS
)
1292 clnt_perrno (status
);
1297 /* Clean up before losing control. */
1304 clnt_destroy (pClient
); /* The net connection */
1308 free (vx_host
); /* The hostname */
1312 /* A vxprocess target should be started via "run" not "target". */
1315 vx_proc_open (name
, from_tty
)
1319 error ("Use the \"run\" command to start a VxWorks process.");
1322 /* Target ops structure for accessing memory and such over the net */
1324 struct target_ops vx_ops
= {
1325 "vxworks", "VxWorks target memory via RPC over TCP/IP",
1326 "Use VxWorks target memory. \n\
1327 Specify the name of the machine to connect to.",
1328 vx_open
, vx_close
, vx_attach
, 0, /* vx_detach, */
1329 0, 0, /* resume, wait */
1330 0, 0, /* read_reg, write_reg */
1331 0, host_convert_to_virtual
, host_convert_from_virtual
, /* prep_to_store, */
1332 vx_xfer_memory
, vx_files_info
,
1333 0, 0, /* insert_breakpoint, remove_breakpoint */
1334 0, 0, 0, 0, 0, /* terminal stuff */
1338 vx_create_inferior
, 0, /* mourn_inferior */
1339 core_stratum
, 0, /* next */
1340 1, 1, 0, 0, 0, /* all mem, mem, stack, regs, exec */
1341 0, 0, /* Section pointers */
1342 OPS_MAGIC
, /* Always the last thing */
1345 /* Target ops structure for accessing VxWorks child processes over the net */
1347 struct target_ops vx_run_ops
= {
1348 "vxprocess", "VxWorks process",
1349 "VxWorks process, started by the \"run\" command.",
1350 vx_proc_open
, vx_proc_close
, 0, vx_detach
, /* vx_attach */
1352 vx_read_register
, vx_write_register
,
1353 vx_prepare_to_store
, host_convert_to_virtual
, host_convert_from_virtual
,
1354 vx_xfer_memory
, vx_run_files_info
,
1355 vx_insert_breakpoint
, vx_remove_breakpoint
,
1356 0, 0, 0, 0, 0, /* terminal stuff */
1360 0, vx_mourn_inferior
,
1361 process_stratum
, 0, /* next */
1362 0, 1, 1, 1, 1, /* all mem, mem, stack, regs, exec */
1363 /* all_mem is off to avoid spurious msg in "i files" */
1364 0, 0, /* Section pointers */
1365 OPS_MAGIC
, /* Always the last thing */
1367 /* ==> Remember when reading at end of file, there are two "ops" structs here. */
1372 add_target (&vx_ops
);
1373 add_target (&vx_run_ops
);