Subversion Repositories or1k

/* Memory-access and commands for remote VxWorks processes, for GDB.

   Copyright (C) 1990-95, 1997-98, 1999 Free Software Foundation, Inc.

   Contributed by Wind River Systems and Cygnus Support.

   This file is part of GDB.

   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.

   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.

   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.  */

#include "defs.h"

#include "frame.h"

#include "inferior.h"

#include "gdb_wait.h"

#include "target.h"

#include "gdbcore.h"

#include "command.h"

#include "symtab.h"

#include "complaints.h"

#include "gdbcmd.h"

#include "bfd.h"                /* Required by objfiles.h.  */

#include "symfile.h"            /* Required by objfiles.h.  */

#include "objfiles.h"

#include "gdb-stabs.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     /* 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 ();

extern int stop_soon_quietly;   /* for wait_for_inferior */

static int net_step ();

static int net_ptrace_clnt_call ();     /* Forward decl */

static enum clnt_stat net_clnt_call ();         /* Forward decl */

/* 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;

static char *vx_running;        /* Called function */

/* 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";

CLIENT *pClient;                /* client used in net debugging */

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 ();

/* 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

net_load (filename, pTextAddr, pDataAddr, pBssAddr)

     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));

  /* 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...  */

  load_timeout.tv_sec = 99999999;       /* A large number, effectively inf. */

  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)   /* 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

net_break (addr, procnum)

     int addr;

     u_long procnum;

{

  enum clnt_stat status;

  int break_status;

  Rptrace ptrace_in;            /* XXX This is stupid.  It doesn't need to be a ptrace

                                   structure.  How about something smaller? */

  memset ((char *) &ptrace_in, '\0', sizeof (ptrace_in));

  break_status = 0;

  ptrace_in.addr = addr;

  ptrace_in.pid = inferior_pid;

  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;          /* probably (FIXME) zero */

}

/* returns 0 if successful, errno otherwise */

static int

vx_insert_breakpoint (addr)

     int addr;

{

  return net_break (addr, VX_BREAK_ADD);

}

/* returns 0 if successful, errno otherwise */

static int

vx_remove_breakpoint (addr)

     int addr;

{

  return net_break (addr, VX_BREAK_DELETE);

}

/* Start an inferior process and sets inferior_pid to its pid.

   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.  */

static void

vx_create_inferior (exec_file, args, env)

     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 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);

  inferior_pid = taskStart.pid;

  /* 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

parse_args (arg_string, arg_struct)

     register char *arg_string;

     arg_array *arg_struct;

{

  register int arg_count = 0;    /* number of arguments */

  register int arg_index = 0;

  register char *p0;

  memset ((char *) arg_struct, '\0', sizeof (arg_array));

  /* 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 *

skip_white_space (p)

     register char *p;

{

  while (*p == ' ' || *p == '\t')

    p++;

  return p;

}

/* 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 *

find_white_space (p)

     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;

}

/* Poll the VxWorks target system for an event related

   to the debugged task.

   Returns -1 if remote wait failed, task status otherwise.  */

static int

net_wait (pEvent)

     RDB_EVENT *pEvent;

{

  int pid;

  enum clnt_stat status;

  memset ((char *) pEvent, '\0', sizeof (RDB_EVENT));

  pid = inferior_pid;

  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);

}

/* Suspend the remote task.

   Returns -1 if suspend fails on target system, 0 otherwise.  */

static int

net_quit ()

{

  int pid;

  int quit_status;

  enum clnt_stat status;

  quit_status = 0;

  /* don't let rdbTask suspend itself by passing a pid of 0 */

  if ((pid = inferior_pid) == 0)

    return -1;

  status = net_clnt_call (VX_TASK_SUSPEND, xdr_int, &pid, xdr_int,

                          &quit_status);

  return (status == RPC_SUCCESS) ? quit_status : -1;

}

/* Read a register or registers from the remote system.  */

void

net_read_registers (reg_buf, len, procnum)

     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));

  /* Initialize RPC input argument structure.  */

  ptrace_in.pid = inferior_pid;

  ptrace_in.info.ttype = NOINFO;

  /* Initialize RPC return value structure.  */

  out_data.bytes = reg_buf;

  out_data.len = len;

  ptrace_out.info.more_data = (caddr_t) & out_data;

  /* 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)

               ? "general-purpose"

               : "floating-point");

      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

net_write_registers (reg_buf, len, procnum)

     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));

  /* Initialize RPC input argument structure.  */

  in_data.bytes = reg_buf;

  in_data.len = len;

  ptrace_in.pid = inferior_pid;

  ptrace_in.info.ttype = DATA;

  ptrace_in.info.more_data = (caddr_t) & in_data;

  /* 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)

               ? "general-purpose"

               : "floating-point");

      perror_with_name (message);

    }

}

/* Prepare to store registers.  Since we will store all of them,

   read out their current values now.  */

static void

vx_prepare_to_store ()

{

  /* 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

   inferior.

   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

vx_xfer_memory (memaddr, myaddr, len, write, target)

     CORE_ADDR memaddr;

     char *myaddr;

     int len;

     int write;

     struct target_ops *target; /* ignored */

{

  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 = inferior_pid; /* XXX pid unnecessary for READDATA */

  ptrace_in.addr = (int) memaddr;       /* Where from */

  ptrace_in.data = len;         /* How many bytes */

  if (write)

    {

      ptrace_in.info.ttype = DATA;

      ptrace_in.info.more_data = (caddr_t) & data;

      data.bytes = (caddr_t) myaddr;    /* Where from */

      data.len = len;           /* How many bytes (again, for XDR) */

      request = PTRACE_WRITEDATA;

    }

  else

    {

      ptrace_out.info.more_data = (caddr_t) & data;

      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))

        error (rpcerr);

      status = ptrace_out.status;

      if (status == 0)

        {

          memaddr += nxfer;

          myaddr += nxfer;

          nleft -= nxfer;

        }

      else

        {

          /* 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.  */

          errno = ptrace_out.errno_num;

        }

    }

  /* Return the number of bytes transferred.  */

  return (len - nleft);

}

static void

vx_files_info ()

{

  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 ()

{

  printf_unfiltered ("\tRunning %s VxWorks process %s",

                     vx_running ? "child" : "attached",

                     local_hex_string (inferior_pid));

  if (vx_running)

    printf_unfiltered (", function `%s'", vx_running);

  printf_unfiltered (".\n");

}

static void

vx_resume (pid, step, siggnal)

     int pid;

     int step;

     enum target_signal siggnal;

{

  int status;

  Rptrace ptrace_in;

  Ptrace_return ptrace_out;

  CORE_ADDR cont_addr;

  if (pid == -1)

    pid = inferior_pid;

  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));

  ptrace_in.pid = pid;

  ptrace_in.addr = cont_addr;   /* Target side insists on this, or it panics.  */

  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 ()

{

  pop_target ();                /* Pop back to no-child state */

  generic_mourn_inferior ();

}

static void vx_add_symbols PARAMS ((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 PARAMS ((bfd *, asection *, void *));

static void

find_sect (abfd, sect, obj)

     bfd *abfd;

     asection *sect;

     PTR 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)

        {

          /* 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

vx_add_symbols (name, from_tty, text_addr, data_addr, bss_addr)

     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;

  /* 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.  */

  objfile = symbol_file_add (name, from_tty, NULL, 0, 0);

  /* 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.  */