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