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, 1998,
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);
114 * Some systems (Linux) may have threads implemented as pseudo-processes,
115 * in which case we may be tracing more than one process at a time.
116 * In that case, inferior_pid will contain the main process ID and the
117 * individual thread (process) id mashed together. These macros are
118 * used to separate them out. The definitions may be overridden in tm.h
120 * NOTE: default definitions here are for systems with no threads.
121 * Useful definitions MUST be provided in tm.h
124 #if !defined (PIDGET) /* Default definition for PIDGET/TIDGET. */
125 #define PIDGET(PID) PID
126 #define TIDGET(PID) 0
129 void _initialize_kernel_u_addr (void);
130 void _initialize_infptrace (void);
133 /* This function simply calls ptrace with the given arguments.
134 It exists so that all calls to ptrace are isolated in this
135 machine-dependent file. */
137 call_ptrace (int request
, int pid
, PTRACE_ARG3_TYPE addr
, int data
)
144 printf ("call_ptrace(request=%d, pid=%d, addr=0x%x, data=0x%x)",
145 request
, pid
, addr
, data
);
147 #if defined(PT_SETTRC)
148 /* If the parent can be told to attach to us, try to do it. */
149 if (request
== PT_SETTRC
)
152 #if !defined (FIVE_ARG_PTRACE)
153 pt_status
= ptrace (PT_SETTRC
, pid
, addr
, data
);
155 /* Deal with HPUX 8.0 braindamage. We never use the
156 calls which require the fifth argument. */
157 pt_status
= ptrace (PT_SETTRC
, pid
, addr
, data
, 0);
160 perror_with_name ("ptrace");
162 printf (" = %d\n", pt_status
);
167 return parent_attach_all (pid
, addr
, data
);
171 #if defined(PT_CONTIN1)
172 /* On HPUX, PT_CONTIN1 is a form of continue that preserves pending
173 signals. If it's available, use it. */
174 if (request
== PT_CONTINUE
)
175 request
= PT_CONTIN1
;
178 #if defined(PT_SINGLE1)
179 /* On HPUX, PT_SINGLE1 is a form of step that preserves pending
180 signals. If it's available, use it. */
181 if (request
== PT_STEP
)
182 request
= PT_SINGLE1
;
189 #if !defined (FIVE_ARG_PTRACE)
190 pt_status
= ptrace (request
, pid
, addr
, data
);
192 /* Deal with HPUX 8.0 braindamage. We never use the
193 calls which require the fifth argument. */
194 pt_status
= ptrace (request
, pid
, addr
, data
, 0);
199 printf (" [errno = %d]", errno
);
202 printf (" = 0x%x\n", pt_status
);
208 #if defined (DEBUG_PTRACE) || defined (FIVE_ARG_PTRACE)
209 /* For the rest of the file, use an extra level of indirection */
210 /* This lets us breakpoint usefully on call_ptrace. */
211 #define ptrace call_ptrace
214 /* Wait for a process to finish, possibly running a target-specific
215 hook before returning. */
218 ptrace_wait (ptid_t ptid
, int *status
)
222 wstate
= wait (status
);
223 target_post_wait (pid_to_ptid (wstate
), *status
);
231 int pid
= PIDGET (inferior_ptid
);
236 /* This once used to call "kill" to kill the inferior just in case
237 the inferior was still running. As others have noted in the past
238 (kingdon) there shouldn't be any way to get here if the inferior
239 is still running -- else there's a major problem elsewere in gdb
240 and it needs to be fixed.
242 The kill call causes problems under hpux10, so it's been removed;
243 if this causes problems we'll deal with them as they arise. */
244 ptrace (PT_KILL
, pid
, (PTRACE_ARG3_TYPE
) 0, 0);
245 ptrace_wait (null_ptid
, &status
);
246 target_mourn_inferior ();
251 /* Resume execution of the inferior process.
252 If STEP is nonzero, single-step it.
253 If SIGNAL is nonzero, give it that signal. */
256 child_resume (ptid_t ptid
, int step
, enum target_signal signal
)
258 int pid
= PIDGET (ptid
);
263 /* Resume all threads. */
264 /* I think this only gets used in the non-threaded case, where "resume
265 all threads" and "resume inferior_ptid" are the same. */
266 pid
= PIDGET (inferior_ptid
);
268 /* An address of (PTRACE_ARG3_TYPE)1 tells ptrace to continue from where
269 it was. (If GDB wanted it to start some other way, we have already
270 written a new PC value to the child.)
272 If this system does not support PT_STEP, a higher level function will
273 have called single_step() to transmute the step request into a
274 continue request (by setting breakpoints on all possible successor
275 instructions), so we don't have to worry about that here. */
279 if (SOFTWARE_SINGLE_STEP_P ())
280 internal_error (__FILE__
, __LINE__
, "failed internal consistency check"); /* Make sure this doesn't happen. */
282 ptrace (PT_STEP
, pid
, (PTRACE_ARG3_TYPE
) 1,
283 target_signal_to_host (signal
));
286 ptrace (PT_CONTINUE
, pid
, (PTRACE_ARG3_TYPE
) 1,
287 target_signal_to_host (signal
));
291 perror_with_name ("ptrace");
294 #endif /* CHILD_RESUME */
298 /* Start debugging the process whose number is PID. */
303 ptrace (PT_ATTACH
, pid
, (PTRACE_ARG3_TYPE
) 0, 0);
305 perror_with_name ("ptrace");
310 /* Stop debugging the process whose number is PID
311 and continue it with signal number SIGNAL.
312 SIGNAL = 0 means just continue it. */
318 ptrace (PT_DETACH
, PIDGET (inferior_ptid
), (PTRACE_ARG3_TYPE
) 1,
321 perror_with_name ("ptrace");
324 #endif /* ATTACH_DETACH */
326 /* Default the type of the ptrace transfer to int. */
327 #ifndef PTRACE_XFER_TYPE
328 #define PTRACE_XFER_TYPE int
331 /* KERNEL_U_ADDR is the amount to subtract from u.u_ar0
332 to get the offset in the core file of the register values. */
333 #if defined (KERNEL_U_ADDR_BSD) && !defined (FETCH_INFERIOR_REGISTERS)
334 /* Get kernel_u_addr using BSD-style nlist(). */
335 CORE_ADDR kernel_u_addr
;
336 #endif /* KERNEL_U_ADDR_BSD. */
339 _initialize_kernel_u_addr (void)
341 #if defined (KERNEL_U_ADDR_BSD) && !defined (FETCH_INFERIOR_REGISTERS)
342 struct nlist names
[2];
344 names
[0].n_un
.n_name
= "_u";
345 names
[1].n_un
.n_name
= NULL
;
346 if (nlist ("/vmunix", names
) == 0)
347 kernel_u_addr
= names
[0].n_value
;
349 internal_error (__FILE__
, __LINE__
,
350 "Unable to get kernel u area address.");
351 #endif /* KERNEL_U_ADDR_BSD. */
354 #if !defined (FETCH_INFERIOR_REGISTERS)
356 #if !defined (offsetof)
357 #define offsetof(TYPE, MEMBER) ((unsigned long) &((TYPE *)0)->MEMBER)
360 /* U_REGS_OFFSET is the offset of the registers within the u area. */
361 #if !defined (U_REGS_OFFSET)
362 #define U_REGS_OFFSET \
363 ptrace (PT_READ_U, PIDGET (inferior_ptid), \
364 (PTRACE_ARG3_TYPE) (offsetof (struct user, u_ar0)), 0) \
368 /* Registers we shouldn't try to fetch. */
369 #if !defined (CANNOT_FETCH_REGISTER)
370 #define CANNOT_FETCH_REGISTER(regno) 0
373 /* Fetch one register. */
376 fetch_register (int regno
)
378 /* This isn't really an address. But ptrace thinks of it as one. */
380 char mess
[128]; /* For messages */
382 unsigned int offset
; /* Offset of registers within the u area. */
383 char buf
[MAX_REGISTER_RAW_SIZE
];
386 if (CANNOT_FETCH_REGISTER (regno
))
388 memset (buf
, '\0', REGISTER_RAW_SIZE (regno
)); /* Supply zeroes */
389 supply_register (regno
, buf
);
393 /* Overload thread id onto process id */
394 if ((tid
= TIDGET (inferior_ptid
)) == 0)
395 tid
= PIDGET (inferior_ptid
); /* no thread id, just use process id */
397 offset
= U_REGS_OFFSET
;
399 regaddr
= register_addr (regno
, offset
);
400 for (i
= 0; i
< REGISTER_RAW_SIZE (regno
); i
+= sizeof (PTRACE_XFER_TYPE
))
403 *(PTRACE_XFER_TYPE
*) & buf
[i
] = ptrace (PT_READ_U
, tid
,
404 (PTRACE_ARG3_TYPE
) regaddr
, 0);
405 regaddr
+= sizeof (PTRACE_XFER_TYPE
);
408 sprintf (mess
, "reading register %s (#%d)",
409 REGISTER_NAME (regno
), regno
);
410 perror_with_name (mess
);
413 supply_register (regno
, buf
);
417 /* Fetch register values from the inferior.
418 If REGNO is negative, do this for all registers.
419 Otherwise, REGNO specifies which register (so we can save time). */
422 fetch_inferior_registers (int regno
)
426 fetch_register (regno
);
430 for (regno
= 0; regno
< NUM_REGS
; regno
++)
432 fetch_register (regno
);
437 /* Registers we shouldn't try to store. */
438 #if !defined (CANNOT_STORE_REGISTER)
439 #define CANNOT_STORE_REGISTER(regno) 0
442 /* Store one register. */
445 store_register (int regno
)
447 /* This isn't really an address. But ptrace thinks of it as one. */
449 char mess
[128]; /* For messages */
451 unsigned int offset
; /* Offset of registers within the u area. */
454 if (CANNOT_STORE_REGISTER (regno
))
459 /* Overload thread id onto process id */
460 if ((tid
= TIDGET (inferior_ptid
)) == 0)
461 tid
= PIDGET (inferior_ptid
); /* no thread id, just use process id */
463 offset
= U_REGS_OFFSET
;
465 regaddr
= register_addr (regno
, offset
);
466 for (i
= 0; i
< REGISTER_RAW_SIZE (regno
); i
+= sizeof (PTRACE_XFER_TYPE
))
469 ptrace (PT_WRITE_U
, tid
, (PTRACE_ARG3_TYPE
) regaddr
,
470 *(PTRACE_XFER_TYPE
*) & registers
[REGISTER_BYTE (regno
) + i
]);
471 regaddr
+= sizeof (PTRACE_XFER_TYPE
);
474 sprintf (mess
, "writing register %s (#%d)",
475 REGISTER_NAME (regno
), regno
);
476 perror_with_name (mess
);
481 /* Store our register values back into the inferior.
482 If REGNO is negative, do this for all registers.
483 Otherwise, REGNO specifies which register (so we can save time). */
486 store_inferior_registers (int regno
)
490 store_register (regno
);
494 for (regno
= 0; regno
< NUM_REGS
; regno
++)
496 store_register (regno
);
500 #endif /* !defined (FETCH_INFERIOR_REGISTERS). */
503 #if !defined (CHILD_XFER_MEMORY)
504 /* NOTE! I tried using PTRACE_READDATA, etc., to read and write memory
505 in the NEW_SUN_PTRACE case.
506 It ought to be straightforward. But it appears that writing did
507 not write the data that I specified. I cannot understand where
508 it got the data that it actually did write. */
510 /* Copy LEN bytes to or from inferior's memory starting at MEMADDR
511 to debugger memory starting at MYADDR. Copy to inferior if
512 WRITE is nonzero. TARGET is ignored.
514 Returns the length copied, which is either the LEN argument or zero.
515 This xfer function does not do partial moves, since child_ops
516 doesn't allow memory operations to cross below us in the target stack
520 child_xfer_memory (CORE_ADDR memaddr
, char *myaddr
, int len
, int write
,
521 struct mem_attrib
*attrib ATTRIBUTE_UNUSED
,
522 struct target_ops
*target
)
525 /* Round starting address down to longword boundary. */
526 register CORE_ADDR addr
= memaddr
& -sizeof (PTRACE_XFER_TYPE
);
527 /* Round ending address up; get number of longwords that makes. */
529 = (((memaddr
+ len
) - addr
) + sizeof (PTRACE_XFER_TYPE
) - 1)
530 / sizeof (PTRACE_XFER_TYPE
);
531 /* Allocate buffer of that many longwords. */
532 register PTRACE_XFER_TYPE
*buffer
533 = (PTRACE_XFER_TYPE
*) alloca (count
* sizeof (PTRACE_XFER_TYPE
));
537 /* Fill start and end extra bytes of buffer with existing memory data. */
539 if (addr
!= memaddr
|| len
< (int) sizeof (PTRACE_XFER_TYPE
))
541 /* Need part of initial word -- fetch it. */
542 buffer
[0] = ptrace (PT_READ_I
, PIDGET (inferior_ptid
),
543 (PTRACE_ARG3_TYPE
) addr
, 0);
546 if (count
> 1) /* FIXME, avoid if even boundary */
549 = ptrace (PT_READ_I
, PIDGET (inferior_ptid
),
551 (addr
+ (count
- 1) * sizeof (PTRACE_XFER_TYPE
))),
555 /* Copy data to be written over corresponding part of buffer */
557 memcpy ((char *) buffer
+ (memaddr
& (sizeof (PTRACE_XFER_TYPE
) - 1)),
561 /* Write the entire buffer. */
563 for (i
= 0; i
< count
; i
++, addr
+= sizeof (PTRACE_XFER_TYPE
))
566 ptrace (PT_WRITE_D
, PIDGET (inferior_ptid
),
567 (PTRACE_ARG3_TYPE
) addr
, buffer
[i
]);
570 /* Using the appropriate one (I or D) is necessary for
571 Gould NP1, at least. */
573 ptrace (PT_WRITE_I
, PIDGET (inferior_ptid
),
574 (PTRACE_ARG3_TYPE
) addr
, buffer
[i
]);
579 #ifdef CLEAR_INSN_CACHE
585 /* Read all the longwords */
586 for (i
= 0; i
< count
; i
++, addr
+= sizeof (PTRACE_XFER_TYPE
))
589 buffer
[i
] = ptrace (PT_READ_I
, PIDGET (inferior_ptid
),
590 (PTRACE_ARG3_TYPE
) addr
, 0);
596 /* Copy appropriate bytes out of the buffer. */
598 (char *) buffer
+ (memaddr
& (sizeof (PTRACE_XFER_TYPE
) - 1)),
606 udot_info (char *dummy1
, int dummy2
)
608 #if defined (KERNEL_U_SIZE)
609 int udot_off
; /* Offset into user struct */
610 int udot_val
; /* Value from user struct at udot_off */
611 char mess
[128]; /* For messages */
614 if (!target_has_execution
)
616 error ("The program is not being run.");
619 #if !defined (KERNEL_U_SIZE)
621 /* Adding support for this command is easy. Typically you just add a
622 routine, called "kernel_u_size" that returns the size of the user
623 struct, to the appropriate *-nat.c file and then add to the native
624 config file "#define KERNEL_U_SIZE kernel_u_size()" */
625 error ("Don't know how large ``struct user'' is in this version of gdb.");
629 for (udot_off
= 0; udot_off
< KERNEL_U_SIZE
; udot_off
+= sizeof (udot_val
))
631 if ((udot_off
% 24) == 0)
635 printf_filtered ("\n");
637 printf_filtered ("%04x:", udot_off
);
639 udot_val
= ptrace (PT_READ_U
, PIDGET (inferior_ptid
), (PTRACE_ARG3_TYPE
) udot_off
, 0);
642 sprintf (mess
, "\nreading user struct at offset 0x%x", udot_off
);
643 perror_with_name (mess
);
645 /* Avoid using nonportable (?) "*" in print specs */
646 printf_filtered (sizeof (int) == 4 ? " 0x%08x" : " 0x%16x", udot_val
);
648 printf_filtered ("\n");
652 #endif /* !defined (CHILD_XFER_MEMORY). */
656 _initialize_infptrace (void)
658 #if !defined (CHILD_XFER_MEMORY)
659 add_info ("udot", udot_info
,
660 "Print contents of kernel ``struct user'' for current child.");
This page took 0.042652 seconds and 4 git commands to generate.