python tests: add VFIO_USER_DEVICE_GET_REGION_INFO (#471)

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

2 files changed, 318 insertions, 38 deletions

diff --git a/test/py/libvfio_user.py b/test/py/libvfio_user.py
index a8127de..e889d95 100644
--- a/test/py/libvfio_user.py
+++ b/test/py/libvfio_user.py
@@ -31,6 +31,7 @@
 # Note that we don't use enum here, as class.value is a little verbose
 #
 
+from collections import namedtuple
 from types import SimpleNamespace
 import ctypes as c
 import json
@@ -70,6 +71,17 @@ PCI_EXT_CAP_VNDR_HDR_SIZEOF = 8
 VFIO_DEVICE_FLAGS_RESET = (1 << 0)
 VFIO_DEVICE_FLAGS_PCI = (1 << 1)
 
+VFIO_REGION_INFO_FLAG_READ = (1 << 0)
+VFIO_REGION_INFO_FLAG_WRITE = (1 << 1)
+VFIO_REGION_INFO_FLAG_MMAP = (1 << 2)
+VFIO_REGION_INFO_FLAG_CAPS = (1 << 3)
+
+VFIO_REGION_TYPE_MIGRATION = 3
+VFIO_REGION_SUBTYPE_MIGRATION = 1
+
+VFIO_REGION_INFO_CAP_SPARSE_MMAP = 1
+VFIO_REGION_INFO_CAP_TYPE = 2
+
 # libvfio-user defines
 
 VFU_TRANS_SOCK = 0
@@ -148,30 +160,6 @@ topdir = os.path.realpath(os.path.dirname(__file__) + "/../..")
 build_type = os.getenv("BUILD_TYPE", default="dbg")
 libname = "%s/build/%s/lib/libvfio-user.so" % (topdir, build_type)
 lib = c.CDLL(libname, use_errno=True)
-lib.vfu_create_ctx.argtypes = (c.c_int, c.c_char_p, c.c_int,
-                               c.c_void_p, c.c_int)
-lib.vfu_create_ctx.restype = (c.c_void_p)
-lib.vfu_setup_log.argtypes = (c.c_void_p, c.c_void_p, c.c_int)
-lib.vfu_realize_ctx.argtypes = (c.c_void_p,)
-lib.vfu_attach_ctx.argtypes = (c.c_void_p,)
-lib.vfu_run_ctx.argtypes = (c.c_void_p,)
-lib.vfu_destroy_ctx.argtypes = (c.c_void_p,)
-vfu_region_access_cb_t = c.CFUNCTYPE(c.c_int, c.c_void_p, c.POINTER(c.c_char),
-                                     c.c_ulong, c.c_long, c.c_bool)
-lib.vfu_setup_region.argtypes = (c.c_void_p, c.c_int, c.c_long,
-                                 vfu_region_access_cb_t, c.c_int, c.c_void_p,
-                                 c.c_uint32, c.c_int)
-lib.vfu_pci_get_config_space.argtypes = (c.c_void_p,)
-lib.vfu_pci_get_config_space.restype = (c.c_void_p)
-lib.vfu_setup_device_nr_irqs.argtypes = (c.c_void_p, c.c_int, c.c_uint32)
-lib.vfu_pci_init.argtypes = (c.c_void_p, c.c_int, c.c_int, c.c_int)
-lib.vfu_pci_add_capability.argtypes = (c.c_void_p, c.c_ulong, c.c_int,
-                                       c.POINTER(c.c_byte))
-lib.vfu_pci_find_capability.argtypes = (c.c_void_p, c.c_bool, c.c_int)
-lib.vfu_pci_find_capability.restype = (c.c_ulong)
-lib.vfu_pci_find_next_capability.argtypes = (c.c_void_p, c.c_bool, c.c_ulong,
-                                             c.c_int)
-lib.vfu_pci_find_next_capability.restype = (c.c_ulong)
 
 msg_id = 1
 
@@ -217,25 +205,58 @@ class vfu_pci_hdr_t(c.Structure):
         ("mlat", c.c_byte)
     ]
 
+class iovec_t(c.Structure):
+    _fields_ = [
+        ("iov_base", c.c_void_p),
+        ("iov_len", c.c_int)
+    ]
+
 #
 # Util functions
 #
 
