* [PATCH v1 00/24] vfio-user client
@ 2022-11-08 23:13 John Johnson
2022-11-08 23:13 ` [PATCH v1 01/24] vfio-user: introduce vfio-user protocol specification John Johnson
` (25 more replies)
0 siblings, 26 replies; 82+ messages in thread
From: John Johnson @ 2022-11-08 23:13 UTC (permalink / raw)
To: qemu-devel
Hello,
This is the 6th revision of the vfio-user client implementation.
It is the first patch series (the previous revisions were RFCs)
First of all, thank you for your time reviewing the RFC 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 upstreamed a patch series that implement a server using QEMU.
Contributors:
John G Johnson <john.g.johnson@oracle.com>
John Levon <john.levon@nutanix.com>
Thanos Makatos <thanos.makatos@nutanix.com>
Elena Ufimtseva <elena.ufimtseva@oracle.com>
Jagannathan Raman <jag.raman@oracle.com>
John Johnson (23):
vfio-user: add VFIO base abstract class
vfio-user: add container IO ops vector
vfio-user: add region cache
vfio-user: add device IO ops vector
vfio-user: Define type vfio_user_pci_dev_info
vfio-user: connect vfio proxy to remote server
vfio-user: define socket receive functions
vfio-user: define socket send functions
vfio-user: get device info
vfio-user: get region info
vfio-user: region read/write
vfio-user: pci_user_realize PCI setup
vfio-user: get and set IRQs
vfio-user: forward msix BAR accesses to server
vfio-user: proxy container connect/disconnect
vfio-user: dma map/unmap operations
vfio-user: add dma_unmap_all
vfio-user: secure DMA support
vfio-user: dma read/write operations
vfio-user: pci reset
vfio-user: add 'x-msg-timeout' option that specifies msg wait times
vfio-user: add coalesced posted writes
vfio-user: add trace points
Thanos Makatos (1):
vfio-user: introduce vfio-user protocol specification
MAINTAINERS | 11 +
docs/devel/index-internals.rst | 1 +
docs/devel/vfio-user.rst | 1522 ++++++++++++++++++++++++++++++++
hw/vfio/Kconfig | 10 +
hw/vfio/ap.c | 1 +
hw/vfio/ccw.c | 7 +-
hw/vfio/common.c | 648 ++++++++++++--
hw/vfio/igd.c | 23 +-
hw/vfio/meson.build | 1 +
hw/vfio/migration.c | 2 -
hw/vfio/pci-quirks.c | 19 +-
hw/vfio/pci.c | 926 ++++++++++++++-----
hw/vfio/pci.h | 29 +-
hw/vfio/platform.c | 2 +
hw/vfio/trace-events | 15 +
hw/vfio/user-protocol.h | 244 +++++
hw/vfio/user.c | 1904 ++++++++++++++++++++++++++++++++++++++++
hw/vfio/user.h | 112 +++
include/hw/vfio/vfio-common.h | 82 ++
19 files changed, 5230 insertions(+), 329 deletions(-)
create mode 100644 docs/devel/vfio-user.rst
create mode 100644 hw/vfio/user-protocol.h
create mode 100644 hw/vfio/user.c
create mode 100644 hw/vfio/user.h
--
1.8.3.1
^ permalink raw reply [flat|nested] 82+ messages in thread
* [PATCH v1 01/24] vfio-user: introduce vfio-user protocol specification
2022-11-08 23:13 [PATCH v1 00/24] vfio-user client John Johnson
@ 2022-11-08 23:13 ` John Johnson
2022-11-08 23:13 ` [PATCH v1 02/24] vfio-user: add VFIO base abstract class John Johnson
` (24 subsequent siblings)
25 siblings, 0 replies; 82+ messages in thread
From: John Johnson @ 2022-11-08 23:13 UTC (permalink / raw)
To: qemu-devel
From: Thanos Makatos <thanos.makatos@nutanix.com>
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 <john.g.johnson@oracle.com>
Signed-off-by: Thanos Makatos <thanos.makatos@nutanix.com>
Signed-off-by: John Levon <john.levon@nutanix.com>
---
MAINTAINERS | 6 +
docs/devel/index-internals.rst | 1 +
docs/devel/vfio-user.rst | 1522 ++++++++++++++++++++++++++++++++++++++++
3 files changed, 1529 insertions(+)
create mode 100644 docs/devel/vfio-user.rst
diff --git a/MAINTAINERS b/MAINTAINERS
index 738c4eb..999340d 100644
--- a/MAINTAINERS
+++ b/MAINTAINERS
@@ -1984,6 +1984,12 @@ F: hw/vfio/ap.c
F: docs/system/s390x/vfio-ap.rst
L: qemu-s390x@nongnu.org
+vfio-user
+M: John G Johnson <john.g.johnson@oracle.com>
+M: Thanos Makatos <thanos.makatos@nutanix.com>
+S: Supported
+F: docs/devel/vfio-user.rst
+
vhost
M: Michael S. Tsirkin <mst@redhat.com>
S: Supported
diff --git a/docs/devel/index-internals.rst b/docs/devel/index-internals.rst
index e1a93df..0ecb5c6 100644
--- a/docs/devel/index-internals.rst
+++ b/docs/devel/index-internals.rst
@@ -17,5 +17,6 @@ Details about QEMU's various subsystems including how to add features to them.
s390-dasd-ipl
tracing
vfio-migration
+ vfio-user
writing-monitor-commands
virtio-backends
diff --git a/docs/devel/vfio-user.rst b/docs/devel/vfio-user.rst
new file mode 100644
index 0000000..0d96477
--- /dev/null
+++ b/docs/devel/vfio-user.rst
@@ -0,0 +1,1522 @@
+.. 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://www.kernel.org/doc/html/latest/driver-api/vfio.html>`_.
+
+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
+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 we do
+not examine such alternatives. In this protocol version we focus on using a UNIX
+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 passed through
+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 an API
+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-based VFIO
+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
+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 to share as
+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 capabilities to
+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 the server for
+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 query the
+server for information about the device's regions. This information describes:
+
+* Read and write permissions, whether it can be memory mapped, and whether it
+ 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``
+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
+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 or ioregionfds
+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
+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 the server
+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 device region,
+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 on
+write operations. See `Read and Write Operations`_.
+
+Client memory access
+--------------------
+
+The client uses ``VFIO_USER_DMA_MAP`` and ``VFIO_USER_DMA_UNMAP`` messages to
+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 by the
+server via ``VFIO_USER_DMA_READ`` and ``VFIO_USER_DMA_WRITE`` messages over the
+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 previous command
+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 command will
+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 indeterminate behavior
+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 handle such
+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 server should
+respond to a client disconnection as follows:
+
+ - all client memory regions are unmapped and cleaned up (including closing any
+ 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 input and
+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 by the
+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 data that
+may be read or written via one of the ``VFIO_USER_DMA/REGION_READ/WRITE``
+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_REGION_WRITE_MULTI`` 15 client -> server
+====================================== ========= =================
+
+Header
+------
+
+All messages, both command messages and reply messages, are preceded by a
+16-byte header that contains basic information about the message. The header is
+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_. It is
+ 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, and only
+ 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 reply message,
+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 of the
+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 protocol changes
+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,
+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 the following
+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. |
++--------------------+---------+------------------------------------------------+
+| pgsizes | number | Page sizes supported in DMA map operations |
+| | | or'ed together. Optional, with a default value |
+| | | of supporting only 4k pages. |
++--------------------+---------+------------------------------------------------+
+| max_dma_maps | number | Maximum number DMA map windows that can be |
+| | | valid simultaneously. Optional, with a |
+| | | value of 65535 (64k-1). |
++--------------------+---------+------------------------------------------------+
+| migration | object | Migration capability parameters. If missing |
+| | | then migration is not supported by the sender. |
++--------------------+---------+------------------------------------------------+
+| write_multiple | boolean | ``VFIO_USER_REGION_WRITE_MULTI`` messages |
+| | | are supported if the value is ``true``. |
++--------------------+---------+------------------------------------------------+
+
+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. |
++-----------------+--------+--------------------------------------------------+
+| max_bitmap_size | number | Maximum bitmap size in ``VFIO_USER_DIRTY_PAGES`` |
+| | | and ``VFIO_DMA_UNMAP`` messages. Optional, |
+| | | with a default value of 256MB. |
++-----------------+--------+--------------------------------------------------+
+
+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 the client,
+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,
+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
+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 |
++--------------+--------+------------------------+
+| address | 8 | 8 |
++--------------+--------+------------------------+
+| size | 16 | 8 |
++--------------+--------+------------------------+
+
+* *argsz* is the maximum size of the reply payload.
+* *flags* is unused in this version.
+* *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.
+
+Reply
+^^^^^
+
+Upon receiving a ``VFIO_USER_DMA_UNMAP`` command, if the file descriptor is
+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.
+
+
+``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 the region.
+ * ``VFIO_REGION_INFO_FLAG_MMAP`` specifies the client can mmap() the region.
+ 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 in the
+ 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 | 8 |
++----------+--------+------+
+| ... | | |
++----------+--------+------+
+
+* *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_USER_DEVICE_GET_REGION_IO_FDS``
+--------------------------------------
+
+Clients can access regions via ``VFIO_USER_REGION_READ/WRITE`` or, if provided, by
+``mmap()`` of a file descriptor provided by the server.
+
+``VFIO_USER_DEVICE_GET_REGION_IO_FDS`` provides an alternative access mechanism via
+file descriptors. This is an optional feature intended for performance
+improvements where an underlying sub-system (such as KVM) supports communication
+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
+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://www.kernel.org/doc/Documentation/virtual/kvm/api.txt, *4.59
+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``
+ 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 on the
+ file descriptor
+
+For further information on the ioregionfd-specific fields, see:
+https://lore.kernel.org/kvm/cover.1613828726.git.eafanasova@gmail.com/
+
+(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``)
+* 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 server eventfd
+ signalling.
+ * ``VFIO_IRQ_INFO_MASKABLE`` indicates that the IRQ type supports the ``MASK``
+ and ``UNMASK`` actions in a ``VFIO_USER_DEVICE_SET_IRQS`` message.
+ * ``VFIO_IRQ_INFO_AUTOMASKED`` indicates the IRQ type masks itself after being
+ triggered, and the client must send an ``UNMASK`` action to receive new
+ interrupts.
+ * ``VFIO_IRQ_INFO_NORESIZE`` indicates ``VFIO_USER_SET_IRQS`` operations setup
+ 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 the command.
+ The action is performed unconditionally.
+ * ``VFIO_IRQ_SET_DATA_BOOL`` indicates the data field is an array of boolean
+ bytes. The action is performed if the corresponding boolean is true.
+ * ``VFIO_IRQ_SET_DATA_EVENTFD`` indicates an array of event file descriptors
+ 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 used with
+ ``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 masks
+ the interrupt.
+ * ``VFIO_IRQ_SET_ACTION_UNMASK`` indicates an unmasking event. It can be used
+ 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 the
+ guest unmasks the interrupt.
+ * ``VFIO_IRQ_SET_ACTION_TRIGGER`` indicates a triggering event. It can be used
+ 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 the
+ 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
+ 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 of booleans
+ 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
+ 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/UNMASK)`` along
+ 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)``.
+
+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/UNMASK)``.
+
+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/or server,
+even if the corresponding memory or device region has been shared as mappable.
+
+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 message to
+read from guest memory.
+
+Request
+^^^^^^^
+
++---------+--------+----------+
+| Name | Offset | Size |
++=========+========+==========+
+| address | 0 | 8 |
++---------+--------+----------+
+| count | 8 | 8 |
++---------+--------+----------+
+
+* *address* is the client DMA memory address being accessed. This address must have
+ been previously exported to the server with a ``VFIO_USER_DMA_MAP`` message.
+* *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 message to
+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 address must have
+ been previously exported to the server with a ``VFIO_USER_DMA_MAP`` message.
+* *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_REGION_WRITE_MULTI``
+--------------------------------
+
+This message can be used to coalesce multiple device write operations
+into a single messgage. It is only used as an optimization when the
+outgoing message queue is relatively full.
+
+Request
+^^^^^^^
+
++---------+--------+----------+
+| Name | Offset | Size |
++=========+========+==========+
+| wr_cnt | 0 | 8 |
++---------+--------+----------+
+| wrs | 8 | variable |
++---------+--------+----------+
+
+* *wr_cnt* is the number of device writes coalesced in the message
+* *wrs* is an array of device writes defined below
+
+Single Device Write Format
+""""""""""""""""""""""""""
+
++--------+--------+----------+
+| Name | Offset | Size |
++========+========+==========+
+| offset | 0 | 8 |
++--------+--------+----------+
+| region | 8 | 4 |
++--------+--------+----------+
+| count | 12 | 4 |
++--------+--------+----------+
+| data | 16 | 8 |
++--------+--------+----------+
+
+* *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. This format can
+ only describe writes of 8 bytes or less.
+* *data* is the data to write.
+
+Reply
+^^^^^
+
++---------+--------+----------+
+| Name | Offset | Size |
++=========+========+==========+
+| wr_cnt | 0 | 8 |
++---------+--------+----------+
+
+* *wr_cnt* is the number of device writes completed.
+
+
+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 has on the
+ 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.
--
1.8.3.1
^ permalink raw reply related [flat|nested] 82+ messages in thread
* [PATCH v1 02/24] vfio-user: add VFIO base abstract class
2022-11-08 23:13 [PATCH v1 00/24] vfio-user client John Johnson
2022-11-08 23:13 ` [PATCH v1 01/24] vfio-user: introduce vfio-user protocol specification John Johnson
@ 2022-11-08 23:13 ` John Johnson
2022-12-09 13:54 ` John Levon
2022-12-09 16:04 ` Cédric Le Goater
2022-11-08 23:13 ` [PATCH v1 03/24] vfio-user: add container IO ops vector John Johnson
` (23 subsequent siblings)
25 siblings, 2 replies; 82+ messages in thread
From: John Johnson @ 2022-11-08 23:13 UTC (permalink / raw)
To: qemu-devel
Add an abstract base class both the kernel driver
and user socket implementations can use to share code.
Signed-off-by: John G Johnson <john.g.johnson@oracle.com>
Signed-off-by: Elena Ufimtseva <elena.ufimtseva@oracle.com>
Signed-off-by: Jagannathan Raman <jag.raman@oracle.com>
---
hw/vfio/pci.c | 106 +++++++++++++++++++++++++++++++++++-----------------------
hw/vfio/pci.h | 16 +++++++--
2 files changed, 78 insertions(+), 44 deletions(-)
diff --git a/hw/vfio/pci.c b/hw/vfio/pci.c
index 939dcc3..60acde5 100644
--- a/hw/vfio/pci.c
+++ b/hw/vfio/pci.c
@@ -235,7 +235,7 @@ static void vfio_intx_update(VFIOPCIDevice *vdev, PCIINTxRoute *route)
static void vfio_intx_routing_notifier(PCIDevice *pdev)
{
- VFIOPCIDevice *vdev = VFIO_PCI(pdev);
+ VFIOPCIDevice *vdev = VFIO_PCI_BASE(pdev);
PCIINTxRoute route;
if (vdev->interrupt != VFIO_INT_INTx) {
@@ -467,7 +467,7 @@ static void vfio_update_kvm_msi_virq(VFIOMSIVector *vector, MSIMessage msg,
static int vfio_msix_vector_do_use(PCIDevice *pdev, unsigned int nr,
MSIMessage *msg, IOHandler *handler)
{
- VFIOPCIDevice *vdev = VFIO_PCI(pdev);
+ VFIOPCIDevice *vdev = VFIO_PCI_BASE(pdev);
VFIOMSIVector *vector;
int ret;
@@ -561,7 +561,7 @@ static int vfio_msix_vector_use(PCIDevice *pdev,
static void vfio_msix_vector_release(PCIDevice *pdev, unsigned int nr)
{
- VFIOPCIDevice *vdev = VFIO_PCI(pdev);
+ VFIOPCIDevice *vdev = VFIO_PCI_BASE(pdev);
VFIOMSIVector *vector = &vdev->msi_vectors[nr];
trace_vfio_msix_vector_release(vdev->vbasedev.name, nr);
@@ -1109,7 +1109,7 @@ static const MemoryRegionOps vfio_vga_ops = {
*/
static void vfio_sub_page_bar_update_mapping(PCIDevice *pdev, int bar)
{
- VFIOPCIDevice *vdev = VFIO_PCI(pdev);
+ VFIOPCIDevice *vdev = VFIO_PCI_BASE(pdev);
VFIORegion *region = &vdev->bars[bar].region;
MemoryRegion *mmap_mr, *region_mr, *base_mr;
PCIIORegion *r;
@@ -1155,7 +1155,7 @@ static void vfio_sub_page_bar_update_mapping(PCIDevice *pdev, int bar)
*/
uint32_t vfio_pci_read_config(PCIDevice *pdev, uint32_t addr, int len)
{
- VFIOPCIDevice *vdev = VFIO_PCI(pdev);
+ VFIOPCIDevice *vdev = VFIO_PCI_BASE(pdev);
uint32_t emu_bits = 0, emu_val = 0, phys_val = 0, val;
memcpy(&emu_bits, vdev->emulated_config_bits + addr, len);
@@ -1188,7 +1188,7 @@ uint32_t vfio_pci_read_config(PCIDevice *pdev, uint32_t addr, int len)
void vfio_pci_write_config(PCIDevice *pdev,
uint32_t addr, uint32_t val, int len)
{
- VFIOPCIDevice *vdev = VFIO_PCI(pdev);
+ VFIOPCIDevice *vdev = VFIO_PCI_BASE(pdev);
uint32_t val_le = cpu_to_le32(val);
trace_vfio_pci_write_config(vdev->vbasedev.name, addr, val, len);
@@ -2845,7 +2845,7 @@ static void vfio_unregister_req_notifier(VFIOPCIDevice *vdev)
static void vfio_realize(PCIDevice *pdev, Error **errp)
{
- VFIOPCIDevice *vdev = VFIO_PCI(pdev);
+ VFIOPCIDevice *vdev = VFIO_PCI_BASE(pdev);
VFIODevice *vbasedev = &vdev->vbasedev;
VFIODevice *vbasedev_iter;
VFIOGroup *group;
@@ -3169,7 +3169,7 @@ error:
static void vfio_instance_finalize(Object *obj)
{
- VFIOPCIDevice *vdev = VFIO_PCI(obj);
+ VFIOPCIDevice *vdev = VFIO_PCI_BASE(obj);
VFIOGroup *group = vdev->vbasedev.group;
vfio_display_finalize(vdev);
@@ -3189,7 +3189,7 @@ static void vfio_instance_finalize(Object *obj)
static void vfio_exitfn(PCIDevice *pdev)
{
- VFIOPCIDevice *vdev = VFIO_PCI(pdev);
+ VFIOPCIDevice *vdev = VFIO_PCI_BASE(pdev);
vfio_unregister_req_notifier(vdev);
vfio_unregister_err_notifier(vdev);
@@ -3208,7 +3208,7 @@ static void vfio_exitfn(PCIDevice *pdev)
static void vfio_pci_reset(DeviceState *dev)
{
- VFIOPCIDevice *vdev = VFIO_PCI(dev);
+ VFIOPCIDevice *vdev = VFIO_PCI_BASE(dev);
trace_vfio_pci_reset(vdev->vbasedev.name);
@@ -3248,7 +3248,7 @@ post_reset:
static void vfio_instance_init(Object *obj)
{
PCIDevice *pci_dev = PCI_DEVICE(obj);
- VFIOPCIDevice *vdev = VFIO_PCI(obj);
+ VFIOPCIDevice *vdev = VFIO_PCI_BASE(obj);
device_add_bootindex_property(obj, &vdev->bootindex,
"bootindex", NULL,
@@ -3265,24 +3265,12 @@ static void vfio_instance_init(Object *obj)
pci_dev->cap_present |= QEMU_PCI_CAP_EXPRESS;
}
-static Property vfio_pci_dev_properties[] = {
- DEFINE_PROP_PCI_HOST_DEVADDR("host", VFIOPCIDevice, host),
- DEFINE_PROP_STRING("sysfsdev", VFIOPCIDevice, vbasedev.sysfsdev),
+static Property vfio_pci_base_dev_properties[] = {
DEFINE_PROP_ON_OFF_AUTO("x-pre-copy-dirty-page-tracking", VFIOPCIDevice,
vbasedev.pre_copy_dirty_page_tracking,
ON_OFF_AUTO_ON),
- DEFINE_PROP_ON_OFF_AUTO("display", VFIOPCIDevice,
- display, ON_OFF_AUTO_OFF),
- DEFINE_PROP_UINT32("xres", VFIOPCIDevice, display_xres, 0),
- DEFINE_PROP_UINT32("yres", VFIOPCIDevice, display_yres, 0),
DEFINE_PROP_UINT32("x-intx-mmap-timeout-ms", VFIOPCIDevice,
intx.mmap_timeout, 1100),
- DEFINE_PROP_BIT("x-vga", VFIOPCIDevice, features,
- VFIO_FEATURE_ENABLE_VGA_BIT, false),
- DEFINE_PROP_BIT("x-req", VFIOPCIDevice, features,
- VFIO_FEATURE_ENABLE_REQ_BIT, true),
- DEFINE_PROP_BIT("x-igd-opregion", VFIOPCIDevice, features,
- VFIO_FEATURE_ENABLE_IGD_OPREGION_BIT, false),
DEFINE_PROP_BOOL("x-enable-migration", VFIOPCIDevice,
vbasedev.enable_migration, false),
DEFINE_PROP_BOOL("x-no-mmap", VFIOPCIDevice, vbasedev.no_mmap, false),
@@ -3291,8 +3279,6 @@ static Property vfio_pci_dev_properties[] = {
DEFINE_PROP_BOOL("x-no-kvm-intx", VFIOPCIDevice, no_kvm_intx, false),
DEFINE_PROP_BOOL("x-no-kvm-msi", VFIOPCIDevice, no_kvm_msi, false),
DEFINE_PROP_BOOL("x-no-kvm-msix", VFIOPCIDevice, no_kvm_msix, false),
- DEFINE_PROP_BOOL("x-no-geforce-quirks", VFIOPCIDevice,
- no_geforce_quirks, false),
DEFINE_PROP_BOOL("x-no-kvm-ioeventfd", VFIOPCIDevice, no_kvm_ioeventfd,
false),
DEFINE_PROP_BOOL("x-no-vfio-ioeventfd", VFIOPCIDevice, no_vfio_ioeventfd,
@@ -3303,10 +3289,6 @@ static Property vfio_pci_dev_properties[] = {
sub_vendor_id, PCI_ANY_ID),
DEFINE_PROP_UINT32("x-pci-sub-device-id", VFIOPCIDevice,
sub_device_id, PCI_ANY_ID),
- DEFINE_PROP_UINT32("x-igd-gms", VFIOPCIDevice, igd_gms, 0),
- DEFINE_PROP_UNSIGNED_NODEFAULT("x-nv-gpudirect-clique", VFIOPCIDevice,
- nv_gpudirect_clique,
- qdev_prop_nv_gpudirect_clique, uint8_t),
DEFINE_PROP_OFF_AUTO_PCIBAR("x-msix-relocation", VFIOPCIDevice, msix_relo,
OFF_AUTOPCIBAR_OFF),
/*
@@ -3317,28 +3299,25 @@ static Property vfio_pci_dev_properties[] = {
DEFINE_PROP_END_OF_LIST(),
};
-static void vfio_pci_dev_class_init(ObjectClass *klass, void *data)
+static void vfio_pci_base_dev_class_init(ObjectClass *klass, void *data)
{
DeviceClass *dc = DEVICE_CLASS(klass);
PCIDeviceClass *pdc = PCI_DEVICE_CLASS(klass);
- dc->reset = vfio_pci_reset;
- device_class_set_props(dc, vfio_pci_dev_properties);
- dc->desc = "VFIO-based PCI device assignment";
+ device_class_set_props(dc, vfio_pci_base_dev_properties);
+ dc->desc = "VFIO PCI base device";
set_bit(DEVICE_CATEGORY_MISC, dc->categories);
- pdc->realize = vfio_realize;
pdc->exit = vfio_exitfn;
pdc->config_read = vfio_pci_read_config;
pdc->config_write = vfio_pci_write_config;
}
-static const TypeInfo vfio_pci_dev_info = {
- .name = TYPE_VFIO_PCI,
+static const TypeInfo vfio_pci_base_dev_info = {
+ .name = TYPE_VFIO_PCI_BASE,
.parent = TYPE_PCI_DEVICE,
- .instance_size = sizeof(VFIOPCIDevice),
- .class_init = vfio_pci_dev_class_init,
- .instance_init = vfio_instance_init,
- .instance_finalize = vfio_instance_finalize,
+ .instance_size = 0,
+ .abstract = true,
+ .class_init = vfio_pci_base_dev_class_init,
.interfaces = (InterfaceInfo[]) {
{ INTERFACE_PCIE_DEVICE },
{ INTERFACE_CONVENTIONAL_PCI_DEVICE },
@@ -3346,6 +3325,48 @@ static const TypeInfo vfio_pci_dev_info = {
},
};
+static Property vfio_pci_dev_properties[] = {
+ DEFINE_PROP_PCI_HOST_DEVADDR("host", VFIOPCIDevice, host),
+ DEFINE_PROP_STRING("sysfsdev", VFIOPCIDevice, vbasedev.sysfsdev),
+ DEFINE_PROP_ON_OFF_AUTO("display", VFIOPCIDevice,
+ display, ON_OFF_AUTO_OFF),
+ DEFINE_PROP_UINT32("xres", VFIOPCIDevice, display_xres, 0),
+ DEFINE_PROP_UINT32("yres", VFIOPCIDevice, display_yres, 0),
+ DEFINE_PROP_BIT("x-vga", VFIOPCIDevice, features,
+ VFIO_FEATURE_ENABLE_VGA_BIT, false),
+ DEFINE_PROP_BIT("x-req", VFIOPCIDevice, features,
+ VFIO_FEATURE_ENABLE_REQ_BIT, true),
+ DEFINE_PROP_BIT("x-igd-opregion", VFIOPCIDevice, features,
+ VFIO_FEATURE_ENABLE_IGD_OPREGION_BIT, false),
+ DEFINE_PROP_BOOL("x-no-geforce-quirks", VFIOPCIDevice,
+ no_geforce_quirks, false),
+ DEFINE_PROP_UINT32("x-igd-gms", VFIOPCIDevice, igd_gms, 0),
+ DEFINE_PROP_UNSIGNED_NODEFAULT("x-nv-gpudirect-clique", VFIOPCIDevice,
+ nv_gpudirect_clique,
+ qdev_prop_nv_gpudirect_clique, uint8_t),
+ DEFINE_PROP_END_OF_LIST(),
+};
+
+static void vfio_pci_dev_class_init(ObjectClass *klass, void *data)
+{
+ DeviceClass *dc = DEVICE_CLASS(klass);
+ PCIDeviceClass *pdc = PCI_DEVICE_CLASS(klass);
+
+ dc->reset = vfio_pci_reset;
+ device_class_set_props(dc, vfio_pci_dev_properties);
+ dc->desc = "VFIO-based PCI device assignment";
+ pdc->realize = vfio_realize;
+}
+
+static const TypeInfo vfio_pci_dev_info = {
+ .name = TYPE_VFIO_PCI,
+ .parent = TYPE_VFIO_PCI_BASE,
+ .instance_size = sizeof(VFIOKernPCIDevice),
+ .class_init = vfio_pci_dev_class_init,
+ .instance_init = vfio_instance_init,
+ .instance_finalize = vfio_instance_finalize,
+};
+
static Property vfio_pci_dev_nohotplug_properties[] = {
DEFINE_PROP_BOOL("ramfb", VFIOPCIDevice, enable_ramfb, false),
DEFINE_PROP_END_OF_LIST(),
@@ -3362,12 +3383,13 @@ static void vfio_pci_nohotplug_dev_class_init(ObjectClass *klass, void *data)
static const TypeInfo vfio_pci_nohotplug_dev_info = {
.name = TYPE_VFIO_PCI_NOHOTPLUG,
.parent = TYPE_VFIO_PCI,
- .instance_size = sizeof(VFIOPCIDevice),
+ .instance_size = sizeof(VFIOKernPCIDevice),
.class_init = vfio_pci_nohotplug_dev_class_init,
};
static void register_vfio_pci_dev_type(void)
{
+ type_register_static(&vfio_pci_base_dev_info);
type_register_static(&vfio_pci_dev_info);
type_register_static(&vfio_pci_nohotplug_dev_info);
}
diff --git a/hw/vfio/pci.h b/hw/vfio/pci.h
index 7c236a5..7c5c8ec 100644
--- a/hw/vfio/pci.h
+++ b/hw/vfio/pci.h
@@ -115,8 +115,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;
@@ -177,6 +182,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)
{
--
1.8.3.1
^ permalink raw reply related [flat|nested] 82+ messages in thread
* [PATCH v1 03/24] vfio-user: add container IO ops vector
2022-11-08 23:13 [PATCH v1 00/24] vfio-user client John Johnson
2022-11-08 23:13 ` [PATCH v1 01/24] vfio-user: introduce vfio-user protocol specification John Johnson
2022-11-08 23:13 ` [PATCH v1 02/24] vfio-user: add VFIO base abstract class John Johnson
@ 2022-11-08 23:13 ` John Johnson
2022-12-09 14:10 ` John Levon
2022-12-09 16:10 ` Cédric Le Goater
2022-11-08 23:13 ` [PATCH v1 04/24] vfio-user: add region cache John Johnson
` (22 subsequent siblings)
25 siblings, 2 replies; 82+ messages in thread
From: John Johnson @ 2022-11-08 23:13 UTC (permalink / raw)
To: qemu-devel
Used for communication with VFIO driver
(prep work for vfio-user, which will communicate over a socket)
Signed-off-by: John G Johnson <john.g.johnson@oracle.com>
---
hw/vfio/common.c | 126 ++++++++++++++++++++++++++++--------------
include/hw/vfio/vfio-common.h | 33 +++++++++++
2 files changed, 117 insertions(+), 42 deletions(-)
diff --git a/hw/vfio/common.c b/hw/vfio/common.c
index ace9562..83d69b9 100644
--- a/hw/vfio/common.c
+++ b/hw/vfio/common.c
@@ -432,12 +432,12 @@ static int vfio_dma_unmap_bitmap(VFIOContainer *container,
goto unmap_exit;
}
- ret = ioctl(container->fd, VFIO_IOMMU_UNMAP_DMA, unmap);
+ ret = CONT_DMA_UNMAP(container, unmap, bitmap);
if (!ret) {
cpu_physical_memory_set_dirty_lebitmap((unsigned long *)bitmap->data,
iotlb->translated_addr, pages);
} else {
- error_report("VFIO_UNMAP_DMA with DIRTY_BITMAP : %m");
+ error_report("VFIO_UNMAP_DMA with DIRTY_BITMAP : %s", strerror(-ret));
}
g_free(bitmap->data);
@@ -465,30 +465,7 @@ static int vfio_dma_unmap(VFIOContainer *container,
return vfio_dma_unmap_bitmap(container, iova, size, iotlb);
}
- while (ioctl(container->fd, VFIO_IOMMU_UNMAP_DMA, &unmap)) {
- /*
- * The type1 backend has an off-by-one bug in the kernel (71a7d3d78e3c
- * v4.15) where an overflow in its wrap-around check prevents us from
- * unmapping the last page of the address space. Test for the error
- * condition and re-try the unmap excluding the last page. The
- * expectation is that we've never mapped the last page anyway and this
- * unmap request comes via vIOMMU support which also makes it unlikely
- * that this page is used. This bug was introduced well after type1 v2
- * support was introduced, so we shouldn't need to test for v1. A fix
- * is queued for kernel v5.0 so this workaround can be removed once
- * affected kernels are sufficiently deprecated.
- */
- if (errno == EINVAL && unmap.size && !(unmap.iova + unmap.size) &&
- container->iommu_type == VFIO_TYPE1v2_IOMMU) {
- trace_vfio_dma_unmap_overflow_workaround();
- unmap.size -= 1ULL << ctz64(container->pgsizes);
- continue;
- }
- error_report("VFIO_UNMAP_DMA failed: %s", strerror(errno));
- return -errno;
- }
-
- return 0;
+ return CONT_DMA_UNMAP(container, &unmap, NULL);
}
static int vfio_dma_map(VFIOContainer *container, hwaddr iova,
@@ -501,24 +478,18 @@ static int vfio_dma_map(VFIOContainer *container, hwaddr iova,
.iova = iova,
.size = size,
};
+ int ret;
if (!readonly) {
map.flags |= VFIO_DMA_MAP_FLAG_WRITE;
}
- /*
- * Try the mapping, if it fails with EBUSY, unmap the region and try
- * again. This shouldn't be necessary, but we sometimes see it in
- * the VGA ROM space.
- */
- if (ioctl(container->fd, VFIO_IOMMU_MAP_DMA, &map) == 0 ||
- (errno == EBUSY && vfio_dma_unmap(container, iova, size, NULL) == 0 &&
- ioctl(container->fd, VFIO_IOMMU_MAP_DMA, &map) == 0)) {
- return 0;
- }
+ ret = CONT_DMA_MAP(container, &map);
- error_report("VFIO_MAP_DMA failed: %s", strerror(errno));
- return -errno;
+ if (ret < 0) {
+ error_report("VFIO_MAP_DMA failed: %s", strerror(-ret));
+ }
+ return ret;
}
static void vfio_host_win_add(VFIOContainer *container,
@@ -1263,10 +1234,10 @@ static void vfio_set_dirty_page_tracking(VFIOContainer *container, bool start)
dirty.flags = VFIO_IOMMU_DIRTY_PAGES_FLAG_STOP;
}
- ret = ioctl(container->fd, VFIO_IOMMU_DIRTY_PAGES, &dirty);
+ ret = CONT_DIRTY_BITMAP(container, &dirty, NULL);
if (ret) {
error_report("Failed to set dirty tracking flag 0x%x errno: %d",
- dirty.flags, errno);
+ dirty.flags, -ret);
}
}
@@ -1316,11 +1287,11 @@ static int vfio_get_dirty_bitmap(VFIOContainer *container, uint64_t iova,
goto err_out;
}
- ret = ioctl(container->fd, VFIO_IOMMU_DIRTY_PAGES, dbitmap);
+ ret = CONT_DIRTY_BITMAP(container, dbitmap, range);
if (ret) {
error_report("Failed to get dirty bitmap for iova: 0x%"PRIx64
" size: 0x%"PRIx64" err: %d", (uint64_t)range->iova,
- (uint64_t)range->size, errno);
+ (uint64_t)range->size, -ret);
goto err_out;
}
@@ -2090,6 +2061,7 @@ static int vfio_connect_container(VFIOGroup *group, AddressSpace *as,
container->error = NULL;
container->dirty_pages_supported = false;
container->dma_max_mappings = 0;
+ container->io_ops = &vfio_cont_io_ioctl;
QLIST_INIT(&container->giommu_list);
QLIST_INIT(&container->hostwin_list);
QLIST_INIT(&container->vrdl_list);
@@ -2626,3 +2598,73 @@ int vfio_eeh_as_op(AddressSpace *as, uint32_t op)
}
return vfio_eeh_container_op(container, op);
}
+
+/*
+ * Traditional ioctl() based io_ops
+ */
+
+static int vfio_io_dma_map(VFIOContainer *container,
+ struct vfio_iommu_type1_dma_map *map)
+{
+
+ /*
+ * Try the mapping, if it fails with EBUSY, unmap the region and try
+ * again. This shouldn't be necessary, but we sometimes see it in
+ * the VGA ROM space.
+ */
+ if (ioctl(container->fd, VFIO_IOMMU_MAP_DMA, map) == 0 ||
+ (errno == EBUSY &&
+ vfio_dma_unmap(container, map->iova, map->size, NULL) == 0 &&
+ ioctl(container->fd, VFIO_IOMMU_MAP_DMA, map) == 0)) {
+ return 0;
+ }
+ return -errno;
+}
+
+static int vfio_io_dma_unmap(VFIOContainer *container,
+ struct vfio_iommu_type1_dma_unmap *unmap,
+ struct vfio_bitmap *bitmap)
+{
+
+ while (ioctl(container->fd, VFIO_IOMMU_UNMAP_DMA, unmap)) {
+ /*
+ * The type1 backend has an off-by-one bug in the kernel (71a7d3d78e3c
+ * v4.15) where an overflow in its wrap-around check prevents us from
+ * unmapping the last page of the address space. Test for the error
+ * condition and re-try the unmap excluding the last page. The
+ * expectation is that we've never mapped the last page anyway and this
+ * unmap request comes via vIOMMU support which also makes it unlikely
+ * that this page is used. This bug was introduced well after type1 v2
+ * support was introduced, so we shouldn't need to test for v1. A fix
+ * is queued for kernel v5.0 so this workaround can be removed once
+ * affected kernels are sufficiently deprecated.
+ */
+ if (errno == EINVAL && unmap->size && !(unmap->iova + unmap->size) &&
+ container->iommu_type == VFIO_TYPE1v2_IOMMU) {
+ trace_vfio_dma_unmap_overflow_workaround();
+ unmap->size -= 1ULL << ctz64(container->pgsizes);
+ continue;
+ }
+ error_report("VFIO_UNMAP_DMA failed: %s", strerror(errno));
+ return -errno;
+ }
+
+ return 0;
+}
+
+static int vfio_io_dirty_bitmap(VFIOContainer *container,
+ struct vfio_iommu_type1_dirty_bitmap *bitmap,
+ struct vfio_iommu_type1_dirty_bitmap_get *range)
+{
+ int ret;
+
+ ret = ioctl(container->fd, VFIO_IOMMU_DIRTY_PAGES, bitmap);
+
+ return ret < 0 ? -errno : ret;
+}
+
+VFIOContIO vfio_cont_io_ioctl = {
+ .dma_map = vfio_io_dma_map,
+ .dma_unmap = vfio_io_dma_unmap,
+ .dirty_bitmap = vfio_io_dirty_bitmap,
+};
diff --git a/include/hw/vfio/vfio-common.h b/include/hw/vfio/vfio-common.h
index e573f5a..6fd40f1 100644
--- a/include/hw/vfio/vfio-common.h
+++ b/include/hw/vfio/vfio-common.h
@@ -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;
--
1.8.3.1
^ permalink raw reply related [flat|nested] 82+ messages in thread
* [PATCH v1 04/24] vfio-user: add region cache
2022-11-08 23:13 [PATCH v1 00/24] vfio-user client John Johnson
` (2 preceding siblings ...)
2022-11-08 23:13 ` [PATCH v1 03/24] vfio-user: add container IO ops vector John Johnson
@ 2022-11-08 23:13 ` John Johnson
2022-12-09 14:15 ` John Levon
` (2 more replies)
2022-11-08 23:13 ` [PATCH v1 05/24] vfio-user: add device IO ops vector John Johnson
` (21 subsequent siblings)
25 siblings, 3 replies; 82+ messages in thread
From: John Johnson @ 2022-11-08 23:13 UTC (permalink / raw)
To: qemu-devel
cache VFIO_DEVICE_GET_REGION_INFO results to reduce
memory alloc/free cycles and as prep work for vfio-user
Signed-off-by: John G Johnson <john.g.johnson@oracle.com>
Signed-off-by: Elena Ufimtseva <elena.ufimtseva@oracle.com>
Signed-off-by: Jagannathan Raman <jag.raman@oracle.com>
---
hw/vfio/ccw.c | 5 -----
hw/vfio/common.c | 41 +++++++++++++++++++++++++++++++++++------
hw/vfio/igd.c | 23 +++++++++--------------
hw/vfio/migration.c | 2 --
hw/vfio/pci-quirks.c | 19 +++++--------------
hw/vfio/pci.c | 8 --------
include/hw/vfio/vfio-common.h | 2 ++
7 files changed, 51 insertions(+), 49 deletions(-)
diff --git a/hw/vfio/ccw.c b/hw/vfio/ccw.c
index 0354737..06b588c 100644
--- a/hw/vfio/ccw.c
+++ b/hw/vfio/ccw.c
@@ -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;
}
diff --git a/hw/vfio/common.c b/hw/vfio/common.c
index 83d69b9..dd9104f 100644
--- a/hw/vfio/common.c
+++ b/hw/vfio/common.c
@@ -1600,8 +1600,6 @@ int vfio_region_setup(Object *obj, VFIODevice *vbasedev, VFIORegion *region,
}
}
- g_free(info);
-
trace_vfio_region_setup(vbasedev->name, index, name,
region->flags, region->fd_offset, region->size);
return 0;
@@ -2357,6 +2355,16 @@ void vfio_put_group(VFIOGroup *group)
}
}
+void vfio_get_all_regions(VFIODevice *vbasedev)
+{
+ struct vfio_region_info *info;
+ int i;
+
+ for (i = 0; i < vbasedev->num_regions; i++) {
+ vfio_get_region_info(vbasedev, i, &info);
+ }
+}
+
int vfio_get_device(VFIOGroup *group, const char *name,
VFIODevice *vbasedev, Error **errp)
{
@@ -2412,12 +2420,23 @@ int vfio_get_device(VFIOGroup *group, const char *name,
trace_vfio_get_device(name, dev_info.flags, dev_info.num_regions,
dev_info.num_irqs);
+ vfio_get_all_regions(vbasedev);
vbasedev->reset_works = !!(dev_info.flags & VFIO_DEVICE_FLAGS_RESET);
return 0;
}
void vfio_put_base_device(VFIODevice *vbasedev)
{
+ if (vbasedev->regions != NULL) {
+ int i;
+
+ for (i = 0; i < vbasedev->num_regions; i++) {
+ g_free(vbasedev->regions[i]);
+ }
+ g_free(vbasedev->regions);
+ vbasedev->regions = NULL;
+ }
+
if (!vbasedev->group) {
return;
}
@@ -2432,6 +2451,17 @@ int vfio_get_region_info(VFIODevice *vbasedev, int index,
{
size_t argsz = sizeof(struct vfio_region_info);
+ /* create region cache */
+ if (vbasedev->regions == NULL) {
+ vbasedev->regions = g_new0(struct vfio_region_info *,
+ vbasedev->num_regions);
+ }
+ /* check cache */
+ if (vbasedev->regions[index] != NULL) {
+ *info = vbasedev->regions[index];
+ return 0;
+ }
+
*info = g_malloc0(argsz);
(*info)->index = index;
@@ -2451,6 +2481,9 @@ retry:
goto retry;
}
+ /* fill cache */
+ vbasedev->regions[index] = *info;
+
return 0;
}
@@ -2469,7 +2502,6 @@ int vfio_get_dev_region_info(VFIODevice *vbasedev, uint32_t type,
hdr = vfio_get_region_info_cap(*info, VFIO_REGION_INFO_CAP_TYPE);
if (!hdr) {
- g_free(*info);
continue;
}
@@ -2481,8 +2513,6 @@ int vfio_get_dev_region_info(VFIODevice *vbasedev, uint32_t type,
if (cap_type->type == type && cap_type->subtype == subtype) {
return 0;
}
-
- g_free(*info);
}
*info = NULL;
@@ -2498,7 +2528,6 @@ bool vfio_has_region_cap(VFIODevice *vbasedev, int region, uint16_t cap_type)
if (vfio_get_region_info_cap(info, cap_type)) {
ret = true;
}
- g_free(info);
}
return ret;
diff --git a/hw/vfio/igd.c b/hw/vfio/igd.c
index afe3fe7..22efa1a 100644
--- a/hw/vfio/igd.c
+++ b/hw/vfio/igd.c
@@ -425,7 +425,7 @@ void vfio_probe_igd_bar4_quirk(VFIOPCIDevice *vdev, int nr)
if ((ret || !rom->size) && !vdev->pdev.romfile) {
error_report("IGD device %s has no ROM, legacy mode disabled",
vdev->vbasedev.name);
- goto out;
+ return;
}
/*
@@ -436,7 +436,7 @@ void vfio_probe_igd_bar4_quirk(VFIOPCIDevice *vdev, int nr)
error_report("IGD device %s hotplugged, ROM disabled, "
"legacy mode disabled", vdev->vbasedev.name);
vdev->rom_read_failed = true;
- goto out;
+ return;
}
/*
@@ -449,7 +449,7 @@ void vfio_probe_igd_bar4_quirk(VFIOPCIDevice *vdev, int nr)
if (ret) {
error_report("IGD device %s does not support OpRegion access,"
"legacy mode disabled", vdev->vbasedev.name);
- goto out;
+ return;
}
ret = vfio_get_dev_region_info(&vdev->vbasedev,
@@ -458,7 +458,7 @@ void vfio_probe_igd_bar4_quirk(VFIOPCIDevice *vdev, int nr)
if (ret) {
error_report("IGD device %s does not support host bridge access,"
"legacy mode disabled", vdev->vbasedev.name);
- goto out;
+ return;
}
ret = vfio_get_dev_region_info(&vdev->vbasedev,
@@ -467,7 +467,7 @@ void vfio_probe_igd_bar4_quirk(VFIOPCIDevice *vdev, int nr)
if (ret) {
error_report("IGD device %s does not support LPC bridge access,"
"legacy mode disabled", vdev->vbasedev.name);
- goto out;
+ return;
}
gmch = vfio_pci_read_config(&vdev->pdev, IGD_GMCH, 4);
@@ -481,7 +481,7 @@ void vfio_probe_igd_bar4_quirk(VFIOPCIDevice *vdev, int nr)
error_reportf_err(err, VFIO_MSG_PREFIX, vdev->vbasedev.name);
error_report("IGD device %s failed to enable VGA access, "
"legacy mode disabled", vdev->vbasedev.name);
- goto out;
+ return;
}
/* Create our LPC/ISA bridge */
@@ -489,7 +489,7 @@ void vfio_probe_igd_bar4_quirk(VFIOPCIDevice *vdev, int nr)
if (ret) {
error_report("IGD device %s failed to create LPC bridge, "
"legacy mode disabled", vdev->vbasedev.name);
- goto out;
+ return;
}
/* Stuff some host values into the VM PCI host bridge */
@@ -497,7 +497,7 @@ void vfio_probe_igd_bar4_quirk(VFIOPCIDevice *vdev, int nr)
if (ret) {
error_report("IGD device %s failed to modify host bridge, "
"legacy mode disabled", vdev->vbasedev.name);
- goto out;
+ return;
}
/* Setup OpRegion access */
@@ -505,7 +505,7 @@ void vfio_probe_igd_bar4_quirk(VFIOPCIDevice *vdev, int nr)
if (ret) {
error_append_hint(&err, "IGD legacy mode disabled\n");
error_reportf_err(err, VFIO_MSG_PREFIX, vdev->vbasedev.name);
- goto out;
+ return;
}
/* Setup our quirk to munge GTT addresses to the VM allocated buffer */
@@ -608,9 +608,4 @@ void vfio_probe_igd_bar4_quirk(VFIOPCIDevice *vdev, int nr)
trace_vfio_pci_igd_bdsm_enabled(vdev->vbasedev.name, ggms_mb + gms_mb);
-out:
- g_free(rom);
- g_free(opregion);
- g_free(host);
- g_free(lpc);
}
diff --git a/hw/vfio/migration.c b/hw/vfio/migration.c
index a6ad1f8..397be43 100644
--- a/hw/vfio/migration.c
+++ b/hw/vfio/migration.c
@@ -879,13 +879,11 @@ int vfio_migration_probe(VFIODevice *vbasedev, Error **errp)
}
trace_vfio_migration_probe(vbasedev->name, info->index);
- g_free(info);
return 0;
add_blocker:
error_setg(&vbasedev->migration_blocker,
"VFIO device doesn't support migration");
- g_free(info);
ret = migrate_add_blocker(vbasedev->migration_blocker, errp);
if (ret < 0) {
diff --git a/hw/vfio/pci-quirks.c b/hw/vfio/pci-quirks.c
index f0147a0..c04ee19 100644
--- a/hw/vfio/pci-quirks.c
+++ b/hw/vfio/pci-quirks.c
@@ -1585,16 +1585,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);
@@ -1607,8 +1605,6 @@ int vfio_pci_nvidia_v100_ram_init(VFIOPCIDevice *vdev, Error **errp)
OBJ_PROP_FLAG_READ);
trace_vfio_pci_nvidia_gpu_setup_quirk(vdev->vbasedev.name, cap->tgt,
nv2reg->size);
-free_exit:
- g_free(nv2reg);
return ret;
}
@@ -1635,16 +1631,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;
@@ -1653,8 +1647,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);
@@ -1674,8 +1667,6 @@ int vfio_pci_nvlink2_init(VFIOPCIDevice *vdev, Error **errp)
OBJ_PROP_FLAG_READ);
trace_vfio_pci_nvlink2_setup_quirk_lnkspd(vdev->vbasedev.name,
capspeed->link_speed);
-free_exit:
- g_free(atsdreg);
return ret;
}
diff --git a/hw/vfio/pci.c b/hw/vfio/pci.c
index 60acde5..1c7618d 100644
--- a/hw/vfio/pci.c
+++ b/hw/vfio/pci.c
@@ -836,8 +836,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 "
@@ -2564,7 +2562,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;
}
@@ -2573,8 +2570,6 @@ int vfio_populate_vga(VFIOPCIDevice *vdev, Error **errp)
vdev->vga->fd_offset = reg_info->offset;
vdev->vga->fd = vdev->vbasedev.fd;
- g_free(reg_info);
-
vdev->vga->region[QEMU_PCI_VGA_MEM].offset = QEMU_PCI_VGA_MEM_BASE;
vdev->vga->region[QEMU_PCI_VGA_MEM].nr = QEMU_PCI_VGA_MEM;
QLIST_INIT(&vdev->vga->region[QEMU_PCI_VGA_MEM].quirks);
@@ -2669,8 +2664,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) {
@@ -3079,7 +3072,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;
}
diff --git a/include/hw/vfio/vfio-common.h b/include/hw/vfio/vfio-common.h
index 6fd40f1..a1db165 100644
--- a/include/hw/vfio/vfio-common.h
+++ b/include/hw/vfio/vfio-common.h
@@ -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);
--
1.8.3.1
^ permalink raw reply related [flat|nested] 82+ messages in thread
* [PATCH v1 05/24] vfio-user: add device IO ops vector
2022-11-08 23:13 [PATCH v1 00/24] vfio-user client John Johnson
` (3 preceding siblings ...)
2022-11-08 23:13 ` [PATCH v1 04/24] vfio-user: add region cache John Johnson
@ 2022-11-08 23:13 ` John Johnson
2022-12-09 14:43 ` John Levon
2022-12-12 7:59 ` Cédric Le Goater
2022-11-08 23:13 ` [PATCH v1 06/24] vfio-user: Define type vfio_user_pci_dev_info John Johnson
` (20 subsequent siblings)
25 siblings, 2 replies; 82+ messages in thread
From: John Johnson @ 2022-11-08 23:13 UTC (permalink / raw)
To: qemu-devel
Used for communication with VFIO driver
(prep work for vfio-user, which will communicate over a socket)
Signed-off-by: John G Johnson <john.g.johnson@oracle.com>
---
hw/vfio/ap.c | 1 +
hw/vfio/ccw.c | 1 +
hw/vfio/common.c | 107 +++++++++++++++++++++++++++-----
hw/vfio/pci.c | 140 ++++++++++++++++++++++++++----------------
hw/vfio/platform.c | 1 +
include/hw/vfio/vfio-common.h | 27 ++++++++
6 files changed, 209 insertions(+), 68 deletions(-)
diff --git a/hw/vfio/ap.c b/hw/vfio/ap.c
index e0dd561..7ef42f1 100644
--- a/hw/vfio/ap.c
+++ b/hw/vfio/ap.c
@@ -102,6 +102,7 @@ static void vfio_ap_realize(DeviceState *dev, Error **errp)
mdevid = basename(vapdev->vdev.sysfsdev);
vapdev->vdev.name = g_strdup_printf("%s", mdevid);
vapdev->vdev.dev = dev;
+ vapdev->vdev.io_ops = &vfio_dev_io_ioctl;
/*
* vfio-ap devices operate in a way compatible with discarding of
diff --git a/hw/vfio/ccw.c b/hw/vfio/ccw.c
index 06b588c..cbd1c25 100644
--- a/hw/vfio/ccw.c
+++ b/hw/vfio/ccw.c
@@ -614,6 +614,7 @@ static void vfio_ccw_get_device(VFIOGroup *group, VFIOCCWDevice *vcdev,
vcdev->vdev.type = VFIO_DEVICE_TYPE_CCW;
vcdev->vdev.name = name;
vcdev->vdev.dev = &vcdev->cdev.parent_obj.parent_obj;
+ vcdev->vdev.io_ops = &vfio_dev_io_ioctl;
return;
diff --git a/hw/vfio/common.c b/hw/vfio/common.c
index dd9104f..c7bf0aa 100644
--- a/hw/vfio/common.c
+++ b/hw/vfio/common.c
@@ -71,7 +71,7 @@ void vfio_disable_irqindex(VFIODevice *vbasedev, int index)
.count = 0,
};
- ioctl(vbasedev->fd, VFIO_DEVICE_SET_IRQS, &irq_set);
+ VDEV_SET_IRQS(vbasedev, &irq_set);
}
void vfio_unmask_single_irqindex(VFIODevice *vbasedev, int index)
@@ -84,7 +84,7 @@ void vfio_unmask_single_irqindex(VFIODevice *vbasedev, int index)
.count = 1,
};
- ioctl(vbasedev->fd, VFIO_DEVICE_SET_IRQS, &irq_set);
+ VDEV_SET_IRQS(vbasedev, &irq_set);
}
void vfio_mask_single_irqindex(VFIODevice *vbasedev, int index)
@@ -97,7 +97,7 @@ void vfio_mask_single_irqindex(VFIODevice *vbasedev, int index)
.count = 1,
};
- ioctl(vbasedev->fd, VFIO_DEVICE_SET_IRQS, &irq_set);
+ VDEV_SET_IRQS(vbasedev, &irq_set);
}
static inline const char *action_to_str(int action)
@@ -178,9 +178,7 @@ int vfio_set_irq_signaling(VFIODevice *vbasedev, int index, int subindex,
pfd = (int32_t *)&irq_set->data;
*pfd = fd;
- if (ioctl(vbasedev->fd, VFIO_DEVICE_SET_IRQS, irq_set)) {
- ret = -errno;
- }
+ ret = VDEV_SET_IRQS(vbasedev, irq_set);
g_free(irq_set);
if (!ret) {
@@ -215,6 +213,7 @@ void vfio_region_write(void *opaque, hwaddr addr,
uint32_t dword;
uint64_t qword;
} buf;
+ int ret;
switch (size) {
case 1:
@@ -234,13 +233,15 @@ void vfio_region_write(void *opaque, hwaddr addr,
break;
}
- if (pwrite(vbasedev->fd, &buf, size, region->fd_offset + addr) != size) {
+ ret = VDEV_REGION_WRITE(vbasedev, region->nr, addr, size, &buf);
+ if (ret != size) {
+ const char *err = ret < 0 ? strerror(-ret) : "short write";
+
error_report("%s(%s:region%d+0x%"HWADDR_PRIx", 0x%"PRIx64
- ",%d) failed: %m",
+ ",%d) failed: %s",
__func__, vbasedev->name, region->nr,
- addr, data, size);
+ addr, data, size, err);
}
-
trace_vfio_region_write(vbasedev->name, region->nr, addr, data, size);
/*
@@ -266,13 +267,18 @@ uint64_t vfio_region_read(void *opaque,
uint64_t qword;
} buf;
uint64_t data = 0;
+ int ret;
+
+ ret = VDEV_REGION_READ(vbasedev, region->nr, addr, size, &buf);
+ if (ret != size) {
+ const char *err = ret < 0 ? strerror(-ret) : "short read";
- if (pread(vbasedev->fd, &buf, size, region->fd_offset + addr) != size) {
- error_report("%s(%s:region%d+0x%"HWADDR_PRIx", %d) failed: %m",
+ error_report("%s(%s:region%d+0x%"HWADDR_PRIx", %d) failed: %s",
__func__, vbasedev->name, region->nr,
- addr, size);
+ addr, size, err);
return (uint64_t)-1;
}
+
switch (size) {
case 1:
data = buf.byte;
@@ -2450,6 +2456,7 @@ int vfio_get_region_info(VFIODevice *vbasedev, int index,
struct vfio_region_info **info)
{
size_t argsz = sizeof(struct vfio_region_info);
+ int ret;
/* create region cache */
if (vbasedev->regions == NULL) {
@@ -2468,10 +2475,11 @@ int vfio_get_region_info(VFIODevice *vbasedev, int index,
retry:
(*info)->argsz = argsz;
- if (ioctl(vbasedev->fd, VFIO_DEVICE_GET_REGION_INFO, *info)) {
+ ret = VDEV_GET_REGION_INFO(vbasedev, *info);
+ if (ret != 0) {
g_free(*info);
*info = NULL;
- return -errno;
+ return ret;
}
if ((*info)->argsz > argsz) {
@@ -2632,6 +2640,75 @@ int vfio_eeh_as_op(AddressSpace *as, uint32_t op)
* Traditional ioctl() based io_ops
*/
+static int vfio_io_get_info(VFIODevice *vbasedev, struct vfio_device_info *info)
+{
+ int ret;
+
+ ret = ioctl(vbasedev->fd, VFIO_DEVICE_GET_INFO, info);
+
+ return ret < 0 ? -errno : ret;
+}
+
+static int vfio_io_get_region_info(VFIODevice *vbasedev,
+ struct vfio_region_info *info)
+{
+ int ret;
+
+ ret = ioctl(vbasedev->fd, VFIO_DEVICE_GET_REGION_INFO, info);
+
+ return ret < 0 ? -errno : ret;
+}
+
+static int vfio_io_get_irq_info(VFIODevice *vbasedev,
+ struct vfio_irq_info *info)
+{
+ int ret;
+
+ ret = ioctl(vbasedev->fd, VFIO_DEVICE_GET_IRQ_INFO, info);
+
+ return ret < 0 ? -errno : ret;
+}
+
+static int vfio_io_set_irqs(VFIODevice *vbasedev, struct vfio_irq_set *irqs)
+{
+ int ret;
+
+ ret = ioctl(vbasedev->fd, VFIO_DEVICE_SET_IRQS, irqs);
+
+ return ret < 0 ? -errno : ret;
+}
+
+static int vfio_io_region_read(VFIODevice *vbasedev, uint8_t index, off_t off,
+ uint32_t size, void *data)
+{
+ struct vfio_region_info *info = vbasedev->regions[index];
+ int ret;
+
+ ret = pread(vbasedev->fd, data, size, info->offset + off);
+
+ return ret < 0 ? -errno : ret;
+}
+
+static int vfio_io_region_write(VFIODevice *vbasedev, uint8_t index, off_t off,
+ uint32_t size, void *data)
+{
+ struct vfio_region_info *info = vbasedev->regions[index];
+ int ret;
+
+ ret = pwrite(vbasedev->fd, data, size, info->offset + off);
+
+ return ret < 0 ? -errno : ret;
+}
+
+VFIODevIO vfio_dev_io_ioctl = {
+ .get_info = vfio_io_get_info,
+ .get_region_info = vfio_io_get_region_info,
+ .get_irq_info = vfio_io_get_irq_info,
+ .set_irqs = vfio_io_set_irqs,
+ .region_read = vfio_io_region_read,
+ .region_write = vfio_io_region_write,
+};
+
static int vfio_io_dma_map(VFIOContainer *container,
struct vfio_iommu_type1_dma_map *map)
{
diff --git a/hw/vfio/pci.c b/hw/vfio/pci.c
index 1c7618d..80b03a2 100644
--- a/hw/vfio/pci.c
+++ b/hw/vfio/pci.c
@@ -43,6 +43,14 @@
#include "migration/blocker.h"
#include "migration/qemu-file.h"
+/* convenience macros for PCI config space */
+#define VDEV_CONFIG_READ(vbasedev, off, size, data) \
+ VDEV_REGION_READ((vbasedev), VFIO_PCI_CONFIG_REGION_INDEX, (off), \
+ (size), (data))
+#define VDEV_CONFIG_WRITE(vbasedev, off, size, data) \
+ VDEV_REGION_WRITE((vbasedev), VFIO_PCI_CONFIG_REGION_INDEX, (off), \
+ (size), (data))
+
#define TYPE_VFIO_PCI_NOHOTPLUG "vfio-pci-nohotplug"
/* Protected by BQL */
@@ -406,7 +414,7 @@ static int vfio_enable_vectors(VFIOPCIDevice *vdev, bool msix)
fds[i] = fd;
}
- ret = ioctl(vdev->vbasedev.fd, VFIO_DEVICE_SET_IRQS, irq_set);
+ ret = VDEV_SET_IRQS(&vdev->vbasedev, irq_set);
g_free(irq_set);
@@ -818,14 +826,16 @@ static void vfio_update_msi(VFIOPCIDevice *vdev)
static void vfio_pci_load_rom(VFIOPCIDevice *vdev)
{
+ VFIODevice *vbasedev = &vdev->vbasedev;
struct vfio_region_info *reg_info;
uint64_t size;
off_t off = 0;
ssize_t bytes;
+ int ret;
- if (vfio_get_region_info(&vdev->vbasedev,
- VFIO_PCI_ROM_REGION_INDEX, ®_info)) {
- error_report("vfio: Error getting ROM info: %m");
+ ret = vfio_get_region_info(vbasedev, VFIO_PCI_ROM_REGION_INDEX, ®_info);
+ if (ret < 0) {
+ error_report("vfio: Error getting ROM info: %s", strerror(-ret));
return;
}
@@ -850,18 +860,19 @@ static void vfio_pci_load_rom(VFIOPCIDevice *vdev)
memset(vdev->rom, 0xff, size);
while (size) {
- bytes = pread(vdev->vbasedev.fd, vdev->rom + off,
- size, vdev->rom_offset + off);
+ bytes = VDEV_REGION_READ(vbasedev, VFIO_PCI_ROM_REGION_INDEX, off,
+ size, vdev->rom + off);
if (bytes == 0) {
break;
} else if (bytes > 0) {
off += bytes;
size -= bytes;
} else {
- if (errno == EINTR || errno == EAGAIN) {
+ if (bytes == -EINTR || bytes == -EAGAIN) {
continue;
}
- error_report("vfio: Error reading device ROM: %m");
+ error_report("vfio: Error reading device ROM: %s",
+ strerror(-bytes));
break;
}
}
@@ -949,11 +960,10 @@ static const MemoryRegionOps vfio_rom_ops = {
static void vfio_pci_size_rom(VFIOPCIDevice *vdev)
{
+ VFIODevice *vbasedev = &vdev->vbasedev;
uint32_t orig, size = cpu_to_le32((uint32_t)PCI_ROM_ADDRESS_MASK);
- off_t offset = vdev->config_offset + PCI_ROM_ADDRESS;
DeviceState *dev = DEVICE(vdev);
char *name;
- int fd = vdev->vbasedev.fd;
if (vdev->pdev.romfile || !vdev->pdev.rom_bar) {
/* Since pci handles romfile, just print a message and return */
@@ -970,11 +980,12 @@ static void vfio_pci_size_rom(VFIOPCIDevice *vdev)
* Use the same size ROM BAR as the physical device. The contents
* will get filled in later when the guest tries to read it.
*/
- if (pread(fd, &orig, 4, offset) != 4 ||
- pwrite(fd, &size, 4, offset) != 4 ||
- pread(fd, &size, 4, offset) != 4 ||
- pwrite(fd, &orig, 4, offset) != 4) {
- error_report("%s(%s) failed: %m", __func__, vdev->vbasedev.name);
+ if (VDEV_CONFIG_READ(vbasedev, PCI_ROM_ADDRESS, 4, &orig) != 4 ||
+ VDEV_CONFIG_WRITE(vbasedev, PCI_ROM_ADDRESS, 4, &size) != 4 ||
+ VDEV_CONFIG_READ(vbasedev, PCI_ROM_ADDRESS, 4, &size) != 4 ||
+ VDEV_CONFIG_WRITE(vbasedev, PCI_ROM_ADDRESS, 4, &orig) != 4) {
+
+ error_report("%s(%s) ROM access failed", __func__, vbasedev->name);
return;
}
@@ -1154,6 +1165,7 @@ static void vfio_sub_page_bar_update_mapping(PCIDevice *pdev, int bar)
uint32_t vfio_pci_read_config(PCIDevice *pdev, uint32_t addr, int len)
{
VFIOPCIDevice *vdev = VFIO_PCI_BASE(pdev);
+ VFIODevice *vbasedev = &vdev->vbasedev;
uint32_t emu_bits = 0, emu_val = 0, phys_val = 0, val;
memcpy(&emu_bits, vdev->emulated_config_bits + addr, len);
@@ -1166,12 +1178,13 @@ uint32_t vfio_pci_read_config(PCIDevice *pdev, uint32_t addr, int len)
if (~emu_bits & (0xffffffffU >> (32 - len * 8))) {
ssize_t ret;
- ret = pread(vdev->vbasedev.fd, &phys_val, len,
- vdev->config_offset + addr);
+ ret = VDEV_CONFIG_READ(vbasedev, addr, len, &phys_val);
if (ret != len) {
- error_report("%s(%s, 0x%x, 0x%x) failed: %m",
- __func__, vdev->vbasedev.name, addr, len);
- return -errno;
+ const char *err = ret < 0 ? strerror(-ret) : "short read";
+
+ error_report("%s(%s, 0x%x, 0x%x) failed: %s",
+ __func__, vbasedev->name, addr, len, err);
+ return -1;
}
phys_val = le32_to_cpu(phys_val);
}
@@ -1187,15 +1200,19 @@ void vfio_pci_write_config(PCIDevice *pdev,
uint32_t addr, uint32_t val, int len)
{
VFIOPCIDevice *vdev = VFIO_PCI_BASE(pdev);
+ VFIODevice *vbasedev = &vdev->vbasedev;
uint32_t val_le = cpu_to_le32(val);
+ int ret;
trace_vfio_pci_write_config(vdev->vbasedev.name, addr, val, len);
/* Write everything to VFIO, let it filter out what we can't write */
- if (pwrite(vdev->vbasedev.fd, &val_le, len, vdev->config_offset + addr)
- != len) {
- error_report("%s(%s, 0x%x, 0x%x, 0x%x) failed: %m",
- __func__, vdev->vbasedev.name, addr, val, len);
+ ret = VDEV_CONFIG_WRITE(vbasedev, addr, len, &val_le);
+ if (ret != len) {
+ const char *err = ret < 0 ? strerror(-ret) : "short write";
+
+ error_report("%s(%s, 0x%x, 0x%x, 0x%x) failed: %s",
+ __func__, vbasedev->name, addr, val, len, err);
}
/* MSI/MSI-X Enabling/Disabling */
@@ -1283,10 +1300,13 @@ static int vfio_msi_setup(VFIOPCIDevice *vdev, int pos, Error **errp)
int ret, entries;
Error *err = NULL;
- if (pread(vdev->vbasedev.fd, &ctrl, sizeof(ctrl),
- vdev->config_offset + pos + PCI_CAP_FLAGS) != sizeof(ctrl)) {
- error_setg_errno(errp, errno, "failed reading MSI PCI_CAP_FLAGS");
- return -errno;
+ ret = VDEV_CONFIG_READ(&vdev->vbasedev, pos + PCI_CAP_FLAGS,
+ sizeof(ctrl), &ctrl);
+ if (ret != sizeof(ctrl)) {
+ const char *err = ret < 0 ? strerror(-ret) : "short read";
+
+ error_setg(errp, "failed reading MSI PCI_CAP_FLAGS %s", err);
+ return ret;
}
ctrl = le16_to_cpu(ctrl);
@@ -1488,33 +1508,39 @@ static void vfio_pci_relocate_msix(VFIOPCIDevice *vdev, Error **errp)
*/
static void vfio_msix_early_setup(VFIOPCIDevice *vdev, Error **errp)
{
+ VFIODevice *vbasedev = &vdev->vbasedev;
uint8_t pos;
uint16_t ctrl;
uint32_t table, pba;
- int fd = vdev->vbasedev.fd;
VFIOMSIXInfo *msix;
+ int ret;
pos = pci_find_capability(&vdev->pdev, PCI_CAP_ID_MSIX);
if (!pos) {
return;
}
- if (pread(fd, &ctrl, sizeof(ctrl),
- vdev->config_offset + pos + PCI_MSIX_FLAGS) != sizeof(ctrl)) {
- error_setg_errno(errp, errno, "failed to read PCI MSIX FLAGS");
- return;
+ ret = VDEV_CONFIG_READ(vbasedev, pos + PCI_MSIX_FLAGS,
+ sizeof(ctrl), &ctrl);
+ if (ret != sizeof(ctrl)) {
+ const char *err = ret < 0 ? strerror(-ret) : "short read";
+
+ error_setg(errp, "failed to read PCI MSIX FLAGS %s", err);
}
- if (pread(fd, &table, sizeof(table),
- vdev->config_offset + pos + PCI_MSIX_TABLE) != sizeof(table)) {
- error_setg_errno(errp, errno, "failed to read PCI MSIX TABLE");
- return;
+ ret = VDEV_CONFIG_READ(vbasedev, pos + PCI_MSIX_TABLE,
+ sizeof(table), &table);
+ if (ret != sizeof(table)) {
+ const char *err = ret < 0 ? strerror(-ret) : "short read";
+
+ error_setg(errp, "failed to read PCI MSIX TABLE %s", err);
}
- if (pread(fd, &pba, sizeof(pba),
- vdev->config_offset + pos + PCI_MSIX_PBA) != sizeof(pba)) {
- error_setg_errno(errp, errno, "failed to read PCI MSIX PBA");
- return;
+ ret = VDEV_CONFIG_READ(vbasedev, pos + PCI_MSIX_PBA, sizeof(pba), &pba);
+ if (ret != sizeof(pba)) {
+ const char *err = ret < 0 ? strerror(-ret) : "short read";
+
+ error_setg(errp, "failed to read PCI MSIX PBA %s", err);
}
ctrl = le16_to_cpu(ctrl);
@@ -1652,7 +1678,6 @@ static void vfio_mmap_set_enabled(VFIOPCIDevice *vdev, bool enabled)
static void vfio_bar_prepare(VFIOPCIDevice *vdev, int nr)
{
VFIOBAR *bar = &vdev->bars[nr];
-
uint32_t pci_bar;
int ret;
@@ -1662,10 +1687,12 @@ static void vfio_bar_prepare(VFIOPCIDevice *vdev, int nr)
}
/* Determine what type of BAR this is for registration */
- ret = pread(vdev->vbasedev.fd, &pci_bar, sizeof(pci_bar),
- vdev->config_offset + PCI_BASE_ADDRESS_0 + (4 * nr));
+ ret = VDEV_CONFIG_READ(&vdev->vbasedev, PCI_BASE_ADDRESS_0 + (4 * nr),
+ sizeof(pci_bar), &pci_bar);
if (ret != sizeof(pci_bar)) {
- error_report("vfio: Failed to read BAR %d (%m)", nr);
+ const char *err = ret < 0 ? strerror(-ret) : "short read";
+
+ error_report("vfio: Failed to read BAR %d (%s)", nr, err);
return;
}
@@ -2213,8 +2240,9 @@ static void vfio_pci_pre_reset(VFIOPCIDevice *vdev)
static void vfio_pci_post_reset(VFIOPCIDevice *vdev)
{
+ VFIODevice *vbasedev = &vdev->vbasedev;
Error *err = NULL;
- int nr;
+ int ret, nr;
vfio_intx_enable(vdev, &err);
if (err) {
@@ -2222,13 +2250,16 @@ static void vfio_pci_post_reset(VFIOPCIDevice *vdev)
}
for (nr = 0; nr < PCI_NUM_REGIONS - 1; ++nr) {
- off_t addr = vdev->config_offset + PCI_BASE_ADDRESS_0 + (4 * nr);
+ off_t addr = PCI_BASE_ADDRESS_0 + (4 * nr);
uint32_t val = 0;
uint32_t len = sizeof(val);
- if (pwrite(vdev->vbasedev.fd, &val, len, addr) != len) {
- error_report("%s(%s) reset bar %d failed: %m", __func__,
- vdev->vbasedev.name, nr);
+ ret = VDEV_CONFIG_WRITE(vbasedev, addr, len, &val);
+ if (ret != len) {
+ const char *err = ret < 0 ? strerror(-ret) : "short write";
+
+ error_report("%s(%s) reset bar %d failed: %s", __func__,
+ vbasedev->name, nr, err);
}
}
@@ -2675,7 +2706,7 @@ static void vfio_populate_device(VFIOPCIDevice *vdev, Error **errp)
irq_info.index = VFIO_PCI_ERR_IRQ_INDEX;
- ret = ioctl(vdev->vbasedev.fd, VFIO_DEVICE_GET_IRQ_INFO, &irq_info);
+ 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));
@@ -2794,8 +2825,10 @@ static void vfio_register_req_notifier(VFIOPCIDevice *vdev)
return;
}
- if (ioctl(vdev->vbasedev.fd,
- VFIO_DEVICE_GET_IRQ_INFO, &irq_info) < 0 || irq_info.count < 1) {
+ if (VDEV_GET_IRQ_INFO(&vdev->vbasedev, &irq_info) < 0) {
+ return;
+ }
+ if (irq_info.count < 1) {
return;
}
@@ -2874,6 +2907,7 @@ static void vfio_realize(PCIDevice *pdev, Error **errp)
vbasedev->ops = &vfio_pci_ops;
vbasedev->type = VFIO_DEVICE_TYPE_PCI;
vbasedev->dev = DEVICE(vdev);
+ vbasedev->io_ops = &vfio_dev_io_ioctl;
tmp = g_strdup_printf("%s/iommu_group", vbasedev->sysfsdev);
len = readlink(tmp, group_path, sizeof(group_path));
diff --git a/hw/vfio/platform.c b/hw/vfio/platform.c
index 5af73f9..c136b09 100644
--- a/hw/vfio/platform.c
+++ b/hw/vfio/platform.c
@@ -621,6 +621,7 @@ static void vfio_platform_realize(DeviceState *dev, Error **errp)
vbasedev->type = VFIO_DEVICE_TYPE_PLATFORM;
vbasedev->dev = dev;
vbasedev->ops = &vfio_platform_ops;
+ vbasedev->io_ops = &vfio_dev_io_ioctl;
qemu_mutex_init(&vdev->intp_mutex);
diff --git a/include/hw/vfio/vfio-common.h b/include/hw/vfio/vfio-common.h
index a1db165..7713d98 100644
--- a/include/hw/vfio/vfio-common.h
+++ b/include/hw/vfio/vfio-common.h
@@ -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 */
--
1.8.3.1
^ permalink raw reply related [flat|nested] 82+ messages in thread
* [PATCH v1 06/24] vfio-user: Define type vfio_user_pci_dev_info
2022-11-08 23:13 [PATCH v1 00/24] vfio-user client John Johnson
` (4 preceding siblings ...)
2022-11-08 23:13 ` [PATCH v1 05/24] vfio-user: add device IO ops vector John Johnson
@ 2022-11-08 23:13 ` John Johnson
2022-12-09 15:23 ` John Levon
2022-12-12 9:01 ` Cédric Le Goater
2022-11-08 23:13 ` [PATCH v1 07/24] vfio-user: connect vfio proxy to remote server John Johnson
` (19 subsequent siblings)
25 siblings, 2 replies; 82+ messages in thread
From: John Johnson @ 2022-11-08 23:13 UTC (permalink / raw)
To: qemu-devel
New class for vfio-user with its class and instance
constructors and destructors, and its pci ops.
Signed-off-by: Elena Ufimtseva <elena.ufimtseva@oracle.com>
Signed-off-by: John G Johnson <john.g.johnson@oracle.com>
Signed-off-by: Jagannathan Raman <jag.raman@oracle.com>
---
hw/vfio/Kconfig | 10 +++++++
hw/vfio/common.c | 5 ++++
hw/vfio/pci.c | 89 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++
hw/vfio/pci.h | 8 +++++
4 files changed, 112 insertions(+)
diff --git a/hw/vfio/Kconfig b/hw/vfio/Kconfig
index 7cdba05..301894e 100644
--- a/hw/vfio/Kconfig
+++ b/hw/vfio/Kconfig
@@ -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
diff --git a/hw/vfio/common.c b/hw/vfio/common.c
index c7bf0aa..c589bd9 100644
--- a/hw/vfio/common.c
+++ b/hw/vfio/common.c
@@ -1774,6 +1774,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);
}
}
diff --git a/hw/vfio/pci.c b/hw/vfio/pci.c
index 80b03a2..dc19869 100644
--- a/hw/vfio/pci.c
+++ b/hw/vfio/pci.c
@@ -19,6 +19,7 @@
*/
#include "qemu/osdep.h"
+#include CONFIG_DEVICES
#include <linux/vfio.h>
#include <sys/ioctl.h>
@@ -3421,3 +3422,91 @@ static void register_vfio_pci_dev_type(void)
}
type_init(register_vfio_pci_dev_type)
+
+
+#ifdef CONFIG_VFIO_USER_PCI
+
+/*
+ * vfio-user routines.
+ */
+
+/*
+ * Emulated devices don't use host hot reset
+ */
+static void vfio_user_compute_needs_reset(VFIODevice *vbasedev)
+{
+ vbasedev->needs_reset = false;
+}
+
+static VFIODeviceOps vfio_user_pci_ops = {
+ .vfio_compute_needs_reset = vfio_user_compute_needs_reset,
+ .vfio_eoi = vfio_intx_eoi,
+ .vfio_get_object = vfio_pci_get_object,
+ .vfio_save_config = vfio_pci_save_config,
+ .vfio_load_config = vfio_pci_load_config,
+};
+
+static void vfio_user_pci_realize(PCIDevice *pdev, Error **errp)
+{
+ ERRP_GUARD();
+ VFIOUserPCIDevice *udev = VFIO_USER_PCI(pdev);
+ VFIOPCIDevice *vdev = VFIO_PCI_BASE(pdev);
+ VFIODevice *vbasedev = &vdev->vbasedev;
+
+ /*
+ * TODO: make option parser understand SocketAddress
+ * and use that instead of having scalar options
+ * for each socket type.
+ */
+ if (!udev->sock_name) {
+ error_setg(errp, "No socket specified");
+ error_append_hint(errp, "Use -device vfio-user-pci,socket=<name>\n");
+ return;
+ }
+
+ vbasedev->name = g_strdup_printf("VFIO user <%s>", udev->sock_name);
+ vbasedev->ops = &vfio_user_pci_ops;
+ vbasedev->type = VFIO_DEVICE_TYPE_PCI;
+ vbasedev->dev = DEVICE(vdev);
+
+}
+
+static void vfio_user_instance_finalize(Object *obj)
+{
+ VFIOPCIDevice *vdev = VFIO_PCI_BASE(obj);
+
+ vfio_put_device(vdev);
+}
+
+static Property vfio_user_pci_dev_properties[] = {
+ DEFINE_PROP_STRING("socket", VFIOUserPCIDevice, sock_name),
+ DEFINE_PROP_END_OF_LIST(),
+};
+
+static void vfio_user_pci_dev_class_init(ObjectClass *klass, void *data)
+{
+ DeviceClass *dc = DEVICE_CLASS(klass);
+ PCIDeviceClass *pdc = PCI_DEVICE_CLASS(klass);
+
+ device_class_set_props(dc, vfio_user_pci_dev_properties);
+ dc->desc = "VFIO over socket PCI device assignment";
+ pdc->realize = vfio_user_pci_realize;
+}
+
+static const TypeInfo vfio_user_pci_dev_info = {
+ .name = TYPE_VFIO_USER_PCI,
+ .parent = TYPE_VFIO_PCI_BASE,
+ .instance_size = sizeof(VFIOUserPCIDevice),
+ .class_init = vfio_user_pci_dev_class_init,
+ .instance_init = vfio_instance_init,
+ .instance_finalize = vfio_user_instance_finalize,
+};
+
+static void register_vfio_user_dev_type(void)
+{
+ type_register_static(&vfio_user_pci_dev_info);
+}
+
+type_init(register_vfio_user_dev_type)
+
+#endif /* VFIO_USER_PCI */
diff --git a/hw/vfio/pci.h b/hw/vfio/pci.h
index 7c5c8ec..27db931 100644
--- a/hw/vfio/pci.h
+++ b/hw/vfio/pci.h
@@ -189,6 +189,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)
{
--
1.8.3.1
^ permalink raw reply related [flat|nested] 82+ messages in thread
* [PATCH v1 07/24] vfio-user: connect vfio proxy to remote server
2022-11-08 23:13 [PATCH v1 00/24] vfio-user client John Johnson
` (5 preceding siblings ...)
2022-11-08 23:13 ` [PATCH v1 06/24] vfio-user: Define type vfio_user_pci_dev_info John Johnson
@ 2022-11-08 23:13 ` John Johnson
2022-12-09 15:23 ` John Levon
2022-12-12 16:24 ` Cédric Le Goater
2022-11-08 23:13 ` [PATCH v1 08/24] vfio-user: define socket receive functions John Johnson
` (18 subsequent siblings)
25 siblings, 2 replies; 82+ messages in thread
From: John Johnson @ 2022-11-08 23:13 UTC (permalink / raw)
To: qemu-devel
add user.c & user.h files for vfio-user code
add proxy struct to handle comms with remote server
Signed-off-by: John G Johnson <john.g.johnson@oracle.com>
Signed-off-by: Elena Ufimtseva <elena.ufimtseva@oracle.com>
Signed-off-by: Jagannathan Raman <jag.raman@oracle.com>
---
MAINTAINERS | 4 +
hw/vfio/meson.build | 1 +
hw/vfio/pci.c | 19 +++++
hw/vfio/user.c | 170 ++++++++++++++++++++++++++++++++++++++++++
hw/vfio/user.h | 78 +++++++++++++++++++
include/hw/vfio/vfio-common.h | 2 +
6 files changed, 274 insertions(+)
create mode 100644 hw/vfio/user.c
create mode 100644 hw/vfio/user.h
diff --git a/MAINTAINERS b/MAINTAINERS
index 999340d..5d64d02 100644
--- a/MAINTAINERS
+++ b/MAINTAINERS
@@ -1987,8 +1987,12 @@ L: qemu-s390x@nongnu.org
vfio-user
M: John G Johnson <john.g.johnson@oracle.com>
M: Thanos Makatos <thanos.makatos@nutanix.com>
+M: Elena Ufimtseva <elena.ufimtseva@oracle.com>
+M: Jagannathan Raman <jag.raman@oracle.com>
S: Supported
F: docs/devel/vfio-user.rst
+F: hw/vfio/user.c
+F: hw/vfio/user.h
vhost
M: Michael S. Tsirkin <mst@redhat.com>
diff --git a/hw/vfio/meson.build b/hw/vfio/meson.build
index da9af29..2f86f72 100644
--- a/hw/vfio/meson.build
+++ b/hw/vfio/meson.build
@@ -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'))
diff --git a/hw/vfio/pci.c b/hw/vfio/pci.c
index dc19869..e5f2413 100644
--- a/hw/vfio/pci.c
+++ b/hw/vfio/pci.c
@@ -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) \
@@ -3452,6 +3453,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
@@ -3464,6 +3468,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->ops = &vfio_user_pci_ops;
vbasedev->type = VFIO_DEVICE_TYPE_PCI;
@@ -3474,8 +3488,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[] = {
diff --git a/hw/vfio/user.c b/hw/vfio/user.c
new file mode 100644
index 0000000..4f09060
--- /dev/null
+++ b/hw/vfio/user.c
@@ -0,0 +1,170 @@
+/*
+ * 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 or later.
+ * See the COPYING file in the top-level directory.
+ *
+ */
+
+#include "qemu/osdep.h"
+#include <linux/vfio.h>
+#include <sys/ioctl.h>
+
+#include "qemu/error-report.h"
+#include "qapi/error.h"
+#include "qemu/main-loop.h"
+#include "hw/hw.h"
+#include "hw/vfio/vfio-common.h"
+#include "hw/vfio/vfio.h"
+#include "qemu/sockets.h"
+#include "io/channel.h"
+#include "io/channel-socket.h"
+#include "io/channel-util.h"
+#include "sysemu/iothread.h"
+#include "user.h"
+
+static IOThread *vfio_user_iothread;
+
+static void vfio_user_shutdown(VFIOProxy *proxy);
+
+
+/*
+ * Functions called by main, CPU, or iothread threads
+ */
+
+static void vfio_user_shutdown(VFIOProxy *proxy)
+{
+ qio_channel_shutdown(proxy->ioc, QIO_CHANNEL_SHUTDOWN_READ, NULL);
+ qio_channel_set_aio_fd_handler(proxy->ioc, proxy->ctx, NULL, NULL, NULL);
+}
+
+/*
+ * Functions only called by iothread
+ */
+
+static void vfio_user_cb(void *opaque)
+{
+ VFIOProxy *proxy = opaque;
+
+ QEMU_LOCK_GUARD(&proxy->lock);
+
+ proxy->state = VFIO_PROXY_CLOSED;
+ qemu_cond_signal(&proxy->close_cv);
+}
+
+
+/*
+ * Functions called by main or CPU threads
+ */
+
+static QLIST_HEAD(, VFIOProxy) vfio_user_sockets =
+ QLIST_HEAD_INITIALIZER(vfio_user_sockets);
+
+VFIOProxy *vfio_user_connect_dev(SocketAddress *addr, Error **errp)
+{
+ VFIOProxy *proxy;
+ QIOChannelSocket *sioc;
+ QIOChannel *ioc;
+ char *sockname;
+
+ if (addr->type != SOCKET_ADDRESS_TYPE_UNIX) {
+ error_setg(errp, "vfio_user_connect - bad address family");
+ return NULL;
+ }
+ sockname = addr->u.q_unix.path;
+
+ sioc = qio_channel_socket_new();
+ ioc = QIO_CHANNEL(sioc);
+ if (qio_channel_socket_connect_sync(sioc, addr, errp)) {
+ object_unref(OBJECT(ioc));
+ return NULL;
+ }
+ qio_channel_set_blocking(ioc, false, NULL);
+
+ proxy = g_malloc0(sizeof(VFIOProxy));
+ proxy->sockname = g_strdup_printf("unix:%s", sockname);
+ proxy->ioc = ioc;
+ proxy->flags = VFIO_PROXY_CLIENT;
+ proxy->state = VFIO_PROXY_CONNECTED;
+
+ qemu_mutex_init(&proxy->lock);
+ qemu_cond_init(&proxy->close_cv);
+
+ if (vfio_user_iothread == NULL) {
+ vfio_user_iothread = iothread_create("VFIO user", errp);
+ }
+
+ proxy->ctx = iothread_get_aio_context(vfio_user_iothread);
+
+ QTAILQ_INIT(&proxy->outgoing);
+ QTAILQ_INIT(&proxy->incoming);
+ QTAILQ_INIT(&proxy->free);
+ QTAILQ_INIT(&proxy->pending);
+ QLIST_INSERT_HEAD(&vfio_user_sockets, proxy, next);
+
+ return proxy;
+}
+
+void vfio_user_disconnect(VFIOProxy *proxy)
+{
+ VFIOUserMsg *r1, *r2;
+
+ qemu_mutex_lock(&proxy->lock);
+
+ /* our side is quitting */
+ if (proxy->state == VFIO_PROXY_CONNECTED) {
+ vfio_user_shutdown(proxy);
+ if (!QTAILQ_EMPTY(&proxy->pending)) {
+ error_printf("vfio_user_disconnect: outstanding requests\n");
+ }
+ }
+ object_unref(OBJECT(proxy->ioc));
+ proxy->ioc = NULL;
+
+ proxy->state = VFIO_PROXY_CLOSING;
+ QTAILQ_FOREACH_SAFE(r1, &proxy->outgoing, next, r2) {
+ qemu_cond_destroy(&r1->cv);
+ QTAILQ_REMOVE(&proxy->pending, r1, next);
+ g_free(r1);
+ }
+ QTAILQ_FOREACH_SAFE(r1, &proxy->incoming, next, r2) {
+ qemu_cond_destroy(&r1->cv);
+ QTAILQ_REMOVE(&proxy->incoming, r1, next);
+ g_free(r1);
+ }
+ QTAILQ_FOREACH_SAFE(r1, &proxy->pending, next, r2) {
+ qemu_cond_destroy(&r1->cv);
+ QTAILQ_REMOVE(&proxy->pending, r1, next);
+ g_free(r1);
+ }
+ QTAILQ_FOREACH_SAFE(r1, &proxy->free, next, r2) {
+ qemu_cond_destroy(&r1->cv);
+ QTAILQ_REMOVE(&proxy->free, r1, next);
+ g_free(r1);
+ }
+
+ /*
+ * Make sure the iothread isn't blocking anywhere
+ * with a ref to this proxy by waiting for a BH
+ * handler to run after the proxy fd handlers were
+ * deleted above.
+ */
+ aio_bh_schedule_oneshot(proxy->ctx, vfio_user_cb, proxy);
+ qemu_cond_wait(&proxy->close_cv, &proxy->lock);
+
+ /* we now hold the only ref to proxy */
+ qemu_mutex_unlock(&proxy->lock);
+ qemu_cond_destroy(&proxy->close_cv);
+ qemu_mutex_destroy(&proxy->lock);
+
+ QLIST_REMOVE(proxy, next);
+ if (QLIST_EMPTY(&vfio_user_sockets)) {
+ iothread_destroy(vfio_user_iothread);
+ vfio_user_iothread = NULL;
+ }
+
+ g_free(proxy->sockname);
+ g_free(proxy);
+}
diff --git a/hw/vfio/user.h b/hw/vfio/user.h
new file mode 100644
index 0000000..da92862
--- /dev/null
+++ b/hw/vfio/user.h
@@ -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 */
diff --git a/include/hw/vfio/vfio-common.h b/include/hw/vfio/vfio-common.h
index 7713d98..fb7d865 100644
--- a/include/hw/vfio/vfio-common.h
+++ b/include/hw/vfio/vfio-common.h
@@ -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;
--
1.8.3.1
^ permalink raw reply related [flat|nested] 82+ messages in thread
* [PATCH v1 08/24] vfio-user: define socket receive functions
2022-11-08 23:13 [PATCH v1 00/24] vfio-user client John Johnson
` (6 preceding siblings ...)
2022-11-08 23:13 ` [PATCH v1 07/24] vfio-user: connect vfio proxy to remote server John Johnson
@ 2022-11-08 23:13 ` John Johnson
2022-12-09 15:34 ` John Levon
2022-12-13 10:45 ` Cédric Le Goater
2022-11-08 23:13 ` [PATCH v1 09/24] vfio-user: define socket send functions John Johnson
` (17 subsequent siblings)
25 siblings, 2 replies; 82+ messages in thread
From: John Johnson @ 2022-11-08 23:13 UTC (permalink / raw)
To: qemu-devel
Add infrastructure needed to receive incoming messages
Signed-off-by: John G Johnson <john.g.johnson@oracle.com>
Signed-off-by: Elena Ufimtseva <elena.ufimtseva@oracle.com>
Signed-off-by: Jagannathan Raman <jag.raman@oracle.com>
---
MAINTAINERS | 1 +
hw/vfio/pci.c | 11 ++
hw/vfio/user-protocol.h | 54 +++++++
hw/vfio/user.c | 399 ++++++++++++++++++++++++++++++++++++++++++++++++
hw/vfio/user.h | 8 +
5 files changed, 473 insertions(+)
create mode 100644 hw/vfio/user-protocol.h
diff --git a/MAINTAINERS b/MAINTAINERS
index 5d64d02..b6c186b 100644
--- a/MAINTAINERS
+++ b/MAINTAINERS
@@ -1993,6 +1993,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 <mst@redhat.com>
diff --git a/hw/vfio/pci.c b/hw/vfio/pci.c
index e5f2413..f086235 100644
--- a/hw/vfio/pci.c
+++ b/hw/vfio/pci.c
@@ -3432,6 +3432,16 @@ type_init(register_vfio_pci_dev_type)
*/
/*
+ * Incoming request message callback.
+ *
+ * Runs off main loop, so BQL held.
+ */
+static void vfio_user_pci_process_req(void *opaque, VFIOUserMsg *msg)
+{
+
+}
+
+/*
* Emulated devices don't use host hot reset
*/
static void vfio_user_compute_needs_reset(VFIODevice *vbasedev)
@@ -3477,6 +3487,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->ops = &vfio_user_pci_ops;
diff --git a/hw/vfio/user-protocol.h b/hw/vfio/user-protocol.h
new file mode 100644
index 0000000..d23877c
--- /dev/null
+++ b/hw/vfio/user-protocol.h
@@ -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 */
diff --git a/hw/vfio/user.c b/hw/vfio/user.c
index 4f09060..ffd69b9 100644
--- a/hw/vfio/user.c
+++ b/hw/vfio/user.c
@@ -28,7 +28,22 @@
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 +55,334 @@ 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
*/
+/*
+ * Process a received message.
+ */
+static void vfio_user_process(VFIOProxy *proxy, VFIOUserMsg *msg, bool isreply)
+{
+
+ /*
+ * 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 (msg->hdr->flags & VFIO_USER_ERROR) {
+ error_printf("vfio_user_rcv: error reply on async request ");
+ error_printf("command %x error %s\n", msg->hdr->command,
+ strerror(msg->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);
+ }
+}
+
+/*
+ * Complete a partial message read
+ */
+static int vfio_user_complete(VFIOProxy *proxy, Error **errp)
+{
+ VFIOUserMsg *msg = proxy->part_recv;
+ size_t msgleft = proxy->recv_left;
+ bool isreply;
+ char *data;
+ int ret;
+
+ data = (char *)msg->hdr + (msg->hdr->size - msgleft);
+ while (msgleft > 0) {
+ ret = qio_channel_read(proxy->ioc, data, msgleft, errp);
+
+ /* error or would block */
+ if (ret <= 0) {
+ /* try for rest on next iternation */
+ if (ret == QIO_CHANNEL_ERR_BLOCK) {
+ proxy->recv_left = msgleft;
+ }
+ return ret;
+ }
+
+ msgleft -= ret;
+ data += ret;
+ }
+
+ /*
+ * Read complete message, process it.
+ */
+ proxy->part_recv = NULL;
+ proxy->recv_left = 0;
+ isreply = (msg->hdr->flags & VFIO_USER_TYPE) == VFIO_USER_REPLY;
+ vfio_user_process(proxy, msg, isreply);
+
+ /* return positive value */
+ return 1;
+}
+
+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;
+
+ /*
+ * Complete any partial reads
+ */
+ if (proxy->part_recv != NULL) {
+ ret = vfio_user_complete(proxy, &local_err);
+
+ /* still not complete, try later */
+ if (ret == QIO_CHANNEL_ERR_BLOCK) {
+ return ret;
+ }
+
+ if (ret <= 0) {
+ goto fatal;
+ }
+ /* else fall into reading another msg */
+ }
+
+ /*
+ * Read header
+ */
+ ret = qio_channel_readv_full(proxy->ioc, &iov, 1, &fdp, &numfds,
+ &local_err);
+ if (ret == QIO_CHANNEL_ERR_BLOCK) {
+ return ret;
+ }
+
+ /* read error or other side closed connection */
+ if (ret <= 0) {
+ goto fatal;
+ }
+
+ if (ret < sizeof(msg)) {
+ error_setg(&local_err, "short read of header");
+ goto fatal;
+ }
+
+ /*
+ * Validate header
+ */
+ if (hdr.size < sizeof(VFIOUserHdr)) {
+ error_setg(&local_err, "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, "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, "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, "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, "reply larger than recv buffer");
+ goto err;
+ }
+ *msg->hdr = hdr;
+ data = (char *)msg->hdr + sizeof(hdr);
+ } else {
+ 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;
+ }
+
+ /*
+ * Read rest of message.
+ */
+ msgleft = hdr.size - sizeof(hdr);
+ while (msgleft > 0) {
+ ret = qio_channel_read(proxy->ioc, data, msgleft, &local_err);
+
+ /* prepare to complete read on next iternation */
+ if (ret == QIO_CHANNEL_ERR_BLOCK) {
+ proxy->part_recv = msg;
+ proxy->recv_left = msgleft;
+ return ret;
+ }
+
+ if (ret <= 0) {
+ goto fatal;
+ }
+
+ msgleft -= ret;
+ data += ret;
+ }
+
+ vfio_user_process(proxy, msg, isreply);
+ 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;
+
+ /* set error if server side closed */
+ if (ret == 0) {
+ error_setg(&local_err, "server closed socket");
+ }
+
+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_prepend(&local_err, "vfio_user_recv: ");
+ error_report_err(local_err);
+ return -1;
+}
+
static void vfio_user_cb(void *opaque)
{
VFIOProxy *proxy = opaque;
@@ -59,6 +398,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->incoming, 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 +481,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);
@@ -107,6 +492,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;
@@ -122,6 +519,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) {
diff --git a/hw/vfio/user.h b/hw/vfio/user.h
index da92862..68a1080 100644
--- a/hw/vfio/user.h
+++ b/hw/vfio/user.h
@@ -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;
@@ -66,6 +69,8 @@ typedef struct VFIOProxy {
VFIOUserMsgQ incoming;
VFIOUserMsgQ outgoing;
VFIOUserMsg *last_nowait;
+ VFIOUserMsg *part_recv;
+ size_t recv_left;
enum proxy_state state;
} VFIOProxy;
@@ -74,5 +79,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 */
--
1.8.3.1
^ permalink raw reply related [flat|nested] 82+ messages in thread
* [PATCH v1 09/24] vfio-user: define socket send functions
2022-11-08 23:13 [PATCH v1 00/24] vfio-user client John Johnson
` (7 preceding siblings ...)
2022-11-08 23:13 ` [PATCH v1 08/24] vfio-user: define socket receive functions John Johnson
@ 2022-11-08 23:13 ` John Johnson
2022-12-09 15:52 ` John Levon
2022-12-13 13:48 ` Cédric Le Goater
2022-11-08 23:13 ` [PATCH v1 10/24] vfio-user: get device info John Johnson
` (16 subsequent siblings)
25 siblings, 2 replies; 82+ messages in thread
From: John Johnson @ 2022-11-08 23:13 UTC (permalink / raw)
To: qemu-devel
Also negotiate protocol version with remote server
Signed-off-by: Jagannathan Raman <jag.raman@oracle.com>
Signed-off-by: Elena Ufimtseva <elena.ufimtseva@oracle.com>
Signed-off-by: John G Johnson <john.g.johnson@oracle.com>
---
hw/vfio/pci.c | 15 ++
hw/vfio/pci.h | 1 +
hw/vfio/user-protocol.h | 62 ++++++
hw/vfio/user.c | 508 ++++++++++++++++++++++++++++++++++++++++++++++++
hw/vfio/user.h | 9 +
5 files changed, 595 insertions(+)
diff --git a/hw/vfio/pci.c b/hw/vfio/pci.c
index f086235..b2534b3 100644
--- a/hw/vfio/pci.c
+++ b/hw/vfio/pci.c
@@ -3489,11 +3489,25 @@ 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(proxy, &err);
+ if (err != NULL) {
+ error_propagate(errp, err);
+ goto error;
+ }
+
vbasedev->name = g_strdup_printf("VFIO user <%s>", udev->sock_name);
vbasedev->ops = &vfio_user_pci_ops;
vbasedev->type = VFIO_DEVICE_TYPE_PCI;
vbasedev->dev = DEVICE(vdev);
+ return;
+
+error:
+ error_prepend(errp, VFIO_MSG_PREFIX, vdev->vbasedev.name);
}
static void vfio_user_instance_finalize(Object *obj)
@@ -3510,6 +3524,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(),
};
diff --git a/hw/vfio/pci.h b/hw/vfio/pci.h
index 27db931..c47d2f8 100644
--- a/hw/vfio/pci.h
+++ b/hw/vfio/pci.h
@@ -195,6 +195,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 */
diff --git a/hw/vfio/user-protocol.h b/hw/vfio/user-protocol.h
index d23877c..5de5b20 100644
--- a/hw/vfio/user-protocol.h
+++ b/hw/vfio/user-protocol.h
@@ -51,4 +51,66 @@ 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_PGSIZES "pgsizes"
+#define VFIO_USER_CAP_MAP_MAX "max_dma_maps"
+#define VFIO_USER_CAP_MIGR "migration"
+
+/* "migration" members */
+#define VFIO_USER_CAP_PGSIZE "pgsize"
+#define VFIO_USER_CAP_MAX_BITMAP "max_bitmap_size"
+
+/*
+ * 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)
+
+/*
+ * Default pagesizes supported is 4k.
+ */
+#define VFIO_USER_DEF_PGSIZE 4096
+
+/*
+ * Default max number of DMA mappings is stolen from the
+ * linux kernel "dma_entry_limit"
+ */
+#define VFIO_USER_DEF_MAP_MAX 65535
+
+/*
+ * Default max bitmap size is also take from the linux kernel,
+ * where usage of signed ints limits the VA range to 2^31 bytes.
+ * Dividing that by the number of bits per byte yields 256MB
+ */
+#define VFIO_USER_DEF_MAX_BITMAP (256 * 1024 * 1024)
+
#endif /* VFIO_USER_PROTOCOL_H */
diff --git a/hw/vfio/user.c b/hw/vfio/user.c
index ffd69b9..31bcc93 100644
--- a/hw/vfio/user.c
+++ b/hw/vfio/user.c
@@ -23,11 +23,19 @@
#include "io/channel-socket.h"
#include "io/channel-util.h"
#include "sysemu/iothread.h"
+#include "qapi/qmp/qdict.h"
+#include "qapi/qmp/qjson.h"
+#include "qapi/qmp/qnull.h"
+#include "qapi/qmp/qstring.h"
+#include "qapi/qmp/qnum.h"
+#include "qapi/qmp/qbool.h"
#include "user.h"
+static int wait_time = 5000; /* wait up to 5 sec for busy servers */
static 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);
@@ -35,9 +43,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);
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)
{
@@ -55,6 +70,33 @@ 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, 0,
+ &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)
{
@@ -95,6 +137,7 @@ static void vfio_user_recycle(VFIOProxy *proxy, VFIOUserMsg *msg)
msg->hdr = NULL;
msg->fds = NULL;
msg->complete = false;
+ msg->pending = false;
QTAILQ_INSERT_HEAD(&proxy->free, msg, next);
}
@@ -383,6 +426,54 @@ 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;
+
+ QEMU_LOCK_GUARD(&proxy->lock);
+
+ if (proxy->state == VFIO_PROXY_CONNECTED) {
+ while (!QTAILQ_EMPTY(&proxy->outgoing)) {
+ if (vfio_user_send_one(proxy) < 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;
+
+ msg = QTAILQ_FIRST(&proxy->outgoing);
+ 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);
+ msg->pending = true;
+ }
+
+ return 0;
+}
+
static void vfio_user_cb(void *opaque)
{
VFIOProxy *proxy = opaque;
@@ -443,6 +534,134 @@ 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);
+ msg->pending = true;
+ }
+
+ 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)) {
+ VFIOUserMsgQ *list;
+
+ list = msg->pending ? &proxy->pending : &proxy->outgoing;
+ QTAILQ_REMOVE(list, 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);
@@ -470,6 +689,15 @@ VFIOProxy *vfio_user_connect_dev(SocketAddress *addr, Error **errp)
proxy = g_malloc0(sizeof(VFIOProxy));
proxy->sockname = g_strdup_printf("unix:%s", sockname);
proxy->ioc = ioc;
+
+ /* init defaults */
+ proxy->max_xfer_size = VFIO_USER_DEF_MAX_XFER;
+ proxy->max_send_fds = VFIO_USER_DEF_MAX_FDS;
+ proxy->max_dma = VFIO_USER_DEF_MAP_MAX;
+ proxy->dma_pgsizes = VFIO_USER_DEF_PGSIZE;
+ proxy->max_bitmap = VFIO_USER_DEF_MAX_BITMAP;
+ proxy->migr_pgsize = VFIO_USER_DEF_PGSIZE;
+
proxy->flags = VFIO_PROXY_CLIENT;
proxy->state = VFIO_PROXY_CONNECTED;
@@ -567,3 +795,283 @@ 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)(VFIOProxy *proxy, QObject *qobj, Error **errp);
+};
+
+static int caps_parse(VFIOProxy *proxy, 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(proxy, 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_migr_pgsize(VFIOProxy *proxy, 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;
+ }
+
+ /* must be larger than default */
+ if (pgsize & (VFIO_USER_DEF_PGSIZE - 1)) {
+ error_setg(errp, "pgsize 0x%"PRIx64" too small", pgsize);
+ return -1;
+ }
+
+ proxy->migr_pgsize = pgsize;
+ return 0;
+}
+
+static int check_bitmap(VFIOProxy *proxy, QObject *qobj, Error **errp)
+{
+ QNum *qn = qobject_to(QNum, qobj);
+ uint64_t bitmap_size;
+
+ if (qn == NULL || !qnum_get_try_uint(qn, &bitmap_size)) {
+ error_setg(errp, "malformed %s", VFIO_USER_CAP_MAX_BITMAP);
+ return -1;
+ }
+
+ /* can only lower it */
+ if (bitmap_size > VFIO_USER_DEF_MAX_BITMAP) {
+ error_setg(errp, "%s too large", VFIO_USER_CAP_MAX_BITMAP);
+ return -1;
+ }
+
+ proxy->max_bitmap = bitmap_size;
+ return 0;
+}
+
+static struct cap_entry caps_migr[] = {
+ { VFIO_USER_CAP_PGSIZE, check_migr_pgsize },
+ { VFIO_USER_CAP_MAX_BITMAP, check_bitmap },
+ { NULL }
+};
+
+static int check_max_fds(VFIOProxy *proxy, QObject *qobj, Error **errp)
+{
+ QNum *qn = qobject_to(QNum, qobj);
+ uint64_t max_send_fds;
+
+ 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;
+ }
+ proxy->max_send_fds = max_send_fds;
+ return 0;
+}
+
+static int check_max_xfer(VFIOProxy *proxy, QObject *qobj, Error **errp)
+{
+ QNum *qn = qobject_to(QNum, qobj);
+ uint64_t max_xfer_size;
+
+ 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;
+ }
+ proxy->max_xfer_size = max_xfer_size;
+ return 0;
+}
+
+static int check_pgsizes(VFIOProxy *proxy, QObject *qobj, Error **errp)
+{
+ QNum *qn = qobject_to(QNum, qobj);
+ uint64_t pgsizes;
+
+ if (qn == NULL || !qnum_get_try_uint(qn, &pgsizes)) {
+ error_setg(errp, "malformed %s", VFIO_USER_CAP_PGSIZES);
+ return -1;
+ }
+
+ /* must be larger than default */
+ if (pgsizes & (VFIO_USER_DEF_PGSIZE - 1)) {
+ error_setg(errp, "pgsize 0x%"PRIx64" too small", pgsizes);
+ return -1;
+ }
+
+ proxy->dma_pgsizes = pgsizes;
+ return 0;
+}
+
+static int check_max_dma(VFIOProxy *proxy, QObject *qobj, Error **errp)
+{
+ QNum *qn = qobject_to(QNum, qobj);
+ uint64_t max_dma;
+
+ if (qn == NULL || !qnum_get_try_uint(qn, &max_dma)) {
+ error_setg(errp, "malformed %s", VFIO_USER_CAP_MAP_MAX);
+ return -1;
+ }
+
+ /* can only lower it */
+ if (max_dma > VFIO_USER_DEF_MAP_MAX) {
+ error_setg(errp, "%s too large", VFIO_USER_CAP_MAP_MAX);
+ return -1;
+ }
+
+ proxy->max_dma = max_dma;
+ return 0;
+}
+
+static int check_migr(VFIOProxy *proxy, 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(proxy, 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_PGSIZES, check_pgsizes },
+ { VFIO_USER_CAP_MAP_MAX, check_max_dma },
+ { VFIO_USER_CAP_MIGR, check_migr },
+ { NULL }
+};
+
+static int check_cap(VFIOProxy *proxy, 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(proxy, qdict, caps_cap, errp);
+}
+
+static struct cap_entry ver_0_0[] = {
+ { VFIO_USER_CAP, check_cap },
+ { NULL }
+};
+
+static int caps_check(VFIOProxy *proxy, 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(proxy, 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, VFIO_USER_DEF_PGSIZE);
+ qdict_put_int(migdict, VFIO_USER_CAP_MAX_BITMAP, VFIO_USER_DEF_MAX_BITMAP);
+ 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);
+ qdict_put_int(capdict, VFIO_USER_CAP_PGSIZES, VFIO_USER_DEF_PGSIZE);
+ qdict_put_int(capdict, VFIO_USER_CAP_MAP_MAX, VFIO_USER_DEF_MAP_MAX);
+
+ 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(VFIOProxy *proxy, 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(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(proxy, msgp->minor, reply, errp) != 0) {
+ return -1;
+ }
+
+ return 0;
+}
diff --git a/hw/vfio/user.h b/hw/vfio/user.h
index 68a1080..8ce3cd9 100644
--- a/hw/vfio/user.h
+++ b/hw/vfio/user.h
@@ -35,6 +35,7 @@ typedef struct VFIOUserMsg {
uint32_t id;
QemuCond cv;
bool complete;
+ bool pending;
enum msg_type type;
} VFIOUserMsg;
@@ -54,6 +55,12 @@ typedef struct VFIOProxy {
struct QIOChannel *ioc;
void (*request)(void *opaque, VFIOUserMsg *msg);
void *req_arg;
+ uint64_t max_xfer_size;
+ uint64_t max_send_fds;
+ uint64_t max_dma;
+ uint64_t dma_pgsizes;
+ uint64_t max_bitmap;
+ uint64_t migr_pgsize;
int flags;
QemuCond close_cv;
AioContext *ctx;
@@ -76,11 +83,13 @@ typedef struct VFIOProxy {
/* VFIOProxy flags */
#define VFIO_PROXY_CLIENT 0x1
+#define VFIO_PROXY_FORCE_QUEUED 0x4
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);
+int vfio_user_validate_version(VFIOProxy *proxy, Error **errp);
#endif /* VFIO_USER_H */
--
1.8.3.1
^ permalink raw reply related [flat|nested] 82+ messages in thread
* [PATCH v1 10/24] vfio-user: get device info
2022-11-08 23:13 [PATCH v1 00/24] vfio-user client John Johnson
` (8 preceding siblings ...)
2022-11-08 23:13 ` [PATCH v1 09/24] vfio-user: define socket send functions John Johnson
@ 2022-11-08 23:13 ` John Johnson
2022-12-09 15:57 ` John Levon
2022-12-13 14:06 ` Cédric Le Goater
2022-11-08 23:13 ` [PATCH v1 11/24] vfio-user: get region info John Johnson
` (15 subsequent siblings)
25 siblings, 2 replies; 82+ messages in thread
From: John Johnson @ 2022-11-08 23:13 UTC (permalink / raw)
To: qemu-devel
Signed-off-by: Elena Ufimtseva <elena.ufimtseva@oracle.com>
Signed-off-by: John G Johnson <john.g.johnson@oracle.com>
Signed-off-by: Jagannathan Raman <jag.raman@oracle.com>
---
hw/vfio/pci.c | 15 ++++++++++++++
hw/vfio/user-protocol.h | 13 ++++++++++++
hw/vfio/user.c | 55 +++++++++++++++++++++++++++++++++++++++++++++++++
hw/vfio/user.h | 2 ++
4 files changed, 85 insertions(+)
diff --git a/hw/vfio/pci.c b/hw/vfio/pci.c
index b2534b3..2e0e41d 100644
--- a/hw/vfio/pci.c
+++ b/hw/vfio/pci.c
@@ -3465,6 +3465,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;
/*
@@ -3503,6 +3505,19 @@ static void vfio_user_pci_realize(PCIDevice *pdev, Error **errp)
vbasedev->ops = &vfio_user_pci_ops;
vbasedev->type = VFIO_DEVICE_TYPE_PCI;
vbasedev->dev = DEVICE(vdev);
+ 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;
+ }
+
+ vfio_populate_device(vdev, &err);
+ if (err) {
+ error_propagate(errp, err);
+ goto error;
+ }
return;
diff --git a/hw/vfio/user-protocol.h b/hw/vfio/user-protocol.h
index 5de5b20..43912a5 100644
--- a/hw/vfio/user-protocol.h
+++ b/hw/vfio/user-protocol.h
@@ -113,4 +113,17 @@ typedef struct {
*/
#define VFIO_USER_DEF_MAX_BITMAP (256 * 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 */
diff --git a/hw/vfio/user.c b/hw/vfio/user.c
index 31bcc93..7873534 100644
--- a/hw/vfio/user.c
+++ b/hw/vfio/user.c
@@ -31,6 +31,14 @@
#include "qapi/qmp/qbool.h"
#include "user.h"
+
+/*
+ * These are to defend against a malign server trying
+ * to force us to run out of memory.
+ */
+#define VFIO_USER_MAX_REGIONS 100
+#define VFIO_USER_MAX_IRQS 50
+
static int wait_time = 5000; /* wait up to 5 sec for busy servers */
static IOThread *vfio_user_iothread;
@@ -1075,3 +1083,50 @@ int vfio_user_validate_version(VFIOProxy *proxy, Error **errp)
return 0;
}
+
+static int vfio_user_get_info(VFIOProxy *proxy, struct vfio_device_info *info)
+{
+ VFIOUserDeviceInfo msg;
+
+ memset(&msg, 0, sizeof(msg));
+ vfio_user_request_msg(&msg.hdr, VFIO_USER_DEVICE_GET_INFO, sizeof(msg), 0);
+ msg.argsz = sizeof(struct vfio_device_info);
+
+ vfio_user_send_wait(proxy, &msg.hdr, NULL, 0, false);
+ if (msg.hdr.flags & VFIO_USER_ERROR) {
+ return -msg.hdr.error_reply;
+ }
+
+ memcpy(info, &msg.argsz, sizeof(*info));
+ return 0;
+}
+
+
+/*
+ * Socket-based io_ops
+ */
+
+static int vfio_user_io_get_info(VFIODevice *vbasedev,
+ struct vfio_device_info *info)
+{
+ int ret;
+
+ ret = vfio_user_get_info(vbasedev->proxy, info);
+ if (ret) {
+ return ret;
+ }
+
+ /* defend against a malicious server */
+ if (info->num_regions > VFIO_USER_MAX_REGIONS ||
+ info->num_irqs > VFIO_USER_MAX_IRQS) {
+ error_printf("vfio_user_get_info: invalid reply\n");
+ return -EINVAL;
+ }
+
+ return 0;
+}
+
+VFIODevIO vfio_dev_io_sock = {
+ .get_info = vfio_user_io_get_info,
+};
+
diff --git a/hw/vfio/user.h b/hw/vfio/user.h
index 8ce3cd9..2547cf6 100644
--- a/hw/vfio/user.h
+++ b/hw/vfio/user.h
@@ -92,4 +92,6 @@ void vfio_user_set_handler(VFIODevice *vbasedev,
void *reqarg);
int vfio_user_validate_version(VFIOProxy *proxy, Error **errp);
+extern VFIODevIO vfio_dev_io_sock;
+
#endif /* VFIO_USER_H */
--
1.8.3.1
^ permalink raw reply related [flat|nested] 82+ messages in thread
* [PATCH v1 11/24] vfio-user: get region info
2022-11-08 23:13 [PATCH v1 00/24] vfio-user client John Johnson
` (9 preceding siblings ...)
2022-11-08 23:13 ` [PATCH v1 10/24] vfio-user: get device info John Johnson
@ 2022-11-08 23:13 ` John Johnson
2022-12-09 17:04 ` John Levon
2022-12-13 15:15 ` Cédric Le Goater
2022-11-08 23:13 ` [PATCH v1 12/24] vfio-user: region read/write John Johnson
` (14 subsequent siblings)
25 siblings, 2 replies; 82+ messages in thread
From: John Johnson @ 2022-11-08 23:13 UTC (permalink / raw)
To: qemu-devel
Add per-region FD to support mmap() of remote device regions
Signed-off-by: Elena Ufimtseva <elena.ufimtseva@oracle.com>
Signed-off-by: John G Johnson <john.g.johnson@oracle.com>
Signed-off-by: Jagannathan Raman <jag.raman@oracle.com>
---
hw/vfio/common.c | 32 ++++++++++++++++++++---
hw/vfio/user-protocol.h | 14 ++++++++++
hw/vfio/user.c | 59 +++++++++++++++++++++++++++++++++++++++++++
include/hw/vfio/vfio-common.h | 8 +++---
4 files changed, 107 insertions(+), 6 deletions(-)
diff --git a/hw/vfio/common.c b/hw/vfio/common.c
index c589bd9..87400b3 100644
--- a/hw/vfio/common.c
+++ b/hw/vfio/common.c
@@ -41,6 +41,7 @@
#include "qapi/error.h"
#include "migration/migration.h"
#include "sysemu/tpm.h"
+#include "hw/vfio/user.h"
VFIOGroupList vfio_group_list =
QLIST_HEAD_INITIALIZER(vfio_group_list);
@@ -1586,6 +1587,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);
@@ -1637,7 +1643,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) {
@@ -2442,10 +2448,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) {
@@ -2461,12 +2474,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) {
@@ -2480,7 +2497,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;
@@ -2490,12 +2507,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;
}
@@ -2655,10 +2679,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;
diff --git a/hw/vfio/user-protocol.h b/hw/vfio/user-protocol.h
index 43912a5..a1b64fe 100644
--- a/hw/vfio/user-protocol.h
+++ b/hw/vfio/user-protocol.h
@@ -126,4 +126,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 */
diff --git a/hw/vfio/user.c b/hw/vfio/user.c
index 7873534..69b0fed 100644
--- a/hw/vfio/user.c
+++ b/hw/vfio/user.c
@@ -1101,6 +1101,40 @@ static int vfio_user_get_info(VFIOProxy *proxy, struct vfio_device_info *info)
return 0;
}
+static int vfio_user_get_region_info(VFIOProxy *proxy,
+ struct vfio_region_info *info,
+ VFIOUserFDs *fds)
+{
+ g_autofree VFIOUserRegionInfo *msgp = NULL;
+ uint32_t size;
+
+ /* data returned can be larger than vfio_region_info */
+ if (info->argsz < sizeof(*info)) {
+ error_printf("vfio_user_get_region_info argsz too small\n");
+ return -EINVAL;
+ }
+ if (fds != NULL && fds->send_fds != 0) {
+ error_printf("vfio_user_get_region_info can't send FDs\n");
+ return -EINVAL;
+ }
+
+ size = info->argsz + sizeof(VFIOUserHdr);
+ msgp = g_malloc0(size);
+
+ vfio_user_request_msg(&msgp->hdr, VFIO_USER_DEVICE_GET_REGION_INFO,
+ sizeof(*msgp), 0);
+ msgp->argsz = info->argsz;
+ msgp->index = info->index;
+
+ vfio_user_send_wait(proxy, &msgp->hdr, fds, size, false);
+ if (msgp->hdr.flags & VFIO_USER_ERROR) {
+ return -msgp->hdr.error_reply;
+ }
+
+ memcpy(info, &msgp->argsz, info->argsz);
+ return 0;
+}
+
/*
* Socket-based io_ops
@@ -1126,7 +1160,32 @@ static int vfio_user_io_get_info(VFIODevice *vbasedev,
return 0;
}
+static int vfio_user_io_get_region_info(VFIODevice *vbasedev,
+ struct vfio_region_info *info,
+ int *fd)
+{
+ int ret;
+ VFIOUserFDs fds = { 0, 1, fd};
+
+ ret = vfio_user_get_region_info(vbasedev->proxy, info, &fds);
+ if (ret) {
+ return ret;
+ }
+
+ if (info->index > vbasedev->num_regions) {
+ return -EINVAL;
+ }
+ /* cap_offset in valid area */
+ if ((info->flags & VFIO_REGION_INFO_FLAG_CAPS) &&
+ (info->cap_offset < sizeof(*info) || info->cap_offset > info->argsz)) {
+ return -EINVAL;
+ }
+
+ return 0;
+}
+
VFIODevIO vfio_dev_io_sock = {
.get_info = vfio_user_io_get_info,
+ .get_region_info = vfio_user_io_get_region_info,
};
diff --git a/include/hw/vfio/vfio-common.h b/include/hw/vfio/vfio-common.h
index fb7d865..3406e6a 100644
--- a/include/hw/vfio/vfio-common.h
+++ b/include/hw/vfio/vfio-common.h
@@ -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) \
--
1.8.3.1
^ permalink raw reply related [flat|nested] 82+ messages in thread
* [PATCH v1 12/24] vfio-user: region read/write
2022-11-08 23:13 [PATCH v1 00/24] vfio-user client John Johnson
` (10 preceding siblings ...)
2022-11-08 23:13 ` [PATCH v1 11/24] vfio-user: get region info John Johnson
@ 2022-11-08 23:13 ` John Johnson
2022-12-09 17:11 ` John Levon
2022-12-13 16:13 ` Cédric Le Goater
2022-11-08 23:13 ` [PATCH v1 13/24] vfio-user: pci_user_realize PCI setup John Johnson
` (13 subsequent siblings)
25 siblings, 2 replies; 82+ messages in thread
From: John Johnson @ 2022-11-08 23:13 UTC (permalink / raw)
To: qemu-devel
Add support for posted writes on remote devices
Signed-off-by: Elena Ufimtseva <elena.ufimtseva@oracle.com>
Signed-off-by: John G Johnson <john.g.johnson@oracle.com>
Signed-off-by: Jagannathan Raman <jag.raman@oracle.com>
---
hw/vfio/common.c | 10 +++-
hw/vfio/pci.c | 9 +++-
hw/vfio/pci.h | 1 +
hw/vfio/user-protocol.h | 12 +++++
hw/vfio/user.c | 109 ++++++++++++++++++++++++++++++++++++++++++
hw/vfio/user.h | 1 +
include/hw/vfio/vfio-common.h | 7 +--
7 files changed, 143 insertions(+), 6 deletions(-)
diff --git a/hw/vfio/common.c b/hw/vfio/common.c
index 87400b3..87cd1d1 100644
--- a/hw/vfio/common.c
+++ b/hw/vfio/common.c
@@ -214,6 +214,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) {
@@ -234,7 +235,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";
@@ -1587,6 +1592,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 {
@@ -2721,7 +2727,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;
diff --git a/hw/vfio/pci.c b/hw/vfio/pci.c
index 2e0e41d..027f9d5 100644
--- a/hw/vfio/pci.c
+++ b/hw/vfio/pci.c
@@ -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"
@@ -1704,6 +1704,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)
@@ -3494,6 +3497,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(proxy, &err);
if (err != NULL) {
@@ -3540,6 +3546,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(),
};
diff --git a/hw/vfio/pci.h b/hw/vfio/pci.h
index c47d2f8..ec17f2e 100644
--- a/hw/vfio/pci.h
+++ b/hw/vfio/pci.h
@@ -196,6 +196,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 */
diff --git a/hw/vfio/user-protocol.h b/hw/vfio/user-protocol.h
index a1b64fe..124340c 100644
--- a/hw/vfio/user-protocol.h
+++ b/hw/vfio/user-protocol.h
@@ -140,4 +140,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 */
diff --git a/hw/vfio/user.c b/hw/vfio/user.c
index 69b0fed..1453bb5 100644
--- a/hw/vfio/user.c
+++ b/hw/vfio/user.c
@@ -57,6 +57,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,
@@ -618,6 +620,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)
{
@@ -1135,6 +1164,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 > proxy->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 > proxy->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-based io_ops
@@ -1184,8 +1277,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,
};
diff --git a/hw/vfio/user.h b/hw/vfio/user.h
index 2547cf6..359a029 100644
--- a/hw/vfio/user.h
+++ b/hw/vfio/user.h
@@ -84,6 +84,7 @@ typedef struct VFIOProxy {
/* VFIOProxy flags */
#define VFIO_PROXY_CLIENT 0x1
#define VFIO_PROXY_FORCE_QUEUED 0x4
+#define VFIO_PROXY_NO_POST 0x8
VFIOProxy *vfio_user_connect_dev(SocketAddress *addr, Error **errp);
void vfio_user_disconnect(VFIOProxy *proxy);
diff --git a/include/hw/vfio/vfio-common.h b/include/hw/vfio/vfio-common.h
index 3406e6a..6324132 100644
--- a/include/hw/vfio/vfio-common.h
+++ b/include/hw/vfio/vfio-common.h
@@ -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,
--
1.8.3.1
^ permalink raw reply related [flat|nested] 82+ messages in thread
* [PATCH v1 13/24] vfio-user: pci_user_realize PCI setup
2022-11-08 23:13 [PATCH v1 00/24] vfio-user client John Johnson
` (11 preceding siblings ...)
2022-11-08 23:13 ` [PATCH v1 12/24] vfio-user: region read/write John Johnson
@ 2022-11-08 23:13 ` John Johnson
2022-12-09 17:22 ` John Levon
2022-12-13 16:13 ` Cédric Le Goater
2022-11-08 23:13 ` [PATCH v1 14/24] vfio-user: get and set IRQs John Johnson
` (12 subsequent siblings)
25 siblings, 2 replies; 82+ messages in thread
From: John Johnson @ 2022-11-08 23:13 UTC (permalink / raw)
To: qemu-devel
PCI BARs read from remote device
PCI config reads/writes sent to remote server
Signed-off-by: Elena Ufimtseva <elena.ufimtseva@oracle.com>
Signed-off-by: John G Johnson <john.g.johnson@oracle.com>
Signed-off-by: Jagannathan Raman <jag.raman@oracle.com>
---
hw/vfio/pci.c | 277 ++++++++++++++++++++++++++++++++++++----------------------
1 file changed, 174 insertions(+), 103 deletions(-)
diff --git a/hw/vfio/pci.c b/hw/vfio/pci.c
index 027f9d5..7abe44e 100644
--- a/hw/vfio/pci.c
+++ b/hw/vfio/pci.c
@@ -2874,6 +2874,133 @@ 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;
+ VFIODevice *vbasedev = &vdev->vbasedev;
+ 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(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(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(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);
@@ -2990,92 +3117,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(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(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(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(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) {
@@ -3116,29 +3167,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);
@@ -3525,8 +3562,42 @@ 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) {
+ error_propagate(errp, 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:
error_prepend(errp, VFIO_MSG_PREFIX, vdev->vbasedev.name);
}
--
1.8.3.1
^ permalink raw reply related [flat|nested] 82+ messages in thread
* [PATCH v1 14/24] vfio-user: get and set IRQs
2022-11-08 23:13 [PATCH v1 00/24] vfio-user client John Johnson
` (12 preceding siblings ...)
2022-11-08 23:13 ` [PATCH v1 13/24] vfio-user: pci_user_realize PCI setup John Johnson
@ 2022-11-08 23:13 ` John Johnson
2022-12-09 17:29 ` John Levon
2022-12-13 16:39 ` Cédric Le Goater
2022-11-08 23:13 ` [PATCH v1 15/24] vfio-user: forward msix BAR accesses to server John Johnson
` (11 subsequent siblings)
25 siblings, 2 replies; 82+ messages in thread
From: John Johnson @ 2022-11-08 23:13 UTC (permalink / raw)
To: qemu-devel
Signed-off-by: Elena Ufimtseva <elena.ufimtseva@oracle.com>
Signed-off-by: John G Johnson <john.g.johnson@oracle.com>
Signed-off-by: Jagannathan Raman <jag.raman@oracle.com>
---
hw/vfio/pci.c | 7 ++-
hw/vfio/user-protocol.h | 25 +++++++++
hw/vfio/user.c | 135 ++++++++++++++++++++++++++++++++++++++++++++++++
3 files changed, 166 insertions(+), 1 deletion(-)
diff --git a/hw/vfio/pci.c b/hw/vfio/pci.c
index 7abe44e..be39a4e 100644
--- a/hw/vfio/pci.c
+++ b/hw/vfio/pci.c
@@ -713,7 +713,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 {
error_report("vfio: Error: Failed to enable %d "
"MSI vectors, retry with %d", vdev->nr_vectors, ret);
@@ -2712,6 +2713,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));
@@ -3593,6 +3595,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:
diff --git a/hw/vfio/user-protocol.h b/hw/vfio/user-protocol.h
index 124340c..31704cf 100644
--- a/hw/vfio/user-protocol.h
+++ b/hw/vfio/user-protocol.h
@@ -141,6 +141,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
*/
diff --git a/hw/vfio/user.c b/hw/vfio/user.c
index 1453bb5..815385b 100644
--- a/hw/vfio/user.c
+++ b/hw/vfio/user.c
@@ -1164,6 +1164,117 @@ static int vfio_user_get_region_info(VFIOProxy *proxy,
return 0;
}
+static int vfio_user_get_irq_info(VFIOProxy *proxy,
+ struct vfio_irq_info *info)
+{
+ VFIOUserIRQInfo msg;
+
+ memset(&msg, 0, sizeof(msg));
+ vfio_user_request_msg(&msg.hdr, VFIO_USER_DEVICE_GET_IRQ_INFO,
+ sizeof(msg), 0);
+ msg.argsz = info->argsz;
+ msg.index = info->index;
+
+ vfio_user_send_wait(proxy, &msg.hdr, NULL, 0, false);
+ if (msg.hdr.flags & VFIO_USER_ERROR) {
+ return -msg.hdr.error_reply;
+ }
+
+ memcpy(info, &msg.argsz, sizeof(*info));
+ return 0;
+}
+
+static int irq_howmany(int *fdp, uint32_t cur, uint32_t max)
+{
+ int n = 0;
+
+ if (fdp[cur] != -1) {
+ do {
+ n++;
+ } while (n < max && fdp[cur + n] != -1);
+ } else {
+ do {
+ n++;
+ } while (n < max && fdp[cur + n] == -1);
+ }
+
+ return n;
+}
+
+static int vfio_user_set_irqs(VFIOProxy *proxy, struct vfio_irq_set *irq)
+{
+ g_autofree VFIOUserIRQSet *msgp = NULL;
+ uint32_t size, nfds, send_fds, sent_fds, max;
+
+ if (irq->argsz < sizeof(*irq)) {
+ error_printf("vfio_user_set_irqs argsz too small\n");
+ return -EINVAL;
+ }
+
+ /*
+ * Handle simple case
+ */
+ if ((irq->flags & VFIO_IRQ_SET_DATA_EVENTFD) == 0) {
+ size = sizeof(VFIOUserHdr) + irq->argsz;
+ msgp = g_malloc0(size);
+
+ vfio_user_request_msg(&msgp->hdr, VFIO_USER_DEVICE_SET_IRQS, size, 0);
+ msgp->argsz = irq->argsz;
+ msgp->flags = irq->flags;
+ msgp->index = irq->index;
+ msgp->start = irq->start;
+ msgp->count = irq->count;
+
+ vfio_user_send_wait(proxy, &msgp->hdr, NULL, 0, false);
+ if (msgp->hdr.flags & VFIO_USER_ERROR) {
+ return -msgp->hdr.error_reply;
+ }
+
+ return 0;
+ }
+
+ /*
+ * Calculate the number of FDs to send
+ * and adjust argsz
+ */
+ nfds = (irq->argsz - sizeof(*irq)) / sizeof(int);
+ irq->argsz = sizeof(*irq);
+ msgp = g_malloc0(sizeof(*msgp));
+ /*
+ * Send in chunks if over max_send_fds
+ */
+ for (sent_fds = 0; nfds > sent_fds; sent_fds += send_fds) {
+ VFIOUserFDs *arg_fds, loop_fds;
+
+ /* must send all valid FDs or all invalid FDs in single msg */
+ max = nfds - sent_fds;
+ if (max > proxy->max_send_fds) {
+ max = proxy->max_send_fds;
+ }
+ send_fds = irq_howmany((int *)irq->data, sent_fds, max);
+
+ vfio_user_request_msg(&msgp->hdr, VFIO_USER_DEVICE_SET_IRQS,
+ sizeof(*msgp), 0);
+ msgp->argsz = irq->argsz;
+ msgp->flags = irq->flags;
+ msgp->index = irq->index;
+ msgp->start = irq->start + sent_fds;
+ msgp->count = send_fds;
+
+ loop_fds.send_fds = send_fds;
+ loop_fds.recv_fds = 0;
+ loop_fds.fds = (int *)irq->data + sent_fds;
+ arg_fds = loop_fds.fds[0] != -1 ? &loop_fds : NULL;
+
+ vfio_user_send_wait(proxy, &msgp->hdr, arg_fds, 0, false);
+ if (msgp->hdr.flags & VFIO_USER_ERROR) {
+ return -msgp->hdr.error_reply;
+ }
+ }
+
+ return 0;
+}
+
static int vfio_user_region_read(VFIOProxy *proxy, uint8_t index, off_t offset,
uint32_t count, void *data)
{
@@ -1277,6 +1388,28 @@ static int vfio_user_io_get_region_info(VFIODevice *vbasedev,
return 0;
}
+static int vfio_user_io_get_irq_info(VFIODevice *vbasedev,
+ struct vfio_irq_info *irq)
+{
+ int ret;
+
+ ret = vfio_user_get_irq_info(vbasedev->proxy, irq);
+ if (ret) {
+ return ret;
+ }
+
+ if (irq->index > vbasedev->num_irqs) {
+ return -EINVAL;
+ }
+ return 0;
+}
+
+static int vfio_user_io_set_irqs(VFIODevice *vbasedev,
+ struct vfio_irq_set *irqs)
+{
+ return vfio_user_set_irqs(vbasedev->proxy, irqs);
+}
+
static int vfio_user_io_region_read(VFIODevice *vbasedev, uint8_t index,
off_t off, uint32_t size, void *data)
{
@@ -1294,6 +1427,8 @@ static int vfio_user_io_region_write(VFIODevice *vbasedev, uint8_t index,
VFIODevIO vfio_dev_io_sock = {
.get_info = vfio_user_io_get_info,
.get_region_info = vfio_user_io_get_region_info,
+ .get_irq_info = vfio_user_io_get_irq_info,
+ .set_irqs = vfio_user_io_set_irqs,
.region_read = vfio_user_io_region_read,
.region_write = vfio_user_io_region_write,
};
--
1.8.3.1
^ permalink raw reply related [flat|nested] 82+ messages in thread
* [PATCH v1 15/24] vfio-user: forward msix BAR accesses to server
2022-11-08 23:13 [PATCH v1 00/24] vfio-user client John Johnson
` (13 preceding siblings ...)
2022-11-08 23:13 ` [PATCH v1 14/24] vfio-user: get and set IRQs John Johnson
@ 2022-11-08 23:13 ` John Johnson
2022-12-09 17:45 ` John Levon
2022-12-14 17:00 ` Cédric Le Goater
2022-11-08 23:13 ` [PATCH v1 16/24] vfio-user: proxy container connect/disconnect John Johnson
` (10 subsequent siblings)
25 siblings, 2 replies; 82+ messages in thread
From: John Johnson @ 2022-11-08 23:13 UTC (permalink / raw)
To: qemu-devel
Server holds device current device pending state
Use irq masking commands in socket case
Signed-off-by: John G Johnson <john.g.johnson@oracle.com>
Signed-off-by: Elena Ufimtseva <elena.ufimtseva@oracle.com>
Signed-off-by: Jagannathan Raman <jag.raman@oracle.com>
---
hw/vfio/ccw.c | 1 +
hw/vfio/common.c | 26 +++++++++++++
hw/vfio/pci.c | 87 ++++++++++++++++++++++++++++++++++++++++++-
hw/vfio/pci.h | 1 +
hw/vfio/platform.c | 1 +
include/hw/vfio/vfio-common.h | 3 ++
6 files changed, 118 insertions(+), 1 deletion(-)
diff --git a/hw/vfio/ccw.c b/hw/vfio/ccw.c
index cbd1c25..830ca53 100644
--- a/hw/vfio/ccw.c
+++ b/hw/vfio/ccw.c
@@ -615,6 +615,7 @@ static void vfio_ccw_get_device(VFIOGroup *group, VFIOCCWDevice *vcdev,
vcdev->vdev.name = name;
vcdev->vdev.dev = &vcdev->cdev.parent_obj.parent_obj;
vcdev->vdev.io_ops = &vfio_dev_io_ioctl;
+ vcdev->vdev.irq_mask_works = false;
return;
diff --git a/hw/vfio/common.c b/hw/vfio/common.c
index 87cd1d1..b540195 100644
--- a/hw/vfio/common.c
+++ b/hw/vfio/common.c
@@ -101,6 +101,32 @@ void vfio_mask_single_irqindex(VFIODevice *vbasedev, int index)
VDEV_SET_IRQS(vbasedev, &irq_set);
}
+void vfio_mask_single_irq(VFIODevice *vbasedev, int index, int irq)
+{
+ struct vfio_irq_set irq_set = {
+ .argsz = sizeof(irq_set),
+ .flags = VFIO_IRQ_SET_DATA_NONE | VFIO_IRQ_SET_ACTION_MASK,
+ .index = index,
+ .start = irq,
+ .count = 1,
+ };
+
+ VDEV_SET_IRQS(vbasedev, &irq_set);
+}
+
+void vfio_unmask_single_irq(VFIODevice *vbasedev, int index, int irq)
+{
+ struct vfio_irq_set irq_set = {
+ .argsz = sizeof(irq_set),
+ .flags = VFIO_IRQ_SET_DATA_NONE | VFIO_IRQ_SET_ACTION_UNMASK,
+ .index = index,
+ .start = irq,
+ .count = 1,
+ };
+
+ VDEV_SET_IRQS(vbasedev, &irq_set);
+}
+
static inline const char *action_to_str(int action)
{
switch (action) {
diff --git a/hw/vfio/pci.c b/hw/vfio/pci.c
index be39a4e..a1ae3fb 100644
--- a/hw/vfio/pci.c
+++ b/hw/vfio/pci.c
@@ -479,6 +479,7 @@ static int vfio_msix_vector_do_use(PCIDevice *pdev, unsigned int nr,
{
VFIOPCIDevice *vdev = VFIO_PCI_BASE(pdev);
VFIOMSIVector *vector;
+ bool new_vec = false;
int ret;
trace_vfio_msix_vector_do_use(vdev->vbasedev.name, nr);
@@ -492,6 +493,7 @@ static int vfio_msix_vector_do_use(PCIDevice *pdev, unsigned int nr,
error_report("vfio: Error: event_notifier_init failed");
}
vector->use = true;
+ new_vec = true;
msix_vector_use(pdev, nr);
}
@@ -518,6 +520,7 @@ static int vfio_msix_vector_do_use(PCIDevice *pdev, unsigned int nr,
kvm_irqchip_commit_route_changes(&vfio_route_change);
vfio_connect_kvm_msi_virq(vector);
}
+ new_vec = true;
}
}
@@ -525,6 +528,8 @@ static int vfio_msix_vector_do_use(PCIDevice *pdev, unsigned int nr,
* We don't want to have the host allocate all possible MSI vectors
* for a device if they're not in use, so we shutdown and incrementally
* increase them as needed.
+ * Otherwise, unmask the vector if the vector is already setup (and we can
+ * do so) or send the fd if not.
*/
if (vdev->nr_vectors < nr + 1) {
vdev->nr_vectors = nr + 1;
@@ -535,6 +540,8 @@ static int vfio_msix_vector_do_use(PCIDevice *pdev, unsigned int nr,
error_report("vfio: failed to enable vectors, %d", ret);
}
}
+ } else if (vdev->vbasedev.irq_mask_works && !new_vec) {
+ vfio_unmask_single_irq(&vdev->vbasedev, VFIO_PCI_MSIX_IRQ_INDEX, nr);
} else {
Error *err = NULL;
int32_t fd;
@@ -576,6 +583,12 @@ static void vfio_msix_vector_release(PCIDevice *pdev, unsigned int nr)
trace_vfio_msix_vector_release(vdev->vbasedev.name, nr);
+ /* just mask vector if peer supports it */
+ if (vdev->vbasedev.irq_mask_works) {
+ vfio_mask_single_irq(&vdev->vbasedev, VFIO_PCI_MSIX_IRQ_INDEX, nr);
+ return;
+ }
+
/*
* There are still old guests that mask and unmask vectors on every
* interrupt. If we're using QEMU bypass with a KVM irqfd, leave all of
@@ -646,7 +659,7 @@ static void vfio_msix_enable(VFIOPCIDevice *vdev)
if (ret) {
error_report("vfio: failed to enable vectors, %d", ret);
}
- } else {
+ } else if (!vdev->vbasedev.irq_mask_works) {
/*
* Some communication channels between VF & PF or PF & fw rely on the
* physical state of the device and expect that enabling MSI-X from the
@@ -662,6 +675,13 @@ static void vfio_msix_enable(VFIOPCIDevice *vdev)
*/
vfio_msix_vector_do_use(&vdev->pdev, 0, NULL, NULL);
vfio_msix_vector_release(&vdev->pdev, 0);
+ } else {
+ /*
+ * If we can use irq masking, send an invalid fd on vector 0
+ * to enable MSI-X without any vectors enabled.
+ */
+ vfio_set_irq_signaling(&vdev->vbasedev, VFIO_PCI_MSIX_IRQ_INDEX, 0,
+ VFIO_IRQ_SET_ACTION_TRIGGER, -1, NULL);
}
trace_vfio_msix_enable(vdev->vbasedev.name);
@@ -3042,6 +3062,7 @@ static void vfio_realize(PCIDevice *pdev, Error **errp)
vbasedev->type = VFIO_DEVICE_TYPE_PCI;
vbasedev->dev = DEVICE(vdev);
vbasedev->io_ops = &vfio_dev_io_ioctl;
+ vbasedev->irq_mask_works = false;
tmp = g_strdup_printf("%s/iommu_group", vbasedev->sysfsdev);
len = readlink(tmp, group_path, sizeof(group_path));
@@ -3474,6 +3495,62 @@ type_init(register_vfio_pci_dev_type)
*/
/*
+ * The server maintains the device's pending interrupts,
+ * via its MSIX table and PBA, so we treat these acceses
+ * like PCI config space and forward them.
+ */
+static uint64_t vfio_user_pba_read(void *opaque, hwaddr addr,
+ unsigned size)
+{
+ VFIOPCIDevice *vdev = opaque;
+ VFIORegion *region = &vdev->bars[vdev->msix->pba_bar].region;
+ uint64_t data;
+
+ /* server copy is what matters */
+ data = vfio_region_read(region, addr + vdev->msix->pba_offset, size);
+ return data;
+}
+
+static void vfio_user_pba_write(void *opaque, hwaddr addr,
+ uint64_t data, unsigned size)
+{
+ /* dropped */
+}
+
+static const MemoryRegionOps vfio_user_pba_ops = {
+ .read = vfio_user_pba_read,
+ .write = vfio_user_pba_write,
+ .endianness = DEVICE_LITTLE_ENDIAN,
+};
+
+static void vfio_user_msix_setup(VFIOPCIDevice *vdev)
+{
+ MemoryRegion *vfio_reg, *msix_reg, *pba_reg;
+
+ pba_reg = g_new0(MemoryRegion, 1);
+ vdev->msix->pba_region = pba_reg;
+
+ vfio_reg = vdev->bars[vdev->msix->pba_bar].mr;
+ msix_reg = &vdev->pdev.msix_pba_mmio;
+ memory_region_init_io(pba_reg, OBJECT(vdev), &vfio_user_pba_ops, vdev,
+ "VFIO MSIX PBA", int128_get64(msix_reg->size));
+ memory_region_add_subregion_overlap(vfio_reg, vdev->msix->pba_offset,
+ pba_reg, 1);
+}
+
+static void vfio_user_msix_teardown(VFIOPCIDevice *vdev)
+{
+ MemoryRegion *mr, *sub;
+
+ mr = vdev->bars[vdev->msix->pba_bar].mr;
+ sub = vdev->msix->pba_region;
+ memory_region_del_subregion(mr, sub);
+
+ g_free(vdev->msix->pba_region);
+ vdev->msix->pba_region = NULL;
+}
+
+/*
* Incoming request message callback.
*
* Runs off main loop, so BQL held.
@@ -3551,6 +3628,7 @@ static void vfio_user_pci_realize(PCIDevice *pdev, Error **errp)
vbasedev->type = VFIO_DEVICE_TYPE_PCI;
vbasedev->dev = DEVICE(vdev);
vbasedev->io_ops = &vfio_dev_io_sock;
+ vdev->vbasedev.irq_mask_works = true;
ret = VDEV_GET_INFO(vbasedev, &info);
if (ret) {
@@ -3589,6 +3667,9 @@ static void vfio_user_pci_realize(PCIDevice *pdev, Error **errp)
if (ret) {
goto out_teardown;
}
+ if (vdev->msix != NULL) {
+ vfio_user_msix_setup(vdev);
+ }
ret = vfio_interrupt_setup(vdev, errp);
if (ret) {
@@ -3612,6 +3693,10 @@ static void vfio_user_instance_finalize(Object *obj)
VFIOPCIDevice *vdev = VFIO_PCI_BASE(obj);
VFIODevice *vbasedev = &vdev->vbasedev;
+ if (vdev->msix != NULL) {
+ vfio_user_msix_teardown(vdev);
+ }
+
vfio_put_device(vdev);
if (vbasedev->proxy != NULL) {
diff --git a/hw/vfio/pci.h b/hw/vfio/pci.h
index ec17f2e..c04fa58 100644
--- a/hw/vfio/pci.h
+++ b/hw/vfio/pci.h
@@ -113,6 +113,7 @@ typedef struct VFIOMSIXInfo {
uint32_t table_offset;
uint32_t pba_offset;
unsigned long *pending;
+ MemoryRegion *pba_region;
} VFIOMSIXInfo;
/*
diff --git a/hw/vfio/platform.c b/hw/vfio/platform.c
index c136b09..ccf1df7 100644
--- a/hw/vfio/platform.c
+++ b/hw/vfio/platform.c
@@ -622,6 +622,7 @@ static void vfio_platform_realize(DeviceState *dev, Error **errp)
vbasedev->dev = dev;
vbasedev->ops = &vfio_platform_ops;
vbasedev->io_ops = &vfio_dev_io_ioctl;
+ vbasedev->irq_mask_works = false;
qemu_mutex_init(&vdev->intp_mutex);
diff --git a/include/hw/vfio/vfio-common.h b/include/hw/vfio/vfio-common.h
index 6324132..793ca94 100644
--- a/include/hw/vfio/vfio-common.h
+++ b/include/hw/vfio/vfio-common.h
@@ -142,6 +142,7 @@ typedef struct VFIODevice {
bool no_mmap;
bool ram_block_discard_allowed;
bool enable_migration;
+ bool irq_mask_works;
VFIODeviceOps *ops;
VFIODevIO *io_ops;
unsigned int num_irqs;
@@ -260,6 +261,8 @@ void vfio_put_base_device(VFIODevice *vbasedev);
void vfio_disable_irqindex(VFIODevice *vbasedev, int index);
void vfio_unmask_single_irqindex(VFIODevice *vbasedev, int index);
void vfio_mask_single_irqindex(VFIODevice *vbasedev, int index);
+void vfio_unmask_single_irq(VFIODevice *vbasedev, int index, int irq);
+void vfio_mask_single_irq(VFIODevice *vbasedev, int index, int irq);
int vfio_set_irq_signaling(VFIODevice *vbasedev, int index, int subindex,
int action, int fd, Error **errp);
void vfio_region_write(void *opaque, hwaddr addr,
--
1.8.3.1
^ permalink raw reply related [flat|nested] 82+ messages in thread
* [PATCH v1 16/24] vfio-user: proxy container connect/disconnect
2022-11-08 23:13 [PATCH v1 00/24] vfio-user client John Johnson
` (14 preceding siblings ...)
2022-11-08 23:13 ` [PATCH v1 15/24] vfio-user: forward msix BAR accesses to server John Johnson
@ 2022-11-08 23:13 ` John Johnson
2022-12-09 17:54 ` John Levon
2022-12-14 17:59 ` Cédric Le Goater
2022-11-08 23:13 ` [PATCH v1 17/24] vfio-user: dma map/unmap operations John Johnson
` (9 subsequent siblings)
25 siblings, 2 replies; 82+ messages in thread
From: John Johnson @ 2022-11-08 23:13 UTC (permalink / raw)
To: qemu-devel
Signed-off-by: Elena Ufimtseva <elena.ufimtseva@oracle.com>
Signed-off-by: John G Johnson <john.g.johnson@oracle.com>
Signed-off-by: Jagannathan Raman <jag.raman@oracle.com>
---
hw/vfio/common.c | 207 +++++++++++++++++++++++++++++++++++++++++-
hw/vfio/pci.c | 18 +++-
hw/vfio/user.c | 3 +
hw/vfio/user.h | 1 +
include/hw/vfio/vfio-common.h | 6 ++
5 files changed, 231 insertions(+), 4 deletions(-)
diff --git a/hw/vfio/common.c b/hw/vfio/common.c
index b540195..e73a772 100644
--- a/hw/vfio/common.c
+++ b/hw/vfio/common.c
@@ -19,6 +19,7 @@
*/
#include "qemu/osdep.h"
+#include CONFIG_DEVICES
#include <sys/ioctl.h>
#ifdef CONFIG_KVM
#include <linux/kvm.h>
@@ -2267,6 +2268,208 @@ put_space_exit:
return ret;
}
+
+#ifdef CONFIG_VFIO_USER
+
+static int vfio_connect_proxy(VFIOProxy *proxy, VFIOGroup *group,
+ AddressSpace *as, Error **errp)
+{
+ VFIOAddressSpace *space;
+ VFIOContainer *container;
+ int ret;
+
+ /*
+ * try to mirror vfio_connect_container()
+ * as much as possible
+ */
+
+ space = vfio_get_address_space(as);
+
+ container = g_malloc0(sizeof(*container));
+ container->space = space;
+ container->fd = -1;
+ container->error = NULL;
+ container->io_ops = &vfio_cont_io_sock;
+ QLIST_INIT(&container->giommu_list);
+ QLIST_INIT(&container->hostwin_list);
+ QLIST_INIT(&container->vrdl_list);
+ container->proxy = proxy;
+
+ /*
+ * The proxy uses a SW IOMMU in lieu of the HW one
+ * used in the ioctl() version. Mascarade as TYPE1
+ * for maximum capatibility
+ */
+ container->iommu_type = VFIO_TYPE1_IOMMU;
+
+ /*
+ * VFIO user allows the device server to map guest
+ * memory so it has the same issue with discards as
+ * a local IOMMU has.
+ */
+ ret = vfio_ram_block_discard_disable(container, true);
+ if (ret) {
+ error_setg_errno(errp, -ret, "Cannot set discarding of RAM broken");
+ goto free_container_exit;
+ }
+
+ vfio_host_win_add(container, 0, (hwaddr)-1, proxy->dma_pgsizes);
+ container->pgsizes = proxy->dma_pgsizes;
+ container->dma_max_mappings = proxy->max_dma;
+
+ /* setup bitmask now, but migration support won't be ready until v2 */
+ container->dirty_pages_supported = true;
+ container->max_dirty_bitmap_size = proxy->max_bitmap;
+ container->dirty_pgsizes = proxy->migr_pgsize;
+
+ QLIST_INIT(&container->group_list);
+ QLIST_INSERT_HEAD(&space->containers, container, next);
+
+ group->container = container;
+ QLIST_INSERT_HEAD(&container->group_list, group, container_next);
+
+ container->listener = vfio_memory_listener;
+ memory_listener_register(&container->listener, container->space->as);
+
+ if (container->error) {
+ ret = -1;
+ error_propagate_prepend(errp, container->error,
+ "memory listener initialization failed: ");
+ goto listener_release_exit;
+ }
+
+ container->initialized = true;
+
+ return 0;
+
+listener_release_exit:
+ QLIST_REMOVE(group, container_next);
+ QLIST_REMOVE(container, next);
+ vfio_listener_release(container);
+ vfio_ram_block_discard_disable(container, false);
+
+free_container_exit:
+ g_free(container);
+
+ vfio_put_address_space(space);
+
+ return ret;
+}
+
+static void vfio_disconnect_proxy(VFIOGroup *group)
+{
+ VFIOContainer *container = group->container;
+ VFIOAddressSpace *space = container->space;
+ VFIOGuestIOMMU *giommu, *tmp;
+ VFIOHostDMAWindow *hostwin, *next;
+
+ /*
+ * try to mirror vfio_disconnect_container()
+ * as much as possible, knowing each device
+ * is in one group and one container
+ */
+
+ QLIST_REMOVE(group, container_next);
+ group->container = NULL;
+
+ /*
+ * Explicitly release the listener first before unset container,
+ * since unset may destroy the backend container if it's the last
+ * group.
+ */
+ memory_listener_unregister(&container->listener);
+
+ QLIST_REMOVE(container, next);
+
+ QLIST_FOREACH_SAFE(giommu, &container->giommu_list, giommu_next, tmp) {
+ memory_region_unregister_iommu_notifier(
+ MEMORY_REGION(giommu->iommu_mr), &giommu->n);
+ QLIST_REMOVE(giommu, giommu_next);
+ g_free(giommu);
+ }
+
+ QLIST_FOREACH_SAFE(hostwin, &container->hostwin_list, hostwin_next,
+ next) {
+ QLIST_REMOVE(hostwin, hostwin_next);
+ g_free(hostwin);
+ }
+
+ g_free(container);
+ vfio_put_address_space(space);
+}
+
+int vfio_user_get_device(VFIOGroup *group, VFIODevice *vbasedev, Error **errp)
+{
+ struct vfio_device_info info = { .argsz = sizeof(info) };
+ int ret;
+
+ ret = VDEV_GET_INFO(vbasedev, &info);
+ if (ret) {
+ error_setg_errno(errp, -ret, "get info failure");
+ return ret;
+ }
+
+ vbasedev->fd = -1;
+ vbasedev->group = group;
+ QLIST_INSERT_HEAD(&group->device_list, vbasedev, next);
+
+ vbasedev->num_irqs = info.num_irqs;
+ vbasedev->num_regions = info.num_regions;
+ vbasedev->flags = info.flags;
+
+ vfio_get_all_regions(vbasedev);
+ vbasedev->reset_works = !!(info.flags & VFIO_DEVICE_FLAGS_RESET);
+ return 0;
+}
+
+VFIOGroup *vfio_user_get_group(VFIOProxy *proxy, AddressSpace *as, Error **errp)
+{
+ VFIOGroup *group;
+
+ /*
+ * Mirror vfio_get_group(), except that each
+ * device gets its own group and container,
+ * unrelated to any host IOMMU groupings
+ */
+ group = g_malloc0(sizeof(*group));
+ group->fd = -1;
+ group->groupid = -1;
+ QLIST_INIT(&group->device_list);
+
+ if (vfio_connect_proxy(proxy, group, as, errp)) {
+ error_prepend(errp, "failed to connect proxy");
+ g_free(group);
+ group = NULL;
+ }
+
+ if (QLIST_EMPTY(&vfio_group_list)) {
+ qemu_register_reset(vfio_reset_handler, NULL);
+ }
+
+ QLIST_INSERT_HEAD(&vfio_group_list, group, next);
+
+ return group;
+}
+
+void vfio_user_put_group(VFIOGroup *group)
+{
+ if (!group || !QLIST_EMPTY(&group->device_list)) {
+ return;
+ }
+
+ vfio_ram_block_discard_disable(group->container, false);
+ vfio_disconnect_proxy(group);
+ QLIST_REMOVE(group, next);
+ g_free(group);
+
+ if (QLIST_EMPTY(&vfio_group_list)) {
+ qemu_unregister_reset(vfio_reset_handler, NULL);
+ }
+}
+
+#endif /* CONFIG_VFIO_USER */
+
+
static void vfio_disconnect_container(VFIOGroup *group)
{
VFIOContainer *container = group->container;
@@ -2499,7 +2702,9 @@ void vfio_put_base_device(VFIODevice *vbasedev)
QLIST_REMOVE(vbasedev, next);
vbasedev->group = NULL;
trace_vfio_put_base_device(vbasedev->fd);
- close(vbasedev->fd);
+ if (vbasedev->fd != -1) {
+ close(vbasedev->fd);
+ }
}
int vfio_get_region_info(VFIODevice *vbasedev, int index,
diff --git a/hw/vfio/pci.c b/hw/vfio/pci.c
index a1ae3fb..53e3bb8 100644
--- a/hw/vfio/pci.c
+++ b/hw/vfio/pci.c
@@ -3584,7 +3584,7 @@ static void vfio_user_pci_realize(PCIDevice *pdev, Error **errp)
VFIODevice *vbasedev = &vdev->vbasedev;
SocketAddress addr;
VFIOProxy *proxy;
- struct vfio_device_info info;
+ VFIOGroup *group = NULL;
int ret;
Error *err = NULL;
@@ -3630,9 +3630,15 @@ static void vfio_user_pci_realize(PCIDevice *pdev, Error **errp)
vbasedev->io_ops = &vfio_dev_io_sock;
vdev->vbasedev.irq_mask_works = true;
- ret = VDEV_GET_INFO(vbasedev, &info);
+ group = vfio_user_get_group(proxy, pci_device_iommu_address_space(pdev),
+ errp);
+ if (!group) {
+ goto error;
+ }
+
+ ret = vfio_user_get_device(group, vbasedev, errp);
if (ret) {
- error_setg_errno(errp, -ret, "get info failure");
+ vfio_user_put_group(group);
goto error;
}
@@ -3692,12 +3698,18 @@ static void vfio_user_instance_finalize(Object *obj)
{
VFIOPCIDevice *vdev = VFIO_PCI_BASE(obj);
VFIODevice *vbasedev = &vdev->vbasedev;
+ VFIOGroup *group = vbasedev->group;
+
+ vfio_bars_finalize(vdev);
+ g_free(vdev->emulated_config_bits);
+ g_free(vdev->rom);
if (vdev->msix != NULL) {
vfio_user_msix_teardown(vdev);
}
vfio_put_device(vdev);
+ vfio_user_put_group(group);
if (vbasedev->proxy != NULL) {
vfio_user_disconnect(vbasedev->proxy);
diff --git a/hw/vfio/user.c b/hw/vfio/user.c
index 815385b..2d35f83 100644
--- a/hw/vfio/user.c
+++ b/hw/vfio/user.c
@@ -1433,3 +1433,6 @@ VFIODevIO vfio_dev_io_sock = {
.region_write = vfio_user_io_region_write,
};
+
+VFIOContIO vfio_cont_io_sock = {
+};
diff --git a/hw/vfio/user.h b/hw/vfio/user.h
index 359a029..19b8a29 100644
--- a/hw/vfio/user.h
+++ b/hw/vfio/user.h
@@ -94,5 +94,6 @@ void vfio_user_set_handler(VFIODevice *vbasedev,
int vfio_user_validate_version(VFIOProxy *proxy, Error **errp);
extern VFIODevIO vfio_dev_io_sock;
+extern VFIOContIO vfio_cont_io_sock;
#endif /* VFIO_USER_H */
diff --git a/include/hw/vfio/vfio-common.h b/include/hw/vfio/vfio-common.h
index 793ca94..312ef9c 100644
--- a/include/hw/vfio/vfio-common.h
+++ b/include/hw/vfio/vfio-common.h
@@ -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;
@@ -282,6 +283,11 @@ void vfio_put_group(VFIOGroup *group);
int vfio_get_device(VFIOGroup *group, const char *name,
VFIODevice *vbasedev, Error **errp);
+int vfio_user_get_device(VFIOGroup *group, VFIODevice *vbasedev, Error **errp);
+VFIOGroup *vfio_user_get_group(VFIOProxy *proxy, AddressSpace *as,
+ Error **errp);
+void vfio_user_put_group(VFIOGroup *group);
+
extern const MemoryRegionOps vfio_region_ops;
typedef QLIST_HEAD(VFIOGroupList, VFIOGroup) VFIOGroupList;
extern VFIOGroupList vfio_group_list;
--
1.8.3.1
^ permalink raw reply related [flat|nested] 82+ messages in thread
* [PATCH v1 17/24] vfio-user: dma map/unmap operations
2022-11-08 23:13 [PATCH v1 00/24] vfio-user client John Johnson
` (15 preceding siblings ...)
2022-11-08 23:13 ` [PATCH v1 16/24] vfio-user: proxy container connect/disconnect John Johnson
@ 2022-11-08 23:13 ` John Johnson
2022-12-15 12:39 ` Cédric Le Goater
2022-11-08 23:13 ` [PATCH v1 18/24] vfio-user: add dma_unmap_all John Johnson
` (8 subsequent siblings)
25 siblings, 1 reply; 82+ messages in thread
From: John Johnson @ 2022-11-08 23:13 UTC (permalink / raw)
To: qemu-devel
Add ability to do async operations during memory transactions
Signed-off-by: Jagannathan Raman <jag.raman@oracle.com>
Signed-off-by: Elena Ufimtseva <elena.ufimtseva@oracle.com>
Signed-off-by: John G Johnson <john.g.johnson@oracle.com>
---
hw/vfio/common.c | 63 +++++++++---
hw/vfio/user-protocol.h | 32 ++++++
hw/vfio/user.c | 220 ++++++++++++++++++++++++++++++++++++++++++
include/hw/vfio/vfio-common.h | 9 +-
4 files changed, 308 insertions(+), 16 deletions(-)
diff --git a/hw/vfio/common.c b/hw/vfio/common.c
index e73a772..fe6eddd 100644
--- a/hw/vfio/common.c
+++ b/hw/vfio/common.c
@@ -507,7 +507,7 @@ static int vfio_dma_unmap(VFIOContainer *container,
return CONT_DMA_UNMAP(container, &unmap, NULL);
}
-static int vfio_dma_map(VFIOContainer *container, hwaddr iova,
+static int vfio_dma_map(VFIOContainer *container, MemoryRegion *mr, hwaddr iova,
ram_addr_t size, void *vaddr, bool readonly)
{
struct vfio_iommu_type1_dma_map map = {
@@ -523,7 +523,7 @@ static int vfio_dma_map(VFIOContainer *container, hwaddr iova,
map.flags |= VFIO_DMA_MAP_FLAG_WRITE;
}
- ret = CONT_DMA_MAP(container, &map);
+ ret = CONT_DMA_MAP(container, mr, &map);
if (ret < 0) {
error_report("VFIO_MAP_DMA failed: %s", strerror(-ret));
@@ -586,7 +586,8 @@ static bool vfio_listener_skipped_section(MemoryRegionSection *section)
/* Called with rcu_read_lock held. */
static bool vfio_get_xlat_addr(IOMMUTLBEntry *iotlb, void **vaddr,
- ram_addr_t *ram_addr, bool *read_only)
+ ram_addr_t *ram_addr, bool *read_only,
+ MemoryRegion **mrp)
{
MemoryRegion *mr;
hwaddr xlat;
@@ -667,6 +668,10 @@ static bool vfio_get_xlat_addr(IOMMUTLBEntry *iotlb, void **vaddr,
*read_only = !writable || mr->readonly;
}
+ if (mrp != NULL) {
+ *mrp = mr;
+ }
+
return true;
}
@@ -674,6 +679,7 @@ static void vfio_iommu_map_notify(IOMMUNotifier *n, IOMMUTLBEntry *iotlb)
{
VFIOGuestIOMMU *giommu = container_of(n, VFIOGuestIOMMU, n);
VFIOContainer *container = giommu->container;
+ MemoryRegion *mr;
hwaddr iova = iotlb->iova + giommu->iommu_offset;
void *vaddr;
int ret;
@@ -692,7 +698,7 @@ static void vfio_iommu_map_notify(IOMMUNotifier *n, IOMMUTLBEntry *iotlb)
if ((iotlb->perm & IOMMU_RW) != IOMMU_NONE) {
bool read_only;
- if (!vfio_get_xlat_addr(iotlb, &vaddr, NULL, &read_only)) {
+ if (!vfio_get_xlat_addr(iotlb, &vaddr, NULL, &read_only, &mr)) {
goto out;
}
/*
@@ -702,14 +708,14 @@ static void vfio_iommu_map_notify(IOMMUNotifier *n, IOMMUTLBEntry *iotlb)
* of vaddr will always be there, even if the memory object is
* destroyed and its backing memory munmap-ed.
*/
- ret = vfio_dma_map(container, iova,
+ ret = vfio_dma_map(container, mr, iova,
iotlb->addr_mask + 1, vaddr,
read_only);
if (ret) {
error_report("vfio_dma_map(%p, 0x%"HWADDR_PRIx", "
- "0x%"HWADDR_PRIx", %p) = %d (%m)",
+ "0x%"HWADDR_PRIx", %p)",
container, iova,
- iotlb->addr_mask + 1, vaddr, ret);
+ iotlb->addr_mask + 1, vaddr);
}
} else {
ret = vfio_dma_unmap(container, iova, iotlb->addr_mask + 1, iotlb);
@@ -764,7 +770,7 @@ static int vfio_ram_discard_notify_populate(RamDiscardListener *rdl,
section->offset_within_address_space;
vaddr = memory_region_get_ram_ptr(section->mr) + start;
- ret = vfio_dma_map(vrdl->container, iova, next - start,
+ ret = vfio_dma_map(vrdl->container, section->mr, iova, next - start,
vaddr, section->readonly);
if (ret) {
/* Rollback */
@@ -888,6 +894,29 @@ static bool vfio_known_safe_misalignment(MemoryRegionSection *section)
return true;
}
+static void vfio_listener_begin(MemoryListener *listener)
+{
+ VFIOContainer *container = container_of(listener, VFIOContainer, listener);
+
+ /*
+ * When DMA space is the physical address space,
+ * the region add/del listeners will fire during
+ * memory update transactions. These depend on BQL
+ * being held, so do any resulting map/demap ops async
+ * while keeping BQL.
+ */
+ container->async_ops = true;
+}
+
+static void vfio_listener_commit(MemoryListener *listener)
+{
+ VFIOContainer *container = container_of(listener, VFIOContainer, listener);
+
+ /* wait here for any async requests sent during the transaction */
+ CONT_WAIT_COMMIT(container);
+ container->async_ops = false;
+}
+
static void vfio_listener_region_add(MemoryListener *listener,
MemoryRegionSection *section)
{
@@ -1095,12 +1124,12 @@ static void vfio_listener_region_add(MemoryListener *listener,
}
}
- ret = vfio_dma_map(container, iova, int128_get64(llsize),
+ ret = vfio_dma_map(container, section->mr, iova, int128_get64(llsize),
vaddr, section->readonly);
if (ret) {
error_setg(&err, "vfio_dma_map(%p, 0x%"HWADDR_PRIx", "
- "0x%"HWADDR_PRIx", %p) = %d (%m)",
- container, iova, int128_get64(llsize), vaddr, ret);
+ "0x%"HWADDR_PRIx", %p)",
+ container, iova, int128_get64(llsize), vaddr);
if (memory_region_is_ram_device(section->mr)) {
/* Allow unexpected mappings not to be fatal for RAM devices */
error_report_err(err);
@@ -1369,7 +1398,7 @@ static void vfio_iommu_map_dirty_notify(IOMMUNotifier *n, IOMMUTLBEntry *iotlb)
}
rcu_read_lock();
- if (vfio_get_xlat_addr(iotlb, NULL, &translated_addr, NULL)) {
+ if (vfio_get_xlat_addr(iotlb, NULL, &translated_addr, NULL, NULL)) {
int ret;
ret = vfio_get_dirty_bitmap(container, iova, iotlb->addr_mask + 1,
@@ -1487,6 +1516,8 @@ static void vfio_listener_log_sync(MemoryListener *listener,
static const MemoryListener vfio_memory_listener = {
.name = "vfio",
+ .begin = vfio_listener_begin,
+ .commit = vfio_listener_commit,
.region_add = vfio_listener_region_add,
.region_del = vfio_listener_region_del,
.log_global_start = vfio_listener_log_global_start,
@@ -2977,7 +3008,7 @@ VFIODevIO vfio_dev_io_ioctl = {
.region_write = vfio_io_region_write,
};
-static int vfio_io_dma_map(VFIOContainer *container,
+static int vfio_io_dma_map(VFIOContainer *container, MemoryRegion *mr,
struct vfio_iommu_type1_dma_map *map)
{
@@ -3037,8 +3068,14 @@ static int vfio_io_dirty_bitmap(VFIOContainer *container,
return ret < 0 ? -errno : ret;
}
+static void vfio_io_wait_commit(VFIOContainer *container)
+{
+ /* ioctl()s are synchronous */
+}
+
VFIOContIO vfio_cont_io_ioctl = {
.dma_map = vfio_io_dma_map,
.dma_unmap = vfio_io_dma_unmap,
.dirty_bitmap = vfio_io_dirty_bitmap,
+ .wait_commit = vfio_io_wait_commit,
};
diff --git a/hw/vfio/user-protocol.h b/hw/vfio/user-protocol.h
index 31704cf..e9fcf64 100644
--- a/hw/vfio/user-protocol.h
+++ b/hw/vfio/user-protocol.h
@@ -114,6 +114,31 @@ typedef struct {
#define VFIO_USER_DEF_MAX_BITMAP (256 * 1024 * 1024)
/*
+ * 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
*/
@@ -177,4 +202,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 */
diff --git a/hw/vfio/user.c b/hw/vfio/user.c
index 2d35f83..1fd37cc 100644
--- a/hw/vfio/user.c
+++ b/hw/vfio/user.c
@@ -59,8 +59,11 @@ 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_nowait(VFIOProxy *proxy, VFIOUserHdr *hdr,
+ VFIOUserFDs *fds, int rsize);
static void vfio_user_send_wait(VFIOProxy *proxy, VFIOUserHdr *hdr,
VFIOUserFDs *fds, int rsize, bool nobql);
+static void vfio_user_wait_reqs(VFIOProxy *proxy);
static void vfio_user_request_msg(VFIOUserHdr *hdr, uint16_t cmd,
uint32_t size, uint32_t flags);
@@ -647,6 +650,36 @@ static void vfio_user_send_async(VFIOProxy *proxy, VFIOUserHdr *hdr,
}
}
+/*
+ * nowait send - vfio_wait_reqs() can wait for it later
+ */
+static void vfio_user_send_nowait(VFIOProxy *proxy, VFIOUserHdr *hdr,
+ VFIOUserFDs *fds, int rsize)
+{
+ VFIOUserMsg *msg;
+ int ret;
+
+ if (hdr->flags & VFIO_USER_NO_REPLY) {
+ error_printf("vfio_user_send_nowait on async message\n");
+ return;
+ }
+
+ QEMU_LOCK_GUARD(&proxy->lock);
+
+ msg = vfio_user_getmsg(proxy, hdr, fds);
+ msg->id = hdr->id;
+ msg->rsize = rsize ? rsize : hdr->size;
+ msg->type = VFIO_MSG_NOWAIT;
+
+ ret = vfio_user_send_queued(proxy, msg);
+ if (ret < 0) {
+ vfio_user_recycle(proxy, msg);
+ return;
+ }
+
+ proxy->last_nowait = msg;
+}
+
static void vfio_user_send_wait(VFIOProxy *proxy, VFIOUserHdr *hdr,
VFIOUserFDs *fds, int rsize, bool nobql)
{
@@ -699,6 +732,60 @@ static void vfio_user_send_wait(VFIOProxy *proxy, VFIOUserHdr *hdr,
}
}
+static void vfio_user_wait_reqs(VFIOProxy *proxy)
+{
+ VFIOUserMsg *msg;
+ bool iolock = false;
+
+ /*
+ * Any DMA map/unmap requests sent in the middle
+ * of a memory region transaction were sent nowait.
+ * Wait for them here.
+ */
+ qemu_mutex_lock(&proxy->lock);
+ if (proxy->last_nowait != NULL) {
+ iolock = qemu_mutex_iothread_locked();
+ if (iolock) {
+ qemu_mutex_unlock_iothread();
+ }
+
+ /*
+ * Change type to WAIT to wait for reply
+ */
+ msg = proxy->last_nowait;
+ msg->type = VFIO_MSG_WAIT;
+ while (!msg->complete) {
+ if (!qemu_cond_timedwait(&msg->cv, &proxy->lock, wait_time)) {
+ VFIOUserMsgQ *list;
+
+ list = msg->pending ? &proxy->pending : &proxy->outgoing;
+ QTAILQ_REMOVE(list, msg, next);
+ error_printf("vfio_wait_reqs - timed out\n");
+ break;
+ }
+ }
+
+ if (msg->hdr->flags & VFIO_USER_ERROR) {
+ error_printf("vfio_user_wait_reqs - error reply on async request ");
+ error_printf("command %x error %s\n", msg->hdr->command,
+ strerror(msg->hdr->error_reply));
+ }
+
+ proxy->last_nowait = NULL;
+ /*
+ * Change type back to NOWAIT to free
+ */
+ msg->type = VFIO_MSG_NOWAIT;
+ 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);
@@ -1113,6 +1200,103 @@ int vfio_user_validate_version(VFIOProxy *proxy, Error **errp)
return 0;
}
+static int vfio_user_dma_map(VFIOProxy *proxy,
+ struct vfio_iommu_type1_dma_map *map,
+ int fd, bool will_commit)
+{
+ VFIOUserFDs *fds = NULL;
+ VFIOUserDMAMap *msgp = g_malloc0(sizeof(*msgp));
+ int ret;
+
+ vfio_user_request_msg(&msgp->hdr, VFIO_USER_DMA_MAP, sizeof(*msgp), 0);
+ msgp->argsz = map->argsz;
+ msgp->flags = map->flags;
+ msgp->offset = map->vaddr;
+ msgp->iova = map->iova;
+ msgp->size = map->size;
+
+ /*
+ * The will_commit case sends without blocking or dropping BQL.
+ * They're later waited for in vfio_send_wait_reqs.
+ */
+ if (will_commit) {
+ /* can't use auto variable since we don't block */
+ if (fd != -1) {
+ fds = vfio_user_getfds(1);
+ fds->send_fds = 1;
+ fds->fds[0] = fd;
+ }
+ vfio_user_send_nowait(proxy, &msgp->hdr, fds, 0);
+ ret = 0;
+ } else {
+ VFIOUserFDs local_fds = { 1, 0, &fd };
+
+ fds = fd != -1 ? &local_fds : NULL;
+ vfio_user_send_wait(proxy, &msgp->hdr, fds, 0, will_commit);
+ ret = (msgp->hdr.flags & VFIO_USER_ERROR) ? -msgp->hdr.error_reply : 0;
+ g_free(msgp);
+ }
+
+ return ret;
+}
+
+static int vfio_user_dma_unmap(VFIOProxy *proxy,
+ struct vfio_iommu_type1_dma_unmap *unmap,
+ struct vfio_bitmap *bitmap, bool will_commit)
+{
+ struct {
+ VFIOUserDMAUnmap msg;
+ VFIOUserBitmap bitmap;
+ } *msgp = NULL;
+ int msize, rsize;
+ bool blocking = !will_commit;
+
+ if (bitmap == NULL &&
+ (unmap->flags & VFIO_DMA_UNMAP_FLAG_GET_DIRTY_BITMAP)) {
+ error_printf("vfio_user_dma_unmap mismatched flags and bitmap\n");
+ return -EINVAL;
+ }
+
+ /*
+ * If a dirty bitmap is returned, allocate extra space for it
+ * and block for reply even in the will_commit case.
+ * Otherwise, can send the unmap request without waiting.
+ */
+ if (bitmap != NULL) {
+ blocking = true;
+ msize = sizeof(*msgp);
+ rsize = msize + bitmap->size;
+ msgp = g_malloc0(rsize);
+ msgp->bitmap.pgsize = bitmap->pgsize;
+ msgp->bitmap.size = bitmap->size;
+ } else {
+ msize = rsize = sizeof(VFIOUserDMAUnmap);
+ msgp = g_malloc0(rsize);
+ }
+
+ vfio_user_request_msg(&msgp->msg.hdr, VFIO_USER_DMA_UNMAP, msize, 0);
+ msgp->msg.argsz = rsize - sizeof(VFIOUserHdr);
+ msgp->msg.argsz = unmap->argsz;
+ msgp->msg.flags = unmap->flags;
+ msgp->msg.iova = unmap->iova;
+ msgp->msg.size = unmap->size;
+
+ if (blocking) {
+ vfio_user_send_wait(proxy, &msgp->msg.hdr, NULL, rsize, will_commit);
+ if (msgp->msg.hdr.flags & VFIO_USER_ERROR) {
+ return -msgp->msg.hdr.error_reply;
+ }
+ if (bitmap != NULL) {
+ memcpy(bitmap->data, &msgp->bitmap.data, bitmap->size);
+ }
+ g_free(msgp);
+ } else {
+ vfio_user_send_nowait(proxy, &msgp->msg.hdr, NULL, rsize);
+ }
+
+ return 0;
+}
+
static int vfio_user_get_info(VFIOProxy *proxy, struct vfio_device_info *info)
{
VFIOUserDeviceInfo msg;
@@ -1434,5 +1618,41 @@ VFIODevIO vfio_dev_io_sock = {
};
+static int vfio_user_io_dma_map(VFIOContainer *container, MemoryRegion *mr,
+ struct vfio_iommu_type1_dma_map *map)
+{
+ int fd = memory_region_get_fd(mr);
+
+ /*
+ * map->vaddr enters as a QEMU process address
+ * make it either a file offset for mapped areas or 0
+ */
+ if (fd != -1) {
+ void *addr = (void *)(uintptr_t)map->vaddr;
+
+ map->vaddr = qemu_ram_block_host_offset(mr->ram_block, addr);
+ } else {
+ map->vaddr = 0;
+ }
+
+ return vfio_user_dma_map(container->proxy, map, fd, container->async_ops);
+}
+
+static int vfio_user_io_dma_unmap(VFIOContainer *container,
+ struct vfio_iommu_type1_dma_unmap *unmap,
+ struct vfio_bitmap *bitmap)
+{
+ return vfio_user_dma_unmap(container->proxy, unmap, bitmap,
+ container->async_ops);
+}
+
+static void vfio_user_io_wait_commit(VFIOContainer *container)
+{
+ vfio_user_wait_reqs(container->proxy);
+}
+
VFIOContIO vfio_cont_io_sock = {
+ .dma_map = vfio_user_io_dma_map,
+ .dma_unmap = vfio_user_io_dma_unmap,
+ .wait_commit = vfio_user_io_wait_commit,
};
diff --git a/include/hw/vfio/vfio-common.h b/include/hw/vfio/vfio-common.h
index 312ef9c..413dafc 100644
--- a/include/hw/vfio/vfio-common.h
+++ b/include/hw/vfio/vfio-common.h
@@ -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;
@@ -200,7 +201,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,
@@ -208,14 +209,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;
--
1.8.3.1
^ permalink raw reply related [flat|nested] 82+ messages in thread
* [PATCH v1 18/24] vfio-user: add dma_unmap_all
2022-11-08 23:13 [PATCH v1 00/24] vfio-user client John Johnson
` (16 preceding siblings ...)
2022-11-08 23:13 ` [PATCH v1 17/24] vfio-user: dma map/unmap operations John Johnson
@ 2022-11-08 23:13 ` John Johnson
2022-12-09 17:58 ` John Levon
2022-11-08 23:13 ` [PATCH v1 19/24] vfio-user: secure DMA support John Johnson
` (7 subsequent siblings)
25 siblings, 1 reply; 82+ messages in thread
From: John Johnson @ 2022-11-08 23:13 UTC (permalink / raw)
To: qemu-devel
Signed-off-by: John G Johnson <john.g.johnson@oracle.com>
Signed-off-by: Elena Ufimtseva <elena.ufimtseva@oracle.com>
Signed-off-by: Jagannathan Raman <jag.raman@oracle.com>
---
hw/vfio/common.c | 45 ++++++++++++++++++++++++++++++++++---------
hw/vfio/user.c | 24 +++++++++++++++++++++++
include/hw/vfio/vfio-common.h | 3 +++
3 files changed, 63 insertions(+), 9 deletions(-)
diff --git a/hw/vfio/common.c b/hw/vfio/common.c
index fe6eddd..cd64ec2 100644
--- a/hw/vfio/common.c
+++ b/hw/vfio/common.c
@@ -507,6 +507,14 @@ static int vfio_dma_unmap(VFIOContainer *container,
return CONT_DMA_UNMAP(container, &unmap, NULL);
}
+/*
+ * DMA - Mapping and unmapping for the "type1" IOMMU interface used on x86
+ */
+static int vfio_dma_unmap_all(VFIOContainer *container)
+{
+ return CONT_DMA_UNMAP_ALL(container, VFIO_DMA_UNMAP_FLAG_ALL);
+}
+
static int vfio_dma_map(VFIOContainer *container, MemoryRegion *mr, hwaddr iova,
ram_addr_t size, void *vaddr, bool readonly)
{
@@ -1256,17 +1264,10 @@ static void vfio_listener_region_del(MemoryListener *listener,
if (try_unmap) {
if (int128_eq(llsize, int128_2_64())) {
- /* The unmap ioctl doesn't accept a full 64-bit span. */
- llsize = int128_rshift(llsize, 1);
+ ret = vfio_dma_unmap_all(container);
+ } else {
ret = vfio_dma_unmap(container, iova, int128_get64(llsize), NULL);
- if (ret) {
- error_report("vfio_dma_unmap(%p, 0x%"HWADDR_PRIx", "
- "0x%"HWADDR_PRIx") = %d (%m)",
- container, iova, int128_get64(llsize), ret);
- }
- iova += int128_get64(llsize);
}
- ret = vfio_dma_unmap(container, iova, int128_get64(llsize), NULL);
if (ret) {
error_report("vfio_dma_unmap(%p, 0x%"HWADDR_PRIx", "
"0x%"HWADDR_PRIx") = %d (%m)",
@@ -3057,6 +3058,31 @@ static int vfio_io_dma_unmap(VFIOContainer *container,
return 0;
}
+static int vfio_io_dma_unmap_all(VFIOContainer *container, uint32_t flags)
+{
+ struct vfio_iommu_type1_dma_unmap unmap = {
+ .argsz = sizeof(unmap),
+ .flags = 0,
+ .size = 0x8000000000000000,
+ };
+ int ret;
+
+ /* The unmap ioctl doesn't accept a full 64-bit span. */
+ unmap.iova = 0;
+ ret = ioctl(container->fd, VFIO_IOMMU_UNMAP_DMA, &unmap);
+ if (ret) {
+ return -errno;
+ }
+
+ unmap.iova += unmap.size;
+ ret = ioctl(container->fd, VFIO_IOMMU_UNMAP_DMA, &unmap);
+ if (ret) {
+ return -errno;
+ }
+
+ return 0;
+}
+
static int vfio_io_dirty_bitmap(VFIOContainer *container,
struct vfio_iommu_type1_dirty_bitmap *bitmap,
struct vfio_iommu_type1_dirty_bitmap_get *range)
@@ -3076,6 +3102,7 @@ static void vfio_io_wait_commit(VFIOContainer *container)
VFIOContIO vfio_cont_io_ioctl = {
.dma_map = vfio_io_dma_map,
.dma_unmap = vfio_io_dma_unmap,
+ .dma_unmap_all = vfio_io_dma_unmap_all,
.dirty_bitmap = vfio_io_dirty_bitmap,
.wait_commit = vfio_io_wait_commit,
};
diff --git a/hw/vfio/user.c b/hw/vfio/user.c
index 1fd37cc..d62fe05 100644
--- a/hw/vfio/user.c
+++ b/hw/vfio/user.c
@@ -1646,6 +1646,28 @@ static int vfio_user_io_dma_unmap(VFIOContainer *container,
container->async_ops);
}
+static int vfio_user_io_dma_unmap_all(VFIOContainer *container, uint32_t flags)
+{
+ struct vfio_iommu_type1_dma_unmap unmap = {
+ .argsz = sizeof(unmap),
+ .flags = flags | VFIO_DMA_UNMAP_FLAG_ALL,
+ .iova = 0,
+ .size = 0,
+ };
+
+ return vfio_user_dma_unmap(container->proxy, &unmap, NULL,
+ 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)
+{
+
+ /* vfio-user doesn't support migration */
+ return -EINVAL;
+}
+
static void vfio_user_io_wait_commit(VFIOContainer *container)
{
vfio_user_wait_reqs(container->proxy);
@@ -1654,5 +1676,7 @@ 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,
+ .dma_unmap_all = vfio_user_io_dma_unmap_all,
+ .dirty_bitmap = vfio_user_io_dirty_bitmap,
.wait_commit = vfio_user_io_wait_commit,
};
diff --git a/include/hw/vfio/vfio-common.h b/include/hw/vfio/vfio-common.h
index 413dafc..d7e3f51 100644
--- a/include/hw/vfio/vfio-common.h
+++ b/include/hw/vfio/vfio-common.h
@@ -206,6 +206,7 @@ struct VFIOContIO {
int (*dma_unmap)(VFIOContainer *container,
struct vfio_iommu_type1_dma_unmap *unmap,
struct vfio_bitmap *bitmap);
+ int (*dma_unmap_all)(VFIOContainer *container, uint32_t flags);
int (*dirty_bitmap)(VFIOContainer *container,
struct vfio_iommu_type1_dirty_bitmap *bitmap,
struct vfio_iommu_type1_dirty_bitmap_get *range);
@@ -216,6 +217,8 @@ struct VFIOContIO {
((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_DMA_UNMAP_ALL(cont, flags) \
+ ((cont)->io_ops->dma_unmap_all((cont), (flags)))
#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))
--
1.8.3.1
^ permalink raw reply related [flat|nested] 82+ messages in thread
* [PATCH v1 19/24] vfio-user: secure DMA support
2022-11-08 23:13 [PATCH v1 00/24] vfio-user client John Johnson
` (17 preceding siblings ...)
2022-11-08 23:13 ` [PATCH v1 18/24] vfio-user: add dma_unmap_all John Johnson
@ 2022-11-08 23:13 ` John Johnson
2022-12-09 18:01 ` John Levon
2022-11-08 23:13 ` [PATCH v1 20/24] vfio-user: dma read/write operations John Johnson
` (6 subsequent siblings)
25 siblings, 1 reply; 82+ messages in thread
From: John Johnson @ 2022-11-08 23:13 UTC (permalink / raw)
To: qemu-devel
Secure DMA forces the remote process to use DMA r/w messages
instead of directly mapping guest memeory.
Signed-off-by: John G Johnson <john.g.johnson@oracle.com>
Signed-off-by: Elena Ufimtseva <elena.ufimtseva@oracle.com>
Signed-off-by: Jagannathan Raman <jag.raman@oracle.com>
---
hw/vfio/pci.c | 4 ++++
hw/vfio/pci.h | 1 +
hw/vfio/user.c | 2 +-
hw/vfio/user.h | 1 +
4 files changed, 7 insertions(+), 1 deletion(-)
diff --git a/hw/vfio/pci.c b/hw/vfio/pci.c
index 53e3bb8..ce6776b 100644
--- a/hw/vfio/pci.c
+++ b/hw/vfio/pci.c
@@ -3610,6 +3610,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;
}
@@ -3718,6 +3721,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(),
diff --git a/hw/vfio/pci.h b/hw/vfio/pci.h
index c04fa58..c4b8e5c 100644
--- a/hw/vfio/pci.h
+++ b/hw/vfio/pci.h
@@ -196,6 +196,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 */
};
diff --git a/hw/vfio/user.c b/hw/vfio/user.c
index d62fe05..0c5493e 100644
--- a/hw/vfio/user.c
+++ b/hw/vfio/user.c
@@ -1627,7 +1627,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);
diff --git a/hw/vfio/user.h b/hw/vfio/user.h
index 19b8a29..6bd9fd3 100644
--- a/hw/vfio/user.h
+++ b/hw/vfio/user.h
@@ -83,6 +83,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
--
1.8.3.1
^ permalink raw reply related [flat|nested] 82+ messages in thread
* [PATCH v1 20/24] vfio-user: dma read/write operations
2022-11-08 23:13 [PATCH v1 00/24] vfio-user client John Johnson
` (18 preceding siblings ...)
2022-11-08 23:13 ` [PATCH v1 19/24] vfio-user: secure DMA support John Johnson
@ 2022-11-08 23:13 ` John Johnson
2022-12-09 18:11 ` John Levon
2022-11-08 23:13 ` [PATCH v1 21/24] vfio-user: pci reset John Johnson
` (5 subsequent siblings)
25 siblings, 1 reply; 82+ messages in thread
From: John Johnson @ 2022-11-08 23:13 UTC (permalink / raw)
To: qemu-devel
Messages from server to client that peform device DMA.
Signed-off-by: Elena Ufimtseva <elena.ufimtseva@oracle.com>
Signed-off-by: John G Johnson <john.g.johnson@oracle.com>
Signed-off-by: Jagannathan Raman <jag.raman@oracle.com>
---
hw/vfio/pci.c | 110 ++++++++++++++++++++++++++++++++++++++++++++++++
hw/vfio/user-protocol.h | 11 +++++
hw/vfio/user.c | 57 +++++++++++++++++++++++++
hw/vfio/user.h | 3 ++
4 files changed, 181 insertions(+)
diff --git a/hw/vfio/pci.c b/hw/vfio/pci.c
index ce6776b..559b20d 100644
--- a/hw/vfio/pci.c
+++ b/hw/vfio/pci.c
@@ -3550,6 +3550,95 @@ static void vfio_user_msix_teardown(VFIOPCIDevice *vdev)
vdev->msix->pba_region = NULL;
}
+static void vfio_user_dma_read(VFIOPCIDevice *vdev, VFIOUserDMARW *msg)
+{
+ PCIDevice *pdev = &vdev->pdev;
+ VFIOProxy *proxy = vdev->vbasedev.proxy;
+ VFIOUserDMARW *res;
+ MemTxResult r;
+ size_t size;
+
+ if (msg->hdr.size < sizeof(*msg)) {
+ vfio_user_send_error(proxy, &msg->hdr, EINVAL);
+ return;
+ }
+ if (msg->count > proxy->max_xfer_size) {
+ vfio_user_send_error(proxy, &msg->hdr, E2BIG);
+ return;
+ }
+
+ /* switch to our own message buffer */
+ size = msg->count + sizeof(VFIOUserDMARW);
+ res = g_malloc0(size);
+ memcpy(res, msg, sizeof(*res));
+ g_free(msg);
+
+ r = pci_dma_read(pdev, res->offset, &res->data, res->count);
+
+ switch (r) {
+ case MEMTX_OK:
+ if (res->hdr.flags & VFIO_USER_NO_REPLY) {
+ g_free(res);
+ return;
+ }
+ vfio_user_send_reply(proxy, &res->hdr, size);
+ break;
+ case MEMTX_ERROR:
+ vfio_user_send_error(proxy, &res->hdr, EFAULT);
+ break;
+ case MEMTX_DECODE_ERROR:
+ vfio_user_send_error(proxy, &res->hdr, ENODEV);
+ break;
+ case MEMTX_ACCESS_ERROR:
+ vfio_user_send_error(proxy, &res->hdr, EPERM);
+ break;
+ default:
+ error_printf("vfio_user_dma_read unknown error %d\n", r);
+ vfio_user_send_error(vdev->vbasedev.proxy, &res->hdr, EINVAL);
+ }
+}
+
+static void vfio_user_dma_write(VFIOPCIDevice *vdev, VFIOUserDMARW *msg)
+{
+ PCIDevice *pdev = &vdev->pdev;
+ VFIOProxy *proxy = vdev->vbasedev.proxy;
+ MemTxResult r;
+
+ if (msg->hdr.size < sizeof(*msg)) {
+ vfio_user_send_error(proxy, &msg->hdr, EINVAL);
+ return;
+ }
+ /* make sure transfer count isn't larger than the message data */
+ if (msg->count > msg->hdr.size - sizeof(*msg)) {
+ vfio_user_send_error(proxy, &msg->hdr, E2BIG);
+ return;
+ }
+
+ r = pci_dma_write(pdev, msg->offset, &msg->data, msg->count);
+
+ switch (r) {
+ case MEMTX_OK:
+ if ((msg->hdr.flags & VFIO_USER_NO_REPLY) == 0) {
+ vfio_user_send_reply(proxy, &msg->hdr, sizeof(msg->hdr));
+ } else {
+ g_free(msg);
+ }
+ break;
+ case MEMTX_ERROR:
+ vfio_user_send_error(proxy, &msg->hdr, EFAULT);
+ break;
+ case MEMTX_DECODE_ERROR:
+ vfio_user_send_error(proxy, &msg->hdr, ENODEV);
+ break;
+ case MEMTX_ACCESS_ERROR:
+ vfio_user_send_error(proxy, &msg->hdr, EPERM);
+ break;
+ default:
+ error_printf("vfio_user_dma_write unknown error %d\n", r);
+ vfio_user_send_error(vdev->vbasedev.proxy, &msg->hdr, EINVAL);
+ }
+}
+
/*
* Incoming request message callback.
*
@@ -3557,9 +3646,30 @@ static void vfio_user_msix_teardown(VFIOPCIDevice *vdev)
*/
static void vfio_user_pci_process_req(void *opaque, VFIOUserMsg *msg)
{
+ VFIOPCIDevice *vdev = opaque;
+ VFIOUserHdr *hdr = msg->hdr;
+
+ /* no incoming PCI requests pass FDs */
+ if (msg->fds != NULL) {
+ vfio_user_send_error(vdev->vbasedev.proxy, hdr, EINVAL);
+ vfio_user_putfds(msg);
+ return;
+ }
+ switch (hdr->command) {
+ case VFIO_USER_DMA_READ:
+ vfio_user_dma_read(vdev, (VFIOUserDMARW *)hdr);
+ break;
+ case VFIO_USER_DMA_WRITE:
+ vfio_user_dma_write(vdev, (VFIOUserDMARW *)hdr);
+ break;
+ default:
+ error_printf("vfio_user_process_req unknown cmd %d\n", hdr->command);
+ vfio_user_send_error(vdev->vbasedev.proxy, hdr, ENOSYS);
+ }
}
+
/*
* Emulated devices don't use host hot reset
*/
diff --git a/hw/vfio/user-protocol.h b/hw/vfio/user-protocol.h
index e9fcf64..6afd090 100644
--- a/hw/vfio/user-protocol.h
+++ b/hw/vfio/user-protocol.h
@@ -202,6 +202,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;
diff --git a/hw/vfio/user.c b/hw/vfio/user.c
index 0c5493e..56b3616 100644
--- a/hw/vfio/user.c
+++ b/hw/vfio/user.c
@@ -379,6 +379,10 @@ static int vfio_user_recv_one(VFIOProxy *proxy)
*msg->hdr = hdr;
data = (char *)msg->hdr + sizeof(hdr);
} else {
+ if (hdr.size > proxy->max_xfer_size + sizeof(VFIOUserDMARW)) {
+ 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);
@@ -786,6 +790,59 @@ static void vfio_user_wait_reqs(VFIOProxy *proxy)
}
}
+/*
+ * Reply to an incoming request.
+ */
+void vfio_user_send_reply(VFIOProxy *proxy, VFIOUserHdr *hdr, int size)
+{
+
+ if (size < sizeof(VFIOUserHdr)) {
+ error_printf("vfio_user_send_reply - size too small\n");
+ g_free(hdr);
+ return;
+ }
+
+ /*
+ * convert header to associated reply
+ */
+ hdr->flags = VFIO_USER_REPLY;
+ hdr->size = size;
+
+ vfio_user_send_async(proxy, hdr, NULL);
+}
+
+/*
+ * Send an error reply to an incoming request.
+ */
+void vfio_user_send_error(VFIOProxy *proxy, VFIOUserHdr *hdr, int error)
+{
+
+ /*
+ * convert header to associated reply
+ */
+ hdr->flags = VFIO_USER_REPLY;
+ hdr->flags |= VFIO_USER_ERROR;
+ hdr->error_reply = error;
+ hdr->size = sizeof(*hdr);
+
+ vfio_user_send_async(proxy, hdr, NULL);
+}
+
+/*
+ * Close FDs erroneously received in an incoming request.
+ */
+void vfio_user_putfds(VFIOUserMsg *msg)
+{
+ VFIOUserFDs *fds = msg->fds;
+ int i;
+
+ for (i = 0; i < fds->recv_fds; i++) {
+ close(fds->fds[i]);
+ }
+ g_free(fds);
+ msg->fds = NULL;
+}
+
static QLIST_HEAD(, VFIOProxy) vfio_user_sockets =
QLIST_HEAD_INITIALIZER(vfio_user_sockets);
diff --git a/hw/vfio/user.h b/hw/vfio/user.h
index 6bd9fd3..18e3112 100644
--- a/hw/vfio/user.h
+++ b/hw/vfio/user.h
@@ -93,6 +93,9 @@ void vfio_user_set_handler(VFIODevice *vbasedev,
void (*handler)(void *opaque, VFIOUserMsg *msg),
void *reqarg);
int vfio_user_validate_version(VFIOProxy *proxy, Error **errp);
+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);
extern VFIODevIO vfio_dev_io_sock;
extern VFIOContIO vfio_cont_io_sock;
--
1.8.3.1
^ permalink raw reply related [flat|nested] 82+ messages in thread
* [PATCH v1 21/24] vfio-user: pci reset
2022-11-08 23:13 [PATCH v1 00/24] vfio-user client John Johnson
` (19 preceding siblings ...)
2022-11-08 23:13 ` [PATCH v1 20/24] vfio-user: dma read/write operations John Johnson
@ 2022-11-08 23:13 ` John Johnson
2022-12-09 18:13 ` John Levon
2022-11-08 23:13 ` [PATCH v1 22/24] vfio-user: add 'x-msg-timeout' option that specifies msg wait times John Johnson
` (4 subsequent siblings)
25 siblings, 1 reply; 82+ messages in thread
From: John Johnson @ 2022-11-08 23:13 UTC (permalink / raw)
To: qemu-devel
Message to tell the server to reset the device.
Signed-off-by: Elena Ufimtseva <elena.ufimtseva@oracle.com>
Signed-off-by: John G Johnson <john.g.johnson@oracle.com>
Signed-off-by: Jagannathan Raman <jag.raman@oracle.com>
---
hw/vfio/pci.c | 15 +++++++++++++++
hw/vfio/user.c | 12 ++++++++++++
hw/vfio/user.h | 1 +
3 files changed, 28 insertions(+)
diff --git a/hw/vfio/pci.c b/hw/vfio/pci.c
index 559b20d..005fcf8 100644
--- a/hw/vfio/pci.c
+++ b/hw/vfio/pci.c
@@ -3829,6 +3829,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),
@@ -3842,6 +3856,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;
diff --git a/hw/vfio/user.c b/hw/vfio/user.c
index 56b3616..ddf9e13 100644
--- a/hw/vfio/user.c
+++ b/hw/vfio/user.c
@@ -1580,6 +1580,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
diff --git a/hw/vfio/user.h b/hw/vfio/user.h
index 18e3112..d88ffe5 100644
--- a/hw/vfio/user.h
+++ b/hw/vfio/user.h
@@ -96,6 +96,7 @@ int vfio_user_validate_version(VFIOProxy *proxy, Error **errp);
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);
+void vfio_user_reset(VFIOProxy *proxy);
extern VFIODevIO vfio_dev_io_sock;
extern VFIOContIO vfio_cont_io_sock;
--
1.8.3.1
^ permalink raw reply related [flat|nested] 82+ messages in thread
* [PATCH v1 22/24] vfio-user: add 'x-msg-timeout' option that specifies msg wait times
2022-11-08 23:13 [PATCH v1 00/24] vfio-user client John Johnson
` (20 preceding siblings ...)
2022-11-08 23:13 ` [PATCH v1 21/24] vfio-user: pci reset John Johnson
@ 2022-11-08 23:13 ` John Johnson
2022-12-09 18:14 ` John Levon
2022-12-15 12:56 ` Cédric Le Goater
2022-11-08 23:13 ` [PATCH v1 23/24] vfio-user: add coalesced posted writes John Johnson
` (3 subsequent siblings)
25 siblings, 2 replies; 82+ messages in thread
From: John Johnson @ 2022-11-08 23:13 UTC (permalink / raw)
To: qemu-devel
Signed-off-by: John G Johnson <john.g.johnson@oracle.com>
Signed-off-by: Elena Ufimtseva <elena.ufimtseva@oracle.com>
Signed-off-by: Jagannathan Raman <jag.raman@oracle.com>
---
hw/vfio/pci.c | 4 ++++
hw/vfio/pci.h | 1 +
hw/vfio/user.c | 7 +++++--
hw/vfio/user.h | 1 +
4 files changed, 11 insertions(+), 2 deletions(-)
diff --git a/hw/vfio/pci.c b/hw/vfio/pci.c
index 005fcf8..3ae3a13 100644
--- a/hw/vfio/pci.c
+++ b/hw/vfio/pci.c
@@ -3729,6 +3729,9 @@ static void vfio_user_pci_realize(PCIDevice *pdev, Error **errp)
if (udev->no_post) {
proxy->flags |= VFIO_PROXY_NO_POST;
}
+ if (udev->wait_time) {
+ proxy->wait_time = udev->wait_time;
+ }
vfio_user_validate_version(proxy, &err);
if (err != NULL) {
@@ -3848,6 +3851,7 @@ static Property vfio_user_pci_dev_properties[] = {
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_UINT32("x-msg-timeout", VFIOUserPCIDevice, wait_time, 0),
DEFINE_PROP_END_OF_LIST(),
};
diff --git a/hw/vfio/pci.h b/hw/vfio/pci.h
index c4b8e5c..48b19ee 100644
--- a/hw/vfio/pci.h
+++ b/hw/vfio/pci.h
@@ -199,6 +199,7 @@ struct VFIOUserPCIDevice {
bool secure_dma; /* disable shared mem for DMA */
bool send_queued; /* all sends are queued */
bool no_post; /* all regions write are sync */
+ uint32_t wait_time; /* timeout for message replies */
};
/* Use uin32_t for vendor & device so PCI_ANY_ID expands and cannot match hw */
diff --git a/hw/vfio/user.c b/hw/vfio/user.c
index ddf9e13..a9e6cf5 100644
--- a/hw/vfio/user.c
+++ b/hw/vfio/user.c
@@ -717,7 +717,8 @@ static void vfio_user_send_wait(VFIOProxy *proxy, VFIOUserHdr *hdr,
if (ret == 0) {
while (!msg->complete) {
- if (!qemu_cond_timedwait(&msg->cv, &proxy->lock, wait_time)) {
+ if (!qemu_cond_timedwait(&msg->cv, &proxy->lock,
+ proxy->wait_time)) {
VFIOUserMsgQ *list;
list = msg->pending ? &proxy->pending : &proxy->outgoing;
@@ -759,7 +760,8 @@ static void vfio_user_wait_reqs(VFIOProxy *proxy)
msg = proxy->last_nowait;
msg->type = VFIO_MSG_WAIT;
while (!msg->complete) {
- if (!qemu_cond_timedwait(&msg->cv, &proxy->lock, wait_time)) {
+ if (!qemu_cond_timedwait(&msg->cv, &proxy->lock,
+ proxy->wait_time)) {
VFIOUserMsgQ *list;
list = msg->pending ? &proxy->pending : &proxy->outgoing;
@@ -881,6 +883,7 @@ VFIOProxy *vfio_user_connect_dev(SocketAddress *addr, Error **errp)
proxy->flags = VFIO_PROXY_CLIENT;
proxy->state = VFIO_PROXY_CONNECTED;
+ proxy->wait_time = wait_time;
qemu_mutex_init(&proxy->lock);
qemu_cond_init(&proxy->close_cv);
diff --git a/hw/vfio/user.h b/hw/vfio/user.h
index d88ffe5..f711861 100644
--- a/hw/vfio/user.h
+++ b/hw/vfio/user.h
@@ -62,6 +62,7 @@ typedef struct VFIOProxy {
uint64_t max_bitmap;
uint64_t migr_pgsize;
int flags;
+ uint32_t wait_time;
QemuCond close_cv;
AioContext *ctx;
QEMUBH *req_bh;
--
1.8.3.1
^ permalink raw reply related [flat|nested] 82+ messages in thread
* [PATCH v1 23/24] vfio-user: add coalesced posted writes
2022-11-08 23:13 [PATCH v1 00/24] vfio-user client John Johnson
` (21 preceding siblings ...)
2022-11-08 23:13 ` [PATCH v1 22/24] vfio-user: add 'x-msg-timeout' option that specifies msg wait times John Johnson
@ 2022-11-08 23:13 ` John Johnson
2022-12-09 18:16 ` John Levon
2022-11-08 23:13 ` [PATCH v1 24/24] vfio-user: add trace points John Johnson
` (2 subsequent siblings)
25 siblings, 1 reply; 82+ messages in thread
From: John Johnson @ 2022-11-08 23:13 UTC (permalink / raw)
To: qemu-devel
Add new message to send multiple writes to server
Signed-off-by: John G Johnson <john.g.johnson@oracle.com>
Signed-off-by: Elena Ufimtseva <elena.ufimtseva@oracle.com>
Signed-off-by: Jagannathan Raman <jag.raman@oracle.com>
---
hw/vfio/user-protocol.h | 21 ++++++++
hw/vfio/user.c | 128 +++++++++++++++++++++++++++++++++++++++++++++++-
hw/vfio/user.h | 7 +++
3 files changed, 154 insertions(+), 2 deletions(-)
diff --git a/hw/vfio/user-protocol.h b/hw/vfio/user-protocol.h
index 6afd090..ffa222b 100644
--- a/hw/vfio/user-protocol.h
+++ b/hw/vfio/user-protocol.h
@@ -40,6 +40,7 @@ enum vfio_user_command {
VFIO_USER_DMA_WRITE = 12,
VFIO_USER_DEVICE_RESET = 13,
VFIO_USER_DIRTY_PAGES = 14,
+ VFIO_USER_REGION_WRITE_MULTI = 15,
VFIO_USER_MAX,
};
@@ -73,6 +74,7 @@ typedef struct {
#define VFIO_USER_CAP_PGSIZES "pgsizes"
#define VFIO_USER_CAP_MAP_MAX "max_dma_maps"
#define VFIO_USER_CAP_MIGR "migration"
+#define VFIO_USER_CAP_MULTI "write_multiple"
/* "migration" members */
#define VFIO_USER_CAP_PGSIZE "pgsize"
@@ -220,4 +222,23 @@ typedef struct {
char data[];
} VFIOUserBitmap;
+/*
+ * VFIO_USER_REGION_WRITE_MULTI
+ */
+#define VFIO_USER_MULTI_DATA 8
+#define VFIO_USER_MULTI_MAX 200
+
+typedef struct {
+ uint64_t offset;
+ uint32_t region;
+ uint32_t count;
+ char data[VFIO_USER_MULTI_DATA];
+} VFIOUserWROne;
+
+typedef struct {
+ VFIOUserHdr hdr;
+ uint64_t wr_cnt;
+ VFIOUserWROne wrs[VFIO_USER_MULTI_MAX];
+} VFIOUserWRMulti;
+
#endif /* VFIO_USER_PROTOCOL_H */
diff --git a/hw/vfio/user.c b/hw/vfio/user.c
index a9e6cf5..4ed305b 100644
--- a/hw/vfio/user.c
+++ b/hw/vfio/user.c
@@ -66,6 +66,7 @@ static void vfio_user_send_wait(VFIOProxy *proxy, VFIOUserHdr *hdr,
static void vfio_user_wait_reqs(VFIOProxy *proxy);
static void vfio_user_request_msg(VFIOUserHdr *hdr, uint16_t cmd,
uint32_t size, uint32_t flags);
+static void vfio_user_flush_multi(VFIOProxy *proxy);
static inline void vfio_user_set_error(VFIOUserHdr *hdr, uint32_t err)
{
@@ -461,6 +462,11 @@ static void vfio_user_send(void *opaque)
}
qio_channel_set_aio_fd_handler(proxy->ioc, proxy->ctx,
vfio_user_recv, NULL, proxy);
+
+ /* queue empty - send any pending multi write msgs */
+ if (proxy->wr_multi != NULL) {
+ vfio_user_flush_multi(proxy);
+ }
}
}
@@ -481,6 +487,7 @@ static int vfio_user_send_one(VFIOProxy *proxy)
}
QTAILQ_REMOVE(&proxy->outgoing, msg, next);
+ proxy->num_outgoing--;
if (msg->type == VFIO_MSG_ASYNC) {
vfio_user_recycle(proxy, msg);
} else {
@@ -587,11 +594,18 @@ static int vfio_user_send_queued(VFIOProxy *proxy, VFIOUserMsg *msg)
{
int ret;
+ /* older coalesced writes go first */
+ if (proxy->wr_multi != NULL &&
+ ((msg->hdr->flags & VFIO_USER_TYPE) == VFIO_USER_REQUEST)) {
+ vfio_user_flush_multi(proxy);
+ }
+
/*
* Unsent outgoing msgs - add to tail
*/
if (!QTAILQ_EMPTY(&proxy->outgoing)) {
QTAILQ_INSERT_TAIL(&proxy->outgoing, msg, next);
+ proxy->num_outgoing++;
return 0;
}
@@ -605,6 +619,7 @@ static int vfio_user_send_queued(VFIOProxy *proxy, VFIOUserMsg *msg)
}
if (ret == QIO_CHANNEL_ERR_BLOCK) {
QTAILQ_INSERT_HEAD(&proxy->outgoing, msg, next);
+ proxy->num_outgoing = 1;
qio_channel_set_aio_fd_handler(proxy->ioc, proxy->ctx,
vfio_user_recv, vfio_user_send,
proxy);
@@ -1145,12 +1160,27 @@ static int check_migr(VFIOProxy *proxy, QObject *qobj, Error **errp)
return caps_parse(proxy, qdict, caps_migr, errp);
}
+static int check_multi(VFIOProxy *proxy, QObject *qobj, Error **errp)
+{
+ QBool *qb = qobject_to(QBool, qobj);
+
+ if (qb == NULL) {
+ error_setg(errp, "malformed %s", VFIO_USER_CAP_MULTI);
+ return -1;
+ }
+ if (qbool_get_bool(qb)) {
+ proxy->flags |= VFIO_PROXY_USE_MULTI;
+ }
+ return 0;
+}
+
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_PGSIZES, check_pgsizes },
{ VFIO_USER_CAP_MAP_MAX, check_max_dma },
{ VFIO_USER_CAP_MIGR, check_migr },
+ { VFIO_USER_CAP_MULTI, check_multi },
{ NULL }
};
@@ -1209,6 +1239,7 @@ static GString *caps_json(void)
qdict_put_int(capdict, VFIO_USER_CAP_MAX_XFER, VFIO_USER_DEF_MAX_XFER);
qdict_put_int(capdict, VFIO_USER_CAP_PGSIZES, VFIO_USER_DEF_PGSIZE);
qdict_put_int(capdict, VFIO_USER_CAP_MAP_MAX, VFIO_USER_DEF_MAP_MAX);
+ qdict_put_bool(capdict, VFIO_USER_CAP_MULTI, true);
qdict_put_obj(dict, VFIO_USER_CAP, QOBJECT(capdict));
@@ -1547,18 +1578,111 @@ static int vfio_user_region_read(VFIOProxy *proxy, uint8_t index, off_t offset,
return msgp->count;
}
+static void vfio_user_flush_multi(VFIOProxy *proxy)
+{
+ VFIOUserMsg *msg;
+ VFIOUserWRMulti *wm = proxy->wr_multi;
+ int ret;
+
+ proxy->wr_multi = NULL;
+
+ /* adjust size for actual # of writes */
+ wm->hdr.size -= (VFIO_USER_MULTI_MAX - wm->wr_cnt) * sizeof(VFIOUserWROne);
+
+ msg = vfio_user_getmsg(proxy, &wm->hdr, NULL);
+ msg->id = wm->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_create_multi(VFIOProxy *proxy)
+{
+ VFIOUserWRMulti *wm;
+
+ wm = g_malloc0(sizeof(*wm));
+ vfio_user_request_msg(&wm->hdr, VFIO_USER_REGION_WRITE_MULTI,
+ sizeof(*wm), VFIO_USER_NO_REPLY);
+ proxy->wr_multi = wm;
+}
+
+static void vfio_user_add_multi(VFIOProxy *proxy, uint8_t index, off_t offset,
+ uint32_t count, void *data)
+{
+ VFIOUserWRMulti *wm = proxy->wr_multi;
+ VFIOUserWROne *w1 = &wm->wrs[wm->wr_cnt];
+
+ w1->offset = offset;
+ w1->region = index;
+ w1->count = count;
+ memcpy(&w1->data, data, count);
+
+ wm->wr_cnt++;
+ if (wm->wr_cnt == VFIO_USER_MULTI_MAX ||
+ proxy->num_outgoing < VFIO_USER_OUT_LOW) {
+ vfio_user_flush_multi(proxy);
+ }
+}
+
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 flags;
int size = sizeof(*msgp) + count;
+ bool can_multi;
int ret;
if (count > proxy->max_xfer_size) {
return -EINVAL;
}
+ if (proxy->flags & VFIO_PROXY_NO_POST) {
+ post = false;
+ }
+
+ /* write eligible to be in a WRITE_MULTI msg ? */
+ can_multi = (proxy->flags & VFIO_PROXY_USE_MULTI) && post &&
+ count <= VFIO_USER_MULTI_DATA;
+
+ /*
+ * This should be a rare case, so first check without the lock,
+ * if we're wrong, vfio_send_queued() will flush any posted writes
+ * we missed here
+ */
+ if (proxy->wr_multi != NULL ||
+ (proxy->num_outgoing > VFIO_USER_OUT_HIGH && can_multi)) {
+
+ /*
+ * re-check with lock
+ *
+ * if already building a WRITE_MULTI msg,
+ * add this one if possible else flush pending before
+ * sending the current one
+ *
+ * else if outgoing queue is over the highwater,
+ * start a new WRITE_MULTI message
+ */
+ WITH_QEMU_LOCK_GUARD(&proxy->lock) {
+ if (proxy->wr_multi != NULL) {
+ if (can_multi) {
+ vfio_user_add_multi(proxy, index, offset, count, data);
+ return count;
+ }
+ vfio_user_flush_multi(proxy);
+ } else if (proxy->num_outgoing > VFIO_USER_OUT_HIGH && can_multi) {
+ vfio_user_create_multi(proxy);
+ vfio_user_add_multi(proxy, index, offset, count, data);
+ return count;
+ }
+ }
+ }
+
+ flags = post ? VFIO_USER_NO_REPLY : 0;
msgp = g_malloc0(size);
vfio_user_request_msg(&msgp->hdr, VFIO_USER_REGION_WRITE, size, flags);
msgp->offset = offset;
@@ -1567,7 +1691,7 @@ static int vfio_user_region_write(VFIOProxy *proxy, uint8_t index, off_t offset,
memcpy(&msgp->data, data, count);
/* async send will free msg after it's sent */
- if (post && !(proxy->flags & VFIO_PROXY_NO_POST)) {
+ if (post) {
vfio_user_send_async(proxy, &msgp->hdr, NULL);
return count;
}
diff --git a/hw/vfio/user.h b/hw/vfio/user.h
index f711861..c96e74a 100644
--- a/hw/vfio/user.h
+++ b/hw/vfio/user.h
@@ -79,6 +79,8 @@ typedef struct VFIOProxy {
VFIOUserMsg *last_nowait;
VFIOUserMsg *part_recv;
size_t recv_left;
+ VFIOUserWRMulti *wr_multi;
+ int num_outgoing;
enum proxy_state state;
} VFIOProxy;
@@ -87,6 +89,11 @@ typedef struct VFIOProxy {
#define VFIO_PROXY_SECURE 0x2
#define VFIO_PROXY_FORCE_QUEUED 0x4
#define VFIO_PROXY_NO_POST 0x8
+#define VFIO_PROXY_USE_MULTI 0x10
+
+/* coalescing high and low water marks for VFIOProxy num_outgoing */
+#define VFIO_USER_OUT_HIGH 1024
+#define VFIO_USER_OUT_LOW 128
VFIOProxy *vfio_user_connect_dev(SocketAddress *addr, Error **errp);
void vfio_user_disconnect(VFIOProxy *proxy);
--
1.8.3.1
^ permalink raw reply related [flat|nested] 82+ messages in thread
* [PATCH v1 24/24] vfio-user: add trace points
2022-11-08 23:13 [PATCH v1 00/24] vfio-user client John Johnson
` (22 preceding siblings ...)
2022-11-08 23:13 ` [PATCH v1 23/24] vfio-user: add coalesced posted writes John Johnson
@ 2022-11-08 23:13 ` John Johnson
2022-12-15 12:59 ` Cédric Le Goater
2022-12-12 9:41 ` [PATCH v1 00/24] vfio-user client Philippe Mathieu-Daudé
2022-12-16 11:31 ` Cédric Le Goater
25 siblings, 1 reply; 82+ messages in thread
From: John Johnson @ 2022-11-08 23:13 UTC (permalink / raw)
To: qemu-devel
Signed-off-by: John G Johnson <john.g.johnson@oracle.com>
Signed-off-by: Elena Ufimtseva <elena.ufimtseva@oracle.com>
Signed-off-by: Jagannathan Raman <jag.raman@oracle.com>
---
hw/vfio/trace-events | 15 +++++++++++++++
hw/vfio/user.c | 26 ++++++++++++++++++++++++++
2 files changed, 41 insertions(+)
diff --git a/hw/vfio/trace-events b/hw/vfio/trace-events
index 73dffe9..c27cec7 100644
--- a/hw/vfio/trace-events
+++ b/hw/vfio/trace-events
@@ -166,3 +166,18 @@ vfio_load_state_device_data(const char *name, uint64_t data_offset, uint64_t dat
vfio_load_cleanup(const char *name) " (%s)"
vfio_get_dirty_bitmap(int fd, uint64_t iova, uint64_t size, uint64_t bitmap_size, uint64_t start) "container fd=%d, iova=0x%"PRIx64" size= 0x%"PRIx64" bitmap_size=0x%"PRIx64" start=0x%"PRIx64
vfio_iommu_map_dirty_notify(uint64_t iova_start, uint64_t iova_end) "iommu dirty @ 0x%"PRIx64" - 0x%"PRIx64
+
+# user.c
+vfio_user_recv_hdr(const char *name, uint16_t id, uint16_t cmd, uint32_t size, uint32_t flags) " (%s) id 0x%x cmd 0x%x size 0x%x flags 0x%x"
+vfio_user_recv_read(uint16_t id, int read) " id 0x%x read 0x%x"
+vfio_user_recv_request(uint16_t cmd) " command 0x%x"
+vfio_user_send_write(uint16_t id, int wrote) " id 0x%x wrote 0x%x"
+vfio_user_version(uint16_t major, uint16_t minor, const char *caps) " major %d minor %d caps: %s"
+vfio_user_dma_map(uint64_t iova, uint64_t size, uint64_t off, uint32_t flags, bool will_commit) " iova 0x%"PRIx64" size 0x%"PRIx64" off 0x%"PRIx64" flags 0x%x will_commit %d"
+vfio_user_dma_unmap(uint64_t iova, uint64_t size, uint32_t flags, bool dirty, bool will_commit) " iova 0x%"PRIx64" size 0x%"PRIx64" flags 0x%x dirty %d will_commit %d"
+vfio_user_get_info(uint32_t nregions, uint32_t nirqs) " #regions %d #irqs %d"
+vfio_user_get_region_info(uint32_t index, uint32_t flags, uint64_t size) " index %d flags 0x%x size 0x%"PRIx64
+vfio_user_get_irq_info(uint32_t index, uint32_t flags, uint32_t count) " index %d flags 0x%x count %d"
+vfio_user_set_irqs(uint32_t index, uint32_t start, uint32_t count, uint32_t flags) " index %d start %d count %d flags 0x%x"
+vfio_user_region_rw(uint32_t region, uint64_t off, uint32_t count) " region %d offset 0x%"PRIx64" count %d"
+vfio_user_wrmulti(const char *s, uint64_t wr_cnt) " %s count 0x%"PRIx64
diff --git a/hw/vfio/user.c b/hw/vfio/user.c
index 4ed305b..74e1714 100644
--- a/hw/vfio/user.c
+++ b/hw/vfio/user.c
@@ -30,6 +30,8 @@
#include "qapi/qmp/qnum.h"
#include "qapi/qmp/qbool.h"
#include "user.h"
+#include "trace.h"
+
/*
@@ -108,6 +110,8 @@ static int vfio_user_send_qio(VFIOProxy *proxy, VFIOUserMsg *msg)
vfio_user_shutdown(proxy);
error_report_err(local_err);
}
+ trace_vfio_user_send_write(msg->hdr->id, ret);
+
return ret;
}
@@ -225,6 +229,7 @@ static int vfio_user_complete(VFIOProxy *proxy, Error **errp)
}
return ret;
}
+ trace_vfio_user_recv_read(msg->hdr->id, ret);
msgleft -= ret;
data += ret;
@@ -332,6 +337,8 @@ static int vfio_user_recv_one(VFIOProxy *proxy)
error_setg(&local_err, "unknown message type");
goto fatal;
}
+ trace_vfio_user_recv_hdr(proxy->sockname, hdr.id, hdr.command, hdr.size,
+ hdr.flags);
/*
* For replies, find the matching pending request.
@@ -408,6 +415,7 @@ static int vfio_user_recv_one(VFIOProxy *proxy)
if (ret <= 0) {
goto fatal;
}
+ trace_vfio_user_recv_read(hdr.id, ret);
msgleft -= ret;
data += ret;
@@ -546,6 +554,7 @@ static void vfio_user_request(void *opaque)
QTAILQ_INIT(&free);
QTAILQ_FOREACH_SAFE(msg, &new, next, m1) {
QTAILQ_REMOVE(&new, msg, next);
+ trace_vfio_user_recv_request(msg->hdr->command);
proxy->request(proxy->req_arg, msg);
QTAILQ_INSERT_HEAD(&free, msg, next);
}
@@ -1265,6 +1274,7 @@ int vfio_user_validate_version(VFIOProxy *proxy, Error **errp)
msgp->minor = VFIO_USER_MINOR_VER;
memcpy(&msgp->capabilities, caps->str, caplen);
g_string_free(caps, true);
+ trace_vfio_user_version(msgp->major, msgp->minor, msgp->capabilities);
vfio_user_send_wait(proxy, &msgp->hdr, NULL, 0, false);
if (msgp->hdr.flags & VFIO_USER_ERROR) {
@@ -1288,6 +1298,7 @@ int vfio_user_validate_version(VFIOProxy *proxy, Error **errp)
return -1;
}
+ trace_vfio_user_version(msgp->major, msgp->minor, msgp->capabilities);
return 0;
}
@@ -1305,6 +1316,8 @@ static int vfio_user_dma_map(VFIOProxy *proxy,
msgp->offset = map->vaddr;
msgp->iova = map->iova;
msgp->size = map->size;
+ trace_vfio_user_dma_map(msgp->iova, msgp->size, msgp->offset, msgp->flags,
+ will_commit);
/*
* The will_commit case sends without blocking or dropping BQL.
@@ -1371,6 +1384,8 @@ static int vfio_user_dma_unmap(VFIOProxy *proxy,
msgp->msg.flags = unmap->flags;
msgp->msg.iova = unmap->iova;
msgp->msg.size = unmap->size;
+ trace_vfio_user_dma_unmap(msgp->msg.iova, msgp->msg.size, msgp->msg.flags,
+ bitmap != NULL, will_commit);
if (blocking) {
vfio_user_send_wait(proxy, &msgp->msg.hdr, NULL, rsize, will_commit);
@@ -1400,6 +1415,7 @@ static int vfio_user_get_info(VFIOProxy *proxy, struct vfio_device_info *info)
if (msg.hdr.flags & VFIO_USER_ERROR) {
return -msg.hdr.error_reply;
}
+ trace_vfio_user_get_info(msg.num_regions, msg.num_irqs);
memcpy(info, &msg.argsz, sizeof(*info));
return 0;
@@ -1434,6 +1450,7 @@ static int vfio_user_get_region_info(VFIOProxy *proxy,
if (msgp->hdr.flags & VFIO_USER_ERROR) {
return -msgp->hdr.error_reply;
}
+ trace_vfio_user_get_region_info(msgp->index, msgp->flags, msgp->size);
memcpy(info, &msgp->argsz, info->argsz);
return 0;
@@ -1454,6 +1471,7 @@ static int vfio_user_get_irq_info(VFIOProxy *proxy,
if (msg.hdr.flags & VFIO_USER_ERROR) {
return -msg.hdr.error_reply;
}
+ trace_vfio_user_get_irq_info(msg.index, msg.flags, msg.count);
memcpy(info, &msg.argsz, sizeof(*info));
return 0;
@@ -1499,6 +1517,8 @@ static int vfio_user_set_irqs(VFIOProxy *proxy, struct vfio_irq_set *irq)
msgp->index = irq->index;
msgp->start = irq->start;
msgp->count = irq->count;
+ trace_vfio_user_set_irqs(msgp->index, msgp->start, msgp->count,
+ msgp->flags);
vfio_user_send_wait(proxy, &msgp->hdr, NULL, 0, false);
if (msgp->hdr.flags & VFIO_USER_ERROR) {
@@ -1535,6 +1555,8 @@ static int vfio_user_set_irqs(VFIOProxy *proxy, struct vfio_irq_set *irq)
msgp->index = irq->index;
msgp->start = irq->start + sent_fds;
msgp->count = send_fds;
+ trace_vfio_user_set_irqs(msgp->index, msgp->start, msgp->count,
+ msgp->flags);
loop_fds.send_fds = send_fds;
loop_fds.recv_fds = 0;
@@ -1565,6 +1587,7 @@ static int vfio_user_region_read(VFIOProxy *proxy, uint8_t index, off_t offset,
msgp->offset = offset;
msgp->region = index;
msgp->count = count;
+ trace_vfio_user_region_rw(msgp->region, msgp->offset, msgp->count);
vfio_user_send_wait(proxy, &msgp->hdr, NULL, size, false);
if (msgp->hdr.flags & VFIO_USER_ERROR) {
@@ -1593,6 +1616,7 @@ static void vfio_user_flush_multi(VFIOProxy *proxy)
msg->id = wm->hdr.id;
msg->rsize = 0;
msg->type = VFIO_MSG_ASYNC;
+ trace_vfio_user_wrmulti("flush", wm->wr_cnt);
ret = vfio_user_send_queued(proxy, msg);
if (ret < 0) {
@@ -1622,6 +1646,7 @@ static void vfio_user_add_multi(VFIOProxy *proxy, uint8_t index, off_t offset,
memcpy(&w1->data, data, count);
wm->wr_cnt++;
+ trace_vfio_user_wrmulti("add", wm->wr_cnt);
if (wm->wr_cnt == VFIO_USER_MULTI_MAX ||
proxy->num_outgoing < VFIO_USER_OUT_LOW) {
vfio_user_flush_multi(proxy);
@@ -1689,6 +1714,7 @@ static int vfio_user_region_write(VFIOProxy *proxy, uint8_t index, off_t offset,
msgp->region = index;
msgp->count = count;
memcpy(&msgp->data, data, count);
+ trace_vfio_user_region_rw(msgp->region, msgp->offset, msgp->count);
/* async send will free msg after it's sent */
if (post) {
--
1.8.3.1
^ permalink raw reply related [flat|nested] 82+ messages in thread
* Re: [PATCH v1 02/24] vfio-user: add VFIO base abstract class
2022-11-08 23:13 ` [PATCH v1 02/24] vfio-user: add VFIO base abstract class John Johnson
@ 2022-12-09 13:54 ` John Levon
2022-12-09 16:04 ` Cédric Le Goater
1 sibling, 0 replies; 82+ messages in thread
From: John Levon @ 2022-12-09 13:54 UTC (permalink / raw)
To: John Johnson; +Cc: qemu-devel
On Tue, Nov 08, 2022 at 03:13:24PM -0800, John Johnson wrote:
> Add an abstract base class both the kernel driver
> and user socket implementations can use to share code.
LGTM
Reviewed-by: John Levon <john.levon@nutanix.com>
regards
john
^ permalink raw reply [flat|nested] 82+ messages in thread
* Re: [PATCH v1 03/24] vfio-user: add container IO ops vector
2022-11-08 23:13 ` [PATCH v1 03/24] vfio-user: add container IO ops vector John Johnson
@ 2022-12-09 14:10 ` John Levon
2022-12-09 16:10 ` Cédric Le Goater
1 sibling, 0 replies; 82+ messages in thread
From: John Levon @ 2022-12-09 14:10 UTC (permalink / raw)
To: John Johnson; +Cc: qemu-devel
On Tue, Nov 08, 2022 at 03:13:25PM -0800, John Johnson wrote:
> Used for communication with VFIO driver
> (prep work for vfio-user, which will communicate over a socket)
> index e573f5a..6fd40f1 100644
> --- a/include/hw/vfio/vfio-common.h
> +++ b/include/hw/vfio/vfio-common.h
> +
> +extern VFIOContIO vfio_cont_io_ioctl;
Nit, there's no need for this to be non-static, it's only used in
hw/vfio/common.c
regards
john
^ permalink raw reply [flat|nested] 82+ messages in thread
* Re: [PATCH v1 04/24] vfio-user: add region cache
2022-11-08 23:13 ` [PATCH v1 04/24] vfio-user: add region cache John Johnson
@ 2022-12-09 14:15 ` John Levon
2022-12-12 7:44 ` Cédric Le Goater
2022-12-12 11:42 ` Philippe Mathieu-Daudé
2 siblings, 0 replies; 82+ messages in thread
From: John Levon @ 2022-12-09 14:15 UTC (permalink / raw)
To: John Johnson; +Cc: qemu-devel
On Tue, Nov 08, 2022 at 03:13:26PM -0800, John Johnson wrote:
> cache VFIO_DEVICE_GET_REGION_INFO results to reduce
> memory alloc/free cycles and as prep work for vfio-user
LGTM
Reviewed-by: John Levon <john.levon@nutanix.com>
regards
john
^ permalink raw reply [flat|nested] 82+ messages in thread
* Re: [PATCH v1 05/24] vfio-user: add device IO ops vector
2022-11-08 23:13 ` [PATCH v1 05/24] vfio-user: add device IO ops vector John Johnson
@ 2022-12-09 14:43 ` John Levon
2022-12-12 7:59 ` Cédric Le Goater
1 sibling, 0 replies; 82+ messages in thread
From: John Levon @ 2022-12-09 14:43 UTC (permalink / raw)
To: John Johnson; +Cc: qemu-devel
On Tue, Nov 08, 2022 at 03:13:27PM -0800, John Johnson wrote:
> Used for communication with VFIO driver
> (prep work for vfio-user, which will communicate over a socket)
>
> @@ -1166,12 +1178,13 @@ uint32_t vfio_pci_read_config(PCIDevice *pdev, uint32_t addr, int len)
> if (~emu_bits & (0xffffffffU >> (32 - len * 8))) {
> ssize_t ret;
>
> - ret = pread(vdev->vbasedev.fd, &phys_val, len,
> - vdev->config_offset + addr);
> + ret = VDEV_CONFIG_READ(vbasedev, addr, len, &phys_val);
> if (ret != len) {
> - error_report("%s(%s, 0x%x, 0x%x) failed: %m",
> - __func__, vdev->vbasedev.name, addr, len);
> - return -errno;
> + const char *err = ret < 0 ? strerror(-ret) : "short read";
> +
> + error_report("%s(%s, 0x%x, 0x%x) failed: %s",
> + __func__, vbasedev->name, addr, len, err);
> + return -1;
Mention this drive-by return value fix in the commit message?
> @@ -1283,10 +1300,13 @@ static int vfio_msi_setup(VFIOPCIDevice *vdev, int pos, Error **errp)
> int ret, entries;
> Error *err = NULL;
>
> - if (pread(vdev->vbasedev.fd, &ctrl, sizeof(ctrl),
> - vdev->config_offset + pos + PCI_CAP_FLAGS) != sizeof(ctrl)) {
> - error_setg_errno(errp, errno, "failed reading MSI PCI_CAP_FLAGS");
> - return -errno;
> + ret = VDEV_CONFIG_READ(&vdev->vbasedev, pos + PCI_CAP_FLAGS,
> + sizeof(ctrl), &ctrl);
> + if (ret != sizeof(ctrl)) {
> + const char *err = ret < 0 ? strerror(-ret) : "short read";
> +
> + error_setg(errp, "failed reading MSI PCI_CAP_FLAGS %s", err);
> + return ret;
I suppose this was already broken, but if we get a short read we won't bubble up
an error properly here since ret is not in -errno form. Probably true of some
other short read paths?
regards
john
^ permalink raw reply [flat|nested] 82+ messages in thread
* Re: [PATCH v1 06/24] vfio-user: Define type vfio_user_pci_dev_info
2022-11-08 23:13 ` [PATCH v1 06/24] vfio-user: Define type vfio_user_pci_dev_info John Johnson
@ 2022-12-09 15:23 ` John Levon
2022-12-12 9:01 ` Cédric Le Goater
1 sibling, 0 replies; 82+ messages in thread
From: John Levon @ 2022-12-09 15:23 UTC (permalink / raw)
To: John Johnson; +Cc: qemu-devel
On Tue, Nov 08, 2022 at 03:13:28PM -0800, John Johnson wrote:
> New class for vfio-user with its class and instance
> constructors and destructors, and its pci ops.
LGTM
Reviewed-by: John Levon <john.levon@nutanix.com>
regards
john
^ permalink raw reply [flat|nested] 82+ messages in thread
* Re: [PATCH v1 07/24] vfio-user: connect vfio proxy to remote server
2022-11-08 23:13 ` [PATCH v1 07/24] vfio-user: connect vfio proxy to remote server John Johnson
@ 2022-12-09 15:23 ` John Levon
2022-12-12 16:24 ` Cédric Le Goater
1 sibling, 0 replies; 82+ messages in thread
From: John Levon @ 2022-12-09 15:23 UTC (permalink / raw)
To: John Johnson; +Cc: qemu-devel
On Tue, Nov 08, 2022 at 03:13:29PM -0800, John Johnson wrote:
> add user.c & user.h files for vfio-user code
> add proxy struct to handle comms with remote server
LGTM
Reviewed-by: John Levon <john.levon@nutanix.com>
regards
john
^ permalink raw reply [flat|nested] 82+ messages in thread
* Re: [PATCH v1 08/24] vfio-user: define socket receive functions
2022-11-08 23:13 ` [PATCH v1 08/24] vfio-user: define socket receive functions John Johnson
@ 2022-12-09 15:34 ` John Levon
2022-12-13 10:45 ` Cédric Le Goater
1 sibling, 0 replies; 82+ messages in thread
From: John Levon @ 2022-12-09 15:34 UTC (permalink / raw)
To: John Johnson; +Cc: qemu-devel
On Tue, Nov 08, 2022 at 03:13:30PM -0800, John Johnson wrote:
> Add infrastructure needed to receive incoming messages
>
> +static void vfio_user_process(VFIOProxy *proxy, VFIOUserMsg *msg, bool isreply)
> +{
> +
> + /*
> + * 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 (msg->hdr->flags & VFIO_USER_ERROR) {
> + error_printf("vfio_user_rcv: error reply on async request ");
nit, s/vfio_user_rcv/vfio_user_process/ , or even __func__ ?
> + error_prepend(&local_err, "vfio_user_recv: ");
nit, same here
regards
john
^ permalink raw reply [flat|nested] 82+ messages in thread
* Re: [PATCH v1 09/24] vfio-user: define socket send functions
2022-11-08 23:13 ` [PATCH v1 09/24] vfio-user: define socket send functions John Johnson
@ 2022-12-09 15:52 ` John Levon
2022-12-13 13:48 ` Cédric Le Goater
1 sibling, 0 replies; 82+ messages in thread
From: John Levon @ 2022-12-09 15:52 UTC (permalink / raw)
To: John Johnson; +Cc: qemu-devel
On Tue, Nov 08, 2022 at 03:13:31PM -0800, John Johnson wrote:
> Also negotiate protocol version with remote server
LGTM
Reviewed-by: John Levon <john.levon@nutanix.com>
regards
john
^ permalink raw reply [flat|nested] 82+ messages in thread
* Re: [PATCH v1 10/24] vfio-user: get device info
2022-11-08 23:13 ` [PATCH v1 10/24] vfio-user: get device info John Johnson
@ 2022-12-09 15:57 ` John Levon
2022-12-12 20:28 ` John Johnson
2022-12-13 14:06 ` Cédric Le Goater
1 sibling, 1 reply; 82+ messages in thread
From: John Levon @ 2022-12-09 15:57 UTC (permalink / raw)
To: John Johnson; +Cc: qemu-devel
On Tue, Nov 08, 2022 at 03:13:32PM -0800, John Johnson wrote:
> +/*
> + * 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;
The server doesn't have or populate cap_offset - and this isn't in the protocol
either.
Looks good otherwise
regards
john
^ permalink raw reply [flat|nested] 82+ messages in thread
* Re: [PATCH v1 02/24] vfio-user: add VFIO base abstract class
2022-11-08 23:13 ` [PATCH v1 02/24] vfio-user: add VFIO base abstract class John Johnson
2022-12-09 13:54 ` John Levon
@ 2022-12-09 16:04 ` Cédric Le Goater
2022-12-12 20:30 ` John Johnson
1 sibling, 1 reply; 82+ messages in thread
From: Cédric Le Goater @ 2022-12-09 16:04 UTC (permalink / raw)
To: John Johnson, qemu-devel
Hello John,
On 11/9/22 00:13, John Johnson wrote:
> Add an abstract base class both the kernel driver
> and user socket implementations can use to share code.
>
> Signed-off-by: John G Johnson <john.g.johnson@oracle.com>
> Signed-off-by: Elena Ufimtseva <elena.ufimtseva@oracle.com>
> Signed-off-by: Jagannathan Raman <jag.raman@oracle.com>
I would help the reader if the header files came first. You could use :
[diff]
orderFile = /path/to/qemu/scripts/git.orderfile
I would simply use 'Kernel' instead of 'Kern' in the type definition.
A part from that,
Reviewed-by: Cédric Le Goater <clg@redhat.com>
Thanks,
C.
> ---
> hw/vfio/pci.c | 106 +++++++++++++++++++++++++++++++++++-----------------------
> hw/vfio/pci.h | 16 +++++++--
> 2 files changed, 78 insertions(+), 44 deletions(-)
>
> diff --git a/hw/vfio/pci.c b/hw/vfio/pci.c
> index 939dcc3..60acde5 100644
> --- a/hw/vfio/pci.c
> +++ b/hw/vfio/pci.c
> @@ -235,7 +235,7 @@ static void vfio_intx_update(VFIOPCIDevice *vdev, PCIINTxRoute *route)
>
> static void vfio_intx_routing_notifier(PCIDevice *pdev)
> {
> - VFIOPCIDevice *vdev = VFIO_PCI(pdev);
> + VFIOPCIDevice *vdev = VFIO_PCI_BASE(pdev);
> PCIINTxRoute route;
>
> if (vdev->interrupt != VFIO_INT_INTx) {
> @@ -467,7 +467,7 @@ static void vfio_update_kvm_msi_virq(VFIOMSIVector *vector, MSIMessage msg,
> static int vfio_msix_vector_do_use(PCIDevice *pdev, unsigned int nr,
> MSIMessage *msg, IOHandler *handler)
> {
> - VFIOPCIDevice *vdev = VFIO_PCI(pdev);
> + VFIOPCIDevice *vdev = VFIO_PCI_BASE(pdev);
> VFIOMSIVector *vector;
> int ret;
>
> @@ -561,7 +561,7 @@ static int vfio_msix_vector_use(PCIDevice *pdev,
>
> static void vfio_msix_vector_release(PCIDevice *pdev, unsigned int nr)
> {
> - VFIOPCIDevice *vdev = VFIO_PCI(pdev);
> + VFIOPCIDevice *vdev = VFIO_PCI_BASE(pdev);
> VFIOMSIVector *vector = &vdev->msi_vectors[nr];
>
> trace_vfio_msix_vector_release(vdev->vbasedev.name, nr);
> @@ -1109,7 +1109,7 @@ static const MemoryRegionOps vfio_vga_ops = {
> */
> static void vfio_sub_page_bar_update_mapping(PCIDevice *pdev, int bar)
> {
> - VFIOPCIDevice *vdev = VFIO_PCI(pdev);
> + VFIOPCIDevice *vdev = VFIO_PCI_BASE(pdev);
> VFIORegion *region = &vdev->bars[bar].region;
> MemoryRegion *mmap_mr, *region_mr, *base_mr;
> PCIIORegion *r;
> @@ -1155,7 +1155,7 @@ static void vfio_sub_page_bar_update_mapping(PCIDevice *pdev, int bar)
> */
> uint32_t vfio_pci_read_config(PCIDevice *pdev, uint32_t addr, int len)
> {
> - VFIOPCIDevice *vdev = VFIO_PCI(pdev);
> + VFIOPCIDevice *vdev = VFIO_PCI_BASE(pdev);
> uint32_t emu_bits = 0, emu_val = 0, phys_val = 0, val;
>
> memcpy(&emu_bits, vdev->emulated_config_bits + addr, len);
> @@ -1188,7 +1188,7 @@ uint32_t vfio_pci_read_config(PCIDevice *pdev, uint32_t addr, int len)
> void vfio_pci_write_config(PCIDevice *pdev,
> uint32_t addr, uint32_t val, int len)
> {
> - VFIOPCIDevice *vdev = VFIO_PCI(pdev);
> + VFIOPCIDevice *vdev = VFIO_PCI_BASE(pdev);
> uint32_t val_le = cpu_to_le32(val);
>
> trace_vfio_pci_write_config(vdev->vbasedev.name, addr, val, len);
> @@ -2845,7 +2845,7 @@ static void vfio_unregister_req_notifier(VFIOPCIDevice *vdev)
>
> static void vfio_realize(PCIDevice *pdev, Error **errp)
> {
> - VFIOPCIDevice *vdev = VFIO_PCI(pdev);
> + VFIOPCIDevice *vdev = VFIO_PCI_BASE(pdev);
> VFIODevice *vbasedev = &vdev->vbasedev;
> VFIODevice *vbasedev_iter;
> VFIOGroup *group;
> @@ -3169,7 +3169,7 @@ error:
>
> static void vfio_instance_finalize(Object *obj)
> {
> - VFIOPCIDevice *vdev = VFIO_PCI(obj);
> + VFIOPCIDevice *vdev = VFIO_PCI_BASE(obj);
> VFIOGroup *group = vdev->vbasedev.group;
>
> vfio_display_finalize(vdev);
> @@ -3189,7 +3189,7 @@ static void vfio_instance_finalize(Object *obj)
>
> static void vfio_exitfn(PCIDevice *pdev)
> {
> - VFIOPCIDevice *vdev = VFIO_PCI(pdev);
> + VFIOPCIDevice *vdev = VFIO_PCI_BASE(pdev);
>
> vfio_unregister_req_notifier(vdev);
> vfio_unregister_err_notifier(vdev);
> @@ -3208,7 +3208,7 @@ static void vfio_exitfn(PCIDevice *pdev)
>
> static void vfio_pci_reset(DeviceState *dev)
> {
> - VFIOPCIDevice *vdev = VFIO_PCI(dev);
> + VFIOPCIDevice *vdev = VFIO_PCI_BASE(dev);
>
> trace_vfio_pci_reset(vdev->vbasedev.name);
>
> @@ -3248,7 +3248,7 @@ post_reset:
> static void vfio_instance_init(Object *obj)
> {
> PCIDevice *pci_dev = PCI_DEVICE(obj);
> - VFIOPCIDevice *vdev = VFIO_PCI(obj);
> + VFIOPCIDevice *vdev = VFIO_PCI_BASE(obj);
>
> device_add_bootindex_property(obj, &vdev->bootindex,
> "bootindex", NULL,
> @@ -3265,24 +3265,12 @@ static void vfio_instance_init(Object *obj)
> pci_dev->cap_present |= QEMU_PCI_CAP_EXPRESS;
> }
>
> -static Property vfio_pci_dev_properties[] = {
> - DEFINE_PROP_PCI_HOST_DEVADDR("host", VFIOPCIDevice, host),
> - DEFINE_PROP_STRING("sysfsdev", VFIOPCIDevice, vbasedev.sysfsdev),
> +static Property vfio_pci_base_dev_properties[] = {
> DEFINE_PROP_ON_OFF_AUTO("x-pre-copy-dirty-page-tracking", VFIOPCIDevice,
> vbasedev.pre_copy_dirty_page_tracking,
> ON_OFF_AUTO_ON),
> - DEFINE_PROP_ON_OFF_AUTO("display", VFIOPCIDevice,
> - display, ON_OFF_AUTO_OFF),
> - DEFINE_PROP_UINT32("xres", VFIOPCIDevice, display_xres, 0),
> - DEFINE_PROP_UINT32("yres", VFIOPCIDevice, display_yres, 0),
> DEFINE_PROP_UINT32("x-intx-mmap-timeout-ms", VFIOPCIDevice,
> intx.mmap_timeout, 1100),
> - DEFINE_PROP_BIT("x-vga", VFIOPCIDevice, features,
> - VFIO_FEATURE_ENABLE_VGA_BIT, false),
> - DEFINE_PROP_BIT("x-req", VFIOPCIDevice, features,
> - VFIO_FEATURE_ENABLE_REQ_BIT, true),
> - DEFINE_PROP_BIT("x-igd-opregion", VFIOPCIDevice, features,
> - VFIO_FEATURE_ENABLE_IGD_OPREGION_BIT, false),
> DEFINE_PROP_BOOL("x-enable-migration", VFIOPCIDevice,
> vbasedev.enable_migration, false),
> DEFINE_PROP_BOOL("x-no-mmap", VFIOPCIDevice, vbasedev.no_mmap, false),
> @@ -3291,8 +3279,6 @@ static Property vfio_pci_dev_properties[] = {
> DEFINE_PROP_BOOL("x-no-kvm-intx", VFIOPCIDevice, no_kvm_intx, false),
> DEFINE_PROP_BOOL("x-no-kvm-msi", VFIOPCIDevice, no_kvm_msi, false),
> DEFINE_PROP_BOOL("x-no-kvm-msix", VFIOPCIDevice, no_kvm_msix, false),
> - DEFINE_PROP_BOOL("x-no-geforce-quirks", VFIOPCIDevice,
> - no_geforce_quirks, false),
> DEFINE_PROP_BOOL("x-no-kvm-ioeventfd", VFIOPCIDevice, no_kvm_ioeventfd,
> false),
> DEFINE_PROP_BOOL("x-no-vfio-ioeventfd", VFIOPCIDevice, no_vfio_ioeventfd,
> @@ -3303,10 +3289,6 @@ static Property vfio_pci_dev_properties[] = {
> sub_vendor_id, PCI_ANY_ID),
> DEFINE_PROP_UINT32("x-pci-sub-device-id", VFIOPCIDevice,
> sub_device_id, PCI_ANY_ID),
> - DEFINE_PROP_UINT32("x-igd-gms", VFIOPCIDevice, igd_gms, 0),
> - DEFINE_PROP_UNSIGNED_NODEFAULT("x-nv-gpudirect-clique", VFIOPCIDevice,
> - nv_gpudirect_clique,
> - qdev_prop_nv_gpudirect_clique, uint8_t),
> DEFINE_PROP_OFF_AUTO_PCIBAR("x-msix-relocation", VFIOPCIDevice, msix_relo,
> OFF_AUTOPCIBAR_OFF),
> /*
> @@ -3317,28 +3299,25 @@ static Property vfio_pci_dev_properties[] = {
> DEFINE_PROP_END_OF_LIST(),
> };
>
> -static void vfio_pci_dev_class_init(ObjectClass *klass, void *data)
> +static void vfio_pci_base_dev_class_init(ObjectClass *klass, void *data)
> {
> DeviceClass *dc = DEVICE_CLASS(klass);
> PCIDeviceClass *pdc = PCI_DEVICE_CLASS(klass);
>
> - dc->reset = vfio_pci_reset;
> - device_class_set_props(dc, vfio_pci_dev_properties);
> - dc->desc = "VFIO-based PCI device assignment";
> + device_class_set_props(dc, vfio_pci_base_dev_properties);
> + dc->desc = "VFIO PCI base device";
> set_bit(DEVICE_CATEGORY_MISC, dc->categories);
> - pdc->realize = vfio_realize;
> pdc->exit = vfio_exitfn;
> pdc->config_read = vfio_pci_read_config;
> pdc->config_write = vfio_pci_write_config;
> }
>
> -static const TypeInfo vfio_pci_dev_info = {
> - .name = TYPE_VFIO_PCI,
> +static const TypeInfo vfio_pci_base_dev_info = {
> + .name = TYPE_VFIO_PCI_BASE,
> .parent = TYPE_PCI_DEVICE,
> - .instance_size = sizeof(VFIOPCIDevice),
> - .class_init = vfio_pci_dev_class_init,
> - .instance_init = vfio_instance_init,
> - .instance_finalize = vfio_instance_finalize,
> + .instance_size = 0,
> + .abstract = true,
> + .class_init = vfio_pci_base_dev_class_init,
> .interfaces = (InterfaceInfo[]) {
> { INTERFACE_PCIE_DEVICE },
> { INTERFACE_CONVENTIONAL_PCI_DEVICE },
> @@ -3346,6 +3325,48 @@ static const TypeInfo vfio_pci_dev_info = {
> },
> };
>
> +static Property vfio_pci_dev_properties[] = {
> + DEFINE_PROP_PCI_HOST_DEVADDR("host", VFIOPCIDevice, host),
> + DEFINE_PROP_STRING("sysfsdev", VFIOPCIDevice, vbasedev.sysfsdev),
> + DEFINE_PROP_ON_OFF_AUTO("display", VFIOPCIDevice,
> + display, ON_OFF_AUTO_OFF),
> + DEFINE_PROP_UINT32("xres", VFIOPCIDevice, display_xres, 0),
> + DEFINE_PROP_UINT32("yres", VFIOPCIDevice, display_yres, 0),
> + DEFINE_PROP_BIT("x-vga", VFIOPCIDevice, features,
> + VFIO_FEATURE_ENABLE_VGA_BIT, false),
> + DEFINE_PROP_BIT("x-req", VFIOPCIDevice, features,
> + VFIO_FEATURE_ENABLE_REQ_BIT, true),
> + DEFINE_PROP_BIT("x-igd-opregion", VFIOPCIDevice, features,
> + VFIO_FEATURE_ENABLE_IGD_OPREGION_BIT, false),
> + DEFINE_PROP_BOOL("x-no-geforce-quirks", VFIOPCIDevice,
> + no_geforce_quirks, false),
> + DEFINE_PROP_UINT32("x-igd-gms", VFIOPCIDevice, igd_gms, 0),
> + DEFINE_PROP_UNSIGNED_NODEFAULT("x-nv-gpudirect-clique", VFIOPCIDevice,
> + nv_gpudirect_clique,
> + qdev_prop_nv_gpudirect_clique, uint8_t),
> + DEFINE_PROP_END_OF_LIST(),
> +};
> +
> +static void vfio_pci_dev_class_init(ObjectClass *klass, void *data)
> +{
> + DeviceClass *dc = DEVICE_CLASS(klass);
> + PCIDeviceClass *pdc = PCI_DEVICE_CLASS(klass);
> +
> + dc->reset = vfio_pci_reset;
> + device_class_set_props(dc, vfio_pci_dev_properties);
> + dc->desc = "VFIO-based PCI device assignment";
> + pdc->realize = vfio_realize;
> +}
> +
> +static const TypeInfo vfio_pci_dev_info = {
> + .name = TYPE_VFIO_PCI,
> + .parent = TYPE_VFIO_PCI_BASE,
> + .instance_size = sizeof(VFIOKernPCIDevice),
> + .class_init = vfio_pci_dev_class_init,
> + .instance_init = vfio_instance_init,
> + .instance_finalize = vfio_instance_finalize,
> +};
> +
> static Property vfio_pci_dev_nohotplug_properties[] = {
> DEFINE_PROP_BOOL("ramfb", VFIOPCIDevice, enable_ramfb, false),
> DEFINE_PROP_END_OF_LIST(),
> @@ -3362,12 +3383,13 @@ static void vfio_pci_nohotplug_dev_class_init(ObjectClass *klass, void *data)
> static const TypeInfo vfio_pci_nohotplug_dev_info = {
> .name = TYPE_VFIO_PCI_NOHOTPLUG,
> .parent = TYPE_VFIO_PCI,
> - .instance_size = sizeof(VFIOPCIDevice),
> + .instance_size = sizeof(VFIOKernPCIDevice),
> .class_init = vfio_pci_nohotplug_dev_class_init,
> };
>
> static void register_vfio_pci_dev_type(void)
> {
> + type_register_static(&vfio_pci_base_dev_info);
> type_register_static(&vfio_pci_dev_info);
> type_register_static(&vfio_pci_nohotplug_dev_info);
> }
> diff --git a/hw/vfio/pci.h b/hw/vfio/pci.h
> index 7c236a5..7c5c8ec 100644
> --- a/hw/vfio/pci.h
> +++ b/hw/vfio/pci.h
> @@ -115,8 +115,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;
> @@ -177,6 +182,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)
> {
^ permalink raw reply [flat|nested] 82+ messages in thread
* Re: [PATCH v1 03/24] vfio-user: add container IO ops vector
2022-11-08 23:13 ` [PATCH v1 03/24] vfio-user: add container IO ops vector John Johnson
2022-12-09 14:10 ` John Levon
@ 2022-12-09 16:10 ` Cédric Le Goater
2022-12-12 9:40 ` Philippe Mathieu-Daudé
1 sibling, 1 reply; 82+ messages in thread
From: Cédric Le Goater @ 2022-12-09 16:10 UTC (permalink / raw)
To: John Johnson, qemu-devel
Hello John,
On 11/9/22 00:13, John Johnson wrote:
> Used for communication with VFIO driver
> (prep work for vfio-user, which will communicate over a socket)
>
> Signed-off-by: John G Johnson <john.g.johnson@oracle.com>
> ---
> hw/vfio/common.c | 126 ++++++++++++++++++++++++++++--------------
> include/hw/vfio/vfio-common.h | 33 +++++++++++
> 2 files changed, 117 insertions(+), 42 deletions(-)
>
> diff --git a/hw/vfio/common.c b/hw/vfio/common.c
> index ace9562..83d69b9 100644
> --- a/hw/vfio/common.c
> +++ b/hw/vfio/common.c
> @@ -432,12 +432,12 @@ static int vfio_dma_unmap_bitmap(VFIOContainer *container,
> goto unmap_exit;
> }
>
> - ret = ioctl(container->fd, VFIO_IOMMU_UNMAP_DMA, unmap);
> + ret = CONT_DMA_UNMAP(container, unmap, bitmap);
I am not sure these macros are very useful, compared to :
container->ops->dma_unmap(container, unmap, bitmap);
> if (!ret) {
> cpu_physical_memory_set_dirty_lebitmap((unsigned long *)bitmap->data,
> iotlb->translated_addr, pages);
> } else {
> - error_report("VFIO_UNMAP_DMA with DIRTY_BITMAP : %m");
> + error_report("VFIO_UNMAP_DMA with DIRTY_BITMAP : %s", strerror(-ret));
> }
>
> g_free(bitmap->data);
> @@ -465,30 +465,7 @@ static int vfio_dma_unmap(VFIOContainer *container,
> return vfio_dma_unmap_bitmap(container, iova, size, iotlb);
> }
>
> - while (ioctl(container->fd, VFIO_IOMMU_UNMAP_DMA, &unmap)) {
> - /*
> - * The type1 backend has an off-by-one bug in the kernel (71a7d3d78e3c
> - * v4.15) where an overflow in its wrap-around check prevents us from
> - * unmapping the last page of the address space. Test for the error
> - * condition and re-try the unmap excluding the last page. The
> - * expectation is that we've never mapped the last page anyway and this
> - * unmap request comes via vIOMMU support which also makes it unlikely
> - * that this page is used. This bug was introduced well after type1 v2
> - * support was introduced, so we shouldn't need to test for v1. A fix
> - * is queued for kernel v5.0 so this workaround can be removed once
> - * affected kernels are sufficiently deprecated.
> - */
> - if (errno == EINVAL && unmap.size && !(unmap.iova + unmap.size) &&
> - container->iommu_type == VFIO_TYPE1v2_IOMMU) {
> - trace_vfio_dma_unmap_overflow_workaround();
> - unmap.size -= 1ULL << ctz64(container->pgsizes);
> - continue;
> - }
> - error_report("VFIO_UNMAP_DMA failed: %s", strerror(errno));
> - return -errno;
> - }
> -
> - return 0;
> + return CONT_DMA_UNMAP(container, &unmap, NULL);
> }
>
> static int vfio_dma_map(VFIOContainer *container, hwaddr iova,
> @@ -501,24 +478,18 @@ static int vfio_dma_map(VFIOContainer *container, hwaddr iova,
> .iova = iova,
> .size = size,
> };
> + int ret;
>
> if (!readonly) {
> map.flags |= VFIO_DMA_MAP_FLAG_WRITE;
> }
>
> - /*
> - * Try the mapping, if it fails with EBUSY, unmap the region and try
> - * again. This shouldn't be necessary, but we sometimes see it in
> - * the VGA ROM space.
> - */
> - if (ioctl(container->fd, VFIO_IOMMU_MAP_DMA, &map) == 0 ||
> - (errno == EBUSY && vfio_dma_unmap(container, iova, size, NULL) == 0 &&
> - ioctl(container->fd, VFIO_IOMMU_MAP_DMA, &map) == 0)) {
> - return 0;
> - }
> + ret = CONT_DMA_MAP(container, &map);
>
> - error_report("VFIO_MAP_DMA failed: %s", strerror(errno));
> - return -errno;
> + if (ret < 0) {
> + error_report("VFIO_MAP_DMA failed: %s", strerror(-ret));
> + }
> + return ret;
> }
>
> static void vfio_host_win_add(VFIOContainer *container,
> @@ -1263,10 +1234,10 @@ static void vfio_set_dirty_page_tracking(VFIOContainer *container, bool start)
> dirty.flags = VFIO_IOMMU_DIRTY_PAGES_FLAG_STOP;
> }
>
> - ret = ioctl(container->fd, VFIO_IOMMU_DIRTY_PAGES, &dirty);
> + ret = CONT_DIRTY_BITMAP(container, &dirty, NULL);
> if (ret) {
> error_report("Failed to set dirty tracking flag 0x%x errno: %d",
> - dirty.flags, errno);
> + dirty.flags, -ret);
> }
> }
>
> @@ -1316,11 +1287,11 @@ static int vfio_get_dirty_bitmap(VFIOContainer *container, uint64_t iova,
> goto err_out;
> }
>
> - ret = ioctl(container->fd, VFIO_IOMMU_DIRTY_PAGES, dbitmap);
> + ret = CONT_DIRTY_BITMAP(container, dbitmap, range);
> if (ret) {
> error_report("Failed to get dirty bitmap for iova: 0x%"PRIx64
> " size: 0x%"PRIx64" err: %d", (uint64_t)range->iova,
> - (uint64_t)range->size, errno);
> + (uint64_t)range->size, -ret);
> goto err_out;
> }
>
> @@ -2090,6 +2061,7 @@ static int vfio_connect_container(VFIOGroup *group, AddressSpace *as,
> container->error = NULL;
> container->dirty_pages_supported = false;
> container->dma_max_mappings = 0;
> + container->io_ops = &vfio_cont_io_ioctl;
> QLIST_INIT(&container->giommu_list);
> QLIST_INIT(&container->hostwin_list);
> QLIST_INIT(&container->vrdl_list);
> @@ -2626,3 +2598,73 @@ int vfio_eeh_as_op(AddressSpace *as, uint32_t op)
> }
> return vfio_eeh_container_op(container, op);
> }
> +
> +/*
> + * Traditional ioctl() based io_ops
> + */
> +
> +static int vfio_io_dma_map(VFIOContainer *container,
> + struct vfio_iommu_type1_dma_map *map)
> +{
> +
> + /*
> + * Try the mapping, if it fails with EBUSY, unmap the region and try
> + * again. This shouldn't be necessary, but we sometimes see it in
> + * the VGA ROM space.
> + */
> + if (ioctl(container->fd, VFIO_IOMMU_MAP_DMA, map) == 0 ||
> + (errno == EBUSY &&
> + vfio_dma_unmap(container, map->iova, map->size, NULL) == 0 &&
> + ioctl(container->fd, VFIO_IOMMU_MAP_DMA, map) == 0)) {
> + return 0;
> + }
> + return -errno;
> +}
> +
> +static int vfio_io_dma_unmap(VFIOContainer *container,
> + struct vfio_iommu_type1_dma_unmap *unmap,
> + struct vfio_bitmap *bitmap)
> +{
> +
> + while (ioctl(container->fd, VFIO_IOMMU_UNMAP_DMA, unmap)) {
> + /*
> + * The type1 backend has an off-by-one bug in the kernel (71a7d3d78e3c
> + * v4.15) where an overflow in its wrap-around check prevents us from
> + * unmapping the last page of the address space. Test for the error
> + * condition and re-try the unmap excluding the last page. The
> + * expectation is that we've never mapped the last page anyway and this
> + * unmap request comes via vIOMMU support which also makes it unlikely
> + * that this page is used. This bug was introduced well after type1 v2
> + * support was introduced, so we shouldn't need to test for v1. A fix
> + * is queued for kernel v5.0 so this workaround can be removed once
> + * affected kernels are sufficiently deprecated.
> + */
> + if (errno == EINVAL && unmap->size && !(unmap->iova + unmap->size) &&
> + container->iommu_type == VFIO_TYPE1v2_IOMMU) {
> + trace_vfio_dma_unmap_overflow_workaround();
> + unmap->size -= 1ULL << ctz64(container->pgsizes);
> + continue;
> + }
> + error_report("VFIO_UNMAP_DMA failed: %s", strerror(errno));
> + return -errno;
> + }
> +
> + return 0;
> +}
> +
> +static int vfio_io_dirty_bitmap(VFIOContainer *container,
> + struct vfio_iommu_type1_dirty_bitmap *bitmap,
> + struct vfio_iommu_type1_dirty_bitmap_get *range)
> +{
> + int ret;
> +
> + ret = ioctl(container->fd, VFIO_IOMMU_DIRTY_PAGES, bitmap);
> +
> + return ret < 0 ? -errno : ret;
> +}
> +
> +VFIOContIO vfio_cont_io_ioctl = {
> + .dma_map = vfio_io_dma_map,
> + .dma_unmap = vfio_io_dma_unmap,
> + .dirty_bitmap = vfio_io_dirty_bitmap,
> +};
> diff --git a/include/hw/vfio/vfio-common.h b/include/hw/vfio/vfio-common.h
> index e573f5a..6fd40f1 100644
> --- a/include/hw/vfio/vfio-common.h
> +++ b/include/hw/vfio/vfio-common.h
> @@ -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;
ops should be enough.
> 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 {
VFIOContainerOps seems more adequate with the current VFIO terminology
in QEMU.
Thanks,
C.
> + 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;
^ permalink raw reply [flat|nested] 82+ messages in thread
* Re: [PATCH v1 11/24] vfio-user: get region info
2022-11-08 23:13 ` [PATCH v1 11/24] vfio-user: get region info John Johnson
@ 2022-12-09 17:04 ` John Levon
2022-12-13 15:15 ` Cédric Le Goater
1 sibling, 0 replies; 82+ messages in thread
From: John Levon @ 2022-12-09 17:04 UTC (permalink / raw)
To: John Johnson; +Cc: qemu-devel
On Tue, Nov 08, 2022 at 03:13:33PM -0800, John Johnson wrote:
> Add per-region FD to support mmap() of remote device regions
>
> +/*
> + * VFIO_USER_DEVICE_GET_REGION_INFO
> + * imported from struct_vfio_region_info
s/struct_vfio_region_info/struct vfio_region_info/
regards
john
^ permalink raw reply [flat|nested] 82+ messages in thread
* Re: [PATCH v1 12/24] vfio-user: region read/write
2022-11-08 23:13 ` [PATCH v1 12/24] vfio-user: region read/write John Johnson
@ 2022-12-09 17:11 ` John Levon
2022-12-13 16:13 ` Cédric Le Goater
1 sibling, 0 replies; 82+ messages in thread
From: John Levon @ 2022-12-09 17:11 UTC (permalink / raw)
To: John Johnson; +Cc: qemu-devel
On Tue, Nov 08, 2022 at 03:13:34PM -0800, John Johnson wrote:
> Add support for posted writes on remote devices
LGTM
Reviewed-by: John Levon <john.levon@nutanix.com>
regards
john
^ permalink raw reply [flat|nested] 82+ messages in thread
* Re: [PATCH v1 13/24] vfio-user: pci_user_realize PCI setup
2022-11-08 23:13 ` [PATCH v1 13/24] vfio-user: pci_user_realize PCI setup John Johnson
@ 2022-12-09 17:22 ` John Levon
2022-12-13 16:13 ` Cédric Le Goater
1 sibling, 0 replies; 82+ messages in thread
From: John Levon @ 2022-12-09 17:22 UTC (permalink / raw)
To: John Johnson; +Cc: qemu-devel
On Tue, Nov 08, 2022 at 03:13:35PM -0800, John Johnson wrote:
> PCI BARs read from remote device
> PCI config reads/writes sent to remote server
Reviewed-by: John Levon <john.levon@nutanix.com>
regards
john
^ permalink raw reply [flat|nested] 82+ messages in thread
* Re: [PATCH v1 14/24] vfio-user: get and set IRQs
2022-11-08 23:13 ` [PATCH v1 14/24] vfio-user: get and set IRQs John Johnson
@ 2022-12-09 17:29 ` John Levon
2022-12-12 20:28 ` John Johnson
2022-12-13 16:39 ` Cédric Le Goater
1 sibling, 1 reply; 82+ messages in thread
From: John Levon @ 2022-12-09 17:29 UTC (permalink / raw)
To: John Johnson; +Cc: qemu-devel
On Tue, Nov 08, 2022 at 03:13:36PM -0800, John Johnson wrote:
> +static int vfio_user_io_get_irq_info(VFIODevice *vbasedev,
> + struct vfio_irq_info *irq)
> +{
> + int ret;
> +
> + ret = vfio_user_get_irq_info(vbasedev->proxy, irq);
> + if (ret) {
> + return ret;
> + }
> +
> + if (irq->index > vbasedev->num_irqs) {
> + return -EINVAL;
> + }
Why are we validating ->index *after* requesting the info? Seems a bit weird?
regards
john
^ permalink raw reply [flat|nested] 82+ messages in thread
* Re: [PATCH v1 15/24] vfio-user: forward msix BAR accesses to server
2022-11-08 23:13 ` [PATCH v1 15/24] vfio-user: forward msix BAR accesses to server John Johnson
@ 2022-12-09 17:45 ` John Levon
2022-12-14 17:00 ` Cédric Le Goater
1 sibling, 0 replies; 82+ messages in thread
From: John Levon @ 2022-12-09 17:45 UTC (permalink / raw)
To: John Johnson; +Cc: qemu-devel
On Tue, Nov 08, 2022 at 03:13:37PM -0800, John Johnson wrote:
> Server holds device current device pending state
> Use irq masking commands in socket case
As far as I'm able to tell, this looks good to me
regards
john
^ permalink raw reply [flat|nested] 82+ messages in thread
* Re: [PATCH v1 16/24] vfio-user: proxy container connect/disconnect
2022-11-08 23:13 ` [PATCH v1 16/24] vfio-user: proxy container connect/disconnect John Johnson
@ 2022-12-09 17:54 ` John Levon
2022-12-14 17:59 ` Cédric Le Goater
1 sibling, 0 replies; 82+ messages in thread
From: John Levon @ 2022-12-09 17:54 UTC (permalink / raw)
To: John Johnson; +Cc: qemu-devel
On Tue, Nov 08, 2022 at 03:13:38PM -0800, John Johnson wrote:
> + /*
> + * The proxy uses a SW IOMMU in lieu of the HW one
> + * used in the ioctl() version. Mascarade as TYPE1
> + * for maximum capatibility
> + */
capability
> @@ -3692,12 +3698,18 @@ static void vfio_user_instance_finalize(Object *obj)
> {
> VFIOPCIDevice *vdev = VFIO_PCI_BASE(obj);
> VFIODevice *vbasedev = &vdev->vbasedev;
> + VFIOGroup *group = vbasedev->group;
> +
> + vfio_bars_finalize(vdev);
> + g_free(vdev->emulated_config_bits);
> + g_free(vdev->rom);
These changes seem unrelated to this particular patch?
> diff --git a/include/hw/vfio/vfio-common.h b/include/hw/vfio/vfio-common.h
> index 793ca94..312ef9c 100644
> --- a/include/hw/vfio/vfio-common.h
> +++ b/include/hw/vfio/vfio-common.h
> @@ -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;
> @@ -282,6 +283,11 @@ void vfio_put_group(VFIOGroup *group);
> int vfio_get_device(VFIOGroup *group, const char *name,
> VFIODevice *vbasedev, Error **errp);
>
> +int vfio_user_get_device(VFIOGroup *group, VFIODevice *vbasedev, Error **errp);
> +VFIOGroup *vfio_user_get_group(VFIOProxy *proxy, AddressSpace *as,
> + Error **errp);
> +void vfio_user_put_group(VFIOGroup *group);
> +
Why aren't these in user.h?
regards
john
^ permalink raw reply [flat|nested] 82+ messages in thread
* Re: [PATCH v1 18/24] vfio-user: add dma_unmap_all
2022-11-08 23:13 ` [PATCH v1 18/24] vfio-user: add dma_unmap_all John Johnson
@ 2022-12-09 17:58 ` John Levon
0 siblings, 0 replies; 82+ messages in thread
From: John Levon @ 2022-12-09 17:58 UTC (permalink / raw)
To: John Johnson; +Cc: qemu-devel
On Tue, Nov 08, 2022 at 03:13:40PM -0800, John Johnson wrote:
> Signed-off-by: John G Johnson <john.g.johnson@oracle.com>
> Signed-off-by: Elena Ufimtseva <elena.ufimtseva@oracle.com>
> Signed-off-by: Jagannathan Raman <jag.raman@oracle.com>
> ---
> +static int vfio_user_io_dirty_bitmap(VFIOContainer *container,
> + struct vfio_iommu_type1_dirty_bitmap *bitmap,
> + struct vfio_iommu_type1_dirty_bitmap_get *range)
> +{
> +
> + /* vfio-user doesn't support migration */
> + return -EINVAL;
> +}
... and dirty_bitmap callback?
regards
john
^ permalink raw reply [flat|nested] 82+ messages in thread
* Re: [PATCH v1 19/24] vfio-user: secure DMA support
2022-11-08 23:13 ` [PATCH v1 19/24] vfio-user: secure DMA support John Johnson
@ 2022-12-09 18:01 ` John Levon
2022-12-12 20:31 ` John Johnson
0 siblings, 1 reply; 82+ messages in thread
From: John Levon @ 2022-12-09 18:01 UTC (permalink / raw)
To: John Johnson; +Cc: qemu-devel
On Tue, Nov 08, 2022 at 03:13:41PM -0800, John Johnson wrote:
> Secure DMA forces the remote process to use DMA r/w messages
> instead of directly mapping guest memeory.
I don't really get why this is called "secure" - shouldn't have an option name
more closely resembling what it actually does?
regards
john
^ permalink raw reply [flat|nested] 82+ messages in thread
* Re: [PATCH v1 20/24] vfio-user: dma read/write operations
2022-11-08 23:13 ` [PATCH v1 20/24] vfio-user: dma read/write operations John Johnson
@ 2022-12-09 18:11 ` John Levon
0 siblings, 0 replies; 82+ messages in thread
From: John Levon @ 2022-12-09 18:11 UTC (permalink / raw)
To: John Johnson; +Cc: qemu-devel
On Tue, Nov 08, 2022 at 03:13:42PM -0800, John Johnson wrote:
> static void vfio_user_pci_process_req(void *opaque, VFIOUserMsg *msg)
> {
> + VFIOPCIDevice *vdev = opaque;
> + VFIOUserHdr *hdr = msg->hdr;
> +
> + /* no incoming PCI requests pass FDs */
> + if (msg->fds != NULL) {
> + vfio_user_send_error(vdev->vbasedev.proxy, hdr, EINVAL);
> + vfio_user_putfds(msg);
> + return;
> + }
>
> + switch (hdr->command) {
> + case VFIO_USER_DMA_READ:
> + vfio_user_dma_read(vdev, (VFIOUserDMARW *)hdr);
> + break;
> + case VFIO_USER_DMA_WRITE:
> + vfio_user_dma_write(vdev, (VFIOUserDMARW *)hdr);
> + break;
> + default:
> + error_printf("vfio_user_process_req unknown cmd %d\n", hdr->command);
__func__ or vfio_user_pci_process_req ?
regards
john
^ permalink raw reply [flat|nested] 82+ messages in thread
* Re: [PATCH v1 21/24] vfio-user: pci reset
2022-11-08 23:13 ` [PATCH v1 21/24] vfio-user: pci reset John Johnson
@ 2022-12-09 18:13 ` John Levon
0 siblings, 0 replies; 82+ messages in thread
From: John Levon @ 2022-12-09 18:13 UTC (permalink / raw)
To: John Johnson; +Cc: qemu-devel
On Tue, Nov 08, 2022 at 03:13:43PM -0800, John Johnson wrote:
> Message to tell the server to reset the device.
LGTM
Reviewed-by: John Levon <john.levon@nutanix.com>
regards
john
^ permalink raw reply [flat|nested] 82+ messages in thread
* Re: [PATCH v1 22/24] vfio-user: add 'x-msg-timeout' option that specifies msg wait times
2022-11-08 23:13 ` [PATCH v1 22/24] vfio-user: add 'x-msg-timeout' option that specifies msg wait times John Johnson
@ 2022-12-09 18:14 ` John Levon
2022-12-15 12:56 ` Cédric Le Goater
1 sibling, 0 replies; 82+ messages in thread
From: John Levon @ 2022-12-09 18:14 UTC (permalink / raw)
To: John Johnson; +Cc: qemu-devel
LGTM
Reviewed-by: John Levon <john.levon@nutanix.com>
regards
john
^ permalink raw reply [flat|nested] 82+ messages in thread
* Re: [PATCH v1 23/24] vfio-user: add coalesced posted writes
2022-11-08 23:13 ` [PATCH v1 23/24] vfio-user: add coalesced posted writes John Johnson
@ 2022-12-09 18:16 ` John Levon
0 siblings, 0 replies; 82+ messages in thread
From: John Levon @ 2022-12-09 18:16 UTC (permalink / raw)
To: John Johnson; +Cc: qemu-devel
On Tue, Nov 08, 2022 at 03:13:45PM -0800, John Johnson wrote:
> Add new message to send multiple writes to server
LGTM - but maybe commit message could have some context as to why this is
useful?
Reviewed-by: John Levon <john.levon@nutanix.com>
regards
john
^ permalink raw reply [flat|nested] 82+ messages in thread
* Re: [PATCH v1 04/24] vfio-user: add region cache
2022-11-08 23:13 ` [PATCH v1 04/24] vfio-user: add region cache John Johnson
2022-12-09 14:15 ` John Levon
@ 2022-12-12 7:44 ` Cédric Le Goater
2022-12-12 11:42 ` Philippe Mathieu-Daudé
2 siblings, 0 replies; 82+ messages in thread
From: Cédric Le Goater @ 2022-12-12 7:44 UTC (permalink / raw)
To: John Johnson, qemu-devel
On 11/9/22 00:13, John Johnson wrote:
> cache VFIO_DEVICE_GET_REGION_INFO results to reduce
> memory alloc/free cycles and as prep work for vfio-user
>
> Signed-off-by: John G Johnson <john.g.johnson@oracle.com>
> Signed-off-by: Elena Ufimtseva <elena.ufimtseva@oracle.com>
> Signed-off-by: Jagannathan Raman <jag.raman@oracle.com>
LGTM,
Reviewed-by: Cédric Le Goater <clg@redhat.com>
Thanks,
C.
> ---
> hw/vfio/ccw.c | 5 -----
> hw/vfio/common.c | 41 +++++++++++++++++++++++++++++++++++------
> hw/vfio/igd.c | 23 +++++++++--------------
> hw/vfio/migration.c | 2 --
> hw/vfio/pci-quirks.c | 19 +++++--------------
> hw/vfio/pci.c | 8 --------
> include/hw/vfio/vfio-common.h | 2 ++
> 7 files changed, 51 insertions(+), 49 deletions(-)
>
> diff --git a/hw/vfio/ccw.c b/hw/vfio/ccw.c
> index 0354737..06b588c 100644
> --- a/hw/vfio/ccw.c
> +++ b/hw/vfio/ccw.c
> @@ -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;
> }
>
> diff --git a/hw/vfio/common.c b/hw/vfio/common.c
> index 83d69b9..dd9104f 100644
> --- a/hw/vfio/common.c
> +++ b/hw/vfio/common.c
> @@ -1600,8 +1600,6 @@ int vfio_region_setup(Object *obj, VFIODevice *vbasedev, VFIORegion *region,
> }
> }
>
> - g_free(info);
> -
> trace_vfio_region_setup(vbasedev->name, index, name,
> region->flags, region->fd_offset, region->size);
> return 0;
> @@ -2357,6 +2355,16 @@ void vfio_put_group(VFIOGroup *group)
> }
> }
>
> +void vfio_get_all_regions(VFIODevice *vbasedev)
> +{
> + struct vfio_region_info *info;
> + int i;
> +
> + for (i = 0; i < vbasedev->num_regions; i++) {
> + vfio_get_region_info(vbasedev, i, &info);
> + }
> +}
> +
> int vfio_get_device(VFIOGroup *group, const char *name,
> VFIODevice *vbasedev, Error **errp)
> {
> @@ -2412,12 +2420,23 @@ int vfio_get_device(VFIOGroup *group, const char *name,
> trace_vfio_get_device(name, dev_info.flags, dev_info.num_regions,
> dev_info.num_irqs);
>
> + vfio_get_all_regions(vbasedev);
> vbasedev->reset_works = !!(dev_info.flags & VFIO_DEVICE_FLAGS_RESET);
> return 0;
> }
>
> void vfio_put_base_device(VFIODevice *vbasedev)
> {
> + if (vbasedev->regions != NULL) {
> + int i;
> +
> + for (i = 0; i < vbasedev->num_regions; i++) {
> + g_free(vbasedev->regions[i]);
> + }
> + g_free(vbasedev->regions);
> + vbasedev->regions = NULL;
> + }
> +
> if (!vbasedev->group) {
> return;
> }
> @@ -2432,6 +2451,17 @@ int vfio_get_region_info(VFIODevice *vbasedev, int index,
> {
> size_t argsz = sizeof(struct vfio_region_info);
>
> + /* create region cache */
> + if (vbasedev->regions == NULL) {
> + vbasedev->regions = g_new0(struct vfio_region_info *,
> + vbasedev->num_regions);
> + }
> + /* check cache */
> + if (vbasedev->regions[index] != NULL) {
> + *info = vbasedev->regions[index];
> + return 0;
> + }
> +
> *info = g_malloc0(argsz);
>
> (*info)->index = index;
> @@ -2451,6 +2481,9 @@ retry:
> goto retry;
> }
>
> + /* fill cache */
> + vbasedev->regions[index] = *info;
> +
> return 0;
> }
>
> @@ -2469,7 +2502,6 @@ int vfio_get_dev_region_info(VFIODevice *vbasedev, uint32_t type,
>
> hdr = vfio_get_region_info_cap(*info, VFIO_REGION_INFO_CAP_TYPE);
> if (!hdr) {
> - g_free(*info);
> continue;
> }
>
> @@ -2481,8 +2513,6 @@ int vfio_get_dev_region_info(VFIODevice *vbasedev, uint32_t type,
> if (cap_type->type == type && cap_type->subtype == subtype) {
> return 0;
> }
> -
> - g_free(*info);
> }
>
> *info = NULL;
> @@ -2498,7 +2528,6 @@ bool vfio_has_region_cap(VFIODevice *vbasedev, int region, uint16_t cap_type)
> if (vfio_get_region_info_cap(info, cap_type)) {
> ret = true;
> }
> - g_free(info);
> }
>
> return ret;
> diff --git a/hw/vfio/igd.c b/hw/vfio/igd.c
> index afe3fe7..22efa1a 100644
> --- a/hw/vfio/igd.c
> +++ b/hw/vfio/igd.c
> @@ -425,7 +425,7 @@ void vfio_probe_igd_bar4_quirk(VFIOPCIDevice *vdev, int nr)
> if ((ret || !rom->size) && !vdev->pdev.romfile) {
> error_report("IGD device %s has no ROM, legacy mode disabled",
> vdev->vbasedev.name);
> - goto out;
> + return;
> }
>
> /*
> @@ -436,7 +436,7 @@ void vfio_probe_igd_bar4_quirk(VFIOPCIDevice *vdev, int nr)
> error_report("IGD device %s hotplugged, ROM disabled, "
> "legacy mode disabled", vdev->vbasedev.name);
> vdev->rom_read_failed = true;
> - goto out;
> + return;
> }
>
> /*
> @@ -449,7 +449,7 @@ void vfio_probe_igd_bar4_quirk(VFIOPCIDevice *vdev, int nr)
> if (ret) {
> error_report("IGD device %s does not support OpRegion access,"
> "legacy mode disabled", vdev->vbasedev.name);
> - goto out;
> + return;
> }
>
> ret = vfio_get_dev_region_info(&vdev->vbasedev,
> @@ -458,7 +458,7 @@ void vfio_probe_igd_bar4_quirk(VFIOPCIDevice *vdev, int nr)
> if (ret) {
> error_report("IGD device %s does not support host bridge access,"
> "legacy mode disabled", vdev->vbasedev.name);
> - goto out;
> + return;
> }
>
> ret = vfio_get_dev_region_info(&vdev->vbasedev,
> @@ -467,7 +467,7 @@ void vfio_probe_igd_bar4_quirk(VFIOPCIDevice *vdev, int nr)
> if (ret) {
> error_report("IGD device %s does not support LPC bridge access,"
> "legacy mode disabled", vdev->vbasedev.name);
> - goto out;
> + return;
> }
>
> gmch = vfio_pci_read_config(&vdev->pdev, IGD_GMCH, 4);
> @@ -481,7 +481,7 @@ void vfio_probe_igd_bar4_quirk(VFIOPCIDevice *vdev, int nr)
> error_reportf_err(err, VFIO_MSG_PREFIX, vdev->vbasedev.name);
> error_report("IGD device %s failed to enable VGA access, "
> "legacy mode disabled", vdev->vbasedev.name);
> - goto out;
> + return;
> }
>
> /* Create our LPC/ISA bridge */
> @@ -489,7 +489,7 @@ void vfio_probe_igd_bar4_quirk(VFIOPCIDevice *vdev, int nr)
> if (ret) {
> error_report("IGD device %s failed to create LPC bridge, "
> "legacy mode disabled", vdev->vbasedev.name);
> - goto out;
> + return;
> }
>
> /* Stuff some host values into the VM PCI host bridge */
> @@ -497,7 +497,7 @@ void vfio_probe_igd_bar4_quirk(VFIOPCIDevice *vdev, int nr)
> if (ret) {
> error_report("IGD device %s failed to modify host bridge, "
> "legacy mode disabled", vdev->vbasedev.name);
> - goto out;
> + return;
> }
>
> /* Setup OpRegion access */
> @@ -505,7 +505,7 @@ void vfio_probe_igd_bar4_quirk(VFIOPCIDevice *vdev, int nr)
> if (ret) {
> error_append_hint(&err, "IGD legacy mode disabled\n");
> error_reportf_err(err, VFIO_MSG_PREFIX, vdev->vbasedev.name);
> - goto out;
> + return;
> }
>
> /* Setup our quirk to munge GTT addresses to the VM allocated buffer */
> @@ -608,9 +608,4 @@ void vfio_probe_igd_bar4_quirk(VFIOPCIDevice *vdev, int nr)
>
> trace_vfio_pci_igd_bdsm_enabled(vdev->vbasedev.name, ggms_mb + gms_mb);
>
> -out:
> - g_free(rom);
> - g_free(opregion);
> - g_free(host);
> - g_free(lpc);
> }
> diff --git a/hw/vfio/migration.c b/hw/vfio/migration.c
> index a6ad1f8..397be43 100644
> --- a/hw/vfio/migration.c
> +++ b/hw/vfio/migration.c
> @@ -879,13 +879,11 @@ int vfio_migration_probe(VFIODevice *vbasedev, Error **errp)
> }
>
> trace_vfio_migration_probe(vbasedev->name, info->index);
> - g_free(info);
> return 0;
>
> add_blocker:
> error_setg(&vbasedev->migration_blocker,
> "VFIO device doesn't support migration");
> - g_free(info);
>
> ret = migrate_add_blocker(vbasedev->migration_blocker, errp);
> if (ret < 0) {
> diff --git a/hw/vfio/pci-quirks.c b/hw/vfio/pci-quirks.c
> index f0147a0..c04ee19 100644
> --- a/hw/vfio/pci-quirks.c
> +++ b/hw/vfio/pci-quirks.c
> @@ -1585,16 +1585,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);
> @@ -1607,8 +1605,6 @@ int vfio_pci_nvidia_v100_ram_init(VFIOPCIDevice *vdev, Error **errp)
> OBJ_PROP_FLAG_READ);
> trace_vfio_pci_nvidia_gpu_setup_quirk(vdev->vbasedev.name, cap->tgt,
> nv2reg->size);
> -free_exit:
> - g_free(nv2reg);
>
> return ret;
> }
> @@ -1635,16 +1631,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;
>
> @@ -1653,8 +1647,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);
> @@ -1674,8 +1667,6 @@ int vfio_pci_nvlink2_init(VFIOPCIDevice *vdev, Error **errp)
> OBJ_PROP_FLAG_READ);
> trace_vfio_pci_nvlink2_setup_quirk_lnkspd(vdev->vbasedev.name,
> capspeed->link_speed);
> -free_exit:
> - g_free(atsdreg);
>
> return ret;
> }
> diff --git a/hw/vfio/pci.c b/hw/vfio/pci.c
> index 60acde5..1c7618d 100644
> --- a/hw/vfio/pci.c
> +++ b/hw/vfio/pci.c
> @@ -836,8 +836,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 "
> @@ -2564,7 +2562,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;
> }
>
> @@ -2573,8 +2570,6 @@ int vfio_populate_vga(VFIOPCIDevice *vdev, Error **errp)
> vdev->vga->fd_offset = reg_info->offset;
> vdev->vga->fd = vdev->vbasedev.fd;
>
> - g_free(reg_info);
> -
> vdev->vga->region[QEMU_PCI_VGA_MEM].offset = QEMU_PCI_VGA_MEM_BASE;
> vdev->vga->region[QEMU_PCI_VGA_MEM].nr = QEMU_PCI_VGA_MEM;
> QLIST_INIT(&vdev->vga->region[QEMU_PCI_VGA_MEM].quirks);
> @@ -2669,8 +2664,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) {
> @@ -3079,7 +3072,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;
> }
> diff --git a/include/hw/vfio/vfio-common.h b/include/hw/vfio/vfio-common.h
> index 6fd40f1..a1db165 100644
> --- a/include/hw/vfio/vfio-common.h
> +++ b/include/hw/vfio/vfio-common.h
> @@ -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);
^ permalink raw reply [flat|nested] 82+ messages in thread
* Re: [PATCH v1 05/24] vfio-user: add device IO ops vector
2022-11-08 23:13 ` [PATCH v1 05/24] vfio-user: add device IO ops vector John Johnson
2022-12-09 14:43 ` John Levon
@ 2022-12-12 7:59 ` Cédric Le Goater
1 sibling, 0 replies; 82+ messages in thread
From: Cédric Le Goater @ 2022-12-12 7:59 UTC (permalink / raw)
To: John Johnson, qemu-devel
On 11/9/22 00:13, John Johnson wrote:
> Used for communication with VFIO driver
> (prep work for vfio-user, which will communicate over a socket)
>
> Signed-off-by: John G Johnson <john.g.johnson@oracle.com>
I would keep the short rw handling for a subsequent patch to make
sure the changes do not introduce any functional change.
> ---
> hw/vfio/ap.c | 1 +
> hw/vfio/ccw.c | 1 +
> hw/vfio/common.c | 107 +++++++++++++++++++++++++++-----
> hw/vfio/pci.c | 140 ++++++++++++++++++++++++++----------------
> hw/vfio/platform.c | 1 +
> include/hw/vfio/vfio-common.h | 27 ++++++++
> 6 files changed, 209 insertions(+), 68 deletions(-)
>
> diff --git a/hw/vfio/ap.c b/hw/vfio/ap.c
> index e0dd561..7ef42f1 100644
> --- a/hw/vfio/ap.c
> +++ b/hw/vfio/ap.c
> @@ -102,6 +102,7 @@ static void vfio_ap_realize(DeviceState *dev, Error **errp)
> mdevid = basename(vapdev->vdev.sysfsdev);
> vapdev->vdev.name = g_strdup_printf("%s", mdevid);
> vapdev->vdev.dev = dev;
> + vapdev->vdev.io_ops = &vfio_dev_io_ioctl;
>
> /*
> * vfio-ap devices operate in a way compatible with discarding of
> diff --git a/hw/vfio/ccw.c b/hw/vfio/ccw.c
> index 06b588c..cbd1c25 100644
> --- a/hw/vfio/ccw.c
> +++ b/hw/vfio/ccw.c
> @@ -614,6 +614,7 @@ static void vfio_ccw_get_device(VFIOGroup *group, VFIOCCWDevice *vcdev,
> vcdev->vdev.type = VFIO_DEVICE_TYPE_CCW;
> vcdev->vdev.name = name;
> vcdev->vdev.dev = &vcdev->cdev.parent_obj.parent_obj;
> + vcdev->vdev.io_ops = &vfio_dev_io_ioctl;
>
> return;
>
> diff --git a/hw/vfio/common.c b/hw/vfio/common.c
> index dd9104f..c7bf0aa 100644
> --- a/hw/vfio/common.c
> +++ b/hw/vfio/common.c
> @@ -71,7 +71,7 @@ void vfio_disable_irqindex(VFIODevice *vbasedev, int index)
> .count = 0,
> };
>
> - ioctl(vbasedev->fd, VFIO_DEVICE_SET_IRQS, &irq_set);
> + VDEV_SET_IRQS(vbasedev, &irq_set);
> }
>
> void vfio_unmask_single_irqindex(VFIODevice *vbasedev, int index)
> @@ -84,7 +84,7 @@ void vfio_unmask_single_irqindex(VFIODevice *vbasedev, int index)
> .count = 1,
> };
>
> - ioctl(vbasedev->fd, VFIO_DEVICE_SET_IRQS, &irq_set);
> + VDEV_SET_IRQS(vbasedev, &irq_set);
> }
>
> void vfio_mask_single_irqindex(VFIODevice *vbasedev, int index)
> @@ -97,7 +97,7 @@ void vfio_mask_single_irqindex(VFIODevice *vbasedev, int index)
> .count = 1,
> };
>
> - ioctl(vbasedev->fd, VFIO_DEVICE_SET_IRQS, &irq_set);
> + VDEV_SET_IRQS(vbasedev, &irq_set);
> }
>
> static inline const char *action_to_str(int action)
> @@ -178,9 +178,7 @@ int vfio_set_irq_signaling(VFIODevice *vbasedev, int index, int subindex,
> pfd = (int32_t *)&irq_set->data;
> *pfd = fd;
>
> - if (ioctl(vbasedev->fd, VFIO_DEVICE_SET_IRQS, irq_set)) {
> - ret = -errno;
> - }
> + ret = VDEV_SET_IRQS(vbasedev, irq_set);
> g_free(irq_set);
>
> if (!ret) {
> @@ -215,6 +213,7 @@ void vfio_region_write(void *opaque, hwaddr addr,
> uint32_t dword;
> uint64_t qword;
> } buf;
> + int ret;
>
> switch (size) {
> case 1:
> @@ -234,13 +233,15 @@ void vfio_region_write(void *opaque, hwaddr addr,
> break;
> }
>
> - if (pwrite(vbasedev->fd, &buf, size, region->fd_offset + addr) != size) {
> + ret = VDEV_REGION_WRITE(vbasedev, region->nr, addr, size, &buf);
> + if (ret != size) {
> + const char *err = ret < 0 ? strerror(-ret) : "short write";
> +
> error_report("%s(%s:region%d+0x%"HWADDR_PRIx", 0x%"PRIx64
> - ",%d) failed: %m",
> + ",%d) failed: %s",
> __func__, vbasedev->name, region->nr,
> - addr, data, size);
> + addr, data, size, err);
> }
> -
> trace_vfio_region_write(vbasedev->name, region->nr, addr, data, size);
>
> /*
> @@ -266,13 +267,18 @@ uint64_t vfio_region_read(void *opaque,
> uint64_t qword;
> } buf;
> uint64_t data = 0;
> + int ret;
> +
> + ret = VDEV_REGION_READ(vbasedev, region->nr, addr, size, &buf);
> + if (ret != size) {
> + const char *err = ret < 0 ? strerror(-ret) : "short read";
>
> - if (pread(vbasedev->fd, &buf, size, region->fd_offset + addr) != size) {
> - error_report("%s(%s:region%d+0x%"HWADDR_PRIx", %d) failed: %m",
> + error_report("%s(%s:region%d+0x%"HWADDR_PRIx", %d) failed: %s",
> __func__, vbasedev->name, region->nr,
> - addr, size);
> + addr, size, err);
> return (uint64_t)-1;
> }
> +
> switch (size) {
> case 1:
> data = buf.byte;
> @@ -2450,6 +2456,7 @@ int vfio_get_region_info(VFIODevice *vbasedev, int index,
> struct vfio_region_info **info)
> {
> size_t argsz = sizeof(struct vfio_region_info);
> + int ret;
>
> /* create region cache */
> if (vbasedev->regions == NULL) {
> @@ -2468,10 +2475,11 @@ int vfio_get_region_info(VFIODevice *vbasedev, int index,
> retry:
> (*info)->argsz = argsz;
>
> - if (ioctl(vbasedev->fd, VFIO_DEVICE_GET_REGION_INFO, *info)) {
> + ret = VDEV_GET_REGION_INFO(vbasedev, *info);
> + if (ret != 0) {
> g_free(*info);
> *info = NULL;
> - return -errno;
> + return ret;
> }
>
> if ((*info)->argsz > argsz) {
> @@ -2632,6 +2640,75 @@ int vfio_eeh_as_op(AddressSpace *as, uint32_t op)
> * Traditional ioctl() based io_ops
> */
>
> +static int vfio_io_get_info(VFIODevice *vbasedev, struct vfio_device_info *info)
> +{
> + int ret;
> +
> + ret = ioctl(vbasedev->fd, VFIO_DEVICE_GET_INFO, info);
> +
> + return ret < 0 ? -errno : ret;
> +}
> +
> +static int vfio_io_get_region_info(VFIODevice *vbasedev,
> + struct vfio_region_info *info)
> +{
> + int ret;
> +
> + ret = ioctl(vbasedev->fd, VFIO_DEVICE_GET_REGION_INFO, info);
> +
> + return ret < 0 ? -errno : ret;
> +}
> +
> +static int vfio_io_get_irq_info(VFIODevice *vbasedev,
> + struct vfio_irq_info *info)
> +{
> + int ret;
> +
> + ret = ioctl(vbasedev->fd, VFIO_DEVICE_GET_IRQ_INFO, info);
> +
> + return ret < 0 ? -errno : ret;
> +}
> +
> +static int vfio_io_set_irqs(VFIODevice *vbasedev, struct vfio_irq_set *irqs)
> +{
> + int ret;
> +
> + ret = ioctl(vbasedev->fd, VFIO_DEVICE_SET_IRQS, irqs);
> +
> + return ret < 0 ? -errno : ret;
> +}
> +
> +static int vfio_io_region_read(VFIODevice *vbasedev, uint8_t index, off_t off,
> + uint32_t size, void *data)
> +{
> + struct vfio_region_info *info = vbasedev->regions[index];
> + int ret;
> +
> + ret = pread(vbasedev->fd, data, size, info->offset + off);
> +
> + return ret < 0 ? -errno : ret;
> +}
> +
> +static int vfio_io_region_write(VFIODevice *vbasedev, uint8_t index, off_t off,
> + uint32_t size, void *data)
> +{
> + struct vfio_region_info *info = vbasedev->regions[index];
> + int ret;
> +
> + ret = pwrite(vbasedev->fd, data, size, info->offset + off);
> +
> + return ret < 0 ? -errno : ret;
> +}
> +
> +VFIODevIO vfio_dev_io_ioctl = {
> + .get_info = vfio_io_get_info,
> + .get_region_info = vfio_io_get_region_info,
> + .get_irq_info = vfio_io_get_irq_info,
> + .set_irqs = vfio_io_set_irqs,
> + .region_read = vfio_io_region_read,
> + .region_write = vfio_io_region_write,
> +};
> +
> static int vfio_io_dma_map(VFIOContainer *container,
> struct vfio_iommu_type1_dma_map *map)
> {
> diff --git a/hw/vfio/pci.c b/hw/vfio/pci.c
> index 1c7618d..80b03a2 100644
> --- a/hw/vfio/pci.c
> +++ b/hw/vfio/pci.c
> @@ -43,6 +43,14 @@
> #include "migration/blocker.h"
> #include "migration/qemu-file.h"
>
> +/* convenience macros for PCI config space */
> +#define VDEV_CONFIG_READ(vbasedev, off, size, data) \
> + VDEV_REGION_READ((vbasedev), VFIO_PCI_CONFIG_REGION_INDEX, (off), \
> + (size), (data))
> +#define VDEV_CONFIG_WRITE(vbasedev, off, size, data) \
> + VDEV_REGION_WRITE((vbasedev), VFIO_PCI_CONFIG_REGION_INDEX, (off), \
> + (size), (data))
> +
> #define TYPE_VFIO_PCI_NOHOTPLUG "vfio-pci-nohotplug"
>
> /* Protected by BQL */
> @@ -406,7 +414,7 @@ static int vfio_enable_vectors(VFIOPCIDevice *vdev, bool msix)
> fds[i] = fd;
> }
>
> - ret = ioctl(vdev->vbasedev.fd, VFIO_DEVICE_SET_IRQS, irq_set);
> + ret = VDEV_SET_IRQS(&vdev->vbasedev, irq_set);
>
> g_free(irq_set);
>
> @@ -818,14 +826,16 @@ static void vfio_update_msi(VFIOPCIDevice *vdev)
>
> static void vfio_pci_load_rom(VFIOPCIDevice *vdev)
> {
> + VFIODevice *vbasedev = &vdev->vbasedev;
> struct vfio_region_info *reg_info;
> uint64_t size;
> off_t off = 0;
> ssize_t bytes;
> + int ret;
>
> - if (vfio_get_region_info(&vdev->vbasedev,
> - VFIO_PCI_ROM_REGION_INDEX, ®_info)) {
> - error_report("vfio: Error getting ROM info: %m");
> + ret = vfio_get_region_info(vbasedev, VFIO_PCI_ROM_REGION_INDEX, ®_info);
> + if (ret < 0) {
> + error_report("vfio: Error getting ROM info: %s", strerror(-ret));
> return;
> }
>
> @@ -850,18 +860,19 @@ static void vfio_pci_load_rom(VFIOPCIDevice *vdev)
> memset(vdev->rom, 0xff, size);
>
> while (size) {
> - bytes = pread(vdev->vbasedev.fd, vdev->rom + off,
> - size, vdev->rom_offset + off);
> + bytes = VDEV_REGION_READ(vbasedev, VFIO_PCI_ROM_REGION_INDEX, off,
> + size, vdev->rom + off);
> if (bytes == 0) {
> break;
> } else if (bytes > 0) {
> off += bytes;
> size -= bytes;
> } else {
> - if (errno == EINTR || errno == EAGAIN) {
> + if (bytes == -EINTR || bytes == -EAGAIN) {
> continue;
> }
> - error_report("vfio: Error reading device ROM: %m");
> + error_report("vfio: Error reading device ROM: %s",
> + strerror(-bytes));
> break;
> }
> }
> @@ -949,11 +960,10 @@ static const MemoryRegionOps vfio_rom_ops = {
>
> static void vfio_pci_size_rom(VFIOPCIDevice *vdev)
> {
> + VFIODevice *vbasedev = &vdev->vbasedev;
> uint32_t orig, size = cpu_to_le32((uint32_t)PCI_ROM_ADDRESS_MASK);
> - off_t offset = vdev->config_offset + PCI_ROM_ADDRESS;
> DeviceState *dev = DEVICE(vdev);
> char *name;
> - int fd = vdev->vbasedev.fd;
>
> if (vdev->pdev.romfile || !vdev->pdev.rom_bar) {
> /* Since pci handles romfile, just print a message and return */
> @@ -970,11 +980,12 @@ static void vfio_pci_size_rom(VFIOPCIDevice *vdev)
> * Use the same size ROM BAR as the physical device. The contents
> * will get filled in later when the guest tries to read it.
> */
> - if (pread(fd, &orig, 4, offset) != 4 ||
> - pwrite(fd, &size, 4, offset) != 4 ||
> - pread(fd, &size, 4, offset) != 4 ||
> - pwrite(fd, &orig, 4, offset) != 4) {
> - error_report("%s(%s) failed: %m", __func__, vdev->vbasedev.name);
> + if (VDEV_CONFIG_READ(vbasedev, PCI_ROM_ADDRESS, 4, &orig) != 4 ||
> + VDEV_CONFIG_WRITE(vbasedev, PCI_ROM_ADDRESS, 4, &size) != 4 ||
> + VDEV_CONFIG_READ(vbasedev, PCI_ROM_ADDRESS, 4, &size) != 4 ||
> + VDEV_CONFIG_WRITE(vbasedev, PCI_ROM_ADDRESS, 4, &orig) != 4) {
> +
> + error_report("%s(%s) ROM access failed", __func__, vbasedev->name);
> return;
> }
>
> @@ -1154,6 +1165,7 @@ static void vfio_sub_page_bar_update_mapping(PCIDevice *pdev, int bar)
> uint32_t vfio_pci_read_config(PCIDevice *pdev, uint32_t addr, int len)
> {
> VFIOPCIDevice *vdev = VFIO_PCI_BASE(pdev);
> + VFIODevice *vbasedev = &vdev->vbasedev;
> uint32_t emu_bits = 0, emu_val = 0, phys_val = 0, val;
>
> memcpy(&emu_bits, vdev->emulated_config_bits + addr, len);
> @@ -1166,12 +1178,13 @@ uint32_t vfio_pci_read_config(PCIDevice *pdev, uint32_t addr, int len)
> if (~emu_bits & (0xffffffffU >> (32 - len * 8))) {
> ssize_t ret;
>
> - ret = pread(vdev->vbasedev.fd, &phys_val, len,
> - vdev->config_offset + addr);
> + ret = VDEV_CONFIG_READ(vbasedev, addr, len, &phys_val);
> if (ret != len) {
> - error_report("%s(%s, 0x%x, 0x%x) failed: %m",
> - __func__, vdev->vbasedev.name, addr, len);
> - return -errno;
> + const char *err = ret < 0 ? strerror(-ret) : "short read";
> +
> + error_report("%s(%s, 0x%x, 0x%x) failed: %s",
> + __func__, vbasedev->name, addr, len, err);
> + return -1;
> }
> phys_val = le32_to_cpu(phys_val);
> }
> @@ -1187,15 +1200,19 @@ void vfio_pci_write_config(PCIDevice *pdev,
> uint32_t addr, uint32_t val, int len)
> {
> VFIOPCIDevice *vdev = VFIO_PCI_BASE(pdev);
> + VFIODevice *vbasedev = &vdev->vbasedev;
> uint32_t val_le = cpu_to_le32(val);
> + int ret;
>
> trace_vfio_pci_write_config(vdev->vbasedev.name, addr, val, len);
>
> /* Write everything to VFIO, let it filter out what we can't write */
> - if (pwrite(vdev->vbasedev.fd, &val_le, len, vdev->config_offset + addr)
> - != len) {
> - error_report("%s(%s, 0x%x, 0x%x, 0x%x) failed: %m",
> - __func__, vdev->vbasedev.name, addr, val, len);
> + ret = VDEV_CONFIG_WRITE(vbasedev, addr, len, &val_le);
> + if (ret != len) {
> + const char *err = ret < 0 ? strerror(-ret) : "short write";
> +
> + error_report("%s(%s, 0x%x, 0x%x, 0x%x) failed: %s",
> + __func__, vbasedev->name, addr, val, len, err);
> }
>
> /* MSI/MSI-X Enabling/Disabling */
> @@ -1283,10 +1300,13 @@ static int vfio_msi_setup(VFIOPCIDevice *vdev, int pos, Error **errp)
> int ret, entries;
> Error *err = NULL;
>
> - if (pread(vdev->vbasedev.fd, &ctrl, sizeof(ctrl),
> - vdev->config_offset + pos + PCI_CAP_FLAGS) != sizeof(ctrl)) {
> - error_setg_errno(errp, errno, "failed reading MSI PCI_CAP_FLAGS");
> - return -errno;
> + ret = VDEV_CONFIG_READ(&vdev->vbasedev, pos + PCI_CAP_FLAGS,
> + sizeof(ctrl), &ctrl);
> + if (ret != sizeof(ctrl)) {
> + const char *err = ret < 0 ? strerror(-ret) : "short read";
> +
> + error_setg(errp, "failed reading MSI PCI_CAP_FLAGS %s", err);
> + return ret;
> }
> ctrl = le16_to_cpu(ctrl);
>
> @@ -1488,33 +1508,39 @@ static void vfio_pci_relocate_msix(VFIOPCIDevice *vdev, Error **errp)
> */
> static void vfio_msix_early_setup(VFIOPCIDevice *vdev, Error **errp)
> {
> + VFIODevice *vbasedev = &vdev->vbasedev;
> uint8_t pos;
> uint16_t ctrl;
> uint32_t table, pba;
> - int fd = vdev->vbasedev.fd;
> VFIOMSIXInfo *msix;
> + int ret;
>
> pos = pci_find_capability(&vdev->pdev, PCI_CAP_ID_MSIX);
> if (!pos) {
> return;
> }
>
> - if (pread(fd, &ctrl, sizeof(ctrl),
> - vdev->config_offset + pos + PCI_MSIX_FLAGS) != sizeof(ctrl)) {
> - error_setg_errno(errp, errno, "failed to read PCI MSIX FLAGS");
> - return;
> + ret = VDEV_CONFIG_READ(vbasedev, pos + PCI_MSIX_FLAGS,
> + sizeof(ctrl), &ctrl);
> + if (ret != sizeof(ctrl)) {
> + const char *err = ret < 0 ? strerror(-ret) : "short read";
> +
> + error_setg(errp, "failed to read PCI MSIX FLAGS %s", err);
> }
>
> - if (pread(fd, &table, sizeof(table),
> - vdev->config_offset + pos + PCI_MSIX_TABLE) != sizeof(table)) {
> - error_setg_errno(errp, errno, "failed to read PCI MSIX TABLE");
> - return;
> + ret = VDEV_CONFIG_READ(vbasedev, pos + PCI_MSIX_TABLE,
> + sizeof(table), &table);
> + if (ret != sizeof(table)) {
> + const char *err = ret < 0 ? strerror(-ret) : "short read";
> +
> + error_setg(errp, "failed to read PCI MSIX TABLE %s", err);
> }
>
> - if (pread(fd, &pba, sizeof(pba),
> - vdev->config_offset + pos + PCI_MSIX_PBA) != sizeof(pba)) {
> - error_setg_errno(errp, errno, "failed to read PCI MSIX PBA");
> - return;
> + ret = VDEV_CONFIG_READ(vbasedev, pos + PCI_MSIX_PBA, sizeof(pba), &pba);
> + if (ret != sizeof(pba)) {
> + const char *err = ret < 0 ? strerror(-ret) : "short read";
> +
> + error_setg(errp, "failed to read PCI MSIX PBA %s", err);
> }
>
> ctrl = le16_to_cpu(ctrl);
> @@ -1652,7 +1678,6 @@ static void vfio_mmap_set_enabled(VFIOPCIDevice *vdev, bool enabled)
> static void vfio_bar_prepare(VFIOPCIDevice *vdev, int nr)
> {
> VFIOBAR *bar = &vdev->bars[nr];
> -
> uint32_t pci_bar;
> int ret;
>
> @@ -1662,10 +1687,12 @@ static void vfio_bar_prepare(VFIOPCIDevice *vdev, int nr)
> }
>
> /* Determine what type of BAR this is for registration */
> - ret = pread(vdev->vbasedev.fd, &pci_bar, sizeof(pci_bar),
> - vdev->config_offset + PCI_BASE_ADDRESS_0 + (4 * nr));
> + ret = VDEV_CONFIG_READ(&vdev->vbasedev, PCI_BASE_ADDRESS_0 + (4 * nr),
> + sizeof(pci_bar), &pci_bar);
> if (ret != sizeof(pci_bar)) {
> - error_report("vfio: Failed to read BAR %d (%m)", nr);
> + const char *err = ret < 0 ? strerror(-ret) : "short read";
> +
> + error_report("vfio: Failed to read BAR %d (%s)", nr, err);
> return;
> }
>
> @@ -2213,8 +2240,9 @@ static void vfio_pci_pre_reset(VFIOPCIDevice *vdev)
>
> static void vfio_pci_post_reset(VFIOPCIDevice *vdev)
> {
> + VFIODevice *vbasedev = &vdev->vbasedev;
> Error *err = NULL;
> - int nr;
> + int ret, nr;
>
> vfio_intx_enable(vdev, &err);
> if (err) {
> @@ -2222,13 +2250,16 @@ static void vfio_pci_post_reset(VFIOPCIDevice *vdev)
> }
>
> for (nr = 0; nr < PCI_NUM_REGIONS - 1; ++nr) {
> - off_t addr = vdev->config_offset + PCI_BASE_ADDRESS_0 + (4 * nr);
> + off_t addr = PCI_BASE_ADDRESS_0 + (4 * nr);
> uint32_t val = 0;
> uint32_t len = sizeof(val);
>
> - if (pwrite(vdev->vbasedev.fd, &val, len, addr) != len) {
> - error_report("%s(%s) reset bar %d failed: %m", __func__,
> - vdev->vbasedev.name, nr);
> + ret = VDEV_CONFIG_WRITE(vbasedev, addr, len, &val);
> + if (ret != len) {
> + const char *err = ret < 0 ? strerror(-ret) : "short write";
> +
> + error_report("%s(%s) reset bar %d failed: %s", __func__,
> + vbasedev->name, nr, err);
> }
> }
>
> @@ -2675,7 +2706,7 @@ static void vfio_populate_device(VFIOPCIDevice *vdev, Error **errp)
>
> irq_info.index = VFIO_PCI_ERR_IRQ_INDEX;
>
> - ret = ioctl(vdev->vbasedev.fd, VFIO_DEVICE_GET_IRQ_INFO, &irq_info);
> + 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));
> @@ -2794,8 +2825,10 @@ static void vfio_register_req_notifier(VFIOPCIDevice *vdev)
> return;
> }
>
> - if (ioctl(vdev->vbasedev.fd,
> - VFIO_DEVICE_GET_IRQ_INFO, &irq_info) < 0 || irq_info.count < 1) {
> + if (VDEV_GET_IRQ_INFO(&vdev->vbasedev, &irq_info) < 0) {
> + return;
> + }
> + if (irq_info.count < 1) {
> return;
> }
>
> @@ -2874,6 +2907,7 @@ static void vfio_realize(PCIDevice *pdev, Error **errp)
> vbasedev->ops = &vfio_pci_ops;
> vbasedev->type = VFIO_DEVICE_TYPE_PCI;
> vbasedev->dev = DEVICE(vdev);
> + vbasedev->io_ops = &vfio_dev_io_ioctl;
>
> tmp = g_strdup_printf("%s/iommu_group", vbasedev->sysfsdev);
> len = readlink(tmp, group_path, sizeof(group_path));
> diff --git a/hw/vfio/platform.c b/hw/vfio/platform.c
> index 5af73f9..c136b09 100644
> --- a/hw/vfio/platform.c
> +++ b/hw/vfio/platform.c
> @@ -621,6 +621,7 @@ static void vfio_platform_realize(DeviceState *dev, Error **errp)
> vbasedev->type = VFIO_DEVICE_TYPE_PLATFORM;
> vbasedev->dev = dev;
> vbasedev->ops = &vfio_platform_ops;
> + vbasedev->io_ops = &vfio_dev_io_ioctl;
>
> qemu_mutex_init(&vdev->intp_mutex);
>
> diff --git a/include/hw/vfio/vfio-common.h b/include/hw/vfio/vfio-common.h
> index a1db165..7713d98 100644
> --- a/include/hw/vfio/vfio-common.h
> +++ b/include/hw/vfio/vfio-common.h
> @@ -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;
VFIODeviceIoOps ?
> 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)))
I don't find these macros very usefull.
Thanks,
C.
> 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 */
^ permalink raw reply [flat|nested] 82+ messages in thread
* Re: [PATCH v1 06/24] vfio-user: Define type vfio_user_pci_dev_info
2022-11-08 23:13 ` [PATCH v1 06/24] vfio-user: Define type vfio_user_pci_dev_info John Johnson
2022-12-09 15:23 ` John Levon
@ 2022-12-12 9:01 ` Cédric Le Goater
2022-12-12 11:03 ` John Levon
2022-12-12 21:32 ` John Johnson
1 sibling, 2 replies; 82+ messages in thread
From: Cédric Le Goater @ 2022-12-12 9:01 UTC (permalink / raw)
To: John Johnson, qemu-devel
On 11/9/22 00:13, John Johnson wrote:
> New class for vfio-user with its class and instance
> constructors and destructors, and its pci ops.
>
> Signed-off-by: Elena Ufimtseva <elena.ufimtseva@oracle.com>
> Signed-off-by: John G Johnson <john.g.johnson@oracle.com>
> Signed-off-by: Jagannathan Raman <jag.raman@oracle.com>
> ---
> hw/vfio/Kconfig | 10 +++++++
> hw/vfio/common.c | 5 ++++
> hw/vfio/pci.c | 89 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++
> hw/vfio/pci.h | 8 +++++
> 4 files changed, 112 insertions(+)
>
> diff --git a/hw/vfio/Kconfig b/hw/vfio/Kconfig
> index 7cdba05..301894e 100644
> --- a/hw/vfio/Kconfig
> +++ b/hw/vfio/Kconfig
> @@ -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
> diff --git a/hw/vfio/common.c b/hw/vfio/common.c
> index c7bf0aa..c589bd9 100644
> --- a/hw/vfio/common.c
> +++ b/hw/vfio/common.c
> @@ -1774,6 +1774,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;
> + }
Since needs_reset is false, which is the case for VFIO User,
vfio_hot_reset_multi won't be called. I don't think we care
much about adding this error message. In another patch, may be.
> vbasedev->ops->vfio_hot_reset_multi(vbasedev);
> }
> }
> diff --git a/hw/vfio/pci.c b/hw/vfio/pci.c
> index 80b03a2..dc19869 100644
> --- a/hw/vfio/pci.c
> +++ b/hw/vfio/pci.c
> @@ -19,6 +19,7 @@
> */
>
> #include "qemu/osdep.h"
> +#include CONFIG_DEVICES
> #include <linux/vfio.h>
> #include <sys/ioctl.h>
>
> @@ -3421,3 +3422,91 @@ static void register_vfio_pci_dev_type(void)
> }
>
> type_init(register_vfio_pci_dev_type)
> +
> +
> +#ifdef CONFIG_VFIO_USER_PCI
Why not introduce a new file hw/vfio/user.c file ? It would be
cleaner.
> +
> +/*
> + * vfio-user routines.
> + */
> +
> +/*
> + * Emulated devices don't use host hot reset
> + */
> +static void vfio_user_compute_needs_reset(VFIODevice *vbasedev)
> +{
> + vbasedev->needs_reset = false;
> +}
> +
> +static VFIODeviceOps vfio_user_pci_ops = {
> + .vfio_compute_needs_reset = vfio_user_compute_needs_reset,
> + .vfio_eoi = vfio_intx_eoi,
> + .vfio_get_object = vfio_pci_get_object,
> + .vfio_save_config = vfio_pci_save_config,
> + .vfio_load_config = vfio_pci_load_config,
> +};
> +
> +static void vfio_user_pci_realize(PCIDevice *pdev, Error **errp)
> +{
> + ERRP_GUARD();
> + VFIOUserPCIDevice *udev = VFIO_USER_PCI(pdev);
> + VFIOPCIDevice *vdev = VFIO_PCI_BASE(pdev);
> + VFIODevice *vbasedev = &vdev->vbasedev;
> +
> + /*
> + * TODO: make option parser understand SocketAddress
> + * and use that instead of having scalar options
> + * for each socket type.
> + */
> + if (!udev->sock_name) {
> + error_setg(errp, "No socket specified");
> + error_append_hint(errp, "Use -device vfio-user-pci,socket=<name>\n");
> + return;
> + }
> +
> + vbasedev->name = g_strdup_printf("VFIO user <%s>", udev->sock_name);
> + vbasedev->ops = &vfio_user_pci_ops;
> + vbasedev->type = VFIO_DEVICE_TYPE_PCI;
> + vbasedev->dev = DEVICE(vdev);
> +
> +}
> +
> +static void vfio_user_instance_finalize(Object *obj)
> +{
> + VFIOPCIDevice *vdev = VFIO_PCI_BASE(obj);
> +
> + vfio_put_device(vdev);
> +}
> +
> +static Property vfio_user_pci_dev_properties[] = {
> + DEFINE_PROP_STRING("socket", VFIOUserPCIDevice, sock_name),
This looks like a good candidate for using a chardev. It could only
support AF_UNIX to start with if fd passing is the required feature.
But at least, the model would be using a well known backend. I think
vhost has the same kind of constraints.
Thanks,
C.
> + DEFINE_PROP_END_OF_LIST(),
> +};
> +
> +static void vfio_user_pci_dev_class_init(ObjectClass *klass, void *data)
> +{
> + DeviceClass *dc = DEVICE_CLASS(klass);
> + PCIDeviceClass *pdc = PCI_DEVICE_CLASS(klass);
> +
> + device_class_set_props(dc, vfio_user_pci_dev_properties);
> + dc->desc = "VFIO over socket PCI device assignment";
> + pdc->realize = vfio_user_pci_realize;
> +}
> +
> +static const TypeInfo vfio_user_pci_dev_info = {
> + .name = TYPE_VFIO_USER_PCI,
> + .parent = TYPE_VFIO_PCI_BASE,
> + .instance_size = sizeof(VFIOUserPCIDevice),
> + .class_init = vfio_user_pci_dev_class_init,
> + .instance_init = vfio_instance_init,
> + .instance_finalize = vfio_user_instance_finalize,
> +};
> +
> +static void register_vfio_user_dev_type(void)
> +{
> + type_register_static(&vfio_user_pci_dev_info);
> +}
> +
> +type_init(register_vfio_user_dev_type)
> +
> +#endif /* VFIO_USER_PCI */
> diff --git a/hw/vfio/pci.h b/hw/vfio/pci.h
> index 7c5c8ec..27db931 100644
> --- a/hw/vfio/pci.h
> +++ b/hw/vfio/pci.h
> @@ -189,6 +189,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)
> {
^ permalink raw reply [flat|nested] 82+ messages in thread
* Re: [PATCH v1 03/24] vfio-user: add container IO ops vector
2022-12-09 16:10 ` Cédric Le Goater
@ 2022-12-12 9:40 ` Philippe Mathieu-Daudé
0 siblings, 0 replies; 82+ messages in thread
From: Philippe Mathieu-Daudé @ 2022-12-12 9:40 UTC (permalink / raw)
To: Cédric Le Goater, John Johnson, qemu-devel
On 9/12/22 17:10, Cédric Le Goater wrote:
> Hello John,
>
> On 11/9/22 00:13, John Johnson wrote:
>> Used for communication with VFIO driver
>> (prep work for vfio-user, which will communicate over a socket)
>>
>> Signed-off-by: John G Johnson <john.g.johnson@oracle.com>
>> ---
>> hw/vfio/common.c | 126
>> ++++++++++++++++++++++++++++--------------
>> include/hw/vfio/vfio-common.h | 33 +++++++++++
>> 2 files changed, 117 insertions(+), 42 deletions(-)
>>
>> diff --git a/hw/vfio/common.c b/hw/vfio/common.c
>> index ace9562..83d69b9 100644
>> --- a/hw/vfio/common.c
>> +++ b/hw/vfio/common.c
>> @@ -432,12 +432,12 @@ static int vfio_dma_unmap_bitmap(VFIOContainer
>> *container,
>> goto unmap_exit;
>> }
>> - ret = ioctl(container->fd, VFIO_IOMMU_UNMAP_DMA, unmap);
>> + ret = CONT_DMA_UNMAP(container, unmap, bitmap);
>
> I am not sure these macros are very useful, compared to :
>
> container->ops->dma_unmap(container, unmap, bitmap);
I was going to report the same.
>> +/*
>> + * 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 {
>
> VFIOContainerOps seems more adequate with the current VFIO terminology
> in QEMU.
Yes please, abbreviated "Cont" is not helpful.
^ permalink raw reply [flat|nested] 82+ messages in thread
* Re: [PATCH v1 00/24] vfio-user client
2022-11-08 23:13 [PATCH v1 00/24] vfio-user client John Johnson
` (23 preceding siblings ...)
2022-11-08 23:13 ` [PATCH v1 24/24] vfio-user: add trace points John Johnson
@ 2022-12-12 9:41 ` Philippe Mathieu-Daudé
2022-12-16 11:31 ` Cédric Le Goater
25 siblings, 0 replies; 82+ messages in thread
From: Philippe Mathieu-Daudé @ 2022-12-12 9:41 UTC (permalink / raw)
To: John Johnson, qemu-devel; +Cc: Mark Burton, Edgar E. Iglesias
Cc'ing Mark & Edgar.
On 9/11/22 00:13, John Johnson wrote:
> Hello,
>
> This is the 6th revision of the vfio-user client implementation.
> It is the first patch series (the previous revisions were RFCs)
>
> First of all, thank you for your time reviewing the RFC 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 upstreamed a patch series that implement a server using QEMU.
>
>
> Contributors:
>
> John G Johnson <john.g.johnson@oracle.com>
> John Levon <john.levon@nutanix.com>
> Thanos Makatos <thanos.makatos@nutanix.com>
> Elena Ufimtseva <elena.ufimtseva@oracle.com>
> Jagannathan Raman <jag.raman@oracle.com>
>
> John Johnson (23):
> vfio-user: add VFIO base abstract class
> vfio-user: add container IO ops vector
> vfio-user: add region cache
> vfio-user: add device IO ops vector
> vfio-user: Define type vfio_user_pci_dev_info
> vfio-user: connect vfio proxy to remote server
> vfio-user: define socket receive functions
> vfio-user: define socket send functions
> vfio-user: get device info
> vfio-user: get region info
> vfio-user: region read/write
> vfio-user: pci_user_realize PCI setup
> vfio-user: get and set IRQs
> vfio-user: forward msix BAR accesses to server
> vfio-user: proxy container connect/disconnect
> vfio-user: dma map/unmap operations
> vfio-user: add dma_unmap_all
> vfio-user: secure DMA support
> vfio-user: dma read/write operations
> vfio-user: pci reset
> vfio-user: add 'x-msg-timeout' option that specifies msg wait times
> vfio-user: add coalesced posted writes
> vfio-user: add trace points
^ permalink raw reply [flat|nested] 82+ messages in thread
* Re: [PATCH v1 06/24] vfio-user: Define type vfio_user_pci_dev_info
2022-12-12 9:01 ` Cédric Le Goater
@ 2022-12-12 11:03 ` John Levon
2022-12-12 11:46 ` Philippe Mathieu-Daudé
2022-12-12 21:32 ` John Johnson
1 sibling, 1 reply; 82+ messages in thread
From: John Levon @ 2022-12-12 11:03 UTC (permalink / raw)
To: Cédric Le Goater; +Cc: John Johnson, qemu-devel
On Mon, Dec 12, 2022 at 10:01:33AM +0100, Cédric Le Goater wrote:
> > diff --git a/hw/vfio/pci.c b/hw/vfio/pci.c
> > index 80b03a2..dc19869 100644
> > --- a/hw/vfio/pci.c
> > +++ b/hw/vfio/pci.c
> > @@ -19,6 +19,7 @@
> > */
> > #include "qemu/osdep.h"
> > +#include CONFIG_DEVICES
> > #include <linux/vfio.h>
> > #include <sys/ioctl.h>
> > @@ -3421,3 +3422,91 @@ static void register_vfio_pci_dev_type(void)
> > }
> > type_init(register_vfio_pci_dev_type)
> > +
> > +
> > +#ifdef CONFIG_VFIO_USER_PCI
>
> Why not introduce a new file hw/vfio/user.c file ? It would be
> cleaner.
user.c is in this series, and holds the vfio-user implementation - it's not a
PCI specific thing. So it would have to be hw/vfio/user_pci.c or something
regards
john
^ permalink raw reply [flat|nested] 82+ messages in thread
* Re: [PATCH v1 04/24] vfio-user: add region cache
2022-11-08 23:13 ` [PATCH v1 04/24] vfio-user: add region cache John Johnson
2022-12-09 14:15 ` John Levon
2022-12-12 7:44 ` Cédric Le Goater
@ 2022-12-12 11:42 ` Philippe Mathieu-Daudé
2023-02-02 5:21 ` John Johnson
2 siblings, 1 reply; 82+ messages in thread
From: Philippe Mathieu-Daudé @ 2022-12-12 11:42 UTC (permalink / raw)
To: John Johnson, qemu-devel
On 9/11/22 00:13, John Johnson wrote:
> cache VFIO_DEVICE_GET_REGION_INFO results to reduce
> memory alloc/free cycles and as prep work for vfio-user
>
> Signed-off-by: John G Johnson <john.g.johnson@oracle.com>
> Signed-off-by: Elena Ufimtseva <elena.ufimtseva@oracle.com>
> Signed-off-by: Jagannathan Raman <jag.raman@oracle.com>
> ---
> hw/vfio/ccw.c | 5 -----
> hw/vfio/common.c | 41 +++++++++++++++++++++++++++++++++++------
> hw/vfio/igd.c | 23 +++++++++--------------
> hw/vfio/migration.c | 2 --
> hw/vfio/pci-quirks.c | 19 +++++--------------
> hw/vfio/pci.c | 8 --------
> include/hw/vfio/vfio-common.h | 2 ++
> 7 files changed, 51 insertions(+), 49 deletions(-)
> void vfio_put_base_device(VFIODevice *vbasedev)
> {
> + if (vbasedev->regions != NULL) {
> + int i;
> +
> + for (i = 0; i < vbasedev->num_regions; i++) {
> + g_free(vbasedev->regions[i]);
> + }
> + g_free(vbasedev->regions);
> + vbasedev->regions = NULL;
> + }
> +
> if (!vbasedev->group) {
> return;
> }
> @@ -2432,6 +2451,17 @@ int vfio_get_region_info(VFIODevice *vbasedev, int index,
> {
> size_t argsz = sizeof(struct vfio_region_info);
>
> + /* create region cache */
> + if (vbasedev->regions == NULL) {
> + vbasedev->regions = g_new0(struct vfio_region_info *,
> + vbasedev->num_regions);
> + }
> + /* check cache */
> + if (vbasedev->regions[index] != NULL) {
> + *info = vbasedev->regions[index];
> + return 0;
> + }
What about simply allocating/releasing once regions[] in
vfio_instance_init / vfio_instance_finalize?
^ permalink raw reply [flat|nested] 82+ messages in thread
* Re: [PATCH v1 06/24] vfio-user: Define type vfio_user_pci_dev_info
2022-12-12 11:03 ` John Levon
@ 2022-12-12 11:46 ` Philippe Mathieu-Daudé
2022-12-12 20:44 ` John Johnson
0 siblings, 1 reply; 82+ messages in thread
From: Philippe Mathieu-Daudé @ 2022-12-12 11:46 UTC (permalink / raw)
To: John Levon, Cédric Le Goater; +Cc: John Johnson, qemu-devel
On 12/12/22 12:03, John Levon wrote:
> On Mon, Dec 12, 2022 at 10:01:33AM +0100, Cédric Le Goater wrote:
>
>>> diff --git a/hw/vfio/pci.c b/hw/vfio/pci.c
>>> index 80b03a2..dc19869 100644
>>> --- a/hw/vfio/pci.c
>>> +++ b/hw/vfio/pci.c
>>> @@ -19,6 +19,7 @@
>>> */
>>> #include "qemu/osdep.h"
>>> +#include CONFIG_DEVICES
>>> #include <linux/vfio.h>
>>> #include <sys/ioctl.h>
>>> @@ -3421,3 +3422,91 @@ static void register_vfio_pci_dev_type(void)
>>> }
>>> type_init(register_vfio_pci_dev_type)
>>> +
>>> +
>>> +#ifdef CONFIG_VFIO_USER_PCI
>>
>> Why not introduce a new file hw/vfio/user.c file ? It would be
>> cleaner.
>
> user.c is in this series, and holds the vfio-user implementation - it's not a
> PCI specific thing. So it would have to be hw/vfio/user_pci.c or something
Or hw/vfio/pci-user.c
^ permalink raw reply [flat|nested] 82+ messages in thread
* Re: [PATCH v1 07/24] vfio-user: connect vfio proxy to remote server
2022-11-08 23:13 ` [PATCH v1 07/24] vfio-user: connect vfio proxy to remote server John Johnson
2022-12-09 15:23 ` John Levon
@ 2022-12-12 16:24 ` Cédric Le Goater
1 sibling, 0 replies; 82+ messages in thread
From: Cédric Le Goater @ 2022-12-12 16:24 UTC (permalink / raw)
To: John Johnson, qemu-devel
On 11/9/22 00:13, John Johnson wrote:
> add user.c & user.h files for vfio-user code
> add proxy struct to handle comms with remote server
>
> Signed-off-by: John G Johnson <john.g.johnson@oracle.com>
> Signed-off-by: Elena Ufimtseva <elena.ufimtseva@oracle.com>
> Signed-off-by: Jagannathan Raman <jag.raman@oracle.com>
> ---
> MAINTAINERS | 4 +
> hw/vfio/meson.build | 1 +
> hw/vfio/pci.c | 19 +++++
> hw/vfio/user.c | 170 ++++++++++++++++++++++++++++++++++++++++++
> hw/vfio/user.h | 78 +++++++++++++++++++
> include/hw/vfio/vfio-common.h | 2 +
> 6 files changed, 274 insertions(+)
> create mode 100644 hw/vfio/user.c
> create mode 100644 hw/vfio/user.h
>
> diff --git a/MAINTAINERS b/MAINTAINERS
> index 999340d..5d64d02 100644
> --- a/MAINTAINERS
> +++ b/MAINTAINERS
> @@ -1987,8 +1987,12 @@ L: qemu-s390x@nongnu.org
> vfio-user
> M: John G Johnson <john.g.johnson@oracle.com>
> M: Thanos Makatos <thanos.makatos@nutanix.com>
> +M: Elena Ufimtseva <elena.ufimtseva@oracle.com>
> +M: Jagannathan Raman <jag.raman@oracle.com>
> S: Supported
> F: docs/devel/vfio-user.rst
> +F: hw/vfio/user.c
> +F: hw/vfio/user.h
>
> vhost
> M: Michael S. Tsirkin <mst@redhat.com>
> diff --git a/hw/vfio/meson.build b/hw/vfio/meson.build
> index da9af29..2f86f72 100644
> --- a/hw/vfio/meson.build
> +++ b/hw/vfio/meson.build
> @@ -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'))
> diff --git a/hw/vfio/pci.c b/hw/vfio/pci.c
> index dc19869..e5f2413 100644
> --- a/hw/vfio/pci.c
> +++ b/hw/vfio/pci.c
> @@ -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) \
> @@ -3452,6 +3453,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
> @@ -3464,6 +3468,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) {
The underlying error of vfio_user_connect_dev() should be propagated.
> + error_setg(errp, "Remote proxy not found");
> + return;
> + }
> + vbasedev->proxy = proxy;
> +
> vbasedev->name = g_strdup_printf("VFIO user <%s>", udev->sock_name);
> vbasedev->ops = &vfio_user_pci_ops;
> vbasedev->type = VFIO_DEVICE_TYPE_PCI;
> @@ -3474,8 +3488,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) {
could be an assert ?
> + vfio_user_disconnect(vbasedev->proxy);
> + }
> }
>
> static Property vfio_user_pci_dev_properties[] = {
> diff --git a/hw/vfio/user.c b/hw/vfio/user.c
> new file mode 100644
> index 0000000..4f09060
> --- /dev/null
> +++ b/hw/vfio/user.c
> @@ -0,0 +1,170 @@
> +/*
> + * 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 or later.
> + * See the COPYING file in the top-level directory.
> + *
> + */
> +
> +#include "qemu/osdep.h"
> +#include <linux/vfio.h>
> +#include <sys/ioctl.h>
> +
> +#include "qemu/error-report.h"
> +#include "qapi/error.h"
> +#include "qemu/main-loop.h"
> +#include "hw/hw.h"
> +#include "hw/vfio/vfio-common.h"
> +#include "hw/vfio/vfio.h"
> +#include "qemu/sockets.h"
> +#include "io/channel.h"
> +#include "io/channel-socket.h"
> +#include "io/channel-util.h"
> +#include "sysemu/iothread.h"
> +#include "user.h"
> +
> +static IOThread *vfio_user_iothread;
> +
> +static void vfio_user_shutdown(VFIOProxy *proxy);
> +
> +
> +/*
> + * Functions called by main, CPU, or iothread threads
> + */
> +
> +static void vfio_user_shutdown(VFIOProxy *proxy)
> +{
> + qio_channel_shutdown(proxy->ioc, QIO_CHANNEL_SHUTDOWN_READ, NULL);
> + qio_channel_set_aio_fd_handler(proxy->ioc, proxy->ctx, NULL, NULL, NULL);
> +}
> +
> +/*
> + * Functions only called by iothread
> + */
> +
> +static void vfio_user_cb(void *opaque)
> +{
> + VFIOProxy *proxy = opaque;
> +
> + QEMU_LOCK_GUARD(&proxy->lock);
> +
> + proxy->state = VFIO_PROXY_CLOSED;
> + qemu_cond_signal(&proxy->close_cv);
> +}
> +
> +
> +/*
> + * Functions called by main or CPU threads
> + */
> +
> +static QLIST_HEAD(, VFIOProxy) vfio_user_sockets =
> + QLIST_HEAD_INITIALIZER(vfio_user_sockets);
> +
> +VFIOProxy *vfio_user_connect_dev(SocketAddress *addr, Error **errp)
> +{
> + VFIOProxy *proxy;
> + QIOChannelSocket *sioc;
> + QIOChannel *ioc;
> + char *sockname;
> +
> + if (addr->type != SOCKET_ADDRESS_TYPE_UNIX) {
> + error_setg(errp, "vfio_user_connect - bad address family");
> + return NULL;
> + }
> + sockname = addr->u.q_unix.path;
> +
> + sioc = qio_channel_socket_new();
> + ioc = QIO_CHANNEL(sioc);
> + if (qio_channel_socket_connect_sync(sioc, addr, errp)) {
> + object_unref(OBJECT(ioc));
> + return NULL;
> + }
> + qio_channel_set_blocking(ioc, false, NULL);
> +
> + proxy = g_malloc0(sizeof(VFIOProxy));
> + proxy->sockname = g_strdup_printf("unix:%s", sockname);
> + proxy->ioc = ioc;
> + proxy->flags = VFIO_PROXY_CLIENT;
> + proxy->state = VFIO_PROXY_CONNECTED;
> +
> + qemu_mutex_init(&proxy->lock);
> + qemu_cond_init(&proxy->close_cv);
> +
> + if (vfio_user_iothread == NULL) {
> + vfio_user_iothread = iothread_create("VFIO user", errp);
> + }
> +
> + proxy->ctx = iothread_get_aio_context(vfio_user_iothread);
> +
> + QTAILQ_INIT(&proxy->outgoing);
> + QTAILQ_INIT(&proxy->incoming);
> + QTAILQ_INIT(&proxy->free);
> + QTAILQ_INIT(&proxy->pending);
> + QLIST_INSERT_HEAD(&vfio_user_sockets, proxy, next);
> +
> + return proxy;
> +}
> +
> +void vfio_user_disconnect(VFIOProxy *proxy)
> +{
> + VFIOUserMsg *r1, *r2;
> +
> + qemu_mutex_lock(&proxy->lock);
> +
> + /* our side is quitting */
> + if (proxy->state == VFIO_PROXY_CONNECTED) {
> + vfio_user_shutdown(proxy);
> + if (!QTAILQ_EMPTY(&proxy->pending)) {
> + error_printf("vfio_user_disconnect: outstanding requests\n");
> + }
> + }
> + object_unref(OBJECT(proxy->ioc));
> + proxy->ioc = NULL;
> +
> + proxy->state = VFIO_PROXY_CLOSING;
> + QTAILQ_FOREACH_SAFE(r1, &proxy->outgoing, next, r2) {
> + qemu_cond_destroy(&r1->cv);
> + QTAILQ_REMOVE(&proxy->pending, r1, next);
> + g_free(r1);
> + }
> + QTAILQ_FOREACH_SAFE(r1, &proxy->incoming, next, r2) {
> + qemu_cond_destroy(&r1->cv);
> + QTAILQ_REMOVE(&proxy->incoming, r1, next);
> + g_free(r1);
> + }
> + QTAILQ_FOREACH_SAFE(r1, &proxy->pending, next, r2) {
> + qemu_cond_destroy(&r1->cv);
> + QTAILQ_REMOVE(&proxy->pending, r1, next);
> + g_free(r1);
> + }
> + QTAILQ_FOREACH_SAFE(r1, &proxy->free, next, r2) {
> + qemu_cond_destroy(&r1->cv);
> + QTAILQ_REMOVE(&proxy->free, r1, next);
> + g_free(r1);
> + }
> +
> + /*
> + * Make sure the iothread isn't blocking anywhere
> + * with a ref to this proxy by waiting for a BH
> + * handler to run after the proxy fd handlers were
> + * deleted above.
> + */
> + aio_bh_schedule_oneshot(proxy->ctx, vfio_user_cb, proxy);
> + qemu_cond_wait(&proxy->close_cv, &proxy->lock);
> +
> + /* we now hold the only ref to proxy */
> + qemu_mutex_unlock(&proxy->lock);
> + qemu_cond_destroy(&proxy->close_cv);
> + qemu_mutex_destroy(&proxy->lock);
> +
> + QLIST_REMOVE(proxy, next);
> + if (QLIST_EMPTY(&vfio_user_sockets)) {
> + iothread_destroy(vfio_user_iothread);
> + vfio_user_iothread = NULL;
> + }
> +
> + g_free(proxy->sockname);
> + g_free(proxy);
> +}
> diff --git a/hw/vfio/user.h b/hw/vfio/user.h
> new file mode 100644
> index 0000000..da92862
> --- /dev/null
> +++ b/hw/vfio/user.h
> @@ -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 {
VFIOUserProxy ? to be consistent with the namespace.
Thanks,
C.
> + 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 */
> diff --git a/include/hw/vfio/vfio-common.h b/include/hw/vfio/vfio-common.h
> index 7713d98..fb7d865 100644
> --- a/include/hw/vfio/vfio-common.h
> +++ b/include/hw/vfio/vfio-common.h
> @@ -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;
>
^ permalink raw reply [flat|nested] 82+ messages in thread
* Re: [PATCH v1 10/24] vfio-user: get device info
2022-12-09 15:57 ` John Levon
@ 2022-12-12 20:28 ` John Johnson
0 siblings, 0 replies; 82+ messages in thread
From: John Johnson @ 2022-12-12 20:28 UTC (permalink / raw)
To: John Levon; +Cc: qemu-devel
> On Dec 9, 2022, at 7:57 AM, John Levon <levon@movementarian.org> wrote:
>
> On Tue, Nov 08, 2022 at 03:13:32PM -0800, John Johnson wrote:
>
>> +/*
>> + * 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;
>
> The server doesn't have or populate cap_offset - and this isn't in the protocol
> either.
>
I can just delete it from VFIOUserDeviceInfo
JJ
^ permalink raw reply [flat|nested] 82+ messages in thread
* Re: [PATCH v1 14/24] vfio-user: get and set IRQs
2022-12-09 17:29 ` John Levon
@ 2022-12-12 20:28 ` John Johnson
0 siblings, 0 replies; 82+ messages in thread
From: John Johnson @ 2022-12-12 20:28 UTC (permalink / raw)
To: John Levon; +Cc: qemu-devel
> On Dec 9, 2022, at 9:29 AM, John Levon <levon@movementarian.org> wrote:
>
> On Tue, Nov 08, 2022 at 03:13:36PM -0800, John Johnson wrote:
>
>> +static int vfio_user_io_get_irq_info(VFIODevice *vbasedev,
>> + struct vfio_irq_info *irq)
>> +{
>> + int ret;
>> +
>> + ret = vfio_user_get_irq_info(vbasedev->proxy, irq);
>> + if (ret) {
>> + return ret;
>> + }
>> +
>> + if (irq->index > vbasedev->num_irqs) {
>> + return -EINVAL;
>> + }
>
> Why are we validating ->index *after* requesting the info? Seems a bit weird?
>
That check is to validate the server return content (to the extent we can).
JJ
^ permalink raw reply [flat|nested] 82+ messages in thread
* Re: [PATCH v1 02/24] vfio-user: add VFIO base abstract class
2022-12-09 16:04 ` Cédric Le Goater
@ 2022-12-12 20:30 ` John Johnson
0 siblings, 0 replies; 82+ messages in thread
From: John Johnson @ 2022-12-12 20:30 UTC (permalink / raw)
To: Cédric Le Goater; +Cc: qemu-devel
I can look into using orderfile
JJ
> On Dec 9, 2022, at 8:04 AM, Cédric Le Goater <clg@redhat.com> wrote:
>
> Hello John,
>
> On 11/9/22 00:13, John Johnson wrote:
>> Add an abstract base class both the kernel driver
>> and user socket implementations can use to share code.
>> Signed-off-by: John G Johnson <john.g.johnson@oracle.com>
>> Signed-off-by: Elena Ufimtseva <elena.ufimtseva@oracle.com>
>> Signed-off-by: Jagannathan Raman <jag.raman@oracle.com>
>
> I would help the reader if the header files came first. You could use :
>
> [diff]
> orderFile = /path/to/qemu/scripts/git.orderfile
>
>
> I would simply use 'Kernel' instead of 'Kern' in the type definition.
> A part from that,
>
> Reviewed-by: Cédric Le Goater <clg@redhat.com>
>
> Thanks,
>
> C.
>
>> ---
>> hw/vfio/pci.c | 106 +++++++++++++++++++++++++++++++++++-----------------------
>> hw/vfio/pci.h | 16 +++++++--
>> 2 files changed, 78 insertions(+), 44 deletions(-)
>> diff --git a/hw/vfio/pci.c b/hw/vfio/pci.c
>> index 939dcc3..60acde5 100644
>> --- a/hw/vfio/pci.c
>> +++ b/hw/vfio/pci.c
>> @@ -235,7 +235,7 @@ static void vfio_intx_update(VFIOPCIDevice *vdev, PCIINTxRoute *route)
>> static void vfio_intx_routing_notifier(PCIDevice *pdev)
>> {
>> - VFIOPCIDevice *vdev = VFIO_PCI(pdev);
>> + VFIOPCIDevice *vdev = VFIO_PCI_BASE(pdev);
>> PCIINTxRoute route;
>> if (vdev->interrupt != VFIO_INT_INTx) {
>> @@ -467,7 +467,7 @@ static void vfio_update_kvm_msi_virq(VFIOMSIVector *vector, MSIMessage msg,
>> static int vfio_msix_vector_do_use(PCIDevice *pdev, unsigned int nr,
>> MSIMessage *msg, IOHandler *handler)
>> {
>> - VFIOPCIDevice *vdev = VFIO_PCI(pdev);
>> + VFIOPCIDevice *vdev = VFIO_PCI_BASE(pdev);
>> VFIOMSIVector *vector;
>> int ret;
>> @@ -561,7 +561,7 @@ static int vfio_msix_vector_use(PCIDevice *pdev,
>> static void vfio_msix_vector_release(PCIDevice *pdev, unsigned int nr)
>> {
>> - VFIOPCIDevice *vdev = VFIO_PCI(pdev);
>> + VFIOPCIDevice *vdev = VFIO_PCI_BASE(pdev);
>> VFIOMSIVector *vector = &vdev->msi_vectors[nr];
>> trace_vfio_msix_vector_release(vdev->vbasedev.name, nr);
>> @@ -1109,7 +1109,7 @@ static const MemoryRegionOps vfio_vga_ops = {
>> */
>> static void vfio_sub_page_bar_update_mapping(PCIDevice *pdev, int bar)
>> {
>> - VFIOPCIDevice *vdev = VFIO_PCI(pdev);
>> + VFIOPCIDevice *vdev = VFIO_PCI_BASE(pdev);
>> VFIORegion *region = &vdev->bars[bar].region;
>> MemoryRegion *mmap_mr, *region_mr, *base_mr;
>> PCIIORegion *r;
>> @@ -1155,7 +1155,7 @@ static void vfio_sub_page_bar_update_mapping(PCIDevice *pdev, int bar)
>> */
>> uint32_t vfio_pci_read_config(PCIDevice *pdev, uint32_t addr, int len)
>> {
>> - VFIOPCIDevice *vdev = VFIO_PCI(pdev);
>> + VFIOPCIDevice *vdev = VFIO_PCI_BASE(pdev);
>> uint32_t emu_bits = 0, emu_val = 0, phys_val = 0, val;
>> memcpy(&emu_bits, vdev->emulated_config_bits + addr, len);
>> @@ -1188,7 +1188,7 @@ uint32_t vfio_pci_read_config(PCIDevice *pdev, uint32_t addr, int len)
>> void vfio_pci_write_config(PCIDevice *pdev,
>> uint32_t addr, uint32_t val, int len)
>> {
>> - VFIOPCIDevice *vdev = VFIO_PCI(pdev);
>> + VFIOPCIDevice *vdev = VFIO_PCI_BASE(pdev);
>> uint32_t val_le = cpu_to_le32(val);
>> trace_vfio_pci_write_config(vdev->vbasedev.name, addr, val, len);
>> @@ -2845,7 +2845,7 @@ static void vfio_unregister_req_notifier(VFIOPCIDevice *vdev)
>> static void vfio_realize(PCIDevice *pdev, Error **errp)
>> {
>> - VFIOPCIDevice *vdev = VFIO_PCI(pdev);
>> + VFIOPCIDevice *vdev = VFIO_PCI_BASE(pdev);
>> VFIODevice *vbasedev = &vdev->vbasedev;
>> VFIODevice *vbasedev_iter;
>> VFIOGroup *group;
>> @@ -3169,7 +3169,7 @@ error:
>> static void vfio_instance_finalize(Object *obj)
>> {
>> - VFIOPCIDevice *vdev = VFIO_PCI(obj);
>> + VFIOPCIDevice *vdev = VFIO_PCI_BASE(obj);
>> VFIOGroup *group = vdev->vbasedev.group;
>> vfio_display_finalize(vdev);
>> @@ -3189,7 +3189,7 @@ static void vfio_instance_finalize(Object *obj)
>> static void vfio_exitfn(PCIDevice *pdev)
>> {
>> - VFIOPCIDevice *vdev = VFIO_PCI(pdev);
>> + VFIOPCIDevice *vdev = VFIO_PCI_BASE(pdev);
>> vfio_unregister_req_notifier(vdev);
>> vfio_unregister_err_notifier(vdev);
>> @@ -3208,7 +3208,7 @@ static void vfio_exitfn(PCIDevice *pdev)
>> static void vfio_pci_reset(DeviceState *dev)
>> {
>> - VFIOPCIDevice *vdev = VFIO_PCI(dev);
>> + VFIOPCIDevice *vdev = VFIO_PCI_BASE(dev);
>> trace_vfio_pci_reset(vdev->vbasedev.name);
>> @@ -3248,7 +3248,7 @@ post_reset:
>> static void vfio_instance_init(Object *obj)
>> {
>> PCIDevice *pci_dev = PCI_DEVICE(obj);
>> - VFIOPCIDevice *vdev = VFIO_PCI(obj);
>> + VFIOPCIDevice *vdev = VFIO_PCI_BASE(obj);
>> device_add_bootindex_property(obj, &vdev->bootindex,
>> "bootindex", NULL,
>> @@ -3265,24 +3265,12 @@ static void vfio_instance_init(Object *obj)
>> pci_dev->cap_present |= QEMU_PCI_CAP_EXPRESS;
>> }
>> -static Property vfio_pci_dev_properties[] = {
>> - DEFINE_PROP_PCI_HOST_DEVADDR("host", VFIOPCIDevice, host),
>> - DEFINE_PROP_STRING("sysfsdev", VFIOPCIDevice, vbasedev.sysfsdev),
>> +static Property vfio_pci_base_dev_properties[] = {
>> DEFINE_PROP_ON_OFF_AUTO("x-pre-copy-dirty-page-tracking", VFIOPCIDevice,
>> vbasedev.pre_copy_dirty_page_tracking,
>> ON_OFF_AUTO_ON),
>> - DEFINE_PROP_ON_OFF_AUTO("display", VFIOPCIDevice,
>> - display, ON_OFF_AUTO_OFF),
>> - DEFINE_PROP_UINT32("xres", VFIOPCIDevice, display_xres, 0),
>> - DEFINE_PROP_UINT32("yres", VFIOPCIDevice, display_yres, 0),
>> DEFINE_PROP_UINT32("x-intx-mmap-timeout-ms", VFIOPCIDevice,
>> intx.mmap_timeout, 1100),
>> - DEFINE_PROP_BIT("x-vga", VFIOPCIDevice, features,
>> - VFIO_FEATURE_ENABLE_VGA_BIT, false),
>> - DEFINE_PROP_BIT("x-req", VFIOPCIDevice, features,
>> - VFIO_FEATURE_ENABLE_REQ_BIT, true),
>> - DEFINE_PROP_BIT("x-igd-opregion", VFIOPCIDevice, features,
>> - VFIO_FEATURE_ENABLE_IGD_OPREGION_BIT, false),
>> DEFINE_PROP_BOOL("x-enable-migration", VFIOPCIDevice,
>> vbasedev.enable_migration, false),
>> DEFINE_PROP_BOOL("x-no-mmap", VFIOPCIDevice, vbasedev.no_mmap, false),
>> @@ -3291,8 +3279,6 @@ static Property vfio_pci_dev_properties[] = {
>> DEFINE_PROP_BOOL("x-no-kvm-intx", VFIOPCIDevice, no_kvm_intx, false),
>> DEFINE_PROP_BOOL("x-no-kvm-msi", VFIOPCIDevice, no_kvm_msi, false),
>> DEFINE_PROP_BOOL("x-no-kvm-msix", VFIOPCIDevice, no_kvm_msix, false),
>> - DEFINE_PROP_BOOL("x-no-geforce-quirks", VFIOPCIDevice,
>> - no_geforce_quirks, false),
>> DEFINE_PROP_BOOL("x-no-kvm-ioeventfd", VFIOPCIDevice, no_kvm_ioeventfd,
>> false),
>> DEFINE_PROP_BOOL("x-no-vfio-ioeventfd", VFIOPCIDevice, no_vfio_ioeventfd,
>> @@ -3303,10 +3289,6 @@ static Property vfio_pci_dev_properties[] = {
>> sub_vendor_id, PCI_ANY_ID),
>> DEFINE_PROP_UINT32("x-pci-sub-device-id", VFIOPCIDevice,
>> sub_device_id, PCI_ANY_ID),
>> - DEFINE_PROP_UINT32("x-igd-gms", VFIOPCIDevice, igd_gms, 0),
>> - DEFINE_PROP_UNSIGNED_NODEFAULT("x-nv-gpudirect-clique", VFIOPCIDevice,
>> - nv_gpudirect_clique,
>> - qdev_prop_nv_gpudirect_clique, uint8_t),
>> DEFINE_PROP_OFF_AUTO_PCIBAR("x-msix-relocation", VFIOPCIDevice, msix_relo,
>> OFF_AUTOPCIBAR_OFF),
>> /*
>> @@ -3317,28 +3299,25 @@ static Property vfio_pci_dev_properties[] = {
>> DEFINE_PROP_END_OF_LIST(),
>> };
>> -static void vfio_pci_dev_class_init(ObjectClass *klass, void *data)
>> +static void vfio_pci_base_dev_class_init(ObjectClass *klass, void *data)
>> {
>> DeviceClass *dc = DEVICE_CLASS(klass);
>> PCIDeviceClass *pdc = PCI_DEVICE_CLASS(klass);
>> - dc->reset = vfio_pci_reset;
>> - device_class_set_props(dc, vfio_pci_dev_properties);
>> - dc->desc = "VFIO-based PCI device assignment";
>> + device_class_set_props(dc, vfio_pci_base_dev_properties);
>> + dc->desc = "VFIO PCI base device";
>> set_bit(DEVICE_CATEGORY_MISC, dc->categories);
>> - pdc->realize = vfio_realize;
>> pdc->exit = vfio_exitfn;
>> pdc->config_read = vfio_pci_read_config;
>> pdc->config_write = vfio_pci_write_config;
>> }
>> -static const TypeInfo vfio_pci_dev_info = {
>> - .name = TYPE_VFIO_PCI,
>> +static const TypeInfo vfio_pci_base_dev_info = {
>> + .name = TYPE_VFIO_PCI_BASE,
>> .parent = TYPE_PCI_DEVICE,
>> - .instance_size = sizeof(VFIOPCIDevice),
>> - .class_init = vfio_pci_dev_class_init,
>> - .instance_init = vfio_instance_init,
>> - .instance_finalize = vfio_instance_finalize,
>> + .instance_size = 0,
>> + .abstract = true,
>> + .class_init = vfio_pci_base_dev_class_init,
>> .interfaces = (InterfaceInfo[]) {
>> { INTERFACE_PCIE_DEVICE },
>> { INTERFACE_CONVENTIONAL_PCI_DEVICE },
>> @@ -3346,6 +3325,48 @@ static const TypeInfo vfio_pci_dev_info = {
>> },
>> };
>> +static Property vfio_pci_dev_properties[] = {
>> + DEFINE_PROP_PCI_HOST_DEVADDR("host", VFIOPCIDevice, host),
>> + DEFINE_PROP_STRING("sysfsdev", VFIOPCIDevice, vbasedev.sysfsdev),
>> + DEFINE_PROP_ON_OFF_AUTO("display", VFIOPCIDevice,
>> + display, ON_OFF_AUTO_OFF),
>> + DEFINE_PROP_UINT32("xres", VFIOPCIDevice, display_xres, 0),
>> + DEFINE_PROP_UINT32("yres", VFIOPCIDevice, display_yres, 0),
>> + DEFINE_PROP_BIT("x-vga", VFIOPCIDevice, features,
>> + VFIO_FEATURE_ENABLE_VGA_BIT, false),
>> + DEFINE_PROP_BIT("x-req", VFIOPCIDevice, features,
>> + VFIO_FEATURE_ENABLE_REQ_BIT, true),
>> + DEFINE_PROP_BIT("x-igd-opregion", VFIOPCIDevice, features,
>> + VFIO_FEATURE_ENABLE_IGD_OPREGION_BIT, false),
>> + DEFINE_PROP_BOOL("x-no-geforce-quirks", VFIOPCIDevice,
>> + no_geforce_quirks, false),
>> + DEFINE_PROP_UINT32("x-igd-gms", VFIOPCIDevice, igd_gms, 0),
>> + DEFINE_PROP_UNSIGNED_NODEFAULT("x-nv-gpudirect-clique", VFIOPCIDevice,
>> + nv_gpudirect_clique,
>> + qdev_prop_nv_gpudirect_clique, uint8_t),
>> + DEFINE_PROP_END_OF_LIST(),
>> +};
>> +
>> +static void vfio_pci_dev_class_init(ObjectClass *klass, void *data)
>> +{
>> + DeviceClass *dc = DEVICE_CLASS(klass);
>> + PCIDeviceClass *pdc = PCI_DEVICE_CLASS(klass);
>> +
>> + dc->reset = vfio_pci_reset;
>> + device_class_set_props(dc, vfio_pci_dev_properties);
>> + dc->desc = "VFIO-based PCI device assignment";
>> + pdc->realize = vfio_realize;
>> +}
>> +
>> +static const TypeInfo vfio_pci_dev_info = {
>> + .name = TYPE_VFIO_PCI,
>> + .parent = TYPE_VFIO_PCI_BASE,
>> + .instance_size = sizeof(VFIOKernPCIDevice),
>> + .class_init = vfio_pci_dev_class_init,
>> + .instance_init = vfio_instance_init,
>> + .instance_finalize = vfio_instance_finalize,
>> +};
>> +
>> static Property vfio_pci_dev_nohotplug_properties[] = {
>> DEFINE_PROP_BOOL("ramfb", VFIOPCIDevice, enable_ramfb, false),
>> DEFINE_PROP_END_OF_LIST(),
>> @@ -3362,12 +3383,13 @@ static void vfio_pci_nohotplug_dev_class_init(ObjectClass *klass, void *data)
>> static const TypeInfo vfio_pci_nohotplug_dev_info = {
>> .name = TYPE_VFIO_PCI_NOHOTPLUG,
>> .parent = TYPE_VFIO_PCI,
>> - .instance_size = sizeof(VFIOPCIDevice),
>> + .instance_size = sizeof(VFIOKernPCIDevice),
>> .class_init = vfio_pci_nohotplug_dev_class_init,
>> };
>> static void register_vfio_pci_dev_type(void)
>> {
>> + type_register_static(&vfio_pci_base_dev_info);
>> type_register_static(&vfio_pci_dev_info);
>> type_register_static(&vfio_pci_nohotplug_dev_info);
>> }
>> diff --git a/hw/vfio/pci.h b/hw/vfio/pci.h
>> index 7c236a5..7c5c8ec 100644
>> --- a/hw/vfio/pci.h
>> +++ b/hw/vfio/pci.h
>> @@ -115,8 +115,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;
>> @@ -177,6 +182,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)
>> {
>
^ permalink raw reply [flat|nested] 82+ messages in thread
* Re: [PATCH v1 19/24] vfio-user: secure DMA support
2022-12-09 18:01 ` John Levon
@ 2022-12-12 20:31 ` John Johnson
0 siblings, 0 replies; 82+ messages in thread
From: John Johnson @ 2022-12-12 20:31 UTC (permalink / raw)
To: John Levon; +Cc: qemu-devel
> On Dec 9, 2022, at 10:01 AM, John Levon <levon@movementarian.org> wrote:
>
> On Tue, Nov 08, 2022 at 03:13:41PM -0800, John Johnson wrote:
>
>> Secure DMA forces the remote process to use DMA r/w messages
>> instead of directly mapping guest memeory.
>
> I don't really get why this is called "secure" - shouldn't have an option name
> more closely resembling what it actually does?
>
The option was added to address a security concern if the server has
mmap() access to guest memory. I can re-name it.
JJ
^ permalink raw reply [flat|nested] 82+ messages in thread
* Re: [PATCH v1 06/24] vfio-user: Define type vfio_user_pci_dev_info
2022-12-12 11:46 ` Philippe Mathieu-Daudé
@ 2022-12-12 20:44 ` John Johnson
0 siblings, 0 replies; 82+ messages in thread
From: John Johnson @ 2022-12-12 20:44 UTC (permalink / raw)
To: Philippe Mathieu-Daudé; +Cc: John Levon, Cédric Le Goater, qemu-devel
> On Dec 12, 2022, at 3:46 AM, Philippe Mathieu-Daudé <philmd@linaro.org> wrote:
>
> On 12/12/22 12:03, John Levon wrote:
>> On Mon, Dec 12, 2022 at 10:01:33AM +0100, Cédric Le Goater wrote:
>>>> diff --git a/hw/vfio/pci.c b/hw/vfio/pci.c
>>>> index 80b03a2..dc19869 100644
>>>> --- a/hw/vfio/pci.c
>>>> +++ b/hw/vfio/pci.c
>>>> @@ -19,6 +19,7 @@
>>>> */
>>>> #include "qemu/osdep.h"
>>>> +#include CONFIG_DEVICES
>>>> #include <linux/vfio.h>
>>>> #include <sys/ioctl.h>
>>>> @@ -3421,3 +3422,91 @@ static void register_vfio_pci_dev_type(void)
>>>> }
>>>> type_init(register_vfio_pci_dev_type)
>>>> +
>>>> +
>>>> +#ifdef CONFIG_VFIO_USER_PCI
>>>
>>> Why not introduce a new file hw/vfio/user.c file ? It would be
>>> cleaner.
>> user.c is in this series, and holds the vfio-user implementation - it's not a
>> PCI specific thing. So it would have to be hw/vfio/user_pci.c or something
>
> Or hw/vfio/pci-user.c
The vfio_user_* routines use a lot of hw/vfio/pci.c routines, so we’d
need to make a lot of those routines non-static if we made a new file.
JJ
^ permalink raw reply [flat|nested] 82+ messages in thread
* Re: [PATCH v1 06/24] vfio-user: Define type vfio_user_pci_dev_info
2022-12-12 9:01 ` Cédric Le Goater
2022-12-12 11:03 ` John Levon
@ 2022-12-12 21:32 ` John Johnson
1 sibling, 0 replies; 82+ messages in thread
From: John Johnson @ 2022-12-12 21:32 UTC (permalink / raw)
To: Cédric Le Goater; +Cc: qemu-devel
> On Dec 12, 2022, at 1:01 AM, Cédric Le Goater <clg@redhat.com> wrote:
>
> On 11/9/22 00:13, John Johnson wrote:
>>
>> +
>> +static Property vfio_user_pci_dev_properties[] = {
>> + DEFINE_PROP_STRING("socket", VFIOUserPCIDevice, sock_name),
>
> This looks like a good candidate for using a chardev. It could only
> support AF_UNIX to start with if fd passing is the required feature.
> But at least, the model would be using a well known backend. I think
> vhost has the same kind of constraints.
>
It should be a SocketAddress, but there is no command line
parser for that. The next best option was to name the struct members
individually, so a string for addr.u.q_unix.path
JJ
^ permalink raw reply [flat|nested] 82+ messages in thread
* Re: [PATCH v1 08/24] vfio-user: define socket receive functions
2022-11-08 23:13 ` [PATCH v1 08/24] vfio-user: define socket receive functions John Johnson
2022-12-09 15:34 ` John Levon
@ 2022-12-13 10:45 ` Cédric Le Goater
1 sibling, 0 replies; 82+ messages in thread
From: Cédric Le Goater @ 2022-12-13 10:45 UTC (permalink / raw)
To: John Johnson, qemu-devel
On 11/9/22 00:13, John Johnson wrote:
> Add infrastructure needed to receive incoming messages
>
> Signed-off-by: John G Johnson <john.g.johnson@oracle.com>
> Signed-off-by: Elena Ufimtseva <elena.ufimtseva@oracle.com>
> Signed-off-by: Jagannathan Raman <jag.raman@oracle.com>
> ---
> MAINTAINERS | 1 +
> hw/vfio/pci.c | 11 ++
> hw/vfio/user-protocol.h | 54 +++++++
> hw/vfio/user.c | 399 ++++++++++++++++++++++++++++++++++++++++++++++++
> hw/vfio/user.h | 8 +
> 5 files changed, 473 insertions(+)
> create mode 100644 hw/vfio/user-protocol.h>
> diff --git a/MAINTAINERS b/MAINTAINERS
> index 5d64d02..b6c186b 100644
> --- a/MAINTAINERS
> +++ b/MAINTAINERS
> @@ -1993,6 +1993,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 <mst@redhat.com>
> diff --git a/hw/vfio/pci.c b/hw/vfio/pci.c
> index e5f2413..f086235 100644
> --- a/hw/vfio/pci.c
> +++ b/hw/vfio/pci.c
> @@ -3432,6 +3432,16 @@ type_init(register_vfio_pci_dev_type)
> */
>
> /*
> + * Incoming request message callback.
> + *
> + * Runs off main loop, so BQL held.
> + */
> +static void vfio_user_pci_process_req(void *opaque, VFIOUserMsg *msg)
> +{
> +
> +}
> +
> +/*
> * Emulated devices don't use host hot reset
> */
> static void vfio_user_compute_needs_reset(VFIODevice *vbasedev)
> @@ -3477,6 +3487,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->ops = &vfio_user_pci_ops;
> diff --git a/hw/vfio/user-protocol.h b/hw/vfio/user-protocol.h
> new file mode 100644
> index 0000000..d23877c
> --- /dev/null
> +++ b/hw/vfio/user-protocol.h
> @@ -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 */
> diff --git a/hw/vfio/user.c b/hw/vfio/user.c
> index 4f09060..ffd69b9 100644
> --- a/hw/vfio/user.c
> +++ b/hw/vfio/user.c
> @@ -28,7 +28,22 @@
> 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 +55,334 @@ 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));
may be change the fds field of VFIOUserFDs struct to fds[];
> +
> + return fds;
> +}
> +
> /*
> * Functions only called by iothread
> */
>
> +/*
> + * Process a received message.
> + */
> +static void vfio_user_process(VFIOProxy *proxy, VFIOUserMsg *msg, bool isreply)
> +{
> +
> + /*
> + * 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 (msg->hdr->flags & VFIO_USER_ERROR) {
> + error_printf("vfio_user_rcv: error reply on async request ");
> + error_printf("command %x error %s\n", msg->hdr->command,
> + strerror(msg->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);
> + }
> +}
> +
> +/*
> + * Complete a partial message read
> + */
> +static int vfio_user_complete(VFIOProxy *proxy, Error **errp)
> +{
> + VFIOUserMsg *msg = proxy->part_recv;
> + size_t msgleft = proxy->recv_left;
> + bool isreply;
> + char *data;
> + int ret;
> +
> + data = (char *)msg->hdr + (msg->hdr->size - msgleft);
> + while (msgleft > 0) {
> + ret = qio_channel_read(proxy->ioc, data, msgleft, errp);
> +
> + /* error or would block */
> + if (ret <= 0) {
> + /* try for rest on next iternation */
> + if (ret == QIO_CHANNEL_ERR_BLOCK) {
> + proxy->recv_left = msgleft;
> + }
> + return ret;
> + }
> +
> + msgleft -= ret;
> + data += ret;
> + }
> +
> + /*
> + * Read complete message, process it.
> + */
> + proxy->part_recv = NULL;
> + proxy->recv_left = 0;
> + isreply = (msg->hdr->flags & VFIO_USER_TYPE) == VFIO_USER_REPLY;
> + vfio_user_process(proxy, msg, isreply);
> +
> + /* return positive value */
> + return 1;
> +}
> +
> +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;
> +
> + /*
> + * Complete any partial reads
> + */
> + if (proxy->part_recv != NULL) {
> + ret = vfio_user_complete(proxy, &local_err);
> +
> + /* still not complete, try later */
> + if (ret == QIO_CHANNEL_ERR_BLOCK) {
> + return ret;
> + }
> +
> + if (ret <= 0) {
> + goto fatal;
> + }
> + /* else fall into reading another msg */
> + }
> +
> + /*
> + * Read header
> + */
> + ret = qio_channel_readv_full(proxy->ioc, &iov, 1, &fdp, &numfds,
> + &local_err);
> + if (ret == QIO_CHANNEL_ERR_BLOCK) {
> + return ret;
> + }
> +
> + /* read error or other side closed connection */
> + if (ret <= 0) {
> + goto fatal;
> + }
> +
> + if (ret < sizeof(msg)) {
> + error_setg(&local_err, "short read of header");
> + goto fatal;
> + }
> +
> + /*
> + * Validate header
> + */
> + if (hdr.size < sizeof(VFIOUserHdr)) {
> + error_setg(&local_err, "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, "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, "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, "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;
> + }
> + }
Looks good. Pity we can not use the chardev/char-socket.c code.
Thanks,
C.
> + /*
> + * Put the whole message into a single buffer.
> + */
> + if (isreply) {
> + if (hdr.size > msg->rsize) {
> + error_setg(&local_err, "reply larger than recv buffer");
> + goto err;
> + }
> + *msg->hdr = hdr;
> + data = (char *)msg->hdr + sizeof(hdr);
> + } else {
> + 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;
> + }
> +
> + /*
> + * Read rest of message.
> + */
> + msgleft = hdr.size - sizeof(hdr);
> + while (msgleft > 0) {
> + ret = qio_channel_read(proxy->ioc, data, msgleft, &local_err);
> +
> + /* prepare to complete read on next iternation */
> + if (ret == QIO_CHANNEL_ERR_BLOCK) {
> + proxy->part_recv = msg;
> + proxy->recv_left = msgleft;
> + return ret;
> + }
> +
> + if (ret <= 0) {
> + goto fatal;
> + }
> +
> + msgleft -= ret;
> + data += ret;
> + }
> +
> + vfio_user_process(proxy, msg, isreply);
> + 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;
> +
> + /* set error if server side closed */
> + if (ret == 0) {
> + error_setg(&local_err, "server closed socket");
> + }
> +
> +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_prepend(&local_err, "vfio_user_recv: ");
> + error_report_err(local_err);
> + return -1;
> +}
> +
> static void vfio_user_cb(void *opaque)
> {
> VFIOProxy *proxy = opaque;
> @@ -59,6 +398,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->incoming, 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 +481,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);
> @@ -107,6 +492,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;
> @@ -122,6 +519,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) {
> diff --git a/hw/vfio/user.h b/hw/vfio/user.h
> index da92862..68a1080 100644
> --- a/hw/vfio/user.h
> +++ b/hw/vfio/user.h
> @@ -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;
> @@ -66,6 +69,8 @@ typedef struct VFIOProxy {
> VFIOUserMsgQ incoming;
> VFIOUserMsgQ outgoing;
> VFIOUserMsg *last_nowait;
> + VFIOUserMsg *part_recv;
> + size_t recv_left;
> enum proxy_state state;
> } VFIOProxy;
>
> @@ -74,5 +79,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 */
^ permalink raw reply [flat|nested] 82+ messages in thread
* Re: [PATCH v1 09/24] vfio-user: define socket send functions
2022-11-08 23:13 ` [PATCH v1 09/24] vfio-user: define socket send functions John Johnson
2022-12-09 15:52 ` John Levon
@ 2022-12-13 13:48 ` Cédric Le Goater
2023-02-02 5:21 ` John Johnson
1 sibling, 1 reply; 82+ messages in thread
From: Cédric Le Goater @ 2022-12-13 13:48 UTC (permalink / raw)
To: John Johnson, qemu-devel
On 11/9/22 00:13, John Johnson wrote:
> Also negotiate protocol version with remote server
>
> Signed-off-by: Jagannathan Raman <jag.raman@oracle.com>
> Signed-off-by: Elena Ufimtseva <elena.ufimtseva@oracle.com>
> Signed-off-by: John G Johnson <john.g.johnson@oracle.com>
> ---
> hw/vfio/pci.c | 15 ++
> hw/vfio/pci.h | 1 +
> hw/vfio/user-protocol.h | 62 ++++++
> hw/vfio/user.c | 508 ++++++++++++++++++++++++++++++++++++++++++++++++
> hw/vfio/user.h | 9 +
> 5 files changed, 595 insertions(+)
>
> diff --git a/hw/vfio/pci.c b/hw/vfio/pci.c
> index f086235..b2534b3 100644
> --- a/hw/vfio/pci.c
> +++ b/hw/vfio/pci.c
> @@ -3489,11 +3489,25 @@ 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(proxy, &err);
> + if (err != NULL) {
> + error_propagate(errp, err);
> + goto error;
> + }
> +
> vbasedev->name = g_strdup_printf("VFIO user <%s>", udev->sock_name);
> vbasedev->ops = &vfio_user_pci_ops;
> vbasedev->type = VFIO_DEVICE_TYPE_PCI;
> vbasedev->dev = DEVICE(vdev);
>
> + return;
> +
> +error:
> + error_prepend(errp, VFIO_MSG_PREFIX, vdev->vbasedev.name);
> }
>
> static void vfio_user_instance_finalize(Object *obj)
> @@ -3510,6 +3524,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(),
> };
>
> diff --git a/hw/vfio/pci.h b/hw/vfio/pci.h
> index 27db931..c47d2f8 100644
> --- a/hw/vfio/pci.h
> +++ b/hw/vfio/pci.h
> @@ -195,6 +195,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 */
> diff --git a/hw/vfio/user-protocol.h b/hw/vfio/user-protocol.h
> index d23877c..5de5b20 100644
> --- a/hw/vfio/user-protocol.h
> +++ b/hw/vfio/user-protocol.h
> @@ -51,4 +51,66 @@ 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_PGSIZES "pgsizes"
> +#define VFIO_USER_CAP_MAP_MAX "max_dma_maps"
> +#define VFIO_USER_CAP_MIGR "migration"
> +
> +/* "migration" members */
> +#define VFIO_USER_CAP_PGSIZE "pgsize"
> +#define VFIO_USER_CAP_MAX_BITMAP "max_bitmap_size"
> +
> +/*
> + * 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)
> +
> +/*
> + * Default pagesizes supported is 4k.
> + */
> +#define VFIO_USER_DEF_PGSIZE 4096
> +
> +/*
> + * Default max number of DMA mappings is stolen from the
> + * linux kernel "dma_entry_limit"
> + */
> +#define VFIO_USER_DEF_MAP_MAX 65535
> +
> +/*
> + * Default max bitmap size is also take from the linux kernel,
> + * where usage of signed ints limits the VA range to 2^31 bytes.
> + * Dividing that by the number of bits per byte yields 256MB
> + */
> +#define VFIO_USER_DEF_MAX_BITMAP (256 * 1024 * 1024)
> +
> #endif /* VFIO_USER_PROTOCOL_H */
> diff --git a/hw/vfio/user.c b/hw/vfio/user.c
> index ffd69b9..31bcc93 100644
> --- a/hw/vfio/user.c
> +++ b/hw/vfio/user.c
> @@ -23,11 +23,19 @@
> #include "io/channel-socket.h"
> #include "io/channel-util.h"
> #include "sysemu/iothread.h"
> +#include "qapi/qmp/qdict.h"
> +#include "qapi/qmp/qjson.h"
> +#include "qapi/qmp/qnull.h"
> +#include "qapi/qmp/qstring.h"
> +#include "qapi/qmp/qnum.h"
> +#include "qapi/qmp/qbool.h"
> #include "user.h"
>
> +static int wait_time = 5000; /* wait up to 5 sec for busy servers */
> static 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);
> @@ -35,9 +43,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);
> 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)
> {
> @@ -55,6 +70,33 @@ 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, 0,
> + &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)
> {
> @@ -95,6 +137,7 @@ static void vfio_user_recycle(VFIOProxy *proxy, VFIOUserMsg *msg)
> msg->hdr = NULL;
> msg->fds = NULL;
> msg->complete = false;
> + msg->pending = false;
> QTAILQ_INSERT_HEAD(&proxy->free, msg, next);
> }
>
> @@ -383,6 +426,54 @@ 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;
> +
> + QEMU_LOCK_GUARD(&proxy->lock);
> +
> + if (proxy->state == VFIO_PROXY_CONNECTED) {
> + while (!QTAILQ_EMPTY(&proxy->outgoing)) {
> + if (vfio_user_send_one(proxy) < 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;
> +
> + msg = QTAILQ_FIRST(&proxy->outgoing);
> + 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);
> + msg->pending = true;
> + }
> +
> + return 0;
> +}
> +
> static void vfio_user_cb(void *opaque)
> {
> VFIOProxy *proxy = opaque;
> @@ -443,6 +534,134 @@ 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);
> + msg->pending = true;
> + }
> +
> + 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");
Shouldn't there be a vfio_user_set_error() call also ?
> + 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)) {
> + VFIOUserMsgQ *list;
> +
> + list = msg->pending ? &proxy->pending : &proxy->outgoing;
> + QTAILQ_REMOVE(list, 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);
>
> @@ -470,6 +689,15 @@ VFIOProxy *vfio_user_connect_dev(SocketAddress *addr, Error **errp)
> proxy = g_malloc0(sizeof(VFIOProxy));
> proxy->sockname = g_strdup_printf("unix:%s", sockname);
> proxy->ioc = ioc;
> +
> + /* init defaults */
> + proxy->max_xfer_size = VFIO_USER_DEF_MAX_XFER;
> + proxy->max_send_fds = VFIO_USER_DEF_MAX_FDS;
> + proxy->max_dma = VFIO_USER_DEF_MAP_MAX;
> + proxy->dma_pgsizes = VFIO_USER_DEF_PGSIZE;
> + proxy->max_bitmap = VFIO_USER_DEF_MAX_BITMAP;
> + proxy->migr_pgsize = VFIO_USER_DEF_PGSIZE;
> +
> proxy->flags = VFIO_PROXY_CLIENT;
> proxy->state = VFIO_PROXY_CONNECTED;
>
> @@ -567,3 +795,283 @@ 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)(VFIOProxy *proxy, QObject *qobj, Error **errp);
> +};
> +
> +static int caps_parse(VFIOProxy *proxy, 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(proxy, qobj, errp)) {
> + return -1;
> + }
> + qdict_del(qdict, p->name);
> + }
> + }
> +
> + /* warning, for now */
> + if (qdict_size(qdict) != 0) {
> + error_printf("spurious capabilities\n");
May be use warn_report() instead
> + }
> + return 0;
> +}
> +
> +static int check_migr_pgsize(VFIOProxy *proxy, 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;
> + }
> +
> + /* must be larger than default */
> + if (pgsize & (VFIO_USER_DEF_PGSIZE - 1)) {
> + error_setg(errp, "pgsize 0x%"PRIx64" too small", pgsize);
> + return -1;
> + }
> +
> + proxy->migr_pgsize = pgsize;
> + return 0;
> +}
> +
> +static int check_bitmap(VFIOProxy *proxy, QObject *qobj, Error **errp)
> +{
> + QNum *qn = qobject_to(QNum, qobj);
> + uint64_t bitmap_size;
> +
> + if (qn == NULL || !qnum_get_try_uint(qn, &bitmap_size)) {
> + error_setg(errp, "malformed %s", VFIO_USER_CAP_MAX_BITMAP);
> + return -1;
> + }
> +
> + /* can only lower it */
> + if (bitmap_size > VFIO_USER_DEF_MAX_BITMAP) {
> + error_setg(errp, "%s too large", VFIO_USER_CAP_MAX_BITMAP);
> + return -1;
> + }
> +
> + proxy->max_bitmap = bitmap_size;
> + return 0;
> +}
> +
> +static struct cap_entry caps_migr[] = {
> + { VFIO_USER_CAP_PGSIZE, check_migr_pgsize },
> + { VFIO_USER_CAP_MAX_BITMAP, check_bitmap },
> + { NULL }
> +};
> +
> +static int check_max_fds(VFIOProxy *proxy, QObject *qobj, Error **errp)
> +{
> + QNum *qn = qobject_to(QNum, qobj);
> + uint64_t max_send_fds;
> +
> + 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;
> + }
> + proxy->max_send_fds = max_send_fds;
> + return 0;
> +}
> +
> +static int check_max_xfer(VFIOProxy *proxy, QObject *qobj, Error **errp)
> +{
> + QNum *qn = qobject_to(QNum, qobj);
> + uint64_t max_xfer_size;
> +
> + 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;
> + }
> + proxy->max_xfer_size = max_xfer_size;
> + return 0;
> +}
> +
> +static int check_pgsizes(VFIOProxy *proxy, QObject *qobj, Error **errp)
> +{
> + QNum *qn = qobject_to(QNum, qobj);
> + uint64_t pgsizes;
> +
> + if (qn == NULL || !qnum_get_try_uint(qn, &pgsizes)) {
> + error_setg(errp, "malformed %s", VFIO_USER_CAP_PGSIZES);
> + return -1;
> + }
> +
> + /* must be larger than default */
> + if (pgsizes & (VFIO_USER_DEF_PGSIZE - 1)) {
> + error_setg(errp, "pgsize 0x%"PRIx64" too small", pgsizes);
> + return -1;
> + }
> +
> + proxy->dma_pgsizes = pgsizes;
> + return 0;
> +}
> +
> +static int check_max_dma(VFIOProxy *proxy, QObject *qobj, Error **errp)
> +{
> + QNum *qn = qobject_to(QNum, qobj);
> + uint64_t max_dma;
> +
> + if (qn == NULL || !qnum_get_try_uint(qn, &max_dma)) {
> + error_setg(errp, "malformed %s", VFIO_USER_CAP_MAP_MAX);
> + return -1;
> + }
> +
> + /* can only lower it */
> + if (max_dma > VFIO_USER_DEF_MAP_MAX) {
> + error_setg(errp, "%s too large", VFIO_USER_CAP_MAP_MAX);
> + return -1;
> + }
> +
> + proxy->max_dma = max_dma;
> + return 0;
> +}
> +
> +static int check_migr(VFIOProxy *proxy, 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(proxy, 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_PGSIZES, check_pgsizes },
> + { VFIO_USER_CAP_MAP_MAX, check_max_dma },
> + { VFIO_USER_CAP_MIGR, check_migr },
> + { NULL }
> +};
> +
> +static int check_cap(VFIOProxy *proxy, 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(proxy, qdict, caps_cap, errp);
> +}
> +
> +static struct cap_entry ver_0_0[] = {
> + { VFIO_USER_CAP, check_cap },
> + { NULL }
> +};
> +
> +static int caps_check(VFIOProxy *proxy, int minor, const char *caps,
what is the minor parameter for ?
Thanks,
C.
> + 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(proxy, 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, VFIO_USER_DEF_PGSIZE);
> + qdict_put_int(migdict, VFIO_USER_CAP_MAX_BITMAP, VFIO_USER_DEF_MAX_BITMAP);
> + 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);
> + qdict_put_int(capdict, VFIO_USER_CAP_PGSIZES, VFIO_USER_DEF_PGSIZE);
> + qdict_put_int(capdict, VFIO_USER_CAP_MAP_MAX, VFIO_USER_DEF_MAP_MAX);
> +
> + 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(VFIOProxy *proxy, 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(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(proxy, msgp->minor, reply, errp) != 0) {
> + return -1;
> + }
> +
> + return 0;
> +}
> diff --git a/hw/vfio/user.h b/hw/vfio/user.h
> index 68a1080..8ce3cd9 100644
> --- a/hw/vfio/user.h
> +++ b/hw/vfio/user.h
> @@ -35,6 +35,7 @@ typedef struct VFIOUserMsg {
> uint32_t id;
> QemuCond cv;
> bool complete;
> + bool pending;
> enum msg_type type;
> } VFIOUserMsg;
>
> @@ -54,6 +55,12 @@ typedef struct VFIOProxy {
> struct QIOChannel *ioc;
> void (*request)(void *opaque, VFIOUserMsg *msg);
> void *req_arg;
> + uint64_t max_xfer_size;
> + uint64_t max_send_fds;
> + uint64_t max_dma;
> + uint64_t dma_pgsizes;
> + uint64_t max_bitmap;
> + uint64_t migr_pgsize;
> int flags;
> QemuCond close_cv;
> AioContext *ctx;
> @@ -76,11 +83,13 @@ typedef struct VFIOProxy {
>
> /* VFIOProxy flags */
> #define VFIO_PROXY_CLIENT 0x1
> +#define VFIO_PROXY_FORCE_QUEUED 0x4
>
> 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);
> +int vfio_user_validate_version(VFIOProxy *proxy, Error **errp);
>
> #endif /* VFIO_USER_H */
^ permalink raw reply [flat|nested] 82+ messages in thread
* Re: [PATCH v1 10/24] vfio-user: get device info
2022-11-08 23:13 ` [PATCH v1 10/24] vfio-user: get device info John Johnson
2022-12-09 15:57 ` John Levon
@ 2022-12-13 14:06 ` Cédric Le Goater
1 sibling, 0 replies; 82+ messages in thread
From: Cédric Le Goater @ 2022-12-13 14:06 UTC (permalink / raw)
To: John Johnson, qemu-devel
On 11/9/22 00:13, John Johnson wrote:
> Signed-off-by: Elena Ufimtseva <elena.ufimtseva@oracle.com>
> Signed-off-by: John G Johnson <john.g.johnson@oracle.com>
> Signed-off-by: Jagannathan Raman <jag.raman@oracle.com>
> ---
> hw/vfio/pci.c | 15 ++++++++++++++
> hw/vfio/user-protocol.h | 13 ++++++++++++
> hw/vfio/user.c | 55 +++++++++++++++++++++++++++++++++++++++++++++++++
> hw/vfio/user.h | 2 ++
> 4 files changed, 85 insertions(+)
>
> diff --git a/hw/vfio/pci.c b/hw/vfio/pci.c
> index b2534b3..2e0e41d 100644
> --- a/hw/vfio/pci.c
> +++ b/hw/vfio/pci.c
> @@ -3465,6 +3465,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;
>
> /*
> @@ -3503,6 +3505,19 @@ static void vfio_user_pci_realize(PCIDevice *pdev, Error **errp)
> vbasedev->ops = &vfio_user_pci_ops;
> vbasedev->type = VFIO_DEVICE_TYPE_PCI;
> vbasedev->dev = DEVICE(vdev);
> + vbasedev->io_ops = &vfio_dev_io_sock;
> +
> + ret = VDEV_GET_INFO(vbasedev, &info);
We are dealing with a "vfio-user-pci" device since this is being
called from the realize handler.
Is it really useful to go through the ops abstraction layer here ?
Can't we simply call vfio_user_get_info() ? and propagate the
underlying Error while we're at it.
> + if (ret) {
> + error_setg_errno(errp, -ret, "get info failure");
> + goto error;
> + }
> +
> + vfio_populate_device(vdev, &err);
> + if (err) {
> + error_propagate(errp, err);
> + goto error;
> + }
>
> return;
>
> diff --git a/hw/vfio/user-protocol.h b/hw/vfio/user-protocol.h
> index 5de5b20..43912a5 100644
> --- a/hw/vfio/user-protocol.h
> +++ b/hw/vfio/user-protocol.h
> @@ -113,4 +113,17 @@ typedef struct {
> */
> #define VFIO_USER_DEF_MAX_BITMAP (256 * 1024 * 1024)
>
> +/*
> + * VFIO_USER_DEVICE_GET_INFO
> + * imported from struct_device_info
from struct vfio_device_info
Thanks,
C.
> + */
> +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 */
> diff --git a/hw/vfio/user.c b/hw/vfio/user.c
> index 31bcc93..7873534 100644
> --- a/hw/vfio/user.c
> +++ b/hw/vfio/user.c
> @@ -31,6 +31,14 @@
> #include "qapi/qmp/qbool.h"
> #include "user.h"
>
> +
> +/*
> + * These are to defend against a malign server trying
> + * to force us to run out of memory.
> + */
> +#define VFIO_USER_MAX_REGIONS 100
> +#define VFIO_USER_MAX_IRQS 50
> +
> static int wait_time = 5000; /* wait up to 5 sec for busy servers */
> static IOThread *vfio_user_iothread;
>
> @@ -1075,3 +1083,50 @@ int vfio_user_validate_version(VFIOProxy *proxy, Error **errp)
>
> return 0;
> }
> +
> +static int vfio_user_get_info(VFIOProxy *proxy, struct vfio_device_info *info)
> +{
> + VFIOUserDeviceInfo msg;
> +
> + memset(&msg, 0, sizeof(msg));
> + vfio_user_request_msg(&msg.hdr, VFIO_USER_DEVICE_GET_INFO, sizeof(msg), 0);
> + msg.argsz = sizeof(struct vfio_device_info);
> +
> + vfio_user_send_wait(proxy, &msg.hdr, NULL, 0, false);
> + if (msg.hdr.flags & VFIO_USER_ERROR) {
> + return -msg.hdr.error_reply;
> + }
> +
> + memcpy(info, &msg.argsz, sizeof(*info));
> + return 0;
> +}
> +
> +
> +/*
> + * Socket-based io_ops
> + */
> +
> +static int vfio_user_io_get_info(VFIODevice *vbasedev,
> + struct vfio_device_info *info)
> +{
> + int ret;
> +
> + ret = vfio_user_get_info(vbasedev->proxy, info);
> + if (ret) {
> + return ret;
> + }
> +
> + /* defend against a malicious server */
> + if (info->num_regions > VFIO_USER_MAX_REGIONS ||
> + info->num_irqs > VFIO_USER_MAX_IRQS) {
> + error_printf("vfio_user_get_info: invalid reply\n");
> + return -EINVAL;
> + }
> +
> + return 0;
> +}
> +
> +VFIODevIO vfio_dev_io_sock = {
> + .get_info = vfio_user_io_get_info,
> +};
> +
> diff --git a/hw/vfio/user.h b/hw/vfio/user.h
> index 8ce3cd9..2547cf6 100644
> --- a/hw/vfio/user.h
> +++ b/hw/vfio/user.h
> @@ -92,4 +92,6 @@ void vfio_user_set_handler(VFIODevice *vbasedev,
> void *reqarg);
> int vfio_user_validate_version(VFIOProxy *proxy, Error **errp);
>
> +extern VFIODevIO vfio_dev_io_sock;
> +
> #endif /* VFIO_USER_H */
^ permalink raw reply [flat|nested] 82+ messages in thread
* Re: [PATCH v1 11/24] vfio-user: get region info
2022-11-08 23:13 ` [PATCH v1 11/24] vfio-user: get region info John Johnson
2022-12-09 17:04 ` John Levon
@ 2022-12-13 15:15 ` Cédric Le Goater
1 sibling, 0 replies; 82+ messages in thread
From: Cédric Le Goater @ 2022-12-13 15:15 UTC (permalink / raw)
To: John Johnson, qemu-devel
On 11/9/22 00:13, John Johnson wrote:
> Add per-region FD to support mmap() of remote device regions
>
> Signed-off-by: Elena Ufimtseva <elena.ufimtseva@oracle.com>
> Signed-off-by: John G Johnson <john.g.johnson@oracle.com>
> Signed-off-by: Jagannathan Raman <jag.raman@oracle.com>
> ---
> hw/vfio/common.c | 32 ++++++++++++++++++++---
> hw/vfio/user-protocol.h | 14 ++++++++++
> hw/vfio/user.c | 59 +++++++++++++++++++++++++++++++++++++++++++
> include/hw/vfio/vfio-common.h | 8 +++---
> 4 files changed, 107 insertions(+), 6 deletions(-)
>
> diff --git a/hw/vfio/common.c b/hw/vfio/common.c
> index c589bd9..87400b3 100644
> --- a/hw/vfio/common.c
> +++ b/hw/vfio/common.c
> @@ -41,6 +41,7 @@
> #include "qapi/error.h"
> #include "migration/migration.h"
> #include "sysemu/tpm.h"
> +#include "hw/vfio/user.h"
>
> VFIOGroupList vfio_group_list =
> QLIST_HEAD_INITIALIZER(vfio_group_list);
> @@ -1586,6 +1587,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);
> @@ -1637,7 +1643,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) {
> @@ -2442,10 +2448,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) {
> @@ -2461,12 +2474,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) {
This looks like a shortcut. Could we introduce at least an inline helper
returning the need to allocate an fd per region ? It could use the same
kind of heuristic but it would be hidden under a helper.
> + vbasedev->regfds = g_new0(int, vbasedev->num_regions);
> + }
> }
> /* check cache */
> if (vbasedev->regions[index] != NULL) {
> @@ -2480,7 +2497,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;
> @@ -2490,12 +2507,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;
> }
> @@ -2655,10 +2679,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;
> diff --git a/hw/vfio/user-protocol.h b/hw/vfio/user-protocol.h
> index 43912a5..a1b64fe 100644
> --- a/hw/vfio/user-protocol.h
> +++ b/hw/vfio/user-protocol.h
> @@ -126,4 +126,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 */
> diff --git a/hw/vfio/user.c b/hw/vfio/user.c
> index 7873534..69b0fed 100644
> --- a/hw/vfio/user.c
> +++ b/hw/vfio/user.c
> @@ -1101,6 +1101,40 @@ static int vfio_user_get_info(VFIOProxy *proxy, struct vfio_device_info *info)
> return 0;
> }
>
> +static int vfio_user_get_region_info(VFIOProxy *proxy,
> + struct vfio_region_info *info,
> + VFIOUserFDs *fds)
> +{
> + g_autofree VFIOUserRegionInfo *msgp = NULL;
> + uint32_t size;
> +
> + /* data returned can be larger than vfio_region_info */
> + if (info->argsz < sizeof(*info)) {
> + error_printf("vfio_user_get_region_info argsz too small\n");
It would be nice to report the errors at the upper layer and remove all
the error_printf(). Since it seems too difficult in this case, may be
return -E2BIG.
Thanks,
C.
> + return -EINVAL;
> + }
> + if (fds != NULL && fds->send_fds != 0) {
> + error_printf("vfio_user_get_region_info can't send FDs\n");
> + return -EINVAL;
> + }
> +
> + size = info->argsz + sizeof(VFIOUserHdr);
> + msgp = g_malloc0(size);
> +
> + vfio_user_request_msg(&msgp->hdr, VFIO_USER_DEVICE_GET_REGION_INFO,
> + sizeof(*msgp), 0);
> + msgp->argsz = info->argsz;
> + msgp->index = info->index;
> +
> + vfio_user_send_wait(proxy, &msgp->hdr, fds, size, false);
> + if (msgp->hdr.flags & VFIO_USER_ERROR) {
> + return -msgp->hdr.error_reply;
> + }
> +
> + memcpy(info, &msgp->argsz, info->argsz);
> + return 0;
> +}
> +
>
> /*
> * Socket-based io_ops
> @@ -1126,7 +1160,32 @@ static int vfio_user_io_get_info(VFIODevice *vbasedev,
> return 0;
> }
>
> +static int vfio_user_io_get_region_info(VFIODevice *vbasedev,
> + struct vfio_region_info *info,
> + int *fd)
> +{
> + int ret;
> + VFIOUserFDs fds = { 0, 1, fd};
> +
> + ret = vfio_user_get_region_info(vbasedev->proxy, info, &fds);
> + if (ret) {
> + return ret;
> + }
> +
> + if (info->index > vbasedev->num_regions) {
> + return -EINVAL;
> + }
> + /* cap_offset in valid area */
> + if ((info->flags & VFIO_REGION_INFO_FLAG_CAPS) &&
> + (info->cap_offset < sizeof(*info) || info->cap_offset > info->argsz)) {
> + return -EINVAL;
> + }
> +
> + return 0;
> +}
> +
> VFIODevIO vfio_dev_io_sock = {
> .get_info = vfio_user_io_get_info,
> + .get_region_info = vfio_user_io_get_region_info,
> };
>
> diff --git a/include/hw/vfio/vfio-common.h b/include/hw/vfio/vfio-common.h
> index fb7d865..3406e6a 100644
> --- a/include/hw/vfio/vfio-common.h
> +++ b/include/hw/vfio/vfio-common.h
> @@ -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) \
^ permalink raw reply [flat|nested] 82+ messages in thread
* Re: [PATCH v1 12/24] vfio-user: region read/write
2022-11-08 23:13 ` [PATCH v1 12/24] vfio-user: region read/write John Johnson
2022-12-09 17:11 ` John Levon
@ 2022-12-13 16:13 ` Cédric Le Goater
1 sibling, 0 replies; 82+ messages in thread
From: Cédric Le Goater @ 2022-12-13 16:13 UTC (permalink / raw)
To: John Johnson, qemu-devel
On 11/9/22 00:13, John Johnson wrote:
> Add support for posted writes on remote devices
>
> Signed-off-by: Elena Ufimtseva <elena.ufimtseva@oracle.com>
> Signed-off-by: John G Johnson <john.g.johnson@oracle.com>
> Signed-off-by: Jagannathan Raman <jag.raman@oracle.com>
Reviewed-by: Cédric Le Goater <clg@redhat.com>
Thanks,
C.
> ---
> hw/vfio/common.c | 10 +++-
> hw/vfio/pci.c | 9 +++-
> hw/vfio/pci.h | 1 +
> hw/vfio/user-protocol.h | 12 +++++
> hw/vfio/user.c | 109 ++++++++++++++++++++++++++++++++++++++++++
> hw/vfio/user.h | 1 +
> include/hw/vfio/vfio-common.h | 7 +--
> 7 files changed, 143 insertions(+), 6 deletions(-)
>
> diff --git a/hw/vfio/common.c b/hw/vfio/common.c
> index 87400b3..87cd1d1 100644
> --- a/hw/vfio/common.c
> +++ b/hw/vfio/common.c
> @@ -214,6 +214,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) {
> @@ -234,7 +235,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";
>
> @@ -1587,6 +1592,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 {
> @@ -2721,7 +2727,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;
> diff --git a/hw/vfio/pci.c b/hw/vfio/pci.c
> index 2e0e41d..027f9d5 100644
> --- a/hw/vfio/pci.c
> +++ b/hw/vfio/pci.c
> @@ -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"
>
> @@ -1704,6 +1704,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)
> @@ -3494,6 +3497,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(proxy, &err);
> if (err != NULL) {
> @@ -3540,6 +3546,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(),
> };
>
> diff --git a/hw/vfio/pci.h b/hw/vfio/pci.h
> index c47d2f8..ec17f2e 100644
> --- a/hw/vfio/pci.h
> +++ b/hw/vfio/pci.h
> @@ -196,6 +196,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 */
> diff --git a/hw/vfio/user-protocol.h b/hw/vfio/user-protocol.h
> index a1b64fe..124340c 100644
> --- a/hw/vfio/user-protocol.h
> +++ b/hw/vfio/user-protocol.h
> @@ -140,4 +140,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 */
> diff --git a/hw/vfio/user.c b/hw/vfio/user.c
> index 69b0fed..1453bb5 100644
> --- a/hw/vfio/user.c
> +++ b/hw/vfio/user.c
> @@ -57,6 +57,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,
> @@ -618,6 +620,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)
> {
> @@ -1135,6 +1164,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 > proxy->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 > proxy->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-based io_ops
> @@ -1184,8 +1277,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,
> };
>
> diff --git a/hw/vfio/user.h b/hw/vfio/user.h
> index 2547cf6..359a029 100644
> --- a/hw/vfio/user.h
> +++ b/hw/vfio/user.h
> @@ -84,6 +84,7 @@ typedef struct VFIOProxy {
> /* VFIOProxy flags */
> #define VFIO_PROXY_CLIENT 0x1
> #define VFIO_PROXY_FORCE_QUEUED 0x4
> +#define VFIO_PROXY_NO_POST 0x8
>
> VFIOProxy *vfio_user_connect_dev(SocketAddress *addr, Error **errp);
> void vfio_user_disconnect(VFIOProxy *proxy);
> diff --git a/include/hw/vfio/vfio-common.h b/include/hw/vfio/vfio-common.h
> index 3406e6a..6324132 100644
> --- a/include/hw/vfio/vfio-common.h
> +++ b/include/hw/vfio/vfio-common.h
> @@ -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,
^ permalink raw reply [flat|nested] 82+ messages in thread
* Re: [PATCH v1 13/24] vfio-user: pci_user_realize PCI setup
2022-11-08 23:13 ` [PATCH v1 13/24] vfio-user: pci_user_realize PCI setup John Johnson
2022-12-09 17:22 ` John Levon
@ 2022-12-13 16:13 ` Cédric Le Goater
1 sibling, 0 replies; 82+ messages in thread
From: Cédric Le Goater @ 2022-12-13 16:13 UTC (permalink / raw)
To: John Johnson, qemu-devel
On 11/9/22 00:13, John Johnson wrote:
> PCI BARs read from remote device
> PCI config reads/writes sent to remote server
>
> Signed-off-by: Elena Ufimtseva <elena.ufimtseva@oracle.com>
> Signed-off-by: John G Johnson <john.g.johnson@oracle.com>
> Signed-off-by: Jagannathan Raman <jag.raman@oracle.com>
Reviewed-by: Cédric Le Goater <clg@redhat.com>
Thanks,
C.
> ---
> hw/vfio/pci.c | 277 ++++++++++++++++++++++++++++++++++++----------------------
> 1 file changed, 174 insertions(+), 103 deletions(-)
>
> diff --git a/hw/vfio/pci.c b/hw/vfio/pci.c
> index 027f9d5..7abe44e 100644
> --- a/hw/vfio/pci.c
> +++ b/hw/vfio/pci.c
> @@ -2874,6 +2874,133 @@ 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;
> + VFIODevice *vbasedev = &vdev->vbasedev;
> + 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(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(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(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);
> @@ -2990,92 +3117,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(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(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(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(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) {
> @@ -3116,29 +3167,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);
> @@ -3525,8 +3562,42 @@ 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) {
> + error_propagate(errp, 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:
> error_prepend(errp, VFIO_MSG_PREFIX, vdev->vbasedev.name);
> }
^ permalink raw reply [flat|nested] 82+ messages in thread
* Re: [PATCH v1 14/24] vfio-user: get and set IRQs
2022-11-08 23:13 ` [PATCH v1 14/24] vfio-user: get and set IRQs John Johnson
2022-12-09 17:29 ` John Levon
@ 2022-12-13 16:39 ` Cédric Le Goater
2022-12-13 23:10 ` John Johnson
2023-02-02 5:21 ` John Johnson
1 sibling, 2 replies; 82+ messages in thread
From: Cédric Le Goater @ 2022-12-13 16:39 UTC (permalink / raw)
To: John Johnson, qemu-devel
On 11/9/22 00:13, John Johnson wrote:
> Signed-off-by: Elena Ufimtseva <elena.ufimtseva@oracle.com>
> Signed-off-by: John G Johnson <john.g.johnson@oracle.com>
> Signed-off-by: Jagannathan Raman <jag.raman@oracle.com>
> ---
> hw/vfio/pci.c | 7 ++-
> hw/vfio/user-protocol.h | 25 +++++++++
> hw/vfio/user.c | 135 ++++++++++++++++++++++++++++++++++++++++++++++++
> 3 files changed, 166 insertions(+), 1 deletion(-)
>
> diff --git a/hw/vfio/pci.c b/hw/vfio/pci.c
> index 7abe44e..be39a4e 100644
> --- a/hw/vfio/pci.c
> +++ b/hw/vfio/pci.c
> @@ -713,7 +713,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));
This change belongs to another patch.
> } else {
> error_report("vfio: Error: Failed to enable %d "
> "MSI vectors, retry with %d", vdev->nr_vectors, ret);
> @@ -2712,6 +2713,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));
> @@ -3593,6 +3595,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:
> diff --git a/hw/vfio/user-protocol.h b/hw/vfio/user-protocol.h
> index 124340c..31704cf 100644
> --- a/hw/vfio/user-protocol.h
> +++ b/hw/vfio/user-protocol.h
> @@ -141,6 +141,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
> */
> diff --git a/hw/vfio/user.c b/hw/vfio/user.c
> index 1453bb5..815385b 100644
> --- a/hw/vfio/user.c
> +++ b/hw/vfio/user.c
> @@ -1164,6 +1164,117 @@ static int vfio_user_get_region_info(VFIOProxy *proxy,
> return 0;
> }
>
> +static int vfio_user_get_irq_info(VFIOProxy *proxy,
> + struct vfio_irq_info *info)
> +{
> + VFIOUserIRQInfo msg;
> +
> + memset(&msg, 0, sizeof(msg));
> + vfio_user_request_msg(&msg.hdr, VFIO_USER_DEVICE_GET_IRQ_INFO,
> + sizeof(msg), 0);
> + msg.argsz = info->argsz;
> + msg.index = info->index;
> +
> + vfio_user_send_wait(proxy, &msg.hdr, NULL, 0, false);
> + if (msg.hdr.flags & VFIO_USER_ERROR) {
> + return -msg.hdr.error_reply;
> + }
> +
> + memcpy(info, &msg.argsz, sizeof(*info));
> + return 0;
> +}
> +
> +static int irq_howmany(int *fdp, uint32_t cur, uint32_t max)
intriguing routine. See comment below.
> +{
> + int n = 0;
> +
> + if (fdp[cur] != -1) {
> + do {
> + n++;
> + } while (n < max && fdp[cur + n] != -1);
> + } else {
> + do {
> + n++;
> + } while (n < max && fdp[cur + n] == -1);
> + }
> +
> + return n;
> +}
> +
> +static int vfio_user_set_irqs(VFIOProxy *proxy, struct vfio_irq_set *irq)
> +{
> + g_autofree VFIOUserIRQSet *msgp = NULL;
> + uint32_t size, nfds, send_fds, sent_fds, max;
> +
> + if (irq->argsz < sizeof(*irq)) {
> + error_printf("vfio_user_set_irqs argsz too small\n");
> + return -EINVAL;
> + }
> +
> + /*
> + * Handle simple case
> + */
> + if ((irq->flags & VFIO_IRQ_SET_DATA_EVENTFD) == 0) {
> + size = sizeof(VFIOUserHdr) + irq->argsz;
> + msgp = g_malloc0(size);
> +
> + vfio_user_request_msg(&msgp->hdr, VFIO_USER_DEVICE_SET_IRQS, size, 0);
> + msgp->argsz = irq->argsz;
> + msgp->flags = irq->flags;
> + msgp->index = irq->index;
> + msgp->start = irq->start;
> + msgp->count = irq->count;
> +
> + vfio_user_send_wait(proxy, &msgp->hdr, NULL, 0, false);
> + if (msgp->hdr.flags & VFIO_USER_ERROR) {
> + return -msgp->hdr.error_reply;
> + }
> +
> + return 0;
> + }
> +
> + /*
> + * Calculate the number of FDs to send
> + * and adjust argsz
> + */
> + nfds = (irq->argsz - sizeof(*irq)) / sizeof(int);
> + irq->argsz = sizeof(*irq);
> + msgp = g_malloc0(sizeof(*msgp));
> + /*
> + * Send in chunks if over max_send_fds
> + */
> + for (sent_fds = 0; nfds > sent_fds; sent_fds += send_fds) {
> + VFIOUserFDs *arg_fds, loop_fds;
> +
> + /* must send all valid FDs or all invalid FDs in single msg */
why is that ?
> + max = nfds - sent_fds;
> + if (max > proxy->max_send_fds) {
> + max = proxy->max_send_fds;
> + }
> + send_fds = irq_howmany((int *)irq->data, sent_fds, max);
sent_fds can never be -1 but irq_howmany() is taking into account this
value. Why ?
> +
> + vfio_user_request_msg(&msgp->hdr, VFIO_USER_DEVICE_SET_IRQS,
> + sizeof(*msgp), 0);
> + msgp->argsz = irq->argsz;
> + msgp->flags = irq->flags;
> + msgp->index = irq->index;
> + msgp->start = irq->start + sent_fds;
> + msgp->count = send_fds;
> +
> + loop_fds.send_fds = send_fds;
> + loop_fds.recv_fds = 0;
> + loop_fds.fds = (int *)irq->data + sent_fds;
> + arg_fds = loop_fds.fds[0] != -1 ? &loop_fds : NULL;
> +
> + vfio_user_send_wait(proxy, &msgp->hdr, arg_fds, 0, false);
> + if (msgp->hdr.flags & VFIO_USER_ERROR) {
> + return -msgp->hdr.error_reply;
> + }
> + }
> +
> + return 0;
> +}
> +
> static int vfio_user_region_read(VFIOProxy *proxy, uint8_t index, off_t offset,
> uint32_t count, void *data)
> {
> @@ -1277,6 +1388,28 @@ static int vfio_user_io_get_region_info(VFIODevice *vbasedev,
> return 0;
> }
>
> +static int vfio_user_io_get_irq_info(VFIODevice *vbasedev,
> + struct vfio_irq_info *irq)
> +{
> + int ret;
> +
> + ret = vfio_user_get_irq_info(vbasedev->proxy, irq);
> + if (ret) {
> + return ret;
> + }
> +
> + if (irq->index > vbasedev->num_irqs) {
> + return -EINVAL;
> + }
> + return 0;
> +}
> +
> +static int vfio_user_io_set_irqs(VFIODevice *vbasedev,
> + struct vfio_irq_set *irqs)
> +{
> + return vfio_user_set_irqs(vbasedev->proxy, irqs);
> +}
> +
> static int vfio_user_io_region_read(VFIODevice *vbasedev, uint8_t index,
> off_t off, uint32_t size, void *data)
> {
> @@ -1294,6 +1427,8 @@ static int vfio_user_io_region_write(VFIODevice *vbasedev, uint8_t index,
> VFIODevIO vfio_dev_io_sock = {
> .get_info = vfio_user_io_get_info,
> .get_region_info = vfio_user_io_get_region_info,
> + .get_irq_info = vfio_user_io_get_irq_info,
> + .set_irqs = vfio_user_io_set_irqs,
> .region_read = vfio_user_io_region_read,
> .region_write = vfio_user_io_region_write,
> };
^ permalink raw reply [flat|nested] 82+ messages in thread
* Re: [PATCH v1 14/24] vfio-user: get and set IRQs
2022-12-13 16:39 ` Cédric Le Goater
@ 2022-12-13 23:10 ` John Johnson
2023-02-02 5:21 ` John Johnson
1 sibling, 0 replies; 82+ messages in thread
From: John Johnson @ 2022-12-13 23:10 UTC (permalink / raw)
To: Cédric Le Goater; +Cc: qemu-devel
> On Dec 13, 2022, at 8:39 AM, Cédric Le Goater <clg@redhat.com> wrote:
>
> On 11/9/22 00:13, John Johnson wrote:
>>
>> +
>> + /* must send all valid FDs or all invalid FDs in single msg */
>
> why is that ?
>
This has to do with how VFIO sends FDs to the kernel. The
ioctl() i/f has an array of FDs, with -1 signifying an invalid one.
FDs can only be sent over a UNIX socket as a single array of them
(all must be valid, no -1 holes in the array).
In order to emulate the ioctl() use, we’d need to send an
ancillary array to map the ordinal index of irq_data to the ordinal
index of the FDs in the message. Since multi-FD sends are only done
at device set-up, it seemed simpler to just break them up.
JJ
^ permalink raw reply [flat|nested] 82+ messages in thread
* Re: [PATCH v1 15/24] vfio-user: forward msix BAR accesses to server
2022-11-08 23:13 ` [PATCH v1 15/24] vfio-user: forward msix BAR accesses to server John Johnson
2022-12-09 17:45 ` John Levon
@ 2022-12-14 17:00 ` Cédric Le Goater
1 sibling, 0 replies; 82+ messages in thread
From: Cédric Le Goater @ 2022-12-14 17:00 UTC (permalink / raw)
To: John Johnson, qemu-devel
On 11/9/22 00:13, John Johnson wrote:
> Server holds device current device pending state
> Use irq masking commands in socket case
>
> Signed-off-by: John G Johnson <john.g.johnson@oracle.com>
> Signed-off-by: Elena Ufimtseva <elena.ufimtseva@oracle.com>
> Signed-off-by: Jagannathan Raman <jag.raman@oracle.com>
May be use 'can_mask_irq' instead of 'irq_mask_works'
Reviewed-by: Cédric Le Goater <clg@kaod.org>
Thanks,
C.
One typo below,
> ---
> hw/vfio/ccw.c | 1 +
> hw/vfio/common.c | 26 +++++++++++++
> hw/vfio/pci.c | 87 ++++++++++++++++++++++++++++++++++++++++++-
> hw/vfio/pci.h | 1 +
> hw/vfio/platform.c | 1 +
> include/hw/vfio/vfio-common.h | 3 ++
> 6 files changed, 118 insertions(+), 1 deletion(-)
>
> diff --git a/hw/vfio/ccw.c b/hw/vfio/ccw.c
> index cbd1c25..830ca53 100644
> --- a/hw/vfio/ccw.c
> +++ b/hw/vfio/ccw.c
> @@ -615,6 +615,7 @@ static void vfio_ccw_get_device(VFIOGroup *group, VFIOCCWDevice *vcdev,
> vcdev->vdev.name = name;
> vcdev->vdev.dev = &vcdev->cdev.parent_obj.parent_obj;
> vcdev->vdev.io_ops = &vfio_dev_io_ioctl;
> + vcdev->vdev.irq_mask_works = false;
>
> return;
>
> diff --git a/hw/vfio/common.c b/hw/vfio/common.c
> index 87cd1d1..b540195 100644
> --- a/hw/vfio/common.c
> +++ b/hw/vfio/common.c
> @@ -101,6 +101,32 @@ void vfio_mask_single_irqindex(VFIODevice *vbasedev, int index)
> VDEV_SET_IRQS(vbasedev, &irq_set);
> }
>
> +void vfio_mask_single_irq(VFIODevice *vbasedev, int index, int irq)
> +{
> + struct vfio_irq_set irq_set = {
> + .argsz = sizeof(irq_set),
> + .flags = VFIO_IRQ_SET_DATA_NONE | VFIO_IRQ_SET_ACTION_MASK,
> + .index = index,
> + .start = irq,
> + .count = 1,
> + };
> +
> + VDEV_SET_IRQS(vbasedev, &irq_set);
> +}
> +
> +void vfio_unmask_single_irq(VFIODevice *vbasedev, int index, int irq)
> +{
> + struct vfio_irq_set irq_set = {
> + .argsz = sizeof(irq_set),
> + .flags = VFIO_IRQ_SET_DATA_NONE | VFIO_IRQ_SET_ACTION_UNMASK,
> + .index = index,
> + .start = irq,
> + .count = 1,
> + };
> +
> + VDEV_SET_IRQS(vbasedev, &irq_set);
> +}
> +
> static inline const char *action_to_str(int action)
> {
> switch (action) {
> diff --git a/hw/vfio/pci.c b/hw/vfio/pci.c
> index be39a4e..a1ae3fb 100644
> --- a/hw/vfio/pci.c
> +++ b/hw/vfio/pci.c
> @@ -479,6 +479,7 @@ static int vfio_msix_vector_do_use(PCIDevice *pdev, unsigned int nr,
> {
> VFIOPCIDevice *vdev = VFIO_PCI_BASE(pdev);
> VFIOMSIVector *vector;
> + bool new_vec = false;
> int ret;
>
> trace_vfio_msix_vector_do_use(vdev->vbasedev.name, nr);
> @@ -492,6 +493,7 @@ static int vfio_msix_vector_do_use(PCIDevice *pdev, unsigned int nr,
> error_report("vfio: Error: event_notifier_init failed");
> }
> vector->use = true;
> + new_vec = true;
> msix_vector_use(pdev, nr);
> }
>
> @@ -518,6 +520,7 @@ static int vfio_msix_vector_do_use(PCIDevice *pdev, unsigned int nr,
> kvm_irqchip_commit_route_changes(&vfio_route_change);
> vfio_connect_kvm_msi_virq(vector);
> }
> + new_vec = true;
> }
> }
>
> @@ -525,6 +528,8 @@ static int vfio_msix_vector_do_use(PCIDevice *pdev, unsigned int nr,
> * We don't want to have the host allocate all possible MSI vectors
> * for a device if they're not in use, so we shutdown and incrementally
> * increase them as needed.
> + * Otherwise, unmask the vector if the vector is already setup (and we can
> + * do so) or send the fd if not.
> */
> if (vdev->nr_vectors < nr + 1) {
> vdev->nr_vectors = nr + 1;
> @@ -535,6 +540,8 @@ static int vfio_msix_vector_do_use(PCIDevice *pdev, unsigned int nr,
> error_report("vfio: failed to enable vectors, %d", ret);
> }
> }
> + } else if (vdev->vbasedev.irq_mask_works && !new_vec) {
> + vfio_unmask_single_irq(&vdev->vbasedev, VFIO_PCI_MSIX_IRQ_INDEX, nr);
> } else {
> Error *err = NULL;
> int32_t fd;
> @@ -576,6 +583,12 @@ static void vfio_msix_vector_release(PCIDevice *pdev, unsigned int nr)
>
> trace_vfio_msix_vector_release(vdev->vbasedev.name, nr);
>
> + /* just mask vector if peer supports it */
> + if (vdev->vbasedev.irq_mask_works) {
> + vfio_mask_single_irq(&vdev->vbasedev, VFIO_PCI_MSIX_IRQ_INDEX, nr);
> + return;
> + }
> +
> /*
> * There are still old guests that mask and unmask vectors on every
> * interrupt. If we're using QEMU bypass with a KVM irqfd, leave all of
> @@ -646,7 +659,7 @@ static void vfio_msix_enable(VFIOPCIDevice *vdev)
> if (ret) {
> error_report("vfio: failed to enable vectors, %d", ret);
> }
> - } else {
> + } else if (!vdev->vbasedev.irq_mask_works) {
> /*
> * Some communication channels between VF & PF or PF & fw rely on the
> * physical state of the device and expect that enabling MSI-X from the
> @@ -662,6 +675,13 @@ static void vfio_msix_enable(VFIOPCIDevice *vdev)
> */
> vfio_msix_vector_do_use(&vdev->pdev, 0, NULL, NULL);
> vfio_msix_vector_release(&vdev->pdev, 0);
> + } else {
> + /*
> + * If we can use irq masking, send an invalid fd on vector 0
> + * to enable MSI-X without any vectors enabled.
> + */
> + vfio_set_irq_signaling(&vdev->vbasedev, VFIO_PCI_MSIX_IRQ_INDEX, 0,
> + VFIO_IRQ_SET_ACTION_TRIGGER, -1, NULL);
> }
>
> trace_vfio_msix_enable(vdev->vbasedev.name);
> @@ -3042,6 +3062,7 @@ static void vfio_realize(PCIDevice *pdev, Error **errp)
> vbasedev->type = VFIO_DEVICE_TYPE_PCI;
> vbasedev->dev = DEVICE(vdev);
> vbasedev->io_ops = &vfio_dev_io_ioctl;
> + vbasedev->irq_mask_works = false;
>
> tmp = g_strdup_printf("%s/iommu_group", vbasedev->sysfsdev);
> len = readlink(tmp, group_path, sizeof(group_path));
> @@ -3474,6 +3495,62 @@ type_init(register_vfio_pci_dev_type)
> */
>
> /*
> + * The server maintains the device's pending interrupts,
> + * via its MSIX table and PBA, so we treat these acceses
'accesses'
> + * like PCI config space and forward them.
> + */
> +static uint64_t vfio_user_pba_read(void *opaque, hwaddr addr,
> + unsigned size)
> +{
> + VFIOPCIDevice *vdev = opaque;
> + VFIORegion *region = &vdev->bars[vdev->msix->pba_bar].region;
> + uint64_t data;
> +
> + /* server copy is what matters */
> + data = vfio_region_read(region, addr + vdev->msix->pba_offset, size);
> + return data;
> +}
> +
> +static void vfio_user_pba_write(void *opaque, hwaddr addr,
> + uint64_t data, unsigned size)
> +{
> + /* dropped */
> +}
> +
> +static const MemoryRegionOps vfio_user_pba_ops = {
> + .read = vfio_user_pba_read,
> + .write = vfio_user_pba_write,
> + .endianness = DEVICE_LITTLE_ENDIAN,
> +};
> +
> +static void vfio_user_msix_setup(VFIOPCIDevice *vdev)
> +{
> + MemoryRegion *vfio_reg, *msix_reg, *pba_reg;
> +
> + pba_reg = g_new0(MemoryRegion, 1);
> + vdev->msix->pba_region = pba_reg;
> +
> + vfio_reg = vdev->bars[vdev->msix->pba_bar].mr;
> + msix_reg = &vdev->pdev.msix_pba_mmio;
> + memory_region_init_io(pba_reg, OBJECT(vdev), &vfio_user_pba_ops, vdev,
> + "VFIO MSIX PBA", int128_get64(msix_reg->size));
> + memory_region_add_subregion_overlap(vfio_reg, vdev->msix->pba_offset,
> + pba_reg, 1);
> +}
> +
> +static void vfio_user_msix_teardown(VFIOPCIDevice *vdev)
> +{
> + MemoryRegion *mr, *sub;
> +
> + mr = vdev->bars[vdev->msix->pba_bar].mr;
> + sub = vdev->msix->pba_region;
> + memory_region_del_subregion(mr, sub);
> +
> + g_free(vdev->msix->pba_region);
> + vdev->msix->pba_region = NULL;
> +}
> +
> +/*
> * Incoming request message callback.
> *
> * Runs off main loop, so BQL held.
> @@ -3551,6 +3628,7 @@ static void vfio_user_pci_realize(PCIDevice *pdev, Error **errp)
> vbasedev->type = VFIO_DEVICE_TYPE_PCI;
> vbasedev->dev = DEVICE(vdev);
> vbasedev->io_ops = &vfio_dev_io_sock;
> + vdev->vbasedev.irq_mask_works = true;
>
> ret = VDEV_GET_INFO(vbasedev, &info);
> if (ret) {
> @@ -3589,6 +3667,9 @@ static void vfio_user_pci_realize(PCIDevice *pdev, Error **errp)
> if (ret) {
> goto out_teardown;
> }
> + if (vdev->msix != NULL) {
> + vfio_user_msix_setup(vdev);
> + }
>
> ret = vfio_interrupt_setup(vdev, errp);
> if (ret) {
> @@ -3612,6 +3693,10 @@ static void vfio_user_instance_finalize(Object *obj)
> VFIOPCIDevice *vdev = VFIO_PCI_BASE(obj);
> VFIODevice *vbasedev = &vdev->vbasedev;
>
> + if (vdev->msix != NULL) {
> + vfio_user_msix_teardown(vdev);
> + }
> +
> vfio_put_device(vdev);
>
> if (vbasedev->proxy != NULL) {
> diff --git a/hw/vfio/pci.h b/hw/vfio/pci.h
> index ec17f2e..c04fa58 100644
> --- a/hw/vfio/pci.h
> +++ b/hw/vfio/pci.h
> @@ -113,6 +113,7 @@ typedef struct VFIOMSIXInfo {
> uint32_t table_offset;
> uint32_t pba_offset;
> unsigned long *pending;
> + MemoryRegion *pba_region;
> } VFIOMSIXInfo;
>
> /*
> diff --git a/hw/vfio/platform.c b/hw/vfio/platform.c
> index c136b09..ccf1df7 100644
> --- a/hw/vfio/platform.c
> +++ b/hw/vfio/platform.c
> @@ -622,6 +622,7 @@ static void vfio_platform_realize(DeviceState *dev, Error **errp)
> vbasedev->dev = dev;
> vbasedev->ops = &vfio_platform_ops;
> vbasedev->io_ops = &vfio_dev_io_ioctl;
> + vbasedev->irq_mask_works = false;
>
> qemu_mutex_init(&vdev->intp_mutex);
>
> diff --git a/include/hw/vfio/vfio-common.h b/include/hw/vfio/vfio-common.h
> index 6324132..793ca94 100644
> --- a/include/hw/vfio/vfio-common.h
> +++ b/include/hw/vfio/vfio-common.h
> @@ -142,6 +142,7 @@ typedef struct VFIODevice {
> bool no_mmap;
> bool ram_block_discard_allowed;
> bool enable_migration;
> + bool irq_mask_works;
> VFIODeviceOps *ops;
> VFIODevIO *io_ops;
> unsigned int num_irqs;
> @@ -260,6 +261,8 @@ void vfio_put_base_device(VFIODevice *vbasedev);
> void vfio_disable_irqindex(VFIODevice *vbasedev, int index);
> void vfio_unmask_single_irqindex(VFIODevice *vbasedev, int index);
> void vfio_mask_single_irqindex(VFIODevice *vbasedev, int index);
> +void vfio_unmask_single_irq(VFIODevice *vbasedev, int index, int irq);
> +void vfio_mask_single_irq(VFIODevice *vbasedev, int index, int irq);
> int vfio_set_irq_signaling(VFIODevice *vbasedev, int index, int subindex,
> int action, int fd, Error **errp);
> void vfio_region_write(void *opaque, hwaddr addr,
^ permalink raw reply [flat|nested] 82+ messages in thread
* Re: [PATCH v1 16/24] vfio-user: proxy container connect/disconnect
2022-11-08 23:13 ` [PATCH v1 16/24] vfio-user: proxy container connect/disconnect John Johnson
2022-12-09 17:54 ` John Levon
@ 2022-12-14 17:59 ` Cédric Le Goater
1 sibling, 0 replies; 82+ messages in thread
From: Cédric Le Goater @ 2022-12-14 17:59 UTC (permalink / raw)
To: John Johnson, qemu-devel
On 11/9/22 00:13, John Johnson wrote:
> Signed-off-by: Elena Ufimtseva <elena.ufimtseva@oracle.com>
> Signed-off-by: John G Johnson <john.g.johnson@oracle.com>
> Signed-off-by: Jagannathan Raman <jag.raman@oracle.com>
> ---
> hw/vfio/common.c | 207 +++++++++++++++++++++++++++++++++++++++++-
> hw/vfio/pci.c | 18 +++-
> hw/vfio/user.c | 3 +
> hw/vfio/user.h | 1 +
> include/hw/vfio/vfio-common.h | 6 ++
> 5 files changed, 231 insertions(+), 4 deletions(-)
>
> diff --git a/hw/vfio/common.c b/hw/vfio/common.c
> index b540195..e73a772 100644
> --- a/hw/vfio/common.c
> +++ b/hw/vfio/common.c
> @@ -19,6 +19,7 @@
> */
>
> #include "qemu/osdep.h"
> +#include CONFIG_DEVICES
> #include <sys/ioctl.h>
> #ifdef CONFIG_KVM
> #include <linux/kvm.h>
> @@ -2267,6 +2268,208 @@ put_space_exit:
> return ret;
> }
>
> +
> +#ifdef CONFIG_VFIO_USER
this code belongs to hw/vfio/user.c. You will need to export the required
vfio subroutines for it.
> +
> +static int vfio_connect_proxy(VFIOProxy *proxy, VFIOGroup *group,
> + AddressSpace *as, Error **errp)
> +{
> + VFIOAddressSpace *space;
> + VFIOContainer *container;
> + int ret;
> +
> + /*
> + * try to mirror vfio_connect_container()
> + * as much as possible
> + */
Yes. This is very much like the VFIO_TYPE1_IOMMU case.
Could we wrap the vfio_get_iommu_info() routine in some way to bring it
even close ? to avoid all this code duplication.
> +
> + space = vfio_get_address_space(as);
> +
> + container = g_malloc0(sizeof(*container));
> + container->space = space;
> + container->fd = -1;
> + container->error = NULL;
> + container->io_ops = &vfio_cont_io_sock;
> + QLIST_INIT(&container->giommu_list);
> + QLIST_INIT(&container->hostwin_list);
> + QLIST_INIT(&container->vrdl_list);
> + container->proxy = proxy;
> +
> + /*
> + * The proxy uses a SW IOMMU in lieu of the HW one
> + * used in the ioctl() version. Mascarade as TYPE1
> + * for maximum capatibility
> + */
> + container->iommu_type = VFIO_TYPE1_IOMMU;
> +
> + /*
> + * VFIO user allows the device server to map guest
> + * memory so it has the same issue with discards as
> + * a local IOMMU has.
> + */
> + ret = vfio_ram_block_discard_disable(container, true);
> + if (ret) {
> + error_setg_errno(errp, -ret, "Cannot set discarding of RAM broken");
> + goto free_container_exit;
> + }
> +
> + vfio_host_win_add(container, 0, (hwaddr)-1, proxy->dma_pgsizes);
> + container->pgsizes = proxy->dma_pgsizes;
> + container->dma_max_mappings = proxy->max_dma;
> +
> + /* setup bitmask now, but migration support won't be ready until v2 */
> + container->dirty_pages_supported = true;
> + container->max_dirty_bitmap_size = proxy->max_bitmap;
> + container->dirty_pgsizes = proxy->migr_pgsize;
> +
> + QLIST_INIT(&container->group_list);
> + QLIST_INSERT_HEAD(&space->containers, container, next);
> +
> + group->container = container;
> + QLIST_INSERT_HEAD(&container->group_list, group, container_next);
> +
> + container->listener = vfio_memory_listener;
> + memory_listener_register(&container->listener, container->space->as);
> +
> + if (container->error) {
> + ret = -1;
> + error_propagate_prepend(errp, container->error,
> + "memory listener initialization failed: ");
> + goto listener_release_exit;
> + }
> +
> + container->initialized = true;
> +
> + return 0;
> +
> +listener_release_exit:
> + QLIST_REMOVE(group, container_next);
> + QLIST_REMOVE(container, next);
> + vfio_listener_release(container);
> + vfio_ram_block_discard_disable(container, false);
> +
> +free_container_exit:
> + g_free(container);
> +
> + vfio_put_address_space(space);
> +
> + return ret;
> +}
> +
> +static void vfio_disconnect_proxy(VFIOGroup *group)
> +{
> + VFIOContainer *container = group->container;
> + VFIOAddressSpace *space = container->space;
> + VFIOGuestIOMMU *giommu, *tmp;
> + VFIOHostDMAWindow *hostwin, *next;
> +
> + /*
> + * try to mirror vfio_disconnect_container()
same comment.
Given the code that follows, I wonder if we shouldn't introduce new
VFIOGroup models: Base, PCI, User, to isolate the differences and
reduce duplication.
Thanks,
C.
> + * as much as possible, knowing each device
> + * is in one group and one container
> + */
> +
> + QLIST_REMOVE(group, container_next);
> + group->container = NULL;
> +
> + /*
> + * Explicitly release the listener first before unset container,
> + * since unset may destroy the backend container if it's the last
> + * group.
> + */
> + memory_listener_unregister(&container->listener);
> +
> + QLIST_REMOVE(container, next);
> +
> + QLIST_FOREACH_SAFE(giommu, &container->giommu_list, giommu_next, tmp) {
> + memory_region_unregister_iommu_notifier(
> + MEMORY_REGION(giommu->iommu_mr), &giommu->n);
> + QLIST_REMOVE(giommu, giommu_next);
> + g_free(giommu);
> + }
> +
> + QLIST_FOREACH_SAFE(hostwin, &container->hostwin_list, hostwin_next,
> + next) {
> + QLIST_REMOVE(hostwin, hostwin_next);
> + g_free(hostwin);
> + }
> +
> + g_free(container);
> + vfio_put_address_space(space);
> +}
> +
> +int vfio_user_get_device(VFIOGroup *group, VFIODevice *vbasedev, Error **errp)
> +{
> + struct vfio_device_info info = { .argsz = sizeof(info) };
> + int ret;
> +
> + ret = VDEV_GET_INFO(vbasedev, &info);
> + if (ret) {
> + error_setg_errno(errp, -ret, "get info failure");
> + return ret;
> + }
> +
> + vbasedev->fd = -1;
> + vbasedev->group = group;
> + QLIST_INSERT_HEAD(&group->device_list, vbasedev, next);
> +
> + vbasedev->num_irqs = info.num_irqs;
> + vbasedev->num_regions = info.num_regions;
> + vbasedev->flags = info.flags;
> +
> + vfio_get_all_regions(vbasedev);
> + vbasedev->reset_works = !!(info.flags & VFIO_DEVICE_FLAGS_RESET);
> + return 0;
> +}
> +
> +VFIOGroup *vfio_user_get_group(VFIOProxy *proxy, AddressSpace *as, Error **errp)
> +{
> + VFIOGroup *group;
> +
> + /*
> + * Mirror vfio_get_group(), except that each
> + * device gets its own group and container,
> + * unrelated to any host IOMMU groupings
> + */
> + group = g_malloc0(sizeof(*group));
> + group->fd = -1;
> + group->groupid = -1;
> + QLIST_INIT(&group->device_list);
> +
> + if (vfio_connect_proxy(proxy, group, as, errp)) {
> + error_prepend(errp, "failed to connect proxy");
> + g_free(group);
> + group = NULL;
> + }
> +
> + if (QLIST_EMPTY(&vfio_group_list)) {
> + qemu_register_reset(vfio_reset_handler, NULL);
> + }
> +
> + QLIST_INSERT_HEAD(&vfio_group_list, group, next);
> +
> + return group;
> +}
> +
> +void vfio_user_put_group(VFIOGroup *group)
> +{
> + if (!group || !QLIST_EMPTY(&group->device_list)) {
> + return;
> + }
> +
> + vfio_ram_block_discard_disable(group->container, false);
> + vfio_disconnect_proxy(group);
> + QLIST_REMOVE(group, next);
> + g_free(group);
> +
> + if (QLIST_EMPTY(&vfio_group_list)) {
> + qemu_unregister_reset(vfio_reset_handler, NULL);
> + }
> +}
> +
> +#endif /* CONFIG_VFIO_USER */
> +
> +
> static void vfio_disconnect_container(VFIOGroup *group)
> {
> VFIOContainer *container = group->container;
> @@ -2499,7 +2702,9 @@ void vfio_put_base_device(VFIODevice *vbasedev)
> QLIST_REMOVE(vbasedev, next);
> vbasedev->group = NULL;
> trace_vfio_put_base_device(vbasedev->fd);
> - close(vbasedev->fd);
> + if (vbasedev->fd != -1) {
> + close(vbasedev->fd);
> + }
> }
>
> int vfio_get_region_info(VFIODevice *vbasedev, int index,
> diff --git a/hw/vfio/pci.c b/hw/vfio/pci.c
> index a1ae3fb..53e3bb8 100644
> --- a/hw/vfio/pci.c
> +++ b/hw/vfio/pci.c
> @@ -3584,7 +3584,7 @@ static void vfio_user_pci_realize(PCIDevice *pdev, Error **errp)
> VFIODevice *vbasedev = &vdev->vbasedev;
> SocketAddress addr;
> VFIOProxy *proxy;
> - struct vfio_device_info info;
> + VFIOGroup *group = NULL;
> int ret;
> Error *err = NULL;
>
> @@ -3630,9 +3630,15 @@ static void vfio_user_pci_realize(PCIDevice *pdev, Error **errp)
> vbasedev->io_ops = &vfio_dev_io_sock;
> vdev->vbasedev.irq_mask_works = true;
>
> - ret = VDEV_GET_INFO(vbasedev, &info);
> + group = vfio_user_get_group(proxy, pci_device_iommu_address_space(pdev),
> + errp);
> + if (!group) {
> + goto error;
> + }
> +
> + ret = vfio_user_get_device(group, vbasedev, errp);
> if (ret) {
> - error_setg_errno(errp, -ret, "get info failure");
> + vfio_user_put_group(group);
> goto error;
> }
>
> @@ -3692,12 +3698,18 @@ static void vfio_user_instance_finalize(Object *obj)
> {
> VFIOPCIDevice *vdev = VFIO_PCI_BASE(obj);
> VFIODevice *vbasedev = &vdev->vbasedev;
> + VFIOGroup *group = vbasedev->group;
> +
> + vfio_bars_finalize(vdev);
> + g_free(vdev->emulated_config_bits);
> + g_free(vdev->rom);
>
> if (vdev->msix != NULL) {
> vfio_user_msix_teardown(vdev);
> }
>
> vfio_put_device(vdev);
> + vfio_user_put_group(group);
>
> if (vbasedev->proxy != NULL) {
> vfio_user_disconnect(vbasedev->proxy);
> diff --git a/hw/vfio/user.c b/hw/vfio/user.c
> index 815385b..2d35f83 100644
> --- a/hw/vfio/user.c
> +++ b/hw/vfio/user.c
> @@ -1433,3 +1433,6 @@ VFIODevIO vfio_dev_io_sock = {
> .region_write = vfio_user_io_region_write,
> };
>
> +
> +VFIOContIO vfio_cont_io_sock = {
> +};
> diff --git a/hw/vfio/user.h b/hw/vfio/user.h
> index 359a029..19b8a29 100644
> --- a/hw/vfio/user.h
> +++ b/hw/vfio/user.h
> @@ -94,5 +94,6 @@ void vfio_user_set_handler(VFIODevice *vbasedev,
> int vfio_user_validate_version(VFIOProxy *proxy, Error **errp);
>
> extern VFIODevIO vfio_dev_io_sock;
> +extern VFIOContIO vfio_cont_io_sock;
>
> #endif /* VFIO_USER_H */
> diff --git a/include/hw/vfio/vfio-common.h b/include/hw/vfio/vfio-common.h
> index 793ca94..312ef9c 100644
> --- a/include/hw/vfio/vfio-common.h
> +++ b/include/hw/vfio/vfio-common.h
> @@ -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;
> @@ -282,6 +283,11 @@ void vfio_put_group(VFIOGroup *group);
> int vfio_get_device(VFIOGroup *group, const char *name,
> VFIODevice *vbasedev, Error **errp);
>
> +int vfio_user_get_device(VFIOGroup *group, VFIODevice *vbasedev, Error **errp);
> +VFIOGroup *vfio_user_get_group(VFIOProxy *proxy, AddressSpace *as,
> + Error **errp);
> +void vfio_user_put_group(VFIOGroup *group);
> +
> extern const MemoryRegionOps vfio_region_ops;
> typedef QLIST_HEAD(VFIOGroupList, VFIOGroup) VFIOGroupList;
> extern VFIOGroupList vfio_group_list;
^ permalink raw reply [flat|nested] 82+ messages in thread
* Re: [PATCH v1 17/24] vfio-user: dma map/unmap operations
2022-11-08 23:13 ` [PATCH v1 17/24] vfio-user: dma map/unmap operations John Johnson
@ 2022-12-15 12:39 ` Cédric Le Goater
0 siblings, 0 replies; 82+ messages in thread
From: Cédric Le Goater @ 2022-12-15 12:39 UTC (permalink / raw)
To: qemu-devel
On 11/9/22 00:13, John Johnson wrote:
> Add ability to do async operations during memory transactions
>
> Signed-off-by: Jagannathan Raman <jag.raman@oracle.com>
> Signed-off-by: Elena Ufimtseva <elena.ufimtseva@oracle.com>
> Signed-off-by: John G Johnson <john.g.johnson@oracle.com>
> ---
> hw/vfio/common.c | 63 +++++++++---
> hw/vfio/user-protocol.h | 32 ++++++
> hw/vfio/user.c | 220 ++++++++++++++++++++++++++++++++++++++++++
> include/hw/vfio/vfio-common.h | 9 +-
> 4 files changed, 308 insertions(+), 16 deletions(-)
>
> diff --git a/hw/vfio/common.c b/hw/vfio/common.c
> index e73a772..fe6eddd 100644
> --- a/hw/vfio/common.c
> +++ b/hw/vfio/common.c
> @@ -507,7 +507,7 @@ static int vfio_dma_unmap(VFIOContainer *container,
> return CONT_DMA_UNMAP(container, &unmap, NULL);
> }
>
> -static int vfio_dma_map(VFIOContainer *container, hwaddr iova,
> +static int vfio_dma_map(VFIOContainer *container, MemoryRegion *mr, hwaddr iova,
> ram_addr_t size, void *vaddr, bool readonly)
> {
> struct vfio_iommu_type1_dma_map map = {
> @@ -523,7 +523,7 @@ static int vfio_dma_map(VFIOContainer *container, hwaddr iova,
> map.flags |= VFIO_DMA_MAP_FLAG_WRITE;
> }
>
> - ret = CONT_DMA_MAP(container, &map);
> + ret = CONT_DMA_MAP(container, mr, &map);
>
> if (ret < 0) {
> error_report("VFIO_MAP_DMA failed: %s", strerror(-ret));
> @@ -586,7 +586,8 @@ static bool vfio_listener_skipped_section(MemoryRegionSection *section)
>
> /* Called with rcu_read_lock held. */
> static bool vfio_get_xlat_addr(IOMMUTLBEntry *iotlb, void **vaddr,
> - ram_addr_t *ram_addr, bool *read_only)
> + ram_addr_t *ram_addr, bool *read_only,
> + MemoryRegion **mrp)
> {
This needs a small update. A memory_get_xlat_addr() routine was introduced since.
> MemoryRegion *mr;
> hwaddr xlat;
> @@ -667,6 +668,10 @@ static bool vfio_get_xlat_addr(IOMMUTLBEntry *iotlb, void **vaddr,
> *read_only = !writable || mr->readonly;
> }
>
> + if (mrp != NULL) {
> + *mrp = mr;
> + }
> +
> return true;
> }
>
> @@ -674,6 +679,7 @@ static void vfio_iommu_map_notify(IOMMUNotifier *n, IOMMUTLBEntry *iotlb)
> {
> VFIOGuestIOMMU *giommu = container_of(n, VFIOGuestIOMMU, n);
> VFIOContainer *container = giommu->container;
> + MemoryRegion *mr;
> hwaddr iova = iotlb->iova + giommu->iommu_offset;
> void *vaddr;
> int ret;
> @@ -692,7 +698,7 @@ static void vfio_iommu_map_notify(IOMMUNotifier *n, IOMMUTLBEntry *iotlb)
> if ((iotlb->perm & IOMMU_RW) != IOMMU_NONE) {
> bool read_only;
>
> - if (!vfio_get_xlat_addr(iotlb, &vaddr, NULL, &read_only)) {
> + if (!vfio_get_xlat_addr(iotlb, &vaddr, NULL, &read_only, &mr)) {
> goto out;
> }
> /*
> @@ -702,14 +708,14 @@ static void vfio_iommu_map_notify(IOMMUNotifier *n, IOMMUTLBEntry *iotlb)
> * of vaddr will always be there, even if the memory object is
> * destroyed and its backing memory munmap-ed.
> */
> - ret = vfio_dma_map(container, iova,
> + ret = vfio_dma_map(container, mr, iova,
> iotlb->addr_mask + 1, vaddr,
> read_only);
> if (ret) {
> error_report("vfio_dma_map(%p, 0x%"HWADDR_PRIx", "
> - "0x%"HWADDR_PRIx", %p) = %d (%m)",
> + "0x%"HWADDR_PRIx", %p)",
> container, iova,
> - iotlb->addr_mask + 1, vaddr, ret);
> + iotlb->addr_mask + 1, vaddr);
> }
> } else {
> ret = vfio_dma_unmap(container, iova, iotlb->addr_mask + 1, iotlb);
> @@ -764,7 +770,7 @@ static int vfio_ram_discard_notify_populate(RamDiscardListener *rdl,
> section->offset_within_address_space;
> vaddr = memory_region_get_ram_ptr(section->mr) + start;
>
> - ret = vfio_dma_map(vrdl->container, iova, next - start,
> + ret = vfio_dma_map(vrdl->container, section->mr, iova, next - start,
> vaddr, section->readonly);
> if (ret) {
> /* Rollback */
> @@ -888,6 +894,29 @@ static bool vfio_known_safe_misalignment(MemoryRegionSection *section)
> return true;
> }
>
> +static void vfio_listener_begin(MemoryListener *listener)
> +{
> + VFIOContainer *container = container_of(listener, VFIOContainer, listener);
> +
> + /*
> + * When DMA space is the physical address space,
> + * the region add/del listeners will fire during
> + * memory update transactions. These depend on BQL
> + * being held, so do any resulting map/demap ops async
> + * while keeping BQL.
> + */
> + container->async_ops = true;
> +}
> +
> +static void vfio_listener_commit(MemoryListener *listener)
> +{
> + VFIOContainer *container = container_of(listener, VFIOContainer, listener);
> +
> + /* wait here for any async requests sent during the transaction */
> + CONT_WAIT_COMMIT(container);
> + container->async_ops = false;
> +}
> +
> static void vfio_listener_region_add(MemoryListener *listener,
> MemoryRegionSection *section)
> {
> @@ -1095,12 +1124,12 @@ static void vfio_listener_region_add(MemoryListener *listener,
> }
> }
>
> - ret = vfio_dma_map(container, iova, int128_get64(llsize),
> + ret = vfio_dma_map(container, section->mr, iova, int128_get64(llsize),
> vaddr, section->readonly);
> if (ret) {
> error_setg(&err, "vfio_dma_map(%p, 0x%"HWADDR_PRIx", "
> - "0x%"HWADDR_PRIx", %p) = %d (%m)",
> - container, iova, int128_get64(llsize), vaddr, ret);
> + "0x%"HWADDR_PRIx", %p)",
> + container, iova, int128_get64(llsize), vaddr);
> if (memory_region_is_ram_device(section->mr)) {
> /* Allow unexpected mappings not to be fatal for RAM devices */
> error_report_err(err);
> @@ -1369,7 +1398,7 @@ static void vfio_iommu_map_dirty_notify(IOMMUNotifier *n, IOMMUTLBEntry *iotlb)
> }
>
> rcu_read_lock();
> - if (vfio_get_xlat_addr(iotlb, NULL, &translated_addr, NULL)) {
> + if (vfio_get_xlat_addr(iotlb, NULL, &translated_addr, NULL, NULL)) {
> int ret;
>
> ret = vfio_get_dirty_bitmap(container, iova, iotlb->addr_mask + 1,
> @@ -1487,6 +1516,8 @@ static void vfio_listener_log_sync(MemoryListener *listener,
>
> static const MemoryListener vfio_memory_listener = {
> .name = "vfio",
> + .begin = vfio_listener_begin,
> + .commit = vfio_listener_commit,
> .region_add = vfio_listener_region_add,
> .region_del = vfio_listener_region_del,
> .log_global_start = vfio_listener_log_global_start,
> @@ -2977,7 +3008,7 @@ VFIODevIO vfio_dev_io_ioctl = {
> .region_write = vfio_io_region_write,
> };
>
> -static int vfio_io_dma_map(VFIOContainer *container,
> +static int vfio_io_dma_map(VFIOContainer *container, MemoryRegion *mr,
> struct vfio_iommu_type1_dma_map *map)
> {
>
> @@ -3037,8 +3068,14 @@ static int vfio_io_dirty_bitmap(VFIOContainer *container,
> return ret < 0 ? -errno : ret;
> }
>
> +static void vfio_io_wait_commit(VFIOContainer *container)
> +{
> + /* ioctl()s are synchronous */
> +}
> +
> VFIOContIO vfio_cont_io_ioctl = {
> .dma_map = vfio_io_dma_map,
> .dma_unmap = vfio_io_dma_unmap,
> .dirty_bitmap = vfio_io_dirty_bitmap,
> + .wait_commit = vfio_io_wait_commit,
> };
> diff --git a/hw/vfio/user-protocol.h b/hw/vfio/user-protocol.h
> index 31704cf..e9fcf64 100644
> --- a/hw/vfio/user-protocol.h
> +++ b/hw/vfio/user-protocol.h
> @@ -114,6 +114,31 @@ typedef struct {
> #define VFIO_USER_DEF_MAX_BITMAP (256 * 1024 * 1024)
>
> /*
> + * 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
> */
> @@ -177,4 +202,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 */
> diff --git a/hw/vfio/user.c b/hw/vfio/user.c
> index 2d35f83..1fd37cc 100644
> --- a/hw/vfio/user.c
> +++ b/hw/vfio/user.c
> @@ -59,8 +59,11 @@ 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_nowait(VFIOProxy *proxy, VFIOUserHdr *hdr,
> + VFIOUserFDs *fds, int rsize);
> static void vfio_user_send_wait(VFIOProxy *proxy, VFIOUserHdr *hdr,
> VFIOUserFDs *fds, int rsize, bool nobql);
> +static void vfio_user_wait_reqs(VFIOProxy *proxy);
> static void vfio_user_request_msg(VFIOUserHdr *hdr, uint16_t cmd,
> uint32_t size, uint32_t flags);
>
> @@ -647,6 +650,36 @@ static void vfio_user_send_async(VFIOProxy *proxy, VFIOUserHdr *hdr,
> }
> }
>
> +/*
> + * nowait send - vfio_wait_reqs() can wait for it later
> + */
> +static void vfio_user_send_nowait(VFIOProxy *proxy, VFIOUserHdr *hdr,
> + VFIOUserFDs *fds, int rsize)
> +{
> + VFIOUserMsg *msg;
> + int ret;
> +
> + if (hdr->flags & VFIO_USER_NO_REPLY) {
> + error_printf("vfio_user_send_nowait on async message\n");
> + return;
> + }
> +
> + QEMU_LOCK_GUARD(&proxy->lock);
> +
> + msg = vfio_user_getmsg(proxy, hdr, fds);
> + msg->id = hdr->id;
> + msg->rsize = rsize ? rsize : hdr->size;
> + msg->type = VFIO_MSG_NOWAIT;
> +
> + ret = vfio_user_send_queued(proxy, msg);
> + if (ret < 0) {
> + vfio_user_recycle(proxy, msg);
> + return;
> + }
> +
> + proxy->last_nowait = msg;
> +}
> +
> static void vfio_user_send_wait(VFIOProxy *proxy, VFIOUserHdr *hdr,
> VFIOUserFDs *fds, int rsize, bool nobql)
> {
> @@ -699,6 +732,60 @@ static void vfio_user_send_wait(VFIOProxy *proxy, VFIOUserHdr *hdr,
> }
> }
>
> +static void vfio_user_wait_reqs(VFIOProxy *proxy)
> +{
> + VFIOUserMsg *msg;
> + bool iolock = false;
> +
> + /*
> + * Any DMA map/unmap requests sent in the middle
> + * of a memory region transaction were sent nowait.
> + * Wait for them here.
> + */
> + qemu_mutex_lock(&proxy->lock);
> + if (proxy->last_nowait != NULL) {
> + iolock = qemu_mutex_iothread_locked();
> + if (iolock) {
> + qemu_mutex_unlock_iothread();
> + }
> +
> + /*
> + * Change type to WAIT to wait for reply
> + */
> + msg = proxy->last_nowait;
> + msg->type = VFIO_MSG_WAIT;
> + while (!msg->complete) {
> + if (!qemu_cond_timedwait(&msg->cv, &proxy->lock, wait_time)) {
> + VFIOUserMsgQ *list;
> +
> + list = msg->pending ? &proxy->pending : &proxy->outgoing;
> + QTAILQ_REMOVE(list, msg, next);
> + error_printf("vfio_wait_reqs - timed out\n");
> + break;
> + }
> + }
> +
> + if (msg->hdr->flags & VFIO_USER_ERROR) {
> + error_printf("vfio_user_wait_reqs - error reply on async request ");
> + error_printf("command %x error %s\n", msg->hdr->command,
> + strerror(msg->hdr->error_reply));
> + }
> +
> + proxy->last_nowait = NULL;
> + /*
> + * Change type back to NOWAIT to free
> + */
> + msg->type = VFIO_MSG_NOWAIT;
> + 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);
>
> @@ -1113,6 +1200,103 @@ int vfio_user_validate_version(VFIOProxy *proxy, Error **errp)
> return 0;
> }
>
> +static int vfio_user_dma_map(VFIOProxy *proxy,
> + struct vfio_iommu_type1_dma_map *map,
> + int fd, bool will_commit)
> +{
> + VFIOUserFDs *fds = NULL;
> + VFIOUserDMAMap *msgp = g_malloc0(sizeof(*msgp));
> + int ret;
> +
> + vfio_user_request_msg(&msgp->hdr, VFIO_USER_DMA_MAP, sizeof(*msgp), 0);
> + msgp->argsz = map->argsz;
> + msgp->flags = map->flags;
> + msgp->offset = map->vaddr;
> + msgp->iova = map->iova;
> + msgp->size = map->size;
> +
> + /*
> + * The will_commit case sends without blocking or dropping BQL.
> + * They're later waited for in vfio_send_wait_reqs.
> + */
> + if (will_commit) {
> + /* can't use auto variable since we don't block */
> + if (fd != -1) {
> + fds = vfio_user_getfds(1);
It is difficult to see where vfio_user_putfds() is called to free fds.
> + fds->send_fds = 1;
> + fds->fds[0] = fd;
> + }
> + vfio_user_send_nowait(proxy, &msgp->hdr, fds, 0);
> + ret = 0;
> + } else {
> + VFIOUserFDs local_fds = { 1, 0, &fd };
> +
> + fds = fd != -1 ? &local_fds : NULL;
> + vfio_user_send_wait(proxy, &msgp->hdr, fds, 0, will_commit);
> + ret = (msgp->hdr.flags & VFIO_USER_ERROR) ? -msgp->hdr.error_reply : 0;
> + g_free(msgp);
> + }
> +
> + return ret;
> +}
> +
> +static int vfio_user_dma_unmap(VFIOProxy *proxy,
> + struct vfio_iommu_type1_dma_unmap *unmap,
> + struct vfio_bitmap *bitmap, bool will_commit)
> +{
> + struct {
> + VFIOUserDMAUnmap msg;
> + VFIOUserBitmap bitmap;
> + } *msgp = NULL;
> + int msize, rsize;
> + bool blocking = !will_commit;
> +
> + if (bitmap == NULL &&
> + (unmap->flags & VFIO_DMA_UNMAP_FLAG_GET_DIRTY_BITMAP)) {
> + error_printf("vfio_user_dma_unmap mismatched flags and bitmap\n");
> + return -EINVAL;
> + }
> +
> + /*
> + * If a dirty bitmap is returned, allocate extra space for it
> + * and block for reply even in the will_commit case.
> + * Otherwise, can send the unmap request without waiting.
> + */
> + if (bitmap != NULL) {
> + blocking = true;
> + msize = sizeof(*msgp);
> + rsize = msize + bitmap->size;
> + msgp = g_malloc0(rsize);
> + msgp->bitmap.pgsize = bitmap->pgsize;
> + msgp->bitmap.size = bitmap->size;
> + } else {
> + msize = rsize = sizeof(VFIOUserDMAUnmap);
> + msgp = g_malloc0(rsize);
> + }
> +
> + vfio_user_request_msg(&msgp->msg.hdr, VFIO_USER_DMA_UNMAP, msize, 0);
> + msgp->msg.argsz = rsize - sizeof(VFIOUserHdr);
> + msgp->msg.argsz = unmap->argsz;
> + msgp->msg.flags = unmap->flags;
> + msgp->msg.iova = unmap->iova;
> + msgp->msg.size = unmap->size;
> +
> + if (blocking) {
> + vfio_user_send_wait(proxy, &msgp->msg.hdr, NULL, rsize, will_commit);
> + if (msgp->msg.hdr.flags & VFIO_USER_ERROR) {
> + return -msgp->msg.hdr.error_reply;
> + }
> + if (bitmap != NULL) {
> + memcpy(bitmap->data, &msgp->bitmap.data, bitmap->size);
> + }
> + g_free(msgp);
> + } else {
> + vfio_user_send_nowait(proxy, &msgp->msg.hdr, NULL, rsize);
> + }
> +
> + return 0;
> +}
> +
> static int vfio_user_get_info(VFIOProxy *proxy, struct vfio_device_info *info)
> {
> VFIOUserDeviceInfo msg;
> @@ -1434,5 +1618,41 @@ VFIODevIO vfio_dev_io_sock = {
> };
>
>
> +static int vfio_user_io_dma_map(VFIOContainer *container, MemoryRegion *mr,
> + struct vfio_iommu_type1_dma_map *map)
> +{
> + int fd = memory_region_get_fd(mr);
> +
> + /*
> + * map->vaddr enters as a QEMU process address
> + * make it either a file offset for mapped areas or 0
> + */
> + if (fd != -1) {
> + void *addr = (void *)(uintptr_t)map->vaddr;
> +
> + map->vaddr = qemu_ram_block_host_offset(mr->ram_block, addr);
> + } else {
> + map->vaddr = 0;
> + }
> +
> + return vfio_user_dma_map(container->proxy, map, fd, container->async_ops);
> +}
> +
> +static int vfio_user_io_dma_unmap(VFIOContainer *container,
> + struct vfio_iommu_type1_dma_unmap *unmap,
> + struct vfio_bitmap *bitmap)
> +{
> + return vfio_user_dma_unmap(container->proxy, unmap, bitmap,
> + container->async_ops);
> +}
> +
> +static void vfio_user_io_wait_commit(VFIOContainer *container)
> +{
> + vfio_user_wait_reqs(container->proxy);
> +}
> +
> VFIOContIO vfio_cont_io_sock = {
> + .dma_map = vfio_user_io_dma_map,
> + .dma_unmap = vfio_user_io_dma_unmap,
> + .wait_commit = vfio_user_io_wait_commit,
> };
> diff --git a/include/hw/vfio/vfio-common.h b/include/hw/vfio/vfio-common.h
> index 312ef9c..413dafc 100644
> --- a/include/hw/vfio/vfio-common.h
> +++ b/include/hw/vfio/vfio-common.h
> @@ -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;
> @@ -200,7 +201,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,
> @@ -208,14 +209,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;
^ permalink raw reply [flat|nested] 82+ messages in thread
* Re: [PATCH v1 22/24] vfio-user: add 'x-msg-timeout' option that specifies msg wait times
2022-11-08 23:13 ` [PATCH v1 22/24] vfio-user: add 'x-msg-timeout' option that specifies msg wait times John Johnson
2022-12-09 18:14 ` John Levon
@ 2022-12-15 12:56 ` Cédric Le Goater
2022-12-16 4:22 ` John Johnson
1 sibling, 1 reply; 82+ messages in thread
From: Cédric Le Goater @ 2022-12-15 12:56 UTC (permalink / raw)
To: John Johnson, qemu-devel
On 11/9/22 00:13, John Johnson wrote:
> Signed-off-by: John G Johnson <john.g.johnson@oracle.com>
> Signed-off-by: Elena Ufimtseva <elena.ufimtseva@oracle.com>
> Signed-off-by: Jagannathan Raman <jag.raman@oracle.com>
> ---
> hw/vfio/pci.c | 4 ++++
> hw/vfio/pci.h | 1 +
> hw/vfio/user.c | 7 +++++--
> hw/vfio/user.h | 1 +
> 4 files changed, 11 insertions(+), 2 deletions(-)>
> diff --git a/hw/vfio/pci.c b/hw/vfio/pci.c
> index 005fcf8..3ae3a13 100644
> --- a/hw/vfio/pci.c
> +++ b/hw/vfio/pci.c
> @@ -3729,6 +3729,9 @@ static void vfio_user_pci_realize(PCIDevice *pdev, Error **errp)
> if (udev->no_post) {
> proxy->flags |= VFIO_PROXY_NO_POST;
> }
> + if (udev->wait_time) {
> + proxy->wait_time = udev->wait_time;
> + }
>
> vfio_user_validate_version(proxy, &err);
> if (err != NULL) {
> @@ -3848,6 +3851,7 @@ static Property vfio_user_pci_dev_properties[] = {
> 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_UINT32("x-msg-timeout", VFIOUserPCIDevice, wait_time, 0),
I see that patch 9 introduced :
+static int wait_time = 5000; /* wait up to 5 sec for busy servers */
May be use a define instead and assign "x-msg-timeout" to this default
value.
how do you plan to use the "x-msg-timeout" property ?
Thanks,
C.
> DEFINE_PROP_END_OF_LIST(),
> };
>
> diff --git a/hw/vfio/pci.h b/hw/vfio/pci.h
> index c4b8e5c..48b19ee 100644
> --- a/hw/vfio/pci.h
> +++ b/hw/vfio/pci.h
> @@ -199,6 +199,7 @@ struct VFIOUserPCIDevice {
> bool secure_dma; /* disable shared mem for DMA */
> bool send_queued; /* all sends are queued */
> bool no_post; /* all regions write are sync */
> + uint32_t wait_time; /* timeout for message replies */
> };
>
> /* Use uin32_t for vendor & device so PCI_ANY_ID expands and cannot match hw */
> diff --git a/hw/vfio/user.c b/hw/vfio/user.c
> index ddf9e13..a9e6cf5 100644
> --- a/hw/vfio/user.c
> +++ b/hw/vfio/user.c
> @@ -717,7 +717,8 @@ static void vfio_user_send_wait(VFIOProxy *proxy, VFIOUserHdr *hdr,
>
> if (ret == 0) {
> while (!msg->complete) {
> - if (!qemu_cond_timedwait(&msg->cv, &proxy->lock, wait_time)) {
> + if (!qemu_cond_timedwait(&msg->cv, &proxy->lock,
> + proxy->wait_time)) {
> VFIOUserMsgQ *list;
>
> list = msg->pending ? &proxy->pending : &proxy->outgoing;
> @@ -759,7 +760,8 @@ static void vfio_user_wait_reqs(VFIOProxy *proxy)
> msg = proxy->last_nowait;
> msg->type = VFIO_MSG_WAIT;
> while (!msg->complete) {
> - if (!qemu_cond_timedwait(&msg->cv, &proxy->lock, wait_time)) {
> + if (!qemu_cond_timedwait(&msg->cv, &proxy->lock,
> + proxy->wait_time)) {
> VFIOUserMsgQ *list;
>
> list = msg->pending ? &proxy->pending : &proxy->outgoing;
> @@ -881,6 +883,7 @@ VFIOProxy *vfio_user_connect_dev(SocketAddress *addr, Error **errp)
>
> proxy->flags = VFIO_PROXY_CLIENT;
> proxy->state = VFIO_PROXY_CONNECTED;
> + proxy->wait_time = wait_time;
>
> qemu_mutex_init(&proxy->lock);
> qemu_cond_init(&proxy->close_cv);
> diff --git a/hw/vfio/user.h b/hw/vfio/user.h
> index d88ffe5..f711861 100644
> --- a/hw/vfio/user.h
> +++ b/hw/vfio/user.h
> @@ -62,6 +62,7 @@ typedef struct VFIOProxy {
> uint64_t max_bitmap;
> uint64_t migr_pgsize;
> int flags;
> + uint32_t wait_time;
> QemuCond close_cv;
> AioContext *ctx;
> QEMUBH *req_bh;
^ permalink raw reply [flat|nested] 82+ messages in thread
* Re: [PATCH v1 24/24] vfio-user: add trace points
2022-11-08 23:13 ` [PATCH v1 24/24] vfio-user: add trace points John Johnson
@ 2022-12-15 12:59 ` Cédric Le Goater
0 siblings, 0 replies; 82+ messages in thread
From: Cédric Le Goater @ 2022-12-15 12:59 UTC (permalink / raw)
To: John Johnson, qemu-devel
On 11/9/22 00:13, John Johnson wrote:
> Signed-off-by: John G Johnson <john.g.johnson@oracle.com>
> Signed-off-by: Elena Ufimtseva <elena.ufimtseva@oracle.com>
> Signed-off-by: Jagannathan Raman <jag.raman@oracle.com>
> ---
> hw/vfio/trace-events | 15 +++++++++++++++
> hw/vfio/user.c | 26 ++++++++++++++++++++++++++
> 2 files changed, 41 insertions(+)
I would introduce the traces progressively in the patchset with the
routine being traced.
Thanks,
C.
>
> diff --git a/hw/vfio/trace-events b/hw/vfio/trace-events
> index 73dffe9..c27cec7 100644
> --- a/hw/vfio/trace-events
> +++ b/hw/vfio/trace-events
> @@ -166,3 +166,18 @@ vfio_load_state_device_data(const char *name, uint64_t data_offset, uint64_t dat
> vfio_load_cleanup(const char *name) " (%s)"
> vfio_get_dirty_bitmap(int fd, uint64_t iova, uint64_t size, uint64_t bitmap_size, uint64_t start) "container fd=%d, iova=0x%"PRIx64" size= 0x%"PRIx64" bitmap_size=0x%"PRIx64" start=0x%"PRIx64
> vfio_iommu_map_dirty_notify(uint64_t iova_start, uint64_t iova_end) "iommu dirty @ 0x%"PRIx64" - 0x%"PRIx64
> +
> +# user.c
> +vfio_user_recv_hdr(const char *name, uint16_t id, uint16_t cmd, uint32_t size, uint32_t flags) " (%s) id 0x%x cmd 0x%x size 0x%x flags 0x%x"
> +vfio_user_recv_read(uint16_t id, int read) " id 0x%x read 0x%x"
> +vfio_user_recv_request(uint16_t cmd) " command 0x%x"
> +vfio_user_send_write(uint16_t id, int wrote) " id 0x%x wrote 0x%x"
> +vfio_user_version(uint16_t major, uint16_t minor, const char *caps) " major %d minor %d caps: %s"
> +vfio_user_dma_map(uint64_t iova, uint64_t size, uint64_t off, uint32_t flags, bool will_commit) " iova 0x%"PRIx64" size 0x%"PRIx64" off 0x%"PRIx64" flags 0x%x will_commit %d"
> +vfio_user_dma_unmap(uint64_t iova, uint64_t size, uint32_t flags, bool dirty, bool will_commit) " iova 0x%"PRIx64" size 0x%"PRIx64" flags 0x%x dirty %d will_commit %d"
> +vfio_user_get_info(uint32_t nregions, uint32_t nirqs) " #regions %d #irqs %d"
> +vfio_user_get_region_info(uint32_t index, uint32_t flags, uint64_t size) " index %d flags 0x%x size 0x%"PRIx64
> +vfio_user_get_irq_info(uint32_t index, uint32_t flags, uint32_t count) " index %d flags 0x%x count %d"
> +vfio_user_set_irqs(uint32_t index, uint32_t start, uint32_t count, uint32_t flags) " index %d start %d count %d flags 0x%x"
> +vfio_user_region_rw(uint32_t region, uint64_t off, uint32_t count) " region %d offset 0x%"PRIx64" count %d"
> +vfio_user_wrmulti(const char *s, uint64_t wr_cnt) " %s count 0x%"PRIx64
> diff --git a/hw/vfio/user.c b/hw/vfio/user.c
> index 4ed305b..74e1714 100644
> --- a/hw/vfio/user.c
> +++ b/hw/vfio/user.c
> @@ -30,6 +30,8 @@
> #include "qapi/qmp/qnum.h"
> #include "qapi/qmp/qbool.h"
> #include "user.h"
> +#include "trace.h"
> +
>
>
> /*
> @@ -108,6 +110,8 @@ static int vfio_user_send_qio(VFIOProxy *proxy, VFIOUserMsg *msg)
> vfio_user_shutdown(proxy);
> error_report_err(local_err);
> }
> + trace_vfio_user_send_write(msg->hdr->id, ret);
> +
> return ret;
> }
>
> @@ -225,6 +229,7 @@ static int vfio_user_complete(VFIOProxy *proxy, Error **errp)
> }
> return ret;
> }
> + trace_vfio_user_recv_read(msg->hdr->id, ret);
>
> msgleft -= ret;
> data += ret;
> @@ -332,6 +337,8 @@ static int vfio_user_recv_one(VFIOProxy *proxy)
> error_setg(&local_err, "unknown message type");
> goto fatal;
> }
> + trace_vfio_user_recv_hdr(proxy->sockname, hdr.id, hdr.command, hdr.size,
> + hdr.flags);
>
> /*
> * For replies, find the matching pending request.
> @@ -408,6 +415,7 @@ static int vfio_user_recv_one(VFIOProxy *proxy)
> if (ret <= 0) {
> goto fatal;
> }
> + trace_vfio_user_recv_read(hdr.id, ret);
>
> msgleft -= ret;
> data += ret;
> @@ -546,6 +554,7 @@ static void vfio_user_request(void *opaque)
> QTAILQ_INIT(&free);
> QTAILQ_FOREACH_SAFE(msg, &new, next, m1) {
> QTAILQ_REMOVE(&new, msg, next);
> + trace_vfio_user_recv_request(msg->hdr->command);
> proxy->request(proxy->req_arg, msg);
> QTAILQ_INSERT_HEAD(&free, msg, next);
> }
> @@ -1265,6 +1274,7 @@ int vfio_user_validate_version(VFIOProxy *proxy, Error **errp)
> msgp->minor = VFIO_USER_MINOR_VER;
> memcpy(&msgp->capabilities, caps->str, caplen);
> g_string_free(caps, true);
> + trace_vfio_user_version(msgp->major, msgp->minor, msgp->capabilities);
>
> vfio_user_send_wait(proxy, &msgp->hdr, NULL, 0, false);
> if (msgp->hdr.flags & VFIO_USER_ERROR) {
> @@ -1288,6 +1298,7 @@ int vfio_user_validate_version(VFIOProxy *proxy, Error **errp)
> return -1;
> }
>
> + trace_vfio_user_version(msgp->major, msgp->minor, msgp->capabilities);
> return 0;
> }
>
> @@ -1305,6 +1316,8 @@ static int vfio_user_dma_map(VFIOProxy *proxy,
> msgp->offset = map->vaddr;
> msgp->iova = map->iova;
> msgp->size = map->size;
> + trace_vfio_user_dma_map(msgp->iova, msgp->size, msgp->offset, msgp->flags,
> + will_commit);
>
> /*
> * The will_commit case sends without blocking or dropping BQL.
> @@ -1371,6 +1384,8 @@ static int vfio_user_dma_unmap(VFIOProxy *proxy,
> msgp->msg.flags = unmap->flags;
> msgp->msg.iova = unmap->iova;
> msgp->msg.size = unmap->size;
> + trace_vfio_user_dma_unmap(msgp->msg.iova, msgp->msg.size, msgp->msg.flags,
> + bitmap != NULL, will_commit);
>
> if (blocking) {
> vfio_user_send_wait(proxy, &msgp->msg.hdr, NULL, rsize, will_commit);
> @@ -1400,6 +1415,7 @@ static int vfio_user_get_info(VFIOProxy *proxy, struct vfio_device_info *info)
> if (msg.hdr.flags & VFIO_USER_ERROR) {
> return -msg.hdr.error_reply;
> }
> + trace_vfio_user_get_info(msg.num_regions, msg.num_irqs);
>
> memcpy(info, &msg.argsz, sizeof(*info));
> return 0;
> @@ -1434,6 +1450,7 @@ static int vfio_user_get_region_info(VFIOProxy *proxy,
> if (msgp->hdr.flags & VFIO_USER_ERROR) {
> return -msgp->hdr.error_reply;
> }
> + trace_vfio_user_get_region_info(msgp->index, msgp->flags, msgp->size);
>
> memcpy(info, &msgp->argsz, info->argsz);
> return 0;
> @@ -1454,6 +1471,7 @@ static int vfio_user_get_irq_info(VFIOProxy *proxy,
> if (msg.hdr.flags & VFIO_USER_ERROR) {
> return -msg.hdr.error_reply;
> }
> + trace_vfio_user_get_irq_info(msg.index, msg.flags, msg.count);
>
> memcpy(info, &msg.argsz, sizeof(*info));
> return 0;
> @@ -1499,6 +1517,8 @@ static int vfio_user_set_irqs(VFIOProxy *proxy, struct vfio_irq_set *irq)
> msgp->index = irq->index;
> msgp->start = irq->start;
> msgp->count = irq->count;
> + trace_vfio_user_set_irqs(msgp->index, msgp->start, msgp->count,
> + msgp->flags);
>
> vfio_user_send_wait(proxy, &msgp->hdr, NULL, 0, false);
> if (msgp->hdr.flags & VFIO_USER_ERROR) {
> @@ -1535,6 +1555,8 @@ static int vfio_user_set_irqs(VFIOProxy *proxy, struct vfio_irq_set *irq)
> msgp->index = irq->index;
> msgp->start = irq->start + sent_fds;
> msgp->count = send_fds;
> + trace_vfio_user_set_irqs(msgp->index, msgp->start, msgp->count,
> + msgp->flags);
>
> loop_fds.send_fds = send_fds;
> loop_fds.recv_fds = 0;
> @@ -1565,6 +1587,7 @@ static int vfio_user_region_read(VFIOProxy *proxy, uint8_t index, off_t offset,
> msgp->offset = offset;
> msgp->region = index;
> msgp->count = count;
> + trace_vfio_user_region_rw(msgp->region, msgp->offset, msgp->count);
>
> vfio_user_send_wait(proxy, &msgp->hdr, NULL, size, false);
> if (msgp->hdr.flags & VFIO_USER_ERROR) {
> @@ -1593,6 +1616,7 @@ static void vfio_user_flush_multi(VFIOProxy *proxy)
> msg->id = wm->hdr.id;
> msg->rsize = 0;
> msg->type = VFIO_MSG_ASYNC;
> + trace_vfio_user_wrmulti("flush", wm->wr_cnt);
>
> ret = vfio_user_send_queued(proxy, msg);
> if (ret < 0) {
> @@ -1622,6 +1646,7 @@ static void vfio_user_add_multi(VFIOProxy *proxy, uint8_t index, off_t offset,
> memcpy(&w1->data, data, count);
>
> wm->wr_cnt++;
> + trace_vfio_user_wrmulti("add", wm->wr_cnt);
> if (wm->wr_cnt == VFIO_USER_MULTI_MAX ||
> proxy->num_outgoing < VFIO_USER_OUT_LOW) {
> vfio_user_flush_multi(proxy);
> @@ -1689,6 +1714,7 @@ static int vfio_user_region_write(VFIOProxy *proxy, uint8_t index, off_t offset,
> msgp->region = index;
> msgp->count = count;
> memcpy(&msgp->data, data, count);
> + trace_vfio_user_region_rw(msgp->region, msgp->offset, msgp->count);
>
> /* async send will free msg after it's sent */
> if (post) {
^ permalink raw reply [flat|nested] 82+ messages in thread
* Re: [PATCH v1 22/24] vfio-user: add 'x-msg-timeout' option that specifies msg wait times
2022-12-15 12:56 ` Cédric Le Goater
@ 2022-12-16 4:22 ` John Johnson
0 siblings, 0 replies; 82+ messages in thread
From: John Johnson @ 2022-12-16 4:22 UTC (permalink / raw)
To: Cédric Le Goater; +Cc: qemu-devel
> On Dec 15, 2022, at 4:56 AM, Cédric Le Goater <clg@redhat.com> wrote:
>
> On 11/9/22 00:13, John Johnson wrote:
>>
>> + DEFINE_PROP_UINT32("x-msg-timeout", VFIOUserPCIDevice, wait_time, 0),
>
> I see that patch 9 introduced :
>
> +static int wait_time = 5000; /* wait up to 5 sec for busy servers */
>
> May be use a define instead and assign "x-msg-timeout" to this default
> value.
>
> how do you plan to use the "x-msg-timeout" property ?
>
It was originally used to empirically discover a value that wouldn't
timeout with the device servers we’re using. I kept in case new devices with
longer response times are encountered.
JJ
^ permalink raw reply [flat|nested] 82+ messages in thread
* Re: [PATCH v1 00/24] vfio-user client
2022-11-08 23:13 [PATCH v1 00/24] vfio-user client John Johnson
` (24 preceding siblings ...)
2022-12-12 9:41 ` [PATCH v1 00/24] vfio-user client Philippe Mathieu-Daudé
@ 2022-12-16 11:31 ` Cédric Le Goater
2023-02-02 5:20 ` John Johnson
25 siblings, 1 reply; 82+ messages in thread
From: Cédric Le Goater @ 2022-12-16 11:31 UTC (permalink / raw)
To: John Johnson, qemu-devel
On 11/9/22 00:13, John Johnson wrote:
>
> Hello,
>
> This is the 6th revision of the vfio-user client implementation.
> It is the first patch series (the previous revisions were RFCs)
>
> First of all, thank you for your time reviewing the RFC 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 upstreamed a patch series that implement a server using QEMU.
>
Thanks for this contribution,
This is a large and complex framework which looks quite mature. QEMU
would need implementations of remote devices under contrib/, provided
as examples for the QEMU crowd. These are important to show possible
use cases and also, they could possibly be run for non regression tests
done by maintainers and distros. e1000e is quite popular, it would
be a good target. It could be a simpler device to start with, but we
would need to cover the basic features, INTx, MSI, DMA, etc. when time
permits. There are samples under libvfio-user and I wonder how we
could leverage them.
Unit tests under /tests would be (really) good to have. These would be
run by CI. Yes, this is a lot of work :/ but very important for QEMU
stability.
The "socket" name property is not the preferred way in QEMU to define
a remote peer to contact. Is there a possibility to use the chardev
interface in some simple way ? I am thinking about the command line
interface and the integration with libvirt.
More code should be isolated under the *user.c file, even if that
means exporting definitions of routines which are local today. I don't
think the #ifdef CONFIG_VIO_USER in the vfio files are something we
will want to merge.
Some renaming to be done, like Kern -> Kernel, etc. nothing major.
I am not convinced that the macros hiding the VFIO backend IO ops are
useful. I even recall some places where the vfio-user implemented
handler could be called directly without calling the top routine first.
Anyhow, it would be better to be explicit, the macros don't add much.
There is a lot of code duplication for the IOMMU support. Did you
consider implementing a VFIOGroup class to share the common behaviour ?
May be too early, but this is certainly something to keep in mind.
The msg recycling feature looks nice but isn't it an optimization ?
More globally speaking, for what kind of crazy setup this feature could
help us with ? I was wondering if you had tried to implement a remote
device or bridge in another QEMU process, for instance.
Thanks,
C.
> Contributors:
>
> John G Johnson <john.g.johnson@oracle.com>
> John Levon <john.levon@nutanix.com>
> Thanos Makatos <thanos.makatos@nutanix.com>
> Elena Ufimtseva <elena.ufimtseva@oracle.com>
> Jagannathan Raman <jag.raman@oracle.com>
>
> John Johnson (23):
> vfio-user: add VFIO base abstract class
> vfio-user: add container IO ops vector
> vfio-user: add region cache
> vfio-user: add device IO ops vector
> vfio-user: Define type vfio_user_pci_dev_info
> vfio-user: connect vfio proxy to remote server
> vfio-user: define socket receive functions
> vfio-user: define socket send functions
> vfio-user: get device info
> vfio-user: get region info
> vfio-user: region read/write
> vfio-user: pci_user_realize PCI setup
> vfio-user: get and set IRQs
> vfio-user: forward msix BAR accesses to server
> vfio-user: proxy container connect/disconnect
> vfio-user: dma map/unmap operations
> vfio-user: add dma_unmap_all
> vfio-user: secure DMA support
> vfio-user: dma read/write operations
> vfio-user: pci reset
> vfio-user: add 'x-msg-timeout' option that specifies msg wait times
> vfio-user: add coalesced posted writes
> vfio-user: add trace points
>
> Thanos Makatos (1):
> vfio-user: introduce vfio-user protocol specification
>
> MAINTAINERS | 11 +
> docs/devel/index-internals.rst | 1 +
> docs/devel/vfio-user.rst | 1522 ++++++++++++++++++++++++++++++++
> hw/vfio/Kconfig | 10 +
> hw/vfio/ap.c | 1 +
> hw/vfio/ccw.c | 7 +-
> hw/vfio/common.c | 648 ++++++++++++--
> hw/vfio/igd.c | 23 +-
> hw/vfio/meson.build | 1 +
> hw/vfio/migration.c | 2 -
> hw/vfio/pci-quirks.c | 19 +-
> hw/vfio/pci.c | 926 ++++++++++++++-----
> hw/vfio/pci.h | 29 +-
> hw/vfio/platform.c | 2 +
> hw/vfio/trace-events | 15 +
> hw/vfio/user-protocol.h | 244 +++++
> hw/vfio/user.c | 1904 ++++++++++++++++++++++++++++++++++++++++
> hw/vfio/user.h | 112 +++
> include/hw/vfio/vfio-common.h | 82 ++
> 19 files changed, 5230 insertions(+), 329 deletions(-)
> create mode 100644 docs/devel/vfio-user.rst
> create mode 100644 hw/vfio/user-protocol.h
> create mode 100644 hw/vfio/user.c
> create mode 100644 hw/vfio/user.h
>
^ permalink raw reply [flat|nested] 82+ messages in thread
* Re: [PATCH v1 00/24] vfio-user client
2022-12-16 11:31 ` Cédric Le Goater
@ 2023-02-02 5:20 ` John Johnson
0 siblings, 0 replies; 82+ messages in thread
From: John Johnson @ 2023-02-02 5:20 UTC (permalink / raw)
To: Cédric Le Goater; +Cc: qemu-devel
> On Dec 16, 2022, at 3:31 AM, Cédric Le Goater <clg@redhat.com> wrote:
>
> On 11/9/22 00:13, John Johnson wrote:
>> Hello,
>> This is the 6th revision of the vfio-user client implementation.
>> It is the first patch series (the previous revisions were RFCs)
>> First of all, thank you for your time reviewing the RFC 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 upstreamed a patch series that implement a server using QEMU.
>
> Thanks for this contribution,
>
Thank you for taking the time to review it
>
> This is a large and complex framework which looks quite mature. QEMU
> would need implementations of remote devices under contrib/, provided
> as examples for the QEMU crowd. These are important to show possible
> use cases and also, they could possibly be run for non regression tests
> done by maintainers and distros. e1000e is quite popular, it would
> be a good target. It could be a simpler device to start with, but we
> would need to cover the basic features, INTx, MSI, DMA, etc. when time
> permits. There are samples under libvfio-user and I wonder how we
> could leverage them.
>
A QEMU server patch is already upstream, which allows QEMU to
act as a vfio-user device server. We’ve tested with some disk devices
(mpt, lsi895)
> Unit tests under /tests would be (really) good to have. These would be
> run by CI. Yes, this is a lot of work :/ but very important for QEMU
> stability.
>
We have an avocado test using an mpt disk controller that didn’t
get pushed with the server changes since the client isn’t upstream. I’ll
add it to this patch series.
> The "socket" name property is not the preferred way in QEMU to define
> a remote peer to contact. Is there a possibility to use the chardev
> interface in some simple way ? I am thinking about the command line
> interface and the integration with libvirt.
>
I was asked to look at using the socket command line parser,
but its visitor function doesn’t work with device property list options,
so the compromise was to use a SocketAddress as the argument to
vfio_user_connect_dev, so vfio-user can be changed without much work if
the visitor changes.
> More code should be isolated under the *user.c file, even if that
> means exporting definitions of routines which are local today. I don't
> think the #ifdef CONFIG_VIO_USER in the vfio files are something we
> will want to merge.
>
> Some renaming to be done, like Kern -> Kernel, etc. nothing major.
>
> I am not convinced that the macros hiding the VFIO backend IO ops are
> useful. I even recall some places where the vfio-user implemented
> handler could be called directly without calling the top routine first.
> Anyhow, it would be better to be explicit, the macros don't add much.
>
I have a patch series that renames the struct to your preference
and removes the virtual function macros. It will be out shortly.
> There is a lot of code duplication for the IOMMU support. Did you
> consider implementing a VFIOGroup class to share the common behaviour ?
> May be too early, but this is certainly something to keep in mind.
>
I did refactor the IOMMU group code so vfio-user and the kernel
version can share common.c routines. I hope this helps.
> The msg recycling feature looks nice but isn't it an optimization ?
>
It was done more as a place to hold bug catching code than as
an optimization. e.g., If I misplace a msg, I can usually find it on
free list.
> More globally speaking, for what kind of crazy setup this feature could
> help us with ? I was wondering if you had tried to implement a remote
> device or bridge in another QEMU process, for instance.
> \
We arrived at this setup from a KVM forum in 2019, where several
groups wanted to do device emulation outside the VMM for security and
perfomance reasons. We merged a couple projects together into vfio-user.
Thanks again for the feedback.
JJ
^ permalink raw reply [flat|nested] 82+ messages in thread
* Re: [PATCH v1 04/24] vfio-user: add region cache
2022-12-12 11:42 ` Philippe Mathieu-Daudé
@ 2023-02-02 5:21 ` John Johnson
0 siblings, 0 replies; 82+ messages in thread
From: John Johnson @ 2023-02-02 5:21 UTC (permalink / raw)
To: Philippe Mathieu-Daudé; +Cc: QEMU Devel Mailing List
> On Dec 12, 2022, at 3:42 AM, Philippe Mathieu-Daudé <philmd@linaro.org> wrote:
>
> On 9/11/22 00:13, John Johnson wrote:
>> cache VFIO_DEVICE_GET_REGION_INFO results to reduce
>> memory alloc/free cycles and as prep work for vfio-user
>> Signed-off-by: John G Johnson <john.g.johnson@oracle.com>
>> Signed-off-by: Elena Ufimtseva <elena.ufimtseva@oracle.com>
>> Signed-off-by: Jagannathan Raman <jag.raman@oracle.com>
>> ---
>> hw/vfio/ccw.c | 5 -----
>> hw/vfio/common.c | 41 +++++++++++++++++++++++++++++++++++------
>> hw/vfio/igd.c | 23 +++++++++--------------
>> hw/vfio/migration.c | 2 --
>> hw/vfio/pci-quirks.c | 19 +++++--------------
>> hw/vfio/pci.c | 8 --------
>> include/hw/vfio/vfio-common.h | 2 ++
>> 7 files changed, 51 insertions(+), 49 deletions(-)
>
>
>> void vfio_put_base_device(VFIODevice *vbasedev)
>> {
>> + if (vbasedev->regions != NULL) {
>> + int i;
>> +
>> + for (i = 0; i < vbasedev->num_regions; i++) {
>> + g_free(vbasedev->regions[i]);
>> + }
>> + g_free(vbasedev->regions);
>> + vbasedev->regions = NULL;
>> + }
>> +
>> if (!vbasedev->group) {
>> return;
>> }
>> @@ -2432,6 +2451,17 @@ int vfio_get_region_info(VFIODevice *vbasedev, int index,
>> {
>> size_t argsz = sizeof(struct vfio_region_info);
>> + /* create region cache */
>> + if (vbasedev->regions == NULL) {
>> + vbasedev->regions = g_new0(struct vfio_region_info *,
>> + vbasedev->num_regions);
>> + }
>> + /* check cache */
>> + if (vbasedev->regions[index] != NULL) {
>> + *info = vbasedev->regions[index];
>> + return 0;
>> + }
>
> What about simply allocating/releasing once regions[] in
> vfio_instance_init / vfio_instance_finalize?
I think this is done already, except with _realize and _instance_finalize.
e.g,, vfio_realize() -> vfio_get_device() -> vfio_get_all_regions allocates
and
vfio_instance_finalize -> vfio_put_device -> vfio_put_base_device deallocates
JJ
^ permalink raw reply [flat|nested] 82+ messages in thread
* Re: [PATCH v1 14/24] vfio-user: get and set IRQs
2022-12-13 16:39 ` Cédric Le Goater
2022-12-13 23:10 ` John Johnson
@ 2023-02-02 5:21 ` John Johnson
1 sibling, 0 replies; 82+ messages in thread
From: John Johnson @ 2023-02-02 5:21 UTC (permalink / raw)
To: Cédric Le Goater; +Cc: qemu-devel
> On Dec 13, 2022, at 8:39 AM, Cédric Le Goater <clg@redhat.com> wrote:
>
> On 11/9/22 00:13, John Johnson wrote:
>>
>> diff --git a/hw/vfio/pci.c b/hw/vfio/pci.c
>> index 7abe44e..be39a4e 100644
>> --- a/hw/vfio/pci.c
>> +++ b/hw/vfio/pci.c
>> @@ -713,7 +713,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));
>
> This change belongs to another patch.
>
This is the patch where errno may not be set because
vfio_enable_vectors() didn’t make a syscall.
JJ
^ permalink raw reply [flat|nested] 82+ messages in thread
* Re: [PATCH v1 09/24] vfio-user: define socket send functions
2022-12-13 13:48 ` Cédric Le Goater
@ 2023-02-02 5:21 ` John Johnson
0 siblings, 0 replies; 82+ messages in thread
From: John Johnson @ 2023-02-02 5:21 UTC (permalink / raw)
To: Cédric Le Goater; +Cc: qemu-devel
> On Dec 13, 2022, at 5:48 AM, Cédric Le Goater <clg@redhat.com> wrote:
>
> On 11/9/22 00:13, John Johnson wrote:
>>
>> +
>> +static struct cap_entry ver_0_0[] = {
>> + { VFIO_USER_CAP, check_cap },
>> + { NULL }
>> +};
>> +
>> +static int caps_check(VFIOProxy *proxy, int minor, const char *caps,
>
> what is the minor parameter for ?
>
So we can make forward compatible changes to the protocol.
JJ
^ permalink raw reply [flat|nested] 82+ messages in thread
end of thread, other threads:[~2023-02-02 5:22 UTC | newest]
Thread overview: 82+ messages (download: mbox.gz / follow: Atom feed)
-- links below jump to the message on this page --
2022-11-08 23:13 [PATCH v1 00/24] vfio-user client John Johnson
2022-11-08 23:13 ` [PATCH v1 01/24] vfio-user: introduce vfio-user protocol specification John Johnson
2022-11-08 23:13 ` [PATCH v1 02/24] vfio-user: add VFIO base abstract class John Johnson
2022-12-09 13:54 ` John Levon
2022-12-09 16:04 ` Cédric Le Goater
2022-12-12 20:30 ` John Johnson
2022-11-08 23:13 ` [PATCH v1 03/24] vfio-user: add container IO ops vector John Johnson
2022-12-09 14:10 ` John Levon
2022-12-09 16:10 ` Cédric Le Goater
2022-12-12 9:40 ` Philippe Mathieu-Daudé
2022-11-08 23:13 ` [PATCH v1 04/24] vfio-user: add region cache John Johnson
2022-12-09 14:15 ` John Levon
2022-12-12 7:44 ` Cédric Le Goater
2022-12-12 11:42 ` Philippe Mathieu-Daudé
2023-02-02 5:21 ` John Johnson
2022-11-08 23:13 ` [PATCH v1 05/24] vfio-user: add device IO ops vector John Johnson
2022-12-09 14:43 ` John Levon
2022-12-12 7:59 ` Cédric Le Goater
2022-11-08 23:13 ` [PATCH v1 06/24] vfio-user: Define type vfio_user_pci_dev_info John Johnson
2022-12-09 15:23 ` John Levon
2022-12-12 9:01 ` Cédric Le Goater
2022-12-12 11:03 ` John Levon
2022-12-12 11:46 ` Philippe Mathieu-Daudé
2022-12-12 20:44 ` John Johnson
2022-12-12 21:32 ` John Johnson
2022-11-08 23:13 ` [PATCH v1 07/24] vfio-user: connect vfio proxy to remote server John Johnson
2022-12-09 15:23 ` John Levon
2022-12-12 16:24 ` Cédric Le Goater
2022-11-08 23:13 ` [PATCH v1 08/24] vfio-user: define socket receive functions John Johnson
2022-12-09 15:34 ` John Levon
2022-12-13 10:45 ` Cédric Le Goater
2022-11-08 23:13 ` [PATCH v1 09/24] vfio-user: define socket send functions John Johnson
2022-12-09 15:52 ` John Levon
2022-12-13 13:48 ` Cédric Le Goater
2023-02-02 5:21 ` John Johnson
2022-11-08 23:13 ` [PATCH v1 10/24] vfio-user: get device info John Johnson
2022-12-09 15:57 ` John Levon
2022-12-12 20:28 ` John Johnson
2022-12-13 14:06 ` Cédric Le Goater
2022-11-08 23:13 ` [PATCH v1 11/24] vfio-user: get region info John Johnson
2022-12-09 17:04 ` John Levon
2022-12-13 15:15 ` Cédric Le Goater
2022-11-08 23:13 ` [PATCH v1 12/24] vfio-user: region read/write John Johnson
2022-12-09 17:11 ` John Levon
2022-12-13 16:13 ` Cédric Le Goater
2022-11-08 23:13 ` [PATCH v1 13/24] vfio-user: pci_user_realize PCI setup John Johnson
2022-12-09 17:22 ` John Levon
2022-12-13 16:13 ` Cédric Le Goater
2022-11-08 23:13 ` [PATCH v1 14/24] vfio-user: get and set IRQs John Johnson
2022-12-09 17:29 ` John Levon
2022-12-12 20:28 ` John Johnson
2022-12-13 16:39 ` Cédric Le Goater
2022-12-13 23:10 ` John Johnson
2023-02-02 5:21 ` John Johnson
2022-11-08 23:13 ` [PATCH v1 15/24] vfio-user: forward msix BAR accesses to server John Johnson
2022-12-09 17:45 ` John Levon
2022-12-14 17:00 ` Cédric Le Goater
2022-11-08 23:13 ` [PATCH v1 16/24] vfio-user: proxy container connect/disconnect John Johnson
2022-12-09 17:54 ` John Levon
2022-12-14 17:59 ` Cédric Le Goater
2022-11-08 23:13 ` [PATCH v1 17/24] vfio-user: dma map/unmap operations John Johnson
2022-12-15 12:39 ` Cédric Le Goater
2022-11-08 23:13 ` [PATCH v1 18/24] vfio-user: add dma_unmap_all John Johnson
2022-12-09 17:58 ` John Levon
2022-11-08 23:13 ` [PATCH v1 19/24] vfio-user: secure DMA support John Johnson
2022-12-09 18:01 ` John Levon
2022-12-12 20:31 ` John Johnson
2022-11-08 23:13 ` [PATCH v1 20/24] vfio-user: dma read/write operations John Johnson
2022-12-09 18:11 ` John Levon
2022-11-08 23:13 ` [PATCH v1 21/24] vfio-user: pci reset John Johnson
2022-12-09 18:13 ` John Levon
2022-11-08 23:13 ` [PATCH v1 22/24] vfio-user: add 'x-msg-timeout' option that specifies msg wait times John Johnson
2022-12-09 18:14 ` John Levon
2022-12-15 12:56 ` Cédric Le Goater
2022-12-16 4:22 ` John Johnson
2022-11-08 23:13 ` [PATCH v1 23/24] vfio-user: add coalesced posted writes John Johnson
2022-12-09 18:16 ` John Levon
2022-11-08 23:13 ` [PATCH v1 24/24] vfio-user: add trace points John Johnson
2022-12-15 12:59 ` Cédric Le Goater
2022-12-12 9:41 ` [PATCH v1 00/24] vfio-user client Philippe Mathieu-Daudé
2022-12-16 11:31 ` Cédric Le Goater
2023-02-02 5:20 ` John Johnson
This is an external index of several public inboxes,
see mirroring instructions on how to clone and mirror
all data and code used by this external index.