diff --git a/kernel/dev/iommu/intel/device_context.cpp b/kernel/dev/iommu/intel/device_context.cpp
index 194010f..a609d03 100644
--- a/kernel/dev/iommu/intel/device_context.cpp
+++ b/kernel/dev/iommu/intel/device_context.cpp
@@ -6,9 +6,12 @@
 
 #include "device_context.h"
 
+#include <fbl/auto_call.h>
 #include <fbl/unique_ptr.h>
+#include <kernel/range_check.h>
 #include <trace.h>
 #include <vm/vm.h>
+#include <vm/vm_object_paged.h>
 #include <zxcpp/new.h>
 
 #include "hw.h"
@@ -21,13 +24,14 @@
 DeviceContext::DeviceContext(ds::Bdf bdf, uint32_t domain_id, IommuImpl* parent,
                              volatile ds::ExtendedContextEntry* context_entry)
         : parent_(parent), extended_context_entry_(context_entry), second_level_pt_(parent, this),
-          bdf_(bdf), extended_(true), domain_id_(domain_id) {
+          region_alloc_(), bdf_(bdf), extended_(true), domain_id_(domain_id) {
 }
 
 DeviceContext::DeviceContext(ds::Bdf bdf, uint32_t domain_id, IommuImpl* parent,
                              volatile ds::ContextEntry* context_entry)
         : parent_(parent), context_entry_(context_entry), second_level_pt_(parent, this),
-          bdf_(bdf), extended_(false), domain_id_(domain_id) {
+          region_alloc_(), bdf_(bdf), extended_(false),
+          domain_id_(domain_id) {
 }
 
 DeviceContext::~DeviceContext() {
@@ -59,6 +63,30 @@
     second_level_pt_.Destroy();
 }
 
+zx_status_t DeviceContext::InitCommon() {
+    // TODO(teisenbe): don't hardcode PML4_L
+    DEBUG_ASSERT(parent_->caps()->supports_48_bit_agaw());
+    zx_status_t status = second_level_pt_.Init(PML4_L);
+    if (status != ZX_OK) {
+        return status;
+    }
+
+    constexpr size_t kMaxAllocatorMemoryUsage = 16 * PAGE_SIZE;
+    fbl::RefPtr<RegionAllocator::RegionPool> region_pool =
+            RegionAllocator::RegionPool::Create(kMaxAllocatorMemoryUsage);
+    if (region_pool == nullptr) {
+        return ZX_ERR_NO_MEMORY;
+    }
+    region_alloc_.SetRegionPool(fbl::move(region_pool));
+
+    // Start the allocations at 1MB to handle the equivalent of nullptr
+    // dereferences.
+    uint64_t base = 1ull << 20;
+    uint64_t size = aspace_size() - base;
+    region_alloc_.AddRegion({ .base = 1ull << 20, .size = size });
+    return ZX_OK;
+}
+
 zx_status_t DeviceContext::Create(ds::Bdf bdf, uint32_t domain_id, IommuImpl* parent,
                                   volatile ds::ContextEntry* context_entry,
                                   fbl::unique_ptr<DeviceContext>* device) {
@@ -75,9 +103,7 @@
         return ZX_ERR_NO_MEMORY;
     }
 
-    // TODO(teisenbe): don't hardcode PML4_L
-    DEBUG_ASSERT(parent->caps()->supports_48_bit_agaw());
-    zx_status_t status = dev->second_level_pt_.Init(PML4_L);
+    zx_status_t status = dev->InitCommon();
     if (status != ZX_OK) {
         return status;
     }
@@ -113,8 +139,7 @@
         return ZX_ERR_NO_MEMORY;
     }
 
-    DEBUG_ASSERT(parent->caps()->supports_48_bit_agaw());
-    zx_status_t status = dev->second_level_pt_.Init(PML4_L);
+    zx_status_t status = dev->InitCommon();
     if (status != ZX_OK) {
         return status;
     }
@@ -146,11 +171,9 @@
     return ZX_OK;
 }
 
