gdb/gdbserver/spu-low.c

   1 /* Low level interface to SPUs, for the remote server for GDB.
   2    Copyright (C) 2006-2012 Free Software Foundation, Inc.
   3
   4    Contributed by Ulrich Weigand <uweigand@de.ibm.com>.
   5
   6    This file is part of GDB.
   7
   8    This program is free software; you can redistribute it and/or modify
   9    it under the terms of the GNU General Public License as published by
  10    the Free Software Foundation; either version 3 of the License, or
  11    (at your option) any later version.
  12
  13    This program is distributed in the hope that it will be useful,
  14    but WITHOUT ANY WARRANTY; without even the implied warranty of
  15    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16    GNU General Public License for more details.
  17
  18    You should have received a copy of the GNU General Public License
  19    along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
  20
  21 #include "server.h"
  22
  23 #include <sys/wait.h>
  24 #include <stdio.h>
  25 #include <sys/ptrace.h>
  26 #include <fcntl.h>
  27 #include <string.h>
  28 #include <stdlib.h>
  29 #include <unistd.h>
  30 #include <errno.h>
  31 #include <sys/syscall.h>
  32
  33 /* Some older glibc versions do not define this.  */
  34 #ifndef __WNOTHREAD
  35 #define __WNOTHREAD     0x20000000      /* Don't wait on children of other
  36                                            threads in this group */
  37 #endif
  38
  39 #define PTRACE_TYPE_RET long
  40 #define PTRACE_TYPE_ARG3 long
  41
  42 /* Number of registers.  */
  43 #define SPU_NUM_REGS         130
  44 #define SPU_NUM_CORE_REGS    128
  45
  46 /* Special registers.  */
  47 #define SPU_ID_REGNUM        128
  48 #define SPU_PC_REGNUM        129
  49
  50 /* PPU side system calls.  */
  51 #define INSTR_SC        0x44000002
  52 #define NR_spu_run      0x0116
  53
  54 /* These are used in remote-utils.c.  */
  55 int using_threads = 0;
  56
  57 /* Defined in auto-generated file reg-spu.c.  */
  58 void init_registers_spu (void);
  59
  60
  61 /* Fetch PPU register REGNO.  */
  62 static CORE_ADDR
  63 fetch_ppc_register (int regno)
  64 {
  65   PTRACE_TYPE_RET res;
  66
  67   int tid = ptid_get_lwp (current_ptid);
  68
  69 #ifndef __powerpc64__
  70   /* If running as a 32-bit process on a 64-bit system, we attempt
  71      to get the full 64-bit register content of the target process.
  72      If the PPC special ptrace call fails, we're on a 32-bit system;
  73      just fall through to the regular ptrace call in that case.  */
  74   {
  75     char buf[8];
  76
  77     errno = 0;
  78     ptrace (PPC_PTRACE_PEEKUSR_3264, tid,
  79             (PTRACE_TYPE_ARG3) (regno * 8), buf);
  80     if (errno == 0)
  81       ptrace (PPC_PTRACE_PEEKUSR_3264, tid,
  82               (PTRACE_TYPE_ARG3) (regno * 8 + 4), buf + 4);
  83     if (errno == 0)
  84       return (CORE_ADDR) *(unsigned long long *)buf;
  85   }
  86 #endif
  87
  88   errno = 0;
  89   res = ptrace (PT_READ_U, tid,
  90                 (PTRACE_TYPE_ARG3) (regno * sizeof (PTRACE_TYPE_RET)), 0);
  91   if (errno != 0)
  92     {
  93       char mess[128];
  94       sprintf (mess, "reading PPC register #%d", regno);
  95       perror_with_name (mess);
  96     }
  97
  98   return (CORE_ADDR) (unsigned long) res;
  99 }
 100
 101 /* Fetch WORD from PPU memory at (aligned) MEMADDR in thread TID.  */
 102 static int
 103 fetch_ppc_memory_1 (int tid, CORE_ADDR memaddr, PTRACE_TYPE_RET *word)
 104 {
 105   errno = 0;
 106
 107 #ifndef __powerpc64__
 108   if (memaddr >> 32)
 109     {
 110       unsigned long long addr_8 = (unsigned long long) memaddr;
 111       ptrace (PPC_PTRACE_PEEKTEXT_3264, tid, (PTRACE_TYPE_ARG3) &addr_8, word);
 112     }
 113   else
 114 #endif
 115     *word = ptrace (PT_READ_I, tid, (PTRACE_TYPE_ARG3) (size_t) memaddr, 0);
 116
 117   return errno;
 118 }
 119
 120 /* Store WORD into PPU memory at (aligned) MEMADDR in thread TID.  */
 121 static int
 122 store_ppc_memory_1 (int tid, CORE_ADDR memaddr, PTRACE_TYPE_RET word)
 123 {
 124   errno = 0;
 125
 126 #ifndef __powerpc64__
 127   if (memaddr >> 32)
 128     {
 129       unsigned long long addr_8 = (unsigned long long) memaddr;
 130       ptrace (PPC_PTRACE_POKEDATA_3264, tid, (PTRACE_TYPE_ARG3) &addr_8, word);
 131     }
 132   else
 133 #endif
 134     ptrace (PT_WRITE_D, tid, (PTRACE_TYPE_ARG3) (size_t) memaddr, word);
 135
 136   return errno;
 137 }
 138
 139 /* Fetch LEN bytes of PPU memory at MEMADDR to MYADDR.  */
 140 static int
 141 fetch_ppc_memory (CORE_ADDR memaddr, char *myaddr, int len)
 142 {
 143   int i, ret;
 144
 145   CORE_ADDR addr = memaddr & -(CORE_ADDR) sizeof (PTRACE_TYPE_RET);
 146   int count = ((((memaddr + len) - addr) + sizeof (PTRACE_TYPE_RET) - 1)
 147                / sizeof (PTRACE_TYPE_RET));
 148   PTRACE_TYPE_RET *buffer;
 149
 150   int tid = ptid_get_lwp (current_ptid);
 151
 152   buffer = (PTRACE_TYPE_RET *) alloca (count * sizeof (PTRACE_TYPE_RET));
 153   for (i = 0; i < count; i++, addr += sizeof (PTRACE_TYPE_RET))
 154     if ((ret = fetch_ppc_memory_1 (tid, addr, &buffer[i])) != 0)
 155       return ret;
 156
 157   memcpy (myaddr,
 158           (char *) buffer + (memaddr & (sizeof (PTRACE_TYPE_RET) - 1)),
 159           len);
 160
 161   return 0;
 162 }
 163
 164 /* Store LEN bytes from MYADDR to PPU memory at MEMADDR.  */
 165 static int
 166 store_ppc_memory (CORE_ADDR memaddr, char *myaddr, int len)
 167 {
 168   int i, ret;
 169
 170   CORE_ADDR addr = memaddr & -(CORE_ADDR) sizeof (PTRACE_TYPE_RET);
 171   int count = ((((memaddr + len) - addr) + sizeof (PTRACE_TYPE_RET) - 1)
 172                / sizeof (PTRACE_TYPE_RET));
 173   PTRACE_TYPE_RET *buffer;
 174
 175   int tid = ptid_get_lwp (current_ptid);
 176
 177   buffer = (PTRACE_TYPE_RET *) alloca (count * sizeof (PTRACE_TYPE_RET));
 178
 179   if (addr != memaddr || len < (int) sizeof (PTRACE_TYPE_RET))
 180     if ((ret = fetch_ppc_memory_1 (tid, addr, &buffer[0])) != 0)
 181       return ret;
 182
 183   if (count > 1)
 184     if ((ret = fetch_ppc_memory_1 (tid, addr + (count - 1)
 185                                                * sizeof (PTRACE_TYPE_RET),
 186                                    &buffer[count - 1])) != 0)
 187       return ret;
 188
 189   memcpy ((char *) buffer + (memaddr & (sizeof (PTRACE_TYPE_RET) - 1)),
 190           myaddr, len);
 191
 192   for (i = 0; i < count; i++, addr += sizeof (PTRACE_TYPE_RET))
 193     if ((ret = store_ppc_memory_1 (tid, addr, buffer[i])) != 0)
 194       return ret;
 195
 196   return 0;
 197 }
 198
 199
 200 /* If the PPU thread is currently stopped on a spu_run system call,
 201    return to FD and ADDR the file handle and NPC parameter address
 202    used with the system call.  Return non-zero if successful.  */
 203 static int
 204 parse_spufs_run (int *fd, CORE_ADDR *addr)
 205 {
 206   unsigned int insn;
 207   CORE_ADDR pc = fetch_ppc_register (32);  /* nip */
 208
 209   /* Fetch instruction preceding current NIP.  */
 210   if (fetch_ppc_memory (pc-4, (char *) &insn, 4) != 0)
 211     return 0;
 212   /* It should be a "sc" instruction.  */
 213   if (insn != INSTR_SC)
 214     return 0;
 215   /* System call number should be NR_spu_run.  */
 216   if (fetch_ppc_register (0) != NR_spu_run)
 217     return 0;
 218
 219   /* Register 3 contains fd, register 4 the NPC param pointer.  */
 220   *fd = fetch_ppc_register (34);  /* orig_gpr3 */
 221   *addr = fetch_ppc_register (4);
 222   return 1;
 223 }
 224
 225
 226 /* Copy LEN bytes at OFFSET in spufs file ANNEX into/from READBUF or WRITEBUF,
 227    using the /proc file system.  */
 228 static int
 229 spu_proc_xfer_spu (const char *annex, unsigned char *readbuf,
 230                    const unsigned char *writebuf,
 231                    CORE_ADDR offset, int len)
 232 {
 233   char buf[128];
 234   int fd = 0;
 235   int ret = -1;
 236
 237   if (!annex)
 238     return 0;
 239
 240   sprintf (buf, "/proc/%ld/fd/%s", ptid_get_lwp (current_ptid), annex);
 241   fd = open (buf, writebuf? O_WRONLY : O_RDONLY);
 242   if (fd <= 0)
 243     return -1;
 244
 245   if (offset != 0
 246       && lseek (fd, (off_t) offset, SEEK_SET) != (off_t) offset)
 247     {
 248       close (fd);
 249       return 0;
 250     }
 251
 252   if (writebuf)
 253     ret = write (fd, writebuf, (size_t) len);
 254   else if (readbuf)
 255     ret = read (fd, readbuf, (size_t) len);
 256
 257   close (fd);
 258   return ret;
 259 }
 260
 261
 262 /* Start an inferior process and returns its pid.
 263    ALLARGS is a vector of program-name and args. */
 264 static int
 265 spu_create_inferior (char *program, char **allargs)
 266 {
 267   int pid;
 268   ptid_t ptid;
 269
 270   pid = fork ();
 271   if (pid < 0)
 272     perror_with_name ("fork");
 273
 274   if (pid == 0)
 275     {
 276       ptrace (PTRACE_TRACEME, 0, 0, 0);
 277
 278       setpgid (0, 0);
 279
 280       execv (program, allargs);
 281       if (errno == ENOENT)
 282         execvp (program, allargs);
 283
 284       fprintf (stderr, "Cannot exec %s: %s.\n", program,
 285                strerror (errno));
 286       fflush (stderr);
 287       _exit (0177);
 288     }
 289
 290   add_process (pid, 0);
 291
 292   ptid = ptid_build (pid, pid, 0);
 293   add_thread (ptid, NULL);
 294   return pid;
 295 }
 296
 297 /* Attach to an inferior process.  */
 298 int
 299 spu_attach (unsigned long  pid)
 300 {
 301   ptid_t ptid;
 302
 303   if (ptrace (PTRACE_ATTACH, pid, 0, 0) != 0)
 304     {
 305       fprintf (stderr, "Cannot attach to process %ld: %s (%d)\n", pid,
 306                strerror (errno), errno);
 307       fflush (stderr);
 308       _exit (0177);
 309     }
 310
 311   add_process (pid, 1);
 312   ptid = ptid_build (pid, pid, 0);
 313   add_thread (ptid, NULL);
 314   return 0;
 315 }
 316
 317 /* Kill the inferior process.  */
 318 static int
 319 spu_kill (int pid)
 320 {
 321   int status, ret;
 322   struct process_info *process = find_process_pid (pid);
 323   if (process == NULL)
 324     return -1;
 325
 326   ptrace (PTRACE_KILL, pid, 0, 0);
 327
 328   do {
 329     ret = waitpid (pid, &status, 0);
 330     if (WIFEXITED (status) || WIFSIGNALED (status))
 331       break;
 332   } while (ret != -1 || errno != ECHILD);
 333
 334   clear_inferiors ();
 335   remove_process (process);
 336   return 0;
 337 }
 338
 339 /* Detach from inferior process.  */
 340 static int
 341 spu_detach (int pid)
 342 {
 343   struct process_info *process = find_process_pid (pid);
 344   if (process == NULL)
 345     return -1;
 346
 347   ptrace (PTRACE_DETACH, pid, 0, 0);
 348
 349   clear_inferiors ();
 350   remove_process (process);
 351   return 0;
 352 }
 353
 354 static void
 355 spu_mourn (struct process_info *process)
 356 {
 357   remove_process (process);
 358 }
 359
 360 static void
 361 spu_join (int pid)
 362 {
 363   int status, ret;
 364
 365   do {
 366     ret = waitpid (pid, &status, 0);
 367     if (WIFEXITED (status) || WIFSIGNALED (status))
 368       break;
 369   } while (ret != -1 || errno != ECHILD);
 370 }
 371
 372 /* Return nonzero if the given thread is still alive.  */
 373 static int
 374 spu_thread_alive (ptid_t ptid)
 375 {
 376   return ptid_equal (ptid, current_ptid);
 377 }
 378
 379 /* Resume process.  */
 380 static void
 381 spu_resume (struct thread_resume *resume_info, size_t n)
 382 {
 383   size_t i;
 384
 385   for (i = 0; i < n; i++)
 386     if (ptid_equal (resume_info[i].thread, minus_one_ptid)
 387         || ptid_equal (resume_info[i].thread, current_ptid))
 388       break;
 389
 390   if (i == n)
 391     return;
 392
 393   /* We don't support hardware single-stepping right now, assume
 394      GDB knows to use software single-stepping.  */
 395   if (resume_info[i].kind == resume_step)
 396     fprintf (stderr, "Hardware single-step not supported.\n");
 397
 398   regcache_invalidate ();
 399
 400   errno = 0;
 401   ptrace (PTRACE_CONT, ptid_get_lwp (current_ptid), 0, resume_info[i].sig);
 402   if (errno)
 403     perror_with_name ("ptrace");
 404 }
 405
 406 /* Wait for process, returns status.  */
 407 static ptid_t
 408 spu_wait (ptid_t ptid, struct target_waitstatus *ourstatus, int options)
 409 {
 410   int pid = ptid_get_pid (ptid);
 411   int w;
 412   int ret;
 413
 414   while (1)
 415     {
 416       ret = waitpid (pid, &w, WNOHANG | __WALL | __WNOTHREAD);
 417
 418       if (ret == -1)
 419         {
 420           if (errno != ECHILD)
 421             perror_with_name ("waitpid");
 422         }
 423       else if (ret > 0)
 424         break;
 425
 426       usleep (1000);
 427     }
 428
 429   /* On the first wait, continue running the inferior until we are
 430      blocked inside an spu_run system call.  */
 431   if (!server_waiting)
 432     {
 433       int fd;
 434       CORE_ADDR addr;
 435
 436       while (!parse_spufs_run (&fd, &addr))
 437         {
 438           ptrace (PT_SYSCALL, pid, (PTRACE_TYPE_ARG3) 0, 0);
 439           waitpid (pid, NULL, __WALL | __WNOTHREAD);
 440         }
 441     }
 442
 443   if (WIFEXITED (w))
 444     {
 445       fprintf (stderr, "\nChild exited with retcode = %x \n", WEXITSTATUS (w));
 446       ourstatus->kind =  TARGET_WAITKIND_EXITED;
 447       ourstatus->value.integer = WEXITSTATUS (w);
 448       clear_inferiors ();
 449       return pid_to_ptid (ret);
 450     }
 451   else if (!WIFSTOPPED (w))
 452     {
 453       fprintf (stderr, "\nChild terminated with signal = %x \n", WTERMSIG (w));
 454       ourstatus->kind = TARGET_WAITKIND_SIGNALLED;
 455       ourstatus->value.sig = gdb_signal_from_host (WTERMSIG (w));
 456       clear_inferiors ();
 457       return pid_to_ptid (ret);
 458     }
 459
 460   /* After attach, we may have received a SIGSTOP.  Do not return this
 461      as signal to GDB, or else it will try to continue with SIGSTOP ...  */
 462   if (!server_waiting)
 463     {
 464       ourstatus->kind = TARGET_WAITKIND_STOPPED;
 465       ourstatus->value.sig = GDB_SIGNAL_0;
 466       return ptid_build (ret, ret, 0);
 467     }
 468
 469   ourstatus->kind = TARGET_WAITKIND_STOPPED;
 470   ourstatus->value.sig = gdb_signal_from_host (WSTOPSIG (w));
 471   return ptid_build (ret, ret, 0);
 472 }
 473
 474 /* Fetch inferior registers.  */
 475 static void
 476 spu_fetch_registers (struct regcache *regcache, int regno)
 477 {
 478   int fd;
 479   CORE_ADDR addr;
 480
 481   /* We must be stopped on a spu_run system call.  */
 482   if (!parse_spufs_run (&fd, &addr))
 483     return;
 484
 485   /* The ID register holds the spufs file handle.  */
 486   if (regno == -1 || regno == SPU_ID_REGNUM)
 487     supply_register (regcache, SPU_ID_REGNUM, (char *)&fd);
 488
 489   /* The NPC register is found at ADDR.  */
 490   if (regno == -1 || regno == SPU_PC_REGNUM)
 491     {
 492       char buf[4];
 493       if (fetch_ppc_memory (addr, buf, 4) == 0)
 494         supply_register (regcache, SPU_PC_REGNUM, buf);
 495     }
 496
 497   /* The GPRs are found in the "regs" spufs file.  */
 498   if (regno == -1 || (regno >= 0 && regno < SPU_NUM_CORE_REGS))
 499     {
 500       unsigned char buf[16*SPU_NUM_CORE_REGS];
 501       char annex[32];
 502       int i;
 503
 504       sprintf (annex, "%d/regs", fd);
 505       if (spu_proc_xfer_spu (annex, buf, NULL, 0, sizeof buf) == sizeof buf)
 506         for (i = 0; i < SPU_NUM_CORE_REGS; i++)
 507           supply_register (regcache, i, buf + i*16);
 508     }
 509 }
 510
 511 /* Store inferior registers.  */
 512 static void
 513 spu_store_registers (struct regcache *regcache, int regno)
 514 {
 515   int fd;
 516   CORE_ADDR addr;
 517
 518   /* ??? Some callers use 0 to mean all registers.  */
 519   if (regno == 0)
 520     regno = -1;
 521
 522   /* We must be stopped on a spu_run system call.  */
 523   if (!parse_spufs_run (&fd, &addr))
 524     return;
 525
 526   /* The NPC register is found at ADDR.  */
 527   if (regno == -1 || regno == SPU_PC_REGNUM)
 528     {
 529       char buf[4];
 530       collect_register (regcache, SPU_PC_REGNUM, buf);
 531       store_ppc_memory (addr, buf, 4);
 532     }
 533
 534   /* The GPRs are found in the "regs" spufs file.  */
 535   if (regno == -1 || (regno >= 0 && regno < SPU_NUM_CORE_REGS))
 536     {
 537       unsigned char buf[16*SPU_NUM_CORE_REGS];
 538       char annex[32];
 539       int i;
 540
 541       for (i = 0; i < SPU_NUM_CORE_REGS; i++)
 542         collect_register (regcache, i, buf + i*16);
 543
 544       sprintf (annex, "%d/regs", fd);
 545       spu_proc_xfer_spu (annex, NULL, buf, 0, sizeof buf);
 546     }
 547 }
 548
 549 /* Copy LEN bytes from inferior's memory starting at MEMADDR
 550    to debugger memory starting at MYADDR.  */
 551 static int
 552 spu_read_memory (CORE_ADDR memaddr, unsigned char *myaddr, int len)
 553 {
 554   int fd, ret;
 555   CORE_ADDR addr;
 556   char annex[32], lslr_annex[32], buf[32];
 557   CORE_ADDR lslr;
 558
 559   /* We must be stopped on a spu_run system call.  */
 560   if (!parse_spufs_run (&fd, &addr))
 561     return 0;
 562
 563   /* Use the "mem" spufs file to access SPU local store.  */
 564   sprintf (annex, "%d/mem", fd);
 565   ret = spu_proc_xfer_spu (annex, myaddr, NULL, memaddr, len);
 566   if (ret > 0)
 567     return ret == len ? 0 : EIO;
 568
 569   /* SPU local store access wraps the address around at the
 570      local store limit.  We emulate this here.  To avoid needing
 571      an extra access to retrieve the LSLR, we only do that after
 572      trying the original address first, and getting end-of-file.  */
 573   sprintf (lslr_annex, "%d/lslr", fd);
 574   memset (buf, 0, sizeof buf);
 575   if (spu_proc_xfer_spu (lslr_annex, (unsigned char *)buf, NULL,
 576                          0, sizeof buf) <= 0)
 577     return ret;
 578
 579   lslr = strtoul (buf, NULL, 16);
 580   ret = spu_proc_xfer_spu (annex, myaddr, NULL, memaddr & lslr, len);
 581
 582   return ret == len ? 0 : EIO;
 583 }
 584
 585 /* Copy LEN bytes of data from debugger memory at MYADDR
 586    to inferior's memory at MEMADDR.
 587    On failure (cannot write the inferior)
 588    returns the value of errno.  */
 589 static int
 590 spu_write_memory (CORE_ADDR memaddr, const unsigned char *myaddr, int len)
 591 {
 592   int fd, ret;
 593   CORE_ADDR addr;
 594   char annex[32], lslr_annex[32], buf[32];
 595   CORE_ADDR lslr;
 596
 597   /* We must be stopped on a spu_run system call.  */
 598   if (!parse_spufs_run (&fd, &addr))
 599     return 0;
 600
 601   /* Use the "mem" spufs file to access SPU local store.  */
 602   sprintf (annex, "%d/mem", fd);
 603   ret = spu_proc_xfer_spu (annex, NULL, myaddr, memaddr, len);
 604   if (ret > 0)
 605     return ret == len ? 0 : EIO;
 606
 607   /* SPU local store access wraps the address around at the
 608      local store limit.  We emulate this here.  To avoid needing
 609      an extra access to retrieve the LSLR, we only do that after
 610      trying the original address first, and getting end-of-file.  */
 611   sprintf (lslr_annex, "%d/lslr", fd);
 612   memset (buf, 0, sizeof buf);
 613   if (spu_proc_xfer_spu (lslr_annex, (unsigned char *)buf, NULL,
 614                          0, sizeof buf) <= 0)
 615     return ret;
 616
 617   lslr = strtoul (buf, NULL, 16);
 618   ret = spu_proc_xfer_spu (annex, NULL, myaddr, memaddr & lslr, len);
 619
 620   return ret == len ? 0 : EIO;
 621 }
 622
 623 /* Look up special symbols -- unneded here.  */
 624 static void
 625 spu_look_up_symbols (void)
 626 {
 627 }
 628
 629 /* Send signal to inferior.  */
 630 static void
 631 spu_request_interrupt (void)
 632 {
 633   syscall (SYS_tkill, ptid_get_lwp (current_ptid), SIGINT);
 634 }
 635
 636 static struct target_ops spu_target_ops = {
 637   spu_create_inferior,
 638   spu_attach,
 639   spu_kill,
 640   spu_detach,
 641   spu_mourn,
 642   spu_join,
 643   spu_thread_alive,
 644   spu_resume,
 645   spu_wait,
 646   spu_fetch_registers,
 647   spu_store_registers,
 648   NULL, /* prepare_to_access_memory */
 649   NULL, /* done_accessing_memory */
 650   spu_read_memory,
 651   spu_write_memory,
 652   spu_look_up_symbols,
 653   spu_request_interrupt,
 654   NULL,
 655   NULL,
 656   NULL,
 657   NULL,
 658   NULL,
 659   NULL,
 660   NULL,
 661   spu_proc_xfer_spu,
 662   hostio_last_error_from_errno,
 663 };
 664
 665 void
 666 initialize_low (void)
 667 {
 668   static const unsigned char breakpoint[] = { 0x00, 0x00, 0x3f, 0xff };
 669
 670   set_target_ops (&spu_target_ops);
 671   set_breakpoint_data (breakpoint, sizeof breakpoint);
 672   init_registers_spu ();
 673 }