1 /* Low level interface to ptrace, for the remote server for GDB.
2 Copyright (C) 1986, 1987, 1993 Free Software Foundation, Inc.
4 This file is part of GDB.
6 This program is free software; you can redistribute it and/or modify
7 it under the terms of the GNU General Public License as published by
8 the Free Software Foundation; either version 2 of the License, or
9 (at your option) any later version.
11 This program is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 GNU General Public License for more details.
16 You should have received a copy of the GNU General Public License
17 along with this program; if not, write to the Free Software
18 Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
25 #include <sys/param.h>
29 #include <sys/signal.h>
31 #include <sys/kernel.h>
35 #include <sys/itimer.h>
37 #include <sys/resource.h>
40 #include <sys/ioctl.h>
46 char registers[REGISTER_BYTES];
48 #include <sys/ptrace.h>
50 /* Start an inferior process and returns its pid.
51 ALLARGS is a vector of program-name and args. */
54 create_inferior (program, allargs)
62 perror_with_name ("fork");
68 /* Switch child to it's own process group so that signals won't
69 directly affect gdbserver. */
73 ioctl (0, TIOCSPGRP, &pgrp);
75 ptrace (PTRACE_TRACEME, 0, (PTRACE_ARG3_TYPE)0, 0);
77 execv (program, allargs);
79 fprintf (stderr, "GDBserver (process %d): Cannot exec %s: %s.\n",
81 errno < sys_nerr ? sys_errlist[errno] : "unknown error");
89 /* Kill the inferior process. Make us have no inferior. */
94 if (inferior_pid == 0)
96 ptrace (PTRACE_KILL, inferior_pid, 0, 0);
102 /* Return nonzero if the given thread is still alive. */
107 /* Arggh. Apparently pthread_kill only works for threads within
108 the process that calls pthread_kill.
110 We want to avoid the lynx signal extensions as they simply don't
111 map well to the generic gdb interface we want to keep.
113 All we want to do is determine if a particular thread is alive;
114 it appears as if we can just make a harmless thread specific
115 ptrace call to do that. */
116 return (ptrace (PTRACE_THREADUSER,
117 BUILDPID (PIDGET (inferior_pid), pid), 0, 0) != -1);
120 /* Wait for process, returns status */
137 if (pid != PIDGET(inferior_pid))
138 perror_with_name ("wait");
140 thread_from_wait = w.w_tid;
141 inferior_pid = BUILDPID (inferior_pid, w.w_tid);
144 && WSTOPSIG(w) == SIGTRAP)
148 realsig = ptrace (PTRACE_GETTRACESIG, inferior_pid,
149 (PTRACE_ARG3_TYPE)0, 0);
151 if (realsig == SIGNEWTHREAD)
153 /* It's a new thread notification. Nothing to do here since
154 the machine independent code in wait_for_inferior will
155 add the thread to the thread list and restart the thread
156 when pid != inferior_pid and pid is not in the thread list.
157 We don't even want to muck with realsig -- the code in
158 wait_for_inferior expects SIGTRAP. */
168 return ((unsigned char) WEXITSTATUS (w));
170 else if (!WIFSTOPPED (w))
173 return ((unsigned char) WTERMSIG (w));
176 fetch_inferior_registers (0);
179 return ((unsigned char) WSTOPSIG (w));
182 /* Resume execution of the inferior process.
183 If STEP is nonzero, single-step it.
184 If SIGNAL is nonzero, give it that signal. */
187 myresume (step, signal)
192 ptrace (step ? PTRACE_SINGLESTEP_ONE : PTRACE_CONT,
193 BUILDPID (inferior_pid, cont_thread == -1 ? 0 : cont_thread),
196 perror_with_name ("ptrace");
200 #define offsetof(TYPE, MEMBER) ((unsigned long) &((TYPE *)0)->MEMBER)
202 /* Mapping between GDB register #s and offsets into econtext. Must be
203 consistent with REGISTER_NAMES macro in various tmXXX.h files. */
205 #define X(ENTRY)(offsetof(struct econtext, ENTRY))
208 /* Mappings from tm-i386v.h */
210 static int regmap[] =
226 X(ecode), /* Lynx doesn't give us either fs or gs, so */
227 X(fault), /* we just substitute these two in the hopes
228 that they are useful. */
233 /* Mappings from tm-m68k.h */
235 static int regmap[] =
247 X(regs[10]), /* a2 */
248 X(regs[11]), /* a3 */
249 X(regs[12]), /* a4 */
250 X(regs[13]), /* a5 */
251 X(regs[14]), /* fp */
256 X(fregs[0*3]), /* fp0 */
257 X(fregs[1*3]), /* fp1 */
258 X(fregs[2*3]), /* fp2 */
259 X(fregs[3*3]), /* fp3 */
260 X(fregs[4*3]), /* fp4 */
261 X(fregs[5*3]), /* fp5 */
262 X(fregs[6*3]), /* fp6 */
263 X(fregs[7*3]), /* fp7 */
265 X(fcregs[0]), /* fpcontrol */
266 X(fcregs[1]), /* fpstatus */
267 X(fcregs[2]), /* fpiaddr */
269 X(fault), /* fpflags */
274 /* Mappings from tm-sparc.h */
276 #define FX(ENTRY)(offsetof(struct fcontext, ENTRY))
278 static int regmap[] =
285 -1, /* g5->g7 aren't saved by Lynx */
298 -1,-1,-1,-1,-1,-1,-1,-1, /* l0 -> l7 */
300 -1,-1,-1,-1,-1,-1,-1,-1, /* i0 -> i7 */
302 FX(f.fregs[0]), /* f0 */
348 /* This routine handles some oddball cases for Sparc registers and LynxOS.
349 In partucular, it causes refs to G0, g5->7, and all fp regs to return zero.
350 It also handles knows where to find the I & L regs on the stack. */
353 fetch_inferior_registers (regno)
359 #define WHATREGS_FLOAT 1
360 #define WHATREGS_GEN 2
361 #define WHATREGS_STACK 4
364 whatregs = WHATREGS_FLOAT | WHATREGS_GEN | WHATREGS_STACK;
365 else if (regno >= L0_REGNUM && regno <= I7_REGNUM)
366 whatregs = WHATREGS_STACK;
367 else if (regno >= FP0_REGNUM && regno < FP0_REGNUM + 32)
368 whatregs = WHATREGS_FLOAT;
370 whatregs = WHATREGS_GEN;
372 if (whatregs & WHATREGS_GEN)
374 struct econtext ec; /* general regs */
375 char buf[MAX_REGISTER_RAW_SIZE];
380 retval = ptrace (PTRACE_GETREGS,
381 BUILDPID (inferior_pid, general_thread),
382 (PTRACE_ARG3_TYPE) &ec,
385 perror_with_name ("Sparc fetch_inferior_registers(ptrace)");
387 memset (buf, 0, REGISTER_RAW_SIZE (G0_REGNUM));
388 supply_register (G0_REGNUM, buf);
389 supply_register (TBR_REGNUM, (char *)&ec.tbr);
391 memcpy (®isters[REGISTER_BYTE (G1_REGNUM)], &ec.g1,
392 4 * REGISTER_RAW_SIZE (G1_REGNUM));
393 for (i = G1_REGNUM; i <= G1_REGNUM + 3; i++)
394 register_valid[i] = 1;
396 supply_register (PS_REGNUM, (char *)&ec.psr);
397 supply_register (Y_REGNUM, (char *)&ec.y);
398 supply_register (PC_REGNUM, (char *)&ec.pc);
399 supply_register (NPC_REGNUM, (char *)&ec.npc);
400 supply_register (WIM_REGNUM, (char *)&ec.wim);
402 memcpy (®isters[REGISTER_BYTE (O0_REGNUM)], ec.o,
403 8 * REGISTER_RAW_SIZE (O0_REGNUM));
404 for (i = O0_REGNUM; i <= O0_REGNUM + 7; i++)
405 register_valid[i] = 1;
408 if (whatregs & WHATREGS_STACK)
413 sp = read_register (SP_REGNUM);
415 target_xfer_memory (sp + FRAME_SAVED_I0,
416 ®isters[REGISTER_BYTE(I0_REGNUM)],
417 8 * REGISTER_RAW_SIZE (I0_REGNUM), 0);
418 for (i = I0_REGNUM; i <= I7_REGNUM; i++)
419 register_valid[i] = 1;
421 target_xfer_memory (sp + FRAME_SAVED_L0,
422 ®isters[REGISTER_BYTE(L0_REGNUM)],
423 8 * REGISTER_RAW_SIZE (L0_REGNUM), 0);
424 for (i = L0_REGNUM; i <= L0_REGNUM + 7; i++)
425 register_valid[i] = 1;
428 if (whatregs & WHATREGS_FLOAT)
430 struct fcontext fc; /* fp regs */
435 retval = ptrace (PTRACE_GETFPREGS, BUILDPID (inferior_pid, general_thread), (PTRACE_ARG3_TYPE) &fc,
438 perror_with_name ("Sparc fetch_inferior_registers(ptrace)");
440 memcpy (®isters[REGISTER_BYTE (FP0_REGNUM)], fc.f.fregs,
441 32 * REGISTER_RAW_SIZE (FP0_REGNUM));
442 for (i = FP0_REGNUM; i <= FP0_REGNUM + 31; i++)
443 register_valid[i] = 1;
445 supply_register (FPS_REGNUM, (char *)&fc.fsr);
450 /* This routine handles storing of the I & L regs for the Sparc. The trick
451 here is that they actually live on the stack. The really tricky part is
452 that when changing the stack pointer, the I & L regs must be written to
453 where the new SP points, otherwise the regs will be incorrect when the
454 process is started up again. We assume that the I & L regs are valid at
458 store_inferior_registers (regno)
465 whatregs = WHATREGS_FLOAT | WHATREGS_GEN | WHATREGS_STACK;
466 else if (regno >= L0_REGNUM && regno <= I7_REGNUM)
467 whatregs = WHATREGS_STACK;
468 else if (regno >= FP0_REGNUM && regno < FP0_REGNUM + 32)
469 whatregs = WHATREGS_FLOAT;
470 else if (regno == SP_REGNUM)
471 whatregs = WHATREGS_STACK | WHATREGS_GEN;
473 whatregs = WHATREGS_GEN;
475 if (whatregs & WHATREGS_GEN)
477 struct econtext ec; /* general regs */
480 ec.tbr = read_register (TBR_REGNUM);
481 memcpy (&ec.g1, ®isters[REGISTER_BYTE (G1_REGNUM)],
482 4 * REGISTER_RAW_SIZE (G1_REGNUM));
484 ec.psr = read_register (PS_REGNUM);
485 ec.y = read_register (Y_REGNUM);
486 ec.pc = read_register (PC_REGNUM);
487 ec.npc = read_register (NPC_REGNUM);
488 ec.wim = read_register (WIM_REGNUM);
490 memcpy (ec.o, ®isters[REGISTER_BYTE (O0_REGNUM)],
491 8 * REGISTER_RAW_SIZE (O0_REGNUM));
494 retval = ptrace (PTRACE_SETREGS, BUILDPID (inferior_pid, general_thread), (PTRACE_ARG3_TYPE) &ec,
497 perror_with_name ("Sparc fetch_inferior_registers(ptrace)");
500 if (whatregs & WHATREGS_STACK)
505 sp = read_register (SP_REGNUM);
507 if (regno == -1 || regno == SP_REGNUM)
509 if (!register_valid[L0_REGNUM+5])
511 target_xfer_memory (sp + FRAME_SAVED_I0,
512 ®isters[REGISTER_BYTE (I0_REGNUM)],
513 8 * REGISTER_RAW_SIZE (I0_REGNUM), 1);
515 target_xfer_memory (sp + FRAME_SAVED_L0,
516 ®isters[REGISTER_BYTE (L0_REGNUM)],
517 8 * REGISTER_RAW_SIZE (L0_REGNUM), 1);
519 else if (regno >= L0_REGNUM && regno <= I7_REGNUM)
521 if (!register_valid[regno])
523 if (regno >= L0_REGNUM && regno <= L0_REGNUM + 7)
524 regoffset = REGISTER_BYTE (regno) - REGISTER_BYTE (L0_REGNUM)
527 regoffset = REGISTER_BYTE (regno) - REGISTER_BYTE (I0_REGNUM)
529 target_xfer_memory (sp + regoffset, ®isters[REGISTER_BYTE (regno)],
530 REGISTER_RAW_SIZE (regno), 1);
534 if (whatregs & WHATREGS_FLOAT)
536 struct fcontext fc; /* fp regs */
539 /* We read fcontext first so that we can get good values for fq_t... */
541 retval = ptrace (PTRACE_GETFPREGS, BUILDPID (inferior_pid, general_thread), (PTRACE_ARG3_TYPE) &fc,
544 perror_with_name ("Sparc fetch_inferior_registers(ptrace)");
546 memcpy (fc.f.fregs, ®isters[REGISTER_BYTE (FP0_REGNUM)],
547 32 * REGISTER_RAW_SIZE (FP0_REGNUM));
549 fc.fsr = read_register (FPS_REGNUM);
552 retval = ptrace (PTRACE_SETFPREGS, BUILDPID (inferior_pid, general_thread), (PTRACE_ARG3_TYPE) &fc,
555 perror_with_name ("Sparc fetch_inferior_registers(ptrace)");
563 /* Return the offset relative to the start of the per-thread data to the
564 saved context block. */
567 lynx_registers_addr()
570 int ecpoff = offsetof(st_t, ecp);
574 stblock = (CORE_ADDR) ptrace (PTRACE_THREADUSER, BUILDPID (inferior_pid, general_thread),
575 (PTRACE_ARG3_TYPE)0, 0);
577 perror_with_name ("PTRACE_THREADUSER");
579 ecp = (CORE_ADDR) ptrace (PTRACE_PEEKTHREAD, BUILDPID (inferior_pid, general_thread),
580 (PTRACE_ARG3_TYPE)ecpoff, 0);
582 perror_with_name ("lynx_registers_addr(PTRACE_PEEKTHREAD)");
584 return ecp - stblock;
587 /* Fetch one or more registers from the inferior. REGNO == -1 to get
588 them all. We actually fetch more than requested, when convenient,
589 marking them as valid so we won't fetch them again. */
592 fetch_inferior_registers (ignored)
599 ecp = lynx_registers_addr();
601 for (regno = 0; regno < NUM_REGS; regno++)
603 int ptrace_fun = PTRACE_PEEKTHREAD;
605 #ifdef PTRACE_PEEKUSP
606 ptrace_fun = regno == SP_REGNUM ? PTRACE_PEEKUSP : PTRACE_PEEKTHREAD;
610 reg = ptrace (ptrace_fun, BUILDPID (inferior_pid, general_thread),
611 (PTRACE_ARG3_TYPE) (ecp + regmap[regno]), 0);
613 perror_with_name ("fetch_inferior_registers(PTRACE_PEEKTHREAD)");
615 *(unsigned long *)®isters[REGISTER_BYTE (regno)] = reg;
619 /* Store our register values back into the inferior.
620 If REGNO is -1, do this for all registers.
621 Otherwise, REGNO specifies which register (so we can save time). */
624 store_inferior_registers (ignored)
631 ecp = lynx_registers_addr();
633 for (regno = 0; regno < NUM_REGS; regno++)
635 int ptrace_fun = PTRACE_POKEUSER;
637 #ifdef PTRACE_POKEUSP
638 ptrace_fun = regno == SP_REGNUM ? PTRACE_POKEUSP : PTRACE_POKEUSER;
641 reg = *(unsigned long *)®isters[REGISTER_BYTE (regno)];
644 ptrace (ptrace_fun, BUILDPID (inferior_pid, general_thread),
645 (PTRACE_ARG3_TYPE) (ecp + regmap[regno]), reg);
647 perror_with_name ("PTRACE_POKEUSER");
653 /* NOTE! I tried using PTRACE_READDATA, etc., to read and write memory
654 in the NEW_SUN_PTRACE case.
655 It ought to be straightforward. But it appears that writing did
656 not write the data that I specified. I cannot understand where
657 it got the data that it actually did write. */
659 /* Copy LEN bytes from inferior's memory starting at MEMADDR
660 to debugger memory starting at MYADDR. */
663 read_inferior_memory (memaddr, myaddr, len)
669 /* Round starting address down to longword boundary. */
670 register CORE_ADDR addr = memaddr & -sizeof (int);
671 /* Round ending address up; get number of longwords that makes. */
673 = (((memaddr + len) - addr) + sizeof (int) - 1) / sizeof (int);
674 /* Allocate buffer of that many longwords. */
675 register int *buffer = (int *) alloca (count * sizeof (int));
677 /* Read all the longwords */
678 for (i = 0; i < count; i++, addr += sizeof (int))
680 buffer[i] = ptrace (PTRACE_PEEKTEXT, BUILDPID (inferior_pid, general_thread), addr, 0);
683 /* Copy appropriate bytes out of the buffer. */
684 memcpy (myaddr, (char *) buffer + (memaddr & (sizeof (int) - 1)), len);
687 /* Copy LEN bytes of data from debugger memory at MYADDR
688 to inferior's memory at MEMADDR.
689 On failure (cannot write the inferior)
690 returns the value of errno. */
693 write_inferior_memory (memaddr, myaddr, len)
699 /* Round starting address down to longword boundary. */
700 register CORE_ADDR addr = memaddr & -sizeof (int);
701 /* Round ending address up; get number of longwords that makes. */
703 = (((memaddr + len) - addr) + sizeof (int) - 1) / sizeof (int);
704 /* Allocate buffer of that many longwords. */
705 register int *buffer = (int *) alloca (count * sizeof (int));
708 /* Fill start and end extra bytes of buffer with existing memory data. */
710 buffer[0] = ptrace (PTRACE_PEEKTEXT, BUILDPID (inferior_pid, general_thread), addr, 0);
715 = ptrace (PTRACE_PEEKTEXT, BUILDPID (inferior_pid, general_thread),
716 addr + (count - 1) * sizeof (int), 0);
719 /* Copy data to be written over corresponding part of buffer */
721 memcpy ((char *) buffer + (memaddr & (sizeof (int) - 1)), myaddr, len);
723 /* Write the entire buffer. */
725 for (i = 0; i < count; i++, addr += sizeof (int))
730 ptrace (PTRACE_POKETEXT, BUILDPID (inferior_pid, general_thread), addr, buffer[i]);
734 ptrace (PTRACE_POKETEXT): errno=%d, pid=0x%x, addr=0x%x, buffer[i] = 0x%x\n",
735 errno, BUILDPID (inferior_pid, general_thread),
737 fprintf(stderr, "Sleeping for 1 second\n");