/* Memory-access and commands for remote VxWorks processes, for GDB.
- Copyright (C) 1990-1991 Free Software Foundation, Inc.
+ Copyright 1990, 1991, 1992 Free Software Foundation, Inc.
Contributed by Wind River Systems and Cygnus Support.
This file is part of GDB.
Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */
#include "defs.h"
-#include "param.h"
#include "frame.h"
#include "inferior.h"
#include "wait.h"
#include "gdbcore.h"
#include "command.h"
#include "symtab.h"
-#include "symfile.h" /* for struct complaint */
+#include "complaints.h"
+#include "gdbcmd.h"
-#include <stdio.h>
#include <string.h>
#include <errno.h>
#include <signal.h>
#include <fcntl.h>
#include <sys/types.h>
-#include <sys/time.h>
#include <sys/socket.h>
+#define malloc bogon_malloc /* Sun claims "char *malloc()" not void * */
#define free bogon_free /* Sun claims "int free()" not void */
+#define realloc bogon_realloc /* Sun claims "char *realloc()", not void * */
#include <rpc/rpc.h>
+#undef malloc
#undef free
+#undef realloc
#include <sys/time.h> /* UTek's <rpc/rpc.h> doesn't #incl this */
#include <netdb.h>
-#include <ptrace.h>
-#include "xdr_ptrace.h"
-#include "xdr_ld.h"
-#include "xdr_rdb.h"
-#include "dbgRpcLib.h"
-
-/* get rid of value.h if possible */
-#include <value.h>
+#include "vx-share/ptrace.h"
+#include "vx-share/xdr_ptrace.h"
+#include "vx-share/xdr_ld.h"
+#include "vx-share/xdr_rdb.h"
+#include "vx-share/dbgRpcLib.h"
+
#include <symtab.h>
-
-extern value call_function_by_hand ();
+
extern void symbol_file_command ();
extern int stop_soon_quietly; /* for wait_for_inferior */
/* Tell the VxWorks target system to download a file.
The load addresses of the text, data, and bss segments are
- stored in pTextAddr, pDataAddr, and *pBssAddr (respectively).
+ stored in *pTextAddr, *pDataAddr, and *pBssAddr (respectively).
Returns 0 for success, -1 for failure. */
static int
struct ldfile ldstruct;
struct timeval load_timeout;
- bzero ((char *) &ldstruct, sizeof (ldstruct));
+ memset ((char *) &ldstruct, '\0', sizeof (ldstruct));
/* We invoke clnt_call () here directly, instead of through
net_clnt_call (), because we need to set a large timeout value.
The load on the target side can take quite a while, easily
more than 10 seconds. The user can kill this call by typing
CTRL-C if there really is a problem with the load.
-
+
Do not change the tv_sec value without checking -- select() imposes
a limit of 10**8 on it for no good reason that I can see... */
if (status == RPC_SUCCESS)
{
- if (*ldstruct.name == NULL) /* load failed on VxWorks side */
+ if (*ldstruct.name == 0) /* load failed on VxWorks side */
return -1;
*pTextAddr = ldstruct.txt_addr;
*pDataAddr = ldstruct.data_addr;
Rptrace ptrace_in; /* XXX This is stupid. It doesn't need to be a ptrace
structure. How about something smaller? */
- bzero ((char *) &ptrace_in, sizeof (ptrace_in));
+ memset ((char *) &ptrace_in, '\0', sizeof (ptrace_in));
break_status = 0;
ptrace_in.addr = addr;
/* returns 0 if successful, errno otherwise */
-int
+static int
vx_insert_breakpoint (addr)
int addr;
{
/* returns 0 if successful, errno otherwise */
-int
+static int
vx_remove_breakpoint (addr)
int addr;
{
Returns process id. Errors reported with error().
On VxWorks, we ignore exec_file. */
-void
+static void
vx_create_inferior (exec_file, args, env)
char *exec_file;
char *args;
arg_array passArgs;
TASK_START taskStart;
- bzero ((char *) &passArgs, sizeof (passArgs));
- bzero ((char *) &taskStart, sizeof (taskStart));
+ memset ((char *) &passArgs, '\0', sizeof (passArgs));
+ memset ((char *) &taskStart, '\0', sizeof (taskStart));
/* parse arguments, put them in passArgs */
push_target (&vx_run_ops);
inferior_pid = taskStart.pid;
-#if defined (START_INFERIOR_HOOK)
- START_INFERIOR_HOOK ();
-#endif
-
/* We will get a trace trap after one instruction.
Insert breakpoints and continue. */
/* Install inferior's terminal modes. */
target_terminal_inferior ();
- /* remote_start(args); */
- /* trap_expected = 0; */
stop_soon_quietly = 1;
wait_for_inferior (); /* Get the task spawn event */
stop_soon_quietly = 0;
register int arg_index = 0;
register char *p0;
- bzero ((char *) arg_struct, sizeof (arg_array));
+ memset ((char *) arg_struct, '\0', sizeof (arg_array));
/* first count how many arguments there are */
to the debugged task.
Returns -1 if remote wait failed, task status otherwise. */
-int
+static int
net_wait (pEvent)
RDB_EVENT *pEvent;
{
int pid;
enum clnt_stat status;
- bzero ((char *) pEvent, sizeof (RDB_EVENT));
+ memset ((char *) pEvent, '\0', sizeof (RDB_EVENT));
pid = inferior_pid;
status = net_clnt_call (PROCESS_WAIT, xdr_int, &pid, xdr_RDB_EVENT, pEvent);
/* Suspend the remote task.
Returns -1 if suspend fails on target system, 0 otherwise. */
-int
+static int
net_quit ()
{
int pid;
/* Read a register or registers from the remote system. */
-int
+static void
vx_read_register (regno)
int regno;
{
int status;
Rptrace ptrace_in;
Ptrace_return ptrace_out;
- struct regs inferior_registers;
- struct fp_status inferior_fp_registers;
+ C_bytes in_data;
+ C_bytes out_data;
extern char registers[];
- bzero ((char *) &ptrace_in, sizeof (ptrace_in));
- bzero ((char *) &ptrace_out, sizeof (ptrace_out));
+ memset ((char *) &ptrace_in, '\0', sizeof (ptrace_in));
+ memset ((char *) &ptrace_out, '\0', sizeof (ptrace_out));
/* FIXME, eventually only get the ones we need. */
registers_fetched ();
ptrace_in.pid = inferior_pid;
- ptrace_out.info.more_data = (caddr_t) &inferior_registers;
+ ptrace_out.info.more_data = (caddr_t) &out_data;
+ out_data.len = VX_NUM_REGS * REGISTER_RAW_SIZE (0);
+ out_data.bytes = (caddr_t) registers;
+
status = net_ptrace_clnt_call (PTRACE_GETREGS, &ptrace_in, &ptrace_out);
if (status)
error (rpcerr);
if (ptrace_out.status == -1)
{
errno = ptrace_out.errno;
- return -1;
+ perror_with_name ("net_ptrace_clnt_call(PTRACE_GETREGS)");
}
-#ifdef I80960
-
- bcopy ((char *) inferior_registers.r_lreg,
- ®isters[REGISTER_BYTE (R0_REGNUM)], 16 * sizeof (int));
- bcopy ((char *) inferior_registers.r_greg,
- ®isters[REGISTER_BYTE (G0_REGNUM)], 16 * sizeof (int));
-
- /* Don't assume that a location in registers[] is properly aligned. */
-
- bcopy ((char *) &inferior_registers.r_pcw,
- ®isters[REGISTER_BYTE (PCW_REGNUM)], sizeof (int));
- bcopy ((char *) &inferior_registers.r_acw,
- ®isters[REGISTER_BYTE (ACW_REGNUM)], sizeof (int));
- bcopy ((char *) &inferior_registers.r_lreg[2], /* r2 (RIP) -> IP */
- ®isters[REGISTER_BYTE (IP_REGNUM)], sizeof (int));
- bcopy ((char *) &inferior_registers.r_tcw,
- ®isters[REGISTER_BYTE (TCW_REGNUM)], sizeof (int));
-
- /* If the target has floating point registers, fetch them.
- Otherwise, zero the floating point register values in
- registers[] for good measure, even though we might not
- need to. */
-
- if (target_has_fp)
- {
- ptrace_in.pid = inferior_pid;
- ptrace_out.info.more_data = (caddr_t) &inferior_fp_registers;
- status = net_ptrace_clnt_call (PTRACE_GETFPREGS, &ptrace_in, &ptrace_out);
- if (status)
- error (rpcerr);
- if (ptrace_out.status == -1)
- {
- errno = ptrace_out.errno;
- return -1;
- }
-
- bcopy (&inferior_fp_registers, ®isters[REGISTER_BYTE (FP0_REGNUM)],
- REGISTER_RAW_SIZE (FP0_REGNUM) * 4);
- }
- else
- {
- bzero ((char *) ®isters[REGISTER_BYTE (FP0_REGNUM)],
- REGISTER_RAW_SIZE (FP0_REGNUM) * 4);
- }
-
-#else /* not 960, thus must be 68000: FIXME! */
-
- bcopy (&inferior_registers, registers, 16 * 4);
- *(int *)®isters[REGISTER_BYTE (PS_REGNUM)] = inferior_registers.r_ps;
- *(int *)®isters[REGISTER_BYTE (PC_REGNUM)] = inferior_registers.r_pc;
+#ifdef VX_SIZE_FPREGS
+ /* If the target has floating point registers, fetch them.
+ Otherwise, zero the floating point register values in
+ registers[] for good measure, even though we might not
+ need to. */
if (target_has_fp)
{
ptrace_in.pid = inferior_pid;
- ptrace_out.info.more_data = (caddr_t) &inferior_fp_registers;
+ ptrace_out.info.more_data = (caddr_t) &out_data;
+ out_data.len = VX_SIZE_FPREGS;
+ out_data.bytes = (caddr_t) ®isters[REGISTER_BYTE (FP0_REGNUM)];
+
status = net_ptrace_clnt_call (PTRACE_GETFPREGS, &ptrace_in, &ptrace_out);
if (status)
error (rpcerr);
if (ptrace_out.status == -1)
{
errno = ptrace_out.errno;
- return -1;
+ perror_with_name ("net_ptrace_clnt_call(PTRACE_GETFPREGS)");
}
-
- bcopy (&inferior_fp_registers, ®isters[REGISTER_BYTE (FP0_REGNUM)],
- sizeof inferior_fp_registers.fps_regs);
- bcopy (&inferior_fp_registers.fps_control,
- ®isters[REGISTER_BYTE (FPC_REGNUM)],
- sizeof inferior_fp_registers - sizeof inferior_fp_registers.fps_regs);
}
else
{
- bzero (®isters[REGISTER_BYTE (FP0_REGNUM)],
- sizeof inferior_fp_registers.fps_regs);
- bzero (®isters[REGISTER_BYTE (FPC_REGNUM)],
- sizeof inferior_fp_registers - sizeof inferior_fp_registers.fps_regs);
+ memset (®isters[REGISTER_BYTE (FP0_REGNUM)], '\0', VX_SIZE_FPREGS);
}
-#endif /* various architectures */
-
- return 0;
+#endif /* VX_SIZE_FPREGS */
}
/* Prepare to store registers. Since we will store all of them,
read out their current values now. */
-void
+static void
vx_prepare_to_store ()
{
- vx_read_register (-1);
+ /* Fetch all registers, if any of them are not yet fetched. */
+ read_register_bytes (0, NULL, REGISTER_BYTES);
}
Otherwise, REGNO specifies which register (so we can save time). */
/* FIXME, look at REGNO to save time here */
+static void
vx_write_register (regno)
int regno;
{
- struct regs inferior_registers;
- struct fp_status inferior_fp_registers;
+ C_bytes in_data;
+ C_bytes out_data;
extern char registers[];
int status;
Rptrace ptrace_in;
Ptrace_return ptrace_out;
- bzero ((char *) &ptrace_in, sizeof (ptrace_in));
- bzero ((char *) &ptrace_out, sizeof (ptrace_out));
-
-#ifdef I80960
-
- bcopy (®isters[REGISTER_BYTE (R0_REGNUM)],
- (char *) inferior_registers.r_lreg, 16 * sizeof (int));
- bcopy (®isters[REGISTER_BYTE (G0_REGNUM)],
- (char *) inferior_registers.r_greg, 16 * sizeof (int));
+ memset ((char *) &ptrace_in, '\0', sizeof (ptrace_in));
+ memset ((char *) &ptrace_out, '\0', sizeof (ptrace_out));
- /* Don't assume that a location in registers[] is properly aligned. */
-
- bcopy (®isters[REGISTER_BYTE (PCW_REGNUM)],
- (char *) &inferior_registers.r_pcw, sizeof (int));
- bcopy (®isters[REGISTER_BYTE (ACW_REGNUM)],
- (char *) &inferior_registers.r_acw, sizeof (int));
- bcopy (®isters[REGISTER_BYTE (TCW_REGNUM)],
- (char *) &inferior_registers.r_tcw, sizeof (int));
-
-#else /* not 960 -- assume 68k -- FIXME */
-
- bcopy (registers, &inferior_registers, 16 * 4);
- inferior_registers.r_ps = *(int *)®isters[REGISTER_BYTE (PS_REGNUM)];
- inferior_registers.r_pc = *(int *)®isters[REGISTER_BYTE (PC_REGNUM)];
+ ptrace_in.pid = inferior_pid;
+ ptrace_in.info.ttype = DATA;
+ ptrace_in.info.more_data = (caddr_t) &in_data;
-#endif /* Different register sets */
+ in_data.bytes = registers;
- ptrace_in.pid = inferior_pid;
- ptrace_in.info.ttype = REGS;
- ptrace_in.info.more_data = (caddr_t) &inferior_registers;
+ in_data.len = VX_NUM_REGS * sizeof (REGISTER_TYPE);
/* XXX change second param to be a proc number */
status = net_ptrace_clnt_call (PTRACE_SETREGS, &ptrace_in, &ptrace_out);
if (ptrace_out.status == -1)
{
errno = ptrace_out.errno;
- return -1;
+ perror_with_name ("net_ptrace_clnt_call(PTRACE_SETREGS)");
}
+#ifdef VX_SIZE_FPREGS
/* Store floating point registers if the target has them. */
if (target_has_fp)
{
-#ifdef I80960
-
- bcopy (®isters[REGISTER_BYTE (FP0_REGNUM)], &inferior_fp_registers,
- sizeof inferior_fp_registers.fps_regs);
-
-#else /* not 960 -- assume 68k -- FIXME */
-
- bcopy (®isters[REGISTER_BYTE (FP0_REGNUM)], &inferior_fp_registers,
- sizeof inferior_fp_registers.fps_regs);
- bcopy (®isters[REGISTER_BYTE (FPC_REGNUM)],
- &inferior_fp_registers.fps_control,
- sizeof inferior_fp_registers - sizeof inferior_fp_registers.fps_regs);
+ ptrace_in.pid = inferior_pid;
+ ptrace_in.info.ttype = DATA;
+ ptrace_in.info.more_data = (caddr_t) &in_data;
-#endif /* Different register sets */
- ptrace_in.pid = inferior_pid;
- ptrace_in.info.ttype = FPREGS;
- ptrace_in.info.more_data = (caddr_t) &inferior_fp_registers;
+ in_data.bytes = ®isters[REGISTER_BYTE (FP0_REGNUM)];
+ in_data.len = VX_SIZE_FPREGS;
status = net_ptrace_clnt_call (PTRACE_SETFPREGS, &ptrace_in, &ptrace_out);
if (status)
if (ptrace_out.status == -1)
{
errno = ptrace_out.errno;
- return -1;
+ perror_with_name ("net_ptrace_clnt_call(PTRACE_SETFPREGS)");
}
}
- return 0;
+#endif /* VX_SIZE_FPREGS */
}
/* Copy LEN bytes to or from remote inferior's memory starting at MEMADDR
handle the current address but can handle one N bytes further, but
vxworks doesn't give us that information. */
-int
+static int
vx_xfer_memory (memaddr, myaddr, len, write, target)
CORE_ADDR memaddr;
char *myaddr;
Ptrace_return ptrace_out;
C_bytes data;
- bzero ((char *) &ptrace_in, sizeof (ptrace_in));
- bzero ((char *) &ptrace_out, sizeof (ptrace_out));
+ memset ((char *) &ptrace_in, '\0', sizeof (ptrace_in));
+ memset ((char *) &ptrace_out, '\0', sizeof (ptrace_out));
ptrace_in.pid = inferior_pid; /* XXX pid unnecessary for READDATA */
ptrace_in.addr = (int) memaddr; /* Where from */
return len; /* Moved *all* the bytes */
}
-void
+static void
vx_files_info ()
{
printf ("\tAttached to host `%s'", vx_host);
printf (".\n");
}
-void
+static void
vx_run_files_info ()
{
- printf ("\tRunning %s VxWorks process 0x%x",
+ printf ("\tRunning %s VxWorks process %s",
vx_running? "child": "attached",
- inferior_pid);
+ local_hex_string((unsigned long) inferior_pid));
if (vx_running)
printf (", function `%s'", vx_running);
printf(".\n");
}
-void
-vx_resume (step, siggnal)
+static void
+vx_resume (pid, step, siggnal)
+ int pid;
int step;
int siggnal;
{
if (siggnal != 0 && siggnal != stop_signal)
error ("Cannot send signals to VxWorks processes");
- bzero ((char *) &ptrace_in, sizeof (ptrace_in));
- bzero ((char *) &ptrace_out, sizeof (ptrace_out));
+ memset ((char *) &ptrace_in, '\0', sizeof (ptrace_in));
+ memset ((char *) &ptrace_out, '\0', sizeof (ptrace_out));
- ptrace_in.pid = inferior_pid;
+ ptrace_in.pid = pid;
ptrace_in.addr = 1; /* Target side insists on this, or it panics. */
/* XXX change second param to be a proc number */
}
}
-void
+static void
vx_mourn_inferior ()
{
pop_target (); /* Pop back to no-child state */
\f
/* This function allows the addition of incrementally linked object files. */
-void
+static void
vx_load_command (arg_string, from_tty)
char* arg_string;
int from_tty;
immediate_quit--;
/* FIXME, for now we ignore data_addr and bss_addr. */
- symbol_file_add (arg_string, from_tty, text_addr, 0);
+ symbol_file_add (arg_string, from_tty, text_addr, 0, 0, 0);
}
#ifdef FIXME /* Not ready for prime time */
NULL, memory for the buffer will be allocated by XDR.
Returns -1 if rpc failed, 0 otherwise. */
-int
+static int
net_get_boot_file (pBootFile)
char **pBootFile;
{
There's no way to check if the returned loadTable is correct.
VxWorks doesn't check it. */
-int
+static int
net_get_symbols (pLoadTable)
ldtabl *pLoadTable; /* return pointer to ldtabl here */
{
enum clnt_stat status;
- bzero ((char *) pLoadTable, sizeof (struct ldtabl));
+ memset ((char *) pLoadTable, '\0', sizeof (struct ldtabl));
status = net_clnt_call (VX_STATE_INQ, xdr_void, 0, xdr_ldtabl, pLoadTable);
return (status == RPC_SUCCESS) ? 0 : -1;
struct complaint cant_contact_target =
{"Lost contact with VxWorks target", 0, 0};
-int
+static int
vx_lookup_symbol (name, pAddr)
char *name; /* symbol name */
CORE_ADDR *pAddr;
SYMBOL_ADDR symbolAddr;
*pAddr = 0;
- bzero ((char *) &symbolAddr, sizeof (symbolAddr));
+ memset ((char *) &symbolAddr, '\0', sizeof (symbolAddr));
status = net_clnt_call (VX_SYMBOL_INQ, xdr_wrapstring, &name,
xdr_SYMBOL_ADDR, &symbolAddr);
if (status != RPC_SUCCESS) {
- complain (&cant_contact_target, 0);
+ complain (&cant_contact_target);
return -1;
}
Returns 1 if target has floating point processor, 0 otherwise.
Calls error() if rpc fails. */
-int
+static int
net_check_for_fp ()
{
enum clnt_stat status;
/* Establish an RPC connection with the VxWorks target system.
Calls error () if unable to establish connection. */
-void
+static void
net_connect (host)
char *host;
{
struct sockaddr_in destAddr;
struct hostent *destHost;
+ unsigned long addr;
+
+ /* Get the internet address for the given host. Allow a numeric
+ IP address or a hostname. */
- /* get the internet address for the given host */
-
- if ((destHost = (struct hostent *) gethostbyname (host)) == NULL)
- error ("Invalid hostname. Couldn't find remote host address.");
+ addr = inet_addr (host);
+ if (addr == -1)
+ {
+ destHost = (struct hostent *) gethostbyname (host);
+ if (destHost == NULL)
+ error ("Invalid hostname. Couldn't find remote host address.");
+ addr = * (unsigned long *) destHost->h_addr;
+ }
- bzero (&destAddr, sizeof (destAddr));
+ memset (&destAddr, '\0', sizeof (destAddr));
- destAddr.sin_addr.s_addr = * (u_long *) destHost->h_addr;
+ destAddr.sin_addr.s_addr = addr;
destAddr.sin_family = AF_INET;
destAddr.sin_port = 0; /* set to actual port that remote
ptrace is listening on. */
sleep_ms (200); /* FIXME Don't kill the network too badly */
}
else if (pid != inferior_pid)
- fatal ("Bad pid for debugged task: 0x%x\n", pid);
+ fatal ("Bad pid for debugged task: %s\n",
+ local_hex_string((unsigned long) pid));
} while (pid == 0);
/* FIXME, eventually do more then SIGTRAP on everything... */
case EVENT_ZERO_DIV: /* Division by zero */
WSETSTOP (w, SIGFPE); /* Like Unix, call it a float exception. */
+ break;
case EVENT_SIGNAL:
/* The target is not running Unix, and its
struct ldfile *pLoadFile = (struct ldfile *)arg;
printf("\t%s: ", pLoadFile->name);
- symbol_file_add (pLoadFile->name, 0, pLoadFile->txt_addr, 0);
+ symbol_file_add (pLoadFile->name, 0, pLoadFile->txt_addr, 0, 0, 0);
printf ("ok\n");
return 1;
}
{
if (*bootFile) {
printf_filtered ("\t%s: ", bootFile);
- if (catch_errors (symbol_stub, bootFile,
- "Error while reading symbols from boot file:\n"))
+ if (catch_errors
+ (symbol_stub, bootFile,
+ "Error while reading symbols from boot file:\n", RETURN_MASK_ALL))
puts_filtered ("ok\n");
} else if (from_tty)
printf ("VxWorks kernel symbols not loaded.\n");
/* Botches, FIXME:
(1) Searches the PATH, not the source path.
(2) data and bss are assumed to be at the usual offsets from text. */
- catch_errors (add_symbol_stub, (char *)pLoadFile, (char *)0);
+ catch_errors (add_symbol_stub, (char *)pLoadFile, (char *)0,
+ RETURN_MASK_ALL);
#endif
}
printf_filtered ("Done.\n");
clnt_freeres (pClient, xdr_ldtabl, &loadTable);
}
\f
-/* attach_command --
- takes a task started up outside of gdb and ``attaches'' to it.
+/* Takes a task started up outside of gdb and ``attaches'' to it.
This stops it cold in its tracks and allows us to start tracing it. */
static void
Ptrace_return ptrace_out;
int status;
- dont_repeat();
-
if (!args)
error_no_arg ("process-id to attach");
error ("Invalid process-id -- give a single number in decimal or 0xhex");
if (from_tty)
- printf ("Attaching pid 0x%x.\n", pid);
+ printf ("Attaching pid %s.\n",
+ local_hex_string((unsigned long) pid));
- bzero ((char *)&ptrace_in, sizeof (ptrace_in));
- bzero ((char *)&ptrace_out, sizeof (ptrace_out));
+ memset ((char *)&ptrace_in, '\0', sizeof (ptrace_in));
+ memset ((char *)&ptrace_out, '\0', sizeof (ptrace_out));
ptrace_in.pid = pid;
status = net_ptrace_clnt_call (PTRACE_ATTACH, &ptrace_in, &ptrace_out);
push_target (&vx_run_ops);
inferior_pid = pid;
vx_running = 0;
-
-#if defined (START_INFERIOR_HOOK)
- START_INFERIOR_HOOK ();
-#endif
-
- mark_breakpoints_out ();
-
- /* Set up the "saved terminal modes" of the inferior
- based on what modes we are starting it with. */
- target_terminal_init ();
-
- /* Install inferior's terminal modes. */
- target_terminal_inferior ();
-
- /* We will get a task spawn event immediately. */
- init_wait_for_inferior ();
- clear_proceed_status ();
- stop_soon_quietly = 1;
- wait_for_inferior ();
- stop_soon_quietly = 0;
- normal_stop ();
}
error ("Argument given to VxWorks \"detach\".");
if (from_tty)
- printf ("Detaching pid 0x%x.\n", inferior_pid);
+ printf ("Detaching pid %s.\n",
+ local_hex_string((unsigned long) inferior_pid));
if (args) /* FIXME, should be possible to leave suspended */
signal = atoi (args);
- bzero ((char *)&ptrace_in, sizeof (ptrace_in));
- bzero ((char *)&ptrace_out, sizeof (ptrace_out));
+ memset ((char *)&ptrace_in, '\0', sizeof (ptrace_in));
+ memset ((char *)&ptrace_out, '\0', sizeof (ptrace_out));
ptrace_in.pid = inferior_pid;
status = net_ptrace_clnt_call (PTRACE_DETACH, &ptrace_in, &ptrace_out);
/* vx_kill -- takes a running task and wipes it out. */
static void
-vx_kill (args, from_tty)
- char *args;
- int from_tty;
+vx_kill ()
{
Rptrace ptrace_in;
Ptrace_return ptrace_out;
int status;
- if (args)
- error ("Argument given to VxWorks \"kill\".");
-
- if (from_tty)
- printf ("Killing pid 0x%x.\n", inferior_pid);
+ printf ("Killing pid %s.\n", local_hex_string((unsigned long) inferior_pid));
- bzero ((char *)&ptrace_in, sizeof (ptrace_in));
- bzero ((char *)&ptrace_out, sizeof (ptrace_out));
+ memset ((char *)&ptrace_in, '\0', sizeof (ptrace_in));
+ memset ((char *)&ptrace_out, '\0', sizeof (ptrace_out));
ptrace_in.pid = inferior_pid;
status = net_ptrace_clnt_call (PTRACE_KILL, &ptrace_in, &ptrace_out);
if (status == -1)
- error (rpcerr);
- if (ptrace_out.status == -1)
+ warning (rpcerr);
+ else if (ptrace_out.status == -1)
{
errno = ptrace_out.errno;
perror_with_name ("Killing VxWorks process");
}
- /* If it gives good status, the process is *gone*, no events remain. */
+ /* If it gives good status, the process is *gone*, no events remain.
+ If the kill failed, assume the process is gone anyhow. */
inferior_pid = 0;
pop_target (); /* go back to non-executing VxWorks connection */
}
/* Clean up from the VxWorks process target as it goes away. */
-void
+static void
vx_proc_close (quitting)
int quitting;
{
vx_running = 0;
}
\f
-/* Cross-net conversion of floats to and from extended form.
- (This is needed because different target machines have different
- extended floating point formats.) */
-
-/* Convert from an extended float to a double.
-
- The extended float is stored as raw data pointed to by FROM.
- Return the converted value as raw data in the double pointed to by TO.
-*/
-
-static void
-vx_convert_to_virtual (regno, from, to)
- int regno;
- char *from;
- char *to;
-{
- enum clnt_stat status;
-
- if (REGISTER_CONVERTIBLE (regno))
- {
- if (!target_has_fp) {
- *(double *)to = 0.0; /* Skip the trouble if no float anyway */
- return;
- }
-
- status = net_clnt_call (VX_CONV_FROM_68881, xdr_ext_fp, from,
- xdr_double, to);
-
- if (status == RPC_SUCCESS)
- return;
- else
- error (rpcerr);
- }
- else
- bcopy (from, to, REGISTER_VIRTUAL_SIZE (regno));
-}
-
-
-/* The converse: convert from a double to an extended float.
-
- The double is stored as raw data pointed to by FROM.
- Return the converted value as raw data in the extended
- float pointed to by TO.
-*/
-
-static void
-vx_convert_from_virtual (regno, from, to)
- int regno;
- char *from;
- char *to;
-{
- enum clnt_stat status;
-
- if (REGISTER_CONVERTIBLE (regno))
- {
- if (!target_has_fp) {
- bzero (to, REGISTER_RAW_SIZE (FP0_REGNUM)); /* Shrug */
- return;
- }
-
- status = net_clnt_call (VX_CONV_TO_68881, xdr_double, from,
- xdr_ext_fp, to);
- if (status == RPC_SUCCESS)
- return;
- else
- error (rpcerr);
- }
- else
- bcopy (from, to, REGISTER_VIRTUAL_SIZE (regno));
-}
-\f
/* Make an RPC call to the VxWorks target.
Returns RPC status. */
/* Clean up before losing control. */
-void
+static void
vx_close (quitting)
int quitting;
{
vx_open, vx_close, vx_attach, 0, /* vx_detach, */
0, 0, /* resume, wait */
0, 0, /* read_reg, write_reg */
- 0, vx_convert_to_virtual, vx_convert_from_virtual, /* prep_to_store, */
+ 0, /* prep_to_store, */
vx_xfer_memory, vx_files_info,
0, 0, /* insert_breakpoint, remove_breakpoint */
0, 0, 0, 0, 0, /* terminal stuff */
0, /* vx_kill, */
vx_load_command,
- 0, /* call_function */
vx_lookup_symbol,
vx_create_inferior, 0, /* mourn_inferior */
+ 0, /* can_run */
+ 0, /* notice_signals */
core_stratum, 0, /* next */
1, 1, 0, 0, 0, /* all mem, mem, stack, regs, exec */
0, 0, /* Section pointers */
vx_proc_open, vx_proc_close, 0, vx_detach, /* vx_attach */
vx_resume, vx_wait,
vx_read_register, vx_write_register,
- vx_prepare_to_store, vx_convert_to_virtual, vx_convert_from_virtual,
+ vx_prepare_to_store,
vx_xfer_memory, vx_run_files_info,
vx_insert_breakpoint, vx_remove_breakpoint,
0, 0, 0, 0, 0, /* terminal stuff */
vx_kill,
vx_load_command,
- call_function_by_hand, /* FIXME, calling fns is maybe botched? */
vx_lookup_symbol,
0, vx_mourn_inferior,
+ 0, /* can_run */
+ 0, /* notice_signals */
process_stratum, 0, /* next */
0, 1, 1, 1, 1, /* all mem, mem, stack, regs, exec */
/* all_mem is off to avoid spurious msg in "i files" */
void
_initialize_vx ()
{
- add_target (&vx_ops);
+
+ add_show_from_set
+ (add_set_cmd ("vxworks-timeout", class_support, var_uinteger,
+ (char *) &rpcTimeout.tv_sec,
+ "Set seconds to wait for rpc calls to return.\n\
+Set the number of seconds to wait for rpc calls to return.", &setlist),
+ &showlist);
+
+ add_target (&vx_ops);
add_target (&vx_run_ops);
}