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/error-report.h" 26 #include "qapi/error.h" 27 #include "qapi-visit.h" 28 #include "sysemu/replay.h" 29 30 #include "chardev/char-fe.h" 31 #include "chardev/char-io.h" 32 #include "chardev/char-mux.h" 33 34 int qemu_chr_fe_write(CharBackend *be, const uint8_t *buf, int len) 35 { 36 Chardev *s = be->chr; 37 38 if (!s) { 39 return 0; 40 } 41 42 return qemu_chr_write(s, buf, len, false); 43 } 44 45 int qemu_chr_fe_write_all(CharBackend *be, const uint8_t *buf, int len) 46 { 47 Chardev *s = be->chr; 48 49 if (!s) { 50 return 0; 51 } 52 53 return qemu_chr_write(s, buf, len, true); 54 } 55 56 int qemu_chr_fe_read_all(CharBackend *be, uint8_t *buf, int len) 57 { 58 Chardev *s = be->chr; 59 int offset = 0, counter = 10; 60 int res; 61 62 if (!s || !CHARDEV_GET_CLASS(s)->chr_sync_read) { 63 return 0; 64 } 65 66 if (qemu_chr_replay(s) && replay_mode == REPLAY_MODE_PLAY) { 67 return replay_char_read_all_load(buf); 68 } 69 70 while (offset < len) { 71 retry: 72 res = CHARDEV_GET_CLASS(s)->chr_sync_read(s, buf + offset, 73 len - offset); 74 if (res == -1 && errno == EAGAIN) { 75 g_usleep(100); 76 goto retry; 77 } 78 79 if (res == 0) { 80 break; 81 } 82 83 if (res < 0) { 84 if (qemu_chr_replay(s) && replay_mode == REPLAY_MODE_RECORD) { 85 replay_char_read_all_save_error(res); 86 } 87 return res; 88 } 89 90 offset += res; 91 92 if (!counter--) { 93 break; 94 } 95 } 96 97 if (qemu_chr_replay(s) && replay_mode == REPLAY_MODE_RECORD) { 98 replay_char_read_all_save_buf(buf, offset); 99 } 100 return offset; 101 } 102 103 int qemu_chr_fe_ioctl(CharBackend *be, int cmd, void *arg) 104 { 105 Chardev *s = be->chr; 106 int res; 107 108 if (!s || !CHARDEV_GET_CLASS(s)->chr_ioctl || qemu_chr_replay(s)) { 109 res = -ENOTSUP; 110 } else { 111 res = CHARDEV_GET_CLASS(s)->chr_ioctl(s, cmd, arg); 112 } 113 114 return res; 115 } 116 117 int qemu_chr_fe_get_msgfd(CharBackend *be) 118 { 119 Chardev *s = be->chr; 120 int fd; 121 int res = (qemu_chr_fe_get_msgfds(be, &fd, 1) == 1) ? fd : -1; 122 if (s && qemu_chr_replay(s)) { 123 error_report("Replay: get msgfd is not supported " 124 "for serial devices yet"); 125 exit(1); 126 } 127 return res; 128 } 129 130 int qemu_chr_fe_get_msgfds(CharBackend *be, int *fds, int len) 131 { 132 Chardev *s = be->chr; 133 134 if (!s) { 135 return -1; 136 } 137 138 return CHARDEV_GET_CLASS(s)->get_msgfds ? 139 CHARDEV_GET_CLASS(s)->get_msgfds(s, fds, len) : -1; 140 } 141 142 int qemu_chr_fe_set_msgfds(CharBackend *be, int *fds, int num) 143 { 144 Chardev *s = be->chr; 145 146 if (!s) { 147 return -1; 148 } 149 150 return CHARDEV_GET_CLASS(s)->set_msgfds ? 151 CHARDEV_GET_CLASS(s)->set_msgfds(s, fds, num) : -1; 152 } 153 154 void qemu_chr_fe_accept_input(CharBackend *be) 155 { 156 Chardev *s = be->chr; 157 158 if (!s) { 159 return; 160 } 161 162 if (CHARDEV_GET_CLASS(s)->chr_accept_input) { 163 CHARDEV_GET_CLASS(s)->chr_accept_input(s); 164 } 165 qemu_notify_event(); 166 } 167 168 void qemu_chr_fe_printf(CharBackend *be, const char *fmt, ...) 169 { 170 char buf[CHR_READ_BUF_LEN]; 171 va_list ap; 172 va_start(ap, fmt); 173 vsnprintf(buf, sizeof(buf), fmt, ap); 174 /* XXX this blocks entire thread. Rewrite to use 175 * qemu_chr_fe_write and background I/O callbacks */ 176 qemu_chr_fe_write_all(be, (uint8_t *)buf, strlen(buf)); 177 va_end(ap); 178 } 179 180 Chardev *qemu_chr_fe_get_driver(CharBackend *be) 181 { 182 return be->chr; 183 } 184 185 bool qemu_chr_fe_init(CharBackend *b, Chardev *s, Error **errp) 186 { 187 int tag = 0; 188 189 if (CHARDEV_IS_MUX(s)) { 190 MuxChardev *d = MUX_CHARDEV(s); 191 192 if (d->mux_cnt >= MAX_MUX) { 193 goto unavailable; 194 } 195 196 d->backends[d->mux_cnt] = b; 197 tag = d->mux_cnt++; 198 } else if (s->be) { 199 goto unavailable; 200 } else { 201 s->be = b; 202 } 203 204 b->fe_open = false; 205 b->tag = tag; 206 b->chr = s; 207 return true; 208 209 unavailable: 210 error_setg(errp, QERR_DEVICE_IN_USE, s->label); 211 return false; 212 } 213 214 void qemu_chr_fe_deinit(CharBackend *b, bool del) 215 { 216 assert(b); 217 218 if (b->chr) { 219 qemu_chr_fe_set_handlers(b, NULL, NULL, NULL, NULL, NULL, true); 220 if (b->chr->be == b) { 221 b->chr->be = NULL; 222 } 223 if (CHARDEV_IS_MUX(b->chr)) { 224 MuxChardev *d = MUX_CHARDEV(b->chr); 225 d->backends[b->tag] = NULL; 226 } 227 if (del) { 228 object_unparent(OBJECT(b->chr)); 229 } 230 b->chr = NULL; 231 } 232 } 233 234 void qemu_chr_fe_set_handlers(CharBackend *b, 235 IOCanReadHandler *fd_can_read, 236 IOReadHandler *fd_read, 237 IOEventHandler *fd_event, 238 void *opaque, 239 GMainContext *context, 240 bool set_open) 241 { 242 Chardev *s; 243 ChardevClass *cc; 244 int fe_open; 245 246 s = b->chr; 247 if (!s) { 248 return; 249 } 250 251 cc = CHARDEV_GET_CLASS(s); 252 if (!opaque && !fd_can_read && !fd_read && !fd_event) { 253 fe_open = 0; 254 remove_fd_in_watch(s); 255 } else { 256 fe_open = 1; 257 } 258 b->chr_can_read = fd_can_read; 259 b->chr_read = fd_read; 260 b->chr_event = fd_event; 261 b->opaque = opaque; 262 if (cc->chr_update_read_handler) { 263 cc->chr_update_read_handler(s, context); 264 } 265 266 if (set_open) { 267 qemu_chr_fe_set_open(b, fe_open); 268 } 269 270 if (fe_open) { 271 qemu_chr_fe_take_focus(b); 272 /* We're connecting to an already opened device, so let's make sure we 273 also get the open event */ 274 if (s->be_open) { 275 qemu_chr_be_event(s, CHR_EVENT_OPENED); 276 } 277 } 278 279 if (CHARDEV_IS_MUX(s)) { 280 mux_chr_set_handlers(s, context); 281 } 282 } 283 284 void qemu_chr_fe_take_focus(CharBackend *b) 285 { 286 if (!b->chr) { 287 return; 288 } 289 290 if (CHARDEV_IS_MUX(b->chr)) { 291 mux_set_focus(b->chr, b->tag); 292 } 293 } 294 295 int qemu_chr_fe_wait_connected(CharBackend *be, Error **errp) 296 { 297 if (!be->chr) { 298 error_setg(errp, "missing associated backend"); 299 return -1; 300 } 301 302 return qemu_chr_wait_connected(be->chr, errp); 303 } 304 305 void qemu_chr_fe_set_echo(CharBackend *be, bool echo) 306 { 307 Chardev *chr = be->chr; 308 309 if (chr && CHARDEV_GET_CLASS(chr)->chr_set_echo) { 310 CHARDEV_GET_CLASS(chr)->chr_set_echo(chr, echo); 311 } 312 } 313 314 void qemu_chr_fe_set_open(CharBackend *be, int fe_open) 315 { 316 Chardev *chr = be->chr; 317 318 if (!chr) { 319 return; 320 } 321 322 if (be->fe_open == fe_open) { 323 return; 324 } 325 be->fe_open = fe_open; 326 if (CHARDEV_GET_CLASS(chr)->chr_set_fe_open) { 327 CHARDEV_GET_CLASS(chr)->chr_set_fe_open(chr, fe_open); 328 } 329 } 330 331 guint qemu_chr_fe_add_watch(CharBackend *be, GIOCondition cond, 332 GIOFunc func, void *user_data) 333 { 334 Chardev *s = be->chr; 335 GSource *src; 336 guint tag; 337 338 if (!s || CHARDEV_GET_CLASS(s)->chr_add_watch == NULL) { 339 return 0; 340 } 341 342 src = CHARDEV_GET_CLASS(s)->chr_add_watch(s, cond); 343 if (!src) { 344 return 0; 345 } 346 347 g_source_set_callback(src, (GSourceFunc)func, user_data, NULL); 348 tag = g_source_attach(src, NULL); 349 g_source_unref(src); 350 351 return tag; 352 } 353 354 void qemu_chr_fe_disconnect(CharBackend *be) 355 { 356 Chardev *chr = be->chr; 357 358 if (chr && CHARDEV_GET_CLASS(chr)->chr_disconnect) { 359 CHARDEV_GET_CLASS(chr)->chr_disconnect(chr); 360 } 361 } 362