gdb/inf-ttrace.c

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