support for shadow ioeventfd (#698)

When an ioeventfd is written to, KVM discards the value since it has no
memory to write it to, and simply kicks the eventfd. This a problem for
devices such a NVMe controllers that need the value (e.g. doorbells on
BAR0). This patch allows the vfio-user server to pass a file descriptor
that can be mmap'ed and KVM can write the ioeventfd value to this
_shadow_ memory instead of discarding it. This shadow memory is not
exposed to the guest.

Signed-off-by: Thanos Makatos <thanos.makatos@nutanix.com>
Reviewed-by: John Levon <john.levon@nutanix.com>
Change-Id: Iad849c94076ffa5988e034c8bf7ec312d01f095f

5 files changed, 121 insertions, 8 deletions

diff --git a/test/py/libvfio_user.py b/test/py/libvfio_user.py
index 0ebf773..c852542 100644
--- a/test/py/libvfio_user.py
+++ b/test/py/libvfio_user.py
@@ -194,6 +194,7 @@ VFIO_IOMMU_DIRTY_PAGES_FLAG_GET_BITMAP = (1 << 2)
 
 VFIO_USER_IO_FD_TYPE_IOEVENTFD = 0
 VFIO_USER_IO_FD_TYPE_IOREGIONFD = 1
+VFIO_USER_IO_FD_TYPE_IOEVENTFD_SHADOW = 2
 
 
 # enum vfu_dev_irq_type
@@ -620,7 +621,7 @@ lib.vfu_sgl_put.argtypes = (c.c_void_p, c.POINTER(dma_sg_t),
 
 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)
+                                     c.c_uint64, c.c_int32)
 
 lib.vfu_device_quiesced.argtypes = (c.c_void_p, c.c_int)
 
@@ -635,6 +636,10 @@ def to_byte(val):
     return val.to_bytes(1, 'little')
 
 
+def to_bytes_le(n, length=1):
+    return n.to_bytes(length, 'little')
+
+
 def skip(fmt, buf):
     """Return the data remaining after skipping the given elements."""
     return buf[struct.calcsize(fmt):]
@@ -645,6 +650,9 @@ def parse_json(json_str):
     return json.loads(json_str, object_hook=lambda d: SimpleNamespace(**d))
 
 
+IOEVENT_SIZE = 8
+
+
 def eventfd(initval=0, flags=0):
     libc.eventfd.argtypes = (c.c_uint, c.c_int)
     return libc.eventfd(initval, flags)
@@ -1184,11 +1192,12 @@ def vfu_sgl_put(ctx, sg, iovec, cnt=1):
     return lib.vfu_sgl_put(ctx, sg, iovec, cnt)
 
 
-def vfu_create_ioeventfd(ctx, region_idx, fd, offset, size, flags, datamatch):
+def vfu_create_ioeventfd(ctx, region_idx, fd, offset, size, flags, datamatch,
+                         shadow_fd=-1):
     assert ctx is not None
 
     return lib.vfu_create_ioeventfd(ctx, region_idx, fd, offset, size,
-                                    flags, datamatch)
+                                    flags, datamatch, shadow_fd)
 
 
 def vfu_device_quiesced(ctx, err):
diff --git a/test/py/meson.build b/test/py/meson.build
index d9c97b3..0ea9f08 100644
--- a/test/py/meson.build
+++ b/test/py/meson.build
@@ -49,6 +49,10 @@ python_tests = [
     'test_vfu_realize_ctx.py',
 ]
 
+if get_option('shadow-ioeventfd')
+    python_tests += 'test_shadow_ioeventfd.py'
+endif
+
 python_files = python_tests_common + python_tests
 
 if pytest.found() and opt_sanitizers == 'none'
diff --git a/test/py/test_device_get_region_io_fds.py b/test/py/test_device_get_region_io_fds.py
index cb1b732..924f462 100644
--- a/test/py/test_device_get_region_io_fds.py
+++ b/test/py/test_device_get_region_io_fds.py
@@ -36,7 +36,6 @@ import struct
 ctx = None
 sock = None
 fds = []
-IOEVENT_SIZE = 8
 
 
 def test_device_get_region_io_fds_setup():
