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