1 /* Low-level child interface to ttrace.
3 Copyright (C) 2004-2014 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"
33 #include "gdb_assert.h"
36 #include <sys/ttrace.h>
39 #include "inf-child.h"
40 #include "inf-ttrace.h"
41 #include "common/filestuff.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
= XNEW (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 (struct target_ops
*self
,
363 int type
, int len
, int ot
)
365 return (type
== bp_hardware_watchpoint
);
369 inf_ttrace_region_ok_for_hw_watchpoint (CORE_ADDR addr
, int len
)
374 /* Return non-zero if the current inferior was (potentially) stopped
375 by hitting a "hardware" watchpoint. */
378 inf_ttrace_stopped_by_watchpoint (struct target_ops
*ops
)
380 pid_t pid
= ptid_get_pid (inferior_ptid
);
381 lwpid_t lwpid
= ptid_get_lwp (inferior_ptid
);
384 if (inf_ttrace_page_dict
.count
> 0)
386 if (ttrace (TT_LWP_GET_STATE
, pid
, lwpid
,
387 (uintptr_t)&tts
, sizeof tts
, 0) == -1)
388 perror_with_name (("ttrace"));
390 if (tts
.tts_event
== TTEVT_SIGNAL
391 && tts
.tts_u
.tts_signal
.tts_signo
== SIGBUS
)
393 const int pagesize
= inf_ttrace_page_dict
.pagesize
;
394 void *addr
= tts
.tts_u
.tts_signal
.tts_siginfo
.si_addr
;
395 CORE_ADDR page_addr
= ((uintptr_t)addr
/ pagesize
) * pagesize
;
397 if (inf_ttrace_get_page (pid
, page_addr
))
406 /* When tracking a vfork(2), we cannot detach from the parent until
407 after the child has called exec(3) or has exited. If we are still
408 attached to the parent, this variable will be set to the process ID
409 of the parent. Otherwise it will be set to zero. */
410 static pid_t inf_ttrace_vfork_ppid
= -1;
413 inf_ttrace_follow_fork (struct target_ops
*ops
, int follow_child
,
417 lwpid_t lwpid
, flwpid
;
419 struct thread_info
*tp
= inferior_thread ();
421 gdb_assert (tp
->pending_follow
.kind
== TARGET_WAITKIND_FORKED
422 || tp
->pending_follow
.kind
== TARGET_WAITKIND_VFORKED
);
424 pid
= ptid_get_pid (inferior_ptid
);
425 lwpid
= ptid_get_lwp (inferior_ptid
);
427 /* Get all important details that core GDB doesn't (and shouldn't)
429 if (ttrace (TT_LWP_GET_STATE
, pid
, lwpid
,
430 (uintptr_t)&tts
, sizeof tts
, 0) == -1)
431 perror_with_name (("ttrace"));
433 gdb_assert (tts
.tts_event
== TTEVT_FORK
|| tts
.tts_event
== TTEVT_VFORK
);
435 if (tts
.tts_u
.tts_fork
.tts_isparent
)
438 lwpid
= tts
.tts_lwpid
;
439 fpid
= tts
.tts_u
.tts_fork
.tts_fpid
;
440 flwpid
= tts
.tts_u
.tts_fork
.tts_flwpid
;
444 pid
= tts
.tts_u
.tts_fork
.tts_fpid
;
445 lwpid
= tts
.tts_u
.tts_fork
.tts_flwpid
;
447 flwpid
= tts
.tts_lwpid
;
452 struct inferior
*inf
;
453 struct inferior
*parent_inf
;
455 parent_inf
= find_inferior_pid (pid
);
457 inferior_ptid
= ptid_build (fpid
, flwpid
, 0);
458 inf
= add_inferior (fpid
);
459 inf
->attach_flag
= parent_inf
->attach_flag
;
460 inf
->pspace
= parent_inf
->pspace
;
461 inf
->aspace
= parent_inf
->aspace
;
462 copy_terminal_info (inf
, parent_inf
);
463 detach_breakpoints (ptid_build (pid
, lwpid
, 0));
465 target_terminal_ours ();
466 fprintf_unfiltered (gdb_stdlog
,
467 _("Attaching after fork to child process %ld.\n"),
472 inferior_ptid
= ptid_build (pid
, lwpid
, 0);
473 /* Detach any remaining breakpoints in the child. In the case
474 of fork events, we do not need to do this, because breakpoints
475 should have already been removed earlier. */
476 if (tts
.tts_event
== TTEVT_VFORK
)
477 detach_breakpoints (ptid_build (fpid
, flwpid
, 0));
479 target_terminal_ours ();
480 fprintf_unfiltered (gdb_stdlog
,
481 _("Detaching after fork from child process %ld.\n"),
485 if (tts
.tts_event
== TTEVT_VFORK
)
487 gdb_assert (!tts
.tts_u
.tts_fork
.tts_isparent
);
491 /* We can't detach from the parent yet. */
492 inf_ttrace_vfork_ppid
= pid
;
494 reattach_breakpoints (fpid
);
498 if (ttrace (TT_PROC_DETACH
, fpid
, 0, 0, 0, 0) == -1)
499 perror_with_name (("ttrace"));
501 /* Wait till we get the TTEVT_VFORK event in the parent.
502 This indicates that the child has called exec(3) or has
503 exited and that the parent is ready to be traced again. */
504 if (ttrace_wait (pid
, lwpid
, TTRACE_WAITOK
, &tts
, sizeof tts
) == -1)
505 perror_with_name (("ttrace_wait"));
506 gdb_assert (tts
.tts_event
== TTEVT_VFORK
);
507 gdb_assert (tts
.tts_u
.tts_fork
.tts_isparent
);
509 reattach_breakpoints (pid
);
514 gdb_assert (tts
.tts_u
.tts_fork
.tts_isparent
);
518 if (ttrace (TT_PROC_DETACH
, pid
, 0, 0, 0, 0) == -1)
519 perror_with_name (("ttrace"));
523 if (ttrace (TT_PROC_DETACH
, fpid
, 0, 0, 0, 0) == -1)
524 perror_with_name (("ttrace"));
530 struct thread_info
*ti
;
532 /* The child will start out single-threaded. */
533 inf_ttrace_num_lwps
= 1;
534 inf_ttrace_num_lwps_in_syscall
= 0;
537 delete_thread_silent (ptid_build (pid
, lwpid
, 0));
538 detach_inferior (pid
);
540 /* Add child thread. inferior_ptid was already set above. */
541 ti
= add_thread_silent (inferior_ptid
);
543 xmalloc (sizeof (struct inf_ttrace_private_thread_info
));
544 memset (ti
->private, 0,
545 sizeof (struct inf_ttrace_private_thread_info
));
552 /* File descriptors for pipes used as semaphores during initial
553 startup of an inferior. */
554 static int inf_ttrace_pfd1
[2];
555 static int inf_ttrace_pfd2
[2];
558 do_cleanup_pfds (void *dummy
)
560 close (inf_ttrace_pfd1
[0]);
561 close (inf_ttrace_pfd1
[1]);
562 close (inf_ttrace_pfd2
[0]);
563 close (inf_ttrace_pfd2
[1]);
565 unmark_fd_no_cloexec (inf_ttrace_pfd1
[0]);
566 unmark_fd_no_cloexec (inf_ttrace_pfd1
[1]);
567 unmark_fd_no_cloexec (inf_ttrace_pfd2
[0]);
568 unmark_fd_no_cloexec (inf_ttrace_pfd2
[1]);
572 inf_ttrace_prepare (void)
574 if (pipe (inf_ttrace_pfd1
) == -1)
575 perror_with_name (("pipe"));
577 if (pipe (inf_ttrace_pfd2
) == -1)
579 close (inf_ttrace_pfd1
[0]);
580 close (inf_ttrace_pfd2
[0]);
581 perror_with_name (("pipe"));
584 mark_fd_no_cloexec (inf_ttrace_pfd1
[0]);
585 mark_fd_no_cloexec (inf_ttrace_pfd1
[1]);
586 mark_fd_no_cloexec (inf_ttrace_pfd2
[0]);
587 mark_fd_no_cloexec (inf_ttrace_pfd2
[1]);
590 /* Prepare to be traced. */
595 struct cleanup
*old_chain
= make_cleanup (do_cleanup_pfds
, 0);
598 /* "Trace me, Dr. Memory!" */
599 if (ttrace (TT_PROC_SETTRC
, 0, 0, 0, TT_VERSION
, 0) == -1)
600 perror_with_name (("ttrace"));
602 /* Tell our parent that we are ready to be traced. */
603 if (write (inf_ttrace_pfd1
[1], &c
, sizeof c
) != sizeof c
)
604 perror_with_name (("write"));
606 /* Wait until our parent has set the initial event mask. */
607 if (read (inf_ttrace_pfd2
[0], &c
, sizeof c
) != sizeof c
)
608 perror_with_name (("read"));
610 do_cleanups (old_chain
);
613 /* Start tracing PID. */
616 inf_ttrace_him (struct target_ops
*ops
, int pid
)
618 struct cleanup
*old_chain
= make_cleanup (do_cleanup_pfds
, 0);
622 /* Wait until our child is ready to be traced. */
623 if (read (inf_ttrace_pfd1
[0], &c
, sizeof c
) != sizeof c
)
624 perror_with_name (("read"));
626 /* Set the initial event mask. */
627 memset (&tte
, 0, sizeof (tte
));
628 tte
.tte_events
|= TTEVT_EXEC
| TTEVT_EXIT
| TTEVT_FORK
| TTEVT_VFORK
;
629 tte
.tte_events
|= TTEVT_LWP_CREATE
| TTEVT_LWP_EXIT
| TTEVT_LWP_TERMINATE
;
630 #ifdef TTEVT_BPT_SSTEP
631 tte
.tte_events
|= TTEVT_BPT_SSTEP
;
633 tte
.tte_opts
|= TTEO_PROC_INHERIT
;
634 if (ttrace (TT_PROC_SET_EVENT_MASK
, pid
, 0,
635 (uintptr_t)&tte
, sizeof tte
, 0) == -1)
636 perror_with_name (("ttrace"));
638 /* Tell our child that we have set the initial event mask. */
639 if (write (inf_ttrace_pfd2
[1], &c
, sizeof c
) != sizeof c
)
640 perror_with_name (("write"));
642 do_cleanups (old_chain
);
646 startup_inferior (START_INFERIOR_TRAPS_EXPECTED
);
648 /* On some targets, there must be some explicit actions taken after
649 the inferior has been started up. */
650 target_post_startup_inferior (pid_to_ptid (pid
));
654 inf_ttrace_create_inferior (struct target_ops
*ops
, char *exec_file
,
655 char *allargs
, char **env
, int from_tty
)
659 gdb_assert (inf_ttrace_num_lwps
== 0);
660 gdb_assert (inf_ttrace_num_lwps_in_syscall
== 0);
661 gdb_assert (inf_ttrace_page_dict
.count
== 0);
662 gdb_assert (inf_ttrace_reenable_page_protections
== 0);
663 gdb_assert (inf_ttrace_vfork_ppid
== -1);
665 pid
= fork_inferior (exec_file
, allargs
, env
, inf_ttrace_me
, NULL
,
666 inf_ttrace_prepare
, NULL
, NULL
);
668 inf_ttrace_him (ops
, pid
);
672 inf_ttrace_mourn_inferior (struct target_ops
*ops
)
674 const int num_buckets
= ARRAY_SIZE (inf_ttrace_page_dict
.buckets
);
677 inf_ttrace_num_lwps
= 0;
678 inf_ttrace_num_lwps_in_syscall
= 0;
680 for (bucket
= 0; bucket
< num_buckets
; bucket
++)
682 struct inf_ttrace_page
*page
;
683 struct inf_ttrace_page
*next
;
685 page
= inf_ttrace_page_dict
.buckets
[bucket
].next
;
693 inf_ttrace_page_dict
.count
= 0;
696 generic_mourn_inferior ();
699 /* Assuming we just attached the debugger to a new inferior, create
700 a new thread_info structure for each thread, and add it to our
704 inf_ttrace_create_threads_after_attach (int pid
)
709 struct thread_info
*ti
;
711 status
= ttrace (TT_PROC_GET_FIRST_LWP_STATE
, pid
, 0,
712 (uintptr_t) &tts
, sizeof (ttstate_t
), 0);
714 perror_with_name (_("TT_PROC_GET_FIRST_LWP_STATE ttrace call failed"));
715 gdb_assert (tts
.tts_pid
== pid
);
717 /* Add the stopped thread. */
718 ptid
= ptid_build (pid
, tts
.tts_lwpid
, 0);
719 ti
= add_thread (ptid
);
720 ti
->private = xzalloc (sizeof (struct inf_ttrace_private_thread_info
));
721 inf_ttrace_num_lwps
++;
723 /* We use the "first stopped thread" as the currently active thread. */
724 inferior_ptid
= ptid
;
726 /* Iterative over all the remaining threads. */
732 status
= ttrace (TT_PROC_GET_NEXT_LWP_STATE
, pid
, 0,
733 (uintptr_t) &tts
, sizeof (ttstate_t
), 0);
735 perror_with_name (_("TT_PROC_GET_NEXT_LWP_STATE ttrace call failed"));
737 break; /* End of list. */
739 ptid
= ptid_build (tts
.tts_pid
, tts
.tts_lwpid
, 0);
740 ti
= add_thread (ptid
);
741 ti
->private = xzalloc (sizeof (struct inf_ttrace_private_thread_info
));
742 inf_ttrace_num_lwps
++;
747 inf_ttrace_attach (struct target_ops
*ops
, char *args
, int from_tty
)
752 struct inferior
*inf
;
754 pid
= parse_pid_to_attach (args
);
756 if (pid
== getpid ()) /* Trying to masturbate? */
757 error (_("I refuse to debug myself!"));
761 exec_file
= get_exec_file (0);
764 printf_unfiltered (_("Attaching to program: %s, %s\n"), exec_file
,
765 target_pid_to_str (pid_to_ptid (pid
)));
767 printf_unfiltered (_("Attaching to %s\n"),
768 target_pid_to_str (pid_to_ptid (pid
)));
770 gdb_flush (gdb_stdout
);
773 gdb_assert (inf_ttrace_num_lwps
== 0);
774 gdb_assert (inf_ttrace_num_lwps_in_syscall
== 0);
775 gdb_assert (inf_ttrace_vfork_ppid
== -1);
777 if (ttrace (TT_PROC_ATTACH
, pid
, 0, TT_KILL_ON_EXIT
, TT_VERSION
, 0) == -1)
778 perror_with_name (("ttrace"));
780 inf
= current_inferior ();
781 inferior_appeared (inf
, pid
);
782 inf
->attach_flag
= 1;
784 /* Set the initial event mask. */
785 memset (&tte
, 0, sizeof (tte
));
786 tte
.tte_events
|= TTEVT_EXEC
| TTEVT_EXIT
| TTEVT_FORK
| TTEVT_VFORK
;
787 tte
.tte_events
|= TTEVT_LWP_CREATE
| TTEVT_LWP_EXIT
| TTEVT_LWP_TERMINATE
;
788 #ifdef TTEVT_BPT_SSTEP
789 tte
.tte_events
|= TTEVT_BPT_SSTEP
;
791 tte
.tte_opts
|= TTEO_PROC_INHERIT
;
792 if (ttrace (TT_PROC_SET_EVENT_MASK
, pid
, 0,
793 (uintptr_t)&tte
, sizeof tte
, 0) == -1)
794 perror_with_name (("ttrace"));
798 inf_ttrace_create_threads_after_attach (pid
);
802 inf_ttrace_detach (struct target_ops
*ops
, const char *args
, int from_tty
)
804 pid_t pid
= ptid_get_pid (inferior_ptid
);
809 char *exec_file
= get_exec_file (0);
812 printf_unfiltered (_("Detaching from program: %s, %s\n"), exec_file
,
813 target_pid_to_str (pid_to_ptid (pid
)));
814 gdb_flush (gdb_stdout
);
819 /* ??? The HP-UX 11.0 ttrace(2) manual page doesn't mention that we
820 can pass a signal number here. Does this really work? */
821 if (ttrace (TT_PROC_DETACH
, pid
, 0, 0, sig
, 0) == -1)
822 perror_with_name (("ttrace"));
824 if (inf_ttrace_vfork_ppid
!= -1)
826 if (ttrace (TT_PROC_DETACH
, inf_ttrace_vfork_ppid
, 0, 0, 0, 0) == -1)
827 perror_with_name (("ttrace"));
828 inf_ttrace_vfork_ppid
= -1;
831 inf_ttrace_num_lwps
= 0;
832 inf_ttrace_num_lwps_in_syscall
= 0;
834 inferior_ptid
= null_ptid
;
835 detach_inferior (pid
);
841 inf_ttrace_kill (struct target_ops
*ops
)
843 pid_t pid
= ptid_get_pid (inferior_ptid
);
848 if (ttrace (TT_PROC_EXIT
, pid
, 0, 0, 0, 0) == -1)
849 perror_with_name (("ttrace"));
850 /* ??? Is it necessary to call ttrace_wait() here? */
852 if (inf_ttrace_vfork_ppid
!= -1)
854 if (ttrace (TT_PROC_DETACH
, inf_ttrace_vfork_ppid
, 0, 0, 0, 0) == -1)
855 perror_with_name (("ttrace"));
856 inf_ttrace_vfork_ppid
= -1;
859 target_mourn_inferior ();
862 /* Check is a dying thread is dead by now, and delete it from GDBs
863 thread list if so. */
865 inf_ttrace_delete_dead_threads_callback (struct thread_info
*info
, void *arg
)
868 struct inf_ttrace_private_thread_info
*p
;
870 if (is_exited (info
->ptid
))
873 lwpid
= ptid_get_lwp (info
->ptid
);
874 p
= (struct inf_ttrace_private_thread_info
*) info
->private;
876 /* Check if an lwp that was dying is still there or not. */
877 if (p
->dying
&& (kill (lwpid
, 0) == -1))
879 delete_thread (info
->ptid
);
884 /* Resume the lwp pointed to by INFO, with REQUEST, and pass it signal
888 inf_ttrace_resume_lwp (struct thread_info
*info
, ttreq_t request
, int sig
)
890 pid_t pid
= ptid_get_pid (info
->ptid
);
891 lwpid_t lwpid
= ptid_get_lwp (info
->ptid
);
893 if (ttrace (request
, pid
, lwpid
, TT_NOPC
, sig
, 0) == -1)
895 struct inf_ttrace_private_thread_info
*p
896 = (struct inf_ttrace_private_thread_info
*) info
->private;
897 if (p
->dying
&& errno
== EPROTO
)
898 /* This is expected, it means the dying lwp is really gone
899 by now. If ttrace had an event to inform the debugger
900 the lwp is really gone, this wouldn't be needed. */
901 delete_thread (info
->ptid
);
903 /* This was really unexpected. */
904 perror_with_name (("ttrace"));
908 /* Callback for iterate_over_threads. */
911 inf_ttrace_resume_callback (struct thread_info
*info
, void *arg
)
913 if (!ptid_equal (info
->ptid
, inferior_ptid
) && !is_exited (info
->ptid
))
914 inf_ttrace_resume_lwp (info
, TT_LWP_CONTINUE
, 0);
920 inf_ttrace_resume (struct target_ops
*ops
,
921 ptid_t ptid
, int step
, enum gdb_signal signal
)
924 ttreq_t request
= step
? TT_LWP_SINGLE
: TT_LWP_CONTINUE
;
925 int sig
= gdb_signal_to_host (signal
);
926 struct thread_info
*info
;
928 /* A specific PTID means `step only this process id'. */
929 resume_all
= (ptid_equal (ptid
, minus_one_ptid
));
931 /* If resuming all threads, it's the current thread that should be
932 handled specially. */
934 ptid
= inferior_ptid
;
936 info
= find_thread_ptid (ptid
);
937 inf_ttrace_resume_lwp (info
, request
, sig
);
940 /* Let all the other threads run too. */
941 iterate_over_threads (inf_ttrace_resume_callback
, NULL
);
945 inf_ttrace_wait (struct target_ops
*ops
,
946 ptid_t ptid
, struct target_waitstatus
*ourstatus
, int options
)
948 pid_t pid
= ptid_get_pid (ptid
);
949 lwpid_t lwpid
= ptid_get_lwp (ptid
);
951 struct thread_info
*ti
;
954 /* Until proven otherwise. */
955 ourstatus
->kind
= TARGET_WAITKIND_SPURIOUS
;
960 gdb_assert (pid
!= 0 || lwpid
== 0);
966 if (ttrace_wait (pid
, lwpid
, TTRACE_WAITOK
, &tts
, sizeof tts
) == -1)
967 perror_with_name (("ttrace_wait"));
969 if (tts
.tts_event
== TTEVT_VFORK
&& tts
.tts_u
.tts_fork
.tts_isparent
)
971 if (inf_ttrace_vfork_ppid
!= -1)
973 gdb_assert (inf_ttrace_vfork_ppid
== tts
.tts_pid
);
975 if (ttrace (TT_PROC_DETACH
, tts
.tts_pid
, 0, 0, 0, 0) == -1)
976 perror_with_name (("ttrace"));
977 inf_ttrace_vfork_ppid
= -1;
980 tts
.tts_event
= TTEVT_NONE
;
983 clear_sigint_trap ();
985 while (tts
.tts_event
== TTEVT_NONE
);
987 /* Now that we've waited, we can re-enable the page protections. */
988 if (inf_ttrace_reenable_page_protections
)
990 gdb_assert (inf_ttrace_num_lwps_in_syscall
== 0);
991 inf_ttrace_enable_page_protections (tts
.tts_pid
);
992 inf_ttrace_reenable_page_protections
= 0;
995 ptid
= ptid_build (tts
.tts_pid
, tts
.tts_lwpid
, 0);
997 if (inf_ttrace_num_lwps
== 0)
999 struct thread_info
*ti
;
1001 inf_ttrace_num_lwps
= 1;
1003 /* This is the earliest we hear about the lwp member of
1004 INFERIOR_PTID, after an attach or fork_inferior. */
1005 gdb_assert (ptid_get_lwp (inferior_ptid
) == 0);
1007 /* We haven't set the private member on the main thread yet. Do
1009 ti
= find_thread_ptid (inferior_ptid
);
1010 gdb_assert (ti
!= NULL
&& ti
->private == NULL
);
1012 xmalloc (sizeof (struct inf_ttrace_private_thread_info
));
1013 memset (ti
->private, 0,
1014 sizeof (struct inf_ttrace_private_thread_info
));
1016 /* Notify the core that this ptid changed. This changes
1017 inferior_ptid as well. */
1018 thread_change_ptid (inferior_ptid
, ptid
);
1021 switch (tts
.tts_event
)
1023 #ifdef TTEVT_BPT_SSTEP
1024 case TTEVT_BPT_SSTEP
:
1025 /* Make it look like a breakpoint. */
1026 ourstatus
->kind
= TARGET_WAITKIND_STOPPED
;
1027 ourstatus
->value
.sig
= GDB_SIGNAL_TRAP
;
1032 ourstatus
->kind
= TARGET_WAITKIND_EXECD
;
1033 ourstatus
->value
.execd_pathname
=
1034 xmalloc (tts
.tts_u
.tts_exec
.tts_pathlen
+ 1);
1035 if (ttrace (TT_PROC_GET_PATHNAME
, tts
.tts_pid
, 0,
1036 (uintptr_t)ourstatus
->value
.execd_pathname
,
1037 tts
.tts_u
.tts_exec
.tts_pathlen
, 0) == -1)
1038 perror_with_name (("ttrace"));
1039 ourstatus
->value
.execd_pathname
[tts
.tts_u
.tts_exec
.tts_pathlen
] = 0;
1041 /* At this point, all inserted breakpoints are gone. Doing this
1042 as soon as we detect an exec prevents the badness of deleting
1043 a breakpoint writing the current "shadow contents" to lift
1044 the bp. That shadow is NOT valid after an exec. */
1045 mark_breakpoints_out ();
1049 store_waitstatus (ourstatus
, tts
.tts_u
.tts_exit
.tts_exitcode
);
1050 inf_ttrace_num_lwps
= 0;
1054 related_ptid
= ptid_build (tts
.tts_u
.tts_fork
.tts_fpid
,
1055 tts
.tts_u
.tts_fork
.tts_flwpid
, 0);
1057 ourstatus
->kind
= TARGET_WAITKIND_FORKED
;
1058 ourstatus
->value
.related_pid
= related_ptid
;
1060 /* Make sure the other end of the fork is stopped too. */
1061 if (ttrace_wait (tts
.tts_u
.tts_fork
.tts_fpid
,
1062 tts
.tts_u
.tts_fork
.tts_flwpid
,
1063 TTRACE_WAITOK
, &tts
, sizeof tts
) == -1)
1064 perror_with_name (("ttrace_wait"));
1066 gdb_assert (tts
.tts_event
== TTEVT_FORK
);
1067 if (tts
.tts_u
.tts_fork
.tts_isparent
)
1069 related_ptid
= ptid_build (tts
.tts_u
.tts_fork
.tts_fpid
,
1070 tts
.tts_u
.tts_fork
.tts_flwpid
, 0);
1071 ptid
= ptid_build (tts
.tts_pid
, tts
.tts_lwpid
, 0);
1072 ourstatus
->value
.related_pid
= related_ptid
;
1077 gdb_assert (!tts
.tts_u
.tts_fork
.tts_isparent
);
1079 related_ptid
= ptid_build (tts
.tts_u
.tts_fork
.tts_fpid
,
1080 tts
.tts_u
.tts_fork
.tts_flwpid
, 0);
1082 ourstatus
->kind
= TARGET_WAITKIND_VFORKED
;
1083 ourstatus
->value
.related_pid
= related_ptid
;
1085 /* HACK: To avoid touching the parent during the vfork, switch
1087 inferior_ptid
= ptid
;
1090 case TTEVT_LWP_CREATE
:
1091 lwpid
= tts
.tts_u
.tts_thread
.tts_target_lwpid
;
1092 ptid
= ptid_build (tts
.tts_pid
, lwpid
, 0);
1093 ti
= add_thread (ptid
);
1095 xmalloc (sizeof (struct inf_ttrace_private_thread_info
));
1096 memset (ti
->private, 0,
1097 sizeof (struct inf_ttrace_private_thread_info
));
1098 inf_ttrace_num_lwps
++;
1099 ptid
= ptid_build (tts
.tts_pid
, tts
.tts_lwpid
, 0);
1100 /* Let the lwp_create-caller thread continue. */
1101 ttrace (TT_LWP_CONTINUE
, ptid_get_pid (ptid
),
1102 ptid_get_lwp (ptid
), TT_NOPC
, 0, 0);
1103 /* Return without stopping the whole process. */
1104 ourstatus
->kind
= TARGET_WAITKIND_IGNORE
;
1107 case TTEVT_LWP_EXIT
:
1108 if (print_thread_events
)
1109 printf_unfiltered (_("[%s exited]\n"), target_pid_to_str (ptid
));
1110 ti
= find_thread_ptid (ptid
);
1111 gdb_assert (ti
!= NULL
);
1112 ((struct inf_ttrace_private_thread_info
*)ti
->private)->dying
= 1;
1113 inf_ttrace_num_lwps
--;
1114 /* Let the thread really exit. */
1115 ttrace (TT_LWP_CONTINUE
, ptid_get_pid (ptid
),
1116 ptid_get_lwp (ptid
), TT_NOPC
, 0, 0);
1117 /* Return without stopping the whole process. */
1118 ourstatus
->kind
= TARGET_WAITKIND_IGNORE
;
1121 case TTEVT_LWP_TERMINATE
:
1122 lwpid
= tts
.tts_u
.tts_thread
.tts_target_lwpid
;
1123 ptid
= ptid_build (tts
.tts_pid
, lwpid
, 0);
1124 if (print_thread_events
)
1125 printf_unfiltered(_("[%s has been terminated]\n"),
1126 target_pid_to_str (ptid
));
1127 ti
= find_thread_ptid (ptid
);
1128 gdb_assert (ti
!= NULL
);
1129 ((struct inf_ttrace_private_thread_info
*)ti
->private)->dying
= 1;
1130 inf_ttrace_num_lwps
--;
1132 /* Resume the lwp_terminate-caller thread. */
1133 ptid
= ptid_build (tts
.tts_pid
, tts
.tts_lwpid
, 0);
1134 ttrace (TT_LWP_CONTINUE
, ptid_get_pid (ptid
),
1135 ptid_get_lwp (ptid
), TT_NOPC
, 0, 0);
1136 /* Return without stopping the whole process. */
1137 ourstatus
->kind
= TARGET_WAITKIND_IGNORE
;
1141 ourstatus
->kind
= TARGET_WAITKIND_STOPPED
;
1142 ourstatus
->value
.sig
=
1143 gdb_signal_from_host (tts
.tts_u
.tts_signal
.tts_signo
);
1146 case TTEVT_SYSCALL_ENTRY
:
1147 gdb_assert (inf_ttrace_reenable_page_protections
== 0);
1148 inf_ttrace_num_lwps_in_syscall
++;
1149 if (inf_ttrace_num_lwps_in_syscall
== 1)
1151 /* A thread has just entered a system call. Disable any
1152 page protections as the kernel can't deal with them. */
1153 inf_ttrace_disable_page_protections (tts
.tts_pid
);
1155 ourstatus
->kind
= TARGET_WAITKIND_SYSCALL_ENTRY
;
1156 ourstatus
->value
.syscall_number
= tts
.tts_scno
;
1159 case TTEVT_SYSCALL_RETURN
:
1160 if (inf_ttrace_num_lwps_in_syscall
> 0)
1162 /* If the last thread has just left the system call, this
1163 would be a logical place to re-enable the page
1164 protections, but that doesn't work. We can't re-enable
1165 them until we've done another wait. */
1166 inf_ttrace_reenable_page_protections
=
1167 (inf_ttrace_num_lwps_in_syscall
== 1);
1168 inf_ttrace_num_lwps_in_syscall
--;
1170 ourstatus
->kind
= TARGET_WAITKIND_SYSCALL_RETURN
;
1171 ourstatus
->value
.syscall_number
= tts
.tts_scno
;
1175 gdb_assert (!"Unexpected ttrace event");
1179 /* Make sure all threads within the process are stopped. */
1180 if (ttrace (TT_PROC_STOP
, tts
.tts_pid
, 0, 0, 0, 0) == -1)
1181 perror_with_name (("ttrace"));
1183 /* Now that the whole process is stopped, check if any dying thread
1184 is really dead by now. If a dying thread is still alive, it will
1185 be stopped too, and will still show up in `info threads', tagged
1186 with "(Exiting)". We could make `info threads' prune dead
1187 threads instead via inf_ttrace_thread_alive, but doing this here
1188 has the advantage that a frontend is notificed sooner of thread
1189 exits. Note that a dying lwp is still alive, it still has to be
1190 resumed, like any other lwp. */
1191 iterate_over_threads (inf_ttrace_delete_dead_threads_callback
, NULL
);
1196 /* Transfer LEN bytes from ADDR in the inferior's memory into READBUF,
1197 and transfer LEN bytes from WRITEBUF into the inferior's memory at
1198 ADDR. Either READBUF or WRITEBUF may be null, in which case the
1199 corresponding transfer doesn't happen. Return the number of bytes
1200 actually transferred (which may be zero if an error occurs). */
1203 inf_ttrace_xfer_memory (CORE_ADDR addr
, ULONGEST len
,
1204 void *readbuf
, const void *writebuf
)
1206 pid_t pid
= ptid_get_pid (inferior_ptid
);
1208 /* HP-UX treats text space and data space differently. GDB however,
1209 doesn't really know the difference. Therefore we try both. Try
1210 text space before data space though because when we're writing
1211 into text space the instruction cache might need to be flushed. */
1214 && ttrace (TT_PROC_RDTEXT
, pid
, 0, addr
, len
, (uintptr_t)readbuf
) == -1
1215 && ttrace (TT_PROC_RDDATA
, pid
, 0, addr
, len
, (uintptr_t)readbuf
) == -1)
1219 && ttrace (TT_PROC_WRTEXT
, pid
, 0, addr
, len
, (uintptr_t)writebuf
) == -1
1220 && ttrace (TT_PROC_WRDATA
, pid
, 0, addr
, len
, (uintptr_t)writebuf
) == -1)
1226 static enum target_xfer_status
1227 inf_ttrace_xfer_partial (struct target_ops
*ops
, enum target_object object
,
1228 const char *annex
, gdb_byte
*readbuf
,
1229 const gdb_byte
*writebuf
,
1230 ULONGEST offset
, ULONGEST len
, ULONGEST
*xfered_len
)
1234 case TARGET_OBJECT_MEMORY
:
1236 LONGEST val
= inf_ttrace_xfer_memory (offset
, len
, readbuf
, writebuf
);
1239 return TARGET_XFER_EOF
;
1242 *xfered_len
= (ULONGEST
) val
;
1243 return TARGET_XFER_OK
;
1247 case TARGET_OBJECT_UNWIND_TABLE
:
1248 return TARGET_XFER_E_IO
;
1250 case TARGET_OBJECT_AUXV
:
1251 return TARGET_XFER_E_IO
;
1253 case TARGET_OBJECT_WCOOKIE
:
1254 return TARGET_XFER_E_IO
;
1257 return TARGET_XFER_E_IO
;
1261 /* Print status information about what we're accessing. */
1264 inf_ttrace_files_info (struct target_ops
*ignore
)
1266 struct inferior
*inf
= current_inferior ();
1267 printf_filtered (_("\tUsing the running image of %s %s.\n"),
1268 inf
->attach_flag
? "attached" : "child",
1269 target_pid_to_str (inferior_ptid
));
1273 inf_ttrace_thread_alive (struct target_ops
*ops
, ptid_t ptid
)
1278 /* Return a string describing the state of the thread specified by
1282 inf_ttrace_extra_thread_info (struct thread_info
*info
)
1284 struct inf_ttrace_private_thread_info
* private =
1285 (struct inf_ttrace_private_thread_info
*) info
->private;
1287 if (private != NULL
&& private->dying
)
1294 inf_ttrace_pid_to_str (struct target_ops
*ops
, ptid_t ptid
)
1296 pid_t pid
= ptid_get_pid (ptid
);
1297 lwpid_t lwpid
= ptid_get_lwp (ptid
);
1298 static char buf
[128];
1301 xsnprintf (buf
, sizeof buf
, "process %ld",
1304 xsnprintf (buf
, sizeof buf
, "process %ld, lwp %ld",
1305 (long) pid
, (long) lwpid
);
1310 /* Implement the get_ada_task_ptid target_ops method. */
1313 inf_ttrace_get_ada_task_ptid (long lwp
, long thread
)
1315 return ptid_build (ptid_get_pid (inferior_ptid
), lwp
, 0);
1320 inf_ttrace_target (void)
1322 struct target_ops
*t
= inf_child_target ();
1324 t
->to_attach
= inf_ttrace_attach
;
1325 t
->to_detach
= inf_ttrace_detach
;
1326 t
->to_resume
= inf_ttrace_resume
;
1327 t
->to_wait
= inf_ttrace_wait
;
1328 t
->to_files_info
= inf_ttrace_files_info
;
1329 t
->to_can_use_hw_breakpoint
= inf_ttrace_can_use_hw_breakpoint
;
1330 t
->to_insert_watchpoint
= inf_ttrace_insert_watchpoint
;
1331 t
->to_remove_watchpoint
= inf_ttrace_remove_watchpoint
;
1332 t
->to_stopped_by_watchpoint
= inf_ttrace_stopped_by_watchpoint
;
1333 t
->to_region_ok_for_hw_watchpoint
=
1334 inf_ttrace_region_ok_for_hw_watchpoint
;
1335 t
->to_kill
= inf_ttrace_kill
;
1336 t
->to_create_inferior
= inf_ttrace_create_inferior
;
1337 t
->to_follow_fork
= inf_ttrace_follow_fork
;
1338 t
->to_mourn_inferior
= inf_ttrace_mourn_inferior
;
1339 t
->to_thread_alive
= inf_ttrace_thread_alive
;
1340 t
->to_extra_thread_info
= inf_ttrace_extra_thread_info
;
1341 t
->to_pid_to_str
= inf_ttrace_pid_to_str
;
1342 t
->to_xfer_partial
= inf_ttrace_xfer_partial
;
1343 t
->to_get_ada_task_ptid
= inf_ttrace_get_ada_task_ptid
;
1350 /* Prevent warning from -Wmissing-prototypes. */
1351 void _initialize_inf_ttrace (void);
1354 _initialize_inf_ttrace (void)
1357 inf_ttrace_page_dict
.pagesize
= getpagesize();