Received-SPF: pass (google.com: domain of linux-kernel-owner@vger.kernel.org designates 2620:137:e000::1:20 as permitted sender) client-ip=2620:137:e000::1:20;
Message-ID: <9aa6a7b7-68c9-d2f7-28ee-cbc6dfa1380a@shipmail.org>
Date:   Thu, 6 Jul 2023 19:30:47 +0200
MIME-Version: 1.0
User-Agent: Mozilla/5.0 (X11; Linux x86_64; rv:102.0) Gecko/20100101
 Thunderbird/102.11.1
Subject: Re: [PATCH drm-next v6 02/13] drm: manager to keep track of GPUs VA
 mappings
Content-Language: en-US
To:     Danilo Krummrich <dakr@redhat.com>
Cc:     airlied@gmail.com, daniel@ffwll.ch, tzimmermann@suse.de,
        mripard@kernel.org, corbet@lwn.net, christian.koenig@amd.com,
        bskeggs@redhat.com, Liam.Howlett@oracle.com,
        matthew.brost@intel.com, boris.brezillon@collabora.com,
        alexdeucher@gmail.com, ogabbay@kernel.org, bagasdotme@gmail.com,
        willy@infradead.org, jason@jlekstrand.net,
        linux-doc@vger.kernel.org, nouveau@lists.freedesktop.org,
        linux-kernel@vger.kernel.org, dri-devel@lists.freedesktop.org,
        Donald Robson <donald.robson@imgtec.com>,
        Dave Airlie <airlied@redhat.com>
References: <20230629222651.3196-1-dakr@redhat.com>
 <20230629222651.3196-3-dakr@redhat.com>
 <2a8a420c-a628-e34c-c732-0bd1bcb52a84@shipmail.org>
 <cd0d07be-9534-52c8-7b2d-6ab70dae7198@redhat.com>
From:   =?UTF-8?Q?Thomas_Hellstr=c3=b6m_=28Intel=29?= 
        <thomas_os@shipmail.org>
In-Reply-To: <cd0d07be-9534-52c8-7b2d-6ab70dae7198@redhat.com>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Precedence: bulk


