chael Snyder <msnyder@redhat.com>

	* lin-lwp.c: Added or elaborated on "debug lin-lwp" info.
\10qCVS: Committing in .

diff --git a/gdb/ChangeLog b/gdb/ChangeLog
index 2c30678..122f2d1 100644 (file)
--- a/gdb/ChangeLog
+++ b/gdb/ChangeLog
@@ -1,3 +1,7 @@
+2003-01-06  Michael Snyder  <msnyder@redhat.com>
+
+       * lin-lwp.c: Added or elaborated on "debug lin-lwp" info.
+
 2003-01-06  Andrew Cagney  <ac131313@redhat.com>
 
        * frame.h (deprecated_frame_xmalloc_with_cleanup): Declare.

diff --git a/gdb/lin-lwp.c b/gdb/lin-lwp.c
index 0b30cea..6118927 100644 (file)
--- a/gdb/lin-lwp.c
+++ b/gdb/lin-lwp.c
@@ -379,6 +379,11 @@ lin_lwp_attach_lwp (ptid_t ptid, int verbose)
        error ("Can't attach %s: %s", target_pid_to_str (ptid),
               safe_strerror (errno));
 
+      if (debug_lin_lwp)
+       fprintf_unfiltered (gdb_stdlog, 
+                           "LLAL: PTRACE_ATTACH %s, 0, 0 (OK)\n", 
+                           target_pid_to_str (ptid));
+
       pid = waitpid (GET_LWP (ptid), &status, 0);
       if (pid == -1 && errno == ECHILD)
        {
@@ -391,6 +396,14 @@ lin_lwp_attach_lwp (ptid_t ptid, int verbose)
                  && WIFSTOPPED (status) && WSTOPSIG (status));
 
       lp->stopped = 1;
+
+      if (debug_lin_lwp)
+       {
+         fprintf_unfiltered (gdb_stdlog,
+                             "LLAL: waitpid %s received %s\n",
+                             target_pid_to_str (ptid), 
+                             status_to_str (status));
+       }
     }
   else
     {
@@ -439,6 +452,12 @@ lin_lwp_attach (char *args, int from_tty)
   /* Fake the SIGSTOP that core GDB expects.  */
   lp->status = W_STOPCODE (SIGSTOP);
   lp->resumed = 1;
+  if (debug_lin_lwp)
+    {
+      fprintf_unfiltered (gdb_stdlog,
+                         "LLA: waitpid %ld, faking SIGSTOP\n", 
+                         (long) pid);
+    }
 }
 
 static int
@@ -447,16 +466,24 @@ detach_callback (struct lwp_info *lp, void *data)
   gdb_assert (lp->status == 0 || WIFSTOPPED (lp->status));
 
   if (debug_lin_lwp && lp->status)
-    fprintf_unfiltered (gdb_stdlog, "Pending %s for LWP %ld on detach.\n",
-                       strsignal (WSTOPSIG (lp->status)), GET_LWP (lp->ptid));
+    fprintf_unfiltered (gdb_stdlog, "DC:  Pending %s for %s on detach.\n",
+                       strsignal (WSTOPSIG (lp->status)), 
+                       target_pid_to_str (lp->ptid));
 
   while (lp->signalled && lp->stopped)
     {
+      errno = 0;
       if (ptrace (PTRACE_CONT, GET_LWP (lp->ptid), 0,
                  WSTOPSIG (lp->status)) < 0)
        error ("Can't continue %s: %s", target_pid_to_str (lp->ptid),
               safe_strerror (errno));
 
+      if (debug_lin_lwp)
+       fprintf_unfiltered (gdb_stdlog, 
+                           "DC:  PTRACE_CONTINUE (%s, 0, %s) (OK)\n",
+                           target_pid_to_str (lp->ptid),
+                           status_to_str (lp->status)); 
+
       lp->stopped = 0;
       lp->signalled = 0;
       lp->status = 0;
@@ -469,11 +496,18 @@ detach_callback (struct lwp_info *lp, void *data)
      overall process id just yet.  */
   if (GET_LWP (lp->ptid) != GET_PID (lp->ptid))
     {
+      errno = 0;
       if (ptrace (PTRACE_DETACH, GET_LWP (lp->ptid), 0,
                  WSTOPSIG (lp->status)) < 0)
        error ("Can't detach %s: %s", target_pid_to_str (lp->ptid),
               safe_strerror (errno));
 
+      if (debug_lin_lwp)
+       fprintf_unfiltered (gdb_stdlog,
+                           "PTRACE_DETACH (%s, %s, 0) (OK)\n",
+                           target_pid_to_str (lp->ptid), 
+                           strsignal (WSTOPSIG (lp->status)));
+
       delete_lwp (lp->ptid);
     }
 
@@ -552,6 +586,10 @@ resume_callback (struct lwp_info *lp, void *data)
 #endif
 
       child_resume (pid_to_ptid (GET_LWP (lp->ptid)), 0, TARGET_SIGNAL_0);
+      if (debug_lin_lwp)
+       fprintf_unfiltered (gdb_stdlog, 
+                           "RC:  PTRACE_CONT %s, 0, 0 (resume sibling)\n",
+                           target_pid_to_str (lp->ptid));
       lp->stopped = 0;
       lp->step = 0;
     }
