x86, AMD IOMMU: add domain allocation and deallocation functions

This patch adds the functions to allocate and free protection domains for the
IOMMU.

Signed-off-by: Joerg Roedel <joerg.roedel@amd.com>
Cc: iommu@lists.linux-foundation.org
Cc: bhavna.sarathy@amd.com
Cc: Sebastian.Biemueller@amd.com
Cc: robert.richter@amd.com
Cc: joro@8bytes.org
Signed-off-by: Ingo Molnar <mingo@elte.hu>

1 files changed, 147 insertions, 0 deletions

diff --git a/arch/x86/kernel/amd_iommu.c b/arch/x86/kernel/amd_iommu.c
index 69d8d024387e..c43d15dbc8fa 100644
--- a/arch/x86/kernel/amd_iommu.c
+++ b/arch/x86/kernel/amd_iommu.c
@@ -314,3 +314,150 @@ static void dma_ops_free_addresses(struct dma_ops_domain *dom,
         iommu_area_free(dom->bitmap, address, pages);
 }
 
+static u16 domain_id_alloc(void)
+{
+        unsigned long flags;
+        int id;
+
+        write_lock_irqsave(&amd_iommu_devtable_lock, flags);
+        id = find_first_zero_bit(amd_iommu_pd_alloc_bitmap, MAX_DOMAIN_ID);
+        BUG_ON(id == 0);
+        if (id > 0 && id < MAX_DOMAIN_ID)
+                __set_bit(id, amd_iommu_pd_alloc_bitmap);
+        else
+                id = 0;
+        write_unlock_irqrestore(&amd_iommu_devtable_lock, flags);
+
+        return id;
+}
+
+static void dma_ops_reserve_addresses(struct dma_ops_domain *dom,
+                                      unsigned long start_page,
+                                      unsigned int pages)
+{
+        unsigned int last_page = dom->aperture_size >> PAGE_SHIFT;
+
+        if (start_page + pages > last_page)
+                pages = last_page - start_page;
+
+        set_bit_string(dom->bitmap, start_page, pages);
+}
+
+static void dma_ops_free_pagetable(struct dma_ops_domain *dma_dom)
+{
+        int i, j;
+        u64 *p1, *p2, *p3;
+
+        p1 = dma_dom->domain.pt_root;
+
+        if (!p1)
+                return;
+
+        for (i = 0; i < 512; ++i) {
+                if (!IOMMU_PTE_PRESENT(p1[i]))
+                        continue;
+
+                p2 = IOMMU_PTE_PAGE(p1[i]);
+                for (j = 0; j < 512; ++i) {
+                        if (!IOMMU_PTE_PRESENT(p2[j]))
+                                continue;
+                        p3 = IOMMU_PTE_PAGE(p2[j]);
+                        free_page((unsigned long)p3);
+                }
+
+                free_page((unsigned long)p2);
+        }
+
+        free_page((unsigned long)p1);
+}
+
+static void dma_ops_domain_free(struct dma_ops_domain *dom)
+{
+        if (!dom)
+                return;
+
+        dma_ops_free_pagetable(dom);
+
+        kfree(dom->pte_pages);
+
+        kfree(dom->bitmap);
+
+        kfree(dom);
+}
+
+static struct dma_ops_domain *dma_ops_domain_alloc(struct amd_iommu *iommu,
+                                                   unsigned order)
+{
+        struct dma_ops_domain *dma_dom;
+        unsigned i, num_pte_pages;
+        u64 *l2_pde;
+        u64 address;
+
+        /*
+         * Currently the DMA aperture must be between 32 MB and 1GB in size
+         */
+        if ((order < 25) || (order > 30))
+                return NULL;
+
+        dma_dom = kzalloc(sizeof(struct dma_ops_domain), GFP_KERNEL);
+        if (!dma_dom)
+                return NULL;
+
+        spin_lock_init(&dma_dom->domain.lock);
+
+        dma_dom->domain.id = domain_id_alloc();
+        if (dma_dom->domain.id == 0)
+                goto free_dma_dom;
+        dma_dom->domain.mode = PAGE_MODE_3_LEVEL;
+        dma_dom->domain.pt_root = (void *)get_zeroed_page(GFP_KERNEL);
+        dma_dom->domain.priv = dma_dom;
+        if (!dma_dom->domain.pt_root)
+                goto free_dma_dom;
+        dma_dom->aperture_size = (1ULL << order);
+        dma_dom->bitmap = kzalloc(dma_dom->aperture_size / (PAGE_SIZE * 8),
+                                  GFP_KERNEL);
+        if (!dma_dom->bitmap)
+                goto free_dma_dom;
+        /*
+         * mark the first page as allocated so we never return 0 as
+         * a valid dma-address. So we can use 0 as error value
+         */
+        dma_dom->bitmap[0] = 1;
+        dma_dom->next_bit = 0;
+
+        if (iommu->exclusion_start &&
+            iommu->exclusion_start < dma_dom->aperture_size) {
+                unsigned long startpage = iommu->exclusion_start >> PAGE_SHIFT;
+                int pages = to_pages(iommu->exclusion_start,
+                                iommu->exclusion_length);
+                dma_ops_reserve_addresses(dma_dom, startpage, pages);
+        }
+
+        num_pte_pages = dma_dom->aperture_size / (PAGE_SIZE * 512);
+        dma_dom->pte_pages = kzalloc(num_pte_pages * sizeof(void *),
+                        GFP_KERNEL);
+        if (!dma_dom->pte_pages)
+                goto free_dma_dom;
+
+        l2_pde = (u64 *)get_zeroed_page(GFP_KERNEL);
+        if (l2_pde == NULL)
+                goto free_dma_dom;
+
+        dma_dom->domain.pt_root[0] = IOMMU_L2_PDE(virt_to_phys(l2_pde));
+
+        for (i = 0; i < num_pte_pages; ++i) {
+                dma_dom->pte_pages[i] = (u64 *)get_zeroed_page(GFP_KERNEL);
+                if (!dma_dom->pte_pages[i])
+                        goto free_dma_dom;
+                address = virt_to_phys(dma_dom->pte_pages[i]);
+                l2_pde[i] = IOMMU_L1_PDE(address);
+        }
+
+        return dma_dom;
+
+free_dma_dom:
+        dma_ops_domain_free(dma_dom);
+
+        return NULL;
+}
+