On 7/6/23 17:48, Danilo Krummrich wrote:
> Hi Thomas,
>
> On 7/6/23 10:49, Thomas Hellström (Intel) wrote:
>> Hi, Danilo
>>
>> Some review comments below:
>>
>> On 6/30/23 00:25, Danilo Krummrich wrote:
>>> Add infrastructure to keep track of GPU virtual address (VA) mappings
>>> with a decicated VA space manager implementation.
>>>
>>> New UAPIs, motivated by Vulkan sparse memory bindings graphics drivers
>>> start implementing, allow userspace applications to request multiple 
>>> and
>>> arbitrary GPU VA mappings of buffer objects. The DRM GPU VA manager is
>>> intended to serve the following purposes in this context.
>>>
>>> 1) Provide infrastructure to track GPU VA allocations and mappings,
>>>     making use of the maple_tree.
>>
>> It looks like we're not using the maple tree anymore, but rather an 
>> instantiation of an interval tree.
>>
>> (Perhaps as a follow-up it makes sense to provide a pre-instantiated 
>> common u64 version of the interval tree in addition to the unsigned 
>> long one since it appears to be used in multiple places in graphics 
>> drivers).
>>
>>> 2) Generically connect GPU VA mappings to their backing buffers, in
>>>     particular DRM GEM objects.
>>>
>>> 3) Provide a common implementation to perform more complex mapping
>>>     operations on the GPU VA space. In particular splitting and merging
>>>     of GPU VA mappings, e.g. for intersecting mapping requests or 
>>> partial
>>>     unmap requests.
>>>
>>> Tested-by: Donald Robson<donald.robson@imgtec.com>
>>> Reviewed-by: Boris Brezillon<boris.brezillon@collabora.com>
>>> Suggested-by: Dave Airlie<airlied@redhat.com>
>>> Signed-off-by: Danilo Krummrich<dakr@redhat.com>
>>> ---
>>>   Documentation/gpu/drm-mm.rst    |   36 +
>>>   drivers/gpu/drm/Makefile        |    1 +
>>>   drivers/gpu/drm/drm_gem.c       |    3 +
>>>   drivers/gpu/drm/drm_gpuva_mgr.c | 1743 
>>> +++++++++++++++++++++++++++++++
>>>   include/drm/drm_drv.h           |    6 +
>>>   include/drm/drm_gem.h           |   52 +
>>>   include/drm/drm_gpuva_mgr.h     |  756 ++++++++++++++
>>>   7 files changed, 2597 insertions(+)
>>>   create mode 100644 drivers/gpu/drm/drm_gpuva_mgr.c
>>>   create mode 100644 include/drm/drm_gpuva_mgr.h
>>>
>>> diff --git a/Documentation/gpu/drm-mm.rst 
>>> b/Documentation/gpu/drm-mm.rst
>>> index a52e6f4117d6..3d5dc9dc1bfe 100644
>>> --- a/Documentation/gpu/drm-mm.rst
>>> +++ b/Documentation/gpu/drm-mm.rst
>>> @@ -466,6 +466,42 @@ DRM MM Range Allocator Function References
>>>   .. kernel-doc:: drivers/gpu/drm/drm_mm.c
>>>      :export:
>>> +DRM GPU VA Manager
>>> +==================
>>> +
>>> +Overview
>>> +--------
>>> +
>>> +.. kernel-doc:: drivers/gpu/drm/drm_gpuva_mgr.c
>>> +   :doc: Overview
>>> +
>>> +Split and Merge
>>> +---------------
>>> +
>>> +.. kernel-doc:: drivers/gpu/drm/drm_gpuva_mgr.c
>>> +   :doc: Split and Merge
>>> +
>>> +Locking
>>> +-------
>>> +
>>> +.. kernel-doc:: drivers/gpu/drm/drm_gpuva_mgr.c
>>> +   :doc: Locking
>>> +
>>> +Examples
>>> +--------
>>> +
>>> +.. kernel-doc:: drivers/gpu/drm/drm_gpuva_mgr.c
>>> +   :doc: Examples
>>> +
>>> +DRM GPU VA Manager Function References
>>> +--------------------------------------
>>> +
>>> +.. kernel-doc:: include/drm/drm_gpuva_mgr.h
>>> +   :internal:
>>> +
>>> +.. kernel-doc:: drivers/gpu/drm/drm_gpuva_mgr.c
>>> +   :export:
>>> +
>>>   DRM Buddy Allocator
>>>   ===================
>>> diff --git a/drivers/gpu/drm/Makefile b/drivers/gpu/drm/Makefile
>>> index 414855e2a463..6d6c9dec66e8 100644
>>> --- a/drivers/gpu/drm/Makefile
>>> +++ b/drivers/gpu/drm/Makefile
>>> @@ -45,6 +45,7 @@ drm-y := \
>>>       drm_vblank.o \
>>>       drm_vblank_work.o \
>>>       drm_vma_manager.o \
>>> +    drm_gpuva_mgr.o \
>>>       drm_writeback.o
>>>   drm-$(CONFIG_DRM_LEGACY) += \
>>>       drm_agpsupport.o \
>>> diff --git a/drivers/gpu/drm/drm_gem.c b/drivers/gpu/drm/drm_gem.c
>>> index 1a5a2cd0d4ec..cd878ebddbd0 100644
>>> --- a/drivers/gpu/drm/drm_gem.c
>>> +++ b/drivers/gpu/drm/drm_gem.c
>>> @@ -164,6 +164,9 @@ void drm_gem_private_object_init(struct 
>>> drm_device *dev,
>>>       if (!obj->resv)
>>>           obj->resv = &obj->_resv;
>>> +    if (drm_core_check_feature(dev, DRIVER_GEM_GPUVA))
>>> +        drm_gem_gpuva_init(obj);
>>> +
>>>       drm_vma_node_reset(&obj->vma_node);
>>>       INIT_LIST_HEAD(&obj->lru_node);
>>>   }
>>> diff --git a/drivers/gpu/drm/drm_gpuva_mgr.c 
>>> b/drivers/gpu/drm/drm_gpuva_mgr.c
>>> new file mode 100644
>>> index 000000000000..4414990c05cc
>>> --- /dev/null
>>> +++ b/drivers/gpu/drm/drm_gpuva_mgr.c
>>> @@ -0,0 +1,1743 @@
>>> +// SPDX-License-Identifier: GPL-2.0
>>> +/*
>> SPDX-License is GPL-2.0 but below looks like MIT. Can we use "GPL-2.0 
>> OR MIT" or does something restrict it to GPL-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 it's own nor memory allocations of 
>>> &drm_gpuva
>> s/it's/its/
>>> + * 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 it's capability to manage and represent a GPU VA space, the
>> s/it's/its/
>>> + * &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 it's BO offset.
>> Typo: s/it's/its/ above and in multiple places below.
>>> + *
>>> + *    ::
>>> + *
>>> + *         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 it's 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 by setting the 
>>> @DRM_GPUVA_MANAGER_LOCK_EXTERN
>>> + * flag.
>>
>> Is the external lock used or anticipated by any WIP implementation? 
>> If not I suggest to leave it out until there is a user.
>
> I think the PowerVR driver requires this. However, it's generally 
> useful for any driver using direct callbacks rather than drm_gpuva_ops.
>
> Once the page table handling in Nouveau is re-worked, and direct 
> callbacks can be used, I probably want to use this in Nouveau as well.
>
> Gonna fix up all other comments.

Sounds good to me. The main concern here with the external lock was 
testing coverage if no user. I don't have anything against it per se.

Going on vacation on Monday, but that Acked-by: once addressed on IRC 
still holds.

Thanks,

Thomas


>
> - Danilo
>
>>
>>> + *
>>> + * For the latter, functions such as drm_gpuva_link() or 
>>> drm_gpuva_unlink()
>>> + * contain lockdep checks to indicate locking issues. For this to 
>>> work drivers
>>> + * must provide (in case the @DRM_GPUVA_MANAGER_LOCK_EXTERN flag is 
>>> set) their
>>> + * external lock with drm_gpuva_manager_set_ext_lock() after 
>>> initialization.
>>> + */
>>> +
>>> +/**
>>> + * 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 __attribute__((unused)),
>>
>> Would  s/__attribute__((unused))/__maybe_unused/ work here?
>>
>>> +             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 inline bool
>> "static inline" is typically used only in header files, since the 
>> compiler should be smart enough to inline if beneficial. Prefer 
>> "static". Also in multiple places below.
>>> +drm_gpuva_check_overflow(u64 addr, u64 range)
>>> +{
>>> +    u64 end;
>>> +
>>> +    return WARN(check_add_overflow(addr, range, &end),
>>> +            "GPUVA address limited to %lu bytes.\n", sizeof(end));
>>> +}
>>> +
>>> +static inline 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 inline 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 inline 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
>> Function kerneldoc names should end with "()": 
>> drm_gpuva_manager_init(). General comment across the patch.
>>> + * @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
>>> + * @flags: the feature flags for the &drm_gpuva_manager
>>> + *
>>> + * 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,
>>> +               enum drm_gpuva_manager_flags flags)
>>> +{
>>> +    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->flags = flags;
>>> +    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(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(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(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(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_gpuva_manager *mgr = va->mgr;
>>> +    struct drm_gem_object *obj = va->gem.obj;
>>> +
>>> +    if (unlikely(!obj))
>>> +        return;
>>> +
>>> +    if (drm_gpuva_manager_external_lock(mgr))
>>> +        drm_gpuva_manager_ext_assert_held(mgr);
>>> +    else
>>> +        dma_resv_assert_held(obj->resv);
>>> +
>>> +    list_add_tail(&va->gem.entry, &obj->gpuva.list);
>>> +}
>>> +EXPORT_SYMBOL(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_gpuva_manager *mgr = va->mgr;
>>> +    struct drm_gem_object *obj = va->gem.obj;
>>> +
>>> +    if (unlikely(!obj))
>>> +        return;
>>> +
>>> +    if (drm_gpuva_manager_external_lock(mgr))
>>> +        drm_gpuva_manager_ext_assert_held(mgr);
>>> +    else
>>> +        dma_resv_assert_held(obj->resv);
>>> +
>>> +    list_del_init(&va->gem.entry);
>>> +}
>>> +EXPORT_SYMBOL(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(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(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(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(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(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(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;
>>> +    struct drm_gpuva_op_map *map;
>>> +
>>> +    drm_gpuva_remove(curr);
>>> +
>>> +    if ((map = op->prev)) {
>>> +        drm_gpuva_init_from_op(prev, map);
>>> +        drm_gpuva_insert(mgr, prev);
>>> +    }
>>> +
>>> +    if ((map = op->next)) {
>>> +        drm_gpuva_init_from_op(next, map);
>>> +        drm_gpuva_insert(mgr, next);
>>> +    }
>>> +}
>>> +EXPORT_SYMBOL(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(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, *prev = NULL;
>>> +    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;
>>> +                goto next;
>>> +            }
>>> +
>>> +            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;
>>> +                goto next;
>>> +            }
>>> +
>>> +            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;
>>> +                goto next;
>>> +            }
>>> +
>>> +            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;
>>> +            }
>>> +        }
>>> +next:
>>> +        prev = va;
>>> +    }
>>> +
>>> +    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(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(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(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(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(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;
>>> +
>>> +    if (drm_gpuva_manager_external_lock(mgr))
>>> +        drm_gpuva_manager_ext_assert_held(mgr);
>>> +    else
>>> +        dma_resv_assert_held(obj->resv);
>>> +
>>> +    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(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(drm_gpuva_ops_free);
>>> diff --git a/include/drm/drm_drv.h b/include/drm/drm_drv.h
>>> index 89e2706cac56..04dbe223b1a5 100644
>>> --- a/include/drm/drm_drv.h
>>> +++ b/include/drm/drm_drv.h
>>> @@ -104,6 +104,12 @@ enum drm_driver_feature {
>>>        * acceleration should be handled by two drivers that are 
>>> connected using auxiliary bus.
>>>        */
>>>       DRIVER_COMPUTE_ACCEL            = BIT(7),
>>> +    /**
>>> +     * @DRIVER_GEM_GPUVA:
>>> +     *
>>> +     * Driver supports user defined GPU VA bindings for GEM objects.
>>> +     */
>>> +    DRIVER_GEM_GPUVA        = BIT(8),
>>>       /* IMPORTANT: Below are all the legacy flags, add new ones 
>>> above. */
>>> diff --git a/include/drm/drm_gem.h b/include/drm/drm_gem.h
>>> index bbc721870c13..5ec8148a30ee 100644
>>> --- a/include/drm/drm_gem.h
>>> +++ b/include/drm/drm_gem.h
>>> @@ -36,6 +36,8 @@
>>>   #include <linux/kref.h>
>>>   #include <linux/dma-resv.h>
>>> +#include <linux/list.h>
>>> +#include <linux/mutex.h>
>>>   #include <drm/drm_vma_manager.h>
>>> @@ -379,6 +381,18 @@ struct drm_gem_object {
>>>        */
>>>       struct dma_resv _resv;
>>> +    /**
>>> +     * @gpuva:
>>> +     *
>>> +     * Provides the list of GPU VAs attached to this GEM object.
>>> +     *
>>> +     * Drivers should lock list accesses with the GEMs &dma_resv lock
>>> +     * (&drm_gem_object.resv).
>>> +     */
>>> +    struct {
>>> +        struct list_head list;
>>> +    } gpuva;
>>> +
>>>       /**
>>>        * @funcs:
>>>        *
>>> @@ -526,4 +540,42 @@ unsigned long drm_gem_lru_scan(struct 
>>> drm_gem_lru *lru,
>>>   int drm_gem_evict(struct drm_gem_object *obj);
>>> +/**
>>> + * drm_gem_gpuva_init - initialize the gpuva list of a GEM object
>>> + * @obj: the &drm_gem_object
>>> + *
>>> + * This initializes the &drm_gem_object's &drm_gpuva list.
>>> + *
>>> + * Calling this function is only necessary for drivers intending to 
>>> support the
>>> + * &drm_driver_feature DRIVER_GEM_GPUVA.
>>> + */
>>> +static inline void drm_gem_gpuva_init(struct drm_gem_object *obj)
>>> +{
>>> +    INIT_LIST_HEAD(&obj->gpuva.list);
>>> +}
>>> +
>>> +/**
>>> + * drm_gem_for_each_gpuva - iternator to walk over a list of gpuvas
>>
>> s/iternator/iterator/. (multiple places) Although since "iterator" 
>> typically refers to an object being iterated over, perhaps
>>
>> "drm_gem_for_each_gpuva() - iterate over a list of gpuvas", (general 
>> comment across the patch).
>>
>>> + * @entry: &drm_gpuva structure to assign to in each iteration step
>>> + * @obj: the &drm_gem_object the &drm_gpuvas to walk are associated 
>>> with
>>> + *
>>> + * This iterator walks over all &drm_gpuva structures associated 
>>> with the
>>> + * &drm_gpuva_manager.
>>> + */
>>> +#define drm_gem_for_each_gpuva(entry__, obj__) \
>>> +    list_for_each_entry(entry__, &(obj__)->gpuva.list, gem.entry)
>>> +
>>> +/**
>>> + * drm_gem_for_each_gpuva_safe - iternator to safely walk over a 
>>> list of gpuvas
>>> + * @entry: &drm_gpuva structure to assign to in each iteration step
>>> + * @next: &next &drm_gpuva to store the next step
>>> + * @obj: the &drm_gem_object the &drm_gpuvas to walk are associated 
>>> with
>>> + *
>>> + * This iterator walks over all &drm_gpuva structures associated 
>>> with the
>>> + * &drm_gem_object. It is implemented with 
>>> list_for_each_entry_safe(), hence
>>> + * it is save against removal of elements.
>>> + */
>>> +#define drm_gem_for_each_gpuva_safe(entry__, next__, obj__) \
>>> +    list_for_each_entry_safe(entry__, next__, &(obj__)->gpuva.list, 
>>> gem.entry)
>>> +
>>>   #endif /* __DRM_GEM_H__ */
>>> diff --git a/include/drm/drm_gpuva_mgr.h b/include/drm/drm_gpuva_mgr.h
>>> new file mode 100644
>>> index 000000000000..4f23aaf726dd
>>> --- /dev/null
>>> +++ b/include/drm/drm_gpuva_mgr.h
>>> @@ -0,0 +1,756 @@
>>> +/* SPDX-License-Identifier: GPL-2.0 */
>>> +
>>> +#ifndef __DRM_GPUVA_MGR_H__
>>> +#define __DRM_GPUVA_MGR_H__
>>> +
>>> +/*
>>> + * 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.
>>> + */
>>> +
>>> +#include <linux/list.h>
>>> +#include <linux/rbtree.h>
>>> +#include <linux/types.h>
>>> +
>>> +#include <drm/drm_gem.h>
>>> +
>>> +struct drm_gpuva_manager;
>>> +struct drm_gpuva_fn_ops;
>>> +
>>> +/**
>>> + * enum drm_gpuva_flags - flags for struct drm_gpuva
>>> + */
>>> +enum drm_gpuva_flags {
>>> +    /**
>>> +     * @DRM_GPUVA_INVALIDATED:
>>> +     *
>>> +     * Flag indicating that the &drm_gpuva's backing GEM is 
>>> invalidated.
>>> +     */
>>> +    DRM_GPUVA_INVALIDATED = (1 << 0),
>>> +
>>> +    /**
>>> +     * @DRM_GPUVA_SPARSE:
>>> +     *
>>> +     * Flag indicating that the &drm_gpuva is a sparse mapping.
>>> +     */
>>> +    DRM_GPUVA_SPARSE = (1 << 1),
>>> +
>>> +    /**
>>> +     * @DRM_GPUVA_USERBITS: user defined bits
>>> +     */
>>> +    DRM_GPUVA_USERBITS = (1 << 2),
>>> +};
>>> +
>>> +/**
>>> + * struct drm_gpuva - structure to track a GPU VA mapping
>>> + *
>>> + * This structure represents a GPU VA mapping and is associated with a
>>> + * &drm_gpuva_manager.
>>> + *
>>> + * Typically, this structure is embedded in bigger driver structures.
>>> + */
>>> +struct drm_gpuva {
>>> +    /**
>>> +     * @mgr: the &drm_gpuva_manager this object is associated with
>>> +     */
>>> +    struct drm_gpuva_manager *mgr;
>>> +
>>> +    /**
>>> +     * @flags: the &drm_gpuva_flags for this mapping
>>> +     */
>>> +    enum drm_gpuva_flags flags;
>>> +
>>> +    /**
>>> +     * @va: structure containing the address and range of the 
>>> &drm_gpuva
>>> +     */
>>> +    struct {
>>> +        /**
>>> +         * @addr: the start address
>>> +         */
>>> +        u64 addr;
>>> +
>>> +        /*
>>> +         * @range: the range
>>> +         */
>>> +        u64 range;
>>> +    } va;
>>> +
>>> +    /**
>>> +     * @gem: structure containing the &drm_gem_object and it's offset
>>> +     */
>>> +    struct {
>>> +        /**
>>> +         * @offset: the offset within the &drm_gem_object
>>> +         */
>>> +        u64 offset;
>>> +
>>> +        /**
>>> +         * @obj: the mapped &drm_gem_object
>>> +         */
>>> +        struct drm_gem_object *obj;
>>> +
>>> +        /**
>>> +         * @entry: the &list_head to attach this object to a 
>>> &drm_gem_object
>>> +         */
>>> +        struct list_head entry;
>>> +    } gem;
>>> +
>>> +    /**
>>> +     * @rb: structure containing data to store &drm_gpuvas in a 
>>> rb-tree
>>> +     */
>>> +    struct {
>>> +        /**
>>> +         * @rb: the rb-tree node
>>> +         */
>>> +        struct rb_node node;
>>> +
>>> +        /**
>>> +         * @entry: The &list_head to additionally connect &drm_gpuvas
>>> +         * in the same order they appear in the interval tree. This is
>>> +         * useful to keep iterating &drm_gpuvas from a start node 
>>> found
>>> +         * through the rb-tree while doing modifications on the 
>>> rb-tree
>>> +         * itself.
>>> +         */
>>> +        struct list_head entry;
>>> +
>>> +        /**
>>> +         * @__subtree_last: needed by the interval tree, holding 
>>> last-in-subtree
>>> +         */
>>> +        u64 __subtree_last;
>>> +    } rb;
>>> +};
>>> +
>>> +int drm_gpuva_insert(struct drm_gpuva_manager *mgr, struct 
>>> drm_gpuva *va);
>>> +void drm_gpuva_remove(struct drm_gpuva *va);
>>> +
>>> +void drm_gpuva_link(struct drm_gpuva *va);
>>> +void drm_gpuva_unlink(struct drm_gpuva *va);
>>> +
>>> +struct drm_gpuva *drm_gpuva_find(struct drm_gpuva_manager *mgr,
>>> +                 u64 addr, u64 range);
>>> +struct drm_gpuva *drm_gpuva_find_first(struct drm_gpuva_manager *mgr,
>>> +                       u64 addr, u64 range);
>>> +struct drm_gpuva *drm_gpuva_find_prev(struct drm_gpuva_manager 
>>> *mgr, u64 start);
>>> +struct drm_gpuva *drm_gpuva_find_next(struct drm_gpuva_manager 
>>> *mgr, u64 end);
>>> +
>>> +bool drm_gpuva_interval_empty(struct drm_gpuva_manager *mgr, u64 
>>> addr, u64 range);
>>> +
>>> +static inline void drm_gpuva_init(struct drm_gpuva *va, u64 addr, 
>>> u64 range,
>>> +                  struct drm_gem_object *obj, u64 offset)
>>> +{
>>> +    va->va.addr = addr;
>>> +    va->va.range = range;
>>> +    va->gem.obj = obj;
>>> +    va->gem.offset = offset;
>>> +}
>>> +
>>> +/**
>>> + * drm_gpuva_invalidate - sets whether the backing GEM of this 
>>> &drm_gpuva is
>>> + * invalidated
>>> + * @va: the &drm_gpuva to set the invalidate flag for
>>> + * @invalidate: indicates whether the &drm_gpuva is invalidated
>>> + */
>>> +static inline void drm_gpuva_invalidate(struct drm_gpuva *va, bool 
>>> invalidate)
>>> +{
>>> +    if (invalidate)
>>> +        va->flags |= DRM_GPUVA_INVALIDATED;
>>> +    else
>>> +        va->flags &= ~DRM_GPUVA_INVALIDATED;
>>> +}
>>> +
>>> +/**
>>> + * drm_gpuva_invalidated - indicates whether the backing BO of this 
>>> &drm_gpuva
>>> + * is invalidated
>>> + * @va: the &drm_gpuva to check
>>> + */
>>> +static inline bool drm_gpuva_invalidated(struct drm_gpuva *va)
>>> +{
>>> +    return va->flags & DRM_GPUVA_INVALIDATED;
>>> +}
>>> +
>>> +#ifdef CONFIG_LOCKDEP
>>> +typedef struct lockdep_map *lockdep_map_p;
>>> +#define drm_gpuva_manager_ext_assert_held(mgr)        \
>>> +    lockdep_assert(lock_is_held((mgr)->ext_lock) != 
>>> LOCK_STATE_NOT_HELD)
>>> +/**
>>> + * drm_gpuva_manager_set_ext_lock - set the external lock according to
>>> + * @DRM_GPUVA_MANAGER_LOCK_EXTERN
>>> + * @mgr: the &drm_gpuva_manager to set the lock for
>>> + * @lock: the lock to set
>>> + *
>>> + * If @DRM_GPUVA_MANAGER_LOCK_EXTERN is set, drivers need to call 
>>> this function
>>> + * to provide the lock used to lock linking and unlinking of 
>>> &drm_gpuvas to the
>>> + * &drm_gem_objects GPUVA list.
>>> + */
>>> +#define drm_gpuva_manager_set_ext_lock(mgr, lock)    \
>>> +    (mgr)->ext_lock = &(lock)->dep_map
>>> +#else
>>> +typedef struct { /* nothing */ } lockdep_map_p;
>>> +#define drm_gpuva_manager_ext_assert_held(mgr)        do { 
>>> (void)(mgr); } while (0)
>>> +#define drm_gpuva_manager_set_ext_lock(mgr, lock)    do { } while (0)
>>> +#endif
>>> +
>>> +/**
>>> + * enum drm_gpuva_manager_flags - the feature flags for the 
>>> &drm_gpuva_manager
>>> + */
>>> +enum drm_gpuva_manager_flags {
>>> +    /**
>>> +     * @DRM_GPUVA_MANAGER_LOCK_EXTERN:
>>> +     *
>>> +     * Indicates the driver has it's own external lock for linking and
>>> +     * unlinking &drm_gpuvas to the &drm_gem_objects GPUVA list.
>>> +     *
>>> +     * When setting this flag it is rquired to set a lock via
>>> +     * drm_gpuva_set_ext_lock().
>>> +     */
>>> +    DRM_GPUVA_MANAGER_LOCK_EXTERN = (1 << 0),
>>> +};
>>> +
>>> +/**
>>> + * struct drm_gpuva_manager - DRM GPU VA Manager
>>> + *
>>> + * The DRM GPU VA Manager keeps track of a GPU's virtual address 
>>> space by using
>>> + * &maple_tree structures. Typically, this structure is embedded in 
>>> bigger
>>> + * driver structures.
>>> + *
>>> + * Drivers can pass addresses and ranges in an arbitrary unit, e.g. 
>>> bytes or
>>> + * pages.
>>> + *
>>> + * There should be one manager instance per GPU virtual address space.
>>> + */
>>> +struct drm_gpuva_manager {
>>> +    /**
>>> +     * @name: the name of the DRM GPU VA space
>>> +     */
>>> +    const char *name;
>>> +
>>> +    /**
>>> +     * @flags: the feature flags of the &drm_gpuva_manager
>>> +     */
>>> +    enum drm_gpuva_manager_flags flags;
>>> +
>>> +    /**
>>> +     * @mm_start: start of the VA space
>>> +     */
>>> +    u64 mm_start;
>>> +
>>> +    /**
>>> +     * @mm_range: length of the VA space
>>> +     */
>>> +    u64 mm_range;
>>> +
>>> +    /**
>>> +     * @rb: structures to track &drm_gpuva entries
>>> +     */
>>> +    struct {
>>> +        /**
>>> +         * @tree: the rb-tree to track GPU VA mappings
>>> +         */
>>> +        struct rb_root_cached tree;
>>> +
>>> +        /**
>>> +         * @list: the &list_head to track GPU VA mappings
>>> +         */
>>> +        struct list_head list;
>>> +    } rb;
>>> +
>>> +    /**
>>> +     * @kernel_alloc_node:
>>> +     *
>>> +     * &drm_gpuva representing the address space cutout reserved for
>>> +     * the kernel
>>> +     */
>>> +    struct drm_gpuva kernel_alloc_node;
>>> +
>>> +    /**
>>> +     * @ops: &drm_gpuva_fn_ops providing the split/merge steps to 
>>> drivers
>>> +     */
>>> +    const struct drm_gpuva_fn_ops *ops;
>>> +
>>> +    /**
>>> +     * @ext_lock: &lockdep_map according to 
>>> @DRM_GPUVA_MANAGER_LOCK_EXTERN
>>> +     */
>>> +    lockdep_map_p ext_lock;
>>> +};
>>> +
>>> +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,
>>> +                enum drm_gpuva_manager_flags flags);
>>> +void drm_gpuva_manager_destroy(struct drm_gpuva_manager *mgr);
>>> +
>>> +/**
>>> + * drm_gpuva_manager_external_lock - indicates whether the
>>> + * @DRM_GPUVA_MANAGER_LOCK_EXTERN flag is set
>>> + * @mgr: the &drm_gpuva_manager to check the flag for
>>> + */
>>> +static inline bool drm_gpuva_manager_external_lock(struct 
>>> drm_gpuva_manager *mgr)
>>> +{
>>> +    return mgr->flags & DRM_GPUVA_MANAGER_LOCK_EXTERN;
>>> +}
>>> +
>>> +/**
>>> + * drm_gpuva_for_each_va_range - iternator to walk over a range of 
>>> &drm_gpuvas
>>> + * @va__: &drm_gpuva structure to assign to in each iteration step
>>> + * @mgr__: &drm_gpuva_manager to walk over
>>> + * @start__: starting offset, the first gpuva will overlap this
>>> + * @end__: ending offset, the last gpuva will start before this 
>>> (but may
>>> + * overlap)
>>> + *
>>> + * This iterator walks over all &drm_gpuvas in the 
>>> &drm_gpuva_manager that lie
>>> + * between @start__ and @end__. It is implemented similarly to 
>>> list_for_each(),
>>> + * but is using the &drm_gpuva_manager's internal interval tree to 
>>> accelerate
>>> + * the search for the starting &drm_gpuva, and hence isn't safe 
>>> against removal
>>> + * of elements. It assumes that @end__ is within (or is the upper 
>>> limit of) the
>>> + * &drm_gpuva_manager. This iterator does not skip over the 
>>> &drm_gpuva_manager's
>>> + * @kernel_alloc_node.
>>> + */
>>> +#define drm_gpuva_for_each_va_range(va__, mgr__, start__, end__) \
>>> +    for (va__ = drm_gpuva_find_first((mgr__), (start__), (end__)); \
>>> +         va__ && (va__->va.addr < (end__)) && \
>>> +         !list_entry_is_head(va__, &(mgr__)->rb.list, rb.entry); \
>>> +         va__ = list_next_entry(va__, rb.entry))
>>> +
>>> +/**
>>> + * drm_gpuva_for_each_va_range_safe - iternator to safely walk over 
>>> a range of
>>> + * &drm_gpuvas
>>> + * @va__: &drm_gpuva to assign to in each iteration step
>>> + * @next__: another &drm_gpuva to use as temporary storage
>>> + * @mgr__: &drm_gpuva_manager to walk over
>>> + * @start__: starting offset, the first gpuva will overlap this
>>> + * @end__: ending offset, the last gpuva will start before this 
>>> (but may
>>> + * overlap)
>>> + *
>>> + * This iterator walks over all &drm_gpuvas in the 
>>> &drm_gpuva_manager that lie
>>> + * between @start__ and @end__. It is implemented similarly to
>>> + * list_for_each_safe(), but is using the &drm_gpuva_manager's 
>>> internal interval
>>> + * tree to accelerate the search for the starting &drm_gpuva, and 
>>> hence is safe
>>> + * against removal of elements. It assumes that @end__ is within 
>>> (or is the
>>> + * upper limit of) the &drm_gpuva_manager. This iterator does not 
>>> skip over the
>>> + * &drm_gpuva_manager's @kernel_alloc_node.
>>> + */
>>> +#define drm_gpuva_for_each_va_range_safe(va__, next__, mgr__, 
>>> start__, end__) \
>>> +    for (va__ = drm_gpuva_find_first((mgr__), (start__), (end__)), \
>>> +         next__ = va ? list_next_entry(va__, rb.entry) : NULL; \
>>> +         va__ && (va__->va.addr < (end__)) && \
>>> +         !list_entry_is_head(va__, &(mgr__)->rb.list, rb.entry); \
>>> +         va__ = next__, next__ = list_next_entry(va__, rb.entry))
>>> +
>>> +/**
>>> + * drm_gpuva_for_each_va - iternator to walk over all &drm_gpuvas
>>> + * @va__: &drm_gpuva to assign to in each iteration step
>>> + * @mgr__: &drm_gpuva_manager to walk over
>>> + *
>>> + * This iterator walks over all &drm_gpuva structures associated 
>>> with the given
>>> + * &drm_gpuva_manager.
>>> + */
>>> +#define drm_gpuva_for_each_va(va__, mgr__) \
>>> +    list_for_each_entry(va__, &(mgr__)->rb.list, rb.entry)
>>> +
>>> +/**
>>> + * drm_gpuva_for_each_va_safe - iternator to safely walk over all 
>>> &drm_gpuvas
>>> + * @va__: &drm_gpuva to assign to in each iteration step
>>> + * @next__: another &drm_gpuva to use as temporary storage
>>> + * @mgr__: &drm_gpuva_manager to walk over
>>> + *
>>> + * This iterator walks over all &drm_gpuva structures associated 
>>> with the given
>>> + * &drm_gpuva_manager. It is implemented with 
>>> list_for_each_entry_safe(), and
>>> + * hence safe against the removal of elements.
>>> + */
>>> +#define drm_gpuva_for_each_va_safe(va__, next__, mgr__) \
>>> +    list_for_each_entry_safe(va__, next__, &(mgr__)->rb.list, 
>>> rb.entry)
>>> +
>>> +/**
>>> + * enum drm_gpuva_op_type - GPU VA operation type
>>> + *
>>> + * Operations to alter the GPU VA mappings tracked by the 
>>> &drm_gpuva_manager.
>>> + */
>>> +enum drm_gpuva_op_type {
>>> +    /**
>>> +     * @DRM_GPUVA_OP_MAP: the map op type
>>> +     */
>>> +    DRM_GPUVA_OP_MAP,
>>> +
>>> +    /**
>>> +     * @DRM_GPUVA_OP_REMAP: the remap op type
>>> +     */
>>> +    DRM_GPUVA_OP_REMAP,
>>> +
>>> +    /**
>>> +     * @DRM_GPUVA_OP_UNMAP: the unmap op type
>>> +     */
>>> +    DRM_GPUVA_OP_UNMAP,
>>> +
>>> +    /**
>>> +     * @DRM_GPUVA_OP_PREFETCH: the prefetch op type
>>> +     */
>>> +    DRM_GPUVA_OP_PREFETCH,
>>> +};
>>> +
>>> +/**
>>> + * struct drm_gpuva_op_map - GPU VA map operation
>>> + *
>>> + * This structure represents a single map operation generated by the
>>> + * DRM GPU VA manager.
>>> + */
>>> +struct drm_gpuva_op_map {
>>> +    /**
>>> +     * @va: structure containing address and range of a map
>>> +     * operation
>>> +     */
>>> +    struct {
>>> +        /**
>>> +         * @addr: the base address of the new mapping
>>> +         */
>>> +        u64 addr;
>>> +
>>> +        /**
>>> +         * @range: the range of the new mapping
>>> +         */
>>> +        u64 range;
>>> +    } va;
>>> +
>>> +    /**
>>> +     * @gem: structure containing the &drm_gem_object and it's offset
>>> +     */
>>> +    struct {
>>> +        /**
>>> +         * @offset: the offset within the &drm_gem_object
>>> +         */
>>> +        u64 offset;
>>> +
>>> +        /**
>>> +         * @obj: the &drm_gem_object to map
>>> +         */
>>> +        struct drm_gem_object *obj;
>>> +    } gem;
>>> +};
>>> +
>>> +/**
>>> + * struct drm_gpuva_op_unmap - GPU VA unmap operation
>>> + *
>>> + * This structure represents a single unmap operation generated by the
>>> + * DRM GPU VA manager.
>>> + */
>>> +struct drm_gpuva_op_unmap {
>>> +    /**
>>> +     * @va: the &drm_gpuva to unmap
>>> +     */
>>> +    struct drm_gpuva *va;
>>> +
>>> +    /**
>>> +     * @keep:
>>> +     *
>>> +     * Indicates whether this &drm_gpuva is physically contiguous 
>>> with the
>>> +     * original mapping request.
>>> +     *
>>> +     * Optionally, if &keep is set, drivers may keep the actual 
>>> page table
>>> +     * mappings for this &drm_gpuva, adding the missing page table 
>>> entries
>>> +     * only and update the &drm_gpuva_manager accordingly.
>>> +     */
>>> +    bool keep;
>>> +};
>>> +
>>> +/**
>>> + * struct drm_gpuva_op_remap - GPU VA remap operation
>>> + *
>>> + * This represents a single remap operation generated by the DRM 
>>> GPU VA manager.
>>> + *
>>> + * A remap operation is generated when an existing GPU VA mmapping 
>>> is split up
>>> + * by inserting a new GPU VA mapping or by partially unmapping 
>>> existent
>>> + * mapping(s), hence it consists of a maximum of two map and one unmap
>>> + * operation.
>>> + *
>>> + * The @unmap operation takes care of removing the original 
>>> existing mapping.
>>> + * @prev is used to remap the preceding part, @next the subsequent 
>>> part.
>>> + *
>>> + * If either a new mapping's start address is aligned with the 
>>> start address
>>> + * of the old mapping or the new mapping's end address is aligned 
>>> with the
>>> + * end address of the old mapping, either @prev or @next is NULL.
>>> + *
>>> + * Note, the reason for a dedicated remap operation, rather than 
>>> arbitrary
>>> + * unmap and map operations, is to give drivers the chance of 
>>> extracting driver
>>> + * specific data for creating the new mappings from the unmap 
>>> operations's
>>> + * &drm_gpuva structure which typically is embedded in larger 
>>> driver specific
>>> + * structures.
>>> + */
>>> +struct drm_gpuva_op_remap {
>>> +    /**
>>> +     * @prev: the preceding part of a split mapping
>>> +     */
>>> +    struct drm_gpuva_op_map *prev;
>>> +
>>> +    /**
>>> +     * @next: the subsequent part of a split mapping
>>> +     */
>>> +    struct drm_gpuva_op_map *next;
>>> +
>>> +    /**
>>> +     * @unmap: the unmap operation for the original existing mapping
>>> +     */
>>> +    struct drm_gpuva_op_unmap *unmap;
>>> +};
>>> +
>>> +/**
>>> + * struct drm_gpuva_op_prefetch - GPU VA prefetch operation
>>> + *
>>> + * This structure represents a single prefetch operation generated 
>>> by the
>>> + * DRM GPU VA manager.
>>> + */
>>> +struct drm_gpuva_op_prefetch {
>>> +    /**
>>> +     * @va: the &drm_gpuva to prefetch
>>> +     */
>>> +    struct drm_gpuva *va;
>>> +};
>>> +
>>> +/**
>>> + * struct drm_gpuva_op - GPU VA operation
>>> + *
>>> + * This structure represents a single generic operation.
>>> + *
>>> + * The particular type of the operation is defined by @op.
>>> + */
>>> +struct drm_gpuva_op {
>>> +    /**
>>> +     * @entry:
>>> +     *
>>> +     * The &list_head used to distribute instances of this struct 
>>> within
>>> +     * &drm_gpuva_ops.
>>> +     */
>>> +    struct list_head entry;
>>> +
>>> +    /**
>>> +     * @op: the type of the operation
>>> +     */
>>> +    enum drm_gpuva_op_type op;
>>> +
>>> +    union {
>>> +        /**
>>> +         * @map: the map operation
>>> +         */
>>> +        struct drm_gpuva_op_map map;
>>> +
>>> +        /**
>>> +         * @remap: the remap operation
>>> +         */
>>> +        struct drm_gpuva_op_remap remap;
>>> +
>>> +        /**
>>> +         * @unmap: the unmap operation
>>> +         */
>>> +        struct drm_gpuva_op_unmap unmap;
>>> +
>>> +        /**
>>> +         * @prefetch: the prefetch operation
>>> +         */
>>> +        struct drm_gpuva_op_prefetch prefetch;
>>> +    };
>>> +};
>>> +
>>> +/**
>>> + * struct drm_gpuva_ops - wraps a list of &drm_gpuva_op
>>> + */
>>> +struct drm_gpuva_ops {
>>> +    /**
>>> +     * @list: the &list_head
>>> +     */
>>> +    struct list_head list;
>>> +};
>>> +
>>> +/**
>>> + * drm_gpuva_for_each_op - iterator to walk over &drm_gpuva_ops
>>> + * @op: &drm_gpuva_op to assign in each iteration step
>>> + * @ops: &drm_gpuva_ops to walk
>>> + *
>>> + * This iterator walks over all ops within a given list of operations.
>>> + */
>>> +#define drm_gpuva_for_each_op(op, ops) list_for_each_entry(op, 
>>> &(ops)->list, entry)
>>> +
>>> +/**
>>> + * drm_gpuva_for_each_op_safe - iterator to safely walk over 
>>> &drm_gpuva_ops
>>> + * @op: &drm_gpuva_op to assign in each iteration step
>>> + * @next: &next &drm_gpuva_op to store the next step
>>> + * @ops: &drm_gpuva_ops to walk
>>> + *
>>> + * This iterator walks over all ops within a given list of 
>>> operations. It is
>>> + * implemented with list_for_each_safe(), so save against removal 
>>> of elements.
>>> + */
>>> +#define drm_gpuva_for_each_op_safe(op, next, ops) \
>>> +    list_for_each_entry_safe(op, next, &(ops)->list, entry)
>>> +
>>> +/**
>>> + * drm_gpuva_for_each_op_from_reverse - iterate backwards from the 
>>> given point
>>> + * @op: &drm_gpuva_op to assign in each iteration step
>>> + * @ops: &drm_gpuva_ops to walk
>>> + *
>>> + * This iterator walks over all ops within a given list of 
>>> operations beginning
>>> + * from the given operation in reverse order.
>>> + */
>>> +#define drm_gpuva_for_each_op_from_reverse(op, ops) \
>>> +    list_for_each_entry_from_reverse(op, &(ops)->list, entry)
>>> +
>>> +/**
>>> + * drm_gpuva_first_op - returns the first &drm_gpuva_op from 
>>> &drm_gpuva_ops
>>> + * @ops: the &drm_gpuva_ops to get the fist &drm_gpuva_op from
>>> + */
>>> +#define drm_gpuva_first_op(ops) \
>>> +    list_first_entry(&(ops)->list, struct drm_gpuva_op, entry)
>>> +
>>> +/**
>>> + * drm_gpuva_last_op - returns the last &drm_gpuva_op from 
>>> &drm_gpuva_ops
>>> + * @ops: the &drm_gpuva_ops to get the last &drm_gpuva_op from
>>> + */
>>> +#define drm_gpuva_last_op(ops) \
>>> +    list_last_entry(&(ops)->list, struct drm_gpuva_op, entry)
>>> +
>>> +/**
>>> + * drm_gpuva_prev_op - previous &drm_gpuva_op in the list
>>> + * @op: the current &drm_gpuva_op
>>> + */
>>> +#define drm_gpuva_prev_op(op) list_prev_entry(op, entry)
>>> +
>>> +/**
>>> + * drm_gpuva_next_op - next &drm_gpuva_op in the list
>>> + * @op: the current &drm_gpuva_op
>>> + */
>>> +#define drm_gpuva_next_op(op) list_next_entry(op, entry)
>>> +
>>> +struct drm_gpuva_ops *
>>> +drm_gpuva_sm_map_ops_create(struct drm_gpuva_manager *mgr,
>>> +                u64 addr, u64 range,
>>> +                struct drm_gem_object *obj, u64 offset);
>>> +struct drm_gpuva_ops *
>>> +drm_gpuva_sm_unmap_ops_create(struct drm_gpuva_manager *mgr,
>>> +                  u64 addr, u64 range);
>>> +
>>> +struct drm_gpuva_ops *
>>> +drm_gpuva_prefetch_ops_create(struct drm_gpuva_manager *mgr,
>>> +                 u64 addr, u64 range);
>>> +
>>> +struct drm_gpuva_ops *
>>> +drm_gpuva_gem_unmap_ops_create(struct drm_gpuva_manager *mgr,
>>> +                   struct drm_gem_object *obj);
>>> +
>>> +void drm_gpuva_ops_free(struct drm_gpuva_manager *mgr,
>>> +            struct drm_gpuva_ops *ops);
>>> +
>>> +static inline void drm_gpuva_init_from_op(struct drm_gpuva *va,
>>> +                      struct drm_gpuva_op_map *op)
>>> +{
>>> +    drm_gpuva_init(va, op->va.addr, op->va.range,
>>> +               op->gem.obj, op->gem.offset);
>>> +}
>>> +
>>> +/**
>>> + * struct drm_gpuva_fn_ops - callbacks for split/merge steps
>>> + *
>>> + * This structure defines the callbacks used by &drm_gpuva_sm_map and
>>> + * &drm_gpuva_sm_unmap to provide the split/merge steps for map and 
>>> unmap
>>> + * operations to drivers.
>>> + */
>>> +struct drm_gpuva_fn_ops {
>>> +    /**
>>> +     * @op_alloc: called when the &drm_gpuva_manager allocates
>>> +     * a struct drm_gpuva_op
>>> +     *
>>> +     * Some drivers may want to embed struct drm_gpuva_op into driver
>>> +     * specific structures. By implementing this callback drivers can
>>> +     * allocate memory accordingly.
>>> +     *
>>> +     * This callback is optional.
>>> +     */
>>> +    struct drm_gpuva_op *(*op_alloc)(void);
>>> +
>>> +    /**
>>> +     * @op_free: called when the &drm_gpuva_manager frees a
>>> +     * struct drm_gpuva_op
>>> +     *
>>> +     * Some drivers may want to embed struct drm_gpuva_op into driver
>>> +     * specific structures. By implementing this callback drivers can
>>> +     * free the previously allocated memory accordingly.
>>> +     *
>>> +     * This callback is optional.
>>> +     */
>>> +    void (*op_free)(struct drm_gpuva_op *op);
>>> +
>>> +    /**
>>> +     * @sm_step_map: called from &drm_gpuva_sm_map to finally 
>>> insert the
>>> +     * mapping once all previous steps were completed
>>> +     *
>>> +     * The &priv pointer matches the one the driver passed to
>>> +     * &drm_gpuva_sm_map or &drm_gpuva_sm_unmap, respectively.
>>> +     *
>>> +     * Can be NULL if &drm_gpuva_sm_map is used.
>>> +     */
>>> +    int (*sm_step_map)(struct drm_gpuva_op *op, void *priv);
>>> +
>>> +    /**
>>> +     * @sm_step_remap: called from &drm_gpuva_sm_map and
>>> +     * &drm_gpuva_sm_unmap to split up an existent mapping
>>> +     *
>>> +     * This callback is called when existent mapping needs to be 
>>> split up.
>>> +     * This is the case when either a newly requested mapping 
>>> overlaps or
>>> +     * is enclosed by an existent mapping or a partial unmap of an 
>>> existent
>>> +     * mapping is requested.
>>> +     *
>>> +     * The &priv pointer matches the one the driver passed to
>>> +     * &drm_gpuva_sm_map or &drm_gpuva_sm_unmap, respectively.
>>> +     *
>>> +     * Can be NULL if neither &drm_gpuva_sm_map nor 
>>> &drm_gpuva_sm_unmap is
>>> +     * used.
>>> +     */
>>> +    int (*sm_step_remap)(struct drm_gpuva_op *op, void *priv);
>>> +
>>> +    /**
>>> +     * @sm_step_unmap: called from &drm_gpuva_sm_map and
>>> +     * &drm_gpuva_sm_unmap to unmap an existent mapping
>>> +     *
>>> +     * This callback is called when existent mapping needs to be 
>>> unmapped.
>>> +     * This is the case when either a newly requested mapping 
>>> encloses an
>>> +     * existent mapping or an unmap of an existent mapping is 
>>> requested.
>>> +     *
>>> +     * The &priv pointer matches the one the driver passed to
>>> +     * &drm_gpuva_sm_map or &drm_gpuva_sm_unmap, respectively.
>>> +     *
>>> +     * Can be NULL if neither &drm_gpuva_sm_map nor 
>>> &drm_gpuva_sm_unmap is
>>> +     * used.
>>> +     */
>>> +    int (*sm_step_unmap)(struct drm_gpuva_op *op, void *priv);
>>> +};
>>> +
>>> +int drm_gpuva_sm_map(struct drm_gpuva_manager *mgr, void *priv,
>>> +             u64 addr, u64 range,
>>> +             struct drm_gem_object *obj, u64 offset);
>>> +
>>> +int drm_gpuva_sm_unmap(struct drm_gpuva_manager *mgr, void *priv,
>>> +               u64 addr, u64 range);
>>> +
>>> +void drm_gpuva_map(struct drm_gpuva_manager *mgr,
>>> +           struct drm_gpuva *va,
>>> +           struct drm_gpuva_op_map *op);
>> Missing newline
>>> +void drm_gpuva_remap(struct drm_gpuva *prev,
>>> +             struct drm_gpuva *next,
>>> +             struct drm_gpuva_op_remap *op);
>> Missing newline
>>> +void drm_gpuva_unmap(struct drm_gpuva_op_unmap *op);
>>> +
>>> +#endif /* __DRM_GPUVA_MGR_H__ */
>>