gdb/inf-ttrace.c

   1 /* Low-level child interface to ttrace.
   2
   3    Copyright (C) 2004-2014 Free Software Foundation, Inc.
   4
   5    This file is part of GDB.
   6
   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.
  11
  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.
  16
  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/>.  */
  19
  20 #include "defs.h"
  21
  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.  */
  24 #ifdef HAVE_TTRACE
  25
  26 #include "command.h"
  27 #include "gdbcore.h"
  28 #include "gdbthread.h"
  29 #include "inferior.h"
  30 #include "terminal.h"
  31 #include "target.h"
  32
  33 #include "gdb_assert.h"
  34 #include <string.h>
  35 #include <sys/mman.h>
  36 #include <sys/ttrace.h>
  37 #include <signal.h>
  38
  39 #include "inf-child.h"
  40 #include "inf-ttrace.h"
  41 #include "common/filestuff.h"
  42
  43 \f
  44
  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.  */
  53
  54 /* Number of active lwps.  */
  55 static int inf_ttrace_num_lwps;
  56 \f
  57
  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.  */
  63
  64 struct inf_ttrace_page
  65 {
  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;
  71 };
  72
  73 struct inf_ttrace_page_dict
  74 {
  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;
  79
  80 struct inf_ttrace_private_thread_info
  81 {
  82   int dying;
  83 };
  84
  85 /* Number of lwps that are currently in a system call.  */
  86 static int inf_ttrace_num_lwps_in_syscall;
  87
  88 /* Flag to indicate whether we should re-enable page protections after
  89    the next wait.  */
  90 static int inf_ttrace_reenable_page_protections;
  91
  92 /* Enable system call events for process PID.  */
  93
  94 static void
  95 inf_ttrace_enable_syscall_events (pid_t pid)
  96 {
  97   ttevent_t tte;
  98   ttstate_t tts;
  99
 100   gdb_assert (inf_ttrace_num_lwps_in_syscall == 0);
 101
 102   if (ttrace (TT_PROC_GET_EVENT_MASK, pid, 0,
 103               (uintptr_t)&tte, sizeof tte, 0) == -1)
 104     perror_with_name (("ttrace"));
 105
 106   tte.tte_events |= (TTEVT_SYSCALL_ENTRY | TTEVT_SYSCALL_RETURN);
 107
 108   if (ttrace (TT_PROC_SET_EVENT_MASK, pid, 0,
 109               (uintptr_t)&tte, sizeof tte, 0) == -1)
 110     perror_with_name (("ttrace"));
 111
 112   if (ttrace (TT_PROC_GET_FIRST_LWP_STATE, pid, 0,
 113               (uintptr_t)&tts, sizeof tts, 0) == -1)
 114     perror_with_name (("ttrace"));
 115
 116   if (tts.tts_flags & TTS_INSYSCALL)
 117     inf_ttrace_num_lwps_in_syscall++;
 118
 119   /* FIXME: Handle multiple threads.  */
 120 }
 121
 122 /* Disable system call events for process PID.  */
 123
 124 static void
 125 inf_ttrace_disable_syscall_events (pid_t pid)
 126 {
 127   ttevent_t tte;
 128
 129   gdb_assert (inf_ttrace_page_dict.count == 0);
 130
 131   if (ttrace (TT_PROC_GET_EVENT_MASK, pid, 0,
 132               (uintptr_t)&tte, sizeof tte, 0) == -1)
 133     perror_with_name (("ttrace"));
 134
 135   tte.tte_events &= ~(TTEVT_SYSCALL_ENTRY | TTEVT_SYSCALL_RETURN);
 136
 137   if (ttrace (TT_PROC_SET_EVENT_MASK, pid, 0,
 138               (uintptr_t)&tte, sizeof tte, 0) == -1)
 139     perror_with_name (("ttrace"));
 140
 141   inf_ttrace_num_lwps_in_syscall = 0;
 142 }
 143
 144 /* Get information about the page at address ADDR for process PID from
 145    the dictionary.  */
 146
 147 static struct inf_ttrace_page *
 148 inf_ttrace_get_page (pid_t pid, CORE_ADDR addr)
 149 {
 150   const int num_buckets = ARRAY_SIZE (inf_ttrace_page_dict.buckets);
 151   const int pagesize = inf_ttrace_page_dict.pagesize;
 152   int bucket;
 153   struct inf_ttrace_page *page;
 154
 155   bucket = (addr / pagesize) % num_buckets;
 156   page = &inf_ttrace_page_dict.buckets[bucket];
 157   while (page)
 158     {
 159       if (page->addr == addr)
 160         break;
 161
 162       page = page->next;
 163     }
 164
 165   return page;
 166 }
 167
 168 /* Add the page at address ADDR for process PID to the dictionary.  */
 169
 170 static struct inf_ttrace_page *
 171 inf_ttrace_add_page (pid_t pid, CORE_ADDR addr)
 172 {
 173   const int num_buckets = ARRAY_SIZE (inf_ttrace_page_dict.buckets);
 174   const int pagesize = inf_ttrace_page_dict.pagesize;
 175   int bucket;
 176   struct inf_ttrace_page *page;
 177   struct inf_ttrace_page *prev = NULL;
 178
 179   bucket = (addr / pagesize) % num_buckets;
 180   page = &inf_ttrace_page_dict.buckets[bucket];
 181   while (page)
 182     {
 183       if (page->addr == addr)
 184         break;
 185
 186       prev = page;
 187       page = page->next;
 188     }
 189
 190   if (!page)
 191     {
 192       int prot;
 193
 194       if (ttrace (TT_PROC_GET_MPROTECT, pid, 0,
 195                   addr, 0, (uintptr_t)&prot) == -1)
 196         perror_with_name (("ttrace"));
 197
 198       page = XNEW (struct inf_ttrace_page);
 199       page->addr = addr;
 200       page->prot = prot;
 201       page->refcount = 0;
 202       page->next = NULL;
 203
 204       page->prev = prev;
 205       prev->next = page;
 206
 207       inf_ttrace_page_dict.count++;
 208       if (inf_ttrace_page_dict.count == 1)
 209         inf_ttrace_enable_syscall_events (pid);
 210
 211       if (inf_ttrace_num_lwps_in_syscall == 0)
 212         {
 213           if (ttrace (TT_PROC_SET_MPROTECT, pid, 0,
 214                       addr, pagesize, prot & ~PROT_WRITE) == -1)
 215             perror_with_name (("ttrace"));
 216         }
 217     }
 218
 219   return page;
 220 }
 221
 222 /* Insert the page at address ADDR of process PID to the dictionary.  */
 223
 224 static void
 225 inf_ttrace_insert_page (pid_t pid, CORE_ADDR addr)
 226 {
 227   struct inf_ttrace_page *page;
 228
 229   page = inf_ttrace_get_page (pid, addr);
 230   if (!page)
 231     page = inf_ttrace_add_page (pid, addr);
 232
 233   page->refcount++;
 234 }
 235
 236 /* Remove the page at address ADDR of process PID from the dictionary.  */
 237
 238 static void
 239 inf_ttrace_remove_page (pid_t pid, CORE_ADDR addr)
 240 {
 241   const int pagesize = inf_ttrace_page_dict.pagesize;
 242   struct inf_ttrace_page *page;
 243
 244   page = inf_ttrace_get_page (pid, addr);
 245   page->refcount--;
 246
 247   gdb_assert (page->refcount >= 0);
 248
 249   if (page->refcount == 0)
 250     {
 251       if (inf_ttrace_num_lwps_in_syscall == 0)
 252         {
 253           if (ttrace (TT_PROC_SET_MPROTECT, pid, 0,
 254                       addr, pagesize, page->prot) == -1)
 255             perror_with_name (("ttrace"));
 256         }
 257
 258       inf_ttrace_page_dict.count--;
 259       if (inf_ttrace_page_dict.count == 0)
 260         inf_ttrace_disable_syscall_events (pid);
 261
 262       page->prev->next = page->next;
 263       if (page->next)
 264         page->next->prev = page->prev;
 265
 266       xfree (page);
 267     }
 268 }
 269
 270 /* Mask the bits in PROT from the page protections that are currently
 271    in the dictionary for process PID.  */
 272
 273 static void
 274 inf_ttrace_mask_page_protections (pid_t pid, int prot)
 275 {
 276   const int num_buckets = ARRAY_SIZE (inf_ttrace_page_dict.buckets);
 277   const int pagesize = inf_ttrace_page_dict.pagesize;
 278   int bucket;
 279
 280   for (bucket = 0; bucket < num_buckets; bucket++)
 281     {
 282       struct inf_ttrace_page *page;
 283
 284       page = inf_ttrace_page_dict.buckets[bucket].next;
 285       while (page)
 286         {
 287           if (ttrace (TT_PROC_SET_MPROTECT, pid, 0,
 288                       page->addr, pagesize, page->prot & ~prot) == -1)
 289             perror_with_name (("ttrace"));
 290
 291           page = page->next;
 292         }
 293     }
 294 }
 295
 296 /* Write-protect the pages in the dictionary for process PID.  */
 297
 298 static void
 299 inf_ttrace_enable_page_protections (pid_t pid)
 300 {
 301   inf_ttrace_mask_page_protections (pid, PROT_WRITE);
 302 }
 303
 304 /* Restore the protection of the pages in the dictionary for process
 305    PID.  */
 306
 307 static void
 308 inf_ttrace_disable_page_protections (pid_t pid)
 309 {
 310   inf_ttrace_mask_page_protections (pid, 0);
 311 }
 312
 313 /* Insert a "hardware" watchpoint for LEN bytes at address ADDR of
 314    type TYPE.  */
 315
 316 static int
 317 inf_ttrace_insert_watchpoint (CORE_ADDR addr, int len, int type,
 318                               struct expression *cond)
 319 {
 320   const int pagesize = inf_ttrace_page_dict.pagesize;
 321   pid_t pid = ptid_get_pid (inferior_ptid);
 322   CORE_ADDR page_addr;
 323   int num_pages;
 324   int page;
 325
 326   gdb_assert (type == hw_write);
 327
 328   page_addr = (addr / pagesize) * pagesize;
 329   num_pages = (len + pagesize - 1) / pagesize;
 330
 331   for (page = 0; page < num_pages; page++, page_addr += pagesize)
 332     inf_ttrace_insert_page (pid, page_addr);
 333
 334   return 1;
 335 }
 336
 337 /* Remove a "hardware" watchpoint for LEN bytes at address ADDR of
 338    type TYPE.  */
 339
 340 static int
 341 inf_ttrace_remove_watchpoint (CORE_ADDR addr, int len, int type,
 342                               struct expression *cond)
 343 {
 344   const int pagesize = inf_ttrace_page_dict.pagesize;
 345   pid_t pid = ptid_get_pid (inferior_ptid);
 346   CORE_ADDR page_addr;
 347   int num_pages;
 348   int page;
 349
 350   gdb_assert (type == hw_write);
 351
 352   page_addr = (addr / pagesize) * pagesize;
 353   num_pages = (len + pagesize - 1) / pagesize;
 354
 355   for (page = 0; page < num_pages; page++, page_addr += pagesize)
 356     inf_ttrace_remove_page (pid, page_addr);
 357
 358   return 1;
 359 }
 360
 361 static int
 362 inf_ttrace_can_use_hw_breakpoint (int type, int len, int ot)
 363 {
 364   return (type == bp_hardware_watchpoint);
 365 }
 366
 367 static int
 368 inf_ttrace_region_ok_for_hw_watchpoint (CORE_ADDR addr, int len)
 369 {
 370   return 1;
 371 }
 372
 373 /* Return non-zero if the current inferior was (potentially) stopped
 374    by hitting a "hardware" watchpoint.  */
 375
 376 static int
 377 inf_ttrace_stopped_by_watchpoint (void)
 378 {
 379   pid_t pid = ptid_get_pid (inferior_ptid);
 380   lwpid_t lwpid = ptid_get_lwp (inferior_ptid);
 381   ttstate_t tts;
 382
 383   if (inf_ttrace_page_dict.count > 0)
 384     {
 385       if (ttrace (TT_LWP_GET_STATE, pid, lwpid,
 386                   (uintptr_t)&tts, sizeof tts, 0) == -1)
 387         perror_with_name (("ttrace"));
 388
 389       if (tts.tts_event == TTEVT_SIGNAL
 390           && tts.tts_u.tts_signal.tts_signo == SIGBUS)
 391         {
 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;
 395
 396           if (inf_ttrace_get_page (pid, page_addr))
 397             return 1;
 398         }
 399     }
 400
 401   return 0;
 402 }
 403 \f
 404
 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;
 410
 411 static int
 412 inf_ttrace_follow_fork (struct target_ops *ops, int follow_child,
 413                         int detach_fork)
 414 {
 415   pid_t pid, fpid;
 416   lwpid_t lwpid, flwpid;
 417   ttstate_t tts;
 418   struct thread_info *tp = inferior_thread ();
 419
 420   gdb_assert (tp->pending_follow.kind == TARGET_WAITKIND_FORKED
 421               || tp->pending_follow.kind == TARGET_WAITKIND_VFORKED);
 422
 423   pid = ptid_get_pid (inferior_ptid);
 424   lwpid = ptid_get_lwp (inferior_ptid);
 425
 426   /* Get all important details that core GDB doesn't (and shouldn't)
 427      know about.  */
 428   if (ttrace (TT_LWP_GET_STATE, pid, lwpid,
 429               (uintptr_t)&tts, sizeof tts, 0) == -1)
 430     perror_with_name (("ttrace"));
 431
 432   gdb_assert (tts.tts_event == TTEVT_FORK || tts.tts_event == TTEVT_VFORK);
 433
 434   if (tts.tts_u.tts_fork.tts_isparent)
 435     {
 436       pid = tts.tts_pid;
 437       lwpid = tts.tts_lwpid;
 438       fpid = tts.tts_u.tts_fork.tts_fpid;
 439       flwpid = tts.tts_u.tts_fork.tts_flwpid;
 440     }
 441   else
 442     {
 443       pid = tts.tts_u.tts_fork.tts_fpid;
 444       lwpid = tts.tts_u.tts_fork.tts_flwpid;
 445       fpid = tts.tts_pid;
 446       flwpid = tts.tts_lwpid;
 447     }
 448
 449   if (follow_child)
 450     {
 451       struct inferior *inf;
 452       struct inferior *parent_inf;
 453
 454       parent_inf = find_inferior_pid (pid);
 455
 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));
 463
 464       target_terminal_ours ();
 465       fprintf_unfiltered (gdb_stdlog,
 466                           _("Attaching after fork to child process %ld.\n"),
 467                           (long)fpid);
 468     }
 469   else
 470     {
 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));
 477
 478       target_terminal_ours ();
 479       fprintf_unfiltered (gdb_stdlog,
 480                           _("Detaching after fork from child process %ld.\n"),
 481                           (long)fpid);
 482     }
 483
 484   if (tts.tts_event == TTEVT_VFORK)
 485     {
 486       gdb_assert (!tts.tts_u.tts_fork.tts_isparent);
 487
 488       if (follow_child)
 489         {
 490           /* We can't detach from the parent yet.  */
 491           inf_ttrace_vfork_ppid = pid;
 492
 493           reattach_breakpoints (fpid);
 494         }
 495       else
 496         {
 497           if (ttrace (TT_PROC_DETACH, fpid, 0, 0, 0, 0) == -1)
 498             perror_with_name (("ttrace"));
 499
 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);
 507
 508           reattach_breakpoints (pid);
 509         }
 510     }
 511   else
 512     {
 513       gdb_assert (tts.tts_u.tts_fork.tts_isparent);
 514
 515       if (follow_child)
 516         {
 517           if (ttrace (TT_PROC_DETACH, pid, 0, 0, 0, 0) == -1)
 518             perror_with_name (("ttrace"));
 519         }
 520       else
 521         {
 522           if (ttrace (TT_PROC_DETACH, fpid, 0, 0, 0, 0) == -1)
 523             perror_with_name (("ttrace"));
 524         }
 525     }
 526
 527   if (follow_child)
 528     {
 529       struct thread_info *ti;
 530
 531       /* The child will start out single-threaded.  */
 532       inf_ttrace_num_lwps = 1;
 533       inf_ttrace_num_lwps_in_syscall = 0;
 534
 535       /* Delete parent.  */
 536       delete_thread_silent (ptid_build (pid, lwpid, 0));
 537       detach_inferior (pid);
 538
 539       /* Add child thread.  inferior_ptid was already set above.  */
 540       ti = add_thread_silent (inferior_ptid);
 541       ti->private =
 542         xmalloc (sizeof (struct inf_ttrace_private_thread_info));
 543       memset (ti->private, 0,
 544               sizeof (struct inf_ttrace_private_thread_info));
 545     }
 546
 547   return 0;
 548 }
 549 \f
 550
 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];
 555
 556 static void
 557 do_cleanup_pfds (void *dummy)
 558 {
 559   close (inf_ttrace_pfd1[0]);
 560   close (inf_ttrace_pfd1[1]);
 561   close (inf_ttrace_pfd2[0]);
 562   close (inf_ttrace_pfd2[1]);
 563
 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]);
 568 }
 569
 570 static void
 571 inf_ttrace_prepare (void)
 572 {
 573   if (pipe (inf_ttrace_pfd1) == -1)
 574     perror_with_name (("pipe"));
 575
 576   if (pipe (inf_ttrace_pfd2) == -1)
 577     {
 578       close (inf_ttrace_pfd1[0]);
 579       close (inf_ttrace_pfd2[0]);
 580       perror_with_name (("pipe"));
 581     }
 582
 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]);
 587 }
 588
 589 /* Prepare to be traced.  */
 590
 591 static void
 592 inf_ttrace_me (void)
 593 {
 594   struct cleanup *old_chain = make_cleanup (do_cleanup_pfds, 0);
 595   char c;
 596
 597   /* "Trace me, Dr. Memory!"  */
 598   if (ttrace (TT_PROC_SETTRC, 0, 0, 0, TT_VERSION, 0) == -1)
 599     perror_with_name (("ttrace"));
 600
 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"));
 604
 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"));
 608
 609   do_cleanups (old_chain);
 610 }
 611
 612 /* Start tracing PID.  */
 613
 614 static void
 615 inf_ttrace_him (struct target_ops *ops, int pid)
 616 {
 617   struct cleanup *old_chain = make_cleanup (do_cleanup_pfds, 0);
 618   ttevent_t tte;
 619   char c;
 620
 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"));
 624
 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;
 631 #endif
 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"));
 636
 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"));
 640
 641   do_cleanups (old_chain);
 642
 643   push_target (ops);
 644
 645   startup_inferior (START_INFERIOR_TRAPS_EXPECTED);
 646
 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));
 650 }
 651
 652 static void
 653 inf_ttrace_create_inferior (struct target_ops *ops, char *exec_file,
 654                             char *allargs, char **env, int from_tty)
 655 {
 656   int pid;
 657
 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);
 663
 664   pid = fork_inferior (exec_file, allargs, env, inf_ttrace_me, NULL,
 665                        inf_ttrace_prepare, NULL, NULL);
 666
 667   inf_ttrace_him (ops, pid);
 668 }
 669
 670 static void
 671 inf_ttrace_mourn_inferior (struct target_ops *ops)
 672 {
 673   const int num_buckets = ARRAY_SIZE (inf_ttrace_page_dict.buckets);
 674   int bucket;
 675
 676   inf_ttrace_num_lwps = 0;
 677   inf_ttrace_num_lwps_in_syscall = 0;
 678
 679   for (bucket = 0; bucket < num_buckets; bucket++)
 680     {
 681       struct inf_ttrace_page *page;
 682       struct inf_ttrace_page *next;
 683
 684       page = inf_ttrace_page_dict.buckets[bucket].next;
 685       while (page)
 686         {
 687           next = page->next;
 688           xfree (page);
 689           page = next;
 690         }
 691     }
 692   inf_ttrace_page_dict.count = 0;
 693
 694   unpush_target (ops);
 695   generic_mourn_inferior ();
 696 }
 697
 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
 700    list of threads.  */
 701
 702 static void
 703 inf_ttrace_create_threads_after_attach (int pid)
 704 {
 705   int status;
 706   ptid_t ptid;
 707   ttstate_t tts;
 708   struct thread_info *ti;
 709
 710   status = ttrace (TT_PROC_GET_FIRST_LWP_STATE, pid, 0,
 711                    (uintptr_t) &tts, sizeof (ttstate_t), 0);
 712   if (status < 0)
 713     perror_with_name (_("TT_PROC_GET_FIRST_LWP_STATE ttrace call failed"));
 714   gdb_assert (tts.tts_pid == pid);
 715
 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++;
 721
 722   /* We use the "first stopped thread" as the currently active thread.  */
 723   inferior_ptid = ptid;
 724
 725   /* Iterative over all the remaining threads.  */
 726
 727   for (;;)
 728     {
 729       ptid_t ptid;
 730
 731       status = ttrace (TT_PROC_GET_NEXT_LWP_STATE, pid, 0,
 732                        (uintptr_t) &tts, sizeof (ttstate_t), 0);
 733       if (status < 0)
 734         perror_with_name (_("TT_PROC_GET_NEXT_LWP_STATE ttrace call failed"));
 735       if (status == 0)
 736         break;  /* End of list.  */
 737
 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++;
 742     }
 743 }
 744
 745 static void
 746 inf_ttrace_attach (struct target_ops *ops, char *args, int from_tty)
 747 {
 748   char *exec_file;
 749   pid_t pid;
 750   ttevent_t tte;
 751   struct inferior *inf;
 752
 753   pid = parse_pid_to_attach (args);
 754
 755   if (pid == getpid ())         /* Trying to masturbate?  */
 756     error (_("I refuse to debug myself!"));
 757
 758   if (from_tty)
 759     {
 760       exec_file = get_exec_file (0);
 761
 762       if (exec_file)
 763         printf_unfiltered (_("Attaching to program: %s, %s\n"), exec_file,
 764                            target_pid_to_str (pid_to_ptid (pid)));
 765       else
 766         printf_unfiltered (_("Attaching to %s\n"),
 767                            target_pid_to_str (pid_to_ptid (pid)));
 768
 769       gdb_flush (gdb_stdout);
 770     }
 771
 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);
 775
 776   if (ttrace (TT_PROC_ATTACH, pid, 0, TT_KILL_ON_EXIT, TT_VERSION, 0) == -1)
 777     perror_with_name (("ttrace"));
 778
 779   inf = current_inferior ();
 780   inferior_appeared (inf, pid);
 781   inf->attach_flag = 1;
 782
 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;
 789 #endif
 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"));
 794
 795   push_target (ops);
 796
 797   inf_ttrace_create_threads_after_attach (pid);
 798 }
 799
 800 static void
 801 inf_ttrace_detach (struct target_ops *ops, const char *args, int from_tty)
 802 {
 803   pid_t pid = ptid_get_pid (inferior_ptid);
 804   int sig = 0;
 805
 806   if (from_tty)
 807     {
 808       char *exec_file = get_exec_file (0);
 809       if (exec_file == 0)
 810         exec_file = "";
 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);
 814     }
 815   if (args)
 816     sig = atoi (args);
 817
 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"));
 822
 823   if (inf_ttrace_vfork_ppid != -1)
 824     {
 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;
 828     }
 829
 830   inf_ttrace_num_lwps = 0;
 831   inf_ttrace_num_lwps_in_syscall = 0;
 832
 833   inferior_ptid = null_ptid;
 834   detach_inferior (pid);
 835
 836   unpush_target (ops);
 837 }
 838
 839 static void
 840 inf_ttrace_kill (struct target_ops *ops)
 841 {
 842   pid_t pid = ptid_get_pid (inferior_ptid);
 843
 844   if (pid == 0)
 845     return;
 846
 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?  */
 850
 851   if (inf_ttrace_vfork_ppid != -1)
 852     {
 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;
 856     }
 857
 858   target_mourn_inferior ();
 859 }
 860
 861 /* Check is a dying thread is dead by now, and delete it from GDBs
 862    thread list if so.  */
 863 static int
 864 inf_ttrace_delete_dead_threads_callback (struct thread_info *info, void *arg)
 865 {
 866   lwpid_t lwpid;
 867   struct inf_ttrace_private_thread_info *p;
 868
 869   if (is_exited (info->ptid))
 870     return 0;
 871
 872   lwpid = ptid_get_lwp (info->ptid);
 873   p = (struct inf_ttrace_private_thread_info *) info->private;
 874
 875   /* Check if an lwp that was dying is still there or not.  */
 876   if (p->dying && (kill (lwpid, 0) == -1))
 877     /* It's gone now.  */
 878     delete_thread (info->ptid);
 879
 880   return 0;
 881 }
 882
 883 /* Resume the lwp pointed to by INFO, with REQUEST, and pass it signal
 884    SIG.  */
 885
 886 static void
 887 inf_ttrace_resume_lwp (struct thread_info *info, ttreq_t request, int sig)
 888 {
 889   pid_t pid = ptid_get_pid (info->ptid);
 890   lwpid_t lwpid = ptid_get_lwp (info->ptid);
 891
 892   if (ttrace (request, pid, lwpid, TT_NOPC, sig, 0) == -1)
 893     {
 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);
 901       else
 902         /* This was really unexpected.  */
 903         perror_with_name (("ttrace"));
 904     }
 905 }
 906
 907 /* Callback for iterate_over_threads.  */
 908
 909 static int
 910 inf_ttrace_resume_callback (struct thread_info *info, void *arg)
 911 {
 912   if (!ptid_equal (info->ptid, inferior_ptid) && !is_exited (info->ptid))
 913     inf_ttrace_resume_lwp (info, TT_LWP_CONTINUE, 0);
 914
 915   return 0;
 916 }
 917
 918 static void
 919 inf_ttrace_resume (struct target_ops *ops,
 920                    ptid_t ptid, int step, enum gdb_signal signal)
 921 {
 922   int resume_all;
 923   ttreq_t request = step ? TT_LWP_SINGLE : TT_LWP_CONTINUE;
 924   int sig = gdb_signal_to_host (signal);
 925   struct thread_info *info;
 926
 927   /* A specific PTID means `step only this process id'.  */
 928   resume_all = (ptid_equal (ptid, minus_one_ptid));
 929
 930   /* If resuming all threads, it's the current thread that should be
 931      handled specially.  */
 932   if (resume_all)
 933     ptid = inferior_ptid;
 934
 935   info = find_thread_ptid (ptid);
 936   inf_ttrace_resume_lwp (info, request, sig);
 937
 938   if (resume_all)
 939     /* Let all the other threads run too.  */
 940     iterate_over_threads (inf_ttrace_resume_callback, NULL);
 941 }
 942
 943 static ptid_t
 944 inf_ttrace_wait (struct target_ops *ops,
 945                  ptid_t ptid, struct target_waitstatus *ourstatus, int options)
 946 {
 947   pid_t pid = ptid_get_pid (ptid);
 948   lwpid_t lwpid = ptid_get_lwp (ptid);
 949   ttstate_t tts;
 950   struct thread_info *ti;
 951   ptid_t related_ptid;
 952
 953   /* Until proven otherwise.  */
 954   ourstatus->kind = TARGET_WAITKIND_SPURIOUS;
 955
 956   if (pid == -1)
 957     pid = lwpid = 0;
 958
 959   gdb_assert (pid != 0 || lwpid == 0);
 960
 961   do
 962     {
 963       set_sigint_trap ();
 964
 965       if (ttrace_wait (pid, lwpid, TTRACE_WAITOK, &tts, sizeof tts) == -1)
 966         perror_with_name (("ttrace_wait"));
 967
 968       if (tts.tts_event == TTEVT_VFORK && tts.tts_u.tts_fork.tts_isparent)
 969         {
 970           if (inf_ttrace_vfork_ppid != -1)
 971             {
 972               gdb_assert (inf_ttrace_vfork_ppid == tts.tts_pid);
 973
 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;
 977             }
 978
 979           tts.tts_event = TTEVT_NONE;
 980         }
 981
 982       clear_sigint_trap ();
 983     }
 984   while (tts.tts_event == TTEVT_NONE);
 985
 986   /* Now that we've waited, we can re-enable the page protections.  */
 987   if (inf_ttrace_reenable_page_protections)
 988     {
 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;
 992     }
 993
 994   ptid = ptid_build (tts.tts_pid, tts.tts_lwpid, 0);
 995
 996   if (inf_ttrace_num_lwps == 0)
 997     {
 998       struct thread_info *ti;
 999
1000       inf_ttrace_num_lwps = 1;
1001
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);
1005
1006       /* We haven't set the private member on the main thread yet.  Do
1007          it now.  */
1008       ti = find_thread_ptid (inferior_ptid);
1009       gdb_assert (ti != NULL && ti->private == NULL);
1010       ti->private =
1011         xmalloc (sizeof (struct inf_ttrace_private_thread_info));
1012       memset (ti->private, 0,
1013               sizeof (struct inf_ttrace_private_thread_info));
1014
1015       /* Notify the core that this ptid changed.  This changes
1016          inferior_ptid as well.  */
1017       thread_change_ptid (inferior_ptid, ptid);
1018     }
1019
1020   switch (tts.tts_event)
1021     {
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;
1027       break;
1028 #endif
1029
1030     case TTEVT_EXEC:
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;
1039
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 ();
1045       break;
1046
1047     case TTEVT_EXIT:
1048       store_waitstatus (ourstatus, tts.tts_u.tts_exit.tts_exitcode);
1049       inf_ttrace_num_lwps = 0;
1050       break;
1051
1052     case TTEVT_FORK:
1053       related_ptid = ptid_build (tts.tts_u.tts_fork.tts_fpid,
1054                                  tts.tts_u.tts_fork.tts_flwpid, 0);
1055
1056       ourstatus->kind = TARGET_WAITKIND_FORKED;
1057       ourstatus->value.related_pid = related_ptid;
1058
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"));
1064
1065       gdb_assert (tts.tts_event == TTEVT_FORK);
1066       if (tts.tts_u.tts_fork.tts_isparent)
1067         {
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;
1072         }
1073       break;
1074
1075     case TTEVT_VFORK:
1076       gdb_assert (!tts.tts_u.tts_fork.tts_isparent);
1077
1078       related_ptid = ptid_build (tts.tts_u.tts_fork.tts_fpid,
1079                                  tts.tts_u.tts_fork.tts_flwpid, 0);
1080
1081       ourstatus->kind = TARGET_WAITKIND_VFORKED;
1082       ourstatus->value.related_pid = related_ptid;
1083
1084       /* HACK: To avoid touching the parent during the vfork, switch
1085          away from it.  */
1086       inferior_ptid = ptid;
1087       break;
1088
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);
1093       ti->private =
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;
1104       return ptid;
1105
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;
1118       return ptid;
1119
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--;
1130
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;
1137       return ptid;
1138
1139     case TTEVT_SIGNAL:
1140       ourstatus->kind = TARGET_WAITKIND_STOPPED;
1141       ourstatus->value.sig =
1142         gdb_signal_from_host (tts.tts_u.tts_signal.tts_signo);
1143       break;
1144
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)
1149         {
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);
1153         }
1154       ourstatus->kind = TARGET_WAITKIND_SYSCALL_ENTRY;
1155       ourstatus->value.syscall_number = tts.tts_scno;
1156       break;
1157
1158     case TTEVT_SYSCALL_RETURN:
1159       if (inf_ttrace_num_lwps_in_syscall > 0)
1160         {
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--;
1168         }
1169       ourstatus->kind = TARGET_WAITKIND_SYSCALL_RETURN;
1170       ourstatus->value.syscall_number = tts.tts_scno;
1171       break;
1172
1173     default:
1174       gdb_assert (!"Unexpected ttrace event");
1175       break;
1176     }
1177
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"));
1181
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);
1191
1192   return ptid;
1193 }
1194
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).  */
1200
1201 static LONGEST
1202 inf_ttrace_xfer_memory (CORE_ADDR addr, ULONGEST len,
1203                         void *readbuf, const void *writebuf)
1204 {
1205   pid_t pid = ptid_get_pid (inferior_ptid);
1206
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.  */
1211
1212   if (readbuf
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)
1215     return 0;
1216
1217   if (writebuf
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)
1220     return 0;
1221
1222   return len;
1223 }
1224
1225 static LONGEST
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)
1230 {
1231   switch (object)
1232     {
1233     case TARGET_OBJECT_MEMORY:
1234       return inf_ttrace_xfer_memory (offset, len, readbuf, writebuf);
1235
1236     case TARGET_OBJECT_UNWIND_TABLE:
1237       return -1;
1238
1239     case TARGET_OBJECT_AUXV:
1240       return -1;
1241
1242     case TARGET_OBJECT_WCOOKIE:
1243       return -1;
1244
1245     default:
1246       return -1;
1247     }
1248 }
1249
1250 /* Print status information about what we're accessing.  */
1251
1252 static void
1253 inf_ttrace_files_info (struct target_ops *ignore)
1254 {
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));
1259 }
1260
1261 static int
1262 inf_ttrace_thread_alive (struct target_ops *ops, ptid_t ptid)
1263 {
1264   return 1;
1265 }
1266
1267 /* Return a string describing the state of the thread specified by
1268    INFO.  */
1269
1270 static char *
1271 inf_ttrace_extra_thread_info (struct thread_info *info)
1272 {
1273   struct inf_ttrace_private_thread_info* private =
1274     (struct inf_ttrace_private_thread_info *) info->private;
1275
1276   if (private != NULL && private->dying)
1277     return "Exiting";
1278
1279   return NULL;
1280 }
1281
1282 static char *
1283 inf_ttrace_pid_to_str (struct target_ops *ops, ptid_t ptid)
1284 {
1285   pid_t pid = ptid_get_pid (ptid);
1286   lwpid_t lwpid = ptid_get_lwp (ptid);
1287   static char buf[128];
1288
1289   if (lwpid == 0)
1290     xsnprintf (buf, sizeof buf, "process %ld",
1291                (long) pid);
1292   else
1293     xsnprintf (buf, sizeof buf, "process %ld, lwp %ld",
1294                (long) pid, (long) lwpid);
1295   return buf;
1296 }
1297 \f
1298
1299 /* Implement the get_ada_task_ptid target_ops method.  */
1300
1301 static ptid_t
1302 inf_ttrace_get_ada_task_ptid (long lwp, long thread)
1303 {
1304   return ptid_build (ptid_get_pid (inferior_ptid), lwp, 0);
1305 }
1306
1307 \f
1308 struct target_ops *
1309 inf_ttrace_target (void)
1310 {
1311   struct target_ops *t = inf_child_target ();
1312
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;
1333
1334   return t;
1335 }
1336 #endif
1337 \f
1338
1339 /* Prevent warning from -Wmissing-prototypes.  */
1340 void _initialize_inf_ttrace (void);
1341
1342 void
1343 _initialize_inf_ttrace (void)
1344 {
1345 #ifdef HAVE_TTRACE
1346   inf_ttrace_page_dict.pagesize = getpagesize();
1347 #endif
1348 }