1 /* Low-level child interface to ttrace.
3 Copyright (C) 2004, 2005, 2006, 2007, 2008, 2009, 2010
4 Free Software Foundation, Inc.
6 This file is part of GDB.
8 This program is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 3 of the License, or
11 (at your option) any later version.
13 This program is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
18 You should have received a copy of the GNU General Public License
19 along with this program. If not, see <http://www.gnu.org/licenses/>. */
23 /* The ttrace(2) system call didn't exist before HP-UX 10.30. Don't
24 try to compile this code unless we have it. */
29 #include "gdbthread.h"
34 #include "gdb_assert.h"
35 #include "gdb_string.h"
37 #include <sys/ttrace.h>
40 #include "inf-child.h"
41 #include "inf-ttrace.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
= XMALLOC (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
)
319 const int pagesize
= inf_ttrace_page_dict
.pagesize
;
320 pid_t pid
= ptid_get_pid (inferior_ptid
);
325 gdb_assert (type
== hw_write
);
327 page_addr
= (addr
/ pagesize
) * pagesize
;
328 num_pages
= (len
+ pagesize
- 1) / pagesize
;
330 for (page
= 0; page
< num_pages
; page
++, page_addr
+= pagesize
)
331 inf_ttrace_insert_page (pid
, page_addr
);
336 /* Remove a "hardware" watchpoint for LEN bytes at address ADDR of
340 inf_ttrace_remove_watchpoint (CORE_ADDR addr
, int len
, int type
)
342 const int pagesize
= inf_ttrace_page_dict
.pagesize
;
343 pid_t pid
= ptid_get_pid (inferior_ptid
);
348 gdb_assert (type
== hw_write
);
350 page_addr
= (addr
/ pagesize
) * pagesize
;
351 num_pages
= (len
+ pagesize
- 1) / pagesize
;
353 for (page
= 0; page
< num_pages
; page
++, page_addr
+= pagesize
)
354 inf_ttrace_remove_page (pid
, page_addr
);
360 inf_ttrace_can_use_hw_breakpoint (int type
, int len
, int ot
)
362 return (type
== bp_hardware_watchpoint
);
366 inf_ttrace_region_ok_for_hw_watchpoint (CORE_ADDR addr
, int len
)
371 /* Return non-zero if the current inferior was (potentially) stopped
372 by hitting a "hardware" watchpoint. */
375 inf_ttrace_stopped_by_watchpoint (void)
377 pid_t pid
= ptid_get_pid (inferior_ptid
);
378 lwpid_t lwpid
= ptid_get_lwp (inferior_ptid
);
381 if (inf_ttrace_page_dict
.count
> 0)
383 if (ttrace (TT_LWP_GET_STATE
, pid
, lwpid
,
384 (uintptr_t)&tts
, sizeof tts
, 0) == -1)
385 perror_with_name (("ttrace"));
387 if (tts
.tts_event
== TTEVT_SIGNAL
388 && tts
.tts_u
.tts_signal
.tts_signo
== SIGBUS
)
390 const int pagesize
= inf_ttrace_page_dict
.pagesize
;
391 void *addr
= tts
.tts_u
.tts_signal
.tts_siginfo
.si_addr
;
392 CORE_ADDR page_addr
= ((uintptr_t)addr
/ pagesize
) * pagesize
;
394 if (inf_ttrace_get_page (pid
, page_addr
))
403 /* When tracking a vfork(2), we cannot detach from the parent until
404 after the child has called exec(3) or has exited. If we are still
405 attached to the parent, this variable will be set to the process ID
406 of the parent. Otherwise it will be set to zero. */
407 static pid_t inf_ttrace_vfork_ppid
= -1;
410 inf_ttrace_follow_fork (struct target_ops
*ops
, int follow_child
)
413 lwpid_t lwpid
, flwpid
;
415 struct thread_info
*tp
= inferior_thread ();
417 gdb_assert (tp
->pending_follow
.kind
== TARGET_WAITKIND_FORKED
418 || tp
->pending_follow
.kind
== TARGET_WAITKIND_VFORKED
);
420 pid
= ptid_get_pid (inferior_ptid
);
421 lwpid
= ptid_get_lwp (inferior_ptid
);
423 /* Get all important details that core GDB doesn't (and shouldn't)
425 if (ttrace (TT_LWP_GET_STATE
, pid
, lwpid
,
426 (uintptr_t)&tts
, sizeof tts
, 0) == -1)
427 perror_with_name (("ttrace"));
429 gdb_assert (tts
.tts_event
== TTEVT_FORK
|| tts
.tts_event
== TTEVT_VFORK
);
431 if (tts
.tts_u
.tts_fork
.tts_isparent
)
434 lwpid
= tts
.tts_lwpid
;
435 fpid
= tts
.tts_u
.tts_fork
.tts_fpid
;
436 flwpid
= tts
.tts_u
.tts_fork
.tts_flwpid
;
440 pid
= tts
.tts_u
.tts_fork
.tts_fpid
;
441 lwpid
= tts
.tts_u
.tts_fork
.tts_flwpid
;
443 flwpid
= tts
.tts_lwpid
;
448 struct inferior
*inf
;
449 struct inferior
*parent_inf
;
451 parent_inf
= find_inferior_pid (pid
);
453 inferior_ptid
= ptid_build (fpid
, flwpid
, 0);
454 inf
= add_inferior (fpid
);
455 inf
->attach_flag
= parent_inf
->attach_flag
;
456 inf
->pspace
= parent_inf
->pspace
;
457 inf
->aspace
= parent_inf
->aspace
;
458 copy_terminal_info (inf
, parent_inf
);
459 detach_breakpoints (pid
);
461 target_terminal_ours ();
462 fprintf_unfiltered (gdb_stdlog
, _("\
463 Attaching after fork to child process %ld.\n"), (long)fpid
);
467 inferior_ptid
= ptid_build (pid
, lwpid
, 0);
468 detach_breakpoints (fpid
);
470 target_terminal_ours ();
471 fprintf_unfiltered (gdb_stdlog
, _("\
472 Detaching after fork from child process %ld.\n"), (long)fpid
);
475 if (tts
.tts_event
== TTEVT_VFORK
)
477 gdb_assert (!tts
.tts_u
.tts_fork
.tts_isparent
);
481 /* We can't detach from the parent yet. */
482 inf_ttrace_vfork_ppid
= pid
;
484 reattach_breakpoints (fpid
);
488 if (ttrace (TT_PROC_DETACH
, fpid
, 0, 0, 0, 0) == -1)
489 perror_with_name (("ttrace"));
491 /* Wait till we get the TTEVT_VFORK event in the parent.
492 This indicates that the child has called exec(3) or has
493 exited and that the parent is ready to be traced again. */
494 if (ttrace_wait (pid
, lwpid
, TTRACE_WAITOK
, &tts
, sizeof tts
) == -1)
495 perror_with_name (("ttrace_wait"));
496 gdb_assert (tts
.tts_event
== TTEVT_VFORK
);
497 gdb_assert (tts
.tts_u
.tts_fork
.tts_isparent
);
499 reattach_breakpoints (pid
);
504 gdb_assert (tts
.tts_u
.tts_fork
.tts_isparent
);
508 if (ttrace (TT_PROC_DETACH
, pid
, 0, 0, 0, 0) == -1)
509 perror_with_name (("ttrace"));
513 if (ttrace (TT_PROC_DETACH
, fpid
, 0, 0, 0, 0) == -1)
514 perror_with_name (("ttrace"));
520 struct thread_info
*ti
;
522 /* The child will start out single-threaded. */
523 inf_ttrace_num_lwps
= 1;
524 inf_ttrace_num_lwps_in_syscall
= 0;
527 delete_thread_silent (ptid_build (pid
, lwpid
, 0));
528 detach_inferior (pid
);
530 /* Add child thread. inferior_ptid was already set above. */
531 ti
= add_thread_silent (inferior_ptid
);
533 xmalloc (sizeof (struct inf_ttrace_private_thread_info
));
534 memset (ti
->private, 0,
535 sizeof (struct inf_ttrace_private_thread_info
));
542 /* File descriptors for pipes used as semaphores during initial
543 startup of an inferior. */
544 static int inf_ttrace_pfd1
[2];
545 static int inf_ttrace_pfd2
[2];
548 do_cleanup_pfds (void *dummy
)
550 close (inf_ttrace_pfd1
[0]);
551 close (inf_ttrace_pfd1
[1]);
552 close (inf_ttrace_pfd2
[0]);
553 close (inf_ttrace_pfd2
[1]);
557 inf_ttrace_prepare (void)
559 if (pipe (inf_ttrace_pfd1
) == -1)
560 perror_with_name (("pipe"));
562 if (pipe (inf_ttrace_pfd2
) == -1)
564 close (inf_ttrace_pfd1
[0]);
565 close (inf_ttrace_pfd2
[0]);
566 perror_with_name (("pipe"));
570 /* Prepare to be traced. */
575 struct cleanup
*old_chain
= make_cleanup (do_cleanup_pfds
, 0);
578 /* "Trace me, Dr. Memory!" */
579 if (ttrace (TT_PROC_SETTRC
, 0, 0, 0, TT_VERSION
, 0) == -1)
580 perror_with_name (("ttrace"));
582 /* Tell our parent that we are ready to be traced. */
583 if (write (inf_ttrace_pfd1
[1], &c
, sizeof c
) != sizeof c
)
584 perror_with_name (("write"));
586 /* Wait until our parent has set the initial event mask. */
587 if (read (inf_ttrace_pfd2
[0], &c
, sizeof c
) != sizeof c
)
588 perror_with_name (("read"));
590 do_cleanups (old_chain
);
593 /* Start tracing PID. */
596 inf_ttrace_him (struct target_ops
*ops
, int pid
)
598 struct cleanup
*old_chain
= make_cleanup (do_cleanup_pfds
, 0);
602 /* Wait until our child is ready to be traced. */
603 if (read (inf_ttrace_pfd1
[0], &c
, sizeof c
) != sizeof c
)
604 perror_with_name (("read"));
606 /* Set the initial event mask. */
607 memset (&tte
, 0, sizeof (tte
));
608 tte
.tte_events
|= TTEVT_EXEC
| TTEVT_EXIT
| TTEVT_FORK
| TTEVT_VFORK
;
609 tte
.tte_events
|= TTEVT_LWP_CREATE
| TTEVT_LWP_EXIT
| TTEVT_LWP_TERMINATE
;
610 #ifdef TTEVT_BPT_SSTEP
611 tte
.tte_events
|= TTEVT_BPT_SSTEP
;
613 tte
.tte_opts
|= TTEO_PROC_INHERIT
;
614 if (ttrace (TT_PROC_SET_EVENT_MASK
, pid
, 0,
615 (uintptr_t)&tte
, sizeof tte
, 0) == -1)
616 perror_with_name (("ttrace"));
618 /* Tell our child that we have set the initial event mask. */
619 if (write (inf_ttrace_pfd2
[1], &c
, sizeof c
) != sizeof c
)
620 perror_with_name (("write"));
622 do_cleanups (old_chain
);
626 /* On some targets, there must be some explicit synchronization
627 between the parent and child processes after the debugger forks,
628 and before the child execs the debuggee program. This call
629 basically gives permission for the child to exec. */
631 target_acknowledge_created_inferior (pid
);
633 /* START_INFERIOR_TRAPS_EXPECTED is defined in inferior.h, and will
634 be 1 or 2 depending on whether we're starting without or with a
636 startup_inferior (START_INFERIOR_TRAPS_EXPECTED
);
638 /* On some targets, there must be some explicit actions taken after
639 the inferior has been started up. */
640 target_post_startup_inferior (pid_to_ptid (pid
));
644 inf_ttrace_create_inferior (struct target_ops
*ops
, char *exec_file
,
645 char *allargs
, char **env
, int from_tty
)
649 gdb_assert (inf_ttrace_num_lwps
== 0);
650 gdb_assert (inf_ttrace_num_lwps_in_syscall
== 0);
651 gdb_assert (inf_ttrace_page_dict
.count
== 0);
652 gdb_assert (inf_ttrace_reenable_page_protections
== 0);
653 gdb_assert (inf_ttrace_vfork_ppid
== -1);
655 pid
= fork_inferior (exec_file
, allargs
, env
, inf_ttrace_me
, NULL
,
656 inf_ttrace_prepare
, NULL
);
658 inf_ttrace_him (ops
, pid
);
662 inf_ttrace_mourn_inferior (struct target_ops
*ops
)
664 const int num_buckets
= ARRAY_SIZE (inf_ttrace_page_dict
.buckets
);
667 inf_ttrace_num_lwps
= 0;
668 inf_ttrace_num_lwps_in_syscall
= 0;
670 for (bucket
= 0; bucket
< num_buckets
; bucket
++)
672 struct inf_ttrace_page
*page
;
673 struct inf_ttrace_page
*next
;
675 page
= inf_ttrace_page_dict
.buckets
[bucket
].next
;
683 inf_ttrace_page_dict
.count
= 0;
686 generic_mourn_inferior ();
690 inf_ttrace_attach (struct target_ops
*ops
, char *args
, int from_tty
)
696 struct inferior
*inf
;
699 error_no_arg (_("process-id to attach"));
702 pid
= strtol (args
, &dummy
, 0);
703 if (pid
== 0 && args
== dummy
)
704 error (_("Illegal process-id: %s."), args
);
706 if (pid
== getpid ()) /* Trying to masturbate? */
707 error (_("I refuse to debug myself!"));
711 exec_file
= get_exec_file (0);
714 printf_unfiltered (_("Attaching to program: %s, %s\n"), exec_file
,
715 target_pid_to_str (pid_to_ptid (pid
)));
717 printf_unfiltered (_("Attaching to %s\n"),
718 target_pid_to_str (pid_to_ptid (pid
)));
720 gdb_flush (gdb_stdout
);
723 gdb_assert (inf_ttrace_num_lwps
== 0);
724 gdb_assert (inf_ttrace_num_lwps_in_syscall
== 0);
725 gdb_assert (inf_ttrace_vfork_ppid
== -1);
727 if (ttrace (TT_PROC_ATTACH
, pid
, 0, TT_KILL_ON_EXIT
, TT_VERSION
, 0) == -1)
728 perror_with_name (("ttrace"));
730 inf
= current_inferior ();
731 inferior_appeared (inf
, pid
);
732 inf
->attach_flag
= 1;
734 /* Set the initial event mask. */
735 memset (&tte
, 0, sizeof (tte
));
736 tte
.tte_events
|= TTEVT_EXEC
| TTEVT_EXIT
| TTEVT_FORK
| TTEVT_VFORK
;
737 tte
.tte_events
|= TTEVT_LWP_CREATE
| TTEVT_LWP_EXIT
| TTEVT_LWP_TERMINATE
;
738 #ifdef TTEVT_BPT_SSTEP
739 tte
.tte_events
|= TTEVT_BPT_SSTEP
;
741 tte
.tte_opts
|= TTEO_PROC_INHERIT
;
742 if (ttrace (TT_PROC_SET_EVENT_MASK
, pid
, 0,
743 (uintptr_t)&tte
, sizeof tte
, 0) == -1)
744 perror_with_name (("ttrace"));
748 /* We'll bump inf_ttrace_num_lwps up and add the private data to the
749 thread as soon as we get to inf_ttrace_wait. At this point, we
750 don't have lwpid info yet. */
751 inferior_ptid
= pid_to_ptid (pid
);
752 add_thread_silent (inferior_ptid
);
756 inf_ttrace_detach (struct target_ops
*ops
, char *args
, int from_tty
)
758 pid_t pid
= ptid_get_pid (inferior_ptid
);
763 char *exec_file
= get_exec_file (0);
766 printf_unfiltered (_("Detaching from program: %s, %s\n"), exec_file
,
767 target_pid_to_str (pid_to_ptid (pid
)));
768 gdb_flush (gdb_stdout
);
773 /* ??? The HP-UX 11.0 ttrace(2) manual page doesn't mention that we
774 can pass a signal number here. Does this really work? */
775 if (ttrace (TT_PROC_DETACH
, pid
, 0, 0, sig
, 0) == -1)
776 perror_with_name (("ttrace"));
778 if (inf_ttrace_vfork_ppid
!= -1)
780 if (ttrace (TT_PROC_DETACH
, inf_ttrace_vfork_ppid
, 0, 0, 0, 0) == -1)
781 perror_with_name (("ttrace"));
782 inf_ttrace_vfork_ppid
= -1;
785 inf_ttrace_num_lwps
= 0;
786 inf_ttrace_num_lwps_in_syscall
= 0;
788 inferior_ptid
= null_ptid
;
789 detach_inferior (pid
);
795 inf_ttrace_kill (struct target_ops
*ops
)
797 pid_t pid
= ptid_get_pid (inferior_ptid
);
802 if (ttrace (TT_PROC_EXIT
, pid
, 0, 0, 0, 0) == -1)
803 perror_with_name (("ttrace"));
804 /* ??? Is it necessary to call ttrace_wait() here? */
806 if (inf_ttrace_vfork_ppid
!= -1)
808 if (ttrace (TT_PROC_DETACH
, inf_ttrace_vfork_ppid
, 0, 0, 0, 0) == -1)
809 perror_with_name (("ttrace"));
810 inf_ttrace_vfork_ppid
= -1;
813 target_mourn_inferior ();
816 /* Check is a dying thread is dead by now, and delete it from GDBs
817 thread list if so. */
819 inf_ttrace_delete_dead_threads_callback (struct thread_info
*info
, void *arg
)
822 struct inf_ttrace_private_thread_info
*p
;
824 if (is_exited (info
->ptid
))
827 lwpid
= ptid_get_lwp (info
->ptid
);
828 p
= (struct inf_ttrace_private_thread_info
*) info
->private;
830 /* Check if an lwp that was dying is still there or not. */
831 if (p
->dying
&& (kill (lwpid
, 0) == -1))
833 delete_thread (info
->ptid
);
838 /* Resume the lwp pointed to by INFO, with REQUEST, and pass it signal
842 inf_ttrace_resume_lwp (struct thread_info
*info
, ttreq_t request
, int sig
)
844 pid_t pid
= ptid_get_pid (info
->ptid
);
845 lwpid_t lwpid
= ptid_get_lwp (info
->ptid
);
847 if (ttrace (request
, pid
, lwpid
, TT_NOPC
, sig
, 0) == -1)
849 struct inf_ttrace_private_thread_info
*p
850 = (struct inf_ttrace_private_thread_info
*) info
->private;
851 if (p
->dying
&& errno
== EPROTO
)
852 /* This is expected, it means the dying lwp is really gone
853 by now. If ttrace had an event to inform the debugger
854 the lwp is really gone, this wouldn't be needed. */
855 delete_thread (info
->ptid
);
857 /* This was really unexpected. */
858 perror_with_name (("ttrace"));
862 /* Callback for iterate_over_threads. */
865 inf_ttrace_resume_callback (struct thread_info
*info
, void *arg
)
867 if (!ptid_equal (info
->ptid
, inferior_ptid
) && !is_exited (info
->ptid
))
868 inf_ttrace_resume_lwp (info
, TT_LWP_CONTINUE
, 0);
874 inf_ttrace_resume (struct target_ops
*ops
,
875 ptid_t ptid
, int step
, enum target_signal signal
)
878 ttreq_t request
= step
? TT_LWP_SINGLE
: TT_LWP_CONTINUE
;
879 int sig
= target_signal_to_host (signal
);
880 struct thread_info
*info
;
882 /* A specific PTID means `step only this process id'. */
883 resume_all
= (ptid_equal (ptid
, minus_one_ptid
));
885 /* If resuming all threads, it's the current thread that should be
886 handled specially. */
888 ptid
= inferior_ptid
;
890 info
= find_thread_ptid (ptid
);
891 inf_ttrace_resume_lwp (info
, request
, sig
);
894 /* Let all the other threads run too. */
895 iterate_over_threads (inf_ttrace_resume_callback
, NULL
);
899 inf_ttrace_wait (struct target_ops
*ops
,
900 ptid_t ptid
, struct target_waitstatus
*ourstatus
, int options
)
902 pid_t pid
= ptid_get_pid (ptid
);
903 lwpid_t lwpid
= ptid_get_lwp (ptid
);
905 struct thread_info
*ti
;
908 /* Until proven otherwise. */
909 ourstatus
->kind
= TARGET_WAITKIND_SPURIOUS
;
914 gdb_assert (pid
!= 0 || lwpid
== 0);
920 if (ttrace_wait (pid
, lwpid
, TTRACE_WAITOK
, &tts
, sizeof tts
) == -1)
921 perror_with_name (("ttrace_wait"));
923 if (tts
.tts_event
== TTEVT_VFORK
&& tts
.tts_u
.tts_fork
.tts_isparent
)
925 if (inf_ttrace_vfork_ppid
!= -1)
927 gdb_assert (inf_ttrace_vfork_ppid
== tts
.tts_pid
);
929 if (ttrace (TT_PROC_DETACH
, tts
.tts_pid
, 0, 0, 0, 0) == -1)
930 perror_with_name (("ttrace"));
931 inf_ttrace_vfork_ppid
= -1;
934 tts
.tts_event
= TTEVT_NONE
;
937 clear_sigint_trap ();
939 while (tts
.tts_event
== TTEVT_NONE
);
941 /* Now that we've waited, we can re-enable the page protections. */
942 if (inf_ttrace_reenable_page_protections
)
944 gdb_assert (inf_ttrace_num_lwps_in_syscall
== 0);
945 inf_ttrace_enable_page_protections (tts
.tts_pid
);
946 inf_ttrace_reenable_page_protections
= 0;
949 ptid
= ptid_build (tts
.tts_pid
, tts
.tts_lwpid
, 0);
951 if (inf_ttrace_num_lwps
== 0)
953 struct thread_info
*ti
;
955 inf_ttrace_num_lwps
= 1;
957 /* This is the earliest we hear about the lwp member of
958 INFERIOR_PTID, after an attach or fork_inferior. */
959 gdb_assert (ptid_get_lwp (inferior_ptid
) == 0);
961 /* We haven't set the private member on the main thread yet. Do
963 ti
= find_thread_ptid (inferior_ptid
);
964 gdb_assert (ti
!= NULL
&& ti
->private == NULL
);
966 xmalloc (sizeof (struct inf_ttrace_private_thread_info
));
967 memset (ti
->private, 0,
968 sizeof (struct inf_ttrace_private_thread_info
));
970 /* Notify the core that this ptid changed. This changes
971 inferior_ptid as well. */
972 thread_change_ptid (inferior_ptid
, ptid
);
975 switch (tts
.tts_event
)
977 #ifdef TTEVT_BPT_SSTEP
978 case TTEVT_BPT_SSTEP
:
979 /* Make it look like a breakpoint. */
980 ourstatus
->kind
= TARGET_WAITKIND_STOPPED
;
981 ourstatus
->value
.sig
= TARGET_SIGNAL_TRAP
;
986 ourstatus
->kind
= TARGET_WAITKIND_EXECD
;
987 ourstatus
->value
.execd_pathname
=
988 xmalloc (tts
.tts_u
.tts_exec
.tts_pathlen
+ 1);
989 if (ttrace (TT_PROC_GET_PATHNAME
, tts
.tts_pid
, 0,
990 (uintptr_t)ourstatus
->value
.execd_pathname
,
991 tts
.tts_u
.tts_exec
.tts_pathlen
, 0) == -1)
992 perror_with_name (("ttrace"));
993 ourstatus
->value
.execd_pathname
[tts
.tts_u
.tts_exec
.tts_pathlen
] = 0;
995 /* At this point, all inserted breakpoints are gone. Doing this
996 as soon as we detect an exec prevents the badness of deleting
997 a breakpoint writing the current "shadow contents" to lift
998 the bp. That shadow is NOT valid after an exec. */
999 mark_breakpoints_out ();
1003 store_waitstatus (ourstatus
, tts
.tts_u
.tts_exit
.tts_exitcode
);
1004 inf_ttrace_num_lwps
= 0;
1008 related_ptid
= ptid_build (tts
.tts_u
.tts_fork
.tts_fpid
,
1009 tts
.tts_u
.tts_fork
.tts_flwpid
, 0);
1011 ourstatus
->kind
= TARGET_WAITKIND_FORKED
;
1012 ourstatus
->value
.related_pid
= related_ptid
;
1014 /* Make sure the other end of the fork is stopped too. */
1015 if (ttrace_wait (tts
.tts_u
.tts_fork
.tts_fpid
,
1016 tts
.tts_u
.tts_fork
.tts_flwpid
,
1017 TTRACE_WAITOK
, &tts
, sizeof tts
) == -1)
1018 perror_with_name (("ttrace_wait"));
1020 gdb_assert (tts
.tts_event
== TTEVT_FORK
);
1021 if (tts
.tts_u
.tts_fork
.tts_isparent
)
1023 related_ptid
= ptid_build (tts
.tts_u
.tts_fork
.tts_fpid
,
1024 tts
.tts_u
.tts_fork
.tts_flwpid
, 0);
1025 ptid
= ptid_build (tts
.tts_pid
, tts
.tts_lwpid
, 0);
1026 ourstatus
->value
.related_pid
= related_ptid
;
1031 gdb_assert (!tts
.tts_u
.tts_fork
.tts_isparent
);
1033 related_ptid
= ptid_build (tts
.tts_u
.tts_fork
.tts_fpid
,
1034 tts
.tts_u
.tts_fork
.tts_flwpid
, 0);
1036 ourstatus
->kind
= TARGET_WAITKIND_VFORKED
;
1037 ourstatus
->value
.related_pid
= related_ptid
;
1039 /* HACK: To avoid touching the parent during the vfork, switch
1041 inferior_ptid
= ptid
;
1044 case TTEVT_LWP_CREATE
:
1045 lwpid
= tts
.tts_u
.tts_thread
.tts_target_lwpid
;
1046 ptid
= ptid_build (tts
.tts_pid
, lwpid
, 0);
1047 ti
= add_thread (ptid
);
1049 xmalloc (sizeof (struct inf_ttrace_private_thread_info
));
1050 memset (ti
->private, 0,
1051 sizeof (struct inf_ttrace_private_thread_info
));
1052 inf_ttrace_num_lwps
++;
1053 ptid
= ptid_build (tts
.tts_pid
, tts
.tts_lwpid
, 0);
1054 /* Let the lwp_create-caller thread continue. */
1055 ttrace (TT_LWP_CONTINUE
, ptid_get_pid (ptid
),
1056 ptid_get_lwp (ptid
), TT_NOPC
, 0, 0);
1057 /* Return without stopping the whole process. */
1058 ourstatus
->kind
= TARGET_WAITKIND_IGNORE
;
1061 case TTEVT_LWP_EXIT
:
1062 if (print_thread_events
)
1063 printf_unfiltered (_("[%s exited]\n"), target_pid_to_str (ptid
));
1064 ti
= find_thread_ptid (ptid
);
1065 gdb_assert (ti
!= NULL
);
1066 ((struct inf_ttrace_private_thread_info
*)ti
->private)->dying
= 1;
1067 inf_ttrace_num_lwps
--;
1068 /* Let the thread really exit. */
1069 ttrace (TT_LWP_CONTINUE
, ptid_get_pid (ptid
),
1070 ptid_get_lwp (ptid
), TT_NOPC
, 0, 0);
1071 /* Return without stopping the whole process. */
1072 ourstatus
->kind
= TARGET_WAITKIND_IGNORE
;
1075 case TTEVT_LWP_TERMINATE
:
1076 lwpid
= tts
.tts_u
.tts_thread
.tts_target_lwpid
;
1077 ptid
= ptid_build (tts
.tts_pid
, lwpid
, 0);
1078 if (print_thread_events
)
1079 printf_unfiltered(_("[%s has been terminated]\n"),
1080 target_pid_to_str (ptid
));
1081 ti
= find_thread_ptid (ptid
);
1082 gdb_assert (ti
!= NULL
);
1083 ((struct inf_ttrace_private_thread_info
*)ti
->private)->dying
= 1;
1084 inf_ttrace_num_lwps
--;
1086 /* Resume the lwp_terminate-caller thread. */
1087 ptid
= ptid_build (tts
.tts_pid
, tts
.tts_lwpid
, 0);
1088 ttrace (TT_LWP_CONTINUE
, ptid_get_pid (ptid
),
1089 ptid_get_lwp (ptid
), TT_NOPC
, 0, 0);
1090 /* Return without stopping the whole process. */
1091 ourstatus
->kind
= TARGET_WAITKIND_IGNORE
;
1095 ourstatus
->kind
= TARGET_WAITKIND_STOPPED
;
1096 ourstatus
->value
.sig
=
1097 target_signal_from_host (tts
.tts_u
.tts_signal
.tts_signo
);
1100 case TTEVT_SYSCALL_ENTRY
:
1101 gdb_assert (inf_ttrace_reenable_page_protections
== 0);
1102 inf_ttrace_num_lwps_in_syscall
++;
1103 if (inf_ttrace_num_lwps_in_syscall
== 1)
1105 /* A thread has just entered a system call. Disable any
1106 page protections as the kernel can't deal with them. */
1107 inf_ttrace_disable_page_protections (tts
.tts_pid
);
1109 ourstatus
->kind
= TARGET_WAITKIND_SYSCALL_ENTRY
;
1110 ourstatus
->value
.syscall_number
= tts
.tts_scno
;
1113 case TTEVT_SYSCALL_RETURN
:
1114 if (inf_ttrace_num_lwps_in_syscall
> 0)
1116 /* If the last thread has just left the system call, this
1117 would be a logical place to re-enable the page
1118 protections, but that doesn't work. We can't re-enable
1119 them until we've done another wait. */
1120 inf_ttrace_reenable_page_protections
=
1121 (inf_ttrace_num_lwps_in_syscall
== 1);
1122 inf_ttrace_num_lwps_in_syscall
--;
1124 ourstatus
->kind
= TARGET_WAITKIND_SYSCALL_RETURN
;
1125 ourstatus
->value
.syscall_number
= tts
.tts_scno
;
1129 gdb_assert (!"Unexpected ttrace event");
1133 /* Make sure all threads within the process are stopped. */
1134 if (ttrace (TT_PROC_STOP
, tts
.tts_pid
, 0, 0, 0, 0) == -1)
1135 perror_with_name (("ttrace"));
1137 /* Now that the whole process is stopped, check if any dying thread
1138 is really dead by now. If a dying thread is still alive, it will
1139 be stopped too, and will still show up in `info threads', tagged
1140 with "(Exiting)". We could make `info threads' prune dead
1141 threads instead via inf_ttrace_thread_alive, but doing this here
1142 has the advantage that a frontend is notificed sooner of thread
1143 exits. Note that a dying lwp is still alive, it still has to be
1144 resumed, like any other lwp. */
1145 iterate_over_threads (inf_ttrace_delete_dead_threads_callback
, NULL
);
1150 /* Transfer LEN bytes from ADDR in the inferior's memory into READBUF,
1151 and transfer LEN bytes from WRITEBUF into the inferior's memory at
1152 ADDR. Either READBUF or WRITEBUF may be null, in which case the
1153 corresponding transfer doesn't happen. Return the number of bytes
1154 actually transferred (which may be zero if an error occurs). */
1157 inf_ttrace_xfer_memory (CORE_ADDR addr
, ULONGEST len
,
1158 void *readbuf
, const void *writebuf
)
1160 pid_t pid
= ptid_get_pid (inferior_ptid
);
1162 /* HP-UX treats text space and data space differently. GDB however,
1163 doesn't really know the difference. Therefore we try both. Try
1164 text space before data space though because when we're writing
1165 into text space the instruction cache might need to be flushed. */
1168 && ttrace (TT_PROC_RDTEXT
, pid
, 0, addr
, len
, (uintptr_t)readbuf
) == -1
1169 && ttrace (TT_PROC_RDDATA
, pid
, 0, addr
, len
, (uintptr_t)readbuf
) == -1)
1173 && ttrace (TT_PROC_WRTEXT
, pid
, 0, addr
, len
, (uintptr_t)writebuf
) == -1
1174 && ttrace (TT_PROC_WRDATA
, pid
, 0, addr
, len
, (uintptr_t)writebuf
) == -1)
1181 inf_ttrace_xfer_partial (struct target_ops
*ops
, enum target_object object
,
1182 const char *annex
, gdb_byte
*readbuf
,
1183 const gdb_byte
*writebuf
, ULONGEST offset
, LONGEST len
)
1187 case TARGET_OBJECT_MEMORY
:
1188 return inf_ttrace_xfer_memory (offset
, len
, readbuf
, writebuf
);
1190 case TARGET_OBJECT_UNWIND_TABLE
:
1193 case TARGET_OBJECT_AUXV
:
1196 case TARGET_OBJECT_WCOOKIE
:
1204 /* Print status information about what we're accessing. */
1207 inf_ttrace_files_info (struct target_ops
*ignore
)
1209 struct inferior
*inf
= current_inferior ();
1210 printf_filtered (_("\tUsing the running image of %s %s.\n"),
1211 inf
->attach_flag
? "attached" : "child",
1212 target_pid_to_str (inferior_ptid
));
1216 inf_ttrace_thread_alive (struct target_ops
*ops
, ptid_t ptid
)
1221 /* Return a string describing the state of the thread specified by
1225 inf_ttrace_extra_thread_info (struct thread_info
*info
)
1227 struct inf_ttrace_private_thread_info
* private =
1228 (struct inf_ttrace_private_thread_info
*) info
->private;
1230 if (private != NULL
&& private->dying
)
1237 inf_ttrace_pid_to_str (struct target_ops
*ops
, ptid_t ptid
)
1239 pid_t pid
= ptid_get_pid (ptid
);
1240 lwpid_t lwpid
= ptid_get_lwp (ptid
);
1241 static char buf
[128];
1244 xsnprintf (buf
, sizeof buf
, "process %ld",
1247 xsnprintf (buf
, sizeof buf
, "process %ld, lwp %ld",
1248 (long) pid
, (long) lwpid
);
1254 inf_ttrace_target (void)
1256 struct target_ops
*t
= inf_child_target ();
1258 t
->to_attach
= inf_ttrace_attach
;
1259 t
->to_detach
= inf_ttrace_detach
;
1260 t
->to_resume
= inf_ttrace_resume
;
1261 t
->to_wait
= inf_ttrace_wait
;
1262 t
->to_files_info
= inf_ttrace_files_info
;
1263 t
->to_can_use_hw_breakpoint
= inf_ttrace_can_use_hw_breakpoint
;
1264 t
->to_insert_watchpoint
= inf_ttrace_insert_watchpoint
;
1265 t
->to_remove_watchpoint
= inf_ttrace_remove_watchpoint
;
1266 t
->to_stopped_by_watchpoint
= inf_ttrace_stopped_by_watchpoint
;
1267 t
->to_region_ok_for_hw_watchpoint
=
1268 inf_ttrace_region_ok_for_hw_watchpoint
;
1269 t
->to_kill
= inf_ttrace_kill
;
1270 t
->to_create_inferior
= inf_ttrace_create_inferior
;
1271 t
->to_follow_fork
= inf_ttrace_follow_fork
;
1272 t
->to_mourn_inferior
= inf_ttrace_mourn_inferior
;
1273 t
->to_thread_alive
= inf_ttrace_thread_alive
;
1274 t
->to_extra_thread_info
= inf_ttrace_extra_thread_info
;
1275 t
->to_pid_to_str
= inf_ttrace_pid_to_str
;
1276 t
->to_xfer_partial
= inf_ttrace_xfer_partial
;
1283 /* Prevent warning from -Wmissing-prototypes. */
1284 void _initialize_hppa_hpux_nat (void);
1287 _initialize_inf_ttrace (void)
1290 inf_ttrace_page_dict
.pagesize
= getpagesize();