@@ -622,6 +660,12 @@ lin_lwp_resume (ptid_t ptid, int step, enum target_signal signo)
     iterate_over_lwps (resume_callback, NULL);
 
   child_resume (ptid, step, signo);
+  if (debug_lin_lwp)
+    fprintf_unfiltered (gdb_stdlog,
+                       "LLR: %s %s, %s (resume event thread)\n",
+                       step ? "PTRACE_SINGLESTEP" : "PTRACE_CONT",
+                       target_pid_to_str (ptid),
+                       signo ? strsignal (signo) : "0");
 }
 \f
 
@@ -634,6 +678,12 @@ stop_callback (struct lwp_info *lp, void *data)
     {
       int ret;
 
+      if (debug_lin_lwp)
+       {
+         fprintf_unfiltered (gdb_stdlog,
+                             "SC:  kill %s **<SIGSTOP>**\n",
+                             target_pid_to_str (lp->ptid));
+       }
       ret = kill (GET_LWP (lp->ptid), SIGSTOP);
       gdb_assert (ret == 0);
 
@@ -667,6 +717,14 @@ stop_wait_callback (struct lwp_info *lp, void *data)
 
       gdb_assert (pid == GET_LWP (lp->ptid));
 
+      if (debug_lin_lwp)
+       {
+         fprintf_unfiltered (gdb_stdlog,
+                             "SWC: waitpid %s received %s\n",
+                             target_pid_to_str (lp->ptid), 
+                             status_to_str (status));
+       }
+
       if (WIFEXITED (status) || WIFSIGNALED (status))
        {
          gdb_assert (num_lwps > 1);
@@ -681,8 +739,8 @@ stop_wait_callback (struct lwp_info *lp, void *data)
                                 target_pid_to_str (lp->ptid));
            }
          if (debug_lin_lwp)
-           fprintf_unfiltered (gdb_stdlog, 
-                               "%s exited.\n", target_pid_to_str (lp->ptid));
+           fprintf_unfiltered (gdb_stdlog, "SWC: %s exited.\n", 
+                               target_pid_to_str (lp->ptid));
 
          delete_lwp (lp->ptid);
          return 0;
@@ -693,7 +751,14 @@ stop_wait_callback (struct lwp_info *lp, void *data)
       /* Ignore any signals in FLUSH_MASK.  */
       if (flush_mask && sigismember (flush_mask, WSTOPSIG (status)))
        {
+         errno = 0;
          ptrace (PTRACE_CONT, GET_LWP (lp->ptid), 0, 0);
+         if (debug_lin_lwp)
+           fprintf_unfiltered (gdb_stdlog,
+                               "PTRACE_CONT %s, 0, 0 (%s)\n",
+                               target_pid_to_str (lp->ptid),
+                               errno ? safe_strerror (errno) : "OK");
+
          return stop_wait_callback (lp, flush_mask);
        }
 
@@ -715,18 +780,26 @@ stop_wait_callback (struct lwp_info *lp, void *data)
                 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_stderr, 