-zx_status_t DeviceContext::SecondLevelMap(const fbl::RefPtr<VmObject>& vmo,
-                                          uint64_t offset, size_t size, uint32_t perms,
-                                          paddr_t* virt_paddr, size_t* mapped_len) {
-    DEBUG_ASSERT(IS_PAGE_ALIGNED(offset));
-    size_t mapped;
+namespace {
+
+uint perms_to_arch_mmu_flags(uint32_t perms) {
     uint flags = 0;
     if (perms & IOMMU_FLAG_PERM_READ) {
         flags |= ARCH_MMU_FLAG_PERM_READ;
@@ -161,6 +184,107 @@
     if (perms & IOMMU_FLAG_PERM_EXECUTE) {
         flags |= ARCH_MMU_FLAG_PERM_EXECUTE;
     }
+    return flags;
+}
+
+} // namespace
+
+zx_status_t DeviceContext::SecondLevelMap(const fbl::RefPtr<VmObject>& vmo, uint64_t offset,
+                                          size_t size, uint32_t perms, bool map_contiguous,
+                                          paddr_t* virt_paddr, size_t* mapped_len) {
+    DEBUG_ASSERT(IS_PAGE_ALIGNED(offset));
+
+    uint flags = perms_to_arch_mmu_flags(perms);
+
+    if (vmo->is_paged() && !static_cast<VmObjectPaged*>(vmo.get())->is_contiguous()) {
+        return SecondLevelMapDiscontiguous(vmo, offset, size, flags, map_contiguous,
+                                           virt_paddr, mapped_len);
+    }
+    return SecondLevelMapContiguous(vmo, offset, size, flags, virt_paddr, mapped_len);
+}
+
+zx_status_t DeviceContext::SecondLevelMapDiscontiguous(const fbl::RefPtr<VmObject>& vmo,
+                                                       uint64_t offset, size_t size, uint flags,
+                                                       bool map_contiguous, paddr_t* virt_paddr,
+                                                       size_t* mapped_len) {
+    // If we don't need to map everything, don't try to map more than
+    // the min contiguity at a time.
+    const uint64_t min_contig = minimum_contiguity();
+    if (!map_contiguous && size > min_contig) {
+        size = min_contig;
+    }
+
+    auto lookup_fn = [](void* ctx, size_t offset, size_t index, paddr_t pa) {
+        paddr_t* paddr = static_cast<paddr_t*>(ctx);
+        paddr[index] = pa;
+        return ZX_OK;
+    };
+
+    fbl::unique_ptr<const RegionAllocator::Region> region;
+    zx_status_t status = region_alloc_.GetRegion(size, min_contig, region);
+    if (status != ZX_OK) {
+        return status;
+    }
+
+    // Reserve a spot in the allocated regions list, so the extension can't fail
+    // after we do the map.
+    fbl::AllocChecker ac;
+    allocated_regions_.reserve(allocated_regions_.size() + 1, &ac);
+    if (!ac.check()) {
+        return ZX_ERR_NO_MEMORY;
+    }
+
+    paddr_t base = region->base;
+    size_t remaining = size;
+
+    auto cleanup_partial = fbl::MakeAutoCall([&]() {
+        size_t allocated = base - region->base;
+        size_t unmapped;
+        second_level_pt_.UnmapPages(base, allocated / PAGE_SIZE, &unmapped);
+        DEBUG_ASSERT(unmapped == allocated / PAGE_SIZE);
+    });
+
+    while (remaining > 0) {
+        const size_t kNumEntriesPerLookup = 32;
+        size_t chunk_size = fbl::min(remaining, kNumEntriesPerLookup * PAGE_SIZE);
+        paddr_t paddrs[kNumEntriesPerLookup] = {};
+        status = vmo->Lookup(offset, chunk_size, 0, lookup_fn, &paddrs);
+        if (status != ZX_OK) {
+            return status;
+        }
+
+        size_t map_len = chunk_size / PAGE_SIZE;
+        size_t mapped;
+        status = second_level_pt_.MapPages(base, paddrs, map_len, flags, &mapped);
+        if (status != ZX_OK) {
+            return status;
+        }
+        ASSERT(mapped == map_len);
+
+        base += chunk_size;
+        offset += chunk_size;
+        remaining -= chunk_size;
+    }
+
+    cleanup_partial.cancel();
+
+    *virt_paddr = region->base;
+    *mapped_len = size;
+
+    allocated_regions_.push_back(fbl::move(region), &ac);
+    // Check shouldn't be able to fail, since we reserved the capacity already
+    ASSERT(ac.check());
+
+    LTRACEF("Map(%02x:%02x.%1x): -> [%p, %p) %#x\n", bdf_.bus(), bdf_.dev(), bdf_.func(),
+            (void*)*virt_paddr, (void*)(*virt_paddr + *mapped_len), flags);
+    return ZX_OK;
+}
+
+zx_status_t DeviceContext::SecondLevelMapContiguous(const fbl::RefPtr<VmObject>& vmo,
+                                                    uint64_t offset, size_t size, uint flags,
+                                                    paddr_t* virt_paddr, size_t* mapped_len) {
+
+    DEBUG_ASSERT(!vmo->is_paged() || static_cast<VmObjectPaged*>(vmo.get())->is_contiguous());
 
     auto lookup_fn = [](void* ctx, size_t offset, size_t index, paddr_t pa) {
         paddr_t* paddr = static_cast<paddr_t*>(ctx);
@@ -168,52 +292,133 @@
         return ZX_OK;
     };
 
-    // Lookup the page in the VMO at the given offset.  If this VMO is a
-    // physical VMO, we know it's contiguous and just extrapolate the rest of
-    // the addresses from the first.  If it's paged, we have no guarantee that
-    // the VMO is contiguous, so just map the first page in.  The caller of this
-    // API will make more calls to map the subsequent pages in.
+    // Lookup the page in the VMO at the given offset.  Since we know the VMO is
+    // contiguous, we can just extrapolate the rest of the addresses from the
+    // first.
     paddr_t paddr = UINT64_MAX;
-    zx_status_t status = vmo->Lookup(offset, fbl::min<size_t>(PAGE_SIZE, size), 0, lookup_fn,
-                                     &paddr);
+    zx_status_t status = vmo->Lookup(offset, PAGE_SIZE, 0, lookup_fn, &paddr);
     if (status != ZX_OK) {
         return status;
     }
-    if (paddr == UINT64_MAX) {
-        return ZX_ERR_BAD_STATE;
+    DEBUG_ASSERT(paddr != UINT64_MAX);
+
+    fbl::unique_ptr<const RegionAllocator::Region> region;
+    uint64_t min_contig = minimum_contiguity();
+    status = region_alloc_.GetRegion(size, min_contig, region);
+    if (status != ZX_OK) {
+        return status;
     }
 
-    size_t map_len;
-    if (vmo->is_paged()) {
-        map_len = 1;
-    } else {
-        map_len = ROUNDUP(size, PAGE_SIZE) / PAGE_SIZE;
+    // Reserve a spot in the allocated regions list, so the extension can't fail
+    // after we do the map.
+    fbl::AllocChecker ac;
+    allocated_regions_.reserve(allocated_regions_.size() + 1, &ac);
+    if (!ac.check()) {
+        return ZX_ERR_NO_MEMORY;
     }
 
-    // TODO(teisenbe): Instead of doing direct mapping, remap to form contiguous
-    // ranges, and handle more than one page at a time in here.
-    status = second_level_pt_.MapPagesContiguous(paddr, paddr, map_len, flags,
-                                                 &mapped);
+    size_t map_len = size / PAGE_SIZE;
+    size_t mapped;
+    status = second_level_pt_.MapPagesContiguous(region->base, paddr, map_len, flags, &mapped);
     if (status != ZX_OK) {
         return status;
     }
     ASSERT(mapped == map_len);
 
-    *virt_paddr = paddr;
+    *virt_paddr = region->base;
     *mapped_len = map_len * PAGE_SIZE;
 
+    allocated_regions_.push_back(fbl::move(region), &ac);
+    // Check shouldn't be able to fail, since we reserved the capacity already
+    ASSERT(ac.check());
+
     LTRACEF("Map(%02x:%02x.%1x): [%p, %p) -> %p %#x\n", bdf_.bus(), bdf_.dev(), bdf_.func(),
-            (void*)paddr, (void*)(paddr + PAGE_SIZE), (void*)paddr, flags);
+            (void*)paddr, (void*)(paddr + size), (void*)paddr, flags);
+    return ZX_OK;
+}
+
+zx_status_t DeviceContext::SecondLevelMapIdentity(paddr_t base, size_t size, uint32_t perms) {
+    DEBUG_ASSERT(IS_PAGE_ALIGNED(base));
+    DEBUG_ASSERT(IS_PAGE_ALIGNED(size));
+
+    uint flags = perms_to_arch_mmu_flags(perms);
+
+    fbl::unique_ptr<const RegionAllocator::Region> region;
+    zx_status_t status = region_alloc_.GetRegion({ base, size }, region);
+    if (status != ZX_OK) {
+        return status;
+    }
+
+    // Reserve a spot in the allocated regions list, so the extension can't fail
+    // after we do the map.
+    fbl::AllocChecker ac;
+    allocated_regions_.reserve(allocated_regions_.size() + 1, &ac);
+    if (!ac.check()) {
+        return ZX_ERR_NO_MEMORY;
+    }
+
+    size_t map_len = size / PAGE_SIZE;
+    size_t mapped;
+    status = second_level_pt_.MapPagesContiguous(base, base, map_len, flags, &mapped);
+    if (status != ZX_OK) {
+        return status;
+    }
+    ASSERT(mapped == map_len);
+
+    allocated_regions_.push_back(fbl::move(region), &ac);
+    ASSERT(ac.check());
     return ZX_OK;
 }
 
 zx_status_t DeviceContext::SecondLevelUnmap(paddr_t virt_paddr, size_t size) {
     DEBUG_ASSERT(IS_PAGE_ALIGNED(virt_paddr));
     DEBUG_ASSERT(IS_PAGE_ALIGNED(size));
-    size_t unmapped;
-    LTRACEF("Unmap(%02x:%02x.%1x): [%p, %p)\n", bdf_.bus(), bdf_.dev(), bdf_.func(),
-            (void*)virt_paddr, (void*)(virt_paddr + size));
-    return second_level_pt_.UnmapPages(virt_paddr, size / PAGE_SIZE, &unmapped);
+
+    // Check if we're trying to partially unmap a region, and if so fail.
+    for (size_t i = 0; i < allocated_regions_.size(); ++i) {
+        const auto& region = allocated_regions_[i];
+
+        paddr_t intersect_base;
+        size_t intersect_size;
+        if (!GetIntersect(virt_paddr, size, region->base, region->size,
+                          &intersect_base, &intersect_size)) {
+            continue;
+        }
+
+        if (intersect_base != region->base || intersect_size != region->size) {
+            return ZX_ERR_NOT_SUPPORTED;
+        }
+    }
+
+    for (size_t i = 0; i < allocated_regions_.size(); ++i) {
+        const auto& region = allocated_regions_[i];
+        if (region->base < virt_paddr || region->base + region->size > virt_paddr + size) {
+            continue;
+        }
+
+        size_t unmapped;
+        LTRACEF("Unmap(%02x:%02x.%1x): [%p, %p)\n", bdf_.bus(), bdf_.dev(), bdf_.func(),
+                (void*)region->base, (void*)(region->base + region->size));
+        zx_status_t status = second_level_pt_.UnmapPages(region->base, region->size / PAGE_SIZE,
+                                                         &unmapped);
+        // Unmap should only fail if an input were invalid
+        ASSERT(status == ZX_OK);
+        allocated_regions_.erase(i);
+        i--;
+    }
+
+    return ZX_OK;
+}
+
+uint64_t DeviceContext::minimum_contiguity() const {
+    // TODO(teisenbe): Do not hardcode this.
+    return 1ull << 20;
+}
+
+uint64_t DeviceContext::aspace_size() const {
+    // TODO(teisenbe): Do not hardcode this
+    // 2^48 is the size of an address space using 4-levevel translation.
+    return 1ull << 48;
 }
 
 } // namespace intel_iommu
diff --git a/kernel/dev/iommu/intel/device_context.h b/kernel/dev/iommu/intel/device_context.h
index 30ba21b..1ca662b 100644
--- a/kernel/dev/iommu/intel/device_context.h
+++ b/kernel/dev/iommu/intel/device_context.h
@@ -9,6 +9,8 @@
 #include <fbl/intrusive_double_list.h>
 #include <fbl/macros.h>
 #include <fbl/unique_ptr.h>
+#include <fbl/vector.h>
+#include <region-alloc/region-alloc.h>
 #include <vm/vm_object.h>
 
 #include "hw.h"
@@ -38,17 +40,27 @@
 
     uint32_t domain_id() const { return domain_id_; }
 
+    uint64_t minimum_contiguity() const;
+    uint64_t aspace_size() const;
+
     // Use the second-level translation table to map the host pages in the given
     // range on |vmo| to the guest's address |*virt_paddr|.  |size| is in bytes.
     // |mapped_len| may be larger than |size|, if |size| was not page-aligned.
     //
-    // This function may return a partial mapping, in which case |mapped_len|
-    // will indicate how many bytes were actually mapped.
+    // If |map_contiguous| is false, this function may return a partial mapping,
+    // in which case |mapped_len| will indicate how many bytes were actually mapped.
+    //
+    // If |map_contiguous| is true, this function will never return a partial
+    // mapping, and |mapped_len| should be equal to |size|.
     zx_status_t SecondLevelMap(const fbl::RefPtr<VmObject>& vmo,
                                uint64_t offset, size_t size, uint32_t perms,
-                               paddr_t* virt_paddr, size_t* mapped_len);
+                               bool map_contiguous, paddr_t* virt_paddr, size_t* mapped_len);
     zx_status_t SecondLevelUnmap(paddr_t virt_paddr, size_t size);
 
+    // Use the second-level translation table to identity-map the given range of
+    // host pages.
+    zx_status_t SecondLevelMapIdentity(paddr_t base, size_t size, uint32_t perms);
+
 private:
     DeviceContext(ds::Bdf bdf, uint32_t domain_id, IommuImpl* parent,
                   volatile ds::ExtendedContextEntry* context_entry);
@@ -57,6 +69,25 @@
 
     DISALLOW_COPY_ASSIGN_AND_MOVE(DeviceContext);
 
+    // Shared initialization code for the two public Create() methods
+    zx_status_t InitCommon();
+
+    // Map a VMO which may consist of discontiguous physical pages.  If
+    // |map_contiguous| is true, this must either map the whole requested range
+    // contiguously, or fail.  If |map_contiguous| is false, it may return
+    // success with a partial mapping.
+    zx_status_t SecondLevelMapDiscontiguous(const fbl::RefPtr<VmObject>& vmo,
+                                            uint64_t offset, size_t size, uint flags,
+                                            bool map_contiguous, paddr_t* virt_paddr,
+                                            size_t* mapped_len);
+
+    // Map a VMO which consists of contiguous physical pages.  Currently we assume
+    // that all contiguous VMOs should be mapped as a contiguous range, so this
+    // function will not return a partial mapping.
+    zx_status_t SecondLevelMapContiguous(const fbl::RefPtr<VmObject>& vmo,
+                                         uint64_t offset, size_t size, uint flags,
+                                         paddr_t* virt_paddr, size_t* mapped_len);
+
     IommuImpl* const parent_;
     union {
         volatile ds::ExtendedContextEntry* const extended_context_entry_;
@@ -66,6 +97,9 @@
     // Page tables used for translating requests-without-PASID and for nested
     // translation of requests-with-PASID.
     SecondLevelPageTable second_level_pt_;
+    RegionAllocator region_alloc_;
+    // TODO(teisenbe): Use a better datastructure for these...
+    fbl::Vector<fbl::unique_ptr<const RegionAllocator::Region>> allocated_regions_;
 
     const ds::Bdf bdf_;
     const bool extended_;
diff --git a/kernel/dev/iommu/intel/iommu_impl.cpp b/kernel/dev/iommu/intel/iommu_impl.cpp
index aedbaa4..ad960d8 100644
--- a/kernel/dev/iommu/intel/iommu_impl.cpp
+++ b/kernel/dev/iommu/intel/iommu_impl.cpp
@@ -244,13 +244,6 @@
     return false;
 }
 
-zx_status_t IommuImpl::MapContiguous(uint64_t bus_txn_id, const fbl::RefPtr<VmObject>& vmo,
-                                     uint64_t offset, size_t size, uint32_t perms,
-                                     dev_vaddr_t* vaddr, size_t* mapped_len) {
-    DEBUG_ASSERT(!vmo->is_paged() || static_cast<VmObjectPaged*>(vmo.get())->is_contiguous());
-    return Map(bus_txn_id, vmo, offset, size, perms, vaddr, mapped_len);
-}
-
 zx_status_t IommuImpl::Map(uint64_t bus_txn_id, const fbl::RefPtr<VmObject>& vmo,
                            uint64_t offset, size_t size, uint32_t perms,
                            dev_vaddr_t* vaddr, size_t* mapped_len) {
@@ -276,7 +269,42 @@
     if (status != ZX_OK) {
         return status;
     }
-    status = dev->SecondLevelMap(vmo, offset, size, perms, vaddr, mapped_len);
+    status = dev->SecondLevelMap(vmo, offset, size, perms, false /* map_contiguous */,
+                                 vaddr, mapped_len);
+    if (status != ZX_OK) {
+        return status;
+    }
+
+    return ZX_OK;
+}
+
+zx_status_t IommuImpl::MapContiguous(uint64_t bus_txn_id, const fbl::RefPtr<VmObject>& vmo,
+                                     uint64_t offset, size_t size, uint32_t perms,
+                                     dev_vaddr_t* vaddr, size_t* mapped_len) {
+    DEBUG_ASSERT(vaddr);
+    if (!IS_PAGE_ALIGNED(offset) || size == 0) {
+        return ZX_ERR_INVALID_ARGS;
+    }
+    if (perms & ~(IOMMU_FLAG_PERM_READ | IOMMU_FLAG_PERM_WRITE | IOMMU_FLAG_PERM_EXECUTE)) {
+        return ZX_ERR_INVALID_ARGS;
+    }
+    if (perms == 0) {
+        return ZX_ERR_INVALID_ARGS;
+    }
+    if (!IsValidBusTxnId(bus_txn_id)) {
+        return ZX_ERR_NOT_FOUND;
+    }
+
+    ds::Bdf bdf = decode_bus_txn_id(bus_txn_id);
+
+    fbl::AutoLock guard(&lock_);
+    DeviceContext* dev;
+    zx_status_t status = GetOrCreateDeviceContextLocked(bdf, &dev);
+    if (status != ZX_OK) {
+        return status;
+    }
+    status = dev->SecondLevelMap(vmo, offset, size, perms, true /* map_contiguous */,
+                                 vaddr, mapped_len);
     if (status != ZX_OK) {
         return status;
     }
@@ -426,23 +454,14 @@
                 return status;
             }
 
-            fbl::RefPtr<VmObject> vmo;
-            status = VmObjectPhysical::Create(mem->base_addr, mem->len, &vmo);
-            if (status != ZX_OK) {
-                return status;
-            }
-
             LTRACEF("Enabling region [%lx, %lx) for %02x:%02x.%02x\n", mem->base_addr,
                     mem->base_addr + mem->len, bdf.bus(), bdf.dev(), bdf.func());
-            dev_vaddr_t vaddr;
-            size_t mapped_len;
+            size_t size = ROUNDUP(mem->len, PAGE_SIZE);
             const uint32_t perms = IOMMU_FLAG_PERM_READ | IOMMU_FLAG_PERM_WRITE;
-            status = dev->SecondLevelMap(vmo, 0, mem->len, perms, &vaddr, &mapped_len);
+            status = dev->SecondLevelMapIdentity(mem->base_addr, size, perms);
             if (status != ZX_OK) {
                 return status;
             }
-            ASSERT(vaddr == mem->base_addr);
-            ASSERT(mapped_len == ROUNDUP(mem->len, PAGE_SIZE));
         }
 
         cursor_bytes += sizeof(*mem) + mem->scope_bytes;
