vfio-user client
v4 cover vfio-user client
Hello,
This is the 4th revision of the vfio-user client implementation.
First of all, thank you for your time reviewing the previous versions.
The vfio-user framework consists of 3 parts:
1) The VFIO user protocol specification.
2) A client - the VFIO device in QEMU that encapsulates VFIO messages and sends them to the server.
3) A server - a remote process that emulates a device.
This patchset implements parts 1 and 2.
The libvfio-user project (https://github.com/nutanix/libvfio-user)
can be used by a remote process to handle the protocol to implement the third part. We also have sent a patch series that implement a server using QEMU.
Contributors:
John G Johnson <[email protected]>
John Levon <[email protected]>
Thanos Makatos <[email protected]>
Elena Ufimtseva <[email protected]>
Jagannathan Raman <[email protected]>
Changes from v3->v4:
vfio-user: introduce vfio-user protocol specification
No v4 specific changess
vfio-user: add VFIO base abstract class
Put all properties except those specific to the ioctl() implementation in the base class
vfio-user: add container IO ops vector
Move will_commit support to dma map/unmap patch below Use ternary return expression in IO ops vectors
vfio-user: add region cache
New patch with only region cache support
Make vfio_get_region_info return region reference instead of a copy
vfio-user: add device IO ops vector
Move posted write support to region read/write patch below
Move FD receiving code to get region info patch below
Add VDEV_CONFIG_READ/WRITE macros to pci.c for convenient access to PCI config space Use ternary return expression in IO ops vectors
vfio-user: Define type vfio_user_pci_dev_info
Move secure DMA support to separate patch below
Remove dummy function for vfio_hot_reset_multi ops vector Add vfio_user_instance_finalize code from connect proxy patch below
vfio-user: connect vfio proxy to remote server
Move vfio_user_instance_finalize code to define type patch above
vfio-user: define socket receive functions
Handle kernel splitting message from server into multiple read()s Fix incoming message queue handling in vfio_user_request() Move secure DMA support to separate patch below
Move MAX_FDS and MAX_XFER defines to socket send patch below
vfio-user: define socket send functions
Free pending messages when the reply times out
Add MAX_FDS and MAX_XFER defines from socket recv patch above Don't set error twice on a capabilities parsing error
vfio-user: get device info
Add vfio_get_all_regions() call
Validate device info return values from server
vfio-user: get region info
Add FD receiving code from device IO ops patch above Add a generic FD to VFIORegion for mapping device regions Validate region info return values from server
vfio-user: region read/write
Add posted write support from device IO ops patch above Check region read/write count against max_xfer
vfio-user: pci_user_realize PCI setup
Refactor realize functions to use common setup functions
vfio-user: get and set IRQs
Validate irq return values from server
vfio-user: proxy container connect/disconnect
No v4 specific changes
vfio-user: dma map/unmap operations
Add wlll_commit support from container IO ops patch above Rename will_commit to async_ops to describe its operation better Pass memory region to dma_map op so only vfio-user needs to look up FD Free pending messages when the reply times out
Move secure DMA support to separate patch below
Set argz in dma_unmap message according to spec
vfio-user: secure DMA support
New patch consolidating all secure DMA support
vfio-user: dma read/write operations
vfio-user: pci reset
No v4 specific changes
vfio-user: migration support
Move qemu file errors fix to its own patch below Set argz in get_dirty_bitmap message according to spec
Only set qemu file error if saving state if the file exists
New patch with just this fix found during vfio-user development
Removed from v4:
Add validation ops vector
Generic checking moved to the corresponding vfio-user function
Changes from v2->v3:
John Johnson (18):
vfio-user: add VFIO base abstract class
Moved common vfio pci cli options to base class
Add container IO ops vector
Added ops vectors to decide to use ioctl() or socket implementation
Add device IO ops vector
Added ops vectors to decide to use ioctl() or socket implementation
Add validation ops vector
Added validation vector to check user replies
vfio-user: Define type vfio_user_pci_dev_info
Added separate VFIO_USER_PCI config element to control whether vfio-user is compiled Fix scalar spelling
vfio-user: connect vfio proxy to remote server
Made socket IO non-blocking
Use g_strdup_printf to save socket name
vfio-user: define socket receive functions
Made socket IO non-blocking
Process inbound commands in main loop thread to avoid BQL interactions with recv Added comment describing inbound command callback usage
Use true/false instead of 1/0 for booleans
vfio-user: define socket send functions
Made socket IO non-blocking
Added version string NULL termination check
vfio-user: get device info
Added ops vectors to decide to use ioctl() or socket implementation Added validation vector to check user replies
vfio-user: get region info
Added ops vectors to decide to use ioctl() or socket implementation Added validation vector to check user replies
Remove merge bug that filled region cache twice
vfio-user: region read/write
Added ops vectors to decide to use ioctl() or socket implementation Added validation vector to check user replies
Made posted write conditional on region not mapped
vfio-user: pci_user_realize PCI setup
Moved common vfio pci cli options to base class
vfio-user: get and set IRQs
Added ops vectors to decide to use ioctl() or socket implementation Added validation vector to check user replies
Fixed %m usage when not using syscall
vfio-user: proxy container connect/disconnect
Added separate VFIO_USER_PCI config element to control whether vfio-user is compiled Use true/false instead of 1/0 for booleans
vfio-user: dma map/unmap operations
Added ops vectors to decide to use ioctl() or socket implementation Use BQL instead of iolock in comments
Fixed %m usage when not using syscall
vfio-user: dma read/write operations
Added header checking before loading DMA message content Added error handling if DMA fails
vfio-user: pci reset
no r3-specific changes
vfio-user: migration support
generic fix: only set qemu file error if there is a file
Thanos Makatos (1):
vfio-user: introduce vfio-user protocol specification
Spec specifies host endiannes instead of always LE Fixed grammar error
docs/devel/index.rst | 1 + docs/devel/vfio-user.rst | 1810 +++++++++++++++++++++++++++++++++++++++++ hw/vfio/pci.h | 27 +- hw/vfio/user-protocol.h | 221 +++++ hw/vfio/user.h | 96 +++ include/hw/vfio/vfio-common.h | 73 ++ hw/vfio/ccw.c | 5 - hw/vfio/common.c | 477 +++++++++-- hw/vfio/migration.c | 34 +- hw/vfio/pci-quirks.c | 19 +- hw/vfio/pci.c | 856 ++++++++++++++----- hw/vfio/user.c | 1596 ++++++++++++++++++++++++++++++++++++ MAINTAINERS | 11 + hw/vfio/Kconfig | 10 + hw/vfio/meson.build | 1 + 15 files changed, 4919 insertions(+), 318 deletions(-) create mode 100644 docs/devel/vfio-user.rst create mode 100644 hw/vfio/user-protocol.h create mode 100644 hw/vfio/user.h create mode 100644 hw/vfio/user.c
Signature · 1 line
1.8.3.1
RFC v4 1/21 vfio-user: introduce vfio-user protocol specification
From: Thanos Makatos <[email protected]>
This patch introduces the vfio-user protocol specification (formerly known as VFIO-over-socket), which is designed to allow devices to be emulated outside QEMU, in a separate process. vfio-user reuses the existing VFIO defines, structs and concepts.
It has been earlier discussed as an RFC in:
"RFC: use VFIO over a UNIX domain socket to implement device offloading"
--- docs/devel/index.rst | 1 + docs/devel/vfio-user.rst | 1810 ++++++++++++++++++++++++++++++++++++++++++++++ MAINTAINERS | 6 + 3 files changed, 1817 insertions(+) create mode 100644 docs/devel/vfio-user.rst
docs/devel/index.rst +1 -0
@@ -48,3 +48,4 @@ modifying QEMU's source code. trivial-patches submitting-a-patch submitting-a-pull-request + vfio-user
docs/devel/vfio-user.rst new file +1810 -0
1,810 lines not on this page · raw message
MAINTAINERS +6 -0
@@ -1900,6 +1900,12 @@ F: hw/vfio/ap.c F: docs/system/s390x/vfio-ap.rst L: [email protected] +vfio-user +M: John G Johnson <[email protected]> +M: Thanos Makatos <[email protected]> +S: Supported +F: docs/devel/vfio-user.rst + vhost M: Michael S. Tsirkin <[email protected]> S: Supported
Signature · 1 line
1.8.3.1
RE: [RFC v4 01/21] vfio-user: introduce vfio-user protocol specification
Quoted 1,846 lines
-----Original Message-----
From: Qemu-devel <qemu-devel- [email protected]> On Behalf Of John Johnson
Sent: 12 January 2022 00:44
To: [email protected]
Subject: [RFC v4 01/21] vfio-user: introduce vfio-user protocol specificationFrom: Thanos Makatos <[email protected]>
This patch introduces the vfio-user protocol specification (formerly known as VFIO-over-socket), which is designed to allow devices to be emulated outside QEMU, in a separate process. vfio-user reuses the existing VFIO defines, structs and concepts.
It has been earlier discussed as an RFC in:
"RFC: use VFIO over a UNIX domain socket to implement device offloading"Signed-off-by John G Johnson <[email protected]>Signed-off-by Thanos Makatos <[email protected]>Signed-off-by John Levon <[email protected]>--- docs/devel/index.rst | 1 + docs/devel/vfio-user.rst | 1810 ++++++++++++++++++++++++++++++++++++++++++++++ MAINTAINERS | 6 + 3 files changed, 1817 insertions(+) create mode 100644 docs/devel/vfio-user.rstdocs/devel/index.rst +1
-0@@ -48,3 +48,4 @@ modifying QEMU's source code. trivial-patches submitting-a-patch submitting-a-pull-request + vfio-userdocs/devel/vfio-user.rst new file +21
-0@@ -0,0 +1,1810 @@ +.. include:: <isonum.txt> +******************************** +vfio-user Protocol Specification +******************************** + +-------------- +Version_ 0.9.1 +-------------- + +.. contents:: Table of Contents + +Introduction +============ +vfio-user is a protocol that allows a device to be emulated in a separate +process outside of a Virtual Machine Monitor (VMM). vfio-user devices consist +of a generic VFIO device type, living inside the VMM, which we call the client, +and the core device implementation, living outside the VMM, which we call the +server. + +The vfio-user specification is partly based on the +`Linux VFIO ioctl interface <https://urldefense.proofpoint.com/v2/url?u=https-3A__www.kernel.org_doc_html_latest_driver- 2Dapi_vfio.html&d=DwIBAg&c=s883GpUCOChKOHiocYtGcg&r=XTpYsh5Ps2zJvt w6ogtti46atk736SI4vgsJiUKIyDE&m=ngoOFuShfuAMJEVdV4gT7GrSMsClZglKPZXI UUeqln2aRgULhPnXxADWhHOl4DBy&s=9CWGM- s7UoGGB9GFCKuhOj_7UwoSttlAcxrpEWTjdYI&e= >`_.
docs/devel/vfio-user.rst new file +10
-0+ +VFIO is a mature and stable API, backed by an extensively used framework. The +existing VFIO client implementation in QEMU (``qemu/hw/vfio/``) can be largely +re-used, though there is nothing in this specification that requires that +particular implementation. None of the VFIO kernel modules are required for +supporting the protocol, on either the client or server side. Some source +definitions in VFIO are re-used for vfio-user. + +The main idea is to allow a virtual device to function in a separate process in +the same host over a UNIX domain socket. A UNIX domain socket (``AF_UNIX``)is
docs/devel/vfio-user.rst new file +10
-0+chosen because file descriptors can be trivially sent over it, which in turn +allows: + +* Sharing of client memory for DMA with the server. +* Sharing of server memory with the client for fast MMIO. +* Efficient sharing of eventfd's for triggering interrupts. + +Other socket types could be used which allow the server to run in a separate +guest in the same host (``AF_VSOCK``) or remotely (``AF_INET``). Theoretically +the underlying transport does not necessarily have to be a socket, however wedo
+not examine such alternatives. In this protocol version we focus on using a UNIXdocs/devel/vfio-user.rst new file +11
-0+domain socket and introduce basic support for the other two types of sockets +without considering performance implications. + +While passing of file descriptors is desirable for performance reasons, support +is not necessary for either the client or the server in order to implement the +protocol. There is always an in-band, message-passing fall back mechanism. + +Overview +======== + +VFIO is a framework that allows a physical device to be securely passedthrough
docs/devel/vfio-user.rst new file +3
-0+to a user space process; the device-specific kernel driver does not drive the +device at all. Typically, the user space process is a VMM and the device is +passed through to it in order to achieve high performance. VFIO provides anAPI
docs/devel/vfio-user.rst new file +6
-0+and the required functionality in the kernel. QEMU has adopted VFIO to allow a +guest to directly access physical devices, instead of emulating them in +software. + +vfio-user reuses the core VFIO concepts defined in its API, but implements them +as messages to be sent over a socket. It does not change the kernel-basedVFIO
docs/devel/vfio-user.rst new file +13
-0+in any way, in fact none of the VFIO kernel modules need to be loaded to use +vfio-user. It is also possible for the client to concurrently use the current +kernel-based VFIO for one device, and vfio-user for another device. + +VFIO Device Model +----------------- + +A device under VFIO presents a standard interface to the user process. Many of +the VFIO operations in the existing interface use the ``ioctl()`` system call, and +references to the existing interface are called the ``ioctl()`` implementation in +this document. + +The following sections describe the set of messages that implement the vfio-user
docs/devel/vfio-user.rst new file +5
-0+interface over a socket. In many cases, the messages are analogous to data +structures used in the ``ioctl()`` implementation. Messages derived from the +``ioctl()`` will have a name derived from the ``ioctl()`` command name. E.g., the +``VFIO_DEVICE_GET_INFO`` ``ioctl()`` command becomes a +``VFIO_USER_DEVICE_GET_INFO`` message. The purpose of this reuse is toshare as
docs/devel/vfio-user.rst new file +7
-0+much code as feasible with the ``ioctl()`` implementation``. + +Connection Initiation +^^^^^^^^^^^^^^^^^^^^^ + +After the client connects to the server, the initial client message is +``VFIO_USER_VERSION`` to propose a protocol version and set of capabilitiesto
docs/devel/vfio-user.rst new file +8
-0+apply to the session. The server replies with a compatible version and set of +capabilities it supports, or closes the connection if it cannot support the +advertised version. + +Device Information +^^^^^^^^^^^^^^^^^^ + +The client uses a ``VFIO_USER_DEVICE_GET_INFO`` message to query theserver for
docs/devel/vfio-user.rst new file +11
-0+information about the device. This information includes: + +* The device type and whether it supports reset (``VFIO_DEVICE_FLAGS_``), +* the number of device regions, and +* the device presents to the client the number of interrupt types the device + supports. + +Region Information +^^^^^^^^^^^^^^^^^^ + +The client uses ``VFIO_USER_DEVICE_GET_REGION_INFO`` messages to querythe
docs/devel/vfio-user.rst new file +3
-0+server for information about the device's regions. This information describes: + +* Read and write permissions, whether it can be memory mapped, and whetherit
docs/devel/vfio-user.rst new file +19
-0+ supports additional capabilities (``VFIO_REGION_INFO_CAP_``). +* Region index, size, and offset. + +When a device region can be mapped by the client, the server provides a file +descriptor which the client can ``mmap()``. The server is responsible for +polling for client updates to memory mapped regions. + +Region Capabilities +""""""""""""""""""" + +Some regions have additional capabilities that cannot be described adequately +by the region info data structure. These capabilities are returned in the +region info reply in a list similar to PCI capabilities in a PCI device's +configuration space. + +Sparse Regions +"""""""""""""" +A region can be memory-mappable in whole or in part. When only a subset of a +region can be mapped by the client, a``VFIO_REGION_INFO_CAP_SPARSE_MMAP``
docs/devel/vfio-user.rst new file +15
-0+capability is included in the region info reply. This capability describes +which portions can be mapped by the client. + +.. Note:: + For example, in a virtual NVMe controller, sparse regions can be used so + that accesses to the NVMe registers (found in the beginning of BAR0) are + trapped (an infrequent event), while allowing direct access to the doorbells + (an extremely frequent event as every I/O submission requires a write to + BAR0), found in the next page after the NVMe registers in BAR0. + +Device-Specific Regions +""""""""""""""""""""""" + +A device can define regions additional to the standard ones (e.g. PCI indexes +0-8). This is achieved by including a ``VFIO_REGION_INFO_CAP_TYPE``capability
docs/devel/vfio-user.rst new file +9
-0+in the region info reply of a device-specific region. Such regions are reflected +in ``struct vfio_user_device_info.num_regions``. Thus, for PCI devices this +value can be equal to, or higher than, ``VFIO_PCI_NUM_REGIONS``. + +Region I/O via file descriptors +------------------------------- + +For unmapped regions, region I/O from the client is done via +``VFIO_USER_REGION_READ/WRITE``. As an optimization, ioeventfds orioregionfds
docs/devel/vfio-user.rst new file +2
-0+may be configured for sub-regions of some regions. A client may request +information on these sub-regions via``VFIO_USER_DEVICE_GET_REGION_IO_FDS``; by
docs/devel/vfio-user.rst new file +8
-0+configuring the returned file descriptors as ioeventfds or ioregionfds, the +server can be directly notified of I/O (for example, by KVM) without taking a +trip through the client. + +Interrupts +^^^^^^^^^^ + +The client uses ``VFIO_USER_DEVICE_GET_IRQ_INFO`` messages to query theserver
docs/devel/vfio-user.rst new file +10
-0+for the device's interrupt types. The interrupt types are specific to the bus +the device is attached to, and the client is expected to know the capabilities +of each interrupt type. The server can signal an interrupt by directly injecting +interrupts into the guest via an event file descriptor. The client configures +how the server signals an interrupt with ``VFIO_USER_SET_IRQS`` messages. + +Device Read and Write +^^^^^^^^^^^^^^^^^^^^^ + +When the guest executes load or store operations to an unmapped deviceregion,
+the client forwards these operations to the server with +``VFIO_USER_REGION_READ`` or ``VFIO_USER_REGION_WRITE`` messages. The server
+will reply with data from the device on read operations or an acknowledgement ondocs/devel/vfio-user.rst new file +6
-0+write operations. See `Read and Write Operations`_. + +Client memory access +-------------------- + +The client uses ``VFIO_USER_DMA_MAP`` and ``VFIO_USER_DMA_UNMAP``messages to
docs/devel/vfio-user.rst new file +2
-0+inform the server of the valid DMA ranges that the server can access on behalf +of a device (typically, VM guest memory). DMA memory may be accessed bythe
+server via ``VFIO_USER_DMA_READ`` and ``VFIO_USER_DMA_WRITE`` messages over thedocs/devel/vfio-user.rst new file +41
-0+socket. In this case, the "DMA" part of the naming is a misnomer. + +Actual direct memory access of client memory from the server is possible if the +client provides file descriptors the server can ``mmap()``. Note that ``mmap()`` +privileges cannot be revoked by the client, therefore file descriptors should +only be exported in environments where the client trusts the server not to +corrupt guest memory. + +See `Read and Write Operations`_. + +Client/server interactions +========================== + +Socket +------ + +A server can serve: + +1) one or more clients, and/or +2) one or more virtual devices, belonging to one or more clients. + +The current protocol specification requires a dedicated socket per +client/server connection. It is a server-side implementation detail whether a +single server handles multiple virtual devices from the same or multiple +clients. The location of the socket is implementation-specific. Multiplexing +clients, devices, and servers over the same socket is not supported in this +version of the protocol. + +Authentication +-------------- + +For ``AF_UNIX``, we rely on OS mandatory access controls on the socket files, +therefore it is up to the management layer to set up the socket as required. +Socket types that span guests or hosts will require a proper authentication +mechanism. Defining that mechanism is deferred to a future version of the +protocol. + +Command Concurrency +------------------- + +A client may pipeline multiple commands without waiting for previouscommand
docs/devel/vfio-user.rst new file +3
-0+replies. The server will process commands in the order they are received. A +consequence of this is if a client issues a command with the *No_reply* bit, +then subsequently issues a command without *No_reply*, the older commandwill
docs/devel/vfio-user.rst new file +8
-0+have been processed before the reply to the younger command is sent by the +server. The client must be aware of the device's capability to process +concurrent commands if pipelining is used. For example, pipelining allows +multiple client threads to concurrently access device regions; the client must +ensure these accesses obey device semantics. + +An example is a frame buffer device, where the device may allow concurrent +access to different areas of video memory, but may have indeterminatebehavior
docs/devel/vfio-user.rst new file +14
-0+if concurrent accesses are performed to command or status registers. + +Note that unrelated messages sent from the server to the client can appear in +between a client to server request/reply and vice versa. + +Implementers should be prepared for certain commands to exhibit potentially +unbounded latencies. For example, ``VFIO_USER_DEVICE_RESET`` may take an +arbitrarily long time to complete; clients should take care not to block +unnecessarily. + +Socket Disconnection Behavior +----------------------------- +The server and the client can disconnect from each other, either intentionally +or unexpectedly. Both the client and the server need to know how to handlesuch
docs/devel/vfio-user.rst new file +28
-0+events. + +Server Disconnection +^^^^^^^^^^^^^^^^^^^^ +A server disconnecting from the client may indicate that: + +1) A virtual device has been restarted, either intentionally (e.g. because of a + device update) or unintentionally (e.g. because of a crash). +2) A virtual device has been shut down with no intention to be restarted. + +It is impossible for the client to know whether or not a failure is +intermittent or innocuous and should be retried, therefore the client should +reset the VFIO device when it detects the socket has been disconnected. +Error recovery will be driven by the guest's device error handling +behavior. + +Client Disconnection +^^^^^^^^^^^^^^^^^^^^ +The client disconnecting from the server primarily means that the client +has exited. Currently, this means that the guest is shut down so the device is +no longer needed therefore the server can automatically exit. However, there +can be cases where a client disconnection should not result in a server exit: + +1) A single server serving multiple clients. +2) A multi-process QEMU upgrading itself step by step, which is not yet + implemented. + +Therefore in order for the protocol to be forward compatible, the servershould
docs/devel/vfio-user.rst new file +3
-0+respond to a client disconnection as follows: + + - all client memory regions are unmapped and cleaned up (including closingany
docs/devel/vfio-user.rst new file +15
-0+ passed file descriptors) + - all IRQ file descriptors passed from the old client are closed + - the device state should otherwise be retained + +The expectation is that when a client reconnects, it will re-establish IRQ and +client memory mappings. + +If anything happens to the client (such as qemu really did exit), the control +stack will know about it and can clean up resources accordingly. + +Security Considerations +----------------------- + +Speaking generally, vfio-user clients should not trust servers, and vice versa. +Standard tools and mechanisms should be used on both sides to validate inputand
docs/devel/vfio-user.rst new file +23
-0+prevent against denial of service scenarios, buffer overflow, etc. + +Request Retry and Response Timeout +---------------------------------- +A failed command is a command that has been successfully sent and has been +responded to with an error code. Failure to send the command in the first place +(e.g. because the socket is disconnected) is a different type of error examined +earlier in the disconnect section. + +.. Note:: + QEMU's VFIO retries certain operations if they fail. While this makes sense + for real HW, we don't know for sure whether it makes sense for virtual + devices. + +Defining a retry and timeout scheme is deferred to a future version of the +protocol. + +Message sizes +------------- + +Some requests have an ``argsz`` field. In a request, it defines the maximum +expected reply payload size, which should be at least the size of the fixed +reply payload headers defined here. The *request* payload size is defined bythe
docs/devel/vfio-user.rst new file +11
-0+usual ``msg_size`` field in the header, not the ``argsz`` field. + +In a reply, the server sets ``argsz`` field to the size needed for a full +payload size. This may be less than the requested maximum size. This may be +larger than the requested maximum size: in that case, the full payload is not +included in the reply, but the ``argsz`` field in the reply indicates the needed +size, allowing a client to allocate a larger buffer for holding the reply before +trying again. + +In addition, during negotiation (see `Version`_), the client and server may +each specify a ``max_data_xfer_size`` value; this defines the maximum datathat
+may be read or written via one of the
``VFIO_USER_DMA/REGION_READ/WRITE``docs/devel/vfio-user.rst new file +21
-0+messages; see `Read and Write Operations`_. + +Protocol Specification +====================== + +To distinguish from the base VFIO symbols, all vfio-user symbols are prefixed +with ``vfio_user`` or ``VFIO_USER``. In this revision, all data is in the +endianness of the host system, although this may be relaxed in future +revisions in cases where the client and server run on different hosts +with different endianness. + +Unless otherwise specified, all sizes should be presumed to be in bytes. + +.. _Commands: + +Commands +-------- +The following table lists the VFIO message command IDs, and whether the +message command is sent from the client or the server. + +====================================== ==========================
+Name Command Request Direction
+====================================== =========
=================+``VFIO_USER_VERSION`` 1 client -> server +``VFIO_USER_DMA_MAP`` 2 client -> server +``VFIO_USER_DMA_UNMAP`` 3 client -> server +``VFIO_USER_DEVICE_GET_INFO`` 4 client -> server +``VFIO_USER_DEVICE_GET_REGION_INFO`` 5 client -> server +``VFIO_USER_DEVICE_GET_REGION_IO_FDS`` 6 client -> server +``VFIO_USER_DEVICE_GET_IRQ_INFO`` 7 client -> server +``VFIO_USER_DEVICE_SET_IRQS`` 8 client -> server +``VFIO_USER_REGION_READ`` 9 client -> server +``VFIO_USER_REGION_WRITE`` 10 client -> server +``VFIO_USER_DMA_READ`` 11 server -> client +``VFIO_USER_DMA_WRITE`` 12 server -> client +``VFIO_USER_DEVICE_RESET`` 13 client -> server +``VFIO_USER_DIRTY_PAGES`` 14 client -> server +====================================== ==========================
docs/devel/vfio-user.rst new file +6
-0+ +Header +------ + +All messages, both command messages and reply messages, are preceded by a +16-byte header that contains basic information about the message. The headeris
docs/devel/vfio-user.rst new file +33
-0+followed by message-specific data described in the sections below. + ++----------------+--------+-------------+ +| Name | Offset | Size | ++================+========+=============+ +| Message ID | 0 | 2 | ++----------------+--------+-------------+ +| Command | 2 | 2 | ++----------------+--------+-------------+ +| Message size | 4 | 4 | ++----------------+--------+-------------+ +| Flags | 8 | 4 | ++----------------+--------+-------------+ +| | +-----+------------+ | +| | | Bit | Definition | | +| | +=====+============+ | +| | | 0-3 | Type | | +| | +-----+------------+ | +| | | 4 | No_reply | | +| | +-----+------------+ | +| | | 5 | Error | | +| | +-----+------------+ | ++----------------+--------+-------------+ +| Error | 12 | 4 | ++----------------+--------+-------------+ +| <message data> | 16 | variable | ++----------------+--------+-------------+ + +* *Message ID* identifies the message, and is echoed in the command's reply + message. Message IDs belong entirely to the sender, can be re-used (even + concurrently) and the receiver must not make any assumptions about their + uniqueness. +* *Command* specifies the command to be executed, listed in Commands_. Itis
docs/devel/vfio-user.rst new file +11
-0+ also set in the reply header. +* *Message size* contains the size of the entire message, including the header. +* *Flags* contains attributes of the message: + + * The *Type* bits indicate the message type. + + * *Command* (value 0x0) indicates a command message. + * *Reply* (value 0x1) indicates a reply message acknowledging a previous + command with the same message ID. + * *No_reply* in a command message indicates that no reply is needed for this + command. This is commonly used when multiple commands are sent, andonly
docs/devel/vfio-user.rst new file +8
-0+ the last needs acknowledgement. + * *Error* in a reply message indicates the command being acknowledged had + an error. In this case, the *Error* field will be valid. + +* *Error* in a reply message is an optional UNIX errno value. It may be zero + even if the Error bit is set in Flags. It is reserved in a command message. + +Each command message in Commands_ must be replied to with a replymessage,
docs/devel/vfio-user.rst new file +8
-0+unless the message sets the *No_Reply* bit. The reply consists of the header +with the *Reply* bit set, plus any additional data. + +If an error occurs, the reply message must only include the reply header. + +As the header is standard in both requests and replies, it is not included in +the command-specific specifications below; each message definition should be +appended to the standard header, and the offsets are given from the end ofthe
docs/devel/vfio-user.rst new file +23
-0+standard header. + +``VFIO_USER_VERSION`` +--------------------- + +.. _Version: + +This is the initial message sent by the client after the socket connection is +established; the same format is used for the server's reply. + +Upon establishing a connection, the client must send a ``VFIO_USER_VERSION`` +message proposing a protocol version and a set of capabilities. The server +compares these with the versions and capabilities it supports and sends a +``VFIO_USER_VERSION`` reply according to the following rules. + +* The major version in the reply must be the same as proposed. If the client + does not support the proposed major, it closes the connection. +* The minor version in the reply must be equal to or less than the minor + version proposed. +* The capability list must be a subset of those proposed. If the server + requires a capability the client did not include, it closes the connection. + +The protocol major version will only change when incompatible protocolchanges
+are made, such as changing the message format. The minor version may change
+when compatible changes are made, such as adding new messages or capabilities,docs/devel/vfio-user.rst new file +19
-0+Both the client and server must support all minor versions less than the +maximum minor version it supports. E.g., an implementation that supports +version 1.3 must also support 1.0 through 1.2. + +When making a change to this specification, the protocol version number must +be included in the form "added in version X.Y" + +Request +^^^^^^^ + +============== ====== ==== +Name Offset Size +============== ====== ==== +version major 0 2 +version minor 2 2 +version data 4 variable (including terminating NUL). Optional. +============== ====== ==== + +The version data is an optional UTF-8 encoded JSON byte array with thefollowing
docs/devel/vfio-user.rst new file +14
-0+format: + ++--------------+--------+-----------------------------------+ +| Name | Type | Description | ++==============+========+===================================+ +| capabilities | object | Contains common capabilities that | +| | | the sender supports. Optional. | ++--------------+--------+-----------------------------------+ + +Capabilities: + ++--------------------+--------+------------------------------------------------+ +| Name | Type | Description | ++====================+========+================================================+
+|max_msg_fds| number | Maximum number of file descriptors that can
be |+| | | received by the sender in one message. | +| | | Optional. If not specified then the receiver | +| | | must assume a value of ``1``. | ++--------------------+--------+------------------------------------------------+ +| max_data_xfer_size | number | Maximum ``count`` for data transfer messages; | +| | | see `Read and Write Operations`_. Optional, | +| | | with a default value of 1048576 bytes. | ++--------------------+--------+------------------------------------------------+ +| migration | object | Migration capability parameters. If missing | +| | | then migration is not supported by the sender. |++--------------------+--------+------------------------------------------------+
docs/devel/vfio-user.rst new file +6
-0+ +The migration capability contains the following name/value pairs: + ++--------+--------+-----------------------------------------------+ +| Name | Type | Description | ++========+========+===============================================+
+| pgsize | number | Page size of dirty pages bitmap. The smallest | +| | | between the client and the server is used. |++--------+--------+-----------------------------------------------+
docs/devel/vfio-user.rst new file +14
-0+ +Reply +^^^^^ + +The same message format is used in the server's reply with the semantics +described above. + +``VFIO_USER_DMA_MAP`` +--------------------- + +This command message is sent by the client to the server to inform it of the +memory regions the server can access. It must be sent before the server can +perform any DMA to the client. It is normally sent directly after the version +handshake is completed, but may also occur when memory is added to theclient,
docs/devel/vfio-user.rst new file +51
-0+or if the client uses a vIOMMU. + +Request +^^^^^^^ + +The request payload for this message is a structure of the following format: + ++-------------+--------+-------------+ +| Name | Offset | Size | ++=============+========+=============+ +| argsz | 0 | 4 | ++-------------+--------+-------------+ +| flags | 4 | 4 | ++-------------+--------+-------------+ +| | +-----+------------+ | +| | | Bit | Definition | | +| | +=====+============+ | +| | | 0 | readable | | +| | +-----+------------+ | +| | | 1 | writeable | | +| | +-----+------------+ | ++-------------+--------+-------------+ +| offset | 8 | 8 | ++-------------+--------+-------------+ +| address | 16 | 8 | ++-------------+--------+-------------+ +| size | 24 | 8 | ++-------------+--------+-------------+ + +* *argsz* is the size of the above structure. Note there is no reply payload, + so this field differs from other message types. +* *flags* contains the following region attributes: + + * *readable* indicates that the region can be read from. + + * *writeable* indicates that the region can be written to. + +* *offset* is the file offset of the region with respect to the associated file + descriptor, or zero if the region is not mappable +* *address* is the base DMA address of the region. +* *size* is the size of the region. + +This structure is 32 bytes in size, so the message size is 16 + 32 bytes. + +If the DMA region being added can be directly mapped by the server, a file +descriptor must be sent as part of the message meta-data. The region can be +mapped via the mmap() system call. On ``AF_UNIX`` sockets, the file descriptor +must be passed as ``SCM_RIGHTS`` type ancillary data. Otherwise, if the DMA +region cannot be directly mapped by the server, no file descriptor must be sent +as part of the message meta-data and the DMA region can be accessed by the +server using ``VFIO_USER_DMA_READ`` and ``VFIO_USER_DMA_WRITE``messages,
docs/devel/vfio-user.rst new file +14
-0+explained in `Read and Write Operations`_. A command to map over an existing +region must be failed by the server with ``EEXIST`` set in error field in the +reply. + +Reply +^^^^^ + +There is no payload in the reply message. + +``VFIO_USER_DMA_UNMAP`` +----------------------- + +This command message is sent by the client to the server to inform it that a +DMA region, previously made available via a ``VFIO_USER_DMA_MAP``command
docs/devel/vfio-user.rst new file +66
-0+message, is no longer available for DMA. It typically occurs when memory is +subtracted from the client or if the client uses a vIOMMU. The DMA region is +described by the following structure: + +Request +^^^^^^^ + +The request payload for this message is a structure of the following format: + ++--------------+--------+------------------------+ +| Name | Offset | Size | ++==============+========+========================+ +| argsz | 0 | 4 | ++--------------+--------+------------------------+ +| flags | 4 | 4 | ++--------------+--------+------------------------+ +| | +-----+-----------------------+ | +| | | Bit | Definition | | +| | +=====+=======================+ | +| | | 0 | get dirty page bitmap | | +| | +-----+-----------------------+ | ++--------------+--------+------------------------+ +| address | 8 | 8 | ++--------------+--------+------------------------+ +| size | 16 | 8 | ++--------------+--------+------------------------+ + +* *argsz* is the maximum size of the reply payload. +* *flags* contains the following DMA region attributes: + + * *get dirty page bitmap* indicates that a dirty page bitmap must be + populated before unmapping the DMA region. The client must provide a + `VFIO Bitmap`_ structure, explained below, immediately following this + entry. + +* *address* is the base DMA address of the DMA region. +* *size* is the size of the DMA region. + +The address and size of the DMA region being unmapped must match exactly a +previous mapping. The size of request message depends on whether or not the +*get dirty page bitmap* bit is set in Flags: + +* If not set, the size of the total request message is: 16 + 24. + +* If set, the size of the total request message is: 16 + 24 + 16. + +.. _VFIO Bitmap: + +VFIO Bitmap Format +"""""""""""""""""" + ++--------+--------+------+ +| Name | Offset | Size | ++========+========+======+ +| pgsize | 0 | 8 | ++--------+--------+------+ +| size | 8 | 8 | ++--------+--------+------+ + +* *pgsize* is the page size for the bitmap, in bytes. +* *size* is the size for the bitmap, in bytes, excluding the VFIO bitmap header. + +Reply +^^^^^ + +Upon receiving a ``VFIO_USER_DMA_UNMAP`` command, if the file descriptoris
docs/devel/vfio-user.rst new file +149
-0+mapped then the server must release all references to that DMA region before +replying, which potentially includes in-flight DMA transactions. + +The server responds with the original DMA entry in the request. If the +*get dirty page bitmap* bit is set in flags in the request, then +the server also includes the `VFIO Bitmap`_ structure sent in the request, +followed by the corresponding dirty page bitmap, where each bit represents +one page of size *pgsize* in `VFIO Bitmap`_ . + +The total size of the total reply message is: +16 + 24 + (16 + *size* in `VFIO Bitmap`_ if *get dirty page bitmap* is set). + +``VFIO_USER_DEVICE_GET_INFO`` +----------------------------- + +This command message is sent by the client to the server to query for basic +information about the device. + +Request +^^^^^^^ + ++-------------+--------+--------------------------+ +| Name | Offset | Size | ++=============+========+==========================+ +| argsz | 0 | 4 | ++-------------+--------+--------------------------+ +| flags | 4 | 4 | ++-------------+--------+--------------------------+ +| | +-----+-------------------------+ | +| | | Bit | Definition | | +| | +=====+=========================+ | +| | | 0 | VFIO_DEVICE_FLAGS_RESET | | +| | +-----+-------------------------+ | +| | | 1 | VFIO_DEVICE_FLAGS_PCI | | +| | +-----+-------------------------+ | ++-------------+--------+--------------------------+ +| num_regions | 8 | 4 | ++-------------+--------+--------------------------+ +| num_irqs | 12 | 4 | ++-------------+--------+--------------------------+ + +* *argsz* is the maximum size of the reply payload +* all other fields must be zero. + +Reply +^^^^^ + ++-------------+--------+--------------------------+ +| Name | Offset | Size | ++=============+========+==========================+ +| argsz | 0 | 4 | ++-------------+--------+--------------------------+ +| flags | 4 | 4 | ++-------------+--------+--------------------------+ +| | +-----+-------------------------+ | +| | | Bit | Definition | | +| | +=====+=========================+ | +| | | 0 | VFIO_DEVICE_FLAGS_RESET | | +| | +-----+-------------------------+ | +| | | 1 | VFIO_DEVICE_FLAGS_PCI | | +| | +-----+-------------------------+ | ++-------------+--------+--------------------------+ +| num_regions | 8 | 4 | ++-------------+--------+--------------------------+ +| num_irqs | 12 | 4 | ++-------------+--------+--------------------------+ + +* *argsz* is the size required for the full reply payload (16 bytes today) +* *flags* contains the following device attributes. + + * ``VFIO_DEVICE_FLAGS_RESET`` indicates that the device supports the + ``VFIO_USER_DEVICE_RESET`` message. + * ``VFIO_DEVICE_FLAGS_PCI`` indicates that the device is a PCI device. + +* *num_regions* is the number of memory regions that the device exposes. +* *num_irqs* is the number of distinct interrupt types that the device supports. + +This version of the protocol only supports PCI devices. Additional devices may +be supported in future versions. + +``VFIO_USER_DEVICE_GET_REGION_INFO`` +------------------------------------ + +This command message is sent by the client to the server to query for +information about device regions. The VFIO region info structure is defined in +``<linux/vfio.h>`` (``struct vfio_region_info``). + +Request +^^^^^^^ + ++------------+--------+------------------------------+ +| Name | Offset | Size | ++============+========+==============================+ +| argsz | 0 | 4 | ++------------+--------+------------------------------+ +| flags | 4 | 4 | ++------------+--------+------------------------------+ +| index | 8 | 4 | ++------------+--------+------------------------------+ +| cap_offset | 12 | 4 | ++------------+--------+------------------------------+ +| size | 16 | 8 | ++------------+--------+------------------------------+ +| offset | 24 | 8 | ++------------+--------+------------------------------+ + +* *argsz* the maximum size of the reply payload +* *index* is the index of memory region being queried, it is the only field + that is required to be set in the command message. +* all other fields must be zero. + +Reply +^^^^^ + ++------------+--------+------------------------------+ +| Name | Offset | Size | ++============+========+==============================+ +| argsz | 0 | 4 | ++------------+--------+------------------------------+ +| flags | 4 | 4 | ++------------+--------+------------------------------+ +| | +-----+-----------------------------+ | +| | | Bit | Definition | | +| | +=====+=============================+ | +| | | 0 | VFIO_REGION_INFO_FLAG_READ | | +| | +-----+-----------------------------+ | +| | | 1 | VFIO_REGION_INFO_FLAG_WRITE | | +| | +-----+-----------------------------+ | +| | | 2 | VFIO_REGION_INFO_FLAG_MMAP | | +| | +-----+-----------------------------+ | +| | | 3 | VFIO_REGION_INFO_FLAG_CAPS | | +| | +-----+-----------------------------+ | ++------------+--------+------------------------------+ ++------------+--------+------------------------------+ +| index | 8 | 4 | ++------------+--------+------------------------------+ +| cap_offset | 12 | 4 | ++------------+--------+------------------------------+ +| size | 16 | 8 | ++------------+--------+------------------------------+ +| offset | 24 | 8 | ++------------+--------+------------------------------+ + +* *argsz* is the size required for the full reply payload (region info structure + plus the size of any region capabilities) +* *flags* are attributes of the region: + + * ``VFIO_REGION_INFO_FLAG_READ`` allows client read access to the region. + * ``VFIO_REGION_INFO_FLAG_WRITE`` allows client write access to theregion.
+ * ``VFIO_REGION_INFO_FLAG_MMAP`` specifies the client canmmap()the region.docs/devel/vfio-user.rst new file +4
-0+ When this flag is set, the reply will include a file descriptor in its + meta-data. On ``AF_UNIX`` sockets, the file descriptors will be passed as + ``SCM_RIGHTS`` type ancillary data. + * ``VFIO_REGION_INFO_FLAG_CAPS`` indicates additional capabilities found inthe
docs/devel/vfio-user.rst new file +81
-0+ reply. + +* *index* is the index of memory region being queried, it is the only field + that is required to be set in the command message. +* *cap_offset* describes where additional region capabilities can be found. + cap_offset is relative to the beginning of the VFIO region info structure. + The data structure it points is a VFIO cap header defined in + ``<linux/vfio.h>``. +* *size* is the size of the region. +* *offset* is the offset that should be given to the mmap() system call for + regions with the MMAP attribute. It is also used as the base offset when + mapping a VFIO sparse mmap area, described below. + +VFIO region capabilities +"""""""""""""""""""""""" + +The VFIO region information can also include a capabilities list. This list is +similar to a PCI capability list - each entry has a common header that +identifies a capability and where the next capability in the list can be found. +The VFIO capability header format is defined in ``<linux/vfio.h>`` (``struct +vfio_info_cap_header``). + +VFIO cap header format +"""""""""""""""""""""" + ++---------+--------+------+ +| Name | Offset | Size | ++=========+========+======+ +| id | 0 | 2 | ++---------+--------+------+ +| version | 2 | 2 | ++---------+--------+------+ +| next | 4 | 4 | ++---------+--------+------+ + +* *id* is the capability identity. +* *version* is a capability-specific version number. +* *next* specifies the offset of the next capability in the capability list. It + is relative to the beginning of the VFIO region info structure. + +VFIO sparse mmap cap header +""""""""""""""""""""""""""" + ++------------------+----------------------------------+ +| Name | Value | ++==================+==================================+ +| id | VFIO_REGION_INFO_CAP_SPARSE_MMAP | ++------------------+----------------------------------+ +| version | 0x1 | ++------------------+----------------------------------+ +| next | <next> | ++------------------+----------------------------------+ +| sparse mmap info | VFIO region info sparse mmap | ++------------------+----------------------------------+ + +This capability is defined when only a subrange of the region supports +direct access by the client via mmap(). The VFIO sparse mmap area is defined in +``<linux/vfio.h>`` (``struct vfio_region_sparse_mmap_area`` and ``struct +vfio_region_info_cap_sparse_mmap``). + +VFIO region info cap sparse mmap +"""""""""""""""""""""""""""""""" + ++----------+--------+------+ +| Name | Offset | Size | ++==========+========+======+ +| nr_areas | 0 | 4 | ++----------+--------+------+ +| reserved | 4 | 4 | ++----------+--------+------+ +| offset | 8 | 8 | ++----------+--------+------+ +| size | 16 | 9 | ++----------+--------+------+ +| ... | | | ++----------+--------+------+ + +* *nr_areas* is the number of sparse mmap areas in the region. +* *offset* and size describe a single area that can be mapped by the client. + There will be *nr_areas* pairs of offset and size. The offset will be added to + the base offset given in the ``VFIO_USER_DEVICE_GET_REGION_INFO`` toform the
docs/devel/vfio-user.rst new file +38
-0+ offset argument of the subsequent mmap() call. + +The VFIO sparse mmap area is defined in ``<linux/vfio.h>`` (``struct +vfio_region_info_cap_sparse_mmap``). + +VFIO region type cap header +""""""""""""""""""""""""""" + ++------------------+---------------------------+ +| Name | Value | ++==================+===========================+ +| id | VFIO_REGION_INFO_CAP_TYPE | ++------------------+---------------------------+ +| version | 0x1 | ++------------------+---------------------------+ +| next | <next> | ++------------------+---------------------------+ +| region info type | VFIO region info type | ++------------------+---------------------------+ + +This capability is defined when a region is specific to the device. + +VFIO region info type cap +""""""""""""""""""""""""" + +The VFIO region info type is defined in ``<linux/vfio.h>`` +(``struct vfio_region_info_cap_type``). + ++---------+--------+------+ +| Name | Offset | Size | ++=========+========+======+ +| type | 0 | 4 | ++---------+--------+------+ +| subtype | 4 | 4 | ++---------+--------+------+ + +The only device-specific region type and subtype supported by vfio-user is +``VFIO_REGION_TYPE_MIGRATION`` (3) and``VFIO_REGION_SUBTYPE_MIGRATION`` (1).
docs/devel/vfio-user.rst new file +5
-0+ +``VFIO_USER_DEVICE_GET_REGION_IO_FDS`` +-------------------------------------- + +Clients can access regions via ``VFIO_USER_REGION_READ/WRITE`` or, ifprovided, by
+``mmap()`` of a file descriptor provided by the server.
+
+``VFIO_USER_DEVICE_GET_REGION_IO_FDS`` provides an alternative access mechanism viadocs/devel/vfio-user.rst new file +2
-0+file descriptors. This is an optional feature intended for performance +improvements where an underlying sub-system (such as KVM) supportscommunication
docs/devel/vfio-user.rst new file +7
-0+across such file descriptors to the vfio-user server, without needing to +round-trip through the client. + +The server returns an array of sub-regions for the requested region. Each +sub-region describes a span (offset and size) of a region, along with the +requested file descriptor notification mechanism to use. Each sub-region in the +response message may choose to use a different method, as defined below.The
docs/devel/vfio-user.rst new file +104
-0+two mechanisms supported in this specification are ioeventfds and ioregionfds. + +The server in addition returns a file descriptor in the ancillary data; clients +are expected to configure each sub-region's file descriptor with the requested +notification method. For example, a client could configure KVM with the +requested ioeventfd via a ``KVM_IOEVENTFD`` ``ioctl()``. + +Request +^^^^^^^ + ++-------------+--------+------+ +| Name | Offset | Size | ++=============+========+======+ +| argsz | 0 | 4 | ++-------------+--------+------+ +| flags | 4 | 4 | ++-------------+--------+------+ +| index | 8 | 4 | ++-------------+--------+------+ +| count | 12 | 4 | ++-------------+--------+------+ + +* *argsz* the maximum size of the reply payload +* *index* is the index of memory region being queried +* all other fields must be zero + +The client must set ``flags`` to zero and specify the region being queried in +the ``index``. + +Reply +^^^^^ + ++-------------+--------+------+ +| Name | Offset | Size | ++=============+========+======+ +| argsz | 0 | 4 | ++-------------+--------+------+ +| flags | 4 | 4 | ++-------------+--------+------+ +| index | 8 | 4 | ++-------------+--------+------+ +| count | 12 | 4 | ++-------------+--------+------+ +| sub-regions | 16 | ... | ++-------------+--------+------+ + +* *argsz* is the size of the region IO FD info structure plus the + total size of the sub-region array. Thus, each array entry "i" is at offset + i * ((argsz - 32) / count). Note that currently this is 40 bytes for both IO + FD types, but this is not to be relied on. As elsewhere, this indicates the + full reply payload size needed. +* *flags* must be zero +* *index* is the index of memory region being queried +* *count* is the number of sub-regions in the array +* *sub-regions* is the array of Sub-Region IO FD info structures + +The reply message will additionally include at least one file descriptor in the +ancillary data. Note that more than one sub-region may share the same file +descriptor. + +Note that it is the client's responsibility to verify the requested values (for +example, that the requested offset does not exceed the region's bounds). + +Each sub-region given in the response has one of two possible structures, +depending whether *type* is ``VFIO_USER_IO_FD_TYPE_IOEVENTFD`` or +``VFIO_USER_IO_FD_TYPE_IOREGIONFD``: + +Sub-Region IO FD info format (ioeventfd) +"""""""""""""""""""""""""""""""""""""""" + ++-----------+--------+------+ +| Name | Offset | Size | ++===========+========+======+ +| offset | 0 | 8 | ++-----------+--------+------+ +| size | 8 | 8 | ++-----------+--------+------+ +| fd_index | 16 | 4 | ++-----------+--------+------+ +| type | 20 | 4 | ++-----------+--------+------+ +| flags | 24 | 4 | ++-----------+--------+------+ +| padding | 28 | 4 | ++-----------+--------+------+ +| datamatch | 32 | 8 | ++-----------+--------+------+ + +* *offset* is the offset of the start of the sub-region within the region + requested ("physical address offset" for the region) +* *size* is the length of the sub-region. This may be zero if the access size is + not relevant, which may allow for optimizations +* *fd_index* is the index in the ancillary data of the FD to use for ioeventfd + notification; it may be shared. +* *type* is ``VFIO_USER_IO_FD_TYPE_IOEVENTFD`` +* *flags* is any of: + + * ``KVM_IOEVENTFD_FLAG_DATAMATCH`` + * ``KVM_IOEVENTFD_FLAG_PIO`` + * ``KVM_IOEVENTFD_FLAG_VIRTIO_CCW_NOTIFY`` (FIXME: makes sense?) + +* *datamatch* is the datamatch value if needed + +See https://urldefense.proofpoint.com/v2/url?u=https-3A__www.kernel.org_doc_Documentation_virtual_kvm_api.txt&d=DwIBAg&c= s883GpUCOChKOHiocYtGcg&r=XTpYsh5Ps2zJvtw6ogtti46atk736SI4vgsJiUKIyDE &m=ngoOFuShfuAMJEVdV4gT7GrSMsClZglKPZXIUUeqln2aRgULhPnXxADWhHOl 4DBy&s=D1hlJS25Ny7l_WLpHhCzIn7vdmBG4HMgjTgxv-9frDU&e= , *4.59
docs/devel/vfio-user.rst new file +27
-0+KVM_IOEVENTFD* for further context on the ioeventfd-specific fields. + +Sub-Region IO FD info format (ioregionfd) +""""""""""""""""""""""""""""""""""""""""" + ++-----------+--------+------+ +| Name | Offset | Size | ++===========+========+======+ +| offset | 0 | 8 | ++-----------+--------+------+ +| size | 8 | 8 | ++-----------+--------+------+ +| fd_index | 16 | 4 | ++-----------+--------+------+ +| type | 20 | 4 | ++-----------+--------+------+ +| flags | 24 | 4 | ++-----------+--------+------+ +| padding | 28 | 4 | ++-----------+--------+------+ +| user_data | 32 | 8 | ++-----------+--------+------+ + +* *offset* is the offset of the start of the sub-region within the region + requested ("physical address offset" for the region) +* *size* is the length of the sub-region. This may be zero if the access size is + not relevant, which may allow for optimizations;``KVM_IOREGION_POSTED_WRITES``
docs/devel/vfio-user.rst new file +10
-0+ must be set in *flags* in this case +* *fd_index* is the index in the ancillary data of the FD to use for ioregionfd + messages; it may be shared +* *type* is ``VFIO_USER_IO_FD_TYPE_IOREGIONFD`` +* *flags* is any of: + + * ``KVM_IOREGION_PIO`` + * ``KVM_IOREGION_POSTED_WRITES`` + +* *user_data* is an opaque value passed back to the server via a message onthe
docs/devel/vfio-user.rst new file +4
-0+ file descriptor + +For further information on the ioregionfd-specific fields, see: +https://urldefense.proofpoint.com/v2/url?u=https-3A__lore.kernel.org_kvm_cover.1613828726.git.eafanasova- 40gmail.com_&d=DwIBAg&c=s883GpUCOChKOHiocYtGcg&r=XTpYsh5Ps2zJvtw6 ogtti46atk736SI4vgsJiUKIyDE&m=ngoOFuShfuAMJEVdV4gT7GrSMsClZglKPZXIUU eqln2aRgULhPnXxADWhHOl4DBy&s=OOeFsvNXwrHKJ_usTp2EzZuq5leMI9ggCxJ 0g5sPuw8&e=
docs/devel/vfio-user.rst new file +39
-0+ +(FIXME: update with final API docs.) + +``VFIO_USER_DEVICE_GET_IRQ_INFO`` +--------------------------------- + +This command message is sent by the client to the server to query for +information about device interrupt types. The VFIO IRQ info structure is +defined in ``<linux/vfio.h>`` (``struct vfio_irq_info``). + +Request +^^^^^^^ + ++-------+--------+---------------------------+ +| Name | Offset | Size | ++=======+========+===========================+ +| argsz | 0 | 4 | ++-------+--------+---------------------------+ +| flags | 4 | 4 | ++-------+--------+---------------------------+ +| | +-----+--------------------------+ | +| | | Bit | Definition | | +| | +=====+==========================+ | +| | | 0 | VFIO_IRQ_INFO_EVENTFD | | +| | +-----+--------------------------+ | +| | | 1 | VFIO_IRQ_INFO_MASKABLE | | +| | +-----+--------------------------+ | +| | | 2 | VFIO_IRQ_INFO_AUTOMASKED | | +| | +-----+--------------------------+ | +| | | 3 | VFIO_IRQ_INFO_NORESIZE | | +| | +-----+--------------------------+ | ++-------+--------+---------------------------+ +| index | 8 | 4 | ++-------+--------+---------------------------+ +| count | 12 | 4 | ++-------+--------+---------------------------+ + +* *argsz* is the maximum size of the reply payload (16 bytes today) +* index is the index of IRQ type being queried (e.g.``VFIO_PCI_MSIX_IRQ_INDEX``)
docs/devel/vfio-user.rst new file +33
-0+* all other fields must be zero + +Reply +^^^^^ + ++-------+--------+---------------------------+ +| Name | Offset | Size | ++=======+========+===========================+ +| argsz | 0 | 4 | ++-------+--------+---------------------------+ +| flags | 4 | 4 | ++-------+--------+---------------------------+ +| | +-----+--------------------------+ | +| | | Bit | Definition | | +| | +=====+==========================+ | +| | | 0 | VFIO_IRQ_INFO_EVENTFD | | +| | +-----+--------------------------+ | +| | | 1 | VFIO_IRQ_INFO_MASKABLE | | +| | +-----+--------------------------+ | +| | | 2 | VFIO_IRQ_INFO_AUTOMASKED | | +| | +-----+--------------------------+ | +| | | 3 | VFIO_IRQ_INFO_NORESIZE | | +| | +-----+--------------------------+ | ++-------+--------+---------------------------+ +| index | 8 | 4 | ++-------+--------+---------------------------+ +| count | 12 | 4 | ++-------+--------+---------------------------+ + +* *argsz* is the size required for the full reply payload (16 bytes today) +* *flags* defines IRQ attributes: + + * ``VFIO_IRQ_INFO_EVENTFD`` indicates the IRQ type can support servereventfd
docs/devel/vfio-user.rst new file +2
-0+ signalling. + * ``VFIO_IRQ_INFO_MASKABLE`` indicates that the IRQ type supports the``MASK``
docs/devel/vfio-user.rst new file +2
-0+ and ``UNMASK`` actions in a ``VFIO_USER_DEVICE_SET_IRQS`` message. + * ``VFIO_IRQ_INFO_AUTOMASKED`` indicates the IRQ type masks itself afterbeing
docs/devel/vfio-user.rst new file +3
-0+ triggered, and the client must send an ``UNMASK`` action to receive new + interrupts. + * ``VFIO_IRQ_INFO_NORESIZE`` indicates ``VFIO_USER_SET_IRQS`` operationssetup
docs/devel/vfio-user.rst new file +56
-0+ interrupts as a set, and new sub-indexes cannot be enabled without disabling + the entire type. +* index is the index of IRQ type being queried +* count describes the number of interrupts of the queried type. + +``VFIO_USER_DEVICE_SET_IRQS`` +----------------------------- + +This command message is sent by the client to the server to set actions for +device interrupt types. The VFIO IRQ set structure is defined in +``<linux/vfio.h>`` (``struct vfio_irq_set``). + +Request +^^^^^^^ + ++-------+--------+------------------------------+ +| Name | Offset | Size | ++=======+========+==============================+ +| argsz | 0 | 4 | ++-------+--------+------------------------------+ +| flags | 4 | 4 | ++-------+--------+------------------------------+ +| | +-----+-----------------------------+ | +| | | Bit | Definition | | +| | +=====+=============================+ | +| | | 0 | VFIO_IRQ_SET_DATA_NONE | | +| | +-----+-----------------------------+ | +| | | 1 | VFIO_IRQ_SET_DATA_BOOL | | +| | +-----+-----------------------------+ | +| | | 2 | VFIO_IRQ_SET_DATA_EVENTFD | | +| | +-----+-----------------------------+ | +| | | 3 | VFIO_IRQ_SET_ACTION_MASK | | +| | +-----+-----------------------------+ | +| | | 4 | VFIO_IRQ_SET_ACTION_UNMASK | | +| | +-----+-----------------------------+ | +| | | 5 | VFIO_IRQ_SET_ACTION_TRIGGER | | +| | +-----+-----------------------------+ | ++-------+--------+------------------------------+ +| index | 8 | 4 | ++-------+--------+------------------------------+ +| start | 12 | 4 | ++-------+--------+------------------------------+ +| count | 16 | 4 | ++-------+--------+------------------------------+ +| data | 20 | variable | ++-------+--------+------------------------------+ + +* *argsz* is the size of the VFIO IRQ set request payload, including any *data* + field. Note there is no reply payload, so this field differs from other + message types. +* *flags* defines the action performed on the interrupt range. The ``DATA`` + flags describe the data field sent in the message; the ``ACTION`` flags + describe the action to be performed. The flags are mutually exclusive for + both sets. + + * ``VFIO_IRQ_SET_DATA_NONE`` indicates there is no data field in thecommand.
docs/devel/vfio-user.rst new file +2
-0+ The action is performed unconditionally. + * ``VFIO_IRQ_SET_DATA_BOOL`` indicates the data field is an array ofboolean
docs/devel/vfio-user.rst new file +2
-0+ bytes. The action is performed if the corresponding boolean is true. + * ``VFIO_IRQ_SET_DATA_EVENTFD`` indicates an array of event filedescriptors
docs/devel/vfio-user.rst new file +6
-0+ was sent in the message meta-data. These descriptors will be signalled when + the action defined by the action flags occurs. In ``AF_UNIX`` sockets, the + descriptors are sent as ``SCM_RIGHTS`` type ancillary data. + If no file descriptors are provided, this de-assigns the specified + previously configured interrupts. + * ``VFIO_IRQ_SET_ACTION_MASK`` indicates a masking event. It can be usedwith
+ ``VFIO_IRQ_SET_DATA_BOOL`` or ``VFIO_IRQ_SET_DATA_NONE`` to mask an
interrupt,
+ or with ``VFIO_IRQ_SET_DATA_EVENTFD`` to generate an event when the
guest masksdocs/devel/vfio-user.rst new file +2
-0+ the interrupt. + * ``VFIO_IRQ_SET_ACTION_UNMASK`` indicates an unmasking event. It can beused
+ with ``VFIO_IRQ_SET_DATA_BOOL`` or ``VFIO_IRQ_SET_DATA_NONE`` to
unmask an
+ interrupt, or with ``VFIO_IRQ_SET_DATA_EVENTFD`` to generate an event
when thedocs/devel/vfio-user.rst new file +2
-0+ guest unmasks the interrupt. + * ``VFIO_IRQ_SET_ACTION_TRIGGER`` indicates a triggering event. It can beused
+ with ``VFIO_IRQ_SET_DATA_BOOL`` or ``VFIO_IRQ_SET_DATA_NONE`` to
trigger an
+ interrupt, or with ``VFIO_IRQ_SET_DATA_EVENTFD`` to generate an event
when thedocs/devel/vfio-user.rst new file +6
-0+ server triggers the interrupt. + +* *index* is the index of IRQ type being setup. +* *start* is the start of the sub-index being set. +* *count* describes the number of sub-indexes being set. As a special case, a + count (and start) of 0, with data flags of ``VFIO_IRQ_SET_DATA_NONE``disables
docs/devel/vfio-user.rst new file +3
-0+ all interrupts of the index. +* *data* is an optional field included when the + ``VFIO_IRQ_SET_DATA_BOOL`` flag is present. It contains an array ofbooleans
docs/devel/vfio-user.rst new file +12
-0+ that specify whether the action is to be performed on the corresponding + index. It's used when the action is only performed on a subset of the range + specified. + +Not all interrupt types support every combination of data and action flags. +The client must know the capabilities of the device and IRQ index before it +sends a ``VFIO_USER_DEVICE_SET_IRQ`` message. + +In typical operation, a specific IRQ may operate as follows: + +1. The client sends a ``VFIO_USER_DEVICE_SET_IRQ`` message with + ``flags=(VFIO_IRQ_SET_DATA_EVENTFD|VFIO_IRQ_SET_ACTION_TRIGGER)``along
docs/devel/vfio-user.rst new file +5
-0+ with an eventfd. This associates the IRQ with a particular eventfd on the + server side. + +#. The client may send a ``VFIO_USER_DEVICE_SET_IRQ`` message with +``flags=(VFIO_IRQ_SET_DATA_EVENTFD|VFIO_IRQ_SET_ACTION_MASK/UNMAS K)`` along
docs/devel/vfio-user.rst new file +11
-0+ with another eventfd. This associates the given eventfd with the + mask/unmask state on the server side. + +#. The server may trigger the IRQ by writing 1 to the eventfd. + +#. The server may mask/unmask an IRQ which will write 1 to the corresponding + mask/unmask eventfd, if there is one. + +5. A client may trigger a device IRQ itself, by sending a + ``VFIO_USER_DEVICE_SET_IRQ`` message with +``flags=(VFIO_IRQ_SET_DATA_NONE/BOOL|VFIO_IRQ_SET_ACTION_TRIGGER)`` .
docs/devel/vfio-user.rst new file +4
-0+ +6. A client may mask or unmask the IRQ, by sending a + ``VFIO_USER_DEVICE_SET_IRQ`` message with +``flags=(VFIO_IRQ_SET_DATA_NONE/BOOL|VFIO_IRQ_SET_ACTION_MASK/UN MASK)``.
docs/devel/vfio-user.rst new file +9
-0+ +Reply +^^^^^ + +There is no payload in the reply. + +.. _Read and Write Operations: + +Note that all of these operations must be supported by the client and/orserver,
+even if the corresponding memory or device region has been shared as mappable.docs/devel/vfio-user.rst new file +96
-0+ +The ``count`` field must not exceed the value of ``max_data_xfer_size`` of the +peer, for both reads and writes. + +``VFIO_USER_REGION_READ`` +------------------------- + +If a device region is not mappable, it's not directly accessible by the client +via ``mmap()`` of the underlying file descriptor. In this case, a client can +read from a device region with this message. + +Request +^^^^^^^ + ++--------+--------+----------+ +| Name | Offset | Size | ++========+========+==========+ +| offset | 0 | 8 | ++--------+--------+----------+ +| region | 8 | 4 | ++--------+--------+----------+ +| count | 12 | 4 | ++--------+--------+----------+ + +* *offset* into the region being accessed. +* *region* is the index of the region being accessed. +* *count* is the size of the data to be transferred. + +Reply +^^^^^ + ++--------+--------+----------+ +| Name | Offset | Size | ++========+========+==========+ +| offset | 0 | 8 | ++--------+--------+----------+ +| region | 8 | 4 | ++--------+--------+----------+ +| count | 12 | 4 | ++--------+--------+----------+ +| data | 16 | variable | ++--------+--------+----------+ + +* *offset* into the region accessed. +* *region* is the index of the region accessed. +* *count* is the size of the data transferred. +* *data* is the data that was read from the device region. + +``VFIO_USER_REGION_WRITE`` +-------------------------- + +If a device region is not mappable, it's not directly accessible by the client +via mmap() of the underlying fd. In this case, a client can write to a device +region with this message. + +Request +^^^^^^^ + ++--------+--------+----------+ +| Name | Offset | Size | ++========+========+==========+ +| offset | 0 | 8 | ++--------+--------+----------+ +| region | 8 | 4 | ++--------+--------+----------+ +| count | 12 | 4 | ++--------+--------+----------+ +| data | 16 | variable | ++--------+--------+----------+ + +* *offset* into the region being accessed. +* *region* is the index of the region being accessed. +* *count* is the size of the data to be transferred. +* *data* is the data to write + +Reply +^^^^^ + ++--------+--------+----------+ +| Name | Offset | Size | ++========+========+==========+ +| offset | 0 | 8 | ++--------+--------+----------+ +| region | 8 | 4 | ++--------+--------+----------+ +| count | 12 | 4 | ++--------+--------+----------+ + +* *offset* into the region accessed. +* *region* is the index of the region accessed. +* *count* is the size of the data transferred. + +``VFIO_USER_DMA_READ`` +----------------------- + +If the client has not shared mappable memory, the server can use this messageto
docs/devel/vfio-user.rst new file +14
-0+read from guest memory. + +Request +^^^^^^^ + ++---------+--------+----------+ +| Name | Offset | Size | ++=========+========+==========+ +| address | 0 | 8 | ++---------+--------+----------+ +| count | 8 | 8 | ++---------+--------+----------+ + +* *address* is the client DMA memory address being accessed. This addressmust have
+ been previously exported to the server with a ``VFIO_USER_DMA_MAP`` message.docs/devel/vfio-user.rst new file +23
-0+* *count* is the size of the data to be transferred. + +Reply +^^^^^ + ++---------+--------+----------+ +| Name | Offset | Size | ++=========+========+==========+ +| address | 0 | 8 | ++---------+--------+----------+ +| count | 8 | 8 | ++---------+--------+----------+ +| data | 16 | variable | ++---------+--------+----------+ + +* *address* is the client DMA memory address being accessed. +* *count* is the size of the data transferred. +* *data* is the data read. + +``VFIO_USER_DMA_WRITE`` +----------------------- + +If the client has not shared mappable memory, the server can use this messageto
docs/devel/vfio-user.rst new file +16
-0+write to guest memory. + +Request +^^^^^^^ + ++---------+--------+----------+ +| Name | Offset | Size | ++=========+========+==========+ +| address | 0 | 8 | ++---------+--------+----------+ +| count | 8 | 8 | ++---------+--------+----------+ +| data | 16 | variable | ++---------+--------+----------+ + +* *address* is the client DMA memory address being accessed. This addressmust have
+ been previously exported to the server with a ``VFIO_USER_DMA_MAP`` message.docs/devel/vfio-user.rst new file +27
-0+* *count* is the size of the data to be transferred. +* *data* is the data to write + +Reply +^^^^^ + ++---------+--------+----------+ +| Name | Offset | Size | ++=========+========+==========+ +| address | 0 | 8 | ++---------+--------+----------+ +| count | 8 | 4 | ++---------+--------+----------+ + +* *address* is the client DMA memory address being accessed. +* *count* is the size of the data transferred. + +``VFIO_USER_DEVICE_RESET`` +-------------------------- + +This command message is sent from the client to the server to reset the device. +Neither the request or reply have a payload. + +``VFIO_USER_DIRTY_PAGES`` +------------------------- + +This command is analogous to ``VFIO_IOMMU_DIRTY_PAGES``. It is sent by theclient
docs/devel/vfio-user.rst new file +29
-0+to the server in order to control logging of dirty pages, usually during a live +migration. + +Dirty page tracking is optional for server implementation; clients should not +rely on it. + +Request +^^^^^^^ + ++-------+--------+-----------------------------------------+ +| Name | Offset | Size | ++=======+========+=========================================+ +| argsz | 0 | 4 | ++-------+--------+-----------------------------------------+ +| flags | 4 | 4 | ++-------+--------+-----------------------------------------+ +| | +-----+----------------------------------------+ | +| | | Bit | Definition | | +| | +=====+========================================+ | +| | | 0 | VFIO_IOMMU_DIRTY_PAGES_FLAG_START | | +| | +-----+----------------------------------------+ | +| | | 1 | VFIO_IOMMU_DIRTY_PAGES_FLAG_STOP | | +| | +-----+----------------------------------------+ | +| | | 2 | VFIO_IOMMU_DIRTY_PAGES_FLAG_GET_BITMAP | | +| | +-----+----------------------------------------+ | ++-------+--------+-----------------------------------------+ + +* *argsz* is the size of the VFIO dirty bitmap info structure for + ``START/STOP``; and for ``GET_BITMAP``, the maximum size of the replypayload
docs/devel/vfio-user.rst new file +4
-0+ +* *flags* defines the action to be performed by the server: + + * ``VFIO_IOMMU_DIRTY_PAGES_FLAG_START`` instructs the server to startlogging
docs/devel/vfio-user.rst new file +4
-0+ pages it dirties. Logging continues until explicitly disabled by + ``VFIO_IOMMU_DIRTY_PAGES_FLAG_STOP``. + + * ``VFIO_IOMMU_DIRTY_PAGES_FLAG_STOP`` instructs the server to stoplogging
docs/devel/vfio-user.rst new file +3
-0+ dirty pages. + + * ``VFIO_IOMMU_DIRTY_PAGES_FLAG_GET_BITMAP`` requests the server toreturn
docs/devel/vfio-user.rst new file +42
-0+ the dirty bitmap for a specific IOVA range. The IOVA range is specified by + a "VFIO Bitmap Range" structure, which must immediately follow this + "VFIO Dirty Pages" structure. See `VFIO Bitmap Range Format`_. + This operation is only valid if logging of dirty pages has been previously + started. + + These flags are mutually exclusive with each other. + +This part of the request is analogous to VFIO's ``struct +vfio_iommu_type1_dirty_bitmap``. + +.. _VFIO Bitmap Range Format: + +VFIO Bitmap Range Format +"""""""""""""""""""""""" + ++--------+--------+------+ +| Name | Offset | Size | ++========+========+======+ +| iova | 0 | 8 | ++--------+--------+------+ +| size | 8 | 8 | ++--------+--------+------+ +| bitmap | 16 | 24 | ++--------+--------+------+ + +* *iova* is the IOVA offset + +* *size* is the size of the IOVA region + +* *bitmap* is the VFIO Bitmap explained in `VFIO Bitmap`_. + +This part of the request is analogous to VFIO's ``struct +vfio_iommu_type1_dirty_bitmap_get``. + +Reply +^^^^^ + +For ``VFIO_IOMMU_DIRTY_PAGES_FLAG_START`` or +``VFIO_IOMMU_DIRTY_PAGES_FLAG_STOP``, there is no reply payload. + +For ``VFIO_IOMMU_DIRTY_PAGES_FLAG_GET_BITMAP``, the reply payload isas follows:
+
++--------------+--------+-----------------------------------------+
+| Name | Offset | Size |
++==============+========+=======================================
==+
+| argsz | 0 | 4 |
++--------------+--------+-----------------------------------------+
+| flags | 4 | 4 |
++--------------+--------+-----------------------------------------++| | +-----+----------------------------------------+ | +| | | Bit | Definition | | +| | +=====+========================================+ | +| | | 2 | VFIO_IOMMU_DIRTY_PAGES_FLAG_GET_BITMAP | | +| | +-----+----------------------------------------+ |++--------------+--------+-----------------------------------------+
+| bitmap range | 8 | 40 |
++--------------+--------+-----------------------------------------+
+| bitmap | 48 | variable |
++--------------+--------+-----------------------------------------+docs/devel/vfio-user.rst new file +13
-0+ +* *argsz* is the size required for the full reply payload (dirty pages structure + + bitmap range structure + actual bitmap) +* *flags* is ``VFIO_IOMMU_DIRTY_PAGES_FLAG_GET_BITMAP`` +* *bitmap range* is the same bitmap range struct provided in the request, as + defined in `VFIO Bitmap Range Format`_. +* *bitmap* is the actual dirty pages bitmap corresponding to the range request + +VFIO Device Migration Info +-------------------------- + +A device may contain a migration region (of type +``VFIO_REGION_TYPE_MIGRATION``). The beginning of the region mustcontain
+``struct vfio_device_migration_info``, defined in ``<linux/vfio.h>``. Thisdocs/devel/vfio-user.rst new file +33
-0+subregion is accessed like any other part of a standard vfio-user region +using ``VFIO_USER_REGION_READ``/``VFIO_USER_REGION_WRITE``. + ++---------------+--------+-----------------------------+ +| Name | Offset | Size | ++===============+========+=============================+ +| device_state | 0 | 4 | ++---------------+--------+-----------------------------+ +| | +-----+----------------------------+ | +| | | Bit | Definition | | +| | +=====+============================+ | +| | | 0 | VFIO_DEVICE_STATE_RUNNING | | +| | +-----+----------------------------+ | +| | | 1 | VFIO_DEVICE_STATE_SAVING | | +| | +-----+----------------------------+ | +| | | 2 | VFIO_DEVICE_STATE_RESUMING | | +| | +-----+----------------------------+ | ++---------------+--------+-----------------------------+ +| reserved | 4 | 4 | ++---------------+--------+-----------------------------+ +| pending_bytes | 8 | 8 | ++---------------+--------+-----------------------------+ +| data_offset | 16 | 8 | ++---------------+--------+-----------------------------+ +| data_size | 24 | 8 | ++---------------+--------+-----------------------------+ + +* *device_state* defines the state of the device: + + The client initiates device state transition by writing the intended state. + The server must respond only after it has successfully transitioned to the new + state. If an error occurs then the server must respond to the + ``VFIO_USER_REGION_WRITE`` operation with the Error field set accordinglyand
docs/devel/vfio-user.rst new file +3
-0+ must remain at the previous state, or in case of internal error it must + transition to the error state, defined as + ``VFIO_DEVICE_STATE_RESUMING | VFIO_DEVICE_STATE_SAVING``. Theclient must
docs/devel/vfio-user.rst new file +8
-0+ re-read the device state in order to determine it afresh. + + The following device states are defined: + + +-----------+---------+----------+-----------------------------------+ + | _RESUMING | _SAVING | _RUNNING | Description | + +===========+=========+==========+===================================+
docs/devel/vfio-user.rst new file +21
-0+ | 0 | 0 | 0 | Device is stopped. | + +-----------+---------+----------+-----------------------------------+ + | 0 | 0 | 1 | Device is running, default state. | + +-----------+---------+----------+-----------------------------------+ + | 0 | 1 | 0 | Stop-and-copy state | + +-----------+---------+----------+-----------------------------------+ + | 0 | 1 | 1 | Pre-copy state | + +-----------+---------+----------+-----------------------------------+ + | 1 | 0 | 0 | Resuming | + +-----------+---------+----------+-----------------------------------+ + | 1 | 0 | 1 | Invalid state | + +-----------+---------+----------+-----------------------------------+ + | 1 | 1 | 0 | Error state | + +-----------+---------+----------+-----------------------------------+ + | 1 | 1 | 1 | Invalid state | + +-----------+---------+----------+-----------------------------------+ + + Valid state transitions are shown in the following table: + + +-------------------------+---------+---------+---------------+----------+----------+ + | |darr| From / To |rarr| | Stopped | Running | Stop-and-copy | Pre-copy |Resuming |
+
+=========================+=========+=========+===============+==
========+==========+docs/devel/vfio-user.rst new file +16
-0+ | Stopped | \- | 1 | 0 | 0 | 0 | + +-------------------------+---------+---------+---------------+----------+----------+ + | Running | 1 | \- | 1 | 1 | 1 | + +-------------------------+---------+---------+---------------+----------+----------+ + | Stop-and-copy | 1 | 1 | \- | 0 | 0 | + +-------------------------+---------+---------+---------------+----------+----------+ + | Pre-copy | 0 | 0 | 1 | \- | 0 | + +-------------------------+---------+---------+---------------+----------+----------+ + | Resuming | 0 | 1 | 0 | 0 | \- | + +-------------------------+---------+---------+---------------+----------+----------+ + + A device is migrated to the destination as follows: + + * The source client transitions the device state from the running state to + the pre-copy state. This transition is optional for the client but must be + supported by the server. The source server starts sending device state data
docs/devel/vfio-user.rst line 1683
Quoted 10 lines
docs/devel/vfio-user.rst new file +10
-0+ to the source client through the migration region while the device is + running. + + * The source client transitions the device state from the running state or the + pre-copy state to the stop-and-copy state. The source server stops the + device, saves device state and sends it to the source client through the + migration region. + + The source client is responsible for sending the migration data to the + destination client.
What happens when the device needs to dirty memory when transitioning to the stop-and-copy state? I would expect the source client to request dirty pages for mapped DMA regions (or use the "get dirty page bitmap"/ VFIO_DMA_UNMAP_FLAG_GET_DIRTY_BITMAP bit when unmapping the DMA region) and transmit those pages to the client destination. I've looked at linux/include/uapi/linux/vfio.h and it's not clear to me.
Quoted 151 lines
docs/devel/vfio-user.rst new file +64
-0+ + A device is resumed on the destination as follows: + + * The destination client transitions the device state from the running state + to the resuming state. The destination server uses the device state data + received through the migration region to resume the device. + + * The destination client provides saved device state to the destination + server and then transitions the device to back to the running state. + +* *reserved* This field is reserved and any access to it must be ignored by the + server. + +* *pending_bytes* Remaining bytes to be migrated by the server. This field is + read only. + +* *data_offset* Offset in the migration region where the client must: + + * read from, during the pre-copy or stop-and-copy state, or + + * write to, during the resuming state. + + This field is read only. + +* *data_size* Contains the size, in bytes, of the amount of data copied to: + + * the source migration region by the source server during the pre-copy or + stop-and copy state, or + + * the destination migration region by the destination client during the + resuming state. + +Device-specific data must be stored at any position after +``struct vfio_device_migration_info``. Note that the migration region can be +memory mappable, even partially. In practise, only the migration data portion +can be memory mapped. + +The client processes device state data during the pre-copy and the +stop-and-copy state in the following iterative manner: + + 1. The client reads ``pending_bytes`` to mark a new iteration. Repeated reads + of this field is an idempotent operation. If there are no migration data + to be consumed then the next step depends on the current device state: + + * pre-copy: the client must try again. + + * stop-and-copy: this procedure can end and the device can now start + resuming on the destination. + + 2. The client reads ``data_offset``; at this point the server must make + available a portion of migration data at this offset to be read by the + client, which must happen *before* completing the read operation. The + amount of data to be read must be stored in the ``data_size`` field, which + the client reads next. + + 3. The client reads ``data_size`` to determine the amount of migration data + available. + + 4. The client reads and processes the migration data. + + 5. Go to step 1. + +Note that the client can transition the device from the pre-copy state to the +stop-and-copy state at any time; ``pending_bytes`` does not need to becomezero.
docs/devel/vfio-user.rst new file +6
-0+ +The client initializes the device state on the destination by setting the +device state in the resuming state and writing the migration data to the +destination migration region at ``data_offset`` offset. The client can write the +source migration data in an iterative manner and the server must consume this +data before completing each write operation, updating the ``data_offset``field.
+The server must apply the source migration data on the device resume state. Thedocs/devel/vfio-user.rst new file +43
-0+client must write data on the same order and transaction size as read. + +If an error occurs then the server must fail the read or write operation. It is +an implementation detail of the client how to handle errors. + +Appendices +========== + +Unused VFIO ``ioctl()`` commands +-------------------------------- + +The following VFIO commands do not have an equivalent vfio-user command: + +* ``VFIO_GET_API_VERSION`` +* ``VFIO_CHECK_EXTENSION`` +* ``VFIO_SET_IOMMU`` +* ``VFIO_GROUP_GET_STATUS`` +* ``VFIO_GROUP_SET_CONTAINER`` +* ``VFIO_GROUP_UNSET_CONTAINER`` +* ``VFIO_GROUP_GET_DEVICE_FD`` +* ``VFIO_IOMMU_GET_INFO`` + +However, once support for live migration for VFIO devices is finalized some +of the above commands may have to be handled by the client in their +corresponding vfio-user form. This will be addressed in a future protocol +version. + +VFIO groups and containers +^^^^^^^^^^^^^^^^^^^^^^^^^^ + +The current VFIO implementation includes group and container idioms that +describe how a device relates to the host IOMMU. In the vfio-user +implementation, the IOMMU is implemented in SW by the client, and is not +visible to the server. The simplest idea would be that the client put each +device into its own group and container. + +Backend Program Conventions +--------------------------- + +vfio-user backend program conventions are based on the vhost-user ones. + +* The backend program must not daemonize itself. +* No assumptions must be made as to what access the backend program hason the
docs/devel/vfio-user.rst new file +13
-0+ system. +* File descriptors 0, 1 and 2 must exist, must have regular + stdin/stdout/stderr semantics, and can be redirected. +* The backend program must honor the SIGTERM signal. +* The backend program must accept the following commands line options: + + * ``--socket-path=PATH``: path to UNIX domain socket, + * ``--fd=FDNUM``: file descriptor for UNIX domain socket, incompatible with + ``--socket-path`` +* The backend program must be accompanied with a JSON file stored under + ``/usr/share/vfio-user``. + +TODO add schema similar to docs/interop/vhost-user.json.MAINTAINERS +6
-1@@ -1900,6 +1900,12 @@ F: hw/vfio/ap.c F: docs/system/s390x/vfio-ap.rst L: [email protected] +vfio-user +M: John G Johnson <[email protected]> +M: Thanos Makatos <[email protected]> +S: Supported +F: docs/devel/vfio-user.rst + vhost M: Michael S. Tsirkin <[email protected]> S: Supported --1.8.3.1
Re: [RFC v4 01/21] vfio-user: introduce vfio-user protocol specification
In reply to John JohnsonQuoted 4 lines · On Tue, 11 Jan 2022 16:43:37 -0800 John Johnson <[email protected]>…
docs/devel/vfio-user.rst new file +4
-0+VFIO region info cap sparse mmap +"""""""""""""""""""""""""""""""" + ++----------+--------+------+
docs/devel/vfio-user.rst line 887
Quoted 10 lines
docs/devel/vfio-user.rst new file +10
-0+| Name | Offset | Size | ++==========+========+======+ +| nr_areas | 0 | 4 | ++----------+--------+------+ +| reserved | 4 | 4 | ++----------+--------+------+ +| offset | 8 | 8 | ++----------+--------+------+ +| size | 16 | 9 | ++----------+--------+------+
Typo, I'm pretty sure size isn't 9 bytes.
Quoted 35 lines
+| ... | | |
++----------+--------+------+docs/devel/vfio-user.rst new file +33
-0+ +* *nr_areas* is the number of sparse mmap areas in the region. +* *offset* and size describe a single area that can be mapped by the client. + There will be *nr_areas* pairs of offset and size. The offset will be added to + the base offset given in the ``VFIO_USER_DEVICE_GET_REGION_INFO`` to form the + offset argument of the subsequent mmap() call. + +The VFIO sparse mmap area is defined in ``<linux/vfio.h>`` (``struct +vfio_region_info_cap_sparse_mmap``). + +VFIO region type cap header +""""""""""""""""""""""""""" + ++------------------+---------------------------+ +| Name | Value | ++==================+===========================+ +| id | VFIO_REGION_INFO_CAP_TYPE | ++------------------+---------------------------+ +| version | 0x1 | ++------------------+---------------------------+ +| next | <next> | ++------------------+---------------------------+ +| region info type | VFIO region info type | ++------------------+---------------------------+ + +This capability is defined when a region is specific to the device. + +VFIO region info type cap +""""""""""""""""""""""""" + +The VFIO region info type is defined in ``<linux/vfio.h>`` +(``struct vfio_region_info_cap_type``). +
docs/devel/vfio-user.rst line 932
Quoted 10 lines
docs/devel/vfio-user.rst new file +10
-0++---------+--------+------+ +| Name | Offset | Size | ++=========+========+======+ +| type | 0 | 4 | ++---------+--------+------+ +| subtype | 4 | 4 | ++---------+--------+------+ + +The only device-specific region type and subtype supported by vfio-user is +``VFIO_REGION_TYPE_MIGRATION`` (3) and ``VFIO_REGION_SUBTYPE_MIGRATION`` (1).
These should be considered deprecated from the kernel interface. I hope there are plans for vfio-user to adopt the new interface that's currently available in linux-next and intended for v5.18.
...
Quoted 8 lines
docs/devel/vfio-user.rst new file +8
-0+Unused VFIO ``ioctl()`` commands +-------------------------------- + +The following VFIO commands do not have an equivalent vfio-user command: + +* ``VFIO_GET_API_VERSION`` +* ``VFIO_CHECK_EXTENSION`` +* ``VFIO_SET_IOMMU``
docs/devel/vfio-user.rst line 1780
Quoted 10 lines
docs/devel/vfio-user.rst new file +10
-0+* ``VFIO_GROUP_GET_STATUS`` +* ``VFIO_GROUP_SET_CONTAINER`` +* ``VFIO_GROUP_UNSET_CONTAINER`` +* ``VFIO_GROUP_GET_DEVICE_FD`` +* ``VFIO_IOMMU_GET_INFO`` + +However, once support for live migration for VFIO devices is finalized some +of the above commands may have to be handled by the client in their +corresponding vfio-user form. This will be addressed in a future protocol +version.
As above, I'd go ahead and drop the migration region interface support, it's being removed from the kernel. Dirty page handling might also be something you want to pull back on as we're expecting in-kernel vfio to essentially deprecate its iommu backends in favor of a new shared userspace iommufd interface. We expect to have backwards compatibility via that interface, but as QEMU migration support for vfio-pci devices is experimental and there are desires not to consolidate dirty page tracking behind the iommu interface in the new model, it's not clear if the kernel will continue to expose the current dirty page tracking.
AIUI, we're expecting to see patches officially proposing the iommufd interface in the kernel "soon". Thanks,
Alex
Re: [RFC v4 01/21] vfio-user: introduce vfio-user protocol specification
Quoted 6 lines · Alex Williamson
Quoted 2 lines
+The only device-specific region type and subtype supported by vfio-user is +``VFIO_REGION_TYPE_MIGRATION`` (3) and ``VFIO_REGION_SUBTYPE_MIGRATION`` (1).
These should be considered deprecated from the kernel interface. I hope there are plans for vfio-user to adopt the new interface that's currently available in linux-next and intended for v5.18.
https://github.com/nutanix/libvfio-user/issues/654
regards
john
Re: [RFC v4 01/21] vfio-user: introduce vfio-user protocol specification
In reply to Alex WilliamsonQuoted 18 lines · Alex Williamson
Quoted 15 lines
docs/devel/vfio-user.rst new file +13
-0+ +VFIO region info type cap +""""""""""""""""""""""""" + +The VFIO region info type is defined in ``<linux/vfio.h>`` +(``struct vfio_region_info_cap_type``). + ++---------+--------+------+ +| Name | Offset | Size | ++=========+========+======+ +| type | 0 | 4 | ++---------+--------+------+ +| subtype | 4 | 4 |
Quoted 9 lines
docs/devel/vfio-user.rst line 932
Quoted 4 lines
++---------+--------+------+
docs/devel/vfio-user.rst new file +3
-0+ +The only device-specific region type and subtype supported by vfio-user is +``VFIO_REGION_TYPE_MIGRATION`` (3) and ``VFIO_REGION_SUBTYPE_MIGRATION`` (1).These should be considered deprecated from the kernel interface. I hope there are plans for vfio-user to adopt the new interface that's currently available in linux-next and intended for v5.18.
We will follow the interfaces that QEMU uses. Do you have an idea
when the VFIO v2 changes will be pulled into QEMU? Will the v2 code be experimental like v1 was?
Quoted 30 lines
...
Quoted 8 lines
docs/devel/vfio-user.rst new file +8
-0+Unused VFIO ``ioctl()`` commands +-------------------------------- + +The following VFIO commands do not have an equivalent vfio-user command: + +* ``VFIO_GET_API_VERSION`` +* ``VFIO_CHECK_EXTENSION`` +* ``VFIO_SET_IOMMU``docs/devel/vfio-user.rst line 1780
Quoted 10 lines
docs/devel/vfio-user.rst new file +10
-0+* ``VFIO_GROUP_GET_STATUS`` +* ``VFIO_GROUP_SET_CONTAINER`` +* ``VFIO_GROUP_UNSET_CONTAINER`` +* ``VFIO_GROUP_GET_DEVICE_FD`` +* ``VFIO_IOMMU_GET_INFO`` + +However, once support for live migration for VFIO devices is finalized some +of the above commands may have to be handled by the client in their +corresponding vfio-user form. This will be addressed in a future protocol +version.As above, I'd go ahead and drop the migration region interface support, it's being removed from the kernel. Dirty page handling might also be something you want to pull back on as we're expecting in-kernel vfio to essentially deprecate its iommu backends in favor of a new shared userspace iommufd interface. We expect to have backwards compatibility via that interface, but as QEMU migration support for vfio-pci devices is experimental and there are desires not to consolidate dirty page tracking behind the iommu interface in the new model, it's not clear if the kernel will continue to expose the current dirty page tracking.
Quoted 3 lines
AIUI, we're expecting to see patches officially proposing the iommufd interface in the kernel "soon". Thanks,
I’m not very concerned about which host kernel drivers QEMU will
interact with, as vfio-user doesn’t talk to any of them. I am interested in the data structures being used. Will they remain dirty bitmap based, or is a different structure being entertained?
JJ
RE: [RFC v4 01/21] vfio-user: introduce vfio-user protocol specification
In reply to Alex WilliamsonQuoted 113 lines
-----Original Message-----
From: Qemu-devel <qemu-devel- [email protected]> On Behalf Of Alex Williamson
Sent: 09 March 2022 22:35
To: John Johnson <[email protected]>
Cc: [email protected]
Subject: Re: [RFC v4 01/21] vfio-user: introduce vfio-user protocol specificationQuoted 4 lines · On Tue, 11 Jan 2022 16:43:37 -0800 John Johnson <[email protected]>…
docs/devel/vfio-user.rst new file +4
-0+VFIO region info cap sparse mmap +"""""""""""""""""""""""""""""""" + ++----------+--------+------+docs/devel/vfio-user.rst line 887
Quoted 10 lines
docs/devel/vfio-user.rst new file +10
-0+| Name | Offset | Size | ++==========+========+======+ +| nr_areas | 0 | 4 | ++----------+--------+------+ +| reserved | 4 | 4 | ++----------+--------+------+ +| offset | 8 | 8 | ++----------+--------+------+ +| size | 16 | 9 | ++----------+--------+------+Typo, I'm pretty sure size isn't 9 bytes.
docs/devel/vfio-user.rst
Quoted 7 lines
+| ... | | |
++----------+--------+------+docs/devel/vfio-user.rst new file +5
-0+ +* *nr_areas* is the number of sparse mmap areas in the region. +* *offset* and size describe a single area that can be mapped by the client. + There will be *nr_areas* pairs of offset and size. The offset will be added to + the base offset given in the ``VFIO_USER_DEVICE_GET_REGION_INFO`` toform the
Quoted 28 lines
docs/devel/vfio-user.rst new file +28
-0+ offset argument of the subsequent mmap() call. + +The VFIO sparse mmap area is defined in ``<linux/vfio.h>`` (``struct +vfio_region_info_cap_sparse_mmap``). + +VFIO region type cap header +""""""""""""""""""""""""""" + ++------------------+---------------------------+ +| Name | Value | ++==================+===========================+ +| id | VFIO_REGION_INFO_CAP_TYPE | ++------------------+---------------------------+ +| version | 0x1 | ++------------------+---------------------------+ +| next | <next> | ++------------------+---------------------------+ +| region info type | VFIO region info type | ++------------------+---------------------------+ + +This capability is defined when a region is specific to the device. + +VFIO region info type cap +""""""""""""""""""""""""" + +The VFIO region info type is defined in ``<linux/vfio.h>`` +(``struct vfio_region_info_cap_type``). +docs/devel/vfio-user.rst
Quoted 10 lines
docs/devel/vfio-user.rst new file +10
-0++---------+--------+------+ +| Name | Offset | Size | ++=========+========+======+ +| type | 0 | 4 | ++---------+--------+------+ +| subtype | 4 | 4 | ++---------+--------+------+ + +The only device-specific region type and subtype supported by vfio-user is +``VFIO_REGION_TYPE_MIGRATION`` (3) and``VFIO_REGION_SUBTYPE_MIGRATION`` (1).
These should be considered deprecated from the kernel interface. I hope there are plans for vfio-user to adopt the new interface that's currently available in linux-next and intended for v5.18.
...
docs/devel/vfio-user.rst
Quoted 4 lines
docs/devel/vfio-user.rst new file +4
-0+Unused VFIO ``ioctl()`` commands +-------------------------------- + +The following VFIO commands do not have an equivalent vfio-usercommand:
Quoted 4 lines
docs/devel/vfio-user.rst new file +4
-0+ +* ``VFIO_GET_API_VERSION`` +* ``VFIO_CHECK_EXTENSION`` +* ``VFIO_SET_IOMMU``docs/devel/vfio-user.rst line 1780
Quoted 10 lines
docs/devel/vfio-user.rst new file +10
-0+* ``VFIO_GROUP_GET_STATUS`` +* ``VFIO_GROUP_SET_CONTAINER`` +* ``VFIO_GROUP_UNSET_CONTAINER`` +* ``VFIO_GROUP_GET_DEVICE_FD`` +* ``VFIO_IOMMU_GET_INFO`` + +However, once support for live migration for VFIO devices is finalized some +of the above commands may have to be handled by the client in their +corresponding vfio-user form. This will be addressed in a future protocol +version.As above, I'd go ahead and drop the migration region interface support, it's being removed from the kernel. Dirty page handling might also be something you want to pull back on as we're expecting in-kernel vfio to essentially deprecate its iommu backends in favor of a new shared userspace iommufd interface. We expect to have backwards compatibility via that interface, but as QEMU migration support for vfio-pci devices is experimental and there are desires not to consolidate dirty page tracking behind the iommu interface in the new model, it's not clear if the kernel will continue to expose the current dirty page tracking.
Quoted 2 lines
AIUI, we're expecting to see patches officially proposing the iommufd interface in the kernel "soon". Thanks,
Are you referring to the "[RFC v2] /dev/iommu uAPI proposal" work (https://lkml.org/lkml/2021/7/9/89)?
Quoted 3 lines
Alex
Re: [RFC v4 01/21] vfio-user: introduce vfio-user protocol specification
Quoted 111 lines · On Tue, 15 Mar 2022 21:43:15 +0000 Thanos Makatos <[email protected]>…
Quoted 111 lines
-----Original Message-----
From: Qemu-devel <qemu-devel- [email protected]> On Behalf Of Alex Williamson
Sent: 09 March 2022 22:35
To: John Johnson <[email protected]>
Cc: [email protected]
Subject: Re: [RFC v4 01/21] vfio-user: introduce vfio-user protocol specificationQuoted 4 lines · On Tue, 11 Jan 2022 16:43:37 -0800 John Johnson <[email protected]>…
docs/devel/vfio-user.rst new file +4
-0+VFIO region info cap sparse mmap +"""""""""""""""""""""""""""""""" + ++----------+--------+------+docs/devel/vfio-user.rst line 887
Quoted 10 lines
docs/devel/vfio-user.rst new file +10
-0+| Name | Offset | Size | ++==========+========+======+ +| nr_areas | 0 | 4 | ++----------+--------+------+ +| reserved | 4 | 4 | ++----------+--------+------+ +| offset | 8 | 8 | ++----------+--------+------+ +| size | 16 | 9 | ++----------+--------+------+Typo, I'm pretty sure size isn't 9 bytes.
docs/devel/vfio-user.rst
Quoted 7 lines
+| ... | | |
++----------+--------+------+docs/devel/vfio-user.rst new file +5
-0+ +* *nr_areas* is the number of sparse mmap areas in the region. +* *offset* and size describe a single area that can be mapped by the client. + There will be *nr_areas* pairs of offset and size. The offset will be added to + the base offset given in the ``VFIO_USER_DEVICE_GET_REGION_INFO`` toform the
Quoted 28 lines
docs/devel/vfio-user.rst new file +28
-0+ offset argument of the subsequent mmap() call. + +The VFIO sparse mmap area is defined in ``<linux/vfio.h>`` (``struct +vfio_region_info_cap_sparse_mmap``). + +VFIO region type cap header +""""""""""""""""""""""""""" + ++------------------+---------------------------+ +| Name | Value | ++==================+===========================+ +| id | VFIO_REGION_INFO_CAP_TYPE | ++------------------+---------------------------+ +| version | 0x1 | ++------------------+---------------------------+ +| next | <next> | ++------------------+---------------------------+ +| region info type | VFIO region info type | ++------------------+---------------------------+ + +This capability is defined when a region is specific to the device. + +VFIO region info type cap +""""""""""""""""""""""""" + +The VFIO region info type is defined in ``<linux/vfio.h>`` +(``struct vfio_region_info_cap_type``). +docs/devel/vfio-user.rst
Quoted 10 lines
docs/devel/vfio-user.rst new file +10
-0++---------+--------+------+ +| Name | Offset | Size | ++=========+========+======+ +| type | 0 | 4 | ++---------+--------+------+ +| subtype | 4 | 4 | ++---------+--------+------+ + +The only device-specific region type and subtype supported by vfio-user is +``VFIO_REGION_TYPE_MIGRATION`` (3) and``VFIO_REGION_SUBTYPE_MIGRATION`` (1).
These should be considered deprecated from the kernel interface. I hope there are plans for vfio-user to adopt the new interface that's currently available in linux-next and intended for v5.18.
...
docs/devel/vfio-user.rst
Quoted 4 lines
docs/devel/vfio-user.rst new file +4
-0+Unused VFIO ``ioctl()`` commands +-------------------------------- + +The following VFIO commands do not have an equivalent vfio-usercommand:
Quoted 4 lines
docs/devel/vfio-user.rst new file +4
-0+ +* ``VFIO_GET_API_VERSION`` +* ``VFIO_CHECK_EXTENSION`` +* ``VFIO_SET_IOMMU``docs/devel/vfio-user.rst line 1780
Quoted 10 lines
docs/devel/vfio-user.rst new file +10
-0+* ``VFIO_GROUP_GET_STATUS`` +* ``VFIO_GROUP_SET_CONTAINER`` +* ``VFIO_GROUP_UNSET_CONTAINER`` +* ``VFIO_GROUP_GET_DEVICE_FD`` +* ``VFIO_IOMMU_GET_INFO`` + +However, once support for live migration for VFIO devices is finalized some +of the above commands may have to be handled by the client in their +corresponding vfio-user form. This will be addressed in a future protocol +version.As above, I'd go ahead and drop the migration region interface support, it's being removed from the kernel. Dirty page handling might also be something you want to pull back on as we're expecting in-kernel vfio to essentially deprecate its iommu backends in favor of a new shared userspace iommufd interface. We expect to have backwards compatibility via that interface, but as QEMU migration support for vfio-pci devices is experimental and there are desires not to consolidate dirty page tracking behind the iommu interface in the new model, it's not clear if the kernel will continue to expose the current dirty page tracking.
Quoted 4 lines
Quoted 2 lines
AIUI, we're expecting to see patches officially proposing the iommufd interface in the kernel "soon". Thanks,
Are you referring to the "[RFC v2]
/dev/iommuuAPI proposal" work (https://lkml.org/lkml/2021/7/9/89)?
There's a more recent proposal here:
https://lore.kernel.org/all/[email protected]/
But I suspect based on discussions that it's evolved quite a lot since then. Based on various test robot reports, I gather the current pre-release is tracking in Yi's tree here:
https://github.com/luxis1999/iommufd
Thanks,
Alex
Re: [RFC v4 01/21] vfio-user: introduce vfio-user protocol specification
In reply to Alex WilliamsonQuoted 37 lines · Alex Williamson
Quoted 31 lines · On Tue, 11 Jan 2022 16:43:37 -0800 John Johnson <[email protected]>…
docs/devel/vfio-user.rst new file +30
-0+ +VFIO region type cap header +""""""""""""""""""""""""""" + ++------------------+---------------------------+ +| Name | Value | ++==================+===========================+ +| id | VFIO_REGION_INFO_CAP_TYPE | ++------------------+---------------------------+ +| version | 0x1 | ++------------------+---------------------------+ +| next | <next> | ++------------------+---------------------------+ +| region info type | VFIO region info type | ++------------------+---------------------------+ + +This capability is defined when a region is specific to the device. + +VFIO region info type cap +""""""""""""""""""""""""" + +The VFIO region info type is defined in ``<linux/vfio.h>`` +(``struct vfio_region_info_cap_type``). + ++---------+--------+------+ +| Name | Offset | Size | ++=========+========+======+ +| type | 0 | 4 | ++---------+--------+------+ +| subtype | 4 | 4 |
Quoted 9 lines
docs/devel/vfio-user.rst line 932
Quoted 4 lines
++---------+--------+------+
docs/devel/vfio-user.rst new file +3
-0+ +The only device-specific region type and subtype supported by vfio-user is +``VFIO_REGION_TYPE_MIGRATION`` (3) and ``VFIO_REGION_SUBTYPE_MIGRATION`` (1).These should be considered deprecated from the kernel interface. I hope there are plans for vfio-user to adopt the new interface that's currently available in linux-next and intended for v5.18.
I re-issued the series without v1 migration support, but I
haven’t seen any additional feedback. What do you think the next step should be? Wait for v2 to be pulled and merge it? Something else? Thank you.
JJ
no migration URL:
https://lists.gnu.org/archive/html/qemu-devel/2022-05/msg01105.html
RFC v4 2/21 vfio-user: add VFIO base abstract class
In reply to John JohnsonAdd an abstract base class both the kernel driver and user socket implementations can use to share code.
--- hw/vfio/pci.h | 16 +++++++-- hw/vfio/pci.c | 106 +++++++++++++++++++++++++++++++++++----------------------- 2 files changed, 78 insertions(+), 44 deletions(-)
hw/vfio/pci.h +14 -2
@@ -114,8 +114,13 @@ typedef struct VFIOMSIXInfo {unsigned long *pending; } VFIOMSIXInfo; -#define TYPE_VFIO_PCI "vfio-pci" -OBJECT_DECLARE_SIMPLE_TYPE(VFIOPCIDevice, VFIO_PCI) +/* +* TYPE_VFIO_PCI_BASE is an abstract type used to share code +* between VFIO implementations that use a kernel driver +* with those that use user sockets. +*/ +#define TYPE_VFIO_PCI_BASE "vfio-pci-base" +OBJECT_DECLARE_SIMPLE_TYPE(VFIOPCIDevice, VFIO_PCI_BASE)struct VFIOPCIDevice {PCIDevice pdev;
@@ -175,6 +180,13 @@ struct VFIOPCIDevice {Notifier irqchip_change_notifier; }; +#define TYPE_VFIO_PCI "vfio-pci" +OBJECT_DECLARE_SIMPLE_TYPE(VFIOKernPCIDevice, VFIO_PCI) + +struct VFIOKernPCIDevice { +VFIOPCIDevice device; +}; +/* Use uin32_t for vendor & device so PCI_ANY_ID expands and cannot match hw */ static inline bool vfio_pci_is (VFIOPCIDevice *vdev,uint32_t vendor,uint32_t device) {
hw/vfio/pci.c +64 -42
229 lines not on this page · raw message
Signature · 1 line
1.8.3.1
RFC v4 3/21 vfio-user: add container IO ops vector
In reply to John JohnsonUsed for communication with VFIO driver
(prep work for vfio-user, which will communicate over a socket)
--- include/hw/vfio/vfio-common.h | 33 +++++++++++ hw/vfio/common.c | 126 ++++++++++++++++++++++++++++-------------- 2 files changed, 117 insertions(+), 42 deletions(-)
include/hw/vfio/vfio-common.h +33 -0
@@ -75,6 +75,7 @@ typedef struct VFIOAddressSpace { } VFIOAddressSpace;struct VFIOGroup ; +typedef struct VFIOContIO VFIOContIO ; typedef struct VFIOContainer { VFIOAddressSpace *space;
@@ -83,6 +84,7 @@ typedef struct VFIOContainer {MemoryListener prereg_listener;unsigned iommu_type;Error *error; +VFIOContIO *io_ops;bool initialized;bool dirty_pages_supported;uint64_t dirty_pgsizes;
@@ -154,6 +156,37 @@ struct VFIODeviceOps {int (*vfio_load_config)(VFIODevice *vdev,QEMUFile *f); }; +#ifdef CONFIG_LINUX + +/* +* The next 2 ops vectors are how Devices and Containers +* communicate with the server. The default option is +* through ioctl() to the kernel VFIO driver, but vfio-user +* can use a socket to a remote process. +*/ + +struct VFIOContIO { +int (*dma_map)(VFIOContainer *container, +struct vfio_iommu_type1_dma_map *map); +int (*dma_unmap)(VFIOContainer *container, +struct vfio_iommu_type1_dma_unmap *unmap, +struct vfio_bitmap *bitmap); +int (*dirty_bitmap)(VFIOContainer *container, +struct vfio_iommu_type1_dirty_bitmap *bitmap, +struct vfio_iommu_type1_dirty_bitmap_get *range); +}; + +#define CONT_DMA_MAP (cont, map) \ + ((cont)->io_ops->dma_map((cont), (map))) +#define CONT_DMA_UNMAP (cont, unmap, bitmap) \ + ((cont)->io_ops->dma_unmap((cont), (unmap), (bitmap))) +#define CONT_DIRTY_BITMAP (cont, bitmap, range) \ + ((cont)->io_ops->dirty_bitmap((cont), (bitmap), (range))) + +extern VFIOContIO vfio_cont_io_ioctl; + +#endif /* CONFIG_LINUX */ + typedef struct VFIOGroup { int fd; int groupid;
hw/vfio/common.c +84 -42
180 lines not on this page · raw message
Signature · 1 line
1.8.3.1
RFC v4 4/21 vfio-user: add region cache
In reply to John Johnsoncache VFIO_DEVICE_GET_REGION_INFO results to reduce memory alloc/free cycles and as prep work for vfio-user
--- include/hw/vfio/vfio-common.h | 2 ++ hw/vfio/ccw.c | 5 ----- hw/vfio/common.c | 41 +++++++++++++++++++++++++++++++++++------ hw/vfio/pci-quirks.c | 19 ++++++------------- hw/vfio/pci.c | 6 ------ 5 files changed, 43 insertions(+), 30 deletions(-)
include/hw/vfio/vfio-common.h +2 -0
@@ -145,6 +145,7 @@ typedef struct VFIODevice {VFIOMigration *migration;Error *migration_blocker;OnOffAuto pre_copy_dirty_page_tracking; +struct vfio_region_info **regions; } VFIODevice;struct VFIODeviceOps {
@@ -258,6 +259,7 @@ int vfio_get_region_info(VFIODevice *vbasedev, int index, struct vfio_region_info **info);int vfio_get_dev_region_info (VFIODevice *vbasedev,uint32_t type,uint32_t subtype,struct vfio_region_info **info); +void vfio_get_all_regions (VFIODevice *vbasedev);bool vfio_has_region_cap (VFIODevice *vbasedev,int region,uint16_t cap_type);struct vfio_info_cap_header *vfio_get_region_info_cap (struct vfio_region_info *info,uint16_t id);
hw/vfio/ccw.c +0 -5
@@ -517,7 +517,6 @@ static void vfio_ccw_get_region(VFIOCCWDevice *vcdev, Error **errp) vcdev->io_region_offset = info->offset; vcdev->io_region =g_malloc0 (info->size); -g_free (info);/* check for the optional async command region */ ret = vfio_get_dev_region_info(vdev, VFIO_REGION_TYPE_CCW,
@@ -530,7 +529,6 @@ static void vfio_ccw_get_region(VFIOCCWDevice *vcdev, Error **errp) } vcdev->async_cmd_region_offset = info->offset; vcdev->async_cmd_region =g_malloc0 (info->size); -g_free (info); } ret = vfio_get_dev_region_info(vdev, VFIO_REGION_TYPE_CCW,
@@ -543,7 +541,6 @@ static void vfio_ccw_get_region(VFIOCCWDevice *vcdev, Error **errp) } vcdev->schib_region_offset = info->offset; vcdev->schib_region =g_malloc (info->size); -g_free (info); } ret = vfio_get_dev_region_info(vdev, VFIO_REGION_TYPE_CCW,
@@ -557,7 +554,6 @@ static void vfio_ccw_get_region(VFIOCCWDevice *vcdev, Error **errp) } vcdev->crw_region_offset = info->offset; vcdev->crw_region =g_malloc (info->size); -g_free (info); }return ;
@@ -567,7 +563,6 @@ out_err:g_free (vcdev->schib_region);g_free (vcdev->async_cmd_region);g_free (vcdev->io_region); -g_free (info);return ; }
hw/vfio/common.c +35 -6
95 lines not on this page · raw message
hw/vfio/pci-quirks.c +6 -13
@@ -1601,16 +1601,14 @@ int vfio_pci_nvidia_v100_ram_init(VFIOPCIDevice *vdev, Error **errp) hdr =vfio_get_region_info_cap (nv2reg,VFIO_REGION_INFO_CAP_NVLINK2_SSATGT );if (!hdr) { - ret = -ENODEV ; - goto free_exit; +return -ENODEV ; } cap = (void *) hdr; p =mmap (NULL , nv2reg->size,PROT_READ |PROT_WRITE ,MAP_SHARED , vdev->vbasedev.fd, nv2reg->offset);if (p ==MAP_FAILED ) { - ret = -errno; - goto free_exit; +return -errno; } quirk =vfio_quirk_alloc (1 );
@@ -1623,7 +1621,7 @@ int vfio_pci_nvidia_v100_ram_init(VFIOPCIDevice *vdev, Error **errp) (void *) (uintptr_t) cap->tgt);trace_vfio_pci_nvidia_gpu_setup_quirk (vdev->vbasedev.name, cap->tgt, nv2reg->size); -free_exit: +g_free (nv2reg);return ret;
@@ -1651,16 +1649,14 @@ int vfio_pci_nvlink2_init(VFIOPCIDevice *vdev, Error **errp) hdr =vfio_get_region_info_cap (atsdreg,VFIO_REGION_INFO_CAP_NVLINK2_SSATGT );if (!hdr) { - ret = -ENODEV ; - goto free_exit; +return -ENODEV ; } captgt = (void *) hdr; hdr =vfio_get_region_info_cap (atsdreg,VFIO_REGION_INFO_CAP_NVLINK2_LNKSPD );if (!hdr) { - ret = -ENODEV ; - goto free_exit; +return -ENODEV ; } capspeed = (void *) hdr;
@@ -1669,8 +1665,7 @@ int vfio_pci_nvlink2_init(VFIOPCIDevice *vdev, Error **errp) p =mmap (NULL , atsdreg->size,PROT_READ |PROT_WRITE ,MAP_SHARED , vdev->vbasedev.fd, atsdreg->offset);if (p ==MAP_FAILED ) { - ret = -errno; - goto free_exit; +return -errno; } quirk =vfio_quirk_alloc (1 );
@@ -1690,8 +1685,6 @@ int vfio_pci_nvlink2_init(VFIOPCIDevice *vdev, Error **errp) (void *) (uintptr_t) capspeed->link_speed);trace_vfio_pci_nvlink2_setup_quirk_lnkspd (vdev->vbasedev.name, capspeed->link_speed); -free_exit: -g_free (atsdreg);return ret; }
hw/vfio/pci.c +0 -6
@@ -790,8 +790,6 @@ static void vfio_pci_load_rom(VFIOPCIDevice *vdev) vdev->rom_size = size = reg_info->size; vdev->rom_offset = reg_info->offset; -g_free (reg_info); -if (!vdev->rom_size) { vdev->rom_read_failed = true; error_report("vfio-pci: Cannot read device rom at "
@@ -2518,7 +2516,6 @@ int vfio_populate_vga(VFIOPCIDevice *vdev, Error **errp)error_setg (errp,"unexpected VGA info, flags 0x%lx, size 0x%lx" , (unsigned long )reg_info->flags, (unsigned long )reg_info->size); -g_free (reg_info);return -EINVAL ; }
@@ -2623,8 +2620,6 @@ static void vfio_populate_device(VFIOPCIDevice *vdev, Error **errp) } vdev->config_offset = reg_info->offset; -g_free (reg_info); -if (vdev->features &VFIO_FEATURE_ENABLE_VGA ) { ret =vfio_populate_vga (vdev, errp);if (ret) {
@@ -3032,7 +3027,6 @@ static void vfio_realize(PCIDevice *pdev, Error **errp) } ret =vfio_pci_igd_opregion_init (vdev, opregion, errp); -g_free (opregion);if (ret) { goto out_teardown; }
Signature · 1 line
1.8.3.1
Re: [RFC v4 04/21] vfio-user: add region cache
Quoted 24 lines · On Tue, 11 Jan 2022 16:43:40 -0800 John Johnson <[email protected]>…
hw/vfio/pci-quirks.c +2
-4@@ -1601,16 +1601,14 @@ int vfio_pci_nvidia_v100_ram_init(VFIOPCIDevice *vdev, Error **errp) hdr =vfio_get_region_info_cap (nv2reg,VFIO_REGION_INFO_CAP_NVLINK2_SSATGT );if (!hdr) { - ret = -ENODEV ; - goto free_exit; +return -ENODEV ; } cap = (void *) hdr; p =mmap (NULL , nv2reg->size,PROT_READ |PROT_WRITE ,MAP_SHARED , vdev->vbasedev.fd, nv2reg->offset);if (p ==MAP_FAILED ) { - ret = -errno; - goto free_exit; +return -errno; } quirk =vfio_quirk_alloc (1 );
hw/vfio/pci-quirks.c int vfio_pci_nvidia_v100_ram_init(VFIOPCIDevice *vdev, Error **errp) · line 1625
Quoted 6 lines
hw/vfio/pci-quirks.c +1
-1@@ -1623,7 +1621,7 @@ int vfio_pci_nvidia_v100_ram_init(VFIOPCIDevice *vdev, Error **errp) (void *) (uintptr_t) cap->tgt);trace_vfio_pci_nvidia_gpu_setup_quirk (vdev->vbasedev.name, cap->tgt, nv2reg->size); -free_exit: +g_free (nv2reg);
Shouldn't this g_free() be removed as well?
Quoted 32 lines
hw/vfio/pci-quirks.c +3
-6return ret;@@ -1651,16 +1649,14 @@ int vfio_pci_nvlink2_init(VFIOPCIDevice *vdev, Error **errp) hdr =vfio_get_region_info_cap (atsdreg,VFIO_REGION_INFO_CAP_NVLINK2_SSATGT );if (!hdr) { - ret = -ENODEV ; - goto free_exit; +return -ENODEV ; } captgt = (void *) hdr; hdr =vfio_get_region_info_cap (atsdreg,VFIO_REGION_INFO_CAP_NVLINK2_LNKSPD );if (!hdr) { - ret = -ENODEV ; - goto free_exit; +return -ENODEV ; } capspeed = (void *) hdr;@@ -1669,8 +1665,7 @@ int vfio_pci_nvlink2_init(VFIOPCIDevice *vdev, Error **errp) p =mmap (NULL , atsdreg->size,PROT_READ |PROT_WRITE ,MAP_SHARED , vdev->vbasedev.fd, atsdreg->offset);if (p ==MAP_FAILED ) { - ret = -errno; - goto free_exit; +return -errno; } quirk =vfio_quirk_alloc (1 );
hw/vfio/pci-quirks.c int vfio_pci_nvlink2_init(VFIOPCIDevice *vdev, Error **errp) · line 1694
Quoted 5 lines
hw/vfio/pci-quirks.c +0
-2@@ -1690,8 +1685,6 @@ int vfio_pci_nvlink2_init(VFIOPCIDevice *vdev, Error **errp) (void *) (uintptr_t) capspeed->link_speed);trace_vfio_pci_nvlink2_setup_quirk_lnkspd (vdev->vbasedev.name, capspeed->link_speed); -free_exit: -g_free (atsdreg);
Like was done for this equivalent usage. Thanks,
Alex
RFC v4 5/21 vfio-user: add device IO ops vector
In reply to John JohnsonUsed for communication with VFIO driver
(prep work for vfio-user, which will communicate over a socket)
--- include/hw/vfio/vfio-common.h | 27 ++++++++ hw/vfio/common.c | 107 +++++++++++++++++++++++++++----- hw/vfio/pci.c | 140 ++++++++++++++++++++++++++---------------- 3 files changed, 206 insertions(+), 68 deletions(-)
include/hw/vfio/vfio-common.h +27 -0
@@ -124,6 +124,7 @@ typedef struct VFIOHostDMAWindow { } VFIOHostDMAWindow;typedef struct VFIODeviceOps VFIODeviceOps ; +typedef struct VFIODevIO VFIODevIO ; typedef struct VFIODevice { QLIST_ENTRY(VFIODevice) next;
@@ -139,6 +140,7 @@ typedef struct VFIODevice {bool ram_block_discard_allowed;bool enable_migration;VFIODeviceOps *ops; +VFIODevIO *io_ops;unsigned int num_irqs;unsigned int num_regions;unsigned int flags;
@@ -165,6 +167,30 @@ struct VFIODeviceOps {* through ioctl() to the kernel VFIO driver, but vfio-user * can use a socket to a remote process. */ +struct VFIODevIO { +int (*get_info)(VFIODevice *vdev,struct vfio_device_info *info); +int (*get_region_info)(VFIODevice *vdev, +struct vfio_region_info *info); +int (*get_irq_info)(VFIODevice *vdev,struct vfio_irq_info *irq); +int (*set_irqs)(VFIODevice *vdev,struct vfio_irq_set *irqs); +int (*region_read)(VFIODevice *vdev,uint8_t nr,off_t off,uint32_t size, +void *data); +int (*region_write)(VFIODevice *vdev,uint8_t nr,off_t off,uint32_t size, +void *data); +}; + +#define VDEV_GET_INFO (vdev, info) \ + ((vdev)->io_ops->get_info((vdev), (info))) +#define VDEV_GET_REGION_INFO (vdev, info) \ + ((vdev)->io_ops->get_region_info((vdev), (info))) +#define VDEV_GET_IRQ_INFO (vdev, irq) \ + ((vdev)->io_ops->get_irq_info((vdev), (irq))) +#define VDEV_SET_IRQS (vdev, irqs) \ + ((vdev)->io_ops->set_irqs((vdev), (irqs))) +#define VDEV_REGION_READ (vdev, nr, off, size, data) \ + ((vdev)->io_ops->region_read((vdev), (nr), (off), (size), (data))) +#define VDEV_REGION_WRITE (vdev, nr, off, size, data) \ + ((vdev)->io_ops->region_write((vdev), (nr), (off), (size), (data)))struct VFIOContIO { int (*dma_map)(VFIOContainer *container,
@@ -184,6 +210,7 @@ struct VFIOContIO {#define CONT_DIRTY_BITMAP (cont, bitmap, range) \ ((cont)->io_ops->dirty_bitmap((cont), (bitmap), (range))) +extern VFIODevIO vfio_dev_io_ioctl;extern VFIOContIO vfio_cont_io_ioctl;#endif /* CONFIG_LINUX */
hw/vfio/common.c +92 -15
176 lines not on this page · raw message
hw/vfio/pci.c +87 -53
289 lines not on this page · raw message
Signature · 1 line
1.8.3.1
RFC v4 6/21 vfio-user: Define type vfio_user_pci_dev_info
In reply to John JohnsonNew class for vfio-user with its class and instance constructors and destructors, and its pci ops.
--- hw/vfio/pci.h | 8 +++++ hw/vfio/common.c | 5 ++++ hw/vfio/pci.c | 90 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++ hw/vfio/Kconfig | 10 +++++++ 4 files changed, 113 insertions(+)
hw/vfio/pci.h +8 -0
@@ -187,6 +187,14 @@ struct VFIOKernPCIDevice {VFIOPCIDevice device; }; +#define TYPE_VFIO_USER_PCI "vfio-user-pci" +OBJECT_DECLARE_SIMPLE_TYPE(VFIOUserPCIDevice, VFIO_USER_PCI) + +struct VFIOUserPCIDevice { +VFIOPCIDevice device; +char *sock_name; +}; +/* Use uin32_t for vendor & device so PCI_ANY_ID expands and cannot match hw */ static inline bool vfio_pci_is (VFIOPCIDevice *vdev,uint32_t vendor,uint32_t device) {
hw/vfio/common.c +5 -0
@@ -1742,6 +1742,11 @@ void vfio_reset_handler(void *opaque) QLIST_FOREACH(group, &vfio_group_list, next) { QLIST_FOREACH(vbasedev, &group->device_list, next) {if (vbasedev->dev->realized && vbasedev->needs_reset) { +if (vbasedev->ops->vfio_hot_reset_multi ==NULL ) { +error_printf ("%s: No hot reset handler specified\n" , + vbasedev->name); +continue ; + } vbasedev->ops->vfio_hot_reset_multi (vbasedev); } }
hw/vfio/pci.c +90 -0
99 lines not on this page · raw message
hw/vfio/Kconfig +10 -0
@@ -2,6 +2,10 @@ config VFIO bool depends on LINUX +config VFIO_USER + bool + depends on VFIO + config VFIO_PCI bool default y
@@ -9,6 +13,12 @@ config VFIO_PCI select EDID depends on LINUX && PCI +config VFIO_USER_PCI + bool + default y + select VFIO_USER + depends on VFIO_PCI + config VFIO_CCW bool default y
Signature · 1 line
1.8.3.1
RFC v4 7/21 vfio-user: connect vfio proxy to remote server
In reply to John Johnsonadd user.c & user.h files for vfio-user code add proxy struct to handle comms with remote server
--- hw/vfio/user.h | 78 +++++++++++++++++++ include/hw/vfio/vfio-common.h | 2 + hw/vfio/pci.c | 19 +++++ hw/vfio/user.c | 170 ++++++++++++++++++++++++++++++++++++++++++ MAINTAINERS | 4 + hw/vfio/meson.build | 1 + 6 files changed, 274 insertions(+) create mode 100644 hw/vfio/user.h create mode 100644 hw/vfio/user.c
hw/vfio/user.h new file +78 -0
@@ -0,0 +1,78 @@ +#ifndef VFIO_USER_H +#define VFIO_USER_H + +/* +* vfio protocol over a UNIX socket. +* +* Copyright © 2018, 2021 Oracle and/or its affiliates. +* +* This work is licensed under the terms of the GNU GPL, version 2. See +* the COPYING file in the top-level directory. +* +*/ + +typedef struct { +int send_fds; +int recv_fds; +int *fds; +}VFIOUserFDs ; + +enum msg_type { +VFIO_MSG_NONE , +VFIO_MSG_ASYNC , +VFIO_MSG_WAIT , +VFIO_MSG_NOWAIT , +VFIO_MSG_REQ , +}; + +typedef struct VFIOUserMsg { +QTAILQ_ENTRY (VFIOUserMsg) next; +VFIOUserFDs *fds; +uint32_t rsize; +uint32_t id; +QemuCond cv; +bool complete; +enum msg_type type; +}VFIOUserMsg ; + + +enum proxy_state { +VFIO_PROXY_CONNECTED =1 , +VFIO_PROXY_ERROR =2 , +VFIO_PROXY_CLOSING =3 , +VFIO_PROXY_CLOSED =4 , +}; + +typedef QTAILQ_HEAD(VFIOUserMsgQ, VFIOUserMsg) VFIOUserMsgQ; + +typedef struct VFIOProxy { +QLIST_ENTRY (VFIOProxy) next; +char *sockname; +struct QIOChannel *ioc; +void (*request)(void *opaque,VFIOUserMsg *msg); +void *req_arg; +int flags; +QemuCond close_cv; +AioContext *ctx; +QEMUBH *req_bh; + +/* +* above only changed when BQL is held +* below are protected by per-proxy lock +*/ +QemuMutex lock; +VFIOUserMsgQ free; +VFIOUserMsgQ pending; +VFIOUserMsgQ incoming; +VFIOUserMsgQ outgoing; +VFIOUserMsg *last_nowait; +enum proxy_state state; +}VFIOProxy ; + +/* VFIOProxy flags */ +#define VFIO_PROXY_CLIENT 0x1 + +VFIOProxy *vfio_user_connect_dev (SocketAddress *addr,Error **errp); +void vfio_user_disconnect (VFIOProxy *proxy); + +#endif /* VFIO_USER_H */
include/hw/vfio/vfio-common.h +2 -0
@@ -76,6 +76,7 @@ typedef struct VFIOAddressSpace {struct VFIOGroup ;typedef struct VFIOContIO VFIOContIO ; +typedef struct VFIOProxy VFIOProxy ; typedef struct VFIOContainer { VFIOAddressSpace *space;
@@ -147,6 +148,7 @@ typedef struct VFIODevice {VFIOMigration *migration;Error *migration_blocker;OnOffAuto pre_copy_dirty_page_tracking; +VFIOProxy *proxy;struct vfio_region_info **regions; } VFIODevice;
hw/vfio/pci.c +19 -0
@@ -43,6 +43,7 @@#include "qapi/error.h" #include "migration/blocker.h" #include "migration/qemu-file.h" +#include "hw/vfio/user.h" /* convenience macros for PCI config space */ #define VDEV_CONFIG_READ (vbasedev, off, size, data) \
@@ -3407,6 +3408,9 @@ static void vfio_user_pci_realize(PCIDevice *pdev, Error **errp)VFIOUserPCIDevice *udev =VFIO_USER_PCI (pdev);VFIOPCIDevice *vdev =VFIO_PCI_BASE (pdev);VFIODevice *vbasedev = &vdev->vbasedev; +SocketAddress addr; +VFIOProxy *proxy; +Error *err =NULL ;/* * TODO: make option parser understand SocketAddress
@@ -3419,6 +3423,16 @@ static void vfio_user_pci_realize(PCIDevice *pdev, Error **errp)return ; } +memset (&addr,0 ,sizeof (addr)); + addr.type =SOCKET_ADDRESS_TYPE_UNIX ; + addr.u.q_unix.path = udev->sock_name; + proxy =vfio_user_connect_dev (&addr, &err); +if (!proxy) { +error_setg (errp,"Remote proxy not found" ); +return ; + } + vbasedev->proxy = proxy; + vbasedev->name =g_strdup_printf ("VFIO user <%s>" , udev->sock_name); vbasedev->dev =DEVICE (vdev); vbasedev->fd =-1 ;
@@ -3430,8 +3444,13 @@ static void vfio_user_pci_realize(PCIDevice *pdev, Error **errp)static void vfio_user_instance_finalize (Object *obj) {VFIOPCIDevice *vdev =VFIO_PCI_BASE (obj); +VFIODevice *vbasedev = &vdev->vbasedev;vfio_put_device (vdev); + +if (vbasedev->proxy !=NULL ) { +vfio_user_disconnect (vbasedev->proxy); + } }static Property vfio_user_pci_dev_properties[] = {
hw/vfio/user.c new file +170 -0
170 lines not on this page · raw message
MAINTAINERS +4 -0
@@ -1903,8 +1903,12 @@ L: [email protected] vfio-user M: John G Johnson <[email protected]> M: Thanos Makatos <[email protected]> +M: Elena Ufimtseva <[email protected]> +M: Jagannathan Raman <[email protected]> S: Supported F: docs/devel/vfio-user.rst +F: hw/vfio/user.c +F: hw/vfio/user.h vhost M: Michael S. Tsirkin <[email protected]>
hw/vfio/meson.build +1 -0
@@ -9,6 +9,7 @@ vfio_ss.add(when: 'CONFIG_VFIO_PCI', if_true: files( 'pci-quirks.c', 'pci.c', )) +vfio_ss.add(when: 'CONFIG_VFIO_USER', if_true: files('user.c')) vfio_ss.add(when: 'CONFIG_VFIO_CCW', if_true: files('ccw.c')) vfio_ss.add(when: 'CONFIG_VFIO_PLATFORM', if_true: files('platform.c')) vfio_ss.add(when: 'CONFIG_VFIO_XGMAC', if_true: files('calxeda-xgmac.c'))
Signature · 1 line
1.8.3.1
RFC v4 8/21 vfio-user: define socket receive functions
In reply to John JohnsonAdd infrastructure needed to receive incoming messages
--- hw/vfio/user-protocol.h | 54 ++++++++ hw/vfio/user.h | 6 + hw/vfio/pci.c | 6 + hw/vfio/user.c | 327 ++++++++++++++++++++++++++++++++++++++++++++++++ MAINTAINERS | 1 + 5 files changed, 394 insertions(+) create mode 100644 hw/vfio/user-protocol.h
hw/vfio/user-protocol.h new file +54 -0
@@ -0,0 +1,54 @@ +#ifndef VFIO_USER_PROTOCOL_H +#define VFIO_USER_PROTOCOL_H + +/* +* vfio protocol over a UNIX socket. +* +* Copyright © 2018, 2021 Oracle and/or its affiliates. +* +* This work is licensed under the terms of the GNU GPL, version 2. See +* the COPYING file in the top-level directory. +* +* Each message has a standard header that describes the command +* being sent, which is almost always a VFIO ioctl(). +* +* The header may be followed by command-specific data, such as the +* region and offset info for read and write commands. +*/ + +typedef struct { +uint16_t id; +uint16_t command; +uint32_t size; +uint32_t flags; +uint32_t error_reply; +}VFIOUserHdr ; + +/* VFIOUserHdr commands */ +enum vfio_user_command { +VFIO_USER_VERSION =1 , +VFIO_USER_DMA_MAP =2 , +VFIO_USER_DMA_UNMAP =3 , +VFIO_USER_DEVICE_GET_INFO =4 , +VFIO_USER_DEVICE_GET_REGION_INFO =5 , +VFIO_USER_DEVICE_GET_REGION_IO_FDS =6 , +VFIO_USER_DEVICE_GET_IRQ_INFO =7 , +VFIO_USER_DEVICE_SET_IRQS =8 , +VFIO_USER_REGION_READ =9 , +VFIO_USER_REGION_WRITE =10 , +VFIO_USER_DMA_READ =11 , +VFIO_USER_DMA_WRITE =12 , +VFIO_USER_DEVICE_RESET =13 , +VFIO_USER_DIRTY_PAGES =14 , +VFIO_USER_MAX , +}; + +/* VFIOUserHdr flags */ +#define VFIO_USER_REQUEST 0x0 +#define VFIO_USER_REPLY 0x1 +#define VFIO_USER_TYPE 0xF + +#define VFIO_USER_NO_REPLY 0x10 +#define VFIO_USER_ERROR 0x20 + +#endif /* VFIO_USER_PROTOCOL_H */
hw/vfio/user.h +6 -0
@@ -11,6 +11,8 @@* */ +#include "user-protocol.h" + typedef struct { int send_fds; int recv_fds;
@@ -27,6 +29,7 @@ enum msg_type { typedef struct VFIOUserMsg { QTAILQ_ENTRY(VFIOUserMsg) next; + VFIOUserHdr *hdr; VFIOUserFDs *fds; uint32_t rsize; uint32_t id;
@@ -74,5 +77,8 @@ typedef struct VFIOProxy {VFIOProxy *vfio_user_connect_dev (SocketAddress *addr,Error **errp);void vfio_user_disconnect (VFIOProxy *proxy); +void vfio_user_set_handler (VFIODevice *vbasedev, +void (*handler)(void *opaque,VFIOUserMsg *msg), +void *reqarg);#endif /* VFIO_USER_H */
hw/vfio/pci.c +6 -0
@@ -3386,6 +3386,11 @@ type_init(register_vfio_pci_dev_type)* vfio-user routines. */ +static void vfio_user_pci_process_req (void *opaque,VFIOUserMsg *msg) +{ + +} +/* * Emulated devices don't use host hot reset */
@@ -3432,6 +3437,7 @@ static void vfio_user_pci_realize(PCIDevice *pdev, Error **errp)return ; } vbasedev->proxy = proxy; +vfio_user_set_handler (vbasedev, vfio_user_pci_process_req, vdev); vbasedev->name =g_strdup_printf ("VFIO user <%s>" , udev->sock_name); vbasedev->dev =DEVICE (vdev);
hw/vfio/user.c +327 -0
371 lines not on this page · raw message
MAINTAINERS +1 -0
@@ -1909,6 +1909,7 @@ S: Supported F: docs/devel/vfio-user.rst F: hw/vfio/user.c F: hw/vfio/user.h +F: hw/vfio/user-protocol.h vhost M: Michael S. Tsirkin <[email protected]>
Signature · 1 line
1.8.3.1
RE: [RFC v4 08/21] vfio-user: define socket receive functions
Quoted 365 lines
-----Original Message-----
From: Qemu-devel <qemu-devel- [email protected]> On Behalf Of John Johnson
Sent: 12 January 2022 00:44
To: [email protected]
Subject: [RFC v4 08/21] vfio-user: define socket receive functionsAdd infrastructure needed to receive incoming messages
Signed-off-by John G Johnson <[email protected]>Signed-off-by Elena Ufimtseva <[email protected]>Signed-off-by Jagannathan Raman <[email protected]>--- hw/vfio/user-protocol.h | 54 ++++++++ hw/vfio/user.h | 6 + hw/vfio/pci.c | 6 + hw/vfio/user.c | 327 ++++++++++++++++++++++++++++++++++++++++++++++++ MAINTAINERS | 1 + 5 files changed, 394 insertions(+) create mode 100644 hw/vfio/user-protocol.hhw/vfio/user-protocol.h new file +54
-0@@ -0,0 +1,54 @@ +#ifndef VFIO_USER_PROTOCOL_H +#define VFIO_USER_PROTOCOL_H + +/* +* vfio protocol over a UNIX socket. +* +* Copyright © 2018, 2021 Oracle and/or its affiliates. +* +* This work is licensed under the terms of the GNU GPL, version 2. See +* the COPYING file in the top-level directory. +* +* Each message has a standard header that describes the command +* being sent, which is almost always a VFIO ioctl(). +* +* The header may be followed by command-specific data, such as the +* region and offset info for read and write commands. +*/ + +typedef struct { +uint16_t id; +uint16_t command; +uint32_t size; +uint32_t flags; +uint32_t error_reply; +}VFIOUserHdr ; + +/* VFIOUserHdr commands */ +enum vfio_user_command { +VFIO_USER_VERSION =1 , +VFIO_USER_DMA_MAP =2 , +VFIO_USER_DMA_UNMAP =3 , +VFIO_USER_DEVICE_GET_INFO =4 , +VFIO_USER_DEVICE_GET_REGION_INFO =5 , +VFIO_USER_DEVICE_GET_REGION_IO_FDS =6 , +VFIO_USER_DEVICE_GET_IRQ_INFO =7 , +VFIO_USER_DEVICE_SET_IRQS =8 , +VFIO_USER_REGION_READ =9 , +VFIO_USER_REGION_WRITE =10 , +VFIO_USER_DMA_READ =11 , +VFIO_USER_DMA_WRITE =12 , +VFIO_USER_DEVICE_RESET =13 , +VFIO_USER_DIRTY_PAGES =14 , +VFIO_USER_MAX , +}; + +/* VFIOUserHdr flags */ +#define VFIO_USER_REQUEST 0x0 +#define VFIO_USER_REPLY 0x1 +#define VFIO_USER_TYPE 0xF + +#define VFIO_USER_NO_REPLY 0x10 +#define VFIO_USER_ERROR 0x20 + +#endif /* VFIO_USER_PROTOCOL_H */ hw/vfio/user.h +6
-0@@ -11,6 +11,8 @@* */ +#include "user-protocol.h" + typedef struct { int send_fds; int recv_fds;@@ -27,6 +29,7 @@ enum msg_type { typedef struct VFIOUserMsg { QTAILQ_ENTRY(VFIOUserMsg) next; + VFIOUserHdr *hdr; VFIOUserFDs *fds; uint32_t rsize; uint32_t id;@@ -74,5 +77,8 @@ typedef struct VFIOProxy {VFIOProxy *vfio_user_connect_dev (SocketAddress *addr,Error **errp);void vfio_user_disconnect (VFIOProxy *proxy); +void vfio_user_set_handler (VFIODevice *vbasedev, +void (*handler)(void *opaque,VFIOUserMsg *msg), +void *reqarg);#endif /* VFIO_USER_H */ hw/vfio/pci.c +6
-0@@ -3386,6 +3386,11 @@ type_init(register_vfio_pci_dev_type)* vfio-user routines. */ +static void vfio_user_pci_process_req (void *opaque,VFIOUserMsg *msg) +{ + +} +/* * Emulated devices don't use host hot reset */ @@ -3432,6 +3437,7 @@ static void vfio_user_pci_realize(PCIDevice *pdev, Error **errp) return; } vbasedev->proxy = proxy; +vfio_user_set_handler (vbasedev, vfio_user_pci_process_req, vdev); vbasedev->name =g_strdup_printf ("VFIO user <%s>" , udev->sock_name);vbasedev->dev = DEVICE(vdev);hw/vfio/user.c +202
-0@@ -25,10 +25,26 @@#include "sysemu/iothread.h" #include "user.h" +static uint64_t max_xfer_size;static IOThread *vfio_user_iothread;static void vfio_user_shutdown (VFIOProxy *proxy); +static VFIOUserMsg *vfio_user_getmsg (VFIOProxy *proxy,VFIOUserHdr *hdr, +VFIOUserFDs *fds); +static VFIOUserFDs *vfio_user_getfds (int numfds); +static void vfio_user_recycle (VFIOProxy *proxy,VFIOUserMsg *msg); +static void vfio_user_recv (void *opaque); +static int vfio_user_recv_one (VFIOProxy *proxy); +static void vfio_user_cb (void *opaque); + +static void vfio_user_request (void *opaque); + +static inline void vfio_user_set_error (VFIOUserHdr *hdr,uint32_t err) +{ + hdr->flags |=VFIO_USER_ERROR ; + hdr->error_reply = err; +}/* * Functions called by main, CPU, or iothread threads @@ -40,10 +56,261 @@ static void vfio_user_shutdown(VFIOProxy *proxy)qio_channel_set_aio_fd_handler (proxy->ioc, proxy->ctx,NULL ,NULL ,NULL ); } +static VFIOUserMsg *vfio_user_getmsg (VFIOProxy *proxy,VFIOUserHdr *hdr, +VFIOUserFDs *fds) +{ +VFIOUserMsg *msg; + + msg =QTAILQ_FIRST (&proxy->free); +if (msg !=NULL ) { +QTAILQ_REMOVE (&proxy->free, msg, next); + }else { + msg =g_malloc0 (sizeof (*msg)); +qemu_cond_init (&msg->cv); + } + + msg->hdr = hdr; + msg->fds = fds; +return msg; +} + +/* +* Recycle a message list entry to the free list. +*/ +static void vfio_user_recycle (VFIOProxy *proxy,VFIOUserMsg *msg) +{ +if (msg->type ==VFIO_MSG_NONE ) { +error_printf ("vfio_user_recycle - freeing free msg\n" ); +return ; + } + +/* free msg buffer if no one is waiting to consume the reply */ +if (msg->type ==VFIO_MSG_NOWAIT || msg->type ==VFIO_MSG_ASYNC ) { +g_free (msg->hdr); +if (msg->fds !=NULL ) { +g_free (msg->fds); + } + } + + msg->type =VFIO_MSG_NONE ; + msg->hdr =NULL ; + msg->fds =NULL ; + msg->complete = false; +QTAILQ_INSERT_HEAD (&proxy->free, msg, next); +} + +static VFIOUserFDs *vfio_user_getfds (int numfds) +{ +VFIOUserFDs *fds =g_malloc0 (sizeof (*fds) + (numfds *sizeof (int ))); + + fds->fds = (int *)((char *)fds +sizeof (*fds)); + +return fds; +} +/* * Functions only called by iothread */ +static void vfio_user_recv (void *opaque) +{ +VFIOProxy *proxy = opaque; + +QEMU_LOCK_GUARD (&proxy->lock); + +if (proxy->state ==VFIO_PROXY_CONNECTED ) { +while (vfio_user_recv_one (proxy) ==0 ) { + ; + } + } +} + +/* +* Receive and process one incoming message. +* +* For replies, find matching outgoing request and wake any waiters. +* For requests, queue in incoming list and run request BH. +*/ +static int vfio_user_recv_one (VFIOProxy *proxy) +{ +VFIOUserMsg *msg =NULL ; + g_autofree int *fdp = NULL; +VFIOUserFDs *reqfds; +VFIOUserHdr hdr; +struct iovec iov = { + .iov_base = &hdr, + .iov_len =sizeof (hdr), + }; +bool isreply = false; +int i, ret; +size_t msgleft, numfds =0 ; +char *data =NULL ; +char *buf =NULL ; +Error *local_err =NULL ; + +/* +* Read header +*/ + ret =qio_channel_readv_full (proxy->ioc, &iov,1 , &fdp, &numfds, + &local_err); +if (ret ==QIO_CHANNEL_ERR_BLOCK ) { +return ret; + } +if (ret <=0 ) { +/* read error or other side closed connection */ +if (ret ==0 ) { +error_setg (&local_err,"vfio_user_recv server closed socket" ); + }else { +error_prepend (&local_err,"vfio_user_recv" ); + } + goto fatal; + } +if (ret <sizeof (msg)) { +error_setg (&local_err,"vfio_user_recv short read of header" ); + goto fatal; + } + +/* +* Validate header +*/ +if (hdr.size <sizeof (VFIOUserHdr)) { +error_setg (&local_err,"vfio_user_recv bad header size" ); + goto fatal; + } +switch (hdr.flags &VFIO_USER_TYPE ) { +case VFIO_USER_REQUEST : + isreply = false; +break ; +case VFIO_USER_REPLY : + isreply = true; +break ; +default : +error_setg (&local_err,"vfio_user_recv unknown message type" ); + goto fatal; + } + +/* +* For replies, find the matching pending request. +* For requests, reap incoming FDs. +*/ +if (isreply) { + QTAILQ_FOREACH(msg, &proxy->pending, next) { +if (hdr.id == msg->id) { +break ; + } + } +if (msg ==NULL ) { +error_setg (&local_err,"vfio_user_recv unexpected reply" ); + goto err; + } +QTAILQ_REMOVE (&proxy->pending, msg, next); + +/* +* Process any received FDs +*/ +if (numfds !=0 ) { +if (msg->fds ==NULL || msg->fds->recv_fds < numfds) { +error_setg (&local_err,"vfio_user_recv unexpected FDs" ); + goto err; + } + msg->fds->recv_fds = numfds; +memcpy (msg->fds->fds, fdp, numfds *sizeof (int )); + } + }else { +if (numfds !=0 ) { + reqfds =vfio_user_getfds (numfds); +memcpy (reqfds->fds, fdp, numfds *sizeof (int )); + }else { + reqfds =NULL ; + } + } + +/* +* Put the whole message into a single buffer. +*/ +if (isreply) { +if (hdr.size > msg->rsize) { +error_setg (&local_err, +"vfio_user_recv reply larger than recv buffer" ); + goto err; + } + *msg->hdr = hdr; + data = (char *)msg->hdr +sizeof (hdr); + }else { +if (hdr.size > max_xfer_size) { +error_setg (&local_err,"vfio_user_recv request larger than max" ); + goto err; + } + buf =g_malloc0 (hdr.size); +memcpy (buf, &hdr,sizeof (hdr)); + data = buf +sizeof (hdr); + msg =vfio_user_getmsg (proxy, (VFIOUserHdr *)buf, reqfds); + msg->type =VFIO_MSG_REQ ;
hw/vfio/user.c static void vfio_user_shutdown(VFIOProxy *proxy) · line 258
Quoted 10 lines
hw/vfio/user.c +10
-0+ } + + msgleft = hdr.size -sizeof (hdr); +while (msgleft >0 ) { + ret =qio_channel_read (proxy->ioc, data, msgleft, &local_err); + +/* error or would block */ +if (ret <0 ) { + goto fatal; + }
IIUC qio_channel_read() ends up calling qio_channel_socket_readv() which can return QIO_CHANNEL_ERR_BLOCK (-2). The if will be taken so local_err is NULL and that causes a segfault when error_report_err(local_err) is called before returning from this function.
Quoted 163 lines
hw/vfio/user.c +101
-0+ + msgleft -= ret; + data += ret; + } + +/* +* Replies signal a waiter, if none just check for errors +* and free the message buffer. +* +* Requests get queued for the BH. +*/ +if (isreply) { + msg->complete = true; +if (msg->type ==VFIO_MSG_WAIT ) { +qemu_cond_signal (&msg->cv); + }else { +if (hdr.flags &VFIO_USER_ERROR ) { +error_printf ("vfio_user_rcv error reply on async request " ); +error_printf ("command %x error %s\n" , hdr.command, +strerror (hdr.error_reply)); + } +/* youngest nowait msg has been ack'd */ +if (proxy->last_nowait == msg) { + proxy->last_nowait =NULL ; + } +vfio_user_recycle (proxy, msg); + } + }else { +QTAILQ_INSERT_TAIL (&proxy->incoming, msg, next); +qemu_bh_schedule (proxy->req_bh); + } +return 0 ; + +/* +* fatal means the other side closed or we don't trust the stream +* err means this message is corrupt +*/ +fatal: +vfio_user_shutdown (proxy); + proxy->state =VFIO_PROXY_ERROR ; + +err: +for (i =0 ; i < numfds; i++) { +close (fdp[i]); + } +if (isreply && msg !=NULL ) { +/* force an error to keep sending thread from hanging */ +vfio_user_set_error (msg->hdr,EINVAL ); + msg->complete = true; +qemu_cond_signal (&msg->cv); + } +error_report_err (local_err); +return -1 ; +} +static void vfio_user_cb (void *opaque) {VFIOProxy *proxy = opaque;@@ -59,6 +326,51 @@ static void vfio_user_cb(void *opaque)* Functions called by main or CPU threads */ +/* +* Process incoming requests. +* +* The bus-specific callback has the form: +* request(opaque, msg) +* where 'opaque' was specified in vfio_user_set_handler +* and 'msg' is the inbound message. +* +* The callback is responsible for disposing of the message buffer, +* usually by re-using it when calling vfio_send_reply or vfio_send_error, +* both of which free their message buffer when the reply is sent. +* +* If the callback uses a new buffer, it needs to free the old one. +*/ +static void vfio_user_request (void *opaque) +{ +VFIOProxy *proxy = opaque; +VFIOUserMsgQ new, free; +VFIOUserMsg *msg, *m1; + +/* reap all incoming */ +QTAILQ_INIT (&new); + WITH_QEMU_LOCK_GUARD(&proxy->lock) { + QTAILQ_FOREACH_SAFE(msg, &proxy->incoming, next, m1) { +QTAILQ_REMOVE (&proxy->pending, msg, next); +QTAILQ_INSERT_TAIL (&new, msg, next); + } + } + +/* process list */ +QTAILQ_INIT (&free); + QTAILQ_FOREACH_SAFE(msg, &new, next, m1) { +QTAILQ_REMOVE (&new, msg, next); + proxy->request (proxy->req_arg, msg); +QTAILQ_INSERT_HEAD (&free, msg, next); + } + +/* free list */ + WITH_QEMU_LOCK_GUARD(&proxy->lock) { + QTAILQ_FOREACH_SAFE(msg, &free, next, m1) { +vfio_user_recycle (proxy, msg); + } + } +} + static QLIST_HEAD(, VFIOProxy) vfio_user_sockets =QLIST_HEAD_INITIALIZER (vfio_user_sockets);@@ -97,6 +409,7 @@ VFIOProxy *vfio_user_connect_dev(SocketAddress *addr, Error **errp) } proxy->ctx =iothread_get_aio_context (vfio_user_iothread); + proxy->req_bh =qemu_bh_new (vfio_user_request, proxy);QTAILQ_INIT (&proxy->outgoing);QTAILQ_INIT(&proxy->incoming);hw/vfio/user.c +12
-0@@ -107,6 +420,18 @@ VFIOProxy *vfio_user_connect_dev(SocketAddress *addr, Error **errp)return proxy; } +void vfio_user_set_handler (VFIODevice *vbasedev, +void (*handler)(void *opaque,VFIOUserMsg *msg), +void *req_arg) +{ +VFIOProxy *proxy = vbasedev->proxy; + + proxy->request = handler; + proxy->req_arg = req_arg; +qio_channel_set_aio_fd_handler (proxy->ioc, proxy->ctx, + vfio_user_recv,NULL , proxy); +} +void vfio_user_disconnect (VFIOProxy *proxy) {VFIOUserMsg *r1, *r2;hw/vfio/user.c +2
-0@@ -122,6 +447,8 @@ void vfio_user_disconnect(VFIOProxy *proxy) }object_unref (OBJECT (proxy->ioc)); proxy->ioc =NULL ; +qemu_bh_delete (proxy->req_bh); + proxy->req_bh =NULL ; proxy->state =VFIO_PROXY_CLOSING ; QTAILQ_FOREACH_SAFE(r1, &proxy->outgoing, next, r2) {MAINTAINERS +1
-1@@ -1909,6 +1909,7 @@ S: Supported F: docs/devel/vfio-user.rst F: hw/vfio/user.c F: hw/vfio/user.h +F: hw/vfio/user-protocol.h vhost M: Michael S. Tsirkin <[email protected]> --1.8.3.1
RE: [RFC v4 08/21] vfio-user: define socket receive functions
Quoted 384 lines
-----Original Message-----
From: Qemu-devel <qemu-devel- [email protected]> On Behalf Of Thanos Makatos
Sent: 03 February 2022 21:54
To: John Johnson <[email protected]>; [email protected]
Subject: RE: [RFC v4 08/21] vfio-user: define socket receive functionsQuoted 143 lines
-----Original Message-----
From: Qemu-devel <qemu-devel- [email protected]> On Behalf Of John Johnson
Sent: 12 January 2022 00:44
To: [email protected]
Subject: [RFC v4 08/21] vfio-user: define socket receive functionsAdd infrastructure needed to receive incoming messages
Signed-off-by John G Johnson <[email protected]>Signed-off-by Elena Ufimtseva <[email protected]>Signed-off-by Jagannathan Raman <[email protected]>--- hw/vfio/user-protocol.h | 54 ++++++++ hw/vfio/user.h | 6 + hw/vfio/pci.c | 6 + hw/vfio/user.c | 327 ++++++++++++++++++++++++++++++++++++++++++++++++ MAINTAINERS | 1 + 5 files changed, 394 insertions(+) create mode 100644 hw/vfio/user-protocol.hhw/vfio/user-protocol.h new file +54
-0@@ -0,0 +1,54 @@ +#ifndef VFIO_USER_PROTOCOL_H +#define VFIO_USER_PROTOCOL_H + +/* +* vfio protocol over a UNIX socket. +* +* Copyright © 2018, 2021 Oracle and/or its affiliates. +* +* This work is licensed under the terms of the GNU GPL, version 2. See +* the COPYING file in the top-level directory. +* +* Each message has a standard header that describes the command +* being sent, which is almost always a VFIO ioctl(). +* +* The header may be followed by command-specific data, such as the +* region and offset info for read and write commands. +*/ + +typedef struct { +uint16_t id; +uint16_t command; +uint32_t size; +uint32_t flags; +uint32_t error_reply; +}VFIOUserHdr ; + +/* VFIOUserHdr commands */ +enum vfio_user_command { +VFIO_USER_VERSION =1 , +VFIO_USER_DMA_MAP =2 , +VFIO_USER_DMA_UNMAP =3 , +VFIO_USER_DEVICE_GET_INFO =4 , +VFIO_USER_DEVICE_GET_REGION_INFO =5 , +VFIO_USER_DEVICE_GET_REGION_IO_FDS =6 , +VFIO_USER_DEVICE_GET_IRQ_INFO =7 , +VFIO_USER_DEVICE_SET_IRQS =8 , +VFIO_USER_REGION_READ =9 , +VFIO_USER_REGION_WRITE =10 , +VFIO_USER_DMA_READ =11 , +VFIO_USER_DMA_WRITE =12 , +VFIO_USER_DEVICE_RESET =13 , +VFIO_USER_DIRTY_PAGES =14 , +VFIO_USER_MAX , +}; + +/* VFIOUserHdr flags */ +#define VFIO_USER_REQUEST 0x0 +#define VFIO_USER_REPLY 0x1 +#define VFIO_USER_TYPE 0xF + +#define VFIO_USER_NO_REPLY 0x10 +#define VFIO_USER_ERROR 0x20 + +#endif /* VFIO_USER_PROTOCOL_H */ hw/vfio/user.h +6
-0@@ -11,6 +11,8 @@* */ +#include "user-protocol.h" + typedef struct { int send_fds; int recv_fds;@@ -27,6 +29,7 @@ enum msg_type { typedef struct VFIOUserMsg { QTAILQ_ENTRY(VFIOUserMsg) next; + VFIOUserHdr *hdr; VFIOUserFDs *fds; uint32_t rsize; uint32_t id;@@ -74,5 +77,8 @@ typedef struct VFIOProxy {VFIOProxy *vfio_user_connect_dev (SocketAddress *addr,Error **errp);void vfio_user_disconnect (VFIOProxy *proxy); +void vfio_user_set_handler (VFIODevice *vbasedev, +void (*handler)(void *opaque,VFIOUserMsg *msg), +void *reqarg);#endif /* VFIO_USER_H */ hw/vfio/pci.c +6
-0@@ -3386,6 +3386,11 @@ type_init(register_vfio_pci_dev_type)* vfio-user routines. */ +static void vfio_user_pci_process_req (void *opaque,VFIOUserMsg *msg) +{ + +} +/* * Emulated devices don't use host hot reset */ @@ -3432,6 +3437,7 @@ static void vfio_user_pci_realize(PCIDevice *pdev, Error **errp) return; } vbasedev->proxy = proxy; +vfio_user_set_handler (vbasedev, vfio_user_pci_process_req, vdev); vbasedev->name =g_strdup_printf ("VFIO user <%s>" , udev->sock_name);vbasedev->dev = DEVICE(vdev);hw/vfio/user.c +0
-0hw/vfio/user.c line 32
Quoted 8 lines
hw/vfio/user.c +2
-0@@ -25,10 +25,26 @@#include "sysemu/iothread.h" #include "user.h" +static uint64_t max_xfer_size;static IOThread *vfio_user_iothread;static void vfio_user_shutdown (VFIOProxy *proxy); +static VFIOUserMsg *vfio_user_getmsg(VFIOProxy *proxy, VFIOUserHdr*hdr,
Quoted 19 lines
hw/vfio/user.c +14
-0+ VFIOUserFDs *fds); +static VFIOUserFDs *vfio_user_getfds (int numfds); +static void vfio_user_recycle (VFIOProxy *proxy,VFIOUserMsg *msg); +static void vfio_user_recv (void *opaque); +static int vfio_user_recv_one (VFIOProxy *proxy); +static void vfio_user_cb (void *opaque); + +static void vfio_user_request (void *opaque); + +static inline void vfio_user_set_error (VFIOUserHdr *hdr,uint32_t err) +{ + hdr->flags |=VFIO_USER_ERROR ; + hdr->error_reply = err; +}/* * Functions called by main, CPU, or iothread threads hw/vfio/user.c static void vfio_user_shutdown(VFIOProxy *proxy) · line 56
Quoted 1 line
hw/vfio/user.c +0
-0@@ -40,10 +56,261 @@ static void vfio_user_shutdown(VFIOProxy *proxy) qio_channel_set_aio_fd_handler(proxy->ioc, proxy->ctx, NULL, NULL,NULL);
hw/vfio/user.c static void vfio_user_shutdown(VFIOProxy *proxy) · line 59
Quoted 3 lines
hw/vfio/user.c +1
-0} +static VFIOUserMsg *vfio_user_getmsg(VFIOProxy *proxy, VFIOUserHdr*hdr,
Quoted 19 lines
hw/vfio/user.c +19
-0+ VFIOUserFDs *fds) +{ +VFIOUserMsg *msg; + + msg =QTAILQ_FIRST (&proxy->free); +if (msg !=NULL ) { +QTAILQ_REMOVE (&proxy->free, msg, next); + }else { + msg =g_malloc0 (sizeof (*msg)); +qemu_cond_init (&msg->cv); + } + + msg->hdr = hdr; + msg->fds = fds; +return msg; +} + +/* +* Recycle a message list entry to the free list. hw/vfio/user.c static void vfio_user_shutdown(VFIOProxy *proxy)
Quoted 10 lines
hw/vfio/user.c +10
-0+*/ +static void vfio_user_recycle (VFIOProxy *proxy,VFIOUserMsg *msg) +{ +if (msg->type ==VFIO_MSG_NONE ) { +error_printf ("vfio_user_recycle - freeing free msg\n" ); +return ; + } + +/* free msg buffer if no one is waiting to consume the reply */ +if (msg->type ==VFIO_MSG_NOWAIT || msg->type ==VFIO_MSG_ASYNC ){
Quoted 167 lines
hw/vfio/user.c +163
-0+g_free (msg->hdr); +if (msg->fds !=NULL ) { +g_free (msg->fds); + } + } + + msg->type =VFIO_MSG_NONE ; + msg->hdr =NULL ; + msg->fds =NULL ; + msg->complete = false; +QTAILQ_INSERT_HEAD (&proxy->free, msg, next); +} + +static VFIOUserFDs *vfio_user_getfds (int numfds) +{ +VFIOUserFDs *fds =g_malloc0 (sizeof (*fds) + (numfds *sizeof (int ))); + + fds->fds = (int *)((char *)fds +sizeof (*fds)); + +return fds; +} +/* * Functions only called by iothread */ +static void vfio_user_recv (void *opaque) +{ +VFIOProxy *proxy = opaque; + +QEMU_LOCK_GUARD (&proxy->lock); + +if (proxy->state ==VFIO_PROXY_CONNECTED ) { +while (vfio_user_recv_one (proxy) ==0 ) { + ; + } + } +} + +/* +* Receive and process one incoming message. +* +* For replies, find matching outgoing request and wake any waiters. +* For requests, queue in incoming list and run request BH. +*/ +static int vfio_user_recv_one (VFIOProxy *proxy) +{ +VFIOUserMsg *msg =NULL ; + g_autofree int *fdp = NULL; +VFIOUserFDs *reqfds; +VFIOUserHdr hdr; +struct iovec iov = { + .iov_base = &hdr, + .iov_len =sizeof (hdr), + }; +bool isreply = false; +int i, ret; +size_t msgleft, numfds =0 ; +char *data =NULL ; +char *buf =NULL ; +Error *local_err =NULL ; + +/* +* Read header +*/ + ret =qio_channel_readv_full (proxy->ioc, &iov,1 , &fdp, &numfds, + &local_err); +if (ret ==QIO_CHANNEL_ERR_BLOCK ) { +return ret; + } +if (ret <=0 ) { +/* read error or other side closed connection */ +if (ret ==0 ) { +error_setg (&local_err,"vfio_user_recv server closed socket" ); + }else { +error_prepend (&local_err,"vfio_user_recv" ); + } + goto fatal; + } +if (ret <sizeof (msg)) { +error_setg (&local_err,"vfio_user_recv short read of header" ); + goto fatal; + } + +/* +* Validate header +*/ +if (hdr.size <sizeof (VFIOUserHdr)) { +error_setg (&local_err,"vfio_user_recv bad header size" ); + goto fatal; + } +switch (hdr.flags &VFIO_USER_TYPE ) { +case VFIO_USER_REQUEST : + isreply = false; +break ; +case VFIO_USER_REPLY : + isreply = true; +break ; +default : +error_setg (&local_err,"vfio_user_recv unknown message type" ); + goto fatal; + } + +/* +* For replies, find the matching pending request. +* For requests, reap incoming FDs. +*/ +if (isreply) { + QTAILQ_FOREACH(msg, &proxy->pending, next) { +if (hdr.id == msg->id) { +break ; + } + } +if (msg ==NULL ) { +error_setg (&local_err,"vfio_user_recv unexpected reply" ); + goto err; + } +QTAILQ_REMOVE (&proxy->pending, msg, next); + +/* +* Process any received FDs +*/ +if (numfds !=0 ) { +if (msg->fds ==NULL || msg->fds->recv_fds < numfds) { +error_setg (&local_err,"vfio_user_recv unexpected FDs" ); + goto err; + } + msg->fds->recv_fds = numfds; +memcpy (msg->fds->fds, fdp, numfds *sizeof (int )); + } + }else { +if (numfds !=0 ) { + reqfds =vfio_user_getfds (numfds); +memcpy (reqfds->fds, fdp, numfds *sizeof (int )); + }else { + reqfds =NULL ; + } + } + +/* +* Put the whole message into a single buffer. +*/ +if (isreply) { +if (hdr.size > msg->rsize) { +error_setg (&local_err, +"vfio_user_recv reply larger than recv buffer" ); + goto err; + } + *msg->hdr = hdr; + data = (char *)msg->hdr +sizeof (hdr); + }else { +if (hdr.size > max_xfer_size) { +error_setg (&local_err,"vfio_user_recv request larger than max" ); + goto err; + } + buf =g_malloc0 (hdr.size); +memcpy (buf, &hdr,sizeof (hdr)); + data = buf +sizeof (hdr); + msg =vfio_user_getmsg (proxy, (VFIOUserHdr *)buf, reqfds); + msg->type =VFIO_MSG_REQ ; + } + + msgleft = hdr.size -sizeof (hdr); +while (msgleft >0 ) { + ret =qio_channel_read (proxy->ioc, data, msgleft, &local_err); + +/* error or would block */
Quoted 8 lines
hw/vfio/user.c static void vfio_user_shutdown(VFIOProxy *proxy) · line 258
Quoted 3 lines
hw/vfio/user.c +3
-0+if (ret <0 ) { + goto fatal; + }IIUC
qio_channel_read()ends up callingqio_channel_socket_readv()which can returnQIO_CHANNEL_ERR_BLOCK(-2). The if will be taken solocal_erris NULL and that causes a segfault whenerror_report_err(local_err)is called before returning from this function.
In fact, don't we need to continue if qio_channel_read() returns QIO_CHANNEL_ERR_BLOCK and only fail if it returns -1?
Quoted 164 lines
Quoted 164 lines
hw/vfio/user.c +101
-0+ + msgleft -= ret; + data += ret; + } + +/* +* Replies signal a waiter, if none just check for errors +* and free the message buffer. +* +* Requests get queued for the BH. +*/ +if (isreply) { + msg->complete = true; +if (msg->type ==VFIO_MSG_WAIT ) { +qemu_cond_signal (&msg->cv); + }else { +if (hdr.flags &VFIO_USER_ERROR ) { +error_printf ("vfio_user_rcv error reply on async request " ); +error_printf ("command %x error %s\n" , hdr.command, +strerror (hdr.error_reply)); + } +/* youngest nowait msg has been ack'd */ +if (proxy->last_nowait == msg) { + proxy->last_nowait =NULL ; + } +vfio_user_recycle (proxy, msg); + } + }else { +QTAILQ_INSERT_TAIL (&proxy->incoming, msg, next); +qemu_bh_schedule (proxy->req_bh); + } +return 0 ; + +/* +* fatal means the other side closed or we don't trust the stream +* err means this message is corrupt +*/ +fatal: +vfio_user_shutdown (proxy); + proxy->state =VFIO_PROXY_ERROR ; + +err: +for (i =0 ; i < numfds; i++) { +close (fdp[i]); + } +if (isreply && msg !=NULL ) { +/* force an error to keep sending thread from hanging */ +vfio_user_set_error (msg->hdr,EINVAL ); + msg->complete = true; +qemu_cond_signal (&msg->cv); + } +error_report_err (local_err); +return -1 ; +} +static void vfio_user_cb (void *opaque) {VFIOProxy *proxy = opaque;@@ -59,6 +326,51 @@ static void vfio_user_cb(void *opaque)* Functions called by main or CPU threads */ +/* +* Process incoming requests. +* +* The bus-specific callback has the form: +* request(opaque, msg) +* where 'opaque' was specified in vfio_user_set_handler +* and 'msg' is the inbound message. +* +* The callback is responsible for disposing of the message buffer, +* usually by re-using it when calling vfio_send_reply or vfio_send_error, +* both of which free their message buffer when the reply is sent. +* +* If the callback uses a new buffer, it needs to free the old one. +*/ +static void vfio_user_request (void *opaque) +{ +VFIOProxy *proxy = opaque; +VFIOUserMsgQ new, free; +VFIOUserMsg *msg, *m1; + +/* reap all incoming */ +QTAILQ_INIT (&new); + WITH_QEMU_LOCK_GUARD(&proxy->lock) { + QTAILQ_FOREACH_SAFE(msg, &proxy->incoming, next, m1) { +QTAILQ_REMOVE (&proxy->pending, msg, next); +QTAILQ_INSERT_TAIL (&new, msg, next); + } + } + +/* process list */ +QTAILQ_INIT (&free); + QTAILQ_FOREACH_SAFE(msg, &new, next, m1) { +QTAILQ_REMOVE (&new, msg, next); + proxy->request (proxy->req_arg, msg); +QTAILQ_INSERT_HEAD (&free, msg, next); + } + +/* free list */ + WITH_QEMU_LOCK_GUARD(&proxy->lock) { + QTAILQ_FOREACH_SAFE(msg, &free, next, m1) { +vfio_user_recycle (proxy, msg); + } + } +} + static QLIST_HEAD(, VFIOProxy) vfio_user_sockets =QLIST_HEAD_INITIALIZER (vfio_user_sockets);@@ -97,6 +409,7 @@ VFIOProxy *vfio_user_connect_dev(SocketAddress *addr, Error **errp) } proxy->ctx =iothread_get_aio_context (vfio_user_iothread); + proxy->req_bh =qemu_bh_new (vfio_user_request, proxy);QTAILQ_INIT (&proxy->outgoing);QTAILQ_INIT(&proxy->incoming);hw/vfio/user.c +12
-0@@ -107,6 +420,18 @@ VFIOProxy *vfio_user_connect_dev(SocketAddress *addr, Error **errp)return proxy; } +void vfio_user_set_handler (VFIODevice *vbasedev, +void (*handler)(void *opaque,VFIOUserMsg *msg), +void *req_arg) +{ +VFIOProxy *proxy = vbasedev->proxy; + + proxy->request = handler; + proxy->req_arg = req_arg; +qio_channel_set_aio_fd_handler (proxy->ioc, proxy->ctx, + vfio_user_recv,NULL , proxy); +} +void vfio_user_disconnect (VFIOProxy *proxy) {VFIOUserMsg *r1, *r2;hw/vfio/user.c +2
-0@@ -122,6 +447,8 @@ void vfio_user_disconnect(VFIOProxy *proxy) }object_unref (OBJECT (proxy->ioc)); proxy->ioc =NULL ; +qemu_bh_delete (proxy->req_bh); + proxy->req_bh =NULL ; proxy->state =VFIO_PROXY_CLOSING ; QTAILQ_FOREACH_SAFE(r1, &proxy->outgoing, next, r2) {MAINTAINERS +1
-1@@ -1909,6 +1909,7 @@ S: Supported F: docs/devel/vfio-user.rst F: hw/vfio/user.c F: hw/vfio/user.h +F: hw/vfio/user-protocol.h vhost M: Michael S. Tsirkin <[email protected]> --1.8.3.1
Re: [RFC v4 08/21] vfio-user: define socket receive functions
Quoted 38 lines · Thanos Makatos
Quoted 19 lines
-----Original Message-----
From: Qemu-devel <qemu-devel- [email protected]> On Behalf Of Thanos Makatos
Sent: 03 February 2022 21:54
To: John Johnson <[email protected]>; [email protected]
Subject: RE: [RFC v4 08/21] vfio-user: define socket receive functionsQuoted 8 lines
-----Original Message-----
From: Qemu-devel <qemu-devel- [email protected]> On Behalf Of John Johnson
Sent: 12 January 2022 00:44
To: [email protected]
Subject: [RFC v4 08/21] vfio-user: define socket receive functionsQuoted 15 lines
hw/vfio/user.c static void vfio_user_shutdown(VFIOProxy *proxy) · line 258
Quoted 10 lines
hw/vfio/user.c +10
-0+ } + + msgleft = hdr.size -sizeof (hdr); +while (msgleft >0 ) { + ret =qio_channel_read (proxy->ioc, data, msgleft, &local_err); + +/* error or would block */ +if (ret <0 ) { + goto fatal; + }IIUC
qio_channel_read()ends up callingqio_channel_socket_readv()which can returnQIO_CHANNEL_ERR_BLOCK(-2). The if will be taken solocal_erris NULL and that causes a segfault whenerror_report_err(local_err)is called before returning from this function.
Quoted 8 lines
In fact, don't we need to continue if
qio_channel_read()returnsQIO_CHANNEL_ERR_BLOCKand only fail if it returns -1?Quoted 6 lines
hw/vfio/user.c static void vfio_user_shutdown(VFIOProxy *proxy) · line 263
Quoted 6 lines
hw/vfio/user.c +5
-0+ + msgleft -= ret; + data += ret; + } +
I can’t loop indefinitely, as a malicious server could cause the receiver to loop
continuously if it sends a packet with a header length greater than the packet length.
If large messages are being fragmented by the socket code, then I think I’ll need
to change the packet parser to able to reassemble them.
JJ
RE: [RFC v4 08/21] vfio-user: define socket receive functions
In reply to John JohnsonQuoted 276 lines
-----Original Message-----
From: Qemu-devel <qemu-devel- [email protected]> On Behalf Of John Johnson
Sent: 12 January 2022 00:44
To: [email protected]
Subject: [RFC v4 08/21] vfio-user: define socket receive functionsAdd infrastructure needed to receive incoming messages
Signed-off-by John G Johnson <[email protected]>Signed-off-by Elena Ufimtseva <[email protected]>Signed-off-by Jagannathan Raman <[email protected]>--- hw/vfio/user-protocol.h | 54 ++++++++ hw/vfio/user.h | 6 + hw/vfio/pci.c | 6 + hw/vfio/user.c | 327 ++++++++++++++++++++++++++++++++++++++++++++++++ MAINTAINERS | 1 + 5 files changed, 394 insertions(+) create mode 100644 hw/vfio/user-protocol.hhw/vfio/user-protocol.h new file +54
-0@@ -0,0 +1,54 @@ +#ifndef VFIO_USER_PROTOCOL_H +#define VFIO_USER_PROTOCOL_H + +/* +* vfio protocol over a UNIX socket. +* +* Copyright © 2018, 2021 Oracle and/or its affiliates. +* +* This work is licensed under the terms of the GNU GPL, version 2. See +* the COPYING file in the top-level directory. +* +* Each message has a standard header that describes the command +* being sent, which is almost always a VFIO ioctl(). +* +* The header may be followed by command-specific data, such as the +* region and offset info for read and write commands. +*/ + +typedef struct { +uint16_t id; +uint16_t command; +uint32_t size; +uint32_t flags; +uint32_t error_reply; +}VFIOUserHdr ; + +/* VFIOUserHdr commands */ +enum vfio_user_command { +VFIO_USER_VERSION =1 , +VFIO_USER_DMA_MAP =2 , +VFIO_USER_DMA_UNMAP =3 , +VFIO_USER_DEVICE_GET_INFO =4 , +VFIO_USER_DEVICE_GET_REGION_INFO =5 , +VFIO_USER_DEVICE_GET_REGION_IO_FDS =6 , +VFIO_USER_DEVICE_GET_IRQ_INFO =7 , +VFIO_USER_DEVICE_SET_IRQS =8 , +VFIO_USER_REGION_READ =9 , +VFIO_USER_REGION_WRITE =10 , +VFIO_USER_DMA_READ =11 , +VFIO_USER_DMA_WRITE =12 , +VFIO_USER_DEVICE_RESET =13 , +VFIO_USER_DIRTY_PAGES =14 , +VFIO_USER_MAX , +}; + +/* VFIOUserHdr flags */ +#define VFIO_USER_REQUEST 0x0 +#define VFIO_USER_REPLY 0x1 +#define VFIO_USER_TYPE 0xF + +#define VFIO_USER_NO_REPLY 0x10 +#define VFIO_USER_ERROR 0x20 + +#endif /* VFIO_USER_PROTOCOL_H */ hw/vfio/user.h +6
-0@@ -11,6 +11,8 @@* */ +#include "user-protocol.h" + typedef struct { int send_fds; int recv_fds;@@ -27,6 +29,7 @@ enum msg_type { typedef struct VFIOUserMsg { QTAILQ_ENTRY(VFIOUserMsg) next; + VFIOUserHdr *hdr; VFIOUserFDs *fds; uint32_t rsize; uint32_t id;@@ -74,5 +77,8 @@ typedef struct VFIOProxy {VFIOProxy *vfio_user_connect_dev (SocketAddress *addr,Error **errp);void vfio_user_disconnect (VFIOProxy *proxy); +void vfio_user_set_handler (VFIODevice *vbasedev, +void (*handler)(void *opaque,VFIOUserMsg *msg), +void *reqarg);#endif /* VFIO_USER_H */ hw/vfio/pci.c +6
-0@@ -3386,6 +3386,11 @@ type_init(register_vfio_pci_dev_type)* vfio-user routines. */ +static void vfio_user_pci_process_req (void *opaque,VFIOUserMsg *msg) +{ + +} +/* * Emulated devices don't use host hot reset */ @@ -3432,6 +3437,7 @@ static void vfio_user_pci_realize(PCIDevice *pdev, Error **errp) return; } vbasedev->proxy = proxy; +vfio_user_set_handler (vbasedev, vfio_user_pci_process_req, vdev); vbasedev->name =g_strdup_printf ("VFIO user <%s>" , udev->sock_name);vbasedev->dev = DEVICE(vdev);hw/vfio/user.c +115
-0@@ -25,10 +25,26 @@#include "sysemu/iothread.h" #include "user.h" +static uint64_t max_xfer_size;static IOThread *vfio_user_iothread;static void vfio_user_shutdown (VFIOProxy *proxy); +static VFIOUserMsg *vfio_user_getmsg (VFIOProxy *proxy,VFIOUserHdr *hdr, +VFIOUserFDs *fds); +static VFIOUserFDs *vfio_user_getfds (int numfds); +static void vfio_user_recycle (VFIOProxy *proxy,VFIOUserMsg *msg); +static void vfio_user_recv (void *opaque); +static int vfio_user_recv_one (VFIOProxy *proxy); +static void vfio_user_cb (void *opaque); + +static void vfio_user_request (void *opaque); + +static inline void vfio_user_set_error (VFIOUserHdr *hdr,uint32_t err) +{ + hdr->flags |=VFIO_USER_ERROR ; + hdr->error_reply = err; +}/* * Functions called by main, CPU, or iothread threads @@ -40,10 +56,261 @@ static void vfio_user_shutdown(VFIOProxy *proxy)qio_channel_set_aio_fd_handler (proxy->ioc, proxy->ctx,NULL ,NULL ,NULL ); } +static VFIOUserMsg *vfio_user_getmsg (VFIOProxy *proxy,VFIOUserHdr *hdr, +VFIOUserFDs *fds) +{ +VFIOUserMsg *msg; + + msg =QTAILQ_FIRST (&proxy->free); +if (msg !=NULL ) { +QTAILQ_REMOVE (&proxy->free, msg, next); + }else { + msg =g_malloc0 (sizeof (*msg)); +qemu_cond_init (&msg->cv); + } + + msg->hdr = hdr; + msg->fds = fds; +return msg; +} + +/* +* Recycle a message list entry to the free list. +*/ +static void vfio_user_recycle (VFIOProxy *proxy,VFIOUserMsg *msg) +{ +if (msg->type ==VFIO_MSG_NONE ) { +error_printf ("vfio_user_recycle - freeing free msg\n" ); +return ; + } + +/* free msg buffer if no one is waiting to consume the reply */ +if (msg->type ==VFIO_MSG_NOWAIT || msg->type ==VFIO_MSG_ASYNC ) { +g_free (msg->hdr); +if (msg->fds !=NULL ) { +g_free (msg->fds); + } + } + + msg->type =VFIO_MSG_NONE ; + msg->hdr =NULL ; + msg->fds =NULL ; + msg->complete = false; +QTAILQ_INSERT_HEAD (&proxy->free, msg, next); +} + +static VFIOUserFDs *vfio_user_getfds (int numfds) +{ +VFIOUserFDs *fds =g_malloc0 (sizeof (*fds) + (numfds *sizeof (int ))); + + fds->fds = (int *)((char *)fds +sizeof (*fds)); + +return fds; +} +/* * Functions only called by iothread */ +static void vfio_user_recv (void *opaque) +{ +VFIOProxy *proxy = opaque; + +QEMU_LOCK_GUARD (&proxy->lock); + +if (proxy->state ==VFIO_PROXY_CONNECTED ) { +while (vfio_user_recv_one (proxy) ==0 ) { + ; + } + } +} + +/* +* Receive and process one incoming message. +* +* For replies, find matching outgoing request and wake any waiters. +* For requests, queue in incoming list and run request BH. +*/ +static int vfio_user_recv_one (VFIOProxy *proxy) +{ +VFIOUserMsg *msg =NULL ; + g_autofree int *fdp = NULL; +VFIOUserFDs *reqfds; +VFIOUserHdr hdr; +struct iovec iov = { + .iov_base = &hdr, + .iov_len =sizeof (hdr), + }; +bool isreply = false; +int i, ret; +size_t msgleft, numfds =0 ; +char *data =NULL ; +char *buf =NULL ; +Error *local_err =NULL ; + +/* +* Read header +*/ + ret =qio_channel_readv_full (proxy->ioc, &iov,1 , &fdp, &numfds, + &local_err); +if (ret ==QIO_CHANNEL_ERR_BLOCK ) { +return ret; + } +if (ret <=0 ) { +/* read error or other side closed connection */ +if (ret ==0 ) {
hw/vfio/user.c static void vfio_user_shutdown(VFIOProxy *proxy) · line 171
Quoted 10 lines
hw/vfio/user.c +10
-0+error_setg (&local_err,"vfio_user_recv server closed socket" ); + }else { +error_prepend (&local_err,"vfio_user_recv" ); + } + goto fatal; + } +if (ret <sizeof (msg)) { +error_setg (&local_err,"vfio_user_recv short read of header" ); + goto fatal; + }
Print received size for debug purposes?
hw/vfio/user.c static void vfio_user_shutdown(VFIOProxy *proxy) · line 179
Quoted 8 lines
hw/vfio/user.c +8
-0+ +/* +* Validate header +*/ +if (hdr.size <sizeof (VFIOUserHdr)) { +error_setg (&local_err,"vfio_user_recv bad header size" ); + goto fatal; + }
Print header size?
hw/vfio/user.c static void vfio_user_shutdown(VFIOProxy *proxy) · line 190
Quoted 11 lines
hw/vfio/user.c +11
-0+switch (hdr.flags &VFIO_USER_TYPE ) { +case VFIO_USER_REQUEST : + isreply = false; +break ; +case VFIO_USER_REPLY : + isreply = true; +break ; +default : +error_setg (&local_err,"vfio_user_recv unknown message type" ); + goto fatal; + }
Print message type?
Quoted 36 lines
hw/vfio/user.c +36
-0+ +/* +* For replies, find the matching pending request. +* For requests, reap incoming FDs. +*/ +if (isreply) { + QTAILQ_FOREACH(msg, &proxy->pending, next) { +if (hdr.id == msg->id) { +break ; + } + } +if (msg ==NULL ) { +error_setg (&local_err,"vfio_user_recv unexpected reply" ); + goto err; + } +QTAILQ_REMOVE (&proxy->pending, msg, next); + +/* +* Process any received FDs +*/ +if (numfds !=0 ) { +if (msg->fds ==NULL || msg->fds->recv_fds < numfds) { +error_setg (&local_err,"vfio_user_recv unexpected FDs" ); + goto err; + } + msg->fds->recv_fds = numfds; +memcpy (msg->fds->fds, fdp, numfds *sizeof (int )); + } + }else { +if (numfds !=0 ) { + reqfds =vfio_user_getfds (numfds); +memcpy (reqfds->fds, fdp, numfds *sizeof (int )); + }else { + reqfds =NULL ; + } + }
hw/vfio/user.c static void vfio_user_shutdown(VFIOProxy *proxy) · line 236
Quoted 10 lines
hw/vfio/user.c +10
-0+ +/* +* Put the whole message into a single buffer. +*/ +if (isreply) { +if (hdr.size > msg->rsize) { +error_setg (&local_err, +"vfio_user_recv reply larger than recv buffer" ); + goto err; + }
Print hdr.size and msg->rsize?
hw/vfio/user.c static void vfio_user_shutdown(VFIOProxy *proxy) · line 243
Quoted 7 lines
hw/vfio/user.c +7
-0+ *msg->hdr = hdr; + data = (char *)msg->hdr +sizeof (hdr); + }else { +if (hdr.size > max_xfer_size) { +error_setg (&local_err,"vfio_user_recv request larger than max" ); + goto err; + }
Print hdr.size?
Quoted 178 lines
hw/vfio/user.c +116
-0+ buf =g_malloc0 (hdr.size); +memcpy (buf, &hdr,sizeof (hdr)); + data = buf +sizeof (hdr); + msg =vfio_user_getmsg (proxy, (VFIOUserHdr *)buf, reqfds); + msg->type =VFIO_MSG_REQ ; + } + + msgleft = hdr.size -sizeof (hdr); +while (msgleft >0 ) { + ret =qio_channel_read (proxy->ioc, data, msgleft, &local_err); + +/* error or would block */ +if (ret <0 ) { + goto fatal; + } + + msgleft -= ret; + data += ret; + } + +/* +* Replies signal a waiter, if none just check for errors +* and free the message buffer. +* +* Requests get queued for the BH. +*/ +if (isreply) { + msg->complete = true; +if (msg->type ==VFIO_MSG_WAIT ) { +qemu_cond_signal (&msg->cv); + }else { +if (hdr.flags &VFIO_USER_ERROR ) { +error_printf ("vfio_user_rcv error reply on async request " ); +error_printf ("command %x error %s\n" , hdr.command, +strerror (hdr.error_reply)); + } +/* youngest nowait msg has been ack'd */ +if (proxy->last_nowait == msg) { + proxy->last_nowait =NULL ; + } +vfio_user_recycle (proxy, msg); + } + }else { +QTAILQ_INSERT_TAIL (&proxy->incoming, msg, next); +qemu_bh_schedule (proxy->req_bh); + } +return 0 ; + +/* +* fatal means the other side closed or we don't trust the stream +* err means this message is corrupt +*/ +fatal: +vfio_user_shutdown (proxy); + proxy->state =VFIO_PROXY_ERROR ; + +err: +for (i =0 ; i < numfds; i++) { +close (fdp[i]); + } +if (isreply && msg !=NULL ) { +/* force an error to keep sending thread from hanging */ +vfio_user_set_error (msg->hdr,EINVAL ); + msg->complete = true; +qemu_cond_signal (&msg->cv); + } +error_report_err (local_err); +return -1 ; +} +static void vfio_user_cb (void *opaque) {VFIOProxy *proxy = opaque;@@ -59,6 +326,51 @@ static void vfio_user_cb(void *opaque)* Functions called by main or CPU threads */ +/* +* Process incoming requests. +* +* The bus-specific callback has the form: +* request(opaque, msg) +* where 'opaque' was specified in vfio_user_set_handler +* and 'msg' is the inbound message. +* +* The callback is responsible for disposing of the message buffer, +* usually by re-using it when calling vfio_send_reply or vfio_send_error, +* both of which free their message buffer when the reply is sent. +* +* If the callback uses a new buffer, it needs to free the old one. +*/ +static void vfio_user_request (void *opaque) +{ +VFIOProxy *proxy = opaque; +VFIOUserMsgQ new, free; +VFIOUserMsg *msg, *m1; + +/* reap all incoming */ +QTAILQ_INIT (&new); + WITH_QEMU_LOCK_GUARD(&proxy->lock) { + QTAILQ_FOREACH_SAFE(msg, &proxy->incoming, next, m1) { +QTAILQ_REMOVE (&proxy->pending, msg, next); +QTAILQ_INSERT_TAIL (&new, msg, next); + } + } + +/* process list */ +QTAILQ_INIT (&free); + QTAILQ_FOREACH_SAFE(msg, &new, next, m1) { +QTAILQ_REMOVE (&new, msg, next); + proxy->request (proxy->req_arg, msg); +QTAILQ_INSERT_HEAD (&free, msg, next); + } + +/* free list */ + WITH_QEMU_LOCK_GUARD(&proxy->lock) { + QTAILQ_FOREACH_SAFE(msg, &free, next, m1) { +vfio_user_recycle (proxy, msg); + } + } +} + static QLIST_HEAD(, VFIOProxy) vfio_user_sockets =QLIST_HEAD_INITIALIZER (vfio_user_sockets);@@ -97,6 +409,7 @@ VFIOProxy *vfio_user_connect_dev(SocketAddress *addr, Error **errp) } proxy->ctx =iothread_get_aio_context (vfio_user_iothread); + proxy->req_bh =qemu_bh_new (vfio_user_request, proxy);QTAILQ_INIT (&proxy->outgoing);QTAILQ_INIT(&proxy->incoming);hw/vfio/user.c +12
-0@@ -107,6 +420,18 @@ VFIOProxy *vfio_user_connect_dev(SocketAddress *addr, Error **errp)return proxy; } +void vfio_user_set_handler (VFIODevice *vbasedev, +void (*handler)(void *opaque,VFIOUserMsg *msg), +void *req_arg) +{ +VFIOProxy *proxy = vbasedev->proxy; + + proxy->request = handler; + proxy->req_arg = req_arg; +qio_channel_set_aio_fd_handler (proxy->ioc, proxy->ctx, + vfio_user_recv,NULL , proxy); +} +void vfio_user_disconnect (VFIOProxy *proxy) {VFIOUserMsg *r1, *r2;hw/vfio/user.c +2
-0@@ -122,6 +447,8 @@ void vfio_user_disconnect(VFIOProxy *proxy) }object_unref (OBJECT (proxy->ioc)); proxy->ioc =NULL ; +qemu_bh_delete (proxy->req_bh); + proxy->req_bh =NULL ; proxy->state =VFIO_PROXY_CLOSING ; QTAILQ_FOREACH_SAFE(r1, &proxy->outgoing, next, r2) {MAINTAINERS +1
-1@@ -1909,6 +1909,7 @@ S: Supported F: docs/devel/vfio-user.rst F: hw/vfio/user.c F: hw/vfio/user.h +F: hw/vfio/user-protocol.h vhost M: Michael S. Tsirkin <[email protected]> --1.8.3.1
RE: [RFC v4 08/21] vfio-user: define socket receive functions
Quoted 129 lines
Quoted 34 lines
hw/vfio/user.c +34
-0+/* +* Receive and process one incoming message. +* +* For replies, find matching outgoing request and wake any waiters. +* For requests, queue in incoming list and run request BH. +*/ +static int vfio_user_recv_one (VFIOProxy *proxy) +{ +VFIOUserMsg *msg =NULL ; + g_autofree int *fdp = NULL; +VFIOUserFDs *reqfds; +VFIOUserHdr hdr; +struct iovec iov = { + .iov_base = &hdr, + .iov_len =sizeof (hdr), + }; +bool isreply = false; +int i, ret; +size_t msgleft, numfds =0 ; +char *data =NULL ; +char *buf =NULL ; +Error *local_err =NULL ; + +/* +* Read header +*/ + ret =qio_channel_readv_full (proxy->ioc, &iov,1 , &fdp, &numfds, + &local_err); +if (ret ==QIO_CHANNEL_ERR_BLOCK ) { +return ret; + } +if (ret <=0 ) { +/* read error or other side closed connection */ +if (ret ==0 ) {hw/vfio/user.c static void vfio_user_shutdown(VFIOProxy *proxy) · line 171
Quoted 10 lines
hw/vfio/user.c +10
-0+error_setg (&local_err,"vfio_user_recv server closed socket" ); + }else { +error_prepend (&local_err,"vfio_user_recv" ); + } + goto fatal; + } +if (ret <sizeof (msg)) { +error_setg (&local_err,"vfio_user_recv short read of header" ); + goto fatal; + }Print received size for debug purposes?
hw/vfio/user.c static void vfio_user_shutdown(VFIOProxy *proxy) · line 179
Quoted 8 lines
hw/vfio/user.c +8
-0+ +/* +* Validate header +*/ +if (hdr.size <sizeof (VFIOUserHdr)) { +error_setg (&local_err,"vfio_user_recv bad header size" ); + goto fatal; + }Print header size?
hw/vfio/user.c static void vfio_user_shutdown(VFIOProxy *proxy) · line 190
Quoted 11 lines
hw/vfio/user.c +11
-0+switch (hdr.flags &VFIO_USER_TYPE ) { +case VFIO_USER_REQUEST : + isreply = false; +break ; +case VFIO_USER_REPLY : + isreply = true; +break ; +default : +error_setg (&local_err,"vfio_user_recv unknown message type" ); + goto fatal; + }Print message type?
Quoted 36 lines
hw/vfio/user.c +36
-0+ +/* +* For replies, find the matching pending request. +* For requests, reap incoming FDs. +*/ +if (isreply) { + QTAILQ_FOREACH(msg, &proxy->pending, next) { +if (hdr.id == msg->id) { +break ; + } + } +if (msg ==NULL ) { +error_setg (&local_err,"vfio_user_recv unexpected reply" ); + goto err; + } +QTAILQ_REMOVE (&proxy->pending, msg, next); + +/* +* Process any received FDs +*/ +if (numfds !=0 ) { +if (msg->fds ==NULL || msg->fds->recv_fds < numfds) { +error_setg (&local_err,"vfio_user_recv unexpected FDs" ); + goto err; + } + msg->fds->recv_fds = numfds; +memcpy (msg->fds->fds, fdp, numfds *sizeof (int )); + } + }else { +if (numfds !=0 ) { + reqfds =vfio_user_getfds (numfds); +memcpy (reqfds->fds, fdp, numfds *sizeof (int )); + }else { + reqfds =NULL ; + } + }hw/vfio/user.c static void vfio_user_shutdown(VFIOProxy *proxy) · line 236
Quoted 10 lines
hw/vfio/user.c +10
-0+ +/* +* Put the whole message into a single buffer. +*/ +if (isreply) { +if (hdr.size > msg->rsize) { +error_setg (&local_err, +"vfio_user_recv reply larger than recv buffer" ); + goto err; + }Print hdr.size and
msg->rsize?hw/vfio/user.c static void vfio_user_shutdown(VFIOProxy *proxy) · line 243
Quoted 7 lines
hw/vfio/user.c +7
-0+ *msg->hdr = hdr; + data = (char *)msg->hdr +sizeof (hdr); + }else { +if (hdr.size > max_xfer_size) { +error_setg (&local_err,"vfio_user_recv request larger than max" ); + goto err; + }
Quoted 1 line
Print hdr.size?
On second thought, should we dump the entire header in case of such errors? If not by default then at least in debug builds?
Re: [RFC v4 08/21] vfio-user: define socket receive functions
Quoted 7 lines · Thanos Makatos
Quoted 2 lines
Quoted 2 lines
On second thought, should we dump the entire header in case of such errors? If not by default then at least in debug builds?
I was thinking of adding qemu tracepoints in the recv and send paths
for your other debug rfe. Maybe I’ll add one set for the normal path that prints an abbreviated header, and another set for the error case that prints the whole header. Would that work?
JJ
RE: [RFC v4 08/21] vfio-user: define socket receive functions
Quoted 16 lines
-----Original Message-----
From: John Johnson <[email protected]>
Sent: 16 February 2022 02:10
To: Thanos Makatos <[email protected]>
Cc: [email protected]
Subject: Re: [RFC v4 08/21] vfio-user: define socket receive functionsQuoted 1 line
On Feb 15, 2022, at 6:50 AM, Thanos Makatos
Quoted 3 lines · <[email protected]> wrote:
Quoted 2 lines
Quoted 2 lines
Quoted 8 lines
Quoted 1 line
On second thought, should we dump the entire header in case of such errors?
If not by default then at least in debug builds?
I was thinking of adding qemu tracepoints in the recv and send paths
for your other debug rfe. Maybe I’ll add one set for the normal path that prints an abbreviated header, and another set for the error case that prints the whole header. Would that work?
Yes that would be great.
RFC v4 9/21 vfio-user: define socket send functions
In reply to John JohnsonAlso negotiate protocol version with remote server
--- hw/vfio/pci.h | 1 + hw/vfio/user-protocol.h | 41 +++++ hw/vfio/user.h | 2 + hw/vfio/pci.c | 16 ++ hw/vfio/user.c | 414 +++++++++++++++++++++++++++++++++++++++++++++++- 5 files changed, 473 insertions(+), 1 deletion(-)
hw/vfio/pci.h +1 -0
@@ -193,6 +193,7 @@ OBJECT_DECLARE_SIMPLE_TYPE(VFIOUserPCIDevice, VFIO_USER_PCI)struct VFIOUserPCIDevice {VFIOPCIDevice device;char *sock_name; +bool send_queued;/* all sends are queued */ };/* Use uin32_t for vendor & device so PCI_ANY_ID expands and cannot match hw */
hw/vfio/user-protocol.h +41 -0
45 lines not on this page · raw message
hw/vfio/user.h +2 -0
@@ -74,11 +74,13 @@ typedef struct VFIOProxy {/* VFIOProxy flags */ #define VFIO_PROXY_CLIENT 0x1 +#define VFIO_PROXY_FORCE_QUEUED 0x4VFIOProxy *vfio_user_connect_dev (SocketAddress *addr,Error **errp);void vfio_user_disconnect (VFIOProxy *proxy);void vfio_user_set_handler (VFIODevice *vbasedev,void (*handler)(void *opaque,VFIOUserMsg *msg),void *reqarg); +int vfio_user_validate_version (VFIODevice *vbasedev,Error **errp);#endif /* VFIO_USER_H */
hw/vfio/pci.c +16 -0
@@ -3439,12 +3439,27 @@ static void vfio_user_pci_realize(PCIDevice *pdev, Error **errp) vbasedev->proxy = proxy;vfio_user_set_handler (vbasedev, vfio_user_pci_process_req, vdev); +if (udev->send_queued) { + proxy->flags |=VFIO_PROXY_FORCE_QUEUED ; + } + +vfio_user_validate_version (vbasedev, &err); +if (err !=NULL ) { +error_propagate (errp, err); + goto error; + } + vbasedev->name =g_strdup_printf ("VFIO user <%s>" , udev->sock_name); vbasedev->dev =DEVICE (vdev); vbasedev->fd =-1 ; vbasedev->type =VFIO_DEVICE_TYPE_PCI ; vbasedev->ops = &vfio_user_pci_ops; +return ; + +error: +vfio_user_disconnect (proxy); +error_prepend (errp,VFIO_MSG_PREFIX , vdev->vbasedev.name); }static void vfio_user_instance_finalize (Object *obj)
@@ -3461,6 +3476,7 @@ static void vfio_user_instance_finalize(Object *obj)static Property vfio_user_pci_dev_properties[] = {DEFINE_PROP_STRING ("socket" , VFIOUserPCIDevice, sock_name), +DEFINE_PROP_BOOL ("x-send-queued" , VFIOUserPCIDevice, send_queued, false),DEFINE_PROP_END_OF_LIST (), };
hw/vfio/user.c +413 -1
455 lines not on this page · raw message
Signature · 1 line
1.8.3.1
RE: [RFC v4 09/21] vfio-user: define socket send functions
Quoted 155 lines
-----Original Message-----
From: Qemu-devel <qemu-devel- [email protected]> On Behalf Of John Johnson
Sent: 12 January 2022 00:44
To: [email protected]
Subject: [RFC v4 09/21] vfio-user: define socket send functionsAlso negotiate protocol version with remote server
Signed-off-by Jagannathan Raman <[email protected]>Signed-off-by Elena Ufimtseva <[email protected]>Signed-off-by John G Johnson <[email protected]>--- hw/vfio/pci.h | 1 + hw/vfio/user-protocol.h | 41 +++++ hw/vfio/user.h | 2 + hw/vfio/pci.c | 16 ++ hw/vfio/user.c | 414 +++++++++++++++++++++++++++++++++++++++++++++++- 5 files changed, 473 insertions(+), 1 deletion(-)hw/vfio/pci.h +1
-0@@ -193,6 +193,7 @@ OBJECT_DECLARE_SIMPLE_TYPE(VFIOUserPCIDevice, VFIO_USER_PCI)struct VFIOUserPCIDevice {VFIOPCIDevice device;char *sock_name; +bool send_queued;/* all sends are queued */ };/* Use
uin32_tfor vendor & device soPCI_ANY_IDexpands and cannot match
hw */hw/vfio/user-protocol.h +41
-0@@ -51,4 +51,45 @@ enum vfio_user_command {#define VFIO_USER_NO_REPLY 0x10#define VFIO_USER_ERROR 0x20 + +/* +* VFIO_USER_VERSION +*/ +typedef struct { +VFIOUserHdr hdr; +uint16_t major; +uint16_t minor; +char capabilities[]; +}VFIOUserVersion ; + +#define VFIO_USER_MAJOR_VER 0 +#define VFIO_USER_MINOR_VER 0 + +#define VFIO_USER_CAP "capabilities" + +/* "capabilities" members */ +#define VFIO_USER_CAP_MAX_FDS "max_msg_fds" +#define VFIO_USER_CAP_MAX_XFER "max_data_xfer_size" +#define VFIO_USER_CAP_MIGR "migration" + +/* "migration" member */ +#define VFIO_USER_CAP_PGSIZE "pgsize" + +/* +* Max FDs mainly comes into play when a device supports multiple interrupts +* where each ones uses an eventfd to inject it into the guest. +* It is clamped by the the number of FDs the qio channel supports in a +* single message. +*/ +#define VFIO_USER_DEF_MAX_FDS 8 +#define VFIO_USER_MAX_MAX_FDS 16 + +/* +* Max transfer limits the amount of data in region and DMA messages. +* Region R/W will be very small (limited by how much a single instruction +* can process) so just use a reasonable limit here. +*/ +#define VFIO_USER_DEF_MAX_XFER (1024 * 1024) +#define VFIO_USER_MAX_MAX_XFER (64 * 1024 * 1024) +#endif /* VFIO_USER_PROTOCOL_H */ hw/vfio/user.h +2
-0@@ -74,11 +74,13 @@ typedef struct VFIOProxy {/* VFIOProxy flags */ #define VFIO_PROXY_CLIENT 0x1 +#define VFIO_PROXY_FORCE_QUEUED 0x4VFIOProxy *vfio_user_connect_dev (SocketAddress *addr,Error **errp);void vfio_user_disconnect (VFIOProxy *proxy);void vfio_user_set_handler (VFIODevice *vbasedev,void (*handler)(void *opaque,VFIOUserMsg *msg),void *reqarg); +int vfio_user_validate_version (VFIODevice *vbasedev,Error **errp);#endif /* VFIO_USER_H */ hw/vfio/pci.c +15
-0@@ -3439,12 +3439,27 @@ static void vfio_user_pci_realize(PCIDevice *pdev, Error **errp) vbasedev->proxy = proxy;vfio_user_set_handler (vbasedev, vfio_user_pci_process_req, vdev); +if (udev->send_queued) { + proxy->flags |=VFIO_PROXY_FORCE_QUEUED ; + } + +vfio_user_validate_version (vbasedev, &err); +if (err !=NULL ) { +error_propagate (errp, err); + goto error; + } + vbasedev->name =g_strdup_printf ("VFIO user <%s>" , udev->sock_name); vbasedev->dev =DEVICE (vdev); vbasedev->fd =-1 ; vbasedev->type =VFIO_DEVICE_TYPE_PCI ; vbasedev->ops = &vfio_user_pci_ops; +return ; + +error: +vfio_user_disconnect (proxy); +error_prepend (errp,VFIO_MSG_PREFIX , vdev->vbasedev.name); }static void
vfio_user_instance_finalize(Object *obj)hw/vfio/pci.c +1
-0@@ -3461,6 +3476,7 @@ static void vfio_user_instance_finalize(Object *obj)static Property vfio_user_pci_dev_properties[] = {DEFINE_PROP_STRING ("socket" , VFIOUserPCIDevice, sock_name), +DEFINE_PROP_BOOL ("x-send-queued" , VFIOUserPCIDevice, send_queued, false),DEFINE_PROP_END_OF_LIST (), };hw/vfio/user.c +1
-0@@ -23,12 +23,20 @@#include "io/channel-socket.h" #include "io/channel-util.h" #include "sysemu/iothread.h" +#include "qapi/qmp/qdict.h"
hw/vfio/user.c line 35
Quoted 10 lines
hw/vfio/user.c +7
-1+#include "qapi/qmp/qjson.h" +#include "qapi/qmp/qnull.h" +#include "qapi/qmp/qstring.h" +#include "qapi/qmp/qnum.h" #include "user.h" -static uint64_t max_xfer_size; +static uint64_t max_xfer_size =VFIO_USER_DEF_MAX_XFER ; +static uint64_t max_send_fds =VFIO_USER_DEF_MAX_FDS ; +static int wait_time =1000 ;/* wait 1 sec for replies */
Could we make this configurable via the command line as it helps debugging?
Quoted 452 lines
hw/vfio/user.c +8
-0static IOThread *vfio_user_iothread;static void vfio_user_shutdown (VFIOProxy *proxy); +static int vfio_user_send_qio (VFIOProxy *proxy,VFIOUserMsg *msg);static VFIOUserMsg *vfio_user_getmsg (VFIOProxy *proxy,VFIOUserHdr *hdr,VFIOUserFDs *fds);static VFIOUserFDs *vfio_user_getfds (int numfds);@@ -36,9 +44,16 @@ static void vfio_user_recycle(VFIOProxy *proxy, VFIOUserMsg *msg);static void vfio_user_recv (void *opaque);static int vfio_user_recv_one (VFIOProxy *proxy); +static void vfio_user_send (void *opaque); +static int vfio_user_send_one (VFIOProxy *proxy,VFIOUserMsg *msg);static void vfio_user_cb (void *opaque);static void vfio_user_request (void *opaque); +static int vfio_user_send_queued (VFIOProxy *proxy,VFIOUserMsg *msg); +static void vfio_user_send_wait (VFIOProxy *proxy,VFIOUserHdr *hdr, +VFIOUserFDs *fds,int rsize,bool nobql); +static void vfio_user_request_msg (VFIOUserHdr *hdr,uint16_t cmd, +uint32_t size,uint32_t flags);static inline void vfio_user_set_error (VFIOUserHdr *hdr,uint32_t err){
hw/vfio/user.c +346
-0@@ -56,6 +71,32 @@ static void vfio_user_shutdown(VFIOProxy *proxy)qio_channel_set_aio_fd_handler (proxy->ioc, proxy->ctx,NULL ,NULL ,NULL ); } +static int vfio_user_send_qio (VFIOProxy *proxy,VFIOUserMsg *msg) +{ +VFIOUserFDs *fds = msg->fds; +struct iovec iov = { + .iov_base = msg->hdr, + .iov_len = msg->hdr->size, + }; +size_t numfds =0 ; +int ret, *fdp =NULL ; +Error *local_err =NULL ; + +if (fds !=NULL && fds->send_fds !=0 ) { + numfds = fds->send_fds; + fdp = fds->fds; + } + + ret =qio_channel_writev_full (proxy->ioc, &iov,1 , fdp, numfds, &local_err); + +if (ret ==-1 ) { +vfio_user_set_error (msg->hdr,EIO ); +vfio_user_shutdown (proxy); +error_report_err (local_err); + } +return ret; +} +static VFIOUserMsg *vfio_user_getmsg (VFIOProxy *proxy,VFIOUserHdr *hdr,VFIOUserFDs *fds) {@@ -311,6 +352,53 @@ err:return -1 ; } +/* +* Send messages from outgoing queue when the socket buffer has space. +* If we deplete 'outgoing', remove ourselves from the poll list. +*/ +static void vfio_user_send (void *opaque) +{ +VFIOProxy *proxy = opaque; +VFIOUserMsg *msg; + +QEMU_LOCK_GUARD (&proxy->lock); + +if (proxy->state ==VFIO_PROXY_CONNECTED ) { +while (!QTAILQ_EMPTY (&proxy->outgoing)) { + msg =QTAILQ_FIRST (&proxy->outgoing); +if (vfio_user_send_one (proxy, msg) <0 ) { +return ; + } + } +qio_channel_set_aio_fd_handler (proxy->ioc, proxy->ctx, + vfio_user_recv,NULL , proxy); + } +} + +/* +* Send a single message. +* +* Sent async messages are freed, others are moved to pending queue. +*/ +static int vfio_user_send_one (VFIOProxy *proxy,VFIOUserMsg *msg) +{ +int ret; + + ret =vfio_user_send_qio (proxy, msg); +if (ret <0 ) { +return ret; + } + +QTAILQ_REMOVE (&proxy->outgoing, msg, next); +if (msg->type ==VFIO_MSG_ASYNC ) { +vfio_user_recycle (proxy, msg); + }else { +QTAILQ_INSERT_TAIL (&proxy->pending, msg, next); + } + +return 0 ; +} +static void vfio_user_cb (void *opaque) {VFIOProxy *proxy = opaque;@@ -371,6 +459,130 @@ static void vfio_user_request(void *opaque) } } +/* +* Messages are queued onto the proxy's outgoing list. +* +* It handles 3 types of messages: +* +* async messages - replies and posted writes +* +* There will be no reply from the server, so message +* buffers are freed after they're sent. +* +* nowait messages - map/unmap during address space transactions +* +* These are also sent async, but a reply is expected so that +* vfio_wait_reqs() can wait for the youngest nowait request. +* They transition from the outgoing list to the pending list +* when sent, and are freed when the reply is received. +* +* wait messages - all other requests +* +* The reply to these messages is waited for by their caller. +* They also transition from outgoing to pending when sent, but +* the message buffer is returned to the caller with the reply +* contents. The caller is responsible for freeing these messages. +* +* As an optimization, if the outgoing list and the socket send +* buffer are empty, the message is sent inline instead of being +* added to the outgoing list. The rest of the transitions are +* unchanged. +* +* returns 0 if the message was sent or queued +* returns -1 on send error +*/ +static int vfio_user_send_queued (VFIOProxy *proxy,VFIOUserMsg *msg) +{ +int ret; + +/* +* Unsent outgoing msgs - add to tail +*/ +if (!QTAILQ_EMPTY (&proxy->outgoing)) { +QTAILQ_INSERT_TAIL (&proxy->outgoing, msg, next); +return 0 ; + } + +/* +* Try inline - if blocked, queue it and kick send poller +*/ +if (proxy->flags &VFIO_PROXY_FORCE_QUEUED ) { + ret =QIO_CHANNEL_ERR_BLOCK ; + }else { + ret =vfio_user_send_qio (proxy, msg); + } +if (ret ==QIO_CHANNEL_ERR_BLOCK ) { +QTAILQ_INSERT_HEAD (&proxy->outgoing, msg, next); +qio_channel_set_aio_fd_handler (proxy->ioc, proxy->ctx, + vfio_user_recv, vfio_user_send, + proxy); +return 0 ; + } +if (ret ==-1 ) { +return ret; + } + +/* +* Sent - free async, add others to pending +*/ +if (msg->type ==VFIO_MSG_ASYNC ) { +vfio_user_recycle (proxy, msg); + }else { +QTAILQ_INSERT_TAIL (&proxy->pending, msg, next); + } + +return 0 ; +} + +static void vfio_user_send_wait (VFIOProxy *proxy,VFIOUserHdr *hdr, +VFIOUserFDs *fds,int rsize,bool nobql) +{ +VFIOUserMsg *msg; +bool iolock = false; +int ret; + +if (hdr->flags &VFIO_USER_NO_REPLY ) { +error_printf ("vfio_user_send_wait on async message\n" ); +return ; + } + +/* +* We may block later, so use a per-proxy lock and drop +* BQL while we sleep unless 'nobql' says not to. +*/ +qemu_mutex_lock (&proxy->lock); +if (!nobql) { + iolock =qemu_mutex_iothread_locked (); +if (iolock) { +qemu_mutex_unlock_iothread (); + } + } + + msg =vfio_user_getmsg (proxy, hdr, fds); + msg->id = hdr->id; + msg->rsize = rsize ? rsize : hdr->size; + msg->type =VFIO_MSG_WAIT ; + + ret =vfio_user_send_queued (proxy, msg); + +if (ret ==0 ) { +while (!msg->complete) { +if (!qemu_cond_timedwait (&msg->cv, &proxy->lock, wait_time)) { +QTAILQ_REMOVE (&proxy->pending, msg, next); +vfio_user_set_error (hdr,ETIMEDOUT ); +break ; + } + } + } +vfio_user_recycle (proxy, msg); + +/* lock order is BQL->proxy - don't hold proxy when getting BQL */ +qemu_mutex_unlock (&proxy->lock); +if (iolock) { +qemu_mutex_lock_iothread (); + } +} + static QLIST_HEAD(, VFIOProxy) vfio_user_sockets =QLIST_HEAD_INITIALIZER (vfio_user_sockets);@@ -495,3 +707,203 @@ void vfio_user_disconnect(VFIOProxy *proxy)g_free (proxy->sockname);g_free (proxy); } + +static void vfio_user_request_msg (VFIOUserHdr *hdr,uint16_t cmd, +uint32_t size,uint32_t flags) +{ +static uint16_t next_id; + + hdr->id =qatomic_fetch_inc (&next_id); + hdr->command = cmd; + hdr->size = size; + hdr->flags = (flags & ~VFIO_USER_TYPE ) |VFIO_USER_REQUEST ; + hdr->error_reply =0 ; +} + +struct cap_entry { +const char *name; +int (*check)(QObject *qobj,Error **errp); +}; + +static int caps_parse (QDict *qdict,struct cap_entry caps[],Error **errp) +{ +QObject *qobj; +struct cap_entry *p; + +for (p = caps; p->name !=NULL ; p++) { + qobj =qdict_get (qdict, p->name); +if (qobj !=NULL ) { +if (p->check (qobj, errp)) { +return -1 ; + } +qdict_del (qdict, p->name); + } + } + +/* warning, for now */ +if (qdict_size (qdict) !=0 ) { +error_printf ("spurious capabilities\n" ); + } +return 0 ; +} + +static int check_pgsize (QObject *qobj,Error **errp) +{ +QNum *qn =qobject_to (QNum, qobj); +uint64_t pgsize; + +if (qn ==NULL || !qnum_get_try_uint (qn, &pgsize)) { +error_setg (errp,"malformed %s" ,VFIO_USER_CAP_PGSIZE ); +return -1 ; + } +return pgsize ==4096 ?0 :-1 ; +} + +static struct cap_entry caps_migr[] = { + {VFIO_USER_CAP_PGSIZE , check_pgsize }, + {NULL } +}; + +static int check_max_fds (QObject *qobj,Error **errp) +{ +QNum *qn =qobject_to (QNum, qobj); + +if (qn ==NULL || !qnum_get_try_uint (qn, &max_send_fds) || + max_send_fds >VFIO_USER_MAX_MAX_FDS ) { +error_setg (errp,"malformed %s" ,VFIO_USER_CAP_MAX_FDS ); +return -1 ; + } +return 0 ; +} + +static int check_max_xfer (QObject *qobj,Error **errp) +{ +QNum *qn =qobject_to (QNum, qobj); + +if (qn ==NULL || !qnum_get_try_uint (qn, &max_xfer_size) || + max_xfer_size >VFIO_USER_MAX_MAX_XFER ) { +error_setg (errp,"malformed %s" ,VFIO_USER_CAP_MAX_XFER ); +return -1 ; + } +return 0 ; +} + +static int check_migr (QObject *qobj,Error **errp) +{ +QDict *qdict =qobject_to (QDict, qobj); + +if (qdict ==NULL ) { +error_setg (errp,"malformed %s" ,VFIO_USER_CAP_MAX_FDS ); +return -1 ; + } +return caps_parse (qdict, caps_migr, errp); +} + +static struct cap_entry caps_cap[] = { + {VFIO_USER_CAP_MAX_FDS , check_max_fds }, + {VFIO_USER_CAP_MAX_XFER , check_max_xfer }, + {VFIO_USER_CAP_MIGR , check_migr }, + {NULL } +}; + +static int check_cap (QObject *qobj,Error **errp) +{ +QDict *qdict =qobject_to (QDict, qobj); + +if (qdict ==NULL ) { +error_setg (errp,"malformed %s" ,VFIO_USER_CAP ); +return -1 ; + } +return caps_parse (qdict, caps_cap, errp); +} + +static struct cap_entry ver_0_0[] = { + {VFIO_USER_CAP , check_cap }, + {NULL } +}; + +static int caps_check (int minor,const char *caps,Error **errp) +{ +QObject *qobj; +QDict *qdict; +int ret; + + qobj =qobject_from_json (caps,NULL ); +if (qobj ==NULL ) { +error_setg (errp,"malformed capabilities %s" , caps); +return -1 ; + } + qdict =qobject_to (QDict, qobj); +if (qdict ==NULL ) { +error_setg (errp,"capabilities %s not an object" , caps); +qobject_unref (qobj); +return -1 ; + } + ret =caps_parse (qdict, ver_0_0, errp); + +qobject_unref (qobj); +return ret; +} + +static GString *caps_json (void ) +{ +QDict *dict =qdict_new (); +QDict *capdict =qdict_new (); +QDict *migdict =qdict_new (); +GString *str; + +qdict_put_int (migdict,VFIO_USER_CAP_PGSIZE ,4096 ); +qdict_put_obj (capdict,VFIO_USER_CAP_MIGR ,QOBJECT (migdict)); + + qdict_put_int(capdict, VFIO_USER_CAP_MAX_FDS,
VFIO_USER_MAX_MAX_FDS);
+ qdict_put_int(capdict,VFIO_USER_CAP_MAX_XFER,VFIO_USER_DEF_MAX_XFER);hw/vfio/user.c +50
-1+ +qdict_put_obj (dict,VFIO_USER_CAP ,QOBJECT (capdict)); + + str =qobject_to_json (QOBJECT (dict)); +qobject_unref (dict); +return str; +} + +int vfio_user_validate_version (VFIODevice *vbasedev,Error **errp) +{ + g_autofree VFIOUserVersion *msgp; +GString *caps; +char *reply; +int size, caplen; + + caps =caps_json (); + caplen = caps->len +1 ; + size =sizeof (*msgp) + caplen; + msgp =g_malloc0 (size); + +vfio_user_request_msg (&msgp->hdr,VFIO_USER_VERSION , size,0 ); + msgp->major =VFIO_USER_MAJOR_VER ; + msgp->minor =VFIO_USER_MINOR_VER ; +memcpy (&msgp->capabilities, caps->str, caplen); +g_string_free (caps, true); + +vfio_user_send_wait (vbasedev->proxy, &msgp->hdr,NULL ,0 , false); +if (msgp->hdr.flags &VFIO_USER_ERROR ) { +error_setg_errno (errp, msgp->hdr.error_reply,"version reply" ); +return -1 ; + } + +if (msgp->major !=VFIO_USER_MAJOR_VER || + msgp->minor >VFIO_USER_MINOR_VER ) { +error_setg (errp,"incompatible server version" ); +return -1 ; + } + + reply = msgp->capabilities; +if (reply[msgp->hdr.size -sizeof (*msgp) -1 ] !='\0' ) { +error_setg (errp,"corrupt version reply" ); +return -1 ; + } + +if (caps_check (msgp->minor, reply, errp) !=0 ) { +return -1 ; + } + +return 0 ; +} --1.8.3.1
Re: [RFC v4 09/21] vfio-user: define socket send functions
Quoted 9 lines · Thanos Makatos
Quoted 3 lines
+static int
wait_time= 1000; /* wait 1 sec for replies */Could we make this configurable via the command line as it helps debugging?
Yes, I can add a CLI option.
JJ
RFC v4 10/21 vfio-user: get device info
In reply to John Johnson--- hw/vfio/user-protocol.h | 14 ++++++++++++++ hw/vfio/user.h | 2 ++ hw/vfio/pci.c | 26 ++++++++++++++++++++++++++ hw/vfio/user.c | 44 ++++++++++++++++++++++++++++++++++++++++++++ 4 files changed, 86 insertions(+)
hw/vfio/user-protocol.h +14 -0
@@ -92,4 +92,18 @@ typedef struct {#define VFIO_USER_DEF_MAX_XFER (1024 * 1024)#define VFIO_USER_MAX_MAX_XFER (64 * 1024 * 1024) + +/* +* VFIO_USER_DEVICE_GET_INFO +* imported from struct_device_info +*/ +typedef struct { +VFIOUserHdr hdr; +uint32_t argsz; +uint32_t flags; +uint32_t num_regions; +uint32_t num_irqs; +uint32_t cap_offset; +}VFIOUserDeviceInfo ; +#endif /* VFIO_USER_PROTOCOL_H */
hw/vfio/user.h +2 -0
@@ -83,4 +83,6 @@ void vfio_user_set_handler(VFIODevice *vbasedev, void *reqarg);int vfio_user_validate_version (VFIODevice *vbasedev,Error **errp); +extern VFIODevIO vfio_dev_io_sock; +#endif /* VFIO_USER_H */
hw/vfio/pci.c +26 -0
@@ -3415,6 +3415,8 @@ static void vfio_user_pci_realize(PCIDevice *pdev, Error **errp)VFIODevice *vbasedev = &vdev->vbasedev;SocketAddress addr;VFIOProxy *proxy; +struct vfio_device_info info; +int ret;Error *err =NULL ;/*
@@ -3454,6 +3456,30 @@ static void vfio_user_pci_realize(PCIDevice *pdev, Error **errp) vbasedev->fd =-1 ; vbasedev->type =VFIO_DEVICE_TYPE_PCI ; vbasedev->ops = &vfio_user_pci_ops; + vbasedev->io_ops = &vfio_dev_io_sock; + + ret =VDEV_GET_INFO (vbasedev, &info); +if (ret) { +error_setg_errno (errp, -ret,"get info failure" ); + goto error; + } +/* must be PCI */ +if ((info.flags &VFIO_DEVICE_FLAGS_PCI ) ==0 ) { +error_setg (errp,"remote device not PCI" ); + goto error; + } + + vbasedev->num_irqs = info.num_irqs; + vbasedev->num_regions = info.num_regions; + vbasedev->flags = info.flags; + vbasedev->reset_works = !!(info.flags &VFIO_DEVICE_FLAGS_RESET ); + +vfio_get_all_regions (vbasedev); +vfio_populate_device (vdev, &err); +if (err) { +error_propagate (errp, err); + goto error; + }return ;
hw/vfio/user.c +44 -0
47 lines not on this page · raw message
Signature · 1 line
1.8.3.1
RFC v4 11/21 vfio-user: get region info
In reply to John JohnsonAdd per-region FD to support mmap() of remote device regions
--- hw/vfio/user-protocol.h | 14 ++++++++++ include/hw/vfio/vfio-common.h | 8 +++--- hw/vfio/common.c | 32 ++++++++++++++++++++--- hw/vfio/user.c | 59 +++++++++++++++++++++++++++++++++++++++++++ 4 files changed, 107 insertions(+), 6 deletions(-)
hw/vfio/user-protocol.h +14 -0
@@ -106,4 +106,18 @@ typedef struct { uint32_t cap_offset; } VFIOUserDeviceInfo; +/* +* VFIO_USER_DEVICE_GET_REGION_INFO +* imported from struct_vfio_region_info +*/ +typedef struct { +VFIOUserHdr hdr; +uint32_t argsz; +uint32_t flags; +uint32_t index; +uint32_t cap_offset; +uint64_t size; +uint64_t offset; +}VFIOUserRegionInfo ; +#endif /* VFIO_USER_PROTOCOL_H */
include/hw/vfio/vfio-common.h +5 -3
@@ -56,6 +56,7 @@ typedef struct VFIORegion {uint32_t nr_mmaps;VFIOMmap *mmaps;uint8_t nr;/* cache the region number for debug */ +int fd;/* fd to mmap() region */ } VFIORegion; typedef struct VFIOMigration {
@@ -150,6 +151,7 @@ typedef struct VFIODevice {OnOffAuto pre_copy_dirty_page_tracking;VFIOProxy *proxy;struct vfio_region_info **regions; +int *regfds; } VFIODevice;struct VFIODeviceOps {
@@ -172,7 +174,7 @@ struct VFIODeviceOps {struct VFIODevIO {int (*get_info)(VFIODevice *vdev,struct vfio_device_info *info);int (*get_region_info)(VFIODevice *vdev, -struct vfio_region_info *info); +struct vfio_region_info *info,int *fd);int (*get_irq_info)(VFIODevice *vdev,struct vfio_irq_info *irq);int (*set_irqs)(VFIODevice *vdev,struct vfio_irq_set *irqs); int (*region_read)(VFIODevice *vdev, uint8_t nr, off_t off, uint32_t size,
@@ -183,8 +185,8 @@ struct VFIODevIO {#define VDEV_GET_INFO (vdev, info) \ ((vdev)->io_ops->get_info((vdev), (info))) -#define VDEV_GET_REGION_INFO (vdev, info) \ - ((vdev)->io_ops->get_region_info((vdev), (info))) +#define VDEV_GET_REGION_INFO (vdev, info, fd) \ + ((vdev)->io_ops->get_region_info((vdev), (info), (fd)))#define VDEV_GET_IRQ_INFO (vdev, irq) \ ((vdev)->io_ops->get_irq_info((vdev), (irq)))#define VDEV_SET_IRQS (vdev, irqs) \
hw/vfio/common.c +29 -3
@@ -40,6 +40,7 @@#include "trace.h" #include "qapi/error.h" #include "migration/migration.h" +#include "hw/vfio/user.h" VFIOGroupList vfio_group_list =QLIST_HEAD_INITIALIZER (vfio_group_list);
@@ -1554,6 +1555,11 @@ int vfio_region_setup(Object *obj, VFIODevice *vbasedev, VFIORegion *region, region->size = info->size; region->fd_offset = info->offset; region->nr = index; +if (vbasedev->regfds !=NULL ) { + region->fd = vbasedev->regfds[index]; + }else { + region->fd = vbasedev->fd; + }if (region->size) { region->mem =g_new0 (MemoryRegion,1 );
@@ -1605,7 +1611,7 @@ int vfio_region_mmap(VFIORegion *region)for (i =0 ; i < region->nr_mmaps; i++) { region->mmaps[i].mmap =mmap (NULL , region->mmaps[i].size, prot, -MAP_SHARED , region->vbasedev->fd, +MAP_SHARED , region->fd, region->fd_offset + region->mmaps[i].offset);if (region->mmaps[i].mmap ==MAP_FAILED ) {
@@ -2410,10 +2416,17 @@ void vfio_put_base_device(VFIODevice *vbasedev)int i;for (i =0 ; i < vbasedev->num_regions; i++) { +if (vbasedev->regfds !=NULL && vbasedev->regfds[i] !=-1 ) { +close (vbasedev->regfds[i]); + }g_free (vbasedev->regions[i]); }g_free (vbasedev->regions); vbasedev->regions =NULL ; +if (vbasedev->regfds !=NULL ) { +g_free (vbasedev->regfds); + vbasedev->regfds =NULL ; + } }if (!vbasedev->group) {
@@ -2429,12 +2442,16 @@ int vfio_get_region_info(VFIODevice *vbasedev, int index, struct vfio_region_info **info) {size_t argsz =sizeof (struct vfio_region_info ); +int fd =-1 ;int ret;/* create region cache */ if (vbasedev->regions ==NULL ) { vbasedev->regions = g_new0(struct vfio_region_info *, vbasedev->num_regions); +if (vbasedev->proxy !=NULL ) { + vbasedev->regfds =g_new0 (int, vbasedev->num_regions); + } }/* check cache */ if (vbasedev->regions[index] !=NULL ) {
@@ -2448,7 +2465,7 @@ int vfio_get_region_info(VFIODevice *vbasedev, int index, retry: (*info)->argsz = argsz; - ret =VDEV_GET_REGION_INFO (vbasedev, *info); + ret =VDEV_GET_REGION_INFO (vbasedev, *info, &fd);if (ret !=0 ) {g_free (*info); *info =NULL ;
@@ -2458,12 +2475,19 @@ retry:if ((*info)->argsz > argsz) { argsz = (*info)->argsz; *info =g_realloc (*info, argsz); +if (fd !=-1 ) { +close (fd); + fd =-1 ; + } goto retry; }/* fill cache */ vbasedev->regions[index] = *info; +if (vbasedev->regfds !=NULL ) { + vbasedev->regfds[index] = fd; + }return 0 ; }
@@ -2623,10 +2647,12 @@ static int vfio_io_get_info(VFIODevice *vbasedev, struct vfio_device_info *info) }static int vfio_io_get_region_info (VFIODevice *vbasedev, -struct vfio_region_info *info) +struct vfio_region_info *info, +int *fd) {int ret; + *fd =-1 ; ret =ioctl (vbasedev->fd,VFIO_DEVICE_GET_REGION_INFO , info);return ret <0 ? -errno : ret;
hw/vfio/user.c +59 -0
72 lines not on this page · raw message
Signature · 1 line
1.8.3.1
RFC v4 12/21 vfio-user: region read/write
In reply to John JohnsonAdd support for posted writes on remote devices
--- hw/vfio/pci.h | 1 + hw/vfio/user-protocol.h | 12 +++++ hw/vfio/user.h | 1 + include/hw/vfio/vfio-common.h | 7 +-- hw/vfio/common.c | 10 +++- hw/vfio/pci.c | 9 +++- hw/vfio/user.c | 109 ++++++++++++++++++++++++++++++++++++++++++ 7 files changed, 143 insertions(+), 6 deletions(-)
hw/vfio/pci.h +1 -0
@@ -194,6 +194,7 @@ struct VFIOUserPCIDevice {VFIOPCIDevice device;char *sock_name;bool send_queued;/* all sends are queued */ +bool no_post;/* all regions write are sync */ };/* Use uin32_t for vendor & device so PCI_ANY_ID expands and cannot match hw */
hw/vfio/user-protocol.h +12 -0
@@ -120,4 +120,16 @@ typedef struct { uint64_t offset; } VFIOUserRegionInfo; +/* +* VFIO_USER_REGION_READ +* VFIO_USER_REGION_WRITE +*/ +typedef struct { +VFIOUserHdr hdr; +uint64_t offset; +uint32_t region; +uint32_t count; +char data[]; +}VFIOUserRegionRW ; +#endif /* VFIO_USER_PROTOCOL_H */
hw/vfio/user.h +1 -0
@@ -75,6 +75,7 @@ typedef struct VFIOProxy {/* VFIOProxy flags */ #define VFIO_PROXY_CLIENT 0x1#define VFIO_PROXY_FORCE_QUEUED 0x4 +#define VFIO_PROXY_NO_POST 0x8VFIOProxy *vfio_user_connect_dev (SocketAddress *addr,Error **errp);void vfio_user_disconnect (VFIOProxy *proxy);
include/hw/vfio/vfio-common.h +4 -3
@@ -57,6 +57,7 @@ typedef struct VFIORegion {VFIOMmap *mmaps;uint8_t nr;/* cache the region number for debug */ int fd;/* fd to mmap() region */ +bool post_wr;/* writes can be posted */ } VFIORegion; typedef struct VFIOMigration {
@@ -180,7 +181,7 @@ struct VFIODevIO {int (*region_read)(VFIODevice *vdev,uint8_t nr,off_t off,uint32_t size,void *data);int (*region_write)(VFIODevice *vdev,uint8_t nr,off_t off,uint32_t size, -void *data); +void *data,bool post); };#define VDEV_GET_INFO (vdev, info) \
@@ -193,8 +194,8 @@ struct VFIODevIO { ((vdev)->io_ops->set_irqs((vdev), (irqs)))#define VDEV_REGION_READ (vdev, nr, off, size, data) \ ((vdev)->io_ops->region_read((vdev), (nr), (off), (size), (data))) -#define VDEV_REGION_WRITE (vdev, nr, off, size, data) \ - ((vdev)->io_ops->region_write((vdev), (nr), (off), (size), (data))) +#define VDEV_REGION_WRITE (vdev, nr, off, size, data, post) \ + ((vdev)->io_ops->region_write((vdev), (nr), (off), (size), (data), (post)))struct VFIOContIO { int (*dma_map)(VFIOContainer *container,
hw/vfio/common.c +8 -2
@@ -213,6 +213,7 @@ void vfio_region_write(void *opaque, hwaddr addr,uint32_t dword;uint64_t qword; } buf; +bool post = region->post_wr;int ret;switch (size) {
@@ -233,7 +234,11 @@ void vfio_region_write(void *opaque, hwaddr addr,break ; } - ret =VDEV_REGION_WRITE (vbasedev, region->nr, addr, size, &buf); +/* read-after-write hazard if guest can directly access region */ +if (region->nr_mmaps) { + post = false; + } + ret =VDEV_REGION_WRITE (vbasedev, region->nr, addr, size, &buf, post);if (ret != size) {const char *err = ret <0 ?strerror (-ret) :"short write" ;
@@ -1555,6 +1560,7 @@ int vfio_region_setup(Object *obj, VFIODevice *vbasedev, VFIORegion *region, region->size = info->size; region->fd_offset = info->offset; region->nr = index; + region->post_wr = false;if (vbasedev->regfds !=NULL ) { region->fd = vbasedev->regfds[index]; }else {
@@ -2689,7 +2695,7 @@ static int vfio_io_region_read(VFIODevice *vbasedev, uint8_t index, off_t off, }static int vfio_io_region_write (VFIODevice *vbasedev,uint8_t index,off_t off, -uint32_t size,void *data) +uint32_t size,void *data,bool post) {struct vfio_region_info *info = vbasedev->regions[index];int ret;
hw/vfio/pci.c +8 -1
@@ -51,7 +51,7 @@ (size), (data))#define VDEV_CONFIG_WRITE (vbasedev, off, size, data) \ VDEV_REGION_WRITE((vbasedev), VFIO_PCI_CONFIG_REGION_INDEX, (off), \ - (size), (data)) + (size), (data), false)#define TYPE_VFIO_PCI_NOHOTPLUG "vfio-pci-nohotplug"
@@ -1658,6 +1658,9 @@ static void vfio_bar_prepare(VFIOPCIDevice *vdev, int nr) bar->type = pci_bar & (bar->ioport ? ~PCI_BASE_ADDRESS_IO_MASK : ~PCI_BASE_ADDRESS_MEM_MASK ); bar->size = bar->region.size; + +/* IO regions are sync, memory can be async */ + bar->region.post_wr = (bar->ioport ==0 ); }static void vfio_bars_prepare (VFIOPCIDevice *vdev)
@@ -3444,6 +3447,9 @@ static void vfio_user_pci_realize(PCIDevice *pdev, Error **errp)if (udev->send_queued) { proxy->flags |=VFIO_PROXY_FORCE_QUEUED ; } +if (udev->no_post) { + proxy->flags |=VFIO_PROXY_NO_POST ; + }vfio_user_validate_version (vbasedev, &err);if (err !=NULL ) {
@@ -3503,6 +3509,7 @@ static void vfio_user_instance_finalize(Object *obj)static Property vfio_user_pci_dev_properties[] = {DEFINE_PROP_STRING ("socket" , VFIOUserPCIDevice, sock_name),DEFINE_PROP_BOOL ("x-send-queued" , VFIOUserPCIDevice, send_queued, false), +DEFINE_PROP_BOOL ("x-no-posted-writes" , VFIOUserPCIDevice, no_post, false),DEFINE_PROP_END_OF_LIST (), };
hw/vfio/user.c +109 -0
135 lines not on this page · raw message
Signature · 1 line
1.8.3.1
RE: [RFC v4 12/21] vfio-user: region read/write
Quoted 185 lines
-----Original Message-----
From: Qemu-devel <qemu-devel- [email protected]> On Behalf Of John Johnson
Sent: 12 January 2022 00:44
To: [email protected]
Subject: [RFC v4 12/21] vfio-user: region read/writeAdd support for posted writes on remote devices
Signed-off-by Elena Ufimtseva <[email protected]>Signed-off-by John G Johnson <[email protected]>Signed-off-by Jagannathan Raman <[email protected]>--- hw/vfio/pci.h | 1 + hw/vfio/user-protocol.h | 12 +++++ hw/vfio/user.h | 1 + include/hw/vfio/vfio-common.h | 7 +-- hw/vfio/common.c | 10 +++- hw/vfio/pci.c | 9 +++- hw/vfio/user.c | 109 ++++++++++++++++++++++++++++++++++++++++++ 7 files changed, 143 insertions(+), 6 deletions(-)hw/vfio/pci.h +1
-0@@ -194,6 +194,7 @@ struct VFIOUserPCIDevice {VFIOPCIDevice device;char *sock_name;bool send_queued;/* all sends are queued */ +bool no_post;/* all regions write are sync */ };/* Use uin32_t for vendor & device so PCI_ANY_ID expands and cannot match hw */
hw/vfio/user-protocol.h +12
-0@@ -120,4 +120,16 @@ typedef struct { uint64_t offset; } VFIOUserRegionInfo; +/* +* VFIO_USER_REGION_READ +* VFIO_USER_REGION_WRITE +*/ +typedef struct { +VFIOUserHdr hdr; +uint64_t offset; +uint32_t region; +uint32_t count; +char data[]; +}VFIOUserRegionRW ; +#endif /* VFIO_USER_PROTOCOL_H */ hw/vfio/user.h +1
-0@@ -75,6 +75,7 @@ typedef struct VFIOProxy {/* VFIOProxy flags */ #define VFIO_PROXY_CLIENT 0x1#define VFIO_PROXY_FORCE_QUEUED 0x4 +#define VFIO_PROXY_NO_POST 0x8VFIOProxy *vfio_user_connect_dev (SocketAddress *addr,Error **errp);void vfio_user_disconnect (VFIOProxy *proxy);include/hw/vfio/vfio-common.h +4
-3@@ -57,6 +57,7 @@ typedef struct VFIORegion {VFIOMmap *mmaps;uint8_t nr;/* cache the region number for debug */ int fd;/* fd to mmap() region */ +bool post_wr;/* writes can be posted */ } VFIORegion; typedef struct VFIOMigration {@@ -180,7 +181,7 @@ struct VFIODevIO {int (*region_read)(VFIODevice *vdev,uint8_t nr,off_t off,uint32_t size,void *data);int (*region_write)(VFIODevice *vdev,uint8_t nr,off_t off,uint32_t size, -void *data); +void *data,bool post); };#define VDEV_GET_INFO (vdev, info) \@@ -193,8 +194,8 @@ struct VFIODevIO { ((vdev)->io_ops->set_irqs((vdev), (irqs)))#define VDEV_REGION_READ (vdev, nr, off, size, data) \ ((vdev)->io_ops->region_read((vdev), (nr), (off), (size), (data))) -#define VDEV_REGION_WRITE (vdev, nr, off, size, data) \ - ((vdev)->io_ops->region_write((vdev), (nr), (off), (size), (data))) +#define VDEV_REGION_WRITE (vdev, nr, off, size, data, post) \ + ((vdev)->io_ops->region_write((vdev), (nr), (off), (size), (data), (post)))struct VFIOContIO { int (*dma_map)(VFIOContainer *container,hw/vfio/common.c +7
-1@@ -213,6 +213,7 @@ void vfio_region_write(void *opaque, hwaddr addr,uint32_t dword;uint64_t qword; } buf; +bool post = region->post_wr;int ret;switch (size) {@@ -233,7 +234,11 @@ void vfio_region_write(void *opaque, hwaddr addr,break ; } - ret =VDEV_REGION_WRITE (vbasedev, region->nr, addr, size, &buf); +/* read-after-write hazard if guest can directly access region */ +if (region->nr_mmaps) { + post = false; + } + ret =VDEV_REGION_WRITE (vbasedev, region->nr, addr, size, &buf, post);if (ret != size) {const char *err = ret <0 ?strerror (-ret) :"short write" ;@@ -1555,6 +1560,7 @@ int vfio_region_setup(Object *obj, VFIODevice *vbasedev, VFIORegion *region, region->size = info->size; region->fd_offset = info->offset; region->nr = index; + region->post_wr = false;if (vbasedev->regfds !=NULL ) { region->fd = vbasedev->regfds[index];} else {hw/vfio/common.c +1
-1@@ -2689,7 +2695,7 @@ static int vfio_io_region_read(VFIODevice *vbasedev, uint8_t index, off_t off, } static int vfio_io_region_write(VFIODevice *vbasedev, uint8_t index, off_t off, - uint32_t size, void *data) + uint32_t size, void *data, bool post) { struct vfio_region_info *info = vbasedev->regions[index];int ret;hw/vfio/pci.c +4
-1@@ -51,7 +51,7 @@ (size), (data))#define VDEV_CONFIG_WRITE (vbasedev, off, size, data) \ VDEV_REGION_WRITE((vbasedev), VFIO_PCI_CONFIG_REGION_INDEX, (off), \ - (size), (data)) + (size), (data), false)#define TYPE_VFIO_PCI_NOHOTPLUG "vfio-pci-nohotplug"@@ -1658,6 +1658,9 @@ static void vfio_bar_prepare(VFIOPCIDevice *vdev, int nr) bar->type = pci_bar & (bar->ioport ? ~PCI_BASE_ADDRESS_IO_MASK : ~PCI_BASE_ADDRESS_MEM_MASK ); bar->size = bar->region.size; + +/* IO regions are sync, memory can be async */ + bar->region.post_wr = (bar->ioport ==0 ); }static void
vfio_bars_prepare(VFIOPCIDevice *vdev)hw/vfio/pci.c +3
-0@@ -3444,6 +3447,9 @@ static void vfio_user_pci_realize(PCIDevice *pdev, Error **errp)if (udev->send_queued) { proxy->flags |=VFIO_PROXY_FORCE_QUEUED ; } +if (udev->no_post) { + proxy->flags |=VFIO_PROXY_NO_POST ; + }vfio_user_validate_version (vbasedev, &err);if (err != NULL) {
hw/vfio/pci.c static void vfio_user_instance_finalize(Object *obj) · line 3513
Quoted 5 lines
hw/vfio/pci.c +1
-0@@ -3503,6 +3509,7 @@ static void vfio_user_instance_finalize(Object *obj)static Property vfio_user_pci_dev_properties[] = {DEFINE_PROP_STRING ("socket" , VFIOUserPCIDevice, sock_name),DEFINE_PROP_BOOL ("x-send-queued" , VFIOUserPCIDevice, send_queued, false), + DEFINE_PROP_BOOL("x-no-posted-writes", VFIOUserPCIDevice, no_post,
IMO renaming this to "x-posted-writes" and defaulting it to true would be easier to understand, but that's a matter of personal preference.
Could we have another option that would check the error code of the response for writes, at least for debugging purposes? IIUC in real HW writes are posted it isn't possible to check whether HW was happy with the write, but now we're talking to emulated HW.
I suppose this new option would have to depend on writes not being posted.
Quoted 154 lines
hw/vfio/pci.c +0
-0false), DEFINE_PROP_END_OF_LIST(),};
hw/vfio/user.c +29
-0@@ -50,6 +50,8 @@ static void vfio_user_cb(void *opaque);static void vfio_user_request (void *opaque);static int vfio_user_send_queued (VFIOProxy *proxy,VFIOUserMsg *msg); +static void vfio_user_send_async (VFIOProxy *proxy,VFIOUserHdr *hdr, +VFIOUserFDs *fds);static void vfio_user_send_wait (VFIOProxy *proxy,VFIOUserHdr *hdr,VFIOUserFDs *fds,int rsize,bool nobql); static void vfio_user_request_msg(VFIOUserHdr *hdr, uint16_t cmd,@@ -534,6 +536,33 @@ static int vfio_user_send_queued(VFIOProxy *proxy, VFIOUserMsg *msg)return 0 ; } +/* +* async send - msg can be queued, but will be freed when sent +*/ +static void vfio_user_send_async (VFIOProxy *proxy,VFIOUserHdr *hdr, +VFIOUserFDs *fds) +{ +VFIOUserMsg *msg; +int ret; + +if (!(hdr->flags & (VFIO_USER_NO_REPLY |VFIO_USER_REPLY ))) { +error_printf ("vfio_user_send_async on sync message\n" ); +return ; + } + +QEMU_LOCK_GUARD (&proxy->lock); + + msg =vfio_user_getmsg (proxy, hdr, fds); + msg->id = hdr->id; + msg->rsize =0 ; + msg->type =VFIO_MSG_ASYNC ; + + ret =vfio_user_send_queued (proxy, msg); +if (ret <0 ) { +vfio_user_recycle (proxy, msg); + } +} +static void vfio_user_send_wait (VFIOProxy *proxy,VFIOUserHdr *hdr,VFIOUserFDs *fds,int rsize,bool nobql){
hw/vfio/user.c +64
-0@@ -959,6 +988,70 @@ static int vfio_user_get_region_info(VFIOProxy *proxy,return 0 ; } +static int vfio_user_region_read (VFIOProxy *proxy,uint8_t index,off_t offset, +uint32_t count,void *data) +{ + g_autofree VFIOUserRegionRW *msgp = NULL; +int size =sizeof (*msgp) + count; + +if (count > max_xfer_size) { +return -EINVAL ; + } + + msgp =g_malloc0 (size); +vfio_user_request_msg (&msgp->hdr,VFIO_USER_REGION_READ ,sizeof (*msgp),0 ); + msgp->offset = offset; + msgp->region = index; + msgp->count = count; + +vfio_user_send_wait (proxy, &msgp->hdr,NULL , size, false); +if (msgp->hdr.flags &VFIO_USER_ERROR ) { +return -msgp->hdr.error_reply; + }else if (msgp->count > count) { +return -E2BIG ; + }else { +memcpy (data, &msgp->data, msgp->count); + } + +return msgp->count; +} + +static int vfio_user_region_write (VFIOProxy *proxy,uint8_t index,off_t offset, +uint32_t count,void *data,bool post) +{ +VFIOUserRegionRW *msgp =NULL ; +int flags = post ?VFIO_USER_NO_REPLY :0 ; +int size =sizeof (*msgp) + count; +int ret; + +if (count > max_xfer_size) { +return -EINVAL ; + } + + msgp =g_malloc0 (size); +vfio_user_request_msg (&msgp->hdr,VFIO_USER_REGION_WRITE , size, flags); + msgp->offset = offset; + msgp->region = index; + msgp->count = count; +memcpy (&msgp->data, data, count); + +/* async send will free msg after it's sent */ +if (post && !(proxy->flags &VFIO_PROXY_NO_POST )) { +vfio_user_send_async (proxy, &msgp->hdr,NULL ); +return count; + } + +vfio_user_send_wait (proxy, &msgp->hdr,NULL ,0 , false); +if (msgp->hdr.flags &VFIO_USER_ERROR ) { + ret = -msgp->hdr.error_reply; + }else { + ret = count; + } + +g_free (msgp); +return ret; +} +/*
* Socket-basedio_opshw/vfio/user.c +16
-1@@ -1005,8 +1098,24 @@ static int vfio_user_io_get_region_info(VFIODevice *vbasedev, return 0; } +static int vfio_user_io_region_read (VFIODevice *vbasedev,uint8_t index, +off_t off,uint32_t size,void *data) +{ +return vfio_user_region_read (vbasedev->proxy, index, off, size, data); +} + +static int vfio_user_io_region_write (VFIODevice *vbasedev,uint8_t index, +off_t off,unsigned size,void *data, +bool post) +{ +return vfio_user_region_write (vbasedev->proxy, index, off, size, data, + post); +} +VFIODevIO vfio_dev_io_sock = { .get_info = vfio_user_io_get_info, .get_region_info = vfio_user_io_get_region_info, + .region_read = vfio_user_io_region_read, + .region_write = vfio_user_io_region_write, }; --1.8.3.1
RFC v4 13/21 vfio-user: pci_user_realize PCI setup
In reply to John JohnsonPCI BARs read from remote device
PCI config reads/writes sent to remote server
--- hw/vfio/pci.c | 275 ++++++++++++++++++++++++++++++++++++---------------------- 1 file changed, 172 insertions(+), 103 deletions(-)
hw/vfio/pci.c +172 -103
@@ -2830,6 +2830,132 @@ static void vfio_unregister_req_notifier(VFIOPCIDevice *vdev) vdev->req_enabled = false; } +static void vfio_pci_config_setup (VFIOPCIDevice *vdev,Error **errp) +{ +PCIDevice *pdev = &vdev->pdev; +Error *err =NULL ; + +/* vfio emulates a lot for us, but some bits need extra love */ + vdev->emulated_config_bits =g_malloc0 (vdev->config_size); + +/* QEMU can choose to expose the ROM or not */ +memset (vdev->emulated_config_bits +PCI_ROM_ADDRESS ,0xff ,4 ); +/* QEMU can also add or extend BARs */ +memset (vdev->emulated_config_bits +PCI_BASE_ADDRESS_0 ,0xff ,6 *4 ); + +/* +* The PCI spec reserves vendor ID 0xffff as an invalid value. The +* device ID is managed by the vendor and need only be a 16-bit value. +* Allow any 16-bit value for subsystem so they can be hidden or changed. +*/ +if (vdev->vendor_id !=PCI_ANY_ID ) { +if (vdev->vendor_id >=0xffff ) { +error_setg (errp,"invalid PCI vendor ID provided" ); +return ; + } +vfio_add_emulated_word (vdev,PCI_VENDOR_ID , vdev->vendor_id, ~0 ); +trace_vfio_pci_emulated_vendor_id (vdev->vbasedev.name, vdev->vendor_id); + }else { + vdev->vendor_id =pci_get_word (pdev->config +PCI_VENDOR_ID ); + } + +if (vdev->device_id !=PCI_ANY_ID ) { +if (vdev->device_id >0xffff ) { +error_setg (errp,"invalid PCI device ID provided" ); +return ; + } +vfio_add_emulated_word (vdev,PCI_DEVICE_ID , vdev->device_id, ~0 ); +trace_vfio_pci_emulated_device_id (vdev->vbasedev.name, vdev->device_id); + }else { + vdev->device_id =pci_get_word (pdev->config +PCI_DEVICE_ID ); + } + +if (vdev->sub_vendor_id !=PCI_ANY_ID ) { +if (vdev->sub_vendor_id >0xffff ) { +error_setg (errp,"invalid PCI subsystem vendor ID provided" ); +return ; + } +vfio_add_emulated_word (vdev,PCI_SUBSYSTEM_VENDOR_ID , + vdev->sub_vendor_id, ~0 ); +trace_vfio_pci_emulated_sub_vendor_id (vdev->vbasedev.name, + vdev->sub_vendor_id); + } + +if (vdev->sub_device_id !=PCI_ANY_ID ) { +if (vdev->sub_device_id >0xffff ) { +error_setg (errp,"invalid PCI subsystem device ID provided" ); +return ; + } +vfio_add_emulated_word (vdev,PCI_SUBSYSTEM_ID , vdev->sub_device_id, ~0 ); +trace_vfio_pci_emulated_sub_device_id (vdev->vbasedev.name, + vdev->sub_device_id); + } + +/* QEMU can change multi-function devices to single function, or reverse */ + vdev->emulated_config_bits[PCI_HEADER_TYPE ] = +PCI_HEADER_TYPE_MULTI_FUNCTION ; + +/* Restore or clear multifunction, this is always controlled by QEMU */ +if (vdev->pdev.cap_present &QEMU_PCI_CAP_MULTIFUNCTION ) { + vdev->pdev.config[PCI_HEADER_TYPE ] |=PCI_HEADER_TYPE_MULTI_FUNCTION ; + }else { + vdev->pdev.config[PCI_HEADER_TYPE ] &= ~PCI_HEADER_TYPE_MULTI_FUNCTION ; + } + +/* +* Clear host resource mapping info. If we choose not to register a +* BAR, such as might be the case with the option ROM, we can get +* confusing, unwritable, residual addresses from the host here. +*/ +memset (&vdev->pdev.config[PCI_BASE_ADDRESS_0 ],0 ,24 ); +memset (&vdev->pdev.config[PCI_ROM_ADDRESS ],0 ,4 ); + +vfio_pci_size_rom (vdev); + +vfio_bars_prepare (vdev); + +vfio_msix_early_setup (vdev, &err); +if (err) { +error_propagate (errp, err); +return ; + } + +vfio_bars_register (vdev); +} + +static int vfio_interrupt_setup (VFIOPCIDevice *vdev,Error **errp) +{ +PCIDevice *pdev = &vdev->pdev; +int ret; + +/* QEMU emulates all of MSI & MSIX */ +if (pdev->cap_present &QEMU_PCI_CAP_MSIX ) { +memset (vdev->emulated_config_bits + pdev->msix_cap,0xff , +MSIX_CAP_LENGTH ); + } + +if (pdev->cap_present &QEMU_PCI_CAP_MSI ) { +memset (vdev->emulated_config_bits + pdev->msi_cap,0xff , + vdev->msi_cap_size); + } + +if (vfio_pci_read_config (&vdev->pdev,PCI_INTERRUPT_PIN ,1 )) { + vdev->intx.mmap_timer =timer_new_ms (QEMU_CLOCK_VIRTUAL , + vfio_intx_mmap_enable, vdev); +pci_device_set_intx_routing_notifier (&vdev->pdev, + vfio_intx_routing_notifier); + vdev->irqchip_change_notifier.notify = vfio_irqchip_change; +kvm_irqchip_add_change_notifier (&vdev->irqchip_change_notifier); + ret =vfio_intx_enable (vdev, errp); +if (ret) { +pci_device_set_intx_routing_notifier (&vdev->pdev,NULL ); +kvm_irqchip_remove_change_notifier (&vdev->irqchip_change_notifier); +return ret; + } + } +return 0 ; +} +static void vfio_realize (PCIDevice *pdev,Error **errp) {VFIOPCIDevice *vdev =VFIO_PCI_BASE (pdev);
@@ -2945,92 +3071,16 @@ static void vfio_realize(PCIDevice *pdev, Error **errp) goto error; } -/* vfio emulates a lot for us, but some bits need extra love */ - vdev->emulated_config_bits =g_malloc0 (vdev->config_size); - -/* QEMU can choose to expose the ROM or not */ -memset (vdev->emulated_config_bits +PCI_ROM_ADDRESS ,0xff ,4 ); -/* QEMU can also add or extend BARs */ -memset (vdev->emulated_config_bits +PCI_BASE_ADDRESS_0 ,0xff ,6 *4 ); - -/* -* The PCI spec reserves vendor ID 0xffff as an invalid value. The -* device ID is managed by the vendor and need only be a 16-bit value. -* Allow any 16-bit value for subsystem so they can be hidden or changed. -*/ -if (vdev->vendor_id !=PCI_ANY_ID ) { -if (vdev->vendor_id >=0xffff ) { -error_setg (errp,"invalid PCI vendor ID provided" ); - goto error; - } -vfio_add_emulated_word (vdev,PCI_VENDOR_ID , vdev->vendor_id, ~0 ); -trace_vfio_pci_emulated_vendor_id (vdev->vbasedev.name, vdev->vendor_id); - }else { - vdev->vendor_id =pci_get_word (pdev->config +PCI_VENDOR_ID ); - } - -if (vdev->device_id !=PCI_ANY_ID ) { -if (vdev->device_id >0xffff ) { -error_setg (errp,"invalid PCI device ID provided" ); - goto error; - } -vfio_add_emulated_word (vdev,PCI_DEVICE_ID , vdev->device_id, ~0 ); -trace_vfio_pci_emulated_device_id (vdev->vbasedev.name, vdev->device_id); - }else { - vdev->device_id =pci_get_word (pdev->config +PCI_DEVICE_ID ); - } - -if (vdev->sub_vendor_id !=PCI_ANY_ID ) { -if (vdev->sub_vendor_id >0xffff ) { -error_setg (errp,"invalid PCI subsystem vendor ID provided" ); - goto error; - } -vfio_add_emulated_word (vdev,PCI_SUBSYSTEM_VENDOR_ID , - vdev->sub_vendor_id, ~0 ); -trace_vfio_pci_emulated_sub_vendor_id (vdev->vbasedev.name, - vdev->sub_vendor_id); - } - -if (vdev->sub_device_id !=PCI_ANY_ID ) { -if (vdev->sub_device_id >0xffff ) { -error_setg (errp,"invalid PCI subsystem device ID provided" ); - goto error; - } -vfio_add_emulated_word (vdev,PCI_SUBSYSTEM_ID , vdev->sub_device_id, ~0 ); -trace_vfio_pci_emulated_sub_device_id (vdev->vbasedev.name, - vdev->sub_device_id); - } - -/* QEMU can change multi-function devices to single function, or reverse */ - vdev->emulated_config_bits[PCI_HEADER_TYPE ] = -PCI_HEADER_TYPE_MULTI_FUNCTION ; - -/* Restore or clear multifunction, this is always controlled by QEMU */ -if (vdev->pdev.cap_present &QEMU_PCI_CAP_MULTIFUNCTION ) { - vdev->pdev.config[PCI_HEADER_TYPE ] |=PCI_HEADER_TYPE_MULTI_FUNCTION ; - }else { - vdev->pdev.config[PCI_HEADER_TYPE ] &= ~PCI_HEADER_TYPE_MULTI_FUNCTION ; - } - -/* -* Clear host resource mapping info. If we choose not to register a -* BAR, such as might be the case with the option ROM, we can get -* confusing, unwritable, residual addresses from the host here. -*/ -memset (&vdev->pdev.config[PCI_BASE_ADDRESS_0 ],0 ,24 ); -memset (&vdev->pdev.config[PCI_ROM_ADDRESS ],0 ,4 ); - -vfio_pci_size_rom (vdev); - -vfio_bars_prepare (vdev); - -vfio_msix_early_setup (vdev, &err); +vfio_pci_config_setup (vdev, &err);if (err) { -error_propagate (errp, err); goto error; } -vfio_bars_register (vdev); +/* +* vfio_pci_config_setup will have registered the device's BARs +* and setup any MSIX BARs, so errors after it succeeds must +* use out_teardown +*/ ret =vfio_add_capabilities (vdev, errp);if (ret) {
@@ -3071,29 +3121,15 @@ static void vfio_realize(PCIDevice *pdev, Error **errp) } } -/* QEMU emulates all of MSI & MSIX */ -if (pdev->cap_present &QEMU_PCI_CAP_MSIX ) { -memset (vdev->emulated_config_bits + pdev->msix_cap,0xff , -MSIX_CAP_LENGTH ); - } - -if (pdev->cap_present &QEMU_PCI_CAP_MSI ) { -memset (vdev->emulated_config_bits + pdev->msi_cap,0xff , - vdev->msi_cap_size); + ret =vfio_interrupt_setup (vdev, errp); +if (ret) { + goto out_teardown; } -if (vfio_pci_read_config (&vdev->pdev,PCI_INTERRUPT_PIN ,1 )) { - vdev->intx.mmap_timer =timer_new_ms (QEMU_CLOCK_VIRTUAL , - vfio_intx_mmap_enable, vdev); -pci_device_set_intx_routing_notifier (&vdev->pdev, - vfio_intx_routing_notifier); - vdev->irqchip_change_notifier.notify = vfio_irqchip_change; -kvm_irqchip_add_change_notifier (&vdev->irqchip_change_notifier); - ret =vfio_intx_enable (vdev, errp); -if (ret) { - goto out_deregister; - } - } +/* +* vfio_interrupt_setup will have setup INTx's KVM routing +* so errors after it succeeds must use out_deregister +*/ if (vdev->display !=ON_OFF_AUTO_OFF ) { ret =vfio_display_probe (vdev, errp);
@@ -3487,8 +3523,41 @@ static void vfio_user_pci_realize(PCIDevice *pdev, Error **errp) goto error; } +/* Get a copy of config space */ + ret =VDEV_REGION_READ (vbasedev,VFIO_PCI_CONFIG_REGION_INDEX ,0 , +MIN (pci_config_size (pdev), vdev->config_size), + pdev->config); +if (ret < (int )MIN (pci_config_size (&vdev->pdev), vdev->config_size)) { +error_setg_errno (errp, -ret,"failed to read device config space" ); + goto error; + } + +vfio_pci_config_setup (vdev, &err); +if (err) { + goto error; + } + +/* +* vfio_pci_config_setup will have registered the device's BARs +* and setup any MSIX BARs, so errors after it succeeds must +* use out_teardown +*/ + + ret =vfio_add_capabilities (vdev, errp); +if (ret) { + goto out_teardown; + } + + ret =vfio_interrupt_setup (vdev, errp); +if (ret) { + goto out_teardown; + } +return ; +out_teardown: +vfio_teardown_msi (vdev); +vfio_bars_exit (vdev); error:vfio_user_disconnect (proxy);error_prepend (errp,VFIO_MSG_PREFIX , vdev->vbasedev.name);
Signature · 1 line
1.8.3.1
RFC v4 14/21 vfio-user: get and set IRQs
In reply to John Johnson--- hw/vfio/user-protocol.h | 25 +++++++++ hw/vfio/pci.c | 9 +++- hw/vfio/user.c | 131 ++++++++++++++++++++++++++++++++++++++++++++++++ 3 files changed, 163 insertions(+), 2 deletions(-)
hw/vfio/user-protocol.h +25 -0
@@ -121,6 +121,31 @@ typedef struct { } VFIOUserRegionInfo;/* +* VFIO_USER_DEVICE_GET_IRQ_INFO +* imported from struct vfio_irq_info +*/ +typedef struct { +VFIOUserHdr hdr; +uint32_t argsz; +uint32_t flags; +uint32_t index; +uint32_t count; +}VFIOUserIRQInfo ; + +/* +* VFIO_USER_DEVICE_SET_IRQS +* imported from struct vfio_irq_set +*/ +typedef struct { +VFIOUserHdr hdr; +uint32_t argsz; +uint32_t flags; +uint32_t index; +uint32_t start; +uint32_t count; +}VFIOUserIRQSet ; + +/* * VFIO_USER_REGION_READ * VFIO_USER_REGION_WRITE */
hw/vfio/pci.c +7 -2
@@ -514,7 +514,7 @@ static int vfio_msix_vector_do_use(PCIDevice *pdev, unsigned int nr, vdev->nr_vectors = nr +1 ; ret =vfio_enable_vectors (vdev, true);if (ret) { -error_report ("vfio: failed to enable vectors, %d" , ret); +error_report ("vfio: failed to enable vectors, %s" ,strerror (-ret)); } }else {Error *err =NULL ;
@@ -659,7 +659,8 @@ retry: ret =vfio_enable_vectors (vdev, false);if (ret) {if (ret <0 ) { -error_report ("vfio: Error: Failed to setup MSI fds: %m" ); +error_report ("vfio: Error: Failed to setup MSI fds: %s" , +strerror (-ret)); }else if (ret != vdev->nr_vectors) {error_report ("vfio: Error: Failed to enable %d " "MSI vectors, retry with %d" , vdev->nr_vectors, ret);
@@ -2668,6 +2669,7 @@ static void vfio_populate_device(VFIOPCIDevice *vdev, Error **errp) irq_info.index =VFIO_PCI_ERR_IRQ_INDEX ; ret =VDEV_GET_IRQ_INFO (vbasedev, &irq_info); +if (ret) {/* This can fail for an old kernel or legacy PCI dev */ trace_vfio_populate_device_get_irq_info_failure (strerror (errno));
@@ -3553,6 +3555,9 @@ static void vfio_user_pci_realize(PCIDevice *pdev, Error **errp) goto out_teardown; } +vfio_register_err_notifier (vdev); +vfio_register_req_notifier (vdev); +return ; out_teardown:
hw/vfio/user.c +131 -0
149 lines not on this page · raw message
Signature · 1 line
1.8.3.1
RFC v4 15/21 vfio-user: proxy container connect/disconnect
In reply to John Johnson--- hw/vfio/user.h | 1 + include/hw/vfio/vfio-common.h | 3 ++ hw/vfio/common.c | 105 ++++++++++++++++++++++++++++++++++++++++++ hw/vfio/pci.c | 25 ++++++++++ hw/vfio/user.c | 3 ++ 5 files changed, 137 insertions(+)
hw/vfio/user.h +1 -0
@@ -85,5 +85,6 @@ void vfio_user_set_handler(VFIODevice *vbasedev,int vfio_user_validate_version (VFIODevice *vbasedev,Error **errp);extern VFIODevIO vfio_dev_io_sock; +extern VFIOContIO vfio_cont_io_sock;#endif /* VFIO_USER_H */
include/hw/vfio/vfio-common.h +3 -0
@@ -94,6 +94,7 @@ typedef struct VFIOContainer {uint64_t max_dirty_bitmap_size;unsigned long pgsizes;unsigned int dma_max_mappings; +VFIOProxy *proxy; QLIST_HEAD(, VFIOGuestIOMMU) giommu_list; QLIST_HEAD(, VFIOHostDMAWindow) hostwin_list; QLIST_HEAD(, VFIOGroup) group_list;
@@ -278,6 +279,8 @@ VFIOGroup *vfio_get_group(int groupid, AddressSpace *as, Error **errp);void vfio_put_group (VFIOGroup *group);int vfio_get_device (VFIOGroup *group,const char *name,VFIODevice *vbasedev,Error **errp); +void vfio_connect_proxy (VFIOProxy *proxy,VFIOGroup *group,AddressSpace *as); +void vfio_disconnect_proxy (VFIOGroup *group);extern const MemoryRegionOps vfio_region_ops; typedef QLIST_HEAD(VFIOGroupList, VFIOGroup) VFIOGroupList;
hw/vfio/common.c +105 -0
123 lines not on this page · raw message
hw/vfio/pci.c +25 -0
@@ -3456,6 +3456,7 @@ static void vfio_user_pci_realize(PCIDevice *pdev, Error **errp)VFIODevice *vbasedev = &vdev->vbasedev;SocketAddress addr;VFIOProxy *proxy; +VFIOGroup *group =NULL ;struct vfio_device_info info;int ret;Error *err =NULL ;
@@ -3502,6 +3503,19 @@ static void vfio_user_pci_realize(PCIDevice *pdev, Error **errp) vbasedev->ops = &vfio_user_pci_ops; vbasedev->io_ops = &vfio_dev_io_sock; +/* +* each device gets its own group and container +* make them unrelated to any host IOMMU groupings +*/ + group =g_malloc0 (sizeof (*group)); + group->fd =-1 ; + group->groupid =-1 ; +QLIST_INIT (&group->device_list); +QLIST_INSERT_HEAD (&group->device_list, vbasedev, next); + vbasedev->group = group; + +vfio_connect_proxy (proxy, group,pci_device_iommu_address_space (pdev)); + ret =VDEV_GET_INFO (vbasedev, &info);if (ret) {error_setg_errno (errp, -ret,"get info failure" );
@@ -3564,6 +3578,10 @@ out_teardown:vfio_teardown_msi (vdev);vfio_bars_exit (vdev); error: +if (group !=NULL ) { +vfio_disconnect_proxy (group); +g_free (group); + }vfio_user_disconnect (proxy);error_prepend (errp,VFIO_MSG_PREFIX , vdev->vbasedev.name); }
@@ -3572,6 +3590,13 @@ static void vfio_user_instance_finalize(Object *obj) {VFIOPCIDevice *vdev =VFIO_PCI_BASE (obj);VFIODevice *vbasedev = &vdev->vbasedev; +VFIOGroup *group = vbasedev->group; + +if (group !=NULL ) { +vfio_disconnect_proxy (group); +g_free (group); + vbasedev->group =NULL ; + }vfio_put_device (vdev);
hw/vfio/user.c +3 -0
@@ -1250,3 +1250,6 @@ VFIODevIO vfio_dev_io_sock = { .region_write = vfio_user_io_region_write, }; + +VFIOContIO vfio_cont_io_sock = { +};
Signature · 1 line
1.8.3.1
RFC v4 16/21 vfio-user: dma map/unmap operations
In reply to John JohnsonAdd ability to do async operations during memory transactions
--- hw/vfio/user-protocol.h | 32 +++++++ include/hw/vfio/vfio-common.h | 9 +- hw/vfio/common.c | 63 +++++++++--- hw/vfio/user.c | 217 ++++++++++++++++++++++++++++++++++++++++++ 4 files changed, 305 insertions(+), 16 deletions(-)
hw/vfio/user-protocol.h +32 -0
@@ -94,6 +94,31 @@ typedef struct {/* +* VFIO_USER_DMA_MAP +* imported from struct vfio_iommu_type1_dma_map +*/ +typedef struct { +VFIOUserHdr hdr; +uint32_t argsz; +uint32_t flags; +uint64_t offset;/* FD offset */ +uint64_t iova; +uint64_t size; +}VFIOUserDMAMap ; + +/* +* VFIO_USER_DMA_UNMAP +* imported from struct vfio_iommu_type1_dma_unmap +*/ +typedef struct { +VFIOUserHdr hdr; +uint32_t argsz; +uint32_t flags; +uint64_t iova; +uint64_t size; +}VFIOUserDMAUnmap ; + +/* * VFIO_USER_DEVICE_GET_INFO * imported from struct_device_info */
@@ -157,4 +182,11 @@ typedef struct { char data[]; } VFIOUserRegionRW; +/*imported from struct vfio_bitmap */ +typedef struct { +uint64_t pgsize; +uint64_t size; +char data[]; +}VFIOUserBitmap ; +#endif /* VFIO_USER_PROTOCOL_H */
include/hw/vfio/vfio-common.h +6 -3
@@ -90,6 +90,7 @@ typedef struct VFIOContainer {VFIOContIO *io_ops;bool initialized;bool dirty_pages_supported; +bool async_ops;uint64_t dirty_pgsizes;uint64_t max_dirty_bitmap_size;unsigned long pgsizes;
@@ -199,7 +200,7 @@ struct VFIODevIO { ((vdev)->io_ops->region_write((vdev), (nr), (off), (size), (data), (post)))struct VFIOContIO { -int (*dma_map)(VFIOContainer *container, +int (*dma_map)(VFIOContainer *container,MemoryRegion *mr,struct vfio_iommu_type1_dma_map *map); int (*dma_unmap)(VFIOContainer *container, struct vfio_iommu_type1_dma_unmap *unmap,
@@ -207,14 +208,16 @@ struct VFIOContIO {int (*dirty_bitmap)(VFIOContainer *container,struct vfio_iommu_type1_dirty_bitmap *bitmap,struct vfio_iommu_type1_dirty_bitmap_get *range); +void (*wait_commit)(VFIOContainer *container); }; -#define CONT_DMA_MAP (cont, map) \ - ((cont)->io_ops->dma_map((cont), (map))) +#define CONT_DMA_MAP (cont, mr, map) \ + ((cont)->io_ops->dma_map((cont), (mr), (map)))#define CONT_DMA_UNMAP (cont, unmap, bitmap) \ ((cont)->io_ops->dma_unmap((cont), (unmap), (bitmap)))#define CONT_DIRTY_BITMAP (cont, bitmap, range) \ ((cont)->io_ops->dirty_bitmap((cont), (bitmap), (range))) +#define CONT_WAIT_COMMIT (cont) ((cont)->io_ops->wait_commit(cont))extern VFIODevIO vfio_dev_io_ioctl;extern VFIOContIO vfio_cont_io_ioctl;
hw/vfio/common.c +50 -13
157 lines not on this page · raw message
hw/vfio/user.c +217 -0
248 lines not on this page · raw message
Signature · 1 line
1.8.3.1
RFC v4 17/21 vfio-user: secure DMA support
In reply to John JohnsonSecure DMA forces the remote process to use DMA r/w messages instead of directly mapping guest memeory.
--- hw/vfio/pci.h | 1 + hw/vfio/user.h | 1 + hw/vfio/pci.c | 4 ++++ hw/vfio/user.c | 2 +- 4 files changed, 7 insertions(+), 1 deletion(-)
hw/vfio/pci.h +1 -0
@@ -193,6 +193,7 @@ OBJECT_DECLARE_SIMPLE_TYPE(VFIOUserPCIDevice, VFIO_USER_PCI)struct VFIOUserPCIDevice {VFIOPCIDevice device;char *sock_name; +bool secure_dma;/* disable shared mem for DMA */ bool send_queued;/* all sends are queued */ bool no_post;/* all regions write are sync */ };
hw/vfio/user.h +1 -0
@@ -74,6 +74,7 @@ typedef struct VFIOProxy {/* VFIOProxy flags */ #define VFIO_PROXY_CLIENT 0x1 +#define VFIO_PROXY_SECURE 0x2#define VFIO_PROXY_FORCE_QUEUED 0x4#define VFIO_PROXY_NO_POST 0x8
hw/vfio/pci.c +4 -0
@@ -3483,6 +3483,9 @@ static void vfio_user_pci_realize(PCIDevice *pdev, Error **errp) vbasedev->proxy = proxy;vfio_user_set_handler (vbasedev, vfio_user_pci_process_req, vdev); +if (udev->secure_dma) { + proxy->flags |=VFIO_PROXY_SECURE ; + }if (udev->send_queued) { proxy->flags |=VFIO_PROXY_FORCE_QUEUED ; }
@@ -3607,6 +3610,7 @@ static void vfio_user_instance_finalize(Object *obj)static Property vfio_user_pci_dev_properties[] = {DEFINE_PROP_STRING ("socket" , VFIOUserPCIDevice, sock_name), +DEFINE_PROP_BOOL ("secure-dma" , VFIOUserPCIDevice, secure_dma, false),DEFINE_PROP_BOOL ("x-send-queued" , VFIOUserPCIDevice, send_queued, false),DEFINE_PROP_BOOL ("x-no-posted-writes" , VFIOUserPCIDevice, no_post, false),DEFINE_PROP_END_OF_LIST (),
hw/vfio/user.c +1 -1
@@ -1441,7 +1441,7 @@ static int vfio_user_io_dma_map(VFIOContainer *container, MemoryRegion *mr,* map->vaddr enters as a QEMU process address * make it either a file offset for mapped areas or 0 */ -if (fd !=-1 ) { +if (fd !=-1 && (container->proxy->flags &VFIO_PROXY_SECURE ) ==0 ) {void *addr = (void *)(uintptr_t )map->vaddr; map->vaddr =qemu_ram_block_host_offset (mr->ram_block, addr);
Signature · 1 line
1.8.3.1
RFC v4 18/21 vfio-user: dma read/write operations
In reply to John JohnsonMessages from server to client that peform device DMA.
--- hw/vfio/user-protocol.h | 11 +++++ hw/vfio/user.h | 4 ++ hw/vfio/pci.c | 105 ++++++++++++++++++++++++++++++++++++++++++++++++ hw/vfio/user.c | 60 ++++++++++++++++++++++++++- 4 files changed, 179 insertions(+), 1 deletion(-)
hw/vfio/user-protocol.h +11 -0
@@ -182,6 +182,17 @@ typedef struct {char data[]; } VFIOUserRegionRW; +/* +* VFIO_USER_DMA_READ +* VFIO_USER_DMA_WRITE +*/ +typedef struct { +VFIOUserHdr hdr; +uint64_t offset; +uint32_t count; +char data[]; +}VFIOUserDMARW ; +/*imported from struct vfio_bitmap */ typedef struct { uint64_t pgsize;
hw/vfio/user.h +4 -0
@@ -80,9 +80,13 @@ typedef struct VFIOProxy {VFIOProxy *vfio_user_connect_dev (SocketAddress *addr,Error **errp);void vfio_user_disconnect (VFIOProxy *proxy); +uint64_t vfio_user_max_xfer (void );void vfio_user_set_handler (VFIODevice *vbasedev,void (*handler)(void *opaque,VFIOUserMsg *msg),void *reqarg); +void vfio_user_send_reply (VFIOProxy *proxy,VFIOUserHdr *hdr,int size); +void vfio_user_send_error (VFIOProxy *proxy,VFIOUserHdr *hdr,int error); +void vfio_user_putfds (VFIOUserMsg *msg);int vfio_user_validate_version (VFIODevice *vbasedev,Error **errp);extern VFIODevIO vfio_dev_io_sock;
hw/vfio/pci.c +105 -0
116 lines not on this page · raw message
hw/vfio/user.c +59 -1
78 lines not on this page · raw message
Signature · 1 line
1.8.3.1
RFC v4 19/21 vfio-user: pci reset
In reply to John JohnsonMessage to tell the server to reset the device.
--- hw/vfio/user.h | 1 + hw/vfio/pci.c | 15 +++++++++++++++ hw/vfio/user.c | 12 ++++++++++++ 3 files changed, 28 insertions(+)
hw/vfio/user.h +1 -0
@@ -88,6 +88,7 @@ void vfio_user_send_reply(VFIOProxy *proxy, VFIOUserHdr *hdr, int size);void vfio_user_send_error (VFIOProxy *proxy,VFIOUserHdr *hdr,int error);void vfio_user_putfds (VFIOUserMsg *msg);int vfio_user_validate_version (VFIODevice *vbasedev,Error **errp); +void vfio_user_reset (VFIOProxy *proxy);extern VFIODevIO vfio_dev_io_sock;extern VFIOContIO vfio_cont_io_sock;
hw/vfio/pci.c +15 -0
@@ -3713,6 +3713,20 @@ static void vfio_user_instance_finalize(Object *obj) } } +static void vfio_user_pci_reset (DeviceState *dev) +{ +VFIOPCIDevice *vdev =VFIO_PCI_BASE (dev); +VFIODevice *vbasedev = &vdev->vbasedev; + +vfio_pci_pre_reset (vdev); + +if (vbasedev->reset_works) { +vfio_user_reset (vbasedev->proxy); + } + +vfio_pci_post_reset (vdev); +} +static Property vfio_user_pci_dev_properties[] = {DEFINE_PROP_STRING ("socket" , VFIOUserPCIDevice, sock_name),DEFINE_PROP_BOOL ("secure-dma" , VFIOUserPCIDevice, secure_dma, false),
@@ -3726,6 +3740,7 @@ static void vfio_user_pci_dev_class_init(ObjectClass *klass, void *data)DeviceClass *dc =DEVICE_CLASS (klass);PCIDeviceClass *pdc =PCI_DEVICE_CLASS (klass); + dc->reset = vfio_user_pci_reset;device_class_set_props (dc, vfio_user_pci_dev_properties); dc->desc ="VFIO over socket PCI device assignment" ; pdc->realize = vfio_user_pci_realize;
hw/vfio/user.c +12 -0
@@ -1398,6 +1398,18 @@ static int vfio_user_region_write(VFIOProxy *proxy, uint8_t index, off_t offset,return ret; } +void vfio_user_reset (VFIOProxy *proxy) +{ +VFIOUserHdr msg; + +vfio_user_request_msg (&msg,VFIO_USER_DEVICE_RESET ,sizeof (msg),0 ); + +vfio_user_send_wait (proxy, &msg,NULL ,0 , false); +if (msg.flags &VFIO_USER_ERROR ) { +error_printf ("reset reply error %d\n" , msg.error_reply); + } +} +/* * Socket-based io_ops
Signature · 1 line
1.8.3.1
RFC v4 20/21 vfio-user: migration support
In reply to John Johnson--- hw/vfio/user-protocol.h | 18 +++++++++++++++++ hw/vfio/migration.c | 30 +++++++++++++-------------- hw/vfio/pci.c | 7 +++++++ hw/vfio/user.c | 54 +++++++++++++++++++++++++++++++++++++++++++++++++ 4 files changed, 93 insertions(+), 16 deletions(-)
hw/vfio/user-protocol.h +18 -0
@@ -193,6 +193,10 @@ typedef struct {char data[]; } VFIOUserDMARW; +/* +* VFIO_USER_DIRTY_PAGES +*/ +/*imported from struct vfio_bitmap */ typedef struct { uint64_t pgsize;
@@ -200,4 +204,18 @@ typedef struct { char data[]; } VFIOUserBitmap; +/* imported from struct vfio_iommu_type1_dirty_bitmap_get */ +typedef struct { +uint64_t iova; +uint64_t size; +VFIOUserBitmap bitmap; +}VFIOUserBitmapRange ; + +/* imported from struct vfio_iommu_type1_dirty_bitmap */ +typedef struct { +VFIOUserHdr hdr; +uint32_t argsz; +uint32_t flags; +}VFIOUserDirtyPages ; +#endif /* VFIO_USER_PROTOCOL_H */
hw/vfio/migration.c +14 -16
@@ -27,6 +27,7 @@#include "pci.h" #include "trace.h" #include "hw/hw.h" +#include "user.h" /* * Flags to be used as unique delimiters for VFIO devices in the migration
@@ -49,11 +50,13 @@ static int64_t bytes_transferred;static inline int vfio_mig_access (VFIODevice *vbasedev,void *val,int count,off_t off,bool iswrite) { +VFIORegion *region = &vbasedev->migration->region;int ret; - ret = iswrite ?pwrite (vbasedev->fd, val, count, off) : -pread (vbasedev->fd, val, count, off); -if (ret < count) { + ret = iswrite ? +VDEV_REGION_WRITE (vbasedev, region->nr, off, count, val, false) : +VDEV_REGION_READ (vbasedev, region->nr, off, count, val); +if (ret < count) {error_report ("vfio_mig_%s %d byte %s: failed at offset 0x%" HWADDR_PRIx", err: %s" , iswrite ?"write" :"read" , count, vbasedev->name, off,strerror (errno));
@@ -111,9 +114,7 @@ static int vfio_migration_set_state(VFIODevice *vbasedev, uint32_t mask, uint32_t value) {VFIOMigration *migration = vbasedev->migration; -VFIORegion *region = &migration->region; -off_t dev_state_off = region->fd_offset + -VFIO_MIG_STRUCT_OFFSET (device_state); +off_t dev_state_off =VFIO_MIG_STRUCT_OFFSET (device_state);uint32_t device_state;int ret;
@@ -201,13 +202,13 @@ static int vfio_save_buffer(QEMUFile *f, VFIODevice *vbasedev, uint64_t *size)int ret; ret =vfio_mig_read (vbasedev, &data_offset,sizeof (data_offset), - region->fd_offset +VFIO_MIG_STRUCT_OFFSET (data_offset)); +VFIO_MIG_STRUCT_OFFSET (data_offset));if (ret <0 ) {return ret; } ret =vfio_mig_read (vbasedev, &data_size,sizeof (data_size), - region->fd_offset +VFIO_MIG_STRUCT_OFFSET (data_size)); +VFIO_MIG_STRUCT_OFFSET (data_size));if (ret <0 ) {return ret; }
@@ -233,8 +234,7 @@ static int vfio_save_buffer(QEMUFile *f, VFIODevice *vbasedev, uint64_t *size) } buf_allocated = true; - ret =vfio_mig_read (vbasedev, buf, sec_size, - region->fd_offset + data_offset); + ret =vfio_mig_read (vbasedev, buf, sec_size, data_offset);if (ret <0 ) {g_free (buf);return ret;
@@ -269,7 +269,7 @@ static int vfio_load_buffer(QEMUFile *f, VFIODevice *vbasedev, do { ret = vfio_mig_read(vbasedev, &data_offset, sizeof(data_offset), - region->fd_offset + VFIO_MIG_STRUCT_OFFSET(data_offset)); + VFIO_MIG_STRUCT_OFFSET(data_offset)); if (ret < 0) { return ret; }
@@ -309,8 +309,7 @@ static int vfio_load_buffer(QEMUFile *f, VFIODevice *vbasedev,qemu_get_buffer (f, buf, sec_size);if (buf_alloc) { - ret =vfio_mig_write (vbasedev, buf, sec_size, - region->fd_offset + data_offset); + ret =vfio_mig_write (vbasedev, buf, sec_size, data_offset);g_free (buf);if (ret <0 ) {
@@ -322,7 +321,7 @@ static int vfio_load_buffer(QEMUFile *f, VFIODevice *vbasedev, } ret =vfio_mig_write (vbasedev, &report_size,sizeof (report_size), - region->fd_offset +VFIO_MIG_STRUCT_OFFSET (data_size)); +VFIO_MIG_STRUCT_OFFSET (data_size));if (ret <0 ) {return ret; }
@@ -334,12 +333,11 @@ static int vfio_load_buffer(QEMUFile *f, VFIODevice *vbasedev,static int vfio_update_pending (VFIODevice *vbasedev) {VFIOMigration *migration = vbasedev->migration; -VFIORegion *region = &migration->region;uint64_t pending_bytes =0 ;int ret; ret =vfio_mig_read (vbasedev, &pending_bytes,sizeof (pending_bytes), - region->fd_offset +VFIO_MIG_STRUCT_OFFSET (pending_bytes)); +VFIO_MIG_STRUCT_OFFSET (pending_bytes));if (ret <0 ) { migration->pending_bytes =0 ;return ret;
hw/vfio/pci.c +7 -0
@@ -3677,6 +3677,13 @@ static void vfio_user_pci_realize(PCIDevice *pdev, Error **errp) goto out_teardown; } +if (!pdev->failover_pair_id) { + ret =vfio_migration_probe (&vdev->vbasedev, errp); +if (ret) { +error_report ("%s: Migration disabled" , vdev->vbasedev.name); + } + } +vfio_register_err_notifier (vdev);vfio_register_req_notifier (vdev);
hw/vfio/user.c +54 -0
71 lines not on this page · raw message
Signature · 1 line
1.8.3.1
RE: [RFC v4 20/21] vfio-user: migration support
Quoted 225 lines
-----Original Message-----
From: Qemu-devel <qemu-devel- [email protected]> On Behalf Of John Johnson
Sent: 12 January 2022 00:44
To: [email protected]
Subject: [RFC v4 20/21] vfio-user: migration supportSigned-off-by John G Johnson <[email protected]>Signed-off-by Elena Ufimtseva <[email protected]>Signed-off-by Jagannathan Raman <[email protected]>--- hw/vfio/user-protocol.h | 18 +++++++++++++++++ hw/vfio/migration.c | 30 +++++++++++++-------------- hw/vfio/pci.c | 7 +++++++ hw/vfio/user.c | 54 +++++++++++++++++++++++++++++++++++++++++++++++++ 4 files changed, 93 insertions(+), 16 deletions(-)hw/vfio/user-protocol.h +18
-0@@ -193,6 +193,10 @@ typedef struct {char data[]; } VFIOUserDMARW; +/* +* VFIO_USER_DIRTY_PAGES +*/ +/*imported from struct vfio_bitmap */ typedef struct { uint64_t pgsize;@@ -200,4 +204,18 @@ typedef struct { char data[]; } VFIOUserBitmap; +/* imported from struct vfio_iommu_type1_dirty_bitmap_get */ +typedef struct { +uint64_t iova; +uint64_t size; +VFIOUserBitmap bitmap; +}VFIOUserBitmapRange ; + +/* imported from struct vfio_iommu_type1_dirty_bitmap */ +typedef struct { +VFIOUserHdr hdr; +uint32_t argsz; +uint32_t flags; +}VFIOUserDirtyPages ; +#endif /* VFIO_USER_PROTOCOL_H */ hw/vfio/migration.c +9
-8@@ -27,6 +27,7 @@#include "pci.h" #include "trace.h" #include "hw/hw.h" +#include "user.h" /* * Flags to be used as unique delimiters for VFIO devices in the migration @@ -49,11 +50,13 @@ static int64_t bytes_transferred;static inline int vfio_mig_access (VFIODevice *vbasedev,void *val,int count,off_t off,bool iswrite) { +VFIORegion *region = &vbasedev->migration->region;int ret; - ret = iswrite ?pwrite (vbasedev->fd, val, count, off) : -pread (vbasedev->fd, val, count, off); -if (ret < count) { + ret = iswrite ? +VDEV_REGION_WRITE (vbasedev, region->nr, off, count, val, false) : +VDEV_REGION_READ (vbasedev, region->nr, off, count, val); +if (ret < count) {error_report ("vfio_mig_%s %d byte %s: failed at offset 0x%" HWADDR_PRIx", err: %s" , iswrite ?"write" :"read" , count, vbasedev->name, off,strerror (errno));@@ -111,9 +114,7 @@ static int vfio_migration_set_state(VFIODevice *vbasedev, uint32_t mask, uint32_t value) {VFIOMigration *migration = vbasedev->migration; -VFIORegion *region = &migration->region; -off_t dev_state_off = region->fd_offset + -VFIO_MIG_STRUCT_OFFSET (device_state); +off_t dev_state_off =VFIO_MIG_STRUCT_OFFSET (device_state);uint32_t device_state;int ret;@@ -201,13 +202,13 @@ static int vfio_save_buffer(QEMUFile *f, VFIODevice *vbasedev, uint64_t *size)int ret; ret =vfio_mig_read (vbasedev, &data_offset,sizeof (data_offset), - region->fd_offset +VFIO_MIG_STRUCT_OFFSET (data_offset)); +VFIO_MIG_STRUCT_OFFSET (data_offset));if (ret <0 ) {return ret; } ret =vfio_mig_read (vbasedev, &data_size,sizeof (data_size), - region->fd_offset +VFIO_MIG_STRUCT_OFFSET (data_size)); +VFIO_MIG_STRUCT_OFFSET (data_size));if (ret <0 ) {return ret;}hw/vfio/migration.c +1
-2@@ -233,8 +234,7 @@ static int vfio_save_buffer(QEMUFile *f, VFIODevice *vbasedev, uint64_t *size) } buf_allocated = true; - ret =vfio_mig_read (vbasedev, buf, sec_size, - region->fd_offset + data_offset); + ret =vfio_mig_read (vbasedev, buf, sec_size, data_offset);if (ret <0 ) {g_free (buf);return ret;hw/vfio/migration.c +1
-1@@ -269,7 +269,7 @@ static int vfio_load_buffer(QEMUFile *f, VFIODevice *vbasedev, do { ret =vfio_mig_read (vbasedev, &data_offset,sizeof (data_offset), - region->fd_offset +VFIO_MIG_STRUCT_OFFSET (data_offset)); +VFIO_MIG_STRUCT_OFFSET (data_offset));if (ret <0 ) {return ret;}hw/vfio/migration.c +1
-2@@ -309,8 +309,7 @@ static int vfio_load_buffer(QEMUFile *f, VFIODevice *vbasedev,qemu_get_buffer (f, buf, sec_size);if (buf_alloc) { - ret =vfio_mig_write (vbasedev, buf, sec_size, - region->fd_offset + data_offset); + ret =vfio_mig_write (vbasedev, buf, sec_size, data_offset);g_free (buf);if (ret < 0) {hw/vfio/migration.c +1
-1@@ -322,7 +321,7 @@ static int vfio_load_buffer(QEMUFile *f, VFIODevice *vbasedev, } ret =vfio_mig_write (vbasedev, &report_size,sizeof (report_size), - region->fd_offset +VFIO_MIG_STRUCT_OFFSET (data_size)); +VFIO_MIG_STRUCT_OFFSET (data_size));if (ret <0 ) {return ret;}hw/vfio/migration.c +1
-2@@ -334,12 +333,11 @@ static int vfio_load_buffer(QEMUFile *f, VFIODevice *vbasedev, static int vfio_update_pending(VFIODevice *vbasedev) {VFIOMigration *migration = vbasedev->migration; -VFIORegion *region = &migration->region;uint64_t pending_bytes =0 ;int ret; ret =vfio_mig_read (vbasedev, &pending_bytes,sizeof (pending_bytes), - region->fd_offset +VFIO_MIG_STRUCT_OFFSET (pending_bytes)); +VFIO_MIG_STRUCT_OFFSET (pending_bytes));if (ret <0 ) { migration->pending_bytes =0 ;return ret;hw/vfio/pci.c +7
-0@@ -3677,6 +3677,13 @@ static void vfio_user_pci_realize(PCIDevice *pdev, Error **errp) goto out_teardown; } +if (!pdev->failover_pair_id) { + ret =vfio_migration_probe (&vdev->vbasedev, errp); +if (ret) { +error_report ("%s: Migration disabled" , vdev->vbasedev.name); + } + } +vfio_register_err_notifier (vdev);vfio_register_req_notifier (vdev);hw/vfio/user.c +28
-0@@ -1410,6 +1410,52 @@ void vfio_user_reset(VFIOProxy *proxy) } } +static int vfio_user_dirty_bitmap (VFIOProxy *proxy, +struct vfio_iommu_type1_dirty_bitmap *cmd, +struct vfio_iommu_type1_dirty_bitmap_get + *dbitmap) +{ +g_autofree struct { +VFIOUserDirtyPages msg; +VFIOUserBitmapRange range; + } *msgp =NULL ; +int msize, rsize; + +/* +* If just the command is sent, the returned bitmap isn't needed. +* The bitmap structs are different from the ioctl() versions, +* ioctl() returns the bitmap in a local VA +*/ +if (dbitmap !=NULL ) { + msize =sizeof (*msgp); + rsize = msize + dbitmap->bitmap.size; + msgp =g_malloc0 (rsize); + msgp->range.iova = dbitmap->iova; + msgp->range.size = dbitmap->size; + msgp->range.bitmap.pgsize = dbitmap->bitmap.pgsize; + msgp->range.bitmap.size = dbitmap->bitmap.size; + }else { + msize = rsize =sizeof (VFIOUserDirtyPages); + msgp =g_malloc0 (rsize); + }
hw/vfio/user.c void vfio_user_reset(VFIOProxy *proxy) · line 1450
Quoted 10 lines
hw/vfio/user.c +9
-0+ +vfio_user_request_msg (&msgp->msg.hdr,VFIO_USER_DIRTY_PAGES , msize,0 ); + msgp->msg.argsz = rsize -sizeof (VFIOUserHdr); + msgp->msg.flags = cmd->flags; + +vfio_user_send_wait (proxy, &msgp->msg.hdr,NULL , rsize, false); +if (msgp->msg.hdr.flags &VFIO_USER_ERROR ) { +return -msgp->msg.hdr.error_reply; + }
We need to check argsz in the response, in which case the client needs to retry with a larger argsz.
Quoted 38 lines
hw/vfio/user.c +9
-0+ +if (dbitmap !=NULL ) { +memcpy (dbitmap->bitmap.data, &msgp->range.bitmap.data, + dbitmap->bitmap.size); + } + +return 0 ; +} +/* * Socket-based
io_opshw/vfio/user.c +7
-0@@ -1530,6 +1576,13 @@ static int vfio_user_io_dma_unmap(VFIOContainer *container, container->async_ops); } +static int vfio_user_io_dirty_bitmap (VFIOContainer *container, +struct vfio_iommu_type1_dirty_bitmap *bitmap, +struct vfio_iommu_type1_dirty_bitmap_get *range) +{ +return vfio_user_dirty_bitmap (container->proxy, bitmap, range); +} +static void vfio_user_io_wait_commit (VFIOContainer *container) {vfio_user_wait_reqs(container->proxy);hw/vfio/user.c +1
-0@@ -1538,5 +1591,6 @@ static void vfio_user_io_wait_commit(VFIOContainer *container)VFIOContIO vfio_cont_io_sock = { .dma_map = vfio_user_io_dma_map, .dma_unmap = vfio_user_io_dma_unmap, + .dirty_bitmap = vfio_user_io_dirty_bitmap, .wait_commit = vfio_user_io_wait_commit,};
--
1.8.3.1
Re: [RFC v4 20/21] vfio-user: migration support
Quoted 46 lines · Thanos Makatos
Quoted 43 lines
-----Original Message-----
From: Qemu-devel <qemu-devel- [email protected]> On Behalf Of John Johnson
Sent: 12 January 2022 00:44
To: [email protected]
Subject: [RFC v4 20/21] vfio-user: migration supporthw/vfio/user.c +30
-0+static int vfio_user_dirty_bitmap (VFIOProxy *proxy, +struct vfio_iommu_type1_dirty_bitmap *cmd, +struct vfio_iommu_type1_dirty_bitmap_get + *dbitmap) +{ +g_autofree struct { +VFIOUserDirtyPages msg; +VFIOUserBitmapRange range; + } *msgp =NULL ; +int msize, rsize; + +/* +* If just the command is sent, the returned bitmap isn't needed. +* The bitmap structs are different from the ioctl() versions, +* ioctl() returns the bitmap in a local VA +*/ +if (dbitmap !=NULL ) { + msize =sizeof (*msgp); + rsize = msize + dbitmap->bitmap.size; + msgp =g_malloc0 (rsize); + msgp->range.iova = dbitmap->iova; + msgp->range.size = dbitmap->size; + msgp->range.bitmap.pgsize = dbitmap->bitmap.pgsize; + msgp->range.bitmap.size = dbitmap->bitmap.size; + }else { + msize = rsize =sizeof (VFIOUserDirtyPages); + msgp =g_malloc0 (rsize); + } + + vfio_user_request_msg(&msgp->msg.hdr, VFIO_USER_DIRTY_PAGES, msize,0);
+msgp->msg.argsz= rsize - sizeof(VFIOUserHdr);
Quoted 9 lines
hw/vfio/user.c void vfio_user_reset(VFIOProxy *proxy) · line 1449
Quoted 6 lines
hw/vfio/user.c +6
-0+ msgp->msg.flags = cmd->flags; + +vfio_user_send_wait (proxy, &msgp->msg.hdr,NULL , rsize, false); +if (msgp->msg.hdr.flags &VFIO_USER_ERROR ) { +return -msgp->msg.hdr.error_reply; + }We need to check argsz in the response, in which case the client needs to retry with a larger argsz.
The client needs to retry if the server reply can be larger than the client
expects, such as GET_REGION_INFO, where the client doesn’t know how many capabilities will be returned a priori.
In this case, argsz is derived from dbitmap->bitmap.size, which was set in
vfio_get_dirty_bitmap() to be large enough to cover the entire range:
pages = REAL_HOST_PAGE_ALIGN(range->size) / qemu_real_host_page_size; range->bitmap.size = ROUND_UP(pages, sizeof(__u64) * BITS_PER_BYTE) /
BITS_PER_BYTE;
so I’m not sure we’d ever see a case where the reply is larger than expected.
JJ
Quoted 10 lines
Quoted 10 lines
hw/vfio/user.c +9
-0+ +if (dbitmap !=NULL ) { +memcpy (dbitmap->bitmap.data, &msgp->range.bitmap.data, + dbitmap->bitmap.size); + } + +return 0 ; +} +
RE: [RFC v4 20/21] vfio-user: migration support
Quoted 72 lines
-----Original Message-----
From: John Johnson <[email protected]>
Sent: 14 February 2022 18:50
To: Thanos Makatos <[email protected]>
Cc: [email protected]
Subject: Re: [RFC v4 20/21] vfio-user: migration supportQuoted 1 line
On Feb 11, 2022, at 5:31 AM, Thanos Makatos
Quoted 33 lines · <[email protected]> wrote:
Quoted 33 lines
-----Original Message-----
From: Qemu-devel <qemu-devel- [email protected]> On Behalf Of John Johnson
Sent: 12 January 2022 00:44
To: [email protected]
Subject: [RFC v4 20/21] vfio-user: migration supporthw/vfio/user.c +22
-0+static int vfio_user_dirty_bitmap (VFIOProxy *proxy, +struct vfio_iommu_type1_dirty_bitmap *cmd, +struct vfio_iommu_type1_dirty_bitmap_get + *dbitmap) +{ +g_autofree struct { +VFIOUserDirtyPages msg; +VFIOUserBitmapRange range; + } *msgp =NULL ; +int msize, rsize; + +/* +* If just the command is sent, the returned bitmap isn't needed. +* The bitmap structs are different from the ioctl() versions, +* ioctl() returns the bitmap in a local VA +*/ +if (dbitmap !=NULL ) { + msize =sizeof (*msgp); + rsize = msize + dbitmap->bitmap.size; + msgp =g_malloc0 (rsize); + msgp->range.iova = dbitmap->iova; + msgp->range.size = dbitmap->size;Quoted 8 lines
hw/vfio/user.c void vfio_user_reset(VFIOProxy *proxy)
Quoted 8 lines
hw/vfio/user.c +8
-0+ msgp->range.bitmap.pgsize = dbitmap->bitmap.pgsize; + msgp->range.bitmap.size = dbitmap->bitmap.size; + }else { + msize = rsize =sizeof (VFIOUserDirtyPages); + msgp =g_malloc0 (rsize); + } + + vfio_user_request_msg(&msgp->msg.hdr, VFIO_USER_DIRTY_PAGES,msize,
Quoted 10 lines
hw/vfio/user.c void vfio_user_reset(VFIOProxy *proxy) · line 1449
Quoted 8 lines
0);
hw/vfio/user.c +7
-0+ msgp->msg.argsz = rsize -sizeof (VFIOUserHdr); + msgp->msg.flags = cmd->flags; + +vfio_user_send_wait (proxy, &msgp->msg.hdr,NULL , rsize, false); +if (msgp->msg.hdr.flags &VFIO_USER_ERROR ) { +return -msgp->msg.hdr.error_reply; + }We need to check argsz in the response, in which case the client needs to retry
with a larger argsz.
Quoted 1 line
The client needs to retry if the server reply can be larger than the client
expects, such asGET_REGION_INFO, where the client doesn’t know how many capabilities
will be returned a priori.In this case, argsz is derived from dbitmap->bitmap.size, which was set
Quoted 8 lines
in
vfio_get_dirty_bitmap()to be large enough to cover the entire range:pages =
REAL_HOST_PAGE_ALIGN(range->size)/qemu_real_host_page_size;range->bitmap.size=ROUND_UP(pages, sizeof(__u64) * BITS_PER_BYTE)/BITS_PER_BYTE;so I’m not sure we’d ever see a case where the reply is larger than expected.
The client is doing the right thing, and most likely at this stage a different argsz would mean a server bug. I did actually run into this case because of a server bug, should we at least check and report and error if it's not what we expect?
RFC v4 21/21 Only set qemu file error if saving state so the file exists
In reply to John Johnson--- hw/vfio/migration.c | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-)
hw/vfio/migration.c +3 -1
@@ -742,7 +742,9 @@ static void vfio_vmstate_change(void *opaque, bool running, RunState state)*/ error_report ("%s: Failed to set device state 0x%x" , vbasedev->name, (migration->device_state & mask) | value); -qemu_file_set_error (migrate_get_current ()->to_dst_file, ret); +if (value !=0 ) { +qemu_file_set_error (migrate_get_current ()->to_dst_file, ret); + } } vbasedev->migration->vm_running = running; trace_vfio_vmstate_change(vbasedev->name, running, RunState_str(state),
Signature · 1 line
1.8.3.1