gdb/inf-ttrace.c

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