1 /* Low level Unix child interface to ptrace, for GDB when running under Unix.
2 Copyright 1988, 1989, 1990, 1991, 1992 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., 675 Mass Ave, Cambridge, MA 02139, USA. */
26 #include <sys/types.h>
29 #include <sys/param.h>
32 #include <sys/ioctl.h>
34 #ifdef PTRACE_IN_WRONG_PLACE
37 #include <sys/ptrace.h>
41 #if !defined (PT_KILL)
51 #endif /* No PT_KILL. */
54 #define PT_ATTACH PTRACE_ATTACH
57 #define PT_DETACH PTRACE_DETACH
66 #if !defined (FETCH_INFERIOR_REGISTERS)
67 #include <sys/user.h> /* Probably need to poke the user structure */
68 #if defined (KERNEL_U_ADDR_BSD)
69 #include <a.out.h> /* For struct nlist */
70 #endif /* KERNEL_U_ADDR_BSD. */
71 #endif /* !FETCH_INFERIOR_REGISTERS */
74 /* This function simply calls ptrace with the given arguments.
75 It exists so that all calls to ptrace are isolated in this
76 machine-dependent file. */
78 call_ptrace (request
, pid
, addr
, data
)
80 PTRACE_ARG3_TYPE addr
;
83 return ptrace (request
, pid
, addr
, data
);
87 /* For the rest of the file, use an extra level of indirection */
88 /* This lets us breakpoint usefully on call_ptrace. */
89 #define ptrace call_ptrace
92 /* This is used when GDB is exiting. It gives less chance of error.*/
97 if (inferior_pid
== 0)
99 ptrace (PT_KILL
, inferior_pid
, (PTRACE_ARG3_TYPE
) 0, 0);
106 kill_inferior_fast ();
107 target_mourn_inferior ();
110 /* Resume execution of the inferior process.
111 If STEP is nonzero, single-step it.
112 If SIGNAL is nonzero, give it that signal. */
115 child_resume (step
, signal
)
121 /* An address of (PTRACE_ARG3_TYPE)1 tells ptrace to continue from where
122 it was. (If GDB wanted it to start some other way, we have already
123 written a new PC value to the child.)
125 If this system does not support PT_STEP, a higher level function will
126 have called single_step() to transmute the step request into a
127 continue request (by setting breakpoints on all possible successor
128 instructions), so we don't have to worry about that here. */
131 ptrace (PT_STEP
, inferior_pid
, (PTRACE_ARG3_TYPE
) 1, signal
);
133 #ifdef AIX_BUGGY_PTRACE_CONTINUE
134 AIX_BUGGY_PTRACE_CONTINUE
;
136 ptrace (PT_CONTINUE
, inferior_pid
, (PTRACE_ARG3_TYPE
) 1, signal
);
140 perror_with_name ("ptrace");
144 /* Nonzero if we are debugging an attached process rather than
146 extern int attach_flag
;
148 /* Start debugging the process whose number is PID. */
154 ptrace (PT_ATTACH
, pid
, (PTRACE_ARG3_TYPE
) 0, 0);
156 perror_with_name ("ptrace");
161 /* Stop debugging the process whose number is PID
162 and continue it with signal number SIGNAL.
163 SIGNAL = 0 means just continue it. */
170 ptrace (PT_DETACH
, inferior_pid
, (PTRACE_ARG3_TYPE
) 1, signal
);
172 perror_with_name ("ptrace");
175 #endif /* ATTACH_DETACH */
177 #if !defined (FETCH_INFERIOR_REGISTERS)
179 /* KERNEL_U_ADDR is the amount to subtract from u.u_ar0
180 to get the offset in the core file of the register values. */
181 #if defined (KERNEL_U_ADDR_BSD)
182 /* Get kernel_u_addr using BSD-style nlist(). */
183 CORE_ADDR kernel_u_addr
;
186 _initialize_kernel_u_addr ()
188 struct nlist names
[2];
190 names
[0].n_un
.n_name
= "_u";
191 names
[1].n_un
.n_name
= NULL
;
192 if (nlist ("/vmunix", names
) == 0)
193 kernel_u_addr
= names
[0].n_value
;
195 fatal ("Unable to get kernel u area address.");
197 #endif /* KERNEL_U_ADDR_BSD. */
199 #if defined (KERNEL_U_ADDR_HPUX)
200 /* Get kernel_u_addr using HPUX-style nlist(). */
201 CORE_ADDR kernel_u_addr
;
206 unsigned char n_type
;
207 unsigned char n_length
;
211 static struct hpnlist nl
[] = {{ "_u", -1, }, { (char *) 0, }};
213 /* read the value of the u area from the hp-ux kernel */
214 void _initialize_kernel_u_addr ()
216 nlist ("/hp-ux", &nl
);
217 kernel_u_addr
= nl
[0].n_value
;
219 #endif /* KERNEL_U_ADDR_HPUX. */
221 #if !defined (offsetof)
222 #define offsetof(TYPE, MEMBER) ((unsigned long) &((TYPE *)0)->MEMBER)
225 /* U_REGS_OFFSET is the offset of the registers within the u area. */
226 #if !defined (U_REGS_OFFSET)
227 #define U_REGS_OFFSET \
228 ptrace (PT_READ_U, inferior_pid, \
229 (PTRACE_ARG3_TYPE) (offsetof (struct user, u_ar0)), 0) \
233 /* Registers we shouldn't try to fetch. */
234 #if !defined (CANNOT_FETCH_REGISTER)
235 #define CANNOT_FETCH_REGISTER(regno) 0
238 /* Fetch one register. */
241 fetch_register (regno
)
244 register unsigned int regaddr
;
245 char buf
[MAX_REGISTER_RAW_SIZE
];
246 char mess
[128]; /* For messages */
249 /* Offset of registers within the u area. */
252 if (CANNOT_FETCH_REGISTER (regno
))
254 bzero (buf
, REGISTER_RAW_SIZE (regno
)); /* Supply zeroes */
255 supply_register (regno
, buf
);
259 offset
= U_REGS_OFFSET
;
261 regaddr
= register_addr (regno
, offset
);
262 for (i
= 0; i
< REGISTER_RAW_SIZE (regno
); i
+= sizeof (int))
265 *(int *) &buf
[i
] = ptrace (PT_READ_U
, inferior_pid
,
266 (PTRACE_ARG3_TYPE
) regaddr
, 0);
267 regaddr
+= sizeof (int);
270 sprintf (mess
, "reading register %s (#%d)", reg_names
[regno
], regno
);
271 perror_with_name (mess
);
274 supply_register (regno
, buf
);
278 /* Fetch all registers, or just one, from the child process. */
281 fetch_inferior_registers (regno
)
285 for (regno
= 0; regno
< NUM_REGS
; regno
++)
286 fetch_register (regno
);
288 fetch_register (regno
);
291 /* Registers we shouldn't try to store. */
292 #if !defined (CANNOT_STORE_REGISTER)
293 #define CANNOT_STORE_REGISTER(regno) 0
296 /* Store our register values back into the inferior.
297 If REGNO is -1, do this for all registers.
298 Otherwise, REGNO specifies which register (so we can save time). */
301 store_inferior_registers (regno
)
304 register unsigned int regaddr
;
306 extern char registers
[];
309 unsigned int offset
= U_REGS_OFFSET
;
313 regaddr
= register_addr (regno
, offset
);
314 for (i
= 0; i
< REGISTER_RAW_SIZE (regno
); i
+= sizeof(int))
317 ptrace (PT_WRITE_U
, inferior_pid
, (PTRACE_ARG3_TYPE
) regaddr
,
318 *(int *) ®isters
[REGISTER_BYTE (regno
) + i
]);
321 sprintf (buf
, "writing register number %d(%d)", regno
, i
);
322 perror_with_name (buf
);
324 regaddr
+= sizeof(int);
329 for (regno
= 0; regno
< NUM_REGS
; regno
++)
331 if (CANNOT_STORE_REGISTER (regno
))
333 regaddr
= register_addr (regno
, offset
);
334 for (i
= 0; i
< REGISTER_RAW_SIZE (regno
); i
+= sizeof(int))
337 ptrace (PT_WRITE_U
, inferior_pid
, (PTRACE_ARG3_TYPE
) regaddr
,
338 *(int *) ®isters
[REGISTER_BYTE (regno
) + i
]);
341 sprintf (buf
, "writing register number %d(%d)", regno
, i
);
342 perror_with_name (buf
);
344 regaddr
+= sizeof(int);
349 #endif /* !defined (FETCH_INFERIOR_REGISTERS). */
351 /* NOTE! I tried using PTRACE_READDATA, etc., to read and write memory
352 in the NEW_SUN_PTRACE case.
353 It ought to be straightforward. But it appears that writing did
354 not write the data that I specified. I cannot understand where
355 it got the data that it actually did write. */
357 /* Copy LEN bytes to or from inferior's memory starting at MEMADDR
358 to debugger memory starting at MYADDR. Copy to inferior if
361 Returns the length copied, which is either the LEN argument or zero.
362 This xfer function does not do partial moves, since child_ops
363 doesn't allow memory operations to cross below us in the target stack
367 child_xfer_memory (memaddr
, myaddr
, len
, write
, target
)
372 struct target_ops
*target
; /* ignored */
375 /* Round starting address down to longword boundary. */
376 register CORE_ADDR addr
= memaddr
& - sizeof (int);
377 /* Round ending address up; get number of longwords that makes. */
379 = (((memaddr
+ len
) - addr
) + sizeof (int) - 1) / sizeof (int);
380 /* Allocate buffer of that many longwords. */
381 register int *buffer
= (int *) alloca (count
* sizeof (int));
385 /* Fill start and end extra bytes of buffer with existing memory data. */
387 if (addr
!= memaddr
|| len
< (int)sizeof (int)) {
388 /* Need part of initial word -- fetch it. */
389 buffer
[0] = ptrace (PT_READ_I
, inferior_pid
, (PTRACE_ARG3_TYPE
) addr
,
393 if (count
> 1) /* FIXME, avoid if even boundary */
396 = ptrace (PT_READ_I
, inferior_pid
,
397 (PTRACE_ARG3_TYPE
) (addr
+ (count
- 1) * sizeof (int)),
401 /* Copy data to be written over corresponding part of buffer */
403 memcpy ((char *) buffer
+ (memaddr
& (sizeof (int) - 1)), myaddr
, len
);
405 /* Write the entire buffer. */
407 for (i
= 0; i
< count
; i
++, addr
+= sizeof (int))
410 ptrace (PT_WRITE_D
, inferior_pid
, (PTRACE_ARG3_TYPE
) addr
,
414 /* Using the appropriate one (I or D) is necessary for
415 Gould NP1, at least. */
417 ptrace (PT_WRITE_I
, inferior_pid
, (PTRACE_ARG3_TYPE
) addr
,
426 /* Read all the longwords */
427 for (i
= 0; i
< count
; i
++, addr
+= sizeof (int))
430 buffer
[i
] = ptrace (PT_READ_I
, inferior_pid
,
431 (PTRACE_ARG3_TYPE
) addr
, 0);
437 /* Copy appropriate bytes out of the buffer. */
438 memcpy (myaddr
, (char *) buffer
+ (memaddr
& (sizeof (int) - 1)), len
);