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>

4 files changed, 319 insertions, 186 deletions

diff --git a/lib/libvfio-user.c b/lib/libvfio-user.c
index e147091..7518a46 100644
--- a/lib/libvfio-user.c
+++ b/lib/libvfio-user.c
@@ -98,7 +98,7 @@ get_vfio_caps_size(bool is_migr_reg, vfu_reg_info_t *reg)
 
 /*
  * Populate the sparse mmap capability information to vfio-client.
- * Sparse mmap information stays after struct vfio_region_info and cap_offest
+ * Sparse mmap information stays after struct vfio_region_info and cap_offset
  * points accordingly.
  */
 static int
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)
diff --git a/test/unit-tests.c b/test/unit-tests.c
index 7c7685d..029e8d2 100644
--- a/test/unit-tests.c
+++ b/test/unit-tests.c
@@ -550,152 +550,6 @@ typedef struct {
     int conn_fd;
 } tran_sock_t;
 
-static void
-test_get_region_info(UNUSED void **state)
-{
-    struct iovec iov = { .iov_base = (void *)0x8badf00, .iov_len = 0x0d15ea5e };
-    vfu_reg_info_t reg_info[VFU_PCI_DEV_NUM_REGIONS] = {
-        {
-            .size = 0xcadebabe
-        },
-        {
-            .flags = VFU_REGION_FLAG_RW,
-            .size = 0xdeadbeef,
-            .fd = 0x12345
-        },
-        [VFU_PCI_DEV_MIGR_REGION_IDX] = {
-            .flags = VFU_REGION_FLAG_RW,
-            .size = 0x1000,
-            .fd = -1
-        }
-    };
-    struct vfio_region_info_cap_sparse_mmap *sparse;
-    struct vfio_region_info_cap_type *type;
-    struct vfio_region_info in_info = {
-        .index = 0
-    };
-    struct vfio_region_info *out_info;
-    int ret;
-
-    vfu_ctx.nr_regions = ARRAY_SIZE(reg_info);
-    vfu_ctx.reg_info = reg_info;
-
-    /* bad argsz */
-    ret = handle_device_get_region_info(&vfu_ctx,
-                                        mkmsg(VFIO_USER_DEVICE_GET_REGION_INFO,
-                                        &in_info, 0));
-    assert_int_equal(-1, ret);
-    assert_int_equal(EINVAL, errno);
-
-    /* bad region */
-    in_info.index = vfu_ctx.nr_regions;
-    in_info.argsz = sizeof(struct vfio_region_info);
-
-    ret = handle_device_get_region_info(&vfu_ctx,
-                                        mkmsg(VFIO_USER_DEVICE_GET_REGION_INFO,
-                                        &in_info, in_info.argsz));
-    assert_int_equal(-1, ret);
-    assert_int_equal(EINVAL, errno);
-
-    /* no region caps */
-    in_info.index = 1;
-
-    ret = handle_device_get_region_info(&vfu_ctx,
-                                        mkmsg(VFIO_USER_DEVICE_GET_REGION_INFO,
-                                        &in_info, in_info.argsz));
-    assert_int_equal(0, ret);
-
-    out_info = msg.out_data;
-
-    assert_int_equal(sizeof(struct vfio_region_info), out_info->argsz);
-    assert_int_equal(VFIO_REGION_INFO_FLAG_READ | VFIO_REGION_INFO_FLAG_WRITE |
-                     VFIO_REGION_INFO_FLAG_MMAP, out_info->flags);
-    assert_int_equal(1, out_info->index);
-    assert_int_equal(0x10000000000, out_info->offset);
-    assert_int_equal(0xdeadbeef, out_info->size);
-    assert_int_equal(0, msg.nr_out_fds);
-
-    free(msg.out_data);
-    msg.out_data = NULL;
-
-    /* regions caps (sparse mmap) but argsz too small */
-    vfu_ctx.reg_info[1].mmap_areas = &iov;
-    vfu_ctx.reg_info[1].nr_mmap_areas = 1;
-
-    ret = handle_device_get_region_info(&vfu_ctx,
-                                        mkmsg(VFIO_USER_DEVICE_GET_REGION_INFO,
-                                        &in_info, in_info.argsz));
-    assert_int_equal(0, ret);
-
-    out_info = msg.out_data;
-
-    assert_int_equal(in_info.argsz +
-                     sizeof(struct vfio_region_info_cap_sparse_mmap) +
-                     sizeof(struct vfio_region_sparse_mmap_area),
-                     out_info->argsz);
-    assert_int_equal(VFIO_REGION_INFO_FLAG_READ | VFIO_REGION_INFO_FLAG_WRITE |
-                     VFIO_REGION_INFO_FLAG_MMAP | VFIO_REGION_INFO_FLAG_CAPS,
-                     out_info->flags);
-
-    free(msg.out_data);
-    msg.out_data = NULL;
-
-    /* region caps and argsz large enough */
-    in_info.argsz += sizeof(struct vfio_region_info_cap_sparse_mmap) +
-                     sizeof(struct vfio_region_sparse_mmap_area);
-
-    ret = handle_device_get_region_info(&vfu_ctx,
-                                        mkmsg(VFIO_USER_DEVICE_GET_REGION_INFO,
-                                        &in_info, in_info.argsz));
-    assert_int_equal(0, ret);
-
-    out_info = msg.out_data;
-
-    sparse = (struct vfio_region_info_cap_sparse_mmap *)(out_info + 1);
-    assert_int_equal(VFIO_REGION_INFO_CAP_SPARSE_MMAP, sparse->header.id);
-    assert_int_equal(1, sparse->header.version);
-    assert_int_equal(0, sparse->header.next);
-    assert_int_equal(1, sparse->nr_areas);
-
-    assert_int_equal(1, msg.nr_out_fds);
-    assert_int_equal(0x12345, msg.out_fds[0]);
-
-    free(msg.out_fds);
-    msg.out_fds = NULL;
-    msg.nr_out_fds = 0;
-
-    free(msg.out_data);
-    msg.out_data = NULL;
-
-    /* migration cap */
-    vfu_ctx.reg_info[1].mmap_areas = NULL;
-    vfu_ctx.reg_info[1].nr_mmap_areas = 0;
-
-    in_info.index = VFU_PCI_DEV_MIGR_REGION_IDX;
-    in_info.argsz = sizeof(in_info) + sizeof(struct vfio_region_info_cap_type);
-
-    ret = handle_device_get_region_info(&vfu_ctx,
-                                        mkmsg(VFIO_USER_DEVICE_GET_REGION_INFO,
-                                        &in_info, in_info.argsz));
-    assert_int_equal(0, ret);
-
-    out_info = msg.out_data;
-
-    assert_int_equal(VFIO_REGION_INFO_FLAG_READ | VFIO_REGION_INFO_FLAG_WRITE |
-                     VFIO_REGION_INFO_FLAG_CAPS, out_info->flags);
-    type = (struct vfio_region_info_cap_type *)(out_info + 1);
-    assert_int_equal(VFIO_REGION_INFO_CAP_TYPE, type->header.id);
-    assert_int_equal(VFIO_REGION_TYPE_MIGRATION , type->type);
-    assert_int_equal(VFIO_REGION_SUBTYPE_MIGRATION, type->subtype);
-    assert_null(msg.out_fds);
-    assert_int_equal(0, msg.nr_out_fds);
-
-    free(msg.out_data);
-    msg.out_data = NULL;
-
-    /* FIXME add check  for multiple sparse areas */
-}
-
 /*
  * Performs various checks when adding sparse memory regions.
  */
@@ -1402,7 +1256,6 @@ main(void)
         cmocka_unit_test_setup(test_dma_map_sg, setup),
         cmocka_unit_test_setup(test_dma_addr_to_sg, setup),
         cmocka_unit_test_setup(test_vfu_setup_device_dma, setup),
-        cmocka_unit_test_setup(test_get_region_info, setup),
         cmocka_unit_test_setup(test_setup_sparse_region, setup),
         cmocka_unit_test_setup(test_dirty_pages_without_dma, setup),
         cmocka_unit_test_setup(test_device_set_irqs, setup),