1 /* Low-level child interface to ttrace.
3 Copyright (C) 2004, 2005, 2006, 2007, 2008, 2009
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 3 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, see <http://www.gnu.org/licenses/>. */
23 /* The ttrace(2) system call didn't exist before HP-UX 10.30. Don't
24 try to compile this code unless we have it. */
29 #include "gdbthread.h"
34 #include "gdb_assert.h"
35 #include "gdb_string.h"
37 #include <sys/ttrace.h>
40 #include "inf-child.h"
41 #include "inf-ttrace.h"
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
*tp
= inferior_thread ();
417 gdb_assert (tp
->pending_follow
.kind
== TARGET_WAITKIND_FORKED
418 || tp
->pending_follow
.kind
== TARGET_WAITKIND_VFORKED
);
420 pid
= ptid_get_pid (inferior_ptid
);
421 lwpid
= ptid_get_lwp (inferior_ptid
);
423 /* Get all important details that core GDB doesn't (and shouldn't)
425 if (ttrace (TT_LWP_GET_STATE
, pid
, lwpid
,
426 (uintptr_t)&tts
, sizeof tts
, 0) == -1)
427 perror_with_name (("ttrace"));
429 gdb_assert (tts
.tts_event
== TTEVT_FORK
|| tts
.tts_event
== TTEVT_VFORK
);
431 if (tts
.tts_u
.tts_fork
.tts_isparent
)
434 lwpid
= tts
.tts_lwpid
;
435 fpid
= tts
.tts_u
.tts_fork
.tts_fpid
;
436 flwpid
= tts
.tts_u
.tts_fork
.tts_flwpid
;
440 pid
= tts
.tts_u
.tts_fork
.tts_fpid
;
441 lwpid
= tts
.tts_u
.tts_fork
.tts_flwpid
;
443 flwpid
= tts
.tts_lwpid
;
448 struct inferior
*inf
;
449 struct inferior
*parent_inf
;
451 parent_inf
= find_inferior_pid (pid
);
453 inferior_ptid
= ptid_build (fpid
, flwpid
, 0);
454 inf
= add_inferior (fpid
);
455 inf
->attach_flag
= parent_inf
->attach_flag
;
456 copy_terminal_info (inf
, parent_inf
);
457 detach_breakpoints (pid
);
459 target_terminal_ours ();
460 fprintf_unfiltered (gdb_stdlog
, _("\
461 Attaching after fork to child process %ld.\n"), (long)fpid
);
465 inferior_ptid
= ptid_build (pid
, lwpid
, 0);
466 detach_breakpoints (fpid
);
468 target_terminal_ours ();
469 fprintf_unfiltered (gdb_stdlog
, _("\
470 Detaching after fork from child process %ld.\n"), (long)fpid
);
473 if (tts
.tts_event
== TTEVT_VFORK
)
475 gdb_assert (!tts
.tts_u
.tts_fork
.tts_isparent
);
479 /* We can't detach from the parent yet. */
480 inf_ttrace_vfork_ppid
= pid
;
482 reattach_breakpoints (fpid
);
486 if (ttrace (TT_PROC_DETACH
, fpid
, 0, 0, 0, 0) == -1)
487 perror_with_name (("ttrace"));
489 /* Wait till we get the TTEVT_VFORK event in the parent.
490 This indicates that the child has called exec(3) or has
491 exited and that the parent is ready to be traced again. */
492 if (ttrace_wait (pid
, lwpid
, TTRACE_WAITOK
, &tts
, sizeof tts
) == -1)
493 perror_with_name (("ttrace_wait"));
494 gdb_assert (tts
.tts_event
== TTEVT_VFORK
);
495 gdb_assert (tts
.tts_u
.tts_fork
.tts_isparent
);
497 reattach_breakpoints (pid
);
502 gdb_assert (tts
.tts_u
.tts_fork
.tts_isparent
);
506 if (ttrace (TT_PROC_DETACH
, pid
, 0, 0, 0, 0) == -1)
507 perror_with_name (("ttrace"));
511 if (ttrace (TT_PROC_DETACH
, fpid
, 0, 0, 0, 0) == -1)
512 perror_with_name (("ttrace"));
518 struct thread_info
*ti
;
520 /* The child will start out single-threaded. */
521 inf_ttrace_num_lwps
= 1;
522 inf_ttrace_num_lwps_in_syscall
= 0;
525 delete_thread_silent (ptid_build (pid
, lwpid
, 0));
526 detach_inferior (pid
);
528 /* Add child thread. inferior_ptid was already set above. */
529 ti
= add_thread_silent (inferior_ptid
);
531 xmalloc (sizeof (struct inf_ttrace_private_thread_info
));
532 memset (ti
->private, 0,
533 sizeof (struct inf_ttrace_private_thread_info
));
540 /* File descriptors for pipes used as semaphores during initial
541 startup of an inferior. */
542 static int inf_ttrace_pfd1
[2];
543 static int inf_ttrace_pfd2
[2];
546 do_cleanup_pfds (void *dummy
)
548 close (inf_ttrace_pfd1
[0]);
549 close (inf_ttrace_pfd1
[1]);
550 close (inf_ttrace_pfd2
[0]);
551 close (inf_ttrace_pfd2
[1]);
555 inf_ttrace_prepare (void)
557 if (pipe (inf_ttrace_pfd1
) == -1)
558 perror_with_name (("pipe"));
560 if (pipe (inf_ttrace_pfd2
) == -1)
562 close (inf_ttrace_pfd1
[0]);
563 close (inf_ttrace_pfd2
[0]);
564 perror_with_name (("pipe"));
568 /* Prepare to be traced. */
573 struct cleanup
*old_chain
= make_cleanup (do_cleanup_pfds
, 0);
576 /* "Trace me, Dr. Memory!" */
577 if (ttrace (TT_PROC_SETTRC
, 0, 0, 0, TT_VERSION
, 0) == -1)
578 perror_with_name (("ttrace"));
580 /* Tell our parent that we are ready to be traced. */
581 if (write (inf_ttrace_pfd1
[1], &c
, sizeof c
) != sizeof c
)
582 perror_with_name (("write"));
584 /* Wait until our parent has set the initial event mask. */
585 if (read (inf_ttrace_pfd2
[0], &c
, sizeof c
) != sizeof c
)
586 perror_with_name (("read"));
588 do_cleanups (old_chain
);
591 /* Start tracing PID. */
594 inf_ttrace_him (struct target_ops
*ops
, int pid
)
596 struct cleanup
*old_chain
= make_cleanup (do_cleanup_pfds
, 0);
600 /* Wait until our child is ready to be traced. */
601 if (read (inf_ttrace_pfd1
[0], &c
, sizeof c
) != sizeof c
)
602 perror_with_name (("read"));
604 /* Set the initial event mask. */
605 memset (&tte
, 0, sizeof (tte
));
606 tte
.tte_events
|= TTEVT_EXEC
| TTEVT_EXIT
| TTEVT_FORK
| TTEVT_VFORK
;
607 tte
.tte_events
|= TTEVT_LWP_CREATE
| TTEVT_LWP_EXIT
| TTEVT_LWP_TERMINATE
;
608 #ifdef TTEVT_BPT_SSTEP
609 tte
.tte_events
|= TTEVT_BPT_SSTEP
;
611 tte
.tte_opts
|= TTEO_PROC_INHERIT
;
612 if (ttrace (TT_PROC_SET_EVENT_MASK
, pid
, 0,
613 (uintptr_t)&tte
, sizeof tte
, 0) == -1)
614 perror_with_name (("ttrace"));
616 /* Tell our child that we have set the initial event mask. */
617 if (write (inf_ttrace_pfd2
[1], &c
, sizeof c
) != sizeof c
)
618 perror_with_name (("write"));
620 do_cleanups (old_chain
);
624 /* On some targets, there must be some explicit synchronization
625 between the parent and child processes after the debugger forks,
626 and before the child execs the debuggee program. This call
627 basically gives permission for the child to exec. */
629 target_acknowledge_created_inferior (pid
);
631 /* START_INFERIOR_TRAPS_EXPECTED is defined in inferior.h, and will
632 be 1 or 2 depending on whether we're starting without or with a
634 startup_inferior (START_INFERIOR_TRAPS_EXPECTED
);
636 /* On some targets, there must be some explicit actions taken after
637 the inferior has been started up. */
638 target_post_startup_inferior (pid_to_ptid (pid
));
642 inf_ttrace_create_inferior (struct target_ops
*ops
, char *exec_file
,
643 char *allargs
, char **env
, int from_tty
)
647 gdb_assert (inf_ttrace_num_lwps
== 0);
648 gdb_assert (inf_ttrace_num_lwps_in_syscall
== 0);
649 gdb_assert (inf_ttrace_page_dict
.count
== 0);
650 gdb_assert (inf_ttrace_reenable_page_protections
== 0);
651 gdb_assert (inf_ttrace_vfork_ppid
== -1);
653 pid
= fork_inferior (exec_file
, allargs
, env
, inf_ttrace_me
, NULL
,
654 inf_ttrace_prepare
, NULL
);
656 inf_ttrace_him (ops
, pid
);
660 inf_ttrace_mourn_inferior (struct target_ops
*ops
)
662 const int num_buckets
= ARRAY_SIZE (inf_ttrace_page_dict
.buckets
);
665 inf_ttrace_num_lwps
= 0;
666 inf_ttrace_num_lwps_in_syscall
= 0;
668 for (bucket
= 0; bucket
< num_buckets
; bucket
++)
670 struct inf_ttrace_page
*page
;
671 struct inf_ttrace_page
*next
;
673 page
= inf_ttrace_page_dict
.buckets
[bucket
].next
;
681 inf_ttrace_page_dict
.count
= 0;
684 generic_mourn_inferior ();
688 inf_ttrace_attach (struct target_ops
*ops
, char *args
, int from_tty
)
694 struct inferior
*inf
;
697 error_no_arg (_("process-id to attach"));
700 pid
= strtol (args
, &dummy
, 0);
701 if (pid
== 0 && args
== dummy
)
702 error (_("Illegal process-id: %s."), args
);
704 if (pid
== getpid ()) /* Trying to masturbate? */
705 error (_("I refuse to debug myself!"));
709 exec_file
= get_exec_file (0);
712 printf_unfiltered (_("Attaching to program: %s, %s\n"), exec_file
,
713 target_pid_to_str (pid_to_ptid (pid
)));
715 printf_unfiltered (_("Attaching to %s\n"),
716 target_pid_to_str (pid_to_ptid (pid
)));
718 gdb_flush (gdb_stdout
);
721 gdb_assert (inf_ttrace_num_lwps
== 0);
722 gdb_assert (inf_ttrace_num_lwps_in_syscall
== 0);
723 gdb_assert (inf_ttrace_vfork_ppid
== -1);
725 if (ttrace (TT_PROC_ATTACH
, pid
, 0, TT_KILL_ON_EXIT
, TT_VERSION
, 0) == -1)
726 perror_with_name (("ttrace"));
728 inf
= add_inferior (pid
);
729 inf
->attach_flag
= 1;
731 /* Set the initial event mask. */
732 memset (&tte
, 0, sizeof (tte
));
733 tte
.tte_events
|= TTEVT_EXEC
| TTEVT_EXIT
| TTEVT_FORK
| TTEVT_VFORK
;
734 tte
.tte_events
|= TTEVT_LWP_CREATE
| TTEVT_LWP_EXIT
| TTEVT_LWP_TERMINATE
;
735 #ifdef TTEVT_BPT_SSTEP
736 tte
.tte_events
|= TTEVT_BPT_SSTEP
;
738 tte
.tte_opts
|= TTEO_PROC_INHERIT
;
739 if (ttrace (TT_PROC_SET_EVENT_MASK
, pid
, 0,
740 (uintptr_t)&tte
, sizeof tte
, 0) == -1)
741 perror_with_name (("ttrace"));
745 /* We'll bump inf_ttrace_num_lwps up and add the private data to the
746 thread as soon as we get to inf_ttrace_wait. At this point, we
747 don't have lwpid info yet. */
748 inferior_ptid
= pid_to_ptid (pid
);
749 add_thread_silent (inferior_ptid
);
753 inf_ttrace_detach (struct target_ops
*ops
, char *args
, int from_tty
)
755 pid_t pid
= ptid_get_pid (inferior_ptid
);
760 char *exec_file
= get_exec_file (0);
763 printf_unfiltered (_("Detaching from program: %s, %s\n"), exec_file
,
764 target_pid_to_str (pid_to_ptid (pid
)));
765 gdb_flush (gdb_stdout
);
770 /* ??? The HP-UX 11.0 ttrace(2) manual page doesn't mention that we
771 can pass a signal number here. Does this really work? */
772 if (ttrace (TT_PROC_DETACH
, pid
, 0, 0, sig
, 0) == -1)
773 perror_with_name (("ttrace"));
775 if (inf_ttrace_vfork_ppid
!= -1)
777 if (ttrace (TT_PROC_DETACH
, inf_ttrace_vfork_ppid
, 0, 0, 0, 0) == -1)
778 perror_with_name (("ttrace"));
779 inf_ttrace_vfork_ppid
= -1;
782 inf_ttrace_num_lwps
= 0;
783 inf_ttrace_num_lwps_in_syscall
= 0;
785 inferior_ptid
= null_ptid
;
786 detach_inferior (pid
);
792 inf_ttrace_kill (struct target_ops
*ops
)
794 pid_t pid
= ptid_get_pid (inferior_ptid
);
799 if (ttrace (TT_PROC_EXIT
, pid
, 0, 0, 0, 0) == -1)
800 perror_with_name (("ttrace"));
801 /* ??? Is it necessary to call ttrace_wait() here? */
803 if (inf_ttrace_vfork_ppid
!= -1)
805 if (ttrace (TT_PROC_DETACH
, inf_ttrace_vfork_ppid
, 0, 0, 0, 0) == -1)
806 perror_with_name (("ttrace"));
807 inf_ttrace_vfork_ppid
= -1;
810 target_mourn_inferior ();
813 /* Check is a dying thread is dead by now, and delete it from GDBs
814 thread list if so. */
816 inf_ttrace_delete_dead_threads_callback (struct thread_info
*info
, void *arg
)
819 struct inf_ttrace_private_thread_info
*p
;
821 if (is_exited (info
->ptid
))
824 lwpid
= ptid_get_lwp (info
->ptid
);
825 p
= (struct inf_ttrace_private_thread_info
*) info
->private;
827 /* Check if an lwp that was dying is still there or not. */
828 if (p
->dying
&& (kill (lwpid
, 0) == -1))
830 delete_thread (info
->ptid
);
835 /* Resume the lwp pointed to by INFO, with REQUEST, and pass it signal
839 inf_ttrace_resume_lwp (struct thread_info
*info
, ttreq_t request
, int sig
)
841 pid_t pid
= ptid_get_pid (info
->ptid
);
842 lwpid_t lwpid
= ptid_get_lwp (info
->ptid
);
844 if (ttrace (request
, pid
, lwpid
, TT_NOPC
, sig
, 0) == -1)
846 struct inf_ttrace_private_thread_info
*p
847 = (struct inf_ttrace_private_thread_info
*) info
->private;
848 if (p
->dying
&& errno
== EPROTO
)
849 /* This is expected, it means the dying lwp is really gone
850 by now. If ttrace had an event to inform the debugger
851 the lwp is really gone, this wouldn't be needed. */
852 delete_thread (info
->ptid
);
854 /* This was really unexpected. */
855 perror_with_name (("ttrace"));
859 /* Callback for iterate_over_threads. */
862 inf_ttrace_resume_callback (struct thread_info
*info
, void *arg
)
864 if (!ptid_equal (info
->ptid
, inferior_ptid
) && !is_exited (info
->ptid
))
865 inf_ttrace_resume_lwp (info
, TT_LWP_CONTINUE
, 0);
871 inf_ttrace_resume (struct target_ops
*ops
,
872 ptid_t ptid
, int step
, enum target_signal signal
)
875 ttreq_t request
= step
? TT_LWP_SINGLE
: TT_LWP_CONTINUE
;
876 int sig
= target_signal_to_host (signal
);
877 struct thread_info
*info
;
879 /* A specific PTID means `step only this process id'. */
880 resume_all
= (ptid_equal (ptid
, minus_one_ptid
));
882 /* If resuming all threads, it's the current thread that should be
883 handled specially. */
885 ptid
= inferior_ptid
;
887 info
= find_thread_ptid (ptid
);
888 inf_ttrace_resume_lwp (info
, request
, sig
);
891 /* Let all the other threads run too. */
892 iterate_over_threads (inf_ttrace_resume_callback
, NULL
);
896 inf_ttrace_wait (struct target_ops
*ops
,
897 ptid_t ptid
, struct target_waitstatus
*ourstatus
, int options
)
899 pid_t pid
= ptid_get_pid (ptid
);
900 lwpid_t lwpid
= ptid_get_lwp (ptid
);
902 struct thread_info
*ti
;
905 /* Until proven otherwise. */
906 ourstatus
->kind
= TARGET_WAITKIND_SPURIOUS
;
911 gdb_assert (pid
!= 0 || lwpid
== 0);
917 if (ttrace_wait (pid
, lwpid
, TTRACE_WAITOK
, &tts
, sizeof tts
) == -1)
918 perror_with_name (("ttrace_wait"));
920 if (tts
.tts_event
== TTEVT_VFORK
&& tts
.tts_u
.tts_fork
.tts_isparent
)
922 if (inf_ttrace_vfork_ppid
!= -1)
924 gdb_assert (inf_ttrace_vfork_ppid
== tts
.tts_pid
);
926 if (ttrace (TT_PROC_DETACH
, tts
.tts_pid
, 0, 0, 0, 0) == -1)
927 perror_with_name (("ttrace"));
928 inf_ttrace_vfork_ppid
= -1;
931 tts
.tts_event
= TTEVT_NONE
;
934 clear_sigint_trap ();
936 while (tts
.tts_event
== TTEVT_NONE
);
938 /* Now that we've waited, we can re-enable the page protections. */
939 if (inf_ttrace_reenable_page_protections
)
941 gdb_assert (inf_ttrace_num_lwps_in_syscall
== 0);
942 inf_ttrace_enable_page_protections (tts
.tts_pid
);
943 inf_ttrace_reenable_page_protections
= 0;
946 ptid
= ptid_build (tts
.tts_pid
, tts
.tts_lwpid
, 0);
948 if (inf_ttrace_num_lwps
== 0)
950 struct thread_info
*ti
;
952 inf_ttrace_num_lwps
= 1;
954 /* This is the earliest we hear about the lwp member of
955 INFERIOR_PTID, after an attach or fork_inferior. */
956 gdb_assert (ptid_get_lwp (inferior_ptid
) == 0);
958 /* We haven't set the private member on the main thread yet. Do
960 ti
= find_thread_ptid (inferior_ptid
);
961 gdb_assert (ti
!= NULL
&& ti
->private == NULL
);
963 xmalloc (sizeof (struct inf_ttrace_private_thread_info
));
964 memset (ti
->private, 0,
965 sizeof (struct inf_ttrace_private_thread_info
));
967 /* Notify the core that this ptid changed. This changes
968 inferior_ptid as well. */
969 thread_change_ptid (inferior_ptid
, ptid
);
972 switch (tts
.tts_event
)
974 #ifdef TTEVT_BPT_SSTEP
975 case TTEVT_BPT_SSTEP
:
976 /* Make it look like a breakpoint. */
977 ourstatus
->kind
= TARGET_WAITKIND_STOPPED
;
978 ourstatus
->value
.sig
= TARGET_SIGNAL_TRAP
;
983 ourstatus
->kind
= TARGET_WAITKIND_EXECD
;
984 ourstatus
->value
.execd_pathname
=
985 xmalloc (tts
.tts_u
.tts_exec
.tts_pathlen
+ 1);
986 if (ttrace (TT_PROC_GET_PATHNAME
, tts
.tts_pid
, 0,
987 (uintptr_t)ourstatus
->value
.execd_pathname
,
988 tts
.tts_u
.tts_exec
.tts_pathlen
, 0) == -1)
989 perror_with_name (("ttrace"));
990 ourstatus
->value
.execd_pathname
[tts
.tts_u
.tts_exec
.tts_pathlen
] = 0;
992 /* At this point, all inserted breakpoints are gone. Doing this
993 as soon as we detect an exec prevents the badness of deleting
994 a breakpoint writing the current "shadow contents" to lift
995 the bp. That shadow is NOT valid after an exec. */
996 mark_breakpoints_out ();
1000 store_waitstatus (ourstatus
, tts
.tts_u
.tts_exit
.tts_exitcode
);
1001 inf_ttrace_num_lwps
= 0;
1005 related_ptid
= ptid_build (tts
.tts_u
.tts_fork
.tts_fpid
,
1006 tts
.tts_u
.tts_fork
.tts_flwpid
, 0);
1008 ourstatus
->kind
= TARGET_WAITKIND_FORKED
;
1009 ourstatus
->value
.related_pid
= related_ptid
;
1011 /* Make sure the other end of the fork is stopped too. */
1012 if (ttrace_wait (tts
.tts_u
.tts_fork
.tts_fpid
,
1013 tts
.tts_u
.tts_fork
.tts_flwpid
,
1014 TTRACE_WAITOK
, &tts
, sizeof tts
) == -1)
1015 perror_with_name (("ttrace_wait"));
1017 gdb_assert (tts
.tts_event
== TTEVT_FORK
);
1018 if (tts
.tts_u
.tts_fork
.tts_isparent
)
1020 related_ptid
= ptid_build (tts
.tts_u
.tts_fork
.tts_fpid
,
1021 tts
.tts_u
.tts_fork
.tts_flwpid
, 0);
1022 ptid
= ptid_build (tts
.tts_pid
, tts
.tts_lwpid
, 0);
1023 ourstatus
->value
.related_pid
= related_ptid
;
1028 gdb_assert (!tts
.tts_u
.tts_fork
.tts_isparent
);
1030 related_ptid
= ptid_build (tts
.tts_u
.tts_fork
.tts_fpid
,
1031 tts
.tts_u
.tts_fork
.tts_flwpid
, 0);
1033 ourstatus
->kind
= TARGET_WAITKIND_VFORKED
;
1034 ourstatus
->value
.related_pid
= related_ptid
;
1036 /* HACK: To avoid touching the parent during the vfork, switch
1038 inferior_ptid
= ptid
;
1041 case TTEVT_LWP_CREATE
:
1042 lwpid
= tts
.tts_u
.tts_thread
.tts_target_lwpid
;
1043 ptid
= ptid_build (tts
.tts_pid
, lwpid
, 0);
1044 ti
= add_thread (ptid
);
1046 xmalloc (sizeof (struct inf_ttrace_private_thread_info
));
1047 memset (ti
->private, 0,
1048 sizeof (struct inf_ttrace_private_thread_info
));
1049 inf_ttrace_num_lwps
++;
1050 ptid
= ptid_build (tts
.tts_pid
, tts
.tts_lwpid
, 0);
1051 /* Let the lwp_create-caller thread continue. */
1052 ttrace (TT_LWP_CONTINUE
, ptid_get_pid (ptid
),
1053 ptid_get_lwp (ptid
), TT_NOPC
, 0, 0);
1054 /* Return without stopping the whole process. */
1055 ourstatus
->kind
= TARGET_WAITKIND_IGNORE
;
1058 case TTEVT_LWP_EXIT
:
1059 if (print_thread_events
)
1060 printf_unfiltered (_("[%s exited]\n"), target_pid_to_str (ptid
));
1061 ti
= find_thread_ptid (ptid
);
1062 gdb_assert (ti
!= NULL
);
1063 ((struct inf_ttrace_private_thread_info
*)ti
->private)->dying
= 1;
1064 inf_ttrace_num_lwps
--;
1065 /* Let the thread really exit. */
1066 ttrace (TT_LWP_CONTINUE
, ptid_get_pid (ptid
),
1067 ptid_get_lwp (ptid
), TT_NOPC
, 0, 0);
1068 /* Return without stopping the whole process. */
1069 ourstatus
->kind
= TARGET_WAITKIND_IGNORE
;
1072 case TTEVT_LWP_TERMINATE
:
1073 lwpid
= tts
.tts_u
.tts_thread
.tts_target_lwpid
;
1074 ptid
= ptid_build (tts
.tts_pid
, lwpid
, 0);
1075 if (print_thread_events
)
1076 printf_unfiltered(_("[%s has been terminated]\n"),
1077 target_pid_to_str (ptid
));
1078 ti
= find_thread_ptid (ptid
);
1079 gdb_assert (ti
!= NULL
);
1080 ((struct inf_ttrace_private_thread_info
*)ti
->private)->dying
= 1;
1081 inf_ttrace_num_lwps
--;
1083 /* Resume the lwp_terminate-caller thread. */
1084 ptid
= ptid_build (tts
.tts_pid
, tts
.tts_lwpid
, 0);
1085 ttrace (TT_LWP_CONTINUE
, ptid_get_pid (ptid
),
1086 ptid_get_lwp (ptid
), TT_NOPC
, 0, 0);
1087 /* Return without stopping the whole process. */
1088 ourstatus
->kind
= TARGET_WAITKIND_IGNORE
;
1092 ourstatus
->kind
= TARGET_WAITKIND_STOPPED
;
1093 ourstatus
->value
.sig
=
1094 target_signal_from_host (tts
.tts_u
.tts_signal
.tts_signo
);
1097 case TTEVT_SYSCALL_ENTRY
:
1098 gdb_assert (inf_ttrace_reenable_page_protections
== 0);
1099 inf_ttrace_num_lwps_in_syscall
++;
1100 if (inf_ttrace_num_lwps_in_syscall
== 1)
1102 /* A thread has just entered a system call. Disable any
1103 page protections as the kernel can't deal with them. */
1104 inf_ttrace_disable_page_protections (tts
.tts_pid
);
1106 ourstatus
->kind
= TARGET_WAITKIND_SYSCALL_ENTRY
;
1107 ourstatus
->value
.syscall_number
= tts
.tts_scno
;
1110 case TTEVT_SYSCALL_RETURN
:
1111 if (inf_ttrace_num_lwps_in_syscall
> 0)
1113 /* If the last thread has just left the system call, this
1114 would be a logical place to re-enable the page
1115 protections, but that doesn't work. We can't re-enable
1116 them until we've done another wait. */
1117 inf_ttrace_reenable_page_protections
=
1118 (inf_ttrace_num_lwps_in_syscall
== 1);
1119 inf_ttrace_num_lwps_in_syscall
--;
1121 ourstatus
->kind
= TARGET_WAITKIND_SYSCALL_RETURN
;
1122 ourstatus
->value
.syscall_number
= tts
.tts_scno
;
1126 gdb_assert (!"Unexpected ttrace event");
1130 /* Make sure all threads within the process are stopped. */
1131 if (ttrace (TT_PROC_STOP
, tts
.tts_pid
, 0, 0, 0, 0) == -1)
1132 perror_with_name (("ttrace"));
1134 /* Now that the whole process is stopped, check if any dying thread
1135 is really dead by now. If a dying thread is still alive, it will
1136 be stopped too, and will still show up in `info threads', tagged
1137 with "(Exiting)". We could make `info threads' prune dead
1138 threads instead via inf_ttrace_thread_alive, but doing this here
1139 has the advantage that a frontend is notificed sooner of thread
1140 exits. Note that a dying lwp is still alive, it still has to be
1141 resumed, like any other lwp. */
1142 iterate_over_threads (inf_ttrace_delete_dead_threads_callback
, NULL
);
1147 /* Transfer LEN bytes from ADDR in the inferior's memory into READBUF,
1148 and transfer LEN bytes from WRITEBUF into the inferior's memory at
1149 ADDR. Either READBUF or WRITEBUF may be null, in which case the
1150 corresponding transfer doesn't happen. Return the number of bytes
1151 actually transferred (which may be zero if an error occurs). */
1154 inf_ttrace_xfer_memory (CORE_ADDR addr
, ULONGEST len
,
1155 void *readbuf
, const void *writebuf
)
1157 pid_t pid
= ptid_get_pid (inferior_ptid
);
1159 /* HP-UX treats text space and data space differently. GDB however,
1160 doesn't really know the difference. Therefore we try both. Try
1161 text space before data space though because when we're writing
1162 into text space the instruction cache might need to be flushed. */
1165 && ttrace (TT_PROC_RDTEXT
, pid
, 0, addr
, len
, (uintptr_t)readbuf
) == -1
1166 && ttrace (TT_PROC_RDDATA
, pid
, 0, addr
, len
, (uintptr_t)readbuf
) == -1)
1170 && ttrace (TT_PROC_WRTEXT
, pid
, 0, addr
, len
, (uintptr_t)writebuf
) == -1
1171 && ttrace (TT_PROC_WRDATA
, pid
, 0, addr
, len
, (uintptr_t)writebuf
) == -1)
1178 inf_ttrace_xfer_partial (struct target_ops
*ops
, enum target_object object
,
1179 const char *annex
, gdb_byte
*readbuf
,
1180 const gdb_byte
*writebuf
, ULONGEST offset
, LONGEST len
)
1184 case TARGET_OBJECT_MEMORY
:
1185 return inf_ttrace_xfer_memory (offset
, len
, readbuf
, writebuf
);
1187 case TARGET_OBJECT_UNWIND_TABLE
:
1190 case TARGET_OBJECT_AUXV
:
1193 case TARGET_OBJECT_WCOOKIE
:
1201 /* Print status information about what we're accessing. */
1204 inf_ttrace_files_info (struct target_ops
*ignore
)
1206 struct inferior
*inf
= current_inferior ();
1207 printf_filtered (_("\tUsing the running image of %s %s.\n"),
1208 inf
->attach_flag
? "attached" : "child",
1209 target_pid_to_str (inferior_ptid
));
1213 inf_ttrace_thread_alive (struct target_ops
*ops
, ptid_t ptid
)
1218 /* Return a string describing the state of the thread specified by
1222 inf_ttrace_extra_thread_info (struct thread_info
*info
)
1224 struct inf_ttrace_private_thread_info
* private =
1225 (struct inf_ttrace_private_thread_info
*) info
->private;
1227 if (private != NULL
&& private->dying
)
1234 inf_ttrace_pid_to_str (struct target_ops
*ops
, ptid_t ptid
)
1236 pid_t pid
= ptid_get_pid (ptid
);
1237 lwpid_t lwpid
= ptid_get_lwp (ptid
);
1238 static char buf
[128];
1241 xsnprintf (buf
, sizeof buf
, "process %ld",
1244 xsnprintf (buf
, sizeof buf
, "process %ld, lwp %ld",
1245 (long) pid
, (long) lwpid
);
1251 inf_ttrace_target (void)
1253 struct target_ops
*t
= inf_child_target ();
1255 t
->to_attach
= inf_ttrace_attach
;
1256 t
->to_detach
= inf_ttrace_detach
;
1257 t
->to_resume
= inf_ttrace_resume
;
1258 t
->to_wait
= inf_ttrace_wait
;
1259 t
->to_files_info
= inf_ttrace_files_info
;
1260 t
->to_can_use_hw_breakpoint
= inf_ttrace_can_use_hw_breakpoint
;
1261 t
->to_insert_watchpoint
= inf_ttrace_insert_watchpoint
;
1262 t
->to_remove_watchpoint
= inf_ttrace_remove_watchpoint
;
1263 t
->to_stopped_by_watchpoint
= inf_ttrace_stopped_by_watchpoint
;
1264 t
->to_region_ok_for_hw_watchpoint
=
1265 inf_ttrace_region_ok_for_hw_watchpoint
;
1266 t
->to_kill
= inf_ttrace_kill
;
1267 t
->to_create_inferior
= inf_ttrace_create_inferior
;
1268 t
->to_follow_fork
= inf_ttrace_follow_fork
;
1269 t
->to_mourn_inferior
= inf_ttrace_mourn_inferior
;
1270 t
->to_thread_alive
= inf_ttrace_thread_alive
;
1271 t
->to_extra_thread_info
= inf_ttrace_extra_thread_info
;
1272 t
->to_pid_to_str
= inf_ttrace_pid_to_str
;
1273 t
->to_xfer_partial
= inf_ttrace_xfer_partial
;
1280 /* Prevent warning from -Wmissing-prototypes. */
1281 void _initialize_hppa_hpux_nat (void);
1284 _initialize_inf_ttrace (void)
1287 inf_ttrace_page_dict
.pagesize
= getpagesize();