test: add tests for dirty page logging

Signed-off-by: William Henderson <william.henderson@nutanix.com>

test/py/libvfio_user.py

@@ -203,9 +203,14 @@ def is_32bit():
 
 VFIO_DMA_UNMAP_FLAG_GET_DIRTY_BITMAP = (1 << 0)
 
-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_DEVICE_FEATURE_MASK = 0xffff
+VFIO_DEVICE_FEATURE_GET = (1 << 16)
+VFIO_DEVICE_FEATURE_SET = (1 << 17)
+VFIO_DEVICE_FEATURE_PROBE = (1 << 18)
+
+VFIO_DEVICE_FEATURE_DMA_LOGGING_START = 6
+VFIO_DEVICE_FEATURE_DMA_LOGGING_STOP = 7
+VFIO_DEVICE_FEATURE_DMA_LOGGING_REPORT = 8
 
 VFIO_USER_IO_FD_TYPE_IOEVENTFD = 0
 VFIO_USER_IO_FD_TYPE_IOREGIONFD = 1
@@ -549,6 +554,40 @@ class vfu_migration_callbacks_t(Structure):
  ]
 
 
+class vfio_user_device_feature(Structure):
+ _pack_ = 1
+ _fields_ = [
+ ("argsz", c.c_uint32),
+ ("flags", c.c_uint32)
+ ]
+
+
+class vfio_user_device_feature_dma_logging_control(Structure):
+ _pack_ = 1
+ _fields_ = [
+ ("page_size", c.c_uint64),
+ ("num_ranges", c.c_uint32),
+ ("reserved", c.c_uint32),
+ ]
+
+
+class vfio_user_device_feature_dma_logging_range(Structure):
+ _pack_ = 1
+ _fields_ = [
+ ("iova", c.c_uint64),
+ ("length", c.c_uint64),
+ ]
+
+
+class vfio_user_device_feature_dma_logging_report(Structure):
+ _pack_ = 1
+ _fields_ = [
+ ("iova", c.c_uint64),
+ ("length", c.c_uint64),
+ ("page_size", c.c_uint64)
+ ]
+
+
 class dma_sg_t(Structure):
  _fields_ = [
  ("dma_addr", c.c_void_p),

test/py/meson.build

@@ -33,6 +33,7 @@ python_tests = [
  'test_device_get_region_info_zero_size.py',
  'test_device_get_region_io_fds.py',
  'test_device_set_irqs.py',
+ 'test_dirty_pages.py',
  'test_dma_map.py',
  'test_dma_unmap.py',
  'test_irq_trigger.py',

test/py/test_dirty_pages.py

@@ -0,0 +1,324 @@
+#
+# 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
+# SERVICESLOSS 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 mmap
+import tempfile
+
+ctx = None
+quiesce_errno = 0
+
+
+@vfu_dma_register_cb_t
+def dma_register(ctx, info):
+ return 0
+
+
+@vfu_dma_unregister_cb_t
+def dma_unregister(ctx, info):
+ return 0
+
+
+@vfu_device_quiesce_cb_t
+def quiesce_cb(ctx):
+ if quiesce_errno:
+ c.set_errno(errno.EBUSY)
+ return -1
+ return 0
+
+
+def test_dirty_pages_setup():
+ global ctx, sock
+
+ ctx = vfu_create_ctx(flags=LIBVFIO_USER_FLAG_ATTACH_NB)
+ assert ctx is not None
+
+ ret = vfu_pci_init(ctx)
+ assert ret == 0
+
+ vfu_setup_device_quiesce_cb(ctx, quiesce_cb=quiesce_cb)
+
+ ret = vfu_setup_device_dma(ctx, dma_register, dma_unregister)
+ assert ret == 0
+
+ f = tempfile.TemporaryFile()
+ f.truncate(2 << PAGE_SHIFT)
+
+ ret = vfu_realize_ctx(ctx)
+ assert ret == 0
+
+ sock = connect_client(ctx)
+
+ f = tempfile.TemporaryFile()
+ f.truncate(0x10 << PAGE_SHIFT)
+
+ payload = vfio_user_dma_map(argsz=len(vfio_user_dma_map()),
+ flags=(VFIO_USER_F_DMA_REGION_READ | VFIO_USER_F_DMA_REGION_WRITE),
+ offset=0, addr=0x10 << PAGE_SHIFT, size=0x20 << PAGE_SHIFT)
+
+ msg(ctx, sock, VFIO_USER_DMA_MAP, payload, fds=[f.fileno()])
+
+ payload = vfio_user_dma_map(argsz=len(vfio_user_dma_map()),
+ flags=(VFIO_USER_F_DMA_REGION_READ | VFIO_USER_F_DMA_REGION_WRITE),
+ offset=0, addr=0x40 << PAGE_SHIFT, size=0x10 << PAGE_SHIFT)
+
+ msg(ctx, sock, VFIO_USER_DMA_MAP, payload)
+
+
+def test_setup_migr_region():
+ ret = vfu_setup_device_migration_callbacks(ctx)
+ assert ret == 0
+
+
+def start_logging():
+ feature = vfio_user_device_feature(
+ argsz=len(vfio_user_device_feature()) +
+ len(vfio_user_device_feature_dma_logging_control()),
+ flags=VFIO_DEVICE_FEATURE_DMA_LOGGING_START | VFIO_DEVICE_FEATURE_SET)
+
+ payload = vfio_user_device_feature_dma_logging_control(
+ page_size=PAGE_SIZE,
+ num_ranges=0,
+ reserved=0)
+
+ msg(ctx, sock, VFIO_USER_DEVICE_FEATURE, bytes(feature) + bytes(payload))
+
+
+def test_dirty_pages_start():
+ start_logging()
+ # should be idempotent
+ start_logging()
+
+
+def test_dirty_pages_get_unmodified():
+ argsz = len(vfio_user_device_feature()) + \
+ len(vfio_user_device_feature_dma_logging_report())
+
+ feature = vfio_user_device_feature(
+ argsz=argsz,
+ flags=VFIO_DEVICE_FEATURE_DMA_LOGGING_REPORT | VFIO_DEVICE_FEATURE_GET
+ )
+
+ report = vfio_user_device_feature_dma_logging_report(
+ iova=0x10 << PAGE_SHIFT,
+ length=0x10 << PAGE_SHIFT,
+ page_size=PAGE_SIZE
+ )
+
+ payload = bytes(feature) + bytes(report)
+
+ result = msg(ctx, sock, VFIO_USER_DEVICE_FEATURE, payload)
+
+ assert len(result) == argsz + 8
+
+ feature, result = vfio_user_device_feature.pop_from_buffer(result)
+
+ assert feature.argsz == argsz + 8
+ assert feature.flags == VFIO_DEVICE_FEATURE_DMA_LOGGING_REPORT \
+ | VFIO_DEVICE_FEATURE_GET
+
+ report, bitmap = \
+ vfio_user_device_feature_dma_logging_report.pop_from_buffer(result)
+
+ assert report.iova == 0x10 << PAGE_SHIFT
+ assert report.length == 0x10 << PAGE_SHIFT
+ assert report.page_size == PAGE_SIZE
+
+ assert len(bitmap) == 8
+
+ for b in bitmap:
+ assert b == 0
+
+
+def get_dirty_page_bitmap():
+ argsz = len(vfio_user_device_feature()) + \
+ len(vfio_user_device_feature_dma_logging_report())
+
+ feature = vfio_user_device_feature(
+ argsz=argsz,
+ flags=VFIO_DEVICE_FEATURE_DMA_LOGGING_REPORT | VFIO_DEVICE_FEATURE_GET
+ )
+
+ report = vfio_user_device_feature_dma_logging_report(
+ iova=0x10 << PAGE_SHIFT,
+ length=0x10 << PAGE_SHIFT,
+ page_size=PAGE_SIZE
+ )
+
+ payload = bytes(feature) + bytes(report)
+
+ result = msg(ctx, sock, VFIO_USER_DEVICE_FEATURE, payload)
+
+ assert len(result) == argsz + 8
+
+ _, result = vfio_user_device_feature.pop_from_buffer(result)
+ _, result = \
+ vfio_user_device_feature_dma_logging_report.pop_from_buffer(result)
+
+ assert len(result) == 8
+
+ return struct.unpack("Q", result)[0]
+
+
+sg3 = None
+iovec3 = None
+
+
+def write_to_page(ctx, page, nr_pages, get_bitmap=True):
+ """Simulate a write to the given address and size."""
+ ret, sg = vfu_addr_to_sgl(ctx, dma_addr=page << PAGE_SHIFT,
+ length=nr_pages << PAGE_SHIFT)
+ assert ret == 1
+ iovec = iovec_t()
+ ret = vfu_sgl_get(ctx, sg, iovec)
+ assert ret == 0
+ vfu_sgl_put(ctx, sg, iovec)
+ if get_bitmap:
+ return get_dirty_page_bitmap()
+ return None
+
+
+def test_dirty_pages_get_modified():
+ ret, sg1 = vfu_addr_to_sgl(ctx, dma_addr=0x10 << PAGE_SHIFT,
+ length=PAGE_SIZE)
+ assert ret == 1
+ iovec1 = iovec_t()
+ ret = vfu_sgl_get(ctx, sg1, iovec1)
+ assert ret == 0
+
+ # read only
+ ret, sg2 = vfu_addr_to_sgl(ctx, dma_addr=0x11 << PAGE_SHIFT,
+ length=PAGE_SIZE, prot=mmap.PROT_READ)
+ assert ret == 1
+ iovec2 = iovec_t()
+ ret = vfu_sgl_get(ctx, sg2, iovec2)
+ assert ret == 0
+
+ # simple single bitmap entry map
+ ret, sg3 = vfu_addr_to_sgl(ctx, dma_addr=0x12 << PAGE_SHIFT,
+ length=PAGE_SIZE)
+ assert ret == 1
+ iovec3 = iovec_t()
+ ret = vfu_sgl_get(ctx, sg3, iovec3)
+ assert ret == 0
+
+ # write that spans bytes in bitmap
+ ret, sg4 = vfu_addr_to_sgl(ctx, dma_addr=0x16 << PAGE_SHIFT,
+ length=0x4 << PAGE_SHIFT)
+ assert ret == 1
+ iovec4 = iovec_t()
+ ret = vfu_sgl_get(ctx, sg4, iovec4)
+ assert ret == 0
+
+ # not put yet, dirty bitmap should be zero
+ bitmap = get_dirty_page_bitmap()
+ assert bitmap == 0b0000000000000000
+
+ # put SGLs, dirty bitmap should be updated
+ vfu_sgl_put(ctx, sg1, iovec1)
+ vfu_sgl_put(ctx, sg4, iovec4)
+ bitmap = get_dirty_page_bitmap()
+ assert bitmap == 0b0000001111000001
+
+ # after another two puts, should just be one dirty page
+ vfu_sgl_put(ctx, sg2, iovec2)
+ vfu_sgl_put(ctx, sg3, iovec3)
+ bitmap = get_dirty_page_bitmap()
+ assert bitmap == 0b0000000000000100
+
+ # and should now be clear
+ bitmap = get_dirty_page_bitmap()
+ assert bitmap == 0b0000000000000000
+
+ #
+ # check various edge cases of bitmap values.
+ #
+
+ # very first bit
+ bitmap = write_to_page(ctx, 0x10, 1)
+ assert bitmap == 0b0000000000000001
+
+ # top bit of first byte
+ bitmap = write_to_page(ctx, 0x17, 1)
+ assert bitmap == 0b0000000010000000
+
+ # all bits except top one of first byte
+ bitmap = write_to_page(ctx, 0x10, 7)
+ assert bitmap == 0b0000000001111111
+
+ # all bits of first byte
+ bitmap = write_to_page(ctx, 0x10, 8)
+ assert bitmap == 0b0000000011111111
+
+ # all bits of first byte plus bottom bit of next
+ bitmap = write_to_page(ctx, 0x10, 9)
+ assert bitmap == 0b0000000111111111
+
+ # straddle top/bottom bit
+ bitmap = write_to_page(ctx, 0x17, 2)
+ assert bitmap == 0b0000000110000000
+
+ # top bit of second byte
+ bitmap = write_to_page(ctx, 0x1f, 1)
+ assert bitmap == 0b1000000000000000
+
+ # top bit of third byte
+ bitmap = write_to_page(ctx, 0x27, 1)
+ assert bitmap == 0b100000000000000000000000
+
+ # bits in third and first byte
+ write_to_page(ctx, 0x26, 1, get_bitmap=False)
+ write_to_page(ctx, 0x12, 2, get_bitmap=False)
+ bitmap = get_dirty_page_bitmap()
+ assert bitmap == 0b010000000000000000001100
+
+
+def test_dirty_pages_stop():
+ # FIXME we have a memory leak as we don't free dirty bitmaps when
+ # destroying the context.
+ feature = vfio_user_device_feature(
+ argsz=len(vfio_user_device_feature()) +
+ len(vfio_user_device_feature_dma_logging_control()),
+ flags=VFIO_DEVICE_FEATURE_DMA_LOGGING_STOP | VFIO_DEVICE_FEATURE_SET)
+
+ payload = vfio_user_device_feature_dma_logging_control(
+ page_size=PAGE_SIZE,
+ num_ranges=0,
+ reserved=0)
+
+ msg(ctx, sock, VFIO_USER_DEVICE_FEATURE, bytes(feature) + bytes(payload))
+
+
+def test_dirty_pages_cleanup():
+ disconnect_client(ctx, sock)
+ vfu_destroy_ctx(ctx)
+
+# ex: set tabstop=4 shiftwidth=4 softtabstop=4 expandtab: