// SPDX-License-Identifier: GPL-2.0 WITH Linux-syscall-note
|
/*
|
*
|
* (C) COPYRIGHT 2020-2022 ARM Limited. All rights reserved.
|
*
|
* This program is free software and is provided to you under the terms of the
|
* GNU General Public License version 2 as published by the Free Software
|
* Foundation, and any use by you of this program is subject to the terms
|
* of such GNU license.
|
*
|
* This program is distributed in the hope that it will be useful,
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
* GNU General Public License for more details.
|
*
|
* You should have received a copy of the GNU General Public License
|
* along with this program; if not, you can access it online at
|
* http://www.gnu.org/licenses/gpl-2.0.html.
|
*
|
*/
|
|
#include <mali_kbase.h>
|
#include <mali_kbase_mem_linux.h>
|
#include <mali_kbase_defs.h>
|
#include <mali_kbase_trace_gpu_mem.h>
|
|
/**
|
* struct kbase_dma_buf - Object instantiated when a dma-buf imported allocation
|
* is mapped to GPU for the first time within a process.
|
* Another instantiation is done for the case when that
|
* allocation is mapped for the first time to GPU.
|
*
|
* @dma_buf: Reference to dma_buf been imported.
|
* @dma_buf_node: Link node to maintain a rb_tree of kbase_dma_buf.
|
* @import_count: The number of times the dma_buf was imported.
|
*/
|
struct kbase_dma_buf {
|
struct dma_buf *dma_buf;
|
struct rb_node dma_buf_node;
|
u32 import_count;
|
};
|
|
/**
|
* kbase_delete_dma_buf_mapping - Delete a dma buffer mapping.
|
*
|
* @kctx: Pointer to kbase context.
|
* @dma_buf: Pointer to a dma buffer mapping.
|
* @tree: Pointer to root of rb_tree containing the dma_buf's mapped.
|
*
|
* when we un-map any dma mapping we need to remove them from rb_tree,
|
* rb_tree is maintained at kbase_device level and kbase_process level
|
* by passing the root of kbase_device or kbase_process we can remove
|
* the node from the tree.
|
*
|
* Return: true on success.
|
*/
|
static bool kbase_delete_dma_buf_mapping(struct kbase_context *kctx,
|
struct dma_buf *dma_buf,
|
struct rb_root *tree)
|
{
|
struct kbase_dma_buf *buf_node = NULL;
|
struct rb_node *node = tree->rb_node;
|
bool mapping_removed = false;
|
|
lockdep_assert_held(&kctx->kbdev->dma_buf_lock);
|
|
while (node) {
|
buf_node = rb_entry(node, struct kbase_dma_buf, dma_buf_node);
|
|
if (dma_buf == buf_node->dma_buf) {
|
WARN_ON(!buf_node->import_count);
|
|
buf_node->import_count--;
|
|
if (!buf_node->import_count) {
|
rb_erase(&buf_node->dma_buf_node, tree);
|
kfree(buf_node);
|
mapping_removed = true;
|
}
|
|
break;
|
}
|
|
if (dma_buf < buf_node->dma_buf)
|
node = node->rb_left;
|
else
|
node = node->rb_right;
|
}
|
|
WARN_ON(!buf_node);
|
return mapping_removed;
|
}
|
|
/**
|
* kbase_capture_dma_buf_mapping - capture a dma buffer mapping.
|
*
|
* @kctx: Pointer to kbase context.
|
* @dma_buf: Pointer to a dma buffer mapping.
|
* @root: Pointer to root of rb_tree containing the dma_buf's.
|
*
|
* We maintain a kbase_device level and kbase_process level rb_tree
|
* of all unique dma_buf's mapped to gpu memory. So when attach any
|
* dma_buf add it the rb_tree's. To add the unique mapping we need
|
* check if the mapping is not a duplicate and then add them.
|
*
|
* Return: true on success
|
*/
|
static bool kbase_capture_dma_buf_mapping(struct kbase_context *kctx,
|
struct dma_buf *dma_buf,
|
struct rb_root *root)
|
{
|
struct kbase_dma_buf *buf_node = NULL;
|
struct rb_node *node = root->rb_node;
|
bool unique_buf_imported = true;
|
|
lockdep_assert_held(&kctx->kbdev->dma_buf_lock);
|
|
while (node) {
|
buf_node = rb_entry(node, struct kbase_dma_buf, dma_buf_node);
|
|
if (dma_buf == buf_node->dma_buf) {
|
unique_buf_imported = false;
|
break;
|
}
|
|
if (dma_buf < buf_node->dma_buf)
|
node = node->rb_left;
|
else
|
node = node->rb_right;
|
}
|
|
if (unique_buf_imported) {
|
struct kbase_dma_buf *new_buf_node =
|
kzalloc(sizeof(*new_buf_node), GFP_KERNEL);
|
|
if (new_buf_node == NULL) {
|
dev_err(kctx->kbdev->dev, "Error allocating memory for kbase_dma_buf\n");
|
/* Dont account for it if we fail to allocate memory */
|
unique_buf_imported = false;
|
} else {
|
struct rb_node **new = &(root->rb_node), *parent = NULL;
|
|
new_buf_node->dma_buf = dma_buf;
|
new_buf_node->import_count = 1;
|
while (*new) {
|
struct kbase_dma_buf *new_node;
|
|
parent = *new;
|
new_node = rb_entry(parent, struct kbase_dma_buf,
|
dma_buf_node);
|
if (dma_buf < new_node->dma_buf)
|
new = &(*new)->rb_left;
|
else
|
new = &(*new)->rb_right;
|
}
|
rb_link_node(&new_buf_node->dma_buf_node, parent, new);
|
rb_insert_color(&new_buf_node->dma_buf_node, root);
|
}
|
} else if (!WARN_ON(!buf_node)) {
|
buf_node->import_count++;
|
}
|
|
return unique_buf_imported;
|
}
|
|
void kbase_remove_dma_buf_usage(struct kbase_context *kctx,
|
struct kbase_mem_phy_alloc *alloc)
|
{
|
struct kbase_device *kbdev = kctx->kbdev;
|
bool dev_mapping_removed, prcs_mapping_removed;
|
|
mutex_lock(&kbdev->dma_buf_lock);
|
|
dev_mapping_removed = kbase_delete_dma_buf_mapping(
|
kctx, alloc->imported.umm.dma_buf, &kbdev->dma_buf_root);
|
|
prcs_mapping_removed = kbase_delete_dma_buf_mapping(
|
kctx, alloc->imported.umm.dma_buf, &kctx->kprcs->dma_buf_root);
|
|
WARN_ON(dev_mapping_removed && !prcs_mapping_removed);
|
|
spin_lock(&kbdev->gpu_mem_usage_lock);
|
if (dev_mapping_removed)
|
kbdev->total_gpu_pages -= alloc->nents;
|
|
if (prcs_mapping_removed)
|
kctx->kprcs->total_gpu_pages -= alloc->nents;
|
|
if (dev_mapping_removed || prcs_mapping_removed)
|
kbase_trace_gpu_mem_usage(kbdev, kctx);
|
spin_unlock(&kbdev->gpu_mem_usage_lock);
|
|
mutex_unlock(&kbdev->dma_buf_lock);
|
}
|
|
void kbase_add_dma_buf_usage(struct kbase_context *kctx,
|
struct kbase_mem_phy_alloc *alloc)
|
{
|
struct kbase_device *kbdev = kctx->kbdev;
|
bool unique_dev_dmabuf, unique_prcs_dmabuf;
|
|
mutex_lock(&kbdev->dma_buf_lock);
|
|
/* add dma_buf to device and process. */
|
unique_dev_dmabuf = kbase_capture_dma_buf_mapping(
|
kctx, alloc->imported.umm.dma_buf, &kbdev->dma_buf_root);
|
|
unique_prcs_dmabuf = kbase_capture_dma_buf_mapping(
|
kctx, alloc->imported.umm.dma_buf, &kctx->kprcs->dma_buf_root);
|
|
WARN_ON(unique_dev_dmabuf && !unique_prcs_dmabuf);
|
|
spin_lock(&kbdev->gpu_mem_usage_lock);
|
if (unique_dev_dmabuf)
|
kbdev->total_gpu_pages += alloc->nents;
|
|
if (unique_prcs_dmabuf)
|
kctx->kprcs->total_gpu_pages += alloc->nents;
|
|
if (unique_prcs_dmabuf || unique_dev_dmabuf)
|
kbase_trace_gpu_mem_usage(kbdev, kctx);
|
spin_unlock(&kbdev->gpu_mem_usage_lock);
|
|
mutex_unlock(&kbdev->dma_buf_lock);
|
}
|
