gdb/lin-lwp.c

   1 /* Multi-threaded debugging support for Linux (LWP layer).
   2    Copyright 2000, 2001 Free Software Foundation, Inc.
   3
   4    This file is part of GDB.
   5
   6    This program is free software; you can redistribute it and/or modify
   7    it under the terms of the GNU General Public License as published by
   8    the Free Software Foundation; either version 2 of the License, or
   9    (at your option) any later version.
  10
  11    This program is distributed in the hope that it will be useful,
  12    but WITHOUT ANY WARRANTY; without even the implied warranty of
  13    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14    GNU General Public License for more details.
  15
  16    You should have received a copy of the GNU General Public License
  17    along with this program; if not, write to the Free Software
  18    Foundation, Inc., 59 Temple Place - Suite 330,
  19    Boston, MA 02111-1307, USA.  */
  20
  21 #include "defs.h"
  22
  23 #include "gdb_assert.h"
  24 #include <errno.h>
  25 #include <signal.h>
  26 #include <sys/ptrace.h>
  27 #include "gdb_wait.h"
  28
  29 #include "gdbthread.h"
  30 #include "inferior.h"
  31 #include "target.h"
  32 #include "regcache.h"
  33 #include "gdbcmd.h"
  34
  35 static int debug_lin_lwp;
  36 extern const char *strsignal (int sig);
  37
  38 /* On Linux there are no real LWP's.  The closest thing to LWP's are
  39    processes sharing the same VM space.  A multi-threaded process is
  40    basically a group of such processes.  However, such a grouping is
  41    almost entirely a user-space issue; the kernel doesn't enforce such
  42    a grouping at all (this might change in the future).  In general,
  43    we'll rely on the threads library (i.e. the LinuxThreads library)
  44    to provide such a grouping.
  45
  46    It is perfectly well possible to write a multi-threaded application
  47    without the assistance of a threads library, by using the clone
  48    system call directly.  This module should be able to give some
  49    rudimentary support for debugging such applications if developers
  50    specify the CLONE_PTRACE flag in the clone system call, and are
  51    using Linux 2.4 or above.
  52
  53    Note that there are some peculiarities in Linux that affect this
  54    code:
  55
  56    - In general one should specify the __WCLONE flag to waitpid in
  57      order to make it report events for any of the cloned processes
  58      (and leave it out for the initial process).  However, if a cloned
  59      process has exited the exit status is only reported if the
  60      __WCLONE flag is absent.  Linux 2.4 has a __WALL flag, but we
  61      cannot use it since GDB must work on older systems too.
  62
  63    - When a traced, cloned process exits and is waited for by the
  64      debugger, the kernel reassigns it to the original parent and
  65      keeps it around as a "zombie".  Somehow, the LinuxThreads library
  66      doesn't notice this, which leads to the "zombie problem": When
  67      debugged a multi-threaded process that spawns a lot of threads
  68      will run out of processes, even if the threads exit, because the
  69      "zombies" stay around.  */
  70
  71 /* Structure describing a LWP.  */
  72 struct lwp_info
  73 {
  74   /* The process id of the LWP.  This is a combination of the LWP id
  75      and overall process id.  */
  76   ptid_t ptid;
  77
  78   /* Non-zero if we sent this LWP a SIGSTOP (but the LWP didn't report
  79      it back yet).  */
  80   int signalled;
  81
  82   /* Non-zero if this LWP is stopped.  */
  83   int stopped;
  84
  85   /* Non-zero if this LWP will be/has been resumed.  Note that an LWP
  86      can be marked both as stopped and resumed at the same time.  This
  87      happens if we try to resume an LWP that has a wait status
  88      pending.  We shouldn't let the LWP run until that wait status has
  89      been processed, but we should not report that wait status if GDB
  90      didn't try to let the LWP run.  */
  91   int resumed;
  92
  93   /* If non-zero, a pending wait status.  */
  94   int status;
  95
  96   /* Non-zero if we were stepping this LWP.  */
  97   int step;
  98
  99   /* Next LWP in list.  */
 100   struct lwp_info *next;
 101 };
 102
 103 /* List of known LWPs.  */
 104 static struct lwp_info *lwp_list;
 105
 106 /* Number of LWPs in the list.  */
 107 static int num_lwps;
 108
 109 /* Non-zero if we're running in "threaded" mode.  */
 110 static int threaded;
 111 \f
 112
 113 #define GET_LWP(ptid)           ptid_get_lwp (ptid)
 114 #define GET_PID(ptid)           ptid_get_pid (ptid)
 115 #define is_lwp(ptid)            (GET_LWP (ptid) != 0)
 116 #define BUILD_LWP(lwp, pid)     ptid_build (pid, lwp, 0)
 117
 118 #define is_cloned(pid)  (GET_LWP (pid) != GET_PID (pid))
 119
 120 /* If the last reported event was a SIGTRAP, this variable is set to
 121    the process id of the LWP/thread that got it.  */
 122 ptid_t trap_ptid;
 123 \f
 124
 125 /* This module's target-specific operations.  */
 126 static struct target_ops lin_lwp_ops;
 127
 128 /* The standard child operations.  */
 129 extern struct target_ops child_ops;
 130
 131 /* Since we cannot wait (in lin_lwp_wait) for the initial process and
 132    any cloned processes with a single call to waitpid, we have to use
 133    the WNOHANG flag and call waitpid in a loop.  To optimize
 134    things a bit we use `sigsuspend' to wake us up when a process has
 135    something to report (it will send us a SIGCHLD if it has).  To make
 136    this work we have to juggle with the signal mask.  We save the
 137    original signal mask such that we can restore it before creating a
 138    new process in order to avoid blocking certain signals in the
 139    inferior.  We then block SIGCHLD during the waitpid/sigsuspend
 140    loop.  */
 141
 142 /* Original signal mask.  */
 143 static sigset_t normal_mask;
 144
 145 /* Signal mask for use with sigsuspend in lin_lwp_wait, initialized in
 146    _initialize_lin_lwp.  */
 147 static sigset_t suspend_mask;
 148
 149 /* Signals to block to make that sigsuspend work.  */
 150 static sigset_t blocked_mask;
 151 \f
 152
 153 /* Prototypes for local functions.  */
 154 static int stop_wait_callback (struct lwp_info *lp, void *data);
 155 \f
 156 /* Convert wait status STATUS to a string.  Used for printing debug
 157    messages only.  */
 158
 159 static char *
 160 status_to_str (int status)
 161 {
 162   static char buf[64];
 163
 164   if (WIFSTOPPED (status))
 165     snprintf (buf, sizeof (buf), "%s (stopped)",
 166               strsignal (WSTOPSIG (status)));
 167   else if (WIFSIGNALED (status))
 168     snprintf (buf, sizeof (buf), "%s (terminated)",
 169               strsignal (WSTOPSIG (status)));
 170   else
 171     snprintf (buf, sizeof (buf), "%d (exited)",
 172               WEXITSTATUS (status));
 173
 174   return buf;
 175 }
 176 \f
 177 /* Initialize the list of LWPs.  Note that this module, contrary to
 178    what GDB's generic threads layer does for its thread list,
 179    re-initializes the LWP lists whenever we mourn or detach (which
 180    doesn't involve mourning) the inferior.  */
 181
 182 static void
 183 init_lwp_list (void)
 184 {
 185   struct lwp_info *lp, *lpnext;
 186
 187   for (lp = lwp_list; lp; lp = lpnext)
 188     {
 189       lpnext = lp->next;
 190       xfree (lp);
 191     }
 192
 193   lwp_list = NULL;
 194   num_lwps = 0;
 195   threaded = 0;
 196 }
 197
 198 /* Add the LWP specified by PID to the list.  If this causes the
 199    number of LWPs to become larger than one, go into "threaded" mode.
 200    Return a pointer to the structure describing the new LWP.  */
 201
 202 static struct lwp_info *
 203 add_lwp (ptid_t ptid)
 204 {
 205   struct lwp_info *lp;
 206
 207   gdb_assert (is_lwp (ptid));
 208
 209   lp = (struct lwp_info *) xmalloc (sizeof (struct lwp_info));
 210
 211   memset (lp, 0, sizeof (struct lwp_info));
 212
 213   lp->ptid = ptid;
 214
 215   lp->next = lwp_list;
 216   lwp_list = lp;
 217   if (++num_lwps > 1)
 218     threaded = 1;
 219
 220   return lp;
 221 }
 222
 223 /* Remove the LWP specified by PID from the list.  */
 224
 225 static void
 226 delete_lwp (ptid_t ptid)
 227 {
 228   struct lwp_info *lp, *lpprev;
 229
 230   lpprev = NULL;
 231
 232   for (lp = lwp_list; lp; lpprev = lp, lp = lp->next)
 233     if (ptid_equal (lp->ptid, ptid))
 234       break;
 235
 236   if (!lp)
 237     return;
 238
 239   /* We don't go back to "non-threaded" mode if the number of threads
 240      becomes less than two.  */
 241   num_lwps--;
 242
 243   if (lpprev)
 244     lpprev->next = lp->next;
 245   else
 246     lwp_list = lp->next;
 247
 248   xfree (lp);
 249 }
 250
 251 /* Return a pointer to the structure describing the LWP corresponding
 252    to PID.  If no corresponding LWP could be found, return NULL.  */
 253
 254 static struct lwp_info *
 255 find_lwp_pid (ptid_t ptid)
 256 {
 257   struct lwp_info *lp;
 258   int lwp;
 259
 260   if (is_lwp (ptid))
 261     lwp = GET_LWP (ptid);
 262   else
 263     lwp = GET_PID (ptid);
 264
 265   for (lp = lwp_list; lp; lp = lp->next)
 266     if (lwp == GET_LWP (lp->ptid))
 267       return lp;
 268
 269   return NULL;
 270 }
 271
 272 /* Call CALLBACK with its second argument set to DATA for every LWP in
 273    the list.  If CALLBACK returns 1 for a particular LWP, return a
 274    pointer to the structure describing that LWP immediately.
 275    Otherwise return NULL.  */
 276
 277 struct lwp_info *
 278 iterate_over_lwps (int (*callback) (struct lwp_info *, void *), void *data)
 279 {
 280   struct lwp_info *lp, *lpnext;
 281
 282   for (lp = lwp_list; lp; lp = lpnext)
 283     {
 284       lpnext = lp->next;
 285       if ((*callback) (lp, data))
 286         return lp;
 287     }
 288
 289   return NULL;
 290 }
 291 \f
 292
 293 /* Implementation of the PREPARE_TO_PROCEED hook for the Linux LWP
 294    layer.
 295
 296    Note that this implementation is potentially redundant now that
 297    default_prepare_to_proceed() has been added.
 298
 299    FIXME This may not support switching threads after Ctrl-C
 300    correctly. The default implementation does support this. */
 301
 302 int
 303 lin_lwp_prepare_to_proceed (void)
 304 {
 305   if (! ptid_equal (trap_ptid, null_ptid)
 306       && ! ptid_equal (inferior_ptid, trap_ptid))
 307     {
 308       /* Switched over from TRAP_PID.  */
 309       CORE_ADDR stop_pc = read_pc ();
 310       CORE_ADDR trap_pc;
 311
 312       /* Avoid switching where it wouldn't do any good, i.e. if both
 313          threads are at the same breakpoint.  */
 314       trap_pc = read_pc_pid (trap_ptid);
 315       if (trap_pc != stop_pc && breakpoint_here_p (trap_pc))
 316         {
 317           /* User hasn't deleted the breakpoint.  Return non-zero, and
 318              switch back to TRAP_PID.  */
 319           inferior_ptid = trap_ptid;
 320
 321           /* FIXME: Is this stuff really necessary?  */
 322           flush_cached_frames ();
 323           registers_changed ();
 324
 325           return 1;
 326         }
 327     }
 328
 329   return 0;
 330 }
 331 \f
 332
 333 #if 0
 334 static void
 335 lin_lwp_open (char *args, int from_tty)
 336 {
 337   push_target (&lin_lwp_ops);
 338 }
 339 #endif
 340
 341 /* Attach to the LWP specified by PID.  If VERBOSE is non-zero, print
 342    a message telling the user that a new LWP has been added to the
 343    process.  */
 344
 345 void
 346 lin_lwp_attach_lwp (ptid_t ptid, int verbose)
 347 {
 348   struct lwp_info *lp;
 349
 350   gdb_assert (is_lwp (ptid));
 351
 352   if (verbose)
 353     printf_filtered ("[New %s]\n", target_pid_to_str (ptid));
 354
 355   /* We assume that we're already tracing the initial process.  */
 356   if (is_cloned (ptid) && ptrace (PTRACE_ATTACH, GET_LWP (ptid), 0, 0) < 0)
 357     error ("Can't attach %s: %s", target_pid_to_str (ptid), strerror (errno));
 358
 359   lp = find_lwp_pid (ptid);
 360   if (lp == NULL)
 361     lp = add_lwp (ptid);
 362
 363   if (is_cloned (ptid))
 364     {
 365       lp->signalled = 1;
 366       stop_wait_callback (lp, NULL);
 367     }
 368 }
 369
 370 static void
 371 lin_lwp_attach (char *args, int from_tty)
 372 {
 373   struct lwp_info *lp;
 374
 375   /* FIXME: We should probably accept a list of process id's, and
 376      attach all of them.  */
 377   child_ops.to_attach (args, from_tty);
 378
 379   /* Add the initial process as the first LWP to the list.  */
 380   lp = add_lwp (BUILD_LWP (PIDGET (inferior_ptid), PIDGET (inferior_ptid)));
 381
 382   /* Make sure the initial process is stopped.  The user-level threads
 383      layer might want to poke around in the inferior, and that won't
 384      work if things haven't stabilized yet.  */
 385   lp->signalled = 1;
 386   stop_wait_callback (lp, NULL);
 387   gdb_assert (lp->status == 0);
 388
 389   /* Fake the SIGSTOP that core GDB expects.  */
 390   lp->status = W_STOPCODE (SIGSTOP);
 391   lp->resumed = 1;
 392 }
 393
 394 static int
 395 detach_callback (struct lwp_info *lp, void *data)
 396 {
 397   gdb_assert (lp->status == 0 || WIFSTOPPED (lp->status));
 398
 399   if (debug_lin_lwp && lp->status)
 400     fprintf_unfiltered (gdb_stdlog, "Pending %s for LWP %ld on detach.\n",
 401                         strsignal (WSTOPSIG (lp->status)), GET_LWP (lp->ptid));
 402
 403   while (lp->signalled && lp->stopped)
 404     {
 405       if (ptrace (PTRACE_CONT, GET_LWP (lp->ptid), 0,
 406                   WSTOPSIG (lp->status)) < 0)
 407         error ("Can't continue %s: %s", target_pid_to_str (lp->ptid),
 408                strerror (errno));
 409
 410       lp->stopped = 0;
 411       lp->signalled = 0;
 412       lp->status = 0;
 413       stop_wait_callback (lp, NULL);
 414
 415       gdb_assert (lp->status == 0 || WIFSTOPPED (lp->status));
 416     }
 417
 418   if (is_cloned (lp->ptid))
 419     {
 420       if (ptrace (PTRACE_DETACH, GET_LWP (lp->ptid), 0,
 421                   WSTOPSIG (lp->status)) < 0)
 422         error ("Can't detach %s: %s", target_pid_to_str (lp->ptid),
 423                strerror (errno));
 424
 425       delete_lwp (lp->ptid);
 426     }
 427
 428   return 0;
 429 }
 430
 431 static void
 432 lin_lwp_detach (char *args, int from_tty)
 433 {
 434   iterate_over_lwps (detach_callback, NULL);
 435
 436   /* Only the initial (uncloned) process should be left right now.  */
 437   gdb_assert (num_lwps == 1);
 438
 439   trap_ptid = null_ptid;
 440
 441   /* Destroy LWP info; it's no longer valid.  */
 442   init_lwp_list ();
 443
 444   /* Restore the original signal mask.  */
 445   sigprocmask (SIG_SETMASK, &normal_mask, NULL);
 446   sigemptyset (&blocked_mask);
 447
 448   inferior_ptid = pid_to_ptid (GET_PID (inferior_ptid));
 449   child_ops.to_detach (args, from_tty);
 450 }
 451 \f
 452
 453 struct private_thread_info
 454 {
 455   int lwpid;
 456 };
 457
 458 /* Return non-zero if TP corresponds to the LWP specified by DATA
 459    (which is assumed to be a pointer to a `struct lwp_info'.  */
 460
 461 static int
 462 find_lwp_callback (struct thread_info *tp, void *data)
 463 {
 464   struct lwp_info *lp = data;
 465
 466   if (tp->private->lwpid == GET_LWP (lp->ptid))
 467     return 1;
 468
 469   return 0;
 470 }
 471
 472 /* Resume LP.  */
 473
 474 static int
 475 resume_callback (struct lwp_info *lp, void *data)
 476 {
 477   if (lp->stopped && lp->status == 0)
 478     {
 479       struct thread_info *tp;
 480
 481 #if 0
 482       /* FIXME: kettenis/2000-08-26: This should really be handled
 483          properly by core GDB.  */
 484
 485       tp = find_thread_pid (lp->ptid);
 486       if (tp == NULL)
 487         tp = iterate_over_threads (find_lwp_callback, lp);
 488       gdb_assert (tp);
 489
 490       /* If we were previously stepping the thread, and now continue
 491          the thread we must invalidate the stepping range.  However,
 492          if there is a step_resume breakpoint for this thread, we must
 493          preserve the stepping range to make it possible to continue
 494          stepping once we hit it.  */
 495       if (tp->step_range_end && tp->step_resume_breakpoint == NULL)
 496         {
 497           gdb_assert (lp->step);
 498           tp->step_range_start = tp->step_range_end = 0;
 499         }
 500 #endif
 501
 502       child_resume (pid_to_ptid (GET_LWP (lp->ptid)), 0, TARGET_SIGNAL_0);
 503       lp->stopped = 0;
 504       lp->step = 0;
 505     }
 506
 507   return 0;
 508 }
 509
 510 static int
 511 resume_clear_callback (struct lwp_info *lp, void *data)
 512 {
 513   lp->resumed = 0;
 514   return 0;
 515 }
 516
 517 static int
 518 resume_set_callback (struct lwp_info *lp, void *data)
 519 {
 520   lp->resumed = 1;
 521   return 0;
 522 }
 523
 524 static void
 525 lin_lwp_resume (ptid_t ptid, int step, enum target_signal signo)
 526 {
 527   struct lwp_info *lp;
 528   int resume_all;
 529
 530   /* Apparently the interpretation of PID is dependent on STEP: If
 531      STEP is non-zero, a specific PID means `step only this process
 532      id'.  But if STEP is zero, then PID means `continue *all*
 533      processes, but give the signal only to this one'.  */
 534   resume_all = (PIDGET (ptid) == -1) || !step;
 535
 536   if (resume_all)
 537     iterate_over_lwps (resume_set_callback, NULL);
 538   else
 539     iterate_over_lwps (resume_clear_callback, NULL);
 540
 541   /* If PID is -1, it's the current inferior that should be
 542      handled specially.  */
 543   if (PIDGET (ptid) == -1)
 544     ptid = inferior_ptid;
 545
 546   lp = find_lwp_pid (ptid);
 547   if (lp)
 548     {
 549       ptid = pid_to_ptid (GET_LWP (lp->ptid));
 550
 551       /* Remember if we're stepping.  */
 552       lp->step = step;
 553
 554       /* Mark this LWP as resumed.  */
 555       lp->resumed = 1;
 556
 557       /* If we have a pending wait status for this thread, there is no
 558          point in resuming the process.  */
 559       if (lp->status)
 560         {
 561           /* FIXME: What should we do if we are supposed to continue
 562              this thread with a signal?  */
 563           gdb_assert (signo == TARGET_SIGNAL_0);
 564           return;
 565         }
 566
 567       /* Mark LWP as not stopped to prevent it from being continued by
 568          resume_callback.  */
 569       lp->stopped = 0;
 570     }
 571
 572   if (resume_all)
 573     iterate_over_lwps (resume_callback, NULL);
 574
 575   child_resume (ptid, step, signo);
 576 }
 577 \f
 578
 579 /* Send a SIGSTOP to LP.  */
 580
 581 static int
 582 stop_callback (struct lwp_info *lp, void *data)
 583 {
 584   if (! lp->stopped && ! lp->signalled)
 585     {
 586       int ret;
 587
 588       ret = kill (GET_LWP (lp->ptid), SIGSTOP);
 589       gdb_assert (ret == 0);
 590
 591       lp->signalled = 1;
 592       gdb_assert (lp->status == 0);
 593     }
 594
 595   return 0;
 596 }
 597
 598 /* Wait until LP is stopped.  If DATA is non-null it is interpreted as
 599    a pointer to a set of signals to be flushed immediately.  */
 600
 601 static int
 602 stop_wait_callback (struct lwp_info *lp, void *data)
 603 {
 604   sigset_t *flush_mask = data;
 605
 606   if (! lp->stopped && lp->signalled)
 607     {
 608       pid_t pid;
 609       int status;
 610
 611       gdb_assert (lp->status == 0);
 612
 613       pid = waitpid (GET_LWP (lp->ptid), &status,
 614                      is_cloned (lp->ptid) ? __WCLONE : 0);
 615       if (pid == -1 && errno == ECHILD)
 616         /* OK, the proccess has disappeared.  We'll catch the actual
 617            exit event in lin_lwp_wait.  */
 618         return 0;
 619
 620       gdb_assert (pid == GET_LWP (lp->ptid));
 621
 622       if (WIFEXITED (status) || WIFSIGNALED (status))
 623         {
 624           gdb_assert (num_lwps > 1);
 625
 626           if (in_thread_list (lp->ptid))
 627             {
 628               /* Core GDB cannot deal with us deleting the current
 629                  thread.  */
 630               if (!ptid_equal (lp->ptid, inferior_ptid))
 631                 delete_thread (lp->ptid);
 632               printf_unfiltered ("[%s exited]\n",
 633                                  target_pid_to_str (lp->ptid));
 634             }
 635           if (debug_lin_lwp)
 636             fprintf_unfiltered (gdb_stdlog,
 637                                 "%s exited.\n", target_pid_to_str (lp->ptid));
 638
 639           delete_lwp (lp->ptid);
 640           return 0;
 641         }
 642
 643       gdb_assert (WIFSTOPPED (status));
 644
 645       /* Ignore any signals in FLUSH_MASK.  */
 646       if (flush_mask && sigismember (flush_mask, WSTOPSIG (status)))
 647         {
 648           ptrace (PTRACE_CONT, GET_LWP (lp->ptid), 0, 0);
 649           return stop_wait_callback (lp, flush_mask);
 650         }
 651
 652       if (WSTOPSIG (status) != SIGSTOP)
 653         {
 654           if (WSTOPSIG (status) == SIGTRAP)
 655             {
 656               /* If a LWP other than the LWP that we're reporting an
 657                  event for has hit a GDB breakpoint (as opposed to
 658                  some random trap signal), then just arrange for it to
 659                  hit it again later.  We don't keep the SIGTRAP status
 660                  and don't forward the SIGTRAP signal to the LWP.  We
 661                  will handle the current event, eventually we will
 662                  resume all LWPs, and this one will get its breakpoint
 663                  trap again.
 664
 665                  If we do not do this, then we run the risk that the
 666                  user will delete or disable the breakpoint, but the
 667                  thread will have already tripped on it.  */
 668
 669               /* Now resume this LWP and get the SIGSTOP event. */
 670               ptrace (PTRACE_CONT, GET_LWP (lp->ptid), 0, 0);
 671               if (debug_lin_lwp)
 672                 {
 673                   fprintf_unfiltered (gdb_stderr,
 674                                       "SWC: Candidate SIGTRAP event in %ld\n",
 675                                       GET_LWP (lp->ptid));
 676                 }
 677               /* Hold the SIGTRAP for handling by lin_lwp_wait. */
 678               stop_wait_callback (lp, data);
 679               /* If there's another event, throw it back into the queue. */
 680               if (lp->status)
 681                 kill (GET_LWP (lp->ptid), WSTOPSIG (lp->status));
 682               /* Save the sigtrap event. */
 683               lp->status = status;
 684               return 0;
 685             }
 686           else
 687             {
 688               /* The thread was stopped with a signal other than
 689                  SIGSTOP, and didn't accidentally trip a breakpoint. */
 690
 691               if (debug_lin_lwp)
 692                 {
 693                   fprintf_unfiltered (gdb_stderr,
 694                                       "SWC: Pending event %d in %ld\n",
 695                                       WSTOPSIG (status), GET_LWP (lp->ptid));
 696                 }
 697               /* Now resume this LWP and get the SIGSTOP event. */
 698               ptrace (PTRACE_CONT, GET_LWP (lp->ptid), 0, 0);
 699
 700               /* Hold this event/waitstatus while we check to see if
 701                  there are any more (we still want to get that SIGSTOP). */
 702               stop_wait_callback (lp, data);
 703               /* If the lp->status field is still empty, use it to hold
 704                  this event.  If not, then this event must be returned
 705                  to the event queue of the LWP.  */
 706               if (lp->status == 0)
 707                 lp->status = status;
 708               else
 709                 kill (GET_LWP (lp->ptid), WSTOPSIG (status));
 710               return 0;
 711             }
 712         }
 713       else
 714         {
 715           /* We caught the SIGSTOP that we intended to catch, so
 716              there's no SIGSTOP pending.  */
 717           lp->stopped = 1;
 718           lp->signalled = 0;
 719         }
 720     }
 721
 722   return 0;
 723 }
 724
 725 /* Return non-zero if LP has a wait status pending.  */
 726
 727 static int
 728 status_callback (struct lwp_info *lp, void *data)
 729 {
 730   /* Only report a pending wait status if we pretend that this has
 731      indeed been resumed.  */
 732   return (lp->status != 0 && lp->resumed);
 733 }
 734
 735 /* Return non-zero if LP isn't stopped.  */
 736
 737 static int
 738 running_callback (struct lwp_info *lp, void *data)
 739 {
 740   return (lp->stopped == 0);
 741 }
 742
 743 /* Count the LWP's that have had events.  */
 744
 745 static int
 746 count_events_callback (struct lwp_info *lp, void *data)
 747 {
 748   int *count = data;
 749
 750   gdb_assert (count != NULL);
 751
 752   /* Count only LWPs that have a SIGTRAP event pending.  */
 753   if (lp->status != 0
 754       && WIFSTOPPED (lp->status) && WSTOPSIG (lp->status) == SIGTRAP)
 755     (*count)++;
 756
 757   return 0;
 758 }
 759
 760 /* Select the LWP (if any) that is currently being single-stepped.  */
 761
 762 static int
 763 select_singlestep_lwp_callback (struct lwp_info *lp, void *data)
 764 {
 765   if (lp->step && lp->status != 0)
 766     return 1;
 767   else
 768     return 0;
 769 }
 770
 771 /* Select the Nth LWP that has had a SIGTRAP event.  */
 772
 773 static int
 774 select_event_lwp_callback (struct lwp_info *lp, void *data)
 775 {
 776   int *selector = data;
 777
 778   gdb_assert (selector != NULL);
 779
 780   /* Select only LWPs that have a SIGTRAP event pending. */
 781   if (lp->status != 0
 782       && WIFSTOPPED (lp->status) && WSTOPSIG (lp->status) == SIGTRAP)
 783     if ((*selector)-- == 0)
 784       return 1;
 785
 786   return 0;
 787 }
 788
 789 static int
 790 cancel_breakpoints_callback (struct lwp_info *lp, void *data)
 791 {
 792   struct lwp_info *event_lp = data;
 793
 794   /* Leave the LWP that has been elected to receive a SIGTRAP alone.  */
 795   if (lp == event_lp)
 796     return 0;
 797
 798   /* If a LWP other than the LWP that we're reporting an event for has
 799      hit a GDB breakpoint (as opposed to some random trap signal),
 800      then just arrange for it to hit it again later.  We don't keep
 801      the SIGTRAP status and don't forward the SIGTRAP signal to the
 802      LWP.  We will handle the current event, eventually we will resume
 803      all LWPs, and this one will get its breakpoint trap again.
 804
 805      If we do not do this, then we run the risk that the user will
 806      delete or disable the breakpoint, but the LWP will have already
 807      tripped on it.  */
 808
 809   if (lp->status != 0
 810       && WIFSTOPPED (lp->status) &&  WSTOPSIG (lp->status) == SIGTRAP
 811       && breakpoint_inserted_here_p (read_pc_pid (lp->ptid) -
 812                                      DECR_PC_AFTER_BREAK))
 813     {
 814       if (debug_lin_lwp)
 815         fprintf_unfiltered (gdb_stdlog,
 816                             "Push back breakpoint for LWP %ld\n",
 817                             GET_LWP (lp->ptid));
 818
 819       /* Back up the PC if necessary.  */
 820       if (DECR_PC_AFTER_BREAK)
 821         write_pc_pid (read_pc_pid (lp->ptid) - DECR_PC_AFTER_BREAK, lp->ptid);
 822
 823       /* Throw away the SIGTRAP.  */
 824       lp->status = 0;
 825     }
 826
 827   return 0;
 828 }
 829
 830 /* Select one LWP out of those that have events pending.  */
 831
 832 static void
 833 select_event_lwp (struct lwp_info **orig_lp, int *status)
 834 {
 835   int num_events = 0;
 836   int random_selector;
 837   struct lwp_info *event_lp;
 838
 839   /* Record the wait status for the origional LWP.  */
 840   (*orig_lp)->status = *status;
 841
 842   /* Give preference to any LWP that is being single-stepped.  */
 843   event_lp = iterate_over_lwps (select_singlestep_lwp_callback, NULL);
 844   if (event_lp != NULL)
 845     {
 846       if (debug_lin_lwp)
 847         fprintf_unfiltered (gdb_stdlog,
 848                             "Select single-step LWP %ld\n",
 849                             GET_LWP (event_lp->ptid));
 850     }
 851   else
 852     {
 853       /* No single-stepping LWP.  Select one at random, out of those
 854          which have had SIGTRAP events.  */
 855
 856       /* First see how many SIGTRAP events we have.  */
 857       iterate_over_lwps (count_events_callback, &num_events);
 858
 859       /* Now randomly pick a LWP out of those that have had a SIGTRAP.  */
 860       random_selector = (int)
 861         ((num_events * (double) rand ()) / (RAND_MAX + 1.0));
 862
 863       if (debug_lin_lwp && num_events > 1)
 864         fprintf_unfiltered (gdb_stdlog,
 865                             "Found %d SIGTRAP events, selecting #%d\n",
 866                             num_events, random_selector);
 867
 868       event_lp = iterate_over_lwps (select_event_lwp_callback,
 869                                     &random_selector);
 870     }
 871
 872   if (event_lp != NULL)
 873     {
 874       /* Switch the event LWP.  */
 875       *orig_lp = event_lp;
 876       *status  = event_lp->status;
 877     }
 878
 879   /* Flush the wait status for the event LWP.  */
 880   (*orig_lp)->status = 0;
 881 }
 882
 883 /* Return non-zero if LP has been resumed.  */
 884
 885 static int
 886 resumed_callback (struct lwp_info *lp, void *data)
 887 {
 888   return lp->resumed;
 889 }
 890
 891 static ptid_t
 892 lin_lwp_wait (ptid_t ptid, struct target_waitstatus *ourstatus)
 893 {
 894   struct lwp_info *lp = NULL;
 895   int options = 0;
 896   int status = 0;
 897   pid_t pid = PIDGET (ptid);
 898   sigset_t flush_mask;
 899
 900   sigemptyset (&flush_mask);
 901
 902   /* Make sure SIGCHLD is blocked.  */
 903   if (! sigismember (&blocked_mask, SIGCHLD))
 904     {
 905       sigaddset (&blocked_mask, SIGCHLD);
 906       sigprocmask (SIG_BLOCK, &blocked_mask, NULL);
 907     }
 908
 909  retry:
 910
 911   /* Make sure there is at least one thread that has been resumed.  */
 912   gdb_assert (iterate_over_lwps (resumed_callback, NULL));
 913
 914   /* First check if there is a LWP with a wait status pending.  */
 915   if (pid == -1)
 916     {
 917       /* Any LWP that's been resumed will do.  */
 918       lp = iterate_over_lwps (status_callback, NULL);
 919       if (lp)
 920         {
 921           status = lp->status;
 922           lp->status = 0;
 923
 924           if (debug_lin_lwp && status)
 925             fprintf_unfiltered (gdb_stdlog,
 926                                 "Using pending wait status %s for LWP %ld.\n",
 927                                 status_to_str (status), GET_LWP (lp->ptid));
 928         }
 929
 930       /* But if we don't fine one, we'll have to wait, and check both
 931          cloned and uncloned processes.  We start with the cloned
 932          processes.  */
 933       options = __WCLONE | WNOHANG;
 934     }
 935   else if (is_lwp (ptid))
 936     {
 937       if (debug_lin_lwp)
 938         fprintf_unfiltered (gdb_stdlog,
 939                             "Waiting for specific LWP %ld.\n",
 940                             GET_LWP (ptid));
 941
 942       /* We have a specific LWP to check.  */
 943       lp = find_lwp_pid (ptid);
 944       gdb_assert (lp);
 945       status = lp->status;
 946       lp->status = 0;
 947
 948       if (debug_lin_lwp && status)
 949         fprintf_unfiltered (gdb_stdlog,
 950                             "Using pending wait status %s for LWP %ld.\n",
 951                             status_to_str (status), GET_LWP (lp->ptid));
 952
 953       /* If we have to wait, take into account whether PID is a cloned
 954          process or not.  And we have to convert it to something that
 955          the layer beneath us can understand.  */
 956       options = is_cloned (lp->ptid) ? __WCLONE : 0;
 957       pid = GET_LWP (ptid);
 958     }
 959
 960   if (status && lp->signalled)
 961     {
 962       /* A pending SIGSTOP may interfere with the normal stream of
 963          events.  In a typical case where interference is a problem,
 964          we have a SIGSTOP signal pending for LWP A while
 965          single-stepping it, encounter an event in LWP B, and take the
 966          pending SIGSTOP while trying to stop LWP A.  After processing
 967          the event in LWP B, LWP A is continued, and we'll never see
 968          the SIGTRAP associated with the last time we were
 969          single-stepping LWP A.  */
 970
 971       /* Resume the thread.  It should halt immediately returning the
 972          pending SIGSTOP.  */
 973       child_resume (pid_to_ptid (GET_LWP (lp->ptid)), lp->step,
 974                     TARGET_SIGNAL_0);
 975       lp->stopped = 0;
 976       gdb_assert (lp->resumed);
 977
 978       /* This should catch the pending SIGSTOP.  */
 979       stop_wait_callback (lp, NULL);
 980     }
 981
 982   set_sigint_trap ();   /* Causes SIGINT to be passed on to the
 983                            attached process. */
 984   set_sigio_trap ();
 985
 986   while (status == 0)
 987     {
 988       pid_t lwpid;
 989
 990       lwpid = waitpid (pid, &status, options);
 991       if (lwpid > 0)
 992         {
 993           gdb_assert (pid == -1 || lwpid == pid);
 994
 995           lp = find_lwp_pid (pid_to_ptid (lwpid));
 996           if (! lp)
 997             {
 998               lp = add_lwp (BUILD_LWP (lwpid, GET_PID (inferior_ptid)));
 999               if (threaded)
1000                 {
1001                   gdb_assert (WIFSTOPPED (status)
1002                               && WSTOPSIG (status) == SIGSTOP);
1003                   lp->signalled = 1;
1004
1005                   if (! in_thread_list (inferior_ptid))
1006                     {
1007                       inferior_ptid = BUILD_LWP (GET_PID (inferior_ptid),
1008                                                  GET_PID (inferior_ptid));
1009                       add_thread (inferior_ptid);
1010                     }
1011
1012                   add_thread (lp->ptid);
1013                   printf_unfiltered ("[New %s]\n",
1014                                      target_pid_to_str (lp->ptid));
1015                 }
1016             }
1017
1018           /* Make sure we don't report a TARGET_WAITKIND_EXITED or
1019              TARGET_WAITKIND_SIGNALLED event if there are still LWP's
1020              left in the process.  */
1021           if ((WIFEXITED (status) || WIFSIGNALED (status)) && num_lwps > 1)
1022             {
1023               if (in_thread_list (lp->ptid))
1024                 {
1025                   /* Core GDB cannot deal with us deleting the current
1026                      thread.  */
1027                   if (! ptid_equal (lp->ptid, inferior_ptid))
1028                     delete_thread (lp->ptid);
1029                   printf_unfiltered ("[%s exited]\n",
1030                                      target_pid_to_str (lp->ptid));
1031                 }
1032               if (debug_lin_lwp)
1033                 fprintf_unfiltered (gdb_stdlog,
1034                                     "%s exited.\n",
1035                                     target_pid_to_str (lp->ptid));
1036
1037               delete_lwp (lp->ptid);
1038
1039               /* Make sure there is at least one thread running.  */
1040               gdb_assert (iterate_over_lwps (running_callback, NULL));
1041
1042               /* Discard the event.  */
1043               status = 0;
1044               continue;
1045             }
1046
1047           /* Make sure we don't report a SIGSTOP that we sent
1048              ourselves in an attempt to stop an LWP.  */
1049           if (lp->signalled && WIFSTOPPED (status)
1050               && WSTOPSIG (status) == SIGSTOP)
1051             {
1052               if (debug_lin_lwp)
1053                 fprintf_unfiltered (gdb_stdlog,
1054                                     "Delayed SIGSTOP caught for %s.\n",
1055                                     target_pid_to_str (lp->ptid));
1056
1057               /* This is a delayed SIGSTOP.  */
1058               lp->signalled = 0;
1059
1060               child_resume (pid_to_ptid (GET_LWP (lp->ptid)), lp->step,
1061                             TARGET_SIGNAL_0);
1062               lp->stopped = 0;
1063               gdb_assert (lp->resumed);
1064
1065               /* Discard the event.  */
1066               status = 0;
1067               continue;
1068             }
1069
1070           break;
1071         }
1072
1073       if (pid == -1)
1074         {
1075           /* Alternate between checking cloned and uncloned processes.  */
1076           options ^= __WCLONE;
1077
1078           /* And suspend every time we have checked both.  */
1079           if (options & __WCLONE)
1080             sigsuspend (&suspend_mask);
1081         }
1082
1083       /* We shouldn't end up here unless we want to try again.  */
1084       gdb_assert (status == 0);
1085     }
1086
1087   clear_sigio_trap ();
1088   clear_sigint_trap ();
1089
1090   gdb_assert (lp);
1091
1092   /* Don't report signals that GDB isn't interested in, such as
1093      signals that are neither printed nor stopped upon.  Stopping all
1094      threads can be a bit time-consuming so if we want decent
1095      performance with heavily multi-threaded programs, especially when
1096      they're using a high frequency timer, we'd better avoid it if we
1097      can.  */
1098
1099   if (WIFSTOPPED (status))
1100     {
1101       int signo = target_signal_from_host (WSTOPSIG (status));
1102
1103       if (signal_stop_state (signo) == 0
1104           && signal_print_state (signo) == 0
1105           && signal_pass_state (signo) == 1)
1106         {
1107           /* FIMXE: kettenis/2001-06-06: Should we resume all threads
1108              here?  It is not clear we should.  GDB may not expect
1109              other threads to run.  On the other hand, not resuming
1110              newly attached threads may cause an unwanted delay in
1111              getting them running.  */
1112           child_resume (pid_to_ptid (GET_LWP (lp->ptid)), lp->step, signo);
1113           lp->stopped = 0;
1114           status = 0;
1115           goto retry;
1116         }
1117
1118       if (signo == TARGET_SIGNAL_INT
1119           && signal_pass_state (signo) == 0)
1120         {
1121           /* If ^C/BREAK is typed at the tty/console, SIGINT gets
1122              forwarded to the entire process group, that is, all LWP's
1123              will receive it.  Since we only want to report it once,
1124              we try to flush it from all LWPs except this one.  */
1125           sigaddset (&flush_mask, SIGINT);
1126         }
1127     }
1128
1129   /* This LWP is stopped now.  */
1130   lp->stopped = 1;
1131
1132   if (debug_lin_lwp)
1133     fprintf_unfiltered (gdb_stdlog, "Candidate event %s in LWP %ld.\n",
1134                         status_to_str (status), GET_LWP (lp->ptid));
1135
1136   /* Now stop all other LWP's ...  */
1137   iterate_over_lwps (stop_callback, NULL);
1138
1139   /* ... and wait until all of them have reported back that they're no
1140      longer running.  */
1141   iterate_over_lwps (stop_wait_callback, &flush_mask);
1142
1143   /* If we're not waiting for a specific LWP, choose an event LWP from
1144      among those that have had events.  Giving equal priority to all
1145      LWPs that have had events helps prevent starvation.  */
1146   if (pid == -1)
1147     select_event_lwp (&lp, &status);
1148
1149   /* Now that we've selected our final event LWP, cancel any
1150      breakpoints in other LWPs that have hit a GDB breakpoint.  See
1151      the comment in cancel_breakpoints_callback to find out why.  */
1152   iterate_over_lwps (cancel_breakpoints_callback, lp);
1153
1154   /* If we're not running in "threaded" mode, we'll report the bare
1155      process id.  */
1156
1157   if (WIFSTOPPED (status) && WSTOPSIG (status) == SIGTRAP)
1158     {
1159       trap_ptid = (threaded ? lp->ptid : pid_to_ptid (GET_LWP (lp->ptid)));
1160       if (debug_lin_lwp)
1161         fprintf_unfiltered (gdb_stdlog,
1162                             "LLW: trap_ptid is %ld\n",
1163                             GET_LWP (trap_ptid));
1164     }
1165   else
1166     trap_ptid = null_ptid;
1167
1168   store_waitstatus (ourstatus, status);
1169   return (threaded ? lp->ptid : pid_to_ptid (GET_LWP (lp->ptid)));
1170 }
1171
1172 static int
1173 kill_callback (struct lwp_info *lp, void *data)
1174 {
1175   ptrace (PTRACE_KILL, GET_LWP (lp->ptid), 0, 0);
1176   return 0;
1177 }
1178
1179 static int
1180 kill_wait_callback (struct lwp_info *lp, void *data)
1181 {
1182   pid_t pid;
1183
1184   /* We must make sure that there are no pending events (delayed
1185      SIGSTOPs, pending SIGTRAPs, etc.) to make sure the current
1186      program doesn't interfere with any following debugging session.  */
1187
1188   /* For cloned processes we must check both with __WCLONE and
1189      without, since the exit status of a cloned process isn't reported
1190      with __WCLONE.  */
1191   if (is_cloned (lp->ptid))
1192     {
1193       do
1194         {
1195           pid = waitpid (GET_LWP (lp->ptid), NULL, __WCLONE);
1196         }
1197       while (pid == GET_LWP (lp->ptid));
1198
1199       gdb_assert (pid == -1 && errno == ECHILD);
1200     }
1201
1202   do
1203     {
1204       pid = waitpid (GET_LWP (lp->ptid), NULL, 0);
1205     }
1206   while (pid == GET_LWP (lp->ptid));
1207
1208   gdb_assert (pid == -1 && errno == ECHILD);
1209   return 0;
1210 }
1211
1212 static void
1213 lin_lwp_kill (void)
1214 {
1215   /* Kill all LWP's ...  */
1216   iterate_over_lwps (kill_callback, NULL);
1217
1218   /* ... and wait until we've flushed all events.  */
1219   iterate_over_lwps (kill_wait_callback, NULL);
1220
1221   target_mourn_inferior ();
1222 }
1223
1224 static void
1225 lin_lwp_create_inferior (char *exec_file, char *allargs, char **env)
1226 {
1227   child_ops.to_create_inferior (exec_file, allargs, env);
1228 }
1229
1230 static void
1231 lin_lwp_mourn_inferior (void)
1232 {
1233   trap_ptid = null_ptid;
1234
1235   /* Destroy LWP info; it's no longer valid.  */
1236   init_lwp_list ();
1237
1238   /* Restore the original signal mask.  */
1239   sigprocmask (SIG_SETMASK, &normal_mask, NULL);
1240   sigemptyset (&blocked_mask);
1241
1242   child_ops.to_mourn_inferior ();
1243 }
1244
1245 static void
1246 lin_lwp_fetch_registers (int regno)
1247 {
1248   struct cleanup *old_chain = save_inferior_ptid ();
1249
1250   if (is_lwp (inferior_ptid))
1251     inferior_ptid = pid_to_ptid (GET_LWP (inferior_ptid));
1252
1253   fetch_inferior_registers (regno);
1254
1255   do_cleanups (old_chain);
1256 }
1257
1258 static void
1259 lin_lwp_store_registers (int regno)
1260 {
1261   struct cleanup *old_chain = save_inferior_ptid ();
1262
1263   if (is_lwp (inferior_ptid))
1264     inferior_ptid = pid_to_ptid (GET_LWP (inferior_ptid));
1265
1266   store_inferior_registers (regno);
1267
1268   do_cleanups (old_chain);
1269 }
1270
1271 static int
1272 lin_lwp_xfer_memory (CORE_ADDR memaddr, char *myaddr, int len, int write,
1273                      struct mem_attrib *attrib,
1274                      struct target_ops *target)
1275 {
1276   struct cleanup *old_chain = save_inferior_ptid ();
1277   int xfer;
1278
1279   if (is_lwp (inferior_ptid))
1280     inferior_ptid = pid_to_ptid (GET_LWP (inferior_ptid));
1281
1282   xfer = child_xfer_memory (memaddr, myaddr, len, write, attrib, target);
1283
1284   do_cleanups (old_chain);
1285   return xfer;
1286 }
1287
1288 static int
1289 lin_lwp_thread_alive (ptid_t ptid)
1290 {
1291   gdb_assert (is_lwp (ptid));
1292
1293   errno = 0;
1294   ptrace (PTRACE_PEEKUSER, GET_LWP (ptid), 0, 0);
1295   if (errno)
1296     return 0;
1297
1298   return 1;
1299 }
1300
1301 static char *
1302 lin_lwp_pid_to_str (ptid_t ptid)
1303 {
1304   static char buf[64];
1305
1306   if (is_lwp (ptid))
1307     {
1308       snprintf (buf, sizeof (buf), "LWP %ld", GET_LWP (ptid));
1309       return buf;
1310     }
1311
1312   return normal_pid_to_str (ptid);
1313 }
1314
1315 static void
1316 init_lin_lwp_ops (void)
1317 {
1318 #if 0
1319   lin_lwp_ops.to_open = lin_lwp_open;
1320 #endif
1321   lin_lwp_ops.to_shortname = "lwp-layer";
1322   lin_lwp_ops.to_longname = "lwp-layer";
1323   lin_lwp_ops.to_doc = "Low level threads support (LWP layer)";
1324   lin_lwp_ops.to_attach = lin_lwp_attach;
1325   lin_lwp_ops.to_detach = lin_lwp_detach;
1326   lin_lwp_ops.to_resume = lin_lwp_resume;
1327   lin_lwp_ops.to_wait = lin_lwp_wait;
1328   lin_lwp_ops.to_fetch_registers = lin_lwp_fetch_registers;
1329   lin_lwp_ops.to_store_registers = lin_lwp_store_registers;
1330   lin_lwp_ops.to_xfer_memory = lin_lwp_xfer_memory;
1331   lin_lwp_ops.to_kill = lin_lwp_kill;
1332   lin_lwp_ops.to_create_inferior = lin_lwp_create_inferior;
1333   lin_lwp_ops.to_mourn_inferior = lin_lwp_mourn_inferior;
1334   lin_lwp_ops.to_thread_alive = lin_lwp_thread_alive;
1335   lin_lwp_ops.to_pid_to_str = lin_lwp_pid_to_str;
1336   lin_lwp_ops.to_stratum = thread_stratum;
1337   lin_lwp_ops.to_has_thread_control = tc_schedlock;
1338   lin_lwp_ops.to_magic = OPS_MAGIC;
1339 }
1340
1341 static void
1342 sigchld_handler (int signo)
1343 {
1344   /* Do nothing.  The only reason for this handler is that it allows
1345      us to use sigsuspend in lin_lwp_wait above to wait for the
1346      arrival of a SIGCHLD.  */
1347 }
1348
1349 void
1350 _initialize_lin_lwp (void)
1351 {
1352   struct sigaction action;
1353
1354   extern void thread_db_init (struct target_ops *);
1355
1356   init_lin_lwp_ops ();
1357   add_target (&lin_lwp_ops);
1358   thread_db_init (&lin_lwp_ops);
1359
1360   /* Save the original signal mask.  */
1361   sigprocmask (SIG_SETMASK, NULL, &normal_mask);
1362
1363   action.sa_handler = sigchld_handler;
1364   sigemptyset (&action.sa_mask);
1365   action.sa_flags = 0;
1366   sigaction (SIGCHLD, &action, NULL);
1367
1368   /* Make sure we don't block SIGCHLD during a sigsuspend.  */
1369   sigprocmask (SIG_SETMASK, NULL, &suspend_mask);
1370   sigdelset (&suspend_mask, SIGCHLD);
1371
1372   sigemptyset (&blocked_mask);
1373
1374   add_show_from_set (add_set_cmd ("lin-lwp", no_class, var_zinteger,
1375                                   (char *) &debug_lin_lwp,
1376                                   "Set debugging of linux lwp module.\n\
1377 Enables printf debugging output.\n",
1378                                       &setdebuglist),
1379                      &showdebuglist);
1380 }
1381 \f
1382
1383 /* FIXME: kettenis/2000-08-26: The stuff on this page is specific to
1384    the LinuxThreads library and therefore doesn't really belong here.  */
1385
1386 /* Read variable NAME in the target and return its value if found.
1387    Otherwise return zero.  It is assumed that the type of the variable
1388    is `int'.  */
1389
1390 static int
1391 get_signo (const char *name)
1392 {
1393   struct minimal_symbol *ms;
1394   int signo;
1395
1396   ms = lookup_minimal_symbol (name, NULL, NULL);
1397   if (ms == NULL)
1398     return 0;
1399
1400   if (target_read_memory (SYMBOL_VALUE_ADDRESS (ms), (char *) &signo,
1401                           sizeof (signo)) != 0)
1402     return 0;
1403
1404   return signo;
1405 }
1406
1407 /* Return the set of signals used by the threads library in *SET.  */
1408
1409 void
1410 lin_thread_get_thread_signals (sigset_t *set)
1411 {
1412   struct sigaction action;
1413   int restart, cancel;
1414
1415   sigemptyset (set);
1416
1417   restart = get_signo ("__pthread_sig_restart");
1418   if (restart == 0)
1419     return;
1420
1421   cancel = get_signo ("__pthread_sig_cancel");
1422   if (cancel == 0)
1423     return;
1424
1425   sigaddset (set, restart);
1426   sigaddset (set, cancel);
1427
1428   /* The LinuxThreads library makes terminating threads send a special
1429      "cancel" signal instead of SIGCHLD.  Make sure we catch those (to
1430      prevent them from terminating GDB itself, which is likely to be
1431      their default action) and treat them the same way as SIGCHLD.  */
1432
1433   action.sa_handler = sigchld_handler;
1434   sigemptyset (&action.sa_mask);
1435   action.sa_flags = 0;
1436   sigaction (cancel, &action, NULL);
1437
1438   /* We block the "cancel" signal throughout this code ...  */
1439   sigaddset (&blocked_mask, cancel);
1440   sigprocmask (SIG_BLOCK, &blocked_mask, NULL);
1441
1442   /* ... except during a sigsuspend.  */
1443   sigdelset (&suspend_mask, cancel);
1444 }