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,
3 1998, 1999, 2000, 2001, 2002
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., 59 Temple Place - Suite 330,
21 Boston, MA 02111-1307, USA. */
27 #include "gdb_string.h"
35 #include <sys/types.h>
38 #include <sys/param.h>
39 #include "gdb_dirent.h"
41 #include <sys/ioctl.h>
46 #ifdef HAVE_SYS_PTRACE_H
47 #include <sys/ptrace.h>
51 #if !defined (PT_READ_I)
52 #define PT_READ_I 1 /* Read word from text space */
54 #if !defined (PT_READ_D)
55 #define PT_READ_D 2 /* Read word from data space */
57 #if !defined (PT_READ_U)
58 #define PT_READ_U 3 /* Read word from kernel user struct */
60 #if !defined (PT_WRITE_I)
61 #define PT_WRITE_I 4 /* Write word to text space */
63 #if !defined (PT_WRITE_D)
64 #define PT_WRITE_D 5 /* Write word to data space */
66 #if !defined (PT_WRITE_U)
67 #define PT_WRITE_U 6 /* Write word to kernel user struct */
69 #if !defined (PT_CONTINUE)
70 #define PT_CONTINUE 7 /* Continue after signal */
72 #if !defined (PT_STEP)
73 #define PT_STEP 9 /* Set flag for single stepping */
75 #if !defined (PT_KILL)
76 #define PT_KILL 8 /* Send child a SIGKILL signal */
80 #define PT_ATTACH PTRACE_ATTACH
83 #define PT_DETACH PTRACE_DETACH
91 /* Don't think this is used anymore. On the sequent (not sure whether it's
92 dynix or ptx or both), it is included unconditionally by sys/user.h and
93 not protected against multiple inclusion. */
97 #if !defined (FETCH_INFERIOR_REGISTERS)
98 #include <sys/user.h> /* Probably need to poke the user structure */
99 #if defined (KERNEL_U_ADDR_BSD)
100 #include <a.out.h> /* For struct nlist */
101 #endif /* KERNEL_U_ADDR_BSD. */
102 #endif /* !FETCH_INFERIOR_REGISTERS */
104 #if !defined (CHILD_XFER_MEMORY)
105 static void udot_info (char *, int);
108 #if !defined (FETCH_INFERIOR_REGISTERS)
109 static void fetch_register (int);
110 static void store_register (int);
113 void _initialize_kernel_u_addr (void);
114 void _initialize_infptrace (void);
117 /* This function simply calls ptrace with the given arguments.
118 It exists so that all calls to ptrace are isolated in this
119 machine-dependent file. */
121 call_ptrace (int request
, int pid
, PTRACE_ARG3_TYPE addr
, int data
)
128 printf ("call_ptrace(request=%d, pid=%d, addr=0x%x, data=0x%x)",
129 request
, pid
, addr
, data
);
131 #if defined(PT_SETTRC)
132 /* If the parent can be told to attach to us, try to do it. */
133 if (request
== PT_SETTRC
)
136 #if !defined (FIVE_ARG_PTRACE)
137 pt_status
= ptrace (PT_SETTRC
, pid
, addr
, data
);
139 /* Deal with HPUX 8.0 braindamage. We never use the
140 calls which require the fifth argument. */
141 pt_status
= ptrace (PT_SETTRC
, pid
, addr
, data
, 0);
144 perror_with_name ("ptrace");
146 printf (" = %d\n", pt_status
);
151 return parent_attach_all (pid
, addr
, data
);
155 #if defined(PT_CONTIN1)
156 /* On HPUX, PT_CONTIN1 is a form of continue that preserves pending
157 signals. If it's available, use it. */
158 if (request
== PT_CONTINUE
)
159 request
= PT_CONTIN1
;
162 #if defined(PT_SINGLE1)
163 /* On HPUX, PT_SINGLE1 is a form of step that preserves pending
164 signals. If it's available, use it. */
165 if (request
== PT_STEP
)
166 request
= PT_SINGLE1
;
173 #if !defined (FIVE_ARG_PTRACE)
174 pt_status
= ptrace (request
, pid
, addr
, data
);
176 /* Deal with HPUX 8.0 braindamage. We never use the
177 calls which require the fifth argument. */
178 pt_status
= ptrace (request
, pid
, addr
, data
, 0);
183 printf (" [errno = %d]", errno
);
186 printf (" = 0x%x\n", pt_status
);
192 #if defined (DEBUG_PTRACE) || defined (FIVE_ARG_PTRACE)
193 /* For the rest of the file, use an extra level of indirection */
194 /* This lets us breakpoint usefully on call_ptrace. */
195 #define ptrace call_ptrace
198 /* Wait for a process to finish, possibly running a target-specific
199 hook before returning. */
202 ptrace_wait (ptid_t ptid
, int *status
)
206 wstate
= wait (status
);
207 target_post_wait (pid_to_ptid (wstate
), *status
);
211 #ifndef KILL_INFERIOR
216 int pid
= PIDGET (inferior_ptid
);
221 /* This once used to call "kill" to kill the inferior just in case
222 the inferior was still running. As others have noted in the past
223 (kingdon) there shouldn't be any way to get here if the inferior
224 is still running -- else there's a major problem elsewere in gdb
225 and it needs to be fixed.
227 The kill call causes problems under hpux10, so it's been removed;
228 if this causes problems we'll deal with them as they arise. */
229 ptrace (PT_KILL
, pid
, (PTRACE_ARG3_TYPE
) 0, 0);
230 ptrace_wait (null_ptid
, &status
);
231 target_mourn_inferior ();
233 #endif /* KILL_INFERIOR */
237 /* Resume execution of the inferior process.
238 If STEP is nonzero, single-step it.
239 If SIGNAL is nonzero, give it that signal. */
242 child_resume (ptid_t ptid
, int step
, enum target_signal signal
)
244 int pid
= PIDGET (ptid
);
249 /* Resume all threads. */
250 /* I think this only gets used in the non-threaded case, where "resume
251 all threads" and "resume inferior_ptid" are the same. */
252 pid
= PIDGET (inferior_ptid
);
254 /* An address of (PTRACE_ARG3_TYPE)1 tells ptrace to continue from where
255 it was. (If GDB wanted it to start some other way, we have already
256 written a new PC value to the child.)
258 If this system does not support PT_STEP, a higher level function will
259 have called single_step() to transmute the step request into a
260 continue request (by setting breakpoints on all possible successor
261 instructions), so we don't have to worry about that here. */
265 if (SOFTWARE_SINGLE_STEP_P ())
266 internal_error (__FILE__
, __LINE__
, "failed internal consistency check"); /* Make sure this doesn't happen. */
268 ptrace (PT_STEP
, pid
, (PTRACE_ARG3_TYPE
) 1,
269 target_signal_to_host (signal
));
272 ptrace (PT_CONTINUE
, pid
, (PTRACE_ARG3_TYPE
) 1,
273 target_signal_to_host (signal
));
277 perror_with_name ("ptrace");
280 #endif /* CHILD_RESUME */
284 /* Start debugging the process whose number is PID. */
289 ptrace (PT_ATTACH
, pid
, (PTRACE_ARG3_TYPE
) 0, 0);
291 perror_with_name ("ptrace");
296 /* Stop debugging the process whose number is PID
297 and continue it with signal number SIGNAL.
298 SIGNAL = 0 means just continue it. */
304 ptrace (PT_DETACH
, PIDGET (inferior_ptid
), (PTRACE_ARG3_TYPE
) 1,
307 print_sys_errmsg ("ptrace", errno
);
310 #endif /* ATTACH_DETACH */
312 /* Default the type of the ptrace transfer to int. */
313 #ifndef PTRACE_XFER_TYPE
314 #define PTRACE_XFER_TYPE int
317 /* KERNEL_U_ADDR is the amount to subtract from u.u_ar0
318 to get the offset in the core file of the register values. */
319 #if defined (KERNEL_U_ADDR_BSD) && !defined (FETCH_INFERIOR_REGISTERS)
320 /* Get kernel_u_addr using BSD-style nlist(). */
321 CORE_ADDR kernel_u_addr
;
322 #endif /* KERNEL_U_ADDR_BSD. */
325 _initialize_kernel_u_addr (void)
327 #if defined (KERNEL_U_ADDR_BSD) && !defined (FETCH_INFERIOR_REGISTERS)
328 struct nlist names
[2];
330 names
[0].n_un
.n_name
= "_u";
331 names
[1].n_un
.n_name
= NULL
;
332 if (nlist ("/vmunix", names
) == 0)
333 kernel_u_addr
= names
[0].n_value
;
335 internal_error (__FILE__
, __LINE__
,
336 "Unable to get kernel u area address.");
337 #endif /* KERNEL_U_ADDR_BSD. */
340 #if !defined (FETCH_INFERIOR_REGISTERS)
342 #if !defined (offsetof)
343 #define offsetof(TYPE, MEMBER) ((unsigned long) &((TYPE *)0)->MEMBER)
346 /* U_REGS_OFFSET is the offset of the registers within the u area. */
347 #if !defined (U_REGS_OFFSET)
348 #define U_REGS_OFFSET \
349 ptrace (PT_READ_U, PIDGET (inferior_ptid), \
350 (PTRACE_ARG3_TYPE) (offsetof (struct user, u_ar0)), 0) \
354 /* Fetch one register. */
357 fetch_register (int regno
)
359 /* This isn't really an address. But ptrace thinks of it as one. */
361 char mess
[128]; /* For messages */
363 unsigned int offset
; /* Offset of registers within the u area. */
364 char buf
[MAX_REGISTER_SIZE
];
367 if (CANNOT_FETCH_REGISTER (regno
))
369 memset (buf
, '\0', DEPRECATED_REGISTER_RAW_SIZE (regno
)); /* Supply zeroes */
370 supply_register (regno
, buf
);
374 /* Overload thread id onto process id */
375 if ((tid
= TIDGET (inferior_ptid
)) == 0)
376 tid
= PIDGET (inferior_ptid
); /* no thread id, just use process id */
378 offset
= U_REGS_OFFSET
;
380 regaddr
= register_addr (regno
, offset
);
381 for (i
= 0; i
< DEPRECATED_REGISTER_RAW_SIZE (regno
); i
+= sizeof (PTRACE_XFER_TYPE
))
384 *(PTRACE_XFER_TYPE
*) & buf
[i
] = ptrace (PT_READ_U
, tid
,
385 (PTRACE_ARG3_TYPE
) regaddr
, 0);
386 regaddr
+= sizeof (PTRACE_XFER_TYPE
);
389 sprintf (mess
, "reading register %s (#%d)",
390 REGISTER_NAME (regno
), regno
);
391 perror_with_name (mess
);
394 supply_register (regno
, buf
);
398 /* Fetch register values from the inferior.
399 If REGNO is negative, do this for all registers.
400 Otherwise, REGNO specifies which register (so we can save time). */
403 fetch_inferior_registers (int regno
)
407 fetch_register (regno
);
411 for (regno
= 0; regno
< NUM_REGS
; regno
++)
413 fetch_register (regno
);
418 /* Store one register. */
421 store_register (int regno
)
423 /* This isn't really an address. But ptrace thinks of it as one. */
425 char mess
[128]; /* For messages */
427 unsigned int offset
; /* Offset of registers within the u area. */
429 char buf
[MAX_REGISTER_SIZE
];
431 if (CANNOT_STORE_REGISTER (regno
))
436 /* Overload thread id onto process id */
437 if ((tid
= TIDGET (inferior_ptid
)) == 0)
438 tid
= PIDGET (inferior_ptid
); /* no thread id, just use process id */
440 offset
= U_REGS_OFFSET
;
442 regaddr
= register_addr (regno
, offset
);
444 /* Put the contents of regno into a local buffer */
445 regcache_collect (regno
, buf
);
447 /* Store the local buffer into the inferior a chunk at the time. */
448 for (i
= 0; i
< DEPRECATED_REGISTER_RAW_SIZE (regno
); i
+= sizeof (PTRACE_XFER_TYPE
))
451 ptrace (PT_WRITE_U
, tid
, (PTRACE_ARG3_TYPE
) regaddr
,
452 *(PTRACE_XFER_TYPE
*) (buf
+ i
));
453 regaddr
+= sizeof (PTRACE_XFER_TYPE
);
456 sprintf (mess
, "writing register %s (#%d)",
457 REGISTER_NAME (regno
), regno
);
458 perror_with_name (mess
);
463 /* Store our register values back into the inferior.
464 If REGNO is negative, do this for all registers.
465 Otherwise, REGNO specifies which register (so we can save time). */
468 store_inferior_registers (int regno
)
472 store_register (regno
);
476 for (regno
= 0; regno
< NUM_REGS
; regno
++)
478 store_register (regno
);
482 #endif /* !defined (FETCH_INFERIOR_REGISTERS). */
485 /* Set an upper limit on alloca. */
486 #ifndef GDB_MAX_ALLOCA
487 #define GDB_MAX_ALLOCA 0x1000
490 #if !defined (CHILD_XFER_MEMORY)
491 /* NOTE! I tried using PTRACE_READDATA, etc., to read and write memory
492 in the NEW_SUN_PTRACE case. It ought to be straightforward. But
493 it appears that writing did not write the data that I specified. I
494 cannot understand where it got the data that it actually did write. */
496 /* Copy LEN bytes to or from inferior's memory starting at MEMADDR to
497 debugger memory starting at MYADDR. Copy to inferior if WRITE is
498 nonzero. TARGET is ignored.
500 Returns the length copied, which is either the LEN argument or
501 zero. This xfer function does not do partial moves, since
502 child_ops doesn't allow memory operations to cross below us in the
503 target stack anyway. */
506 child_xfer_memory (CORE_ADDR memaddr
, char *myaddr
, int len
, int write
,
507 struct mem_attrib
*attrib
, struct target_ops
*target
)
510 /* Round starting address down to longword boundary. */
511 CORE_ADDR addr
= memaddr
& -(CORE_ADDR
) sizeof (PTRACE_XFER_TYPE
);
512 /* Round ending address up; get number of longwords that makes. */
513 int count
= ((((memaddr
+ len
) - addr
) + sizeof (PTRACE_XFER_TYPE
) - 1)
514 / sizeof (PTRACE_XFER_TYPE
));
515 int alloc
= count
* sizeof (PTRACE_XFER_TYPE
);
516 PTRACE_XFER_TYPE
*buffer
;
517 struct cleanup
*old_chain
= NULL
;
520 /* OpenBSD 3.1, NetBSD 1.6 and FreeBSD 5.0 have a new PT_IO request
521 that promises to be much more efficient in reading and writing
522 data in the traced process's address space. */
525 struct ptrace_io_desc piod
;
527 /* NOTE: We assume that there are no distinct address spaces for
528 instruction and data. */
529 piod
.piod_op
= write
? PIOD_WRITE_D
: PIOD_READ_D
;
530 piod
.piod_offs
= (void *) memaddr
;
531 piod
.piod_addr
= myaddr
;
534 if (ptrace (PT_IO
, PIDGET (inferior_ptid
), (caddr_t
) &piod
, 0) == -1)
536 /* If the PT_IO request is somehow not supported, fallback on
537 using PT_WRITE_D/PT_READ_D. Otherwise we will return zero
538 to indicate failure. */
544 /* Return the actual number of bytes read or written. */
545 return piod
.piod_len
;
550 /* Allocate buffer of that many longwords. */
551 if (len
< GDB_MAX_ALLOCA
)
553 buffer
= (PTRACE_XFER_TYPE
*) alloca (alloc
);
557 buffer
= (PTRACE_XFER_TYPE
*) xmalloc (alloc
);
558 old_chain
= make_cleanup (xfree
, buffer
);
563 /* Fill start and end extra bytes of buffer with existing memory
565 if (addr
!= memaddr
|| len
< (int) sizeof (PTRACE_XFER_TYPE
))
567 /* Need part of initial word -- fetch it. */
568 buffer
[0] = ptrace (PT_READ_I
, PIDGET (inferior_ptid
),
569 (PTRACE_ARG3_TYPE
) addr
, 0);
572 if (count
> 1) /* FIXME, avoid if even boundary. */
575 ptrace (PT_READ_I
, PIDGET (inferior_ptid
),
577 (addr
+ (count
- 1) * sizeof (PTRACE_XFER_TYPE
))), 0);
580 /* Copy data to be written over corresponding part of buffer. */
581 memcpy ((char *) buffer
+ (memaddr
& (sizeof (PTRACE_XFER_TYPE
) - 1)),
584 /* Write the entire buffer. */
585 for (i
= 0; i
< count
; i
++, addr
+= sizeof (PTRACE_XFER_TYPE
))
588 ptrace (PT_WRITE_D
, PIDGET (inferior_ptid
),
589 (PTRACE_ARG3_TYPE
) addr
, buffer
[i
]);
592 /* Using the appropriate one (I or D) is necessary for
593 Gould NP1, at least. */
595 ptrace (PT_WRITE_I
, PIDGET (inferior_ptid
),
596 (PTRACE_ARG3_TYPE
) addr
, buffer
[i
]);
601 #ifdef CLEAR_INSN_CACHE
607 /* Read all the longwords. */
608 for (i
= 0; i
< count
; i
++, addr
+= sizeof (PTRACE_XFER_TYPE
))
611 buffer
[i
] = ptrace (PT_READ_I
, PIDGET (inferior_ptid
),
612 (PTRACE_ARG3_TYPE
) addr
, 0);
618 /* Copy appropriate bytes out of the buffer. */
620 (char *) buffer
+ (memaddr
& (sizeof (PTRACE_XFER_TYPE
) - 1)),
624 if (old_chain
!= NULL
)
625 do_cleanups (old_chain
);
631 udot_info (char *dummy1
, int dummy2
)
633 #if defined (KERNEL_U_SIZE)
634 long udot_off
; /* Offset into user struct */
635 int udot_val
; /* Value from user struct at udot_off */
636 char mess
[128]; /* For messages */
639 if (!target_has_execution
)
641 error ("The program is not being run.");
644 #if !defined (KERNEL_U_SIZE)
646 /* Adding support for this command is easy. Typically you just add a
647 routine, called "kernel_u_size" that returns the size of the user
648 struct, to the appropriate *-nat.c file and then add to the native
649 config file "#define KERNEL_U_SIZE kernel_u_size()" */
650 error ("Don't know how large ``struct user'' is in this version of gdb.");
654 for (udot_off
= 0; udot_off
< KERNEL_U_SIZE
; udot_off
+= sizeof (udot_val
))
656 if ((udot_off
% 24) == 0)
660 printf_filtered ("\n");
662 printf_filtered ("%s:", paddr (udot_off
));
664 udot_val
= ptrace (PT_READ_U
, PIDGET (inferior_ptid
), (PTRACE_ARG3_TYPE
) udot_off
, 0);
667 sprintf (mess
, "\nreading user struct at offset 0x%s",
668 paddr_nz (udot_off
));
669 perror_with_name (mess
);
671 /* Avoid using nonportable (?) "*" in print specs */
672 printf_filtered (sizeof (int) == 4 ? " 0x%08x" : " 0x%16x", udot_val
);
674 printf_filtered ("\n");
678 #endif /* !defined (CHILD_XFER_MEMORY). */
682 _initialize_infptrace (void)
684 #if !defined (CHILD_XFER_MEMORY)
685 add_info ("udot", udot_info
,
686 "Print contents of kernel ``struct user'' for current child.");
This page took 0.044493 seconds and 4 git commands to generate.