habanalabs: fix possible hole in device va

cb_map_mem() uses gen_pool_alloc() to get virtual address for
mapping a CB.
The mapping is done in chunks of page size, so if the CB size is
larger, it is possible that the allocated virtual addresses won't
be consecutive.
User retrieves this device VA which returns the virtual address
in the first va_block. If there is a "hole" in the virtual addresses,
user can configure a HW block with a bad device VA.

Signed-off-by: farah kassabri <fkassabri@habana.ai>
Reviewed-by: Oded Gabbay <ogabbay@kernel.org>
Signed-off-by: Oded Gabbay <ogabbay@kernel.org>

diff --git a/drivers/misc/habanalabs/common/command_buffer.c b/drivers/misc/habanalabs/common/command_buffer.c
index c3e2568542a15e5a0d0398fe182202d81b0d9b9a..d16de18863ba036bfc6123dbc661eb9c5fd0adb0 100644 (file)
--- a/drivers/misc/habanalabs/common/command_buffer.c
+++ b/drivers/misc/habanalabs/common/command_buffer.c
@@ -18,11 +18,7 @@ static int cb_map_mem(struct hl_ctx *ctx, struct hl_cb *cb)
 {
        struct hl_device *hdev = ctx->hdev;
        struct asic_fixed_properties *prop = &hdev->asic_prop;
-       struct hl_vm_va_block *va_block, *tmp;
-       dma_addr_t bus_addr;
-       u64 virt_addr;
        u32 page_size = prop->pmmu.page_size;
-       s32 offset;
        int rc;
 
        if (!hdev->supports_cb_mapping) {
@@ -37,106 +33,45 @@ static int cb_map_mem(struct hl_ctx *ctx, struct hl_cb *cb)
                return -EINVAL;
        }
 
-       INIT_LIST_HEAD(&cb->va_block_list);
-
-       for (bus_addr = cb->bus_address;
-                       bus_addr < cb->bus_address + cb->size;
-                       bus_addr += page_size) {
-
-               virt_addr = (u64) gen_pool_alloc(ctx->cb_va_pool, page_size);
-               if (!virt_addr) {
-                       dev_err(hdev->dev,
-                               "Failed to allocate device virtual address for CB\n");
-                       rc = -ENOMEM;
-                       goto err_va_pool_free;
-               }
+       if (cb->is_mmu_mapped)
+               return 0;
 
-               va_block = kzalloc(sizeof(*va_block), GFP_KERNEL);
-               if (!va_block) {
-                       rc = -ENOMEM;
-                       gen_pool_free(ctx->cb_va_pool, virt_addr, page_size);
-                       goto err_va_pool_free;
-               }
+       cb->roundup_size = roundup(cb->size, page_size);
 
-               va_block->start = virt_addr;
-               va_block->end = virt_addr + page_size - 1;
-               va_block->size = page_size;
-               list_add_tail(&va_block->node, &cb->va_block_list);
+       cb->virtual_addr = (u64) gen_pool_alloc(ctx->cb_va_pool, cb->roundup_size);
+       if (!cb->virtual_addr) {
+               dev_err(hdev->dev, "Failed to allocate device virtual address for CB\n");
+               return -ENOMEM;
        }
 
        mutex_lock(&ctx->mmu_lock);
-
-       bus_addr = cb->bus_address;
-       offset = 0;
-       list_for_each_entry(va_block, &cb->va_block_list, node) {
-               rc = hl_mmu_map_page(ctx, va_block->start, bus_addr,
-                               va_block->size, list_is_last(&va_block->node,
-                                                       &cb->va_block_list));
-               if (rc) {
-                       dev_err(hdev->dev, "Failed to map VA %#llx to CB\n",
-                               va_block->start);
-                       goto err_va_umap;
-               }
-
-               bus_addr += va_block->size;
-               offset += va_block->size;
+       rc = hl_mmu_map_contiguous(ctx, cb->virtual_addr, cb->bus_address, cb->roundup_size);
+       if (rc) {
+               dev_err(hdev->dev, "Failed to map VA %#llx to CB\n", cb->virtual_addr);
+               goto err_va_umap;
        }
-
        rc = hl_mmu_invalidate_cache(hdev, false, MMU_OP_USERPTR | MMU_OP_SKIP_LOW_CACHE_INV);
-
        mutex_unlock(&ctx->mmu_lock);
 
        cb->is_mmu_mapped = true;
-
        return rc;
 
 err_va_umap:
-       list_for_each_entry(va_block, &cb->va_block_list, node) {
-               if (offset <= 0)
-                       break;
-               hl_mmu_unmap_page(ctx, va_block->start, va_block->size,
-                               offset <= va_block->size);
-               offset -= va_block->size;
-       }
-
-       rc = hl_mmu_invalidate_cache(hdev, true, MMU_OP_USERPTR);
-
        mutex_unlock(&ctx->mmu_lock);
-
-err_va_pool_free:
-       list_for_each_entry_safe(va_block, tmp, &cb->va_block_list, node) {
-               gen_pool_free(ctx->cb_va_pool, va_block->start, va_block->size);
-               list_del(&va_block->node);
-               kfree(va_block);
-       }
-
+       gen_pool_free(ctx->cb_va_pool, cb->virtual_addr, cb->roundup_size);
        return rc;
 }
 
 static void cb_unmap_mem(struct hl_ctx *ctx, struct hl_cb *cb)
 {
        struct hl_device *hdev = ctx->hdev;
-       struct hl_vm_va_block *va_block, *tmp;
 
        mutex_lock(&ctx->mmu_lock);
-
-       list_for_each_entry(va_block, &cb->va_block_list, node)
-               if (hl_mmu_unmap_page(ctx, va_block->start, va_block->size,
-                               list_is_last(&va_block->node,
-                                               &cb->va_block_list)))
-                       dev_warn_ratelimited(hdev->dev,
-                                       "Failed to unmap CB's va 0x%llx\n",
-                                       va_block->start);
-
+       hl_mmu_unmap_contiguous(ctx, cb->virtual_addr, cb->roundup_size);
        hl_mmu_invalidate_cache(hdev, true, MMU_OP_USERPTR);
-
        mutex_unlock(&ctx->mmu_lock);
 
-       list_for_each_entry_safe(va_block, tmp, &cb->va_block_list, node) {
-               gen_pool_free(ctx->cb_va_pool, va_block->start, va_block->size);
-               list_del(&va_block->node);
-               kfree(va_block);
-       }
+       gen_pool_free(ctx->cb_va_pool, cb->virtual_addr, cb->roundup_size);
 }
 
 static void cb_fini(struct hl_device *hdev, struct hl_cb *cb)
@@ -378,7 +313,6 @@ int hl_cb_destroy(struct hl_mem_mgr *mmg, u64 cb_handle)
 static int hl_cb_info(struct hl_mem_mgr *mmg,
                        u64 handle, u32 flags, u32 *usage_cnt, u64 *device_va)
 {
-       struct hl_vm_va_block *va_block;
        struct hl_cb *cb;
        int rc = 0;
 
@@ -390,9 +324,8 @@ static int hl_cb_info(struct hl_mem_mgr *mmg,
        }
 
        if (flags & HL_CB_FLAGS_GET_DEVICE_VA) {
-               va_block = list_first_entry(&cb->va_block_list, struct hl_vm_va_block, node);
-               if (va_block) {
-                       *device_va = va_block->start;
+               if (cb->is_mmu_mapped) {
+                       *device_va = cb->virtual_addr;
                } else {
                        dev_err(mmg->dev, "CB is not mapped to the device's MMU\n");
                        rc = -EINVAL;

diff --git a/drivers/misc/habanalabs/common/habanalabs.h b/drivers/misc/habanalabs/common/habanalabs.h
index c1bd82d4a83c9550718b70d5af8acbcc825f11e5..b7e01651d42981685942081d880de05ea0adf021 100644 (file)
--- a/drivers/misc/habanalabs/common/habanalabs.h
+++ b/drivers/misc/habanalabs/common/habanalabs.h
@@ -917,11 +917,11 @@ struct hl_mmap_mem_buf {
  * @buf: back pointer to the parent mappable memory buffer
  * @debugfs_list: node in debugfs list of command buffers.
  * @pool_list: node in pool list of command buffers.
- * @va_block_list: list of virtual addresses blocks of the CB if it is mapped to
- *                 the device's MMU.
  * @kernel_address: Holds the CB's kernel virtual address.
+ * @virtual_addr: Holds the CB's virtual address.
  * @bus_address: Holds the CB's DMA address.
  * @size: holds the CB's size.
+ * @roundup_size: holds the cb size after roundup to page size.
  * @cs_cnt: holds number of CS that this CB participates in.
  * @is_pool: true if CB was acquired from the pool, false otherwise.
  * @is_internal: internally allocated
@@ -933,10 +933,11 @@ struct hl_cb {
        struct hl_mmap_mem_buf  *buf;
        struct list_head        debugfs_list;
        struct list_head        pool_list;
-       struct list_head        va_block_list;
        void                    *kernel_address;
+       u64                     virtual_addr;
        dma_addr_t              bus_address;
        u32                     size;
+       u32                     roundup_size;
        atomic_t                cs_cnt;
        u8                      is_pool;
        u8                      is_internal;