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);
58 call_ptrace (int request
, int pid
, PTRACE_ARG3_TYPE addr
, int data
)
60 return ptrace (request
, pid
, addr
, data
);
63 /* Wait for a process to finish, possibly running a target-specific
64 hook before returning. */
66 /* NOTE: cagney: 2004-09-29: Dependant on the native configuration,
67 "hppah-nat.c" may either call this or infttrace.c's implementation
68 of ptrace_wait. See "hppahpux.mh". */
71 ptrace_wait (ptid_t ptid
, int *status
)
75 wstate
= wait (status
);
79 #ifndef DEPRECATED_KILL_INFERIOR
80 /* NOTE: cagney/2004-09-12: Instead of definining this macro, code
81 should call inf_ptrace_target to get a basic ptrace target and then
82 locally update any necessary methods. See ppcnbsd-nat.c. */
88 int pid
= PIDGET (inferior_ptid
);
93 /* This once used to call "kill" to kill the inferior just in case
94 the inferior was still running. As others have noted in the past
95 (kingdon) there shouldn't be any way to get here if the inferior
96 is still running -- else there's a major problem elsewere in gdb
97 and it needs to be fixed.
99 The kill call causes problems under hpux10, so it's been removed;
100 if this causes problems we'll deal with them as they arise. */
101 ptrace (PT_KILL
, pid
, (PTRACE_TYPE_ARG3
) 0, 0);
103 target_mourn_inferior ();
105 #endif /* DEPRECATED_KILL_INFERIOR */
107 #ifndef DEPRECATED_CHILD_RESUME
108 /* NOTE: cagney/2004-09-12: Instead of definining this macro, code
109 should call inf_ptrace_target to get a basic ptrace target and then
110 locally update any necessary methods. See ppcnbsd-nat.c. */
112 /* Resume execution of the inferior process.
113 If STEP is nonzero, single-step it.
114 If SIGNAL is nonzero, give it that signal. */
117 child_resume (ptid_t ptid
, int step
, enum target_signal signal
)
119 int request
= PT_CONTINUE
;
120 int pid
= PIDGET (ptid
);
123 /* Resume all threads. */
124 /* I think this only gets used in the non-threaded case, where "resume
125 all threads" and "resume inferior_ptid" are the same. */
126 pid
= PIDGET (inferior_ptid
);
130 /* If this system does not support PT_STEP, a higher level
131 function will have called single_step() to transmute the step
132 request into a continue request (by setting breakpoints on
133 all possible successor instructions), so we don't have to
134 worry about that here. */
136 gdb_assert (!SOFTWARE_SINGLE_STEP_P ());
140 /* An address of (PTRACE_TYPE_ARG3)1 tells ptrace to continue from
141 where it was. If GDB wanted it to start some other way, we have
142 already written a new PC value to the child. */
145 ptrace (request
, pid
, (PTRACE_TYPE_ARG3
)1, target_signal_to_host (signal
));
147 perror_with_name (("ptrace"));
149 #endif /* DEPRECATED_CHILD_RESUME */
152 /* Start debugging the process whose number is PID. */
159 ptrace (PT_ATTACH
, pid
, (PTRACE_TYPE_ARG3
) 0, 0);
161 perror_with_name (("ptrace"));
165 error (_("This system does not support attaching to a process"));
169 /* Stop debugging the process whose number is PID and continue it with
170 signal number SIGNAL. SIGNAL = 0 means just continue it. */
176 int pid
= PIDGET (inferior_ptid
);
179 ptrace (PT_DETACH
, pid
, (PTRACE_TYPE_ARG3
) 1, signal
);
181 perror_with_name (("ptrace"));
184 error (_("This system does not support detaching from a process"));
189 #ifndef FETCH_INFERIOR_REGISTERS
191 /* U_REGS_OFFSET is the offset of the registers within the u area. */
192 #ifndef U_REGS_OFFSET
195 #define offsetof(TYPE, MEMBER) ((unsigned long) &((TYPE *)0)->MEMBER)
198 #define U_REGS_OFFSET \
199 ptrace (PT_READ_U, PIDGET (inferior_ptid), \
200 (PTRACE_TYPE_ARG3) (offsetof (struct user, u_ar0)), 0) \
204 /* Fetch register REGNUM from the inferior. */
207 fetch_register (int regnum
)
211 PTRACE_TYPE_RET
*buf
;
214 if (CANNOT_FETCH_REGISTER (regnum
))
216 regcache_raw_supply (current_regcache
, regnum
, NULL
);
220 /* GNU/Linux LWP ID's are process ID's. */
221 tid
= TIDGET (inferior_ptid
);
223 tid
= PIDGET (inferior_ptid
); /* Not a threaded program. */
225 /* This isn't really an address. But ptrace thinks of it as one. */
226 addr
= register_addr (regnum
, U_REGS_OFFSET
);
227 size
= register_size (current_gdbarch
, regnum
);
229 gdb_assert ((size
% sizeof (PTRACE_TYPE_RET
)) == 0);
232 /* Read the register contents from the inferior a chuck at the time. */
233 for (i
= 0; i
< size
/ sizeof (PTRACE_TYPE_RET
); i
++)
236 buf
[i
] = ptrace (PT_READ_U
, tid
, (PTRACE_TYPE_ARG3
) addr
, 0);
238 error (_("Couldn't read register %s (#%d): %s."), REGISTER_NAME (regnum
),
239 regnum
, safe_strerror (errno
));
241 addr
+= sizeof (PTRACE_TYPE_RET
);
243 regcache_raw_supply (current_regcache
, regnum
, buf
);
246 /* Fetch register REGNUM from the inferior. If REGNUM is -1, do this
247 for all registers. */
250 fetch_inferior_registers (int regnum
)
253 for (regnum
= 0; regnum
< NUM_REGS
; regnum
++)
254 fetch_register (regnum
);
256 fetch_register (regnum
);
259 /* Store register REGNUM into the inferior. */
262 store_register (int regnum
)
266 PTRACE_TYPE_RET
*buf
;
269 if (CANNOT_STORE_REGISTER (regnum
))
272 /* GNU/Linux LWP ID's are process ID's. */
273 tid
= TIDGET (inferior_ptid
);
275 tid
= PIDGET (inferior_ptid
); /* Not a threaded program. */
277 /* This isn't really an address. But ptrace thinks of it as one. */
278 addr
= register_addr (regnum
, U_REGS_OFFSET
);
279 size
= register_size (current_gdbarch
, regnum
);
281 gdb_assert ((size
% sizeof (PTRACE_TYPE_RET
)) == 0);
284 /* Write the register contents into the inferior a chunk at the time. */
285 regcache_raw_collect (current_regcache
, regnum
, buf
);
286 for (i
= 0; i
< size
/ sizeof (PTRACE_TYPE_RET
); i
++)
289 ptrace (PT_WRITE_U
, tid
, (PTRACE_TYPE_ARG3
) addr
, buf
[i
]);
291 error (_("Couldn't write register %s (#%d): %s."),
292 REGISTER_NAME (regnum
), regnum
, safe_strerror (errno
));
294 addr
+= sizeof (PTRACE_TYPE_RET
);
298 /* Store register REGNUM back into the inferior. If REGNUM is -1, do
299 this for all registers (including the floating point registers). */
302 store_inferior_registers (int regnum
)
305 for (regnum
= 0; regnum
< NUM_REGS
; regnum
++)
306 store_register (regnum
);
308 store_register (regnum
);
311 #endif /* not FETCH_INFERIOR_REGISTERS. */
314 /* Set an upper limit on alloca. */
315 #ifndef GDB_MAX_ALLOCA
316 #define GDB_MAX_ALLOCA 0x1000
319 #if !defined (CHILD_XFER_MEMORY)
320 /* NOTE! I tried using PTRACE_READDATA, etc., to read and write memory
321 in the NEW_SUN_PTRACE case. It ought to be straightforward. But
322 it appears that writing did not write the data that I specified. I
323 cannot understand where it got the data that it actually did write. */
325 /* Copy LEN bytes to or from inferior's memory starting at MEMADDR to
326 debugger memory starting at MYADDR. Copy to inferior if WRITE is
327 nonzero. TARGET is ignored.
329 Returns the length copied, which is either the LEN argument or
330 zero. This xfer function does not do partial moves, since
331 deprecated_child_ops doesn't allow memory operations to cross below
332 us in the target stack anyway. */
335 child_xfer_memory (CORE_ADDR memaddr
, gdb_byte
*myaddr
, int len
, int write
,
336 struct mem_attrib
*attrib
, struct target_ops
*target
)
339 /* Round starting address down to longword boundary. */
340 CORE_ADDR addr
= memaddr
& -(CORE_ADDR
) sizeof (PTRACE_TYPE_RET
);
341 /* Round ending address up; get number of longwords that makes. */
342 int count
= ((((memaddr
+ len
) - addr
) + sizeof (PTRACE_TYPE_RET
) - 1)
343 / sizeof (PTRACE_TYPE_RET
));
344 int alloc
= count
* sizeof (PTRACE_TYPE_RET
);
345 PTRACE_TYPE_RET
*buffer
;
346 struct cleanup
*old_chain
= NULL
;
349 /* OpenBSD 3.1, NetBSD 1.6 and FreeBSD 5.0 have a new PT_IO request
350 that promises to be much more efficient in reading and writing
351 data in the traced process's address space. */
354 struct ptrace_io_desc piod
;
356 /* NOTE: We assume that there are no distinct address spaces for
357 instruction and data. */
358 piod
.piod_op
= write
? PIOD_WRITE_D
: PIOD_READ_D
;
359 piod
.piod_offs
= (void *) memaddr
;
360 piod
.piod_addr
= myaddr
;
363 if (ptrace (PT_IO
, PIDGET (inferior_ptid
), (caddr_t
) &piod
, 0) == -1)
365 /* If the PT_IO request is somehow not supported, fallback on
366 using PT_WRITE_D/PT_READ_D. Otherwise we will return zero
367 to indicate failure. */
373 /* Return the actual number of bytes read or written. */
374 return piod
.piod_len
;
379 /* Allocate buffer of that many longwords. */
380 if (len
< GDB_MAX_ALLOCA
)
382 buffer
= (PTRACE_TYPE_RET
*) alloca (alloc
);
386 buffer
= (PTRACE_TYPE_RET
*) xmalloc (alloc
);
387 old_chain
= make_cleanup (xfree
, buffer
);
392 /* Fill start and end extra bytes of buffer with existing memory
394 if (addr
!= memaddr
|| len
< (int) sizeof (PTRACE_TYPE_RET
))
396 /* Need part of initial word -- fetch it. */
397 buffer
[0] = ptrace (PT_READ_I
, PIDGET (inferior_ptid
),
398 (PTRACE_TYPE_ARG3
) addr
, 0);
401 if (count
> 1) /* FIXME, avoid if even boundary. */
404 ptrace (PT_READ_I
, PIDGET (inferior_ptid
),
406 (addr
+ (count
- 1) * sizeof (PTRACE_TYPE_RET
))), 0);
409 /* Copy data to be written over corresponding part of buffer. */
410 memcpy ((char *) buffer
+ (memaddr
& (sizeof (PTRACE_TYPE_RET
) - 1)),
413 /* Write the entire buffer. */
414 for (i
= 0; i
< count
; i
++, addr
+= sizeof (PTRACE_TYPE_RET
))
417 ptrace (PT_WRITE_D
, PIDGET (inferior_ptid
),
418 (PTRACE_TYPE_ARG3
) addr
, buffer
[i
]);
421 /* Using the appropriate one (I or D) is necessary for
422 Gould NP1, at least. */
424 ptrace (PT_WRITE_I
, PIDGET (inferior_ptid
),
425 (PTRACE_TYPE_ARG3
) addr
, buffer
[i
]);
433 /* Read all the longwords. */
434 for (i
= 0; i
< count
; i
++, addr
+= sizeof (PTRACE_TYPE_RET
))
437 buffer
[i
] = ptrace (PT_READ_I
, PIDGET (inferior_ptid
),
438 (PTRACE_TYPE_ARG3
) addr
, 0);
444 /* Copy appropriate bytes out of the buffer. */
446 (char *) buffer
+ (memaddr
& (sizeof (PTRACE_TYPE_RET
) - 1)),
450 if (old_chain
!= NULL
)
451 do_cleanups (old_chain
);
457 udot_info (char *dummy1
, int dummy2
)
459 #if defined (KERNEL_U_SIZE)
460 long udot_off
; /* Offset into user struct */
461 int udot_val
; /* Value from user struct at udot_off */
462 char mess
[128]; /* For messages */
465 if (!target_has_execution
)
467 error (_("The program is not being run."));
470 #if !defined (KERNEL_U_SIZE)
472 /* Adding support for this command is easy. Typically you just add a
473 routine, called "kernel_u_size" that returns the size of the user
474 struct, to the appropriate *-nat.c file and then add to the native
475 config file "#define KERNEL_U_SIZE kernel_u_size()" */
476 error (_("Don't know how large ``struct user'' is in this version of gdb."));
480 for (udot_off
= 0; udot_off
< KERNEL_U_SIZE
; udot_off
+= sizeof (udot_val
))
482 if ((udot_off
% 24) == 0)
486 printf_filtered ("\n");
488 printf_filtered ("%s:", paddr (udot_off
));
490 udot_val
= ptrace (PT_READ_U
, PIDGET (inferior_ptid
), (PTRACE_TYPE_ARG3
) udot_off
, 0);
493 sprintf (mess
, "\nreading user struct at offset 0x%s",
494 paddr_nz (udot_off
));
495 perror_with_name (mess
);
497 /* Avoid using nonportable (?) "*" in print specs */
498 printf_filtered (sizeof (int) == 4 ? " 0x%08x" : " 0x%16x", udot_val
);
500 printf_filtered ("\n");
504 #endif /* !defined (CHILD_XFER_MEMORY). */
508 _initialize_infptrace (void)
510 #if !defined (CHILD_XFER_MEMORY)
511 add_info ("udot", udot_info
,
512 _("Print contents of kernel ``struct user'' for current child."));
This page took 0.040174 seconds and 4 git commands to generate.