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
);
647 if (!target_is_pushed (ops
))
650 startup_inferior (START_INFERIOR_TRAPS_EXPECTED
);
652 /* On some targets, there must be some explicit actions taken after
653 the inferior has been started up. */
654 target_post_startup_inferior (pid_to_ptid (pid
));
658 inf_ttrace_create_inferior (struct target_ops
*ops
, char *exec_file
,
659 char *allargs
, char **env
, int from_tty
)
663 gdb_assert (inf_ttrace_num_lwps
== 0);
664 gdb_assert (inf_ttrace_num_lwps_in_syscall
== 0);
665 gdb_assert (inf_ttrace_page_dict
.count
== 0);
666 gdb_assert (inf_ttrace_reenable_page_protections
== 0);
667 gdb_assert (inf_ttrace_vfork_ppid
== -1);
669 pid
= fork_inferior (exec_file
, allargs
, env
, inf_ttrace_me
, NULL
,
670 inf_ttrace_prepare
, NULL
, NULL
);
672 inf_ttrace_him (ops
, pid
);
676 inf_ttrace_mourn_inferior (struct target_ops
*ops
)
678 const int num_buckets
= ARRAY_SIZE (inf_ttrace_page_dict
.buckets
);
681 inf_ttrace_num_lwps
= 0;
682 inf_ttrace_num_lwps_in_syscall
= 0;
684 for (bucket
= 0; bucket
< num_buckets
; bucket
++)
686 struct inf_ttrace_page
*page
;
687 struct inf_ttrace_page
*next
;
689 page
= inf_ttrace_page_dict
.buckets
[bucket
].next
;
697 inf_ttrace_page_dict
.count
= 0;
699 generic_mourn_inferior ();
700 inf_child_maybe_unpush_target (ops
);
703 /* Assuming we just attached the debugger to a new inferior, create
704 a new thread_info structure for each thread, and add it to our
708 inf_ttrace_create_threads_after_attach (int pid
)
713 struct thread_info
*ti
;
715 status
= ttrace (TT_PROC_GET_FIRST_LWP_STATE
, pid
, 0,
716 (uintptr_t) &tts
, sizeof (ttstate_t
), 0);
718 perror_with_name (_("TT_PROC_GET_FIRST_LWP_STATE ttrace call failed"));
719 gdb_assert (tts
.tts_pid
== pid
);
721 /* Add the stopped thread. */
722 ptid
= ptid_build (pid
, tts
.tts_lwpid
, 0);
723 ti
= add_thread (ptid
);
724 ti
->private = xzalloc (sizeof (struct inf_ttrace_private_thread_info
));
725 inf_ttrace_num_lwps
++;
727 /* We use the "first stopped thread" as the currently active thread. */
728 inferior_ptid
= ptid
;
730 /* Iterative over all the remaining threads. */
736 status
= ttrace (TT_PROC_GET_NEXT_LWP_STATE
, pid
, 0,
737 (uintptr_t) &tts
, sizeof (ttstate_t
), 0);
739 perror_with_name (_("TT_PROC_GET_NEXT_LWP_STATE ttrace call failed"));
741 break; /* End of list. */
743 ptid
= ptid_build (tts
.tts_pid
, tts
.tts_lwpid
, 0);
744 ti
= add_thread (ptid
);
745 ti
->private = xzalloc (sizeof (struct inf_ttrace_private_thread_info
));
746 inf_ttrace_num_lwps
++;
751 inf_ttrace_attach (struct target_ops
*ops
, char *args
, int from_tty
)
756 struct inferior
*inf
;
758 pid
= parse_pid_to_attach (args
);
760 if (pid
== getpid ()) /* Trying to masturbate? */
761 error (_("I refuse to debug myself!"));
765 exec_file
= get_exec_file (0);
768 printf_unfiltered (_("Attaching to program: %s, %s\n"), exec_file
,
769 target_pid_to_str (pid_to_ptid (pid
)));
771 printf_unfiltered (_("Attaching to %s\n"),
772 target_pid_to_str (pid_to_ptid (pid
)));
774 gdb_flush (gdb_stdout
);
777 gdb_assert (inf_ttrace_num_lwps
== 0);
778 gdb_assert (inf_ttrace_num_lwps_in_syscall
== 0);
779 gdb_assert (inf_ttrace_vfork_ppid
== -1);
781 if (ttrace (TT_PROC_ATTACH
, pid
, 0, TT_KILL_ON_EXIT
, TT_VERSION
, 0) == -1)
782 perror_with_name (("ttrace"));
784 inf
= current_inferior ();
785 inferior_appeared (inf
, pid
);
786 inf
->attach_flag
= 1;
788 /* Set the initial event mask. */
789 memset (&tte
, 0, sizeof (tte
));
790 tte
.tte_events
|= TTEVT_EXEC
| TTEVT_EXIT
| TTEVT_FORK
| TTEVT_VFORK
;
791 tte
.tte_events
|= TTEVT_LWP_CREATE
| TTEVT_LWP_EXIT
| TTEVT_LWP_TERMINATE
;
792 #ifdef TTEVT_BPT_SSTEP
793 tte
.tte_events
|= TTEVT_BPT_SSTEP
;
795 tte
.tte_opts
|= TTEO_PROC_INHERIT
;
796 if (ttrace (TT_PROC_SET_EVENT_MASK
, pid
, 0,
797 (uintptr_t)&tte
, sizeof tte
, 0) == -1)
798 perror_with_name (("ttrace"));
800 if (!target_is_pushed (ops
))
803 inf_ttrace_create_threads_after_attach (pid
);
807 inf_ttrace_detach (struct target_ops
*ops
, const char *args
, int from_tty
)
809 pid_t pid
= ptid_get_pid (inferior_ptid
);
814 char *exec_file
= get_exec_file (0);
817 printf_unfiltered (_("Detaching from program: %s, %s\n"), exec_file
,
818 target_pid_to_str (pid_to_ptid (pid
)));
819 gdb_flush (gdb_stdout
);
824 /* ??? The HP-UX 11.0 ttrace(2) manual page doesn't mention that we
825 can pass a signal number here. Does this really work? */
826 if (ttrace (TT_PROC_DETACH
, pid
, 0, 0, sig
, 0) == -1)
827 perror_with_name (("ttrace"));
829 if (inf_ttrace_vfork_ppid
!= -1)
831 if (ttrace (TT_PROC_DETACH
, inf_ttrace_vfork_ppid
, 0, 0, 0, 0) == -1)
832 perror_with_name (("ttrace"));
833 inf_ttrace_vfork_ppid
= -1;
836 inf_ttrace_num_lwps
= 0;
837 inf_ttrace_num_lwps_in_syscall
= 0;
839 inferior_ptid
= null_ptid
;
840 detach_inferior (pid
);
842 inf_child_maybe_unpush_target (ops
);
846 inf_ttrace_kill (struct target_ops
*ops
)
848 pid_t pid
= ptid_get_pid (inferior_ptid
);
853 if (ttrace (TT_PROC_EXIT
, pid
, 0, 0, 0, 0) == -1)
854 perror_with_name (("ttrace"));
855 /* ??? Is it necessary to call ttrace_wait() here? */
857 if (inf_ttrace_vfork_ppid
!= -1)
859 if (ttrace (TT_PROC_DETACH
, inf_ttrace_vfork_ppid
, 0, 0, 0, 0) == -1)
860 perror_with_name (("ttrace"));
861 inf_ttrace_vfork_ppid
= -1;
864 target_mourn_inferior ();
867 /* Check is a dying thread is dead by now, and delete it from GDBs
868 thread list if so. */
870 inf_ttrace_delete_dead_threads_callback (struct thread_info
*info
, void *arg
)
873 struct inf_ttrace_private_thread_info
*p
;
875 if (is_exited (info
->ptid
))
878 lwpid
= ptid_get_lwp (info
->ptid
);
879 p
= (struct inf_ttrace_private_thread_info
*) info
->private;
881 /* Check if an lwp that was dying is still there or not. */
882 if (p
->dying
&& (kill (lwpid
, 0) == -1))
884 delete_thread (info
->ptid
);
889 /* Resume the lwp pointed to by INFO, with REQUEST, and pass it signal
893 inf_ttrace_resume_lwp (struct thread_info
*info
, ttreq_t request
, int sig
)
895 pid_t pid
= ptid_get_pid (info
->ptid
);
896 lwpid_t lwpid
= ptid_get_lwp (info
->ptid
);
898 if (ttrace (request
, pid
, lwpid
, TT_NOPC
, sig
, 0) == -1)
900 struct inf_ttrace_private_thread_info
*p
901 = (struct inf_ttrace_private_thread_info
*) info
->private;
902 if (p
->dying
&& errno
== EPROTO
)
903 /* This is expected, it means the dying lwp is really gone
904 by now. If ttrace had an event to inform the debugger
905 the lwp is really gone, this wouldn't be needed. */
906 delete_thread (info
->ptid
);
908 /* This was really unexpected. */
909 perror_with_name (("ttrace"));
913 /* Callback for iterate_over_threads. */
916 inf_ttrace_resume_callback (struct thread_info
*info
, void *arg
)
918 if (!ptid_equal (info
->ptid
, inferior_ptid
) && !is_exited (info
->ptid
))
919 inf_ttrace_resume_lwp (info
, TT_LWP_CONTINUE
, 0);
925 inf_ttrace_resume (struct target_ops
*ops
,
926 ptid_t ptid
, int step
, enum gdb_signal signal
)
929 ttreq_t request
= step
? TT_LWP_SINGLE
: TT_LWP_CONTINUE
;
930 int sig
= gdb_signal_to_host (signal
);
931 struct thread_info
*info
;
933 /* A specific PTID means `step only this process id'. */
934 resume_all
= (ptid_equal (ptid
, minus_one_ptid
));
936 /* If resuming all threads, it's the current thread that should be
937 handled specially. */
939 ptid
= inferior_ptid
;
941 info
= find_thread_ptid (ptid
);
942 inf_ttrace_resume_lwp (info
, request
, sig
);
945 /* Let all the other threads run too. */
946 iterate_over_threads (inf_ttrace_resume_callback
, NULL
);
950 inf_ttrace_wait (struct target_ops
*ops
,
951 ptid_t ptid
, struct target_waitstatus
*ourstatus
, int options
)
953 pid_t pid
= ptid_get_pid (ptid
);
954 lwpid_t lwpid
= ptid_get_lwp (ptid
);
956 struct thread_info
*ti
;
959 /* Until proven otherwise. */
960 ourstatus
->kind
= TARGET_WAITKIND_SPURIOUS
;
965 gdb_assert (pid
!= 0 || lwpid
== 0);
971 if (ttrace_wait (pid
, lwpid
, TTRACE_WAITOK
, &tts
, sizeof tts
) == -1)
972 perror_with_name (("ttrace_wait"));
974 if (tts
.tts_event
== TTEVT_VFORK
&& tts
.tts_u
.tts_fork
.tts_isparent
)
976 if (inf_ttrace_vfork_ppid
!= -1)
978 gdb_assert (inf_ttrace_vfork_ppid
== tts
.tts_pid
);
980 if (ttrace (TT_PROC_DETACH
, tts
.tts_pid
, 0, 0, 0, 0) == -1)
981 perror_with_name (("ttrace"));
982 inf_ttrace_vfork_ppid
= -1;
985 tts
.tts_event
= TTEVT_NONE
;
988 clear_sigint_trap ();
990 while (tts
.tts_event
== TTEVT_NONE
);
992 /* Now that we've waited, we can re-enable the page protections. */
993 if (inf_ttrace_reenable_page_protections
)
995 gdb_assert (inf_ttrace_num_lwps_in_syscall
== 0);
996 inf_ttrace_enable_page_protections (tts
.tts_pid
);
997 inf_ttrace_reenable_page_protections
= 0;
1000 ptid
= ptid_build (tts
.tts_pid
, tts
.tts_lwpid
, 0);
1002 if (inf_ttrace_num_lwps
== 0)
1004 struct thread_info
*ti
;
1006 inf_ttrace_num_lwps
= 1;
1008 /* This is the earliest we hear about the lwp member of
1009 INFERIOR_PTID, after an attach or fork_inferior. */
1010 gdb_assert (ptid_get_lwp (inferior_ptid
) == 0);
1012 /* We haven't set the private member on the main thread yet. Do
1014 ti
= find_thread_ptid (inferior_ptid
);
1015 gdb_assert (ti
!= NULL
&& ti
->private == NULL
);
1017 xmalloc (sizeof (struct inf_ttrace_private_thread_info
));
1018 memset (ti
->private, 0,
1019 sizeof (struct inf_ttrace_private_thread_info
));
1021 /* Notify the core that this ptid changed. This changes
1022 inferior_ptid as well. */
1023 thread_change_ptid (inferior_ptid
, ptid
);
1026 switch (tts
.tts_event
)
1028 #ifdef TTEVT_BPT_SSTEP
1029 case TTEVT_BPT_SSTEP
:
1030 /* Make it look like a breakpoint. */
1031 ourstatus
->kind
= TARGET_WAITKIND_STOPPED
;
1032 ourstatus
->value
.sig
= GDB_SIGNAL_TRAP
;
1037 ourstatus
->kind
= TARGET_WAITKIND_EXECD
;
1038 ourstatus
->value
.execd_pathname
=
1039 xmalloc (tts
.tts_u
.tts_exec
.tts_pathlen
+ 1);
1040 if (ttrace (TT_PROC_GET_PATHNAME
, tts
.tts_pid
, 0,
1041 (uintptr_t)ourstatus
->value
.execd_pathname
,
1042 tts
.tts_u
.tts_exec
.tts_pathlen
, 0) == -1)
1043 perror_with_name (("ttrace"));
1044 ourstatus
->value
.execd_pathname
[tts
.tts_u
.tts_exec
.tts_pathlen
] = 0;
1046 /* At this point, all inserted breakpoints are gone. Doing this
1047 as soon as we detect an exec prevents the badness of deleting
1048 a breakpoint writing the current "shadow contents" to lift
1049 the bp. That shadow is NOT valid after an exec. */
1050 mark_breakpoints_out ();
1054 store_waitstatus (ourstatus
, tts
.tts_u
.tts_exit
.tts_exitcode
);
1055 inf_ttrace_num_lwps
= 0;
1059 related_ptid
= ptid_build (tts
.tts_u
.tts_fork
.tts_fpid
,
1060 tts
.tts_u
.tts_fork
.tts_flwpid
, 0);
1062 ourstatus
->kind
= TARGET_WAITKIND_FORKED
;
1063 ourstatus
->value
.related_pid
= related_ptid
;
1065 /* Make sure the other end of the fork is stopped too. */
1066 if (ttrace_wait (tts
.tts_u
.tts_fork
.tts_fpid
,
1067 tts
.tts_u
.tts_fork
.tts_flwpid
,
1068 TTRACE_WAITOK
, &tts
, sizeof tts
) == -1)
1069 perror_with_name (("ttrace_wait"));
1071 gdb_assert (tts
.tts_event
== TTEVT_FORK
);
1072 if (tts
.tts_u
.tts_fork
.tts_isparent
)
1074 related_ptid
= ptid_build (tts
.tts_u
.tts_fork
.tts_fpid
,
1075 tts
.tts_u
.tts_fork
.tts_flwpid
, 0);
1076 ptid
= ptid_build (tts
.tts_pid
, tts
.tts_lwpid
, 0);
1077 ourstatus
->value
.related_pid
= related_ptid
;
1082 gdb_assert (!tts
.tts_u
.tts_fork
.tts_isparent
);
1084 related_ptid
= ptid_build (tts
.tts_u
.tts_fork
.tts_fpid
,
1085 tts
.tts_u
.tts_fork
.tts_flwpid
, 0);
1087 ourstatus
->kind
= TARGET_WAITKIND_VFORKED
;
1088 ourstatus
->value
.related_pid
= related_ptid
;
1090 /* HACK: To avoid touching the parent during the vfork, switch
1092 inferior_ptid
= ptid
;
1095 case TTEVT_LWP_CREATE
:
1096 lwpid
= tts
.tts_u
.tts_thread
.tts_target_lwpid
;
1097 ptid
= ptid_build (tts
.tts_pid
, lwpid
, 0);
1098 ti
= add_thread (ptid
);
1100 xmalloc (sizeof (struct inf_ttrace_private_thread_info
));
1101 memset (ti
->private, 0,
1102 sizeof (struct inf_ttrace_private_thread_info
));
1103 inf_ttrace_num_lwps
++;
1104 ptid
= ptid_build (tts
.tts_pid
, tts
.tts_lwpid
, 0);
1105 /* Let the lwp_create-caller thread continue. */
1106 ttrace (TT_LWP_CONTINUE
, ptid_get_pid (ptid
),
1107 ptid_get_lwp (ptid
), TT_NOPC
, 0, 0);
1108 /* Return without stopping the whole process. */
1109 ourstatus
->kind
= TARGET_WAITKIND_IGNORE
;
1112 case TTEVT_LWP_EXIT
:
1113 if (print_thread_events
)
1114 printf_unfiltered (_("[%s exited]\n"), target_pid_to_str (ptid
));
1115 ti
= find_thread_ptid (ptid
);
1116 gdb_assert (ti
!= NULL
);
1117 ((struct inf_ttrace_private_thread_info
*)ti
->private)->dying
= 1;
1118 inf_ttrace_num_lwps
--;
1119 /* Let the thread really exit. */
1120 ttrace (TT_LWP_CONTINUE
, ptid_get_pid (ptid
),
1121 ptid_get_lwp (ptid
), TT_NOPC
, 0, 0);
1122 /* Return without stopping the whole process. */
1123 ourstatus
->kind
= TARGET_WAITKIND_IGNORE
;
1126 case TTEVT_LWP_TERMINATE
:
1127 lwpid
= tts
.tts_u
.tts_thread
.tts_target_lwpid
;
1128 ptid
= ptid_build (tts
.tts_pid
, lwpid
, 0);
1129 if (print_thread_events
)
1130 printf_unfiltered(_("[%s has been terminated]\n"),
1131 target_pid_to_str (ptid
));
1132 ti
= find_thread_ptid (ptid
);
1133 gdb_assert (ti
!= NULL
);
1134 ((struct inf_ttrace_private_thread_info
*)ti
->private)->dying
= 1;
1135 inf_ttrace_num_lwps
--;
1137 /* Resume the lwp_terminate-caller thread. */
1138 ptid
= ptid_build (tts
.tts_pid
, tts
.tts_lwpid
, 0);
1139 ttrace (TT_LWP_CONTINUE
, ptid_get_pid (ptid
),
1140 ptid_get_lwp (ptid
), TT_NOPC
, 0, 0);
1141 /* Return without stopping the whole process. */
1142 ourstatus
->kind
= TARGET_WAITKIND_IGNORE
;
1146 ourstatus
->kind
= TARGET_WAITKIND_STOPPED
;
1147 ourstatus
->value
.sig
=
1148 gdb_signal_from_host (tts
.tts_u
.tts_signal
.tts_signo
);
1151 case TTEVT_SYSCALL_ENTRY
:
1152 gdb_assert (inf_ttrace_reenable_page_protections
== 0);
1153 inf_ttrace_num_lwps_in_syscall
++;
1154 if (inf_ttrace_num_lwps_in_syscall
== 1)
1156 /* A thread has just entered a system call. Disable any
1157 page protections as the kernel can't deal with them. */
1158 inf_ttrace_disable_page_protections (tts
.tts_pid
);
1160 ourstatus
->kind
= TARGET_WAITKIND_SYSCALL_ENTRY
;
1161 ourstatus
->value
.syscall_number
= tts
.tts_scno
;
1164 case TTEVT_SYSCALL_RETURN
:
1165 if (inf_ttrace_num_lwps_in_syscall
> 0)
1167 /* If the last thread has just left the system call, this
1168 would be a logical place to re-enable the page
1169 protections, but that doesn't work. We can't re-enable
1170 them until we've done another wait. */
1171 inf_ttrace_reenable_page_protections
=
1172 (inf_ttrace_num_lwps_in_syscall
== 1);
1173 inf_ttrace_num_lwps_in_syscall
--;
1175 ourstatus
->kind
= TARGET_WAITKIND_SYSCALL_RETURN
;
1176 ourstatus
->value
.syscall_number
= tts
.tts_scno
;
1180 gdb_assert (!"Unexpected ttrace event");
1184 /* Make sure all threads within the process are stopped. */
1185 if (ttrace (TT_PROC_STOP
, tts
.tts_pid
, 0, 0, 0, 0) == -1)
1186 perror_with_name (("ttrace"));
1188 /* Now that the whole process is stopped, check if any dying thread
1189 is really dead by now. If a dying thread is still alive, it will
1190 be stopped too, and will still show up in `info threads', tagged
1191 with "(Exiting)". We could make `info threads' prune dead
1192 threads instead via inf_ttrace_thread_alive, but doing this here
1193 has the advantage that a frontend is notificed sooner of thread
1194 exits. Note that a dying lwp is still alive, it still has to be
1195 resumed, like any other lwp. */
1196 iterate_over_threads (inf_ttrace_delete_dead_threads_callback
, NULL
);
1201 /* Transfer LEN bytes from ADDR in the inferior's memory into READBUF,
1202 and transfer LEN bytes from WRITEBUF into the inferior's memory at
1203 ADDR. Either READBUF or WRITEBUF may be null, in which case the
1204 corresponding transfer doesn't happen. Return the number of bytes
1205 actually transferred (which may be zero if an error occurs). */
1208 inf_ttrace_xfer_memory (CORE_ADDR addr
, ULONGEST len
,
1209 void *readbuf
, const void *writebuf
)
1211 pid_t pid
= ptid_get_pid (inferior_ptid
);
1213 /* HP-UX treats text space and data space differently. GDB however,
1214 doesn't really know the difference. Therefore we try both. Try
1215 text space before data space though because when we're writing
1216 into text space the instruction cache might need to be flushed. */
1219 && ttrace (TT_PROC_RDTEXT
, pid
, 0, addr
, len
, (uintptr_t)readbuf
) == -1
1220 && ttrace (TT_PROC_RDDATA
, pid
, 0, addr
, len
, (uintptr_t)readbuf
) == -1)
1224 && ttrace (TT_PROC_WRTEXT
, pid
, 0, addr
, len
, (uintptr_t)writebuf
) == -1
1225 && ttrace (TT_PROC_WRDATA
, pid
, 0, addr
, len
, (uintptr_t)writebuf
) == -1)
1231 static enum target_xfer_status
1232 inf_ttrace_xfer_partial (struct target_ops
*ops
, enum target_object object
,
1233 const char *annex
, gdb_byte
*readbuf
,
1234 const gdb_byte
*writebuf
,
1235 ULONGEST offset
, ULONGEST len
, ULONGEST
*xfered_len
)
1239 case TARGET_OBJECT_MEMORY
:
1241 LONGEST val
= inf_ttrace_xfer_memory (offset
, len
, readbuf
, writebuf
);
1244 return TARGET_XFER_EOF
;
1247 *xfered_len
= (ULONGEST
) val
;
1248 return TARGET_XFER_OK
;
1252 case TARGET_OBJECT_UNWIND_TABLE
:
1253 return TARGET_XFER_E_IO
;
1255 case TARGET_OBJECT_AUXV
:
1256 return TARGET_XFER_E_IO
;
1258 case TARGET_OBJECT_WCOOKIE
:
1259 return TARGET_XFER_E_IO
;
1262 return TARGET_XFER_E_IO
;
1266 /* Print status information about what we're accessing. */
1269 inf_ttrace_files_info (struct target_ops
*ignore
)
1271 struct inferior
*inf
= current_inferior ();
1272 printf_filtered (_("\tUsing the running image of %s %s.\n"),
1273 inf
->attach_flag
? "attached" : "child",
1274 target_pid_to_str (inferior_ptid
));
1278 inf_ttrace_thread_alive (struct target_ops
*ops
, ptid_t ptid
)
1283 /* Return a string describing the state of the thread specified by
1287 inf_ttrace_extra_thread_info (struct target_ops
*self
,
1288 struct thread_info
*info
)
1290 struct inf_ttrace_private_thread_info
* private =
1291 (struct inf_ttrace_private_thread_info
*) info
->private;
1293 if (private != NULL
&& private->dying
)
1300 inf_ttrace_pid_to_str (struct target_ops
*ops
, ptid_t ptid
)
1302 pid_t pid
= ptid_get_pid (ptid
);
1303 lwpid_t lwpid
= ptid_get_lwp (ptid
);
1304 static char buf
[128];
1307 xsnprintf (buf
, sizeof buf
, "process %ld",
1310 xsnprintf (buf
, sizeof buf
, "process %ld, lwp %ld",
1311 (long) pid
, (long) lwpid
);
1316 /* Implement the get_ada_task_ptid target_ops method. */
1319 inf_ttrace_get_ada_task_ptid (struct target_ops
*self
, long lwp
, long thread
)
1321 return ptid_build (ptid_get_pid (inferior_ptid
), lwp
, 0);
1326 inf_ttrace_target (void)
1328 struct target_ops
*t
= inf_child_target ();
1330 t
->to_attach
= inf_ttrace_attach
;
1331 t
->to_detach
= inf_ttrace_detach
;
1332 t
->to_resume
= inf_ttrace_resume
;
1333 t
->to_wait
= inf_ttrace_wait
;
1334 t
->to_files_info
= inf_ttrace_files_info
;
1335 t
->to_can_use_hw_breakpoint
= inf_ttrace_can_use_hw_breakpoint
;
1336 t
->to_insert_watchpoint
= inf_ttrace_insert_watchpoint
;
1337 t
->to_remove_watchpoint
= inf_ttrace_remove_watchpoint
;
1338 t
->to_stopped_by_watchpoint
= inf_ttrace_stopped_by_watchpoint
;
1339 t
->to_region_ok_for_hw_watchpoint
=
1340 inf_ttrace_region_ok_for_hw_watchpoint
;
1341 t
->to_kill
= inf_ttrace_kill
;
1342 t
->to_create_inferior
= inf_ttrace_create_inferior
;
1343 t
->to_follow_fork
= inf_ttrace_follow_fork
;
1344 t
->to_mourn_inferior
= inf_ttrace_mourn_inferior
;
1345 t
->to_thread_alive
= inf_ttrace_thread_alive
;
1346 t
->to_extra_thread_info
= inf_ttrace_extra_thread_info
;
1347 t
->to_pid_to_str
= inf_ttrace_pid_to_str
;
1348 t
->to_xfer_partial
= inf_ttrace_xfer_partial
;
1349 t
->to_get_ada_task_ptid
= inf_ttrace_get_ada_task_ptid
;
1356 /* Prevent warning from -Wmissing-prototypes. */
1357 void _initialize_inf_ttrace (void);
1360 _initialize_inf_ttrace (void)
1363 inf_ttrace_page_dict
.pagesize
= getpagesize();