GDB (xrefs)

/tmp/gdb-8.1/gdb/ser-event.c
Go to the documentation of this file.
1 /* Serial interface for a selectable event.
2 Copyright (C) 2016-2018 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 "common/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 }
read
ssize_t read(int fd, void *buf, size_t count)
Definition: expect-read1.c:26
xfree
void xfree(void *)
gdb_pipe_cloexec
int gdb_pipe_cloexec(int filedes[2])
Definition: filestuff.c:373
serial_event_state::write_fd
int write_fd
Definition: ser-event.c:45
internal_error
void internal_error(const char *file, int line, const char *fmt,...)
Definition: errors.c:50
defs.h
serial_ops
Definition: serial.h:250
XNEW
#define XNEW(T)
Definition: poison.h:109
name
const char *const name
Definition: aarch64-tdep.c:76
serial_open_ops
struct serial * serial_open_ops(const struct serial_ops *ops)
Definition: serial.c:265
serial_event_fd
int serial_event_fd(struct serial_event *event)
Definition: ser-event.c:171
serial_event_close
static void serial_event_close(struct serial *scb)
Definition: ser-event.c:94
serial_event_ops
static const struct serial_ops serial_event_ops
Definition: ser-event.c:131
serial.h
serial
Definition: serial.h:224
ser-event.h
serial_event_state
Definition: ser-event.c:37
serial_event_clear
void serial_event_clear(struct serial_event *event)
Definition: ser-event.c:202
make_serial_event
struct serial_event * make_serial_event(void)
Definition: ser-event.c:163
serial::fd
int fd
Definition: serial.h:230
serial_event_set
void serial_event_set(struct serial_event *event)
Definition: ser-event.c:181
serial_event_open
static int serial_event_open(struct serial *scb, const char *name)
Definition: ser-event.c:52
filestuff.h
serial::state
void * state
Definition: serial.h:237