1 /* 2 * USB redirector usb-guest 3 * 4 * Copyright (c) 2011-2012 Red Hat, Inc. 5 * 6 * Red Hat Authors: 7 * Hans de Goede <hdegoede@redhat.com> 8 * 9 * Permission is hereby granted, free of charge, to any person obtaining a copy 10 * of this software and associated documentation files (the "Software"), to deal 11 * in the Software without restriction, including without limitation the rights 12 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell 13 * copies of the Software, and to permit persons to whom the Software is 14 * furnished to do so, subject to the following conditions: 15 * 16 * The above copyright notice and this permission notice shall be included in 17 * all copies or substantial portions of the Software. 18 * 19 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 20 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 21 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL 22 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 23 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, 24 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN 25 * THE SOFTWARE. 26 */ 27 28 #include "qemu/osdep.h" 29 #include "qemu-common.h" 30 #include "qemu/units.h" 31 #include "qapi/error.h" 32 #include "qemu/timer.h" 33 #include "sysemu/runstate.h" 34 #include "sysemu/sysemu.h" 35 #include "qapi/qmp/qerror.h" 36 #include "qemu/error-report.h" 37 #include "qemu/iov.h" 38 #include "qemu/module.h" 39 #include "chardev/char-fe.h" 40 41 #include <usbredirparser.h> 42 #include <usbredirfilter.h> 43 44 #include "hw/qdev-properties.h" 45 #include "hw/usb.h" 46 #include "migration/qemu-file-types.h" 47 #include "migration/vmstate.h" 48 49 /* ERROR is defined below. Remove any previous definition. */ 50 #undef ERROR 51 52 #define MAX_ENDPOINTS 32 53 #define NO_INTERFACE_INFO 255 /* Valid interface_count always <= 32 */ 54 #define EP2I(ep_address) (((ep_address & 0x80) >> 3) | (ep_address & 0x0f)) 55 #define I2EP(i) (((i & 0x10) << 3) | (i & 0x0f)) 56 #define USBEP2I(usb_ep) (((usb_ep)->pid == USB_TOKEN_IN) ? \ 57 ((usb_ep)->nr | 0x10) : ((usb_ep)->nr)) 58 #define I2USBEP(d, i) (usb_ep_get(&(d)->dev, \ 59 ((i) & 0x10) ? USB_TOKEN_IN : USB_TOKEN_OUT, \ 60 (i) & 0x0f)) 61 62 #ifndef USBREDIR_VERSION /* This is not defined in older usbredir versions */ 63 #define USBREDIR_VERSION 0 64 #endif 65 66 typedef struct USBRedirDevice USBRedirDevice; 67 68 /* Struct to hold buffered packets */ 69 struct buf_packet { 70 uint8_t *data; 71 void *free_on_destroy; 72 uint16_t len; 73 uint16_t offset; 74 uint8_t status; 75 QTAILQ_ENTRY(buf_packet)next; 76 }; 77 78 struct endp_data { 79 USBRedirDevice *dev; 80 uint8_t type; 81 uint8_t interval; 82 uint8_t interface; /* bInterfaceNumber this ep belongs to */ 83 uint16_t max_packet_size; /* In bytes, not wMaxPacketSize format !! */ 84 uint32_t max_streams; 85 uint8_t iso_started; 86 uint8_t iso_error; /* For reporting iso errors to the HC */ 87 uint8_t interrupt_started; 88 uint8_t interrupt_error; 89 uint8_t bulk_receiving_enabled; 90 uint8_t bulk_receiving_started; 91 uint8_t bufpq_prefilled; 92 uint8_t bufpq_dropping_packets; 93 QTAILQ_HEAD(, buf_packet) bufpq; 94 int32_t bufpq_size; 95 int32_t bufpq_target_size; 96 USBPacket *pending_async_packet; 97 }; 98 99 struct PacketIdQueueEntry { 100 uint64_t id; 101 QTAILQ_ENTRY(PacketIdQueueEntry)next; 102 }; 103 104 struct PacketIdQueue { 105 USBRedirDevice *dev; 106 const char *name; 107 QTAILQ_HEAD(, PacketIdQueueEntry) head; 108 int size; 109 }; 110 111 struct USBRedirDevice { 112 USBDevice dev; 113 /* Properties */ 114 CharBackend cs; 115 bool enable_streams; 116 uint8_t debug; 117 int32_t bootindex; 118 char *filter_str; 119 /* Data passed from chardev the fd_read cb to the usbredirparser read cb */ 120 const uint8_t *read_buf; 121 int read_buf_size; 122 /* Active chardev-watch-tag */ 123 guint watch; 124 /* For async handling of close / reject */ 125 QEMUBH *chardev_close_bh; 126 QEMUBH *device_reject_bh; 127 /* To delay the usb attach in case of quick chardev close + open */ 128 QEMUTimer *attach_timer; 129 int64_t next_attach_time; 130 struct usbredirparser *parser; 131 struct endp_data endpoint[MAX_ENDPOINTS]; 132 struct PacketIdQueue cancelled; 133 struct PacketIdQueue already_in_flight; 134 void (*buffered_bulk_in_complete)(USBRedirDevice *, USBPacket *, uint8_t); 135 /* Data for device filtering */ 136 struct usb_redir_device_connect_header device_info; 137 struct usb_redir_interface_info_header interface_info; 138 struct usbredirfilter_rule *filter_rules; 139 int filter_rules_count; 140 int compatible_speedmask; 141 VMChangeStateEntry *vmstate; 142 }; 143 144 #define TYPE_USB_REDIR "usb-redir" 145 #define USB_REDIRECT(obj) OBJECT_CHECK(USBRedirDevice, (obj), TYPE_USB_REDIR) 146 147 static void usbredir_hello(void *priv, struct usb_redir_hello_header *h); 148 static void usbredir_device_connect(void *priv, 149 struct usb_redir_device_connect_header *device_connect); 150 static void usbredir_device_disconnect(void *priv); 151 static void usbredir_interface_info(void *priv, 152 struct usb_redir_interface_info_header *interface_info); 153 static void usbredir_ep_info(void *priv, 154 struct usb_redir_ep_info_header *ep_info); 155 static void usbredir_configuration_status(void *priv, uint64_t id, 156 struct usb_redir_configuration_status_header *configuration_status); 157 static void usbredir_alt_setting_status(void *priv, uint64_t id, 158 struct usb_redir_alt_setting_status_header *alt_setting_status); 159 static void usbredir_iso_stream_status(void *priv, uint64_t id, 160 struct usb_redir_iso_stream_status_header *iso_stream_status); 161 static void usbredir_interrupt_receiving_status(void *priv, uint64_t id, 162 struct usb_redir_interrupt_receiving_status_header 163 *interrupt_receiving_status); 164 static void usbredir_bulk_streams_status(void *priv, uint64_t id, 165 struct usb_redir_bulk_streams_status_header *bulk_streams_status); 166 static void usbredir_bulk_receiving_status(void *priv, uint64_t id, 167 struct usb_redir_bulk_receiving_status_header *bulk_receiving_status); 168 static void usbredir_control_packet(void *priv, uint64_t id, 169 struct usb_redir_control_packet_header *control_packet, 170 uint8_t *data, int data_len); 171 static void usbredir_bulk_packet(void *priv, uint64_t id, 172 struct usb_redir_bulk_packet_header *bulk_packet, 173 uint8_t *data, int data_len); 174 static void usbredir_iso_packet(void *priv, uint64_t id, 175 struct usb_redir_iso_packet_header *iso_packet, 176 uint8_t *data, int data_len); 177 static void usbredir_interrupt_packet(void *priv, uint64_t id, 178 struct usb_redir_interrupt_packet_header *interrupt_header, 179 uint8_t *data, int data_len); 180 static void usbredir_buffered_bulk_packet(void *priv, uint64_t id, 181 struct usb_redir_buffered_bulk_packet_header *buffered_bulk_packet, 182 uint8_t *data, int data_len); 183 184 static void usbredir_handle_status(USBRedirDevice *dev, USBPacket *p, 185 int status); 186 187 #define VERSION "qemu usb-redir guest " QEMU_VERSION 188 189 /* 190 * Logging stuff 191 */ 192 193 #define ERROR(...) \ 194 do { \ 195 if (dev->debug >= usbredirparser_error) { \ 196 error_report("usb-redir error: " __VA_ARGS__); \ 197 } \ 198 } while (0) 199 #define WARNING(...) \ 200 do { \ 201 if (dev->debug >= usbredirparser_warning) { \ 202 warn_report("" __VA_ARGS__); \ 203 } \ 204 } while (0) 205 #define INFO(...) \ 206 do { \ 207 if (dev->debug >= usbredirparser_info) { \ 208 error_report("usb-redir: " __VA_ARGS__); \ 209 } \ 210 } while (0) 211 #define DPRINTF(...) \ 212 do { \ 213 if (dev->debug >= usbredirparser_debug) { \ 214 error_report("usb-redir: " __VA_ARGS__); \ 215 } \ 216 } while (0) 217 #define DPRINTF2(...) \ 218 do { \ 219 if (dev->debug >= usbredirparser_debug_data) { \ 220 error_report("usb-redir: " __VA_ARGS__); \ 221 } \ 222 } while (0) 223 224 static void usbredir_log(void *priv, int level, const char *msg) 225 { 226 USBRedirDevice *dev = priv; 227 228 if (dev->debug < level) { 229 return; 230 } 231 232 error_report("%s", msg); 233 } 234 235 static void usbredir_log_data(USBRedirDevice *dev, const char *desc, 236 const uint8_t *data, int len) 237 { 238 if (dev->debug < usbredirparser_debug_data) { 239 return; 240 } 241 qemu_hexdump((char *)data, stderr, desc, len); 242 } 243 244 /* 245 * usbredirparser io functions 246 */ 247 248 static int usbredir_read(void *priv, uint8_t *data, int count) 249 { 250 USBRedirDevice *dev = priv; 251 252 if (dev->read_buf_size < count) { 253 count = dev->read_buf_size; 254 } 255 256 memcpy(data, dev->read_buf, count); 257 258 dev->read_buf_size -= count; 259 if (dev->read_buf_size) { 260 dev->read_buf += count; 261 } else { 262 dev->read_buf = NULL; 263 } 264 265 return count; 266 } 267 268 static gboolean usbredir_write_unblocked(GIOChannel *chan, GIOCondition cond, 269 void *opaque) 270 { 271 USBRedirDevice *dev = opaque; 272 273 dev->watch = 0; 274 usbredirparser_do_write(dev->parser); 275 276 return FALSE; 277 } 278 279 static int usbredir_write(void *priv, uint8_t *data, int count) 280 { 281 USBRedirDevice *dev = priv; 282 int r; 283 284 if (!qemu_chr_fe_backend_open(&dev->cs)) { 285 return 0; 286 } 287 288 /* Don't send new data to the chardev until our state is fully synced */ 289 if (!runstate_check(RUN_STATE_RUNNING)) { 290 return 0; 291 } 292 293 r = qemu_chr_fe_write(&dev->cs, data, count); 294 if (r < count) { 295 if (!dev->watch) { 296 dev->watch = qemu_chr_fe_add_watch(&dev->cs, G_IO_OUT | G_IO_HUP, 297 usbredir_write_unblocked, dev); 298 } 299 if (r < 0) { 300 r = 0; 301 } 302 } 303 return r; 304 } 305 306 /* 307 * Cancelled and buffered packets helpers 308 */ 309 310 static void packet_id_queue_init(struct PacketIdQueue *q, 311 USBRedirDevice *dev, const char *name) 312 { 313 q->dev = dev; 314 q->name = name; 315 QTAILQ_INIT(&q->head); 316 q->size = 0; 317 } 318 319 static void packet_id_queue_add(struct PacketIdQueue *q, uint64_t id) 320 { 321 USBRedirDevice *dev = q->dev; 322 struct PacketIdQueueEntry *e; 323 324 DPRINTF("adding packet id %"PRIu64" to %s queue\n", id, q->name); 325 326 e = g_new0(struct PacketIdQueueEntry, 1); 327 e->id = id; 328 QTAILQ_INSERT_TAIL(&q->head, e, next); 329 q->size++; 330 } 331 332 static int packet_id_queue_remove(struct PacketIdQueue *q, uint64_t id) 333 { 334 USBRedirDevice *dev = q->dev; 335 struct PacketIdQueueEntry *e; 336 337 QTAILQ_FOREACH(e, &q->head, next) { 338 if (e->id == id) { 339 DPRINTF("removing packet id %"PRIu64" from %s queue\n", 340 id, q->name); 341 QTAILQ_REMOVE(&q->head, e, next); 342 q->size--; 343 g_free(e); 344 return 1; 345 } 346 } 347 return 0; 348 } 349 350 static void packet_id_queue_empty(struct PacketIdQueue *q) 351 { 352 USBRedirDevice *dev = q->dev; 353 struct PacketIdQueueEntry *e, *next_e; 354 355 DPRINTF("removing %d packet-ids from %s queue\n", q->size, q->name); 356 357 QTAILQ_FOREACH_SAFE(e, &q->head, next, next_e) { 358 QTAILQ_REMOVE(&q->head, e, next); 359 g_free(e); 360 } 361 q->size = 0; 362 } 363 364 static void usbredir_cancel_packet(USBDevice *udev, USBPacket *p) 365 { 366 USBRedirDevice *dev = USB_REDIRECT(udev); 367 int i = USBEP2I(p->ep); 368 369 if (p->combined) { 370 usb_combined_packet_cancel(udev, p); 371 return; 372 } 373 374 if (dev->endpoint[i].pending_async_packet) { 375 assert(dev->endpoint[i].pending_async_packet == p); 376 dev->endpoint[i].pending_async_packet = NULL; 377 return; 378 } 379 380 packet_id_queue_add(&dev->cancelled, p->id); 381 usbredirparser_send_cancel_data_packet(dev->parser, p->id); 382 usbredirparser_do_write(dev->parser); 383 } 384 385 static int usbredir_is_cancelled(USBRedirDevice *dev, uint64_t id) 386 { 387 if (!dev->dev.attached) { 388 return 1; /* Treat everything as cancelled after a disconnect */ 389 } 390 return packet_id_queue_remove(&dev->cancelled, id); 391 } 392 393 static void usbredir_fill_already_in_flight_from_ep(USBRedirDevice *dev, 394 struct USBEndpoint *ep) 395 { 396 static USBPacket *p; 397 398 /* async handled packets for bulk receiving eps do not count as inflight */ 399 if (dev->endpoint[USBEP2I(ep)].bulk_receiving_started) { 400 return; 401 } 402 403 QTAILQ_FOREACH(p, &ep->queue, queue) { 404 /* Skip combined packets, except for the first */ 405 if (p->combined && p != p->combined->first) { 406 continue; 407 } 408 if (p->state == USB_PACKET_ASYNC) { 409 packet_id_queue_add(&dev->already_in_flight, p->id); 410 } 411 } 412 } 413 414 static void usbredir_fill_already_in_flight(USBRedirDevice *dev) 415 { 416 int ep; 417 struct USBDevice *udev = &dev->dev; 418 419 usbredir_fill_already_in_flight_from_ep(dev, &udev->ep_ctl); 420 421 for (ep = 0; ep < USB_MAX_ENDPOINTS; ep++) { 422 usbredir_fill_already_in_flight_from_ep(dev, &udev->ep_in[ep]); 423 usbredir_fill_already_in_flight_from_ep(dev, &udev->ep_out[ep]); 424 } 425 } 426 427 static int usbredir_already_in_flight(USBRedirDevice *dev, uint64_t id) 428 { 429 return packet_id_queue_remove(&dev->already_in_flight, id); 430 } 431 432 static USBPacket *usbredir_find_packet_by_id(USBRedirDevice *dev, 433 uint8_t ep, uint64_t id) 434 { 435 USBPacket *p; 436 437 if (usbredir_is_cancelled(dev, id)) { 438 return NULL; 439 } 440 441 p = usb_ep_find_packet_by_id(&dev->dev, 442 (ep & USB_DIR_IN) ? USB_TOKEN_IN : USB_TOKEN_OUT, 443 ep & 0x0f, id); 444 if (p == NULL) { 445 ERROR("could not find packet with id %"PRIu64"\n", id); 446 } 447 return p; 448 } 449 450 static int bufp_alloc(USBRedirDevice *dev, uint8_t *data, uint16_t len, 451 uint8_t status, uint8_t ep, void *free_on_destroy) 452 { 453 struct buf_packet *bufp; 454 455 if (!dev->endpoint[EP2I(ep)].bufpq_dropping_packets && 456 dev->endpoint[EP2I(ep)].bufpq_size > 457 2 * dev->endpoint[EP2I(ep)].bufpq_target_size) { 458 DPRINTF("bufpq overflow, dropping packets ep %02X\n", ep); 459 dev->endpoint[EP2I(ep)].bufpq_dropping_packets = 1; 460 } 461 /* Since we're interupting the stream anyways, drop enough packets to get 462 back to our target buffer size */ 463 if (dev->endpoint[EP2I(ep)].bufpq_dropping_packets) { 464 if (dev->endpoint[EP2I(ep)].bufpq_size > 465 dev->endpoint[EP2I(ep)].bufpq_target_size) { 466 free(data); 467 return -1; 468 } 469 dev->endpoint[EP2I(ep)].bufpq_dropping_packets = 0; 470 } 471 472 bufp = g_new(struct buf_packet, 1); 473 bufp->data = data; 474 bufp->len = len; 475 bufp->offset = 0; 476 bufp->status = status; 477 bufp->free_on_destroy = free_on_destroy; 478 QTAILQ_INSERT_TAIL(&dev->endpoint[EP2I(ep)].bufpq, bufp, next); 479 dev->endpoint[EP2I(ep)].bufpq_size++; 480 return 0; 481 } 482 483 static void bufp_free(USBRedirDevice *dev, struct buf_packet *bufp, 484 uint8_t ep) 485 { 486 QTAILQ_REMOVE(&dev->endpoint[EP2I(ep)].bufpq, bufp, next); 487 dev->endpoint[EP2I(ep)].bufpq_size--; 488 free(bufp->free_on_destroy); 489 g_free(bufp); 490 } 491 492 static void usbredir_free_bufpq(USBRedirDevice *dev, uint8_t ep) 493 { 494 struct buf_packet *buf, *buf_next; 495 496 QTAILQ_FOREACH_SAFE(buf, &dev->endpoint[EP2I(ep)].bufpq, next, buf_next) { 497 bufp_free(dev, buf, ep); 498 } 499 } 500 501 /* 502 * USBDevice callbacks 503 */ 504 505 static void usbredir_handle_reset(USBDevice *udev) 506 { 507 USBRedirDevice *dev = USB_REDIRECT(udev); 508 509 DPRINTF("reset device\n"); 510 usbredirparser_send_reset(dev->parser); 511 usbredirparser_do_write(dev->parser); 512 } 513 514 static void usbredir_handle_iso_data(USBRedirDevice *dev, USBPacket *p, 515 uint8_t ep) 516 { 517 int status, len; 518 if (!dev->endpoint[EP2I(ep)].iso_started && 519 !dev->endpoint[EP2I(ep)].iso_error) { 520 struct usb_redir_start_iso_stream_header start_iso = { 521 .endpoint = ep, 522 }; 523 int pkts_per_sec; 524 525 if (dev->dev.speed == USB_SPEED_HIGH) { 526 pkts_per_sec = 8000 / dev->endpoint[EP2I(ep)].interval; 527 } else { 528 pkts_per_sec = 1000 / dev->endpoint[EP2I(ep)].interval; 529 } 530 /* Testing has shown that we need circa 60 ms buffer */ 531 dev->endpoint[EP2I(ep)].bufpq_target_size = (pkts_per_sec * 60) / 1000; 532 533 /* Aim for approx 100 interrupts / second on the client to 534 balance latency and interrupt load */ 535 start_iso.pkts_per_urb = pkts_per_sec / 100; 536 if (start_iso.pkts_per_urb < 1) { 537 start_iso.pkts_per_urb = 1; 538 } else if (start_iso.pkts_per_urb > 32) { 539 start_iso.pkts_per_urb = 32; 540 } 541 542 start_iso.no_urbs = DIV_ROUND_UP( 543 dev->endpoint[EP2I(ep)].bufpq_target_size, 544 start_iso.pkts_per_urb); 545 /* Output endpoints pre-fill only 1/2 of the packets, keeping the rest 546 as overflow buffer. Also see the usbredir protocol documentation */ 547 if (!(ep & USB_DIR_IN)) { 548 start_iso.no_urbs *= 2; 549 } 550 if (start_iso.no_urbs > 16) { 551 start_iso.no_urbs = 16; 552 } 553 554 /* No id, we look at the ep when receiving a status back */ 555 usbredirparser_send_start_iso_stream(dev->parser, 0, &start_iso); 556 usbredirparser_do_write(dev->parser); 557 DPRINTF("iso stream started pkts/sec %d pkts/urb %d urbs %d ep %02X\n", 558 pkts_per_sec, start_iso.pkts_per_urb, start_iso.no_urbs, ep); 559 dev->endpoint[EP2I(ep)].iso_started = 1; 560 dev->endpoint[EP2I(ep)].bufpq_prefilled = 0; 561 dev->endpoint[EP2I(ep)].bufpq_dropping_packets = 0; 562 } 563 564 if (ep & USB_DIR_IN) { 565 struct buf_packet *isop; 566 567 if (dev->endpoint[EP2I(ep)].iso_started && 568 !dev->endpoint[EP2I(ep)].bufpq_prefilled) { 569 if (dev->endpoint[EP2I(ep)].bufpq_size < 570 dev->endpoint[EP2I(ep)].bufpq_target_size) { 571 return; 572 } 573 dev->endpoint[EP2I(ep)].bufpq_prefilled = 1; 574 } 575 576 isop = QTAILQ_FIRST(&dev->endpoint[EP2I(ep)].bufpq); 577 if (isop == NULL) { 578 DPRINTF("iso-token-in ep %02X, no isop, iso_error: %d\n", 579 ep, dev->endpoint[EP2I(ep)].iso_error); 580 /* Re-fill the buffer */ 581 dev->endpoint[EP2I(ep)].bufpq_prefilled = 0; 582 /* Check iso_error for stream errors, otherwise its an underrun */ 583 status = dev->endpoint[EP2I(ep)].iso_error; 584 dev->endpoint[EP2I(ep)].iso_error = 0; 585 p->status = status ? USB_RET_IOERROR : USB_RET_SUCCESS; 586 return; 587 } 588 DPRINTF2("iso-token-in ep %02X status %d len %d queue-size: %d\n", ep, 589 isop->status, isop->len, dev->endpoint[EP2I(ep)].bufpq_size); 590 591 status = isop->status; 592 len = isop->len; 593 if (len > p->iov.size) { 594 ERROR("received iso data is larger then packet ep %02X (%d > %d)\n", 595 ep, len, (int)p->iov.size); 596 len = p->iov.size; 597 status = usb_redir_babble; 598 } 599 usb_packet_copy(p, isop->data, len); 600 bufp_free(dev, isop, ep); 601 usbredir_handle_status(dev, p, status); 602 } else { 603 /* If the stream was not started because of a pending error don't 604 send the packet to the usb-host */ 605 if (dev->endpoint[EP2I(ep)].iso_started) { 606 struct usb_redir_iso_packet_header iso_packet = { 607 .endpoint = ep, 608 .length = p->iov.size 609 }; 610 uint8_t buf[p->iov.size]; 611 /* No id, we look at the ep when receiving a status back */ 612 usb_packet_copy(p, buf, p->iov.size); 613 usbredirparser_send_iso_packet(dev->parser, 0, &iso_packet, 614 buf, p->iov.size); 615 usbredirparser_do_write(dev->parser); 616 } 617 status = dev->endpoint[EP2I(ep)].iso_error; 618 dev->endpoint[EP2I(ep)].iso_error = 0; 619 DPRINTF2("iso-token-out ep %02X status %d len %zd\n", ep, status, 620 p->iov.size); 621 usbredir_handle_status(dev, p, status); 622 } 623 } 624 625 static void usbredir_stop_iso_stream(USBRedirDevice *dev, uint8_t ep) 626 { 627 struct usb_redir_stop_iso_stream_header stop_iso_stream = { 628 .endpoint = ep 629 }; 630 if (dev->endpoint[EP2I(ep)].iso_started) { 631 usbredirparser_send_stop_iso_stream(dev->parser, 0, &stop_iso_stream); 632 DPRINTF("iso stream stopped ep %02X\n", ep); 633 dev->endpoint[EP2I(ep)].iso_started = 0; 634 } 635 dev->endpoint[EP2I(ep)].iso_error = 0; 636 usbredir_free_bufpq(dev, ep); 637 } 638 639 /* 640 * The usb-host may poll the endpoint faster then our guest, resulting in lots 641 * of smaller bulkp-s. The below buffered_bulk_in_complete* functions combine 642 * data from multiple bulkp-s into a single packet, avoiding bufpq overflows. 643 */ 644 static void usbredir_buffered_bulk_add_data_to_packet(USBRedirDevice *dev, 645 struct buf_packet *bulkp, int count, USBPacket *p, uint8_t ep) 646 { 647 usb_packet_copy(p, bulkp->data + bulkp->offset, count); 648 bulkp->offset += count; 649 if (bulkp->offset == bulkp->len) { 650 /* Store status in the last packet with data from this bulkp */ 651 usbredir_handle_status(dev, p, bulkp->status); 652 bufp_free(dev, bulkp, ep); 653 } 654 } 655 656 static void usbredir_buffered_bulk_in_complete_raw(USBRedirDevice *dev, 657 USBPacket *p, uint8_t ep) 658 { 659 struct buf_packet *bulkp; 660 int count; 661 662 while ((bulkp = QTAILQ_FIRST(&dev->endpoint[EP2I(ep)].bufpq)) && 663 p->actual_length < p->iov.size && p->status == USB_RET_SUCCESS) { 664 count = bulkp->len - bulkp->offset; 665 if (count > (p->iov.size - p->actual_length)) { 666 count = p->iov.size - p->actual_length; 667 } 668 usbredir_buffered_bulk_add_data_to_packet(dev, bulkp, count, p, ep); 669 } 670 } 671 672 static void usbredir_buffered_bulk_in_complete_ftdi(USBRedirDevice *dev, 673 USBPacket *p, uint8_t ep) 674 { 675 const int maxp = dev->endpoint[EP2I(ep)].max_packet_size; 676 uint8_t header[2] = { 0, 0 }; 677 struct buf_packet *bulkp; 678 int count; 679 680 while ((bulkp = QTAILQ_FIRST(&dev->endpoint[EP2I(ep)].bufpq)) && 681 p->actual_length < p->iov.size && p->status == USB_RET_SUCCESS) { 682 if (bulkp->len < 2) { 683 WARNING("malformed ftdi bulk in packet\n"); 684 bufp_free(dev, bulkp, ep); 685 continue; 686 } 687 688 if ((p->actual_length % maxp) == 0) { 689 usb_packet_copy(p, bulkp->data, 2); 690 memcpy(header, bulkp->data, 2); 691 } else { 692 if (bulkp->data[0] != header[0] || bulkp->data[1] != header[1]) { 693 break; /* Different header, add to next packet */ 694 } 695 } 696 697 if (bulkp->offset == 0) { 698 bulkp->offset = 2; /* Skip header */ 699 } 700 count = bulkp->len - bulkp->offset; 701 /* Must repeat the header at maxp interval */ 702 if (count > (maxp - (p->actual_length % maxp))) { 703 count = maxp - (p->actual_length % maxp); 704 } 705 usbredir_buffered_bulk_add_data_to_packet(dev, bulkp, count, p, ep); 706 } 707 } 708 709 static void usbredir_buffered_bulk_in_complete(USBRedirDevice *dev, 710 USBPacket *p, uint8_t ep) 711 { 712 p->status = USB_RET_SUCCESS; /* Clear previous ASYNC status */ 713 dev->buffered_bulk_in_complete(dev, p, ep); 714 DPRINTF("bulk-token-in ep %02X status %d len %d id %"PRIu64"\n", 715 ep, p->status, p->actual_length, p->id); 716 } 717 718 static void usbredir_handle_buffered_bulk_in_data(USBRedirDevice *dev, 719 USBPacket *p, uint8_t ep) 720 { 721 /* Input bulk endpoint, buffered packet input */ 722 if (!dev->endpoint[EP2I(ep)].bulk_receiving_started) { 723 int bpt; 724 struct usb_redir_start_bulk_receiving_header start = { 725 .endpoint = ep, 726 .stream_id = 0, 727 .no_transfers = 5, 728 }; 729 /* Round bytes_per_transfer up to a multiple of max_packet_size */ 730 bpt = 512 + dev->endpoint[EP2I(ep)].max_packet_size - 1; 731 bpt /= dev->endpoint[EP2I(ep)].max_packet_size; 732 bpt *= dev->endpoint[EP2I(ep)].max_packet_size; 733 start.bytes_per_transfer = bpt; 734 /* No id, we look at the ep when receiving a status back */ 735 usbredirparser_send_start_bulk_receiving(dev->parser, 0, &start); 736 usbredirparser_do_write(dev->parser); 737 DPRINTF("bulk receiving started bytes/transfer %u count %d ep %02X\n", 738 start.bytes_per_transfer, start.no_transfers, ep); 739 dev->endpoint[EP2I(ep)].bulk_receiving_started = 1; 740 /* We don't really want to drop bulk packets ever, but 741 having some upper limit to how much we buffer is good. */ 742 dev->endpoint[EP2I(ep)].bufpq_target_size = 5000; 743 dev->endpoint[EP2I(ep)].bufpq_dropping_packets = 0; 744 } 745 746 if (QTAILQ_EMPTY(&dev->endpoint[EP2I(ep)].bufpq)) { 747 DPRINTF("bulk-token-in ep %02X, no bulkp\n", ep); 748 assert(dev->endpoint[EP2I(ep)].pending_async_packet == NULL); 749 dev->endpoint[EP2I(ep)].pending_async_packet = p; 750 p->status = USB_RET_ASYNC; 751 return; 752 } 753 usbredir_buffered_bulk_in_complete(dev, p, ep); 754 } 755 756 static void usbredir_stop_bulk_receiving(USBRedirDevice *dev, uint8_t ep) 757 { 758 struct usb_redir_stop_bulk_receiving_header stop_bulk = { 759 .endpoint = ep, 760 .stream_id = 0, 761 }; 762 if (dev->endpoint[EP2I(ep)].bulk_receiving_started) { 763 usbredirparser_send_stop_bulk_receiving(dev->parser, 0, &stop_bulk); 764 DPRINTF("bulk receiving stopped ep %02X\n", ep); 765 dev->endpoint[EP2I(ep)].bulk_receiving_started = 0; 766 } 767 usbredir_free_bufpq(dev, ep); 768 } 769 770 static void usbredir_handle_bulk_data(USBRedirDevice *dev, USBPacket *p, 771 uint8_t ep) 772 { 773 struct usb_redir_bulk_packet_header bulk_packet; 774 size_t size = usb_packet_size(p); 775 const int maxp = dev->endpoint[EP2I(ep)].max_packet_size; 776 777 if (usbredir_already_in_flight(dev, p->id)) { 778 p->status = USB_RET_ASYNC; 779 return; 780 } 781 782 if (dev->endpoint[EP2I(ep)].bulk_receiving_enabled) { 783 if (size != 0 && (size % maxp) == 0) { 784 usbredir_handle_buffered_bulk_in_data(dev, p, ep); 785 return; 786 } 787 WARNING("bulk recv invalid size %zd ep %02x, disabling\n", size, ep); 788 assert(dev->endpoint[EP2I(ep)].pending_async_packet == NULL); 789 usbredir_stop_bulk_receiving(dev, ep); 790 dev->endpoint[EP2I(ep)].bulk_receiving_enabled = 0; 791 } 792 793 DPRINTF("bulk-out ep %02X stream %u len %zd id %"PRIu64"\n", 794 ep, p->stream, size, p->id); 795 796 bulk_packet.endpoint = ep; 797 bulk_packet.length = size; 798 bulk_packet.stream_id = p->stream; 799 bulk_packet.length_high = size >> 16; 800 assert(bulk_packet.length_high == 0 || 801 usbredirparser_peer_has_cap(dev->parser, 802 usb_redir_cap_32bits_bulk_length)); 803 804 if (ep & USB_DIR_IN || size == 0) { 805 usbredirparser_send_bulk_packet(dev->parser, p->id, 806 &bulk_packet, NULL, 0); 807 } else { 808 uint8_t buf[size]; 809 usb_packet_copy(p, buf, size); 810 usbredir_log_data(dev, "bulk data out:", buf, size); 811 usbredirparser_send_bulk_packet(dev->parser, p->id, 812 &bulk_packet, buf, size); 813 } 814 usbredirparser_do_write(dev->parser); 815 p->status = USB_RET_ASYNC; 816 } 817 818 static void usbredir_handle_interrupt_in_data(USBRedirDevice *dev, 819 USBPacket *p, uint8_t ep) 820 { 821 /* Input interrupt endpoint, buffered packet input */ 822 struct buf_packet *intp, *intp_to_free; 823 int status, len, sum; 824 825 if (!dev->endpoint[EP2I(ep)].interrupt_started && 826 !dev->endpoint[EP2I(ep)].interrupt_error) { 827 struct usb_redir_start_interrupt_receiving_header start_int = { 828 .endpoint = ep, 829 }; 830 /* No id, we look at the ep when receiving a status back */ 831 usbredirparser_send_start_interrupt_receiving(dev->parser, 0, 832 &start_int); 833 usbredirparser_do_write(dev->parser); 834 DPRINTF("interrupt recv started ep %02X\n", ep); 835 dev->endpoint[EP2I(ep)].interrupt_started = 1; 836 /* We don't really want to drop interrupt packets ever, but 837 having some upper limit to how much we buffer is good. */ 838 dev->endpoint[EP2I(ep)].bufpq_target_size = 1000; 839 dev->endpoint[EP2I(ep)].bufpq_dropping_packets = 0; 840 } 841 842 /* check for completed interrupt message (with all fragments) */ 843 sum = 0; 844 QTAILQ_FOREACH(intp, &dev->endpoint[EP2I(ep)].bufpq, next) { 845 sum += intp->len; 846 if (intp->len < dev->endpoint[EP2I(ep)].max_packet_size || 847 sum >= p->iov.size) 848 break; 849 } 850 851 if (intp == NULL) { 852 DPRINTF2("interrupt-token-in ep %02X, no intp, buffered %d\n", ep, sum); 853 /* Check interrupt_error for stream errors */ 854 status = dev->endpoint[EP2I(ep)].interrupt_error; 855 dev->endpoint[EP2I(ep)].interrupt_error = 0; 856 if (status) { 857 usbredir_handle_status(dev, p, status); 858 } else { 859 p->status = USB_RET_NAK; 860 } 861 return; 862 } 863 864 /* copy of completed interrupt message */ 865 sum = 0; 866 status = usb_redir_success; 867 intp_to_free = NULL; 868 QTAILQ_FOREACH(intp, &dev->endpoint[EP2I(ep)].bufpq, next) { 869 if (intp_to_free) { 870 bufp_free(dev, intp_to_free, ep); 871 } 872 DPRINTF("interrupt-token-in ep %02X fragment status %d len %d\n", ep, 873 intp->status, intp->len); 874 875 sum += intp->len; 876 len = intp->len; 877 if (status == usb_redir_success) { 878 status = intp->status; 879 } 880 if (sum > p->iov.size) { 881 ERROR("received int data is larger then packet ep %02X\n", ep); 882 len -= (sum - p->iov.size); 883 sum = p->iov.size; 884 status = usb_redir_babble; 885 } 886 887 usb_packet_copy(p, intp->data, len); 888 889 intp_to_free = intp; 890 if (intp->len < dev->endpoint[EP2I(ep)].max_packet_size || 891 sum >= p->iov.size) 892 break; 893 } 894 if (intp_to_free) { 895 bufp_free(dev, intp_to_free, ep); 896 } 897 DPRINTF("interrupt-token-in ep %02X summary status %d len %d\n", ep, 898 status, sum); 899 usbredir_handle_status(dev, p, status); 900 } 901 902 /* 903 * Handle interrupt out data, the usbredir protocol expects us to do this 904 * async, so that it can report back a completion status. But guests will 905 * expect immediate completion for an interrupt endpoint, and handling this 906 * async causes migration issues. So we report success directly, counting 907 * on the fact that output interrupt packets normally always succeed. 908 */ 909 static void usbredir_handle_interrupt_out_data(USBRedirDevice *dev, 910 USBPacket *p, uint8_t ep) 911 { 912 struct usb_redir_interrupt_packet_header interrupt_packet; 913 uint8_t buf[p->iov.size]; 914 915 DPRINTF("interrupt-out ep %02X len %zd id %"PRIu64"\n", ep, 916 p->iov.size, p->id); 917 918 interrupt_packet.endpoint = ep; 919 interrupt_packet.length = p->iov.size; 920 921 usb_packet_copy(p, buf, p->iov.size); 922 usbredir_log_data(dev, "interrupt data out:", buf, p->iov.size); 923 usbredirparser_send_interrupt_packet(dev->parser, p->id, 924 &interrupt_packet, buf, p->iov.size); 925 usbredirparser_do_write(dev->parser); 926 } 927 928 static void usbredir_stop_interrupt_receiving(USBRedirDevice *dev, 929 uint8_t ep) 930 { 931 struct usb_redir_stop_interrupt_receiving_header stop_interrupt_recv = { 932 .endpoint = ep 933 }; 934 if (dev->endpoint[EP2I(ep)].interrupt_started) { 935 usbredirparser_send_stop_interrupt_receiving(dev->parser, 0, 936 &stop_interrupt_recv); 937 DPRINTF("interrupt recv stopped ep %02X\n", ep); 938 dev->endpoint[EP2I(ep)].interrupt_started = 0; 939 } 940 dev->endpoint[EP2I(ep)].interrupt_error = 0; 941 usbredir_free_bufpq(dev, ep); 942 } 943 944 static void usbredir_handle_data(USBDevice *udev, USBPacket *p) 945 { 946 USBRedirDevice *dev = USB_REDIRECT(udev); 947 uint8_t ep; 948 949 ep = p->ep->nr; 950 if (p->pid == USB_TOKEN_IN) { 951 ep |= USB_DIR_IN; 952 } 953 954 switch (dev->endpoint[EP2I(ep)].type) { 955 case USB_ENDPOINT_XFER_CONTROL: 956 ERROR("handle_data called for control transfer on ep %02X\n", ep); 957 p->status = USB_RET_NAK; 958 break; 959 case USB_ENDPOINT_XFER_BULK: 960 if (p->state == USB_PACKET_SETUP && p->pid == USB_TOKEN_IN && 961 p->ep->pipeline) { 962 p->status = USB_RET_ADD_TO_QUEUE; 963 break; 964 } 965 usbredir_handle_bulk_data(dev, p, ep); 966 break; 967 case USB_ENDPOINT_XFER_ISOC: 968 usbredir_handle_iso_data(dev, p, ep); 969 break; 970 case USB_ENDPOINT_XFER_INT: 971 if (ep & USB_DIR_IN) { 972 usbredir_handle_interrupt_in_data(dev, p, ep); 973 } else { 974 usbredir_handle_interrupt_out_data(dev, p, ep); 975 } 976 break; 977 default: 978 ERROR("handle_data ep %02X has unknown type %d\n", ep, 979 dev->endpoint[EP2I(ep)].type); 980 p->status = USB_RET_NAK; 981 } 982 } 983 984 static void usbredir_flush_ep_queue(USBDevice *dev, USBEndpoint *ep) 985 { 986 if (ep->pid == USB_TOKEN_IN && ep->pipeline) { 987 usb_ep_combine_input_packets(ep); 988 } 989 } 990 991 static void usbredir_stop_ep(USBRedirDevice *dev, int i) 992 { 993 uint8_t ep = I2EP(i); 994 995 switch (dev->endpoint[i].type) { 996 case USB_ENDPOINT_XFER_BULK: 997 if (ep & USB_DIR_IN) { 998 usbredir_stop_bulk_receiving(dev, ep); 999 } 1000 break; 1001 case USB_ENDPOINT_XFER_ISOC: 1002 usbredir_stop_iso_stream(dev, ep); 1003 break; 1004 case USB_ENDPOINT_XFER_INT: 1005 if (ep & USB_DIR_IN) { 1006 usbredir_stop_interrupt_receiving(dev, ep); 1007 } 1008 break; 1009 } 1010 usbredir_free_bufpq(dev, ep); 1011 } 1012 1013 static void usbredir_ep_stopped(USBDevice *udev, USBEndpoint *uep) 1014 { 1015 USBRedirDevice *dev = USB_REDIRECT(udev); 1016 1017 usbredir_stop_ep(dev, USBEP2I(uep)); 1018 usbredirparser_do_write(dev->parser); 1019 } 1020 1021 static void usbredir_set_config(USBRedirDevice *dev, USBPacket *p, 1022 int config) 1023 { 1024 struct usb_redir_set_configuration_header set_config; 1025 int i; 1026 1027 DPRINTF("set config %d id %"PRIu64"\n", config, p->id); 1028 1029 for (i = 0; i < MAX_ENDPOINTS; i++) { 1030 usbredir_stop_ep(dev, i); 1031 } 1032 1033 set_config.configuration = config; 1034 usbredirparser_send_set_configuration(dev->parser, p->id, &set_config); 1035 usbredirparser_do_write(dev->parser); 1036 p->status = USB_RET_ASYNC; 1037 } 1038 1039 static void usbredir_get_config(USBRedirDevice *dev, USBPacket *p) 1040 { 1041 DPRINTF("get config id %"PRIu64"\n", p->id); 1042 1043 usbredirparser_send_get_configuration(dev->parser, p->id); 1044 usbredirparser_do_write(dev->parser); 1045 p->status = USB_RET_ASYNC; 1046 } 1047 1048 static void usbredir_set_interface(USBRedirDevice *dev, USBPacket *p, 1049 int interface, int alt) 1050 { 1051 struct usb_redir_set_alt_setting_header set_alt; 1052 int i; 1053 1054 DPRINTF("set interface %d alt %d id %"PRIu64"\n", interface, alt, p->id); 1055 1056 for (i = 0; i < MAX_ENDPOINTS; i++) { 1057 if (dev->endpoint[i].interface == interface) { 1058 usbredir_stop_ep(dev, i); 1059 } 1060 } 1061 1062 set_alt.interface = interface; 1063 set_alt.alt = alt; 1064 usbredirparser_send_set_alt_setting(dev->parser, p->id, &set_alt); 1065 usbredirparser_do_write(dev->parser); 1066 p->status = USB_RET_ASYNC; 1067 } 1068 1069 static void usbredir_get_interface(USBRedirDevice *dev, USBPacket *p, 1070 int interface) 1071 { 1072 struct usb_redir_get_alt_setting_header get_alt; 1073 1074 DPRINTF("get interface %d id %"PRIu64"\n", interface, p->id); 1075 1076 get_alt.interface = interface; 1077 usbredirparser_send_get_alt_setting(dev->parser, p->id, &get_alt); 1078 usbredirparser_do_write(dev->parser); 1079 p->status = USB_RET_ASYNC; 1080 } 1081 1082 static void usbredir_handle_control(USBDevice *udev, USBPacket *p, 1083 int request, int value, int index, int length, uint8_t *data) 1084 { 1085 USBRedirDevice *dev = USB_REDIRECT(udev); 1086 struct usb_redir_control_packet_header control_packet; 1087 1088 if (usbredir_already_in_flight(dev, p->id)) { 1089 p->status = USB_RET_ASYNC; 1090 return; 1091 } 1092 1093 /* Special cases for certain standard device requests */ 1094 switch (request) { 1095 case DeviceOutRequest | USB_REQ_SET_ADDRESS: 1096 DPRINTF("set address %d\n", value); 1097 dev->dev.addr = value; 1098 return; 1099 case DeviceOutRequest | USB_REQ_SET_CONFIGURATION: 1100 usbredir_set_config(dev, p, value & 0xff); 1101 return; 1102 case DeviceRequest | USB_REQ_GET_CONFIGURATION: 1103 usbredir_get_config(dev, p); 1104 return; 1105 case InterfaceOutRequest | USB_REQ_SET_INTERFACE: 1106 usbredir_set_interface(dev, p, index, value); 1107 return; 1108 case InterfaceRequest | USB_REQ_GET_INTERFACE: 1109 usbredir_get_interface(dev, p, index); 1110 return; 1111 } 1112 1113 /* Normal ctrl requests, note request is (bRequestType << 8) | bRequest */ 1114 DPRINTF( 1115 "ctrl-out type 0x%x req 0x%x val 0x%x index %d len %d id %"PRIu64"\n", 1116 request >> 8, request & 0xff, value, index, length, p->id); 1117 1118 control_packet.request = request & 0xFF; 1119 control_packet.requesttype = request >> 8; 1120 control_packet.endpoint = control_packet.requesttype & USB_DIR_IN; 1121 control_packet.value = value; 1122 control_packet.index = index; 1123 control_packet.length = length; 1124 1125 if (control_packet.requesttype & USB_DIR_IN) { 1126 usbredirparser_send_control_packet(dev->parser, p->id, 1127 &control_packet, NULL, 0); 1128 } else { 1129 usbredir_log_data(dev, "ctrl data out:", data, length); 1130 usbredirparser_send_control_packet(dev->parser, p->id, 1131 &control_packet, data, length); 1132 } 1133 usbredirparser_do_write(dev->parser); 1134 p->status = USB_RET_ASYNC; 1135 } 1136 1137 static int usbredir_alloc_streams(USBDevice *udev, USBEndpoint **eps, 1138 int nr_eps, int streams) 1139 { 1140 USBRedirDevice *dev = USB_REDIRECT(udev); 1141 #if USBREDIR_VERSION >= 0x000700 1142 struct usb_redir_alloc_bulk_streams_header alloc_streams; 1143 int i; 1144 1145 if (!usbredirparser_peer_has_cap(dev->parser, 1146 usb_redir_cap_bulk_streams)) { 1147 ERROR("peer does not support streams\n"); 1148 goto reject; 1149 } 1150 1151 if (streams == 0) { 1152 ERROR("request to allocate 0 streams\n"); 1153 return -1; 1154 } 1155 1156 alloc_streams.no_streams = streams; 1157 alloc_streams.endpoints = 0; 1158 for (i = 0; i < nr_eps; i++) { 1159 alloc_streams.endpoints |= 1 << USBEP2I(eps[i]); 1160 } 1161 usbredirparser_send_alloc_bulk_streams(dev->parser, 0, &alloc_streams); 1162 usbredirparser_do_write(dev->parser); 1163 1164 return 0; 1165 #else 1166 ERROR("usbredir_alloc_streams not implemented\n"); 1167 goto reject; 1168 #endif 1169 reject: 1170 ERROR("streams are not available, disconnecting\n"); 1171 qemu_bh_schedule(dev->device_reject_bh); 1172 return -1; 1173 } 1174 1175 static void usbredir_free_streams(USBDevice *udev, USBEndpoint **eps, 1176 int nr_eps) 1177 { 1178 #if USBREDIR_VERSION >= 0x000700 1179 USBRedirDevice *dev = USB_REDIRECT(udev); 1180 struct usb_redir_free_bulk_streams_header free_streams; 1181 int i; 1182 1183 if (!usbredirparser_peer_has_cap(dev->parser, 1184 usb_redir_cap_bulk_streams)) { 1185 return; 1186 } 1187 1188 free_streams.endpoints = 0; 1189 for (i = 0; i < nr_eps; i++) { 1190 free_streams.endpoints |= 1 << USBEP2I(eps[i]); 1191 } 1192 usbredirparser_send_free_bulk_streams(dev->parser, 0, &free_streams); 1193 usbredirparser_do_write(dev->parser); 1194 #endif 1195 } 1196 1197 /* 1198 * Close events can be triggered by usbredirparser_do_write which gets called 1199 * from within the USBDevice data / control packet callbacks and doing a 1200 * usb_detach from within these callbacks is not a good idea. 1201 * 1202 * So we use a bh handler to take care of close events. 1203 */ 1204 static void usbredir_chardev_close_bh(void *opaque) 1205 { 1206 USBRedirDevice *dev = opaque; 1207 1208 qemu_bh_cancel(dev->device_reject_bh); 1209 usbredir_device_disconnect(dev); 1210 1211 if (dev->parser) { 1212 DPRINTF("destroying usbredirparser\n"); 1213 usbredirparser_destroy(dev->parser); 1214 dev->parser = NULL; 1215 } 1216 if (dev->watch) { 1217 g_source_remove(dev->watch); 1218 dev->watch = 0; 1219 } 1220 } 1221 1222 static void usbredir_create_parser(USBRedirDevice *dev) 1223 { 1224 uint32_t caps[USB_REDIR_CAPS_SIZE] = { 0, }; 1225 int flags = 0; 1226 1227 DPRINTF("creating usbredirparser\n"); 1228 1229 dev->parser = qemu_oom_check(usbredirparser_create()); 1230 dev->parser->priv = dev; 1231 dev->parser->log_func = usbredir_log; 1232 dev->parser->read_func = usbredir_read; 1233 dev->parser->write_func = usbredir_write; 1234 dev->parser->hello_func = usbredir_hello; 1235 dev->parser->device_connect_func = usbredir_device_connect; 1236 dev->parser->device_disconnect_func = usbredir_device_disconnect; 1237 dev->parser->interface_info_func = usbredir_interface_info; 1238 dev->parser->ep_info_func = usbredir_ep_info; 1239 dev->parser->configuration_status_func = usbredir_configuration_status; 1240 dev->parser->alt_setting_status_func = usbredir_alt_setting_status; 1241 dev->parser->iso_stream_status_func = usbredir_iso_stream_status; 1242 dev->parser->interrupt_receiving_status_func = 1243 usbredir_interrupt_receiving_status; 1244 dev->parser->bulk_streams_status_func = usbredir_bulk_streams_status; 1245 dev->parser->bulk_receiving_status_func = usbredir_bulk_receiving_status; 1246 dev->parser->control_packet_func = usbredir_control_packet; 1247 dev->parser->bulk_packet_func = usbredir_bulk_packet; 1248 dev->parser->iso_packet_func = usbredir_iso_packet; 1249 dev->parser->interrupt_packet_func = usbredir_interrupt_packet; 1250 dev->parser->buffered_bulk_packet_func = usbredir_buffered_bulk_packet; 1251 dev->read_buf = NULL; 1252 dev->read_buf_size = 0; 1253 1254 usbredirparser_caps_set_cap(caps, usb_redir_cap_connect_device_version); 1255 usbredirparser_caps_set_cap(caps, usb_redir_cap_filter); 1256 usbredirparser_caps_set_cap(caps, usb_redir_cap_ep_info_max_packet_size); 1257 usbredirparser_caps_set_cap(caps, usb_redir_cap_64bits_ids); 1258 usbredirparser_caps_set_cap(caps, usb_redir_cap_32bits_bulk_length); 1259 usbredirparser_caps_set_cap(caps, usb_redir_cap_bulk_receiving); 1260 #if USBREDIR_VERSION >= 0x000700 1261 if (dev->enable_streams) { 1262 usbredirparser_caps_set_cap(caps, usb_redir_cap_bulk_streams); 1263 } 1264 #endif 1265 1266 if (runstate_check(RUN_STATE_INMIGRATE)) { 1267 flags |= usbredirparser_fl_no_hello; 1268 } 1269 usbredirparser_init(dev->parser, VERSION, caps, USB_REDIR_CAPS_SIZE, 1270 flags); 1271 usbredirparser_do_write(dev->parser); 1272 } 1273 1274 static void usbredir_reject_device(USBRedirDevice *dev) 1275 { 1276 usbredir_device_disconnect(dev); 1277 if (usbredirparser_peer_has_cap(dev->parser, usb_redir_cap_filter)) { 1278 usbredirparser_send_filter_reject(dev->parser); 1279 usbredirparser_do_write(dev->parser); 1280 } 1281 } 1282 1283 /* 1284 * We may need to reject the device when the hcd calls alloc_streams, doing 1285 * an usb_detach from within a hcd call is not a good idea, hence this bh. 1286 */ 1287 static void usbredir_device_reject_bh(void *opaque) 1288 { 1289 USBRedirDevice *dev = opaque; 1290 1291 usbredir_reject_device(dev); 1292 } 1293 1294 static void usbredir_do_attach(void *opaque) 1295 { 1296 USBRedirDevice *dev = opaque; 1297 Error *local_err = NULL; 1298 1299 /* In order to work properly with XHCI controllers we need these caps */ 1300 if ((dev->dev.port->speedmask & USB_SPEED_MASK_SUPER) && !( 1301 usbredirparser_peer_has_cap(dev->parser, 1302 usb_redir_cap_ep_info_max_packet_size) && 1303 usbredirparser_peer_has_cap(dev->parser, 1304 usb_redir_cap_32bits_bulk_length) && 1305 usbredirparser_peer_has_cap(dev->parser, 1306 usb_redir_cap_64bits_ids))) { 1307 ERROR("usb-redir-host lacks capabilities needed for use with XHCI\n"); 1308 usbredir_reject_device(dev); 1309 return; 1310 } 1311 1312 usb_device_attach(&dev->dev, &local_err); 1313 if (local_err) { 1314 error_report_err(local_err); 1315 WARNING("rejecting device due to speed mismatch\n"); 1316 usbredir_reject_device(dev); 1317 } 1318 } 1319 1320 /* 1321 * chardev callbacks 1322 */ 1323 1324 static int usbredir_chardev_can_read(void *opaque) 1325 { 1326 USBRedirDevice *dev = opaque; 1327 1328 if (!dev->parser) { 1329 WARNING("chardev_can_read called on non open chardev!\n"); 1330 return 0; 1331 } 1332 1333 /* Don't read new data from the chardev until our state is fully synced */ 1334 if (!runstate_check(RUN_STATE_RUNNING)) { 1335 return 0; 1336 } 1337 1338 /* usbredir_parser_do_read will consume *all* data we give it */ 1339 return 1 * MiB; 1340 } 1341 1342 static void usbredir_chardev_read(void *opaque, const uint8_t *buf, int size) 1343 { 1344 USBRedirDevice *dev = opaque; 1345 1346 /* No recursion allowed! */ 1347 assert(dev->read_buf == NULL); 1348 1349 dev->read_buf = buf; 1350 dev->read_buf_size = size; 1351 1352 usbredirparser_do_read(dev->parser); 1353 /* Send any acks, etc. which may be queued now */ 1354 usbredirparser_do_write(dev->parser); 1355 } 1356 1357 static void usbredir_chardev_event(void *opaque, QEMUChrEvent event) 1358 { 1359 USBRedirDevice *dev = opaque; 1360 1361 switch (event) { 1362 case CHR_EVENT_OPENED: 1363 DPRINTF("chardev open\n"); 1364 /* Make sure any pending closes are handled (no-op if none pending) */ 1365 usbredir_chardev_close_bh(dev); 1366 qemu_bh_cancel(dev->chardev_close_bh); 1367 usbredir_create_parser(dev); 1368 break; 1369 case CHR_EVENT_CLOSED: 1370 DPRINTF("chardev close\n"); 1371 qemu_bh_schedule(dev->chardev_close_bh); 1372 break; 1373 case CHR_EVENT_BREAK: 1374 case CHR_EVENT_MUX_IN: 1375 case CHR_EVENT_MUX_OUT: 1376 /* Ignore */ 1377 break; 1378 } 1379 } 1380 1381 /* 1382 * init + destroy 1383 */ 1384 1385 static void usbredir_vm_state_change(void *priv, int running, RunState state) 1386 { 1387 USBRedirDevice *dev = priv; 1388 1389 if (state == RUN_STATE_RUNNING && dev->parser != NULL) { 1390 usbredirparser_do_write(dev->parser); /* Flush any pending writes */ 1391 } 1392 } 1393 1394 static void usbredir_init_endpoints(USBRedirDevice *dev) 1395 { 1396 int i; 1397 1398 usb_ep_init(&dev->dev); 1399 memset(dev->endpoint, 0, sizeof(dev->endpoint)); 1400 for (i = 0; i < MAX_ENDPOINTS; i++) { 1401 dev->endpoint[i].dev = dev; 1402 QTAILQ_INIT(&dev->endpoint[i].bufpq); 1403 } 1404 } 1405 1406 static void usbredir_realize(USBDevice *udev, Error **errp) 1407 { 1408 USBRedirDevice *dev = USB_REDIRECT(udev); 1409 int i; 1410 1411 if (!qemu_chr_fe_backend_connected(&dev->cs)) { 1412 error_setg(errp, QERR_MISSING_PARAMETER, "chardev"); 1413 return; 1414 } 1415 1416 if (dev->filter_str) { 1417 i = usbredirfilter_string_to_rules(dev->filter_str, ":", "|", 1418 &dev->filter_rules, 1419 &dev->filter_rules_count); 1420 if (i) { 1421 error_setg(errp, QERR_INVALID_PARAMETER_VALUE, "filter", 1422 "a usb device filter string"); 1423 return; 1424 } 1425 } 1426 1427 dev->chardev_close_bh = qemu_bh_new(usbredir_chardev_close_bh, dev); 1428 dev->device_reject_bh = qemu_bh_new(usbredir_device_reject_bh, dev); 1429 dev->attach_timer = timer_new_ms(QEMU_CLOCK_VIRTUAL, usbredir_do_attach, dev); 1430 1431 packet_id_queue_init(&dev->cancelled, dev, "cancelled"); 1432 packet_id_queue_init(&dev->already_in_flight, dev, "already-in-flight"); 1433 usbredir_init_endpoints(dev); 1434 1435 /* We'll do the attach once we receive the speed from the usb-host */ 1436 udev->auto_attach = 0; 1437 1438 /* Will be cleared during setup when we find conflicts */ 1439 dev->compatible_speedmask = USB_SPEED_MASK_FULL | USB_SPEED_MASK_HIGH; 1440 1441 /* Let the backend know we are ready */ 1442 qemu_chr_fe_set_handlers(&dev->cs, usbredir_chardev_can_read, 1443 usbredir_chardev_read, usbredir_chardev_event, 1444 NULL, dev, NULL, true); 1445 1446 dev->vmstate = 1447 qemu_add_vm_change_state_handler(usbredir_vm_state_change, dev); 1448 } 1449 1450 static void usbredir_cleanup_device_queues(USBRedirDevice *dev) 1451 { 1452 int i; 1453 1454 packet_id_queue_empty(&dev->cancelled); 1455 packet_id_queue_empty(&dev->already_in_flight); 1456 for (i = 0; i < MAX_ENDPOINTS; i++) { 1457 usbredir_free_bufpq(dev, I2EP(i)); 1458 } 1459 } 1460 1461 static void usbredir_unrealize(USBDevice *udev, Error **errp) 1462 { 1463 USBRedirDevice *dev = USB_REDIRECT(udev); 1464 1465 qemu_chr_fe_deinit(&dev->cs, true); 1466 1467 /* Note must be done after qemu_chr_close, as that causes a close event */ 1468 qemu_bh_delete(dev->chardev_close_bh); 1469 qemu_bh_delete(dev->device_reject_bh); 1470 1471 timer_del(dev->attach_timer); 1472 timer_free(dev->attach_timer); 1473 1474 usbredir_cleanup_device_queues(dev); 1475 1476 if (dev->parser) { 1477 usbredirparser_destroy(dev->parser); 1478 } 1479 if (dev->watch) { 1480 g_source_remove(dev->watch); 1481 } 1482 1483 free(dev->filter_rules); 1484 qemu_del_vm_change_state_handler(dev->vmstate); 1485 } 1486 1487 static int usbredir_check_filter(USBRedirDevice *dev) 1488 { 1489 if (dev->interface_info.interface_count == NO_INTERFACE_INFO) { 1490 ERROR("No interface info for device\n"); 1491 goto error; 1492 } 1493 1494 if (dev->filter_rules) { 1495 if (!usbredirparser_peer_has_cap(dev->parser, 1496 usb_redir_cap_connect_device_version)) { 1497 ERROR("Device filter specified and peer does not have the " 1498 "connect_device_version capability\n"); 1499 goto error; 1500 } 1501 1502 if (usbredirfilter_check( 1503 dev->filter_rules, 1504 dev->filter_rules_count, 1505 dev->device_info.device_class, 1506 dev->device_info.device_subclass, 1507 dev->device_info.device_protocol, 1508 dev->interface_info.interface_class, 1509 dev->interface_info.interface_subclass, 1510 dev->interface_info.interface_protocol, 1511 dev->interface_info.interface_count, 1512 dev->device_info.vendor_id, 1513 dev->device_info.product_id, 1514 dev->device_info.device_version_bcd, 1515 0) != 0) { 1516 goto error; 1517 } 1518 } 1519 1520 return 0; 1521 1522 error: 1523 usbredir_reject_device(dev); 1524 return -1; 1525 } 1526 1527 static void usbredir_check_bulk_receiving(USBRedirDevice *dev) 1528 { 1529 int i, j, quirks; 1530 1531 if (!usbredirparser_peer_has_cap(dev->parser, 1532 usb_redir_cap_bulk_receiving)) { 1533 return; 1534 } 1535 1536 for (i = EP2I(USB_DIR_IN); i < MAX_ENDPOINTS; i++) { 1537 dev->endpoint[i].bulk_receiving_enabled = 0; 1538 } 1539 1540 if (dev->interface_info.interface_count == NO_INTERFACE_INFO) { 1541 return; 1542 } 1543 1544 for (i = 0; i < dev->interface_info.interface_count; i++) { 1545 quirks = usb_get_quirks(dev->device_info.vendor_id, 1546 dev->device_info.product_id, 1547 dev->interface_info.interface_class[i], 1548 dev->interface_info.interface_subclass[i], 1549 dev->interface_info.interface_protocol[i]); 1550 if (!(quirks & USB_QUIRK_BUFFER_BULK_IN)) { 1551 continue; 1552 } 1553 if (quirks & USB_QUIRK_IS_FTDI) { 1554 dev->buffered_bulk_in_complete = 1555 usbredir_buffered_bulk_in_complete_ftdi; 1556 } else { 1557 dev->buffered_bulk_in_complete = 1558 usbredir_buffered_bulk_in_complete_raw; 1559 } 1560 1561 for (j = EP2I(USB_DIR_IN); j < MAX_ENDPOINTS; j++) { 1562 if (dev->endpoint[j].interface == 1563 dev->interface_info.interface[i] && 1564 dev->endpoint[j].type == USB_ENDPOINT_XFER_BULK && 1565 dev->endpoint[j].max_packet_size != 0) { 1566 dev->endpoint[j].bulk_receiving_enabled = 1; 1567 /* 1568 * With buffering pipelining is not necessary. Also packet 1569 * combining and bulk in buffering don't play nice together! 1570 */ 1571 I2USBEP(dev, j)->pipeline = false; 1572 break; /* Only buffer for the first ep of each intf */ 1573 } 1574 } 1575 } 1576 } 1577 1578 /* 1579 * usbredirparser packet complete callbacks 1580 */ 1581 1582 static void usbredir_handle_status(USBRedirDevice *dev, USBPacket *p, 1583 int status) 1584 { 1585 switch (status) { 1586 case usb_redir_success: 1587 p->status = USB_RET_SUCCESS; /* Clear previous ASYNC status */ 1588 break; 1589 case usb_redir_stall: 1590 p->status = USB_RET_STALL; 1591 break; 1592 case usb_redir_cancelled: 1593 /* 1594 * When the usbredir-host unredirects a device, it will report a status 1595 * of cancelled for all pending packets, followed by a disconnect msg. 1596 */ 1597 p->status = USB_RET_IOERROR; 1598 break; 1599 case usb_redir_inval: 1600 WARNING("got invalid param error from usb-host?\n"); 1601 p->status = USB_RET_IOERROR; 1602 break; 1603 case usb_redir_babble: 1604 p->status = USB_RET_BABBLE; 1605 break; 1606 case usb_redir_ioerror: 1607 case usb_redir_timeout: 1608 default: 1609 p->status = USB_RET_IOERROR; 1610 } 1611 } 1612 1613 static void usbredir_hello(void *priv, struct usb_redir_hello_header *h) 1614 { 1615 USBRedirDevice *dev = priv; 1616 1617 /* Try to send the filter info now that we've the usb-host's caps */ 1618 if (usbredirparser_peer_has_cap(dev->parser, usb_redir_cap_filter) && 1619 dev->filter_rules) { 1620 usbredirparser_send_filter_filter(dev->parser, dev->filter_rules, 1621 dev->filter_rules_count); 1622 usbredirparser_do_write(dev->parser); 1623 } 1624 } 1625 1626 static void usbredir_device_connect(void *priv, 1627 struct usb_redir_device_connect_header *device_connect) 1628 { 1629 USBRedirDevice *dev = priv; 1630 const char *speed; 1631 1632 if (timer_pending(dev->attach_timer) || dev->dev.attached) { 1633 ERROR("Received device connect while already connected\n"); 1634 return; 1635 } 1636 1637 switch (device_connect->speed) { 1638 case usb_redir_speed_low: 1639 speed = "low speed"; 1640 dev->dev.speed = USB_SPEED_LOW; 1641 dev->compatible_speedmask &= ~USB_SPEED_MASK_FULL; 1642 dev->compatible_speedmask &= ~USB_SPEED_MASK_HIGH; 1643 break; 1644 case usb_redir_speed_full: 1645 speed = "full speed"; 1646 dev->dev.speed = USB_SPEED_FULL; 1647 dev->compatible_speedmask &= ~USB_SPEED_MASK_HIGH; 1648 break; 1649 case usb_redir_speed_high: 1650 speed = "high speed"; 1651 dev->dev.speed = USB_SPEED_HIGH; 1652 break; 1653 case usb_redir_speed_super: 1654 speed = "super speed"; 1655 dev->dev.speed = USB_SPEED_SUPER; 1656 break; 1657 default: 1658 speed = "unknown speed"; 1659 dev->dev.speed = USB_SPEED_FULL; 1660 } 1661 1662 if (usbredirparser_peer_has_cap(dev->parser, 1663 usb_redir_cap_connect_device_version)) { 1664 INFO("attaching %s device %04x:%04x version %d.%d class %02x\n", 1665 speed, device_connect->vendor_id, device_connect->product_id, 1666 ((device_connect->device_version_bcd & 0xf000) >> 12) * 10 + 1667 ((device_connect->device_version_bcd & 0x0f00) >> 8), 1668 ((device_connect->device_version_bcd & 0x00f0) >> 4) * 10 + 1669 ((device_connect->device_version_bcd & 0x000f) >> 0), 1670 device_connect->device_class); 1671 } else { 1672 INFO("attaching %s device %04x:%04x class %02x\n", speed, 1673 device_connect->vendor_id, device_connect->product_id, 1674 device_connect->device_class); 1675 } 1676 1677 dev->dev.speedmask = (1 << dev->dev.speed) | dev->compatible_speedmask; 1678 dev->device_info = *device_connect; 1679 1680 if (usbredir_check_filter(dev)) { 1681 WARNING("Device %04x:%04x rejected by device filter, not attaching\n", 1682 device_connect->vendor_id, device_connect->product_id); 1683 return; 1684 } 1685 1686 usbredir_check_bulk_receiving(dev); 1687 timer_mod(dev->attach_timer, dev->next_attach_time); 1688 } 1689 1690 static void usbredir_device_disconnect(void *priv) 1691 { 1692 USBRedirDevice *dev = priv; 1693 1694 /* Stop any pending attaches */ 1695 timer_del(dev->attach_timer); 1696 1697 if (dev->dev.attached) { 1698 DPRINTF("detaching device\n"); 1699 usb_device_detach(&dev->dev); 1700 /* 1701 * Delay next usb device attach to give the guest a chance to see 1702 * see the detach / attach in case of quick close / open succession 1703 */ 1704 dev->next_attach_time = qemu_clock_get_ms(QEMU_CLOCK_VIRTUAL) + 200; 1705 } 1706 1707 /* Reset state so that the next dev connected starts with a clean slate */ 1708 usbredir_cleanup_device_queues(dev); 1709 usbredir_init_endpoints(dev); 1710 dev->interface_info.interface_count = NO_INTERFACE_INFO; 1711 dev->dev.addr = 0; 1712 dev->dev.speed = 0; 1713 dev->compatible_speedmask = USB_SPEED_MASK_FULL | USB_SPEED_MASK_HIGH; 1714 } 1715 1716 static void usbredir_interface_info(void *priv, 1717 struct usb_redir_interface_info_header *interface_info) 1718 { 1719 USBRedirDevice *dev = priv; 1720 1721 dev->interface_info = *interface_info; 1722 1723 /* 1724 * If we receive interface info after the device has already been 1725 * connected (ie on a set_config), re-check interface dependent things. 1726 */ 1727 if (timer_pending(dev->attach_timer) || dev->dev.attached) { 1728 usbredir_check_bulk_receiving(dev); 1729 if (usbredir_check_filter(dev)) { 1730 ERROR("Device no longer matches filter after interface info " 1731 "change, disconnecting!\n"); 1732 } 1733 } 1734 } 1735 1736 static void usbredir_mark_speed_incompatible(USBRedirDevice *dev, int speed) 1737 { 1738 dev->compatible_speedmask &= ~(1 << speed); 1739 dev->dev.speedmask = (1 << dev->dev.speed) | dev->compatible_speedmask; 1740 } 1741 1742 static void usbredir_set_pipeline(USBRedirDevice *dev, struct USBEndpoint *uep) 1743 { 1744 if (uep->type != USB_ENDPOINT_XFER_BULK) { 1745 return; 1746 } 1747 if (uep->pid == USB_TOKEN_OUT) { 1748 uep->pipeline = true; 1749 } 1750 if (uep->pid == USB_TOKEN_IN && uep->max_packet_size != 0 && 1751 usbredirparser_peer_has_cap(dev->parser, 1752 usb_redir_cap_32bits_bulk_length)) { 1753 uep->pipeline = true; 1754 } 1755 } 1756 1757 static void usbredir_setup_usb_eps(USBRedirDevice *dev) 1758 { 1759 struct USBEndpoint *usb_ep; 1760 int i; 1761 1762 for (i = 0; i < MAX_ENDPOINTS; i++) { 1763 usb_ep = I2USBEP(dev, i); 1764 usb_ep->type = dev->endpoint[i].type; 1765 usb_ep->ifnum = dev->endpoint[i].interface; 1766 usb_ep->max_packet_size = dev->endpoint[i].max_packet_size; 1767 usb_ep->max_streams = dev->endpoint[i].max_streams; 1768 usbredir_set_pipeline(dev, usb_ep); 1769 } 1770 } 1771 1772 static void usbredir_ep_info(void *priv, 1773 struct usb_redir_ep_info_header *ep_info) 1774 { 1775 USBRedirDevice *dev = priv; 1776 int i; 1777 1778 assert(dev != NULL); 1779 for (i = 0; i < MAX_ENDPOINTS; i++) { 1780 dev->endpoint[i].type = ep_info->type[i]; 1781 dev->endpoint[i].interval = ep_info->interval[i]; 1782 dev->endpoint[i].interface = ep_info->interface[i]; 1783 if (usbredirparser_peer_has_cap(dev->parser, 1784 usb_redir_cap_ep_info_max_packet_size)) { 1785 dev->endpoint[i].max_packet_size = ep_info->max_packet_size[i]; 1786 } 1787 #if USBREDIR_VERSION >= 0x000700 1788 if (usbredirparser_peer_has_cap(dev->parser, 1789 usb_redir_cap_bulk_streams)) { 1790 dev->endpoint[i].max_streams = ep_info->max_streams[i]; 1791 } 1792 #endif 1793 switch (dev->endpoint[i].type) { 1794 case usb_redir_type_invalid: 1795 break; 1796 case usb_redir_type_iso: 1797 usbredir_mark_speed_incompatible(dev, USB_SPEED_FULL); 1798 usbredir_mark_speed_incompatible(dev, USB_SPEED_HIGH); 1799 /* Fall through */ 1800 case usb_redir_type_interrupt: 1801 if (!usbredirparser_peer_has_cap(dev->parser, 1802 usb_redir_cap_ep_info_max_packet_size) || 1803 ep_info->max_packet_size[i] > 64) { 1804 usbredir_mark_speed_incompatible(dev, USB_SPEED_FULL); 1805 } 1806 if (!usbredirparser_peer_has_cap(dev->parser, 1807 usb_redir_cap_ep_info_max_packet_size) || 1808 ep_info->max_packet_size[i] > 1024) { 1809 usbredir_mark_speed_incompatible(dev, USB_SPEED_HIGH); 1810 } 1811 if (dev->endpoint[i].interval == 0) { 1812 ERROR("Received 0 interval for isoc or irq endpoint\n"); 1813 usbredir_reject_device(dev); 1814 return; 1815 } 1816 /* Fall through */ 1817 case usb_redir_type_control: 1818 case usb_redir_type_bulk: 1819 DPRINTF("ep: %02X type: %d interface: %d\n", I2EP(i), 1820 dev->endpoint[i].type, dev->endpoint[i].interface); 1821 break; 1822 default: 1823 ERROR("Received invalid endpoint type\n"); 1824 usbredir_reject_device(dev); 1825 return; 1826 } 1827 } 1828 /* The new ep info may have caused a speed incompatibility, recheck */ 1829 if (dev->dev.attached && 1830 !(dev->dev.port->speedmask & dev->dev.speedmask)) { 1831 ERROR("Device no longer matches speed after endpoint info change, " 1832 "disconnecting!\n"); 1833 usbredir_reject_device(dev); 1834 return; 1835 } 1836 usbredir_setup_usb_eps(dev); 1837 usbredir_check_bulk_receiving(dev); 1838 } 1839 1840 static void usbredir_configuration_status(void *priv, uint64_t id, 1841 struct usb_redir_configuration_status_header *config_status) 1842 { 1843 USBRedirDevice *dev = priv; 1844 USBPacket *p; 1845 1846 DPRINTF("set config status %d config %d id %"PRIu64"\n", 1847 config_status->status, config_status->configuration, id); 1848 1849 p = usbredir_find_packet_by_id(dev, 0, id); 1850 if (p) { 1851 if (dev->dev.setup_buf[0] & USB_DIR_IN) { 1852 dev->dev.data_buf[0] = config_status->configuration; 1853 p->actual_length = 1; 1854 } 1855 usbredir_handle_status(dev, p, config_status->status); 1856 usb_generic_async_ctrl_complete(&dev->dev, p); 1857 } 1858 } 1859 1860 static void usbredir_alt_setting_status(void *priv, uint64_t id, 1861 struct usb_redir_alt_setting_status_header *alt_setting_status) 1862 { 1863 USBRedirDevice *dev = priv; 1864 USBPacket *p; 1865 1866 DPRINTF("alt status %d intf %d alt %d id: %"PRIu64"\n", 1867 alt_setting_status->status, alt_setting_status->interface, 1868 alt_setting_status->alt, id); 1869 1870 p = usbredir_find_packet_by_id(dev, 0, id); 1871 if (p) { 1872 if (dev->dev.setup_buf[0] & USB_DIR_IN) { 1873 dev->dev.data_buf[0] = alt_setting_status->alt; 1874 p->actual_length = 1; 1875 } 1876 usbredir_handle_status(dev, p, alt_setting_status->status); 1877 usb_generic_async_ctrl_complete(&dev->dev, p); 1878 } 1879 } 1880 1881 static void usbredir_iso_stream_status(void *priv, uint64_t id, 1882 struct usb_redir_iso_stream_status_header *iso_stream_status) 1883 { 1884 USBRedirDevice *dev = priv; 1885 uint8_t ep = iso_stream_status->endpoint; 1886 1887 DPRINTF("iso status %d ep %02X id %"PRIu64"\n", iso_stream_status->status, 1888 ep, id); 1889 1890 if (!dev->dev.attached || !dev->endpoint[EP2I(ep)].iso_started) { 1891 return; 1892 } 1893 1894 dev->endpoint[EP2I(ep)].iso_error = iso_stream_status->status; 1895 if (iso_stream_status->status == usb_redir_stall) { 1896 DPRINTF("iso stream stopped by peer ep %02X\n", ep); 1897 dev->endpoint[EP2I(ep)].iso_started = 0; 1898 } 1899 } 1900 1901 static void usbredir_interrupt_receiving_status(void *priv, uint64_t id, 1902 struct usb_redir_interrupt_receiving_status_header 1903 *interrupt_receiving_status) 1904 { 1905 USBRedirDevice *dev = priv; 1906 uint8_t ep = interrupt_receiving_status->endpoint; 1907 1908 DPRINTF("interrupt recv status %d ep %02X id %"PRIu64"\n", 1909 interrupt_receiving_status->status, ep, id); 1910 1911 if (!dev->dev.attached || !dev->endpoint[EP2I(ep)].interrupt_started) { 1912 return; 1913 } 1914 1915 dev->endpoint[EP2I(ep)].interrupt_error = 1916 interrupt_receiving_status->status; 1917 if (interrupt_receiving_status->status == usb_redir_stall) { 1918 DPRINTF("interrupt receiving stopped by peer ep %02X\n", ep); 1919 dev->endpoint[EP2I(ep)].interrupt_started = 0; 1920 } 1921 } 1922 1923 static void usbredir_bulk_streams_status(void *priv, uint64_t id, 1924 struct usb_redir_bulk_streams_status_header *bulk_streams_status) 1925 { 1926 #if USBREDIR_VERSION >= 0x000700 1927 USBRedirDevice *dev = priv; 1928 1929 if (bulk_streams_status->status == usb_redir_success) { 1930 DPRINTF("bulk streams status %d eps %08x\n", 1931 bulk_streams_status->status, bulk_streams_status->endpoints); 1932 } else { 1933 ERROR("bulk streams %s failed status %d eps %08x\n", 1934 (bulk_streams_status->no_streams == 0) ? "free" : "alloc", 1935 bulk_streams_status->status, bulk_streams_status->endpoints); 1936 ERROR("usb-redir-host does not provide streams, disconnecting\n"); 1937 usbredir_reject_device(dev); 1938 } 1939 #endif 1940 } 1941 1942 static void usbredir_bulk_receiving_status(void *priv, uint64_t id, 1943 struct usb_redir_bulk_receiving_status_header *bulk_receiving_status) 1944 { 1945 USBRedirDevice *dev = priv; 1946 uint8_t ep = bulk_receiving_status->endpoint; 1947 1948 DPRINTF("bulk recv status %d ep %02X id %"PRIu64"\n", 1949 bulk_receiving_status->status, ep, id); 1950 1951 if (!dev->dev.attached || !dev->endpoint[EP2I(ep)].bulk_receiving_started) { 1952 return; 1953 } 1954 1955 if (bulk_receiving_status->status == usb_redir_stall) { 1956 DPRINTF("bulk receiving stopped by peer ep %02X\n", ep); 1957 dev->endpoint[EP2I(ep)].bulk_receiving_started = 0; 1958 } 1959 } 1960 1961 static void usbredir_control_packet(void *priv, uint64_t id, 1962 struct usb_redir_control_packet_header *control_packet, 1963 uint8_t *data, int data_len) 1964 { 1965 USBRedirDevice *dev = priv; 1966 USBPacket *p; 1967 int len = control_packet->length; 1968 1969 DPRINTF("ctrl-in status %d len %d id %"PRIu64"\n", control_packet->status, 1970 len, id); 1971 1972 /* Fix up USB-3 ep0 maxpacket size to allow superspeed connected devices 1973 * to work redirected to a not superspeed capable hcd */ 1974 if (dev->dev.speed == USB_SPEED_SUPER && 1975 !((dev->dev.port->speedmask & USB_SPEED_MASK_SUPER)) && 1976 control_packet->requesttype == 0x80 && 1977 control_packet->request == 6 && 1978 control_packet->value == 0x100 && control_packet->index == 0 && 1979 data_len >= 18 && data[7] == 9) { 1980 data[7] = 64; 1981 } 1982 1983 p = usbredir_find_packet_by_id(dev, 0, id); 1984 if (p) { 1985 usbredir_handle_status(dev, p, control_packet->status); 1986 if (data_len > 0) { 1987 usbredir_log_data(dev, "ctrl data in:", data, data_len); 1988 if (data_len > sizeof(dev->dev.data_buf)) { 1989 ERROR("ctrl buffer too small (%d > %zu)\n", 1990 data_len, sizeof(dev->dev.data_buf)); 1991 p->status = USB_RET_STALL; 1992 data_len = len = sizeof(dev->dev.data_buf); 1993 } 1994 memcpy(dev->dev.data_buf, data, data_len); 1995 } 1996 p->actual_length = len; 1997 usb_generic_async_ctrl_complete(&dev->dev, p); 1998 } 1999 free(data); 2000 } 2001 2002 static void usbredir_bulk_packet(void *priv, uint64_t id, 2003 struct usb_redir_bulk_packet_header *bulk_packet, 2004 uint8_t *data, int data_len) 2005 { 2006 USBRedirDevice *dev = priv; 2007 uint8_t ep = bulk_packet->endpoint; 2008 int len = (bulk_packet->length_high << 16) | bulk_packet->length; 2009 USBPacket *p; 2010 2011 DPRINTF("bulk-in status %d ep %02X stream %u len %d id %"PRIu64"\n", 2012 bulk_packet->status, ep, bulk_packet->stream_id, len, id); 2013 2014 p = usbredir_find_packet_by_id(dev, ep, id); 2015 if (p) { 2016 size_t size = usb_packet_size(p); 2017 usbredir_handle_status(dev, p, bulk_packet->status); 2018 if (data_len > 0) { 2019 usbredir_log_data(dev, "bulk data in:", data, data_len); 2020 if (data_len > size) { 2021 ERROR("bulk got more data then requested (%d > %zd)\n", 2022 data_len, p->iov.size); 2023 p->status = USB_RET_BABBLE; 2024 data_len = len = size; 2025 } 2026 usb_packet_copy(p, data, data_len); 2027 } 2028 p->actual_length = len; 2029 if (p->pid == USB_TOKEN_IN && p->ep->pipeline) { 2030 usb_combined_input_packet_complete(&dev->dev, p); 2031 } else { 2032 usb_packet_complete(&dev->dev, p); 2033 } 2034 } 2035 free(data); 2036 } 2037 2038 static void usbredir_iso_packet(void *priv, uint64_t id, 2039 struct usb_redir_iso_packet_header *iso_packet, 2040 uint8_t *data, int data_len) 2041 { 2042 USBRedirDevice *dev = priv; 2043 uint8_t ep = iso_packet->endpoint; 2044 2045 DPRINTF2("iso-in status %d ep %02X len %d id %"PRIu64"\n", 2046 iso_packet->status, ep, data_len, id); 2047 2048 if (dev->endpoint[EP2I(ep)].type != USB_ENDPOINT_XFER_ISOC) { 2049 ERROR("received iso packet for non iso endpoint %02X\n", ep); 2050 free(data); 2051 return; 2052 } 2053 2054 if (dev->endpoint[EP2I(ep)].iso_started == 0) { 2055 DPRINTF("received iso packet for non started stream ep %02X\n", ep); 2056 free(data); 2057 return; 2058 } 2059 2060 /* bufp_alloc also adds the packet to the ep queue */ 2061 bufp_alloc(dev, data, data_len, iso_packet->status, ep, data); 2062 } 2063 2064 static void usbredir_interrupt_packet(void *priv, uint64_t id, 2065 struct usb_redir_interrupt_packet_header *interrupt_packet, 2066 uint8_t *data, int data_len) 2067 { 2068 USBRedirDevice *dev = priv; 2069 uint8_t ep = interrupt_packet->endpoint; 2070 2071 DPRINTF("interrupt-in status %d ep %02X len %d id %"PRIu64"\n", 2072 interrupt_packet->status, ep, data_len, id); 2073 2074 if (dev->endpoint[EP2I(ep)].type != USB_ENDPOINT_XFER_INT) { 2075 ERROR("received int packet for non interrupt endpoint %02X\n", ep); 2076 free(data); 2077 return; 2078 } 2079 2080 if (ep & USB_DIR_IN) { 2081 if (dev->endpoint[EP2I(ep)].interrupt_started == 0) { 2082 DPRINTF("received int packet while not started ep %02X\n", ep); 2083 free(data); 2084 return; 2085 } 2086 2087 /* bufp_alloc also adds the packet to the ep queue */ 2088 bufp_alloc(dev, data, data_len, interrupt_packet->status, ep, data); 2089 2090 /* insufficient data solved with USB_RET_NAK */ 2091 usb_wakeup(usb_ep_get(&dev->dev, USB_TOKEN_IN, ep & 0x0f), 0); 2092 } else { 2093 /* 2094 * We report output interrupt packets as completed directly upon 2095 * submission, so all we can do here if one failed is warn. 2096 */ 2097 if (interrupt_packet->status) { 2098 WARNING("interrupt output failed status %d ep %02X id %"PRIu64"\n", 2099 interrupt_packet->status, ep, id); 2100 } 2101 } 2102 } 2103 2104 static void usbredir_buffered_bulk_packet(void *priv, uint64_t id, 2105 struct usb_redir_buffered_bulk_packet_header *buffered_bulk_packet, 2106 uint8_t *data, int data_len) 2107 { 2108 USBRedirDevice *dev = priv; 2109 uint8_t status, ep = buffered_bulk_packet->endpoint; 2110 void *free_on_destroy; 2111 int i, len; 2112 2113 DPRINTF("buffered-bulk-in status %d ep %02X len %d id %"PRIu64"\n", 2114 buffered_bulk_packet->status, ep, data_len, id); 2115 2116 if (dev->endpoint[EP2I(ep)].type != USB_ENDPOINT_XFER_BULK) { 2117 ERROR("received buffered-bulk packet for non bulk ep %02X\n", ep); 2118 free(data); 2119 return; 2120 } 2121 2122 if (dev->endpoint[EP2I(ep)].bulk_receiving_started == 0) { 2123 DPRINTF("received buffered-bulk packet on not started ep %02X\n", ep); 2124 free(data); 2125 return; 2126 } 2127 2128 /* Data must be in maxp chunks for buffered_bulk_add_*_data_to_packet */ 2129 len = dev->endpoint[EP2I(ep)].max_packet_size; 2130 status = usb_redir_success; 2131 free_on_destroy = NULL; 2132 for (i = 0; i < data_len; i += len) { 2133 int r; 2134 if (len >= (data_len - i)) { 2135 len = data_len - i; 2136 status = buffered_bulk_packet->status; 2137 free_on_destroy = data; 2138 } 2139 /* bufp_alloc also adds the packet to the ep queue */ 2140 r = bufp_alloc(dev, data + i, len, status, ep, free_on_destroy); 2141 if (r) { 2142 break; 2143 } 2144 } 2145 2146 if (dev->endpoint[EP2I(ep)].pending_async_packet) { 2147 USBPacket *p = dev->endpoint[EP2I(ep)].pending_async_packet; 2148 dev->endpoint[EP2I(ep)].pending_async_packet = NULL; 2149 usbredir_buffered_bulk_in_complete(dev, p, ep); 2150 usb_packet_complete(&dev->dev, p); 2151 } 2152 } 2153 2154 /* 2155 * Migration code 2156 */ 2157 2158 static int usbredir_pre_save(void *priv) 2159 { 2160 USBRedirDevice *dev = priv; 2161 2162 usbredir_fill_already_in_flight(dev); 2163 2164 return 0; 2165 } 2166 2167 static int usbredir_post_load(void *priv, int version_id) 2168 { 2169 USBRedirDevice *dev = priv; 2170 2171 if (dev == NULL || dev->parser == NULL) { 2172 return 0; 2173 } 2174 2175 switch (dev->device_info.speed) { 2176 case usb_redir_speed_low: 2177 dev->dev.speed = USB_SPEED_LOW; 2178 break; 2179 case usb_redir_speed_full: 2180 dev->dev.speed = USB_SPEED_FULL; 2181 break; 2182 case usb_redir_speed_high: 2183 dev->dev.speed = USB_SPEED_HIGH; 2184 break; 2185 case usb_redir_speed_super: 2186 dev->dev.speed = USB_SPEED_SUPER; 2187 break; 2188 default: 2189 dev->dev.speed = USB_SPEED_FULL; 2190 } 2191 dev->dev.speedmask = (1 << dev->dev.speed); 2192 2193 usbredir_setup_usb_eps(dev); 2194 usbredir_check_bulk_receiving(dev); 2195 2196 return 0; 2197 } 2198 2199 /* For usbredirparser migration */ 2200 static int usbredir_put_parser(QEMUFile *f, void *priv, size_t unused, 2201 const VMStateField *field, QJSON *vmdesc) 2202 { 2203 USBRedirDevice *dev = priv; 2204 uint8_t *data; 2205 int len; 2206 2207 if (dev->parser == NULL) { 2208 qemu_put_be32(f, 0); 2209 return 0; 2210 } 2211 2212 usbredirparser_serialize(dev->parser, &data, &len); 2213 qemu_oom_check(data); 2214 2215 qemu_put_be32(f, len); 2216 qemu_put_buffer(f, data, len); 2217 2218 free(data); 2219 2220 return 0; 2221 } 2222 2223 static int usbredir_get_parser(QEMUFile *f, void *priv, size_t unused, 2224 const VMStateField *field) 2225 { 2226 USBRedirDevice *dev = priv; 2227 uint8_t *data; 2228 int len, ret; 2229 2230 len = qemu_get_be32(f); 2231 if (len == 0) { 2232 return 0; 2233 } 2234 2235 /* 2236 * If our chardev is not open already at this point the usbredir connection 2237 * has been broken (non seamless migration, or restore from disk). 2238 * 2239 * In this case create a temporary parser to receive the migration data, 2240 * and schedule the close_bh to report the device as disconnected to the 2241 * guest and to destroy the parser again. 2242 */ 2243 if (dev->parser == NULL) { 2244 WARNING("usb-redir connection broken during migration\n"); 2245 usbredir_create_parser(dev); 2246 qemu_bh_schedule(dev->chardev_close_bh); 2247 } 2248 2249 data = g_malloc(len); 2250 qemu_get_buffer(f, data, len); 2251 2252 ret = usbredirparser_unserialize(dev->parser, data, len); 2253 2254 g_free(data); 2255 2256 return ret; 2257 } 2258 2259 static const VMStateInfo usbredir_parser_vmstate_info = { 2260 .name = "usb-redir-parser", 2261 .put = usbredir_put_parser, 2262 .get = usbredir_get_parser, 2263 }; 2264 2265 2266 /* For buffered packets (iso/irq) queue migration */ 2267 static int usbredir_put_bufpq(QEMUFile *f, void *priv, size_t unused, 2268 const VMStateField *field, QJSON *vmdesc) 2269 { 2270 struct endp_data *endp = priv; 2271 USBRedirDevice *dev = endp->dev; 2272 struct buf_packet *bufp; 2273 int len, i = 0; 2274 2275 qemu_put_be32(f, endp->bufpq_size); 2276 QTAILQ_FOREACH(bufp, &endp->bufpq, next) { 2277 len = bufp->len - bufp->offset; 2278 DPRINTF("put_bufpq %d/%d len %d status %d\n", i + 1, endp->bufpq_size, 2279 len, bufp->status); 2280 qemu_put_be32(f, len); 2281 qemu_put_be32(f, bufp->status); 2282 qemu_put_buffer(f, bufp->data + bufp->offset, len); 2283 i++; 2284 } 2285 assert(i == endp->bufpq_size); 2286 2287 return 0; 2288 } 2289 2290 static int usbredir_get_bufpq(QEMUFile *f, void *priv, size_t unused, 2291 const VMStateField *field) 2292 { 2293 struct endp_data *endp = priv; 2294 USBRedirDevice *dev = endp->dev; 2295 struct buf_packet *bufp; 2296 int i; 2297 2298 endp->bufpq_size = qemu_get_be32(f); 2299 for (i = 0; i < endp->bufpq_size; i++) { 2300 bufp = g_new(struct buf_packet, 1); 2301 bufp->len = qemu_get_be32(f); 2302 bufp->status = qemu_get_be32(f); 2303 bufp->offset = 0; 2304 bufp->data = qemu_oom_check(malloc(bufp->len)); /* regular malloc! */ 2305 bufp->free_on_destroy = bufp->data; 2306 qemu_get_buffer(f, bufp->data, bufp->len); 2307 QTAILQ_INSERT_TAIL(&endp->bufpq, bufp, next); 2308 DPRINTF("get_bufpq %d/%d len %d status %d\n", i + 1, endp->bufpq_size, 2309 bufp->len, bufp->status); 2310 } 2311 return 0; 2312 } 2313 2314 static const VMStateInfo usbredir_ep_bufpq_vmstate_info = { 2315 .name = "usb-redir-bufpq", 2316 .put = usbredir_put_bufpq, 2317 .get = usbredir_get_bufpq, 2318 }; 2319 2320 2321 /* For endp_data migration */ 2322 static bool usbredir_bulk_receiving_needed(void *priv) 2323 { 2324 struct endp_data *endp = priv; 2325 2326 return endp->bulk_receiving_started; 2327 } 2328 2329 static const VMStateDescription usbredir_bulk_receiving_vmstate = { 2330 .name = "usb-redir-ep/bulk-receiving", 2331 .version_id = 1, 2332 .minimum_version_id = 1, 2333 .needed = usbredir_bulk_receiving_needed, 2334 .fields = (VMStateField[]) { 2335 VMSTATE_UINT8(bulk_receiving_started, struct endp_data), 2336 VMSTATE_END_OF_LIST() 2337 } 2338 }; 2339 2340 static bool usbredir_stream_needed(void *priv) 2341 { 2342 struct endp_data *endp = priv; 2343 2344 return endp->max_streams; 2345 } 2346 2347 static const VMStateDescription usbredir_stream_vmstate = { 2348 .name = "usb-redir-ep/stream-state", 2349 .version_id = 1, 2350 .minimum_version_id = 1, 2351 .needed = usbredir_stream_needed, 2352 .fields = (VMStateField[]) { 2353 VMSTATE_UINT32(max_streams, struct endp_data), 2354 VMSTATE_END_OF_LIST() 2355 } 2356 }; 2357 2358 static const VMStateDescription usbredir_ep_vmstate = { 2359 .name = "usb-redir-ep", 2360 .version_id = 1, 2361 .minimum_version_id = 1, 2362 .fields = (VMStateField[]) { 2363 VMSTATE_UINT8(type, struct endp_data), 2364 VMSTATE_UINT8(interval, struct endp_data), 2365 VMSTATE_UINT8(interface, struct endp_data), 2366 VMSTATE_UINT16(max_packet_size, struct endp_data), 2367 VMSTATE_UINT8(iso_started, struct endp_data), 2368 VMSTATE_UINT8(iso_error, struct endp_data), 2369 VMSTATE_UINT8(interrupt_started, struct endp_data), 2370 VMSTATE_UINT8(interrupt_error, struct endp_data), 2371 VMSTATE_UINT8(bufpq_prefilled, struct endp_data), 2372 VMSTATE_UINT8(bufpq_dropping_packets, struct endp_data), 2373 { 2374 .name = "bufpq", 2375 .version_id = 0, 2376 .field_exists = NULL, 2377 .size = 0, 2378 .info = &usbredir_ep_bufpq_vmstate_info, 2379 .flags = VMS_SINGLE, 2380 .offset = 0, 2381 }, 2382 VMSTATE_INT32(bufpq_target_size, struct endp_data), 2383 VMSTATE_END_OF_LIST() 2384 }, 2385 .subsections = (const VMStateDescription*[]) { 2386 &usbredir_bulk_receiving_vmstate, 2387 &usbredir_stream_vmstate, 2388 NULL 2389 } 2390 }; 2391 2392 2393 /* For PacketIdQueue migration */ 2394 static int usbredir_put_packet_id_q(QEMUFile *f, void *priv, size_t unused, 2395 const VMStateField *field, QJSON *vmdesc) 2396 { 2397 struct PacketIdQueue *q = priv; 2398 USBRedirDevice *dev = q->dev; 2399 struct PacketIdQueueEntry *e; 2400 int remain = q->size; 2401 2402 DPRINTF("put_packet_id_q %s size %d\n", q->name, q->size); 2403 qemu_put_be32(f, q->size); 2404 QTAILQ_FOREACH(e, &q->head, next) { 2405 qemu_put_be64(f, e->id); 2406 remain--; 2407 } 2408 assert(remain == 0); 2409 2410 return 0; 2411 } 2412 2413 static int usbredir_get_packet_id_q(QEMUFile *f, void *priv, size_t unused, 2414 const VMStateField *field) 2415 { 2416 struct PacketIdQueue *q = priv; 2417 USBRedirDevice *dev = q->dev; 2418 int i, size; 2419 uint64_t id; 2420 2421 size = qemu_get_be32(f); 2422 DPRINTF("get_packet_id_q %s size %d\n", q->name, size); 2423 for (i = 0; i < size; i++) { 2424 id = qemu_get_be64(f); 2425 packet_id_queue_add(q, id); 2426 } 2427 assert(q->size == size); 2428 return 0; 2429 } 2430 2431 static const VMStateInfo usbredir_ep_packet_id_q_vmstate_info = { 2432 .name = "usb-redir-packet-id-q", 2433 .put = usbredir_put_packet_id_q, 2434 .get = usbredir_get_packet_id_q, 2435 }; 2436 2437 static const VMStateDescription usbredir_ep_packet_id_queue_vmstate = { 2438 .name = "usb-redir-packet-id-queue", 2439 .version_id = 1, 2440 .minimum_version_id = 1, 2441 .fields = (VMStateField[]) { 2442 { 2443 .name = "queue", 2444 .version_id = 0, 2445 .field_exists = NULL, 2446 .size = 0, 2447 .info = &usbredir_ep_packet_id_q_vmstate_info, 2448 .flags = VMS_SINGLE, 2449 .offset = 0, 2450 }, 2451 VMSTATE_END_OF_LIST() 2452 } 2453 }; 2454 2455 2456 /* For usb_redir_device_connect_header migration */ 2457 static const VMStateDescription usbredir_device_info_vmstate = { 2458 .name = "usb-redir-device-info", 2459 .version_id = 1, 2460 .minimum_version_id = 1, 2461 .fields = (VMStateField[]) { 2462 VMSTATE_UINT8(speed, struct usb_redir_device_connect_header), 2463 VMSTATE_UINT8(device_class, struct usb_redir_device_connect_header), 2464 VMSTATE_UINT8(device_subclass, struct usb_redir_device_connect_header), 2465 VMSTATE_UINT8(device_protocol, struct usb_redir_device_connect_header), 2466 VMSTATE_UINT16(vendor_id, struct usb_redir_device_connect_header), 2467 VMSTATE_UINT16(product_id, struct usb_redir_device_connect_header), 2468 VMSTATE_UINT16(device_version_bcd, 2469 struct usb_redir_device_connect_header), 2470 VMSTATE_END_OF_LIST() 2471 } 2472 }; 2473 2474 2475 /* For usb_redir_interface_info_header migration */ 2476 static const VMStateDescription usbredir_interface_info_vmstate = { 2477 .name = "usb-redir-interface-info", 2478 .version_id = 1, 2479 .minimum_version_id = 1, 2480 .fields = (VMStateField[]) { 2481 VMSTATE_UINT32(interface_count, 2482 struct usb_redir_interface_info_header), 2483 VMSTATE_UINT8_ARRAY(interface, 2484 struct usb_redir_interface_info_header, 32), 2485 VMSTATE_UINT8_ARRAY(interface_class, 2486 struct usb_redir_interface_info_header, 32), 2487 VMSTATE_UINT8_ARRAY(interface_subclass, 2488 struct usb_redir_interface_info_header, 32), 2489 VMSTATE_UINT8_ARRAY(interface_protocol, 2490 struct usb_redir_interface_info_header, 32), 2491 VMSTATE_END_OF_LIST() 2492 } 2493 }; 2494 2495 2496 /* And finally the USBRedirDevice vmstate itself */ 2497 static const VMStateDescription usbredir_vmstate = { 2498 .name = "usb-redir", 2499 .version_id = 1, 2500 .minimum_version_id = 1, 2501 .pre_save = usbredir_pre_save, 2502 .post_load = usbredir_post_load, 2503 .fields = (VMStateField[]) { 2504 VMSTATE_USB_DEVICE(dev, USBRedirDevice), 2505 VMSTATE_TIMER_PTR(attach_timer, USBRedirDevice), 2506 { 2507 .name = "parser", 2508 .version_id = 0, 2509 .field_exists = NULL, 2510 .size = 0, 2511 .info = &usbredir_parser_vmstate_info, 2512 .flags = VMS_SINGLE, 2513 .offset = 0, 2514 }, 2515 VMSTATE_STRUCT_ARRAY(endpoint, USBRedirDevice, MAX_ENDPOINTS, 1, 2516 usbredir_ep_vmstate, struct endp_data), 2517 VMSTATE_STRUCT(cancelled, USBRedirDevice, 1, 2518 usbredir_ep_packet_id_queue_vmstate, 2519 struct PacketIdQueue), 2520 VMSTATE_STRUCT(already_in_flight, USBRedirDevice, 1, 2521 usbredir_ep_packet_id_queue_vmstate, 2522 struct PacketIdQueue), 2523 VMSTATE_STRUCT(device_info, USBRedirDevice, 1, 2524 usbredir_device_info_vmstate, 2525 struct usb_redir_device_connect_header), 2526 VMSTATE_STRUCT(interface_info, USBRedirDevice, 1, 2527 usbredir_interface_info_vmstate, 2528 struct usb_redir_interface_info_header), 2529 VMSTATE_END_OF_LIST() 2530 } 2531 }; 2532 2533 static Property usbredir_properties[] = { 2534 DEFINE_PROP_CHR("chardev", USBRedirDevice, cs), 2535 DEFINE_PROP_UINT8("debug", USBRedirDevice, debug, usbredirparser_warning), 2536 DEFINE_PROP_STRING("filter", USBRedirDevice, filter_str), 2537 DEFINE_PROP_BOOL("streams", USBRedirDevice, enable_streams, true), 2538 DEFINE_PROP_END_OF_LIST(), 2539 }; 2540 2541 static void usbredir_class_initfn(ObjectClass *klass, void *data) 2542 { 2543 USBDeviceClass *uc = USB_DEVICE_CLASS(klass); 2544 DeviceClass *dc = DEVICE_CLASS(klass); 2545 2546 uc->realize = usbredir_realize; 2547 uc->product_desc = "USB Redirection Device"; 2548 uc->unrealize = usbredir_unrealize; 2549 uc->cancel_packet = usbredir_cancel_packet; 2550 uc->handle_reset = usbredir_handle_reset; 2551 uc->handle_data = usbredir_handle_data; 2552 uc->handle_control = usbredir_handle_control; 2553 uc->flush_ep_queue = usbredir_flush_ep_queue; 2554 uc->ep_stopped = usbredir_ep_stopped; 2555 uc->alloc_streams = usbredir_alloc_streams; 2556 uc->free_streams = usbredir_free_streams; 2557 dc->vmsd = &usbredir_vmstate; 2558 dc->props = usbredir_properties; 2559 set_bit(DEVICE_CATEGORY_MISC, dc->categories); 2560 } 2561 2562 static void usbredir_instance_init(Object *obj) 2563 { 2564 USBDevice *udev = USB_DEVICE(obj); 2565 USBRedirDevice *dev = USB_REDIRECT(udev); 2566 2567 device_add_bootindex_property(obj, &dev->bootindex, 2568 "bootindex", NULL, 2569 &udev->qdev, NULL); 2570 } 2571 2572 static const TypeInfo usbredir_dev_info = { 2573 .name = TYPE_USB_REDIR, 2574 .parent = TYPE_USB_DEVICE, 2575 .instance_size = sizeof(USBRedirDevice), 2576 .class_init = usbredir_class_initfn, 2577 .instance_init = usbredir_instance_init, 2578 }; 2579 2580 static void usbredir_register_types(void) 2581 { 2582 type_register_static(&usbredir_dev_info); 2583 } 2584 2585 type_init(usbredir_register_types) 2586