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. */
30 #include "symfile.h" /* for struct complaint */
36 #include <sys/types.h>
38 #include <sys/socket.h>
39 #define free bogon_free /* Sun claims "int free()" not void */
42 #include <sys/time.h> /* UTek's <rpc/rpc.h> doesn't #incl this */
45 #include "xdr_ptrace.h"
48 #include "dbgRpcLib.h"
50 /* get rid of value.h if possible */
54 extern void symbol_file_command ();
55 extern int stop_soon_quietly
; /* for wait_for_inferior */
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
== NULL
) /* 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
;
376 struct regs inferior_registers
;
377 struct fp_status inferior_fp_registers
;
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
) &inferior_registers
;
388 status
= net_ptrace_clnt_call (PTRACE_GETREGS
, &ptrace_in
, &ptrace_out
);
391 if (ptrace_out
.status
== -1)
393 errno
= ptrace_out
.errno
;
399 bcopy ((char *) inferior_registers
.r_lreg
,
400 ®isters
[REGISTER_BYTE (R0_REGNUM
)], 16 * sizeof (int));
401 bcopy ((char *) inferior_registers
.r_greg
,
402 ®isters
[REGISTER_BYTE (G0_REGNUM
)], 16 * sizeof (int));
404 /* Don't assume that a location in registers[] is properly aligned. */
406 bcopy ((char *) &inferior_registers
.r_pcw
,
407 ®isters
[REGISTER_BYTE (PCW_REGNUM
)], sizeof (int));
408 bcopy ((char *) &inferior_registers
.r_acw
,
409 ®isters
[REGISTER_BYTE (ACW_REGNUM
)], sizeof (int));
410 bcopy ((char *) &inferior_registers
.r_lreg
[2], /* r2 (RIP) -> IP */
411 ®isters
[REGISTER_BYTE (IP_REGNUM
)], sizeof (int));
412 bcopy ((char *) &inferior_registers
.r_tcw
,
413 ®isters
[REGISTER_BYTE (TCW_REGNUM
)], sizeof (int));
415 /* If the target has floating point registers, fetch them.
416 Otherwise, zero the floating point register values in
417 registers[] for good measure, even though we might not
422 ptrace_in
.pid
= inferior_pid
;
423 ptrace_out
.info
.more_data
= (caddr_t
) &inferior_fp_registers
;
424 status
= net_ptrace_clnt_call (PTRACE_GETFPREGS
, &ptrace_in
, &ptrace_out
);
427 if (ptrace_out
.status
== -1)
429 errno
= ptrace_out
.errno
;
433 bcopy (&inferior_fp_registers
, ®isters
[REGISTER_BYTE (FP0_REGNUM
)],
434 REGISTER_RAW_SIZE (FP0_REGNUM
) * 4);
438 bzero ((char *) ®isters
[REGISTER_BYTE (FP0_REGNUM
)],
439 REGISTER_RAW_SIZE (FP0_REGNUM
) * 4);
442 #else /* not 960, thus must be 68000: FIXME! */
444 bcopy (&inferior_registers
, registers
, 16 * 4);
445 *(int *)®isters
[REGISTER_BYTE (PS_REGNUM
)] = inferior_registers
.r_ps
;
446 *(int *)®isters
[REGISTER_BYTE (PC_REGNUM
)] = inferior_registers
.r_pc
;
450 ptrace_in
.pid
= inferior_pid
;
451 ptrace_out
.info
.more_data
= (caddr_t
) &inferior_fp_registers
;
452 status
= net_ptrace_clnt_call (PTRACE_GETFPREGS
, &ptrace_in
, &ptrace_out
);
455 if (ptrace_out
.status
== -1)
457 errno
= ptrace_out
.errno
;
461 bcopy (&inferior_fp_registers
, ®isters
[REGISTER_BYTE (FP0_REGNUM
)],
462 sizeof inferior_fp_registers
.fps_regs
);
463 bcopy (&inferior_fp_registers
.fps_control
,
464 ®isters
[REGISTER_BYTE (FPC_REGNUM
)],
465 sizeof inferior_fp_registers
- sizeof inferior_fp_registers
.fps_regs
);
469 bzero (®isters
[REGISTER_BYTE (FP0_REGNUM
)],
470 sizeof inferior_fp_registers
.fps_regs
);
471 bzero (®isters
[REGISTER_BYTE (FPC_REGNUM
)],
472 sizeof inferior_fp_registers
- sizeof inferior_fp_registers
.fps_regs
);
474 #endif /* various architectures */
479 /* Prepare to store registers. Since we will store all of them,
480 read out their current values now. */
483 vx_prepare_to_store ()
485 vx_read_register (-1);
489 /* Store our register values back into the inferior.
490 If REGNO is -1, do this for all registers.
491 Otherwise, REGNO specifies which register (so we can save time). */
492 /* FIXME, look at REGNO to save time here */
494 vx_write_register (regno
)
497 struct regs inferior_registers
;
498 struct fp_status inferior_fp_registers
;
499 extern char registers
[];
502 Ptrace_return ptrace_out
;
504 bzero ((char *) &ptrace_in
, sizeof (ptrace_in
));
505 bzero ((char *) &ptrace_out
, sizeof (ptrace_out
));
509 bcopy (®isters
[REGISTER_BYTE (R0_REGNUM
)],
510 (char *) inferior_registers
.r_lreg
, 16 * sizeof (int));
511 bcopy (®isters
[REGISTER_BYTE (G0_REGNUM
)],
512 (char *) inferior_registers
.r_greg
, 16 * sizeof (int));
514 /* Don't assume that a location in registers[] is properly aligned. */
516 bcopy (®isters
[REGISTER_BYTE (PCW_REGNUM
)],
517 (char *) &inferior_registers
.r_pcw
, sizeof (int));
518 bcopy (®isters
[REGISTER_BYTE (ACW_REGNUM
)],
519 (char *) &inferior_registers
.r_acw
, sizeof (int));
520 bcopy (®isters
[REGISTER_BYTE (TCW_REGNUM
)],
521 (char *) &inferior_registers
.r_tcw
, sizeof (int));
523 #else /* not 960 -- assume 68k -- FIXME */
525 bcopy (registers
, &inferior_registers
, 16 * 4);
526 inferior_registers
.r_ps
= *(int *)®isters
[REGISTER_BYTE (PS_REGNUM
)];
527 inferior_registers
.r_pc
= *(int *)®isters
[REGISTER_BYTE (PC_REGNUM
)];
529 #endif /* Different register sets */
531 ptrace_in
.pid
= inferior_pid
;
532 ptrace_in
.info
.ttype
= REGS
;
533 ptrace_in
.info
.more_data
= (caddr_t
) &inferior_registers
;
535 /* XXX change second param to be a proc number */
536 status
= net_ptrace_clnt_call (PTRACE_SETREGS
, &ptrace_in
, &ptrace_out
);
539 if (ptrace_out
.status
== -1)
541 errno
= ptrace_out
.errno
;
545 /* Store floating point registers if the target has them. */
551 bcopy (®isters
[REGISTER_BYTE (FP0_REGNUM
)], &inferior_fp_registers
,
552 sizeof inferior_fp_registers
.fps_regs
);
554 #else /* not 960 -- assume 68k -- FIXME */
556 bcopy (®isters
[REGISTER_BYTE (FP0_REGNUM
)], &inferior_fp_registers
,
557 sizeof inferior_fp_registers
.fps_regs
);
558 bcopy (®isters
[REGISTER_BYTE (FPC_REGNUM
)],
559 &inferior_fp_registers
.fps_control
,
560 sizeof inferior_fp_registers
- sizeof inferior_fp_registers
.fps_regs
);
562 #endif /* Different register sets */
564 ptrace_in
.pid
= inferior_pid
;
565 ptrace_in
.info
.ttype
= FPREGS
;
566 ptrace_in
.info
.more_data
= (caddr_t
) &inferior_fp_registers
;
568 status
= net_ptrace_clnt_call (PTRACE_SETFPREGS
, &ptrace_in
, &ptrace_out
);
571 if (ptrace_out
.status
== -1)
573 errno
= ptrace_out
.errno
;
580 /* Copy LEN bytes to or from remote inferior's memory starting at MEMADDR
581 to debugger memory starting at MYADDR. WRITE is true if writing to the
583 Result is the number of bytes written or read (zero if error). The
584 protocol allows us to return a negative count, indicating that we can't
585 handle the current address but can handle one N bytes further, but
586 vxworks doesn't give us that information. */
589 vx_xfer_memory (memaddr
, myaddr
, len
, write
, target
)
594 struct target_ops
*target
; /* ignored */
598 Ptrace_return ptrace_out
;
601 bzero ((char *) &ptrace_in
, sizeof (ptrace_in
));
602 bzero ((char *) &ptrace_out
, sizeof (ptrace_out
));
604 ptrace_in
.pid
= inferior_pid
; /* XXX pid unnecessary for READDATA */
605 ptrace_in
.addr
= (int) memaddr
; /* Where from */
606 ptrace_in
.data
= len
; /* How many bytes */
610 ptrace_in
.info
.ttype
= DATA
;
611 ptrace_in
.info
.more_data
= (caddr_t
) &data
;
613 data
.bytes
= (caddr_t
) myaddr
; /* Where from */
614 data
.len
= len
; /* How many bytes (again, for XDR) */
616 /* XXX change second param to be a proc number */
617 status
= net_ptrace_clnt_call (PTRACE_WRITEDATA
, &ptrace_in
, &ptrace_out
);
621 ptrace_out
.info
.more_data
= (caddr_t
) &data
;
622 data
.bytes
= myaddr
; /* Where to */
623 data
.len
= len
; /* How many (again, for XDR) */
625 /* XXX change second param to be a proc number */
626 status
= net_ptrace_clnt_call (PTRACE_READDATA
, &ptrace_in
, &ptrace_out
);
631 if (ptrace_out
.status
== -1)
633 return 0; /* No bytes moved */
635 return len
; /* Moved *all* the bytes */
641 printf ("\tAttached to host `%s'", vx_host
);
642 printf (", which has %sfloating point", target_has_fp
? "": "no ");
649 printf ("\tRunning %s VxWorks process %s",
650 vx_running
? "child": "attached",
651 local_hex_string(inferior_pid
));
653 printf (", function `%s'", vx_running
);
658 vx_resume (step
, siggnal
)
664 Ptrace_return ptrace_out
;
666 if (siggnal
!= 0 && siggnal
!= stop_signal
)
667 error ("Cannot send signals to VxWorks processes");
669 bzero ((char *) &ptrace_in
, sizeof (ptrace_in
));
670 bzero ((char *) &ptrace_out
, sizeof (ptrace_out
));
672 ptrace_in
.pid
= inferior_pid
;
673 ptrace_in
.addr
= 1; /* Target side insists on this, or it panics. */
675 /* XXX change second param to be a proc number */
676 status
= net_ptrace_clnt_call (step
? PTRACE_SINGLESTEP
: PTRACE_CONT
,
677 &ptrace_in
, &ptrace_out
);
680 if (ptrace_out
.status
== -1)
682 errno
= ptrace_out
.errno
;
683 perror_with_name ("Resuming remote process");
690 pop_target (); /* Pop back to no-child state */
691 generic_mourn_inferior ();
695 /* This function allows the addition of incrementally linked object files. */
698 vx_load_command (arg_string
, from_tty
)
707 error ("The load command takes a file name");
709 arg_string
= tilde_expand (arg_string
);
710 make_cleanup (free
, arg_string
);
716 if (net_load (arg_string
, &text_addr
, &data_addr
, &bss_addr
) == -1)
717 error ("Load failed on target machine");
720 /* FIXME, for now we ignore data_addr and bss_addr. */
721 symbol_file_add (arg_string
, from_tty
, text_addr
, 0);
724 #ifdef FIXME /* Not ready for prime time */
725 /* Single step the target program at the source or machine level.
726 Takes an error exit if rpc fails.
727 Returns -1 if remote single-step operation fails, else 0. */
732 enum clnt_stat status
;
734 SOURCE_STEP source_step
;
736 source_step
.taskId
= inferior_pid
;
740 source_step
.startAddr
= step_range_start
;
741 source_step
.endAddr
= step_range_end
;
745 source_step
.startAddr
= 0;
746 source_step
.endAddr
= 0;
749 status
= net_clnt_call (VX_SOURCE_STEP
, xdr_SOURCE_STEP
, &source_step
,
750 xdr_int
, &step_status
);
752 if (status
== RPC_SUCCESS
)
759 /* Emulate ptrace using RPC calls to the VxWorks target system.
760 Returns nonzero (-1) if RPC status to VxWorks is bad, 0 otherwise. */
763 net_ptrace_clnt_call (request
, pPtraceIn
, pPtraceOut
)
764 enum ptracereq request
;
766 Ptrace_return
*pPtraceOut
;
768 enum clnt_stat status
;
770 status
= net_clnt_call (request
, xdr_rptrace
, pPtraceIn
, xdr_ptrace_return
,
773 if (status
!= RPC_SUCCESS
)
779 /* Query the target for the name of the file from which VxWorks was
780 booted. pBootFile is the address of a pointer to the buffer to
781 receive the file name; if the pointer pointed to by pBootFile is
782 NULL, memory for the buffer will be allocated by XDR.
783 Returns -1 if rpc failed, 0 otherwise. */
786 net_get_boot_file (pBootFile
)
789 enum clnt_stat status
;
791 status
= net_clnt_call (VX_BOOT_FILE_INQ
, xdr_void
, (char *) 0,
792 xdr_wrapstring
, pBootFile
);
793 return (status
== RPC_SUCCESS
) ? 0 : -1;
796 /* Fetch a list of loaded object modules from the VxWorks target.
797 Returns -1 if rpc failed, 0 otherwise
798 There's no way to check if the returned loadTable is correct.
799 VxWorks doesn't check it. */
802 net_get_symbols (pLoadTable
)
803 ldtabl
*pLoadTable
; /* return pointer to ldtabl here */
805 enum clnt_stat status
;
807 bzero ((char *) pLoadTable
, sizeof (struct ldtabl
));
809 status
= net_clnt_call (VX_STATE_INQ
, xdr_void
, 0, xdr_ldtabl
, pLoadTable
);
810 return (status
== RPC_SUCCESS
) ? 0 : -1;
813 /* Look up a symbol in the VxWorks target's symbol table.
814 Returns status of symbol read on target side (0=success, -1=fail)
815 Returns -1 and complain()s if rpc fails. */
817 struct complaint cant_contact_target
=
818 {"Lost contact with VxWorks target", 0, 0};
821 vx_lookup_symbol (name
, pAddr
)
822 char *name
; /* symbol name */
825 enum clnt_stat status
;
826 SYMBOL_ADDR symbolAddr
;
829 bzero ((char *) &symbolAddr
, sizeof (symbolAddr
));
831 status
= net_clnt_call (VX_SYMBOL_INQ
, xdr_wrapstring
, &name
,
832 xdr_SYMBOL_ADDR
, &symbolAddr
);
833 if (status
!= RPC_SUCCESS
) {
834 complain (&cant_contact_target
, 0);
838 *pAddr
= symbolAddr
.addr
;
839 return symbolAddr
.status
;
842 /* Check to see if the VxWorks target has a floating point coprocessor.
843 Returns 1 if target has floating point processor, 0 otherwise.
844 Calls error() if rpc fails. */
849 enum clnt_stat status
;
850 bool_t fp
= 0; /* true if fp processor is present on target board */
852 status
= net_clnt_call (VX_FP_INQUIRE
, xdr_void
, 0, xdr_bool
, &fp
);
853 if (status
!= RPC_SUCCESS
)
859 /* Establish an RPC connection with the VxWorks target system.
860 Calls error () if unable to establish connection. */
866 struct sockaddr_in destAddr
;
867 struct hostent
*destHost
;
869 /* get the internet address for the given host */
871 if ((destHost
= (struct hostent
*) gethostbyname (host
)) == NULL
)
872 error ("Invalid hostname. Couldn't find remote host address.");
874 bzero (&destAddr
, sizeof (destAddr
));
876 destAddr
.sin_addr
.s_addr
= * (u_long
*) destHost
->h_addr
;
877 destAddr
.sin_family
= AF_INET
;
878 destAddr
.sin_port
= 0; /* set to actual port that remote
879 ptrace is listening on. */
881 /* Create a tcp client transport on which to issue
882 calls to the remote ptrace server. */
884 ptraceSock
= RPC_ANYSOCK
;
885 pClient
= clnttcp_create (&destAddr
, RDBPROG
, RDBVERS
, &ptraceSock
, 0, 0);
886 /* FIXME, here is where we deal with different version numbers of the proto */
890 clnt_pcreateerror ("\tnet_connect");
891 error ("Couldn't connect to remote target.");
895 /* Sleep for the specified number of milliseconds
896 * (assumed to be less than 1000).
897 * If select () is interrupted, returns immediately;
898 * takes an error exit if select () fails for some other reason.
905 struct timeval select_timeout
;
908 select_timeout
.tv_sec
= 0;
909 select_timeout
.tv_usec
= ms
* 1000;
911 status
= select (0, (fd_set
*) 0, (fd_set
*) 0, (fd_set
*) 0, &select_timeout
);
913 if (status
< 0 && errno
!= EINTR
)
914 perror_with_name ("select");
917 /* Wait for control to return from inferior to debugger.
918 If inferior gets a signal, we may decide to start it up again
919 instead of returning. That is why there is a loop in this function.
920 When this function actually returns it means the inferior
921 should be left stopped and GDB should read more commands. */
923 /* For network debugging with VxWorks.
924 * VxWorks knows when tasks hit breakpoints, receive signals, exit, etc,
925 * so vx_wait() receives this information directly from
926 * VxWorks instead of trying to figure out what happenned via a wait() call.
940 /* If CTRL-C is hit during this loop,
941 suspend the inferior process. */
946 quit_failed
= (net_quit () == -1);
950 /* If a net_quit () or net_wait () call has failed,
951 allow the user to break the connection with the target.
952 We can't simply error () out of this loop, since the
953 data structures representing the state of the inferior
954 are in an inconsistent state. */
956 if (quit_failed
|| net_wait (&rdbEvent
) == -1)
959 if (query ("Can't %s. Disconnect from target system? ",
960 (quit_failed
) ? "suspend remote task"
961 : "get status of remote task"))
963 target_mourn_inferior();
964 error ("Use the \"target\" command to reconnect.");
968 terminal_inferior ();
973 pid
= rdbEvent
.taskId
;
976 sleep_ms (200); /* FIXME Don't kill the network too badly */
978 else if (pid
!= inferior_pid
)
979 fatal ("Bad pid for debugged task: %s\n", local_hex_string(pid
));
982 /* FIXME, eventually do more then SIGTRAP on everything... */
983 switch (rdbEvent
.eventType
)
987 /* FIXME is it possible to distinguish between a
988 XXX normal vs abnormal exit in VxWorks? */
991 case EVENT_START
: /* Task was just started. */
992 WSETSTOP (w
, SIGTRAP
);
996 WSETSTOP (w
, SIGTRAP
);
997 /* XXX was it stopped by a signal? act accordingly */
1000 case EVENT_BREAK
: /* Breakpoint was hit. */
1001 WSETSTOP (w
, SIGTRAP
);
1004 case EVENT_SUSPEND
: /* Task was suspended, probably by ^C. */
1005 WSETSTOP (w
, SIGINT
);
1008 case EVENT_BUS_ERR
: /* Task made evil nasty reference. */
1009 WSETSTOP (w
, SIGBUS
);
1012 case EVENT_ZERO_DIV
: /* Division by zero */
1013 WSETSTOP (w
, SIGFPE
); /* Like Unix, call it a float exception. */
1016 /* The target is not running Unix, and its
1017 faults/traces do not map nicely into Unix signals.
1018 Make sure they do not get confused with Unix signals
1019 by numbering them with values higher than the highest
1020 legal Unix signal. code in the arch-dependent PRINT_RANDOM_SIGNAL
1021 routine will interpret the value for wait_for_inferior. */
1022 WSETSTOP (w
, rdbEvent
.sigType
+ NSIG
);
1025 *status
= *(int *)&w
; /* Grumble union wait crap Grumble */
1033 symbol_file_command (arg
, 0);
1038 add_symbol_stub (arg
)
1041 struct ldfile
*pLoadFile
= (struct ldfile
*)arg
;
1043 printf("\t%s: ", pLoadFile
->name
);
1044 symbol_file_add (pLoadFile
->name
, 0, pLoadFile
->txt_addr
, 0);
1048 /* Target command for VxWorks target systems.
1050 Used in vxgdb. Takes the name of a remote target machine
1051 running vxWorks and connects to it to initialize remote network
1055 vx_open (args
, from_tty
)
1059 extern int close ();
1061 extern char *source_path
;
1062 struct ldtabl loadTable
;
1063 struct ldfile
*pLoadFile
;
1065 extern CLIENT
*pClient
;
1068 error_no_arg ("target machine name");
1070 target_preopen (from_tty
);
1072 unpush_target (&vx_ops
);
1073 printf ("Attaching remote machine across net...\n");
1076 /* Allow the user to kill the connect attempt by typing ^C.
1077 Wait until the call to target_has_fp () completes before
1078 disallowing an immediate quit, since even if net_connect ()
1079 is successful, the remote debug server might be hung. */
1084 target_has_fp
= net_check_for_fp ();
1085 printf_filtered ("Connected to %s.\n", args
);
1089 push_target (&vx_ops
);
1091 /* Save a copy of the target host's name. */
1092 vx_host
= savestring (args
, strlen (args
));
1094 /* Find out the name of the file from which the target was booted
1095 and load its symbol table. */
1097 printf_filtered ("Looking in Unix path for all loaded modules:\n");
1099 if (!net_get_boot_file (&bootFile
))
1102 printf_filtered ("\t%s: ", bootFile
);
1103 if (catch_errors (symbol_stub
, bootFile
,
1104 "Error while reading symbols from boot file:\n"))
1105 puts_filtered ("ok\n");
1106 } else if (from_tty
)
1107 printf ("VxWorks kernel symbols not loaded.\n");
1110 error ("Can't retrieve boot file name from target machine.");
1112 clnt_freeres (pClient
, xdr_wrapstring
, &bootFile
);
1114 if (net_get_symbols (&loadTable
) != 0)
1115 error ("Can't read loaded modules from target machine");
1118 while (++i
< loadTable
.tbl_size
)
1120 QUIT
; /* FIXME, avoids clnt_freeres below: mem leak */
1121 pLoadFile
= &loadTable
.tbl_ent
[i
];
1125 struct cleanup
*old_chain
;
1126 char *fullname
= NULL
;
1128 desc
= openp (source_path
, 0, pLoadFile
->name
, O_RDONLY
, 0, &fullname
);
1130 perror_with_name (pLoadFile
->name
);
1131 old_chain
= make_cleanup (close
, desc
);
1132 add_file_at_addr (fullname
, desc
, pLoadFile
->txt_addr
, pLoadFile
->data_addr
,
1133 pLoadFile
->bss_addr
);
1134 do_cleanups (old_chain
);
1138 (1) Searches the PATH, not the source path.
1139 (2) data and bss are assumed to be at the usual offsets from text. */
1140 catch_errors (add_symbol_stub
, (char *)pLoadFile
, (char *)0);
1143 printf_filtered ("Done.\n");
1145 clnt_freeres (pClient
, xdr_ldtabl
, &loadTable
);
1148 /* attach_command --
1149 takes a task started up outside of gdb and ``attaches'' to it.
1150 This stops it cold in its tracks and allows us to start tracing it. */
1153 vx_attach (args
, from_tty
)
1160 Ptrace_return ptrace_out
;
1166 error_no_arg ("process-id to attach");
1168 pid
= strtol (args
, &cptr
, 0);
1169 if ((cptr
== args
) || (*cptr
!= '\0'))
1170 error ("Invalid process-id -- give a single number in decimal or 0xhex");
1173 printf ("Attaching pid %s.\n", local_hex_string(pid
));
1175 bzero ((char *)&ptrace_in
, sizeof (ptrace_in
));
1176 bzero ((char *)&ptrace_out
, sizeof (ptrace_out
));
1177 ptrace_in
.pid
= pid
;
1179 status
= net_ptrace_clnt_call (PTRACE_ATTACH
, &ptrace_in
, &ptrace_out
);
1182 if (ptrace_out
.status
== -1)
1184 errno
= ptrace_out
.errno
;
1185 perror_with_name ("Attaching remote process");
1189 push_target (&vx_run_ops
);
1193 mark_breakpoints_out ();
1195 /* Set up the "saved terminal modes" of the inferior
1196 based on what modes we are starting it with. */
1197 target_terminal_init ();
1199 /* Install inferior's terminal modes. */
1200 target_terminal_inferior ();
1202 /* We will get a task spawn event immediately. */
1203 init_wait_for_inferior ();
1204 clear_proceed_status ();
1205 stop_soon_quietly
= 1;
1206 wait_for_inferior ();
1207 stop_soon_quietly
= 0;
1212 /* detach_command --
1213 takes a program previously attached to and detaches it.
1214 The program resumes execution and will no longer stop
1215 on signals, etc. We better not have left any breakpoints
1216 in the program or it'll die when it hits one. For this
1217 to work, it may be necessary for the process to have been
1218 previously attached. It *might* work if the program was
1219 started via the normal ptrace (PTRACE_TRACEME). */
1222 vx_detach (args
, from_tty
)
1227 Ptrace_return ptrace_out
;
1232 error ("Argument given to VxWorks \"detach\".");
1235 printf ("Detaching pid %s.\n", local_hex_string(inferior_pid
));
1237 if (args
) /* FIXME, should be possible to leave suspended */
1238 signal
= atoi (args
);
1240 bzero ((char *)&ptrace_in
, sizeof (ptrace_in
));
1241 bzero ((char *)&ptrace_out
, sizeof (ptrace_out
));
1242 ptrace_in
.pid
= inferior_pid
;
1244 status
= net_ptrace_clnt_call (PTRACE_DETACH
, &ptrace_in
, &ptrace_out
);
1247 if (ptrace_out
.status
== -1)
1249 errno
= ptrace_out
.errno
;
1250 perror_with_name ("Detaching VxWorks process");
1254 pop_target (); /* go back to non-executing VxWorks connection */
1257 /* vx_kill -- takes a running task and wipes it out. */
1260 vx_kill (args
, from_tty
)
1265 Ptrace_return ptrace_out
;
1269 error ("Argument given to VxWorks \"kill\".");
1272 printf ("Killing pid %s.\n", local_hex_string(inferior_pid
));
1274 bzero ((char *)&ptrace_in
, sizeof (ptrace_in
));
1275 bzero ((char *)&ptrace_out
, sizeof (ptrace_out
));
1276 ptrace_in
.pid
= inferior_pid
;
1278 status
= net_ptrace_clnt_call (PTRACE_KILL
, &ptrace_in
, &ptrace_out
);
1281 if (ptrace_out
.status
== -1)
1283 errno
= ptrace_out
.errno
;
1284 perror_with_name ("Killing VxWorks process");
1287 /* If it gives good status, the process is *gone*, no events remain. */
1289 pop_target (); /* go back to non-executing VxWorks connection */
1292 /* Clean up from the VxWorks process target as it goes away. */
1295 vx_proc_close (quitting
)
1298 inferior_pid
= 0; /* No longer have a process. */
1304 /* Cross-net conversion of floats to and from extended form.
1305 (This is needed because different target machines have different
1306 extended floating point formats.) */
1308 /* Convert from an extended float to a double.
1310 The extended float is stored as raw data pointed to by FROM.
1311 Return the converted value as raw data in the double pointed to by TO.
1315 vx_convert_to_virtual (regno
, from
, to
)
1320 enum clnt_stat status
;
1322 if (REGISTER_CONVERTIBLE (regno
))
1324 if (!target_has_fp
) {
1325 *(double *)to
= 0.0; /* Skip the trouble if no float anyway */
1329 status
= net_clnt_call (VX_CONV_FROM_68881
, xdr_ext_fp
, from
,
1332 if (status
== RPC_SUCCESS
)
1338 bcopy (from
, to
, REGISTER_VIRTUAL_SIZE (regno
));
1342 /* The converse: convert from a double to an extended float.
1344 The double is stored as raw data pointed to by FROM.
1345 Return the converted value as raw data in the extended
1346 float pointed to by TO.
1350 vx_convert_from_virtual (regno
, from
, to
)
1355 enum clnt_stat status
;
1357 if (REGISTER_CONVERTIBLE (regno
))
1359 if (!target_has_fp
) {
1360 bzero (to
, REGISTER_RAW_SIZE (FP0_REGNUM
)); /* Shrug */
1364 status
= net_clnt_call (VX_CONV_TO_68881
, xdr_double
, from
,
1366 if (status
== RPC_SUCCESS
)
1372 bcopy (from
, to
, REGISTER_VIRTUAL_SIZE (regno
));
1375 /* Make an RPC call to the VxWorks target.
1376 Returns RPC status. */
1378 static enum clnt_stat
1379 net_clnt_call (procNum
, inProc
, in
, outProc
, out
)
1380 enum ptracereq procNum
;
1386 enum clnt_stat status
;
1388 status
= clnt_call (pClient
, procNum
, inProc
, in
, outProc
, out
, rpcTimeout
);
1390 if (status
!= RPC_SUCCESS
)
1391 clnt_perrno (status
);
1396 /* Clean up before losing control. */
1403 clnt_destroy (pClient
); /* The net connection */
1407 free (vx_host
); /* The hostname */
1411 /* A vxprocess target should be started via "run" not "target". */
1414 vx_proc_open (name
, from_tty
)
1418 error ("Use the \"run\" command to start a VxWorks process.");
1421 /* Target ops structure for accessing memory and such over the net */
1423 struct target_ops vx_ops
= {
1424 "vxworks", "VxWorks target memory via RPC over TCP/IP",
1425 "Use VxWorks target memory. \n\
1426 Specify the name of the machine to connect to.",
1427 vx_open
, vx_close
, vx_attach
, 0, /* vx_detach, */
1428 0, 0, /* resume, wait */
1429 0, 0, /* read_reg, write_reg */
1430 0, vx_convert_to_virtual
, vx_convert_from_virtual
, /* prep_to_store, */
1431 vx_xfer_memory
, vx_files_info
,
1432 0, 0, /* insert_breakpoint, remove_breakpoint */
1433 0, 0, 0, 0, 0, /* terminal stuff */
1437 vx_create_inferior
, 0, /* mourn_inferior */
1438 core_stratum
, 0, /* next */
1439 1, 1, 0, 0, 0, /* all mem, mem, stack, regs, exec */
1440 0, 0, /* Section pointers */
1441 OPS_MAGIC
, /* Always the last thing */
1444 /* Target ops structure for accessing VxWorks child processes over the net */
1446 struct target_ops vx_run_ops
= {
1447 "vxprocess", "VxWorks process",
1448 "VxWorks process, started by the \"run\" command.",
1449 vx_proc_open
, vx_proc_close
, 0, vx_detach
, /* vx_attach */
1451 vx_read_register
, vx_write_register
,
1452 vx_prepare_to_store
, vx_convert_to_virtual
, vx_convert_from_virtual
,
1453 vx_xfer_memory
, vx_run_files_info
,
1454 vx_insert_breakpoint
, vx_remove_breakpoint
,
1455 0, 0, 0, 0, 0, /* terminal stuff */
1459 0, vx_mourn_inferior
,
1460 process_stratum
, 0, /* next */
1461 0, 1, 1, 1, 1, /* all mem, mem, stack, regs, exec */
1462 /* all_mem is off to avoid spurious msg in "i files" */
1463 0, 0, /* Section pointers */
1464 OPS_MAGIC
, /* Always the last thing */
1466 /* ==> Remember when reading at end of file, there are two "ops" structs here. */
1471 add_target (&vx_ops
);
1472 add_target (&vx_run_ops
);