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 <sys/ttrace.h>
36 #include "inf-child.h"
37 #include "inf-ttrace.h"
38 #include "common/filestuff.h"
42 /* HP-UX uses a threading model where each user-space thread
43 corresponds to a kernel thread. These kernel threads are called
44 lwps. The ttrace(2) interface gives us almost full control over
45 the threads, which makes it very easy to support them in GDB. We
46 identify the threads by process ID and lwp ID. The ttrace(2) also
47 provides us with a thread's user ID (in the `tts_user_tid' member
48 of `ttstate_t') but we don't use that (yet) as it isn't necessary
49 to uniquely label the thread. */
51 /* Number of active lwps. */
52 static int inf_ttrace_num_lwps
;
55 /* On HP-UX versions that have the ttrace(2) system call, we can
56 implement "hardware" watchpoints by fiddling with the protection of
57 pages in the address space that contain the variable being watched.
58 In order to implement this, we keep a dictionary of pages for which
59 we have changed the protection. */
61 struct inf_ttrace_page
63 CORE_ADDR addr
; /* Page address. */
64 int prot
; /* Protection. */
65 int refcount
; /* Reference count. */
66 struct inf_ttrace_page
*next
;
67 struct inf_ttrace_page
*prev
;
70 struct inf_ttrace_page_dict
72 struct inf_ttrace_page buckets
[128];
73 int pagesize
; /* Page size. */
74 int count
; /* Number of pages in this dictionary. */
75 } inf_ttrace_page_dict
;
77 struct inf_ttrace_private_thread_info
82 /* Number of lwps that are currently in a system call. */
83 static int inf_ttrace_num_lwps_in_syscall
;
85 /* Flag to indicate whether we should re-enable page protections after
87 static int inf_ttrace_reenable_page_protections
;
89 /* Enable system call events for process PID. */
92 inf_ttrace_enable_syscall_events (pid_t pid
)
97 gdb_assert (inf_ttrace_num_lwps_in_syscall
== 0);
99 if (ttrace (TT_PROC_GET_EVENT_MASK
, pid
, 0,
100 (uintptr_t)&tte
, sizeof tte
, 0) == -1)
101 perror_with_name (("ttrace"));
103 tte
.tte_events
|= (TTEVT_SYSCALL_ENTRY
| TTEVT_SYSCALL_RETURN
);
105 if (ttrace (TT_PROC_SET_EVENT_MASK
, pid
, 0,
106 (uintptr_t)&tte
, sizeof tte
, 0) == -1)
107 perror_with_name (("ttrace"));
109 if (ttrace (TT_PROC_GET_FIRST_LWP_STATE
, pid
, 0,
110 (uintptr_t)&tts
, sizeof tts
, 0) == -1)
111 perror_with_name (("ttrace"));
113 if (tts
.tts_flags
& TTS_INSYSCALL
)
114 inf_ttrace_num_lwps_in_syscall
++;
116 /* FIXME: Handle multiple threads. */
119 /* Disable system call events for process PID. */
122 inf_ttrace_disable_syscall_events (pid_t pid
)
126 gdb_assert (inf_ttrace_page_dict
.count
== 0);
128 if (ttrace (TT_PROC_GET_EVENT_MASK
, pid
, 0,
129 (uintptr_t)&tte
, sizeof tte
, 0) == -1)
130 perror_with_name (("ttrace"));
132 tte
.tte_events
&= ~(TTEVT_SYSCALL_ENTRY
| TTEVT_SYSCALL_RETURN
);
134 if (ttrace (TT_PROC_SET_EVENT_MASK
, pid
, 0,
135 (uintptr_t)&tte
, sizeof tte
, 0) == -1)
136 perror_with_name (("ttrace"));
138 inf_ttrace_num_lwps_in_syscall
= 0;
141 /* Get information about the page at address ADDR for process PID from
144 static struct inf_ttrace_page
*
145 inf_ttrace_get_page (pid_t pid
, CORE_ADDR addr
)
147 const int num_buckets
= ARRAY_SIZE (inf_ttrace_page_dict
.buckets
);
148 const int pagesize
= inf_ttrace_page_dict
.pagesize
;
150 struct inf_ttrace_page
*page
;
152 bucket
= (addr
/ pagesize
) % num_buckets
;
153 page
= &inf_ttrace_page_dict
.buckets
[bucket
];
156 if (page
->addr
== addr
)
165 /* Add the page at address ADDR for process PID to the dictionary. */
167 static struct inf_ttrace_page
*
168 inf_ttrace_add_page (pid_t pid
, CORE_ADDR addr
)
170 const int num_buckets
= ARRAY_SIZE (inf_ttrace_page_dict
.buckets
);
171 const int pagesize
= inf_ttrace_page_dict
.pagesize
;
173 struct inf_ttrace_page
*page
;
174 struct inf_ttrace_page
*prev
= NULL
;
176 bucket
= (addr
/ pagesize
) % num_buckets
;
177 page
= &inf_ttrace_page_dict
.buckets
[bucket
];
180 if (page
->addr
== addr
)
191 if (ttrace (TT_PROC_GET_MPROTECT
, pid
, 0,
192 addr
, 0, (uintptr_t)&prot
) == -1)
193 perror_with_name (("ttrace"));
195 page
= XNEW (struct inf_ttrace_page
);
204 inf_ttrace_page_dict
.count
++;
205 if (inf_ttrace_page_dict
.count
== 1)
206 inf_ttrace_enable_syscall_events (pid
);
208 if (inf_ttrace_num_lwps_in_syscall
== 0)
210 if (ttrace (TT_PROC_SET_MPROTECT
, pid
, 0,
211 addr
, pagesize
, prot
& ~PROT_WRITE
) == -1)
212 perror_with_name (("ttrace"));
219 /* Insert the page at address ADDR of process PID to the dictionary. */
222 inf_ttrace_insert_page (pid_t pid
, CORE_ADDR addr
)
224 struct inf_ttrace_page
*page
;
226 page
= inf_ttrace_get_page (pid
, addr
);
228 page
= inf_ttrace_add_page (pid
, addr
);
233 /* Remove the page at address ADDR of process PID from the dictionary. */
236 inf_ttrace_remove_page (pid_t pid
, CORE_ADDR addr
)
238 const int pagesize
= inf_ttrace_page_dict
.pagesize
;
239 struct inf_ttrace_page
*page
;
241 page
= inf_ttrace_get_page (pid
, addr
);
244 gdb_assert (page
->refcount
>= 0);
246 if (page
->refcount
== 0)
248 if (inf_ttrace_num_lwps_in_syscall
== 0)
250 if (ttrace (TT_PROC_SET_MPROTECT
, pid
, 0,
251 addr
, pagesize
, page
->prot
) == -1)
252 perror_with_name (("ttrace"));
255 inf_ttrace_page_dict
.count
--;
256 if (inf_ttrace_page_dict
.count
== 0)
257 inf_ttrace_disable_syscall_events (pid
);
259 page
->prev
->next
= page
->next
;
261 page
->next
->prev
= page
->prev
;
267 /* Mask the bits in PROT from the page protections that are currently
268 in the dictionary for process PID. */
271 inf_ttrace_mask_page_protections (pid_t pid
, int prot
)
273 const int num_buckets
= ARRAY_SIZE (inf_ttrace_page_dict
.buckets
);
274 const int pagesize
= inf_ttrace_page_dict
.pagesize
;
277 for (bucket
= 0; bucket
< num_buckets
; bucket
++)
279 struct inf_ttrace_page
*page
;
281 page
= inf_ttrace_page_dict
.buckets
[bucket
].next
;
284 if (ttrace (TT_PROC_SET_MPROTECT
, pid
, 0,
285 page
->addr
, pagesize
, page
->prot
& ~prot
) == -1)
286 perror_with_name (("ttrace"));
293 /* Write-protect the pages in the dictionary for process PID. */
296 inf_ttrace_enable_page_protections (pid_t pid
)
298 inf_ttrace_mask_page_protections (pid
, PROT_WRITE
);
301 /* Restore the protection of the pages in the dictionary for process
305 inf_ttrace_disable_page_protections (pid_t pid
)
307 inf_ttrace_mask_page_protections (pid
, 0);
310 /* Insert a "hardware" watchpoint for LEN bytes at address ADDR of
314 inf_ttrace_insert_watchpoint (struct target_ops
*self
,
315 CORE_ADDR addr
, int len
, int type
,
316 struct expression
*cond
)
318 const int pagesize
= inf_ttrace_page_dict
.pagesize
;
319 pid_t pid
= ptid_get_pid (inferior_ptid
);
324 gdb_assert (type
== hw_write
);
326 page_addr
= (addr
/ pagesize
) * pagesize
;
327 num_pages
= (len
+ pagesize
- 1) / pagesize
;
329 for (page
= 0; page
< num_pages
; page
++, page_addr
+= pagesize
)
330 inf_ttrace_insert_page (pid
, page_addr
);
335 /* Remove a "hardware" watchpoint for LEN bytes at address ADDR of
339 inf_ttrace_remove_watchpoint (struct target_ops
*self
,
340 CORE_ADDR addr
, int len
, int type
,
341 struct expression
*cond
)
343 const int pagesize
= inf_ttrace_page_dict
.pagesize
;
344 pid_t pid
= ptid_get_pid (inferior_ptid
);
349 gdb_assert (type
== hw_write
);
351 page_addr
= (addr
/ pagesize
) * pagesize
;
352 num_pages
= (len
+ pagesize
- 1) / pagesize
;
354 for (page
= 0; page
< num_pages
; page
++, page_addr
+= pagesize
)
355 inf_ttrace_remove_page (pid
, page_addr
);
361 inf_ttrace_can_use_hw_breakpoint (struct target_ops
*self
,
362 int type
, int len
, int ot
)
364 return (type
== bp_hardware_watchpoint
);
368 inf_ttrace_region_ok_for_hw_watchpoint (struct target_ops
*self
,
369 CORE_ADDR addr
, int len
)
374 /* Return non-zero if the current inferior was (potentially) stopped
375 by hitting a "hardware" watchpoint. */
378 inf_ttrace_stopped_by_watchpoint (struct target_ops
*ops
)
380 pid_t pid
= ptid_get_pid (inferior_ptid
);
381 lwpid_t lwpid
= ptid_get_lwp (inferior_ptid
);
384 if (inf_ttrace_page_dict
.count
> 0)
386 if (ttrace (TT_LWP_GET_STATE
, pid
, lwpid
,
387 (uintptr_t)&tts
, sizeof tts
, 0) == -1)
388 perror_with_name (("ttrace"));
390 if (tts
.tts_event
== TTEVT_SIGNAL
391 && tts
.tts_u
.tts_signal
.tts_signo
== SIGBUS
)
393 const int pagesize
= inf_ttrace_page_dict
.pagesize
;
394 void *addr
= tts
.tts_u
.tts_signal
.tts_siginfo
.si_addr
;
395 CORE_ADDR page_addr
= ((uintptr_t)addr
/ pagesize
) * pagesize
;
397 if (inf_ttrace_get_page (pid
, page_addr
))
406 /* Target hook for follow_fork. On entry and at return inferior_ptid
407 is the ptid of the followed inferior. */
410 inf_ttrace_follow_fork (struct target_ops
*ops
, int follow_child
,
413 struct thread_info
*tp
= inferior_thread ();
415 gdb_assert (tp
->pending_follow
.kind
== TARGET_WAITKIND_FORKED
416 || tp
->pending_follow
.kind
== TARGET_WAITKIND_VFORKED
);
420 struct thread_info
*ti
;
422 /* The child will start out single-threaded. */
423 inf_ttrace_num_lwps
= 1;
424 inf_ttrace_num_lwps_in_syscall
= 0;
426 ti
= inferior_thread ();
428 xmalloc (sizeof (struct inf_ttrace_private_thread_info
));
429 memset (ti
->private, 0,
430 sizeof (struct inf_ttrace_private_thread_info
));
436 /* Following parent. Detach child now. */
437 child_pid
= ptid_get_pid (tp
->pending_follow
.value
.related_pid
);
438 if (ttrace (TT_PROC_DETACH
, child_pid
, 0, 0, 0, 0) == -1)
439 perror_with_name (("ttrace"));
446 /* File descriptors for pipes used as semaphores during initial
447 startup of an inferior. */
448 static int inf_ttrace_pfd1
[2];
449 static int inf_ttrace_pfd2
[2];
452 do_cleanup_pfds (void *dummy
)
454 close (inf_ttrace_pfd1
[0]);
455 close (inf_ttrace_pfd1
[1]);
456 close (inf_ttrace_pfd2
[0]);
457 close (inf_ttrace_pfd2
[1]);
459 unmark_fd_no_cloexec (inf_ttrace_pfd1
[0]);
460 unmark_fd_no_cloexec (inf_ttrace_pfd1
[1]);
461 unmark_fd_no_cloexec (inf_ttrace_pfd2
[0]);
462 unmark_fd_no_cloexec (inf_ttrace_pfd2
[1]);
466 inf_ttrace_prepare (void)
468 if (pipe (inf_ttrace_pfd1
) == -1)
469 perror_with_name (("pipe"));
471 if (pipe (inf_ttrace_pfd2
) == -1)
473 close (inf_ttrace_pfd1
[0]);
474 close (inf_ttrace_pfd2
[0]);
475 perror_with_name (("pipe"));
478 mark_fd_no_cloexec (inf_ttrace_pfd1
[0]);
479 mark_fd_no_cloexec (inf_ttrace_pfd1
[1]);
480 mark_fd_no_cloexec (inf_ttrace_pfd2
[0]);
481 mark_fd_no_cloexec (inf_ttrace_pfd2
[1]);
484 /* Prepare to be traced. */
489 struct cleanup
*old_chain
= make_cleanup (do_cleanup_pfds
, 0);
492 /* "Trace me, Dr. Memory!" */
493 if (ttrace (TT_PROC_SETTRC
, 0, 0, 0, TT_VERSION
, 0) == -1)
494 perror_with_name (("ttrace"));
496 /* Tell our parent that we are ready to be traced. */
497 if (write (inf_ttrace_pfd1
[1], &c
, sizeof c
) != sizeof c
)
498 perror_with_name (("write"));
500 /* Wait until our parent has set the initial event mask. */
501 if (read (inf_ttrace_pfd2
[0], &c
, sizeof c
) != sizeof c
)
502 perror_with_name (("read"));
504 do_cleanups (old_chain
);
507 /* Start tracing PID. */
510 inf_ttrace_him (struct target_ops
*ops
, int pid
)
512 struct cleanup
*old_chain
= make_cleanup (do_cleanup_pfds
, 0);
516 /* Wait until our child is ready to be traced. */
517 if (read (inf_ttrace_pfd1
[0], &c
, sizeof c
) != sizeof c
)
518 perror_with_name (("read"));
520 /* Set the initial event mask. */
521 memset (&tte
, 0, sizeof (tte
));
522 tte
.tte_events
|= TTEVT_EXEC
| TTEVT_EXIT
| TTEVT_FORK
| TTEVT_VFORK
;
523 tte
.tte_events
|= TTEVT_LWP_CREATE
| TTEVT_LWP_EXIT
| TTEVT_LWP_TERMINATE
;
524 #ifdef TTEVT_BPT_SSTEP
525 tte
.tte_events
|= TTEVT_BPT_SSTEP
;
527 tte
.tte_opts
|= TTEO_PROC_INHERIT
;
528 if (ttrace (TT_PROC_SET_EVENT_MASK
, pid
, 0,
529 (uintptr_t)&tte
, sizeof tte
, 0) == -1)
530 perror_with_name (("ttrace"));
532 /* Tell our child that we have set the initial event mask. */
533 if (write (inf_ttrace_pfd2
[1], &c
, sizeof c
) != sizeof c
)
534 perror_with_name (("write"));
536 do_cleanups (old_chain
);
538 if (!target_is_pushed (ops
))
541 startup_inferior (START_INFERIOR_TRAPS_EXPECTED
);
543 /* On some targets, there must be some explicit actions taken after
544 the inferior has been started up. */
545 target_post_startup_inferior (pid_to_ptid (pid
));
549 inf_ttrace_create_inferior (struct target_ops
*ops
, char *exec_file
,
550 char *allargs
, char **env
, int from_tty
)
554 gdb_assert (inf_ttrace_num_lwps
== 0);
555 gdb_assert (inf_ttrace_num_lwps_in_syscall
== 0);
556 gdb_assert (inf_ttrace_page_dict
.count
== 0);
557 gdb_assert (inf_ttrace_reenable_page_protections
== 0);
559 pid
= fork_inferior (exec_file
, allargs
, env
, inf_ttrace_me
, NULL
,
560 inf_ttrace_prepare
, NULL
, NULL
);
562 inf_ttrace_him (ops
, pid
);
566 inf_ttrace_mourn_inferior (struct target_ops
*ops
)
568 const int num_buckets
= ARRAY_SIZE (inf_ttrace_page_dict
.buckets
);
571 inf_ttrace_num_lwps
= 0;
572 inf_ttrace_num_lwps_in_syscall
= 0;
574 for (bucket
= 0; bucket
< num_buckets
; bucket
++)
576 struct inf_ttrace_page
*page
;
577 struct inf_ttrace_page
*next
;
579 page
= inf_ttrace_page_dict
.buckets
[bucket
].next
;
587 inf_ttrace_page_dict
.count
= 0;
589 inf_child_mourn_inferior (ops
);
592 /* Assuming we just attached the debugger to a new inferior, create
593 a new thread_info structure for each thread, and add it to our
597 inf_ttrace_create_threads_after_attach (int pid
)
602 struct thread_info
*ti
;
604 status
= ttrace (TT_PROC_GET_FIRST_LWP_STATE
, pid
, 0,
605 (uintptr_t) &tts
, sizeof (ttstate_t
), 0);
607 perror_with_name (_("TT_PROC_GET_FIRST_LWP_STATE ttrace call failed"));
608 gdb_assert (tts
.tts_pid
== pid
);
610 /* Add the stopped thread. */
611 ptid
= ptid_build (pid
, tts
.tts_lwpid
, 0);
612 ti
= add_thread (ptid
);
613 ti
->private = xzalloc (sizeof (struct inf_ttrace_private_thread_info
));
614 inf_ttrace_num_lwps
++;
616 /* We use the "first stopped thread" as the currently active thread. */
617 inferior_ptid
= ptid
;
619 /* Iterative over all the remaining threads. */
625 status
= ttrace (TT_PROC_GET_NEXT_LWP_STATE
, pid
, 0,
626 (uintptr_t) &tts
, sizeof (ttstate_t
), 0);
628 perror_with_name (_("TT_PROC_GET_NEXT_LWP_STATE ttrace call failed"));
630 break; /* End of list. */
632 ptid
= ptid_build (tts
.tts_pid
, tts
.tts_lwpid
, 0);
633 ti
= add_thread (ptid
);
634 ti
->private = xzalloc (sizeof (struct inf_ttrace_private_thread_info
));
635 inf_ttrace_num_lwps
++;
640 inf_ttrace_attach (struct target_ops
*ops
, const char *args
, int from_tty
)
645 struct inferior
*inf
;
647 pid
= parse_pid_to_attach (args
);
649 if (pid
== getpid ()) /* Trying to masturbate? */
650 error (_("I refuse to debug myself!"));
654 exec_file
= get_exec_file (0);
657 printf_unfiltered (_("Attaching to program: %s, %s\n"), exec_file
,
658 target_pid_to_str (pid_to_ptid (pid
)));
660 printf_unfiltered (_("Attaching to %s\n"),
661 target_pid_to_str (pid_to_ptid (pid
)));
663 gdb_flush (gdb_stdout
);
666 gdb_assert (inf_ttrace_num_lwps
== 0);
667 gdb_assert (inf_ttrace_num_lwps_in_syscall
== 0);
669 if (ttrace (TT_PROC_ATTACH
, pid
, 0, TT_KILL_ON_EXIT
, TT_VERSION
, 0) == -1)
670 perror_with_name (("ttrace"));
672 inf
= current_inferior ();
673 inferior_appeared (inf
, pid
);
674 inf
->attach_flag
= 1;
676 /* Set the initial event mask. */
677 memset (&tte
, 0, sizeof (tte
));
678 tte
.tte_events
|= TTEVT_EXEC
| TTEVT_EXIT
| TTEVT_FORK
| TTEVT_VFORK
;
679 tte
.tte_events
|= TTEVT_LWP_CREATE
| TTEVT_LWP_EXIT
| TTEVT_LWP_TERMINATE
;
680 #ifdef TTEVT_BPT_SSTEP
681 tte
.tte_events
|= TTEVT_BPT_SSTEP
;
683 tte
.tte_opts
|= TTEO_PROC_INHERIT
;
684 if (ttrace (TT_PROC_SET_EVENT_MASK
, pid
, 0,
685 (uintptr_t)&tte
, sizeof tte
, 0) == -1)
686 perror_with_name (("ttrace"));
688 if (!target_is_pushed (ops
))
691 inf_ttrace_create_threads_after_attach (pid
);
695 inf_ttrace_detach (struct target_ops
*ops
, const char *args
, int from_tty
)
697 pid_t pid
= ptid_get_pid (inferior_ptid
);
702 char *exec_file
= get_exec_file (0);
705 printf_unfiltered (_("Detaching from program: %s, %s\n"), exec_file
,
706 target_pid_to_str (pid_to_ptid (pid
)));
707 gdb_flush (gdb_stdout
);
712 /* ??? The HP-UX 11.0 ttrace(2) manual page doesn't mention that we
713 can pass a signal number here. Does this really work? */
714 if (ttrace (TT_PROC_DETACH
, pid
, 0, 0, sig
, 0) == -1)
715 perror_with_name (("ttrace"));
717 inf_ttrace_num_lwps
= 0;
718 inf_ttrace_num_lwps_in_syscall
= 0;
720 inferior_ptid
= null_ptid
;
721 detach_inferior (pid
);
723 inf_child_maybe_unpush_target (ops
);
727 inf_ttrace_kill (struct target_ops
*ops
)
729 pid_t pid
= ptid_get_pid (inferior_ptid
);
734 if (ttrace (TT_PROC_EXIT
, pid
, 0, 0, 0, 0) == -1)
735 perror_with_name (("ttrace"));
736 /* ??? Is it necessary to call ttrace_wait() here? */
738 target_mourn_inferior ();
741 /* Check is a dying thread is dead by now, and delete it from GDBs
742 thread list if so. */
744 inf_ttrace_delete_dead_threads_callback (struct thread_info
*info
, void *arg
)
747 struct inf_ttrace_private_thread_info
*p
;
749 if (is_exited (info
->ptid
))
752 lwpid
= ptid_get_lwp (info
->ptid
);
753 p
= (struct inf_ttrace_private_thread_info
*) info
->private;
755 /* Check if an lwp that was dying is still there or not. */
756 if (p
->dying
&& (kill (lwpid
, 0) == -1))
758 delete_thread (info
->ptid
);
763 /* Resume the lwp pointed to by INFO, with REQUEST, and pass it signal
767 inf_ttrace_resume_lwp (struct thread_info
*info
, ttreq_t request
, int sig
)
769 pid_t pid
= ptid_get_pid (info
->ptid
);
770 lwpid_t lwpid
= ptid_get_lwp (info
->ptid
);
772 if (ttrace (request
, pid
, lwpid
, TT_NOPC
, sig
, 0) == -1)
774 struct inf_ttrace_private_thread_info
*p
775 = (struct inf_ttrace_private_thread_info
*) info
->private;
776 if (p
->dying
&& errno
== EPROTO
)
777 /* This is expected, it means the dying lwp is really gone
778 by now. If ttrace had an event to inform the debugger
779 the lwp is really gone, this wouldn't be needed. */
780 delete_thread (info
->ptid
);
782 /* This was really unexpected. */
783 perror_with_name (("ttrace"));
787 /* Callback for iterate_over_threads. */
790 inf_ttrace_resume_callback (struct thread_info
*info
, void *arg
)
792 if (!ptid_equal (info
->ptid
, inferior_ptid
) && !is_exited (info
->ptid
))
793 inf_ttrace_resume_lwp (info
, TT_LWP_CONTINUE
, 0);
799 inf_ttrace_resume (struct target_ops
*ops
,
800 ptid_t ptid
, int step
, enum gdb_signal signal
)
803 ttreq_t request
= step
? TT_LWP_SINGLE
: TT_LWP_CONTINUE
;
804 int sig
= gdb_signal_to_host (signal
);
805 struct thread_info
*info
;
807 /* A specific PTID means `step only this process id'. */
808 resume_all
= (ptid_equal (ptid
, minus_one_ptid
));
810 /* If resuming all threads, it's the current thread that should be
811 handled specially. */
813 ptid
= inferior_ptid
;
815 info
= find_thread_ptid (ptid
);
816 inf_ttrace_resume_lwp (info
, request
, sig
);
819 /* Let all the other threads run too. */
820 iterate_over_threads (inf_ttrace_resume_callback
, NULL
);
824 inf_ttrace_wait (struct target_ops
*ops
,
825 ptid_t ptid
, struct target_waitstatus
*ourstatus
, int options
)
827 pid_t pid
= ptid_get_pid (ptid
);
828 lwpid_t lwpid
= ptid_get_lwp (ptid
);
830 struct thread_info
*ti
;
833 /* Until proven otherwise. */
834 ourstatus
->kind
= TARGET_WAITKIND_SPURIOUS
;
839 gdb_assert (pid
!= 0 || lwpid
== 0);
845 if (ttrace_wait (pid
, lwpid
, TTRACE_WAITOK
, &tts
, sizeof tts
) == -1)
846 perror_with_name (("ttrace_wait"));
848 clear_sigint_trap ();
850 while (tts
.tts_event
== TTEVT_NONE
);
852 /* Now that we've waited, we can re-enable the page protections. */
853 if (inf_ttrace_reenable_page_protections
)
855 gdb_assert (inf_ttrace_num_lwps_in_syscall
== 0);
856 inf_ttrace_enable_page_protections (tts
.tts_pid
);
857 inf_ttrace_reenable_page_protections
= 0;
860 ptid
= ptid_build (tts
.tts_pid
, tts
.tts_lwpid
, 0);
862 if (inf_ttrace_num_lwps
== 0)
864 struct thread_info
*ti
;
866 inf_ttrace_num_lwps
= 1;
868 /* This is the earliest we hear about the lwp member of
869 INFERIOR_PTID, after an attach or fork_inferior. */
870 gdb_assert (ptid_get_lwp (inferior_ptid
) == 0);
872 /* We haven't set the private member on the main thread yet. Do
874 ti
= find_thread_ptid (inferior_ptid
);
875 gdb_assert (ti
!= NULL
&& ti
->private == NULL
);
877 xmalloc (sizeof (struct inf_ttrace_private_thread_info
));
878 memset (ti
->private, 0,
879 sizeof (struct inf_ttrace_private_thread_info
));
881 /* Notify the core that this ptid changed. This changes
882 inferior_ptid as well. */
883 thread_change_ptid (inferior_ptid
, ptid
);
886 switch (tts
.tts_event
)
888 #ifdef TTEVT_BPT_SSTEP
889 case TTEVT_BPT_SSTEP
:
890 /* Make it look like a breakpoint. */
891 ourstatus
->kind
= TARGET_WAITKIND_STOPPED
;
892 ourstatus
->value
.sig
= GDB_SIGNAL_TRAP
;
897 ourstatus
->kind
= TARGET_WAITKIND_EXECD
;
898 ourstatus
->value
.execd_pathname
=
899 xmalloc (tts
.tts_u
.tts_exec
.tts_pathlen
+ 1);
900 if (ttrace (TT_PROC_GET_PATHNAME
, tts
.tts_pid
, 0,
901 (uintptr_t)ourstatus
->value
.execd_pathname
,
902 tts
.tts_u
.tts_exec
.tts_pathlen
, 0) == -1)
903 perror_with_name (("ttrace"));
904 ourstatus
->value
.execd_pathname
[tts
.tts_u
.tts_exec
.tts_pathlen
] = 0;
906 /* At this point, all inserted breakpoints are gone. Doing this
907 as soon as we detect an exec prevents the badness of deleting
908 a breakpoint writing the current "shadow contents" to lift
909 the bp. That shadow is NOT valid after an exec. */
910 mark_breakpoints_out ();
914 store_waitstatus (ourstatus
, tts
.tts_u
.tts_exit
.tts_exitcode
);
915 inf_ttrace_num_lwps
= 0;
919 related_ptid
= ptid_build (tts
.tts_u
.tts_fork
.tts_fpid
,
920 tts
.tts_u
.tts_fork
.tts_flwpid
, 0);
922 ourstatus
->kind
= TARGET_WAITKIND_FORKED
;
923 ourstatus
->value
.related_pid
= related_ptid
;
925 /* Make sure the other end of the fork is stopped too. */
926 if (ttrace_wait (tts
.tts_u
.tts_fork
.tts_fpid
,
927 tts
.tts_u
.tts_fork
.tts_flwpid
,
928 TTRACE_WAITOK
, &tts
, sizeof tts
) == -1)
929 perror_with_name (("ttrace_wait"));
931 gdb_assert (tts
.tts_event
== TTEVT_FORK
);
932 if (tts
.tts_u
.tts_fork
.tts_isparent
)
934 related_ptid
= ptid_build (tts
.tts_u
.tts_fork
.tts_fpid
,
935 tts
.tts_u
.tts_fork
.tts_flwpid
, 0);
936 ptid
= ptid_build (tts
.tts_pid
, tts
.tts_lwpid
, 0);
937 ourstatus
->value
.related_pid
= related_ptid
;
942 if (tts
.tts_u
.tts_fork
.tts_isparent
)
943 ourstatus
->kind
= TARGET_WAITKIND_VFORK_DONE
;
946 related_ptid
= ptid_build (tts
.tts_u
.tts_fork
.tts_fpid
,
947 tts
.tts_u
.tts_fork
.tts_flwpid
, 0);
949 ourstatus
->kind
= TARGET_WAITKIND_VFORKED
;
950 ourstatus
->value
.related_pid
= related_ptid
;
954 case TTEVT_LWP_CREATE
:
955 lwpid
= tts
.tts_u
.tts_thread
.tts_target_lwpid
;
956 ptid
= ptid_build (tts
.tts_pid
, lwpid
, 0);
957 ti
= add_thread (ptid
);
959 xmalloc (sizeof (struct inf_ttrace_private_thread_info
));
960 memset (ti
->private, 0,
961 sizeof (struct inf_ttrace_private_thread_info
));
962 inf_ttrace_num_lwps
++;
963 ptid
= ptid_build (tts
.tts_pid
, tts
.tts_lwpid
, 0);
964 /* Let the lwp_create-caller thread continue. */
965 ttrace (TT_LWP_CONTINUE
, ptid_get_pid (ptid
),
966 ptid_get_lwp (ptid
), TT_NOPC
, 0, 0);
967 /* Return without stopping the whole process. */
968 ourstatus
->kind
= TARGET_WAITKIND_IGNORE
;
972 if (print_thread_events
)
973 printf_unfiltered (_("[%s exited]\n"), target_pid_to_str (ptid
));
974 ti
= find_thread_ptid (ptid
);
975 gdb_assert (ti
!= NULL
);
976 ((struct inf_ttrace_private_thread_info
*)ti
->private)->dying
= 1;
977 inf_ttrace_num_lwps
--;
978 /* Let the thread really exit. */
979 ttrace (TT_LWP_CONTINUE
, ptid_get_pid (ptid
),
980 ptid_get_lwp (ptid
), TT_NOPC
, 0, 0);
981 /* Return without stopping the whole process. */
982 ourstatus
->kind
= TARGET_WAITKIND_IGNORE
;
985 case TTEVT_LWP_TERMINATE
:
986 lwpid
= tts
.tts_u
.tts_thread
.tts_target_lwpid
;
987 ptid
= ptid_build (tts
.tts_pid
, lwpid
, 0);
988 if (print_thread_events
)
989 printf_unfiltered(_("[%s has been terminated]\n"),
990 target_pid_to_str (ptid
));
991 ti
= find_thread_ptid (ptid
);
992 gdb_assert (ti
!= NULL
);
993 ((struct inf_ttrace_private_thread_info
*)ti
->private)->dying
= 1;
994 inf_ttrace_num_lwps
--;
996 /* Resume the lwp_terminate-caller thread. */
997 ptid
= ptid_build (tts
.tts_pid
, tts
.tts_lwpid
, 0);
998 ttrace (TT_LWP_CONTINUE
, ptid_get_pid (ptid
),
999 ptid_get_lwp (ptid
), TT_NOPC
, 0, 0);
1000 /* Return without stopping the whole process. */
1001 ourstatus
->kind
= TARGET_WAITKIND_IGNORE
;
1005 ourstatus
->kind
= TARGET_WAITKIND_STOPPED
;
1006 ourstatus
->value
.sig
=
1007 gdb_signal_from_host (tts
.tts_u
.tts_signal
.tts_signo
);
1010 case TTEVT_SYSCALL_ENTRY
:
1011 gdb_assert (inf_ttrace_reenable_page_protections
== 0);
1012 inf_ttrace_num_lwps_in_syscall
++;
1013 if (inf_ttrace_num_lwps_in_syscall
== 1)
1015 /* A thread has just entered a system call. Disable any
1016 page protections as the kernel can't deal with them. */
1017 inf_ttrace_disable_page_protections (tts
.tts_pid
);
1019 ourstatus
->kind
= TARGET_WAITKIND_SYSCALL_ENTRY
;
1020 ourstatus
->value
.syscall_number
= tts
.tts_scno
;
1023 case TTEVT_SYSCALL_RETURN
:
1024 if (inf_ttrace_num_lwps_in_syscall
> 0)
1026 /* If the last thread has just left the system call, this
1027 would be a logical place to re-enable the page
1028 protections, but that doesn't work. We can't re-enable
1029 them until we've done another wait. */
1030 inf_ttrace_reenable_page_protections
=
1031 (inf_ttrace_num_lwps_in_syscall
== 1);
1032 inf_ttrace_num_lwps_in_syscall
--;
1034 ourstatus
->kind
= TARGET_WAITKIND_SYSCALL_RETURN
;
1035 ourstatus
->value
.syscall_number
= tts
.tts_scno
;
1039 gdb_assert (!"Unexpected ttrace event");
1043 /* Make sure all threads within the process are stopped. */
1044 if (ttrace (TT_PROC_STOP
, tts
.tts_pid
, 0, 0, 0, 0) == -1)
1045 perror_with_name (("ttrace"));
1047 /* Now that the whole process is stopped, check if any dying thread
1048 is really dead by now. If a dying thread is still alive, it will
1049 be stopped too, and will still show up in `info threads', tagged
1050 with "(Exiting)". We could make `info threads' prune dead
1051 threads instead via inf_ttrace_thread_alive, but doing this here
1052 has the advantage that a frontend is notificed sooner of thread
1053 exits. Note that a dying lwp is still alive, it still has to be
1054 resumed, like any other lwp. */
1055 iterate_over_threads (inf_ttrace_delete_dead_threads_callback
, NULL
);
1060 /* Transfer LEN bytes from ADDR in the inferior's memory into READBUF,
1061 and transfer LEN bytes from WRITEBUF into the inferior's memory at
1062 ADDR. Either READBUF or WRITEBUF may be null, in which case the
1063 corresponding transfer doesn't happen. Return the number of bytes
1064 actually transferred (which may be zero if an error occurs). */
1067 inf_ttrace_xfer_memory (CORE_ADDR addr
, ULONGEST len
,
1068 void *readbuf
, const void *writebuf
)
1070 pid_t pid
= ptid_get_pid (inferior_ptid
);
1072 /* HP-UX treats text space and data space differently. GDB however,
1073 doesn't really know the difference. Therefore we try both. Try
1074 text space before data space though because when we're writing
1075 into text space the instruction cache might need to be flushed. */
1078 && ttrace (TT_PROC_RDTEXT
, pid
, 0, addr
, len
, (uintptr_t)readbuf
) == -1
1079 && ttrace (TT_PROC_RDDATA
, pid
, 0, addr
, len
, (uintptr_t)readbuf
) == -1)
1083 && ttrace (TT_PROC_WRTEXT
, pid
, 0, addr
, len
, (uintptr_t)writebuf
) == -1
1084 && ttrace (TT_PROC_WRDATA
, pid
, 0, addr
, len
, (uintptr_t)writebuf
) == -1)
1090 static enum target_xfer_status
1091 inf_ttrace_xfer_partial (struct target_ops
*ops
, enum target_object object
,
1092 const char *annex
, gdb_byte
*readbuf
,
1093 const gdb_byte
*writebuf
,
1094 ULONGEST offset
, ULONGEST len
, ULONGEST
*xfered_len
)
1098 case TARGET_OBJECT_MEMORY
:
1100 LONGEST val
= inf_ttrace_xfer_memory (offset
, len
, readbuf
, writebuf
);
1103 return TARGET_XFER_EOF
;
1106 *xfered_len
= (ULONGEST
) val
;
1107 return TARGET_XFER_OK
;
1111 case TARGET_OBJECT_UNWIND_TABLE
:
1112 return TARGET_XFER_E_IO
;
1114 case TARGET_OBJECT_AUXV
:
1115 return TARGET_XFER_E_IO
;
1117 case TARGET_OBJECT_WCOOKIE
:
1118 return TARGET_XFER_E_IO
;
1121 return TARGET_XFER_E_IO
;
1125 /* Print status information about what we're accessing. */
1128 inf_ttrace_files_info (struct target_ops
*ignore
)
1130 struct inferior
*inf
= current_inferior ();
1131 printf_filtered (_("\tUsing the running image of %s %s.\n"),
1132 inf
->attach_flag
? "attached" : "child",
1133 target_pid_to_str (inferior_ptid
));
1137 inf_ttrace_thread_alive (struct target_ops
*ops
, ptid_t ptid
)
1142 /* Return a string describing the state of the thread specified by
1146 inf_ttrace_extra_thread_info (struct target_ops
*self
,
1147 struct thread_info
*info
)
1149 struct inf_ttrace_private_thread_info
* private =
1150 (struct inf_ttrace_private_thread_info
*) info
->private;
1152 if (private != NULL
&& private->dying
)
1159 inf_ttrace_pid_to_str (struct target_ops
*ops
, ptid_t ptid
)
1161 pid_t pid
= ptid_get_pid (ptid
);
1162 lwpid_t lwpid
= ptid_get_lwp (ptid
);
1163 static char buf
[128];
1166 xsnprintf (buf
, sizeof buf
, "process %ld",
1169 xsnprintf (buf
, sizeof buf
, "process %ld, lwp %ld",
1170 (long) pid
, (long) lwpid
);
1175 /* Implement the get_ada_task_ptid target_ops method. */
1178 inf_ttrace_get_ada_task_ptid (struct target_ops
*self
, long lwp
, long thread
)
1180 return ptid_build (ptid_get_pid (inferior_ptid
), lwp
, 0);
1185 inf_ttrace_target (void)
1187 struct target_ops
*t
= inf_child_target ();
1189 t
->to_attach
= inf_ttrace_attach
;
1190 t
->to_detach
= inf_ttrace_detach
;
1191 t
->to_resume
= inf_ttrace_resume
;
1192 t
->to_wait
= inf_ttrace_wait
;
1193 t
->to_files_info
= inf_ttrace_files_info
;
1194 t
->to_can_use_hw_breakpoint
= inf_ttrace_can_use_hw_breakpoint
;
1195 t
->to_insert_watchpoint
= inf_ttrace_insert_watchpoint
;
1196 t
->to_remove_watchpoint
= inf_ttrace_remove_watchpoint
;
1197 t
->to_stopped_by_watchpoint
= inf_ttrace_stopped_by_watchpoint
;
1198 t
->to_region_ok_for_hw_watchpoint
=
1199 inf_ttrace_region_ok_for_hw_watchpoint
;
1200 t
->to_kill
= inf_ttrace_kill
;
1201 t
->to_create_inferior
= inf_ttrace_create_inferior
;
1202 t
->to_follow_fork
= inf_ttrace_follow_fork
;
1203 t
->to_mourn_inferior
= inf_ttrace_mourn_inferior
;
1204 t
->to_thread_alive
= inf_ttrace_thread_alive
;
1205 t
->to_extra_thread_info
= inf_ttrace_extra_thread_info
;
1206 t
->to_pid_to_str
= inf_ttrace_pid_to_str
;
1207 t
->to_xfer_partial
= inf_ttrace_xfer_partial
;
1208 t
->to_get_ada_task_ptid
= inf_ttrace_get_ada_task_ptid
;
1215 /* Prevent warning from -Wmissing-prototypes. */
1216 void _initialize_inf_ttrace (void);
1219 _initialize_inf_ttrace (void)
1222 inf_ttrace_page_dict
.pagesize
= getpagesize();