1999-04-16 03:35:26 +02:00
|
|
|
|
/* Memory-access and commands for remote VxWorks processes, for GDB.
|
2001-03-06 09:22:02 +01:00
|
|
|
|
Copyright 1990, 1991, 1992, 1993, 1994, 1995, 1997, 1998, 1999, 2000,
|
|
|
|
|
2001 Free Software Foundation, Inc.
|
1999-04-16 03:35:26 +02:00
|
|
|
|
Contributed by Wind River Systems and Cygnus Support.
|
|
|
|
|
|
1999-07-07 22:19:36 +02:00
|
|
|
|
This file is part of GDB.
|
1999-04-16 03:35:26 +02:00
|
|
|
|
|
1999-07-07 22:19:36 +02:00
|
|
|
|
This program is free software; you can redistribute it and/or modify
|
|
|
|
|
it under the terms of the GNU General Public License as published by
|
|
|
|
|
the Free Software Foundation; either version 2 of the License, or
|
|
|
|
|
(at your option) any later version.
|
1999-04-16 03:35:26 +02:00
|
|
|
|
|
1999-07-07 22:19:36 +02:00
|
|
|
|
This program is distributed in the hope that it will be useful,
|
|
|
|
|
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
|
|
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
|
|
|
GNU General Public License for more details.
|
1999-04-16 03:35:26 +02:00
|
|
|
|
|
1999-07-07 22:19:36 +02:00
|
|
|
|
You should have received a copy of the GNU General Public License
|
|
|
|
|
along with this program; if not, write to the Free Software
|
|
|
|
|
Foundation, Inc., 59 Temple Place - Suite 330,
|
|
|
|
|
Boston, MA 02111-1307, USA. */
|
1999-04-16 03:35:26 +02:00
|
|
|
|
|
|
|
|
|
#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"
|
1999-07-07 22:19:36 +02:00
|
|
|
|
#include "bfd.h" /* Required by objfiles.h. */
|
2001-01-27 01:43:26 +01:00
|
|
|
|
#include "symfile.h"
|
1999-04-16 03:35:26 +02:00
|
|
|
|
#include "objfiles.h"
|
|
|
|
|
#include "gdb-stabs.h"
|
2001-03-01 02:39:22 +01:00
|
|
|
|
#include "regcache.h"
|
1999-04-16 03:35:26 +02:00
|
|
|
|
|
|
|
|
|
#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 /* 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 "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>
|
|
|
|
|
|
|
|
|
|
/* Maximum number of bytes to transfer in a single
|
|
|
|
|
PTRACE_{READ,WRITE}DATA request. */
|
|
|
|
|
#define VX_MEMXFER_MAX 4096
|
|
|
|
|
|
|
|
|
|
extern void vx_read_register ();
|
|
|
|
|
extern void vx_write_register ();
|
|
|
|
|
extern void symbol_file_command ();
|
1999-07-07 22:19:36 +02:00
|
|
|
|
extern int stop_soon_quietly; /* for wait_for_inferior */
|
1999-04-16 03:35:26 +02:00
|
|
|
|
|
|
|
|
|
static int net_step ();
|
|
|
|
|
static int net_ptrace_clnt_call (); /* Forward decl */
|
1999-07-07 22:19:36 +02:00
|
|
|
|
static enum clnt_stat net_clnt_call (); /* Forward decl */
|
1999-04-16 03:35:26 +02:00
|
|
|
|
|
|
|
|
|
/* Target ops structure for accessing memory and such over the net */
|
|
|
|
|
|
|
|
|
|
static struct target_ops vx_ops;
|
|
|
|
|
|
|
|
|
|
/* Target ops structure for accessing VxWorks child processes over the net */
|
|
|
|
|
|
|
|
|
|
static struct target_ops vx_run_ops;
|
|
|
|
|
|
|
|
|
|
/* Saved name of target host and called function for "info files".
|
|
|
|
|
Both malloc'd. */
|
|
|
|
|
|
|
|
|
|
static char *vx_host;
|
1999-07-07 22:19:36 +02:00
|
|
|
|
static char *vx_running; /* Called function */
|
1999-04-16 03:35:26 +02:00
|
|
|
|
|
|
|
|
|
/* Nonzero means target that is being debugged remotely has a floating
|
|
|
|
|
point processor. */
|
|
|
|
|
|
|
|
|
|
int target_has_fp;
|
|
|
|
|
|
|
|
|
|
/* Default error message when the network is forking up. */
|
|
|
|
|
|
|
|
|
|
static const char rpcerr[] = "network target debugging: rpc error";
|
|
|
|
|
|
1999-07-07 22:19:36 +02:00
|
|
|
|
CLIENT *pClient; /* client used in net debugging */
|
1999-04-16 03:35:26 +02:00
|
|
|
|
static int ptraceSock = RPC_ANYSOCK;
|
|
|
|
|
|
1999-07-07 22:19:36 +02:00
|
|
|
|
enum clnt_stat net_clnt_call ();
|
1999-04-16 03:35:26 +02:00
|
|
|
|
static void parse_args ();
|
|
|
|
|
|
1999-07-07 22:19:36 +02:00
|
|
|
|
static struct timeval rpcTimeout =
|
|
|
|
|
{10, 0};
|
1999-04-16 03:35:26 +02:00
|
|
|
|
|
|
|
|
|
static char *skip_white_space ();
|
|
|
|
|
static char *find_white_space ();
|
1999-07-07 22:19:36 +02:00
|
|
|
|
|
1999-04-16 03:35:26 +02:00
|
|
|
|
/* 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).
|
|
|
|
|
Returns 0 for success, -1 for failure. */
|
|
|
|
|
|
|
|
|
|
static int
|
2000-07-30 03:48:28 +02:00
|
|
|
|
net_load (char *filename, CORE_ADDR *pTextAddr, CORE_ADDR *pDataAddr,
|
|
|
|
|
CORE_ADDR *pBssAddr)
|
1999-04-16 03:35:26 +02:00
|
|
|
|
{
|
|
|
|
|
enum clnt_stat status;
|
|
|
|
|
struct ldfile ldstruct;
|
|
|
|
|
struct timeval load_timeout;
|
|
|
|
|
|
|
|
|
|
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... */
|
|
|
|
|
|
1999-07-07 22:19:36 +02:00
|
|
|
|
load_timeout.tv_sec = 99999999; /* A large number, effectively inf. */
|
1999-04-16 03:35:26 +02:00
|
|
|
|
load_timeout.tv_usec = 0;
|
1999-07-07 22:19:36 +02:00
|
|
|
|
|
1999-04-16 03:35:26 +02:00
|
|
|
|
status = clnt_call (pClient, VX_LOAD, xdr_wrapstring, &filename, xdr_ldfile,
|
|
|
|
|
&ldstruct, load_timeout);
|
|
|
|
|
|
|
|
|
|
if (status == RPC_SUCCESS)
|
|
|
|
|
{
|
|
|
|
|
if (*ldstruct.name == 0) /* load failed on VxWorks side */
|
|
|
|
|
return -1;
|
|
|
|
|
*pTextAddr = ldstruct.txt_addr;
|
|
|
|
|
*pDataAddr = ldstruct.data_addr;
|
|
|
|
|
*pBssAddr = ldstruct.bss_addr;
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
else
|
|
|
|
|
return -1;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* returns 0 if successful, errno if RPC failed or VxWorks complains. */
|
|
|
|
|
|
|
|
|
|
static int
|
2000-07-30 03:48:28 +02:00
|
|
|
|
net_break (int addr, u_long procnum)
|
1999-04-16 03:35:26 +02:00
|
|
|
|
{
|
|
|
|
|
enum clnt_stat status;
|
|
|
|
|
int break_status;
|
1999-07-07 22:19:36 +02:00
|
|
|
|
Rptrace ptrace_in; /* XXX This is stupid. It doesn't need to be a ptrace
|
|
|
|
|
structure. How about something smaller? */
|
1999-04-16 03:35:26 +02:00
|
|
|
|
|
|
|
|
|
memset ((char *) &ptrace_in, '\0', sizeof (ptrace_in));
|
|
|
|
|
break_status = 0;
|
|
|
|
|
|
|
|
|
|
ptrace_in.addr = addr;
|
2001-05-04 06:15:33 +02:00
|
|
|
|
ptrace_in.pid = PIDGET (inferior_ptid);
|
1999-04-16 03:35:26 +02:00
|
|
|
|
|
|
|
|
|
status = net_clnt_call (procnum, xdr_rptrace, &ptrace_in, xdr_int,
|
|
|
|
|
&break_status);
|
|
|
|
|
|
|
|
|
|
if (status != RPC_SUCCESS)
|
1999-07-07 22:19:36 +02:00
|
|
|
|
return errno;
|
1999-04-16 03:35:26 +02:00
|
|
|
|
|
|
|
|
|
if (break_status == -1)
|
|
|
|
|
return ENOMEM;
|
1999-07-07 22:19:36 +02:00
|
|
|
|
return break_status; /* probably (FIXME) zero */
|
1999-04-16 03:35:26 +02:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* returns 0 if successful, errno otherwise */
|
|
|
|
|
|
|
|
|
|
static int
|
2000-07-30 03:48:28 +02:00
|
|
|
|
vx_insert_breakpoint (int addr)
|
1999-04-16 03:35:26 +02:00
|
|
|
|
{
|
|
|
|
|
return net_break (addr, VX_BREAK_ADD);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* returns 0 if successful, errno otherwise */
|
|
|
|
|
|
|
|
|
|
static int
|
2000-07-30 03:48:28 +02:00
|
|
|
|
vx_remove_breakpoint (int addr)
|
1999-04-16 03:35:26 +02:00
|
|
|
|
{
|
|
|
|
|
return net_break (addr, VX_BREAK_DELETE);
|
|
|
|
|
}
|
|
|
|
|
|
2001-05-04 06:15:33 +02:00
|
|
|
|
/* Start an inferior process and sets inferior_ptid to its pid.
|
1999-04-16 03:35:26 +02:00
|
|
|
|
EXEC_FILE is the file to run.
|
|
|
|
|
ALLARGS is a string containing the arguments to the program.
|
|
|
|
|
ENV is the environment vector to pass.
|
|
|
|
|
Returns process id. Errors reported with error().
|
|
|
|
|
On VxWorks, we ignore exec_file. */
|
1999-07-07 22:19:36 +02:00
|
|
|
|
|
1999-04-16 03:35:26 +02:00
|
|
|
|
static void
|
2000-07-30 03:48:28 +02:00
|
|
|
|
vx_create_inferior (char *exec_file, char *args, char **env)
|
1999-04-16 03:35:26 +02:00
|
|
|
|
{
|
|
|
|
|
enum clnt_stat status;
|
|
|
|
|
arg_array passArgs;
|
|
|
|
|
TASK_START taskStart;
|
|
|
|
|
|
|
|
|
|
memset ((char *) &passArgs, '\0', sizeof (passArgs));
|
|
|
|
|
memset ((char *) &taskStart, '\0', sizeof (taskStart));
|
|
|
|
|
|
|
|
|
|
/* parse arguments, put them in passArgs */
|
|
|
|
|
|
|
|
|
|
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");
|
|
|
|
|
|
|
|
|
|
/* Save the name of the running function */
|
|
|
|
|
vx_running = savestring (passArgs.arg_array_val[0],
|
|
|
|
|
strlen (passArgs.arg_array_val[0]));
|
|
|
|
|
|
|
|
|
|
push_target (&vx_run_ops);
|
2001-05-04 06:15:33 +02:00
|
|
|
|
inferior_ptid = pid_to_ptid (taskStart.pid);
|
1999-04-16 03:35:26 +02:00
|
|
|
|
|
|
|
|
|
/* We will get a trace trap after one instruction.
|
|
|
|
|
Insert breakpoints and continue. */
|
|
|
|
|
|
|
|
|
|
init_wait_for_inferior ();
|
|
|
|
|
|
|
|
|
|
/* 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 ();
|
|
|
|
|
|
|
|
|
|
stop_soon_quietly = 1;
|
|
|
|
|
wait_for_inferior (); /* Get the task spawn event */
|
|
|
|
|
stop_soon_quietly = 0;
|
|
|
|
|
|
|
|
|
|
/* insert_step_breakpoint (); FIXME, do we need this? */
|
|
|
|
|
proceed (-1, TARGET_SIGNAL_DEFAULT, 0);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* Fill ARGSTRUCT in argc/argv form with the arguments from the
|
|
|
|
|
argument string ARGSTRING. */
|
|
|
|
|
|
|
|
|
|
static void
|
2000-07-30 03:48:28 +02:00
|
|
|
|
parse_args (register char *arg_string, arg_array *arg_struct)
|
1999-04-16 03:35:26 +02:00
|
|
|
|
{
|
|
|
|
|
register int arg_count = 0; /* number of arguments */
|
|
|
|
|
register int arg_index = 0;
|
|
|
|
|
register char *p0;
|
1999-07-07 22:19:36 +02:00
|
|
|
|
|
1999-04-16 03:35:26 +02:00
|
|
|
|
memset ((char *) arg_struct, '\0', sizeof (arg_array));
|
1999-07-07 22:19:36 +02:00
|
|
|
|
|
1999-04-16 03:35:26 +02:00
|
|
|
|
/* first count how many arguments there are */
|
|
|
|
|
|
|
|
|
|
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 *));
|
|
|
|
|
|
|
|
|
|
/* now copy argument strings into arg_struct. */
|
|
|
|
|
|
|
|
|
|
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;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* Advance a string pointer across whitespace and return a pointer
|
|
|
|
|
to the first non-white character. */
|
|
|
|
|
|
|
|
|
|
static char *
|
2000-07-30 03:48:28 +02:00
|
|
|
|
skip_white_space (register char *p)
|
1999-04-16 03:35:26 +02:00
|
|
|
|
{
|
|
|
|
|
while (*p == ' ' || *p == '\t')
|
|
|
|
|
p++;
|
|
|
|
|
return p;
|
|
|
|
|
}
|
1999-07-07 22:19:36 +02:00
|
|
|
|
|
1999-04-16 03:35:26 +02:00
|
|
|
|
/* Search for the first unquoted whitespace character in a string.
|
|
|
|
|
Returns a pointer to the character, or to the null terminator
|
|
|
|
|
if no whitespace is found. */
|
|
|
|
|
|
|
|
|
|
static char *
|
2000-07-30 03:48:28 +02:00
|
|
|
|
find_white_space (register char *p)
|
1999-04-16 03:35:26 +02:00
|
|
|
|
{
|
|
|
|
|
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;
|
|
|
|
|
}
|
1999-07-07 22:19:36 +02:00
|
|
|
|
|
1999-04-16 03:35:26 +02:00
|
|
|
|
/* Poll the VxWorks target system for an event related
|
|
|
|
|
to the debugged task.
|
|
|
|
|
Returns -1 if remote wait failed, task status otherwise. */
|
|
|
|
|
|
|
|
|
|
static int
|
2000-07-30 03:48:28 +02:00
|
|
|
|
net_wait (RDB_EVENT *pEvent)
|
1999-04-16 03:35:26 +02:00
|
|
|
|
{
|
1999-07-07 22:19:36 +02:00
|
|
|
|
int pid;
|
|
|
|
|
enum clnt_stat status;
|
1999-04-16 03:35:26 +02:00
|
|
|
|
|
1999-07-07 22:19:36 +02:00
|
|
|
|
memset ((char *) pEvent, '\0', sizeof (RDB_EVENT));
|
1999-04-16 03:35:26 +02:00
|
|
|
|
|
2001-05-04 06:15:33 +02:00
|
|
|
|
pid = PIDGET inferior_ptid);
|
1999-07-07 22:19:36 +02:00
|
|
|
|
status = net_clnt_call (PROCESS_WAIT, xdr_int, &pid, xdr_RDB_EVENT,
|
|
|
|
|
pEvent);
|
|
|
|
|
|
|
|
|
|
/* return (status == RPC_SUCCESS)? pEvent->status: -1; */
|
|
|
|
|
if (status == RPC_SUCCESS)
|
|
|
|
|
return ((pEvent->status) ? 1 : 0);
|
|
|
|
|
else if (status == RPC_TIMEDOUT)
|
|
|
|
|
return (1);
|
|
|
|
|
else
|
|
|
|
|
return (-1);
|
1999-04-16 03:35:26 +02:00
|
|
|
|
}
|
1999-07-07 22:19:36 +02:00
|
|
|
|
|
1999-04-16 03:35:26 +02:00
|
|
|
|
/* Suspend the remote task.
|
|
|
|
|
Returns -1 if suspend fails on target system, 0 otherwise. */
|
|
|
|
|
|
|
|
|
|
static int
|
2000-07-30 03:48:28 +02:00
|
|
|
|
net_quit (void)
|
1999-04-16 03:35:26 +02:00
|
|
|
|
{
|
|
|
|
|
int pid;
|
|
|
|
|
int quit_status;
|
|
|
|
|
enum clnt_stat status;
|
|
|
|
|
|
|
|
|
|
quit_status = 0;
|
|
|
|
|
|
|
|
|
|
/* don't let rdbTask suspend itself by passing a pid of 0 */
|
|
|
|
|
|
2001-05-04 06:15:33 +02:00
|
|
|
|
if ((pid = PIDGET (inferior_ptid)) == 0)
|
1999-04-16 03:35:26 +02:00
|
|
|
|
return -1;
|
|
|
|
|
|
|
|
|
|
status = net_clnt_call (VX_TASK_SUSPEND, xdr_int, &pid, xdr_int,
|
|
|
|
|
&quit_status);
|
|
|
|
|
|
1999-07-07 22:19:36 +02:00
|
|
|
|
return (status == RPC_SUCCESS) ? quit_status : -1;
|
1999-04-16 03:35:26 +02:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* Read a register or registers from the remote system. */
|
|
|
|
|
|
|
|
|
|
void
|
2000-07-30 03:48:28 +02:00
|
|
|
|
net_read_registers (char *reg_buf, int len, u_long procnum)
|
1999-04-16 03:35:26 +02:00
|
|
|
|
{
|
|
|
|
|
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));
|
|
|
|
|
|
|
|
|
|
/* Initialize RPC input argument structure. */
|
|
|
|
|
|
2001-05-04 06:15:33 +02:00
|
|
|
|
ptrace_in.pid = PIDGET (inferior_ptid);
|
1999-04-16 03:35:26 +02:00
|
|
|
|
ptrace_in.info.ttype = NOINFO;
|
|
|
|
|
|
|
|
|
|
/* Initialize RPC return value structure. */
|
|
|
|
|
|
|
|
|
|
out_data.bytes = reg_buf;
|
|
|
|
|
out_data.len = len;
|
1999-07-07 22:19:36 +02:00
|
|
|
|
ptrace_out.info.more_data = (caddr_t) & out_data;
|
1999-04-16 03:35:26 +02:00
|
|
|
|
|
|
|
|
|
/* Call RPC; take an error exit if appropriate. */
|
|
|
|
|
|
|
|
|
|
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)
|
1999-07-07 22:19:36 +02:00
|
|
|
|
? "general-purpose"
|
|
|
|
|
: "floating-point");
|
1999-04-16 03:35:26 +02:00
|
|
|
|
perror_with_name (message);
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* Write register values to a VxWorks target. REG_BUF points to a buffer
|
|
|
|
|
containing the raw register values, LEN is the length of REG_BUF in
|
|
|
|
|
bytes, and PROCNUM is the RPC procedure number (PTRACE_SETREGS or
|
|
|
|
|
PTRACE_SETFPREGS). An error exit is taken if the RPC call fails or
|
|
|
|
|
if an error status is returned by the remote debug server. This is
|
|
|
|
|
a utility routine used by vx_write_register (). */
|
|
|
|
|
|
|
|
|
|
void
|
2000-07-30 03:48:28 +02:00
|
|
|
|
net_write_registers (char *reg_buf, int len, u_long procnum)
|
1999-04-16 03:35:26 +02:00
|
|
|
|
{
|
|
|
|
|
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));
|
|
|
|
|
|
|
|
|
|
/* Initialize RPC input argument structure. */
|
|
|
|
|
|
|
|
|
|
in_data.bytes = reg_buf;
|
|
|
|
|
in_data.len = len;
|
|
|
|
|
|
2001-05-04 06:15:33 +02:00
|
|
|
|
ptrace_in.pid = PIDGET (inferior_ptid);
|
1999-04-16 03:35:26 +02:00
|
|
|
|
ptrace_in.info.ttype = DATA;
|
1999-07-07 22:19:36 +02:00
|
|
|
|
ptrace_in.info.more_data = (caddr_t) & in_data;
|
1999-04-16 03:35:26 +02:00
|
|
|
|
|
|
|
|
|
/* Call RPC; take an error exit if appropriate. */
|
|
|
|
|
|
|
|
|
|
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)
|
1999-07-07 22:19:36 +02:00
|
|
|
|
? "general-purpose"
|
|
|
|
|
: "floating-point");
|
1999-04-16 03:35:26 +02:00
|
|
|
|
perror_with_name (message);
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* Prepare to store registers. Since we will store all of them,
|
|
|
|
|
read out their current values now. */
|
|
|
|
|
|
|
|
|
|
static void
|
2000-07-30 03:48:28 +02:00
|
|
|
|
vx_prepare_to_store (void)
|
1999-04-16 03:35:26 +02:00
|
|
|
|
{
|
|
|
|
|
/* Fetch all registers, if any of them are not yet fetched. */
|
|
|
|
|
read_register_bytes (0, NULL, REGISTER_BYTES);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* Copy LEN bytes to or from remote inferior's memory starting at MEMADDR
|
|
|
|
|
to debugger memory starting at MYADDR. WRITE is true if writing to the
|
2000-10-16 08:42:28 +02:00
|
|
|
|
inferior. TARGET is unused.
|
1999-04-16 03:35:26 +02:00
|
|
|
|
Result is the number of bytes written or read (zero if error). The
|
|
|
|
|
protocol allows us to return a negative count, indicating that we can't
|
|
|
|
|
handle the current address but can handle one N bytes further, but
|
|
|
|
|
vxworks doesn't give us that information. */
|
|
|
|
|
|
|
|
|
|
static int
|
2000-10-16 08:42:28 +02:00
|
|
|
|
vx_xfer_memory (CORE_ADDR memaddr, char *myaddr, int len, int write,
|
* exec.c (xfer_memory): Add attrib argument.
* infptrace.c (child_xfer_memory): Likewise.
* monitor.c (monitor_xfer_memory): Likewise.
* remote-adapt.c (adapt_xfer_inferior_memory): Likewise.
* remote-array.c (array_xfer_memory): Likewise.
* remote-bug.c (bug_xfer_memory): Likewise.
* remote-e7000.c (e7000_xfer_inferior_memory): Likewise.
* remote-eb.c (eb_xfer_inferior_memory): Likewise.
* remote-es.c (es1800_xfer_inferior_memory): Likewise.
* remote-mips.c (mips_xfer_memory): Likewise.
* remote-mm.c (mm_xfer_inferior_memory): Likewise.
* remote-nindy.c (nindy_xfer_inferior_memory): Likewise.
* remote-os9k.c (rombug_xfer_inferior_memory): Likewise.
* remote-rdi.c (arm_rdi_xfer_memory): Likewise.
* remote-rdp.c (remote_rdp_xfer_inferior_memory): Likewise.
* remote-sds.c (sds_xfer_memory): Likewise.
* remote-sim.c (gdbsim_xfer_inferior_memory): Likewise.
* remote-st.c (st2000_xfer_inferior_memory): Likewise.
* remote-udi.c (udi_xfer_inferior_memory): Likewise.
* remote-vx.c (vx_xfer_memory): Likewise.
* remote.c (remote_xfer_memory): Likewise.
* target.c (debug_to_xfer_memory, do_xfer_memory): Likewise.
* target.h (child_xfer_memory, do_xfer_memory, xfer_memory): Likewise.
* target.h (#include "memattr.h"): Added.
(target_ops.to_xfer_memory): Add attrib argument.
* wince.c (_initialize_inftarg): Removed call to set_dcache_state.
* dcache.h (set_dcache_state): Removed declaration.
* dcache.c (set_dcache_state): Removed definition
* dcache.c: Update module comment, as dcache is now enabled and
disabled with memory region attributes instead of by the global
variable "remotecache". Add comment describing the interaction
between dcache and memory region attributes.
(dcache_xfer_memory): Add comment describing benefits of moving
cache writeback to a higher level.
(dcache_struct): Removed cache_has_stuff field. This was used to
record whether the cache had been accessed in order to invalidate
it when it was disabled. However, this is not needed because the
cache is write through and the code that enables, disables, and
deletes memory regions invalidate the cache. Add comment which
suggests that we could be more selective and only invalidate those
cache lines containing data from those memory regions.
(dcache_invalidate): Updated.
(dcache_xfer_memory): Updated.
(dcache_alloc): Don't abort() if dcache_enabled_p is clear.
(dcache_xfer_memory): Removed code that called do_xfer_memory() to
perform a uncached transfer if dcache_enabled_p was clear. This
function is now only called if caching is enabled for the memory
region.
(dcache_info): Always print cache info.
* target.c (do_xfer_memory): Add attrib argument.
(target_xfer_memory, target_xfer_memory_partial): Break transfer
into chunks defined by memory regions, pass region attributes to
do_xfer_memory().
* dcache.c (dcache_read_line, dcache_write_line): Likewise.
* Makefile.in (SFILES): Add memattr.c.
(COMMON_OBS): Add memattr.o.
(dcache.o): Add target.h to dependencies.
* memattr.c: New file.
* memattr.h: Likewise.
2001-01-23 23:48:56 +01:00
|
|
|
|
struct mem_attrib *attrib ATTRIBUTE_UNUSED,
|
|
|
|
|
struct target_ops *target ATTRIBUTE_UNUSED)
|
1999-04-16 03:35:26 +02:00
|
|
|
|
{
|
|
|
|
|
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));
|
|
|
|
|
|
2001-05-04 06:15:33 +02:00
|
|
|
|
ptrace_in.pid = PIDGET (inferior_ptid); /* XXX pid unnecessary for READDATA */
|
1999-04-16 03:35:26 +02:00
|
|
|
|
ptrace_in.addr = (int) memaddr; /* Where from */
|
1999-07-07 22:19:36 +02:00
|
|
|
|
ptrace_in.data = len; /* How many bytes */
|
1999-04-16 03:35:26 +02:00
|
|
|
|
|
|
|
|
|
if (write)
|
|
|
|
|
{
|
1999-07-07 22:19:36 +02:00
|
|
|
|
ptrace_in.info.ttype = DATA;
|
|
|
|
|
ptrace_in.info.more_data = (caddr_t) & data;
|
1999-04-16 03:35:26 +02:00
|
|
|
|
|
|
|
|
|
data.bytes = (caddr_t) myaddr; /* Where from */
|
1999-07-07 22:19:36 +02:00
|
|
|
|
data.len = len; /* How many bytes (again, for XDR) */
|
1999-04-16 03:35:26 +02:00
|
|
|
|
request = PTRACE_WRITEDATA;
|
|
|
|
|
}
|
|
|
|
|
else
|
|
|
|
|
{
|
1999-07-07 22:19:36 +02:00
|
|
|
|
ptrace_out.info.more_data = (caddr_t) & data;
|
1999-04-16 03:35:26 +02:00
|
|
|
|
request = PTRACE_READDATA;
|
|
|
|
|
}
|
|
|
|
|
/* Loop until the entire request has been satisfied, transferring
|
|
|
|
|
at most VX_MEMXFER_MAX bytes per iteration. Break from the loop
|
|
|
|
|
if an error status is returned by the remote debug server. */
|
|
|
|
|
|
|
|
|
|
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;
|
|
|
|
|
|
|
|
|
|
/* Request a block from the remote debug server; if RPC fails,
|
|
|
|
|
report an error and return to debugger command level. */
|
|
|
|
|
|
|
|
|
|
if (net_ptrace_clnt_call (request, &ptrace_in, &ptrace_out))
|
1999-07-07 22:19:36 +02:00
|
|
|
|
error (rpcerr);
|
1999-04-16 03:35:26 +02:00
|
|
|
|
|
|
|
|
|
status = ptrace_out.status;
|
|
|
|
|
if (status == 0)
|
1999-07-07 22:19:36 +02:00
|
|
|
|
{
|
|
|
|
|
memaddr += nxfer;
|
|
|
|
|
myaddr += nxfer;
|
|
|
|
|
nleft -= nxfer;
|
|
|
|
|
}
|
1999-04-16 03:35:26 +02:00
|
|
|
|
else
|
1999-07-07 22:19:36 +02:00
|
|
|
|
{
|
|
|
|
|
/* A target-side error has ocurred. Set errno to the error
|
|
|
|
|
code chosen by the target so that a later perror () will
|
|
|
|
|
say something meaningful. */
|
1999-04-16 03:35:26 +02:00
|
|
|
|
|
1999-07-07 22:19:36 +02:00
|
|
|
|
errno = ptrace_out.errno_num;
|
|
|
|
|
}
|
1999-04-16 03:35:26 +02:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* Return the number of bytes transferred. */
|
|
|
|
|
|
|
|
|
|
return (len - nleft);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static void
|
2000-07-30 03:48:28 +02:00
|
|
|
|
vx_files_info (void)
|
1999-04-16 03:35:26 +02:00
|
|
|
|
{
|
|
|
|
|
printf_unfiltered ("\tAttached to host `%s'", vx_host);
|
1999-07-07 22:19:36 +02:00
|
|
|
|
printf_unfiltered (", which has %sfloating point", target_has_fp ? "" : "no ");
|
1999-04-16 03:35:26 +02:00
|
|
|
|
printf_unfiltered (".\n");
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static void
|
2000-07-30 03:48:28 +02:00
|
|
|
|
vx_run_files_info (void)
|
1999-04-16 03:35:26 +02:00
|
|
|
|
{
|
1999-07-07 22:19:36 +02:00
|
|
|
|
printf_unfiltered ("\tRunning %s VxWorks process %s",
|
1999-04-16 03:35:26 +02:00
|
|
|
|
vx_running ? "child" : "attached",
|
2001-05-04 06:15:33 +02:00
|
|
|
|
local_hex_string (PIDGET (inferior_ptid)));
|
1999-04-16 03:35:26 +02:00
|
|
|
|
if (vx_running)
|
|
|
|
|
printf_unfiltered (", function `%s'", vx_running);
|
1999-07-07 22:19:36 +02:00
|
|
|
|
printf_unfiltered (".\n");
|
1999-04-16 03:35:26 +02:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static void
|
2001-05-04 06:15:33 +02:00
|
|
|
|
vx_resume (ptid_t ptid, int step, enum target_signal siggnal)
|
1999-04-16 03:35:26 +02:00
|
|
|
|
{
|
|
|
|
|
int status;
|
|
|
|
|
Rptrace ptrace_in;
|
|
|
|
|
Ptrace_return ptrace_out;
|
|
|
|
|
CORE_ADDR cont_addr;
|
|
|
|
|
|
2001-05-04 06:15:33 +02:00
|
|
|
|
if (ptid_equal (ptid, minus_one_ptid))
|
|
|
|
|
ptid = inferior_ptid;
|
1999-04-16 03:35:26 +02:00
|
|
|
|
|
|
|
|
|
if (siggnal != 0 && siggnal != stop_signal)
|
|
|
|
|
error ("Cannot send signals to VxWorks processes");
|
|
|
|
|
|
|
|
|
|
/* Set CONT_ADDR to the address at which we are continuing,
|
|
|
|
|
or to 1 if we are continuing from where the program stopped.
|
|
|
|
|
This conforms to traditional ptrace () usage, but at the same
|
|
|
|
|
time has special meaning for the VxWorks remote debug server.
|
|
|
|
|
If the address is not 1, the server knows that the target
|
|
|
|
|
program is jumping to a new address, which requires special
|
|
|
|
|
handling if there is a breakpoint at the new address. */
|
|
|
|
|
|
|
|
|
|
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));
|
|
|
|
|
|
2001-05-04 06:15:33 +02:00
|
|
|
|
ptrace_in.pid = PIDGET (ptid);
|
1999-07-07 22:19:36 +02:00
|
|
|
|
ptrace_in.addr = cont_addr; /* Target side insists on this, or it panics. */
|
1999-04-16 03:35:26 +02:00
|
|
|
|
|
|
|
|
|
if (step)
|
1999-07-07 22:19:36 +02:00
|
|
|
|
status = net_step ();
|
1999-04-16 03:35:26 +02:00
|
|
|
|
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
|
2000-07-30 03:48:28 +02:00
|
|
|
|
vx_mourn_inferior (void)
|
1999-04-16 03:35:26 +02:00
|
|
|
|
{
|
|
|
|
|
pop_target (); /* Pop back to no-child state */
|
|
|
|
|
generic_mourn_inferior ();
|
|
|
|
|
}
|
|
|
|
|
|
1999-07-07 22:19:36 +02:00
|
|
|
|
|
2000-05-28 03:12:42 +02:00
|
|
|
|
static void vx_add_symbols (char *, int, CORE_ADDR, CORE_ADDR, CORE_ADDR);
|
1999-04-16 03:35:26 +02:00
|
|
|
|
|
1999-07-07 22:19:36 +02:00
|
|
|
|
struct find_sect_args
|
|
|
|
|
{
|
|
|
|
|
CORE_ADDR text_start;
|
|
|
|
|
CORE_ADDR data_start;
|
|
|
|
|
CORE_ADDR bss_start;
|
|
|
|
|
};
|
1999-04-16 03:35:26 +02:00
|
|
|
|
|
2000-05-28 03:12:42 +02:00
|
|
|
|
static void find_sect (bfd *, asection *, void *);
|
1999-04-16 03:35:26 +02:00
|
|
|
|
|
|
|
|
|
static void
|
2000-07-30 03:48:28 +02:00
|
|
|
|
find_sect (bfd *abfd, asection *sect, PTR obj)
|
1999-04-16 03:35:26 +02:00
|
|
|
|
{
|
1999-07-07 22:19:36 +02:00
|
|
|
|
struct find_sect_args *args = (struct find_sect_args *) obj;
|
1999-04-16 03:35:26 +02:00
|
|
|
|
|
|
|
|
|
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)
|
|
|
|
|
{
|
|
|
|
|
/* Exclude .ctor and .dtor sections which have SEC_CODE set but not
|
|
|
|
|
SEC_DATA. */
|
|
|
|
|
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
|
2000-07-30 03:48:28 +02:00
|
|
|
|
vx_add_symbols (char *name, int from_tty, CORE_ADDR text_addr,
|
|
|
|
|
CORE_ADDR data_addr, CORE_ADDR bss_addr)
|
1999-04-16 03:35:26 +02:00
|
|
|
|
{
|
|
|
|
|
struct section_offsets *offs;
|
|
|
|
|
struct objfile *objfile;
|
|
|
|
|
struct find_sect_args ss;
|
|
|
|
|
|
|
|
|
|
/* It might be nice to suppress the breakpoint_re_set which happens here
|
|
|
|
|
because we are going to do one again after the objfile_relocate. */
|
1999-10-12 06:37:53 +02:00
|
|
|
|
objfile = symbol_file_add (name, from_tty, NULL, 0, 0);
|
1999-04-16 03:35:26 +02:00
|
|
|
|
|
|
|
|
|
/* This is a (slightly cheesy) way of superceding the old symbols. A less
|
|
|
|
|
cheesy way would be to find the objfile with the same name and
|
|
|
|
|
free_objfile it. */
|
|
|
|
|
objfile_to_front (objfile);
|
|
|
|
|
|
1999-09-09 02:02:17 +02:00
|
|
|
|
offs = (struct section_offsets *) alloca (SIZEOF_SECTION_OFFSETS);
|
|
|
|
|
memcpy (offs, objfile->section_offsets, SIZEOF_SECTION_OFFSETS);
|
1999-04-16 03:35:26 +02:00
|
|
|
|
|
|
|
|
|
ss.text_start = 0;
|
|
|
|
|
ss.data_start = 0;
|
|
|
|
|
ss.bss_start = 0;
|
|
|
|
|
bfd_map_over_sections (objfile->obfd, find_sect, &ss);
|
|
|
|
|
|
|
|
|
|
/* Both COFF and b.out frontends use these SECT_OFF_* values. */
|
2000-08-28 00:30:29 +02:00
|
|
|
|
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;
|
1999-04-16 03:35:26 +02:00
|
|
|
|
objfile_relocate (objfile, offs);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* This function allows the addition of incrementally linked object files. */
|
|
|
|
|
|
|
|
|
|
static void
|
2000-07-30 03:48:28 +02:00
|
|
|
|
vx_load_command (char *arg_string, int from_tty)
|
1999-04-16 03:35:26 +02:00
|
|
|
|
{
|
|
|
|
|
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);
|
2000-12-15 02:01:51 +01:00
|
|
|
|
make_cleanup (xfree, arg_string);
|
1999-04-16 03:35:26 +02:00
|
|
|
|
|
|
|
|
|
dont_repeat ();
|
|
|
|
|
|
|
|
|
|
/* Refuse to load the module if a debugged task is running. Doing so
|
|
|
|
|
can have a number of unpleasant consequences to the running task. */
|
|
|
|
|
|
2001-05-04 06:15:33 +02:00
|
|
|
|
if (PIDGET (inferior_ptid) != 0 && target_has_execution)
|
1999-04-16 03:35:26 +02:00
|
|
|
|
{
|
|
|
|
|
if (query ("You may not load a module while the target task is running.\n\
|
|
|
|
|
Kill the target task? "))
|
1999-07-07 22:19:36 +02:00
|
|
|
|
target_kill ();
|
1999-04-16 03:35:26 +02:00
|
|
|
|
else
|
* gdbarch.sh, hp-psymtab-read.c, hpread.c, m3-nat.c, mcore-tdep.c,
mips-tdep.c, monitor.c, regcache.c, remote-es.c, ser-unix.c,
somread.c, tracepoint.c: Fix spelling errors in comments.
* gdbarch.c: Regenerate.
* gnu-nat.c (S_exception_raise_request): Fix typos and spelling
errors in strings.
* m3-nat.c (intercept_exec_calls, mach_thread_parse_id): Likewise.
* mcore-tdep.c (mcore_analyze_prologue): Likewise.
* mips-tdep.c (mips16_next_pc, _initialize_mips_tdep): Likewise.
* remote-e7000.c (e7000_start_remote): Likewise.
* remote-rdp.c (handle_swi): Likewise.
* remote-vx.c (vx_load_command): Likewise.
* sh-tdep.c (sh_do_pseudo_register): Likewise.
* sol-thread.c (td_err_string): Likewise.
* symtab.c (decode_line_2): Likewise.
-------------------------------------------------------------------
2000-10-30 22:50:58 +01:00
|
|
|
|
error ("Load canceled.");
|
1999-04-16 03:35:26 +02:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
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);
|
|
|
|
|
|
|
|
|
|
/* Getting new symbols may change our opinion about what is
|
|
|
|
|
frameless. */
|
|
|
|
|
reinit_frame_cache ();
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* Single step the target program at the source or machine level.
|
|
|
|
|
Takes an error exit if rpc fails.
|
|
|
|
|
Returns -1 if remote single-step operation fails, else 0. */
|
|
|
|
|
|
|
|
|
|
static int
|
2000-07-30 03:48:28 +02:00
|
|
|
|
net_step (void)
|
1999-04-16 03:35:26 +02:00
|
|
|
|
{
|
|
|
|
|
enum clnt_stat status;
|
|
|
|
|
int step_status;
|
|
|
|
|
SOURCE_STEP source_step;
|
|
|
|
|
|
2001-05-04 06:15:33 +02:00
|
|
|
|
source_step.taskId = PIDGET (inferior_ptid);
|
1999-04-16 03:35:26 +02:00
|
|
|
|
|
|
|
|
|
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;
|
1999-07-07 22:19:36 +02:00
|
|
|
|
else
|
1999-04-16 03:35:26 +02:00
|
|
|
|
error (rpcerr);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* Emulate ptrace using RPC calls to the VxWorks target system.
|
|
|
|
|
Returns nonzero (-1) if RPC status to VxWorks is bad, 0 otherwise. */
|
|
|
|
|
|
|
|
|
|
static int
|
2000-07-30 03:48:28 +02:00
|
|
|
|
net_ptrace_clnt_call (enum ptracereq request, Rptrace *pPtraceIn,
|
|
|
|
|
Ptrace_return *pPtraceOut)
|
1999-04-16 03:35:26 +02:00
|
|
|
|
{
|
|
|
|
|
enum clnt_stat status;
|
|
|
|
|
|
|
|
|
|
status = net_clnt_call (request, xdr_rptrace, pPtraceIn, xdr_ptrace_return,
|
|
|
|
|
pPtraceOut);
|
|
|
|
|
|
|
|
|
|
if (status != RPC_SUCCESS)
|
1999-07-07 22:19:36 +02:00
|
|
|
|
return -1;
|
1999-04-16 03:35:26 +02:00
|
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* Query the target for the name of the file from which VxWorks was
|
|
|
|
|
booted. pBootFile is the address of a pointer to the buffer to
|
|
|
|
|
receive the file name; if the pointer pointed to by pBootFile is
|
|
|
|
|
NULL, memory for the buffer will be allocated by XDR.
|
|
|
|
|
Returns -1 if rpc failed, 0 otherwise. */
|
|
|
|
|
|
|
|
|
|
static int
|
2000-07-30 03:48:28 +02:00
|
|
|
|
net_get_boot_file (char **pBootFile)
|
1999-04-16 03:35:26 +02:00
|
|
|
|
{
|
|
|
|
|
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;
|
|
|
|
|
}
|
|
|
|
|
|
2000-10-16 08:42:28 +02:00
|
|
|
|
/* Fetch a list of loaded object modules from the VxWorks target
|
|
|
|
|
and store in PLOADTABLE.
|
1999-04-16 03:35:26 +02:00
|
|
|
|
Returns -1 if rpc failed, 0 otherwise
|
|
|
|
|
There's no way to check if the returned loadTable is correct.
|
|
|
|
|
VxWorks doesn't check it. */
|
|
|
|
|
|
|
|
|
|
static int
|
2000-10-16 08:42:28 +02:00
|
|
|
|
net_get_symbols (ldtabl *pLoadTable)
|
1999-04-16 03:35:26 +02:00
|
|
|
|
{
|
|
|
|
|
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;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* Look up a symbol in the VxWorks target's symbol table.
|
|
|
|
|
Returns status of symbol read on target side (0=success, -1=fail)
|
|
|
|
|
Returns -1 and complain()s if rpc fails. */
|
|
|
|
|
|
|
|
|
|
struct complaint cant_contact_target =
|
1999-07-07 22:19:36 +02:00
|
|
|
|
{"Lost contact with VxWorks target", 0, 0};
|
1999-04-16 03:35:26 +02:00
|
|
|
|
|
|
|
|
|
static int
|
2000-07-30 03:48:28 +02:00
|
|
|
|
vx_lookup_symbol (char *name, /* symbol name */
|
|
|
|
|
CORE_ADDR *pAddr)
|
1999-04-16 03:35:26 +02:00
|
|
|
|
{
|
|
|
|
|
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)
|
|
|
|
|
{
|
|
|
|
|
complain (&cant_contact_target);
|
|
|
|
|
return -1;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
*pAddr = symbolAddr.addr;
|
|
|
|
|
return symbolAddr.status;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* Check to see if the VxWorks target has a floating point coprocessor.
|
|
|
|
|
Returns 1 if target has floating point processor, 0 otherwise.
|
|
|
|
|
Calls error() if rpc fails. */
|
|
|
|
|
|
|
|
|
|
static int
|
2000-07-30 03:48:28 +02:00
|
|
|
|
net_check_for_fp (void)
|
1999-04-16 03:35:26 +02:00
|
|
|
|
{
|
|
|
|
|
enum clnt_stat status;
|
1999-07-07 22:19:36 +02:00
|
|
|
|
bool_t fp = 0; /* true if fp processor is present on target board */
|
1999-04-16 03:35:26 +02:00
|
|
|
|
|
|
|
|
|
status = net_clnt_call (VX_FP_INQUIRE, xdr_void, 0, xdr_bool, &fp);
|
|
|
|
|
if (status != RPC_SUCCESS)
|
|
|
|
|
error (rpcerr);
|
|
|
|
|
|
1999-07-07 22:19:36 +02:00
|
|
|
|
return (int) fp;
|
1999-04-16 03:35:26 +02:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* Establish an RPC connection with the VxWorks target system.
|
|
|
|
|
Calls error () if unable to establish connection. */
|
|
|
|
|
|
|
|
|
|
static void
|
2000-07-30 03:48:28 +02:00
|
|
|
|
net_connect (char *host)
|
1999-04-16 03:35:26 +02:00
|
|
|
|
{
|
|
|
|
|
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. */
|
|
|
|
|
|
|
|
|
|
addr = inet_addr (host);
|
|
|
|
|
if (addr == -1)
|
|
|
|
|
{
|
|
|
|
|
destHost = (struct hostent *) gethostbyname (host);
|
|
|
|
|
if (destHost == NULL)
|
|
|
|
|
/* FIXME: Probably should include hostname here in quotes.
|
|
|
|
|
For example if the user types "target vxworks vx960 " it should
|
|
|
|
|
say "Invalid host `vx960 '." not just "Invalid hostname". */
|
|
|
|
|
error ("Invalid hostname. Couldn't find remote host address.");
|
1999-07-07 22:19:36 +02:00
|
|
|
|
addr = *(unsigned long *) destHost->h_addr;
|
1999-04-16 03:35:26 +02:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
memset (&destAddr, '\0', sizeof (destAddr));
|
|
|
|
|
|
|
|
|
|
destAddr.sin_addr.s_addr = addr;
|
1999-07-07 22:19:36 +02:00
|
|
|
|
destAddr.sin_family = AF_INET;
|
|
|
|
|
destAddr.sin_port = 0; /* set to actual port that remote
|
|
|
|
|
ptrace is listening on. */
|
1999-04-16 03:35:26 +02:00
|
|
|
|
|
|
|
|
|
/* Create a tcp client transport on which to issue
|
|
|
|
|
calls to the remote ptrace server. */
|
|
|
|
|
|
|
|
|
|
ptraceSock = RPC_ANYSOCK;
|
|
|
|
|
pClient = clnttcp_create (&destAddr, RDBPROG, RDBVERS, &ptraceSock, 0, 0);
|
|
|
|
|
/* FIXME, here is where we deal with different version numbers of the
|
|
|
|
|
proto */
|
|
|
|
|
|
|
|
|
|
if (pClient == NULL)
|
|
|
|
|
{
|
|
|
|
|
clnt_pcreateerror ("\tnet_connect");
|
|
|
|
|
error ("Couldn't connect to remote target.");
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* Sleep for the specified number of milliseconds
|
|
|
|
|
* (assumed to be less than 1000).
|
|
|
|
|
* If select () is interrupted, returns immediately;
|
|
|
|
|
* takes an error exit if select () fails for some other reason.
|
|
|
|
|
*/
|
|
|
|
|
|
|
|
|
|
static void
|
2000-07-30 03:48:28 +02:00
|
|
|
|
sleep_ms (long ms)
|
1999-04-16 03:35:26 +02:00
|
|
|
|
{
|
|
|
|
|
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");
|
|
|
|
|
}
|
|
|
|
|
|
2001-05-04 06:15:33 +02:00
|
|
|
|
static ptid_t
|
|
|
|
|
vx_wait (ptid_t ptid_to_wait_for, struct target_waitstatus *status)
|
1999-04-16 03:35:26 +02:00
|
|
|
|
{
|
|
|
|
|
register int pid;
|
|
|
|
|
RDB_EVENT rdbEvent;
|
|
|
|
|
int quit_failed;
|
|
|
|
|
|
|
|
|
|
do
|
|
|
|
|
{
|
|
|
|
|
/* If CTRL-C is hit during this loop,
|
1999-07-07 22:19:36 +02:00
|
|
|
|
suspend the inferior process. */
|
1999-04-16 03:35:26 +02:00
|
|
|
|
|
|
|
|
|
quit_failed = 0;
|
|
|
|
|
if (quit_flag)
|
|
|
|
|
{
|
|
|
|
|
quit_failed = (net_quit () == -1);
|
|
|
|
|
quit_flag = 0;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* If a net_quit () or net_wait () call has failed,
|
1999-07-07 22:19:36 +02:00
|
|
|
|
allow the user to break the connection with the target.
|
|
|
|
|
We can't simply error () out of this loop, since the
|
|
|
|
|
data structures representing the state of the inferior
|
|
|
|
|
are in an inconsistent state. */
|
1999-04-16 03:35:26 +02:00
|
|
|
|
|
|
|
|
|
if (quit_failed || net_wait (&rdbEvent) == -1)
|
|
|
|
|
{
|
|
|
|
|
terminal_ours ();
|
|
|
|
|
if (query ("Can't %s. Disconnect from target system? ",
|
|
|
|
|
(quit_failed) ? "suspend remote task"
|
1999-07-07 22:19:36 +02:00
|
|
|
|
: "get status of remote task"))
|
1999-04-16 03:35:26 +02:00
|
|
|
|
{
|
1999-07-07 22:19:36 +02:00
|
|
|
|
target_mourn_inferior ();
|
1999-04-16 03:35:26 +02:00
|
|
|
|
error ("Use the \"target\" command to reconnect.");
|
|
|
|
|
}
|
|
|
|
|
else
|
|
|
|
|
{
|
|
|
|
|
terminal_inferior ();
|
|
|
|
|
continue;
|
|
|
|
|
}
|
|
|
|
|
}
|
1999-07-07 22:19:36 +02:00
|
|
|
|
|
1999-04-16 03:35:26 +02:00
|
|
|
|
pid = rdbEvent.taskId;
|
|
|
|
|
if (pid == 0)
|
|
|
|
|
{
|
|
|
|
|
sleep_ms (200); /* FIXME Don't kill the network too badly */
|
|
|
|
|
}
|
2001-05-04 06:15:33 +02:00
|
|
|
|
else if (pid != PIDGET (inferior_ptid))
|
2001-02-08 07:03:54 +01:00
|
|
|
|
internal_error (__FILE__, __LINE__,
|
|
|
|
|
"Bad pid for debugged task: %s\n",
|
1999-08-09 23:36:23 +02:00
|
|
|
|
local_hex_string ((unsigned long) pid));
|
1999-07-07 22:19:36 +02:00
|
|
|
|
}
|
|
|
|
|
while (pid == 0);
|
1999-04-16 03:35:26 +02:00
|
|
|
|
|
|
|
|
|
/* The mostly likely kind. */
|
|
|
|
|
status->kind = TARGET_WAITKIND_STOPPED;
|
|
|
|
|
|
|
|
|
|
switch (rdbEvent.eventType)
|
|
|
|
|
{
|
|
|
|
|
case EVENT_EXIT:
|
|
|
|
|
status->kind = TARGET_WAITKIND_EXITED;
|
|
|
|
|
/* FIXME is it possible to distinguish between a
|
1999-07-07 22:19:36 +02:00
|
|
|
|
normal vs abnormal exit in VxWorks? */
|
1999-04-16 03:35:26 +02:00
|
|
|
|
status->value.integer = 0;
|
|
|
|
|
break;
|
|
|
|
|
|
|
|
|
|
case EVENT_START:
|
|
|
|
|
/* Task was just started. */
|
|
|
|
|
status->value.sig = TARGET_SIGNAL_TRAP;
|
|
|
|
|
break;
|
|
|
|
|
|
|
|
|
|
case EVENT_STOP:
|
|
|
|
|
status->value.sig = TARGET_SIGNAL_TRAP;
|
|
|
|
|
/* XXX was it stopped by a signal? act accordingly */
|
|
|
|
|
break;
|
|
|
|
|
|
|
|
|
|
case EVENT_BREAK: /* Breakpoint was hit. */
|
|
|
|
|
status->value.sig = TARGET_SIGNAL_TRAP;
|
|
|
|
|
break;
|
|
|
|
|
|
1999-07-07 22:19:36 +02:00
|
|
|
|
case EVENT_SUSPEND: /* Task was suspended, probably by ^C. */
|
1999-04-16 03:35:26 +02:00
|
|
|
|
status->value.sig = TARGET_SIGNAL_INT;
|
|
|
|
|
break;
|
|
|
|
|
|
1999-07-07 22:19:36 +02:00
|
|
|
|
case EVENT_BUS_ERR: /* Task made evil nasty reference. */
|
1999-04-16 03:35:26 +02:00
|
|
|
|
status->value.sig = TARGET_SIGNAL_BUS;
|
|
|
|
|
break;
|
|
|
|
|
|
|
|
|
|
case EVENT_ZERO_DIV: /* Division by zero */
|
|
|
|
|
status->value.sig = TARGET_SIGNAL_FPE;
|
|
|
|
|
break;
|
|
|
|
|
|
|
|
|
|
case EVENT_SIGNAL:
|
|
|
|
|
#ifdef I80960
|
|
|
|
|
status->value.sig = i960_fault_to_signal (rdbEvent.sigType);
|
|
|
|
|
#else
|
|
|
|
|
/* Back in the old days, before enum target_signal, this code used
|
1999-07-07 22:19:36 +02:00
|
|
|
|
to add NSIG to the signal number and claim that PRINT_RANDOM_SIGNAL
|
|
|
|
|
would take care of it. But PRINT_RANDOM_SIGNAL has never been
|
|
|
|
|
defined except on the i960, so I don't really know what we are
|
|
|
|
|
supposed to do on other architectures. */
|
1999-04-16 03:35:26 +02:00
|
|
|
|
status->value.sig = TARGET_SIGNAL_UNKNOWN;
|
|
|
|
|
#endif
|
|
|
|
|
break;
|
1999-07-07 22:19:36 +02:00
|
|
|
|
} /* switch */
|
2001-05-04 06:15:33 +02:00
|
|
|
|
return pid_to_ptid (pid);
|
1999-04-16 03:35:26 +02:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static int
|
2000-07-30 03:48:28 +02:00
|
|
|
|
symbol_stub (char *arg)
|
1999-04-16 03:35:26 +02:00
|
|
|
|
{
|
2001-01-27 01:43:26 +01:00
|
|
|
|
symbol_file_add_main (arg, 0);
|
1999-04-16 03:35:26 +02:00
|
|
|
|
return 1;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static int
|
2000-07-30 03:48:28 +02:00
|
|
|
|
add_symbol_stub (char *arg)
|
1999-04-16 03:35:26 +02:00
|
|
|
|
{
|
1999-07-07 22:19:36 +02:00
|
|
|
|
struct ldfile *pLoadFile = (struct ldfile *) arg;
|
1999-04-16 03:35:26 +02:00
|
|
|
|
|
1999-07-07 22:19:36 +02:00
|
|
|
|
printf_unfiltered ("\t%s: ", pLoadFile->name);
|
1999-04-16 03:35:26 +02:00
|
|
|
|
vx_add_symbols (pLoadFile->name, 0, pLoadFile->txt_addr,
|
|
|
|
|
pLoadFile->data_addr, pLoadFile->bss_addr);
|
|
|
|
|
printf_unfiltered ("ok\n");
|
|
|
|
|
return 1;
|
|
|
|
|
}
|
|
|
|
|
/* Target command for VxWorks target systems.
|
|
|
|
|
|
|
|
|
|
Used in vxgdb. Takes the name of a remote target machine
|
|
|
|
|
running vxWorks and connects to it to initialize remote network
|
|
|
|
|
debugging. */
|
|
|
|
|
|
|
|
|
|
static void
|
2000-07-30 03:48:28 +02:00
|
|
|
|
vx_open (char *args, int from_tty)
|
1999-04-16 03:35:26 +02:00
|
|
|
|
{
|
|
|
|
|
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);
|
1999-07-07 22:19:36 +02:00
|
|
|
|
|
1999-04-16 03:35:26 +02:00
|
|
|
|
unpush_target (&vx_ops);
|
|
|
|
|
printf_unfiltered ("Attaching remote machine across net...\n");
|
|
|
|
|
gdb_flush (gdb_stdout);
|
|
|
|
|
|
|
|
|
|
/* Allow the user to kill the connect attempt by typing ^C.
|
|
|
|
|
Wait until the call to target_has_fp () completes before
|
|
|
|
|
disallowing an immediate quit, since even if net_connect ()
|
|
|
|
|
is successful, the remote debug server might be hung. */
|
|
|
|
|
|
|
|
|
|
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);
|
|
|
|
|
|
|
|
|
|
/* Save a copy of the target host's name. */
|
|
|
|
|
vx_host = savestring (args, strlen (args));
|
|
|
|
|
|
|
|
|
|
/* Find out the name of the file from which the target was booted
|
|
|
|
|
and load its symbol table. */
|
|
|
|
|
|
|
|
|
|
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);
|
|
|
|
|
/* This assumes that the kernel is never relocated. Hope that is an
|
|
|
|
|
accurate assumption. */
|
|
|
|
|
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");
|
|
|
|
|
|
1999-07-07 22:19:36 +02:00
|
|
|
|
i = 0 - 1;
|
1999-04-16 03:35:26 +02:00
|
|
|
|
while (++i < loadTable.tbl_size)
|
|
|
|
|
{
|
1999-07-07 22:19:36 +02:00
|
|
|
|
QUIT; /* FIXME, avoids clnt_freeres below: mem leak */
|
|
|
|
|
pLoadFile = &loadTable.tbl_ent[i];
|
1999-04-16 03:35:26 +02:00
|
|
|
|
#ifdef WRS_ORIG
|
1999-07-07 22:19:36 +02:00
|
|
|
|
{
|
|
|
|
|
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);
|
|
|
|
|
}
|
1999-04-16 03:35:26 +02:00
|
|
|
|
#else
|
|
|
|
|
/* FIXME: Is there something better to search than the PATH? (probably
|
1999-07-07 22:19:36 +02:00
|
|
|
|
not the source path, since source might be in different directories
|
|
|
|
|
than objects. */
|
1999-04-16 03:35:26 +02:00
|
|
|
|
|
1999-07-07 22:19:36 +02:00
|
|
|
|
if (catch_errors (add_symbol_stub, (char *) pLoadFile, (char *) 0,
|
1999-04-16 03:35:26 +02:00
|
|
|
|
RETURN_MASK_ALL))
|
|
|
|
|
symbols_added = 1;
|
|
|
|
|
#endif
|
|
|
|
|
}
|
|
|
|
|
printf_filtered ("Done.\n");
|
|
|
|
|
|
|
|
|
|
clnt_freeres (pClient, xdr_ldtabl, &loadTable);
|
|
|
|
|
|
|
|
|
|
/* Getting new symbols may change our opinion about what is
|
|
|
|
|
frameless. */
|
|
|
|
|
if (symbols_added)
|
|
|
|
|
reinit_frame_cache ();
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* 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
|
2000-07-30 03:48:28 +02:00
|
|
|
|
vx_attach (char *args, int from_tty)
|
1999-04-16 03:35:26 +02:00
|
|
|
|
{
|
|
|
|
|
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",
|
1999-07-07 22:19:36 +02:00
|
|
|
|
local_hex_string ((unsigned long) pid));
|
1999-04-16 03:35:26 +02:00
|
|
|
|
|
1999-07-07 22:19:36 +02:00
|
|
|
|
memset ((char *) &ptrace_in, '\0', sizeof (ptrace_in));
|
|
|
|
|
memset ((char *) &ptrace_out, '\0', sizeof (ptrace_out));
|
1999-04-16 03:35:26 +02:00
|
|
|
|
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");
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* It worked... */
|
|
|
|
|
|
2001-05-04 06:15:33 +02:00
|
|
|
|
inferior_ptid = pid_to_ptid (pid);
|
1999-04-16 03:35:26 +02:00
|
|
|
|
push_target (&vx_run_ops);
|
|
|
|
|
|
|
|
|
|
if (vx_running)
|
2000-12-15 02:01:51 +01:00
|
|
|
|
xfree (vx_running);
|
1999-04-16 03:35:26 +02:00
|
|
|
|
vx_running = 0;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* detach_command --
|
|
|
|
|
takes a program previously attached to and detaches it.
|
|
|
|
|
The program resumes execution and will no longer stop
|
|
|
|
|
on signals, etc. We better not have left any breakpoints
|
|
|
|
|
in the program or it'll die when it hits one. For this
|
|
|
|
|
to work, it may be necessary for the process to have been
|
|
|
|
|
previously attached. It *might* work if the program was
|
|
|
|
|
started via the normal ptrace (PTRACE_TRACEME). */
|
|
|
|
|
|
|
|
|
|
static void
|
2000-07-30 03:48:28 +02:00
|
|
|
|
vx_detach (char *args, int from_tty)
|
1999-04-16 03:35:26 +02:00
|
|
|
|
{
|
|
|
|
|
Rptrace ptrace_in;
|
|
|
|
|
Ptrace_return ptrace_out;
|
|
|
|
|
int signal = 0;
|
|
|
|
|
int status;
|
|
|
|
|
|
|
|
|
|
if (args)
|
|
|
|
|
error ("Argument given to VxWorks \"detach\".");
|
|
|
|
|
|
|
|
|
|
if (from_tty)
|
1999-07-07 22:19:36 +02:00
|
|
|
|
printf_unfiltered ("Detaching pid %s.\n",
|
2001-05-04 06:15:33 +02:00
|
|
|
|
local_hex_string (
|
|
|
|
|
(unsigned long) PIDGET (inferior_ptid)));
|
1999-04-16 03:35:26 +02:00
|
|
|
|
|
1999-07-07 22:19:36 +02:00
|
|
|
|
if (args) /* FIXME, should be possible to leave suspended */
|
1999-04-16 03:35:26 +02:00
|
|
|
|
signal = atoi (args);
|
1999-07-07 22:19:36 +02:00
|
|
|
|
|
|
|
|
|
memset ((char *) &ptrace_in, '\0', sizeof (ptrace_in));
|
|
|
|
|
memset ((char *) &ptrace_out, '\0', sizeof (ptrace_out));
|
2001-05-04 06:15:33 +02:00
|
|
|
|
ptrace_in.pid = PIDGET (inferior_ptid);
|
1999-04-16 03:35:26 +02:00
|
|
|
|
|
|
|
|
|
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");
|
|
|
|
|
}
|
|
|
|
|
|
2001-05-04 06:15:33 +02:00
|
|
|
|
inferior_ptid = null_ptid;
|
1999-07-07 22:19:36 +02:00
|
|
|
|
pop_target (); /* go back to non-executing VxWorks connection */
|
1999-04-16 03:35:26 +02:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* vx_kill -- takes a running task and wipes it out. */
|
|
|
|
|
|
|
|
|
|
static void
|
2000-07-30 03:48:28 +02:00
|
|
|
|
vx_kill (void)
|
1999-04-16 03:35:26 +02:00
|
|
|
|
{
|
|
|
|
|
Rptrace ptrace_in;
|
|
|
|
|
Ptrace_return ptrace_out;
|
|
|
|
|
int status;
|
|
|
|
|
|
2001-05-04 06:15:33 +02:00
|
|
|
|
printf_unfiltered ("Killing pid %s.\n", local_hex_string ((unsigned long) PIDGET (inferior_ptid)));
|
1999-04-16 03:35:26 +02:00
|
|
|
|
|
1999-07-07 22:19:36 +02:00
|
|
|
|
memset ((char *) &ptrace_in, '\0', sizeof (ptrace_in));
|
|
|
|
|
memset ((char *) &ptrace_out, '\0', sizeof (ptrace_out));
|
2001-05-04 06:15:33 +02:00
|
|
|
|
ptrace_in.pid = PIDGET (inferior_ptid);
|
1999-04-16 03:35:26 +02:00
|
|
|
|
|
|
|
|
|
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");
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* If it gives good status, the process is *gone*, no events remain.
|
|
|
|
|
If the kill failed, assume the process is gone anyhow. */
|
2001-05-04 06:15:33 +02:00
|
|
|
|
inferior_ptid = null_ptid;
|
1999-07-07 22:19:36 +02:00
|
|
|
|
pop_target (); /* go back to non-executing VxWorks connection */
|
1999-04-16 03:35:26 +02:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* Clean up from the VxWorks process target as it goes away. */
|
|
|
|
|
|
|
|
|
|
static void
|
2000-07-30 03:48:28 +02:00
|
|
|
|
vx_proc_close (int quitting)
|
1999-04-16 03:35:26 +02:00
|
|
|
|
{
|
2001-05-04 06:15:33 +02:00
|
|
|
|
inferior_ptid = null_ptid; /* No longer have a process. */
|
1999-04-16 03:35:26 +02:00
|
|
|
|
if (vx_running)
|
2000-12-15 02:01:51 +01:00
|
|
|
|
xfree (vx_running);
|
1999-04-16 03:35:26 +02:00
|
|
|
|
vx_running = 0;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* Make an RPC call to the VxWorks target.
|
|
|
|
|
Returns RPC status. */
|
|
|
|
|
|
|
|
|
|
static enum clnt_stat
|
2000-07-30 03:48:28 +02:00
|
|
|
|
net_clnt_call (enum ptracereq procNum, xdrproc_t inProc, char *in,
|
|
|
|
|
xdrproc_t outProc, char *out)
|
1999-04-16 03:35:26 +02:00
|
|
|
|
{
|
|
|
|
|
enum clnt_stat status;
|
1999-07-07 22:19:36 +02:00
|
|
|
|
|
1999-04-16 03:35:26 +02:00
|
|
|
|
status = clnt_call (pClient, procNum, inProc, in, outProc, out, rpcTimeout);
|
|
|
|
|
|
|
|
|
|
if (status != RPC_SUCCESS)
|
1999-07-07 22:19:36 +02:00
|
|
|
|
clnt_perrno (status);
|
1999-04-16 03:35:26 +02:00
|
|
|
|
|
|
|
|
|
return status;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* Clean up before losing control. */
|
|
|
|
|
|
|
|
|
|
static void
|
2000-07-30 03:48:28 +02:00
|
|
|
|
vx_close (int quitting)
|
1999-04-16 03:35:26 +02:00
|
|
|
|
{
|
|
|
|
|
if (pClient)
|
|
|
|
|
clnt_destroy (pClient); /* The net connection */
|
|
|
|
|
pClient = 0;
|
|
|
|
|
|
|
|
|
|
if (vx_host)
|
2000-12-15 02:01:51 +01:00
|
|
|
|
xfree (vx_host); /* The hostname */
|
1999-04-16 03:35:26 +02:00
|
|
|
|
vx_host = 0;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* A vxprocess target should be started via "run" not "target". */
|
1999-07-07 22:19:36 +02:00
|
|
|
|
/*ARGSUSED */
|
1999-04-16 03:35:26 +02:00
|
|
|
|
static void
|
2000-07-30 03:48:28 +02:00
|
|
|
|
vx_proc_open (char *name, int from_tty)
|
1999-04-16 03:35:26 +02:00
|
|
|
|
{
|
|
|
|
|
error ("Use the \"run\" command to start a VxWorks process.");
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static void
|
2000-07-30 03:48:28 +02:00
|
|
|
|
init_vx_ops (void)
|
1999-04-16 03:35:26 +02:00
|
|
|
|
{
|
|
|
|
|
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;
|
1999-07-07 22:19:36 +02:00
|
|
|
|
vx_ops.to_magic = OPS_MAGIC; /* Always the last thing */
|
1999-04-16 03:35:26 +02:00
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
static void
|
2000-07-30 03:48:28 +02:00
|
|
|
|
init_vx_run_ops (void)
|
1999-04-16 03:35:26 +02:00
|
|
|
|
{
|
|
|
|
|
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;
|
1999-07-07 22:19:36 +02:00
|
|
|
|
vx_run_ops.to_mourn_inferior = vx_mourn_inferior;
|
1999-04-16 03:35:26 +02:00
|
|
|
|
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;
|
1999-07-07 22:19:36 +02:00
|
|
|
|
vx_run_ops.to_has_execution = 1;
|
|
|
|
|
vx_run_ops.to_magic = OPS_MAGIC;
|
1999-04-16 03:35:26 +02:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
void
|
2000-07-30 03:48:28 +02:00
|
|
|
|
_initialize_vx (void)
|
1999-04-16 03:35:26 +02:00
|
|
|
|
{
|
|
|
|
|
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);
|
|
|
|
|
}
|