Commit 6dcdd06e authored by Maxime Coquelin's avatar Maxime Coquelin Committed by Michael S. Tsirkin
Browse files

spec/vhost-user spec: Add IOMMU support 



This patch specifies and implements the master/slave communication
to support device IOTLB in slave.

The vhost_iotlb_msg structure introduced for kernel backends is
re-used, making the design close between the two backends.

An exception is the use of the secondary channel to enable the
slave to send IOTLB miss requests to the master.

Signed-off-by: default avatarMaxime Coquelin <maxime.coquelin@redhat.com>
Reviewed-by: default avatarMichael S. Tsirkin <mst@redhat.com>
Signed-off-by: default avatarMichael S. Tsirkin <mst@redhat.com>
parent 4bbeeba0

docs/specs/vhost-user.txt

+84 −0
Original line number Diff line number Diff line
@@ -97,6 +97,25 @@ Depending on the request type, payload can be: 
   log offset: offset from start of supplied file descriptor

       where logging starts (i.e. where guest address 0 would be logged)



 * An IOTLB message

   ---------------------------------------------------------

   | iova | size | user address | permissions flags | type |

   ---------------------------------------------------------



   IOVA: a 64-bit I/O virtual address programmed by the guest

   Size: a 64-bit size

   User address: a 64-bit user address

   Permissions: a 8-bit value:

    - 0: No access

    - 1: Read access

    - 2: Write access

    - 3: Read/Write access

   Type: a 8-bit IOTLB message type:

    - 1: IOTLB miss

    - 2: IOTLB update

    - 3: IOTLB invalidate

    - 4: IOTLB access fail



In QEMU the vhost-user message is implemented with the following struct:



typedef struct VhostUserMsg {
@@ -109,6 +128,7 @@ typedef struct VhostUserMsg { 
        struct vhost_vring_addr addr;

        VhostUserMemory memory;

        VhostUserLog log;

        struct vhost_iotlb_msg iotlb;

    };

} QEMU_PACKED VhostUserMsg;
@@ -253,6 +273,38 @@ Once the source has finished migration, rings will be stopped by 
the source. No further update must be done before rings are

restarted.



IOMMU support

-------------



When the VIRTIO_F_IOMMU_PLATFORM feature has been negotiated, the master

sends IOTLB entries update & invalidation by sending VHOST_USER_IOTLB_MSG

requests to the slave with a struct vhost_iotlb_msg as payload. For update

events, the iotlb payload has to be filled with the update message type (2),

the I/O virtual address, the size, the user virtual address, and the

permissions flags. Addresses and size must be within vhost memory regions set

via the VHOST_USER_SET_MEM_TABLE request. For invalidation events, the iotlb

payload has to be filled with the invalidation message type (3), the I/O virtual

address and the size. On success, the slave is expected to reply with a zero

payload, non-zero otherwise.



The slave relies on the slave communcation channel (see "Slave communication"

section below) to send IOTLB miss and access failure events, by sending

VHOST_USER_SLAVE_IOTLB_MSG requests to the master with a struct vhost_iotlb_msg

as payload. For miss events, the iotlb payload has to be filled with the miss

message type (1), the I/O virtual address and the permissions flags. For access

failure event, the iotlb payload has to be filled with the access failure

message type (4), the I/O virtual address and the permissions flags.

For synchronization purpose, the slave may rely on the reply-ack feature,

so the master may send a reply when operation is completed if the reply-ack

feature is negotiated and slaves requests a reply. For miss events, completed

operation means either master sent an update message containing the IOTLB entry

containing requested address and permission, or master sent nothing if the IOTLB

miss message is invalid (invalid IOVA or permission).



The master isn't expected to take the initiative to send IOTLB update messages,

as the slave sends IOTLB miss messages for the guest virtual memory areas it

needs to access.



Slave communication

-------------------
@@ -514,6 +566,38 @@ Master message types 
      If VHOST_USER_PROTOCOL_F_REPLY_ACK is negotiated, slave must respond

      with zero for success, non-zero otherwise.



 * VHOST_USER_IOTLB_MSG



      Id: 22

      Equivalent ioctl: N/A (equivalent to VHOST_IOTLB_MSG message type)

      Master payload: struct vhost_iotlb_msg

      Slave payload: u64



      Send IOTLB messages with struct vhost_iotlb_msg as payload.

      Master sends such requests to update and invalidate entries in the device

      IOTLB. The slave has to acknowledge the request with sending zero as u64

      payload for success, non-zero otherwise.

      This request should be send only when VIRTIO_F_IOMMU_PLATFORM feature

      has been successfully negotiated.



Slave message types

-------------------



 * VHOST_USER_SLAVE_IOTLB_MSG



      Id: 1

      Equivalent ioctl: N/A (equivalent to VHOST_IOTLB_MSG message type)

      Slave payload: struct vhost_iotlb_msg

      Master payload: N/A



      Send IOTLB messages with struct vhost_iotlb_msg as payload.

      Slave sends such requests to notify of an IOTLB miss, or an IOTLB

      access failure. If VHOST_USER_PROTOCOL_F_REPLY_ACK is negotiated,

      and slave set the VHOST_USER_NEED_REPLY flag, master must respond with

      zero when operation is successfully completed, or non-zero otherwise.

      This request should be send only when VIRTIO_F_IOMMU_PLATFORM feature

      has been successfully negotiated.



