gdb/inf-ttrace.c

   1 /* Low-level child interface to ttrace.
   2
   3    Copyright 2004 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 2 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, write to the Free Software
  19    Foundation, Inc., 59 Temple Place - Suite 330,
  20    Boston, MA 02111-1307, USA.  */
  21
  22 #include "defs.h"
  23
  24 /* The ttrace(2) system call didn't exist before HP-UX 10.30.  Don't
  25    try to compile this code unless we have it.  */
  26 #ifdef HAVE_TTRACE
  27
  28 #include "command.h"
  29 #include "gdbcore.h"
  30 #include "gdbthread.h"
  31 #include "inferior.h"
  32 #include "observer.h"
  33 #include "target.h"
  34
  35 #include "gdb_assert.h"
  36 #include "gdb_string.h"
  37 #include <sys/mman.h>
  38 #include <sys/ttrace.h>
  39
  40 #include "inf-child.h"
  41 #include "inf-ttrace.h"
  42
  43 /* HACK: Save the ttrace ops returned by inf_ttrace_target.  */
  44 static struct target_ops *ttrace_ops_hack;
  45 \f
  46
  47 /* HP-UX uses a threading model where each user-space thread
  48    corresponds to a kernel thread.  These kernel threads are called
  49    lwps.  The ttrace(2) interface gives us almost full control over
  50    the threads, which makes it very easy to support them in GDB.  We
  51    identify the threads by process ID and lwp ID.  The ttrace(2) also
  52    provides us with a thread's user ID (in the `tts_user_tid' member
  53    of `ttstate_t') but we don't use that (yet) as it isn't necessary
  54    to uniquely label the thread.  */
  55
  56 /* Number of active lwps.  */
  57 static int inf_ttrace_num_lwps;
  58 \f
  59
  60 /* On HP-UX versions that have the ttrace(2) system call, we can
  61    implement "hardware" watchpoints by fiddling with the protection of
  62    pages in the address space that contain the variable being watched.
  63    In order to implement this, we keep a dictionary of pages for which
  64    we have changed the protection.  */
  65
  66 struct inf_ttrace_page
  67 {
  68   CORE_ADDR addr;               /* Page address.  */
  69   int prot;                     /* Protection.  */
  70   int refcount;                 /* Reference count.  */
  71   struct inf_ttrace_page *next;
  72   struct inf_ttrace_page *prev;
  73 };
  74
  75 struct inf_ttrace_page_dict
  76 {
  77   struct inf_ttrace_page buckets[128];
  78   int pagesize;                 /* Page size.  */
  79   int count;                    /* Number of pages in this dictionary.  */
  80 } inf_ttrace_page_dict;
  81
  82 /* Number of lwps that are currently in a system call.  */
  83 static int inf_ttrace_num_lwps_in_syscall;
  84
  85 /* Flag to indicate whether we should re-enable page protections after
  86    the next wait.  */
  87 static int inf_ttrace_reenable_page_protections;
  88
  89 /* Enable system call events for process PID.  */
  90
  91 static void
  92 inf_ttrace_enable_syscall_events (pid_t pid)
  93 {
  94   ttevent_t tte;
  95   ttstate_t tts;
  96
  97   gdb_assert (inf_ttrace_num_lwps_in_syscall == 0);
  98
  99   if (ttrace (TT_PROC_GET_EVENT_MASK, pid, 0,
 100               (uintptr_t)&tte, sizeof tte, 0) == -1)
 101     perror_with_name ("ttrace");
 102
 103   tte.tte_events |= (TTEVT_SYSCALL_ENTRY | TTEVT_SYSCALL_RETURN);
 104
 105   if (ttrace (TT_PROC_SET_EVENT_MASK, pid, 0,
 106               (uintptr_t)&tte, sizeof tte, 0) == -1)
 107     perror_with_name ("ttrace");
 108
 109   if (ttrace (TT_PROC_GET_FIRST_LWP_STATE, pid, 0,
 110               (uintptr_t)&tts, sizeof tts, 0) == -1)
 111     perror_with_name ("ttrace");
 112
 113   if (tts.tts_flags & TTS_INSYSCALL)
 114     inf_ttrace_num_lwps_in_syscall++;
 115
 116   /* FIXME: Handle multiple threads.  */
 117 }
 118
 119 /* Disable system call events for process PID.  */
 120
 121 static void
 122 inf_ttrace_disable_syscall_events (pid_t pid)
 123 {
 124   ttevent_t tte;
 125
 126   gdb_assert (inf_ttrace_page_dict.count == 0);
 127
 128   if (ttrace (TT_PROC_GET_EVENT_MASK, pid, 0,
 129               (uintptr_t)&tte, sizeof tte, 0) == -1)
 130     perror_with_name ("ttrace");
 131
 132   tte.tte_events &= ~(TTEVT_SYSCALL_ENTRY | TTEVT_SYSCALL_RETURN);
 133
 134   if (ttrace (TT_PROC_SET_EVENT_MASK, pid, 0,
 135               (uintptr_t)&tte, sizeof tte, 0) == -1)
 136     perror_with_name ("ttrace");
 137
 138   inf_ttrace_num_lwps_in_syscall = 0;
 139 }
 140
 141 /* Get information about the page at address ADDR for process PID from
 142    the dictionary.  */
 143
 144 static struct inf_ttrace_page *
 145 inf_ttrace_get_page (pid_t pid, CORE_ADDR addr)
 146 {
 147   const int num_buckets = ARRAY_SIZE (inf_ttrace_page_dict.buckets);
 148   const int pagesize = inf_ttrace_page_dict.pagesize;
 149   int bucket;
 150   struct inf_ttrace_page *page;
 151
 152   bucket = (addr / pagesize) % num_buckets;
 153   page = &inf_ttrace_page_dict.buckets[bucket];
 154   while (page)
 155     {
 156       if (page->addr == addr)
 157         break;
 158
 159       page = page->next;
 160     }
 161
 162   return page;
 163 }
 164
 165 /* Add the page at address ADDR for process PID to the dictionary.  */
 166
 167 static struct inf_ttrace_page *
 168 inf_ttrace_add_page (pid_t pid, CORE_ADDR addr)
 169 {
 170   const int num_buckets = ARRAY_SIZE (inf_ttrace_page_dict.buckets);
 171   const int pagesize = inf_ttrace_page_dict.pagesize;
 172   int bucket;
 173   struct inf_ttrace_page *page;
 174   struct inf_ttrace_page *prev = NULL;
 175
 176   bucket = (addr / pagesize) % num_buckets;
 177   page = &inf_ttrace_page_dict.buckets[bucket];
 178   while (page)
 179     {
 180       if (page->addr == addr)
 181         break;
 182
 183       prev = page;
 184       page = page->next;
 185     }
 186
 187   if (!page)
 188     {
 189       int prot;
 190
 191       if (ttrace (TT_PROC_GET_MPROTECT, pid, 0,
 192                   addr, 0, (uintptr_t)&prot) == -1)
 193         perror_with_name ("ttrace");
 194
 195       page = XMALLOC (struct inf_ttrace_page);
 196       page->addr = addr;
 197       page->prot = prot;
 198       page->refcount = 0;
 199       page->next = NULL;
 200
 201       page->prev = prev;
 202       prev->next = page;
 203
 204       inf_ttrace_page_dict.count++;
 205       if (inf_ttrace_page_dict.count == 1)
 206         inf_ttrace_enable_syscall_events (pid);
 207
 208       if (inf_ttrace_num_lwps_in_syscall == 0)
 209         {
 210           if (ttrace (TT_PROC_SET_MPROTECT, pid, 0,
 211                       addr, pagesize, prot & ~PROT_WRITE) == -1)
 212             perror_with_name ("ttrace");
 213         }
 214     }
 215
 216   return page;
 217 }
 218
 219 /* Insert the page at address ADDR of process PID to the dictionary.  */
 220
 221 static void
 222 inf_ttrace_insert_page (pid_t pid, CORE_ADDR addr)
 223 {
 224   struct inf_ttrace_page *page;
 225
 226   page = inf_ttrace_get_page (pid, addr);
 227   if (!page)
 228     page = inf_ttrace_add_page (pid, addr);
 229
 230   page->refcount++;
 231 }
 232
 233 /* Remove the page at address ADDR of process PID from the dictionary.  */
 234
 235 static void
 236 inf_ttrace_remove_page (pid_t pid, CORE_ADDR addr)
 237 {
 238   const int pagesize = inf_ttrace_page_dict.pagesize;
 239   struct inf_ttrace_page *page;
 240
 241   page = inf_ttrace_get_page (pid, addr);
 242   page->refcount--;
 243
 244   gdb_assert (page->refcount >= 0);
 245
 246   if (page->refcount == 0)
 247     {
 248       if (inf_ttrace_num_lwps_in_syscall == 0)
 249         {
 250           if (ttrace (TT_PROC_SET_MPROTECT, pid, 0,
 251                       addr, pagesize, page->prot) == -1)
 252             perror_with_name ("ttrace");
 253         }
 254
 255       inf_ttrace_page_dict.count--;
 256       if (inf_ttrace_page_dict.count == 0)
 257         inf_ttrace_disable_syscall_events (pid);
 258
 259       page->prev->next = page->next;
 260       if (page->next)
 261         page->next->prev = page->prev;
 262
 263       xfree (page);
 264     }
 265 }
 266
 267 /* Mask the bits in PROT from the page protections that are currently
 268    in the dictionary for process PID.  */
 269
 270 static void
 271 inf_ttrace_mask_page_protections (pid_t pid, int prot)
 272 {
 273   const int num_buckets = ARRAY_SIZE (inf_ttrace_page_dict.buckets);
 274   const int pagesize = inf_ttrace_page_dict.pagesize;
 275   int bucket;
 276
 277   for (bucket = 0; bucket < num_buckets; bucket++)
 278     {
 279       struct inf_ttrace_page *page;
 280
 281       page = inf_ttrace_page_dict.buckets[bucket].next;
 282       while (page)
 283         {
 284           if (ttrace (TT_PROC_SET_MPROTECT, pid, 0,
 285                       page->addr, pagesize, page->prot & ~prot) == -1)
 286             perror_with_name ("ttrace");
 287
 288           page = page->next;
 289         }
 290     }
 291 }
 292
 293 /* Write-protect the pages in the dictionary for process PID.  */
 294
 295 static void
 296 inf_ttrace_enable_page_protections (pid_t pid)
 297 {
 298   inf_ttrace_mask_page_protections (pid, PROT_WRITE);
 299 }
 300
 301 /* Restore the protection of the pages in the dictionary for process
 302    PID.  */
 303
 304 static void
 305 inf_ttrace_disable_page_protections (pid_t pid)
 306 {
 307   inf_ttrace_mask_page_protections (pid, 0);
 308 }
 309
 310 /* Insert a "hardware" watchpoint for LEN bytes at address ADDR of
 311    type TYPE.  */
 312
 313 static int
 314 inf_ttrace_insert_watchpoint (CORE_ADDR addr, int len, int type)
 315 {
 316   const int pagesize = inf_ttrace_page_dict.pagesize;
 317   pid_t pid = ptid_get_pid (inferior_ptid);
 318   CORE_ADDR page_addr;
 319   int num_pages;
 320   int page;
 321
 322   gdb_assert (type == hw_write);
 323
 324   page_addr = (addr / pagesize) * pagesize;
 325   num_pages = (len + pagesize - 1) / pagesize;
 326
 327   for (page = 0; page < num_pages; page++, page_addr += pagesize)
 328     inf_ttrace_insert_page (pid, page_addr);
 329
 330   return 1;
 331 }
 332
 333 /* Remove a "hardware" watchpoint for LEN bytes at address ADDR of
 334    type TYPE.  */
 335
 336 static int
 337 inf_ttrace_remove_watchpoint (CORE_ADDR addr, int len, int type)
 338 {
 339   const int pagesize = inf_ttrace_page_dict.pagesize;
 340   pid_t pid = ptid_get_pid (inferior_ptid);
 341   CORE_ADDR page_addr;
 342   int num_pages;
 343   int page;
 344
 345   gdb_assert (type == hw_write);
 346
 347   page_addr = (addr / pagesize) * pagesize;
 348   num_pages = (len + pagesize - 1) / pagesize;
 349
 350   for (page = 0; page < num_pages; page++, page_addr += pagesize)
 351     inf_ttrace_remove_page (pid, page_addr);
 352
 353   return 1;
 354 }
 355
 356 static int
 357 inf_ttrace_can_use_hw_breakpoint (int type, int len, int ot)
 358 {
 359   return (type == bp_hardware_watchpoint);
 360 }
 361
 362 static int
 363 inf_ttrace_region_size_ok_for_hw_watchpoint (int len)
 364 {
 365   return 1;
 366 }
 367
 368 /* Return non-zero if the current inferior was (potentially) stopped
 369    by hitting a "hardware" watchpoint.  */
 370
 371 static int
 372 inf_ttrace_stopped_by_watchpoint (void)
 373 {
 374   pid_t pid = ptid_get_pid (inferior_ptid);
 375   lwpid_t lwpid = ptid_get_lwp (inferior_ptid);
 376   ttstate_t tts;
 377
 378   if (inf_ttrace_page_dict.count > 0)
 379     {
 380       if (ttrace (TT_LWP_GET_STATE, pid, lwpid,
 381                   (uintptr_t)&tts, sizeof tts, 0) == -1)
 382         perror_with_name ("ttrace");
 383
 384       if (tts.tts_event == TTEVT_SIGNAL
 385           && tts.tts_u.tts_signal.tts_signo == SIGBUS)
 386         {
 387           const int pagesize = inf_ttrace_page_dict.pagesize;
 388           void *addr = tts.tts_u.tts_signal.tts_siginfo.si_addr;
 389           CORE_ADDR page_addr = ((uintptr_t)addr / pagesize) * pagesize;
 390
 391           if (inf_ttrace_get_page (pid, page_addr))
 392             return 1;
 393         }
 394     }
 395
 396   return 0;
 397 }
 398 \f
 399
 400 /* File descriptors for pipes used as semaphores during initial
 401    startup of an inferior.  */
 402 static int inf_ttrace_pfd1[2];
 403 static int inf_ttrace_pfd2[2];
 404
 405 static void
 406 do_cleanup_pfds (void *dummy)
 407 {
 408   close (inf_ttrace_pfd1[0]);
 409   close (inf_ttrace_pfd1[1]);
 410   close (inf_ttrace_pfd2[0]);
 411   close (inf_ttrace_pfd2[1]);
 412 }
 413
 414 static void
 415 inf_ttrace_prepare (void)
 416 {
 417   if (pipe (inf_ttrace_pfd1) == -1)
 418     perror_with_name ("pipe");
 419
 420   if (pipe (inf_ttrace_pfd2) == -1)
 421     {
 422       close (inf_ttrace_pfd1[0]);
 423       close (inf_ttrace_pfd2[0]);
 424       perror_with_name ("pipe");
 425     }
 426 }
 427
 428 /* Prepare to be traced.  */
 429
 430 static void
 431 inf_ttrace_me (void)
 432 {
 433   struct cleanup *old_chain = make_cleanup (do_cleanup_pfds, 0);
 434   char c;
 435
 436   /* "Trace me, Dr. Memory!"  */
 437   if (ttrace (TT_PROC_SETTRC, 0, 0, 0, TT_VERSION, 0) == -1)
 438     perror_with_name ("ttrace");
 439
 440   /* Tell our parent that we are ready to be traced.  */
 441   if (write (inf_ttrace_pfd1[1], &c, sizeof c) != sizeof c)
 442     perror_with_name ("write");
 443
 444   /* Wait until our parent has set the initial event mask.  */
 445   if (read (inf_ttrace_pfd2[0], &c, sizeof c) != sizeof c)
 446     perror_with_name ("read");
 447
 448   do_cleanups (old_chain);
 449 }
 450
 451 /* Start tracing PID.  */
 452
 453 static void
 454 inf_ttrace_him (int pid)
 455 {
 456   struct cleanup *old_chain = make_cleanup (do_cleanup_pfds, 0);
 457   ttevent_t tte;
 458   char c;
 459
 460   /* Wait until our child is ready to be traced.  */
 461   if (read (inf_ttrace_pfd1[0], &c, sizeof c) != sizeof c)
 462     perror_with_name ("read");
 463
 464   /* Set the initial event mask.  */
 465   memset (&tte, 0, sizeof (tte));
 466   tte.tte_events |= TTEVT_EXEC | TTEVT_EXIT;
 467   tte.tte_events |= TTEVT_LWP_CREATE | TTEVT_LWP_EXIT | TTEVT_LWP_TERMINATE;
 468   tte.tte_opts = TTEO_NOSTRCCHLD;
 469   if (ttrace (TT_PROC_SET_EVENT_MASK, pid, 0,
 470               (uintptr_t)&tte, sizeof tte, 0) == -1)
 471     perror_with_name ("ttrace");
 472
 473   /* Tell our child that we have set the initial event mask.  */
 474   if (write (inf_ttrace_pfd2[1], &c, sizeof c) != sizeof c)
 475     perror_with_name ("write");
 476
 477   do_cleanups (old_chain);
 478
 479   push_target (ttrace_ops_hack);
 480
 481   /* On some targets, there must be some explicit synchronization
 482      between the parent and child processes after the debugger forks,
 483      and before the child execs the debuggee program.  This call
 484      basically gives permission for the child to exec.  */
 485
 486   target_acknowledge_created_inferior (pid);
 487
 488   /* START_INFERIOR_TRAPS_EXPECTED is defined in inferior.h, and will
 489      be 1 or 2 depending on whether we're starting without or with a
 490      shell.  */
 491   startup_inferior (START_INFERIOR_TRAPS_EXPECTED);
 492
 493   /* On some targets, there must be some explicit actions taken after
 494      the inferior has been started up.  */
 495   target_post_startup_inferior (pid_to_ptid (pid));
 496 }
 497
 498 static void
 499 inf_ttrace_create_inferior (char *exec_file, char *allargs, char **env,
 500                             int from_tty)
 501 {
 502   gdb_assert (inf_ttrace_num_lwps == 0);
 503   gdb_assert (inf_ttrace_num_lwps_in_syscall == 0);
 504   gdb_assert (inf_ttrace_page_dict.count == 0);
 505   gdb_assert (inf_ttrace_reenable_page_protections == 0);
 506
 507   fork_inferior (exec_file, allargs, env, inf_ttrace_me, inf_ttrace_him,
 508                  inf_ttrace_prepare, NULL);
 509
 510   /* We are at the first instruction we care about.  */
 511   observer_notify_inferior_created (&current_target, from_tty);
 512
 513   /* Pedal to the metal...  */
 514   proceed ((CORE_ADDR) -1, TARGET_SIGNAL_0, 0);
 515 }
 516
 517 static void
 518 inf_ttrace_kill_inferior (void)
 519 {
 520   pid_t pid = ptid_get_pid (inferior_ptid);
 521
 522   if (pid == 0)
 523     return;
 524
 525   if (ttrace (TT_PROC_EXIT, pid, 0, 0, 0, 0) == -1)
 526     perror_with_name ("ttrace");
 527   /* ??? Is it necessary to call ttrace_wait() here?  */
 528   target_mourn_inferior ();
 529 }
 530
 531 static void
 532 inf_ttrace_mourn_inferior (void)
 533 {
 534   const int num_buckets = ARRAY_SIZE (inf_ttrace_page_dict.buckets);
 535   int bucket;
 536
 537   inf_ttrace_num_lwps = 0;
 538   inf_ttrace_num_lwps_in_syscall = 0;
 539
 540   for (bucket = 0; bucket < num_buckets; bucket++)
 541     {
 542       struct inf_ttrace_page *page;
 543       struct inf_ttrace_page *next;
 544
 545       page = inf_ttrace_page_dict.buckets[bucket].next;
 546       while (page)
 547         {
 548           next = page->next;
 549           xfree (page);
 550           page = next;
 551         }
 552     }
 553   inf_ttrace_page_dict.count = 0;
 554
 555   unpush_target (ttrace_ops_hack);
 556   generic_mourn_inferior ();
 557 }
 558
 559 static void
 560 inf_ttrace_attach (char *args, int from_tty)
 561 {
 562   char *exec_file;
 563   pid_t pid;
 564   char *dummy;
 565   ttevent_t tte;
 566
 567   if (!args)
 568     error_no_arg ("process-id to attach");
 569
 570   dummy = args;
 571   pid = strtol (args, &dummy, 0);
 572   if (pid == 0 && args == dummy)
 573     error ("Illegal process-id: %s\n", args);
 574
 575   if (pid == getpid ())         /* Trying to masturbate?  */
 576     error ("I refuse to debug myself!");
 577
 578   if (from_tty)
 579     {
 580       exec_file = (char *) get_exec_file (0);
 581
 582       if (exec_file)
 583         printf_unfiltered ("Attaching to program: %s, %s\n", exec_file,
 584                            target_pid_to_str (pid_to_ptid (pid)));
 585       else
 586         printf_unfiltered ("Attaching to %s\n",
 587                            target_pid_to_str (pid_to_ptid (pid)));
 588
 589       gdb_flush (gdb_stdout);
 590     }
 591
 592   gdb_assert (inf_ttrace_num_lwps == 0);
 593   gdb_assert (inf_ttrace_num_lwps_in_syscall == 0);
 594
 595   if (ttrace (TT_PROC_ATTACH, pid, 0, TT_KILL_ON_EXIT, TT_VERSION, 0) == -1)
 596     perror_with_name ("ttrace");
 597   attach_flag = 1;
 598
 599   /* Set the initial event mask.  */
 600   memset (&tte, 0, sizeof (tte));
 601   tte.tte_events |= TTEVT_EXEC | TTEVT_EXIT;
 602   tte.tte_events |= TTEVT_LWP_CREATE | TTEVT_LWP_EXIT | TTEVT_LWP_TERMINATE;
 603   tte.tte_opts = TTEO_NOSTRCCHLD;
 604   if (ttrace (TT_PROC_SET_EVENT_MASK, pid, 0,
 605               (uintptr_t)&tte, sizeof tte, 0) == -1)
 606     perror_with_name ("ttrace");
 607
 608   inferior_ptid = pid_to_ptid (pid);
 609   push_target (ttrace_ops_hack);
 610
 611   /* Do this first, before anything has had a chance to query the
 612      inferior's symbol table or similar.  */
 613   observer_notify_inferior_created (&current_target, from_tty);
 614 }
 615
 616 static void
 617 inf_ttrace_detach (char *args, int from_tty)
 618 {
 619   int sig = 0;
 620   pid_t pid = ptid_get_pid (inferior_ptid);
 621
 622   if (from_tty)
 623     {
 624       char *exec_file = get_exec_file (0);
 625       if (exec_file == 0)
 626         exec_file = "";
 627       printf_unfiltered ("Detaching from program: %s, %s\n", exec_file,
 628                          target_pid_to_str (pid_to_ptid (pid)));
 629       gdb_flush (gdb_stdout);
 630     }
 631   if (args)
 632     sig = atoi (args);
 633
 634   /* ??? The HP-UX 11.0 ttrace(2) manual page doesn't mention that we
 635      can pass a signal number here.  Does this really work?  */
 636   if (ttrace (TT_PROC_DETACH, pid, 0, 0, sig, 0) == -1)
 637     perror_with_name ("ttrace");
 638
 639   inf_ttrace_num_lwps = 0;
 640   inf_ttrace_num_lwps_in_syscall = 0;
 641
 642   unpush_target (ttrace_ops_hack);
 643   inferior_ptid = null_ptid;
 644 }
 645
 646 static void
 647 inf_ttrace_resume (ptid_t ptid, int step, enum target_signal signal)
 648 {
 649   pid_t pid = ptid_get_pid (ptid);
 650   lwpid_t lwpid = ptid_get_lwp (ptid);
 651   ttreq_t request = step ? TT_LWP_SINGLE : TT_LWP_CONTINUE;
 652   int sig = target_signal_to_host (signal);
 653
 654   if (pid == -1)
 655     {
 656       pid = ptid_get_pid (inferior_ptid);
 657       lwpid = ptid_get_lwp (inferior_ptid);
 658     }
 659
 660   if (ttrace (request, pid, lwpid, TT_NOPC, sig, 0) == -1)
 661     perror_with_name ("ttrace");
 662
 663   if (ptid_equal (ptid, minus_one_ptid))
 664     {
 665       /* Let all the other threads run too.  */
 666       if (ttrace (TT_PROC_CONTINUE, pid, 0, 0, 0, 0) == -1)
 667         perror_with_name ("ttrace");
 668     }
 669 }
 670
 671 static ptid_t
 672 inf_ttrace_wait (ptid_t ptid, struct target_waitstatus *ourstatus)
 673 {
 674   pid_t pid = ptid_get_pid (ptid);
 675   lwpid_t lwpid = ptid_get_lwp (ptid);
 676   ttstate_t tts;
 677
 678   /* Until proven otherwise.  */
 679   ourstatus->kind = TARGET_WAITKIND_SPURIOUS;
 680
 681   if (pid == -1)
 682     pid = 0;
 683
 684   gdb_assert (lwpid == 0 || pid != 0);
 685
 686   do
 687     {
 688       set_sigint_trap ();
 689       set_sigio_trap ();
 690
 691       if (ttrace_wait (pid, lwpid, TTRACE_WAITOK, &tts, sizeof tts) == -1)
 692         perror_with_name ("ttrace_wait");
 693
 694       clear_sigio_trap ();
 695       clear_sigint_trap ();
 696     }
 697   while (tts.tts_event == TTEVT_NONE);
 698
 699   /* Now that we've waited, we can re-enable the page protections.  */
 700   if (inf_ttrace_reenable_page_protections)
 701     {
 702       gdb_assert (inf_ttrace_num_lwps_in_syscall == 0);
 703       inf_ttrace_enable_page_protections (tts.tts_pid);
 704       inf_ttrace_reenable_page_protections = 0;
 705     }
 706
 707   ptid = ptid_build (tts.tts_pid, tts.tts_lwpid, 0);
 708
 709   switch (tts.tts_event)
 710     {
 711     case TTEVT_EXEC:
 712       /* Make it look like a breakpoint.  */
 713       ourstatus->kind = TARGET_WAITKIND_STOPPED;
 714       ourstatus->value.sig = TARGET_SIGNAL_TRAP;
 715       break;
 716
 717     case TTEVT_EXIT:
 718       store_waitstatus (ourstatus, tts.tts_u.tts_exit.tts_exitcode);
 719       inf_ttrace_num_lwps = 0;
 720       break;
 721
 722     case TTEVT_LWP_CREATE:
 723       lwpid = tts.tts_u.tts_thread.tts_target_lwpid;
 724       ptid = ptid_build (tts.tts_pid, lwpid, 0);
 725       if (inf_ttrace_num_lwps == 0)
 726         {
 727           /* Now that we're going to be multi-threaded, add the
 728              origional thread to the list first.  */
 729           add_thread (ptid_build (tts.tts_pid, tts.tts_lwpid, 0));
 730           inf_ttrace_num_lwps++;
 731         }
 732       printf_filtered ("[New %s]\n", target_pid_to_str (ptid));
 733       add_thread (ptid);
 734       inf_ttrace_num_lwps++;
 735       ptid = ptid_build (tts.tts_pid, tts.tts_lwpid, 0);
 736       break;
 737
 738     case TTEVT_LWP_EXIT:
 739       printf_filtered("[%s exited]\n", target_pid_to_str (ptid));
 740       delete_thread (ptid);
 741       inf_ttrace_num_lwps--;
 742       /* If we don't return -1 here, core GDB will re-add the thread.  */
 743       ptid = minus_one_ptid;
 744       break;
 745
 746     case TTEVT_LWP_TERMINATE:
 747       lwpid = tts.tts_u.tts_thread.tts_target_lwpid;
 748       ptid = ptid_build (tts.tts_pid, lwpid, 0);
 749       printf_filtered("[%s has been terminated]\n", target_pid_to_str (ptid));
 750       delete_thread (ptid);
 751       inf_ttrace_num_lwps--;
 752       ptid = ptid_build (tts.tts_pid, tts.tts_lwpid, 0);
 753       break;
 754
 755     case TTEVT_SIGNAL:
 756       ourstatus->kind = TARGET_WAITKIND_STOPPED;
 757       ourstatus->value.sig =
 758         target_signal_from_host (tts.tts_u.tts_signal.tts_signo);
 759       break;
 760
 761     case TTEVT_SYSCALL_ENTRY:
 762       gdb_assert (inf_ttrace_reenable_page_protections == 0);
 763       inf_ttrace_num_lwps_in_syscall++;
 764       if (inf_ttrace_num_lwps_in_syscall == 1)
 765         {
 766           /* A thread has just entered a system call.  Disable any
 767              page protections as the kernel can't deal with them.  */
 768           inf_ttrace_disable_page_protections (tts.tts_pid);
 769         }
 770       ourstatus->kind = TARGET_WAITKIND_SYSCALL_ENTRY;
 771       ourstatus->value.syscall_id = tts.tts_scno;
 772       break;
 773
 774     case TTEVT_SYSCALL_RETURN:
 775       if (inf_ttrace_num_lwps_in_syscall > 0)
 776         {
 777           /* If the last thread has just left the system call, this
 778              would be a logical place to re-enable the page
 779              protections, but that doesn't work.  We can't re-enable
 780              them until we've done another wait.  */
 781           inf_ttrace_reenable_page_protections =
 782             (inf_ttrace_num_lwps_in_syscall == 1);
 783           inf_ttrace_num_lwps_in_syscall--;
 784         }
 785       ourstatus->kind = TARGET_WAITKIND_SYSCALL_RETURN;
 786       ourstatus->value.syscall_id = tts.tts_scno;
 787       break;
 788
 789     default:
 790       gdb_assert (!"Unexpected ttrace event");
 791       break;
 792     }
 793
 794   /* Make sure all threads within the process are stopped.  */
 795   if (ttrace (TT_PROC_STOP, tts.tts_pid, 0, 0, 0, 0) == -1)
 796     perror_with_name ("ttrace");
 797
 798   /* HACK: Twiddle INFERIOR_PTID such that the initial thread of a
 799      process isn't recognized as a new thread.  */
 800   if (ptid_get_lwp (inferior_ptid) == 0)
 801     inferior_ptid = ptid;
 802
 803   return ptid;
 804 }
 805
 806 /* Transfer LEN bytes from ADDR in the inferior's memory into READBUF,
 807    and transfer LEN bytes from WRITEBUF into the inferior's memory at
 808    ADDR.  Either READBUF or WRITEBUF may be null, in which case the
 809    corresponding transfer doesn't happen.  Return the number of bytes
 810    actually transferred (which may be zero if an error occurs).  */
 811
 812 static LONGEST
 813 inf_ttrace_xfer_memory (CORE_ADDR addr, ULONGEST len,
 814                         void *readbuf, const void *writebuf)
 815 {
 816   pid_t pid = ptid_get_pid (inferior_ptid);
 817
 818   /* HP-UX treats text space and data space differently.  GDB however,
 819      doesn't really know the difference.  Therefore we try both.  Try
 820      text space before data space though because when we're writing
 821      into text space the instruction cache might need to be flushed.  */
 822
 823   if (readbuf
 824       && ttrace (TT_PROC_RDTEXT, pid, 0, addr, len, (uintptr_t)readbuf) == -1
 825       && ttrace (TT_PROC_RDDATA, pid, 0, addr, len, (uintptr_t)readbuf) == -1)
 826     return 0;
 827
 828   if (writebuf
 829       && ttrace (TT_PROC_WRTEXT, pid, 0, addr, len, (uintptr_t)writebuf) == -1
 830       && ttrace (TT_PROC_WRDATA, pid, 0, addr, len, (uintptr_t)writebuf) == -1)
 831     return 0;
 832
 833   return len;
 834 }
 835
 836 static LONGEST
 837 inf_ttrace_xfer_partial (struct target_ops *ops, enum target_object object,
 838                          const char *annex, void *readbuf,
 839                          const void *writebuf, ULONGEST offset, LONGEST len)
 840 {
 841   switch (object)
 842     {
 843     case TARGET_OBJECT_MEMORY:
 844       return inf_ttrace_xfer_memory (offset, len, readbuf, writebuf);
 845
 846     case TARGET_OBJECT_UNWIND_TABLE:
 847       return -1;
 848
 849     case TARGET_OBJECT_AUXV:
 850       return -1;
 851
 852     case TARGET_OBJECT_WCOOKIE:
 853       return -1;
 854
 855     default:
 856       return -1;
 857     }
 858 }
 859
 860 /* Print status information about what we're accessing.  */
 861
 862 static void
 863 inf_ttrace_files_info (struct target_ops *ignore)
 864 {
 865   printf_unfiltered ("\tUsing the running image of %s %s.\n",
 866                      attach_flag ? "attached" : "child",
 867                      target_pid_to_str (inferior_ptid));
 868 }
 869
 870 static int
 871 inf_ttrace_thread_alive (ptid_t ptid)
 872 {
 873   return 1;
 874 }
 875
 876 static char *
 877 inf_ttrace_pid_to_str (ptid_t ptid)
 878 {
 879   if (inf_ttrace_num_lwps > 0)
 880     {
 881       pid_t pid = ptid_get_pid (ptid);
 882       lwpid_t lwpid = ptid_get_lwp (ptid);
 883       static char buf[80];
 884
 885       sprintf (buf, "process %ld, lwp %ld", (long)pid, (long)lwpid);
 886       return buf;
 887     }
 888
 889   return normal_pid_to_str (ptid);
 890 }
 891 \f
 892
 893 struct target_ops *
 894 inf_ttrace_target (void)
 895 {
 896   struct target_ops *t = inf_child_target ();
 897
 898   t->to_create_inferior = inf_ttrace_create_inferior;
 899   t->to_kill = inf_ttrace_kill_inferior;
 900   t->to_mourn_inferior = inf_ttrace_mourn_inferior;
 901   t->to_attach = inf_ttrace_attach;
 902   t->to_detach = inf_ttrace_detach;
 903   t->to_resume = inf_ttrace_resume;
 904   t->to_wait = inf_ttrace_wait;
 905   t->to_xfer_partial = inf_ttrace_xfer_partial;
 906   t->to_files_info = inf_ttrace_files_info;
 907   t->to_thread_alive = inf_ttrace_thread_alive;
 908   t->to_pid_to_str = inf_ttrace_pid_to_str;
 909   t->to_can_use_hw_breakpoint = inf_ttrace_can_use_hw_breakpoint;
 910   t->to_region_size_ok_for_hw_watchpoint =
 911     inf_ttrace_region_size_ok_for_hw_watchpoint;
 912   t->to_insert_watchpoint = inf_ttrace_insert_watchpoint;
 913   t->to_remove_watchpoint = inf_ttrace_remove_watchpoint;
 914   t->to_stopped_by_watchpoint = inf_ttrace_stopped_by_watchpoint;
 915
 916   ttrace_ops_hack = t;
 917   return t;
 918 }
 919 #endif
 920 \f
 921
 922 /* Prevent warning from -Wmissing-prototypes.  */
 923 void _initialize_hppa_hpux_nat (void);
 924
 925 void
 926 _initialize_inf_ttrace (void)
 927 {
 928 #ifdef HAVE_TTRACE
 929   inf_ttrace_page_dict.pagesize = getpagesize();
 930 #endif
 931 }