1 /* Native support code for HPUX PA-RISC.
2 Copyright 1986, 1987, 1989, 1990, 1991, 1992, 1993, 1998, 1999,
4 Free Software Foundation, Inc.
6 Contributed by the Center for Software Science at the
7 University of Utah (pa-gdb-bugs@cs.utah.edu).
9 This file is part of GDB.
11 This program is free software; you can redistribute it and/or modify
12 it under the terms of the GNU General Public License as published by
13 the Free Software Foundation; either version 2 of the License, or
14 (at your option) any later version.
16 This program is distributed in the hope that it will be useful,
17 but WITHOUT ANY WARRANTY; without even the implied warranty of
18 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
19 GNU General Public License for more details.
21 You should have received a copy of the GNU General Public License
22 along with this program; if not, write to the Free Software
23 Foundation, Inc., 59 Temple Place - Suite 330,
24 Boston, MA 02111-1307, USA. */
30 #include <sys/ptrace.h>
35 extern CORE_ADDR text_end
;
37 static void fetch_register (int);
40 fetch_inferior_registers (int regno
)
43 for (regno
= 0; regno
< NUM_REGS
; regno
++)
44 fetch_register (regno
);
46 fetch_register (regno
);
49 /* Our own version of the offsetof macro, since we can't assume ANSI C. */
50 #define HPPAH_OFFSETOF(type, member) ((int) (&((type *) 0)->member))
52 /* Store our register values back into the inferior.
53 If REGNO is -1, do this for all registers.
54 Otherwise, REGNO specifies which register (so we can save time). */
57 store_inferior_registers (int regno
)
59 register unsigned int regaddr
;
62 unsigned int offset
= U_REGS_OFFSET
;
67 unsigned int addr
, len
, offset
;
69 if (CANNOT_STORE_REGISTER (regno
))
73 len
= REGISTER_RAW_SIZE (regno
);
75 /* Requests for register zero actually want the save_state's
76 ss_flags member. As RM says: "Oh, what a hack!" */
80 addr
= HPPAH_OFFSETOF (save_state_t
, ss_flags
);
81 len
= sizeof (ss
.ss_flags
);
83 /* Note that ss_flags is always an int, no matter what
84 REGISTER_RAW_SIZE(0) says. Assuming all HP-UX PA machines
85 are big-endian, put it at the least significant end of the
86 value, and zap the rest of the buffer. */
87 offset
= REGISTER_RAW_SIZE (0) - len
;
90 /* Floating-point registers come from the ss_fpblock area. */
91 else if (regno
>= FP0_REGNUM
)
92 addr
= (HPPAH_OFFSETOF (save_state_t
, ss_fpblock
)
93 + (REGISTER_BYTE (regno
) - REGISTER_BYTE (FP0_REGNUM
)));
95 /* Wide registers come from the ss_wide area.
96 I think it's more PC to test (ss_flags & SS_WIDEREGS) to select
97 between ss_wide and ss_narrow than to use the raw register size.
98 But checking ss_flags would require an extra ptrace call for
99 every register reference. Bleah. */
101 addr
= (HPPAH_OFFSETOF (save_state_t
, ss_wide
)
102 + REGISTER_BYTE (regno
));
104 /* Narrow registers come from the ss_narrow area. Note that
105 ss_narrow starts with gr1, not gr0. */
107 addr
= (HPPAH_OFFSETOF (save_state_t
, ss_narrow
)
108 + (REGISTER_BYTE (regno
) - REGISTER_BYTE (1)));
110 internal_error (__FILE__
, __LINE__
,
111 "hppah-nat.c (write_register): unexpected register size");
113 #ifdef GDB_TARGET_IS_HPPA_20W
114 /* Unbelieveable. The PC head and tail must be written in 64bit hunks
115 or we will get an error. Worse yet, the oddball ptrace/ttrace
116 layering will not allow us to perform a 64bit register store.
119 if (regno
== PCOQ_HEAD_REGNUM
|| regno
== PCOQ_TAIL_REGNUM
&& len
== 8)
123 temp
= *(CORE_ADDR
*)®isters
[REGISTER_BYTE (regno
)];
125 /* Set the priv level (stored in the low two bits of the PC. */
128 ttrace_write_reg_64 (inferior_pid
, (CORE_ADDR
)addr
, (CORE_ADDR
)&temp
);
130 /* If we fail to write the PC, give a true error instead of
134 char *err
= safe_strerror (errno
);
135 char *msg
= alloca (strlen (err
) + 128);
136 sprintf (msg
, "writing `%s' register: %s",
137 REGISTER_NAME (regno
), err
);
138 perror_with_name (msg
);
143 /* Another crock. HPUX complains if you write a nonzero value to
144 the high part of IPSW. What will it take for HP to catch a
145 clue about building sensible interfaces? */
146 if (regno
== IPSW_REGNUM
&& len
== 8)
147 *(int *)®isters
[REGISTER_BYTE (regno
)] = 0;
150 for (i
= 0; i
< len
; i
+= sizeof (int))
153 call_ptrace (PT_WUREGS
, inferior_pid
, (PTRACE_ARG3_TYPE
) addr
+ i
,
154 *(int *) ®isters
[REGISTER_BYTE (regno
) + i
]);
157 /* Warning, not error, in case we are attached; sometimes
158 the kernel doesn't let us at the registers. */
159 char *err
= safe_strerror (errno
);
160 char *msg
= alloca (strlen (err
) + 128);
161 sprintf (msg
, "writing `%s' register: %s",
162 REGISTER_NAME (regno
), err
);
163 /* If we fail to write the PC, give a true error instead of
165 if (regno
== PCOQ_HEAD_REGNUM
|| regno
== PCOQ_TAIL_REGNUM
)
166 perror_with_name (msg
);
174 for (regno
= 0; regno
< NUM_REGS
; regno
++)
175 store_inferior_registers (regno
);
179 /* Fetch a register's value from the process's U area. */
181 fetch_register (int regno
)
183 char buf
[MAX_REGISTER_RAW_SIZE
];
184 unsigned int addr
, len
, offset
;
188 len
= REGISTER_RAW_SIZE (regno
);
190 /* Requests for register zero actually want the save_state's
191 ss_flags member. As RM says: "Oh, what a hack!" */
195 addr
= HPPAH_OFFSETOF (save_state_t
, ss_flags
);
196 len
= sizeof (ss
.ss_flags
);
198 /* Note that ss_flags is always an int, no matter what
199 REGISTER_RAW_SIZE(0) says. Assuming all HP-UX PA machines
200 are big-endian, put it at the least significant end of the
201 value, and zap the rest of the buffer. */
202 offset
= REGISTER_RAW_SIZE (0) - len
;
203 memset (buf
, 0, sizeof (buf
));
206 /* Floating-point registers come from the ss_fpblock area. */
207 else if (regno
>= FP0_REGNUM
)
208 addr
= (HPPAH_OFFSETOF (save_state_t
, ss_fpblock
)
209 + (REGISTER_BYTE (regno
) - REGISTER_BYTE (FP0_REGNUM
)));
211 /* Wide registers come from the ss_wide area.
212 I think it's more PC to test (ss_flags & SS_WIDEREGS) to select
213 between ss_wide and ss_narrow than to use the raw register size.
214 But checking ss_flags would require an extra ptrace call for
215 every register reference. Bleah. */
217 addr
= (HPPAH_OFFSETOF (save_state_t
, ss_wide
)
218 + REGISTER_BYTE (regno
));
220 /* Narrow registers come from the ss_narrow area. Note that
221 ss_narrow starts with gr1, not gr0. */
223 addr
= (HPPAH_OFFSETOF (save_state_t
, ss_narrow
)
224 + (REGISTER_BYTE (regno
) - REGISTER_BYTE (1)));
227 internal_error (__FILE__
, __LINE__
,
228 "hppa-nat.c (fetch_register): unexpected register size");
230 for (i
= 0; i
< len
; i
+= sizeof (int))
233 /* Copy an int from the U area to buf. Fill the least
234 significant end if len != raw_size. */
235 * (int *) &buf
[offset
+ i
] =
236 call_ptrace (PT_RUREGS
, inferior_pid
,
237 (PTRACE_ARG3_TYPE
) addr
+ i
, 0);
240 /* Warning, not error, in case we are attached; sometimes
241 the kernel doesn't let us at the registers. */
242 char *err
= safe_strerror (errno
);
243 char *msg
= alloca (strlen (err
) + 128);
244 sprintf (msg
, "reading `%s' register: %s",
245 REGISTER_NAME (regno
), err
);
251 /* If we're reading an address from the instruction address queue,
252 mask out the bottom two bits --- they contain the privilege
254 if (regno
== PCOQ_HEAD_REGNUM
|| regno
== PCOQ_TAIL_REGNUM
)
255 buf
[len
- 1] &= ~0x3;
257 supply_register (regno
, buf
);
261 /* Copy LEN bytes to or from inferior's memory starting at MEMADDR
262 to debugger memory starting at MYADDR. Copy to inferior if
265 Returns the length copied, which is either the LEN argument or zero.
266 This xfer function does not do partial moves, since child_ops
267 doesn't allow memory operations to cross below us in the target stack
268 anyway. TARGET is ignored. */
271 child_xfer_memory (CORE_ADDR memaddr
, char *myaddr
, int len
, int write
,
272 struct mem_attrib
*mem
,
273 struct target_ops
*target
)
276 /* Round starting address down to longword boundary. */
277 register CORE_ADDR addr
= memaddr
& - (CORE_ADDR
)(sizeof (int));
278 /* Round ending address up; get number of longwords that makes. */
280 = (((memaddr
+ len
) - addr
) + sizeof (int) - 1) / sizeof (int);
282 /* Allocate buffer of that many longwords.
283 Note -- do not use alloca to allocate this buffer since there is no
284 guarantee of when the buffer will actually be deallocated.
286 This routine can be called over and over with the same call chain;
287 this (in effect) would pile up all those alloca requests until a call
288 to alloca was made from a point higher than this routine in the
290 register int *buffer
= (int *) xmalloc (count
* sizeof (int));
294 /* Fill start and end extra bytes of buffer with existing memory data. */
295 if (addr
!= memaddr
|| len
< (int) sizeof (int))
297 /* Need part of initial word -- fetch it. */
298 buffer
[0] = call_ptrace (addr
< text_end
? PT_RIUSER
: PT_RDUSER
,
299 inferior_pid
, (PTRACE_ARG3_TYPE
) addr
, 0);
302 if (count
> 1) /* FIXME, avoid if even boundary */
305 = call_ptrace (addr
< text_end
? PT_RIUSER
: PT_RDUSER
,
307 (PTRACE_ARG3_TYPE
) (addr
308 + (count
- 1) * sizeof (int)),
312 /* Copy data to be written over corresponding part of buffer */
313 memcpy ((char *) buffer
+ (memaddr
& (sizeof (int) - 1)), myaddr
, len
);
315 /* Write the entire buffer. */
316 for (i
= 0; i
< count
; i
++, addr
+= sizeof (int))
320 /* The HP-UX kernel crashes if you use PT_WDUSER to write into the
321 text segment. FIXME -- does it work to write into the data
322 segment using WIUSER, or do these idiots really expect us to
323 figure out which segment the address is in, so we can use a
324 separate system call for it??! */
326 pt_request
= (addr
< text_end
) ? PT_WIUSER
: PT_WDUSER
;
327 pt_status
= call_ptrace (pt_request
,
329 (PTRACE_ARG3_TYPE
) addr
,
332 /* Did we fail? Might we've guessed wrong about which
333 segment this address resides in? Try the other request,
334 and see if that works... */
335 if ((pt_status
== -1) && errno
)
338 pt_request
= (pt_request
== PT_WIUSER
) ? PT_WDUSER
: PT_WIUSER
;
339 pt_status
= call_ptrace (pt_request
,
341 (PTRACE_ARG3_TYPE
) addr
,
344 /* No, we still fail. Okay, time to punt. */
345 if ((pt_status
== -1) && errno
)
355 /* Read all the longwords */
356 for (i
= 0; i
< count
; i
++, addr
+= sizeof (int))
359 buffer
[i
] = call_ptrace (addr
< text_end
? PT_RIUSER
: PT_RDUSER
,
360 inferior_pid
, (PTRACE_ARG3_TYPE
) addr
, 0);
369 /* Copy appropriate bytes out of the buffer. */
370 memcpy (myaddr
, (char *) buffer
+ (memaddr
& (sizeof (int) - 1)), len
);
378 child_post_follow_inferior_by_clone (void)
382 /* This function is used when following both the parent and child
383 of a fork. In this case, the debugger clones itself. The original
384 debugger follows the parent, the clone follows the child. The
385 original detaches from the child, delivering a SIGSTOP to it to
386 keep it from running away until the clone can attach itself.
388 At this point, the clone has attached to the child. Because of
389 the SIGSTOP, we must now deliver a SIGCONT to the child, or it
390 won't behave properly. */
391 status
= kill (inferior_pid
, SIGCONT
);
396 child_post_follow_vfork (int parent_pid
, int followed_parent
, int child_pid
,
399 /* Are we a debugger that followed the parent of a vfork? If so,
400 then recall that the child's vfork event was delivered to us
401 first. And, that the parent was suspended by the OS until the
402 child's exec or exit events were received.
404 Upon receiving that child vfork, then, we were forced to remove
405 all breakpoints in the child and continue it so that it could
406 reach the exec or exit point.
408 But also recall that the parent and child of a vfork share the
409 same address space. Thus, removing bp's in the child also
410 removed them from the parent.
412 Now that the child has safely exec'd or exited, we must restore
413 the parent's breakpoints before we continue it. Else, we may
414 cause it run past expected stopping points. */
417 reattach_breakpoints (parent_pid
);
420 /* Are we a debugger that followed the child of a vfork? If so,
421 then recall that we don't actually acquire control of the child
422 until after it has exec'd or exited. */
425 /* If the child has exited, then there's nothing for us to do.
426 In the case of an exec event, we'll let that be handled by
427 the normal mechanism that notices and handles exec events, in
432 /* Format a process id, given PID. Be sure to terminate
433 this with a null--it's going to be printed via a "%s". */
435 child_pid_to_str (pid_t pid
)
437 /* Static because address returned */
440 /* Extra NULLs for paranoia's sake */
441 sprintf (buf
, "process %d\0\0\0\0", pid
);
446 /* Format a thread id, given TID. Be sure to terminate
447 this with a null--it's going to be printed via a "%s".
449 Note: This is a core-gdb tid, not the actual system tid.
450 See infttrace.c for details. */
452 hppa_tid_to_str (pid_t tid
)
454 /* Static because address returned */
457 /* Extra NULLs for paranoia's sake */
458 sprintf (buf
, "system thread %d\0\0\0\0", tid
);
463 #if !defined (GDB_NATIVE_HPUX_11)
465 /* The following code is a substitute for the infttrace.c versions used
466 with ttrace() in HPUX 11. */
468 /* This value is an arbitrary integer. */
469 #define PT_VERSION 123456
471 /* This semaphore is used to coordinate the child and parent processes
472 after a fork(), and before an exec() by the child. See
473 parent_attach_all for details. */
477 int parent_channel
[2]; /* Parent "talks" to [1], child "listens" to [0] */
478 int child_channel
[2]; /* Child "talks" to [1], parent "listens" to [0] */
483 #define SEM_LISTEN (0)
485 static startup_semaphore_t startup_semaphore
;
487 extern int parent_attach_all (int, PTRACE_ARG3_TYPE
, int);
490 /* This function causes the caller's process to be traced by its
491 parent. This is intended to be called after GDB forks itself,
492 and before the child execs the target.
494 Note that HP-UX ptrace is rather funky in how this is done.
495 If the parent wants to get the initial exec event of a child,
496 it must set the ptrace event mask of the child to include execs.
497 (The child cannot do this itself.) This must be done after the
498 child is forked, but before it execs.
500 To coordinate the parent and child, we implement a semaphore using
501 pipes. After SETTRC'ing itself, the child tells the parent that
502 it is now traceable by the parent, and waits for the parent's
503 acknowledgement. The parent can then set the child's event mask,
504 and notify the child that it can now exec.
506 (The acknowledgement by parent happens as a result of a call to
507 child_acknowledge_created_inferior.) */
510 parent_attach_all (int pid
, PTRACE_ARG3_TYPE addr
, int data
)
514 /* We need a memory home for a constant. */
515 int tc_magic_child
= PT_VERSION
;
516 int tc_magic_parent
= 0;
518 /* The remainder of this function is only useful for HPUX 10.0 and
519 later, as it depends upon the ability to request notification
520 of specific kinds of events by the kernel. */
521 #if defined(PT_SET_EVENT_MASK)
523 /* Notify the parent that we're potentially ready to exec(). */
524 write (startup_semaphore
.child_channel
[SEM_TALK
],
526 sizeof (tc_magic_child
));
528 /* Wait for acknowledgement from the parent. */
529 read (startup_semaphore
.parent_channel
[SEM_LISTEN
],
531 sizeof (tc_magic_parent
));
532 if (tc_magic_child
!= tc_magic_parent
)
533 warning ("mismatched semaphore magic");
535 /* Discard our copy of the semaphore. */
536 (void) close (startup_semaphore
.parent_channel
[SEM_LISTEN
]);
537 (void) close (startup_semaphore
.parent_channel
[SEM_TALK
]);
538 (void) close (startup_semaphore
.child_channel
[SEM_LISTEN
]);
539 (void) close (startup_semaphore
.child_channel
[SEM_TALK
]);
547 hppa_require_attach (int pid
)
552 unsigned int regs_offset
;
554 /* Are we already attached? There appears to be no explicit way to
555 answer this via ptrace, so we try something which should be
556 innocuous if we are attached. If that fails, then we assume
557 we're not attached, and so attempt to make it so. */
560 regs_offset
= U_REGS_OFFSET
;
561 pc_addr
= register_addr (PC_REGNUM
, regs_offset
);
562 pc
= call_ptrace (PT_READ_U
, pid
, (PTRACE_ARG3_TYPE
) pc_addr
, 0);
567 pt_status
= call_ptrace (PT_ATTACH
, pid
, (PTRACE_ARG3_TYPE
) 0, 0);
572 /* Now we really are attached. */
580 hppa_require_detach (int pid
, int signal
)
583 call_ptrace (PT_DETACH
, pid
, (PTRACE_ARG3_TYPE
) 1, signal
);
584 errno
= 0; /* Ignore any errors. */
588 /* Since ptrace doesn't support memory page-protection events, which
589 are used to implement "hardware" watchpoints on HP-UX, these are
590 dummy versions, which perform no useful work. */
593 hppa_enable_page_protection_events (int pid
)
598 hppa_disable_page_protection_events (int pid
)
603 hppa_insert_hw_watchpoint (int pid
, CORE_ADDR start
, LONGEST len
, int type
)
605 error ("Hardware watchpoints not implemented on this platform.");
609 hppa_remove_hw_watchpoint (int pid
, CORE_ADDR start
, LONGEST len
,
612 error ("Hardware watchpoints not implemented on this platform.");
616 hppa_can_use_hw_watchpoint (enum bptype type
, int cnt
, enum bptype ot
)
622 hppa_range_profitable_for_hw_watchpoint (int pid
, CORE_ADDR start
, LONGEST len
)
624 error ("Hardware watchpoints not implemented on this platform.");
628 hppa_pid_or_tid_to_str (pid_t id
)
630 /* In the ptrace world, there are only processes. */
631 return child_pid_to_str (id
);
634 /* This function has no meaning in a non-threaded world. Thus, we
635 return 0 (FALSE). See the use of "hppa_prepare_to_proceed" in
639 hppa_switched_threads (pid_t pid
)
645 hppa_ensure_vforking_parent_remains_stopped (int pid
)
647 /* This assumes that the vforked parent is presently stopped, and
648 that the vforked child has just delivered its first exec event.
649 Calling kill() this way will cause the SIGTRAP to be delivered as
650 soon as the parent is resumed, which happens as soon as the
651 vforked child is resumed. See wait_for_inferior for the use of
657 hppa_resume_execd_vforking_child_to_get_parent_vfork (void)
659 return 1; /* Yes, the child must be resumed. */
663 require_notification_of_events (int pid
)
665 #if defined(PT_SET_EVENT_MASK)
667 ptrace_event_t ptrace_events
;
671 /* Instruct the kernel as to the set of events we wish to be
672 informed of. (This support does not exist before HPUX 10.0.
673 We'll assume if PT_SET_EVENT_MASK has not been defined by
674 <sys/ptrace.h>, then we're being built on pre-10.0.) */
675 memset (&ptrace_events
, 0, sizeof (ptrace_events
));
677 /* Note: By default, all signals are visible to us. If we wish
678 the kernel to keep certain signals hidden from us, we do it
679 by calling sigdelset (ptrace_events.pe_signals, signal) for
680 each such signal here, before doing PT_SET_EVENT_MASK. */
681 /* RM: The above comment is no longer true. We start with ignoring
682 all signals, and then add the ones we are interested in. We could
683 do it the other way: start by looking at all signals and then
684 deleting the ones that we aren't interested in, except that
685 multiple gdb signals may be mapped to the same host signal
686 (eg. TARGET_SIGNAL_IO and TARGET_SIGNAL_POLL both get mapped to
687 signal 22 on HPUX 10.20) We want to be notified if we are
688 interested in either signal. */
689 sigfillset (&ptrace_events
.pe_signals
);
691 /* RM: Let's not bother with signals we don't care about */
692 nsigs
= (int) TARGET_SIGNAL_LAST
;
693 for (signum
= nsigs
; signum
> 0; signum
--)
695 if ((signal_stop_state (signum
)) ||
696 (signal_print_state (signum
)) ||
697 (!signal_pass_state (signum
)))
699 if (target_signal_to_host_p (signum
))
700 sigdelset (&ptrace_events
.pe_signals
,
701 target_signal_to_host (signum
));
705 ptrace_events
.pe_set_event
= 0;
707 ptrace_events
.pe_set_event
|= PTRACE_SIGNAL
;
708 ptrace_events
.pe_set_event
|= PTRACE_EXEC
;
709 ptrace_events
.pe_set_event
|= PTRACE_FORK
;
710 ptrace_events
.pe_set_event
|= PTRACE_VFORK
;
711 /* ??rehrauer: Add this one when we're prepared to catch it...
712 ptrace_events.pe_set_event |= PTRACE_EXIT;
716 pt_status
= call_ptrace (PT_SET_EVENT_MASK
,
718 (PTRACE_ARG3_TYPE
) & ptrace_events
,
719 sizeof (ptrace_events
));
721 perror_with_name ("ptrace");
728 require_notification_of_exec_events (int pid
)
730 #if defined(PT_SET_EVENT_MASK)
732 ptrace_event_t ptrace_events
;
734 /* Instruct the kernel as to the set of events we wish to be
735 informed of. (This support does not exist before HPUX 10.0.
736 We'll assume if PT_SET_EVENT_MASK has not been defined by
737 <sys/ptrace.h>, then we're being built on pre-10.0.) */
738 memset (&ptrace_events
, 0, sizeof (ptrace_events
));
740 /* Note: By default, all signals are visible to us. If we wish
741 the kernel to keep certain signals hidden from us, we do it
742 by calling sigdelset (ptrace_events.pe_signals, signal) for
743 each such signal here, before doing PT_SET_EVENT_MASK. */
744 sigemptyset (&ptrace_events
.pe_signals
);
746 ptrace_events
.pe_set_event
= 0;
748 ptrace_events
.pe_set_event
|= PTRACE_EXEC
;
749 /* ??rehrauer: Add this one when we're prepared to catch it...
750 ptrace_events.pe_set_event |= PTRACE_EXIT;
754 pt_status
= call_ptrace (PT_SET_EVENT_MASK
,
756 (PTRACE_ARG3_TYPE
) & ptrace_events
,
757 sizeof (ptrace_events
));
759 perror_with_name ("ptrace");
765 /* This function is called by the parent process, with pid being the
766 ID of the child process, after the debugger has forked. */
769 child_acknowledge_created_inferior (int pid
)
771 /* We need a memory home for a constant. */
772 int tc_magic_parent
= PT_VERSION
;
773 int tc_magic_child
= 0;
775 /* The remainder of this function is only useful for HPUX 10.0 and
776 later, as it depends upon the ability to request notification
777 of specific kinds of events by the kernel. */
778 #if defined(PT_SET_EVENT_MASK)
779 /* Wait for the child to tell us that it has forked. */
780 read (startup_semaphore
.child_channel
[SEM_LISTEN
],
782 sizeof (tc_magic_child
));
784 /* Notify the child that it can exec.
786 In the infttrace.c variant of this function, we set the child's
787 event mask after the fork but before the exec. In the ptrace
788 world, it seems we can't set the event mask until after the exec. */
789 write (startup_semaphore
.parent_channel
[SEM_TALK
],
791 sizeof (tc_magic_parent
));
793 /* We'd better pause a bit before trying to set the event mask,
794 though, to ensure that the exec has happened. We don't want to
795 wait() on the child, because that'll screw up the upper layers
796 of gdb's execution control that expect to see the exec event.
798 After an exec, the child is no longer executing gdb code. Hence,
799 we can't have yet another synchronization via the pipes. We'll
800 just sleep for a second, and hope that's enough delay... */
803 /* Instruct the kernel as to the set of events we wish to be
805 require_notification_of_exec_events (pid
);
807 /* Discard our copy of the semaphore. */
808 (void) close (startup_semaphore
.parent_channel
[SEM_LISTEN
]);
809 (void) close (startup_semaphore
.parent_channel
[SEM_TALK
]);
810 (void) close (startup_semaphore
.child_channel
[SEM_LISTEN
]);
811 (void) close (startup_semaphore
.child_channel
[SEM_TALK
]);
816 child_post_startup_inferior (int pid
)
818 require_notification_of_events (pid
);
822 child_post_attach (int pid
)
824 require_notification_of_events (pid
);
828 child_insert_fork_catchpoint (int pid
)
830 /* This request is only available on HPUX 10.0 and later. */
831 #if !defined(PT_SET_EVENT_MASK)
832 error ("Unable to catch forks prior to HPUX 10.0");
834 /* Enable reporting of fork events from the kernel. */
835 /* ??rehrauer: For the moment, we're always enabling these events,
836 and just ignoring them if there's no catchpoint to catch them. */
842 child_remove_fork_catchpoint (int pid
)
844 /* This request is only available on HPUX 10.0 and later. */
845 #if !defined(PT_SET_EVENT_MASK)
846 error ("Unable to catch forks prior to HPUX 10.0");
848 /* Disable reporting of fork events from the kernel. */
849 /* ??rehrauer: For the moment, we're always enabling these events,
850 and just ignoring them if there's no catchpoint to catch them. */
856 child_insert_vfork_catchpoint (int pid
)
858 /* This request is only available on HPUX 10.0 and later. */
859 #if !defined(PT_SET_EVENT_MASK)
860 error ("Unable to catch vforks prior to HPUX 10.0");
862 /* Enable reporting of vfork events from the kernel. */
863 /* ??rehrauer: For the moment, we're always enabling these events,
864 and just ignoring them if there's no catchpoint to catch them. */
870 child_remove_vfork_catchpoint (int pid
)
872 /* This request is only available on HPUX 10.0 and later. */
873 #if !defined(PT_SET_EVENT_MASK)
874 error ("Unable to catch vforks prior to HPUX 10.0");
876 /* Disable reporting of vfork events from the kernel. */
877 /* ??rehrauer: For the moment, we're always enabling these events,
878 and just ignoring them if there's no catchpoint to catch them. */
884 child_has_forked (int pid
, int *childpid
)
886 /* This request is only available on HPUX 10.0 and later. */
887 #if !defined(PT_GET_PROCESS_STATE)
892 ptrace_state_t ptrace_state
;
895 pt_status
= call_ptrace (PT_GET_PROCESS_STATE
,
897 (PTRACE_ARG3_TYPE
) & ptrace_state
,
898 sizeof (ptrace_state
));
900 perror_with_name ("ptrace");
904 if (ptrace_state
.pe_report_event
& PTRACE_FORK
)
906 *childpid
= ptrace_state
.pe_other_pid
;
915 child_has_vforked (int pid
, int *childpid
)
917 /* This request is only available on HPUX 10.0 and later. */
918 #if !defined(PT_GET_PROCESS_STATE)
924 ptrace_state_t ptrace_state
;
927 pt_status
= call_ptrace (PT_GET_PROCESS_STATE
,
929 (PTRACE_ARG3_TYPE
) & ptrace_state
,
930 sizeof (ptrace_state
));
932 perror_with_name ("ptrace");
936 if (ptrace_state
.pe_report_event
& PTRACE_VFORK
)
938 *childpid
= ptrace_state
.pe_other_pid
;
947 child_can_follow_vfork_prior_to_exec (void)
949 /* ptrace doesn't allow this. */
954 child_insert_exec_catchpoint (int pid
)
956 /* This request is only available on HPUX 10.0 and later. */
957 #if !defined(PT_SET_EVENT_MASK)
958 error ("Unable to catch execs prior to HPUX 10.0");
961 /* Enable reporting of exec events from the kernel. */
962 /* ??rehrauer: For the moment, we're always enabling these events,
963 and just ignoring them if there's no catchpoint to catch them. */
969 child_remove_exec_catchpoint (int pid
)
971 /* This request is only available on HPUX 10.0 and later. */
972 #if !defined(PT_SET_EVENT_MASK)
973 error ("Unable to catch execs prior to HPUX 10.0");
976 /* Disable reporting of exec events from the kernel. */
977 /* ??rehrauer: For the moment, we're always enabling these events,
978 and just ignoring them if there's no catchpoint to catch them. */
984 child_has_execd (int pid
, char **execd_pathname
)
986 /* This request is only available on HPUX 10.0 and later. */
987 #if !defined(PT_GET_PROCESS_STATE)
988 *execd_pathname
= NULL
;
993 ptrace_state_t ptrace_state
;
996 pt_status
= call_ptrace (PT_GET_PROCESS_STATE
,
998 (PTRACE_ARG3_TYPE
) & ptrace_state
,
999 sizeof (ptrace_state
));
1001 perror_with_name ("ptrace");
1005 if (ptrace_state
.pe_report_event
& PTRACE_EXEC
)
1007 char *exec_file
= target_pid_to_exec_file (pid
);
1008 *execd_pathname
= savestring (exec_file
, strlen (exec_file
));
1017 child_reported_exec_events_per_exec_call (void)
1019 return 2; /* ptrace reports the event twice per call. */
1023 child_has_syscall_event (int pid
, enum target_waitkind
*kind
, int *syscall_id
)
1025 /* This request is only available on HPUX 10.30 and later, via
1026 the ttrace interface. */
1028 *kind
= TARGET_WAITKIND_SPURIOUS
;
1034 child_pid_to_exec_file (int pid
)
1036 static char exec_file_buffer
[1024];
1038 CORE_ADDR top_of_stack
;
1042 int saved_inferior_pid
;
1045 #ifdef PT_GET_PROCESS_PATHNAME
1046 /* As of 10.x HP-UX, there's an explicit request to get the pathname. */
1047 pt_status
= call_ptrace (PT_GET_PROCESS_PATHNAME
,
1049 (PTRACE_ARG3_TYPE
) exec_file_buffer
,
1050 sizeof (exec_file_buffer
) - 1);
1052 return exec_file_buffer
;
1055 /* It appears that this request is broken prior to 10.30.
1056 If it fails, try a really, truly amazingly gross hack
1057 that DDE uses, of pawing through the process' data
1058 segment to find the pathname. */
1060 top_of_stack
= 0x7b03a000;
1064 /* On the chance that pid != inferior_pid, set inferior_pid
1065 to pid, so that (grrrr!) implicit uses of inferior_pid get
1068 saved_inferior_pid
= inferior_pid
;
1071 /* Try to grab a null-terminated string. */
1074 if (target_read_memory (top_of_stack
, four_chars
, 4) != 0)
1076 inferior_pid
= saved_inferior_pid
;
1079 for (i
= 0; i
< 4; i
++)
1081 exec_file_buffer
[name_index
++] = four_chars
[i
];
1082 done
= (four_chars
[i
] == '\0');
1089 if (exec_file_buffer
[0] == '\0')
1091 inferior_pid
= saved_inferior_pid
;
1095 inferior_pid
= saved_inferior_pid
;
1096 return exec_file_buffer
;
1100 pre_fork_inferior (void)
1104 status
= pipe (startup_semaphore
.parent_channel
);
1107 warning ("error getting parent pipe for startup semaphore");
1111 status
= pipe (startup_semaphore
.child_channel
);
1114 warning ("error getting child pipe for startup semaphore");
1120 /* Check to see if the given thread is alive.
1122 This is a no-op, as ptrace doesn't support threads, so we just
1126 child_thread_alive (int pid
)
1131 #endif /* ! GDB_NATIVE_HPUX_11 */