1 /* Low-level child interface to ttrace.
3 Copyright (C) 2004, 2005, 2006, 2007, 2008 Free Software Foundation, Inc.
5 This file is part of GDB.
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 3 of the License, or
10 (at your option) any later version.
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with this program. If not, see <http://www.gnu.org/licenses/>. */
22 /* The ttrace(2) system call didn't exist before HP-UX 10.30. Don't
23 try to compile this code unless we have it. */
28 #include "gdbthread.h"
32 #include "gdb_assert.h"
33 #include "gdb_string.h"
35 #include <sys/ttrace.h>
38 #include "inf-child.h"
39 #include "inf-ttrace.h"
41 /* HACK: Save the ttrace ops returned by inf_ttrace_target. */
42 static struct target_ops
*ttrace_ops_hack
;
45 /* HP-UX uses a threading model where each user-space thread
46 corresponds to a kernel thread. These kernel threads are called
47 lwps. The ttrace(2) interface gives us almost full control over
48 the threads, which makes it very easy to support them in GDB. We
49 identify the threads by process ID and lwp ID. The ttrace(2) also
50 provides us with a thread's user ID (in the `tts_user_tid' member
51 of `ttstate_t') but we don't use that (yet) as it isn't necessary
52 to uniquely label the thread. */
54 /* Number of active lwps. */
55 static int inf_ttrace_num_lwps
;
58 /* On HP-UX versions that have the ttrace(2) system call, we can
59 implement "hardware" watchpoints by fiddling with the protection of
60 pages in the address space that contain the variable being watched.
61 In order to implement this, we keep a dictionary of pages for which
62 we have changed the protection. */
64 struct inf_ttrace_page
66 CORE_ADDR addr
; /* Page address. */
67 int prot
; /* Protection. */
68 int refcount
; /* Reference count. */
69 struct inf_ttrace_page
*next
;
70 struct inf_ttrace_page
*prev
;
73 struct inf_ttrace_page_dict
75 struct inf_ttrace_page buckets
[128];
76 int pagesize
; /* Page size. */
77 int count
; /* Number of pages in this dictionary. */
78 } inf_ttrace_page_dict
;
80 struct inf_ttrace_private_thread_info
85 /* Number of lwps that are currently in a system call. */
86 static int inf_ttrace_num_lwps_in_syscall
;
88 /* Flag to indicate whether we should re-enable page protections after
90 static int inf_ttrace_reenable_page_protections
;
92 /* Enable system call events for process PID. */
95 inf_ttrace_enable_syscall_events (pid_t pid
)
100 gdb_assert (inf_ttrace_num_lwps_in_syscall
== 0);
102 if (ttrace (TT_PROC_GET_EVENT_MASK
, pid
, 0,
103 (uintptr_t)&tte
, sizeof tte
, 0) == -1)
104 perror_with_name (("ttrace"));
106 tte
.tte_events
|= (TTEVT_SYSCALL_ENTRY
| TTEVT_SYSCALL_RETURN
);
108 if (ttrace (TT_PROC_SET_EVENT_MASK
, pid
, 0,
109 (uintptr_t)&tte
, sizeof tte
, 0) == -1)
110 perror_with_name (("ttrace"));
112 if (ttrace (TT_PROC_GET_FIRST_LWP_STATE
, pid
, 0,
113 (uintptr_t)&tts
, sizeof tts
, 0) == -1)
114 perror_with_name (("ttrace"));
116 if (tts
.tts_flags
& TTS_INSYSCALL
)
117 inf_ttrace_num_lwps_in_syscall
++;
119 /* FIXME: Handle multiple threads. */
122 /* Disable system call events for process PID. */
125 inf_ttrace_disable_syscall_events (pid_t pid
)
129 gdb_assert (inf_ttrace_page_dict
.count
== 0);
131 if (ttrace (TT_PROC_GET_EVENT_MASK
, pid
, 0,
132 (uintptr_t)&tte
, sizeof tte
, 0) == -1)
133 perror_with_name (("ttrace"));
135 tte
.tte_events
&= ~(TTEVT_SYSCALL_ENTRY
| TTEVT_SYSCALL_RETURN
);
137 if (ttrace (TT_PROC_SET_EVENT_MASK
, pid
, 0,
138 (uintptr_t)&tte
, sizeof tte
, 0) == -1)
139 perror_with_name (("ttrace"));
141 inf_ttrace_num_lwps_in_syscall
= 0;
144 /* Get information about the page at address ADDR for process PID from
147 static struct inf_ttrace_page
*
148 inf_ttrace_get_page (pid_t pid
, CORE_ADDR addr
)
150 const int num_buckets
= ARRAY_SIZE (inf_ttrace_page_dict
.buckets
);
151 const int pagesize
= inf_ttrace_page_dict
.pagesize
;
153 struct inf_ttrace_page
*page
;
155 bucket
= (addr
/ pagesize
) % num_buckets
;
156 page
= &inf_ttrace_page_dict
.buckets
[bucket
];
159 if (page
->addr
== addr
)
168 /* Add the page at address ADDR for process PID to the dictionary. */
170 static struct inf_ttrace_page
*
171 inf_ttrace_add_page (pid_t pid
, CORE_ADDR addr
)
173 const int num_buckets
= ARRAY_SIZE (inf_ttrace_page_dict
.buckets
);
174 const int pagesize
= inf_ttrace_page_dict
.pagesize
;
176 struct inf_ttrace_page
*page
;
177 struct inf_ttrace_page
*prev
= NULL
;
179 bucket
= (addr
/ pagesize
) % num_buckets
;
180 page
= &inf_ttrace_page_dict
.buckets
[bucket
];
183 if (page
->addr
== addr
)
194 if (ttrace (TT_PROC_GET_MPROTECT
, pid
, 0,
195 addr
, 0, (uintptr_t)&prot
) == -1)
196 perror_with_name (("ttrace"));
198 page
= XMALLOC (struct inf_ttrace_page
);
207 inf_ttrace_page_dict
.count
++;
208 if (inf_ttrace_page_dict
.count
== 1)
209 inf_ttrace_enable_syscall_events (pid
);
211 if (inf_ttrace_num_lwps_in_syscall
== 0)
213 if (ttrace (TT_PROC_SET_MPROTECT
, pid
, 0,
214 addr
, pagesize
, prot
& ~PROT_WRITE
) == -1)
215 perror_with_name (("ttrace"));
222 /* Insert the page at address ADDR of process PID to the dictionary. */
225 inf_ttrace_insert_page (pid_t pid
, CORE_ADDR addr
)
227 struct inf_ttrace_page
*page
;
229 page
= inf_ttrace_get_page (pid
, addr
);
231 page
= inf_ttrace_add_page (pid
, addr
);
236 /* Remove the page at address ADDR of process PID from the dictionary. */
239 inf_ttrace_remove_page (pid_t pid
, CORE_ADDR addr
)
241 const int pagesize
= inf_ttrace_page_dict
.pagesize
;
242 struct inf_ttrace_page
*page
;
244 page
= inf_ttrace_get_page (pid
, addr
);
247 gdb_assert (page
->refcount
>= 0);
249 if (page
->refcount
== 0)
251 if (inf_ttrace_num_lwps_in_syscall
== 0)
253 if (ttrace (TT_PROC_SET_MPROTECT
, pid
, 0,
254 addr
, pagesize
, page
->prot
) == -1)
255 perror_with_name (("ttrace"));
258 inf_ttrace_page_dict
.count
--;
259 if (inf_ttrace_page_dict
.count
== 0)
260 inf_ttrace_disable_syscall_events (pid
);
262 page
->prev
->next
= page
->next
;
264 page
->next
->prev
= page
->prev
;
270 /* Mask the bits in PROT from the page protections that are currently
271 in the dictionary for process PID. */
274 inf_ttrace_mask_page_protections (pid_t pid
, int prot
)
276 const int num_buckets
= ARRAY_SIZE (inf_ttrace_page_dict
.buckets
);
277 const int pagesize
= inf_ttrace_page_dict
.pagesize
;
280 for (bucket
= 0; bucket
< num_buckets
; bucket
++)
282 struct inf_ttrace_page
*page
;
284 page
= inf_ttrace_page_dict
.buckets
[bucket
].next
;
287 if (ttrace (TT_PROC_SET_MPROTECT
, pid
, 0,
288 page
->addr
, pagesize
, page
->prot
& ~prot
) == -1)
289 perror_with_name (("ttrace"));
296 /* Write-protect the pages in the dictionary for process PID. */
299 inf_ttrace_enable_page_protections (pid_t pid
)
301 inf_ttrace_mask_page_protections (pid
, PROT_WRITE
);
304 /* Restore the protection of the pages in the dictionary for process
308 inf_ttrace_disable_page_protections (pid_t pid
)
310 inf_ttrace_mask_page_protections (pid
, 0);
313 /* Insert a "hardware" watchpoint for LEN bytes at address ADDR of
317 inf_ttrace_insert_watchpoint (CORE_ADDR addr
, int len
, int type
)
319 const int pagesize
= inf_ttrace_page_dict
.pagesize
;
320 pid_t pid
= ptid_get_pid (inferior_ptid
);
325 gdb_assert (type
== hw_write
);
327 page_addr
= (addr
/ pagesize
) * pagesize
;
328 num_pages
= (len
+ pagesize
- 1) / pagesize
;
330 for (page
= 0; page
< num_pages
; page
++, page_addr
+= pagesize
)
331 inf_ttrace_insert_page (pid
, page_addr
);
336 /* Remove a "hardware" watchpoint for LEN bytes at address ADDR of
340 inf_ttrace_remove_watchpoint (CORE_ADDR addr
, int len
, int type
)
342 const int pagesize
= inf_ttrace_page_dict
.pagesize
;
343 pid_t pid
= ptid_get_pid (inferior_ptid
);
348 gdb_assert (type
== hw_write
);
350 page_addr
= (addr
/ pagesize
) * pagesize
;
351 num_pages
= (len
+ pagesize
- 1) / pagesize
;
353 for (page
= 0; page
< num_pages
; page
++, page_addr
+= pagesize
)
354 inf_ttrace_remove_page (pid
, page_addr
);
360 inf_ttrace_can_use_hw_breakpoint (int type
, int len
, int ot
)
362 return (type
== bp_hardware_watchpoint
);
366 inf_ttrace_region_ok_for_hw_watchpoint (CORE_ADDR addr
, int len
)
371 /* Return non-zero if the current inferior was (potentially) stopped
372 by hitting a "hardware" watchpoint. */
375 inf_ttrace_stopped_by_watchpoint (void)
377 pid_t pid
= ptid_get_pid (inferior_ptid
);
378 lwpid_t lwpid
= ptid_get_lwp (inferior_ptid
);
381 if (inf_ttrace_page_dict
.count
> 0)
383 if (ttrace (TT_LWP_GET_STATE
, pid
, lwpid
,
384 (uintptr_t)&tts
, sizeof tts
, 0) == -1)
385 perror_with_name (("ttrace"));
387 if (tts
.tts_event
== TTEVT_SIGNAL
388 && tts
.tts_u
.tts_signal
.tts_signo
== SIGBUS
)
390 const int pagesize
= inf_ttrace_page_dict
.pagesize
;
391 void *addr
= tts
.tts_u
.tts_signal
.tts_siginfo
.si_addr
;
392 CORE_ADDR page_addr
= ((uintptr_t)addr
/ pagesize
) * pagesize
;
394 if (inf_ttrace_get_page (pid
, page_addr
))
403 /* When tracking a vfork(2), we cannot detach from the parent until
404 after the child has called exec(3) or has exited. If we are still
405 attached to the parent, this variable will be set to the process ID
406 of the parent. Otherwise it will be set to zero. */
407 static pid_t inf_ttrace_vfork_ppid
= -1;
410 inf_ttrace_follow_fork (struct target_ops
*ops
, int follow_child
)
413 lwpid_t lwpid
, flwpid
;
415 struct thread_info
*last_tp
= NULL
;
416 struct breakpoint
*step_resume_breakpoint
= NULL
;
417 CORE_ADDR step_range_start
= 0, step_range_end
= 0;
418 struct frame_id step_frame_id
= null_frame_id
;
420 /* FIXME: kettenis/20050720: This stuff should really be passed as
421 an argument by our caller. */
424 struct target_waitstatus status
;
426 get_last_target_status (&ptid
, &status
);
427 gdb_assert (status
.kind
== TARGET_WAITKIND_FORKED
428 || status
.kind
== TARGET_WAITKIND_VFORKED
);
430 pid
= ptid_get_pid (ptid
);
431 lwpid
= ptid_get_lwp (ptid
);
432 last_tp
= find_thread_pid (ptid
);
435 /* Get all important details that core GDB doesn't (and shouldn't)
437 if (ttrace (TT_LWP_GET_STATE
, pid
, lwpid
,
438 (uintptr_t)&tts
, sizeof tts
, 0) == -1)
439 perror_with_name (("ttrace"));
441 gdb_assert (tts
.tts_event
== TTEVT_FORK
|| tts
.tts_event
== TTEVT_VFORK
);
443 if (tts
.tts_u
.tts_fork
.tts_isparent
)
446 lwpid
= tts
.tts_lwpid
;
447 fpid
= tts
.tts_u
.tts_fork
.tts_fpid
;
448 flwpid
= tts
.tts_u
.tts_fork
.tts_flwpid
;
452 pid
= tts
.tts_u
.tts_fork
.tts_fpid
;
453 lwpid
= tts
.tts_u
.tts_fork
.tts_flwpid
;
455 flwpid
= tts
.tts_lwpid
;
460 /* Copy user stepping state to the new inferior thread. */
461 step_resume_breakpoint
= last_tp
->step_resume_breakpoint
;
462 step_range_start
= last_tp
->step_range_start
;
463 step_range_end
= last_tp
->step_range_end
;
464 step_frame_id
= last_tp
->step_frame_id
;
466 /* Otherwise, deleting the parent would get rid of this
468 last_tp
->step_resume_breakpoint
= NULL
;
470 inferior_ptid
= ptid_build (fpid
, flwpid
, 0);
471 detach_breakpoints (pid
);
473 target_terminal_ours ();
474 fprintf_unfiltered (gdb_stdlog
, _("\
475 Attaching after fork to child process %ld.\n"), (long)fpid
);
479 inferior_ptid
= ptid_build (pid
, lwpid
, 0);
480 detach_breakpoints (fpid
);
482 target_terminal_ours ();
483 fprintf_unfiltered (gdb_stdlog
, _("\
484 Detaching after fork from child process %ld.\n"), (long)fpid
);
487 if (tts
.tts_event
== TTEVT_VFORK
)
489 gdb_assert (!tts
.tts_u
.tts_fork
.tts_isparent
);
493 /* We can't detach from the parent yet. */
494 inf_ttrace_vfork_ppid
= pid
;
496 reattach_breakpoints (fpid
);
500 if (ttrace (TT_PROC_DETACH
, fpid
, 0, 0, 0, 0) == -1)
501 perror_with_name (("ttrace"));
503 /* Wait till we get the TTEVT_VFORK event in the parent.
504 This indicates that the child has called exec(3) or has
505 exited and that the parent is ready to be traced again. */
506 if (ttrace_wait (pid
, lwpid
, TTRACE_WAITOK
, &tts
, sizeof tts
) == -1)
507 perror_with_name (("ttrace_wait"));
508 gdb_assert (tts
.tts_event
== TTEVT_VFORK
);
509 gdb_assert (tts
.tts_u
.tts_fork
.tts_isparent
);
511 reattach_breakpoints (pid
);
516 gdb_assert (tts
.tts_u
.tts_fork
.tts_isparent
);
520 if (ttrace (TT_PROC_DETACH
, pid
, 0, 0, 0, 0) == -1)
521 perror_with_name (("ttrace"));
525 if (ttrace (TT_PROC_DETACH
, fpid
, 0, 0, 0, 0) == -1)
526 perror_with_name (("ttrace"));
532 struct thread_info
*ti
;
534 /* The child will start out single-threaded. */
535 inf_ttrace_num_lwps
= 1;
536 inf_ttrace_num_lwps_in_syscall
= 0;
539 delete_thread_silent (ptid_build (pid
, lwpid
, 0));
541 /* Add child. inferior_ptid was already set above. */
542 ti
= add_thread_silent (inferior_ptid
);
544 xmalloc (sizeof (struct inf_ttrace_private_thread_info
));
545 memset (ti
->private, 0,
546 sizeof (struct inf_ttrace_private_thread_info
));
548 ti
->step_resume_breakpoint
= step_resume_breakpoint
;
549 ti
->step_range_start
= step_range_start
;
550 ti
->step_range_end
= step_range_end
;
551 ti
->step_frame_id
= step_frame_id
;
553 /* Reset breakpoints in the child as appropriate. */
554 follow_inferior_reset_breakpoints ();
561 /* File descriptors for pipes used as semaphores during initial
562 startup of an inferior. */
563 static int inf_ttrace_pfd1
[2];
564 static int inf_ttrace_pfd2
[2];
567 do_cleanup_pfds (void *dummy
)
569 close (inf_ttrace_pfd1
[0]);
570 close (inf_ttrace_pfd1
[1]);
571 close (inf_ttrace_pfd2
[0]);
572 close (inf_ttrace_pfd2
[1]);
576 inf_ttrace_prepare (void)
578 if (pipe (inf_ttrace_pfd1
) == -1)
579 perror_with_name (("pipe"));
581 if (pipe (inf_ttrace_pfd2
) == -1)
583 close (inf_ttrace_pfd1
[0]);
584 close (inf_ttrace_pfd2
[0]);
585 perror_with_name (("pipe"));
589 /* Prepare to be traced. */
594 struct cleanup
*old_chain
= make_cleanup (do_cleanup_pfds
, 0);
597 /* "Trace me, Dr. Memory!" */
598 if (ttrace (TT_PROC_SETTRC
, 0, 0, 0, TT_VERSION
, 0) == -1)
599 perror_with_name (("ttrace"));
601 /* Tell our parent that we are ready to be traced. */
602 if (write (inf_ttrace_pfd1
[1], &c
, sizeof c
) != sizeof c
)
603 perror_with_name (("write"));
605 /* Wait until our parent has set the initial event mask. */
606 if (read (inf_ttrace_pfd2
[0], &c
, sizeof c
) != sizeof c
)
607 perror_with_name (("read"));
609 do_cleanups (old_chain
);
612 /* Start tracing PID. */
615 inf_ttrace_him (int pid
)
617 struct cleanup
*old_chain
= make_cleanup (do_cleanup_pfds
, 0);
621 /* Wait until our child is ready to be traced. */
622 if (read (inf_ttrace_pfd1
[0], &c
, sizeof c
) != sizeof c
)
623 perror_with_name (("read"));
625 /* Set the initial event mask. */
626 memset (&tte
, 0, sizeof (tte
));
627 tte
.tte_events
|= TTEVT_EXEC
| TTEVT_EXIT
| TTEVT_FORK
| TTEVT_VFORK
;
628 tte
.tte_events
|= TTEVT_LWP_CREATE
| TTEVT_LWP_EXIT
| TTEVT_LWP_TERMINATE
;
629 #ifdef TTEVT_BPT_SSTEP
630 tte
.tte_events
|= TTEVT_BPT_SSTEP
;
632 tte
.tte_opts
|= TTEO_PROC_INHERIT
;
633 if (ttrace (TT_PROC_SET_EVENT_MASK
, pid
, 0,
634 (uintptr_t)&tte
, sizeof tte
, 0) == -1)
635 perror_with_name (("ttrace"));
637 /* Tell our child that we have set the initial event mask. */
638 if (write (inf_ttrace_pfd2
[1], &c
, sizeof c
) != sizeof c
)
639 perror_with_name (("write"));
641 do_cleanups (old_chain
);
643 push_target (ttrace_ops_hack
);
645 /* On some targets, there must be some explicit synchronization
646 between the parent and child processes after the debugger forks,
647 and before the child execs the debuggee program. This call
648 basically gives permission for the child to exec. */
650 target_acknowledge_created_inferior (pid
);
652 /* START_INFERIOR_TRAPS_EXPECTED is defined in inferior.h, and will
653 be 1 or 2 depending on whether we're starting without or with a
655 startup_inferior (START_INFERIOR_TRAPS_EXPECTED
);
657 /* On some targets, there must be some explicit actions taken after
658 the inferior has been started up. */
659 target_post_startup_inferior (pid_to_ptid (pid
));
663 inf_ttrace_create_inferior (char *exec_file
, char *allargs
, char **env
,
666 gdb_assert (inf_ttrace_num_lwps
== 0);
667 gdb_assert (inf_ttrace_num_lwps_in_syscall
== 0);
668 gdb_assert (inf_ttrace_page_dict
.count
== 0);
669 gdb_assert (inf_ttrace_reenable_page_protections
== 0);
670 gdb_assert (inf_ttrace_vfork_ppid
== -1);
672 fork_inferior (exec_file
, allargs
, env
, inf_ttrace_me
, inf_ttrace_him
,
673 inf_ttrace_prepare
, NULL
);
677 inf_ttrace_mourn_inferior (void)
679 const int num_buckets
= ARRAY_SIZE (inf_ttrace_page_dict
.buckets
);
682 inf_ttrace_num_lwps
= 0;
683 inf_ttrace_num_lwps_in_syscall
= 0;
685 for (bucket
= 0; bucket
< num_buckets
; bucket
++)
687 struct inf_ttrace_page
*page
;
688 struct inf_ttrace_page
*next
;
690 page
= inf_ttrace_page_dict
.buckets
[bucket
].next
;
698 inf_ttrace_page_dict
.count
= 0;
700 unpush_target (ttrace_ops_hack
);
701 generic_mourn_inferior ();
705 inf_ttrace_attach (char *args
, int from_tty
)
713 error_no_arg (_("process-id to attach"));
716 pid
= strtol (args
, &dummy
, 0);
717 if (pid
== 0 && args
== dummy
)
718 error (_("Illegal process-id: %s."), args
);
720 if (pid
== getpid ()) /* Trying to masturbate? */
721 error (_("I refuse to debug myself!"));
725 exec_file
= get_exec_file (0);
728 printf_unfiltered (_("Attaching to program: %s, %s\n"), exec_file
,
729 target_pid_to_str (pid_to_ptid (pid
)));
731 printf_unfiltered (_("Attaching to %s\n"),
732 target_pid_to_str (pid_to_ptid (pid
)));
734 gdb_flush (gdb_stdout
);
737 gdb_assert (inf_ttrace_num_lwps
== 0);
738 gdb_assert (inf_ttrace_num_lwps_in_syscall
== 0);
739 gdb_assert (inf_ttrace_vfork_ppid
== -1);
741 if (ttrace (TT_PROC_ATTACH
, pid
, 0, TT_KILL_ON_EXIT
, TT_VERSION
, 0) == -1)
742 perror_with_name (("ttrace"));
745 /* Set the initial event mask. */
746 memset (&tte
, 0, sizeof (tte
));
747 tte
.tte_events
|= TTEVT_EXEC
| TTEVT_EXIT
| TTEVT_FORK
| TTEVT_VFORK
;
748 tte
.tte_events
|= TTEVT_LWP_CREATE
| TTEVT_LWP_EXIT
| TTEVT_LWP_TERMINATE
;
749 #ifdef TTEVT_BPT_SSTEP
750 tte
.tte_events
|= TTEVT_BPT_SSTEP
;
752 tte
.tte_opts
|= TTEO_PROC_INHERIT
;
753 if (ttrace (TT_PROC_SET_EVENT_MASK
, pid
, 0,
754 (uintptr_t)&tte
, sizeof tte
, 0) == -1)
755 perror_with_name (("ttrace"));
757 push_target (ttrace_ops_hack
);
759 /* We'll bump inf_ttrace_num_lwps up and add the private data to the
760 thread as soon as we get to inf_ttrace_wait. At this point, we
761 don't have lwpid info yet. */
762 inferior_ptid
= pid_to_ptid (pid
);
763 add_thread_silent (inferior_ptid
);
767 inf_ttrace_detach (char *args
, int from_tty
)
769 pid_t pid
= ptid_get_pid (inferior_ptid
);
774 char *exec_file
= get_exec_file (0);
777 printf_unfiltered (_("Detaching from program: %s, %s\n"), exec_file
,
778 target_pid_to_str (pid_to_ptid (pid
)));
779 gdb_flush (gdb_stdout
);
784 /* ??? The HP-UX 11.0 ttrace(2) manual page doesn't mention that we
785 can pass a signal number here. Does this really work? */
786 if (ttrace (TT_PROC_DETACH
, pid
, 0, 0, sig
, 0) == -1)
787 perror_with_name (("ttrace"));
789 if (inf_ttrace_vfork_ppid
!= -1)
791 if (ttrace (TT_PROC_DETACH
, inf_ttrace_vfork_ppid
, 0, 0, 0, 0) == -1)
792 perror_with_name (("ttrace"));
793 inf_ttrace_vfork_ppid
= -1;
796 inf_ttrace_num_lwps
= 0;
797 inf_ttrace_num_lwps_in_syscall
= 0;
799 unpush_target (ttrace_ops_hack
);
800 inferior_ptid
= null_ptid
;
804 inf_ttrace_kill (void)
806 pid_t pid
= ptid_get_pid (inferior_ptid
);
811 if (ttrace (TT_PROC_EXIT
, pid
, 0, 0, 0, 0) == -1)
812 perror_with_name (("ttrace"));
813 /* ??? Is it necessary to call ttrace_wait() here? */
815 if (inf_ttrace_vfork_ppid
!= -1)
817 if (ttrace (TT_PROC_DETACH
, inf_ttrace_vfork_ppid
, 0, 0, 0, 0) == -1)
818 perror_with_name (("ttrace"));
819 inf_ttrace_vfork_ppid
= -1;
822 target_mourn_inferior ();
825 /* Check is a dying thread is dead by now, and delete it from GDBs
826 thread list if so. */
828 inf_ttrace_delete_dead_threads_callback (struct thread_info
*info
, void *arg
)
831 struct inf_ttrace_private_thread_info
*p
;
833 if (is_exited (info
->ptid
))
836 lwpid
= ptid_get_lwp (info
->ptid
);
837 p
= (struct inf_ttrace_private_thread_info
*) info
->private;
839 /* Check if an lwp that was dying is still there or not. */
840 if (p
->dying
&& (kill (lwpid
, 0) == -1))
842 delete_thread (info
->ptid
);
847 /* Resume the lwp pointed to by INFO, with REQUEST, and pass it signal
851 inf_ttrace_resume_lwp (struct thread_info
*info
, ttreq_t request
, int sig
)
853 pid_t pid
= ptid_get_pid (info
->ptid
);
854 lwpid_t lwpid
= ptid_get_lwp (info
->ptid
);
856 if (ttrace (request
, pid
, lwpid
, TT_NOPC
, sig
, 0) == -1)
858 struct inf_ttrace_private_thread_info
*p
859 = (struct inf_ttrace_private_thread_info
*) info
->private;
860 if (p
->dying
&& errno
== EPROTO
)
861 /* This is expected, it means the dying lwp is really gone
862 by now. If ttrace had an event to inform the debugger
863 the lwp is really gone, this wouldn't be needed. */
864 delete_thread (info
->ptid
);
866 /* This was really unexpected. */
867 perror_with_name (("ttrace"));
871 /* Callback for iterate_over_threads. */
874 inf_ttrace_resume_callback (struct thread_info
*info
, void *arg
)
876 if (!ptid_equal (info
->ptid
, inferior_ptid
) && !is_exited (info
->ptid
))
877 inf_ttrace_resume_lwp (info
, TT_LWP_CONTINUE
, 0);
883 inf_ttrace_resume (ptid_t ptid
, int step
, enum target_signal signal
)
886 ttreq_t request
= step
? TT_LWP_SINGLE
: TT_LWP_CONTINUE
;
887 int sig
= target_signal_to_host (signal
);
888 struct thread_info
*info
;
890 /* A specific PTID means `step only this process id'. */
891 resume_all
= (ptid_equal (ptid
, minus_one_ptid
));
893 /* If resuming all threads, it's the current thread that should be
894 handled specially. */
896 ptid
= inferior_ptid
;
898 info
= find_thread_pid (ptid
);
899 inf_ttrace_resume_lwp (info
, request
, sig
);
902 /* Let all the other threads run too. */
903 iterate_over_threads (inf_ttrace_resume_callback
, NULL
);
907 inf_ttrace_wait (ptid_t ptid
, struct target_waitstatus
*ourstatus
)
909 pid_t pid
= ptid_get_pid (ptid
);
910 lwpid_t lwpid
= ptid_get_lwp (ptid
);
912 struct thread_info
*ti
;
915 /* Until proven otherwise. */
916 ourstatus
->kind
= TARGET_WAITKIND_SPURIOUS
;
921 gdb_assert (pid
!= 0 || lwpid
== 0);
928 if (ttrace_wait (pid
, lwpid
, TTRACE_WAITOK
, &tts
, sizeof tts
) == -1)
929 perror_with_name (("ttrace_wait"));
931 if (tts
.tts_event
== TTEVT_VFORK
&& tts
.tts_u
.tts_fork
.tts_isparent
)
933 if (inf_ttrace_vfork_ppid
!= -1)
935 gdb_assert (inf_ttrace_vfork_ppid
== tts
.tts_pid
);
937 if (ttrace (TT_PROC_DETACH
, tts
.tts_pid
, 0, 0, 0, 0) == -1)
938 perror_with_name (("ttrace"));
939 inf_ttrace_vfork_ppid
= -1;
942 tts
.tts_event
= TTEVT_NONE
;
946 clear_sigint_trap ();
948 while (tts
.tts_event
== TTEVT_NONE
);
950 /* Now that we've waited, we can re-enable the page protections. */
951 if (inf_ttrace_reenable_page_protections
)
953 gdb_assert (inf_ttrace_num_lwps_in_syscall
== 0);
954 inf_ttrace_enable_page_protections (tts
.tts_pid
);
955 inf_ttrace_reenable_page_protections
= 0;
958 ptid
= ptid_build (tts
.tts_pid
, tts
.tts_lwpid
, 0);
960 if (inf_ttrace_num_lwps
== 0)
962 struct thread_info
*ti
;
964 inf_ttrace_num_lwps
= 1;
966 /* This is the earliest we hear about the lwp member of
967 INFERIOR_PTID, after an attach or fork_inferior. */
968 gdb_assert (ptid_get_lwp (inferior_ptid
) == 0);
970 /* We haven't set the private member on the main thread yet. Do
972 ti
= find_thread_pid (inferior_ptid
);
973 gdb_assert (ti
!= NULL
&& ti
->private == NULL
);
975 xmalloc (sizeof (struct inf_ttrace_private_thread_info
));
976 memset (ti
->private, 0,
977 sizeof (struct inf_ttrace_private_thread_info
));
979 /* Notify the core that this ptid changed. This changes
980 inferior_ptid as well. */
981 thread_change_ptid (inferior_ptid
, ptid
);
984 switch (tts
.tts_event
)
986 #ifdef TTEVT_BPT_SSTEP
987 case TTEVT_BPT_SSTEP
:
988 /* Make it look like a breakpoint. */
989 ourstatus
->kind
= TARGET_WAITKIND_STOPPED
;
990 ourstatus
->value
.sig
= TARGET_SIGNAL_TRAP
;
995 ourstatus
->kind
= TARGET_WAITKIND_EXECD
;
996 ourstatus
->value
.execd_pathname
=
997 xmalloc (tts
.tts_u
.tts_exec
.tts_pathlen
+ 1);
998 if (ttrace (TT_PROC_GET_PATHNAME
, tts
.tts_pid
, 0,
999 (uintptr_t)ourstatus
->value
.execd_pathname
,
1000 tts
.tts_u
.tts_exec
.tts_pathlen
, 0) == -1)
1001 perror_with_name (("ttrace"));
1002 ourstatus
->value
.execd_pathname
[tts
.tts_u
.tts_exec
.tts_pathlen
] = 0;
1004 /* At this point, all inserted breakpoints are gone. Doing this
1005 as soon as we detect an exec prevents the badness of deleting
1006 a breakpoint writing the current "shadow contents" to lift
1007 the bp. That shadow is NOT valid after an exec. */
1008 mark_breakpoints_out ();
1012 store_waitstatus (ourstatus
, tts
.tts_u
.tts_exit
.tts_exitcode
);
1013 inf_ttrace_num_lwps
= 0;
1017 related_ptid
= ptid_build (tts
.tts_u
.tts_fork
.tts_fpid
,
1018 tts
.tts_u
.tts_fork
.tts_flwpid
, 0);
1020 ourstatus
->kind
= TARGET_WAITKIND_FORKED
;
1021 ourstatus
->value
.related_pid
= related_ptid
;
1023 /* Make sure the other end of the fork is stopped too. */
1024 if (ttrace_wait (tts
.tts_u
.tts_fork
.tts_fpid
,
1025 tts
.tts_u
.tts_fork
.tts_flwpid
,
1026 TTRACE_WAITOK
, &tts
, sizeof tts
) == -1)
1027 perror_with_name (("ttrace_wait"));
1029 gdb_assert (tts
.tts_event
== TTEVT_FORK
);
1030 if (tts
.tts_u
.tts_fork
.tts_isparent
)
1032 related_ptid
= ptid_build (tts
.tts_u
.tts_fork
.tts_fpid
,
1033 tts
.tts_u
.tts_fork
.tts_flwpid
, 0);
1034 ptid
= ptid_build (tts
.tts_pid
, tts
.tts_lwpid
, 0);
1035 ourstatus
->value
.related_pid
= related_ptid
;
1040 gdb_assert (!tts
.tts_u
.tts_fork
.tts_isparent
);
1042 related_ptid
= ptid_build (tts
.tts_u
.tts_fork
.tts_fpid
,
1043 tts
.tts_u
.tts_fork
.tts_flwpid
, 0);
1045 ourstatus
->kind
= TARGET_WAITKIND_VFORKED
;
1046 ourstatus
->value
.related_pid
= related_ptid
;
1048 /* HACK: To avoid touching the parent during the vfork, switch
1050 inferior_ptid
= ptid
;
1053 case TTEVT_LWP_CREATE
:
1054 lwpid
= tts
.tts_u
.tts_thread
.tts_target_lwpid
;
1055 ptid
= ptid_build (tts
.tts_pid
, lwpid
, 0);
1056 ti
= add_thread (ptid
);
1058 xmalloc (sizeof (struct inf_ttrace_private_thread_info
));
1059 memset (ti
->private, 0,
1060 sizeof (struct inf_ttrace_private_thread_info
));
1061 inf_ttrace_num_lwps
++;
1062 ptid
= ptid_build (tts
.tts_pid
, tts
.tts_lwpid
, 0);
1063 /* Let the lwp_create-caller thread continue. */
1064 ttrace (TT_LWP_CONTINUE
, ptid_get_pid (ptid
),
1065 ptid_get_lwp (ptid
), TT_NOPC
, 0, 0);
1066 /* Return without stopping the whole process. */
1067 ourstatus
->kind
= TARGET_WAITKIND_IGNORE
;
1070 case TTEVT_LWP_EXIT
:
1071 if (print_thread_events
)
1072 printf_unfiltered (_("[%s exited]\n"), target_pid_to_str (ptid
));
1073 ti
= find_thread_pid (ptid
);
1074 gdb_assert (ti
!= NULL
);
1075 ((struct inf_ttrace_private_thread_info
*)ti
->private)->dying
= 1;
1076 inf_ttrace_num_lwps
--;
1077 /* Let the thread really exit. */
1078 ttrace (TT_LWP_CONTINUE
, ptid_get_pid (ptid
),
1079 ptid_get_lwp (ptid
), TT_NOPC
, 0, 0);
1080 /* Return without stopping the whole process. */
1081 ourstatus
->kind
= TARGET_WAITKIND_IGNORE
;
1084 case TTEVT_LWP_TERMINATE
:
1085 lwpid
= tts
.tts_u
.tts_thread
.tts_target_lwpid
;
1086 ptid
= ptid_build (tts
.tts_pid
, lwpid
, 0);
1087 if (print_thread_events
)
1088 printf_unfiltered(_("[%s has been terminated]\n"),
1089 target_pid_to_str (ptid
));
1090 ti
= find_thread_pid (ptid
);
1091 gdb_assert (ti
!= NULL
);
1092 ((struct inf_ttrace_private_thread_info
*)ti
->private)->dying
= 1;
1093 inf_ttrace_num_lwps
--;
1095 /* Resume the lwp_terminate-caller thread. */
1096 ptid
= ptid_build (tts
.tts_pid
, tts
.tts_lwpid
, 0);
1097 ttrace (TT_LWP_CONTINUE
, ptid_get_pid (ptid
),
1098 ptid_get_lwp (ptid
), TT_NOPC
, 0, 0);
1099 /* Return without stopping the whole process. */
1100 ourstatus
->kind
= TARGET_WAITKIND_IGNORE
;
1104 ourstatus
->kind
= TARGET_WAITKIND_STOPPED
;
1105 ourstatus
->value
.sig
=
1106 target_signal_from_host (tts
.tts_u
.tts_signal
.tts_signo
);
1109 case TTEVT_SYSCALL_ENTRY
:
1110 gdb_assert (inf_ttrace_reenable_page_protections
== 0);
1111 inf_ttrace_num_lwps_in_syscall
++;
1112 if (inf_ttrace_num_lwps_in_syscall
== 1)
1114 /* A thread has just entered a system call. Disable any
1115 page protections as the kernel can't deal with them. */
1116 inf_ttrace_disable_page_protections (tts
.tts_pid
);
1118 ourstatus
->kind
= TARGET_WAITKIND_SYSCALL_ENTRY
;
1119 ourstatus
->value
.syscall_id
= tts
.tts_scno
;
1122 case TTEVT_SYSCALL_RETURN
:
1123 if (inf_ttrace_num_lwps_in_syscall
> 0)
1125 /* If the last thread has just left the system call, this
1126 would be a logical place to re-enable the page
1127 protections, but that doesn't work. We can't re-enable
1128 them until we've done another wait. */
1129 inf_ttrace_reenable_page_protections
=
1130 (inf_ttrace_num_lwps_in_syscall
== 1);
1131 inf_ttrace_num_lwps_in_syscall
--;
1133 ourstatus
->kind
= TARGET_WAITKIND_SYSCALL_RETURN
;
1134 ourstatus
->value
.syscall_id
= tts
.tts_scno
;
1138 gdb_assert (!"Unexpected ttrace event");
1142 /* Make sure all threads within the process are stopped. */
1143 if (ttrace (TT_PROC_STOP
, tts
.tts_pid
, 0, 0, 0, 0) == -1)
1144 perror_with_name (("ttrace"));
1146 /* Now that the whole process is stopped, check if any dying thread
1147 is really dead by now. If a dying thread is still alive, it will
1148 be stopped too, and will still show up in `info threads', tagged
1149 with "(Exiting)". We could make `info threads' prune dead
1150 threads instead via inf_ttrace_thread_alive, but doing this here
1151 has the advantage that a frontend is notificed sooner of thread
1152 exits. Note that a dying lwp is still alive, it still has to be
1153 resumed, like any other lwp. */
1154 iterate_over_threads (inf_ttrace_delete_dead_threads_callback
, NULL
);
1159 /* Transfer LEN bytes from ADDR in the inferior's memory into READBUF,
1160 and transfer LEN bytes from WRITEBUF into the inferior's memory at
1161 ADDR. Either READBUF or WRITEBUF may be null, in which case the
1162 corresponding transfer doesn't happen. Return the number of bytes
1163 actually transferred (which may be zero if an error occurs). */
1166 inf_ttrace_xfer_memory (CORE_ADDR addr
, ULONGEST len
,
1167 void *readbuf
, const void *writebuf
)
1169 pid_t pid
= ptid_get_pid (inferior_ptid
);
1171 /* HP-UX treats text space and data space differently. GDB however,
1172 doesn't really know the difference. Therefore we try both. Try
1173 text space before data space though because when we're writing
1174 into text space the instruction cache might need to be flushed. */
1177 && ttrace (TT_PROC_RDTEXT
, pid
, 0, addr
, len
, (uintptr_t)readbuf
) == -1
1178 && ttrace (TT_PROC_RDDATA
, pid
, 0, addr
, len
, (uintptr_t)readbuf
) == -1)
1182 && ttrace (TT_PROC_WRTEXT
, pid
, 0, addr
, len
, (uintptr_t)writebuf
) == -1
1183 && ttrace (TT_PROC_WRDATA
, pid
, 0, addr
, len
, (uintptr_t)writebuf
) == -1)
1190 inf_ttrace_xfer_partial (struct target_ops
*ops
, enum target_object object
,
1191 const char *annex
, gdb_byte
*readbuf
,
1192 const gdb_byte
*writebuf
, ULONGEST offset
, LONGEST len
)
1196 case TARGET_OBJECT_MEMORY
:
1197 return inf_ttrace_xfer_memory (offset
, len
, readbuf
, writebuf
);
1199 case TARGET_OBJECT_UNWIND_TABLE
:
1202 case TARGET_OBJECT_AUXV
:
1205 case TARGET_OBJECT_WCOOKIE
:
1213 /* Print status information about what we're accessing. */
1216 inf_ttrace_files_info (struct target_ops
*ignore
)
1218 printf_filtered (_("\tUsing the running image of %s %s.\n"),
1219 attach_flag
? "attached" : "child",
1220 target_pid_to_str (inferior_ptid
));
1224 inf_ttrace_thread_alive (ptid_t ptid
)
1229 /* Return a string describing the state of the thread specified by
1233 inf_ttrace_extra_thread_info (struct thread_info
*info
)
1235 struct inf_ttrace_private_thread_info
* private =
1236 (struct inf_ttrace_private_thread_info
*) info
->private;
1238 if (private != NULL
&& private->dying
)
1245 inf_ttrace_pid_to_str (ptid_t ptid
)
1247 pid_t pid
= ptid_get_pid (ptid
);
1248 lwpid_t lwpid
= ptid_get_lwp (ptid
);
1249 static char buf
[128];
1252 xsnprintf (buf
, sizeof buf
, "process %ld",
1255 xsnprintf (buf
, sizeof buf
, "process %ld, lwp %ld",
1256 (long) pid
, (long) lwpid
);
1262 inf_ttrace_target (void)
1264 struct target_ops
*t
= inf_child_target ();
1266 t
->to_attach
= inf_ttrace_attach
;
1267 t
->to_detach
= inf_ttrace_detach
;
1268 t
->to_resume
= inf_ttrace_resume
;
1269 t
->to_wait
= inf_ttrace_wait
;
1270 t
->to_files_info
= inf_ttrace_files_info
;
1271 t
->to_can_use_hw_breakpoint
= inf_ttrace_can_use_hw_breakpoint
;
1272 t
->to_insert_watchpoint
= inf_ttrace_insert_watchpoint
;
1273 t
->to_remove_watchpoint
= inf_ttrace_remove_watchpoint
;
1274 t
->to_stopped_by_watchpoint
= inf_ttrace_stopped_by_watchpoint
;
1275 t
->to_region_ok_for_hw_watchpoint
=
1276 inf_ttrace_region_ok_for_hw_watchpoint
;
1277 t
->to_kill
= inf_ttrace_kill
;
1278 t
->to_create_inferior
= inf_ttrace_create_inferior
;
1279 t
->to_follow_fork
= inf_ttrace_follow_fork
;
1280 t
->to_mourn_inferior
= inf_ttrace_mourn_inferior
;
1281 t
->to_thread_alive
= inf_ttrace_thread_alive
;
1282 t
->to_extra_thread_info
= inf_ttrace_extra_thread_info
;
1283 t
->to_pid_to_str
= inf_ttrace_pid_to_str
;
1284 t
->to_xfer_partial
= inf_ttrace_xfer_partial
;
1286 ttrace_ops_hack
= t
;
1292 /* Prevent warning from -Wmissing-prototypes. */
1293 void _initialize_hppa_hpux_nat (void);
1296 _initialize_inf_ttrace (void)
1299 inf_ttrace_page_dict
.pagesize
= getpagesize();