-                                     "SWC: Candidate SIGTRAP event in %ld\n",
-                                     GET_LWP (lp->ptid));
+                 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, 
+                                     "SWC: Candidate SIGTRAP event in %s\n",
+                                     target_pid_to_str (lp->ptid));
                }
              /* Hold the SIGTRAP for handling by lin_lwp_wait. */
              stop_wait_callback (lp, data);
              /* If there's another event, throw it back into the queue. */
              if (lp->status)
-               kill (GET_LWP (lp->ptid), WSTOPSIG (lp->status));
+               {
+                 kill (GET_LWP (lp->ptid), WSTOPSIG (lp->status));
+               }
              /* Save the sigtrap event. */
              lp->status = status;
              return 0;
@@ -738,12 +811,19 @@ stop_wait_callback (struct lwp_info *lp, void *data)
 
              if (debug_lin_lwp)
                {
-                 fprintf_unfiltered (gdb_stderr, 
-                                     "SWC: Pending event %d in %ld\n",
-                                     WSTOPSIG (status), GET_LWP (lp->ptid));
+                 fprintf_unfiltered (gdb_stdlog, 
+                                     "SWC: Pending event %s in %s\n",
+                                     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, 
+                                   "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). */
@@ -754,7 +834,16 @@ stop_wait_callback (struct lwp_info *lp, void *data)
              if (lp->status == 0)
                lp->status = status;
              else
-               kill (GET_LWP (lp->ptid), WSTOPSIG (status));
+               {
+                 if (debug_lin_lwp)
+                   {
+                     fprintf_unfiltered (gdb_stdlog, 
+                                         "SWC: kill %s, %s\n",
+                                         target_pid_to_str (lp->ptid), 
+                                         status_to_str ((int) status));
+                   }
+                 kill (GET_LWP (lp->ptid), WSTOPSIG (status));
+               }
              return 0;
            }
        }
@@ -861,8 +950,8 @@ cancel_breakpoints_callback (struct lwp_info *lp, void *data)
     {
       if (debug_lin_lwp)
        fprintf_unfiltered (gdb_stdlog,
-                           "Push back breakpoint for LWP %ld\n",
-                           GET_LWP (lp->ptid));
+                           "CBC: Push back breakpoint for %s\n",
+                           target_pid_to_str (lp->ptid));
 
       /* Back up the PC if necessary.  */
       if (DECR_PC_AFTER_BREAK)
