gdb/remote-vx.c

   1 /* Memory-access and commands for remote VxWorks processes, for GDB.
   2    Copyright 1990, 1991, 1992 Free Software Foundation, Inc.
   3    Contributed by Wind River Systems and Cygnus Support.
   4
   5 This file is part of GDB.
   6
   7 This program is free software; you can redistribute it and/or modify
   8 it under the terms of the GNU General Public License as published by
   9 the Free Software Foundation; either version 2 of the License, or
  10 (at your option) any later version.
  11
  12 This program is distributed in the hope that it will be useful,
  13 but WITHOUT ANY WARRANTY; without even the implied warranty of
  14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15 GNU General Public License for more details.
  16
  17 You should have received a copy of the GNU General Public License
  18 along with this program; if not, write to the Free Software
  19 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.  */
  20
  21 #include "defs.h"
  22 #include "frame.h"
  23 #include "inferior.h"
  24 #include "wait.h"
  25 #include "target.h"
  26 #include "gdbcore.h"
  27 #include "command.h"
  28 #include "symtab.h"
  29 #include "complaints.h"
  30
  31 #include <string.h>
  32 #include <errno.h>
  33 #include <signal.h>
  34 #include <fcntl.h>
  35 #include <sys/types.h>
  36 #include <sys/socket.h>
  37 #define malloc bogon_malloc     /* Sun claims "char *malloc()" not void * */
  38 #define free bogon_free         /* Sun claims "int free()" not void */
  39 #define realloc bogon_realloc   /* Sun claims "char *realloc()", not void * */
  40 #include <rpc/rpc.h>
  41 #undef malloc
  42 #undef free
  43 #undef realloc
  44 #include <sys/time.h>           /* UTek's <rpc/rpc.h> doesn't #incl this */
  45 #include <netdb.h>
  46 #include "vx-share/ptrace.h"
  47 #include "vx-share/xdr_ptrace.h"
  48 #include "vx-share/xdr_ld.h"
  49 #include "vx-share/xdr_rdb.h"
  50 #include "vx-share/dbgRpcLib.h"
  51
  52 #include <symtab.h>
  53
  54 extern void symbol_file_command ();
  55 extern int stop_soon_quietly;           /* for wait_for_inferior */
  56
  57 static int net_ptrace_clnt_call ();     /* Forward decl */
  58 static enum clnt_stat net_clnt_call (); /* Forward decl */
  59 extern struct target_ops vx_ops, vx_run_ops;    /* Forward declaration */
  60
  61 /* Saved name of target host and called function for "info files".
  62    Both malloc'd.  */
  63
  64 static char *vx_host;
  65 static char *vx_running;                /* Called function */
  66
  67 /* Nonzero means target that is being debugged remotely has a floating
  68    point processor.  */
  69
  70 static int target_has_fp;
  71
  72 /* Default error message when the network is forking up.  */
  73
  74 static const char rpcerr[] = "network target debugging:  rpc error";
  75
  76 CLIENT *pClient;         /* client used in net debugging */
  77 static int ptraceSock = RPC_ANYSOCK;
  78
  79 enum clnt_stat net_clnt_call();
  80 static void parse_args ();
  81
  82 static struct timeval rpcTimeout = { 10, 0 };
  83
  84 static char *skip_white_space ();
  85 static char *find_white_space ();
  86
  87 /* Tell the VxWorks target system to download a file.
  88    The load addresses of the text, data, and bss segments are
  89    stored in *pTextAddr, *pDataAddr, and *pBssAddr (respectively).
  90    Returns 0 for success, -1 for failure.  */
  91
  92 static int
  93 net_load (filename, pTextAddr, pDataAddr, pBssAddr)
  94     char *filename;
  95     CORE_ADDR *pTextAddr;
  96     CORE_ADDR *pDataAddr;
  97     CORE_ADDR *pBssAddr;
  98     {
  99     enum clnt_stat status;
 100     struct ldfile ldstruct;
 101     struct timeval load_timeout;
 102
 103     bzero ((char *) &ldstruct, sizeof (ldstruct));
 104
 105     /* We invoke clnt_call () here directly, instead of through
 106        net_clnt_call (), because we need to set a large timeout value.
 107        The load on the target side can take quite a while, easily
 108        more than 10 seconds.  The user can kill this call by typing
 109        CTRL-C if there really is a problem with the load.
 110
 111        Do not change the tv_sec value without checking -- select() imposes
 112        a limit of 10**8 on it for no good reason that I can see...  */
 113
 114     load_timeout.tv_sec = 99999999;   /* A large number, effectively inf. */
 115     load_timeout.tv_usec = 0;
 116
 117     status = clnt_call (pClient, VX_LOAD, xdr_wrapstring, &filename, xdr_ldfile,
 118                         &ldstruct, load_timeout);
 119
 120     if (status == RPC_SUCCESS)
 121       {
 122         if (*ldstruct.name == 0)        /* load failed on VxWorks side */
 123           return -1;
 124         *pTextAddr = ldstruct.txt_addr;
 125         *pDataAddr = ldstruct.data_addr;
 126         *pBssAddr = ldstruct.bss_addr;
 127         return 0;
 128       }
 129     else
 130         return -1;
 131     }
 132
 133 /* returns 0 if successful, errno if RPC failed or VxWorks complains. */
 134
 135 static int
 136 net_break (addr, procnum)
 137     int addr;
 138     u_long procnum;
 139     {
 140     enum clnt_stat status;
 141     int break_status;
 142     Rptrace ptrace_in;  /* XXX This is stupid.  It doesn't need to be a ptrace
 143                            structure.  How about something smaller? */
 144
 145     bzero ((char *) &ptrace_in, sizeof (ptrace_in));
 146     break_status = 0;
 147
 148     ptrace_in.addr = addr;
 149     ptrace_in.pid = inferior_pid;
 150
 151     status = net_clnt_call (procnum, xdr_rptrace, &ptrace_in, xdr_int,
 152                             &break_status);
 153
 154     if (status != RPC_SUCCESS)
 155         return errno;
 156
 157     if (break_status == -1)
 158       return ENOMEM;
 159     return break_status;        /* probably (FIXME) zero */
 160     }
 161
 162 /* returns 0 if successful, errno otherwise */
 163
 164 static int
 165 vx_insert_breakpoint (addr)
 166     int addr;
 167     {
 168     return net_break (addr, VX_BREAK_ADD);
 169     }
 170
 171 /* returns 0 if successful, errno otherwise */
 172
 173 static int
 174 vx_remove_breakpoint (addr)
 175     int addr;
 176     {
 177     return net_break (addr, VX_BREAK_DELETE);
 178     }
 179
 180 /* Start an inferior process and sets inferior_pid to its pid.
 181    EXEC_FILE is the file to run.
 182    ALLARGS is a string containing the arguments to the program.
 183    ENV is the environment vector to pass.
 184    Returns process id.  Errors reported with error().
 185    On VxWorks, we ignore exec_file.  */
 186
 187 static void
 188 vx_create_inferior (exec_file, args, env)
 189      char *exec_file;
 190      char *args;
 191      char **env;
 192 {
 193   enum clnt_stat status;
 194   arg_array passArgs;
 195   TASK_START taskStart;
 196
 197   bzero ((char *) &passArgs, sizeof (passArgs));
 198   bzero ((char *) &taskStart, sizeof (taskStart));
 199
 200   /* parse arguments, put them in passArgs */
 201
 202   parse_args (args, &passArgs);
 203
 204   if (passArgs.arg_array_len == 0)
 205     error ("You must specify a function name to run, and arguments if any");
 206
 207   status = net_clnt_call (PROCESS_START, xdr_arg_array, &passArgs,
 208                           xdr_TASK_START, &taskStart);
 209
 210   if ((status != RPC_SUCCESS) || (taskStart.status == -1))
 211     error ("Can't create process on remote target machine");
 212
 213   /* Save the name of the running function */
 214   vx_running = savestring (passArgs.arg_array_val[0],
 215                            strlen (passArgs.arg_array_val[0]));
 216
 217 #ifdef CREATE_INFERIOR_HOOK
 218   CREATE_INFERIOR_HOOK (pid);
 219 #endif
 220
 221   push_target (&vx_run_ops);
 222   inferior_pid = taskStart.pid;
 223
 224   /* We will get a trace trap after one instruction.
 225      Insert breakpoints and continue.  */
 226
 227   init_wait_for_inferior ();
 228
 229   /* Set up the "saved terminal modes" of the inferior
 230      based on what modes we are starting it with.  */
 231   target_terminal_init ();
 232
 233   /* Install inferior's terminal modes.  */
 234   target_terminal_inferior ();
 235
 236   stop_soon_quietly = 1;
 237   wait_for_inferior ();         /* Get the task spawn event */
 238   stop_soon_quietly = 0;
 239
 240   /* insert_step_breakpoint ();  FIXME, do we need this?  */
 241   proceed(-1, -1, 0);
 242 }
 243
 244 /* Fill ARGSTRUCT in argc/argv form with the arguments from the
 245    argument string ARGSTRING.  */
 246
 247 static void
 248 parse_args (arg_string, arg_struct)
 249      register char *arg_string;
 250      arg_array *arg_struct;
 251 {
 252   register int arg_count = 0;   /* number of arguments */
 253   register int arg_index = 0;
 254   register char *p0;
 255
 256   bzero ((char *) arg_struct, sizeof (arg_array));
 257
 258   /* first count how many arguments there are */
 259
 260   p0 = arg_string;
 261   while (*p0 != '\0')
 262     {
 263       if (*(p0 = skip_white_space (p0)) == '\0')
 264         break;
 265       p0 = find_white_space (p0);
 266       arg_count++;
 267     }
 268
 269   arg_struct->arg_array_len = arg_count;
 270   arg_struct->arg_array_val = (char **) xmalloc ((arg_count + 1)
 271                                                  * sizeof (char *));
 272
 273   /* now copy argument strings into arg_struct.  */
 274
 275   while (*(arg_string = skip_white_space (arg_string)))
 276     {
 277       p0 = find_white_space (arg_string);
 278       arg_struct->arg_array_val[arg_index++] = savestring (arg_string,
 279                                                            p0 - arg_string);
 280       arg_string = p0;
 281     }
 282
 283   arg_struct->arg_array_val[arg_count] = NULL;
 284 }
 285
 286 /* Advance a string pointer across whitespace and return a pointer
 287    to the first non-white character.  */
 288
 289 static char *
 290 skip_white_space (p)
 291      register char *p;
 292 {
 293   while (*p == ' ' || *p == '\t')
 294     p++;
 295   return p;
 296 }
 297
 298 /* Search for the first unquoted whitespace character in a string.
 299    Returns a pointer to the character, or to the null terminator
 300    if no whitespace is found.  */
 301
 302 static char *
 303 find_white_space (p)
 304      register char *p;
 305 {
 306   register int c;
 307
 308   while ((c = *p) != ' ' && c != '\t' && c)
 309     {
 310       if (c == '\'' || c == '"')
 311         {
 312           while (*++p != c && *p)
 313             {
 314               if (*p == '\\')
 315                 p++;
 316             }
 317           if (!*p)
 318             break;
 319         }
 320       p++;
 321     }
 322   return p;
 323 }
 324
 325 /* Poll the VxWorks target system for an event related
 326    to the debugged task.
 327    Returns -1 if remote wait failed, task status otherwise.  */
 328
 329 static int
 330 net_wait (pEvent)
 331     RDB_EVENT *pEvent;
 332 {
 333     int pid;
 334     enum clnt_stat status;
 335
 336     bzero ((char *) pEvent, sizeof (RDB_EVENT));
 337
 338     pid = inferior_pid;
 339     status = net_clnt_call (PROCESS_WAIT, xdr_int, &pid, xdr_RDB_EVENT, pEvent);
 340
 341     return (status == RPC_SUCCESS)? pEvent->status: -1;
 342 }
 343
 344 /* Suspend the remote task.
 345    Returns -1 if suspend fails on target system, 0 otherwise.  */
 346
 347 static int
 348 net_quit ()
 349 {
 350     int pid;
 351     int quit_status;
 352     enum clnt_stat status;
 353
 354     quit_status = 0;
 355
 356     /* don't let rdbTask suspend itself by passing a pid of 0 */
 357
 358     if ((pid = inferior_pid) == 0)
 359         return -1;
 360
 361     status = net_clnt_call (VX_TASK_SUSPEND, xdr_int, &pid, xdr_int,
 362                             &quit_status);
 363
 364     return (status == RPC_SUCCESS)? quit_status: -1;
 365 }
 366
 367 /* Read a register or registers from the remote system.  */
 368
 369 static void
 370 vx_read_register (regno)
 371      int regno;
 372 {
 373   int status;
 374   Rptrace ptrace_in;
 375   Ptrace_return ptrace_out;
 376   C_bytes in_data;
 377   C_bytes out_data;
 378   extern char registers[];
 379
 380   bzero ((char *) &ptrace_in, sizeof (ptrace_in));
 381   bzero ((char *) &ptrace_out, sizeof (ptrace_out));
 382
 383   /* FIXME, eventually only get the ones we need.  */
 384   registers_fetched ();
 385
 386   ptrace_in.pid = inferior_pid;
 387   ptrace_out.info.more_data = (caddr_t) &out_data;
 388   out_data.len   = VX_NUM_REGS * REGISTER_RAW_SIZE (0);
 389   out_data.bytes = (caddr_t) registers;
 390
 391   status = net_ptrace_clnt_call (PTRACE_GETREGS, &ptrace_in, &ptrace_out);
 392   if (status)
 393     error (rpcerr);
 394   if (ptrace_out.status == -1)
 395     {
 396       errno = ptrace_out.errno;
 397       perror_with_name ("net_ptrace_clnt_call(PTRACE_GETREGS)");
 398     }
 399
 400 #ifdef VX_SIZE_FPREGS
 401     /* If the target has floating point registers, fetch them.
 402        Otherwise, zero the floating point register values in
 403        registers[] for good measure, even though we might not
 404        need to.  */
 405
 406   if (target_has_fp)
 407     {
 408       ptrace_in.pid = inferior_pid;
 409       ptrace_out.info.more_data = (caddr_t) &out_data;
 410       out_data.len   =  VX_SIZE_FPREGS;
 411       out_data.bytes = (caddr_t) &registers[REGISTER_BYTE (FP0_REGNUM)];
 412
 413       status = net_ptrace_clnt_call (PTRACE_GETFPREGS, &ptrace_in, &ptrace_out);
 414       if (status)
 415         error (rpcerr);
 416       if (ptrace_out.status == -1)
 417         {
 418           errno = ptrace_out.errno;
 419           perror_with_name ("net_ptrace_clnt_call(PTRACE_GETFPREGS)");
 420         }
 421     }
 422   else
 423     {
 424       bzero (&registers[REGISTER_BYTE (FP0_REGNUM)], VX_SIZE_FPREGS);
 425     }
 426 #endif /* VX_SIZE_FPREGS */
 427 }
 428
 429 /* Prepare to store registers.  Since we will store all of them,
 430    read out their current values now.  */
 431
 432 static void
 433 vx_prepare_to_store ()
 434 {
 435   /* Fetch all registers, if any of them are not yet fetched.  */
 436   read_register_bytes (0, NULL, REGISTER_BYTES);
 437 }
 438
 439
 440 /* Store our register values back into the inferior.
 441    If REGNO is -1, do this for all registers.
 442    Otherwise, REGNO specifies which register (so we can save time).  */
 443    /* FIXME, look at REGNO to save time here */
 444
 445 static void
 446 vx_write_register (regno)
 447      int regno;
 448 {
 449   C_bytes in_data;
 450   C_bytes out_data;
 451   extern char registers[];
 452   int status;
 453   Rptrace ptrace_in;
 454   Ptrace_return ptrace_out;
 455
 456   bzero ((char *) &ptrace_in, sizeof (ptrace_in));
 457   bzero ((char *) &ptrace_out, sizeof (ptrace_out));
 458
 459   ptrace_in.pid = inferior_pid;
 460   ptrace_in.info.ttype     = DATA;
 461   ptrace_in.info.more_data = (caddr_t) &in_data;
 462
 463   in_data.bytes = registers;
 464
 465   in_data.len = VX_NUM_REGS * sizeof (REGISTER_TYPE);
 466
 467   /* XXX change second param to be a proc number */
 468   status = net_ptrace_clnt_call (PTRACE_SETREGS, &ptrace_in, &ptrace_out);
 469   if (status)
 470       error (rpcerr);
 471   if (ptrace_out.status == -1)
 472     {
 473       errno = ptrace_out.errno;
 474       perror_with_name ("net_ptrace_clnt_call(PTRACE_SETREGS)");
 475     }
 476
 477 #ifdef VX_SIZE_FPREGS
 478   /* Store floating point registers if the target has them.  */
 479
 480   if (target_has_fp)
 481     {
 482       ptrace_in.pid = inferior_pid;
 483       ptrace_in.info.ttype     = DATA;
 484       ptrace_in.info.more_data = (caddr_t) &in_data;
 485
 486
 487       in_data.bytes = &registers[REGISTER_BYTE (FP0_REGNUM)];
 488       in_data.len = VX_SIZE_FPREGS;
 489
 490       status = net_ptrace_clnt_call (PTRACE_SETFPREGS, &ptrace_in, &ptrace_out);
 491       if (status)
 492           error (rpcerr);
 493       if (ptrace_out.status == -1)
 494         {
 495           errno = ptrace_out.errno;
 496           perror_with_name ("net_ptrace_clnt_call(PTRACE_SETFPREGS)");
 497         }
 498     }
 499 #endif  /* VX_SIZE_FPREGS */
 500 }
 501
 502 /* Copy LEN bytes to or from remote inferior's memory starting at MEMADDR
 503    to debugger memory starting at MYADDR.  WRITE is true if writing to the
 504    inferior.
 505    Result is the number of bytes written or read (zero if error).  The
 506    protocol allows us to return a negative count, indicating that we can't
 507    handle the current address but can handle one N bytes further, but
 508    vxworks doesn't give us that information.  */
 509
 510 static int
 511 vx_xfer_memory (memaddr, myaddr, len, write, target)
 512      CORE_ADDR memaddr;
 513      char *myaddr;
 514      int len;
 515      int write;
 516      struct target_ops *target;                 /* ignored */
 517 {
 518   int status;
 519   Rptrace ptrace_in;
 520   Ptrace_return ptrace_out;
 521   C_bytes data;
 522
 523   bzero ((char *) &ptrace_in, sizeof (ptrace_in));
 524   bzero ((char *) &ptrace_out, sizeof (ptrace_out));
 525
 526   ptrace_in.pid = inferior_pid;         /* XXX pid unnecessary for READDATA */
 527   ptrace_in.addr = (int) memaddr;       /* Where from */
 528   ptrace_in.data = len;                 /* How many bytes */
 529
 530   if (write)
 531     {
 532       ptrace_in.info.ttype     = DATA;
 533       ptrace_in.info.more_data = (caddr_t) &data;
 534
 535       data.bytes = (caddr_t) myaddr;    /* Where from */
 536       data.len   = len;                 /* How many bytes (again, for XDR) */
 537
 538       /* XXX change second param to be a proc number */
 539       status = net_ptrace_clnt_call (PTRACE_WRITEDATA, &ptrace_in, &ptrace_out);
 540     }
 541   else
 542     {
 543       ptrace_out.info.more_data = (caddr_t) &data;
 544       data.bytes = myaddr;              /* Where to */
 545       data.len   = len;                 /* How many (again, for XDR) */
 546
 547       /* XXX change second param to be a proc number */
 548       status = net_ptrace_clnt_call (PTRACE_READDATA, &ptrace_in, &ptrace_out);
 549     }
 550
 551   if (status)
 552       error (rpcerr);
 553   if (ptrace_out.status == -1)
 554     {
 555       return 0;         /* No bytes moved */
 556     }
 557   return len;           /* Moved *all* the bytes */
 558 }
 559
 560 static void
 561 vx_files_info ()
 562 {
 563   printf ("\tAttached to host `%s'", vx_host);
 564   printf (", which has %sfloating point", target_has_fp? "": "no ");
 565   printf (".\n");
 566 }
 567
 568 static void
 569 vx_run_files_info ()
 570 {
 571   printf ("\tRunning %s VxWorks process %s",
 572           vx_running? "child": "attached",
 573           local_hex_string(inferior_pid));
 574   if (vx_running)
 575     printf (", function `%s'", vx_running);
 576   printf(".\n");
 577 }
 578
 579 static void
 580 vx_resume (step, siggnal)
 581      int step;
 582      int siggnal;
 583 {
 584   int status;
 585   Rptrace ptrace_in;
 586   Ptrace_return ptrace_out;
 587
 588   if (siggnal != 0 && siggnal != stop_signal)
 589     error ("Cannot send signals to VxWorks processes");
 590
 591   bzero ((char *) &ptrace_in, sizeof (ptrace_in));
 592   bzero ((char *) &ptrace_out, sizeof (ptrace_out));
 593
 594   ptrace_in.pid = inferior_pid;
 595   ptrace_in.addr = 1;   /* Target side insists on this, or it panics.  */
 596
 597   /* XXX change second param to be a proc number */
 598   status = net_ptrace_clnt_call (step? PTRACE_SINGLESTEP: PTRACE_CONT,
 599                                  &ptrace_in, &ptrace_out);
 600   if (status)
 601       error (rpcerr);
 602   if (ptrace_out.status == -1)
 603     {
 604       errno = ptrace_out.errno;
 605       perror_with_name ("Resuming remote process");
 606     }
 607 }
 608
 609 static void
 610 vx_mourn_inferior ()
 611 {
 612   pop_target ();                /* Pop back to no-child state */
 613   generic_mourn_inferior ();
 614 }
 615
 616 \f
 617 /* This function allows the addition of incrementally linked object files.  */
 618
 619 static void
 620 vx_load_command (arg_string, from_tty)
 621      char* arg_string;
 622      int from_tty;
 623 {
 624   CORE_ADDR text_addr;
 625   CORE_ADDR data_addr;
 626   CORE_ADDR bss_addr;
 627
 628   if (arg_string == 0)
 629     error ("The load command takes a file name");
 630
 631   arg_string = tilde_expand (arg_string);
 632   make_cleanup (free, arg_string);
 633
 634   dont_repeat ();
 635
 636   QUIT;
 637   immediate_quit++;
 638   if (net_load (arg_string, &text_addr, &data_addr, &bss_addr) == -1)
 639     error ("Load failed on target machine");
 640   immediate_quit--;
 641
 642   /* FIXME, for now we ignore data_addr and bss_addr.  */
 643   symbol_file_add (arg_string, from_tty, text_addr, 0, 0, 0);
 644 }
 645
 646 #ifdef FIXME  /* Not ready for prime time */
 647 /* Single step the target program at the source or machine level.
 648    Takes an error exit if rpc fails.
 649    Returns -1 if remote single-step operation fails, else 0.  */
 650
 651 static int
 652 net_step ()
 653 {
 654   enum clnt_stat status;
 655   int step_status;
 656   SOURCE_STEP source_step;
 657
 658   source_step.taskId = inferior_pid;
 659
 660   if (step_range_end)
 661     {
 662       source_step.startAddr = step_range_start;
 663       source_step.endAddr = step_range_end;
 664     }
 665   else
 666     {
 667       source_step.startAddr = 0;
 668       source_step.endAddr = 0;
 669     }
 670
 671   status = net_clnt_call (VX_SOURCE_STEP, xdr_SOURCE_STEP, &source_step,
 672                           xdr_int, &step_status);
 673
 674   if (status == RPC_SUCCESS)
 675     return step_status;
 676   else
 677     error (rpcerr);
 678 }
 679 #endif
 680
 681 /* Emulate ptrace using RPC calls to the VxWorks target system.
 682    Returns nonzero (-1) if RPC status to VxWorks is bad, 0 otherwise.  */
 683
 684 static int
 685 net_ptrace_clnt_call (request, pPtraceIn, pPtraceOut)
 686     enum ptracereq request;
 687     Rptrace *pPtraceIn;
 688     Ptrace_return *pPtraceOut;
 689 {
 690   enum clnt_stat status;
 691
 692   status = net_clnt_call (request, xdr_rptrace, pPtraceIn, xdr_ptrace_return,
 693                           pPtraceOut);
 694
 695   if (status != RPC_SUCCESS)
 696       return -1;
 697
 698   return 0;
 699 }
 700
 701 /* Query the target for the name of the file from which VxWorks was
 702    booted.  pBootFile is the address of a pointer to the buffer to
 703    receive the file name; if the pointer pointed to by pBootFile is
 704    NULL, memory for the buffer will be allocated by XDR.
 705    Returns -1 if rpc failed, 0 otherwise.  */
 706
 707 static int
 708 net_get_boot_file (pBootFile)
 709      char **pBootFile;
 710 {
 711   enum clnt_stat status;
 712
 713   status = net_clnt_call (VX_BOOT_FILE_INQ, xdr_void, (char *) 0,
 714                           xdr_wrapstring, pBootFile);
 715   return (status == RPC_SUCCESS) ? 0 : -1;
 716 }
 717
 718 /* Fetch a list of loaded object modules from the VxWorks target.
 719    Returns -1 if rpc failed, 0 otherwise
 720    There's no way to check if the returned loadTable is correct.
 721    VxWorks doesn't check it.  */
 722
 723 static int
 724 net_get_symbols (pLoadTable)
 725      ldtabl *pLoadTable;                /* return pointer to ldtabl here */
 726 {
 727   enum clnt_stat status;
 728
 729   bzero ((char *) pLoadTable, sizeof (struct ldtabl));
 730
 731   status = net_clnt_call (VX_STATE_INQ, xdr_void, 0, xdr_ldtabl, pLoadTable);
 732   return (status == RPC_SUCCESS) ? 0 : -1;
 733 }
 734
 735 /* Look up a symbol in the VxWorks target's symbol table.
 736    Returns status of symbol read on target side (0=success, -1=fail)
 737    Returns -1 and complain()s if rpc fails.  */
 738
 739 struct complaint cant_contact_target =
 740   {"Lost contact with VxWorks target", 0, 0};
 741
 742 static int
 743 vx_lookup_symbol (name, pAddr)
 744      char *name;                /* symbol name */
 745      CORE_ADDR *pAddr;
 746 {
 747   enum clnt_stat status;
 748   SYMBOL_ADDR symbolAddr;
 749
 750   *pAddr = 0;
 751   bzero ((char *) &symbolAddr, sizeof (symbolAddr));
 752
 753   status = net_clnt_call (VX_SYMBOL_INQ, xdr_wrapstring, &name,
 754                           xdr_SYMBOL_ADDR, &symbolAddr);
 755   if (status != RPC_SUCCESS) {
 756       complain (&cant_contact_target);
 757       return -1;
 758   }
 759
 760   *pAddr = symbolAddr.addr;
 761   return symbolAddr.status;
 762 }
 763
 764 /* Check to see if the VxWorks target has a floating point coprocessor.
 765    Returns 1 if target has floating point processor, 0 otherwise.
 766    Calls error() if rpc fails.  */
 767
 768 static int
 769 net_check_for_fp ()
 770 {
 771   enum clnt_stat status;
 772   bool_t fp = 0;        /* true if fp processor is present on target board */
 773
 774   status = net_clnt_call (VX_FP_INQUIRE, xdr_void, 0, xdr_bool, &fp);
 775   if (status != RPC_SUCCESS)
 776       error (rpcerr);
 777
 778    return (int) fp;
 779 }
 780
 781 /* Establish an RPC connection with the VxWorks target system.
 782    Calls error () if unable to establish connection.  */
 783
 784 static void
 785 net_connect (host)
 786      char *host;
 787 {
 788   struct sockaddr_in destAddr;
 789   struct hostent *destHost;
 790   unsigned long addr;
 791
 792   /* Get the internet address for the given host.  Allow a numeric
 793      IP address or a hostname.  */
 794
 795   addr = inet_addr (host);
 796   if (addr == -1)
 797     {
 798       destHost = (struct hostent *) gethostbyname (host);
 799       if (destHost == NULL)
 800         error ("Invalid hostname.  Couldn't find remote host address.");
 801       addr = * (unsigned long *) destHost->h_addr;
 802     }
 803
 804   bzero (&destAddr, sizeof (destAddr));
 805
 806   destAddr.sin_addr.s_addr = addr;
 807   destAddr.sin_family      = AF_INET;
 808   destAddr.sin_port        = 0; /* set to actual port that remote
 809                                    ptrace is listening on.  */
 810
 811   /* Create a tcp client transport on which to issue
 812      calls to the remote ptrace server.  */
 813
 814   ptraceSock = RPC_ANYSOCK;
 815   pClient = clnttcp_create (&destAddr, RDBPROG, RDBVERS, &ptraceSock, 0, 0);
 816   /* FIXME, here is where we deal with different version numbers of the proto */
 817
 818   if (pClient == NULL)
 819     {
 820       clnt_pcreateerror ("\tnet_connect");
 821       error ("Couldn't connect to remote target.");
 822     }
 823 }
 824 \f
 825 /* Sleep for the specified number of milliseconds
 826  * (assumed to be less than 1000).
 827  * If select () is interrupted, returns immediately;
 828  * takes an error exit if select () fails for some other reason.
 829  */
 830
 831 static void
 832 sleep_ms (ms)
 833      long ms;
 834 {
 835   struct timeval select_timeout;
 836   int status;
 837
 838   select_timeout.tv_sec = 0;
 839   select_timeout.tv_usec = ms * 1000;
 840
 841   status = select (0, (fd_set *) 0, (fd_set *) 0, (fd_set *) 0, &select_timeout);
 842
 843   if (status < 0 && errno != EINTR)
 844     perror_with_name ("select");
 845 }
 846
 847 /* Wait for control to return from inferior to debugger.
 848    If inferior gets a signal, we may decide to start it up again
 849    instead of returning.  That is why there is a loop in this function.
 850    When this function actually returns it means the inferior
 851    should be left stopped and GDB should read more commands.  */
 852
 853 /* For network debugging with VxWorks.
 854  * VxWorks knows when tasks hit breakpoints, receive signals, exit, etc,
 855  * so vx_wait() receives this information directly from
 856  * VxWorks instead of trying to figure out what happenned via a wait() call.
 857  */
 858
 859 static int
 860 vx_wait (status)
 861      int *status;
 862 {
 863   register int pid;
 864   WAITTYPE w;
 865   RDB_EVENT rdbEvent;
 866   int quit_failed;
 867
 868   do
 869     {
 870       /* If CTRL-C is hit during this loop,
 871          suspend the inferior process.  */
 872
 873       quit_failed = 0;
 874       if (quit_flag)
 875         {
 876           quit_failed = (net_quit () == -1);
 877           quit_flag = 0;
 878         }
 879
 880       /* If a net_quit () or net_wait () call has failed,
 881          allow the user to break the connection with the target.
 882          We can't simply error () out of this loop, since the
 883          data structures representing the state of the inferior
 884          are in an inconsistent state.  */
 885
 886       if (quit_failed || net_wait (&rdbEvent) == -1)
 887         {
 888           terminal_ours ();
 889           if (query ("Can't %s.  Disconnect from target system? ",
 890                      (quit_failed) ? "suspend remote task"
 891                                    : "get status of remote task"))
 892             {
 893               target_mourn_inferior();
 894               error ("Use the \"target\" command to reconnect.");
 895             }
 896           else
 897             {
 898               terminal_inferior ();
 899               continue;
 900             }
 901         }
 902
 903       pid = rdbEvent.taskId;
 904       if (pid == 0)
 905         {
 906           sleep_ms (200);       /* FIXME Don't kill the network too badly */
 907         }
 908       else if (pid != inferior_pid)
 909         fatal ("Bad pid for debugged task: %s\n", local_hex_string(pid));
 910     } while (pid == 0);
 911
 912   /* FIXME, eventually do more then SIGTRAP on everything...  */
 913   switch (rdbEvent.eventType)
 914     {
 915     case EVENT_EXIT:
 916       WSETEXIT (w, 0);
 917       /* FIXME is it possible to distinguish between a
 918          XXX   normal vs abnormal exit in VxWorks? */
 919       break;
 920
 921     case EVENT_START:           /* Task was just started. */
 922       WSETSTOP (w, SIGTRAP);
 923       break;
 924
 925     case EVENT_STOP:
 926       WSETSTOP (w, SIGTRAP);
 927       /* XXX was it stopped by a signal?  act accordingly */
 928       break;
 929
 930     case EVENT_BREAK:           /* Breakpoint was hit. */
 931       WSETSTOP (w, SIGTRAP);
 932       break;
 933
 934     case EVENT_SUSPEND:         /* Task was suspended, probably by ^C. */
 935       WSETSTOP (w, SIGINT);
 936       break;
 937
 938     case EVENT_BUS_ERR:         /* Task made evil nasty reference. */
 939       WSETSTOP (w, SIGBUS);
 940       break;
 941
 942     case EVENT_ZERO_DIV:        /* Division by zero */
 943       WSETSTOP (w, SIGFPE);     /* Like Unix, call it a float exception. */
 944       break;
 945
 946     case EVENT_SIGNAL:
 947       /* The target is not running Unix, and its
 948          faults/traces do not map nicely into Unix signals.
 949          Make sure they do not get confused with Unix signals
 950          by numbering them with values higher than the highest
 951          legal Unix signal.  code in the arch-dependent PRINT_RANDOM_SIGNAL
 952          routine will interpret the value for wait_for_inferior.  */
 953       WSETSTOP (w, rdbEvent.sigType + NSIG);
 954       break;
 955     } /* switch */
 956   *status = *(int *)&w;         /* Grumble union wait crap Grumble */
 957   return pid;
 958 }
 959 \f
 960 static int
 961 symbol_stub (arg)
 962      char *arg;
 963 {
 964   symbol_file_command (arg, 0);
 965   return 1;
 966 }
 967
 968 static int
 969 add_symbol_stub (arg)
 970      char *arg;
 971 {
 972   struct ldfile *pLoadFile = (struct ldfile *)arg;
 973
 974   printf("\t%s: ", pLoadFile->name);
 975   symbol_file_add (pLoadFile->name, 0, pLoadFile->txt_addr, 0, 0, 0);
 976   printf ("ok\n");
 977   return 1;
 978 }
 979 /* Target command for VxWorks target systems.
 980
 981    Used in vxgdb.  Takes the name of a remote target machine
 982    running vxWorks and connects to it to initialize remote network
 983    debugging.  */
 984
 985 static void
 986 vx_open (args, from_tty)
 987      char *args;
 988      int from_tty;
 989 {
 990   extern int close ();
 991   char *bootFile;
 992   extern char *source_path;
 993   struct ldtabl loadTable;
 994   struct ldfile *pLoadFile;
 995   int i;
 996   extern CLIENT *pClient;
 997
 998   if (!args)
 999     error_no_arg ("target machine name");
1000
1001   target_preopen (from_tty);
1002
1003   unpush_target (&vx_ops);
1004   printf ("Attaching remote machine across net...\n");
1005   fflush (stdout);
1006
1007   /* Allow the user to kill the connect attempt by typing ^C.
1008      Wait until the call to target_has_fp () completes before
1009      disallowing an immediate quit, since even if net_connect ()
1010      is successful, the remote debug server might be hung.  */
1011
1012   immediate_quit++;
1013
1014   net_connect (args);
1015   target_has_fp = net_check_for_fp ();
1016   printf_filtered ("Connected to %s.\n", args);
1017
1018   immediate_quit--;
1019
1020   push_target (&vx_ops);
1021
1022   /* Save a copy of the target host's name.  */
1023   vx_host = savestring (args, strlen (args));
1024
1025   /* Find out the name of the file from which the target was booted
1026      and load its symbol table.  */
1027
1028   printf_filtered ("Looking in Unix path for all loaded modules:\n");
1029   bootFile = NULL;
1030   if (!net_get_boot_file (&bootFile))
1031     {
1032       if (*bootFile) {
1033         printf_filtered ("\t%s: ", bootFile);
1034         if (catch_errors
1035             (symbol_stub, bootFile,
1036              "Error while reading symbols from boot file:\n", RETURN_MASK_ALL))
1037           puts_filtered ("ok\n");
1038       } else if (from_tty)
1039         printf ("VxWorks kernel symbols not loaded.\n");
1040     }
1041   else
1042     error ("Can't retrieve boot file name from target machine.");
1043
1044   clnt_freeres (pClient, xdr_wrapstring, &bootFile);
1045
1046   if (net_get_symbols (&loadTable) != 0)
1047     error ("Can't read loaded modules from target machine");
1048
1049   i = 0-1;
1050   while (++i < loadTable.tbl_size)
1051     {
1052       QUIT;     /* FIXME, avoids clnt_freeres below:  mem leak */
1053       pLoadFile = &loadTable.tbl_ent [i];
1054 #ifdef WRS_ORIG
1055   {
1056     register int desc;
1057     struct cleanup *old_chain;
1058     char *fullname = NULL;
1059
1060     desc = openp (source_path, 0, pLoadFile->name, O_RDONLY, 0, &fullname);
1061     if (desc < 0)
1062         perror_with_name (pLoadFile->name);
1063     old_chain = make_cleanup (close, desc);
1064     add_file_at_addr (fullname, desc, pLoadFile->txt_addr, pLoadFile->data_addr,
1065                       pLoadFile->bss_addr);
1066     do_cleanups (old_chain);
1067   }
1068 #else
1069       /* Botches, FIXME:
1070          (1)  Searches the PATH, not the source path.
1071          (2)  data and bss are assumed to be at the usual offsets from text.  */
1072       catch_errors (add_symbol_stub, (char *)pLoadFile, (char *)0,
1073                     RETURN_MASK_ALL);
1074 #endif
1075     }
1076   printf_filtered ("Done.\n");
1077
1078   clnt_freeres (pClient, xdr_ldtabl, &loadTable);
1079 }
1080 \f
1081 /* Takes a task started up outside of gdb and ``attaches'' to it.
1082    This stops it cold in its tracks and allows us to start tracing it.  */
1083
1084 static void
1085 vx_attach (args, from_tty)
1086      char *args;
1087      int from_tty;
1088 {
1089   int pid;
1090   char *cptr = 0;
1091   Rptrace ptrace_in;
1092   Ptrace_return ptrace_out;
1093   int status;
1094
1095   if (!args)
1096     error_no_arg ("process-id to attach");
1097
1098   pid = strtol (args, &cptr, 0);
1099   if ((cptr == args) || (*cptr != '\0'))
1100     error ("Invalid process-id -- give a single number in decimal or 0xhex");
1101
1102   if (from_tty)
1103       printf ("Attaching pid %s.\n", local_hex_string(pid));
1104
1105   bzero ((char *)&ptrace_in,  sizeof (ptrace_in));
1106   bzero ((char *)&ptrace_out, sizeof (ptrace_out));
1107   ptrace_in.pid = pid;
1108
1109   status = net_ptrace_clnt_call (PTRACE_ATTACH, &ptrace_in, &ptrace_out);
1110   if (status == -1)
1111     error (rpcerr);
1112   if (ptrace_out.status == -1)
1113     {
1114       errno = ptrace_out.errno;
1115       perror_with_name ("Attaching remote process");
1116     }
1117
1118   /* It worked... */
1119   push_target (&vx_run_ops);
1120   inferior_pid = pid;
1121   vx_running = 0;
1122 }
1123
1124
1125 /* detach_command --
1126    takes a program previously attached to and detaches it.
1127    The program resumes execution and will no longer stop
1128    on signals, etc.  We better not have left any breakpoints
1129    in the program or it'll die when it hits one.  For this
1130    to work, it may be necessary for the process to have been
1131    previously attached.  It *might* work if the program was
1132    started via the normal ptrace (PTRACE_TRACEME).  */
1133
1134 static void
1135 vx_detach (args, from_tty)
1136      char *args;
1137      int from_tty;
1138 {
1139   Rptrace ptrace_in;
1140   Ptrace_return ptrace_out;
1141   int signal = 0;
1142   int status;
1143
1144   if (args)
1145     error ("Argument given to VxWorks \"detach\".");
1146
1147   if (from_tty)
1148       printf ("Detaching pid %s.\n", local_hex_string(inferior_pid));
1149
1150   if (args)             /* FIXME, should be possible to leave suspended */
1151     signal = atoi (args);
1152
1153   bzero ((char *)&ptrace_in,  sizeof (ptrace_in));
1154   bzero ((char *)&ptrace_out, sizeof (ptrace_out));
1155   ptrace_in.pid = inferior_pid;
1156
1157   status = net_ptrace_clnt_call (PTRACE_DETACH, &ptrace_in, &ptrace_out);
1158   if (status == -1)
1159     error (rpcerr);
1160   if (ptrace_out.status == -1)
1161     {
1162       errno = ptrace_out.errno;
1163       perror_with_name ("Detaching VxWorks process");
1164     }
1165
1166   inferior_pid = 0;
1167   pop_target ();        /* go back to non-executing VxWorks connection */
1168 }
1169
1170 /* vx_kill -- takes a running task and wipes it out.  */
1171
1172 static void
1173 vx_kill ()
1174 {
1175   Rptrace ptrace_in;
1176   Ptrace_return ptrace_out;
1177   int status;
1178
1179   printf ("Killing pid %s.\n", local_hex_string(inferior_pid));
1180
1181   bzero ((char *)&ptrace_in,  sizeof (ptrace_in));
1182   bzero ((char *)&ptrace_out, sizeof (ptrace_out));
1183   ptrace_in.pid = inferior_pid;
1184
1185   status = net_ptrace_clnt_call (PTRACE_KILL, &ptrace_in, &ptrace_out);
1186   if (status == -1)
1187     warning (rpcerr);
1188   else if (ptrace_out.status == -1)
1189     {
1190       errno = ptrace_out.errno;
1191       perror_with_name ("Killing VxWorks process");
1192     }
1193
1194   /* If it gives good status, the process is *gone*, no events remain.
1195      If the kill failed, assume the process is gone anyhow.  */
1196   inferior_pid = 0;
1197   pop_target ();        /* go back to non-executing VxWorks connection */
1198 }
1199
1200 /* Clean up from the VxWorks process target as it goes away.  */
1201
1202 static void
1203 vx_proc_close (quitting)
1204      int quitting;
1205 {
1206   inferior_pid = 0;             /* No longer have a process.  */
1207   if (vx_running)
1208     free (vx_running);
1209   vx_running = 0;
1210 }
1211 \f
1212 /* Make an RPC call to the VxWorks target.
1213    Returns RPC status.  */
1214
1215 static enum clnt_stat
1216 net_clnt_call (procNum, inProc, in, outProc, out)
1217     enum ptracereq procNum;
1218     xdrproc_t inProc;
1219     char *in;
1220     xdrproc_t outProc;
1221     char *out;
1222 {
1223   enum clnt_stat status;
1224
1225   status = clnt_call (pClient, procNum, inProc, in, outProc, out, rpcTimeout);
1226
1227   if (status != RPC_SUCCESS)
1228       clnt_perrno (status);
1229
1230   return status;
1231 }
1232
1233 /* Clean up before losing control.  */
1234
1235 static void
1236 vx_close (quitting)
1237      int quitting;
1238 {
1239   if (pClient)
1240     clnt_destroy (pClient);     /* The net connection */
1241   pClient = 0;
1242
1243   if (vx_host)
1244     free (vx_host);             /* The hostname */
1245   vx_host = 0;
1246 }
1247
1248 /* A vxprocess target should be started via "run" not "target".  */
1249 /*ARGSUSED*/
1250 static void
1251 vx_proc_open (name, from_tty)
1252      char *name;
1253      int from_tty;
1254 {
1255   error ("Use the \"run\" command to start a VxWorks process.");
1256 }
1257
1258 /* Target ops structure for accessing memory and such over the net */
1259
1260 struct target_ops vx_ops = {
1261         "vxworks", "VxWorks target memory via RPC over TCP/IP",
1262         "Use VxWorks target memory.  \n\
1263 Specify the name of the machine to connect to.",
1264         vx_open, vx_close, vx_attach, 0, /* vx_detach, */
1265         0, 0, /* resume, wait */
1266         0, 0, /* read_reg, write_reg */
1267         0, /* prep_to_store, */
1268         vx_xfer_memory, vx_files_info,
1269         0, 0, /* insert_breakpoint, remove_breakpoint */
1270         0, 0, 0, 0, 0,  /* terminal stuff */
1271         0, /* vx_kill, */
1272         vx_load_command,
1273         vx_lookup_symbol,
1274         vx_create_inferior, 0,  /* mourn_inferior */
1275         0, /* can_run */
1276         0, /* notice_signals */
1277         core_stratum, 0, /* next */
1278         1, 1, 0, 0, 0,  /* all mem, mem, stack, regs, exec */
1279         0, 0,                   /* Section pointers */
1280         OPS_MAGIC,              /* Always the last thing */
1281 };
1282
1283 /* Target ops structure for accessing VxWorks child processes over the net */
1284
1285 struct target_ops vx_run_ops = {
1286         "vxprocess", "VxWorks process",
1287         "VxWorks process, started by the \"run\" command.",
1288         vx_proc_open, vx_proc_close, 0, vx_detach, /* vx_attach */
1289         vx_resume, vx_wait,
1290         vx_read_register, vx_write_register,
1291         vx_prepare_to_store,
1292         vx_xfer_memory, vx_run_files_info,
1293         vx_insert_breakpoint, vx_remove_breakpoint,
1294         0, 0, 0, 0, 0,  /* terminal stuff */
1295         vx_kill,
1296         vx_load_command,
1297         vx_lookup_symbol,
1298         0, vx_mourn_inferior,
1299         0,  /* can_run */
1300         0, /* notice_signals */
1301         process_stratum, 0, /* next */
1302         0, 1, 1, 1, 1,  /* all mem, mem, stack, regs, exec */
1303                         /* all_mem is off to avoid spurious msg in "i files" */
1304         0, 0,                   /* Section pointers */
1305         OPS_MAGIC,              /* Always the last thing */
1306 };
1307 /* ==> Remember when reading at end of file, there are two "ops" structs here. */
1308 \f
1309 void
1310 _initialize_vx ()
1311 {
1312   add_target (&vx_ops);
1313   add_target (&vx_run_ops);
1314 }