VHOST_USER_PROTOCOL_F_REPLY_ACK:

-------------------------------

The original vhost-user specification only demands replies for certain

hw/net/vhost_net.c

+1 −0
Original line number Diff line number Diff line
@@ -77,6 +77,7 @@ static const int user_feature_bits[] = { 
    VIRTIO_NET_F_HOST_UFO,

    VIRTIO_NET_F_MRG_RXBUF,

    VIRTIO_NET_F_MTU,

    VIRTIO_F_IOMMU_PLATFORM,



    /* This bit implies RARP isn't sent by QEMU out of band */

    VIRTIO_NET_F_GUEST_ANNOUNCE,

hw/virtio/vhost-user.c

+45 −3
Original line number Diff line number Diff line
@@ -62,11 +62,13 @@ typedef enum VhostUserRequest { 
    VHOST_USER_SEND_RARP = 19,

    VHOST_USER_NET_SET_MTU = 20,

    VHOST_USER_SET_SLAVE_REQ_FD = 21,

    VHOST_USER_IOTLB_MSG = 22,

    VHOST_USER_MAX

} VhostUserRequest;



typedef enum VhostUserSlaveRequest {

    VHOST_USER_SLAVE_NONE = 0,

    VHOST_USER_SLAVE_IOTLB_MSG = 1,

    VHOST_USER_SLAVE_MAX

}  VhostUserSlaveRequest;
@@ -104,6 +106,7 @@ typedef struct VhostUserMsg { 
        struct vhost_vring_addr addr;

        VhostUserMemory memory;

        VhostUserLog log;

        struct vhost_iotlb_msg iotlb;

    } payload;

} QEMU_PACKED VhostUserMsg;
@@ -615,6 +618,9 @@ static void slave_read(void *opaque) 
    }



    switch (msg.request) {

    case VHOST_USER_SLAVE_IOTLB_MSG:

        ret = vhost_backend_handle_iotlb_msg(dev, &msg.payload.iotlb);

        break;

    default:

        error_report("Received unexpected msg type.");

        ret = -EINVAL;
@@ -697,7 +703,7 @@ out: 


static int vhost_user_init(struct vhost_dev *dev, void *opaque)

{

    uint64_t features;

    uint64_t features, protocol_features;

    struct vhost_user *u;

    int err;
@@ -717,12 +723,13 @@ static int vhost_user_init(struct vhost_dev *dev, void *opaque) 
        dev->backend_features |= 1ULL << VHOST_USER_F_PROTOCOL_FEATURES;



        err = vhost_user_get_u64(dev, VHOST_USER_GET_PROTOCOL_FEATURES,

                                 &features);

                                 &protocol_features);

        if (err < 0) {

            return err;

        }



        dev->protocol_features = features & VHOST_USER_PROTOCOL_FEATURE_MASK;

        dev->protocol_features =

            protocol_features & VHOST_USER_PROTOCOL_FEATURE_MASK;

        err = vhost_user_set_protocol_features(dev, dev->protocol_features);

        if (err < 0) {

            return err;
@@ -736,6 +743,16 @@ static int vhost_user_init(struct vhost_dev *dev, void *opaque) 
                return err;

            }

        }



        if (virtio_has_feature(features, VIRTIO_F_IOMMU_PLATFORM) &&

                !(virtio_has_feature(dev->protocol_features,

                    VHOST_USER_PROTOCOL_F_SLAVE_REQ) &&

                 virtio_has_feature(dev->protocol_features,

                    VHOST_USER_PROTOCOL_F_REPLY_ACK))) {

            error_report("IOMMU support requires reply-ack and "

                         "slave-req protocol features.");

            return -1;

        }

    }



    if (dev->migration_blocker == NULL &&
@@ -862,6 +879,29 @@ static int vhost_user_net_set_mtu(struct vhost_dev *dev, uint16_t mtu) 
    return 0;

}



static int vhost_user_send_device_iotlb_msg(struct vhost_dev *dev,

                                            struct vhost_iotlb_msg *imsg)

{

    VhostUserMsg msg = {

        .request = VHOST_USER_IOTLB_MSG,

        .size = sizeof(msg.payload.iotlb),

        .flags = VHOST_USER_VERSION | VHOST_USER_NEED_REPLY_MASK,

        .payload.iotlb = *imsg,

    };



    if (vhost_user_write(dev, &msg, NULL, 0) < 0) {

        return -EFAULT;

    }



    return process_message_reply(dev, &msg);

}





static void vhost_user_set_iotlb_callback(struct vhost_dev *dev, int enabled)

{

    /* No-op as the receive channel is not dedicated to IOTLB messages. */

}



const VhostOps user_ops = {

        .backend_type = VHOST_BACKEND_TYPE_USER,

        .vhost_backend_init = vhost_user_init,
@@ -886,4 +926,6 @@ const VhostOps user_ops = { 
        .vhost_migration_done = vhost_user_migration_done,

        .vhost_backend_can_merge = vhost_user_can_merge,

        .vhost_net_set_mtu = vhost_user_net_set_mtu,

        .vhost_set_iotlb_callback = vhost_user_set_iotlb_callback,

        .vhost_send_device_iotlb_msg = vhost_user_send_device_iotlb_msg,

};