Remove some defines from tui-data.h
[external/binutils.git] / gdb / ser-event.c
1 /* Serial interface for a selectable event.
2    Copyright (C) 2016-2019 Free Software Foundation, Inc.
3
4    This file is part of GDB.
5
6    This program is free software; you can redistribute it and/or modify
7    it under the terms of the GNU General Public License as published by
8    the Free Software Foundation; either version 3 of the License, or
9    (at your option) any later version.
10
11    This program is distributed in the hope that it will be useful,
12    but WITHOUT ANY WARRANTY; without even the implied warranty of
13    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
14    GNU General Public License for more details.
15
16    You should have received a copy of the GNU General Public License
17    along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
18
19 #include "defs.h"
20 #include "ser-event.h"
21 #include "serial.h"
22 #include "gdbsupport/filestuff.h"
23
24 /* On POSIX hosts, a serial_event is basically an abstraction for the
25    classical self-pipe trick.
26
27    On Windows, a serial_event is a wrapper around a native Windows
28    event object.  Because we want to interface with gdb_select, which
29    takes file descriptors, we need to wrap that Windows event object
30    in a file descriptor.  As _open_osfhandle can not be used with
31    event objects, we instead create a dummy file wrap that in a file
32    descriptor with _open_osfhandle, and pass that as selectable
33    descriptor to callers.  As Windows' gdb_select converts file
34    descriptors back to Windows handles by calling serial->wait_handle,
35    nothing ever actually waits on that file descriptor.  */
36
37 struct serial_event_state
38   {
39 #ifdef USE_WIN32API
40     /* The Windows event object, created with CreateEvent.  */
41     HANDLE event;
42 #else
43     /* The write side of the pipe.  The read side is in
44        serial->fd.  */
45     int write_fd;
46 #endif
47   };
48
49 /* Open a new serial event.  */
50
51 static int
52 serial_event_open (struct serial *scb, const char *name)
53 {
54   struct serial_event_state *state;
55
56   state = XNEW (struct serial_event_state);
57   scb->state = state;
58
59 #ifndef USE_WIN32API
60   {
61     int fds[2];
62
63     if (gdb_pipe_cloexec (fds) == -1)
64       internal_error (__FILE__, __LINE__,
65                       "creating serial event pipe failed.");
66
67     fcntl (fds[0], F_SETFL, O_NONBLOCK);
68     fcntl (fds[1], F_SETFL, O_NONBLOCK);
69
70     scb->fd = fds[0];
71     state->write_fd = fds[1];
72   }
73 #else
74   {
75     /* A dummy file object that can be wrapped in a file descriptor.
76        We don't need to store this handle because closing the file
77        descriptor automatically closes this.  */
78     HANDLE dummy_file;
79
80     /* A manual-reset event.  */
81     state->event = CreateEvent (0, TRUE, FALSE, 0);
82
83     /* The dummy file handle.  Created just so we have something
84        wrappable in a file descriptor.  */
85     dummy_file = CreateFile ("nul", 0, 0, NULL, OPEN_EXISTING, 0, NULL);
86     scb->fd = _open_osfhandle ((intptr_t) dummy_file, 0);
87   }
88 #endif
89
90   return 0;
91 }
92
93 static void
94 serial_event_close (struct serial *scb)
95 {
96   struct serial_event_state *state = (struct serial_event_state *) scb->state;
97
98   close (scb->fd);
99 #ifndef USE_WIN32API
100   close (state->write_fd);
101 #else
102   CloseHandle (state->event);
103 #endif
104
105   scb->fd = -1;
106
107   xfree (state);
108   scb->state = NULL;
109 }
110
111 #ifdef USE_WIN32API
112
113 /* Implementation of the wait_handle method.  Returns the native
114    Windows event object handle.  */
115
116 static void
117 serial_event_wait_handle (struct serial *scb, HANDLE *read, HANDLE *except)
118 {
119   struct serial_event_state *state = (struct serial_event_state *) scb->state;
120
121   *read = state->event;
122 }
123
124 #endif
125
126 /* The serial_ops for struct serial_event objects.  Note we never
127    register this serial type with serial_add_interface, because this
128    is internal implementation detail never to be used by remote
129    targets for protocol transport.  */
130
131 static const struct serial_ops serial_event_ops =
132 {
133   "event",
134   serial_event_open,
135   serial_event_close,
136   NULL, /* fdopen */
137   NULL, /* readchar */
138   NULL, /* write */
139   NULL, /* flush_output */
140   NULL, /* flush_input */
141   NULL, /* send_break */
142   NULL, /* go_raw */
143   NULL, /* get_tty_state */
144   NULL, /* copy_tty_state */
145   NULL, /* set_tty_state */
146   NULL, /* print_tty_state */
147   NULL, /* setbaudrate */
148   NULL, /* setstopbits */
149   NULL, /* setparity */
150   NULL, /* drain_output */
151   NULL, /* async */
152   NULL, /* read_prim */
153   NULL, /* write_prim */
154   NULL, /* avail */
155 #ifdef USE_WIN32API
156   serial_event_wait_handle,
157 #endif
158 };
159
160 /* See ser-event.h.  */
161
162 struct serial_event *
163 make_serial_event (void)
164 {
165   return (struct serial_event *) serial_open_ops (&serial_event_ops);
166 }
167
168 /* See ser-event.h.  */
169
170 int
171 serial_event_fd (struct serial_event *event)
172 {
173   struct serial *ser = (struct serial *) event;
174
175   return ser->fd;
176 }
177
178 /* See ser-event.h.  */
179
180 void
181 serial_event_set (struct serial_event *event)
182 {
183   struct serial *ser = (struct serial *) event;
184   struct serial_event_state *state = (struct serial_event_state *) ser->state;
185 #ifndef USE_WIN32API
186   int r;
187   char c = '+';         /* Anything.  */
188
189   do
190     {
191       r = write (state->write_fd, &c, 1);
192     }
193   while (r < 0 && errno == EINTR);
194 #else
195   SetEvent (state->event);
196 #endif
197 }
198
199 /* See ser-event.h.  */
200
201 void
202 serial_event_clear (struct serial_event *event)
203 {
204   struct serial *ser = (struct serial *) event;
205 #ifndef USE_WIN32API
206   int r;
207
208   do
209     {
210       char c;
211
212       r = read (ser->fd, &c, 1);
213     }
214   while (r > 0 || (r < 0 && errno == EINTR));
215 #else
216   struct serial_event_state *state = (struct serial_event_state *) ser->state;
217   ResetEvent (state->event);
218 #endif
219 }