+lib.vfu_create_ctx.argtypes = (c.c_int, c.c_char_p, c.c_int,
+                               c.c_void_p, c.c_int)
+lib.vfu_create_ctx.restype = (c.c_void_p)
+lib.vfu_setup_log.argtypes = (c.c_void_p, c.c_void_p, c.c_int)
+lib.vfu_realize_ctx.argtypes = (c.c_void_p,)
+lib.vfu_attach_ctx.argtypes = (c.c_void_p,)
+lib.vfu_run_ctx.argtypes = (c.c_void_p,)
+lib.vfu_destroy_ctx.argtypes = (c.c_void_p,)
+vfu_region_access_cb_t = c.CFUNCTYPE(c.c_int, c.c_void_p, c.POINTER(c.c_char),
+                                     c.c_ulong, c.c_long, c.c_bool)
+lib.vfu_setup_region.argtypes = (c.c_void_p, c.c_int, c.c_ulong,
+                                 vfu_region_access_cb_t, c.c_int, c.c_void_p,
+                                 c.c_uint32, c.c_int)
+lib.vfu_pci_get_config_space.argtypes = (c.c_void_p,)
+lib.vfu_pci_get_config_space.restype = (c.c_void_p)
+lib.vfu_setup_device_nr_irqs.argtypes = (c.c_void_p, c.c_int, c.c_uint32)
+lib.vfu_pci_init.argtypes = (c.c_void_p, c.c_int, c.c_int, c.c_int)
+lib.vfu_pci_add_capability.argtypes = (c.c_void_p, c.c_ulong, c.c_int,
+                                       c.POINTER(c.c_byte))
+lib.vfu_pci_find_capability.argtypes = (c.c_void_p, c.c_bool, c.c_int)
+lib.vfu_pci_find_capability.restype = (c.c_ulong)
+lib.vfu_pci_find_next_capability.argtypes = (c.c_void_p, c.c_bool, c.c_ulong,
+                                             c.c_int)
+lib.vfu_pci_find_next_capability.restype = (c.c_ulong)
+lib.vfu_region_to_offset.argtypes = (c.c_int,)
+lib.vfu_region_to_offset.restype = (c.c_ulong)
+
+
 def to_byte(val):
     """Cast an int to a byte value."""
     return val.to_bytes(1, 'little')
 
-def ext_cap_hdr(buf, offset):
-    """Read an extended cap header."""
-
-    # struct pcie_ext_cap_hdr
-    cap_id, cap_next = struct.unpack('HH', buf[offset:offset+4])
-    cap_next >>= 4
-    return cap_id, cap_next
-
-def skip(data, fmt):
+def skip(fmt, buf):
     """Return the data remaining after skipping the given elements."""
-    return data[struct.calcsize(fmt):]
+    return buf[struct.calcsize(fmt):]
+
+def unpack_prefix(fmt, fields, buf):
+    """Return a namedtuple unpacked from the start of buf, along with the
+       remaining buf if any."""
+    t = namedtuple('_', fields)
+    size = struct.calcsize(fmt)
+    return t._make(struct.unpack_from(fmt, buf)), skip(fmt, buf)
 
 def parse_json(json_str):
     """Parse JSON into an object with attributes (instead of using a dict)."""
@@ -249,7 +270,7 @@ def connect_sock():
 def connect_client(ctx):
     sock = connect_sock()
 
-    json = b'{ "capabilities": { "max_fds": 8 } }'
+    json = b'{ "capabilities": { "max_msg_fds": 8 } }'
     # struct vfio_user_version
     payload = struct.pack("HH%dsc" % len(json), LIBVFIO_USER_MAJOR,
                           LIBVFIO_USER_MINOR, json, b'\0')
@@ -318,7 +339,7 @@ def access_region(ctx, sock, is_write, region, offset, count,
     if is_write:
         return None
 
-    return skip(result, "QII")
+    return skip("QII", result)
 
 def write_region(ctx, sock, region, offset, count, data, expect=0):
     access_region(ctx, sock, True, region, offset, count, data, expect=expect)
@@ -326,6 +347,26 @@ def write_region(ctx, sock, region, offset, count, data, expect=0):
 def read_region(ctx, sock, region, offset, count, expect=0):
     return access_region(ctx, sock, False, region, offset, count, expect=expect)
 
+def ext_cap_hdr(buf, offset):
+    """Read an extended cap header."""
+
+    # struct pcie_ext_cap_hdr
+    cap_id, cap_next = struct.unpack_from('HH', buf, offset)
+    cap_next >>= 4
+    return cap_id, cap_next
+
+def vfio_region_info(buf):
+    return unpack_prefix("IIIIQQ", "argsz flags index cap_off size offset", buf)
+
+def vfio_region_info_cap_type(buf):
+    return unpack_prefix("HHIII", "id version next type subtype", buf)
+
+def vfio_region_info_cap_sparse_mmap(buf):
+    return unpack_prefix("HHIII", "id version next nr_areas reserved", buf)
+
+def vfio_region_sparse_mmap_area(buf):
+    return unpack_prefix("QQ", "offset size", buf)
+
 #
 # Library wrappers
 #
@@ -377,11 +418,25 @@ def vfu_destroy_ctx(ctx):
     if os.path.exists(SOCK_PATH):
         os.remove(SOCK_PATH)
 
-def vfu_setup_region(ctx, index, size, flags=0, cb=None):
+def vfu_setup_region(ctx, index, size, cb=None, flags=0,
+                     mmap_areas=None, fd=-1):
     assert ctx != None
+
+    nr_mmap_areas = 0
+    c_mmap_areas = None
+
+    if mmap_areas:
+        nr_mmap_areas = len(mmap_areas)
+        c_mmap_areas = (iovec_t * nr_mmap_areas)(*mmap_areas)
+
+    # We're sending a file descriptor to ourselves; to pretend the server is
+    # separate, we need to dup() here.
+    if fd != -1:
+        fd = os.dup(fd)
+
     ret = lib.vfu_setup_region(ctx, index, size,
                                c.cast(cb, vfu_region_access_cb_t),
-                               flags, None, 0, -1)
+                               flags, c_mmap_areas, nr_mmap_areas, fd)
     return ret
 
 def vfu_setup_device_nr_irqs(ctx, irqtype, count):
