OpenE2K
/
binutils-gdb
12
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

2003-03-28 Jeff Johnston <jjohnstn@redhat.com> 

* thread.c: Reindented.
        * lin-lwp.c: Ditto.
        * linux-proc.c: Ditto.
This commit is contained in:
Jeff Johnston 2003-03-28 21:42:41 +00:00
parent 98c7071fce
commit 6949171e13
4 changed files with 238 additions and 266 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
gdb/ChangeLog
View File

@ -1,3 +1,9 @@
2003-03-28 Jeff Johnston <jjohnstn@redhat.com>
* thread.c: Reindented.
* lin-lwp.c: Ditto.
* linux-proc.c: Ditto.
2003-03-28 Bob Rossi <bob_rossi@cox.net>
* MAINTAINERS (write after approval): Add myself.

229
gdb/lin-lwp.c
View File

@ -172,8 +172,7 @@ status_to_str (int status)
snprintf (buf, sizeof (buf), "%s (terminated)",
strsignal (WSTOPSIG (status)));
else
snprintf (buf, sizeof (buf), "%d (exited)",
WEXITSTATUS (status));
snprintf (buf, sizeof (buf), "%d (exited)", WEXITSTATUS (status));
return buf;
}
@ -306,8 +305,8 @@ iterate_over_lwps (int (*callback) (struct lwp_info *, void *), void *data)
int
lin_lwp_prepare_to_proceed (void)
{
if (! ptid_equal (trap_ptid, null_ptid)
&& ! ptid_equal (inferior_ptid, trap_ptid))
if (!ptid_equal (trap_ptid, null_ptid)
&& !ptid_equal (inferior_ptid, trap_ptid))
{
/* Switched over from TRAP_PID. */
CORE_ADDR stop_pc = read_pc ();
@ -319,7 +318,7 @@ lin_lwp_prepare_to_proceed (void)
if (trap_pc != stop_pc && breakpoint_here_p (trap_pc))
{
/* User hasn't deleted the breakpoint. Return non-zero, and
switch back to TRAP_PID. */
switch back to TRAP_PID. */
inferior_ptid = trap_ptid;
/* FIXME: Is this stuff really necessary? */
@ -355,7 +354,7 @@ lin_lwp_attach_lwp (ptid_t ptid, int verbose)
/* Make sure SIGCHLD is blocked. We don't want SIGCHLD events
to interrupt either the ptrace() or waitpid() calls below. */
if (! sigismember (&blocked_mask, SIGCHLD))
if (!sigismember (&blocked_mask, SIGCHLD))
{
sigaddset (&blocked_mask, SIGCHLD);
sigprocmask (SIG_BLOCK, &blocked_mask, NULL);
@ -380,8 +379,8 @@ lin_lwp_attach_lwp (ptid_t ptid, int verbose)
safe_strerror (errno));
if (debug_lin_lwp)
fprintf_unfiltered (gdb_stdlog,
"LLAL: PTRACE_ATTACH %s, 0, 0 (OK)\n",
fprintf_unfiltered (gdb_stdlog,
"LLAL: PTRACE_ATTACH %s, 0, 0 (OK)\n",
target_pid_to_str (ptid));
pid = waitpid (GET_LWP (ptid), &status, 0);
@ -401,18 +400,18 @@ lin_lwp_attach_lwp (ptid_t ptid, int verbose)
{
fprintf_unfiltered (gdb_stdlog,
"LLAL: waitpid %s received %s\n",
target_pid_to_str (ptid),
target_pid_to_str (ptid),
status_to_str (status));
}
}
else
{
/* We assume that the LWP representing the original process
is already stopped. Mark it as stopped in the data structure
that the lin-lwp layer uses to keep track of threads. Note
that this won't have already been done since the main thread
will have, we assume, been stopped by an attach from a
different layer. */
is already stopped. Mark it as stopped in the data structure
that the lin-lwp layer uses to keep track of threads. Note
that this won't have already been done since the main thread
will have, we assume, been stopped by an attach from a
different layer. */
lp->stopped = 1;
}
}
@ -455,8 +454,7 @@ lin_lwp_attach (char *args, int from_tty)
if (debug_lin_lwp)
{
fprintf_unfiltered (gdb_stdlog,
"LLA: waitpid %ld, faking SIGSTOP\n",
(long) pid);
"LLA: waitpid %ld, faking SIGSTOP\n", (long) pid);
}
}
@ -467,7 +465,7 @@ detach_callback (struct lwp_info *lp, void *data)
if (debug_lin_lwp && lp->status)
fprintf_unfiltered (gdb_stdlog, "DC: Pending %s for %s on detach.\n",
strsignal (WSTOPSIG (lp->status)),
strsignal (WSTOPSIG (lp->status)),
target_pid_to_str (lp->ptid));
while (lp->signalled && lp->stopped)
@ -479,10 +477,10 @@ detach_callback (struct lwp_info *lp, void *data)
safe_strerror (errno));
if (debug_lin_lwp)
fprintf_unfiltered (gdb_stdlog,
fprintf_unfiltered (gdb_stdlog,
"DC: PTRACE_CONTINUE (%s, 0, %s) (OK)\n",
target_pid_to_str (lp->ptid),
status_to_str (lp->status));
status_to_str (lp->status));
lp->stopped = 0;
lp->signalled = 0;
@ -505,7 +503,7 @@ detach_callback (struct lwp_info *lp, void *data)
if (debug_lin_lwp)
fprintf_unfiltered (gdb_stdlog,
"PTRACE_DETACH (%s, %s, 0) (OK)\n",
target_pid_to_str (lp->ptid),
target_pid_to_str (lp->ptid),
strsignal (WSTOPSIG (lp->status)));
delete_lwp (lp->ptid);
@ -547,7 +545,7 @@ resume_callback (struct lwp_info *lp, void *data)
child_resume (pid_to_ptid (GET_LWP (lp->ptid)), 0, TARGET_SIGNAL_0);
if (debug_lin_lwp)
fprintf_unfiltered (gdb_stdlog,
fprintf_unfiltered (gdb_stdlog,
"RC: PTRACE_CONT %s, 0, 0 (resume sibling)\n",
target_pid_to_str (lp->ptid));
lp->stopped = 0;
@ -606,13 +604,13 @@ lin_lwp_resume (ptid_t ptid, int step, enum target_signal signo)
if (lp->status)
{
/* FIXME: What should we do if we are supposed to continue
this thread with a signal? */
this thread with a signal? */
gdb_assert (signo == TARGET_SIGNAL_0);
return;
}
/* Mark LWP as not stopped to prevent it from being continued by
resume_callback. */
resume_callback. */
lp->stopped = 0;
}
@ -634,7 +632,7 @@ lin_lwp_resume (ptid_t ptid, int step, enum target_signal signo)
static int
stop_callback (struct lwp_info *lp, void *data)
{
if (! lp->stopped && ! lp->signalled)
if (!lp->stopped && !lp->signalled)
{
int ret;
@ -662,7 +660,7 @@ stop_wait_callback (struct lwp_info *lp, void *data)
{
sigset_t *flush_mask = data;
if (! lp->stopped && lp->signalled)
if (!lp->stopped && lp->signalled)
{
pid_t pid;
int status;
@ -681,7 +679,7 @@ stop_wait_callback (struct lwp_info *lp, void *data)
{
fprintf_unfiltered (gdb_stdlog,
"SWC: waitpid %s received %s\n",
target_pid_to_str (lp->ptid),
target_pid_to_str (lp->ptid),
status_to_str (status));
}
@ -692,14 +690,14 @@ stop_wait_callback (struct lwp_info *lp, void *data)
if (in_thread_list (lp->ptid))
{
/* Core GDB cannot deal with us deleting the current
thread. */
thread. */
if (!ptid_equal (lp->ptid, inferior_ptid))
delete_thread (lp->ptid);
printf_unfiltered ("[%s exited]\n",
target_pid_to_str (lp->ptid));
}
if (debug_lin_lwp)
fprintf_unfiltered (gdb_stdlog, "SWC: %s exited.\n",
fprintf_unfiltered (gdb_stdlog, "SWC: %s exited.\n",
target_pid_to_str (lp->ptid));
delete_lwp (lp->ptid);
@ -727,29 +725,29 @@ stop_wait_callback (struct lwp_info *lp, void *data)
if (WSTOPSIG (status) == SIGTRAP)
{
/* If a LWP other than the LWP that we're reporting an
event for has hit a GDB breakpoint (as opposed to
some random trap signal), then just arrange for it to
hit it again later. We don't keep the SIGTRAP status
and don't forward the SIGTRAP signal to the LWP. We
will handle the current event, eventually we will
resume all LWPs, and this one will get its breakpoint
trap again.
event for has hit a GDB breakpoint (as opposed to
some random trap signal), then just arrange for it to
hit it again later. We don't keep the SIGTRAP status
and don't forward the SIGTRAP signal to the LWP. We
will handle the current event, eventually we will
resume all LWPs, and this one will get its breakpoint
trap again.
If we do not do this, then we run the risk that the
user will delete or disable the breakpoint, but the
thread will have already tripped on it. */
If we do not do this, then we run the risk that the
user will delete or disable the breakpoint, but the
thread will have already tripped on it. */
/* Now resume this LWP and get the SIGSTOP event. */
errno = 0;
ptrace (PTRACE_CONT, GET_LWP (lp->ptid), 0, 0);
if (debug_lin_lwp)
{
fprintf_unfiltered (gdb_stdlog,
fprintf_unfiltered (gdb_stdlog,
"PTRACE_CONT %s, 0, 0 (%s)\n",
target_pid_to_str (lp->ptid),
errno ? safe_strerror (errno) : "OK");
fprintf_unfiltered (gdb_stdlog,
fprintf_unfiltered (gdb_stdlog,
"SWC: Candidate SIGTRAP event in %s\n",
target_pid_to_str (lp->ptid));
}
@ -767,39 +765,39 @@ stop_wait_callback (struct lwp_info *lp, void *data)
else
{
/* The thread was stopped with a signal other than
SIGSTOP, and didn't accidentally trip a breakpoint. */
SIGSTOP, and didn't accidentally trip a breakpoint. */
if (debug_lin_lwp)
{
fprintf_unfiltered (gdb_stdlog,
fprintf_unfiltered (gdb_stdlog,
"SWC: Pending event %s in %s\n",
status_to_str ((int) status),
status_to_str ((int) status),
target_pid_to_str (lp->ptid));
}
/* Now resume this LWP and get the SIGSTOP event. */
errno = 0;
ptrace (PTRACE_CONT, GET_LWP (lp->ptid), 0, 0);
if (debug_lin_lwp)
fprintf_unfiltered (gdb_stdlog,
fprintf_unfiltered (gdb_stdlog,
"SWC: PTRACE_CONT %s, 0, 0 (%s)\n",
target_pid_to_str (lp->ptid),
errno ? safe_strerror (errno) : "OK");
/* Hold this event/waitstatus while we check to see if
there are any more (we still want to get that SIGSTOP). */
there are any more (we still want to get that SIGSTOP). */
stop_wait_callback (lp, data);
/* If the lp->status field is still empty, use it to hold
this event. If not, then this event must be returned
to the event queue of the LWP. */
this event. If not, then this event must be returned
to the event queue of the LWP. */
if (lp->status == 0)
lp->status = status;
else
{
if (debug_lin_lwp)
{
fprintf_unfiltered (gdb_stdlog,
fprintf_unfiltered (gdb_stdlog,
"SWC: kill %s, %s\n",
target_pid_to_str (lp->ptid),
target_pid_to_str (lp->ptid),
status_to_str ((int) status));
}
kill (GET_LWP (lp->ptid), WSTOPSIG (status));
@ -810,7 +808,7 @@ stop_wait_callback (struct lwp_info *lp, void *data)
else
{
/* We caught the SIGSTOP that we intended to catch, so
there's no SIGSTOP pending. */
there's no SIGSTOP pending. */
lp->stopped = 1;
lp->signalled = 0;
}
@ -904,8 +902,8 @@ cancel_breakpoints_callback (struct lwp_info *lp, void *data)
tripped on it. */
if (lp->status != 0
&& WIFSTOPPED (lp->status) && WSTOPSIG (lp->status) == SIGTRAP
&& breakpoint_inserted_here_p (read_pc_pid (lp->ptid) -
&& WIFSTOPPED (lp->status) && WSTOPSIG (lp->status) == SIGTRAP
&& breakpoint_inserted_here_p (read_pc_pid (lp->ptid) -
DECR_PC_AFTER_BREAK))
{
if (debug_lin_lwp)
@ -948,7 +946,7 @@ select_event_lwp (struct lwp_info **orig_lp, int *status)
else
{
/* No single-stepping LWP. Select one at random, out of those
which have had SIGTRAP events. */
which have had SIGTRAP events. */
/* First see how many SIGTRAP events we have. */
iterate_over_lwps (count_events_callback, &num_events);
@ -958,8 +956,8 @@ select_event_lwp (struct lwp_info **orig_lp, int *status)
((num_events * (double) rand ()) / (RAND_MAX + 1.0));
if (debug_lin_lwp && num_events > 1)
fprintf_unfiltered (gdb_stdlog,
"SEL: Found %d SIGTRAP events, selecting #%d\n",
fprintf_unfiltered (gdb_stdlog,
"SEL: Found %d SIGTRAP events, selecting #%d\n",
num_events, random_selector);
event_lp = iterate_over_lwps (select_event_lwp_callback,
@ -970,7 +968,7 @@ select_event_lwp (struct lwp_info **orig_lp, int *status)
{
/* Switch the event LWP. */
*orig_lp = event_lp;
*status = event_lp->status;
*status = event_lp->status;
}
/* Flush the wait status for the event LWP. */
@ -1014,17 +1012,16 @@ child_wait (ptid_t ptid, struct target_waitstatus *ourstatus)
if (debug_lin_lwp)
{
fprintf_unfiltered (gdb_stdlog,
fprintf_unfiltered (gdb_stdlog,
"CW: waitpid %ld received %s\n",
(long) pid,
status_to_str (status));
(long) pid, status_to_str (status));
}
save_errno = errno;
/* Make sure we don't report an event for the exit of the
original program, if we've detached from it. */
if (pid != -1 && ! WIFSTOPPED (status) && pid != GET_PID (inferior_ptid))
original program, if we've detached from it. */
if (pid != -1 && !WIFSTOPPED (status) && pid != GET_PID (inferior_ptid))
{
pid = -1;
save_errno = EINTR;
@ -1037,7 +1034,7 @@ child_wait (ptid_t ptid, struct target_waitstatus *ourstatus)
if (pid == -1)
{
warning ("Child process unexpectedly missing: %s",
warning ("Child process unexpectedly missing: %s",
safe_strerror (errno));
/* Claim it exited with unknown signal. */
@ -1064,13 +1061,13 @@ lin_lwp_wait (ptid_t ptid, struct target_waitstatus *ourstatus)
sigemptyset (&flush_mask);
/* Make sure SIGCHLD is blocked. */
if (! sigismember (&blocked_mask, SIGCHLD))
if (!sigismember (&blocked_mask, SIGCHLD))
{
sigaddset (&blocked_mask, SIGCHLD);
sigprocmask (SIG_BLOCK, &blocked_mask, NULL);
}
retry:
retry:
/* Make sure there is at least one LWP that has been resumed, at
least if there are any LWPs at all. */
@ -1089,7 +1086,7 @@ lin_lwp_wait (ptid_t ptid, struct target_waitstatus *ourstatus)
if (debug_lin_lwp && status)
fprintf_unfiltered (gdb_stdlog,
"LLW: Using pending wait status %s for %s.\n",
status_to_str (status),
status_to_str (status),
target_pid_to_str (lp->ptid));
}
@ -1101,7 +1098,7 @@ lin_lwp_wait (ptid_t ptid, struct target_waitstatus *ourstatus)
else if (is_lwp (ptid))
{
if (debug_lin_lwp)
fprintf_unfiltered (gdb_stdlog,
fprintf_unfiltered (gdb_stdlog,
"LLW: Waiting for specific LWP %s.\n",
target_pid_to_str (ptid));
@ -1114,7 +1111,7 @@ lin_lwp_wait (ptid_t ptid, struct target_waitstatus *ourstatus)
if (debug_lin_lwp && status)
fprintf_unfiltered (gdb_stdlog,
"LLW: Using pending wait status %s for %s.\n",
status_to_str (status),
status_to_str (status),
target_pid_to_str (lp->ptid));
/* If we have to wait, take into account whether PID is a cloned
@ -1127,19 +1124,19 @@ lin_lwp_wait (ptid_t ptid, struct target_waitstatus *ourstatus)
if (status && lp->signalled)
{
/* A pending SIGSTOP may interfere with the normal stream of
events. In a typical case where interference is a problem,
we have a SIGSTOP signal pending for LWP A while
single-stepping it, encounter an event in LWP B, and take the
pending SIGSTOP while trying to stop LWP A. After processing
the event in LWP B, LWP A is continued, and we'll never see
the SIGTRAP associated with the last time we were
single-stepping LWP A. */
events. In a typical case where interference is a problem,
we have a SIGSTOP signal pending for LWP A while
single-stepping it, encounter an event in LWP B, and take the
pending SIGSTOP while trying to stop LWP A. After processing
the event in LWP B, LWP A is continued, and we'll never see
the SIGTRAP associated with the last time we were
single-stepping LWP A. */
/* Resume the thread. It should halt immediately returning the
pending SIGSTOP. */
pending SIGSTOP. */
registers_changed ();
child_resume (pid_to_ptid (GET_LWP (lp->ptid)), lp->step,
TARGET_SIGNAL_0);
TARGET_SIGNAL_0);
if (debug_lin_lwp)
fprintf_unfiltered (gdb_stdlog,
"LLW: %s %s, 0, 0 (expect SIGSTOP)\n",
@ -1152,8 +1149,8 @@ lin_lwp_wait (ptid_t ptid, struct target_waitstatus *ourstatus)
stop_wait_callback (lp, NULL);
}
set_sigint_trap (); /* Causes SIGINT to be passed on to the
attached process. */
set_sigint_trap (); /* Causes SIGINT to be passed on to the
attached process. */
set_sigio_trap ();
while (status == 0)
@ -1169,8 +1166,7 @@ lin_lwp_wait (ptid_t ptid, struct target_waitstatus *ourstatus)
{
fprintf_unfiltered (gdb_stdlog,
"LLW: waitpid %ld received %s\n",
(long) lwpid,
status_to_str (status));
(long) lwpid, status_to_str (status));
}
lp = find_lwp_pid (pid_to_ptid (lwpid));
@ -1179,13 +1175,13 @@ lin_lwp_wait (ptid_t ptid, struct target_waitstatus *ourstatus)
our list, i.e. not part of the current process. This can happen
if we detach from a program we original forked and then it
exits. */
if (! WIFSTOPPED (status) && ! lp)
if (!WIFSTOPPED (status) && !lp)
{
status = 0;
continue;
}
if (! lp)
if (!lp)
{
lp = add_lwp (BUILD_LWP (lwpid, GET_PID (inferior_ptid)));
if (options & __WCLONE)
@ -1197,10 +1193,10 @@ lin_lwp_wait (ptid_t ptid, struct target_waitstatus *ourstatus)
&& WSTOPSIG (status) == SIGSTOP);
lp->signalled = 1;
if (! in_thread_list (inferior_ptid))
if (!in_thread_list (inferior_ptid))
{
inferior_ptid = BUILD_LWP (GET_PID (inferior_ptid),
GET_PID (inferior_ptid));
GET_PID (inferior_ptid));
add_thread (inferior_ptid);
}
@ -1211,22 +1207,22 @@ lin_lwp_wait (ptid_t ptid, struct target_waitstatus *ourstatus)
}
/* Make sure we don't report a TARGET_WAITKIND_EXITED or
TARGET_WAITKIND_SIGNALLED event if there are still LWP's
left in the process. */
TARGET_WAITKIND_SIGNALLED event if there are still LWP's
left in the process. */
if ((WIFEXITED (status) || WIFSIGNALED (status)) && num_lwps > 1)
{
if (in_thread_list (lp->ptid))
{
/* Core GDB cannot deal with us deleting the current
thread. */
if (! ptid_equal (lp->ptid, inferior_ptid))
thread. */
if (!ptid_equal (lp->ptid, inferior_ptid))
delete_thread (lp->ptid);
printf_unfiltered ("[%s exited]\n",
target_pid_to_str (lp->ptid));
}
if (debug_lin_lwp)
fprintf_unfiltered (gdb_stdlog,
"LLW: %s exited.\n",
fprintf_unfiltered (gdb_stdlog,
"LLW: %s exited.\n",
target_pid_to_str (lp->ptid));
delete_lwp (lp->ptid);
@ -1240,13 +1236,12 @@ lin_lwp_wait (ptid_t ptid, struct target_waitstatus *ourstatus)
}
/* Make sure we don't report a SIGSTOP that we sent
ourselves in an attempt to stop an LWP. */
ourselves in an attempt to stop an LWP. */
if (lp->signalled
&& WIFSTOPPED (status)
&& WSTOPSIG (status) == SIGSTOP)
&& WIFSTOPPED (status) && WSTOPSIG (status) == SIGSTOP)
{
if (debug_lin_lwp)
fprintf_unfiltered (gdb_stdlog,
fprintf_unfiltered (gdb_stdlog,
"LLW: Delayed SIGSTOP caught for %s.\n",
target_pid_to_str (lp->ptid));
@ -1255,11 +1250,11 @@ lin_lwp_wait (ptid_t ptid, struct target_waitstatus *ourstatus)
registers_changed ();
child_resume (pid_to_ptid (GET_LWP (lp->ptid)), lp->step,
TARGET_SIGNAL_0);
TARGET_SIGNAL_0);
if (debug_lin_lwp)
fprintf_unfiltered (gdb_stdlog,
"LLW: %s %s, 0, 0 (discard SIGSTOP)\n",
lp->step ?
lp->step ?
"PTRACE_SINGLESTEP" : "PTRACE_CONT",
target_pid_to_str (lp->ptid));
@ -1309,16 +1304,17 @@ lin_lwp_wait (ptid_t ptid, struct target_waitstatus *ourstatus)
&& signal_pass_state (signo) == 1)
{
/* FIMXE: kettenis/2001-06-06: Should we resume all threads
here? It is not clear we should. GDB may not expect
other threads to run. On the other hand, not resuming
newly attached threads may cause an unwanted delay in
getting them running. */
here? It is not clear we should. GDB may not expect
other threads to run. On the other hand, not resuming
newly attached threads may cause an unwanted delay in
getting them running. */
registers_changed ();
child_resume (pid_to_ptid (GET_LWP (lp->ptid)), lp->step, signo);
if (debug_lin_lwp)
fprintf_unfiltered (gdb_stdlog,
"LLW: %s %s, %s (preempt 'handle')\n",
lp->step ? "PTRACE_SINGLESTEP" : "PTRACE_CONT",
lp->step ?
"PTRACE_SINGLESTEP" : "PTRACE_CONT",
target_pid_to_str (lp->ptid),
signo ? strsignal (signo) : "0");
lp->stopped = 0;
@ -1326,13 +1322,12 @@ lin_lwp_wait (ptid_t ptid, struct target_waitstatus *ourstatus)
goto retry;
}
if (signo == TARGET_SIGNAL_INT
&& signal_pass_state (signo) == 0)
if (signo == TARGET_SIGNAL_INT && signal_pass_state (signo) == 0)
{
/* If ^C/BREAK is typed at the tty/console, SIGINT gets
forwarded to the entire process group, that is, all LWP's
will receive it. Since we only want to report it once,
we try to flush it from all LWPs except this one. */
forwarded to the entire process group, that is, all LWP's
will receive it. Since we only want to report it once,
we try to flush it from all LWPs except this one. */
sigaddset (&flush_mask, SIGINT);
}
}
@ -1342,8 +1337,7 @@ lin_lwp_wait (ptid_t ptid, struct target_waitstatus *ourstatus)
if (debug_lin_lwp)
fprintf_unfiltered (gdb_stdlog, "LLW: Candidate event %s in %s.\n",
status_to_str (status),
target_pid_to_str (lp->ptid));
status_to_str (status), target_pid_to_str (lp->ptid));
/* Now stop all other LWP's ... */
iterate_over_lwps (stop_callback, NULL);
@ -1370,7 +1364,7 @@ lin_lwp_wait (ptid_t ptid, struct target_waitstatus *ourstatus)
{
trap_ptid = (threaded ? lp->ptid : pid_to_ptid (GET_LWP (lp->ptid)));
if (debug_lin_lwp)
fprintf_unfiltered (gdb_stdlog,
fprintf_unfiltered (gdb_stdlog,
"LLW: trap_ptid is %s.\n",
target_pid_to_str (trap_ptid));
}
@ -1387,7 +1381,7 @@ kill_callback (struct lwp_info *lp, void *data)
errno = 0;
ptrace (PTRACE_KILL, GET_LWP (lp->ptid), 0, 0);
if (debug_lin_lwp)
fprintf_unfiltered (gdb_stdlog,
fprintf_unfiltered (gdb_stdlog,
"KC: PTRACE_KILL %s, 0, 0 (%s)\n",
target_pid_to_str (lp->ptid),
errno ? safe_strerror (errno) : "OK");
@ -1430,7 +1424,7 @@ kill_wait_callback (struct lwp_info *lp, void *data)
if (pid != (pid_t) -1 && debug_lin_lwp)
{
fprintf_unfiltered (gdb_stdlog,
"KWC: wait %s received unk.\n",
"KWC: wait %s received unk.\n",
target_pid_to_str (lp->ptid));
}
}
@ -1458,7 +1452,7 @@ lin_lwp_create_inferior (char *exec_file, char *allargs, char **env)
child_ops.to_create_inferior (exec_file, allargs, env);
}
static void
static void
lin_lwp_mourn_inferior (void)
{
trap_ptid = null_ptid;
@ -1475,8 +1469,7 @@ lin_lwp_mourn_inferior (void)
static int
lin_lwp_xfer_memory (CORE_ADDR memaddr, char *myaddr, int len, int write,
struct mem_attrib *attrib,
struct target_ops *target)
struct mem_attrib *attrib, struct target_ops *target)
{
struct cleanup *old_chain = save_inferior_ptid ();
int xfer;
@ -1502,7 +1495,7 @@ lin_lwp_thread_alive (ptid_t ptid)
if (debug_lin_lwp)
fprintf_unfiltered (gdb_stdlog,
"LLTA: PTRACE_PEEKUSER %s, 0, 0 (%s)\n",
target_pid_to_str (ptid),
target_pid_to_str (ptid),
errno ? safe_strerror (errno) : "OK");
if (errno)
return 0;
@ -1586,11 +1579,9 @@ _initialize_lin_lwp (void)
sigemptyset (&blocked_mask);
add_show_from_set (add_set_cmd ("lin-lwp", no_class, var_zinteger,
(char *) &debug_lin_lwp,
(char *) &debug_lin_lwp,
"Set debugging of GNU/Linux lwp module.\n\
Enables printf debugging output.\n",
&setdebuglist),
&showdebuglist);
Enables printf debugging output.\n", &setdebuglist), &showdebuglist);
}

205
gdb/linux-proc.c
View File

@ -21,17 +21,17 @@
#include "defs.h"
#include "inferior.h"
#include <sys/param.h> /* for MAXPATHLEN */
#include <sys/procfs.h> /* for elf_gregset etc. */
#include "gdb_stat.h" /* for struct stat */
#include <ctype.h> /* for isdigit */
#include <unistd.h> /* for open, pread64 */
#include <fcntl.h> /* for O_RDONLY */
#include "regcache.h" /* for registers_changed */
#include "gregset.h" /* for gregset */
#include "gdbcore.h" /* for get_exec_file */
#include "gdbthread.h" /* for struct thread_info etc. */
#include "elf-bfd.h" /* for elfcore_write_* */
#include <sys/param.h> /* for MAXPATHLEN */
#include <sys/procfs.h> /* for elf_gregset etc. */
#include "gdb_stat.h" /* for struct stat */
#include <ctype.h> /* for isdigit */
#include <unistd.h> /* for open, pread64 */
#include <fcntl.h> /* for O_RDONLY */
#include "regcache.h" /* for registers_changed */
#include "gregset.h" /* for gregset */
#include "gdbcore.h" /* for get_exec_file */
#include "gdbthread.h" /* for struct thread_info etc. */
#include "elf-bfd.h" /* for elfcore_write_* */
#include "cli/cli-decode.h" /* for add_info */
#include "gdb_string.h"
@ -69,28 +69,26 @@ child_pid_to_exec_file (int pid)
* Service function for corefiles and info proc.
*/
static int
read_mapping (FILE *mapfile,
long long *addr,
long long *endaddr,
char *permissions,
long long *offset,
char *device,
long long *inode,
char *filename)
static int
read_mapping (FILE *mapfile,
long long *addr,
long long *endaddr,
char *permissions,
long long *offset,
char *device, long long *inode, char *filename)
{
int ret = fscanf (mapfile, "%llx-%llx %s %llx %s %llx",
int ret = fscanf (mapfile, "%llx-%llx %s %llx %s %llx",
addr, endaddr, permissions, offset, device, inode);
if (ret > 0 && ret != EOF && *inode != 0)
{
/* Eat everything up to EOL for the filename. This will prevent
weird filenames (such as one with embedded whitespace) from
confusing this code. It also makes this code more robust
in respect to annotations the kernel may add after the
filename.
weird filenames (such as one with embedded whitespace) from
confusing this code. It also makes this code more robust
in respect to annotations the kernel may add after the
filename.
Note the filename is used for informational purposes only. */
Note the filename is used for informational purposes only. */
ret += fscanf (mapfile, "%[^\n]\n", filename);
}
else
@ -108,11 +106,9 @@ read_mapping (FILE *mapfile,
*/
static int
linux_find_memory_regions (int (*func) (CORE_ADDR,
linux_find_memory_regions (int (*func) (CORE_ADDR,
unsigned long,
int, int, int,
void *),
void *obfd)
int, int, int, void *), void *obfd)
{
long long pid = PIDGET (inferior_ptid);
char mapsfilename[MAXPATHLEN];
@ -128,31 +124,29 @@ linux_find_memory_regions (int (*func) (CORE_ADDR,
error ("Could not open %s\n", mapsfilename);
if (info_verbose)
fprintf_filtered (gdb_stdout,
fprintf_filtered (gdb_stdout,
"Reading memory regions from %s\n", mapsfilename);
/* Now iterate until end-of-file. */
while (read_mapping (mapsfile, &addr, &endaddr, &permissions[0],
while (read_mapping (mapsfile, &addr, &endaddr, &permissions[0],
&offset, &device[0], &inode, &filename[0]))
{
size = endaddr - addr;
/* Get the segment's permissions. */
read = (strchr (permissions, 'r') != 0);
read = (strchr (permissions, 'r') != 0);
write = (strchr (permissions, 'w') != 0);
exec = (strchr (permissions, 'x') != 0);
exec = (strchr (permissions, 'x') != 0);
if (info_verbose)
{
fprintf_filtered (gdb_stdout,
"Save segment, %lld bytes at 0x%s (%c%c%c)",
size, paddr_nz (addr),
read ? 'r' : ' ',
write ? 'w' : ' ',
exec ? 'x' : ' ');
fprintf_filtered (gdb_stdout,
"Save segment, %lld bytes at 0x%s (%c%c%c)",
size, paddr_nz (addr),
read ? 'r' : ' ',
write ? 'w' : ' ', exec ? 'x' : ' ');
if (filename && filename[0])
fprintf_filtered (gdb_stdout,
" for %s", filename);
fprintf_filtered (gdb_stdout, " for %s", filename);
fprintf_filtered (gdb_stdout, "\n");
}
@ -169,7 +163,7 @@ linux_find_memory_regions (int (*func) (CORE_ADDR,
*/
static char *
linux_do_thread_registers (bfd *obfd, ptid_t ptid,
linux_do_thread_registers (bfd *obfd, ptid_t ptid,
char *note_data, int *note_size)
{
gdb_gregset_t gregs;
@ -180,26 +174,23 @@ linux_do_thread_registers (bfd *obfd, ptid_t ptid,
unsigned long merged_pid = ptid_get_tid (ptid) << 16 | ptid_get_pid (ptid);
fill_gregset (&gregs, -1);
note_data = (char *) elfcore_write_prstatus (obfd,
note_data,
note_size,
merged_pid,
stop_signal,
&gregs);
note_data = (char *) elfcore_write_prstatus (obfd,
note_data,
note_size,
merged_pid,
stop_signal, &gregs);
fill_fpregset (&fpregs, -1);
note_data = (char *) elfcore_write_prfpreg (obfd,
note_data,
note_size,
&fpregs,
sizeof (fpregs));
note_data = (char *) elfcore_write_prfpreg (obfd,
note_data,
note_size,
&fpregs, sizeof (fpregs));
#ifdef FILL_FPXREGSET
fill_fpxregset (&fpxregs, -1);
note_data = (char *) elfcore_write_prxfpreg (obfd,
note_data,
note_size,
&fpxregs,
sizeof (fpxregs));
note_data = (char *) elfcore_write_prxfpreg (obfd,
note_data,
note_size,
&fpxregs, sizeof (fpxregs));
#endif
return note_data;
}
@ -228,9 +219,9 @@ linux_corefile_thread_callback (struct thread_info *ti, void *data)
registers_changed ();
target_fetch_registers (-1); /* FIXME should not be necessary;
fill_gregset should do it automatically. */
args->note_data = linux_do_thread_registers (args->obfd,
ti->ptid,
args->note_data,
args->note_data = linux_do_thread_registers (args->obfd,
ti->ptid,
args->note_data,
args->note_size);
args->num_notes++;
inferior_ptid = saved_ptid;
@ -252,28 +243,24 @@ linux_make_note_section (bfd *obfd, int *note_size)
{
struct linux_corefile_thread_data thread_args;
struct cleanup *old_chain;
char fname[16] = {'\0'};
char psargs[80] = {'\0'};
char fname[16] = { '\0' };
char psargs[80] = { '\0' };
char *note_data = NULL;
ptid_t current_ptid = inferior_ptid;
if (get_exec_file (0))
{
strncpy (fname, strrchr (get_exec_file (0), '/') + 1, sizeof (fname));
strncpy (psargs, get_exec_file (0),
sizeof (psargs));
strncpy (psargs, get_exec_file (0), sizeof (psargs));
if (get_inferior_args ())
{
strncat (psargs, " ",
sizeof (psargs) - strlen (psargs));
strncat (psargs, get_inferior_args (),
strncat (psargs, " ", sizeof (psargs) - strlen (psargs));
strncat (psargs, get_inferior_args (),
sizeof (psargs) - strlen (psargs));
}
note_data = (char *) elfcore_write_prpsinfo (obfd,
note_data,
note_size,
fname,
psargs);
note_data = (char *) elfcore_write_prpsinfo (obfd,
note_data,
note_size, fname, psargs);
}
/* Dump information for threads. */
@ -285,8 +272,8 @@ linux_make_note_section (bfd *obfd, int *note_size)
if (thread_args.num_notes == 0)
{
/* iterate_over_threads didn't come up with any threads;
just use inferior_ptid. */
note_data = linux_do_thread_registers (obfd, inferior_ptid,
just use inferior_ptid. */
note_data = linux_do_thread_registers (obfd, inferior_ptid,
note_data, note_size);
}
else
@ -420,33 +407,30 @@ linux_info_proc_cmd (char *args, int from_tty)
if (TARGET_ADDR_BIT == 32)
{
header_fmt_string = "\t%10s %10s %10s %10s %7s\n";
data_fmt_string = "\t%#10lx %#10lx %#10x %#10x %7s\n";
data_fmt_string = "\t%#10lx %#10lx %#10x %#10x %7s\n";
}
else
{
header_fmt_string = " %18s %18s %10s %10s %7s\n";
data_fmt_string = " %#18lx %#18lx %#10x %#10x %7s\n";
data_fmt_string = " %#18lx %#18lx %#10x %#10x %7s\n";
}
printf_filtered ("Mapped address spaces:\n\n");
printf_filtered (header_fmt_string,
printf_filtered (header_fmt_string,
"Start Addr",
" End Addr",
" Size",
" Offset",
"objfile");
while (read_mapping (procfile, &addr, &endaddr, &permissions[0],
" Size", " Offset", "objfile");
while (read_mapping (procfile, &addr, &endaddr, &permissions[0],
&offset, &device[0], &inode, &filename[0]))
{
size = endaddr - addr;
printf_filtered (data_fmt_string,
(unsigned long) addr, /* FIXME: pr_addr */
(unsigned long) endaddr,
(int) size,
(unsigned int) offset,
printf_filtered (data_fmt_string, (unsigned long) addr, /* FIXME: pr_addr */
(unsigned long) endaddr,
(int) size,
(unsigned int) offset,
filename[0] ? filename : "");
}
fclose (procfile);
@ -463,7 +447,7 @@ linux_info_proc_cmd (char *args, int from_tty)
printf_filtered (buffer);
fclose (procfile);
}
else
else
warning ("unable to open /proc file '%s'", fname1);
}
if (stat_f || all)
@ -493,16 +477,16 @@ linux_info_proc_cmd (char *args, int from_tty)
if (fscanf (procfile, "%u ", &itmp) > 0)
printf_filtered ("Flags: 0x%x\n", itmp);
if (fscanf (procfile, "%u ", &itmp) > 0)
printf_filtered ("Minor faults (no memory page): %u\n",
printf_filtered ("Minor faults (no memory page): %u\n",
(unsigned int) itmp);
if (fscanf (procfile, "%u ", &itmp) > 0)
printf_filtered ("Minor faults, children: %u\n",
printf_filtered ("Minor faults, children: %u\n",
(unsigned int) itmp);
if (fscanf (procfile, "%u ", &itmp) > 0)
printf_filtered ("Major faults (memory page faults): %u\n",
printf_filtered ("Major faults (memory page faults): %u\n",
(unsigned int) itmp);
if (fscanf (procfile, "%u ", &itmp) > 0)
printf_filtered ("Major faults, children: %u\n",
printf_filtered ("Major faults, children: %u\n",
(unsigned int) itmp);
if (fscanf (procfile, "%d ", &itmp) > 0)
printf_filtered ("utime: %d\n", itmp);
@ -513,36 +497,34 @@ linux_info_proc_cmd (char *args, int from_tty)
if (fscanf (procfile, "%d ", &itmp) > 0)
printf_filtered ("stime, children: %d\n", itmp);
if (fscanf (procfile, "%d ", &itmp) > 0)
printf_filtered ("jiffies remaining in current time slice: %d\n",
printf_filtered ("jiffies remaining in current time slice: %d\n",
itmp);
if (fscanf (procfile, "%d ", &itmp) > 0)
printf_filtered ("'nice' value: %d\n", itmp);
if (fscanf (procfile, "%u ", &itmp) > 0)
printf_filtered ("jiffies until next timeout: %u\n",
printf_filtered ("jiffies until next timeout: %u\n",
(unsigned int) itmp);
if (fscanf (procfile, "%u ", &itmp) > 0)
printf_filtered ("jiffies until next SIGALRM: %u\n",
printf_filtered ("jiffies until next SIGALRM: %u\n",
(unsigned int) itmp);
if (fscanf (procfile, "%d ", &itmp) > 0)
printf_filtered ("start time (jiffies since system boot): %d\n",
printf_filtered ("start time (jiffies since system boot): %d\n",
itmp);
if (fscanf (procfile, "%u ", &itmp) > 0)
printf_filtered ("Virtual memory size: %u\n",
printf_filtered ("Virtual memory size: %u\n",
(unsigned int) itmp);
if (fscanf (procfile, "%u ", &itmp) > 0)
printf_filtered ("Resident set size: %u\n",
(unsigned int) itmp);
printf_filtered ("Resident set size: %u\n", (unsigned int) itmp);
if (fscanf (procfile, "%u ", &itmp) > 0)
printf_filtered ("rlim: %u\n",
(unsigned int) itmp);
printf_filtered ("rlim: %u\n", (unsigned int) itmp);
if (fscanf (procfile, "%u ", &itmp) > 0)
printf_filtered ("Start of text: 0x%x\n", itmp);
if (fscanf (procfile, "%u ", &itmp) > 0)
printf_filtered ("End of text: 0x%x\n", itmp);
if (fscanf (procfile, "%u ", &itmp) > 0)
printf_filtered ("Start of stack: 0x%x\n", itmp);
#if 0 /* Don't know how architecture-dependent the rest is...
Anyway the signal bitmap info is available from "status". */
#if 0 /* Don't know how architecture-dependent the rest is...
Anyway the signal bitmap info is available from "status". */
if (fscanf (procfile, "%u ", &itmp) > 0) /* FIXME arch? */
printf_filtered ("Kernel stack pointer: 0x%x\n", itmp);
if (fscanf (procfile, "%u ", &itmp) > 0) /* FIXME arch? */
@ -574,7 +556,7 @@ _initialize_linux_proc (void)
inftarg_set_find_memory_regions (linux_find_memory_regions);
inftarg_set_make_corefile_notes (linux_make_note_section);
add_info ("proc", linux_info_proc_cmd,
add_info ("proc", linux_info_proc_cmd,
"Show /proc process information about any running process.\n\
Specify any process id, or use the program being debugged by default.\n\
Specify any of the following keywords for detailed info:\n\
@ -584,9 +566,9 @@ Specify any of the following keywords for detailed info:\n\
all -- list all available /proc info.");
}
int linux_proc_xfer_memory (CORE_ADDR addr, char *myaddr, int len, int write,
struct mem_attrib *attrib,
struct target_ops *target)
int
linux_proc_xfer_memory (CORE_ADDR addr, char *myaddr, int len, int write,
struct mem_attrib *attrib, struct target_ops *target)
{
int fd, ret;
char filename[64];
@ -616,8 +598,7 @@ int linux_proc_xfer_memory (CORE_ADDR addr, char *myaddr, int len, int write,
#ifdef HAVE_PREAD64
if (pread64 (fd, myaddr, len, addr) != len)
#else
if (lseek (fd, addr, SEEK_SET) == -1
|| read (fd, myaddr, len) != len)
if (lseek (fd, addr, SEEK_SET) == -1 || read (fd, myaddr, len) != len)
#endif
ret = 0;
else

64
gdb/thread.c
View File

@ -255,9 +255,8 @@ in_thread_list (ptid_t ptid)
/* Print a list of thread ids currently known, and the total number of
threads. To be used from within catch_errors. */
static int
do_captured_list_thread_ids (struct ui_out *uiout,
void *arg)
static int
do_captured_list_thread_ids (struct ui_out *uiout, void *arg)
{
struct thread_info *tp;
int num = 0;
@ -291,24 +290,23 @@ gdb_list_thread_ids (struct ui_out *uiout)
/* Load infrun state for the thread PID. */
void
load_infrun_state (ptid_t ptid,
CORE_ADDR *prev_pc,
load_infrun_state (ptid_t ptid,
CORE_ADDR *prev_pc,
CORE_ADDR *prev_func_start,
char **prev_func_name,
char **prev_func_name,
int *trap_expected,
struct breakpoint **step_resume_breakpoint,
struct breakpoint **through_sigtramp_breakpoint,
CORE_ADDR *step_range_start,
CORE_ADDR *step_range_start,
CORE_ADDR *step_range_end,
struct frame_id *step_frame_id,
struct frame_id *step_frame_id,
int *handling_longjmp,
int *another_trap,
int *another_trap,
int *stepping_through_solib_after_catch,
bpstat *stepping_through_solib_catchpoints,
int *stepping_through_sigtramp,
int *current_line,
struct symtab **current_symtab,
CORE_ADDR *step_sp)
int *current_line,
struct symtab **current_symtab, CORE_ADDR *step_sp)
{
struct thread_info *tp;
@ -329,8 +327,10 @@ load_infrun_state (ptid_t ptid,
*step_frame_id = tp->step_frame_id;
*handling_longjmp = tp->handling_longjmp;
*another_trap = tp->another_trap;
*stepping_through_solib_after_catch = tp->stepping_through_solib_after_catch;
*stepping_through_solib_catchpoints = tp->stepping_through_solib_catchpoints;
*stepping_through_solib_after_catch =
tp->stepping_through_solib_after_catch;
*stepping_through_solib_catchpoints =
tp->stepping_through_solib_catchpoints;
*stepping_through_sigtramp = tp->stepping_through_sigtramp;
*current_line = tp->current_line;
*current_symtab = tp->current_symtab;
@ -340,24 +340,23 @@ load_infrun_state (ptid_t ptid,
/* Save infrun state for the thread PID. */
void
save_infrun_state (ptid_t ptid,
CORE_ADDR prev_pc,
save_infrun_state (ptid_t ptid,
CORE_ADDR prev_pc,
CORE_ADDR prev_func_start,
char *prev_func_name,
char *prev_func_name,
int trap_expected,
struct breakpoint *step_resume_breakpoint,
struct breakpoint *through_sigtramp_breakpoint,
CORE_ADDR step_range_start,
CORE_ADDR step_range_start,
CORE_ADDR step_range_end,
const struct frame_id *step_frame_id,
const struct frame_id *step_frame_id,
int handling_longjmp,
int another_trap,
int another_trap,
int stepping_through_solib_after_catch,
bpstat stepping_through_solib_catchpoints,
int stepping_through_sigtramp,
int stepping_through_sigtramp,
int current_line,
struct symtab *current_symtab,
CORE_ADDR step_sp)
struct symtab *current_symtab, CORE_ADDR step_sp)
{
struct thread_info *tp;
@ -506,7 +505,7 @@ switch_to_thread (ptid_t ptid)
static void
restore_current_thread (ptid_t ptid)
{
if (! ptid_equal (ptid, inferior_ptid))
if (!ptid_equal (ptid, inferior_ptid))
{
switch_to_thread (ptid);
print_stack_frame (get_current_frame (), 0, -1);
@ -571,14 +570,13 @@ thread_apply_all_command (char *cmd, int from_tty)
switch_to_thread (tp->ptid);
#ifdef HPUXHPPA
printf_filtered ("\nThread %d (%s):\n",
tp->num,
target_tid_to_str (inferior_ptid));
tp->num, target_tid_to_str (inferior_ptid));
#else
printf_filtered ("\nThread %d (%s):\n", tp->num,
target_pid_to_str (inferior_ptid));
#endif
execute_command (cmd, from_tty);
strcpy (cmd, saved_cmd); /* Restore exact command used previously */
strcpy (cmd, saved_cmd); /* Restore exact command used previously */
}
do_cleanups (saved_cmd_cleanup_chain);
@ -690,8 +688,7 @@ thread_command (char *tidstr, int from_tty)
}
static int
do_captured_thread_select (struct ui_out *uiout,
void *tidstr)
do_captured_thread_select (struct ui_out *uiout, void *tidstr)
{
int num;
struct thread_info *tp;
@ -724,8 +721,7 @@ do_captured_thread_select (struct ui_out *uiout,
}
enum gdb_rc
gdb_thread_select (struct ui_out *uiout,
char *tidstr)
gdb_thread_select (struct ui_out *uiout, char *tidstr)
{
return catch_exceptions (uiout, do_captured_thread_select, tidstr,
NULL, RETURN_MASK_ALL);
@ -744,16 +740,14 @@ _initialize_thread (void)
add_prefix_cmd ("thread", class_run, thread_command,
"Use this command to switch between threads.\n\
The new thread ID must be currently known.", &thread_cmd_list, "thread ", 1,
&cmdlist);
The new thread ID must be currently known.", &thread_cmd_list, "thread ", 1, &cmdlist);
add_prefix_cmd ("apply", class_run, thread_apply_command,
"Apply a command to a list of threads.",
&thread_apply_list, "apply ", 1, &thread_cmd_list);
add_cmd ("all", class_run, thread_apply_all_command,
"Apply a command to all threads.",
&thread_apply_list);
"Apply a command to all threads.", &thread_apply_list);
if (!xdb_commands)
add_com_alias ("t", "thread", class_run, 1);