s390x/sclpconsole-lm: Fix hanging SCLP line mode console
[qemu.git] / qga / channel-win32.c
1 #include <stdlib.h>
2 #include <stdio.h>
3 #include <stdbool.h>
4 #include <glib.h>
5 #include <windows.h>
6 #include <errno.h>
7 #include <io.h>
8 #include "qga/guest-agent-core.h"
9 #include "qga/channel.h"
10
11 typedef struct GAChannelReadState {
12 guint thread_id;
13 uint8_t *buf;
14 size_t buf_size;
15 size_t cur; /* current buffer start */
16 size_t pending; /* pending buffered bytes to read */
17 OVERLAPPED ov;
18 bool ov_pending; /* whether on async read is outstanding */
19 } GAChannelReadState;
20
21 struct GAChannel {
22 HANDLE handle;
23 GAChannelCallback cb;
24 gpointer user_data;
25 GAChannelReadState rstate;
26 GIOCondition pending_events; /* TODO: use GAWatch.pollfd.revents */
27 GSource *source;
28 };
29
30 typedef struct GAWatch {
31 GSource source;
32 GPollFD pollfd;
33 GAChannel *channel;
34 GIOCondition events_mask;
35 } GAWatch;
36
37 /*
38 * Called by glib prior to polling to set up poll events if polling is needed.
39 *
40 */
41 static gboolean ga_channel_prepare(GSource *source, gint *timeout_ms)
42 {
43 GAWatch *watch = (GAWatch *)source;
44 GAChannel *c = (GAChannel *)watch->channel;
45 GAChannelReadState *rs = &c->rstate;
46 DWORD count_read, count_to_read = 0;
47 bool success;
48 GIOCondition new_events = 0;
49
50 g_debug("prepare");
51 /* go ahead and submit another read if there's room in the buffer
52 * and no previous reads are outstanding
53 */
54 if (!rs->ov_pending) {
55 if (rs->cur + rs->pending >= rs->buf_size) {
56 if (rs->cur) {
57 memmove(rs->buf, rs->buf + rs->cur, rs->pending);
58 rs->cur = 0;
59 }
60 }
61 count_to_read = rs->buf_size - rs->cur - rs->pending;
62 }
63
64 if (rs->ov_pending || count_to_read <= 0) {
65 goto out;
66 }
67
68 /* submit the read */
69 success = ReadFile(c->handle, rs->buf + rs->cur + rs->pending,
70 count_to_read, &count_read, &rs->ov);
71 if (success) {
72 rs->pending += count_read;
73 rs->ov_pending = false;
74 } else {
75 if (GetLastError() == ERROR_IO_PENDING) {
76 rs->ov_pending = true;
77 } else {
78 new_events |= G_IO_ERR;
79 }
80 }
81
82 out:
83 /* dont block forever, iterate the main loop every once and a while */
84 *timeout_ms = 500;
85 /* if there's data in the read buffer, or another event is pending,
86 * skip polling and issue user cb.
87 */
88 if (rs->pending) {
89 new_events |= G_IO_IN;
90 }
91 c->pending_events |= new_events;
92 return !!c->pending_events;
93 }
94
95 /*
96 * Called by glib after an outstanding read request is completed.
97 */
98 static gboolean ga_channel_check(GSource *source)
99 {
100 GAWatch *watch = (GAWatch *)source;
101 GAChannel *c = (GAChannel *)watch->channel;
102 GAChannelReadState *rs = &c->rstate;
103 DWORD count_read, error;
104 BOOL success;
105
106 GIOCondition new_events = 0;
107
108 g_debug("check");
109
110 /* failing this implies we issued a read that completed immediately,
111 * yet no data was placed into the buffer (and thus we did not skip
112 * polling). but since EOF is not obtainable until we retrieve an
113 * overlapped result, it must be the case that there was data placed
114 * into the buffer, or an error was generated by Readfile(). in either
115 * case, we should've skipped the polling for this round.
116 */
117 g_assert(rs->ov_pending);
118
119 success = GetOverlappedResult(c->handle, &rs->ov, &count_read, FALSE);
120 if (success) {
121 g_debug("thread: overlapped result, count_read: %d", (int)count_read);
122 rs->pending += count_read;
123 new_events |= G_IO_IN;
124 } else {
125 error = GetLastError();
126 if (error == 0 || error == ERROR_HANDLE_EOF ||
127 error == ERROR_NO_SYSTEM_RESOURCES ||
128 error == ERROR_OPERATION_ABORTED) {
129 /* note: On WinXP SP3 with rhel6ga virtio-win-1.1.16 vioser drivers,
130 * ENSR seems to be synonymous with when we'd normally expect
131 * ERROR_HANDLE_EOF. So treat it as such. Microsoft's
132 * recommendation for ERROR_NO_SYSTEM_RESOURCES is to
133 * retry the read, so this happens to work out anyway. On newer
134 * virtio-win driver, this seems to be replaced with EOA, so
135 * handle that in the same fashion.
136 */
137 new_events |= G_IO_HUP;
138 } else if (error != ERROR_IO_INCOMPLETE) {
139 g_critical("error retrieving overlapped result: %d", (int)error);
140 new_events |= G_IO_ERR;
141 }
142 }
143
144 if (new_events) {
145 rs->ov_pending = 0;
146 }
147 c->pending_events |= new_events;
148
149 return !!c->pending_events;
150 }
151
152 /*
153 * Called by glib after either prepare or check routines signal readiness
154 */
155 static gboolean ga_channel_dispatch(GSource *source, GSourceFunc unused,
156 gpointer user_data)
157 {
158 GAWatch *watch = (GAWatch *)source;
159 GAChannel *c = (GAChannel *)watch->channel;
160 GAChannelReadState *rs = &c->rstate;
161 gboolean success;
162
163 g_debug("dispatch");
164 success = c->cb(watch->pollfd.revents, c->user_data);
165
166 if (c->pending_events & G_IO_ERR) {
167 g_critical("channel error, removing source");
168 return false;
169 }
170
171 /* TODO: replace rs->pending with watch->revents */
172 c->pending_events &= ~G_IO_HUP;
173 if (!rs->pending) {
174 c->pending_events &= ~G_IO_IN;
175 } else {
176 c->pending_events = 0;
177 }
178 return success;
179 }
180
181 static void ga_channel_finalize(GSource *source)
182 {
183 g_debug("finalize");
184 }
185
186 GSourceFuncs ga_channel_watch_funcs = {
187 ga_channel_prepare,
188 ga_channel_check,
189 ga_channel_dispatch,
190 ga_channel_finalize
191 };
192
193 static GSource *ga_channel_create_watch(GAChannel *c)
194 {
195 GSource *source = g_source_new(&ga_channel_watch_funcs, sizeof(GAWatch));
196 GAWatch *watch = (GAWatch *)source;
197
198 watch->channel = c;
199 watch->pollfd.fd = (gintptr) c->rstate.ov.hEvent;
200 g_source_add_poll(source, &watch->pollfd);
201
202 return source;
203 }
204
205 GIOStatus ga_channel_read(GAChannel *c, char *buf, size_t size, gsize *count)
206 {
207 GAChannelReadState *rs = &c->rstate;
208 GIOStatus status;
209 size_t to_read = 0;
210
211 if (c->pending_events & G_IO_ERR) {
212 return G_IO_STATUS_ERROR;
213 }
214
215 *count = to_read = MIN(size, rs->pending);
216 if (to_read) {
217 memcpy(buf, rs->buf + rs->cur, to_read);
218 rs->cur += to_read;
219 rs->pending -= to_read;
220 status = G_IO_STATUS_NORMAL;
221 } else {
222 status = G_IO_STATUS_AGAIN;
223 }
224
225 return status;
226 }
227
228 static GIOStatus ga_channel_write(GAChannel *c, const char *buf, size_t size,
229 size_t *count)
230 {
231 GIOStatus status;
232 OVERLAPPED ov = {0};
233 BOOL ret;
234 DWORD written;
235
236 ov.hEvent = CreateEvent(NULL, FALSE, FALSE, NULL);
237 ret = WriteFile(c->handle, buf, size, &written, &ov);
238 if (!ret) {
239 if (GetLastError() == ERROR_IO_PENDING) {
240 /* write is pending */
241 ret = GetOverlappedResult(c->handle, &ov, &written, TRUE);
242 if (!ret) {
243 if (!GetLastError()) {
244 status = G_IO_STATUS_AGAIN;
245 } else {
246 status = G_IO_STATUS_ERROR;
247 }
248 } else {
249 /* write is complete */
250 status = G_IO_STATUS_NORMAL;
251 *count = written;
252 }
253 } else {
254 status = G_IO_STATUS_ERROR;
255 }
256 } else {
257 /* write returned immediately */
258 status = G_IO_STATUS_NORMAL;
259 *count = written;
260 }
261
262 if (ov.hEvent) {
263 CloseHandle(ov.hEvent);
264 ov.hEvent = NULL;
265 }
266 return status;
267 }
268
269 GIOStatus ga_channel_write_all(GAChannel *c, const char *buf, size_t size)
270 {
271 GIOStatus status = G_IO_STATUS_NORMAL;
272 size_t count;
273
274 while (size) {
275 status = ga_channel_write(c, buf, size, &count);
276 if (status == G_IO_STATUS_NORMAL) {
277 size -= count;
278 buf += count;
279 } else if (status != G_IO_STATUS_AGAIN) {
280 break;
281 }
282 }
283
284 return status;
285 }
286
287 static gboolean ga_channel_open(GAChannel *c, GAChannelMethod method,
288 const gchar *path)
289 {
290 COMMTIMEOUTS comTimeOut = {0};
291 gchar newpath[MAXPATHLEN] = {0};
292 comTimeOut.ReadIntervalTimeout = 1;
293
294 if (method != GA_CHANNEL_VIRTIO_SERIAL && method != GA_CHANNEL_ISA_SERIAL) {
295 g_critical("unsupported communication method");
296 return false;
297 }
298
299 if (method == GA_CHANNEL_ISA_SERIAL){
300 snprintf(newpath, sizeof(newpath), "\\\\.\\%s", path);
301 }else {
302 g_strlcpy(newpath, path, sizeof(newpath));
303 }
304
305 c->handle = CreateFile(newpath, GENERIC_READ | GENERIC_WRITE, 0, NULL,
306 OPEN_EXISTING,
307 FILE_FLAG_NO_BUFFERING | FILE_FLAG_OVERLAPPED, NULL);
308 if (c->handle == INVALID_HANDLE_VALUE) {
309 g_critical("error opening path");
310 return false;
311 }
312
313 if (method == GA_CHANNEL_ISA_SERIAL && !SetCommTimeouts(c->handle,&comTimeOut)) {
314 g_critical("error setting timeout for com port: %lu",GetLastError());
315 CloseHandle(c->handle);
316 return false;
317 }
318
319 return true;
320 }
321
322 GAChannel *ga_channel_new(GAChannelMethod method, const gchar *path,
323 GAChannelCallback cb, gpointer opaque)
324 {
325 GAChannel *c = g_malloc0(sizeof(GAChannel));
326 SECURITY_ATTRIBUTES sec_attrs;
327
328 if (!ga_channel_open(c, method, path)) {
329 g_critical("error opening channel");
330 g_free(c);
331 return NULL;
332 }
333
334 c->cb = cb;
335 c->user_data = opaque;
336
337 sec_attrs.nLength = sizeof(SECURITY_ATTRIBUTES);
338 sec_attrs.lpSecurityDescriptor = NULL;
339 sec_attrs.bInheritHandle = false;
340
341 c->rstate.buf_size = QGA_READ_COUNT_DEFAULT;
342 c->rstate.buf = g_malloc(QGA_READ_COUNT_DEFAULT);
343 c->rstate.ov.hEvent = CreateEvent(&sec_attrs, FALSE, FALSE, NULL);
344
345 c->source = ga_channel_create_watch(c);
346 g_source_attach(c->source, NULL);
347 return c;
348 }
349
350 void ga_channel_free(GAChannel *c)
351 {
352 if (c->source) {
353 g_source_destroy(c->source);
354 }
355 if (c->rstate.ov.hEvent) {
356 CloseHandle(c->rstate.ov.hEvent);
357 }
358 g_free(c->rstate.buf);
359 g_free(c);
360 }