GDB (xrefs)

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