#include "defs.h"
#include "frame.h"
#include "inferior.h"
#include "target.h"
#include "gdbcore.h"
#include "command.h"
#include "symtab.h"
#include "complaints.h"
#include "gdbcmd.h"
#include "bfd.h"
#include "symfile.h"
#include "objfiles.h"
#include "gdb-stabs.h"
#include "regcache.h"
#include "gdb_string.h"
#include <errno.h>
#include <signal.h>
#include <fcntl.h>
#include <sys/types.h>
#include <sys/socket.h>
#define malloc bogon_malloc
#define free bogon_free
#define realloc bogon_realloc
#include <rpc/rpc.h>
#undef malloc
#undef free
#undef realloc
#include <sys/time.h>
#include <netdb.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>
#define VX_MEMXFER_MAX 4096
extern void vx_read_register ();
extern void vx_write_register ();
extern void symbol_file_command ();
extern int stop_soon_quietly;
static int net_step ();
static int net_ptrace_clnt_call ();
static enum clnt_stat net_clnt_call ();
static struct target_ops vx_ops;
static struct target_ops vx_run_ops;
static char *vx_host;
static char *vx_running;
int target_has_fp;
static const char rpcerr[] = "network target debugging: rpc error";
CLIENT *pClient;
static int ptraceSock = RPC_ANYSOCK;
enum clnt_stat net_clnt_call ();
static void parse_args ();
static struct timeval rpcTimeout =
{10, 0};
static char *skip_white_space ();
static char *find_white_space ();
static int
net_load (char *filename, CORE_ADDR *pTextAddr, CORE_ADDR *pDataAddr,
CORE_ADDR *pBssAddr)
{
enum clnt_stat status;
struct ldfile ldstruct;
struct timeval load_timeout;
memset ((char *) &ldstruct, '\0', sizeof (ldstruct));
load_timeout.tv_sec = 99999999;
load_timeout.tv_usec = 0;
status = clnt_call (pClient, VX_LOAD, xdr_wrapstring, &filename, xdr_ldfile,
&ldstruct, load_timeout);
if (status == RPC_SUCCESS)
{
if (*ldstruct.name == 0)
return -1;
*pTextAddr = ldstruct.txt_addr;
*pDataAddr = ldstruct.data_addr;
*pBssAddr = ldstruct.bss_addr;
return 0;
}
else
return -1;
}
static int
net_break (int addr, u_long procnum)
{
enum clnt_stat status;
int break_status;
Rptrace ptrace_in;
memset ((char *) &ptrace_in, '\0', sizeof (ptrace_in));
break_status = 0;
ptrace_in.addr = addr;
ptrace_in.pid = PIDGET (inferior_ptid);
status = net_clnt_call (procnum, xdr_rptrace, &ptrace_in, xdr_int,
&break_status);
if (status != RPC_SUCCESS)
return errno;
if (break_status == -1)
return ENOMEM;
return break_status;
}
static int
vx_insert_breakpoint (int addr)
{
return net_break (addr, VX_BREAK_ADD);
}
static int
vx_remove_breakpoint (int addr)
{
return net_break (addr, VX_BREAK_DELETE);
}
static void
vx_create_inferior (char *exec_file, char *args, char **env)
{
enum clnt_stat status;
arg_array passArgs;
TASK_START taskStart;
memset ((char *) &passArgs, '\0', sizeof (passArgs));
memset ((char *) &taskStart, '\0', sizeof (taskStart));
parse_args (args, &passArgs);
if (passArgs.arg_array_len == 0)
error ("You must specify a function name to run, and arguments if any");
status = net_clnt_call (PROCESS_START, xdr_arg_array, &passArgs,
xdr_TASK_START, &taskStart);
if ((status != RPC_SUCCESS) || (taskStart.status == -1))
error ("Can't create process on remote target machine");
vx_running = savestring (passArgs.arg_array_val[0],
strlen (passArgs.arg_array_val[0]));
push_target (&vx_run_ops);
inferior_ptid = pid_to_ptid (taskStart.pid);
init_wait_for_inferior ();
target_terminal_init ();
target_terminal_inferior ();
stop_soon_quietly = 1;
wait_for_inferior ();
stop_soon_quietly = 0;
proceed (-1, TARGET_SIGNAL_DEFAULT, 0);
}
static void
parse_args (register char *arg_string, arg_array *arg_struct)
{
register int arg_count = 0;
register int arg_index = 0;
register char *p0;
memset ((char *) arg_struct, '\0', sizeof (arg_array));
p0 = arg_string;
while (*p0 != '\0')
{
if (*(p0 = skip_white_space (p0)) == '\0')
break;
p0 = find_white_space (p0);
arg_count++;
}
arg_struct->arg_array_len = arg_count;
arg_struct->arg_array_val = (char **) xmalloc ((arg_count + 1)
* sizeof (char *));
while (*(arg_string = skip_white_space (arg_string)))
{
p0 = find_white_space (arg_string);
arg_struct->arg_array_val[arg_index++] = savestring (arg_string,
p0 - arg_string);
arg_string = p0;
}
arg_struct->arg_array_val[arg_count] = NULL;
}
static char *
skip_white_space (register char *p)
{
while (*p == ' ' || *p == '\t')
p++;
return p;
}
static char *
find_white_space (register char *p)
{
register int c;
while ((c = *p) != ' ' && c != '\t' && c)
{
if (c == '\'' || c == '"')
{
while (*++p != c && *p)
{
if (*p == '\\')
p++;
}
if (!*p)
break;
}
p++;
}
return p;
}
static int
net_wait (RDB_EVENT *pEvent)
{
int pid;
enum clnt_stat status;
memset ((char *) pEvent, '\0', sizeof (RDB_EVENT));
pid = PIDGET (inferior_ptid);
status = net_clnt_call (PROCESS_WAIT, xdr_int, &pid, xdr_RDB_EVENT,
pEvent);
if (status == RPC_SUCCESS)
return ((pEvent->status) ? 1 : 0);
else if (status == RPC_TIMEDOUT)
return (1);
else
return (-1);
}
static int
net_quit (void)
{
int pid;
int quit_status;
enum clnt_stat status;
quit_status = 0;
if ((pid = PIDGET (inferior_ptid)) == 0)
return -1;
status = net_clnt_call (VX_TASK_SUSPEND, xdr_int, &pid, xdr_int,
&quit_status);
return (status == RPC_SUCCESS) ? quit_status : -1;
}
void
net_read_registers (char *reg_buf, int len, u_long procnum)
{
int status;
Rptrace ptrace_in;
Ptrace_return ptrace_out;
C_bytes out_data;
char message[100];
memset ((char *) &ptrace_in, '\0', sizeof (ptrace_in));
memset ((char *) &ptrace_out, '\0', sizeof (ptrace_out));
ptrace_in.pid = PIDGET (inferior_ptid);
ptrace_in.info.ttype = NOINFO;
out_data.bytes = reg_buf;
out_data.len = len;
ptrace_out.info.more_data = (caddr_t) & out_data;
status = net_ptrace_clnt_call (procnum, &ptrace_in, &ptrace_out);
if (status)
error (rpcerr);
if (ptrace_out.status == -1)
{
errno = ptrace_out.errno_num;
sprintf (message, "reading %s registers", (procnum == PTRACE_GETREGS)
? "general-purpose"
: "floating-point");
perror_with_name (message);
}
}
void
net_write_registers (char *reg_buf, int len, u_long procnum)
{
int status;
Rptrace ptrace_in;
Ptrace_return ptrace_out;
C_bytes in_data;
char message[100];
memset ((char *) &ptrace_in, '\0', sizeof (ptrace_in));
memset ((char *) &ptrace_out, '\0', sizeof (ptrace_out));
in_data.bytes = reg_buf;
in_data.len = len;
ptrace_in.pid = PIDGET (inferior_ptid);
ptrace_in.info.ttype = DATA;
ptrace_in.info.more_data = (caddr_t) & in_data;
status = net_ptrace_clnt_call (procnum, &ptrace_in, &ptrace_out);
if (status)
error (rpcerr);
if (ptrace_out.status == -1)
{
errno = ptrace_out.errno_num;
sprintf (message, "writing %s registers", (procnum == PTRACE_SETREGS)
? "general-purpose"
: "floating-point");
perror_with_name (message);
}
}
static void
vx_prepare_to_store (void)
{
deprecated_read_register_bytes (0, NULL, REGISTER_BYTES);
}
static int
vx_xfer_memory (CORE_ADDR memaddr, char *myaddr, int len, int write,
struct mem_attrib *attrib, struct target_ops *target)
{
int status;
Rptrace ptrace_in;
Ptrace_return ptrace_out;
C_bytes data;
enum ptracereq request;
int nleft, nxfer;
memset ((char *) &ptrace_in, '\0', sizeof (ptrace_in));
memset ((char *) &ptrace_out, '\0', sizeof (ptrace_out));
ptrace_in.pid = PIDGET (inferior_ptid);
ptrace_in.addr = (int) memaddr;
ptrace_in.data = len;
if (write)
{
ptrace_in.info.ttype = DATA;
ptrace_in.info.more_data = (caddr_t) & data;
data.bytes = (caddr_t) myaddr;
data.len = len;
request = PTRACE_WRITEDATA;
}
else
{
ptrace_out.info.more_data = (caddr_t) & data;
request = PTRACE_READDATA;
}
nleft = len;
status = 0;
while (nleft > 0 && status == 0)
{
nxfer = min (nleft, VX_MEMXFER_MAX);
ptrace_in.addr = (int) memaddr;
ptrace_in.data = nxfer;
data.bytes = (caddr_t) myaddr;
data.len = nxfer;
if (net_ptrace_clnt_call (request, &ptrace_in, &ptrace_out))
error (rpcerr);
status = ptrace_out.status;
if (status == 0)
{
memaddr += nxfer;
myaddr += nxfer;
nleft -= nxfer;
}
else
{
errno = ptrace_out.errno_num;
}
}
return (len - nleft);
}
static void
vx_files_info (void)
{
printf_unfiltered ("\tAttached to host `%s'", vx_host);
printf_unfiltered (", which has %sfloating point", target_has_fp ? "" : "no ");
printf_unfiltered (".\n");
}
static void
vx_run_files_info (void)
{
printf_unfiltered ("\tRunning %s VxWorks process %s",
vx_running ? "child" : "attached",
local_hex_string (PIDGET (inferior_ptid)));
if (vx_running)
printf_unfiltered (", function `%s'", vx_running);
printf_unfiltered (".\n");
}
static void
vx_resume (ptid_t ptid, int step, enum target_signal siggnal)
{
int status;
Rptrace ptrace_in;
Ptrace_return ptrace_out;
CORE_ADDR cont_addr;
if (ptid_equal (ptid, minus_one_ptid))
ptid = inferior_ptid;
if (siggnal != 0 && siggnal != stop_signal)
error ("Cannot send signals to VxWorks processes");
cont_addr = read_register (PC_REGNUM);
if (cont_addr == stop_pc)
cont_addr = 1;
memset ((char *) &ptrace_in, '\0', sizeof (ptrace_in));
memset ((char *) &ptrace_out, '\0', sizeof (ptrace_out));
ptrace_in.pid = PIDGET (ptid);
ptrace_in.addr = cont_addr;
if (step)
status = net_step ();
else
status = net_ptrace_clnt_call (PTRACE_CONT, &ptrace_in, &ptrace_out);
if (status)
error (rpcerr);
if (ptrace_out.status == -1)
{
errno = ptrace_out.errno_num;
perror_with_name ("Resuming remote process");
}
}
static void
vx_mourn_inferior (void)
{
pop_target ();
generic_mourn_inferior ();
}
static void vx_add_symbols (char *, int, CORE_ADDR, CORE_ADDR, CORE_ADDR);
struct find_sect_args
{
CORE_ADDR text_start;
CORE_ADDR data_start;
CORE_ADDR bss_start;
};
static void find_sect (bfd *, asection *, void *);
static void
find_sect (bfd *abfd, asection *sect, void *obj)
{
struct find_sect_args *args = (struct find_sect_args *) obj;
if (bfd_get_section_flags (abfd, sect) & (SEC_CODE & SEC_READONLY))
args->text_start = bfd_get_section_vma (abfd, sect);
else if (bfd_get_section_flags (abfd, sect) & SEC_ALLOC)
{
if (bfd_get_section_flags (abfd, sect) & SEC_LOAD)
{
if (bfd_get_section_flags (abfd, sect) & SEC_DATA)
args->data_start = bfd_get_section_vma (abfd, sect);
}
else
args->bss_start = bfd_get_section_vma (abfd, sect);
}
}
static void
vx_add_symbols (char *name, int from_tty, CORE_ADDR text_addr,
CORE_ADDR data_addr, CORE_ADDR bss_addr)
{
struct section_offsets *offs;
struct objfile *objfile;
struct find_sect_args ss;
objfile = symbol_file_add (name, from_tty, NULL, 0, 0);
objfile_to_front (objfile);
offs = (struct section_offsets *) alloca (SIZEOF_SECTION_OFFSETS);
memcpy (offs, objfile->section_offsets, SIZEOF_SECTION_OFFSETS);
ss.text_start = 0;
ss.data_start = 0;
ss.bss_start = 0;
bfd_map_over_sections (objfile->obfd, find_sect, &ss);
offs->offsets[SECT_OFF_TEXT (objfile)] = text_addr - ss.text_start;
offs->offsets[SECT_OFF_DATA (objfile)] = data_addr - ss.data_start;
offs->offsets[SECT_OFF_BSS (objfile)] = bss_addr - ss.bss_start;
objfile_relocate (objfile, offs);
}
static void
vx_load_command (char *arg_string, int from_tty)
{
CORE_ADDR text_addr;
CORE_ADDR data_addr;
CORE_ADDR bss_addr;
if (arg_string == 0)
error ("The load command takes a file name");
arg_string = tilde_expand (arg_string);
make_cleanup (xfree, arg_string);
dont_repeat ();
if (PIDGET (inferior_ptid) != 0 && target_has_execution)
{
if (query ("You may not load a module while the target task is running.\n\
Kill the target task? "))
target_kill ();
else
error ("Load canceled.");
}
QUIT;
immediate_quit++;
if (net_load (arg_string, &text_addr, &data_addr, &bss_addr) == -1)
error ("Load failed on target machine");
immediate_quit--;
vx_add_symbols (arg_string, from_tty, text_addr, data_addr, bss_addr);
reinit_frame_cache ();
}
static int
net_step (void)
{
enum clnt_stat status;
int step_status;
SOURCE_STEP source_step;
source_step.taskId = PIDGET (inferior_ptid);
if (step_range_end)
{
source_step.startAddr = step_range_start;
source_step.endAddr = step_range_end;
}
else
{
source_step.startAddr = 0;
source_step.endAddr = 0;
}
status = net_clnt_call (VX_SOURCE_STEP, xdr_SOURCE_STEP, &source_step,
xdr_int, &step_status);
if (status == RPC_SUCCESS)
return step_status;
else
error (rpcerr);
}
static int
net_ptrace_clnt_call (enum ptracereq request, Rptrace *pPtraceIn,
Ptrace_return *pPtraceOut)
{
enum clnt_stat status;
status = net_clnt_call (request, xdr_rptrace, pPtraceIn, xdr_ptrace_return,
pPtraceOut);
if (status != RPC_SUCCESS)
return -1;
return 0;
}
static int
net_get_boot_file (char **pBootFile)
{
enum clnt_stat status;
status = net_clnt_call (VX_BOOT_FILE_INQ, xdr_void, (char *) 0,
xdr_wrapstring, pBootFile);
return (status == RPC_SUCCESS) ? 0 : -1;
}
static int
net_get_symbols (ldtabl *pLoadTable)
{
enum clnt_stat status;
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;
}
static int
vx_lookup_symbol (char *name,
CORE_ADDR *pAddr)
{
enum clnt_stat status;
SYMBOL_ADDR symbolAddr;
*pAddr = 0;
memset ((char *) &symbolAddr, '\0', sizeof (symbolAddr));
status = net_clnt_call (VX_SYMBOL_INQ, xdr_wrapstring, &name,
xdr_SYMBOL_ADDR, &symbolAddr);
if (status != RPC_SUCCESS)
{
complaint (&symfile_complaints, "Lost contact with VxWorks target");
return -1;
}
*pAddr = symbolAddr.addr;
return symbolAddr.status;
}
static int
net_check_for_fp (void)
{
enum clnt_stat status;
bool_t fp = 0;
status = net_clnt_call (VX_FP_INQUIRE, xdr_void, 0, xdr_bool, &fp);
if (status != RPC_SUCCESS)
error (rpcerr);
return (int) fp;
}
static void
net_connect (char *host)
{
struct sockaddr_in destAddr;
struct hostent *destHost;
unsigned long addr;
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;
}
memset (&destAddr, '\0', sizeof (destAddr));
destAddr.sin_addr.s_addr = addr;
destAddr.sin_family = AF_INET;
destAddr.sin_port = 0;
ptraceSock = RPC_ANYSOCK;
pClient = clnttcp_create (&destAddr, RDBPROG, RDBVERS, &ptraceSock, 0, 0);
if (pClient == NULL)
{
clnt_pcreateerror ("\tnet_connect");
error ("Couldn't connect to remote target.");
}
}
static void
sleep_ms (long ms)
{
struct timeval select_timeout;
int status;
select_timeout.tv_sec = 0;
select_timeout.tv_usec = ms * 1000;
status = select (0, (fd_set *) 0, (fd_set *) 0, (fd_set *) 0,
&select_timeout);
if (status < 0 && errno != EINTR)
perror_with_name ("select");
}
static ptid_t
vx_wait (ptid_t ptid_to_wait_for, struct target_waitstatus *status)
{
register int pid;
RDB_EVENT rdbEvent;
int quit_failed;
do
{
quit_failed = 0;
if (quit_flag)
{
quit_failed = (net_quit () == -1);
quit_flag = 0;
}
if (quit_failed || net_wait (&rdbEvent) == -1)
{
terminal_ours ();
if (query ("Can't %s. Disconnect from target system? ",
(quit_failed) ? "suspend remote task"
: "get status of remote task"))
{
target_mourn_inferior ();
error ("Use the \"target\" command to reconnect.");
}
else
{
terminal_inferior ();
continue;
}
}
pid = rdbEvent.taskId;
if (pid == 0)
{
sleep_ms (200);
}
else if (pid != PIDGET (inferior_ptid))
internal_error (__FILE__, __LINE__,
"Bad pid for debugged task: %s\n",
local_hex_string ((unsigned long) pid));
}
while (pid == 0);
status->kind = TARGET_WAITKIND_STOPPED;
switch (rdbEvent.eventType)
{
case EVENT_EXIT:
status->kind = TARGET_WAITKIND_EXITED;
status->value.integer = 0;
break;
case EVENT_START:
status->value.sig = TARGET_SIGNAL_TRAP;
break;
case EVENT_STOP:
status->value.sig = TARGET_SIGNAL_TRAP;
break;
case EVENT_BREAK:
status->value.sig = TARGET_SIGNAL_TRAP;
break;
case EVENT_SUSPEND:
status->value.sig = TARGET_SIGNAL_INT;
break;
case EVENT_BUS_ERR:
status->value.sig = TARGET_SIGNAL_BUS;
break;
case EVENT_ZERO_DIV:
status->value.sig = TARGET_SIGNAL_FPE;
break;
case EVENT_SIGNAL:
#ifdef I80960
status->value.sig = i960_fault_to_signal (rdbEvent.sigType);
#else
status->value.sig = TARGET_SIGNAL_UNKNOWN;
#endif
break;
}
return pid_to_ptid (pid);
}
static int
symbol_stub (char *arg)
{
symbol_file_add_main (arg, 0);
return 1;
}
static int
add_symbol_stub (char *arg)
{
struct ldfile *pLoadFile = (struct ldfile *) arg;
printf_unfiltered ("\t%s: ", pLoadFile->name);
vx_add_symbols (pLoadFile->name, 0, pLoadFile->txt_addr,
pLoadFile->data_addr, pLoadFile->bss_addr);
printf_unfiltered ("ok\n");
return 1;
}
static void
vx_open (char *args, int from_tty)
{
extern int close ();
char *bootFile;
extern char *source_path;
struct ldtabl loadTable;
struct ldfile *pLoadFile;
int i;
extern CLIENT *pClient;
int symbols_added = 0;
if (!args)
error_no_arg ("target machine name");
target_preopen (from_tty);
unpush_target (&vx_ops);
printf_unfiltered ("Attaching remote machine across net...\n");
gdb_flush (gdb_stdout);
immediate_quit++;
net_connect (args);
target_has_fp = net_check_for_fp ();
printf_filtered ("Connected to %s.\n", args);
immediate_quit--;
push_target (&vx_ops);
vx_host = savestring (args, strlen (args));
printf_filtered ("Looking in Unix path for all loaded modules:\n");
bootFile = NULL;
if (!net_get_boot_file (&bootFile))
{
if (*bootFile)
{
printf_filtered ("\t%s: ", bootFile);
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_unfiltered ("VxWorks kernel symbols not loaded.\n");
}
else
error ("Can't retrieve boot file name from target machine.");
clnt_freeres (pClient, xdr_wrapstring, &bootFile);
if (net_get_symbols (&loadTable) != 0)
error ("Can't read loaded modules from target machine");
i = 0 - 1;
while (++i < loadTable.tbl_size)
{
QUIT;
pLoadFile = &loadTable.tbl_ent[i];
#ifdef WRS_ORIG
{
register int desc;
struct cleanup *old_chain;
char *fullname = NULL;
desc = openp (source_path, 0, pLoadFile->name, O_RDONLY, 0, &fullname);
if (desc < 0)
perror_with_name (pLoadFile->name);
old_chain = make_cleanup (close, desc);
add_file_at_addr (fullname, desc, pLoadFile->txt_addr, pLoadFile->data_addr,
pLoadFile->bss_addr);
do_cleanups (old_chain);
}
#else
if (catch_errors (add_symbol_stub, (char *) pLoadFile, (char *) 0,
RETURN_MASK_ALL))
symbols_added = 1;
#endif
}
printf_filtered ("Done.\n");
clnt_freeres (pClient, xdr_ldtabl, &loadTable);
if (symbols_added)
reinit_frame_cache ();
}
static void
vx_attach (char *args, int from_tty)
{
unsigned long pid;
char *cptr = 0;
Rptrace ptrace_in;
Ptrace_return ptrace_out;
int status;
if (!args)
error_no_arg ("process-id to attach");
pid = strtoul (args, &cptr, 0);
if ((cptr == args) || (*cptr != '\0'))
error ("Invalid process-id -- give a single number in decimal or 0xhex");
if (from_tty)
printf_unfiltered ("Attaching pid %s.\n",
local_hex_string ((unsigned long) pid));
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);
if (status == -1)
error (rpcerr);
if (ptrace_out.status == -1)
{
errno = ptrace_out.errno_num;
perror_with_name ("Attaching remote process");
}
inferior_ptid = pid_to_ptid (pid);
push_target (&vx_run_ops);
if (vx_running)
xfree (vx_running);
vx_running = 0;
}
static void
vx_detach (char *args, int from_tty)
{
Rptrace ptrace_in;
Ptrace_return ptrace_out;
int signal = 0;
int status;
if (args)
error ("Argument given to VxWorks \"detach\".");
if (from_tty)
printf_unfiltered ("Detaching pid %s.\n",
local_hex_string (
(unsigned long) PIDGET (inferior_ptid)));
if (args)
signal = atoi (args);
memset ((char *) &ptrace_in, '\0', sizeof (ptrace_in));
memset ((char *) &ptrace_out, '\0', sizeof (ptrace_out));
ptrace_in.pid = PIDGET (inferior_ptid);
status = net_ptrace_clnt_call (PTRACE_DETACH, &ptrace_in, &ptrace_out);
if (status == -1)
error (rpcerr);
if (ptrace_out.status == -1)
{
errno = ptrace_out.errno_num;
perror_with_name ("Detaching VxWorks process");
}
inferior_ptid = null_ptid;
pop_target ();
}
static void
vx_kill (void)
{
Rptrace ptrace_in;
Ptrace_return ptrace_out;
int status;
printf_unfiltered ("Killing pid %s.\n", local_hex_string ((unsigned long) PIDGET (inferior_ptid)));
memset ((char *) &ptrace_in, '\0', sizeof (ptrace_in));
memset ((char *) &ptrace_out, '\0', sizeof (ptrace_out));
ptrace_in.pid = PIDGET (inferior_ptid);
status = net_ptrace_clnt_call (PTRACE_KILL, &ptrace_in, &ptrace_out);
if (status == -1)
warning (rpcerr);
else if (ptrace_out.status == -1)
{
errno = ptrace_out.errno_num;
perror_with_name ("Killing VxWorks process");
}
inferior_ptid = null_ptid;
pop_target ();
}
static void
vx_proc_close (int quitting)
{
inferior_ptid = null_ptid;
if (vx_running)
xfree (vx_running);
vx_running = 0;
}
static enum clnt_stat
net_clnt_call (enum ptracereq procNum, xdrproc_t inProc, char *in,
xdrproc_t outProc, char *out)
{
enum clnt_stat status;
status = clnt_call (pClient, procNum, inProc, in, outProc, out, rpcTimeout);
if (status != RPC_SUCCESS)
clnt_perrno (status);
return status;
}
static void
vx_close (int quitting)
{
if (pClient)
clnt_destroy (pClient);
pClient = 0;
if (vx_host)
xfree (vx_host);
vx_host = 0;
}
static void
vx_proc_open (char *name, int from_tty)
{
error ("Use the \"run\" command to start a VxWorks process.");
}
static void
init_vx_ops (void)
{
vx_ops.to_shortname = "vxworks";
vx_ops.to_longname = "VxWorks target memory via RPC over TCP/IP";
vx_ops.to_doc = "Use VxWorks target memory. \n\
Specify the name of the machine to connect to.";
vx_ops.to_open = vx_open;
vx_ops.to_close = vx_close;
vx_ops.to_attach = vx_attach;
vx_ops.to_xfer_memory = vx_xfer_memory;
vx_ops.to_files_info = vx_files_info;
vx_ops.to_load = vx_load_command;
vx_ops.to_lookup_symbol = vx_lookup_symbol;
vx_ops.to_create_inferior = vx_create_inferior;
vx_ops.to_stratum = core_stratum;
vx_ops.to_has_all_memory = 1;
vx_ops.to_has_memory = 1;
vx_ops.to_magic = OPS_MAGIC;
};
static void
init_vx_run_ops (void)
{
vx_run_ops.to_shortname = "vxprocess";
vx_run_ops.to_longname = "VxWorks process";
vx_run_ops.to_doc = "VxWorks process; started by the \"run\" command.";
vx_run_ops.to_open = vx_proc_open;
vx_run_ops.to_close = vx_proc_close;
vx_run_ops.to_detach = vx_detach;
vx_run_ops.to_resume = vx_resume;
vx_run_ops.to_wait = vx_wait;
vx_run_ops.to_fetch_registers = vx_read_register;
vx_run_ops.to_store_registers = vx_write_register;
vx_run_ops.to_prepare_to_store = vx_prepare_to_store;
vx_run_ops.to_xfer_memory = vx_xfer_memory;
vx_run_ops.to_files_info = vx_run_files_info;
vx_run_ops.to_insert_breakpoint = vx_insert_breakpoint;
vx_run_ops.to_remove_breakpoint = vx_remove_breakpoint;
vx_run_ops.to_kill = vx_kill;
vx_run_ops.to_load = vx_load_command;
vx_run_ops.to_lookup_symbol = vx_lookup_symbol;
vx_run_ops.to_mourn_inferior = vx_mourn_inferior;
vx_run_ops.to_stratum = process_stratum;
vx_run_ops.to_has_memory = 1;
vx_run_ops.to_has_stack = 1;
vx_run_ops.to_has_registers = 1;
vx_run_ops.to_has_execution = 1;
vx_run_ops.to_magic = OPS_MAGIC;
}
void
_initialize_vx (void)
{
init_vx_ops ();
add_target (&vx_ops);
init_vx_run_ops ();
add_target (&vx_run_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);
}