xref: /openbmc/qemu/chardev/char-win.c (revision 4a09d0bb) 
1 /*
2  * QEMU System Emulator
3  *
4  * Copyright (c) 2003-2008 Fabrice Bellard
5  *
6  * Permission is hereby granted, free of charge, to any person obtaining a copy
7  * of this software and associated documentation files (the "Software"), to deal
8  * in the Software without restriction, including without limitation the rights
9  * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
10  * copies of the Software, and to permit persons to whom the Software is
11  * furnished to do so, subject to the following conditions:
12  *
13  * The above copyright notice and this permission notice shall be included in
14  * all copies or substantial portions of the Software.
15  *
16  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
17  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
18  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
19  * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
20  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
21  * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
22  * THE SOFTWARE.
23  */
24 #include "qemu/osdep.h"
25 #include "qemu-common.h"
26 #include "qapi/error.h"
27 #include "char-win.h"
28 
29 static void win_chr_readfile(Chardev *chr)
30 {
31     WinChardev *s = WIN_CHARDEV(chr);
32 
33     int ret, err;
34     uint8_t buf[CHR_READ_BUF_LEN];
35     DWORD size;
36 
37     ZeroMemory(&s->orecv, sizeof(s->orecv));
38     s->orecv.hEvent = s->hrecv;
39     ret = ReadFile(s->hcom, buf, s->len, &size, &s->orecv);
40     if (!ret) {
41         err = GetLastError();
42         if (err == ERROR_IO_PENDING) {
43             ret = GetOverlappedResult(s->hcom, &s->orecv, &size, TRUE);
44         }
45     }
46 
47     if (size > 0) {
48         qemu_chr_be_write(chr, buf, size);
49     }
50 }
51 
52 static void win_chr_read(Chardev *chr)
53 {
54     WinChardev *s = WIN_CHARDEV(chr);
55 
56     if (s->len > s->max_size) {
57         s->len = s->max_size;
58     }
59     if (s->len == 0) {
60         return;
61     }
62 
63     win_chr_readfile(chr);
64 }
65 
66 static int win_chr_read_poll(Chardev *chr)
67 {
68     WinChardev *s = WIN_CHARDEV(chr);
69 
70     s->max_size = qemu_chr_be_can_write(chr);
71     return s->max_size;
72 }
73 
74 static int win_chr_poll(void *opaque)
75 {
76     Chardev *chr = CHARDEV(opaque);
77     WinChardev *s = WIN_CHARDEV(opaque);
78     COMSTAT status;
79     DWORD comerr;
80 
81     ClearCommError(s->hcom, &comerr, &status);
82     if (status.cbInQue > 0) {
83         s->len = status.cbInQue;
84         win_chr_read_poll(chr);
85         win_chr_read(chr);
86         return 1;
87     }
88     return 0;
89 }
90 
91 int win_chr_init(Chardev *chr, const char *filename, Error **errp)
92 {
93     WinChardev *s = WIN_CHARDEV(chr);
94     COMMCONFIG comcfg;
95     COMMTIMEOUTS cto = { 0, 0, 0, 0, 0};
96     COMSTAT comstat;
97     DWORD size;
98     DWORD err;
99 
100     s->hsend = CreateEvent(NULL, TRUE, FALSE, NULL);
101     if (!s->hsend) {
102         error_setg(errp, "Failed CreateEvent");
103         goto fail;
104     }
105     s->hrecv = CreateEvent(NULL, TRUE, FALSE, NULL);
106     if (!s->hrecv) {
107         error_setg(errp, "Failed CreateEvent");
108         goto fail;
109     }
110 
111     s->hcom = CreateFile(filename, GENERIC_READ | GENERIC_WRITE, 0, NULL,
112                       OPEN_EXISTING, FILE_FLAG_OVERLAPPED, 0);
113     if (s->hcom == INVALID_HANDLE_VALUE) {
114         error_setg(errp, "Failed CreateFile (%lu)", GetLastError());
115         s->hcom = NULL;
116         goto fail;
117     }
118 
119     if (!SetupComm(s->hcom, NRECVBUF, NSENDBUF)) {
120         error_setg(errp, "Failed SetupComm");
121         goto fail;
122     }
123 
124     ZeroMemory(&comcfg, sizeof(COMMCONFIG));
125     size = sizeof(COMMCONFIG);
126     GetDefaultCommConfig(filename, &comcfg, &size);
127     comcfg.dcb.DCBlength = sizeof(DCB);
128     CommConfigDialog(filename, NULL, &comcfg);
129 
130     if (!SetCommState(s->hcom, &comcfg.dcb)) {
131         error_setg(errp, "Failed SetCommState");
132         goto fail;
133     }
134 
135     if (!SetCommMask(s->hcom, EV_ERR)) {
136         error_setg(errp, "Failed SetCommMask");
137         goto fail;
138     }
139 
140     cto.ReadIntervalTimeout = MAXDWORD;
141     if (!SetCommTimeouts(s->hcom, &cto)) {
142         error_setg(errp, "Failed SetCommTimeouts");
143         goto fail;
144     }
145 
146     if (!ClearCommError(s->hcom, &err, &comstat)) {
147         error_setg(errp, "Failed ClearCommError");
148         goto fail;
149     }
150     qemu_add_polling_cb(win_chr_poll, chr);
151     return 0;
152 
153  fail:
154     return -1;
155 }
156 
157 int win_chr_pipe_poll(void *opaque)
158 {
159     Chardev *chr = CHARDEV(opaque);
160     WinChardev *s = WIN_CHARDEV(opaque);
161     DWORD size;
162 
163     PeekNamedPipe(s->hcom, NULL, 0, NULL, &size, NULL);
164     if (size > 0) {
165         s->len = size;
166         win_chr_read_poll(chr);
167         win_chr_read(chr);
168         return 1;
169     }
170     return 0;
171 }
172 
173 /* Called with chr_write_lock held.  */
174 static int win_chr_write(Chardev *chr, const uint8_t *buf, int len1)
175 {
176     WinChardev *s = WIN_CHARDEV(chr);
177     DWORD len, ret, size, err;
178 
179     len = len1;
180     ZeroMemory(&s->osend, sizeof(s->osend));
181     s->osend.hEvent = s->hsend;
182     while (len > 0) {
183         if (s->hsend) {
184             ret = WriteFile(s->hcom, buf, len, &size, &s->osend);
185         } else {
186             ret = WriteFile(s->hcom, buf, len, &size, NULL);
187         }
188         if (!ret) {
189             err = GetLastError();
190             if (err == ERROR_IO_PENDING) {
191                 ret = GetOverlappedResult(s->hcom, &s->osend, &size, TRUE);
192                 if (ret) {
193                     buf += size;
194                     len -= size;
195                 } else {
196                     break;
197                 }
198             } else {
199                 break;
200             }
201         } else {
202             buf += size;
203             len -= size;
204         }
205     }
206     return len1 - len;
207 }
208 
209 static void char_win_finalize(Object *obj)
210 {
211     Chardev *chr = CHARDEV(obj);
212     WinChardev *s = WIN_CHARDEV(chr);
213 
214     if (s->skip_free) {
215         return;
216     }
217 
218     if (s->hsend) {
219         CloseHandle(s->hsend);
220     }
221     if (s->hrecv) {
222         CloseHandle(s->hrecv);
223     }
224     if (s->hcom) {
225         CloseHandle(s->hcom);
226     }
227     if (s->fpipe) {
228         qemu_del_polling_cb(win_chr_pipe_poll, chr);
229     } else {
230         qemu_del_polling_cb(win_chr_poll, chr);
231     }
232 
233     qemu_chr_be_event(chr, CHR_EVENT_CLOSED);
234 }
235 
236 void qemu_chr_open_win_file(Chardev *chr, HANDLE fd_out)
237 {
238     WinChardev *s = WIN_CHARDEV(chr);
239 
240     s->skip_free = true;
241     s->hcom = fd_out;
242 }
243 
244 static void char_win_class_init(ObjectClass *oc, void *data)
245 {
246     ChardevClass *cc = CHARDEV_CLASS(oc);
247 
248     cc->chr_write = win_chr_write;
249 }
250 
251 static const TypeInfo char_win_type_info = {
252     .name = TYPE_CHARDEV_WIN,
253     .parent = TYPE_CHARDEV,
254     .instance_size = sizeof(WinChardev),
255     .instance_finalize = char_win_finalize,
256     .class_init = char_win_class_init,
257     .abstract = true,
258 };
259 
260 static void register_types(void)
261 {
262     type_register_static(&char_win_type_info);
263 }
264 
265 type_init(register_types);
266