diff --git a/test/py/test_pci_caps.py b/test/py/test_pci_caps.py
index b83c06c..01f23a2 100644
--- a/test/py/test_pci_caps.py
+++ b/test/py/test_pci_caps.py
@@ -349,10 +349,6 @@ def test_pci_cap_write_px(mock_quiesce, mock_reset):
                          expect=errno.EINVAL)
 
 
-def to_bytes_le(n, length=1):
-    return n.to_bytes(length, 'little')
-
-
 def test_pci_cap_write_msix():
     setup_pci_dev(realize=True)
     sock = connect_client(ctx)
diff --git a/test/py/test_shadow_ioeventfd.py b/test/py/test_shadow_ioeventfd.py
new file mode 100644
index 0000000..642ad0e
--- /dev/null
+++ b/test/py/test_shadow_ioeventfd.py
@@ -0,0 +1,105 @@
+#
+# Copyright (c) 2022 Nutanix Inc. All rights reserved.
+#
+# Authors: Thanos Makatos <thanos.makatos@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 tempfile
+import mmap
+import errno
+
+
+def test_shadow_ioeventfd():
+    """Configure a shadow ioeventfd, have the client trigger it, confirm that
+    the server receives the notification and can see the value."""
+
+    # server setup
+    ctx = vfu_create_ctx(flags=LIBVFIO_USER_FLAG_ATTACH_NB)
+    assert ctx is not None
+    ret = vfu_setup_region(ctx, index=VFU_PCI_DEV_BAR0_REGION_IDX, size=0x1000,
+                           flags=VFU_REGION_FLAG_RW)
+    assert ret == 0
+    fo = tempfile.TemporaryFile(dir="/dev/shm")
+    fo.truncate(0x1000)
+
+    # FIXME
+    # Use pip install eventfd?
+    #   $ grep EFD_NONBLOCK -wr /usr/include/
+    #   /usr/include/bits/eventfd.h:    EFD_NONBLOCK = 00004000
+    EFD_NONBLOCK = 0o00004000
+
+    efd = eventfd(flags=EFD_NONBLOCK)
+    ret = vfu_create_ioeventfd(ctx, VFU_PCI_DEV_BAR0_REGION_IDX, efd, 0x8,
+                               0x16, 0, 0, shadow_fd=fo.fileno())
+    assert ret == 0
+    ret = vfu_realize_ctx(ctx)
+    assert ret == 0
+
+    # client queries I/O region FDs
+    sock = connect_client(ctx)
+    payload = vfio_user_region_io_fds_request(
+                argsz=len(vfio_user_region_io_fds_reply()) +
+                len(vfio_user_sub_region_ioeventfd()), flags=0,
+                index=VFU_PCI_DEV_BAR0_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 reply.count == 1  # 1 eventfd
+    ioevent, _ = vfio_user_sub_region_ioeventfd.pop_from_buffer(ret)
+    assert ioevent.offset == 0x8
+    assert ioevent.size == 0x16
+    assert ioevent.fd_index == 0
+    assert ioevent.type == VFIO_USER_IO_FD_TYPE_IOEVENTFD_SHADOW
+    assert ioevent.flags == 0
+    assert ioevent.datamatch == 0
+
+    assert len(newfds) == 2  # 2 FDs: eventfd plus shadow FD
+    cefd = newfds[0]
+    csfd = newfds[1]
+    cmem = mmap.mmap(csfd, 0x1000)
+
+    # vfio-user app reads the eventfd, there should be nothing there
+    try:
+        os.read(efd, IOEVENT_SIZE)
+    except BlockingIOError as e:
+        if e.errno != errno.EAGAIN:
+            assert False
+    else:
+        assert False
+
+    # Client writes to the I/O region. The write to the eventfd would be done
+    # by KVM and the value would be the same in both cases.
+    cmem.seek(0x8)
+    cmem.write(c.c_ulonglong(0xdeadbeef))
+    os.write(cefd, c.c_ulonglong(0xcafebabe))
+
+    # vfio-user app reads eventfd
+    assert os.read(efd, IOEVENT_SIZE) == to_bytes_le(0xcafebabe, 8)
+    fo.seek(0x8)
+    assert fo.read(0x8) == to_bytes_le(0xdeadbeef, 8)
+
+    vfu_destroy_ctx(ctx)