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"
33 #include "gdb_assert.h"
34 #include "gdb_string.h"
36 #include <sys/ttrace.h>
39 #include "inf-child.h"
40 #include "inf-ttrace.h"
42 /* HACK: Save the ttrace ops returned by inf_ttrace_target. */
43 static struct target_ops
*ttrace_ops_hack
;
46 /* HP-UX uses a threading model where each user-space thread
47 corresponds to a kernel thread. These kernel threads are called
48 lwps. The ttrace(2) interface gives us almost full control over
49 the threads, which makes it very easy to support them in GDB. We
50 identify the threads by process ID and lwp ID. The ttrace(2) also
51 provides us with a thread's user ID (in the `tts_user_tid' member
52 of `ttstate_t') but we don't use that (yet) as it isn't necessary
53 to uniquely label the thread. */
55 /* Number of active lwps. */
56 static int inf_ttrace_num_lwps
;
59 /* On HP-UX versions that have the ttrace(2) system call, we can
60 implement "hardware" watchpoints by fiddling with the protection of
61 pages in the address space that contain the variable being watched.
62 In order to implement this, we keep a dictionary of pages for which
63 we have changed the protection. */
65 struct inf_ttrace_page
67 CORE_ADDR addr
; /* Page address. */
68 int prot
; /* Protection. */
69 int refcount
; /* Reference count. */
70 struct inf_ttrace_page
*next
;
71 struct inf_ttrace_page
*prev
;
74 struct inf_ttrace_page_dict
76 struct inf_ttrace_page buckets
[128];
77 int pagesize
; /* Page size. */
78 int count
; /* Number of pages in this dictionary. */
79 } inf_ttrace_page_dict
;
81 struct inf_ttrace_private_thread_info
86 /* Number of lwps that are currently in a system call. */
87 static int inf_ttrace_num_lwps_in_syscall
;
89 /* Flag to indicate whether we should re-enable page protections after
91 static int inf_ttrace_reenable_page_protections
;
93 /* Enable system call events for process PID. */
96 inf_ttrace_enable_syscall_events (pid_t pid
)
101 gdb_assert (inf_ttrace_num_lwps_in_syscall
== 0);
103 if (ttrace (TT_PROC_GET_EVENT_MASK
, pid
, 0,
104 (uintptr_t)&tte
, sizeof tte
, 0) == -1)
105 perror_with_name (("ttrace"));
107 tte
.tte_events
|= (TTEVT_SYSCALL_ENTRY
| TTEVT_SYSCALL_RETURN
);
109 if (ttrace (TT_PROC_SET_EVENT_MASK
, pid
, 0,
110 (uintptr_t)&tte
, sizeof tte
, 0) == -1)
111 perror_with_name (("ttrace"));
113 if (ttrace (TT_PROC_GET_FIRST_LWP_STATE
, pid
, 0,
114 (uintptr_t)&tts
, sizeof tts
, 0) == -1)
115 perror_with_name (("ttrace"));
117 if (tts
.tts_flags
& TTS_INSYSCALL
)
118 inf_ttrace_num_lwps_in_syscall
++;
120 /* FIXME: Handle multiple threads. */
123 /* Disable system call events for process PID. */
126 inf_ttrace_disable_syscall_events (pid_t pid
)
130 gdb_assert (inf_ttrace_page_dict
.count
== 0);
132 if (ttrace (TT_PROC_GET_EVENT_MASK
, pid
, 0,
133 (uintptr_t)&tte
, sizeof tte
, 0) == -1)
134 perror_with_name (("ttrace"));
136 tte
.tte_events
&= ~(TTEVT_SYSCALL_ENTRY
| TTEVT_SYSCALL_RETURN
);
138 if (ttrace (TT_PROC_SET_EVENT_MASK
, pid
, 0,
139 (uintptr_t)&tte
, sizeof tte
, 0) == -1)
140 perror_with_name (("ttrace"));
142 inf_ttrace_num_lwps_in_syscall
= 0;
145 /* Get information about the page at address ADDR for process PID from
148 static struct inf_ttrace_page
*
149 inf_ttrace_get_page (pid_t pid
, CORE_ADDR addr
)
151 const int num_buckets
= ARRAY_SIZE (inf_ttrace_page_dict
.buckets
);
152 const int pagesize
= inf_ttrace_page_dict
.pagesize
;
154 struct inf_ttrace_page
*page
;
156 bucket
= (addr
/ pagesize
) % num_buckets
;
157 page
= &inf_ttrace_page_dict
.buckets
[bucket
];
160 if (page
->addr
== addr
)
169 /* Add the page at address ADDR for process PID to the dictionary. */
171 static struct inf_ttrace_page
*
172 inf_ttrace_add_page (pid_t pid
, CORE_ADDR addr
)
174 const int num_buckets
= ARRAY_SIZE (inf_ttrace_page_dict
.buckets
);
175 const int pagesize
= inf_ttrace_page_dict
.pagesize
;
177 struct inf_ttrace_page
*page
;
178 struct inf_ttrace_page
*prev
= NULL
;
180 bucket
= (addr
/ pagesize
) % num_buckets
;
181 page
= &inf_ttrace_page_dict
.buckets
[bucket
];
184 if (page
->addr
== addr
)
195 if (ttrace (TT_PROC_GET_MPROTECT
, pid
, 0,
196 addr
, 0, (uintptr_t)&prot
) == -1)
197 perror_with_name (("ttrace"));
199 page
= XMALLOC (struct inf_ttrace_page
);
208 inf_ttrace_page_dict
.count
++;
209 if (inf_ttrace_page_dict
.count
== 1)
210 inf_ttrace_enable_syscall_events (pid
);
212 if (inf_ttrace_num_lwps_in_syscall
== 0)
214 if (ttrace (TT_PROC_SET_MPROTECT
, pid
, 0,
215 addr
, pagesize
, prot
& ~PROT_WRITE
) == -1)
216 perror_with_name (("ttrace"));
223 /* Insert the page at address ADDR of process PID to the dictionary. */
226 inf_ttrace_insert_page (pid_t pid
, CORE_ADDR addr
)
228 struct inf_ttrace_page
*page
;
230 page
= inf_ttrace_get_page (pid
, addr
);
232 page
= inf_ttrace_add_page (pid
, addr
);
237 /* Remove the page at address ADDR of process PID from the dictionary. */
240 inf_ttrace_remove_page (pid_t pid
, CORE_ADDR addr
)
242 const int pagesize
= inf_ttrace_page_dict
.pagesize
;
243 struct inf_ttrace_page
*page
;
245 page
= inf_ttrace_get_page (pid
, addr
);
248 gdb_assert (page
->refcount
>= 0);
250 if (page
->refcount
== 0)
252 if (inf_ttrace_num_lwps_in_syscall
== 0)
254 if (ttrace (TT_PROC_SET_MPROTECT
, pid
, 0,
255 addr
, pagesize
, page
->prot
) == -1)
256 perror_with_name (("ttrace"));
259 inf_ttrace_page_dict
.count
--;
260 if (inf_ttrace_page_dict
.count
== 0)
261 inf_ttrace_disable_syscall_events (pid
);
263 page
->prev
->next
= page
->next
;
265 page
->next
->prev
= page
->prev
;
271 /* Mask the bits in PROT from the page protections that are currently
272 in the dictionary for process PID. */
275 inf_ttrace_mask_page_protections (pid_t pid
, int prot
)
277 const int num_buckets
= ARRAY_SIZE (inf_ttrace_page_dict
.buckets
);
278 const int pagesize
= inf_ttrace_page_dict
.pagesize
;
281 for (bucket
= 0; bucket
< num_buckets
; bucket
++)
283 struct inf_ttrace_page
*page
;
285 page
= inf_ttrace_page_dict
.buckets
[bucket
].next
;
288 if (ttrace (TT_PROC_SET_MPROTECT
, pid
, 0,
289 page
->addr
, pagesize
, page
->prot
& ~prot
) == -1)
290 perror_with_name (("ttrace"));
297 /* Write-protect the pages in the dictionary for process PID. */
300 inf_ttrace_enable_page_protections (pid_t pid
)
302 inf_ttrace_mask_page_protections (pid
, PROT_WRITE
);
305 /* Restore the protection of the pages in the dictionary for process
309 inf_ttrace_disable_page_protections (pid_t pid
)
311 inf_ttrace_mask_page_protections (pid
, 0);
314 /* Insert a "hardware" watchpoint for LEN bytes at address ADDR of
318 inf_ttrace_insert_watchpoint (CORE_ADDR addr
, int len
, int type
)
320 const int pagesize
= inf_ttrace_page_dict
.pagesize
;
321 pid_t pid
= ptid_get_pid (inferior_ptid
);
326 gdb_assert (type
== hw_write
);
328 page_addr
= (addr
/ pagesize
) * pagesize
;
329 num_pages
= (len
+ pagesize
- 1) / pagesize
;
331 for (page
= 0; page
< num_pages
; page
++, page_addr
+= pagesize
)
332 inf_ttrace_insert_page (pid
, page_addr
);
337 /* Remove a "hardware" watchpoint for LEN bytes at address ADDR of
341 inf_ttrace_remove_watchpoint (CORE_ADDR addr
, int len
, int type
)
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 (int type
, int len
, int ot
)
363 return (type
== bp_hardware_watchpoint
);
367 inf_ttrace_region_ok_for_hw_watchpoint (CORE_ADDR addr
, int len
)
372 /* Return non-zero if the current inferior was (potentially) stopped
373 by hitting a "hardware" watchpoint. */
376 inf_ttrace_stopped_by_watchpoint (void)
378 pid_t pid
= ptid_get_pid (inferior_ptid
);
379 lwpid_t lwpid
= ptid_get_lwp (inferior_ptid
);
382 if (inf_ttrace_page_dict
.count
> 0)
384 if (ttrace (TT_LWP_GET_STATE
, pid
, lwpid
,
385 (uintptr_t)&tts
, sizeof tts
, 0) == -1)
386 perror_with_name (("ttrace"));
388 if (tts
.tts_event
== TTEVT_SIGNAL
389 && tts
.tts_u
.tts_signal
.tts_signo
== SIGBUS
)
391 const int pagesize
= inf_ttrace_page_dict
.pagesize
;
392 void *addr
= tts
.tts_u
.tts_signal
.tts_siginfo
.si_addr
;
393 CORE_ADDR page_addr
= ((uintptr_t)addr
/ pagesize
) * pagesize
;
395 if (inf_ttrace_get_page (pid
, page_addr
))
404 /* When tracking a vfork(2), we cannot detach from the parent until
405 after the child has called exec(3) or has exited. If we are still
406 attached to the parent, this variable will be set to the process ID
407 of the parent. Otherwise it will be set to zero. */
408 static pid_t inf_ttrace_vfork_ppid
= -1;
411 inf_ttrace_follow_fork (struct target_ops
*ops
, int follow_child
)
414 lwpid_t lwpid
, flwpid
;
416 struct thread_info
*last_tp
= NULL
;
417 struct breakpoint
*step_resume_breakpoint
= NULL
;
418 CORE_ADDR step_range_start
= 0, step_range_end
= 0;
419 struct frame_id step_frame_id
= null_frame_id
;
421 /* FIXME: kettenis/20050720: This stuff should really be passed as
422 an argument by our caller. */
425 struct target_waitstatus status
;
427 get_last_target_status (&ptid
, &status
);
428 gdb_assert (status
.kind
== TARGET_WAITKIND_FORKED
429 || status
.kind
== TARGET_WAITKIND_VFORKED
);
431 pid
= ptid_get_pid (ptid
);
432 lwpid
= ptid_get_lwp (ptid
);
433 last_tp
= find_thread_pid (ptid
);
436 /* Get all important details that core GDB doesn't (and shouldn't)
438 if (ttrace (TT_LWP_GET_STATE
, pid
, lwpid
,
439 (uintptr_t)&tts
, sizeof tts
, 0) == -1)
440 perror_with_name (("ttrace"));
442 gdb_assert (tts
.tts_event
== TTEVT_FORK
|| tts
.tts_event
== TTEVT_VFORK
);
444 if (tts
.tts_u
.tts_fork
.tts_isparent
)
447 lwpid
= tts
.tts_lwpid
;
448 fpid
= tts
.tts_u
.tts_fork
.tts_fpid
;
449 flwpid
= tts
.tts_u
.tts_fork
.tts_flwpid
;
453 pid
= tts
.tts_u
.tts_fork
.tts_fpid
;
454 lwpid
= tts
.tts_u
.tts_fork
.tts_flwpid
;
456 flwpid
= tts
.tts_lwpid
;
461 /* Copy user stepping state to the new inferior thread. */
462 step_resume_breakpoint
= last_tp
->step_resume_breakpoint
;
463 step_range_start
= last_tp
->step_range_start
;
464 step_range_end
= last_tp
->step_range_end
;
465 step_frame_id
= last_tp
->step_frame_id
;
467 /* Otherwise, deleting the parent would get rid of this
469 last_tp
->step_resume_breakpoint
= NULL
;
471 inferior_ptid
= ptid_build (fpid
, flwpid
, 0);
473 detach_breakpoints (pid
);
475 target_terminal_ours ();
476 fprintf_unfiltered (gdb_stdlog
, _("\
477 Attaching after fork to child process %ld.\n"), (long)fpid
);
481 inferior_ptid
= ptid_build (pid
, lwpid
, 0);
482 detach_breakpoints (fpid
);
484 target_terminal_ours ();
485 fprintf_unfiltered (gdb_stdlog
, _("\
486 Detaching after fork from child process %ld.\n"), (long)fpid
);
489 if (tts
.tts_event
== TTEVT_VFORK
)
491 gdb_assert (!tts
.tts_u
.tts_fork
.tts_isparent
);
495 /* We can't detach from the parent yet. */
496 inf_ttrace_vfork_ppid
= pid
;
498 reattach_breakpoints (fpid
);
502 if (ttrace (TT_PROC_DETACH
, fpid
, 0, 0, 0, 0) == -1)
503 perror_with_name (("ttrace"));
505 /* Wait till we get the TTEVT_VFORK event in the parent.
506 This indicates that the child has called exec(3) or has
507 exited and that the parent is ready to be traced again. */
508 if (ttrace_wait (pid
, lwpid
, TTRACE_WAITOK
, &tts
, sizeof tts
) == -1)
509 perror_with_name (("ttrace_wait"));
510 gdb_assert (tts
.tts_event
== TTEVT_VFORK
);
511 gdb_assert (tts
.tts_u
.tts_fork
.tts_isparent
);
513 reattach_breakpoints (pid
);
518 gdb_assert (tts
.tts_u
.tts_fork
.tts_isparent
);
522 if (ttrace (TT_PROC_DETACH
, pid
, 0, 0, 0, 0) == -1)
523 perror_with_name (("ttrace"));
527 if (ttrace (TT_PROC_DETACH
, fpid
, 0, 0, 0, 0) == -1)
528 perror_with_name (("ttrace"));
534 struct thread_info
*ti
;
536 /* The child will start out single-threaded. */
537 inf_ttrace_num_lwps
= 1;
538 inf_ttrace_num_lwps_in_syscall
= 0;
541 delete_thread_silent (ptid_build (pid
, lwpid
, 0));
542 detach_inferior (pid
);
544 /* Add child thread. inferior_ptid was already set above. */
545 ti
= add_thread_silent (inferior_ptid
);
547 xmalloc (sizeof (struct inf_ttrace_private_thread_info
));
548 memset (ti
->private, 0,
549 sizeof (struct inf_ttrace_private_thread_info
));
551 ti
->step_resume_breakpoint
= step_resume_breakpoint
;
552 ti
->step_range_start
= step_range_start
;
553 ti
->step_range_end
= step_range_end
;
554 ti
->step_frame_id
= step_frame_id
;
556 /* Reset breakpoints in the child as appropriate. */
557 follow_inferior_reset_breakpoints ();
564 /* File descriptors for pipes used as semaphores during initial
565 startup of an inferior. */
566 static int inf_ttrace_pfd1
[2];
567 static int inf_ttrace_pfd2
[2];
570 do_cleanup_pfds (void *dummy
)
572 close (inf_ttrace_pfd1
[0]);
573 close (inf_ttrace_pfd1
[1]);
574 close (inf_ttrace_pfd2
[0]);
575 close (inf_ttrace_pfd2
[1]);
579 inf_ttrace_prepare (void)
581 if (pipe (inf_ttrace_pfd1
) == -1)
582 perror_with_name (("pipe"));
584 if (pipe (inf_ttrace_pfd2
) == -1)
586 close (inf_ttrace_pfd1
[0]);
587 close (inf_ttrace_pfd2
[0]);
588 perror_with_name (("pipe"));
592 /* Prepare to be traced. */
597 struct cleanup
*old_chain
= make_cleanup (do_cleanup_pfds
, 0);
600 /* "Trace me, Dr. Memory!" */
601 if (ttrace (TT_PROC_SETTRC
, 0, 0, 0, TT_VERSION
, 0) == -1)
602 perror_with_name (("ttrace"));
604 /* Tell our parent that we are ready to be traced. */
605 if (write (inf_ttrace_pfd1
[1], &c
, sizeof c
) != sizeof c
)
606 perror_with_name (("write"));
608 /* Wait until our parent has set the initial event mask. */
609 if (read (inf_ttrace_pfd2
[0], &c
, sizeof c
) != sizeof c
)
610 perror_with_name (("read"));
612 do_cleanups (old_chain
);
615 /* Start tracing PID. */
618 inf_ttrace_him (int pid
)
620 struct cleanup
*old_chain
= make_cleanup (do_cleanup_pfds
, 0);
624 /* Wait until our child is ready to be traced. */
625 if (read (inf_ttrace_pfd1
[0], &c
, sizeof c
) != sizeof c
)
626 perror_with_name (("read"));
628 /* Set the initial event mask. */
629 memset (&tte
, 0, sizeof (tte
));
630 tte
.tte_events
|= TTEVT_EXEC
| TTEVT_EXIT
| TTEVT_FORK
| TTEVT_VFORK
;
631 tte
.tte_events
|= TTEVT_LWP_CREATE
| TTEVT_LWP_EXIT
| TTEVT_LWP_TERMINATE
;
632 #ifdef TTEVT_BPT_SSTEP
633 tte
.tte_events
|= TTEVT_BPT_SSTEP
;
635 tte
.tte_opts
|= TTEO_PROC_INHERIT
;
636 if (ttrace (TT_PROC_SET_EVENT_MASK
, pid
, 0,
637 (uintptr_t)&tte
, sizeof tte
, 0) == -1)
638 perror_with_name (("ttrace"));
640 /* Tell our child that we have set the initial event mask. */
641 if (write (inf_ttrace_pfd2
[1], &c
, sizeof c
) != sizeof c
)
642 perror_with_name (("write"));
644 do_cleanups (old_chain
);
646 push_target (ttrace_ops_hack
);
648 /* On some targets, there must be some explicit synchronization
649 between the parent and child processes after the debugger forks,
650 and before the child execs the debuggee program. This call
651 basically gives permission for the child to exec. */
653 target_acknowledge_created_inferior (pid
);
655 /* START_INFERIOR_TRAPS_EXPECTED is defined in inferior.h, and will
656 be 1 or 2 depending on whether we're starting without or with a
658 startup_inferior (START_INFERIOR_TRAPS_EXPECTED
);
660 /* On some targets, there must be some explicit actions taken after
661 the inferior has been started up. */
662 target_post_startup_inferior (pid_to_ptid (pid
));
666 inf_ttrace_create_inferior (struct target_ops
*ops
, char *exec_file
,
667 char *allargs
, char **env
, int from_tty
)
669 gdb_assert (inf_ttrace_num_lwps
== 0);
670 gdb_assert (inf_ttrace_num_lwps_in_syscall
== 0);
671 gdb_assert (inf_ttrace_page_dict
.count
== 0);
672 gdb_assert (inf_ttrace_reenable_page_protections
== 0);
673 gdb_assert (inf_ttrace_vfork_ppid
== -1);
675 fork_inferior (exec_file
, allargs
, env
, inf_ttrace_me
, inf_ttrace_him
,
676 inf_ttrace_prepare
, NULL
);
680 inf_ttrace_mourn_inferior (struct target_ops
*ops
)
682 const int num_buckets
= ARRAY_SIZE (inf_ttrace_page_dict
.buckets
);
685 inf_ttrace_num_lwps
= 0;
686 inf_ttrace_num_lwps_in_syscall
= 0;
688 for (bucket
= 0; bucket
< num_buckets
; bucket
++)
690 struct inf_ttrace_page
*page
;
691 struct inf_ttrace_page
*next
;
693 page
= inf_ttrace_page_dict
.buckets
[bucket
].next
;
701 inf_ttrace_page_dict
.count
= 0;
703 unpush_target (ttrace_ops_hack
);
704 generic_mourn_inferior ();
708 inf_ttrace_attach (struct target_ops
*ops
, char *args
, int from_tty
)
714 struct inferior
*inf
;
717 error_no_arg (_("process-id to attach"));
720 pid
= strtol (args
, &dummy
, 0);
721 if (pid
== 0 && args
== dummy
)
722 error (_("Illegal process-id: %s."), args
);
724 if (pid
== getpid ()) /* Trying to masturbate? */
725 error (_("I refuse to debug myself!"));
729 exec_file
= get_exec_file (0);
732 printf_unfiltered (_("Attaching to program: %s, %s\n"), exec_file
,
733 target_pid_to_str (pid_to_ptid (pid
)));
735 printf_unfiltered (_("Attaching to %s\n"),
736 target_pid_to_str (pid_to_ptid (pid
)));
738 gdb_flush (gdb_stdout
);
741 gdb_assert (inf_ttrace_num_lwps
== 0);
742 gdb_assert (inf_ttrace_num_lwps_in_syscall
== 0);
743 gdb_assert (inf_ttrace_vfork_ppid
== -1);
745 if (ttrace (TT_PROC_ATTACH
, pid
, 0, TT_KILL_ON_EXIT
, TT_VERSION
, 0) == -1)
746 perror_with_name (("ttrace"));
748 inf
= add_inferior (pid
);
749 inf
->attach_flag
= 1;
751 /* Set the initial event mask. */
752 memset (&tte
, 0, sizeof (tte
));
753 tte
.tte_events
|= TTEVT_EXEC
| TTEVT_EXIT
| TTEVT_FORK
| TTEVT_VFORK
;
754 tte
.tte_events
|= TTEVT_LWP_CREATE
| TTEVT_LWP_EXIT
| TTEVT_LWP_TERMINATE
;
755 #ifdef TTEVT_BPT_SSTEP
756 tte
.tte_events
|= TTEVT_BPT_SSTEP
;
758 tte
.tte_opts
|= TTEO_PROC_INHERIT
;
759 if (ttrace (TT_PROC_SET_EVENT_MASK
, pid
, 0,
760 (uintptr_t)&tte
, sizeof tte
, 0) == -1)
761 perror_with_name (("ttrace"));
763 push_target (ttrace_ops_hack
);
765 /* We'll bump inf_ttrace_num_lwps up and add the private data to the
766 thread as soon as we get to inf_ttrace_wait. At this point, we
767 don't have lwpid info yet. */
768 inferior_ptid
= pid_to_ptid (pid
);
769 add_thread_silent (inferior_ptid
);
773 inf_ttrace_detach (struct target_ops
*ops
, char *args
, int from_tty
)
775 pid_t pid
= ptid_get_pid (inferior_ptid
);
780 char *exec_file
= get_exec_file (0);
783 printf_unfiltered (_("Detaching from program: %s, %s\n"), exec_file
,
784 target_pid_to_str (pid_to_ptid (pid
)));
785 gdb_flush (gdb_stdout
);
790 /* ??? The HP-UX 11.0 ttrace(2) manual page doesn't mention that we
791 can pass a signal number here. Does this really work? */
792 if (ttrace (TT_PROC_DETACH
, pid
, 0, 0, sig
, 0) == -1)
793 perror_with_name (("ttrace"));
795 if (inf_ttrace_vfork_ppid
!= -1)
797 if (ttrace (TT_PROC_DETACH
, inf_ttrace_vfork_ppid
, 0, 0, 0, 0) == -1)
798 perror_with_name (("ttrace"));
799 inf_ttrace_vfork_ppid
= -1;
802 inf_ttrace_num_lwps
= 0;
803 inf_ttrace_num_lwps_in_syscall
= 0;
805 inferior_ptid
= null_ptid
;
806 detach_inferior (pid
);
808 unpush_target (ttrace_ops_hack
);
812 inf_ttrace_kill (void)
814 pid_t pid
= ptid_get_pid (inferior_ptid
);
819 if (ttrace (TT_PROC_EXIT
, pid
, 0, 0, 0, 0) == -1)
820 perror_with_name (("ttrace"));
821 /* ??? Is it necessary to call ttrace_wait() here? */
823 if (inf_ttrace_vfork_ppid
!= -1)
825 if (ttrace (TT_PROC_DETACH
, inf_ttrace_vfork_ppid
, 0, 0, 0, 0) == -1)
826 perror_with_name (("ttrace"));
827 inf_ttrace_vfork_ppid
= -1;
830 target_mourn_inferior ();
833 /* Check is a dying thread is dead by now, and delete it from GDBs
834 thread list if so. */
836 inf_ttrace_delete_dead_threads_callback (struct thread_info
*info
, void *arg
)
839 struct inf_ttrace_private_thread_info
*p
;
841 if (is_exited (info
->ptid
))
844 lwpid
= ptid_get_lwp (info
->ptid
);
845 p
= (struct inf_ttrace_private_thread_info
*) info
->private;
847 /* Check if an lwp that was dying is still there or not. */
848 if (p
->dying
&& (kill (lwpid
, 0) == -1))
850 delete_thread (info
->ptid
);
855 /* Resume the lwp pointed to by INFO, with REQUEST, and pass it signal
859 inf_ttrace_resume_lwp (struct thread_info
*info
, ttreq_t request
, int sig
)
861 pid_t pid
= ptid_get_pid (info
->ptid
);
862 lwpid_t lwpid
= ptid_get_lwp (info
->ptid
);
864 if (ttrace (request
, pid
, lwpid
, TT_NOPC
, sig
, 0) == -1)
866 struct inf_ttrace_private_thread_info
*p
867 = (struct inf_ttrace_private_thread_info
*) info
->private;
868 if (p
->dying
&& errno
== EPROTO
)
869 /* This is expected, it means the dying lwp is really gone
870 by now. If ttrace had an event to inform the debugger
871 the lwp is really gone, this wouldn't be needed. */
872 delete_thread (info
->ptid
);
874 /* This was really unexpected. */
875 perror_with_name (("ttrace"));
879 /* Callback for iterate_over_threads. */
882 inf_ttrace_resume_callback (struct thread_info
*info
, void *arg
)
884 if (!ptid_equal (info
->ptid
, inferior_ptid
) && !is_exited (info
->ptid
))
885 inf_ttrace_resume_lwp (info
, TT_LWP_CONTINUE
, 0);
891 inf_ttrace_resume (ptid_t ptid
, int step
, enum target_signal signal
)
894 ttreq_t request
= step
? TT_LWP_SINGLE
: TT_LWP_CONTINUE
;
895 int sig
= target_signal_to_host (signal
);
896 struct thread_info
*info
;
898 /* A specific PTID means `step only this process id'. */
899 resume_all
= (ptid_equal (ptid
, minus_one_ptid
));
901 /* If resuming all threads, it's the current thread that should be
902 handled specially. */
904 ptid
= inferior_ptid
;
906 info
= find_thread_pid (ptid
);
907 inf_ttrace_resume_lwp (info
, request
, sig
);
910 /* Let all the other threads run too. */
911 iterate_over_threads (inf_ttrace_resume_callback
, NULL
);
915 inf_ttrace_wait (ptid_t ptid
, struct target_waitstatus
*ourstatus
)
917 pid_t pid
= ptid_get_pid (ptid
);
918 lwpid_t lwpid
= ptid_get_lwp (ptid
);
920 struct thread_info
*ti
;
923 /* Until proven otherwise. */
924 ourstatus
->kind
= TARGET_WAITKIND_SPURIOUS
;
929 gdb_assert (pid
!= 0 || lwpid
== 0);
935 if (ttrace_wait (pid
, lwpid
, TTRACE_WAITOK
, &tts
, sizeof tts
) == -1)
936 perror_with_name (("ttrace_wait"));
938 if (tts
.tts_event
== TTEVT_VFORK
&& tts
.tts_u
.tts_fork
.tts_isparent
)
940 if (inf_ttrace_vfork_ppid
!= -1)
942 gdb_assert (inf_ttrace_vfork_ppid
== tts
.tts_pid
);
944 if (ttrace (TT_PROC_DETACH
, tts
.tts_pid
, 0, 0, 0, 0) == -1)
945 perror_with_name (("ttrace"));
946 inf_ttrace_vfork_ppid
= -1;
949 tts
.tts_event
= TTEVT_NONE
;
952 clear_sigint_trap ();
954 while (tts
.tts_event
== TTEVT_NONE
);
956 /* Now that we've waited, we can re-enable the page protections. */
957 if (inf_ttrace_reenable_page_protections
)
959 gdb_assert (inf_ttrace_num_lwps_in_syscall
== 0);
960 inf_ttrace_enable_page_protections (tts
.tts_pid
);
961 inf_ttrace_reenable_page_protections
= 0;
964 ptid
= ptid_build (tts
.tts_pid
, tts
.tts_lwpid
, 0);
966 if (inf_ttrace_num_lwps
== 0)
968 struct thread_info
*ti
;
970 inf_ttrace_num_lwps
= 1;
972 /* This is the earliest we hear about the lwp member of
973 INFERIOR_PTID, after an attach or fork_inferior. */
974 gdb_assert (ptid_get_lwp (inferior_ptid
) == 0);
976 /* We haven't set the private member on the main thread yet. Do
978 ti
= find_thread_pid (inferior_ptid
);
979 gdb_assert (ti
!= NULL
&& ti
->private == NULL
);
981 xmalloc (sizeof (struct inf_ttrace_private_thread_info
));
982 memset (ti
->private, 0,
983 sizeof (struct inf_ttrace_private_thread_info
));
985 /* Notify the core that this ptid changed. This changes
986 inferior_ptid as well. */
987 thread_change_ptid (inferior_ptid
, ptid
);
990 switch (tts
.tts_event
)
992 #ifdef TTEVT_BPT_SSTEP
993 case TTEVT_BPT_SSTEP
:
994 /* Make it look like a breakpoint. */
995 ourstatus
->kind
= TARGET_WAITKIND_STOPPED
;
996 ourstatus
->value
.sig
= TARGET_SIGNAL_TRAP
;
1001 ourstatus
->kind
= TARGET_WAITKIND_EXECD
;
1002 ourstatus
->value
.execd_pathname
=
1003 xmalloc (tts
.tts_u
.tts_exec
.tts_pathlen
+ 1);
1004 if (ttrace (TT_PROC_GET_PATHNAME
, tts
.tts_pid
, 0,
1005 (uintptr_t)ourstatus
->value
.execd_pathname
,
1006 tts
.tts_u
.tts_exec
.tts_pathlen
, 0) == -1)
1007 perror_with_name (("ttrace"));
1008 ourstatus
->value
.execd_pathname
[tts
.tts_u
.tts_exec
.tts_pathlen
] = 0;
1010 /* At this point, all inserted breakpoints are gone. Doing this
1011 as soon as we detect an exec prevents the badness of deleting
1012 a breakpoint writing the current "shadow contents" to lift
1013 the bp. That shadow is NOT valid after an exec. */
1014 mark_breakpoints_out ();
1018 store_waitstatus (ourstatus
, tts
.tts_u
.tts_exit
.tts_exitcode
);
1019 inf_ttrace_num_lwps
= 0;
1023 related_ptid
= ptid_build (tts
.tts_u
.tts_fork
.tts_fpid
,
1024 tts
.tts_u
.tts_fork
.tts_flwpid
, 0);
1026 ourstatus
->kind
= TARGET_WAITKIND_FORKED
;
1027 ourstatus
->value
.related_pid
= related_ptid
;
1029 /* Make sure the other end of the fork is stopped too. */
1030 if (ttrace_wait (tts
.tts_u
.tts_fork
.tts_fpid
,
1031 tts
.tts_u
.tts_fork
.tts_flwpid
,
1032 TTRACE_WAITOK
, &tts
, sizeof tts
) == -1)
1033 perror_with_name (("ttrace_wait"));
1035 gdb_assert (tts
.tts_event
== TTEVT_FORK
);
1036 if (tts
.tts_u
.tts_fork
.tts_isparent
)
1038 related_ptid
= ptid_build (tts
.tts_u
.tts_fork
.tts_fpid
,
1039 tts
.tts_u
.tts_fork
.tts_flwpid
, 0);
1040 ptid
= ptid_build (tts
.tts_pid
, tts
.tts_lwpid
, 0);
1041 ourstatus
->value
.related_pid
= related_ptid
;
1046 gdb_assert (!tts
.tts_u
.tts_fork
.tts_isparent
);
1048 related_ptid
= ptid_build (tts
.tts_u
.tts_fork
.tts_fpid
,
1049 tts
.tts_u
.tts_fork
.tts_flwpid
, 0);
1051 ourstatus
->kind
= TARGET_WAITKIND_VFORKED
;
1052 ourstatus
->value
.related_pid
= related_ptid
;
1054 /* HACK: To avoid touching the parent during the vfork, switch
1056 inferior_ptid
= ptid
;
1059 case TTEVT_LWP_CREATE
:
1060 lwpid
= tts
.tts_u
.tts_thread
.tts_target_lwpid
;
1061 ptid
= ptid_build (tts
.tts_pid
, lwpid
, 0);
1062 ti
= add_thread (ptid
);
1064 xmalloc (sizeof (struct inf_ttrace_private_thread_info
));
1065 memset (ti
->private, 0,
1066 sizeof (struct inf_ttrace_private_thread_info
));
1067 inf_ttrace_num_lwps
++;
1068 ptid
= ptid_build (tts
.tts_pid
, tts
.tts_lwpid
, 0);
1069 /* Let the lwp_create-caller thread continue. */
1070 ttrace (TT_LWP_CONTINUE
, ptid_get_pid (ptid
),
1071 ptid_get_lwp (ptid
), TT_NOPC
, 0, 0);
1072 /* Return without stopping the whole process. */
1073 ourstatus
->kind
= TARGET_WAITKIND_IGNORE
;
1076 case TTEVT_LWP_EXIT
:
1077 if (print_thread_events
)
1078 printf_unfiltered (_("[%s exited]\n"), target_pid_to_str (ptid
));
1079 ti
= find_thread_pid (ptid
);
1080 gdb_assert (ti
!= NULL
);
1081 ((struct inf_ttrace_private_thread_info
*)ti
->private)->dying
= 1;
1082 inf_ttrace_num_lwps
--;
1083 /* Let the thread really exit. */
1084 ttrace (TT_LWP_CONTINUE
, ptid_get_pid (ptid
),
1085 ptid_get_lwp (ptid
), TT_NOPC
, 0, 0);
1086 /* Return without stopping the whole process. */
1087 ourstatus
->kind
= TARGET_WAITKIND_IGNORE
;
1090 case TTEVT_LWP_TERMINATE
:
1091 lwpid
= tts
.tts_u
.tts_thread
.tts_target_lwpid
;
1092 ptid
= ptid_build (tts
.tts_pid
, lwpid
, 0);
1093 if (print_thread_events
)
1094 printf_unfiltered(_("[%s has been terminated]\n"),
1095 target_pid_to_str (ptid
));
1096 ti
= find_thread_pid (ptid
);
1097 gdb_assert (ti
!= NULL
);
1098 ((struct inf_ttrace_private_thread_info
*)ti
->private)->dying
= 1;
1099 inf_ttrace_num_lwps
--;
1101 /* Resume the lwp_terminate-caller thread. */
1102 ptid
= ptid_build (tts
.tts_pid
, tts
.tts_lwpid
, 0);
1103 ttrace (TT_LWP_CONTINUE
, ptid_get_pid (ptid
),
1104 ptid_get_lwp (ptid
), TT_NOPC
, 0, 0);
1105 /* Return without stopping the whole process. */
1106 ourstatus
->kind
= TARGET_WAITKIND_IGNORE
;
1110 ourstatus
->kind
= TARGET_WAITKIND_STOPPED
;
1111 ourstatus
->value
.sig
=
1112 target_signal_from_host (tts
.tts_u
.tts_signal
.tts_signo
);
1115 case TTEVT_SYSCALL_ENTRY
:
1116 gdb_assert (inf_ttrace_reenable_page_protections
== 0);
1117 inf_ttrace_num_lwps_in_syscall
++;
1118 if (inf_ttrace_num_lwps_in_syscall
== 1)
1120 /* A thread has just entered a system call. Disable any
1121 page protections as the kernel can't deal with them. */
1122 inf_ttrace_disable_page_protections (tts
.tts_pid
);
1124 ourstatus
->kind
= TARGET_WAITKIND_SYSCALL_ENTRY
;
1125 ourstatus
->value
.syscall_id
= tts
.tts_scno
;
1128 case TTEVT_SYSCALL_RETURN
:
1129 if (inf_ttrace_num_lwps_in_syscall
> 0)
1131 /* If the last thread has just left the system call, this
1132 would be a logical place to re-enable the page
1133 protections, but that doesn't work. We can't re-enable
1134 them until we've done another wait. */
1135 inf_ttrace_reenable_page_protections
=
1136 (inf_ttrace_num_lwps_in_syscall
== 1);
1137 inf_ttrace_num_lwps_in_syscall
--;
1139 ourstatus
->kind
= TARGET_WAITKIND_SYSCALL_RETURN
;
1140 ourstatus
->value
.syscall_id
= tts
.tts_scno
;
1144 gdb_assert (!"Unexpected ttrace event");
1148 /* Make sure all threads within the process are stopped. */
1149 if (ttrace (TT_PROC_STOP
, tts
.tts_pid
, 0, 0, 0, 0) == -1)
1150 perror_with_name (("ttrace"));
1152 /* Now that the whole process is stopped, check if any dying thread
1153 is really dead by now. If a dying thread is still alive, it will
1154 be stopped too, and will still show up in `info threads', tagged
1155 with "(Exiting)". We could make `info threads' prune dead
1156 threads instead via inf_ttrace_thread_alive, but doing this here
1157 has the advantage that a frontend is notificed sooner of thread
1158 exits. Note that a dying lwp is still alive, it still has to be
1159 resumed, like any other lwp. */
1160 iterate_over_threads (inf_ttrace_delete_dead_threads_callback
, NULL
);
1165 /* Transfer LEN bytes from ADDR in the inferior's memory into READBUF,
1166 and transfer LEN bytes from WRITEBUF into the inferior's memory at
1167 ADDR. Either READBUF or WRITEBUF may be null, in which case the
1168 corresponding transfer doesn't happen. Return the number of bytes
1169 actually transferred (which may be zero if an error occurs). */
1172 inf_ttrace_xfer_memory (CORE_ADDR addr
, ULONGEST len
,
1173 void *readbuf
, const void *writebuf
)
1175 pid_t pid
= ptid_get_pid (inferior_ptid
);
1177 /* HP-UX treats text space and data space differently. GDB however,
1178 doesn't really know the difference. Therefore we try both. Try
1179 text space before data space though because when we're writing
1180 into text space the instruction cache might need to be flushed. */
1183 && ttrace (TT_PROC_RDTEXT
, pid
, 0, addr
, len
, (uintptr_t)readbuf
) == -1
1184 && ttrace (TT_PROC_RDDATA
, pid
, 0, addr
, len
, (uintptr_t)readbuf
) == -1)
1188 && ttrace (TT_PROC_WRTEXT
, pid
, 0, addr
, len
, (uintptr_t)writebuf
) == -1
1189 && ttrace (TT_PROC_WRDATA
, pid
, 0, addr
, len
, (uintptr_t)writebuf
) == -1)
1196 inf_ttrace_xfer_partial (struct target_ops
*ops
, enum target_object object
,
1197 const char *annex
, gdb_byte
*readbuf
,
1198 const gdb_byte
*writebuf
, ULONGEST offset
, LONGEST len
)
1202 case TARGET_OBJECT_MEMORY
:
1203 return inf_ttrace_xfer_memory (offset
, len
, readbuf
, writebuf
);
1205 case TARGET_OBJECT_UNWIND_TABLE
:
1208 case TARGET_OBJECT_AUXV
:
1211 case TARGET_OBJECT_WCOOKIE
:
1219 /* Print status information about what we're accessing. */
1222 inf_ttrace_files_info (struct target_ops
*ignore
)
1224 struct inferior
*inf
= current_inferior ();
1225 printf_filtered (_("\tUsing the running image of %s %s.\n"),
1226 inf
->attach_flag
? "attached" : "child",
1227 target_pid_to_str (inferior_ptid
));
1231 inf_ttrace_thread_alive (ptid_t ptid
)
1236 /* Return a string describing the state of the thread specified by
1240 inf_ttrace_extra_thread_info (struct thread_info
*info
)
1242 struct inf_ttrace_private_thread_info
* private =
1243 (struct inf_ttrace_private_thread_info
*) info
->private;
1245 if (private != NULL
&& private->dying
)
1252 inf_ttrace_pid_to_str (ptid_t ptid
)
1254 pid_t pid
= ptid_get_pid (ptid
);
1255 lwpid_t lwpid
= ptid_get_lwp (ptid
);
1256 static char buf
[128];
1259 xsnprintf (buf
, sizeof buf
, "process %ld",
1262 xsnprintf (buf
, sizeof buf
, "process %ld, lwp %ld",
1263 (long) pid
, (long) lwpid
);
1269 inf_ttrace_target (void)
1271 struct target_ops
*t
= inf_child_target ();
1273 t
->to_attach
= inf_ttrace_attach
;
1274 t
->to_detach
= inf_ttrace_detach
;
1275 t
->to_resume
= inf_ttrace_resume
;
1276 t
->to_wait
= inf_ttrace_wait
;
1277 t
->to_files_info
= inf_ttrace_files_info
;
1278 t
->to_can_use_hw_breakpoint
= inf_ttrace_can_use_hw_breakpoint
;
1279 t
->to_insert_watchpoint
= inf_ttrace_insert_watchpoint
;
1280 t
->to_remove_watchpoint
= inf_ttrace_remove_watchpoint
;
1281 t
->to_stopped_by_watchpoint
= inf_ttrace_stopped_by_watchpoint
;
1282 t
->to_region_ok_for_hw_watchpoint
=
1283 inf_ttrace_region_ok_for_hw_watchpoint
;
1284 t
->to_kill
= inf_ttrace_kill
;
1285 t
->to_create_inferior
= inf_ttrace_create_inferior
;
1286 t
->to_follow_fork
= inf_ttrace_follow_fork
;
1287 t
->to_mourn_inferior
= inf_ttrace_mourn_inferior
;
1288 t
->to_thread_alive
= inf_ttrace_thread_alive
;
1289 t
->to_extra_thread_info
= inf_ttrace_extra_thread_info
;
1290 t
->to_pid_to_str
= inf_ttrace_pid_to_str
;
1291 t
->to_xfer_partial
= inf_ttrace_xfer_partial
;
1293 ttrace_ops_hack
= t
;
1299 /* Prevent warning from -Wmissing-prototypes. */
1300 void _initialize_hppa_hpux_nat (void);
1303 _initialize_inf_ttrace (void)
1306 inf_ttrace_page_dict
.pagesize
= getpagesize();