zircon/kernel/object/msi_object_tests.cc - fuchsia - Git at Google

 // Copyright 2020 The Fuchsia Authors
 //
 // Use of this source code is governed by a MIT-style
 // license that can be found in the LICENSE file or at
 // https://opensource.org/licenses/MIT

 #include <debug.h>
 #include <lib/unittest/unittest.h>
 #include <platform.h>
 #include <pow2.h>
 #include <zircon/errors.h>
 #include <zircon/time.h>

 #include <utility>

 #include <fbl/ref_ptr.h>
 #include <kernel/thread.h>
 #include <object/handle.h>
 #include <object/msi_allocation.h>
 #include <object/msi_dispatcher.h>
 #include <vm/pmm.h>
 #include <vm/vm_address_region.h>
 #include <vm/vm_object.h>
 #include <vm/vm_object_paged.h>

 namespace {
 bool MsiIsSupportedTrue() { return true; }
 zx_status_t MsiAllocate(uint requested_irqs, bool /*unused*/, bool /*unused*/,
                         msi_block_t* out_block) {
   out_block->allocated = true;
   out_block->base_irq_id = 128;
   out_block->num_irq = requested_irqs;
   out_block->tgt_addr = 0x1234u;
   out_block->tgt_addr = 0x4321u;
   out_block->platform_ctx = nullptr;
   return ZX_OK;
 }

 // These functions are used to verify we properly bail out if MSI isn't supported.
 void MsiFree(msi_block_t* block) { block->allocated = false; }
 bool MsiIsSupportedFalse() { return false; }
 zx_status_t MsiAllocateAssert(uint32_t /* unused */, bool /* unused */, bool /* unused */,
                               msi_block_t* /* unused */) {
   assert(false);
   return ZX_ERR_NOT_SUPPORTED;
 }

 void MsiFreeAssert(msi_block_t* /* unused */) { assert(false); }
 }  // namespace
 const uint32_t kVectorMax = 256u;

 zx_status_t create_resource_storage_and_allocation(
     ResourceDispatcher::ResourceStorage* rsrc_storage, fbl::RefPtr<MsiAllocation>* alloc,
     uint32_t cnt) {
   zx_status_t status;
   if ((status = ResourceDispatcher::InitializeAllocator(ZX_RSRC_KIND_IRQ, 0, kVectorMax,
                                                         rsrc_storage)) != ZX_OK) {
     return status;
   }

   if ((status = MsiAllocation::Create(cnt, alloc, MsiAllocate, MsiFree, MsiIsSupportedTrue,
                                       rsrc_storage) != ZX_OK)) {
     return status;
   }

   if (rsrc_storage->resource_list.size_slow() != 1u) {
     return ZX_ERR_NO_MEMORY;
   }

   return ZX_OK;
 }

 // Helper function to create a valid vmo / mapping / capability tuple to cut down
 // on the duplication within tests.
 zx_status_t create_valid_msi_vmo(fbl::RefPtr<VmObject>* out_vmo,
                                  fbl::RefPtr<VmMapping>* out_mapping,
                                  volatile MsiCapability** out_cap) {
   zx_status_t status;
   size_t vmo_size = sizeof(MsiCapability);
   fbl::RefPtr<VmObjectPaged> vmo;
   if ((status = VmObjectPaged::CreateContiguous(PMM_ALLOC_FLAG_ANY, vmo_size, 0 /* options */,
                                                 &vmo)) != ZX_OK) {
     return status;
   }

   if ((status = vmo->SetMappingCachePolicy(ZX_CACHE_POLICY_UNCACHED_DEVICE)) != ZX_OK) {
     return status;
   }

   fbl::RefPtr<VmMapping> mapping;
   status = VmAspace::kernel_aspace()->RootVmar()->CreateVmMapping(
       /*mapping_offset=*/0, /*size=*/vmo_size, /*align_pow2=*/0, /*vmar_flags=*/0, vmo,
       /*vmo_offset=*/0, ARCH_MMU_FLAG_PERM_READ | ARCH_MMU_FLAG_PERM_WRITE,
       /*name=*/nullptr, &mapping);
   if (status == ZX_OK) {
     // Prepopulate the mapping so no page faults are needed in kernel mode.
     status = mapping->MapRange(/*offset=*/0, vmo_size, /*commit=*/true);
   }
   if (status != ZX_OK) {
     return status;
   }

   *out_vmo = ktl::move(vmo);
   *out_mapping = ktl::move(mapping);
   *out_cap = reinterpret_cast<MsiCapability*>(out_mapping->get()->base());
   (*out_cap)->id = kMsiCapabilityId;

   return ZX_OK;
 }

 static bool allocation_creation_and_info_test() {
   BEGIN_TEST;

   const uint32_t test_irq_cnt = 8;
   ResourceDispatcher::ResourceStorage rsrc_storage;
   fbl::RefPtr<MsiAllocation> alloc;
   ASSERT_EQ(ZX_OK, create_resource_storage_and_allocation(&rsrc_storage, &alloc, test_irq_cnt));

   zx_info_msi_t info = {};
   alloc->GetInfo(&info);

   // Grab the lock and compare the block values and info values to both our test
   // data and info data.
   Guard<SpinLock, IrqSave> guard{&alloc->lock()};
   ASSERT_EQ(test_irq_cnt, alloc->block().num_irq);
   ASSERT_EQ(true, alloc->block().allocated);
   ASSERT_EQ(info.base_irq_id, alloc->block().base_irq_id);
   ASSERT_EQ(info.num_irq, alloc->block().num_irq);
   ASSERT_EQ(info.target_addr, alloc->block().tgt_addr);
   ASSERT_EQ(info.target_data, alloc->block().tgt_data);
   END_TEST;
 }

 static bool allocation_irq_count_test() {
   BEGIN_TEST;

   ResourceDispatcher::ResourceStorage rsrc_storage;
   ASSERT_EQ(ZX_OK, ResourceDispatcher::InitializeAllocator(ZX_RSRC_KIND_IRQ, 0, kVectorMax,
                                                            &rsrc_storage));
   // Check that the valid range of allocation sizes work. Verifies that only
   // powers of two are valid.
   for (uint32_t cnt = 1; cnt < MsiAllocation::kMsiAllocationCountMax; cnt++) {
     fbl::RefPtr<MsiAllocation> alloc;
     zx_status_t expected = ispow2(cnt) ? ZX_OK : ZX_ERR_INVALID_ARGS;
     ASSERT_EQ(expected, MsiAllocation::Create(cnt, &alloc, MsiAllocate, MsiFree, MsiIsSupportedTrue,
                                               &rsrc_storage));
   }

   fbl::RefPtr<MsiAllocation> alloc;
   // And check the failure cases.
   ASSERT_EQ(ZX_ERR_INVALID_ARGS, MsiAllocation::Create(0, &alloc, MsiAllocate, MsiFree,
                                                        MsiIsSupportedTrue, &rsrc_storage));
   ASSERT_EQ(ZX_ERR_INVALID_ARGS,
             MsiAllocation::Create(MsiAllocation::kMsiAllocationCountMax + 1, &alloc, MsiAllocate,
                                   MsiFree, MsiIsSupportedTrue, &rsrc_storage));

   END_TEST;
 }

 static bool allocation_reservation_test() {
   BEGIN_TEST;

   ResourceDispatcher::ResourceStorage rsrc_storage;
   fbl::RefPtr<MsiAllocation> alloc;
   ASSERT_EQ(ZX_OK, create_resource_storage_and_allocation(&rsrc_storage, &alloc,
                                                           MsiAllocation::kMsiAllocationCountMax));

   // Verify the bounds checking and state of id reservations.
   ASSERT_EQ(ZX_ERR_BAD_STATE, alloc->ReleaseId(0));
   ASSERT_EQ(ZX_OK, alloc->ReserveId(0));
   ASSERT_EQ(ZX_ERR_ALREADY_BOUND, alloc->ReserveId(0));
   ASSERT_EQ(ZX_OK, alloc->ReleaseId(0));
   ASSERT_EQ(ZX_ERR_INVALID_ARGS, alloc->ReserveId(MsiAllocation::kMsiAllocationCountMax));
   ASSERT_EQ(ZX_ERR_INVALID_ARGS, alloc->ReleaseId(MsiAllocation::kMsiAllocationCountMax));
   END_TEST;
 }

 static bool allocation_support_test() {
   BEGIN_TEST;
   ResourceDispatcher::ResourceStorage rsrc_storage;
   ASSERT_EQ(ZX_OK, ResourceDispatcher::InitializeAllocator(ZX_RSRC_KIND_IRQ, 0, kVectorMax,
                                                            &rsrc_storage));

   {
     fbl::RefPtr<MsiAllocation> alloc;
     ASSERT_EQ(ZX_ERR_NOT_SUPPORTED,
               MsiAllocation::Create(1, &alloc, MsiAllocateAssert, MsiFreeAssert,
                                     MsiIsSupportedFalse, &rsrc_storage));
     ASSERT_EQ(0u, rsrc_storage.resource_list.size_slow());
   }

   END_TEST;
 }

 // Use a static var for tracking calls rather than a lambda to avoid storage issues with lambda
 // captures and function pointers without having to increase complexity in the dispatcher.
 static uint32_t register_call_count = 0;
 void register_fn(const msi_block_t*, uint, int_handler, void*) { register_call_count++; }

 static bool interrupt_duplication_test() {
   BEGIN_TEST;
   ResourceDispatcher::ResourceStorage rsrc_storage;
   fbl::RefPtr<MsiAllocation> alloc;
   ASSERT_EQ(ZX_OK, create_resource_storage_and_allocation(&rsrc_storage, &alloc,
                                                           MsiAllocation::kMsiAllocationCountMax));

   fbl::RefPtr<VmObject> vmo;
   fbl::RefPtr<VmMapping> mapping;
   volatile MsiCapability* cap;
   ASSERT_EQ(ZX_OK, create_valid_msi_vmo(&vmo, &mapping, &cap));

   // Now to the meat of the test. Ensure that two MsiDispatchers cannot share
   // the same MSI id, and that when a dispatcher is cleaned up it releases the
   // Id reservation in the allocation.
   zx_rights_t rights;
   KernelHandle<InterruptDispatcher> d1, d2;
   ASSERT_EQ(ZX_OK, MsiDispatcher::Create(alloc, 0, vmo, /*cap_offset=*/0, /*options=*/0, &rights,
                                          &d1, register_fn));
   ASSERT_EQ(ZX_ERR_ALREADY_BOUND, MsiDispatcher::Create(alloc, 0, vmo, /*cap_offset=*/0,
                                                         /*options=*/0, &rights, &d2, register_fn));
   d1.reset();
   ASSERT_EQ(ZX_OK, MsiDispatcher::Create(alloc, 0, vmo, /*cap_offset=*/0, /*options=*/0, &rights,
                                          &d2, register_fn));

   END_TEST;
 }

 static bool interrupt_vmo_test() {
   BEGIN_TEST;
   register_call_count = 0;
   ResourceDispatcher::ResourceStorage rsrc_storage;
   fbl::RefPtr<MsiAllocation> alloc;
   ASSERT_EQ(ZX_OK, create_resource_storage_and_allocation(&rsrc_storage, &alloc,
                                                           MsiAllocation::kMsiAllocationCountMax));

   // This test emulates a block of MSI interrupts each taking up a given bit in a register for
   // their own masking. It validates that the MsiDispatcher masks / unmasks the correct bit, and
   // that the operation of the inherited InterruptDispatcher side of things behaves correctly when
   // interrupts are triggered.
   KernelHandle<InterruptDispatcher> interrupt;
   zx_rights_t rights;
   {
     fbl::RefPtr<VmObjectPaged> vmo, vmo_noncontig;
     size_t vmo_size = sizeof(MsiCapability);
     ASSERT_EQ(ZX_OK,
               VmObjectPaged::CreateContiguous(PMM_ALLOC_FLAG_ANY, vmo_size, /*options=*/0, &vmo));
     ASSERT_EQ(ZX_OK,
               VmObjectPaged::Create(PMM_ALLOC_FLAG_ANY, /*options=*/0, vmo_size, &vmo_noncontig));

     // This should fail because the VMO is non-contiguous.
     ASSERT_EQ(ZX_ERR_INVALID_ARGS,
               MsiDispatcher::Create(alloc, 0, vmo_noncontig, /*cap_offset=*/0, /*options=*/0,
                                     &rights, &interrupt, register_fn));
     // This should fail because the VMO has not had a cache policy set.
     ASSERT_EQ(ZX_ERR_INVALID_ARGS,
               MsiDispatcher::Create(alloc, 0, vmo, /*cap_offset=*/0, /*options=*/0, &rights,
                                     &interrupt, register_fn));
     ASSERT_EQ(ZX_OK, vmo->SetMappingCachePolicy(ZX_CACHE_POLICY_UNCACHED_DEVICE));
     // Create will still fail because the VMO doesn't look like an MSI capability.
     ASSERT_EQ(ZX_ERR_INVALID_ARGS,
               MsiDispatcher::Create(alloc, 0, vmo, /*cap_offset=*/0, /*options=*/0, &rights,
                                     &interrupt, register_fn));
   }

   fbl::RefPtr<VmObject> vmo;
   fbl::RefPtr<VmMapping> mapping;
   volatile MsiCapability* cap;
   ASSERT_EQ(ZX_OK, create_valid_msi_vmo(&vmo, &mapping, &cap));
   // Now Create() should succeed.
   ASSERT_EQ(ZX_OK, MsiDispatcher::Create(alloc, 0, vmo, /*cap_offset=*/0, /*options=*/0, &rights,
                                          &interrupt, register_fn));
   ASSERT_EQ(1u, register_call_count);
   END_TEST;
 }

 static bool interrupt_creation_mask_test() {
   BEGIN_TEST;
   ResourceDispatcher::ResourceStorage rsrc_storage;
   fbl::RefPtr<MsiAllocation> alloc;
   ASSERT_EQ(ZX_OK, create_resource_storage_and_allocation(&rsrc_storage, &alloc,
                                                           MsiAllocation::kMsiAllocationCountMax));
   fbl::RefPtr<VmObject> vmo;
   fbl::RefPtr<VmMapping> mapping;
   volatile MsiCapability* cap;
   ASSERT_EQ(ZX_OK, create_valid_msi_vmo(&vmo, &mapping, &cap));

   zx_rights_t rights;
   // Below test all the mask variants around PVM. This also serves to ensure
   // that the dtor properly releases the msi registration in all cases.
   // Test 32 bit / no pvm
   {
     cap->control = ~(kMsiPvmSupported | kMsi64bitSupported);
     for (uint32_t msi_id = 0; msi_id < MsiAllocation::kMsiAllocationCountMax; msi_id++) {
       cap->mask_bits_32 = 0;
       cap->mask_bits_64 = 0;
       KernelHandle<InterruptDispatcher> interrupt;
       ASSERT_EQ(ZX_OK, MsiDispatcher::Create(alloc, msi_id, vmo, /*cap_offset=*/0, /*options=*/0,
                                              &rights, &interrupt, register_fn));
       auto val_32 = cap->mask_bits_32;
       auto val_64 = cap->mask_bits_64;
       EXPECT_EQ(val_32, 0u);
       EXPECT_EQ(val_64, 0u);
     }
   }

   // Test 32 bit / pvm
   {
     cap->control = ~(kMsi64bitSupported);
     for (uint32_t msi_id = 0; msi_id < MsiAllocation::kMsiAllocationCountMax; msi_id++) {
       cap->mask_bits_32 = 0;
       cap->mask_bits_64 = 0;
       KernelHandle<InterruptDispatcher> interrupt;
       ASSERT_EQ(ZX_OK, MsiDispatcher::Create(alloc, msi_id, vmo, /*cap_offset=*/0, /*options=*/0,
                                              &rights, &interrupt, register_fn));
       auto val_32 = cap->mask_bits_32;
       auto val_64 = cap->mask_bits_64;
       EXPECT_EQ(0u, val_32 & (1u << msi_id));
       EXPECT_EQ(val_64, 0u);
     }
   }

   // Test 64 bit / no pvm
   {
     cap->control = kMsi64bitSupported;
     for (uint32_t msi_id = 0; msi_id < MsiAllocation::kMsiAllocationCountMax; msi_id++) {
       cap->mask_bits_32 = 0;
       cap->mask_bits_64 = 0;
       KernelHandle<InterruptDispatcher> interrupt;
       ASSERT_EQ(ZX_OK, MsiDispatcher::Create(alloc, msi_id, vmo, /*cap_offset=*/0, /*options=*/0,
                                              &rights, &interrupt, register_fn));
       auto val_32 = cap->mask_bits_32;
       auto val_64 = cap->mask_bits_64;
       EXPECT_EQ(val_32, 0u);
       EXPECT_EQ(val_64, 0u);
     }
   }

   // Test 32 bit / pvm
   {
     cap->control = kMsiPvmSupported | kMsi64bitSupported;
     for (uint32_t msi_id = 0; msi_id < MsiAllocation::kMsiAllocationCountMax; msi_id++) {
       cap->mask_bits_32 = 0;
       cap->mask_bits_64 = 0;
       KernelHandle<InterruptDispatcher> interrupt;
       ASSERT_EQ(ZX_OK, MsiDispatcher::Create(alloc, msi_id, vmo, /*cap_offset=*/0, /*options=*/0,
                                              &rights, &interrupt, register_fn));
       auto val_32 = cap->mask_bits_32;
       auto val_64 = cap->mask_bits_64;
       EXPECT_EQ(val_32, 0u);
       EXPECT_EQ(0u, val_64 & (1u << msi_id));
     }
   }

   END_TEST;
 }

 static bool out_of_order_ownership_test() {
   BEGIN_TEST;
   ResourceDispatcher::ResourceStorage rsrc_storage;
   KernelHandle<InterruptDispatcher> interrupt1, interrupt2;
   fbl::RefPtr<VmObject> vmo;
   fbl::RefPtr<VmMapping> mapping;
   volatile MsiCapability* cap;

   ASSERT_EQ(ZX_OK, create_valid_msi_vmo(&vmo, &mapping, &cap));
   {
     zx_rights_t rights;
     fbl::RefPtr<MsiAllocation> alloc;
     ASSERT_EQ(ZX_OK, create_resource_storage_and_allocation(&rsrc_storage, &alloc,
                                                             MsiAllocation::kMsiAllocationCountMax));
     ASSERT_EQ(ZX_OK, MsiDispatcher::Create(alloc, /*msi_id=*/0, vmo, /*cap_offset=*/0,
                                            /*options=*/0, &rights, &interrupt1, register_fn));
     ASSERT_EQ(ZX_OK, MsiDispatcher::Create(alloc, /*msi_id=*/1, vmo, /*cap_offset=*/0,
                                            /*options=*/0, &rights, &interrupt2, register_fn));
   }

   // This test verifies that although our allocation order was Alloc -> 1 -> 2,
   // freeing in the same order behaves properly due to the reference ownership.
   interrupt1.release();

   END_TEST;
 }

 UNITTEST_START_TESTCASE(msi_object)
 UNITTEST("Test that Create() and get_info() operate properly", allocation_creation_and_info_test)
 UNITTEST("Test allocation limits", allocation_irq_count_test)
 UNITTEST("Test reservations for MSI ids", allocation_reservation_test)
 UNITTEST("Test for MSI platform support hooks", allocation_support_test)
 UNITTEST("Test that MsiDispatchers cannot overlap on an MSI id", interrupt_duplication_test)
 UNITTEST("Test that MsiDispatcher validates the VMO", interrupt_vmo_test)
 UNITTEST("Test that MsiDispatcher unmasks on creation", interrupt_creation_mask_test)
 UNITTEST("Test that MsiAllocation & MsiDispatcher ownership is correct",
          out_of_order_ownership_test)
 UNITTEST_END_TESTCASE(msi_object, "msi", "Tests for MSI objects")
	// Copyright 2020 The Fuchsia Authors
	//
	// Use of this source code is governed by a MIT-style
	// license that can be found in the LICENSE file or at
	// https://opensource.org/licenses/MIT

	#include <debug.h>
	#include <lib/unittest/unittest.h>
	#include <platform.h>
	#include <pow2.h>
	#include <zircon/errors.h>
	#include <zircon/time.h>

	#include <utility>

	#include <fbl/ref_ptr.h>
	#include <kernel/thread.h>
	#include <object/handle.h>
	#include <object/msi_allocation.h>
	#include <object/msi_dispatcher.h>
	#include <vm/pmm.h>
	#include <vm/vm_address_region.h>
	#include <vm/vm_object.h>
	#include <vm/vm_object_paged.h>

	namespace {
	bool MsiIsSupportedTrue() { return true; }
	zx_status_t MsiAllocate(uint requested_irqs, bool /unused/, bool /unused/,
	msi_block_t* out_block) {
	out_block->allocated = true;
	out_block->base_irq_id = 128;
	out_block->num_irq = requested_irqs;
	out_block->tgt_addr = 0x1234u;
	out_block->tgt_addr = 0x4321u;
	out_block->platform_ctx = nullptr;
	return ZX_OK;
	}

	// These functions are used to verify we properly bail out if MSI isn't supported.
	void MsiFree(msi_block_t* block) { block->allocated = false; }
	bool MsiIsSupportedFalse() { return false; }
	zx_status_t MsiAllocateAssert(uint32_t /* unused /, bool / unused /, bool / unused */,
	msi_block_t* /* unused */) {
	assert(false);
	return ZX_ERR_NOT_SUPPORTED;
	}

	void MsiFreeAssert(msi_block_t* /* unused */) { assert(false); }
	} // namespace
	const uint32_t kVectorMax = 256u;

	zx_status_t create_resource_storage_and_allocation(
	ResourceDispatcher::ResourceStorage* rsrc_storage, fbl::RefPtr<MsiAllocation>* alloc,
	uint32_t cnt) {
	zx_status_t status;
	if ((status = ResourceDispatcher::InitializeAllocator(ZX_RSRC_KIND_IRQ, 0, kVectorMax,
	rsrc_storage)) != ZX_OK) {
	return status;
	}

	if ((status = MsiAllocation::Create(cnt, alloc, MsiAllocate, MsiFree, MsiIsSupportedTrue,
	rsrc_storage) != ZX_OK)) {
	return status;
	}

	if (rsrc_storage->resource_list.size_slow() != 1u) {
	return ZX_ERR_NO_MEMORY;
	}

	return ZX_OK;
	}

	// Helper function to create a valid vmo / mapping / capability tuple to cut down
	// on the duplication within tests.
	zx_status_t create_valid_msi_vmo(fbl::RefPtr<VmObject>* out_vmo,
	fbl::RefPtr<VmMapping>* out_mapping,
	volatile MsiCapability** out_cap) {
	zx_status_t status;
	size_t vmo_size = sizeof(MsiCapability);
	fbl::RefPtr<VmObjectPaged> vmo;
	if ((status = VmObjectPaged::CreateContiguous(PMM_ALLOC_FLAG_ANY, vmo_size, 0 /* options */,
	&vmo)) != ZX_OK) {
	return status;
	}

	if ((status = vmo->SetMappingCachePolicy(ZX_CACHE_POLICY_UNCACHED_DEVICE)) != ZX_OK) {
	return status;
	}

	fbl::RefPtr<VmMapping> mapping;
	status = VmAspace::kernel_aspace()->RootVmar()->CreateVmMapping(
	/mapping_offset=/0, /size=/vmo_size, /align_pow2=/0, /vmar_flags=/0, vmo,
	/vmo_offset=/0, ARCH_MMU_FLAG_PERM_READ \| ARCH_MMU_FLAG_PERM_WRITE,
	/name=/nullptr, &mapping);
	if (status == ZX_OK) {
	// Prepopulate the mapping so no page faults are needed in kernel mode.
	status = mapping->MapRange(/offset=/0, vmo_size, /commit=/true);
	}
	if (status != ZX_OK) {
	return status;
	}

	*out_vmo = ktl::move(vmo);
	*out_mapping = ktl::move(mapping);
	out_cap = reinterpret_cast<MsiCapability>(out_mapping->get()->base());
	(*out_cap)->id = kMsiCapabilityId;

	return ZX_OK;
	}

	static bool allocation_creation_and_info_test() {
	BEGIN_TEST;

	const uint32_t test_irq_cnt = 8;
	ResourceDispatcher::ResourceStorage rsrc_storage;
	fbl::RefPtr<MsiAllocation> alloc;
	ASSERT_EQ(ZX_OK, create_resource_storage_and_allocation(&rsrc_storage, &alloc, test_irq_cnt));

	zx_info_msi_t info = {};
	alloc->GetInfo(&info);

	// Grab the lock and compare the block values and info values to both our test
	// data and info data.
	Guard<SpinLock, IrqSave> guard{&alloc->lock()};
	ASSERT_EQ(test_irq_cnt, alloc->block().num_irq);
	ASSERT_EQ(true, alloc->block().allocated);
	ASSERT_EQ(info.base_irq_id, alloc->block().base_irq_id);
	ASSERT_EQ(info.num_irq, alloc->block().num_irq);
	ASSERT_EQ(info.target_addr, alloc->block().tgt_addr);
	ASSERT_EQ(info.target_data, alloc->block().tgt_data);
	END_TEST;
	}

	static bool allocation_irq_count_test() {
	BEGIN_TEST;

	ResourceDispatcher::ResourceStorage rsrc_storage;
	ASSERT_EQ(ZX_OK, ResourceDispatcher::InitializeAllocator(ZX_RSRC_KIND_IRQ, 0, kVectorMax,
	&rsrc_storage));
	// Check that the valid range of allocation sizes work. Verifies that only
	// powers of two are valid.
	for (uint32_t cnt = 1; cnt < MsiAllocation::kMsiAllocationCountMax; cnt++) {
	fbl::RefPtr<MsiAllocation> alloc;
	zx_status_t expected = ispow2(cnt) ? ZX_OK : ZX_ERR_INVALID_ARGS;
	ASSERT_EQ(expected, MsiAllocation::Create(cnt, &alloc, MsiAllocate, MsiFree, MsiIsSupportedTrue,
	&rsrc_storage));
	}

	fbl::RefPtr<MsiAllocation> alloc;
	// And check the failure cases.
	ASSERT_EQ(ZX_ERR_INVALID_ARGS, MsiAllocation::Create(0, &alloc, MsiAllocate, MsiFree,
	MsiIsSupportedTrue, &rsrc_storage));
	ASSERT_EQ(ZX_ERR_INVALID_ARGS,
	MsiAllocation::Create(MsiAllocation::kMsiAllocationCountMax + 1, &alloc, MsiAllocate,
	MsiFree, MsiIsSupportedTrue, &rsrc_storage));

	END_TEST;
	}

	static bool allocation_reservation_test() {
	BEGIN_TEST;

	ResourceDispatcher::ResourceStorage rsrc_storage;
	fbl::RefPtr<MsiAllocation> alloc;
	ASSERT_EQ(ZX_OK, create_resource_storage_and_allocation(&rsrc_storage, &alloc,
	MsiAllocation::kMsiAllocationCountMax));

	// Verify the bounds checking and state of id reservations.
	ASSERT_EQ(ZX_ERR_BAD_STATE, alloc->ReleaseId(0));
	ASSERT_EQ(ZX_OK, alloc->ReserveId(0));
	ASSERT_EQ(ZX_ERR_ALREADY_BOUND, alloc->ReserveId(0));
	ASSERT_EQ(ZX_OK, alloc->ReleaseId(0));
	ASSERT_EQ(ZX_ERR_INVALID_ARGS, alloc->ReserveId(MsiAllocation::kMsiAllocationCountMax));
	ASSERT_EQ(ZX_ERR_INVALID_ARGS, alloc->ReleaseId(MsiAllocation::kMsiAllocationCountMax));
	END_TEST;
	}

	static bool allocation_support_test() {
	BEGIN_TEST;
	ResourceDispatcher::ResourceStorage rsrc_storage;
	ASSERT_EQ(ZX_OK, ResourceDispatcher::InitializeAllocator(ZX_RSRC_KIND_IRQ, 0, kVectorMax,
	&rsrc_storage));

	{
	fbl::RefPtr<MsiAllocation> alloc;
	ASSERT_EQ(ZX_ERR_NOT_SUPPORTED,
	MsiAllocation::Create(1, &alloc, MsiAllocateAssert, MsiFreeAssert,
	MsiIsSupportedFalse, &rsrc_storage));
	ASSERT_EQ(0u, rsrc_storage.resource_list.size_slow());
	}

	END_TEST;
	}

	// Use a static var for tracking calls rather than a lambda to avoid storage issues with lambda
	// captures and function pointers without having to increase complexity in the dispatcher.
	static uint32_t register_call_count = 0;
	void register_fn(const msi_block_t, uint, int_handler, void) { register_call_count++; }

	static bool interrupt_duplication_test() {
	BEGIN_TEST;
	ResourceDispatcher::ResourceStorage rsrc_storage;
	fbl::RefPtr<MsiAllocation> alloc;
	ASSERT_EQ(ZX_OK, create_resource_storage_and_allocation(&rsrc_storage, &alloc,
	MsiAllocation::kMsiAllocationCountMax));

	fbl::RefPtr<VmObject> vmo;
	fbl::RefPtr<VmMapping> mapping;
	volatile MsiCapability* cap;
	ASSERT_EQ(ZX_OK, create_valid_msi_vmo(&vmo, &mapping, &cap));

	// Now to the meat of the test. Ensure that two MsiDispatchers cannot share
	// the same MSI id, and that when a dispatcher is cleaned up it releases the
	// Id reservation in the allocation.
	zx_rights_t rights;
	KernelHandle<InterruptDispatcher> d1, d2;
	ASSERT_EQ(ZX_OK, MsiDispatcher::Create(alloc, 0, vmo, /cap_offset=/0, /options=/0, &rights,
	&d1, register_fn));
	ASSERT_EQ(ZX_ERR_ALREADY_BOUND, MsiDispatcher::Create(alloc, 0, vmo, /cap_offset=/0,
	/options=/0, &rights, &d2, register_fn));
	d1.reset();
	ASSERT_EQ(ZX_OK, MsiDispatcher::Create(alloc, 0, vmo, /cap_offset=/0, /options=/0, &rights,
	&d2, register_fn));

	END_TEST;
	}

	static bool interrupt_vmo_test() {
	BEGIN_TEST;
	register_call_count = 0;
	ResourceDispatcher::ResourceStorage rsrc_storage;
	fbl::RefPtr<MsiAllocation> alloc;
	ASSERT_EQ(ZX_OK, create_resource_storage_and_allocation(&rsrc_storage, &alloc,
	MsiAllocation::kMsiAllocationCountMax));

	// This test emulates a block of MSI interrupts each taking up a given bit in a register for
	// their own masking. It validates that the MsiDispatcher masks / unmasks the correct bit, and
	// that the operation of the inherited InterruptDispatcher side of things behaves correctly when
	// interrupts are triggered.
	KernelHandle<InterruptDispatcher> interrupt;
	zx_rights_t rights;
	{
	fbl::RefPtr<VmObjectPaged> vmo, vmo_noncontig;
	size_t vmo_size = sizeof(MsiCapability);
	ASSERT_EQ(ZX_OK,
	VmObjectPaged::CreateContiguous(PMM_ALLOC_FLAG_ANY, vmo_size, /options=/0, &vmo));
	ASSERT_EQ(ZX_OK,
	VmObjectPaged::Create(PMM_ALLOC_FLAG_ANY, /options=/0, vmo_size, &vmo_noncontig));

	// This should fail because the VMO is non-contiguous.
	ASSERT_EQ(ZX_ERR_INVALID_ARGS,
	MsiDispatcher::Create(alloc, 0, vmo_noncontig, /cap_offset=/0, /options=/0,
	&rights, &interrupt, register_fn));
	// This should fail because the VMO has not had a cache policy set.
	ASSERT_EQ(ZX_ERR_INVALID_ARGS,
	MsiDispatcher::Create(alloc, 0, vmo, /cap_offset=/0, /options=/0, &rights,
	&interrupt, register_fn));
	ASSERT_EQ(ZX_OK, vmo->SetMappingCachePolicy(ZX_CACHE_POLICY_UNCACHED_DEVICE));
	// Create will still fail because the VMO doesn't look like an MSI capability.
	ASSERT_EQ(ZX_ERR_INVALID_ARGS,
	MsiDispatcher::Create(alloc, 0, vmo, /cap_offset=/0, /options=/0, &rights,
	&interrupt, register_fn));
	}

	fbl::RefPtr<VmObject> vmo;
	fbl::RefPtr<VmMapping> mapping;
	volatile MsiCapability* cap;
	ASSERT_EQ(ZX_OK, create_valid_msi_vmo(&vmo, &mapping, &cap));
	// Now Create() should succeed.
	ASSERT_EQ(ZX_OK, MsiDispatcher::Create(alloc, 0, vmo, /cap_offset=/0, /options=/0, &rights,
	&interrupt, register_fn));
	ASSERT_EQ(1u, register_call_count);
	END_TEST;
	}

	static bool interrupt_creation_mask_test() {
	BEGIN_TEST;
	ResourceDispatcher::ResourceStorage rsrc_storage;
	fbl::RefPtr<MsiAllocation> alloc;
	ASSERT_EQ(ZX_OK, create_resource_storage_and_allocation(&rsrc_storage, &alloc,
	MsiAllocation::kMsiAllocationCountMax));
	fbl::RefPtr<VmObject> vmo;
	fbl::RefPtr<VmMapping> mapping;
	volatile MsiCapability* cap;
	ASSERT_EQ(ZX_OK, create_valid_msi_vmo(&vmo, &mapping, &cap));

	zx_rights_t rights;
	// Below test all the mask variants around PVM. This also serves to ensure
	// that the dtor properly releases the msi registration in all cases.
	// Test 32 bit / no pvm
	{
	cap->control = ~(kMsiPvmSupported \| kMsi64bitSupported);
	for (uint32_t msi_id = 0; msi_id < MsiAllocation::kMsiAllocationCountMax; msi_id++) {
	cap->mask_bits_32 = 0;
	cap->mask_bits_64 = 0;
	KernelHandle<InterruptDispatcher> interrupt;
	ASSERT_EQ(ZX_OK, MsiDispatcher::Create(alloc, msi_id, vmo, /cap_offset=/0, /options=/0,
	&rights, &interrupt, register_fn));
	auto val_32 = cap->mask_bits_32;
	auto val_64 = cap->mask_bits_64;
	EXPECT_EQ(val_32, 0u);
	EXPECT_EQ(val_64, 0u);
	}
	}

	// Test 32 bit / pvm
	{
	cap->control = ~(kMsi64bitSupported);
	for (uint32_t msi_id = 0; msi_id < MsiAllocation::kMsiAllocationCountMax; msi_id++) {
	cap->mask_bits_32 = 0;
	cap->mask_bits_64 = 0;
	KernelHandle<InterruptDispatcher> interrupt;
	ASSERT_EQ(ZX_OK, MsiDispatcher::Create(alloc, msi_id, vmo, /cap_offset=/0, /options=/0,
	&rights, &interrupt, register_fn));
	auto val_32 = cap->mask_bits_32;
	auto val_64 = cap->mask_bits_64;
	EXPECT_EQ(0u, val_32 & (1u << msi_id));
	EXPECT_EQ(val_64, 0u);
	}
	}

	// Test 64 bit / no pvm
	{
	cap->control = kMsi64bitSupported;
	for (uint32_t msi_id = 0; msi_id < MsiAllocation::kMsiAllocationCountMax; msi_id++) {
	cap->mask_bits_32 = 0;
	cap->mask_bits_64 = 0;
	KernelHandle<InterruptDispatcher> interrupt;
	ASSERT_EQ(ZX_OK, MsiDispatcher::Create(alloc, msi_id, vmo, /cap_offset=/0, /options=/0,
	&rights, &interrupt, register_fn));
	auto val_32 = cap->mask_bits_32;
	auto val_64 = cap->mask_bits_64;
	EXPECT_EQ(val_32, 0u);
	EXPECT_EQ(val_64, 0u);
	}
	}

	// Test 32 bit / pvm
	{
	cap->control = kMsiPvmSupported \| kMsi64bitSupported;
	for (uint32_t msi_id = 0; msi_id < MsiAllocation::kMsiAllocationCountMax; msi_id++) {
	cap->mask_bits_32 = 0;
	cap->mask_bits_64 = 0;
	KernelHandle<InterruptDispatcher> interrupt;
	ASSERT_EQ(ZX_OK, MsiDispatcher::Create(alloc, msi_id, vmo, /cap_offset=/0, /options=/0,
	&rights, &interrupt, register_fn));
	auto val_32 = cap->mask_bits_32;
	auto val_64 = cap->mask_bits_64;
	EXPECT_EQ(val_32, 0u);
	EXPECT_EQ(0u, val_64 & (1u << msi_id));
	}
	}

	END_TEST;
	}

	static bool out_of_order_ownership_test() {
	BEGIN_TEST;
	ResourceDispatcher::ResourceStorage rsrc_storage;
	KernelHandle<InterruptDispatcher> interrupt1, interrupt2;
	fbl::RefPtr<VmObject> vmo;
	fbl::RefPtr<VmMapping> mapping;
	volatile MsiCapability* cap;

	ASSERT_EQ(ZX_OK, create_valid_msi_vmo(&vmo, &mapping, &cap));
	{
	zx_rights_t rights;
	fbl::RefPtr<MsiAllocation> alloc;
	ASSERT_EQ(ZX_OK, create_resource_storage_and_allocation(&rsrc_storage, &alloc,
	MsiAllocation::kMsiAllocationCountMax));
	ASSERT_EQ(ZX_OK, MsiDispatcher::Create(alloc, /msi_id=/0, vmo, /cap_offset=/0,
	/options=/0, &rights, &interrupt1, register_fn));
	ASSERT_EQ(ZX_OK, MsiDispatcher::Create(alloc, /msi_id=/1, vmo, /cap_offset=/0,
	/options=/0, &rights, &interrupt2, register_fn));
	}

	// This test verifies that although our allocation order was Alloc -> 1 -> 2,
	// freeing in the same order behaves properly due to the reference ownership.
	interrupt1.release();

	END_TEST;
	}

	UNITTEST_START_TESTCASE(msi_object)
	UNITTEST("Test that Create() and get_info() operate properly", allocation_creation_and_info_test)
	UNITTEST("Test allocation limits", allocation_irq_count_test)
	UNITTEST("Test reservations for MSI ids", allocation_reservation_test)
	UNITTEST("Test for MSI platform support hooks", allocation_support_test)
	UNITTEST("Test that MsiDispatchers cannot overlap on an MSI id", interrupt_duplication_test)
	UNITTEST("Test that MsiDispatcher validates the VMO", interrupt_vmo_test)
	UNITTEST("Test that MsiDispatcher unmasks on creation", interrupt_creation_mask_test)
	UNITTEST("Test that MsiAllocation & MsiDispatcher ownership is correct",
	out_of_order_ownership_test)
	UNITTEST_END_TESTCASE(msi_object, "msi", "Tests for MSI objects")