@@ -408,3 +463,6 @@ def vfu_pci_find_next_capability(ctx, extended, offset, cap_id):
     assert ctx != None
 
     return lib.vfu_pci_find_next_capability(ctx, extended, offset, cap_id)
+
+def vfu_region_to_offset(region):
+    return lib.vfu_region_to_offset(region)
diff --git a/test/py/test_device_get_region_info.py b/test/py/test_device_get_region_info.py
new file mode 100644
index 0000000..101a561
--- /dev/null
+++ b/test/py/test_device_get_region_info.py
@@ -0,0 +1,222 @@
+#
+# Copyright (c) 2021 Nutanix Inc. All rights reserved.
+#
+# Authors: John Levon <john.levon@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 errno
+import tempfile
+import os
+
+ctx = None
+sock = None
+
+def test_device_get_region_info_setup():
+    global ctx, sock
+
+    ctx = vfu_create_ctx(flags=LIBVFIO_USER_FLAG_ATTACH_NB)
+    assert ctx != None
+
+    ret = vfu_setup_region(ctx, index=VFU_PCI_DEV_BAR1_REGION_IDX, size=4096,
+                           flags=(VFU_REGION_FLAG_RW | VFU_REGION_FLAG_MEM))
+    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=0x10000,
+                           flags=(VFU_REGION_FLAG_RW | VFU_REGION_FLAG_MEM),
+                           mmap_areas=mmap_areas, fd=f.fileno())
+    assert ret == 0
+
+    f = tempfile.TemporaryFile()
+    f.truncate(0x2000)
+
+    mmap_areas = [ (0x1000, 0x1000) ]
+
+    ret = vfu_setup_region(ctx, index=VFU_PCI_DEV_MIGR_REGION_IDX, size=0x2000,
+                           flags=VFU_REGION_FLAG_RW, mmap_areas=mmap_areas,
+                           fd=f.fileno())
+    assert ret == 0
+
+    ret = vfu_realize_ctx(ctx)
+    assert ret == 0
+
+    sock = connect_client(ctx)
+
+def test_device_get_region_info_short_write():
+
+    payload = struct.pack("II", 0, 0)
+
+    hdr = vfio_user_header(VFIO_USER_DEVICE_GET_REGION_INFO, size=len(payload))
+    sock.send(hdr + payload)
+    vfu_run_ctx(ctx)
+    get_reply(sock, expect=errno.EINVAL)
+
+def test_device_get_region_info_bad_argsz():
+
+    # struct vfio_region_info
+    payload = struct.pack("IIIIQQ", 8, 0, VFU_PCI_DEV_BAR1_REGION_IDX, 0, 0, 0)
+
+    hdr = vfio_user_header(VFIO_USER_DEVICE_GET_REGION_INFO, size=len(payload))
+    sock.send(hdr + payload)
+    vfu_run_ctx(ctx)
+    get_reply(sock, expect=errno.EINVAL)
+
+def test_device_get_region_info_bad_index():
+
+    payload = struct.pack("IIIIQQ", 32, 0, VFU_PCI_DEV_NUM_REGIONS, 0, 0, 0)
+
+    hdr = vfio_user_header(VFIO_USER_DEVICE_GET_REGION_INFO, size=len(payload))
+    sock.send(hdr + payload)
+    vfu_run_ctx(ctx)
+    get_reply(sock, expect=errno.EINVAL)
+
+def test_device_get_region_info_larger_argsz():
+
+    payload = struct.pack("IIIIQQ", 32 + 8, 0, VFU_PCI_DEV_BAR1_REGION_IDX,
+                          0, 0, 0)
+
+    hdr = vfio_user_header(VFIO_USER_DEVICE_GET_REGION_INFO, size=len(payload))
+    sock.send(hdr + payload)
+    vfu_run_ctx(ctx)
+    result = get_reply(sock)
+
+    assert(len(result) == 32 + 8)
+
+    info, _ = vfio_region_info(result)
+
+    assert info.argsz == 32
+    assert info.flags == (VFIO_REGION_INFO_FLAG_READ |
+                          VFIO_REGION_INFO_FLAG_WRITE)
+    assert info.index == VFU_PCI_DEV_BAR1_REGION_IDX
+    assert info.cap_off == 0
+    assert info.size == 4096
+    assert info.offset == vfu_region_to_offset(VFU_PCI_DEV_BAR1_REGION_IDX)
+
+def test_device_get_region_info_small_argsz_caps():
+    global sock
+
+    payload = struct.pack("IIIIQQ", 32, 0, VFU_PCI_DEV_BAR2_REGION_IDX, 0, 0, 0)
+
+    hdr = vfio_user_header(VFIO_USER_DEVICE_GET_REGION_INFO, size=len(payload))
+    sock.send(hdr + payload)
+    vfu_run_ctx(ctx)
+    result = get_reply(sock)
+
+    info, _ = vfio_region_info(result)
+
+    assert info.argsz == 80
+    assert info.flags == (VFIO_REGION_INFO_FLAG_READ |
+                          VFIO_REGION_INFO_FLAG_WRITE |
+                          VFIO_REGION_INFO_FLAG_MMAP |
+                          VFIO_REGION_INFO_FLAG_CAPS)
+    assert info.index == VFU_PCI_DEV_BAR2_REGION_IDX
+    assert info.cap_off == 0
+    assert info.size == 0x10000
+    assert info.offset == vfu_region_to_offset(VFU_PCI_DEV_BAR2_REGION_IDX)
+
+    # skip reading the SCM_RIGHTS
+    disconnect_client(ctx, sock)
+
+def test_device_get_region_info_caps():
+    global sock
+
+    sock = connect_client(ctx)
+
+    payload = struct.pack("IIIIQQ", 80, 0, VFU_PCI_DEV_BAR2_REGION_IDX, 0, 0, 0)
+    payload += b'\0' * (80 - 32)
+
+    hdr = vfio_user_header(VFIO_USER_DEVICE_GET_REGION_INFO, size=len(payload))
+    sock.send(hdr + payload)
+    vfu_run_ctx(ctx)
+    result = get_reply(sock)
+
+    info, result = vfio_region_info(result)
+    cap, result = vfio_region_info_cap_sparse_mmap(result)
+    area1, result = vfio_region_sparse_mmap_area(result)
+    area2, result = vfio_region_sparse_mmap_area(result)
+
+    assert info.argsz == 80
+    assert info.cap_off == 32
+
+    assert cap.id == VFIO_REGION_INFO_CAP_SPARSE_MMAP
+    assert cap.version == 1
+    assert cap.next == 0
+    assert cap.nr_areas == 2
+
+    assert area1.offset == 0x2000
+    assert area1.size == 0x1000
+    assert area2.offset == 0x4000
+    assert area2.size == 0x2000
+
+    # skip reading the SCM_RIGHTS
+    disconnect_client(ctx, sock)
+
+def test_device_get_region_info_migr():
+    global sock
+
+    sock = connect_client(ctx)
+
+    payload = struct.pack("IIIIQQ", 80, 0, VFU_PCI_DEV_MIGR_REGION_IDX,
+                          0, 0, 0)
+    payload += b'\0' * (80 - 32)
+
+    hdr = vfio_user_header(VFIO_USER_DEVICE_GET_REGION_INFO, size=len(payload))
+    sock.send(hdr + payload)
+    vfu_run_ctx(ctx)
+    result = get_reply(sock)
+
+    info, result = vfio_region_info(result)
+    mcap, result = vfio_region_info_cap_type(result)
+    cap, result = vfio_region_info_cap_sparse_mmap(result)
+    area, result = vfio_region_sparse_mmap_area(result)
+
+    assert info.argsz == 80
+    assert info.cap_off == 32
+
+    assert mcap.id == VFIO_REGION_INFO_CAP_TYPE
+    assert mcap.version == 1
+    assert mcap.next == 48
+    assert mcap.type == VFIO_REGION_TYPE_MIGRATION
+    assert mcap.subtype == VFIO_REGION_SUBTYPE_MIGRATION
+
+    assert cap.id == VFIO_REGION_INFO_CAP_SPARSE_MMAP
+    assert cap.version == 1
+    assert cap.next == 0
+    assert cap.nr_areas == 1
+
+    assert area.offset == 0x1000
+    assert area.size == 0x1000
+
+    # skip reading the SCM_RIGHTS
+    disconnect_client(ctx, sock)
+
+def test_device_get_region_info_cleanup():
+    vfu_destroy_ctx(ctx)