1 /* Low-level child interface to ttrace.
3 Copyright (C) 2004, 2005, 2006, 2007, 2008, 2009
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
*last_tp
= NULL
;
416 struct breakpoint
*step_resume_breakpoint
= NULL
;
417 CORE_ADDR step_range_start
= 0, step_range_end
= 0;
418 struct frame_id step_frame_id
= null_frame_id
;
420 /* FIXME: kettenis/20050720: This stuff should really be passed as
421 an argument by our caller. */
424 struct target_waitstatus status
;
426 get_last_target_status (&ptid
, &status
);
427 gdb_assert (status
.kind
== TARGET_WAITKIND_FORKED
428 || status
.kind
== TARGET_WAITKIND_VFORKED
);
430 pid
= ptid_get_pid (ptid
);
431 lwpid
= ptid_get_lwp (ptid
);
432 last_tp
= find_thread_pid (ptid
);
435 /* Get all important details that core GDB doesn't (and shouldn't)
437 if (ttrace (TT_LWP_GET_STATE
, pid
, lwpid
,
438 (uintptr_t)&tts
, sizeof tts
, 0) == -1)
439 perror_with_name (("ttrace"));
441 gdb_assert (tts
.tts_event
== TTEVT_FORK
|| tts
.tts_event
== TTEVT_VFORK
);
443 if (tts
.tts_u
.tts_fork
.tts_isparent
)
446 lwpid
= tts
.tts_lwpid
;
447 fpid
= tts
.tts_u
.tts_fork
.tts_fpid
;
448 flwpid
= tts
.tts_u
.tts_fork
.tts_flwpid
;
452 pid
= tts
.tts_u
.tts_fork
.tts_fpid
;
453 lwpid
= tts
.tts_u
.tts_fork
.tts_flwpid
;
455 flwpid
= tts
.tts_lwpid
;
460 struct inferior
*inf
;
461 struct inferior
*parent_inf
;
463 parent_inf
= find_inferior_pid (pid
);
465 /* Copy user stepping state to the new inferior thread. */
466 step_resume_breakpoint
= last_tp
->step_resume_breakpoint
;
467 step_range_start
= last_tp
->step_range_start
;
468 step_range_end
= last_tp
->step_range_end
;
469 step_frame_id
= last_tp
->step_frame_id
;
471 /* Otherwise, deleting the parent would get rid of this
473 last_tp
->step_resume_breakpoint
= NULL
;
475 inferior_ptid
= ptid_build (fpid
, flwpid
, 0);
476 inf
= add_inferior (fpid
);
477 inf
->attach_flag
= parent_inf
->attach_flag
;
478 copy_terminal_info (inf
, parent_inf
);
479 detach_breakpoints (pid
);
481 target_terminal_ours ();
482 fprintf_unfiltered (gdb_stdlog
, _("\
483 Attaching after fork to child process %ld.\n"), (long)fpid
);
487 inferior_ptid
= ptid_build (pid
, lwpid
, 0);
488 detach_breakpoints (fpid
);
490 target_terminal_ours ();
491 fprintf_unfiltered (gdb_stdlog
, _("\
492 Detaching after fork from child process %ld.\n"), (long)fpid
);
495 if (tts
.tts_event
== TTEVT_VFORK
)
497 gdb_assert (!tts
.tts_u
.tts_fork
.tts_isparent
);
501 /* We can't detach from the parent yet. */
502 inf_ttrace_vfork_ppid
= pid
;
504 reattach_breakpoints (fpid
);
508 if (ttrace (TT_PROC_DETACH
, fpid
, 0, 0, 0, 0) == -1)
509 perror_with_name (("ttrace"));
511 /* Wait till we get the TTEVT_VFORK event in the parent.
512 This indicates that the child has called exec(3) or has
513 exited and that the parent is ready to be traced again. */
514 if (ttrace_wait (pid
, lwpid
, TTRACE_WAITOK
, &tts
, sizeof tts
) == -1)
515 perror_with_name (("ttrace_wait"));
516 gdb_assert (tts
.tts_event
== TTEVT_VFORK
);
517 gdb_assert (tts
.tts_u
.tts_fork
.tts_isparent
);
519 reattach_breakpoints (pid
);
524 gdb_assert (tts
.tts_u
.tts_fork
.tts_isparent
);
528 if (ttrace (TT_PROC_DETACH
, pid
, 0, 0, 0, 0) == -1)
529 perror_with_name (("ttrace"));
533 if (ttrace (TT_PROC_DETACH
, fpid
, 0, 0, 0, 0) == -1)
534 perror_with_name (("ttrace"));
540 struct thread_info
*ti
;
542 /* The child will start out single-threaded. */
543 inf_ttrace_num_lwps
= 1;
544 inf_ttrace_num_lwps_in_syscall
= 0;
547 delete_thread_silent (ptid_build (pid
, lwpid
, 0));
548 detach_inferior (pid
);
550 /* Add child thread. inferior_ptid was already set above. */
551 ti
= add_thread_silent (inferior_ptid
);
553 xmalloc (sizeof (struct inf_ttrace_private_thread_info
));
554 memset (ti
->private, 0,
555 sizeof (struct inf_ttrace_private_thread_info
));
557 ti
->step_resume_breakpoint
= step_resume_breakpoint
;
558 ti
->step_range_start
= step_range_start
;
559 ti
->step_range_end
= step_range_end
;
560 ti
->step_frame_id
= step_frame_id
;
562 /* Reset breakpoints in the child as appropriate. */
563 follow_inferior_reset_breakpoints ();
570 /* File descriptors for pipes used as semaphores during initial
571 startup of an inferior. */
572 static int inf_ttrace_pfd1
[2];
573 static int inf_ttrace_pfd2
[2];
576 do_cleanup_pfds (void *dummy
)
578 close (inf_ttrace_pfd1
[0]);
579 close (inf_ttrace_pfd1
[1]);
580 close (inf_ttrace_pfd2
[0]);
581 close (inf_ttrace_pfd2
[1]);
585 inf_ttrace_prepare (void)
587 if (pipe (inf_ttrace_pfd1
) == -1)
588 perror_with_name (("pipe"));
590 if (pipe (inf_ttrace_pfd2
) == -1)
592 close (inf_ttrace_pfd1
[0]);
593 close (inf_ttrace_pfd2
[0]);
594 perror_with_name (("pipe"));
598 /* Prepare to be traced. */
603 struct cleanup
*old_chain
= make_cleanup (do_cleanup_pfds
, 0);
606 /* "Trace me, Dr. Memory!" */
607 if (ttrace (TT_PROC_SETTRC
, 0, 0, 0, TT_VERSION
, 0) == -1)
608 perror_with_name (("ttrace"));
610 /* Tell our parent that we are ready to be traced. */
611 if (write (inf_ttrace_pfd1
[1], &c
, sizeof c
) != sizeof c
)
612 perror_with_name (("write"));
614 /* Wait until our parent has set the initial event mask. */
615 if (read (inf_ttrace_pfd2
[0], &c
, sizeof c
) != sizeof c
)
616 perror_with_name (("read"));
618 do_cleanups (old_chain
);
621 /* Start tracing PID. */
624 inf_ttrace_him (struct target_ops
*ops
, int pid
)
626 struct cleanup
*old_chain
= make_cleanup (do_cleanup_pfds
, 0);
630 /* Wait until our child is ready to be traced. */
631 if (read (inf_ttrace_pfd1
[0], &c
, sizeof c
) != sizeof c
)
632 perror_with_name (("read"));
634 /* Set the initial event mask. */
635 memset (&tte
, 0, sizeof (tte
));
636 tte
.tte_events
|= TTEVT_EXEC
| TTEVT_EXIT
| TTEVT_FORK
| TTEVT_VFORK
;
637 tte
.tte_events
|= TTEVT_LWP_CREATE
| TTEVT_LWP_EXIT
| TTEVT_LWP_TERMINATE
;
638 #ifdef TTEVT_BPT_SSTEP
639 tte
.tte_events
|= TTEVT_BPT_SSTEP
;
641 tte
.tte_opts
|= TTEO_PROC_INHERIT
;
642 if (ttrace (TT_PROC_SET_EVENT_MASK
, pid
, 0,
643 (uintptr_t)&tte
, sizeof tte
, 0) == -1)
644 perror_with_name (("ttrace"));
646 /* Tell our child that we have set the initial event mask. */
647 if (write (inf_ttrace_pfd2
[1], &c
, sizeof c
) != sizeof c
)
648 perror_with_name (("write"));
650 do_cleanups (old_chain
);
654 /* On some targets, there must be some explicit synchronization
655 between the parent and child processes after the debugger forks,
656 and before the child execs the debuggee program. This call
657 basically gives permission for the child to exec. */
659 target_acknowledge_created_inferior (pid
);
661 /* START_INFERIOR_TRAPS_EXPECTED is defined in inferior.h, and will
662 be 1 or 2 depending on whether we're starting without or with a
664 startup_inferior (START_INFERIOR_TRAPS_EXPECTED
);
666 /* On some targets, there must be some explicit actions taken after
667 the inferior has been started up. */
668 target_post_startup_inferior (pid_to_ptid (pid
));
672 inf_ttrace_create_inferior (struct target_ops
*ops
, char *exec_file
,
673 char *allargs
, char **env
, int from_tty
)
677 gdb_assert (inf_ttrace_num_lwps
== 0);
678 gdb_assert (inf_ttrace_num_lwps_in_syscall
== 0);
679 gdb_assert (inf_ttrace_page_dict
.count
== 0);
680 gdb_assert (inf_ttrace_reenable_page_protections
== 0);
681 gdb_assert (inf_ttrace_vfork_ppid
== -1);
683 pid
= fork_inferior (exec_file
, allargs
, env
, inf_ttrace_me
, NULL
,
684 inf_ttrace_prepare
, NULL
);
686 inf_ttrace_him (ops
, pid
);
690 inf_ttrace_mourn_inferior (struct target_ops
*ops
)
692 const int num_buckets
= ARRAY_SIZE (inf_ttrace_page_dict
.buckets
);
695 inf_ttrace_num_lwps
= 0;
696 inf_ttrace_num_lwps_in_syscall
= 0;
698 for (bucket
= 0; bucket
< num_buckets
; bucket
++)
700 struct inf_ttrace_page
*page
;
701 struct inf_ttrace_page
*next
;
703 page
= inf_ttrace_page_dict
.buckets
[bucket
].next
;
711 inf_ttrace_page_dict
.count
= 0;
714 generic_mourn_inferior ();
718 inf_ttrace_attach (struct target_ops
*ops
, char *args
, int from_tty
)
724 struct inferior
*inf
;
727 error_no_arg (_("process-id to attach"));
730 pid
= strtol (args
, &dummy
, 0);
731 if (pid
== 0 && args
== dummy
)
732 error (_("Illegal process-id: %s."), args
);
734 if (pid
== getpid ()) /* Trying to masturbate? */
735 error (_("I refuse to debug myself!"));
739 exec_file
= get_exec_file (0);
742 printf_unfiltered (_("Attaching to program: %s, %s\n"), exec_file
,
743 target_pid_to_str (pid_to_ptid (pid
)));
745 printf_unfiltered (_("Attaching to %s\n"),
746 target_pid_to_str (pid_to_ptid (pid
)));
748 gdb_flush (gdb_stdout
);
751 gdb_assert (inf_ttrace_num_lwps
== 0);
752 gdb_assert (inf_ttrace_num_lwps_in_syscall
== 0);
753 gdb_assert (inf_ttrace_vfork_ppid
== -1);
755 if (ttrace (TT_PROC_ATTACH
, pid
, 0, TT_KILL_ON_EXIT
, TT_VERSION
, 0) == -1)
756 perror_with_name (("ttrace"));
758 inf
= add_inferior (pid
);
759 inf
->attach_flag
= 1;
761 /* Set the initial event mask. */
762 memset (&tte
, 0, sizeof (tte
));
763 tte
.tte_events
|= TTEVT_EXEC
| TTEVT_EXIT
| TTEVT_FORK
| TTEVT_VFORK
;
764 tte
.tte_events
|= TTEVT_LWP_CREATE
| TTEVT_LWP_EXIT
| TTEVT_LWP_TERMINATE
;
765 #ifdef TTEVT_BPT_SSTEP
766 tte
.tte_events
|= TTEVT_BPT_SSTEP
;
768 tte
.tte_opts
|= TTEO_PROC_INHERIT
;
769 if (ttrace (TT_PROC_SET_EVENT_MASK
, pid
, 0,
770 (uintptr_t)&tte
, sizeof tte
, 0) == -1)
771 perror_with_name (("ttrace"));
775 /* We'll bump inf_ttrace_num_lwps up and add the private data to the
776 thread as soon as we get to inf_ttrace_wait. At this point, we
777 don't have lwpid info yet. */
778 inferior_ptid
= pid_to_ptid (pid
);
779 add_thread_silent (inferior_ptid
);
783 inf_ttrace_detach (struct target_ops
*ops
, char *args
, int from_tty
)
785 pid_t pid
= ptid_get_pid (inferior_ptid
);
790 char *exec_file
= get_exec_file (0);
793 printf_unfiltered (_("Detaching from program: %s, %s\n"), exec_file
,
794 target_pid_to_str (pid_to_ptid (pid
)));
795 gdb_flush (gdb_stdout
);
800 /* ??? The HP-UX 11.0 ttrace(2) manual page doesn't mention that we
801 can pass a signal number here. Does this really work? */
802 if (ttrace (TT_PROC_DETACH
, pid
, 0, 0, sig
, 0) == -1)
803 perror_with_name (("ttrace"));
805 if (inf_ttrace_vfork_ppid
!= -1)
807 if (ttrace (TT_PROC_DETACH
, inf_ttrace_vfork_ppid
, 0, 0, 0, 0) == -1)
808 perror_with_name (("ttrace"));
809 inf_ttrace_vfork_ppid
= -1;
812 inf_ttrace_num_lwps
= 0;
813 inf_ttrace_num_lwps_in_syscall
= 0;
815 inferior_ptid
= null_ptid
;
816 detach_inferior (pid
);
822 inf_ttrace_kill (struct target_ops
*ops
)
824 pid_t pid
= ptid_get_pid (inferior_ptid
);
829 if (ttrace (TT_PROC_EXIT
, pid
, 0, 0, 0, 0) == -1)
830 perror_with_name (("ttrace"));
831 /* ??? Is it necessary to call ttrace_wait() here? */
833 if (inf_ttrace_vfork_ppid
!= -1)
835 if (ttrace (TT_PROC_DETACH
, inf_ttrace_vfork_ppid
, 0, 0, 0, 0) == -1)
836 perror_with_name (("ttrace"));
837 inf_ttrace_vfork_ppid
= -1;
840 target_mourn_inferior ();
843 /* Check is a dying thread is dead by now, and delete it from GDBs
844 thread list if so. */
846 inf_ttrace_delete_dead_threads_callback (struct thread_info
*info
, void *arg
)
849 struct inf_ttrace_private_thread_info
*p
;
851 if (is_exited (info
->ptid
))
854 lwpid
= ptid_get_lwp (info
->ptid
);
855 p
= (struct inf_ttrace_private_thread_info
*) info
->private;
857 /* Check if an lwp that was dying is still there or not. */
858 if (p
->dying
&& (kill (lwpid
, 0) == -1))
860 delete_thread (info
->ptid
);
865 /* Resume the lwp pointed to by INFO, with REQUEST, and pass it signal
869 inf_ttrace_resume_lwp (struct thread_info
*info
, ttreq_t request
, int sig
)
871 pid_t pid
= ptid_get_pid (info
->ptid
);
872 lwpid_t lwpid
= ptid_get_lwp (info
->ptid
);
874 if (ttrace (request
, pid
, lwpid
, TT_NOPC
, sig
, 0) == -1)
876 struct inf_ttrace_private_thread_info
*p
877 = (struct inf_ttrace_private_thread_info
*) info
->private;
878 if (p
->dying
&& errno
== EPROTO
)
879 /* This is expected, it means the dying lwp is really gone
880 by now. If ttrace had an event to inform the debugger
881 the lwp is really gone, this wouldn't be needed. */
882 delete_thread (info
->ptid
);
884 /* This was really unexpected. */
885 perror_with_name (("ttrace"));
889 /* Callback for iterate_over_threads. */
892 inf_ttrace_resume_callback (struct thread_info
*info
, void *arg
)
894 if (!ptid_equal (info
->ptid
, inferior_ptid
) && !is_exited (info
->ptid
))
895 inf_ttrace_resume_lwp (info
, TT_LWP_CONTINUE
, 0);
901 inf_ttrace_resume (struct target_ops
*ops
,
902 ptid_t ptid
, int step
, enum target_signal signal
)
905 ttreq_t request
= step
? TT_LWP_SINGLE
: TT_LWP_CONTINUE
;
906 int sig
= target_signal_to_host (signal
);
907 struct thread_info
*info
;
909 /* A specific PTID means `step only this process id'. */
910 resume_all
= (ptid_equal (ptid
, minus_one_ptid
));
912 /* If resuming all threads, it's the current thread that should be
913 handled specially. */
915 ptid
= inferior_ptid
;
917 info
= find_thread_pid (ptid
);
918 inf_ttrace_resume_lwp (info
, request
, sig
);
921 /* Let all the other threads run too. */
922 iterate_over_threads (inf_ttrace_resume_callback
, NULL
);
926 inf_ttrace_wait (struct target_ops
*ops
,
927 ptid_t ptid
, struct target_waitstatus
*ourstatus
, int options
)
929 pid_t pid
= ptid_get_pid (ptid
);
930 lwpid_t lwpid
= ptid_get_lwp (ptid
);
932 struct thread_info
*ti
;
935 /* Until proven otherwise. */
936 ourstatus
->kind
= TARGET_WAITKIND_SPURIOUS
;
941 gdb_assert (pid
!= 0 || lwpid
== 0);
947 if (ttrace_wait (pid
, lwpid
, TTRACE_WAITOK
, &tts
, sizeof tts
) == -1)
948 perror_with_name (("ttrace_wait"));
950 if (tts
.tts_event
== TTEVT_VFORK
&& tts
.tts_u
.tts_fork
.tts_isparent
)
952 if (inf_ttrace_vfork_ppid
!= -1)
954 gdb_assert (inf_ttrace_vfork_ppid
== tts
.tts_pid
);
956 if (ttrace (TT_PROC_DETACH
, tts
.tts_pid
, 0, 0, 0, 0) == -1)
957 perror_with_name (("ttrace"));
958 inf_ttrace_vfork_ppid
= -1;
961 tts
.tts_event
= TTEVT_NONE
;
964 clear_sigint_trap ();
966 while (tts
.tts_event
== TTEVT_NONE
);
968 /* Now that we've waited, we can re-enable the page protections. */
969 if (inf_ttrace_reenable_page_protections
)
971 gdb_assert (inf_ttrace_num_lwps_in_syscall
== 0);
972 inf_ttrace_enable_page_protections (tts
.tts_pid
);
973 inf_ttrace_reenable_page_protections
= 0;
976 ptid
= ptid_build (tts
.tts_pid
, tts
.tts_lwpid
, 0);
978 if (inf_ttrace_num_lwps
== 0)
980 struct thread_info
*ti
;
982 inf_ttrace_num_lwps
= 1;
984 /* This is the earliest we hear about the lwp member of
985 INFERIOR_PTID, after an attach or fork_inferior. */
986 gdb_assert (ptid_get_lwp (inferior_ptid
) == 0);
988 /* We haven't set the private member on the main thread yet. Do
990 ti
= find_thread_pid (inferior_ptid
);
991 gdb_assert (ti
!= NULL
&& ti
->private == NULL
);
993 xmalloc (sizeof (struct inf_ttrace_private_thread_info
));
994 memset (ti
->private, 0,
995 sizeof (struct inf_ttrace_private_thread_info
));
997 /* Notify the core that this ptid changed. This changes
998 inferior_ptid as well. */
999 thread_change_ptid (inferior_ptid
, ptid
);
1002 switch (tts
.tts_event
)
1004 #ifdef TTEVT_BPT_SSTEP
1005 case TTEVT_BPT_SSTEP
:
1006 /* Make it look like a breakpoint. */
1007 ourstatus
->kind
= TARGET_WAITKIND_STOPPED
;
1008 ourstatus
->value
.sig
= TARGET_SIGNAL_TRAP
;
1013 ourstatus
->kind
= TARGET_WAITKIND_EXECD
;
1014 ourstatus
->value
.execd_pathname
=
1015 xmalloc (tts
.tts_u
.tts_exec
.tts_pathlen
+ 1);
1016 if (ttrace (TT_PROC_GET_PATHNAME
, tts
.tts_pid
, 0,
1017 (uintptr_t)ourstatus
->value
.execd_pathname
,
1018 tts
.tts_u
.tts_exec
.tts_pathlen
, 0) == -1)
1019 perror_with_name (("ttrace"));
1020 ourstatus
->value
.execd_pathname
[tts
.tts_u
.tts_exec
.tts_pathlen
] = 0;
1022 /* At this point, all inserted breakpoints are gone. Doing this
1023 as soon as we detect an exec prevents the badness of deleting
1024 a breakpoint writing the current "shadow contents" to lift
1025 the bp. That shadow is NOT valid after an exec. */
1026 mark_breakpoints_out ();
1030 store_waitstatus (ourstatus
, tts
.tts_u
.tts_exit
.tts_exitcode
);
1031 inf_ttrace_num_lwps
= 0;
1035 related_ptid
= ptid_build (tts
.tts_u
.tts_fork
.tts_fpid
,
1036 tts
.tts_u
.tts_fork
.tts_flwpid
, 0);
1038 ourstatus
->kind
= TARGET_WAITKIND_FORKED
;
1039 ourstatus
->value
.related_pid
= related_ptid
;
1041 /* Make sure the other end of the fork is stopped too. */
1042 if (ttrace_wait (tts
.tts_u
.tts_fork
.tts_fpid
,
1043 tts
.tts_u
.tts_fork
.tts_flwpid
,
1044 TTRACE_WAITOK
, &tts
, sizeof tts
) == -1)
1045 perror_with_name (("ttrace_wait"));
1047 gdb_assert (tts
.tts_event
== TTEVT_FORK
);
1048 if (tts
.tts_u
.tts_fork
.tts_isparent
)
1050 related_ptid
= ptid_build (tts
.tts_u
.tts_fork
.tts_fpid
,
1051 tts
.tts_u
.tts_fork
.tts_flwpid
, 0);
1052 ptid
= ptid_build (tts
.tts_pid
, tts
.tts_lwpid
, 0);
1053 ourstatus
->value
.related_pid
= related_ptid
;
1058 gdb_assert (!tts
.tts_u
.tts_fork
.tts_isparent
);
1060 related_ptid
= ptid_build (tts
.tts_u
.tts_fork
.tts_fpid
,
1061 tts
.tts_u
.tts_fork
.tts_flwpid
, 0);
1063 ourstatus
->kind
= TARGET_WAITKIND_VFORKED
;
1064 ourstatus
->value
.related_pid
= related_ptid
;
1066 /* HACK: To avoid touching the parent during the vfork, switch
1068 inferior_ptid
= ptid
;
1071 case TTEVT_LWP_CREATE
:
1072 lwpid
= tts
.tts_u
.tts_thread
.tts_target_lwpid
;
1073 ptid
= ptid_build (tts
.tts_pid
, lwpid
, 0);
1074 ti
= add_thread (ptid
);
1076 xmalloc (sizeof (struct inf_ttrace_private_thread_info
));
1077 memset (ti
->private, 0,
1078 sizeof (struct inf_ttrace_private_thread_info
));
1079 inf_ttrace_num_lwps
++;
1080 ptid
= ptid_build (tts
.tts_pid
, tts
.tts_lwpid
, 0);
1081 /* Let the lwp_create-caller thread continue. */
1082 ttrace (TT_LWP_CONTINUE
, ptid_get_pid (ptid
),
1083 ptid_get_lwp (ptid
), TT_NOPC
, 0, 0);
1084 /* Return without stopping the whole process. */
1085 ourstatus
->kind
= TARGET_WAITKIND_IGNORE
;
1088 case TTEVT_LWP_EXIT
:
1089 if (print_thread_events
)
1090 printf_unfiltered (_("[%s exited]\n"), target_pid_to_str (ptid
));
1091 ti
= find_thread_pid (ptid
);
1092 gdb_assert (ti
!= NULL
);
1093 ((struct inf_ttrace_private_thread_info
*)ti
->private)->dying
= 1;
1094 inf_ttrace_num_lwps
--;
1095 /* Let the thread really exit. */
1096 ttrace (TT_LWP_CONTINUE
, ptid_get_pid (ptid
),
1097 ptid_get_lwp (ptid
), TT_NOPC
, 0, 0);
1098 /* Return without stopping the whole process. */
1099 ourstatus
->kind
= TARGET_WAITKIND_IGNORE
;
1102 case TTEVT_LWP_TERMINATE
:
1103 lwpid
= tts
.tts_u
.tts_thread
.tts_target_lwpid
;
1104 ptid
= ptid_build (tts
.tts_pid
, lwpid
, 0);
1105 if (print_thread_events
)
1106 printf_unfiltered(_("[%s has been terminated]\n"),
1107 target_pid_to_str (ptid
));
1108 ti
= find_thread_pid (ptid
);
1109 gdb_assert (ti
!= NULL
);
1110 ((struct inf_ttrace_private_thread_info
*)ti
->private)->dying
= 1;
1111 inf_ttrace_num_lwps
--;
1113 /* Resume the lwp_terminate-caller thread. */
1114 ptid
= ptid_build (tts
.tts_pid
, tts
.tts_lwpid
, 0);
1115 ttrace (TT_LWP_CONTINUE
, ptid_get_pid (ptid
),
1116 ptid_get_lwp (ptid
), TT_NOPC
, 0, 0);
1117 /* Return without stopping the whole process. */
1118 ourstatus
->kind
= TARGET_WAITKIND_IGNORE
;
1122 ourstatus
->kind
= TARGET_WAITKIND_STOPPED
;
1123 ourstatus
->value
.sig
=
1124 target_signal_from_host (tts
.tts_u
.tts_signal
.tts_signo
);
1127 case TTEVT_SYSCALL_ENTRY
:
1128 gdb_assert (inf_ttrace_reenable_page_protections
== 0);
1129 inf_ttrace_num_lwps_in_syscall
++;
1130 if (inf_ttrace_num_lwps_in_syscall
== 1)
1132 /* A thread has just entered a system call. Disable any
1133 page protections as the kernel can't deal with them. */
1134 inf_ttrace_disable_page_protections (tts
.tts_pid
);
1136 ourstatus
->kind
= TARGET_WAITKIND_SYSCALL_ENTRY
;
1137 ourstatus
->value
.syscall_id
= tts
.tts_scno
;
1140 case TTEVT_SYSCALL_RETURN
:
1141 if (inf_ttrace_num_lwps_in_syscall
> 0)
1143 /* If the last thread has just left the system call, this
1144 would be a logical place to re-enable the page
1145 protections, but that doesn't work. We can't re-enable
1146 them until we've done another wait. */
1147 inf_ttrace_reenable_page_protections
=
1148 (inf_ttrace_num_lwps_in_syscall
== 1);
1149 inf_ttrace_num_lwps_in_syscall
--;
1151 ourstatus
->kind
= TARGET_WAITKIND_SYSCALL_RETURN
;
1152 ourstatus
->value
.syscall_id
= tts
.tts_scno
;
1156 gdb_assert (!"Unexpected ttrace event");
1160 /* Make sure all threads within the process are stopped. */
1161 if (ttrace (TT_PROC_STOP
, tts
.tts_pid
, 0, 0, 0, 0) == -1)
1162 perror_with_name (("ttrace"));
1164 /* Now that the whole process is stopped, check if any dying thread
1165 is really dead by now. If a dying thread is still alive, it will
1166 be stopped too, and will still show up in `info threads', tagged
1167 with "(Exiting)". We could make `info threads' prune dead
1168 threads instead via inf_ttrace_thread_alive, but doing this here
1169 has the advantage that a frontend is notificed sooner of thread
1170 exits. Note that a dying lwp is still alive, it still has to be
1171 resumed, like any other lwp. */
1172 iterate_over_threads (inf_ttrace_delete_dead_threads_callback
, NULL
);
1177 /* Transfer LEN bytes from ADDR in the inferior's memory into READBUF,
1178 and transfer LEN bytes from WRITEBUF into the inferior's memory at
1179 ADDR. Either READBUF or WRITEBUF may be null, in which case the
1180 corresponding transfer doesn't happen. Return the number of bytes
1181 actually transferred (which may be zero if an error occurs). */
1184 inf_ttrace_xfer_memory (CORE_ADDR addr
, ULONGEST len
,
1185 void *readbuf
, const void *writebuf
)
1187 pid_t pid
= ptid_get_pid (inferior_ptid
);
1189 /* HP-UX treats text space and data space differently. GDB however,
1190 doesn't really know the difference. Therefore we try both. Try
1191 text space before data space though because when we're writing
1192 into text space the instruction cache might need to be flushed. */
1195 && ttrace (TT_PROC_RDTEXT
, pid
, 0, addr
, len
, (uintptr_t)readbuf
) == -1
1196 && ttrace (TT_PROC_RDDATA
, pid
, 0, addr
, len
, (uintptr_t)readbuf
) == -1)
1200 && ttrace (TT_PROC_WRTEXT
, pid
, 0, addr
, len
, (uintptr_t)writebuf
) == -1
1201 && ttrace (TT_PROC_WRDATA
, pid
, 0, addr
, len
, (uintptr_t)writebuf
) == -1)
1208 inf_ttrace_xfer_partial (struct target_ops
*ops
, enum target_object object
,
1209 const char *annex
, gdb_byte
*readbuf
,
1210 const gdb_byte
*writebuf
, ULONGEST offset
, LONGEST len
)
1214 case TARGET_OBJECT_MEMORY
:
1215 return inf_ttrace_xfer_memory (offset
, len
, readbuf
, writebuf
);
1217 case TARGET_OBJECT_UNWIND_TABLE
:
1220 case TARGET_OBJECT_AUXV
:
1223 case TARGET_OBJECT_WCOOKIE
:
1231 /* Print status information about what we're accessing. */
1234 inf_ttrace_files_info (struct target_ops
*ignore
)
1236 struct inferior
*inf
= current_inferior ();
1237 printf_filtered (_("\tUsing the running image of %s %s.\n"),
1238 inf
->attach_flag
? "attached" : "child",
1239 target_pid_to_str (inferior_ptid
));
1243 inf_ttrace_thread_alive (struct target_ops
*ops
, ptid_t ptid
)
1248 /* Return a string describing the state of the thread specified by
1252 inf_ttrace_extra_thread_info (struct thread_info
*info
)
1254 struct inf_ttrace_private_thread_info
* private =
1255 (struct inf_ttrace_private_thread_info
*) info
->private;
1257 if (private != NULL
&& private->dying
)
1264 inf_ttrace_pid_to_str (struct target_ops
*ops
, ptid_t ptid
)
1266 pid_t pid
= ptid_get_pid (ptid
);
1267 lwpid_t lwpid
= ptid_get_lwp (ptid
);
1268 static char buf
[128];
1271 xsnprintf (buf
, sizeof buf
, "process %ld",
1274 xsnprintf (buf
, sizeof buf
, "process %ld, lwp %ld",
1275 (long) pid
, (long) lwpid
);
1281 inf_ttrace_target (void)
1283 struct target_ops
*t
= inf_child_target ();
1285 t
->to_attach
= inf_ttrace_attach
;
1286 t
->to_detach
= inf_ttrace_detach
;
1287 t
->to_resume
= inf_ttrace_resume
;
1288 t
->to_wait
= inf_ttrace_wait
;
1289 t
->to_files_info
= inf_ttrace_files_info
;
1290 t
->to_can_use_hw_breakpoint
= inf_ttrace_can_use_hw_breakpoint
;
1291 t
->to_insert_watchpoint
= inf_ttrace_insert_watchpoint
;
1292 t
->to_remove_watchpoint
= inf_ttrace_remove_watchpoint
;
1293 t
->to_stopped_by_watchpoint
= inf_ttrace_stopped_by_watchpoint
;
1294 t
->to_region_ok_for_hw_watchpoint
=
1295 inf_ttrace_region_ok_for_hw_watchpoint
;
1296 t
->to_kill
= inf_ttrace_kill
;
1297 t
->to_create_inferior
= inf_ttrace_create_inferior
;
1298 t
->to_follow_fork
= inf_ttrace_follow_fork
;
1299 t
->to_mourn_inferior
= inf_ttrace_mourn_inferior
;
1300 t
->to_thread_alive
= inf_ttrace_thread_alive
;
1301 t
->to_extra_thread_info
= inf_ttrace_extra_thread_info
;
1302 t
->to_pid_to_str
= inf_ttrace_pid_to_str
;
1303 t
->to_xfer_partial
= inf_ttrace_xfer_partial
;
1310 /* Prevent warning from -Wmissing-prototypes. */
1311 void _initialize_hppa_hpux_nat (void);
1314 _initialize_inf_ttrace (void)
1317 inf_ttrace_page_dict
.pagesize
= getpagesize();