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 (struct target_ops
*self
,
318 CORE_ADDR addr
, int len
, int type
,
319 struct expression
*cond
)
321 const int pagesize
= inf_ttrace_page_dict
.pagesize
;
322 pid_t pid
= ptid_get_pid (inferior_ptid
);
327 gdb_assert (type
== hw_write
);
329 page_addr
= (addr
/ pagesize
) * pagesize
;
330 num_pages
= (len
+ pagesize
- 1) / pagesize
;
332 for (page
= 0; page
< num_pages
; page
++, page_addr
+= pagesize
)
333 inf_ttrace_insert_page (pid
, page_addr
);
338 /* Remove a "hardware" watchpoint for LEN bytes at address ADDR of
342 inf_ttrace_remove_watchpoint (struct target_ops
*self
,
343 CORE_ADDR addr
, int len
, int type
,
344 struct expression
*cond
)
346 const int pagesize
= inf_ttrace_page_dict
.pagesize
;
347 pid_t pid
= ptid_get_pid (inferior_ptid
);
352 gdb_assert (type
== hw_write
);
354 page_addr
= (addr
/ pagesize
) * pagesize
;
355 num_pages
= (len
+ pagesize
- 1) / pagesize
;
357 for (page
= 0; page
< num_pages
; page
++, page_addr
+= pagesize
)
358 inf_ttrace_remove_page (pid
, page_addr
);
364 inf_ttrace_can_use_hw_breakpoint (struct target_ops
*self
,
365 int type
, int len
, int ot
)
367 return (type
== bp_hardware_watchpoint
);
371 inf_ttrace_region_ok_for_hw_watchpoint (CORE_ADDR addr
, int len
)
376 /* Return non-zero if the current inferior was (potentially) stopped
377 by hitting a "hardware" watchpoint. */
380 inf_ttrace_stopped_by_watchpoint (struct target_ops
*ops
)
382 pid_t pid
= ptid_get_pid (inferior_ptid
);
383 lwpid_t lwpid
= ptid_get_lwp (inferior_ptid
);
386 if (inf_ttrace_page_dict
.count
> 0)
388 if (ttrace (TT_LWP_GET_STATE
, pid
, lwpid
,
389 (uintptr_t)&tts
, sizeof tts
, 0) == -1)
390 perror_with_name (("ttrace"));
392 if (tts
.tts_event
== TTEVT_SIGNAL
393 && tts
.tts_u
.tts_signal
.tts_signo
== SIGBUS
)
395 const int pagesize
= inf_ttrace_page_dict
.pagesize
;
396 void *addr
= tts
.tts_u
.tts_signal
.tts_siginfo
.si_addr
;
397 CORE_ADDR page_addr
= ((uintptr_t)addr
/ pagesize
) * pagesize
;
399 if (inf_ttrace_get_page (pid
, page_addr
))
408 /* When tracking a vfork(2), we cannot detach from the parent until
409 after the child has called exec(3) or has exited. If we are still
410 attached to the parent, this variable will be set to the process ID
411 of the parent. Otherwise it will be set to zero. */
412 static pid_t inf_ttrace_vfork_ppid
= -1;
415 inf_ttrace_follow_fork (struct target_ops
*ops
, int follow_child
,
419 lwpid_t lwpid
, flwpid
;
421 struct thread_info
*tp
= inferior_thread ();
423 gdb_assert (tp
->pending_follow
.kind
== TARGET_WAITKIND_FORKED
424 || tp
->pending_follow
.kind
== TARGET_WAITKIND_VFORKED
);
426 pid
= ptid_get_pid (inferior_ptid
);
427 lwpid
= ptid_get_lwp (inferior_ptid
);
429 /* Get all important details that core GDB doesn't (and shouldn't)
431 if (ttrace (TT_LWP_GET_STATE
, pid
, lwpid
,
432 (uintptr_t)&tts
, sizeof tts
, 0) == -1)
433 perror_with_name (("ttrace"));
435 gdb_assert (tts
.tts_event
== TTEVT_FORK
|| tts
.tts_event
== TTEVT_VFORK
);
437 if (tts
.tts_u
.tts_fork
.tts_isparent
)
440 lwpid
= tts
.tts_lwpid
;
441 fpid
= tts
.tts_u
.tts_fork
.tts_fpid
;
442 flwpid
= tts
.tts_u
.tts_fork
.tts_flwpid
;
446 pid
= tts
.tts_u
.tts_fork
.tts_fpid
;
447 lwpid
= tts
.tts_u
.tts_fork
.tts_flwpid
;
449 flwpid
= tts
.tts_lwpid
;
454 struct inferior
*inf
;
455 struct inferior
*parent_inf
;
457 parent_inf
= find_inferior_pid (pid
);
459 inferior_ptid
= ptid_build (fpid
, flwpid
, 0);
460 inf
= add_inferior (fpid
);
461 inf
->attach_flag
= parent_inf
->attach_flag
;
462 inf
->pspace
= parent_inf
->pspace
;
463 inf
->aspace
= parent_inf
->aspace
;
464 copy_terminal_info (inf
, parent_inf
);
465 detach_breakpoints (ptid_build (pid
, lwpid
, 0));
467 target_terminal_ours ();
468 fprintf_unfiltered (gdb_stdlog
,
469 _("Attaching after fork to child process %ld.\n"),
474 inferior_ptid
= ptid_build (pid
, lwpid
, 0);
475 /* Detach any remaining breakpoints in the child. In the case
476 of fork events, we do not need to do this, because breakpoints
477 should have already been removed earlier. */
478 if (tts
.tts_event
== TTEVT_VFORK
)
479 detach_breakpoints (ptid_build (fpid
, flwpid
, 0));
481 target_terminal_ours ();
482 fprintf_unfiltered (gdb_stdlog
,
483 _("Detaching after fork from child process %ld.\n"),
487 if (tts
.tts_event
== TTEVT_VFORK
)
489 gdb_assert (!tts
.tts_u
.tts_fork
.tts_isparent
);
493 /* We can't detach from the parent yet. */
494 inf_ttrace_vfork_ppid
= pid
;
496 reattach_breakpoints (fpid
);
500 if (ttrace (TT_PROC_DETACH
, fpid
, 0, 0, 0, 0) == -1)
501 perror_with_name (("ttrace"));
503 /* Wait till we get the TTEVT_VFORK event in the parent.
504 This indicates that the child has called exec(3) or has
505 exited and that the parent is ready to be traced again. */
506 if (ttrace_wait (pid
, lwpid
, TTRACE_WAITOK
, &tts
, sizeof tts
) == -1)
507 perror_with_name (("ttrace_wait"));
508 gdb_assert (tts
.tts_event
== TTEVT_VFORK
);
509 gdb_assert (tts
.tts_u
.tts_fork
.tts_isparent
);
511 reattach_breakpoints (pid
);
516 gdb_assert (tts
.tts_u
.tts_fork
.tts_isparent
);
520 if (ttrace (TT_PROC_DETACH
, pid
, 0, 0, 0, 0) == -1)
521 perror_with_name (("ttrace"));
525 if (ttrace (TT_PROC_DETACH
, fpid
, 0, 0, 0, 0) == -1)
526 perror_with_name (("ttrace"));
532 struct thread_info
*ti
;
534 /* The child will start out single-threaded. */
535 inf_ttrace_num_lwps
= 1;
536 inf_ttrace_num_lwps_in_syscall
= 0;
539 delete_thread_silent (ptid_build (pid
, lwpid
, 0));
540 detach_inferior (pid
);
542 /* Add child thread. inferior_ptid was already set above. */
543 ti
= add_thread_silent (inferior_ptid
);
545 xmalloc (sizeof (struct inf_ttrace_private_thread_info
));
546 memset (ti
->private, 0,
547 sizeof (struct inf_ttrace_private_thread_info
));
554 /* File descriptors for pipes used as semaphores during initial
555 startup of an inferior. */
556 static int inf_ttrace_pfd1
[2];
557 static int inf_ttrace_pfd2
[2];
560 do_cleanup_pfds (void *dummy
)
562 close (inf_ttrace_pfd1
[0]);
563 close (inf_ttrace_pfd1
[1]);
564 close (inf_ttrace_pfd2
[0]);
565 close (inf_ttrace_pfd2
[1]);
567 unmark_fd_no_cloexec (inf_ttrace_pfd1
[0]);
568 unmark_fd_no_cloexec (inf_ttrace_pfd1
[1]);
569 unmark_fd_no_cloexec (inf_ttrace_pfd2
[0]);
570 unmark_fd_no_cloexec (inf_ttrace_pfd2
[1]);
574 inf_ttrace_prepare (void)
576 if (pipe (inf_ttrace_pfd1
) == -1)
577 perror_with_name (("pipe"));
579 if (pipe (inf_ttrace_pfd2
) == -1)
581 close (inf_ttrace_pfd1
[0]);
582 close (inf_ttrace_pfd2
[0]);
583 perror_with_name (("pipe"));
586 mark_fd_no_cloexec (inf_ttrace_pfd1
[0]);
587 mark_fd_no_cloexec (inf_ttrace_pfd1
[1]);
588 mark_fd_no_cloexec (inf_ttrace_pfd2
[0]);
589 mark_fd_no_cloexec (inf_ttrace_pfd2
[1]);
592 /* Prepare to be traced. */
597 struct cleanup
*old_chain
= make_cleanup (do_cleanup_pfds
, 0);
600 /* "Trace me, Dr. Memory!" */
601 if (ttrace (TT_PROC_SETTRC
, 0, 0, 0, TT_VERSION
, 0) == -1)
602 perror_with_name (("ttrace"));
604 /* Tell our parent that we are ready to be traced. */
605 if (write (inf_ttrace_pfd1
[1], &c
, sizeof c
) != sizeof c
)
606 perror_with_name (("write"));
608 /* Wait until our parent has set the initial event mask. */
609 if (read (inf_ttrace_pfd2
[0], &c
, sizeof c
) != sizeof c
)
610 perror_with_name (("read"));
612 do_cleanups (old_chain
);
615 /* Start tracing PID. */
618 inf_ttrace_him (struct target_ops
*ops
, int pid
)
620 struct cleanup
*old_chain
= make_cleanup (do_cleanup_pfds
, 0);
624 /* Wait until our child is ready to be traced. */
625 if (read (inf_ttrace_pfd1
[0], &c
, sizeof c
) != sizeof c
)
626 perror_with_name (("read"));
628 /* Set the initial event mask. */
629 memset (&tte
, 0, sizeof (tte
));
630 tte
.tte_events
|= TTEVT_EXEC
| TTEVT_EXIT
| TTEVT_FORK
| TTEVT_VFORK
;
631 tte
.tte_events
|= TTEVT_LWP_CREATE
| TTEVT_LWP_EXIT
| TTEVT_LWP_TERMINATE
;
632 #ifdef TTEVT_BPT_SSTEP
633 tte
.tte_events
|= TTEVT_BPT_SSTEP
;
635 tte
.tte_opts
|= TTEO_PROC_INHERIT
;
636 if (ttrace (TT_PROC_SET_EVENT_MASK
, pid
, 0,
637 (uintptr_t)&tte
, sizeof tte
, 0) == -1)
638 perror_with_name (("ttrace"));
640 /* Tell our child that we have set the initial event mask. */
641 if (write (inf_ttrace_pfd2
[1], &c
, sizeof c
) != sizeof c
)
642 perror_with_name (("write"));
644 do_cleanups (old_chain
);
648 startup_inferior (START_INFERIOR_TRAPS_EXPECTED
);
650 /* On some targets, there must be some explicit actions taken after
651 the inferior has been started up. */
652 target_post_startup_inferior (pid_to_ptid (pid
));
656 inf_ttrace_create_inferior (struct target_ops
*ops
, char *exec_file
,
657 char *allargs
, char **env
, int from_tty
)
661 gdb_assert (inf_ttrace_num_lwps
== 0);
662 gdb_assert (inf_ttrace_num_lwps_in_syscall
== 0);
663 gdb_assert (inf_ttrace_page_dict
.count
== 0);
664 gdb_assert (inf_ttrace_reenable_page_protections
== 0);
665 gdb_assert (inf_ttrace_vfork_ppid
== -1);
667 pid
= fork_inferior (exec_file
, allargs
, env
, inf_ttrace_me
, NULL
,
668 inf_ttrace_prepare
, NULL
, NULL
);
670 inf_ttrace_him (ops
, pid
);
674 inf_ttrace_mourn_inferior (struct target_ops
*ops
)
676 const int num_buckets
= ARRAY_SIZE (inf_ttrace_page_dict
.buckets
);
679 inf_ttrace_num_lwps
= 0;
680 inf_ttrace_num_lwps_in_syscall
= 0;
682 for (bucket
= 0; bucket
< num_buckets
; bucket
++)
684 struct inf_ttrace_page
*page
;
685 struct inf_ttrace_page
*next
;
687 page
= inf_ttrace_page_dict
.buckets
[bucket
].next
;
695 inf_ttrace_page_dict
.count
= 0;
698 generic_mourn_inferior ();
701 /* Assuming we just attached the debugger to a new inferior, create
702 a new thread_info structure for each thread, and add it to our
706 inf_ttrace_create_threads_after_attach (int pid
)
711 struct thread_info
*ti
;
713 status
= ttrace (TT_PROC_GET_FIRST_LWP_STATE
, pid
, 0,
714 (uintptr_t) &tts
, sizeof (ttstate_t
), 0);
716 perror_with_name (_("TT_PROC_GET_FIRST_LWP_STATE ttrace call failed"));
717 gdb_assert (tts
.tts_pid
== pid
);
719 /* Add the stopped thread. */
720 ptid
= ptid_build (pid
, tts
.tts_lwpid
, 0);
721 ti
= add_thread (ptid
);
722 ti
->private = xzalloc (sizeof (struct inf_ttrace_private_thread_info
));
723 inf_ttrace_num_lwps
++;
725 /* We use the "first stopped thread" as the currently active thread. */
726 inferior_ptid
= ptid
;
728 /* Iterative over all the remaining threads. */
734 status
= ttrace (TT_PROC_GET_NEXT_LWP_STATE
, pid
, 0,
735 (uintptr_t) &tts
, sizeof (ttstate_t
), 0);
737 perror_with_name (_("TT_PROC_GET_NEXT_LWP_STATE ttrace call failed"));
739 break; /* End of list. */
741 ptid
= ptid_build (tts
.tts_pid
, tts
.tts_lwpid
, 0);
742 ti
= add_thread (ptid
);
743 ti
->private = xzalloc (sizeof (struct inf_ttrace_private_thread_info
));
744 inf_ttrace_num_lwps
++;
749 inf_ttrace_attach (struct target_ops
*ops
, char *args
, int from_tty
)
754 struct inferior
*inf
;
756 pid
= parse_pid_to_attach (args
);
758 if (pid
== getpid ()) /* Trying to masturbate? */
759 error (_("I refuse to debug myself!"));
763 exec_file
= get_exec_file (0);
766 printf_unfiltered (_("Attaching to program: %s, %s\n"), exec_file
,
767 target_pid_to_str (pid_to_ptid (pid
)));
769 printf_unfiltered (_("Attaching to %s\n"),
770 target_pid_to_str (pid_to_ptid (pid
)));
772 gdb_flush (gdb_stdout
);
775 gdb_assert (inf_ttrace_num_lwps
== 0);
776 gdb_assert (inf_ttrace_num_lwps_in_syscall
== 0);
777 gdb_assert (inf_ttrace_vfork_ppid
== -1);
779 if (ttrace (TT_PROC_ATTACH
, pid
, 0, TT_KILL_ON_EXIT
, TT_VERSION
, 0) == -1)
780 perror_with_name (("ttrace"));
782 inf
= current_inferior ();
783 inferior_appeared (inf
, pid
);
784 inf
->attach_flag
= 1;
786 /* Set the initial event mask. */
787 memset (&tte
, 0, sizeof (tte
));
788 tte
.tte_events
|= TTEVT_EXEC
| TTEVT_EXIT
| TTEVT_FORK
| TTEVT_VFORK
;
789 tte
.tte_events
|= TTEVT_LWP_CREATE
| TTEVT_LWP_EXIT
| TTEVT_LWP_TERMINATE
;
790 #ifdef TTEVT_BPT_SSTEP
791 tte
.tte_events
|= TTEVT_BPT_SSTEP
;
793 tte
.tte_opts
|= TTEO_PROC_INHERIT
;
794 if (ttrace (TT_PROC_SET_EVENT_MASK
, pid
, 0,
795 (uintptr_t)&tte
, sizeof tte
, 0) == -1)
796 perror_with_name (("ttrace"));
800 inf_ttrace_create_threads_after_attach (pid
);
804 inf_ttrace_detach (struct target_ops
*ops
, const char *args
, int from_tty
)
806 pid_t pid
= ptid_get_pid (inferior_ptid
);
811 char *exec_file
= get_exec_file (0);
814 printf_unfiltered (_("Detaching from program: %s, %s\n"), exec_file
,
815 target_pid_to_str (pid_to_ptid (pid
)));
816 gdb_flush (gdb_stdout
);
821 /* ??? The HP-UX 11.0 ttrace(2) manual page doesn't mention that we
822 can pass a signal number here. Does this really work? */
823 if (ttrace (TT_PROC_DETACH
, pid
, 0, 0, sig
, 0) == -1)
824 perror_with_name (("ttrace"));
826 if (inf_ttrace_vfork_ppid
!= -1)
828 if (ttrace (TT_PROC_DETACH
, inf_ttrace_vfork_ppid
, 0, 0, 0, 0) == -1)
829 perror_with_name (("ttrace"));
830 inf_ttrace_vfork_ppid
= -1;
833 inf_ttrace_num_lwps
= 0;
834 inf_ttrace_num_lwps_in_syscall
= 0;
836 inferior_ptid
= null_ptid
;
837 detach_inferior (pid
);
843 inf_ttrace_kill (struct target_ops
*ops
)
845 pid_t pid
= ptid_get_pid (inferior_ptid
);
850 if (ttrace (TT_PROC_EXIT
, pid
, 0, 0, 0, 0) == -1)
851 perror_with_name (("ttrace"));
852 /* ??? Is it necessary to call ttrace_wait() here? */
854 if (inf_ttrace_vfork_ppid
!= -1)
856 if (ttrace (TT_PROC_DETACH
, inf_ttrace_vfork_ppid
, 0, 0, 0, 0) == -1)
857 perror_with_name (("ttrace"));
858 inf_ttrace_vfork_ppid
= -1;
861 target_mourn_inferior ();
864 /* Check is a dying thread is dead by now, and delete it from GDBs
865 thread list if so. */
867 inf_ttrace_delete_dead_threads_callback (struct thread_info
*info
, void *arg
)
870 struct inf_ttrace_private_thread_info
*p
;
872 if (is_exited (info
->ptid
))
875 lwpid
= ptid_get_lwp (info
->ptid
);
876 p
= (struct inf_ttrace_private_thread_info
*) info
->private;
878 /* Check if an lwp that was dying is still there or not. */
879 if (p
->dying
&& (kill (lwpid
, 0) == -1))
881 delete_thread (info
->ptid
);
886 /* Resume the lwp pointed to by INFO, with REQUEST, and pass it signal
890 inf_ttrace_resume_lwp (struct thread_info
*info
, ttreq_t request
, int sig
)
892 pid_t pid
= ptid_get_pid (info
->ptid
);
893 lwpid_t lwpid
= ptid_get_lwp (info
->ptid
);
895 if (ttrace (request
, pid
, lwpid
, TT_NOPC
, sig
, 0) == -1)
897 struct inf_ttrace_private_thread_info
*p
898 = (struct inf_ttrace_private_thread_info
*) info
->private;
899 if (p
->dying
&& errno
== EPROTO
)
900 /* This is expected, it means the dying lwp is really gone
901 by now. If ttrace had an event to inform the debugger
902 the lwp is really gone, this wouldn't be needed. */
903 delete_thread (info
->ptid
);
905 /* This was really unexpected. */
906 perror_with_name (("ttrace"));
910 /* Callback for iterate_over_threads. */
913 inf_ttrace_resume_callback (struct thread_info
*info
, void *arg
)
915 if (!ptid_equal (info
->ptid
, inferior_ptid
) && !is_exited (info
->ptid
))
916 inf_ttrace_resume_lwp (info
, TT_LWP_CONTINUE
, 0);
922 inf_ttrace_resume (struct target_ops
*ops
,
923 ptid_t ptid
, int step
, enum gdb_signal signal
)
926 ttreq_t request
= step
? TT_LWP_SINGLE
: TT_LWP_CONTINUE
;
927 int sig
= gdb_signal_to_host (signal
);
928 struct thread_info
*info
;
930 /* A specific PTID means `step only this process id'. */
931 resume_all
= (ptid_equal (ptid
, minus_one_ptid
));
933 /* If resuming all threads, it's the current thread that should be
934 handled specially. */
936 ptid
= inferior_ptid
;
938 info
= find_thread_ptid (ptid
);
939 inf_ttrace_resume_lwp (info
, request
, sig
);
942 /* Let all the other threads run too. */
943 iterate_over_threads (inf_ttrace_resume_callback
, NULL
);
947 inf_ttrace_wait (struct target_ops
*ops
,
948 ptid_t ptid
, struct target_waitstatus
*ourstatus
, int options
)
950 pid_t pid
= ptid_get_pid (ptid
);
951 lwpid_t lwpid
= ptid_get_lwp (ptid
);
953 struct thread_info
*ti
;
956 /* Until proven otherwise. */
957 ourstatus
->kind
= TARGET_WAITKIND_SPURIOUS
;
962 gdb_assert (pid
!= 0 || lwpid
== 0);
968 if (ttrace_wait (pid
, lwpid
, TTRACE_WAITOK
, &tts
, sizeof tts
) == -1)
969 perror_with_name (("ttrace_wait"));
971 if (tts
.tts_event
== TTEVT_VFORK
&& tts
.tts_u
.tts_fork
.tts_isparent
)
973 if (inf_ttrace_vfork_ppid
!= -1)
975 gdb_assert (inf_ttrace_vfork_ppid
== tts
.tts_pid
);
977 if (ttrace (TT_PROC_DETACH
, tts
.tts_pid
, 0, 0, 0, 0) == -1)
978 perror_with_name (("ttrace"));
979 inf_ttrace_vfork_ppid
= -1;
982 tts
.tts_event
= TTEVT_NONE
;
985 clear_sigint_trap ();
987 while (tts
.tts_event
== TTEVT_NONE
);
989 /* Now that we've waited, we can re-enable the page protections. */
990 if (inf_ttrace_reenable_page_protections
)
992 gdb_assert (inf_ttrace_num_lwps_in_syscall
== 0);
993 inf_ttrace_enable_page_protections (tts
.tts_pid
);
994 inf_ttrace_reenable_page_protections
= 0;
997 ptid
= ptid_build (tts
.tts_pid
, tts
.tts_lwpid
, 0);
999 if (inf_ttrace_num_lwps
== 0)
1001 struct thread_info
*ti
;
1003 inf_ttrace_num_lwps
= 1;
1005 /* This is the earliest we hear about the lwp member of
1006 INFERIOR_PTID, after an attach or fork_inferior. */
1007 gdb_assert (ptid_get_lwp (inferior_ptid
) == 0);
1009 /* We haven't set the private member on the main thread yet. Do
1011 ti
= find_thread_ptid (inferior_ptid
);
1012 gdb_assert (ti
!= NULL
&& ti
->private == NULL
);
1014 xmalloc (sizeof (struct inf_ttrace_private_thread_info
));
1015 memset (ti
->private, 0,
1016 sizeof (struct inf_ttrace_private_thread_info
));
1018 /* Notify the core that this ptid changed. This changes
1019 inferior_ptid as well. */
1020 thread_change_ptid (inferior_ptid
, ptid
);
1023 switch (tts
.tts_event
)
1025 #ifdef TTEVT_BPT_SSTEP
1026 case TTEVT_BPT_SSTEP
:
1027 /* Make it look like a breakpoint. */
1028 ourstatus
->kind
= TARGET_WAITKIND_STOPPED
;
1029 ourstatus
->value
.sig
= GDB_SIGNAL_TRAP
;
1034 ourstatus
->kind
= TARGET_WAITKIND_EXECD
;
1035 ourstatus
->value
.execd_pathname
=
1036 xmalloc (tts
.tts_u
.tts_exec
.tts_pathlen
+ 1);
1037 if (ttrace (TT_PROC_GET_PATHNAME
, tts
.tts_pid
, 0,
1038 (uintptr_t)ourstatus
->value
.execd_pathname
,
1039 tts
.tts_u
.tts_exec
.tts_pathlen
, 0) == -1)
1040 perror_with_name (("ttrace"));
1041 ourstatus
->value
.execd_pathname
[tts
.tts_u
.tts_exec
.tts_pathlen
] = 0;
1043 /* At this point, all inserted breakpoints are gone. Doing this
1044 as soon as we detect an exec prevents the badness of deleting
1045 a breakpoint writing the current "shadow contents" to lift
1046 the bp. That shadow is NOT valid after an exec. */
1047 mark_breakpoints_out ();
1051 store_waitstatus (ourstatus
, tts
.tts_u
.tts_exit
.tts_exitcode
);
1052 inf_ttrace_num_lwps
= 0;
1056 related_ptid
= ptid_build (tts
.tts_u
.tts_fork
.tts_fpid
,
1057 tts
.tts_u
.tts_fork
.tts_flwpid
, 0);
1059 ourstatus
->kind
= TARGET_WAITKIND_FORKED
;
1060 ourstatus
->value
.related_pid
= related_ptid
;
1062 /* Make sure the other end of the fork is stopped too. */
1063 if (ttrace_wait (tts
.tts_u
.tts_fork
.tts_fpid
,
1064 tts
.tts_u
.tts_fork
.tts_flwpid
,
1065 TTRACE_WAITOK
, &tts
, sizeof tts
) == -1)
1066 perror_with_name (("ttrace_wait"));
1068 gdb_assert (tts
.tts_event
== TTEVT_FORK
);
1069 if (tts
.tts_u
.tts_fork
.tts_isparent
)
1071 related_ptid
= ptid_build (tts
.tts_u
.tts_fork
.tts_fpid
,
1072 tts
.tts_u
.tts_fork
.tts_flwpid
, 0);
1073 ptid
= ptid_build (tts
.tts_pid
, tts
.tts_lwpid
, 0);
1074 ourstatus
->value
.related_pid
= related_ptid
;
1079 gdb_assert (!tts
.tts_u
.tts_fork
.tts_isparent
);
1081 related_ptid
= ptid_build (tts
.tts_u
.tts_fork
.tts_fpid
,
1082 tts
.tts_u
.tts_fork
.tts_flwpid
, 0);
1084 ourstatus
->kind
= TARGET_WAITKIND_VFORKED
;
1085 ourstatus
->value
.related_pid
= related_ptid
;
1087 /* HACK: To avoid touching the parent during the vfork, switch
1089 inferior_ptid
= ptid
;
1092 case TTEVT_LWP_CREATE
:
1093 lwpid
= tts
.tts_u
.tts_thread
.tts_target_lwpid
;
1094 ptid
= ptid_build (tts
.tts_pid
, lwpid
, 0);
1095 ti
= add_thread (ptid
);
1097 xmalloc (sizeof (struct inf_ttrace_private_thread_info
));
1098 memset (ti
->private, 0,
1099 sizeof (struct inf_ttrace_private_thread_info
));
1100 inf_ttrace_num_lwps
++;
1101 ptid
= ptid_build (tts
.tts_pid
, tts
.tts_lwpid
, 0);
1102 /* Let the lwp_create-caller thread continue. */
1103 ttrace (TT_LWP_CONTINUE
, ptid_get_pid (ptid
),
1104 ptid_get_lwp (ptid
), TT_NOPC
, 0, 0);
1105 /* Return without stopping the whole process. */
1106 ourstatus
->kind
= TARGET_WAITKIND_IGNORE
;
1109 case TTEVT_LWP_EXIT
:
1110 if (print_thread_events
)
1111 printf_unfiltered (_("[%s exited]\n"), target_pid_to_str (ptid
));
1112 ti
= find_thread_ptid (ptid
);
1113 gdb_assert (ti
!= NULL
);
1114 ((struct inf_ttrace_private_thread_info
*)ti
->private)->dying
= 1;
1115 inf_ttrace_num_lwps
--;
1116 /* Let the thread really exit. */
1117 ttrace (TT_LWP_CONTINUE
, ptid_get_pid (ptid
),
1118 ptid_get_lwp (ptid
), TT_NOPC
, 0, 0);
1119 /* Return without stopping the whole process. */
1120 ourstatus
->kind
= TARGET_WAITKIND_IGNORE
;
1123 case TTEVT_LWP_TERMINATE
:
1124 lwpid
= tts
.tts_u
.tts_thread
.tts_target_lwpid
;
1125 ptid
= ptid_build (tts
.tts_pid
, lwpid
, 0);
1126 if (print_thread_events
)
1127 printf_unfiltered(_("[%s has been terminated]\n"),
1128 target_pid_to_str (ptid
));
1129 ti
= find_thread_ptid (ptid
);
1130 gdb_assert (ti
!= NULL
);
1131 ((struct inf_ttrace_private_thread_info
*)ti
->private)->dying
= 1;
1132 inf_ttrace_num_lwps
--;
1134 /* Resume the lwp_terminate-caller thread. */
1135 ptid
= ptid_build (tts
.tts_pid
, tts
.tts_lwpid
, 0);
1136 ttrace (TT_LWP_CONTINUE
, ptid_get_pid (ptid
),
1137 ptid_get_lwp (ptid
), TT_NOPC
, 0, 0);
1138 /* Return without stopping the whole process. */
1139 ourstatus
->kind
= TARGET_WAITKIND_IGNORE
;
1143 ourstatus
->kind
= TARGET_WAITKIND_STOPPED
;
1144 ourstatus
->value
.sig
=
1145 gdb_signal_from_host (tts
.tts_u
.tts_signal
.tts_signo
);
1148 case TTEVT_SYSCALL_ENTRY
:
1149 gdb_assert (inf_ttrace_reenable_page_protections
== 0);
1150 inf_ttrace_num_lwps_in_syscall
++;
1151 if (inf_ttrace_num_lwps_in_syscall
== 1)
1153 /* A thread has just entered a system call. Disable any
1154 page protections as the kernel can't deal with them. */
1155 inf_ttrace_disable_page_protections (tts
.tts_pid
);
1157 ourstatus
->kind
= TARGET_WAITKIND_SYSCALL_ENTRY
;
1158 ourstatus
->value
.syscall_number
= tts
.tts_scno
;
1161 case TTEVT_SYSCALL_RETURN
:
1162 if (inf_ttrace_num_lwps_in_syscall
> 0)
1164 /* If the last thread has just left the system call, this
1165 would be a logical place to re-enable the page
1166 protections, but that doesn't work. We can't re-enable
1167 them until we've done another wait. */
1168 inf_ttrace_reenable_page_protections
=
1169 (inf_ttrace_num_lwps_in_syscall
== 1);
1170 inf_ttrace_num_lwps_in_syscall
--;
1172 ourstatus
->kind
= TARGET_WAITKIND_SYSCALL_RETURN
;
1173 ourstatus
->value
.syscall_number
= tts
.tts_scno
;
1177 gdb_assert (!"Unexpected ttrace event");
1181 /* Make sure all threads within the process are stopped. */
1182 if (ttrace (TT_PROC_STOP
, tts
.tts_pid
, 0, 0, 0, 0) == -1)
1183 perror_with_name (("ttrace"));
1185 /* Now that the whole process is stopped, check if any dying thread
1186 is really dead by now. If a dying thread is still alive, it will
1187 be stopped too, and will still show up in `info threads', tagged
1188 with "(Exiting)". We could make `info threads' prune dead
1189 threads instead via inf_ttrace_thread_alive, but doing this here
1190 has the advantage that a frontend is notificed sooner of thread
1191 exits. Note that a dying lwp is still alive, it still has to be
1192 resumed, like any other lwp. */
1193 iterate_over_threads (inf_ttrace_delete_dead_threads_callback
, NULL
);
1198 /* Transfer LEN bytes from ADDR in the inferior's memory into READBUF,
1199 and transfer LEN bytes from WRITEBUF into the inferior's memory at
1200 ADDR. Either READBUF or WRITEBUF may be null, in which case the
1201 corresponding transfer doesn't happen. Return the number of bytes
1202 actually transferred (which may be zero if an error occurs). */
1205 inf_ttrace_xfer_memory (CORE_ADDR addr
, ULONGEST len
,
1206 void *readbuf
, const void *writebuf
)
1208 pid_t pid
= ptid_get_pid (inferior_ptid
);
1210 /* HP-UX treats text space and data space differently. GDB however,
1211 doesn't really know the difference. Therefore we try both. Try
1212 text space before data space though because when we're writing
1213 into text space the instruction cache might need to be flushed. */
1216 && ttrace (TT_PROC_RDTEXT
, pid
, 0, addr
, len
, (uintptr_t)readbuf
) == -1
1217 && ttrace (TT_PROC_RDDATA
, pid
, 0, addr
, len
, (uintptr_t)readbuf
) == -1)
1221 && ttrace (TT_PROC_WRTEXT
, pid
, 0, addr
, len
, (uintptr_t)writebuf
) == -1
1222 && ttrace (TT_PROC_WRDATA
, pid
, 0, addr
, len
, (uintptr_t)writebuf
) == -1)
1228 static enum target_xfer_status
1229 inf_ttrace_xfer_partial (struct target_ops
*ops
, enum target_object object
,
1230 const char *annex
, gdb_byte
*readbuf
,
1231 const gdb_byte
*writebuf
,
1232 ULONGEST offset
, ULONGEST len
, ULONGEST
*xfered_len
)
1236 case TARGET_OBJECT_MEMORY
:
1238 LONGEST val
= inf_ttrace_xfer_memory (offset
, len
, readbuf
, writebuf
);
1241 return TARGET_XFER_EOF
;
1244 *xfered_len
= (ULONGEST
) val
;
1245 return TARGET_XFER_OK
;
1249 case TARGET_OBJECT_UNWIND_TABLE
:
1250 return TARGET_XFER_E_IO
;
1252 case TARGET_OBJECT_AUXV
:
1253 return TARGET_XFER_E_IO
;
1255 case TARGET_OBJECT_WCOOKIE
:
1256 return TARGET_XFER_E_IO
;
1259 return TARGET_XFER_E_IO
;
1263 /* Print status information about what we're accessing. */
1266 inf_ttrace_files_info (struct target_ops
*ignore
)
1268 struct inferior
*inf
= current_inferior ();
1269 printf_filtered (_("\tUsing the running image of %s %s.\n"),
1270 inf
->attach_flag
? "attached" : "child",
1271 target_pid_to_str (inferior_ptid
));
1275 inf_ttrace_thread_alive (struct target_ops
*ops
, ptid_t ptid
)
1280 /* Return a string describing the state of the thread specified by
1284 inf_ttrace_extra_thread_info (struct thread_info
*info
)
1286 struct inf_ttrace_private_thread_info
* private =
1287 (struct inf_ttrace_private_thread_info
*) info
->private;
1289 if (private != NULL
&& private->dying
)
1296 inf_ttrace_pid_to_str (struct target_ops
*ops
, ptid_t ptid
)
1298 pid_t pid
= ptid_get_pid (ptid
);
1299 lwpid_t lwpid
= ptid_get_lwp (ptid
);
1300 static char buf
[128];
1303 xsnprintf (buf
, sizeof buf
, "process %ld",
1306 xsnprintf (buf
, sizeof buf
, "process %ld, lwp %ld",
1307 (long) pid
, (long) lwpid
);
1312 /* Implement the get_ada_task_ptid target_ops method. */
1315 inf_ttrace_get_ada_task_ptid (long lwp
, long thread
)
1317 return ptid_build (ptid_get_pid (inferior_ptid
), lwp
, 0);
1322 inf_ttrace_target (void)
1324 struct target_ops
*t
= inf_child_target ();
1326 t
->to_attach
= inf_ttrace_attach
;
1327 t
->to_detach
= inf_ttrace_detach
;
1328 t
->to_resume
= inf_ttrace_resume
;
1329 t
->to_wait
= inf_ttrace_wait
;
1330 t
->to_files_info
= inf_ttrace_files_info
;
1331 t
->to_can_use_hw_breakpoint
= inf_ttrace_can_use_hw_breakpoint
;
1332 t
->to_insert_watchpoint
= inf_ttrace_insert_watchpoint
;
1333 t
->to_remove_watchpoint
= inf_ttrace_remove_watchpoint
;
1334 t
->to_stopped_by_watchpoint
= inf_ttrace_stopped_by_watchpoint
;
1335 t
->to_region_ok_for_hw_watchpoint
=
1336 inf_ttrace_region_ok_for_hw_watchpoint
;
1337 t
->to_kill
= inf_ttrace_kill
;
1338 t
->to_create_inferior
= inf_ttrace_create_inferior
;
1339 t
->to_follow_fork
= inf_ttrace_follow_fork
;
1340 t
->to_mourn_inferior
= inf_ttrace_mourn_inferior
;
1341 t
->to_thread_alive
= inf_ttrace_thread_alive
;
1342 t
->to_extra_thread_info
= inf_ttrace_extra_thread_info
;
1343 t
->to_pid_to_str
= inf_ttrace_pid_to_str
;
1344 t
->to_xfer_partial
= inf_ttrace_xfer_partial
;
1345 t
->to_get_ada_task_ptid
= inf_ttrace_get_ada_task_ptid
;
1352 /* Prevent warning from -Wmissing-prototypes. */
1353 void _initialize_inf_ttrace (void);
1356 _initialize_inf_ttrace (void)
1359 inf_ttrace_page_dict
.pagesize
= getpagesize();