1 /* Low level interface to ptrace, for the remote server for GDB.
2 Copyright 1986, 1987, 1993, 1994, 1995, 1999, 2000
3 Free Software Foundation, Inc.
5 This file is part of GDB.
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.
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.
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., 59 Temple Place - Suite 330,
20 Boston, MA 02111-1307, USA. */
27 #include <sys/param.h>
31 #include <sys/signal.h>
33 #include <sys/kernel.h>
37 #include <sys/itimer.h>
39 #include <sys/resource.h>
42 #include <sys/ioctl.h>
48 static char my_registers
[REGISTER_BYTES
];
49 char *registers
= my_registers
;
51 #include <sys/ptrace.h>
53 /* Start an inferior process and returns its pid.
54 ALLARGS is a vector of program-name and args. */
57 create_inferior (char *program
, char **allargs
)
63 perror_with_name ("fork");
69 /* Switch child to it's own process group so that signals won't
70 directly affect gdbserver. */
74 ioctl (0, TIOCSPGRP
, &pgrp
);
76 ptrace (PTRACE_TRACEME
, 0, (PTRACE_ARG3_TYPE
) 0, 0);
78 execv (program
, allargs
);
80 fprintf (stderr
, "GDBserver (process %d): Cannot exec %s: %s.\n",
82 errno
< sys_nerr
? sys_errlist
[errno
] : "unknown error");
90 /* Kill the inferior process. Make us have no inferior. */
95 if (inferior_pid
== 0)
97 ptrace (PTRACE_KILL
, inferior_pid
, 0, 0);
103 /* Return nonzero if the given thread is still alive. */
105 mythread_alive (int pid
)
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 */
123 mywait (char *status
)
136 if (pid
!= PIDGET (inferior_pid
))
137 perror_with_name ("wait");
139 thread_from_wait
= w
.w_tid
;
140 inferior_pid
= BUILDPID (inferior_pid
, w
.w_tid
);
143 && WSTOPSIG (w
) == SIGTRAP
)
147 realsig
= ptrace (PTRACE_GETTRACESIG
, inferior_pid
,
148 (PTRACE_ARG3_TYPE
) 0, 0);
150 if (realsig
== SIGNEWTHREAD
)
152 /* It's a new thread notification. Nothing to do here since
153 the machine independent code in wait_for_inferior will
154 add the thread to the thread list and restart the thread
155 when pid != inferior_pid and pid is not in the thread list.
156 We don't even want to muck with realsig -- the code in
157 wait_for_inferior expects SIGTRAP. */
167 return ((unsigned char) WEXITSTATUS (w
));
169 else if (!WIFSTOPPED (w
))
172 return ((unsigned char) WTERMSIG (w
));
175 fetch_inferior_registers (0);
178 return ((unsigned char) WSTOPSIG (w
));
181 /* Resume execution of the inferior process.
182 If STEP is nonzero, single-step it.
183 If SIGNAL is nonzero, give it that signal. */
186 myresume (int step
, int signal
)
189 ptrace (step
? PTRACE_SINGLESTEP_ONE
: PTRACE_CONT
,
190 BUILDPID (inferior_pid
, cont_thread
== -1 ? 0 : cont_thread
),
193 perror_with_name ("ptrace");
197 #define offsetof(TYPE, MEMBER) ((unsigned long) &((TYPE *)0)->MEMBER)
199 /* Mapping between GDB register #s and offsets into econtext. Must be
200 consistent with REGISTER_NAMES macro in various tmXXX.h files. */
202 #define X(ENTRY)(offsetof(struct econtext, ENTRY))
205 /* Mappings from tm-i386v.h */
207 static int regmap
[] =
223 X (ecode
), /* Lynx doesn't give us either fs or gs, so */
224 X (fault
), /* we just substitute these two in the hopes
225 that they are useful. */
230 /* Mappings from tm-m68k.h */
232 static int regmap
[] =
234 X (regs
[0]), /* d0 */
235 X (regs
[1]), /* d1 */
236 X (regs
[2]), /* d2 */
237 X (regs
[3]), /* d3 */
238 X (regs
[4]), /* d4 */
239 X (regs
[5]), /* d5 */
240 X (regs
[6]), /* d6 */
241 X (regs
[7]), /* d7 */
242 X (regs
[8]), /* a0 */
243 X (regs
[9]), /* a1 */
244 X (regs
[10]), /* a2 */
245 X (regs
[11]), /* a3 */
246 X (regs
[12]), /* a4 */
247 X (regs
[13]), /* a5 */
248 X (regs
[14]), /* fp */
253 X (fregs
[0 * 3]), /* fp0 */
254 X (fregs
[1 * 3]), /* fp1 */
255 X (fregs
[2 * 3]), /* fp2 */
256 X (fregs
[3 * 3]), /* fp3 */
257 X (fregs
[4 * 3]), /* fp4 */
258 X (fregs
[5 * 3]), /* fp5 */
259 X (fregs
[6 * 3]), /* fp6 */
260 X (fregs
[7 * 3]), /* fp7 */
262 X (fcregs
[0]), /* fpcontrol */
263 X (fcregs
[1]), /* fpstatus */
264 X (fcregs
[2]), /* fpiaddr */
265 X (ssw
), /* fpcode */
266 X (fault
), /* fpflags */
271 /* Mappings from tm-sparc.h */
273 #define FX(ENTRY)(offsetof(struct fcontext, ENTRY))
275 static int regmap
[] =
282 -1, /* g5->g7 aren't saved by Lynx */
295 -1, -1, -1, -1, -1, -1, -1, -1, /* l0 -> l7 */
297 -1, -1, -1, -1, -1, -1, -1, -1, /* i0 -> i7 */
299 FX (f
.fregs
[0]), /* f0 */
345 /* This routine handles some oddball cases for Sparc registers and LynxOS.
346 In partucular, it causes refs to G0, g5->7, and all fp regs to return zero.
347 It also handles knows where to find the I & L regs on the stack. */
350 fetch_inferior_registers (int regno
)
355 #define WHATREGS_FLOAT 1
356 #define WHATREGS_GEN 2
357 #define WHATREGS_STACK 4
360 whatregs
= WHATREGS_FLOAT
| WHATREGS_GEN
| WHATREGS_STACK
;
361 else if (regno
>= L0_REGNUM
&& regno
<= I7_REGNUM
)
362 whatregs
= WHATREGS_STACK
;
363 else if (regno
>= FP0_REGNUM
&& regno
< FP0_REGNUM
+ 32)
364 whatregs
= WHATREGS_FLOAT
;
366 whatregs
= WHATREGS_GEN
;
368 if (whatregs
& WHATREGS_GEN
)
370 struct econtext ec
; /* general regs */
371 char buf
[MAX_REGISTER_RAW_SIZE
];
376 retval
= ptrace (PTRACE_GETREGS
,
377 BUILDPID (inferior_pid
, general_thread
),
378 (PTRACE_ARG3_TYPE
) & ec
,
381 perror_with_name ("Sparc fetch_inferior_registers(ptrace)");
383 memset (buf
, 0, REGISTER_RAW_SIZE (G0_REGNUM
));
384 supply_register (G0_REGNUM
, buf
);
385 supply_register (TBR_REGNUM
, (char *) &ec
.tbr
);
387 memcpy (®isters
[REGISTER_BYTE (G1_REGNUM
)], &ec
.g1
,
388 4 * REGISTER_RAW_SIZE (G1_REGNUM
));
389 for (i
= G1_REGNUM
; i
<= G1_REGNUM
+ 3; i
++)
390 register_valid
[i
] = 1;
392 supply_register (PS_REGNUM
, (char *) &ec
.psr
);
393 supply_register (Y_REGNUM
, (char *) &ec
.y
);
394 supply_register (PC_REGNUM
, (char *) &ec
.pc
);
395 supply_register (NPC_REGNUM
, (char *) &ec
.npc
);
396 supply_register (WIM_REGNUM
, (char *) &ec
.wim
);
398 memcpy (®isters
[REGISTER_BYTE (O0_REGNUM
)], ec
.o
,
399 8 * REGISTER_RAW_SIZE (O0_REGNUM
));
400 for (i
= O0_REGNUM
; i
<= O0_REGNUM
+ 7; i
++)
401 register_valid
[i
] = 1;
404 if (whatregs
& WHATREGS_STACK
)
409 sp
= read_register (SP_REGNUM
);
411 target_xfer_memory (sp
+ FRAME_SAVED_I0
,
412 ®isters
[REGISTER_BYTE (I0_REGNUM
)],
413 8 * REGISTER_RAW_SIZE (I0_REGNUM
), 0);
414 for (i
= I0_REGNUM
; i
<= I7_REGNUM
; i
++)
415 register_valid
[i
] = 1;
417 target_xfer_memory (sp
+ FRAME_SAVED_L0
,
418 ®isters
[REGISTER_BYTE (L0_REGNUM
)],
419 8 * REGISTER_RAW_SIZE (L0_REGNUM
), 0);
420 for (i
= L0_REGNUM
; i
<= L0_REGNUM
+ 7; i
++)
421 register_valid
[i
] = 1;
424 if (whatregs
& WHATREGS_FLOAT
)
426 struct fcontext fc
; /* fp regs */
431 retval
= ptrace (PTRACE_GETFPREGS
, BUILDPID (inferior_pid
, general_thread
), (PTRACE_ARG3_TYPE
) & fc
,
434 perror_with_name ("Sparc fetch_inferior_registers(ptrace)");
436 memcpy (®isters
[REGISTER_BYTE (FP0_REGNUM
)], fc
.f
.fregs
,
437 32 * REGISTER_RAW_SIZE (FP0_REGNUM
));
438 for (i
= FP0_REGNUM
; i
<= FP0_REGNUM
+ 31; i
++)
439 register_valid
[i
] = 1;
441 supply_register (FPS_REGNUM
, (char *) &fc
.fsr
);
446 /* This routine handles storing of the I & L regs for the Sparc. The trick
447 here is that they actually live on the stack. The really tricky part is
448 that when changing the stack pointer, the I & L regs must be written to
449 where the new SP points, otherwise the regs will be incorrect when the
450 process is started up again. We assume that the I & L regs are valid at
454 store_inferior_registers (int regno
)
460 whatregs
= WHATREGS_FLOAT
| WHATREGS_GEN
| WHATREGS_STACK
;
461 else if (regno
>= L0_REGNUM
&& regno
<= I7_REGNUM
)
462 whatregs
= WHATREGS_STACK
;
463 else if (regno
>= FP0_REGNUM
&& regno
< FP0_REGNUM
+ 32)
464 whatregs
= WHATREGS_FLOAT
;
465 else if (regno
== SP_REGNUM
)
466 whatregs
= WHATREGS_STACK
| WHATREGS_GEN
;
468 whatregs
= WHATREGS_GEN
;
470 if (whatregs
& WHATREGS_GEN
)
472 struct econtext ec
; /* general regs */
475 ec
.tbr
= read_register (TBR_REGNUM
);
476 memcpy (&ec
.g1
, ®isters
[REGISTER_BYTE (G1_REGNUM
)],
477 4 * REGISTER_RAW_SIZE (G1_REGNUM
));
479 ec
.psr
= read_register (PS_REGNUM
);
480 ec
.y
= read_register (Y_REGNUM
);
481 ec
.pc
= read_register (PC_REGNUM
);
482 ec
.npc
= read_register (NPC_REGNUM
);
483 ec
.wim
= read_register (WIM_REGNUM
);
485 memcpy (ec
.o
, ®isters
[REGISTER_BYTE (O0_REGNUM
)],
486 8 * REGISTER_RAW_SIZE (O0_REGNUM
));
489 retval
= ptrace (PTRACE_SETREGS
, BUILDPID (inferior_pid
, general_thread
), (PTRACE_ARG3_TYPE
) & ec
,
492 perror_with_name ("Sparc fetch_inferior_registers(ptrace)");
495 if (whatregs
& WHATREGS_STACK
)
500 sp
= read_register (SP_REGNUM
);
502 if (regno
== -1 || regno
== SP_REGNUM
)
504 if (!register_valid
[L0_REGNUM
+ 5])
506 target_xfer_memory (sp
+ FRAME_SAVED_I0
,
507 ®isters
[REGISTER_BYTE (I0_REGNUM
)],
508 8 * REGISTER_RAW_SIZE (I0_REGNUM
), 1);
510 target_xfer_memory (sp
+ FRAME_SAVED_L0
,
511 ®isters
[REGISTER_BYTE (L0_REGNUM
)],
512 8 * REGISTER_RAW_SIZE (L0_REGNUM
), 1);
514 else if (regno
>= L0_REGNUM
&& regno
<= I7_REGNUM
)
516 if (!register_valid
[regno
])
518 if (regno
>= L0_REGNUM
&& regno
<= L0_REGNUM
+ 7)
519 regoffset
= REGISTER_BYTE (regno
) - REGISTER_BYTE (L0_REGNUM
)
522 regoffset
= REGISTER_BYTE (regno
) - REGISTER_BYTE (I0_REGNUM
)
524 target_xfer_memory (sp
+ regoffset
, ®isters
[REGISTER_BYTE (regno
)],
525 REGISTER_RAW_SIZE (regno
), 1);
529 if (whatregs
& WHATREGS_FLOAT
)
531 struct fcontext fc
; /* fp regs */
534 /* We read fcontext first so that we can get good values for fq_t... */
536 retval
= ptrace (PTRACE_GETFPREGS
, BUILDPID (inferior_pid
, general_thread
), (PTRACE_ARG3_TYPE
) & fc
,
539 perror_with_name ("Sparc fetch_inferior_registers(ptrace)");
541 memcpy (fc
.f
.fregs
, ®isters
[REGISTER_BYTE (FP0_REGNUM
)],
542 32 * REGISTER_RAW_SIZE (FP0_REGNUM
));
544 fc
.fsr
= read_register (FPS_REGNUM
);
547 retval
= ptrace (PTRACE_SETFPREGS
, BUILDPID (inferior_pid
, general_thread
), (PTRACE_ARG3_TYPE
) & fc
,
550 perror_with_name ("Sparc fetch_inferior_registers(ptrace)");
558 /* Return the offset relative to the start of the per-thread data to the
559 saved context block. */
562 lynx_registers_addr (void)
565 int ecpoff
= offsetof (st_t
, ecp
);
569 stblock
= (CORE_ADDR
) ptrace (PTRACE_THREADUSER
, BUILDPID (inferior_pid
, general_thread
),
570 (PTRACE_ARG3_TYPE
) 0, 0);
572 perror_with_name ("PTRACE_THREADUSER");
574 ecp
= (CORE_ADDR
) ptrace (PTRACE_PEEKTHREAD
, BUILDPID (inferior_pid
, general_thread
),
575 (PTRACE_ARG3_TYPE
) ecpoff
, 0);
577 perror_with_name ("lynx_registers_addr(PTRACE_PEEKTHREAD)");
579 return ecp
- stblock
;
582 /* Fetch one or more registers from the inferior. REGNO == -1 to get
583 them all. We actually fetch more than requested, when convenient,
584 marking them as valid so we won't fetch them again. */
587 fetch_inferior_registers (int ignored
)
593 ecp
= lynx_registers_addr ();
595 for (regno
= 0; regno
< NUM_REGS
; regno
++)
597 int ptrace_fun
= PTRACE_PEEKTHREAD
;
599 #ifdef PTRACE_PEEKUSP
600 ptrace_fun
= regno
== SP_REGNUM
? PTRACE_PEEKUSP
: PTRACE_PEEKTHREAD
;
604 reg
= ptrace (ptrace_fun
, BUILDPID (inferior_pid
, general_thread
),
605 (PTRACE_ARG3_TYPE
) (ecp
+ regmap
[regno
]), 0);
607 perror_with_name ("fetch_inferior_registers(PTRACE_PEEKTHREAD)");
609 *(unsigned long *) ®isters
[REGISTER_BYTE (regno
)] = reg
;
613 /* Store our register values back into the inferior.
614 If REGNO is -1, do this for all registers.
615 Otherwise, REGNO specifies which register (so we can save time). */
618 store_inferior_registers (int ignored
)
624 ecp
= lynx_registers_addr ();
626 for (regno
= 0; regno
< NUM_REGS
; regno
++)
628 int ptrace_fun
= PTRACE_POKEUSER
;
630 #ifdef PTRACE_POKEUSP
631 ptrace_fun
= regno
== SP_REGNUM
? PTRACE_POKEUSP
: PTRACE_POKEUSER
;
634 reg
= *(unsigned long *) ®isters
[REGISTER_BYTE (regno
)];
637 ptrace (ptrace_fun
, BUILDPID (inferior_pid
, general_thread
),
638 (PTRACE_ARG3_TYPE
) (ecp
+ regmap
[regno
]), reg
);
640 perror_with_name ("PTRACE_POKEUSER");
646 /* NOTE! I tried using PTRACE_READDATA, etc., to read and write memory
647 in the NEW_SUN_PTRACE case.
648 It ought to be straightforward. But it appears that writing did
649 not write the data that I specified. I cannot understand where
650 it got the data that it actually did write. */
652 /* Copy LEN bytes from inferior's memory starting at MEMADDR
653 to debugger memory starting at MYADDR. */
656 read_inferior_memory (CORE_ADDR memaddr
, char *myaddr
, int len
)
659 /* Round starting address down to longword boundary. */
660 register CORE_ADDR addr
= memaddr
& -sizeof (int);
661 /* Round ending address up; get number of longwords that makes. */
663 = (((memaddr
+ len
) - addr
) + sizeof (int) - 1) / sizeof (int);
664 /* Allocate buffer of that many longwords. */
665 register int *buffer
= (int *) alloca (count
* sizeof (int));
667 /* Read all the longwords */
668 for (i
= 0; i
< count
; i
++, addr
+= sizeof (int))
670 buffer
[i
] = ptrace (PTRACE_PEEKTEXT
, BUILDPID (inferior_pid
, general_thread
), addr
, 0);
673 /* Copy appropriate bytes out of the buffer. */
674 memcpy (myaddr
, (char *) buffer
+ (memaddr
& (sizeof (int) - 1)), len
);
677 /* Copy LEN bytes of data from debugger memory at MYADDR
678 to inferior's memory at MEMADDR.
679 On failure (cannot write the inferior)
680 returns the value of errno. */
683 write_inferior_memory (CORE_ADDR memaddr
, char *myaddr
, int len
)
686 /* Round starting address down to longword boundary. */
687 register CORE_ADDR addr
= memaddr
& -sizeof (int);
688 /* Round ending address up; get number of longwords that makes. */
690 = (((memaddr
+ len
) - addr
) + sizeof (int) - 1) / sizeof (int);
691 /* Allocate buffer of that many longwords. */
692 register int *buffer
= (int *) alloca (count
* sizeof (int));
695 /* Fill start and end extra bytes of buffer with existing memory data. */
697 buffer
[0] = ptrace (PTRACE_PEEKTEXT
, BUILDPID (inferior_pid
, general_thread
), addr
, 0);
702 = ptrace (PTRACE_PEEKTEXT
, BUILDPID (inferior_pid
, general_thread
),
703 addr
+ (count
- 1) * sizeof (int), 0);
706 /* Copy data to be written over corresponding part of buffer */
708 memcpy ((char *) buffer
+ (memaddr
& (sizeof (int) - 1)), myaddr
, len
);
710 /* Write the entire buffer. */
712 for (i
= 0; i
< count
; i
++, addr
+= sizeof (int))
717 ptrace (PTRACE_POKETEXT
, BUILDPID (inferior_pid
, general_thread
), addr
, buffer
[i
]);
721 ptrace (PTRACE_POKETEXT): errno=%d, pid=0x%x, addr=0x%x, buffer[i] = 0x%x\n",
722 errno
, BUILDPID (inferior_pid
, general_thread
),
724 fprintf (stderr
, "Sleeping for 1 second\n");
736 initialize_low (void)