USB Passthrough Not Working in QEMU? What Are Common Mistakes (And How to Fix Them)

Published 19 November 2025

When a USB device fails to appear in a QEMU guest VM despite explicit configuration, the frustration is palpable. The error messages—"Device 0 (virtserial0) is already in use" or "Permission denied"—mask deeper issues: kernel-level conflicts, missing drivers, or misconfigured virtualization parameters. These problems aren’t just technical quirks; they stem from QEMU’s intricate interplay with the host’s USB stack, PCIe assignment, and permissions framework. The root cause often lies in overlooked details: a forgotten `-device` flag, an unloaded `vfio-pci` module, or a guest OS lacking the necessary USB stack. Even seasoned virtualization engineers overlook these pitfalls, leading to hours spent chasing symptoms rather than solutions.

The irony is that QEMU’s USB passthrough is supposed to be straightforward—directly exposing a physical USB port to a VM with minimal overhead. Yet, in practice, it’s a minefield of edge cases. A single misconfigured `libvirt` XML snippet or an unpatched kernel can render even a high-end USB 3.1 controller useless in the guest. The most critical oversight? Assuming the host’s USB controller is compatible with QEMU’s emulation layer. Some controllers (like Intel’s XHCI) require specific kernel parameters or firmware quirks to function correctly. Without these, the passthrough fails silently, leaving admins to guess whether the issue lies in the hardware, the hypervisor, or the guest’s USB stack.

The Complete Overview of USB Passthrough in QEMU

The complexity arises from QEMU’s dual role: it must both emulate USB controllers for the guest and manage passthrough for physical devices. For example, a USB 3.0 device requires the host’s XHCI controller to be passed through, but if the guest lacks the appropriate USB 3.0 drivers (or if the controller isn’t properly reset), the device will appear as a generic USB 2.0 peripheral—or not at all. Even the order of operations matters: attaching a USB device after the VM starts won’t work unless QEMU is configured with `-usbdevice` dynamically, which most setups avoid for stability reasons.

Historical Background and Evolution

By 2015, libvirt integrated native USB passthrough support via `` tags, simplifying the process but introducing new quirks—such as automatic device detachment when the host unplugs the USB device. Modern QEMU (v6.0+) now supports USB 3.2 and Thunderbolt passthrough, but these features remain niche due to driver limitations in guest OSes. The evolution reflects a broader trend: virtualization tools are catching up to hardware capabilities, but the gap between theory and practice persists, especially for USB passthrough.

Core Mechanisms: How It Works

The process involves three stages:
1. Host Preparation: The USB controller and its child devices (e.g., USB ports) are unbound from their default drivers (e.g., `xhci_hcd`) and bound to `vfio-pci`. This requires:
```bash
echo "0000:00:14.0" > /sys/bus/pci/drivers/xhci_hcd/unbind
echo "vfio-pci" > /sys/bus/pci/devices/0000:00:14.0/driver_override
```
2. QEMU Configuration: The VM is launched with the controller passed through:
```bash
qemu-system-x86_64 ... -device vfio-pci,host=0000:00:14.0
```
3. Guest OS Handling: The guest must recognize the controller (e.g., via `lsusb` or `dmesg`). If the guest lacks drivers (e.g., Windows without USB 3.0 support), the device will fail to initialize.

The catch? USB hubs and composite devices (e.g., a USB-C dock with Ethernet) often require additional steps, such as passing through the entire PCIe hierarchy or manually resetting the hub in the guest.

Key Benefits and Crucial Impact

The impact extends to security and compliance testing. Penetration testers can emulate USB-based attacks (e.g., BadUSB) in a controlled VM environment, while compliance teams can verify USB storage devices against encryption standards without risking host contamination.

"USB passthrough in QEMU bridges the gap between virtual and physical hardware, but the devil is in the details—often, the difference between success and failure isn’t the tool itself, but the user’s understanding of the underlying hardware quirks." — Michael DeHaan, Virtualization Architect

Major Advantages

• Hardware Agnosticism: Test USB devices on any guest OS without physical machine constraints.
• Cost Efficiency: Eliminate the need for dedicated hardware for each test scenario.
• Dynamic Device Assignment: Hot-plug USB devices into running VMs (with proper QEMU flags).
• Legacy Support: Run ancient USB 1.1 devices in modern VMs without host driver conflicts.
• Security Isolation: Contain USB-based malware in VMs without exposing the host.

Comparative Analysis

Future Trends and Innovations

Another trend is containerized USB passthrough, where tools like `firecracker` or `kata-containers` integrate USB redirection into lightweight runtimes. This could democratize USB testing for cloud-native applications, though security implications (e.g., container escape via USB) remain unresolved.

Conclusion

For most users, the fix lies in three critical areas:
1. Kernel and IOMMU: Ensure `vfio-pci` is loaded and IOMMU is enabled (`intel_iommu=on` or `amd_iommu=on`).
2. QEMU Flags: Use `-device vfio-pci` for controllers and `-usbdevice` for specific devices.
3. Guest Drivers: Confirm the guest OS has the necessary USB stack (e.g., Windows USB 3.0 drivers).

Comprehensive FAQs

Q: Why does my USB device appear in `lsusb` but not in the QEMU guest?

The device might be bound to the wrong kernel driver (e.g., `usb-storage`). Unbind it from its current driver and bind it to `vfio-pci`:
```bash
echo "1-1.2" > /sys/bus/usb/drivers/usb-storage/unbind
echo "vfio-pci" > /sys/bus/usb/devices/1-1.2/driver_override
```
If the device is a child of a USB hub, you may need to pass through the entire hub.

Q: How do I pass through a USB 3.0 device if the guest OS doesn’t support it?

Use `-device usb-ehci` (for USB 2.0 emulation) alongside the passthrough controller. Example:
```bash
qemu-system-x86_64 ... -device vfio-pci,host=0000:00:14.0 -device usb-ehci
```
This forces the guest to use a compatible USB 2.0 controller while still accessing the physical USB 3.0 device.

Q: My USB passthrough works in one VM but fails in another. Why?

Check for conflicting `vfio-pci` bindings or differing kernel parameters. Run `dmesg | grep vfio` after launching the failing VM to identify binding errors. Also, ensure the guest’s USB stack isn’t conflicting with the host’s (e.g., Windows Fast Startup can lock USB controllers).

Q: Can I pass through a USB hub with multiple devices?

Yes, but you must pass through the entire PCIe hierarchy or manually bind each child device to `vfio-pci`. For example:
```bash

Bind the hub and its children

Q: What if my USB device requires firmware (e.g., a custom gadget)?

Load the firmware in the guest before attaching the device. For Linux guests, use:
```bash
echo "0x1234 0x5678" > /sys/bus/usb/drivers/usb/firmware
```
Replace `0x1234` and `0x5678` with the vendor and product IDs from `lsusb`. For Windows, install the firmware driver manually in the guest.

Q: How do I debug USB passthrough issues in QEMU?

Use these commands:

• KVM USB troubleshooting
• Linux USB redirection
• QEMU USB passthrough
• USB device assignment failures
• virtualization USB issues