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"
29 #include <sys/types.h>
32 #include <sys/param.h>
35 #include <sys/ioctl.h>
38 #ifdef PTRACE_IN_WRONG_PLACE
41 #include <sys/ptrace.h>
43 #endif /* NO_PTRACE_H */
45 #if !defined (PT_READ_I)
46 #define PT_READ_I 1 /* Read word from text space */
48 #if !defined (PT_READ_D)
49 #define PT_READ_D 2 /* Read word from data space */
51 #if !defined (PT_READ_U)
52 #define PT_READ_U 3 /* Read word from kernel user struct */
54 #if !defined (PT_WRITE_I)
55 #define PT_WRITE_I 4 /* Write word to text space */
57 #if !defined (PT_WRITE_D)
58 #define PT_WRITE_D 5 /* Write word to data space */
60 #if !defined (PT_WRITE_U)
61 #define PT_WRITE_U 6 /* Write word to kernel user struct */
63 #if !defined (PT_CONTINUE)
64 #define PT_CONTINUE 7 /* Continue after signal */
66 #if !defined (PT_STEP)
67 #define PT_STEP 9 /* Set flag for single stepping */
69 #if !defined (PT_KILL)
70 #define PT_KILL 8 /* Send child a SIGKILL signal */
74 #define PT_ATTACH PTRACE_ATTACH
77 #define PT_DETACH PTRACE_DETACH
85 /* Don't think this is used anymore. On the sequent (not sure whether it's
86 dynix or ptx or both), it is included unconditionally by sys/user.h and
87 not protected against multiple inclusion. */
91 #if !defined (FETCH_INFERIOR_REGISTERS)
92 #include <sys/user.h> /* Probably need to poke the user structure */
93 #if defined (KERNEL_U_ADDR_BSD)
94 #include <a.out.h> /* For struct nlist */
95 #endif /* KERNEL_U_ADDR_BSD. */
96 #endif /* !FETCH_INFERIOR_REGISTERS */
98 #if !defined (CHILD_XFER_MEMORY)
99 static void udot_info PARAMS ((char *, int));
102 #if !defined (FETCH_INFERIOR_REGISTERS)
103 static void fetch_register PARAMS ((int));
104 static void store_register PARAMS ((int));
108 /* This function simply calls ptrace with the given arguments.
109 It exists so that all calls to ptrace are isolated in this
110 machine-dependent file. */
112 call_ptrace (request, pid, addr, data)
114 PTRACE_ARG3_TYPE addr;
117 return ptrace (request, pid, addr, data
118 #if defined (FIVE_ARG_PTRACE)
119 /* Deal with HPUX 8.0 braindamage. We never use the
120 calls which require the fifth argument. */
126 #if defined (DEBUG_PTRACE) || defined (FIVE_ARG_PTRACE)
127 /* For the rest of the file, use an extra level of indirection */
128 /* This lets us breakpoint usefully on call_ptrace. */
129 #define ptrace call_ptrace
135 if (inferior_pid == 0)
138 /* This once used to call "kill" to kill the inferior just in case
139 the inferior was still running. As others have noted in the past
140 (kingdon) there shouldn't be any way to get here if the inferior
141 is still running -- else there's a major problem elsewere in gdb
142 and it needs to be fixed.
144 The kill call causes problems under hpux10, so it's been removed;
145 if this causes problems we'll deal with them as they arise. */
146 ptrace (PT_KILL, inferior_pid, (PTRACE_ARG3_TYPE) 0, 0);
148 target_mourn_inferior ();
153 /* Resume execution of the inferior process.
154 If STEP is nonzero, single-step it.
155 If SIGNAL is nonzero, give it that signal. */
158 child_resume (pid, step, signal)
161 enum target_signal signal;
166 /* Resume all threads. */
167 /* I think this only gets used in the non-threaded case, where "resume
168 all threads" and "resume inferior_pid" are the same. */
171 /* An address of (PTRACE_ARG3_TYPE)1 tells ptrace to continue from where
172 it was. (If GDB wanted it to start some other way, we have already
173 written a new PC value to the child.)
175 If this system does not support PT_STEP, a higher level function will
176 have called single_step() to transmute the step request into a
177 continue request (by setting breakpoints on all possible successor
178 instructions), so we don't have to worry about that here. */
182 #ifdef NO_SINGLE_STEP
183 abort(); /* Make sure this doesn't happen. */
185 ptrace (PT_STEP, pid, (PTRACE_ARG3_TYPE) 1,
186 target_signal_to_host (signal));
187 #endif /* NO_SINGLE_STEP */
190 ptrace (PT_CONTINUE, pid, (PTRACE_ARG3_TYPE) 1,
191 target_signal_to_host (signal));
194 perror_with_name ("ptrace");
196 #endif /* CHILD_RESUME */
200 /* Start debugging the process whose number is PID. */
206 ptrace (PT_ATTACH, pid, (PTRACE_ARG3_TYPE) 0, 0);
208 perror_with_name ("ptrace");
213 /* Stop debugging the process whose number is PID
214 and continue it with signal number SIGNAL.
215 SIGNAL = 0 means just continue it. */
222 ptrace (PT_DETACH, inferior_pid, (PTRACE_ARG3_TYPE) 1, signal);
224 perror_with_name ("ptrace");
227 #endif /* ATTACH_DETACH */
229 /* Default the type of the ptrace transfer to int. */
230 #ifndef PTRACE_XFER_TYPE
231 #define PTRACE_XFER_TYPE int
234 /* KERNEL_U_ADDR is the amount to subtract from u.u_ar0
235 to get the offset in the core file of the register values. */
236 #if defined (KERNEL_U_ADDR_BSD) && !defined (FETCH_INFERIOR_REGISTERS)
237 /* Get kernel_u_addr using BSD-style nlist(). */
238 CORE_ADDR kernel_u_addr;
239 #endif /* KERNEL_U_ADDR_BSD. */
242 _initialize_kernel_u_addr ()
244 #if defined (KERNEL_U_ADDR_BSD) && !defined (FETCH_INFERIOR_REGISTERS)
245 struct nlist names[2];
247 names[0].n_un.n_name = "_u";
248 names[1].n_un.n_name = NULL;
249 if (nlist ("/vmunix", names) == 0)
250 kernel_u_addr = names[0].n_value;
252 fatal ("Unable to get kernel u area address.");
253 #endif /* KERNEL_U_ADDR_BSD. */
256 #if !defined (FETCH_INFERIOR_REGISTERS)
258 #if !defined (offsetof)
259 #define offsetof(TYPE, MEMBER) ((unsigned long) &((TYPE *)0)->MEMBER)
262 /* U_REGS_OFFSET is the offset of the registers within the u area. */
263 #if !defined (U_REGS_OFFSET)
264 #define U_REGS_OFFSET \
265 ptrace (PT_READ_U, inferior_pid, \
266 (PTRACE_ARG3_TYPE) (offsetof (struct user, u_ar0)), 0) \
270 /* Registers we shouldn't try to fetch. */
271 #if !defined (CANNOT_FETCH_REGISTER)
272 #define CANNOT_FETCH_REGISTER(regno) 0
275 /* Fetch one register. */
278 fetch_register (regno)
281 /* This isn't really an address. But ptrace thinks of it as one. */
283 char mess[128]; /* For messages */
285 unsigned int offset; /* Offset of registers within the u area. */
286 char buf[MAX_REGISTER_RAW_SIZE];
288 if (CANNOT_FETCH_REGISTER (regno))
290 memset (buf, '\0', REGISTER_RAW_SIZE (regno)); /* Supply zeroes */
291 supply_register (regno, buf);
295 offset = U_REGS_OFFSET;
297 regaddr = register_addr (regno, offset);
298 for (i = 0; i < REGISTER_RAW_SIZE (regno); i += sizeof (PTRACE_XFER_TYPE))
301 *(PTRACE_XFER_TYPE *) &buf[i] = ptrace (PT_READ_U, inferior_pid,
302 (PTRACE_ARG3_TYPE) regaddr, 0);
303 regaddr += sizeof (PTRACE_XFER_TYPE);
306 sprintf (mess, "reading register %s (#%d)", reg_names[regno], regno);
307 perror_with_name (mess);
310 supply_register (regno, buf);
314 /* Fetch register values from the inferior.
315 If REGNO is negative, do this for all registers.
316 Otherwise, REGNO specifies which register (so we can save time). */
319 fetch_inferior_registers (regno)
324 fetch_register (regno);
328 for (regno = 0; regno < ARCH_NUM_REGS; regno++)
330 fetch_register (regno);
335 /* Registers we shouldn't try to store. */
336 #if !defined (CANNOT_STORE_REGISTER)
337 #define CANNOT_STORE_REGISTER(regno) 0
340 /* Store one register. */
343 store_register (regno)
346 /* This isn't really an address. But ptrace thinks of it as one. */
348 char mess[128]; /* For messages */
350 unsigned int offset; /* Offset of registers within the u area. */
352 if (CANNOT_STORE_REGISTER (regno))
357 offset = U_REGS_OFFSET;
359 regaddr = register_addr (regno, offset);
360 for (i = 0; i < REGISTER_RAW_SIZE (regno); i += sizeof(PTRACE_XFER_TYPE))
363 ptrace (PT_WRITE_U, inferior_pid, (PTRACE_ARG3_TYPE) regaddr,
364 *(PTRACE_XFER_TYPE *) ®isters[REGISTER_BYTE (regno) + i]);
365 regaddr += sizeof (PTRACE_XFER_TYPE);
368 sprintf (mess, "writing register %s (#%d)", reg_names[regno], regno);
369 perror_with_name (mess);
374 /* Store our register values back into the inferior.
375 If REGNO is negative, do this for all registers.
376 Otherwise, REGNO specifies which register (so we can save time). */
379 store_inferior_registers (regno)
384 store_register (regno);
388 for (regno = 0; regno < ARCH_NUM_REGS; regno++)
390 store_register (regno);
394 #endif /* !defined (FETCH_INFERIOR_REGISTERS). */
397 #if !defined (CHILD_XFER_MEMORY)
398 /* NOTE! I tried using PTRACE_READDATA, etc., to read and write memory
399 in the NEW_SUN_PTRACE case.
400 It ought to be straightforward. But it appears that writing did
401 not write the data that I specified. I cannot understand where
402 it got the data that it actually did write. */
404 /* Copy LEN bytes to or from inferior's memory starting at MEMADDR
405 to debugger memory starting at MYADDR. Copy to inferior if
408 Returns the length copied, which is either the LEN argument or zero.
409 This xfer function does not do partial moves, since child_ops
410 doesn't allow memory operations to cross below us in the target stack
414 child_xfer_memory (memaddr, myaddr, len, write, target)
419 struct target_ops *target; /* ignored */
422 /* Round starting address down to longword boundary. */
423 register CORE_ADDR addr = memaddr & - sizeof (PTRACE_XFER_TYPE);
424 /* Round ending address up; get number of longwords that makes. */
426 = (((memaddr + len) - addr) + sizeof (PTRACE_XFER_TYPE) - 1)
427 / sizeof (PTRACE_XFER_TYPE);
428 /* Allocate buffer of that many longwords. */
429 register PTRACE_XFER_TYPE *buffer
430 = (PTRACE_XFER_TYPE *) alloca (count * sizeof (PTRACE_XFER_TYPE));
434 /* Fill start and end extra bytes of buffer with existing memory data. */
436 if (addr != memaddr || len < (int) sizeof (PTRACE_XFER_TYPE)) {
437 /* Need part of initial word -- fetch it. */
438 buffer[0] = ptrace (PT_READ_I, inferior_pid, (PTRACE_ARG3_TYPE) addr,
442 if (count > 1) /* FIXME, avoid if even boundary */
445 = ptrace (PT_READ_I, inferior_pid,
447 (addr + (count - 1) * sizeof (PTRACE_XFER_TYPE))),
451 /* Copy data to be written over corresponding part of buffer */
453 memcpy ((char *) buffer + (memaddr & (sizeof (PTRACE_XFER_TYPE) - 1)),
457 /* Write the entire buffer. */
459 for (i = 0; i < count; i++, addr += sizeof (PTRACE_XFER_TYPE))
462 ptrace (PT_WRITE_D, inferior_pid, (PTRACE_ARG3_TYPE) addr,
466 /* Using the appropriate one (I or D) is necessary for
467 Gould NP1, at least. */
469 ptrace (PT_WRITE_I, inferior_pid, (PTRACE_ARG3_TYPE) addr,
478 /* Read all the longwords */
479 for (i = 0; i < count; i++, addr += sizeof (PTRACE_XFER_TYPE))
482 buffer[i] = ptrace (PT_READ_I, inferior_pid,
483 (PTRACE_ARG3_TYPE) addr, 0);
489 /* Copy appropriate bytes out of the buffer. */
491 (char *) buffer + (memaddr & (sizeof (PTRACE_XFER_TYPE) - 1)),
499 udot_info (dummy1, dummy2)
503 #if defined (KERNEL_U_SIZE)
504 int udot_off; /* Offset into user struct */
505 int udot_val; /* Value from user struct at udot_off */
506 char mess[128]; /* For messages */
509 if (!target_has_execution)
511 error ("The program is not being run.");
514 #if !defined (KERNEL_U_SIZE)
516 /* Adding support for this command is easy. Typically you just add a
517 routine, called "kernel_u_size" that returns the size of the user
518 struct, to the appropriate *-nat.c file and then add to the native
519 config file "#define KERNEL_U_SIZE kernel_u_size()" */
520 error ("Don't know how large ``struct user'' is in this version of gdb.");
524 for (udot_off = 0; udot_off < KERNEL_U_SIZE; udot_off += sizeof (udot_val))
526 if ((udot_off % 24) == 0)
530 printf_filtered ("\n");
532 printf_filtered ("%04x:", udot_off);
534 udot_val = ptrace (PT_READ_U, inferior_pid, (PTRACE_ARG3_TYPE) udot_off, 0);
537 sprintf (mess, "\nreading user struct at offset 0x%x", udot_off);
538 perror_with_name (mess);
540 /* Avoid using nonportable (?) "*" in print specs */
541 printf_filtered (sizeof (int) == 4 ? " 0x%08x" : " 0x%16x", udot_val);
543 printf_filtered ("\n");
547 #endif /* !defined (CHILD_XFER_MEMORY). */
551 _initialize_infptrace ()
553 #if !defined (CHILD_XFER_MEMORY)
554 add_info ("udot", udot_info,
555 "Print contents of kernel ``struct user'' for current child.");