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
  37 #include "inf-child.h"
  38 #include "inf-ttrace.h"
  39
  40 /* HACK: Save the ttrace ops returned by inf_ttrace_target.  */
  41 static struct target_ops *ttrace_ops_hack;
  42 \f
  43
  44 /* HP-UX uses a threading model where each user-space thread
  45    corresponds to a kernel thread.  These kernel threads are called
  46    lwps.  The ttrace(2) interface gives us almost full control over
  47    the threads, which makes it very easy to support them in GDB.  We
  48    identify the threads by process ID and lwp ID.  The ttrace(2) also
  49    provides us with a thread's user ID (in the `tts_user_tid' member
  50    of `ttstate_t') but we don't use that (yet) as it isn't necessary
  51    to uniquely label the thread.  */
  52
  53 /* Number of active lwps.  */
  54 static int inf_ttrace_num_lwps;
  55 \f
  56
  57 /* On HP-UX versions that have the ttrace(2) system call, we can
  58    implement "hardware" watchpoints by fiddling with the protection of
  59    pages in the address space that contain the variable being watched.
  60    In order to implement this, we keep a dictionary of pages for which
  61    we have changed the protection.  */
  62
  63 struct inf_ttrace_page
  64 {
  65   CORE_ADDR addr;               /* Page address.  */
  66   int prot;                     /* Protection.  */
  67   int refcount;                 /* Reference count.  */
  68   struct inf_ttrace_page *next;
  69   struct inf_ttrace_page *prev;
  70 };
  71
  72 struct inf_ttrace_page_dict
  73 {
  74   struct inf_ttrace_page buckets[128];
  75   int pagesize;                 /* Page size.  */
  76   int count;                    /* Number of pages in this dictionary.  */
  77 } inf_ttrace_page_dict;
  78
  79 struct inf_ttrace_private_thread_info
  80 {
  81   int dying;
  82 };
  83
  84 /* Number of lwps that are currently in a system call.  */
  85 static int inf_ttrace_num_lwps_in_syscall;
  86
  87 /* Flag to indicate whether we should re-enable page protections after
  88    the next wait.  */
  89 static int inf_ttrace_reenable_page_protections;
  90
  91 /* Enable system call events for process PID.  */
  92
  93 static void
  94 inf_ttrace_enable_syscall_events (pid_t pid)
  95 {
  96   ttevent_t tte;
  97   ttstate_t tts;
  98
  99   gdb_assert (inf_ttrace_num_lwps_in_syscall == 0);
 100
 101   if (ttrace (TT_PROC_GET_EVENT_MASK, pid, 0,
 102               (uintptr_t)&tte, sizeof tte, 0) == -1)
 103     perror_with_name (("ttrace"));
 104
 105   tte.tte_events |= (TTEVT_SYSCALL_ENTRY | TTEVT_SYSCALL_RETURN);
 106
 107   if (ttrace (TT_PROC_SET_EVENT_MASK, pid, 0,
 108               (uintptr_t)&tte, sizeof tte, 0) == -1)
 109     perror_with_name (("ttrace"));
 110
 111   if (ttrace (TT_PROC_GET_FIRST_LWP_STATE, pid, 0,
 112               (uintptr_t)&tts, sizeof tts, 0) == -1)
 113     perror_with_name (("ttrace"));
 114
 115   if (tts.tts_flags & TTS_INSYSCALL)
 116     inf_ttrace_num_lwps_in_syscall++;
 117
 118   /* FIXME: Handle multiple threads.  */
 119 }
 120
 121 /* Disable system call events for process PID.  */
 122
 123 static void
 124 inf_ttrace_disable_syscall_events (pid_t pid)
 125 {
 126   ttevent_t tte;
 127
 128   gdb_assert (inf_ttrace_page_dict.count == 0);
 129
 130   if (ttrace (TT_PROC_GET_EVENT_MASK, pid, 0,
 131               (uintptr_t)&tte, sizeof tte, 0) == -1)
 132     perror_with_name (("ttrace"));
 133
 134   tte.tte_events &= ~(TTEVT_SYSCALL_ENTRY | TTEVT_SYSCALL_RETURN);
 135
 136   if (ttrace (TT_PROC_SET_EVENT_MASK, pid, 0,
 137               (uintptr_t)&tte, sizeof tte, 0) == -1)
 138     perror_with_name (("ttrace"));
 139
 140   inf_ttrace_num_lwps_in_syscall = 0;
 141 }
 142
 143 /* Get information about the page at address ADDR for process PID from
 144    the dictionary.  */
 145
 146 static struct inf_ttrace_page *
 147 inf_ttrace_get_page (pid_t pid, CORE_ADDR addr)
 148 {
 149   const int num_buckets = ARRAY_SIZE (inf_ttrace_page_dict.buckets);
 150   const int pagesize = inf_ttrace_page_dict.pagesize;
 151   int bucket;
 152   struct inf_ttrace_page *page;
 153
 154   bucket = (addr / pagesize) % num_buckets;
 155   page = &inf_ttrace_page_dict.buckets[bucket];
 156   while (page)
 157     {
 158       if (page->addr == addr)
 159         break;
 160
 161       page = page->next;
 162     }
 163
 164   return page;
 165 }
 166
 167 /* Add the page at address ADDR for process PID to the dictionary.  */
 168
 169 static struct inf_ttrace_page *
 170 inf_ttrace_add_page (pid_t pid, CORE_ADDR addr)
 171 {
 172   const int num_buckets = ARRAY_SIZE (inf_ttrace_page_dict.buckets);
 173   const int pagesize = inf_ttrace_page_dict.pagesize;
 174   int bucket;
 175   struct inf_ttrace_page *page;
 176   struct inf_ttrace_page *prev = NULL;
 177
 178   bucket = (addr / pagesize) % num_buckets;
 179   page = &inf_ttrace_page_dict.buckets[bucket];
 180   while (page)
 181     {
 182       if (page->addr == addr)
 183         break;
 184
 185       prev = page;
 186       page = page->next;
 187     }
 188
 189   if (!page)
 190     {
 191       int prot;
 192
 193       if (ttrace (TT_PROC_GET_MPROTECT, pid, 0,
 194                   addr, 0, (uintptr_t)&prot) == -1)
 195         perror_with_name (("ttrace"));
 196
 197       page = XMALLOC (struct inf_ttrace_page);
 198       page->addr = addr;
 199       page->prot = prot;
 200       page->refcount = 0;
 201       page->next = NULL;
 202
 203       page->prev = prev;
 204       prev->next = page;
 205
 206       inf_ttrace_page_dict.count++;
 207       if (inf_ttrace_page_dict.count == 1)
 208         inf_ttrace_enable_syscall_events (pid);
 209
 210       if (inf_ttrace_num_lwps_in_syscall == 0)
 211         {
 212           if (ttrace (TT_PROC_SET_MPROTECT, pid, 0,
 213                       addr, pagesize, prot & ~PROT_WRITE) == -1)
 214             perror_with_name (("ttrace"));
 215         }
 216     }
 217
 218   return page;
 219 }
 220
 221 /* Insert the page at address ADDR of process PID to the dictionary.  */
 222
 223 static void
 224 inf_ttrace_insert_page (pid_t pid, CORE_ADDR addr)
 225 {
 226   struct inf_ttrace_page *page;
 227
 228   page = inf_ttrace_get_page (pid, addr);
 229   if (!page)
 230     page = inf_ttrace_add_page (pid, addr);
 231
 232   page->refcount++;
 233 }
 234
 235 /* Remove the page at address ADDR of process PID from the dictionary.  */
 236
 237 static void
 238 inf_ttrace_remove_page (pid_t pid, CORE_ADDR addr)
 239 {
 240   const int pagesize = inf_ttrace_page_dict.pagesize;
 241   struct inf_ttrace_page *page;
 242
 243   page = inf_ttrace_get_page (pid, addr);
 244   page->refcount--;
 245
 246   gdb_assert (page->refcount >= 0);
 247
 248   if (page->refcount == 0)
 249     {
 250       if (inf_ttrace_num_lwps_in_syscall == 0)
 251         {
 252           if (ttrace (TT_PROC_SET_MPROTECT, pid, 0,
 253                       addr, pagesize, page->prot) == -1)
 254             perror_with_name (("ttrace"));
 255         }
 256
 257       inf_ttrace_page_dict.count--;
 258       if (inf_ttrace_page_dict.count == 0)
 259         inf_ttrace_disable_syscall_events (pid);
 260
 261       page->prev->next = page->next;
 262       if (page->next)
 263         page->next->prev = page->prev;
 264
 265       xfree (page);
 266     }
 267 }
 268
 269 /* Mask the bits in PROT from the page protections that are currently
 270    in the dictionary for process PID.  */
 271
 272 static void
 273 inf_ttrace_mask_page_protections (pid_t pid, int prot)
 274 {
 275   const int num_buckets = ARRAY_SIZE (inf_ttrace_page_dict.buckets);
 276   const int pagesize = inf_ttrace_page_dict.pagesize;
 277   int bucket;
 278
 279   for (bucket = 0; bucket < num_buckets; bucket++)
 280     {
 281       struct inf_ttrace_page *page;
 282
 283       page = inf_ttrace_page_dict.buckets[bucket].next;
 284       while (page)
 285         {
 286           if (ttrace (TT_PROC_SET_MPROTECT, pid, 0,
 287                       page->addr, pagesize, page->prot & ~prot) == -1)
 288             perror_with_name (("ttrace"));
 289
 290           page = page->next;
 291         }
 292     }
 293 }
 294
 295 /* Write-protect the pages in the dictionary for process PID.  */
 296
 297 static void
 298 inf_ttrace_enable_page_protections (pid_t pid)
 299 {
 300   inf_ttrace_mask_page_protections (pid, PROT_WRITE);
 301 }
 302
 303 /* Restore the protection of the pages in the dictionary for process
 304    PID.  */
 305
 306 static void
 307 inf_ttrace_disable_page_protections (pid_t pid)
 308 {
 309   inf_ttrace_mask_page_protections (pid, 0);
 310 }
 311
 312 /* Insert a "hardware" watchpoint for LEN bytes at address ADDR of
 313    type TYPE.  */
 314
 315 static int
 316 inf_ttrace_insert_watchpoint (CORE_ADDR addr, int len, int type)
 317 {
 318   const int pagesize = inf_ttrace_page_dict.pagesize;
 319   pid_t pid = ptid_get_pid (inferior_ptid);
 320   CORE_ADDR page_addr;
 321   int num_pages;
 322   int page;
 323
 324   gdb_assert (type == hw_write);
 325
 326   page_addr = (addr / pagesize) * pagesize;
 327   num_pages = (len + pagesize - 1) / pagesize;
 328
 329   for (page = 0; page < num_pages; page++, page_addr += pagesize)
 330     inf_ttrace_insert_page (pid, page_addr);
 331
 332   return 1;
 333 }
 334
 335 /* Remove a "hardware" watchpoint for LEN bytes at address ADDR of
 336    type TYPE.  */
 337
 338 static int
 339 inf_ttrace_remove_watchpoint (CORE_ADDR addr, int len, int type)
 340 {
 341   const int pagesize = inf_ttrace_page_dict.pagesize;
 342   pid_t pid = ptid_get_pid (inferior_ptid);
 343   CORE_ADDR page_addr;
 344   int num_pages;
 345   int page;
 346
 347   gdb_assert (type == hw_write);
 348
 349   page_addr = (addr / pagesize) * pagesize;
 350   num_pages = (len + pagesize - 1) / pagesize;
 351
 352   for (page = 0; page < num_pages; page++, page_addr += pagesize)
 353     inf_ttrace_remove_page (pid, page_addr);
 354
 355   return 1;
 356 }
 357
 358 static int
 359 inf_ttrace_can_use_hw_breakpoint (int type, int len, int ot)
 360 {
 361   return (type == bp_hardware_watchpoint);
 362 }
 363
 364 static int
 365 inf_ttrace_region_ok_for_hw_watchpoint (CORE_ADDR addr, int len)
 366 {
 367   return 1;
 368 }
 369
 370 /* Return non-zero if the current inferior was (potentially) stopped
 371    by hitting a "hardware" watchpoint.  */
 372
 373 static int
 374 inf_ttrace_stopped_by_watchpoint (void)
 375 {
 376   pid_t pid = ptid_get_pid (inferior_ptid);
 377   lwpid_t lwpid = ptid_get_lwp (inferior_ptid);
 378   ttstate_t tts;
 379
 380   if (inf_ttrace_page_dict.count > 0)
 381     {
 382       if (ttrace (TT_LWP_GET_STATE, pid, lwpid,
 383                   (uintptr_t)&tts, sizeof tts, 0) == -1)
 384         perror_with_name (("ttrace"));
 385
 386       if (tts.tts_event == TTEVT_SIGNAL
 387           && tts.tts_u.tts_signal.tts_signo == SIGBUS)
 388         {
 389           const int pagesize = inf_ttrace_page_dict.pagesize;
 390           void *addr = tts.tts_u.tts_signal.tts_siginfo.si_addr;
 391           CORE_ADDR page_addr = ((uintptr_t)addr / pagesize) * pagesize;
 392
 393           if (inf_ttrace_get_page (pid, page_addr))
 394             return 1;
 395         }
 396     }
 397
 398   return 0;
 399 }
 400 \f
 401
 402 /* When tracking a vfork(2), we cannot detach from the parent until
 403    after the child has called exec(3) or has exited.  If we are still
 404    attached to the parent, this variable will be set to the process ID
 405    of the parent.  Otherwise it will be set to zero.  */
 406 static pid_t inf_ttrace_vfork_ppid = -1;
 407
 408 static int
 409 inf_ttrace_follow_fork (struct target_ops *ops, int follow_child)
 410 {
 411   pid_t pid, fpid;
 412   lwpid_t lwpid, flwpid;
 413   ttstate_t tts;
 414
 415   /* FIXME: kettenis/20050720: This stuff should really be passed as
 416      an argument by our caller.  */
 417   {
 418     ptid_t ptid;
 419     struct target_waitstatus status;
 420
 421     get_last_target_status (&ptid, &status);
 422     gdb_assert (status.kind == TARGET_WAITKIND_FORKED
 423                 || status.kind == TARGET_WAITKIND_VFORKED);
 424
 425     pid = ptid_get_pid (ptid);
 426     lwpid = ptid_get_lwp (ptid);
 427   }
 428
 429   /* Get all important details that core GDB doesn't (and shouldn't)
 430      know about.  */
 431   if (ttrace (TT_LWP_GET_STATE, pid, lwpid,
 432               (uintptr_t)&tts, sizeof tts, 0) == -1)
 433     perror_with_name (("ttrace"));
 434
 435   gdb_assert (tts.tts_event == TTEVT_FORK || tts.tts_event == TTEVT_VFORK);
 436
 437   if (tts.tts_u.tts_fork.tts_isparent)
 438     {
 439       pid = tts.tts_pid;
 440       lwpid = tts.tts_lwpid;
 441       fpid = tts.tts_u.tts_fork.tts_fpid;
 442       flwpid = tts.tts_u.tts_fork.tts_flwpid;
 443     }
 444   else
 445     {
 446       pid = tts.tts_u.tts_fork.tts_fpid;
 447       lwpid = tts.tts_u.tts_fork.tts_flwpid;
 448       fpid = tts.tts_pid;
 449       flwpid = tts.tts_lwpid;
 450     }
 451
 452   if (follow_child)
 453     {
 454       inferior_ptid = ptid_build (fpid, flwpid, 0);
 455       detach_breakpoints (pid);
 456
 457       target_terminal_ours ();
 458       fprintf_unfiltered (gdb_stdlog, _("\
 459 Attaching after fork to child process %ld.\n"), (long)fpid);
 460     }
 461   else
 462     {
 463       inferior_ptid = ptid_build (pid, lwpid, 0);
 464       detach_breakpoints (fpid);
 465
 466       target_terminal_ours ();
 467       fprintf_unfiltered (gdb_stdlog, _("\
 468 Detaching after fork from child process %ld.\n"), (long)fpid);
 469     }
 470
 471   if (tts.tts_event == TTEVT_VFORK)
 472     {
 473       gdb_assert (!tts.tts_u.tts_fork.tts_isparent);
 474
 475       if (follow_child)
 476         {
 477           /* We can't detach from the parent yet.  */
 478           inf_ttrace_vfork_ppid = pid;
 479
 480           reattach_breakpoints (fpid);
 481         }
 482       else
 483         {
 484           if (ttrace (TT_PROC_DETACH, fpid, 0, 0, 0, 0) == -1)
 485             perror_with_name (("ttrace"));
 486
 487           /* Wait till we get the TTEVT_VFORK event in the parent.
 488              This indicates that the child has called exec(3) or has
 489              exited and that the parent is ready to be traced again.  */
 490           if (ttrace_wait (pid, lwpid, TTRACE_WAITOK, &tts, sizeof tts) == -1)
 491             perror_with_name (("ttrace_wait"));
 492           gdb_assert (tts.tts_event == TTEVT_VFORK);
 493           gdb_assert (tts.tts_u.tts_fork.tts_isparent);
 494
 495           reattach_breakpoints (pid);
 496         }
 497     }
 498   else
 499     {
 500       gdb_assert (tts.tts_u.tts_fork.tts_isparent);
 501
 502       if (follow_child)
 503         {
 504           if (ttrace (TT_PROC_DETACH, pid, 0, 0, 0, 0) == -1)
 505             perror_with_name (("ttrace"));
 506         }
 507       else
 508         {
 509           if (ttrace (TT_PROC_DETACH, fpid, 0, 0, 0, 0) == -1)
 510             perror_with_name (("ttrace"));
 511         }
 512     }
 513
 514   if (follow_child)
 515     {
 516       struct thread_info *ti;
 517
 518       /* The child will start out single-threaded.  */
 519       inf_ttrace_num_lwps = 1;
 520       inf_ttrace_num_lwps_in_syscall = 0;
 521
 522       /* Delete parent.  */
 523       delete_thread_silent (ptid_build (pid, lwpid, 0));
 524
 525       /* Add child.  inferior_ptid was already set above.  */
 526       ti = add_thread_silent (inferior_ptid);
 527       ti->private =
 528         xmalloc (sizeof (struct inf_ttrace_private_thread_info));
 529       memset (ti->private, 0,
 530               sizeof (struct inf_ttrace_private_thread_info));
 531
 532       /* Reset breakpoints in the child as appropriate.  */
 533       follow_inferior_reset_breakpoints ();
 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 (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 (ttrace_ops_hack);
 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 (char *exec_file, char *allargs, char **env,
 643                             int from_tty)
 644 {
 645   gdb_assert (inf_ttrace_num_lwps == 0);
 646   gdb_assert (inf_ttrace_num_lwps_in_syscall == 0);
 647   gdb_assert (inf_ttrace_page_dict.count == 0);
 648   gdb_assert (inf_ttrace_reenable_page_protections == 0);
 649   gdb_assert (inf_ttrace_vfork_ppid == -1);
 650
 651   fork_inferior (exec_file, allargs, env, inf_ttrace_me, inf_ttrace_him,
 652                  inf_ttrace_prepare, NULL);
 653 }
 654
 655 static void
 656 inf_ttrace_mourn_inferior (void)
 657 {
 658   const int num_buckets = ARRAY_SIZE (inf_ttrace_page_dict.buckets);
 659   int bucket;
 660
 661   inf_ttrace_num_lwps = 0;
 662   inf_ttrace_num_lwps_in_syscall = 0;
 663
 664   for (bucket = 0; bucket < num_buckets; bucket++)
 665     {
 666       struct inf_ttrace_page *page;
 667       struct inf_ttrace_page *next;
 668
 669       page = inf_ttrace_page_dict.buckets[bucket].next;
 670       while (page)
 671         {
 672           next = page->next;
 673           xfree (page);
 674           page = next;
 675         }
 676     }
 677   inf_ttrace_page_dict.count = 0;
 678
 679   unpush_target (ttrace_ops_hack);
 680   generic_mourn_inferior ();
 681 }
 682
 683 static void
 684 inf_ttrace_attach (char *args, int from_tty)
 685 {
 686   char *exec_file;
 687   pid_t pid;
 688   char *dummy;
 689   ttevent_t tte;
 690
 691   if (!args)
 692     error_no_arg (_("process-id to attach"));
 693
 694   dummy = args;
 695   pid = strtol (args, &dummy, 0);
 696   if (pid == 0 && args == dummy)
 697     error (_("Illegal process-id: %s."), args);
 698
 699   if (pid == getpid ())         /* Trying to masturbate?  */
 700     error (_("I refuse to debug myself!"));
 701
 702   if (from_tty)
 703     {
 704       exec_file = get_exec_file (0);
 705
 706       if (exec_file)
 707         printf_unfiltered (_("Attaching to program: %s, %s\n"), exec_file,
 708                            target_pid_to_str (pid_to_ptid (pid)));
 709       else
 710         printf_unfiltered (_("Attaching to %s\n"),
 711                            target_pid_to_str (pid_to_ptid (pid)));
 712
 713       gdb_flush (gdb_stdout);
 714     }
 715
 716   gdb_assert (inf_ttrace_num_lwps == 0);
 717   gdb_assert (inf_ttrace_num_lwps_in_syscall == 0);
 718   gdb_assert (inf_ttrace_vfork_ppid == -1);
 719
 720   if (ttrace (TT_PROC_ATTACH, pid, 0, TT_KILL_ON_EXIT, TT_VERSION, 0) == -1)
 721     perror_with_name (("ttrace"));
 722   attach_flag = 1;
 723
 724   /* Set the initial event mask.  */
 725   memset (&tte, 0, sizeof (tte));
 726   tte.tte_events |= TTEVT_EXEC | TTEVT_EXIT | TTEVT_FORK | TTEVT_VFORK;
 727   tte.tte_events |= TTEVT_LWP_CREATE | TTEVT_LWP_EXIT | TTEVT_LWP_TERMINATE;
 728 #ifdef TTEVT_BPT_SSTEP
 729   tte.tte_events |= TTEVT_BPT_SSTEP;
 730 #endif
 731   tte.tte_opts |= TTEO_PROC_INHERIT;
 732   if (ttrace (TT_PROC_SET_EVENT_MASK, pid, 0,
 733               (uintptr_t)&tte, sizeof tte, 0) == -1)
 734     perror_with_name (("ttrace"));
 735
 736   push_target (ttrace_ops_hack);
 737
 738   /* We'll bump inf_ttrace_num_lwps up and add the private data to the
 739      thread as soon as we get to inf_ttrace_wait.  At this point, we
 740      don't have lwpid info yet.  */
 741   inferior_ptid = pid_to_ptid (pid);
 742   add_thread_silent (inferior_ptid);
 743 }
 744
 745 static void
 746 inf_ttrace_detach (char *args, int from_tty)
 747 {
 748   pid_t pid = ptid_get_pid (inferior_ptid);
 749   int sig = 0;
 750
 751   if (from_tty)
 752     {
 753       char *exec_file = get_exec_file (0);
 754       if (exec_file == 0)
 755         exec_file = "";
 756       printf_unfiltered (_("Detaching from program: %s, %s\n"), exec_file,
 757                          target_pid_to_str (pid_to_ptid (pid)));
 758       gdb_flush (gdb_stdout);
 759     }
 760   if (args)
 761     sig = atoi (args);
 762
 763   /* ??? The HP-UX 11.0 ttrace(2) manual page doesn't mention that we
 764      can pass a signal number here.  Does this really work?  */
 765   if (ttrace (TT_PROC_DETACH, pid, 0, 0, sig, 0) == -1)
 766     perror_with_name (("ttrace"));
 767
 768   if (inf_ttrace_vfork_ppid != -1)
 769     {
 770       if (ttrace (TT_PROC_DETACH, inf_ttrace_vfork_ppid, 0, 0, 0, 0) == -1)
 771         perror_with_name (("ttrace"));
 772       inf_ttrace_vfork_ppid = -1;
 773     }
 774
 775   inf_ttrace_num_lwps = 0;
 776   inf_ttrace_num_lwps_in_syscall = 0;
 777
 778   unpush_target (ttrace_ops_hack);
 779   inferior_ptid = null_ptid;
 780 }
 781
 782 static void
 783 inf_ttrace_kill (void)
 784 {
 785   pid_t pid = ptid_get_pid (inferior_ptid);
 786
 787   if (pid == 0)
 788     return;
 789
 790   if (ttrace (TT_PROC_EXIT, pid, 0, 0, 0, 0) == -1)
 791     perror_with_name (("ttrace"));
 792   /* ??? Is it necessary to call ttrace_wait() here?  */
 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   target_mourn_inferior ();
 802 }
 803
 804 static int
 805 inf_ttrace_resume_callback (struct thread_info *info, void *arg)
 806 {
 807   if (!ptid_equal (info->ptid, inferior_ptid) && !is_exited (info->ptid))
 808     {
 809       pid_t pid = ptid_get_pid (info->ptid);
 810       lwpid_t lwpid = ptid_get_lwp (info->ptid);
 811
 812       if (ttrace (TT_LWP_CONTINUE, pid, lwpid, TT_NOPC, 0, 0) == -1)
 813         perror_with_name (("ttrace"));
 814     }
 815
 816   return 0;
 817 }
 818
 819 static int
 820 inf_ttrace_delete_dying_threads_callback (struct thread_info *info, void *arg)
 821 {
 822   if (((struct inf_ttrace_private_thread_info *)info->private)->dying == 1)
 823     delete_thread (info->ptid);
 824   return 0;
 825 }
 826
 827 static void
 828 inf_ttrace_resume (ptid_t ptid, int step, enum target_signal signal)
 829 {
 830   pid_t pid = ptid_get_pid (ptid);
 831   lwpid_t lwpid = ptid_get_lwp (ptid);
 832   ttreq_t request = step ? TT_LWP_SINGLE : TT_LWP_CONTINUE;
 833   int sig = target_signal_to_host (signal);
 834
 835   if (pid == -1)
 836     {
 837       pid = ptid_get_pid (inferior_ptid);
 838       lwpid = ptid_get_lwp (inferior_ptid);
 839     }
 840
 841   if (ttrace (request, pid, lwpid, TT_NOPC, sig, 0) == -1)
 842     perror_with_name (("ttrace"));
 843
 844   if (ptid_equal (ptid, minus_one_ptid))
 845     {
 846       /* Let all the other threads run too.  */
 847       iterate_over_threads (inf_ttrace_resume_callback, NULL);
 848       iterate_over_threads (inf_ttrace_delete_dying_threads_callback, NULL);
 849     }
 850 }
 851
 852 static ptid_t
 853 inf_ttrace_wait (ptid_t ptid, struct target_waitstatus *ourstatus)
 854 {
 855   pid_t pid = ptid_get_pid (ptid);
 856   lwpid_t lwpid = ptid_get_lwp (ptid);
 857   ttstate_t tts;
 858   struct thread_info *ti;
 859   ptid_t related_ptid;
 860
 861   /* Until proven otherwise.  */
 862   ourstatus->kind = TARGET_WAITKIND_SPURIOUS;
 863
 864   if (pid == -1)
 865     pid = lwpid = 0;
 866
 867   gdb_assert (pid != 0 || lwpid == 0);
 868
 869   do
 870     {
 871       set_sigint_trap ();
 872       set_sigio_trap ();
 873
 874       if (ttrace_wait (pid, lwpid, TTRACE_WAITOK, &tts, sizeof tts) == -1)
 875         perror_with_name (("ttrace_wait"));
 876
 877       if (tts.tts_event == TTEVT_VFORK && tts.tts_u.tts_fork.tts_isparent)
 878         {
 879           if (inf_ttrace_vfork_ppid != -1)
 880             {
 881               gdb_assert (inf_ttrace_vfork_ppid == tts.tts_pid);
 882
 883               if (ttrace (TT_PROC_DETACH, tts.tts_pid, 0, 0, 0, 0) == -1)
 884                 perror_with_name (("ttrace"));
 885               inf_ttrace_vfork_ppid = -1;
 886             }
 887
 888           tts.tts_event = TTEVT_NONE;
 889         }
 890
 891       clear_sigio_trap ();
 892       clear_sigint_trap ();
 893     }
 894   while (tts.tts_event == TTEVT_NONE);
 895
 896   /* Now that we've waited, we can re-enable the page protections.  */
 897   if (inf_ttrace_reenable_page_protections)
 898     {
 899       gdb_assert (inf_ttrace_num_lwps_in_syscall == 0);
 900       inf_ttrace_enable_page_protections (tts.tts_pid);
 901       inf_ttrace_reenable_page_protections = 0;
 902     }
 903
 904   ptid = ptid_build (tts.tts_pid, tts.tts_lwpid, 0);
 905
 906   if (inf_ttrace_num_lwps == 0)
 907     {
 908       struct thread_info *ti;
 909
 910       inf_ttrace_num_lwps = 1;
 911
 912       /* This is the earliest we hear about the lwp member of
 913          INFERIOR_PTID, after an attach or fork_inferior.  */
 914       gdb_assert (ptid_get_lwp (inferior_ptid) == 0);
 915
 916       /* We haven't set the private member on the main thread yet.  Do
 917          it now.  */
 918       ti = find_thread_pid (inferior_ptid);
 919       gdb_assert (ti != NULL && ti->private == NULL);
 920       ti->private =
 921         xmalloc (sizeof (struct inf_ttrace_private_thread_info));
 922       memset (ti->private, 0,
 923               sizeof (struct inf_ttrace_private_thread_info));
 924
 925       /* Notify the core that this ptid changed.  This changes
 926          inferior_ptid as well.  */
 927       thread_change_ptid (inferior_ptid, ptid);
 928     }
 929
 930   switch (tts.tts_event)
 931     {
 932 #ifdef TTEVT_BPT_SSTEP
 933     case TTEVT_BPT_SSTEP:
 934       /* Make it look like a breakpoint.  */
 935       ourstatus->kind = TARGET_WAITKIND_STOPPED;
 936       ourstatus->value.sig = TARGET_SIGNAL_TRAP;
 937       break;
 938 #endif
 939
 940     case TTEVT_EXEC:
 941       ourstatus->kind = TARGET_WAITKIND_EXECD;
 942       ourstatus->value.execd_pathname =
 943         xmalloc (tts.tts_u.tts_exec.tts_pathlen + 1);
 944       if (ttrace (TT_PROC_GET_PATHNAME, tts.tts_pid, 0,
 945                   (uintptr_t)ourstatus->value.execd_pathname,
 946                   tts.tts_u.tts_exec.tts_pathlen, 0) == -1)
 947         perror_with_name (("ttrace"));
 948       ourstatus->value.execd_pathname[tts.tts_u.tts_exec.tts_pathlen] = 0;
 949
 950       /* At this point, all inserted breakpoints are gone.  Doing this
 951          as soon as we detect an exec prevents the badness of deleting
 952          a breakpoint writing the current "shadow contents" to lift
 953          the bp.  That shadow is NOT valid after an exec.  */
 954       mark_breakpoints_out ();
 955       break;
 956
 957     case TTEVT_EXIT:
 958       store_waitstatus (ourstatus, tts.tts_u.tts_exit.tts_exitcode);
 959       inf_ttrace_num_lwps = 0;
 960       break;
 961
 962     case TTEVT_FORK:
 963       related_ptid = ptid_build (tts.tts_u.tts_fork.tts_fpid,
 964                                  tts.tts_u.tts_fork.tts_flwpid, 0);
 965
 966       ourstatus->kind = TARGET_WAITKIND_FORKED;
 967       ourstatus->value.related_pid = related_ptid;
 968
 969       /* Make sure the other end of the fork is stopped too.  */
 970       if (ttrace_wait (tts.tts_u.tts_fork.tts_fpid,
 971                        tts.tts_u.tts_fork.tts_flwpid,
 972                        TTRACE_WAITOK, &tts, sizeof tts) == -1)
 973         perror_with_name (("ttrace_wait"));
 974
 975       gdb_assert (tts.tts_event == TTEVT_FORK);
 976       if (tts.tts_u.tts_fork.tts_isparent)
 977         {
 978           related_ptid = ptid_build (tts.tts_u.tts_fork.tts_fpid,
 979                                      tts.tts_u.tts_fork.tts_flwpid, 0);
 980           ptid = ptid_build (tts.tts_pid, tts.tts_lwpid, 0);
 981           ourstatus->value.related_pid = related_ptid;
 982         }
 983       break;
 984
 985     case TTEVT_VFORK:
 986       gdb_assert (!tts.tts_u.tts_fork.tts_isparent);
 987
 988       related_ptid = ptid_build (tts.tts_u.tts_fork.tts_fpid,
 989                                  tts.tts_u.tts_fork.tts_flwpid, 0);
 990
 991       ourstatus->kind = TARGET_WAITKIND_VFORKED;
 992       ourstatus->value.related_pid = related_ptid;
 993
 994       /* HACK: To avoid touching the parent during the vfork, switch
 995          away from it.  */
 996       inferior_ptid = ptid;
 997       break;
 998
 999     case TTEVT_LWP_CREATE:
1000       lwpid = tts.tts_u.tts_thread.tts_target_lwpid;
1001       ptid = ptid_build (tts.tts_pid, lwpid, 0);
1002       ti = add_thread (ptid);
1003       ti->private =
1004         xmalloc (sizeof (struct inf_ttrace_private_thread_info));
1005       memset (ti->private, 0,
1006               sizeof (struct inf_ttrace_private_thread_info));
1007       inf_ttrace_num_lwps++;
1008       ptid = ptid_build (tts.tts_pid, tts.tts_lwpid, 0);
1009       break;
1010
1011     case TTEVT_LWP_EXIT:
1012       if (print_thread_events)
1013         printf_unfiltered (_("[%s exited]\n"), target_pid_to_str (ptid));
1014       ti = find_thread_pid (ptid);
1015       gdb_assert (ti != NULL);
1016       ((struct inf_ttrace_private_thread_info *)ti->private)->dying = 1;
1017       inf_ttrace_num_lwps--;
1018       ttrace (TT_LWP_CONTINUE, ptid_get_pid (ptid),
1019               ptid_get_lwp (ptid), TT_NOPC, 0, 0);
1020       /* If we don't return -1 here, core GDB will re-add the thread.  */
1021       ptid = minus_one_ptid;
1022       break;
1023
1024     case TTEVT_LWP_TERMINATE:
1025       lwpid = tts.tts_u.tts_thread.tts_target_lwpid;
1026       ptid = ptid_build (tts.tts_pid, lwpid, 0);
1027       printf_filtered(_("[%s has been terminated]\n"), target_pid_to_str (ptid));
1028       ti = find_thread_pid (ptid);
1029       gdb_assert (ti != NULL);
1030       ((struct inf_ttrace_private_thread_info *)ti->private)->dying = 1;
1031       inf_ttrace_num_lwps--;
1032       ptid = ptid_build (tts.tts_pid, tts.tts_lwpid, 0);
1033       break;
1034
1035     case TTEVT_SIGNAL:
1036       ourstatus->kind = TARGET_WAITKIND_STOPPED;
1037       ourstatus->value.sig =
1038         target_signal_from_host (tts.tts_u.tts_signal.tts_signo);
1039       break;
1040
1041     case TTEVT_SYSCALL_ENTRY:
1042       gdb_assert (inf_ttrace_reenable_page_protections == 0);
1043       inf_ttrace_num_lwps_in_syscall++;
1044       if (inf_ttrace_num_lwps_in_syscall == 1)
1045         {
1046           /* A thread has just entered a system call.  Disable any
1047              page protections as the kernel can't deal with them.  */
1048           inf_ttrace_disable_page_protections (tts.tts_pid);
1049         }
1050       ourstatus->kind = TARGET_WAITKIND_SYSCALL_ENTRY;
1051       ourstatus->value.syscall_id = tts.tts_scno;
1052       break;
1053
1054     case TTEVT_SYSCALL_RETURN:
1055       if (inf_ttrace_num_lwps_in_syscall > 0)
1056         {
1057           /* If the last thread has just left the system call, this
1058              would be a logical place to re-enable the page
1059              protections, but that doesn't work.  We can't re-enable
1060              them until we've done another wait.  */
1061           inf_ttrace_reenable_page_protections =
1062             (inf_ttrace_num_lwps_in_syscall == 1);
1063           inf_ttrace_num_lwps_in_syscall--;
1064         }
1065       ourstatus->kind = TARGET_WAITKIND_SYSCALL_RETURN;
1066       ourstatus->value.syscall_id = tts.tts_scno;
1067       break;
1068
1069     default:
1070       gdb_assert (!"Unexpected ttrace event");
1071       break;
1072     }
1073
1074   /* Make sure all threads within the process are stopped.  */
1075   if (ttrace (TT_PROC_STOP, tts.tts_pid, 0, 0, 0, 0) == -1)
1076     perror_with_name (("ttrace"));
1077
1078   return ptid;
1079 }
1080
1081 /* Transfer LEN bytes from ADDR in the inferior's memory into READBUF,
1082    and transfer LEN bytes from WRITEBUF into the inferior's memory at
1083    ADDR.  Either READBUF or WRITEBUF may be null, in which case the
1084    corresponding transfer doesn't happen.  Return the number of bytes
1085    actually transferred (which may be zero if an error occurs).  */
1086
1087 static LONGEST
1088 inf_ttrace_xfer_memory (CORE_ADDR addr, ULONGEST len,
1089                         void *readbuf, const void *writebuf)
1090 {
1091   pid_t pid = ptid_get_pid (inferior_ptid);
1092
1093   /* HP-UX treats text space and data space differently.  GDB however,
1094      doesn't really know the difference.  Therefore we try both.  Try
1095      text space before data space though because when we're writing
1096      into text space the instruction cache might need to be flushed.  */
1097
1098   if (readbuf
1099       && ttrace (TT_PROC_RDTEXT, pid, 0, addr, len, (uintptr_t)readbuf) == -1
1100       && ttrace (TT_PROC_RDDATA, pid, 0, addr, len, (uintptr_t)readbuf) == -1)
1101     return 0;
1102
1103   if (writebuf
1104       && ttrace (TT_PROC_WRTEXT, pid, 0, addr, len, (uintptr_t)writebuf) == -1
1105       && ttrace (TT_PROC_WRDATA, pid, 0, addr, len, (uintptr_t)writebuf) == -1)
1106     return 0;
1107
1108   return len;
1109 }
1110
1111 static LONGEST
1112 inf_ttrace_xfer_partial (struct target_ops *ops, enum target_object object,
1113                          const char *annex, gdb_byte *readbuf,
1114                          const gdb_byte *writebuf, ULONGEST offset, LONGEST len)
1115 {
1116   switch (object)
1117     {
1118     case TARGET_OBJECT_MEMORY:
1119       return inf_ttrace_xfer_memory (offset, len, readbuf, writebuf);
1120
1121     case TARGET_OBJECT_UNWIND_TABLE:
1122       return -1;
1123
1124     case TARGET_OBJECT_AUXV:
1125       return -1;
1126
1127     case TARGET_OBJECT_WCOOKIE:
1128       return -1;
1129
1130     default:
1131       return -1;
1132     }
1133 }
1134
1135 /* Print status information about what we're accessing.  */
1136
1137 static void
1138 inf_ttrace_files_info (struct target_ops *ignore)
1139 {
1140   printf_filtered (_("\tUsing the running image of %s %s.\n"),
1141                    attach_flag ? "attached" : "child",
1142                    target_pid_to_str (inferior_ptid));
1143 }
1144
1145 static int
1146 inf_ttrace_thread_alive (ptid_t ptid)
1147 {
1148   struct thread_info *ti;
1149   ti = find_thread_pid (ptid);
1150   return !(((struct inf_ttrace_private_thread_info *)ti->private)->dying);
1151 }
1152
1153 static char *
1154 inf_ttrace_pid_to_str (ptid_t ptid)
1155 {
1156   pid_t pid = ptid_get_pid (ptid);
1157   lwpid_t lwpid = ptid_get_lwp (ptid);
1158   static char buf[128];
1159
1160   if (lwpid == 0)
1161     xsnprintf (buf, sizeof buf, "process %ld",
1162                (long) pid);
1163   else
1164     xsnprintf (buf, sizeof buf, "process %ld, lwp %ld",
1165                (long) pid, (long) lwpid);
1166   return buf;
1167 }
1168 \f
1169
1170 struct target_ops *
1171 inf_ttrace_target (void)
1172 {
1173   struct target_ops *t = inf_child_target ();
1174
1175   t->to_attach = inf_ttrace_attach;
1176   t->to_detach = inf_ttrace_detach;
1177   t->to_resume = inf_ttrace_resume;
1178   t->to_wait = inf_ttrace_wait;
1179   t->to_files_info = inf_ttrace_files_info;
1180   t->to_can_use_hw_breakpoint = inf_ttrace_can_use_hw_breakpoint;
1181   t->to_insert_watchpoint = inf_ttrace_insert_watchpoint;
1182   t->to_remove_watchpoint = inf_ttrace_remove_watchpoint;
1183   t->to_stopped_by_watchpoint = inf_ttrace_stopped_by_watchpoint;
1184   t->to_region_ok_for_hw_watchpoint =
1185     inf_ttrace_region_ok_for_hw_watchpoint;
1186   t->to_kill = inf_ttrace_kill;
1187   t->to_create_inferior = inf_ttrace_create_inferior;
1188   t->to_follow_fork = inf_ttrace_follow_fork;
1189   t->to_mourn_inferior = inf_ttrace_mourn_inferior;
1190   t->to_thread_alive = inf_ttrace_thread_alive;
1191   t->to_pid_to_str = inf_ttrace_pid_to_str;
1192   t->to_xfer_partial = inf_ttrace_xfer_partial;
1193
1194   ttrace_ops_hack = t;
1195   return t;
1196 }
1197 #endif
1198 \f
1199
1200 /* Prevent warning from -Wmissing-prototypes.  */
1201 void _initialize_hppa_hpux_nat (void);
1202
1203 void
1204 _initialize_inf_ttrace (void)
1205 {
1206 #ifdef HAVE_TTRACE
1207   inf_ttrace_page_dict.pagesize = getpagesize();
1208 #endif
1209 }