OpenCores
URL https://opencores.org/ocsvn/openrisc/openrisc/trunk

Subversion Repositories openrisc

[/] [openrisc/] [trunk/] [gnu-stable/] [gdb-7.2/] [gdb/] [linux-nat.c] - Blame information for rev 841

Details | Compare with Previous | View Log

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

powered by: WebSVN 2.1.0

© copyright 1999-2024 OpenCores.org, equivalent to Oliscience, all rights reserved. OpenCores®, registered trademark.