chardev/char-win.c

   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
  25 #include "qemu/osdep.h"
  26 #include "qemu/main-loop.h"
  27 #include "qemu/module.h"
  28 #include "qapi/error.h"
  29 #include "chardev/char-win.h"
  30
  31 static void win_chr_read(Chardev *chr, DWORD len)
  32 {
  33     WinChardev *s = WIN_CHARDEV(chr);
  34     int max_size = qemu_chr_be_can_write(chr);
  35     int ret, err;
  36     uint8_t buf[CHR_READ_BUF_LEN];
  37     DWORD size;
  38
  39     if (len > max_size) {
  40         len = max_size;
  41     }
  42     if (len == 0) {
  43         return;
  44     }
  45
  46     ZeroMemory(&s->orecv, sizeof(s->orecv));
  47     s->orecv.hEvent = s->hrecv;
  48     ret = ReadFile(s->file, buf, len, &size, &s->orecv);
  49     if (!ret) {
  50         err = GetLastError();
  51         if (err == ERROR_IO_PENDING) {
  52             ret = GetOverlappedResult(s->file, &s->orecv, &size, TRUE);
  53         }
  54     }
  55
  56     if (size > 0) {
  57         qemu_chr_be_write(chr, buf, size);
  58     }
  59 }
  60
  61 static int win_chr_serial_poll(void *opaque)
  62 {
  63     Chardev *chr = CHARDEV(opaque);
  64     WinChardev *s = WIN_CHARDEV(opaque);
  65     COMSTAT status;
  66     DWORD comerr;
  67
  68     ClearCommError(s->file, &comerr, &status);
  69     if (status.cbInQue > 0) {
  70         win_chr_read(chr, status.cbInQue);
  71         return 1;
  72     }
  73     return 0;
  74 }
  75
  76 int win_chr_serial_init(Chardev *chr, const char *filename, Error **errp)
  77 {
  78     WinChardev *s = WIN_CHARDEV(chr);
  79     COMMCONFIG comcfg;
  80     COMMTIMEOUTS cto = { 0, 0, 0, 0, 0};
  81     COMSTAT comstat;
  82     DWORD size;
  83     DWORD err;
  84
  85     s->hsend = CreateEvent(NULL, TRUE, FALSE, NULL);
  86     if (!s->hsend) {
  87         error_setg(errp, "Failed CreateEvent");
  88         goto fail;
  89     }
  90     s->hrecv = CreateEvent(NULL, TRUE, FALSE, NULL);
  91     if (!s->hrecv) {
  92         error_setg(errp, "Failed CreateEvent");
  93         goto fail;
  94     }
  95
  96     s->file = CreateFile(filename, GENERIC_READ | GENERIC_WRITE, 0, NULL,
  97                       OPEN_EXISTING, FILE_FLAG_OVERLAPPED, 0);
  98     if (s->file == INVALID_HANDLE_VALUE) {
  99         error_setg_win32(errp, GetLastError(), "Failed CreateFile");
 100         s->file = NULL;
 101         goto fail;
 102     }
 103
 104     if (!SetupComm(s->file, NRECVBUF, NSENDBUF)) {
 105         error_setg(errp, "Failed SetupComm");
 106         goto fail;
 107     }
 108
 109     ZeroMemory(&comcfg, sizeof(COMMCONFIG));
 110     size = sizeof(COMMCONFIG);
 111     GetDefaultCommConfig(filename, &comcfg, &size);
 112     comcfg.dcb.DCBlength = sizeof(DCB);
 113     CommConfigDialog(filename, NULL, &comcfg);
 114
 115     if (!SetCommState(s->file, &comcfg.dcb)) {
 116         error_setg(errp, "Failed SetCommState");
 117         goto fail;
 118     }
 119
 120     if (!SetCommMask(s->file, EV_ERR)) {
 121         error_setg(errp, "Failed SetCommMask");
 122         goto fail;
 123     }
 124
 125     cto.ReadIntervalTimeout = MAXDWORD;
 126     if (!SetCommTimeouts(s->file, &cto)) {
 127         error_setg(errp, "Failed SetCommTimeouts");
 128         goto fail;
 129     }
 130
 131     if (!ClearCommError(s->file, &err, &comstat)) {
 132         error_setg(errp, "Failed ClearCommError");
 133         goto fail;
 134     }
 135     qemu_add_polling_cb(win_chr_serial_poll, chr);
 136     return 0;
 137
 138  fail:
 139     return -1;
 140 }
 141
 142 int win_chr_pipe_poll(void *opaque)
 143 {
 144     Chardev *chr = CHARDEV(opaque);
 145     WinChardev *s = WIN_CHARDEV(opaque);
 146     DWORD size;
 147
 148     PeekNamedPipe(s->file, NULL, 0, NULL, &size, NULL);
 149     if (size > 0) {
 150         win_chr_read(chr, size);
 151         return 1;
 152     }
 153     return 0;
 154 }
 155
 156 /* Called with chr_write_lock held.  */
 157 static int win_chr_write(Chardev *chr, const uint8_t *buf, int len1)
 158 {
 159     WinChardev *s = WIN_CHARDEV(chr);
 160     DWORD len, ret, size, err;
 161
 162     len = len1;
 163     ZeroMemory(&s->osend, sizeof(s->osend));
 164     s->osend.hEvent = s->hsend;
 165     while (len > 0) {
 166         if (s->hsend) {
 167             ret = WriteFile(s->file, buf, len, &size, &s->osend);
 168         } else {
 169             ret = WriteFile(s->file, buf, len, &size, NULL);
 170         }
 171         if (!ret) {
 172             err = GetLastError();
 173             if (err == ERROR_IO_PENDING) {
 174                 ret = GetOverlappedResult(s->file, &s->osend, &size, TRUE);
 175                 if (ret) {
 176                     buf += size;
 177                     len -= size;
 178                 } else {
 179                     break;
 180                 }
 181             } else {
 182                 break;
 183             }
 184         } else {
 185             buf += size;
 186             len -= size;
 187         }
 188     }
 189     return len1 - len;
 190 }
 191
 192 static void char_win_finalize(Object *obj)
 193 {
 194     Chardev *chr = CHARDEV(obj);
 195     WinChardev *s = WIN_CHARDEV(chr);
 196
 197     if (s->hsend) {
 198         CloseHandle(s->hsend);
 199     }
 200     if (s->hrecv) {
 201         CloseHandle(s->hrecv);
 202     }
 203     if (!s->keep_open && s->file) {
 204         CloseHandle(s->file);
 205     }
 206     if (s->fpipe) {
 207         qemu_del_polling_cb(win_chr_pipe_poll, chr);
 208     } else {
 209         qemu_del_polling_cb(win_chr_serial_poll, chr);
 210     }
 211
 212     qemu_chr_be_event(chr, CHR_EVENT_CLOSED);
 213 }
 214
 215 void win_chr_set_file(Chardev *chr, HANDLE file, bool keep_open)
 216 {
 217     WinChardev *s = WIN_CHARDEV(chr);
 218
 219     s->keep_open = keep_open;
 220     s->file = file;
 221 }
 222
 223 static void char_win_class_init(ObjectClass *oc, void *data)
 224 {
 225     ChardevClass *cc = CHARDEV_CLASS(oc);
 226
 227     cc->chr_write = win_chr_write;
 228 }
 229
 230 static const TypeInfo char_win_type_info = {
 231     .name = TYPE_CHARDEV_WIN,
 232     .parent = TYPE_CHARDEV,
 233     .instance_size = sizeof(WinChardev),
 234     .instance_finalize = char_win_finalize,
 235     .class_init = char_win_class_init,
 236     .abstract = true,
 237 };
 238
 239 static void register_types(void)
 240 {
 241     type_register_static(&char_win_type_info);
 242 }
 243
 244 type_init(register_types);