initial ioeventfd support (#601)

Provide initial support for handling VFIO_USER_DEVICE_GET_REGION_IO_FDS, along with a new vfu_create_ioeventfd() API.

Reviewed-by: John Levon <john.levon@nutanix.com>

2 files changed, 392 insertions, 1 deletions

diff --git a/test/py/libvfio_user.py b/test/py/libvfio_user.py
index bf3e9cd..1ad5db5 100644
--- a/test/py/libvfio_user.py
+++ b/test/py/libvfio_user.py
@@ -34,6 +34,7 @@
 from collections import namedtuple
 from types import SimpleNamespace
 import ctypes as c
+import array
 import errno
 import json
 import mmap
@@ -170,6 +171,10 @@ VFIO_IOMMU_DIRTY_PAGES_FLAG_START = (1 << 0)
 VFIO_IOMMU_DIRTY_PAGES_FLAG_STOP = (1 << 1)
 VFIO_IOMMU_DIRTY_PAGES_FLAG_GET_BITMAP = (1 << 2)
 
+VFIO_USER_IO_FD_TYPE_IOEVENTFD = 0
+VFIO_USER_IO_FD_TYPE_IOREGIONFD = 1
+
+
 # enum vfu_dev_irq_type
 VFU_DEV_INTX_IRQ = 0
 VFU_DEV_MSI_IRQ  = 1
@@ -329,6 +334,55 @@ class vfio_region_sparse_mmap_area(Structure):
         ("size", c.c_uint64),
     ]
 
+class vfio_user_region_io_fds_request(Structure):
+    _pack_ = 1
+    _fields_ = [
+        ("argsz", c.c_uint32),
+        ("flags", c.c_uint32),
+        ("index", c.c_uint32),
+        ("count", c.c_uint32)
+    ]
+
+class vfio_user_sub_region_ioeventfd(Structure):
+    _pack_ = 1
+    _fields_ = [
+        ("offset", c.c_uint64),
+        ("size", c.c_uint64),
+        ("fd_index", c.c_uint32),
+        ("type", c.c_uint32),
+        ("flags", c.c_uint32),
+        ("padding", c.c_uint32),
+        ("datamatch", c.c_uint64)
+    ]
+
+class vfio_user_sub_region_ioregionfd(Structure):
+    _pack_ = 1
+    _fields_ = [
+        ("offset", c.c_uint64),
+        ("size", c.c_uint64),
+        ("fd_index", c.c_uint32),
+        ("type", c.c_uint32),
+        ("flags", c.c_uint32),
+        ("padding", c.c_uint32),
+        ("user_data", c.c_uint64)
+    ]
+
+class vfio_user_sub_region_io_fd(c.Union):
+    _pack_ = 1
+    _fields_ = [
+        ("sub_region_ioeventfd", vfio_user_sub_region_ioeventfd),
+        ("sub_region_ioregionfd", vfio_user_sub_region_ioregionfd)
+    ]
+
+class vfio_user_region_io_fds_reply(Structure):
+    _pack_ = 1
+    _fields_ = [
+        ("argsz", c.c_uint32),
+        ("flags", c.c_uint32),
+        ("index", c.c_uint32),
+        ("count", c.c_uint32)
+    ]
+
 class vfio_user_dma_map(Structure):
     _pack_ = 1
     _fields_ = [
@@ -406,7 +460,7 @@ class dma_sg_t(Structure):
         ("length", c.c_uint64),
         ("offset", c.c_uint64),
         ("writeable", c.c_bool),
-        ("le_next", c.c_void_p), # FIXME add struct for LIST_ENTRY 
+        ("le_next", c.c_void_p), # FIXME add struct for LIST_ENTRY
         ("le_prev", c.c_void_p),
     ]
 
