gdb/mingw-hdep.c

   1 /* Host support routines for MinGW, for GDB, the GNU debugger.
   2
   3    Copyright (C) 2006-2014 Free Software Foundation, Inc.
   4
   5    This file is part of GDB.
   6
   7    This program is free software; you can redistribute it and/or modify
   8    it under the terms of the GNU General Public License as published by
   9    the Free Software Foundation; either version 3 of the License, or
  10    (at your option) any later version.
  11
  12    This program is distributed in the hope that it will be useful,
  13    but WITHOUT ANY WARRANTY; without even the implied warranty of
  14    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15    GNU General Public License for more details.
  16
  17    You should have received a copy of the GNU General Public License
  18    along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
  19
  20 #include "defs.h"
  21 #include "main.h"
  22 #include "serial.h"
  23 #include "event-loop.h"
  24
  25 #include "gdb_select.h"
  26 #include <string.h>
  27 #include "readline/readline.h"
  28
  29 #include <windows.h>
  30
  31 /* This event is signalled whenever an asynchronous SIGINT handler
  32    needs to perform an action in the main thread.  */
  33 static HANDLE sigint_event;
  34
  35 /* When SIGINT_EVENT is signalled, gdb_select will call this
  36    function.  */
  37 struct async_signal_handler *sigint_handler;
  38
  39 /* The strerror() function can return NULL for errno values that are
  40    out of range.  Provide a "safe" version that always returns a
  41    printable string.
  42
  43    The Windows runtime implementation of strerror never returns NULL,
  44    but does return a useless string for anything above sys_nerr;
  45    unfortunately this includes all socket-related error codes.
  46    This replacement tries to find a system-provided error message.  */
  47
  48 char *
  49 safe_strerror (int errnum)
  50 {
  51   static char *buffer;
  52   int len;
  53
  54   if (errnum >= 0 && errnum < sys_nerr)
  55     return strerror (errnum);
  56
  57   if (buffer)
  58     {
  59       LocalFree (buffer);
  60       buffer = NULL;
  61     }
  62
  63   if (FormatMessage (FORMAT_MESSAGE_ALLOCATE_BUFFER
  64                      | FORMAT_MESSAGE_FROM_SYSTEM,
  65                      NULL, errnum,
  66                      MAKELANGID (LANG_NEUTRAL, SUBLANG_DEFAULT),
  67                      (LPTSTR) &buffer, 0, NULL) == 0)
  68     {
  69       static char buf[32];
  70       xsnprintf (buf, sizeof buf, "(undocumented errno %d)", errnum);
  71       return buf;
  72     }
  73
  74   /* Windows error messages end with a period and a CR-LF; strip that
  75      out.  */
  76   len = strlen (buffer);
  77   if (len > 3 && strcmp (buffer + len - 3, ".\r\n") == 0)
  78     buffer[len - 3] = '\0';
  79
  80   return buffer;
  81 }
  82
  83 /* Return an absolute file name of the running GDB, if possible, or
  84    ARGV0 if not.  The return value is in malloc'ed storage.  */
  85
  86 char *
  87 windows_get_absolute_argv0 (const char *argv0)
  88 {
  89   char full_name[PATH_MAX];
  90
  91   if (GetModuleFileName (NULL, full_name, PATH_MAX))
  92     return xstrdup (full_name);
  93   return xstrdup (argv0);
  94 }
  95
  96 /* Wrapper for select.  On Windows systems, where the select interface
  97    only works for sockets, this uses the GDB serial abstraction to
  98    handle sockets, consoles, pipes, and serial ports.
  99
 100    The arguments to this function are the same as the traditional
 101    arguments to select on POSIX platforms.  */
 102
 103 int
 104 gdb_select (int n, fd_set *readfds, fd_set *writefds, fd_set *exceptfds,
 105             struct timeval *timeout)
 106 {
 107   static HANDLE never_handle;
 108   HANDLE handles[MAXIMUM_WAIT_OBJECTS];
 109   HANDLE h;
 110   DWORD event;
 111   DWORD num_handles;
 112   /* SCBS contains serial control objects corresponding to file
 113      descriptors in READFDS and WRITEFDS.  */
 114   struct serial *scbs[MAXIMUM_WAIT_OBJECTS];
 115   /* The number of valid entries in SCBS.  */
 116   size_t num_scbs;
 117   int fd;
 118   int num_ready;
 119   size_t indx;
 120
 121   num_ready = 0;
 122   num_handles = 0;
 123   num_scbs = 0;
 124   for (fd = 0; fd < n; ++fd)
 125     {
 126       HANDLE read = NULL, except = NULL;
 127       struct serial *scb;
 128
 129       /* There is no support yet for WRITEFDS.  At present, this isn't
 130          used by GDB -- but we do not want to silently ignore WRITEFDS
 131          if something starts using it.  */
 132       gdb_assert (!writefds || !FD_ISSET (fd, writefds));
 133
 134       if ((!readfds || !FD_ISSET (fd, readfds))
 135           && (!exceptfds || !FD_ISSET (fd, exceptfds)))
 136         continue;
 137
 138       scb = serial_for_fd (fd);
 139       if (scb)
 140         {
 141           serial_wait_handle (scb, &read, &except);
 142           scbs[num_scbs++] = scb;
 143         }
 144
 145       if (read == NULL)
 146         read = (HANDLE) _get_osfhandle (fd);
 147       if (except == NULL)
 148         {
 149           if (!never_handle)
 150             never_handle = CreateEvent (0, FALSE, FALSE, 0);
 151
 152           except = never_handle;
 153         }
 154
 155       if (readfds && FD_ISSET (fd, readfds))
 156         {
 157           gdb_assert (num_handles < MAXIMUM_WAIT_OBJECTS);
 158           handles[num_handles++] = read;
 159         }
 160
 161       if (exceptfds && FD_ISSET (fd, exceptfds))
 162         {
 163           gdb_assert (num_handles < MAXIMUM_WAIT_OBJECTS);
 164           handles[num_handles++] = except;
 165         }
 166     }
 167
 168   gdb_assert (num_handles < MAXIMUM_WAIT_OBJECTS);
 169   handles[num_handles++] = sigint_event;
 170
 171   event = WaitForMultipleObjects (num_handles,
 172                                   handles,
 173                                   FALSE,
 174                                   timeout
 175                                   ? (timeout->tv_sec * 1000
 176                                      + timeout->tv_usec / 1000)
 177                                   : INFINITE);
 178   /* EVENT can only be a value in the WAIT_ABANDONED_0 range if the
 179      HANDLES included an abandoned mutex.  Since GDB doesn't use
 180      mutexes, that should never occur.  */
 181   gdb_assert (!(WAIT_ABANDONED_0 <= event
 182                 && event < WAIT_ABANDONED_0 + num_handles));
 183   /* We no longer need the helper threads to check for activity.  */
 184   for (indx = 0; indx < num_scbs; ++indx)
 185     serial_done_wait_handle (scbs[indx]);
 186   if (event == WAIT_FAILED)
 187     return -1;
 188   if (event == WAIT_TIMEOUT)
 189     return 0;
 190   /* Run through the READFDS, clearing bits corresponding to descriptors
 191      for which input is unavailable.  */
 192   h = handles[event - WAIT_OBJECT_0];
 193   for (fd = 0, indx = 0; fd < n; ++fd)
 194     {
 195       HANDLE fd_h;
 196
 197       if ((!readfds || !FD_ISSET (fd, readfds))
 198           && (!exceptfds || !FD_ISSET (fd, exceptfds)))
 199         continue;
 200
 201       if (readfds && FD_ISSET (fd, readfds))
 202         {
 203           fd_h = handles[indx++];
 204           /* This handle might be ready, even though it wasn't the handle
 205              returned by WaitForMultipleObjects.  */
 206           if (fd_h != h && WaitForSingleObject (fd_h, 0) != WAIT_OBJECT_0)
 207             FD_CLR (fd, readfds);
 208           else
 209             num_ready++;
 210         }
 211
 212       if (exceptfds && FD_ISSET (fd, exceptfds))
 213         {
 214           fd_h = handles[indx++];
 215           /* This handle might be ready, even though it wasn't the handle
 216              returned by WaitForMultipleObjects.  */
 217           if (fd_h != h && WaitForSingleObject (fd_h, 0) != WAIT_OBJECT_0)
 218             FD_CLR (fd, exceptfds);
 219           else
 220             num_ready++;
 221         }
 222     }
 223
 224   /* With multi-threaded SIGINT handling, there is a race between the
 225      readline signal handler and GDB.  It may still be in
 226      rl_prep_terminal in another thread.  Do not return until it is
 227      done; we can check the state here because we never longjmp from
 228      signal handlers on Windows.  */
 229   while (RL_ISSTATE (RL_STATE_SIGHANDLER))
 230     Sleep (1);
 231
 232   if (h == sigint_event
 233       || WaitForSingleObject (sigint_event, 0) == WAIT_OBJECT_0)
 234     {
 235       if (sigint_handler != NULL)
 236         call_async_signal_handler (sigint_handler);
 237
 238       if (num_ready == 0)
 239         {
 240           errno = EINTR;
 241           return -1;
 242         }
 243     }
 244
 245   return num_ready;
 246 }
 247
 248 /* Wrapper for the body of signal handlers.  On Windows systems, a
 249    SIGINT handler runs in its own thread.  We can't longjmp from
 250    there, and we shouldn't even prompt the user.  Delay HANDLER
 251    until the main thread is next in gdb_select.  */
 252
 253 void
 254 gdb_call_async_signal_handler (struct async_signal_handler *handler,
 255                                int immediate_p)
 256 {
 257   if (immediate_p)
 258     sigint_handler = handler;
 259   else
 260     {
 261       mark_async_signal_handler (handler);
 262       sigint_handler = NULL;
 263     }
 264   SetEvent (sigint_event);
 265 }
 266
 267 /* -Wmissing-prototypes */
 268 extern initialize_file_ftype _initialize_mingw_hdep;
 269
 270 void
 271 _initialize_mingw_hdep (void)
 272 {
 273   sigint_event = CreateEvent (0, FALSE, FALSE, 0);
 274 }