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.) */
126 #ifdef NO_SINGLE_STEP
127 single_step (signal);
129 ptrace (PT_STEP, inferior_pid, (PTRACE_ARG3_TYPE) 1, signal);
132 #ifdef AIX_BUGGY_PTRACE_CONTINUE
133 AIX_BUGGY_PTRACE_CONTINUE;
135 ptrace (PT_CONTINUE, inferior_pid, (PTRACE_ARG3_TYPE) 1, signal);
139 perror_with_name ("ptrace");
143 /* Nonzero if we are debugging an attached process rather than
145 extern int attach_flag;
147 /* Start debugging the process whose number is PID. */
153 ptrace (PT_ATTACH, pid, (PTRACE_ARG3_TYPE) 0, 0);
155 perror_with_name ("ptrace");
160 /* Stop debugging the process whose number is PID
161 and continue it with signal number SIGNAL.
162 SIGNAL = 0 means just continue it. */
169 ptrace (PT_DETACH, inferior_pid, (PTRACE_ARG3_TYPE) 1, signal);
171 perror_with_name ("ptrace");
174 #endif /* ATTACH_DETACH */
176 #if !defined (FETCH_INFERIOR_REGISTERS)
178 /* KERNEL_U_ADDR is the amount to subtract from u.u_ar0
179 to get the offset in the core file of the register values. */
180 #if defined (KERNEL_U_ADDR_BSD)
181 /* Get kernel_u_addr using BSD-style nlist(). */
182 CORE_ADDR kernel_u_addr;
185 _initialize_kernel_u_addr ()
187 struct nlist names[2];
189 names[0].n_un.n_name = "_u";
190 names[1].n_un.n_name = NULL;
191 if (nlist ("/vmunix", names) == 0)
192 kernel_u_addr = names[0].n_value;
194 fatal ("Unable to get kernel u area address.");
196 #endif /* KERNEL_U_ADDR_BSD. */
198 #if defined (KERNEL_U_ADDR_HPUX)
199 /* Get kernel_u_addr using HPUX-style nlist(). */
200 CORE_ADDR kernel_u_addr;
205 unsigned char n_type;
206 unsigned char n_length;
210 static struct hpnlist nl[] = {{ "_u", -1, }, { (char *) 0, }};
212 /* read the value of the u area from the hp-ux kernel */
213 void _initialize_kernel_u_addr ()
215 nlist ("/hp-ux", &nl);
216 kernel_u_addr = nl[0].n_value;
218 #endif /* KERNEL_U_ADDR_HPUX. */
220 #if !defined (offsetof)
221 #define offsetof(TYPE, MEMBER) ((unsigned long) &((TYPE *)0)->MEMBER)
224 /* U_REGS_OFFSET is the offset of the registers within the u area. */
225 #if !defined (U_REGS_OFFSET)
226 #define U_REGS_OFFSET \
227 ptrace (PT_READ_U, inferior_pid, \
228 (PTRACE_ARG3_TYPE) (offsetof (struct user, u_ar0)), 0) \
232 /* Registers we shouldn't try to fetch. */
233 #if !defined (CANNOT_FETCH_REGISTER)
234 #define CANNOT_FETCH_REGISTER(regno) 0
237 /* Fetch one register. */
240 fetch_register (regno)
243 register unsigned int regaddr;
244 char buf[MAX_REGISTER_RAW_SIZE];
245 char mess[128]; /* For messages */
248 /* Offset of registers within the u area. */
251 if (CANNOT_FETCH_REGISTER (regno))
253 bzero (buf, REGISTER_RAW_SIZE (regno)); /* Supply zeroes */
254 supply_register (regno, buf);
258 offset = U_REGS_OFFSET;
260 regaddr = register_addr (regno, offset);
261 for (i = 0; i < REGISTER_RAW_SIZE (regno); i += sizeof (int))
264 *(int *) &buf[i] = ptrace (PT_READ_U, inferior_pid,
265 (PTRACE_ARG3_TYPE) regaddr, 0);
266 regaddr += sizeof (int);
269 sprintf (mess, "reading register %s (#%d)", reg_names[regno], regno);
270 perror_with_name (mess);
273 supply_register (regno, buf);
277 /* Fetch all registers, or just one, from the child process. */
280 fetch_inferior_registers (regno)
284 for (regno = 0; regno < NUM_REGS; regno++)
285 fetch_register (regno);
287 fetch_register (regno);
290 /* Registers we shouldn't try to store. */
291 #if !defined (CANNOT_STORE_REGISTER)
292 #define CANNOT_STORE_REGISTER(regno) 0
295 /* Store our register values back into the inferior.
296 If REGNO is -1, do this for all registers.
297 Otherwise, REGNO specifies which register (so we can save time). */
300 store_inferior_registers (regno)
303 register unsigned int regaddr;
305 extern char registers[];
308 unsigned int offset = U_REGS_OFFSET;
312 regaddr = register_addr (regno, offset);
313 for (i = 0; i < REGISTER_RAW_SIZE (regno); i += sizeof(int))
316 ptrace (PT_WRITE_U, inferior_pid, (PTRACE_ARG3_TYPE) regaddr,
317 *(int *) ®isters[REGISTER_BYTE (regno) + i]);
320 sprintf (buf, "writing register number %d(%d)", regno, i);
321 perror_with_name (buf);
323 regaddr += sizeof(int);
328 for (regno = 0; regno < NUM_REGS; regno++)
330 if (CANNOT_STORE_REGISTER (regno))
332 regaddr = register_addr (regno, offset);
333 for (i = 0; i < REGISTER_RAW_SIZE (regno); i += sizeof(int))
336 ptrace (PT_WRITE_U, inferior_pid, (PTRACE_ARG3_TYPE) regaddr,
337 *(int *) ®isters[REGISTER_BYTE (regno) + i]);
340 sprintf (buf, "writing register number %d(%d)", regno, i);
341 perror_with_name (buf);
343 regaddr += sizeof(int);
348 #endif /* !defined (FETCH_INFERIOR_REGISTERS). */
350 /* NOTE! I tried using PTRACE_READDATA, etc., to read and write memory
351 in the NEW_SUN_PTRACE case.
352 It ought to be straightforward. But it appears that writing did
353 not write the data that I specified. I cannot understand where
354 it got the data that it actually did write. */
356 /* Copy LEN bytes to or from inferior's memory starting at MEMADDR
357 to debugger memory starting at MYADDR. Copy to inferior if
360 Returns the length copied, which is either the LEN argument or zero.
361 This xfer function does not do partial moves, since child_ops
362 doesn't allow memory operations to cross below us in the target stack
366 child_xfer_memory (memaddr, myaddr, len, write, target)
371 struct target_ops *target; /* ignored */
374 /* Round starting address down to longword boundary. */
375 register CORE_ADDR addr = memaddr & - sizeof (int);
376 /* Round ending address up; get number of longwords that makes. */
378 = (((memaddr + len) - addr) + sizeof (int) - 1) / sizeof (int);
379 /* Allocate buffer of that many longwords. */
380 register int *buffer = (int *) alloca (count * sizeof (int));
384 /* Fill start and end extra bytes of buffer with existing memory data. */
386 if (addr != memaddr || len < (int)sizeof (int)) {
387 /* Need part of initial word -- fetch it. */
388 buffer[0] = ptrace (PT_READ_I, inferior_pid, (PTRACE_ARG3_TYPE) addr,
392 if (count > 1) /* FIXME, avoid if even boundary */
395 = ptrace (PT_READ_I, inferior_pid,
396 (PTRACE_ARG3_TYPE) (addr + (count - 1) * sizeof (int)),
400 /* Copy data to be written over corresponding part of buffer */
402 memcpy ((char *) buffer + (memaddr & (sizeof (int) - 1)), myaddr, len);
404 /* Write the entire buffer. */
406 for (i = 0; i < count; i++, addr += sizeof (int))
409 ptrace (PT_WRITE_D, inferior_pid, (PTRACE_ARG3_TYPE) addr,
413 /* Using the appropriate one (I or D) is necessary for
414 Gould NP1, at least. */
416 ptrace (PT_WRITE_I, inferior_pid, (PTRACE_ARG3_TYPE) addr,
425 /* Read all the longwords */
426 for (i = 0; i < count; i++, addr += sizeof (int))
429 buffer[i] = ptrace (PT_READ_I, inferior_pid,
430 (PTRACE_ARG3_TYPE) addr, 0);
436 /* Copy appropriate bytes out of the buffer. */
437 memcpy (myaddr, (char *) buffer + (memaddr & (sizeof (int) - 1)), len);