1 /* Low-level child interface to ttrace.
3 Copyright (C) 2004-2014 Free Software Foundation, Inc.
5 This file is part of GDB.
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 3 of the License, or
10 (at your option) any later version.
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with this program. If not, see <http://www.gnu.org/licenses/>. */
22 /* The ttrace(2) system call didn't exist before HP-UX 10.30. Don't
23 try to compile this code unless we have it. */
28 #include "gdbthread.h"
33 #include "gdb_assert.h"
36 #include <sys/ttrace.h>
39 #include "inf-child.h"
40 #include "inf-ttrace.h"
41 #include "common/filestuff.h"
45 /* HP-UX uses a threading model where each user-space thread
46 corresponds to a kernel thread. These kernel threads are called
47 lwps. The ttrace(2) interface gives us almost full control over
48 the threads, which makes it very easy to support them in GDB. We
49 identify the threads by process ID and lwp ID. The ttrace(2) also
50 provides us with a thread's user ID (in the `tts_user_tid' member
51 of `ttstate_t') but we don't use that (yet) as it isn't necessary
52 to uniquely label the thread. */
54 /* Number of active lwps. */
55 static int inf_ttrace_num_lwps
;
58 /* On HP-UX versions that have the ttrace(2) system call, we can
59 implement "hardware" watchpoints by fiddling with the protection of
60 pages in the address space that contain the variable being watched.
61 In order to implement this, we keep a dictionary of pages for which
62 we have changed the protection. */
64 struct inf_ttrace_page
66 CORE_ADDR addr
; /* Page address. */
67 int prot
; /* Protection. */
68 int refcount
; /* Reference count. */
69 struct inf_ttrace_page
*next
;
70 struct inf_ttrace_page
*prev
;
73 struct inf_ttrace_page_dict
75 struct inf_ttrace_page buckets
[128];
76 int pagesize
; /* Page size. */
77 int count
; /* Number of pages in this dictionary. */
78 } inf_ttrace_page_dict
;
80 struct inf_ttrace_private_thread_info
85 /* Number of lwps that are currently in a system call. */
86 static int inf_ttrace_num_lwps_in_syscall
;
88 /* Flag to indicate whether we should re-enable page protections after
90 static int inf_ttrace_reenable_page_protections
;
92 /* Enable system call events for process PID. */
95 inf_ttrace_enable_syscall_events (pid_t pid
)
100 gdb_assert (inf_ttrace_num_lwps_in_syscall
== 0);
102 if (ttrace (TT_PROC_GET_EVENT_MASK
, pid
, 0,
103 (uintptr_t)&tte
, sizeof tte
, 0) == -1)
104 perror_with_name (("ttrace"));
106 tte
.tte_events
|= (TTEVT_SYSCALL_ENTRY
| TTEVT_SYSCALL_RETURN
);
108 if (ttrace (TT_PROC_SET_EVENT_MASK
, pid
, 0,
109 (uintptr_t)&tte
, sizeof tte
, 0) == -1)
110 perror_with_name (("ttrace"));
112 if (ttrace (TT_PROC_GET_FIRST_LWP_STATE
, pid
, 0,
113 (uintptr_t)&tts
, sizeof tts
, 0) == -1)
114 perror_with_name (("ttrace"));
116 if (tts
.tts_flags
& TTS_INSYSCALL
)
117 inf_ttrace_num_lwps_in_syscall
++;
119 /* FIXME: Handle multiple threads. */
122 /* Disable system call events for process PID. */
125 inf_ttrace_disable_syscall_events (pid_t pid
)
129 gdb_assert (inf_ttrace_page_dict
.count
== 0);
131 if (ttrace (TT_PROC_GET_EVENT_MASK
, pid
, 0,
132 (uintptr_t)&tte
, sizeof tte
, 0) == -1)
133 perror_with_name (("ttrace"));
135 tte
.tte_events
&= ~(TTEVT_SYSCALL_ENTRY
| TTEVT_SYSCALL_RETURN
);
137 if (ttrace (TT_PROC_SET_EVENT_MASK
, pid
, 0,
138 (uintptr_t)&tte
, sizeof tte
, 0) == -1)
139 perror_with_name (("ttrace"));
141 inf_ttrace_num_lwps_in_syscall
= 0;
144 /* Get information about the page at address ADDR for process PID from
147 static struct inf_ttrace_page
*
148 inf_ttrace_get_page (pid_t pid
, CORE_ADDR addr
)
150 const int num_buckets
= ARRAY_SIZE (inf_ttrace_page_dict
.buckets
);
151 const int pagesize
= inf_ttrace_page_dict
.pagesize
;
153 struct inf_ttrace_page
*page
;
155 bucket
= (addr
/ pagesize
) % num_buckets
;
156 page
= &inf_ttrace_page_dict
.buckets
[bucket
];
159 if (page
->addr
== addr
)
168 /* Add the page at address ADDR for process PID to the dictionary. */
170 static struct inf_ttrace_page
*
171 inf_ttrace_add_page (pid_t pid
, CORE_ADDR addr
)
173 const int num_buckets
= ARRAY_SIZE (inf_ttrace_page_dict
.buckets
);
174 const int pagesize
= inf_ttrace_page_dict
.pagesize
;
176 struct inf_ttrace_page
*page
;
177 struct inf_ttrace_page
*prev
= NULL
;
179 bucket
= (addr
/ pagesize
) % num_buckets
;
180 page
= &inf_ttrace_page_dict
.buckets
[bucket
];
183 if (page
->addr
== addr
)
194 if (ttrace (TT_PROC_GET_MPROTECT
, pid
, 0,
195 addr
, 0, (uintptr_t)&prot
) == -1)
196 perror_with_name (("ttrace"));
198 page
= XNEW (struct inf_ttrace_page
);
207 inf_ttrace_page_dict
.count
++;
208 if (inf_ttrace_page_dict
.count
== 1)
209 inf_ttrace_enable_syscall_events (pid
);
211 if (inf_ttrace_num_lwps_in_syscall
== 0)
213 if (ttrace (TT_PROC_SET_MPROTECT
, pid
, 0,
214 addr
, pagesize
, prot
& ~PROT_WRITE
) == -1)
215 perror_with_name (("ttrace"));
222 /* Insert the page at address ADDR of process PID to the dictionary. */
225 inf_ttrace_insert_page (pid_t pid
, CORE_ADDR addr
)
227 struct inf_ttrace_page
*page
;
229 page
= inf_ttrace_get_page (pid
, addr
);
231 page
= inf_ttrace_add_page (pid
, addr
);
236 /* Remove the page at address ADDR of process PID from the dictionary. */
239 inf_ttrace_remove_page (pid_t pid
, CORE_ADDR addr
)
241 const int pagesize
= inf_ttrace_page_dict
.pagesize
;
242 struct inf_ttrace_page
*page
;
244 page
= inf_ttrace_get_page (pid
, addr
);
247 gdb_assert (page
->refcount
>= 0);
249 if (page
->refcount
== 0)
251 if (inf_ttrace_num_lwps_in_syscall
== 0)
253 if (ttrace (TT_PROC_SET_MPROTECT
, pid
, 0,
254 addr
, pagesize
, page
->prot
) == -1)
255 perror_with_name (("ttrace"));
258 inf_ttrace_page_dict
.count
--;
259 if (inf_ttrace_page_dict
.count
== 0)
260 inf_ttrace_disable_syscall_events (pid
);
262 page
->prev
->next
= page
->next
;
264 page
->next
->prev
= page
->prev
;
270 /* Mask the bits in PROT from the page protections that are currently
271 in the dictionary for process PID. */
274 inf_ttrace_mask_page_protections (pid_t pid
, int prot
)
276 const int num_buckets
= ARRAY_SIZE (inf_ttrace_page_dict
.buckets
);
277 const int pagesize
= inf_ttrace_page_dict
.pagesize
;
280 for (bucket
= 0; bucket
< num_buckets
; bucket
++)
282 struct inf_ttrace_page
*page
;
284 page
= inf_ttrace_page_dict
.buckets
[bucket
].next
;
287 if (ttrace (TT_PROC_SET_MPROTECT
, pid
, 0,
288 page
->addr
, pagesize
, page
->prot
& ~prot
) == -1)
289 perror_with_name (("ttrace"));
296 /* Write-protect the pages in the dictionary for process PID. */
299 inf_ttrace_enable_page_protections (pid_t pid
)
301 inf_ttrace_mask_page_protections (pid
, PROT_WRITE
);
304 /* Restore the protection of the pages in the dictionary for process
308 inf_ttrace_disable_page_protections (pid_t pid
)
310 inf_ttrace_mask_page_protections (pid
, 0);
313 /* Insert a "hardware" watchpoint for LEN bytes at address ADDR of
317 inf_ttrace_insert_watchpoint (CORE_ADDR addr
, int len
, int type
,
318 struct expression
*cond
)
320 const int pagesize
= inf_ttrace_page_dict
.pagesize
;
321 pid_t pid
= ptid_get_pid (inferior_ptid
);
326 gdb_assert (type
== hw_write
);
328 page_addr
= (addr
/ pagesize
) * pagesize
;
329 num_pages
= (len
+ pagesize
- 1) / pagesize
;
331 for (page
= 0; page
< num_pages
; page
++, page_addr
+= pagesize
)
332 inf_ttrace_insert_page (pid
, page_addr
);
337 /* Remove a "hardware" watchpoint for LEN bytes at address ADDR of
341 inf_ttrace_remove_watchpoint (struct target_ops
*self
,
342 CORE_ADDR addr
, int len
, int type
,
343 struct expression
*cond
)
345 const int pagesize
= inf_ttrace_page_dict
.pagesize
;
346 pid_t pid
= ptid_get_pid (inferior_ptid
);
351 gdb_assert (type
== hw_write
);
353 page_addr
= (addr
/ pagesize
) * pagesize
;
354 num_pages
= (len
+ pagesize
- 1) / pagesize
;
356 for (page
= 0; page
< num_pages
; page
++, page_addr
+= pagesize
)
357 inf_ttrace_remove_page (pid
, page_addr
);
363 inf_ttrace_can_use_hw_breakpoint (struct target_ops
*self
,
364 int type
, int len
, int ot
)
366 return (type
== bp_hardware_watchpoint
);
370 inf_ttrace_region_ok_for_hw_watchpoint (CORE_ADDR addr
, int len
)
375 /* Return non-zero if the current inferior was (potentially) stopped
376 by hitting a "hardware" watchpoint. */
379 inf_ttrace_stopped_by_watchpoint (struct target_ops
*ops
)
381 pid_t pid
= ptid_get_pid (inferior_ptid
);
382 lwpid_t lwpid
= ptid_get_lwp (inferior_ptid
);
385 if (inf_ttrace_page_dict
.count
> 0)
387 if (ttrace (TT_LWP_GET_STATE
, pid
, lwpid
,
388 (uintptr_t)&tts
, sizeof tts
, 0) == -1)
389 perror_with_name (("ttrace"));
391 if (tts
.tts_event
== TTEVT_SIGNAL
392 && tts
.tts_u
.tts_signal
.tts_signo
== SIGBUS
)
394 const int pagesize
= inf_ttrace_page_dict
.pagesize
;
395 void *addr
= tts
.tts_u
.tts_signal
.tts_siginfo
.si_addr
;
396 CORE_ADDR page_addr
= ((uintptr_t)addr
/ pagesize
) * pagesize
;
398 if (inf_ttrace_get_page (pid
, page_addr
))
407 /* When tracking a vfork(2), we cannot detach from the parent until
408 after the child has called exec(3) or has exited. If we are still
409 attached to the parent, this variable will be set to the process ID
410 of the parent. Otherwise it will be set to zero. */
411 static pid_t inf_ttrace_vfork_ppid
= -1;
414 inf_ttrace_follow_fork (struct target_ops
*ops
, int follow_child
,
418 lwpid_t lwpid
, flwpid
;
420 struct thread_info
*tp
= inferior_thread ();
422 gdb_assert (tp
->pending_follow
.kind
== TARGET_WAITKIND_FORKED
423 || tp
->pending_follow
.kind
== TARGET_WAITKIND_VFORKED
);
425 pid
= ptid_get_pid (inferior_ptid
);
426 lwpid
= ptid_get_lwp (inferior_ptid
);
428 /* Get all important details that core GDB doesn't (and shouldn't)
430 if (ttrace (TT_LWP_GET_STATE
, pid
, lwpid
,
431 (uintptr_t)&tts
, sizeof tts
, 0) == -1)
432 perror_with_name (("ttrace"));
434 gdb_assert (tts
.tts_event
== TTEVT_FORK
|| tts
.tts_event
== TTEVT_VFORK
);
436 if (tts
.tts_u
.tts_fork
.tts_isparent
)
439 lwpid
= tts
.tts_lwpid
;
440 fpid
= tts
.tts_u
.tts_fork
.tts_fpid
;
441 flwpid
= tts
.tts_u
.tts_fork
.tts_flwpid
;
445 pid
= tts
.tts_u
.tts_fork
.tts_fpid
;
446 lwpid
= tts
.tts_u
.tts_fork
.tts_flwpid
;
448 flwpid
= tts
.tts_lwpid
;
453 struct inferior
*inf
;
454 struct inferior
*parent_inf
;
456 parent_inf
= find_inferior_pid (pid
);
458 inferior_ptid
= ptid_build (fpid
, flwpid
, 0);
459 inf
= add_inferior (fpid
);
460 inf
->attach_flag
= parent_inf
->attach_flag
;
461 inf
->pspace
= parent_inf
->pspace
;
462 inf
->aspace
= parent_inf
->aspace
;
463 copy_terminal_info (inf
, parent_inf
);
464 detach_breakpoints (ptid_build (pid
, lwpid
, 0));
466 target_terminal_ours ();
467 fprintf_unfiltered (gdb_stdlog
,
468 _("Attaching after fork to child process %ld.\n"),
473 inferior_ptid
= ptid_build (pid
, lwpid
, 0);
474 /* Detach any remaining breakpoints in the child. In the case
475 of fork events, we do not need to do this, because breakpoints
476 should have already been removed earlier. */
477 if (tts
.tts_event
== TTEVT_VFORK
)
478 detach_breakpoints (ptid_build (fpid
, flwpid
, 0));
480 target_terminal_ours ();
481 fprintf_unfiltered (gdb_stdlog
,
482 _("Detaching after fork from child process %ld.\n"),
486 if (tts
.tts_event
== TTEVT_VFORK
)
488 gdb_assert (!tts
.tts_u
.tts_fork
.tts_isparent
);
492 /* We can't detach from the parent yet. */
493 inf_ttrace_vfork_ppid
= pid
;
495 reattach_breakpoints (fpid
);
499 if (ttrace (TT_PROC_DETACH
, fpid
, 0, 0, 0, 0) == -1)
500 perror_with_name (("ttrace"));
502 /* Wait till we get the TTEVT_VFORK event in the parent.
503 This indicates that the child has called exec(3) or has
504 exited and that the parent is ready to be traced again. */
505 if (ttrace_wait (pid
, lwpid
, TTRACE_WAITOK
, &tts
, sizeof tts
) == -1)
506 perror_with_name (("ttrace_wait"));
507 gdb_assert (tts
.tts_event
== TTEVT_VFORK
);
508 gdb_assert (tts
.tts_u
.tts_fork
.tts_isparent
);
510 reattach_breakpoints (pid
);
515 gdb_assert (tts
.tts_u
.tts_fork
.tts_isparent
);
519 if (ttrace (TT_PROC_DETACH
, pid
, 0, 0, 0, 0) == -1)
520 perror_with_name (("ttrace"));
524 if (ttrace (TT_PROC_DETACH
, fpid
, 0, 0, 0, 0) == -1)
525 perror_with_name (("ttrace"));
531 struct thread_info
*ti
;
533 /* The child will start out single-threaded. */
534 inf_ttrace_num_lwps
= 1;
535 inf_ttrace_num_lwps_in_syscall
= 0;
538 delete_thread_silent (ptid_build (pid
, lwpid
, 0));
539 detach_inferior (pid
);
541 /* Add child thread. inferior_ptid was already set above. */
542 ti
= add_thread_silent (inferior_ptid
);
544 xmalloc (sizeof (struct inf_ttrace_private_thread_info
));
545 memset (ti
->private, 0,
546 sizeof (struct inf_ttrace_private_thread_info
));
553 /* File descriptors for pipes used as semaphores during initial
554 startup of an inferior. */
555 static int inf_ttrace_pfd1
[2];
556 static int inf_ttrace_pfd2
[2];
559 do_cleanup_pfds (void *dummy
)
561 close (inf_ttrace_pfd1
[0]);
562 close (inf_ttrace_pfd1
[1]);
563 close (inf_ttrace_pfd2
[0]);
564 close (inf_ttrace_pfd2
[1]);
566 unmark_fd_no_cloexec (inf_ttrace_pfd1
[0]);
567 unmark_fd_no_cloexec (inf_ttrace_pfd1
[1]);
568 unmark_fd_no_cloexec (inf_ttrace_pfd2
[0]);
569 unmark_fd_no_cloexec (inf_ttrace_pfd2
[1]);
573 inf_ttrace_prepare (void)
575 if (pipe (inf_ttrace_pfd1
) == -1)
576 perror_with_name (("pipe"));
578 if (pipe (inf_ttrace_pfd2
) == -1)
580 close (inf_ttrace_pfd1
[0]);
581 close (inf_ttrace_pfd2
[0]);
582 perror_with_name (("pipe"));
585 mark_fd_no_cloexec (inf_ttrace_pfd1
[0]);
586 mark_fd_no_cloexec (inf_ttrace_pfd1
[1]);
587 mark_fd_no_cloexec (inf_ttrace_pfd2
[0]);
588 mark_fd_no_cloexec (inf_ttrace_pfd2
[1]);
591 /* Prepare to be traced. */
596 struct cleanup
*old_chain
= make_cleanup (do_cleanup_pfds
, 0);
599 /* "Trace me, Dr. Memory!" */
600 if (ttrace (TT_PROC_SETTRC
, 0, 0, 0, TT_VERSION
, 0) == -1)
601 perror_with_name (("ttrace"));
603 /* Tell our parent that we are ready to be traced. */
604 if (write (inf_ttrace_pfd1
[1], &c
, sizeof c
) != sizeof c
)
605 perror_with_name (("write"));
607 /* Wait until our parent has set the initial event mask. */
608 if (read (inf_ttrace_pfd2
[0], &c
, sizeof c
) != sizeof c
)
609 perror_with_name (("read"));
611 do_cleanups (old_chain
);
614 /* Start tracing PID. */
617 inf_ttrace_him (struct target_ops
*ops
, int pid
)
619 struct cleanup
*old_chain
= make_cleanup (do_cleanup_pfds
, 0);
623 /* Wait until our child is ready to be traced. */
624 if (read (inf_ttrace_pfd1
[0], &c
, sizeof c
) != sizeof c
)
625 perror_with_name (("read"));
627 /* Set the initial event mask. */
628 memset (&tte
, 0, sizeof (tte
));
629 tte
.tte_events
|= TTEVT_EXEC
| TTEVT_EXIT
| TTEVT_FORK
| TTEVT_VFORK
;
630 tte
.tte_events
|= TTEVT_LWP_CREATE
| TTEVT_LWP_EXIT
| TTEVT_LWP_TERMINATE
;
631 #ifdef TTEVT_BPT_SSTEP
632 tte
.tte_events
|= TTEVT_BPT_SSTEP
;
634 tte
.tte_opts
|= TTEO_PROC_INHERIT
;
635 if (ttrace (TT_PROC_SET_EVENT_MASK
, pid
, 0,
636 (uintptr_t)&tte
, sizeof tte
, 0) == -1)
637 perror_with_name (("ttrace"));
639 /* Tell our child that we have set the initial event mask. */
640 if (write (inf_ttrace_pfd2
[1], &c
, sizeof c
) != sizeof c
)
641 perror_with_name (("write"));
643 do_cleanups (old_chain
);
647 startup_inferior (START_INFERIOR_TRAPS_EXPECTED
);
649 /* On some targets, there must be some explicit actions taken after
650 the inferior has been started up. */
651 target_post_startup_inferior (pid_to_ptid (pid
));
655 inf_ttrace_create_inferior (struct target_ops
*ops
, char *exec_file
,
656 char *allargs
, char **env
, int from_tty
)
660 gdb_assert (inf_ttrace_num_lwps
== 0);
661 gdb_assert (inf_ttrace_num_lwps_in_syscall
== 0);
662 gdb_assert (inf_ttrace_page_dict
.count
== 0);
663 gdb_assert (inf_ttrace_reenable_page_protections
== 0);
664 gdb_assert (inf_ttrace_vfork_ppid
== -1);
666 pid
= fork_inferior (exec_file
, allargs
, env
, inf_ttrace_me
, NULL
,
667 inf_ttrace_prepare
, NULL
, NULL
);
669 inf_ttrace_him (ops
, pid
);
673 inf_ttrace_mourn_inferior (struct target_ops
*ops
)
675 const int num_buckets
= ARRAY_SIZE (inf_ttrace_page_dict
.buckets
);
678 inf_ttrace_num_lwps
= 0;
679 inf_ttrace_num_lwps_in_syscall
= 0;
681 for (bucket
= 0; bucket
< num_buckets
; bucket
++)
683 struct inf_ttrace_page
*page
;
684 struct inf_ttrace_page
*next
;
686 page
= inf_ttrace_page_dict
.buckets
[bucket
].next
;
694 inf_ttrace_page_dict
.count
= 0;
697 generic_mourn_inferior ();
700 /* Assuming we just attached the debugger to a new inferior, create
701 a new thread_info structure for each thread, and add it to our
705 inf_ttrace_create_threads_after_attach (int pid
)
710 struct thread_info
*ti
;
712 status
= ttrace (TT_PROC_GET_FIRST_LWP_STATE
, pid
, 0,
713 (uintptr_t) &tts
, sizeof (ttstate_t
), 0);
715 perror_with_name (_("TT_PROC_GET_FIRST_LWP_STATE ttrace call failed"));
716 gdb_assert (tts
.tts_pid
== pid
);
718 /* Add the stopped thread. */
719 ptid
= ptid_build (pid
, tts
.tts_lwpid
, 0);
720 ti
= add_thread (ptid
);
721 ti
->private = xzalloc (sizeof (struct inf_ttrace_private_thread_info
));
722 inf_ttrace_num_lwps
++;
724 /* We use the "first stopped thread" as the currently active thread. */
725 inferior_ptid
= ptid
;
727 /* Iterative over all the remaining threads. */
733 status
= ttrace (TT_PROC_GET_NEXT_LWP_STATE
, pid
, 0,
734 (uintptr_t) &tts
, sizeof (ttstate_t
), 0);
736 perror_with_name (_("TT_PROC_GET_NEXT_LWP_STATE ttrace call failed"));
738 break; /* End of list. */
740 ptid
= ptid_build (tts
.tts_pid
, tts
.tts_lwpid
, 0);
741 ti
= add_thread (ptid
);
742 ti
->private = xzalloc (sizeof (struct inf_ttrace_private_thread_info
));
743 inf_ttrace_num_lwps
++;
748 inf_ttrace_attach (struct target_ops
*ops
, char *args
, int from_tty
)
753 struct inferior
*inf
;
755 pid
= parse_pid_to_attach (args
);
757 if (pid
== getpid ()) /* Trying to masturbate? */
758 error (_("I refuse to debug myself!"));
762 exec_file
= get_exec_file (0);
765 printf_unfiltered (_("Attaching to program: %s, %s\n"), exec_file
,
766 target_pid_to_str (pid_to_ptid (pid
)));
768 printf_unfiltered (_("Attaching to %s\n"),
769 target_pid_to_str (pid_to_ptid (pid
)));
771 gdb_flush (gdb_stdout
);
774 gdb_assert (inf_ttrace_num_lwps
== 0);
775 gdb_assert (inf_ttrace_num_lwps_in_syscall
== 0);
776 gdb_assert (inf_ttrace_vfork_ppid
== -1);
778 if (ttrace (TT_PROC_ATTACH
, pid
, 0, TT_KILL_ON_EXIT
, TT_VERSION
, 0) == -1)
779 perror_with_name (("ttrace"));
781 inf
= current_inferior ();
782 inferior_appeared (inf
, pid
);
783 inf
->attach_flag
= 1;
785 /* Set the initial event mask. */
786 memset (&tte
, 0, sizeof (tte
));
787 tte
.tte_events
|= TTEVT_EXEC
| TTEVT_EXIT
| TTEVT_FORK
| TTEVT_VFORK
;
788 tte
.tte_events
|= TTEVT_LWP_CREATE
| TTEVT_LWP_EXIT
| TTEVT_LWP_TERMINATE
;
789 #ifdef TTEVT_BPT_SSTEP
790 tte
.tte_events
|= TTEVT_BPT_SSTEP
;
792 tte
.tte_opts
|= TTEO_PROC_INHERIT
;
793 if (ttrace (TT_PROC_SET_EVENT_MASK
, pid
, 0,
794 (uintptr_t)&tte
, sizeof tte
, 0) == -1)
795 perror_with_name (("ttrace"));
799 inf_ttrace_create_threads_after_attach (pid
);
803 inf_ttrace_detach (struct target_ops
*ops
, const char *args
, int from_tty
)
805 pid_t pid
= ptid_get_pid (inferior_ptid
);
810 char *exec_file
= get_exec_file (0);
813 printf_unfiltered (_("Detaching from program: %s, %s\n"), exec_file
,
814 target_pid_to_str (pid_to_ptid (pid
)));
815 gdb_flush (gdb_stdout
);
820 /* ??? The HP-UX 11.0 ttrace(2) manual page doesn't mention that we
821 can pass a signal number here. Does this really work? */
822 if (ttrace (TT_PROC_DETACH
, pid
, 0, 0, sig
, 0) == -1)
823 perror_with_name (("ttrace"));
825 if (inf_ttrace_vfork_ppid
!= -1)
827 if (ttrace (TT_PROC_DETACH
, inf_ttrace_vfork_ppid
, 0, 0, 0, 0) == -1)
828 perror_with_name (("ttrace"));
829 inf_ttrace_vfork_ppid
= -1;
832 inf_ttrace_num_lwps
= 0;
833 inf_ttrace_num_lwps_in_syscall
= 0;
835 inferior_ptid
= null_ptid
;
836 detach_inferior (pid
);
842 inf_ttrace_kill (struct target_ops
*ops
)
844 pid_t pid
= ptid_get_pid (inferior_ptid
);
849 if (ttrace (TT_PROC_EXIT
, pid
, 0, 0, 0, 0) == -1)
850 perror_with_name (("ttrace"));
851 /* ??? Is it necessary to call ttrace_wait() here? */
853 if (inf_ttrace_vfork_ppid
!= -1)
855 if (ttrace (TT_PROC_DETACH
, inf_ttrace_vfork_ppid
, 0, 0, 0, 0) == -1)
856 perror_with_name (("ttrace"));
857 inf_ttrace_vfork_ppid
= -1;
860 target_mourn_inferior ();
863 /* Check is a dying thread is dead by now, and delete it from GDBs
864 thread list if so. */
866 inf_ttrace_delete_dead_threads_callback (struct thread_info
*info
, void *arg
)
869 struct inf_ttrace_private_thread_info
*p
;
871 if (is_exited (info
->ptid
))
874 lwpid
= ptid_get_lwp (info
->ptid
);
875 p
= (struct inf_ttrace_private_thread_info
*) info
->private;
877 /* Check if an lwp that was dying is still there or not. */
878 if (p
->dying
&& (kill (lwpid
, 0) == -1))
880 delete_thread (info
->ptid
);
885 /* Resume the lwp pointed to by INFO, with REQUEST, and pass it signal
889 inf_ttrace_resume_lwp (struct thread_info
*info
, ttreq_t request
, int sig
)
891 pid_t pid
= ptid_get_pid (info
->ptid
);
892 lwpid_t lwpid
= ptid_get_lwp (info
->ptid
);
894 if (ttrace (request
, pid
, lwpid
, TT_NOPC
, sig
, 0) == -1)
896 struct inf_ttrace_private_thread_info
*p
897 = (struct inf_ttrace_private_thread_info
*) info
->private;
898 if (p
->dying
&& errno
== EPROTO
)
899 /* This is expected, it means the dying lwp is really gone
900 by now. If ttrace had an event to inform the debugger
901 the lwp is really gone, this wouldn't be needed. */
902 delete_thread (info
->ptid
);
904 /* This was really unexpected. */
905 perror_with_name (("ttrace"));
909 /* Callback for iterate_over_threads. */
912 inf_ttrace_resume_callback (struct thread_info
*info
, void *arg
)
914 if (!ptid_equal (info
->ptid
, inferior_ptid
) && !is_exited (info
->ptid
))
915 inf_ttrace_resume_lwp (info
, TT_LWP_CONTINUE
, 0);
921 inf_ttrace_resume (struct target_ops
*ops
,
922 ptid_t ptid
, int step
, enum gdb_signal signal
)
925 ttreq_t request
= step
? TT_LWP_SINGLE
: TT_LWP_CONTINUE
;
926 int sig
= gdb_signal_to_host (signal
);
927 struct thread_info
*info
;
929 /* A specific PTID means `step only this process id'. */
930 resume_all
= (ptid_equal (ptid
, minus_one_ptid
));
932 /* If resuming all threads, it's the current thread that should be
933 handled specially. */
935 ptid
= inferior_ptid
;
937 info
= find_thread_ptid (ptid
);
938 inf_ttrace_resume_lwp (info
, request
, sig
);
941 /* Let all the other threads run too. */
942 iterate_over_threads (inf_ttrace_resume_callback
, NULL
);
946 inf_ttrace_wait (struct target_ops
*ops
,
947 ptid_t ptid
, struct target_waitstatus
*ourstatus
, int options
)
949 pid_t pid
= ptid_get_pid (ptid
);
950 lwpid_t lwpid
= ptid_get_lwp (ptid
);
952 struct thread_info
*ti
;
955 /* Until proven otherwise. */
956 ourstatus
->kind
= TARGET_WAITKIND_SPURIOUS
;
961 gdb_assert (pid
!= 0 || lwpid
== 0);
967 if (ttrace_wait (pid
, lwpid
, TTRACE_WAITOK
, &tts
, sizeof tts
) == -1)
968 perror_with_name (("ttrace_wait"));
970 if (tts
.tts_event
== TTEVT_VFORK
&& tts
.tts_u
.tts_fork
.tts_isparent
)
972 if (inf_ttrace_vfork_ppid
!= -1)
974 gdb_assert (inf_ttrace_vfork_ppid
== tts
.tts_pid
);
976 if (ttrace (TT_PROC_DETACH
, tts
.tts_pid
, 0, 0, 0, 0) == -1)
977 perror_with_name (("ttrace"));
978 inf_ttrace_vfork_ppid
= -1;
981 tts
.tts_event
= TTEVT_NONE
;
984 clear_sigint_trap ();
986 while (tts
.tts_event
== TTEVT_NONE
);
988 /* Now that we've waited, we can re-enable the page protections. */
989 if (inf_ttrace_reenable_page_protections
)
991 gdb_assert (inf_ttrace_num_lwps_in_syscall
== 0);
992 inf_ttrace_enable_page_protections (tts
.tts_pid
);
993 inf_ttrace_reenable_page_protections
= 0;
996 ptid
= ptid_build (tts
.tts_pid
, tts
.tts_lwpid
, 0);
998 if (inf_ttrace_num_lwps
== 0)
1000 struct thread_info
*ti
;
1002 inf_ttrace_num_lwps
= 1;
1004 /* This is the earliest we hear about the lwp member of
1005 INFERIOR_PTID, after an attach or fork_inferior. */
1006 gdb_assert (ptid_get_lwp (inferior_ptid
) == 0);
1008 /* We haven't set the private member on the main thread yet. Do
1010 ti
= find_thread_ptid (inferior_ptid
);
1011 gdb_assert (ti
!= NULL
&& ti
->private == NULL
);
1013 xmalloc (sizeof (struct inf_ttrace_private_thread_info
));
1014 memset (ti
->private, 0,
1015 sizeof (struct inf_ttrace_private_thread_info
));
1017 /* Notify the core that this ptid changed. This changes
1018 inferior_ptid as well. */
1019 thread_change_ptid (inferior_ptid
, ptid
);
1022 switch (tts
.tts_event
)
1024 #ifdef TTEVT_BPT_SSTEP
1025 case TTEVT_BPT_SSTEP
:
1026 /* Make it look like a breakpoint. */
1027 ourstatus
->kind
= TARGET_WAITKIND_STOPPED
;
1028 ourstatus
->value
.sig
= GDB_SIGNAL_TRAP
;
1033 ourstatus
->kind
= TARGET_WAITKIND_EXECD
;
1034 ourstatus
->value
.execd_pathname
=
1035 xmalloc (tts
.tts_u
.tts_exec
.tts_pathlen
+ 1);
1036 if (ttrace (TT_PROC_GET_PATHNAME
, tts
.tts_pid
, 0,
1037 (uintptr_t)ourstatus
->value
.execd_pathname
,
1038 tts
.tts_u
.tts_exec
.tts_pathlen
, 0) == -1)
1039 perror_with_name (("ttrace"));
1040 ourstatus
->value
.execd_pathname
[tts
.tts_u
.tts_exec
.tts_pathlen
] = 0;
1042 /* At this point, all inserted breakpoints are gone. Doing this
1043 as soon as we detect an exec prevents the badness of deleting
1044 a breakpoint writing the current "shadow contents" to lift
1045 the bp. That shadow is NOT valid after an exec. */
1046 mark_breakpoints_out ();
1050 store_waitstatus (ourstatus
, tts
.tts_u
.tts_exit
.tts_exitcode
);
1051 inf_ttrace_num_lwps
= 0;
1055 related_ptid
= ptid_build (tts
.tts_u
.tts_fork
.tts_fpid
,
1056 tts
.tts_u
.tts_fork
.tts_flwpid
, 0);
1058 ourstatus
->kind
= TARGET_WAITKIND_FORKED
;
1059 ourstatus
->value
.related_pid
= related_ptid
;
1061 /* Make sure the other end of the fork is stopped too. */
1062 if (ttrace_wait (tts
.tts_u
.tts_fork
.tts_fpid
,
1063 tts
.tts_u
.tts_fork
.tts_flwpid
,
1064 TTRACE_WAITOK
, &tts
, sizeof tts
) == -1)
1065 perror_with_name (("ttrace_wait"));
1067 gdb_assert (tts
.tts_event
== TTEVT_FORK
);
1068 if (tts
.tts_u
.tts_fork
.tts_isparent
)
1070 related_ptid
= ptid_build (tts
.tts_u
.tts_fork
.tts_fpid
,
1071 tts
.tts_u
.tts_fork
.tts_flwpid
, 0);
1072 ptid
= ptid_build (tts
.tts_pid
, tts
.tts_lwpid
, 0);
1073 ourstatus
->value
.related_pid
= related_ptid
;
1078 gdb_assert (!tts
.tts_u
.tts_fork
.tts_isparent
);
1080 related_ptid
= ptid_build (tts
.tts_u
.tts_fork
.tts_fpid
,
1081 tts
.tts_u
.tts_fork
.tts_flwpid
, 0);
1083 ourstatus
->kind
= TARGET_WAITKIND_VFORKED
;
1084 ourstatus
->value
.related_pid
= related_ptid
;
1086 /* HACK: To avoid touching the parent during the vfork, switch
1088 inferior_ptid
= ptid
;
1091 case TTEVT_LWP_CREATE
:
1092 lwpid
= tts
.tts_u
.tts_thread
.tts_target_lwpid
;
1093 ptid
= ptid_build (tts
.tts_pid
, lwpid
, 0);
1094 ti
= add_thread (ptid
);
1096 xmalloc (sizeof (struct inf_ttrace_private_thread_info
));
1097 memset (ti
->private, 0,
1098 sizeof (struct inf_ttrace_private_thread_info
));
1099 inf_ttrace_num_lwps
++;
1100 ptid
= ptid_build (tts
.tts_pid
, tts
.tts_lwpid
, 0);
1101 /* Let the lwp_create-caller thread continue. */
1102 ttrace (TT_LWP_CONTINUE
, ptid_get_pid (ptid
),
1103 ptid_get_lwp (ptid
), TT_NOPC
, 0, 0);
1104 /* Return without stopping the whole process. */
1105 ourstatus
->kind
= TARGET_WAITKIND_IGNORE
;
1108 case TTEVT_LWP_EXIT
:
1109 if (print_thread_events
)
1110 printf_unfiltered (_("[%s exited]\n"), target_pid_to_str (ptid
));
1111 ti
= find_thread_ptid (ptid
);
1112 gdb_assert (ti
!= NULL
);
1113 ((struct inf_ttrace_private_thread_info
*)ti
->private)->dying
= 1;
1114 inf_ttrace_num_lwps
--;
1115 /* Let the thread really exit. */
1116 ttrace (TT_LWP_CONTINUE
, ptid_get_pid (ptid
),
1117 ptid_get_lwp (ptid
), TT_NOPC
, 0, 0);
1118 /* Return without stopping the whole process. */
1119 ourstatus
->kind
= TARGET_WAITKIND_IGNORE
;
1122 case TTEVT_LWP_TERMINATE
:
1123 lwpid
= tts
.tts_u
.tts_thread
.tts_target_lwpid
;
1124 ptid
= ptid_build (tts
.tts_pid
, lwpid
, 0);
1125 if (print_thread_events
)
1126 printf_unfiltered(_("[%s has been terminated]\n"),
1127 target_pid_to_str (ptid
));
1128 ti
= find_thread_ptid (ptid
);
1129 gdb_assert (ti
!= NULL
);
1130 ((struct inf_ttrace_private_thread_info
*)ti
->private)->dying
= 1;
1131 inf_ttrace_num_lwps
--;
1133 /* Resume the lwp_terminate-caller thread. */
1134 ptid
= ptid_build (tts
.tts_pid
, tts
.tts_lwpid
, 0);
1135 ttrace (TT_LWP_CONTINUE
, ptid_get_pid (ptid
),
1136 ptid_get_lwp (ptid
), TT_NOPC
, 0, 0);
1137 /* Return without stopping the whole process. */
1138 ourstatus
->kind
= TARGET_WAITKIND_IGNORE
;
1142 ourstatus
->kind
= TARGET_WAITKIND_STOPPED
;
1143 ourstatus
->value
.sig
=
1144 gdb_signal_from_host (tts
.tts_u
.tts_signal
.tts_signo
);
1147 case TTEVT_SYSCALL_ENTRY
:
1148 gdb_assert (inf_ttrace_reenable_page_protections
== 0);
1149 inf_ttrace_num_lwps_in_syscall
++;
1150 if (inf_ttrace_num_lwps_in_syscall
== 1)
1152 /* A thread has just entered a system call. Disable any
1153 page protections as the kernel can't deal with them. */
1154 inf_ttrace_disable_page_protections (tts
.tts_pid
);
1156 ourstatus
->kind
= TARGET_WAITKIND_SYSCALL_ENTRY
;
1157 ourstatus
->value
.syscall_number
= tts
.tts_scno
;
1160 case TTEVT_SYSCALL_RETURN
:
1161 if (inf_ttrace_num_lwps_in_syscall
> 0)
1163 /* If the last thread has just left the system call, this
1164 would be a logical place to re-enable the page
1165 protections, but that doesn't work. We can't re-enable
1166 them until we've done another wait. */
1167 inf_ttrace_reenable_page_protections
=
1168 (inf_ttrace_num_lwps_in_syscall
== 1);
1169 inf_ttrace_num_lwps_in_syscall
--;
1171 ourstatus
->kind
= TARGET_WAITKIND_SYSCALL_RETURN
;
1172 ourstatus
->value
.syscall_number
= tts
.tts_scno
;
1176 gdb_assert (!"Unexpected ttrace event");
1180 /* Make sure all threads within the process are stopped. */
1181 if (ttrace (TT_PROC_STOP
, tts
.tts_pid
, 0, 0, 0, 0) == -1)
1182 perror_with_name (("ttrace"));
1184 /* Now that the whole process is stopped, check if any dying thread
1185 is really dead by now. If a dying thread is still alive, it will
1186 be stopped too, and will still show up in `info threads', tagged
1187 with "(Exiting)". We could make `info threads' prune dead
1188 threads instead via inf_ttrace_thread_alive, but doing this here
1189 has the advantage that a frontend is notificed sooner of thread
1190 exits. Note that a dying lwp is still alive, it still has to be
1191 resumed, like any other lwp. */
1192 iterate_over_threads (inf_ttrace_delete_dead_threads_callback
, NULL
);
1197 /* Transfer LEN bytes from ADDR in the inferior's memory into READBUF,
1198 and transfer LEN bytes from WRITEBUF into the inferior's memory at
1199 ADDR. Either READBUF or WRITEBUF may be null, in which case the
1200 corresponding transfer doesn't happen. Return the number of bytes
1201 actually transferred (which may be zero if an error occurs). */
1204 inf_ttrace_xfer_memory (CORE_ADDR addr
, ULONGEST len
,
1205 void *readbuf
, const void *writebuf
)
1207 pid_t pid
= ptid_get_pid (inferior_ptid
);
1209 /* HP-UX treats text space and data space differently. GDB however,
1210 doesn't really know the difference. Therefore we try both. Try
1211 text space before data space though because when we're writing
1212 into text space the instruction cache might need to be flushed. */
1215 && ttrace (TT_PROC_RDTEXT
, pid
, 0, addr
, len
, (uintptr_t)readbuf
) == -1
1216 && ttrace (TT_PROC_RDDATA
, pid
, 0, addr
, len
, (uintptr_t)readbuf
) == -1)
1220 && ttrace (TT_PROC_WRTEXT
, pid
, 0, addr
, len
, (uintptr_t)writebuf
) == -1
1221 && ttrace (TT_PROC_WRDATA
, pid
, 0, addr
, len
, (uintptr_t)writebuf
) == -1)
1227 static enum target_xfer_status
1228 inf_ttrace_xfer_partial (struct target_ops
*ops
, enum target_object object
,
1229 const char *annex
, gdb_byte
*readbuf
,
1230 const gdb_byte
*writebuf
,
1231 ULONGEST offset
, ULONGEST len
, ULONGEST
*xfered_len
)
1235 case TARGET_OBJECT_MEMORY
:
1237 LONGEST val
= inf_ttrace_xfer_memory (offset
, len
, readbuf
, writebuf
);
1240 return TARGET_XFER_EOF
;
1243 *xfered_len
= (ULONGEST
) val
;
1244 return TARGET_XFER_OK
;
1248 case TARGET_OBJECT_UNWIND_TABLE
:
1249 return TARGET_XFER_E_IO
;
1251 case TARGET_OBJECT_AUXV
:
1252 return TARGET_XFER_E_IO
;
1254 case TARGET_OBJECT_WCOOKIE
:
1255 return TARGET_XFER_E_IO
;
1258 return TARGET_XFER_E_IO
;
1262 /* Print status information about what we're accessing. */
1265 inf_ttrace_files_info (struct target_ops
*ignore
)
1267 struct inferior
*inf
= current_inferior ();
1268 printf_filtered (_("\tUsing the running image of %s %s.\n"),
1269 inf
->attach_flag
? "attached" : "child",
1270 target_pid_to_str (inferior_ptid
));
1274 inf_ttrace_thread_alive (struct target_ops
*ops
, ptid_t ptid
)
1279 /* Return a string describing the state of the thread specified by
1283 inf_ttrace_extra_thread_info (struct thread_info
*info
)
1285 struct inf_ttrace_private_thread_info
* private =
1286 (struct inf_ttrace_private_thread_info
*) info
->private;
1288 if (private != NULL
&& private->dying
)
1295 inf_ttrace_pid_to_str (struct target_ops
*ops
, ptid_t ptid
)
1297 pid_t pid
= ptid_get_pid (ptid
);
1298 lwpid_t lwpid
= ptid_get_lwp (ptid
);
1299 static char buf
[128];
1302 xsnprintf (buf
, sizeof buf
, "process %ld",
1305 xsnprintf (buf
, sizeof buf
, "process %ld, lwp %ld",
1306 (long) pid
, (long) lwpid
);
1311 /* Implement the get_ada_task_ptid target_ops method. */
1314 inf_ttrace_get_ada_task_ptid (long lwp
, long thread
)
1316 return ptid_build (ptid_get_pid (inferior_ptid
), lwp
, 0);
1321 inf_ttrace_target (void)
1323 struct target_ops
*t
= inf_child_target ();
1325 t
->to_attach
= inf_ttrace_attach
;
1326 t
->to_detach
= inf_ttrace_detach
;
1327 t
->to_resume
= inf_ttrace_resume
;
1328 t
->to_wait
= inf_ttrace_wait
;
1329 t
->to_files_info
= inf_ttrace_files_info
;
1330 t
->to_can_use_hw_breakpoint
= inf_ttrace_can_use_hw_breakpoint
;
1331 t
->to_insert_watchpoint
= inf_ttrace_insert_watchpoint
;
1332 t
->to_remove_watchpoint
= inf_ttrace_remove_watchpoint
;
1333 t
->to_stopped_by_watchpoint
= inf_ttrace_stopped_by_watchpoint
;
1334 t
->to_region_ok_for_hw_watchpoint
=
1335 inf_ttrace_region_ok_for_hw_watchpoint
;
1336 t
->to_kill
= inf_ttrace_kill
;
1337 t
->to_create_inferior
= inf_ttrace_create_inferior
;
1338 t
->to_follow_fork
= inf_ttrace_follow_fork
;
1339 t
->to_mourn_inferior
= inf_ttrace_mourn_inferior
;
1340 t
->to_thread_alive
= inf_ttrace_thread_alive
;
1341 t
->to_extra_thread_info
= inf_ttrace_extra_thread_info
;
1342 t
->to_pid_to_str
= inf_ttrace_pid_to_str
;
1343 t
->to_xfer_partial
= inf_ttrace_xfer_partial
;
1344 t
->to_get_ada_task_ptid
= inf_ttrace_get_ada_task_ptid
;
1351 /* Prevent warning from -Wmissing-prototypes. */
1352 void _initialize_inf_ttrace (void);
1355 _initialize_inf_ttrace (void)
1358 inf_ttrace_page_dict
.pagesize
= getpagesize();