1
/* Low level Unix child interface to ptrace, for GDB when running under Unix.
2
Copyright (C) 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., 51 Franklin Street, Fifth Floor,
21
Boston, MA 02110-1301, 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."));
added
removed
gdb/infptrace.c
