1 /* Low level interface to ptrace, for the remote server for GDB.
2 Copyright 1986, 1987, 1993, 1994, 1995, 1999, 2000, 2001, 2002
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 /* Attaching is not supported. */
97 /* Kill the inferior process. Make us have no inferior. */
102 if (inferior_pid
== 0)
104 ptrace (PTRACE_KILL
, inferior_pid
, 0, 0);
110 /* Return nonzero if the given thread is still alive. */
112 mythread_alive (int pid
)
114 /* Arggh. Apparently pthread_kill only works for threads within
115 the process that calls pthread_kill.
117 We want to avoid the lynx signal extensions as they simply don't
118 map well to the generic gdb interface we want to keep.
120 All we want to do is determine if a particular thread is alive;
121 it appears as if we can just make a harmless thread specific
122 ptrace call to do that. */
123 return (ptrace (PTRACE_THREADUSER
,
124 BUILDPID (PIDGET (inferior_pid
), pid
), 0, 0) != -1);
127 /* Wait for process, returns status */
130 mywait (char *status
)
143 if (pid
!= PIDGET (inferior_pid
))
144 perror_with_name ("wait");
146 thread_from_wait
= w
.w_tid
;
147 inferior_pid
= BUILDPID (inferior_pid
, w
.w_tid
);
150 && WSTOPSIG (w
) == SIGTRAP
)
154 realsig
= ptrace (PTRACE_GETTRACESIG
, inferior_pid
,
155 (PTRACE_ARG3_TYPE
) 0, 0);
157 if (realsig
== SIGNEWTHREAD
)
159 /* It's a new thread notification. Nothing to do here since
160 the machine independent code in wait_for_inferior will
161 add the thread to the thread list and restart the thread
162 when pid != inferior_pid and pid is not in the thread list.
163 We don't even want to muck with realsig -- the code in
164 wait_for_inferior expects SIGTRAP. */
174 return ((unsigned char) WEXITSTATUS (w
));
176 else if (!WIFSTOPPED (w
))
179 return ((unsigned char) WTERMSIG (w
));
182 fetch_inferior_registers (0);
185 return ((unsigned char) WSTOPSIG (w
));
188 /* Resume execution of the inferior process.
189 If STEP is nonzero, single-step it.
190 If SIGNAL is nonzero, give it that signal. */
193 myresume (int step
, int signal
)
196 ptrace (step
? PTRACE_SINGLESTEP_ONE
: PTRACE_CONT
,
197 BUILDPID (inferior_pid
, cont_thread
== -1 ? 0 : cont_thread
),
200 perror_with_name ("ptrace");
204 #define offsetof(TYPE, MEMBER) ((unsigned long) &((TYPE *)0)->MEMBER)
206 /* Mapping between GDB register #s and offsets into econtext. Must be
207 consistent with REGISTER_NAMES macro in various tmXXX.h files. */
209 #define X(ENTRY)(offsetof(struct econtext, ENTRY))
212 /* Mappings from tm-i386v.h */
214 static int regmap
[] =
230 X (ecode
), /* Lynx doesn't give us either fs or gs, so */
231 X (fault
), /* we just substitute these two in the hopes
232 that they are useful. */
237 /* Mappings from tm-m68k.h */
239 static int regmap
[] =
241 X (regs
[0]), /* d0 */
242 X (regs
[1]), /* d1 */
243 X (regs
[2]), /* d2 */
244 X (regs
[3]), /* d3 */
245 X (regs
[4]), /* d4 */
246 X (regs
[5]), /* d5 */
247 X (regs
[6]), /* d6 */
248 X (regs
[7]), /* d7 */
249 X (regs
[8]), /* a0 */
250 X (regs
[9]), /* a1 */
251 X (regs
[10]), /* a2 */
252 X (regs
[11]), /* a3 */
253 X (regs
[12]), /* a4 */
254 X (regs
[13]), /* a5 */
255 X (regs
[14]), /* fp */
260 X (fregs
[0 * 3]), /* fp0 */
261 X (fregs
[1 * 3]), /* fp1 */
262 X (fregs
[2 * 3]), /* fp2 */
263 X (fregs
[3 * 3]), /* fp3 */
264 X (fregs
[4 * 3]), /* fp4 */
265 X (fregs
[5 * 3]), /* fp5 */
266 X (fregs
[6 * 3]), /* fp6 */
267 X (fregs
[7 * 3]), /* fp7 */
269 X (fcregs
[0]), /* fpcontrol */
270 X (fcregs
[1]), /* fpstatus */
271 X (fcregs
[2]), /* fpiaddr */
272 X (ssw
), /* fpcode */
273 X (fault
), /* fpflags */
278 /* Mappings from tm-sparc.h */
280 #define FX(ENTRY)(offsetof(struct fcontext, ENTRY))
282 static int regmap
[] =
289 -1, /* g5->g7 aren't saved by Lynx */
302 -1, -1, -1, -1, -1, -1, -1, -1, /* l0 -> l7 */
304 -1, -1, -1, -1, -1, -1, -1, -1, /* i0 -> i7 */
306 FX (f
.fregs
[0]), /* f0 */
352 /* This routine handles some oddball cases for Sparc registers and LynxOS.
353 In partucular, it causes refs to G0, g5->7, and all fp regs to return zero.
354 It also handles knows where to find the I & L regs on the stack. */
357 fetch_inferior_registers (int regno
)
362 #define WHATREGS_FLOAT 1
363 #define WHATREGS_GEN 2
364 #define WHATREGS_STACK 4
367 whatregs
= WHATREGS_FLOAT
| WHATREGS_GEN
| WHATREGS_STACK
;
368 else if (regno
>= L0_REGNUM
&& regno
<= I7_REGNUM
)
369 whatregs
= WHATREGS_STACK
;
370 else if (regno
>= FP0_REGNUM
&& regno
< FP0_REGNUM
+ 32)
371 whatregs
= WHATREGS_FLOAT
;
373 whatregs
= WHATREGS_GEN
;
375 if (whatregs
& WHATREGS_GEN
)
377 struct econtext ec
; /* general regs */
378 char buf
[MAX_REGISTER_RAW_SIZE
];
383 retval
= ptrace (PTRACE_GETREGS
,
384 BUILDPID (inferior_pid
, general_thread
),
385 (PTRACE_ARG3_TYPE
) & ec
,
388 perror_with_name ("Sparc fetch_inferior_registers(ptrace)");
390 memset (buf
, 0, REGISTER_RAW_SIZE (G0_REGNUM
));
391 supply_register (G0_REGNUM
, buf
);
392 supply_register (TBR_REGNUM
, (char *) &ec
.tbr
);
394 memcpy (®isters
[REGISTER_BYTE (G1_REGNUM
)], &ec
.g1
,
395 4 * REGISTER_RAW_SIZE (G1_REGNUM
));
396 for (i
= G1_REGNUM
; i
<= G1_REGNUM
+ 3; i
++)
397 register_valid
[i
] = 1;
399 supply_register (PS_REGNUM
, (char *) &ec
.psr
);
400 supply_register (Y_REGNUM
, (char *) &ec
.y
);
401 supply_register (PC_REGNUM
, (char *) &ec
.pc
);
402 supply_register (NPC_REGNUM
, (char *) &ec
.npc
);
403 supply_register (WIM_REGNUM
, (char *) &ec
.wim
);
405 memcpy (®isters
[REGISTER_BYTE (O0_REGNUM
)], ec
.o
,
406 8 * REGISTER_RAW_SIZE (O0_REGNUM
));
407 for (i
= O0_REGNUM
; i
<= O0_REGNUM
+ 7; i
++)
408 register_valid
[i
] = 1;
411 if (whatregs
& WHATREGS_STACK
)
416 sp
= read_register (SP_REGNUM
);
418 target_xfer_memory (sp
+ FRAME_SAVED_I0
,
419 ®isters
[REGISTER_BYTE (I0_REGNUM
)],
420 8 * REGISTER_RAW_SIZE (I0_REGNUM
), 0);
421 for (i
= I0_REGNUM
; i
<= I7_REGNUM
; i
++)
422 register_valid
[i
] = 1;
424 target_xfer_memory (sp
+ FRAME_SAVED_L0
,
425 ®isters
[REGISTER_BYTE (L0_REGNUM
)],
426 8 * REGISTER_RAW_SIZE (L0_REGNUM
), 0);
427 for (i
= L0_REGNUM
; i
<= L0_REGNUM
+ 7; i
++)
428 register_valid
[i
] = 1;
431 if (whatregs
& WHATREGS_FLOAT
)
433 struct fcontext fc
; /* fp regs */
438 retval
= ptrace (PTRACE_GETFPREGS
, BUILDPID (inferior_pid
, general_thread
), (PTRACE_ARG3_TYPE
) & fc
,
441 perror_with_name ("Sparc fetch_inferior_registers(ptrace)");
443 memcpy (®isters
[REGISTER_BYTE (FP0_REGNUM
)], fc
.f
.fregs
,
444 32 * REGISTER_RAW_SIZE (FP0_REGNUM
));
445 for (i
= FP0_REGNUM
; i
<= FP0_REGNUM
+ 31; i
++)
446 register_valid
[i
] = 1;
448 supply_register (FPS_REGNUM
, (char *) &fc
.fsr
);
453 /* This routine handles storing of the I & L regs for the Sparc. The trick
454 here is that they actually live on the stack. The really tricky part is
455 that when changing the stack pointer, the I & L regs must be written to
456 where the new SP points, otherwise the regs will be incorrect when the
457 process is started up again. We assume that the I & L regs are valid at
461 store_inferior_registers (int regno
)
467 whatregs
= WHATREGS_FLOAT
| WHATREGS_GEN
| WHATREGS_STACK
;
468 else if (regno
>= L0_REGNUM
&& regno
<= I7_REGNUM
)
469 whatregs
= WHATREGS_STACK
;
470 else if (regno
>= FP0_REGNUM
&& regno
< FP0_REGNUM
+ 32)
471 whatregs
= WHATREGS_FLOAT
;
472 else if (regno
== SP_REGNUM
)
473 whatregs
= WHATREGS_STACK
| WHATREGS_GEN
;
475 whatregs
= WHATREGS_GEN
;
477 if (whatregs
& WHATREGS_GEN
)
479 struct econtext ec
; /* general regs */
482 ec
.tbr
= read_register (TBR_REGNUM
);
483 memcpy (&ec
.g1
, ®isters
[REGISTER_BYTE (G1_REGNUM
)],
484 4 * REGISTER_RAW_SIZE (G1_REGNUM
));
486 ec
.psr
= read_register (PS_REGNUM
);
487 ec
.y
= read_register (Y_REGNUM
);
488 ec
.pc
= read_register (PC_REGNUM
);
489 ec
.npc
= read_register (NPC_REGNUM
);
490 ec
.wim
= read_register (WIM_REGNUM
);
492 memcpy (ec
.o
, ®isters
[REGISTER_BYTE (O0_REGNUM
)],
493 8 * REGISTER_RAW_SIZE (O0_REGNUM
));
496 retval
= ptrace (PTRACE_SETREGS
, BUILDPID (inferior_pid
, general_thread
), (PTRACE_ARG3_TYPE
) & ec
,
499 perror_with_name ("Sparc fetch_inferior_registers(ptrace)");
502 if (whatregs
& WHATREGS_STACK
)
507 sp
= read_register (SP_REGNUM
);
509 if (regno
== -1 || regno
== SP_REGNUM
)
511 if (!register_valid
[L0_REGNUM
+ 5])
513 target_xfer_memory (sp
+ FRAME_SAVED_I0
,
514 ®isters
[REGISTER_BYTE (I0_REGNUM
)],
515 8 * REGISTER_RAW_SIZE (I0_REGNUM
), 1);
517 target_xfer_memory (sp
+ FRAME_SAVED_L0
,
518 ®isters
[REGISTER_BYTE (L0_REGNUM
)],
519 8 * REGISTER_RAW_SIZE (L0_REGNUM
), 1);
521 else if (regno
>= L0_REGNUM
&& regno
<= I7_REGNUM
)
523 if (!register_valid
[regno
])
525 if (regno
>= L0_REGNUM
&& regno
<= L0_REGNUM
+ 7)
526 regoffset
= REGISTER_BYTE (regno
) - REGISTER_BYTE (L0_REGNUM
)
529 regoffset
= REGISTER_BYTE (regno
) - REGISTER_BYTE (I0_REGNUM
)
531 target_xfer_memory (sp
+ regoffset
, ®isters
[REGISTER_BYTE (regno
)],
532 REGISTER_RAW_SIZE (regno
), 1);
536 if (whatregs
& WHATREGS_FLOAT
)
538 struct fcontext fc
; /* fp regs */
541 /* We read fcontext first so that we can get good values for fq_t... */
543 retval
= ptrace (PTRACE_GETFPREGS
, BUILDPID (inferior_pid
, general_thread
), (PTRACE_ARG3_TYPE
) & fc
,
546 perror_with_name ("Sparc fetch_inferior_registers(ptrace)");
548 memcpy (fc
.f
.fregs
, ®isters
[REGISTER_BYTE (FP0_REGNUM
)],
549 32 * REGISTER_RAW_SIZE (FP0_REGNUM
));
551 fc
.fsr
= read_register (FPS_REGNUM
);
554 retval
= ptrace (PTRACE_SETFPREGS
, BUILDPID (inferior_pid
, general_thread
), (PTRACE_ARG3_TYPE
) & fc
,
557 perror_with_name ("Sparc fetch_inferior_registers(ptrace)");
565 /* Return the offset relative to the start of the per-thread data to the
566 saved context block. */
569 lynx_registers_addr (void)
572 int ecpoff
= offsetof (st_t
, ecp
);
576 stblock
= (CORE_ADDR
) ptrace (PTRACE_THREADUSER
, BUILDPID (inferior_pid
, general_thread
),
577 (PTRACE_ARG3_TYPE
) 0, 0);
579 perror_with_name ("PTRACE_THREADUSER");
581 ecp
= (CORE_ADDR
) ptrace (PTRACE_PEEKTHREAD
, BUILDPID (inferior_pid
, general_thread
),
582 (PTRACE_ARG3_TYPE
) ecpoff
, 0);
584 perror_with_name ("lynx_registers_addr(PTRACE_PEEKTHREAD)");
586 return ecp
- stblock
;
589 /* Fetch one or more registers from the inferior. REGNO == -1 to get
590 them all. We actually fetch more than requested, when convenient,
591 marking them as valid so we won't fetch them again. */
594 fetch_inferior_registers (int ignored
)
600 ecp
= lynx_registers_addr ();
602 for (regno
= 0; regno
< NUM_REGS
; regno
++)
604 int ptrace_fun
= PTRACE_PEEKTHREAD
;
606 #ifdef PTRACE_PEEKUSP
607 ptrace_fun
= regno
== SP_REGNUM
? PTRACE_PEEKUSP
: PTRACE_PEEKTHREAD
;
611 reg
= ptrace (ptrace_fun
, BUILDPID (inferior_pid
, general_thread
),
612 (PTRACE_ARG3_TYPE
) (ecp
+ regmap
[regno
]), 0);
614 perror_with_name ("fetch_inferior_registers(PTRACE_PEEKTHREAD)");
616 *(unsigned long *) ®isters
[REGISTER_BYTE (regno
)] = reg
;
620 /* Store our register values back into the inferior.
621 If REGNO is -1, do this for all registers.
622 Otherwise, REGNO specifies which register (so we can save time). */
625 store_inferior_registers (int 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 (CORE_ADDR memaddr
, char *myaddr
, int len
)
666 /* Round starting address down to longword boundary. */
667 register CORE_ADDR addr
= memaddr
& -(CORE_ADDR
) sizeof (int);
668 /* Round ending address up; get number of longwords that makes. */
670 = (((memaddr
+ len
) - addr
) + sizeof (int) - 1) / sizeof (int);
671 /* Allocate buffer of that many longwords. */
672 register int *buffer
= (int *) alloca (count
* sizeof (int));
674 /* Read all the longwords */
675 for (i
= 0; i
< count
; i
++, addr
+= sizeof (int))
677 buffer
[i
] = ptrace (PTRACE_PEEKTEXT
, BUILDPID (inferior_pid
, general_thread
), addr
, 0);
680 /* Copy appropriate bytes out of the buffer. */
681 memcpy (myaddr
, (char *) buffer
+ (memaddr
& (sizeof (int) - 1)), len
);
684 /* Copy LEN bytes of data from debugger memory at MYADDR
685 to inferior's memory at MEMADDR.
686 On failure (cannot write the inferior)
687 returns the value of errno. */
690 write_inferior_memory (CORE_ADDR memaddr
, char *myaddr
, int len
)
693 /* Round starting address down to longword boundary. */
694 register CORE_ADDR addr
= memaddr
& -(CORE_ADDR
) sizeof (int);
695 /* Round ending address up; get number of longwords that makes. */
697 = (((memaddr
+ len
) - addr
) + sizeof (int) - 1) / sizeof (int);
698 /* Allocate buffer of that many longwords. */
699 register int *buffer
= (int *) alloca (count
* sizeof (int));
702 /* Fill start and end extra bytes of buffer with existing memory data. */
704 buffer
[0] = ptrace (PTRACE_PEEKTEXT
, BUILDPID (inferior_pid
, general_thread
), addr
, 0);
709 = ptrace (PTRACE_PEEKTEXT
, BUILDPID (inferior_pid
, general_thread
),
710 addr
+ (count
- 1) * sizeof (int), 0);
713 /* Copy data to be written over corresponding part of buffer */
715 memcpy ((char *) buffer
+ (memaddr
& (sizeof (int) - 1)), myaddr
, len
);
717 /* Write the entire buffer. */
719 for (i
= 0; i
< count
; i
++, addr
+= sizeof (int))
724 ptrace (PTRACE_POKETEXT
, BUILDPID (inferior_pid
, general_thread
), addr
, buffer
[i
]);
728 ptrace (PTRACE_POKETEXT): errno=%d, pid=0x%x, addr=0x%x, buffer[i] = 0x%x\n",
729 errno
, BUILDPID (inferior_pid
, general_thread
),
731 fprintf (stderr
, "Sleeping for 1 second\n");
743 initialize_low (void)