gdb/linux-nat.c

   1 /* GNU/Linux native-dependent code common to multiple platforms.
   2
   3    Copyright (C) 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010,
   4    2011 Free Software Foundation, Inc.
   5
   6    This file is part of GDB.
   7
   8    This program is free software; you can redistribute it and/or modify
   9    it under the terms of the GNU General Public License as published by
  10    the Free Software Foundation; either version 3 of the License, or
  11    (at your option) any later version.
  12
  13    This program is distributed in the hope that it will be useful,
  14    but WITHOUT ANY WARRANTY; without even the implied warranty of
  15    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16    GNU General Public License for more details.
  17
  18    You should have received a copy of the GNU General Public License
  19    along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
  20
  21 #include "defs.h"
  22 #include "inferior.h"
  23 #include "target.h"
  24 #include "gdb_string.h"
  25 #include "gdb_wait.h"
  26 #include "gdb_assert.h"
  27 #ifdef HAVE_TKILL_SYSCALL
  28 #include <unistd.h>
  29 #include <sys/syscall.h>
  30 #endif
  31 #include <sys/ptrace.h>
  32 #include "linux-nat.h"
  33 #include "linux-ptrace.h"
  34 #include "linux-fork.h"
  35 #include "gdbthread.h"
  36 #include "gdbcmd.h"
  37 #include "regcache.h"
  38 #include "regset.h"
  39 #include "inf-ptrace.h"
  40 #include "auxv.h"
  41 #include <sys/param.h>          /* for MAXPATHLEN */
  42 #include <sys/procfs.h>         /* for elf_gregset etc.  */
  43 #include "elf-bfd.h"            /* for elfcore_write_* */
  44 #include "gregset.h"            /* for gregset */
  45 #include "gdbcore.h"            /* for get_exec_file */
  46 #include <ctype.h>              /* for isdigit */
  47 #include "gdbthread.h"          /* for struct thread_info etc.  */
  48 #include "gdb_stat.h"           /* for struct stat */
  49 #include <fcntl.h>              /* for O_RDONLY */
  50 #include "inf-loop.h"
  51 #include "event-loop.h"
  52 #include "event-top.h"
  53 #include <pwd.h>
  54 #include <sys/types.h>
  55 #include "gdb_dirent.h"
  56 #include "xml-support.h"
  57 #include "terminal.h"
  58 #include <sys/vfs.h>
  59 #include "solib.h"
  60
  61 #ifndef SPUFS_MAGIC
  62 #define SPUFS_MAGIC 0x23c9b64e
  63 #endif
  64
  65 #ifdef HAVE_PERSONALITY
  66 # include <sys/personality.h>
  67 # if !HAVE_DECL_ADDR_NO_RANDOMIZE
  68 #  define ADDR_NO_RANDOMIZE 0x0040000
  69 # endif
  70 #endif /* HAVE_PERSONALITY */
  71
  72 /* This comment documents high-level logic of this file.
  73
  74 Waiting for events in sync mode
  75 ===============================
  76
  77 When waiting for an event in a specific thread, we just use waitpid, passing
  78 the specific pid, and not passing WNOHANG.
  79
  80 When waiting for an event in all threads, waitpid is not quite good.  Prior to
  81 version 2.4, Linux can either wait for event in main thread, or in secondary
  82 threads.  (2.4 has the __WALL flag).  So, if we use blocking waitpid, we might
  83 miss an event.  The solution is to use non-blocking waitpid, together with
  84 sigsuspend.  First, we use non-blocking waitpid to get an event in the main
  85 process, if any.  Second, we use non-blocking waitpid with the __WCLONED
  86 flag to check for events in cloned processes.  If nothing is found, we use
  87 sigsuspend to wait for SIGCHLD.  When SIGCHLD arrives, it means something
  88 happened to a child process -- and SIGCHLD will be delivered both for events
  89 in main debugged process and in cloned processes.  As soon as we know there's
  90 an event, we get back to calling nonblocking waitpid with and without
  91 __WCLONED.
  92
  93 Note that SIGCHLD should be blocked between waitpid and sigsuspend calls,
  94 so that we don't miss a signal.  If SIGCHLD arrives in between, when it's
  95 blocked, the signal becomes pending and sigsuspend immediately
  96 notices it and returns.
  97
  98 Waiting for events in async mode
  99 ================================
 100
 101 In async mode, GDB should always be ready to handle both user input
 102 and target events, so neither blocking waitpid nor sigsuspend are
 103 viable options.  Instead, we should asynchronously notify the GDB main
 104 event loop whenever there's an unprocessed event from the target.  We
 105 detect asynchronous target events by handling SIGCHLD signals.  To
 106 notify the event loop about target events, the self-pipe trick is used
 107 --- a pipe is registered as waitable event source in the event loop,
 108 the event loop select/poll's on the read end of this pipe (as well on
 109 other event sources, e.g., stdin), and the SIGCHLD handler writes a
 110 byte to this pipe.  This is more portable than relying on
 111 pselect/ppoll, since on kernels that lack those syscalls, libc
 112 emulates them with select/poll+sigprocmask, and that is racy
 113 (a.k.a. plain broken).
 114
 115 Obviously, if we fail to notify the event loop if there's a target
 116 event, it's bad.  OTOH, if we notify the event loop when there's no
 117 event from the target, linux_nat_wait will detect that there's no real
 118 event to report, and return event of type TARGET_WAITKIND_IGNORE.
 119 This is mostly harmless, but it will waste time and is better avoided.
 120
 121 The main design point is that every time GDB is outside linux-nat.c,
 122 we have a SIGCHLD handler installed that is called when something
 123 happens to the target and notifies the GDB event loop.  Whenever GDB
 124 core decides to handle the event, and calls into linux-nat.c, we
 125 process things as in sync mode, except that the we never block in
 126 sigsuspend.
 127
 128 While processing an event, we may end up momentarily blocked in
 129 waitpid calls.  Those waitpid calls, while blocking, are guarantied to
 130 return quickly.  E.g., in all-stop mode, before reporting to the core
 131 that an LWP hit a breakpoint, all LWPs are stopped by sending them
 132 SIGSTOP, and synchronously waiting for the SIGSTOP to be reported.
 133 Note that this is different from blocking indefinitely waiting for the
 134 next event --- here, we're already handling an event.
 135
 136 Use of signals
 137 ==============
 138
 139 We stop threads by sending a SIGSTOP.  The use of SIGSTOP instead of another
 140 signal is not entirely significant; we just need for a signal to be delivered,
 141 so that we can intercept it.  SIGSTOP's advantage is that it can not be
 142 blocked.  A disadvantage is that it is not a real-time signal, so it can only
 143 be queued once; we do not keep track of other sources of SIGSTOP.
 144
 145 Two other signals that can't be blocked are SIGCONT and SIGKILL.  But we can't
 146 use them, because they have special behavior when the signal is generated -
 147 not when it is delivered.  SIGCONT resumes the entire thread group and SIGKILL
 148 kills the entire thread group.
 149
 150 A delivered SIGSTOP would stop the entire thread group, not just the thread we
 151 tkill'd.  But we never let the SIGSTOP be delivered; we always intercept and
 152 cancel it (by PTRACE_CONT without passing SIGSTOP).
 153
 154 We could use a real-time signal instead.  This would solve those problems; we
 155 could use PTRACE_GETSIGINFO to locate the specific stop signals sent by GDB.
 156 But we would still have to have some support for SIGSTOP, since PTRACE_ATTACH
 157 generates it, and there are races with trying to find a signal that is not
 158 blocked.  */
 159
 160 #ifndef O_LARGEFILE
 161 #define O_LARGEFILE 0
 162 #endif
 163
 164 /* Unlike other extended result codes, WSTOPSIG (status) on
 165    PTRACE_O_TRACESYSGOOD syscall events doesn't return SIGTRAP, but
 166    instead SIGTRAP with bit 7 set.  */
 167 #define SYSCALL_SIGTRAP (SIGTRAP | 0x80)
 168
 169 /* The single-threaded native GNU/Linux target_ops.  We save a pointer for
 170    the use of the multi-threaded target.  */
 171 static struct target_ops *linux_ops;
 172 static struct target_ops linux_ops_saved;
 173
 174 /* The method to call, if any, when a new thread is attached.  */
 175 static void (*linux_nat_new_thread) (ptid_t);
 176
 177 /* The method to call, if any, when the siginfo object needs to be
 178    converted between the layout returned by ptrace, and the layout in
 179    the architecture of the inferior.  */
 180 static int (*linux_nat_siginfo_fixup) (struct siginfo *,
 181                                        gdb_byte *,
 182                                        int);
 183
 184 /* The saved to_xfer_partial method, inherited from inf-ptrace.c.
 185    Called by our to_xfer_partial.  */
 186 static LONGEST (*super_xfer_partial) (struct target_ops *,
 187                                       enum target_object,
 188                                       const char *, gdb_byte *,
 189                                       const gdb_byte *,
 190                                       ULONGEST, LONGEST);
 191
 192 static int debug_linux_nat;
 193 static void
 194 show_debug_linux_nat (struct ui_file *file, int from_tty,
 195                       struct cmd_list_element *c, const char *value)
 196 {
 197   fprintf_filtered (file, _("Debugging of GNU/Linux lwp module is %s.\n"),
 198                     value);
 199 }
 200
 201 static int disable_randomization = 1;
 202
 203 static void
 204 show_disable_randomization (struct ui_file *file, int from_tty,
 205                             struct cmd_list_element *c, const char *value)
 206 {
 207 #ifdef HAVE_PERSONALITY
 208   fprintf_filtered (file,
 209                     _("Disabling randomization of debuggee's "
 210                       "virtual address space is %s.\n"),
 211                     value);
 212 #else /* !HAVE_PERSONALITY */
 213   fputs_filtered (_("Disabling randomization of debuggee's "
 214                     "virtual address space is unsupported on\n"
 215                     "this platform.\n"), file);
 216 #endif /* !HAVE_PERSONALITY */
 217 }
 218
 219 static void
 220 set_disable_randomization (char *args, int from_tty,
 221                            struct cmd_list_element *c)
 222 {
 223 #ifndef HAVE_PERSONALITY
 224   error (_("Disabling randomization of debuggee's "
 225            "virtual address space is unsupported on\n"
 226            "this platform."));
 227 #endif /* !HAVE_PERSONALITY */
 228 }
 229
 230 struct simple_pid_list
 231 {
 232   int pid;
 233   int status;
 234   struct simple_pid_list *next;
 235 };
 236 struct simple_pid_list *stopped_pids;
 237
 238 /* This variable is a tri-state flag: -1 for unknown, 0 if PTRACE_O_TRACEFORK
 239    can not be used, 1 if it can.  */
 240
 241 static int linux_supports_tracefork_flag = -1;
 242
 243 /* This variable is a tri-state flag: -1 for unknown, 0 if
 244    PTRACE_O_TRACESYSGOOD can not be used, 1 if it can.  */
 245
 246 static int linux_supports_tracesysgood_flag = -1;
 247
 248 /* If we have PTRACE_O_TRACEFORK, this flag indicates whether we also have
 249    PTRACE_O_TRACEVFORKDONE.  */
 250
 251 static int linux_supports_tracevforkdone_flag = -1;
 252
 253 /* Async mode support.  */
 254
 255 /* Zero if the async mode, although enabled, is masked, which means
 256    linux_nat_wait should behave as if async mode was off.  */
 257 static int linux_nat_async_mask_value = 1;
 258
 259 /* Stores the current used ptrace() options.  */
 260 static int current_ptrace_options = 0;
 261
 262 /* The read/write ends of the pipe registered as waitable file in the
 263    event loop.  */
 264 static int linux_nat_event_pipe[2] = { -1, -1 };
 265
 266 /* Flush the event pipe.  */
 267
 268 static void
 269 async_file_flush (void)
 270 {
 271   int ret;
 272   char buf;
 273
 274   do
 275     {
 276       ret = read (linux_nat_event_pipe[0], &buf, 1);
 277     }
 278   while (ret >= 0 || (ret == -1 && errno == EINTR));
 279 }
 280
 281 /* Put something (anything, doesn't matter what, or how much) in event
 282    pipe, so that the select/poll in the event-loop realizes we have
 283    something to process.  */
 284
 285 static void
 286 async_file_mark (void)
 287 {
 288   int ret;
 289
 290   /* It doesn't really matter what the pipe contains, as long we end
 291      up with something in it.  Might as well flush the previous
 292      left-overs.  */
 293   async_file_flush ();
 294
 295   do
 296     {
 297       ret = write (linux_nat_event_pipe[1], "+", 1);
 298     }
 299   while (ret == -1 && errno == EINTR);
 300
 301   /* Ignore EAGAIN.  If the pipe is full, the event loop will already
 302      be awakened anyway.  */
 303 }
 304
 305 static void linux_nat_async (void (*callback)
 306                              (enum inferior_event_type event_type,
 307                               void *context),
 308                              void *context);
 309 static int linux_nat_async_mask (int mask);
 310 static int kill_lwp (int lwpid, int signo);
 311
 312 static int stop_callback (struct lwp_info *lp, void *data);
 313
 314 static void block_child_signals (sigset_t *prev_mask);
 315 static void restore_child_signals_mask (sigset_t *prev_mask);
 316
 317 struct lwp_info;
 318 static struct lwp_info *add_lwp (ptid_t ptid);
 319 static void purge_lwp_list (int pid);
 320 static struct lwp_info *find_lwp_pid (ptid_t ptid);
 321
 322 \f
 323 /* Trivial list manipulation functions to keep track of a list of
 324    new stopped processes.  */
 325 static void
 326 add_to_pid_list (struct simple_pid_list **listp, int pid, int status)
 327 {
 328   struct simple_pid_list *new_pid = xmalloc (sizeof (struct simple_pid_list));
 329
 330   new_pid->pid = pid;
 331   new_pid->status = status;
 332   new_pid->next = *listp;
 333   *listp = new_pid;
 334 }
 335
 336 static int
 337 pull_pid_from_list (struct simple_pid_list **listp, int pid, int *statusp)
 338 {
 339   struct simple_pid_list **p;
 340
 341   for (p = listp; *p != NULL; p = &(*p)->next)
 342     if ((*p)->pid == pid)
 343       {
 344         struct simple_pid_list *next = (*p)->next;
 345
 346         *statusp = (*p)->status;
 347         xfree (*p);
 348         *p = next;
 349         return 1;
 350       }
 351   return 0;
 352 }
 353
 354 static void
 355 linux_record_stopped_pid (int pid, int status)
 356 {
 357   add_to_pid_list (&stopped_pids, pid, status);
 358 }
 359
 360 \f
 361 /* A helper function for linux_test_for_tracefork, called after fork ().  */
 362
 363 static void
 364 linux_tracefork_child (void)
 365 {
 366   ptrace (PTRACE_TRACEME, 0, 0, 0);
 367   kill (getpid (), SIGSTOP);
 368   fork ();
 369   _exit (0);
 370 }
 371
 372 /* Wrapper function for waitpid which handles EINTR.  */
 373
 374 static int
 375 my_waitpid (int pid, int *statusp, int flags)
 376 {
 377   int ret;
 378
 379   do
 380     {
 381       ret = waitpid (pid, statusp, flags);
 382     }
 383   while (ret == -1 && errno == EINTR);
 384
 385   return ret;
 386 }
 387
 388 /* Determine if PTRACE_O_TRACEFORK can be used to follow fork events.
 389
 390    First, we try to enable fork tracing on ORIGINAL_PID.  If this fails,
 391    we know that the feature is not available.  This may change the tracing
 392    options for ORIGINAL_PID, but we'll be setting them shortly anyway.
 393
 394    However, if it succeeds, we don't know for sure that the feature is
 395    available; old versions of PTRACE_SETOPTIONS ignored unknown options.  We
 396    create a child process, attach to it, use PTRACE_SETOPTIONS to enable
 397    fork tracing, and let it fork.  If the process exits, we assume that we
 398    can't use TRACEFORK; if we get the fork notification, and we can extract
 399    the new child's PID, then we assume that we can.  */
 400
 401 static void
 402 linux_test_for_tracefork (int original_pid)
 403 {
 404   int child_pid, ret, status;
 405   long second_pid;
 406   sigset_t prev_mask;
 407
 408   /* We don't want those ptrace calls to be interrupted.  */
 409   block_child_signals (&prev_mask);
 410
 411   linux_supports_tracefork_flag = 0;
 412   linux_supports_tracevforkdone_flag = 0;
 413
 414   ret = ptrace (PTRACE_SETOPTIONS, original_pid, 0, PTRACE_O_TRACEFORK);
 415   if (ret != 0)
 416     {
 417       restore_child_signals_mask (&prev_mask);
 418       return;
 419     }
 420
 421   child_pid = fork ();
 422   if (child_pid == -1)
 423     perror_with_name (("fork"));
 424
 425   if (child_pid == 0)
 426     linux_tracefork_child ();
 427
 428   ret = my_waitpid (child_pid, &status, 0);
 429   if (ret == -1)
 430     perror_with_name (("waitpid"));
 431   else if (ret != child_pid)
 432     error (_("linux_test_for_tracefork: waitpid: unexpected result %d."), ret);
 433   if (! WIFSTOPPED (status))
 434     error (_("linux_test_for_tracefork: waitpid: unexpected status %d."),
 435            status);
 436
 437   ret = ptrace (PTRACE_SETOPTIONS, child_pid, 0, PTRACE_O_TRACEFORK);
 438   if (ret != 0)
 439     {
 440       ret = ptrace (PTRACE_KILL, child_pid, 0, 0);
 441       if (ret != 0)
 442         {
 443           warning (_("linux_test_for_tracefork: failed to kill child"));
 444           restore_child_signals_mask (&prev_mask);
 445           return;
 446         }
 447
 448       ret = my_waitpid (child_pid, &status, 0);
 449       if (ret != child_pid)
 450         warning (_("linux_test_for_tracefork: failed "
 451                    "to wait for killed child"));
 452       else if (!WIFSIGNALED (status))
 453         warning (_("linux_test_for_tracefork: unexpected "
 454                    "wait status 0x%x from killed child"), status);
 455
 456       restore_child_signals_mask (&prev_mask);
 457       return;
 458     }
 459
 460   /* Check whether PTRACE_O_TRACEVFORKDONE is available.  */
 461   ret = ptrace (PTRACE_SETOPTIONS, child_pid, 0,
 462                 PTRACE_O_TRACEFORK | PTRACE_O_TRACEVFORKDONE);
 463   linux_supports_tracevforkdone_flag = (ret == 0);
 464
 465   ret = ptrace (PTRACE_CONT, child_pid, 0, 0);
 466   if (ret != 0)
 467     warning (_("linux_test_for_tracefork: failed to resume child"));
 468
 469   ret = my_waitpid (child_pid, &status, 0);
 470
 471   if (ret == child_pid && WIFSTOPPED (status)
 472       && status >> 16 == PTRACE_EVENT_FORK)
 473     {
 474       second_pid = 0;
 475       ret = ptrace (PTRACE_GETEVENTMSG, child_pid, 0, &second_pid);
 476       if (ret == 0 && second_pid != 0)
 477         {
 478           int second_status;
 479
 480           linux_supports_tracefork_flag = 1;
 481           my_waitpid (second_pid, &second_status, 0);
 482           ret = ptrace (PTRACE_KILL, second_pid, 0, 0);
 483           if (ret != 0)
 484             warning (_("linux_test_for_tracefork: "
 485                        "failed to kill second child"));
 486           my_waitpid (second_pid, &status, 0);
 487         }
 488     }
 489   else
 490     warning (_("linux_test_for_tracefork: unexpected result from waitpid "
 491              "(%d, status 0x%x)"), ret, status);
 492
 493   ret = ptrace (PTRACE_KILL, child_pid, 0, 0);
 494   if (ret != 0)
 495     warning (_("linux_test_for_tracefork: failed to kill child"));
 496   my_waitpid (child_pid, &status, 0);
 497
 498   restore_child_signals_mask (&prev_mask);
 499 }
 500
 501 /* Determine if PTRACE_O_TRACESYSGOOD can be used to follow syscalls.
 502
 503    We try to enable syscall tracing on ORIGINAL_PID.  If this fails,
 504    we know that the feature is not available.  This may change the tracing
 505    options for ORIGINAL_PID, but we'll be setting them shortly anyway.  */
 506
 507 static void
 508 linux_test_for_tracesysgood (int original_pid)
 509 {
 510   int ret;
 511   sigset_t prev_mask;
 512
 513   /* We don't want those ptrace calls to be interrupted.  */
 514   block_child_signals (&prev_mask);
 515
 516   linux_supports_tracesysgood_flag = 0;
 517
 518   ret = ptrace (PTRACE_SETOPTIONS, original_pid, 0, PTRACE_O_TRACESYSGOOD);
 519   if (ret != 0)
 520     goto out;
 521
 522   linux_supports_tracesysgood_flag = 1;
 523 out:
 524   restore_child_signals_mask (&prev_mask);
 525 }
 526
 527 /* Determine wether we support PTRACE_O_TRACESYSGOOD option available.
 528    This function also sets linux_supports_tracesysgood_flag.  */
 529
 530 static int
 531 linux_supports_tracesysgood (int pid)
 532 {
 533   if (linux_supports_tracesysgood_flag == -1)
 534     linux_test_for_tracesysgood (pid);
 535   return linux_supports_tracesysgood_flag;
 536 }
 537
 538 /* Return non-zero iff we have tracefork functionality available.
 539    This function also sets linux_supports_tracefork_flag.  */
 540
 541 static int
 542 linux_supports_tracefork (int pid)
 543 {
 544   if (linux_supports_tracefork_flag == -1)
 545     linux_test_for_tracefork (pid);
 546   return linux_supports_tracefork_flag;
 547 }
 548
 549 static int
 550 linux_supports_tracevforkdone (int pid)
 551 {
 552   if (linux_supports_tracefork_flag == -1)
 553     linux_test_for_tracefork (pid);
 554   return linux_supports_tracevforkdone_flag;
 555 }
 556
 557 static void
 558 linux_enable_tracesysgood (ptid_t ptid)
 559 {
 560   int pid = ptid_get_lwp (ptid);
 561
 562   if (pid == 0)
 563     pid = ptid_get_pid (ptid);
 564
 565   if (linux_supports_tracesysgood (pid) == 0)
 566     return;
 567
 568   current_ptrace_options |= PTRACE_O_TRACESYSGOOD;
 569
 570   ptrace (PTRACE_SETOPTIONS, pid, 0, current_ptrace_options);
 571 }
 572
 573 \f
 574 void
 575 linux_enable_event_reporting (ptid_t ptid)
 576 {
 577   int pid = ptid_get_lwp (ptid);
 578
 579   if (pid == 0)
 580     pid = ptid_get_pid (ptid);
 581
 582   if (! linux_supports_tracefork (pid))
 583     return;
 584
 585   current_ptrace_options |= PTRACE_O_TRACEFORK | PTRACE_O_TRACEVFORK
 586     | PTRACE_O_TRACEEXEC | PTRACE_O_TRACECLONE;
 587
 588   if (linux_supports_tracevforkdone (pid))
 589     current_ptrace_options |= PTRACE_O_TRACEVFORKDONE;
 590
 591   /* Do not enable PTRACE_O_TRACEEXIT until GDB is more prepared to support
 592      read-only process state.  */
 593
 594   ptrace (PTRACE_SETOPTIONS, pid, 0, current_ptrace_options);
 595 }
 596
 597 static void
 598 linux_child_post_attach (int pid)
 599 {
 600   linux_enable_event_reporting (pid_to_ptid (pid));
 601   check_for_thread_db ();
 602   linux_enable_tracesysgood (pid_to_ptid (pid));
 603 }
 604
 605 static void
 606 linux_child_post_startup_inferior (ptid_t ptid)
 607 {
 608   linux_enable_event_reporting (ptid);
 609   check_for_thread_db ();
 610   linux_enable_tracesysgood (ptid);
 611 }
 612
 613 static int
 614 linux_child_follow_fork (struct target_ops *ops, int follow_child)
 615 {
 616   sigset_t prev_mask;
 617   int has_vforked;
 618   int parent_pid, child_pid;
 619
 620   block_child_signals (&prev_mask);
 621
 622   has_vforked = (inferior_thread ()->pending_follow.kind
 623                  == TARGET_WAITKIND_VFORKED);
 624   parent_pid = ptid_get_lwp (inferior_ptid);
 625   if (parent_pid == 0)
 626     parent_pid = ptid_get_pid (inferior_ptid);
 627   child_pid = PIDGET (inferior_thread ()->pending_follow.value.related_pid);
 628
 629   if (!detach_fork)
 630     linux_enable_event_reporting (pid_to_ptid (child_pid));
 631
 632   if (has_vforked
 633       && !non_stop /* Non-stop always resumes both branches.  */
 634       && (!target_is_async_p () || sync_execution)
 635       && !(follow_child || detach_fork || sched_multi))
 636     {
 637       /* The parent stays blocked inside the vfork syscall until the
 638          child execs or exits.  If we don't let the child run, then
 639          the parent stays blocked.  If we're telling the parent to run
 640          in the foreground, the user will not be able to ctrl-c to get
 641          back the terminal, effectively hanging the debug session.  */
 642       fprintf_filtered (gdb_stderr, _("\
 643 Can not resume the parent process over vfork in the foreground while\n\
 644 holding the child stopped.  Try \"set detach-on-fork\" or \
 645 \"set schedule-multiple\".\n"));
 646       /* FIXME output string > 80 columns.  */
 647       return 1;
 648     }
 649
 650   if (! follow_child)
 651     {
 652       struct lwp_info *child_lp = NULL;
 653
 654       /* We're already attached to the parent, by default.  */
 655
 656       /* Detach new forked process?  */
 657       if (detach_fork)
 658         {
 659           /* Before detaching from the child, remove all breakpoints
 660              from it.  If we forked, then this has already been taken
 661              care of by infrun.c.  If we vforked however, any
 662              breakpoint inserted in the parent is visible in the
 663              child, even those added while stopped in a vfork
 664              catchpoint.  This will remove the breakpoints from the
 665              parent also, but they'll be reinserted below.  */
 666           if (has_vforked)
 667             {
 668               /* keep breakpoints list in sync.  */
 669               remove_breakpoints_pid (GET_PID (inferior_ptid));
 670             }
 671
 672           if (info_verbose || debug_linux_nat)
 673             {
 674               target_terminal_ours ();
 675               fprintf_filtered (gdb_stdlog,
 676                                 "Detaching after fork from "
 677                                 "child process %d.\n",
 678                                 child_pid);
 679             }
 680
 681           ptrace (PTRACE_DETACH, child_pid, 0, 0);
 682         }
 683       else
 684         {
 685           struct inferior *parent_inf, *child_inf;
 686           struct cleanup *old_chain;
 687
 688           /* Add process to GDB's tables.  */
 689           child_inf = add_inferior (child_pid);
 690
 691           parent_inf = current_inferior ();
 692           child_inf->attach_flag = parent_inf->attach_flag;
 693           copy_terminal_info (child_inf, parent_inf);
 694
 695           old_chain = save_inferior_ptid ();
 696           save_current_program_space ();
 697
 698           inferior_ptid = ptid_build (child_pid, child_pid, 0);
 699           add_thread (inferior_ptid);
 700           child_lp = add_lwp (inferior_ptid);
 701           child_lp->stopped = 1;
 702           child_lp->resumed = 1;
 703
 704           /* If this is a vfork child, then the address-space is
 705              shared with the parent.  */
 706           if (has_vforked)
 707             {
 708               child_inf->pspace = parent_inf->pspace;
 709               child_inf->aspace = parent_inf->aspace;
 710
 711               /* The parent will be frozen until the child is done
 712                  with the shared region.  Keep track of the
 713                  parent.  */
 714               child_inf->vfork_parent = parent_inf;
 715               child_inf->pending_detach = 0;
 716               parent_inf->vfork_child = child_inf;
 717               parent_inf->pending_detach = 0;
 718             }
 719           else
 720             {
 721               child_inf->aspace = new_address_space ();
 722               child_inf->pspace = add_program_space (child_inf->aspace);
 723               child_inf->removable = 1;
 724               set_current_program_space (child_inf->pspace);
 725               clone_program_space (child_inf->pspace, parent_inf->pspace);
 726
 727               /* Let the shared library layer (solib-svr4) learn about
 728                  this new process, relocate the cloned exec, pull in
 729                  shared libraries, and install the solib event
 730                  breakpoint.  If a "cloned-VM" event was propagated
 731                  better throughout the core, this wouldn't be
 732                  required.  */
 733               solib_create_inferior_hook (0);
 734             }
 735
 736           /* Let the thread_db layer learn about this new process.  */
 737           check_for_thread_db ();
 738
 739           do_cleanups (old_chain);
 740         }
 741
 742       if (has_vforked)
 743         {
 744           struct lwp_info *lp;
 745           struct inferior *parent_inf;
 746
 747           parent_inf = current_inferior ();
 748
 749           /* If we detached from the child, then we have to be careful
 750              to not insert breakpoints in the parent until the child
 751              is done with the shared memory region.  However, if we're
 752              staying attached to the child, then we can and should
 753              insert breakpoints, so that we can debug it.  A
 754              subsequent child exec or exit is enough to know when does
 755              the child stops using the parent's address space.  */
 756           parent_inf->waiting_for_vfork_done = detach_fork;
 757           parent_inf->pspace->breakpoints_not_allowed = detach_fork;
 758
 759           lp = find_lwp_pid (pid_to_ptid (parent_pid));
 760           gdb_assert (linux_supports_tracefork_flag >= 0);
 761           if (linux_supports_tracevforkdone (0))
 762             {
 763               if (debug_linux_nat)
 764                 fprintf_unfiltered (gdb_stdlog,
 765                                     "LCFF: waiting for VFORK_DONE on %d\n",
 766                                     parent_pid);
 767
 768               lp->stopped = 1;
 769               lp->resumed = 1;
 770
 771               /* We'll handle the VFORK_DONE event like any other
 772                  event, in target_wait.  */
 773             }
 774           else
 775             {
 776               /* We can't insert breakpoints until the child has
 777                  finished with the shared memory region.  We need to
 778                  wait until that happens.  Ideal would be to just
 779                  call:
 780                  - ptrace (PTRACE_SYSCALL, parent_pid, 0, 0);
 781                  - waitpid (parent_pid, &status, __WALL);
 782                  However, most architectures can't handle a syscall
 783                  being traced on the way out if it wasn't traced on
 784                  the way in.
 785
 786                  We might also think to loop, continuing the child
 787                  until it exits or gets a SIGTRAP.  One problem is
 788                  that the child might call ptrace with PTRACE_TRACEME.
 789
 790                  There's no simple and reliable way to figure out when
 791                  the vforked child will be done with its copy of the
 792                  shared memory.  We could step it out of the syscall,
 793                  two instructions, let it go, and then single-step the
 794                  parent once.  When we have hardware single-step, this
 795                  would work; with software single-step it could still
 796                  be made to work but we'd have to be able to insert
 797                  single-step breakpoints in the child, and we'd have
 798                  to insert -just- the single-step breakpoint in the
 799                  parent.  Very awkward.
 800
 801                  In the end, the best we can do is to make sure it
 802                  runs for a little while.  Hopefully it will be out of
 803                  range of any breakpoints we reinsert.  Usually this
 804                  is only the single-step breakpoint at vfork's return
 805                  point.  */
 806
 807               if (debug_linux_nat)
 808                 fprintf_unfiltered (gdb_stdlog,
 809                                     "LCFF: no VFORK_DONE "
 810                                     "support, sleeping a bit\n");
 811
 812               usleep (10000);
 813
 814               /* Pretend we've seen a PTRACE_EVENT_VFORK_DONE event,
 815                  and leave it pending.  The next linux_nat_resume call
 816                  will notice a pending event, and bypasses actually
 817                  resuming the inferior.  */
 818               lp->status = 0;
 819               lp->waitstatus.kind = TARGET_WAITKIND_VFORK_DONE;
 820               lp->stopped = 0;
 821               lp->resumed = 1;
 822
 823               /* If we're in async mode, need to tell the event loop
 824                  there's something here to process.  */
 825               if (target_can_async_p ())
 826                 async_file_mark ();
 827             }
 828         }
 829     }
 830   else
 831     {
 832       struct inferior *parent_inf, *child_inf;
 833       struct lwp_info *lp;
 834       struct program_space *parent_pspace;
 835
 836       if (info_verbose || debug_linux_nat)
 837         {
 838           target_terminal_ours ();
 839           if (has_vforked)
 840             fprintf_filtered (gdb_stdlog,
 841                               _("Attaching after process %d "
 842                                 "vfork to child process %d.\n"),
 843                               parent_pid, child_pid);
 844           else
 845             fprintf_filtered (gdb_stdlog,
 846                               _("Attaching after process %d "
 847                                 "fork to child process %d.\n"),
 848                               parent_pid, child_pid);
 849         }
 850
 851       /* Add the new inferior first, so that the target_detach below
 852          doesn't unpush the target.  */
 853
 854       child_inf = add_inferior (child_pid);
 855
 856       parent_inf = current_inferior ();
 857       child_inf->attach_flag = parent_inf->attach_flag;
 858       copy_terminal_info (child_inf, parent_inf);
 859
 860       parent_pspace = parent_inf->pspace;
 861
 862       /* If we're vforking, we want to hold on to the parent until the
 863          child exits or execs.  At child exec or exit time we can
 864          remove the old breakpoints from the parent and detach or
 865          resume debugging it.  Otherwise, detach the parent now; we'll
 866          want to reuse it's program/address spaces, but we can't set
 867          them to the child before removing breakpoints from the
 868          parent, otherwise, the breakpoints module could decide to
 869          remove breakpoints from the wrong process (since they'd be
 870          assigned to the same address space).  */
 871
 872       if (has_vforked)
 873         {
 874           gdb_assert (child_inf->vfork_parent == NULL);
 875           gdb_assert (parent_inf->vfork_child == NULL);
 876           child_inf->vfork_parent = parent_inf;
 877           child_inf->pending_detach = 0;
 878           parent_inf->vfork_child = child_inf;
 879           parent_inf->pending_detach = detach_fork;
 880           parent_inf->waiting_for_vfork_done = 0;
 881         }
 882       else if (detach_fork)
 883         target_detach (NULL, 0);
 884
 885       /* Note that the detach above makes PARENT_INF dangling.  */
 886
 887       /* Add the child thread to the appropriate lists, and switch to
 888          this new thread, before cloning the program space, and
 889          informing the solib layer about this new process.  */
 890
 891       inferior_ptid = ptid_build (child_pid, child_pid, 0);
 892       add_thread (inferior_ptid);
 893       lp = add_lwp (inferior_ptid);
 894       lp->stopped = 1;
 895       lp->resumed = 1;
 896
 897       /* If this is a vfork child, then the address-space is shared
 898          with the parent.  If we detached from the parent, then we can
 899          reuse the parent's program/address spaces.  */
 900       if (has_vforked || detach_fork)
 901         {
 902           child_inf->pspace = parent_pspace;
 903           child_inf->aspace = child_inf->pspace->aspace;
 904         }
 905       else
 906         {
 907           child_inf->aspace = new_address_space ();
 908           child_inf->pspace = add_program_space (child_inf->aspace);
 909           child_inf->removable = 1;
 910           set_current_program_space (child_inf->pspace);
 911           clone_program_space (child_inf->pspace, parent_pspace);
 912
 913           /* Let the shared library layer (solib-svr4) learn about
 914              this new process, relocate the cloned exec, pull in
 915              shared libraries, and install the solib event breakpoint.
 916              If a "cloned-VM" event was propagated better throughout
 917              the core, this wouldn't be required.  */
 918           solib_create_inferior_hook (0);
 919         }
 920
 921       /* Let the thread_db layer learn about this new process.  */
 922       check_for_thread_db ();
 923     }
 924
 925   restore_child_signals_mask (&prev_mask);
 926   return 0;
 927 }
 928
 929 \f
 930 static int
 931 linux_child_insert_fork_catchpoint (int pid)
 932 {
 933   return !linux_supports_tracefork (pid);
 934 }
 935
 936 static int
 937 linux_child_remove_fork_catchpoint (int pid)
 938 {
 939   return 0;
 940 }
 941
 942 static int
 943 linux_child_insert_vfork_catchpoint (int pid)
 944 {
 945   return !linux_supports_tracefork (pid);
 946 }
 947
 948 static int
 949 linux_child_remove_vfork_catchpoint (int pid)
 950 {
 951   return 0;
 952 }
 953
 954 static int
 955 linux_child_insert_exec_catchpoint (int pid)
 956 {
 957   return !linux_supports_tracefork (pid);
 958 }
 959
 960 static int
 961 linux_child_remove_exec_catchpoint (int pid)
 962 {
 963   return 0;
 964 }
 965
 966 static int
 967 linux_child_set_syscall_catchpoint (int pid, int needed, int any_count,
 968                                     int table_size, int *table)
 969 {
 970   if (!linux_supports_tracesysgood (pid))
 971     return 1;
 972
 973   /* On GNU/Linux, we ignore the arguments.  It means that we only
 974      enable the syscall catchpoints, but do not disable them.
 975
 976      Also, we do not use the `table' information because we do not
 977      filter system calls here.  We let GDB do the logic for us.  */
 978   return 0;
 979 }
 980
 981 /* On GNU/Linux there are no real LWP's.  The closest thing to LWP's
 982    are processes sharing the same VM space.  A multi-threaded process
 983    is basically a group of such processes.  However, such a grouping
 984    is almost entirely a user-space issue; the kernel doesn't enforce
 985    such a grouping at all (this might change in the future).  In
 986    general, we'll rely on the threads library (i.e. the GNU/Linux
 987    Threads library) to provide such a grouping.
 988
 989    It is perfectly well possible to write a multi-threaded application
 990    without the assistance of a threads library, by using the clone
 991    system call directly.  This module should be able to give some
 992    rudimentary support for debugging such applications if developers
 993    specify the CLONE_PTRACE flag in the clone system call, and are
 994    using the Linux kernel 2.4 or above.
 995
 996    Note that there are some peculiarities in GNU/Linux that affect
 997    this code:
 998
 999    - In general one should specify the __WCLONE flag to waitpid in
1000      order to make it report events for any of the cloned processes
1001      (and leave it out for the initial process).  However, if a cloned
1002      process has exited the exit status is only reported if the
1003      __WCLONE flag is absent.  Linux kernel 2.4 has a __WALL flag, but
1004      we cannot use it since GDB must work on older systems too.
1005
1006    - When a traced, cloned process exits and is waited for by the
1007      debugger, the kernel reassigns it to the original parent and
1008      keeps it around as a "zombie".  Somehow, the GNU/Linux Threads
1009      library doesn't notice this, which leads to the "zombie problem":
1010      When debugged a multi-threaded process that spawns a lot of
1011      threads will run out of processes, even if the threads exit,
1012      because the "zombies" stay around.  */
1013
1014 /* List of known LWPs.  */
1015 struct lwp_info *lwp_list;
1016 \f
1017
1018 /* Original signal mask.  */
1019 static sigset_t normal_mask;
1020
1021 /* Signal mask for use with sigsuspend in linux_nat_wait, initialized in
1022    _initialize_linux_nat.  */
1023 static sigset_t suspend_mask;
1024
1025 /* Signals to block to make that sigsuspend work.  */
1026 static sigset_t blocked_mask;
1027
1028 /* SIGCHLD action.  */
1029 struct sigaction sigchld_action;
1030
1031 /* Block child signals (SIGCHLD and linux threads signals), and store
1032    the previous mask in PREV_MASK.  */
1033
1034 static void
1035 block_child_signals (sigset_t *prev_mask)
1036 {
1037   /* Make sure SIGCHLD is blocked.  */
1038   if (!sigismember (&blocked_mask, SIGCHLD))
1039     sigaddset (&blocked_mask, SIGCHLD);
1040
1041   sigprocmask (SIG_BLOCK, &blocked_mask, prev_mask);
1042 }
1043
1044 /* Restore child signals mask, previously returned by
1045    block_child_signals.  */
1046
1047 static void
1048 restore_child_signals_mask (sigset_t *prev_mask)
1049 {
1050   sigprocmask (SIG_SETMASK, prev_mask, NULL);
1051 }
1052
1053 /* Mask of signals to pass directly to the inferior.  */
1054 static sigset_t pass_mask;
1055
1056 /* Update signals to pass to the inferior.  */
1057 static void
1058 linux_nat_pass_signals (int numsigs, unsigned char *pass_signals)
1059 {
1060   int signo;
1061
1062   sigemptyset (&pass_mask);
1063
1064   for (signo = 1; signo < NSIG; signo++)
1065     {
1066       int target_signo = target_signal_from_host (signo);
1067       if (target_signo < numsigs && pass_signals[target_signo])
1068         sigaddset (&pass_mask, signo);
1069     }
1070 }
1071
1072 \f
1073
1074 /* Prototypes for local functions.  */
1075 static int stop_wait_callback (struct lwp_info *lp, void *data);
1076 static int linux_thread_alive (ptid_t ptid);
1077 static char *linux_child_pid_to_exec_file (int pid);
1078
1079 \f
1080 /* Convert wait status STATUS to a string.  Used for printing debug
1081    messages only.  */
1082
1083 static char *
1084 status_to_str (int status)
1085 {
1086   static char buf[64];
1087
1088   if (WIFSTOPPED (status))
1089     {
1090       if (WSTOPSIG (status) == SYSCALL_SIGTRAP)
1091         snprintf (buf, sizeof (buf), "%s (stopped at syscall)",
1092                   strsignal (SIGTRAP));
1093       else
1094         snprintf (buf, sizeof (buf), "%s (stopped)",
1095                   strsignal (WSTOPSIG (status)));
1096     }
1097   else if (WIFSIGNALED (status))
1098     snprintf (buf, sizeof (buf), "%s (terminated)",
1099               strsignal (WTERMSIG (status)));
1100   else
1101     snprintf (buf, sizeof (buf), "%d (exited)", WEXITSTATUS (status));
1102
1103   return buf;
1104 }
1105
1106 /* Remove all LWPs belong to PID from the lwp list.  */
1107
1108 static void
1109 purge_lwp_list (int pid)
1110 {
1111   struct lwp_info *lp, *lpprev, *lpnext;
1112
1113   lpprev = NULL;
1114
1115   for (lp = lwp_list; lp; lp = lpnext)
1116     {
1117       lpnext = lp->next;
1118
1119       if (ptid_get_pid (lp->ptid) == pid)
1120         {
1121           if (lp == lwp_list)
1122             lwp_list = lp->next;
1123           else
1124             lpprev->next = lp->next;
1125
1126           xfree (lp);
1127         }
1128       else
1129         lpprev = lp;
1130     }
1131 }
1132
1133 /* Return the number of known LWPs in the tgid given by PID.  */
1134
1135 static int
1136 num_lwps (int pid)
1137 {
1138   int count = 0;
1139   struct lwp_info *lp;
1140
1141   for (lp = lwp_list; lp; lp = lp->next)
1142     if (ptid_get_pid (lp->ptid) == pid)
1143       count++;
1144
1145   return count;
1146 }
1147
1148 /* Add the LWP specified by PID to the list.  Return a pointer to the
1149    structure describing the new LWP.  The LWP should already be stopped
1150    (with an exception for the very first LWP).  */
1151
1152 static struct lwp_info *
1153 add_lwp (ptid_t ptid)
1154 {
1155   struct lwp_info *lp;
1156
1157   gdb_assert (is_lwp (ptid));
1158
1159   lp = (struct lwp_info *) xmalloc (sizeof (struct lwp_info));
1160
1161   memset (lp, 0, sizeof (struct lwp_info));
1162
1163   lp->waitstatus.kind = TARGET_WAITKIND_IGNORE;
1164
1165   lp->ptid = ptid;
1166   lp->core = -1;
1167
1168   lp->next = lwp_list;
1169   lwp_list = lp;
1170
1171   if (num_lwps (GET_PID (ptid)) > 1 && linux_nat_new_thread != NULL)
1172     linux_nat_new_thread (ptid);
1173
1174   return lp;
1175 }
1176
1177 /* Remove the LWP specified by PID from the list.  */
1178
1179 static void
1180 delete_lwp (ptid_t ptid)
1181 {
1182   struct lwp_info *lp, *lpprev;
1183
1184   lpprev = NULL;
1185
1186   for (lp = lwp_list; lp; lpprev = lp, lp = lp->next)
1187     if (ptid_equal (lp->ptid, ptid))
1188       break;
1189
1190   if (!lp)
1191     return;
1192
1193   if (lpprev)
1194     lpprev->next = lp->next;
1195   else
1196     lwp_list = lp->next;
1197
1198   xfree (lp);
1199 }
1200
1201 /* Return a pointer to the structure describing the LWP corresponding
1202    to PID.  If no corresponding LWP could be found, return NULL.  */
1203
1204 static struct lwp_info *
1205 find_lwp_pid (ptid_t ptid)
1206 {
1207   struct lwp_info *lp;
1208   int lwp;
1209
1210   if (is_lwp (ptid))
1211     lwp = GET_LWP (ptid);
1212   else
1213     lwp = GET_PID (ptid);
1214
1215   for (lp = lwp_list; lp; lp = lp->next)
1216     if (lwp == GET_LWP (lp->ptid))
1217       return lp;
1218
1219   return NULL;
1220 }
1221
1222 /* Call CALLBACK with its second argument set to DATA for every LWP in
1223    the list.  If CALLBACK returns 1 for a particular LWP, return a
1224    pointer to the structure describing that LWP immediately.
1225    Otherwise return NULL.  */
1226
1227 struct lwp_info *
1228 iterate_over_lwps (ptid_t filter,
1229                    int (*callback) (struct lwp_info *, void *),
1230                    void *data)
1231 {
1232   struct lwp_info *lp, *lpnext;
1233
1234   for (lp = lwp_list; lp; lp = lpnext)
1235     {
1236       lpnext = lp->next;
1237
1238       if (ptid_match (lp->ptid, filter))
1239         {
1240           if ((*callback) (lp, data))
1241             return lp;
1242         }
1243     }
1244
1245   return NULL;
1246 }
1247
1248 /* Update our internal state when changing from one checkpoint to
1249    another indicated by NEW_PTID.  We can only switch single-threaded
1250    applications, so we only create one new LWP, and the previous list
1251    is discarded.  */
1252
1253 void
1254 linux_nat_switch_fork (ptid_t new_ptid)
1255 {
1256   struct lwp_info *lp;
1257
1258   purge_lwp_list (GET_PID (inferior_ptid));
1259
1260   lp = add_lwp (new_ptid);
1261   lp->stopped = 1;
1262
1263   /* This changes the thread's ptid while preserving the gdb thread
1264      num.  Also changes the inferior pid, while preserving the
1265      inferior num.  */
1266   thread_change_ptid (inferior_ptid, new_ptid);
1267
1268   /* We've just told GDB core that the thread changed target id, but,
1269      in fact, it really is a different thread, with different register
1270      contents.  */
1271   registers_changed ();
1272 }
1273
1274 /* Handle the exit of a single thread LP.  */
1275
1276 static void
1277 exit_lwp (struct lwp_info *lp)
1278 {
1279   struct thread_info *th = find_thread_ptid (lp->ptid);
1280
1281   if (th)
1282     {
1283       if (print_thread_events)
1284         printf_unfiltered (_("[%s exited]\n"), target_pid_to_str (lp->ptid));
1285
1286       delete_thread (lp->ptid);
1287     }
1288
1289   delete_lwp (lp->ptid);
1290 }
1291
1292 /* Return an lwp's tgid, found in `/proc/PID/status'.  */
1293
1294 int
1295 linux_proc_get_tgid (int lwpid)
1296 {
1297   FILE *status_file;
1298   char buf[100];
1299   int tgid = -1;
1300
1301   snprintf (buf, sizeof (buf), "/proc/%d/status", (int) lwpid);
1302   status_file = fopen (buf, "r");
1303   if (status_file != NULL)
1304     {
1305       while (fgets (buf, sizeof (buf), status_file))
1306         {
1307           if (strncmp (buf, "Tgid:", 5) == 0)
1308             {
1309               tgid = strtoul (buf + strlen ("Tgid:"), NULL, 10);
1310               break;
1311             }
1312         }
1313
1314       fclose (status_file);
1315     }
1316
1317   return tgid;
1318 }
1319
1320 /* Detect `T (stopped)' in `/proc/PID/status'.
1321    Other states including `T (tracing stop)' are reported as false.  */
1322
1323 static int
1324 pid_is_stopped (pid_t pid)
1325 {
1326   FILE *status_file;
1327   char buf[100];
1328   int retval = 0;
1329
1330   snprintf (buf, sizeof (buf), "/proc/%d/status", (int) pid);
1331   status_file = fopen (buf, "r");
1332   if (status_file != NULL)
1333     {
1334       int have_state = 0;
1335
1336       while (fgets (buf, sizeof (buf), status_file))
1337         {
1338           if (strncmp (buf, "State:", 6) == 0)
1339             {
1340               have_state = 1;
1341               break;
1342             }
1343         }
1344       if (have_state && strstr (buf, "T (stopped)") != NULL)
1345         retval = 1;
1346       fclose (status_file);
1347     }
1348   return retval;
1349 }
1350
1351 /* Wait for the LWP specified by LP, which we have just attached to.
1352    Returns a wait status for that LWP, to cache.  */
1353
1354 static int
1355 linux_nat_post_attach_wait (ptid_t ptid, int first, int *cloned,
1356                             int *signalled)
1357 {
1358   pid_t new_pid, pid = GET_LWP (ptid);
1359   int status;
1360
1361   if (pid_is_stopped (pid))
1362     {
1363       if (debug_linux_nat)
1364         fprintf_unfiltered (gdb_stdlog,
1365                             "LNPAW: Attaching to a stopped process\n");
1366
1367       /* The process is definitely stopped.  It is in a job control
1368          stop, unless the kernel predates the TASK_STOPPED /
1369          TASK_TRACED distinction, in which case it might be in a
1370          ptrace stop.  Make sure it is in a ptrace stop; from there we
1371          can kill it, signal it, et cetera.
1372
1373          First make sure there is a pending SIGSTOP.  Since we are
1374          already attached, the process can not transition from stopped
1375          to running without a PTRACE_CONT; so we know this signal will
1376          go into the queue.  The SIGSTOP generated by PTRACE_ATTACH is
1377          probably already in the queue (unless this kernel is old
1378          enough to use TASK_STOPPED for ptrace stops); but since SIGSTOP
1379          is not an RT signal, it can only be queued once.  */
1380       kill_lwp (pid, SIGSTOP);
1381
1382       /* Finally, resume the stopped process.  This will deliver the SIGSTOP
1383          (or a higher priority signal, just like normal PTRACE_ATTACH).  */
1384       ptrace (PTRACE_CONT, pid, 0, 0);
1385     }
1386
1387   /* Make sure the initial process is stopped.  The user-level threads
1388      layer might want to poke around in the inferior, and that won't
1389      work if things haven't stabilized yet.  */
1390   new_pid = my_waitpid (pid, &status, 0);
1391   if (new_pid == -1 && errno == ECHILD)
1392     {
1393       if (first)
1394         warning (_("%s is a cloned process"), target_pid_to_str (ptid));
1395
1396       /* Try again with __WCLONE to check cloned processes.  */
1397       new_pid = my_waitpid (pid, &status, __WCLONE);
1398       *cloned = 1;
1399     }
1400
1401   gdb_assert (pid == new_pid);
1402
1403   if (!WIFSTOPPED (status))
1404     {
1405       /* The pid we tried to attach has apparently just exited.  */
1406       if (debug_linux_nat)
1407         fprintf_unfiltered (gdb_stdlog, "LNPAW: Failed to stop %d: %s",
1408                             pid, status_to_str (status));
1409       return status;
1410     }
1411
1412   if (WSTOPSIG (status) != SIGSTOP)
1413     {
1414       *signalled = 1;
1415       if (debug_linux_nat)
1416         fprintf_unfiltered (gdb_stdlog,
1417                             "LNPAW: Received %s after attaching\n",
1418                             status_to_str (status));
1419     }
1420
1421   return status;
1422 }
1423
1424 /* Attach to the LWP specified by PID.  Return 0 if successful or -1
1425    if the new LWP could not be attached.  */
1426
1427 int
1428 lin_lwp_attach_lwp (ptid_t ptid)
1429 {
1430   struct lwp_info *lp;
1431   sigset_t prev_mask;
1432
1433   gdb_assert (is_lwp (ptid));
1434
1435   block_child_signals (&prev_mask);
1436
1437   lp = find_lwp_pid (ptid);
1438
1439   /* We assume that we're already attached to any LWP that has an id
1440      equal to the overall process id, and to any LWP that is already
1441      in our list of LWPs.  If we're not seeing exit events from threads
1442      and we've had PID wraparound since we last tried to stop all threads,
1443      this assumption might be wrong; fortunately, this is very unlikely
1444      to happen.  */
1445   if (GET_LWP (ptid) != GET_PID (ptid) && lp == NULL)
1446     {
1447       int status, cloned = 0, signalled = 0;
1448
1449       if (ptrace (PTRACE_ATTACH, GET_LWP (ptid), 0, 0) < 0)
1450         {
1451           /* If we fail to attach to the thread, issue a warning,
1452              but continue.  One way this can happen is if thread
1453              creation is interrupted; as of Linux kernel 2.6.19, a
1454              bug may place threads in the thread list and then fail
1455              to create them.  */
1456           warning (_("Can't attach %s: %s"), target_pid_to_str (ptid),
1457                    safe_strerror (errno));
1458           restore_child_signals_mask (&prev_mask);
1459           return -1;
1460         }
1461
1462       if (debug_linux_nat)
1463         fprintf_unfiltered (gdb_stdlog,
1464                             "LLAL: PTRACE_ATTACH %s, 0, 0 (OK)\n",
1465                             target_pid_to_str (ptid));
1466
1467       status = linux_nat_post_attach_wait (ptid, 0, &cloned, &signalled);
1468       if (!WIFSTOPPED (status))
1469         {
1470           restore_child_signals_mask (&prev_mask);
1471           return -1;
1472         }
1473
1474       lp = add_lwp (ptid);
1475       lp->stopped = 1;
1476       lp->cloned = cloned;
1477       lp->signalled = signalled;
1478       if (WSTOPSIG (status) != SIGSTOP)
1479         {
1480           lp->resumed = 1;
1481           lp->status = status;
1482         }
1483
1484       target_post_attach (GET_LWP (lp->ptid));
1485
1486       if (debug_linux_nat)
1487         {
1488           fprintf_unfiltered (gdb_stdlog,
1489                               "LLAL: waitpid %s received %s\n",
1490                               target_pid_to_str (ptid),
1491                               status_to_str (status));
1492         }
1493     }
1494   else
1495     {
1496       /* We assume that the LWP representing the original process is
1497          already stopped.  Mark it as stopped in the data structure
1498          that the GNU/linux ptrace layer uses to keep track of
1499          threads.  Note that this won't have already been done since
1500          the main thread will have, we assume, been stopped by an
1501          attach from a different layer.  */
1502       if (lp == NULL)
1503         lp = add_lwp (ptid);
1504       lp->stopped = 1;
1505     }
1506
1507   restore_child_signals_mask (&prev_mask);
1508   return 0;
1509 }
1510
1511 static void
1512 linux_nat_create_inferior (struct target_ops *ops,
1513                            char *exec_file, char *allargs, char **env,
1514                            int from_tty)
1515 {
1516 #ifdef HAVE_PERSONALITY
1517   int personality_orig = 0, personality_set = 0;
1518 #endif /* HAVE_PERSONALITY */
1519
1520   /* The fork_child mechanism is synchronous and calls target_wait, so
1521      we have to mask the async mode.  */
1522
1523 #ifdef HAVE_PERSONALITY
1524   if (disable_randomization)
1525     {
1526       errno = 0;
1527       personality_orig = personality (0xffffffff);
1528       if (errno == 0 && !(personality_orig & ADDR_NO_RANDOMIZE))
1529         {
1530           personality_set = 1;
1531           personality (personality_orig | ADDR_NO_RANDOMIZE);
1532         }
1533       if (errno != 0 || (personality_set
1534                          && !(personality (0xffffffff) & ADDR_NO_RANDOMIZE)))
1535         warning (_("Error disabling address space randomization: %s"),
1536                  safe_strerror (errno));
1537     }
1538 #endif /* HAVE_PERSONALITY */
1539
1540   /* Make sure we report all signals during startup.  */
1541   linux_nat_pass_signals (0, NULL);
1542
1543   linux_ops->to_create_inferior (ops, exec_file, allargs, env, from_tty);
1544
1545 #ifdef HAVE_PERSONALITY
1546   if (personality_set)
1547     {
1548       errno = 0;
1549       personality (personality_orig);
1550       if (errno != 0)
1551         warning (_("Error restoring address space randomization: %s"),
1552                  safe_strerror (errno));
1553     }
1554 #endif /* HAVE_PERSONALITY */
1555 }
1556
1557 static void
1558 linux_nat_attach (struct target_ops *ops, char *args, int from_tty)
1559 {
1560   struct lwp_info *lp;
1561   int status;
1562   ptid_t ptid;
1563
1564   /* Make sure we report all signals during attach.  */
1565   linux_nat_pass_signals (0, NULL);
1566
1567   linux_ops->to_attach (ops, args, from_tty);
1568
1569   /* The ptrace base target adds the main thread with (pid,0,0)
1570      format.  Decorate it with lwp info.  */
1571   ptid = BUILD_LWP (GET_PID (inferior_ptid), GET_PID (inferior_ptid));
1572   thread_change_ptid (inferior_ptid, ptid);
1573
1574   /* Add the initial process as the first LWP to the list.  */
1575   lp = add_lwp (ptid);
1576
1577   status = linux_nat_post_attach_wait (lp->ptid, 1, &lp->cloned,
1578                                        &lp->signalled);
1579   if (!WIFSTOPPED (status))
1580     {
1581       if (WIFEXITED (status))
1582         {
1583           int exit_code = WEXITSTATUS (status);
1584
1585           target_terminal_ours ();
1586           target_mourn_inferior ();
1587           if (exit_code == 0)
1588             error (_("Unable to attach: program exited normally."));
1589           else
1590             error (_("Unable to attach: program exited with code %d."),
1591                    exit_code);
1592         }
1593       else if (WIFSIGNALED (status))
1594         {
1595           enum target_signal signo;
1596
1597           target_terminal_ours ();
1598           target_mourn_inferior ();
1599
1600           signo = target_signal_from_host (WTERMSIG (status));
1601           error (_("Unable to attach: program terminated with signal "
1602                    "%s, %s."),
1603                  target_signal_to_name (signo),
1604                  target_signal_to_string (signo));
1605         }
1606
1607       internal_error (__FILE__, __LINE__,
1608                       _("unexpected status %d for PID %ld"),
1609                       status, (long) GET_LWP (ptid));
1610     }
1611
1612   lp->stopped = 1;
1613
1614   /* Save the wait status to report later.  */
1615   lp->resumed = 1;
1616   if (debug_linux_nat)
1617     fprintf_unfiltered (gdb_stdlog,
1618                         "LNA: waitpid %ld, saving status %s\n",
1619                         (long) GET_PID (lp->ptid), status_to_str (status));
1620
1621   lp->status = status;
1622
1623   if (target_can_async_p ())
1624     target_async (inferior_event_handler, 0);
1625 }
1626
1627 /* Get pending status of LP.  */
1628 static int
1629 get_pending_status (struct lwp_info *lp, int *status)
1630 {
1631   enum target_signal signo = TARGET_SIGNAL_0;
1632
1633   /* If we paused threads momentarily, we may have stored pending
1634      events in lp->status or lp->waitstatus (see stop_wait_callback),
1635      and GDB core hasn't seen any signal for those threads.
1636      Otherwise, the last signal reported to the core is found in the
1637      thread object's stop_signal.
1638
1639      There's a corner case that isn't handled here at present.  Only
1640      if the thread stopped with a TARGET_WAITKIND_STOPPED does
1641      stop_signal make sense as a real signal to pass to the inferior.
1642      Some catchpoint related events, like
1643      TARGET_WAITKIND_(V)FORK|EXEC|SYSCALL, have their stop_signal set
1644      to TARGET_SIGNAL_SIGTRAP when the catchpoint triggers.  But,
1645      those traps are debug API (ptrace in our case) related and
1646      induced; the inferior wouldn't see them if it wasn't being
1647      traced.  Hence, we should never pass them to the inferior, even
1648      when set to pass state.  Since this corner case isn't handled by
1649      infrun.c when proceeding with a signal, for consistency, neither
1650      do we handle it here (or elsewhere in the file we check for
1651      signal pass state).  Normally SIGTRAP isn't set to pass state, so
1652      this is really a corner case.  */
1653
1654   if (lp->waitstatus.kind != TARGET_WAITKIND_IGNORE)
1655     signo = TARGET_SIGNAL_0; /* a pending ptrace event, not a real signal.  */
1656   else if (lp->status)
1657     signo = target_signal_from_host (WSTOPSIG (lp->status));
1658   else if (non_stop && !is_executing (lp->ptid))
1659     {
1660       struct thread_info *tp = find_thread_ptid (lp->ptid);
1661
1662       signo = tp->suspend.stop_signal;
1663     }
1664   else if (!non_stop)
1665     {
1666       struct target_waitstatus last;
1667       ptid_t last_ptid;
1668
1669       get_last_target_status (&last_ptid, &last);
1670
1671       if (GET_LWP (lp->ptid) == GET_LWP (last_ptid))
1672         {
1673           struct thread_info *tp = find_thread_ptid (lp->ptid);
1674
1675           signo = tp->suspend.stop_signal;
1676         }
1677     }
1678
1679   *status = 0;
1680
1681   if (signo == TARGET_SIGNAL_0)
1682     {
1683       if (debug_linux_nat)
1684         fprintf_unfiltered (gdb_stdlog,
1685                             "GPT: lwp %s has no pending signal\n",
1686                             target_pid_to_str (lp->ptid));
1687     }
1688   else if (!signal_pass_state (signo))
1689     {
1690       if (debug_linux_nat)
1691         fprintf_unfiltered (gdb_stdlog,
1692                             "GPT: lwp %s had signal %s, "
1693                             "but it is in no pass state\n",
1694                             target_pid_to_str (lp->ptid),
1695                             target_signal_to_string (signo));
1696     }
1697   else
1698     {
1699       *status = W_STOPCODE (target_signal_to_host (signo));
1700
1701       if (debug_linux_nat)
1702         fprintf_unfiltered (gdb_stdlog,
1703                             "GPT: lwp %s has pending signal %s\n",
1704                             target_pid_to_str (lp->ptid),
1705                             target_signal_to_string (signo));
1706     }
1707
1708   return 0;
1709 }
1710
1711 static int
1712 detach_callback (struct lwp_info *lp, void *data)
1713 {
1714   gdb_assert (lp->status == 0 || WIFSTOPPED (lp->status));
1715
1716   if (debug_linux_nat && lp->status)
1717     fprintf_unfiltered (gdb_stdlog, "DC:  Pending %s for %s on detach.\n",
1718                         strsignal (WSTOPSIG (lp->status)),
1719                         target_pid_to_str (lp->ptid));
1720
1721   /* If there is a pending SIGSTOP, get rid of it.  */
1722   if (lp->signalled)
1723     {
1724       if (debug_linux_nat)
1725         fprintf_unfiltered (gdb_stdlog,
1726                             "DC: Sending SIGCONT to %s\n",
1727                             target_pid_to_str (lp->ptid));
1728
1729       kill_lwp (GET_LWP (lp->ptid), SIGCONT);
1730       lp->signalled = 0;
1731     }
1732
1733   /* We don't actually detach from the LWP that has an id equal to the
1734      overall process id just yet.  */
1735   if (GET_LWP (lp->ptid) != GET_PID (lp->ptid))
1736     {
1737       int status = 0;
1738
1739       /* Pass on any pending signal for this LWP.  */
1740       get_pending_status (lp, &status);
1741
1742       errno = 0;
1743       if (ptrace (PTRACE_DETACH, GET_LWP (lp->ptid), 0,
1744                   WSTOPSIG (status)) < 0)
1745         error (_("Can't detach %s: %s"), target_pid_to_str (lp->ptid),
1746                safe_strerror (errno));
1747
1748       if (debug_linux_nat)
1749         fprintf_unfiltered (gdb_stdlog,
1750                             "PTRACE_DETACH (%s, %s, 0) (OK)\n",
1751                             target_pid_to_str (lp->ptid),
1752                             strsignal (WSTOPSIG (status)));
1753
1754       delete_lwp (lp->ptid);
1755     }
1756
1757   return 0;
1758 }
1759
1760 static void
1761 linux_nat_detach (struct target_ops *ops, char *args, int from_tty)
1762 {
1763   int pid;
1764   int status;
1765   struct lwp_info *main_lwp;
1766
1767   pid = GET_PID (inferior_ptid);
1768
1769   if (target_can_async_p ())
1770     linux_nat_async (NULL, 0);
1771
1772   /* Stop all threads before detaching.  ptrace requires that the
1773      thread is stopped to sucessfully detach.  */
1774   iterate_over_lwps (pid_to_ptid (pid), stop_callback, NULL);
1775   /* ... and wait until all of them have reported back that
1776      they're no longer running.  */
1777   iterate_over_lwps (pid_to_ptid (pid), stop_wait_callback, NULL);
1778
1779   iterate_over_lwps (pid_to_ptid (pid), detach_callback, NULL);
1780
1781   /* Only the initial process should be left right now.  */
1782   gdb_assert (num_lwps (GET_PID (inferior_ptid)) == 1);
1783
1784   main_lwp = find_lwp_pid (pid_to_ptid (pid));
1785
1786   /* Pass on any pending signal for the last LWP.  */
1787   if ((args == NULL || *args == '\0')
1788       && get_pending_status (main_lwp, &status) != -1
1789       && WIFSTOPPED (status))
1790     {
1791       /* Put the signal number in ARGS so that inf_ptrace_detach will
1792          pass it along with PTRACE_DETACH.  */
1793       args = alloca (8);
1794       sprintf (args, "%d", (int) WSTOPSIG (status));
1795       if (debug_linux_nat)
1796         fprintf_unfiltered (gdb_stdlog,
1797                             "LND: Sending signal %s to %s\n",
1798                             args,
1799                             target_pid_to_str (main_lwp->ptid));
1800     }
1801
1802   delete_lwp (main_lwp->ptid);
1803
1804   if (forks_exist_p ())
1805     {
1806       /* Multi-fork case.  The current inferior_ptid is being detached
1807          from, but there are other viable forks to debug.  Detach from
1808          the current fork, and context-switch to the first
1809          available.  */
1810       linux_fork_detach (args, from_tty);
1811
1812       if (non_stop && target_can_async_p ())
1813         target_async (inferior_event_handler, 0);
1814     }
1815   else
1816     linux_ops->to_detach (ops, args, from_tty);
1817 }
1818
1819 /* Resume LP.  */
1820
1821 static int
1822 resume_callback (struct lwp_info *lp, void *data)
1823 {
1824   struct inferior *inf = find_inferior_pid (GET_PID (lp->ptid));
1825
1826   if (lp->stopped && inf->vfork_child != NULL)
1827     {
1828       if (debug_linux_nat)
1829         fprintf_unfiltered (gdb_stdlog,
1830                             "RC: Not resuming %s (vfork parent)\n",
1831                             target_pid_to_str (lp->ptid));
1832     }
1833   else if (lp->stopped && lp->status == 0)
1834     {
1835       if (debug_linux_nat)
1836         fprintf_unfiltered (gdb_stdlog,
1837                             "RC:  PTRACE_CONT %s, 0, 0 (resuming sibling)\n",
1838                             target_pid_to_str (lp->ptid));
1839
1840       linux_ops->to_resume (linux_ops,
1841                             pid_to_ptid (GET_LWP (lp->ptid)),
1842                             0, TARGET_SIGNAL_0);
1843       if (debug_linux_nat)
1844         fprintf_unfiltered (gdb_stdlog,
1845                             "RC:  PTRACE_CONT %s, 0, 0 (resume sibling)\n",
1846                             target_pid_to_str (lp->ptid));
1847       lp->stopped = 0;
1848       lp->step = 0;
1849       memset (&lp->siginfo, 0, sizeof (lp->siginfo));
1850       lp->stopped_by_watchpoint = 0;
1851     }
1852   else if (lp->stopped && debug_linux_nat)
1853     fprintf_unfiltered (gdb_stdlog,
1854                         "RC: Not resuming sibling %s (has pending)\n",
1855                         target_pid_to_str (lp->ptid));
1856   else if (debug_linux_nat)
1857     fprintf_unfiltered (gdb_stdlog,
1858                         "RC: Not resuming sibling %s (not stopped)\n",
1859                         target_pid_to_str (lp->ptid));
1860
1861   return 0;
1862 }
1863
1864 static int
1865 resume_clear_callback (struct lwp_info *lp, void *data)
1866 {
1867   lp->resumed = 0;
1868   return 0;
1869 }
1870
1871 static int
1872 resume_set_callback (struct lwp_info *lp, void *data)
1873 {
1874   lp->resumed = 1;
1875   return 0;
1876 }
1877
1878 static void
1879 linux_nat_resume (struct target_ops *ops,
1880                   ptid_t ptid, int step, enum target_signal signo)
1881 {
1882   sigset_t prev_mask;
1883   struct lwp_info *lp;
1884   int resume_many;
1885
1886   if (debug_linux_nat)
1887     fprintf_unfiltered (gdb_stdlog,
1888                         "LLR: Preparing to %s %s, %s, inferior_ptid %s\n",
1889                         step ? "step" : "resume",
1890                         target_pid_to_str (ptid),
1891                         (signo != TARGET_SIGNAL_0
1892                          ? strsignal (target_signal_to_host (signo)) : "0"),
1893                         target_pid_to_str (inferior_ptid));
1894
1895   block_child_signals (&prev_mask);
1896
1897   /* A specific PTID means `step only this process id'.  */
1898   resume_many = (ptid_equal (minus_one_ptid, ptid)
1899                  || ptid_is_pid (ptid));
1900
1901   /* Mark the lwps we're resuming as resumed.  */
1902   iterate_over_lwps (ptid, resume_set_callback, NULL);
1903
1904   /* See if it's the current inferior that should be handled
1905      specially.  */
1906   if (resume_many)
1907     lp = find_lwp_pid (inferior_ptid);
1908   else
1909     lp = find_lwp_pid (ptid);
1910   gdb_assert (lp != NULL);
1911
1912   /* Remember if we're stepping.  */
1913   lp->step = step;
1914
1915   /* If we have a pending wait status for this thread, there is no
1916      point in resuming the process.  But first make sure that
1917      linux_nat_wait won't preemptively handle the event - we
1918      should never take this short-circuit if we are going to
1919      leave LP running, since we have skipped resuming all the
1920      other threads.  This bit of code needs to be synchronized
1921      with linux_nat_wait.  */
1922
1923   if (lp->status && WIFSTOPPED (lp->status))
1924     {
1925       if (!lp->step
1926           && WSTOPSIG (lp->status)
1927           && sigismember (&pass_mask, WSTOPSIG (lp->status)))
1928         {
1929           if (debug_linux_nat)
1930             fprintf_unfiltered (gdb_stdlog,
1931                                 "LLR: Not short circuiting for ignored "
1932                                 "status 0x%x\n", lp->status);
1933
1934           /* FIXME: What should we do if we are supposed to continue
1935              this thread with a signal?  */
1936           gdb_assert (signo == TARGET_SIGNAL_0);
1937           signo = target_signal_from_host (WSTOPSIG (lp->status));
1938           lp->status = 0;
1939         }
1940     }
1941
1942   if (lp->status || lp->waitstatus.kind != TARGET_WAITKIND_IGNORE)
1943     {
1944       /* FIXME: What should we do if we are supposed to continue
1945          this thread with a signal?  */
1946       gdb_assert (signo == TARGET_SIGNAL_0);
1947
1948       if (debug_linux_nat)
1949         fprintf_unfiltered (gdb_stdlog,
1950                             "LLR: Short circuiting for status 0x%x\n",
1951                             lp->status);
1952
1953       restore_child_signals_mask (&prev_mask);
1954       if (target_can_async_p ())
1955         {
1956           target_async (inferior_event_handler, 0);
1957           /* Tell the event loop we have something to process.  */
1958           async_file_mark ();
1959         }
1960       return;
1961     }
1962
1963   /* Mark LWP as not stopped to prevent it from being continued by
1964      resume_callback.  */
1965   lp->stopped = 0;
1966
1967   if (resume_many)
1968     iterate_over_lwps (ptid, resume_callback, NULL);
1969
1970   /* Convert to something the lower layer understands.  */
1971   ptid = pid_to_ptid (GET_LWP (lp->ptid));
1972
1973   linux_ops->to_resume (linux_ops, ptid, step, signo);
1974   memset (&lp->siginfo, 0, sizeof (lp->siginfo));
1975   lp->stopped_by_watchpoint = 0;
1976
1977   if (debug_linux_nat)
1978     fprintf_unfiltered (gdb_stdlog,
1979                         "LLR: %s %s, %s (resume event thread)\n",
1980                         step ? "PTRACE_SINGLESTEP" : "PTRACE_CONT",
1981                         target_pid_to_str (ptid),
1982                         (signo != TARGET_SIGNAL_0
1983                          ? strsignal (target_signal_to_host (signo)) : "0"));
1984
1985   restore_child_signals_mask (&prev_mask);
1986   if (target_can_async_p ())
1987     target_async (inferior_event_handler, 0);
1988 }
1989
1990 /* Send a signal to an LWP.  */
1991
1992 static int
1993 kill_lwp (int lwpid, int signo)
1994 {
1995   /* Use tkill, if possible, in case we are using nptl threads.  If tkill
1996      fails, then we are not using nptl threads and we should be using kill.  */
1997
1998 #ifdef HAVE_TKILL_SYSCALL
1999   {
2000     static int tkill_failed;
2001
2002     if (!tkill_failed)
2003       {
2004         int ret;
2005
2006         errno = 0;
2007         ret = syscall (__NR_tkill, lwpid, signo);
2008         if (errno != ENOSYS)
2009           return ret;
2010         tkill_failed = 1;
2011       }
2012   }
2013 #endif
2014
2015   return kill (lwpid, signo);
2016 }
2017
2018 /* Handle a GNU/Linux syscall trap wait response.  If we see a syscall
2019    event, check if the core is interested in it: if not, ignore the
2020    event, and keep waiting; otherwise, we need to toggle the LWP's
2021    syscall entry/exit status, since the ptrace event itself doesn't
2022    indicate it, and report the trap to higher layers.  */
2023
2024 static int
2025 linux_handle_syscall_trap (struct lwp_info *lp, int stopping)
2026 {
2027   struct target_waitstatus *ourstatus = &lp->waitstatus;
2028   struct gdbarch *gdbarch = target_thread_architecture (lp->ptid);
2029   int syscall_number = (int) gdbarch_get_syscall_number (gdbarch, lp->ptid);
2030
2031   if (stopping)
2032     {
2033       /* If we're stopping threads, there's a SIGSTOP pending, which
2034          makes it so that the LWP reports an immediate syscall return,
2035          followed by the SIGSTOP.  Skip seeing that "return" using
2036          PTRACE_CONT directly, and let stop_wait_callback collect the
2037          SIGSTOP.  Later when the thread is resumed, a new syscall
2038          entry event.  If we didn't do this (and returned 0), we'd
2039          leave a syscall entry pending, and our caller, by using
2040          PTRACE_CONT to collect the SIGSTOP, skips the syscall return
2041          itself.  Later, when the user re-resumes this LWP, we'd see
2042          another syscall entry event and we'd mistake it for a return.
2043
2044          If stop_wait_callback didn't force the SIGSTOP out of the LWP
2045          (leaving immediately with LWP->signalled set, without issuing
2046          a PTRACE_CONT), it would still be problematic to leave this
2047          syscall enter pending, as later when the thread is resumed,
2048          it would then see the same syscall exit mentioned above,
2049          followed by the delayed SIGSTOP, while the syscall didn't
2050          actually get to execute.  It seems it would be even more
2051          confusing to the user.  */
2052
2053       if (debug_linux_nat)
2054         fprintf_unfiltered (gdb_stdlog,
2055                             "LHST: ignoring syscall %d "
2056                             "for LWP %ld (stopping threads), "
2057                             "resuming with PTRACE_CONT for SIGSTOP\n",
2058                             syscall_number,
2059                             GET_LWP (lp->ptid));
2060
2061       lp->syscall_state = TARGET_WAITKIND_IGNORE;
2062       ptrace (PTRACE_CONT, GET_LWP (lp->ptid), 0, 0);
2063       return 1;
2064     }
2065
2066   if (catch_syscall_enabled ())
2067     {
2068       /* Always update the entry/return state, even if this particular
2069          syscall isn't interesting to the core now.  In async mode,
2070          the user could install a new catchpoint for this syscall
2071          between syscall enter/return, and we'll need to know to
2072          report a syscall return if that happens.  */
2073       lp->syscall_state = (lp->syscall_state == TARGET_WAITKIND_SYSCALL_ENTRY
2074                            ? TARGET_WAITKIND_SYSCALL_RETURN
2075                            : TARGET_WAITKIND_SYSCALL_ENTRY);
2076
2077       if (catching_syscall_number (syscall_number))
2078         {
2079           /* Alright, an event to report.  */
2080           ourstatus->kind = lp->syscall_state;
2081           ourstatus->value.syscall_number = syscall_number;
2082
2083           if (debug_linux_nat)
2084             fprintf_unfiltered (gdb_stdlog,
2085                                 "LHST: stopping for %s of syscall %d"
2086                                 " for LWP %ld\n",
2087                                 lp->syscall_state
2088                                 == TARGET_WAITKIND_SYSCALL_ENTRY
2089                                 ? "entry" : "return",
2090                                 syscall_number,
2091                                 GET_LWP (lp->ptid));
2092           return 0;
2093         }
2094
2095       if (debug_linux_nat)
2096         fprintf_unfiltered (gdb_stdlog,
2097                             "LHST: ignoring %s of syscall %d "
2098                             "for LWP %ld\n",
2099                             lp->syscall_state == TARGET_WAITKIND_SYSCALL_ENTRY
2100                             ? "entry" : "return",
2101                             syscall_number,
2102                             GET_LWP (lp->ptid));
2103     }
2104   else
2105     {
2106       /* If we had been syscall tracing, and hence used PT_SYSCALL
2107          before on this LWP, it could happen that the user removes all
2108          syscall catchpoints before we get to process this event.
2109          There are two noteworthy issues here:
2110
2111          - When stopped at a syscall entry event, resuming with
2112            PT_STEP still resumes executing the syscall and reports a
2113            syscall return.
2114
2115          - Only PT_SYSCALL catches syscall enters.  If we last
2116            single-stepped this thread, then this event can't be a
2117            syscall enter.  If we last single-stepped this thread, this
2118            has to be a syscall exit.
2119
2120          The points above mean that the next resume, be it PT_STEP or
2121          PT_CONTINUE, can not trigger a syscall trace event.  */
2122       if (debug_linux_nat)
2123         fprintf_unfiltered (gdb_stdlog,
2124                             "LHST: caught syscall event "
2125                             "with no syscall catchpoints."
2126                             " %d for LWP %ld, ignoring\n",
2127                             syscall_number,
2128                             GET_LWP (lp->ptid));
2129       lp->syscall_state = TARGET_WAITKIND_IGNORE;
2130     }
2131
2132   /* The core isn't interested in this event.  For efficiency, avoid
2133      stopping all threads only to have the core resume them all again.
2134      Since we're not stopping threads, if we're still syscall tracing
2135      and not stepping, we can't use PTRACE_CONT here, as we'd miss any
2136      subsequent syscall.  Simply resume using the inf-ptrace layer,
2137      which knows when to use PT_SYSCALL or PT_CONTINUE.  */
2138
2139   /* Note that gdbarch_get_syscall_number may access registers, hence
2140      fill a regcache.  */
2141   registers_changed ();
2142   linux_ops->to_resume (linux_ops, pid_to_ptid (GET_LWP (lp->ptid)),
2143                         lp->step, TARGET_SIGNAL_0);
2144   return 1;
2145 }
2146
2147 /* Handle a GNU/Linux extended wait response.  If we see a clone
2148    event, we need to add the new LWP to our list (and not report the
2149    trap to higher layers).  This function returns non-zero if the
2150    event should be ignored and we should wait again.  If STOPPING is
2151    true, the new LWP remains stopped, otherwise it is continued.  */
2152
2153 static int
2154 linux_handle_extended_wait (struct lwp_info *lp, int status,
2155                             int stopping)
2156 {
2157   int pid = GET_LWP (lp->ptid);
2158   struct target_waitstatus *ourstatus = &lp->waitstatus;
2159   int event = status >> 16;
2160
2161   if (event == PTRACE_EVENT_FORK || event == PTRACE_EVENT_VFORK
2162       || event == PTRACE_EVENT_CLONE)
2163     {
2164       unsigned long new_pid;
2165       int ret;
2166
2167       ptrace (PTRACE_GETEVENTMSG, pid, 0, &new_pid);
2168
2169       /* If we haven't already seen the new PID stop, wait for it now.  */
2170       if (! pull_pid_from_list (&stopped_pids, new_pid, &status))
2171         {
2172           /* The new child has a pending SIGSTOP.  We can't affect it until it
2173              hits the SIGSTOP, but we're already attached.  */
2174           ret = my_waitpid (new_pid, &status,
2175                             (event == PTRACE_EVENT_CLONE) ? __WCLONE : 0);
2176           if (ret == -1)
2177             perror_with_name (_("waiting for new child"));
2178           else if (ret != new_pid)
2179             internal_error (__FILE__, __LINE__,
2180                             _("wait returned unexpected PID %d"), ret);
2181           else if (!WIFSTOPPED (status))
2182             internal_error (__FILE__, __LINE__,
2183                             _("wait returned unexpected status 0x%x"), status);
2184         }
2185
2186       ourstatus->value.related_pid = ptid_build (new_pid, new_pid, 0);
2187
2188       if (event == PTRACE_EVENT_FORK
2189           && linux_fork_checkpointing_p (GET_PID (lp->ptid)))
2190         {
2191           /* Handle checkpointing by linux-fork.c here as a special
2192              case.  We don't want the follow-fork-mode or 'catch fork'
2193              to interfere with this.  */
2194
2195           /* This won't actually modify the breakpoint list, but will
2196              physically remove the breakpoints from the child.  */
2197           detach_breakpoints (new_pid);
2198
2199           /* Retain child fork in ptrace (stopped) state.  */
2200           if (!find_fork_pid (new_pid))
2201             add_fork (new_pid);
2202
2203           /* Report as spurious, so that infrun doesn't want to follow
2204              this fork.  We're actually doing an infcall in
2205              linux-fork.c.  */
2206           ourstatus->kind = TARGET_WAITKIND_SPURIOUS;
2207           linux_enable_event_reporting (pid_to_ptid (new_pid));
2208
2209           /* Report the stop to the core.  */
2210           return 0;
2211         }
2212
2213       if (event == PTRACE_EVENT_FORK)
2214         ourstatus->kind = TARGET_WAITKIND_FORKED;
2215       else if (event == PTRACE_EVENT_VFORK)
2216         ourstatus->kind = TARGET_WAITKIND_VFORKED;
2217       else
2218         {
2219           struct lwp_info *new_lp;
2220
2221           ourstatus->kind = TARGET_WAITKIND_IGNORE;
2222
2223           new_lp = add_lwp (BUILD_LWP (new_pid, GET_PID (lp->ptid)));
2224           new_lp->cloned = 1;
2225           new_lp->stopped = 1;
2226
2227           if (WSTOPSIG (status) != SIGSTOP)
2228             {
2229               /* This can happen if someone starts sending signals to
2230                  the new thread before it gets a chance to run, which
2231                  have a lower number than SIGSTOP (e.g. SIGUSR1).
2232                  This is an unlikely case, and harder to handle for
2233                  fork / vfork than for clone, so we do not try - but
2234                  we handle it for clone events here.  We'll send
2235                  the other signal on to the thread below.  */
2236
2237               new_lp->signalled = 1;
2238             }
2239           else
2240             status = 0;
2241
2242           if (non_stop)
2243             {
2244               /* Add the new thread to GDB's lists as soon as possible
2245                  so that:
2246
2247                  1) the frontend doesn't have to wait for a stop to
2248                  display them, and,
2249
2250                  2) we tag it with the correct running state.  */
2251
2252               /* If the thread_db layer is active, let it know about
2253                  this new thread, and add it to GDB's list.  */
2254               if (!thread_db_attach_lwp (new_lp->ptid))
2255                 {
2256                   /* We're not using thread_db.  Add it to GDB's
2257                      list.  */
2258                   target_post_attach (GET_LWP (new_lp->ptid));
2259                   add_thread (new_lp->ptid);
2260                 }
2261
2262               if (!stopping)
2263                 {
2264                   set_running (new_lp->ptid, 1);
2265                   set_executing (new_lp->ptid, 1);
2266                 }
2267             }
2268
2269           /* Note the need to use the low target ops to resume, to
2270              handle resuming with PT_SYSCALL if we have syscall
2271              catchpoints.  */
2272           if (!stopping)
2273             {
2274               enum target_signal signo;
2275
2276               new_lp->stopped = 0;
2277               new_lp->resumed = 1;
2278
2279               signo = (status
2280                        ? target_signal_from_host (WSTOPSIG (status))
2281                        : TARGET_SIGNAL_0);
2282
2283               linux_ops->to_resume (linux_ops, pid_to_ptid (new_pid),
2284                                     0, signo);
2285             }
2286           else
2287             {
2288               if (status != 0)
2289                 {
2290                   /* We created NEW_LP so it cannot yet contain STATUS.  */
2291                   gdb_assert (new_lp->status == 0);
2292
2293                   /* Save the wait status to report later.  */
2294                   if (debug_linux_nat)
2295                     fprintf_unfiltered (gdb_stdlog,
2296                                         "LHEW: waitpid of new LWP %ld, "
2297                                         "saving status %s\n",
2298                                         (long) GET_LWP (new_lp->ptid),
2299                                         status_to_str (status));
2300                   new_lp->status = status;
2301                 }
2302             }
2303
2304           if (debug_linux_nat)
2305             fprintf_unfiltered (gdb_stdlog,
2306                                 "LHEW: Got clone event "
2307                                 "from LWP %ld, resuming\n",
2308                                 GET_LWP (lp->ptid));
2309           linux_ops->to_resume (linux_ops, pid_to_ptid (GET_LWP (lp->ptid)),
2310                                 0, TARGET_SIGNAL_0);
2311
2312           return 1;
2313         }
2314
2315       return 0;
2316     }
2317
2318   if (event == PTRACE_EVENT_EXEC)
2319     {
2320       if (debug_linux_nat)
2321         fprintf_unfiltered (gdb_stdlog,
2322                             "LHEW: Got exec event from LWP %ld\n",
2323                             GET_LWP (lp->ptid));
2324
2325       ourstatus->kind = TARGET_WAITKIND_EXECD;
2326       ourstatus->value.execd_pathname
2327         = xstrdup (linux_child_pid_to_exec_file (pid));
2328
2329       return 0;
2330     }
2331
2332   if (event == PTRACE_EVENT_VFORK_DONE)
2333     {
2334       if (current_inferior ()->waiting_for_vfork_done)
2335         {
2336           if (debug_linux_nat)
2337             fprintf_unfiltered (gdb_stdlog,
2338                                 "LHEW: Got expected PTRACE_EVENT_"
2339                                 "VFORK_DONE from LWP %ld: stopping\n",
2340                                 GET_LWP (lp->ptid));
2341
2342           ourstatus->kind = TARGET_WAITKIND_VFORK_DONE;
2343           return 0;
2344         }
2345
2346       if (debug_linux_nat)
2347         fprintf_unfiltered (gdb_stdlog,
2348                             "LHEW: Got PTRACE_EVENT_VFORK_DONE "
2349                             "from LWP %ld: resuming\n",
2350                             GET_LWP (lp->ptid));
2351       ptrace (PTRACE_CONT, GET_LWP (lp->ptid), 0, 0);
2352       return 1;
2353     }
2354
2355   internal_error (__FILE__, __LINE__,
2356                   _("unknown ptrace event %d"), event);
2357 }
2358
2359 /* Wait for LP to stop.  Returns the wait status, or 0 if the LWP has
2360    exited.  */
2361
2362 static int
2363 wait_lwp (struct lwp_info *lp)
2364 {
2365   pid_t pid;
2366   int status;
2367   int thread_dead = 0;
2368
2369   gdb_assert (!lp->stopped);
2370   gdb_assert (lp->status == 0);
2371
2372   pid = my_waitpid (GET_LWP (lp->ptid), &status, 0);
2373   if (pid == -1 && errno == ECHILD)
2374     {
2375       pid = my_waitpid (GET_LWP (lp->ptid), &status, __WCLONE);
2376       if (pid == -1 && errno == ECHILD)
2377         {
2378           /* The thread has previously exited.  We need to delete it
2379              now because, for some vendor 2.4 kernels with NPTL
2380              support backported, there won't be an exit event unless
2381              it is the main thread.  2.6 kernels will report an exit
2382              event for each thread that exits, as expected.  */
2383           thread_dead = 1;
2384           if (debug_linux_nat)
2385             fprintf_unfiltered (gdb_stdlog, "WL: %s vanished.\n",
2386                                 target_pid_to_str (lp->ptid));
2387         }
2388     }
2389
2390   if (!thread_dead)
2391     {
2392       gdb_assert (pid == GET_LWP (lp->ptid));
2393
2394       if (debug_linux_nat)
2395         {
2396           fprintf_unfiltered (gdb_stdlog,
2397                               "WL: waitpid %s received %s\n",
2398                               target_pid_to_str (lp->ptid),
2399                               status_to_str (status));
2400         }
2401     }
2402
2403   /* Check if the thread has exited.  */
2404   if (WIFEXITED (status) || WIFSIGNALED (status))
2405     {
2406       thread_dead = 1;
2407       if (debug_linux_nat)
2408         fprintf_unfiltered (gdb_stdlog, "WL: %s exited.\n",
2409                             target_pid_to_str (lp->ptid));
2410     }
2411
2412   if (thread_dead)
2413     {
2414       exit_lwp (lp);
2415       return 0;
2416     }
2417
2418   gdb_assert (WIFSTOPPED (status));
2419
2420   /* Handle GNU/Linux's syscall SIGTRAPs.  */
2421   if (WIFSTOPPED (status) && WSTOPSIG (status) == SYSCALL_SIGTRAP)
2422     {
2423       /* No longer need the sysgood bit.  The ptrace event ends up
2424          recorded in lp->waitstatus if we care for it.  We can carry
2425          on handling the event like a regular SIGTRAP from here
2426          on.  */
2427       status = W_STOPCODE (SIGTRAP);
2428       if (linux_handle_syscall_trap (lp, 1))
2429         return wait_lwp (lp);
2430     }
2431
2432   /* Handle GNU/Linux's extended waitstatus for trace events.  */
2433   if (WIFSTOPPED (status) && WSTOPSIG (status) == SIGTRAP && status >> 16 != 0)
2434     {
2435       if (debug_linux_nat)
2436         fprintf_unfiltered (gdb_stdlog,
2437                             "WL: Handling extended status 0x%06x\n",
2438                             status);
2439       if (linux_handle_extended_wait (lp, status, 1))
2440         return wait_lwp (lp);
2441     }
2442
2443   return status;
2444 }
2445
2446 /* Save the most recent siginfo for LP.  This is currently only called
2447    for SIGTRAP; some ports use the si_addr field for
2448    target_stopped_data_address.  In the future, it may also be used to
2449    restore the siginfo of requeued signals.  */
2450
2451 static void
2452 save_siginfo (struct lwp_info *lp)
2453 {
2454   errno = 0;
2455   ptrace (PTRACE_GETSIGINFO, GET_LWP (lp->ptid),
2456           (PTRACE_TYPE_ARG3) 0, &lp->siginfo);
2457
2458   if (errno != 0)
2459     memset (&lp->siginfo, 0, sizeof (lp->siginfo));
2460 }
2461
2462 /* Send a SIGSTOP to LP.  */
2463
2464 static int
2465 stop_callback (struct lwp_info *lp, void *data)
2466 {
2467   if (!lp->stopped && !lp->signalled)
2468     {
2469       int ret;
2470
2471       if (debug_linux_nat)
2472         {
2473           fprintf_unfiltered (gdb_stdlog,
2474                               "SC:  kill %s **<SIGSTOP>**\n",
2475                               target_pid_to_str (lp->ptid));
2476         }
2477       errno = 0;
2478       ret = kill_lwp (GET_LWP (lp->ptid), SIGSTOP);
2479       if (debug_linux_nat)
2480         {
2481           fprintf_unfiltered (gdb_stdlog,
2482                               "SC:  lwp kill %d %s\n",
2483                               ret,
2484                               errno ? safe_strerror (errno) : "ERRNO-OK");
2485         }
2486
2487       lp->signalled = 1;
2488       gdb_assert (lp->status == 0);
2489     }
2490
2491   return 0;
2492 }
2493
2494 /* Return non-zero if LWP PID has a pending SIGINT.  */
2495
2496 static int
2497 linux_nat_has_pending_sigint (int pid)
2498 {
2499   sigset_t pending, blocked, ignored;
2500
2501   linux_proc_pending_signals (pid, &pending, &blocked, &ignored);
2502
2503   if (sigismember (&pending, SIGINT)
2504       && !sigismember (&ignored, SIGINT))
2505     return 1;
2506
2507   return 0;
2508 }
2509
2510 /* Set a flag in LP indicating that we should ignore its next SIGINT.  */
2511
2512 static int
2513 set_ignore_sigint (struct lwp_info *lp, void *data)
2514 {
2515   /* If a thread has a pending SIGINT, consume it; otherwise, set a
2516      flag to consume the next one.  */
2517   if (lp->stopped && lp->status != 0 && WIFSTOPPED (lp->status)
2518       && WSTOPSIG (lp->status) == SIGINT)
2519     lp->status = 0;
2520   else
2521     lp->ignore_sigint = 1;
2522
2523   return 0;
2524 }
2525
2526 /* If LP does not have a SIGINT pending, then clear the ignore_sigint flag.
2527    This function is called after we know the LWP has stopped; if the LWP
2528    stopped before the expected SIGINT was delivered, then it will never have
2529    arrived.  Also, if the signal was delivered to a shared queue and consumed
2530    by a different thread, it will never be delivered to this LWP.  */
2531
2532 static void
2533 maybe_clear_ignore_sigint (struct lwp_info *lp)
2534 {
2535   if (!lp->ignore_sigint)
2536     return;
2537
2538   if (!linux_nat_has_pending_sigint (GET_LWP (lp->ptid)))
2539     {
2540       if (debug_linux_nat)
2541         fprintf_unfiltered (gdb_stdlog,
2542                             "MCIS: Clearing bogus flag for %s\n",
2543                             target_pid_to_str (lp->ptid));
2544       lp->ignore_sigint = 0;
2545     }
2546 }
2547
2548 /* Fetch the possible triggered data watchpoint info and store it in
2549    LP.
2550
2551    On some archs, like x86, that use debug registers to set
2552    watchpoints, it's possible that the way to know which watched
2553    address trapped, is to check the register that is used to select
2554    which address to watch.  Problem is, between setting the watchpoint
2555    and reading back which data address trapped, the user may change
2556    the set of watchpoints, and, as a consequence, GDB changes the
2557    debug registers in the inferior.  To avoid reading back a stale
2558    stopped-data-address when that happens, we cache in LP the fact
2559    that a watchpoint trapped, and the corresponding data address, as
2560    soon as we see LP stop with a SIGTRAP.  If GDB changes the debug
2561    registers meanwhile, we have the cached data we can rely on.  */
2562
2563 static void
2564 save_sigtrap (struct lwp_info *lp)
2565 {
2566   struct cleanup *old_chain;
2567
2568   if (linux_ops->to_stopped_by_watchpoint == NULL)
2569     {
2570       lp->stopped_by_watchpoint = 0;
2571       return;
2572     }
2573
2574   old_chain = save_inferior_ptid ();
2575   inferior_ptid = lp->ptid;
2576
2577   lp->stopped_by_watchpoint = linux_ops->to_stopped_by_watchpoint ();
2578
2579   if (lp->stopped_by_watchpoint)
2580     {
2581       if (linux_ops->to_stopped_data_address != NULL)
2582         lp->stopped_data_address_p =
2583           linux_ops->to_stopped_data_address (&current_target,
2584                                               &lp->stopped_data_address);
2585       else
2586         lp->stopped_data_address_p = 0;
2587     }
2588
2589   do_cleanups (old_chain);
2590 }
2591
2592 /* See save_sigtrap.  */
2593
2594 static int
2595 linux_nat_stopped_by_watchpoint (void)
2596 {
2597   struct lwp_info *lp = find_lwp_pid (inferior_ptid);
2598
2599   gdb_assert (lp != NULL);
2600
2601   return lp->stopped_by_watchpoint;
2602 }
2603
2604 static int
2605 linux_nat_stopped_data_address (struct target_ops *ops, CORE_ADDR *addr_p)
2606 {
2607   struct lwp_info *lp = find_lwp_pid (inferior_ptid);
2608
2609   gdb_assert (lp != NULL);
2610
2611   *addr_p = lp->stopped_data_address;
2612
2613   return lp->stopped_data_address_p;
2614 }
2615
2616 /* Commonly any breakpoint / watchpoint generate only SIGTRAP.  */
2617
2618 static int
2619 sigtrap_is_event (int status)
2620 {
2621   return WIFSTOPPED (status) && WSTOPSIG (status) == SIGTRAP;
2622 }
2623
2624 /* SIGTRAP-like events recognizer.  */
2625
2626 static int (*linux_nat_status_is_event) (int status) = sigtrap_is_event;
2627
2628 /* Check for SIGTRAP-like events in LP.  */
2629
2630 static int
2631 linux_nat_lp_status_is_event (struct lwp_info *lp)
2632 {
2633   /* We check for lp->waitstatus in addition to lp->status, because we can
2634      have pending process exits recorded in lp->status
2635      and W_EXITCODE(0,0) == 0.  We should probably have an additional
2636      lp->status_p flag.  */
2637
2638   return (lp->waitstatus.kind == TARGET_WAITKIND_IGNORE
2639           && linux_nat_status_is_event (lp->status));
2640 }
2641
2642 /* Set alternative SIGTRAP-like events recognizer.  If
2643    breakpoint_inserted_here_p there then gdbarch_decr_pc_after_break will be
2644    applied.  */
2645
2646 void
2647 linux_nat_set_status_is_event (struct target_ops *t,
2648                                int (*status_is_event) (int status))
2649 {
2650   linux_nat_status_is_event = status_is_event;
2651 }
2652
2653 /* Wait until LP is stopped.  */
2654
2655 static int
2656 stop_wait_callback (struct lwp_info *lp, void *data)
2657 {
2658   struct inferior *inf = find_inferior_pid (GET_PID (lp->ptid));
2659
2660   /* If this is a vfork parent, bail out, it is not going to report
2661      any SIGSTOP until the vfork is done with.  */
2662   if (inf->vfork_child != NULL)
2663     return 0;
2664
2665   if (!lp->stopped)
2666     {
2667       int status;
2668
2669       status = wait_lwp (lp);
2670       if (status == 0)
2671         return 0;
2672
2673       if (lp->ignore_sigint && WIFSTOPPED (status)
2674           && WSTOPSIG (status) == SIGINT)
2675         {
2676           lp->ignore_sigint = 0;
2677
2678           errno = 0;
2679           ptrace (PTRACE_CONT, GET_LWP (lp->ptid), 0, 0);
2680           if (debug_linux_nat)
2681             fprintf_unfiltered (gdb_stdlog,
2682                                 "PTRACE_CONT %s, 0, 0 (%s) "
2683                                 "(discarding SIGINT)\n",
2684                                 target_pid_to_str (lp->ptid),
2685                                 errno ? safe_strerror (errno) : "OK");
2686
2687           return stop_wait_callback (lp, NULL);
2688         }
2689
2690       maybe_clear_ignore_sigint (lp);
2691
2692       if (WSTOPSIG (status) != SIGSTOP)
2693         {
2694           if (linux_nat_status_is_event (status))
2695             {
2696               /* If a LWP other than the LWP that we're reporting an
2697                  event for has hit a GDB breakpoint (as opposed to
2698                  some random trap signal), then just arrange for it to
2699                  hit it again later.  We don't keep the SIGTRAP status
2700                  and don't forward the SIGTRAP signal to the LWP.  We
2701                  will handle the current event, eventually we will
2702                  resume all LWPs, and this one will get its breakpoint
2703                  trap again.
2704
2705                  If we do not do this, then we run the risk that the
2706                  user will delete or disable the breakpoint, but the
2707                  thread will have already tripped on it.  */
2708
2709               /* Save the trap's siginfo in case we need it later.  */
2710               save_siginfo (lp);
2711
2712               save_sigtrap (lp);
2713
2714               /* Now resume this LWP and get the SIGSTOP event.  */
2715               errno = 0;
2716               ptrace (PTRACE_CONT, GET_LWP (lp->ptid), 0, 0);
2717               if (debug_linux_nat)
2718                 {
2719                   fprintf_unfiltered (gdb_stdlog,
2720                                       "PTRACE_CONT %s, 0, 0 (%s)\n",
2721                                       target_pid_to_str (lp->ptid),
2722                                       errno ? safe_strerror (errno) : "OK");
2723
2724                   fprintf_unfiltered (gdb_stdlog,
2725                                       "SWC: Candidate SIGTRAP event in %s\n",
2726                                       target_pid_to_str (lp->ptid));
2727                 }
2728               /* Hold this event/waitstatus while we check to see if
2729                  there are any more (we still want to get that SIGSTOP).  */
2730               stop_wait_callback (lp, NULL);
2731
2732               /* Hold the SIGTRAP for handling by linux_nat_wait.  If
2733                  there's another event, throw it back into the
2734                  queue.  */
2735               if (lp->status)
2736                 {
2737                   if (debug_linux_nat)
2738                     fprintf_unfiltered (gdb_stdlog,
2739                                         "SWC: kill %s, %s\n",
2740                                         target_pid_to_str (lp->ptid),
2741                                         status_to_str ((int) status));
2742                   kill_lwp (GET_LWP (lp->ptid), WSTOPSIG (lp->status));
2743                 }
2744
2745               /* Save the sigtrap event.  */
2746               lp->status = status;
2747               return 0;
2748             }
2749           else
2750             {
2751               /* The thread was stopped with a signal other than
2752                  SIGSTOP, and didn't accidentally trip a breakpoint.  */
2753
2754               if (debug_linux_nat)
2755                 {
2756                   fprintf_unfiltered (gdb_stdlog,
2757                                       "SWC: Pending event %s in %s\n",
2758                                       status_to_str ((int) status),
2759                                       target_pid_to_str (lp->ptid));
2760                 }
2761               /* Now resume this LWP and get the SIGSTOP event.  */
2762               errno = 0;
2763               ptrace (PTRACE_CONT, GET_LWP (lp->ptid), 0, 0);
2764               if (debug_linux_nat)
2765                 fprintf_unfiltered (gdb_stdlog,
2766                                     "SWC: PTRACE_CONT %s, 0, 0 (%s)\n",
2767                                     target_pid_to_str (lp->ptid),
2768                                     errno ? safe_strerror (errno) : "OK");
2769
2770               /* Hold this event/waitstatus while we check to see if
2771                  there are any more (we still want to get that SIGSTOP).  */
2772               stop_wait_callback (lp, NULL);
2773
2774               /* If the lp->status field is still empty, use it to
2775                  hold this event.  If not, then this event must be
2776                  returned to the event queue of the LWP.  */
2777               if (lp->status)
2778                 {
2779                   if (debug_linux_nat)
2780                     {
2781                       fprintf_unfiltered (gdb_stdlog,
2782                                           "SWC: kill %s, %s\n",
2783                                           target_pid_to_str (lp->ptid),
2784                                           status_to_str ((int) status));
2785                     }
2786                   kill_lwp (GET_LWP (lp->ptid), WSTOPSIG (status));
2787                 }
2788               else
2789                 lp->status = status;
2790               return 0;
2791             }
2792         }
2793       else
2794         {
2795           /* We caught the SIGSTOP that we intended to catch, so
2796              there's no SIGSTOP pending.  */
2797           lp->stopped = 1;
2798           lp->signalled = 0;
2799         }
2800     }
2801
2802   return 0;
2803 }
2804
2805 /* Return non-zero if LP has a wait status pending.  */
2806
2807 static int
2808 status_callback (struct lwp_info *lp, void *data)
2809 {
2810   /* Only report a pending wait status if we pretend that this has
2811      indeed been resumed.  */
2812   if (!lp->resumed)
2813     return 0;
2814
2815   if (lp->waitstatus.kind != TARGET_WAITKIND_IGNORE)
2816     {
2817       /* A ptrace event, like PTRACE_FORK|VFORK|EXEC, syscall event,
2818          or a pending process exit.  Note that `W_EXITCODE(0,0) ==
2819          0', so a clean process exit can not be stored pending in
2820          lp->status, it is indistinguishable from
2821          no-pending-status.  */
2822       return 1;
2823     }
2824
2825   if (lp->status != 0)
2826     return 1;
2827
2828   return 0;
2829 }
2830
2831 /* Return non-zero if LP isn't stopped.  */
2832
2833 static int
2834 running_callback (struct lwp_info *lp, void *data)
2835 {
2836   return (lp->stopped == 0 || (lp->status != 0 && lp->resumed));
2837 }
2838
2839 /* Count the LWP's that have had events.  */
2840
2841 static int
2842 count_events_callback (struct lwp_info *lp, void *data)
2843 {
2844   int *count = data;
2845
2846   gdb_assert (count != NULL);
2847
2848   /* Count only resumed LWPs that have a SIGTRAP event pending.  */
2849   if (lp->resumed && linux_nat_lp_status_is_event (lp))
2850     (*count)++;
2851
2852   return 0;
2853 }
2854
2855 /* Select the LWP (if any) that is currently being single-stepped.  */
2856
2857 static int
2858 select_singlestep_lwp_callback (struct lwp_info *lp, void *data)
2859 {
2860   if (lp->step && lp->status != 0)
2861     return 1;
2862   else
2863     return 0;
2864 }
2865
2866 /* Select the Nth LWP that has had a SIGTRAP event.  */
2867
2868 static int
2869 select_event_lwp_callback (struct lwp_info *lp, void *data)
2870 {
2871   int *selector = data;
2872
2873   gdb_assert (selector != NULL);
2874
2875   /* Select only resumed LWPs that have a SIGTRAP event pending.  */
2876   if (lp->resumed && linux_nat_lp_status_is_event (lp))
2877     if ((*selector)-- == 0)
2878       return 1;
2879
2880   return 0;
2881 }
2882
2883 static int
2884 cancel_breakpoint (struct lwp_info *lp)
2885 {
2886   /* Arrange for a breakpoint to be hit again later.  We don't keep
2887      the SIGTRAP status and don't forward the SIGTRAP signal to the
2888      LWP.  We will handle the current event, eventually we will resume
2889      this LWP, and this breakpoint will trap again.
2890
2891      If we do not do this, then we run the risk that the user will
2892      delete or disable the breakpoint, but the LWP will have already
2893      tripped on it.  */
2894
2895   struct regcache *regcache = get_thread_regcache (lp->ptid);
2896   struct gdbarch *gdbarch = get_regcache_arch (regcache);
2897   CORE_ADDR pc;
2898
2899   pc = regcache_read_pc (regcache) - gdbarch_decr_pc_after_break (gdbarch);
2900   if (breakpoint_inserted_here_p (get_regcache_aspace (regcache), pc))
2901     {
2902       if (debug_linux_nat)
2903         fprintf_unfiltered (gdb_stdlog,
2904                             "CB: Push back breakpoint for %s\n",
2905                             target_pid_to_str (lp->ptid));
2906
2907       /* Back up the PC if necessary.  */
2908       if (gdbarch_decr_pc_after_break (gdbarch))
2909         regcache_write_pc (regcache, pc);
2910
2911       return 1;
2912     }
2913   return 0;
2914 }
2915
2916 static int
2917 cancel_breakpoints_callback (struct lwp_info *lp, void *data)
2918 {
2919   struct lwp_info *event_lp = data;
2920
2921   /* Leave the LWP that has been elected to receive a SIGTRAP alone.  */
2922   if (lp == event_lp)
2923     return 0;
2924
2925   /* If a LWP other than the LWP that we're reporting an event for has
2926      hit a GDB breakpoint (as opposed to some random trap signal),
2927      then just arrange for it to hit it again later.  We don't keep
2928      the SIGTRAP status and don't forward the SIGTRAP signal to the
2929      LWP.  We will handle the current event, eventually we will resume
2930      all LWPs, and this one will get its breakpoint trap again.
2931
2932      If we do not do this, then we run the risk that the user will
2933      delete or disable the breakpoint, but the LWP will have already
2934      tripped on it.  */
2935
2936   if (linux_nat_lp_status_is_event (lp)
2937       && cancel_breakpoint (lp))
2938     /* Throw away the SIGTRAP.  */
2939     lp->status = 0;
2940
2941   return 0;
2942 }
2943
2944 /* Select one LWP out of those that have events pending.  */
2945
2946 static void
2947 select_event_lwp (ptid_t filter, struct lwp_info **orig_lp, int *status)
2948 {
2949   int num_events = 0;
2950   int random_selector;
2951   struct lwp_info *event_lp;
2952
2953   /* Record the wait status for the original LWP.  */
2954   (*orig_lp)->status = *status;
2955
2956   /* Give preference to any LWP that is being single-stepped.  */
2957   event_lp = iterate_over_lwps (filter,
2958                                 select_singlestep_lwp_callback, NULL);
2959   if (event_lp != NULL)
2960     {
2961       if (debug_linux_nat)
2962         fprintf_unfiltered (gdb_stdlog,
2963                             "SEL: Select single-step %s\n",
2964                             target_pid_to_str (event_lp->ptid));
2965     }
2966   else
2967     {
2968       /* No single-stepping LWP.  Select one at random, out of those
2969          which have had SIGTRAP events.  */
2970
2971       /* First see how many SIGTRAP events we have.  */
2972       iterate_over_lwps (filter, count_events_callback, &num_events);
2973
2974       /* Now randomly pick a LWP out of those that have had a SIGTRAP.  */
2975       random_selector = (int)
2976         ((num_events * (double) rand ()) / (RAND_MAX + 1.0));
2977
2978       if (debug_linux_nat && num_events > 1)
2979         fprintf_unfiltered (gdb_stdlog,
2980                             "SEL: Found %d SIGTRAP events, selecting #%d\n",
2981                             num_events, random_selector);
2982
2983       event_lp = iterate_over_lwps (filter,
2984                                     select_event_lwp_callback,
2985                                     &random_selector);
2986     }
2987
2988   if (event_lp != NULL)
2989     {
2990       /* Switch the event LWP.  */
2991       *orig_lp = event_lp;
2992       *status = event_lp->status;
2993     }
2994
2995   /* Flush the wait status for the event LWP.  */
2996   (*orig_lp)->status = 0;
2997 }
2998
2999 /* Return non-zero if LP has been resumed.  */
3000
3001 static int
3002 resumed_callback (struct lwp_info *lp, void *data)
3003 {
3004   return lp->resumed;
3005 }
3006
3007 /* Stop an active thread, verify it still exists, then resume it.  */
3008
3009 static int
3010 stop_and_resume_callback (struct lwp_info *lp, void *data)
3011 {
3012   struct lwp_info *ptr;
3013
3014   if (!lp->stopped && !lp->signalled)
3015     {
3016       stop_callback (lp, NULL);
3017       stop_wait_callback (lp, NULL);
3018       /* Resume if the lwp still exists.  */
3019       for (ptr = lwp_list; ptr; ptr = ptr->next)
3020         if (lp == ptr)
3021           {
3022             resume_callback (lp, NULL);
3023             resume_set_callback (lp, NULL);
3024           }
3025     }
3026   return 0;
3027 }
3028
3029 /* Check if we should go on and pass this event to common code.
3030    Return the affected lwp if we are, or NULL otherwise.  */
3031 static struct lwp_info *
3032 linux_nat_filter_event (int lwpid, int status, int options)
3033 {
3034   struct lwp_info *lp;
3035
3036   lp = find_lwp_pid (pid_to_ptid (lwpid));
3037
3038   /* Check for stop events reported by a process we didn't already
3039      know about - anything not already in our LWP list.
3040
3041      If we're expecting to receive stopped processes after
3042      fork, vfork, and clone events, then we'll just add the
3043      new one to our list and go back to waiting for the event
3044      to be reported - the stopped process might be returned
3045      from waitpid before or after the event is.  */
3046   if (WIFSTOPPED (status) && !lp)
3047     {
3048       linux_record_stopped_pid (lwpid, status);
3049       return NULL;
3050     }
3051
3052   /* Make sure we don't report an event for the exit of an LWP not in
3053      our list, i.e. not part of the current process.  This can happen
3054      if we detach from a program we originally forked and then it
3055      exits.  */
3056   if (!WIFSTOPPED (status) && !lp)
3057     return NULL;
3058
3059   /* NOTE drow/2003-06-17: This code seems to be meant for debugging
3060      CLONE_PTRACE processes which do not use the thread library -
3061      otherwise we wouldn't find the new LWP this way.  That doesn't
3062      currently work, and the following code is currently unreachable
3063      due to the two blocks above.  If it's fixed some day, this code
3064      should be broken out into a function so that we can also pick up
3065      LWPs from the new interface.  */
3066   if (!lp)
3067     {
3068       lp = add_lwp (BUILD_LWP (lwpid, GET_PID (inferior_ptid)));
3069       if (options & __WCLONE)
3070         lp->cloned = 1;
3071
3072       gdb_assert (WIFSTOPPED (status)
3073                   && WSTOPSIG (status) == SIGSTOP);
3074       lp->signalled = 1;
3075
3076       if (!in_thread_list (inferior_ptid))
3077         {
3078           inferior_ptid = BUILD_LWP (GET_PID (inferior_ptid),
3079                                      GET_PID (inferior_ptid));
3080           add_thread (inferior_ptid);
3081         }
3082
3083       add_thread (lp->ptid);
3084     }
3085
3086   /* Handle GNU/Linux's syscall SIGTRAPs.  */
3087   if (WIFSTOPPED (status) && WSTOPSIG (status) == SYSCALL_SIGTRAP)
3088     {
3089       /* No longer need the sysgood bit.  The ptrace event ends up
3090          recorded in lp->waitstatus if we care for it.  We can carry
3091          on handling the event like a regular SIGTRAP from here
3092          on.  */
3093       status = W_STOPCODE (SIGTRAP);
3094       if (linux_handle_syscall_trap (lp, 0))
3095         return NULL;
3096     }
3097
3098   /* Handle GNU/Linux's extended waitstatus for trace events.  */
3099   if (WIFSTOPPED (status) && WSTOPSIG (status) == SIGTRAP && status >> 16 != 0)
3100     {
3101       if (debug_linux_nat)
3102         fprintf_unfiltered (gdb_stdlog,
3103                             "LLW: Handling extended status 0x%06x\n",
3104                             status);
3105       if (linux_handle_extended_wait (lp, status, 0))
3106         return NULL;
3107     }
3108
3109   if (linux_nat_status_is_event (status))
3110     {
3111       /* Save the trap's siginfo in case we need it later.  */
3112       save_siginfo (lp);
3113
3114       save_sigtrap (lp);
3115     }
3116
3117   /* Check if the thread has exited.  */
3118   if ((WIFEXITED (status) || WIFSIGNALED (status))
3119       && num_lwps (GET_PID (lp->ptid)) > 1)
3120     {
3121       /* If this is the main thread, we must stop all threads and verify
3122          if they are still alive.  This is because in the nptl thread model
3123          on Linux 2.4, there is no signal issued for exiting LWPs
3124          other than the main thread.  We only get the main thread exit
3125          signal once all child threads have already exited.  If we
3126          stop all the threads and use the stop_wait_callback to check
3127          if they have exited we can determine whether this signal
3128          should be ignored or whether it means the end of the debugged
3129          application, regardless of which threading model is being
3130          used.  */
3131       if (GET_PID (lp->ptid) == GET_LWP (lp->ptid))
3132         {
3133           lp->stopped = 1;
3134           iterate_over_lwps (pid_to_ptid (GET_PID (lp->ptid)),
3135                              stop_and_resume_callback, NULL);
3136         }
3137
3138       if (debug_linux_nat)
3139         fprintf_unfiltered (gdb_stdlog,
3140                             "LLW: %s exited.\n",
3141                             target_pid_to_str (lp->ptid));
3142
3143       if (num_lwps (GET_PID (lp->ptid)) > 1)
3144        {
3145          /* If there is at least one more LWP, then the exit signal
3146             was not the end of the debugged application and should be
3147             ignored.  */
3148          exit_lwp (lp);
3149          return NULL;
3150        }
3151     }
3152
3153   /* Check if the current LWP has previously exited.  In the nptl
3154      thread model, LWPs other than the main thread do not issue
3155      signals when they exit so we must check whenever the thread has
3156      stopped.  A similar check is made in stop_wait_callback().  */
3157   if (num_lwps (GET_PID (lp->ptid)) > 1 && !linux_thread_alive (lp->ptid))
3158     {
3159       ptid_t ptid = pid_to_ptid (GET_PID (lp->ptid));
3160
3161       if (debug_linux_nat)
3162         fprintf_unfiltered (gdb_stdlog,
3163                             "LLW: %s exited.\n",
3164                             target_pid_to_str (lp->ptid));
3165
3166       exit_lwp (lp);
3167
3168       /* Make sure there is at least one thread running.  */
3169       gdb_assert (iterate_over_lwps (ptid, running_callback, NULL));
3170
3171       /* Discard the event.  */
3172       return NULL;
3173     }
3174
3175   /* Make sure we don't report a SIGSTOP that we sent ourselves in
3176      an attempt to stop an LWP.  */
3177   if (lp->signalled
3178       && WIFSTOPPED (status) && WSTOPSIG (status) == SIGSTOP)
3179     {
3180       if (debug_linux_nat)
3181         fprintf_unfiltered (gdb_stdlog,
3182                             "LLW: Delayed SIGSTOP caught for %s.\n",
3183                             target_pid_to_str (lp->ptid));
3184
3185       /* This is a delayed SIGSTOP.  */
3186       lp->signalled = 0;
3187
3188       registers_changed ();
3189
3190       linux_ops->to_resume (linux_ops, pid_to_ptid (GET_LWP (lp->ptid)),
3191                             lp->step, TARGET_SIGNAL_0);
3192       if (debug_linux_nat)
3193         fprintf_unfiltered (gdb_stdlog,
3194                             "LLW: %s %s, 0, 0 (discard SIGSTOP)\n",
3195                             lp->step ?
3196                             "PTRACE_SINGLESTEP" : "PTRACE_CONT",
3197                             target_pid_to_str (lp->ptid));
3198
3199       lp->stopped = 0;
3200       gdb_assert (lp->resumed);
3201
3202       /* Discard the event.  */
3203       return NULL;
3204     }
3205
3206   /* Make sure we don't report a SIGINT that we have already displayed
3207      for another thread.  */
3208   if (lp->ignore_sigint
3209       && WIFSTOPPED (status) && WSTOPSIG (status) == SIGINT)
3210     {
3211       if (debug_linux_nat)
3212         fprintf_unfiltered (gdb_stdlog,
3213                             "LLW: Delayed SIGINT caught for %s.\n",
3214                             target_pid_to_str (lp->ptid));
3215
3216       /* This is a delayed SIGINT.  */
3217       lp->ignore_sigint = 0;
3218
3219       registers_changed ();
3220       linux_ops->to_resume (linux_ops, pid_to_ptid (GET_LWP (lp->ptid)),
3221                             lp->step, TARGET_SIGNAL_0);
3222       if (debug_linux_nat)
3223         fprintf_unfiltered (gdb_stdlog,
3224                             "LLW: %s %s, 0, 0 (discard SIGINT)\n",
3225                             lp->step ?
3226                             "PTRACE_SINGLESTEP" : "PTRACE_CONT",
3227                             target_pid_to_str (lp->ptid));
3228
3229       lp->stopped = 0;
3230       gdb_assert (lp->resumed);
3231
3232       /* Discard the event.  */
3233       return NULL;
3234     }
3235
3236   /* An interesting event.  */
3237   gdb_assert (lp);
3238   lp->status = status;
3239   return lp;
3240 }
3241
3242 static ptid_t
3243 linux_nat_wait_1 (struct target_ops *ops,
3244                   ptid_t ptid, struct target_waitstatus *ourstatus,
3245                   int target_options)
3246 {
3247   static sigset_t prev_mask;
3248   struct lwp_info *lp = NULL;
3249   int options = 0;
3250   int status = 0;
3251   pid_t pid;
3252
3253   if (debug_linux_nat)
3254     fprintf_unfiltered (gdb_stdlog, "LLW: enter\n");
3255
3256   /* The first time we get here after starting a new inferior, we may
3257      not have added it to the LWP list yet - this is the earliest
3258      moment at which we know its PID.  */
3259   if (ptid_is_pid (inferior_ptid))
3260     {
3261       /* Upgrade the main thread's ptid.  */
3262       thread_change_ptid (inferior_ptid,
3263                           BUILD_LWP (GET_PID (inferior_ptid),
3264                                      GET_PID (inferior_ptid)));
3265
3266       lp = add_lwp (inferior_ptid);
3267       lp->resumed = 1;
3268     }
3269
3270   /* Make sure SIGCHLD is blocked.  */
3271   block_child_signals (&prev_mask);
3272
3273   if (ptid_equal (ptid, minus_one_ptid))
3274     pid = -1;
3275   else if (ptid_is_pid (ptid))
3276     /* A request to wait for a specific tgid.  This is not possible
3277        with waitpid, so instead, we wait for any child, and leave
3278        children we're not interested in right now with a pending
3279        status to report later.  */
3280     pid = -1;
3281   else
3282     pid = GET_LWP (ptid);
3283
3284 retry:
3285   lp = NULL;
3286   status = 0;
3287
3288   /* Make sure that of those LWPs we want to get an event from, there
3289      is at least one LWP that has been resumed.  If there's none, just
3290      bail out.  The core may just be flushing asynchronously all
3291      events.  */
3292   if (iterate_over_lwps (ptid, resumed_callback, NULL) == NULL)
3293     {
3294       ourstatus->kind = TARGET_WAITKIND_IGNORE;
3295
3296       if (debug_linux_nat)
3297         fprintf_unfiltered (gdb_stdlog, "LLW: exit (no resumed LWP)\n");
3298
3299       restore_child_signals_mask (&prev_mask);
3300       return minus_one_ptid;
3301     }
3302
3303   /* First check if there is a LWP with a wait status pending.  */
3304   if (pid == -1)
3305     {
3306       /* Any LWP that's been resumed will do.  */
3307       lp = iterate_over_lwps (ptid, status_callback, NULL);
3308       if (lp)
3309         {
3310           if (debug_linux_nat && lp->status)
3311             fprintf_unfiltered (gdb_stdlog,
3312                                 "LLW: Using pending wait status %s for %s.\n",
3313                                 status_to_str (lp->status),
3314                                 target_pid_to_str (lp->ptid));
3315         }
3316
3317       /* But if we don't find one, we'll have to wait, and check both
3318          cloned and uncloned processes.  We start with the cloned
3319          processes.  */
3320       options = __WCLONE | WNOHANG;
3321     }
3322   else if (is_lwp (ptid))
3323     {
3324       if (debug_linux_nat)
3325         fprintf_unfiltered (gdb_stdlog,
3326                             "LLW: Waiting for specific LWP %s.\n",
3327                             target_pid_to_str (ptid));
3328
3329       /* We have a specific LWP to check.  */
3330       lp = find_lwp_pid (ptid);
3331       gdb_assert (lp);
3332
3333       if (debug_linux_nat && lp->status)
3334         fprintf_unfiltered (gdb_stdlog,
3335                             "LLW: Using pending wait status %s for %s.\n",
3336                             status_to_str (lp->status),
3337                             target_pid_to_str (lp->ptid));
3338
3339       /* If we have to wait, take into account whether PID is a cloned
3340          process or not.  And we have to convert it to something that
3341          the layer beneath us can understand.  */
3342       options = lp->cloned ? __WCLONE : 0;
3343       pid = GET_LWP (ptid);
3344
3345       /* We check for lp->waitstatus in addition to lp->status,
3346          because we can have pending process exits recorded in
3347          lp->status and W_EXITCODE(0,0) == 0.  We should probably have
3348          an additional lp->status_p flag.  */
3349       if (lp->status == 0 && lp->waitstatus.kind == TARGET_WAITKIND_IGNORE)
3350         lp = NULL;
3351     }
3352
3353   if (lp && lp->signalled)
3354     {
3355       /* A pending SIGSTOP may interfere with the normal stream of
3356          events.  In a typical case where interference is a problem,
3357          we have a SIGSTOP signal pending for LWP A while
3358          single-stepping it, encounter an event in LWP B, and take the
3359          pending SIGSTOP while trying to stop LWP A.  After processing
3360          the event in LWP B, LWP A is continued, and we'll never see
3361          the SIGTRAP associated with the last time we were
3362          single-stepping LWP A.  */
3363
3364       /* Resume the thread.  It should halt immediately returning the
3365          pending SIGSTOP.  */
3366       registers_changed ();
3367       linux_ops->to_resume (linux_ops, pid_to_ptid (GET_LWP (lp->ptid)),
3368                             lp->step, TARGET_SIGNAL_0);
3369       if (debug_linux_nat)
3370         fprintf_unfiltered (gdb_stdlog,
3371                             "LLW: %s %s, 0, 0 (expect SIGSTOP)\n",
3372                             lp->step ? "PTRACE_SINGLESTEP" : "PTRACE_CONT",
3373                             target_pid_to_str (lp->ptid));
3374       lp->stopped = 0;
3375       gdb_assert (lp->resumed);
3376
3377       /* Catch the pending SIGSTOP.  */
3378       status = lp->status;
3379       lp->status = 0;
3380
3381       stop_wait_callback (lp, NULL);
3382
3383       /* If the lp->status field isn't empty, we caught another signal
3384          while flushing the SIGSTOP.  Return it back to the event
3385          queue of the LWP, as we already have an event to handle.  */
3386       if (lp->status)
3387         {
3388           if (debug_linux_nat)
3389             fprintf_unfiltered (gdb_stdlog,
3390                                 "LLW: kill %s, %s\n",
3391                                 target_pid_to_str (lp->ptid),
3392                                 status_to_str (lp->status));
3393           kill_lwp (GET_LWP (lp->ptid), WSTOPSIG (lp->status));
3394         }
3395
3396       lp->status = status;
3397     }
3398
3399   if (!target_can_async_p ())
3400     {
3401       /* Causes SIGINT to be passed on to the attached process.  */
3402       set_sigint_trap ();
3403     }
3404
3405   /* Translate generic target_wait options into waitpid options.  */
3406   if (target_options & TARGET_WNOHANG)
3407     options |= WNOHANG;
3408
3409   while (lp == NULL)
3410     {
3411       pid_t lwpid;
3412
3413       lwpid = my_waitpid (pid, &status, options);
3414
3415       if (lwpid > 0)
3416         {
3417           gdb_assert (pid == -1 || lwpid == pid);
3418
3419           if (debug_linux_nat)
3420             {
3421               fprintf_unfiltered (gdb_stdlog,
3422                                   "LLW: waitpid %ld received %s\n",
3423                                   (long) lwpid, status_to_str (status));
3424             }
3425
3426           lp = linux_nat_filter_event (lwpid, status, options);
3427
3428           /* STATUS is now no longer valid, use LP->STATUS instead.  */
3429           status = 0;
3430
3431           if (lp
3432               && ptid_is_pid (ptid)
3433               && ptid_get_pid (lp->ptid) != ptid_get_pid (ptid))
3434             {
3435               gdb_assert (lp->resumed);
3436
3437               if (debug_linux_nat)
3438                 fprintf (stderr,
3439                          "LWP %ld got an event %06x, leaving pending.\n",
3440                          ptid_get_lwp (lp->ptid), lp->status);
3441
3442               if (WIFSTOPPED (lp->status))
3443                 {
3444                   if (WSTOPSIG (lp->status) != SIGSTOP)
3445                     {
3446                       /* Cancel breakpoint hits.  The breakpoint may
3447                          be removed before we fetch events from this
3448                          process to report to the core.  It is best
3449                          not to assume the moribund breakpoints
3450                          heuristic always handles these cases --- it
3451                          could be too many events go through to the
3452                          core before this one is handled.  All-stop
3453                          always cancels breakpoint hits in all
3454                          threads.  */
3455                       if (non_stop
3456                           && linux_nat_lp_status_is_event (lp)
3457                           && cancel_breakpoint (lp))
3458                         {
3459                           /* Throw away the SIGTRAP.  */
3460                           lp->status = 0;
3461
3462                           if (debug_linux_nat)
3463                             fprintf (stderr,
3464                                      "LLW: LWP %ld hit a breakpoint while"
3465                                      " waiting for another process;"
3466                                      " cancelled it\n",
3467                                      ptid_get_lwp (lp->ptid));
3468                         }
3469                       lp->stopped = 1;
3470                     }
3471                   else
3472                     {
3473                       lp->stopped = 1;
3474                       lp->signalled = 0;
3475                     }
3476                 }
3477               else if (WIFEXITED (lp->status) || WIFSIGNALED (lp->status))
3478                 {
3479                   if (debug_linux_nat)
3480                     fprintf (stderr,
3481                              "Process %ld exited while stopping LWPs\n",
3482                              ptid_get_lwp (lp->ptid));
3483
3484                   /* This was the last lwp in the process.  Since
3485                      events are serialized to GDB core, and we can't
3486                      report this one right now, but GDB core and the
3487                      other target layers will want to be notified
3488                      about the exit code/signal, leave the status
3489                      pending for the next time we're able to report
3490                      it.  */
3491
3492                   /* Prevent trying to stop this thread again.  We'll
3493                      never try to resume it because it has a pending
3494                      status.  */
3495                   lp->stopped = 1;
3496
3497                   /* Dead LWP's aren't expected to reported a pending
3498                      sigstop.  */
3499                   lp->signalled = 0;
3500
3501                   /* Store the pending event in the waitstatus as
3502                      well, because W_EXITCODE(0,0) == 0.  */
3503                   store_waitstatus (&lp->waitstatus, lp->status);
3504                 }
3505
3506               /* Keep looking.  */
3507               lp = NULL;
3508               continue;
3509             }
3510
3511           if (lp)
3512             break;
3513           else
3514             {
3515               if (pid == -1)
3516                 {
3517                   /* waitpid did return something.  Restart over.  */
3518                   options |= __WCLONE;
3519                 }
3520               continue;
3521             }
3522         }
3523
3524       if (pid == -1)
3525         {
3526           /* Alternate between checking cloned and uncloned processes.  */
3527           options ^= __WCLONE;
3528
3529           /* And every time we have checked both:
3530              In async mode, return to event loop;
3531              In sync mode, suspend waiting for a SIGCHLD signal.  */
3532           if (options & __WCLONE)
3533             {
3534               if (target_options & TARGET_WNOHANG)
3535                 {
3536                   /* No interesting event.  */
3537                   ourstatus->kind = TARGET_WAITKIND_IGNORE;
3538
3539                   if (debug_linux_nat)
3540                     fprintf_unfiltered (gdb_stdlog, "LLW: exit (ignore)\n");
3541
3542                   restore_child_signals_mask (&prev_mask);
3543                   return minus_one_ptid;
3544                 }
3545
3546               sigsuspend (&suspend_mask);
3547             }
3548         }
3549       else if (target_options & TARGET_WNOHANG)
3550         {
3551           /* No interesting event for PID yet.  */
3552           ourstatus->kind = TARGET_WAITKIND_IGNORE;
3553
3554           if (debug_linux_nat)
3555             fprintf_unfiltered (gdb_stdlog, "LLW: exit (ignore)\n");
3556
3557           restore_child_signals_mask (&prev_mask);
3558           return minus_one_ptid;
3559         }
3560
3561       /* We shouldn't end up here unless we want to try again.  */
3562       gdb_assert (lp == NULL);
3563     }
3564
3565   if (!target_can_async_p ())
3566     clear_sigint_trap ();
3567
3568   gdb_assert (lp);
3569
3570   status = lp->status;
3571   lp->status = 0;
3572
3573   /* Don't report signals that GDB isn't interested in, such as
3574      signals that are neither printed nor stopped upon.  Stopping all
3575      threads can be a bit time-consuming so if we want decent
3576      performance with heavily multi-threaded programs, especially when
3577      they're using a high frequency timer, we'd better avoid it if we
3578      can.  */
3579
3580   if (WIFSTOPPED (status))
3581     {
3582       enum target_signal signo = target_signal_from_host (WSTOPSIG (status));
3583
3584       /* When using hardware single-step, we need to report every signal.
3585          Otherwise, signals in pass_mask may be short-circuited.  */
3586       if (!lp->step
3587           && WSTOPSIG (status) && sigismember (&pass_mask, WSTOPSIG (status)))
3588         {
3589           /* FIMXE: kettenis/2001-06-06: Should we resume all threads
3590              here?  It is not clear we should.  GDB may not expect
3591              other threads to run.  On the other hand, not resuming
3592              newly attached threads may cause an unwanted delay in
3593              getting them running.  */
3594           registers_changed ();
3595           linux_ops->to_resume (linux_ops, pid_to_ptid (GET_LWP (lp->ptid)),
3596                                 lp->step, signo);
3597           if (debug_linux_nat)
3598             fprintf_unfiltered (gdb_stdlog,
3599                                 "LLW: %s %s, %s (preempt 'handle')\n",
3600                                 lp->step ?
3601                                 "PTRACE_SINGLESTEP" : "PTRACE_CONT",
3602                                 target_pid_to_str (lp->ptid),
3603                                 (signo != TARGET_SIGNAL_0
3604                                  ? strsignal (target_signal_to_host (signo))
3605                                  : "0"));
3606           lp->stopped = 0;
3607           goto retry;
3608         }
3609
3610       if (!non_stop)
3611         {
3612           /* Only do the below in all-stop, as we currently use SIGINT
3613              to implement target_stop (see linux_nat_stop) in
3614              non-stop.  */
3615           if (signo == TARGET_SIGNAL_INT && signal_pass_state (signo) == 0)
3616             {
3617               /* If ^C/BREAK is typed at the tty/console, SIGINT gets
3618                  forwarded to the entire process group, that is, all LWPs
3619                  will receive it - unless they're using CLONE_THREAD to
3620                  share signals.  Since we only want to report it once, we
3621                  mark it as ignored for all LWPs except this one.  */
3622               iterate_over_lwps (pid_to_ptid (ptid_get_pid (ptid)),
3623                                               set_ignore_sigint, NULL);
3624               lp->ignore_sigint = 0;
3625             }
3626           else
3627             maybe_clear_ignore_sigint (lp);
3628         }
3629     }
3630
3631   /* This LWP is stopped now.  */
3632   lp->stopped = 1;
3633
3634   if (debug_linux_nat)
3635     fprintf_unfiltered (gdb_stdlog, "LLW: Candidate event %s in %s.\n",
3636                         status_to_str (status), target_pid_to_str (lp->ptid));
3637
3638   if (!non_stop)
3639     {
3640       /* Now stop all other LWP's ...  */
3641       iterate_over_lwps (minus_one_ptid, stop_callback, NULL);
3642
3643       /* ... and wait until all of them have reported back that
3644          they're no longer running.  */
3645       iterate_over_lwps (minus_one_ptid, stop_wait_callback, NULL);
3646
3647       /* If we're not waiting for a specific LWP, choose an event LWP
3648          from among those that have had events.  Giving equal priority
3649          to all LWPs that have had events helps prevent
3650          starvation.  */
3651       if (pid == -1)
3652         select_event_lwp (ptid, &lp, &status);
3653
3654       /* Now that we've selected our final event LWP, cancel any
3655          breakpoints in other LWPs that have hit a GDB breakpoint.
3656          See the comment in cancel_breakpoints_callback to find out
3657          why.  */
3658       iterate_over_lwps (minus_one_ptid, cancel_breakpoints_callback, lp);
3659
3660       /* In all-stop, from the core's perspective, all LWPs are now
3661          stopped until a new resume action is sent over.  */
3662       iterate_over_lwps (minus_one_ptid, resume_clear_callback, NULL);
3663     }
3664   else
3665     lp->resumed = 0;
3666
3667   if (linux_nat_status_is_event (status))
3668     {
3669       if (debug_linux_nat)
3670         fprintf_unfiltered (gdb_stdlog,
3671                             "LLW: trap ptid is %s.\n",
3672                             target_pid_to_str (lp->ptid));
3673     }
3674
3675   if (lp->waitstatus.kind != TARGET_WAITKIND_IGNORE)
3676     {
3677       *ourstatus = lp->waitstatus;
3678       lp->waitstatus.kind = TARGET_WAITKIND_IGNORE;
3679     }
3680   else
3681     store_waitstatus (ourstatus, status);
3682
3683   if (debug_linux_nat)
3684     fprintf_unfiltered (gdb_stdlog, "LLW: exit\n");
3685
3686   restore_child_signals_mask (&prev_mask);
3687
3688   if (ourstatus->kind == TARGET_WAITKIND_EXITED
3689       || ourstatus->kind == TARGET_WAITKIND_SIGNALLED)
3690     lp->core = -1;
3691   else
3692     lp->core = linux_nat_core_of_thread_1 (lp->ptid);
3693
3694   return lp->ptid;
3695 }
3696
3697 /* Resume LWPs that are currently stopped without any pending status
3698    to report, but are resumed from the core's perspective.  */
3699
3700 static int
3701 resume_stopped_resumed_lwps (struct lwp_info *lp, void *data)
3702 {
3703   ptid_t *wait_ptid_p = data;
3704
3705   if (lp->stopped
3706       && lp->resumed
3707       && lp->status == 0
3708       && lp->waitstatus.kind == TARGET_WAITKIND_IGNORE)
3709     {
3710       gdb_assert (is_executing (lp->ptid));
3711
3712       /* Don't bother if there's a breakpoint at PC that we'd hit
3713          immediately, and we're not waiting for this LWP.  */
3714       if (!ptid_match (lp->ptid, *wait_ptid_p))
3715         {
3716           struct regcache *regcache = get_thread_regcache (lp->ptid);
3717           CORE_ADDR pc = regcache_read_pc (regcache);
3718
3719           if (breakpoint_inserted_here_p (get_regcache_aspace (regcache), pc))
3720             return 0;
3721         }
3722
3723       if (debug_linux_nat)
3724         fprintf_unfiltered (gdb_stdlog,
3725                             "RSRL: resuming stopped-resumed LWP %s\n",
3726                             target_pid_to_str (lp->ptid));
3727
3728       linux_ops->to_resume (linux_ops, pid_to_ptid (GET_LWP (lp->ptid)),
3729                             lp->step, TARGET_SIGNAL_0);
3730       lp->stopped = 0;
3731       memset (&lp->siginfo, 0, sizeof (lp->siginfo));
3732       lp->stopped_by_watchpoint = 0;
3733     }
3734
3735   return 0;
3736 }
3737
3738 static ptid_t
3739 linux_nat_wait (struct target_ops *ops,
3740                 ptid_t ptid, struct target_waitstatus *ourstatus,
3741                 int target_options)
3742 {
3743   ptid_t event_ptid;
3744
3745   if (debug_linux_nat)
3746     fprintf_unfiltered (gdb_stdlog,
3747                         "linux_nat_wait: [%s]\n", target_pid_to_str (ptid));
3748
3749   /* Flush the async file first.  */
3750   if (target_can_async_p ())
3751     async_file_flush ();
3752
3753   /* Resume LWPs that are currently stopped without any pending status
3754      to report, but are resumed from the core's perspective.  LWPs get
3755      in this state if we find them stopping at a time we're not
3756      interested in reporting the event (target_wait on a
3757      specific_process, for example, see linux_nat_wait_1), and
3758      meanwhile the event became uninteresting.  Don't bother resuming
3759      LWPs we're not going to wait for if they'd stop immediately.  */
3760   if (non_stop)
3761     iterate_over_lwps (minus_one_ptid, resume_stopped_resumed_lwps, &ptid);
3762
3763   event_ptid = linux_nat_wait_1 (ops, ptid, ourstatus, target_options);
3764
3765   /* If we requested any event, and something came out, assume there
3766      may be more.  If we requested a specific lwp or process, also
3767      assume there may be more.  */
3768   if (target_can_async_p ()
3769       && (ourstatus->kind != TARGET_WAITKIND_IGNORE
3770           || !ptid_equal (ptid, minus_one_ptid)))
3771     async_file_mark ();
3772
3773   /* Get ready for the next event.  */
3774   if (target_can_async_p ())
3775     target_async (inferior_event_handler, 0);
3776
3777   return event_ptid;
3778 }
3779
3780 static int
3781 kill_callback (struct lwp_info *lp, void *data)
3782 {
3783   errno = 0;
3784   ptrace (PTRACE_KILL, GET_LWP (lp->ptid), 0, 0);
3785   if (debug_linux_nat)
3786     fprintf_unfiltered (gdb_stdlog,
3787                         "KC:  PTRACE_KILL %s, 0, 0 (%s)\n",
3788                         target_pid_to_str (lp->ptid),
3789                         errno ? safe_strerror (errno) : "OK");
3790
3791   return 0;
3792 }
3793
3794 static int
3795 kill_wait_callback (struct lwp_info *lp, void *data)
3796 {
3797   pid_t pid;
3798
3799   /* We must make sure that there are no pending events (delayed
3800      SIGSTOPs, pending SIGTRAPs, etc.) to make sure the current
3801      program doesn't interfere with any following debugging session.  */
3802
3803   /* For cloned processes we must check both with __WCLONE and
3804      without, since the exit status of a cloned process isn't reported
3805      with __WCLONE.  */
3806   if (lp->cloned)
3807     {
3808       do
3809         {
3810           pid = my_waitpid (GET_LWP (lp->ptid), NULL, __WCLONE);
3811           if (pid != (pid_t) -1)
3812             {
3813               if (debug_linux_nat)
3814                 fprintf_unfiltered (gdb_stdlog,
3815                                     "KWC: wait %s received unknown.\n",
3816                                     target_pid_to_str (lp->ptid));
3817               /* The Linux kernel sometimes fails to kill a thread
3818                  completely after PTRACE_KILL; that goes from the stop
3819                  point in do_fork out to the one in
3820                  get_signal_to_deliever and waits again.  So kill it
3821                  again.  */
3822               kill_callback (lp, NULL);
3823             }
3824         }
3825       while (pid == GET_LWP (lp->ptid));
3826
3827       gdb_assert (pid == -1 && errno == ECHILD);
3828     }
3829
3830   do
3831     {
3832       pid = my_waitpid (GET_LWP (lp->ptid), NULL, 0);
3833       if (pid != (pid_t) -1)
3834         {
3835           if (debug_linux_nat)
3836             fprintf_unfiltered (gdb_stdlog,
3837                                 "KWC: wait %s received unk.\n",
3838                                 target_pid_to_str (lp->ptid));
3839           /* See the call to kill_callback above.  */
3840           kill_callback (lp, NULL);
3841         }
3842     }
3843   while (pid == GET_LWP (lp->ptid));
3844
3845   gdb_assert (pid == -1 && errno == ECHILD);
3846   return 0;
3847 }
3848
3849 static void
3850 linux_nat_kill (struct target_ops *ops)
3851 {
3852   struct target_waitstatus last;
3853   ptid_t last_ptid;
3854   int status;
3855
3856   /* If we're stopped while forking and we haven't followed yet,
3857      kill the other task.  We need to do this first because the
3858      parent will be sleeping if this is a vfork.  */
3859
3860   get_last_target_status (&last_ptid, &last);
3861
3862   if (last.kind == TARGET_WAITKIND_FORKED
3863       || last.kind == TARGET_WAITKIND_VFORKED)
3864     {
3865       ptrace (PT_KILL, PIDGET (last.value.related_pid), 0, 0);
3866       wait (&status);
3867     }
3868
3869   if (forks_exist_p ())
3870     linux_fork_killall ();
3871   else
3872     {
3873       ptid_t ptid = pid_to_ptid (ptid_get_pid (inferior_ptid));
3874
3875       /* Stop all threads before killing them, since ptrace requires
3876          that the thread is stopped to sucessfully PTRACE_KILL.  */
3877       iterate_over_lwps (ptid, stop_callback, NULL);
3878       /* ... and wait until all of them have reported back that
3879          they're no longer running.  */
3880       iterate_over_lwps (ptid, stop_wait_callback, NULL);
3881
3882       /* Kill all LWP's ...  */
3883       iterate_over_lwps (ptid, kill_callback, NULL);
3884
3885       /* ... and wait until we've flushed all events.  */
3886       iterate_over_lwps (ptid, kill_wait_callback, NULL);
3887     }
3888
3889   target_mourn_inferior ();
3890 }
3891
3892 static void
3893 linux_nat_mourn_inferior (struct target_ops *ops)
3894 {
3895   purge_lwp_list (ptid_get_pid (inferior_ptid));
3896
3897   if (! forks_exist_p ())
3898     /* Normal case, no other forks available.  */
3899     linux_ops->to_mourn_inferior (ops);
3900   else
3901     /* Multi-fork case.  The current inferior_ptid has exited, but
3902        there are other viable forks to debug.  Delete the exiting
3903        one and context-switch to the first available.  */
3904     linux_fork_mourn_inferior ();
3905 }
3906
3907 /* Convert a native/host siginfo object, into/from the siginfo in the
3908    layout of the inferiors' architecture.  */
3909
3910 static void
3911 siginfo_fixup (struct siginfo *siginfo, gdb_byte *inf_siginfo, int direction)
3912 {
3913   int done = 0;
3914
3915   if (linux_nat_siginfo_fixup != NULL)
3916     done = linux_nat_siginfo_fixup (siginfo, inf_siginfo, direction);
3917
3918   /* If there was no callback, or the callback didn't do anything,
3919      then just do a straight memcpy.  */
3920   if (!done)
3921     {
3922       if (direction == 1)
3923         memcpy (siginfo, inf_siginfo, sizeof (struct siginfo));
3924       else
3925         memcpy (inf_siginfo, siginfo, sizeof (struct siginfo));
3926     }
3927 }
3928
3929 static LONGEST
3930 linux_xfer_siginfo (struct target_ops *ops, enum target_object object,
3931                     const char *annex, gdb_byte *readbuf,
3932                     const gdb_byte *writebuf, ULONGEST offset, LONGEST len)
3933 {
3934   int pid;
3935   struct siginfo siginfo;
3936   gdb_byte inf_siginfo[sizeof (struct siginfo)];
3937
3938   gdb_assert (object == TARGET_OBJECT_SIGNAL_INFO);
3939   gdb_assert (readbuf || writebuf);
3940
3941   pid = GET_LWP (inferior_ptid);
3942   if (pid == 0)
3943     pid = GET_PID (inferior_ptid);
3944
3945   if (offset > sizeof (siginfo))
3946     return -1;
3947
3948   errno = 0;
3949   ptrace (PTRACE_GETSIGINFO, pid, (PTRACE_TYPE_ARG3) 0, &siginfo);
3950   if (errno != 0)
3951     return -1;
3952
3953   /* When GDB is built as a 64-bit application, ptrace writes into
3954      SIGINFO an object with 64-bit layout.  Since debugging a 32-bit
3955      inferior with a 64-bit GDB should look the same as debugging it
3956      with a 32-bit GDB, we need to convert it.  GDB core always sees
3957      the converted layout, so any read/write will have to be done
3958      post-conversion.  */
3959   siginfo_fixup (&siginfo, inf_siginfo, 0);
3960
3961   if (offset + len > sizeof (siginfo))
3962     len = sizeof (siginfo) - offset;
3963
3964   if (readbuf != NULL)
3965     memcpy (readbuf, inf_siginfo + offset, len);
3966   else
3967     {
3968       memcpy (inf_siginfo + offset, writebuf, len);
3969
3970       /* Convert back to ptrace layout before flushing it out.  */
3971       siginfo_fixup (&siginfo, inf_siginfo, 1);
3972
3973       errno = 0;
3974       ptrace (PTRACE_SETSIGINFO, pid, (PTRACE_TYPE_ARG3) 0, &siginfo);
3975       if (errno != 0)
3976         return -1;
3977     }
3978
3979   return len;
3980 }
3981
3982 static LONGEST
3983 linux_nat_xfer_partial (struct target_ops *ops, enum target_object object,
3984                         const char *annex, gdb_byte *readbuf,
3985                         const gdb_byte *writebuf,
3986                         ULONGEST offset, LONGEST len)
3987 {
3988   struct cleanup *old_chain;
3989   LONGEST xfer;
3990
3991   if (object == TARGET_OBJECT_SIGNAL_INFO)
3992     return linux_xfer_siginfo (ops, object, annex, readbuf, writebuf,
3993                                offset, len);
3994
3995   /* The target is connected but no live inferior is selected.  Pass
3996      this request down to a lower stratum (e.g., the executable
3997      file).  */
3998   if (object == TARGET_OBJECT_MEMORY && ptid_equal (inferior_ptid, null_ptid))
3999     return 0;
4000
4001   old_chain = save_inferior_ptid ();
4002
4003   if (is_lwp (inferior_ptid))
4004     inferior_ptid = pid_to_ptid (GET_LWP (inferior_ptid));
4005
4006   xfer = linux_ops->to_xfer_partial (ops, object, annex, readbuf, writebuf,
4007                                      offset, len);
4008
4009   do_cleanups (old_chain);
4010   return xfer;
4011 }
4012
4013 static int
4014 linux_thread_alive (ptid_t ptid)
4015 {
4016   int err, tmp_errno;
4017
4018   gdb_assert (is_lwp (ptid));
4019
4020   /* Send signal 0 instead of anything ptrace, because ptracing a
4021      running thread errors out claiming that the thread doesn't
4022      exist.  */
4023   err = kill_lwp (GET_LWP (ptid), 0);
4024   tmp_errno = errno;
4025   if (debug_linux_nat)
4026     fprintf_unfiltered (gdb_stdlog,
4027                         "LLTA: KILL(SIG0) %s (%s)\n",
4028                         target_pid_to_str (ptid),
4029                         err ? safe_strerror (tmp_errno) : "OK");
4030
4031   if (err != 0)
4032     return 0;
4033
4034   return 1;
4035 }
4036
4037 static int
4038 linux_nat_thread_alive (struct target_ops *ops, ptid_t ptid)
4039 {
4040   return linux_thread_alive (ptid);
4041 }
4042
4043 static char *
4044 linux_nat_pid_to_str (struct target_ops *ops, ptid_t ptid)
4045 {
4046   static char buf[64];
4047
4048   if (is_lwp (ptid)
4049       && (GET_PID (ptid) != GET_LWP (ptid)
4050           || num_lwps (GET_PID (ptid)) > 1))
4051     {
4052       snprintf (buf, sizeof (buf), "LWP %ld", GET_LWP (ptid));
4053       return buf;
4054     }
4055
4056   return normal_pid_to_str (ptid);
4057 }
4058
4059 static char *
4060 linux_nat_thread_name (struct thread_info *thr)
4061 {
4062   int pid = ptid_get_pid (thr->ptid);
4063   long lwp = ptid_get_lwp (thr->ptid);
4064 #define FORMAT "/proc/%d/task/%ld/comm"
4065   char buf[sizeof (FORMAT) + 30];
4066   FILE *comm_file;
4067   char *result = NULL;
4068
4069   snprintf (buf, sizeof (buf), FORMAT, pid, lwp);
4070   comm_file = fopen (buf, "r");
4071   if (comm_file)
4072     {
4073       /* Not exported by the kernel, so we define it here.  */
4074 #define COMM_LEN 16
4075       static char line[COMM_LEN + 1];
4076
4077       if (fgets (line, sizeof (line), comm_file))
4078         {
4079           char *nl = strchr (line, '\n');
4080
4081           if (nl)
4082             *nl = '\0';
4083           if (*line != '\0')
4084             result = line;
4085         }
4086
4087       fclose (comm_file);
4088     }
4089
4090 #undef COMM_LEN
4091 #undef FORMAT
4092
4093   return result;
4094 }
4095
4096 /* Accepts an integer PID; Returns a string representing a file that
4097    can be opened to get the symbols for the child process.  */
4098
4099 static char *
4100 linux_child_pid_to_exec_file (int pid)
4101 {
4102   char *name1, *name2;
4103
4104   name1 = xmalloc (MAXPATHLEN);
4105   name2 = xmalloc (MAXPATHLEN);
4106   make_cleanup (xfree, name1);
4107   make_cleanup (xfree, name2);
4108   memset (name2, 0, MAXPATHLEN);
4109
4110   sprintf (name1, "/proc/%d/exe", pid);
4111   if (readlink (name1, name2, MAXPATHLEN) > 0)
4112     return name2;
4113   else
4114     return name1;
4115 }
4116
4117 /* Service function for corefiles and info proc.  */
4118
4119 static int
4120 read_mapping (FILE *mapfile,
4121               long long *addr,
4122               long long *endaddr,
4123               char *permissions,
4124               long long *offset,
4125               char *device, long long *inode, char *filename)
4126 {
4127   int ret = fscanf (mapfile, "%llx-%llx %s %llx %s %llx",
4128                     addr, endaddr, permissions, offset, device, inode);
4129
4130   filename[0] = '\0';
4131   if (ret > 0 && ret != EOF)
4132     {
4133       /* Eat everything up to EOL for the filename.  This will prevent
4134          weird filenames (such as one with embedded whitespace) from
4135          confusing this code.  It also makes this code more robust in
4136          respect to annotations the kernel may add after the filename.
4137
4138          Note the filename is used for informational purposes
4139          only.  */
4140       ret += fscanf (mapfile, "%[^\n]\n", filename);
4141     }
4142
4143   return (ret != 0 && ret != EOF);
4144 }
4145
4146 /* Fills the "to_find_memory_regions" target vector.  Lists the memory
4147    regions in the inferior for a corefile.  */
4148
4149 static int
4150 linux_nat_find_memory_regions (find_memory_region_ftype func, void *obfd)
4151 {
4152   int pid = PIDGET (inferior_ptid);
4153   char mapsfilename[MAXPATHLEN];
4154   FILE *mapsfile;
4155   long long addr, endaddr, size, offset, inode;
4156   char permissions[8], device[8], filename[MAXPATHLEN];
4157   int read, write, exec;
4158   struct cleanup *cleanup;
4159
4160   /* Compose the filename for the /proc memory map, and open it.  */
4161   sprintf (mapsfilename, "/proc/%d/maps", pid);
4162   if ((mapsfile = fopen (mapsfilename, "r")) == NULL)
4163     error (_("Could not open %s."), mapsfilename);
4164   cleanup = make_cleanup_fclose (mapsfile);
4165
4166   if (info_verbose)
4167     fprintf_filtered (gdb_stdout,
4168                       "Reading memory regions from %s\n", mapsfilename);
4169
4170   /* Now iterate until end-of-file.  */
4171   while (read_mapping (mapsfile, &addr, &endaddr, &permissions[0],
4172                        &offset, &device[0], &inode, &filename[0]))
4173     {
4174       size = endaddr - addr;
4175
4176       /* Get the segment's permissions.  */
4177       read = (strchr (permissions, 'r') != 0);
4178       write = (strchr (permissions, 'w') != 0);
4179       exec = (strchr (permissions, 'x') != 0);
4180
4181       if (info_verbose)
4182         {
4183           fprintf_filtered (gdb_stdout,
4184                             "Save segment, %s bytes at %s (%c%c%c)",
4185                             plongest (size), paddress (target_gdbarch, addr),
4186                             read ? 'r' : ' ',
4187                             write ? 'w' : ' ', exec ? 'x' : ' ');
4188           if (filename[0])
4189             fprintf_filtered (gdb_stdout, " for %s", filename);
4190           fprintf_filtered (gdb_stdout, "\n");
4191         }
4192
4193       /* Invoke the callback function to create the corefile
4194          segment.  */
4195       func (addr, size, read, write, exec, obfd);
4196     }
4197   do_cleanups (cleanup);
4198   return 0;
4199 }
4200
4201 static int
4202 find_signalled_thread (struct thread_info *info, void *data)
4203 {
4204   if (info->suspend.stop_signal != TARGET_SIGNAL_0
4205       && ptid_get_pid (info->ptid) == ptid_get_pid (inferior_ptid))
4206     return 1;
4207
4208   return 0;
4209 }
4210
4211 static enum target_signal
4212 find_stop_signal (void)
4213 {
4214   struct thread_info *info =
4215     iterate_over_threads (find_signalled_thread, NULL);
4216
4217   if (info)
4218     return info->suspend.stop_signal;
4219   else
4220     return TARGET_SIGNAL_0;
4221 }
4222
4223 /* Records the thread's register state for the corefile note
4224    section.  */
4225
4226 static char *
4227 linux_nat_do_thread_registers (bfd *obfd, ptid_t ptid,
4228                                char *note_data, int *note_size,
4229                                enum target_signal stop_signal)
4230 {
4231   unsigned long lwp = ptid_get_lwp (ptid);
4232   struct gdbarch *gdbarch = target_gdbarch;
4233   struct regcache *regcache = get_thread_arch_regcache (ptid, gdbarch);
4234   const struct regset *regset;
4235   int core_regset_p;
4236   struct cleanup *old_chain;
4237   struct core_regset_section *sect_list;
4238   char *gdb_regset;
4239
4240   old_chain = save_inferior_ptid ();
4241   inferior_ptid = ptid;
4242   target_fetch_registers (regcache, -1);
4243   do_cleanups (old_chain);
4244
4245   core_regset_p = gdbarch_regset_from_core_section_p (gdbarch);
4246   sect_list = gdbarch_core_regset_sections (gdbarch);
4247
4248   /* The loop below uses the new struct core_regset_section, which stores
4249      the supported section names and sizes for the core file.  Note that
4250      note PRSTATUS needs to be treated specially.  But the other notes are
4251      structurally the same, so they can benefit from the new struct.  */
4252   if (core_regset_p && sect_list != NULL)
4253     while (sect_list->sect_name != NULL)
4254       {
4255         regset = gdbarch_regset_from_core_section (gdbarch,
4256                                                    sect_list->sect_name,
4257                                                    sect_list->size);
4258         gdb_assert (regset && regset->collect_regset);
4259         gdb_regset = xmalloc (sect_list->size);
4260         regset->collect_regset (regset, regcache, -1,
4261                                 gdb_regset, sect_list->size);
4262
4263         if (strcmp (sect_list->sect_name, ".reg") == 0)
4264           note_data = (char *) elfcore_write_prstatus
4265                                 (obfd, note_data, note_size,
4266                                  lwp, target_signal_to_host (stop_signal),
4267                                  gdb_regset);
4268         else
4269           note_data = (char *) elfcore_write_register_note
4270                                 (obfd, note_data, note_size,
4271                                  sect_list->sect_name, gdb_regset,
4272                                  sect_list->size);
4273         xfree (gdb_regset);
4274         sect_list++;
4275       }
4276
4277   /* For architectures that does not have the struct core_regset_section
4278      implemented, we use the old method.  When all the architectures have
4279      the new support, the code below should be deleted.  */
4280   else
4281     {
4282       gdb_gregset_t gregs;
4283       gdb_fpregset_t fpregs;
4284
4285       if (core_regset_p
4286           && (regset = gdbarch_regset_from_core_section (gdbarch, ".reg",
4287                                                          sizeof (gregs)))
4288           != NULL && regset->collect_regset != NULL)
4289         regset->collect_regset (regset, regcache, -1,
4290                                 &gregs, sizeof (gregs));
4291       else
4292         fill_gregset (regcache, &gregs, -1);
4293
4294       note_data = (char *) elfcore_write_prstatus
4295         (obfd, note_data, note_size, lwp, target_signal_to_host (stop_signal),
4296          &gregs);
4297
4298       if (core_regset_p
4299           && (regset = gdbarch_regset_from_core_section (gdbarch, ".reg2",
4300                                                          sizeof (fpregs)))
4301           != NULL && regset->collect_regset != NULL)
4302         regset->collect_regset (regset, regcache, -1,
4303                                 &fpregs, sizeof (fpregs));
4304       else
4305         fill_fpregset (regcache, &fpregs, -1);
4306
4307       note_data = (char *) elfcore_write_prfpreg (obfd,
4308                                                   note_data,
4309                                                   note_size,
4310                                                   &fpregs, sizeof (fpregs));
4311     }
4312
4313   return note_data;
4314 }
4315
4316 struct linux_nat_corefile_thread_data
4317 {
4318   bfd *obfd;
4319   char *note_data;
4320   int *note_size;
4321   int num_notes;
4322   enum target_signal stop_signal;
4323 };
4324
4325 /* Called by gdbthread.c once per thread.  Records the thread's
4326    register state for the corefile note section.  */
4327
4328 static int
4329 linux_nat_corefile_thread_callback (struct lwp_info *ti, void *data)
4330 {
4331   struct linux_nat_corefile_thread_data *args = data;
4332
4333   args->note_data = linux_nat_do_thread_registers (args->obfd,
4334                                                    ti->ptid,
4335                                                    args->note_data,
4336                                                    args->note_size,
4337                                                    args->stop_signal);
4338   args->num_notes++;
4339
4340   return 0;
4341 }
4342
4343 /* Enumerate spufs IDs for process PID.  */
4344
4345 static void
4346 iterate_over_spus (int pid, void (*callback) (void *, int), void *data)
4347 {
4348   char path[128];
4349   DIR *dir;
4350   struct dirent *entry;
4351
4352   xsnprintf (path, sizeof path, "/proc/%d/fd", pid);
4353   dir = opendir (path);
4354   if (!dir)
4355     return;
4356
4357   rewinddir (dir);
4358   while ((entry = readdir (dir)) != NULL)
4359     {
4360       struct stat st;
4361       struct statfs stfs;
4362       int fd;
4363
4364       fd = atoi (entry->d_name);
4365       if (!fd)
4366         continue;
4367
4368       xsnprintf (path, sizeof path, "/proc/%d/fd/%d", pid, fd);
4369       if (stat (path, &st) != 0)
4370         continue;
4371       if (!S_ISDIR (st.st_mode))
4372         continue;
4373
4374       if (statfs (path, &stfs) != 0)
4375         continue;
4376       if (stfs.f_type != SPUFS_MAGIC)
4377         continue;
4378
4379       callback (data, fd);
4380     }
4381
4382   closedir (dir);
4383 }
4384
4385 /* Generate corefile notes for SPU contexts.  */
4386
4387 struct linux_spu_corefile_data
4388 {
4389   bfd *obfd;
4390   char *note_data;
4391   int *note_size;
4392 };
4393
4394 static void
4395 linux_spu_corefile_callback (void *data, int fd)
4396 {
4397   struct linux_spu_corefile_data *args = data;
4398   int i;
4399
4400   static const char *spu_files[] =
4401     {
4402       "object-id",
4403       "mem",
4404       "regs",
4405       "fpcr",
4406       "lslr",
4407       "decr",
4408       "decr_status",
4409       "signal1",
4410       "signal1_type",
4411       "signal2",
4412       "signal2_type",
4413       "event_mask",
4414       "event_status",
4415       "mbox_info",
4416       "ibox_info",
4417       "wbox_info",
4418       "dma_info",
4419       "proxydma_info",
4420    };
4421
4422   for (i = 0; i < sizeof (spu_files) / sizeof (spu_files[0]); i++)
4423     {
4424       char annex[32], note_name[32];
4425       gdb_byte *spu_data;
4426       LONGEST spu_len;
4427
4428       xsnprintf (annex, sizeof annex, "%d/%s", fd, spu_files[i]);
4429       spu_len = target_read_alloc (&current_target, TARGET_OBJECT_SPU,
4430                                    annex, &spu_data);
4431       if (spu_len > 0)
4432         {
4433           xsnprintf (note_name, sizeof note_name, "SPU/%s", annex);
4434           args->note_data = elfcore_write_note (args->obfd, args->note_data,
4435                                                 args->note_size, note_name,
4436                                                 NT_SPU, spu_data, spu_len);
4437           xfree (spu_data);
4438         }
4439     }
4440 }
4441
4442 static char *
4443 linux_spu_make_corefile_notes (bfd *obfd, char *note_data, int *note_size)
4444 {
4445   struct linux_spu_corefile_data args;
4446
4447   args.obfd = obfd;
4448   args.note_data = note_data;
4449   args.note_size = note_size;
4450
4451   iterate_over_spus (PIDGET (inferior_ptid),
4452                      linux_spu_corefile_callback, &args);
4453
4454   return args.note_data;
4455 }
4456
4457 /* Fills the "to_make_corefile_note" target vector.  Builds the note
4458    section for a corefile, and returns it in a malloc buffer.  */
4459
4460 static char *
4461 linux_nat_make_corefile_notes (bfd *obfd, int *note_size)
4462 {
4463   struct linux_nat_corefile_thread_data thread_args;
4464   /* The variable size must be >= sizeof (prpsinfo_t.pr_fname).  */
4465   char fname[16] = { '\0' };
4466   /* The variable size must be >= sizeof (prpsinfo_t.pr_psargs).  */
4467   char psargs[80] = { '\0' };
4468   char *note_data = NULL;
4469   ptid_t filter = pid_to_ptid (ptid_get_pid (inferior_ptid));
4470   gdb_byte *auxv;
4471   int auxv_len;
4472
4473   if (get_exec_file (0))
4474     {
4475       strncpy (fname, lbasename (get_exec_file (0)), sizeof (fname));
4476       strncpy (psargs, get_exec_file (0), sizeof (psargs));
4477       if (get_inferior_args ())
4478         {
4479           char *string_end;
4480           char *psargs_end = psargs + sizeof (psargs);
4481
4482           /* linux_elfcore_write_prpsinfo () handles zero unterminated
4483              strings fine.  */
4484           string_end = memchr (psargs, 0, sizeof (psargs));
4485           if (string_end != NULL)
4486             {
4487               *string_end++ = ' ';
4488               strncpy (string_end, get_inferior_args (),
4489                        psargs_end - string_end);
4490             }
4491         }
4492       note_data = (char *) elfcore_write_prpsinfo (obfd,
4493                                                    note_data,
4494                                                    note_size, fname, psargs);
4495     }
4496
4497   /* Dump information for threads.  */
4498   thread_args.obfd = obfd;
4499   thread_args.note_data = note_data;
4500   thread_args.note_size = note_size;
4501   thread_args.num_notes = 0;
4502   thread_args.stop_signal = find_stop_signal ();
4503   iterate_over_lwps (filter, linux_nat_corefile_thread_callback, &thread_args);
4504   gdb_assert (thread_args.num_notes != 0);
4505   note_data = thread_args.note_data;
4506
4507   auxv_len = target_read_alloc (&current_target, TARGET_OBJECT_AUXV,
4508                                 NULL, &auxv);
4509   if (auxv_len > 0)
4510     {
4511       note_data = elfcore_write_note (obfd, note_data, note_size,
4512                                       "CORE", NT_AUXV, auxv, auxv_len);
4513       xfree (auxv);
4514     }
4515
4516   note_data = linux_spu_make_corefile_notes (obfd, note_data, note_size);
4517
4518   make_cleanup (xfree, note_data);
4519   return note_data;
4520 }
4521
4522 /* Implement the "info proc" command.  */
4523
4524 static void
4525 linux_nat_info_proc_cmd (char *args, int from_tty)
4526 {
4527   /* A long is used for pid instead of an int to avoid a loss of precision
4528      compiler warning from the output of strtoul.  */
4529   long pid = PIDGET (inferior_ptid);
4530   FILE *procfile;
4531   char **argv = NULL;
4532   char buffer[MAXPATHLEN];
4533   char fname1[MAXPATHLEN], fname2[MAXPATHLEN];
4534   int cmdline_f = 1;
4535   int cwd_f = 1;
4536   int exe_f = 1;
4537   int mappings_f = 0;
4538   int status_f = 0;
4539   int stat_f = 0;
4540   int all = 0;
4541   struct stat dummy;
4542
4543   if (args)
4544     {
4545       /* Break up 'args' into an argv array.  */
4546       argv = gdb_buildargv (args);
4547       make_cleanup_freeargv (argv);
4548     }
4549   while (argv != NULL && *argv != NULL)
4550     {
4551       if (isdigit (argv[0][0]))
4552         {
4553           pid = strtoul (argv[0], NULL, 10);
4554         }
4555       else if (strncmp (argv[0], "mappings", strlen (argv[0])) == 0)
4556         {
4557           mappings_f = 1;
4558         }
4559       else if (strcmp (argv[0], "status") == 0)
4560         {
4561           status_f = 1;
4562         }
4563       else if (strcmp (argv[0], "stat") == 0)
4564         {
4565           stat_f = 1;
4566         }
4567       else if (strcmp (argv[0], "cmd") == 0)
4568         {
4569           cmdline_f = 1;
4570         }
4571       else if (strncmp (argv[0], "exe", strlen (argv[0])) == 0)
4572         {
4573           exe_f = 1;
4574         }
4575       else if (strcmp (argv[0], "cwd") == 0)
4576         {
4577           cwd_f = 1;
4578         }
4579       else if (strncmp (argv[0], "all", strlen (argv[0])) == 0)
4580         {
4581           all = 1;
4582         }
4583       else
4584         {
4585           /* [...] (future options here).  */
4586         }
4587       argv++;
4588     }
4589   if (pid == 0)
4590     error (_("No current process: you must name one."));
4591
4592   sprintf (fname1, "/proc/%ld", pid);
4593   if (stat (fname1, &dummy) != 0)
4594     error (_("No /proc directory: '%s'"), fname1);
4595
4596   printf_filtered (_("process %ld\n"), pid);
4597   if (cmdline_f || all)
4598     {
4599       sprintf (fname1, "/proc/%ld/cmdline", pid);
4600       if ((procfile = fopen (fname1, "r")) != NULL)
4601         {
4602           struct cleanup *cleanup = make_cleanup_fclose (procfile);
4603
4604           if (fgets (buffer, sizeof (buffer), procfile))
4605             printf_filtered ("cmdline = '%s'\n", buffer);
4606           else
4607             warning (_("unable to read '%s'"), fname1);
4608           do_cleanups (cleanup);
4609         }
4610       else
4611         warning (_("unable to open /proc file '%s'"), fname1);
4612     }
4613   if (cwd_f || all)
4614     {
4615       sprintf (fname1, "/proc/%ld/cwd", pid);
4616       memset (fname2, 0, sizeof (fname2));
4617       if (readlink (fname1, fname2, sizeof (fname2)) > 0)
4618         printf_filtered ("cwd = '%s'\n", fname2);
4619       else
4620         warning (_("unable to read link '%s'"), fname1);
4621     }
4622   if (exe_f || all)
4623     {
4624       sprintf (fname1, "/proc/%ld/exe", pid);
4625       memset (fname2, 0, sizeof (fname2));
4626       if (readlink (fname1, fname2, sizeof (fname2)) > 0)
4627         printf_filtered ("exe = '%s'\n", fname2);
4628       else
4629         warning (_("unable to read link '%s'"), fname1);
4630     }
4631   if (mappings_f || all)
4632     {
4633       sprintf (fname1, "/proc/%ld/maps", pid);
4634       if ((procfile = fopen (fname1, "r")) != NULL)
4635         {
4636           long long addr, endaddr, size, offset, inode;
4637           char permissions[8], device[8], filename[MAXPATHLEN];
4638           struct cleanup *cleanup;
4639
4640           cleanup = make_cleanup_fclose (procfile);
4641           printf_filtered (_("Mapped address spaces:\n\n"));
4642           if (gdbarch_addr_bit (target_gdbarch) == 32)
4643             {
4644               printf_filtered ("\t%10s %10s %10s %10s %7s\n",
4645                            "Start Addr",
4646                            "  End Addr",
4647                            "      Size", "    Offset", "objfile");
4648             }
4649           else
4650             {
4651               printf_filtered ("  %18s %18s %10s %10s %7s\n",
4652                            "Start Addr",
4653                            "  End Addr",
4654                            "      Size", "    Offset", "objfile");
4655             }
4656
4657           while (read_mapping (procfile, &addr, &endaddr, &permissions[0],
4658                                &offset, &device[0], &inode, &filename[0]))
4659             {
4660               size = endaddr - addr;
4661
4662               /* FIXME: carlton/2003-08-27: Maybe the printf_filtered
4663                  calls here (and possibly above) should be abstracted
4664                  out into their own functions?  Andrew suggests using
4665                  a generic local_address_string instead to print out
4666                  the addresses; that makes sense to me, too.  */
4667
4668               if (gdbarch_addr_bit (target_gdbarch) == 32)
4669                 {
4670                   printf_filtered ("\t%#10lx %#10lx %#10x %#10x %7s\n",
4671                                (unsigned long) addr,    /* FIXME: pr_addr */
4672                                (unsigned long) endaddr,
4673                                (int) size,
4674                                (unsigned int) offset,
4675                                filename[0] ? filename : "");
4676                 }
4677               else
4678                 {
4679                   printf_filtered ("  %#18lx %#18lx %#10x %#10x %7s\n",
4680                                (unsigned long) addr,    /* FIXME: pr_addr */
4681                                (unsigned long) endaddr,
4682                                (int) size,
4683                                (unsigned int) offset,
4684                                filename[0] ? filename : "");
4685                 }
4686             }
4687
4688           do_cleanups (cleanup);
4689         }
4690       else
4691         warning (_("unable to open /proc file '%s'"), fname1);
4692     }
4693   if (status_f || all)
4694     {
4695       sprintf (fname1, "/proc/%ld/status", pid);
4696       if ((procfile = fopen (fname1, "r")) != NULL)
4697         {
4698           struct cleanup *cleanup = make_cleanup_fclose (procfile);
4699
4700           while (fgets (buffer, sizeof (buffer), procfile) != NULL)
4701             puts_filtered (buffer);
4702           do_cleanups (cleanup);
4703         }
4704       else
4705         warning (_("unable to open /proc file '%s'"), fname1);
4706     }
4707   if (stat_f || all)
4708     {
4709       sprintf (fname1, "/proc/%ld/stat", pid);
4710       if ((procfile = fopen (fname1, "r")) != NULL)
4711         {
4712           int itmp;
4713           char ctmp;
4714           long ltmp;
4715           struct cleanup *cleanup = make_cleanup_fclose (procfile);
4716
4717           if (fscanf (procfile, "%d ", &itmp) > 0)
4718             printf_filtered (_("Process: %d\n"), itmp);
4719           if (fscanf (procfile, "(%[^)]) ", &buffer[0]) > 0)
4720             printf_filtered (_("Exec file: %s\n"), buffer);
4721           if (fscanf (procfile, "%c ", &ctmp) > 0)
4722             printf_filtered (_("State: %c\n"), ctmp);
4723           if (fscanf (procfile, "%d ", &itmp) > 0)
4724             printf_filtered (_("Parent process: %d\n"), itmp);
4725           if (fscanf (procfile, "%d ", &itmp) > 0)
4726             printf_filtered (_("Process group: %d\n"), itmp);
4727           if (fscanf (procfile, "%d ", &itmp) > 0)
4728             printf_filtered (_("Session id: %d\n"), itmp);
4729           if (fscanf (procfile, "%d ", &itmp) > 0)
4730             printf_filtered (_("TTY: %d\n"), itmp);
4731           if (fscanf (procfile, "%d ", &itmp) > 0)
4732             printf_filtered (_("TTY owner process group: %d\n"), itmp);
4733           if (fscanf (procfile, "%lu ", &ltmp) > 0)
4734             printf_filtered (_("Flags: 0x%lx\n"), ltmp);
4735           if (fscanf (procfile, "%lu ", &ltmp) > 0)
4736             printf_filtered (_("Minor faults (no memory page): %lu\n"),
4737                              (unsigned long) ltmp);
4738           if (fscanf (procfile, "%lu ", &ltmp) > 0)
4739             printf_filtered (_("Minor faults, children: %lu\n"),
4740                              (unsigned long) ltmp);
4741           if (fscanf (procfile, "%lu ", &ltmp) > 0)
4742             printf_filtered (_("Major faults (memory page faults): %lu\n"),
4743                              (unsigned long) ltmp);
4744           if (fscanf (procfile, "%lu ", &ltmp) > 0)
4745             printf_filtered (_("Major faults, children: %lu\n"),
4746                              (unsigned long) ltmp);
4747           if (fscanf (procfile, "%ld ", &ltmp) > 0)
4748             printf_filtered (_("utime: %ld\n"), ltmp);
4749           if (fscanf (procfile, "%ld ", &ltmp) > 0)
4750             printf_filtered (_("stime: %ld\n"), ltmp);
4751           if (fscanf (procfile, "%ld ", &ltmp) > 0)
4752             printf_filtered (_("utime, children: %ld\n"), ltmp);
4753           if (fscanf (procfile, "%ld ", &ltmp) > 0)
4754             printf_filtered (_("stime, children: %ld\n"), ltmp);
4755           if (fscanf (procfile, "%ld ", &ltmp) > 0)
4756             printf_filtered (_("jiffies remaining in current "
4757                                "time slice: %ld\n"), ltmp);
4758           if (fscanf (procfile, "%ld ", &ltmp) > 0)
4759             printf_filtered (_("'nice' value: %ld\n"), ltmp);
4760           if (fscanf (procfile, "%lu ", &ltmp) > 0)
4761             printf_filtered (_("jiffies until next timeout: %lu\n"),
4762                              (unsigned long) ltmp);
4763           if (fscanf (procfile, "%lu ", &ltmp) > 0)
4764             printf_filtered (_("jiffies until next SIGALRM: %lu\n"),
4765                              (unsigned long) ltmp);
4766           if (fscanf (procfile, "%ld ", &ltmp) > 0)
4767             printf_filtered (_("start time (jiffies since "
4768                                "system boot): %ld\n"), ltmp);
4769           if (fscanf (procfile, "%lu ", &ltmp) > 0)
4770             printf_filtered (_("Virtual memory size: %lu\n"),
4771                              (unsigned long) ltmp);
4772           if (fscanf (procfile, "%lu ", &ltmp) > 0)
4773             printf_filtered (_("Resident set size: %lu\n"),
4774                              (unsigned long) ltmp);
4775           if (fscanf (procfile, "%lu ", &ltmp) > 0)
4776             printf_filtered (_("rlim: %lu\n"), (unsigned long) ltmp);
4777           if (fscanf (procfile, "%lu ", &ltmp) > 0)
4778             printf_filtered (_("Start of text: 0x%lx\n"), ltmp);
4779           if (fscanf (procfile, "%lu ", &ltmp) > 0)
4780             printf_filtered (_("End of text: 0x%lx\n"), ltmp);
4781           if (fscanf (procfile, "%lu ", &ltmp) > 0)
4782             printf_filtered (_("Start of stack: 0x%lx\n"), ltmp);
4783 #if 0   /* Don't know how architecture-dependent the rest is...
4784            Anyway the signal bitmap info is available from "status".  */
4785           if (fscanf (procfile, "%lu ", &ltmp) > 0)     /* FIXME arch?  */
4786             printf_filtered (_("Kernel stack pointer: 0x%lx\n"), ltmp);
4787           if (fscanf (procfile, "%lu ", &ltmp) > 0)     /* FIXME arch?  */
4788             printf_filtered (_("Kernel instr pointer: 0x%lx\n"), ltmp);
4789           if (fscanf (procfile, "%ld ", &ltmp) > 0)
4790             printf_filtered (_("Pending signals bitmap: 0x%lx\n"), ltmp);
4791           if (fscanf (procfile, "%ld ", &ltmp) > 0)
4792             printf_filtered (_("Blocked signals bitmap: 0x%lx\n"), ltmp);
4793           if (fscanf (procfile, "%ld ", &ltmp) > 0)
4794             printf_filtered (_("Ignored signals bitmap: 0x%lx\n"), ltmp);
4795           if (fscanf (procfile, "%ld ", &ltmp) > 0)
4796             printf_filtered (_("Catched signals bitmap: 0x%lx\n"), ltmp);
4797           if (fscanf (procfile, "%lu ", &ltmp) > 0)     /* FIXME arch?  */
4798             printf_filtered (_("wchan (system call): 0x%lx\n"), ltmp);
4799 #endif
4800           do_cleanups (cleanup);
4801         }
4802       else
4803         warning (_("unable to open /proc file '%s'"), fname1);
4804     }
4805 }
4806
4807 /* Implement the to_xfer_partial interface for memory reads using the /proc
4808    filesystem.  Because we can use a single read() call for /proc, this
4809    can be much more efficient than banging away at PTRACE_PEEKTEXT,
4810    but it doesn't support writes.  */
4811
4812 static LONGEST
4813 linux_proc_xfer_partial (struct target_ops *ops, enum target_object object,
4814                          const char *annex, gdb_byte *readbuf,
4815                          const gdb_byte *writebuf,
4816                          ULONGEST offset, LONGEST len)
4817 {
4818   LONGEST ret;
4819   int fd;
4820   char filename[64];
4821
4822   if (object != TARGET_OBJECT_MEMORY || !readbuf)
4823     return 0;
4824
4825   /* Don't bother for one word.  */
4826   if (len < 3 * sizeof (long))
4827     return 0;
4828
4829   /* We could keep this file open and cache it - possibly one per
4830      thread.  That requires some juggling, but is even faster.  */
4831   sprintf (filename, "/proc/%d/mem", PIDGET (inferior_ptid));
4832   fd = open (filename, O_RDONLY | O_LARGEFILE);
4833   if (fd == -1)
4834     return 0;
4835
4836   /* If pread64 is available, use it.  It's faster if the kernel
4837      supports it (only one syscall), and it's 64-bit safe even on
4838      32-bit platforms (for instance, SPARC debugging a SPARC64
4839      application).  */
4840 #ifdef HAVE_PREAD64
4841   if (pread64 (fd, readbuf, len, offset) != len)
4842 #else
4843   if (lseek (fd, offset, SEEK_SET) == -1 || read (fd, readbuf, len) != len)
4844 #endif
4845     ret = 0;
4846   else
4847     ret = len;
4848
4849   close (fd);
4850   return ret;
4851 }
4852
4853
4854 /* Enumerate spufs IDs for process PID.  */
4855 static LONGEST
4856 spu_enumerate_spu_ids (int pid, gdb_byte *buf, ULONGEST offset, LONGEST len)
4857 {
4858   enum bfd_endian byte_order = gdbarch_byte_order (target_gdbarch);
4859   LONGEST pos = 0;
4860   LONGEST written = 0;
4861   char path[128];
4862   DIR *dir;
4863   struct dirent *entry;
4864
4865   xsnprintf (path, sizeof path, "/proc/%d/fd", pid);
4866   dir = opendir (path);
4867   if (!dir)
4868     return -1;
4869
4870   rewinddir (dir);
4871   while ((entry = readdir (dir)) != NULL)
4872     {
4873       struct stat st;
4874       struct statfs stfs;
4875       int fd;
4876
4877       fd = atoi (entry->d_name);
4878       if (!fd)
4879         continue;
4880
4881       xsnprintf (path, sizeof path, "/proc/%d/fd/%d", pid, fd);
4882       if (stat (path, &st) != 0)
4883         continue;
4884       if (!S_ISDIR (st.st_mode))
4885         continue;
4886
4887       if (statfs (path, &stfs) != 0)
4888         continue;
4889       if (stfs.f_type != SPUFS_MAGIC)
4890         continue;
4891
4892       if (pos >= offset && pos + 4 <= offset + len)
4893         {
4894           store_unsigned_integer (buf + pos - offset, 4, byte_order, fd);
4895           written += 4;
4896         }
4897       pos += 4;
4898     }
4899
4900   closedir (dir);
4901   return written;
4902 }
4903
4904 /* Implement the to_xfer_partial interface for the TARGET_OBJECT_SPU
4905    object type, using the /proc file system.  */
4906 static LONGEST
4907 linux_proc_xfer_spu (struct target_ops *ops, enum target_object object,
4908                      const char *annex, gdb_byte *readbuf,
4909                      const gdb_byte *writebuf,
4910                      ULONGEST offset, LONGEST len)
4911 {
4912   char buf[128];
4913   int fd = 0;
4914   int ret = -1;
4915   int pid = PIDGET (inferior_ptid);
4916
4917   if (!annex)
4918     {
4919       if (!readbuf)
4920         return -1;
4921       else
4922         return spu_enumerate_spu_ids (pid, readbuf, offset, len);
4923     }
4924
4925   xsnprintf (buf, sizeof buf, "/proc/%d/fd/%s", pid, annex);
4926   fd = open (buf, writebuf? O_WRONLY : O_RDONLY);
4927   if (fd <= 0)
4928     return -1;
4929
4930   if (offset != 0
4931       && lseek (fd, (off_t) offset, SEEK_SET) != (off_t) offset)
4932     {
4933       close (fd);
4934       return 0;
4935     }
4936
4937   if (writebuf)
4938     ret = write (fd, writebuf, (size_t) len);
4939   else if (readbuf)
4940     ret = read (fd, readbuf, (size_t) len);
4941
4942   close (fd);
4943   return ret;
4944 }
4945
4946
4947 /* Parse LINE as a signal set and add its set bits to SIGS.  */
4948
4949 static void
4950 add_line_to_sigset (const char *line, sigset_t *sigs)
4951 {
4952   int len = strlen (line) - 1;
4953   const char *p;
4954   int signum;
4955
4956   if (line[len] != '\n')
4957     error (_("Could not parse signal set: %s"), line);
4958
4959   p = line;
4960   signum = len * 4;
4961   while (len-- > 0)
4962     {
4963       int digit;
4964
4965       if (*p >= '0' && *p <= '9')
4966         digit = *p - '0';
4967       else if (*p >= 'a' && *p <= 'f')
4968         digit = *p - 'a' + 10;
4969       else
4970         error (_("Could not parse signal set: %s"), line);
4971
4972       signum -= 4;
4973
4974       if (digit & 1)
4975         sigaddset (sigs, signum + 1);
4976       if (digit & 2)
4977         sigaddset (sigs, signum + 2);
4978       if (digit & 4)
4979         sigaddset (sigs, signum + 3);
4980       if (digit & 8)
4981         sigaddset (sigs, signum + 4);
4982
4983       p++;
4984     }
4985 }
4986
4987 /* Find process PID's pending signals from /proc/pid/status and set
4988    SIGS to match.  */
4989
4990 void
4991 linux_proc_pending_signals (int pid, sigset_t *pending,
4992                             sigset_t *blocked, sigset_t *ignored)
4993 {
4994   FILE *procfile;
4995   char buffer[MAXPATHLEN], fname[MAXPATHLEN];
4996   struct cleanup *cleanup;
4997
4998   sigemptyset (pending);
4999   sigemptyset (blocked);
5000   sigemptyset (ignored);
5001   sprintf (fname, "/proc/%d/status", pid);
5002   procfile = fopen (fname, "r");
5003   if (procfile == NULL)
5004     error (_("Could not open %s"), fname);
5005   cleanup = make_cleanup_fclose (procfile);
5006
5007   while (fgets (buffer, MAXPATHLEN, procfile) != NULL)
5008     {
5009       /* Normal queued signals are on the SigPnd line in the status
5010          file.  However, 2.6 kernels also have a "shared" pending
5011          queue for delivering signals to a thread group, so check for
5012          a ShdPnd line also.
5013
5014          Unfortunately some Red Hat kernels include the shared pending
5015          queue but not the ShdPnd status field.  */
5016
5017       if (strncmp (buffer, "SigPnd:\t", 8) == 0)
5018         add_line_to_sigset (buffer + 8, pending);
5019       else if (strncmp (buffer, "ShdPnd:\t", 8) == 0)
5020         add_line_to_sigset (buffer + 8, pending);
5021       else if (strncmp (buffer, "SigBlk:\t", 8) == 0)
5022         add_line_to_sigset (buffer + 8, blocked);
5023       else if (strncmp (buffer, "SigIgn:\t", 8) == 0)
5024         add_line_to_sigset (buffer + 8, ignored);
5025     }
5026
5027   do_cleanups (cleanup);
5028 }
5029
5030 static LONGEST
5031 linux_nat_xfer_osdata (struct target_ops *ops, enum target_object object,
5032                        const char *annex, gdb_byte *readbuf,
5033                        const gdb_byte *writebuf, ULONGEST offset, LONGEST len)
5034 {
5035   /* We make the process list snapshot when the object starts to be
5036      read.  */
5037   static const char *buf;
5038   static LONGEST len_avail = -1;
5039   static struct obstack obstack;
5040
5041   DIR *dirp;
5042
5043   gdb_assert (object == TARGET_OBJECT_OSDATA);
5044
5045   if (!annex)
5046     {
5047       if (offset == 0)
5048         {
5049           if (len_avail != -1 && len_avail != 0)
5050             obstack_free (&obstack, NULL);
5051           len_avail = 0;
5052           buf = NULL;
5053           obstack_init (&obstack);
5054           obstack_grow_str (&obstack, "<osdata type=\"types\">\n");
5055
5056           obstack_xml_printf (&obstack,
5057                               "<item>"
5058                               "<column name=\"Type\">processes</column>"
5059                               "<column name=\"Description\">"
5060                               "Listing of all processes</column>"
5061                               "</item>");
5062
5063           obstack_grow_str0 (&obstack, "</osdata>\n");
5064           buf = obstack_finish (&obstack);
5065           len_avail = strlen (buf);
5066         }
5067
5068       if (offset >= len_avail)
5069         {
5070           /* Done.  Get rid of the obstack.  */
5071           obstack_free (&obstack, NULL);
5072           buf = NULL;
5073           len_avail = 0;
5074           return 0;
5075         }
5076
5077       if (len > len_avail - offset)
5078         len = len_avail - offset;
5079       memcpy (readbuf, buf + offset, len);
5080
5081       return len;
5082     }
5083
5084   if (strcmp (annex, "processes") != 0)
5085     return 0;
5086
5087   gdb_assert (readbuf && !writebuf);
5088
5089   if (offset == 0)
5090     {
5091       if (len_avail != -1 && len_avail != 0)
5092         obstack_free (&obstack, NULL);
5093       len_avail = 0;
5094       buf = NULL;
5095       obstack_init (&obstack);
5096       obstack_grow_str (&obstack, "<osdata type=\"processes\">\n");
5097
5098       dirp = opendir ("/proc");
5099       if (dirp)
5100         {
5101           struct dirent *dp;
5102
5103           while ((dp = readdir (dirp)) != NULL)
5104             {
5105               struct stat statbuf;
5106               char procentry[sizeof ("/proc/4294967295")];
5107
5108               if (!isdigit (dp->d_name[0])
5109                   || NAMELEN (dp) > sizeof ("4294967295") - 1)
5110                 continue;
5111
5112               sprintf (procentry, "/proc/%s", dp->d_name);
5113               if (stat (procentry, &statbuf) == 0
5114                   && S_ISDIR (statbuf.st_mode))
5115                 {
5116                   char *pathname;
5117                   FILE *f;
5118                   char cmd[MAXPATHLEN + 1];
5119                   struct passwd *entry;
5120
5121                   pathname = xstrprintf ("/proc/%s/cmdline", dp->d_name);
5122                   entry = getpwuid (statbuf.st_uid);
5123
5124                   if ((f = fopen (pathname, "r")) != NULL)
5125                     {
5126                       size_t length = fread (cmd, 1, sizeof (cmd) - 1, f);
5127
5128                       if (length > 0)
5129                         {
5130                           int i;
5131
5132                           for (i = 0; i < length; i++)
5133                             if (cmd[i] == '\0')
5134                               cmd[i] = ' ';
5135                           cmd[length] = '\0';
5136
5137                           obstack_xml_printf (
5138                             &obstack,
5139                             "<item>"
5140                             "<column name=\"pid\">%s</column>"
5141                             "<column name=\"user\">%s</column>"
5142                             "<column name=\"command\">%s</column>"
5143                             "</item>",
5144                             dp->d_name,
5145                             entry ? entry->pw_name : "?",
5146                             cmd);
5147                         }
5148                       fclose (f);
5149                     }
5150
5151                   xfree (pathname);
5152                 }
5153             }
5154
5155           closedir (dirp);
5156         }
5157
5158       obstack_grow_str0 (&obstack, "</osdata>\n");
5159       buf = obstack_finish (&obstack);
5160       len_avail = strlen (buf);
5161     }
5162
5163   if (offset >= len_avail)
5164     {
5165       /* Done.  Get rid of the obstack.  */
5166       obstack_free (&obstack, NULL);
5167       buf = NULL;
5168       len_avail = 0;
5169       return 0;
5170     }
5171
5172   if (len > len_avail - offset)
5173     len = len_avail - offset;
5174   memcpy (readbuf, buf + offset, len);
5175
5176   return len;
5177 }
5178
5179 static LONGEST
5180 linux_xfer_partial (struct target_ops *ops, enum target_object object,
5181                     const char *annex, gdb_byte *readbuf,
5182                     const gdb_byte *writebuf, ULONGEST offset, LONGEST len)
5183 {
5184   LONGEST xfer;
5185
5186   if (object == TARGET_OBJECT_AUXV)
5187     return memory_xfer_auxv (ops, object, annex, readbuf, writebuf,
5188                              offset, len);
5189
5190   if (object == TARGET_OBJECT_OSDATA)
5191     return linux_nat_xfer_osdata (ops, object, annex, readbuf, writebuf,
5192                                offset, len);
5193
5194   if (object == TARGET_OBJECT_SPU)
5195     return linux_proc_xfer_spu (ops, object, annex, readbuf, writebuf,
5196                                 offset, len);
5197
5198   /* GDB calculates all the addresses in possibly larget width of the address.
5199      Address width needs to be masked before its final use - either by
5200      linux_proc_xfer_partial or inf_ptrace_xfer_partial.
5201
5202      Compare ADDR_BIT first to avoid a compiler warning on shift overflow.  */
5203
5204   if (object == TARGET_OBJECT_MEMORY)
5205     {
5206       int addr_bit = gdbarch_addr_bit (target_gdbarch);
5207
5208       if (addr_bit < (sizeof (ULONGEST) * HOST_CHAR_BIT))
5209         offset &= ((ULONGEST) 1 << addr_bit) - 1;
5210     }
5211
5212   xfer = linux_proc_xfer_partial (ops, object, annex, readbuf, writebuf,
5213                                   offset, len);
5214   if (xfer != 0)
5215     return xfer;
5216
5217   return super_xfer_partial (ops, object, annex, readbuf, writebuf,
5218                              offset, len);
5219 }
5220
5221 /* Create a prototype generic GNU/Linux target.  The client can override
5222    it with local methods.  */
5223
5224 static void
5225 linux_target_install_ops (struct target_ops *t)
5226 {
5227   t->to_insert_fork_catchpoint = linux_child_insert_fork_catchpoint;
5228   t->to_remove_fork_catchpoint = linux_child_remove_fork_catchpoint;
5229   t->to_insert_vfork_catchpoint = linux_child_insert_vfork_catchpoint;
5230   t->to_remove_vfork_catchpoint = linux_child_remove_vfork_catchpoint;
5231   t->to_insert_exec_catchpoint = linux_child_insert_exec_catchpoint;
5232   t->to_remove_exec_catchpoint = linux_child_remove_exec_catchpoint;
5233   t->to_set_syscall_catchpoint = linux_child_set_syscall_catchpoint;
5234   t->to_pid_to_exec_file = linux_child_pid_to_exec_file;
5235   t->to_post_startup_inferior = linux_child_post_startup_inferior;
5236   t->to_post_attach = linux_child_post_attach;
5237   t->to_follow_fork = linux_child_follow_fork;
5238   t->to_find_memory_regions = linux_nat_find_memory_regions;
5239   t->to_make_corefile_notes = linux_nat_make_corefile_notes;
5240
5241   super_xfer_partial = t->to_xfer_partial;
5242   t->to_xfer_partial = linux_xfer_partial;
5243 }
5244
5245 struct target_ops *
5246 linux_target (void)
5247 {
5248   struct target_ops *t;
5249
5250   t = inf_ptrace_target ();
5251   linux_target_install_ops (t);
5252
5253   return t;
5254 }
5255
5256 struct target_ops *
5257 linux_trad_target (CORE_ADDR (*register_u_offset)(struct gdbarch *, int, int))
5258 {
5259   struct target_ops *t;
5260
5261   t = inf_ptrace_trad_target (register_u_offset);
5262   linux_target_install_ops (t);
5263
5264   return t;
5265 }
5266
5267 /* target_is_async_p implementation.  */
5268
5269 static int
5270 linux_nat_is_async_p (void)
5271 {
5272   /* NOTE: palves 2008-03-21: We're only async when the user requests
5273      it explicitly with the "set target-async" command.
5274      Someday, linux will always be async.  */
5275   if (!target_async_permitted)
5276     return 0;
5277
5278   /* See target.h/target_async_mask.  */
5279   return linux_nat_async_mask_value;
5280 }
5281
5282 /* target_can_async_p implementation.  */
5283
5284 static int
5285 linux_nat_can_async_p (void)
5286 {
5287   /* NOTE: palves 2008-03-21: We're only async when the user requests
5288      it explicitly with the "set target-async" command.
5289      Someday, linux will always be async.  */
5290   if (!target_async_permitted)
5291     return 0;
5292
5293   /* See target.h/target_async_mask.  */
5294   return linux_nat_async_mask_value;
5295 }
5296
5297 static int
5298 linux_nat_supports_non_stop (void)
5299 {
5300   return 1;
5301 }
5302
5303 /* True if we want to support multi-process.  To be removed when GDB
5304    supports multi-exec.  */
5305
5306 int linux_multi_process = 1;
5307
5308 static int
5309 linux_nat_supports_multi_process (void)
5310 {
5311   return linux_multi_process;
5312 }
5313
5314 /* target_async_mask implementation.  */
5315
5316 static int
5317 linux_nat_async_mask (int new_mask)
5318 {
5319   int curr_mask = linux_nat_async_mask_value;
5320
5321   if (curr_mask != new_mask)
5322     {
5323       if (new_mask == 0)
5324         {
5325           linux_nat_async (NULL, 0);
5326           linux_nat_async_mask_value = new_mask;
5327         }
5328       else
5329         {
5330           linux_nat_async_mask_value = new_mask;
5331
5332           /* If we're going out of async-mask in all-stop, then the
5333              inferior is stopped.  The next resume will call
5334              target_async.  In non-stop, the target event source
5335              should be always registered in the event loop.  Do so
5336              now.  */
5337           if (non_stop)
5338             linux_nat_async (inferior_event_handler, 0);
5339         }
5340     }
5341
5342   return curr_mask;
5343 }
5344
5345 static int async_terminal_is_ours = 1;
5346
5347 /* target_terminal_inferior implementation.  */
5348
5349 static void
5350 linux_nat_terminal_inferior (void)
5351 {
5352   if (!target_is_async_p ())
5353     {
5354       /* Async mode is disabled.  */
5355       terminal_inferior ();
5356       return;
5357     }
5358
5359   terminal_inferior ();
5360
5361   /* Calls to target_terminal_*() are meant to be idempotent.  */
5362   if (!async_terminal_is_ours)
5363     return;
5364
5365   delete_file_handler (input_fd);
5366   async_terminal_is_ours = 0;
5367   set_sigint_trap ();
5368 }
5369
5370 /* target_terminal_ours implementation.  */
5371
5372 static void
5373 linux_nat_terminal_ours (void)
5374 {
5375   if (!target_is_async_p ())
5376     {
5377       /* Async mode is disabled.  */
5378       terminal_ours ();
5379       return;
5380     }
5381
5382   /* GDB should never give the terminal to the inferior if the
5383      inferior is running in the background (run&, continue&, etc.),
5384      but claiming it sure should.  */
5385   terminal_ours ();
5386
5387   if (async_terminal_is_ours)
5388     return;
5389
5390   clear_sigint_trap ();
5391   add_file_handler (input_fd, stdin_event_handler, 0);
5392   async_terminal_is_ours = 1;
5393 }
5394
5395 static void (*async_client_callback) (enum inferior_event_type event_type,
5396                                       void *context);
5397 static void *async_client_context;
5398
5399 /* SIGCHLD handler that serves two purposes: In non-stop/async mode,
5400    so we notice when any child changes state, and notify the
5401    event-loop; it allows us to use sigsuspend in linux_nat_wait_1
5402    above to wait for the arrival of a SIGCHLD.  */
5403
5404 static void
5405 sigchld_handler (int signo)
5406 {
5407   int old_errno = errno;
5408
5409   if (debug_linux_nat)
5410     ui_file_write_async_safe (gdb_stdlog,
5411                               "sigchld\n", sizeof ("sigchld\n") - 1);
5412
5413   if (signo == SIGCHLD
5414       && linux_nat_event_pipe[0] != -1)
5415     async_file_mark (); /* Let the event loop know that there are
5416                            events to handle.  */
5417
5418   errno = old_errno;
5419 }
5420
5421 /* Callback registered with the target events file descriptor.  */
5422
5423 static void
5424 handle_target_event (int error, gdb_client_data client_data)
5425 {
5426   (*async_client_callback) (INF_REG_EVENT, async_client_context);
5427 }
5428
5429 /* Create/destroy the target events pipe.  Returns previous state.  */
5430
5431 static int
5432 linux_async_pipe (int enable)
5433 {
5434   int previous = (linux_nat_event_pipe[0] != -1);
5435
5436   if (previous != enable)
5437     {
5438       sigset_t prev_mask;
5439
5440       block_child_signals (&prev_mask);
5441
5442       if (enable)
5443         {
5444           if (pipe (linux_nat_event_pipe) == -1)
5445             internal_error (__FILE__, __LINE__,
5446                             "creating event pipe failed.");
5447
5448           fcntl (linux_nat_event_pipe[0], F_SETFL, O_NONBLOCK);
5449           fcntl (linux_nat_event_pipe[1], F_SETFL, O_NONBLOCK);
5450         }
5451       else
5452         {
5453           close (linux_nat_event_pipe[0]);
5454           close (linux_nat_event_pipe[1]);
5455           linux_nat_event_pipe[0] = -1;
5456           linux_nat_event_pipe[1] = -1;
5457         }
5458
5459       restore_child_signals_mask (&prev_mask);
5460     }
5461
5462   return previous;
5463 }
5464
5465 /* target_async implementation.  */
5466
5467 static void
5468 linux_nat_async (void (*callback) (enum inferior_event_type event_type,
5469                                    void *context), void *context)
5470 {
5471   if (linux_nat_async_mask_value == 0 || !target_async_permitted)
5472     internal_error (__FILE__, __LINE__,
5473                     "Calling target_async when async is masked");
5474
5475   if (callback != NULL)
5476     {
5477       async_client_callback = callback;
5478       async_client_context = context;
5479       if (!linux_async_pipe (1))
5480         {
5481           add_file_handler (linux_nat_event_pipe[0],
5482                             handle_target_event, NULL);
5483           /* There may be pending events to handle.  Tell the event loop
5484              to poll them.  */
5485           async_file_mark ();
5486         }
5487     }
5488   else
5489     {
5490       async_client_callback = callback;
5491       async_client_context = context;
5492       delete_file_handler (linux_nat_event_pipe[0]);
5493       linux_async_pipe (0);
5494     }
5495   return;
5496 }
5497
5498 /* Stop an LWP, and push a TARGET_SIGNAL_0 stop status if no other
5499    event came out.  */
5500
5501 static int
5502 linux_nat_stop_lwp (struct lwp_info *lwp, void *data)
5503 {
5504   if (!lwp->stopped)
5505     {
5506       ptid_t ptid = lwp->ptid;
5507
5508       if (debug_linux_nat)
5509         fprintf_unfiltered (gdb_stdlog,
5510                             "LNSL: running -> suspending %s\n",
5511                             target_pid_to_str (lwp->ptid));
5512
5513
5514       stop_callback (lwp, NULL);
5515       stop_wait_callback (lwp, NULL);
5516
5517       /* If the lwp exits while we try to stop it, there's nothing
5518          else to do.  */
5519       lwp = find_lwp_pid (ptid);
5520       if (lwp == NULL)
5521         return 0;
5522
5523       /* If we didn't collect any signal other than SIGSTOP while
5524          stopping the LWP, push a SIGNAL_0 event.  In either case, the
5525          event-loop will end up calling target_wait which will collect
5526          these.  */
5527       if (lwp->status == 0)
5528         lwp->status = W_STOPCODE (0);
5529       async_file_mark ();
5530     }
5531   else
5532     {
5533       /* Already known to be stopped; do nothing.  */
5534
5535       if (debug_linux_nat)
5536         {
5537           if (find_thread_ptid (lwp->ptid)->stop_requested)
5538             fprintf_unfiltered (gdb_stdlog,
5539                                 "LNSL: already stopped/stop_requested %s\n",
5540                                 target_pid_to_str (lwp->ptid));
5541           else
5542             fprintf_unfiltered (gdb_stdlog,
5543                                 "LNSL: already stopped/no "
5544                                 "stop_requested yet %s\n",
5545                                 target_pid_to_str (lwp->ptid));
5546         }
5547     }
5548   return 0;
5549 }
5550
5551 static void
5552 linux_nat_stop (ptid_t ptid)
5553 {
5554   if (non_stop)
5555     iterate_over_lwps (ptid, linux_nat_stop_lwp, NULL);
5556   else
5557     linux_ops->to_stop (ptid);
5558 }
5559
5560 static void
5561 linux_nat_close (int quitting)
5562 {
5563   /* Unregister from the event loop.  */
5564   if (target_is_async_p ())
5565     target_async (NULL, 0);
5566
5567   /* Reset the async_masking.  */
5568   linux_nat_async_mask_value = 1;
5569
5570   if (linux_ops->to_close)
5571     linux_ops->to_close (quitting);
5572 }
5573
5574 /* When requests are passed down from the linux-nat layer to the
5575    single threaded inf-ptrace layer, ptids of (lwpid,0,0) form are
5576    used.  The address space pointer is stored in the inferior object,
5577    but the common code that is passed such ptid can't tell whether
5578    lwpid is a "main" process id or not (it assumes so).  We reverse
5579    look up the "main" process id from the lwp here.  */
5580
5581 struct address_space *
5582 linux_nat_thread_address_space (struct target_ops *t, ptid_t ptid)
5583 {
5584   struct lwp_info *lwp;
5585   struct inferior *inf;
5586   int pid;
5587
5588   pid = GET_LWP (ptid);
5589   if (GET_LWP (ptid) == 0)
5590     {
5591       /* An (lwpid,0,0) ptid.  Look up the lwp object to get at the
5592          tgid.  */
5593       lwp = find_lwp_pid (ptid);
5594       pid = GET_PID (lwp->ptid);
5595     }
5596   else
5597     {
5598       /* A (pid,lwpid,0) ptid.  */
5599       pid = GET_PID (ptid);
5600     }
5601
5602   inf = find_inferior_pid (pid);
5603   gdb_assert (inf != NULL);
5604   return inf->aspace;
5605 }
5606
5607 int
5608 linux_nat_core_of_thread_1 (ptid_t ptid)
5609 {
5610   struct cleanup *back_to;
5611   char *filename;
5612   FILE *f;
5613   char *content = NULL;
5614   char *p;
5615   char *ts = 0;
5616   int content_read = 0;
5617   int i;
5618   int core;
5619
5620   filename = xstrprintf ("/proc/%d/task/%ld/stat",
5621                          GET_PID (ptid), GET_LWP (ptid));
5622   back_to = make_cleanup (xfree, filename);
5623
5624   f = fopen (filename, "r");
5625   if (!f)
5626     {
5627       do_cleanups (back_to);
5628       return -1;
5629     }
5630
5631   make_cleanup_fclose (f);
5632
5633   for (;;)
5634     {
5635       int n;
5636
5637       content = xrealloc (content, content_read + 1024);
5638       n = fread (content + content_read, 1, 1024, f);
5639       content_read += n;
5640       if (n < 1024)
5641         {
5642           content[content_read] = '\0';
5643           break;
5644         }
5645     }
5646
5647   make_cleanup (xfree, content);
5648
5649   p = strchr (content, '(');
5650
5651   /* Skip ")".  */
5652   if (p != NULL)
5653     p = strchr (p, ')');
5654   if (p != NULL)
5655     p++;
5656
5657   /* If the first field after program name has index 0, then core number is
5658      the field with index 36.  There's no constant for that anywhere.  */
5659   if (p != NULL)
5660     p = strtok_r (p, " ", &ts);
5661   for (i = 0; p != NULL && i != 36; ++i)
5662     p = strtok_r (NULL, " ", &ts);
5663
5664   if (p == NULL || sscanf (p, "%d", &core) == 0)
5665     core = -1;
5666
5667   do_cleanups (back_to);
5668
5669   return core;
5670 }
5671
5672 /* Return the cached value of the processor core for thread PTID.  */
5673
5674 int
5675 linux_nat_core_of_thread (struct target_ops *ops, ptid_t ptid)
5676 {
5677   struct lwp_info *info = find_lwp_pid (ptid);
5678
5679   if (info)
5680     return info->core;
5681   return -1;
5682 }
5683
5684 void
5685 linux_nat_add_target (struct target_ops *t)
5686 {
5687   /* Save the provided single-threaded target.  We save this in a separate
5688      variable because another target we've inherited from (e.g. inf-ptrace)
5689      may have saved a pointer to T; we want to use it for the final
5690      process stratum target.  */
5691   linux_ops_saved = *t;
5692   linux_ops = &linux_ops_saved;
5693
5694   /* Override some methods for multithreading.  */
5695   t->to_create_inferior = linux_nat_create_inferior;
5696   t->to_attach = linux_nat_attach;
5697   t->to_detach = linux_nat_detach;
5698   t->to_resume = linux_nat_resume;
5699   t->to_wait = linux_nat_wait;
5700   t->to_pass_signals = linux_nat_pass_signals;
5701   t->to_xfer_partial = linux_nat_xfer_partial;
5702   t->to_kill = linux_nat_kill;
5703   t->to_mourn_inferior = linux_nat_mourn_inferior;
5704   t->to_thread_alive = linux_nat_thread_alive;
5705   t->to_pid_to_str = linux_nat_pid_to_str;
5706   t->to_thread_name = linux_nat_thread_name;
5707   t->to_has_thread_control = tc_schedlock;
5708   t->to_thread_address_space = linux_nat_thread_address_space;
5709   t->to_stopped_by_watchpoint = linux_nat_stopped_by_watchpoint;
5710   t->to_stopped_data_address = linux_nat_stopped_data_address;
5711
5712   t->to_can_async_p = linux_nat_can_async_p;
5713   t->to_is_async_p = linux_nat_is_async_p;
5714   t->to_supports_non_stop = linux_nat_supports_non_stop;
5715   t->to_async = linux_nat_async;
5716   t->to_async_mask = linux_nat_async_mask;
5717   t->to_terminal_inferior = linux_nat_terminal_inferior;
5718   t->to_terminal_ours = linux_nat_terminal_ours;
5719   t->to_close = linux_nat_close;
5720
5721   /* Methods for non-stop support.  */
5722   t->to_stop = linux_nat_stop;
5723
5724   t->to_supports_multi_process = linux_nat_supports_multi_process;
5725
5726   t->to_core_of_thread = linux_nat_core_of_thread;
5727
5728   /* We don't change the stratum; this target will sit at
5729      process_stratum and thread_db will set at thread_stratum.  This
5730      is a little strange, since this is a multi-threaded-capable
5731      target, but we want to be on the stack below thread_db, and we
5732      also want to be used for single-threaded processes.  */
5733
5734   add_target (t);
5735 }
5736
5737 /* Register a method to call whenever a new thread is attached.  */
5738 void
5739 linux_nat_set_new_thread (struct target_ops *t, void (*new_thread) (ptid_t))
5740 {
5741   /* Save the pointer.  We only support a single registered instance
5742      of the GNU/Linux native target, so we do not need to map this to
5743      T.  */
5744   linux_nat_new_thread = new_thread;
5745 }
5746
5747 /* Register a method that converts a siginfo object between the layout
5748    that ptrace returns, and the layout in the architecture of the
5749    inferior.  */
5750 void
5751 linux_nat_set_siginfo_fixup (struct target_ops *t,
5752                              int (*siginfo_fixup) (struct siginfo *,
5753                                                    gdb_byte *,
5754                                                    int))
5755 {
5756   /* Save the pointer.  */
5757   linux_nat_siginfo_fixup = siginfo_fixup;
5758 }
5759
5760 /* Return the saved siginfo associated with PTID.  */
5761 struct siginfo *
5762 linux_nat_get_siginfo (ptid_t ptid)
5763 {
5764   struct lwp_info *lp = find_lwp_pid (ptid);
5765
5766   gdb_assert (lp != NULL);
5767
5768   return &lp->siginfo;
5769 }
5770
5771 /* Provide a prototype to silence -Wmissing-prototypes.  */
5772 extern initialize_file_ftype _initialize_linux_nat;
5773
5774 void
5775 _initialize_linux_nat (void)
5776 {
5777   add_info ("proc", linux_nat_info_proc_cmd, _("\
5778 Show /proc process information about any running process.\n\
5779 Specify any process id, or use the program being debugged by default.\n\
5780 Specify any of the following keywords for detailed info:\n\
5781   mappings -- list of mapped memory regions.\n\
5782   stat     -- list a bunch of random process info.\n\
5783   status   -- list a different bunch of random process info.\n\
5784   all      -- list all available /proc info."));
5785
5786   add_setshow_zinteger_cmd ("lin-lwp", class_maintenance,
5787                             &debug_linux_nat, _("\
5788 Set debugging of GNU/Linux lwp module."), _("\
5789 Show debugging of GNU/Linux lwp module."), _("\
5790 Enables printf debugging output."),
5791                             NULL,
5792                             show_debug_linux_nat,
5793                             &setdebuglist, &showdebuglist);
5794
5795   /* Save this mask as the default.  */
5796   sigprocmask (SIG_SETMASK, NULL, &normal_mask);
5797
5798   /* Install a SIGCHLD handler.  */
5799   sigchld_action.sa_handler = sigchld_handler;
5800   sigemptyset (&sigchld_action.sa_mask);
5801   sigchld_action.sa_flags = SA_RESTART;
5802
5803   /* Make it the default.  */
5804   sigaction (SIGCHLD, &sigchld_action, NULL);
5805
5806   /* Make sure we don't block SIGCHLD during a sigsuspend.  */
5807   sigprocmask (SIG_SETMASK, NULL, &suspend_mask);
5808   sigdelset (&suspend_mask, SIGCHLD);
5809
5810   sigemptyset (&blocked_mask);
5811
5812   add_setshow_boolean_cmd ("disable-randomization", class_support,
5813                            &disable_randomization, _("\
5814 Set disabling of debuggee's virtual address space randomization."), _("\
5815 Show disabling of debuggee's virtual address space randomization."), _("\
5816 When this mode is on (which is the default), randomization of the virtual\n\
5817 address space is disabled.  Standalone programs run with the randomization\n\
5818 enabled by default on some platforms."),
5819                            &set_disable_randomization,
5820                            &show_disable_randomization,
5821                            &setlist, &showlist);
5822 }
5823 \f
5824
5825 /* FIXME: kettenis/2000-08-26: The stuff on this page is specific to
5826    the GNU/Linux Threads library and therefore doesn't really belong
5827    here.  */
5828
5829 /* Read variable NAME in the target and return its value if found.
5830    Otherwise return zero.  It is assumed that the type of the variable
5831    is `int'.  */
5832
5833 static int
5834 get_signo (const char *name)
5835 {
5836   struct minimal_symbol *ms;
5837   int signo;
5838
5839   ms = lookup_minimal_symbol (name, NULL, NULL);
5840   if (ms == NULL)
5841     return 0;
5842
5843   if (target_read_memory (SYMBOL_VALUE_ADDRESS (ms), (gdb_byte *) &signo,
5844                           sizeof (signo)) != 0)
5845     return 0;
5846
5847   return signo;
5848 }
5849
5850 /* Return the set of signals used by the threads library in *SET.  */
5851
5852 void
5853 lin_thread_get_thread_signals (sigset_t *set)
5854 {
5855   struct sigaction action;
5856   int restart, cancel;
5857
5858   sigemptyset (&blocked_mask);
5859   sigemptyset (set);
5860
5861   restart = get_signo ("__pthread_sig_restart");
5862   cancel = get_signo ("__pthread_sig_cancel");
5863
5864   /* LinuxThreads normally uses the first two RT signals, but in some legacy
5865      cases may use SIGUSR1/SIGUSR2.  NPTL always uses RT signals, but does
5866      not provide any way for the debugger to query the signal numbers -
5867      fortunately they don't change!  */
5868
5869   if (restart == 0)
5870     restart = __SIGRTMIN;
5871
5872   if (cancel == 0)
5873     cancel = __SIGRTMIN + 1;
5874
5875   sigaddset (set, restart);
5876   sigaddset (set, cancel);
5877
5878   /* The GNU/Linux Threads library makes terminating threads send a
5879      special "cancel" signal instead of SIGCHLD.  Make sure we catch
5880      those (to prevent them from terminating GDB itself, which is
5881      likely to be their default action) and treat them the same way as
5882      SIGCHLD.  */
5883
5884   action.sa_handler = sigchld_handler;
5885   sigemptyset (&action.sa_mask);
5886   action.sa_flags = SA_RESTART;
5887   sigaction (cancel, &action, NULL);
5888
5889   /* We block the "cancel" signal throughout this code ...  */
5890   sigaddset (&blocked_mask, cancel);
5891   sigprocmask (SIG_BLOCK, &blocked_mask, NULL);
5892
5893   /* ... except during a sigsuspend.  */
5894   sigdelset (&suspend_mask, cancel);
5895 }