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-common.h" 29 #include "qemu-timer.h" 30 #include "monitor.h" 31 #include "sysemu.h" 32 #include "iov.h" 33 34 #include <dirent.h> 35 #include <sys/ioctl.h> 36 #include <signal.h> 37 #include <usbredirparser.h> 38 #include <usbredirfilter.h> 39 40 #include "hw/usb.h" 41 42 #define MAX_ENDPOINTS 32 43 #define NO_INTERFACE_INFO 255 /* Valid interface_count always <= 32 */ 44 #define EP2I(ep_address) (((ep_address & 0x80) >> 3) | (ep_address & 0x0f)) 45 #define I2EP(i) (((i & 0x10) << 3) | (i & 0x0f)) 46 47 typedef struct USBRedirDevice USBRedirDevice; 48 49 /* Struct to hold buffered packets (iso or int input packets) */ 50 struct buf_packet { 51 uint8_t *data; 52 int len; 53 int status; 54 QTAILQ_ENTRY(buf_packet)next; 55 }; 56 57 struct endp_data { 58 uint8_t type; 59 uint8_t interval; 60 uint8_t interface; /* bInterfaceNumber this ep belongs to */ 61 uint16_t max_packet_size; /* In bytes, not wMaxPacketSize format !! */ 62 uint8_t iso_started; 63 uint8_t iso_error; /* For reporting iso errors to the HC */ 64 uint8_t interrupt_started; 65 uint8_t interrupt_error; 66 uint8_t bufpq_prefilled; 67 uint8_t bufpq_dropping_packets; 68 QTAILQ_HEAD(, buf_packet) bufpq; 69 int32_t bufpq_size; 70 int32_t bufpq_target_size; 71 }; 72 73 struct PacketIdQueueEntry { 74 uint64_t id; 75 QTAILQ_ENTRY(PacketIdQueueEntry)next; 76 }; 77 78 struct PacketIdQueue { 79 USBRedirDevice *dev; 80 const char *name; 81 QTAILQ_HEAD(, PacketIdQueueEntry) head; 82 int size; 83 }; 84 85 struct USBRedirDevice { 86 USBDevice dev; 87 /* Properties */ 88 CharDriverState *cs; 89 uint8_t debug; 90 char *filter_str; 91 int32_t bootindex; 92 /* Data passed from chardev the fd_read cb to the usbredirparser read cb */ 93 const uint8_t *read_buf; 94 int read_buf_size; 95 /* For async handling of close */ 96 QEMUBH *chardev_close_bh; 97 /* To delay the usb attach in case of quick chardev close + open */ 98 QEMUTimer *attach_timer; 99 int64_t next_attach_time; 100 struct usbredirparser *parser; 101 struct endp_data endpoint[MAX_ENDPOINTS]; 102 struct PacketIdQueue cancelled; 103 struct PacketIdQueue already_in_flight; 104 /* Data for device filtering */ 105 struct usb_redir_device_connect_header device_info; 106 struct usb_redir_interface_info_header interface_info; 107 struct usbredirfilter_rule *filter_rules; 108 int filter_rules_count; 109 int compatible_speedmask; 110 }; 111 112 static void usbredir_hello(void *priv, struct usb_redir_hello_header *h); 113 static void usbredir_device_connect(void *priv, 114 struct usb_redir_device_connect_header *device_connect); 115 static void usbredir_device_disconnect(void *priv); 116 static void usbredir_interface_info(void *priv, 117 struct usb_redir_interface_info_header *interface_info); 118 static void usbredir_ep_info(void *priv, 119 struct usb_redir_ep_info_header *ep_info); 120 static void usbredir_configuration_status(void *priv, uint64_t id, 121 struct usb_redir_configuration_status_header *configuration_status); 122 static void usbredir_alt_setting_status(void *priv, uint64_t id, 123 struct usb_redir_alt_setting_status_header *alt_setting_status); 124 static void usbredir_iso_stream_status(void *priv, uint64_t id, 125 struct usb_redir_iso_stream_status_header *iso_stream_status); 126 static void usbredir_interrupt_receiving_status(void *priv, uint64_t id, 127 struct usb_redir_interrupt_receiving_status_header 128 *interrupt_receiving_status); 129 static void usbredir_bulk_streams_status(void *priv, uint64_t id, 130 struct usb_redir_bulk_streams_status_header *bulk_streams_status); 131 static void usbredir_control_packet(void *priv, uint64_t id, 132 struct usb_redir_control_packet_header *control_packet, 133 uint8_t *data, int data_len); 134 static void usbredir_bulk_packet(void *priv, uint64_t id, 135 struct usb_redir_bulk_packet_header *bulk_packet, 136 uint8_t *data, int data_len); 137 static void usbredir_iso_packet(void *priv, uint64_t id, 138 struct usb_redir_iso_packet_header *iso_packet, 139 uint8_t *data, int data_len); 140 static void usbredir_interrupt_packet(void *priv, uint64_t id, 141 struct usb_redir_interrupt_packet_header *interrupt_header, 142 uint8_t *data, int data_len); 143 144 static void usbredir_handle_status(USBRedirDevice *dev, USBPacket *p, 145 int status); 146 147 #define VERSION "qemu usb-redir guest " QEMU_VERSION 148 149 /* 150 * Logging stuff 151 */ 152 153 #define ERROR(...) \ 154 do { \ 155 if (dev->debug >= usbredirparser_error) { \ 156 error_report("usb-redir error: " __VA_ARGS__); \ 157 } \ 158 } while (0) 159 #define WARNING(...) \ 160 do { \ 161 if (dev->debug >= usbredirparser_warning) { \ 162 error_report("usb-redir warning: " __VA_ARGS__); \ 163 } \ 164 } while (0) 165 #define INFO(...) \ 166 do { \ 167 if (dev->debug >= usbredirparser_info) { \ 168 error_report("usb-redir: " __VA_ARGS__); \ 169 } \ 170 } while (0) 171 #define DPRINTF(...) \ 172 do { \ 173 if (dev->debug >= usbredirparser_debug) { \ 174 error_report("usb-redir: " __VA_ARGS__); \ 175 } \ 176 } while (0) 177 #define DPRINTF2(...) \ 178 do { \ 179 if (dev->debug >= usbredirparser_debug_data) { \ 180 error_report("usb-redir: " __VA_ARGS__); \ 181 } \ 182 } while (0) 183 184 static void usbredir_log(void *priv, int level, const char *msg) 185 { 186 USBRedirDevice *dev = priv; 187 188 if (dev->debug < level) { 189 return; 190 } 191 192 error_report("%s", msg); 193 } 194 195 static void usbredir_log_data(USBRedirDevice *dev, const char *desc, 196 const uint8_t *data, int len) 197 { 198 int i, j, n; 199 200 if (dev->debug < usbredirparser_debug_data) { 201 return; 202 } 203 204 for (i = 0; i < len; i += j) { 205 char buf[128]; 206 207 n = sprintf(buf, "%s", desc); 208 for (j = 0; j < 8 && i + j < len; j++) { 209 n += sprintf(buf + n, " %02X", data[i + j]); 210 } 211 error_report("%s", buf); 212 } 213 } 214 215 /* 216 * usbredirparser io functions 217 */ 218 219 static int usbredir_read(void *priv, uint8_t *data, int count) 220 { 221 USBRedirDevice *dev = priv; 222 223 if (dev->read_buf_size < count) { 224 count = dev->read_buf_size; 225 } 226 227 memcpy(data, dev->read_buf, count); 228 229 dev->read_buf_size -= count; 230 if (dev->read_buf_size) { 231 dev->read_buf += count; 232 } else { 233 dev->read_buf = NULL; 234 } 235 236 return count; 237 } 238 239 static int usbredir_write(void *priv, uint8_t *data, int count) 240 { 241 USBRedirDevice *dev = priv; 242 243 if (!dev->cs->opened) { 244 return 0; 245 } 246 247 /* Don't send new data to the chardev until our state is fully synced */ 248 if (!runstate_check(RUN_STATE_RUNNING)) { 249 return 0; 250 } 251 252 return qemu_chr_fe_write(dev->cs, data, count); 253 } 254 255 /* 256 * Cancelled and buffered packets helpers 257 */ 258 259 static void packet_id_queue_init(struct PacketIdQueue *q, 260 USBRedirDevice *dev, const char *name) 261 { 262 q->dev = dev; 263 q->name = name; 264 QTAILQ_INIT(&q->head); 265 q->size = 0; 266 } 267 268 static void packet_id_queue_add(struct PacketIdQueue *q, uint64_t id) 269 { 270 USBRedirDevice *dev = q->dev; 271 struct PacketIdQueueEntry *e; 272 273 DPRINTF("adding packet id %"PRIu64" to %s queue\n", id, q->name); 274 275 e = g_malloc0(sizeof(struct PacketIdQueueEntry)); 276 e->id = id; 277 QTAILQ_INSERT_TAIL(&q->head, e, next); 278 q->size++; 279 } 280 281 static int packet_id_queue_remove(struct PacketIdQueue *q, uint64_t id) 282 { 283 USBRedirDevice *dev = q->dev; 284 struct PacketIdQueueEntry *e; 285 286 QTAILQ_FOREACH(e, &q->head, next) { 287 if (e->id == id) { 288 DPRINTF("removing packet id %"PRIu64" from %s queue\n", 289 id, q->name); 290 QTAILQ_REMOVE(&q->head, e, next); 291 q->size--; 292 g_free(e); 293 return 1; 294 } 295 } 296 return 0; 297 } 298 299 static void packet_id_queue_empty(struct PacketIdQueue *q) 300 { 301 USBRedirDevice *dev = q->dev; 302 struct PacketIdQueueEntry *e, *next_e; 303 304 DPRINTF("removing %d packet-ids from %s queue\n", q->size, q->name); 305 306 QTAILQ_FOREACH_SAFE(e, &q->head, next, next_e) { 307 QTAILQ_REMOVE(&q->head, e, next); 308 g_free(e); 309 } 310 q->size = 0; 311 } 312 313 static void usbredir_cancel_packet(USBDevice *udev, USBPacket *p) 314 { 315 USBRedirDevice *dev = DO_UPCAST(USBRedirDevice, dev, udev); 316 317 if (p->combined) { 318 usb_combined_packet_cancel(udev, p); 319 return; 320 } 321 322 packet_id_queue_add(&dev->cancelled, p->id); 323 usbredirparser_send_cancel_data_packet(dev->parser, p->id); 324 usbredirparser_do_write(dev->parser); 325 } 326 327 static int usbredir_is_cancelled(USBRedirDevice *dev, uint64_t id) 328 { 329 if (!dev->dev.attached) { 330 return 1; /* Treat everything as cancelled after a disconnect */ 331 } 332 return packet_id_queue_remove(&dev->cancelled, id); 333 } 334 335 static void usbredir_fill_already_in_flight_from_ep(USBRedirDevice *dev, 336 struct USBEndpoint *ep) 337 { 338 static USBPacket *p; 339 340 QTAILQ_FOREACH(p, &ep->queue, queue) { 341 /* Skip combined packets, except for the first */ 342 if (p->combined && p != p->combined->first) { 343 continue; 344 } 345 if (p->state == USB_PACKET_ASYNC) { 346 packet_id_queue_add(&dev->already_in_flight, p->id); 347 } 348 } 349 } 350 351 static void usbredir_fill_already_in_flight(USBRedirDevice *dev) 352 { 353 int ep; 354 struct USBDevice *udev = &dev->dev; 355 356 usbredir_fill_already_in_flight_from_ep(dev, &udev->ep_ctl); 357 358 for (ep = 0; ep < USB_MAX_ENDPOINTS; ep++) { 359 usbredir_fill_already_in_flight_from_ep(dev, &udev->ep_in[ep]); 360 usbredir_fill_already_in_flight_from_ep(dev, &udev->ep_out[ep]); 361 } 362 } 363 364 static int usbredir_already_in_flight(USBRedirDevice *dev, uint64_t id) 365 { 366 return packet_id_queue_remove(&dev->already_in_flight, id); 367 } 368 369 static USBPacket *usbredir_find_packet_by_id(USBRedirDevice *dev, 370 uint8_t ep, uint64_t id) 371 { 372 USBPacket *p; 373 374 if (usbredir_is_cancelled(dev, id)) { 375 return NULL; 376 } 377 378 p = usb_ep_find_packet_by_id(&dev->dev, 379 (ep & USB_DIR_IN) ? USB_TOKEN_IN : USB_TOKEN_OUT, 380 ep & 0x0f, id); 381 if (p == NULL) { 382 ERROR("could not find packet with id %"PRIu64"\n", id); 383 } 384 return p; 385 } 386 387 static void bufp_alloc(USBRedirDevice *dev, 388 uint8_t *data, int len, int status, uint8_t ep) 389 { 390 struct buf_packet *bufp; 391 392 if (!dev->endpoint[EP2I(ep)].bufpq_dropping_packets && 393 dev->endpoint[EP2I(ep)].bufpq_size > 394 2 * dev->endpoint[EP2I(ep)].bufpq_target_size) { 395 DPRINTF("bufpq overflow, dropping packets ep %02X\n", ep); 396 dev->endpoint[EP2I(ep)].bufpq_dropping_packets = 1; 397 } 398 /* Since we're interupting the stream anyways, drop enough packets to get 399 back to our target buffer size */ 400 if (dev->endpoint[EP2I(ep)].bufpq_dropping_packets) { 401 if (dev->endpoint[EP2I(ep)].bufpq_size > 402 dev->endpoint[EP2I(ep)].bufpq_target_size) { 403 free(data); 404 return; 405 } 406 dev->endpoint[EP2I(ep)].bufpq_dropping_packets = 0; 407 } 408 409 bufp = g_malloc(sizeof(struct buf_packet)); 410 bufp->data = data; 411 bufp->len = len; 412 bufp->status = status; 413 QTAILQ_INSERT_TAIL(&dev->endpoint[EP2I(ep)].bufpq, bufp, next); 414 dev->endpoint[EP2I(ep)].bufpq_size++; 415 } 416 417 static void bufp_free(USBRedirDevice *dev, struct buf_packet *bufp, 418 uint8_t ep) 419 { 420 QTAILQ_REMOVE(&dev->endpoint[EP2I(ep)].bufpq, bufp, next); 421 dev->endpoint[EP2I(ep)].bufpq_size--; 422 free(bufp->data); 423 g_free(bufp); 424 } 425 426 static void usbredir_free_bufpq(USBRedirDevice *dev, uint8_t ep) 427 { 428 struct buf_packet *buf, *buf_next; 429 430 QTAILQ_FOREACH_SAFE(buf, &dev->endpoint[EP2I(ep)].bufpq, next, buf_next) { 431 bufp_free(dev, buf, ep); 432 } 433 } 434 435 /* 436 * USBDevice callbacks 437 */ 438 439 static void usbredir_handle_reset(USBDevice *udev) 440 { 441 USBRedirDevice *dev = DO_UPCAST(USBRedirDevice, dev, udev); 442 443 DPRINTF("reset device\n"); 444 usbredirparser_send_reset(dev->parser); 445 usbredirparser_do_write(dev->parser); 446 } 447 448 static void usbredir_handle_iso_data(USBRedirDevice *dev, USBPacket *p, 449 uint8_t ep) 450 { 451 int status, len; 452 if (!dev->endpoint[EP2I(ep)].iso_started && 453 !dev->endpoint[EP2I(ep)].iso_error) { 454 struct usb_redir_start_iso_stream_header start_iso = { 455 .endpoint = ep, 456 }; 457 int pkts_per_sec; 458 459 if (dev->dev.speed == USB_SPEED_HIGH) { 460 pkts_per_sec = 8000 / dev->endpoint[EP2I(ep)].interval; 461 } else { 462 pkts_per_sec = 1000 / dev->endpoint[EP2I(ep)].interval; 463 } 464 /* Testing has shown that we need circa 60 ms buffer */ 465 dev->endpoint[EP2I(ep)].bufpq_target_size = (pkts_per_sec * 60) / 1000; 466 467 /* Aim for approx 100 interrupts / second on the client to 468 balance latency and interrupt load */ 469 start_iso.pkts_per_urb = pkts_per_sec / 100; 470 if (start_iso.pkts_per_urb < 1) { 471 start_iso.pkts_per_urb = 1; 472 } else if (start_iso.pkts_per_urb > 32) { 473 start_iso.pkts_per_urb = 32; 474 } 475 476 start_iso.no_urbs = (dev->endpoint[EP2I(ep)].bufpq_target_size + 477 start_iso.pkts_per_urb - 1) / 478 start_iso.pkts_per_urb; 479 /* Output endpoints pre-fill only 1/2 of the packets, keeping the rest 480 as overflow buffer. Also see the usbredir protocol documentation */ 481 if (!(ep & USB_DIR_IN)) { 482 start_iso.no_urbs *= 2; 483 } 484 if (start_iso.no_urbs > 16) { 485 start_iso.no_urbs = 16; 486 } 487 488 /* No id, we look at the ep when receiving a status back */ 489 usbredirparser_send_start_iso_stream(dev->parser, 0, &start_iso); 490 usbredirparser_do_write(dev->parser); 491 DPRINTF("iso stream started pkts/sec %d pkts/urb %d urbs %d ep %02X\n", 492 pkts_per_sec, start_iso.pkts_per_urb, start_iso.no_urbs, ep); 493 dev->endpoint[EP2I(ep)].iso_started = 1; 494 dev->endpoint[EP2I(ep)].bufpq_prefilled = 0; 495 dev->endpoint[EP2I(ep)].bufpq_dropping_packets = 0; 496 } 497 498 if (ep & USB_DIR_IN) { 499 struct buf_packet *isop; 500 501 if (dev->endpoint[EP2I(ep)].iso_started && 502 !dev->endpoint[EP2I(ep)].bufpq_prefilled) { 503 if (dev->endpoint[EP2I(ep)].bufpq_size < 504 dev->endpoint[EP2I(ep)].bufpq_target_size) { 505 return; 506 } 507 dev->endpoint[EP2I(ep)].bufpq_prefilled = 1; 508 } 509 510 isop = QTAILQ_FIRST(&dev->endpoint[EP2I(ep)].bufpq); 511 if (isop == NULL) { 512 DPRINTF("iso-token-in ep %02X, no isop, iso_error: %d\n", 513 ep, dev->endpoint[EP2I(ep)].iso_error); 514 /* Re-fill the buffer */ 515 dev->endpoint[EP2I(ep)].bufpq_prefilled = 0; 516 /* Check iso_error for stream errors, otherwise its an underrun */ 517 status = dev->endpoint[EP2I(ep)].iso_error; 518 dev->endpoint[EP2I(ep)].iso_error = 0; 519 p->status = status ? USB_RET_IOERROR : USB_RET_SUCCESS; 520 return; 521 } 522 DPRINTF2("iso-token-in ep %02X status %d len %d queue-size: %d\n", ep, 523 isop->status, isop->len, dev->endpoint[EP2I(ep)].bufpq_size); 524 525 status = isop->status; 526 len = isop->len; 527 if (len > p->iov.size) { 528 ERROR("received iso data is larger then packet ep %02X (%d > %d)\n", 529 ep, len, (int)p->iov.size); 530 len = p->iov.size; 531 status = usb_redir_babble; 532 } 533 usb_packet_copy(p, isop->data, len); 534 bufp_free(dev, isop, ep); 535 usbredir_handle_status(dev, p, status); 536 } else { 537 /* If the stream was not started because of a pending error don't 538 send the packet to the usb-host */ 539 if (dev->endpoint[EP2I(ep)].iso_started) { 540 struct usb_redir_iso_packet_header iso_packet = { 541 .endpoint = ep, 542 .length = p->iov.size 543 }; 544 uint8_t buf[p->iov.size]; 545 /* No id, we look at the ep when receiving a status back */ 546 usb_packet_copy(p, buf, p->iov.size); 547 usbredirparser_send_iso_packet(dev->parser, 0, &iso_packet, 548 buf, p->iov.size); 549 usbredirparser_do_write(dev->parser); 550 } 551 status = dev->endpoint[EP2I(ep)].iso_error; 552 dev->endpoint[EP2I(ep)].iso_error = 0; 553 DPRINTF2("iso-token-out ep %02X status %d len %zd\n", ep, status, 554 p->iov.size); 555 usbredir_handle_status(dev, p, status); 556 } 557 } 558 559 static void usbredir_stop_iso_stream(USBRedirDevice *dev, uint8_t ep) 560 { 561 struct usb_redir_stop_iso_stream_header stop_iso_stream = { 562 .endpoint = ep 563 }; 564 if (dev->endpoint[EP2I(ep)].iso_started) { 565 usbredirparser_send_stop_iso_stream(dev->parser, 0, &stop_iso_stream); 566 DPRINTF("iso stream stopped ep %02X\n", ep); 567 dev->endpoint[EP2I(ep)].iso_started = 0; 568 } 569 dev->endpoint[EP2I(ep)].iso_error = 0; 570 usbredir_free_bufpq(dev, ep); 571 } 572 573 static void usbredir_handle_bulk_data(USBRedirDevice *dev, USBPacket *p, 574 uint8_t ep) 575 { 576 struct usb_redir_bulk_packet_header bulk_packet; 577 size_t size = (p->combined) ? p->combined->iov.size : p->iov.size; 578 579 DPRINTF("bulk-out ep %02X len %zd id %"PRIu64"\n", ep, size, p->id); 580 581 if (usbredir_already_in_flight(dev, p->id)) { 582 p->status = USB_RET_ASYNC; 583 return; 584 } 585 586 bulk_packet.endpoint = ep; 587 bulk_packet.length = size; 588 bulk_packet.stream_id = 0; 589 bulk_packet.length_high = size >> 16; 590 assert(bulk_packet.length_high == 0 || 591 usbredirparser_peer_has_cap(dev->parser, 592 usb_redir_cap_32bits_bulk_length)); 593 594 if (ep & USB_DIR_IN) { 595 usbredirparser_send_bulk_packet(dev->parser, p->id, 596 &bulk_packet, NULL, 0); 597 } else { 598 uint8_t buf[size]; 599 if (p->combined) { 600 iov_to_buf(p->combined->iov.iov, p->combined->iov.niov, 601 0, buf, size); 602 } else { 603 usb_packet_copy(p, buf, size); 604 } 605 usbredir_log_data(dev, "bulk data out:", buf, size); 606 usbredirparser_send_bulk_packet(dev->parser, p->id, 607 &bulk_packet, buf, size); 608 } 609 usbredirparser_do_write(dev->parser); 610 p->status = USB_RET_ASYNC; 611 } 612 613 static void usbredir_handle_interrupt_in_data(USBRedirDevice *dev, 614 USBPacket *p, uint8_t ep) 615 { 616 /* Input interrupt endpoint, buffered packet input */ 617 struct buf_packet *intp; 618 int status, len; 619 620 if (!dev->endpoint[EP2I(ep)].interrupt_started && 621 !dev->endpoint[EP2I(ep)].interrupt_error) { 622 struct usb_redir_start_interrupt_receiving_header start_int = { 623 .endpoint = ep, 624 }; 625 /* No id, we look at the ep when receiving a status back */ 626 usbredirparser_send_start_interrupt_receiving(dev->parser, 0, 627 &start_int); 628 usbredirparser_do_write(dev->parser); 629 DPRINTF("interrupt recv started ep %02X\n", ep); 630 dev->endpoint[EP2I(ep)].interrupt_started = 1; 631 /* We don't really want to drop interrupt packets ever, but 632 having some upper limit to how much we buffer is good. */ 633 dev->endpoint[EP2I(ep)].bufpq_target_size = 1000; 634 dev->endpoint[EP2I(ep)].bufpq_dropping_packets = 0; 635 } 636 637 intp = QTAILQ_FIRST(&dev->endpoint[EP2I(ep)].bufpq); 638 if (intp == NULL) { 639 DPRINTF2("interrupt-token-in ep %02X, no intp\n", ep); 640 /* Check interrupt_error for stream errors */ 641 status = dev->endpoint[EP2I(ep)].interrupt_error; 642 dev->endpoint[EP2I(ep)].interrupt_error = 0; 643 if (status) { 644 usbredir_handle_status(dev, p, status); 645 } else { 646 p->status = USB_RET_NAK; 647 } 648 return; 649 } 650 DPRINTF("interrupt-token-in ep %02X status %d len %d\n", ep, 651 intp->status, intp->len); 652 653 status = intp->status; 654 len = intp->len; 655 if (len > p->iov.size) { 656 ERROR("received int data is larger then packet ep %02X\n", ep); 657 len = p->iov.size; 658 status = usb_redir_babble; 659 } 660 usb_packet_copy(p, intp->data, len); 661 bufp_free(dev, intp, ep); 662 usbredir_handle_status(dev, p, status); 663 } 664 665 /* 666 * Handle interrupt out data, the usbredir protocol expects us to do this 667 * async, so that it can report back a completion status. But guests will 668 * expect immediate completion for an interrupt endpoint, and handling this 669 * async causes migration issues. So we report success directly, counting 670 * on the fact that output interrupt packets normally always succeed. 671 */ 672 static void usbredir_handle_interrupt_out_data(USBRedirDevice *dev, 673 USBPacket *p, uint8_t ep) 674 { 675 struct usb_redir_interrupt_packet_header interrupt_packet; 676 uint8_t buf[p->iov.size]; 677 678 DPRINTF("interrupt-out ep %02X len %zd id %"PRIu64"\n", ep, 679 p->iov.size, p->id); 680 681 interrupt_packet.endpoint = ep; 682 interrupt_packet.length = p->iov.size; 683 684 usb_packet_copy(p, buf, p->iov.size); 685 usbredir_log_data(dev, "interrupt data out:", buf, p->iov.size); 686 usbredirparser_send_interrupt_packet(dev->parser, p->id, 687 &interrupt_packet, buf, p->iov.size); 688 usbredirparser_do_write(dev->parser); 689 } 690 691 static void usbredir_stop_interrupt_receiving(USBRedirDevice *dev, 692 uint8_t ep) 693 { 694 struct usb_redir_stop_interrupt_receiving_header stop_interrupt_recv = { 695 .endpoint = ep 696 }; 697 if (dev->endpoint[EP2I(ep)].interrupt_started) { 698 usbredirparser_send_stop_interrupt_receiving(dev->parser, 0, 699 &stop_interrupt_recv); 700 DPRINTF("interrupt recv stopped ep %02X\n", ep); 701 dev->endpoint[EP2I(ep)].interrupt_started = 0; 702 } 703 dev->endpoint[EP2I(ep)].interrupt_error = 0; 704 usbredir_free_bufpq(dev, ep); 705 } 706 707 static void usbredir_handle_data(USBDevice *udev, USBPacket *p) 708 { 709 USBRedirDevice *dev = DO_UPCAST(USBRedirDevice, dev, udev); 710 uint8_t ep; 711 712 ep = p->ep->nr; 713 if (p->pid == USB_TOKEN_IN) { 714 ep |= USB_DIR_IN; 715 } 716 717 switch (dev->endpoint[EP2I(ep)].type) { 718 case USB_ENDPOINT_XFER_CONTROL: 719 ERROR("handle_data called for control transfer on ep %02X\n", ep); 720 p->status = USB_RET_NAK; 721 break; 722 case USB_ENDPOINT_XFER_ISOC: 723 usbredir_handle_iso_data(dev, p, ep); 724 break; 725 case USB_ENDPOINT_XFER_BULK: 726 if (p->state == USB_PACKET_SETUP && p->pid == USB_TOKEN_IN && 727 p->ep->pipeline) { 728 p->status = USB_RET_ADD_TO_QUEUE; 729 break; 730 } 731 usbredir_handle_bulk_data(dev, p, ep); 732 break; 733 case USB_ENDPOINT_XFER_INT: 734 if (ep & USB_DIR_IN) { 735 usbredir_handle_interrupt_in_data(dev, p, ep); 736 } else { 737 usbredir_handle_interrupt_out_data(dev, p, ep); 738 } 739 break; 740 default: 741 ERROR("handle_data ep %02X has unknown type %d\n", ep, 742 dev->endpoint[EP2I(ep)].type); 743 p->status = USB_RET_NAK; 744 } 745 } 746 747 static void usbredir_flush_ep_queue(USBDevice *dev, USBEndpoint *ep) 748 { 749 if (ep->pid == USB_TOKEN_IN && ep->pipeline) { 750 usb_ep_combine_input_packets(ep); 751 } 752 } 753 754 static void usbredir_set_config(USBRedirDevice *dev, USBPacket *p, 755 int config) 756 { 757 struct usb_redir_set_configuration_header set_config; 758 int i; 759 760 DPRINTF("set config %d id %"PRIu64"\n", config, p->id); 761 762 for (i = 0; i < MAX_ENDPOINTS; i++) { 763 switch (dev->endpoint[i].type) { 764 case USB_ENDPOINT_XFER_ISOC: 765 usbredir_stop_iso_stream(dev, I2EP(i)); 766 break; 767 case USB_ENDPOINT_XFER_INT: 768 if (i & 0x10) { 769 usbredir_stop_interrupt_receiving(dev, I2EP(i)); 770 } 771 break; 772 } 773 usbredir_free_bufpq(dev, I2EP(i)); 774 } 775 776 set_config.configuration = config; 777 usbredirparser_send_set_configuration(dev->parser, p->id, &set_config); 778 usbredirparser_do_write(dev->parser); 779 p->status = USB_RET_ASYNC; 780 } 781 782 static void usbredir_get_config(USBRedirDevice *dev, USBPacket *p) 783 { 784 DPRINTF("get config id %"PRIu64"\n", p->id); 785 786 usbredirparser_send_get_configuration(dev->parser, p->id); 787 usbredirparser_do_write(dev->parser); 788 p->status = USB_RET_ASYNC; 789 } 790 791 static void usbredir_set_interface(USBRedirDevice *dev, USBPacket *p, 792 int interface, int alt) 793 { 794 struct usb_redir_set_alt_setting_header set_alt; 795 int i; 796 797 DPRINTF("set interface %d alt %d id %"PRIu64"\n", interface, alt, p->id); 798 799 for (i = 0; i < MAX_ENDPOINTS; i++) { 800 if (dev->endpoint[i].interface == interface) { 801 switch (dev->endpoint[i].type) { 802 case USB_ENDPOINT_XFER_ISOC: 803 usbredir_stop_iso_stream(dev, I2EP(i)); 804 break; 805 case USB_ENDPOINT_XFER_INT: 806 if (i & 0x10) { 807 usbredir_stop_interrupt_receiving(dev, I2EP(i)); 808 } 809 break; 810 } 811 usbredir_free_bufpq(dev, I2EP(i)); 812 } 813 } 814 815 set_alt.interface = interface; 816 set_alt.alt = alt; 817 usbredirparser_send_set_alt_setting(dev->parser, p->id, &set_alt); 818 usbredirparser_do_write(dev->parser); 819 p->status = USB_RET_ASYNC; 820 } 821 822 static void usbredir_get_interface(USBRedirDevice *dev, USBPacket *p, 823 int interface) 824 { 825 struct usb_redir_get_alt_setting_header get_alt; 826 827 DPRINTF("get interface %d id %"PRIu64"\n", interface, p->id); 828 829 get_alt.interface = interface; 830 usbredirparser_send_get_alt_setting(dev->parser, p->id, &get_alt); 831 usbredirparser_do_write(dev->parser); 832 p->status = USB_RET_ASYNC; 833 } 834 835 static void usbredir_handle_control(USBDevice *udev, USBPacket *p, 836 int request, int value, int index, int length, uint8_t *data) 837 { 838 USBRedirDevice *dev = DO_UPCAST(USBRedirDevice, dev, udev); 839 struct usb_redir_control_packet_header control_packet; 840 841 if (usbredir_already_in_flight(dev, p->id)) { 842 p->status = USB_RET_ASYNC; 843 return; 844 } 845 846 /* Special cases for certain standard device requests */ 847 switch (request) { 848 case DeviceOutRequest | USB_REQ_SET_ADDRESS: 849 DPRINTF("set address %d\n", value); 850 dev->dev.addr = value; 851 return; 852 case DeviceOutRequest | USB_REQ_SET_CONFIGURATION: 853 usbredir_set_config(dev, p, value & 0xff); 854 return; 855 case DeviceRequest | USB_REQ_GET_CONFIGURATION: 856 usbredir_get_config(dev, p); 857 return; 858 case InterfaceOutRequest | USB_REQ_SET_INTERFACE: 859 usbredir_set_interface(dev, p, index, value); 860 return; 861 case InterfaceRequest | USB_REQ_GET_INTERFACE: 862 usbredir_get_interface(dev, p, index); 863 return; 864 } 865 866 /* Normal ctrl requests, note request is (bRequestType << 8) | bRequest */ 867 DPRINTF( 868 "ctrl-out type 0x%x req 0x%x val 0x%x index %d len %d id %"PRIu64"\n", 869 request >> 8, request & 0xff, value, index, length, p->id); 870 871 control_packet.request = request & 0xFF; 872 control_packet.requesttype = request >> 8; 873 control_packet.endpoint = control_packet.requesttype & USB_DIR_IN; 874 control_packet.value = value; 875 control_packet.index = index; 876 control_packet.length = length; 877 878 if (control_packet.requesttype & USB_DIR_IN) { 879 usbredirparser_send_control_packet(dev->parser, p->id, 880 &control_packet, NULL, 0); 881 } else { 882 usbredir_log_data(dev, "ctrl data out:", data, length); 883 usbredirparser_send_control_packet(dev->parser, p->id, 884 &control_packet, data, length); 885 } 886 usbredirparser_do_write(dev->parser); 887 p->status = USB_RET_ASYNC; 888 } 889 890 /* 891 * Close events can be triggered by usbredirparser_do_write which gets called 892 * from within the USBDevice data / control packet callbacks and doing a 893 * usb_detach from within these callbacks is not a good idea. 894 * 895 * So we use a bh handler to take care of close events. 896 */ 897 static void usbredir_chardev_close_bh(void *opaque) 898 { 899 USBRedirDevice *dev = opaque; 900 901 usbredir_device_disconnect(dev); 902 903 if (dev->parser) { 904 DPRINTF("destroying usbredirparser\n"); 905 usbredirparser_destroy(dev->parser); 906 dev->parser = NULL; 907 } 908 } 909 910 static void usbredir_create_parser(USBRedirDevice *dev) 911 { 912 uint32_t caps[USB_REDIR_CAPS_SIZE] = { 0, }; 913 int flags = 0; 914 915 DPRINTF("creating usbredirparser\n"); 916 917 dev->parser = qemu_oom_check(usbredirparser_create()); 918 dev->parser->priv = dev; 919 dev->parser->log_func = usbredir_log; 920 dev->parser->read_func = usbredir_read; 921 dev->parser->write_func = usbredir_write; 922 dev->parser->hello_func = usbredir_hello; 923 dev->parser->device_connect_func = usbredir_device_connect; 924 dev->parser->device_disconnect_func = usbredir_device_disconnect; 925 dev->parser->interface_info_func = usbredir_interface_info; 926 dev->parser->ep_info_func = usbredir_ep_info; 927 dev->parser->configuration_status_func = usbredir_configuration_status; 928 dev->parser->alt_setting_status_func = usbredir_alt_setting_status; 929 dev->parser->iso_stream_status_func = usbredir_iso_stream_status; 930 dev->parser->interrupt_receiving_status_func = 931 usbredir_interrupt_receiving_status; 932 dev->parser->bulk_streams_status_func = usbredir_bulk_streams_status; 933 dev->parser->control_packet_func = usbredir_control_packet; 934 dev->parser->bulk_packet_func = usbredir_bulk_packet; 935 dev->parser->iso_packet_func = usbredir_iso_packet; 936 dev->parser->interrupt_packet_func = usbredir_interrupt_packet; 937 dev->read_buf = NULL; 938 dev->read_buf_size = 0; 939 940 usbredirparser_caps_set_cap(caps, usb_redir_cap_connect_device_version); 941 usbredirparser_caps_set_cap(caps, usb_redir_cap_filter); 942 usbredirparser_caps_set_cap(caps, usb_redir_cap_ep_info_max_packet_size); 943 usbredirparser_caps_set_cap(caps, usb_redir_cap_64bits_ids); 944 usbredirparser_caps_set_cap(caps, usb_redir_cap_32bits_bulk_length); 945 946 if (runstate_check(RUN_STATE_INMIGRATE)) { 947 flags |= usbredirparser_fl_no_hello; 948 } 949 usbredirparser_init(dev->parser, VERSION, caps, USB_REDIR_CAPS_SIZE, 950 flags); 951 usbredirparser_do_write(dev->parser); 952 } 953 954 static void usbredir_reject_device(USBRedirDevice *dev) 955 { 956 usbredir_device_disconnect(dev); 957 if (usbredirparser_peer_has_cap(dev->parser, usb_redir_cap_filter)) { 958 usbredirparser_send_filter_reject(dev->parser); 959 usbredirparser_do_write(dev->parser); 960 } 961 } 962 963 static void usbredir_do_attach(void *opaque) 964 { 965 USBRedirDevice *dev = opaque; 966 967 /* In order to work properly with XHCI controllers we need these caps */ 968 if ((dev->dev.port->speedmask & USB_SPEED_MASK_SUPER) && !( 969 usbredirparser_peer_has_cap(dev->parser, 970 usb_redir_cap_ep_info_max_packet_size) && 971 usbredirparser_peer_has_cap(dev->parser, 972 usb_redir_cap_64bits_ids))) { 973 ERROR("usb-redir-host lacks capabilities needed for use with XHCI\n"); 974 usbredir_reject_device(dev); 975 return; 976 } 977 978 if (usb_device_attach(&dev->dev) != 0) { 979 WARNING("rejecting device due to speed mismatch\n"); 980 usbredir_reject_device(dev); 981 } 982 } 983 984 /* 985 * chardev callbacks 986 */ 987 988 static int usbredir_chardev_can_read(void *opaque) 989 { 990 USBRedirDevice *dev = opaque; 991 992 if (!dev->parser) { 993 WARNING("chardev_can_read called on non open chardev!\n"); 994 return 0; 995 } 996 997 /* Don't read new data from the chardev until our state is fully synced */ 998 if (!runstate_check(RUN_STATE_RUNNING)) { 999 return 0; 1000 } 1001 1002 /* usbredir_parser_do_read will consume *all* data we give it */ 1003 return 1024 * 1024; 1004 } 1005 1006 static void usbredir_chardev_read(void *opaque, const uint8_t *buf, int size) 1007 { 1008 USBRedirDevice *dev = opaque; 1009 1010 /* No recursion allowed! */ 1011 assert(dev->read_buf == NULL); 1012 1013 dev->read_buf = buf; 1014 dev->read_buf_size = size; 1015 1016 usbredirparser_do_read(dev->parser); 1017 /* Send any acks, etc. which may be queued now */ 1018 usbredirparser_do_write(dev->parser); 1019 } 1020 1021 static void usbredir_chardev_event(void *opaque, int event) 1022 { 1023 USBRedirDevice *dev = opaque; 1024 1025 switch (event) { 1026 case CHR_EVENT_OPENED: 1027 DPRINTF("chardev open\n"); 1028 /* Make sure any pending closes are handled (no-op if none pending) */ 1029 usbredir_chardev_close_bh(dev); 1030 qemu_bh_cancel(dev->chardev_close_bh); 1031 usbredir_create_parser(dev); 1032 break; 1033 case CHR_EVENT_CLOSED: 1034 DPRINTF("chardev close\n"); 1035 qemu_bh_schedule(dev->chardev_close_bh); 1036 break; 1037 } 1038 } 1039 1040 /* 1041 * init + destroy 1042 */ 1043 1044 static void usbredir_vm_state_change(void *priv, int running, RunState state) 1045 { 1046 USBRedirDevice *dev = priv; 1047 1048 if (state == RUN_STATE_RUNNING && dev->parser != NULL) { 1049 usbredirparser_do_write(dev->parser); /* Flush any pending writes */ 1050 } 1051 } 1052 1053 static int usbredir_initfn(USBDevice *udev) 1054 { 1055 USBRedirDevice *dev = DO_UPCAST(USBRedirDevice, dev, udev); 1056 int i; 1057 1058 if (dev->cs == NULL) { 1059 qerror_report(QERR_MISSING_PARAMETER, "chardev"); 1060 return -1; 1061 } 1062 1063 if (dev->filter_str) { 1064 i = usbredirfilter_string_to_rules(dev->filter_str, ":", "|", 1065 &dev->filter_rules, 1066 &dev->filter_rules_count); 1067 if (i) { 1068 qerror_report(QERR_INVALID_PARAMETER_VALUE, "filter", 1069 "a usb device filter string"); 1070 return -1; 1071 } 1072 } 1073 1074 dev->chardev_close_bh = qemu_bh_new(usbredir_chardev_close_bh, dev); 1075 dev->attach_timer = qemu_new_timer_ms(vm_clock, usbredir_do_attach, dev); 1076 1077 packet_id_queue_init(&dev->cancelled, dev, "cancelled"); 1078 packet_id_queue_init(&dev->already_in_flight, dev, "already-in-flight"); 1079 for (i = 0; i < MAX_ENDPOINTS; i++) { 1080 QTAILQ_INIT(&dev->endpoint[i].bufpq); 1081 } 1082 1083 /* We'll do the attach once we receive the speed from the usb-host */ 1084 udev->auto_attach = 0; 1085 1086 /* Will be cleared during setup when we find conflicts */ 1087 dev->compatible_speedmask = USB_SPEED_MASK_FULL | USB_SPEED_MASK_HIGH; 1088 1089 /* Let the backend know we are ready */ 1090 qemu_chr_fe_open(dev->cs); 1091 qemu_chr_add_handlers(dev->cs, usbredir_chardev_can_read, 1092 usbredir_chardev_read, usbredir_chardev_event, dev); 1093 1094 qemu_add_vm_change_state_handler(usbredir_vm_state_change, dev); 1095 add_boot_device_path(dev->bootindex, &udev->qdev, NULL); 1096 return 0; 1097 } 1098 1099 static void usbredir_cleanup_device_queues(USBRedirDevice *dev) 1100 { 1101 int i; 1102 1103 packet_id_queue_empty(&dev->cancelled); 1104 packet_id_queue_empty(&dev->already_in_flight); 1105 for (i = 0; i < MAX_ENDPOINTS; i++) { 1106 usbredir_free_bufpq(dev, I2EP(i)); 1107 } 1108 } 1109 1110 static void usbredir_handle_destroy(USBDevice *udev) 1111 { 1112 USBRedirDevice *dev = DO_UPCAST(USBRedirDevice, dev, udev); 1113 1114 qemu_chr_fe_close(dev->cs); 1115 qemu_chr_delete(dev->cs); 1116 /* Note must be done after qemu_chr_close, as that causes a close event */ 1117 qemu_bh_delete(dev->chardev_close_bh); 1118 1119 qemu_del_timer(dev->attach_timer); 1120 qemu_free_timer(dev->attach_timer); 1121 1122 usbredir_cleanup_device_queues(dev); 1123 1124 if (dev->parser) { 1125 usbredirparser_destroy(dev->parser); 1126 } 1127 1128 free(dev->filter_rules); 1129 } 1130 1131 static int usbredir_check_filter(USBRedirDevice *dev) 1132 { 1133 if (dev->interface_info.interface_count == NO_INTERFACE_INFO) { 1134 ERROR("No interface info for device\n"); 1135 goto error; 1136 } 1137 1138 if (dev->filter_rules) { 1139 if (!usbredirparser_peer_has_cap(dev->parser, 1140 usb_redir_cap_connect_device_version)) { 1141 ERROR("Device filter specified and peer does not have the " 1142 "connect_device_version capability\n"); 1143 goto error; 1144 } 1145 1146 if (usbredirfilter_check( 1147 dev->filter_rules, 1148 dev->filter_rules_count, 1149 dev->device_info.device_class, 1150 dev->device_info.device_subclass, 1151 dev->device_info.device_protocol, 1152 dev->interface_info.interface_class, 1153 dev->interface_info.interface_subclass, 1154 dev->interface_info.interface_protocol, 1155 dev->interface_info.interface_count, 1156 dev->device_info.vendor_id, 1157 dev->device_info.product_id, 1158 dev->device_info.device_version_bcd, 1159 0) != 0) { 1160 goto error; 1161 } 1162 } 1163 1164 return 0; 1165 1166 error: 1167 usbredir_reject_device(dev); 1168 return -1; 1169 } 1170 1171 /* 1172 * usbredirparser packet complete callbacks 1173 */ 1174 1175 static void usbredir_handle_status(USBRedirDevice *dev, USBPacket *p, 1176 int status) 1177 { 1178 switch (status) { 1179 case usb_redir_success: 1180 p->status = USB_RET_SUCCESS; /* Clear previous ASYNC status */ 1181 break; 1182 case usb_redir_stall: 1183 p->status = USB_RET_STALL; 1184 break; 1185 case usb_redir_cancelled: 1186 /* 1187 * When the usbredir-host unredirects a device, it will report a status 1188 * of cancelled for all pending packets, followed by a disconnect msg. 1189 */ 1190 p->status = USB_RET_IOERROR; 1191 break; 1192 case usb_redir_inval: 1193 WARNING("got invalid param error from usb-host?\n"); 1194 p->status = USB_RET_IOERROR; 1195 break; 1196 case usb_redir_babble: 1197 p->status = USB_RET_BABBLE; 1198 break; 1199 case usb_redir_ioerror: 1200 case usb_redir_timeout: 1201 default: 1202 p->status = USB_RET_IOERROR; 1203 } 1204 } 1205 1206 static void usbredir_hello(void *priv, struct usb_redir_hello_header *h) 1207 { 1208 USBRedirDevice *dev = priv; 1209 1210 /* Try to send the filter info now that we've the usb-host's caps */ 1211 if (usbredirparser_peer_has_cap(dev->parser, usb_redir_cap_filter) && 1212 dev->filter_rules) { 1213 usbredirparser_send_filter_filter(dev->parser, dev->filter_rules, 1214 dev->filter_rules_count); 1215 usbredirparser_do_write(dev->parser); 1216 } 1217 } 1218 1219 static void usbredir_device_connect(void *priv, 1220 struct usb_redir_device_connect_header *device_connect) 1221 { 1222 USBRedirDevice *dev = priv; 1223 const char *speed; 1224 1225 if (qemu_timer_pending(dev->attach_timer) || dev->dev.attached) { 1226 ERROR("Received device connect while already connected\n"); 1227 return; 1228 } 1229 1230 switch (device_connect->speed) { 1231 case usb_redir_speed_low: 1232 speed = "low speed"; 1233 dev->dev.speed = USB_SPEED_LOW; 1234 dev->compatible_speedmask &= ~USB_SPEED_MASK_FULL; 1235 dev->compatible_speedmask &= ~USB_SPEED_MASK_HIGH; 1236 break; 1237 case usb_redir_speed_full: 1238 speed = "full speed"; 1239 dev->dev.speed = USB_SPEED_FULL; 1240 dev->compatible_speedmask &= ~USB_SPEED_MASK_HIGH; 1241 break; 1242 case usb_redir_speed_high: 1243 speed = "high speed"; 1244 dev->dev.speed = USB_SPEED_HIGH; 1245 break; 1246 case usb_redir_speed_super: 1247 speed = "super speed"; 1248 dev->dev.speed = USB_SPEED_SUPER; 1249 break; 1250 default: 1251 speed = "unknown speed"; 1252 dev->dev.speed = USB_SPEED_FULL; 1253 } 1254 1255 if (usbredirparser_peer_has_cap(dev->parser, 1256 usb_redir_cap_connect_device_version)) { 1257 INFO("attaching %s device %04x:%04x version %d.%d class %02x\n", 1258 speed, device_connect->vendor_id, device_connect->product_id, 1259 ((device_connect->device_version_bcd & 0xf000) >> 12) * 10 + 1260 ((device_connect->device_version_bcd & 0x0f00) >> 8), 1261 ((device_connect->device_version_bcd & 0x00f0) >> 4) * 10 + 1262 ((device_connect->device_version_bcd & 0x000f) >> 0), 1263 device_connect->device_class); 1264 } else { 1265 INFO("attaching %s device %04x:%04x class %02x\n", speed, 1266 device_connect->vendor_id, device_connect->product_id, 1267 device_connect->device_class); 1268 } 1269 1270 dev->dev.speedmask = (1 << dev->dev.speed) | dev->compatible_speedmask; 1271 dev->device_info = *device_connect; 1272 1273 if (usbredir_check_filter(dev)) { 1274 WARNING("Device %04x:%04x rejected by device filter, not attaching\n", 1275 device_connect->vendor_id, device_connect->product_id); 1276 return; 1277 } 1278 1279 qemu_mod_timer(dev->attach_timer, dev->next_attach_time); 1280 } 1281 1282 static void usbredir_device_disconnect(void *priv) 1283 { 1284 USBRedirDevice *dev = priv; 1285 int i; 1286 1287 /* Stop any pending attaches */ 1288 qemu_del_timer(dev->attach_timer); 1289 1290 if (dev->dev.attached) { 1291 DPRINTF("detaching device\n"); 1292 usb_device_detach(&dev->dev); 1293 /* 1294 * Delay next usb device attach to give the guest a chance to see 1295 * see the detach / attach in case of quick close / open succession 1296 */ 1297 dev->next_attach_time = qemu_get_clock_ms(vm_clock) + 200; 1298 } 1299 1300 /* Reset state so that the next dev connected starts with a clean slate */ 1301 usbredir_cleanup_device_queues(dev); 1302 memset(dev->endpoint, 0, sizeof(dev->endpoint)); 1303 for (i = 0; i < MAX_ENDPOINTS; i++) { 1304 QTAILQ_INIT(&dev->endpoint[i].bufpq); 1305 } 1306 usb_ep_init(&dev->dev); 1307 dev->interface_info.interface_count = NO_INTERFACE_INFO; 1308 dev->dev.addr = 0; 1309 dev->dev.speed = 0; 1310 dev->compatible_speedmask = USB_SPEED_MASK_FULL | USB_SPEED_MASK_HIGH; 1311 } 1312 1313 static void usbredir_interface_info(void *priv, 1314 struct usb_redir_interface_info_header *interface_info) 1315 { 1316 USBRedirDevice *dev = priv; 1317 1318 dev->interface_info = *interface_info; 1319 1320 /* 1321 * If we receive interface info after the device has already been 1322 * connected (ie on a set_config), re-check the filter. 1323 */ 1324 if (qemu_timer_pending(dev->attach_timer) || dev->dev.attached) { 1325 if (usbredir_check_filter(dev)) { 1326 ERROR("Device no longer matches filter after interface info " 1327 "change, disconnecting!\n"); 1328 } 1329 } 1330 } 1331 1332 static void usbredir_mark_speed_incompatible(USBRedirDevice *dev, int speed) 1333 { 1334 dev->compatible_speedmask &= ~(1 << speed); 1335 dev->dev.speedmask = (1 << dev->dev.speed) | dev->compatible_speedmask; 1336 } 1337 1338 static void usbredir_set_pipeline(USBRedirDevice *dev, struct USBEndpoint *uep) 1339 { 1340 if (uep->type != USB_ENDPOINT_XFER_BULK) { 1341 return; 1342 } 1343 if (uep->pid == USB_TOKEN_OUT) { 1344 uep->pipeline = true; 1345 } 1346 if (uep->pid == USB_TOKEN_IN && uep->max_packet_size != 0 && 1347 usbredirparser_peer_has_cap(dev->parser, 1348 usb_redir_cap_32bits_bulk_length)) { 1349 uep->pipeline = true; 1350 } 1351 } 1352 1353 static void usbredir_setup_usb_eps(USBRedirDevice *dev) 1354 { 1355 struct USBEndpoint *usb_ep; 1356 int i, pid; 1357 1358 for (i = 0; i < MAX_ENDPOINTS; i++) { 1359 pid = (i & 0x10) ? USB_TOKEN_IN : USB_TOKEN_OUT; 1360 usb_ep = usb_ep_get(&dev->dev, pid, i & 0x0f); 1361 usb_ep->type = dev->endpoint[i].type; 1362 usb_ep->ifnum = dev->endpoint[i].interface; 1363 usb_ep->max_packet_size = dev->endpoint[i].max_packet_size; 1364 usbredir_set_pipeline(dev, usb_ep); 1365 } 1366 } 1367 1368 static void usbredir_ep_info(void *priv, 1369 struct usb_redir_ep_info_header *ep_info) 1370 { 1371 USBRedirDevice *dev = priv; 1372 int i; 1373 1374 for (i = 0; i < MAX_ENDPOINTS; i++) { 1375 dev->endpoint[i].type = ep_info->type[i]; 1376 dev->endpoint[i].interval = ep_info->interval[i]; 1377 dev->endpoint[i].interface = ep_info->interface[i]; 1378 if (usbredirparser_peer_has_cap(dev->parser, 1379 usb_redir_cap_ep_info_max_packet_size)) { 1380 dev->endpoint[i].max_packet_size = ep_info->max_packet_size[i]; 1381 } 1382 switch (dev->endpoint[i].type) { 1383 case usb_redir_type_invalid: 1384 break; 1385 case usb_redir_type_iso: 1386 usbredir_mark_speed_incompatible(dev, USB_SPEED_FULL); 1387 usbredir_mark_speed_incompatible(dev, USB_SPEED_HIGH); 1388 /* Fall through */ 1389 case usb_redir_type_interrupt: 1390 if (!usbredirparser_peer_has_cap(dev->parser, 1391 usb_redir_cap_ep_info_max_packet_size) || 1392 ep_info->max_packet_size[i] > 64) { 1393 usbredir_mark_speed_incompatible(dev, USB_SPEED_FULL); 1394 } 1395 if (!usbredirparser_peer_has_cap(dev->parser, 1396 usb_redir_cap_ep_info_max_packet_size) || 1397 ep_info->max_packet_size[i] > 1024) { 1398 usbredir_mark_speed_incompatible(dev, USB_SPEED_HIGH); 1399 } 1400 if (dev->endpoint[i].interval == 0) { 1401 ERROR("Received 0 interval for isoc or irq endpoint\n"); 1402 usbredir_reject_device(dev); 1403 return; 1404 } 1405 /* Fall through */ 1406 case usb_redir_type_control: 1407 case usb_redir_type_bulk: 1408 DPRINTF("ep: %02X type: %d interface: %d\n", I2EP(i), 1409 dev->endpoint[i].type, dev->endpoint[i].interface); 1410 break; 1411 default: 1412 ERROR("Received invalid endpoint type\n"); 1413 usbredir_reject_device(dev); 1414 return; 1415 } 1416 } 1417 /* The new ep info may have caused a speed incompatibility, recheck */ 1418 if (dev->dev.attached && 1419 !(dev->dev.port->speedmask & dev->dev.speedmask)) { 1420 ERROR("Device no longer matches speed after endpoint info change, " 1421 "disconnecting!\n"); 1422 usbredir_reject_device(dev); 1423 return; 1424 } 1425 usbredir_setup_usb_eps(dev); 1426 } 1427 1428 static void usbredir_configuration_status(void *priv, uint64_t id, 1429 struct usb_redir_configuration_status_header *config_status) 1430 { 1431 USBRedirDevice *dev = priv; 1432 USBPacket *p; 1433 1434 DPRINTF("set config status %d config %d id %"PRIu64"\n", 1435 config_status->status, config_status->configuration, id); 1436 1437 p = usbredir_find_packet_by_id(dev, 0, id); 1438 if (p) { 1439 if (dev->dev.setup_buf[0] & USB_DIR_IN) { 1440 dev->dev.data_buf[0] = config_status->configuration; 1441 p->actual_length = 1; 1442 } 1443 usbredir_handle_status(dev, p, config_status->status); 1444 usb_generic_async_ctrl_complete(&dev->dev, p); 1445 } 1446 } 1447 1448 static void usbredir_alt_setting_status(void *priv, uint64_t id, 1449 struct usb_redir_alt_setting_status_header *alt_setting_status) 1450 { 1451 USBRedirDevice *dev = priv; 1452 USBPacket *p; 1453 1454 DPRINTF("alt status %d intf %d alt %d id: %"PRIu64"\n", 1455 alt_setting_status->status, alt_setting_status->interface, 1456 alt_setting_status->alt, id); 1457 1458 p = usbredir_find_packet_by_id(dev, 0, id); 1459 if (p) { 1460 if (dev->dev.setup_buf[0] & USB_DIR_IN) { 1461 dev->dev.data_buf[0] = alt_setting_status->alt; 1462 p->actual_length = 1; 1463 } 1464 usbredir_handle_status(dev, p, alt_setting_status->status); 1465 usb_generic_async_ctrl_complete(&dev->dev, p); 1466 } 1467 } 1468 1469 static void usbredir_iso_stream_status(void *priv, uint64_t id, 1470 struct usb_redir_iso_stream_status_header *iso_stream_status) 1471 { 1472 USBRedirDevice *dev = priv; 1473 uint8_t ep = iso_stream_status->endpoint; 1474 1475 DPRINTF("iso status %d ep %02X id %"PRIu64"\n", iso_stream_status->status, 1476 ep, id); 1477 1478 if (!dev->dev.attached || !dev->endpoint[EP2I(ep)].iso_started) { 1479 return; 1480 } 1481 1482 dev->endpoint[EP2I(ep)].iso_error = iso_stream_status->status; 1483 if (iso_stream_status->status == usb_redir_stall) { 1484 DPRINTF("iso stream stopped by peer ep %02X\n", ep); 1485 dev->endpoint[EP2I(ep)].iso_started = 0; 1486 } 1487 } 1488 1489 static void usbredir_interrupt_receiving_status(void *priv, uint64_t id, 1490 struct usb_redir_interrupt_receiving_status_header 1491 *interrupt_receiving_status) 1492 { 1493 USBRedirDevice *dev = priv; 1494 uint8_t ep = interrupt_receiving_status->endpoint; 1495 1496 DPRINTF("interrupt recv status %d ep %02X id %"PRIu64"\n", 1497 interrupt_receiving_status->status, ep, id); 1498 1499 if (!dev->dev.attached || !dev->endpoint[EP2I(ep)].interrupt_started) { 1500 return; 1501 } 1502 1503 dev->endpoint[EP2I(ep)].interrupt_error = 1504 interrupt_receiving_status->status; 1505 if (interrupt_receiving_status->status == usb_redir_stall) { 1506 DPRINTF("interrupt receiving stopped by peer ep %02X\n", ep); 1507 dev->endpoint[EP2I(ep)].interrupt_started = 0; 1508 } 1509 } 1510 1511 static void usbredir_bulk_streams_status(void *priv, uint64_t id, 1512 struct usb_redir_bulk_streams_status_header *bulk_streams_status) 1513 { 1514 } 1515 1516 static void usbredir_control_packet(void *priv, uint64_t id, 1517 struct usb_redir_control_packet_header *control_packet, 1518 uint8_t *data, int data_len) 1519 { 1520 USBRedirDevice *dev = priv; 1521 USBPacket *p; 1522 int len = control_packet->length; 1523 1524 DPRINTF("ctrl-in status %d len %d id %"PRIu64"\n", control_packet->status, 1525 len, id); 1526 1527 /* Fix up USB-3 ep0 maxpacket size to allow superspeed connected devices 1528 * to work redirected to a not superspeed capable hcd */ 1529 if (dev->dev.speed == USB_SPEED_SUPER && 1530 !((dev->dev.port->speedmask & USB_SPEED_MASK_SUPER)) && 1531 control_packet->requesttype == 0x80 && 1532 control_packet->request == 6 && 1533 control_packet->value == 0x100 && control_packet->index == 0 && 1534 data_len >= 18 && data[7] == 9) { 1535 data[7] = 64; 1536 } 1537 1538 p = usbredir_find_packet_by_id(dev, 0, id); 1539 if (p) { 1540 usbredir_handle_status(dev, p, control_packet->status); 1541 if (data_len > 0) { 1542 usbredir_log_data(dev, "ctrl data in:", data, data_len); 1543 if (data_len > sizeof(dev->dev.data_buf)) { 1544 ERROR("ctrl buffer too small (%d > %zu)\n", 1545 data_len, sizeof(dev->dev.data_buf)); 1546 p->status = USB_RET_STALL; 1547 data_len = len = sizeof(dev->dev.data_buf); 1548 } 1549 memcpy(dev->dev.data_buf, data, data_len); 1550 } 1551 p->actual_length = len; 1552 usb_generic_async_ctrl_complete(&dev->dev, p); 1553 } 1554 free(data); 1555 } 1556 1557 static void usbredir_bulk_packet(void *priv, uint64_t id, 1558 struct usb_redir_bulk_packet_header *bulk_packet, 1559 uint8_t *data, int data_len) 1560 { 1561 USBRedirDevice *dev = priv; 1562 uint8_t ep = bulk_packet->endpoint; 1563 int len = (bulk_packet->length_high << 16) | bulk_packet->length; 1564 USBPacket *p; 1565 1566 DPRINTF("bulk-in status %d ep %02X len %d id %"PRIu64"\n", 1567 bulk_packet->status, ep, len, id); 1568 1569 p = usbredir_find_packet_by_id(dev, ep, id); 1570 if (p) { 1571 size_t size = (p->combined) ? p->combined->iov.size : p->iov.size; 1572 usbredir_handle_status(dev, p, bulk_packet->status); 1573 if (data_len > 0) { 1574 usbredir_log_data(dev, "bulk data in:", data, data_len); 1575 if (data_len > size) { 1576 ERROR("bulk got more data then requested (%d > %zd)\n", 1577 data_len, p->iov.size); 1578 p->status = USB_RET_BABBLE; 1579 data_len = len = size; 1580 } 1581 if (p->combined) { 1582 iov_from_buf(p->combined->iov.iov, p->combined->iov.niov, 1583 0, data, data_len); 1584 } else { 1585 usb_packet_copy(p, data, data_len); 1586 } 1587 } 1588 p->actual_length = len; 1589 if (p->pid == USB_TOKEN_IN && p->ep->pipeline) { 1590 usb_combined_input_packet_complete(&dev->dev, p); 1591 } else { 1592 usb_packet_complete(&dev->dev, p); 1593 } 1594 } 1595 free(data); 1596 } 1597 1598 static void usbredir_iso_packet(void *priv, uint64_t id, 1599 struct usb_redir_iso_packet_header *iso_packet, 1600 uint8_t *data, int data_len) 1601 { 1602 USBRedirDevice *dev = priv; 1603 uint8_t ep = iso_packet->endpoint; 1604 1605 DPRINTF2("iso-in status %d ep %02X len %d id %"PRIu64"\n", 1606 iso_packet->status, ep, data_len, id); 1607 1608 if (dev->endpoint[EP2I(ep)].type != USB_ENDPOINT_XFER_ISOC) { 1609 ERROR("received iso packet for non iso endpoint %02X\n", ep); 1610 free(data); 1611 return; 1612 } 1613 1614 if (dev->endpoint[EP2I(ep)].iso_started == 0) { 1615 DPRINTF("received iso packet for non started stream ep %02X\n", ep); 1616 free(data); 1617 return; 1618 } 1619 1620 /* bufp_alloc also adds the packet to the ep queue */ 1621 bufp_alloc(dev, data, data_len, iso_packet->status, ep); 1622 } 1623 1624 static void usbredir_interrupt_packet(void *priv, uint64_t id, 1625 struct usb_redir_interrupt_packet_header *interrupt_packet, 1626 uint8_t *data, int data_len) 1627 { 1628 USBRedirDevice *dev = priv; 1629 uint8_t ep = interrupt_packet->endpoint; 1630 1631 DPRINTF("interrupt-in status %d ep %02X len %d id %"PRIu64"\n", 1632 interrupt_packet->status, ep, data_len, id); 1633 1634 if (dev->endpoint[EP2I(ep)].type != USB_ENDPOINT_XFER_INT) { 1635 ERROR("received int packet for non interrupt endpoint %02X\n", ep); 1636 free(data); 1637 return; 1638 } 1639 1640 if (ep & USB_DIR_IN) { 1641 if (dev->endpoint[EP2I(ep)].interrupt_started == 0) { 1642 DPRINTF("received int packet while not started ep %02X\n", ep); 1643 free(data); 1644 return; 1645 } 1646 1647 /* bufp_alloc also adds the packet to the ep queue */ 1648 bufp_alloc(dev, data, data_len, interrupt_packet->status, ep); 1649 } else { 1650 /* 1651 * We report output interrupt packets as completed directly upon 1652 * submission, so all we can do here if one failed is warn. 1653 */ 1654 if (interrupt_packet->status) { 1655 WARNING("interrupt output failed status %d ep %02X id %"PRIu64"\n", 1656 interrupt_packet->status, ep, id); 1657 } 1658 } 1659 } 1660 1661 /* 1662 * Migration code 1663 */ 1664 1665 static void usbredir_pre_save(void *priv) 1666 { 1667 USBRedirDevice *dev = priv; 1668 1669 usbredir_fill_already_in_flight(dev); 1670 } 1671 1672 static int usbredir_post_load(void *priv, int version_id) 1673 { 1674 USBRedirDevice *dev = priv; 1675 1676 switch (dev->device_info.speed) { 1677 case usb_redir_speed_low: 1678 dev->dev.speed = USB_SPEED_LOW; 1679 break; 1680 case usb_redir_speed_full: 1681 dev->dev.speed = USB_SPEED_FULL; 1682 break; 1683 case usb_redir_speed_high: 1684 dev->dev.speed = USB_SPEED_HIGH; 1685 break; 1686 case usb_redir_speed_super: 1687 dev->dev.speed = USB_SPEED_SUPER; 1688 break; 1689 default: 1690 dev->dev.speed = USB_SPEED_FULL; 1691 } 1692 dev->dev.speedmask = (1 << dev->dev.speed); 1693 1694 usbredir_setup_usb_eps(dev); 1695 1696 return 0; 1697 } 1698 1699 /* For usbredirparser migration */ 1700 static void usbredir_put_parser(QEMUFile *f, void *priv, size_t unused) 1701 { 1702 USBRedirDevice *dev = priv; 1703 uint8_t *data; 1704 int len; 1705 1706 if (dev->parser == NULL) { 1707 qemu_put_be32(f, 0); 1708 return; 1709 } 1710 1711 usbredirparser_serialize(dev->parser, &data, &len); 1712 qemu_oom_check(data); 1713 1714 qemu_put_be32(f, len); 1715 qemu_put_buffer(f, data, len); 1716 1717 free(data); 1718 } 1719 1720 static int usbredir_get_parser(QEMUFile *f, void *priv, size_t unused) 1721 { 1722 USBRedirDevice *dev = priv; 1723 uint8_t *data; 1724 int len, ret; 1725 1726 len = qemu_get_be32(f); 1727 if (len == 0) { 1728 return 0; 1729 } 1730 1731 /* 1732 * If our chardev is not open already at this point the usbredir connection 1733 * has been broken (non seamless migration, or restore from disk). 1734 * 1735 * In this case create a temporary parser to receive the migration data, 1736 * and schedule the close_bh to report the device as disconnected to the 1737 * guest and to destroy the parser again. 1738 */ 1739 if (dev->parser == NULL) { 1740 WARNING("usb-redir connection broken during migration\n"); 1741 usbredir_create_parser(dev); 1742 qemu_bh_schedule(dev->chardev_close_bh); 1743 } 1744 1745 data = g_malloc(len); 1746 qemu_get_buffer(f, data, len); 1747 1748 ret = usbredirparser_unserialize(dev->parser, data, len); 1749 1750 g_free(data); 1751 1752 return ret; 1753 } 1754 1755 static const VMStateInfo usbredir_parser_vmstate_info = { 1756 .name = "usb-redir-parser", 1757 .put = usbredir_put_parser, 1758 .get = usbredir_get_parser, 1759 }; 1760 1761 1762 /* For buffered packets (iso/irq) queue migration */ 1763 static void usbredir_put_bufpq(QEMUFile *f, void *priv, size_t unused) 1764 { 1765 struct endp_data *endp = priv; 1766 struct buf_packet *bufp; 1767 int remain = endp->bufpq_size; 1768 1769 qemu_put_be32(f, endp->bufpq_size); 1770 QTAILQ_FOREACH(bufp, &endp->bufpq, next) { 1771 qemu_put_be32(f, bufp->len); 1772 qemu_put_be32(f, bufp->status); 1773 qemu_put_buffer(f, bufp->data, bufp->len); 1774 remain--; 1775 } 1776 assert(remain == 0); 1777 } 1778 1779 static int usbredir_get_bufpq(QEMUFile *f, void *priv, size_t unused) 1780 { 1781 struct endp_data *endp = priv; 1782 struct buf_packet *bufp; 1783 int i; 1784 1785 endp->bufpq_size = qemu_get_be32(f); 1786 for (i = 0; i < endp->bufpq_size; i++) { 1787 bufp = g_malloc(sizeof(struct buf_packet)); 1788 bufp->len = qemu_get_be32(f); 1789 bufp->status = qemu_get_be32(f); 1790 bufp->data = qemu_oom_check(malloc(bufp->len)); /* regular malloc! */ 1791 qemu_get_buffer(f, bufp->data, bufp->len); 1792 QTAILQ_INSERT_TAIL(&endp->bufpq, bufp, next); 1793 } 1794 return 0; 1795 } 1796 1797 static const VMStateInfo usbredir_ep_bufpq_vmstate_info = { 1798 .name = "usb-redir-bufpq", 1799 .put = usbredir_put_bufpq, 1800 .get = usbredir_get_bufpq, 1801 }; 1802 1803 1804 /* For endp_data migration */ 1805 static const VMStateDescription usbredir_ep_vmstate = { 1806 .name = "usb-redir-ep", 1807 .version_id = 1, 1808 .minimum_version_id = 1, 1809 .fields = (VMStateField[]) { 1810 VMSTATE_UINT8(type, struct endp_data), 1811 VMSTATE_UINT8(interval, struct endp_data), 1812 VMSTATE_UINT8(interface, struct endp_data), 1813 VMSTATE_UINT16(max_packet_size, struct endp_data), 1814 VMSTATE_UINT8(iso_started, struct endp_data), 1815 VMSTATE_UINT8(iso_error, struct endp_data), 1816 VMSTATE_UINT8(interrupt_started, struct endp_data), 1817 VMSTATE_UINT8(interrupt_error, struct endp_data), 1818 VMSTATE_UINT8(bufpq_prefilled, struct endp_data), 1819 VMSTATE_UINT8(bufpq_dropping_packets, struct endp_data), 1820 { 1821 .name = "bufpq", 1822 .version_id = 0, 1823 .field_exists = NULL, 1824 .size = 0, 1825 .info = &usbredir_ep_bufpq_vmstate_info, 1826 .flags = VMS_SINGLE, 1827 .offset = 0, 1828 }, 1829 VMSTATE_INT32(bufpq_target_size, struct endp_data), 1830 VMSTATE_END_OF_LIST() 1831 } 1832 }; 1833 1834 1835 /* For PacketIdQueue migration */ 1836 static void usbredir_put_packet_id_q(QEMUFile *f, void *priv, size_t unused) 1837 { 1838 struct PacketIdQueue *q = priv; 1839 USBRedirDevice *dev = q->dev; 1840 struct PacketIdQueueEntry *e; 1841 int remain = q->size; 1842 1843 DPRINTF("put_packet_id_q %s size %d\n", q->name, q->size); 1844 qemu_put_be32(f, q->size); 1845 QTAILQ_FOREACH(e, &q->head, next) { 1846 qemu_put_be64(f, e->id); 1847 remain--; 1848 } 1849 assert(remain == 0); 1850 } 1851 1852 static int usbredir_get_packet_id_q(QEMUFile *f, void *priv, size_t unused) 1853 { 1854 struct PacketIdQueue *q = priv; 1855 USBRedirDevice *dev = q->dev; 1856 int i, size; 1857 uint64_t id; 1858 1859 size = qemu_get_be32(f); 1860 DPRINTF("get_packet_id_q %s size %d\n", q->name, size); 1861 for (i = 0; i < size; i++) { 1862 id = qemu_get_be64(f); 1863 packet_id_queue_add(q, id); 1864 } 1865 assert(q->size == size); 1866 return 0; 1867 } 1868 1869 static const VMStateInfo usbredir_ep_packet_id_q_vmstate_info = { 1870 .name = "usb-redir-packet-id-q", 1871 .put = usbredir_put_packet_id_q, 1872 .get = usbredir_get_packet_id_q, 1873 }; 1874 1875 static const VMStateDescription usbredir_ep_packet_id_queue_vmstate = { 1876 .name = "usb-redir-packet-id-queue", 1877 .version_id = 1, 1878 .minimum_version_id = 1, 1879 .fields = (VMStateField[]) { 1880 { 1881 .name = "queue", 1882 .version_id = 0, 1883 .field_exists = NULL, 1884 .size = 0, 1885 .info = &usbredir_ep_packet_id_q_vmstate_info, 1886 .flags = VMS_SINGLE, 1887 .offset = 0, 1888 }, 1889 VMSTATE_END_OF_LIST() 1890 } 1891 }; 1892 1893 1894 /* For usb_redir_device_connect_header migration */ 1895 static const VMStateDescription usbredir_device_info_vmstate = { 1896 .name = "usb-redir-device-info", 1897 .version_id = 1, 1898 .minimum_version_id = 1, 1899 .fields = (VMStateField[]) { 1900 VMSTATE_UINT8(speed, struct usb_redir_device_connect_header), 1901 VMSTATE_UINT8(device_class, struct usb_redir_device_connect_header), 1902 VMSTATE_UINT8(device_subclass, struct usb_redir_device_connect_header), 1903 VMSTATE_UINT8(device_protocol, struct usb_redir_device_connect_header), 1904 VMSTATE_UINT16(vendor_id, struct usb_redir_device_connect_header), 1905 VMSTATE_UINT16(product_id, struct usb_redir_device_connect_header), 1906 VMSTATE_UINT16(device_version_bcd, 1907 struct usb_redir_device_connect_header), 1908 VMSTATE_END_OF_LIST() 1909 } 1910 }; 1911 1912 1913 /* For usb_redir_interface_info_header migration */ 1914 static const VMStateDescription usbredir_interface_info_vmstate = { 1915 .name = "usb-redir-interface-info", 1916 .version_id = 1, 1917 .minimum_version_id = 1, 1918 .fields = (VMStateField[]) { 1919 VMSTATE_UINT32(interface_count, 1920 struct usb_redir_interface_info_header), 1921 VMSTATE_UINT8_ARRAY(interface, 1922 struct usb_redir_interface_info_header, 32), 1923 VMSTATE_UINT8_ARRAY(interface_class, 1924 struct usb_redir_interface_info_header, 32), 1925 VMSTATE_UINT8_ARRAY(interface_subclass, 1926 struct usb_redir_interface_info_header, 32), 1927 VMSTATE_UINT8_ARRAY(interface_protocol, 1928 struct usb_redir_interface_info_header, 32), 1929 VMSTATE_END_OF_LIST() 1930 } 1931 }; 1932 1933 1934 /* And finally the USBRedirDevice vmstate itself */ 1935 static const VMStateDescription usbredir_vmstate = { 1936 .name = "usb-redir", 1937 .version_id = 1, 1938 .minimum_version_id = 1, 1939 .pre_save = usbredir_pre_save, 1940 .post_load = usbredir_post_load, 1941 .fields = (VMStateField[]) { 1942 VMSTATE_USB_DEVICE(dev, USBRedirDevice), 1943 VMSTATE_TIMER(attach_timer, USBRedirDevice), 1944 { 1945 .name = "parser", 1946 .version_id = 0, 1947 .field_exists = NULL, 1948 .size = 0, 1949 .info = &usbredir_parser_vmstate_info, 1950 .flags = VMS_SINGLE, 1951 .offset = 0, 1952 }, 1953 VMSTATE_STRUCT_ARRAY(endpoint, USBRedirDevice, MAX_ENDPOINTS, 1, 1954 usbredir_ep_vmstate, struct endp_data), 1955 VMSTATE_STRUCT(cancelled, USBRedirDevice, 1, 1956 usbredir_ep_packet_id_queue_vmstate, 1957 struct PacketIdQueue), 1958 VMSTATE_STRUCT(already_in_flight, USBRedirDevice, 1, 1959 usbredir_ep_packet_id_queue_vmstate, 1960 struct PacketIdQueue), 1961 VMSTATE_STRUCT(device_info, USBRedirDevice, 1, 1962 usbredir_device_info_vmstate, 1963 struct usb_redir_device_connect_header), 1964 VMSTATE_STRUCT(interface_info, USBRedirDevice, 1, 1965 usbredir_interface_info_vmstate, 1966 struct usb_redir_interface_info_header), 1967 VMSTATE_END_OF_LIST() 1968 } 1969 }; 1970 1971 static Property usbredir_properties[] = { 1972 DEFINE_PROP_CHR("chardev", USBRedirDevice, cs), 1973 DEFINE_PROP_UINT8("debug", USBRedirDevice, debug, usbredirparser_warning), 1974 DEFINE_PROP_STRING("filter", USBRedirDevice, filter_str), 1975 DEFINE_PROP_INT32("bootindex", USBRedirDevice, bootindex, -1), 1976 DEFINE_PROP_END_OF_LIST(), 1977 }; 1978 1979 static void usbredir_class_initfn(ObjectClass *klass, void *data) 1980 { 1981 USBDeviceClass *uc = USB_DEVICE_CLASS(klass); 1982 DeviceClass *dc = DEVICE_CLASS(klass); 1983 1984 uc->init = usbredir_initfn; 1985 uc->product_desc = "USB Redirection Device"; 1986 uc->handle_destroy = usbredir_handle_destroy; 1987 uc->cancel_packet = usbredir_cancel_packet; 1988 uc->handle_reset = usbredir_handle_reset; 1989 uc->handle_data = usbredir_handle_data; 1990 uc->handle_control = usbredir_handle_control; 1991 uc->flush_ep_queue = usbredir_flush_ep_queue; 1992 dc->vmsd = &usbredir_vmstate; 1993 dc->props = usbredir_properties; 1994 } 1995 1996 static TypeInfo usbredir_dev_info = { 1997 .name = "usb-redir", 1998 .parent = TYPE_USB_DEVICE, 1999 .instance_size = sizeof(USBRedirDevice), 2000 .class_init = usbredir_class_initfn, 2001 }; 2002 2003 static void usbredir_register_types(void) 2004 { 2005 type_register_static(&usbredir_dev_info); 2006 } 2007 2008 type_init(usbredir_register_types) 2009