@@ -893,8 +982,8 @@ select_event_lwp (struct lwp_info **orig_lp, int *status)
     {
       if (debug_lin_lwp)
        fprintf_unfiltered (gdb_stdlog,
-                           "Select single-step LWP %ld\n",
-                           GET_LWP (event_lp->ptid));
+                           "SEL: Select single-step %s\n",
+                           target_pid_to_str (event_lp->ptid));
     }
   else
     {
@@ -910,7 +999,7 @@ select_event_lwp (struct lwp_info **orig_lp, int *status)
 
       if (debug_lin_lwp && num_events > 1)
        fprintf_unfiltered (gdb_stdlog, 
-                           "Found %d SIGTRAP events, selecting #%d\n", 
+                           "SEL: Found %d SIGTRAP events, selecting #%d\n", 
                            num_events, random_selector);
 
       event_lp = iterate_over_lwps (select_event_lwp_callback,
@@ -962,6 +1051,15 @@ child_wait (ptid_t ptid, struct target_waitstatus *ourstatus)
       if (pid == -1 && errno == ECHILD)
        /* Try again with __WCLONE to check cloned processes.  */
        pid = waitpid (GET_PID (ptid), &status, __WCLONE);
+
+      if (debug_lin_lwp)
+       {
+         fprintf_unfiltered (gdb_stdlog, 
+                             "CW:  waitpid %ld received %s\n",
+                             (long) pid, 
+                             status_to_str (status));
+       }
+
       save_errno = errno;
 
       clear_sigio_trap ();
@@ -971,7 +1069,8 @@ child_wait (ptid_t ptid, struct target_waitstatus *ourstatus)
 
   if (pid == -1)
     {
-      warning ("Child process unexpectedly missing: %s", safe_strerror (errno));
+      warning ("Child process unexpectedly missing: %s", 
+              safe_strerror (errno));
 
       /* Claim it exited with unknown signal.  */
       ourstatus->kind = TARGET_WAITKIND_SIGNALLED;
@@ -1021,8 +1120,9 @@ lin_lwp_wait (ptid_t ptid, struct target_waitstatus *ourstatus)
 
          if (debug_lin_lwp && status)
            fprintf_unfiltered (gdb_stdlog,
-                               "Using pending wait status %s for LWP %ld.\n",
-                               status_to_str (status), GET_LWP (lp->ptid));
+                               "LLW: Using pending wait status %s for %s.\n",
+                               status_to_str (status), 
+                               target_pid_to_str (lp->ptid));
        }
 
       /* But if we don't fine one, we'll have to wait, and check both
@@ -1034,8 +1134,8 @@ lin_lwp_wait (ptid_t ptid, struct target_waitstatus *ourstatus)
     {
       if (debug_lin_lwp)
        fprintf_unfiltered (gdb_stdlog, 
-                           "Waiting for specific LWP %ld.\n",
-                           GET_LWP (ptid));
+                           "LLW: Waiting for specific LWP %s.\n",
+                           target_pid_to_str (ptid));
 
       /* We have a specific LWP to check.  */
       lp = find_lwp_pid (ptid);
@@ -1045,8 +1145,9 @@ lin_lwp_wait (ptid_t ptid, struct target_waitstatus *ourstatus)
 
       if (debug_lin_lwp && status)
        fprintf_unfiltered (gdb_stdlog,
-                           "Using pending wait status %s for LWP %ld.\n",
-                           status_to_str (status), GET_LWP (lp->ptid));
+                           "LLW: Using pending wait status %s for %s.\n",
+                           status_to_str (status), 
+                           target_pid_to_str (lp->ptid));
 
       /* If we have to wait, take into account whether PID is a cloned
          process or not.  And we have to convert it to something that
@@ -1068,8 +1169,14 @@ lin_lwp_wait (ptid_t ptid, struct target_waitstatus *ourstatus)
 
       /* Resume the thread.  It should halt immediately returning the
         pending SIGSTOP.  */
+      registers_changed ();
       child_resume (pid_to_ptid (GET_LWP (lp->ptid)), lp->step,
                     TARGET_SIGNAL_0);
+      if (debug_lin_lwp)
+       fprintf_unfiltered (gdb_stdlog,
+                           "LLW: %s %s, 0, 0 (expect SIGSTOP)\n",
+                           lp->step ? "PTRACE_SINGLESTEP" : "PTRACE_CONT",
+                           target_pid_to_str (lp->ptid));
       lp->stopped = 0;
       gdb_assert (lp->resumed);
 
