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 Free Software Foundation, Inc.
4 This file is part of GDB.
6 This program is free software; you can redistribute it and/or modify
7 it under the terms of the GNU General Public License as published by
8 the Free Software Foundation; either version 2 of the License, or
9 (at your option) any later version.
11 This program is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 GNU General Public License for more details.
16 You should have received a copy of the GNU General Public License
17 along with this program; if not, write to the Free Software
18 Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
24 #include "gdb_string.h"
27 #include <sys/types.h>
30 #include <sys/param.h>
33 #include <sys/ioctl.h>
36 #ifdef PTRACE_IN_WRONG_PLACE
39 #include <sys/ptrace.h>
41 #endif /* NO_PTRACE_H */
43 #if !defined (PT_READ_I)
44 #define PT_READ_I 1 /* Read word from text space */
46 #if !defined (PT_READ_D)
47 #define PT_READ_D 2 /* Read word from data space */
49 #if !defined (PT_READ_U)
50 #define PT_READ_U 3 /* Read word from kernel user struct */
52 #if !defined (PT_WRITE_I)
53 #define PT_WRITE_I 4 /* Write word to text space */
55 #if !defined (PT_WRITE_D)
56 #define PT_WRITE_D 5 /* Write word to data space */
58 #if !defined (PT_WRITE_U)
59 #define PT_WRITE_U 6 /* Write word to kernel user struct */
61 #if !defined (PT_CONTINUE)
62 #define PT_CONTINUE 7 /* Continue after signal */
64 #if !defined (PT_STEP)
65 #define PT_STEP 9 /* Set flag for single stepping */
67 #if !defined (PT_KILL)
68 #define PT_KILL 8 /* Send child a SIGKILL signal */
72 #define PT_ATTACH PTRACE_ATTACH
75 #define PT_DETACH PTRACE_DETACH
83 /* Don't think this is used anymore. On the sequent (not sure whether it's
84 dynix or ptx or both), it is included unconditionally by sys/user.h and
85 not protected against multiple inclusion. */
89 #if !defined (FETCH_INFERIOR_REGISTERS)
90 #include <sys/user.h> /* Probably need to poke the user structure */
91 #if defined (KERNEL_U_ADDR_BSD)
92 #include <a.out.h> /* For struct nlist */
93 #endif /* KERNEL_U_ADDR_BSD. */
94 #endif /* !FETCH_INFERIOR_REGISTERS */
97 /* This function simply calls ptrace with the given arguments.
98 It exists so that all calls to ptrace are isolated in this
99 machine-dependent file. */
101 call_ptrace (request
, pid
, addr
, data
)
103 PTRACE_ARG3_TYPE addr
;
106 return ptrace (request
, pid
, addr
, data
107 #if defined (FIVE_ARG_PTRACE)
108 /* Deal with HPUX 8.0 braindamage. We never use the
109 calls which require the fifth argument. */
115 #if defined (DEBUG_PTRACE) || defined (FIVE_ARG_PTRACE)
116 /* For the rest of the file, use an extra level of indirection */
117 /* This lets us breakpoint usefully on call_ptrace. */
118 #define ptrace call_ptrace
124 if (inferior_pid
== 0)
126 /* ptrace PT_KILL only works if process is stopped!!! So stop it with
127 a real signal first, if we can. FIXME: This is bogus. When the inferior
128 is not stopped, GDB should just be waiting for it. Either the following
129 line is unecessary, or there is some problem elsewhere in GDB which
130 causes us to get here when the inferior is not stopped. */
131 kill (inferior_pid
, SIGKILL
);
132 ptrace (PT_KILL
, inferior_pid
, (PTRACE_ARG3_TYPE
) 0, 0);
134 target_mourn_inferior ();
139 /* Resume execution of the inferior process.
140 If STEP is nonzero, single-step it.
141 If SIGNAL is nonzero, give it that signal. */
144 child_resume (pid
, step
, signal
)
147 enum target_signal signal
;
152 /* Resume all threads. */
153 /* I think this only gets used in the non-threaded case, where "resume
154 all threads" and "resume inferior_pid" are the same. */
157 /* An address of (PTRACE_ARG3_TYPE)1 tells ptrace to continue from where
158 it was. (If GDB wanted it to start some other way, we have already
159 written a new PC value to the child.)
161 If this system does not support PT_STEP, a higher level function will
162 have called single_step() to transmute the step request into a
163 continue request (by setting breakpoints on all possible successor
164 instructions), so we don't have to worry about that here. */
167 ptrace (PT_STEP
, pid
, (PTRACE_ARG3_TYPE
) 1,
168 target_signal_to_host (signal
));
170 ptrace (PT_CONTINUE
, pid
, (PTRACE_ARG3_TYPE
) 1,
171 target_signal_to_host (signal
));
174 perror_with_name ("ptrace");
176 #endif /* CHILD_RESUME */
180 /* Start debugging the process whose number is PID. */
186 ptrace (PT_ATTACH
, pid
, (PTRACE_ARG3_TYPE
) 0, 0);
188 perror_with_name ("ptrace");
193 /* Stop debugging the process whose number is PID
194 and continue it with signal number SIGNAL.
195 SIGNAL = 0 means just continue it. */
202 ptrace (PT_DETACH
, inferior_pid
, (PTRACE_ARG3_TYPE
) 1, signal
);
204 perror_with_name ("ptrace");
207 #endif /* ATTACH_DETACH */
209 /* Default the type of the ptrace transfer to int. */
210 #ifndef PTRACE_XFER_TYPE
211 #define PTRACE_XFER_TYPE int
214 /* KERNEL_U_ADDR is the amount to subtract from u.u_ar0
215 to get the offset in the core file of the register values. */
216 #if defined (KERNEL_U_ADDR_BSD) && !defined (FETCH_INFERIOR_REGISTERS)
217 /* Get kernel_u_addr using BSD-style nlist(). */
218 CORE_ADDR kernel_u_addr
;
219 #endif /* KERNEL_U_ADDR_BSD. */
222 _initialize_kernel_u_addr ()
224 #if defined (KERNEL_U_ADDR_BSD) && !defined (FETCH_INFERIOR_REGISTERS)
225 struct nlist names
[2];
227 names
[0].n_un
.n_name
= "_u";
228 names
[1].n_un
.n_name
= NULL
;
229 if (nlist ("/vmunix", names
) == 0)
230 kernel_u_addr
= names
[0].n_value
;
232 fatal ("Unable to get kernel u area address.");
233 #endif /* KERNEL_U_ADDR_BSD. */
236 #if !defined (FETCH_INFERIOR_REGISTERS)
238 #if !defined (offsetof)
239 #define offsetof(TYPE, MEMBER) ((unsigned long) &((TYPE *)0)->MEMBER)
242 /* U_REGS_OFFSET is the offset of the registers within the u area. */
243 #if !defined (U_REGS_OFFSET)
244 #define U_REGS_OFFSET \
245 ptrace (PT_READ_U, inferior_pid, \
246 (PTRACE_ARG3_TYPE) (offsetof (struct user, u_ar0)), 0) \
250 /* Registers we shouldn't try to fetch. */
251 #if !defined (CANNOT_FETCH_REGISTER)
252 #define CANNOT_FETCH_REGISTER(regno) 0
255 /* Fetch one register. */
258 fetch_register (regno
)
261 /* This isn't really an address. But ptrace thinks of it as one. */
263 char buf
[MAX_REGISTER_RAW_SIZE
];
264 char mess
[128]; /* For messages */
267 /* Offset of registers within the u area. */
270 if (CANNOT_FETCH_REGISTER (regno
))
272 memset (buf
, '\0', REGISTER_RAW_SIZE (regno
)); /* Supply zeroes */
273 supply_register (regno
, buf
);
277 offset
= U_REGS_OFFSET
;
279 regaddr
= register_addr (regno
, offset
);
280 for (i
= 0; i
< REGISTER_RAW_SIZE (regno
); i
+= sizeof (PTRACE_XFER_TYPE
))
283 *(PTRACE_XFER_TYPE
*) &buf
[i
] = ptrace (PT_READ_U
, inferior_pid
,
284 (PTRACE_ARG3_TYPE
) regaddr
, 0);
285 regaddr
+= sizeof (PTRACE_XFER_TYPE
);
288 sprintf (mess
, "reading register %s (#%d)", reg_names
[regno
], regno
);
289 perror_with_name (mess
);
292 supply_register (regno
, buf
);
296 /* Fetch all registers, or just one, from the child process. */
299 fetch_inferior_registers (regno
)
306 numregs
= ARCH_NUM_REGS
;
307 for (regno
= 0; regno
< numregs
; regno
++)
308 fetch_register (regno
);
311 fetch_register (regno
);
314 /* Registers we shouldn't try to store. */
315 #if !defined (CANNOT_STORE_REGISTER)
316 #define CANNOT_STORE_REGISTER(regno) 0
319 /* Store our register values back into the inferior.
320 If REGNO is -1, do this for all registers.
321 Otherwise, REGNO specifies which register (so we can save time). */
324 store_inferior_registers (regno
)
327 /* This isn't really an address. But ptrace thinks of it as one. */
330 register int i
, numregs
;
332 unsigned int offset
= U_REGS_OFFSET
;
336 regaddr
= register_addr (regno
, offset
);
337 for (i
= 0; i
< REGISTER_RAW_SIZE (regno
); i
+= sizeof(PTRACE_XFER_TYPE
))
340 ptrace (PT_WRITE_U
, inferior_pid
, (PTRACE_ARG3_TYPE
) regaddr
,
341 *(PTRACE_XFER_TYPE
*) ®isters
[REGISTER_BYTE (regno
) + i
]);
344 sprintf (buf
, "writing register number %d(%d)", regno
, i
);
345 perror_with_name (buf
);
347 regaddr
+= sizeof(PTRACE_XFER_TYPE
);
352 numregs
= ARCH_NUM_REGS
;
353 for (regno
= 0; regno
< numregs
; regno
++)
355 if (CANNOT_STORE_REGISTER (regno
))
357 regaddr
= register_addr (regno
, offset
);
358 for (i
= 0; i
< REGISTER_RAW_SIZE (regno
); i
+= sizeof(PTRACE_XFER_TYPE
))
361 ptrace (PT_WRITE_U
, inferior_pid
, (PTRACE_ARG3_TYPE
) regaddr
,
362 *(PTRACE_XFER_TYPE
*) ®isters
[REGISTER_BYTE (regno
) + i
]);
365 sprintf (buf
, "writing register number %d(%d)", regno
, i
);
366 perror_with_name (buf
);
368 regaddr
+= sizeof(PTRACE_XFER_TYPE
);
373 #endif /* !defined (FETCH_INFERIOR_REGISTERS). */
376 #if !defined (CHILD_XFER_MEMORY)
377 /* NOTE! I tried using PTRACE_READDATA, etc., to read and write memory
378 in the NEW_SUN_PTRACE case.
379 It ought to be straightforward. But it appears that writing did
380 not write the data that I specified. I cannot understand where
381 it got the data that it actually did write. */
383 /* Copy LEN bytes to or from inferior's memory starting at MEMADDR
384 to debugger memory starting at MYADDR. Copy to inferior if
387 Returns the length copied, which is either the LEN argument or zero.
388 This xfer function does not do partial moves, since child_ops
389 doesn't allow memory operations to cross below us in the target stack
393 child_xfer_memory (memaddr
, myaddr
, len
, write
, target
)
398 struct target_ops
*target
; /* ignored */
401 /* Round starting address down to longword boundary. */
402 register CORE_ADDR addr
= memaddr
& - sizeof (PTRACE_XFER_TYPE
);
403 /* Round ending address up; get number of longwords that makes. */
405 = (((memaddr
+ len
) - addr
) + sizeof (PTRACE_XFER_TYPE
) - 1)
406 / sizeof (PTRACE_XFER_TYPE
);
407 /* Allocate buffer of that many longwords. */
408 register PTRACE_XFER_TYPE
*buffer
409 = (PTRACE_XFER_TYPE
*) alloca (count
* sizeof (PTRACE_XFER_TYPE
));
413 /* Fill start and end extra bytes of buffer with existing memory data. */
415 if (addr
!= memaddr
|| len
< (int) sizeof (PTRACE_XFER_TYPE
)) {
416 /* Need part of initial word -- fetch it. */
417 buffer
[0] = ptrace (PT_READ_I
, inferior_pid
, (PTRACE_ARG3_TYPE
) addr
,
421 if (count
> 1) /* FIXME, avoid if even boundary */
424 = ptrace (PT_READ_I
, inferior_pid
,
426 (addr
+ (count
- 1) * sizeof (PTRACE_XFER_TYPE
))),
430 /* Copy data to be written over corresponding part of buffer */
432 memcpy ((char *) buffer
+ (memaddr
& (sizeof (PTRACE_XFER_TYPE
) - 1)),
436 /* Write the entire buffer. */
438 for (i
= 0; i
< count
; i
++, addr
+= sizeof (PTRACE_XFER_TYPE
))
441 ptrace (PT_WRITE_D
, inferior_pid
, (PTRACE_ARG3_TYPE
) addr
,
445 /* Using the appropriate one (I or D) is necessary for
446 Gould NP1, at least. */
448 ptrace (PT_WRITE_I
, inferior_pid
, (PTRACE_ARG3_TYPE
) addr
,
457 /* Read all the longwords */
458 for (i
= 0; i
< count
; i
++, addr
+= sizeof (PTRACE_XFER_TYPE
))
461 buffer
[i
] = ptrace (PT_READ_I
, inferior_pid
,
462 (PTRACE_ARG3_TYPE
) addr
, 0);
468 /* Copy appropriate bytes out of the buffer. */
470 (char *) buffer
+ (memaddr
& (sizeof (PTRACE_XFER_TYPE
) - 1)),
480 int udot_off
; /* Offset into user struct */
481 int udot_val
; /* Value from user struct at udot_off */
482 char mess
[128]; /* For messages */
484 if (!target_has_execution
)
486 error ("The program is not being run.");
489 #if !defined (KERNEL_U_SIZE)
491 /* Adding support for this command is easy. Typically you just add a
492 routine, called "kernel_u_size" that returns the size of the user
493 struct, to the appropriate *-nat.c file and then add to the native
494 config file "#define KERNEL_U_SIZE kernel_u_size()" */
495 error ("Don't know how large ``struct user'' is in this version of gdb.");
499 for (udot_off
= 0; udot_off
< KERNEL_U_SIZE
; udot_off
+= sizeof (udot_val
))
501 if ((udot_off
% 24) == 0)
505 printf_filtered ("\n");
507 printf_filtered ("%04x:", udot_off
);
509 udot_val
= ptrace (PT_READ_U
, inferior_pid
, (PTRACE_ARG3_TYPE
) udot_off
, 0);
512 sprintf (mess
, "\nreading user struct at offset 0x%x", udot_off
);
513 perror_with_name (mess
);
515 /* Avoid using nonportable (?) "*" in print specs */
516 printf_filtered (sizeof (int) == 4 ? " 0x%08x" : " 0x%16x", udot_val
);
518 printf_filtered ("\n");
524 _initialize_infptrace ()
526 add_info ("udot", udot_info
,
527 "Print contents of kernel ``struct user'' for current child.");
530 #endif /* !defined (CHILD_XFER_MEMORY). */
This page took 0.049115 seconds and 4 git commands to generate.