1 /* Low level Unix child interface to ptrace, for GDB when running under Unix.
2 Copyright 1988, 89, 90, 91, 92, 93, 94, 95, 96, 1998, 2001
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. */
26 #include "gdb_string.h"
34 #include <sys/types.h>
37 #include <sys/param.h>
38 #include "gdb_dirent.h"
40 #include <sys/ioctl.h>
45 #ifdef HAVE_SYS_PTRACE_H
46 #include <sys/ptrace.h>
50 #if !defined (PT_READ_I)
51 #define PT_READ_I 1 /* Read word from text space */
53 #if !defined (PT_READ_D)
54 #define PT_READ_D 2 /* Read word from data space */
56 #if !defined (PT_READ_U)
57 #define PT_READ_U 3 /* Read word from kernel user struct */
59 #if !defined (PT_WRITE_I)
60 #define PT_WRITE_I 4 /* Write word to text space */
62 #if !defined (PT_WRITE_D)
63 #define PT_WRITE_D 5 /* Write word to data space */
65 #if !defined (PT_WRITE_U)
66 #define PT_WRITE_U 6 /* Write word to kernel user struct */
68 #if !defined (PT_CONTINUE)
69 #define PT_CONTINUE 7 /* Continue after signal */
71 #if !defined (PT_STEP)
72 #define PT_STEP 9 /* Set flag for single stepping */
74 #if !defined (PT_KILL)
75 #define PT_KILL 8 /* Send child a SIGKILL signal */
79 #define PT_ATTACH PTRACE_ATTACH
82 #define PT_DETACH PTRACE_DETACH
90 /* Don't think this is used anymore. On the sequent (not sure whether it's
91 dynix or ptx or both), it is included unconditionally by sys/user.h and
92 not protected against multiple inclusion. */
96 #if !defined (FETCH_INFERIOR_REGISTERS)
97 #include <sys/user.h> /* Probably need to poke the user structure */
98 #if defined (KERNEL_U_ADDR_BSD)
99 #include <a.out.h> /* For struct nlist */
100 #endif /* KERNEL_U_ADDR_BSD. */
101 #endif /* !FETCH_INFERIOR_REGISTERS */
103 #if !defined (CHILD_XFER_MEMORY)
104 static void udot_info (char *, int);
107 #if !defined (FETCH_INFERIOR_REGISTERS)
108 static void fetch_register (int);
109 static void store_register (int);
113 * Some systems (Linux) may have threads implemented as pseudo-processes,
114 * in which case we may be tracing more than one process at a time.
115 * In that case, inferior_pid will contain the main process ID and the
116 * individual thread (process) id mashed together. These macros are
117 * used to separate them out. The definitions may be overridden in tm.h
119 * NOTE: default definitions here are for systems with no threads.
120 * Useful definitions MUST be provided in tm.h
123 #if !defined (PIDGET) /* Default definition for PIDGET/TIDGET. */
124 #define PIDGET(PID) PID
125 #define TIDGET(PID) 0
128 void _initialize_kernel_u_addr (void);
129 void _initialize_infptrace (void);
132 /* This function simply calls ptrace with the given arguments.
133 It exists so that all calls to ptrace are isolated in this
134 machine-dependent file. */
136 call_ptrace (int request
, int pid
, PTRACE_ARG3_TYPE addr
, int data
)
143 printf ("call_ptrace(request=%d, pid=%d, addr=0x%x, data=0x%x)",
144 request
, pid
, addr
, data
);
146 #if defined(PT_SETTRC)
147 /* If the parent can be told to attach to us, try to do it. */
148 if (request
== PT_SETTRC
)
151 #if !defined (FIVE_ARG_PTRACE)
152 pt_status
= ptrace (PT_SETTRC
, pid
, addr
, data
);
154 /* Deal with HPUX 8.0 braindamage. We never use the
155 calls which require the fifth argument. */
156 pt_status
= ptrace (PT_SETTRC
, pid
, addr
, data
, 0);
159 perror_with_name ("ptrace");
161 printf (" = %d\n", pt_status
);
166 return parent_attach_all (pid
, addr
, data
);
170 #if defined(PT_CONTIN1)
171 /* On HPUX, PT_CONTIN1 is a form of continue that preserves pending
172 signals. If it's available, use it. */
173 if (request
== PT_CONTINUE
)
174 request
= PT_CONTIN1
;
177 #if defined(PT_SINGLE1)
178 /* On HPUX, PT_SINGLE1 is a form of step that preserves pending
179 signals. If it's available, use it. */
180 if (request
== PT_STEP
)
181 request
= PT_SINGLE1
;
188 #if !defined (FIVE_ARG_PTRACE)
189 pt_status
= ptrace (request
, pid
, addr
, data
);
191 /* Deal with HPUX 8.0 braindamage. We never use the
192 calls which require the fifth argument. */
193 pt_status
= ptrace (request
, pid
, addr
, data
, 0);
198 printf (" [errno = %d]", errno
);
201 printf (" = 0x%x\n", pt_status
);
207 #if defined (DEBUG_PTRACE) || defined (FIVE_ARG_PTRACE)
208 /* For the rest of the file, use an extra level of indirection */
209 /* This lets us breakpoint usefully on call_ptrace. */
210 #define ptrace call_ptrace
213 /* Wait for a process to finish, possibly running a target-specific
214 hook before returning. */
217 ptrace_wait (int pid
, int *status
)
221 wstate
= wait (status
);
222 target_post_wait (wstate
, *status
);
231 if (inferior_pid
== 0)
234 /* This once used to call "kill" to kill the inferior just in case
235 the inferior was still running. As others have noted in the past
236 (kingdon) there shouldn't be any way to get here if the inferior
237 is still running -- else there's a major problem elsewere in gdb
238 and it needs to be fixed.
240 The kill call causes problems under hpux10, so it's been removed;
241 if this causes problems we'll deal with them as they arise. */
242 ptrace (PT_KILL
, inferior_pid
, (PTRACE_ARG3_TYPE
) 0, 0);
243 ptrace_wait (0, &status
);
244 target_mourn_inferior ();
249 /* Resume execution of the inferior process.
250 If STEP is nonzero, single-step it.
251 If SIGNAL is nonzero, give it that signal. */
254 child_resume (int pid
, int step
, enum target_signal signal
)
259 /* Resume all threads. */
260 /* I think this only gets used in the non-threaded case, where "resume
261 all threads" and "resume inferior_pid" are the same. */
264 /* An address of (PTRACE_ARG3_TYPE)1 tells ptrace to continue from where
265 it was. (If GDB wanted it to start some other way, we have already
266 written a new PC value to the child.)
268 If this system does not support PT_STEP, a higher level function will
269 have called single_step() to transmute the step request into a
270 continue request (by setting breakpoints on all possible successor
271 instructions), so we don't have to worry about that here. */
275 if (SOFTWARE_SINGLE_STEP_P
)
276 internal_error (__FILE__
, __LINE__
, "failed internal consistency check"); /* Make sure this doesn't happen. */
278 ptrace (PT_STEP
, pid
, (PTRACE_ARG3_TYPE
) 1,
279 target_signal_to_host (signal
));
282 ptrace (PT_CONTINUE
, pid
, (PTRACE_ARG3_TYPE
) 1,
283 target_signal_to_host (signal
));
287 perror_with_name ("ptrace");
290 #endif /* CHILD_RESUME */
294 /* Start debugging the process whose number is PID. */
299 ptrace (PT_ATTACH
, pid
, (PTRACE_ARG3_TYPE
) 0, 0);
301 perror_with_name ("ptrace");
306 /* Stop debugging the process whose number is PID
307 and continue it with signal number SIGNAL.
308 SIGNAL = 0 means just continue it. */
314 ptrace (PT_DETACH
, inferior_pid
, (PTRACE_ARG3_TYPE
) 1, signal
);
316 perror_with_name ("ptrace");
319 #endif /* ATTACH_DETACH */
321 /* Default the type of the ptrace transfer to int. */
322 #ifndef PTRACE_XFER_TYPE
323 #define PTRACE_XFER_TYPE int
326 /* KERNEL_U_ADDR is the amount to subtract from u.u_ar0
327 to get the offset in the core file of the register values. */
328 #if defined (KERNEL_U_ADDR_BSD) && !defined (FETCH_INFERIOR_REGISTERS)
329 /* Get kernel_u_addr using BSD-style nlist(). */
330 CORE_ADDR kernel_u_addr
;
331 #endif /* KERNEL_U_ADDR_BSD. */
334 _initialize_kernel_u_addr (void)
336 #if defined (KERNEL_U_ADDR_BSD) && !defined (FETCH_INFERIOR_REGISTERS)
337 struct nlist names
[2];
339 names
[0].n_un
.n_name
= "_u";
340 names
[1].n_un
.n_name
= NULL
;
341 if (nlist ("/vmunix", names
) == 0)
342 kernel_u_addr
= names
[0].n_value
;
344 internal_error (__FILE__
, __LINE__
,
345 "Unable to get kernel u area address.");
346 #endif /* KERNEL_U_ADDR_BSD. */
349 #if !defined (FETCH_INFERIOR_REGISTERS)
351 #if !defined (offsetof)
352 #define offsetof(TYPE, MEMBER) ((unsigned long) &((TYPE *)0)->MEMBER)
355 /* U_REGS_OFFSET is the offset of the registers within the u area. */
356 #if !defined (U_REGS_OFFSET)
357 #define U_REGS_OFFSET \
358 ptrace (PT_READ_U, inferior_pid, \
359 (PTRACE_ARG3_TYPE) (offsetof (struct user, u_ar0)), 0) \
363 /* Registers we shouldn't try to fetch. */
364 #if !defined (CANNOT_FETCH_REGISTER)
365 #define CANNOT_FETCH_REGISTER(regno) 0
368 /* Fetch one register. */
371 fetch_register (int regno
)
373 /* This isn't really an address. But ptrace thinks of it as one. */
375 char mess
[128]; /* For messages */
377 unsigned int offset
; /* Offset of registers within the u area. */
378 char buf
[MAX_REGISTER_RAW_SIZE
];
381 if (CANNOT_FETCH_REGISTER (regno
))
383 memset (buf
, '\0', REGISTER_RAW_SIZE (regno
)); /* Supply zeroes */
384 supply_register (regno
, buf
);
388 /* Overload thread id onto process id */
389 if ((tid
= TIDGET (inferior_pid
)) == 0)
390 tid
= inferior_pid
; /* no thread id, just use process id */
392 offset
= U_REGS_OFFSET
;
394 regaddr
= register_addr (regno
, offset
);
395 for (i
= 0; i
< REGISTER_RAW_SIZE (regno
); i
+= sizeof (PTRACE_XFER_TYPE
))
398 *(PTRACE_XFER_TYPE
*) & buf
[i
] = ptrace (PT_READ_U
, tid
,
399 (PTRACE_ARG3_TYPE
) regaddr
, 0);
400 regaddr
+= sizeof (PTRACE_XFER_TYPE
);
403 sprintf (mess
, "reading register %s (#%d)",
404 REGISTER_NAME (regno
), regno
);
405 perror_with_name (mess
);
408 supply_register (regno
, buf
);
412 /* Fetch register values from the inferior.
413 If REGNO is negative, do this for all registers.
414 Otherwise, REGNO specifies which register (so we can save time). */
417 fetch_inferior_registers (int regno
)
421 fetch_register (regno
);
425 for (regno
= 0; regno
< ARCH_NUM_REGS
; regno
++)
427 fetch_register (regno
);
432 /* Registers we shouldn't try to store. */
433 #if !defined (CANNOT_STORE_REGISTER)
434 #define CANNOT_STORE_REGISTER(regno) 0
437 /* Store one register. */
440 store_register (int regno
)
442 /* This isn't really an address. But ptrace thinks of it as one. */
444 char mess
[128]; /* For messages */
446 unsigned int offset
; /* Offset of registers within the u area. */
449 if (CANNOT_STORE_REGISTER (regno
))
454 /* Overload thread id onto process id */
455 if ((tid
= TIDGET (inferior_pid
)) == 0)
456 tid
= inferior_pid
; /* no thread id, just use process id */
458 offset
= U_REGS_OFFSET
;
460 regaddr
= register_addr (regno
, offset
);
461 for (i
= 0; i
< REGISTER_RAW_SIZE (regno
); i
+= sizeof (PTRACE_XFER_TYPE
))
464 ptrace (PT_WRITE_U
, tid
, (PTRACE_ARG3_TYPE
) regaddr
,
465 *(PTRACE_XFER_TYPE
*) & registers
[REGISTER_BYTE (regno
) + i
]);
466 regaddr
+= sizeof (PTRACE_XFER_TYPE
);
469 sprintf (mess
, "writing register %s (#%d)",
470 REGISTER_NAME (regno
), regno
);
471 perror_with_name (mess
);
476 /* Store our register values back into the inferior.
477 If REGNO is negative, do this for all registers.
478 Otherwise, REGNO specifies which register (so we can save time). */
481 store_inferior_registers (int regno
)
485 store_register (regno
);
489 for (regno
= 0; regno
< ARCH_NUM_REGS
; regno
++)
491 store_register (regno
);
495 #endif /* !defined (FETCH_INFERIOR_REGISTERS). */
498 #if !defined (CHILD_XFER_MEMORY)
499 /* NOTE! I tried using PTRACE_READDATA, etc., to read and write memory
500 in the NEW_SUN_PTRACE case.
501 It ought to be straightforward. But it appears that writing did
502 not write the data that I specified. I cannot understand where
503 it got the data that it actually did write. */
505 /* Copy LEN bytes to or from inferior's memory starting at MEMADDR
506 to debugger memory starting at MYADDR. Copy to inferior if
507 WRITE is nonzero. TARGET is ignored.
509 Returns the length copied, which is either the LEN argument or zero.
510 This xfer function does not do partial moves, since child_ops
511 doesn't allow memory operations to cross below us in the target stack
515 child_xfer_memory (CORE_ADDR memaddr
, char *myaddr
, int len
, int write
,
516 struct mem_attrib
*attrib ATTRIBUTE_UNUSED
,
517 struct target_ops
*target
)
520 /* Round starting address down to longword boundary. */
521 register CORE_ADDR addr
= memaddr
& -sizeof (PTRACE_XFER_TYPE
);
522 /* Round ending address up; get number of longwords that makes. */
524 = (((memaddr
+ len
) - addr
) + sizeof (PTRACE_XFER_TYPE
) - 1)
525 / sizeof (PTRACE_XFER_TYPE
);
526 /* Allocate buffer of that many longwords. */
527 register PTRACE_XFER_TYPE
*buffer
528 = (PTRACE_XFER_TYPE
*) alloca (count
* sizeof (PTRACE_XFER_TYPE
));
532 /* Fill start and end extra bytes of buffer with existing memory data. */
534 if (addr
!= memaddr
|| len
< (int) sizeof (PTRACE_XFER_TYPE
))
536 /* Need part of initial word -- fetch it. */
537 buffer
[0] = ptrace (PT_READ_I
, PIDGET (inferior_pid
),
538 (PTRACE_ARG3_TYPE
) addr
, 0);
541 if (count
> 1) /* FIXME, avoid if even boundary */
544 = ptrace (PT_READ_I
, PIDGET (inferior_pid
),
546 (addr
+ (count
- 1) * sizeof (PTRACE_XFER_TYPE
))),
550 /* Copy data to be written over corresponding part of buffer */
552 memcpy ((char *) buffer
+ (memaddr
& (sizeof (PTRACE_XFER_TYPE
) - 1)),
556 /* Write the entire buffer. */
558 for (i
= 0; i
< count
; i
++, addr
+= sizeof (PTRACE_XFER_TYPE
))
561 ptrace (PT_WRITE_D
, PIDGET (inferior_pid
),
562 (PTRACE_ARG3_TYPE
) addr
, buffer
[i
]);
565 /* Using the appropriate one (I or D) is necessary for
566 Gould NP1, at least. */
568 ptrace (PT_WRITE_I
, PIDGET (inferior_pid
),
569 (PTRACE_ARG3_TYPE
) addr
, buffer
[i
]);
574 #ifdef CLEAR_INSN_CACHE
580 /* Read all the longwords */
581 for (i
= 0; i
< count
; i
++, addr
+= sizeof (PTRACE_XFER_TYPE
))
584 buffer
[i
] = ptrace (PT_READ_I
, PIDGET (inferior_pid
),
585 (PTRACE_ARG3_TYPE
) addr
, 0);
591 /* Copy appropriate bytes out of the buffer. */
593 (char *) buffer
+ (memaddr
& (sizeof (PTRACE_XFER_TYPE
) - 1)),
601 udot_info (char *dummy1
, int dummy2
)
603 #if defined (KERNEL_U_SIZE)
604 int udot_off
; /* Offset into user struct */
605 int udot_val
; /* Value from user struct at udot_off */
606 char mess
[128]; /* For messages */
609 if (!target_has_execution
)
611 error ("The program is not being run.");
614 #if !defined (KERNEL_U_SIZE)
616 /* Adding support for this command is easy. Typically you just add a
617 routine, called "kernel_u_size" that returns the size of the user
618 struct, to the appropriate *-nat.c file and then add to the native
619 config file "#define KERNEL_U_SIZE kernel_u_size()" */
620 error ("Don't know how large ``struct user'' is in this version of gdb.");
624 for (udot_off
= 0; udot_off
< KERNEL_U_SIZE
; udot_off
+= sizeof (udot_val
))
626 if ((udot_off
% 24) == 0)
630 printf_filtered ("\n");
632 printf_filtered ("%04x:", udot_off
);
634 udot_val
= ptrace (PT_READ_U
, inferior_pid
, (PTRACE_ARG3_TYPE
) udot_off
, 0);
637 sprintf (mess
, "\nreading user struct at offset 0x%x", udot_off
);
638 perror_with_name (mess
);
640 /* Avoid using nonportable (?) "*" in print specs */
641 printf_filtered (sizeof (int) == 4 ? " 0x%08x" : " 0x%16x", udot_val
);
643 printf_filtered ("\n");
647 #endif /* !defined (CHILD_XFER_MEMORY). */
651 _initialize_infptrace (void)
653 #if !defined (CHILD_XFER_MEMORY)
654 add_info ("udot", udot_info
,
655 "Print contents of kernel ``struct user'' for current child.");