@@ -773,14 +792,37 @@
 }
 
 uint64_t IommuImpl::minimum_contiguity(uint64_t bus_txn_id) {
-    // TODO(teisenbe): Discover this from the device context
-    return PAGE_SIZE;
+    if (!IsValidBusTxnId(bus_txn_id)) {
+        return 0;
+    }
+
+    ds::Bdf bdf = decode_bus_txn_id(bus_txn_id);
+
+    fbl::AutoLock guard(&lock_);
+    DeviceContext* dev;
+    zx_status_t status = GetOrCreateDeviceContextLocked(bdf, &dev);
+    if (status != ZX_OK) {
+        return status;
+    }
+
+    return dev->minimum_contiguity();
 }
 
 uint64_t IommuImpl::aspace_size(uint64_t bus_txn_id) {
-    // TODO(teisenbe): Discover this from the device context
-    // 2^48 is the size of an address space using 4-levevel translation.
-    return 1ull << 48;
+    if (!IsValidBusTxnId(bus_txn_id)) {
+        return 0;
+    }
+
+    ds::Bdf bdf = decode_bus_txn_id(bus_txn_id);
+
+    fbl::AutoLock guard(&lock_);
+    DeviceContext* dev;
+    zx_status_t status = GetOrCreateDeviceContextLocked(bdf, &dev);
+    if (status != ZX_OK) {
+        return status;
+    }
+
+    return dev->aspace_size();
 }
 
 } // namespace intel_iommu
diff --git a/kernel/dev/iommu/intel/rules.mk b/kernel/dev/iommu/intel/rules.mk
index 5ec8dfc..19ecaf3 100644
--- a/kernel/dev/iommu/intel/rules.mk
+++ b/kernel/dev/iommu/intel/rules.mk
@@ -22,5 +22,6 @@
     kernel/lib/bitmap \
     kernel/lib/fbl \
     kernel/lib/hwreg \
+    kernel/lib/region-alloc \
 
 include make/module.mk