GDB (xrefs)
/tmp/gdb-7.10/gdb/ser-mingw.c
Go to the documentation of this file.
1 /* Serial interface for local (hardwired) serial ports on Windows systems
2 
3  Copyright (C) 2006-2015 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 "serial.h"
22 #include "ser-base.h"
23 #include "ser-tcp.h"
24 
25 #include <windows.h>
26 #include <conio.h>
27 
28 #include <fcntl.h>
29 #include <unistd.h>
30 #include <sys/types.h>
31 
32 #include "command.h"
33 
34 void _initialize_ser_windows (void);
35 
37 {
39  OVERLAPPED ov;
40  DWORD lastCommMask;
41  HANDLE except_event;
42 };
43 
44 /* CancelIo is not available for Windows 95 OS, so we need to use
45  LoadLibrary/GetProcAddress to avoid a startup failure. */
46 #define CancelIo dyn_CancelIo
47 static BOOL WINAPI (*CancelIo) (HANDLE);
48 
49 /* Open up a real live device for serial I/O. */
50 
51 static int
52 ser_windows_open (struct serial *scb, const char *name)
53 {
54  HANDLE h;
55  struct ser_windows_state *state;
56  COMMTIMEOUTS timeouts;
57 
58  h = CreateFile (name, GENERIC_READ | GENERIC_WRITE, 0, NULL,
59  OPEN_EXISTING, FILE_FLAG_OVERLAPPED, NULL);
60  if (h == INVALID_HANDLE_VALUE)
61  {
62  errno = ENOENT;
63  return -1;
64  }
65 
66  scb->fd = _open_osfhandle ((intptr_t) h, O_RDWR);
67  if (scb->fd < 0)
68  {
69  errno = ENOENT;
70  return -1;
71  }
72 
73  if (!SetCommMask (h, EV_RXCHAR))
74  {
75  errno = EINVAL;
76  return -1;
77  }
78 
79  timeouts.ReadIntervalTimeout = MAXDWORD;
80  timeouts.ReadTotalTimeoutConstant = 0;
81  timeouts.ReadTotalTimeoutMultiplier = 0;
82  timeouts.WriteTotalTimeoutConstant = 0;
83  timeouts.WriteTotalTimeoutMultiplier = 0;
84  if (!SetCommTimeouts (h, &timeouts))
85  {
86  errno = EINVAL;
87  return -1;
88  }
89 
90  state = xmalloc (sizeof (struct ser_windows_state));
91  memset (state, 0, sizeof (struct ser_windows_state));
92  scb->state = state;
93 
94  /* Create a manual reset event to watch the input buffer. */
95  state->ov.hEvent = CreateEvent (0, TRUE, FALSE, 0);
96 
97  /* Create a (currently unused) handle to record exceptions. */
98  state->except_event = CreateEvent (0, TRUE, FALSE, 0);
99 
100  return 0;
101 }
102 
103 /* Wait for the output to drain away, as opposed to flushing (discarding)
104  it. */
105 
106 static int
108 {
109  HANDLE h = (HANDLE) _get_osfhandle (scb->fd);
110 
111  return (FlushFileBuffers (h) != 0) ? 0 : -1;
112 }
113 
114 static int
116 {
117  HANDLE h = (HANDLE) _get_osfhandle (scb->fd);
118 
119  return (PurgeComm (h, PURGE_TXCLEAR) != 0) ? 0 : -1;
120 }
121 
122 static int
124 {
125  HANDLE h = (HANDLE) _get_osfhandle (scb->fd);
126 
127  return (PurgeComm (h, PURGE_RXCLEAR) != 0) ? 0 : -1;
128 }
129 
130 static int
132 {
133  HANDLE h = (HANDLE) _get_osfhandle (scb->fd);
134 
135  if (SetCommBreak (h) == 0)
136  return -1;
137 
138  /* Delay for 250 milliseconds. */
139  Sleep (250);
140 
141  if (ClearCommBreak (h))
142  return -1;
143 
144  return 0;
145 }
146 
147 static void
148 ser_windows_raw (struct serial *scb)
149 {
150  HANDLE h = (HANDLE) _get_osfhandle (scb->fd);
151  DCB state;
152 
153  if (GetCommState (h, &state) == 0)
154  return;
155 
156  state.fOutxCtsFlow = FALSE;
157  state.fOutxDsrFlow = FALSE;
158  state.fDtrControl = DTR_CONTROL_ENABLE;
159  state.fDsrSensitivity = FALSE;
160  state.fOutX = FALSE;
161  state.fInX = FALSE;
162  state.fNull = FALSE;
163  state.fAbortOnError = FALSE;
164  state.ByteSize = 8;
165 
166  scb->current_timeout = 0;
167 
168  if (SetCommState (h, &state) == 0)
169  warning (_("SetCommState failed"));
170 }
171 
172 static int
173 ser_windows_setstopbits (struct serial *scb, int num)
174 {
175  HANDLE h = (HANDLE) _get_osfhandle (scb->fd);
176  DCB state;
177 
178  if (GetCommState (h, &state) == 0)
179  return -1;
180 
181  switch (num)
182  {
183  case SERIAL_1_STOPBITS:
184  state.StopBits = ONESTOPBIT;
185  break;
187  state.StopBits = ONE5STOPBITS;
188  break;
189  case SERIAL_2_STOPBITS:
190  state.StopBits = TWOSTOPBITS;
191  break;
192  default:
193  return 1;
194  }
195 
196  return (SetCommState (h, &state) != 0) ? 0 : -1;
197 }
198 
199 /* Implement the "setparity" serial_ops callback. */
200 
201 static int
203 {
204  HANDLE h = (HANDLE) _get_osfhandle (scb->fd);
205  DCB state;
206 
207  if (GetCommState (h, &state) == 0)
208  return -1;
209 
210  switch (parity)
211  {
212  case GDBPARITY_NONE:
213  state.Parity = NOPARITY;
214  state.fParity = FALSE;
215  break;
216  case GDBPARITY_ODD:
217  state.Parity = ODDPARITY;
218  state.fParity = TRUE;
219  break;
220  case GDBPARITY_EVEN:
221  state.Parity = EVENPARITY;
222  state.fParity = TRUE;
223  break;
224  default:
225  internal_warning (__FILE__, __LINE__,
226  "Incorrect parity value: %d", parity);
227  return -1;
228  }
229 
230  return (SetCommState (h, &state) != 0) ? 0 : -1;
231 }
232 
233 static int
235 {
236  HANDLE h = (HANDLE) _get_osfhandle (scb->fd);
237  DCB state;
238 
239  if (GetCommState (h, &state) == 0)
240  return -1;
241 
242  state.BaudRate = rate;
243 
244  return (SetCommState (h, &state) != 0) ? 0 : -1;
245 }
246 
247 static void
249 {
250  struct ser_windows_state *state;
251 
252  /* Stop any pending selects. On Windows 95 OS, CancelIo function does
253  not exist. In that case, it can be replaced by a call to CloseHandle,
254  but this is not necessary here as we do close the Windows handle
255  by calling close (scb->fd) below. */
256  if (CancelIo)
257  CancelIo ((HANDLE) _get_osfhandle (scb->fd));
258  state = scb->state;
259  CloseHandle (state->ov.hEvent);
260  CloseHandle (state->except_event);
261 
262  if (scb->fd < 0)
263  return;
264 
265  close (scb->fd);
266  scb->fd = -1;
267 
268  xfree (scb->state);
269 }
270 
271 static void
272 ser_windows_wait_handle (struct serial *scb, HANDLE *read, HANDLE *except)
273 {
274  struct ser_windows_state *state;
275  COMSTAT status;
276  DWORD errors;
277  HANDLE h = (HANDLE) _get_osfhandle (scb->fd);
278 
279  state = scb->state;
280 
281  *except = state->except_event;
282  *read = state->ov.hEvent;
283 
284  if (state->in_progress)
285  return;
286 
287  /* Reset the mask - we are only interested in any characters which
288  arrive after this point, not characters which might have arrived
289  and already been read. */
290 
291  /* This really, really shouldn't be necessary - just the second one.
292  But otherwise an internal flag for EV_RXCHAR does not get
293  cleared, and we get a duplicated event, if the last batch
294  of characters included at least two arriving close together. */
295  if (!SetCommMask (h, 0))
296  warning (_("ser_windows_wait_handle: reseting mask failed"));
297 
298  if (!SetCommMask (h, EV_RXCHAR))
299  warning (_("ser_windows_wait_handle: reseting mask failed (2)"));
300 
301  /* There's a potential race condition here; we must check cbInQue
302  and not wait if that's nonzero. */
303 
304  ClearCommError (h, &errors, &status);
305  if (status.cbInQue > 0)
306  {
307  SetEvent (state->ov.hEvent);
308  return;
309  }
310 
311  state->in_progress = 1;
312  ResetEvent (state->ov.hEvent);
313  state->lastCommMask = -2;
314  if (WaitCommEvent (h, &state->lastCommMask, &state->ov))
315  {
316  gdb_assert (state->lastCommMask & EV_RXCHAR);
317  SetEvent (state->ov.hEvent);
318  }
319  else
320  gdb_assert (GetLastError () == ERROR_IO_PENDING);
321 }
322 
323 static int
324 ser_windows_read_prim (struct serial *scb, size_t count)
325 {
326  struct ser_windows_state *state;
327  OVERLAPPED ov;
328  DWORD bytes_read, bytes_read_tmp;
329  HANDLE h;
330  gdb_byte *p;
331 
332  state = scb->state;
333  if (state->in_progress)
334  {
335  WaitForSingleObject (state->ov.hEvent, INFINITE);
336  state->in_progress = 0;
337  ResetEvent (state->ov.hEvent);
338  }
339 
340  memset (&ov, 0, sizeof (OVERLAPPED));
341  ov.hEvent = CreateEvent (0, FALSE, FALSE, 0);
342  h = (HANDLE) _get_osfhandle (scb->fd);
343 
344  if (!ReadFile (h, scb->buf, /* count */ 1, &bytes_read, &ov))
345  {
346  if (GetLastError () != ERROR_IO_PENDING
347  || !GetOverlappedResult (h, &ov, &bytes_read, TRUE))
348  bytes_read = -1;
349  }
350 
351  CloseHandle (ov.hEvent);
352  return bytes_read;
353 }
354 
355 static int
356 ser_windows_write_prim (struct serial *scb, const void *buf, size_t len)
357 {
358  struct ser_windows_state *state;
359  OVERLAPPED ov;
360  DWORD bytes_written;
361  HANDLE h;
362 
363  memset (&ov, 0, sizeof (OVERLAPPED));
364  ov.hEvent = CreateEvent (0, FALSE, FALSE, 0);
365  h = (HANDLE) _get_osfhandle (scb->fd);
366  if (!WriteFile (h, buf, len, &bytes_written, &ov))
367  {
368  if (GetLastError () != ERROR_IO_PENDING
369  || !GetOverlappedResult (h, &ov, &bytes_written, TRUE))
370  bytes_written = -1;
371  }
372 
373  CloseHandle (ov.hEvent);
374  return bytes_written;
375 }
376 
377 /* On Windows, gdb_select is implemented using WaitForMulpleObjects.
378  A "select thread" is created for each file descriptor. These
379  threads looks for activity on the corresponding descriptor, using
380  whatever techniques are appropriate for the descriptor type. When
381  that activity occurs, the thread signals an appropriate event,
382  which wakes up WaitForMultipleObjects.
383 
384  Each select thread is in one of two states: stopped or started.
385  Select threads begin in the stopped state. When gdb_select is
386  called, threads corresponding to the descriptors of interest are
387  started by calling a wait_handle function. Each thread that
388  notices activity signals the appropriate event and then reenters
389  the stopped state. Before gdb_select returns it calls the
390  wait_handle_done functions, which return the threads to the stopped
391  state. */
392 
396 };
397 
399 {
400  /* Signaled by the select thread to indicate that data is available
401  on the file descriptor. */
402  HANDLE read_event;
403  /* Signaled by the select thread to indicate that an exception has
404  occurred on the file descriptor. */
405  HANDLE except_event;
406  /* Signaled by the select thread to indicate that it has entered the
407  started state. HAVE_STARTED and HAVE_STOPPED are never signaled
408  simultaneously. */
409  HANDLE have_started;
410  /* Signaled by the select thread to indicate that it has stopped,
411  either because data is available (and READ_EVENT is signaled),
412  because an exception has occurred (and EXCEPT_EVENT is signaled),
413  or because STOP_SELECT was signaled. */
414  HANDLE have_stopped;
415 
416  /* Signaled by the main program to tell the select thread to enter
417  the started state. */
418  HANDLE start_select;
419  /* Signaled by the main program to tell the select thread to enter
420  the stopped state. */
421  HANDLE stop_select;
422  /* Signaled by the main program to tell the select thread to
423  exit. */
424  HANDLE exit_select;
425 
426  /* The handle for the select thread. */
427  HANDLE thread;
428  /* The state of the select thread. This field is only accessed in
429  the main program, never by the select thread itself. */
431 };
432 
433 /* Called by a select thread to enter the stopped state. This
434  function does not return until the thread has re-entered the
435  started state. */
436 static void
438 {
439  HANDLE wait_events[2];
440 
441  /* There are two things that can wake us up: a request that we enter
442  the started state, or that we exit this thread. */
443  wait_events[0] = state->start_select;
444  wait_events[1] = state->exit_select;
445  if (WaitForMultipleObjects (2, wait_events, FALSE, INFINITE)
446  != WAIT_OBJECT_0)
447  /* Either the EXIT_SELECT event was signaled (requesting that the
448  thread exit) or an error has occurred. In either case, we exit
449  the thread. */
450  ExitThread (0);
451 
452  /* We are now in the started state. */
453  SetEvent (state->have_started);
454 }
455 
456 typedef DWORD WINAPI (*thread_fn_type)(void *);
457 
458 /* Create a new select thread for SCB executing THREAD_FN. The STATE
459  will be filled in by this function before return. */
460 static void
462  struct serial *scb,
463  struct ser_console_state *state)
464 {
465  DWORD threadId;
466 
467  /* Create all of the events. These are all auto-reset events. */
468  state->read_event = CreateEvent (NULL, FALSE, FALSE, NULL);
469  state->except_event = CreateEvent (NULL, FALSE, FALSE, NULL);
470  state->have_started = CreateEvent (NULL, FALSE, FALSE, NULL);
471  state->have_stopped = CreateEvent (NULL, FALSE, FALSE, NULL);
472  state->start_select = CreateEvent (NULL, FALSE, FALSE, NULL);
473  state->stop_select = CreateEvent (NULL, FALSE, FALSE, NULL);
474  state->exit_select = CreateEvent (NULL, FALSE, FALSE, NULL);
475 
476  state->thread = CreateThread (NULL, 0, thread_fn, scb, 0, &threadId);
477  /* The thread begins in the stopped state. */
478  state->thread_state = STS_STOPPED;
479 }
480 
481 /* Destroy the select thread indicated by STATE. */
482 static void
484 {
485  /* Ask the thread to exit. */
486  SetEvent (state->exit_select);
487  /* Wait until it does. */
488  WaitForSingleObject (state->thread, INFINITE);
489 
490  /* Destroy the events. */
491  CloseHandle (state->read_event);
492  CloseHandle (state->except_event);
493  CloseHandle (state->have_started);
494  CloseHandle (state->have_stopped);
495  CloseHandle (state->start_select);
496  CloseHandle (state->stop_select);
497  CloseHandle (state->exit_select);
498 }
499 
500 /* Called by gdb_select to start the select thread indicated by STATE.
501  This function does not return until the thread has started. */
502 static void
504 {
505  /* Ask the thread to start. */
506  SetEvent (state->start_select);
507  /* Wait until it does. */
508  WaitForSingleObject (state->have_started, INFINITE);
509  /* The thread is now started. */
510  state->thread_state = STS_STARTED;
511 }
512 
513 /* Called by gdb_select to stop the select thread indicated by STATE.
514  This function does not return until the thread has stopped. */
515 static void
517 {
518  /* If the thread is already in the stopped state, we have nothing to
519  do. Some of the wait_handle functions avoid calling
520  start_select_thread if they notice activity on the relevant file
521  descriptors. The wait_handle_done functions still call
522  stop_select_thread -- but it is already stopped. */
523  if (state->thread_state != STS_STARTED)
524  return;
525  /* Ask the thread to stop. */
526  SetEvent (state->stop_select);
527  /* Wait until it does. */
528  WaitForSingleObject (state->have_stopped, INFINITE);
529  /* The thread is now stopped. */
530  state->thread_state = STS_STOPPED;
531 }
532 
533 static DWORD WINAPI
535 {
536  struct serial *scb = arg;
537  struct ser_console_state *state;
538  int event_index;
539  HANDLE h;
540 
541  state = scb->state;
542  h = (HANDLE) _get_osfhandle (scb->fd);
543 
544  while (1)
545  {
546  HANDLE wait_events[2];
547  INPUT_RECORD record;
548  DWORD n_records;
549 
550  select_thread_wait (state);
551 
552  while (1)
553  {
554  wait_events[0] = state->stop_select;
555  wait_events[1] = h;
556 
557  event_index = WaitForMultipleObjects (2, wait_events,
558  FALSE, INFINITE);
559 
560  if (event_index == WAIT_OBJECT_0
561  || WaitForSingleObject (state->stop_select, 0) == WAIT_OBJECT_0)
562  break;
563 
564  if (event_index != WAIT_OBJECT_0 + 1)
565  {
566  /* Wait must have failed; assume an error has occured, e.g.
567  the handle has been closed. */
568  SetEvent (state->except_event);
569  break;
570  }
571 
572  /* We've got a pending event on the console. See if it's
573  of interest. */
574  if (!PeekConsoleInput (h, &record, 1, &n_records) || n_records != 1)
575  {
576  /* Something went wrong. Maybe the console is gone. */
577  SetEvent (state->except_event);
578  break;
579  }
580 
581  if (record.EventType == KEY_EVENT && record.Event.KeyEvent.bKeyDown)
582  {
583  WORD keycode = record.Event.KeyEvent.wVirtualKeyCode;
584 
585  /* Ignore events containing only control keys. We must
586  recognize "enhanced" keys which we are interested in
587  reading via getch, if they do not map to ASCII. But we
588  do not want to report input available for e.g. the
589  control key alone. */
590 
591  if (record.Event.KeyEvent.uChar.AsciiChar != 0
592  || keycode == VK_PRIOR
593  || keycode == VK_NEXT
594  || keycode == VK_END
595  || keycode == VK_HOME
596  || keycode == VK_LEFT
597  || keycode == VK_UP
598  || keycode == VK_RIGHT
599  || keycode == VK_DOWN
600  || keycode == VK_INSERT
601  || keycode == VK_DELETE)
602  {
603  /* This is really a keypress. */
604  SetEvent (state->read_event);
605  break;
606  }
607  }
608 
609  /* Otherwise discard it and wait again. */
610  ReadConsoleInput (h, &record, 1, &n_records);
611  }
612 
613  SetEvent(state->have_stopped);
614  }
615  return 0;
616 }
617 
618 static int
619 fd_is_pipe (int fd)
620 {
621  if (PeekNamedPipe ((HANDLE) _get_osfhandle (fd), NULL, 0, NULL, NULL, NULL))
622  return 1;
623  else
624  return 0;
625 }
626 
627 static int
628 fd_is_file (int fd)
629 {
630  if (GetFileType ((HANDLE) _get_osfhandle (fd)) == FILE_TYPE_DISK)
631  return 1;
632  else
633  return 0;
634 }
635 
636 static DWORD WINAPI
638 {
639  struct serial *scb = arg;
640  struct ser_console_state *state;
641  int event_index;
642  HANDLE h;
643 
644  state = scb->state;
645  h = (HANDLE) _get_osfhandle (scb->fd);
646 
647  while (1)
648  {
649  DWORD n_avail;
650 
651  select_thread_wait (state);
652 
653  /* Wait for something to happen on the pipe. */
654  while (1)
655  {
656  if (!PeekNamedPipe (h, NULL, 0, NULL, &n_avail, NULL))
657  {
658  SetEvent (state->except_event);
659  break;
660  }
661 
662  if (n_avail > 0)
663  {
664  SetEvent (state->read_event);
665  break;
666  }
667 
668  /* Delay 10ms before checking again, but allow the stop
669  event to wake us. */
670  if (WaitForSingleObject (state->stop_select, 10) == WAIT_OBJECT_0)
671  break;
672  }
673 
674  SetEvent (state->have_stopped);
675  }
676  return 0;
677 }
678 
679 static DWORD WINAPI
681 {
682  struct serial *scb = arg;
683  struct ser_console_state *state;
684  int event_index;
685  HANDLE h;
686 
687  state = scb->state;
688  h = (HANDLE) _get_osfhandle (scb->fd);
689 
690  while (1)
691  {
692  select_thread_wait (state);
693 
694  if (SetFilePointer (h, 0, NULL, FILE_CURRENT)
695  == INVALID_SET_FILE_POINTER)
696  SetEvent (state->except_event);
697  else
698  SetEvent (state->read_event);
699 
700  SetEvent (state->have_stopped);
701  }
702  return 0;
703 }
704 
705 static void
706 ser_console_wait_handle (struct serial *scb, HANDLE *read, HANDLE *except)
707 {
708  struct ser_console_state *state = scb->state;
709 
710  if (state == NULL)
711  {
712  thread_fn_type thread_fn;
713  int is_tty;
714 
715  is_tty = isatty (scb->fd);
716  if (!is_tty && !fd_is_file (scb->fd) && !fd_is_pipe (scb->fd))
717  {
718  *read = NULL;
719  *except = NULL;
720  return;
721  }
722 
723  state = xmalloc (sizeof (struct ser_console_state));
724  memset (state, 0, sizeof (struct ser_console_state));
725  scb->state = state;
726 
727  if (is_tty)
728  thread_fn = console_select_thread;
729  else if (fd_is_pipe (scb->fd))
730  thread_fn = pipe_select_thread;
731  else
732  thread_fn = file_select_thread;
733 
734  create_select_thread (thread_fn, scb, state);
735  }
736 
737  *read = state->read_event;
738  *except = state->except_event;
739 
740  /* Start from a blank state. */
741  ResetEvent (state->read_event);
742  ResetEvent (state->except_event);
743  ResetEvent (state->stop_select);
744 
745  /* First check for a key already in the buffer. If there is one,
746  we don't need a thread. This also catches the second key of
747  multi-character returns from getch, for instance for arrow
748  keys. The second half is in a C library internal buffer,
749  and PeekConsoleInput will not find it. */
750  if (_kbhit ())
751  {
752  SetEvent (state->read_event);
753  return;
754  }
755 
756  /* Otherwise, start the select thread. */
757  start_select_thread (state);
758 }
759 
760 static void
762 {
763  struct ser_console_state *state = scb->state;
764 
765  if (state == NULL)
766  return;
767 
768  stop_select_thread (state);
769 }
770 
771 static void
773 {
774  struct ser_console_state *state = scb->state;
775 
776  if (scb->state)
777  {
778  destroy_select_thread (state);
779  xfree (scb->state);
780  }
781 }
782 
784 {
785  int is_a_tty;
786 };
787 
788 static serial_ttystate
790 {
791  if (isatty (scb->fd))
792  {
793  struct ser_console_ttystate *state;
794 
795  state = (struct ser_console_ttystate *) xmalloc (sizeof *state);
796  state->is_a_tty = 1;
797  return state;
798  }
799  else
800  return NULL;
801 }
802 
804 {
805  /* Since we use the pipe_select_thread for our select emulation,
806  we need to place the state structure it requires at the front
807  of our state. */
809 
810  /* The pex obj for our (one-stage) pipeline. */
811  struct pex_obj *pex;
812 
813  /* Streams for the pipeline's input and output. */
814  FILE *input, *output;
815 };
816 
817 static struct pipe_state *
819 {
820  struct pipe_state *ps = XNEW (struct pipe_state);
821 
822  memset (ps, 0, sizeof (*ps));
823  ps->wait.read_event = INVALID_HANDLE_VALUE;
824  ps->wait.except_event = INVALID_HANDLE_VALUE;
825  ps->wait.start_select = INVALID_HANDLE_VALUE;
826  ps->wait.stop_select = INVALID_HANDLE_VALUE;
827 
828  return ps;
829 }
830 
831 static void
833 {
834  int saved_errno = errno;
835 
836  if (ps->wait.read_event != INVALID_HANDLE_VALUE)
838 
839  /* Close the pipe to the child. We must close the pipe before
840  calling pex_free because pex_free will wait for the child to exit
841  and the child will not exit until the pipe is closed. */
842  if (ps->input)
843  fclose (ps->input);
844  if (ps->pex)
845  {
846  pex_free (ps->pex);
847  /* pex_free closes ps->output. */
848  }
849  else if (ps->output)
850  fclose (ps->output);
851 
852  xfree (ps);
853 
854  errno = saved_errno;
855 }
856 
857 static void
858 cleanup_pipe_state (void *untyped)
859 {
860  struct pipe_state *ps = untyped;
861 
862  free_pipe_state (ps);
863 }
864 
865 static int
866 pipe_windows_open (struct serial *scb, const char *name)
867 {
868  struct pipe_state *ps;
869  FILE *pex_stderr;
870  char **argv;
871  struct cleanup *back_to;
872 
873  if (name == NULL)
874  error_no_arg (_("child command"));
875 
876  argv = gdb_buildargv (name);
877  back_to = make_cleanup_freeargv (argv);
878 
879  if (! argv[0] || argv[0][0] == '\0')
880  error (_("missing child command"));
881 
882  ps = make_pipe_state ();
884 
885  ps->pex = pex_init (PEX_USE_PIPES, "target remote pipe", NULL);
886  if (! ps->pex)
887  goto fail;
888  ps->input = pex_input_pipe (ps->pex, 1);
889  if (! ps->input)
890  goto fail;
891 
892  {
893  int err;
894  const char *err_msg
895  = pex_run (ps->pex, PEX_SEARCH | PEX_BINARY_INPUT | PEX_BINARY_OUTPUT
896  | PEX_STDERR_TO_PIPE,
897  argv[0], argv, NULL, NULL,
898  &err);
899 
900  if (err_msg)
901  {
902  /* Our caller expects us to return -1, but all they'll do with
903  it generally is print the message based on errno. We have
904  all the same information here, plus err_msg provided by
905  pex_run, so we just raise the error here. */
906  if (err)
907  error (_("error starting child process '%s': %s: %s"),
908  name, err_msg, safe_strerror (err));
909  else
910  error (_("error starting child process '%s': %s"),
911  name, err_msg);
912  }
913  }
914 
915  ps->output = pex_read_output (ps->pex, 1);
916  if (! ps->output)
917  goto fail;
918  scb->fd = fileno (ps->output);
919 
920  pex_stderr = pex_read_err (ps->pex, 1);
921  if (! pex_stderr)
922  goto fail;
923  scb->error_fd = fileno (pex_stderr);
924 
925  scb->state = (void *) ps;
926 
927  discard_cleanups (back_to);
928  return 0;
929 
930  fail:
931  do_cleanups (back_to);
932  return -1;
933 }
934 
935 static int
936 pipe_windows_fdopen (struct serial *scb, int fd)
937 {
938  struct pipe_state *ps;
939 
940  ps = make_pipe_state ();
941 
942  ps->input = fdopen (fd, "r+");
943  if (! ps->input)
944  goto fail;
945 
946  ps->output = fdopen (fd, "r+");
947  if (! ps->output)
948  goto fail;
949 
950  scb->fd = fd;
951  scb->state = (void *) ps;
952 
953  return 0;
954 
955  fail:
956  free_pipe_state (ps);
957  return -1;
958 }
959 
960 static void
962 {
963  struct pipe_state *ps = scb->state;
964 
965  /* In theory, we should try to kill the subprocess here, but the pex
966  interface doesn't give us enough information to do that. Usually
967  closing the input pipe will get the message across. */
968 
969  free_pipe_state (ps);
970 }
971 
972 
973 static int
974 pipe_windows_read (struct serial *scb, size_t count)
975 {
976  HANDLE pipeline_out = (HANDLE) _get_osfhandle (scb->fd);
977  DWORD available;
978  DWORD bytes_read;
979 
980  if (pipeline_out == INVALID_HANDLE_VALUE)
981  return -1;
982 
983  if (! PeekNamedPipe (pipeline_out, NULL, 0, NULL, &available, NULL))
984  return -1;
985 
986  if (count > available)
987  count = available;
988 
989  if (! ReadFile (pipeline_out, scb->buf, count, &bytes_read, NULL))
990  return -1;
991 
992  return bytes_read;
993 }
994 
995 
996 static int
997 pipe_windows_write (struct serial *scb, const void *buf, size_t count)
998 {
999  struct pipe_state *ps = scb->state;
1000  HANDLE pipeline_in;
1001  DWORD written;
1002 
1003  int pipeline_in_fd = fileno (ps->input);
1004  if (pipeline_in_fd < 0)
1005  return -1;
1006 
1007  pipeline_in = (HANDLE) _get_osfhandle (pipeline_in_fd);
1008  if (pipeline_in == INVALID_HANDLE_VALUE)
1009  return -1;
1010 
1011  if (! WriteFile (pipeline_in, buf, count, &written, NULL))
1012  return -1;
1013 
1014  return written;
1015 }
1016 
1017 
1018 static void
1019 pipe_wait_handle (struct serial *scb, HANDLE *read, HANDLE *except)
1020 {
1021  struct pipe_state *ps = scb->state;
1022 
1023  /* Have we allocated our events yet? */
1024  if (ps->wait.read_event == INVALID_HANDLE_VALUE)
1025  /* Start the thread. */
1027 
1028  *read = ps->wait.read_event;
1029  *except = ps->wait.except_event;
1030 
1031  /* Start from a blank state. */
1032  ResetEvent (ps->wait.read_event);
1033  ResetEvent (ps->wait.except_event);
1034  ResetEvent (ps->wait.stop_select);
1035 
1036  start_select_thread (&ps->wait);
1037 }
1038 
1039 static void
1041 {
1042  struct pipe_state *ps = scb->state;
1043 
1044  /* Have we allocated our events yet? */
1045  if (ps->wait.read_event == INVALID_HANDLE_VALUE)
1046  return;
1047 
1048  stop_select_thread (&ps->wait);
1049 }
1050 
1051 static int
1052 pipe_avail (struct serial *scb, int fd)
1053 {
1054  HANDLE h = (HANDLE) _get_osfhandle (fd);
1055  DWORD numBytes;
1056  BOOL r = PeekNamedPipe (h, NULL, 0, NULL, &numBytes, NULL);
1057 
1058  if (r == FALSE)
1059  numBytes = 0;
1060  return numBytes;
1061 }
1062 
1063 int
1064 gdb_pipe (int pdes[2])
1065 {
1066  if (_pipe (pdes, 512, _O_BINARY | _O_NOINHERIT) == -1)
1067  return -1;
1068  return 0;
1069 }
1070 
1072 {
1074 
1075  HANDLE sock_event;
1076 };
1077 
1078 /* Check whether the socket has any pending data to be read. If so,
1079  set the select thread's read event. On error, set the select
1080  thread's except event. If any event was set, return true,
1081  otherwise return false. */
1082 
1083 static int
1085 {
1086  struct net_windows_state *state = scb->state;
1087  unsigned long available;
1088 
1089  if (ioctlsocket (scb->fd, FIONREAD, &available) != 0)
1090  {
1091  /* The socket closed, or some other error. */
1092  SetEvent (state->base.except_event);
1093  return 1;
1094  }
1095  else if (available > 0)
1096  {
1097  SetEvent (state->base.read_event);
1098  return 1;
1099  }
1100 
1101  return 0;
1102 }
1103 
1104 static DWORD WINAPI
1106 {
1107  struct serial *scb = arg;
1108  struct net_windows_state *state;
1109  int event_index;
1110 
1111  state = scb->state;
1112 
1113  while (1)
1114  {
1115  HANDLE wait_events[2];
1116  WSANETWORKEVENTS events;
1117 
1118  select_thread_wait (&state->base);
1119 
1120  wait_events[0] = state->base.stop_select;
1121  wait_events[1] = state->sock_event;
1122 
1123  /* Wait for something to happen on the socket. */
1124  while (1)
1125  {
1126  event_index = WaitForMultipleObjects (2, wait_events, FALSE, INFINITE);
1127 
1128  if (event_index == WAIT_OBJECT_0
1129  || WaitForSingleObject (state->base.stop_select, 0) == WAIT_OBJECT_0)
1130  {
1131  /* We have been requested to stop. */
1132  break;
1133  }
1134 
1135  if (event_index != WAIT_OBJECT_0 + 1)
1136  {
1137  /* Some error has occured. Assume that this is an error
1138  condition. */
1139  SetEvent (state->base.except_event);
1140  break;
1141  }
1142 
1143  /* Enumerate the internal network events, and reset the
1144  object that signalled us to catch the next event. */
1145  if (WSAEnumNetworkEvents (scb->fd, state->sock_event, &events) != 0)
1146  {
1147  /* Something went wrong. Maybe the socket is gone. */
1148  SetEvent (state->base.except_event);
1149  break;
1150  }
1151 
1152  if (events.lNetworkEvents & FD_READ)
1153  {
1155  break;
1156 
1157  /* Spurious wakeup. That is, the socket's event was
1158  signalled before we last called recv. */
1159  }
1160 
1161  if (events.lNetworkEvents & FD_CLOSE)
1162  {
1163  SetEvent (state->base.except_event);
1164  break;
1165  }
1166  }
1167 
1168  SetEvent (state->base.have_stopped);
1169  }
1170  return 0;
1171 }
1172 
1173 static void
1174 net_windows_wait_handle (struct serial *scb, HANDLE *read, HANDLE *except)
1175 {
1176  struct net_windows_state *state = scb->state;
1177 
1178  /* Start from a clean slate. */
1179  ResetEvent (state->base.read_event);
1180  ResetEvent (state->base.except_event);
1181  ResetEvent (state->base.stop_select);
1182 
1183  *read = state->base.read_event;
1184  *except = state->base.except_event;
1185 
1186  /* Check any pending events. Otherwise, start the select
1187  thread. */
1189  start_select_thread (&state->base);
1190 }
1191 
1192 static void
1194 {
1195  struct net_windows_state *state = scb->state;
1196 
1197  stop_select_thread (&state->base);
1198 }
1199 
1200 static int
1201 net_windows_open (struct serial *scb, const char *name)
1202 {
1203  struct net_windows_state *state;
1204  int ret;
1205  DWORD threadId;
1206 
1207  ret = net_open (scb, name);
1208  if (ret != 0)
1209  return ret;
1210 
1211  state = xmalloc (sizeof (struct net_windows_state));
1212  memset (state, 0, sizeof (struct net_windows_state));
1213  scb->state = state;
1214 
1215  /* Associate an event with the socket. */
1216  state->sock_event = CreateEvent (0, TRUE, FALSE, 0);
1217  WSAEventSelect (scb->fd, state->sock_event, FD_READ | FD_CLOSE);
1218 
1219  /* Start the thread. */
1221 
1222  return 0;
1223 }
1224 
1225 
1226 static void
1228 {
1229  struct net_windows_state *state = scb->state;
1230 
1231  destroy_select_thread (&state->base);
1232  CloseHandle (state->sock_event);
1233 
1234  xfree (scb->state);
1235 
1236  net_close (scb);
1237 }
1238 
1239 /* The serial port driver. */
1240 
1241 static const struct serial_ops hardwire_ops =
1242 {
1243  "hardwire",
1246  NULL,
1253  /* These are only used for stdin; we do not need them for serial
1254  ports, so supply the standard dummies. */
1267  NULL,
1269 };
1270 
1271 /* The dummy serial driver used for terminals. We only provide the
1272  TTY-related methods. */
1273 
1274 static const struct serial_ops tty_ops =
1275 {
1276  "terminal",
1277  NULL,
1279  NULL,
1280  NULL,
1281  NULL,
1282  NULL,
1283  NULL,
1284  NULL,
1285  NULL,
1291  NULL,
1292  NULL,
1293  NULL,
1295  NULL,
1296  NULL,
1297  NULL,
1298  NULL,
1301 };
1302 
1303 /* The pipe interface. */
1304 
1305 static const struct serial_ops pipe_ops =
1306 {
1307  "pipe",
1316  ser_base_raw,
1329  pipe_avail,
1332 };
1333 
1334 /* The TCP/UDP socket driver. */
1335 
1336 static const struct serial_ops tcp_ops =
1337 {
1338  "tcp",
1341  NULL,
1347  ser_base_raw,
1358  net_read_prim,
1360  NULL,
1363 };
1364 
1365 void
1367 {
1368  WSADATA wsa_data;
1369  struct serial_ops *ops;
1370 
1371  HMODULE hm = NULL;
1372 
1373  /* First find out if kernel32 exports CancelIo function. */
1374  hm = LoadLibrary ("kernel32.dll");
1375  if (hm)
1376  {
1377  CancelIo = (void *) GetProcAddress (hm, "CancelIo");
1378  FreeLibrary (hm);
1379  }
1380  else
1381  CancelIo = NULL;
1382 
1383  serial_add_interface (&hardwire_ops);
1384  serial_add_interface (&tty_ops);
1385  serial_add_interface (&pipe_ops);
1386 
1387  /* If WinSock works, register the TCP/UDP socket driver. */
1388 
1389  if (WSAStartup (MAKEWORD (1, 0), &wsa_data) != 0)
1390  /* WinSock is unavailable. */
1391  return;
1392 
1393  serial_add_interface (&tcp_ops);
1394 }
void error_no_arg(const char *why)
Definition: cli-cmds.c:205
struct cleanup * make_cleanup_freeargv(char **arg)
Definition: utils.c:165
ssize_t read(int fd, void *buf, size_t count)
Definition: expect-read1.c:26
static int net_windows_open(struct serial *scb, const char *name)
Definition: ser-mingw.c:1201
static int ser_windows_drain_output(struct serial *scb)
Definition: ser-mingw.c:107
static void select_thread_wait(struct ser_console_state *state)
Definition: ser-mingw.c:437
static DWORD WINAPI net_windows_select_thread(void *arg)
Definition: ser-mingw.c:1105
static int ser_windows_write_prim(struct serial *scb, const void *buf, size_t len)
Definition: ser-mingw.c:356
FILE * input
Definition: ser-mingw.c:814
FILE * output
Definition: ser-mingw.c:814
static void ser_windows_close(struct serial *scb)
Definition: ser-mingw.c:248
int current_timeout
Definition: serial.h:246
int ser_base_set_tty_state(struct serial *scb, serial_ttystate ttystate)
Definition: ser-base.c:510
#define GDBPARITY_EVEN
Definition: serial.h:191
static serial_ttystate ser_console_get_tty_state(struct serial *scb)
Definition: ser-mingw.c:789
static int fd_is_pipe(int fd)
Definition: ser-mingw.c:619
HANDLE exit_select
Definition: ser-mingw.c:424
def record
Definition: arm-linux.py:35
void xfree(void *)
Definition: common-utils.c:97
int ser_base_flush_output(struct serial *scb)
Definition: ser-base.c:459
static void ser_console_done_wait_handle(struct serial *scb)
Definition: ser-mingw.c:761
void warning(const char *fmt,...)
Definition: errors.c:26
static int ser_windows_setparity(struct serial *scb, int parity)
Definition: ser-mingw.c:202
static void pipe_done_wait_handle(struct serial *scb)
Definition: ser-mingw.c:1040
unsigned available
Definition: go32-nat.c:1070
static void net_windows_done_wait_handle(struct serial *scb)
Definition: ser-mingw.c:1193
static void net_windows_wait_handle(struct serial *scb, HANDLE *read, HANDLE *except)
Definition: ser-mingw.c:1174
static int pipe_avail(struct serial *scb, int fd)
Definition: ser-mingw.c:1052
HANDLE start_select
Definition: ser-mingw.c:418
HANDLE except_event
Definition: ser-mingw.c:405
int net_write_prim(struct serial *scb, const void *buf, size_t count)
Definition: ser-tcp.c:348
static void pipe_wait_handle(struct serial *scb, HANDLE *read, HANDLE *except)
Definition: ser-mingw.c:1019
static int fd_is_file(int fd)
Definition: ser-mingw.c:628
int error_fd
Definition: serial.h:238
static DWORD WINAPI file_select_thread(void *arg)
Definition: ser-mingw.c:680
int ser_base_setbaudrate(struct serial *scb, int rate)
Definition: ser-base.c:533
static void stop_select_thread(struct ser_console_state *state)
Definition: ser-mingw.c:516
#define _(String)
Definition: gdb_locale.h:40
static int ser_windows_send_break(struct serial *scb)
Definition: ser-mingw.c:131
int ser_base_setstopbits(struct serial *scb, int num)
Definition: ser-base.c:539
HANDLE stop_select
Definition: ser-mingw.c:421
void _initialize_ser_windows(void)
Definition: ser-mingw.c:1366
static DWORD WINAPI console_select_thread(void *arg)
Definition: ser-mingw.c:534
static void ser_console_wait_handle(struct serial *scb, HANDLE *read, HANDLE *except)
Definition: ser-mingw.c:706
void ser_base_raw(struct serial *scb)
Definition: ser-base.c:490
void ser_base_async(struct serial *scb, int async_p)
Definition: ser-base.c:555
const char *const name
Definition: aarch64-tdep.c:68
int net_read_prim(struct serial *scb, size_t count)
Definition: ser-tcp.c:339
static int net_windows_socket_check_pending(struct serial *scb)
Definition: ser-mingw.c:1084
HANDLE have_stopped
Definition: ser-mingw.c:414
#define GDBPARITY_NONE
Definition: serial.h:189
DWORD WINAPI(* thread_fn_type)(void *)
Definition: ser-mingw.c:456
struct pex_obj * pex
Definition: ser-mingw.c:811
mach_port_t mach_port_t name mach_port_t mach_port_t name error_t err
Definition: gnu-nat.c:1816
struct ser_console_state base
Definition: ser-mingw.c:1073
OVERLAPPED ov
Definition: ser-mingw.c:39
mach_port_t mach_port_t name mach_port_t mach_port_t name error_t int status
Definition: gnu-nat.c:1816
static void ser_console_close(struct serial *scb)
Definition: ser-mingw.c:772
int ser_base_noflush_set_tty_state(struct serial *scb, serial_ttystate new_ttystate, serial_ttystate old_ttystate)
Definition: ser-base.c:516
struct cleanup * make_cleanup(make_cleanup_ftype *function, void *arg)
Definition: cleanups.c:117
static const char * parity
Definition: serial.c:658
#define gdb_assert(expr)
Definition: gdb_assert.h:33
static void net_windows_close(struct serial *scb)
Definition: ser-mingw.c:1227
Definition: serial.h:227
static int ser_windows_open(struct serial *scb, const char *name)
Definition: ser-mingw.c:52
int ser_base_drain_output(struct serial *scb)
Definition: ser-base.c:484
unsigned char buf[BUFSIZ]
Definition: serial.h:245
static int ser_windows_setstopbits(struct serial *scb, int num)
Definition: ser-mingw.c:173
static DWORD WINAPI pipe_select_thread(void *arg)
Definition: ser-mingw.c:637
static void ser_windows_raw(struct serial *scb)
Definition: ser-mingw.c:148
static int ser_windows_flush_input(struct serial *scb)
Definition: ser-mingw.c:123
void * xmalloc(YYSIZE_T)
int gdb_pipe(int pdes[2])
Definition: ser-mingw.c:1064
select_thread_state
Definition: ser-mingw.c:393
static int pipe_windows_read(struct serial *scb, size_t count)
Definition: ser-mingw.c:974
#define SERIAL_1_AND_A_HALF_STOPBITS
Definition: serial.h:184
static struct pipe_state * make_pipe_state(void)
Definition: ser-mingw.c:818
#define SERIAL_1_STOPBITS
Definition: serial.h:183
bfd_byte gdb_byte
Definition: common-types.h:38
void ser_base_print_tty_state(struct serial *scb, serial_ttystate ttystate, struct ui_file *stream)
Definition: ser-base.c:524
void discard_cleanups(struct cleanup *old_chain)
Definition: cleanups.c:213
HANDLE have_started
Definition: ser-mingw.c:409
int ser_base_setparity(struct serial *scb, int parity)
Definition: ser-base.c:547
HANDLE except_event
Definition: ser-mingw.c:41
static int pipe_windows_write(struct serial *scb, const void *buf, size_t count)
Definition: ser-mingw.c:997
#define SERIAL_2_STOPBITS
Definition: serial.h:185
void serial_add_interface(const struct serial_ops *optable)
Definition: serial.c:162
static void start_select_thread(struct ser_console_state *state)
Definition: ser-mingw.c:503
#define CancelIo
Definition: ser-mingw.c:46
int ser_base_flush_input(struct serial *scb)
Definition: ser-base.c:465
struct ser_console_state wait
Definition: ser-mingw.c:808
int ser_base_readchar(struct serial *scb, int timeout)
Definition: ser-base.c:435
char * safe_strerror(int)
static int ser_windows_read_prim(struct serial *scb, size_t count)
Definition: ser-mingw.c:324
static void create_select_thread(thread_fn_type thread_fn, struct serial *scb, struct ser_console_state *state)
Definition: ser-mingw.c:461
int fd
Definition: serial.h:233
int ser_base_send_break(struct serial *scb)
Definition: ser-base.c:478
int ser_base_write(struct serial *scb, const void *buf, size_t count)
Definition: ser-base.c:441
static void ser_windows_wait_handle(struct serial *scb, HANDLE *read, HANDLE *except)
Definition: ser-mingw.c:272
char ** gdb_buildargv(const char *s)
Definition: utils.c:3036
void net_close(struct serial *scb)
Definition: ser-tcp.c:329
static int ser_windows_flush_output(struct serial *scb)
Definition: ser-mingw.c:115
int ser_tcp_send_break(struct serial *scb)
Definition: ser-tcp.c:354
static void free_pipe_state(struct pipe_state *ps)
Definition: ser-mingw.c:832
enum select_thread_state thread_state
Definition: ser-mingw.c:430
serial_ttystate ser_base_copy_tty_state(struct serial *scb, serial_ttystate ttystate)
Definition: ser-base.c:503
void * serial_ttystate
Definition: serial.h:27
DWORD lastCommMask
Definition: ser-mingw.c:40
static int pipe_windows_open(struct serial *scb, const char *name)
Definition: ser-mingw.c:866
static int pipe_windows_fdopen(struct serial *scb, int fd)
Definition: ser-mingw.c:936
#define GDBPARITY_ODD
Definition: serial.h:190
void * state
Definition: serial.h:240
void internal_warning(const char *file, int line, const char *fmt,...)
Definition: errors.c:62
static void destroy_select_thread(struct ser_console_state *state)
Definition: ser-mingw.c:483
void error(const char *fmt,...)
Definition: errors.c:38
static void pipe_windows_close(struct serial *scb)
Definition: ser-mingw.c:961
void do_cleanups(struct cleanup *old_chain)
Definition: cleanups.c:175
static void cleanup_pipe_state(void *untyped)
Definition: ser-mingw.c:858
serial_ttystate ser_base_get_tty_state(struct serial *scb)
Definition: ser-base.c:496
static int ser_windows_setbaudrate(struct serial *scb, int rate)
Definition: ser-mingw.c:234
const ULONGEST const LONGEST len
Definition: target.h:309
int rate
Definition: ser-unix.c:683
int net_open(struct serial *scb, const char *name)
Definition: ser-tcp.c:156