@@ -1090,6 +1197,14 @@ lin_lwp_wait (ptid_t ptid, struct target_waitstatus *ourstatus)
        {
          gdb_assert (pid == -1 || lwpid == pid);
 
+         if (debug_lin_lwp)
+           {
+             fprintf_unfiltered (gdb_stdlog,
+                                 "LLW: waitpid %ld received %s\n",
+                                 (long) lwpid, 
+                                 status_to_str (status));
+           }
+
          lp = find_lwp_pid (pid_to_ptid (lwpid));
          if (! lp)
            {
@@ -1132,7 +1247,7 @@ lin_lwp_wait (ptid_t ptid, struct target_waitstatus *ourstatus)
                }
              if (debug_lin_lwp)
                fprintf_unfiltered (gdb_stdlog, 
-                                   "%s exited.\n", 
+                                   "LLW: %s exited.\n", 
                                    target_pid_to_str (lp->ptid));
 
              delete_lwp (lp->ptid);
@@ -1147,19 +1262,28 @@ 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.  */
-         if (lp->signalled && WIFSTOPPED (status)
+         if (lp->signalled
+              && WIFSTOPPED (status)
              && WSTOPSIG (status) == SIGSTOP)
            {
              if (debug_lin_lwp)
                fprintf_unfiltered (gdb_stdlog, 
-                                   "Delayed SIGSTOP caught for %s.\n",
+                                   "LLW: Delayed SIGSTOP caught for %s.\n",
                                    target_pid_to_str (lp->ptid));
 
              /* This is a delayed SIGSTOP.  */
              lp->signalled = 0;
 
+             registers_changed ();
              child_resume (pid_to_ptid (GET_LWP (lp->ptid)), lp->step,
                            TARGET_SIGNAL_0);
+             if (debug_lin_lwp)
+               fprintf_unfiltered (gdb_stdlog,
+                                   "LLW: %s %s, 0, 0 (discard SIGSTOP)\n",
+                                   lp->step ? 
+                                   "PTRACE_SINGLESTEP" : "PTRACE_CONT",
+                                   target_pid_to_str (lp->ptid));
+
              lp->stopped = 0;
              gdb_assert (lp->resumed);
 
@@ -1210,7 +1334,14 @@ lin_lwp_wait (ptid_t ptid, struct target_waitstatus *ourstatus)
              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",
+                               target_pid_to_str (lp->ptid),
+                               signo ? strsignal (signo) : "0");
          lp->stopped = 0;
          status = 0;
          goto retry;
@@ -1231,8 +1362,9 @@ lin_lwp_wait (ptid_t ptid, struct target_waitstatus *ourstatus)
   lp->stopped = 1;
 
   if (debug_lin_lwp)
-    fprintf_unfiltered (gdb_stdlog, "Candidate event %s in LWP %ld.\n",
-                       status_to_str (status), GET_LWP (lp->ptid));
+    fprintf_unfiltered (gdb_stdlog, "LLW: Candidate event %s in %s.\n",
+                       status_to_str (status), 
+                       target_pid_to_str (lp->ptid));
 
   /* Now stop all other LWP's ...  */
   iterate_over_lwps (stop_callback, NULL);
@@ -1260,8 +1392,8 @@ 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, 
-                           "LLW: trap_ptid is %ld\n",
-                           GET_LWP (trap_ptid));
+                           "LLW: trap_ptid is %s.\n",
+                           target_pid_to_str (trap_ptid));
     }
   else
     trap_ptid = null_ptid;
@@ -1273,7 +1405,14 @@ lin_lwp_wait (ptid_t ptid, struct target_waitstatus *ourstatus)
 static int
 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, 
+                       "KC:  PTRACE_KILL %s, 0, 0 (%s)\n",
+                       target_pid_to_str (lp->ptid),
+                       errno ? safe_strerror (errno) : "OK");
+
   return 0;
 }
 
@@ -1294,6 +1433,12 @@ kill_wait_callback (struct lwp_info *lp, void *data)
       do
        {
          pid = waitpid (GET_LWP (lp->ptid), NULL, __WCLONE);
+         if (pid != (pid_t) -1 && debug_lin_lwp)
+           {
+             fprintf_unfiltered (gdb_stdlog,
+                                 "KWC: wait %s received unknown.\n",
+                                 target_pid_to_str (lp->ptid));
+           }
        }
       while (pid == GET_LWP (lp->ptid));
 
@@ -1303,6 +1448,12 @@ kill_wait_callback (struct lwp_info *lp, void *data)
   do
     {
       pid = waitpid (GET_LWP (lp->ptid), NULL, 0);
+      if (pid != (pid_t) -1 && debug_lin_lwp)
+       {
+         fprintf_unfiltered (gdb_stdlog,
+                             "KWC: wait %s received unk.\n", 
+                             target_pid_to_str (lp->ptid));
+       }
     }
   while (pid == GET_LWP (lp->ptid));
 
@@ -1369,6 +1520,11 @@ lin_lwp_thread_alive (ptid_t ptid)
 
   errno = 0;
   ptrace (PTRACE_PEEKUSER, GET_LWP (ptid), 0, 0);
+  if (debug_lin_lwp)
+    fprintf_unfiltered (gdb_stdlog,
+                       "LLTA: PTRACE_PEEKUSER %s, 0, 0 (%s)\n",
+                       target_pid_to_str (ptid), 
+                       errno ? safe_strerror (errno) : "OK");
   if (errno)
     return 0;