1 /* Low-level child interface to ttrace.
3 Copyright (C) 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011
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
,
318 struct expression
*cond
)
320 const int pagesize
= inf_ttrace_page_dict
.pagesize
;
321 pid_t pid
= ptid_get_pid (inferior_ptid
);
326 gdb_assert (type
== hw_write
);
328 page_addr
= (addr
/ pagesize
) * pagesize
;
329 num_pages
= (len
+ pagesize
- 1) / pagesize
;
331 for (page
= 0; page
< num_pages
; page
++, page_addr
+= pagesize
)
332 inf_ttrace_insert_page (pid
, page_addr
);
337 /* Remove a "hardware" watchpoint for LEN bytes at address ADDR of
341 inf_ttrace_remove_watchpoint (CORE_ADDR addr
, int len
, int type
,
342 struct expression
*cond
)
344 const int pagesize
= inf_ttrace_page_dict
.pagesize
;
345 pid_t pid
= ptid_get_pid (inferior_ptid
);
350 gdb_assert (type
== hw_write
);
352 page_addr
= (addr
/ pagesize
) * pagesize
;
353 num_pages
= (len
+ pagesize
- 1) / pagesize
;
355 for (page
= 0; page
< num_pages
; page
++, page_addr
+= pagesize
)
356 inf_ttrace_remove_page (pid
, page_addr
);
362 inf_ttrace_can_use_hw_breakpoint (int type
, int len
, int ot
)
364 return (type
== bp_hardware_watchpoint
);
368 inf_ttrace_region_ok_for_hw_watchpoint (CORE_ADDR addr
, int len
)
373 /* Return non-zero if the current inferior was (potentially) stopped
374 by hitting a "hardware" watchpoint. */
377 inf_ttrace_stopped_by_watchpoint (void)
379 pid_t pid
= ptid_get_pid (inferior_ptid
);
380 lwpid_t lwpid
= ptid_get_lwp (inferior_ptid
);
383 if (inf_ttrace_page_dict
.count
> 0)
385 if (ttrace (TT_LWP_GET_STATE
, pid
, lwpid
,
386 (uintptr_t)&tts
, sizeof tts
, 0) == -1)
387 perror_with_name (("ttrace"));
389 if (tts
.tts_event
== TTEVT_SIGNAL
390 && tts
.tts_u
.tts_signal
.tts_signo
== SIGBUS
)
392 const int pagesize
= inf_ttrace_page_dict
.pagesize
;
393 void *addr
= tts
.tts_u
.tts_signal
.tts_siginfo
.si_addr
;
394 CORE_ADDR page_addr
= ((uintptr_t)addr
/ pagesize
) * pagesize
;
396 if (inf_ttrace_get_page (pid
, page_addr
))
405 /* When tracking a vfork(2), we cannot detach from the parent until
406 after the child has called exec(3) or has exited. If we are still
407 attached to the parent, this variable will be set to the process ID
408 of the parent. Otherwise it will be set to zero. */
409 static pid_t inf_ttrace_vfork_ppid
= -1;
412 inf_ttrace_follow_fork (struct target_ops
*ops
, int follow_child
)
415 lwpid_t lwpid
, flwpid
;
417 struct thread_info
*tp
= inferior_thread ();
419 gdb_assert (tp
->pending_follow
.kind
== TARGET_WAITKIND_FORKED
420 || tp
->pending_follow
.kind
== TARGET_WAITKIND_VFORKED
);
422 pid
= ptid_get_pid (inferior_ptid
);
423 lwpid
= ptid_get_lwp (inferior_ptid
);
425 /* Get all important details that core GDB doesn't (and shouldn't)
427 if (ttrace (TT_LWP_GET_STATE
, pid
, lwpid
,
428 (uintptr_t)&tts
, sizeof tts
, 0) == -1)
429 perror_with_name (("ttrace"));
431 gdb_assert (tts
.tts_event
== TTEVT_FORK
|| tts
.tts_event
== TTEVT_VFORK
);
433 if (tts
.tts_u
.tts_fork
.tts_isparent
)
436 lwpid
= tts
.tts_lwpid
;
437 fpid
= tts
.tts_u
.tts_fork
.tts_fpid
;
438 flwpid
= tts
.tts_u
.tts_fork
.tts_flwpid
;
442 pid
= tts
.tts_u
.tts_fork
.tts_fpid
;
443 lwpid
= tts
.tts_u
.tts_fork
.tts_flwpid
;
445 flwpid
= tts
.tts_lwpid
;
450 struct inferior
*inf
;
451 struct inferior
*parent_inf
;
453 parent_inf
= find_inferior_pid (pid
);
455 inferior_ptid
= ptid_build (fpid
, flwpid
, 0);
456 inf
= add_inferior (fpid
);
457 inf
->attach_flag
= parent_inf
->attach_flag
;
458 inf
->pspace
= parent_inf
->pspace
;
459 inf
->aspace
= parent_inf
->aspace
;
460 copy_terminal_info (inf
, parent_inf
);
461 detach_breakpoints (pid
);
463 target_terminal_ours ();
464 fprintf_unfiltered (gdb_stdlog
, _("\
465 Attaching after fork to child process %ld.\n"), (long)fpid
);
469 inferior_ptid
= ptid_build (pid
, lwpid
, 0);
470 detach_breakpoints (fpid
);
472 target_terminal_ours ();
473 fprintf_unfiltered (gdb_stdlog
, _("\
474 Detaching after fork from child process %ld.\n"), (long)fpid
);
477 if (tts
.tts_event
== TTEVT_VFORK
)
479 gdb_assert (!tts
.tts_u
.tts_fork
.tts_isparent
);
483 /* We can't detach from the parent yet. */
484 inf_ttrace_vfork_ppid
= pid
;
486 reattach_breakpoints (fpid
);
490 if (ttrace (TT_PROC_DETACH
, fpid
, 0, 0, 0, 0) == -1)
491 perror_with_name (("ttrace"));
493 /* Wait till we get the TTEVT_VFORK event in the parent.
494 This indicates that the child has called exec(3) or has
495 exited and that the parent is ready to be traced again. */
496 if (ttrace_wait (pid
, lwpid
, TTRACE_WAITOK
, &tts
, sizeof tts
) == -1)
497 perror_with_name (("ttrace_wait"));
498 gdb_assert (tts
.tts_event
== TTEVT_VFORK
);
499 gdb_assert (tts
.tts_u
.tts_fork
.tts_isparent
);
501 reattach_breakpoints (pid
);
506 gdb_assert (tts
.tts_u
.tts_fork
.tts_isparent
);
510 if (ttrace (TT_PROC_DETACH
, pid
, 0, 0, 0, 0) == -1)
511 perror_with_name (("ttrace"));
515 if (ttrace (TT_PROC_DETACH
, fpid
, 0, 0, 0, 0) == -1)
516 perror_with_name (("ttrace"));
522 struct thread_info
*ti
;
524 /* The child will start out single-threaded. */
525 inf_ttrace_num_lwps
= 1;
526 inf_ttrace_num_lwps_in_syscall
= 0;
529 delete_thread_silent (ptid_build (pid
, lwpid
, 0));
530 detach_inferior (pid
);
532 /* Add child thread. inferior_ptid was already set above. */
533 ti
= add_thread_silent (inferior_ptid
);
535 xmalloc (sizeof (struct inf_ttrace_private_thread_info
));
536 memset (ti
->private, 0,
537 sizeof (struct inf_ttrace_private_thread_info
));
544 /* File descriptors for pipes used as semaphores during initial
545 startup of an inferior. */
546 static int inf_ttrace_pfd1
[2];
547 static int inf_ttrace_pfd2
[2];
550 do_cleanup_pfds (void *dummy
)
552 close (inf_ttrace_pfd1
[0]);
553 close (inf_ttrace_pfd1
[1]);
554 close (inf_ttrace_pfd2
[0]);
555 close (inf_ttrace_pfd2
[1]);
559 inf_ttrace_prepare (void)
561 if (pipe (inf_ttrace_pfd1
) == -1)
562 perror_with_name (("pipe"));
564 if (pipe (inf_ttrace_pfd2
) == -1)
566 close (inf_ttrace_pfd1
[0]);
567 close (inf_ttrace_pfd2
[0]);
568 perror_with_name (("pipe"));
572 /* Prepare to be traced. */
577 struct cleanup
*old_chain
= make_cleanup (do_cleanup_pfds
, 0);
580 /* "Trace me, Dr. Memory!" */
581 if (ttrace (TT_PROC_SETTRC
, 0, 0, 0, TT_VERSION
, 0) == -1)
582 perror_with_name (("ttrace"));
584 /* Tell our parent that we are ready to be traced. */
585 if (write (inf_ttrace_pfd1
[1], &c
, sizeof c
) != sizeof c
)
586 perror_with_name (("write"));
588 /* Wait until our parent has set the initial event mask. */
589 if (read (inf_ttrace_pfd2
[0], &c
, sizeof c
) != sizeof c
)
590 perror_with_name (("read"));
592 do_cleanups (old_chain
);
595 /* Start tracing PID. */
598 inf_ttrace_him (struct target_ops
*ops
, int pid
)
600 struct cleanup
*old_chain
= make_cleanup (do_cleanup_pfds
, 0);
604 /* Wait until our child is ready to be traced. */
605 if (read (inf_ttrace_pfd1
[0], &c
, sizeof c
) != sizeof c
)
606 perror_with_name (("read"));
608 /* Set the initial event mask. */
609 memset (&tte
, 0, sizeof (tte
));
610 tte
.tte_events
|= TTEVT_EXEC
| TTEVT_EXIT
| TTEVT_FORK
| TTEVT_VFORK
;
611 tte
.tte_events
|= TTEVT_LWP_CREATE
| TTEVT_LWP_EXIT
| TTEVT_LWP_TERMINATE
;
612 #ifdef TTEVT_BPT_SSTEP
613 tte
.tte_events
|= TTEVT_BPT_SSTEP
;
615 tte
.tte_opts
|= TTEO_PROC_INHERIT
;
616 if (ttrace (TT_PROC_SET_EVENT_MASK
, pid
, 0,
617 (uintptr_t)&tte
, sizeof tte
, 0) == -1)
618 perror_with_name (("ttrace"));
620 /* Tell our child that we have set the initial event mask. */
621 if (write (inf_ttrace_pfd2
[1], &c
, sizeof c
) != sizeof c
)
622 perror_with_name (("write"));
624 do_cleanups (old_chain
);
628 /* START_INFERIOR_TRAPS_EXPECTED is defined in inferior.h, and will
629 be 1 or 2 depending on whether we're starting without or with a
631 startup_inferior (START_INFERIOR_TRAPS_EXPECTED
);
633 /* On some targets, there must be some explicit actions taken after
634 the inferior has been started up. */
635 target_post_startup_inferior (pid_to_ptid (pid
));
639 inf_ttrace_create_inferior (struct target_ops
*ops
, char *exec_file
,
640 char *allargs
, char **env
, int from_tty
)
644 gdb_assert (inf_ttrace_num_lwps
== 0);
645 gdb_assert (inf_ttrace_num_lwps_in_syscall
== 0);
646 gdb_assert (inf_ttrace_page_dict
.count
== 0);
647 gdb_assert (inf_ttrace_reenable_page_protections
== 0);
648 gdb_assert (inf_ttrace_vfork_ppid
== -1);
650 pid
= fork_inferior (exec_file
, allargs
, env
, inf_ttrace_me
, NULL
,
651 inf_ttrace_prepare
, NULL
);
653 inf_ttrace_him (ops
, pid
);
657 inf_ttrace_mourn_inferior (struct target_ops
*ops
)
659 const int num_buckets
= ARRAY_SIZE (inf_ttrace_page_dict
.buckets
);
662 inf_ttrace_num_lwps
= 0;
663 inf_ttrace_num_lwps_in_syscall
= 0;
665 for (bucket
= 0; bucket
< num_buckets
; bucket
++)
667 struct inf_ttrace_page
*page
;
668 struct inf_ttrace_page
*next
;
670 page
= inf_ttrace_page_dict
.buckets
[bucket
].next
;
678 inf_ttrace_page_dict
.count
= 0;
681 generic_mourn_inferior ();
685 inf_ttrace_attach (struct target_ops
*ops
, char *args
, int from_tty
)
690 struct inferior
*inf
;
692 pid
= parse_pid_to_attach (args
);
694 if (pid
== getpid ()) /* Trying to masturbate? */
695 error (_("I refuse to debug myself!"));
699 exec_file
= get_exec_file (0);
702 printf_unfiltered (_("Attaching to program: %s, %s\n"), exec_file
,
703 target_pid_to_str (pid_to_ptid (pid
)));
705 printf_unfiltered (_("Attaching to %s\n"),
706 target_pid_to_str (pid_to_ptid (pid
)));
708 gdb_flush (gdb_stdout
);
711 gdb_assert (inf_ttrace_num_lwps
== 0);
712 gdb_assert (inf_ttrace_num_lwps_in_syscall
== 0);
713 gdb_assert (inf_ttrace_vfork_ppid
== -1);
715 if (ttrace (TT_PROC_ATTACH
, pid
, 0, TT_KILL_ON_EXIT
, TT_VERSION
, 0) == -1)
716 perror_with_name (("ttrace"));
718 inf
= current_inferior ();
719 inferior_appeared (inf
, pid
);
720 inf
->attach_flag
= 1;
722 /* Set the initial event mask. */
723 memset (&tte
, 0, sizeof (tte
));
724 tte
.tte_events
|= TTEVT_EXEC
| TTEVT_EXIT
| TTEVT_FORK
| TTEVT_VFORK
;
725 tte
.tte_events
|= TTEVT_LWP_CREATE
| TTEVT_LWP_EXIT
| TTEVT_LWP_TERMINATE
;
726 #ifdef TTEVT_BPT_SSTEP
727 tte
.tte_events
|= TTEVT_BPT_SSTEP
;
729 tte
.tte_opts
|= TTEO_PROC_INHERIT
;
730 if (ttrace (TT_PROC_SET_EVENT_MASK
, pid
, 0,
731 (uintptr_t)&tte
, sizeof tte
, 0) == -1)
732 perror_with_name (("ttrace"));
736 /* We'll bump inf_ttrace_num_lwps up and add the private data to the
737 thread as soon as we get to inf_ttrace_wait. At this point, we
738 don't have lwpid info yet. */
739 inferior_ptid
= pid_to_ptid (pid
);
740 add_thread_silent (inferior_ptid
);
744 inf_ttrace_detach (struct target_ops
*ops
, char *args
, int from_tty
)
746 pid_t pid
= ptid_get_pid (inferior_ptid
);
751 char *exec_file
= get_exec_file (0);
754 printf_unfiltered (_("Detaching from program: %s, %s\n"), exec_file
,
755 target_pid_to_str (pid_to_ptid (pid
)));
756 gdb_flush (gdb_stdout
);
761 /* ??? The HP-UX 11.0 ttrace(2) manual page doesn't mention that we
762 can pass a signal number here. Does this really work? */
763 if (ttrace (TT_PROC_DETACH
, pid
, 0, 0, sig
, 0) == -1)
764 perror_with_name (("ttrace"));
766 if (inf_ttrace_vfork_ppid
!= -1)
768 if (ttrace (TT_PROC_DETACH
, inf_ttrace_vfork_ppid
, 0, 0, 0, 0) == -1)
769 perror_with_name (("ttrace"));
770 inf_ttrace_vfork_ppid
= -1;
773 inf_ttrace_num_lwps
= 0;
774 inf_ttrace_num_lwps_in_syscall
= 0;
776 inferior_ptid
= null_ptid
;
777 detach_inferior (pid
);
783 inf_ttrace_kill (struct target_ops
*ops
)
785 pid_t pid
= ptid_get_pid (inferior_ptid
);
790 if (ttrace (TT_PROC_EXIT
, pid
, 0, 0, 0, 0) == -1)
791 perror_with_name (("ttrace"));
792 /* ??? Is it necessary to call ttrace_wait() here? */
794 if (inf_ttrace_vfork_ppid
!= -1)
796 if (ttrace (TT_PROC_DETACH
, inf_ttrace_vfork_ppid
, 0, 0, 0, 0) == -1)
797 perror_with_name (("ttrace"));
798 inf_ttrace_vfork_ppid
= -1;
801 target_mourn_inferior ();
804 /* Check is a dying thread is dead by now, and delete it from GDBs
805 thread list if so. */
807 inf_ttrace_delete_dead_threads_callback (struct thread_info
*info
, void *arg
)
810 struct inf_ttrace_private_thread_info
*p
;
812 if (is_exited (info
->ptid
))
815 lwpid
= ptid_get_lwp (info
->ptid
);
816 p
= (struct inf_ttrace_private_thread_info
*) info
->private;
818 /* Check if an lwp that was dying is still there or not. */
819 if (p
->dying
&& (kill (lwpid
, 0) == -1))
821 delete_thread (info
->ptid
);
826 /* Resume the lwp pointed to by INFO, with REQUEST, and pass it signal
830 inf_ttrace_resume_lwp (struct thread_info
*info
, ttreq_t request
, int sig
)
832 pid_t pid
= ptid_get_pid (info
->ptid
);
833 lwpid_t lwpid
= ptid_get_lwp (info
->ptid
);
835 if (ttrace (request
, pid
, lwpid
, TT_NOPC
, sig
, 0) == -1)
837 struct inf_ttrace_private_thread_info
*p
838 = (struct inf_ttrace_private_thread_info
*) info
->private;
839 if (p
->dying
&& errno
== EPROTO
)
840 /* This is expected, it means the dying lwp is really gone
841 by now. If ttrace had an event to inform the debugger
842 the lwp is really gone, this wouldn't be needed. */
843 delete_thread (info
->ptid
);
845 /* This was really unexpected. */
846 perror_with_name (("ttrace"));
850 /* Callback for iterate_over_threads. */
853 inf_ttrace_resume_callback (struct thread_info
*info
, void *arg
)
855 if (!ptid_equal (info
->ptid
, inferior_ptid
) && !is_exited (info
->ptid
))
856 inf_ttrace_resume_lwp (info
, TT_LWP_CONTINUE
, 0);
862 inf_ttrace_resume (struct target_ops
*ops
,
863 ptid_t ptid
, int step
, enum target_signal signal
)
866 ttreq_t request
= step
? TT_LWP_SINGLE
: TT_LWP_CONTINUE
;
867 int sig
= target_signal_to_host (signal
);
868 struct thread_info
*info
;
870 /* A specific PTID means `step only this process id'. */
871 resume_all
= (ptid_equal (ptid
, minus_one_ptid
));
873 /* If resuming all threads, it's the current thread that should be
874 handled specially. */
876 ptid
= inferior_ptid
;
878 info
= find_thread_ptid (ptid
);
879 inf_ttrace_resume_lwp (info
, request
, sig
);
882 /* Let all the other threads run too. */
883 iterate_over_threads (inf_ttrace_resume_callback
, NULL
);
887 inf_ttrace_wait (struct target_ops
*ops
,
888 ptid_t ptid
, struct target_waitstatus
*ourstatus
, int options
)
890 pid_t pid
= ptid_get_pid (ptid
);
891 lwpid_t lwpid
= ptid_get_lwp (ptid
);
893 struct thread_info
*ti
;
896 /* Until proven otherwise. */
897 ourstatus
->kind
= TARGET_WAITKIND_SPURIOUS
;
902 gdb_assert (pid
!= 0 || lwpid
== 0);
908 if (ttrace_wait (pid
, lwpid
, TTRACE_WAITOK
, &tts
, sizeof tts
) == -1)
909 perror_with_name (("ttrace_wait"));
911 if (tts
.tts_event
== TTEVT_VFORK
&& tts
.tts_u
.tts_fork
.tts_isparent
)
913 if (inf_ttrace_vfork_ppid
!= -1)
915 gdb_assert (inf_ttrace_vfork_ppid
== tts
.tts_pid
);
917 if (ttrace (TT_PROC_DETACH
, tts
.tts_pid
, 0, 0, 0, 0) == -1)
918 perror_with_name (("ttrace"));
919 inf_ttrace_vfork_ppid
= -1;
922 tts
.tts_event
= TTEVT_NONE
;
925 clear_sigint_trap ();
927 while (tts
.tts_event
== TTEVT_NONE
);
929 /* Now that we've waited, we can re-enable the page protections. */
930 if (inf_ttrace_reenable_page_protections
)
932 gdb_assert (inf_ttrace_num_lwps_in_syscall
== 0);
933 inf_ttrace_enable_page_protections (tts
.tts_pid
);
934 inf_ttrace_reenable_page_protections
= 0;
937 ptid
= ptid_build (tts
.tts_pid
, tts
.tts_lwpid
, 0);
939 if (inf_ttrace_num_lwps
== 0)
941 struct thread_info
*ti
;
943 inf_ttrace_num_lwps
= 1;
945 /* This is the earliest we hear about the lwp member of
946 INFERIOR_PTID, after an attach or fork_inferior. */
947 gdb_assert (ptid_get_lwp (inferior_ptid
) == 0);
949 /* We haven't set the private member on the main thread yet. Do
951 ti
= find_thread_ptid (inferior_ptid
);
952 gdb_assert (ti
!= NULL
&& ti
->private == NULL
);
954 xmalloc (sizeof (struct inf_ttrace_private_thread_info
));
955 memset (ti
->private, 0,
956 sizeof (struct inf_ttrace_private_thread_info
));
958 /* Notify the core that this ptid changed. This changes
959 inferior_ptid as well. */
960 thread_change_ptid (inferior_ptid
, ptid
);
963 switch (tts
.tts_event
)
965 #ifdef TTEVT_BPT_SSTEP
966 case TTEVT_BPT_SSTEP
:
967 /* Make it look like a breakpoint. */
968 ourstatus
->kind
= TARGET_WAITKIND_STOPPED
;
969 ourstatus
->value
.sig
= TARGET_SIGNAL_TRAP
;
974 ourstatus
->kind
= TARGET_WAITKIND_EXECD
;
975 ourstatus
->value
.execd_pathname
=
976 xmalloc (tts
.tts_u
.tts_exec
.tts_pathlen
+ 1);
977 if (ttrace (TT_PROC_GET_PATHNAME
, tts
.tts_pid
, 0,
978 (uintptr_t)ourstatus
->value
.execd_pathname
,
979 tts
.tts_u
.tts_exec
.tts_pathlen
, 0) == -1)
980 perror_with_name (("ttrace"));
981 ourstatus
->value
.execd_pathname
[tts
.tts_u
.tts_exec
.tts_pathlen
] = 0;
983 /* At this point, all inserted breakpoints are gone. Doing this
984 as soon as we detect an exec prevents the badness of deleting
985 a breakpoint writing the current "shadow contents" to lift
986 the bp. That shadow is NOT valid after an exec. */
987 mark_breakpoints_out ();
991 store_waitstatus (ourstatus
, tts
.tts_u
.tts_exit
.tts_exitcode
);
992 inf_ttrace_num_lwps
= 0;
996 related_ptid
= ptid_build (tts
.tts_u
.tts_fork
.tts_fpid
,
997 tts
.tts_u
.tts_fork
.tts_flwpid
, 0);
999 ourstatus
->kind
= TARGET_WAITKIND_FORKED
;
1000 ourstatus
->value
.related_pid
= related_ptid
;
1002 /* Make sure the other end of the fork is stopped too. */
1003 if (ttrace_wait (tts
.tts_u
.tts_fork
.tts_fpid
,
1004 tts
.tts_u
.tts_fork
.tts_flwpid
,
1005 TTRACE_WAITOK
, &tts
, sizeof tts
) == -1)
1006 perror_with_name (("ttrace_wait"));
1008 gdb_assert (tts
.tts_event
== TTEVT_FORK
);
1009 if (tts
.tts_u
.tts_fork
.tts_isparent
)
1011 related_ptid
= ptid_build (tts
.tts_u
.tts_fork
.tts_fpid
,
1012 tts
.tts_u
.tts_fork
.tts_flwpid
, 0);
1013 ptid
= ptid_build (tts
.tts_pid
, tts
.tts_lwpid
, 0);
1014 ourstatus
->value
.related_pid
= related_ptid
;
1019 gdb_assert (!tts
.tts_u
.tts_fork
.tts_isparent
);
1021 related_ptid
= ptid_build (tts
.tts_u
.tts_fork
.tts_fpid
,
1022 tts
.tts_u
.tts_fork
.tts_flwpid
, 0);
1024 ourstatus
->kind
= TARGET_WAITKIND_VFORKED
;
1025 ourstatus
->value
.related_pid
= related_ptid
;
1027 /* HACK: To avoid touching the parent during the vfork, switch
1029 inferior_ptid
= ptid
;
1032 case TTEVT_LWP_CREATE
:
1033 lwpid
= tts
.tts_u
.tts_thread
.tts_target_lwpid
;
1034 ptid
= ptid_build (tts
.tts_pid
, lwpid
, 0);
1035 ti
= add_thread (ptid
);
1037 xmalloc (sizeof (struct inf_ttrace_private_thread_info
));
1038 memset (ti
->private, 0,
1039 sizeof (struct inf_ttrace_private_thread_info
));
1040 inf_ttrace_num_lwps
++;
1041 ptid
= ptid_build (tts
.tts_pid
, tts
.tts_lwpid
, 0);
1042 /* Let the lwp_create-caller thread continue. */
1043 ttrace (TT_LWP_CONTINUE
, ptid_get_pid (ptid
),
1044 ptid_get_lwp (ptid
), TT_NOPC
, 0, 0);
1045 /* Return without stopping the whole process. */
1046 ourstatus
->kind
= TARGET_WAITKIND_IGNORE
;
1049 case TTEVT_LWP_EXIT
:
1050 if (print_thread_events
)
1051 printf_unfiltered (_("[%s exited]\n"), target_pid_to_str (ptid
));
1052 ti
= find_thread_ptid (ptid
);
1053 gdb_assert (ti
!= NULL
);
1054 ((struct inf_ttrace_private_thread_info
*)ti
->private)->dying
= 1;
1055 inf_ttrace_num_lwps
--;
1056 /* Let the thread really exit. */
1057 ttrace (TT_LWP_CONTINUE
, ptid_get_pid (ptid
),
1058 ptid_get_lwp (ptid
), TT_NOPC
, 0, 0);
1059 /* Return without stopping the whole process. */
1060 ourstatus
->kind
= TARGET_WAITKIND_IGNORE
;
1063 case TTEVT_LWP_TERMINATE
:
1064 lwpid
= tts
.tts_u
.tts_thread
.tts_target_lwpid
;
1065 ptid
= ptid_build (tts
.tts_pid
, lwpid
, 0);
1066 if (print_thread_events
)
1067 printf_unfiltered(_("[%s has been terminated]\n"),
1068 target_pid_to_str (ptid
));
1069 ti
= find_thread_ptid (ptid
);
1070 gdb_assert (ti
!= NULL
);
1071 ((struct inf_ttrace_private_thread_info
*)ti
->private)->dying
= 1;
1072 inf_ttrace_num_lwps
--;
1074 /* Resume the lwp_terminate-caller thread. */
1075 ptid
= ptid_build (tts
.tts_pid
, tts
.tts_lwpid
, 0);
1076 ttrace (TT_LWP_CONTINUE
, ptid_get_pid (ptid
),
1077 ptid_get_lwp (ptid
), TT_NOPC
, 0, 0);
1078 /* Return without stopping the whole process. */
1079 ourstatus
->kind
= TARGET_WAITKIND_IGNORE
;
1083 ourstatus
->kind
= TARGET_WAITKIND_STOPPED
;
1084 ourstatus
->value
.sig
=
1085 target_signal_from_host (tts
.tts_u
.tts_signal
.tts_signo
);
1088 case TTEVT_SYSCALL_ENTRY
:
1089 gdb_assert (inf_ttrace_reenable_page_protections
== 0);
1090 inf_ttrace_num_lwps_in_syscall
++;
1091 if (inf_ttrace_num_lwps_in_syscall
== 1)
1093 /* A thread has just entered a system call. Disable any
1094 page protections as the kernel can't deal with them. */
1095 inf_ttrace_disable_page_protections (tts
.tts_pid
);
1097 ourstatus
->kind
= TARGET_WAITKIND_SYSCALL_ENTRY
;
1098 ourstatus
->value
.syscall_number
= tts
.tts_scno
;
1101 case TTEVT_SYSCALL_RETURN
:
1102 if (inf_ttrace_num_lwps_in_syscall
> 0)
1104 /* If the last thread has just left the system call, this
1105 would be a logical place to re-enable the page
1106 protections, but that doesn't work. We can't re-enable
1107 them until we've done another wait. */
1108 inf_ttrace_reenable_page_protections
=
1109 (inf_ttrace_num_lwps_in_syscall
== 1);
1110 inf_ttrace_num_lwps_in_syscall
--;
1112 ourstatus
->kind
= TARGET_WAITKIND_SYSCALL_RETURN
;
1113 ourstatus
->value
.syscall_number
= tts
.tts_scno
;
1117 gdb_assert (!"Unexpected ttrace event");
1121 /* Make sure all threads within the process are stopped. */
1122 if (ttrace (TT_PROC_STOP
, tts
.tts_pid
, 0, 0, 0, 0) == -1)
1123 perror_with_name (("ttrace"));
1125 /* Now that the whole process is stopped, check if any dying thread
1126 is really dead by now. If a dying thread is still alive, it will
1127 be stopped too, and will still show up in `info threads', tagged
1128 with "(Exiting)". We could make `info threads' prune dead
1129 threads instead via inf_ttrace_thread_alive, but doing this here
1130 has the advantage that a frontend is notificed sooner of thread
1131 exits. Note that a dying lwp is still alive, it still has to be
1132 resumed, like any other lwp. */
1133 iterate_over_threads (inf_ttrace_delete_dead_threads_callback
, NULL
);
1138 /* Transfer LEN bytes from ADDR in the inferior's memory into READBUF,
1139 and transfer LEN bytes from WRITEBUF into the inferior's memory at
1140 ADDR. Either READBUF or WRITEBUF may be null, in which case the
1141 corresponding transfer doesn't happen. Return the number of bytes
1142 actually transferred (which may be zero if an error occurs). */
1145 inf_ttrace_xfer_memory (CORE_ADDR addr
, ULONGEST len
,
1146 void *readbuf
, const void *writebuf
)
1148 pid_t pid
= ptid_get_pid (inferior_ptid
);
1150 /* HP-UX treats text space and data space differently. GDB however,
1151 doesn't really know the difference. Therefore we try both. Try
1152 text space before data space though because when we're writing
1153 into text space the instruction cache might need to be flushed. */
1156 && ttrace (TT_PROC_RDTEXT
, pid
, 0, addr
, len
, (uintptr_t)readbuf
) == -1
1157 && ttrace (TT_PROC_RDDATA
, pid
, 0, addr
, len
, (uintptr_t)readbuf
) == -1)
1161 && ttrace (TT_PROC_WRTEXT
, pid
, 0, addr
, len
, (uintptr_t)writebuf
) == -1
1162 && ttrace (TT_PROC_WRDATA
, pid
, 0, addr
, len
, (uintptr_t)writebuf
) == -1)
1169 inf_ttrace_xfer_partial (struct target_ops
*ops
, enum target_object object
,
1170 const char *annex
, gdb_byte
*readbuf
,
1171 const gdb_byte
*writebuf
, ULONGEST offset
, LONGEST len
)
1175 case TARGET_OBJECT_MEMORY
:
1176 return inf_ttrace_xfer_memory (offset
, len
, readbuf
, writebuf
);
1178 case TARGET_OBJECT_UNWIND_TABLE
:
1181 case TARGET_OBJECT_AUXV
:
1184 case TARGET_OBJECT_WCOOKIE
:
1192 /* Print status information about what we're accessing. */
1195 inf_ttrace_files_info (struct target_ops
*ignore
)
1197 struct inferior
*inf
= current_inferior ();
1198 printf_filtered (_("\tUsing the running image of %s %s.\n"),
1199 inf
->attach_flag
? "attached" : "child",
1200 target_pid_to_str (inferior_ptid
));
1204 inf_ttrace_thread_alive (struct target_ops
*ops
, ptid_t ptid
)
1209 /* Return a string describing the state of the thread specified by
1213 inf_ttrace_extra_thread_info (struct thread_info
*info
)
1215 struct inf_ttrace_private_thread_info
* private =
1216 (struct inf_ttrace_private_thread_info
*) info
->private;
1218 if (private != NULL
&& private->dying
)
1225 inf_ttrace_pid_to_str (struct target_ops
*ops
, ptid_t ptid
)
1227 pid_t pid
= ptid_get_pid (ptid
);
1228 lwpid_t lwpid
= ptid_get_lwp (ptid
);
1229 static char buf
[128];
1232 xsnprintf (buf
, sizeof buf
, "process %ld",
1235 xsnprintf (buf
, sizeof buf
, "process %ld, lwp %ld",
1236 (long) pid
, (long) lwpid
);
1241 /* Implement the get_ada_task_ptid target_ops method. */
1244 inf_ttrace_get_ada_task_ptid (long lwp
, long thread
)
1246 return ptid_build (ptid_get_pid (inferior_ptid
), lwp
, 0);
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
;
1274 t
->to_get_ada_task_ptid
= inf_ttrace_get_ada_task_ptid
;
1281 /* Prevent warning from -Wmissing-prototypes. */
1282 void _initialize_hppa_hpux_nat (void);
1285 _initialize_inf_ttrace (void)
1288 inf_ttrace_page_dict
.pagesize
= getpagesize();