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 (struct target_ops
*self
,
372 CORE_ADDR addr
, int len
)
377 /* Return non-zero if the current inferior was (potentially) stopped
378 by hitting a "hardware" watchpoint. */
381 inf_ttrace_stopped_by_watchpoint (struct target_ops
*ops
)
383 pid_t pid
= ptid_get_pid (inferior_ptid
);
384 lwpid_t lwpid
= ptid_get_lwp (inferior_ptid
);
387 if (inf_ttrace_page_dict
.count
> 0)
389 if (ttrace (TT_LWP_GET_STATE
, pid
, lwpid
,
390 (uintptr_t)&tts
, sizeof tts
, 0) == -1)
391 perror_with_name (("ttrace"));
393 if (tts
.tts_event
== TTEVT_SIGNAL
394 && tts
.tts_u
.tts_signal
.tts_signo
== SIGBUS
)
396 const int pagesize
= inf_ttrace_page_dict
.pagesize
;
397 void *addr
= tts
.tts_u
.tts_signal
.tts_siginfo
.si_addr
;
398 CORE_ADDR page_addr
= ((uintptr_t)addr
/ pagesize
) * pagesize
;
400 if (inf_ttrace_get_page (pid
, page_addr
))
409 /* When tracking a vfork(2), we cannot detach from the parent until
410 after the child has called exec(3) or has exited. If we are still
411 attached to the parent, this variable will be set to the process ID
412 of the parent. Otherwise it will be set to zero. */
413 static pid_t inf_ttrace_vfork_ppid
= -1;
416 inf_ttrace_follow_fork (struct target_ops
*ops
, int follow_child
,
420 lwpid_t lwpid
, flwpid
;
422 struct thread_info
*tp
= inferior_thread ();
424 gdb_assert (tp
->pending_follow
.kind
== TARGET_WAITKIND_FORKED
425 || tp
->pending_follow
.kind
== TARGET_WAITKIND_VFORKED
);
427 pid
= ptid_get_pid (inferior_ptid
);
428 lwpid
= ptid_get_lwp (inferior_ptid
);
430 /* Get all important details that core GDB doesn't (and shouldn't)
432 if (ttrace (TT_LWP_GET_STATE
, pid
, lwpid
,
433 (uintptr_t)&tts
, sizeof tts
, 0) == -1)
434 perror_with_name (("ttrace"));
436 gdb_assert (tts
.tts_event
== TTEVT_FORK
|| tts
.tts_event
== TTEVT_VFORK
);
438 if (tts
.tts_u
.tts_fork
.tts_isparent
)
441 lwpid
= tts
.tts_lwpid
;
442 fpid
= tts
.tts_u
.tts_fork
.tts_fpid
;
443 flwpid
= tts
.tts_u
.tts_fork
.tts_flwpid
;
447 pid
= tts
.tts_u
.tts_fork
.tts_fpid
;
448 lwpid
= tts
.tts_u
.tts_fork
.tts_flwpid
;
450 flwpid
= tts
.tts_lwpid
;
455 struct inferior
*inf
;
456 struct inferior
*parent_inf
;
458 parent_inf
= find_inferior_pid (pid
);
460 inferior_ptid
= ptid_build (fpid
, flwpid
, 0);
461 inf
= add_inferior (fpid
);
462 inf
->attach_flag
= parent_inf
->attach_flag
;
463 inf
->pspace
= parent_inf
->pspace
;
464 inf
->aspace
= parent_inf
->aspace
;
465 copy_terminal_info (inf
, parent_inf
);
466 detach_breakpoints (ptid_build (pid
, lwpid
, 0));
468 target_terminal_ours ();
469 fprintf_unfiltered (gdb_stdlog
,
470 _("Attaching after fork to child process %ld.\n"),
475 inferior_ptid
= ptid_build (pid
, lwpid
, 0);
476 /* Detach any remaining breakpoints in the child. In the case
477 of fork events, we do not need to do this, because breakpoints
478 should have already been removed earlier. */
479 if (tts
.tts_event
== TTEVT_VFORK
)
480 detach_breakpoints (ptid_build (fpid
, flwpid
, 0));
482 target_terminal_ours ();
483 fprintf_unfiltered (gdb_stdlog
,
484 _("Detaching after fork from child process %ld.\n"),
488 if (tts
.tts_event
== TTEVT_VFORK
)
490 gdb_assert (!tts
.tts_u
.tts_fork
.tts_isparent
);
494 /* We can't detach from the parent yet. */
495 inf_ttrace_vfork_ppid
= pid
;
497 reattach_breakpoints (fpid
);
501 if (ttrace (TT_PROC_DETACH
, fpid
, 0, 0, 0, 0) == -1)
502 perror_with_name (("ttrace"));
504 /* Wait till we get the TTEVT_VFORK event in the parent.
505 This indicates that the child has called exec(3) or has
506 exited and that the parent is ready to be traced again. */
507 if (ttrace_wait (pid
, lwpid
, TTRACE_WAITOK
, &tts
, sizeof tts
) == -1)
508 perror_with_name (("ttrace_wait"));
509 gdb_assert (tts
.tts_event
== TTEVT_VFORK
);
510 gdb_assert (tts
.tts_u
.tts_fork
.tts_isparent
);
512 reattach_breakpoints (pid
);
517 gdb_assert (tts
.tts_u
.tts_fork
.tts_isparent
);
521 if (ttrace (TT_PROC_DETACH
, pid
, 0, 0, 0, 0) == -1)
522 perror_with_name (("ttrace"));
526 if (ttrace (TT_PROC_DETACH
, fpid
, 0, 0, 0, 0) == -1)
527 perror_with_name (("ttrace"));
533 struct thread_info
*ti
;
535 /* The child will start out single-threaded. */
536 inf_ttrace_num_lwps
= 1;
537 inf_ttrace_num_lwps_in_syscall
= 0;
540 delete_thread_silent (ptid_build (pid
, lwpid
, 0));
541 detach_inferior (pid
);
543 /* Add child thread. inferior_ptid was already set above. */
544 ti
= add_thread_silent (inferior_ptid
);
546 xmalloc (sizeof (struct inf_ttrace_private_thread_info
));
547 memset (ti
->private, 0,
548 sizeof (struct inf_ttrace_private_thread_info
));
555 /* File descriptors for pipes used as semaphores during initial
556 startup of an inferior. */
557 static int inf_ttrace_pfd1
[2];
558 static int inf_ttrace_pfd2
[2];
561 do_cleanup_pfds (void *dummy
)
563 close (inf_ttrace_pfd1
[0]);
564 close (inf_ttrace_pfd1
[1]);
565 close (inf_ttrace_pfd2
[0]);
566 close (inf_ttrace_pfd2
[1]);
568 unmark_fd_no_cloexec (inf_ttrace_pfd1
[0]);
569 unmark_fd_no_cloexec (inf_ttrace_pfd1
[1]);
570 unmark_fd_no_cloexec (inf_ttrace_pfd2
[0]);
571 unmark_fd_no_cloexec (inf_ttrace_pfd2
[1]);
575 inf_ttrace_prepare (void)
577 if (pipe (inf_ttrace_pfd1
) == -1)
578 perror_with_name (("pipe"));
580 if (pipe (inf_ttrace_pfd2
) == -1)
582 close (inf_ttrace_pfd1
[0]);
583 close (inf_ttrace_pfd2
[0]);
584 perror_with_name (("pipe"));
587 mark_fd_no_cloexec (inf_ttrace_pfd1
[0]);
588 mark_fd_no_cloexec (inf_ttrace_pfd1
[1]);
589 mark_fd_no_cloexec (inf_ttrace_pfd2
[0]);
590 mark_fd_no_cloexec (inf_ttrace_pfd2
[1]);
593 /* Prepare to be traced. */
598 struct cleanup
*old_chain
= make_cleanup (do_cleanup_pfds
, 0);
601 /* "Trace me, Dr. Memory!" */
602 if (ttrace (TT_PROC_SETTRC
, 0, 0, 0, TT_VERSION
, 0) == -1)
603 perror_with_name (("ttrace"));
605 /* Tell our parent that we are ready to be traced. */
606 if (write (inf_ttrace_pfd1
[1], &c
, sizeof c
) != sizeof c
)
607 perror_with_name (("write"));
609 /* Wait until our parent has set the initial event mask. */
610 if (read (inf_ttrace_pfd2
[0], &c
, sizeof c
) != sizeof c
)
611 perror_with_name (("read"));
613 do_cleanups (old_chain
);
616 /* Start tracing PID. */
619 inf_ttrace_him (struct target_ops
*ops
, int pid
)
621 struct cleanup
*old_chain
= make_cleanup (do_cleanup_pfds
, 0);
625 /* Wait until our child is ready to be traced. */
626 if (read (inf_ttrace_pfd1
[0], &c
, sizeof c
) != sizeof c
)
627 perror_with_name (("read"));
629 /* Set the initial event mask. */
630 memset (&tte
, 0, sizeof (tte
));
631 tte
.tte_events
|= TTEVT_EXEC
| TTEVT_EXIT
| TTEVT_FORK
| TTEVT_VFORK
;
632 tte
.tte_events
|= TTEVT_LWP_CREATE
| TTEVT_LWP_EXIT
| TTEVT_LWP_TERMINATE
;
633 #ifdef TTEVT_BPT_SSTEP
634 tte
.tte_events
|= TTEVT_BPT_SSTEP
;
636 tte
.tte_opts
|= TTEO_PROC_INHERIT
;
637 if (ttrace (TT_PROC_SET_EVENT_MASK
, pid
, 0,
638 (uintptr_t)&tte
, sizeof tte
, 0) == -1)
639 perror_with_name (("ttrace"));
641 /* Tell our child that we have set the initial event mask. */
642 if (write (inf_ttrace_pfd2
[1], &c
, sizeof c
) != sizeof c
)
643 perror_with_name (("write"));
645 do_cleanups (old_chain
);
649 startup_inferior (START_INFERIOR_TRAPS_EXPECTED
);
651 /* On some targets, there must be some explicit actions taken after
652 the inferior has been started up. */
653 target_post_startup_inferior (pid_to_ptid (pid
));
657 inf_ttrace_create_inferior (struct target_ops
*ops
, char *exec_file
,
658 char *allargs
, char **env
, int from_tty
)
662 gdb_assert (inf_ttrace_num_lwps
== 0);
663 gdb_assert (inf_ttrace_num_lwps_in_syscall
== 0);
664 gdb_assert (inf_ttrace_page_dict
.count
== 0);
665 gdb_assert (inf_ttrace_reenable_page_protections
== 0);
666 gdb_assert (inf_ttrace_vfork_ppid
== -1);
668 pid
= fork_inferior (exec_file
, allargs
, env
, inf_ttrace_me
, NULL
,
669 inf_ttrace_prepare
, NULL
, NULL
);
671 inf_ttrace_him (ops
, pid
);
675 inf_ttrace_mourn_inferior (struct target_ops
*ops
)
677 const int num_buckets
= ARRAY_SIZE (inf_ttrace_page_dict
.buckets
);
680 inf_ttrace_num_lwps
= 0;
681 inf_ttrace_num_lwps_in_syscall
= 0;
683 for (bucket
= 0; bucket
< num_buckets
; bucket
++)
685 struct inf_ttrace_page
*page
;
686 struct inf_ttrace_page
*next
;
688 page
= inf_ttrace_page_dict
.buckets
[bucket
].next
;
696 inf_ttrace_page_dict
.count
= 0;
699 generic_mourn_inferior ();
702 /* Assuming we just attached the debugger to a new inferior, create
703 a new thread_info structure for each thread, and add it to our
707 inf_ttrace_create_threads_after_attach (int pid
)
712 struct thread_info
*ti
;
714 status
= ttrace (TT_PROC_GET_FIRST_LWP_STATE
, pid
, 0,
715 (uintptr_t) &tts
, sizeof (ttstate_t
), 0);
717 perror_with_name (_("TT_PROC_GET_FIRST_LWP_STATE ttrace call failed"));
718 gdb_assert (tts
.tts_pid
== pid
);
720 /* Add the stopped thread. */
721 ptid
= ptid_build (pid
, tts
.tts_lwpid
, 0);
722 ti
= add_thread (ptid
);
723 ti
->private = xzalloc (sizeof (struct inf_ttrace_private_thread_info
));
724 inf_ttrace_num_lwps
++;
726 /* We use the "first stopped thread" as the currently active thread. */
727 inferior_ptid
= ptid
;
729 /* Iterative over all the remaining threads. */
735 status
= ttrace (TT_PROC_GET_NEXT_LWP_STATE
, pid
, 0,
736 (uintptr_t) &tts
, sizeof (ttstate_t
), 0);
738 perror_with_name (_("TT_PROC_GET_NEXT_LWP_STATE ttrace call failed"));
740 break; /* End of list. */
742 ptid
= ptid_build (tts
.tts_pid
, tts
.tts_lwpid
, 0);
743 ti
= add_thread (ptid
);
744 ti
->private = xzalloc (sizeof (struct inf_ttrace_private_thread_info
));
745 inf_ttrace_num_lwps
++;
750 inf_ttrace_attach (struct target_ops
*ops
, char *args
, int from_tty
)
755 struct inferior
*inf
;
757 pid
= parse_pid_to_attach (args
);
759 if (pid
== getpid ()) /* Trying to masturbate? */
760 error (_("I refuse to debug myself!"));
764 exec_file
= get_exec_file (0);
767 printf_unfiltered (_("Attaching to program: %s, %s\n"), exec_file
,
768 target_pid_to_str (pid_to_ptid (pid
)));
770 printf_unfiltered (_("Attaching to %s\n"),
771 target_pid_to_str (pid_to_ptid (pid
)));
773 gdb_flush (gdb_stdout
);
776 gdb_assert (inf_ttrace_num_lwps
== 0);
777 gdb_assert (inf_ttrace_num_lwps_in_syscall
== 0);
778 gdb_assert (inf_ttrace_vfork_ppid
== -1);
780 if (ttrace (TT_PROC_ATTACH
, pid
, 0, TT_KILL_ON_EXIT
, TT_VERSION
, 0) == -1)
781 perror_with_name (("ttrace"));
783 inf
= current_inferior ();
784 inferior_appeared (inf
, pid
);
785 inf
->attach_flag
= 1;
787 /* Set the initial event mask. */
788 memset (&tte
, 0, sizeof (tte
));
789 tte
.tte_events
|= TTEVT_EXEC
| TTEVT_EXIT
| TTEVT_FORK
| TTEVT_VFORK
;
790 tte
.tte_events
|= TTEVT_LWP_CREATE
| TTEVT_LWP_EXIT
| TTEVT_LWP_TERMINATE
;
791 #ifdef TTEVT_BPT_SSTEP
792 tte
.tte_events
|= TTEVT_BPT_SSTEP
;
794 tte
.tte_opts
|= TTEO_PROC_INHERIT
;
795 if (ttrace (TT_PROC_SET_EVENT_MASK
, pid
, 0,
796 (uintptr_t)&tte
, sizeof tte
, 0) == -1)
797 perror_with_name (("ttrace"));
801 inf_ttrace_create_threads_after_attach (pid
);
805 inf_ttrace_detach (struct target_ops
*ops
, const char *args
, int from_tty
)
807 pid_t pid
= ptid_get_pid (inferior_ptid
);
812 char *exec_file
= get_exec_file (0);
815 printf_unfiltered (_("Detaching from program: %s, %s\n"), exec_file
,
816 target_pid_to_str (pid_to_ptid (pid
)));
817 gdb_flush (gdb_stdout
);
822 /* ??? The HP-UX 11.0 ttrace(2) manual page doesn't mention that we
823 can pass a signal number here. Does this really work? */
824 if (ttrace (TT_PROC_DETACH
, pid
, 0, 0, sig
, 0) == -1)
825 perror_with_name (("ttrace"));
827 if (inf_ttrace_vfork_ppid
!= -1)
829 if (ttrace (TT_PROC_DETACH
, inf_ttrace_vfork_ppid
, 0, 0, 0, 0) == -1)
830 perror_with_name (("ttrace"));
831 inf_ttrace_vfork_ppid
= -1;
834 inf_ttrace_num_lwps
= 0;
835 inf_ttrace_num_lwps_in_syscall
= 0;
837 inferior_ptid
= null_ptid
;
838 detach_inferior (pid
);
844 inf_ttrace_kill (struct target_ops
*ops
)
846 pid_t pid
= ptid_get_pid (inferior_ptid
);
851 if (ttrace (TT_PROC_EXIT
, pid
, 0, 0, 0, 0) == -1)
852 perror_with_name (("ttrace"));
853 /* ??? Is it necessary to call ttrace_wait() here? */
855 if (inf_ttrace_vfork_ppid
!= -1)
857 if (ttrace (TT_PROC_DETACH
, inf_ttrace_vfork_ppid
, 0, 0, 0, 0) == -1)
858 perror_with_name (("ttrace"));
859 inf_ttrace_vfork_ppid
= -1;
862 target_mourn_inferior ();
865 /* Check is a dying thread is dead by now, and delete it from GDBs
866 thread list if so. */
868 inf_ttrace_delete_dead_threads_callback (struct thread_info
*info
, void *arg
)
871 struct inf_ttrace_private_thread_info
*p
;
873 if (is_exited (info
->ptid
))
876 lwpid
= ptid_get_lwp (info
->ptid
);
877 p
= (struct inf_ttrace_private_thread_info
*) info
->private;
879 /* Check if an lwp that was dying is still there or not. */
880 if (p
->dying
&& (kill (lwpid
, 0) == -1))
882 delete_thread (info
->ptid
);
887 /* Resume the lwp pointed to by INFO, with REQUEST, and pass it signal
891 inf_ttrace_resume_lwp (struct thread_info
*info
, ttreq_t request
, int sig
)
893 pid_t pid
= ptid_get_pid (info
->ptid
);
894 lwpid_t lwpid
= ptid_get_lwp (info
->ptid
);
896 if (ttrace (request
, pid
, lwpid
, TT_NOPC
, sig
, 0) == -1)
898 struct inf_ttrace_private_thread_info
*p
899 = (struct inf_ttrace_private_thread_info
*) info
->private;
900 if (p
->dying
&& errno
== EPROTO
)
901 /* This is expected, it means the dying lwp is really gone
902 by now. If ttrace had an event to inform the debugger
903 the lwp is really gone, this wouldn't be needed. */
904 delete_thread (info
->ptid
);
906 /* This was really unexpected. */
907 perror_with_name (("ttrace"));
911 /* Callback for iterate_over_threads. */
914 inf_ttrace_resume_callback (struct thread_info
*info
, void *arg
)
916 if (!ptid_equal (info
->ptid
, inferior_ptid
) && !is_exited (info
->ptid
))
917 inf_ttrace_resume_lwp (info
, TT_LWP_CONTINUE
, 0);
923 inf_ttrace_resume (struct target_ops
*ops
,
924 ptid_t ptid
, int step
, enum gdb_signal signal
)
927 ttreq_t request
= step
? TT_LWP_SINGLE
: TT_LWP_CONTINUE
;
928 int sig
= gdb_signal_to_host (signal
);
929 struct thread_info
*info
;
931 /* A specific PTID means `step only this process id'. */
932 resume_all
= (ptid_equal (ptid
, minus_one_ptid
));
934 /* If resuming all threads, it's the current thread that should be
935 handled specially. */
937 ptid
= inferior_ptid
;
939 info
= find_thread_ptid (ptid
);
940 inf_ttrace_resume_lwp (info
, request
, sig
);
943 /* Let all the other threads run too. */
944 iterate_over_threads (inf_ttrace_resume_callback
, NULL
);
948 inf_ttrace_wait (struct target_ops
*ops
,
949 ptid_t ptid
, struct target_waitstatus
*ourstatus
, int options
)
951 pid_t pid
= ptid_get_pid (ptid
);
952 lwpid_t lwpid
= ptid_get_lwp (ptid
);
954 struct thread_info
*ti
;
957 /* Until proven otherwise. */
958 ourstatus
->kind
= TARGET_WAITKIND_SPURIOUS
;
963 gdb_assert (pid
!= 0 || lwpid
== 0);
969 if (ttrace_wait (pid
, lwpid
, TTRACE_WAITOK
, &tts
, sizeof tts
) == -1)
970 perror_with_name (("ttrace_wait"));
972 if (tts
.tts_event
== TTEVT_VFORK
&& tts
.tts_u
.tts_fork
.tts_isparent
)
974 if (inf_ttrace_vfork_ppid
!= -1)
976 gdb_assert (inf_ttrace_vfork_ppid
== tts
.tts_pid
);
978 if (ttrace (TT_PROC_DETACH
, tts
.tts_pid
, 0, 0, 0, 0) == -1)
979 perror_with_name (("ttrace"));
980 inf_ttrace_vfork_ppid
= -1;
983 tts
.tts_event
= TTEVT_NONE
;
986 clear_sigint_trap ();
988 while (tts
.tts_event
== TTEVT_NONE
);
990 /* Now that we've waited, we can re-enable the page protections. */
991 if (inf_ttrace_reenable_page_protections
)
993 gdb_assert (inf_ttrace_num_lwps_in_syscall
== 0);
994 inf_ttrace_enable_page_protections (tts
.tts_pid
);
995 inf_ttrace_reenable_page_protections
= 0;
998 ptid
= ptid_build (tts
.tts_pid
, tts
.tts_lwpid
, 0);
1000 if (inf_ttrace_num_lwps
== 0)
1002 struct thread_info
*ti
;
1004 inf_ttrace_num_lwps
= 1;
1006 /* This is the earliest we hear about the lwp member of
1007 INFERIOR_PTID, after an attach or fork_inferior. */
1008 gdb_assert (ptid_get_lwp (inferior_ptid
) == 0);
1010 /* We haven't set the private member on the main thread yet. Do
1012 ti
= find_thread_ptid (inferior_ptid
);
1013 gdb_assert (ti
!= NULL
&& ti
->private == NULL
);
1015 xmalloc (sizeof (struct inf_ttrace_private_thread_info
));
1016 memset (ti
->private, 0,
1017 sizeof (struct inf_ttrace_private_thread_info
));
1019 /* Notify the core that this ptid changed. This changes
1020 inferior_ptid as well. */
1021 thread_change_ptid (inferior_ptid
, ptid
);
1024 switch (tts
.tts_event
)
1026 #ifdef TTEVT_BPT_SSTEP
1027 case TTEVT_BPT_SSTEP
:
1028 /* Make it look like a breakpoint. */
1029 ourstatus
->kind
= TARGET_WAITKIND_STOPPED
;
1030 ourstatus
->value
.sig
= GDB_SIGNAL_TRAP
;
1035 ourstatus
->kind
= TARGET_WAITKIND_EXECD
;
1036 ourstatus
->value
.execd_pathname
=
1037 xmalloc (tts
.tts_u
.tts_exec
.tts_pathlen
+ 1);
1038 if (ttrace (TT_PROC_GET_PATHNAME
, tts
.tts_pid
, 0,
1039 (uintptr_t)ourstatus
->value
.execd_pathname
,
1040 tts
.tts_u
.tts_exec
.tts_pathlen
, 0) == -1)
1041 perror_with_name (("ttrace"));
1042 ourstatus
->value
.execd_pathname
[tts
.tts_u
.tts_exec
.tts_pathlen
] = 0;
1044 /* At this point, all inserted breakpoints are gone. Doing this
1045 as soon as we detect an exec prevents the badness of deleting
1046 a breakpoint writing the current "shadow contents" to lift
1047 the bp. That shadow is NOT valid after an exec. */
1048 mark_breakpoints_out ();
1052 store_waitstatus (ourstatus
, tts
.tts_u
.tts_exit
.tts_exitcode
);
1053 inf_ttrace_num_lwps
= 0;
1057 related_ptid
= ptid_build (tts
.tts_u
.tts_fork
.tts_fpid
,
1058 tts
.tts_u
.tts_fork
.tts_flwpid
, 0);
1060 ourstatus
->kind
= TARGET_WAITKIND_FORKED
;
1061 ourstatus
->value
.related_pid
= related_ptid
;
1063 /* Make sure the other end of the fork is stopped too. */
1064 if (ttrace_wait (tts
.tts_u
.tts_fork
.tts_fpid
,
1065 tts
.tts_u
.tts_fork
.tts_flwpid
,
1066 TTRACE_WAITOK
, &tts
, sizeof tts
) == -1)
1067 perror_with_name (("ttrace_wait"));
1069 gdb_assert (tts
.tts_event
== TTEVT_FORK
);
1070 if (tts
.tts_u
.tts_fork
.tts_isparent
)
1072 related_ptid
= ptid_build (tts
.tts_u
.tts_fork
.tts_fpid
,
1073 tts
.tts_u
.tts_fork
.tts_flwpid
, 0);
1074 ptid
= ptid_build (tts
.tts_pid
, tts
.tts_lwpid
, 0);
1075 ourstatus
->value
.related_pid
= related_ptid
;
1080 gdb_assert (!tts
.tts_u
.tts_fork
.tts_isparent
);
1082 related_ptid
= ptid_build (tts
.tts_u
.tts_fork
.tts_fpid
,
1083 tts
.tts_u
.tts_fork
.tts_flwpid
, 0);
1085 ourstatus
->kind
= TARGET_WAITKIND_VFORKED
;
1086 ourstatus
->value
.related_pid
= related_ptid
;
1088 /* HACK: To avoid touching the parent during the vfork, switch
1090 inferior_ptid
= ptid
;
1093 case TTEVT_LWP_CREATE
:
1094 lwpid
= tts
.tts_u
.tts_thread
.tts_target_lwpid
;
1095 ptid
= ptid_build (tts
.tts_pid
, lwpid
, 0);
1096 ti
= add_thread (ptid
);
1098 xmalloc (sizeof (struct inf_ttrace_private_thread_info
));
1099 memset (ti
->private, 0,
1100 sizeof (struct inf_ttrace_private_thread_info
));
1101 inf_ttrace_num_lwps
++;
1102 ptid
= ptid_build (tts
.tts_pid
, tts
.tts_lwpid
, 0);
1103 /* Let the lwp_create-caller thread continue. */
1104 ttrace (TT_LWP_CONTINUE
, ptid_get_pid (ptid
),
1105 ptid_get_lwp (ptid
), TT_NOPC
, 0, 0);
1106 /* Return without stopping the whole process. */
1107 ourstatus
->kind
= TARGET_WAITKIND_IGNORE
;
1110 case TTEVT_LWP_EXIT
:
1111 if (print_thread_events
)
1112 printf_unfiltered (_("[%s exited]\n"), target_pid_to_str (ptid
));
1113 ti
= find_thread_ptid (ptid
);
1114 gdb_assert (ti
!= NULL
);
1115 ((struct inf_ttrace_private_thread_info
*)ti
->private)->dying
= 1;
1116 inf_ttrace_num_lwps
--;
1117 /* Let the thread really exit. */
1118 ttrace (TT_LWP_CONTINUE
, ptid_get_pid (ptid
),
1119 ptid_get_lwp (ptid
), TT_NOPC
, 0, 0);
1120 /* Return without stopping the whole process. */
1121 ourstatus
->kind
= TARGET_WAITKIND_IGNORE
;
1124 case TTEVT_LWP_TERMINATE
:
1125 lwpid
= tts
.tts_u
.tts_thread
.tts_target_lwpid
;
1126 ptid
= ptid_build (tts
.tts_pid
, lwpid
, 0);
1127 if (print_thread_events
)
1128 printf_unfiltered(_("[%s has been terminated]\n"),
1129 target_pid_to_str (ptid
));
1130 ti
= find_thread_ptid (ptid
);
1131 gdb_assert (ti
!= NULL
);
1132 ((struct inf_ttrace_private_thread_info
*)ti
->private)->dying
= 1;
1133 inf_ttrace_num_lwps
--;
1135 /* Resume the lwp_terminate-caller thread. */
1136 ptid
= ptid_build (tts
.tts_pid
, tts
.tts_lwpid
, 0);
1137 ttrace (TT_LWP_CONTINUE
, ptid_get_pid (ptid
),
1138 ptid_get_lwp (ptid
), TT_NOPC
, 0, 0);
1139 /* Return without stopping the whole process. */
1140 ourstatus
->kind
= TARGET_WAITKIND_IGNORE
;
1144 ourstatus
->kind
= TARGET_WAITKIND_STOPPED
;
1145 ourstatus
->value
.sig
=
1146 gdb_signal_from_host (tts
.tts_u
.tts_signal
.tts_signo
);
1149 case TTEVT_SYSCALL_ENTRY
:
1150 gdb_assert (inf_ttrace_reenable_page_protections
== 0);
1151 inf_ttrace_num_lwps_in_syscall
++;
1152 if (inf_ttrace_num_lwps_in_syscall
== 1)
1154 /* A thread has just entered a system call. Disable any
1155 page protections as the kernel can't deal with them. */
1156 inf_ttrace_disable_page_protections (tts
.tts_pid
);
1158 ourstatus
->kind
= TARGET_WAITKIND_SYSCALL_ENTRY
;
1159 ourstatus
->value
.syscall_number
= tts
.tts_scno
;
1162 case TTEVT_SYSCALL_RETURN
:
1163 if (inf_ttrace_num_lwps_in_syscall
> 0)
1165 /* If the last thread has just left the system call, this
1166 would be a logical place to re-enable the page
1167 protections, but that doesn't work. We can't re-enable
1168 them until we've done another wait. */
1169 inf_ttrace_reenable_page_protections
=
1170 (inf_ttrace_num_lwps_in_syscall
== 1);
1171 inf_ttrace_num_lwps_in_syscall
--;
1173 ourstatus
->kind
= TARGET_WAITKIND_SYSCALL_RETURN
;
1174 ourstatus
->value
.syscall_number
= tts
.tts_scno
;
1178 gdb_assert (!"Unexpected ttrace event");
1182 /* Make sure all threads within the process are stopped. */
1183 if (ttrace (TT_PROC_STOP
, tts
.tts_pid
, 0, 0, 0, 0) == -1)
1184 perror_with_name (("ttrace"));
1186 /* Now that the whole process is stopped, check if any dying thread
1187 is really dead by now. If a dying thread is still alive, it will
1188 be stopped too, and will still show up in `info threads', tagged
1189 with "(Exiting)". We could make `info threads' prune dead
1190 threads instead via inf_ttrace_thread_alive, but doing this here
1191 has the advantage that a frontend is notificed sooner of thread
1192 exits. Note that a dying lwp is still alive, it still has to be
1193 resumed, like any other lwp. */
1194 iterate_over_threads (inf_ttrace_delete_dead_threads_callback
, NULL
);
1199 /* Transfer LEN bytes from ADDR in the inferior's memory into READBUF,
1200 and transfer LEN bytes from WRITEBUF into the inferior's memory at
1201 ADDR. Either READBUF or WRITEBUF may be null, in which case the
1202 corresponding transfer doesn't happen. Return the number of bytes
1203 actually transferred (which may be zero if an error occurs). */
1206 inf_ttrace_xfer_memory (CORE_ADDR addr
, ULONGEST len
,
1207 void *readbuf
, const void *writebuf
)
1209 pid_t pid
= ptid_get_pid (inferior_ptid
);
1211 /* HP-UX treats text space and data space differently. GDB however,
1212 doesn't really know the difference. Therefore we try both. Try
1213 text space before data space though because when we're writing
1214 into text space the instruction cache might need to be flushed. */
1217 && ttrace (TT_PROC_RDTEXT
, pid
, 0, addr
, len
, (uintptr_t)readbuf
) == -1
1218 && ttrace (TT_PROC_RDDATA
, pid
, 0, addr
, len
, (uintptr_t)readbuf
) == -1)
1222 && ttrace (TT_PROC_WRTEXT
, pid
, 0, addr
, len
, (uintptr_t)writebuf
) == -1
1223 && ttrace (TT_PROC_WRDATA
, pid
, 0, addr
, len
, (uintptr_t)writebuf
) == -1)
1229 static enum target_xfer_status
1230 inf_ttrace_xfer_partial (struct target_ops
*ops
, enum target_object object
,
1231 const char *annex
, gdb_byte
*readbuf
,
1232 const gdb_byte
*writebuf
,
1233 ULONGEST offset
, ULONGEST len
, ULONGEST
*xfered_len
)
1237 case TARGET_OBJECT_MEMORY
:
1239 LONGEST val
= inf_ttrace_xfer_memory (offset
, len
, readbuf
, writebuf
);
1242 return TARGET_XFER_EOF
;
1245 *xfered_len
= (ULONGEST
) val
;
1246 return TARGET_XFER_OK
;
1250 case TARGET_OBJECT_UNWIND_TABLE
:
1251 return TARGET_XFER_E_IO
;
1253 case TARGET_OBJECT_AUXV
:
1254 return TARGET_XFER_E_IO
;
1256 case TARGET_OBJECT_WCOOKIE
:
1257 return TARGET_XFER_E_IO
;
1260 return TARGET_XFER_E_IO
;
1264 /* Print status information about what we're accessing. */
1267 inf_ttrace_files_info (struct target_ops
*ignore
)
1269 struct inferior
*inf
= current_inferior ();
1270 printf_filtered (_("\tUsing the running image of %s %s.\n"),
1271 inf
->attach_flag
? "attached" : "child",
1272 target_pid_to_str (inferior_ptid
));
1276 inf_ttrace_thread_alive (struct target_ops
*ops
, ptid_t ptid
)
1281 /* Return a string describing the state of the thread specified by
1285 inf_ttrace_extra_thread_info (struct target_ops
*self
,
1286 struct thread_info
*info
)
1288 struct inf_ttrace_private_thread_info
* private =
1289 (struct inf_ttrace_private_thread_info
*) info
->private;
1291 if (private != NULL
&& private->dying
)
1298 inf_ttrace_pid_to_str (struct target_ops
*ops
, ptid_t ptid
)
1300 pid_t pid
= ptid_get_pid (ptid
);
1301 lwpid_t lwpid
= ptid_get_lwp (ptid
);
1302 static char buf
[128];
1305 xsnprintf (buf
, sizeof buf
, "process %ld",
1308 xsnprintf (buf
, sizeof buf
, "process %ld, lwp %ld",
1309 (long) pid
, (long) lwpid
);
1314 /* Implement the get_ada_task_ptid target_ops method. */
1317 inf_ttrace_get_ada_task_ptid (struct target_ops
*self
, long lwp
, long thread
)
1319 return ptid_build (ptid_get_pid (inferior_ptid
), lwp
, 0);
1324 inf_ttrace_target (void)
1326 struct target_ops
*t
= inf_child_target ();
1328 t
->to_attach
= inf_ttrace_attach
;
1329 t
->to_detach
= inf_ttrace_detach
;
1330 t
->to_resume
= inf_ttrace_resume
;
1331 t
->to_wait
= inf_ttrace_wait
;
1332 t
->to_files_info
= inf_ttrace_files_info
;
1333 t
->to_can_use_hw_breakpoint
= inf_ttrace_can_use_hw_breakpoint
;
1334 t
->to_insert_watchpoint
= inf_ttrace_insert_watchpoint
;
1335 t
->to_remove_watchpoint
= inf_ttrace_remove_watchpoint
;
1336 t
->to_stopped_by_watchpoint
= inf_ttrace_stopped_by_watchpoint
;
1337 t
->to_region_ok_for_hw_watchpoint
=
1338 inf_ttrace_region_ok_for_hw_watchpoint
;
1339 t
->to_kill
= inf_ttrace_kill
;
1340 t
->to_create_inferior
= inf_ttrace_create_inferior
;
1341 t
->to_follow_fork
= inf_ttrace_follow_fork
;
1342 t
->to_mourn_inferior
= inf_ttrace_mourn_inferior
;
1343 t
->to_thread_alive
= inf_ttrace_thread_alive
;
1344 t
->to_extra_thread_info
= inf_ttrace_extra_thread_info
;
1345 t
->to_pid_to_str
= inf_ttrace_pid_to_str
;
1346 t
->to_xfer_partial
= inf_ttrace_xfer_partial
;
1347 t
->to_get_ada_task_ptid
= inf_ttrace_get_ada_task_ptid
;
1354 /* Prevent warning from -Wmissing-prototypes. */
1355 void _initialize_inf_ttrace (void);
1358 _initialize_inf_ttrace (void)
1361 inf_ttrace_page_dict
.pagesize
= getpagesize();