1 /* Low-level child interface to ttrace.
3 Copyright (C) 2004-2014 Free Software Foundation, Inc.
5 This file is part of GDB.
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 3 of the License, or
10 (at your option) any later version.
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with this program. If not, see <http://www.gnu.org/licenses/>. */
22 /* The ttrace(2) system call didn't exist before HP-UX 10.30. Don't
23 try to compile this code unless we have it. */
28 #include "gdbthread.h"
33 #include "gdb_assert.h"
36 #include <sys/ttrace.h>
39 #include "inf-child.h"
40 #include "inf-ttrace.h"
41 #include "common/filestuff.h"
45 /* HP-UX uses a threading model where each user-space thread
46 corresponds to a kernel thread. These kernel threads are called
47 lwps. The ttrace(2) interface gives us almost full control over
48 the threads, which makes it very easy to support them in GDB. We
49 identify the threads by process ID and lwp ID. The ttrace(2) also
50 provides us with a thread's user ID (in the `tts_user_tid' member
51 of `ttstate_t') but we don't use that (yet) as it isn't necessary
52 to uniquely label the thread. */
54 /* Number of active lwps. */
55 static int inf_ttrace_num_lwps;
58 /* On HP-UX versions that have the ttrace(2) system call, we can
59 implement "hardware" watchpoints by fiddling with the protection of
60 pages in the address space that contain the variable being watched.
61 In order to implement this, we keep a dictionary of pages for which
62 we have changed the protection. */
64 struct inf_ttrace_page
66 CORE_ADDR addr; /* Page address. */
67 int prot; /* Protection. */
68 int refcount; /* Reference count. */
69 struct inf_ttrace_page *next;
70 struct inf_ttrace_page *prev;
73 struct inf_ttrace_page_dict
75 struct inf_ttrace_page buckets[128];
76 int pagesize; /* Page size. */
77 int count; /* Number of pages in this dictionary. */
78 } inf_ttrace_page_dict;
80 struct inf_ttrace_private_thread_info
85 /* Number of lwps that are currently in a system call. */
86 static int inf_ttrace_num_lwps_in_syscall;
88 /* Flag to indicate whether we should re-enable page protections after
90 static int inf_ttrace_reenable_page_protections;
92 /* Enable system call events for process PID. */
95 inf_ttrace_enable_syscall_events (pid_t pid)
100 gdb_assert (inf_ttrace_num_lwps_in_syscall == 0);
102 if (ttrace (TT_PROC_GET_EVENT_MASK, pid, 0,
103 (uintptr_t)&tte, sizeof tte, 0) == -1)
104 perror_with_name (("ttrace"));
106 tte.tte_events |= (TTEVT_SYSCALL_ENTRY | TTEVT_SYSCALL_RETURN);
108 if (ttrace (TT_PROC_SET_EVENT_MASK, pid, 0,
109 (uintptr_t)&tte, sizeof tte, 0) == -1)
110 perror_with_name (("ttrace"));
112 if (ttrace (TT_PROC_GET_FIRST_LWP_STATE, pid, 0,
113 (uintptr_t)&tts, sizeof tts, 0) == -1)
114 perror_with_name (("ttrace"));
116 if (tts.tts_flags & TTS_INSYSCALL)
117 inf_ttrace_num_lwps_in_syscall++;
119 /* FIXME: Handle multiple threads. */
122 /* Disable system call events for process PID. */
125 inf_ttrace_disable_syscall_events (pid_t pid)
129 gdb_assert (inf_ttrace_page_dict.count == 0);
131 if (ttrace (TT_PROC_GET_EVENT_MASK, pid, 0,
132 (uintptr_t)&tte, sizeof tte, 0) == -1)
133 perror_with_name (("ttrace"));
135 tte.tte_events &= ~(TTEVT_SYSCALL_ENTRY | TTEVT_SYSCALL_RETURN);
137 if (ttrace (TT_PROC_SET_EVENT_MASK, pid, 0,
138 (uintptr_t)&tte, sizeof tte, 0) == -1)
139 perror_with_name (("ttrace"));
141 inf_ttrace_num_lwps_in_syscall = 0;
144 /* Get information about the page at address ADDR for process PID from
147 static struct inf_ttrace_page *
148 inf_ttrace_get_page (pid_t pid, CORE_ADDR addr)
150 const int num_buckets = ARRAY_SIZE (inf_ttrace_page_dict.buckets);
151 const int pagesize = inf_ttrace_page_dict.pagesize;
153 struct inf_ttrace_page *page;
155 bucket = (addr / pagesize) % num_buckets;
156 page = &inf_ttrace_page_dict.buckets[bucket];
159 if (page->addr == addr)
168 /* Add the page at address ADDR for process PID to the dictionary. */
170 static struct inf_ttrace_page *
171 inf_ttrace_add_page (pid_t pid, CORE_ADDR addr)
173 const int num_buckets = ARRAY_SIZE (inf_ttrace_page_dict.buckets);
174 const int pagesize = inf_ttrace_page_dict.pagesize;
176 struct inf_ttrace_page *page;
177 struct inf_ttrace_page *prev = NULL;
179 bucket = (addr / pagesize) % num_buckets;
180 page = &inf_ttrace_page_dict.buckets[bucket];
183 if (page->addr == addr)
194 if (ttrace (TT_PROC_GET_MPROTECT, pid, 0,
195 addr, 0, (uintptr_t)&prot) == -1)
196 perror_with_name (("ttrace"));
198 page = XNEW (struct inf_ttrace_page);
207 inf_ttrace_page_dict.count++;
208 if (inf_ttrace_page_dict.count == 1)
209 inf_ttrace_enable_syscall_events (pid);
211 if (inf_ttrace_num_lwps_in_syscall == 0)
213 if (ttrace (TT_PROC_SET_MPROTECT, pid, 0,
214 addr, pagesize, prot & ~PROT_WRITE) == -1)
215 perror_with_name (("ttrace"));
222 /* Insert the page at address ADDR of process PID to the dictionary. */
225 inf_ttrace_insert_page (pid_t pid, CORE_ADDR addr)
227 struct inf_ttrace_page *page;
229 page = inf_ttrace_get_page (pid, addr);
231 page = inf_ttrace_add_page (pid, addr);
236 /* Remove the page at address ADDR of process PID from the dictionary. */
239 inf_ttrace_remove_page (pid_t pid, CORE_ADDR addr)
241 const int pagesize = inf_ttrace_page_dict.pagesize;
242 struct inf_ttrace_page *page;
244 page = inf_ttrace_get_page (pid, addr);
247 gdb_assert (page->refcount >= 0);
249 if (page->refcount == 0)
251 if (inf_ttrace_num_lwps_in_syscall == 0)
253 if (ttrace (TT_PROC_SET_MPROTECT, pid, 0,
254 addr, pagesize, page->prot) == -1)
255 perror_with_name (("ttrace"));
258 inf_ttrace_page_dict.count--;
259 if (inf_ttrace_page_dict.count == 0)
260 inf_ttrace_disable_syscall_events (pid);
262 page->prev->next = page->next;
264 page->next->prev = page->prev;
270 /* Mask the bits in PROT from the page protections that are currently
271 in the dictionary for process PID. */
274 inf_ttrace_mask_page_protections (pid_t pid, int prot)
276 const int num_buckets = ARRAY_SIZE (inf_ttrace_page_dict.buckets);
277 const int pagesize = inf_ttrace_page_dict.pagesize;
280 for (bucket = 0; bucket < num_buckets; bucket++)
282 struct inf_ttrace_page *page;
284 page = inf_ttrace_page_dict.buckets[bucket].next;
287 if (ttrace (TT_PROC_SET_MPROTECT, pid, 0,
288 page->addr, pagesize, page->prot & ~prot) == -1)
289 perror_with_name (("ttrace"));
296 /* Write-protect the pages in the dictionary for process PID. */
299 inf_ttrace_enable_page_protections (pid_t pid)
301 inf_ttrace_mask_page_protections (pid, PROT_WRITE);
304 /* Restore the protection of the pages in the dictionary for process
308 inf_ttrace_disable_page_protections (pid_t pid)
310 inf_ttrace_mask_page_protections (pid, 0);
313 /* Insert a "hardware" watchpoint for LEN bytes at address ADDR of
317 inf_ttrace_insert_watchpoint (CORE_ADDR addr, int len, int type,
318 struct expression *cond)
320 const int pagesize = inf_ttrace_page_dict.pagesize;
321 pid_t pid = ptid_get_pid (inferior_ptid);
326 gdb_assert (type == hw_write);
328 page_addr = (addr / pagesize) * pagesize;
329 num_pages = (len + pagesize - 1) / pagesize;
331 for (page = 0; page < num_pages; page++, page_addr += pagesize)
332 inf_ttrace_insert_page (pid, page_addr);
337 /* Remove a "hardware" watchpoint for LEN bytes at address ADDR of
341 inf_ttrace_remove_watchpoint (CORE_ADDR addr, int len, int type,
342 struct expression *cond)
344 const int pagesize = inf_ttrace_page_dict.pagesize;
345 pid_t pid = ptid_get_pid (inferior_ptid);
350 gdb_assert (type == hw_write);
352 page_addr = (addr / pagesize) * pagesize;
353 num_pages = (len + pagesize - 1) / pagesize;
355 for (page = 0; page < num_pages; page++, page_addr += pagesize)
356 inf_ttrace_remove_page (pid, page_addr);
362 inf_ttrace_can_use_hw_breakpoint (int type, int len, int ot)
364 return (type == bp_hardware_watchpoint);
368 inf_ttrace_region_ok_for_hw_watchpoint (CORE_ADDR addr, int len)
373 /* Return non-zero if the current inferior was (potentially) stopped
374 by hitting a "hardware" watchpoint. */
377 inf_ttrace_stopped_by_watchpoint (void)
379 pid_t pid = ptid_get_pid (inferior_ptid);
380 lwpid_t lwpid = ptid_get_lwp (inferior_ptid);
383 if (inf_ttrace_page_dict.count > 0)
385 if (ttrace (TT_LWP_GET_STATE, pid, lwpid,
386 (uintptr_t)&tts, sizeof tts, 0) == -1)
387 perror_with_name (("ttrace"));
389 if (tts.tts_event == TTEVT_SIGNAL
390 && tts.tts_u.tts_signal.tts_signo == SIGBUS)
392 const int pagesize = inf_ttrace_page_dict.pagesize;
393 void *addr = tts.tts_u.tts_signal.tts_siginfo.si_addr;
394 CORE_ADDR page_addr = ((uintptr_t)addr / pagesize) * pagesize;
396 if (inf_ttrace_get_page (pid, page_addr))
405 /* When tracking a vfork(2), we cannot detach from the parent until
406 after the child has called exec(3) or has exited. If we are still
407 attached to the parent, this variable will be set to the process ID
408 of the parent. Otherwise it will be set to zero. */
409 static pid_t inf_ttrace_vfork_ppid = -1;
412 inf_ttrace_follow_fork (struct target_ops *ops, int follow_child,
416 lwpid_t lwpid, flwpid;
418 struct thread_info *tp = inferior_thread ();
420 gdb_assert (tp->pending_follow.kind == TARGET_WAITKIND_FORKED
421 || tp->pending_follow.kind == TARGET_WAITKIND_VFORKED);
423 pid = ptid_get_pid (inferior_ptid);
424 lwpid = ptid_get_lwp (inferior_ptid);
426 /* Get all important details that core GDB doesn't (and shouldn't)
428 if (ttrace (TT_LWP_GET_STATE, pid, lwpid,
429 (uintptr_t)&tts, sizeof tts, 0) == -1)
430 perror_with_name (("ttrace"));
432 gdb_assert (tts.tts_event == TTEVT_FORK || tts.tts_event == TTEVT_VFORK);
434 if (tts.tts_u.tts_fork.tts_isparent)
437 lwpid = tts.tts_lwpid;
438 fpid = tts.tts_u.tts_fork.tts_fpid;
439 flwpid = tts.tts_u.tts_fork.tts_flwpid;
443 pid = tts.tts_u.tts_fork.tts_fpid;
444 lwpid = tts.tts_u.tts_fork.tts_flwpid;
446 flwpid = tts.tts_lwpid;
451 struct inferior *inf;
452 struct inferior *parent_inf;
454 parent_inf = find_inferior_pid (pid);
456 inferior_ptid = ptid_build (fpid, flwpid, 0);
457 inf = add_inferior (fpid);
458 inf->attach_flag = parent_inf->attach_flag;
459 inf->pspace = parent_inf->pspace;
460 inf->aspace = parent_inf->aspace;
461 copy_terminal_info (inf, parent_inf);
462 detach_breakpoints (ptid_build (pid, lwpid, 0));
464 target_terminal_ours ();
465 fprintf_unfiltered (gdb_stdlog,
466 _("Attaching after fork to child process %ld.\n"),
471 inferior_ptid = ptid_build (pid, lwpid, 0);
472 /* Detach any remaining breakpoints in the child. In the case
473 of fork events, we do not need to do this, because breakpoints
474 should have already been removed earlier. */
475 if (tts.tts_event == TTEVT_VFORK)
476 detach_breakpoints (ptid_build (fpid, flwpid, 0));
478 target_terminal_ours ();
479 fprintf_unfiltered (gdb_stdlog,
480 _("Detaching after fork from child process %ld.\n"),
484 if (tts.tts_event == TTEVT_VFORK)
486 gdb_assert (!tts.tts_u.tts_fork.tts_isparent);
490 /* We can't detach from the parent yet. */
491 inf_ttrace_vfork_ppid = pid;
493 reattach_breakpoints (fpid);
497 if (ttrace (TT_PROC_DETACH, fpid, 0, 0, 0, 0) == -1)
498 perror_with_name (("ttrace"));
500 /* Wait till we get the TTEVT_VFORK event in the parent.
501 This indicates that the child has called exec(3) or has
502 exited and that the parent is ready to be traced again. */
503 if (ttrace_wait (pid, lwpid, TTRACE_WAITOK, &tts, sizeof tts) == -1)
504 perror_with_name (("ttrace_wait"));
505 gdb_assert (tts.tts_event == TTEVT_VFORK);
506 gdb_assert (tts.tts_u.tts_fork.tts_isparent);
508 reattach_breakpoints (pid);
513 gdb_assert (tts.tts_u.tts_fork.tts_isparent);
517 if (ttrace (TT_PROC_DETACH, pid, 0, 0, 0, 0) == -1)
518 perror_with_name (("ttrace"));
522 if (ttrace (TT_PROC_DETACH, fpid, 0, 0, 0, 0) == -1)
523 perror_with_name (("ttrace"));
529 struct thread_info *ti;
531 /* The child will start out single-threaded. */
532 inf_ttrace_num_lwps = 1;
533 inf_ttrace_num_lwps_in_syscall = 0;
536 delete_thread_silent (ptid_build (pid, lwpid, 0));
537 detach_inferior (pid);
539 /* Add child thread. inferior_ptid was already set above. */
540 ti = add_thread_silent (inferior_ptid);
542 xmalloc (sizeof (struct inf_ttrace_private_thread_info));
543 memset (ti->private, 0,
544 sizeof (struct inf_ttrace_private_thread_info));
551 /* File descriptors for pipes used as semaphores during initial
552 startup of an inferior. */
553 static int inf_ttrace_pfd1[2];
554 static int inf_ttrace_pfd2[2];
557 do_cleanup_pfds (void *dummy)
559 close (inf_ttrace_pfd1[0]);
560 close (inf_ttrace_pfd1[1]);
561 close (inf_ttrace_pfd2[0]);
562 close (inf_ttrace_pfd2[1]);
564 unmark_fd_no_cloexec (inf_ttrace_pfd1[0]);
565 unmark_fd_no_cloexec (inf_ttrace_pfd1[1]);
566 unmark_fd_no_cloexec (inf_ttrace_pfd2[0]);
567 unmark_fd_no_cloexec (inf_ttrace_pfd2[1]);
571 inf_ttrace_prepare (void)
573 if (pipe (inf_ttrace_pfd1) == -1)
574 perror_with_name (("pipe"));
576 if (pipe (inf_ttrace_pfd2) == -1)
578 close (inf_ttrace_pfd1[0]);
579 close (inf_ttrace_pfd2[0]);
580 perror_with_name (("pipe"));
583 mark_fd_no_cloexec (inf_ttrace_pfd1[0]);
584 mark_fd_no_cloexec (inf_ttrace_pfd1[1]);
585 mark_fd_no_cloexec (inf_ttrace_pfd2[0]);
586 mark_fd_no_cloexec (inf_ttrace_pfd2[1]);
589 /* Prepare to be traced. */
594 struct cleanup *old_chain = make_cleanup (do_cleanup_pfds, 0);
597 /* "Trace me, Dr. Memory!" */
598 if (ttrace (TT_PROC_SETTRC, 0, 0, 0, TT_VERSION, 0) == -1)
599 perror_with_name (("ttrace"));
601 /* Tell our parent that we are ready to be traced. */
602 if (write (inf_ttrace_pfd1[1], &c, sizeof c) != sizeof c)
603 perror_with_name (("write"));
605 /* Wait until our parent has set the initial event mask. */
606 if (read (inf_ttrace_pfd2[0], &c, sizeof c) != sizeof c)
607 perror_with_name (("read"));
609 do_cleanups (old_chain);
612 /* Start tracing PID. */
615 inf_ttrace_him (struct target_ops *ops, int pid)
617 struct cleanup *old_chain = make_cleanup (do_cleanup_pfds, 0);
621 /* Wait until our child is ready to be traced. */
622 if (read (inf_ttrace_pfd1[0], &c, sizeof c) != sizeof c)
623 perror_with_name (("read"));
625 /* Set the initial event mask. */
626 memset (&tte, 0, sizeof (tte));
627 tte.tte_events |= TTEVT_EXEC | TTEVT_EXIT | TTEVT_FORK | TTEVT_VFORK;
628 tte.tte_events |= TTEVT_LWP_CREATE | TTEVT_LWP_EXIT | TTEVT_LWP_TERMINATE;
629 #ifdef TTEVT_BPT_SSTEP
630 tte.tte_events |= TTEVT_BPT_SSTEP;
632 tte.tte_opts |= TTEO_PROC_INHERIT;
633 if (ttrace (TT_PROC_SET_EVENT_MASK, pid, 0,
634 (uintptr_t)&tte, sizeof tte, 0) == -1)
635 perror_with_name (("ttrace"));
637 /* Tell our child that we have set the initial event mask. */
638 if (write (inf_ttrace_pfd2[1], &c, sizeof c) != sizeof c)
639 perror_with_name (("write"));
641 do_cleanups (old_chain);
645 startup_inferior (START_INFERIOR_TRAPS_EXPECTED);
647 /* On some targets, there must be some explicit actions taken after
648 the inferior has been started up. */
649 target_post_startup_inferior (pid_to_ptid (pid));
653 inf_ttrace_create_inferior (struct target_ops *ops, char *exec_file,
654 char *allargs, char **env, int from_tty)
658 gdb_assert (inf_ttrace_num_lwps == 0);
659 gdb_assert (inf_ttrace_num_lwps_in_syscall == 0);
660 gdb_assert (inf_ttrace_page_dict.count == 0);
661 gdb_assert (inf_ttrace_reenable_page_protections == 0);
662 gdb_assert (inf_ttrace_vfork_ppid == -1);
664 pid = fork_inferior (exec_file, allargs, env, inf_ttrace_me, NULL,
665 inf_ttrace_prepare, NULL, NULL);
667 inf_ttrace_him (ops, pid);
671 inf_ttrace_mourn_inferior (struct target_ops *ops)
673 const int num_buckets = ARRAY_SIZE (inf_ttrace_page_dict.buckets);
676 inf_ttrace_num_lwps = 0;
677 inf_ttrace_num_lwps_in_syscall = 0;
679 for (bucket = 0; bucket < num_buckets; bucket++)
681 struct inf_ttrace_page *page;
682 struct inf_ttrace_page *next;
684 page = inf_ttrace_page_dict.buckets[bucket].next;
692 inf_ttrace_page_dict.count = 0;
695 generic_mourn_inferior ();
698 /* Assuming we just attached the debugger to a new inferior, create
699 a new thread_info structure for each thread, and add it to our
703 inf_ttrace_create_threads_after_attach (int pid)
708 struct thread_info *ti;
710 status = ttrace (TT_PROC_GET_FIRST_LWP_STATE, pid, 0,
711 (uintptr_t) &tts, sizeof (ttstate_t), 0);
713 perror_with_name (_("TT_PROC_GET_FIRST_LWP_STATE ttrace call failed"));
714 gdb_assert (tts.tts_pid == pid);
716 /* Add the stopped thread. */
717 ptid = ptid_build (pid, tts.tts_lwpid, 0);
718 ti = add_thread (ptid);
719 ti->private = xzalloc (sizeof (struct inf_ttrace_private_thread_info));
720 inf_ttrace_num_lwps++;
722 /* We use the "first stopped thread" as the currently active thread. */
723 inferior_ptid = ptid;
725 /* Iterative over all the remaining threads. */
731 status = ttrace (TT_PROC_GET_NEXT_LWP_STATE, pid, 0,
732 (uintptr_t) &tts, sizeof (ttstate_t), 0);
734 perror_with_name (_("TT_PROC_GET_NEXT_LWP_STATE ttrace call failed"));
736 break; /* End of list. */
738 ptid = ptid_build (tts.tts_pid, tts.tts_lwpid, 0);
739 ti = add_thread (ptid);
740 ti->private = xzalloc (sizeof (struct inf_ttrace_private_thread_info));
741 inf_ttrace_num_lwps++;
746 inf_ttrace_attach (struct target_ops *ops, char *args, int from_tty)
751 struct inferior *inf;
753 pid = parse_pid_to_attach (args);
755 if (pid == getpid ()) /* Trying to masturbate? */
756 error (_("I refuse to debug myself!"));
760 exec_file = get_exec_file (0);
763 printf_unfiltered (_("Attaching to program: %s, %s\n"), exec_file,
764 target_pid_to_str (pid_to_ptid (pid)));
766 printf_unfiltered (_("Attaching to %s\n"),
767 target_pid_to_str (pid_to_ptid (pid)));
769 gdb_flush (gdb_stdout);
772 gdb_assert (inf_ttrace_num_lwps == 0);
773 gdb_assert (inf_ttrace_num_lwps_in_syscall == 0);
774 gdb_assert (inf_ttrace_vfork_ppid == -1);
776 if (ttrace (TT_PROC_ATTACH, pid, 0, TT_KILL_ON_EXIT, TT_VERSION, 0) == -1)
777 perror_with_name (("ttrace"));
779 inf = current_inferior ();
780 inferior_appeared (inf, pid);
781 inf->attach_flag = 1;
783 /* Set the initial event mask. */
784 memset (&tte, 0, sizeof (tte));
785 tte.tte_events |= TTEVT_EXEC | TTEVT_EXIT | TTEVT_FORK | TTEVT_VFORK;
786 tte.tte_events |= TTEVT_LWP_CREATE | TTEVT_LWP_EXIT | TTEVT_LWP_TERMINATE;
787 #ifdef TTEVT_BPT_SSTEP
788 tte.tte_events |= TTEVT_BPT_SSTEP;
790 tte.tte_opts |= TTEO_PROC_INHERIT;
791 if (ttrace (TT_PROC_SET_EVENT_MASK, pid, 0,
792 (uintptr_t)&tte, sizeof tte, 0) == -1)
793 perror_with_name (("ttrace"));
797 inf_ttrace_create_threads_after_attach (pid);
801 inf_ttrace_detach (struct target_ops *ops, const char *args, int from_tty)
803 pid_t pid = ptid_get_pid (inferior_ptid);
808 char *exec_file = get_exec_file (0);
811 printf_unfiltered (_("Detaching from program: %s, %s\n"), exec_file,
812 target_pid_to_str (pid_to_ptid (pid)));
813 gdb_flush (gdb_stdout);
818 /* ??? The HP-UX 11.0 ttrace(2) manual page doesn't mention that we
819 can pass a signal number here. Does this really work? */
820 if (ttrace (TT_PROC_DETACH, pid, 0, 0, sig, 0) == -1)
821 perror_with_name (("ttrace"));
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 inf_ttrace_num_lwps = 0;
831 inf_ttrace_num_lwps_in_syscall = 0;
833 inferior_ptid = null_ptid;
834 detach_inferior (pid);
840 inf_ttrace_kill (struct target_ops *ops)
842 pid_t pid = ptid_get_pid (inferior_ptid);
847 if (ttrace (TT_PROC_EXIT, pid, 0, 0, 0, 0) == -1)
848 perror_with_name (("ttrace"));
849 /* ??? Is it necessary to call ttrace_wait() here? */
851 if (inf_ttrace_vfork_ppid != -1)
853 if (ttrace (TT_PROC_DETACH, inf_ttrace_vfork_ppid, 0, 0, 0, 0) == -1)
854 perror_with_name (("ttrace"));
855 inf_ttrace_vfork_ppid = -1;
858 target_mourn_inferior ();
861 /* Check is a dying thread is dead by now, and delete it from GDBs
862 thread list if so. */
864 inf_ttrace_delete_dead_threads_callback (struct thread_info *info, void *arg)
867 struct inf_ttrace_private_thread_info *p;
869 if (is_exited (info->ptid))
872 lwpid = ptid_get_lwp (info->ptid);
873 p = (struct inf_ttrace_private_thread_info *) info->private;
875 /* Check if an lwp that was dying is still there or not. */
876 if (p->dying && (kill (lwpid, 0) == -1))
878 delete_thread (info->ptid);
883 /* Resume the lwp pointed to by INFO, with REQUEST, and pass it signal
887 inf_ttrace_resume_lwp (struct thread_info *info, ttreq_t request, int sig)
889 pid_t pid = ptid_get_pid (info->ptid);
890 lwpid_t lwpid = ptid_get_lwp (info->ptid);
892 if (ttrace (request, pid, lwpid, TT_NOPC, sig, 0) == -1)
894 struct inf_ttrace_private_thread_info *p
895 = (struct inf_ttrace_private_thread_info *) info->private;
896 if (p->dying && errno == EPROTO)
897 /* This is expected, it means the dying lwp is really gone
898 by now. If ttrace had an event to inform the debugger
899 the lwp is really gone, this wouldn't be needed. */
900 delete_thread (info->ptid);
902 /* This was really unexpected. */
903 perror_with_name (("ttrace"));
907 /* Callback for iterate_over_threads. */
910 inf_ttrace_resume_callback (struct thread_info *info, void *arg)
912 if (!ptid_equal (info->ptid, inferior_ptid) && !is_exited (info->ptid))
913 inf_ttrace_resume_lwp (info, TT_LWP_CONTINUE, 0);
919 inf_ttrace_resume (struct target_ops *ops,
920 ptid_t ptid, int step, enum gdb_signal signal)
923 ttreq_t request = step ? TT_LWP_SINGLE : TT_LWP_CONTINUE;
924 int sig = gdb_signal_to_host (signal);
925 struct thread_info *info;
927 /* A specific PTID means `step only this process id'. */
928 resume_all = (ptid_equal (ptid, minus_one_ptid));
930 /* If resuming all threads, it's the current thread that should be
931 handled specially. */
933 ptid = inferior_ptid;
935 info = find_thread_ptid (ptid);
936 inf_ttrace_resume_lwp (info, request, sig);
939 /* Let all the other threads run too. */
940 iterate_over_threads (inf_ttrace_resume_callback, NULL);
944 inf_ttrace_wait (struct target_ops *ops,
945 ptid_t ptid, struct target_waitstatus *ourstatus, int options)
947 pid_t pid = ptid_get_pid (ptid);
948 lwpid_t lwpid = ptid_get_lwp (ptid);
950 struct thread_info *ti;
953 /* Until proven otherwise. */
954 ourstatus->kind = TARGET_WAITKIND_SPURIOUS;
959 gdb_assert (pid != 0 || lwpid == 0);
965 if (ttrace_wait (pid, lwpid, TTRACE_WAITOK, &tts, sizeof tts) == -1)
966 perror_with_name (("ttrace_wait"));
968 if (tts.tts_event == TTEVT_VFORK && tts.tts_u.tts_fork.tts_isparent)
970 if (inf_ttrace_vfork_ppid != -1)
972 gdb_assert (inf_ttrace_vfork_ppid == tts.tts_pid);
974 if (ttrace (TT_PROC_DETACH, tts.tts_pid, 0, 0, 0, 0) == -1)
975 perror_with_name (("ttrace"));
976 inf_ttrace_vfork_ppid = -1;
979 tts.tts_event = TTEVT_NONE;
982 clear_sigint_trap ();
984 while (tts.tts_event == TTEVT_NONE);
986 /* Now that we've waited, we can re-enable the page protections. */
987 if (inf_ttrace_reenable_page_protections)
989 gdb_assert (inf_ttrace_num_lwps_in_syscall == 0);
990 inf_ttrace_enable_page_protections (tts.tts_pid);
991 inf_ttrace_reenable_page_protections = 0;
994 ptid = ptid_build (tts.tts_pid, tts.tts_lwpid, 0);
996 if (inf_ttrace_num_lwps == 0)
998 struct thread_info *ti;
1000 inf_ttrace_num_lwps = 1;
1002 /* This is the earliest we hear about the lwp member of
1003 INFERIOR_PTID, after an attach or fork_inferior. */
1004 gdb_assert (ptid_get_lwp (inferior_ptid) == 0);
1006 /* We haven't set the private member on the main thread yet. Do
1008 ti = find_thread_ptid (inferior_ptid);
1009 gdb_assert (ti != NULL && ti->private == NULL);
1011 xmalloc (sizeof (struct inf_ttrace_private_thread_info));
1012 memset (ti->private, 0,
1013 sizeof (struct inf_ttrace_private_thread_info));
1015 /* Notify the core that this ptid changed. This changes
1016 inferior_ptid as well. */
1017 thread_change_ptid (inferior_ptid, ptid);
1020 switch (tts.tts_event)
1022 #ifdef TTEVT_BPT_SSTEP
1023 case TTEVT_BPT_SSTEP:
1024 /* Make it look like a breakpoint. */
1025 ourstatus->kind = TARGET_WAITKIND_STOPPED;
1026 ourstatus->value.sig = GDB_SIGNAL_TRAP;
1031 ourstatus->kind = TARGET_WAITKIND_EXECD;
1032 ourstatus->value.execd_pathname =
1033 xmalloc (tts.tts_u.tts_exec.tts_pathlen + 1);
1034 if (ttrace (TT_PROC_GET_PATHNAME, tts.tts_pid, 0,
1035 (uintptr_t)ourstatus->value.execd_pathname,
1036 tts.tts_u.tts_exec.tts_pathlen, 0) == -1)
1037 perror_with_name (("ttrace"));
1038 ourstatus->value.execd_pathname[tts.tts_u.tts_exec.tts_pathlen] = 0;
1040 /* At this point, all inserted breakpoints are gone. Doing this
1041 as soon as we detect an exec prevents the badness of deleting
1042 a breakpoint writing the current "shadow contents" to lift
1043 the bp. That shadow is NOT valid after an exec. */
1044 mark_breakpoints_out ();
1048 store_waitstatus (ourstatus, tts.tts_u.tts_exit.tts_exitcode);
1049 inf_ttrace_num_lwps = 0;
1053 related_ptid = ptid_build (tts.tts_u.tts_fork.tts_fpid,
1054 tts.tts_u.tts_fork.tts_flwpid, 0);
1056 ourstatus->kind = TARGET_WAITKIND_FORKED;
1057 ourstatus->value.related_pid = related_ptid;
1059 /* Make sure the other end of the fork is stopped too. */
1060 if (ttrace_wait (tts.tts_u.tts_fork.tts_fpid,
1061 tts.tts_u.tts_fork.tts_flwpid,
1062 TTRACE_WAITOK, &tts, sizeof tts) == -1)
1063 perror_with_name (("ttrace_wait"));
1065 gdb_assert (tts.tts_event == TTEVT_FORK);
1066 if (tts.tts_u.tts_fork.tts_isparent)
1068 related_ptid = ptid_build (tts.tts_u.tts_fork.tts_fpid,
1069 tts.tts_u.tts_fork.tts_flwpid, 0);
1070 ptid = ptid_build (tts.tts_pid, tts.tts_lwpid, 0);
1071 ourstatus->value.related_pid = related_ptid;
1076 gdb_assert (!tts.tts_u.tts_fork.tts_isparent);
1078 related_ptid = ptid_build (tts.tts_u.tts_fork.tts_fpid,
1079 tts.tts_u.tts_fork.tts_flwpid, 0);
1081 ourstatus->kind = TARGET_WAITKIND_VFORKED;
1082 ourstatus->value.related_pid = related_ptid;
1084 /* HACK: To avoid touching the parent during the vfork, switch
1086 inferior_ptid = ptid;
1089 case TTEVT_LWP_CREATE:
1090 lwpid = tts.tts_u.tts_thread.tts_target_lwpid;
1091 ptid = ptid_build (tts.tts_pid, lwpid, 0);
1092 ti = add_thread (ptid);
1094 xmalloc (sizeof (struct inf_ttrace_private_thread_info));
1095 memset (ti->private, 0,
1096 sizeof (struct inf_ttrace_private_thread_info));
1097 inf_ttrace_num_lwps++;
1098 ptid = ptid_build (tts.tts_pid, tts.tts_lwpid, 0);
1099 /* Let the lwp_create-caller thread continue. */
1100 ttrace (TT_LWP_CONTINUE, ptid_get_pid (ptid),
1101 ptid_get_lwp (ptid), TT_NOPC, 0, 0);
1102 /* Return without stopping the whole process. */
1103 ourstatus->kind = TARGET_WAITKIND_IGNORE;
1106 case TTEVT_LWP_EXIT:
1107 if (print_thread_events)
1108 printf_unfiltered (_("[%s exited]\n"), target_pid_to_str (ptid));
1109 ti = find_thread_ptid (ptid);
1110 gdb_assert (ti != NULL);
1111 ((struct inf_ttrace_private_thread_info *)ti->private)->dying = 1;
1112 inf_ttrace_num_lwps--;
1113 /* Let the thread really exit. */
1114 ttrace (TT_LWP_CONTINUE, ptid_get_pid (ptid),
1115 ptid_get_lwp (ptid), TT_NOPC, 0, 0);
1116 /* Return without stopping the whole process. */
1117 ourstatus->kind = TARGET_WAITKIND_IGNORE;
1120 case TTEVT_LWP_TERMINATE:
1121 lwpid = tts.tts_u.tts_thread.tts_target_lwpid;
1122 ptid = ptid_build (tts.tts_pid, lwpid, 0);
1123 if (print_thread_events)
1124 printf_unfiltered(_("[%s has been terminated]\n"),
1125 target_pid_to_str (ptid));
1126 ti = find_thread_ptid (ptid);
1127 gdb_assert (ti != NULL);
1128 ((struct inf_ttrace_private_thread_info *)ti->private)->dying = 1;
1129 inf_ttrace_num_lwps--;
1131 /* Resume the lwp_terminate-caller thread. */
1132 ptid = ptid_build (tts.tts_pid, tts.tts_lwpid, 0);
1133 ttrace (TT_LWP_CONTINUE, ptid_get_pid (ptid),
1134 ptid_get_lwp (ptid), TT_NOPC, 0, 0);
1135 /* Return without stopping the whole process. */
1136 ourstatus->kind = TARGET_WAITKIND_IGNORE;
1140 ourstatus->kind = TARGET_WAITKIND_STOPPED;
1141 ourstatus->value.sig =
1142 gdb_signal_from_host (tts.tts_u.tts_signal.tts_signo);
1145 case TTEVT_SYSCALL_ENTRY:
1146 gdb_assert (inf_ttrace_reenable_page_protections == 0);
1147 inf_ttrace_num_lwps_in_syscall++;
1148 if (inf_ttrace_num_lwps_in_syscall == 1)
1150 /* A thread has just entered a system call. Disable any
1151 page protections as the kernel can't deal with them. */
1152 inf_ttrace_disable_page_protections (tts.tts_pid);
1154 ourstatus->kind = TARGET_WAITKIND_SYSCALL_ENTRY;
1155 ourstatus->value.syscall_number = tts.tts_scno;
1158 case TTEVT_SYSCALL_RETURN:
1159 if (inf_ttrace_num_lwps_in_syscall > 0)
1161 /* If the last thread has just left the system call, this
1162 would be a logical place to re-enable the page
1163 protections, but that doesn't work. We can't re-enable
1164 them until we've done another wait. */
1165 inf_ttrace_reenable_page_protections =
1166 (inf_ttrace_num_lwps_in_syscall == 1);
1167 inf_ttrace_num_lwps_in_syscall--;
1169 ourstatus->kind = TARGET_WAITKIND_SYSCALL_RETURN;
1170 ourstatus->value.syscall_number = tts.tts_scno;
1174 gdb_assert (!"Unexpected ttrace event");
1178 /* Make sure all threads within the process are stopped. */
1179 if (ttrace (TT_PROC_STOP, tts.tts_pid, 0, 0, 0, 0) == -1)
1180 perror_with_name (("ttrace"));
1182 /* Now that the whole process is stopped, check if any dying thread
1183 is really dead by now. If a dying thread is still alive, it will
1184 be stopped too, and will still show up in `info threads', tagged
1185 with "(Exiting)". We could make `info threads' prune dead
1186 threads instead via inf_ttrace_thread_alive, but doing this here
1187 has the advantage that a frontend is notificed sooner of thread
1188 exits. Note that a dying lwp is still alive, it still has to be
1189 resumed, like any other lwp. */
1190 iterate_over_threads (inf_ttrace_delete_dead_threads_callback, NULL);
1195 /* Transfer LEN bytes from ADDR in the inferior's memory into READBUF,
1196 and transfer LEN bytes from WRITEBUF into the inferior's memory at
1197 ADDR. Either READBUF or WRITEBUF may be null, in which case the
1198 corresponding transfer doesn't happen. Return the number of bytes
1199 actually transferred (which may be zero if an error occurs). */
1202 inf_ttrace_xfer_memory (CORE_ADDR addr, ULONGEST len,
1203 void *readbuf, const void *writebuf)
1205 pid_t pid = ptid_get_pid (inferior_ptid);
1207 /* HP-UX treats text space and data space differently. GDB however,
1208 doesn't really know the difference. Therefore we try both. Try
1209 text space before data space though because when we're writing
1210 into text space the instruction cache might need to be flushed. */
1213 && ttrace (TT_PROC_RDTEXT, pid, 0, addr, len, (uintptr_t)readbuf) == -1
1214 && ttrace (TT_PROC_RDDATA, pid, 0, addr, len, (uintptr_t)readbuf) == -1)
1218 && ttrace (TT_PROC_WRTEXT, pid, 0, addr, len, (uintptr_t)writebuf) == -1
1219 && ttrace (TT_PROC_WRDATA, pid, 0, addr, len, (uintptr_t)writebuf) == -1)
1226 inf_ttrace_xfer_partial (struct target_ops *ops, enum target_object object,
1227 const char *annex, gdb_byte *readbuf,
1228 const gdb_byte *writebuf,
1229 ULONGEST offset, ULONGEST len)
1233 case TARGET_OBJECT_MEMORY:
1234 return inf_ttrace_xfer_memory (offset, len, readbuf, writebuf);
1236 case TARGET_OBJECT_UNWIND_TABLE:
1239 case TARGET_OBJECT_AUXV:
1242 case TARGET_OBJECT_WCOOKIE:
1250 /* Print status information about what we're accessing. */
1253 inf_ttrace_files_info (struct target_ops *ignore)
1255 struct inferior *inf = current_inferior ();
1256 printf_filtered (_("\tUsing the running image of %s %s.\n"),
1257 inf->attach_flag ? "attached" : "child",
1258 target_pid_to_str (inferior_ptid));
1262 inf_ttrace_thread_alive (struct target_ops *ops, ptid_t ptid)
1267 /* Return a string describing the state of the thread specified by
1271 inf_ttrace_extra_thread_info (struct thread_info *info)
1273 struct inf_ttrace_private_thread_info* private =
1274 (struct inf_ttrace_private_thread_info *) info->private;
1276 if (private != NULL && private->dying)
1283 inf_ttrace_pid_to_str (struct target_ops *ops, ptid_t ptid)
1285 pid_t pid = ptid_get_pid (ptid);
1286 lwpid_t lwpid = ptid_get_lwp (ptid);
1287 static char buf[128];
1290 xsnprintf (buf, sizeof buf, "process %ld",
1293 xsnprintf (buf, sizeof buf, "process %ld, lwp %ld",
1294 (long) pid, (long) lwpid);
1299 /* Implement the get_ada_task_ptid target_ops method. */
1302 inf_ttrace_get_ada_task_ptid (long lwp, long thread)
1304 return ptid_build (ptid_get_pid (inferior_ptid), lwp, 0);
1309 inf_ttrace_target (void)
1311 struct target_ops *t = inf_child_target ();
1313 t->to_attach = inf_ttrace_attach;
1314 t->to_detach = inf_ttrace_detach;
1315 t->to_resume = inf_ttrace_resume;
1316 t->to_wait = inf_ttrace_wait;
1317 t->to_files_info = inf_ttrace_files_info;
1318 t->to_can_use_hw_breakpoint = inf_ttrace_can_use_hw_breakpoint;
1319 t->to_insert_watchpoint = inf_ttrace_insert_watchpoint;
1320 t->to_remove_watchpoint = inf_ttrace_remove_watchpoint;
1321 t->to_stopped_by_watchpoint = inf_ttrace_stopped_by_watchpoint;
1322 t->to_region_ok_for_hw_watchpoint =
1323 inf_ttrace_region_ok_for_hw_watchpoint;
1324 t->to_kill = inf_ttrace_kill;
1325 t->to_create_inferior = inf_ttrace_create_inferior;
1326 t->to_follow_fork = inf_ttrace_follow_fork;
1327 t->to_mourn_inferior = inf_ttrace_mourn_inferior;
1328 t->to_thread_alive = inf_ttrace_thread_alive;
1329 t->to_extra_thread_info = inf_ttrace_extra_thread_info;
1330 t->to_pid_to_str = inf_ttrace_pid_to_str;
1331 t->to_xfer_partial = inf_ttrace_xfer_partial;
1332 t->to_get_ada_task_ptid = inf_ttrace_get_ada_task_ptid;
1339 /* Prevent warning from -Wmissing-prototypes. */
1340 void _initialize_inf_ttrace (void);
1343 _initialize_inf_ttrace (void)
1346 inf_ttrace_page_dict.pagesize = getpagesize();