1 /* Low level Unix child interface to ptrace, for GDB when running under Unix.
2 Copyright 1988, 1989, 1990, 1991, 1992, 1993, 1994, 1995, 1996,
3 1998, 1999, 2000, 2001, 2002, 2004
4 Free Software Foundation, Inc.
6 This file is part of GDB.
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 2 of the License, or
11 (at your option) any later version.
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.
18 You should have received a copy of the GNU General Public License
19 along with this program; if not, write to the Free Software
20 Foundation, Inc., 59 Temple Place - Suite 330,
21 Boston, MA 02111-1307, USA. */
31 #include "gdb_assert.h"
33 #include "gdb_string.h"
35 #include <sys/param.h>
36 #include "gdb_dirent.h"
38 #include <sys/ioctl.h>
40 #include "gdb_ptrace.h"
42 #ifdef HAVE_SYS_FILE_H
46 #if !defined (FETCH_INFERIOR_REGISTERS)
47 #include <sys/user.h> /* Probably need to poke the user structure */
48 #endif /* !FETCH_INFERIOR_REGISTERS */
50 #if !defined (CHILD_XFER_MEMORY)
51 static void udot_info (char *, int);
54 void _initialize_infptrace (void);
57 /* This function simply calls ptrace with the given arguments.
58 It exists so that all calls to ptrace are isolated in this
59 machine-dependent file. */
61 call_ptrace (int request
, int pid
, PTRACE_ARG3_TYPE addr
, int data
)
68 printf ("call_ptrace(request=%d, pid=%d, addr=0x%x, data=0x%x)",
69 request
, pid
, addr
, data
);
71 #if defined(PT_SETTRC)
72 /* If the parent can be told to attach to us, try to do it. */
73 if (request
== PT_SETTRC
)
76 #ifndef PTRACE_TYPE_ARG5
77 pt_status
= ptrace (PT_SETTRC
, pid
, addr
, data
);
79 /* Deal with HPUX 8.0 braindamage. We never use the
80 calls which require the fifth argument. */
81 pt_status
= ptrace (PT_SETTRC
, pid
, addr
, data
, 0);
84 perror_with_name ("ptrace");
86 printf (" = %d\n", pt_status
);
91 return parent_attach_all (pid
, addr
, data
);
95 #if defined(PT_CONTIN1)
96 /* On HPUX, PT_CONTIN1 is a form of continue that preserves pending
97 signals. If it's available, use it. */
98 if (request
== PT_CONTINUE
)
102 #if defined(PT_SINGLE1)
103 /* On HPUX, PT_SINGLE1 is a form of step that preserves pending
104 signals. If it's available, use it. */
105 if (request
== PT_STEP
)
106 request
= PT_SINGLE1
;
113 #ifndef PTRACE_TYPE_ARG5
114 pt_status
= ptrace (request
, pid
, addr
, data
);
116 /* Deal with HPUX 8.0 braindamage. We never use the
117 calls which require the fifth argument. */
118 pt_status
= ptrace (request
, pid
, addr
, data
, 0);
123 printf (" [errno = %d]", errno
);
126 printf (" = 0x%x\n", pt_status
);
132 #if defined (DEBUG_PTRACE) || defined (PTRACE_TYPE_ARG5)
133 /* For the rest of the file, use an extra level of indirection */
134 /* This lets us breakpoint usefully on call_ptrace. */
135 #define ptrace call_ptrace
138 /* Wait for a process to finish, possibly running a target-specific
139 hook before returning. */
141 /* NOTE: cagney: 2004-09-29: Dependant on the native configuration,
142 "hppah-nat.c" may either call this or infttrace.c's implementation
143 of ptrace_wait. See "hppahpux.mh". */
146 ptrace_wait (ptid_t ptid
, int *status
)
150 wstate
= wait (status
);
154 #ifndef DEPRECATED_KILL_INFERIOR
155 /* NOTE: cagney/2004-09-12: Instead of definining this macro, code
156 should call inf_ptrace_target to get a basic ptrace target and then
157 locally update any necessary methods. See ppcnbsd-nat.c. */
163 int pid
= PIDGET (inferior_ptid
);
168 /* This once used to call "kill" to kill the inferior just in case
169 the inferior was still running. As others have noted in the past
170 (kingdon) there shouldn't be any way to get here if the inferior
171 is still running -- else there's a major problem elsewere in gdb
172 and it needs to be fixed.
174 The kill call causes problems under hpux10, so it's been removed;
175 if this causes problems we'll deal with them as they arise. */
176 ptrace (PT_KILL
, pid
, (PTRACE_TYPE_ARG3
) 0, 0);
178 target_mourn_inferior ();
180 #endif /* DEPRECATED_KILL_INFERIOR */
182 #ifndef DEPRECATED_CHILD_RESUME
183 /* NOTE: cagney/2004-09-12: Instead of definining this macro, code
184 should call inf_ptrace_target to get a basic ptrace target and then
185 locally update any necessary methods. See ppcnbsd-nat.c. */
187 /* Resume execution of the inferior process.
188 If STEP is nonzero, single-step it.
189 If SIGNAL is nonzero, give it that signal. */
192 child_resume (ptid_t ptid
, int step
, enum target_signal signal
)
194 int request
= PT_CONTINUE
;
195 int pid
= PIDGET (ptid
);
198 /* Resume all threads. */
199 /* I think this only gets used in the non-threaded case, where "resume
200 all threads" and "resume inferior_ptid" are the same. */
201 pid
= PIDGET (inferior_ptid
);
205 /* If this system does not support PT_STEP, a higher level
206 function will have called single_step() to transmute the step
207 request into a continue request (by setting breakpoints on
208 all possible successor instructions), so we don't have to
209 worry about that here. */
211 gdb_assert (!SOFTWARE_SINGLE_STEP_P ());
215 /* An address of (PTRACE_TYPE_ARG3)1 tells ptrace to continue from
216 where it was. If GDB wanted it to start some other way, we have
217 already written a new PC value to the child. */
220 ptrace (request
, pid
, (PTRACE_TYPE_ARG3
)1, target_signal_to_host (signal
));
222 perror_with_name ("ptrace");
224 #endif /* DEPRECATED_CHILD_RESUME */
227 /* Start debugging the process whose number is PID. */
234 ptrace (PT_ATTACH
, pid
, (PTRACE_TYPE_ARG3
) 0, 0);
236 perror_with_name ("ptrace");
240 error ("This system does not support attaching to a process");
244 /* Stop debugging the process whose number is PID and continue it with
245 signal number SIGNAL. SIGNAL = 0 means just continue it. */
251 int pid
= PIDGET (inferior_ptid
);
254 ptrace (PT_DETACH
, pid
, (PTRACE_TYPE_ARG3
) 1, signal
);
256 perror_with_name ("ptrace");
259 error ("This system does not support detaching from a process");
264 #ifndef FETCH_INFERIOR_REGISTERS
266 /* U_REGS_OFFSET is the offset of the registers within the u area. */
267 #ifndef U_REGS_OFFSET
270 #define offsetof(TYPE, MEMBER) ((unsigned long) &((TYPE *)0)->MEMBER)
273 #define U_REGS_OFFSET \
274 ptrace (PT_READ_U, PIDGET (inferior_ptid), \
275 (PTRACE_TYPE_ARG3) (offsetof (struct user, u_ar0)), 0) \
279 /* Fetch register REGNUM from the inferior. */
282 fetch_register (int regnum
)
286 PTRACE_TYPE_RET
*buf
;
289 if (CANNOT_FETCH_REGISTER (regnum
))
291 regcache_raw_supply (current_regcache
, regnum
, NULL
);
295 /* GNU/Linux LWP ID's are process ID's. */
296 tid
= TIDGET (inferior_ptid
);
298 tid
= PIDGET (inferior_ptid
); /* Not a threaded program. */
300 /* This isn't really an address. But ptrace thinks of it as one. */
301 addr
= register_addr (regnum
, U_REGS_OFFSET
);
302 size
= register_size (current_gdbarch
, regnum
);
304 gdb_assert ((size
% sizeof (PTRACE_TYPE_RET
)) == 0);
307 /* Read the register contents from the inferior a chuck at the time. */
308 for (i
= 0; i
< size
/ sizeof (PTRACE_TYPE_RET
); i
++)
311 buf
[i
] = ptrace (PT_READ_U
, tid
, (PTRACE_TYPE_ARG3
) addr
, 0);
313 error ("Couldn't read register %s (#%d): %s.", REGISTER_NAME (regnum
),
314 regnum
, safe_strerror (errno
));
316 addr
+= sizeof (PTRACE_TYPE_RET
);
318 regcache_raw_supply (current_regcache
, regnum
, buf
);
321 /* Fetch register REGNUM from the inferior. If REGNUM is -1, do this
322 for all registers. */
325 fetch_inferior_registers (int regnum
)
328 for (regnum
= 0; regnum
< NUM_REGS
; regnum
++)
329 fetch_register (regnum
);
331 fetch_register (regnum
);
334 /* Store register REGNUM into the inferior. */
337 store_register (int regnum
)
341 PTRACE_TYPE_RET
*buf
;
344 if (CANNOT_STORE_REGISTER (regnum
))
347 /* GNU/Linux LWP ID's are process ID's. */
348 tid
= TIDGET (inferior_ptid
);
350 tid
= PIDGET (inferior_ptid
); /* Not a threaded program. */
352 /* This isn't really an address. But ptrace thinks of it as one. */
353 addr
= register_addr (regnum
, U_REGS_OFFSET
);
354 size
= register_size (current_gdbarch
, regnum
);
356 gdb_assert ((size
% sizeof (PTRACE_TYPE_RET
)) == 0);
359 /* Write the register contents into the inferior a chunk at the time. */
360 regcache_raw_collect (current_regcache
, regnum
, buf
);
361 for (i
= 0; i
< size
/ sizeof (PTRACE_TYPE_RET
); i
++)
364 ptrace (PT_WRITE_U
, tid
, (PTRACE_TYPE_ARG3
) addr
, buf
[i
]);
366 error ("Couldn't write register %s (#%d): %s.", REGISTER_NAME (regnum
),
367 regnum
, safe_strerror (errno
));
369 addr
+= sizeof (PTRACE_TYPE_RET
);
373 /* Store register REGNUM back into the inferior. If REGNUM is -1, do
374 this for all registers (including the floating point registers). */
377 store_inferior_registers (int regnum
)
380 for (regnum
= 0; regnum
< NUM_REGS
; regnum
++)
381 store_register (regnum
);
383 store_register (regnum
);
386 #endif /* not FETCH_INFERIOR_REGISTERS. */
389 /* Set an upper limit on alloca. */
390 #ifndef GDB_MAX_ALLOCA
391 #define GDB_MAX_ALLOCA 0x1000
394 #if !defined (CHILD_XFER_MEMORY)
395 /* NOTE! I tried using PTRACE_READDATA, etc., to read and write memory
396 in the NEW_SUN_PTRACE case. It ought to be straightforward. But
397 it appears that writing did not write the data that I specified. I
398 cannot understand where it got the data that it actually did write. */
400 /* Copy LEN bytes to or from inferior's memory starting at MEMADDR to
401 debugger memory starting at MYADDR. Copy to inferior if WRITE is
402 nonzero. TARGET is ignored.
404 Returns the length copied, which is either the LEN argument or
405 zero. This xfer function does not do partial moves, since
406 deprecated_child_ops doesn't allow memory operations to cross below
407 us in the target stack anyway. */
410 child_xfer_memory (CORE_ADDR memaddr
, char *myaddr
, int len
, int write
,
411 struct mem_attrib
*attrib
, struct target_ops
*target
)
414 /* Round starting address down to longword boundary. */
415 CORE_ADDR addr
= memaddr
& -(CORE_ADDR
) sizeof (PTRACE_TYPE_RET
);
416 /* Round ending address up; get number of longwords that makes. */
417 int count
= ((((memaddr
+ len
) - addr
) + sizeof (PTRACE_TYPE_RET
) - 1)
418 / sizeof (PTRACE_TYPE_RET
));
419 int alloc
= count
* sizeof (PTRACE_TYPE_RET
);
420 PTRACE_TYPE_RET
*buffer
;
421 struct cleanup
*old_chain
= NULL
;
424 /* OpenBSD 3.1, NetBSD 1.6 and FreeBSD 5.0 have a new PT_IO request
425 that promises to be much more efficient in reading and writing
426 data in the traced process's address space. */
429 struct ptrace_io_desc piod
;
431 /* NOTE: We assume that there are no distinct address spaces for
432 instruction and data. */
433 piod
.piod_op
= write
? PIOD_WRITE_D
: PIOD_READ_D
;
434 piod
.piod_offs
= (void *) memaddr
;
435 piod
.piod_addr
= myaddr
;
438 if (ptrace (PT_IO
, PIDGET (inferior_ptid
), (caddr_t
) &piod
, 0) == -1)
440 /* If the PT_IO request is somehow not supported, fallback on
441 using PT_WRITE_D/PT_READ_D. Otherwise we will return zero
442 to indicate failure. */
448 /* Return the actual number of bytes read or written. */
449 return piod
.piod_len
;
454 /* Allocate buffer of that many longwords. */
455 if (len
< GDB_MAX_ALLOCA
)
457 buffer
= (PTRACE_TYPE_RET
*) alloca (alloc
);
461 buffer
= (PTRACE_TYPE_RET
*) xmalloc (alloc
);
462 old_chain
= make_cleanup (xfree
, buffer
);
467 /* Fill start and end extra bytes of buffer with existing memory
469 if (addr
!= memaddr
|| len
< (int) sizeof (PTRACE_TYPE_RET
))
471 /* Need part of initial word -- fetch it. */
472 buffer
[0] = ptrace (PT_READ_I
, PIDGET (inferior_ptid
),
473 (PTRACE_TYPE_ARG3
) addr
, 0);
476 if (count
> 1) /* FIXME, avoid if even boundary. */
479 ptrace (PT_READ_I
, PIDGET (inferior_ptid
),
481 (addr
+ (count
- 1) * sizeof (PTRACE_TYPE_RET
))), 0);
484 /* Copy data to be written over corresponding part of buffer. */
485 memcpy ((char *) buffer
+ (memaddr
& (sizeof (PTRACE_TYPE_RET
) - 1)),
488 /* Write the entire buffer. */
489 for (i
= 0; i
< count
; i
++, addr
+= sizeof (PTRACE_TYPE_RET
))
492 ptrace (PT_WRITE_D
, PIDGET (inferior_ptid
),
493 (PTRACE_TYPE_ARG3
) addr
, buffer
[i
]);
496 /* Using the appropriate one (I or D) is necessary for
497 Gould NP1, at least. */
499 ptrace (PT_WRITE_I
, PIDGET (inferior_ptid
),
500 (PTRACE_TYPE_ARG3
) addr
, buffer
[i
]);
508 /* Read all the longwords. */
509 for (i
= 0; i
< count
; i
++, addr
+= sizeof (PTRACE_TYPE_RET
))
512 buffer
[i
] = ptrace (PT_READ_I
, PIDGET (inferior_ptid
),
513 (PTRACE_TYPE_ARG3
) addr
, 0);
519 /* Copy appropriate bytes out of the buffer. */
521 (char *) buffer
+ (memaddr
& (sizeof (PTRACE_TYPE_RET
) - 1)),
525 if (old_chain
!= NULL
)
526 do_cleanups (old_chain
);
532 udot_info (char *dummy1
, int dummy2
)
534 #if defined (KERNEL_U_SIZE)
535 long udot_off
; /* Offset into user struct */
536 int udot_val
; /* Value from user struct at udot_off */
537 char mess
[128]; /* For messages */
540 if (!target_has_execution
)
542 error ("The program is not being run.");
545 #if !defined (KERNEL_U_SIZE)
547 /* Adding support for this command is easy. Typically you just add a
548 routine, called "kernel_u_size" that returns the size of the user
549 struct, to the appropriate *-nat.c file and then add to the native
550 config file "#define KERNEL_U_SIZE kernel_u_size()" */
551 error ("Don't know how large ``struct user'' is in this version of gdb.");
555 for (udot_off
= 0; udot_off
< KERNEL_U_SIZE
; udot_off
+= sizeof (udot_val
))
557 if ((udot_off
% 24) == 0)
561 printf_filtered ("\n");
563 printf_filtered ("%s:", paddr (udot_off
));
565 udot_val
= ptrace (PT_READ_U
, PIDGET (inferior_ptid
), (PTRACE_TYPE_ARG3
) udot_off
, 0);
568 sprintf (mess
, "\nreading user struct at offset 0x%s",
569 paddr_nz (udot_off
));
570 perror_with_name (mess
);
572 /* Avoid using nonportable (?) "*" in print specs */
573 printf_filtered (sizeof (int) == 4 ? " 0x%08x" : " 0x%16x", udot_val
);
575 printf_filtered ("\n");
579 #endif /* !defined (CHILD_XFER_MEMORY). */
583 _initialize_infptrace (void)
585 #if !defined (CHILD_XFER_MEMORY)
586 add_info ("udot", udot_info
,
587 "Print contents of kernel ``struct user'' for current child.");
This page took 0.04099 seconds and 4 git commands to generate.