1724 lines
48 KiB
C
1724 lines
48 KiB
C
// SPDX-License-Identifier: GPL-2.0-only
|
|
/*
|
|
* Copyright (c) 2022 Red Hat.
|
|
*
|
|
* Permission is hereby granted, free of charge, to any person obtaining a
|
|
* copy of this software and associated documentation files (the "Software"),
|
|
* to deal in the Software without restriction, including without limitation
|
|
* the rights to use, copy, modify, merge, publish, distribute, sublicense,
|
|
* and/or sell copies of the Software, and to permit persons to whom the
|
|
* Software is furnished to do so, subject to the following conditions:
|
|
*
|
|
* The above copyright notice and this permission notice shall be included in
|
|
* all copies or substantial portions of the Software.
|
|
*
|
|
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
|
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
|
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
|
|
* THE COPYRIGHT HOLDER(S) OR AUTHOR(S) BE LIABLE FOR ANY CLAIM, DAMAGES OR
|
|
* OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
|
|
* ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
|
|
* OTHER DEALINGS IN THE SOFTWARE.
|
|
*
|
|
* Authors:
|
|
* Danilo Krummrich <dakr@redhat.com>
|
|
*
|
|
*/
|
|
|
|
#include <drm/drm_gpuva_mgr.h>
|
|
|
|
#include <linux/interval_tree_generic.h>
|
|
#include <linux/mm.h>
|
|
|
|
/**
|
|
* DOC: Overview
|
|
*
|
|
* The DRM GPU VA Manager, represented by struct drm_gpuva_manager keeps track
|
|
* of a GPU's virtual address (VA) space and manages the corresponding virtual
|
|
* mappings represented by &drm_gpuva objects. It also keeps track of the
|
|
* mapping's backing &drm_gem_object buffers.
|
|
*
|
|
* &drm_gem_object buffers maintain a list of &drm_gpuva objects representing
|
|
* all existent GPU VA mappings using this &drm_gem_object as backing buffer.
|
|
*
|
|
* GPU VAs can be flagged as sparse, such that drivers may use GPU VAs to also
|
|
* keep track of sparse PTEs in order to support Vulkan 'Sparse Resources'.
|
|
*
|
|
* The GPU VA manager internally uses a rb-tree to manage the
|
|
* &drm_gpuva mappings within a GPU's virtual address space.
|
|
*
|
|
* The &drm_gpuva_manager contains a special &drm_gpuva representing the
|
|
* portion of VA space reserved by the kernel. This node is initialized together
|
|
* with the GPU VA manager instance and removed when the GPU VA manager is
|
|
* destroyed.
|
|
*
|
|
* In a typical application drivers would embed struct drm_gpuva_manager and
|
|
* struct drm_gpuva within their own driver specific structures, there won't be
|
|
* any memory allocations of its own nor memory allocations of &drm_gpuva
|
|
* entries.
|
|
*
|
|
* The data structures needed to store &drm_gpuvas within the &drm_gpuva_manager
|
|
* are contained within struct drm_gpuva already. Hence, for inserting
|
|
* &drm_gpuva entries from within dma-fence signalling critical sections it is
|
|
* enough to pre-allocate the &drm_gpuva structures.
|
|
*/
|
|
|
|
/**
|
|
* DOC: Split and Merge
|
|
*
|
|
* Besides its capability to manage and represent a GPU VA space, the
|
|
* &drm_gpuva_manager also provides functions to let the &drm_gpuva_manager
|
|
* calculate a sequence of operations to satisfy a given map or unmap request.
|
|
*
|
|
* Therefore the DRM GPU VA manager provides an algorithm implementing splitting
|
|
* and merging of existent GPU VA mappings with the ones that are requested to
|
|
* be mapped or unmapped. This feature is required by the Vulkan API to
|
|
* implement Vulkan 'Sparse Memory Bindings' - drivers UAPIs often refer to this
|
|
* as VM BIND.
|
|
*
|
|
* Drivers can call drm_gpuva_sm_map() to receive a sequence of callbacks
|
|
* containing map, unmap and remap operations for a given newly requested
|
|
* mapping. The sequence of callbacks represents the set of operations to
|
|
* execute in order to integrate the new mapping cleanly into the current state
|
|
* of the GPU VA space.
|
|
*
|
|
* Depending on how the new GPU VA mapping intersects with the existent mappings
|
|
* of the GPU VA space the &drm_gpuva_fn_ops callbacks contain an arbitrary
|
|
* amount of unmap operations, a maximum of two remap operations and a single
|
|
* map operation. The caller might receive no callback at all if no operation is
|
|
* required, e.g. if the requested mapping already exists in the exact same way.
|
|
*
|
|
* The single map operation represents the original map operation requested by
|
|
* the caller.
|
|
*
|
|
* &drm_gpuva_op_unmap contains a 'keep' field, which indicates whether the
|
|
* &drm_gpuva to unmap is physically contiguous with the original mapping
|
|
* request. Optionally, if 'keep' is set, drivers may keep the actual page table
|
|
* entries for this &drm_gpuva, adding the missing page table entries only and
|
|
* update the &drm_gpuva_manager's view of things accordingly.
|
|
*
|
|
* Drivers may do the same optimization, namely delta page table updates, also
|
|
* for remap operations. This is possible since &drm_gpuva_op_remap consists of
|
|
* one unmap operation and one or two map operations, such that drivers can
|
|
* derive the page table update delta accordingly.
|
|
*
|
|
* Note that there can't be more than two existent mappings to split up, one at
|
|
* the beginning and one at the end of the new mapping, hence there is a
|
|
* maximum of two remap operations.
|
|
*
|
|
* Analogous to drm_gpuva_sm_map() drm_gpuva_sm_unmap() uses &drm_gpuva_fn_ops
|
|
* to call back into the driver in order to unmap a range of GPU VA space. The
|
|
* logic behind this function is way simpler though: For all existent mappings
|
|
* enclosed by the given range unmap operations are created. For mappings which
|
|
* are only partically located within the given range, remap operations are
|
|
* created such that those mappings are split up and re-mapped partically.
|
|
*
|
|
* As an alternative to drm_gpuva_sm_map() and drm_gpuva_sm_unmap(),
|
|
* drm_gpuva_sm_map_ops_create() and drm_gpuva_sm_unmap_ops_create() can be used
|
|
* to directly obtain an instance of struct drm_gpuva_ops containing a list of
|
|
* &drm_gpuva_op, which can be iterated with drm_gpuva_for_each_op(). This list
|
|
* contains the &drm_gpuva_ops analogous to the callbacks one would receive when
|
|
* calling drm_gpuva_sm_map() or drm_gpuva_sm_unmap(). While this way requires
|
|
* more memory (to allocate the &drm_gpuva_ops), it provides drivers a way to
|
|
* iterate the &drm_gpuva_op multiple times, e.g. once in a context where memory
|
|
* allocations are possible (e.g. to allocate GPU page tables) and once in the
|
|
* dma-fence signalling critical path.
|
|
*
|
|
* To update the &drm_gpuva_manager's view of the GPU VA space
|
|
* drm_gpuva_insert() and drm_gpuva_remove() may be used. These functions can
|
|
* safely be used from &drm_gpuva_fn_ops callbacks originating from
|
|
* drm_gpuva_sm_map() or drm_gpuva_sm_unmap(). However, it might be more
|
|
* convenient to use the provided helper functions drm_gpuva_map(),
|
|
* drm_gpuva_remap() and drm_gpuva_unmap() instead.
|
|
*
|
|
* The following diagram depicts the basic relationships of existent GPU VA
|
|
* mappings, a newly requested mapping and the resulting mappings as implemented
|
|
* by drm_gpuva_sm_map() - it doesn't cover any arbitrary combinations of these.
|
|
*
|
|
* 1) Requested mapping is identical. Replace it, but indicate the backing PTEs
|
|
* could be kept.
|
|
*
|
|
* ::
|
|
*
|
|
* 0 a 1
|
|
* old: |-----------| (bo_offset=n)
|
|
*
|
|
* 0 a 1
|
|
* req: |-----------| (bo_offset=n)
|
|
*
|
|
* 0 a 1
|
|
* new: |-----------| (bo_offset=n)
|
|
*
|
|
*
|
|
* 2) Requested mapping is identical, except for the BO offset, hence replace
|
|
* the mapping.
|
|
*
|
|
* ::
|
|
*
|
|
* 0 a 1
|
|
* old: |-----------| (bo_offset=n)
|
|
*
|
|
* 0 a 1
|
|
* req: |-----------| (bo_offset=m)
|
|
*
|
|
* 0 a 1
|
|
* new: |-----------| (bo_offset=m)
|
|
*
|
|
*
|
|
* 3) Requested mapping is identical, except for the backing BO, hence replace
|
|
* the mapping.
|
|
*
|
|
* ::
|
|
*
|
|
* 0 a 1
|
|
* old: |-----------| (bo_offset=n)
|
|
*
|
|
* 0 b 1
|
|
* req: |-----------| (bo_offset=n)
|
|
*
|
|
* 0 b 1
|
|
* new: |-----------| (bo_offset=n)
|
|
*
|
|
*
|
|
* 4) Existent mapping is a left aligned subset of the requested one, hence
|
|
* replace the existent one.
|
|
*
|
|
* ::
|
|
*
|
|
* 0 a 1
|
|
* old: |-----| (bo_offset=n)
|
|
*
|
|
* 0 a 2
|
|
* req: |-----------| (bo_offset=n)
|
|
*
|
|
* 0 a 2
|
|
* new: |-----------| (bo_offset=n)
|
|
*
|
|
* .. note::
|
|
* We expect to see the same result for a request with a different BO
|
|
* and/or non-contiguous BO offset.
|
|
*
|
|
*
|
|
* 5) Requested mapping's range is a left aligned subset of the existent one,
|
|
* but backed by a different BO. Hence, map the requested mapping and split
|
|
* the existent one adjusting its BO offset.
|
|
*
|
|
* ::
|
|
*
|
|
* 0 a 2
|
|
* old: |-----------| (bo_offset=n)
|
|
*
|
|
* 0 b 1
|
|
* req: |-----| (bo_offset=n)
|
|
*
|
|
* 0 b 1 a' 2
|
|
* new: |-----|-----| (b.bo_offset=n, a.bo_offset=n+1)
|
|
*
|
|
* .. note::
|
|
* We expect to see the same result for a request with a different BO
|
|
* and/or non-contiguous BO offset.
|
|
*
|
|
*
|
|
* 6) Existent mapping is a superset of the requested mapping. Split it up, but
|
|
* indicate that the backing PTEs could be kept.
|
|
*
|
|
* ::
|
|
*
|
|
* 0 a 2
|
|
* old: |-----------| (bo_offset=n)
|
|
*
|
|
* 0 a 1
|
|
* req: |-----| (bo_offset=n)
|
|
*
|
|
* 0 a 1 a' 2
|
|
* new: |-----|-----| (a.bo_offset=n, a'.bo_offset=n+1)
|
|
*
|
|
*
|
|
* 7) Requested mapping's range is a right aligned subset of the existent one,
|
|
* but backed by a different BO. Hence, map the requested mapping and split
|
|
* the existent one, without adjusting the BO offset.
|
|
*
|
|
* ::
|
|
*
|
|
* 0 a 2
|
|
* old: |-----------| (bo_offset=n)
|
|
*
|
|
* 1 b 2
|
|
* req: |-----| (bo_offset=m)
|
|
*
|
|
* 0 a 1 b 2
|
|
* new: |-----|-----| (a.bo_offset=n,b.bo_offset=m)
|
|
*
|
|
*
|
|
* 8) Existent mapping is a superset of the requested mapping. Split it up, but
|
|
* indicate that the backing PTEs could be kept.
|
|
*
|
|
* ::
|
|
*
|
|
* 0 a 2
|
|
* old: |-----------| (bo_offset=n)
|
|
*
|
|
* 1 a 2
|
|
* req: |-----| (bo_offset=n+1)
|
|
*
|
|
* 0 a' 1 a 2
|
|
* new: |-----|-----| (a'.bo_offset=n, a.bo_offset=n+1)
|
|
*
|
|
*
|
|
* 9) Existent mapping is overlapped at the end by the requested mapping backed
|
|
* by a different BO. Hence, map the requested mapping and split up the
|
|
* existent one, without adjusting the BO offset.
|
|
*
|
|
* ::
|
|
*
|
|
* 0 a 2
|
|
* old: |-----------| (bo_offset=n)
|
|
*
|
|
* 1 b 3
|
|
* req: |-----------| (bo_offset=m)
|
|
*
|
|
* 0 a 1 b 3
|
|
* new: |-----|-----------| (a.bo_offset=n,b.bo_offset=m)
|
|
*
|
|
*
|
|
* 10) Existent mapping is overlapped by the requested mapping, both having the
|
|
* same backing BO with a contiguous offset. Indicate the backing PTEs of
|
|
* the old mapping could be kept.
|
|
*
|
|
* ::
|
|
*
|
|
* 0 a 2
|
|
* old: |-----------| (bo_offset=n)
|
|
*
|
|
* 1 a 3
|
|
* req: |-----------| (bo_offset=n+1)
|
|
*
|
|
* 0 a' 1 a 3
|
|
* new: |-----|-----------| (a'.bo_offset=n, a.bo_offset=n+1)
|
|
*
|
|
*
|
|
* 11) Requested mapping's range is a centered subset of the existent one
|
|
* having a different backing BO. Hence, map the requested mapping and split
|
|
* up the existent one in two mappings, adjusting the BO offset of the right
|
|
* one accordingly.
|
|
*
|
|
* ::
|
|
*
|
|
* 0 a 3
|
|
* old: |-----------------| (bo_offset=n)
|
|
*
|
|
* 1 b 2
|
|
* req: |-----| (bo_offset=m)
|
|
*
|
|
* 0 a 1 b 2 a' 3
|
|
* new: |-----|-----|-----| (a.bo_offset=n,b.bo_offset=m,a'.bo_offset=n+2)
|
|
*
|
|
*
|
|
* 12) Requested mapping is a contiguous subset of the existent one. Split it
|
|
* up, but indicate that the backing PTEs could be kept.
|
|
*
|
|
* ::
|
|
*
|
|
* 0 a 3
|
|
* old: |-----------------| (bo_offset=n)
|
|
*
|
|
* 1 a 2
|
|
* req: |-----| (bo_offset=n+1)
|
|
*
|
|
* 0 a' 1 a 2 a'' 3
|
|
* old: |-----|-----|-----| (a'.bo_offset=n, a.bo_offset=n+1, a''.bo_offset=n+2)
|
|
*
|
|
*
|
|
* 13) Existent mapping is a right aligned subset of the requested one, hence
|
|
* replace the existent one.
|
|
*
|
|
* ::
|
|
*
|
|
* 1 a 2
|
|
* old: |-----| (bo_offset=n+1)
|
|
*
|
|
* 0 a 2
|
|
* req: |-----------| (bo_offset=n)
|
|
*
|
|
* 0 a 2
|
|
* new: |-----------| (bo_offset=n)
|
|
*
|
|
* .. note::
|
|
* We expect to see the same result for a request with a different bo
|
|
* and/or non-contiguous bo_offset.
|
|
*
|
|
*
|
|
* 14) Existent mapping is a centered subset of the requested one, hence
|
|
* replace the existent one.
|
|
*
|
|
* ::
|
|
*
|
|
* 1 a 2
|
|
* old: |-----| (bo_offset=n+1)
|
|
*
|
|
* 0 a 3
|
|
* req: |----------------| (bo_offset=n)
|
|
*
|
|
* 0 a 3
|
|
* new: |----------------| (bo_offset=n)
|
|
*
|
|
* .. note::
|
|
* We expect to see the same result for a request with a different bo
|
|
* and/or non-contiguous bo_offset.
|
|
*
|
|
*
|
|
* 15) Existent mappings is overlapped at the beginning by the requested mapping
|
|
* backed by a different BO. Hence, map the requested mapping and split up
|
|
* the existent one, adjusting its BO offset accordingly.
|
|
*
|
|
* ::
|
|
*
|
|
* 1 a 3
|
|
* old: |-----------| (bo_offset=n)
|
|
*
|
|
* 0 b 2
|
|
* req: |-----------| (bo_offset=m)
|
|
*
|
|
* 0 b 2 a' 3
|
|
* new: |-----------|-----| (b.bo_offset=m,a.bo_offset=n+2)
|
|
*/
|
|
|
|
/**
|
|
* DOC: Locking
|
|
*
|
|
* Generally, the GPU VA manager does not take care of locking itself, it is
|
|
* the drivers responsibility to take care about locking. Drivers might want to
|
|
* protect the following operations: inserting, removing and iterating
|
|
* &drm_gpuva objects as well as generating all kinds of operations, such as
|
|
* split / merge or prefetch.
|
|
*
|
|
* The GPU VA manager also does not take care of the locking of the backing
|
|
* &drm_gem_object buffers GPU VA lists by itself; drivers are responsible to
|
|
* enforce mutual exclusion using either the GEMs dma_resv lock or alternatively
|
|
* a driver specific external lock. For the latter see also
|
|
* drm_gem_gpuva_set_lock().
|
|
*
|
|
* However, the GPU VA manager contains lockdep checks to ensure callers of its
|
|
* API hold the corresponding lock whenever the &drm_gem_objects GPU VA list is
|
|
* accessed by functions such as drm_gpuva_link() or drm_gpuva_unlink().
|
|
*/
|
|
|
|
/**
|
|
* DOC: Examples
|
|
*
|
|
* This section gives two examples on how to let the DRM GPUVA Manager generate
|
|
* &drm_gpuva_op in order to satisfy a given map or unmap request and how to
|
|
* make use of them.
|
|
*
|
|
* The below code is strictly limited to illustrate the generic usage pattern.
|
|
* To maintain simplicitly, it doesn't make use of any abstractions for common
|
|
* code, different (asyncronous) stages with fence signalling critical paths,
|
|
* any other helpers or error handling in terms of freeing memory and dropping
|
|
* previously taken locks.
|
|
*
|
|
* 1) Obtain a list of &drm_gpuva_op to create a new mapping::
|
|
*
|
|
* // Allocates a new &drm_gpuva.
|
|
* struct drm_gpuva * driver_gpuva_alloc(void);
|
|
*
|
|
* // Typically drivers would embedd the &drm_gpuva_manager and &drm_gpuva
|
|
* // structure in individual driver structures and lock the dma-resv with
|
|
* // drm_exec or similar helpers.
|
|
* int driver_mapping_create(struct drm_gpuva_manager *mgr,
|
|
* u64 addr, u64 range,
|
|
* struct drm_gem_object *obj, u64 offset)
|
|
* {
|
|
* struct drm_gpuva_ops *ops;
|
|
* struct drm_gpuva_op *op
|
|
*
|
|
* driver_lock_va_space();
|
|
* ops = drm_gpuva_sm_map_ops_create(mgr, addr, range,
|
|
* obj, offset);
|
|
* if (IS_ERR(ops))
|
|
* return PTR_ERR(ops);
|
|
*
|
|
* drm_gpuva_for_each_op(op, ops) {
|
|
* struct drm_gpuva *va;
|
|
*
|
|
* switch (op->op) {
|
|
* case DRM_GPUVA_OP_MAP:
|
|
* va = driver_gpuva_alloc();
|
|
* if (!va)
|
|
* ; // unwind previous VA space updates,
|
|
* // free memory and unlock
|
|
*
|
|
* driver_vm_map();
|
|
* drm_gpuva_map(mgr, va, &op->map);
|
|
* drm_gpuva_link(va);
|
|
*
|
|
* break;
|
|
* case DRM_GPUVA_OP_REMAP: {
|
|
* struct drm_gpuva *prev = NULL, *next = NULL;
|
|
*
|
|
* va = op->remap.unmap->va;
|
|
*
|
|
* if (op->remap.prev) {
|
|
* prev = driver_gpuva_alloc();
|
|
* if (!prev)
|
|
* ; // unwind previous VA space
|
|
* // updates, free memory and
|
|
* // unlock
|
|
* }
|
|
*
|
|
* if (op->remap.next) {
|
|
* next = driver_gpuva_alloc();
|
|
* if (!next)
|
|
* ; // unwind previous VA space
|
|
* // updates, free memory and
|
|
* // unlock
|
|
* }
|
|
*
|
|
* driver_vm_remap();
|
|
* drm_gpuva_remap(prev, next, &op->remap);
|
|
*
|
|
* drm_gpuva_unlink(va);
|
|
* if (prev)
|
|
* drm_gpuva_link(prev);
|
|
* if (next)
|
|
* drm_gpuva_link(next);
|
|
*
|
|
* break;
|
|
* }
|
|
* case DRM_GPUVA_OP_UNMAP:
|
|
* va = op->unmap->va;
|
|
*
|
|
* driver_vm_unmap();
|
|
* drm_gpuva_unlink(va);
|
|
* drm_gpuva_unmap(&op->unmap);
|
|
*
|
|
* break;
|
|
* default:
|
|
* break;
|
|
* }
|
|
* }
|
|
* driver_unlock_va_space();
|
|
*
|
|
* return 0;
|
|
* }
|
|
*
|
|
* 2) Receive a callback for each &drm_gpuva_op to create a new mapping::
|
|
*
|
|
* struct driver_context {
|
|
* struct drm_gpuva_manager *mgr;
|
|
* struct drm_gpuva *new_va;
|
|
* struct drm_gpuva *prev_va;
|
|
* struct drm_gpuva *next_va;
|
|
* };
|
|
*
|
|
* // ops to pass to drm_gpuva_manager_init()
|
|
* static const struct drm_gpuva_fn_ops driver_gpuva_ops = {
|
|
* .sm_step_map = driver_gpuva_map,
|
|
* .sm_step_remap = driver_gpuva_remap,
|
|
* .sm_step_unmap = driver_gpuva_unmap,
|
|
* };
|
|
*
|
|
* // Typically drivers would embedd the &drm_gpuva_manager and &drm_gpuva
|
|
* // structure in individual driver structures and lock the dma-resv with
|
|
* // drm_exec or similar helpers.
|
|
* int driver_mapping_create(struct drm_gpuva_manager *mgr,
|
|
* u64 addr, u64 range,
|
|
* struct drm_gem_object *obj, u64 offset)
|
|
* {
|
|
* struct driver_context ctx;
|
|
* struct drm_gpuva_ops *ops;
|
|
* struct drm_gpuva_op *op;
|
|
* int ret = 0;
|
|
*
|
|
* ctx.mgr = mgr;
|
|
*
|
|
* ctx.new_va = kzalloc(sizeof(*ctx.new_va), GFP_KERNEL);
|
|
* ctx.prev_va = kzalloc(sizeof(*ctx.prev_va), GFP_KERNEL);
|
|
* ctx.next_va = kzalloc(sizeof(*ctx.next_va), GFP_KERNEL);
|
|
* if (!ctx.new_va || !ctx.prev_va || !ctx.next_va) {
|
|
* ret = -ENOMEM;
|
|
* goto out;
|
|
* }
|
|
*
|
|
* driver_lock_va_space();
|
|
* ret = drm_gpuva_sm_map(mgr, &ctx, addr, range, obj, offset);
|
|
* driver_unlock_va_space();
|
|
*
|
|
* out:
|
|
* kfree(ctx.new_va);
|
|
* kfree(ctx.prev_va);
|
|
* kfree(ctx.next_va);
|
|
* return ret;
|
|
* }
|
|
*
|
|
* int driver_gpuva_map(struct drm_gpuva_op *op, void *__ctx)
|
|
* {
|
|
* struct driver_context *ctx = __ctx;
|
|
*
|
|
* drm_gpuva_map(ctx->mgr, ctx->new_va, &op->map);
|
|
*
|
|
* drm_gpuva_link(ctx->new_va);
|
|
*
|
|
* // prevent the new GPUVA from being freed in
|
|
* // driver_mapping_create()
|
|
* ctx->new_va = NULL;
|
|
*
|
|
* return 0;
|
|
* }
|
|
*
|
|
* int driver_gpuva_remap(struct drm_gpuva_op *op, void *__ctx)
|
|
* {
|
|
* struct driver_context *ctx = __ctx;
|
|
*
|
|
* drm_gpuva_remap(ctx->prev_va, ctx->next_va, &op->remap);
|
|
*
|
|
* drm_gpuva_unlink(op->remap.unmap->va);
|
|
* kfree(op->remap.unmap->va);
|
|
*
|
|
* if (op->remap.prev) {
|
|
* drm_gpuva_link(ctx->prev_va);
|
|
* ctx->prev_va = NULL;
|
|
* }
|
|
*
|
|
* if (op->remap.next) {
|
|
* drm_gpuva_link(ctx->next_va);
|
|
* ctx->next_va = NULL;
|
|
* }
|
|
*
|
|
* return 0;
|
|
* }
|
|
*
|
|
* int driver_gpuva_unmap(struct drm_gpuva_op *op, void *__ctx)
|
|
* {
|
|
* drm_gpuva_unlink(op->unmap.va);
|
|
* drm_gpuva_unmap(&op->unmap);
|
|
* kfree(op->unmap.va);
|
|
*
|
|
* return 0;
|
|
* }
|
|
*/
|
|
|
|
#define to_drm_gpuva(__node) container_of((__node), struct drm_gpuva, rb.node)
|
|
|
|
#define GPUVA_START(node) ((node)->va.addr)
|
|
#define GPUVA_LAST(node) ((node)->va.addr + (node)->va.range - 1)
|
|
|
|
/* We do not actually use drm_gpuva_it_next(), tell the compiler to not complain
|
|
* about this.
|
|
*/
|
|
INTERVAL_TREE_DEFINE(struct drm_gpuva, rb.node, u64, rb.__subtree_last,
|
|
GPUVA_START, GPUVA_LAST, static __maybe_unused,
|
|
drm_gpuva_it)
|
|
|
|
static int __drm_gpuva_insert(struct drm_gpuva_manager *mgr,
|
|
struct drm_gpuva *va);
|
|
static void __drm_gpuva_remove(struct drm_gpuva *va);
|
|
|
|
static bool
|
|
drm_gpuva_check_overflow(u64 addr, u64 range)
|
|
{
|
|
u64 end;
|
|
|
|
return WARN(check_add_overflow(addr, range, &end),
|
|
"GPUVA address limited to %zu bytes.\n", sizeof(end));
|
|
}
|
|
|
|
static bool
|
|
drm_gpuva_in_mm_range(struct drm_gpuva_manager *mgr, u64 addr, u64 range)
|
|
{
|
|
u64 end = addr + range;
|
|
u64 mm_start = mgr->mm_start;
|
|
u64 mm_end = mm_start + mgr->mm_range;
|
|
|
|
return addr >= mm_start && end <= mm_end;
|
|
}
|
|
|
|
static bool
|
|
drm_gpuva_in_kernel_node(struct drm_gpuva_manager *mgr, u64 addr, u64 range)
|
|
{
|
|
u64 end = addr + range;
|
|
u64 kstart = mgr->kernel_alloc_node.va.addr;
|
|
u64 krange = mgr->kernel_alloc_node.va.range;
|
|
u64 kend = kstart + krange;
|
|
|
|
return krange && addr < kend && kstart < end;
|
|
}
|
|
|
|
static bool
|
|
drm_gpuva_range_valid(struct drm_gpuva_manager *mgr,
|
|
u64 addr, u64 range)
|
|
{
|
|
return !drm_gpuva_check_overflow(addr, range) &&
|
|
drm_gpuva_in_mm_range(mgr, addr, range) &&
|
|
!drm_gpuva_in_kernel_node(mgr, addr, range);
|
|
}
|
|
|
|
/**
|
|
* drm_gpuva_manager_init() - initialize a &drm_gpuva_manager
|
|
* @mgr: pointer to the &drm_gpuva_manager to initialize
|
|
* @name: the name of the GPU VA space
|
|
* @start_offset: the start offset of the GPU VA space
|
|
* @range: the size of the GPU VA space
|
|
* @reserve_offset: the start of the kernel reserved GPU VA area
|
|
* @reserve_range: the size of the kernel reserved GPU VA area
|
|
* @ops: &drm_gpuva_fn_ops called on &drm_gpuva_sm_map / &drm_gpuva_sm_unmap
|
|
*
|
|
* The &drm_gpuva_manager must be initialized with this function before use.
|
|
*
|
|
* Note that @mgr must be cleared to 0 before calling this function. The given
|
|
* &name is expected to be managed by the surrounding driver structures.
|
|
*/
|
|
void
|
|
drm_gpuva_manager_init(struct drm_gpuva_manager *mgr,
|
|
const char *name,
|
|
u64 start_offset, u64 range,
|
|
u64 reserve_offset, u64 reserve_range,
|
|
const struct drm_gpuva_fn_ops *ops)
|
|
{
|
|
mgr->rb.tree = RB_ROOT_CACHED;
|
|
INIT_LIST_HEAD(&mgr->rb.list);
|
|
|
|
drm_gpuva_check_overflow(start_offset, range);
|
|
mgr->mm_start = start_offset;
|
|
mgr->mm_range = range;
|
|
|
|
mgr->name = name ? name : "unknown";
|
|
mgr->ops = ops;
|
|
|
|
memset(&mgr->kernel_alloc_node, 0, sizeof(struct drm_gpuva));
|
|
|
|
if (reserve_range) {
|
|
mgr->kernel_alloc_node.va.addr = reserve_offset;
|
|
mgr->kernel_alloc_node.va.range = reserve_range;
|
|
|
|
if (likely(!drm_gpuva_check_overflow(reserve_offset,
|
|
reserve_range)))
|
|
__drm_gpuva_insert(mgr, &mgr->kernel_alloc_node);
|
|
}
|
|
}
|
|
EXPORT_SYMBOL_GPL(drm_gpuva_manager_init);
|
|
|
|
/**
|
|
* drm_gpuva_manager_destroy() - cleanup a &drm_gpuva_manager
|
|
* @mgr: pointer to the &drm_gpuva_manager to clean up
|
|
*
|
|
* Note that it is a bug to call this function on a manager that still
|
|
* holds GPU VA mappings.
|
|
*/
|
|
void
|
|
drm_gpuva_manager_destroy(struct drm_gpuva_manager *mgr)
|
|
{
|
|
mgr->name = NULL;
|
|
|
|
if (mgr->kernel_alloc_node.va.range)
|
|
__drm_gpuva_remove(&mgr->kernel_alloc_node);
|
|
|
|
WARN(!RB_EMPTY_ROOT(&mgr->rb.tree.rb_root),
|
|
"GPUVA tree is not empty, potentially leaking memory.");
|
|
}
|
|
EXPORT_SYMBOL_GPL(drm_gpuva_manager_destroy);
|
|
|
|
static int
|
|
__drm_gpuva_insert(struct drm_gpuva_manager *mgr,
|
|
struct drm_gpuva *va)
|
|
{
|
|
struct rb_node *node;
|
|
struct list_head *head;
|
|
|
|
if (drm_gpuva_it_iter_first(&mgr->rb.tree,
|
|
GPUVA_START(va),
|
|
GPUVA_LAST(va)))
|
|
return -EEXIST;
|
|
|
|
va->mgr = mgr;
|
|
|
|
drm_gpuva_it_insert(va, &mgr->rb.tree);
|
|
|
|
node = rb_prev(&va->rb.node);
|
|
if (node)
|
|
head = &(to_drm_gpuva(node))->rb.entry;
|
|
else
|
|
head = &mgr->rb.list;
|
|
|
|
list_add(&va->rb.entry, head);
|
|
|
|
return 0;
|
|
}
|
|
|
|
/**
|
|
* drm_gpuva_insert() - insert a &drm_gpuva
|
|
* @mgr: the &drm_gpuva_manager to insert the &drm_gpuva in
|
|
* @va: the &drm_gpuva to insert
|
|
*
|
|
* Insert a &drm_gpuva with a given address and range into a
|
|
* &drm_gpuva_manager.
|
|
*
|
|
* It is safe to use this function using the safe versions of iterating the GPU
|
|
* VA space, such as drm_gpuva_for_each_va_safe() and
|
|
* drm_gpuva_for_each_va_range_safe().
|
|
*
|
|
* Returns: 0 on success, negative error code on failure.
|
|
*/
|
|
int
|
|
drm_gpuva_insert(struct drm_gpuva_manager *mgr,
|
|
struct drm_gpuva *va)
|
|
{
|
|
u64 addr = va->va.addr;
|
|
u64 range = va->va.range;
|
|
|
|
if (unlikely(!drm_gpuva_range_valid(mgr, addr, range)))
|
|
return -EINVAL;
|
|
|
|
return __drm_gpuva_insert(mgr, va);
|
|
}
|
|
EXPORT_SYMBOL_GPL(drm_gpuva_insert);
|
|
|
|
static void
|
|
__drm_gpuva_remove(struct drm_gpuva *va)
|
|
{
|
|
drm_gpuva_it_remove(va, &va->mgr->rb.tree);
|
|
list_del_init(&va->rb.entry);
|
|
}
|
|
|
|
/**
|
|
* drm_gpuva_remove() - remove a &drm_gpuva
|
|
* @va: the &drm_gpuva to remove
|
|
*
|
|
* This removes the given &va from the underlaying tree.
|
|
*
|
|
* It is safe to use this function using the safe versions of iterating the GPU
|
|
* VA space, such as drm_gpuva_for_each_va_safe() and
|
|
* drm_gpuva_for_each_va_range_safe().
|
|
*/
|
|
void
|
|
drm_gpuva_remove(struct drm_gpuva *va)
|
|
{
|
|
struct drm_gpuva_manager *mgr = va->mgr;
|
|
|
|
if (unlikely(va == &mgr->kernel_alloc_node)) {
|
|
WARN(1, "Can't destroy kernel reserved node.\n");
|
|
return;
|
|
}
|
|
|
|
__drm_gpuva_remove(va);
|
|
}
|
|
EXPORT_SYMBOL_GPL(drm_gpuva_remove);
|
|
|
|
/**
|
|
* drm_gpuva_link() - link a &drm_gpuva
|
|
* @va: the &drm_gpuva to link
|
|
*
|
|
* This adds the given &va to the GPU VA list of the &drm_gem_object it is
|
|
* associated with.
|
|
*
|
|
* This function expects the caller to protect the GEM's GPUVA list against
|
|
* concurrent access using the GEMs dma_resv lock.
|
|
*/
|
|
void
|
|
drm_gpuva_link(struct drm_gpuva *va)
|
|
{
|
|
struct drm_gem_object *obj = va->gem.obj;
|
|
|
|
if (unlikely(!obj))
|
|
return;
|
|
|
|
drm_gem_gpuva_assert_lock_held(obj);
|
|
|
|
list_add_tail(&va->gem.entry, &obj->gpuva.list);
|
|
}
|
|
EXPORT_SYMBOL_GPL(drm_gpuva_link);
|
|
|
|
/**
|
|
* drm_gpuva_unlink() - unlink a &drm_gpuva
|
|
* @va: the &drm_gpuva to unlink
|
|
*
|
|
* This removes the given &va from the GPU VA list of the &drm_gem_object it is
|
|
* associated with.
|
|
*
|
|
* This function expects the caller to protect the GEM's GPUVA list against
|
|
* concurrent access using the GEMs dma_resv lock.
|
|
*/
|
|
void
|
|
drm_gpuva_unlink(struct drm_gpuva *va)
|
|
{
|
|
struct drm_gem_object *obj = va->gem.obj;
|
|
|
|
if (unlikely(!obj))
|
|
return;
|
|
|
|
drm_gem_gpuva_assert_lock_held(obj);
|
|
|
|
list_del_init(&va->gem.entry);
|
|
}
|
|
EXPORT_SYMBOL_GPL(drm_gpuva_unlink);
|
|
|
|
/**
|
|
* drm_gpuva_find_first() - find the first &drm_gpuva in the given range
|
|
* @mgr: the &drm_gpuva_manager to search in
|
|
* @addr: the &drm_gpuvas address
|
|
* @range: the &drm_gpuvas range
|
|
*
|
|
* Returns: the first &drm_gpuva within the given range
|
|
*/
|
|
struct drm_gpuva *
|
|
drm_gpuva_find_first(struct drm_gpuva_manager *mgr,
|
|
u64 addr, u64 range)
|
|
{
|
|
u64 last = addr + range - 1;
|
|
|
|
return drm_gpuva_it_iter_first(&mgr->rb.tree, addr, last);
|
|
}
|
|
EXPORT_SYMBOL_GPL(drm_gpuva_find_first);
|
|
|
|
/**
|
|
* drm_gpuva_find() - find a &drm_gpuva
|
|
* @mgr: the &drm_gpuva_manager to search in
|
|
* @addr: the &drm_gpuvas address
|
|
* @range: the &drm_gpuvas range
|
|
*
|
|
* Returns: the &drm_gpuva at a given &addr and with a given &range
|
|
*/
|
|
struct drm_gpuva *
|
|
drm_gpuva_find(struct drm_gpuva_manager *mgr,
|
|
u64 addr, u64 range)
|
|
{
|
|
struct drm_gpuva *va;
|
|
|
|
va = drm_gpuva_find_first(mgr, addr, range);
|
|
if (!va)
|
|
goto out;
|
|
|
|
if (va->va.addr != addr ||
|
|
va->va.range != range)
|
|
goto out;
|
|
|
|
return va;
|
|
|
|
out:
|
|
return NULL;
|
|
}
|
|
EXPORT_SYMBOL_GPL(drm_gpuva_find);
|
|
|
|
/**
|
|
* drm_gpuva_find_prev() - find the &drm_gpuva before the given address
|
|
* @mgr: the &drm_gpuva_manager to search in
|
|
* @start: the given GPU VA's start address
|
|
*
|
|
* Find the adjacent &drm_gpuva before the GPU VA with given &start address.
|
|
*
|
|
* Note that if there is any free space between the GPU VA mappings no mapping
|
|
* is returned.
|
|
*
|
|
* Returns: a pointer to the found &drm_gpuva or NULL if none was found
|
|
*/
|
|
struct drm_gpuva *
|
|
drm_gpuva_find_prev(struct drm_gpuva_manager *mgr, u64 start)
|
|
{
|
|
if (!drm_gpuva_range_valid(mgr, start - 1, 1))
|
|
return NULL;
|
|
|
|
return drm_gpuva_it_iter_first(&mgr->rb.tree, start - 1, start);
|
|
}
|
|
EXPORT_SYMBOL_GPL(drm_gpuva_find_prev);
|
|
|
|
/**
|
|
* drm_gpuva_find_next() - find the &drm_gpuva after the given address
|
|
* @mgr: the &drm_gpuva_manager to search in
|
|
* @end: the given GPU VA's end address
|
|
*
|
|
* Find the adjacent &drm_gpuva after the GPU VA with given &end address.
|
|
*
|
|
* Note that if there is any free space between the GPU VA mappings no mapping
|
|
* is returned.
|
|
*
|
|
* Returns: a pointer to the found &drm_gpuva or NULL if none was found
|
|
*/
|
|
struct drm_gpuva *
|
|
drm_gpuva_find_next(struct drm_gpuva_manager *mgr, u64 end)
|
|
{
|
|
if (!drm_gpuva_range_valid(mgr, end, 1))
|
|
return NULL;
|
|
|
|
return drm_gpuva_it_iter_first(&mgr->rb.tree, end, end + 1);
|
|
}
|
|
EXPORT_SYMBOL_GPL(drm_gpuva_find_next);
|
|
|
|
/**
|
|
* drm_gpuva_interval_empty() - indicate whether a given interval of the VA space
|
|
* is empty
|
|
* @mgr: the &drm_gpuva_manager to check the range for
|
|
* @addr: the start address of the range
|
|
* @range: the range of the interval
|
|
*
|
|
* Returns: true if the interval is empty, false otherwise
|
|
*/
|
|
bool
|
|
drm_gpuva_interval_empty(struct drm_gpuva_manager *mgr, u64 addr, u64 range)
|
|
{
|
|
return !drm_gpuva_find_first(mgr, addr, range);
|
|
}
|
|
EXPORT_SYMBOL_GPL(drm_gpuva_interval_empty);
|
|
|
|
/**
|
|
* drm_gpuva_map() - helper to insert a &drm_gpuva according to a
|
|
* &drm_gpuva_op_map
|
|
* @mgr: the &drm_gpuva_manager
|
|
* @va: the &drm_gpuva to insert
|
|
* @op: the &drm_gpuva_op_map to initialize @va with
|
|
*
|
|
* Initializes the @va from the @op and inserts it into the given @mgr.
|
|
*/
|
|
void
|
|
drm_gpuva_map(struct drm_gpuva_manager *mgr,
|
|
struct drm_gpuva *va,
|
|
struct drm_gpuva_op_map *op)
|
|
{
|
|
drm_gpuva_init_from_op(va, op);
|
|
drm_gpuva_insert(mgr, va);
|
|
}
|
|
EXPORT_SYMBOL_GPL(drm_gpuva_map);
|
|
|
|
/**
|
|
* drm_gpuva_remap() - helper to remap a &drm_gpuva according to a
|
|
* &drm_gpuva_op_remap
|
|
* @prev: the &drm_gpuva to remap when keeping the start of a mapping
|
|
* @next: the &drm_gpuva to remap when keeping the end of a mapping
|
|
* @op: the &drm_gpuva_op_remap to initialize @prev and @next with
|
|
*
|
|
* Removes the currently mapped &drm_gpuva and remaps it using @prev and/or
|
|
* @next.
|
|
*/
|
|
void
|
|
drm_gpuva_remap(struct drm_gpuva *prev,
|
|
struct drm_gpuva *next,
|
|
struct drm_gpuva_op_remap *op)
|
|
{
|
|
struct drm_gpuva *curr = op->unmap->va;
|
|
struct drm_gpuva_manager *mgr = curr->mgr;
|
|
|
|
drm_gpuva_remove(curr);
|
|
|
|
if (op->prev) {
|
|
drm_gpuva_init_from_op(prev, op->prev);
|
|
drm_gpuva_insert(mgr, prev);
|
|
}
|
|
|
|
if (op->next) {
|
|
drm_gpuva_init_from_op(next, op->next);
|
|
drm_gpuva_insert(mgr, next);
|
|
}
|
|
}
|
|
EXPORT_SYMBOL_GPL(drm_gpuva_remap);
|
|
|
|
/**
|
|
* drm_gpuva_unmap() - helper to remove a &drm_gpuva according to a
|
|
* &drm_gpuva_op_unmap
|
|
* @op: the &drm_gpuva_op_unmap specifying the &drm_gpuva to remove
|
|
*
|
|
* Removes the &drm_gpuva associated with the &drm_gpuva_op_unmap.
|
|
*/
|
|
void
|
|
drm_gpuva_unmap(struct drm_gpuva_op_unmap *op)
|
|
{
|
|
drm_gpuva_remove(op->va);
|
|
}
|
|
EXPORT_SYMBOL_GPL(drm_gpuva_unmap);
|
|
|
|
static int
|
|
op_map_cb(const struct drm_gpuva_fn_ops *fn, void *priv,
|
|
u64 addr, u64 range,
|
|
struct drm_gem_object *obj, u64 offset)
|
|
{
|
|
struct drm_gpuva_op op = {};
|
|
|
|
op.op = DRM_GPUVA_OP_MAP;
|
|
op.map.va.addr = addr;
|
|
op.map.va.range = range;
|
|
op.map.gem.obj = obj;
|
|
op.map.gem.offset = offset;
|
|
|
|
return fn->sm_step_map(&op, priv);
|
|
}
|
|
|
|
static int
|
|
op_remap_cb(const struct drm_gpuva_fn_ops *fn, void *priv,
|
|
struct drm_gpuva_op_map *prev,
|
|
struct drm_gpuva_op_map *next,
|
|
struct drm_gpuva_op_unmap *unmap)
|
|
{
|
|
struct drm_gpuva_op op = {};
|
|
struct drm_gpuva_op_remap *r;
|
|
|
|
op.op = DRM_GPUVA_OP_REMAP;
|
|
r = &op.remap;
|
|
r->prev = prev;
|
|
r->next = next;
|
|
r->unmap = unmap;
|
|
|
|
return fn->sm_step_remap(&op, priv);
|
|
}
|
|
|
|
static int
|
|
op_unmap_cb(const struct drm_gpuva_fn_ops *fn, void *priv,
|
|
struct drm_gpuva *va, bool merge)
|
|
{
|
|
struct drm_gpuva_op op = {};
|
|
|
|
op.op = DRM_GPUVA_OP_UNMAP;
|
|
op.unmap.va = va;
|
|
op.unmap.keep = merge;
|
|
|
|
return fn->sm_step_unmap(&op, priv);
|
|
}
|
|
|
|
static int
|
|
__drm_gpuva_sm_map(struct drm_gpuva_manager *mgr,
|
|
const struct drm_gpuva_fn_ops *ops, void *priv,
|
|
u64 req_addr, u64 req_range,
|
|
struct drm_gem_object *req_obj, u64 req_offset)
|
|
{
|
|
struct drm_gpuva *va, *next;
|
|
u64 req_end = req_addr + req_range;
|
|
int ret;
|
|
|
|
if (unlikely(!drm_gpuva_range_valid(mgr, req_addr, req_range)))
|
|
return -EINVAL;
|
|
|
|
drm_gpuva_for_each_va_range_safe(va, next, mgr, req_addr, req_end) {
|
|
struct drm_gem_object *obj = va->gem.obj;
|
|
u64 offset = va->gem.offset;
|
|
u64 addr = va->va.addr;
|
|
u64 range = va->va.range;
|
|
u64 end = addr + range;
|
|
bool merge = !!va->gem.obj;
|
|
|
|
if (addr == req_addr) {
|
|
merge &= obj == req_obj &&
|
|
offset == req_offset;
|
|
|
|
if (end == req_end) {
|
|
ret = op_unmap_cb(ops, priv, va, merge);
|
|
if (ret)
|
|
return ret;
|
|
break;
|
|
}
|
|
|
|
if (end < req_end) {
|
|
ret = op_unmap_cb(ops, priv, va, merge);
|
|
if (ret)
|
|
return ret;
|
|
continue;
|
|
}
|
|
|
|
if (end > req_end) {
|
|
struct drm_gpuva_op_map n = {
|
|
.va.addr = req_end,
|
|
.va.range = range - req_range,
|
|
.gem.obj = obj,
|
|
.gem.offset = offset + req_range,
|
|
};
|
|
struct drm_gpuva_op_unmap u = {
|
|
.va = va,
|
|
.keep = merge,
|
|
};
|
|
|
|
ret = op_remap_cb(ops, priv, NULL, &n, &u);
|
|
if (ret)
|
|
return ret;
|
|
break;
|
|
}
|
|
} else if (addr < req_addr) {
|
|
u64 ls_range = req_addr - addr;
|
|
struct drm_gpuva_op_map p = {
|
|
.va.addr = addr,
|
|
.va.range = ls_range,
|
|
.gem.obj = obj,
|
|
.gem.offset = offset,
|
|
};
|
|
struct drm_gpuva_op_unmap u = { .va = va };
|
|
|
|
merge &= obj == req_obj &&
|
|
offset + ls_range == req_offset;
|
|
u.keep = merge;
|
|
|
|
if (end == req_end) {
|
|
ret = op_remap_cb(ops, priv, &p, NULL, &u);
|
|
if (ret)
|
|
return ret;
|
|
break;
|
|
}
|
|
|
|
if (end < req_end) {
|
|
ret = op_remap_cb(ops, priv, &p, NULL, &u);
|
|
if (ret)
|
|
return ret;
|
|
continue;
|
|
}
|
|
|
|
if (end > req_end) {
|
|
struct drm_gpuva_op_map n = {
|
|
.va.addr = req_end,
|
|
.va.range = end - req_end,
|
|
.gem.obj = obj,
|
|
.gem.offset = offset + ls_range +
|
|
req_range,
|
|
};
|
|
|
|
ret = op_remap_cb(ops, priv, &p, &n, &u);
|
|
if (ret)
|
|
return ret;
|
|
break;
|
|
}
|
|
} else if (addr > req_addr) {
|
|
merge &= obj == req_obj &&
|
|
offset == req_offset +
|
|
(addr - req_addr);
|
|
|
|
if (end == req_end) {
|
|
ret = op_unmap_cb(ops, priv, va, merge);
|
|
if (ret)
|
|
return ret;
|
|
break;
|
|
}
|
|
|
|
if (end < req_end) {
|
|
ret = op_unmap_cb(ops, priv, va, merge);
|
|
if (ret)
|
|
return ret;
|
|
continue;
|
|
}
|
|
|
|
if (end > req_end) {
|
|
struct drm_gpuva_op_map n = {
|
|
.va.addr = req_end,
|
|
.va.range = end - req_end,
|
|
.gem.obj = obj,
|
|
.gem.offset = offset + req_end - addr,
|
|
};
|
|
struct drm_gpuva_op_unmap u = {
|
|
.va = va,
|
|
.keep = merge,
|
|
};
|
|
|
|
ret = op_remap_cb(ops, priv, NULL, &n, &u);
|
|
if (ret)
|
|
return ret;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
return op_map_cb(ops, priv,
|
|
req_addr, req_range,
|
|
req_obj, req_offset);
|
|
}
|
|
|
|
static int
|
|
__drm_gpuva_sm_unmap(struct drm_gpuva_manager *mgr,
|
|
const struct drm_gpuva_fn_ops *ops, void *priv,
|
|
u64 req_addr, u64 req_range)
|
|
{
|
|
struct drm_gpuva *va, *next;
|
|
u64 req_end = req_addr + req_range;
|
|
int ret;
|
|
|
|
if (unlikely(!drm_gpuva_range_valid(mgr, req_addr, req_range)))
|
|
return -EINVAL;
|
|
|
|
drm_gpuva_for_each_va_range_safe(va, next, mgr, req_addr, req_end) {
|
|
struct drm_gpuva_op_map prev = {}, next = {};
|
|
bool prev_split = false, next_split = false;
|
|
struct drm_gem_object *obj = va->gem.obj;
|
|
u64 offset = va->gem.offset;
|
|
u64 addr = va->va.addr;
|
|
u64 range = va->va.range;
|
|
u64 end = addr + range;
|
|
|
|
if (addr < req_addr) {
|
|
prev.va.addr = addr;
|
|
prev.va.range = req_addr - addr;
|
|
prev.gem.obj = obj;
|
|
prev.gem.offset = offset;
|
|
|
|
prev_split = true;
|
|
}
|
|
|
|
if (end > req_end) {
|
|
next.va.addr = req_end;
|
|
next.va.range = end - req_end;
|
|
next.gem.obj = obj;
|
|
next.gem.offset = offset + (req_end - addr);
|
|
|
|
next_split = true;
|
|
}
|
|
|
|
if (prev_split || next_split) {
|
|
struct drm_gpuva_op_unmap unmap = { .va = va };
|
|
|
|
ret = op_remap_cb(ops, priv,
|
|
prev_split ? &prev : NULL,
|
|
next_split ? &next : NULL,
|
|
&unmap);
|
|
if (ret)
|
|
return ret;
|
|
} else {
|
|
ret = op_unmap_cb(ops, priv, va, false);
|
|
if (ret)
|
|
return ret;
|
|
}
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
/**
|
|
* drm_gpuva_sm_map() - creates the &drm_gpuva_op split/merge steps
|
|
* @mgr: the &drm_gpuva_manager representing the GPU VA space
|
|
* @req_addr: the start address of the new mapping
|
|
* @req_range: the range of the new mapping
|
|
* @req_obj: the &drm_gem_object to map
|
|
* @req_offset: the offset within the &drm_gem_object
|
|
* @priv: pointer to a driver private data structure
|
|
*
|
|
* This function iterates the given range of the GPU VA space. It utilizes the
|
|
* &drm_gpuva_fn_ops to call back into the driver providing the split and merge
|
|
* steps.
|
|
*
|
|
* Drivers may use these callbacks to update the GPU VA space right away within
|
|
* the callback. In case the driver decides to copy and store the operations for
|
|
* later processing neither this function nor &drm_gpuva_sm_unmap is allowed to
|
|
* be called before the &drm_gpuva_manager's view of the GPU VA space was
|
|
* updated with the previous set of operations. To update the
|
|
* &drm_gpuva_manager's view of the GPU VA space drm_gpuva_insert(),
|
|
* drm_gpuva_destroy_locked() and/or drm_gpuva_destroy_unlocked() should be
|
|
* used.
|
|
*
|
|
* A sequence of callbacks can contain map, unmap and remap operations, but
|
|
* the sequence of callbacks might also be empty if no operation is required,
|
|
* e.g. if the requested mapping already exists in the exact same way.
|
|
*
|
|
* There can be an arbitrary amount of unmap operations, a maximum of two remap
|
|
* operations and a single map operation. The latter one represents the original
|
|
* map operation requested by the caller.
|
|
*
|
|
* Returns: 0 on success or a negative error code
|
|
*/
|
|
int
|
|
drm_gpuva_sm_map(struct drm_gpuva_manager *mgr, void *priv,
|
|
u64 req_addr, u64 req_range,
|
|
struct drm_gem_object *req_obj, u64 req_offset)
|
|
{
|
|
const struct drm_gpuva_fn_ops *ops = mgr->ops;
|
|
|
|
if (unlikely(!(ops && ops->sm_step_map &&
|
|
ops->sm_step_remap &&
|
|
ops->sm_step_unmap)))
|
|
return -EINVAL;
|
|
|
|
return __drm_gpuva_sm_map(mgr, ops, priv,
|
|
req_addr, req_range,
|
|
req_obj, req_offset);
|
|
}
|
|
EXPORT_SYMBOL_GPL(drm_gpuva_sm_map);
|
|
|
|
/**
|
|
* drm_gpuva_sm_unmap() - creates the &drm_gpuva_ops to split on unmap
|
|
* @mgr: the &drm_gpuva_manager representing the GPU VA space
|
|
* @priv: pointer to a driver private data structure
|
|
* @req_addr: the start address of the range to unmap
|
|
* @req_range: the range of the mappings to unmap
|
|
*
|
|
* This function iterates the given range of the GPU VA space. It utilizes the
|
|
* &drm_gpuva_fn_ops to call back into the driver providing the operations to
|
|
* unmap and, if required, split existent mappings.
|
|
*
|
|
* Drivers may use these callbacks to update the GPU VA space right away within
|
|
* the callback. In case the driver decides to copy and store the operations for
|
|
* later processing neither this function nor &drm_gpuva_sm_map is allowed to be
|
|
* called before the &drm_gpuva_manager's view of the GPU VA space was updated
|
|
* with the previous set of operations. To update the &drm_gpuva_manager's view
|
|
* of the GPU VA space drm_gpuva_insert(), drm_gpuva_destroy_locked() and/or
|
|
* drm_gpuva_destroy_unlocked() should be used.
|
|
*
|
|
* A sequence of callbacks can contain unmap and remap operations, depending on
|
|
* whether there are actual overlapping mappings to split.
|
|
*
|
|
* There can be an arbitrary amount of unmap operations and a maximum of two
|
|
* remap operations.
|
|
*
|
|
* Returns: 0 on success or a negative error code
|
|
*/
|
|
int
|
|
drm_gpuva_sm_unmap(struct drm_gpuva_manager *mgr, void *priv,
|
|
u64 req_addr, u64 req_range)
|
|
{
|
|
const struct drm_gpuva_fn_ops *ops = mgr->ops;
|
|
|
|
if (unlikely(!(ops && ops->sm_step_remap &&
|
|
ops->sm_step_unmap)))
|
|
return -EINVAL;
|
|
|
|
return __drm_gpuva_sm_unmap(mgr, ops, priv,
|
|
req_addr, req_range);
|
|
}
|
|
EXPORT_SYMBOL_GPL(drm_gpuva_sm_unmap);
|
|
|
|
static struct drm_gpuva_op *
|
|
gpuva_op_alloc(struct drm_gpuva_manager *mgr)
|
|
{
|
|
const struct drm_gpuva_fn_ops *fn = mgr->ops;
|
|
struct drm_gpuva_op *op;
|
|
|
|
if (fn && fn->op_alloc)
|
|
op = fn->op_alloc();
|
|
else
|
|
op = kzalloc(sizeof(*op), GFP_KERNEL);
|
|
|
|
if (unlikely(!op))
|
|
return NULL;
|
|
|
|
return op;
|
|
}
|
|
|
|
static void
|
|
gpuva_op_free(struct drm_gpuva_manager *mgr,
|
|
struct drm_gpuva_op *op)
|
|
{
|
|
const struct drm_gpuva_fn_ops *fn = mgr->ops;
|
|
|
|
if (fn && fn->op_free)
|
|
fn->op_free(op);
|
|
else
|
|
kfree(op);
|
|
}
|
|
|
|
static int
|
|
drm_gpuva_sm_step(struct drm_gpuva_op *__op,
|
|
void *priv)
|
|
{
|
|
struct {
|
|
struct drm_gpuva_manager *mgr;
|
|
struct drm_gpuva_ops *ops;
|
|
} *args = priv;
|
|
struct drm_gpuva_manager *mgr = args->mgr;
|
|
struct drm_gpuva_ops *ops = args->ops;
|
|
struct drm_gpuva_op *op;
|
|
|
|
op = gpuva_op_alloc(mgr);
|
|
if (unlikely(!op))
|
|
goto err;
|
|
|
|
memcpy(op, __op, sizeof(*op));
|
|
|
|
if (op->op == DRM_GPUVA_OP_REMAP) {
|
|
struct drm_gpuva_op_remap *__r = &__op->remap;
|
|
struct drm_gpuva_op_remap *r = &op->remap;
|
|
|
|
r->unmap = kmemdup(__r->unmap, sizeof(*r->unmap),
|
|
GFP_KERNEL);
|
|
if (unlikely(!r->unmap))
|
|
goto err_free_op;
|
|
|
|
if (__r->prev) {
|
|
r->prev = kmemdup(__r->prev, sizeof(*r->prev),
|
|
GFP_KERNEL);
|
|
if (unlikely(!r->prev))
|
|
goto err_free_unmap;
|
|
}
|
|
|
|
if (__r->next) {
|
|
r->next = kmemdup(__r->next, sizeof(*r->next),
|
|
GFP_KERNEL);
|
|
if (unlikely(!r->next))
|
|
goto err_free_prev;
|
|
}
|
|
}
|
|
|
|
list_add_tail(&op->entry, &ops->list);
|
|
|
|
return 0;
|
|
|
|
err_free_unmap:
|
|
kfree(op->remap.unmap);
|
|
err_free_prev:
|
|
kfree(op->remap.prev);
|
|
err_free_op:
|
|
gpuva_op_free(mgr, op);
|
|
err:
|
|
return -ENOMEM;
|
|
}
|
|
|
|
static const struct drm_gpuva_fn_ops gpuva_list_ops = {
|
|
.sm_step_map = drm_gpuva_sm_step,
|
|
.sm_step_remap = drm_gpuva_sm_step,
|
|
.sm_step_unmap = drm_gpuva_sm_step,
|
|
};
|
|
|
|
/**
|
|
* drm_gpuva_sm_map_ops_create() - creates the &drm_gpuva_ops to split and merge
|
|
* @mgr: the &drm_gpuva_manager representing the GPU VA space
|
|
* @req_addr: the start address of the new mapping
|
|
* @req_range: the range of the new mapping
|
|
* @req_obj: the &drm_gem_object to map
|
|
* @req_offset: the offset within the &drm_gem_object
|
|
*
|
|
* This function creates a list of operations to perform splitting and merging
|
|
* of existent mapping(s) with the newly requested one.
|
|
*
|
|
* The list can be iterated with &drm_gpuva_for_each_op and must be processed
|
|
* in the given order. It can contain map, unmap and remap operations, but it
|
|
* also can be empty if no operation is required, e.g. if the requested mapping
|
|
* already exists is the exact same way.
|
|
*
|
|
* There can be an arbitrary amount of unmap operations, a maximum of two remap
|
|
* operations and a single map operation. The latter one represents the original
|
|
* map operation requested by the caller.
|
|
*
|
|
* Note that before calling this function again with another mapping request it
|
|
* is necessary to update the &drm_gpuva_manager's view of the GPU VA space. The
|
|
* previously obtained operations must be either processed or abandoned. To
|
|
* update the &drm_gpuva_manager's view of the GPU VA space drm_gpuva_insert(),
|
|
* drm_gpuva_destroy_locked() and/or drm_gpuva_destroy_unlocked() should be
|
|
* used.
|
|
*
|
|
* After the caller finished processing the returned &drm_gpuva_ops, they must
|
|
* be freed with &drm_gpuva_ops_free.
|
|
*
|
|
* Returns: a pointer to the &drm_gpuva_ops on success, an ERR_PTR on failure
|
|
*/
|
|
struct drm_gpuva_ops *
|
|
drm_gpuva_sm_map_ops_create(struct drm_gpuva_manager *mgr,
|
|
u64 req_addr, u64 req_range,
|
|
struct drm_gem_object *req_obj, u64 req_offset)
|
|
{
|
|
struct drm_gpuva_ops *ops;
|
|
struct {
|
|
struct drm_gpuva_manager *mgr;
|
|
struct drm_gpuva_ops *ops;
|
|
} args;
|
|
int ret;
|
|
|
|
ops = kzalloc(sizeof(*ops), GFP_KERNEL);
|
|
if (unlikely(!ops))
|
|
return ERR_PTR(-ENOMEM);
|
|
|
|
INIT_LIST_HEAD(&ops->list);
|
|
|
|
args.mgr = mgr;
|
|
args.ops = ops;
|
|
|
|
ret = __drm_gpuva_sm_map(mgr, &gpuva_list_ops, &args,
|
|
req_addr, req_range,
|
|
req_obj, req_offset);
|
|
if (ret)
|
|
goto err_free_ops;
|
|
|
|
return ops;
|
|
|
|
err_free_ops:
|
|
drm_gpuva_ops_free(mgr, ops);
|
|
return ERR_PTR(ret);
|
|
}
|
|
EXPORT_SYMBOL_GPL(drm_gpuva_sm_map_ops_create);
|
|
|
|
/**
|
|
* drm_gpuva_sm_unmap_ops_create() - creates the &drm_gpuva_ops to split on
|
|
* unmap
|
|
* @mgr: the &drm_gpuva_manager representing the GPU VA space
|
|
* @req_addr: the start address of the range to unmap
|
|
* @req_range: the range of the mappings to unmap
|
|
*
|
|
* This function creates a list of operations to perform unmapping and, if
|
|
* required, splitting of the mappings overlapping the unmap range.
|
|
*
|
|
* The list can be iterated with &drm_gpuva_for_each_op and must be processed
|
|
* in the given order. It can contain unmap and remap operations, depending on
|
|
* whether there are actual overlapping mappings to split.
|
|
*
|
|
* There can be an arbitrary amount of unmap operations and a maximum of two
|
|
* remap operations.
|
|
*
|
|
* Note that before calling this function again with another range to unmap it
|
|
* is necessary to update the &drm_gpuva_manager's view of the GPU VA space. The
|
|
* previously obtained operations must be processed or abandoned. To update the
|
|
* &drm_gpuva_manager's view of the GPU VA space drm_gpuva_insert(),
|
|
* drm_gpuva_destroy_locked() and/or drm_gpuva_destroy_unlocked() should be
|
|
* used.
|
|
*
|
|
* After the caller finished processing the returned &drm_gpuva_ops, they must
|
|
* be freed with &drm_gpuva_ops_free.
|
|
*
|
|
* Returns: a pointer to the &drm_gpuva_ops on success, an ERR_PTR on failure
|
|
*/
|
|
struct drm_gpuva_ops *
|
|
drm_gpuva_sm_unmap_ops_create(struct drm_gpuva_manager *mgr,
|
|
u64 req_addr, u64 req_range)
|
|
{
|
|
struct drm_gpuva_ops *ops;
|
|
struct {
|
|
struct drm_gpuva_manager *mgr;
|
|
struct drm_gpuva_ops *ops;
|
|
} args;
|
|
int ret;
|
|
|
|
ops = kzalloc(sizeof(*ops), GFP_KERNEL);
|
|
if (unlikely(!ops))
|
|
return ERR_PTR(-ENOMEM);
|
|
|
|
INIT_LIST_HEAD(&ops->list);
|
|
|
|
args.mgr = mgr;
|
|
args.ops = ops;
|
|
|
|
ret = __drm_gpuva_sm_unmap(mgr, &gpuva_list_ops, &args,
|
|
req_addr, req_range);
|
|
if (ret)
|
|
goto err_free_ops;
|
|
|
|
return ops;
|
|
|
|
err_free_ops:
|
|
drm_gpuva_ops_free(mgr, ops);
|
|
return ERR_PTR(ret);
|
|
}
|
|
EXPORT_SYMBOL_GPL(drm_gpuva_sm_unmap_ops_create);
|
|
|
|
/**
|
|
* drm_gpuva_prefetch_ops_create() - creates the &drm_gpuva_ops to prefetch
|
|
* @mgr: the &drm_gpuva_manager representing the GPU VA space
|
|
* @addr: the start address of the range to prefetch
|
|
* @range: the range of the mappings to prefetch
|
|
*
|
|
* This function creates a list of operations to perform prefetching.
|
|
*
|
|
* The list can be iterated with &drm_gpuva_for_each_op and must be processed
|
|
* in the given order. It can contain prefetch operations.
|
|
*
|
|
* There can be an arbitrary amount of prefetch operations.
|
|
*
|
|
* After the caller finished processing the returned &drm_gpuva_ops, they must
|
|
* be freed with &drm_gpuva_ops_free.
|
|
*
|
|
* Returns: a pointer to the &drm_gpuva_ops on success, an ERR_PTR on failure
|
|
*/
|
|
struct drm_gpuva_ops *
|
|
drm_gpuva_prefetch_ops_create(struct drm_gpuva_manager *mgr,
|
|
u64 addr, u64 range)
|
|
{
|
|
struct drm_gpuva_ops *ops;
|
|
struct drm_gpuva_op *op;
|
|
struct drm_gpuva *va;
|
|
u64 end = addr + range;
|
|
int ret;
|
|
|
|
ops = kzalloc(sizeof(*ops), GFP_KERNEL);
|
|
if (!ops)
|
|
return ERR_PTR(-ENOMEM);
|
|
|
|
INIT_LIST_HEAD(&ops->list);
|
|
|
|
drm_gpuva_for_each_va_range(va, mgr, addr, end) {
|
|
op = gpuva_op_alloc(mgr);
|
|
if (!op) {
|
|
ret = -ENOMEM;
|
|
goto err_free_ops;
|
|
}
|
|
|
|
op->op = DRM_GPUVA_OP_PREFETCH;
|
|
op->prefetch.va = va;
|
|
list_add_tail(&op->entry, &ops->list);
|
|
}
|
|
|
|
return ops;
|
|
|
|
err_free_ops:
|
|
drm_gpuva_ops_free(mgr, ops);
|
|
return ERR_PTR(ret);
|
|
}
|
|
EXPORT_SYMBOL_GPL(drm_gpuva_prefetch_ops_create);
|
|
|
|
/**
|
|
* drm_gpuva_gem_unmap_ops_create() - creates the &drm_gpuva_ops to unmap a GEM
|
|
* @mgr: the &drm_gpuva_manager representing the GPU VA space
|
|
* @obj: the &drm_gem_object to unmap
|
|
*
|
|
* This function creates a list of operations to perform unmapping for every
|
|
* GPUVA attached to a GEM.
|
|
*
|
|
* The list can be iterated with &drm_gpuva_for_each_op and consists out of an
|
|
* arbitrary amount of unmap operations.
|
|
*
|
|
* After the caller finished processing the returned &drm_gpuva_ops, they must
|
|
* be freed with &drm_gpuva_ops_free.
|
|
*
|
|
* It is the callers responsibility to protect the GEMs GPUVA list against
|
|
* concurrent access using the GEMs dma_resv lock.
|
|
*
|
|
* Returns: a pointer to the &drm_gpuva_ops on success, an ERR_PTR on failure
|
|
*/
|
|
struct drm_gpuva_ops *
|
|
drm_gpuva_gem_unmap_ops_create(struct drm_gpuva_manager *mgr,
|
|
struct drm_gem_object *obj)
|
|
{
|
|
struct drm_gpuva_ops *ops;
|
|
struct drm_gpuva_op *op;
|
|
struct drm_gpuva *va;
|
|
int ret;
|
|
|
|
drm_gem_gpuva_assert_lock_held(obj);
|
|
|
|
ops = kzalloc(sizeof(*ops), GFP_KERNEL);
|
|
if (!ops)
|
|
return ERR_PTR(-ENOMEM);
|
|
|
|
INIT_LIST_HEAD(&ops->list);
|
|
|
|
drm_gem_for_each_gpuva(va, obj) {
|
|
op = gpuva_op_alloc(mgr);
|
|
if (!op) {
|
|
ret = -ENOMEM;
|
|
goto err_free_ops;
|
|
}
|
|
|
|
op->op = DRM_GPUVA_OP_UNMAP;
|
|
op->unmap.va = va;
|
|
list_add_tail(&op->entry, &ops->list);
|
|
}
|
|
|
|
return ops;
|
|
|
|
err_free_ops:
|
|
drm_gpuva_ops_free(mgr, ops);
|
|
return ERR_PTR(ret);
|
|
}
|
|
EXPORT_SYMBOL_GPL(drm_gpuva_gem_unmap_ops_create);
|
|
|
|
/**
|
|
* drm_gpuva_ops_free() - free the given &drm_gpuva_ops
|
|
* @mgr: the &drm_gpuva_manager the ops were created for
|
|
* @ops: the &drm_gpuva_ops to free
|
|
*
|
|
* Frees the given &drm_gpuva_ops structure including all the ops associated
|
|
* with it.
|
|
*/
|
|
void
|
|
drm_gpuva_ops_free(struct drm_gpuva_manager *mgr,
|
|
struct drm_gpuva_ops *ops)
|
|
{
|
|
struct drm_gpuva_op *op, *next;
|
|
|
|
drm_gpuva_for_each_op_safe(op, next, ops) {
|
|
list_del(&op->entry);
|
|
|
|
if (op->op == DRM_GPUVA_OP_REMAP) {
|
|
kfree(op->remap.prev);
|
|
kfree(op->remap.next);
|
|
kfree(op->remap.unmap);
|
|
}
|
|
|
|
gpuva_op_free(mgr, op);
|
|
}
|
|
|
|
kfree(ops);
|
|
}
|
|
EXPORT_SYMBOL_GPL(drm_gpuva_ops_free);
|