gdb/inf-ttrace.c

   1 /* Low-level child interface to ttrace.
   2
   3    Copyright (C) 2004-2013 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 "gdb_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 = XMALLOC (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   /* START_INFERIOR_TRAPS_EXPECTED is defined in inferior.h, and will
 646      be 1 or 2 depending on whether we're starting without or with a
 647      shell.  */
 648   startup_inferior (START_INFERIOR_TRAPS_EXPECTED);
 649
 650   /* On some targets, there must be some explicit actions taken after
 651      the inferior has been started up.  */
 652   target_post_startup_inferior (pid_to_ptid (pid));
 653 }
 654
 655 static void
 656 inf_ttrace_create_inferior (struct target_ops *ops, char *exec_file,
 657                             char *allargs, char **env, int from_tty)
 658 {
 659   int pid;
 660
 661   gdb_assert (inf_ttrace_num_lwps == 0);
 662   gdb_assert (inf_ttrace_num_lwps_in_syscall == 0);
 663   gdb_assert (inf_ttrace_page_dict.count == 0);
 664   gdb_assert (inf_ttrace_reenable_page_protections == 0);
 665   gdb_assert (inf_ttrace_vfork_ppid == -1);
 666
 667   pid = fork_inferior (exec_file, allargs, env, inf_ttrace_me, NULL,
 668                        inf_ttrace_prepare, NULL, NULL);
 669
 670   inf_ttrace_him (ops, pid);
 671 }
 672
 673 static void
 674 inf_ttrace_mourn_inferior (struct target_ops *ops)
 675 {
 676   const int num_buckets = ARRAY_SIZE (inf_ttrace_page_dict.buckets);
 677   int bucket;
 678
 679   inf_ttrace_num_lwps = 0;
 680   inf_ttrace_num_lwps_in_syscall = 0;
 681
 682   for (bucket = 0; bucket < num_buckets; bucket++)
 683     {
 684       struct inf_ttrace_page *page;
 685       struct inf_ttrace_page *next;
 686
 687       page = inf_ttrace_page_dict.buckets[bucket].next;
 688       while (page)
 689         {
 690           next = page->next;
 691           xfree (page);
 692           page = next;
 693         }
 694     }
 695   inf_ttrace_page_dict.count = 0;
 696
 697   unpush_target (ops);
 698   generic_mourn_inferior ();
 699 }
 700
 701 /* Assuming we just attached the debugger to a new inferior, create
 702    a new thread_info structure for each thread, and add it to our
 703    list of threads.  */
 704
 705 static void
 706 inf_ttrace_create_threads_after_attach (int pid)
 707 {
 708   int status;
 709   ptid_t ptid;
 710   ttstate_t tts;
 711   struct thread_info *ti;
 712
 713   status = ttrace (TT_PROC_GET_FIRST_LWP_STATE, pid, 0,
 714                    (uintptr_t) &tts, sizeof (ttstate_t), 0);
 715   if (status < 0)
 716     perror_with_name (_("TT_PROC_GET_FIRST_LWP_STATE ttrace call failed"));
 717   gdb_assert (tts.tts_pid == pid);
 718
 719   /* Add the stopped thread.  */
 720   ptid = ptid_build (pid, tts.tts_lwpid, 0);
 721   ti = add_thread (ptid);
 722   ti->private = xzalloc (sizeof (struct inf_ttrace_private_thread_info));
 723   inf_ttrace_num_lwps++;
 724
 725   /* We use the "first stopped thread" as the currently active thread.  */
 726   inferior_ptid = ptid;
 727
 728   /* Iterative over all the remaining threads.  */
 729
 730   for (;;)
 731     {
 732       ptid_t ptid;
 733
 734       status = ttrace (TT_PROC_GET_NEXT_LWP_STATE, pid, 0,
 735                        (uintptr_t) &tts, sizeof (ttstate_t), 0);
 736       if (status < 0)
 737         perror_with_name (_("TT_PROC_GET_NEXT_LWP_STATE ttrace call failed"));
 738       if (status == 0)
 739         break;  /* End of list.  */
 740
 741       ptid = ptid_build (tts.tts_pid, tts.tts_lwpid, 0);
 742       ti = add_thread (ptid);
 743       ti->private = xzalloc (sizeof (struct inf_ttrace_private_thread_info));
 744       inf_ttrace_num_lwps++;
 745     }
 746 }
 747
 748 static void
 749 inf_ttrace_attach (struct target_ops *ops, char *args, int from_tty)
 750 {
 751   char *exec_file;
 752   pid_t pid;
 753   ttevent_t tte;
 754   struct inferior *inf;
 755
 756   pid = parse_pid_to_attach (args);
 757
 758   if (pid == getpid ())         /* Trying to masturbate?  */
 759     error (_("I refuse to debug myself!"));
 760
 761   if (from_tty)
 762     {
 763       exec_file = get_exec_file (0);
 764
 765       if (exec_file)
 766         printf_unfiltered (_("Attaching to program: %s, %s\n"), exec_file,
 767                            target_pid_to_str (pid_to_ptid (pid)));
 768       else
 769         printf_unfiltered (_("Attaching to %s\n"),
 770                            target_pid_to_str (pid_to_ptid (pid)));
 771
 772       gdb_flush (gdb_stdout);
 773     }
 774
 775   gdb_assert (inf_ttrace_num_lwps == 0);
 776   gdb_assert (inf_ttrace_num_lwps_in_syscall == 0);
 777   gdb_assert (inf_ttrace_vfork_ppid == -1);
 778
 779   if (ttrace (TT_PROC_ATTACH, pid, 0, TT_KILL_ON_EXIT, TT_VERSION, 0) == -1)
 780     perror_with_name (("ttrace"));
 781
 782   inf = current_inferior ();
 783   inferior_appeared (inf, pid);
 784   inf->attach_flag = 1;
 785
 786   /* Set the initial event mask.  */
 787   memset (&tte, 0, sizeof (tte));
 788   tte.tte_events |= TTEVT_EXEC | TTEVT_EXIT | TTEVT_FORK | TTEVT_VFORK;
 789   tte.tte_events |= TTEVT_LWP_CREATE | TTEVT_LWP_EXIT | TTEVT_LWP_TERMINATE;
 790 #ifdef TTEVT_BPT_SSTEP
 791   tte.tte_events |= TTEVT_BPT_SSTEP;
 792 #endif
 793   tte.tte_opts |= TTEO_PROC_INHERIT;
 794   if (ttrace (TT_PROC_SET_EVENT_MASK, pid, 0,
 795               (uintptr_t)&tte, sizeof tte, 0) == -1)
 796     perror_with_name (("ttrace"));
 797
 798   push_target (ops);
 799
 800   inf_ttrace_create_threads_after_attach (pid);
 801 }
 802
 803 static void
 804 inf_ttrace_detach (struct target_ops *ops, char *args, int from_tty)
 805 {
 806   pid_t pid = ptid_get_pid (inferior_ptid);
 807   int sig = 0;
 808
 809   if (from_tty)
 810     {
 811       char *exec_file = get_exec_file (0);
 812       if (exec_file == 0)
 813         exec_file = "";
 814       printf_unfiltered (_("Detaching from program: %s, %s\n"), exec_file,
 815                          target_pid_to_str (pid_to_ptid (pid)));
 816       gdb_flush (gdb_stdout);
 817     }
 818   if (args)
 819     sig = atoi (args);
 820
 821   /* ??? The HP-UX 11.0 ttrace(2) manual page doesn't mention that we
 822      can pass a signal number here.  Does this really work?  */
 823   if (ttrace (TT_PROC_DETACH, pid, 0, 0, sig, 0) == -1)
 824     perror_with_name (("ttrace"));
 825
 826   if (inf_ttrace_vfork_ppid != -1)
 827     {
 828       if (ttrace (TT_PROC_DETACH, inf_ttrace_vfork_ppid, 0, 0, 0, 0) == -1)
 829         perror_with_name (("ttrace"));
 830       inf_ttrace_vfork_ppid = -1;
 831     }
 832
 833   inf_ttrace_num_lwps = 0;
 834   inf_ttrace_num_lwps_in_syscall = 0;
 835
 836   inferior_ptid = null_ptid;
 837   detach_inferior (pid);
 838
 839   unpush_target (ops);
 840 }
 841
 842 static void
 843 inf_ttrace_kill (struct target_ops *ops)
 844 {
 845   pid_t pid = ptid_get_pid (inferior_ptid);
 846
 847   if (pid == 0)
 848     return;
 849
 850   if (ttrace (TT_PROC_EXIT, pid, 0, 0, 0, 0) == -1)
 851     perror_with_name (("ttrace"));
 852   /* ??? Is it necessary to call ttrace_wait() here?  */
 853
 854   if (inf_ttrace_vfork_ppid != -1)
 855     {
 856       if (ttrace (TT_PROC_DETACH, inf_ttrace_vfork_ppid, 0, 0, 0, 0) == -1)
 857         perror_with_name (("ttrace"));
 858       inf_ttrace_vfork_ppid = -1;
 859     }
 860
 861   target_mourn_inferior ();
 862 }
 863
 864 /* Check is a dying thread is dead by now, and delete it from GDBs
 865    thread list if so.  */
 866 static int
 867 inf_ttrace_delete_dead_threads_callback (struct thread_info *info, void *arg)
 868 {
 869   lwpid_t lwpid;
 870   struct inf_ttrace_private_thread_info *p;
 871
 872   if (is_exited (info->ptid))
 873     return 0;
 874
 875   lwpid = ptid_get_lwp (info->ptid);
 876   p = (struct inf_ttrace_private_thread_info *) info->private;
 877
 878   /* Check if an lwp that was dying is still there or not.  */
 879   if (p->dying && (kill (lwpid, 0) == -1))
 880     /* It's gone now.  */
 881     delete_thread (info->ptid);
 882
 883   return 0;
 884 }
 885
 886 /* Resume the lwp pointed to by INFO, with REQUEST, and pass it signal
 887    SIG.  */
 888
 889 static void
 890 inf_ttrace_resume_lwp (struct thread_info *info, ttreq_t request, int sig)
 891 {
 892   pid_t pid = ptid_get_pid (info->ptid);
 893   lwpid_t lwpid = ptid_get_lwp (info->ptid);
 894
 895   if (ttrace (request, pid, lwpid, TT_NOPC, sig, 0) == -1)
 896     {
 897       struct inf_ttrace_private_thread_info *p
 898         = (struct inf_ttrace_private_thread_info *) info->private;
 899       if (p->dying && errno == EPROTO)
 900         /* This is expected, it means the dying lwp is really gone
 901            by now.  If ttrace had an event to inform the debugger
 902            the lwp is really gone, this wouldn't be needed.  */
 903         delete_thread (info->ptid);
 904       else
 905         /* This was really unexpected.  */
 906         perror_with_name (("ttrace"));
 907     }
 908 }
 909
 910 /* Callback for iterate_over_threads.  */
 911
 912 static int
 913 inf_ttrace_resume_callback (struct thread_info *info, void *arg)
 914 {
 915   if (!ptid_equal (info->ptid, inferior_ptid) && !is_exited (info->ptid))
 916     inf_ttrace_resume_lwp (info, TT_LWP_CONTINUE, 0);
 917
 918   return 0;
 919 }
 920
 921 static void
 922 inf_ttrace_resume (struct target_ops *ops,
 923                    ptid_t ptid, int step, enum gdb_signal signal)
 924 {
 925   int resume_all;
 926   ttreq_t request = step ? TT_LWP_SINGLE : TT_LWP_CONTINUE;
 927   int sig = gdb_signal_to_host (signal);
 928   struct thread_info *info;
 929
 930   /* A specific PTID means `step only this process id'.  */
 931   resume_all = (ptid_equal (ptid, minus_one_ptid));
 932
 933   /* If resuming all threads, it's the current thread that should be
 934      handled specially.  */
 935   if (resume_all)
 936     ptid = inferior_ptid;
 937
 938   info = find_thread_ptid (ptid);
 939   inf_ttrace_resume_lwp (info, request, sig);
 940
 941   if (resume_all)
 942     /* Let all the other threads run too.  */
 943     iterate_over_threads (inf_ttrace_resume_callback, NULL);
 944 }
 945
 946 static ptid_t
 947 inf_ttrace_wait (struct target_ops *ops,
 948                  ptid_t ptid, struct target_waitstatus *ourstatus, int options)
 949 {
 950   pid_t pid = ptid_get_pid (ptid);
 951   lwpid_t lwpid = ptid_get_lwp (ptid);
 952   ttstate_t tts;
 953   struct thread_info *ti;
 954   ptid_t related_ptid;
 955
 956   /* Until proven otherwise.  */
 957   ourstatus->kind = TARGET_WAITKIND_SPURIOUS;
 958
 959   if (pid == -1)
 960     pid = lwpid = 0;
 961
 962   gdb_assert (pid != 0 || lwpid == 0);
 963
 964   do
 965     {
 966       set_sigint_trap ();
 967
 968       if (ttrace_wait (pid, lwpid, TTRACE_WAITOK, &tts, sizeof tts) == -1)
 969         perror_with_name (("ttrace_wait"));
 970
 971       if (tts.tts_event == TTEVT_VFORK && tts.tts_u.tts_fork.tts_isparent)
 972         {
 973           if (inf_ttrace_vfork_ppid != -1)
 974             {
 975               gdb_assert (inf_ttrace_vfork_ppid == tts.tts_pid);
 976
 977               if (ttrace (TT_PROC_DETACH, tts.tts_pid, 0, 0, 0, 0) == -1)
 978                 perror_with_name (("ttrace"));
 979               inf_ttrace_vfork_ppid = -1;
 980             }
 981
 982           tts.tts_event = TTEVT_NONE;
 983         }
 984
 985       clear_sigint_trap ();
 986     }
 987   while (tts.tts_event == TTEVT_NONE);
 988
 989   /* Now that we've waited, we can re-enable the page protections.  */
 990   if (inf_ttrace_reenable_page_protections)
 991     {
 992       gdb_assert (inf_ttrace_num_lwps_in_syscall == 0);
 993       inf_ttrace_enable_page_protections (tts.tts_pid);
 994       inf_ttrace_reenable_page_protections = 0;
 995     }
 996
 997   ptid = ptid_build (tts.tts_pid, tts.tts_lwpid, 0);
 998
 999   if (inf_ttrace_num_lwps == 0)
1000     {
1001       struct thread_info *ti;
1002
1003       inf_ttrace_num_lwps = 1;
1004
1005       /* This is the earliest we hear about the lwp member of
1006          INFERIOR_PTID, after an attach or fork_inferior.  */
1007       gdb_assert (ptid_get_lwp (inferior_ptid) == 0);
1008
1009       /* We haven't set the private member on the main thread yet.  Do
1010          it now.  */
1011       ti = find_thread_ptid (inferior_ptid);
1012       gdb_assert (ti != NULL && ti->private == NULL);
1013       ti->private =
1014         xmalloc (sizeof (struct inf_ttrace_private_thread_info));
1015       memset (ti->private, 0,
1016               sizeof (struct inf_ttrace_private_thread_info));
1017
1018       /* Notify the core that this ptid changed.  This changes
1019          inferior_ptid as well.  */
1020       thread_change_ptid (inferior_ptid, ptid);
1021     }
1022
1023   switch (tts.tts_event)
1024     {
1025 #ifdef TTEVT_BPT_SSTEP
1026     case TTEVT_BPT_SSTEP:
1027       /* Make it look like a breakpoint.  */
1028       ourstatus->kind = TARGET_WAITKIND_STOPPED;
1029       ourstatus->value.sig = GDB_SIGNAL_TRAP;
1030       break;
1031 #endif
1032
1033     case TTEVT_EXEC:
1034       ourstatus->kind = TARGET_WAITKIND_EXECD;
1035       ourstatus->value.execd_pathname =
1036         xmalloc (tts.tts_u.tts_exec.tts_pathlen + 1);
1037       if (ttrace (TT_PROC_GET_PATHNAME, tts.tts_pid, 0,
1038                   (uintptr_t)ourstatus->value.execd_pathname,
1039                   tts.tts_u.tts_exec.tts_pathlen, 0) == -1)
1040         perror_with_name (("ttrace"));
1041       ourstatus->value.execd_pathname[tts.tts_u.tts_exec.tts_pathlen] = 0;
1042
1043       /* At this point, all inserted breakpoints are gone.  Doing this
1044          as soon as we detect an exec prevents the badness of deleting
1045          a breakpoint writing the current "shadow contents" to lift
1046          the bp.  That shadow is NOT valid after an exec.  */
1047       mark_breakpoints_out ();
1048       break;
1049
1050     case TTEVT_EXIT:
1051       store_waitstatus (ourstatus, tts.tts_u.tts_exit.tts_exitcode);
1052       inf_ttrace_num_lwps = 0;
1053       break;
1054
1055     case TTEVT_FORK:
1056       related_ptid = ptid_build (tts.tts_u.tts_fork.tts_fpid,
1057                                  tts.tts_u.tts_fork.tts_flwpid, 0);
1058
1059       ourstatus->kind = TARGET_WAITKIND_FORKED;
1060       ourstatus->value.related_pid = related_ptid;
1061
1062       /* Make sure the other end of the fork is stopped too.  */
1063       if (ttrace_wait (tts.tts_u.tts_fork.tts_fpid,
1064                        tts.tts_u.tts_fork.tts_flwpid,
1065                        TTRACE_WAITOK, &tts, sizeof tts) == -1)
1066         perror_with_name (("ttrace_wait"));
1067
1068       gdb_assert (tts.tts_event == TTEVT_FORK);
1069       if (tts.tts_u.tts_fork.tts_isparent)
1070         {
1071           related_ptid = ptid_build (tts.tts_u.tts_fork.tts_fpid,
1072                                      tts.tts_u.tts_fork.tts_flwpid, 0);
1073           ptid = ptid_build (tts.tts_pid, tts.tts_lwpid, 0);
1074           ourstatus->value.related_pid = related_ptid;
1075         }
1076       break;
1077
1078     case TTEVT_VFORK:
1079       gdb_assert (!tts.tts_u.tts_fork.tts_isparent);
1080
1081       related_ptid = ptid_build (tts.tts_u.tts_fork.tts_fpid,
1082                                  tts.tts_u.tts_fork.tts_flwpid, 0);
1083
1084       ourstatus->kind = TARGET_WAITKIND_VFORKED;
1085       ourstatus->value.related_pid = related_ptid;
1086
1087       /* HACK: To avoid touching the parent during the vfork, switch
1088          away from it.  */
1089       inferior_ptid = ptid;
1090       break;
1091
1092     case TTEVT_LWP_CREATE:
1093       lwpid = tts.tts_u.tts_thread.tts_target_lwpid;
1094       ptid = ptid_build (tts.tts_pid, lwpid, 0);
1095       ti = add_thread (ptid);
1096       ti->private =
1097         xmalloc (sizeof (struct inf_ttrace_private_thread_info));
1098       memset (ti->private, 0,
1099               sizeof (struct inf_ttrace_private_thread_info));
1100       inf_ttrace_num_lwps++;
1101       ptid = ptid_build (tts.tts_pid, tts.tts_lwpid, 0);
1102       /* Let the lwp_create-caller thread continue.  */
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;
1107       return ptid;
1108
1109     case TTEVT_LWP_EXIT:
1110       if (print_thread_events)
1111         printf_unfiltered (_("[%s exited]\n"), target_pid_to_str (ptid));
1112       ti = find_thread_ptid (ptid);
1113       gdb_assert (ti != NULL);
1114       ((struct inf_ttrace_private_thread_info *)ti->private)->dying = 1;
1115       inf_ttrace_num_lwps--;
1116       /* Let the thread really exit.  */
1117       ttrace (TT_LWP_CONTINUE, ptid_get_pid (ptid),
1118               ptid_get_lwp (ptid), TT_NOPC, 0, 0);
1119       /* Return without stopping the whole process.  */
1120       ourstatus->kind = TARGET_WAITKIND_IGNORE;
1121       return ptid;
1122
1123     case TTEVT_LWP_TERMINATE:
1124       lwpid = tts.tts_u.tts_thread.tts_target_lwpid;
1125       ptid = ptid_build (tts.tts_pid, lwpid, 0);
1126       if (print_thread_events)
1127         printf_unfiltered(_("[%s has been terminated]\n"),
1128                           target_pid_to_str (ptid));
1129       ti = find_thread_ptid (ptid);
1130       gdb_assert (ti != NULL);
1131       ((struct inf_ttrace_private_thread_info *)ti->private)->dying = 1;
1132       inf_ttrace_num_lwps--;
1133
1134       /* Resume the lwp_terminate-caller thread.  */
1135       ptid = ptid_build (tts.tts_pid, tts.tts_lwpid, 0);
1136       ttrace (TT_LWP_CONTINUE, ptid_get_pid (ptid),
1137               ptid_get_lwp (ptid), TT_NOPC, 0, 0);
1138       /* Return without stopping the whole process.  */
1139       ourstatus->kind = TARGET_WAITKIND_IGNORE;
1140       return ptid;
1141
1142     case TTEVT_SIGNAL:
1143       ourstatus->kind = TARGET_WAITKIND_STOPPED;
1144       ourstatus->value.sig =
1145         gdb_signal_from_host (tts.tts_u.tts_signal.tts_signo);
1146       break;
1147
1148     case TTEVT_SYSCALL_ENTRY:
1149       gdb_assert (inf_ttrace_reenable_page_protections == 0);
1150       inf_ttrace_num_lwps_in_syscall++;
1151       if (inf_ttrace_num_lwps_in_syscall == 1)
1152         {
1153           /* A thread has just entered a system call.  Disable any
1154              page protections as the kernel can't deal with them.  */
1155           inf_ttrace_disable_page_protections (tts.tts_pid);
1156         }
1157       ourstatus->kind = TARGET_WAITKIND_SYSCALL_ENTRY;
1158       ourstatus->value.syscall_number = tts.tts_scno;
1159       break;
1160
1161     case TTEVT_SYSCALL_RETURN:
1162       if (inf_ttrace_num_lwps_in_syscall > 0)
1163         {
1164           /* If the last thread has just left the system call, this
1165              would be a logical place to re-enable the page
1166              protections, but that doesn't work.  We can't re-enable
1167              them until we've done another wait.  */
1168           inf_ttrace_reenable_page_protections =
1169             (inf_ttrace_num_lwps_in_syscall == 1);
1170           inf_ttrace_num_lwps_in_syscall--;
1171         }
1172       ourstatus->kind = TARGET_WAITKIND_SYSCALL_RETURN;
1173       ourstatus->value.syscall_number = tts.tts_scno;
1174       break;
1175
1176     default:
1177       gdb_assert (!"Unexpected ttrace event");
1178       break;
1179     }
1180
1181   /* Make sure all threads within the process are stopped.  */
1182   if (ttrace (TT_PROC_STOP, tts.tts_pid, 0, 0, 0, 0) == -1)
1183     perror_with_name (("ttrace"));
1184
1185   /* Now that the whole process is stopped, check if any dying thread
1186      is really dead by now.  If a dying thread is still alive, it will
1187      be stopped too, and will still show up in `info threads', tagged
1188      with "(Exiting)".  We could make `info threads' prune dead
1189      threads instead via inf_ttrace_thread_alive, but doing this here
1190      has the advantage that a frontend is notificed sooner of thread
1191      exits.  Note that a dying lwp is still alive, it still has to be
1192      resumed, like any other lwp.  */
1193   iterate_over_threads (inf_ttrace_delete_dead_threads_callback, NULL);
1194
1195   return ptid;
1196 }
1197
1198 /* Transfer LEN bytes from ADDR in the inferior's memory into READBUF,
1199    and transfer LEN bytes from WRITEBUF into the inferior's memory at
1200    ADDR.  Either READBUF or WRITEBUF may be null, in which case the
1201    corresponding transfer doesn't happen.  Return the number of bytes
1202    actually transferred (which may be zero if an error occurs).  */
1203
1204 static LONGEST
1205 inf_ttrace_xfer_memory (CORE_ADDR addr, ULONGEST len,
1206                         void *readbuf, const void *writebuf)
1207 {
1208   pid_t pid = ptid_get_pid (inferior_ptid);
1209
1210   /* HP-UX treats text space and data space differently.  GDB however,
1211      doesn't really know the difference.  Therefore we try both.  Try
1212      text space before data space though because when we're writing
1213      into text space the instruction cache might need to be flushed.  */
1214
1215   if (readbuf
1216       && ttrace (TT_PROC_RDTEXT, pid, 0, addr, len, (uintptr_t)readbuf) == -1
1217       && ttrace (TT_PROC_RDDATA, pid, 0, addr, len, (uintptr_t)readbuf) == -1)
1218     return 0;
1219
1220   if (writebuf
1221       && ttrace (TT_PROC_WRTEXT, pid, 0, addr, len, (uintptr_t)writebuf) == -1
1222       && ttrace (TT_PROC_WRDATA, pid, 0, addr, len, (uintptr_t)writebuf) == -1)
1223     return 0;
1224
1225   return len;
1226 }
1227
1228 static LONGEST
1229 inf_ttrace_xfer_partial (struct target_ops *ops, enum target_object object,
1230                          const char *annex, gdb_byte *readbuf,
1231                          const gdb_byte *writebuf,
1232                          ULONGEST offset, LONGEST len)
1233 {
1234   switch (object)
1235     {
1236     case TARGET_OBJECT_MEMORY:
1237       return inf_ttrace_xfer_memory (offset, len, readbuf, writebuf);
1238
1239     case TARGET_OBJECT_UNWIND_TABLE:
1240       return -1;
1241
1242     case TARGET_OBJECT_AUXV:
1243       return -1;
1244
1245     case TARGET_OBJECT_WCOOKIE:
1246       return -1;
1247
1248     default:
1249       return -1;
1250     }
1251 }
1252
1253 /* Print status information about what we're accessing.  */
1254
1255 static void
1256 inf_ttrace_files_info (struct target_ops *ignore)
1257 {
1258   struct inferior *inf = current_inferior ();
1259   printf_filtered (_("\tUsing the running image of %s %s.\n"),
1260                    inf->attach_flag ? "attached" : "child",
1261                    target_pid_to_str (inferior_ptid));
1262 }
1263
1264 static int
1265 inf_ttrace_thread_alive (struct target_ops *ops, ptid_t ptid)
1266 {
1267   return 1;
1268 }
1269
1270 /* Return a string describing the state of the thread specified by
1271    INFO.  */
1272
1273 static char *
1274 inf_ttrace_extra_thread_info (struct thread_info *info)
1275 {
1276   struct inf_ttrace_private_thread_info* private =
1277     (struct inf_ttrace_private_thread_info *) info->private;
1278
1279   if (private != NULL && private->dying)
1280     return "Exiting";
1281
1282   return NULL;
1283 }
1284
1285 static char *
1286 inf_ttrace_pid_to_str (struct target_ops *ops, ptid_t ptid)
1287 {
1288   pid_t pid = ptid_get_pid (ptid);
1289   lwpid_t lwpid = ptid_get_lwp (ptid);
1290   static char buf[128];
1291
1292   if (lwpid == 0)
1293     xsnprintf (buf, sizeof buf, "process %ld",
1294                (long) pid);
1295   else
1296     xsnprintf (buf, sizeof buf, "process %ld, lwp %ld",
1297                (long) pid, (long) lwpid);
1298   return buf;
1299 }
1300 \f
1301
1302 /* Implement the get_ada_task_ptid target_ops method.  */
1303
1304 static ptid_t
1305 inf_ttrace_get_ada_task_ptid (long lwp, long thread)
1306 {
1307   return ptid_build (ptid_get_pid (inferior_ptid), lwp, 0);
1308 }
1309
1310 \f
1311 struct target_ops *
1312 inf_ttrace_target (void)
1313 {
1314   struct target_ops *t = inf_child_target ();
1315
1316   t->to_attach = inf_ttrace_attach;
1317   t->to_detach = inf_ttrace_detach;
1318   t->to_resume = inf_ttrace_resume;
1319   t->to_wait = inf_ttrace_wait;
1320   t->to_files_info = inf_ttrace_files_info;
1321   t->to_can_use_hw_breakpoint = inf_ttrace_can_use_hw_breakpoint;
1322   t->to_insert_watchpoint = inf_ttrace_insert_watchpoint;
1323   t->to_remove_watchpoint = inf_ttrace_remove_watchpoint;
1324   t->to_stopped_by_watchpoint = inf_ttrace_stopped_by_watchpoint;
1325   t->to_region_ok_for_hw_watchpoint =
1326     inf_ttrace_region_ok_for_hw_watchpoint;
1327   t->to_kill = inf_ttrace_kill;
1328   t->to_create_inferior = inf_ttrace_create_inferior;
1329   t->to_follow_fork = inf_ttrace_follow_fork;
1330   t->to_mourn_inferior = inf_ttrace_mourn_inferior;
1331   t->to_thread_alive = inf_ttrace_thread_alive;
1332   t->to_extra_thread_info = inf_ttrace_extra_thread_info;
1333   t->to_pid_to_str = inf_ttrace_pid_to_str;
1334   t->to_xfer_partial = inf_ttrace_xfer_partial;
1335   t->to_get_ada_task_ptid = inf_ttrace_get_ada_task_ptid;
1336
1337   return t;
1338 }
1339 #endif
1340 \f
1341
1342 /* Prevent warning from -Wmissing-prototypes.  */
1343 void _initialize_inf_ttrace (void);
1344
1345 void
1346 _initialize_inf_ttrace (void)
1347 {
1348 #ifdef HAVE_TTRACE
1349   inf_ttrace_page_dict.pagesize = getpagesize();
1350 #endif
1351 }