@@ -455,6 +509,11 @@ lib.vfu_map_sg.argtypes = (c.c_void_p, c.POINTER(dma_sg_t), c.POINTER(iovec_t),
 lib.vfu_unmap_sg.argtypes = (c.c_void_p, c.POINTER(dma_sg_t),
                              c.POINTER(iovec_t), c.c_int)
 
+lib.vfu_create_ioeventfd.argtypes = (c.c_void_p, c.c_uint32, c.c_int,
+                                     c.c_size_t, c.c_uint32, c.c_uint32,
+                                     c.c_uint64)
+
+
 def to_byte(val):
     """Cast an int to a byte value."""
     return val.to_bytes(1, 'little')
@@ -519,6 +578,40 @@ def msg(ctx, sock, cmd, payload, expect=0, fds=None):
 
     return get_reply(sock, expect=expect)
 
+def get_reply_fds(sock, expect=0):
+    """Receives a message from a socket and pulls the returned file descriptors
+       out of the message."""
+    fds = array.array("i")
+    data, ancillary, flags, addr = sock.recvmsg(4096,
+                                            socket.CMSG_LEN(64 * fds.itemsize))
+    (msg_id, cmd, msg_size, msg_flags, errno) = struct.unpack("HHIII",
+                                                              data[0:16])
+    assert errno == expect
+
+    cmsg_level, cmsg_type, packed_fd = ancillary[0] if len(ancillary) != 0 else \
+                                        (0, 0, [])
+    unpacked_fds = []
+    for i in range(0, len(packed_fd), 4):
+        [unpacked_fd] = struct.unpack_from("i", packed_fd, offset = i)
+        unpacked_fds.append(unpacked_fd)
+    assert len(packed_fd)/4 == len(unpacked_fds)
+    assert (msg_flags & VFIO_USER_F_TYPE_REPLY) != 0
+    return (unpacked_fds, data[16:])
+
+def msg_fds(ctx, sock, cmd, payload, expect=0, fds=None):
+    """Round trip a request and reply to the server. With the server returning
+       new fds"""
+    hdr = vfio_user_header(cmd, size=len(payload))
+
+    if fds:
+        sock.sendmsg([hdr + payload], [(socket.SOL_SOCKET, socket.SCM_RIGHTS,
+                                        struct.pack("I" * len(fds), *fds))])
+    else:
+        sock.send(hdr + payload)
+
+    vfu_run_ctx(ctx)
+    return get_reply_fds(sock, expect=expect)
+
 def get_pci_header(ctx):
     ptr = lib.vfu_pci_get_config_space(ctx)
     return c.cast(ptr, c.POINTER(vfu_pci_hdr_t)).contents
@@ -761,4 +854,8 @@ def vfu_map_sg(ctx, sg, iovec, cnt=1, flags=0):
 def vfu_unmap_sg(ctx, sg, iovec, cnt=1):
     return lib.vfu_unmap_sg(ctx, sg, iovec, cnt)
 
+def vfu_create_ioeventfd(ctx, region_idx, fd, offset, size, flags, datamatch):
+    assert ctx != None
+
+    return lib.vfu_create_ioeventfd(ctx, region_idx, fd, offset, size, flags, datamatch)
 # ex: set tabstop=4 shiftwidth=4 softtabstop=4 expandtab: #
diff --git a/test/py/test_device_get_region_io_fds.py b/test/py/test_device_get_region_io_fds.py
new file mode 100644
index 0000000..ab29dbb
--- /dev/null
+++ b/test/py/test_device_get_region_io_fds.py
@@ -0,0 +1,294 @@
+#
+# Copyright (c) 2021 Nutanix Inc. All rights reserved.
+#
+# Authors: Jack Kelly <jack.kelly@nutanix.com>
+#
+#  Redistribution and use in source and binary forms, with or without
+#  modification, are permitted provided that the following conditions are met:
+#      * Redistributions of source code must retain the above copyright
+#        notice, this list of conditions and the following disclaimer.
+#      * Redistributions in binary form must reproduce the above copyright
+#        notice, this list of conditions and the following disclaimer in the
+#        documentation and/or other materials provided with the distribution.
+#      * Neither the name of Nutanix nor the names of its contributors may be
+#        used to endorse or promote products derived from this software without
+#        specific prior written permission.
+#
+#  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+#  AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+#  IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+#  ARE DISCLAIMED. IN NO EVENT SHALL <COPYRIGHT HOLDER> BE LIABLE FOR ANY
+#  DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+#  (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+#  SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+#  CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+#  LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+#  OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH
+#  DAMAGE.
+#
+
+from libvfio_user import *
+import ctypes as c
+import errno
+import tempfile
+import os
+import struct
+import ctypes
+
+ctx = None
+sock = None
+fds = []
+IOEVENT_SIZE = 8
+
+def test_device_get_region_io_fds_setup():
+    global ctx, sock
+
+    ctx = vfu_create_ctx(flags=LIBVFIO_USER_FLAG_ATTACH_NB)
+    assert ctx != None
+
+    f = tempfile.TemporaryFile()
+    f.truncate(65536)
+
+    mmap_areas = [ (0x2000, 0x1000), (0x4000, 0x2000) ]
+
+    ret = vfu_setup_region(ctx, index=VFU_PCI_DEV_BAR1_REGION_IDX, size=0x8000,
+                           flags=(VFU_REGION_FLAG_RW | VFU_REGION_FLAG_MEM),
+                           mmap_areas=mmap_areas, fd=f.fileno(), offset=0x8000)
+    assert ret == 0
+
+    f = tempfile.TemporaryFile()
+    f.truncate(65536)
+
+    mmap_areas = [ (0x2000, 0x1000), (0x4000, 0x2000) ]
+
+    ret = vfu_setup_region(ctx, index=VFU_PCI_DEV_BAR2_REGION_IDX, size=0x8000,
+                           flags=(VFU_REGION_FLAG_RW | VFU_REGION_FLAG_MEM),
+                           mmap_areas=mmap_areas, fd=f.fileno(), offset=0x8000)
+    assert ret == 0
+
+    ret = vfu_realize_ctx(ctx)
+    assert ret == 0
+
+    sock = connect_client(ctx)
+    for i in range(0,6):
+        tmp = eventfd(0,0)
+        fds.append(tmp)
+        assert vfu_create_ioeventfd(ctx, VFU_PCI_DEV_BAR2_REGION_IDX, tmp,
+                                    i * IOEVENT_SIZE, IOEVENT_SIZE, 0, 0) != -1
+
+def test_device_get_region_io_fds_bad_flags():
+
+    payload = vfio_user_region_io_fds_request(
+                argsz = len(vfio_user_region_io_fds_reply()) +
+                len(vfio_user_sub_region_ioeventfd()) * 5, flags = 1,
+                index = VFU_PCI_DEV_BAR2_REGION_IDX, count = 0)
+
+    msg(ctx, sock, VFIO_USER_DEVICE_GET_REGION_IO_FDS, payload,
+        expect=errno.EINVAL)
+
+def test_device_get_region_io_fds_bad_count():
+
+    payload = vfio_user_region_io_fds_request(
+                argsz = len(vfio_user_region_io_fds_reply()) +
+                len(vfio_user_sub_region_ioeventfd()) * 5, flags = 0,
+                index = VFU_PCI_DEV_BAR2_REGION_IDX, count = 1)
+
+    msg(ctx, sock, VFIO_USER_DEVICE_GET_REGION_IO_FDS, payload,
+        expect=errno.EINVAL)
+
+def test_device_get_region_io_fds_buffer_too_small():
+
+    payload = vfio_user_region_io_fds_request(
+            argsz = len(vfio_user_region_io_fds_reply()) - 1, flags = 0,
+            index = VFU_PCI_DEV_BAR2_REGION_IDX, count = 1)
+
+    msg(ctx, sock, VFIO_USER_DEVICE_GET_REGION_IO_FDS, payload,
+        expect=errno.EINVAL)
+
+def test_device_get_region_io_fds_buffer_too_large():
+
+    payload = vfio_user_region_io_fds_request(argsz = SERVER_MAX_DATA_XFER_SIZE
+                                            + 1, flags = 0,
+                                            index = VFU_PCI_DEV_BAR2_REGION_IDX,
+                                            count = 1)
+
+    msg(ctx, sock, VFIO_USER_DEVICE_GET_REGION_IO_FDS, payload, expect =
+        errno.EINVAL)
+
+def test_device_get_region_io_fds_no_regions():
+
+    payload = vfio_user_region_io_fds_request(argsz = 512, flags = 0,
+                                index = VFU_PCI_DEV_BAR1_REGION_IDX, count = 0)
+
+    ret = msg(ctx, sock, VFIO_USER_DEVICE_GET_REGION_IO_FDS, payload, expect=0)
+
+    reply, ret = vfio_user_region_io_fds_reply.pop_from_buffer(ret)
+
+    assert reply.argsz == len(vfio_user_region_io_fds_reply())
+    assert reply.count == 0
+    assert reply.flags == 0
+    assert reply.index == VFU_PCI_DEV_BAR1_REGION_IDX
+
+
+def test_device_get_region_io_fds_no_regions_setup():
+
+    payload = vfio_user_region_io_fds_request(argsz = 512, flags = 0,
+                                index = VFU_PCI_DEV_BAR3_REGION_IDX, count = 0)
+
+    ret = msg(ctx, sock, VFIO_USER_DEVICE_GET_REGION_IO_FDS, payload,
+              expect=errno.EINVAL)
+
+def test_device_get_region_io_fds_region_out_of_range():
+
+    payload = vfio_user_region_io_fds_request(argsz = 512, flags = 0,
+                                              index = 512, count = 0)
+
+    msg(ctx, sock, VFIO_USER_DEVICE_GET_REGION_IO_FDS, payload, expect =
+        errno.EINVAL)
+
+def test_device_get_region_io_fds_fds_read_write():
+
+    payload = vfio_user_region_io_fds_request(
+                argsz = len(vfio_user_region_io_fds_reply()) +
+                len(vfio_user_sub_region_ioeventfd()) * 10, flags = 0,
+                index = VFU_PCI_DEV_BAR2_REGION_IDX, count = 0)
+
+    newfds, ret = msg_fds(ctx, sock, VFIO_USER_DEVICE_GET_REGION_IO_FDS,
+                          payload, expect=0)
+
+    assert len(newfds) == 6
+    _, ret = vfio_user_region_io_fds_reply.pop_from_buffer(ret)
+    _, ret = vfio_user_sub_region_ioeventfd.pop_from_buffer(ret)
+
+    # Simulating a VM triggering an ioeventfd and the server waking up
+
+    # Client
+    for i in range(0, len(newfds)):
+        os.write(newfds[i], c.c_ulonglong(10))
+
+    # Server
+    for i in range(0, len(newfds)):
+        out = os.read(newfds[i], IOEVENT_SIZE)
+        [out] = struct.unpack("@Q",out)
+        assert out == 10
+
+    for i in newfds:
+        os.close(i)
+
+def test_device_get_region_io_fds_full():
+
+    payload = vfio_user_region_io_fds_request(
+                argsz = len(vfio_user_region_io_fds_reply()) +
+                len(vfio_user_sub_region_ioeventfd()) * 6, flags = 0,
+                index = VFU_PCI_DEV_BAR2_REGION_IDX, count = 0)
+
+    newfds, ret = msg_fds(ctx, sock, VFIO_USER_DEVICE_GET_REGION_IO_FDS,
+                          payload, expect=0)
+
+    reply, ret = vfio_user_region_io_fds_reply.pop_from_buffer(ret)
+    assert len(newfds) == reply.count
+    ioevents = []
+    for i in range(0, reply.count):
+        ioevent, ret = vfio_user_sub_region_ioeventfd.pop_from_buffer(ret)
+        ioevents.append(ioevent)
+        os.write(newfds[ioevent.fd_index], c.c_ulonglong(1))
+
+    for i in range(0, reply.count):
+        out = os.read(newfds[ioevents[i].fd_index], ioevent.size)
+        [out] = struct.unpack("@Q",out)
+        assert out == 1
+        assert ioevents[i].size == IOEVENT_SIZE
+        assert ioevents[i].offset == 40 - (IOEVENT_SIZE * i)
+        assert ioevents[i].type == VFIO_USER_IO_FD_TYPE_IOEVENTFD
+
+    for i in newfds:
+        os.close(i)
+
+def test_device_get_region_io_fds_fds_read_write_nothing():
+
+    payload = vfio_user_region_io_fds_request(
+                argsz = len(vfio_user_region_io_fds_reply()), flags = 0,
+                index = VFU_PCI_DEV_BAR2_REGION_IDX, count = 0)
+
+    newfds, ret = msg_fds(ctx, sock, VFIO_USER_DEVICE_GET_REGION_IO_FDS,
+                          payload, expect=0)
+
+    assert len(newfds) == 0
+    reply, _ = vfio_user_region_io_fds_request.pop_from_buffer(ret)
+    assert reply.argsz == len(vfio_user_region_io_fds_reply()) + \
+                          len(vfio_user_sub_region_ioeventfd()) * 6
+
+def test_device_get_region_io_fds_fds_read_write_dupe_fd():
+    """ Test here to show that we can return mutliple sub regions with the same
+        fd_index. fd_index points to the list of fds returned from the socket as
+        returned by msg_fds. """
+
+    t = eventfd(0,0)
+    assert vfu_create_ioeventfd(ctx, VFU_PCI_DEV_BAR2_REGION_IDX, t, 6 *
+                                IOEVENT_SIZE, IOEVENT_SIZE, 0, 0) != -1
+    assert vfu_create_ioeventfd(ctx, VFU_PCI_DEV_BAR2_REGION_IDX, t, 7 *
+                                IOEVENT_SIZE, IOEVENT_SIZE, 0, 0) != -1
+
+    payload = vfio_user_region_io_fds_request(
+                argsz = len(vfio_user_region_io_fds_reply()) +
+                len(vfio_user_sub_region_ioeventfd()) * 8, flags = 0,
+                index = VFU_PCI_DEV_BAR2_REGION_IDX, count = 0)
+
+    newfds, ret = msg_fds(ctx, sock, VFIO_USER_DEVICE_GET_REGION_IO_FDS,
+                          payload, expect=0)
+    reply, ret = vfio_user_region_io_fds_reply.pop_from_buffer(ret)
+    assert len(newfds) == 7
+    assert reply.count == 8
+    assert reply.argsz == len(vfio_user_region_io_fds_reply()) + \
+                          len(vfio_user_sub_region_ioeventfd()) * 8
+
+    ioevents = []
+    for i in range(0, reply.count):
+        ioevent, ret = vfio_user_sub_region_ioeventfd.pop_from_buffer(ret)
+        ioevents.append(ioevent)
+
+    for i in range(2, 8):
+        os.write(newfds[ioevents[i].fd_index], c.c_ulonglong(1))
+
+    for i in range(2, 8):
+        out = os.read(newfds[ioevents[i].fd_index], ioevent.size)
+        [out] = struct.unpack("@Q",out)
+        assert out == 1
+        assert ioevents[i].size == IOEVENT_SIZE
+        assert ioevents[i].offset == 56 - (IOEVENT_SIZE * i)
+        assert ioevents[i].type == VFIO_USER_IO_FD_TYPE_IOEVENTFD
+
+    assert ioevents[0].fd_index == ioevents[1].fd_index
+    assert ioevents[0].offset != ioevents[1].offset
+
+    os.write(newfds[ioevents[0].fd_index], c.c_ulonglong(1))
+
+    out = os.read(newfds[ioevents[1].fd_index], ioevent.size)
+    [out] = struct.unpack("@Q",out)
+    assert out == 1
+
+    os.write(newfds[ioevents[1].fd_index], c.c_ulonglong(1))
+
+    out = os.read(newfds[ioevents[0].fd_index], ioevent.size)
+    [out] = struct.unpack("@Q",out)
+    assert out == 1
+
+    os.write(newfds[ioevents[0].fd_index], c.c_ulonglong(1))
+    out = os.read(newfds[ioevents[1].fd_index], ioevent.size)
+    [out] = struct.unpack("@Q",out)
+    assert out == 1
+
+    for i in newfds:
+        os.close(i)
+
+def test_device_get_region_io_fds_ioeventfd_invalid_size():
+
+    t = eventfd(0,0)
+    assert vfu_create_ioeventfd(ctx, VFU_PCI_DEV_BAR2_REGION_IDX, t, 0x8000
+                                -2048, 4096, 0, 0) == -1
+    os.close(t)
+
+def test_device_get_region_info_cleanup():
+    for i in fds:
+        os.close(i)
+    vfu_destroy_ctx(ctx)