* [PATCH v3 1/6] drm: move the buddy allocator from i915 into common drm
@ 2021-11-16 20:18 ` Arunpravin
0 siblings, 0 replies; 46+ messages in thread
From: Arunpravin @ 2021-11-16 20:18 UTC (permalink / raw)
To: dri-devel, intel-gfx, amd-gfx
Cc: Arunpravin, matthew.auld, tzimmermann, alexander.deucher,
christian.koenig
Move the base i915 buddy allocator code into drm
- Move i915_buddy.h to include/drm
- Move i915_buddy.c to drm root folder
- Rename "i915" string with "drm" string wherever applicable
- Rename "I915" string with "DRM" string wherever applicable
- Fix header file dependencies
- Fix alignment issues
- add Makefile support for drm buddy
- export functions and write kerneldoc description
- Remove i915 selftest config check condition as buddy selftest
will be moved to drm selftest folder
cleanup i915 buddy references in i915 driver module
and replace with drm buddy
v2:
- include header file in alphabetical order (Thomas)
- merged changes listed in the body section into a single patch
to keep the build intact (Christian, Jani)
Signed-off-by: Arunpravin <Arunpravin.PaneerSelvam@amd.com>
---
drivers/gpu/drm/Makefile | 2 +-
drivers/gpu/drm/drm_buddy.c | 521 ++++++++++++++++++
drivers/gpu/drm/drm_drv.c | 3 +
drivers/gpu/drm/i915/Makefile | 1 -
drivers/gpu/drm/i915/i915_buddy.c | 466 ----------------
drivers/gpu/drm/i915/i915_buddy.h | 143 -----
drivers/gpu/drm/i915/i915_module.c | 3 -
drivers/gpu/drm/i915/i915_scatterlist.c | 11 +-
drivers/gpu/drm/i915/i915_ttm_buddy_manager.c | 33 +-
drivers/gpu/drm/i915/i915_ttm_buddy_manager.h | 4 +-
include/drm/drm_buddy.h | 153 +++++
11 files changed, 702 insertions(+), 638 deletions(-)
create mode 100644 drivers/gpu/drm/drm_buddy.c
delete mode 100644 drivers/gpu/drm/i915/i915_buddy.c
delete mode 100644 drivers/gpu/drm/i915/i915_buddy.h
create mode 100644 include/drm/drm_buddy.h
diff --git a/drivers/gpu/drm/Makefile b/drivers/gpu/drm/Makefile
index 0dff40bb863c..dc61e91a3154 100644
--- a/drivers/gpu/drm/Makefile
+++ b/drivers/gpu/drm/Makefile
@@ -18,7 +18,7 @@ drm-y := drm_aperture.o drm_auth.o drm_cache.o \
drm_dumb_buffers.o drm_mode_config.o drm_vblank.o \
drm_syncobj.o drm_lease.o drm_writeback.o drm_client.o \
drm_client_modeset.o drm_atomic_uapi.o drm_hdcp.o \
- drm_managed.o drm_vblank_work.o
+ drm_managed.o drm_vblank_work.o drm_buddy.o
drm-$(CONFIG_DRM_LEGACY) += drm_agpsupport.o drm_bufs.o drm_context.o drm_dma.o \
drm_legacy_misc.o drm_lock.o drm_memory.o drm_scatter.o \
diff --git a/drivers/gpu/drm/drm_buddy.c b/drivers/gpu/drm/drm_buddy.c
new file mode 100644
index 000000000000..39eb1d224bec
--- /dev/null
+++ b/drivers/gpu/drm/drm_buddy.c
@@ -0,0 +1,521 @@
+// SPDX-License-Identifier: MIT
+/*
+ * Copyright © 2021 Intel Corporation
+ */
+
+#include <linux/kmemleak.h>
+#include <linux/sizes.h>
+
+#include <drm/drm_buddy.h>
+
+static struct kmem_cache *slab_blocks;
+
+static struct drm_buddy_block *drm_block_alloc(struct drm_buddy_mm *mm,
+ struct drm_buddy_block *parent,
+ unsigned int order,
+ u64 offset)
+{
+ struct drm_buddy_block *block;
+
+ BUG_ON(order > DRM_BUDDY_MAX_ORDER);
+
+ block = kmem_cache_zalloc(slab_blocks, GFP_KERNEL);
+ if (!block)
+ return NULL;
+
+ block->header = offset;
+ block->header |= order;
+ block->parent = parent;
+
+ BUG_ON(block->header & DRM_BUDDY_HEADER_UNUSED);
+ return block;
+}
+
+static void drm_block_free(struct drm_buddy_mm *mm,
+ struct drm_buddy_block *block)
+{
+ kmem_cache_free(slab_blocks, block);
+}
+
+static void mark_allocated(struct drm_buddy_block *block)
+{
+ block->header &= ~DRM_BUDDY_HEADER_STATE;
+ block->header |= DRM_BUDDY_ALLOCATED;
+
+ list_del(&block->link);
+}
+
+static void mark_free(struct drm_buddy_mm *mm,
+ struct drm_buddy_block *block)
+{
+ block->header &= ~DRM_BUDDY_HEADER_STATE;
+ block->header |= DRM_BUDDY_FREE;
+
+ list_add(&block->link,
+ &mm->free_list[drm_buddy_block_order(block)]);
+}
+
+static void mark_split(struct drm_buddy_block *block)
+{
+ block->header &= ~DRM_BUDDY_HEADER_STATE;
+ block->header |= DRM_BUDDY_SPLIT;
+
+ list_del(&block->link);
+}
+
+/**
+ * drm_buddy_init - init memory manager
+ *
+ * @mm: DRM buddy manager to initialize
+ * @size: size in bytes to manage
+ * @chunk_size: minimum page size in bytes for our allocations
+ *
+ * Initializes the memory manager and its resources.
+ *
+ * Returns:
+ * 0 on success, error code on failure.
+ */
+int drm_buddy_init(struct drm_buddy_mm *mm, u64 size, u64 chunk_size)
+{
+ unsigned int i;
+ u64 offset;
+
+ if (size < chunk_size)
+ return -EINVAL;
+
+ if (chunk_size < PAGE_SIZE)
+ return -EINVAL;
+
+ if (!is_power_of_2(chunk_size))
+ return -EINVAL;
+
+ size = round_down(size, chunk_size);
+
+ mm->size = size;
+ mm->avail = size;
+ mm->chunk_size = chunk_size;
+ mm->max_order = ilog2(size) - ilog2(chunk_size);
+
+ BUG_ON(mm->max_order > DRM_BUDDY_MAX_ORDER);
+
+ mm->free_list = kmalloc_array(mm->max_order + 1,
+ sizeof(struct list_head),
+ GFP_KERNEL);
+ if (!mm->free_list)
+ return -ENOMEM;
+
+ for (i = 0; i <= mm->max_order; ++i)
+ INIT_LIST_HEAD(&mm->free_list[i]);
+
+ mm->n_roots = hweight64(size);
+
+ mm->roots = kmalloc_array(mm->n_roots,
+ sizeof(struct drm_buddy_block *),
+ GFP_KERNEL);
+ if (!mm->roots)
+ goto out_free_list;
+
+ offset = 0;
+ i = 0;
+
+ /*
+ * Split into power-of-two blocks, in case we are given a size that is
+ * not itself a power-of-two.
+ */
+ do {
+ struct drm_buddy_block *root;
+ unsigned int order;
+ u64 root_size;
+
+ root_size = rounddown_pow_of_two(size);
+ order = ilog2(root_size) - ilog2(chunk_size);
+
+ root = drm_block_alloc(mm, NULL, order, offset);
+ if (!root)
+ goto out_free_roots;
+
+ mark_free(mm, root);
+
+ BUG_ON(i > mm->max_order);
+ BUG_ON(drm_buddy_block_size(mm, root) < chunk_size);
+
+ mm->roots[i] = root;
+
+ offset += root_size;
+ size -= root_size;
+ i++;
+ } while (size);
+
+ return 0;
+
+out_free_roots:
+ while (i--)
+ drm_block_free(mm, mm->roots[i]);
+ kfree(mm->roots);
+out_free_list:
+ kfree(mm->free_list);
+ return -ENOMEM;
+}
+EXPORT_SYMBOL(drm_buddy_init);
+
+/**
+ * drm_buddy_fini - tear down the memory manager
+ *
+ * @mm: DRM buddy manager to free
+ *
+ * Cleanup memory manager resources and the freelist
+ */
+void drm_buddy_fini(struct drm_buddy_mm *mm)
+{
+ int i;
+
+ for (i = 0; i < mm->n_roots; ++i) {
+ WARN_ON(!drm_buddy_block_is_free(mm->roots[i]));
+ drm_block_free(mm, mm->roots[i]);
+ }
+
+ WARN_ON(mm->avail != mm->size);
+
+ kfree(mm->roots);
+ kfree(mm->free_list);
+}
+EXPORT_SYMBOL(drm_buddy_fini);
+
+static int split_block(struct drm_buddy_mm *mm,
+ struct drm_buddy_block *block)
+{
+ unsigned int block_order = drm_buddy_block_order(block) - 1;
+ u64 offset = drm_buddy_block_offset(block);
+
+ BUG_ON(!drm_buddy_block_is_free(block));
+ BUG_ON(!drm_buddy_block_order(block));
+
+ block->left = drm_block_alloc(mm, block, block_order, offset);
+ if (!block->left)
+ return -ENOMEM;
+
+ block->right = drm_block_alloc(mm, block, block_order,
+ offset + (mm->chunk_size << block_order));
+ if (!block->right) {
+ drm_block_free(mm, block->left);
+ return -ENOMEM;
+ }
+
+ mark_free(mm, block->left);
+ mark_free(mm, block->right);
+
+ mark_split(block);
+
+ return 0;
+}
+
+static struct drm_buddy_block *
+get_buddy(struct drm_buddy_block *block)
+{
+ struct drm_buddy_block *parent;
+
+ parent = block->parent;
+ if (!parent)
+ return NULL;
+
+ if (parent->left == block)
+ return parent->right;
+
+ return parent->left;
+}
+
+static void __drm_buddy_free(struct drm_buddy_mm *mm,
+ struct drm_buddy_block *block)
+{
+ struct drm_buddy_block *parent;
+
+ while ((parent = block->parent)) {
+ struct drm_buddy_block *buddy;
+
+ buddy = get_buddy(block);
+
+ if (!drm_buddy_block_is_free(buddy))
+ break;
+
+ list_del(&buddy->link);
+
+ drm_block_free(mm, block);
+ drm_block_free(mm, buddy);
+
+ block = parent;
+ }
+
+ mark_free(mm, block);
+}
+
+void drm_buddy_free(struct drm_buddy_mm *mm,
+ struct drm_buddy_block *block)
+{
+ BUG_ON(!drm_buddy_block_is_allocated(block));
+ mm->avail += drm_buddy_block_size(mm, block);
+ __drm_buddy_free(mm, block);
+}
+
+/**
+ * drm_buddy_free_list - free blocks
+ *
+ * @mm: DRM buddy manager
+ * @objects: input list head to free blocks
+ */
+void drm_buddy_free_list(struct drm_buddy_mm *mm, struct list_head *objects)
+{
+ struct drm_buddy_block *block, *on;
+
+ list_for_each_entry_safe(block, on, objects, link) {
+ drm_buddy_free(mm, block);
+ cond_resched();
+ }
+ INIT_LIST_HEAD(objects);
+}
+EXPORT_SYMBOL(drm_buddy_free_list);
+
+/**
+ * drm_buddy_alloc - allocate power-of-two blocks
+ *
+ * @mm: DRM buddy manager to allocate from
+ * @order: size of the allocation
+ *
+ * The order value here translates to:
+ *
+ * 0 = 2^0 * mm->chunk_size
+ * 1 = 2^1 * mm->chunk_size
+ * 2 = 2^2 * mm->chunk_size
+ *
+ * Returns:
+ * allocated ptr to the &drm_buddy_block on success
+ */
+struct drm_buddy_block *
+drm_buddy_alloc(struct drm_buddy_mm *mm, unsigned int order)
+{
+ struct drm_buddy_block *block = NULL;
+ unsigned int i;
+ int err;
+
+ for (i = order; i <= mm->max_order; ++i) {
+ block = list_first_entry_or_null(&mm->free_list[i],
+ struct drm_buddy_block,
+ link);
+ if (block)
+ break;
+ }
+
+ if (!block)
+ return ERR_PTR(-ENOSPC);
+
+ BUG_ON(!drm_buddy_block_is_free(block));
+
+ while (i != order) {
+ err = split_block(mm, block);
+ if (unlikely(err))
+ goto out_free;
+
+ /* Go low */
+ block = block->left;
+ i--;
+ }
+
+ mark_allocated(block);
+ mm->avail -= drm_buddy_block_size(mm, block);
+ kmemleak_update_trace(block);
+ return block;
+
+out_free:
+ if (i != order)
+ __drm_buddy_free(mm, block);
+ return ERR_PTR(err);
+}
+EXPORT_SYMBOL(drm_buddy_alloc);
+
+static inline bool overlaps(u64 s1, u64 e1, u64 s2, u64 e2)
+{
+ return s1 <= e2 && e1 >= s2;
+}
+
+static inline bool contains(u64 s1, u64 e1, u64 s2, u64 e2)
+{
+ return s1 <= s2 && e1 >= e2;
+}
+
+/**
+ * drm_buddy_alloc_range - allocate range
+ *
+ * @mm: DRM buddy manager to allocate from
+ * @blocks: output list head to add allocated blocks
+ * @start: start of the allowed range for this block
+ * @size: size of the allocation
+ *
+ * Intended for pre-allocating portions of the address space, for example to
+ * reserve a block for the initial framebuffer or similar, hence the expectation
+ * here is that drm_buddy_alloc() is still the main vehicle for
+ * allocations, so if that's not the case then the drm_mm range allocator is
+ * probably a much better fit, and so you should probably go use that instead.
+ *
+ * Note that it's safe to chain together multiple alloc_ranges
+ * with the same blocks list
+ *
+ * Returns:
+ * 0 on success, error code on failure.
+ */
+int drm_buddy_alloc_range(struct drm_buddy_mm *mm,
+ struct list_head *blocks,
+ u64 start, u64 size)
+{
+ struct drm_buddy_block *block;
+ struct drm_buddy_block *buddy;
+ LIST_HEAD(allocated);
+ LIST_HEAD(dfs);
+ u64 end;
+ int err;
+ int i;
+
+ if (size < mm->chunk_size)
+ return -EINVAL;
+
+ if (!IS_ALIGNED(size | start, mm->chunk_size))
+ return -EINVAL;
+
+ if (range_overflows(start, size, mm->size))
+ return -EINVAL;
+
+ for (i = 0; i < mm->n_roots; ++i)
+ list_add_tail(&mm->roots[i]->tmp_link, &dfs);
+
+ end = start + size - 1;
+
+ do {
+ u64 block_start;
+ u64 block_end;
+
+ block = list_first_entry_or_null(&dfs,
+ struct drm_buddy_block,
+ tmp_link);
+ if (!block)
+ break;
+
+ list_del(&block->tmp_link);
+
+ block_start = drm_buddy_block_offset(block);
+ block_end = block_start + drm_buddy_block_size(mm, block) - 1;
+
+ if (!overlaps(start, end, block_start, block_end))
+ continue;
+
+ if (drm_buddy_block_is_allocated(block)) {
+ err = -ENOSPC;
+ goto err_free;
+ }
+
+ if (contains(start, end, block_start, block_end)) {
+ if (!drm_buddy_block_is_free(block)) {
+ err = -ENOSPC;
+ goto err_free;
+ }
+
+ mark_allocated(block);
+ mm->avail -= drm_buddy_block_size(mm, block);
+ list_add_tail(&block->link, &allocated);
+ continue;
+ }
+
+ if (!drm_buddy_block_is_split(block)) {
+ err = split_block(mm, block);
+ if (unlikely(err))
+ goto err_undo;
+ }
+
+ list_add(&block->right->tmp_link, &dfs);
+ list_add(&block->left->tmp_link, &dfs);
+ } while (1);
+
+ list_splice_tail(&allocated, blocks);
+ return 0;
+
+err_undo:
+ /*
+ * We really don't want to leave around a bunch of split blocks, since
+ * bigger is better, so make sure we merge everything back before we
+ * free the allocated blocks.
+ */
+ buddy = get_buddy(block);
+ if (buddy &&
+ (drm_buddy_block_is_free(block) &&
+ drm_buddy_block_is_free(buddy)))
+ __drm_buddy_free(mm, block);
+
+err_free:
+ drm_buddy_free_list(mm, &allocated);
+ return err;
+}
+EXPORT_SYMBOL(drm_buddy_alloc_range);
+
+/**
+ * drm_buddy_block_print - print block information
+ *
+ * @mm: DRM buddy manager
+ * @block: DRM buddy block
+ * @p: DRM printer to use
+ */
+void drm_buddy_block_print(struct drm_buddy_mm *mm,
+ struct drm_buddy_block *block,
+ struct drm_printer *p)
+{
+ u64 start = drm_buddy_block_offset(block);
+ u64 size = drm_buddy_block_size(mm, block);
+
+ drm_printf(p, "%#018llx-%#018llx: %llu\n", start, start + size, size);
+}
+EXPORT_SYMBOL(drm_buddy_block_print);
+
+/**
+ * drm_buddy_print - print allocator state
+ *
+ * @mm: DRM buddy manager
+ * @p: DRM printer to use
+ */
+void drm_buddy_print(struct drm_buddy_mm *mm, struct drm_printer *p)
+{
+ int order;
+
+ drm_printf(p, "chunk_size: %lluKiB, total: %lluMiB, free: %lluMiB\n",
+ mm->chunk_size >> 10, mm->size >> 20, mm->avail >> 20);
+
+ for (order = mm->max_order; order >= 0; order--) {
+ struct drm_buddy_block *block;
+ u64 count = 0, free;
+
+ list_for_each_entry(block, &mm->free_list[order], link) {
+ BUG_ON(!drm_buddy_block_is_free(block));
+ count++;
+ }
+
+ drm_printf(p, "order-%d ", order);
+
+ free = count * (mm->chunk_size << order);
+ if (free < SZ_1M)
+ drm_printf(p, "free: %lluKiB", free >> 10);
+ else
+ drm_printf(p, "free: %lluMiB", free >> 20);
+
+ drm_printf(p, ", pages: %llu\n", count);
+ }
+}
+EXPORT_SYMBOL(drm_buddy_print);
+
+void drm_buddy_module_exit(void)
+{
+ kmem_cache_destroy(slab_blocks);
+}
+
+int __init drm_buddy_module_init(void)
+{
+ slab_blocks = KMEM_CACHE(drm_buddy_block, 0);
+ if (!slab_blocks)
+ return -ENOMEM;
+
+ return 0;
+}
diff --git a/drivers/gpu/drm/drm_drv.c b/drivers/gpu/drm/drm_drv.c
index 7a5097467ba5..5d5e46e60586 100644
--- a/drivers/gpu/drm/drm_drv.c
+++ b/drivers/gpu/drm/drm_drv.c
@@ -35,6 +35,7 @@
#include <linux/slab.h>
#include <linux/srcu.h>
+#include <drm/drm_buddy.h>
#include <drm/drm_cache.h>
#include <drm/drm_client.h>
#include <drm/drm_color_mgmt.h>
@@ -1034,6 +1035,7 @@ static void drm_core_exit(void)
drm_sysfs_destroy();
idr_destroy(&drm_minors_idr);
drm_connector_ida_destroy();
+ drm_buddy_module_exit();
}
static int __init drm_core_init(void)
@@ -1043,6 +1045,7 @@ static int __init drm_core_init(void)
drm_connector_ida_init();
idr_init(&drm_minors_idr);
drm_memcpy_init_early();
+ drm_buddy_module_init();
ret = drm_sysfs_init();
if (ret < 0) {
diff --git a/drivers/gpu/drm/i915/Makefile b/drivers/gpu/drm/i915/Makefile
index 467872cca027..fc5ca8c4ccb2 100644
--- a/drivers/gpu/drm/i915/Makefile
+++ b/drivers/gpu/drm/i915/Makefile
@@ -161,7 +161,6 @@ gem-y += \
i915-y += \
$(gem-y) \
i915_active.o \
- i915_buddy.o \
i915_cmd_parser.o \
i915_gem_evict.o \
i915_gem_gtt.o \
diff --git a/drivers/gpu/drm/i915/i915_buddy.c b/drivers/gpu/drm/i915/i915_buddy.c
deleted file mode 100644
index 6e2ad68f8f3f..000000000000
--- a/drivers/gpu/drm/i915/i915_buddy.c
+++ /dev/null
@@ -1,466 +0,0 @@
-// SPDX-License-Identifier: MIT
-/*
- * Copyright © 2021 Intel Corporation
- */
-
-#include <linux/kmemleak.h>
-#include <linux/sizes.h>
-
-#include "i915_buddy.h"
-
-#include "i915_gem.h"
-#include "i915_utils.h"
-
-static struct kmem_cache *slab_blocks;
-
-static struct i915_buddy_block *i915_block_alloc(struct i915_buddy_mm *mm,
- struct i915_buddy_block *parent,
- unsigned int order,
- u64 offset)
-{
- struct i915_buddy_block *block;
-
- GEM_BUG_ON(order > I915_BUDDY_MAX_ORDER);
-
- block = kmem_cache_zalloc(slab_blocks, GFP_KERNEL);
- if (!block)
- return NULL;
-
- block->header = offset;
- block->header |= order;
- block->parent = parent;
-
- GEM_BUG_ON(block->header & I915_BUDDY_HEADER_UNUSED);
- return block;
-}
-
-static void i915_block_free(struct i915_buddy_mm *mm,
- struct i915_buddy_block *block)
-{
- kmem_cache_free(slab_blocks, block);
-}
-
-static void mark_allocated(struct i915_buddy_block *block)
-{
- block->header &= ~I915_BUDDY_HEADER_STATE;
- block->header |= I915_BUDDY_ALLOCATED;
-
- list_del(&block->link);
-}
-
-static void mark_free(struct i915_buddy_mm *mm,
- struct i915_buddy_block *block)
-{
- block->header &= ~I915_BUDDY_HEADER_STATE;
- block->header |= I915_BUDDY_FREE;
-
- list_add(&block->link,
- &mm->free_list[i915_buddy_block_order(block)]);
-}
-
-static void mark_split(struct i915_buddy_block *block)
-{
- block->header &= ~I915_BUDDY_HEADER_STATE;
- block->header |= I915_BUDDY_SPLIT;
-
- list_del(&block->link);
-}
-
-int i915_buddy_init(struct i915_buddy_mm *mm, u64 size, u64 chunk_size)
-{
- unsigned int i;
- u64 offset;
-
- if (size < chunk_size)
- return -EINVAL;
-
- if (chunk_size < PAGE_SIZE)
- return -EINVAL;
-
- if (!is_power_of_2(chunk_size))
- return -EINVAL;
-
- size = round_down(size, chunk_size);
-
- mm->size = size;
- mm->avail = size;
- mm->chunk_size = chunk_size;
- mm->max_order = ilog2(size) - ilog2(chunk_size);
-
- GEM_BUG_ON(mm->max_order > I915_BUDDY_MAX_ORDER);
-
- mm->free_list = kmalloc_array(mm->max_order + 1,
- sizeof(struct list_head),
- GFP_KERNEL);
- if (!mm->free_list)
- return -ENOMEM;
-
- for (i = 0; i <= mm->max_order; ++i)
- INIT_LIST_HEAD(&mm->free_list[i]);
-
- mm->n_roots = hweight64(size);
-
- mm->roots = kmalloc_array(mm->n_roots,
- sizeof(struct i915_buddy_block *),
- GFP_KERNEL);
- if (!mm->roots)
- goto out_free_list;
-
- offset = 0;
- i = 0;
-
- /*
- * Split into power-of-two blocks, in case we are given a size that is
- * not itself a power-of-two.
- */
- do {
- struct i915_buddy_block *root;
- unsigned int order;
- u64 root_size;
-
- root_size = rounddown_pow_of_two(size);
- order = ilog2(root_size) - ilog2(chunk_size);
-
- root = i915_block_alloc(mm, NULL, order, offset);
- if (!root)
- goto out_free_roots;
-
- mark_free(mm, root);
-
- GEM_BUG_ON(i > mm->max_order);
- GEM_BUG_ON(i915_buddy_block_size(mm, root) < chunk_size);
-
- mm->roots[i] = root;
-
- offset += root_size;
- size -= root_size;
- i++;
- } while (size);
-
- return 0;
-
-out_free_roots:
- while (i--)
- i915_block_free(mm, mm->roots[i]);
- kfree(mm->roots);
-out_free_list:
- kfree(mm->free_list);
- return -ENOMEM;
-}
-
-void i915_buddy_fini(struct i915_buddy_mm *mm)
-{
- int i;
-
- for (i = 0; i < mm->n_roots; ++i) {
- GEM_WARN_ON(!i915_buddy_block_is_free(mm->roots[i]));
- i915_block_free(mm, mm->roots[i]);
- }
-
- GEM_WARN_ON(mm->avail != mm->size);
-
- kfree(mm->roots);
- kfree(mm->free_list);
-}
-
-static int split_block(struct i915_buddy_mm *mm,
- struct i915_buddy_block *block)
-{
- unsigned int block_order = i915_buddy_block_order(block) - 1;
- u64 offset = i915_buddy_block_offset(block);
-
- GEM_BUG_ON(!i915_buddy_block_is_free(block));
- GEM_BUG_ON(!i915_buddy_block_order(block));
-
- block->left = i915_block_alloc(mm, block, block_order, offset);
- if (!block->left)
- return -ENOMEM;
-
- block->right = i915_block_alloc(mm, block, block_order,
- offset + (mm->chunk_size << block_order));
- if (!block->right) {
- i915_block_free(mm, block->left);
- return -ENOMEM;
- }
-
- mark_free(mm, block->left);
- mark_free(mm, block->right);
-
- mark_split(block);
-
- return 0;
-}
-
-static struct i915_buddy_block *
-get_buddy(struct i915_buddy_block *block)
-{
- struct i915_buddy_block *parent;
-
- parent = block->parent;
- if (!parent)
- return NULL;
-
- if (parent->left == block)
- return parent->right;
-
- return parent->left;
-}
-
-static void __i915_buddy_free(struct i915_buddy_mm *mm,
- struct i915_buddy_block *block)
-{
- struct i915_buddy_block *parent;
-
- while ((parent = block->parent)) {
- struct i915_buddy_block *buddy;
-
- buddy = get_buddy(block);
-
- if (!i915_buddy_block_is_free(buddy))
- break;
-
- list_del(&buddy->link);
-
- i915_block_free(mm, block);
- i915_block_free(mm, buddy);
-
- block = parent;
- }
-
- mark_free(mm, block);
-}
-
-void i915_buddy_free(struct i915_buddy_mm *mm,
- struct i915_buddy_block *block)
-{
- GEM_BUG_ON(!i915_buddy_block_is_allocated(block));
- mm->avail += i915_buddy_block_size(mm, block);
- __i915_buddy_free(mm, block);
-}
-
-void i915_buddy_free_list(struct i915_buddy_mm *mm, struct list_head *objects)
-{
- struct i915_buddy_block *block, *on;
-
- list_for_each_entry_safe(block, on, objects, link) {
- i915_buddy_free(mm, block);
- cond_resched();
- }
- INIT_LIST_HEAD(objects);
-}
-
-/*
- * Allocate power-of-two block. The order value here translates to:
- *
- * 0 = 2^0 * mm->chunk_size
- * 1 = 2^1 * mm->chunk_size
- * 2 = 2^2 * mm->chunk_size
- * ...
- */
-struct i915_buddy_block *
-i915_buddy_alloc(struct i915_buddy_mm *mm, unsigned int order)
-{
- struct i915_buddy_block *block = NULL;
- unsigned int i;
- int err;
-
- for (i = order; i <= mm->max_order; ++i) {
- block = list_first_entry_or_null(&mm->free_list[i],
- struct i915_buddy_block,
- link);
- if (block)
- break;
- }
-
- if (!block)
- return ERR_PTR(-ENOSPC);
-
- GEM_BUG_ON(!i915_buddy_block_is_free(block));
-
- while (i != order) {
- err = split_block(mm, block);
- if (unlikely(err))
- goto out_free;
-
- /* Go low */
- block = block->left;
- i--;
- }
-
- mark_allocated(block);
- mm->avail -= i915_buddy_block_size(mm, block);
- kmemleak_update_trace(block);
- return block;
-
-out_free:
- if (i != order)
- __i915_buddy_free(mm, block);
- return ERR_PTR(err);
-}
-
-static inline bool overlaps(u64 s1, u64 e1, u64 s2, u64 e2)
-{
- return s1 <= e2 && e1 >= s2;
-}
-
-static inline bool contains(u64 s1, u64 e1, u64 s2, u64 e2)
-{
- return s1 <= s2 && e1 >= e2;
-}
-
-/*
- * Allocate range. Note that it's safe to chain together multiple alloc_ranges
- * with the same blocks list.
- *
- * Intended for pre-allocating portions of the address space, for example to
- * reserve a block for the initial framebuffer or similar, hence the expectation
- * here is that i915_buddy_alloc() is still the main vehicle for
- * allocations, so if that's not the case then the drm_mm range allocator is
- * probably a much better fit, and so you should probably go use that instead.
- */
-int i915_buddy_alloc_range(struct i915_buddy_mm *mm,
- struct list_head *blocks,
- u64 start, u64 size)
-{
- struct i915_buddy_block *block;
- struct i915_buddy_block *buddy;
- LIST_HEAD(allocated);
- LIST_HEAD(dfs);
- u64 end;
- int err;
- int i;
-
- if (size < mm->chunk_size)
- return -EINVAL;
-
- if (!IS_ALIGNED(size | start, mm->chunk_size))
- return -EINVAL;
-
- if (range_overflows(start, size, mm->size))
- return -EINVAL;
-
- for (i = 0; i < mm->n_roots; ++i)
- list_add_tail(&mm->roots[i]->tmp_link, &dfs);
-
- end = start + size - 1;
-
- do {
- u64 block_start;
- u64 block_end;
-
- block = list_first_entry_or_null(&dfs,
- struct i915_buddy_block,
- tmp_link);
- if (!block)
- break;
-
- list_del(&block->tmp_link);
-
- block_start = i915_buddy_block_offset(block);
- block_end = block_start + i915_buddy_block_size(mm, block) - 1;
-
- if (!overlaps(start, end, block_start, block_end))
- continue;
-
- if (i915_buddy_block_is_allocated(block)) {
- err = -ENOSPC;
- goto err_free;
- }
-
- if (contains(start, end, block_start, block_end)) {
- if (!i915_buddy_block_is_free(block)) {
- err = -ENOSPC;
- goto err_free;
- }
-
- mark_allocated(block);
- mm->avail -= i915_buddy_block_size(mm, block);
- list_add_tail(&block->link, &allocated);
- continue;
- }
-
- if (!i915_buddy_block_is_split(block)) {
- err = split_block(mm, block);
- if (unlikely(err))
- goto err_undo;
- }
-
- list_add(&block->right->tmp_link, &dfs);
- list_add(&block->left->tmp_link, &dfs);
- } while (1);
-
- list_splice_tail(&allocated, blocks);
- return 0;
-
-err_undo:
- /*
- * We really don't want to leave around a bunch of split blocks, since
- * bigger is better, so make sure we merge everything back before we
- * free the allocated blocks.
- */
- buddy = get_buddy(block);
- if (buddy &&
- (i915_buddy_block_is_free(block) &&
- i915_buddy_block_is_free(buddy)))
- __i915_buddy_free(mm, block);
-
-err_free:
- i915_buddy_free_list(mm, &allocated);
- return err;
-}
-
-void i915_buddy_block_print(struct i915_buddy_mm *mm,
- struct i915_buddy_block *block,
- struct drm_printer *p)
-{
- u64 start = i915_buddy_block_offset(block);
- u64 size = i915_buddy_block_size(mm, block);
-
- drm_printf(p, "%#018llx-%#018llx: %llu\n", start, start + size, size);
-}
-
-void i915_buddy_print(struct i915_buddy_mm *mm, struct drm_printer *p)
-{
- int order;
-
- drm_printf(p, "chunk_size: %lluKiB, total: %lluMiB, free: %lluMiB\n",
- mm->chunk_size >> 10, mm->size >> 20, mm->avail >> 20);
-
- for (order = mm->max_order; order >= 0; order--) {
- struct i915_buddy_block *block;
- u64 count = 0, free;
-
- list_for_each_entry(block, &mm->free_list[order], link) {
- GEM_BUG_ON(!i915_buddy_block_is_free(block));
- count++;
- }
-
- drm_printf(p, "order-%d ", order);
-
- free = count * (mm->chunk_size << order);
- if (free < SZ_1M)
- drm_printf(p, "free: %lluKiB", free >> 10);
- else
- drm_printf(p, "free: %lluMiB", free >> 20);
-
- drm_printf(p, ", pages: %llu\n", count);
- }
-}
-
-#if IS_ENABLED(CONFIG_DRM_I915_SELFTEST)
-#include "selftests/i915_buddy.c"
-#endif
-
-void i915_buddy_module_exit(void)
-{
- kmem_cache_destroy(slab_blocks);
-}
-
-int __init i915_buddy_module_init(void)
-{
- slab_blocks = KMEM_CACHE(i915_buddy_block, 0);
- if (!slab_blocks)
- return -ENOMEM;
-
- return 0;
-}
diff --git a/drivers/gpu/drm/i915/i915_buddy.h b/drivers/gpu/drm/i915/i915_buddy.h
deleted file mode 100644
index 7077742112ac..000000000000
--- a/drivers/gpu/drm/i915/i915_buddy.h
+++ /dev/null
@@ -1,143 +0,0 @@
-/* SPDX-License-Identifier: MIT */
-/*
- * Copyright © 2021 Intel Corporation
- */
-
-#ifndef __I915_BUDDY_H__
-#define __I915_BUDDY_H__
-
-#include <linux/bitops.h>
-#include <linux/list.h>
-#include <linux/slab.h>
-
-#include <drm/drm_print.h>
-
-struct i915_buddy_block {
-#define I915_BUDDY_HEADER_OFFSET GENMASK_ULL(63, 12)
-#define I915_BUDDY_HEADER_STATE GENMASK_ULL(11, 10)
-#define I915_BUDDY_ALLOCATED (1 << 10)
-#define I915_BUDDY_FREE (2 << 10)
-#define I915_BUDDY_SPLIT (3 << 10)
-/* Free to be used, if needed in the future */
-#define I915_BUDDY_HEADER_UNUSED GENMASK_ULL(9, 6)
-#define I915_BUDDY_HEADER_ORDER GENMASK_ULL(5, 0)
- u64 header;
-
- struct i915_buddy_block *left;
- struct i915_buddy_block *right;
- struct i915_buddy_block *parent;
-
- void *private; /* owned by creator */
-
- /*
- * While the block is allocated by the user through i915_buddy_alloc*,
- * the user has ownership of the link, for example to maintain within
- * a list, if so desired. As soon as the block is freed with
- * i915_buddy_free* ownership is given back to the mm.
- */
- struct list_head link;
- struct list_head tmp_link;
-};
-
-/* Order-zero must be at least PAGE_SIZE */
-#define I915_BUDDY_MAX_ORDER (63 - PAGE_SHIFT)
-
-/*
- * Binary Buddy System.
- *
- * Locking should be handled by the user, a simple mutex around
- * i915_buddy_alloc* and i915_buddy_free* should suffice.
- */
-struct i915_buddy_mm {
- /* Maintain a free list for each order. */
- struct list_head *free_list;
-
- /*
- * Maintain explicit binary tree(s) to track the allocation of the
- * address space. This gives us a simple way of finding a buddy block
- * and performing the potentially recursive merge step when freeing a
- * block. Nodes are either allocated or free, in which case they will
- * also exist on the respective free list.
- */
- struct i915_buddy_block **roots;
-
- /*
- * Anything from here is public, and remains static for the lifetime of
- * the mm. Everything above is considered do-not-touch.
- */
- unsigned int n_roots;
- unsigned int max_order;
-
- /* Must be at least PAGE_SIZE */
- u64 chunk_size;
- u64 size;
- u64 avail;
-};
-
-static inline u64
-i915_buddy_block_offset(struct i915_buddy_block *block)
-{
- return block->header & I915_BUDDY_HEADER_OFFSET;
-}
-
-static inline unsigned int
-i915_buddy_block_order(struct i915_buddy_block *block)
-{
- return block->header & I915_BUDDY_HEADER_ORDER;
-}
-
-static inline unsigned int
-i915_buddy_block_state(struct i915_buddy_block *block)
-{
- return block->header & I915_BUDDY_HEADER_STATE;
-}
-
-static inline bool
-i915_buddy_block_is_allocated(struct i915_buddy_block *block)
-{
- return i915_buddy_block_state(block) == I915_BUDDY_ALLOCATED;
-}
-
-static inline bool
-i915_buddy_block_is_free(struct i915_buddy_block *block)
-{
- return i915_buddy_block_state(block) == I915_BUDDY_FREE;
-}
-
-static inline bool
-i915_buddy_block_is_split(struct i915_buddy_block *block)
-{
- return i915_buddy_block_state(block) == I915_BUDDY_SPLIT;
-}
-
-static inline u64
-i915_buddy_block_size(struct i915_buddy_mm *mm,
- struct i915_buddy_block *block)
-{
- return mm->chunk_size << i915_buddy_block_order(block);
-}
-
-int i915_buddy_init(struct i915_buddy_mm *mm, u64 size, u64 chunk_size);
-
-void i915_buddy_fini(struct i915_buddy_mm *mm);
-
-struct i915_buddy_block *
-i915_buddy_alloc(struct i915_buddy_mm *mm, unsigned int order);
-
-int i915_buddy_alloc_range(struct i915_buddy_mm *mm,
- struct list_head *blocks,
- u64 start, u64 size);
-
-void i915_buddy_free(struct i915_buddy_mm *mm, struct i915_buddy_block *block);
-
-void i915_buddy_free_list(struct i915_buddy_mm *mm, struct list_head *objects);
-
-void i915_buddy_print(struct i915_buddy_mm *mm, struct drm_printer *p);
-void i915_buddy_block_print(struct i915_buddy_mm *mm,
- struct i915_buddy_block *block,
- struct drm_printer *p);
-
-void i915_buddy_module_exit(void);
-int i915_buddy_module_init(void);
-
-#endif
diff --git a/drivers/gpu/drm/i915/i915_module.c b/drivers/gpu/drm/i915/i915_module.c
index c7507266aa83..355681dbd7a8 100644
--- a/drivers/gpu/drm/i915/i915_module.c
+++ b/drivers/gpu/drm/i915/i915_module.c
@@ -9,7 +9,6 @@
#include "gem/i915_gem_context.h"
#include "gem/i915_gem_object.h"
#include "i915_active.h"
-#include "i915_buddy.h"
#include "i915_params.h"
#include "i915_pci.h"
#include "i915_perf.h"
@@ -50,8 +49,6 @@ static const struct {
{ .init = i915_check_nomodeset },
{ .init = i915_active_module_init,
.exit = i915_active_module_exit },
- { .init = i915_buddy_module_init,
- .exit = i915_buddy_module_exit },
{ .init = i915_context_module_init,
.exit = i915_context_module_exit },
{ .init = i915_gem_context_module_init,
diff --git a/drivers/gpu/drm/i915/i915_scatterlist.c b/drivers/gpu/drm/i915/i915_scatterlist.c
index 4a6712dca838..84d622aa32d2 100644
--- a/drivers/gpu/drm/i915/i915_scatterlist.c
+++ b/drivers/gpu/drm/i915/i915_scatterlist.c
@@ -5,10 +5,9 @@
*/
#include "i915_scatterlist.h"
-
-#include "i915_buddy.h"
#include "i915_ttm_buddy_manager.h"
+#include <drm/drm_buddy.h>
#include <drm/drm_mm.h>
#include <linux/slab.h>
@@ -126,9 +125,9 @@ struct sg_table *i915_sg_from_buddy_resource(struct ttm_resource *res,
struct i915_ttm_buddy_resource *bman_res = to_ttm_buddy_resource(res);
const u64 size = res->num_pages << PAGE_SHIFT;
const u64 max_segment = rounddown(UINT_MAX, PAGE_SIZE);
- struct i915_buddy_mm *mm = bman_res->mm;
+ struct drm_buddy_mm *mm = bman_res->mm;
struct list_head *blocks = &bman_res->blocks;
- struct i915_buddy_block *block;
+ struct drm_buddy_block *block;
struct scatterlist *sg;
struct sg_table *st;
resource_size_t prev_end;
@@ -151,8 +150,8 @@ struct sg_table *i915_sg_from_buddy_resource(struct ttm_resource *res,
list_for_each_entry(block, blocks, link) {
u64 block_size, offset;
- block_size = min_t(u64, size, i915_buddy_block_size(mm, block));
- offset = i915_buddy_block_offset(block);
+ block_size = min_t(u64, size, drm_buddy_block_size(mm, block));
+ offset = drm_buddy_block_offset(block);
while (block_size) {
u64 len;
diff --git a/drivers/gpu/drm/i915/i915_ttm_buddy_manager.c b/drivers/gpu/drm/i915/i915_ttm_buddy_manager.c
index d59fbb019032..c4b70cb8c248 100644
--- a/drivers/gpu/drm/i915/i915_ttm_buddy_manager.c
+++ b/drivers/gpu/drm/i915/i915_ttm_buddy_manager.c
@@ -8,14 +8,15 @@
#include <drm/ttm/ttm_bo_driver.h>
#include <drm/ttm/ttm_placement.h>
+#include <drm/drm_buddy.h>
+
#include "i915_ttm_buddy_manager.h"
-#include "i915_buddy.h"
#include "i915_gem.h"
struct i915_ttm_buddy_manager {
struct ttm_resource_manager manager;
- struct i915_buddy_mm mm;
+ struct drm_buddy_mm mm;
struct list_head reserved;
struct mutex lock;
u64 default_page_size;
@@ -34,7 +35,7 @@ static int i915_ttm_buddy_man_alloc(struct ttm_resource_manager *man,
{
struct i915_ttm_buddy_manager *bman = to_buddy_manager(man);
struct i915_ttm_buddy_resource *bman_res;
- struct i915_buddy_mm *mm = &bman->mm;
+ struct drm_buddy_mm *mm = &bman->mm;
unsigned long n_pages;
unsigned int min_order;
u64 min_page_size;
@@ -73,7 +74,7 @@ static int i915_ttm_buddy_man_alloc(struct ttm_resource_manager *man,
n_pages = size >> ilog2(mm->chunk_size);
do {
- struct i915_buddy_block *block;
+ struct drm_buddy_block *block;
unsigned int order;
order = fls(n_pages) - 1;
@@ -82,7 +83,7 @@ static int i915_ttm_buddy_man_alloc(struct ttm_resource_manager *man,
do {
mutex_lock(&bman->lock);
- block = i915_buddy_alloc(mm, order);
+ block = drm_buddy_alloc(mm, order);
mutex_unlock(&bman->lock);
if (!IS_ERR(block))
break;
@@ -106,7 +107,7 @@ static int i915_ttm_buddy_man_alloc(struct ttm_resource_manager *man,
err_free_blocks:
mutex_lock(&bman->lock);
- i915_buddy_free_list(mm, &bman_res->blocks);
+ drm_buddy_free_list(mm, &bman_res->blocks);
mutex_unlock(&bman->lock);
err_free_res:
kfree(bman_res);
@@ -120,7 +121,7 @@ static void i915_ttm_buddy_man_free(struct ttm_resource_manager *man,
struct i915_ttm_buddy_manager *bman = to_buddy_manager(man);
mutex_lock(&bman->lock);
- i915_buddy_free_list(&bman->mm, &bman_res->blocks);
+ drm_buddy_free_list(&bman->mm, &bman_res->blocks);
mutex_unlock(&bman->lock);
kfree(bman_res);
@@ -130,17 +131,17 @@ static void i915_ttm_buddy_man_debug(struct ttm_resource_manager *man,
struct drm_printer *printer)
{
struct i915_ttm_buddy_manager *bman = to_buddy_manager(man);
- struct i915_buddy_block *block;
+ struct drm_buddy_block *block;
mutex_lock(&bman->lock);
drm_printf(printer, "default_page_size: %lluKiB\n",
bman->default_page_size >> 10);
- i915_buddy_print(&bman->mm, printer);
+ drm_buddy_print(&bman->mm, printer);
drm_printf(printer, "reserved:\n");
list_for_each_entry(block, &bman->reserved, link)
- i915_buddy_block_print(&bman->mm, block, printer);
+ drm_buddy_block_print(&bman->mm, block, printer);
mutex_unlock(&bman->lock);
}
@@ -190,7 +191,7 @@ int i915_ttm_buddy_man_init(struct ttm_device *bdev,
if (!bman)
return -ENOMEM;
- err = i915_buddy_init(&bman->mm, size, chunk_size);
+ err = drm_buddy_init(&bman->mm, size, chunk_size);
if (err)
goto err_free_bman;
@@ -228,7 +229,7 @@ int i915_ttm_buddy_man_fini(struct ttm_device *bdev, unsigned int type)
{
struct ttm_resource_manager *man = ttm_manager_type(bdev, type);
struct i915_ttm_buddy_manager *bman = to_buddy_manager(man);
- struct i915_buddy_mm *mm = &bman->mm;
+ struct drm_buddy_mm *mm = &bman->mm;
int ret;
ttm_resource_manager_set_used(man, false);
@@ -240,8 +241,8 @@ int i915_ttm_buddy_man_fini(struct ttm_device *bdev, unsigned int type)
ttm_set_driver_manager(bdev, type, NULL);
mutex_lock(&bman->lock);
- i915_buddy_free_list(mm, &bman->reserved);
- i915_buddy_fini(mm);
+ drm_buddy_free_list(mm, &bman->reserved);
+ drm_buddy_fini(mm);
mutex_unlock(&bman->lock);
ttm_resource_manager_cleanup(man);
@@ -264,11 +265,11 @@ int i915_ttm_buddy_man_reserve(struct ttm_resource_manager *man,
u64 start, u64 size)
{
struct i915_ttm_buddy_manager *bman = to_buddy_manager(man);
- struct i915_buddy_mm *mm = &bman->mm;
+ struct drm_buddy_mm *mm = &bman->mm;
int ret;
mutex_lock(&bman->lock);
- ret = i915_buddy_alloc_range(mm, &bman->reserved, start, size);
+ ret = drm_buddy_alloc_range(mm, &bman->reserved, start, size);
mutex_unlock(&bman->lock);
return ret;
diff --git a/drivers/gpu/drm/i915/i915_ttm_buddy_manager.h b/drivers/gpu/drm/i915/i915_ttm_buddy_manager.h
index 0722d33f3e14..fa644b512c2e 100644
--- a/drivers/gpu/drm/i915/i915_ttm_buddy_manager.h
+++ b/drivers/gpu/drm/i915/i915_ttm_buddy_manager.h
@@ -13,7 +13,7 @@
struct ttm_device;
struct ttm_resource_manager;
-struct i915_buddy_mm;
+struct drm_buddy_mm;
/**
* struct i915_ttm_buddy_resource
@@ -28,7 +28,7 @@ struct i915_buddy_mm;
struct i915_ttm_buddy_resource {
struct ttm_resource base;
struct list_head blocks;
- struct i915_buddy_mm *mm;
+ struct drm_buddy_mm *mm;
};
/**
diff --git a/include/drm/drm_buddy.h b/include/drm/drm_buddy.h
new file mode 100644
index 000000000000..5ce3fc702f80
--- /dev/null
+++ b/include/drm/drm_buddy.h
@@ -0,0 +1,153 @@
+/* SPDX-License-Identifier: MIT */
+/*
+ * Copyright © 2021 Intel Corporation
+ */
+
+#ifndef __DRM_BUDDY_H__
+#define __DRM_BUDDY_H__
+
+#include <linux/bitops.h>
+#include <linux/list.h>
+#include <linux/slab.h>
+#include <linux/sched.h>
+
+#include <drm/drm_print.h>
+
+#define range_overflows(start, size, max) ({ \
+ typeof(start) start__ = (start); \
+ typeof(size) size__ = (size); \
+ typeof(max) max__ = (max); \
+ (void)(&start__ == &size__); \
+ (void)(&start__ == &max__); \
+ start__ >= max__ || size__ > max__ - start__; \
+})
+
+struct drm_buddy_block {
+#define DRM_BUDDY_HEADER_OFFSET GENMASK_ULL(63, 12)
+#define DRM_BUDDY_HEADER_STATE GENMASK_ULL(11, 10)
+#define DRM_BUDDY_ALLOCATED (1 << 10)
+#define DRM_BUDDY_FREE (2 << 10)
+#define DRM_BUDDY_SPLIT (3 << 10)
+/* Free to be used, if needed in the future */
+#define DRM_BUDDY_HEADER_UNUSED GENMASK_ULL(9, 6)
+#define DRM_BUDDY_HEADER_ORDER GENMASK_ULL(5, 0)
+ u64 header;
+
+ struct drm_buddy_block *left;
+ struct drm_buddy_block *right;
+ struct drm_buddy_block *parent;
+
+ void *private; /* owned by creator */
+
+ /*
+ * While the block is allocated by the user through drm_buddy_alloc*,
+ * the user has ownership of the link, for example to maintain within
+ * a list, if so desired. As soon as the block is freed with
+ * drm_buddy_free* ownership is given back to the mm.
+ */
+ struct list_head link;
+ struct list_head tmp_link;
+};
+
+/* Order-zero must be at least PAGE_SIZE */
+#define DRM_BUDDY_MAX_ORDER (63 - PAGE_SHIFT)
+
+/*
+ * Binary Buddy System.
+ *
+ * Locking should be handled by the user, a simple mutex around
+ * drm_buddy_alloc* and drm_buddy_free* should suffice.
+ */
+struct drm_buddy_mm {
+ /* Maintain a free list for each order. */
+ struct list_head *free_list;
+
+ /*
+ * Maintain explicit binary tree(s) to track the allocation of the
+ * address space. This gives us a simple way of finding a buddy block
+ * and performing the potentially recursive merge step when freeing a
+ * block. Nodes are either allocated or free, in which case they will
+ * also exist on the respective free list.
+ */
+ struct drm_buddy_block **roots;
+
+ /*
+ * Anything from here is public, and remains static for the lifetime of
+ * the mm. Everything above is considered do-not-touch.
+ */
+ unsigned int n_roots;
+ unsigned int max_order;
+
+ /* Must be at least PAGE_SIZE */
+ u64 chunk_size;
+ u64 size;
+ u64 avail;
+};
+
+static inline u64
+drm_buddy_block_offset(struct drm_buddy_block *block)
+{
+ return block->header & DRM_BUDDY_HEADER_OFFSET;
+}
+
+static inline unsigned int
+drm_buddy_block_order(struct drm_buddy_block *block)
+{
+ return block->header & DRM_BUDDY_HEADER_ORDER;
+}
+
+static inline unsigned int
+drm_buddy_block_state(struct drm_buddy_block *block)
+{
+ return block->header & DRM_BUDDY_HEADER_STATE;
+}
+
+static inline bool
+drm_buddy_block_is_allocated(struct drm_buddy_block *block)
+{
+ return drm_buddy_block_state(block) == DRM_BUDDY_ALLOCATED;
+}
+
+static inline bool
+drm_buddy_block_is_free(struct drm_buddy_block *block)
+{
+ return drm_buddy_block_state(block) == DRM_BUDDY_FREE;
+}
+
+static inline bool
+drm_buddy_block_is_split(struct drm_buddy_block *block)
+{
+ return drm_buddy_block_state(block) == DRM_BUDDY_SPLIT;
+}
+
+static inline u64
+drm_buddy_block_size(struct drm_buddy_mm *mm,
+ struct drm_buddy_block *block)
+{
+ return mm->chunk_size << drm_buddy_block_order(block);
+}
+
+int drm_buddy_init(struct drm_buddy_mm *mm, u64 size, u64 chunk_size);
+
+void drm_buddy_fini(struct drm_buddy_mm *mm);
+
+struct drm_buddy_block *
+drm_buddy_alloc(struct drm_buddy_mm *mm, unsigned int order);
+
+int drm_buddy_alloc_range(struct drm_buddy_mm *mm,
+ struct list_head *blocks,
+ u64 start, u64 size);
+
+void drm_buddy_free(struct drm_buddy_mm *mm, struct drm_buddy_block *block);
+
+void drm_buddy_free_list(struct drm_buddy_mm *mm, struct list_head *objects);
+
+void drm_buddy_print(struct drm_buddy_mm *mm, struct drm_printer *p);
+void drm_buddy_block_print(struct drm_buddy_mm *mm,
+ struct drm_buddy_block *block,
+ struct drm_printer *p);
+
+void drm_buddy_module_exit(void);
+int drm_buddy_module_init(void);
+
+#endif
--
2.25.1
^ permalink raw reply related [flat|nested] 46+ messages in thread
* [PATCH v3 1/6] drm: move the buddy allocator from i915 into common drm
@ 2021-11-16 20:18 ` Arunpravin
0 siblings, 0 replies; 46+ messages in thread
From: Arunpravin @ 2021-11-16 20:18 UTC (permalink / raw)
To: dri-devel, intel-gfx, amd-gfx
Cc: daniel, Arunpravin, jani.nikula, matthew.auld, tzimmermann,
alexander.deucher, christian.koenig
Move the base i915 buddy allocator code into drm
- Move i915_buddy.h to include/drm
- Move i915_buddy.c to drm root folder
- Rename "i915" string with "drm" string wherever applicable
- Rename "I915" string with "DRM" string wherever applicable
- Fix header file dependencies
- Fix alignment issues
- add Makefile support for drm buddy
- export functions and write kerneldoc description
- Remove i915 selftest config check condition as buddy selftest
will be moved to drm selftest folder
cleanup i915 buddy references in i915 driver module
and replace with drm buddy
v2:
- include header file in alphabetical order (Thomas)
- merged changes listed in the body section into a single patch
to keep the build intact (Christian, Jani)
Signed-off-by: Arunpravin <Arunpravin.PaneerSelvam@amd.com>
---
drivers/gpu/drm/Makefile | 2 +-
drivers/gpu/drm/drm_buddy.c | 521 ++++++++++++++++++
drivers/gpu/drm/drm_drv.c | 3 +
drivers/gpu/drm/i915/Makefile | 1 -
drivers/gpu/drm/i915/i915_buddy.c | 466 ----------------
drivers/gpu/drm/i915/i915_buddy.h | 143 -----
drivers/gpu/drm/i915/i915_module.c | 3 -
drivers/gpu/drm/i915/i915_scatterlist.c | 11 +-
drivers/gpu/drm/i915/i915_ttm_buddy_manager.c | 33 +-
drivers/gpu/drm/i915/i915_ttm_buddy_manager.h | 4 +-
include/drm/drm_buddy.h | 153 +++++
11 files changed, 702 insertions(+), 638 deletions(-)
create mode 100644 drivers/gpu/drm/drm_buddy.c
delete mode 100644 drivers/gpu/drm/i915/i915_buddy.c
delete mode 100644 drivers/gpu/drm/i915/i915_buddy.h
create mode 100644 include/drm/drm_buddy.h
diff --git a/drivers/gpu/drm/Makefile b/drivers/gpu/drm/Makefile
index 0dff40bb863c..dc61e91a3154 100644
--- a/drivers/gpu/drm/Makefile
+++ b/drivers/gpu/drm/Makefile
@@ -18,7 +18,7 @@ drm-y := drm_aperture.o drm_auth.o drm_cache.o \
drm_dumb_buffers.o drm_mode_config.o drm_vblank.o \
drm_syncobj.o drm_lease.o drm_writeback.o drm_client.o \
drm_client_modeset.o drm_atomic_uapi.o drm_hdcp.o \
- drm_managed.o drm_vblank_work.o
+ drm_managed.o drm_vblank_work.o drm_buddy.o
drm-$(CONFIG_DRM_LEGACY) += drm_agpsupport.o drm_bufs.o drm_context.o drm_dma.o \
drm_legacy_misc.o drm_lock.o drm_memory.o drm_scatter.o \
diff --git a/drivers/gpu/drm/drm_buddy.c b/drivers/gpu/drm/drm_buddy.c
new file mode 100644
index 000000000000..39eb1d224bec
--- /dev/null
+++ b/drivers/gpu/drm/drm_buddy.c
@@ -0,0 +1,521 @@
+// SPDX-License-Identifier: MIT
+/*
+ * Copyright © 2021 Intel Corporation
+ */
+
+#include <linux/kmemleak.h>
+#include <linux/sizes.h>
+
+#include <drm/drm_buddy.h>
+
+static struct kmem_cache *slab_blocks;
+
+static struct drm_buddy_block *drm_block_alloc(struct drm_buddy_mm *mm,
+ struct drm_buddy_block *parent,
+ unsigned int order,
+ u64 offset)
+{
+ struct drm_buddy_block *block;
+
+ BUG_ON(order > DRM_BUDDY_MAX_ORDER);
+
+ block = kmem_cache_zalloc(slab_blocks, GFP_KERNEL);
+ if (!block)
+ return NULL;
+
+ block->header = offset;
+ block->header |= order;
+ block->parent = parent;
+
+ BUG_ON(block->header & DRM_BUDDY_HEADER_UNUSED);
+ return block;
+}
+
+static void drm_block_free(struct drm_buddy_mm *mm,
+ struct drm_buddy_block *block)
+{
+ kmem_cache_free(slab_blocks, block);
+}
+
+static void mark_allocated(struct drm_buddy_block *block)
+{
+ block->header &= ~DRM_BUDDY_HEADER_STATE;
+ block->header |= DRM_BUDDY_ALLOCATED;
+
+ list_del(&block->link);
+}
+
+static void mark_free(struct drm_buddy_mm *mm,
+ struct drm_buddy_block *block)
+{
+ block->header &= ~DRM_BUDDY_HEADER_STATE;
+ block->header |= DRM_BUDDY_FREE;
+
+ list_add(&block->link,
+ &mm->free_list[drm_buddy_block_order(block)]);
+}
+
+static void mark_split(struct drm_buddy_block *block)
+{
+ block->header &= ~DRM_BUDDY_HEADER_STATE;
+ block->header |= DRM_BUDDY_SPLIT;
+
+ list_del(&block->link);
+}
+
+/**
+ * drm_buddy_init - init memory manager
+ *
+ * @mm: DRM buddy manager to initialize
+ * @size: size in bytes to manage
+ * @chunk_size: minimum page size in bytes for our allocations
+ *
+ * Initializes the memory manager and its resources.
+ *
+ * Returns:
+ * 0 on success, error code on failure.
+ */
+int drm_buddy_init(struct drm_buddy_mm *mm, u64 size, u64 chunk_size)
+{
+ unsigned int i;
+ u64 offset;
+
+ if (size < chunk_size)
+ return -EINVAL;
+
+ if (chunk_size < PAGE_SIZE)
+ return -EINVAL;
+
+ if (!is_power_of_2(chunk_size))
+ return -EINVAL;
+
+ size = round_down(size, chunk_size);
+
+ mm->size = size;
+ mm->avail = size;
+ mm->chunk_size = chunk_size;
+ mm->max_order = ilog2(size) - ilog2(chunk_size);
+
+ BUG_ON(mm->max_order > DRM_BUDDY_MAX_ORDER);
+
+ mm->free_list = kmalloc_array(mm->max_order + 1,
+ sizeof(struct list_head),
+ GFP_KERNEL);
+ if (!mm->free_list)
+ return -ENOMEM;
+
+ for (i = 0; i <= mm->max_order; ++i)
+ INIT_LIST_HEAD(&mm->free_list[i]);
+
+ mm->n_roots = hweight64(size);
+
+ mm->roots = kmalloc_array(mm->n_roots,
+ sizeof(struct drm_buddy_block *),
+ GFP_KERNEL);
+ if (!mm->roots)
+ goto out_free_list;
+
+ offset = 0;
+ i = 0;
+
+ /*
+ * Split into power-of-two blocks, in case we are given a size that is
+ * not itself a power-of-two.
+ */
+ do {
+ struct drm_buddy_block *root;
+ unsigned int order;
+ u64 root_size;
+
+ root_size = rounddown_pow_of_two(size);
+ order = ilog2(root_size) - ilog2(chunk_size);
+
+ root = drm_block_alloc(mm, NULL, order, offset);
+ if (!root)
+ goto out_free_roots;
+
+ mark_free(mm, root);
+
+ BUG_ON(i > mm->max_order);
+ BUG_ON(drm_buddy_block_size(mm, root) < chunk_size);
+
+ mm->roots[i] = root;
+
+ offset += root_size;
+ size -= root_size;
+ i++;
+ } while (size);
+
+ return 0;
+
+out_free_roots:
+ while (i--)
+ drm_block_free(mm, mm->roots[i]);
+ kfree(mm->roots);
+out_free_list:
+ kfree(mm->free_list);
+ return -ENOMEM;
+}
+EXPORT_SYMBOL(drm_buddy_init);
+
+/**
+ * drm_buddy_fini - tear down the memory manager
+ *
+ * @mm: DRM buddy manager to free
+ *
+ * Cleanup memory manager resources and the freelist
+ */
+void drm_buddy_fini(struct drm_buddy_mm *mm)
+{
+ int i;
+
+ for (i = 0; i < mm->n_roots; ++i) {
+ WARN_ON(!drm_buddy_block_is_free(mm->roots[i]));
+ drm_block_free(mm, mm->roots[i]);
+ }
+
+ WARN_ON(mm->avail != mm->size);
+
+ kfree(mm->roots);
+ kfree(mm->free_list);
+}
+EXPORT_SYMBOL(drm_buddy_fini);
+
+static int split_block(struct drm_buddy_mm *mm,
+ struct drm_buddy_block *block)
+{
+ unsigned int block_order = drm_buddy_block_order(block) - 1;
+ u64 offset = drm_buddy_block_offset(block);
+
+ BUG_ON(!drm_buddy_block_is_free(block));
+ BUG_ON(!drm_buddy_block_order(block));
+
+ block->left = drm_block_alloc(mm, block, block_order, offset);
+ if (!block->left)
+ return -ENOMEM;
+
+ block->right = drm_block_alloc(mm, block, block_order,
+ offset + (mm->chunk_size << block_order));
+ if (!block->right) {
+ drm_block_free(mm, block->left);
+ return -ENOMEM;
+ }
+
+ mark_free(mm, block->left);
+ mark_free(mm, block->right);
+
+ mark_split(block);
+
+ return 0;
+}
+
+static struct drm_buddy_block *
+get_buddy(struct drm_buddy_block *block)
+{
+ struct drm_buddy_block *parent;
+
+ parent = block->parent;
+ if (!parent)
+ return NULL;
+
+ if (parent->left == block)
+ return parent->right;
+
+ return parent->left;
+}
+
+static void __drm_buddy_free(struct drm_buddy_mm *mm,
+ struct drm_buddy_block *block)
+{
+ struct drm_buddy_block *parent;
+
+ while ((parent = block->parent)) {
+ struct drm_buddy_block *buddy;
+
+ buddy = get_buddy(block);
+
+ if (!drm_buddy_block_is_free(buddy))
+ break;
+
+ list_del(&buddy->link);
+
+ drm_block_free(mm, block);
+ drm_block_free(mm, buddy);
+
+ block = parent;
+ }
+
+ mark_free(mm, block);
+}
+
+void drm_buddy_free(struct drm_buddy_mm *mm,
+ struct drm_buddy_block *block)
+{
+ BUG_ON(!drm_buddy_block_is_allocated(block));
+ mm->avail += drm_buddy_block_size(mm, block);
+ __drm_buddy_free(mm, block);
+}
+
+/**
+ * drm_buddy_free_list - free blocks
+ *
+ * @mm: DRM buddy manager
+ * @objects: input list head to free blocks
+ */
+void drm_buddy_free_list(struct drm_buddy_mm *mm, struct list_head *objects)
+{
+ struct drm_buddy_block *block, *on;
+
+ list_for_each_entry_safe(block, on, objects, link) {
+ drm_buddy_free(mm, block);
+ cond_resched();
+ }
+ INIT_LIST_HEAD(objects);
+}
+EXPORT_SYMBOL(drm_buddy_free_list);
+
+/**
+ * drm_buddy_alloc - allocate power-of-two blocks
+ *
+ * @mm: DRM buddy manager to allocate from
+ * @order: size of the allocation
+ *
+ * The order value here translates to:
+ *
+ * 0 = 2^0 * mm->chunk_size
+ * 1 = 2^1 * mm->chunk_size
+ * 2 = 2^2 * mm->chunk_size
+ *
+ * Returns:
+ * allocated ptr to the &drm_buddy_block on success
+ */
+struct drm_buddy_block *
+drm_buddy_alloc(struct drm_buddy_mm *mm, unsigned int order)
+{
+ struct drm_buddy_block *block = NULL;
+ unsigned int i;
+ int err;
+
+ for (i = order; i <= mm->max_order; ++i) {
+ block = list_first_entry_or_null(&mm->free_list[i],
+ struct drm_buddy_block,
+ link);
+ if (block)
+ break;
+ }
+
+ if (!block)
+ return ERR_PTR(-ENOSPC);
+
+ BUG_ON(!drm_buddy_block_is_free(block));
+
+ while (i != order) {
+ err = split_block(mm, block);
+ if (unlikely(err))
+ goto out_free;
+
+ /* Go low */
+ block = block->left;
+ i--;
+ }
+
+ mark_allocated(block);
+ mm->avail -= drm_buddy_block_size(mm, block);
+ kmemleak_update_trace(block);
+ return block;
+
+out_free:
+ if (i != order)
+ __drm_buddy_free(mm, block);
+ return ERR_PTR(err);
+}
+EXPORT_SYMBOL(drm_buddy_alloc);
+
+static inline bool overlaps(u64 s1, u64 e1, u64 s2, u64 e2)
+{
+ return s1 <= e2 && e1 >= s2;
+}
+
+static inline bool contains(u64 s1, u64 e1, u64 s2, u64 e2)
+{
+ return s1 <= s2 && e1 >= e2;
+}
+
+/**
+ * drm_buddy_alloc_range - allocate range
+ *
+ * @mm: DRM buddy manager to allocate from
+ * @blocks: output list head to add allocated blocks
+ * @start: start of the allowed range for this block
+ * @size: size of the allocation
+ *
+ * Intended for pre-allocating portions of the address space, for example to
+ * reserve a block for the initial framebuffer or similar, hence the expectation
+ * here is that drm_buddy_alloc() is still the main vehicle for
+ * allocations, so if that's not the case then the drm_mm range allocator is
+ * probably a much better fit, and so you should probably go use that instead.
+ *
+ * Note that it's safe to chain together multiple alloc_ranges
+ * with the same blocks list
+ *
+ * Returns:
+ * 0 on success, error code on failure.
+ */
+int drm_buddy_alloc_range(struct drm_buddy_mm *mm,
+ struct list_head *blocks,
+ u64 start, u64 size)
+{
+ struct drm_buddy_block *block;
+ struct drm_buddy_block *buddy;
+ LIST_HEAD(allocated);
+ LIST_HEAD(dfs);
+ u64 end;
+ int err;
+ int i;
+
+ if (size < mm->chunk_size)
+ return -EINVAL;
+
+ if (!IS_ALIGNED(size | start, mm->chunk_size))
+ return -EINVAL;
+
+ if (range_overflows(start, size, mm->size))
+ return -EINVAL;
+
+ for (i = 0; i < mm->n_roots; ++i)
+ list_add_tail(&mm->roots[i]->tmp_link, &dfs);
+
+ end = start + size - 1;
+
+ do {
+ u64 block_start;
+ u64 block_end;
+
+ block = list_first_entry_or_null(&dfs,
+ struct drm_buddy_block,
+ tmp_link);
+ if (!block)
+ break;
+
+ list_del(&block->tmp_link);
+
+ block_start = drm_buddy_block_offset(block);
+ block_end = block_start + drm_buddy_block_size(mm, block) - 1;
+
+ if (!overlaps(start, end, block_start, block_end))
+ continue;
+
+ if (drm_buddy_block_is_allocated(block)) {
+ err = -ENOSPC;
+ goto err_free;
+ }
+
+ if (contains(start, end, block_start, block_end)) {
+ if (!drm_buddy_block_is_free(block)) {
+ err = -ENOSPC;
+ goto err_free;
+ }
+
+ mark_allocated(block);
+ mm->avail -= drm_buddy_block_size(mm, block);
+ list_add_tail(&block->link, &allocated);
+ continue;
+ }
+
+ if (!drm_buddy_block_is_split(block)) {
+ err = split_block(mm, block);
+ if (unlikely(err))
+ goto err_undo;
+ }
+
+ list_add(&block->right->tmp_link, &dfs);
+ list_add(&block->left->tmp_link, &dfs);
+ } while (1);
+
+ list_splice_tail(&allocated, blocks);
+ return 0;
+
+err_undo:
+ /*
+ * We really don't want to leave around a bunch of split blocks, since
+ * bigger is better, so make sure we merge everything back before we
+ * free the allocated blocks.
+ */
+ buddy = get_buddy(block);
+ if (buddy &&
+ (drm_buddy_block_is_free(block) &&
+ drm_buddy_block_is_free(buddy)))
+ __drm_buddy_free(mm, block);
+
+err_free:
+ drm_buddy_free_list(mm, &allocated);
+ return err;
+}
+EXPORT_SYMBOL(drm_buddy_alloc_range);
+
+/**
+ * drm_buddy_block_print - print block information
+ *
+ * @mm: DRM buddy manager
+ * @block: DRM buddy block
+ * @p: DRM printer to use
+ */
+void drm_buddy_block_print(struct drm_buddy_mm *mm,
+ struct drm_buddy_block *block,
+ struct drm_printer *p)
+{
+ u64 start = drm_buddy_block_offset(block);
+ u64 size = drm_buddy_block_size(mm, block);
+
+ drm_printf(p, "%#018llx-%#018llx: %llu\n", start, start + size, size);
+}
+EXPORT_SYMBOL(drm_buddy_block_print);
+
+/**
+ * drm_buddy_print - print allocator state
+ *
+ * @mm: DRM buddy manager
+ * @p: DRM printer to use
+ */
+void drm_buddy_print(struct drm_buddy_mm *mm, struct drm_printer *p)
+{
+ int order;
+
+ drm_printf(p, "chunk_size: %lluKiB, total: %lluMiB, free: %lluMiB\n",
+ mm->chunk_size >> 10, mm->size >> 20, mm->avail >> 20);
+
+ for (order = mm->max_order; order >= 0; order--) {
+ struct drm_buddy_block *block;
+ u64 count = 0, free;
+
+ list_for_each_entry(block, &mm->free_list[order], link) {
+ BUG_ON(!drm_buddy_block_is_free(block));
+ count++;
+ }
+
+ drm_printf(p, "order-%d ", order);
+
+ free = count * (mm->chunk_size << order);
+ if (free < SZ_1M)
+ drm_printf(p, "free: %lluKiB", free >> 10);
+ else
+ drm_printf(p, "free: %lluMiB", free >> 20);
+
+ drm_printf(p, ", pages: %llu\n", count);
+ }
+}
+EXPORT_SYMBOL(drm_buddy_print);
+
+void drm_buddy_module_exit(void)
+{
+ kmem_cache_destroy(slab_blocks);
+}
+
+int __init drm_buddy_module_init(void)
+{
+ slab_blocks = KMEM_CACHE(drm_buddy_block, 0);
+ if (!slab_blocks)
+ return -ENOMEM;
+
+ return 0;
+}
diff --git a/drivers/gpu/drm/drm_drv.c b/drivers/gpu/drm/drm_drv.c
index 7a5097467ba5..5d5e46e60586 100644
--- a/drivers/gpu/drm/drm_drv.c
+++ b/drivers/gpu/drm/drm_drv.c
@@ -35,6 +35,7 @@
#include <linux/slab.h>
#include <linux/srcu.h>
+#include <drm/drm_buddy.h>
#include <drm/drm_cache.h>
#include <drm/drm_client.h>
#include <drm/drm_color_mgmt.h>
@@ -1034,6 +1035,7 @@ static void drm_core_exit(void)
drm_sysfs_destroy();
idr_destroy(&drm_minors_idr);
drm_connector_ida_destroy();
+ drm_buddy_module_exit();
}
static int __init drm_core_init(void)
@@ -1043,6 +1045,7 @@ static int __init drm_core_init(void)
drm_connector_ida_init();
idr_init(&drm_minors_idr);
drm_memcpy_init_early();
+ drm_buddy_module_init();
ret = drm_sysfs_init();
if (ret < 0) {
diff --git a/drivers/gpu/drm/i915/Makefile b/drivers/gpu/drm/i915/Makefile
index 467872cca027..fc5ca8c4ccb2 100644
--- a/drivers/gpu/drm/i915/Makefile
+++ b/drivers/gpu/drm/i915/Makefile
@@ -161,7 +161,6 @@ gem-y += \
i915-y += \
$(gem-y) \
i915_active.o \
- i915_buddy.o \
i915_cmd_parser.o \
i915_gem_evict.o \
i915_gem_gtt.o \
diff --git a/drivers/gpu/drm/i915/i915_buddy.c b/drivers/gpu/drm/i915/i915_buddy.c
deleted file mode 100644
index 6e2ad68f8f3f..000000000000
--- a/drivers/gpu/drm/i915/i915_buddy.c
+++ /dev/null
@@ -1,466 +0,0 @@
-// SPDX-License-Identifier: MIT
-/*
- * Copyright © 2021 Intel Corporation
- */
-
-#include <linux/kmemleak.h>
-#include <linux/sizes.h>
-
-#include "i915_buddy.h"
-
-#include "i915_gem.h"
-#include "i915_utils.h"
-
-static struct kmem_cache *slab_blocks;
-
-static struct i915_buddy_block *i915_block_alloc(struct i915_buddy_mm *mm,
- struct i915_buddy_block *parent,
- unsigned int order,
- u64 offset)
-{
- struct i915_buddy_block *block;
-
- GEM_BUG_ON(order > I915_BUDDY_MAX_ORDER);
-
- block = kmem_cache_zalloc(slab_blocks, GFP_KERNEL);
- if (!block)
- return NULL;
-
- block->header = offset;
- block->header |= order;
- block->parent = parent;
-
- GEM_BUG_ON(block->header & I915_BUDDY_HEADER_UNUSED);
- return block;
-}
-
-static void i915_block_free(struct i915_buddy_mm *mm,
- struct i915_buddy_block *block)
-{
- kmem_cache_free(slab_blocks, block);
-}
-
-static void mark_allocated(struct i915_buddy_block *block)
-{
- block->header &= ~I915_BUDDY_HEADER_STATE;
- block->header |= I915_BUDDY_ALLOCATED;
-
- list_del(&block->link);
-}
-
-static void mark_free(struct i915_buddy_mm *mm,
- struct i915_buddy_block *block)
-{
- block->header &= ~I915_BUDDY_HEADER_STATE;
- block->header |= I915_BUDDY_FREE;
-
- list_add(&block->link,
- &mm->free_list[i915_buddy_block_order(block)]);
-}
-
-static void mark_split(struct i915_buddy_block *block)
-{
- block->header &= ~I915_BUDDY_HEADER_STATE;
- block->header |= I915_BUDDY_SPLIT;
-
- list_del(&block->link);
-}
-
-int i915_buddy_init(struct i915_buddy_mm *mm, u64 size, u64 chunk_size)
-{
- unsigned int i;
- u64 offset;
-
- if (size < chunk_size)
- return -EINVAL;
-
- if (chunk_size < PAGE_SIZE)
- return -EINVAL;
-
- if (!is_power_of_2(chunk_size))
- return -EINVAL;
-
- size = round_down(size, chunk_size);
-
- mm->size = size;
- mm->avail = size;
- mm->chunk_size = chunk_size;
- mm->max_order = ilog2(size) - ilog2(chunk_size);
-
- GEM_BUG_ON(mm->max_order > I915_BUDDY_MAX_ORDER);
-
- mm->free_list = kmalloc_array(mm->max_order + 1,
- sizeof(struct list_head),
- GFP_KERNEL);
- if (!mm->free_list)
- return -ENOMEM;
-
- for (i = 0; i <= mm->max_order; ++i)
- INIT_LIST_HEAD(&mm->free_list[i]);
-
- mm->n_roots = hweight64(size);
-
- mm->roots = kmalloc_array(mm->n_roots,
- sizeof(struct i915_buddy_block *),
- GFP_KERNEL);
- if (!mm->roots)
- goto out_free_list;
-
- offset = 0;
- i = 0;
-
- /*
- * Split into power-of-two blocks, in case we are given a size that is
- * not itself a power-of-two.
- */
- do {
- struct i915_buddy_block *root;
- unsigned int order;
- u64 root_size;
-
- root_size = rounddown_pow_of_two(size);
- order = ilog2(root_size) - ilog2(chunk_size);
-
- root = i915_block_alloc(mm, NULL, order, offset);
- if (!root)
- goto out_free_roots;
-
- mark_free(mm, root);
-
- GEM_BUG_ON(i > mm->max_order);
- GEM_BUG_ON(i915_buddy_block_size(mm, root) < chunk_size);
-
- mm->roots[i] = root;
-
- offset += root_size;
- size -= root_size;
- i++;
- } while (size);
-
- return 0;
-
-out_free_roots:
- while (i--)
- i915_block_free(mm, mm->roots[i]);
- kfree(mm->roots);
-out_free_list:
- kfree(mm->free_list);
- return -ENOMEM;
-}
-
-void i915_buddy_fini(struct i915_buddy_mm *mm)
-{
- int i;
-
- for (i = 0; i < mm->n_roots; ++i) {
- GEM_WARN_ON(!i915_buddy_block_is_free(mm->roots[i]));
- i915_block_free(mm, mm->roots[i]);
- }
-
- GEM_WARN_ON(mm->avail != mm->size);
-
- kfree(mm->roots);
- kfree(mm->free_list);
-}
-
-static int split_block(struct i915_buddy_mm *mm,
- struct i915_buddy_block *block)
-{
- unsigned int block_order = i915_buddy_block_order(block) - 1;
- u64 offset = i915_buddy_block_offset(block);
-
- GEM_BUG_ON(!i915_buddy_block_is_free(block));
- GEM_BUG_ON(!i915_buddy_block_order(block));
-
- block->left = i915_block_alloc(mm, block, block_order, offset);
- if (!block->left)
- return -ENOMEM;
-
- block->right = i915_block_alloc(mm, block, block_order,
- offset + (mm->chunk_size << block_order));
- if (!block->right) {
- i915_block_free(mm, block->left);
- return -ENOMEM;
- }
-
- mark_free(mm, block->left);
- mark_free(mm, block->right);
-
- mark_split(block);
-
- return 0;
-}
-
-static struct i915_buddy_block *
-get_buddy(struct i915_buddy_block *block)
-{
- struct i915_buddy_block *parent;
-
- parent = block->parent;
- if (!parent)
- return NULL;
-
- if (parent->left == block)
- return parent->right;
-
- return parent->left;
-}
-
-static void __i915_buddy_free(struct i915_buddy_mm *mm,
- struct i915_buddy_block *block)
-{
- struct i915_buddy_block *parent;
-
- while ((parent = block->parent)) {
- struct i915_buddy_block *buddy;
-
- buddy = get_buddy(block);
-
- if (!i915_buddy_block_is_free(buddy))
- break;
-
- list_del(&buddy->link);
-
- i915_block_free(mm, block);
- i915_block_free(mm, buddy);
-
- block = parent;
- }
-
- mark_free(mm, block);
-}
-
-void i915_buddy_free(struct i915_buddy_mm *mm,
- struct i915_buddy_block *block)
-{
- GEM_BUG_ON(!i915_buddy_block_is_allocated(block));
- mm->avail += i915_buddy_block_size(mm, block);
- __i915_buddy_free(mm, block);
-}
-
-void i915_buddy_free_list(struct i915_buddy_mm *mm, struct list_head *objects)
-{
- struct i915_buddy_block *block, *on;
-
- list_for_each_entry_safe(block, on, objects, link) {
- i915_buddy_free(mm, block);
- cond_resched();
- }
- INIT_LIST_HEAD(objects);
-}
-
-/*
- * Allocate power-of-two block. The order value here translates to:
- *
- * 0 = 2^0 * mm->chunk_size
- * 1 = 2^1 * mm->chunk_size
- * 2 = 2^2 * mm->chunk_size
- * ...
- */
-struct i915_buddy_block *
-i915_buddy_alloc(struct i915_buddy_mm *mm, unsigned int order)
-{
- struct i915_buddy_block *block = NULL;
- unsigned int i;
- int err;
-
- for (i = order; i <= mm->max_order; ++i) {
- block = list_first_entry_or_null(&mm->free_list[i],
- struct i915_buddy_block,
- link);
- if (block)
- break;
- }
-
- if (!block)
- return ERR_PTR(-ENOSPC);
-
- GEM_BUG_ON(!i915_buddy_block_is_free(block));
-
- while (i != order) {
- err = split_block(mm, block);
- if (unlikely(err))
- goto out_free;
-
- /* Go low */
- block = block->left;
- i--;
- }
-
- mark_allocated(block);
- mm->avail -= i915_buddy_block_size(mm, block);
- kmemleak_update_trace(block);
- return block;
-
-out_free:
- if (i != order)
- __i915_buddy_free(mm, block);
- return ERR_PTR(err);
-}
-
-static inline bool overlaps(u64 s1, u64 e1, u64 s2, u64 e2)
-{
- return s1 <= e2 && e1 >= s2;
-}
-
-static inline bool contains(u64 s1, u64 e1, u64 s2, u64 e2)
-{
- return s1 <= s2 && e1 >= e2;
-}
-
-/*
- * Allocate range. Note that it's safe to chain together multiple alloc_ranges
- * with the same blocks list.
- *
- * Intended for pre-allocating portions of the address space, for example to
- * reserve a block for the initial framebuffer or similar, hence the expectation
- * here is that i915_buddy_alloc() is still the main vehicle for
- * allocations, so if that's not the case then the drm_mm range allocator is
- * probably a much better fit, and so you should probably go use that instead.
- */
-int i915_buddy_alloc_range(struct i915_buddy_mm *mm,
- struct list_head *blocks,
- u64 start, u64 size)
-{
- struct i915_buddy_block *block;
- struct i915_buddy_block *buddy;
- LIST_HEAD(allocated);
- LIST_HEAD(dfs);
- u64 end;
- int err;
- int i;
-
- if (size < mm->chunk_size)
- return -EINVAL;
-
- if (!IS_ALIGNED(size | start, mm->chunk_size))
- return -EINVAL;
-
- if (range_overflows(start, size, mm->size))
- return -EINVAL;
-
- for (i = 0; i < mm->n_roots; ++i)
- list_add_tail(&mm->roots[i]->tmp_link, &dfs);
-
- end = start + size - 1;
-
- do {
- u64 block_start;
- u64 block_end;
-
- block = list_first_entry_or_null(&dfs,
- struct i915_buddy_block,
- tmp_link);
- if (!block)
- break;
-
- list_del(&block->tmp_link);
-
- block_start = i915_buddy_block_offset(block);
- block_end = block_start + i915_buddy_block_size(mm, block) - 1;
-
- if (!overlaps(start, end, block_start, block_end))
- continue;
-
- if (i915_buddy_block_is_allocated(block)) {
- err = -ENOSPC;
- goto err_free;
- }
-
- if (contains(start, end, block_start, block_end)) {
- if (!i915_buddy_block_is_free(block)) {
- err = -ENOSPC;
- goto err_free;
- }
-
- mark_allocated(block);
- mm->avail -= i915_buddy_block_size(mm, block);
- list_add_tail(&block->link, &allocated);
- continue;
- }
-
- if (!i915_buddy_block_is_split(block)) {
- err = split_block(mm, block);
- if (unlikely(err))
- goto err_undo;
- }
-
- list_add(&block->right->tmp_link, &dfs);
- list_add(&block->left->tmp_link, &dfs);
- } while (1);
-
- list_splice_tail(&allocated, blocks);
- return 0;
-
-err_undo:
- /*
- * We really don't want to leave around a bunch of split blocks, since
- * bigger is better, so make sure we merge everything back before we
- * free the allocated blocks.
- */
- buddy = get_buddy(block);
- if (buddy &&
- (i915_buddy_block_is_free(block) &&
- i915_buddy_block_is_free(buddy)))
- __i915_buddy_free(mm, block);
-
-err_free:
- i915_buddy_free_list(mm, &allocated);
- return err;
-}
-
-void i915_buddy_block_print(struct i915_buddy_mm *mm,
- struct i915_buddy_block *block,
- struct drm_printer *p)
-{
- u64 start = i915_buddy_block_offset(block);
- u64 size = i915_buddy_block_size(mm, block);
-
- drm_printf(p, "%#018llx-%#018llx: %llu\n", start, start + size, size);
-}
-
-void i915_buddy_print(struct i915_buddy_mm *mm, struct drm_printer *p)
-{
- int order;
-
- drm_printf(p, "chunk_size: %lluKiB, total: %lluMiB, free: %lluMiB\n",
- mm->chunk_size >> 10, mm->size >> 20, mm->avail >> 20);
-
- for (order = mm->max_order; order >= 0; order--) {
- struct i915_buddy_block *block;
- u64 count = 0, free;
-
- list_for_each_entry(block, &mm->free_list[order], link) {
- GEM_BUG_ON(!i915_buddy_block_is_free(block));
- count++;
- }
-
- drm_printf(p, "order-%d ", order);
-
- free = count * (mm->chunk_size << order);
- if (free < SZ_1M)
- drm_printf(p, "free: %lluKiB", free >> 10);
- else
- drm_printf(p, "free: %lluMiB", free >> 20);
-
- drm_printf(p, ", pages: %llu\n", count);
- }
-}
-
-#if IS_ENABLED(CONFIG_DRM_I915_SELFTEST)
-#include "selftests/i915_buddy.c"
-#endif
-
-void i915_buddy_module_exit(void)
-{
- kmem_cache_destroy(slab_blocks);
-}
-
-int __init i915_buddy_module_init(void)
-{
- slab_blocks = KMEM_CACHE(i915_buddy_block, 0);
- if (!slab_blocks)
- return -ENOMEM;
-
- return 0;
-}
diff --git a/drivers/gpu/drm/i915/i915_buddy.h b/drivers/gpu/drm/i915/i915_buddy.h
deleted file mode 100644
index 7077742112ac..000000000000
--- a/drivers/gpu/drm/i915/i915_buddy.h
+++ /dev/null
@@ -1,143 +0,0 @@
-/* SPDX-License-Identifier: MIT */
-/*
- * Copyright © 2021 Intel Corporation
- */
-
-#ifndef __I915_BUDDY_H__
-#define __I915_BUDDY_H__
-
-#include <linux/bitops.h>
-#include <linux/list.h>
-#include <linux/slab.h>
-
-#include <drm/drm_print.h>
-
-struct i915_buddy_block {
-#define I915_BUDDY_HEADER_OFFSET GENMASK_ULL(63, 12)
-#define I915_BUDDY_HEADER_STATE GENMASK_ULL(11, 10)
-#define I915_BUDDY_ALLOCATED (1 << 10)
-#define I915_BUDDY_FREE (2 << 10)
-#define I915_BUDDY_SPLIT (3 << 10)
-/* Free to be used, if needed in the future */
-#define I915_BUDDY_HEADER_UNUSED GENMASK_ULL(9, 6)
-#define I915_BUDDY_HEADER_ORDER GENMASK_ULL(5, 0)
- u64 header;
-
- struct i915_buddy_block *left;
- struct i915_buddy_block *right;
- struct i915_buddy_block *parent;
-
- void *private; /* owned by creator */
-
- /*
- * While the block is allocated by the user through i915_buddy_alloc*,
- * the user has ownership of the link, for example to maintain within
- * a list, if so desired. As soon as the block is freed with
- * i915_buddy_free* ownership is given back to the mm.
- */
- struct list_head link;
- struct list_head tmp_link;
-};
-
-/* Order-zero must be at least PAGE_SIZE */
-#define I915_BUDDY_MAX_ORDER (63 - PAGE_SHIFT)
-
-/*
- * Binary Buddy System.
- *
- * Locking should be handled by the user, a simple mutex around
- * i915_buddy_alloc* and i915_buddy_free* should suffice.
- */
-struct i915_buddy_mm {
- /* Maintain a free list for each order. */
- struct list_head *free_list;
-
- /*
- * Maintain explicit binary tree(s) to track the allocation of the
- * address space. This gives us a simple way of finding a buddy block
- * and performing the potentially recursive merge step when freeing a
- * block. Nodes are either allocated or free, in which case they will
- * also exist on the respective free list.
- */
- struct i915_buddy_block **roots;
-
- /*
- * Anything from here is public, and remains static for the lifetime of
- * the mm. Everything above is considered do-not-touch.
- */
- unsigned int n_roots;
- unsigned int max_order;
-
- /* Must be at least PAGE_SIZE */
- u64 chunk_size;
- u64 size;
- u64 avail;
-};
-
-static inline u64
-i915_buddy_block_offset(struct i915_buddy_block *block)
-{
- return block->header & I915_BUDDY_HEADER_OFFSET;
-}
-
-static inline unsigned int
-i915_buddy_block_order(struct i915_buddy_block *block)
-{
- return block->header & I915_BUDDY_HEADER_ORDER;
-}
-
-static inline unsigned int
-i915_buddy_block_state(struct i915_buddy_block *block)
-{
- return block->header & I915_BUDDY_HEADER_STATE;
-}
-
-static inline bool
-i915_buddy_block_is_allocated(struct i915_buddy_block *block)
-{
- return i915_buddy_block_state(block) == I915_BUDDY_ALLOCATED;
-}
-
-static inline bool
-i915_buddy_block_is_free(struct i915_buddy_block *block)
-{
- return i915_buddy_block_state(block) == I915_BUDDY_FREE;
-}
-
-static inline bool
-i915_buddy_block_is_split(struct i915_buddy_block *block)
-{
- return i915_buddy_block_state(block) == I915_BUDDY_SPLIT;
-}
-
-static inline u64
-i915_buddy_block_size(struct i915_buddy_mm *mm,
- struct i915_buddy_block *block)
-{
- return mm->chunk_size << i915_buddy_block_order(block);
-}
-
-int i915_buddy_init(struct i915_buddy_mm *mm, u64 size, u64 chunk_size);
-
-void i915_buddy_fini(struct i915_buddy_mm *mm);
-
-struct i915_buddy_block *
-i915_buddy_alloc(struct i915_buddy_mm *mm, unsigned int order);
-
-int i915_buddy_alloc_range(struct i915_buddy_mm *mm,
- struct list_head *blocks,
- u64 start, u64 size);
-
-void i915_buddy_free(struct i915_buddy_mm *mm, struct i915_buddy_block *block);
-
-void i915_buddy_free_list(struct i915_buddy_mm *mm, struct list_head *objects);
-
-void i915_buddy_print(struct i915_buddy_mm *mm, struct drm_printer *p);
-void i915_buddy_block_print(struct i915_buddy_mm *mm,
- struct i915_buddy_block *block,
- struct drm_printer *p);
-
-void i915_buddy_module_exit(void);
-int i915_buddy_module_init(void);
-
-#endif
diff --git a/drivers/gpu/drm/i915/i915_module.c b/drivers/gpu/drm/i915/i915_module.c
index c7507266aa83..355681dbd7a8 100644
--- a/drivers/gpu/drm/i915/i915_module.c
+++ b/drivers/gpu/drm/i915/i915_module.c
@@ -9,7 +9,6 @@
#include "gem/i915_gem_context.h"
#include "gem/i915_gem_object.h"
#include "i915_active.h"
-#include "i915_buddy.h"
#include "i915_params.h"
#include "i915_pci.h"
#include "i915_perf.h"
@@ -50,8 +49,6 @@ static const struct {
{ .init = i915_check_nomodeset },
{ .init = i915_active_module_init,
.exit = i915_active_module_exit },
- { .init = i915_buddy_module_init,
- .exit = i915_buddy_module_exit },
{ .init = i915_context_module_init,
.exit = i915_context_module_exit },
{ .init = i915_gem_context_module_init,
diff --git a/drivers/gpu/drm/i915/i915_scatterlist.c b/drivers/gpu/drm/i915/i915_scatterlist.c
index 4a6712dca838..84d622aa32d2 100644
--- a/drivers/gpu/drm/i915/i915_scatterlist.c
+++ b/drivers/gpu/drm/i915/i915_scatterlist.c
@@ -5,10 +5,9 @@
*/
#include "i915_scatterlist.h"
-
-#include "i915_buddy.h"
#include "i915_ttm_buddy_manager.h"
+#include <drm/drm_buddy.h>
#include <drm/drm_mm.h>
#include <linux/slab.h>
@@ -126,9 +125,9 @@ struct sg_table *i915_sg_from_buddy_resource(struct ttm_resource *res,
struct i915_ttm_buddy_resource *bman_res = to_ttm_buddy_resource(res);
const u64 size = res->num_pages << PAGE_SHIFT;
const u64 max_segment = rounddown(UINT_MAX, PAGE_SIZE);
- struct i915_buddy_mm *mm = bman_res->mm;
+ struct drm_buddy_mm *mm = bman_res->mm;
struct list_head *blocks = &bman_res->blocks;
- struct i915_buddy_block *block;
+ struct drm_buddy_block *block;
struct scatterlist *sg;
struct sg_table *st;
resource_size_t prev_end;
@@ -151,8 +150,8 @@ struct sg_table *i915_sg_from_buddy_resource(struct ttm_resource *res,
list_for_each_entry(block, blocks, link) {
u64 block_size, offset;
- block_size = min_t(u64, size, i915_buddy_block_size(mm, block));
- offset = i915_buddy_block_offset(block);
+ block_size = min_t(u64, size, drm_buddy_block_size(mm, block));
+ offset = drm_buddy_block_offset(block);
while (block_size) {
u64 len;
diff --git a/drivers/gpu/drm/i915/i915_ttm_buddy_manager.c b/drivers/gpu/drm/i915/i915_ttm_buddy_manager.c
index d59fbb019032..c4b70cb8c248 100644
--- a/drivers/gpu/drm/i915/i915_ttm_buddy_manager.c
+++ b/drivers/gpu/drm/i915/i915_ttm_buddy_manager.c
@@ -8,14 +8,15 @@
#include <drm/ttm/ttm_bo_driver.h>
#include <drm/ttm/ttm_placement.h>
+#include <drm/drm_buddy.h>
+
#include "i915_ttm_buddy_manager.h"
-#include "i915_buddy.h"
#include "i915_gem.h"
struct i915_ttm_buddy_manager {
struct ttm_resource_manager manager;
- struct i915_buddy_mm mm;
+ struct drm_buddy_mm mm;
struct list_head reserved;
struct mutex lock;
u64 default_page_size;
@@ -34,7 +35,7 @@ static int i915_ttm_buddy_man_alloc(struct ttm_resource_manager *man,
{
struct i915_ttm_buddy_manager *bman = to_buddy_manager(man);
struct i915_ttm_buddy_resource *bman_res;
- struct i915_buddy_mm *mm = &bman->mm;
+ struct drm_buddy_mm *mm = &bman->mm;
unsigned long n_pages;
unsigned int min_order;
u64 min_page_size;
@@ -73,7 +74,7 @@ static int i915_ttm_buddy_man_alloc(struct ttm_resource_manager *man,
n_pages = size >> ilog2(mm->chunk_size);
do {
- struct i915_buddy_block *block;
+ struct drm_buddy_block *block;
unsigned int order;
order = fls(n_pages) - 1;
@@ -82,7 +83,7 @@ static int i915_ttm_buddy_man_alloc(struct ttm_resource_manager *man,
do {
mutex_lock(&bman->lock);
- block = i915_buddy_alloc(mm, order);
+ block = drm_buddy_alloc(mm, order);
mutex_unlock(&bman->lock);
if (!IS_ERR(block))
break;
@@ -106,7 +107,7 @@ static int i915_ttm_buddy_man_alloc(struct ttm_resource_manager *man,
err_free_blocks:
mutex_lock(&bman->lock);
- i915_buddy_free_list(mm, &bman_res->blocks);
+ drm_buddy_free_list(mm, &bman_res->blocks);
mutex_unlock(&bman->lock);
err_free_res:
kfree(bman_res);
@@ -120,7 +121,7 @@ static void i915_ttm_buddy_man_free(struct ttm_resource_manager *man,
struct i915_ttm_buddy_manager *bman = to_buddy_manager(man);
mutex_lock(&bman->lock);
- i915_buddy_free_list(&bman->mm, &bman_res->blocks);
+ drm_buddy_free_list(&bman->mm, &bman_res->blocks);
mutex_unlock(&bman->lock);
kfree(bman_res);
@@ -130,17 +131,17 @@ static void i915_ttm_buddy_man_debug(struct ttm_resource_manager *man,
struct drm_printer *printer)
{
struct i915_ttm_buddy_manager *bman = to_buddy_manager(man);
- struct i915_buddy_block *block;
+ struct drm_buddy_block *block;
mutex_lock(&bman->lock);
drm_printf(printer, "default_page_size: %lluKiB\n",
bman->default_page_size >> 10);
- i915_buddy_print(&bman->mm, printer);
+ drm_buddy_print(&bman->mm, printer);
drm_printf(printer, "reserved:\n");
list_for_each_entry(block, &bman->reserved, link)
- i915_buddy_block_print(&bman->mm, block, printer);
+ drm_buddy_block_print(&bman->mm, block, printer);
mutex_unlock(&bman->lock);
}
@@ -190,7 +191,7 @@ int i915_ttm_buddy_man_init(struct ttm_device *bdev,
if (!bman)
return -ENOMEM;
- err = i915_buddy_init(&bman->mm, size, chunk_size);
+ err = drm_buddy_init(&bman->mm, size, chunk_size);
if (err)
goto err_free_bman;
@@ -228,7 +229,7 @@ int i915_ttm_buddy_man_fini(struct ttm_device *bdev, unsigned int type)
{
struct ttm_resource_manager *man = ttm_manager_type(bdev, type);
struct i915_ttm_buddy_manager *bman = to_buddy_manager(man);
- struct i915_buddy_mm *mm = &bman->mm;
+ struct drm_buddy_mm *mm = &bman->mm;
int ret;
ttm_resource_manager_set_used(man, false);
@@ -240,8 +241,8 @@ int i915_ttm_buddy_man_fini(struct ttm_device *bdev, unsigned int type)
ttm_set_driver_manager(bdev, type, NULL);
mutex_lock(&bman->lock);
- i915_buddy_free_list(mm, &bman->reserved);
- i915_buddy_fini(mm);
+ drm_buddy_free_list(mm, &bman->reserved);
+ drm_buddy_fini(mm);
mutex_unlock(&bman->lock);
ttm_resource_manager_cleanup(man);
@@ -264,11 +265,11 @@ int i915_ttm_buddy_man_reserve(struct ttm_resource_manager *man,
u64 start, u64 size)
{
struct i915_ttm_buddy_manager *bman = to_buddy_manager(man);
- struct i915_buddy_mm *mm = &bman->mm;
+ struct drm_buddy_mm *mm = &bman->mm;
int ret;
mutex_lock(&bman->lock);
- ret = i915_buddy_alloc_range(mm, &bman->reserved, start, size);
+ ret = drm_buddy_alloc_range(mm, &bman->reserved, start, size);
mutex_unlock(&bman->lock);
return ret;
diff --git a/drivers/gpu/drm/i915/i915_ttm_buddy_manager.h b/drivers/gpu/drm/i915/i915_ttm_buddy_manager.h
index 0722d33f3e14..fa644b512c2e 100644
--- a/drivers/gpu/drm/i915/i915_ttm_buddy_manager.h
+++ b/drivers/gpu/drm/i915/i915_ttm_buddy_manager.h
@@ -13,7 +13,7 @@
struct ttm_device;
struct ttm_resource_manager;
-struct i915_buddy_mm;
+struct drm_buddy_mm;
/**
* struct i915_ttm_buddy_resource
@@ -28,7 +28,7 @@ struct i915_buddy_mm;
struct i915_ttm_buddy_resource {
struct ttm_resource base;
struct list_head blocks;
- struct i915_buddy_mm *mm;
+ struct drm_buddy_mm *mm;
};
/**
diff --git a/include/drm/drm_buddy.h b/include/drm/drm_buddy.h
new file mode 100644
index 000000000000..5ce3fc702f80
--- /dev/null
+++ b/include/drm/drm_buddy.h
@@ -0,0 +1,153 @@
+/* SPDX-License-Identifier: MIT */
+/*
+ * Copyright © 2021 Intel Corporation
+ */
+
+#ifndef __DRM_BUDDY_H__
+#define __DRM_BUDDY_H__
+
+#include <linux/bitops.h>
+#include <linux/list.h>
+#include <linux/slab.h>
+#include <linux/sched.h>
+
+#include <drm/drm_print.h>
+
+#define range_overflows(start, size, max) ({ \
+ typeof(start) start__ = (start); \
+ typeof(size) size__ = (size); \
+ typeof(max) max__ = (max); \
+ (void)(&start__ == &size__); \
+ (void)(&start__ == &max__); \
+ start__ >= max__ || size__ > max__ - start__; \
+})
+
+struct drm_buddy_block {
+#define DRM_BUDDY_HEADER_OFFSET GENMASK_ULL(63, 12)
+#define DRM_BUDDY_HEADER_STATE GENMASK_ULL(11, 10)
+#define DRM_BUDDY_ALLOCATED (1 << 10)
+#define DRM_BUDDY_FREE (2 << 10)
+#define DRM_BUDDY_SPLIT (3 << 10)
+/* Free to be used, if needed in the future */
+#define DRM_BUDDY_HEADER_UNUSED GENMASK_ULL(9, 6)
+#define DRM_BUDDY_HEADER_ORDER GENMASK_ULL(5, 0)
+ u64 header;
+
+ struct drm_buddy_block *left;
+ struct drm_buddy_block *right;
+ struct drm_buddy_block *parent;
+
+ void *private; /* owned by creator */
+
+ /*
+ * While the block is allocated by the user through drm_buddy_alloc*,
+ * the user has ownership of the link, for example to maintain within
+ * a list, if so desired. As soon as the block is freed with
+ * drm_buddy_free* ownership is given back to the mm.
+ */
+ struct list_head link;
+ struct list_head tmp_link;
+};
+
+/* Order-zero must be at least PAGE_SIZE */
+#define DRM_BUDDY_MAX_ORDER (63 - PAGE_SHIFT)
+
+/*
+ * Binary Buddy System.
+ *
+ * Locking should be handled by the user, a simple mutex around
+ * drm_buddy_alloc* and drm_buddy_free* should suffice.
+ */
+struct drm_buddy_mm {
+ /* Maintain a free list for each order. */
+ struct list_head *free_list;
+
+ /*
+ * Maintain explicit binary tree(s) to track the allocation of the
+ * address space. This gives us a simple way of finding a buddy block
+ * and performing the potentially recursive merge step when freeing a
+ * block. Nodes are either allocated or free, in which case they will
+ * also exist on the respective free list.
+ */
+ struct drm_buddy_block **roots;
+
+ /*
+ * Anything from here is public, and remains static for the lifetime of
+ * the mm. Everything above is considered do-not-touch.
+ */
+ unsigned int n_roots;
+ unsigned int max_order;
+
+ /* Must be at least PAGE_SIZE */
+ u64 chunk_size;
+ u64 size;
+ u64 avail;
+};
+
+static inline u64
+drm_buddy_block_offset(struct drm_buddy_block *block)
+{
+ return block->header & DRM_BUDDY_HEADER_OFFSET;
+}
+
+static inline unsigned int
+drm_buddy_block_order(struct drm_buddy_block *block)
+{
+ return block->header & DRM_BUDDY_HEADER_ORDER;
+}
+
+static inline unsigned int
+drm_buddy_block_state(struct drm_buddy_block *block)
+{
+ return block->header & DRM_BUDDY_HEADER_STATE;
+}
+
+static inline bool
+drm_buddy_block_is_allocated(struct drm_buddy_block *block)
+{
+ return drm_buddy_block_state(block) == DRM_BUDDY_ALLOCATED;
+}
+
+static inline bool
+drm_buddy_block_is_free(struct drm_buddy_block *block)
+{
+ return drm_buddy_block_state(block) == DRM_BUDDY_FREE;
+}
+
+static inline bool
+drm_buddy_block_is_split(struct drm_buddy_block *block)
+{
+ return drm_buddy_block_state(block) == DRM_BUDDY_SPLIT;
+}
+
+static inline u64
+drm_buddy_block_size(struct drm_buddy_mm *mm,
+ struct drm_buddy_block *block)
+{
+ return mm->chunk_size << drm_buddy_block_order(block);
+}
+
+int drm_buddy_init(struct drm_buddy_mm *mm, u64 size, u64 chunk_size);
+
+void drm_buddy_fini(struct drm_buddy_mm *mm);
+
+struct drm_buddy_block *
+drm_buddy_alloc(struct drm_buddy_mm *mm, unsigned int order);
+
+int drm_buddy_alloc_range(struct drm_buddy_mm *mm,
+ struct list_head *blocks,
+ u64 start, u64 size);
+
+void drm_buddy_free(struct drm_buddy_mm *mm, struct drm_buddy_block *block);
+
+void drm_buddy_free_list(struct drm_buddy_mm *mm, struct list_head *objects);
+
+void drm_buddy_print(struct drm_buddy_mm *mm, struct drm_printer *p);
+void drm_buddy_block_print(struct drm_buddy_mm *mm,
+ struct drm_buddy_block *block,
+ struct drm_printer *p);
+
+void drm_buddy_module_exit(void);
+int drm_buddy_module_init(void);
+
+#endif
--
2.25.1
^ permalink raw reply related [flat|nested] 46+ messages in thread
* [Intel-gfx] [PATCH v3 1/6] drm: move the buddy allocator from i915 into common drm
@ 2021-11-16 20:18 ` Arunpravin
0 siblings, 0 replies; 46+ messages in thread
From: Arunpravin @ 2021-11-16 20:18 UTC (permalink / raw)
To: dri-devel, intel-gfx, amd-gfx
Cc: Arunpravin, matthew.auld, tzimmermann, alexander.deucher,
christian.koenig
Move the base i915 buddy allocator code into drm
- Move i915_buddy.h to include/drm
- Move i915_buddy.c to drm root folder
- Rename "i915" string with "drm" string wherever applicable
- Rename "I915" string with "DRM" string wherever applicable
- Fix header file dependencies
- Fix alignment issues
- add Makefile support for drm buddy
- export functions and write kerneldoc description
- Remove i915 selftest config check condition as buddy selftest
will be moved to drm selftest folder
cleanup i915 buddy references in i915 driver module
and replace with drm buddy
v2:
- include header file in alphabetical order (Thomas)
- merged changes listed in the body section into a single patch
to keep the build intact (Christian, Jani)
Signed-off-by: Arunpravin <Arunpravin.PaneerSelvam@amd.com>
---
drivers/gpu/drm/Makefile | 2 +-
drivers/gpu/drm/drm_buddy.c | 521 ++++++++++++++++++
drivers/gpu/drm/drm_drv.c | 3 +
drivers/gpu/drm/i915/Makefile | 1 -
drivers/gpu/drm/i915/i915_buddy.c | 466 ----------------
drivers/gpu/drm/i915/i915_buddy.h | 143 -----
drivers/gpu/drm/i915/i915_module.c | 3 -
drivers/gpu/drm/i915/i915_scatterlist.c | 11 +-
drivers/gpu/drm/i915/i915_ttm_buddy_manager.c | 33 +-
drivers/gpu/drm/i915/i915_ttm_buddy_manager.h | 4 +-
include/drm/drm_buddy.h | 153 +++++
11 files changed, 702 insertions(+), 638 deletions(-)
create mode 100644 drivers/gpu/drm/drm_buddy.c
delete mode 100644 drivers/gpu/drm/i915/i915_buddy.c
delete mode 100644 drivers/gpu/drm/i915/i915_buddy.h
create mode 100644 include/drm/drm_buddy.h
diff --git a/drivers/gpu/drm/Makefile b/drivers/gpu/drm/Makefile
index 0dff40bb863c..dc61e91a3154 100644
--- a/drivers/gpu/drm/Makefile
+++ b/drivers/gpu/drm/Makefile
@@ -18,7 +18,7 @@ drm-y := drm_aperture.o drm_auth.o drm_cache.o \
drm_dumb_buffers.o drm_mode_config.o drm_vblank.o \
drm_syncobj.o drm_lease.o drm_writeback.o drm_client.o \
drm_client_modeset.o drm_atomic_uapi.o drm_hdcp.o \
- drm_managed.o drm_vblank_work.o
+ drm_managed.o drm_vblank_work.o drm_buddy.o
drm-$(CONFIG_DRM_LEGACY) += drm_agpsupport.o drm_bufs.o drm_context.o drm_dma.o \
drm_legacy_misc.o drm_lock.o drm_memory.o drm_scatter.o \
diff --git a/drivers/gpu/drm/drm_buddy.c b/drivers/gpu/drm/drm_buddy.c
new file mode 100644
index 000000000000..39eb1d224bec
--- /dev/null
+++ b/drivers/gpu/drm/drm_buddy.c
@@ -0,0 +1,521 @@
+// SPDX-License-Identifier: MIT
+/*
+ * Copyright © 2021 Intel Corporation
+ */
+
+#include <linux/kmemleak.h>
+#include <linux/sizes.h>
+
+#include <drm/drm_buddy.h>
+
+static struct kmem_cache *slab_blocks;
+
+static struct drm_buddy_block *drm_block_alloc(struct drm_buddy_mm *mm,
+ struct drm_buddy_block *parent,
+ unsigned int order,
+ u64 offset)
+{
+ struct drm_buddy_block *block;
+
+ BUG_ON(order > DRM_BUDDY_MAX_ORDER);
+
+ block = kmem_cache_zalloc(slab_blocks, GFP_KERNEL);
+ if (!block)
+ return NULL;
+
+ block->header = offset;
+ block->header |= order;
+ block->parent = parent;
+
+ BUG_ON(block->header & DRM_BUDDY_HEADER_UNUSED);
+ return block;
+}
+
+static void drm_block_free(struct drm_buddy_mm *mm,
+ struct drm_buddy_block *block)
+{
+ kmem_cache_free(slab_blocks, block);
+}
+
+static void mark_allocated(struct drm_buddy_block *block)
+{
+ block->header &= ~DRM_BUDDY_HEADER_STATE;
+ block->header |= DRM_BUDDY_ALLOCATED;
+
+ list_del(&block->link);
+}
+
+static void mark_free(struct drm_buddy_mm *mm,
+ struct drm_buddy_block *block)
+{
+ block->header &= ~DRM_BUDDY_HEADER_STATE;
+ block->header |= DRM_BUDDY_FREE;
+
+ list_add(&block->link,
+ &mm->free_list[drm_buddy_block_order(block)]);
+}
+
+static void mark_split(struct drm_buddy_block *block)
+{
+ block->header &= ~DRM_BUDDY_HEADER_STATE;
+ block->header |= DRM_BUDDY_SPLIT;
+
+ list_del(&block->link);
+}
+
+/**
+ * drm_buddy_init - init memory manager
+ *
+ * @mm: DRM buddy manager to initialize
+ * @size: size in bytes to manage
+ * @chunk_size: minimum page size in bytes for our allocations
+ *
+ * Initializes the memory manager and its resources.
+ *
+ * Returns:
+ * 0 on success, error code on failure.
+ */
+int drm_buddy_init(struct drm_buddy_mm *mm, u64 size, u64 chunk_size)
+{
+ unsigned int i;
+ u64 offset;
+
+ if (size < chunk_size)
+ return -EINVAL;
+
+ if (chunk_size < PAGE_SIZE)
+ return -EINVAL;
+
+ if (!is_power_of_2(chunk_size))
+ return -EINVAL;
+
+ size = round_down(size, chunk_size);
+
+ mm->size = size;
+ mm->avail = size;
+ mm->chunk_size = chunk_size;
+ mm->max_order = ilog2(size) - ilog2(chunk_size);
+
+ BUG_ON(mm->max_order > DRM_BUDDY_MAX_ORDER);
+
+ mm->free_list = kmalloc_array(mm->max_order + 1,
+ sizeof(struct list_head),
+ GFP_KERNEL);
+ if (!mm->free_list)
+ return -ENOMEM;
+
+ for (i = 0; i <= mm->max_order; ++i)
+ INIT_LIST_HEAD(&mm->free_list[i]);
+
+ mm->n_roots = hweight64(size);
+
+ mm->roots = kmalloc_array(mm->n_roots,
+ sizeof(struct drm_buddy_block *),
+ GFP_KERNEL);
+ if (!mm->roots)
+ goto out_free_list;
+
+ offset = 0;
+ i = 0;
+
+ /*
+ * Split into power-of-two blocks, in case we are given a size that is
+ * not itself a power-of-two.
+ */
+ do {
+ struct drm_buddy_block *root;
+ unsigned int order;
+ u64 root_size;
+
+ root_size = rounddown_pow_of_two(size);
+ order = ilog2(root_size) - ilog2(chunk_size);
+
+ root = drm_block_alloc(mm, NULL, order, offset);
+ if (!root)
+ goto out_free_roots;
+
+ mark_free(mm, root);
+
+ BUG_ON(i > mm->max_order);
+ BUG_ON(drm_buddy_block_size(mm, root) < chunk_size);
+
+ mm->roots[i] = root;
+
+ offset += root_size;
+ size -= root_size;
+ i++;
+ } while (size);
+
+ return 0;
+
+out_free_roots:
+ while (i--)
+ drm_block_free(mm, mm->roots[i]);
+ kfree(mm->roots);
+out_free_list:
+ kfree(mm->free_list);
+ return -ENOMEM;
+}
+EXPORT_SYMBOL(drm_buddy_init);
+
+/**
+ * drm_buddy_fini - tear down the memory manager
+ *
+ * @mm: DRM buddy manager to free
+ *
+ * Cleanup memory manager resources and the freelist
+ */
+void drm_buddy_fini(struct drm_buddy_mm *mm)
+{
+ int i;
+
+ for (i = 0; i < mm->n_roots; ++i) {
+ WARN_ON(!drm_buddy_block_is_free(mm->roots[i]));
+ drm_block_free(mm, mm->roots[i]);
+ }
+
+ WARN_ON(mm->avail != mm->size);
+
+ kfree(mm->roots);
+ kfree(mm->free_list);
+}
+EXPORT_SYMBOL(drm_buddy_fini);
+
+static int split_block(struct drm_buddy_mm *mm,
+ struct drm_buddy_block *block)
+{
+ unsigned int block_order = drm_buddy_block_order(block) - 1;
+ u64 offset = drm_buddy_block_offset(block);
+
+ BUG_ON(!drm_buddy_block_is_free(block));
+ BUG_ON(!drm_buddy_block_order(block));
+
+ block->left = drm_block_alloc(mm, block, block_order, offset);
+ if (!block->left)
+ return -ENOMEM;
+
+ block->right = drm_block_alloc(mm, block, block_order,
+ offset + (mm->chunk_size << block_order));
+ if (!block->right) {
+ drm_block_free(mm, block->left);
+ return -ENOMEM;
+ }
+
+ mark_free(mm, block->left);
+ mark_free(mm, block->right);
+
+ mark_split(block);
+
+ return 0;
+}
+
+static struct drm_buddy_block *
+get_buddy(struct drm_buddy_block *block)
+{
+ struct drm_buddy_block *parent;
+
+ parent = block->parent;
+ if (!parent)
+ return NULL;
+
+ if (parent->left == block)
+ return parent->right;
+
+ return parent->left;
+}
+
+static void __drm_buddy_free(struct drm_buddy_mm *mm,
+ struct drm_buddy_block *block)
+{
+ struct drm_buddy_block *parent;
+
+ while ((parent = block->parent)) {
+ struct drm_buddy_block *buddy;
+
+ buddy = get_buddy(block);
+
+ if (!drm_buddy_block_is_free(buddy))
+ break;
+
+ list_del(&buddy->link);
+
+ drm_block_free(mm, block);
+ drm_block_free(mm, buddy);
+
+ block = parent;
+ }
+
+ mark_free(mm, block);
+}
+
+void drm_buddy_free(struct drm_buddy_mm *mm,
+ struct drm_buddy_block *block)
+{
+ BUG_ON(!drm_buddy_block_is_allocated(block));
+ mm->avail += drm_buddy_block_size(mm, block);
+ __drm_buddy_free(mm, block);
+}
+
+/**
+ * drm_buddy_free_list - free blocks
+ *
+ * @mm: DRM buddy manager
+ * @objects: input list head to free blocks
+ */
+void drm_buddy_free_list(struct drm_buddy_mm *mm, struct list_head *objects)
+{
+ struct drm_buddy_block *block, *on;
+
+ list_for_each_entry_safe(block, on, objects, link) {
+ drm_buddy_free(mm, block);
+ cond_resched();
+ }
+ INIT_LIST_HEAD(objects);
+}
+EXPORT_SYMBOL(drm_buddy_free_list);
+
+/**
+ * drm_buddy_alloc - allocate power-of-two blocks
+ *
+ * @mm: DRM buddy manager to allocate from
+ * @order: size of the allocation
+ *
+ * The order value here translates to:
+ *
+ * 0 = 2^0 * mm->chunk_size
+ * 1 = 2^1 * mm->chunk_size
+ * 2 = 2^2 * mm->chunk_size
+ *
+ * Returns:
+ * allocated ptr to the &drm_buddy_block on success
+ */
+struct drm_buddy_block *
+drm_buddy_alloc(struct drm_buddy_mm *mm, unsigned int order)
+{
+ struct drm_buddy_block *block = NULL;
+ unsigned int i;
+ int err;
+
+ for (i = order; i <= mm->max_order; ++i) {
+ block = list_first_entry_or_null(&mm->free_list[i],
+ struct drm_buddy_block,
+ link);
+ if (block)
+ break;
+ }
+
+ if (!block)
+ return ERR_PTR(-ENOSPC);
+
+ BUG_ON(!drm_buddy_block_is_free(block));
+
+ while (i != order) {
+ err = split_block(mm, block);
+ if (unlikely(err))
+ goto out_free;
+
+ /* Go low */
+ block = block->left;
+ i--;
+ }
+
+ mark_allocated(block);
+ mm->avail -= drm_buddy_block_size(mm, block);
+ kmemleak_update_trace(block);
+ return block;
+
+out_free:
+ if (i != order)
+ __drm_buddy_free(mm, block);
+ return ERR_PTR(err);
+}
+EXPORT_SYMBOL(drm_buddy_alloc);
+
+static inline bool overlaps(u64 s1, u64 e1, u64 s2, u64 e2)
+{
+ return s1 <= e2 && e1 >= s2;
+}
+
+static inline bool contains(u64 s1, u64 e1, u64 s2, u64 e2)
+{
+ return s1 <= s2 && e1 >= e2;
+}
+
+/**
+ * drm_buddy_alloc_range - allocate range
+ *
+ * @mm: DRM buddy manager to allocate from
+ * @blocks: output list head to add allocated blocks
+ * @start: start of the allowed range for this block
+ * @size: size of the allocation
+ *
+ * Intended for pre-allocating portions of the address space, for example to
+ * reserve a block for the initial framebuffer or similar, hence the expectation
+ * here is that drm_buddy_alloc() is still the main vehicle for
+ * allocations, so if that's not the case then the drm_mm range allocator is
+ * probably a much better fit, and so you should probably go use that instead.
+ *
+ * Note that it's safe to chain together multiple alloc_ranges
+ * with the same blocks list
+ *
+ * Returns:
+ * 0 on success, error code on failure.
+ */
+int drm_buddy_alloc_range(struct drm_buddy_mm *mm,
+ struct list_head *blocks,
+ u64 start, u64 size)
+{
+ struct drm_buddy_block *block;
+ struct drm_buddy_block *buddy;
+ LIST_HEAD(allocated);
+ LIST_HEAD(dfs);
+ u64 end;
+ int err;
+ int i;
+
+ if (size < mm->chunk_size)
+ return -EINVAL;
+
+ if (!IS_ALIGNED(size | start, mm->chunk_size))
+ return -EINVAL;
+
+ if (range_overflows(start, size, mm->size))
+ return -EINVAL;
+
+ for (i = 0; i < mm->n_roots; ++i)
+ list_add_tail(&mm->roots[i]->tmp_link, &dfs);
+
+ end = start + size - 1;
+
+ do {
+ u64 block_start;
+ u64 block_end;
+
+ block = list_first_entry_or_null(&dfs,
+ struct drm_buddy_block,
+ tmp_link);
+ if (!block)
+ break;
+
+ list_del(&block->tmp_link);
+
+ block_start = drm_buddy_block_offset(block);
+ block_end = block_start + drm_buddy_block_size(mm, block) - 1;
+
+ if (!overlaps(start, end, block_start, block_end))
+ continue;
+
+ if (drm_buddy_block_is_allocated(block)) {
+ err = -ENOSPC;
+ goto err_free;
+ }
+
+ if (contains(start, end, block_start, block_end)) {
+ if (!drm_buddy_block_is_free(block)) {
+ err = -ENOSPC;
+ goto err_free;
+ }
+
+ mark_allocated(block);
+ mm->avail -= drm_buddy_block_size(mm, block);
+ list_add_tail(&block->link, &allocated);
+ continue;
+ }
+
+ if (!drm_buddy_block_is_split(block)) {
+ err = split_block(mm, block);
+ if (unlikely(err))
+ goto err_undo;
+ }
+
+ list_add(&block->right->tmp_link, &dfs);
+ list_add(&block->left->tmp_link, &dfs);
+ } while (1);
+
+ list_splice_tail(&allocated, blocks);
+ return 0;
+
+err_undo:
+ /*
+ * We really don't want to leave around a bunch of split blocks, since
+ * bigger is better, so make sure we merge everything back before we
+ * free the allocated blocks.
+ */
+ buddy = get_buddy(block);
+ if (buddy &&
+ (drm_buddy_block_is_free(block) &&
+ drm_buddy_block_is_free(buddy)))
+ __drm_buddy_free(mm, block);
+
+err_free:
+ drm_buddy_free_list(mm, &allocated);
+ return err;
+}
+EXPORT_SYMBOL(drm_buddy_alloc_range);
+
+/**
+ * drm_buddy_block_print - print block information
+ *
+ * @mm: DRM buddy manager
+ * @block: DRM buddy block
+ * @p: DRM printer to use
+ */
+void drm_buddy_block_print(struct drm_buddy_mm *mm,
+ struct drm_buddy_block *block,
+ struct drm_printer *p)
+{
+ u64 start = drm_buddy_block_offset(block);
+ u64 size = drm_buddy_block_size(mm, block);
+
+ drm_printf(p, "%#018llx-%#018llx: %llu\n", start, start + size, size);
+}
+EXPORT_SYMBOL(drm_buddy_block_print);
+
+/**
+ * drm_buddy_print - print allocator state
+ *
+ * @mm: DRM buddy manager
+ * @p: DRM printer to use
+ */
+void drm_buddy_print(struct drm_buddy_mm *mm, struct drm_printer *p)
+{
+ int order;
+
+ drm_printf(p, "chunk_size: %lluKiB, total: %lluMiB, free: %lluMiB\n",
+ mm->chunk_size >> 10, mm->size >> 20, mm->avail >> 20);
+
+ for (order = mm->max_order; order >= 0; order--) {
+ struct drm_buddy_block *block;
+ u64 count = 0, free;
+
+ list_for_each_entry(block, &mm->free_list[order], link) {
+ BUG_ON(!drm_buddy_block_is_free(block));
+ count++;
+ }
+
+ drm_printf(p, "order-%d ", order);
+
+ free = count * (mm->chunk_size << order);
+ if (free < SZ_1M)
+ drm_printf(p, "free: %lluKiB", free >> 10);
+ else
+ drm_printf(p, "free: %lluMiB", free >> 20);
+
+ drm_printf(p, ", pages: %llu\n", count);
+ }
+}
+EXPORT_SYMBOL(drm_buddy_print);
+
+void drm_buddy_module_exit(void)
+{
+ kmem_cache_destroy(slab_blocks);
+}
+
+int __init drm_buddy_module_init(void)
+{
+ slab_blocks = KMEM_CACHE(drm_buddy_block, 0);
+ if (!slab_blocks)
+ return -ENOMEM;
+
+ return 0;
+}
diff --git a/drivers/gpu/drm/drm_drv.c b/drivers/gpu/drm/drm_drv.c
index 7a5097467ba5..5d5e46e60586 100644
--- a/drivers/gpu/drm/drm_drv.c
+++ b/drivers/gpu/drm/drm_drv.c
@@ -35,6 +35,7 @@
#include <linux/slab.h>
#include <linux/srcu.h>
+#include <drm/drm_buddy.h>
#include <drm/drm_cache.h>
#include <drm/drm_client.h>
#include <drm/drm_color_mgmt.h>
@@ -1034,6 +1035,7 @@ static void drm_core_exit(void)
drm_sysfs_destroy();
idr_destroy(&drm_minors_idr);
drm_connector_ida_destroy();
+ drm_buddy_module_exit();
}
static int __init drm_core_init(void)
@@ -1043,6 +1045,7 @@ static int __init drm_core_init(void)
drm_connector_ida_init();
idr_init(&drm_minors_idr);
drm_memcpy_init_early();
+ drm_buddy_module_init();
ret = drm_sysfs_init();
if (ret < 0) {
diff --git a/drivers/gpu/drm/i915/Makefile b/drivers/gpu/drm/i915/Makefile
index 467872cca027..fc5ca8c4ccb2 100644
--- a/drivers/gpu/drm/i915/Makefile
+++ b/drivers/gpu/drm/i915/Makefile
@@ -161,7 +161,6 @@ gem-y += \
i915-y += \
$(gem-y) \
i915_active.o \
- i915_buddy.o \
i915_cmd_parser.o \
i915_gem_evict.o \
i915_gem_gtt.o \
diff --git a/drivers/gpu/drm/i915/i915_buddy.c b/drivers/gpu/drm/i915/i915_buddy.c
deleted file mode 100644
index 6e2ad68f8f3f..000000000000
--- a/drivers/gpu/drm/i915/i915_buddy.c
+++ /dev/null
@@ -1,466 +0,0 @@
-// SPDX-License-Identifier: MIT
-/*
- * Copyright © 2021 Intel Corporation
- */
-
-#include <linux/kmemleak.h>
-#include <linux/sizes.h>
-
-#include "i915_buddy.h"
-
-#include "i915_gem.h"
-#include "i915_utils.h"
-
-static struct kmem_cache *slab_blocks;
-
-static struct i915_buddy_block *i915_block_alloc(struct i915_buddy_mm *mm,
- struct i915_buddy_block *parent,
- unsigned int order,
- u64 offset)
-{
- struct i915_buddy_block *block;
-
- GEM_BUG_ON(order > I915_BUDDY_MAX_ORDER);
-
- block = kmem_cache_zalloc(slab_blocks, GFP_KERNEL);
- if (!block)
- return NULL;
-
- block->header = offset;
- block->header |= order;
- block->parent = parent;
-
- GEM_BUG_ON(block->header & I915_BUDDY_HEADER_UNUSED);
- return block;
-}
-
-static void i915_block_free(struct i915_buddy_mm *mm,
- struct i915_buddy_block *block)
-{
- kmem_cache_free(slab_blocks, block);
-}
-
-static void mark_allocated(struct i915_buddy_block *block)
-{
- block->header &= ~I915_BUDDY_HEADER_STATE;
- block->header |= I915_BUDDY_ALLOCATED;
-
- list_del(&block->link);
-}
-
-static void mark_free(struct i915_buddy_mm *mm,
- struct i915_buddy_block *block)
-{
- block->header &= ~I915_BUDDY_HEADER_STATE;
- block->header |= I915_BUDDY_FREE;
-
- list_add(&block->link,
- &mm->free_list[i915_buddy_block_order(block)]);
-}
-
-static void mark_split(struct i915_buddy_block *block)
-{
- block->header &= ~I915_BUDDY_HEADER_STATE;
- block->header |= I915_BUDDY_SPLIT;
-
- list_del(&block->link);
-}
-
-int i915_buddy_init(struct i915_buddy_mm *mm, u64 size, u64 chunk_size)
-{
- unsigned int i;
- u64 offset;
-
- if (size < chunk_size)
- return -EINVAL;
-
- if (chunk_size < PAGE_SIZE)
- return -EINVAL;
-
- if (!is_power_of_2(chunk_size))
- return -EINVAL;
-
- size = round_down(size, chunk_size);
-
- mm->size = size;
- mm->avail = size;
- mm->chunk_size = chunk_size;
- mm->max_order = ilog2(size) - ilog2(chunk_size);
-
- GEM_BUG_ON(mm->max_order > I915_BUDDY_MAX_ORDER);
-
- mm->free_list = kmalloc_array(mm->max_order + 1,
- sizeof(struct list_head),
- GFP_KERNEL);
- if (!mm->free_list)
- return -ENOMEM;
-
- for (i = 0; i <= mm->max_order; ++i)
- INIT_LIST_HEAD(&mm->free_list[i]);
-
- mm->n_roots = hweight64(size);
-
- mm->roots = kmalloc_array(mm->n_roots,
- sizeof(struct i915_buddy_block *),
- GFP_KERNEL);
- if (!mm->roots)
- goto out_free_list;
-
- offset = 0;
- i = 0;
-
- /*
- * Split into power-of-two blocks, in case we are given a size that is
- * not itself a power-of-two.
- */
- do {
- struct i915_buddy_block *root;
- unsigned int order;
- u64 root_size;
-
- root_size = rounddown_pow_of_two(size);
- order = ilog2(root_size) - ilog2(chunk_size);
-
- root = i915_block_alloc(mm, NULL, order, offset);
- if (!root)
- goto out_free_roots;
-
- mark_free(mm, root);
-
- GEM_BUG_ON(i > mm->max_order);
- GEM_BUG_ON(i915_buddy_block_size(mm, root) < chunk_size);
-
- mm->roots[i] = root;
-
- offset += root_size;
- size -= root_size;
- i++;
- } while (size);
-
- return 0;
-
-out_free_roots:
- while (i--)
- i915_block_free(mm, mm->roots[i]);
- kfree(mm->roots);
-out_free_list:
- kfree(mm->free_list);
- return -ENOMEM;
-}
-
-void i915_buddy_fini(struct i915_buddy_mm *mm)
-{
- int i;
-
- for (i = 0; i < mm->n_roots; ++i) {
- GEM_WARN_ON(!i915_buddy_block_is_free(mm->roots[i]));
- i915_block_free(mm, mm->roots[i]);
- }
-
- GEM_WARN_ON(mm->avail != mm->size);
-
- kfree(mm->roots);
- kfree(mm->free_list);
-}
-
-static int split_block(struct i915_buddy_mm *mm,
- struct i915_buddy_block *block)
-{
- unsigned int block_order = i915_buddy_block_order(block) - 1;
- u64 offset = i915_buddy_block_offset(block);
-
- GEM_BUG_ON(!i915_buddy_block_is_free(block));
- GEM_BUG_ON(!i915_buddy_block_order(block));
-
- block->left = i915_block_alloc(mm, block, block_order, offset);
- if (!block->left)
- return -ENOMEM;
-
- block->right = i915_block_alloc(mm, block, block_order,
- offset + (mm->chunk_size << block_order));
- if (!block->right) {
- i915_block_free(mm, block->left);
- return -ENOMEM;
- }
-
- mark_free(mm, block->left);
- mark_free(mm, block->right);
-
- mark_split(block);
-
- return 0;
-}
-
-static struct i915_buddy_block *
-get_buddy(struct i915_buddy_block *block)
-{
- struct i915_buddy_block *parent;
-
- parent = block->parent;
- if (!parent)
- return NULL;
-
- if (parent->left == block)
- return parent->right;
-
- return parent->left;
-}
-
-static void __i915_buddy_free(struct i915_buddy_mm *mm,
- struct i915_buddy_block *block)
-{
- struct i915_buddy_block *parent;
-
- while ((parent = block->parent)) {
- struct i915_buddy_block *buddy;
-
- buddy = get_buddy(block);
-
- if (!i915_buddy_block_is_free(buddy))
- break;
-
- list_del(&buddy->link);
-
- i915_block_free(mm, block);
- i915_block_free(mm, buddy);
-
- block = parent;
- }
-
- mark_free(mm, block);
-}
-
-void i915_buddy_free(struct i915_buddy_mm *mm,
- struct i915_buddy_block *block)
-{
- GEM_BUG_ON(!i915_buddy_block_is_allocated(block));
- mm->avail += i915_buddy_block_size(mm, block);
- __i915_buddy_free(mm, block);
-}
-
-void i915_buddy_free_list(struct i915_buddy_mm *mm, struct list_head *objects)
-{
- struct i915_buddy_block *block, *on;
-
- list_for_each_entry_safe(block, on, objects, link) {
- i915_buddy_free(mm, block);
- cond_resched();
- }
- INIT_LIST_HEAD(objects);
-}
-
-/*
- * Allocate power-of-two block. The order value here translates to:
- *
- * 0 = 2^0 * mm->chunk_size
- * 1 = 2^1 * mm->chunk_size
- * 2 = 2^2 * mm->chunk_size
- * ...
- */
-struct i915_buddy_block *
-i915_buddy_alloc(struct i915_buddy_mm *mm, unsigned int order)
-{
- struct i915_buddy_block *block = NULL;
- unsigned int i;
- int err;
-
- for (i = order; i <= mm->max_order; ++i) {
- block = list_first_entry_or_null(&mm->free_list[i],
- struct i915_buddy_block,
- link);
- if (block)
- break;
- }
-
- if (!block)
- return ERR_PTR(-ENOSPC);
-
- GEM_BUG_ON(!i915_buddy_block_is_free(block));
-
- while (i != order) {
- err = split_block(mm, block);
- if (unlikely(err))
- goto out_free;
-
- /* Go low */
- block = block->left;
- i--;
- }
-
- mark_allocated(block);
- mm->avail -= i915_buddy_block_size(mm, block);
- kmemleak_update_trace(block);
- return block;
-
-out_free:
- if (i != order)
- __i915_buddy_free(mm, block);
- return ERR_PTR(err);
-}
-
-static inline bool overlaps(u64 s1, u64 e1, u64 s2, u64 e2)
-{
- return s1 <= e2 && e1 >= s2;
-}
-
-static inline bool contains(u64 s1, u64 e1, u64 s2, u64 e2)
-{
- return s1 <= s2 && e1 >= e2;
-}
-
-/*
- * Allocate range. Note that it's safe to chain together multiple alloc_ranges
- * with the same blocks list.
- *
- * Intended for pre-allocating portions of the address space, for example to
- * reserve a block for the initial framebuffer or similar, hence the expectation
- * here is that i915_buddy_alloc() is still the main vehicle for
- * allocations, so if that's not the case then the drm_mm range allocator is
- * probably a much better fit, and so you should probably go use that instead.
- */
-int i915_buddy_alloc_range(struct i915_buddy_mm *mm,
- struct list_head *blocks,
- u64 start, u64 size)
-{
- struct i915_buddy_block *block;
- struct i915_buddy_block *buddy;
- LIST_HEAD(allocated);
- LIST_HEAD(dfs);
- u64 end;
- int err;
- int i;
-
- if (size < mm->chunk_size)
- return -EINVAL;
-
- if (!IS_ALIGNED(size | start, mm->chunk_size))
- return -EINVAL;
-
- if (range_overflows(start, size, mm->size))
- return -EINVAL;
-
- for (i = 0; i < mm->n_roots; ++i)
- list_add_tail(&mm->roots[i]->tmp_link, &dfs);
-
- end = start + size - 1;
-
- do {
- u64 block_start;
- u64 block_end;
-
- block = list_first_entry_or_null(&dfs,
- struct i915_buddy_block,
- tmp_link);
- if (!block)
- break;
-
- list_del(&block->tmp_link);
-
- block_start = i915_buddy_block_offset(block);
- block_end = block_start + i915_buddy_block_size(mm, block) - 1;
-
- if (!overlaps(start, end, block_start, block_end))
- continue;
-
- if (i915_buddy_block_is_allocated(block)) {
- err = -ENOSPC;
- goto err_free;
- }
-
- if (contains(start, end, block_start, block_end)) {
- if (!i915_buddy_block_is_free(block)) {
- err = -ENOSPC;
- goto err_free;
- }
-
- mark_allocated(block);
- mm->avail -= i915_buddy_block_size(mm, block);
- list_add_tail(&block->link, &allocated);
- continue;
- }
-
- if (!i915_buddy_block_is_split(block)) {
- err = split_block(mm, block);
- if (unlikely(err))
- goto err_undo;
- }
-
- list_add(&block->right->tmp_link, &dfs);
- list_add(&block->left->tmp_link, &dfs);
- } while (1);
-
- list_splice_tail(&allocated, blocks);
- return 0;
-
-err_undo:
- /*
- * We really don't want to leave around a bunch of split blocks, since
- * bigger is better, so make sure we merge everything back before we
- * free the allocated blocks.
- */
- buddy = get_buddy(block);
- if (buddy &&
- (i915_buddy_block_is_free(block) &&
- i915_buddy_block_is_free(buddy)))
- __i915_buddy_free(mm, block);
-
-err_free:
- i915_buddy_free_list(mm, &allocated);
- return err;
-}
-
-void i915_buddy_block_print(struct i915_buddy_mm *mm,
- struct i915_buddy_block *block,
- struct drm_printer *p)
-{
- u64 start = i915_buddy_block_offset(block);
- u64 size = i915_buddy_block_size(mm, block);
-
- drm_printf(p, "%#018llx-%#018llx: %llu\n", start, start + size, size);
-}
-
-void i915_buddy_print(struct i915_buddy_mm *mm, struct drm_printer *p)
-{
- int order;
-
- drm_printf(p, "chunk_size: %lluKiB, total: %lluMiB, free: %lluMiB\n",
- mm->chunk_size >> 10, mm->size >> 20, mm->avail >> 20);
-
- for (order = mm->max_order; order >= 0; order--) {
- struct i915_buddy_block *block;
- u64 count = 0, free;
-
- list_for_each_entry(block, &mm->free_list[order], link) {
- GEM_BUG_ON(!i915_buddy_block_is_free(block));
- count++;
- }
-
- drm_printf(p, "order-%d ", order);
-
- free = count * (mm->chunk_size << order);
- if (free < SZ_1M)
- drm_printf(p, "free: %lluKiB", free >> 10);
- else
- drm_printf(p, "free: %lluMiB", free >> 20);
-
- drm_printf(p, ", pages: %llu\n", count);
- }
-}
-
-#if IS_ENABLED(CONFIG_DRM_I915_SELFTEST)
-#include "selftests/i915_buddy.c"
-#endif
-
-void i915_buddy_module_exit(void)
-{
- kmem_cache_destroy(slab_blocks);
-}
-
-int __init i915_buddy_module_init(void)
-{
- slab_blocks = KMEM_CACHE(i915_buddy_block, 0);
- if (!slab_blocks)
- return -ENOMEM;
-
- return 0;
-}
diff --git a/drivers/gpu/drm/i915/i915_buddy.h b/drivers/gpu/drm/i915/i915_buddy.h
deleted file mode 100644
index 7077742112ac..000000000000
--- a/drivers/gpu/drm/i915/i915_buddy.h
+++ /dev/null
@@ -1,143 +0,0 @@
-/* SPDX-License-Identifier: MIT */
-/*
- * Copyright © 2021 Intel Corporation
- */
-
-#ifndef __I915_BUDDY_H__
-#define __I915_BUDDY_H__
-
-#include <linux/bitops.h>
-#include <linux/list.h>
-#include <linux/slab.h>
-
-#include <drm/drm_print.h>
-
-struct i915_buddy_block {
-#define I915_BUDDY_HEADER_OFFSET GENMASK_ULL(63, 12)
-#define I915_BUDDY_HEADER_STATE GENMASK_ULL(11, 10)
-#define I915_BUDDY_ALLOCATED (1 << 10)
-#define I915_BUDDY_FREE (2 << 10)
-#define I915_BUDDY_SPLIT (3 << 10)
-/* Free to be used, if needed in the future */
-#define I915_BUDDY_HEADER_UNUSED GENMASK_ULL(9, 6)
-#define I915_BUDDY_HEADER_ORDER GENMASK_ULL(5, 0)
- u64 header;
-
- struct i915_buddy_block *left;
- struct i915_buddy_block *right;
- struct i915_buddy_block *parent;
-
- void *private; /* owned by creator */
-
- /*
- * While the block is allocated by the user through i915_buddy_alloc*,
- * the user has ownership of the link, for example to maintain within
- * a list, if so desired. As soon as the block is freed with
- * i915_buddy_free* ownership is given back to the mm.
- */
- struct list_head link;
- struct list_head tmp_link;
-};
-
-/* Order-zero must be at least PAGE_SIZE */
-#define I915_BUDDY_MAX_ORDER (63 - PAGE_SHIFT)
-
-/*
- * Binary Buddy System.
- *
- * Locking should be handled by the user, a simple mutex around
- * i915_buddy_alloc* and i915_buddy_free* should suffice.
- */
-struct i915_buddy_mm {
- /* Maintain a free list for each order. */
- struct list_head *free_list;
-
- /*
- * Maintain explicit binary tree(s) to track the allocation of the
- * address space. This gives us a simple way of finding a buddy block
- * and performing the potentially recursive merge step when freeing a
- * block. Nodes are either allocated or free, in which case they will
- * also exist on the respective free list.
- */
- struct i915_buddy_block **roots;
-
- /*
- * Anything from here is public, and remains static for the lifetime of
- * the mm. Everything above is considered do-not-touch.
- */
- unsigned int n_roots;
- unsigned int max_order;
-
- /* Must be at least PAGE_SIZE */
- u64 chunk_size;
- u64 size;
- u64 avail;
-};
-
-static inline u64
-i915_buddy_block_offset(struct i915_buddy_block *block)
-{
- return block->header & I915_BUDDY_HEADER_OFFSET;
-}
-
-static inline unsigned int
-i915_buddy_block_order(struct i915_buddy_block *block)
-{
- return block->header & I915_BUDDY_HEADER_ORDER;
-}
-
-static inline unsigned int
-i915_buddy_block_state(struct i915_buddy_block *block)
-{
- return block->header & I915_BUDDY_HEADER_STATE;
-}
-
-static inline bool
-i915_buddy_block_is_allocated(struct i915_buddy_block *block)
-{
- return i915_buddy_block_state(block) == I915_BUDDY_ALLOCATED;
-}
-
-static inline bool
-i915_buddy_block_is_free(struct i915_buddy_block *block)
-{
- return i915_buddy_block_state(block) == I915_BUDDY_FREE;
-}
-
-static inline bool
-i915_buddy_block_is_split(struct i915_buddy_block *block)
-{
- return i915_buddy_block_state(block) == I915_BUDDY_SPLIT;
-}
-
-static inline u64
-i915_buddy_block_size(struct i915_buddy_mm *mm,
- struct i915_buddy_block *block)
-{
- return mm->chunk_size << i915_buddy_block_order(block);
-}
-
-int i915_buddy_init(struct i915_buddy_mm *mm, u64 size, u64 chunk_size);
-
-void i915_buddy_fini(struct i915_buddy_mm *mm);
-
-struct i915_buddy_block *
-i915_buddy_alloc(struct i915_buddy_mm *mm, unsigned int order);
-
-int i915_buddy_alloc_range(struct i915_buddy_mm *mm,
- struct list_head *blocks,
- u64 start, u64 size);
-
-void i915_buddy_free(struct i915_buddy_mm *mm, struct i915_buddy_block *block);
-
-void i915_buddy_free_list(struct i915_buddy_mm *mm, struct list_head *objects);
-
-void i915_buddy_print(struct i915_buddy_mm *mm, struct drm_printer *p);
-void i915_buddy_block_print(struct i915_buddy_mm *mm,
- struct i915_buddy_block *block,
- struct drm_printer *p);
-
-void i915_buddy_module_exit(void);
-int i915_buddy_module_init(void);
-
-#endif
diff --git a/drivers/gpu/drm/i915/i915_module.c b/drivers/gpu/drm/i915/i915_module.c
index c7507266aa83..355681dbd7a8 100644
--- a/drivers/gpu/drm/i915/i915_module.c
+++ b/drivers/gpu/drm/i915/i915_module.c
@@ -9,7 +9,6 @@
#include "gem/i915_gem_context.h"
#include "gem/i915_gem_object.h"
#include "i915_active.h"
-#include "i915_buddy.h"
#include "i915_params.h"
#include "i915_pci.h"
#include "i915_perf.h"
@@ -50,8 +49,6 @@ static const struct {
{ .init = i915_check_nomodeset },
{ .init = i915_active_module_init,
.exit = i915_active_module_exit },
- { .init = i915_buddy_module_init,
- .exit = i915_buddy_module_exit },
{ .init = i915_context_module_init,
.exit = i915_context_module_exit },
{ .init = i915_gem_context_module_init,
diff --git a/drivers/gpu/drm/i915/i915_scatterlist.c b/drivers/gpu/drm/i915/i915_scatterlist.c
index 4a6712dca838..84d622aa32d2 100644
--- a/drivers/gpu/drm/i915/i915_scatterlist.c
+++ b/drivers/gpu/drm/i915/i915_scatterlist.c
@@ -5,10 +5,9 @@
*/
#include "i915_scatterlist.h"
-
-#include "i915_buddy.h"
#include "i915_ttm_buddy_manager.h"
+#include <drm/drm_buddy.h>
#include <drm/drm_mm.h>
#include <linux/slab.h>
@@ -126,9 +125,9 @@ struct sg_table *i915_sg_from_buddy_resource(struct ttm_resource *res,
struct i915_ttm_buddy_resource *bman_res = to_ttm_buddy_resource(res);
const u64 size = res->num_pages << PAGE_SHIFT;
const u64 max_segment = rounddown(UINT_MAX, PAGE_SIZE);
- struct i915_buddy_mm *mm = bman_res->mm;
+ struct drm_buddy_mm *mm = bman_res->mm;
struct list_head *blocks = &bman_res->blocks;
- struct i915_buddy_block *block;
+ struct drm_buddy_block *block;
struct scatterlist *sg;
struct sg_table *st;
resource_size_t prev_end;
@@ -151,8 +150,8 @@ struct sg_table *i915_sg_from_buddy_resource(struct ttm_resource *res,
list_for_each_entry(block, blocks, link) {
u64 block_size, offset;
- block_size = min_t(u64, size, i915_buddy_block_size(mm, block));
- offset = i915_buddy_block_offset(block);
+ block_size = min_t(u64, size, drm_buddy_block_size(mm, block));
+ offset = drm_buddy_block_offset(block);
while (block_size) {
u64 len;
diff --git a/drivers/gpu/drm/i915/i915_ttm_buddy_manager.c b/drivers/gpu/drm/i915/i915_ttm_buddy_manager.c
index d59fbb019032..c4b70cb8c248 100644
--- a/drivers/gpu/drm/i915/i915_ttm_buddy_manager.c
+++ b/drivers/gpu/drm/i915/i915_ttm_buddy_manager.c
@@ -8,14 +8,15 @@
#include <drm/ttm/ttm_bo_driver.h>
#include <drm/ttm/ttm_placement.h>
+#include <drm/drm_buddy.h>
+
#include "i915_ttm_buddy_manager.h"
-#include "i915_buddy.h"
#include "i915_gem.h"
struct i915_ttm_buddy_manager {
struct ttm_resource_manager manager;
- struct i915_buddy_mm mm;
+ struct drm_buddy_mm mm;
struct list_head reserved;
struct mutex lock;
u64 default_page_size;
@@ -34,7 +35,7 @@ static int i915_ttm_buddy_man_alloc(struct ttm_resource_manager *man,
{
struct i915_ttm_buddy_manager *bman = to_buddy_manager(man);
struct i915_ttm_buddy_resource *bman_res;
- struct i915_buddy_mm *mm = &bman->mm;
+ struct drm_buddy_mm *mm = &bman->mm;
unsigned long n_pages;
unsigned int min_order;
u64 min_page_size;
@@ -73,7 +74,7 @@ static int i915_ttm_buddy_man_alloc(struct ttm_resource_manager *man,
n_pages = size >> ilog2(mm->chunk_size);
do {
- struct i915_buddy_block *block;
+ struct drm_buddy_block *block;
unsigned int order;
order = fls(n_pages) - 1;
@@ -82,7 +83,7 @@ static int i915_ttm_buddy_man_alloc(struct ttm_resource_manager *man,
do {
mutex_lock(&bman->lock);
- block = i915_buddy_alloc(mm, order);
+ block = drm_buddy_alloc(mm, order);
mutex_unlock(&bman->lock);
if (!IS_ERR(block))
break;
@@ -106,7 +107,7 @@ static int i915_ttm_buddy_man_alloc(struct ttm_resource_manager *man,
err_free_blocks:
mutex_lock(&bman->lock);
- i915_buddy_free_list(mm, &bman_res->blocks);
+ drm_buddy_free_list(mm, &bman_res->blocks);
mutex_unlock(&bman->lock);
err_free_res:
kfree(bman_res);
@@ -120,7 +121,7 @@ static void i915_ttm_buddy_man_free(struct ttm_resource_manager *man,
struct i915_ttm_buddy_manager *bman = to_buddy_manager(man);
mutex_lock(&bman->lock);
- i915_buddy_free_list(&bman->mm, &bman_res->blocks);
+ drm_buddy_free_list(&bman->mm, &bman_res->blocks);
mutex_unlock(&bman->lock);
kfree(bman_res);
@@ -130,17 +131,17 @@ static void i915_ttm_buddy_man_debug(struct ttm_resource_manager *man,
struct drm_printer *printer)
{
struct i915_ttm_buddy_manager *bman = to_buddy_manager(man);
- struct i915_buddy_block *block;
+ struct drm_buddy_block *block;
mutex_lock(&bman->lock);
drm_printf(printer, "default_page_size: %lluKiB\n",
bman->default_page_size >> 10);
- i915_buddy_print(&bman->mm, printer);
+ drm_buddy_print(&bman->mm, printer);
drm_printf(printer, "reserved:\n");
list_for_each_entry(block, &bman->reserved, link)
- i915_buddy_block_print(&bman->mm, block, printer);
+ drm_buddy_block_print(&bman->mm, block, printer);
mutex_unlock(&bman->lock);
}
@@ -190,7 +191,7 @@ int i915_ttm_buddy_man_init(struct ttm_device *bdev,
if (!bman)
return -ENOMEM;
- err = i915_buddy_init(&bman->mm, size, chunk_size);
+ err = drm_buddy_init(&bman->mm, size, chunk_size);
if (err)
goto err_free_bman;
@@ -228,7 +229,7 @@ int i915_ttm_buddy_man_fini(struct ttm_device *bdev, unsigned int type)
{
struct ttm_resource_manager *man = ttm_manager_type(bdev, type);
struct i915_ttm_buddy_manager *bman = to_buddy_manager(man);
- struct i915_buddy_mm *mm = &bman->mm;
+ struct drm_buddy_mm *mm = &bman->mm;
int ret;
ttm_resource_manager_set_used(man, false);
@@ -240,8 +241,8 @@ int i915_ttm_buddy_man_fini(struct ttm_device *bdev, unsigned int type)
ttm_set_driver_manager(bdev, type, NULL);
mutex_lock(&bman->lock);
- i915_buddy_free_list(mm, &bman->reserved);
- i915_buddy_fini(mm);
+ drm_buddy_free_list(mm, &bman->reserved);
+ drm_buddy_fini(mm);
mutex_unlock(&bman->lock);
ttm_resource_manager_cleanup(man);
@@ -264,11 +265,11 @@ int i915_ttm_buddy_man_reserve(struct ttm_resource_manager *man,
u64 start, u64 size)
{
struct i915_ttm_buddy_manager *bman = to_buddy_manager(man);
- struct i915_buddy_mm *mm = &bman->mm;
+ struct drm_buddy_mm *mm = &bman->mm;
int ret;
mutex_lock(&bman->lock);
- ret = i915_buddy_alloc_range(mm, &bman->reserved, start, size);
+ ret = drm_buddy_alloc_range(mm, &bman->reserved, start, size);
mutex_unlock(&bman->lock);
return ret;
diff --git a/drivers/gpu/drm/i915/i915_ttm_buddy_manager.h b/drivers/gpu/drm/i915/i915_ttm_buddy_manager.h
index 0722d33f3e14..fa644b512c2e 100644
--- a/drivers/gpu/drm/i915/i915_ttm_buddy_manager.h
+++ b/drivers/gpu/drm/i915/i915_ttm_buddy_manager.h
@@ -13,7 +13,7 @@
struct ttm_device;
struct ttm_resource_manager;
-struct i915_buddy_mm;
+struct drm_buddy_mm;
/**
* struct i915_ttm_buddy_resource
@@ -28,7 +28,7 @@ struct i915_buddy_mm;
struct i915_ttm_buddy_resource {
struct ttm_resource base;
struct list_head blocks;
- struct i915_buddy_mm *mm;
+ struct drm_buddy_mm *mm;
};
/**
diff --git a/include/drm/drm_buddy.h b/include/drm/drm_buddy.h
new file mode 100644
index 000000000000..5ce3fc702f80
--- /dev/null
+++ b/include/drm/drm_buddy.h
@@ -0,0 +1,153 @@
+/* SPDX-License-Identifier: MIT */
+/*
+ * Copyright © 2021 Intel Corporation
+ */
+
+#ifndef __DRM_BUDDY_H__
+#define __DRM_BUDDY_H__
+
+#include <linux/bitops.h>
+#include <linux/list.h>
+#include <linux/slab.h>
+#include <linux/sched.h>
+
+#include <drm/drm_print.h>
+
+#define range_overflows(start, size, max) ({ \
+ typeof(start) start__ = (start); \
+ typeof(size) size__ = (size); \
+ typeof(max) max__ = (max); \
+ (void)(&start__ == &size__); \
+ (void)(&start__ == &max__); \
+ start__ >= max__ || size__ > max__ - start__; \
+})
+
+struct drm_buddy_block {
+#define DRM_BUDDY_HEADER_OFFSET GENMASK_ULL(63, 12)
+#define DRM_BUDDY_HEADER_STATE GENMASK_ULL(11, 10)
+#define DRM_BUDDY_ALLOCATED (1 << 10)
+#define DRM_BUDDY_FREE (2 << 10)
+#define DRM_BUDDY_SPLIT (3 << 10)
+/* Free to be used, if needed in the future */
+#define DRM_BUDDY_HEADER_UNUSED GENMASK_ULL(9, 6)
+#define DRM_BUDDY_HEADER_ORDER GENMASK_ULL(5, 0)
+ u64 header;
+
+ struct drm_buddy_block *left;
+ struct drm_buddy_block *right;
+ struct drm_buddy_block *parent;
+
+ void *private; /* owned by creator */
+
+ /*
+ * While the block is allocated by the user through drm_buddy_alloc*,
+ * the user has ownership of the link, for example to maintain within
+ * a list, if so desired. As soon as the block is freed with
+ * drm_buddy_free* ownership is given back to the mm.
+ */
+ struct list_head link;
+ struct list_head tmp_link;
+};
+
+/* Order-zero must be at least PAGE_SIZE */
+#define DRM_BUDDY_MAX_ORDER (63 - PAGE_SHIFT)
+
+/*
+ * Binary Buddy System.
+ *
+ * Locking should be handled by the user, a simple mutex around
+ * drm_buddy_alloc* and drm_buddy_free* should suffice.
+ */
+struct drm_buddy_mm {
+ /* Maintain a free list for each order. */
+ struct list_head *free_list;
+
+ /*
+ * Maintain explicit binary tree(s) to track the allocation of the
+ * address space. This gives us a simple way of finding a buddy block
+ * and performing the potentially recursive merge step when freeing a
+ * block. Nodes are either allocated or free, in which case they will
+ * also exist on the respective free list.
+ */
+ struct drm_buddy_block **roots;
+
+ /*
+ * Anything from here is public, and remains static for the lifetime of
+ * the mm. Everything above is considered do-not-touch.
+ */
+ unsigned int n_roots;
+ unsigned int max_order;
+
+ /* Must be at least PAGE_SIZE */
+ u64 chunk_size;
+ u64 size;
+ u64 avail;
+};
+
+static inline u64
+drm_buddy_block_offset(struct drm_buddy_block *block)
+{
+ return block->header & DRM_BUDDY_HEADER_OFFSET;
+}
+
+static inline unsigned int
+drm_buddy_block_order(struct drm_buddy_block *block)
+{
+ return block->header & DRM_BUDDY_HEADER_ORDER;
+}
+
+static inline unsigned int
+drm_buddy_block_state(struct drm_buddy_block *block)
+{
+ return block->header & DRM_BUDDY_HEADER_STATE;
+}
+
+static inline bool
+drm_buddy_block_is_allocated(struct drm_buddy_block *block)
+{
+ return drm_buddy_block_state(block) == DRM_BUDDY_ALLOCATED;
+}
+
+static inline bool
+drm_buddy_block_is_free(struct drm_buddy_block *block)
+{
+ return drm_buddy_block_state(block) == DRM_BUDDY_FREE;
+}
+
+static inline bool
+drm_buddy_block_is_split(struct drm_buddy_block *block)
+{
+ return drm_buddy_block_state(block) == DRM_BUDDY_SPLIT;
+}
+
+static inline u64
+drm_buddy_block_size(struct drm_buddy_mm *mm,
+ struct drm_buddy_block *block)
+{
+ return mm->chunk_size << drm_buddy_block_order(block);
+}
+
+int drm_buddy_init(struct drm_buddy_mm *mm, u64 size, u64 chunk_size);
+
+void drm_buddy_fini(struct drm_buddy_mm *mm);
+
+struct drm_buddy_block *
+drm_buddy_alloc(struct drm_buddy_mm *mm, unsigned int order);
+
+int drm_buddy_alloc_range(struct drm_buddy_mm *mm,
+ struct list_head *blocks,
+ u64 start, u64 size);
+
+void drm_buddy_free(struct drm_buddy_mm *mm, struct drm_buddy_block *block);
+
+void drm_buddy_free_list(struct drm_buddy_mm *mm, struct list_head *objects);
+
+void drm_buddy_print(struct drm_buddy_mm *mm, struct drm_printer *p);
+void drm_buddy_block_print(struct drm_buddy_mm *mm,
+ struct drm_buddy_block *block,
+ struct drm_printer *p);
+
+void drm_buddy_module_exit(void);
+int drm_buddy_module_init(void);
+
+#endif
--
2.25.1
^ permalink raw reply related [flat|nested] 46+ messages in thread
* [PATCH v3 2/6] drm: improve drm_buddy_alloc function
2021-11-16 20:18 ` Arunpravin
(?)
@ 2021-11-16 20:18 ` Arunpravin
-1 siblings, 0 replies; 46+ messages in thread
From: Arunpravin @ 2021-11-16 20:18 UTC (permalink / raw)
To: dri-devel, intel-gfx, amd-gfx
Cc: Arunpravin, matthew.auld, tzimmermann, alexander.deucher,
christian.koenig
- Make drm_buddy_alloc a single function to handle
range allocation and non-range allocation demands
- Implemented a new function alloc_range() which allocates
the requested power-of-two block comply with range limitations
- Moved order computation and memory alignment logic from
i915 driver to drm buddy
v2:
merged below changes to keep the build unbroken
- drm_buddy_alloc_range() becomes obsolete and may be removed
- enable ttm range allocation (fpfn / lpfn) support in i915 driver
- apply enhanced drm_buddy_alloc() function to i915 driver
v3(Matthew Auld):
- Fix alignment issues and remove unnecessary list_empty check
- add more validation checks for input arguments
- make alloc_range() block allocations as bottom-up
- optimize order computation logic
- replace uint64_t with u64, which is preferred in the kernel
Signed-off-by: Arunpravin <Arunpravin.PaneerSelvam@amd.com>
---
drivers/gpu/drm/drm_buddy.c | 259 ++++++++++--------
drivers/gpu/drm/i915/i915_ttm_buddy_manager.c | 69 ++---
drivers/gpu/drm/i915/i915_ttm_buddy_manager.h | 2 +
include/drm/drm_buddy.h | 22 +-
4 files changed, 203 insertions(+), 149 deletions(-)
diff --git a/drivers/gpu/drm/drm_buddy.c b/drivers/gpu/drm/drm_buddy.c
index 39eb1d224bec..c9b18a29f8d1 100644
--- a/drivers/gpu/drm/drm_buddy.c
+++ b/drivers/gpu/drm/drm_buddy.c
@@ -274,63 +274,6 @@ void drm_buddy_free_list(struct drm_buddy_mm *mm, struct list_head *objects)
}
EXPORT_SYMBOL(drm_buddy_free_list);
-/**
- * drm_buddy_alloc - allocate power-of-two blocks
- *
- * @mm: DRM buddy manager to allocate from
- * @order: size of the allocation
- *
- * The order value here translates to:
- *
- * 0 = 2^0 * mm->chunk_size
- * 1 = 2^1 * mm->chunk_size
- * 2 = 2^2 * mm->chunk_size
- *
- * Returns:
- * allocated ptr to the &drm_buddy_block on success
- */
-struct drm_buddy_block *
-drm_buddy_alloc(struct drm_buddy_mm *mm, unsigned int order)
-{
- struct drm_buddy_block *block = NULL;
- unsigned int i;
- int err;
-
- for (i = order; i <= mm->max_order; ++i) {
- block = list_first_entry_or_null(&mm->free_list[i],
- struct drm_buddy_block,
- link);
- if (block)
- break;
- }
-
- if (!block)
- return ERR_PTR(-ENOSPC);
-
- BUG_ON(!drm_buddy_block_is_free(block));
-
- while (i != order) {
- err = split_block(mm, block);
- if (unlikely(err))
- goto out_free;
-
- /* Go low */
- block = block->left;
- i--;
- }
-
- mark_allocated(block);
- mm->avail -= drm_buddy_block_size(mm, block);
- kmemleak_update_trace(block);
- return block;
-
-out_free:
- if (i != order)
- __drm_buddy_free(mm, block);
- return ERR_PTR(err);
-}
-EXPORT_SYMBOL(drm_buddy_alloc);
-
static inline bool overlaps(u64 s1, u64 e1, u64 s2, u64 e2)
{
return s1 <= e2 && e1 >= s2;
@@ -341,52 +284,22 @@ static inline bool contains(u64 s1, u64 e1, u64 s2, u64 e2)
return s1 <= s2 && e1 >= e2;
}
-/**
- * drm_buddy_alloc_range - allocate range
- *
- * @mm: DRM buddy manager to allocate from
- * @blocks: output list head to add allocated blocks
- * @start: start of the allowed range for this block
- * @size: size of the allocation
- *
- * Intended for pre-allocating portions of the address space, for example to
- * reserve a block for the initial framebuffer or similar, hence the expectation
- * here is that drm_buddy_alloc() is still the main vehicle for
- * allocations, so if that's not the case then the drm_mm range allocator is
- * probably a much better fit, and so you should probably go use that instead.
- *
- * Note that it's safe to chain together multiple alloc_ranges
- * with the same blocks list
- *
- * Returns:
- * 0 on success, error code on failure.
- */
-int drm_buddy_alloc_range(struct drm_buddy_mm *mm,
- struct list_head *blocks,
- u64 start, u64 size)
+static struct drm_buddy_block *
+alloc_range(struct drm_buddy_mm *mm,
+ u64 start, u64 end,
+ unsigned int order)
{
struct drm_buddy_block *block;
struct drm_buddy_block *buddy;
- LIST_HEAD(allocated);
LIST_HEAD(dfs);
- u64 end;
int err;
int i;
- if (size < mm->chunk_size)
- return -EINVAL;
-
- if (!IS_ALIGNED(size | start, mm->chunk_size))
- return -EINVAL;
-
- if (range_overflows(start, size, mm->size))
- return -EINVAL;
+ end = end - 1;
for (i = 0; i < mm->n_roots; ++i)
list_add_tail(&mm->roots[i]->tmp_link, &dfs);
- end = start + size - 1;
-
do {
u64 block_start;
u64 block_end;
@@ -399,26 +312,26 @@ int drm_buddy_alloc_range(struct drm_buddy_mm *mm,
list_del(&block->tmp_link);
+ if (drm_buddy_block_order(block) < order)
+ continue;
+
block_start = drm_buddy_block_offset(block);
block_end = block_start + drm_buddy_block_size(mm, block) - 1;
if (!overlaps(start, end, block_start, block_end))
continue;
- if (drm_buddy_block_is_allocated(block)) {
- err = -ENOSPC;
- goto err_free;
- }
+ if (drm_buddy_block_is_allocated(block))
+ continue;
- if (contains(start, end, block_start, block_end)) {
- if (!drm_buddy_block_is_free(block)) {
- err = -ENOSPC;
- goto err_free;
- }
+ if (contains(start, end, block_start, block_end) &&
+ order == drm_buddy_block_order(block)) {
+ /*
+ * Find the free block within the range.
+ */
+ if (drm_buddy_block_is_free(block))
+ return block;
- mark_allocated(block);
- mm->avail -= drm_buddy_block_size(mm, block);
- list_add_tail(&block->link, &allocated);
continue;
}
@@ -432,8 +345,7 @@ int drm_buddy_alloc_range(struct drm_buddy_mm *mm,
list_add(&block->left->tmp_link, &dfs);
} while (1);
- list_splice_tail(&allocated, blocks);
- return 0;
+ return ERR_PTR(-ENOSPC);
err_undo:
/*
@@ -446,12 +358,145 @@ int drm_buddy_alloc_range(struct drm_buddy_mm *mm,
(drm_buddy_block_is_free(block) &&
drm_buddy_block_is_free(buddy)))
__drm_buddy_free(mm, block);
+ return ERR_PTR(err);
+}
+
+static struct drm_buddy_block *
+alloc_from_freelist(struct drm_buddy_mm *mm,
+ unsigned int order,
+ unsigned long flags)
+{
+ struct drm_buddy_block *block = NULL;
+ unsigned int i;
+ int err;
+
+ for (i = order; i <= mm->max_order; ++i) {
+ block = list_first_entry_or_null(&mm->free_list[i],
+ struct drm_buddy_block,
+ link);
+ if (block)
+ break;
+ }
+
+ if (!block)
+ return ERR_PTR(-ENOSPC);
+
+ BUG_ON(!drm_buddy_block_is_free(block));
+
+ while (i != order) {
+ err = split_block(mm, block);
+ if (unlikely(err))
+ goto err_undo;
+
+ block = block->right;
+ i--;
+ }
+ return block;
+
+err_undo:
+ if (i != order)
+ __drm_buddy_free(mm, block);
+ return ERR_PTR(err);
+}
+
+/**
+ * drm_buddy_alloc - allocate power-of-two blocks
+ *
+ * @mm: DRM buddy manager to allocate from
+ * @start: start of the allowed range for this block
+ * @end: end of the allowed range for this block
+ * @size: size of the allocation
+ * @min_page_size: alignment of the allocation
+ * @blocks: output list head to add allocated blocks
+ * @flags: DRM_BUDDY_*_ALLOCATION flags
+ *
+ * alloc_range() called on range limitations, which traverses
+ * the tree and returns the desired block.
+ *
+ * alloc_from_freelist() called when *no* range restrictions
+ * are enforced, which picks the block from the freelist.
+ *
+ * blocks are allocated in order, the order value here translates to:
+ *
+ * 0 = 2^0 * mm->chunk_size
+ * 1 = 2^1 * mm->chunk_size
+ * 2 = 2^2 * mm->chunk_size
+ *
+ * Returns:
+ * 0 on success, error code on failure.
+ */
+int drm_buddy_alloc(struct drm_buddy_mm *mm,
+ u64 start, u64 end, u64 size,
+ u64 min_page_size,
+ struct list_head *blocks,
+ unsigned long flags)
+{
+ struct drm_buddy_block *block = NULL;
+ unsigned int min_order, order;
+ unsigned long pages;
+ LIST_HEAD(allocated);
+ int err;
+
+ if (size < mm->chunk_size)
+ return -EINVAL;
+
+ if (min_page_size < mm->chunk_size)
+ return -EINVAL;
+
+ if (!is_power_of_2(min_page_size))
+ return -EINVAL;
+
+ if (!IS_ALIGNED(start | end | size, mm->chunk_size))
+ return -EINVAL;
+
+ if (check_range_overflow(start, end, size, mm->size))
+ return -EINVAL;
+
+ pages = size >> ilog2(mm->chunk_size);
+ order = fls(pages) - 1;
+ min_order = ilog2(min_page_size) - ilog2(mm->chunk_size);
+
+ do {
+ order = min(order, (unsigned int)fls(pages) - 1);
+ BUG_ON(order > mm->max_order);
+ BUG_ON(order < min_order);
+
+ do {
+ if (flags & DRM_BUDDY_RANGE_ALLOCATION)
+ /* Allocate traversing within the range */
+ block = alloc_range(mm, start, end, order);
+ else
+ /* Allocate from freelist */
+ block = alloc_from_freelist(mm, order, flags);
+
+ if (!IS_ERR(block))
+ break;
+
+ if (order-- == min_order) {
+ err = -ENOSPC;
+ goto err_free;
+ }
+ } while (1);
+
+ mark_allocated(block);
+ mm->avail -= drm_buddy_block_size(mm, block);
+ kmemleak_update_trace(block);
+ list_add_tail(&block->link, &allocated);
+
+ pages -= BIT(order);
+
+ if (!pages)
+ break;
+ } while (1);
+
+ list_splice_tail(&allocated, blocks);
+ return 0;
err_free:
drm_buddy_free_list(mm, &allocated);
return err;
}
-EXPORT_SYMBOL(drm_buddy_alloc_range);
+EXPORT_SYMBOL(drm_buddy_alloc);
/**
* drm_buddy_block_print - print block information
diff --git a/drivers/gpu/drm/i915/i915_ttm_buddy_manager.c b/drivers/gpu/drm/i915/i915_ttm_buddy_manager.c
index c4b70cb8c248..9e3d130c3f42 100644
--- a/drivers/gpu/drm/i915/i915_ttm_buddy_manager.c
+++ b/drivers/gpu/drm/i915/i915_ttm_buddy_manager.c
@@ -36,13 +36,14 @@ static int i915_ttm_buddy_man_alloc(struct ttm_resource_manager *man,
struct i915_ttm_buddy_manager *bman = to_buddy_manager(man);
struct i915_ttm_buddy_resource *bman_res;
struct drm_buddy_mm *mm = &bman->mm;
- unsigned long n_pages;
- unsigned int min_order;
+ unsigned long n_pages, lpfn;
u64 min_page_size;
u64 size;
int err;
- GEM_BUG_ON(place->fpfn || place->lpfn);
+ lpfn = place->lpfn;
+ if (!lpfn)
+ lpfn = man->size;
bman_res = kzalloc(sizeof(*bman_res), GFP_KERNEL);
if (!bman_res)
@@ -52,6 +53,9 @@ static int i915_ttm_buddy_man_alloc(struct ttm_resource_manager *man,
INIT_LIST_HEAD(&bman_res->blocks);
bman_res->mm = mm;
+ if (place->fpfn || lpfn != man->size)
+ bman_res->flags |= DRM_BUDDY_RANGE_ALLOCATION;
+
GEM_BUG_ON(!bman_res->base.num_pages);
size = bman_res->base.num_pages << PAGE_SHIFT;
@@ -60,10 +64,16 @@ static int i915_ttm_buddy_man_alloc(struct ttm_resource_manager *man,
min_page_size = bo->page_alignment << PAGE_SHIFT;
GEM_BUG_ON(min_page_size < mm->chunk_size);
- min_order = ilog2(min_page_size) - ilog2(mm->chunk_size);
+
if (place->flags & TTM_PL_FLAG_CONTIGUOUS) {
+ unsigned long pages;
+
size = roundup_pow_of_two(size);
- min_order = ilog2(size) - ilog2(mm->chunk_size);
+ min_page_size = size;
+
+ pages = size >> ilog2(mm->chunk_size);
+ if (pages > lpfn)
+ lpfn = pages;
}
if (size > mm->size) {
@@ -73,34 +83,16 @@ static int i915_ttm_buddy_man_alloc(struct ttm_resource_manager *man,
n_pages = size >> ilog2(mm->chunk_size);
- do {
- struct drm_buddy_block *block;
- unsigned int order;
-
- order = fls(n_pages) - 1;
- GEM_BUG_ON(order > mm->max_order);
- GEM_BUG_ON(order < min_order);
-
- do {
- mutex_lock(&bman->lock);
- block = drm_buddy_alloc(mm, order);
- mutex_unlock(&bman->lock);
- if (!IS_ERR(block))
- break;
-
- if (order-- == min_order) {
- err = -ENOSPC;
- goto err_free_blocks;
- }
- } while (1);
-
- n_pages -= BIT(order);
-
- list_add_tail(&block->link, &bman_res->blocks);
-
- if (!n_pages)
- break;
- } while (1);
+ mutex_lock(&bman->lock);
+ err = drm_buddy_alloc(mm, (u64)place->fpfn << PAGE_SHIFT,
+ (u64)place->lpfn << PAGE_SHIFT,
+ (u64)n_pages << PAGE_SHIFT,
+ min_page_size,
+ &bman_res->blocks,
+ bman_res->flags);
+ mutex_unlock(&bman->lock);
+ if (unlikely(err))
+ goto err_free_blocks;
*res = &bman_res->base;
return 0;
@@ -266,10 +258,19 @@ int i915_ttm_buddy_man_reserve(struct ttm_resource_manager *man,
{
struct i915_ttm_buddy_manager *bman = to_buddy_manager(man);
struct drm_buddy_mm *mm = &bman->mm;
+ unsigned long flags = 0;
+ u64 min_size;
int ret;
+ min_size = size;
+ flags |= DRM_BUDDY_RANGE_ALLOCATION;
+
mutex_lock(&bman->lock);
- ret = drm_buddy_alloc_range(mm, &bman->reserved, start, size);
+ ret = drm_buddy_alloc(mm, start,
+ start + size,
+ size, min_size,
+ &bman->reserved,
+ flags);
mutex_unlock(&bman->lock);
return ret;
diff --git a/drivers/gpu/drm/i915/i915_ttm_buddy_manager.h b/drivers/gpu/drm/i915/i915_ttm_buddy_manager.h
index fa644b512c2e..5ba490875f66 100644
--- a/drivers/gpu/drm/i915/i915_ttm_buddy_manager.h
+++ b/drivers/gpu/drm/i915/i915_ttm_buddy_manager.h
@@ -20,6 +20,7 @@ struct drm_buddy_mm;
*
* @base: struct ttm_resource base class we extend
* @blocks: the list of struct i915_buddy_block for this resource/allocation
+ * @flags: DRM_BUDDY_*_ALLOCATION flags
* @mm: the struct i915_buddy_mm for this resource
*
* Extends the struct ttm_resource to manage an address space allocation with
@@ -28,6 +29,7 @@ struct drm_buddy_mm;
struct i915_ttm_buddy_resource {
struct ttm_resource base;
struct list_head blocks;
+ unsigned long flags;
struct drm_buddy_mm *mm;
};
diff --git a/include/drm/drm_buddy.h b/include/drm/drm_buddy.h
index 5ce3fc702f80..2ec3cbc9d5d7 100644
--- a/include/drm/drm_buddy.h
+++ b/include/drm/drm_buddy.h
@@ -13,15 +13,22 @@
#include <drm/drm_print.h>
-#define range_overflows(start, size, max) ({ \
+#define check_range_overflow(start, end, size, max) ({ \
typeof(start) start__ = (start); \
+ typeof(end) end__ = (end);\
typeof(size) size__ = (size); \
typeof(max) max__ = (max); \
(void)(&start__ == &size__); \
(void)(&start__ == &max__); \
- start__ >= max__ || size__ > max__ - start__; \
+ (void)(&start__ == &end__); \
+ (void)(&end__ == &size__); \
+ (void)(&end__ == &max__); \
+ start__ >= max__ || end__ > max__ || \
+ size__ > end__ - start__; \
})
+#define DRM_BUDDY_RANGE_ALLOCATION (1 << 0)
+
struct drm_buddy_block {
#define DRM_BUDDY_HEADER_OFFSET GENMASK_ULL(63, 12)
#define DRM_BUDDY_HEADER_STATE GENMASK_ULL(11, 10)
@@ -131,12 +138,11 @@ int drm_buddy_init(struct drm_buddy_mm *mm, u64 size, u64 chunk_size);
void drm_buddy_fini(struct drm_buddy_mm *mm);
-struct drm_buddy_block *
-drm_buddy_alloc(struct drm_buddy_mm *mm, unsigned int order);
-
-int drm_buddy_alloc_range(struct drm_buddy_mm *mm,
- struct list_head *blocks,
- u64 start, u64 size);
+int drm_buddy_alloc(struct drm_buddy_mm *mm,
+ u64 start, u64 end, u64 size,
+ u64 min_page_size,
+ struct list_head *blocks,
+ unsigned long flags);
void drm_buddy_free(struct drm_buddy_mm *mm, struct drm_buddy_block *block);
--
2.25.1
^ permalink raw reply related [flat|nested] 46+ messages in thread
* [PATCH v3 2/6] drm: improve drm_buddy_alloc function
@ 2021-11-16 20:18 ` Arunpravin
0 siblings, 0 replies; 46+ messages in thread
From: Arunpravin @ 2021-11-16 20:18 UTC (permalink / raw)
To: dri-devel, intel-gfx, amd-gfx
Cc: daniel, Arunpravin, jani.nikula, matthew.auld, tzimmermann,
alexander.deucher, christian.koenig
- Make drm_buddy_alloc a single function to handle
range allocation and non-range allocation demands
- Implemented a new function alloc_range() which allocates
the requested power-of-two block comply with range limitations
- Moved order computation and memory alignment logic from
i915 driver to drm buddy
v2:
merged below changes to keep the build unbroken
- drm_buddy_alloc_range() becomes obsolete and may be removed
- enable ttm range allocation (fpfn / lpfn) support in i915 driver
- apply enhanced drm_buddy_alloc() function to i915 driver
v3(Matthew Auld):
- Fix alignment issues and remove unnecessary list_empty check
- add more validation checks for input arguments
- make alloc_range() block allocations as bottom-up
- optimize order computation logic
- replace uint64_t with u64, which is preferred in the kernel
Signed-off-by: Arunpravin <Arunpravin.PaneerSelvam@amd.com>
---
drivers/gpu/drm/drm_buddy.c | 259 ++++++++++--------
drivers/gpu/drm/i915/i915_ttm_buddy_manager.c | 69 ++---
drivers/gpu/drm/i915/i915_ttm_buddy_manager.h | 2 +
include/drm/drm_buddy.h | 22 +-
4 files changed, 203 insertions(+), 149 deletions(-)
diff --git a/drivers/gpu/drm/drm_buddy.c b/drivers/gpu/drm/drm_buddy.c
index 39eb1d224bec..c9b18a29f8d1 100644
--- a/drivers/gpu/drm/drm_buddy.c
+++ b/drivers/gpu/drm/drm_buddy.c
@@ -274,63 +274,6 @@ void drm_buddy_free_list(struct drm_buddy_mm *mm, struct list_head *objects)
}
EXPORT_SYMBOL(drm_buddy_free_list);
-/**
- * drm_buddy_alloc - allocate power-of-two blocks
- *
- * @mm: DRM buddy manager to allocate from
- * @order: size of the allocation
- *
- * The order value here translates to:
- *
- * 0 = 2^0 * mm->chunk_size
- * 1 = 2^1 * mm->chunk_size
- * 2 = 2^2 * mm->chunk_size
- *
- * Returns:
- * allocated ptr to the &drm_buddy_block on success
- */
-struct drm_buddy_block *
-drm_buddy_alloc(struct drm_buddy_mm *mm, unsigned int order)
-{
- struct drm_buddy_block *block = NULL;
- unsigned int i;
- int err;
-
- for (i = order; i <= mm->max_order; ++i) {
- block = list_first_entry_or_null(&mm->free_list[i],
- struct drm_buddy_block,
- link);
- if (block)
- break;
- }
-
- if (!block)
- return ERR_PTR(-ENOSPC);
-
- BUG_ON(!drm_buddy_block_is_free(block));
-
- while (i != order) {
- err = split_block(mm, block);
- if (unlikely(err))
- goto out_free;
-
- /* Go low */
- block = block->left;
- i--;
- }
-
- mark_allocated(block);
- mm->avail -= drm_buddy_block_size(mm, block);
- kmemleak_update_trace(block);
- return block;
-
-out_free:
- if (i != order)
- __drm_buddy_free(mm, block);
- return ERR_PTR(err);
-}
-EXPORT_SYMBOL(drm_buddy_alloc);
-
static inline bool overlaps(u64 s1, u64 e1, u64 s2, u64 e2)
{
return s1 <= e2 && e1 >= s2;
@@ -341,52 +284,22 @@ static inline bool contains(u64 s1, u64 e1, u64 s2, u64 e2)
return s1 <= s2 && e1 >= e2;
}
-/**
- * drm_buddy_alloc_range - allocate range
- *
- * @mm: DRM buddy manager to allocate from
- * @blocks: output list head to add allocated blocks
- * @start: start of the allowed range for this block
- * @size: size of the allocation
- *
- * Intended for pre-allocating portions of the address space, for example to
- * reserve a block for the initial framebuffer or similar, hence the expectation
- * here is that drm_buddy_alloc() is still the main vehicle for
- * allocations, so if that's not the case then the drm_mm range allocator is
- * probably a much better fit, and so you should probably go use that instead.
- *
- * Note that it's safe to chain together multiple alloc_ranges
- * with the same blocks list
- *
- * Returns:
- * 0 on success, error code on failure.
- */
-int drm_buddy_alloc_range(struct drm_buddy_mm *mm,
- struct list_head *blocks,
- u64 start, u64 size)
+static struct drm_buddy_block *
+alloc_range(struct drm_buddy_mm *mm,
+ u64 start, u64 end,
+ unsigned int order)
{
struct drm_buddy_block *block;
struct drm_buddy_block *buddy;
- LIST_HEAD(allocated);
LIST_HEAD(dfs);
- u64 end;
int err;
int i;
- if (size < mm->chunk_size)
- return -EINVAL;
-
- if (!IS_ALIGNED(size | start, mm->chunk_size))
- return -EINVAL;
-
- if (range_overflows(start, size, mm->size))
- return -EINVAL;
+ end = end - 1;
for (i = 0; i < mm->n_roots; ++i)
list_add_tail(&mm->roots[i]->tmp_link, &dfs);
- end = start + size - 1;
-
do {
u64 block_start;
u64 block_end;
@@ -399,26 +312,26 @@ int drm_buddy_alloc_range(struct drm_buddy_mm *mm,
list_del(&block->tmp_link);
+ if (drm_buddy_block_order(block) < order)
+ continue;
+
block_start = drm_buddy_block_offset(block);
block_end = block_start + drm_buddy_block_size(mm, block) - 1;
if (!overlaps(start, end, block_start, block_end))
continue;
- if (drm_buddy_block_is_allocated(block)) {
- err = -ENOSPC;
- goto err_free;
- }
+ if (drm_buddy_block_is_allocated(block))
+ continue;
- if (contains(start, end, block_start, block_end)) {
- if (!drm_buddy_block_is_free(block)) {
- err = -ENOSPC;
- goto err_free;
- }
+ if (contains(start, end, block_start, block_end) &&
+ order == drm_buddy_block_order(block)) {
+ /*
+ * Find the free block within the range.
+ */
+ if (drm_buddy_block_is_free(block))
+ return block;
- mark_allocated(block);
- mm->avail -= drm_buddy_block_size(mm, block);
- list_add_tail(&block->link, &allocated);
continue;
}
@@ -432,8 +345,7 @@ int drm_buddy_alloc_range(struct drm_buddy_mm *mm,
list_add(&block->left->tmp_link, &dfs);
} while (1);
- list_splice_tail(&allocated, blocks);
- return 0;
+ return ERR_PTR(-ENOSPC);
err_undo:
/*
@@ -446,12 +358,145 @@ int drm_buddy_alloc_range(struct drm_buddy_mm *mm,
(drm_buddy_block_is_free(block) &&
drm_buddy_block_is_free(buddy)))
__drm_buddy_free(mm, block);
+ return ERR_PTR(err);
+}
+
+static struct drm_buddy_block *
+alloc_from_freelist(struct drm_buddy_mm *mm,
+ unsigned int order,
+ unsigned long flags)
+{
+ struct drm_buddy_block *block = NULL;
+ unsigned int i;
+ int err;
+
+ for (i = order; i <= mm->max_order; ++i) {
+ block = list_first_entry_or_null(&mm->free_list[i],
+ struct drm_buddy_block,
+ link);
+ if (block)
+ break;
+ }
+
+ if (!block)
+ return ERR_PTR(-ENOSPC);
+
+ BUG_ON(!drm_buddy_block_is_free(block));
+
+ while (i != order) {
+ err = split_block(mm, block);
+ if (unlikely(err))
+ goto err_undo;
+
+ block = block->right;
+ i--;
+ }
+ return block;
+
+err_undo:
+ if (i != order)
+ __drm_buddy_free(mm, block);
+ return ERR_PTR(err);
+}
+
+/**
+ * drm_buddy_alloc - allocate power-of-two blocks
+ *
+ * @mm: DRM buddy manager to allocate from
+ * @start: start of the allowed range for this block
+ * @end: end of the allowed range for this block
+ * @size: size of the allocation
+ * @min_page_size: alignment of the allocation
+ * @blocks: output list head to add allocated blocks
+ * @flags: DRM_BUDDY_*_ALLOCATION flags
+ *
+ * alloc_range() called on range limitations, which traverses
+ * the tree and returns the desired block.
+ *
+ * alloc_from_freelist() called when *no* range restrictions
+ * are enforced, which picks the block from the freelist.
+ *
+ * blocks are allocated in order, the order value here translates to:
+ *
+ * 0 = 2^0 * mm->chunk_size
+ * 1 = 2^1 * mm->chunk_size
+ * 2 = 2^2 * mm->chunk_size
+ *
+ * Returns:
+ * 0 on success, error code on failure.
+ */
+int drm_buddy_alloc(struct drm_buddy_mm *mm,
+ u64 start, u64 end, u64 size,
+ u64 min_page_size,
+ struct list_head *blocks,
+ unsigned long flags)
+{
+ struct drm_buddy_block *block = NULL;
+ unsigned int min_order, order;
+ unsigned long pages;
+ LIST_HEAD(allocated);
+ int err;
+
+ if (size < mm->chunk_size)
+ return -EINVAL;
+
+ if (min_page_size < mm->chunk_size)
+ return -EINVAL;
+
+ if (!is_power_of_2(min_page_size))
+ return -EINVAL;
+
+ if (!IS_ALIGNED(start | end | size, mm->chunk_size))
+ return -EINVAL;
+
+ if (check_range_overflow(start, end, size, mm->size))
+ return -EINVAL;
+
+ pages = size >> ilog2(mm->chunk_size);
+ order = fls(pages) - 1;
+ min_order = ilog2(min_page_size) - ilog2(mm->chunk_size);
+
+ do {
+ order = min(order, (unsigned int)fls(pages) - 1);
+ BUG_ON(order > mm->max_order);
+ BUG_ON(order < min_order);
+
+ do {
+ if (flags & DRM_BUDDY_RANGE_ALLOCATION)
+ /* Allocate traversing within the range */
+ block = alloc_range(mm, start, end, order);
+ else
+ /* Allocate from freelist */
+ block = alloc_from_freelist(mm, order, flags);
+
+ if (!IS_ERR(block))
+ break;
+
+ if (order-- == min_order) {
+ err = -ENOSPC;
+ goto err_free;
+ }
+ } while (1);
+
+ mark_allocated(block);
+ mm->avail -= drm_buddy_block_size(mm, block);
+ kmemleak_update_trace(block);
+ list_add_tail(&block->link, &allocated);
+
+ pages -= BIT(order);
+
+ if (!pages)
+ break;
+ } while (1);
+
+ list_splice_tail(&allocated, blocks);
+ return 0;
err_free:
drm_buddy_free_list(mm, &allocated);
return err;
}
-EXPORT_SYMBOL(drm_buddy_alloc_range);
+EXPORT_SYMBOL(drm_buddy_alloc);
/**
* drm_buddy_block_print - print block information
diff --git a/drivers/gpu/drm/i915/i915_ttm_buddy_manager.c b/drivers/gpu/drm/i915/i915_ttm_buddy_manager.c
index c4b70cb8c248..9e3d130c3f42 100644
--- a/drivers/gpu/drm/i915/i915_ttm_buddy_manager.c
+++ b/drivers/gpu/drm/i915/i915_ttm_buddy_manager.c
@@ -36,13 +36,14 @@ static int i915_ttm_buddy_man_alloc(struct ttm_resource_manager *man,
struct i915_ttm_buddy_manager *bman = to_buddy_manager(man);
struct i915_ttm_buddy_resource *bman_res;
struct drm_buddy_mm *mm = &bman->mm;
- unsigned long n_pages;
- unsigned int min_order;
+ unsigned long n_pages, lpfn;
u64 min_page_size;
u64 size;
int err;
- GEM_BUG_ON(place->fpfn || place->lpfn);
+ lpfn = place->lpfn;
+ if (!lpfn)
+ lpfn = man->size;
bman_res = kzalloc(sizeof(*bman_res), GFP_KERNEL);
if (!bman_res)
@@ -52,6 +53,9 @@ static int i915_ttm_buddy_man_alloc(struct ttm_resource_manager *man,
INIT_LIST_HEAD(&bman_res->blocks);
bman_res->mm = mm;
+ if (place->fpfn || lpfn != man->size)
+ bman_res->flags |= DRM_BUDDY_RANGE_ALLOCATION;
+
GEM_BUG_ON(!bman_res->base.num_pages);
size = bman_res->base.num_pages << PAGE_SHIFT;
@@ -60,10 +64,16 @@ static int i915_ttm_buddy_man_alloc(struct ttm_resource_manager *man,
min_page_size = bo->page_alignment << PAGE_SHIFT;
GEM_BUG_ON(min_page_size < mm->chunk_size);
- min_order = ilog2(min_page_size) - ilog2(mm->chunk_size);
+
if (place->flags & TTM_PL_FLAG_CONTIGUOUS) {
+ unsigned long pages;
+
size = roundup_pow_of_two(size);
- min_order = ilog2(size) - ilog2(mm->chunk_size);
+ min_page_size = size;
+
+ pages = size >> ilog2(mm->chunk_size);
+ if (pages > lpfn)
+ lpfn = pages;
}
if (size > mm->size) {
@@ -73,34 +83,16 @@ static int i915_ttm_buddy_man_alloc(struct ttm_resource_manager *man,
n_pages = size >> ilog2(mm->chunk_size);
- do {
- struct drm_buddy_block *block;
- unsigned int order;
-
- order = fls(n_pages) - 1;
- GEM_BUG_ON(order > mm->max_order);
- GEM_BUG_ON(order < min_order);
-
- do {
- mutex_lock(&bman->lock);
- block = drm_buddy_alloc(mm, order);
- mutex_unlock(&bman->lock);
- if (!IS_ERR(block))
- break;
-
- if (order-- == min_order) {
- err = -ENOSPC;
- goto err_free_blocks;
- }
- } while (1);
-
- n_pages -= BIT(order);
-
- list_add_tail(&block->link, &bman_res->blocks);
-
- if (!n_pages)
- break;
- } while (1);
+ mutex_lock(&bman->lock);
+ err = drm_buddy_alloc(mm, (u64)place->fpfn << PAGE_SHIFT,
+ (u64)place->lpfn << PAGE_SHIFT,
+ (u64)n_pages << PAGE_SHIFT,
+ min_page_size,
+ &bman_res->blocks,
+ bman_res->flags);
+ mutex_unlock(&bman->lock);
+ if (unlikely(err))
+ goto err_free_blocks;
*res = &bman_res->base;
return 0;
@@ -266,10 +258,19 @@ int i915_ttm_buddy_man_reserve(struct ttm_resource_manager *man,
{
struct i915_ttm_buddy_manager *bman = to_buddy_manager(man);
struct drm_buddy_mm *mm = &bman->mm;
+ unsigned long flags = 0;
+ u64 min_size;
int ret;
+ min_size = size;
+ flags |= DRM_BUDDY_RANGE_ALLOCATION;
+
mutex_lock(&bman->lock);
- ret = drm_buddy_alloc_range(mm, &bman->reserved, start, size);
+ ret = drm_buddy_alloc(mm, start,
+ start + size,
+ size, min_size,
+ &bman->reserved,
+ flags);
mutex_unlock(&bman->lock);
return ret;
diff --git a/drivers/gpu/drm/i915/i915_ttm_buddy_manager.h b/drivers/gpu/drm/i915/i915_ttm_buddy_manager.h
index fa644b512c2e..5ba490875f66 100644
--- a/drivers/gpu/drm/i915/i915_ttm_buddy_manager.h
+++ b/drivers/gpu/drm/i915/i915_ttm_buddy_manager.h
@@ -20,6 +20,7 @@ struct drm_buddy_mm;
*
* @base: struct ttm_resource base class we extend
* @blocks: the list of struct i915_buddy_block for this resource/allocation
+ * @flags: DRM_BUDDY_*_ALLOCATION flags
* @mm: the struct i915_buddy_mm for this resource
*
* Extends the struct ttm_resource to manage an address space allocation with
@@ -28,6 +29,7 @@ struct drm_buddy_mm;
struct i915_ttm_buddy_resource {
struct ttm_resource base;
struct list_head blocks;
+ unsigned long flags;
struct drm_buddy_mm *mm;
};
diff --git a/include/drm/drm_buddy.h b/include/drm/drm_buddy.h
index 5ce3fc702f80..2ec3cbc9d5d7 100644
--- a/include/drm/drm_buddy.h
+++ b/include/drm/drm_buddy.h
@@ -13,15 +13,22 @@
#include <drm/drm_print.h>
-#define range_overflows(start, size, max) ({ \
+#define check_range_overflow(start, end, size, max) ({ \
typeof(start) start__ = (start); \
+ typeof(end) end__ = (end);\
typeof(size) size__ = (size); \
typeof(max) max__ = (max); \
(void)(&start__ == &size__); \
(void)(&start__ == &max__); \
- start__ >= max__ || size__ > max__ - start__; \
+ (void)(&start__ == &end__); \
+ (void)(&end__ == &size__); \
+ (void)(&end__ == &max__); \
+ start__ >= max__ || end__ > max__ || \
+ size__ > end__ - start__; \
})
+#define DRM_BUDDY_RANGE_ALLOCATION (1 << 0)
+
struct drm_buddy_block {
#define DRM_BUDDY_HEADER_OFFSET GENMASK_ULL(63, 12)
#define DRM_BUDDY_HEADER_STATE GENMASK_ULL(11, 10)
@@ -131,12 +138,11 @@ int drm_buddy_init(struct drm_buddy_mm *mm, u64 size, u64 chunk_size);
void drm_buddy_fini(struct drm_buddy_mm *mm);
-struct drm_buddy_block *
-drm_buddy_alloc(struct drm_buddy_mm *mm, unsigned int order);
-
-int drm_buddy_alloc_range(struct drm_buddy_mm *mm,
- struct list_head *blocks,
- u64 start, u64 size);
+int drm_buddy_alloc(struct drm_buddy_mm *mm,
+ u64 start, u64 end, u64 size,
+ u64 min_page_size,
+ struct list_head *blocks,
+ unsigned long flags);
void drm_buddy_free(struct drm_buddy_mm *mm, struct drm_buddy_block *block);
--
2.25.1
^ permalink raw reply related [flat|nested] 46+ messages in thread
* [Intel-gfx] [PATCH v3 2/6] drm: improve drm_buddy_alloc function
@ 2021-11-16 20:18 ` Arunpravin
0 siblings, 0 replies; 46+ messages in thread
From: Arunpravin @ 2021-11-16 20:18 UTC (permalink / raw)
To: dri-devel, intel-gfx, amd-gfx
Cc: Arunpravin, matthew.auld, tzimmermann, alexander.deucher,
christian.koenig
- Make drm_buddy_alloc a single function to handle
range allocation and non-range allocation demands
- Implemented a new function alloc_range() which allocates
the requested power-of-two block comply with range limitations
- Moved order computation and memory alignment logic from
i915 driver to drm buddy
v2:
merged below changes to keep the build unbroken
- drm_buddy_alloc_range() becomes obsolete and may be removed
- enable ttm range allocation (fpfn / lpfn) support in i915 driver
- apply enhanced drm_buddy_alloc() function to i915 driver
v3(Matthew Auld):
- Fix alignment issues and remove unnecessary list_empty check
- add more validation checks for input arguments
- make alloc_range() block allocations as bottom-up
- optimize order computation logic
- replace uint64_t with u64, which is preferred in the kernel
Signed-off-by: Arunpravin <Arunpravin.PaneerSelvam@amd.com>
---
drivers/gpu/drm/drm_buddy.c | 259 ++++++++++--------
drivers/gpu/drm/i915/i915_ttm_buddy_manager.c | 69 ++---
drivers/gpu/drm/i915/i915_ttm_buddy_manager.h | 2 +
include/drm/drm_buddy.h | 22 +-
4 files changed, 203 insertions(+), 149 deletions(-)
diff --git a/drivers/gpu/drm/drm_buddy.c b/drivers/gpu/drm/drm_buddy.c
index 39eb1d224bec..c9b18a29f8d1 100644
--- a/drivers/gpu/drm/drm_buddy.c
+++ b/drivers/gpu/drm/drm_buddy.c
@@ -274,63 +274,6 @@ void drm_buddy_free_list(struct drm_buddy_mm *mm, struct list_head *objects)
}
EXPORT_SYMBOL(drm_buddy_free_list);
-/**
- * drm_buddy_alloc - allocate power-of-two blocks
- *
- * @mm: DRM buddy manager to allocate from
- * @order: size of the allocation
- *
- * The order value here translates to:
- *
- * 0 = 2^0 * mm->chunk_size
- * 1 = 2^1 * mm->chunk_size
- * 2 = 2^2 * mm->chunk_size
- *
- * Returns:
- * allocated ptr to the &drm_buddy_block on success
- */
-struct drm_buddy_block *
-drm_buddy_alloc(struct drm_buddy_mm *mm, unsigned int order)
-{
- struct drm_buddy_block *block = NULL;
- unsigned int i;
- int err;
-
- for (i = order; i <= mm->max_order; ++i) {
- block = list_first_entry_or_null(&mm->free_list[i],
- struct drm_buddy_block,
- link);
- if (block)
- break;
- }
-
- if (!block)
- return ERR_PTR(-ENOSPC);
-
- BUG_ON(!drm_buddy_block_is_free(block));
-
- while (i != order) {
- err = split_block(mm, block);
- if (unlikely(err))
- goto out_free;
-
- /* Go low */
- block = block->left;
- i--;
- }
-
- mark_allocated(block);
- mm->avail -= drm_buddy_block_size(mm, block);
- kmemleak_update_trace(block);
- return block;
-
-out_free:
- if (i != order)
- __drm_buddy_free(mm, block);
- return ERR_PTR(err);
-}
-EXPORT_SYMBOL(drm_buddy_alloc);
-
static inline bool overlaps(u64 s1, u64 e1, u64 s2, u64 e2)
{
return s1 <= e2 && e1 >= s2;
@@ -341,52 +284,22 @@ static inline bool contains(u64 s1, u64 e1, u64 s2, u64 e2)
return s1 <= s2 && e1 >= e2;
}
-/**
- * drm_buddy_alloc_range - allocate range
- *
- * @mm: DRM buddy manager to allocate from
- * @blocks: output list head to add allocated blocks
- * @start: start of the allowed range for this block
- * @size: size of the allocation
- *
- * Intended for pre-allocating portions of the address space, for example to
- * reserve a block for the initial framebuffer or similar, hence the expectation
- * here is that drm_buddy_alloc() is still the main vehicle for
- * allocations, so if that's not the case then the drm_mm range allocator is
- * probably a much better fit, and so you should probably go use that instead.
- *
- * Note that it's safe to chain together multiple alloc_ranges
- * with the same blocks list
- *
- * Returns:
- * 0 on success, error code on failure.
- */
-int drm_buddy_alloc_range(struct drm_buddy_mm *mm,
- struct list_head *blocks,
- u64 start, u64 size)
+static struct drm_buddy_block *
+alloc_range(struct drm_buddy_mm *mm,
+ u64 start, u64 end,
+ unsigned int order)
{
struct drm_buddy_block *block;
struct drm_buddy_block *buddy;
- LIST_HEAD(allocated);
LIST_HEAD(dfs);
- u64 end;
int err;
int i;
- if (size < mm->chunk_size)
- return -EINVAL;
-
- if (!IS_ALIGNED(size | start, mm->chunk_size))
- return -EINVAL;
-
- if (range_overflows(start, size, mm->size))
- return -EINVAL;
+ end = end - 1;
for (i = 0; i < mm->n_roots; ++i)
list_add_tail(&mm->roots[i]->tmp_link, &dfs);
- end = start + size - 1;
-
do {
u64 block_start;
u64 block_end;
@@ -399,26 +312,26 @@ int drm_buddy_alloc_range(struct drm_buddy_mm *mm,
list_del(&block->tmp_link);
+ if (drm_buddy_block_order(block) < order)
+ continue;
+
block_start = drm_buddy_block_offset(block);
block_end = block_start + drm_buddy_block_size(mm, block) - 1;
if (!overlaps(start, end, block_start, block_end))
continue;
- if (drm_buddy_block_is_allocated(block)) {
- err = -ENOSPC;
- goto err_free;
- }
+ if (drm_buddy_block_is_allocated(block))
+ continue;
- if (contains(start, end, block_start, block_end)) {
- if (!drm_buddy_block_is_free(block)) {
- err = -ENOSPC;
- goto err_free;
- }
+ if (contains(start, end, block_start, block_end) &&
+ order == drm_buddy_block_order(block)) {
+ /*
+ * Find the free block within the range.
+ */
+ if (drm_buddy_block_is_free(block))
+ return block;
- mark_allocated(block);
- mm->avail -= drm_buddy_block_size(mm, block);
- list_add_tail(&block->link, &allocated);
continue;
}
@@ -432,8 +345,7 @@ int drm_buddy_alloc_range(struct drm_buddy_mm *mm,
list_add(&block->left->tmp_link, &dfs);
} while (1);
- list_splice_tail(&allocated, blocks);
- return 0;
+ return ERR_PTR(-ENOSPC);
err_undo:
/*
@@ -446,12 +358,145 @@ int drm_buddy_alloc_range(struct drm_buddy_mm *mm,
(drm_buddy_block_is_free(block) &&
drm_buddy_block_is_free(buddy)))
__drm_buddy_free(mm, block);
+ return ERR_PTR(err);
+}
+
+static struct drm_buddy_block *
+alloc_from_freelist(struct drm_buddy_mm *mm,
+ unsigned int order,
+ unsigned long flags)
+{
+ struct drm_buddy_block *block = NULL;
+ unsigned int i;
+ int err;
+
+ for (i = order; i <= mm->max_order; ++i) {
+ block = list_first_entry_or_null(&mm->free_list[i],
+ struct drm_buddy_block,
+ link);
+ if (block)
+ break;
+ }
+
+ if (!block)
+ return ERR_PTR(-ENOSPC);
+
+ BUG_ON(!drm_buddy_block_is_free(block));
+
+ while (i != order) {
+ err = split_block(mm, block);
+ if (unlikely(err))
+ goto err_undo;
+
+ block = block->right;
+ i--;
+ }
+ return block;
+
+err_undo:
+ if (i != order)
+ __drm_buddy_free(mm, block);
+ return ERR_PTR(err);
+}
+
+/**
+ * drm_buddy_alloc - allocate power-of-two blocks
+ *
+ * @mm: DRM buddy manager to allocate from
+ * @start: start of the allowed range for this block
+ * @end: end of the allowed range for this block
+ * @size: size of the allocation
+ * @min_page_size: alignment of the allocation
+ * @blocks: output list head to add allocated blocks
+ * @flags: DRM_BUDDY_*_ALLOCATION flags
+ *
+ * alloc_range() called on range limitations, which traverses
+ * the tree and returns the desired block.
+ *
+ * alloc_from_freelist() called when *no* range restrictions
+ * are enforced, which picks the block from the freelist.
+ *
+ * blocks are allocated in order, the order value here translates to:
+ *
+ * 0 = 2^0 * mm->chunk_size
+ * 1 = 2^1 * mm->chunk_size
+ * 2 = 2^2 * mm->chunk_size
+ *
+ * Returns:
+ * 0 on success, error code on failure.
+ */
+int drm_buddy_alloc(struct drm_buddy_mm *mm,
+ u64 start, u64 end, u64 size,
+ u64 min_page_size,
+ struct list_head *blocks,
+ unsigned long flags)
+{
+ struct drm_buddy_block *block = NULL;
+ unsigned int min_order, order;
+ unsigned long pages;
+ LIST_HEAD(allocated);
+ int err;
+
+ if (size < mm->chunk_size)
+ return -EINVAL;
+
+ if (min_page_size < mm->chunk_size)
+ return -EINVAL;
+
+ if (!is_power_of_2(min_page_size))
+ return -EINVAL;
+
+ if (!IS_ALIGNED(start | end | size, mm->chunk_size))
+ return -EINVAL;
+
+ if (check_range_overflow(start, end, size, mm->size))
+ return -EINVAL;
+
+ pages = size >> ilog2(mm->chunk_size);
+ order = fls(pages) - 1;
+ min_order = ilog2(min_page_size) - ilog2(mm->chunk_size);
+
+ do {
+ order = min(order, (unsigned int)fls(pages) - 1);
+ BUG_ON(order > mm->max_order);
+ BUG_ON(order < min_order);
+
+ do {
+ if (flags & DRM_BUDDY_RANGE_ALLOCATION)
+ /* Allocate traversing within the range */
+ block = alloc_range(mm, start, end, order);
+ else
+ /* Allocate from freelist */
+ block = alloc_from_freelist(mm, order, flags);
+
+ if (!IS_ERR(block))
+ break;
+
+ if (order-- == min_order) {
+ err = -ENOSPC;
+ goto err_free;
+ }
+ } while (1);
+
+ mark_allocated(block);
+ mm->avail -= drm_buddy_block_size(mm, block);
+ kmemleak_update_trace(block);
+ list_add_tail(&block->link, &allocated);
+
+ pages -= BIT(order);
+
+ if (!pages)
+ break;
+ } while (1);
+
+ list_splice_tail(&allocated, blocks);
+ return 0;
err_free:
drm_buddy_free_list(mm, &allocated);
return err;
}
-EXPORT_SYMBOL(drm_buddy_alloc_range);
+EXPORT_SYMBOL(drm_buddy_alloc);
/**
* drm_buddy_block_print - print block information
diff --git a/drivers/gpu/drm/i915/i915_ttm_buddy_manager.c b/drivers/gpu/drm/i915/i915_ttm_buddy_manager.c
index c4b70cb8c248..9e3d130c3f42 100644
--- a/drivers/gpu/drm/i915/i915_ttm_buddy_manager.c
+++ b/drivers/gpu/drm/i915/i915_ttm_buddy_manager.c
@@ -36,13 +36,14 @@ static int i915_ttm_buddy_man_alloc(struct ttm_resource_manager *man,
struct i915_ttm_buddy_manager *bman = to_buddy_manager(man);
struct i915_ttm_buddy_resource *bman_res;
struct drm_buddy_mm *mm = &bman->mm;
- unsigned long n_pages;
- unsigned int min_order;
+ unsigned long n_pages, lpfn;
u64 min_page_size;
u64 size;
int err;
- GEM_BUG_ON(place->fpfn || place->lpfn);
+ lpfn = place->lpfn;
+ if (!lpfn)
+ lpfn = man->size;
bman_res = kzalloc(sizeof(*bman_res), GFP_KERNEL);
if (!bman_res)
@@ -52,6 +53,9 @@ static int i915_ttm_buddy_man_alloc(struct ttm_resource_manager *man,
INIT_LIST_HEAD(&bman_res->blocks);
bman_res->mm = mm;
+ if (place->fpfn || lpfn != man->size)
+ bman_res->flags |= DRM_BUDDY_RANGE_ALLOCATION;
+
GEM_BUG_ON(!bman_res->base.num_pages);
size = bman_res->base.num_pages << PAGE_SHIFT;
@@ -60,10 +64,16 @@ static int i915_ttm_buddy_man_alloc(struct ttm_resource_manager *man,
min_page_size = bo->page_alignment << PAGE_SHIFT;
GEM_BUG_ON(min_page_size < mm->chunk_size);
- min_order = ilog2(min_page_size) - ilog2(mm->chunk_size);
+
if (place->flags & TTM_PL_FLAG_CONTIGUOUS) {
+ unsigned long pages;
+
size = roundup_pow_of_two(size);
- min_order = ilog2(size) - ilog2(mm->chunk_size);
+ min_page_size = size;
+
+ pages = size >> ilog2(mm->chunk_size);
+ if (pages > lpfn)
+ lpfn = pages;
}
if (size > mm->size) {
@@ -73,34 +83,16 @@ static int i915_ttm_buddy_man_alloc(struct ttm_resource_manager *man,
n_pages = size >> ilog2(mm->chunk_size);
- do {
- struct drm_buddy_block *block;
- unsigned int order;
-
- order = fls(n_pages) - 1;
- GEM_BUG_ON(order > mm->max_order);
- GEM_BUG_ON(order < min_order);
-
- do {
- mutex_lock(&bman->lock);
- block = drm_buddy_alloc(mm, order);
- mutex_unlock(&bman->lock);
- if (!IS_ERR(block))
- break;
-
- if (order-- == min_order) {
- err = -ENOSPC;
- goto err_free_blocks;
- }
- } while (1);
-
- n_pages -= BIT(order);
-
- list_add_tail(&block->link, &bman_res->blocks);
-
- if (!n_pages)
- break;
- } while (1);
+ mutex_lock(&bman->lock);
+ err = drm_buddy_alloc(mm, (u64)place->fpfn << PAGE_SHIFT,
+ (u64)place->lpfn << PAGE_SHIFT,
+ (u64)n_pages << PAGE_SHIFT,
+ min_page_size,
+ &bman_res->blocks,
+ bman_res->flags);
+ mutex_unlock(&bman->lock);
+ if (unlikely(err))
+ goto err_free_blocks;
*res = &bman_res->base;
return 0;
@@ -266,10 +258,19 @@ int i915_ttm_buddy_man_reserve(struct ttm_resource_manager *man,
{
struct i915_ttm_buddy_manager *bman = to_buddy_manager(man);
struct drm_buddy_mm *mm = &bman->mm;
+ unsigned long flags = 0;
+ u64 min_size;
int ret;
+ min_size = size;
+ flags |= DRM_BUDDY_RANGE_ALLOCATION;
+
mutex_lock(&bman->lock);
- ret = drm_buddy_alloc_range(mm, &bman->reserved, start, size);
+ ret = drm_buddy_alloc(mm, start,
+ start + size,
+ size, min_size,
+ &bman->reserved,
+ flags);
mutex_unlock(&bman->lock);
return ret;
diff --git a/drivers/gpu/drm/i915/i915_ttm_buddy_manager.h b/drivers/gpu/drm/i915/i915_ttm_buddy_manager.h
index fa644b512c2e..5ba490875f66 100644
--- a/drivers/gpu/drm/i915/i915_ttm_buddy_manager.h
+++ b/drivers/gpu/drm/i915/i915_ttm_buddy_manager.h
@@ -20,6 +20,7 @@ struct drm_buddy_mm;
*
* @base: struct ttm_resource base class we extend
* @blocks: the list of struct i915_buddy_block for this resource/allocation
+ * @flags: DRM_BUDDY_*_ALLOCATION flags
* @mm: the struct i915_buddy_mm for this resource
*
* Extends the struct ttm_resource to manage an address space allocation with
@@ -28,6 +29,7 @@ struct drm_buddy_mm;
struct i915_ttm_buddy_resource {
struct ttm_resource base;
struct list_head blocks;
+ unsigned long flags;
struct drm_buddy_mm *mm;
};
diff --git a/include/drm/drm_buddy.h b/include/drm/drm_buddy.h
index 5ce3fc702f80..2ec3cbc9d5d7 100644
--- a/include/drm/drm_buddy.h
+++ b/include/drm/drm_buddy.h
@@ -13,15 +13,22 @@
#include <drm/drm_print.h>
-#define range_overflows(start, size, max) ({ \
+#define check_range_overflow(start, end, size, max) ({ \
typeof(start) start__ = (start); \
+ typeof(end) end__ = (end);\
typeof(size) size__ = (size); \
typeof(max) max__ = (max); \
(void)(&start__ == &size__); \
(void)(&start__ == &max__); \
- start__ >= max__ || size__ > max__ - start__; \
+ (void)(&start__ == &end__); \
+ (void)(&end__ == &size__); \
+ (void)(&end__ == &max__); \
+ start__ >= max__ || end__ > max__ || \
+ size__ > end__ - start__; \
})
+#define DRM_BUDDY_RANGE_ALLOCATION (1 << 0)
+
struct drm_buddy_block {
#define DRM_BUDDY_HEADER_OFFSET GENMASK_ULL(63, 12)
#define DRM_BUDDY_HEADER_STATE GENMASK_ULL(11, 10)
@@ -131,12 +138,11 @@ int drm_buddy_init(struct drm_buddy_mm *mm, u64 size, u64 chunk_size);
void drm_buddy_fini(struct drm_buddy_mm *mm);
-struct drm_buddy_block *
-drm_buddy_alloc(struct drm_buddy_mm *mm, unsigned int order);
-
-int drm_buddy_alloc_range(struct drm_buddy_mm *mm,
- struct list_head *blocks,
- u64 start, u64 size);
+int drm_buddy_alloc(struct drm_buddy_mm *mm,
+ u64 start, u64 end, u64 size,
+ u64 min_page_size,
+ struct list_head *blocks,
+ unsigned long flags);
void drm_buddy_free(struct drm_buddy_mm *mm, struct drm_buddy_block *block);
--
2.25.1
^ permalink raw reply related [flat|nested] 46+ messages in thread
* [PATCH v3 3/6] drm: implement top-down allocation method
2021-11-16 20:18 ` Arunpravin
(?)
@ 2021-11-16 20:18 ` Arunpravin
-1 siblings, 0 replies; 46+ messages in thread
From: Arunpravin @ 2021-11-16 20:18 UTC (permalink / raw)
To: dri-devel, intel-gfx, amd-gfx
Cc: Arunpravin, matthew.auld, tzimmermann, alexander.deucher,
christian.koenig
Implemented a function which walk through the order list,
compares the offset and returns the maximum offset block,
this method is unpredictable in obtaining the high range
address blocks which depends on allocation and deallocation.
for instance, if driver requests address at a low specific
range, allocator traverses from the root block and splits
the larger blocks until it reaches the specific block and
in the process of splitting, lower orders in the freelist
are occupied with low range address blocks and for the
subsequent TOPDOWN memory request we may return the low
range blocks.To overcome this issue, we may go with the
below approach.
The other approach, sorting each order list entries in
ascending order and compares the last entry of each
order list in the freelist and return the max block.
This creates sorting overhead on every drm_buddy_free()
request and split up of larger blocks for a single page
request.
v2:
- Fix alignment issues(Matthew Auld)
- Remove unnecessary list_empty check(Matthew Auld)
- merged the below patch to see the feature in action
- add top-down alloc support to i915 driver
Signed-off-by: Arunpravin <Arunpravin.PaneerSelvam@amd.com>
---
drivers/gpu/drm/drm_buddy.c | 36 ++++++++++++++++---
drivers/gpu/drm/i915/i915_ttm_buddy_manager.c | 3 ++
include/drm/drm_buddy.h | 1 +
3 files changed, 35 insertions(+), 5 deletions(-)
diff --git a/drivers/gpu/drm/drm_buddy.c b/drivers/gpu/drm/drm_buddy.c
index c9b18a29f8d1..0a9db2981188 100644
--- a/drivers/gpu/drm/drm_buddy.c
+++ b/drivers/gpu/drm/drm_buddy.c
@@ -361,6 +361,26 @@ alloc_range(struct drm_buddy_mm *mm,
return ERR_PTR(err);
}
+static struct drm_buddy_block *
+get_maxblock(struct list_head *head)
+{
+ struct drm_buddy_block *max_block = NULL, *node;
+
+ max_block = list_first_entry_or_null(head,
+ struct drm_buddy_block,
+ link);
+ if (!max_block)
+ return NULL;
+
+ list_for_each_entry(node, head, link) {
+ if (drm_buddy_block_offset(node) >
+ drm_buddy_block_offset(max_block))
+ max_block = node;
+ }
+
+ return max_block;
+}
+
static struct drm_buddy_block *
alloc_from_freelist(struct drm_buddy_mm *mm,
unsigned int order,
@@ -371,11 +391,17 @@ alloc_from_freelist(struct drm_buddy_mm *mm,
int err;
for (i = order; i <= mm->max_order; ++i) {
- block = list_first_entry_or_null(&mm->free_list[i],
- struct drm_buddy_block,
- link);
- if (block)
- break;
+ if (flags & DRM_BUDDY_TOPDOWN_ALLOCATION) {
+ block = get_maxblock(&mm->free_list[i]);
+ if (block)
+ break;
+ } else {
+ block = list_first_entry_or_null(&mm->free_list[i],
+ struct drm_buddy_block,
+ link);
+ if (block)
+ break;
+ }
}
if (!block)
diff --git a/drivers/gpu/drm/i915/i915_ttm_buddy_manager.c b/drivers/gpu/drm/i915/i915_ttm_buddy_manager.c
index 9e3d130c3f42..b6ed5b37cf18 100644
--- a/drivers/gpu/drm/i915/i915_ttm_buddy_manager.c
+++ b/drivers/gpu/drm/i915/i915_ttm_buddy_manager.c
@@ -53,6 +53,9 @@ static int i915_ttm_buddy_man_alloc(struct ttm_resource_manager *man,
INIT_LIST_HEAD(&bman_res->blocks);
bman_res->mm = mm;
+ if (place->flags & TTM_PL_FLAG_TOPDOWN)
+ bman_res->flags |= DRM_BUDDY_TOPDOWN_ALLOCATION;
+
if (place->fpfn || lpfn != man->size)
bman_res->flags |= DRM_BUDDY_RANGE_ALLOCATION;
diff --git a/include/drm/drm_buddy.h b/include/drm/drm_buddy.h
index 2ec3cbc9d5d7..cbe5e648440a 100644
--- a/include/drm/drm_buddy.h
+++ b/include/drm/drm_buddy.h
@@ -28,6 +28,7 @@
})
#define DRM_BUDDY_RANGE_ALLOCATION (1 << 0)
+#define DRM_BUDDY_TOPDOWN_ALLOCATION (1 << 1)
struct drm_buddy_block {
#define DRM_BUDDY_HEADER_OFFSET GENMASK_ULL(63, 12)
--
2.25.1
^ permalink raw reply related [flat|nested] 46+ messages in thread
* [PATCH v3 3/6] drm: implement top-down allocation method
@ 2021-11-16 20:18 ` Arunpravin
0 siblings, 0 replies; 46+ messages in thread
From: Arunpravin @ 2021-11-16 20:18 UTC (permalink / raw)
To: dri-devel, intel-gfx, amd-gfx
Cc: daniel, Arunpravin, jani.nikula, matthew.auld, tzimmermann,
alexander.deucher, christian.koenig
Implemented a function which walk through the order list,
compares the offset and returns the maximum offset block,
this method is unpredictable in obtaining the high range
address blocks which depends on allocation and deallocation.
for instance, if driver requests address at a low specific
range, allocator traverses from the root block and splits
the larger blocks until it reaches the specific block and
in the process of splitting, lower orders in the freelist
are occupied with low range address blocks and for the
subsequent TOPDOWN memory request we may return the low
range blocks.To overcome this issue, we may go with the
below approach.
The other approach, sorting each order list entries in
ascending order and compares the last entry of each
order list in the freelist and return the max block.
This creates sorting overhead on every drm_buddy_free()
request and split up of larger blocks for a single page
request.
v2:
- Fix alignment issues(Matthew Auld)
- Remove unnecessary list_empty check(Matthew Auld)
- merged the below patch to see the feature in action
- add top-down alloc support to i915 driver
Signed-off-by: Arunpravin <Arunpravin.PaneerSelvam@amd.com>
---
drivers/gpu/drm/drm_buddy.c | 36 ++++++++++++++++---
drivers/gpu/drm/i915/i915_ttm_buddy_manager.c | 3 ++
include/drm/drm_buddy.h | 1 +
3 files changed, 35 insertions(+), 5 deletions(-)
diff --git a/drivers/gpu/drm/drm_buddy.c b/drivers/gpu/drm/drm_buddy.c
index c9b18a29f8d1..0a9db2981188 100644
--- a/drivers/gpu/drm/drm_buddy.c
+++ b/drivers/gpu/drm/drm_buddy.c
@@ -361,6 +361,26 @@ alloc_range(struct drm_buddy_mm *mm,
return ERR_PTR(err);
}
+static struct drm_buddy_block *
+get_maxblock(struct list_head *head)
+{
+ struct drm_buddy_block *max_block = NULL, *node;
+
+ max_block = list_first_entry_or_null(head,
+ struct drm_buddy_block,
+ link);
+ if (!max_block)
+ return NULL;
+
+ list_for_each_entry(node, head, link) {
+ if (drm_buddy_block_offset(node) >
+ drm_buddy_block_offset(max_block))
+ max_block = node;
+ }
+
+ return max_block;
+}
+
static struct drm_buddy_block *
alloc_from_freelist(struct drm_buddy_mm *mm,
unsigned int order,
@@ -371,11 +391,17 @@ alloc_from_freelist(struct drm_buddy_mm *mm,
int err;
for (i = order; i <= mm->max_order; ++i) {
- block = list_first_entry_or_null(&mm->free_list[i],
- struct drm_buddy_block,
- link);
- if (block)
- break;
+ if (flags & DRM_BUDDY_TOPDOWN_ALLOCATION) {
+ block = get_maxblock(&mm->free_list[i]);
+ if (block)
+ break;
+ } else {
+ block = list_first_entry_or_null(&mm->free_list[i],
+ struct drm_buddy_block,
+ link);
+ if (block)
+ break;
+ }
}
if (!block)
diff --git a/drivers/gpu/drm/i915/i915_ttm_buddy_manager.c b/drivers/gpu/drm/i915/i915_ttm_buddy_manager.c
index 9e3d130c3f42..b6ed5b37cf18 100644
--- a/drivers/gpu/drm/i915/i915_ttm_buddy_manager.c
+++ b/drivers/gpu/drm/i915/i915_ttm_buddy_manager.c
@@ -53,6 +53,9 @@ static int i915_ttm_buddy_man_alloc(struct ttm_resource_manager *man,
INIT_LIST_HEAD(&bman_res->blocks);
bman_res->mm = mm;
+ if (place->flags & TTM_PL_FLAG_TOPDOWN)
+ bman_res->flags |= DRM_BUDDY_TOPDOWN_ALLOCATION;
+
if (place->fpfn || lpfn != man->size)
bman_res->flags |= DRM_BUDDY_RANGE_ALLOCATION;
diff --git a/include/drm/drm_buddy.h b/include/drm/drm_buddy.h
index 2ec3cbc9d5d7..cbe5e648440a 100644
--- a/include/drm/drm_buddy.h
+++ b/include/drm/drm_buddy.h
@@ -28,6 +28,7 @@
})
#define DRM_BUDDY_RANGE_ALLOCATION (1 << 0)
+#define DRM_BUDDY_TOPDOWN_ALLOCATION (1 << 1)
struct drm_buddy_block {
#define DRM_BUDDY_HEADER_OFFSET GENMASK_ULL(63, 12)
--
2.25.1
^ permalink raw reply related [flat|nested] 46+ messages in thread
* [Intel-gfx] [PATCH v3 3/6] drm: implement top-down allocation method
@ 2021-11-16 20:18 ` Arunpravin
0 siblings, 0 replies; 46+ messages in thread
From: Arunpravin @ 2021-11-16 20:18 UTC (permalink / raw)
To: dri-devel, intel-gfx, amd-gfx
Cc: Arunpravin, matthew.auld, tzimmermann, alexander.deucher,
christian.koenig
Implemented a function which walk through the order list,
compares the offset and returns the maximum offset block,
this method is unpredictable in obtaining the high range
address blocks which depends on allocation and deallocation.
for instance, if driver requests address at a low specific
range, allocator traverses from the root block and splits
the larger blocks until it reaches the specific block and
in the process of splitting, lower orders in the freelist
are occupied with low range address blocks and for the
subsequent TOPDOWN memory request we may return the low
range blocks.To overcome this issue, we may go with the
below approach.
The other approach, sorting each order list entries in
ascending order and compares the last entry of each
order list in the freelist and return the max block.
This creates sorting overhead on every drm_buddy_free()
request and split up of larger blocks for a single page
request.
v2:
- Fix alignment issues(Matthew Auld)
- Remove unnecessary list_empty check(Matthew Auld)
- merged the below patch to see the feature in action
- add top-down alloc support to i915 driver
Signed-off-by: Arunpravin <Arunpravin.PaneerSelvam@amd.com>
---
drivers/gpu/drm/drm_buddy.c | 36 ++++++++++++++++---
drivers/gpu/drm/i915/i915_ttm_buddy_manager.c | 3 ++
include/drm/drm_buddy.h | 1 +
3 files changed, 35 insertions(+), 5 deletions(-)
diff --git a/drivers/gpu/drm/drm_buddy.c b/drivers/gpu/drm/drm_buddy.c
index c9b18a29f8d1..0a9db2981188 100644
--- a/drivers/gpu/drm/drm_buddy.c
+++ b/drivers/gpu/drm/drm_buddy.c
@@ -361,6 +361,26 @@ alloc_range(struct drm_buddy_mm *mm,
return ERR_PTR(err);
}
+static struct drm_buddy_block *
+get_maxblock(struct list_head *head)
+{
+ struct drm_buddy_block *max_block = NULL, *node;
+
+ max_block = list_first_entry_or_null(head,
+ struct drm_buddy_block,
+ link);
+ if (!max_block)
+ return NULL;
+
+ list_for_each_entry(node, head, link) {
+ if (drm_buddy_block_offset(node) >
+ drm_buddy_block_offset(max_block))
+ max_block = node;
+ }
+
+ return max_block;
+}
+
static struct drm_buddy_block *
alloc_from_freelist(struct drm_buddy_mm *mm,
unsigned int order,
@@ -371,11 +391,17 @@ alloc_from_freelist(struct drm_buddy_mm *mm,
int err;
for (i = order; i <= mm->max_order; ++i) {
- block = list_first_entry_or_null(&mm->free_list[i],
- struct drm_buddy_block,
- link);
- if (block)
- break;
+ if (flags & DRM_BUDDY_TOPDOWN_ALLOCATION) {
+ block = get_maxblock(&mm->free_list[i]);
+ if (block)
+ break;
+ } else {
+ block = list_first_entry_or_null(&mm->free_list[i],
+ struct drm_buddy_block,
+ link);
+ if (block)
+ break;
+ }
}
if (!block)
diff --git a/drivers/gpu/drm/i915/i915_ttm_buddy_manager.c b/drivers/gpu/drm/i915/i915_ttm_buddy_manager.c
index 9e3d130c3f42..b6ed5b37cf18 100644
--- a/drivers/gpu/drm/i915/i915_ttm_buddy_manager.c
+++ b/drivers/gpu/drm/i915/i915_ttm_buddy_manager.c
@@ -53,6 +53,9 @@ static int i915_ttm_buddy_man_alloc(struct ttm_resource_manager *man,
INIT_LIST_HEAD(&bman_res->blocks);
bman_res->mm = mm;
+ if (place->flags & TTM_PL_FLAG_TOPDOWN)
+ bman_res->flags |= DRM_BUDDY_TOPDOWN_ALLOCATION;
+
if (place->fpfn || lpfn != man->size)
bman_res->flags |= DRM_BUDDY_RANGE_ALLOCATION;
diff --git a/include/drm/drm_buddy.h b/include/drm/drm_buddy.h
index 2ec3cbc9d5d7..cbe5e648440a 100644
--- a/include/drm/drm_buddy.h
+++ b/include/drm/drm_buddy.h
@@ -28,6 +28,7 @@
})
#define DRM_BUDDY_RANGE_ALLOCATION (1 << 0)
+#define DRM_BUDDY_TOPDOWN_ALLOCATION (1 << 1)
struct drm_buddy_block {
#define DRM_BUDDY_HEADER_OFFSET GENMASK_ULL(63, 12)
--
2.25.1
^ permalink raw reply related [flat|nested] 46+ messages in thread
* [PATCH v3 4/6] drm: implement a method to free unused pages
2021-11-16 20:18 ` Arunpravin
(?)
@ 2021-11-16 20:18 ` Arunpravin
-1 siblings, 0 replies; 46+ messages in thread
From: Arunpravin @ 2021-11-16 20:18 UTC (permalink / raw)
To: dri-devel, intel-gfx, amd-gfx
Cc: Arunpravin, matthew.auld, tzimmermann, alexander.deucher,
christian.koenig
On contiguous allocation, we round up the size
to the *next* power of 2, implement a function
to free the unused pages after the newly allocate block.
v2(Matthew Auld):
- replace function name 'drm_buddy_free_unused_pages' with
drm_buddy_block_trim
- replace input argument name 'actual_size' with 'new_size'
- add more validation checks for input arguments
- add overlaps check to avoid needless searching and splitting
- merged the below patch to see the feature in action
- add free unused pages support to i915 driver
- lock drm_buddy_block_trim() function as it calls mark_free/mark_split
are all globally visible
Signed-off-by: Arunpravin <Arunpravin.PaneerSelvam@amd.com>
---
drivers/gpu/drm/drm_buddy.c | 108 ++++++++++++++++++
drivers/gpu/drm/i915/i915_ttm_buddy_manager.c | 10 ++
include/drm/drm_buddy.h | 4 +
3 files changed, 122 insertions(+)
diff --git a/drivers/gpu/drm/drm_buddy.c b/drivers/gpu/drm/drm_buddy.c
index 0a9db2981188..943fe2ad27bf 100644
--- a/drivers/gpu/drm/drm_buddy.c
+++ b/drivers/gpu/drm/drm_buddy.c
@@ -284,6 +284,114 @@ static inline bool contains(u64 s1, u64 e1, u64 s2, u64 e2)
return s1 <= s2 && e1 >= e2;
}
+/**
+ * drm_buddy_block_trim - free unused pages
+ *
+ * @mm: DRM buddy manager
+ * @new_size: original size requested
+ * @blocks: output list head to add allocated blocks
+ *
+ * For contiguous allocation, we round up the size to the nearest
+ * power of two value, drivers consume *actual* size, so remaining
+ * portions are unused and it can be freed.
+ *
+ * Returns:
+ * 0 on success, error code on failure.
+ */
+int drm_buddy_block_trim(struct drm_buddy_mm *mm,
+ u64 new_size,
+ struct list_head *blocks)
+{
+ struct drm_buddy_block *block;
+ struct drm_buddy_block *buddy;
+ u64 new_start;
+ u64 new_end;
+ LIST_HEAD(dfs);
+ u64 count = 0;
+ int err;
+
+ if (!list_is_singular(blocks))
+ return -EINVAL;
+
+ block = list_first_entry(blocks,
+ struct drm_buddy_block,
+ link);
+
+ if (!drm_buddy_block_is_allocated(block))
+ return -EINVAL;
+
+ if (new_size > drm_buddy_block_size(mm, block))
+ return -EINVAL;
+
+ if (!new_size && !IS_ALIGNED(new_size, mm->chunk_size))
+ return -EINVAL;
+
+ if (new_size == drm_buddy_block_size(mm, block))
+ return 0;
+
+ list_del(&block->link);
+
+ new_start = drm_buddy_block_offset(block);
+ new_end = new_start + new_size - 1;
+
+ mark_free(mm, block);
+
+ list_add(&block->tmp_link, &dfs);
+
+ do {
+ u64 block_start;
+ u64 block_end;
+
+ block = list_first_entry_or_null(&dfs,
+ struct drm_buddy_block,
+ tmp_link);
+ if (!block)
+ break;
+
+ list_del(&block->tmp_link);
+
+ if (count == new_size)
+ return 0;
+
+ block_start = drm_buddy_block_offset(block);
+ block_end = block_start + drm_buddy_block_size(mm, block) - 1;
+
+ if (!overlaps(new_start, new_end, block_start, block_end))
+ continue;
+
+ if (contains(new_start, new_end, block_start, block_end)) {
+ BUG_ON(!drm_buddy_block_is_free(block));
+
+ /* Allocate only required blocks */
+ mark_allocated(block);
+ mm->avail -= drm_buddy_block_size(mm, block);
+ list_add_tail(&block->link, blocks);
+ count += drm_buddy_block_size(mm, block);
+ continue;
+ }
+
+ if (!drm_buddy_block_is_split(block)) {
+ err = split_block(mm, block);
+ if (unlikely(err))
+ goto err_undo;
+ }
+
+ list_add(&block->right->tmp_link, &dfs);
+ list_add(&block->left->tmp_link, &dfs);
+ } while (1);
+
+ return -ENOSPC;
+
+err_undo:
+ buddy = get_buddy(block);
+ if (buddy &&
+ (drm_buddy_block_is_free(block) &&
+ drm_buddy_block_is_free(buddy)))
+ __drm_buddy_free(mm, block);
+ return err;
+}
+EXPORT_SYMBOL(drm_buddy_block_trim);
+
static struct drm_buddy_block *
alloc_range(struct drm_buddy_mm *mm,
u64 start, u64 end,
diff --git a/drivers/gpu/drm/i915/i915_ttm_buddy_manager.c b/drivers/gpu/drm/i915/i915_ttm_buddy_manager.c
index b6ed5b37cf18..5e1f8c443058 100644
--- a/drivers/gpu/drm/i915/i915_ttm_buddy_manager.c
+++ b/drivers/gpu/drm/i915/i915_ttm_buddy_manager.c
@@ -97,6 +97,16 @@ static int i915_ttm_buddy_man_alloc(struct ttm_resource_manager *man,
if (unlikely(err))
goto err_free_blocks;
+ if (place->flags & TTM_PL_FLAG_CONTIGUOUS) {
+ mutex_lock(&bman->lock);
+ err = drm_buddy_block_trim(mm,
+ (u64)n_pages << PAGE_SHIFT,
+ &bman_res->blocks);
+ mutex_unlock(&bman->lock);
+ if (unlikely(err))
+ goto err_free_blocks;
+ }
+
*res = &bman_res->base;
return 0;
diff --git a/include/drm/drm_buddy.h b/include/drm/drm_buddy.h
index cbe5e648440a..36e8f548acf7 100644
--- a/include/drm/drm_buddy.h
+++ b/include/drm/drm_buddy.h
@@ -145,6 +145,10 @@ int drm_buddy_alloc(struct drm_buddy_mm *mm,
struct list_head *blocks,
unsigned long flags);
+int drm_buddy_block_trim(struct drm_buddy_mm *mm,
+ u64 new_size,
+ struct list_head *blocks);
+
void drm_buddy_free(struct drm_buddy_mm *mm, struct drm_buddy_block *block);
void drm_buddy_free_list(struct drm_buddy_mm *mm, struct list_head *objects);
--
2.25.1
^ permalink raw reply related [flat|nested] 46+ messages in thread
* [PATCH v3 4/6] drm: implement a method to free unused pages
@ 2021-11-16 20:18 ` Arunpravin
0 siblings, 0 replies; 46+ messages in thread
From: Arunpravin @ 2021-11-16 20:18 UTC (permalink / raw)
To: dri-devel, intel-gfx, amd-gfx
Cc: daniel, Arunpravin, jani.nikula, matthew.auld, tzimmermann,
alexander.deucher, christian.koenig
On contiguous allocation, we round up the size
to the *next* power of 2, implement a function
to free the unused pages after the newly allocate block.
v2(Matthew Auld):
- replace function name 'drm_buddy_free_unused_pages' with
drm_buddy_block_trim
- replace input argument name 'actual_size' with 'new_size'
- add more validation checks for input arguments
- add overlaps check to avoid needless searching and splitting
- merged the below patch to see the feature in action
- add free unused pages support to i915 driver
- lock drm_buddy_block_trim() function as it calls mark_free/mark_split
are all globally visible
Signed-off-by: Arunpravin <Arunpravin.PaneerSelvam@amd.com>
---
drivers/gpu/drm/drm_buddy.c | 108 ++++++++++++++++++
drivers/gpu/drm/i915/i915_ttm_buddy_manager.c | 10 ++
include/drm/drm_buddy.h | 4 +
3 files changed, 122 insertions(+)
diff --git a/drivers/gpu/drm/drm_buddy.c b/drivers/gpu/drm/drm_buddy.c
index 0a9db2981188..943fe2ad27bf 100644
--- a/drivers/gpu/drm/drm_buddy.c
+++ b/drivers/gpu/drm/drm_buddy.c
@@ -284,6 +284,114 @@ static inline bool contains(u64 s1, u64 e1, u64 s2, u64 e2)
return s1 <= s2 && e1 >= e2;
}
+/**
+ * drm_buddy_block_trim - free unused pages
+ *
+ * @mm: DRM buddy manager
+ * @new_size: original size requested
+ * @blocks: output list head to add allocated blocks
+ *
+ * For contiguous allocation, we round up the size to the nearest
+ * power of two value, drivers consume *actual* size, so remaining
+ * portions are unused and it can be freed.
+ *
+ * Returns:
+ * 0 on success, error code on failure.
+ */
+int drm_buddy_block_trim(struct drm_buddy_mm *mm,
+ u64 new_size,
+ struct list_head *blocks)
+{
+ struct drm_buddy_block *block;
+ struct drm_buddy_block *buddy;
+ u64 new_start;
+ u64 new_end;
+ LIST_HEAD(dfs);
+ u64 count = 0;
+ int err;
+
+ if (!list_is_singular(blocks))
+ return -EINVAL;
+
+ block = list_first_entry(blocks,
+ struct drm_buddy_block,
+ link);
+
+ if (!drm_buddy_block_is_allocated(block))
+ return -EINVAL;
+
+ if (new_size > drm_buddy_block_size(mm, block))
+ return -EINVAL;
+
+ if (!new_size && !IS_ALIGNED(new_size, mm->chunk_size))
+ return -EINVAL;
+
+ if (new_size == drm_buddy_block_size(mm, block))
+ return 0;
+
+ list_del(&block->link);
+
+ new_start = drm_buddy_block_offset(block);
+ new_end = new_start + new_size - 1;
+
+ mark_free(mm, block);
+
+ list_add(&block->tmp_link, &dfs);
+
+ do {
+ u64 block_start;
+ u64 block_end;
+
+ block = list_first_entry_or_null(&dfs,
+ struct drm_buddy_block,
+ tmp_link);
+ if (!block)
+ break;
+
+ list_del(&block->tmp_link);
+
+ if (count == new_size)
+ return 0;
+
+ block_start = drm_buddy_block_offset(block);
+ block_end = block_start + drm_buddy_block_size(mm, block) - 1;
+
+ if (!overlaps(new_start, new_end, block_start, block_end))
+ continue;
+
+ if (contains(new_start, new_end, block_start, block_end)) {
+ BUG_ON(!drm_buddy_block_is_free(block));
+
+ /* Allocate only required blocks */
+ mark_allocated(block);
+ mm->avail -= drm_buddy_block_size(mm, block);
+ list_add_tail(&block->link, blocks);
+ count += drm_buddy_block_size(mm, block);
+ continue;
+ }
+
+ if (!drm_buddy_block_is_split(block)) {
+ err = split_block(mm, block);
+ if (unlikely(err))
+ goto err_undo;
+ }
+
+ list_add(&block->right->tmp_link, &dfs);
+ list_add(&block->left->tmp_link, &dfs);
+ } while (1);
+
+ return -ENOSPC;
+
+err_undo:
+ buddy = get_buddy(block);
+ if (buddy &&
+ (drm_buddy_block_is_free(block) &&
+ drm_buddy_block_is_free(buddy)))
+ __drm_buddy_free(mm, block);
+ return err;
+}
+EXPORT_SYMBOL(drm_buddy_block_trim);
+
static struct drm_buddy_block *
alloc_range(struct drm_buddy_mm *mm,
u64 start, u64 end,
diff --git a/drivers/gpu/drm/i915/i915_ttm_buddy_manager.c b/drivers/gpu/drm/i915/i915_ttm_buddy_manager.c
index b6ed5b37cf18..5e1f8c443058 100644
--- a/drivers/gpu/drm/i915/i915_ttm_buddy_manager.c
+++ b/drivers/gpu/drm/i915/i915_ttm_buddy_manager.c
@@ -97,6 +97,16 @@ static int i915_ttm_buddy_man_alloc(struct ttm_resource_manager *man,
if (unlikely(err))
goto err_free_blocks;
+ if (place->flags & TTM_PL_FLAG_CONTIGUOUS) {
+ mutex_lock(&bman->lock);
+ err = drm_buddy_block_trim(mm,
+ (u64)n_pages << PAGE_SHIFT,
+ &bman_res->blocks);
+ mutex_unlock(&bman->lock);
+ if (unlikely(err))
+ goto err_free_blocks;
+ }
+
*res = &bman_res->base;
return 0;
diff --git a/include/drm/drm_buddy.h b/include/drm/drm_buddy.h
index cbe5e648440a..36e8f548acf7 100644
--- a/include/drm/drm_buddy.h
+++ b/include/drm/drm_buddy.h
@@ -145,6 +145,10 @@ int drm_buddy_alloc(struct drm_buddy_mm *mm,
struct list_head *blocks,
unsigned long flags);
+int drm_buddy_block_trim(struct drm_buddy_mm *mm,
+ u64 new_size,
+ struct list_head *blocks);
+
void drm_buddy_free(struct drm_buddy_mm *mm, struct drm_buddy_block *block);
void drm_buddy_free_list(struct drm_buddy_mm *mm, struct list_head *objects);
--
2.25.1
^ permalink raw reply related [flat|nested] 46+ messages in thread
* [Intel-gfx] [PATCH v3 4/6] drm: implement a method to free unused pages
@ 2021-11-16 20:18 ` Arunpravin
0 siblings, 0 replies; 46+ messages in thread
From: Arunpravin @ 2021-11-16 20:18 UTC (permalink / raw)
To: dri-devel, intel-gfx, amd-gfx
Cc: Arunpravin, matthew.auld, tzimmermann, alexander.deucher,
christian.koenig
On contiguous allocation, we round up the size
to the *next* power of 2, implement a function
to free the unused pages after the newly allocate block.
v2(Matthew Auld):
- replace function name 'drm_buddy_free_unused_pages' with
drm_buddy_block_trim
- replace input argument name 'actual_size' with 'new_size'
- add more validation checks for input arguments
- add overlaps check to avoid needless searching and splitting
- merged the below patch to see the feature in action
- add free unused pages support to i915 driver
- lock drm_buddy_block_trim() function as it calls mark_free/mark_split
are all globally visible
Signed-off-by: Arunpravin <Arunpravin.PaneerSelvam@amd.com>
---
drivers/gpu/drm/drm_buddy.c | 108 ++++++++++++++++++
drivers/gpu/drm/i915/i915_ttm_buddy_manager.c | 10 ++
include/drm/drm_buddy.h | 4 +
3 files changed, 122 insertions(+)
diff --git a/drivers/gpu/drm/drm_buddy.c b/drivers/gpu/drm/drm_buddy.c
index 0a9db2981188..943fe2ad27bf 100644
--- a/drivers/gpu/drm/drm_buddy.c
+++ b/drivers/gpu/drm/drm_buddy.c
@@ -284,6 +284,114 @@ static inline bool contains(u64 s1, u64 e1, u64 s2, u64 e2)
return s1 <= s2 && e1 >= e2;
}
+/**
+ * drm_buddy_block_trim - free unused pages
+ *
+ * @mm: DRM buddy manager
+ * @new_size: original size requested
+ * @blocks: output list head to add allocated blocks
+ *
+ * For contiguous allocation, we round up the size to the nearest
+ * power of two value, drivers consume *actual* size, so remaining
+ * portions are unused and it can be freed.
+ *
+ * Returns:
+ * 0 on success, error code on failure.
+ */
+int drm_buddy_block_trim(struct drm_buddy_mm *mm,
+ u64 new_size,
+ struct list_head *blocks)
+{
+ struct drm_buddy_block *block;
+ struct drm_buddy_block *buddy;
+ u64 new_start;
+ u64 new_end;
+ LIST_HEAD(dfs);
+ u64 count = 0;
+ int err;
+
+ if (!list_is_singular(blocks))
+ return -EINVAL;
+
+ block = list_first_entry(blocks,
+ struct drm_buddy_block,
+ link);
+
+ if (!drm_buddy_block_is_allocated(block))
+ return -EINVAL;
+
+ if (new_size > drm_buddy_block_size(mm, block))
+ return -EINVAL;
+
+ if (!new_size && !IS_ALIGNED(new_size, mm->chunk_size))
+ return -EINVAL;
+
+ if (new_size == drm_buddy_block_size(mm, block))
+ return 0;
+
+ list_del(&block->link);
+
+ new_start = drm_buddy_block_offset(block);
+ new_end = new_start + new_size - 1;
+
+ mark_free(mm, block);
+
+ list_add(&block->tmp_link, &dfs);
+
+ do {
+ u64 block_start;
+ u64 block_end;
+
+ block = list_first_entry_or_null(&dfs,
+ struct drm_buddy_block,
+ tmp_link);
+ if (!block)
+ break;
+
+ list_del(&block->tmp_link);
+
+ if (count == new_size)
+ return 0;
+
+ block_start = drm_buddy_block_offset(block);
+ block_end = block_start + drm_buddy_block_size(mm, block) - 1;
+
+ if (!overlaps(new_start, new_end, block_start, block_end))
+ continue;
+
+ if (contains(new_start, new_end, block_start, block_end)) {
+ BUG_ON(!drm_buddy_block_is_free(block));
+
+ /* Allocate only required blocks */
+ mark_allocated(block);
+ mm->avail -= drm_buddy_block_size(mm, block);
+ list_add_tail(&block->link, blocks);
+ count += drm_buddy_block_size(mm, block);
+ continue;
+ }
+
+ if (!drm_buddy_block_is_split(block)) {
+ err = split_block(mm, block);
+ if (unlikely(err))
+ goto err_undo;
+ }
+
+ list_add(&block->right->tmp_link, &dfs);
+ list_add(&block->left->tmp_link, &dfs);
+ } while (1);
+
+ return -ENOSPC;
+
+err_undo:
+ buddy = get_buddy(block);
+ if (buddy &&
+ (drm_buddy_block_is_free(block) &&
+ drm_buddy_block_is_free(buddy)))
+ __drm_buddy_free(mm, block);
+ return err;
+}
+EXPORT_SYMBOL(drm_buddy_block_trim);
+
static struct drm_buddy_block *
alloc_range(struct drm_buddy_mm *mm,
u64 start, u64 end,
diff --git a/drivers/gpu/drm/i915/i915_ttm_buddy_manager.c b/drivers/gpu/drm/i915/i915_ttm_buddy_manager.c
index b6ed5b37cf18..5e1f8c443058 100644
--- a/drivers/gpu/drm/i915/i915_ttm_buddy_manager.c
+++ b/drivers/gpu/drm/i915/i915_ttm_buddy_manager.c
@@ -97,6 +97,16 @@ static int i915_ttm_buddy_man_alloc(struct ttm_resource_manager *man,
if (unlikely(err))
goto err_free_blocks;
+ if (place->flags & TTM_PL_FLAG_CONTIGUOUS) {
+ mutex_lock(&bman->lock);
+ err = drm_buddy_block_trim(mm,
+ (u64)n_pages << PAGE_SHIFT,
+ &bman_res->blocks);
+ mutex_unlock(&bman->lock);
+ if (unlikely(err))
+ goto err_free_blocks;
+ }
+
*res = &bman_res->base;
return 0;
diff --git a/include/drm/drm_buddy.h b/include/drm/drm_buddy.h
index cbe5e648440a..36e8f548acf7 100644
--- a/include/drm/drm_buddy.h
+++ b/include/drm/drm_buddy.h
@@ -145,6 +145,10 @@ int drm_buddy_alloc(struct drm_buddy_mm *mm,
struct list_head *blocks,
unsigned long flags);
+int drm_buddy_block_trim(struct drm_buddy_mm *mm,
+ u64 new_size,
+ struct list_head *blocks);
+
void drm_buddy_free(struct drm_buddy_mm *mm, struct drm_buddy_block *block);
void drm_buddy_free_list(struct drm_buddy_mm *mm, struct list_head *objects);
--
2.25.1
^ permalink raw reply related [flat|nested] 46+ messages in thread
* [PATCH v3 5/6] drm/amdgpu: move vram inline functions into a header
2021-11-16 20:18 ` Arunpravin
(?)
@ 2021-11-16 20:18 ` Arunpravin
-1 siblings, 0 replies; 46+ messages in thread
From: Arunpravin @ 2021-11-16 20:18 UTC (permalink / raw)
To: dri-devel, intel-gfx, amd-gfx
Cc: Arunpravin, matthew.auld, tzimmermann, alexander.deucher,
christian.koenig
Move shared vram inline functions and structs
into a header file
Signed-off-by: Arunpravin <Arunpravin.PaneerSelvam@amd.com>
---
drivers/gpu/drm/amd/amdgpu/amdgpu_vram_mgr.h | 51 ++++++++++++++++++++
1 file changed, 51 insertions(+)
create mode 100644 drivers/gpu/drm/amd/amdgpu/amdgpu_vram_mgr.h
diff --git a/drivers/gpu/drm/amd/amdgpu/amdgpu_vram_mgr.h b/drivers/gpu/drm/amd/amdgpu/amdgpu_vram_mgr.h
new file mode 100644
index 000000000000..59983464cce5
--- /dev/null
+++ b/drivers/gpu/drm/amd/amdgpu/amdgpu_vram_mgr.h
@@ -0,0 +1,51 @@
+/* SPDX-License-Identifier: MIT
+ * Copyright 2021 Advanced Micro Devices, Inc.
+ *
+ * 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.
+ *
+ */
+
+#ifndef __AMDGPU_VRAM_MGR_H__
+#define __AMDGPU_VRAM_MGR_H__
+
+#include <drm/drm_buddy.h>
+
+struct amdgpu_vram_mgr_node {
+ struct ttm_resource base;
+ struct list_head blocks;
+ unsigned long flags;
+};
+
+static inline u64 amdgpu_node_start(struct drm_buddy_block *block)
+{
+ return drm_buddy_block_offset(block);
+}
+
+static inline u64 amdgpu_node_size(struct drm_buddy_block *block)
+{
+ return PAGE_SIZE << drm_buddy_block_order(block);
+}
+
+static inline struct amdgpu_vram_mgr_node *
+to_amdgpu_vram_mgr_node(struct ttm_resource *res)
+{
+ return container_of(res, struct amdgpu_vram_mgr_node, base);
+}
+
+#endif
--
2.25.1
^ permalink raw reply related [flat|nested] 46+ messages in thread
* [PATCH v3 5/6] drm/amdgpu: move vram inline functions into a header
@ 2021-11-16 20:18 ` Arunpravin
0 siblings, 0 replies; 46+ messages in thread
From: Arunpravin @ 2021-11-16 20:18 UTC (permalink / raw)
To: dri-devel, intel-gfx, amd-gfx
Cc: daniel, Arunpravin, jani.nikula, matthew.auld, tzimmermann,
alexander.deucher, christian.koenig
Move shared vram inline functions and structs
into a header file
Signed-off-by: Arunpravin <Arunpravin.PaneerSelvam@amd.com>
---
drivers/gpu/drm/amd/amdgpu/amdgpu_vram_mgr.h | 51 ++++++++++++++++++++
1 file changed, 51 insertions(+)
create mode 100644 drivers/gpu/drm/amd/amdgpu/amdgpu_vram_mgr.h
diff --git a/drivers/gpu/drm/amd/amdgpu/amdgpu_vram_mgr.h b/drivers/gpu/drm/amd/amdgpu/amdgpu_vram_mgr.h
new file mode 100644
index 000000000000..59983464cce5
--- /dev/null
+++ b/drivers/gpu/drm/amd/amdgpu/amdgpu_vram_mgr.h
@@ -0,0 +1,51 @@
+/* SPDX-License-Identifier: MIT
+ * Copyright 2021 Advanced Micro Devices, Inc.
+ *
+ * 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.
+ *
+ */
+
+#ifndef __AMDGPU_VRAM_MGR_H__
+#define __AMDGPU_VRAM_MGR_H__
+
+#include <drm/drm_buddy.h>
+
+struct amdgpu_vram_mgr_node {
+ struct ttm_resource base;
+ struct list_head blocks;
+ unsigned long flags;
+};
+
+static inline u64 amdgpu_node_start(struct drm_buddy_block *block)
+{
+ return drm_buddy_block_offset(block);
+}
+
+static inline u64 amdgpu_node_size(struct drm_buddy_block *block)
+{
+ return PAGE_SIZE << drm_buddy_block_order(block);
+}
+
+static inline struct amdgpu_vram_mgr_node *
+to_amdgpu_vram_mgr_node(struct ttm_resource *res)
+{
+ return container_of(res, struct amdgpu_vram_mgr_node, base);
+}
+
+#endif
--
2.25.1
^ permalink raw reply related [flat|nested] 46+ messages in thread
* [Intel-gfx] [PATCH v3 5/6] drm/amdgpu: move vram inline functions into a header
@ 2021-11-16 20:18 ` Arunpravin
0 siblings, 0 replies; 46+ messages in thread
From: Arunpravin @ 2021-11-16 20:18 UTC (permalink / raw)
To: dri-devel, intel-gfx, amd-gfx
Cc: Arunpravin, matthew.auld, tzimmermann, alexander.deucher,
christian.koenig
Move shared vram inline functions and structs
into a header file
Signed-off-by: Arunpravin <Arunpravin.PaneerSelvam@amd.com>
---
drivers/gpu/drm/amd/amdgpu/amdgpu_vram_mgr.h | 51 ++++++++++++++++++++
1 file changed, 51 insertions(+)
create mode 100644 drivers/gpu/drm/amd/amdgpu/amdgpu_vram_mgr.h
diff --git a/drivers/gpu/drm/amd/amdgpu/amdgpu_vram_mgr.h b/drivers/gpu/drm/amd/amdgpu/amdgpu_vram_mgr.h
new file mode 100644
index 000000000000..59983464cce5
--- /dev/null
+++ b/drivers/gpu/drm/amd/amdgpu/amdgpu_vram_mgr.h
@@ -0,0 +1,51 @@
+/* SPDX-License-Identifier: MIT
+ * Copyright 2021 Advanced Micro Devices, Inc.
+ *
+ * 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.
+ *
+ */
+
+#ifndef __AMDGPU_VRAM_MGR_H__
+#define __AMDGPU_VRAM_MGR_H__
+
+#include <drm/drm_buddy.h>
+
+struct amdgpu_vram_mgr_node {
+ struct ttm_resource base;
+ struct list_head blocks;
+ unsigned long flags;
+};
+
+static inline u64 amdgpu_node_start(struct drm_buddy_block *block)
+{
+ return drm_buddy_block_offset(block);
+}
+
+static inline u64 amdgpu_node_size(struct drm_buddy_block *block)
+{
+ return PAGE_SIZE << drm_buddy_block_order(block);
+}
+
+static inline struct amdgpu_vram_mgr_node *
+to_amdgpu_vram_mgr_node(struct ttm_resource *res)
+{
+ return container_of(res, struct amdgpu_vram_mgr_node, base);
+}
+
+#endif
--
2.25.1
^ permalink raw reply related [flat|nested] 46+ messages in thread
* [PATCH v3 6/6] drm/amdgpu: add drm buddy support to amdgpu
2021-11-16 20:18 ` Arunpravin
(?)
@ 2021-11-16 20:18 ` Arunpravin
-1 siblings, 0 replies; 46+ messages in thread
From: Arunpravin @ 2021-11-16 20:18 UTC (permalink / raw)
To: dri-devel, intel-gfx, amd-gfx
Cc: Arunpravin, matthew.auld, tzimmermann, alexander.deucher,
christian.koenig
- Remove drm_mm references and replace with drm buddy functionalities
- Add res cursor support for drm buddy
v2(Matthew Auld):
- replace spinlock with mutex as we call kmem_cache_zalloc(..., GFP_KERNEL)
in drm_buddy_alloc() function
- lock drm_buddy_block_trim() function as it calls mark_free/mark_split
are all globally visible
Signed-off-by: Arunpravin <Arunpravin.PaneerSelvam@amd.com>
---
.../gpu/drm/amd/amdgpu/amdgpu_res_cursor.h | 97 +++++--
drivers/gpu/drm/amd/amdgpu/amdgpu_ttm.h | 6 +-
drivers/gpu/drm/amd/amdgpu/amdgpu_vram_mgr.c | 263 ++++++++++--------
3 files changed, 233 insertions(+), 133 deletions(-)
diff --git a/drivers/gpu/drm/amd/amdgpu/amdgpu_res_cursor.h b/drivers/gpu/drm/amd/amdgpu/amdgpu_res_cursor.h
index acfa207cf970..da12b4ff2e45 100644
--- a/drivers/gpu/drm/amd/amdgpu/amdgpu_res_cursor.h
+++ b/drivers/gpu/drm/amd/amdgpu/amdgpu_res_cursor.h
@@ -30,12 +30,15 @@
#include <drm/ttm/ttm_resource.h>
#include <drm/ttm/ttm_range_manager.h>
+#include "amdgpu_vram_mgr.h"
+
/* state back for walking over vram_mgr and gtt_mgr allocations */
struct amdgpu_res_cursor {
uint64_t start;
uint64_t size;
uint64_t remaining;
- struct drm_mm_node *node;
+ void *node;
+ uint32_t mem_type;
};
/**
@@ -52,27 +55,63 @@ static inline void amdgpu_res_first(struct ttm_resource *res,
uint64_t start, uint64_t size,
struct amdgpu_res_cursor *cur)
{
+ struct drm_buddy_block *block;
+ struct list_head *head, *next;
struct drm_mm_node *node;
- if (!res || res->mem_type == TTM_PL_SYSTEM) {
- cur->start = start;
- cur->size = size;
- cur->remaining = size;
- cur->node = NULL;
- WARN_ON(res && start + size > res->num_pages << PAGE_SHIFT);
- return;
- }
+ if (!res)
+ goto err_out;
BUG_ON(start + size > res->num_pages << PAGE_SHIFT);
- node = to_ttm_range_mgr_node(res)->mm_nodes;
- while (start >= node->size << PAGE_SHIFT)
- start -= node++->size << PAGE_SHIFT;
+ cur->mem_type = res->mem_type;
+
+ switch (cur->mem_type) {
+ case TTM_PL_VRAM:
+ head = &to_amdgpu_vram_mgr_node(res)->blocks;
+
+ block = list_first_entry_or_null(head,
+ struct drm_buddy_block,
+ link);
+ if (!block)
+ goto err_out;
+
+ while (start >= amdgpu_node_size(block)) {
+ start -= amdgpu_node_size(block);
+
+ next = block->link.next;
+ if (next != head)
+ block = list_entry(next, struct drm_buddy_block, link);
+ }
+
+ cur->start = amdgpu_node_start(block) + start;
+ cur->size = min(amdgpu_node_size(block) - start, size);
+ cur->remaining = size;
+ cur->node = block;
+ break;
+ case TTM_PL_TT:
+ node = to_ttm_range_mgr_node(res)->mm_nodes;
+ while (start >= node->size << PAGE_SHIFT)
+ start -= node++->size << PAGE_SHIFT;
+
+ cur->start = (node->start << PAGE_SHIFT) + start;
+ cur->size = min((node->size << PAGE_SHIFT) - start, size);
+ cur->remaining = size;
+ cur->node = node;
+ break;
+ default:
+ goto err_out;
+ }
- cur->start = (node->start << PAGE_SHIFT) + start;
- cur->size = min((node->size << PAGE_SHIFT) - start, size);
+ return;
+
+err_out:
+ cur->start = start;
+ cur->size = size;
cur->remaining = size;
- cur->node = node;
+ cur->node = NULL;
+ WARN_ON(res && start + size > res->num_pages << PAGE_SHIFT);
+ return;
}
/**
@@ -85,7 +124,9 @@ static inline void amdgpu_res_first(struct ttm_resource *res,
*/
static inline void amdgpu_res_next(struct amdgpu_res_cursor *cur, uint64_t size)
{
- struct drm_mm_node *node = cur->node;
+ struct drm_buddy_block *block;
+ struct drm_mm_node *node;
+ struct list_head *next;
BUG_ON(size > cur->remaining);
@@ -99,9 +140,27 @@ static inline void amdgpu_res_next(struct amdgpu_res_cursor *cur, uint64_t size)
return;
}
- cur->node = ++node;
- cur->start = node->start << PAGE_SHIFT;
- cur->size = min(node->size << PAGE_SHIFT, cur->remaining);
+ switch (cur->mem_type) {
+ case TTM_PL_VRAM:
+ block = cur->node;
+
+ next = block->link.next;
+ block = list_entry(next, struct drm_buddy_block, link);
+
+ cur->node = block;
+ cur->start = amdgpu_node_start(block);
+ cur->size = min(amdgpu_node_size(block), cur->remaining);
+ break;
+ case TTM_PL_TT:
+ node = cur->node;
+
+ cur->node = ++node;
+ cur->start = node->start << PAGE_SHIFT;
+ cur->size = min(node->size << PAGE_SHIFT, cur->remaining);
+ break;
+ default:
+ return;
+ }
}
#endif
diff --git a/drivers/gpu/drm/amd/amdgpu/amdgpu_ttm.h b/drivers/gpu/drm/amd/amdgpu/amdgpu_ttm.h
index 7346ecff4438..946dfac486a7 100644
--- a/drivers/gpu/drm/amd/amdgpu/amdgpu_ttm.h
+++ b/drivers/gpu/drm/amd/amdgpu/amdgpu_ttm.h
@@ -26,6 +26,7 @@
#include <linux/dma-direction.h>
#include <drm/gpu_scheduler.h>
+#include <drm/drm_buddy.h>
#include "amdgpu.h"
#define AMDGPU_PL_GDS (TTM_PL_PRIV + 0)
@@ -40,12 +41,13 @@
struct amdgpu_vram_mgr {
struct ttm_resource_manager manager;
- struct drm_mm mm;
- spinlock_t lock;
+ struct drm_buddy_mm mm;
+ struct mutex lock;
struct list_head reservations_pending;
struct list_head reserved_pages;
atomic64_t usage;
atomic64_t vis_usage;
+ u64 default_page_size;
};
struct amdgpu_gtt_mgr {
diff --git a/drivers/gpu/drm/amd/amdgpu/amdgpu_vram_mgr.c b/drivers/gpu/drm/amd/amdgpu/amdgpu_vram_mgr.c
index 7b2b0980ec41..e6074733f00e 100644
--- a/drivers/gpu/drm/amd/amdgpu/amdgpu_vram_mgr.c
+++ b/drivers/gpu/drm/amd/amdgpu/amdgpu_vram_mgr.c
@@ -32,8 +32,12 @@
#include "atom.h"
struct amdgpu_vram_reservation {
+ u64 start;
+ u64 size;
+ u64 min_size;
+ unsigned long flags;
+ struct list_head block;
struct list_head node;
- struct drm_mm_node mm_node;
};
static inline struct amdgpu_vram_mgr *
@@ -196,10 +200,10 @@ const struct attribute_group amdgpu_vram_mgr_attr_group = {
* Calculate how many bytes of the MM node are inside visible VRAM
*/
static u64 amdgpu_vram_mgr_vis_size(struct amdgpu_device *adev,
- struct drm_mm_node *node)
+ struct drm_buddy_block *block)
{
- uint64_t start = node->start << PAGE_SHIFT;
- uint64_t end = (node->size + node->start) << PAGE_SHIFT;
+ u64 start = amdgpu_node_start(block);
+ u64 end = start + amdgpu_node_size(block);
if (start >= adev->gmc.visible_vram_size)
return 0;
@@ -220,9 +224,9 @@ u64 amdgpu_vram_mgr_bo_visible_size(struct amdgpu_bo *bo)
{
struct amdgpu_device *adev = amdgpu_ttm_adev(bo->tbo.bdev);
struct ttm_resource *res = bo->tbo.resource;
- unsigned pages = res->num_pages;
- struct drm_mm_node *mm;
- u64 usage;
+ struct amdgpu_vram_mgr_node *node = to_amdgpu_vram_mgr_node(res);
+ struct drm_buddy_block *block;
+ u64 usage = 0;
if (amdgpu_gmc_vram_full_visible(&adev->gmc))
return amdgpu_bo_size(bo);
@@ -230,9 +234,8 @@ u64 amdgpu_vram_mgr_bo_visible_size(struct amdgpu_bo *bo)
if (res->start >= adev->gmc.visible_vram_size >> PAGE_SHIFT)
return 0;
- mm = &container_of(res, struct ttm_range_mgr_node, base)->mm_nodes[0];
- for (usage = 0; pages; pages -= mm->size, mm++)
- usage += amdgpu_vram_mgr_vis_size(adev, mm);
+ list_for_each_entry(block, &node->blocks, link)
+ usage += amdgpu_vram_mgr_vis_size(adev, block);
return usage;
}
@@ -242,21 +245,29 @@ static void amdgpu_vram_mgr_do_reserve(struct ttm_resource_manager *man)
{
struct amdgpu_vram_mgr *mgr = to_vram_mgr(man);
struct amdgpu_device *adev = to_amdgpu_device(mgr);
- struct drm_mm *mm = &mgr->mm;
+ struct drm_buddy_mm *mm = &mgr->mm;
struct amdgpu_vram_reservation *rsv, *temp;
+ struct drm_buddy_block *block;
uint64_t vis_usage;
list_for_each_entry_safe(rsv, temp, &mgr->reservations_pending, node) {
- if (drm_mm_reserve_node(mm, &rsv->mm_node))
+ if (drm_buddy_alloc(mm, rsv->start, rsv->start + rsv->size,
+ rsv->size, rsv->min_size, &rsv->block,
+ rsv->flags))
continue;
- dev_dbg(adev->dev, "Reservation 0x%llx - %lld, Succeeded\n",
- rsv->mm_node.start, rsv->mm_node.size);
-
- vis_usage = amdgpu_vram_mgr_vis_size(adev, &rsv->mm_node);
- atomic64_add(vis_usage, &mgr->vis_usage);
- atomic64_add(rsv->mm_node.size << PAGE_SHIFT, &mgr->usage);
- list_move(&rsv->node, &mgr->reserved_pages);
+ block = list_first_entry_or_null(&rsv->block,
+ struct drm_buddy_block,
+ link);
+ if (block) {
+ dev_dbg(adev->dev, "Reservation 0x%llx - %lld, Succeeded\n",
+ rsv->start, rsv->size);
+
+ vis_usage = amdgpu_vram_mgr_vis_size(adev, block);
+ atomic64_add(vis_usage, &mgr->vis_usage);
+ atomic64_add(rsv->size, &mgr->usage);
+ list_move(&rsv->node, &mgr->reserved_pages);
+ }
}
}
@@ -280,13 +291,17 @@ int amdgpu_vram_mgr_reserve_range(struct ttm_resource_manager *man,
return -ENOMEM;
INIT_LIST_HEAD(&rsv->node);
- rsv->mm_node.start = start >> PAGE_SHIFT;
- rsv->mm_node.size = size >> PAGE_SHIFT;
+ INIT_LIST_HEAD(&rsv->block);
+
+ rsv->start = start;
+ rsv->size = size;
+ rsv->min_size = size;
+ rsv->flags |= DRM_BUDDY_RANGE_ALLOCATION;
- spin_lock(&mgr->lock);
- list_add_tail(&mgr->reservations_pending, &rsv->node);
+ mutex_lock(&mgr->lock);
+ list_add_tail(&rsv->node, &mgr->reservations_pending);
amdgpu_vram_mgr_do_reserve(man);
- spin_unlock(&mgr->lock);
+ mutex_unlock(&mgr->lock);
return 0;
}
@@ -309,19 +324,19 @@ int amdgpu_vram_mgr_query_page_status(struct ttm_resource_manager *man,
struct amdgpu_vram_reservation *rsv;
int ret;
- spin_lock(&mgr->lock);
+ mutex_lock(&mgr->lock);
list_for_each_entry(rsv, &mgr->reservations_pending, node) {
- if ((rsv->mm_node.start <= start) &&
- (start < (rsv->mm_node.start + rsv->mm_node.size))) {
+ if ((rsv->start <= start) &&
+ (start < (rsv->start + rsv->size))) {
ret = -EBUSY;
goto out;
}
}
list_for_each_entry(rsv, &mgr->reserved_pages, node) {
- if ((rsv->mm_node.start <= start) &&
- (start < (rsv->mm_node.start + rsv->mm_node.size))) {
+ if ((rsv->start <= start) &&
+ (start < (rsv->start + rsv->size))) {
ret = 0;
goto out;
}
@@ -329,32 +344,10 @@ int amdgpu_vram_mgr_query_page_status(struct ttm_resource_manager *man,
ret = -ENOENT;
out:
- spin_unlock(&mgr->lock);
+ mutex_unlock(&mgr->lock);
return ret;
}
-/**
- * amdgpu_vram_mgr_virt_start - update virtual start address
- *
- * @mem: ttm_resource to update
- * @node: just allocated node
- *
- * Calculate a virtual BO start address to easily check if everything is CPU
- * accessible.
- */
-static void amdgpu_vram_mgr_virt_start(struct ttm_resource *mem,
- struct drm_mm_node *node)
-{
- unsigned long start;
-
- start = node->start + node->size;
- if (start > mem->num_pages)
- start -= mem->num_pages;
- else
- start = 0;
- mem->start = max(mem->start, start);
-}
-
/**
* amdgpu_vram_mgr_new - allocate new ranges
*
@@ -370,13 +363,13 @@ static int amdgpu_vram_mgr_new(struct ttm_resource_manager *man,
const struct ttm_place *place,
struct ttm_resource **res)
{
- unsigned long lpfn, num_nodes, pages_per_node, pages_left, pages;
+ unsigned long lpfn, pages_per_node, pages_left, pages, n_pages;
+ u64 vis_usage = 0, mem_bytes, max_bytes, min_page_size;
struct amdgpu_vram_mgr *mgr = to_vram_mgr(man);
struct amdgpu_device *adev = to_amdgpu_device(mgr);
- uint64_t vis_usage = 0, mem_bytes, max_bytes;
- struct ttm_range_mgr_node *node;
- struct drm_mm *mm = &mgr->mm;
- enum drm_mm_insert_mode mode;
+ struct amdgpu_vram_mgr_node *node;
+ struct drm_buddy_mm *mm = &mgr->mm;
+ struct drm_buddy_block *block;
unsigned i;
int r;
@@ -395,10 +388,9 @@ static int amdgpu_vram_mgr_new(struct ttm_resource_manager *man,
goto error_sub;
}
- if (place->flags & TTM_PL_FLAG_CONTIGUOUS) {
+ if (place->flags & TTM_PL_FLAG_CONTIGUOUS)
pages_per_node = ~0ul;
- num_nodes = 1;
- } else {
+ else {
#ifdef CONFIG_TRANSPARENT_HUGEPAGE
pages_per_node = HPAGE_PMD_NR;
#else
@@ -407,11 +399,9 @@ static int amdgpu_vram_mgr_new(struct ttm_resource_manager *man,
#endif
pages_per_node = max_t(uint32_t, pages_per_node,
tbo->page_alignment);
- num_nodes = DIV_ROUND_UP_ULL(PFN_UP(mem_bytes), pages_per_node);
}
- node = kvmalloc(struct_size(node, mm_nodes, num_nodes),
- GFP_KERNEL | __GFP_ZERO);
+ node = kzalloc(sizeof(*node), GFP_KERNEL);
if (!node) {
r = -ENOMEM;
goto error_sub;
@@ -419,9 +409,17 @@ static int amdgpu_vram_mgr_new(struct ttm_resource_manager *man,
ttm_resource_init(tbo, place, &node->base);
- mode = DRM_MM_INSERT_BEST;
+ INIT_LIST_HEAD(&node->blocks);
+
if (place->flags & TTM_PL_FLAG_TOPDOWN)
- mode = DRM_MM_INSERT_HIGH;
+ node->flags |= DRM_BUDDY_TOPDOWN_ALLOCATION;
+
+ if (place->fpfn || lpfn != man->size)
+ /* Allocate blocks in desired range */
+ node->flags |= DRM_BUDDY_RANGE_ALLOCATION;
+
+ min_page_size = mgr->default_page_size;
+ BUG_ON(min_page_size < mm->chunk_size);
pages_left = node->base.num_pages;
@@ -429,36 +427,63 @@ static int amdgpu_vram_mgr_new(struct ttm_resource_manager *man,
pages = min(pages_left, 2UL << (30 - PAGE_SHIFT));
i = 0;
- spin_lock(&mgr->lock);
while (pages_left) {
- uint32_t alignment = tbo->page_alignment;
-
if (pages >= pages_per_node)
- alignment = pages_per_node;
-
- r = drm_mm_insert_node_in_range(mm, &node->mm_nodes[i], pages,
- alignment, 0, place->fpfn,
- lpfn, mode);
- if (unlikely(r)) {
- if (pages > pages_per_node) {
- if (is_power_of_2(pages))
- pages = pages / 2;
- else
- pages = rounddown_pow_of_two(pages);
- continue;
- }
- goto error_free;
+ pages = pages_per_node;
+
+ n_pages = pages;
+
+ if (place->flags & TTM_PL_FLAG_CONTIGUOUS) {
+ n_pages = roundup_pow_of_two(n_pages);
+ min_page_size = (u64)n_pages << PAGE_SHIFT;
+
+ if (n_pages > lpfn)
+ lpfn = n_pages;
}
- vis_usage += amdgpu_vram_mgr_vis_size(adev, &node->mm_nodes[i]);
- amdgpu_vram_mgr_virt_start(&node->base, &node->mm_nodes[i]);
+ mutex_lock(&mgr->lock);
+ r = drm_buddy_alloc(mm, (u64)place->fpfn << PAGE_SHIFT,
+ (u64)lpfn << PAGE_SHIFT,
+ (u64)n_pages << PAGE_SHIFT,
+ min_page_size,
+ &node->blocks,
+ node->flags);
+ mutex_unlock(&mgr->lock);
+ if (unlikely(r))
+ goto error_free_blocks;
+
pages_left -= pages;
++i;
if (pages > pages_left)
pages = pages_left;
}
- spin_unlock(&mgr->lock);
+
+ /* Free unused pages for contiguous allocation */
+ if (place->flags & TTM_PL_FLAG_CONTIGUOUS) {
+ u64 actual_size = (u64)node->base.num_pages << PAGE_SHIFT;
+
+ mutex_lock(&mgr->lock);
+ r = drm_buddy_block_trim(mm,
+ actual_size,
+ &node->blocks);
+ mutex_unlock(&mgr->lock);
+ if (unlikely(r))
+ goto error_free_blocks;
+ }
+
+ list_for_each_entry(block, &node->blocks, link)
+ vis_usage += amdgpu_vram_mgr_vis_size(adev, block);
+
+ block = list_first_entry_or_null(&node->blocks,
+ struct drm_buddy_block,
+ link);
+ if (!block) {
+ r = -ENOENT;
+ goto error_free_res;
+ }
+
+ node->base.start = amdgpu_node_start(block) >> PAGE_SHIFT;
if (i == 1)
node->base.placement |= TTM_PL_FLAG_CONTIGUOUS;
@@ -472,12 +497,12 @@ static int amdgpu_vram_mgr_new(struct ttm_resource_manager *man,
*res = &node->base;
return 0;
-error_free:
- while (i--)
- drm_mm_remove_node(&node->mm_nodes[i]);
- spin_unlock(&mgr->lock);
- kvfree(node);
-
+error_free_blocks:
+ mutex_lock(&mgr->lock);
+ drm_buddy_free_list(mm, &node->blocks);
+ mutex_unlock(&mgr->lock);
+error_free_res:
+ kfree(node);
error_sub:
atomic64_sub(mem_bytes, &mgr->usage);
return r;
@@ -494,28 +519,28 @@ static int amdgpu_vram_mgr_new(struct ttm_resource_manager *man,
static void amdgpu_vram_mgr_del(struct ttm_resource_manager *man,
struct ttm_resource *res)
{
- struct ttm_range_mgr_node *node = to_ttm_range_mgr_node(res);
+ struct amdgpu_vram_mgr_node *node = to_amdgpu_vram_mgr_node(res);
struct amdgpu_vram_mgr *mgr = to_vram_mgr(man);
struct amdgpu_device *adev = to_amdgpu_device(mgr);
+ struct drm_buddy_mm *mm = &mgr->mm;
+ struct drm_buddy_block *block;
uint64_t usage = 0, vis_usage = 0;
- unsigned i, pages;
- spin_lock(&mgr->lock);
- for (i = 0, pages = res->num_pages; pages;
- pages -= node->mm_nodes[i].size, ++i) {
- struct drm_mm_node *mm = &node->mm_nodes[i];
-
- drm_mm_remove_node(mm);
- usage += mm->size << PAGE_SHIFT;
- vis_usage += amdgpu_vram_mgr_vis_size(adev, mm);
+ mutex_lock(&mgr->lock);
+ list_for_each_entry(block, &node->blocks, link) {
+ usage += amdgpu_node_size(block);
+ vis_usage += amdgpu_vram_mgr_vis_size(adev, block);
}
+
amdgpu_vram_mgr_do_reserve(man);
- spin_unlock(&mgr->lock);
+
+ drm_buddy_free_list(mm, &node->blocks);
+ mutex_unlock(&mgr->lock);
atomic64_sub(usage, &mgr->usage);
atomic64_sub(vis_usage, &mgr->vis_usage);
- kvfree(node);
+ kfree(node);
}
/**
@@ -669,10 +694,19 @@ static void amdgpu_vram_mgr_debug(struct ttm_resource_manager *man,
struct drm_printer *printer)
{
struct amdgpu_vram_mgr *mgr = to_vram_mgr(man);
+ struct drm_buddy_mm *mm = &mgr->mm;
+ struct drm_buddy_block *block;
+
+ mutex_lock(&mgr->lock);
+ drm_printf(printer, "default_page_size: %lluKiB\n",
+ mgr->default_page_size >> 10);
- spin_lock(&mgr->lock);
- drm_mm_print(&mgr->mm, printer);
- spin_unlock(&mgr->lock);
+ drm_buddy_print(mm, printer);
+
+ drm_printf(printer, "reserved:\n");
+ list_for_each_entry(block, &mgr->reserved_pages, link)
+ drm_buddy_block_print(mm, block, printer);
+ mutex_unlock(&mgr->lock);
drm_printf(printer, "man size:%llu pages, ram usage:%lluMB, vis usage:%lluMB\n",
man->size, amdgpu_vram_mgr_usage(man) >> 20,
@@ -696,15 +730,20 @@ int amdgpu_vram_mgr_init(struct amdgpu_device *adev)
{
struct amdgpu_vram_mgr *mgr = &adev->mman.vram_mgr;
struct ttm_resource_manager *man = &mgr->manager;
+ int err;
ttm_resource_manager_init(man, adev->gmc.real_vram_size >> PAGE_SHIFT);
man->func = &amdgpu_vram_mgr_func;
- drm_mm_init(&mgr->mm, 0, man->size);
- spin_lock_init(&mgr->lock);
+ err = drm_buddy_init(&mgr->mm, man->size << PAGE_SHIFT, PAGE_SIZE);
+ if (err)
+ return err;
+
+ mutex_init(&mgr->lock);
INIT_LIST_HEAD(&mgr->reservations_pending);
INIT_LIST_HEAD(&mgr->reserved_pages);
+ mgr->default_page_size = PAGE_SIZE;
ttm_set_driver_manager(&adev->mman.bdev, TTM_PL_VRAM, &mgr->manager);
ttm_resource_manager_set_used(man, true);
@@ -732,16 +771,16 @@ void amdgpu_vram_mgr_fini(struct amdgpu_device *adev)
if (ret)
return;
- spin_lock(&mgr->lock);
+ mutex_lock(&mgr->lock);
list_for_each_entry_safe(rsv, temp, &mgr->reservations_pending, node)
kfree(rsv);
list_for_each_entry_safe(rsv, temp, &mgr->reserved_pages, node) {
- drm_mm_remove_node(&rsv->mm_node);
+ drm_buddy_free_list(&mgr->mm, &rsv->block);
kfree(rsv);
}
- drm_mm_takedown(&mgr->mm);
- spin_unlock(&mgr->lock);
+ drm_buddy_fini(&mgr->mm);
+ mutex_unlock(&mgr->lock);
ttm_resource_manager_cleanup(man);
ttm_set_driver_manager(&adev->mman.bdev, TTM_PL_VRAM, NULL);
--
2.25.1
^ permalink raw reply related [flat|nested] 46+ messages in thread
* [PATCH v3 6/6] drm/amdgpu: add drm buddy support to amdgpu
@ 2021-11-16 20:18 ` Arunpravin
0 siblings, 0 replies; 46+ messages in thread
From: Arunpravin @ 2021-11-16 20:18 UTC (permalink / raw)
To: dri-devel, intel-gfx, amd-gfx
Cc: daniel, Arunpravin, jani.nikula, matthew.auld, tzimmermann,
alexander.deucher, christian.koenig
- Remove drm_mm references and replace with drm buddy functionalities
- Add res cursor support for drm buddy
v2(Matthew Auld):
- replace spinlock with mutex as we call kmem_cache_zalloc(..., GFP_KERNEL)
in drm_buddy_alloc() function
- lock drm_buddy_block_trim() function as it calls mark_free/mark_split
are all globally visible
Signed-off-by: Arunpravin <Arunpravin.PaneerSelvam@amd.com>
---
.../gpu/drm/amd/amdgpu/amdgpu_res_cursor.h | 97 +++++--
drivers/gpu/drm/amd/amdgpu/amdgpu_ttm.h | 6 +-
drivers/gpu/drm/amd/amdgpu/amdgpu_vram_mgr.c | 263 ++++++++++--------
3 files changed, 233 insertions(+), 133 deletions(-)
diff --git a/drivers/gpu/drm/amd/amdgpu/amdgpu_res_cursor.h b/drivers/gpu/drm/amd/amdgpu/amdgpu_res_cursor.h
index acfa207cf970..da12b4ff2e45 100644
--- a/drivers/gpu/drm/amd/amdgpu/amdgpu_res_cursor.h
+++ b/drivers/gpu/drm/amd/amdgpu/amdgpu_res_cursor.h
@@ -30,12 +30,15 @@
#include <drm/ttm/ttm_resource.h>
#include <drm/ttm/ttm_range_manager.h>
+#include "amdgpu_vram_mgr.h"
+
/* state back for walking over vram_mgr and gtt_mgr allocations */
struct amdgpu_res_cursor {
uint64_t start;
uint64_t size;
uint64_t remaining;
- struct drm_mm_node *node;
+ void *node;
+ uint32_t mem_type;
};
/**
@@ -52,27 +55,63 @@ static inline void amdgpu_res_first(struct ttm_resource *res,
uint64_t start, uint64_t size,
struct amdgpu_res_cursor *cur)
{
+ struct drm_buddy_block *block;
+ struct list_head *head, *next;
struct drm_mm_node *node;
- if (!res || res->mem_type == TTM_PL_SYSTEM) {
- cur->start = start;
- cur->size = size;
- cur->remaining = size;
- cur->node = NULL;
- WARN_ON(res && start + size > res->num_pages << PAGE_SHIFT);
- return;
- }
+ if (!res)
+ goto err_out;
BUG_ON(start + size > res->num_pages << PAGE_SHIFT);
- node = to_ttm_range_mgr_node(res)->mm_nodes;
- while (start >= node->size << PAGE_SHIFT)
- start -= node++->size << PAGE_SHIFT;
+ cur->mem_type = res->mem_type;
+
+ switch (cur->mem_type) {
+ case TTM_PL_VRAM:
+ head = &to_amdgpu_vram_mgr_node(res)->blocks;
+
+ block = list_first_entry_or_null(head,
+ struct drm_buddy_block,
+ link);
+ if (!block)
+ goto err_out;
+
+ while (start >= amdgpu_node_size(block)) {
+ start -= amdgpu_node_size(block);
+
+ next = block->link.next;
+ if (next != head)
+ block = list_entry(next, struct drm_buddy_block, link);
+ }
+
+ cur->start = amdgpu_node_start(block) + start;
+ cur->size = min(amdgpu_node_size(block) - start, size);
+ cur->remaining = size;
+ cur->node = block;
+ break;
+ case TTM_PL_TT:
+ node = to_ttm_range_mgr_node(res)->mm_nodes;
+ while (start >= node->size << PAGE_SHIFT)
+ start -= node++->size << PAGE_SHIFT;
+
+ cur->start = (node->start << PAGE_SHIFT) + start;
+ cur->size = min((node->size << PAGE_SHIFT) - start, size);
+ cur->remaining = size;
+ cur->node = node;
+ break;
+ default:
+ goto err_out;
+ }
- cur->start = (node->start << PAGE_SHIFT) + start;
- cur->size = min((node->size << PAGE_SHIFT) - start, size);
+ return;
+
+err_out:
+ cur->start = start;
+ cur->size = size;
cur->remaining = size;
- cur->node = node;
+ cur->node = NULL;
+ WARN_ON(res && start + size > res->num_pages << PAGE_SHIFT);
+ return;
}
/**
@@ -85,7 +124,9 @@ static inline void amdgpu_res_first(struct ttm_resource *res,
*/
static inline void amdgpu_res_next(struct amdgpu_res_cursor *cur, uint64_t size)
{
- struct drm_mm_node *node = cur->node;
+ struct drm_buddy_block *block;
+ struct drm_mm_node *node;
+ struct list_head *next;
BUG_ON(size > cur->remaining);
@@ -99,9 +140,27 @@ static inline void amdgpu_res_next(struct amdgpu_res_cursor *cur, uint64_t size)
return;
}
- cur->node = ++node;
- cur->start = node->start << PAGE_SHIFT;
- cur->size = min(node->size << PAGE_SHIFT, cur->remaining);
+ switch (cur->mem_type) {
+ case TTM_PL_VRAM:
+ block = cur->node;
+
+ next = block->link.next;
+ block = list_entry(next, struct drm_buddy_block, link);
+
+ cur->node = block;
+ cur->start = amdgpu_node_start(block);
+ cur->size = min(amdgpu_node_size(block), cur->remaining);
+ break;
+ case TTM_PL_TT:
+ node = cur->node;
+
+ cur->node = ++node;
+ cur->start = node->start << PAGE_SHIFT;
+ cur->size = min(node->size << PAGE_SHIFT, cur->remaining);
+ break;
+ default:
+ return;
+ }
}
#endif
diff --git a/drivers/gpu/drm/amd/amdgpu/amdgpu_ttm.h b/drivers/gpu/drm/amd/amdgpu/amdgpu_ttm.h
index 7346ecff4438..946dfac486a7 100644
--- a/drivers/gpu/drm/amd/amdgpu/amdgpu_ttm.h
+++ b/drivers/gpu/drm/amd/amdgpu/amdgpu_ttm.h
@@ -26,6 +26,7 @@
#include <linux/dma-direction.h>
#include <drm/gpu_scheduler.h>
+#include <drm/drm_buddy.h>
#include "amdgpu.h"
#define AMDGPU_PL_GDS (TTM_PL_PRIV + 0)
@@ -40,12 +41,13 @@
struct amdgpu_vram_mgr {
struct ttm_resource_manager manager;
- struct drm_mm mm;
- spinlock_t lock;
+ struct drm_buddy_mm mm;
+ struct mutex lock;
struct list_head reservations_pending;
struct list_head reserved_pages;
atomic64_t usage;
atomic64_t vis_usage;
+ u64 default_page_size;
};
struct amdgpu_gtt_mgr {
diff --git a/drivers/gpu/drm/amd/amdgpu/amdgpu_vram_mgr.c b/drivers/gpu/drm/amd/amdgpu/amdgpu_vram_mgr.c
index 7b2b0980ec41..e6074733f00e 100644
--- a/drivers/gpu/drm/amd/amdgpu/amdgpu_vram_mgr.c
+++ b/drivers/gpu/drm/amd/amdgpu/amdgpu_vram_mgr.c
@@ -32,8 +32,12 @@
#include "atom.h"
struct amdgpu_vram_reservation {
+ u64 start;
+ u64 size;
+ u64 min_size;
+ unsigned long flags;
+ struct list_head block;
struct list_head node;
- struct drm_mm_node mm_node;
};
static inline struct amdgpu_vram_mgr *
@@ -196,10 +200,10 @@ const struct attribute_group amdgpu_vram_mgr_attr_group = {
* Calculate how many bytes of the MM node are inside visible VRAM
*/
static u64 amdgpu_vram_mgr_vis_size(struct amdgpu_device *adev,
- struct drm_mm_node *node)
+ struct drm_buddy_block *block)
{
- uint64_t start = node->start << PAGE_SHIFT;
- uint64_t end = (node->size + node->start) << PAGE_SHIFT;
+ u64 start = amdgpu_node_start(block);
+ u64 end = start + amdgpu_node_size(block);
if (start >= adev->gmc.visible_vram_size)
return 0;
@@ -220,9 +224,9 @@ u64 amdgpu_vram_mgr_bo_visible_size(struct amdgpu_bo *bo)
{
struct amdgpu_device *adev = amdgpu_ttm_adev(bo->tbo.bdev);
struct ttm_resource *res = bo->tbo.resource;
- unsigned pages = res->num_pages;
- struct drm_mm_node *mm;
- u64 usage;
+ struct amdgpu_vram_mgr_node *node = to_amdgpu_vram_mgr_node(res);
+ struct drm_buddy_block *block;
+ u64 usage = 0;
if (amdgpu_gmc_vram_full_visible(&adev->gmc))
return amdgpu_bo_size(bo);
@@ -230,9 +234,8 @@ u64 amdgpu_vram_mgr_bo_visible_size(struct amdgpu_bo *bo)
if (res->start >= adev->gmc.visible_vram_size >> PAGE_SHIFT)
return 0;
- mm = &container_of(res, struct ttm_range_mgr_node, base)->mm_nodes[0];
- for (usage = 0; pages; pages -= mm->size, mm++)
- usage += amdgpu_vram_mgr_vis_size(adev, mm);
+ list_for_each_entry(block, &node->blocks, link)
+ usage += amdgpu_vram_mgr_vis_size(adev, block);
return usage;
}
@@ -242,21 +245,29 @@ static void amdgpu_vram_mgr_do_reserve(struct ttm_resource_manager *man)
{
struct amdgpu_vram_mgr *mgr = to_vram_mgr(man);
struct amdgpu_device *adev = to_amdgpu_device(mgr);
- struct drm_mm *mm = &mgr->mm;
+ struct drm_buddy_mm *mm = &mgr->mm;
struct amdgpu_vram_reservation *rsv, *temp;
+ struct drm_buddy_block *block;
uint64_t vis_usage;
list_for_each_entry_safe(rsv, temp, &mgr->reservations_pending, node) {
- if (drm_mm_reserve_node(mm, &rsv->mm_node))
+ if (drm_buddy_alloc(mm, rsv->start, rsv->start + rsv->size,
+ rsv->size, rsv->min_size, &rsv->block,
+ rsv->flags))
continue;
- dev_dbg(adev->dev, "Reservation 0x%llx - %lld, Succeeded\n",
- rsv->mm_node.start, rsv->mm_node.size);
-
- vis_usage = amdgpu_vram_mgr_vis_size(adev, &rsv->mm_node);
- atomic64_add(vis_usage, &mgr->vis_usage);
- atomic64_add(rsv->mm_node.size << PAGE_SHIFT, &mgr->usage);
- list_move(&rsv->node, &mgr->reserved_pages);
+ block = list_first_entry_or_null(&rsv->block,
+ struct drm_buddy_block,
+ link);
+ if (block) {
+ dev_dbg(adev->dev, "Reservation 0x%llx - %lld, Succeeded\n",
+ rsv->start, rsv->size);
+
+ vis_usage = amdgpu_vram_mgr_vis_size(adev, block);
+ atomic64_add(vis_usage, &mgr->vis_usage);
+ atomic64_add(rsv->size, &mgr->usage);
+ list_move(&rsv->node, &mgr->reserved_pages);
+ }
}
}
@@ -280,13 +291,17 @@ int amdgpu_vram_mgr_reserve_range(struct ttm_resource_manager *man,
return -ENOMEM;
INIT_LIST_HEAD(&rsv->node);
- rsv->mm_node.start = start >> PAGE_SHIFT;
- rsv->mm_node.size = size >> PAGE_SHIFT;
+ INIT_LIST_HEAD(&rsv->block);
+
+ rsv->start = start;
+ rsv->size = size;
+ rsv->min_size = size;
+ rsv->flags |= DRM_BUDDY_RANGE_ALLOCATION;
- spin_lock(&mgr->lock);
- list_add_tail(&mgr->reservations_pending, &rsv->node);
+ mutex_lock(&mgr->lock);
+ list_add_tail(&rsv->node, &mgr->reservations_pending);
amdgpu_vram_mgr_do_reserve(man);
- spin_unlock(&mgr->lock);
+ mutex_unlock(&mgr->lock);
return 0;
}
@@ -309,19 +324,19 @@ int amdgpu_vram_mgr_query_page_status(struct ttm_resource_manager *man,
struct amdgpu_vram_reservation *rsv;
int ret;
- spin_lock(&mgr->lock);
+ mutex_lock(&mgr->lock);
list_for_each_entry(rsv, &mgr->reservations_pending, node) {
- if ((rsv->mm_node.start <= start) &&
- (start < (rsv->mm_node.start + rsv->mm_node.size))) {
+ if ((rsv->start <= start) &&
+ (start < (rsv->start + rsv->size))) {
ret = -EBUSY;
goto out;
}
}
list_for_each_entry(rsv, &mgr->reserved_pages, node) {
- if ((rsv->mm_node.start <= start) &&
- (start < (rsv->mm_node.start + rsv->mm_node.size))) {
+ if ((rsv->start <= start) &&
+ (start < (rsv->start + rsv->size))) {
ret = 0;
goto out;
}
@@ -329,32 +344,10 @@ int amdgpu_vram_mgr_query_page_status(struct ttm_resource_manager *man,
ret = -ENOENT;
out:
- spin_unlock(&mgr->lock);
+ mutex_unlock(&mgr->lock);
return ret;
}
-/**
- * amdgpu_vram_mgr_virt_start - update virtual start address
- *
- * @mem: ttm_resource to update
- * @node: just allocated node
- *
- * Calculate a virtual BO start address to easily check if everything is CPU
- * accessible.
- */
-static void amdgpu_vram_mgr_virt_start(struct ttm_resource *mem,
- struct drm_mm_node *node)
-{
- unsigned long start;
-
- start = node->start + node->size;
- if (start > mem->num_pages)
- start -= mem->num_pages;
- else
- start = 0;
- mem->start = max(mem->start, start);
-}
-
/**
* amdgpu_vram_mgr_new - allocate new ranges
*
@@ -370,13 +363,13 @@ static int amdgpu_vram_mgr_new(struct ttm_resource_manager *man,
const struct ttm_place *place,
struct ttm_resource **res)
{
- unsigned long lpfn, num_nodes, pages_per_node, pages_left, pages;
+ unsigned long lpfn, pages_per_node, pages_left, pages, n_pages;
+ u64 vis_usage = 0, mem_bytes, max_bytes, min_page_size;
struct amdgpu_vram_mgr *mgr = to_vram_mgr(man);
struct amdgpu_device *adev = to_amdgpu_device(mgr);
- uint64_t vis_usage = 0, mem_bytes, max_bytes;
- struct ttm_range_mgr_node *node;
- struct drm_mm *mm = &mgr->mm;
- enum drm_mm_insert_mode mode;
+ struct amdgpu_vram_mgr_node *node;
+ struct drm_buddy_mm *mm = &mgr->mm;
+ struct drm_buddy_block *block;
unsigned i;
int r;
@@ -395,10 +388,9 @@ static int amdgpu_vram_mgr_new(struct ttm_resource_manager *man,
goto error_sub;
}
- if (place->flags & TTM_PL_FLAG_CONTIGUOUS) {
+ if (place->flags & TTM_PL_FLAG_CONTIGUOUS)
pages_per_node = ~0ul;
- num_nodes = 1;
- } else {
+ else {
#ifdef CONFIG_TRANSPARENT_HUGEPAGE
pages_per_node = HPAGE_PMD_NR;
#else
@@ -407,11 +399,9 @@ static int amdgpu_vram_mgr_new(struct ttm_resource_manager *man,
#endif
pages_per_node = max_t(uint32_t, pages_per_node,
tbo->page_alignment);
- num_nodes = DIV_ROUND_UP_ULL(PFN_UP(mem_bytes), pages_per_node);
}
- node = kvmalloc(struct_size(node, mm_nodes, num_nodes),
- GFP_KERNEL | __GFP_ZERO);
+ node = kzalloc(sizeof(*node), GFP_KERNEL);
if (!node) {
r = -ENOMEM;
goto error_sub;
@@ -419,9 +409,17 @@ static int amdgpu_vram_mgr_new(struct ttm_resource_manager *man,
ttm_resource_init(tbo, place, &node->base);
- mode = DRM_MM_INSERT_BEST;
+ INIT_LIST_HEAD(&node->blocks);
+
if (place->flags & TTM_PL_FLAG_TOPDOWN)
- mode = DRM_MM_INSERT_HIGH;
+ node->flags |= DRM_BUDDY_TOPDOWN_ALLOCATION;
+
+ if (place->fpfn || lpfn != man->size)
+ /* Allocate blocks in desired range */
+ node->flags |= DRM_BUDDY_RANGE_ALLOCATION;
+
+ min_page_size = mgr->default_page_size;
+ BUG_ON(min_page_size < mm->chunk_size);
pages_left = node->base.num_pages;
@@ -429,36 +427,63 @@ static int amdgpu_vram_mgr_new(struct ttm_resource_manager *man,
pages = min(pages_left, 2UL << (30 - PAGE_SHIFT));
i = 0;
- spin_lock(&mgr->lock);
while (pages_left) {
- uint32_t alignment = tbo->page_alignment;
-
if (pages >= pages_per_node)
- alignment = pages_per_node;
-
- r = drm_mm_insert_node_in_range(mm, &node->mm_nodes[i], pages,
- alignment, 0, place->fpfn,
- lpfn, mode);
- if (unlikely(r)) {
- if (pages > pages_per_node) {
- if (is_power_of_2(pages))
- pages = pages / 2;
- else
- pages = rounddown_pow_of_two(pages);
- continue;
- }
- goto error_free;
+ pages = pages_per_node;
+
+ n_pages = pages;
+
+ if (place->flags & TTM_PL_FLAG_CONTIGUOUS) {
+ n_pages = roundup_pow_of_two(n_pages);
+ min_page_size = (u64)n_pages << PAGE_SHIFT;
+
+ if (n_pages > lpfn)
+ lpfn = n_pages;
}
- vis_usage += amdgpu_vram_mgr_vis_size(adev, &node->mm_nodes[i]);
- amdgpu_vram_mgr_virt_start(&node->base, &node->mm_nodes[i]);
+ mutex_lock(&mgr->lock);
+ r = drm_buddy_alloc(mm, (u64)place->fpfn << PAGE_SHIFT,
+ (u64)lpfn << PAGE_SHIFT,
+ (u64)n_pages << PAGE_SHIFT,
+ min_page_size,
+ &node->blocks,
+ node->flags);
+ mutex_unlock(&mgr->lock);
+ if (unlikely(r))
+ goto error_free_blocks;
+
pages_left -= pages;
++i;
if (pages > pages_left)
pages = pages_left;
}
- spin_unlock(&mgr->lock);
+
+ /* Free unused pages for contiguous allocation */
+ if (place->flags & TTM_PL_FLAG_CONTIGUOUS) {
+ u64 actual_size = (u64)node->base.num_pages << PAGE_SHIFT;
+
+ mutex_lock(&mgr->lock);
+ r = drm_buddy_block_trim(mm,
+ actual_size,
+ &node->blocks);
+ mutex_unlock(&mgr->lock);
+ if (unlikely(r))
+ goto error_free_blocks;
+ }
+
+ list_for_each_entry(block, &node->blocks, link)
+ vis_usage += amdgpu_vram_mgr_vis_size(adev, block);
+
+ block = list_first_entry_or_null(&node->blocks,
+ struct drm_buddy_block,
+ link);
+ if (!block) {
+ r = -ENOENT;
+ goto error_free_res;
+ }
+
+ node->base.start = amdgpu_node_start(block) >> PAGE_SHIFT;
if (i == 1)
node->base.placement |= TTM_PL_FLAG_CONTIGUOUS;
@@ -472,12 +497,12 @@ static int amdgpu_vram_mgr_new(struct ttm_resource_manager *man,
*res = &node->base;
return 0;
-error_free:
- while (i--)
- drm_mm_remove_node(&node->mm_nodes[i]);
- spin_unlock(&mgr->lock);
- kvfree(node);
-
+error_free_blocks:
+ mutex_lock(&mgr->lock);
+ drm_buddy_free_list(mm, &node->blocks);
+ mutex_unlock(&mgr->lock);
+error_free_res:
+ kfree(node);
error_sub:
atomic64_sub(mem_bytes, &mgr->usage);
return r;
@@ -494,28 +519,28 @@ static int amdgpu_vram_mgr_new(struct ttm_resource_manager *man,
static void amdgpu_vram_mgr_del(struct ttm_resource_manager *man,
struct ttm_resource *res)
{
- struct ttm_range_mgr_node *node = to_ttm_range_mgr_node(res);
+ struct amdgpu_vram_mgr_node *node = to_amdgpu_vram_mgr_node(res);
struct amdgpu_vram_mgr *mgr = to_vram_mgr(man);
struct amdgpu_device *adev = to_amdgpu_device(mgr);
+ struct drm_buddy_mm *mm = &mgr->mm;
+ struct drm_buddy_block *block;
uint64_t usage = 0, vis_usage = 0;
- unsigned i, pages;
- spin_lock(&mgr->lock);
- for (i = 0, pages = res->num_pages; pages;
- pages -= node->mm_nodes[i].size, ++i) {
- struct drm_mm_node *mm = &node->mm_nodes[i];
-
- drm_mm_remove_node(mm);
- usage += mm->size << PAGE_SHIFT;
- vis_usage += amdgpu_vram_mgr_vis_size(adev, mm);
+ mutex_lock(&mgr->lock);
+ list_for_each_entry(block, &node->blocks, link) {
+ usage += amdgpu_node_size(block);
+ vis_usage += amdgpu_vram_mgr_vis_size(adev, block);
}
+
amdgpu_vram_mgr_do_reserve(man);
- spin_unlock(&mgr->lock);
+
+ drm_buddy_free_list(mm, &node->blocks);
+ mutex_unlock(&mgr->lock);
atomic64_sub(usage, &mgr->usage);
atomic64_sub(vis_usage, &mgr->vis_usage);
- kvfree(node);
+ kfree(node);
}
/**
@@ -669,10 +694,19 @@ static void amdgpu_vram_mgr_debug(struct ttm_resource_manager *man,
struct drm_printer *printer)
{
struct amdgpu_vram_mgr *mgr = to_vram_mgr(man);
+ struct drm_buddy_mm *mm = &mgr->mm;
+ struct drm_buddy_block *block;
+
+ mutex_lock(&mgr->lock);
+ drm_printf(printer, "default_page_size: %lluKiB\n",
+ mgr->default_page_size >> 10);
- spin_lock(&mgr->lock);
- drm_mm_print(&mgr->mm, printer);
- spin_unlock(&mgr->lock);
+ drm_buddy_print(mm, printer);
+
+ drm_printf(printer, "reserved:\n");
+ list_for_each_entry(block, &mgr->reserved_pages, link)
+ drm_buddy_block_print(mm, block, printer);
+ mutex_unlock(&mgr->lock);
drm_printf(printer, "man size:%llu pages, ram usage:%lluMB, vis usage:%lluMB\n",
man->size, amdgpu_vram_mgr_usage(man) >> 20,
@@ -696,15 +730,20 @@ int amdgpu_vram_mgr_init(struct amdgpu_device *adev)
{
struct amdgpu_vram_mgr *mgr = &adev->mman.vram_mgr;
struct ttm_resource_manager *man = &mgr->manager;
+ int err;
ttm_resource_manager_init(man, adev->gmc.real_vram_size >> PAGE_SHIFT);
man->func = &amdgpu_vram_mgr_func;
- drm_mm_init(&mgr->mm, 0, man->size);
- spin_lock_init(&mgr->lock);
+ err = drm_buddy_init(&mgr->mm, man->size << PAGE_SHIFT, PAGE_SIZE);
+ if (err)
+ return err;
+
+ mutex_init(&mgr->lock);
INIT_LIST_HEAD(&mgr->reservations_pending);
INIT_LIST_HEAD(&mgr->reserved_pages);
+ mgr->default_page_size = PAGE_SIZE;
ttm_set_driver_manager(&adev->mman.bdev, TTM_PL_VRAM, &mgr->manager);
ttm_resource_manager_set_used(man, true);
@@ -732,16 +771,16 @@ void amdgpu_vram_mgr_fini(struct amdgpu_device *adev)
if (ret)
return;
- spin_lock(&mgr->lock);
+ mutex_lock(&mgr->lock);
list_for_each_entry_safe(rsv, temp, &mgr->reservations_pending, node)
kfree(rsv);
list_for_each_entry_safe(rsv, temp, &mgr->reserved_pages, node) {
- drm_mm_remove_node(&rsv->mm_node);
+ drm_buddy_free_list(&mgr->mm, &rsv->block);
kfree(rsv);
}
- drm_mm_takedown(&mgr->mm);
- spin_unlock(&mgr->lock);
+ drm_buddy_fini(&mgr->mm);
+ mutex_unlock(&mgr->lock);
ttm_resource_manager_cleanup(man);
ttm_set_driver_manager(&adev->mman.bdev, TTM_PL_VRAM, NULL);
--
2.25.1
^ permalink raw reply related [flat|nested] 46+ messages in thread
* [Intel-gfx] [PATCH v3 6/6] drm/amdgpu: add drm buddy support to amdgpu
@ 2021-11-16 20:18 ` Arunpravin
0 siblings, 0 replies; 46+ messages in thread
From: Arunpravin @ 2021-11-16 20:18 UTC (permalink / raw)
To: dri-devel, intel-gfx, amd-gfx
Cc: Arunpravin, matthew.auld, tzimmermann, alexander.deucher,
christian.koenig
- Remove drm_mm references and replace with drm buddy functionalities
- Add res cursor support for drm buddy
v2(Matthew Auld):
- replace spinlock with mutex as we call kmem_cache_zalloc(..., GFP_KERNEL)
in drm_buddy_alloc() function
- lock drm_buddy_block_trim() function as it calls mark_free/mark_split
are all globally visible
Signed-off-by: Arunpravin <Arunpravin.PaneerSelvam@amd.com>
---
.../gpu/drm/amd/amdgpu/amdgpu_res_cursor.h | 97 +++++--
drivers/gpu/drm/amd/amdgpu/amdgpu_ttm.h | 6 +-
drivers/gpu/drm/amd/amdgpu/amdgpu_vram_mgr.c | 263 ++++++++++--------
3 files changed, 233 insertions(+), 133 deletions(-)
diff --git a/drivers/gpu/drm/amd/amdgpu/amdgpu_res_cursor.h b/drivers/gpu/drm/amd/amdgpu/amdgpu_res_cursor.h
index acfa207cf970..da12b4ff2e45 100644
--- a/drivers/gpu/drm/amd/amdgpu/amdgpu_res_cursor.h
+++ b/drivers/gpu/drm/amd/amdgpu/amdgpu_res_cursor.h
@@ -30,12 +30,15 @@
#include <drm/ttm/ttm_resource.h>
#include <drm/ttm/ttm_range_manager.h>
+#include "amdgpu_vram_mgr.h"
+
/* state back for walking over vram_mgr and gtt_mgr allocations */
struct amdgpu_res_cursor {
uint64_t start;
uint64_t size;
uint64_t remaining;
- struct drm_mm_node *node;
+ void *node;
+ uint32_t mem_type;
};
/**
@@ -52,27 +55,63 @@ static inline void amdgpu_res_first(struct ttm_resource *res,
uint64_t start, uint64_t size,
struct amdgpu_res_cursor *cur)
{
+ struct drm_buddy_block *block;
+ struct list_head *head, *next;
struct drm_mm_node *node;
- if (!res || res->mem_type == TTM_PL_SYSTEM) {
- cur->start = start;
- cur->size = size;
- cur->remaining = size;
- cur->node = NULL;
- WARN_ON(res && start + size > res->num_pages << PAGE_SHIFT);
- return;
- }
+ if (!res)
+ goto err_out;
BUG_ON(start + size > res->num_pages << PAGE_SHIFT);
- node = to_ttm_range_mgr_node(res)->mm_nodes;
- while (start >= node->size << PAGE_SHIFT)
- start -= node++->size << PAGE_SHIFT;
+ cur->mem_type = res->mem_type;
+
+ switch (cur->mem_type) {
+ case TTM_PL_VRAM:
+ head = &to_amdgpu_vram_mgr_node(res)->blocks;
+
+ block = list_first_entry_or_null(head,
+ struct drm_buddy_block,
+ link);
+ if (!block)
+ goto err_out;
+
+ while (start >= amdgpu_node_size(block)) {
+ start -= amdgpu_node_size(block);
+
+ next = block->link.next;
+ if (next != head)
+ block = list_entry(next, struct drm_buddy_block, link);
+ }
+
+ cur->start = amdgpu_node_start(block) + start;
+ cur->size = min(amdgpu_node_size(block) - start, size);
+ cur->remaining = size;
+ cur->node = block;
+ break;
+ case TTM_PL_TT:
+ node = to_ttm_range_mgr_node(res)->mm_nodes;
+ while (start >= node->size << PAGE_SHIFT)
+ start -= node++->size << PAGE_SHIFT;
+
+ cur->start = (node->start << PAGE_SHIFT) + start;
+ cur->size = min((node->size << PAGE_SHIFT) - start, size);
+ cur->remaining = size;
+ cur->node = node;
+ break;
+ default:
+ goto err_out;
+ }
- cur->start = (node->start << PAGE_SHIFT) + start;
- cur->size = min((node->size << PAGE_SHIFT) - start, size);
+ return;
+
+err_out:
+ cur->start = start;
+ cur->size = size;
cur->remaining = size;
- cur->node = node;
+ cur->node = NULL;
+ WARN_ON(res && start + size > res->num_pages << PAGE_SHIFT);
+ return;
}
/**
@@ -85,7 +124,9 @@ static inline void amdgpu_res_first(struct ttm_resource *res,
*/
static inline void amdgpu_res_next(struct amdgpu_res_cursor *cur, uint64_t size)
{
- struct drm_mm_node *node = cur->node;
+ struct drm_buddy_block *block;
+ struct drm_mm_node *node;
+ struct list_head *next;
BUG_ON(size > cur->remaining);
@@ -99,9 +140,27 @@ static inline void amdgpu_res_next(struct amdgpu_res_cursor *cur, uint64_t size)
return;
}
- cur->node = ++node;
- cur->start = node->start << PAGE_SHIFT;
- cur->size = min(node->size << PAGE_SHIFT, cur->remaining);
+ switch (cur->mem_type) {
+ case TTM_PL_VRAM:
+ block = cur->node;
+
+ next = block->link.next;
+ block = list_entry(next, struct drm_buddy_block, link);
+
+ cur->node = block;
+ cur->start = amdgpu_node_start(block);
+ cur->size = min(amdgpu_node_size(block), cur->remaining);
+ break;
+ case TTM_PL_TT:
+ node = cur->node;
+
+ cur->node = ++node;
+ cur->start = node->start << PAGE_SHIFT;
+ cur->size = min(node->size << PAGE_SHIFT, cur->remaining);
+ break;
+ default:
+ return;
+ }
}
#endif
diff --git a/drivers/gpu/drm/amd/amdgpu/amdgpu_ttm.h b/drivers/gpu/drm/amd/amdgpu/amdgpu_ttm.h
index 7346ecff4438..946dfac486a7 100644
--- a/drivers/gpu/drm/amd/amdgpu/amdgpu_ttm.h
+++ b/drivers/gpu/drm/amd/amdgpu/amdgpu_ttm.h
@@ -26,6 +26,7 @@
#include <linux/dma-direction.h>
#include <drm/gpu_scheduler.h>
+#include <drm/drm_buddy.h>
#include "amdgpu.h"
#define AMDGPU_PL_GDS (TTM_PL_PRIV + 0)
@@ -40,12 +41,13 @@
struct amdgpu_vram_mgr {
struct ttm_resource_manager manager;
- struct drm_mm mm;
- spinlock_t lock;
+ struct drm_buddy_mm mm;
+ struct mutex lock;
struct list_head reservations_pending;
struct list_head reserved_pages;
atomic64_t usage;
atomic64_t vis_usage;
+ u64 default_page_size;
};
struct amdgpu_gtt_mgr {
diff --git a/drivers/gpu/drm/amd/amdgpu/amdgpu_vram_mgr.c b/drivers/gpu/drm/amd/amdgpu/amdgpu_vram_mgr.c
index 7b2b0980ec41..e6074733f00e 100644
--- a/drivers/gpu/drm/amd/amdgpu/amdgpu_vram_mgr.c
+++ b/drivers/gpu/drm/amd/amdgpu/amdgpu_vram_mgr.c
@@ -32,8 +32,12 @@
#include "atom.h"
struct amdgpu_vram_reservation {
+ u64 start;
+ u64 size;
+ u64 min_size;
+ unsigned long flags;
+ struct list_head block;
struct list_head node;
- struct drm_mm_node mm_node;
};
static inline struct amdgpu_vram_mgr *
@@ -196,10 +200,10 @@ const struct attribute_group amdgpu_vram_mgr_attr_group = {
* Calculate how many bytes of the MM node are inside visible VRAM
*/
static u64 amdgpu_vram_mgr_vis_size(struct amdgpu_device *adev,
- struct drm_mm_node *node)
+ struct drm_buddy_block *block)
{
- uint64_t start = node->start << PAGE_SHIFT;
- uint64_t end = (node->size + node->start) << PAGE_SHIFT;
+ u64 start = amdgpu_node_start(block);
+ u64 end = start + amdgpu_node_size(block);
if (start >= adev->gmc.visible_vram_size)
return 0;
@@ -220,9 +224,9 @@ u64 amdgpu_vram_mgr_bo_visible_size(struct amdgpu_bo *bo)
{
struct amdgpu_device *adev = amdgpu_ttm_adev(bo->tbo.bdev);
struct ttm_resource *res = bo->tbo.resource;
- unsigned pages = res->num_pages;
- struct drm_mm_node *mm;
- u64 usage;
+ struct amdgpu_vram_mgr_node *node = to_amdgpu_vram_mgr_node(res);
+ struct drm_buddy_block *block;
+ u64 usage = 0;
if (amdgpu_gmc_vram_full_visible(&adev->gmc))
return amdgpu_bo_size(bo);
@@ -230,9 +234,8 @@ u64 amdgpu_vram_mgr_bo_visible_size(struct amdgpu_bo *bo)
if (res->start >= adev->gmc.visible_vram_size >> PAGE_SHIFT)
return 0;
- mm = &container_of(res, struct ttm_range_mgr_node, base)->mm_nodes[0];
- for (usage = 0; pages; pages -= mm->size, mm++)
- usage += amdgpu_vram_mgr_vis_size(adev, mm);
+ list_for_each_entry(block, &node->blocks, link)
+ usage += amdgpu_vram_mgr_vis_size(adev, block);
return usage;
}
@@ -242,21 +245,29 @@ static void amdgpu_vram_mgr_do_reserve(struct ttm_resource_manager *man)
{
struct amdgpu_vram_mgr *mgr = to_vram_mgr(man);
struct amdgpu_device *adev = to_amdgpu_device(mgr);
- struct drm_mm *mm = &mgr->mm;
+ struct drm_buddy_mm *mm = &mgr->mm;
struct amdgpu_vram_reservation *rsv, *temp;
+ struct drm_buddy_block *block;
uint64_t vis_usage;
list_for_each_entry_safe(rsv, temp, &mgr->reservations_pending, node) {
- if (drm_mm_reserve_node(mm, &rsv->mm_node))
+ if (drm_buddy_alloc(mm, rsv->start, rsv->start + rsv->size,
+ rsv->size, rsv->min_size, &rsv->block,
+ rsv->flags))
continue;
- dev_dbg(adev->dev, "Reservation 0x%llx - %lld, Succeeded\n",
- rsv->mm_node.start, rsv->mm_node.size);
-
- vis_usage = amdgpu_vram_mgr_vis_size(adev, &rsv->mm_node);
- atomic64_add(vis_usage, &mgr->vis_usage);
- atomic64_add(rsv->mm_node.size << PAGE_SHIFT, &mgr->usage);
- list_move(&rsv->node, &mgr->reserved_pages);
+ block = list_first_entry_or_null(&rsv->block,
+ struct drm_buddy_block,
+ link);
+ if (block) {
+ dev_dbg(adev->dev, "Reservation 0x%llx - %lld, Succeeded\n",
+ rsv->start, rsv->size);
+
+ vis_usage = amdgpu_vram_mgr_vis_size(adev, block);
+ atomic64_add(vis_usage, &mgr->vis_usage);
+ atomic64_add(rsv->size, &mgr->usage);
+ list_move(&rsv->node, &mgr->reserved_pages);
+ }
}
}
@@ -280,13 +291,17 @@ int amdgpu_vram_mgr_reserve_range(struct ttm_resource_manager *man,
return -ENOMEM;
INIT_LIST_HEAD(&rsv->node);
- rsv->mm_node.start = start >> PAGE_SHIFT;
- rsv->mm_node.size = size >> PAGE_SHIFT;
+ INIT_LIST_HEAD(&rsv->block);
+
+ rsv->start = start;
+ rsv->size = size;
+ rsv->min_size = size;
+ rsv->flags |= DRM_BUDDY_RANGE_ALLOCATION;
- spin_lock(&mgr->lock);
- list_add_tail(&mgr->reservations_pending, &rsv->node);
+ mutex_lock(&mgr->lock);
+ list_add_tail(&rsv->node, &mgr->reservations_pending);
amdgpu_vram_mgr_do_reserve(man);
- spin_unlock(&mgr->lock);
+ mutex_unlock(&mgr->lock);
return 0;
}
@@ -309,19 +324,19 @@ int amdgpu_vram_mgr_query_page_status(struct ttm_resource_manager *man,
struct amdgpu_vram_reservation *rsv;
int ret;
- spin_lock(&mgr->lock);
+ mutex_lock(&mgr->lock);
list_for_each_entry(rsv, &mgr->reservations_pending, node) {
- if ((rsv->mm_node.start <= start) &&
- (start < (rsv->mm_node.start + rsv->mm_node.size))) {
+ if ((rsv->start <= start) &&
+ (start < (rsv->start + rsv->size))) {
ret = -EBUSY;
goto out;
}
}
list_for_each_entry(rsv, &mgr->reserved_pages, node) {
- if ((rsv->mm_node.start <= start) &&
- (start < (rsv->mm_node.start + rsv->mm_node.size))) {
+ if ((rsv->start <= start) &&
+ (start < (rsv->start + rsv->size))) {
ret = 0;
goto out;
}
@@ -329,32 +344,10 @@ int amdgpu_vram_mgr_query_page_status(struct ttm_resource_manager *man,
ret = -ENOENT;
out:
- spin_unlock(&mgr->lock);
+ mutex_unlock(&mgr->lock);
return ret;
}
-/**
- * amdgpu_vram_mgr_virt_start - update virtual start address
- *
- * @mem: ttm_resource to update
- * @node: just allocated node
- *
- * Calculate a virtual BO start address to easily check if everything is CPU
- * accessible.
- */
-static void amdgpu_vram_mgr_virt_start(struct ttm_resource *mem,
- struct drm_mm_node *node)
-{
- unsigned long start;
-
- start = node->start + node->size;
- if (start > mem->num_pages)
- start -= mem->num_pages;
- else
- start = 0;
- mem->start = max(mem->start, start);
-}
-
/**
* amdgpu_vram_mgr_new - allocate new ranges
*
@@ -370,13 +363,13 @@ static int amdgpu_vram_mgr_new(struct ttm_resource_manager *man,
const struct ttm_place *place,
struct ttm_resource **res)
{
- unsigned long lpfn, num_nodes, pages_per_node, pages_left, pages;
+ unsigned long lpfn, pages_per_node, pages_left, pages, n_pages;
+ u64 vis_usage = 0, mem_bytes, max_bytes, min_page_size;
struct amdgpu_vram_mgr *mgr = to_vram_mgr(man);
struct amdgpu_device *adev = to_amdgpu_device(mgr);
- uint64_t vis_usage = 0, mem_bytes, max_bytes;
- struct ttm_range_mgr_node *node;
- struct drm_mm *mm = &mgr->mm;
- enum drm_mm_insert_mode mode;
+ struct amdgpu_vram_mgr_node *node;
+ struct drm_buddy_mm *mm = &mgr->mm;
+ struct drm_buddy_block *block;
unsigned i;
int r;
@@ -395,10 +388,9 @@ static int amdgpu_vram_mgr_new(struct ttm_resource_manager *man,
goto error_sub;
}
- if (place->flags & TTM_PL_FLAG_CONTIGUOUS) {
+ if (place->flags & TTM_PL_FLAG_CONTIGUOUS)
pages_per_node = ~0ul;
- num_nodes = 1;
- } else {
+ else {
#ifdef CONFIG_TRANSPARENT_HUGEPAGE
pages_per_node = HPAGE_PMD_NR;
#else
@@ -407,11 +399,9 @@ static int amdgpu_vram_mgr_new(struct ttm_resource_manager *man,
#endif
pages_per_node = max_t(uint32_t, pages_per_node,
tbo->page_alignment);
- num_nodes = DIV_ROUND_UP_ULL(PFN_UP(mem_bytes), pages_per_node);
}
- node = kvmalloc(struct_size(node, mm_nodes, num_nodes),
- GFP_KERNEL | __GFP_ZERO);
+ node = kzalloc(sizeof(*node), GFP_KERNEL);
if (!node) {
r = -ENOMEM;
goto error_sub;
@@ -419,9 +409,17 @@ static int amdgpu_vram_mgr_new(struct ttm_resource_manager *man,
ttm_resource_init(tbo, place, &node->base);
- mode = DRM_MM_INSERT_BEST;
+ INIT_LIST_HEAD(&node->blocks);
+
if (place->flags & TTM_PL_FLAG_TOPDOWN)
- mode = DRM_MM_INSERT_HIGH;
+ node->flags |= DRM_BUDDY_TOPDOWN_ALLOCATION;
+
+ if (place->fpfn || lpfn != man->size)
+ /* Allocate blocks in desired range */
+ node->flags |= DRM_BUDDY_RANGE_ALLOCATION;
+
+ min_page_size = mgr->default_page_size;
+ BUG_ON(min_page_size < mm->chunk_size);
pages_left = node->base.num_pages;
@@ -429,36 +427,63 @@ static int amdgpu_vram_mgr_new(struct ttm_resource_manager *man,
pages = min(pages_left, 2UL << (30 - PAGE_SHIFT));
i = 0;
- spin_lock(&mgr->lock);
while (pages_left) {
- uint32_t alignment = tbo->page_alignment;
-
if (pages >= pages_per_node)
- alignment = pages_per_node;
-
- r = drm_mm_insert_node_in_range(mm, &node->mm_nodes[i], pages,
- alignment, 0, place->fpfn,
- lpfn, mode);
- if (unlikely(r)) {
- if (pages > pages_per_node) {
- if (is_power_of_2(pages))
- pages = pages / 2;
- else
- pages = rounddown_pow_of_two(pages);
- continue;
- }
- goto error_free;
+ pages = pages_per_node;
+
+ n_pages = pages;
+
+ if (place->flags & TTM_PL_FLAG_CONTIGUOUS) {
+ n_pages = roundup_pow_of_two(n_pages);
+ min_page_size = (u64)n_pages << PAGE_SHIFT;
+
+ if (n_pages > lpfn)
+ lpfn = n_pages;
}
- vis_usage += amdgpu_vram_mgr_vis_size(adev, &node->mm_nodes[i]);
- amdgpu_vram_mgr_virt_start(&node->base, &node->mm_nodes[i]);
+ mutex_lock(&mgr->lock);
+ r = drm_buddy_alloc(mm, (u64)place->fpfn << PAGE_SHIFT,
+ (u64)lpfn << PAGE_SHIFT,
+ (u64)n_pages << PAGE_SHIFT,
+ min_page_size,
+ &node->blocks,
+ node->flags);
+ mutex_unlock(&mgr->lock);
+ if (unlikely(r))
+ goto error_free_blocks;
+
pages_left -= pages;
++i;
if (pages > pages_left)
pages = pages_left;
}
- spin_unlock(&mgr->lock);
+
+ /* Free unused pages for contiguous allocation */
+ if (place->flags & TTM_PL_FLAG_CONTIGUOUS) {
+ u64 actual_size = (u64)node->base.num_pages << PAGE_SHIFT;
+
+ mutex_lock(&mgr->lock);
+ r = drm_buddy_block_trim(mm,
+ actual_size,
+ &node->blocks);
+ mutex_unlock(&mgr->lock);
+ if (unlikely(r))
+ goto error_free_blocks;
+ }
+
+ list_for_each_entry(block, &node->blocks, link)
+ vis_usage += amdgpu_vram_mgr_vis_size(adev, block);
+
+ block = list_first_entry_or_null(&node->blocks,
+ struct drm_buddy_block,
+ link);
+ if (!block) {
+ r = -ENOENT;
+ goto error_free_res;
+ }
+
+ node->base.start = amdgpu_node_start(block) >> PAGE_SHIFT;
if (i == 1)
node->base.placement |= TTM_PL_FLAG_CONTIGUOUS;
@@ -472,12 +497,12 @@ static int amdgpu_vram_mgr_new(struct ttm_resource_manager *man,
*res = &node->base;
return 0;
-error_free:
- while (i--)
- drm_mm_remove_node(&node->mm_nodes[i]);
- spin_unlock(&mgr->lock);
- kvfree(node);
-
+error_free_blocks:
+ mutex_lock(&mgr->lock);
+ drm_buddy_free_list(mm, &node->blocks);
+ mutex_unlock(&mgr->lock);
+error_free_res:
+ kfree(node);
error_sub:
atomic64_sub(mem_bytes, &mgr->usage);
return r;
@@ -494,28 +519,28 @@ static int amdgpu_vram_mgr_new(struct ttm_resource_manager *man,
static void amdgpu_vram_mgr_del(struct ttm_resource_manager *man,
struct ttm_resource *res)
{
- struct ttm_range_mgr_node *node = to_ttm_range_mgr_node(res);
+ struct amdgpu_vram_mgr_node *node = to_amdgpu_vram_mgr_node(res);
struct amdgpu_vram_mgr *mgr = to_vram_mgr(man);
struct amdgpu_device *adev = to_amdgpu_device(mgr);
+ struct drm_buddy_mm *mm = &mgr->mm;
+ struct drm_buddy_block *block;
uint64_t usage = 0, vis_usage = 0;
- unsigned i, pages;
- spin_lock(&mgr->lock);
- for (i = 0, pages = res->num_pages; pages;
- pages -= node->mm_nodes[i].size, ++i) {
- struct drm_mm_node *mm = &node->mm_nodes[i];
-
- drm_mm_remove_node(mm);
- usage += mm->size << PAGE_SHIFT;
- vis_usage += amdgpu_vram_mgr_vis_size(adev, mm);
+ mutex_lock(&mgr->lock);
+ list_for_each_entry(block, &node->blocks, link) {
+ usage += amdgpu_node_size(block);
+ vis_usage += amdgpu_vram_mgr_vis_size(adev, block);
}
+
amdgpu_vram_mgr_do_reserve(man);
- spin_unlock(&mgr->lock);
+
+ drm_buddy_free_list(mm, &node->blocks);
+ mutex_unlock(&mgr->lock);
atomic64_sub(usage, &mgr->usage);
atomic64_sub(vis_usage, &mgr->vis_usage);
- kvfree(node);
+ kfree(node);
}
/**
@@ -669,10 +694,19 @@ static void amdgpu_vram_mgr_debug(struct ttm_resource_manager *man,
struct drm_printer *printer)
{
struct amdgpu_vram_mgr *mgr = to_vram_mgr(man);
+ struct drm_buddy_mm *mm = &mgr->mm;
+ struct drm_buddy_block *block;
+
+ mutex_lock(&mgr->lock);
+ drm_printf(printer, "default_page_size: %lluKiB\n",
+ mgr->default_page_size >> 10);
- spin_lock(&mgr->lock);
- drm_mm_print(&mgr->mm, printer);
- spin_unlock(&mgr->lock);
+ drm_buddy_print(mm, printer);
+
+ drm_printf(printer, "reserved:\n");
+ list_for_each_entry(block, &mgr->reserved_pages, link)
+ drm_buddy_block_print(mm, block, printer);
+ mutex_unlock(&mgr->lock);
drm_printf(printer, "man size:%llu pages, ram usage:%lluMB, vis usage:%lluMB\n",
man->size, amdgpu_vram_mgr_usage(man) >> 20,
@@ -696,15 +730,20 @@ int amdgpu_vram_mgr_init(struct amdgpu_device *adev)
{
struct amdgpu_vram_mgr *mgr = &adev->mman.vram_mgr;
struct ttm_resource_manager *man = &mgr->manager;
+ int err;
ttm_resource_manager_init(man, adev->gmc.real_vram_size >> PAGE_SHIFT);
man->func = &amdgpu_vram_mgr_func;
- drm_mm_init(&mgr->mm, 0, man->size);
- spin_lock_init(&mgr->lock);
+ err = drm_buddy_init(&mgr->mm, man->size << PAGE_SHIFT, PAGE_SIZE);
+ if (err)
+ return err;
+
+ mutex_init(&mgr->lock);
INIT_LIST_HEAD(&mgr->reservations_pending);
INIT_LIST_HEAD(&mgr->reserved_pages);
+ mgr->default_page_size = PAGE_SIZE;
ttm_set_driver_manager(&adev->mman.bdev, TTM_PL_VRAM, &mgr->manager);
ttm_resource_manager_set_used(man, true);
@@ -732,16 +771,16 @@ void amdgpu_vram_mgr_fini(struct amdgpu_device *adev)
if (ret)
return;
- spin_lock(&mgr->lock);
+ mutex_lock(&mgr->lock);
list_for_each_entry_safe(rsv, temp, &mgr->reservations_pending, node)
kfree(rsv);
list_for_each_entry_safe(rsv, temp, &mgr->reserved_pages, node) {
- drm_mm_remove_node(&rsv->mm_node);
+ drm_buddy_free_list(&mgr->mm, &rsv->block);
kfree(rsv);
}
- drm_mm_takedown(&mgr->mm);
- spin_unlock(&mgr->lock);
+ drm_buddy_fini(&mgr->mm);
+ mutex_unlock(&mgr->lock);
ttm_resource_manager_cleanup(man);
ttm_set_driver_manager(&adev->mman.bdev, TTM_PL_VRAM, NULL);
--
2.25.1
^ permalink raw reply related [flat|nested] 46+ messages in thread
* [Intel-gfx] ✗ Fi.CI.BUILD: failure for series starting with [v3,1/6] drm: move the buddy allocator from i915 into common drm
2021-11-16 20:18 ` Arunpravin
` (6 preceding siblings ...)
(?)
@ 2021-11-17 2:55 ` Patchwork
-1 siblings, 0 replies; 46+ messages in thread
From: Patchwork @ 2021-11-17 2:55 UTC (permalink / raw)
To: Arunpravin; +Cc: intel-gfx
== Series Details ==
Series: series starting with [v3,1/6] drm: move the buddy allocator from i915 into common drm
URL : https://patchwork.freedesktop.org/series/96995/
State : failure
== Summary ==
Applying: drm: move the buddy allocator from i915 into common drm
Using index info to reconstruct a base tree...
M drivers/gpu/drm/Makefile
M drivers/gpu/drm/drm_drv.c
M drivers/gpu/drm/i915/Makefile
M drivers/gpu/drm/i915/i915_scatterlist.c
Falling back to patching base and 3-way merge...
Auto-merging drivers/gpu/drm/i915/i915_scatterlist.c
CONFLICT (content): Merge conflict in drivers/gpu/drm/i915/i915_scatterlist.c
Removing drivers/gpu/drm/i915/i915_buddy.h
Removing drivers/gpu/drm/i915/i915_buddy.c
Auto-merging drivers/gpu/drm/i915/Makefile
Auto-merging drivers/gpu/drm/drm_drv.c
Auto-merging drivers/gpu/drm/Makefile
CONFLICT (content): Merge conflict in drivers/gpu/drm/Makefile
error: Failed to merge in the changes.
hint: Use 'git am --show-current-patch=diff' to see the failed patch
Patch failed at 0001 drm: move the buddy allocator from i915 into common drm
When you have resolved this problem, run "git am --continue".
If you prefer to skip this patch, run "git am --skip" instead.
To restore the original branch and stop patching, run "git am --abort".
^ permalink raw reply [flat|nested] 46+ messages in thread
* Re: [PATCH v3 1/6] drm: move the buddy allocator from i915 into common drm
2021-11-16 20:18 ` Arunpravin
(?)
@ 2021-11-17 8:03 ` Christian König
-1 siblings, 0 replies; 46+ messages in thread
From: Christian König @ 2021-11-17 8:03 UTC (permalink / raw)
To: Arunpravin, dri-devel, intel-gfx, amd-gfx
Cc: matthew.auld, tzimmermann, alexander.deucher, christian.koenig
I've looked a bit more into this and I think we should just follow
Thomas Zimmermann's idea to make this a separate module.
Otherwise we just have the code around all the time even if it is unused
and implementing this should be trivial.
See how DRM_GEM_CMA_HELPER or DRM_VRAM_HELPER are done in
drivers/gpu/drm/Kconfig and then have the desired effect in
drivers/gpu/drm/Makefile
Should be something like ~15 lines of additional configuration which
saves a bit of memory on embedded systems which just need a fbdev
replacement.
Thanks,
Christian.
Am 16.11.21 um 21:18 schrieb Arunpravin:
> Move the base i915 buddy allocator code into drm
> - Move i915_buddy.h to include/drm
> - Move i915_buddy.c to drm root folder
> - Rename "i915" string with "drm" string wherever applicable
> - Rename "I915" string with "DRM" string wherever applicable
> - Fix header file dependencies
> - Fix alignment issues
> - add Makefile support for drm buddy
> - export functions and write kerneldoc description
> - Remove i915 selftest config check condition as buddy selftest
> will be moved to drm selftest folder
>
> cleanup i915 buddy references in i915 driver module
> and replace with drm buddy
>
> v2:
> - include header file in alphabetical order (Thomas)
> - merged changes listed in the body section into a single patch
> to keep the build intact (Christian, Jani)
>
> Signed-off-by: Arunpravin <Arunpravin.PaneerSelvam@amd.com>
> ---
> drivers/gpu/drm/Makefile | 2 +-
> drivers/gpu/drm/drm_buddy.c | 521 ++++++++++++++++++
> drivers/gpu/drm/drm_drv.c | 3 +
> drivers/gpu/drm/i915/Makefile | 1 -
> drivers/gpu/drm/i915/i915_buddy.c | 466 ----------------
> drivers/gpu/drm/i915/i915_buddy.h | 143 -----
> drivers/gpu/drm/i915/i915_module.c | 3 -
> drivers/gpu/drm/i915/i915_scatterlist.c | 11 +-
> drivers/gpu/drm/i915/i915_ttm_buddy_manager.c | 33 +-
> drivers/gpu/drm/i915/i915_ttm_buddy_manager.h | 4 +-
> include/drm/drm_buddy.h | 153 +++++
> 11 files changed, 702 insertions(+), 638 deletions(-)
> create mode 100644 drivers/gpu/drm/drm_buddy.c
> delete mode 100644 drivers/gpu/drm/i915/i915_buddy.c
> delete mode 100644 drivers/gpu/drm/i915/i915_buddy.h
> create mode 100644 include/drm/drm_buddy.h
>
> diff --git a/drivers/gpu/drm/Makefile b/drivers/gpu/drm/Makefile
> index 0dff40bb863c..dc61e91a3154 100644
> --- a/drivers/gpu/drm/Makefile
> +++ b/drivers/gpu/drm/Makefile
> @@ -18,7 +18,7 @@ drm-y := drm_aperture.o drm_auth.o drm_cache.o \
> drm_dumb_buffers.o drm_mode_config.o drm_vblank.o \
> drm_syncobj.o drm_lease.o drm_writeback.o drm_client.o \
> drm_client_modeset.o drm_atomic_uapi.o drm_hdcp.o \
> - drm_managed.o drm_vblank_work.o
> + drm_managed.o drm_vblank_work.o drm_buddy.o
>
> drm-$(CONFIG_DRM_LEGACY) += drm_agpsupport.o drm_bufs.o drm_context.o drm_dma.o \
> drm_legacy_misc.o drm_lock.o drm_memory.o drm_scatter.o \
> diff --git a/drivers/gpu/drm/drm_buddy.c b/drivers/gpu/drm/drm_buddy.c
> new file mode 100644
> index 000000000000..39eb1d224bec
> --- /dev/null
> +++ b/drivers/gpu/drm/drm_buddy.c
> @@ -0,0 +1,521 @@
> +// SPDX-License-Identifier: MIT
> +/*
> + * Copyright © 2021 Intel Corporation
> + */
> +
> +#include <linux/kmemleak.h>
> +#include <linux/sizes.h>
> +
> +#include <drm/drm_buddy.h>
> +
> +static struct kmem_cache *slab_blocks;
> +
> +static struct drm_buddy_block *drm_block_alloc(struct drm_buddy_mm *mm,
> + struct drm_buddy_block *parent,
> + unsigned int order,
> + u64 offset)
> +{
> + struct drm_buddy_block *block;
> +
> + BUG_ON(order > DRM_BUDDY_MAX_ORDER);
> +
> + block = kmem_cache_zalloc(slab_blocks, GFP_KERNEL);
> + if (!block)
> + return NULL;
> +
> + block->header = offset;
> + block->header |= order;
> + block->parent = parent;
> +
> + BUG_ON(block->header & DRM_BUDDY_HEADER_UNUSED);
> + return block;
> +}
> +
> +static void drm_block_free(struct drm_buddy_mm *mm,
> + struct drm_buddy_block *block)
> +{
> + kmem_cache_free(slab_blocks, block);
> +}
> +
> +static void mark_allocated(struct drm_buddy_block *block)
> +{
> + block->header &= ~DRM_BUDDY_HEADER_STATE;
> + block->header |= DRM_BUDDY_ALLOCATED;
> +
> + list_del(&block->link);
> +}
> +
> +static void mark_free(struct drm_buddy_mm *mm,
> + struct drm_buddy_block *block)
> +{
> + block->header &= ~DRM_BUDDY_HEADER_STATE;
> + block->header |= DRM_BUDDY_FREE;
> +
> + list_add(&block->link,
> + &mm->free_list[drm_buddy_block_order(block)]);
> +}
> +
> +static void mark_split(struct drm_buddy_block *block)
> +{
> + block->header &= ~DRM_BUDDY_HEADER_STATE;
> + block->header |= DRM_BUDDY_SPLIT;
> +
> + list_del(&block->link);
> +}
> +
> +/**
> + * drm_buddy_init - init memory manager
> + *
> + * @mm: DRM buddy manager to initialize
> + * @size: size in bytes to manage
> + * @chunk_size: minimum page size in bytes for our allocations
> + *
> + * Initializes the memory manager and its resources.
> + *
> + * Returns:
> + * 0 on success, error code on failure.
> + */
> +int drm_buddy_init(struct drm_buddy_mm *mm, u64 size, u64 chunk_size)
> +{
> + unsigned int i;
> + u64 offset;
> +
> + if (size < chunk_size)
> + return -EINVAL;
> +
> + if (chunk_size < PAGE_SIZE)
> + return -EINVAL;
> +
> + if (!is_power_of_2(chunk_size))
> + return -EINVAL;
> +
> + size = round_down(size, chunk_size);
> +
> + mm->size = size;
> + mm->avail = size;
> + mm->chunk_size = chunk_size;
> + mm->max_order = ilog2(size) - ilog2(chunk_size);
> +
> + BUG_ON(mm->max_order > DRM_BUDDY_MAX_ORDER);
> +
> + mm->free_list = kmalloc_array(mm->max_order + 1,
> + sizeof(struct list_head),
> + GFP_KERNEL);
> + if (!mm->free_list)
> + return -ENOMEM;
> +
> + for (i = 0; i <= mm->max_order; ++i)
> + INIT_LIST_HEAD(&mm->free_list[i]);
> +
> + mm->n_roots = hweight64(size);
> +
> + mm->roots = kmalloc_array(mm->n_roots,
> + sizeof(struct drm_buddy_block *),
> + GFP_KERNEL);
> + if (!mm->roots)
> + goto out_free_list;
> +
> + offset = 0;
> + i = 0;
> +
> + /*
> + * Split into power-of-two blocks, in case we are given a size that is
> + * not itself a power-of-two.
> + */
> + do {
> + struct drm_buddy_block *root;
> + unsigned int order;
> + u64 root_size;
> +
> + root_size = rounddown_pow_of_two(size);
> + order = ilog2(root_size) - ilog2(chunk_size);
> +
> + root = drm_block_alloc(mm, NULL, order, offset);
> + if (!root)
> + goto out_free_roots;
> +
> + mark_free(mm, root);
> +
> + BUG_ON(i > mm->max_order);
> + BUG_ON(drm_buddy_block_size(mm, root) < chunk_size);
> +
> + mm->roots[i] = root;
> +
> + offset += root_size;
> + size -= root_size;
> + i++;
> + } while (size);
> +
> + return 0;
> +
> +out_free_roots:
> + while (i--)
> + drm_block_free(mm, mm->roots[i]);
> + kfree(mm->roots);
> +out_free_list:
> + kfree(mm->free_list);
> + return -ENOMEM;
> +}
> +EXPORT_SYMBOL(drm_buddy_init);
> +
> +/**
> + * drm_buddy_fini - tear down the memory manager
> + *
> + * @mm: DRM buddy manager to free
> + *
> + * Cleanup memory manager resources and the freelist
> + */
> +void drm_buddy_fini(struct drm_buddy_mm *mm)
> +{
> + int i;
> +
> + for (i = 0; i < mm->n_roots; ++i) {
> + WARN_ON(!drm_buddy_block_is_free(mm->roots[i]));
> + drm_block_free(mm, mm->roots[i]);
> + }
> +
> + WARN_ON(mm->avail != mm->size);
> +
> + kfree(mm->roots);
> + kfree(mm->free_list);
> +}
> +EXPORT_SYMBOL(drm_buddy_fini);
> +
> +static int split_block(struct drm_buddy_mm *mm,
> + struct drm_buddy_block *block)
> +{
> + unsigned int block_order = drm_buddy_block_order(block) - 1;
> + u64 offset = drm_buddy_block_offset(block);
> +
> + BUG_ON(!drm_buddy_block_is_free(block));
> + BUG_ON(!drm_buddy_block_order(block));
> +
> + block->left = drm_block_alloc(mm, block, block_order, offset);
> + if (!block->left)
> + return -ENOMEM;
> +
> + block->right = drm_block_alloc(mm, block, block_order,
> + offset + (mm->chunk_size << block_order));
> + if (!block->right) {
> + drm_block_free(mm, block->left);
> + return -ENOMEM;
> + }
> +
> + mark_free(mm, block->left);
> + mark_free(mm, block->right);
> +
> + mark_split(block);
> +
> + return 0;
> +}
> +
> +static struct drm_buddy_block *
> +get_buddy(struct drm_buddy_block *block)
> +{
> + struct drm_buddy_block *parent;
> +
> + parent = block->parent;
> + if (!parent)
> + return NULL;
> +
> + if (parent->left == block)
> + return parent->right;
> +
> + return parent->left;
> +}
> +
> +static void __drm_buddy_free(struct drm_buddy_mm *mm,
> + struct drm_buddy_block *block)
> +{
> + struct drm_buddy_block *parent;
> +
> + while ((parent = block->parent)) {
> + struct drm_buddy_block *buddy;
> +
> + buddy = get_buddy(block);
> +
> + if (!drm_buddy_block_is_free(buddy))
> + break;
> +
> + list_del(&buddy->link);
> +
> + drm_block_free(mm, block);
> + drm_block_free(mm, buddy);
> +
> + block = parent;
> + }
> +
> + mark_free(mm, block);
> +}
> +
> +void drm_buddy_free(struct drm_buddy_mm *mm,
> + struct drm_buddy_block *block)
> +{
> + BUG_ON(!drm_buddy_block_is_allocated(block));
> + mm->avail += drm_buddy_block_size(mm, block);
> + __drm_buddy_free(mm, block);
> +}
> +
> +/**
> + * drm_buddy_free_list - free blocks
> + *
> + * @mm: DRM buddy manager
> + * @objects: input list head to free blocks
> + */
> +void drm_buddy_free_list(struct drm_buddy_mm *mm, struct list_head *objects)
> +{
> + struct drm_buddy_block *block, *on;
> +
> + list_for_each_entry_safe(block, on, objects, link) {
> + drm_buddy_free(mm, block);
> + cond_resched();
> + }
> + INIT_LIST_HEAD(objects);
> +}
> +EXPORT_SYMBOL(drm_buddy_free_list);
> +
> +/**
> + * drm_buddy_alloc - allocate power-of-two blocks
> + *
> + * @mm: DRM buddy manager to allocate from
> + * @order: size of the allocation
> + *
> + * The order value here translates to:
> + *
> + * 0 = 2^0 * mm->chunk_size
> + * 1 = 2^1 * mm->chunk_size
> + * 2 = 2^2 * mm->chunk_size
> + *
> + * Returns:
> + * allocated ptr to the &drm_buddy_block on success
> + */
> +struct drm_buddy_block *
> +drm_buddy_alloc(struct drm_buddy_mm *mm, unsigned int order)
> +{
> + struct drm_buddy_block *block = NULL;
> + unsigned int i;
> + int err;
> +
> + for (i = order; i <= mm->max_order; ++i) {
> + block = list_first_entry_or_null(&mm->free_list[i],
> + struct drm_buddy_block,
> + link);
> + if (block)
> + break;
> + }
> +
> + if (!block)
> + return ERR_PTR(-ENOSPC);
> +
> + BUG_ON(!drm_buddy_block_is_free(block));
> +
> + while (i != order) {
> + err = split_block(mm, block);
> + if (unlikely(err))
> + goto out_free;
> +
> + /* Go low */
> + block = block->left;
> + i--;
> + }
> +
> + mark_allocated(block);
> + mm->avail -= drm_buddy_block_size(mm, block);
> + kmemleak_update_trace(block);
> + return block;
> +
> +out_free:
> + if (i != order)
> + __drm_buddy_free(mm, block);
> + return ERR_PTR(err);
> +}
> +EXPORT_SYMBOL(drm_buddy_alloc);
> +
> +static inline bool overlaps(u64 s1, u64 e1, u64 s2, u64 e2)
> +{
> + return s1 <= e2 && e1 >= s2;
> +}
> +
> +static inline bool contains(u64 s1, u64 e1, u64 s2, u64 e2)
> +{
> + return s1 <= s2 && e1 >= e2;
> +}
> +
> +/**
> + * drm_buddy_alloc_range - allocate range
> + *
> + * @mm: DRM buddy manager to allocate from
> + * @blocks: output list head to add allocated blocks
> + * @start: start of the allowed range for this block
> + * @size: size of the allocation
> + *
> + * Intended for pre-allocating portions of the address space, for example to
> + * reserve a block for the initial framebuffer or similar, hence the expectation
> + * here is that drm_buddy_alloc() is still the main vehicle for
> + * allocations, so if that's not the case then the drm_mm range allocator is
> + * probably a much better fit, and so you should probably go use that instead.
> + *
> + * Note that it's safe to chain together multiple alloc_ranges
> + * with the same blocks list
> + *
> + * Returns:
> + * 0 on success, error code on failure.
> + */
> +int drm_buddy_alloc_range(struct drm_buddy_mm *mm,
> + struct list_head *blocks,
> + u64 start, u64 size)
> +{
> + struct drm_buddy_block *block;
> + struct drm_buddy_block *buddy;
> + LIST_HEAD(allocated);
> + LIST_HEAD(dfs);
> + u64 end;
> + int err;
> + int i;
> +
> + if (size < mm->chunk_size)
> + return -EINVAL;
> +
> + if (!IS_ALIGNED(size | start, mm->chunk_size))
> + return -EINVAL;
> +
> + if (range_overflows(start, size, mm->size))
> + return -EINVAL;
> +
> + for (i = 0; i < mm->n_roots; ++i)
> + list_add_tail(&mm->roots[i]->tmp_link, &dfs);
> +
> + end = start + size - 1;
> +
> + do {
> + u64 block_start;
> + u64 block_end;
> +
> + block = list_first_entry_or_null(&dfs,
> + struct drm_buddy_block,
> + tmp_link);
> + if (!block)
> + break;
> +
> + list_del(&block->tmp_link);
> +
> + block_start = drm_buddy_block_offset(block);
> + block_end = block_start + drm_buddy_block_size(mm, block) - 1;
> +
> + if (!overlaps(start, end, block_start, block_end))
> + continue;
> +
> + if (drm_buddy_block_is_allocated(block)) {
> + err = -ENOSPC;
> + goto err_free;
> + }
> +
> + if (contains(start, end, block_start, block_end)) {
> + if (!drm_buddy_block_is_free(block)) {
> + err = -ENOSPC;
> + goto err_free;
> + }
> +
> + mark_allocated(block);
> + mm->avail -= drm_buddy_block_size(mm, block);
> + list_add_tail(&block->link, &allocated);
> + continue;
> + }
> +
> + if (!drm_buddy_block_is_split(block)) {
> + err = split_block(mm, block);
> + if (unlikely(err))
> + goto err_undo;
> + }
> +
> + list_add(&block->right->tmp_link, &dfs);
> + list_add(&block->left->tmp_link, &dfs);
> + } while (1);
> +
> + list_splice_tail(&allocated, blocks);
> + return 0;
> +
> +err_undo:
> + /*
> + * We really don't want to leave around a bunch of split blocks, since
> + * bigger is better, so make sure we merge everything back before we
> + * free the allocated blocks.
> + */
> + buddy = get_buddy(block);
> + if (buddy &&
> + (drm_buddy_block_is_free(block) &&
> + drm_buddy_block_is_free(buddy)))
> + __drm_buddy_free(mm, block);
> +
> +err_free:
> + drm_buddy_free_list(mm, &allocated);
> + return err;
> +}
> +EXPORT_SYMBOL(drm_buddy_alloc_range);
> +
> +/**
> + * drm_buddy_block_print - print block information
> + *
> + * @mm: DRM buddy manager
> + * @block: DRM buddy block
> + * @p: DRM printer to use
> + */
> +void drm_buddy_block_print(struct drm_buddy_mm *mm,
> + struct drm_buddy_block *block,
> + struct drm_printer *p)
> +{
> + u64 start = drm_buddy_block_offset(block);
> + u64 size = drm_buddy_block_size(mm, block);
> +
> + drm_printf(p, "%#018llx-%#018llx: %llu\n", start, start + size, size);
> +}
> +EXPORT_SYMBOL(drm_buddy_block_print);
> +
> +/**
> + * drm_buddy_print - print allocator state
> + *
> + * @mm: DRM buddy manager
> + * @p: DRM printer to use
> + */
> +void drm_buddy_print(struct drm_buddy_mm *mm, struct drm_printer *p)
> +{
> + int order;
> +
> + drm_printf(p, "chunk_size: %lluKiB, total: %lluMiB, free: %lluMiB\n",
> + mm->chunk_size >> 10, mm->size >> 20, mm->avail >> 20);
> +
> + for (order = mm->max_order; order >= 0; order--) {
> + struct drm_buddy_block *block;
> + u64 count = 0, free;
> +
> + list_for_each_entry(block, &mm->free_list[order], link) {
> + BUG_ON(!drm_buddy_block_is_free(block));
> + count++;
> + }
> +
> + drm_printf(p, "order-%d ", order);
> +
> + free = count * (mm->chunk_size << order);
> + if (free < SZ_1M)
> + drm_printf(p, "free: %lluKiB", free >> 10);
> + else
> + drm_printf(p, "free: %lluMiB", free >> 20);
> +
> + drm_printf(p, ", pages: %llu\n", count);
> + }
> +}
> +EXPORT_SYMBOL(drm_buddy_print);
> +
> +void drm_buddy_module_exit(void)
> +{
> + kmem_cache_destroy(slab_blocks);
> +}
> +
> +int __init drm_buddy_module_init(void)
> +{
> + slab_blocks = KMEM_CACHE(drm_buddy_block, 0);
> + if (!slab_blocks)
> + return -ENOMEM;
> +
> + return 0;
> +}
> diff --git a/drivers/gpu/drm/drm_drv.c b/drivers/gpu/drm/drm_drv.c
> index 7a5097467ba5..5d5e46e60586 100644
> --- a/drivers/gpu/drm/drm_drv.c
> +++ b/drivers/gpu/drm/drm_drv.c
> @@ -35,6 +35,7 @@
> #include <linux/slab.h>
> #include <linux/srcu.h>
>
> +#include <drm/drm_buddy.h>
> #include <drm/drm_cache.h>
> #include <drm/drm_client.h>
> #include <drm/drm_color_mgmt.h>
> @@ -1034,6 +1035,7 @@ static void drm_core_exit(void)
> drm_sysfs_destroy();
> idr_destroy(&drm_minors_idr);
> drm_connector_ida_destroy();
> + drm_buddy_module_exit();
> }
>
> static int __init drm_core_init(void)
> @@ -1043,6 +1045,7 @@ static int __init drm_core_init(void)
> drm_connector_ida_init();
> idr_init(&drm_minors_idr);
> drm_memcpy_init_early();
> + drm_buddy_module_init();
>
> ret = drm_sysfs_init();
> if (ret < 0) {
> diff --git a/drivers/gpu/drm/i915/Makefile b/drivers/gpu/drm/i915/Makefile
> index 467872cca027..fc5ca8c4ccb2 100644
> --- a/drivers/gpu/drm/i915/Makefile
> +++ b/drivers/gpu/drm/i915/Makefile
> @@ -161,7 +161,6 @@ gem-y += \
> i915-y += \
> $(gem-y) \
> i915_active.o \
> - i915_buddy.o \
> i915_cmd_parser.o \
> i915_gem_evict.o \
> i915_gem_gtt.o \
> diff --git a/drivers/gpu/drm/i915/i915_buddy.c b/drivers/gpu/drm/i915/i915_buddy.c
> deleted file mode 100644
> index 6e2ad68f8f3f..000000000000
> --- a/drivers/gpu/drm/i915/i915_buddy.c
> +++ /dev/null
> @@ -1,466 +0,0 @@
> -// SPDX-License-Identifier: MIT
> -/*
> - * Copyright © 2021 Intel Corporation
> - */
> -
> -#include <linux/kmemleak.h>
> -#include <linux/sizes.h>
> -
> -#include "i915_buddy.h"
> -
> -#include "i915_gem.h"
> -#include "i915_utils.h"
> -
> -static struct kmem_cache *slab_blocks;
> -
> -static struct i915_buddy_block *i915_block_alloc(struct i915_buddy_mm *mm,
> - struct i915_buddy_block *parent,
> - unsigned int order,
> - u64 offset)
> -{
> - struct i915_buddy_block *block;
> -
> - GEM_BUG_ON(order > I915_BUDDY_MAX_ORDER);
> -
> - block = kmem_cache_zalloc(slab_blocks, GFP_KERNEL);
> - if (!block)
> - return NULL;
> -
> - block->header = offset;
> - block->header |= order;
> - block->parent = parent;
> -
> - GEM_BUG_ON(block->header & I915_BUDDY_HEADER_UNUSED);
> - return block;
> -}
> -
> -static void i915_block_free(struct i915_buddy_mm *mm,
> - struct i915_buddy_block *block)
> -{
> - kmem_cache_free(slab_blocks, block);
> -}
> -
> -static void mark_allocated(struct i915_buddy_block *block)
> -{
> - block->header &= ~I915_BUDDY_HEADER_STATE;
> - block->header |= I915_BUDDY_ALLOCATED;
> -
> - list_del(&block->link);
> -}
> -
> -static void mark_free(struct i915_buddy_mm *mm,
> - struct i915_buddy_block *block)
> -{
> - block->header &= ~I915_BUDDY_HEADER_STATE;
> - block->header |= I915_BUDDY_FREE;
> -
> - list_add(&block->link,
> - &mm->free_list[i915_buddy_block_order(block)]);
> -}
> -
> -static void mark_split(struct i915_buddy_block *block)
> -{
> - block->header &= ~I915_BUDDY_HEADER_STATE;
> - block->header |= I915_BUDDY_SPLIT;
> -
> - list_del(&block->link);
> -}
> -
> -int i915_buddy_init(struct i915_buddy_mm *mm, u64 size, u64 chunk_size)
> -{
> - unsigned int i;
> - u64 offset;
> -
> - if (size < chunk_size)
> - return -EINVAL;
> -
> - if (chunk_size < PAGE_SIZE)
> - return -EINVAL;
> -
> - if (!is_power_of_2(chunk_size))
> - return -EINVAL;
> -
> - size = round_down(size, chunk_size);
> -
> - mm->size = size;
> - mm->avail = size;
> - mm->chunk_size = chunk_size;
> - mm->max_order = ilog2(size) - ilog2(chunk_size);
> -
> - GEM_BUG_ON(mm->max_order > I915_BUDDY_MAX_ORDER);
> -
> - mm->free_list = kmalloc_array(mm->max_order + 1,
> - sizeof(struct list_head),
> - GFP_KERNEL);
> - if (!mm->free_list)
> - return -ENOMEM;
> -
> - for (i = 0; i <= mm->max_order; ++i)
> - INIT_LIST_HEAD(&mm->free_list[i]);
> -
> - mm->n_roots = hweight64(size);
> -
> - mm->roots = kmalloc_array(mm->n_roots,
> - sizeof(struct i915_buddy_block *),
> - GFP_KERNEL);
> - if (!mm->roots)
> - goto out_free_list;
> -
> - offset = 0;
> - i = 0;
> -
> - /*
> - * Split into power-of-two blocks, in case we are given a size that is
> - * not itself a power-of-two.
> - */
> - do {
> - struct i915_buddy_block *root;
> - unsigned int order;
> - u64 root_size;
> -
> - root_size = rounddown_pow_of_two(size);
> - order = ilog2(root_size) - ilog2(chunk_size);
> -
> - root = i915_block_alloc(mm, NULL, order, offset);
> - if (!root)
> - goto out_free_roots;
> -
> - mark_free(mm, root);
> -
> - GEM_BUG_ON(i > mm->max_order);
> - GEM_BUG_ON(i915_buddy_block_size(mm, root) < chunk_size);
> -
> - mm->roots[i] = root;
> -
> - offset += root_size;
> - size -= root_size;
> - i++;
> - } while (size);
> -
> - return 0;
> -
> -out_free_roots:
> - while (i--)
> - i915_block_free(mm, mm->roots[i]);
> - kfree(mm->roots);
> -out_free_list:
> - kfree(mm->free_list);
> - return -ENOMEM;
> -}
> -
> -void i915_buddy_fini(struct i915_buddy_mm *mm)
> -{
> - int i;
> -
> - for (i = 0; i < mm->n_roots; ++i) {
> - GEM_WARN_ON(!i915_buddy_block_is_free(mm->roots[i]));
> - i915_block_free(mm, mm->roots[i]);
> - }
> -
> - GEM_WARN_ON(mm->avail != mm->size);
> -
> - kfree(mm->roots);
> - kfree(mm->free_list);
> -}
> -
> -static int split_block(struct i915_buddy_mm *mm,
> - struct i915_buddy_block *block)
> -{
> - unsigned int block_order = i915_buddy_block_order(block) - 1;
> - u64 offset = i915_buddy_block_offset(block);
> -
> - GEM_BUG_ON(!i915_buddy_block_is_free(block));
> - GEM_BUG_ON(!i915_buddy_block_order(block));
> -
> - block->left = i915_block_alloc(mm, block, block_order, offset);
> - if (!block->left)
> - return -ENOMEM;
> -
> - block->right = i915_block_alloc(mm, block, block_order,
> - offset + (mm->chunk_size << block_order));
> - if (!block->right) {
> - i915_block_free(mm, block->left);
> - return -ENOMEM;
> - }
> -
> - mark_free(mm, block->left);
> - mark_free(mm, block->right);
> -
> - mark_split(block);
> -
> - return 0;
> -}
> -
> -static struct i915_buddy_block *
> -get_buddy(struct i915_buddy_block *block)
> -{
> - struct i915_buddy_block *parent;
> -
> - parent = block->parent;
> - if (!parent)
> - return NULL;
> -
> - if (parent->left == block)
> - return parent->right;
> -
> - return parent->left;
> -}
> -
> -static void __i915_buddy_free(struct i915_buddy_mm *mm,
> - struct i915_buddy_block *block)
> -{
> - struct i915_buddy_block *parent;
> -
> - while ((parent = block->parent)) {
> - struct i915_buddy_block *buddy;
> -
> - buddy = get_buddy(block);
> -
> - if (!i915_buddy_block_is_free(buddy))
> - break;
> -
> - list_del(&buddy->link);
> -
> - i915_block_free(mm, block);
> - i915_block_free(mm, buddy);
> -
> - block = parent;
> - }
> -
> - mark_free(mm, block);
> -}
> -
> -void i915_buddy_free(struct i915_buddy_mm *mm,
> - struct i915_buddy_block *block)
> -{
> - GEM_BUG_ON(!i915_buddy_block_is_allocated(block));
> - mm->avail += i915_buddy_block_size(mm, block);
> - __i915_buddy_free(mm, block);
> -}
> -
> -void i915_buddy_free_list(struct i915_buddy_mm *mm, struct list_head *objects)
> -{
> - struct i915_buddy_block *block, *on;
> -
> - list_for_each_entry_safe(block, on, objects, link) {
> - i915_buddy_free(mm, block);
> - cond_resched();
> - }
> - INIT_LIST_HEAD(objects);
> -}
> -
> -/*
> - * Allocate power-of-two block. The order value here translates to:
> - *
> - * 0 = 2^0 * mm->chunk_size
> - * 1 = 2^1 * mm->chunk_size
> - * 2 = 2^2 * mm->chunk_size
> - * ...
> - */
> -struct i915_buddy_block *
> -i915_buddy_alloc(struct i915_buddy_mm *mm, unsigned int order)
> -{
> - struct i915_buddy_block *block = NULL;
> - unsigned int i;
> - int err;
> -
> - for (i = order; i <= mm->max_order; ++i) {
> - block = list_first_entry_or_null(&mm->free_list[i],
> - struct i915_buddy_block,
> - link);
> - if (block)
> - break;
> - }
> -
> - if (!block)
> - return ERR_PTR(-ENOSPC);
> -
> - GEM_BUG_ON(!i915_buddy_block_is_free(block));
> -
> - while (i != order) {
> - err = split_block(mm, block);
> - if (unlikely(err))
> - goto out_free;
> -
> - /* Go low */
> - block = block->left;
> - i--;
> - }
> -
> - mark_allocated(block);
> - mm->avail -= i915_buddy_block_size(mm, block);
> - kmemleak_update_trace(block);
> - return block;
> -
> -out_free:
> - if (i != order)
> - __i915_buddy_free(mm, block);
> - return ERR_PTR(err);
> -}
> -
> -static inline bool overlaps(u64 s1, u64 e1, u64 s2, u64 e2)
> -{
> - return s1 <= e2 && e1 >= s2;
> -}
> -
> -static inline bool contains(u64 s1, u64 e1, u64 s2, u64 e2)
> -{
> - return s1 <= s2 && e1 >= e2;
> -}
> -
> -/*
> - * Allocate range. Note that it's safe to chain together multiple alloc_ranges
> - * with the same blocks list.
> - *
> - * Intended for pre-allocating portions of the address space, for example to
> - * reserve a block for the initial framebuffer or similar, hence the expectation
> - * here is that i915_buddy_alloc() is still the main vehicle for
> - * allocations, so if that's not the case then the drm_mm range allocator is
> - * probably a much better fit, and so you should probably go use that instead.
> - */
> -int i915_buddy_alloc_range(struct i915_buddy_mm *mm,
> - struct list_head *blocks,
> - u64 start, u64 size)
> -{
> - struct i915_buddy_block *block;
> - struct i915_buddy_block *buddy;
> - LIST_HEAD(allocated);
> - LIST_HEAD(dfs);
> - u64 end;
> - int err;
> - int i;
> -
> - if (size < mm->chunk_size)
> - return -EINVAL;
> -
> - if (!IS_ALIGNED(size | start, mm->chunk_size))
> - return -EINVAL;
> -
> - if (range_overflows(start, size, mm->size))
> - return -EINVAL;
> -
> - for (i = 0; i < mm->n_roots; ++i)
> - list_add_tail(&mm->roots[i]->tmp_link, &dfs);
> -
> - end = start + size - 1;
> -
> - do {
> - u64 block_start;
> - u64 block_end;
> -
> - block = list_first_entry_or_null(&dfs,
> - struct i915_buddy_block,
> - tmp_link);
> - if (!block)
> - break;
> -
> - list_del(&block->tmp_link);
> -
> - block_start = i915_buddy_block_offset(block);
> - block_end = block_start + i915_buddy_block_size(mm, block) - 1;
> -
> - if (!overlaps(start, end, block_start, block_end))
> - continue;
> -
> - if (i915_buddy_block_is_allocated(block)) {
> - err = -ENOSPC;
> - goto err_free;
> - }
> -
> - if (contains(start, end, block_start, block_end)) {
> - if (!i915_buddy_block_is_free(block)) {
> - err = -ENOSPC;
> - goto err_free;
> - }
> -
> - mark_allocated(block);
> - mm->avail -= i915_buddy_block_size(mm, block);
> - list_add_tail(&block->link, &allocated);
> - continue;
> - }
> -
> - if (!i915_buddy_block_is_split(block)) {
> - err = split_block(mm, block);
> - if (unlikely(err))
> - goto err_undo;
> - }
> -
> - list_add(&block->right->tmp_link, &dfs);
> - list_add(&block->left->tmp_link, &dfs);
> - } while (1);
> -
> - list_splice_tail(&allocated, blocks);
> - return 0;
> -
> -err_undo:
> - /*
> - * We really don't want to leave around a bunch of split blocks, since
> - * bigger is better, so make sure we merge everything back before we
> - * free the allocated blocks.
> - */
> - buddy = get_buddy(block);
> - if (buddy &&
> - (i915_buddy_block_is_free(block) &&
> - i915_buddy_block_is_free(buddy)))
> - __i915_buddy_free(mm, block);
> -
> -err_free:
> - i915_buddy_free_list(mm, &allocated);
> - return err;
> -}
> -
> -void i915_buddy_block_print(struct i915_buddy_mm *mm,
> - struct i915_buddy_block *block,
> - struct drm_printer *p)
> -{
> - u64 start = i915_buddy_block_offset(block);
> - u64 size = i915_buddy_block_size(mm, block);
> -
> - drm_printf(p, "%#018llx-%#018llx: %llu\n", start, start + size, size);
> -}
> -
> -void i915_buddy_print(struct i915_buddy_mm *mm, struct drm_printer *p)
> -{
> - int order;
> -
> - drm_printf(p, "chunk_size: %lluKiB, total: %lluMiB, free: %lluMiB\n",
> - mm->chunk_size >> 10, mm->size >> 20, mm->avail >> 20);
> -
> - for (order = mm->max_order; order >= 0; order--) {
> - struct i915_buddy_block *block;
> - u64 count = 0, free;
> -
> - list_for_each_entry(block, &mm->free_list[order], link) {
> - GEM_BUG_ON(!i915_buddy_block_is_free(block));
> - count++;
> - }
> -
> - drm_printf(p, "order-%d ", order);
> -
> - free = count * (mm->chunk_size << order);
> - if (free < SZ_1M)
> - drm_printf(p, "free: %lluKiB", free >> 10);
> - else
> - drm_printf(p, "free: %lluMiB", free >> 20);
> -
> - drm_printf(p, ", pages: %llu\n", count);
> - }
> -}
> -
> -#if IS_ENABLED(CONFIG_DRM_I915_SELFTEST)
> -#include "selftests/i915_buddy.c"
> -#endif
> -
> -void i915_buddy_module_exit(void)
> -{
> - kmem_cache_destroy(slab_blocks);
> -}
> -
> -int __init i915_buddy_module_init(void)
> -{
> - slab_blocks = KMEM_CACHE(i915_buddy_block, 0);
> - if (!slab_blocks)
> - return -ENOMEM;
> -
> - return 0;
> -}
> diff --git a/drivers/gpu/drm/i915/i915_buddy.h b/drivers/gpu/drm/i915/i915_buddy.h
> deleted file mode 100644
> index 7077742112ac..000000000000
> --- a/drivers/gpu/drm/i915/i915_buddy.h
> +++ /dev/null
> @@ -1,143 +0,0 @@
> -/* SPDX-License-Identifier: MIT */
> -/*
> - * Copyright © 2021 Intel Corporation
> - */
> -
> -#ifndef __I915_BUDDY_H__
> -#define __I915_BUDDY_H__
> -
> -#include <linux/bitops.h>
> -#include <linux/list.h>
> -#include <linux/slab.h>
> -
> -#include <drm/drm_print.h>
> -
> -struct i915_buddy_block {
> -#define I915_BUDDY_HEADER_OFFSET GENMASK_ULL(63, 12)
> -#define I915_BUDDY_HEADER_STATE GENMASK_ULL(11, 10)
> -#define I915_BUDDY_ALLOCATED (1 << 10)
> -#define I915_BUDDY_FREE (2 << 10)
> -#define I915_BUDDY_SPLIT (3 << 10)
> -/* Free to be used, if needed in the future */
> -#define I915_BUDDY_HEADER_UNUSED GENMASK_ULL(9, 6)
> -#define I915_BUDDY_HEADER_ORDER GENMASK_ULL(5, 0)
> - u64 header;
> -
> - struct i915_buddy_block *left;
> - struct i915_buddy_block *right;
> - struct i915_buddy_block *parent;
> -
> - void *private; /* owned by creator */
> -
> - /*
> - * While the block is allocated by the user through i915_buddy_alloc*,
> - * the user has ownership of the link, for example to maintain within
> - * a list, if so desired. As soon as the block is freed with
> - * i915_buddy_free* ownership is given back to the mm.
> - */
> - struct list_head link;
> - struct list_head tmp_link;
> -};
> -
> -/* Order-zero must be at least PAGE_SIZE */
> -#define I915_BUDDY_MAX_ORDER (63 - PAGE_SHIFT)
> -
> -/*
> - * Binary Buddy System.
> - *
> - * Locking should be handled by the user, a simple mutex around
> - * i915_buddy_alloc* and i915_buddy_free* should suffice.
> - */
> -struct i915_buddy_mm {
> - /* Maintain a free list for each order. */
> - struct list_head *free_list;
> -
> - /*
> - * Maintain explicit binary tree(s) to track the allocation of the
> - * address space. This gives us a simple way of finding a buddy block
> - * and performing the potentially recursive merge step when freeing a
> - * block. Nodes are either allocated or free, in which case they will
> - * also exist on the respective free list.
> - */
> - struct i915_buddy_block **roots;
> -
> - /*
> - * Anything from here is public, and remains static for the lifetime of
> - * the mm. Everything above is considered do-not-touch.
> - */
> - unsigned int n_roots;
> - unsigned int max_order;
> -
> - /* Must be at least PAGE_SIZE */
> - u64 chunk_size;
> - u64 size;
> - u64 avail;
> -};
> -
> -static inline u64
> -i915_buddy_block_offset(struct i915_buddy_block *block)
> -{
> - return block->header & I915_BUDDY_HEADER_OFFSET;
> -}
> -
> -static inline unsigned int
> -i915_buddy_block_order(struct i915_buddy_block *block)
> -{
> - return block->header & I915_BUDDY_HEADER_ORDER;
> -}
> -
> -static inline unsigned int
> -i915_buddy_block_state(struct i915_buddy_block *block)
> -{
> - return block->header & I915_BUDDY_HEADER_STATE;
> -}
> -
> -static inline bool
> -i915_buddy_block_is_allocated(struct i915_buddy_block *block)
> -{
> - return i915_buddy_block_state(block) == I915_BUDDY_ALLOCATED;
> -}
> -
> -static inline bool
> -i915_buddy_block_is_free(struct i915_buddy_block *block)
> -{
> - return i915_buddy_block_state(block) == I915_BUDDY_FREE;
> -}
> -
> -static inline bool
> -i915_buddy_block_is_split(struct i915_buddy_block *block)
> -{
> - return i915_buddy_block_state(block) == I915_BUDDY_SPLIT;
> -}
> -
> -static inline u64
> -i915_buddy_block_size(struct i915_buddy_mm *mm,
> - struct i915_buddy_block *block)
> -{
> - return mm->chunk_size << i915_buddy_block_order(block);
> -}
> -
> -int i915_buddy_init(struct i915_buddy_mm *mm, u64 size, u64 chunk_size);
> -
> -void i915_buddy_fini(struct i915_buddy_mm *mm);
> -
> -struct i915_buddy_block *
> -i915_buddy_alloc(struct i915_buddy_mm *mm, unsigned int order);
> -
> -int i915_buddy_alloc_range(struct i915_buddy_mm *mm,
> - struct list_head *blocks,
> - u64 start, u64 size);
> -
> -void i915_buddy_free(struct i915_buddy_mm *mm, struct i915_buddy_block *block);
> -
> -void i915_buddy_free_list(struct i915_buddy_mm *mm, struct list_head *objects);
> -
> -void i915_buddy_print(struct i915_buddy_mm *mm, struct drm_printer *p);
> -void i915_buddy_block_print(struct i915_buddy_mm *mm,
> - struct i915_buddy_block *block,
> - struct drm_printer *p);
> -
> -void i915_buddy_module_exit(void);
> -int i915_buddy_module_init(void);
> -
> -#endif
> diff --git a/drivers/gpu/drm/i915/i915_module.c b/drivers/gpu/drm/i915/i915_module.c
> index c7507266aa83..355681dbd7a8 100644
> --- a/drivers/gpu/drm/i915/i915_module.c
> +++ b/drivers/gpu/drm/i915/i915_module.c
> @@ -9,7 +9,6 @@
> #include "gem/i915_gem_context.h"
> #include "gem/i915_gem_object.h"
> #include "i915_active.h"
> -#include "i915_buddy.h"
> #include "i915_params.h"
> #include "i915_pci.h"
> #include "i915_perf.h"
> @@ -50,8 +49,6 @@ static const struct {
> { .init = i915_check_nomodeset },
> { .init = i915_active_module_init,
> .exit = i915_active_module_exit },
> - { .init = i915_buddy_module_init,
> - .exit = i915_buddy_module_exit },
> { .init = i915_context_module_init,
> .exit = i915_context_module_exit },
> { .init = i915_gem_context_module_init,
> diff --git a/drivers/gpu/drm/i915/i915_scatterlist.c b/drivers/gpu/drm/i915/i915_scatterlist.c
> index 4a6712dca838..84d622aa32d2 100644
> --- a/drivers/gpu/drm/i915/i915_scatterlist.c
> +++ b/drivers/gpu/drm/i915/i915_scatterlist.c
> @@ -5,10 +5,9 @@
> */
>
> #include "i915_scatterlist.h"
> -
> -#include "i915_buddy.h"
> #include "i915_ttm_buddy_manager.h"
>
> +#include <drm/drm_buddy.h>
> #include <drm/drm_mm.h>
>
> #include <linux/slab.h>
> @@ -126,9 +125,9 @@ struct sg_table *i915_sg_from_buddy_resource(struct ttm_resource *res,
> struct i915_ttm_buddy_resource *bman_res = to_ttm_buddy_resource(res);
> const u64 size = res->num_pages << PAGE_SHIFT;
> const u64 max_segment = rounddown(UINT_MAX, PAGE_SIZE);
> - struct i915_buddy_mm *mm = bman_res->mm;
> + struct drm_buddy_mm *mm = bman_res->mm;
> struct list_head *blocks = &bman_res->blocks;
> - struct i915_buddy_block *block;
> + struct drm_buddy_block *block;
> struct scatterlist *sg;
> struct sg_table *st;
> resource_size_t prev_end;
> @@ -151,8 +150,8 @@ struct sg_table *i915_sg_from_buddy_resource(struct ttm_resource *res,
> list_for_each_entry(block, blocks, link) {
> u64 block_size, offset;
>
> - block_size = min_t(u64, size, i915_buddy_block_size(mm, block));
> - offset = i915_buddy_block_offset(block);
> + block_size = min_t(u64, size, drm_buddy_block_size(mm, block));
> + offset = drm_buddy_block_offset(block);
>
> while (block_size) {
> u64 len;
> diff --git a/drivers/gpu/drm/i915/i915_ttm_buddy_manager.c b/drivers/gpu/drm/i915/i915_ttm_buddy_manager.c
> index d59fbb019032..c4b70cb8c248 100644
> --- a/drivers/gpu/drm/i915/i915_ttm_buddy_manager.c
> +++ b/drivers/gpu/drm/i915/i915_ttm_buddy_manager.c
> @@ -8,14 +8,15 @@
> #include <drm/ttm/ttm_bo_driver.h>
> #include <drm/ttm/ttm_placement.h>
>
> +#include <drm/drm_buddy.h>
> +
> #include "i915_ttm_buddy_manager.h"
>
> -#include "i915_buddy.h"
> #include "i915_gem.h"
>
> struct i915_ttm_buddy_manager {
> struct ttm_resource_manager manager;
> - struct i915_buddy_mm mm;
> + struct drm_buddy_mm mm;
> struct list_head reserved;
> struct mutex lock;
> u64 default_page_size;
> @@ -34,7 +35,7 @@ static int i915_ttm_buddy_man_alloc(struct ttm_resource_manager *man,
> {
> struct i915_ttm_buddy_manager *bman = to_buddy_manager(man);
> struct i915_ttm_buddy_resource *bman_res;
> - struct i915_buddy_mm *mm = &bman->mm;
> + struct drm_buddy_mm *mm = &bman->mm;
> unsigned long n_pages;
> unsigned int min_order;
> u64 min_page_size;
> @@ -73,7 +74,7 @@ static int i915_ttm_buddy_man_alloc(struct ttm_resource_manager *man,
> n_pages = size >> ilog2(mm->chunk_size);
>
> do {
> - struct i915_buddy_block *block;
> + struct drm_buddy_block *block;
> unsigned int order;
>
> order = fls(n_pages) - 1;
> @@ -82,7 +83,7 @@ static int i915_ttm_buddy_man_alloc(struct ttm_resource_manager *man,
>
> do {
> mutex_lock(&bman->lock);
> - block = i915_buddy_alloc(mm, order);
> + block = drm_buddy_alloc(mm, order);
> mutex_unlock(&bman->lock);
> if (!IS_ERR(block))
> break;
> @@ -106,7 +107,7 @@ static int i915_ttm_buddy_man_alloc(struct ttm_resource_manager *man,
>
> err_free_blocks:
> mutex_lock(&bman->lock);
> - i915_buddy_free_list(mm, &bman_res->blocks);
> + drm_buddy_free_list(mm, &bman_res->blocks);
> mutex_unlock(&bman->lock);
> err_free_res:
> kfree(bman_res);
> @@ -120,7 +121,7 @@ static void i915_ttm_buddy_man_free(struct ttm_resource_manager *man,
> struct i915_ttm_buddy_manager *bman = to_buddy_manager(man);
>
> mutex_lock(&bman->lock);
> - i915_buddy_free_list(&bman->mm, &bman_res->blocks);
> + drm_buddy_free_list(&bman->mm, &bman_res->blocks);
> mutex_unlock(&bman->lock);
>
> kfree(bman_res);
> @@ -130,17 +131,17 @@ static void i915_ttm_buddy_man_debug(struct ttm_resource_manager *man,
> struct drm_printer *printer)
> {
> struct i915_ttm_buddy_manager *bman = to_buddy_manager(man);
> - struct i915_buddy_block *block;
> + struct drm_buddy_block *block;
>
> mutex_lock(&bman->lock);
> drm_printf(printer, "default_page_size: %lluKiB\n",
> bman->default_page_size >> 10);
>
> - i915_buddy_print(&bman->mm, printer);
> + drm_buddy_print(&bman->mm, printer);
>
> drm_printf(printer, "reserved:\n");
> list_for_each_entry(block, &bman->reserved, link)
> - i915_buddy_block_print(&bman->mm, block, printer);
> + drm_buddy_block_print(&bman->mm, block, printer);
> mutex_unlock(&bman->lock);
> }
>
> @@ -190,7 +191,7 @@ int i915_ttm_buddy_man_init(struct ttm_device *bdev,
> if (!bman)
> return -ENOMEM;
>
> - err = i915_buddy_init(&bman->mm, size, chunk_size);
> + err = drm_buddy_init(&bman->mm, size, chunk_size);
> if (err)
> goto err_free_bman;
>
> @@ -228,7 +229,7 @@ int i915_ttm_buddy_man_fini(struct ttm_device *bdev, unsigned int type)
> {
> struct ttm_resource_manager *man = ttm_manager_type(bdev, type);
> struct i915_ttm_buddy_manager *bman = to_buddy_manager(man);
> - struct i915_buddy_mm *mm = &bman->mm;
> + struct drm_buddy_mm *mm = &bman->mm;
> int ret;
>
> ttm_resource_manager_set_used(man, false);
> @@ -240,8 +241,8 @@ int i915_ttm_buddy_man_fini(struct ttm_device *bdev, unsigned int type)
> ttm_set_driver_manager(bdev, type, NULL);
>
> mutex_lock(&bman->lock);
> - i915_buddy_free_list(mm, &bman->reserved);
> - i915_buddy_fini(mm);
> + drm_buddy_free_list(mm, &bman->reserved);
> + drm_buddy_fini(mm);
> mutex_unlock(&bman->lock);
>
> ttm_resource_manager_cleanup(man);
> @@ -264,11 +265,11 @@ int i915_ttm_buddy_man_reserve(struct ttm_resource_manager *man,
> u64 start, u64 size)
> {
> struct i915_ttm_buddy_manager *bman = to_buddy_manager(man);
> - struct i915_buddy_mm *mm = &bman->mm;
> + struct drm_buddy_mm *mm = &bman->mm;
> int ret;
>
> mutex_lock(&bman->lock);
> - ret = i915_buddy_alloc_range(mm, &bman->reserved, start, size);
> + ret = drm_buddy_alloc_range(mm, &bman->reserved, start, size);
> mutex_unlock(&bman->lock);
>
> return ret;
> diff --git a/drivers/gpu/drm/i915/i915_ttm_buddy_manager.h b/drivers/gpu/drm/i915/i915_ttm_buddy_manager.h
> index 0722d33f3e14..fa644b512c2e 100644
> --- a/drivers/gpu/drm/i915/i915_ttm_buddy_manager.h
> +++ b/drivers/gpu/drm/i915/i915_ttm_buddy_manager.h
> @@ -13,7 +13,7 @@
>
> struct ttm_device;
> struct ttm_resource_manager;
> -struct i915_buddy_mm;
> +struct drm_buddy_mm;
>
> /**
> * struct i915_ttm_buddy_resource
> @@ -28,7 +28,7 @@ struct i915_buddy_mm;
> struct i915_ttm_buddy_resource {
> struct ttm_resource base;
> struct list_head blocks;
> - struct i915_buddy_mm *mm;
> + struct drm_buddy_mm *mm;
> };
>
> /**
> diff --git a/include/drm/drm_buddy.h b/include/drm/drm_buddy.h
> new file mode 100644
> index 000000000000..5ce3fc702f80
> --- /dev/null
> +++ b/include/drm/drm_buddy.h
> @@ -0,0 +1,153 @@
> +/* SPDX-License-Identifier: MIT */
> +/*
> + * Copyright © 2021 Intel Corporation
> + */
> +
> +#ifndef __DRM_BUDDY_H__
> +#define __DRM_BUDDY_H__
> +
> +#include <linux/bitops.h>
> +#include <linux/list.h>
> +#include <linux/slab.h>
> +#include <linux/sched.h>
> +
> +#include <drm/drm_print.h>
> +
> +#define range_overflows(start, size, max) ({ \
> + typeof(start) start__ = (start); \
> + typeof(size) size__ = (size); \
> + typeof(max) max__ = (max); \
> + (void)(&start__ == &size__); \
> + (void)(&start__ == &max__); \
> + start__ >= max__ || size__ > max__ - start__; \
> +})
> +
> +struct drm_buddy_block {
> +#define DRM_BUDDY_HEADER_OFFSET GENMASK_ULL(63, 12)
> +#define DRM_BUDDY_HEADER_STATE GENMASK_ULL(11, 10)
> +#define DRM_BUDDY_ALLOCATED (1 << 10)
> +#define DRM_BUDDY_FREE (2 << 10)
> +#define DRM_BUDDY_SPLIT (3 << 10)
> +/* Free to be used, if needed in the future */
> +#define DRM_BUDDY_HEADER_UNUSED GENMASK_ULL(9, 6)
> +#define DRM_BUDDY_HEADER_ORDER GENMASK_ULL(5, 0)
> + u64 header;
> +
> + struct drm_buddy_block *left;
> + struct drm_buddy_block *right;
> + struct drm_buddy_block *parent;
> +
> + void *private; /* owned by creator */
> +
> + /*
> + * While the block is allocated by the user through drm_buddy_alloc*,
> + * the user has ownership of the link, for example to maintain within
> + * a list, if so desired. As soon as the block is freed with
> + * drm_buddy_free* ownership is given back to the mm.
> + */
> + struct list_head link;
> + struct list_head tmp_link;
> +};
> +
> +/* Order-zero must be at least PAGE_SIZE */
> +#define DRM_BUDDY_MAX_ORDER (63 - PAGE_SHIFT)
> +
> +/*
> + * Binary Buddy System.
> + *
> + * Locking should be handled by the user, a simple mutex around
> + * drm_buddy_alloc* and drm_buddy_free* should suffice.
> + */
> +struct drm_buddy_mm {
> + /* Maintain a free list for each order. */
> + struct list_head *free_list;
> +
> + /*
> + * Maintain explicit binary tree(s) to track the allocation of the
> + * address space. This gives us a simple way of finding a buddy block
> + * and performing the potentially recursive merge step when freeing a
> + * block. Nodes are either allocated or free, in which case they will
> + * also exist on the respective free list.
> + */
> + struct drm_buddy_block **roots;
> +
> + /*
> + * Anything from here is public, and remains static for the lifetime of
> + * the mm. Everything above is considered do-not-touch.
> + */
> + unsigned int n_roots;
> + unsigned int max_order;
> +
> + /* Must be at least PAGE_SIZE */
> + u64 chunk_size;
> + u64 size;
> + u64 avail;
> +};
> +
> +static inline u64
> +drm_buddy_block_offset(struct drm_buddy_block *block)
> +{
> + return block->header & DRM_BUDDY_HEADER_OFFSET;
> +}
> +
> +static inline unsigned int
> +drm_buddy_block_order(struct drm_buddy_block *block)
> +{
> + return block->header & DRM_BUDDY_HEADER_ORDER;
> +}
> +
> +static inline unsigned int
> +drm_buddy_block_state(struct drm_buddy_block *block)
> +{
> + return block->header & DRM_BUDDY_HEADER_STATE;
> +}
> +
> +static inline bool
> +drm_buddy_block_is_allocated(struct drm_buddy_block *block)
> +{
> + return drm_buddy_block_state(block) == DRM_BUDDY_ALLOCATED;
> +}
> +
> +static inline bool
> +drm_buddy_block_is_free(struct drm_buddy_block *block)
> +{
> + return drm_buddy_block_state(block) == DRM_BUDDY_FREE;
> +}
> +
> +static inline bool
> +drm_buddy_block_is_split(struct drm_buddy_block *block)
> +{
> + return drm_buddy_block_state(block) == DRM_BUDDY_SPLIT;
> +}
> +
> +static inline u64
> +drm_buddy_block_size(struct drm_buddy_mm *mm,
> + struct drm_buddy_block *block)
> +{
> + return mm->chunk_size << drm_buddy_block_order(block);
> +}
> +
> +int drm_buddy_init(struct drm_buddy_mm *mm, u64 size, u64 chunk_size);
> +
> +void drm_buddy_fini(struct drm_buddy_mm *mm);
> +
> +struct drm_buddy_block *
> +drm_buddy_alloc(struct drm_buddy_mm *mm, unsigned int order);
> +
> +int drm_buddy_alloc_range(struct drm_buddy_mm *mm,
> + struct list_head *blocks,
> + u64 start, u64 size);
> +
> +void drm_buddy_free(struct drm_buddy_mm *mm, struct drm_buddy_block *block);
> +
> +void drm_buddy_free_list(struct drm_buddy_mm *mm, struct list_head *objects);
> +
> +void drm_buddy_print(struct drm_buddy_mm *mm, struct drm_printer *p);
> +void drm_buddy_block_print(struct drm_buddy_mm *mm,
> + struct drm_buddy_block *block,
> + struct drm_printer *p);
> +
> +void drm_buddy_module_exit(void);
> +int drm_buddy_module_init(void);
> +
> +#endif
^ permalink raw reply [flat|nested] 46+ messages in thread
* Re: [PATCH v3 1/6] drm: move the buddy allocator from i915 into common drm
@ 2021-11-17 8:03 ` Christian König
0 siblings, 0 replies; 46+ messages in thread
From: Christian König @ 2021-11-17 8:03 UTC (permalink / raw)
To: Arunpravin, dri-devel, intel-gfx, amd-gfx
Cc: daniel, jani.nikula, matthew.auld, tzimmermann,
alexander.deucher, christian.koenig
I've looked a bit more into this and I think we should just follow
Thomas Zimmermann's idea to make this a separate module.
Otherwise we just have the code around all the time even if it is unused
and implementing this should be trivial.
See how DRM_GEM_CMA_HELPER or DRM_VRAM_HELPER are done in
drivers/gpu/drm/Kconfig and then have the desired effect in
drivers/gpu/drm/Makefile
Should be something like ~15 lines of additional configuration which
saves a bit of memory on embedded systems which just need a fbdev
replacement.
Thanks,
Christian.
Am 16.11.21 um 21:18 schrieb Arunpravin:
> Move the base i915 buddy allocator code into drm
> - Move i915_buddy.h to include/drm
> - Move i915_buddy.c to drm root folder
> - Rename "i915" string with "drm" string wherever applicable
> - Rename "I915" string with "DRM" string wherever applicable
> - Fix header file dependencies
> - Fix alignment issues
> - add Makefile support for drm buddy
> - export functions and write kerneldoc description
> - Remove i915 selftest config check condition as buddy selftest
> will be moved to drm selftest folder
>
> cleanup i915 buddy references in i915 driver module
> and replace with drm buddy
>
> v2:
> - include header file in alphabetical order (Thomas)
> - merged changes listed in the body section into a single patch
> to keep the build intact (Christian, Jani)
>
> Signed-off-by: Arunpravin <Arunpravin.PaneerSelvam@amd.com>
> ---
> drivers/gpu/drm/Makefile | 2 +-
> drivers/gpu/drm/drm_buddy.c | 521 ++++++++++++++++++
> drivers/gpu/drm/drm_drv.c | 3 +
> drivers/gpu/drm/i915/Makefile | 1 -
> drivers/gpu/drm/i915/i915_buddy.c | 466 ----------------
> drivers/gpu/drm/i915/i915_buddy.h | 143 -----
> drivers/gpu/drm/i915/i915_module.c | 3 -
> drivers/gpu/drm/i915/i915_scatterlist.c | 11 +-
> drivers/gpu/drm/i915/i915_ttm_buddy_manager.c | 33 +-
> drivers/gpu/drm/i915/i915_ttm_buddy_manager.h | 4 +-
> include/drm/drm_buddy.h | 153 +++++
> 11 files changed, 702 insertions(+), 638 deletions(-)
> create mode 100644 drivers/gpu/drm/drm_buddy.c
> delete mode 100644 drivers/gpu/drm/i915/i915_buddy.c
> delete mode 100644 drivers/gpu/drm/i915/i915_buddy.h
> create mode 100644 include/drm/drm_buddy.h
>
> diff --git a/drivers/gpu/drm/Makefile b/drivers/gpu/drm/Makefile
> index 0dff40bb863c..dc61e91a3154 100644
> --- a/drivers/gpu/drm/Makefile
> +++ b/drivers/gpu/drm/Makefile
> @@ -18,7 +18,7 @@ drm-y := drm_aperture.o drm_auth.o drm_cache.o \
> drm_dumb_buffers.o drm_mode_config.o drm_vblank.o \
> drm_syncobj.o drm_lease.o drm_writeback.o drm_client.o \
> drm_client_modeset.o drm_atomic_uapi.o drm_hdcp.o \
> - drm_managed.o drm_vblank_work.o
> + drm_managed.o drm_vblank_work.o drm_buddy.o
>
> drm-$(CONFIG_DRM_LEGACY) += drm_agpsupport.o drm_bufs.o drm_context.o drm_dma.o \
> drm_legacy_misc.o drm_lock.o drm_memory.o drm_scatter.o \
> diff --git a/drivers/gpu/drm/drm_buddy.c b/drivers/gpu/drm/drm_buddy.c
> new file mode 100644
> index 000000000000..39eb1d224bec
> --- /dev/null
> +++ b/drivers/gpu/drm/drm_buddy.c
> @@ -0,0 +1,521 @@
> +// SPDX-License-Identifier: MIT
> +/*
> + * Copyright © 2021 Intel Corporation
> + */
> +
> +#include <linux/kmemleak.h>
> +#include <linux/sizes.h>
> +
> +#include <drm/drm_buddy.h>
> +
> +static struct kmem_cache *slab_blocks;
> +
> +static struct drm_buddy_block *drm_block_alloc(struct drm_buddy_mm *mm,
> + struct drm_buddy_block *parent,
> + unsigned int order,
> + u64 offset)
> +{
> + struct drm_buddy_block *block;
> +
> + BUG_ON(order > DRM_BUDDY_MAX_ORDER);
> +
> + block = kmem_cache_zalloc(slab_blocks, GFP_KERNEL);
> + if (!block)
> + return NULL;
> +
> + block->header = offset;
> + block->header |= order;
> + block->parent = parent;
> +
> + BUG_ON(block->header & DRM_BUDDY_HEADER_UNUSED);
> + return block;
> +}
> +
> +static void drm_block_free(struct drm_buddy_mm *mm,
> + struct drm_buddy_block *block)
> +{
> + kmem_cache_free(slab_blocks, block);
> +}
> +
> +static void mark_allocated(struct drm_buddy_block *block)
> +{
> + block->header &= ~DRM_BUDDY_HEADER_STATE;
> + block->header |= DRM_BUDDY_ALLOCATED;
> +
> + list_del(&block->link);
> +}
> +
> +static void mark_free(struct drm_buddy_mm *mm,
> + struct drm_buddy_block *block)
> +{
> + block->header &= ~DRM_BUDDY_HEADER_STATE;
> + block->header |= DRM_BUDDY_FREE;
> +
> + list_add(&block->link,
> + &mm->free_list[drm_buddy_block_order(block)]);
> +}
> +
> +static void mark_split(struct drm_buddy_block *block)
> +{
> + block->header &= ~DRM_BUDDY_HEADER_STATE;
> + block->header |= DRM_BUDDY_SPLIT;
> +
> + list_del(&block->link);
> +}
> +
> +/**
> + * drm_buddy_init - init memory manager
> + *
> + * @mm: DRM buddy manager to initialize
> + * @size: size in bytes to manage
> + * @chunk_size: minimum page size in bytes for our allocations
> + *
> + * Initializes the memory manager and its resources.
> + *
> + * Returns:
> + * 0 on success, error code on failure.
> + */
> +int drm_buddy_init(struct drm_buddy_mm *mm, u64 size, u64 chunk_size)
> +{
> + unsigned int i;
> + u64 offset;
> +
> + if (size < chunk_size)
> + return -EINVAL;
> +
> + if (chunk_size < PAGE_SIZE)
> + return -EINVAL;
> +
> + if (!is_power_of_2(chunk_size))
> + return -EINVAL;
> +
> + size = round_down(size, chunk_size);
> +
> + mm->size = size;
> + mm->avail = size;
> + mm->chunk_size = chunk_size;
> + mm->max_order = ilog2(size) - ilog2(chunk_size);
> +
> + BUG_ON(mm->max_order > DRM_BUDDY_MAX_ORDER);
> +
> + mm->free_list = kmalloc_array(mm->max_order + 1,
> + sizeof(struct list_head),
> + GFP_KERNEL);
> + if (!mm->free_list)
> + return -ENOMEM;
> +
> + for (i = 0; i <= mm->max_order; ++i)
> + INIT_LIST_HEAD(&mm->free_list[i]);
> +
> + mm->n_roots = hweight64(size);
> +
> + mm->roots = kmalloc_array(mm->n_roots,
> + sizeof(struct drm_buddy_block *),
> + GFP_KERNEL);
> + if (!mm->roots)
> + goto out_free_list;
> +
> + offset = 0;
> + i = 0;
> +
> + /*
> + * Split into power-of-two blocks, in case we are given a size that is
> + * not itself a power-of-two.
> + */
> + do {
> + struct drm_buddy_block *root;
> + unsigned int order;
> + u64 root_size;
> +
> + root_size = rounddown_pow_of_two(size);
> + order = ilog2(root_size) - ilog2(chunk_size);
> +
> + root = drm_block_alloc(mm, NULL, order, offset);
> + if (!root)
> + goto out_free_roots;
> +
> + mark_free(mm, root);
> +
> + BUG_ON(i > mm->max_order);
> + BUG_ON(drm_buddy_block_size(mm, root) < chunk_size);
> +
> + mm->roots[i] = root;
> +
> + offset += root_size;
> + size -= root_size;
> + i++;
> + } while (size);
> +
> + return 0;
> +
> +out_free_roots:
> + while (i--)
> + drm_block_free(mm, mm->roots[i]);
> + kfree(mm->roots);
> +out_free_list:
> + kfree(mm->free_list);
> + return -ENOMEM;
> +}
> +EXPORT_SYMBOL(drm_buddy_init);
> +
> +/**
> + * drm_buddy_fini - tear down the memory manager
> + *
> + * @mm: DRM buddy manager to free
> + *
> + * Cleanup memory manager resources and the freelist
> + */
> +void drm_buddy_fini(struct drm_buddy_mm *mm)
> +{
> + int i;
> +
> + for (i = 0; i < mm->n_roots; ++i) {
> + WARN_ON(!drm_buddy_block_is_free(mm->roots[i]));
> + drm_block_free(mm, mm->roots[i]);
> + }
> +
> + WARN_ON(mm->avail != mm->size);
> +
> + kfree(mm->roots);
> + kfree(mm->free_list);
> +}
> +EXPORT_SYMBOL(drm_buddy_fini);
> +
> +static int split_block(struct drm_buddy_mm *mm,
> + struct drm_buddy_block *block)
> +{
> + unsigned int block_order = drm_buddy_block_order(block) - 1;
> + u64 offset = drm_buddy_block_offset(block);
> +
> + BUG_ON(!drm_buddy_block_is_free(block));
> + BUG_ON(!drm_buddy_block_order(block));
> +
> + block->left = drm_block_alloc(mm, block, block_order, offset);
> + if (!block->left)
> + return -ENOMEM;
> +
> + block->right = drm_block_alloc(mm, block, block_order,
> + offset + (mm->chunk_size << block_order));
> + if (!block->right) {
> + drm_block_free(mm, block->left);
> + return -ENOMEM;
> + }
> +
> + mark_free(mm, block->left);
> + mark_free(mm, block->right);
> +
> + mark_split(block);
> +
> + return 0;
> +}
> +
> +static struct drm_buddy_block *
> +get_buddy(struct drm_buddy_block *block)
> +{
> + struct drm_buddy_block *parent;
> +
> + parent = block->parent;
> + if (!parent)
> + return NULL;
> +
> + if (parent->left == block)
> + return parent->right;
> +
> + return parent->left;
> +}
> +
> +static void __drm_buddy_free(struct drm_buddy_mm *mm,
> + struct drm_buddy_block *block)
> +{
> + struct drm_buddy_block *parent;
> +
> + while ((parent = block->parent)) {
> + struct drm_buddy_block *buddy;
> +
> + buddy = get_buddy(block);
> +
> + if (!drm_buddy_block_is_free(buddy))
> + break;
> +
> + list_del(&buddy->link);
> +
> + drm_block_free(mm, block);
> + drm_block_free(mm, buddy);
> +
> + block = parent;
> + }
> +
> + mark_free(mm, block);
> +}
> +
> +void drm_buddy_free(struct drm_buddy_mm *mm,
> + struct drm_buddy_block *block)
> +{
> + BUG_ON(!drm_buddy_block_is_allocated(block));
> + mm->avail += drm_buddy_block_size(mm, block);
> + __drm_buddy_free(mm, block);
> +}
> +
> +/**
> + * drm_buddy_free_list - free blocks
> + *
> + * @mm: DRM buddy manager
> + * @objects: input list head to free blocks
> + */
> +void drm_buddy_free_list(struct drm_buddy_mm *mm, struct list_head *objects)
> +{
> + struct drm_buddy_block *block, *on;
> +
> + list_for_each_entry_safe(block, on, objects, link) {
> + drm_buddy_free(mm, block);
> + cond_resched();
> + }
> + INIT_LIST_HEAD(objects);
> +}
> +EXPORT_SYMBOL(drm_buddy_free_list);
> +
> +/**
> + * drm_buddy_alloc - allocate power-of-two blocks
> + *
> + * @mm: DRM buddy manager to allocate from
> + * @order: size of the allocation
> + *
> + * The order value here translates to:
> + *
> + * 0 = 2^0 * mm->chunk_size
> + * 1 = 2^1 * mm->chunk_size
> + * 2 = 2^2 * mm->chunk_size
> + *
> + * Returns:
> + * allocated ptr to the &drm_buddy_block on success
> + */
> +struct drm_buddy_block *
> +drm_buddy_alloc(struct drm_buddy_mm *mm, unsigned int order)
> +{
> + struct drm_buddy_block *block = NULL;
> + unsigned int i;
> + int err;
> +
> + for (i = order; i <= mm->max_order; ++i) {
> + block = list_first_entry_or_null(&mm->free_list[i],
> + struct drm_buddy_block,
> + link);
> + if (block)
> + break;
> + }
> +
> + if (!block)
> + return ERR_PTR(-ENOSPC);
> +
> + BUG_ON(!drm_buddy_block_is_free(block));
> +
> + while (i != order) {
> + err = split_block(mm, block);
> + if (unlikely(err))
> + goto out_free;
> +
> + /* Go low */
> + block = block->left;
> + i--;
> + }
> +
> + mark_allocated(block);
> + mm->avail -= drm_buddy_block_size(mm, block);
> + kmemleak_update_trace(block);
> + return block;
> +
> +out_free:
> + if (i != order)
> + __drm_buddy_free(mm, block);
> + return ERR_PTR(err);
> +}
> +EXPORT_SYMBOL(drm_buddy_alloc);
> +
> +static inline bool overlaps(u64 s1, u64 e1, u64 s2, u64 e2)
> +{
> + return s1 <= e2 && e1 >= s2;
> +}
> +
> +static inline bool contains(u64 s1, u64 e1, u64 s2, u64 e2)
> +{
> + return s1 <= s2 && e1 >= e2;
> +}
> +
> +/**
> + * drm_buddy_alloc_range - allocate range
> + *
> + * @mm: DRM buddy manager to allocate from
> + * @blocks: output list head to add allocated blocks
> + * @start: start of the allowed range for this block
> + * @size: size of the allocation
> + *
> + * Intended for pre-allocating portions of the address space, for example to
> + * reserve a block for the initial framebuffer or similar, hence the expectation
> + * here is that drm_buddy_alloc() is still the main vehicle for
> + * allocations, so if that's not the case then the drm_mm range allocator is
> + * probably a much better fit, and so you should probably go use that instead.
> + *
> + * Note that it's safe to chain together multiple alloc_ranges
> + * with the same blocks list
> + *
> + * Returns:
> + * 0 on success, error code on failure.
> + */
> +int drm_buddy_alloc_range(struct drm_buddy_mm *mm,
> + struct list_head *blocks,
> + u64 start, u64 size)
> +{
> + struct drm_buddy_block *block;
> + struct drm_buddy_block *buddy;
> + LIST_HEAD(allocated);
> + LIST_HEAD(dfs);
> + u64 end;
> + int err;
> + int i;
> +
> + if (size < mm->chunk_size)
> + return -EINVAL;
> +
> + if (!IS_ALIGNED(size | start, mm->chunk_size))
> + return -EINVAL;
> +
> + if (range_overflows(start, size, mm->size))
> + return -EINVAL;
> +
> + for (i = 0; i < mm->n_roots; ++i)
> + list_add_tail(&mm->roots[i]->tmp_link, &dfs);
> +
> + end = start + size - 1;
> +
> + do {
> + u64 block_start;
> + u64 block_end;
> +
> + block = list_first_entry_or_null(&dfs,
> + struct drm_buddy_block,
> + tmp_link);
> + if (!block)
> + break;
> +
> + list_del(&block->tmp_link);
> +
> + block_start = drm_buddy_block_offset(block);
> + block_end = block_start + drm_buddy_block_size(mm, block) - 1;
> +
> + if (!overlaps(start, end, block_start, block_end))
> + continue;
> +
> + if (drm_buddy_block_is_allocated(block)) {
> + err = -ENOSPC;
> + goto err_free;
> + }
> +
> + if (contains(start, end, block_start, block_end)) {
> + if (!drm_buddy_block_is_free(block)) {
> + err = -ENOSPC;
> + goto err_free;
> + }
> +
> + mark_allocated(block);
> + mm->avail -= drm_buddy_block_size(mm, block);
> + list_add_tail(&block->link, &allocated);
> + continue;
> + }
> +
> + if (!drm_buddy_block_is_split(block)) {
> + err = split_block(mm, block);
> + if (unlikely(err))
> + goto err_undo;
> + }
> +
> + list_add(&block->right->tmp_link, &dfs);
> + list_add(&block->left->tmp_link, &dfs);
> + } while (1);
> +
> + list_splice_tail(&allocated, blocks);
> + return 0;
> +
> +err_undo:
> + /*
> + * We really don't want to leave around a bunch of split blocks, since
> + * bigger is better, so make sure we merge everything back before we
> + * free the allocated blocks.
> + */
> + buddy = get_buddy(block);
> + if (buddy &&
> + (drm_buddy_block_is_free(block) &&
> + drm_buddy_block_is_free(buddy)))
> + __drm_buddy_free(mm, block);
> +
> +err_free:
> + drm_buddy_free_list(mm, &allocated);
> + return err;
> +}
> +EXPORT_SYMBOL(drm_buddy_alloc_range);
> +
> +/**
> + * drm_buddy_block_print - print block information
> + *
> + * @mm: DRM buddy manager
> + * @block: DRM buddy block
> + * @p: DRM printer to use
> + */
> +void drm_buddy_block_print(struct drm_buddy_mm *mm,
> + struct drm_buddy_block *block,
> + struct drm_printer *p)
> +{
> + u64 start = drm_buddy_block_offset(block);
> + u64 size = drm_buddy_block_size(mm, block);
> +
> + drm_printf(p, "%#018llx-%#018llx: %llu\n", start, start + size, size);
> +}
> +EXPORT_SYMBOL(drm_buddy_block_print);
> +
> +/**
> + * drm_buddy_print - print allocator state
> + *
> + * @mm: DRM buddy manager
> + * @p: DRM printer to use
> + */
> +void drm_buddy_print(struct drm_buddy_mm *mm, struct drm_printer *p)
> +{
> + int order;
> +
> + drm_printf(p, "chunk_size: %lluKiB, total: %lluMiB, free: %lluMiB\n",
> + mm->chunk_size >> 10, mm->size >> 20, mm->avail >> 20);
> +
> + for (order = mm->max_order; order >= 0; order--) {
> + struct drm_buddy_block *block;
> + u64 count = 0, free;
> +
> + list_for_each_entry(block, &mm->free_list[order], link) {
> + BUG_ON(!drm_buddy_block_is_free(block));
> + count++;
> + }
> +
> + drm_printf(p, "order-%d ", order);
> +
> + free = count * (mm->chunk_size << order);
> + if (free < SZ_1M)
> + drm_printf(p, "free: %lluKiB", free >> 10);
> + else
> + drm_printf(p, "free: %lluMiB", free >> 20);
> +
> + drm_printf(p, ", pages: %llu\n", count);
> + }
> +}
> +EXPORT_SYMBOL(drm_buddy_print);
> +
> +void drm_buddy_module_exit(void)
> +{
> + kmem_cache_destroy(slab_blocks);
> +}
> +
> +int __init drm_buddy_module_init(void)
> +{
> + slab_blocks = KMEM_CACHE(drm_buddy_block, 0);
> + if (!slab_blocks)
> + return -ENOMEM;
> +
> + return 0;
> +}
> diff --git a/drivers/gpu/drm/drm_drv.c b/drivers/gpu/drm/drm_drv.c
> index 7a5097467ba5..5d5e46e60586 100644
> --- a/drivers/gpu/drm/drm_drv.c
> +++ b/drivers/gpu/drm/drm_drv.c
> @@ -35,6 +35,7 @@
> #include <linux/slab.h>
> #include <linux/srcu.h>
>
> +#include <drm/drm_buddy.h>
> #include <drm/drm_cache.h>
> #include <drm/drm_client.h>
> #include <drm/drm_color_mgmt.h>
> @@ -1034,6 +1035,7 @@ static void drm_core_exit(void)
> drm_sysfs_destroy();
> idr_destroy(&drm_minors_idr);
> drm_connector_ida_destroy();
> + drm_buddy_module_exit();
> }
>
> static int __init drm_core_init(void)
> @@ -1043,6 +1045,7 @@ static int __init drm_core_init(void)
> drm_connector_ida_init();
> idr_init(&drm_minors_idr);
> drm_memcpy_init_early();
> + drm_buddy_module_init();
>
> ret = drm_sysfs_init();
> if (ret < 0) {
> diff --git a/drivers/gpu/drm/i915/Makefile b/drivers/gpu/drm/i915/Makefile
> index 467872cca027..fc5ca8c4ccb2 100644
> --- a/drivers/gpu/drm/i915/Makefile
> +++ b/drivers/gpu/drm/i915/Makefile
> @@ -161,7 +161,6 @@ gem-y += \
> i915-y += \
> $(gem-y) \
> i915_active.o \
> - i915_buddy.o \
> i915_cmd_parser.o \
> i915_gem_evict.o \
> i915_gem_gtt.o \
> diff --git a/drivers/gpu/drm/i915/i915_buddy.c b/drivers/gpu/drm/i915/i915_buddy.c
> deleted file mode 100644
> index 6e2ad68f8f3f..000000000000
> --- a/drivers/gpu/drm/i915/i915_buddy.c
> +++ /dev/null
> @@ -1,466 +0,0 @@
> -// SPDX-License-Identifier: MIT
> -/*
> - * Copyright © 2021 Intel Corporation
> - */
> -
> -#include <linux/kmemleak.h>
> -#include <linux/sizes.h>
> -
> -#include "i915_buddy.h"
> -
> -#include "i915_gem.h"
> -#include "i915_utils.h"
> -
> -static struct kmem_cache *slab_blocks;
> -
> -static struct i915_buddy_block *i915_block_alloc(struct i915_buddy_mm *mm,
> - struct i915_buddy_block *parent,
> - unsigned int order,
> - u64 offset)
> -{
> - struct i915_buddy_block *block;
> -
> - GEM_BUG_ON(order > I915_BUDDY_MAX_ORDER);
> -
> - block = kmem_cache_zalloc(slab_blocks, GFP_KERNEL);
> - if (!block)
> - return NULL;
> -
> - block->header = offset;
> - block->header |= order;
> - block->parent = parent;
> -
> - GEM_BUG_ON(block->header & I915_BUDDY_HEADER_UNUSED);
> - return block;
> -}
> -
> -static void i915_block_free(struct i915_buddy_mm *mm,
> - struct i915_buddy_block *block)
> -{
> - kmem_cache_free(slab_blocks, block);
> -}
> -
> -static void mark_allocated(struct i915_buddy_block *block)
> -{
> - block->header &= ~I915_BUDDY_HEADER_STATE;
> - block->header |= I915_BUDDY_ALLOCATED;
> -
> - list_del(&block->link);
> -}
> -
> -static void mark_free(struct i915_buddy_mm *mm,
> - struct i915_buddy_block *block)
> -{
> - block->header &= ~I915_BUDDY_HEADER_STATE;
> - block->header |= I915_BUDDY_FREE;
> -
> - list_add(&block->link,
> - &mm->free_list[i915_buddy_block_order(block)]);
> -}
> -
> -static void mark_split(struct i915_buddy_block *block)
> -{
> - block->header &= ~I915_BUDDY_HEADER_STATE;
> - block->header |= I915_BUDDY_SPLIT;
> -
> - list_del(&block->link);
> -}
> -
> -int i915_buddy_init(struct i915_buddy_mm *mm, u64 size, u64 chunk_size)
> -{
> - unsigned int i;
> - u64 offset;
> -
> - if (size < chunk_size)
> - return -EINVAL;
> -
> - if (chunk_size < PAGE_SIZE)
> - return -EINVAL;
> -
> - if (!is_power_of_2(chunk_size))
> - return -EINVAL;
> -
> - size = round_down(size, chunk_size);
> -
> - mm->size = size;
> - mm->avail = size;
> - mm->chunk_size = chunk_size;
> - mm->max_order = ilog2(size) - ilog2(chunk_size);
> -
> - GEM_BUG_ON(mm->max_order > I915_BUDDY_MAX_ORDER);
> -
> - mm->free_list = kmalloc_array(mm->max_order + 1,
> - sizeof(struct list_head),
> - GFP_KERNEL);
> - if (!mm->free_list)
> - return -ENOMEM;
> -
> - for (i = 0; i <= mm->max_order; ++i)
> - INIT_LIST_HEAD(&mm->free_list[i]);
> -
> - mm->n_roots = hweight64(size);
> -
> - mm->roots = kmalloc_array(mm->n_roots,
> - sizeof(struct i915_buddy_block *),
> - GFP_KERNEL);
> - if (!mm->roots)
> - goto out_free_list;
> -
> - offset = 0;
> - i = 0;
> -
> - /*
> - * Split into power-of-two blocks, in case we are given a size that is
> - * not itself a power-of-two.
> - */
> - do {
> - struct i915_buddy_block *root;
> - unsigned int order;
> - u64 root_size;
> -
> - root_size = rounddown_pow_of_two(size);
> - order = ilog2(root_size) - ilog2(chunk_size);
> -
> - root = i915_block_alloc(mm, NULL, order, offset);
> - if (!root)
> - goto out_free_roots;
> -
> - mark_free(mm, root);
> -
> - GEM_BUG_ON(i > mm->max_order);
> - GEM_BUG_ON(i915_buddy_block_size(mm, root) < chunk_size);
> -
> - mm->roots[i] = root;
> -
> - offset += root_size;
> - size -= root_size;
> - i++;
> - } while (size);
> -
> - return 0;
> -
> -out_free_roots:
> - while (i--)
> - i915_block_free(mm, mm->roots[i]);
> - kfree(mm->roots);
> -out_free_list:
> - kfree(mm->free_list);
> - return -ENOMEM;
> -}
> -
> -void i915_buddy_fini(struct i915_buddy_mm *mm)
> -{
> - int i;
> -
> - for (i = 0; i < mm->n_roots; ++i) {
> - GEM_WARN_ON(!i915_buddy_block_is_free(mm->roots[i]));
> - i915_block_free(mm, mm->roots[i]);
> - }
> -
> - GEM_WARN_ON(mm->avail != mm->size);
> -
> - kfree(mm->roots);
> - kfree(mm->free_list);
> -}
> -
> -static int split_block(struct i915_buddy_mm *mm,
> - struct i915_buddy_block *block)
> -{
> - unsigned int block_order = i915_buddy_block_order(block) - 1;
> - u64 offset = i915_buddy_block_offset(block);
> -
> - GEM_BUG_ON(!i915_buddy_block_is_free(block));
> - GEM_BUG_ON(!i915_buddy_block_order(block));
> -
> - block->left = i915_block_alloc(mm, block, block_order, offset);
> - if (!block->left)
> - return -ENOMEM;
> -
> - block->right = i915_block_alloc(mm, block, block_order,
> - offset + (mm->chunk_size << block_order));
> - if (!block->right) {
> - i915_block_free(mm, block->left);
> - return -ENOMEM;
> - }
> -
> - mark_free(mm, block->left);
> - mark_free(mm, block->right);
> -
> - mark_split(block);
> -
> - return 0;
> -}
> -
> -static struct i915_buddy_block *
> -get_buddy(struct i915_buddy_block *block)
> -{
> - struct i915_buddy_block *parent;
> -
> - parent = block->parent;
> - if (!parent)
> - return NULL;
> -
> - if (parent->left == block)
> - return parent->right;
> -
> - return parent->left;
> -}
> -
> -static void __i915_buddy_free(struct i915_buddy_mm *mm,
> - struct i915_buddy_block *block)
> -{
> - struct i915_buddy_block *parent;
> -
> - while ((parent = block->parent)) {
> - struct i915_buddy_block *buddy;
> -
> - buddy = get_buddy(block);
> -
> - if (!i915_buddy_block_is_free(buddy))
> - break;
> -
> - list_del(&buddy->link);
> -
> - i915_block_free(mm, block);
> - i915_block_free(mm, buddy);
> -
> - block = parent;
> - }
> -
> - mark_free(mm, block);
> -}
> -
> -void i915_buddy_free(struct i915_buddy_mm *mm,
> - struct i915_buddy_block *block)
> -{
> - GEM_BUG_ON(!i915_buddy_block_is_allocated(block));
> - mm->avail += i915_buddy_block_size(mm, block);
> - __i915_buddy_free(mm, block);
> -}
> -
> -void i915_buddy_free_list(struct i915_buddy_mm *mm, struct list_head *objects)
> -{
> - struct i915_buddy_block *block, *on;
> -
> - list_for_each_entry_safe(block, on, objects, link) {
> - i915_buddy_free(mm, block);
> - cond_resched();
> - }
> - INIT_LIST_HEAD(objects);
> -}
> -
> -/*
> - * Allocate power-of-two block. The order value here translates to:
> - *
> - * 0 = 2^0 * mm->chunk_size
> - * 1 = 2^1 * mm->chunk_size
> - * 2 = 2^2 * mm->chunk_size
> - * ...
> - */
> -struct i915_buddy_block *
> -i915_buddy_alloc(struct i915_buddy_mm *mm, unsigned int order)
> -{
> - struct i915_buddy_block *block = NULL;
> - unsigned int i;
> - int err;
> -
> - for (i = order; i <= mm->max_order; ++i) {
> - block = list_first_entry_or_null(&mm->free_list[i],
> - struct i915_buddy_block,
> - link);
> - if (block)
> - break;
> - }
> -
> - if (!block)
> - return ERR_PTR(-ENOSPC);
> -
> - GEM_BUG_ON(!i915_buddy_block_is_free(block));
> -
> - while (i != order) {
> - err = split_block(mm, block);
> - if (unlikely(err))
> - goto out_free;
> -
> - /* Go low */
> - block = block->left;
> - i--;
> - }
> -
> - mark_allocated(block);
> - mm->avail -= i915_buddy_block_size(mm, block);
> - kmemleak_update_trace(block);
> - return block;
> -
> -out_free:
> - if (i != order)
> - __i915_buddy_free(mm, block);
> - return ERR_PTR(err);
> -}
> -
> -static inline bool overlaps(u64 s1, u64 e1, u64 s2, u64 e2)
> -{
> - return s1 <= e2 && e1 >= s2;
> -}
> -
> -static inline bool contains(u64 s1, u64 e1, u64 s2, u64 e2)
> -{
> - return s1 <= s2 && e1 >= e2;
> -}
> -
> -/*
> - * Allocate range. Note that it's safe to chain together multiple alloc_ranges
> - * with the same blocks list.
> - *
> - * Intended for pre-allocating portions of the address space, for example to
> - * reserve a block for the initial framebuffer or similar, hence the expectation
> - * here is that i915_buddy_alloc() is still the main vehicle for
> - * allocations, so if that's not the case then the drm_mm range allocator is
> - * probably a much better fit, and so you should probably go use that instead.
> - */
> -int i915_buddy_alloc_range(struct i915_buddy_mm *mm,
> - struct list_head *blocks,
> - u64 start, u64 size)
> -{
> - struct i915_buddy_block *block;
> - struct i915_buddy_block *buddy;
> - LIST_HEAD(allocated);
> - LIST_HEAD(dfs);
> - u64 end;
> - int err;
> - int i;
> -
> - if (size < mm->chunk_size)
> - return -EINVAL;
> -
> - if (!IS_ALIGNED(size | start, mm->chunk_size))
> - return -EINVAL;
> -
> - if (range_overflows(start, size, mm->size))
> - return -EINVAL;
> -
> - for (i = 0; i < mm->n_roots; ++i)
> - list_add_tail(&mm->roots[i]->tmp_link, &dfs);
> -
> - end = start + size - 1;
> -
> - do {
> - u64 block_start;
> - u64 block_end;
> -
> - block = list_first_entry_or_null(&dfs,
> - struct i915_buddy_block,
> - tmp_link);
> - if (!block)
> - break;
> -
> - list_del(&block->tmp_link);
> -
> - block_start = i915_buddy_block_offset(block);
> - block_end = block_start + i915_buddy_block_size(mm, block) - 1;
> -
> - if (!overlaps(start, end, block_start, block_end))
> - continue;
> -
> - if (i915_buddy_block_is_allocated(block)) {
> - err = -ENOSPC;
> - goto err_free;
> - }
> -
> - if (contains(start, end, block_start, block_end)) {
> - if (!i915_buddy_block_is_free(block)) {
> - err = -ENOSPC;
> - goto err_free;
> - }
> -
> - mark_allocated(block);
> - mm->avail -= i915_buddy_block_size(mm, block);
> - list_add_tail(&block->link, &allocated);
> - continue;
> - }
> -
> - if (!i915_buddy_block_is_split(block)) {
> - err = split_block(mm, block);
> - if (unlikely(err))
> - goto err_undo;
> - }
> -
> - list_add(&block->right->tmp_link, &dfs);
> - list_add(&block->left->tmp_link, &dfs);
> - } while (1);
> -
> - list_splice_tail(&allocated, blocks);
> - return 0;
> -
> -err_undo:
> - /*
> - * We really don't want to leave around a bunch of split blocks, since
> - * bigger is better, so make sure we merge everything back before we
> - * free the allocated blocks.
> - */
> - buddy = get_buddy(block);
> - if (buddy &&
> - (i915_buddy_block_is_free(block) &&
> - i915_buddy_block_is_free(buddy)))
> - __i915_buddy_free(mm, block);
> -
> -err_free:
> - i915_buddy_free_list(mm, &allocated);
> - return err;
> -}
> -
> -void i915_buddy_block_print(struct i915_buddy_mm *mm,
> - struct i915_buddy_block *block,
> - struct drm_printer *p)
> -{
> - u64 start = i915_buddy_block_offset(block);
> - u64 size = i915_buddy_block_size(mm, block);
> -
> - drm_printf(p, "%#018llx-%#018llx: %llu\n", start, start + size, size);
> -}
> -
> -void i915_buddy_print(struct i915_buddy_mm *mm, struct drm_printer *p)
> -{
> - int order;
> -
> - drm_printf(p, "chunk_size: %lluKiB, total: %lluMiB, free: %lluMiB\n",
> - mm->chunk_size >> 10, mm->size >> 20, mm->avail >> 20);
> -
> - for (order = mm->max_order; order >= 0; order--) {
> - struct i915_buddy_block *block;
> - u64 count = 0, free;
> -
> - list_for_each_entry(block, &mm->free_list[order], link) {
> - GEM_BUG_ON(!i915_buddy_block_is_free(block));
> - count++;
> - }
> -
> - drm_printf(p, "order-%d ", order);
> -
> - free = count * (mm->chunk_size << order);
> - if (free < SZ_1M)
> - drm_printf(p, "free: %lluKiB", free >> 10);
> - else
> - drm_printf(p, "free: %lluMiB", free >> 20);
> -
> - drm_printf(p, ", pages: %llu\n", count);
> - }
> -}
> -
> -#if IS_ENABLED(CONFIG_DRM_I915_SELFTEST)
> -#include "selftests/i915_buddy.c"
> -#endif
> -
> -void i915_buddy_module_exit(void)
> -{
> - kmem_cache_destroy(slab_blocks);
> -}
> -
> -int __init i915_buddy_module_init(void)
> -{
> - slab_blocks = KMEM_CACHE(i915_buddy_block, 0);
> - if (!slab_blocks)
> - return -ENOMEM;
> -
> - return 0;
> -}
> diff --git a/drivers/gpu/drm/i915/i915_buddy.h b/drivers/gpu/drm/i915/i915_buddy.h
> deleted file mode 100644
> index 7077742112ac..000000000000
> --- a/drivers/gpu/drm/i915/i915_buddy.h
> +++ /dev/null
> @@ -1,143 +0,0 @@
> -/* SPDX-License-Identifier: MIT */
> -/*
> - * Copyright © 2021 Intel Corporation
> - */
> -
> -#ifndef __I915_BUDDY_H__
> -#define __I915_BUDDY_H__
> -
> -#include <linux/bitops.h>
> -#include <linux/list.h>
> -#include <linux/slab.h>
> -
> -#include <drm/drm_print.h>
> -
> -struct i915_buddy_block {
> -#define I915_BUDDY_HEADER_OFFSET GENMASK_ULL(63, 12)
> -#define I915_BUDDY_HEADER_STATE GENMASK_ULL(11, 10)
> -#define I915_BUDDY_ALLOCATED (1 << 10)
> -#define I915_BUDDY_FREE (2 << 10)
> -#define I915_BUDDY_SPLIT (3 << 10)
> -/* Free to be used, if needed in the future */
> -#define I915_BUDDY_HEADER_UNUSED GENMASK_ULL(9, 6)
> -#define I915_BUDDY_HEADER_ORDER GENMASK_ULL(5, 0)
> - u64 header;
> -
> - struct i915_buddy_block *left;
> - struct i915_buddy_block *right;
> - struct i915_buddy_block *parent;
> -
> - void *private; /* owned by creator */
> -
> - /*
> - * While the block is allocated by the user through i915_buddy_alloc*,
> - * the user has ownership of the link, for example to maintain within
> - * a list, if so desired. As soon as the block is freed with
> - * i915_buddy_free* ownership is given back to the mm.
> - */
> - struct list_head link;
> - struct list_head tmp_link;
> -};
> -
> -/* Order-zero must be at least PAGE_SIZE */
> -#define I915_BUDDY_MAX_ORDER (63 - PAGE_SHIFT)
> -
> -/*
> - * Binary Buddy System.
> - *
> - * Locking should be handled by the user, a simple mutex around
> - * i915_buddy_alloc* and i915_buddy_free* should suffice.
> - */
> -struct i915_buddy_mm {
> - /* Maintain a free list for each order. */
> - struct list_head *free_list;
> -
> - /*
> - * Maintain explicit binary tree(s) to track the allocation of the
> - * address space. This gives us a simple way of finding a buddy block
> - * and performing the potentially recursive merge step when freeing a
> - * block. Nodes are either allocated or free, in which case they will
> - * also exist on the respective free list.
> - */
> - struct i915_buddy_block **roots;
> -
> - /*
> - * Anything from here is public, and remains static for the lifetime of
> - * the mm. Everything above is considered do-not-touch.
> - */
> - unsigned int n_roots;
> - unsigned int max_order;
> -
> - /* Must be at least PAGE_SIZE */
> - u64 chunk_size;
> - u64 size;
> - u64 avail;
> -};
> -
> -static inline u64
> -i915_buddy_block_offset(struct i915_buddy_block *block)
> -{
> - return block->header & I915_BUDDY_HEADER_OFFSET;
> -}
> -
> -static inline unsigned int
> -i915_buddy_block_order(struct i915_buddy_block *block)
> -{
> - return block->header & I915_BUDDY_HEADER_ORDER;
> -}
> -
> -static inline unsigned int
> -i915_buddy_block_state(struct i915_buddy_block *block)
> -{
> - return block->header & I915_BUDDY_HEADER_STATE;
> -}
> -
> -static inline bool
> -i915_buddy_block_is_allocated(struct i915_buddy_block *block)
> -{
> - return i915_buddy_block_state(block) == I915_BUDDY_ALLOCATED;
> -}
> -
> -static inline bool
> -i915_buddy_block_is_free(struct i915_buddy_block *block)
> -{
> - return i915_buddy_block_state(block) == I915_BUDDY_FREE;
> -}
> -
> -static inline bool
> -i915_buddy_block_is_split(struct i915_buddy_block *block)
> -{
> - return i915_buddy_block_state(block) == I915_BUDDY_SPLIT;
> -}
> -
> -static inline u64
> -i915_buddy_block_size(struct i915_buddy_mm *mm,
> - struct i915_buddy_block *block)
> -{
> - return mm->chunk_size << i915_buddy_block_order(block);
> -}
> -
> -int i915_buddy_init(struct i915_buddy_mm *mm, u64 size, u64 chunk_size);
> -
> -void i915_buddy_fini(struct i915_buddy_mm *mm);
> -
> -struct i915_buddy_block *
> -i915_buddy_alloc(struct i915_buddy_mm *mm, unsigned int order);
> -
> -int i915_buddy_alloc_range(struct i915_buddy_mm *mm,
> - struct list_head *blocks,
> - u64 start, u64 size);
> -
> -void i915_buddy_free(struct i915_buddy_mm *mm, struct i915_buddy_block *block);
> -
> -void i915_buddy_free_list(struct i915_buddy_mm *mm, struct list_head *objects);
> -
> -void i915_buddy_print(struct i915_buddy_mm *mm, struct drm_printer *p);
> -void i915_buddy_block_print(struct i915_buddy_mm *mm,
> - struct i915_buddy_block *block,
> - struct drm_printer *p);
> -
> -void i915_buddy_module_exit(void);
> -int i915_buddy_module_init(void);
> -
> -#endif
> diff --git a/drivers/gpu/drm/i915/i915_module.c b/drivers/gpu/drm/i915/i915_module.c
> index c7507266aa83..355681dbd7a8 100644
> --- a/drivers/gpu/drm/i915/i915_module.c
> +++ b/drivers/gpu/drm/i915/i915_module.c
> @@ -9,7 +9,6 @@
> #include "gem/i915_gem_context.h"
> #include "gem/i915_gem_object.h"
> #include "i915_active.h"
> -#include "i915_buddy.h"
> #include "i915_params.h"
> #include "i915_pci.h"
> #include "i915_perf.h"
> @@ -50,8 +49,6 @@ static const struct {
> { .init = i915_check_nomodeset },
> { .init = i915_active_module_init,
> .exit = i915_active_module_exit },
> - { .init = i915_buddy_module_init,
> - .exit = i915_buddy_module_exit },
> { .init = i915_context_module_init,
> .exit = i915_context_module_exit },
> { .init = i915_gem_context_module_init,
> diff --git a/drivers/gpu/drm/i915/i915_scatterlist.c b/drivers/gpu/drm/i915/i915_scatterlist.c
> index 4a6712dca838..84d622aa32d2 100644
> --- a/drivers/gpu/drm/i915/i915_scatterlist.c
> +++ b/drivers/gpu/drm/i915/i915_scatterlist.c
> @@ -5,10 +5,9 @@
> */
>
> #include "i915_scatterlist.h"
> -
> -#include "i915_buddy.h"
> #include "i915_ttm_buddy_manager.h"
>
> +#include <drm/drm_buddy.h>
> #include <drm/drm_mm.h>
>
> #include <linux/slab.h>
> @@ -126,9 +125,9 @@ struct sg_table *i915_sg_from_buddy_resource(struct ttm_resource *res,
> struct i915_ttm_buddy_resource *bman_res = to_ttm_buddy_resource(res);
> const u64 size = res->num_pages << PAGE_SHIFT;
> const u64 max_segment = rounddown(UINT_MAX, PAGE_SIZE);
> - struct i915_buddy_mm *mm = bman_res->mm;
> + struct drm_buddy_mm *mm = bman_res->mm;
> struct list_head *blocks = &bman_res->blocks;
> - struct i915_buddy_block *block;
> + struct drm_buddy_block *block;
> struct scatterlist *sg;
> struct sg_table *st;
> resource_size_t prev_end;
> @@ -151,8 +150,8 @@ struct sg_table *i915_sg_from_buddy_resource(struct ttm_resource *res,
> list_for_each_entry(block, blocks, link) {
> u64 block_size, offset;
>
> - block_size = min_t(u64, size, i915_buddy_block_size(mm, block));
> - offset = i915_buddy_block_offset(block);
> + block_size = min_t(u64, size, drm_buddy_block_size(mm, block));
> + offset = drm_buddy_block_offset(block);
>
> while (block_size) {
> u64 len;
> diff --git a/drivers/gpu/drm/i915/i915_ttm_buddy_manager.c b/drivers/gpu/drm/i915/i915_ttm_buddy_manager.c
> index d59fbb019032..c4b70cb8c248 100644
> --- a/drivers/gpu/drm/i915/i915_ttm_buddy_manager.c
> +++ b/drivers/gpu/drm/i915/i915_ttm_buddy_manager.c
> @@ -8,14 +8,15 @@
> #include <drm/ttm/ttm_bo_driver.h>
> #include <drm/ttm/ttm_placement.h>
>
> +#include <drm/drm_buddy.h>
> +
> #include "i915_ttm_buddy_manager.h"
>
> -#include "i915_buddy.h"
> #include "i915_gem.h"
>
> struct i915_ttm_buddy_manager {
> struct ttm_resource_manager manager;
> - struct i915_buddy_mm mm;
> + struct drm_buddy_mm mm;
> struct list_head reserved;
> struct mutex lock;
> u64 default_page_size;
> @@ -34,7 +35,7 @@ static int i915_ttm_buddy_man_alloc(struct ttm_resource_manager *man,
> {
> struct i915_ttm_buddy_manager *bman = to_buddy_manager(man);
> struct i915_ttm_buddy_resource *bman_res;
> - struct i915_buddy_mm *mm = &bman->mm;
> + struct drm_buddy_mm *mm = &bman->mm;
> unsigned long n_pages;
> unsigned int min_order;
> u64 min_page_size;
> @@ -73,7 +74,7 @@ static int i915_ttm_buddy_man_alloc(struct ttm_resource_manager *man,
> n_pages = size >> ilog2(mm->chunk_size);
>
> do {
> - struct i915_buddy_block *block;
> + struct drm_buddy_block *block;
> unsigned int order;
>
> order = fls(n_pages) - 1;
> @@ -82,7 +83,7 @@ static int i915_ttm_buddy_man_alloc(struct ttm_resource_manager *man,
>
> do {
> mutex_lock(&bman->lock);
> - block = i915_buddy_alloc(mm, order);
> + block = drm_buddy_alloc(mm, order);
> mutex_unlock(&bman->lock);
> if (!IS_ERR(block))
> break;
> @@ -106,7 +107,7 @@ static int i915_ttm_buddy_man_alloc(struct ttm_resource_manager *man,
>
> err_free_blocks:
> mutex_lock(&bman->lock);
> - i915_buddy_free_list(mm, &bman_res->blocks);
> + drm_buddy_free_list(mm, &bman_res->blocks);
> mutex_unlock(&bman->lock);
> err_free_res:
> kfree(bman_res);
> @@ -120,7 +121,7 @@ static void i915_ttm_buddy_man_free(struct ttm_resource_manager *man,
> struct i915_ttm_buddy_manager *bman = to_buddy_manager(man);
>
> mutex_lock(&bman->lock);
> - i915_buddy_free_list(&bman->mm, &bman_res->blocks);
> + drm_buddy_free_list(&bman->mm, &bman_res->blocks);
> mutex_unlock(&bman->lock);
>
> kfree(bman_res);
> @@ -130,17 +131,17 @@ static void i915_ttm_buddy_man_debug(struct ttm_resource_manager *man,
> struct drm_printer *printer)
> {
> struct i915_ttm_buddy_manager *bman = to_buddy_manager(man);
> - struct i915_buddy_block *block;
> + struct drm_buddy_block *block;
>
> mutex_lock(&bman->lock);
> drm_printf(printer, "default_page_size: %lluKiB\n",
> bman->default_page_size >> 10);
>
> - i915_buddy_print(&bman->mm, printer);
> + drm_buddy_print(&bman->mm, printer);
>
> drm_printf(printer, "reserved:\n");
> list_for_each_entry(block, &bman->reserved, link)
> - i915_buddy_block_print(&bman->mm, block, printer);
> + drm_buddy_block_print(&bman->mm, block, printer);
> mutex_unlock(&bman->lock);
> }
>
> @@ -190,7 +191,7 @@ int i915_ttm_buddy_man_init(struct ttm_device *bdev,
> if (!bman)
> return -ENOMEM;
>
> - err = i915_buddy_init(&bman->mm, size, chunk_size);
> + err = drm_buddy_init(&bman->mm, size, chunk_size);
> if (err)
> goto err_free_bman;
>
> @@ -228,7 +229,7 @@ int i915_ttm_buddy_man_fini(struct ttm_device *bdev, unsigned int type)
> {
> struct ttm_resource_manager *man = ttm_manager_type(bdev, type);
> struct i915_ttm_buddy_manager *bman = to_buddy_manager(man);
> - struct i915_buddy_mm *mm = &bman->mm;
> + struct drm_buddy_mm *mm = &bman->mm;
> int ret;
>
> ttm_resource_manager_set_used(man, false);
> @@ -240,8 +241,8 @@ int i915_ttm_buddy_man_fini(struct ttm_device *bdev, unsigned int type)
> ttm_set_driver_manager(bdev, type, NULL);
>
> mutex_lock(&bman->lock);
> - i915_buddy_free_list(mm, &bman->reserved);
> - i915_buddy_fini(mm);
> + drm_buddy_free_list(mm, &bman->reserved);
> + drm_buddy_fini(mm);
> mutex_unlock(&bman->lock);
>
> ttm_resource_manager_cleanup(man);
> @@ -264,11 +265,11 @@ int i915_ttm_buddy_man_reserve(struct ttm_resource_manager *man,
> u64 start, u64 size)
> {
> struct i915_ttm_buddy_manager *bman = to_buddy_manager(man);
> - struct i915_buddy_mm *mm = &bman->mm;
> + struct drm_buddy_mm *mm = &bman->mm;
> int ret;
>
> mutex_lock(&bman->lock);
> - ret = i915_buddy_alloc_range(mm, &bman->reserved, start, size);
> + ret = drm_buddy_alloc_range(mm, &bman->reserved, start, size);
> mutex_unlock(&bman->lock);
>
> return ret;
> diff --git a/drivers/gpu/drm/i915/i915_ttm_buddy_manager.h b/drivers/gpu/drm/i915/i915_ttm_buddy_manager.h
> index 0722d33f3e14..fa644b512c2e 100644
> --- a/drivers/gpu/drm/i915/i915_ttm_buddy_manager.h
> +++ b/drivers/gpu/drm/i915/i915_ttm_buddy_manager.h
> @@ -13,7 +13,7 @@
>
> struct ttm_device;
> struct ttm_resource_manager;
> -struct i915_buddy_mm;
> +struct drm_buddy_mm;
>
> /**
> * struct i915_ttm_buddy_resource
> @@ -28,7 +28,7 @@ struct i915_buddy_mm;
> struct i915_ttm_buddy_resource {
> struct ttm_resource base;
> struct list_head blocks;
> - struct i915_buddy_mm *mm;
> + struct drm_buddy_mm *mm;
> };
>
> /**
> diff --git a/include/drm/drm_buddy.h b/include/drm/drm_buddy.h
> new file mode 100644
> index 000000000000..5ce3fc702f80
> --- /dev/null
> +++ b/include/drm/drm_buddy.h
> @@ -0,0 +1,153 @@
> +/* SPDX-License-Identifier: MIT */
> +/*
> + * Copyright © 2021 Intel Corporation
> + */
> +
> +#ifndef __DRM_BUDDY_H__
> +#define __DRM_BUDDY_H__
> +
> +#include <linux/bitops.h>
> +#include <linux/list.h>
> +#include <linux/slab.h>
> +#include <linux/sched.h>
> +
> +#include <drm/drm_print.h>
> +
> +#define range_overflows(start, size, max) ({ \
> + typeof(start) start__ = (start); \
> + typeof(size) size__ = (size); \
> + typeof(max) max__ = (max); \
> + (void)(&start__ == &size__); \
> + (void)(&start__ == &max__); \
> + start__ >= max__ || size__ > max__ - start__; \
> +})
> +
> +struct drm_buddy_block {
> +#define DRM_BUDDY_HEADER_OFFSET GENMASK_ULL(63, 12)
> +#define DRM_BUDDY_HEADER_STATE GENMASK_ULL(11, 10)
> +#define DRM_BUDDY_ALLOCATED (1 << 10)
> +#define DRM_BUDDY_FREE (2 << 10)
> +#define DRM_BUDDY_SPLIT (3 << 10)
> +/* Free to be used, if needed in the future */
> +#define DRM_BUDDY_HEADER_UNUSED GENMASK_ULL(9, 6)
> +#define DRM_BUDDY_HEADER_ORDER GENMASK_ULL(5, 0)
> + u64 header;
> +
> + struct drm_buddy_block *left;
> + struct drm_buddy_block *right;
> + struct drm_buddy_block *parent;
> +
> + void *private; /* owned by creator */
> +
> + /*
> + * While the block is allocated by the user through drm_buddy_alloc*,
> + * the user has ownership of the link, for example to maintain within
> + * a list, if so desired. As soon as the block is freed with
> + * drm_buddy_free* ownership is given back to the mm.
> + */
> + struct list_head link;
> + struct list_head tmp_link;
> +};
> +
> +/* Order-zero must be at least PAGE_SIZE */
> +#define DRM_BUDDY_MAX_ORDER (63 - PAGE_SHIFT)
> +
> +/*
> + * Binary Buddy System.
> + *
> + * Locking should be handled by the user, a simple mutex around
> + * drm_buddy_alloc* and drm_buddy_free* should suffice.
> + */
> +struct drm_buddy_mm {
> + /* Maintain a free list for each order. */
> + struct list_head *free_list;
> +
> + /*
> + * Maintain explicit binary tree(s) to track the allocation of the
> + * address space. This gives us a simple way of finding a buddy block
> + * and performing the potentially recursive merge step when freeing a
> + * block. Nodes are either allocated or free, in which case they will
> + * also exist on the respective free list.
> + */
> + struct drm_buddy_block **roots;
> +
> + /*
> + * Anything from here is public, and remains static for the lifetime of
> + * the mm. Everything above is considered do-not-touch.
> + */
> + unsigned int n_roots;
> + unsigned int max_order;
> +
> + /* Must be at least PAGE_SIZE */
> + u64 chunk_size;
> + u64 size;
> + u64 avail;
> +};
> +
> +static inline u64
> +drm_buddy_block_offset(struct drm_buddy_block *block)
> +{
> + return block->header & DRM_BUDDY_HEADER_OFFSET;
> +}
> +
> +static inline unsigned int
> +drm_buddy_block_order(struct drm_buddy_block *block)
> +{
> + return block->header & DRM_BUDDY_HEADER_ORDER;
> +}
> +
> +static inline unsigned int
> +drm_buddy_block_state(struct drm_buddy_block *block)
> +{
> + return block->header & DRM_BUDDY_HEADER_STATE;
> +}
> +
> +static inline bool
> +drm_buddy_block_is_allocated(struct drm_buddy_block *block)
> +{
> + return drm_buddy_block_state(block) == DRM_BUDDY_ALLOCATED;
> +}
> +
> +static inline bool
> +drm_buddy_block_is_free(struct drm_buddy_block *block)
> +{
> + return drm_buddy_block_state(block) == DRM_BUDDY_FREE;
> +}
> +
> +static inline bool
> +drm_buddy_block_is_split(struct drm_buddy_block *block)
> +{
> + return drm_buddy_block_state(block) == DRM_BUDDY_SPLIT;
> +}
> +
> +static inline u64
> +drm_buddy_block_size(struct drm_buddy_mm *mm,
> + struct drm_buddy_block *block)
> +{
> + return mm->chunk_size << drm_buddy_block_order(block);
> +}
> +
> +int drm_buddy_init(struct drm_buddy_mm *mm, u64 size, u64 chunk_size);
> +
> +void drm_buddy_fini(struct drm_buddy_mm *mm);
> +
> +struct drm_buddy_block *
> +drm_buddy_alloc(struct drm_buddy_mm *mm, unsigned int order);
> +
> +int drm_buddy_alloc_range(struct drm_buddy_mm *mm,
> + struct list_head *blocks,
> + u64 start, u64 size);
> +
> +void drm_buddy_free(struct drm_buddy_mm *mm, struct drm_buddy_block *block);
> +
> +void drm_buddy_free_list(struct drm_buddy_mm *mm, struct list_head *objects);
> +
> +void drm_buddy_print(struct drm_buddy_mm *mm, struct drm_printer *p);
> +void drm_buddy_block_print(struct drm_buddy_mm *mm,
> + struct drm_buddy_block *block,
> + struct drm_printer *p);
> +
> +void drm_buddy_module_exit(void);
> +int drm_buddy_module_init(void);
> +
> +#endif
^ permalink raw reply [flat|nested] 46+ messages in thread
* Re: [Intel-gfx] [PATCH v3 1/6] drm: move the buddy allocator from i915 into common drm
@ 2021-11-17 8:03 ` Christian König
0 siblings, 0 replies; 46+ messages in thread
From: Christian König @ 2021-11-17 8:03 UTC (permalink / raw)
To: Arunpravin, dri-devel, intel-gfx, amd-gfx
Cc: matthew.auld, tzimmermann, alexander.deucher, christian.koenig
I've looked a bit more into this and I think we should just follow
Thomas Zimmermann's idea to make this a separate module.
Otherwise we just have the code around all the time even if it is unused
and implementing this should be trivial.
See how DRM_GEM_CMA_HELPER or DRM_VRAM_HELPER are done in
drivers/gpu/drm/Kconfig and then have the desired effect in
drivers/gpu/drm/Makefile
Should be something like ~15 lines of additional configuration which
saves a bit of memory on embedded systems which just need a fbdev
replacement.
Thanks,
Christian.
Am 16.11.21 um 21:18 schrieb Arunpravin:
> Move the base i915 buddy allocator code into drm
> - Move i915_buddy.h to include/drm
> - Move i915_buddy.c to drm root folder
> - Rename "i915" string with "drm" string wherever applicable
> - Rename "I915" string with "DRM" string wherever applicable
> - Fix header file dependencies
> - Fix alignment issues
> - add Makefile support for drm buddy
> - export functions and write kerneldoc description
> - Remove i915 selftest config check condition as buddy selftest
> will be moved to drm selftest folder
>
> cleanup i915 buddy references in i915 driver module
> and replace with drm buddy
>
> v2:
> - include header file in alphabetical order (Thomas)
> - merged changes listed in the body section into a single patch
> to keep the build intact (Christian, Jani)
>
> Signed-off-by: Arunpravin <Arunpravin.PaneerSelvam@amd.com>
> ---
> drivers/gpu/drm/Makefile | 2 +-
> drivers/gpu/drm/drm_buddy.c | 521 ++++++++++++++++++
> drivers/gpu/drm/drm_drv.c | 3 +
> drivers/gpu/drm/i915/Makefile | 1 -
> drivers/gpu/drm/i915/i915_buddy.c | 466 ----------------
> drivers/gpu/drm/i915/i915_buddy.h | 143 -----
> drivers/gpu/drm/i915/i915_module.c | 3 -
> drivers/gpu/drm/i915/i915_scatterlist.c | 11 +-
> drivers/gpu/drm/i915/i915_ttm_buddy_manager.c | 33 +-
> drivers/gpu/drm/i915/i915_ttm_buddy_manager.h | 4 +-
> include/drm/drm_buddy.h | 153 +++++
> 11 files changed, 702 insertions(+), 638 deletions(-)
> create mode 100644 drivers/gpu/drm/drm_buddy.c
> delete mode 100644 drivers/gpu/drm/i915/i915_buddy.c
> delete mode 100644 drivers/gpu/drm/i915/i915_buddy.h
> create mode 100644 include/drm/drm_buddy.h
>
> diff --git a/drivers/gpu/drm/Makefile b/drivers/gpu/drm/Makefile
> index 0dff40bb863c..dc61e91a3154 100644
> --- a/drivers/gpu/drm/Makefile
> +++ b/drivers/gpu/drm/Makefile
> @@ -18,7 +18,7 @@ drm-y := drm_aperture.o drm_auth.o drm_cache.o \
> drm_dumb_buffers.o drm_mode_config.o drm_vblank.o \
> drm_syncobj.o drm_lease.o drm_writeback.o drm_client.o \
> drm_client_modeset.o drm_atomic_uapi.o drm_hdcp.o \
> - drm_managed.o drm_vblank_work.o
> + drm_managed.o drm_vblank_work.o drm_buddy.o
>
> drm-$(CONFIG_DRM_LEGACY) += drm_agpsupport.o drm_bufs.o drm_context.o drm_dma.o \
> drm_legacy_misc.o drm_lock.o drm_memory.o drm_scatter.o \
> diff --git a/drivers/gpu/drm/drm_buddy.c b/drivers/gpu/drm/drm_buddy.c
> new file mode 100644
> index 000000000000..39eb1d224bec
> --- /dev/null
> +++ b/drivers/gpu/drm/drm_buddy.c
> @@ -0,0 +1,521 @@
> +// SPDX-License-Identifier: MIT
> +/*
> + * Copyright © 2021 Intel Corporation
> + */
> +
> +#include <linux/kmemleak.h>
> +#include <linux/sizes.h>
> +
> +#include <drm/drm_buddy.h>
> +
> +static struct kmem_cache *slab_blocks;
> +
> +static struct drm_buddy_block *drm_block_alloc(struct drm_buddy_mm *mm,
> + struct drm_buddy_block *parent,
> + unsigned int order,
> + u64 offset)
> +{
> + struct drm_buddy_block *block;
> +
> + BUG_ON(order > DRM_BUDDY_MAX_ORDER);
> +
> + block = kmem_cache_zalloc(slab_blocks, GFP_KERNEL);
> + if (!block)
> + return NULL;
> +
> + block->header = offset;
> + block->header |= order;
> + block->parent = parent;
> +
> + BUG_ON(block->header & DRM_BUDDY_HEADER_UNUSED);
> + return block;
> +}
> +
> +static void drm_block_free(struct drm_buddy_mm *mm,
> + struct drm_buddy_block *block)
> +{
> + kmem_cache_free(slab_blocks, block);
> +}
> +
> +static void mark_allocated(struct drm_buddy_block *block)
> +{
> + block->header &= ~DRM_BUDDY_HEADER_STATE;
> + block->header |= DRM_BUDDY_ALLOCATED;
> +
> + list_del(&block->link);
> +}
> +
> +static void mark_free(struct drm_buddy_mm *mm,
> + struct drm_buddy_block *block)
> +{
> + block->header &= ~DRM_BUDDY_HEADER_STATE;
> + block->header |= DRM_BUDDY_FREE;
> +
> + list_add(&block->link,
> + &mm->free_list[drm_buddy_block_order(block)]);
> +}
> +
> +static void mark_split(struct drm_buddy_block *block)
> +{
> + block->header &= ~DRM_BUDDY_HEADER_STATE;
> + block->header |= DRM_BUDDY_SPLIT;
> +
> + list_del(&block->link);
> +}
> +
> +/**
> + * drm_buddy_init - init memory manager
> + *
> + * @mm: DRM buddy manager to initialize
> + * @size: size in bytes to manage
> + * @chunk_size: minimum page size in bytes for our allocations
> + *
> + * Initializes the memory manager and its resources.
> + *
> + * Returns:
> + * 0 on success, error code on failure.
> + */
> +int drm_buddy_init(struct drm_buddy_mm *mm, u64 size, u64 chunk_size)
> +{
> + unsigned int i;
> + u64 offset;
> +
> + if (size < chunk_size)
> + return -EINVAL;
> +
> + if (chunk_size < PAGE_SIZE)
> + return -EINVAL;
> +
> + if (!is_power_of_2(chunk_size))
> + return -EINVAL;
> +
> + size = round_down(size, chunk_size);
> +
> + mm->size = size;
> + mm->avail = size;
> + mm->chunk_size = chunk_size;
> + mm->max_order = ilog2(size) - ilog2(chunk_size);
> +
> + BUG_ON(mm->max_order > DRM_BUDDY_MAX_ORDER);
> +
> + mm->free_list = kmalloc_array(mm->max_order + 1,
> + sizeof(struct list_head),
> + GFP_KERNEL);
> + if (!mm->free_list)
> + return -ENOMEM;
> +
> + for (i = 0; i <= mm->max_order; ++i)
> + INIT_LIST_HEAD(&mm->free_list[i]);
> +
> + mm->n_roots = hweight64(size);
> +
> + mm->roots = kmalloc_array(mm->n_roots,
> + sizeof(struct drm_buddy_block *),
> + GFP_KERNEL);
> + if (!mm->roots)
> + goto out_free_list;
> +
> + offset = 0;
> + i = 0;
> +
> + /*
> + * Split into power-of-two blocks, in case we are given a size that is
> + * not itself a power-of-two.
> + */
> + do {
> + struct drm_buddy_block *root;
> + unsigned int order;
> + u64 root_size;
> +
> + root_size = rounddown_pow_of_two(size);
> + order = ilog2(root_size) - ilog2(chunk_size);
> +
> + root = drm_block_alloc(mm, NULL, order, offset);
> + if (!root)
> + goto out_free_roots;
> +
> + mark_free(mm, root);
> +
> + BUG_ON(i > mm->max_order);
> + BUG_ON(drm_buddy_block_size(mm, root) < chunk_size);
> +
> + mm->roots[i] = root;
> +
> + offset += root_size;
> + size -= root_size;
> + i++;
> + } while (size);
> +
> + return 0;
> +
> +out_free_roots:
> + while (i--)
> + drm_block_free(mm, mm->roots[i]);
> + kfree(mm->roots);
> +out_free_list:
> + kfree(mm->free_list);
> + return -ENOMEM;
> +}
> +EXPORT_SYMBOL(drm_buddy_init);
> +
> +/**
> + * drm_buddy_fini - tear down the memory manager
> + *
> + * @mm: DRM buddy manager to free
> + *
> + * Cleanup memory manager resources and the freelist
> + */
> +void drm_buddy_fini(struct drm_buddy_mm *mm)
> +{
> + int i;
> +
> + for (i = 0; i < mm->n_roots; ++i) {
> + WARN_ON(!drm_buddy_block_is_free(mm->roots[i]));
> + drm_block_free(mm, mm->roots[i]);
> + }
> +
> + WARN_ON(mm->avail != mm->size);
> +
> + kfree(mm->roots);
> + kfree(mm->free_list);
> +}
> +EXPORT_SYMBOL(drm_buddy_fini);
> +
> +static int split_block(struct drm_buddy_mm *mm,
> + struct drm_buddy_block *block)
> +{
> + unsigned int block_order = drm_buddy_block_order(block) - 1;
> + u64 offset = drm_buddy_block_offset(block);
> +
> + BUG_ON(!drm_buddy_block_is_free(block));
> + BUG_ON(!drm_buddy_block_order(block));
> +
> + block->left = drm_block_alloc(mm, block, block_order, offset);
> + if (!block->left)
> + return -ENOMEM;
> +
> + block->right = drm_block_alloc(mm, block, block_order,
> + offset + (mm->chunk_size << block_order));
> + if (!block->right) {
> + drm_block_free(mm, block->left);
> + return -ENOMEM;
> + }
> +
> + mark_free(mm, block->left);
> + mark_free(mm, block->right);
> +
> + mark_split(block);
> +
> + return 0;
> +}
> +
> +static struct drm_buddy_block *
> +get_buddy(struct drm_buddy_block *block)
> +{
> + struct drm_buddy_block *parent;
> +
> + parent = block->parent;
> + if (!parent)
> + return NULL;
> +
> + if (parent->left == block)
> + return parent->right;
> +
> + return parent->left;
> +}
> +
> +static void __drm_buddy_free(struct drm_buddy_mm *mm,
> + struct drm_buddy_block *block)
> +{
> + struct drm_buddy_block *parent;
> +
> + while ((parent = block->parent)) {
> + struct drm_buddy_block *buddy;
> +
> + buddy = get_buddy(block);
> +
> + if (!drm_buddy_block_is_free(buddy))
> + break;
> +
> + list_del(&buddy->link);
> +
> + drm_block_free(mm, block);
> + drm_block_free(mm, buddy);
> +
> + block = parent;
> + }
> +
> + mark_free(mm, block);
> +}
> +
> +void drm_buddy_free(struct drm_buddy_mm *mm,
> + struct drm_buddy_block *block)
> +{
> + BUG_ON(!drm_buddy_block_is_allocated(block));
> + mm->avail += drm_buddy_block_size(mm, block);
> + __drm_buddy_free(mm, block);
> +}
> +
> +/**
> + * drm_buddy_free_list - free blocks
> + *
> + * @mm: DRM buddy manager
> + * @objects: input list head to free blocks
> + */
> +void drm_buddy_free_list(struct drm_buddy_mm *mm, struct list_head *objects)
> +{
> + struct drm_buddy_block *block, *on;
> +
> + list_for_each_entry_safe(block, on, objects, link) {
> + drm_buddy_free(mm, block);
> + cond_resched();
> + }
> + INIT_LIST_HEAD(objects);
> +}
> +EXPORT_SYMBOL(drm_buddy_free_list);
> +
> +/**
> + * drm_buddy_alloc - allocate power-of-two blocks
> + *
> + * @mm: DRM buddy manager to allocate from
> + * @order: size of the allocation
> + *
> + * The order value here translates to:
> + *
> + * 0 = 2^0 * mm->chunk_size
> + * 1 = 2^1 * mm->chunk_size
> + * 2 = 2^2 * mm->chunk_size
> + *
> + * Returns:
> + * allocated ptr to the &drm_buddy_block on success
> + */
> +struct drm_buddy_block *
> +drm_buddy_alloc(struct drm_buddy_mm *mm, unsigned int order)
> +{
> + struct drm_buddy_block *block = NULL;
> + unsigned int i;
> + int err;
> +
> + for (i = order; i <= mm->max_order; ++i) {
> + block = list_first_entry_or_null(&mm->free_list[i],
> + struct drm_buddy_block,
> + link);
> + if (block)
> + break;
> + }
> +
> + if (!block)
> + return ERR_PTR(-ENOSPC);
> +
> + BUG_ON(!drm_buddy_block_is_free(block));
> +
> + while (i != order) {
> + err = split_block(mm, block);
> + if (unlikely(err))
> + goto out_free;
> +
> + /* Go low */
> + block = block->left;
> + i--;
> + }
> +
> + mark_allocated(block);
> + mm->avail -= drm_buddy_block_size(mm, block);
> + kmemleak_update_trace(block);
> + return block;
> +
> +out_free:
> + if (i != order)
> + __drm_buddy_free(mm, block);
> + return ERR_PTR(err);
> +}
> +EXPORT_SYMBOL(drm_buddy_alloc);
> +
> +static inline bool overlaps(u64 s1, u64 e1, u64 s2, u64 e2)
> +{
> + return s1 <= e2 && e1 >= s2;
> +}
> +
> +static inline bool contains(u64 s1, u64 e1, u64 s2, u64 e2)
> +{
> + return s1 <= s2 && e1 >= e2;
> +}
> +
> +/**
> + * drm_buddy_alloc_range - allocate range
> + *
> + * @mm: DRM buddy manager to allocate from
> + * @blocks: output list head to add allocated blocks
> + * @start: start of the allowed range for this block
> + * @size: size of the allocation
> + *
> + * Intended for pre-allocating portions of the address space, for example to
> + * reserve a block for the initial framebuffer or similar, hence the expectation
> + * here is that drm_buddy_alloc() is still the main vehicle for
> + * allocations, so if that's not the case then the drm_mm range allocator is
> + * probably a much better fit, and so you should probably go use that instead.
> + *
> + * Note that it's safe to chain together multiple alloc_ranges
> + * with the same blocks list
> + *
> + * Returns:
> + * 0 on success, error code on failure.
> + */
> +int drm_buddy_alloc_range(struct drm_buddy_mm *mm,
> + struct list_head *blocks,
> + u64 start, u64 size)
> +{
> + struct drm_buddy_block *block;
> + struct drm_buddy_block *buddy;
> + LIST_HEAD(allocated);
> + LIST_HEAD(dfs);
> + u64 end;
> + int err;
> + int i;
> +
> + if (size < mm->chunk_size)
> + return -EINVAL;
> +
> + if (!IS_ALIGNED(size | start, mm->chunk_size))
> + return -EINVAL;
> +
> + if (range_overflows(start, size, mm->size))
> + return -EINVAL;
> +
> + for (i = 0; i < mm->n_roots; ++i)
> + list_add_tail(&mm->roots[i]->tmp_link, &dfs);
> +
> + end = start + size - 1;
> +
> + do {
> + u64 block_start;
> + u64 block_end;
> +
> + block = list_first_entry_or_null(&dfs,
> + struct drm_buddy_block,
> + tmp_link);
> + if (!block)
> + break;
> +
> + list_del(&block->tmp_link);
> +
> + block_start = drm_buddy_block_offset(block);
> + block_end = block_start + drm_buddy_block_size(mm, block) - 1;
> +
> + if (!overlaps(start, end, block_start, block_end))
> + continue;
> +
> + if (drm_buddy_block_is_allocated(block)) {
> + err = -ENOSPC;
> + goto err_free;
> + }
> +
> + if (contains(start, end, block_start, block_end)) {
> + if (!drm_buddy_block_is_free(block)) {
> + err = -ENOSPC;
> + goto err_free;
> + }
> +
> + mark_allocated(block);
> + mm->avail -= drm_buddy_block_size(mm, block);
> + list_add_tail(&block->link, &allocated);
> + continue;
> + }
> +
> + if (!drm_buddy_block_is_split(block)) {
> + err = split_block(mm, block);
> + if (unlikely(err))
> + goto err_undo;
> + }
> +
> + list_add(&block->right->tmp_link, &dfs);
> + list_add(&block->left->tmp_link, &dfs);
> + } while (1);
> +
> + list_splice_tail(&allocated, blocks);
> + return 0;
> +
> +err_undo:
> + /*
> + * We really don't want to leave around a bunch of split blocks, since
> + * bigger is better, so make sure we merge everything back before we
> + * free the allocated blocks.
> + */
> + buddy = get_buddy(block);
> + if (buddy &&
> + (drm_buddy_block_is_free(block) &&
> + drm_buddy_block_is_free(buddy)))
> + __drm_buddy_free(mm, block);
> +
> +err_free:
> + drm_buddy_free_list(mm, &allocated);
> + return err;
> +}
> +EXPORT_SYMBOL(drm_buddy_alloc_range);
> +
> +/**
> + * drm_buddy_block_print - print block information
> + *
> + * @mm: DRM buddy manager
> + * @block: DRM buddy block
> + * @p: DRM printer to use
> + */
> +void drm_buddy_block_print(struct drm_buddy_mm *mm,
> + struct drm_buddy_block *block,
> + struct drm_printer *p)
> +{
> + u64 start = drm_buddy_block_offset(block);
> + u64 size = drm_buddy_block_size(mm, block);
> +
> + drm_printf(p, "%#018llx-%#018llx: %llu\n", start, start + size, size);
> +}
> +EXPORT_SYMBOL(drm_buddy_block_print);
> +
> +/**
> + * drm_buddy_print - print allocator state
> + *
> + * @mm: DRM buddy manager
> + * @p: DRM printer to use
> + */
> +void drm_buddy_print(struct drm_buddy_mm *mm, struct drm_printer *p)
> +{
> + int order;
> +
> + drm_printf(p, "chunk_size: %lluKiB, total: %lluMiB, free: %lluMiB\n",
> + mm->chunk_size >> 10, mm->size >> 20, mm->avail >> 20);
> +
> + for (order = mm->max_order; order >= 0; order--) {
> + struct drm_buddy_block *block;
> + u64 count = 0, free;
> +
> + list_for_each_entry(block, &mm->free_list[order], link) {
> + BUG_ON(!drm_buddy_block_is_free(block));
> + count++;
> + }
> +
> + drm_printf(p, "order-%d ", order);
> +
> + free = count * (mm->chunk_size << order);
> + if (free < SZ_1M)
> + drm_printf(p, "free: %lluKiB", free >> 10);
> + else
> + drm_printf(p, "free: %lluMiB", free >> 20);
> +
> + drm_printf(p, ", pages: %llu\n", count);
> + }
> +}
> +EXPORT_SYMBOL(drm_buddy_print);
> +
> +void drm_buddy_module_exit(void)
> +{
> + kmem_cache_destroy(slab_blocks);
> +}
> +
> +int __init drm_buddy_module_init(void)
> +{
> + slab_blocks = KMEM_CACHE(drm_buddy_block, 0);
> + if (!slab_blocks)
> + return -ENOMEM;
> +
> + return 0;
> +}
> diff --git a/drivers/gpu/drm/drm_drv.c b/drivers/gpu/drm/drm_drv.c
> index 7a5097467ba5..5d5e46e60586 100644
> --- a/drivers/gpu/drm/drm_drv.c
> +++ b/drivers/gpu/drm/drm_drv.c
> @@ -35,6 +35,7 @@
> #include <linux/slab.h>
> #include <linux/srcu.h>
>
> +#include <drm/drm_buddy.h>
> #include <drm/drm_cache.h>
> #include <drm/drm_client.h>
> #include <drm/drm_color_mgmt.h>
> @@ -1034,6 +1035,7 @@ static void drm_core_exit(void)
> drm_sysfs_destroy();
> idr_destroy(&drm_minors_idr);
> drm_connector_ida_destroy();
> + drm_buddy_module_exit();
> }
>
> static int __init drm_core_init(void)
> @@ -1043,6 +1045,7 @@ static int __init drm_core_init(void)
> drm_connector_ida_init();
> idr_init(&drm_minors_idr);
> drm_memcpy_init_early();
> + drm_buddy_module_init();
>
> ret = drm_sysfs_init();
> if (ret < 0) {
> diff --git a/drivers/gpu/drm/i915/Makefile b/drivers/gpu/drm/i915/Makefile
> index 467872cca027..fc5ca8c4ccb2 100644
> --- a/drivers/gpu/drm/i915/Makefile
> +++ b/drivers/gpu/drm/i915/Makefile
> @@ -161,7 +161,6 @@ gem-y += \
> i915-y += \
> $(gem-y) \
> i915_active.o \
> - i915_buddy.o \
> i915_cmd_parser.o \
> i915_gem_evict.o \
> i915_gem_gtt.o \
> diff --git a/drivers/gpu/drm/i915/i915_buddy.c b/drivers/gpu/drm/i915/i915_buddy.c
> deleted file mode 100644
> index 6e2ad68f8f3f..000000000000
> --- a/drivers/gpu/drm/i915/i915_buddy.c
> +++ /dev/null
> @@ -1,466 +0,0 @@
> -// SPDX-License-Identifier: MIT
> -/*
> - * Copyright © 2021 Intel Corporation
> - */
> -
> -#include <linux/kmemleak.h>
> -#include <linux/sizes.h>
> -
> -#include "i915_buddy.h"
> -
> -#include "i915_gem.h"
> -#include "i915_utils.h"
> -
> -static struct kmem_cache *slab_blocks;
> -
> -static struct i915_buddy_block *i915_block_alloc(struct i915_buddy_mm *mm,
> - struct i915_buddy_block *parent,
> - unsigned int order,
> - u64 offset)
> -{
> - struct i915_buddy_block *block;
> -
> - GEM_BUG_ON(order > I915_BUDDY_MAX_ORDER);
> -
> - block = kmem_cache_zalloc(slab_blocks, GFP_KERNEL);
> - if (!block)
> - return NULL;
> -
> - block->header = offset;
> - block->header |= order;
> - block->parent = parent;
> -
> - GEM_BUG_ON(block->header & I915_BUDDY_HEADER_UNUSED);
> - return block;
> -}
> -
> -static void i915_block_free(struct i915_buddy_mm *mm,
> - struct i915_buddy_block *block)
> -{
> - kmem_cache_free(slab_blocks, block);
> -}
> -
> -static void mark_allocated(struct i915_buddy_block *block)
> -{
> - block->header &= ~I915_BUDDY_HEADER_STATE;
> - block->header |= I915_BUDDY_ALLOCATED;
> -
> - list_del(&block->link);
> -}
> -
> -static void mark_free(struct i915_buddy_mm *mm,
> - struct i915_buddy_block *block)
> -{
> - block->header &= ~I915_BUDDY_HEADER_STATE;
> - block->header |= I915_BUDDY_FREE;
> -
> - list_add(&block->link,
> - &mm->free_list[i915_buddy_block_order(block)]);
> -}
> -
> -static void mark_split(struct i915_buddy_block *block)
> -{
> - block->header &= ~I915_BUDDY_HEADER_STATE;
> - block->header |= I915_BUDDY_SPLIT;
> -
> - list_del(&block->link);
> -}
> -
> -int i915_buddy_init(struct i915_buddy_mm *mm, u64 size, u64 chunk_size)
> -{
> - unsigned int i;
> - u64 offset;
> -
> - if (size < chunk_size)
> - return -EINVAL;
> -
> - if (chunk_size < PAGE_SIZE)
> - return -EINVAL;
> -
> - if (!is_power_of_2(chunk_size))
> - return -EINVAL;
> -
> - size = round_down(size, chunk_size);
> -
> - mm->size = size;
> - mm->avail = size;
> - mm->chunk_size = chunk_size;
> - mm->max_order = ilog2(size) - ilog2(chunk_size);
> -
> - GEM_BUG_ON(mm->max_order > I915_BUDDY_MAX_ORDER);
> -
> - mm->free_list = kmalloc_array(mm->max_order + 1,
> - sizeof(struct list_head),
> - GFP_KERNEL);
> - if (!mm->free_list)
> - return -ENOMEM;
> -
> - for (i = 0; i <= mm->max_order; ++i)
> - INIT_LIST_HEAD(&mm->free_list[i]);
> -
> - mm->n_roots = hweight64(size);
> -
> - mm->roots = kmalloc_array(mm->n_roots,
> - sizeof(struct i915_buddy_block *),
> - GFP_KERNEL);
> - if (!mm->roots)
> - goto out_free_list;
> -
> - offset = 0;
> - i = 0;
> -
> - /*
> - * Split into power-of-two blocks, in case we are given a size that is
> - * not itself a power-of-two.
> - */
> - do {
> - struct i915_buddy_block *root;
> - unsigned int order;
> - u64 root_size;
> -
> - root_size = rounddown_pow_of_two(size);
> - order = ilog2(root_size) - ilog2(chunk_size);
> -
> - root = i915_block_alloc(mm, NULL, order, offset);
> - if (!root)
> - goto out_free_roots;
> -
> - mark_free(mm, root);
> -
> - GEM_BUG_ON(i > mm->max_order);
> - GEM_BUG_ON(i915_buddy_block_size(mm, root) < chunk_size);
> -
> - mm->roots[i] = root;
> -
> - offset += root_size;
> - size -= root_size;
> - i++;
> - } while (size);
> -
> - return 0;
> -
> -out_free_roots:
> - while (i--)
> - i915_block_free(mm, mm->roots[i]);
> - kfree(mm->roots);
> -out_free_list:
> - kfree(mm->free_list);
> - return -ENOMEM;
> -}
> -
> -void i915_buddy_fini(struct i915_buddy_mm *mm)
> -{
> - int i;
> -
> - for (i = 0; i < mm->n_roots; ++i) {
> - GEM_WARN_ON(!i915_buddy_block_is_free(mm->roots[i]));
> - i915_block_free(mm, mm->roots[i]);
> - }
> -
> - GEM_WARN_ON(mm->avail != mm->size);
> -
> - kfree(mm->roots);
> - kfree(mm->free_list);
> -}
> -
> -static int split_block(struct i915_buddy_mm *mm,
> - struct i915_buddy_block *block)
> -{
> - unsigned int block_order = i915_buddy_block_order(block) - 1;
> - u64 offset = i915_buddy_block_offset(block);
> -
> - GEM_BUG_ON(!i915_buddy_block_is_free(block));
> - GEM_BUG_ON(!i915_buddy_block_order(block));
> -
> - block->left = i915_block_alloc(mm, block, block_order, offset);
> - if (!block->left)
> - return -ENOMEM;
> -
> - block->right = i915_block_alloc(mm, block, block_order,
> - offset + (mm->chunk_size << block_order));
> - if (!block->right) {
> - i915_block_free(mm, block->left);
> - return -ENOMEM;
> - }
> -
> - mark_free(mm, block->left);
> - mark_free(mm, block->right);
> -
> - mark_split(block);
> -
> - return 0;
> -}
> -
> -static struct i915_buddy_block *
> -get_buddy(struct i915_buddy_block *block)
> -{
> - struct i915_buddy_block *parent;
> -
> - parent = block->parent;
> - if (!parent)
> - return NULL;
> -
> - if (parent->left == block)
> - return parent->right;
> -
> - return parent->left;
> -}
> -
> -static void __i915_buddy_free(struct i915_buddy_mm *mm,
> - struct i915_buddy_block *block)
> -{
> - struct i915_buddy_block *parent;
> -
> - while ((parent = block->parent)) {
> - struct i915_buddy_block *buddy;
> -
> - buddy = get_buddy(block);
> -
> - if (!i915_buddy_block_is_free(buddy))
> - break;
> -
> - list_del(&buddy->link);
> -
> - i915_block_free(mm, block);
> - i915_block_free(mm, buddy);
> -
> - block = parent;
> - }
> -
> - mark_free(mm, block);
> -}
> -
> -void i915_buddy_free(struct i915_buddy_mm *mm,
> - struct i915_buddy_block *block)
> -{
> - GEM_BUG_ON(!i915_buddy_block_is_allocated(block));
> - mm->avail += i915_buddy_block_size(mm, block);
> - __i915_buddy_free(mm, block);
> -}
> -
> -void i915_buddy_free_list(struct i915_buddy_mm *mm, struct list_head *objects)
> -{
> - struct i915_buddy_block *block, *on;
> -
> - list_for_each_entry_safe(block, on, objects, link) {
> - i915_buddy_free(mm, block);
> - cond_resched();
> - }
> - INIT_LIST_HEAD(objects);
> -}
> -
> -/*
> - * Allocate power-of-two block. The order value here translates to:
> - *
> - * 0 = 2^0 * mm->chunk_size
> - * 1 = 2^1 * mm->chunk_size
> - * 2 = 2^2 * mm->chunk_size
> - * ...
> - */
> -struct i915_buddy_block *
> -i915_buddy_alloc(struct i915_buddy_mm *mm, unsigned int order)
> -{
> - struct i915_buddy_block *block = NULL;
> - unsigned int i;
> - int err;
> -
> - for (i = order; i <= mm->max_order; ++i) {
> - block = list_first_entry_or_null(&mm->free_list[i],
> - struct i915_buddy_block,
> - link);
> - if (block)
> - break;
> - }
> -
> - if (!block)
> - return ERR_PTR(-ENOSPC);
> -
> - GEM_BUG_ON(!i915_buddy_block_is_free(block));
> -
> - while (i != order) {
> - err = split_block(mm, block);
> - if (unlikely(err))
> - goto out_free;
> -
> - /* Go low */
> - block = block->left;
> - i--;
> - }
> -
> - mark_allocated(block);
> - mm->avail -= i915_buddy_block_size(mm, block);
> - kmemleak_update_trace(block);
> - return block;
> -
> -out_free:
> - if (i != order)
> - __i915_buddy_free(mm, block);
> - return ERR_PTR(err);
> -}
> -
> -static inline bool overlaps(u64 s1, u64 e1, u64 s2, u64 e2)
> -{
> - return s1 <= e2 && e1 >= s2;
> -}
> -
> -static inline bool contains(u64 s1, u64 e1, u64 s2, u64 e2)
> -{
> - return s1 <= s2 && e1 >= e2;
> -}
> -
> -/*
> - * Allocate range. Note that it's safe to chain together multiple alloc_ranges
> - * with the same blocks list.
> - *
> - * Intended for pre-allocating portions of the address space, for example to
> - * reserve a block for the initial framebuffer or similar, hence the expectation
> - * here is that i915_buddy_alloc() is still the main vehicle for
> - * allocations, so if that's not the case then the drm_mm range allocator is
> - * probably a much better fit, and so you should probably go use that instead.
> - */
> -int i915_buddy_alloc_range(struct i915_buddy_mm *mm,
> - struct list_head *blocks,
> - u64 start, u64 size)
> -{
> - struct i915_buddy_block *block;
> - struct i915_buddy_block *buddy;
> - LIST_HEAD(allocated);
> - LIST_HEAD(dfs);
> - u64 end;
> - int err;
> - int i;
> -
> - if (size < mm->chunk_size)
> - return -EINVAL;
> -
> - if (!IS_ALIGNED(size | start, mm->chunk_size))
> - return -EINVAL;
> -
> - if (range_overflows(start, size, mm->size))
> - return -EINVAL;
> -
> - for (i = 0; i < mm->n_roots; ++i)
> - list_add_tail(&mm->roots[i]->tmp_link, &dfs);
> -
> - end = start + size - 1;
> -
> - do {
> - u64 block_start;
> - u64 block_end;
> -
> - block = list_first_entry_or_null(&dfs,
> - struct i915_buddy_block,
> - tmp_link);
> - if (!block)
> - break;
> -
> - list_del(&block->tmp_link);
> -
> - block_start = i915_buddy_block_offset(block);
> - block_end = block_start + i915_buddy_block_size(mm, block) - 1;
> -
> - if (!overlaps(start, end, block_start, block_end))
> - continue;
> -
> - if (i915_buddy_block_is_allocated(block)) {
> - err = -ENOSPC;
> - goto err_free;
> - }
> -
> - if (contains(start, end, block_start, block_end)) {
> - if (!i915_buddy_block_is_free(block)) {
> - err = -ENOSPC;
> - goto err_free;
> - }
> -
> - mark_allocated(block);
> - mm->avail -= i915_buddy_block_size(mm, block);
> - list_add_tail(&block->link, &allocated);
> - continue;
> - }
> -
> - if (!i915_buddy_block_is_split(block)) {
> - err = split_block(mm, block);
> - if (unlikely(err))
> - goto err_undo;
> - }
> -
> - list_add(&block->right->tmp_link, &dfs);
> - list_add(&block->left->tmp_link, &dfs);
> - } while (1);
> -
> - list_splice_tail(&allocated, blocks);
> - return 0;
> -
> -err_undo:
> - /*
> - * We really don't want to leave around a bunch of split blocks, since
> - * bigger is better, so make sure we merge everything back before we
> - * free the allocated blocks.
> - */
> - buddy = get_buddy(block);
> - if (buddy &&
> - (i915_buddy_block_is_free(block) &&
> - i915_buddy_block_is_free(buddy)))
> - __i915_buddy_free(mm, block);
> -
> -err_free:
> - i915_buddy_free_list(mm, &allocated);
> - return err;
> -}
> -
> -void i915_buddy_block_print(struct i915_buddy_mm *mm,
> - struct i915_buddy_block *block,
> - struct drm_printer *p)
> -{
> - u64 start = i915_buddy_block_offset(block);
> - u64 size = i915_buddy_block_size(mm, block);
> -
> - drm_printf(p, "%#018llx-%#018llx: %llu\n", start, start + size, size);
> -}
> -
> -void i915_buddy_print(struct i915_buddy_mm *mm, struct drm_printer *p)
> -{
> - int order;
> -
> - drm_printf(p, "chunk_size: %lluKiB, total: %lluMiB, free: %lluMiB\n",
> - mm->chunk_size >> 10, mm->size >> 20, mm->avail >> 20);
> -
> - for (order = mm->max_order; order >= 0; order--) {
> - struct i915_buddy_block *block;
> - u64 count = 0, free;
> -
> - list_for_each_entry(block, &mm->free_list[order], link) {
> - GEM_BUG_ON(!i915_buddy_block_is_free(block));
> - count++;
> - }
> -
> - drm_printf(p, "order-%d ", order);
> -
> - free = count * (mm->chunk_size << order);
> - if (free < SZ_1M)
> - drm_printf(p, "free: %lluKiB", free >> 10);
> - else
> - drm_printf(p, "free: %lluMiB", free >> 20);
> -
> - drm_printf(p, ", pages: %llu\n", count);
> - }
> -}
> -
> -#if IS_ENABLED(CONFIG_DRM_I915_SELFTEST)
> -#include "selftests/i915_buddy.c"
> -#endif
> -
> -void i915_buddy_module_exit(void)
> -{
> - kmem_cache_destroy(slab_blocks);
> -}
> -
> -int __init i915_buddy_module_init(void)
> -{
> - slab_blocks = KMEM_CACHE(i915_buddy_block, 0);
> - if (!slab_blocks)
> - return -ENOMEM;
> -
> - return 0;
> -}
> diff --git a/drivers/gpu/drm/i915/i915_buddy.h b/drivers/gpu/drm/i915/i915_buddy.h
> deleted file mode 100644
> index 7077742112ac..000000000000
> --- a/drivers/gpu/drm/i915/i915_buddy.h
> +++ /dev/null
> @@ -1,143 +0,0 @@
> -/* SPDX-License-Identifier: MIT */
> -/*
> - * Copyright © 2021 Intel Corporation
> - */
> -
> -#ifndef __I915_BUDDY_H__
> -#define __I915_BUDDY_H__
> -
> -#include <linux/bitops.h>
> -#include <linux/list.h>
> -#include <linux/slab.h>
> -
> -#include <drm/drm_print.h>
> -
> -struct i915_buddy_block {
> -#define I915_BUDDY_HEADER_OFFSET GENMASK_ULL(63, 12)
> -#define I915_BUDDY_HEADER_STATE GENMASK_ULL(11, 10)
> -#define I915_BUDDY_ALLOCATED (1 << 10)
> -#define I915_BUDDY_FREE (2 << 10)
> -#define I915_BUDDY_SPLIT (3 << 10)
> -/* Free to be used, if needed in the future */
> -#define I915_BUDDY_HEADER_UNUSED GENMASK_ULL(9, 6)
> -#define I915_BUDDY_HEADER_ORDER GENMASK_ULL(5, 0)
> - u64 header;
> -
> - struct i915_buddy_block *left;
> - struct i915_buddy_block *right;
> - struct i915_buddy_block *parent;
> -
> - void *private; /* owned by creator */
> -
> - /*
> - * While the block is allocated by the user through i915_buddy_alloc*,
> - * the user has ownership of the link, for example to maintain within
> - * a list, if so desired. As soon as the block is freed with
> - * i915_buddy_free* ownership is given back to the mm.
> - */
> - struct list_head link;
> - struct list_head tmp_link;
> -};
> -
> -/* Order-zero must be at least PAGE_SIZE */
> -#define I915_BUDDY_MAX_ORDER (63 - PAGE_SHIFT)
> -
> -/*
> - * Binary Buddy System.
> - *
> - * Locking should be handled by the user, a simple mutex around
> - * i915_buddy_alloc* and i915_buddy_free* should suffice.
> - */
> -struct i915_buddy_mm {
> - /* Maintain a free list for each order. */
> - struct list_head *free_list;
> -
> - /*
> - * Maintain explicit binary tree(s) to track the allocation of the
> - * address space. This gives us a simple way of finding a buddy block
> - * and performing the potentially recursive merge step when freeing a
> - * block. Nodes are either allocated or free, in which case they will
> - * also exist on the respective free list.
> - */
> - struct i915_buddy_block **roots;
> -
> - /*
> - * Anything from here is public, and remains static for the lifetime of
> - * the mm. Everything above is considered do-not-touch.
> - */
> - unsigned int n_roots;
> - unsigned int max_order;
> -
> - /* Must be at least PAGE_SIZE */
> - u64 chunk_size;
> - u64 size;
> - u64 avail;
> -};
> -
> -static inline u64
> -i915_buddy_block_offset(struct i915_buddy_block *block)
> -{
> - return block->header & I915_BUDDY_HEADER_OFFSET;
> -}
> -
> -static inline unsigned int
> -i915_buddy_block_order(struct i915_buddy_block *block)
> -{
> - return block->header & I915_BUDDY_HEADER_ORDER;
> -}
> -
> -static inline unsigned int
> -i915_buddy_block_state(struct i915_buddy_block *block)
> -{
> - return block->header & I915_BUDDY_HEADER_STATE;
> -}
> -
> -static inline bool
> -i915_buddy_block_is_allocated(struct i915_buddy_block *block)
> -{
> - return i915_buddy_block_state(block) == I915_BUDDY_ALLOCATED;
> -}
> -
> -static inline bool
> -i915_buddy_block_is_free(struct i915_buddy_block *block)
> -{
> - return i915_buddy_block_state(block) == I915_BUDDY_FREE;
> -}
> -
> -static inline bool
> -i915_buddy_block_is_split(struct i915_buddy_block *block)
> -{
> - return i915_buddy_block_state(block) == I915_BUDDY_SPLIT;
> -}
> -
> -static inline u64
> -i915_buddy_block_size(struct i915_buddy_mm *mm,
> - struct i915_buddy_block *block)
> -{
> - return mm->chunk_size << i915_buddy_block_order(block);
> -}
> -
> -int i915_buddy_init(struct i915_buddy_mm *mm, u64 size, u64 chunk_size);
> -
> -void i915_buddy_fini(struct i915_buddy_mm *mm);
> -
> -struct i915_buddy_block *
> -i915_buddy_alloc(struct i915_buddy_mm *mm, unsigned int order);
> -
> -int i915_buddy_alloc_range(struct i915_buddy_mm *mm,
> - struct list_head *blocks,
> - u64 start, u64 size);
> -
> -void i915_buddy_free(struct i915_buddy_mm *mm, struct i915_buddy_block *block);
> -
> -void i915_buddy_free_list(struct i915_buddy_mm *mm, struct list_head *objects);
> -
> -void i915_buddy_print(struct i915_buddy_mm *mm, struct drm_printer *p);
> -void i915_buddy_block_print(struct i915_buddy_mm *mm,
> - struct i915_buddy_block *block,
> - struct drm_printer *p);
> -
> -void i915_buddy_module_exit(void);
> -int i915_buddy_module_init(void);
> -
> -#endif
> diff --git a/drivers/gpu/drm/i915/i915_module.c b/drivers/gpu/drm/i915/i915_module.c
> index c7507266aa83..355681dbd7a8 100644
> --- a/drivers/gpu/drm/i915/i915_module.c
> +++ b/drivers/gpu/drm/i915/i915_module.c
> @@ -9,7 +9,6 @@
> #include "gem/i915_gem_context.h"
> #include "gem/i915_gem_object.h"
> #include "i915_active.h"
> -#include "i915_buddy.h"
> #include "i915_params.h"
> #include "i915_pci.h"
> #include "i915_perf.h"
> @@ -50,8 +49,6 @@ static const struct {
> { .init = i915_check_nomodeset },
> { .init = i915_active_module_init,
> .exit = i915_active_module_exit },
> - { .init = i915_buddy_module_init,
> - .exit = i915_buddy_module_exit },
> { .init = i915_context_module_init,
> .exit = i915_context_module_exit },
> { .init = i915_gem_context_module_init,
> diff --git a/drivers/gpu/drm/i915/i915_scatterlist.c b/drivers/gpu/drm/i915/i915_scatterlist.c
> index 4a6712dca838..84d622aa32d2 100644
> --- a/drivers/gpu/drm/i915/i915_scatterlist.c
> +++ b/drivers/gpu/drm/i915/i915_scatterlist.c
> @@ -5,10 +5,9 @@
> */
>
> #include "i915_scatterlist.h"
> -
> -#include "i915_buddy.h"
> #include "i915_ttm_buddy_manager.h"
>
> +#include <drm/drm_buddy.h>
> #include <drm/drm_mm.h>
>
> #include <linux/slab.h>
> @@ -126,9 +125,9 @@ struct sg_table *i915_sg_from_buddy_resource(struct ttm_resource *res,
> struct i915_ttm_buddy_resource *bman_res = to_ttm_buddy_resource(res);
> const u64 size = res->num_pages << PAGE_SHIFT;
> const u64 max_segment = rounddown(UINT_MAX, PAGE_SIZE);
> - struct i915_buddy_mm *mm = bman_res->mm;
> + struct drm_buddy_mm *mm = bman_res->mm;
> struct list_head *blocks = &bman_res->blocks;
> - struct i915_buddy_block *block;
> + struct drm_buddy_block *block;
> struct scatterlist *sg;
> struct sg_table *st;
> resource_size_t prev_end;
> @@ -151,8 +150,8 @@ struct sg_table *i915_sg_from_buddy_resource(struct ttm_resource *res,
> list_for_each_entry(block, blocks, link) {
> u64 block_size, offset;
>
> - block_size = min_t(u64, size, i915_buddy_block_size(mm, block));
> - offset = i915_buddy_block_offset(block);
> + block_size = min_t(u64, size, drm_buddy_block_size(mm, block));
> + offset = drm_buddy_block_offset(block);
>
> while (block_size) {
> u64 len;
> diff --git a/drivers/gpu/drm/i915/i915_ttm_buddy_manager.c b/drivers/gpu/drm/i915/i915_ttm_buddy_manager.c
> index d59fbb019032..c4b70cb8c248 100644
> --- a/drivers/gpu/drm/i915/i915_ttm_buddy_manager.c
> +++ b/drivers/gpu/drm/i915/i915_ttm_buddy_manager.c
> @@ -8,14 +8,15 @@
> #include <drm/ttm/ttm_bo_driver.h>
> #include <drm/ttm/ttm_placement.h>
>
> +#include <drm/drm_buddy.h>
> +
> #include "i915_ttm_buddy_manager.h"
>
> -#include "i915_buddy.h"
> #include "i915_gem.h"
>
> struct i915_ttm_buddy_manager {
> struct ttm_resource_manager manager;
> - struct i915_buddy_mm mm;
> + struct drm_buddy_mm mm;
> struct list_head reserved;
> struct mutex lock;
> u64 default_page_size;
> @@ -34,7 +35,7 @@ static int i915_ttm_buddy_man_alloc(struct ttm_resource_manager *man,
> {
> struct i915_ttm_buddy_manager *bman = to_buddy_manager(man);
> struct i915_ttm_buddy_resource *bman_res;
> - struct i915_buddy_mm *mm = &bman->mm;
> + struct drm_buddy_mm *mm = &bman->mm;
> unsigned long n_pages;
> unsigned int min_order;
> u64 min_page_size;
> @@ -73,7 +74,7 @@ static int i915_ttm_buddy_man_alloc(struct ttm_resource_manager *man,
> n_pages = size >> ilog2(mm->chunk_size);
>
> do {
> - struct i915_buddy_block *block;
> + struct drm_buddy_block *block;
> unsigned int order;
>
> order = fls(n_pages) - 1;
> @@ -82,7 +83,7 @@ static int i915_ttm_buddy_man_alloc(struct ttm_resource_manager *man,
>
> do {
> mutex_lock(&bman->lock);
> - block = i915_buddy_alloc(mm, order);
> + block = drm_buddy_alloc(mm, order);
> mutex_unlock(&bman->lock);
> if (!IS_ERR(block))
> break;
> @@ -106,7 +107,7 @@ static int i915_ttm_buddy_man_alloc(struct ttm_resource_manager *man,
>
> err_free_blocks:
> mutex_lock(&bman->lock);
> - i915_buddy_free_list(mm, &bman_res->blocks);
> + drm_buddy_free_list(mm, &bman_res->blocks);
> mutex_unlock(&bman->lock);
> err_free_res:
> kfree(bman_res);
> @@ -120,7 +121,7 @@ static void i915_ttm_buddy_man_free(struct ttm_resource_manager *man,
> struct i915_ttm_buddy_manager *bman = to_buddy_manager(man);
>
> mutex_lock(&bman->lock);
> - i915_buddy_free_list(&bman->mm, &bman_res->blocks);
> + drm_buddy_free_list(&bman->mm, &bman_res->blocks);
> mutex_unlock(&bman->lock);
>
> kfree(bman_res);
> @@ -130,17 +131,17 @@ static void i915_ttm_buddy_man_debug(struct ttm_resource_manager *man,
> struct drm_printer *printer)
> {
> struct i915_ttm_buddy_manager *bman = to_buddy_manager(man);
> - struct i915_buddy_block *block;
> + struct drm_buddy_block *block;
>
> mutex_lock(&bman->lock);
> drm_printf(printer, "default_page_size: %lluKiB\n",
> bman->default_page_size >> 10);
>
> - i915_buddy_print(&bman->mm, printer);
> + drm_buddy_print(&bman->mm, printer);
>
> drm_printf(printer, "reserved:\n");
> list_for_each_entry(block, &bman->reserved, link)
> - i915_buddy_block_print(&bman->mm, block, printer);
> + drm_buddy_block_print(&bman->mm, block, printer);
> mutex_unlock(&bman->lock);
> }
>
> @@ -190,7 +191,7 @@ int i915_ttm_buddy_man_init(struct ttm_device *bdev,
> if (!bman)
> return -ENOMEM;
>
> - err = i915_buddy_init(&bman->mm, size, chunk_size);
> + err = drm_buddy_init(&bman->mm, size, chunk_size);
> if (err)
> goto err_free_bman;
>
> @@ -228,7 +229,7 @@ int i915_ttm_buddy_man_fini(struct ttm_device *bdev, unsigned int type)
> {
> struct ttm_resource_manager *man = ttm_manager_type(bdev, type);
> struct i915_ttm_buddy_manager *bman = to_buddy_manager(man);
> - struct i915_buddy_mm *mm = &bman->mm;
> + struct drm_buddy_mm *mm = &bman->mm;
> int ret;
>
> ttm_resource_manager_set_used(man, false);
> @@ -240,8 +241,8 @@ int i915_ttm_buddy_man_fini(struct ttm_device *bdev, unsigned int type)
> ttm_set_driver_manager(bdev, type, NULL);
>
> mutex_lock(&bman->lock);
> - i915_buddy_free_list(mm, &bman->reserved);
> - i915_buddy_fini(mm);
> + drm_buddy_free_list(mm, &bman->reserved);
> + drm_buddy_fini(mm);
> mutex_unlock(&bman->lock);
>
> ttm_resource_manager_cleanup(man);
> @@ -264,11 +265,11 @@ int i915_ttm_buddy_man_reserve(struct ttm_resource_manager *man,
> u64 start, u64 size)
> {
> struct i915_ttm_buddy_manager *bman = to_buddy_manager(man);
> - struct i915_buddy_mm *mm = &bman->mm;
> + struct drm_buddy_mm *mm = &bman->mm;
> int ret;
>
> mutex_lock(&bman->lock);
> - ret = i915_buddy_alloc_range(mm, &bman->reserved, start, size);
> + ret = drm_buddy_alloc_range(mm, &bman->reserved, start, size);
> mutex_unlock(&bman->lock);
>
> return ret;
> diff --git a/drivers/gpu/drm/i915/i915_ttm_buddy_manager.h b/drivers/gpu/drm/i915/i915_ttm_buddy_manager.h
> index 0722d33f3e14..fa644b512c2e 100644
> --- a/drivers/gpu/drm/i915/i915_ttm_buddy_manager.h
> +++ b/drivers/gpu/drm/i915/i915_ttm_buddy_manager.h
> @@ -13,7 +13,7 @@
>
> struct ttm_device;
> struct ttm_resource_manager;
> -struct i915_buddy_mm;
> +struct drm_buddy_mm;
>
> /**
> * struct i915_ttm_buddy_resource
> @@ -28,7 +28,7 @@ struct i915_buddy_mm;
> struct i915_ttm_buddy_resource {
> struct ttm_resource base;
> struct list_head blocks;
> - struct i915_buddy_mm *mm;
> + struct drm_buddy_mm *mm;
> };
>
> /**
> diff --git a/include/drm/drm_buddy.h b/include/drm/drm_buddy.h
> new file mode 100644
> index 000000000000..5ce3fc702f80
> --- /dev/null
> +++ b/include/drm/drm_buddy.h
> @@ -0,0 +1,153 @@
> +/* SPDX-License-Identifier: MIT */
> +/*
> + * Copyright © 2021 Intel Corporation
> + */
> +
> +#ifndef __DRM_BUDDY_H__
> +#define __DRM_BUDDY_H__
> +
> +#include <linux/bitops.h>
> +#include <linux/list.h>
> +#include <linux/slab.h>
> +#include <linux/sched.h>
> +
> +#include <drm/drm_print.h>
> +
> +#define range_overflows(start, size, max) ({ \
> + typeof(start) start__ = (start); \
> + typeof(size) size__ = (size); \
> + typeof(max) max__ = (max); \
> + (void)(&start__ == &size__); \
> + (void)(&start__ == &max__); \
> + start__ >= max__ || size__ > max__ - start__; \
> +})
> +
> +struct drm_buddy_block {
> +#define DRM_BUDDY_HEADER_OFFSET GENMASK_ULL(63, 12)
> +#define DRM_BUDDY_HEADER_STATE GENMASK_ULL(11, 10)
> +#define DRM_BUDDY_ALLOCATED (1 << 10)
> +#define DRM_BUDDY_FREE (2 << 10)
> +#define DRM_BUDDY_SPLIT (3 << 10)
> +/* Free to be used, if needed in the future */
> +#define DRM_BUDDY_HEADER_UNUSED GENMASK_ULL(9, 6)
> +#define DRM_BUDDY_HEADER_ORDER GENMASK_ULL(5, 0)
> + u64 header;
> +
> + struct drm_buddy_block *left;
> + struct drm_buddy_block *right;
> + struct drm_buddy_block *parent;
> +
> + void *private; /* owned by creator */
> +
> + /*
> + * While the block is allocated by the user through drm_buddy_alloc*,
> + * the user has ownership of the link, for example to maintain within
> + * a list, if so desired. As soon as the block is freed with
> + * drm_buddy_free* ownership is given back to the mm.
> + */
> + struct list_head link;
> + struct list_head tmp_link;
> +};
> +
> +/* Order-zero must be at least PAGE_SIZE */
> +#define DRM_BUDDY_MAX_ORDER (63 - PAGE_SHIFT)
> +
> +/*
> + * Binary Buddy System.
> + *
> + * Locking should be handled by the user, a simple mutex around
> + * drm_buddy_alloc* and drm_buddy_free* should suffice.
> + */
> +struct drm_buddy_mm {
> + /* Maintain a free list for each order. */
> + struct list_head *free_list;
> +
> + /*
> + * Maintain explicit binary tree(s) to track the allocation of the
> + * address space. This gives us a simple way of finding a buddy block
> + * and performing the potentially recursive merge step when freeing a
> + * block. Nodes are either allocated or free, in which case they will
> + * also exist on the respective free list.
> + */
> + struct drm_buddy_block **roots;
> +
> + /*
> + * Anything from here is public, and remains static for the lifetime of
> + * the mm. Everything above is considered do-not-touch.
> + */
> + unsigned int n_roots;
> + unsigned int max_order;
> +
> + /* Must be at least PAGE_SIZE */
> + u64 chunk_size;
> + u64 size;
> + u64 avail;
> +};
> +
> +static inline u64
> +drm_buddy_block_offset(struct drm_buddy_block *block)
> +{
> + return block->header & DRM_BUDDY_HEADER_OFFSET;
> +}
> +
> +static inline unsigned int
> +drm_buddy_block_order(struct drm_buddy_block *block)
> +{
> + return block->header & DRM_BUDDY_HEADER_ORDER;
> +}
> +
> +static inline unsigned int
> +drm_buddy_block_state(struct drm_buddy_block *block)
> +{
> + return block->header & DRM_BUDDY_HEADER_STATE;
> +}
> +
> +static inline bool
> +drm_buddy_block_is_allocated(struct drm_buddy_block *block)
> +{
> + return drm_buddy_block_state(block) == DRM_BUDDY_ALLOCATED;
> +}
> +
> +static inline bool
> +drm_buddy_block_is_free(struct drm_buddy_block *block)
> +{
> + return drm_buddy_block_state(block) == DRM_BUDDY_FREE;
> +}
> +
> +static inline bool
> +drm_buddy_block_is_split(struct drm_buddy_block *block)
> +{
> + return drm_buddy_block_state(block) == DRM_BUDDY_SPLIT;
> +}
> +
> +static inline u64
> +drm_buddy_block_size(struct drm_buddy_mm *mm,
> + struct drm_buddy_block *block)
> +{
> + return mm->chunk_size << drm_buddy_block_order(block);
> +}
> +
> +int drm_buddy_init(struct drm_buddy_mm *mm, u64 size, u64 chunk_size);
> +
> +void drm_buddy_fini(struct drm_buddy_mm *mm);
> +
> +struct drm_buddy_block *
> +drm_buddy_alloc(struct drm_buddy_mm *mm, unsigned int order);
> +
> +int drm_buddy_alloc_range(struct drm_buddy_mm *mm,
> + struct list_head *blocks,
> + u64 start, u64 size);
> +
> +void drm_buddy_free(struct drm_buddy_mm *mm, struct drm_buddy_block *block);
> +
> +void drm_buddy_free_list(struct drm_buddy_mm *mm, struct list_head *objects);
> +
> +void drm_buddy_print(struct drm_buddy_mm *mm, struct drm_printer *p);
> +void drm_buddy_block_print(struct drm_buddy_mm *mm,
> + struct drm_buddy_block *block,
> + struct drm_printer *p);
> +
> +void drm_buddy_module_exit(void);
> +int drm_buddy_module_init(void);
> +
> +#endif
^ permalink raw reply [flat|nested] 46+ messages in thread
* Re: [PATCH v3 1/6] drm: move the buddy allocator from i915 into common drm
2021-11-17 8:03 ` Christian König
(?)
@ 2021-11-17 17:05 ` Arunpravin
-1 siblings, 0 replies; 46+ messages in thread
From: Arunpravin @ 2021-11-17 17:05 UTC (permalink / raw)
To: Christian König, dri-devel, intel-gfx, amd-gfx
Cc: matthew.auld, tzimmermann, alexander.deucher, christian.koenig
Hi Christian,
I will make this a separate module.
Thanks,
Arun
On 17/11/21 1:33 pm, Christian König wrote:
> I've looked a bit more into this and I think we should just follow
> Thomas Zimmermann's idea to make this a separate module.
>
> Otherwise we just have the code around all the time even if it is unused
> and implementing this should be trivial.
>
> See how DRM_GEM_CMA_HELPER or DRM_VRAM_HELPER are done in
> drivers/gpu/drm/Kconfig and then have the desired effect in
> drivers/gpu/drm/Makefile
>
> Should be something like ~15 lines of additional configuration which
> saves a bit of memory on embedded systems which just need a fbdev
> replacement.
>
> Thanks,
> Christian.
>
> Am 16.11.21 um 21:18 schrieb Arunpravin:
>> Move the base i915 buddy allocator code into drm
>> - Move i915_buddy.h to include/drm
>> - Move i915_buddy.c to drm root folder
>> - Rename "i915" string with "drm" string wherever applicable
>> - Rename "I915" string with "DRM" string wherever applicable
>> - Fix header file dependencies
>> - Fix alignment issues
>> - add Makefile support for drm buddy
>> - export functions and write kerneldoc description
>> - Remove i915 selftest config check condition as buddy selftest
>> will be moved to drm selftest folder
>>
>> cleanup i915 buddy references in i915 driver module
>> and replace with drm buddy
>>
>> v2:
>> - include header file in alphabetical order (Thomas)
>> - merged changes listed in the body section into a single patch
>> to keep the build intact (Christian, Jani)
>>
>> Signed-off-by: Arunpravin <Arunpravin.PaneerSelvam@amd.com>
>> ---
>> drivers/gpu/drm/Makefile | 2 +-
>> drivers/gpu/drm/drm_buddy.c | 521 ++++++++++++++++++
>> drivers/gpu/drm/drm_drv.c | 3 +
>> drivers/gpu/drm/i915/Makefile | 1 -
>> drivers/gpu/drm/i915/i915_buddy.c | 466 ----------------
>> drivers/gpu/drm/i915/i915_buddy.h | 143 -----
>> drivers/gpu/drm/i915/i915_module.c | 3 -
>> drivers/gpu/drm/i915/i915_scatterlist.c | 11 +-
>> drivers/gpu/drm/i915/i915_ttm_buddy_manager.c | 33 +-
>> drivers/gpu/drm/i915/i915_ttm_buddy_manager.h | 4 +-
>> include/drm/drm_buddy.h | 153 +++++
>> 11 files changed, 702 insertions(+), 638 deletions(-)
>> create mode 100644 drivers/gpu/drm/drm_buddy.c
>> delete mode 100644 drivers/gpu/drm/i915/i915_buddy.c
>> delete mode 100644 drivers/gpu/drm/i915/i915_buddy.h
>> create mode 100644 include/drm/drm_buddy.h
>>
>> diff --git a/drivers/gpu/drm/Makefile b/drivers/gpu/drm/Makefile
>> index 0dff40bb863c..dc61e91a3154 100644
>> --- a/drivers/gpu/drm/Makefile
>> +++ b/drivers/gpu/drm/Makefile
>> @@ -18,7 +18,7 @@ drm-y := drm_aperture.o drm_auth.o drm_cache.o \
>> drm_dumb_buffers.o drm_mode_config.o drm_vblank.o \
>> drm_syncobj.o drm_lease.o drm_writeback.o drm_client.o \
>> drm_client_modeset.o drm_atomic_uapi.o drm_hdcp.o \
>> - drm_managed.o drm_vblank_work.o
>> + drm_managed.o drm_vblank_work.o drm_buddy.o
>>
>> drm-$(CONFIG_DRM_LEGACY) += drm_agpsupport.o drm_bufs.o drm_context.o drm_dma.o \
>> drm_legacy_misc.o drm_lock.o drm_memory.o drm_scatter.o \
>> diff --git a/drivers/gpu/drm/drm_buddy.c b/drivers/gpu/drm/drm_buddy.c
>> new file mode 100644
>> index 000000000000..39eb1d224bec
>> --- /dev/null
>> +++ b/drivers/gpu/drm/drm_buddy.c
>> @@ -0,0 +1,521 @@
>> +// SPDX-License-Identifier: MIT
>> +/*
>> + * Copyright © 2021 Intel Corporation
>> + */
>> +
>> +#include <linux/kmemleak.h>
>> +#include <linux/sizes.h>
>> +
>> +#include <drm/drm_buddy.h>
>> +
>> +static struct kmem_cache *slab_blocks;
>> +
>> +static struct drm_buddy_block *drm_block_alloc(struct drm_buddy_mm *mm,
>> + struct drm_buddy_block *parent,
>> + unsigned int order,
>> + u64 offset)
>> +{
>> + struct drm_buddy_block *block;
>> +
>> + BUG_ON(order > DRM_BUDDY_MAX_ORDER);
>> +
>> + block = kmem_cache_zalloc(slab_blocks, GFP_KERNEL);
>> + if (!block)
>> + return NULL;
>> +
>> + block->header = offset;
>> + block->header |= order;
>> + block->parent = parent;
>> +
>> + BUG_ON(block->header & DRM_BUDDY_HEADER_UNUSED);
>> + return block;
>> +}
>> +
>> +static void drm_block_free(struct drm_buddy_mm *mm,
>> + struct drm_buddy_block *block)
>> +{
>> + kmem_cache_free(slab_blocks, block);
>> +}
>> +
>> +static void mark_allocated(struct drm_buddy_block *block)
>> +{
>> + block->header &= ~DRM_BUDDY_HEADER_STATE;
>> + block->header |= DRM_BUDDY_ALLOCATED;
>> +
>> + list_del(&block->link);
>> +}
>> +
>> +static void mark_free(struct drm_buddy_mm *mm,
>> + struct drm_buddy_block *block)
>> +{
>> + block->header &= ~DRM_BUDDY_HEADER_STATE;
>> + block->header |= DRM_BUDDY_FREE;
>> +
>> + list_add(&block->link,
>> + &mm->free_list[drm_buddy_block_order(block)]);
>> +}
>> +
>> +static void mark_split(struct drm_buddy_block *block)
>> +{
>> + block->header &= ~DRM_BUDDY_HEADER_STATE;
>> + block->header |= DRM_BUDDY_SPLIT;
>> +
>> + list_del(&block->link);
>> +}
>> +
>> +/**
>> + * drm_buddy_init - init memory manager
>> + *
>> + * @mm: DRM buddy manager to initialize
>> + * @size: size in bytes to manage
>> + * @chunk_size: minimum page size in bytes for our allocations
>> + *
>> + * Initializes the memory manager and its resources.
>> + *
>> + * Returns:
>> + * 0 on success, error code on failure.
>> + */
>> +int drm_buddy_init(struct drm_buddy_mm *mm, u64 size, u64 chunk_size)
>> +{
>> + unsigned int i;
>> + u64 offset;
>> +
>> + if (size < chunk_size)
>> + return -EINVAL;
>> +
>> + if (chunk_size < PAGE_SIZE)
>> + return -EINVAL;
>> +
>> + if (!is_power_of_2(chunk_size))
>> + return -EINVAL;
>> +
>> + size = round_down(size, chunk_size);
>> +
>> + mm->size = size;
>> + mm->avail = size;
>> + mm->chunk_size = chunk_size;
>> + mm->max_order = ilog2(size) - ilog2(chunk_size);
>> +
>> + BUG_ON(mm->max_order > DRM_BUDDY_MAX_ORDER);
>> +
>> + mm->free_list = kmalloc_array(mm->max_order + 1,
>> + sizeof(struct list_head),
>> + GFP_KERNEL);
>> + if (!mm->free_list)
>> + return -ENOMEM;
>> +
>> + for (i = 0; i <= mm->max_order; ++i)
>> + INIT_LIST_HEAD(&mm->free_list[i]);
>> +
>> + mm->n_roots = hweight64(size);
>> +
>> + mm->roots = kmalloc_array(mm->n_roots,
>> + sizeof(struct drm_buddy_block *),
>> + GFP_KERNEL);
>> + if (!mm->roots)
>> + goto out_free_list;
>> +
>> + offset = 0;
>> + i = 0;
>> +
>> + /*
>> + * Split into power-of-two blocks, in case we are given a size that is
>> + * not itself a power-of-two.
>> + */
>> + do {
>> + struct drm_buddy_block *root;
>> + unsigned int order;
>> + u64 root_size;
>> +
>> + root_size = rounddown_pow_of_two(size);
>> + order = ilog2(root_size) - ilog2(chunk_size);
>> +
>> + root = drm_block_alloc(mm, NULL, order, offset);
>> + if (!root)
>> + goto out_free_roots;
>> +
>> + mark_free(mm, root);
>> +
>> + BUG_ON(i > mm->max_order);
>> + BUG_ON(drm_buddy_block_size(mm, root) < chunk_size);
>> +
>> + mm->roots[i] = root;
>> +
>> + offset += root_size;
>> + size -= root_size;
>> + i++;
>> + } while (size);
>> +
>> + return 0;
>> +
>> +out_free_roots:
>> + while (i--)
>> + drm_block_free(mm, mm->roots[i]);
>> + kfree(mm->roots);
>> +out_free_list:
>> + kfree(mm->free_list);
>> + return -ENOMEM;
>> +}
>> +EXPORT_SYMBOL(drm_buddy_init);
>> +
>> +/**
>> + * drm_buddy_fini - tear down the memory manager
>> + *
>> + * @mm: DRM buddy manager to free
>> + *
>> + * Cleanup memory manager resources and the freelist
>> + */
>> +void drm_buddy_fini(struct drm_buddy_mm *mm)
>> +{
>> + int i;
>> +
>> + for (i = 0; i < mm->n_roots; ++i) {
>> + WARN_ON(!drm_buddy_block_is_free(mm->roots[i]));
>> + drm_block_free(mm, mm->roots[i]);
>> + }
>> +
>> + WARN_ON(mm->avail != mm->size);
>> +
>> + kfree(mm->roots);
>> + kfree(mm->free_list);
>> +}
>> +EXPORT_SYMBOL(drm_buddy_fini);
>> +
>> +static int split_block(struct drm_buddy_mm *mm,
>> + struct drm_buddy_block *block)
>> +{
>> + unsigned int block_order = drm_buddy_block_order(block) - 1;
>> + u64 offset = drm_buddy_block_offset(block);
>> +
>> + BUG_ON(!drm_buddy_block_is_free(block));
>> + BUG_ON(!drm_buddy_block_order(block));
>> +
>> + block->left = drm_block_alloc(mm, block, block_order, offset);
>> + if (!block->left)
>> + return -ENOMEM;
>> +
>> + block->right = drm_block_alloc(mm, block, block_order,
>> + offset + (mm->chunk_size << block_order));
>> + if (!block->right) {
>> + drm_block_free(mm, block->left);
>> + return -ENOMEM;
>> + }
>> +
>> + mark_free(mm, block->left);
>> + mark_free(mm, block->right);
>> +
>> + mark_split(block);
>> +
>> + return 0;
>> +}
>> +
>> +static struct drm_buddy_block *
>> +get_buddy(struct drm_buddy_block *block)
>> +{
>> + struct drm_buddy_block *parent;
>> +
>> + parent = block->parent;
>> + if (!parent)
>> + return NULL;
>> +
>> + if (parent->left == block)
>> + return parent->right;
>> +
>> + return parent->left;
>> +}
>> +
>> +static void __drm_buddy_free(struct drm_buddy_mm *mm,
>> + struct drm_buddy_block *block)
>> +{
>> + struct drm_buddy_block *parent;
>> +
>> + while ((parent = block->parent)) {
>> + struct drm_buddy_block *buddy;
>> +
>> + buddy = get_buddy(block);
>> +
>> + if (!drm_buddy_block_is_free(buddy))
>> + break;
>> +
>> + list_del(&buddy->link);
>> +
>> + drm_block_free(mm, block);
>> + drm_block_free(mm, buddy);
>> +
>> + block = parent;
>> + }
>> +
>> + mark_free(mm, block);
>> +}
>> +
>> +void drm_buddy_free(struct drm_buddy_mm *mm,
>> + struct drm_buddy_block *block)
>> +{
>> + BUG_ON(!drm_buddy_block_is_allocated(block));
>> + mm->avail += drm_buddy_block_size(mm, block);
>> + __drm_buddy_free(mm, block);
>> +}
>> +
>> +/**
>> + * drm_buddy_free_list - free blocks
>> + *
>> + * @mm: DRM buddy manager
>> + * @objects: input list head to free blocks
>> + */
>> +void drm_buddy_free_list(struct drm_buddy_mm *mm, struct list_head *objects)
>> +{
>> + struct drm_buddy_block *block, *on;
>> +
>> + list_for_each_entry_safe(block, on, objects, link) {
>> + drm_buddy_free(mm, block);
>> + cond_resched();
>> + }
>> + INIT_LIST_HEAD(objects);
>> +}
>> +EXPORT_SYMBOL(drm_buddy_free_list);
>> +
>> +/**
>> + * drm_buddy_alloc - allocate power-of-two blocks
>> + *
>> + * @mm: DRM buddy manager to allocate from
>> + * @order: size of the allocation
>> + *
>> + * The order value here translates to:
>> + *
>> + * 0 = 2^0 * mm->chunk_size
>> + * 1 = 2^1 * mm->chunk_size
>> + * 2 = 2^2 * mm->chunk_size
>> + *
>> + * Returns:
>> + * allocated ptr to the &drm_buddy_block on success
>> + */
>> +struct drm_buddy_block *
>> +drm_buddy_alloc(struct drm_buddy_mm *mm, unsigned int order)
>> +{
>> + struct drm_buddy_block *block = NULL;
>> + unsigned int i;
>> + int err;
>> +
>> + for (i = order; i <= mm->max_order; ++i) {
>> + block = list_first_entry_or_null(&mm->free_list[i],
>> + struct drm_buddy_block,
>> + link);
>> + if (block)
>> + break;
>> + }
>> +
>> + if (!block)
>> + return ERR_PTR(-ENOSPC);
>> +
>> + BUG_ON(!drm_buddy_block_is_free(block));
>> +
>> + while (i != order) {
>> + err = split_block(mm, block);
>> + if (unlikely(err))
>> + goto out_free;
>> +
>> + /* Go low */
>> + block = block->left;
>> + i--;
>> + }
>> +
>> + mark_allocated(block);
>> + mm->avail -= drm_buddy_block_size(mm, block);
>> + kmemleak_update_trace(block);
>> + return block;
>> +
>> +out_free:
>> + if (i != order)
>> + __drm_buddy_free(mm, block);
>> + return ERR_PTR(err);
>> +}
>> +EXPORT_SYMBOL(drm_buddy_alloc);
>> +
>> +static inline bool overlaps(u64 s1, u64 e1, u64 s2, u64 e2)
>> +{
>> + return s1 <= e2 && e1 >= s2;
>> +}
>> +
>> +static inline bool contains(u64 s1, u64 e1, u64 s2, u64 e2)
>> +{
>> + return s1 <= s2 && e1 >= e2;
>> +}
>> +
>> +/**
>> + * drm_buddy_alloc_range - allocate range
>> + *
>> + * @mm: DRM buddy manager to allocate from
>> + * @blocks: output list head to add allocated blocks
>> + * @start: start of the allowed range for this block
>> + * @size: size of the allocation
>> + *
>> + * Intended for pre-allocating portions of the address space, for example to
>> + * reserve a block for the initial framebuffer or similar, hence the expectation
>> + * here is that drm_buddy_alloc() is still the main vehicle for
>> + * allocations, so if that's not the case then the drm_mm range allocator is
>> + * probably a much better fit, and so you should probably go use that instead.
>> + *
>> + * Note that it's safe to chain together multiple alloc_ranges
>> + * with the same blocks list
>> + *
>> + * Returns:
>> + * 0 on success, error code on failure.
>> + */
>> +int drm_buddy_alloc_range(struct drm_buddy_mm *mm,
>> + struct list_head *blocks,
>> + u64 start, u64 size)
>> +{
>> + struct drm_buddy_block *block;
>> + struct drm_buddy_block *buddy;
>> + LIST_HEAD(allocated);
>> + LIST_HEAD(dfs);
>> + u64 end;
>> + int err;
>> + int i;
>> +
>> + if (size < mm->chunk_size)
>> + return -EINVAL;
>> +
>> + if (!IS_ALIGNED(size | start, mm->chunk_size))
>> + return -EINVAL;
>> +
>> + if (range_overflows(start, size, mm->size))
>> + return -EINVAL;
>> +
>> + for (i = 0; i < mm->n_roots; ++i)
>> + list_add_tail(&mm->roots[i]->tmp_link, &dfs);
>> +
>> + end = start + size - 1;
>> +
>> + do {
>> + u64 block_start;
>> + u64 block_end;
>> +
>> + block = list_first_entry_or_null(&dfs,
>> + struct drm_buddy_block,
>> + tmp_link);
>> + if (!block)
>> + break;
>> +
>> + list_del(&block->tmp_link);
>> +
>> + block_start = drm_buddy_block_offset(block);
>> + block_end = block_start + drm_buddy_block_size(mm, block) - 1;
>> +
>> + if (!overlaps(start, end, block_start, block_end))
>> + continue;
>> +
>> + if (drm_buddy_block_is_allocated(block)) {
>> + err = -ENOSPC;
>> + goto err_free;
>> + }
>> +
>> + if (contains(start, end, block_start, block_end)) {
>> + if (!drm_buddy_block_is_free(block)) {
>> + err = -ENOSPC;
>> + goto err_free;
>> + }
>> +
>> + mark_allocated(block);
>> + mm->avail -= drm_buddy_block_size(mm, block);
>> + list_add_tail(&block->link, &allocated);
>> + continue;
>> + }
>> +
>> + if (!drm_buddy_block_is_split(block)) {
>> + err = split_block(mm, block);
>> + if (unlikely(err))
>> + goto err_undo;
>> + }
>> +
>> + list_add(&block->right->tmp_link, &dfs);
>> + list_add(&block->left->tmp_link, &dfs);
>> + } while (1);
>> +
>> + list_splice_tail(&allocated, blocks);
>> + return 0;
>> +
>> +err_undo:
>> + /*
>> + * We really don't want to leave around a bunch of split blocks, since
>> + * bigger is better, so make sure we merge everything back before we
>> + * free the allocated blocks.
>> + */
>> + buddy = get_buddy(block);
>> + if (buddy &&
>> + (drm_buddy_block_is_free(block) &&
>> + drm_buddy_block_is_free(buddy)))
>> + __drm_buddy_free(mm, block);
>> +
>> +err_free:
>> + drm_buddy_free_list(mm, &allocated);
>> + return err;
>> +}
>> +EXPORT_SYMBOL(drm_buddy_alloc_range);
>> +
>> +/**
>> + * drm_buddy_block_print - print block information
>> + *
>> + * @mm: DRM buddy manager
>> + * @block: DRM buddy block
>> + * @p: DRM printer to use
>> + */
>> +void drm_buddy_block_print(struct drm_buddy_mm *mm,
>> + struct drm_buddy_block *block,
>> + struct drm_printer *p)
>> +{
>> + u64 start = drm_buddy_block_offset(block);
>> + u64 size = drm_buddy_block_size(mm, block);
>> +
>> + drm_printf(p, "%#018llx-%#018llx: %llu\n", start, start + size, size);
>> +}
>> +EXPORT_SYMBOL(drm_buddy_block_print);
>> +
>> +/**
>> + * drm_buddy_print - print allocator state
>> + *
>> + * @mm: DRM buddy manager
>> + * @p: DRM printer to use
>> + */
>> +void drm_buddy_print(struct drm_buddy_mm *mm, struct drm_printer *p)
>> +{
>> + int order;
>> +
>> + drm_printf(p, "chunk_size: %lluKiB, total: %lluMiB, free: %lluMiB\n",
>> + mm->chunk_size >> 10, mm->size >> 20, mm->avail >> 20);
>> +
>> + for (order = mm->max_order; order >= 0; order--) {
>> + struct drm_buddy_block *block;
>> + u64 count = 0, free;
>> +
>> + list_for_each_entry(block, &mm->free_list[order], link) {
>> + BUG_ON(!drm_buddy_block_is_free(block));
>> + count++;
>> + }
>> +
>> + drm_printf(p, "order-%d ", order);
>> +
>> + free = count * (mm->chunk_size << order);
>> + if (free < SZ_1M)
>> + drm_printf(p, "free: %lluKiB", free >> 10);
>> + else
>> + drm_printf(p, "free: %lluMiB", free >> 20);
>> +
>> + drm_printf(p, ", pages: %llu\n", count);
>> + }
>> +}
>> +EXPORT_SYMBOL(drm_buddy_print);
>> +
>> +void drm_buddy_module_exit(void)
>> +{
>> + kmem_cache_destroy(slab_blocks);
>> +}
>> +
>> +int __init drm_buddy_module_init(void)
>> +{
>> + slab_blocks = KMEM_CACHE(drm_buddy_block, 0);
>> + if (!slab_blocks)
>> + return -ENOMEM;
>> +
>> + return 0;
>> +}
>> diff --git a/drivers/gpu/drm/drm_drv.c b/drivers/gpu/drm/drm_drv.c
>> index 7a5097467ba5..5d5e46e60586 100644
>> --- a/drivers/gpu/drm/drm_drv.c
>> +++ b/drivers/gpu/drm/drm_drv.c
>> @@ -35,6 +35,7 @@
>> #include <linux/slab.h>
>> #include <linux/srcu.h>
>>
>> +#include <drm/drm_buddy.h>
>> #include <drm/drm_cache.h>
>> #include <drm/drm_client.h>
>> #include <drm/drm_color_mgmt.h>
>> @@ -1034,6 +1035,7 @@ static void drm_core_exit(void)
>> drm_sysfs_destroy();
>> idr_destroy(&drm_minors_idr);
>> drm_connector_ida_destroy();
>> + drm_buddy_module_exit();
>> }
>>
>> static int __init drm_core_init(void)
>> @@ -1043,6 +1045,7 @@ static int __init drm_core_init(void)
>> drm_connector_ida_init();
>> idr_init(&drm_minors_idr);
>> drm_memcpy_init_early();
>> + drm_buddy_module_init();
>>
>> ret = drm_sysfs_init();
>> if (ret < 0) {
>> diff --git a/drivers/gpu/drm/i915/Makefile b/drivers/gpu/drm/i915/Makefile
>> index 467872cca027..fc5ca8c4ccb2 100644
>> --- a/drivers/gpu/drm/i915/Makefile
>> +++ b/drivers/gpu/drm/i915/Makefile
>> @@ -161,7 +161,6 @@ gem-y += \
>> i915-y += \
>> $(gem-y) \
>> i915_active.o \
>> - i915_buddy.o \
>> i915_cmd_parser.o \
>> i915_gem_evict.o \
>> i915_gem_gtt.o \
>> diff --git a/drivers/gpu/drm/i915/i915_buddy.c b/drivers/gpu/drm/i915/i915_buddy.c
>> deleted file mode 100644
>> index 6e2ad68f8f3f..000000000000
>> --- a/drivers/gpu/drm/i915/i915_buddy.c
>> +++ /dev/null
>> @@ -1,466 +0,0 @@
>> -// SPDX-License-Identifier: MIT
>> -/*
>> - * Copyright © 2021 Intel Corporation
>> - */
>> -
>> -#include <linux/kmemleak.h>
>> -#include <linux/sizes.h>
>> -
>> -#include "i915_buddy.h"
>> -
>> -#include "i915_gem.h"
>> -#include "i915_utils.h"
>> -
>> -static struct kmem_cache *slab_blocks;
>> -
>> -static struct i915_buddy_block *i915_block_alloc(struct i915_buddy_mm *mm,
>> - struct i915_buddy_block *parent,
>> - unsigned int order,
>> - u64 offset)
>> -{
>> - struct i915_buddy_block *block;
>> -
>> - GEM_BUG_ON(order > I915_BUDDY_MAX_ORDER);
>> -
>> - block = kmem_cache_zalloc(slab_blocks, GFP_KERNEL);
>> - if (!block)
>> - return NULL;
>> -
>> - block->header = offset;
>> - block->header |= order;
>> - block->parent = parent;
>> -
>> - GEM_BUG_ON(block->header & I915_BUDDY_HEADER_UNUSED);
>> - return block;
>> -}
>> -
>> -static void i915_block_free(struct i915_buddy_mm *mm,
>> - struct i915_buddy_block *block)
>> -{
>> - kmem_cache_free(slab_blocks, block);
>> -}
>> -
>> -static void mark_allocated(struct i915_buddy_block *block)
>> -{
>> - block->header &= ~I915_BUDDY_HEADER_STATE;
>> - block->header |= I915_BUDDY_ALLOCATED;
>> -
>> - list_del(&block->link);
>> -}
>> -
>> -static void mark_free(struct i915_buddy_mm *mm,
>> - struct i915_buddy_block *block)
>> -{
>> - block->header &= ~I915_BUDDY_HEADER_STATE;
>> - block->header |= I915_BUDDY_FREE;
>> -
>> - list_add(&block->link,
>> - &mm->free_list[i915_buddy_block_order(block)]);
>> -}
>> -
>> -static void mark_split(struct i915_buddy_block *block)
>> -{
>> - block->header &= ~I915_BUDDY_HEADER_STATE;
>> - block->header |= I915_BUDDY_SPLIT;
>> -
>> - list_del(&block->link);
>> -}
>> -
>> -int i915_buddy_init(struct i915_buddy_mm *mm, u64 size, u64 chunk_size)
>> -{
>> - unsigned int i;
>> - u64 offset;
>> -
>> - if (size < chunk_size)
>> - return -EINVAL;
>> -
>> - if (chunk_size < PAGE_SIZE)
>> - return -EINVAL;
>> -
>> - if (!is_power_of_2(chunk_size))
>> - return -EINVAL;
>> -
>> - size = round_down(size, chunk_size);
>> -
>> - mm->size = size;
>> - mm->avail = size;
>> - mm->chunk_size = chunk_size;
>> - mm->max_order = ilog2(size) - ilog2(chunk_size);
>> -
>> - GEM_BUG_ON(mm->max_order > I915_BUDDY_MAX_ORDER);
>> -
>> - mm->free_list = kmalloc_array(mm->max_order + 1,
>> - sizeof(struct list_head),
>> - GFP_KERNEL);
>> - if (!mm->free_list)
>> - return -ENOMEM;
>> -
>> - for (i = 0; i <= mm->max_order; ++i)
>> - INIT_LIST_HEAD(&mm->free_list[i]);
>> -
>> - mm->n_roots = hweight64(size);
>> -
>> - mm->roots = kmalloc_array(mm->n_roots,
>> - sizeof(struct i915_buddy_block *),
>> - GFP_KERNEL);
>> - if (!mm->roots)
>> - goto out_free_list;
>> -
>> - offset = 0;
>> - i = 0;
>> -
>> - /*
>> - * Split into power-of-two blocks, in case we are given a size that is
>> - * not itself a power-of-two.
>> - */
>> - do {
>> - struct i915_buddy_block *root;
>> - unsigned int order;
>> - u64 root_size;
>> -
>> - root_size = rounddown_pow_of_two(size);
>> - order = ilog2(root_size) - ilog2(chunk_size);
>> -
>> - root = i915_block_alloc(mm, NULL, order, offset);
>> - if (!root)
>> - goto out_free_roots;
>> -
>> - mark_free(mm, root);
>> -
>> - GEM_BUG_ON(i > mm->max_order);
>> - GEM_BUG_ON(i915_buddy_block_size(mm, root) < chunk_size);
>> -
>> - mm->roots[i] = root;
>> -
>> - offset += root_size;
>> - size -= root_size;
>> - i++;
>> - } while (size);
>> -
>> - return 0;
>> -
>> -out_free_roots:
>> - while (i--)
>> - i915_block_free(mm, mm->roots[i]);
>> - kfree(mm->roots);
>> -out_free_list:
>> - kfree(mm->free_list);
>> - return -ENOMEM;
>> -}
>> -
>> -void i915_buddy_fini(struct i915_buddy_mm *mm)
>> -{
>> - int i;
>> -
>> - for (i = 0; i < mm->n_roots; ++i) {
>> - GEM_WARN_ON(!i915_buddy_block_is_free(mm->roots[i]));
>> - i915_block_free(mm, mm->roots[i]);
>> - }
>> -
>> - GEM_WARN_ON(mm->avail != mm->size);
>> -
>> - kfree(mm->roots);
>> - kfree(mm->free_list);
>> -}
>> -
>> -static int split_block(struct i915_buddy_mm *mm,
>> - struct i915_buddy_block *block)
>> -{
>> - unsigned int block_order = i915_buddy_block_order(block) - 1;
>> - u64 offset = i915_buddy_block_offset(block);
>> -
>> - GEM_BUG_ON(!i915_buddy_block_is_free(block));
>> - GEM_BUG_ON(!i915_buddy_block_order(block));
>> -
>> - block->left = i915_block_alloc(mm, block, block_order, offset);
>> - if (!block->left)
>> - return -ENOMEM;
>> -
>> - block->right = i915_block_alloc(mm, block, block_order,
>> - offset + (mm->chunk_size << block_order));
>> - if (!block->right) {
>> - i915_block_free(mm, block->left);
>> - return -ENOMEM;
>> - }
>> -
>> - mark_free(mm, block->left);
>> - mark_free(mm, block->right);
>> -
>> - mark_split(block);
>> -
>> - return 0;
>> -}
>> -
>> -static struct i915_buddy_block *
>> -get_buddy(struct i915_buddy_block *block)
>> -{
>> - struct i915_buddy_block *parent;
>> -
>> - parent = block->parent;
>> - if (!parent)
>> - return NULL;
>> -
>> - if (parent->left == block)
>> - return parent->right;
>> -
>> - return parent->left;
>> -}
>> -
>> -static void __i915_buddy_free(struct i915_buddy_mm *mm,
>> - struct i915_buddy_block *block)
>> -{
>> - struct i915_buddy_block *parent;
>> -
>> - while ((parent = block->parent)) {
>> - struct i915_buddy_block *buddy;
>> -
>> - buddy = get_buddy(block);
>> -
>> - if (!i915_buddy_block_is_free(buddy))
>> - break;
>> -
>> - list_del(&buddy->link);
>> -
>> - i915_block_free(mm, block);
>> - i915_block_free(mm, buddy);
>> -
>> - block = parent;
>> - }
>> -
>> - mark_free(mm, block);
>> -}
>> -
>> -void i915_buddy_free(struct i915_buddy_mm *mm,
>> - struct i915_buddy_block *block)
>> -{
>> - GEM_BUG_ON(!i915_buddy_block_is_allocated(block));
>> - mm->avail += i915_buddy_block_size(mm, block);
>> - __i915_buddy_free(mm, block);
>> -}
>> -
>> -void i915_buddy_free_list(struct i915_buddy_mm *mm, struct list_head *objects)
>> -{
>> - struct i915_buddy_block *block, *on;
>> -
>> - list_for_each_entry_safe(block, on, objects, link) {
>> - i915_buddy_free(mm, block);
>> - cond_resched();
>> - }
>> - INIT_LIST_HEAD(objects);
>> -}
>> -
>> -/*
>> - * Allocate power-of-two block. The order value here translates to:
>> - *
>> - * 0 = 2^0 * mm->chunk_size
>> - * 1 = 2^1 * mm->chunk_size
>> - * 2 = 2^2 * mm->chunk_size
>> - * ...
>> - */
>> -struct i915_buddy_block *
>> -i915_buddy_alloc(struct i915_buddy_mm *mm, unsigned int order)
>> -{
>> - struct i915_buddy_block *block = NULL;
>> - unsigned int i;
>> - int err;
>> -
>> - for (i = order; i <= mm->max_order; ++i) {
>> - block = list_first_entry_or_null(&mm->free_list[i],
>> - struct i915_buddy_block,
>> - link);
>> - if (block)
>> - break;
>> - }
>> -
>> - if (!block)
>> - return ERR_PTR(-ENOSPC);
>> -
>> - GEM_BUG_ON(!i915_buddy_block_is_free(block));
>> -
>> - while (i != order) {
>> - err = split_block(mm, block);
>> - if (unlikely(err))
>> - goto out_free;
>> -
>> - /* Go low */
>> - block = block->left;
>> - i--;
>> - }
>> -
>> - mark_allocated(block);
>> - mm->avail -= i915_buddy_block_size(mm, block);
>> - kmemleak_update_trace(block);
>> - return block;
>> -
>> -out_free:
>> - if (i != order)
>> - __i915_buddy_free(mm, block);
>> - return ERR_PTR(err);
>> -}
>> -
>> -static inline bool overlaps(u64 s1, u64 e1, u64 s2, u64 e2)
>> -{
>> - return s1 <= e2 && e1 >= s2;
>> -}
>> -
>> -static inline bool contains(u64 s1, u64 e1, u64 s2, u64 e2)
>> -{
>> - return s1 <= s2 && e1 >= e2;
>> -}
>> -
>> -/*
>> - * Allocate range. Note that it's safe to chain together multiple alloc_ranges
>> - * with the same blocks list.
>> - *
>> - * Intended for pre-allocating portions of the address space, for example to
>> - * reserve a block for the initial framebuffer or similar, hence the expectation
>> - * here is that i915_buddy_alloc() is still the main vehicle for
>> - * allocations, so if that's not the case then the drm_mm range allocator is
>> - * probably a much better fit, and so you should probably go use that instead.
>> - */
>> -int i915_buddy_alloc_range(struct i915_buddy_mm *mm,
>> - struct list_head *blocks,
>> - u64 start, u64 size)
>> -{
>> - struct i915_buddy_block *block;
>> - struct i915_buddy_block *buddy;
>> - LIST_HEAD(allocated);
>> - LIST_HEAD(dfs);
>> - u64 end;
>> - int err;
>> - int i;
>> -
>> - if (size < mm->chunk_size)
>> - return -EINVAL;
>> -
>> - if (!IS_ALIGNED(size | start, mm->chunk_size))
>> - return -EINVAL;
>> -
>> - if (range_overflows(start, size, mm->size))
>> - return -EINVAL;
>> -
>> - for (i = 0; i < mm->n_roots; ++i)
>> - list_add_tail(&mm->roots[i]->tmp_link, &dfs);
>> -
>> - end = start + size - 1;
>> -
>> - do {
>> - u64 block_start;
>> - u64 block_end;
>> -
>> - block = list_first_entry_or_null(&dfs,
>> - struct i915_buddy_block,
>> - tmp_link);
>> - if (!block)
>> - break;
>> -
>> - list_del(&block->tmp_link);
>> -
>> - block_start = i915_buddy_block_offset(block);
>> - block_end = block_start + i915_buddy_block_size(mm, block) - 1;
>> -
>> - if (!overlaps(start, end, block_start, block_end))
>> - continue;
>> -
>> - if (i915_buddy_block_is_allocated(block)) {
>> - err = -ENOSPC;
>> - goto err_free;
>> - }
>> -
>> - if (contains(start, end, block_start, block_end)) {
>> - if (!i915_buddy_block_is_free(block)) {
>> - err = -ENOSPC;
>> - goto err_free;
>> - }
>> -
>> - mark_allocated(block);
>> - mm->avail -= i915_buddy_block_size(mm, block);
>> - list_add_tail(&block->link, &allocated);
>> - continue;
>> - }
>> -
>> - if (!i915_buddy_block_is_split(block)) {
>> - err = split_block(mm, block);
>> - if (unlikely(err))
>> - goto err_undo;
>> - }
>> -
>> - list_add(&block->right->tmp_link, &dfs);
>> - list_add(&block->left->tmp_link, &dfs);
>> - } while (1);
>> -
>> - list_splice_tail(&allocated, blocks);
>> - return 0;
>> -
>> -err_undo:
>> - /*
>> - * We really don't want to leave around a bunch of split blocks, since
>> - * bigger is better, so make sure we merge everything back before we
>> - * free the allocated blocks.
>> - */
>> - buddy = get_buddy(block);
>> - if (buddy &&
>> - (i915_buddy_block_is_free(block) &&
>> - i915_buddy_block_is_free(buddy)))
>> - __i915_buddy_free(mm, block);
>> -
>> -err_free:
>> - i915_buddy_free_list(mm, &allocated);
>> - return err;
>> -}
>> -
>> -void i915_buddy_block_print(struct i915_buddy_mm *mm,
>> - struct i915_buddy_block *block,
>> - struct drm_printer *p)
>> -{
>> - u64 start = i915_buddy_block_offset(block);
>> - u64 size = i915_buddy_block_size(mm, block);
>> -
>> - drm_printf(p, "%#018llx-%#018llx: %llu\n", start, start + size, size);
>> -}
>> -
>> -void i915_buddy_print(struct i915_buddy_mm *mm, struct drm_printer *p)
>> -{
>> - int order;
>> -
>> - drm_printf(p, "chunk_size: %lluKiB, total: %lluMiB, free: %lluMiB\n",
>> - mm->chunk_size >> 10, mm->size >> 20, mm->avail >> 20);
>> -
>> - for (order = mm->max_order; order >= 0; order--) {
>> - struct i915_buddy_block *block;
>> - u64 count = 0, free;
>> -
>> - list_for_each_entry(block, &mm->free_list[order], link) {
>> - GEM_BUG_ON(!i915_buddy_block_is_free(block));
>> - count++;
>> - }
>> -
>> - drm_printf(p, "order-%d ", order);
>> -
>> - free = count * (mm->chunk_size << order);
>> - if (free < SZ_1M)
>> - drm_printf(p, "free: %lluKiB", free >> 10);
>> - else
>> - drm_printf(p, "free: %lluMiB", free >> 20);
>> -
>> - drm_printf(p, ", pages: %llu\n", count);
>> - }
>> -}
>> -
>> -#if IS_ENABLED(CONFIG_DRM_I915_SELFTEST)
>> -#include "selftests/i915_buddy.c"
>> -#endif
>> -
>> -void i915_buddy_module_exit(void)
>> -{
>> - kmem_cache_destroy(slab_blocks);
>> -}
>> -
>> -int __init i915_buddy_module_init(void)
>> -{
>> - slab_blocks = KMEM_CACHE(i915_buddy_block, 0);
>> - if (!slab_blocks)
>> - return -ENOMEM;
>> -
>> - return 0;
>> -}
>> diff --git a/drivers/gpu/drm/i915/i915_buddy.h b/drivers/gpu/drm/i915/i915_buddy.h
>> deleted file mode 100644
>> index 7077742112ac..000000000000
>> --- a/drivers/gpu/drm/i915/i915_buddy.h
>> +++ /dev/null
>> @@ -1,143 +0,0 @@
>> -/* SPDX-License-Identifier: MIT */
>> -/*
>> - * Copyright © 2021 Intel Corporation
>> - */
>> -
>> -#ifndef __I915_BUDDY_H__
>> -#define __I915_BUDDY_H__
>> -
>> -#include <linux/bitops.h>
>> -#include <linux/list.h>
>> -#include <linux/slab.h>
>> -
>> -#include <drm/drm_print.h>
>> -
>> -struct i915_buddy_block {
>> -#define I915_BUDDY_HEADER_OFFSET GENMASK_ULL(63, 12)
>> -#define I915_BUDDY_HEADER_STATE GENMASK_ULL(11, 10)
>> -#define I915_BUDDY_ALLOCATED (1 << 10)
>> -#define I915_BUDDY_FREE (2 << 10)
>> -#define I915_BUDDY_SPLIT (3 << 10)
>> -/* Free to be used, if needed in the future */
>> -#define I915_BUDDY_HEADER_UNUSED GENMASK_ULL(9, 6)
>> -#define I915_BUDDY_HEADER_ORDER GENMASK_ULL(5, 0)
>> - u64 header;
>> -
>> - struct i915_buddy_block *left;
>> - struct i915_buddy_block *right;
>> - struct i915_buddy_block *parent;
>> -
>> - void *private; /* owned by creator */
>> -
>> - /*
>> - * While the block is allocated by the user through i915_buddy_alloc*,
>> - * the user has ownership of the link, for example to maintain within
>> - * a list, if so desired. As soon as the block is freed with
>> - * i915_buddy_free* ownership is given back to the mm.
>> - */
>> - struct list_head link;
>> - struct list_head tmp_link;
>> -};
>> -
>> -/* Order-zero must be at least PAGE_SIZE */
>> -#define I915_BUDDY_MAX_ORDER (63 - PAGE_SHIFT)
>> -
>> -/*
>> - * Binary Buddy System.
>> - *
>> - * Locking should be handled by the user, a simple mutex around
>> - * i915_buddy_alloc* and i915_buddy_free* should suffice.
>> - */
>> -struct i915_buddy_mm {
>> - /* Maintain a free list for each order. */
>> - struct list_head *free_list;
>> -
>> - /*
>> - * Maintain explicit binary tree(s) to track the allocation of the
>> - * address space. This gives us a simple way of finding a buddy block
>> - * and performing the potentially recursive merge step when freeing a
>> - * block. Nodes are either allocated or free, in which case they will
>> - * also exist on the respective free list.
>> - */
>> - struct i915_buddy_block **roots;
>> -
>> - /*
>> - * Anything from here is public, and remains static for the lifetime of
>> - * the mm. Everything above is considered do-not-touch.
>> - */
>> - unsigned int n_roots;
>> - unsigned int max_order;
>> -
>> - /* Must be at least PAGE_SIZE */
>> - u64 chunk_size;
>> - u64 size;
>> - u64 avail;
>> -};
>> -
>> -static inline u64
>> -i915_buddy_block_offset(struct i915_buddy_block *block)
>> -{
>> - return block->header & I915_BUDDY_HEADER_OFFSET;
>> -}
>> -
>> -static inline unsigned int
>> -i915_buddy_block_order(struct i915_buddy_block *block)
>> -{
>> - return block->header & I915_BUDDY_HEADER_ORDER;
>> -}
>> -
>> -static inline unsigned int
>> -i915_buddy_block_state(struct i915_buddy_block *block)
>> -{
>> - return block->header & I915_BUDDY_HEADER_STATE;
>> -}
>> -
>> -static inline bool
>> -i915_buddy_block_is_allocated(struct i915_buddy_block *block)
>> -{
>> - return i915_buddy_block_state(block) == I915_BUDDY_ALLOCATED;
>> -}
>> -
>> -static inline bool
>> -i915_buddy_block_is_free(struct i915_buddy_block *block)
>> -{
>> - return i915_buddy_block_state(block) == I915_BUDDY_FREE;
>> -}
>> -
>> -static inline bool
>> -i915_buddy_block_is_split(struct i915_buddy_block *block)
>> -{
>> - return i915_buddy_block_state(block) == I915_BUDDY_SPLIT;
>> -}
>> -
>> -static inline u64
>> -i915_buddy_block_size(struct i915_buddy_mm *mm,
>> - struct i915_buddy_block *block)
>> -{
>> - return mm->chunk_size << i915_buddy_block_order(block);
>> -}
>> -
>> -int i915_buddy_init(struct i915_buddy_mm *mm, u64 size, u64 chunk_size);
>> -
>> -void i915_buddy_fini(struct i915_buddy_mm *mm);
>> -
>> -struct i915_buddy_block *
>> -i915_buddy_alloc(struct i915_buddy_mm *mm, unsigned int order);
>> -
>> -int i915_buddy_alloc_range(struct i915_buddy_mm *mm,
>> - struct list_head *blocks,
>> - u64 start, u64 size);
>> -
>> -void i915_buddy_free(struct i915_buddy_mm *mm, struct i915_buddy_block *block);
>> -
>> -void i915_buddy_free_list(struct i915_buddy_mm *mm, struct list_head *objects);
>> -
>> -void i915_buddy_print(struct i915_buddy_mm *mm, struct drm_printer *p);
>> -void i915_buddy_block_print(struct i915_buddy_mm *mm,
>> - struct i915_buddy_block *block,
>> - struct drm_printer *p);
>> -
>> -void i915_buddy_module_exit(void);
>> -int i915_buddy_module_init(void);
>> -
>> -#endif
>> diff --git a/drivers/gpu/drm/i915/i915_module.c b/drivers/gpu/drm/i915/i915_module.c
>> index c7507266aa83..355681dbd7a8 100644
>> --- a/drivers/gpu/drm/i915/i915_module.c
>> +++ b/drivers/gpu/drm/i915/i915_module.c
>> @@ -9,7 +9,6 @@
>> #include "gem/i915_gem_context.h"
>> #include "gem/i915_gem_object.h"
>> #include "i915_active.h"
>> -#include "i915_buddy.h"
>> #include "i915_params.h"
>> #include "i915_pci.h"
>> #include "i915_perf.h"
>> @@ -50,8 +49,6 @@ static const struct {
>> { .init = i915_check_nomodeset },
>> { .init = i915_active_module_init,
>> .exit = i915_active_module_exit },
>> - { .init = i915_buddy_module_init,
>> - .exit = i915_buddy_module_exit },
>> { .init = i915_context_module_init,
>> .exit = i915_context_module_exit },
>> { .init = i915_gem_context_module_init,
>> diff --git a/drivers/gpu/drm/i915/i915_scatterlist.c b/drivers/gpu/drm/i915/i915_scatterlist.c
>> index 4a6712dca838..84d622aa32d2 100644
>> --- a/drivers/gpu/drm/i915/i915_scatterlist.c
>> +++ b/drivers/gpu/drm/i915/i915_scatterlist.c
>> @@ -5,10 +5,9 @@
>> */
>>
>> #include "i915_scatterlist.h"
>> -
>> -#include "i915_buddy.h"
>> #include "i915_ttm_buddy_manager.h"
>>
>> +#include <drm/drm_buddy.h>
>> #include <drm/drm_mm.h>
>>
>> #include <linux/slab.h>
>> @@ -126,9 +125,9 @@ struct sg_table *i915_sg_from_buddy_resource(struct ttm_resource *res,
>> struct i915_ttm_buddy_resource *bman_res = to_ttm_buddy_resource(res);
>> const u64 size = res->num_pages << PAGE_SHIFT;
>> const u64 max_segment = rounddown(UINT_MAX, PAGE_SIZE);
>> - struct i915_buddy_mm *mm = bman_res->mm;
>> + struct drm_buddy_mm *mm = bman_res->mm;
>> struct list_head *blocks = &bman_res->blocks;
>> - struct i915_buddy_block *block;
>> + struct drm_buddy_block *block;
>> struct scatterlist *sg;
>> struct sg_table *st;
>> resource_size_t prev_end;
>> @@ -151,8 +150,8 @@ struct sg_table *i915_sg_from_buddy_resource(struct ttm_resource *res,
>> list_for_each_entry(block, blocks, link) {
>> u64 block_size, offset;
>>
>> - block_size = min_t(u64, size, i915_buddy_block_size(mm, block));
>> - offset = i915_buddy_block_offset(block);
>> + block_size = min_t(u64, size, drm_buddy_block_size(mm, block));
>> + offset = drm_buddy_block_offset(block);
>>
>> while (block_size) {
>> u64 len;
>> diff --git a/drivers/gpu/drm/i915/i915_ttm_buddy_manager.c b/drivers/gpu/drm/i915/i915_ttm_buddy_manager.c
>> index d59fbb019032..c4b70cb8c248 100644
>> --- a/drivers/gpu/drm/i915/i915_ttm_buddy_manager.c
>> +++ b/drivers/gpu/drm/i915/i915_ttm_buddy_manager.c
>> @@ -8,14 +8,15 @@
>> #include <drm/ttm/ttm_bo_driver.h>
>> #include <drm/ttm/ttm_placement.h>
>>
>> +#include <drm/drm_buddy.h>
>> +
>> #include "i915_ttm_buddy_manager.h"
>>
>> -#include "i915_buddy.h"
>> #include "i915_gem.h"
>>
>> struct i915_ttm_buddy_manager {
>> struct ttm_resource_manager manager;
>> - struct i915_buddy_mm mm;
>> + struct drm_buddy_mm mm;
>> struct list_head reserved;
>> struct mutex lock;
>> u64 default_page_size;
>> @@ -34,7 +35,7 @@ static int i915_ttm_buddy_man_alloc(struct ttm_resource_manager *man,
>> {
>> struct i915_ttm_buddy_manager *bman = to_buddy_manager(man);
>> struct i915_ttm_buddy_resource *bman_res;
>> - struct i915_buddy_mm *mm = &bman->mm;
>> + struct drm_buddy_mm *mm = &bman->mm;
>> unsigned long n_pages;
>> unsigned int min_order;
>> u64 min_page_size;
>> @@ -73,7 +74,7 @@ static int i915_ttm_buddy_man_alloc(struct ttm_resource_manager *man,
>> n_pages = size >> ilog2(mm->chunk_size);
>>
>> do {
>> - struct i915_buddy_block *block;
>> + struct drm_buddy_block *block;
>> unsigned int order;
>>
>> order = fls(n_pages) - 1;
>> @@ -82,7 +83,7 @@ static int i915_ttm_buddy_man_alloc(struct ttm_resource_manager *man,
>>
>> do {
>> mutex_lock(&bman->lock);
>> - block = i915_buddy_alloc(mm, order);
>> + block = drm_buddy_alloc(mm, order);
>> mutex_unlock(&bman->lock);
>> if (!IS_ERR(block))
>> break;
>> @@ -106,7 +107,7 @@ static int i915_ttm_buddy_man_alloc(struct ttm_resource_manager *man,
>>
>> err_free_blocks:
>> mutex_lock(&bman->lock);
>> - i915_buddy_free_list(mm, &bman_res->blocks);
>> + drm_buddy_free_list(mm, &bman_res->blocks);
>> mutex_unlock(&bman->lock);
>> err_free_res:
>> kfree(bman_res);
>> @@ -120,7 +121,7 @@ static void i915_ttm_buddy_man_free(struct ttm_resource_manager *man,
>> struct i915_ttm_buddy_manager *bman = to_buddy_manager(man);
>>
>> mutex_lock(&bman->lock);
>> - i915_buddy_free_list(&bman->mm, &bman_res->blocks);
>> + drm_buddy_free_list(&bman->mm, &bman_res->blocks);
>> mutex_unlock(&bman->lock);
>>
>> kfree(bman_res);
>> @@ -130,17 +131,17 @@ static void i915_ttm_buddy_man_debug(struct ttm_resource_manager *man,
>> struct drm_printer *printer)
>> {
>> struct i915_ttm_buddy_manager *bman = to_buddy_manager(man);
>> - struct i915_buddy_block *block;
>> + struct drm_buddy_block *block;
>>
>> mutex_lock(&bman->lock);
>> drm_printf(printer, "default_page_size: %lluKiB\n",
>> bman->default_page_size >> 10);
>>
>> - i915_buddy_print(&bman->mm, printer);
>> + drm_buddy_print(&bman->mm, printer);
>>
>> drm_printf(printer, "reserved:\n");
>> list_for_each_entry(block, &bman->reserved, link)
>> - i915_buddy_block_print(&bman->mm, block, printer);
>> + drm_buddy_block_print(&bman->mm, block, printer);
>> mutex_unlock(&bman->lock);
>> }
>>
>> @@ -190,7 +191,7 @@ int i915_ttm_buddy_man_init(struct ttm_device *bdev,
>> if (!bman)
>> return -ENOMEM;
>>
>> - err = i915_buddy_init(&bman->mm, size, chunk_size);
>> + err = drm_buddy_init(&bman->mm, size, chunk_size);
>> if (err)
>> goto err_free_bman;
>>
>> @@ -228,7 +229,7 @@ int i915_ttm_buddy_man_fini(struct ttm_device *bdev, unsigned int type)
>> {
>> struct ttm_resource_manager *man = ttm_manager_type(bdev, type);
>> struct i915_ttm_buddy_manager *bman = to_buddy_manager(man);
>> - struct i915_buddy_mm *mm = &bman->mm;
>> + struct drm_buddy_mm *mm = &bman->mm;
>> int ret;
>>
>> ttm_resource_manager_set_used(man, false);
>> @@ -240,8 +241,8 @@ int i915_ttm_buddy_man_fini(struct ttm_device *bdev, unsigned int type)
>> ttm_set_driver_manager(bdev, type, NULL);
>>
>> mutex_lock(&bman->lock);
>> - i915_buddy_free_list(mm, &bman->reserved);
>> - i915_buddy_fini(mm);
>> + drm_buddy_free_list(mm, &bman->reserved);
>> + drm_buddy_fini(mm);
>> mutex_unlock(&bman->lock);
>>
>> ttm_resource_manager_cleanup(man);
>> @@ -264,11 +265,11 @@ int i915_ttm_buddy_man_reserve(struct ttm_resource_manager *man,
>> u64 start, u64 size)
>> {
>> struct i915_ttm_buddy_manager *bman = to_buddy_manager(man);
>> - struct i915_buddy_mm *mm = &bman->mm;
>> + struct drm_buddy_mm *mm = &bman->mm;
>> int ret;
>>
>> mutex_lock(&bman->lock);
>> - ret = i915_buddy_alloc_range(mm, &bman->reserved, start, size);
>> + ret = drm_buddy_alloc_range(mm, &bman->reserved, start, size);
>> mutex_unlock(&bman->lock);
>>
>> return ret;
>> diff --git a/drivers/gpu/drm/i915/i915_ttm_buddy_manager.h b/drivers/gpu/drm/i915/i915_ttm_buddy_manager.h
>> index 0722d33f3e14..fa644b512c2e 100644
>> --- a/drivers/gpu/drm/i915/i915_ttm_buddy_manager.h
>> +++ b/drivers/gpu/drm/i915/i915_ttm_buddy_manager.h
>> @@ -13,7 +13,7 @@
>>
>> struct ttm_device;
>> struct ttm_resource_manager;
>> -struct i915_buddy_mm;
>> +struct drm_buddy_mm;
>>
>> /**
>> * struct i915_ttm_buddy_resource
>> @@ -28,7 +28,7 @@ struct i915_buddy_mm;
>> struct i915_ttm_buddy_resource {
>> struct ttm_resource base;
>> struct list_head blocks;
>> - struct i915_buddy_mm *mm;
>> + struct drm_buddy_mm *mm;
>> };
>>
>> /**
>> diff --git a/include/drm/drm_buddy.h b/include/drm/drm_buddy.h
>> new file mode 100644
>> index 000000000000..5ce3fc702f80
>> --- /dev/null
>> +++ b/include/drm/drm_buddy.h
>> @@ -0,0 +1,153 @@
>> +/* SPDX-License-Identifier: MIT */
>> +/*
>> + * Copyright © 2021 Intel Corporation
>> + */
>> +
>> +#ifndef __DRM_BUDDY_H__
>> +#define __DRM_BUDDY_H__
>> +
>> +#include <linux/bitops.h>
>> +#include <linux/list.h>
>> +#include <linux/slab.h>
>> +#include <linux/sched.h>
>> +
>> +#include <drm/drm_print.h>
>> +
>> +#define range_overflows(start, size, max) ({ \
>> + typeof(start) start__ = (start); \
>> + typeof(size) size__ = (size); \
>> + typeof(max) max__ = (max); \
>> + (void)(&start__ == &size__); \
>> + (void)(&start__ == &max__); \
>> + start__ >= max__ || size__ > max__ - start__; \
>> +})
>> +
>> +struct drm_buddy_block {
>> +#define DRM_BUDDY_HEADER_OFFSET GENMASK_ULL(63, 12)
>> +#define DRM_BUDDY_HEADER_STATE GENMASK_ULL(11, 10)
>> +#define DRM_BUDDY_ALLOCATED (1 << 10)
>> +#define DRM_BUDDY_FREE (2 << 10)
>> +#define DRM_BUDDY_SPLIT (3 << 10)
>> +/* Free to be used, if needed in the future */
>> +#define DRM_BUDDY_HEADER_UNUSED GENMASK_ULL(9, 6)
>> +#define DRM_BUDDY_HEADER_ORDER GENMASK_ULL(5, 0)
>> + u64 header;
>> +
>> + struct drm_buddy_block *left;
>> + struct drm_buddy_block *right;
>> + struct drm_buddy_block *parent;
>> +
>> + void *private; /* owned by creator */
>> +
>> + /*
>> + * While the block is allocated by the user through drm_buddy_alloc*,
>> + * the user has ownership of the link, for example to maintain within
>> + * a list, if so desired. As soon as the block is freed with
>> + * drm_buddy_free* ownership is given back to the mm.
>> + */
>> + struct list_head link;
>> + struct list_head tmp_link;
>> +};
>> +
>> +/* Order-zero must be at least PAGE_SIZE */
>> +#define DRM_BUDDY_MAX_ORDER (63 - PAGE_SHIFT)
>> +
>> +/*
>> + * Binary Buddy System.
>> + *
>> + * Locking should be handled by the user, a simple mutex around
>> + * drm_buddy_alloc* and drm_buddy_free* should suffice.
>> + */
>> +struct drm_buddy_mm {
>> + /* Maintain a free list for each order. */
>> + struct list_head *free_list;
>> +
>> + /*
>> + * Maintain explicit binary tree(s) to track the allocation of the
>> + * address space. This gives us a simple way of finding a buddy block
>> + * and performing the potentially recursive merge step when freeing a
>> + * block. Nodes are either allocated or free, in which case they will
>> + * also exist on the respective free list.
>> + */
>> + struct drm_buddy_block **roots;
>> +
>> + /*
>> + * Anything from here is public, and remains static for the lifetime of
>> + * the mm. Everything above is considered do-not-touch.
>> + */
>> + unsigned int n_roots;
>> + unsigned int max_order;
>> +
>> + /* Must be at least PAGE_SIZE */
>> + u64 chunk_size;
>> + u64 size;
>> + u64 avail;
>> +};
>> +
>> +static inline u64
>> +drm_buddy_block_offset(struct drm_buddy_block *block)
>> +{
>> + return block->header & DRM_BUDDY_HEADER_OFFSET;
>> +}
>> +
>> +static inline unsigned int
>> +drm_buddy_block_order(struct drm_buddy_block *block)
>> +{
>> + return block->header & DRM_BUDDY_HEADER_ORDER;
>> +}
>> +
>> +static inline unsigned int
>> +drm_buddy_block_state(struct drm_buddy_block *block)
>> +{
>> + return block->header & DRM_BUDDY_HEADER_STATE;
>> +}
>> +
>> +static inline bool
>> +drm_buddy_block_is_allocated(struct drm_buddy_block *block)
>> +{
>> + return drm_buddy_block_state(block) == DRM_BUDDY_ALLOCATED;
>> +}
>> +
>> +static inline bool
>> +drm_buddy_block_is_free(struct drm_buddy_block *block)
>> +{
>> + return drm_buddy_block_state(block) == DRM_BUDDY_FREE;
>> +}
>> +
>> +static inline bool
>> +drm_buddy_block_is_split(struct drm_buddy_block *block)
>> +{
>> + return drm_buddy_block_state(block) == DRM_BUDDY_SPLIT;
>> +}
>> +
>> +static inline u64
>> +drm_buddy_block_size(struct drm_buddy_mm *mm,
>> + struct drm_buddy_block *block)
>> +{
>> + return mm->chunk_size << drm_buddy_block_order(block);
>> +}
>> +
>> +int drm_buddy_init(struct drm_buddy_mm *mm, u64 size, u64 chunk_size);
>> +
>> +void drm_buddy_fini(struct drm_buddy_mm *mm);
>> +
>> +struct drm_buddy_block *
>> +drm_buddy_alloc(struct drm_buddy_mm *mm, unsigned int order);
>> +
>> +int drm_buddy_alloc_range(struct drm_buddy_mm *mm,
>> + struct list_head *blocks,
>> + u64 start, u64 size);
>> +
>> +void drm_buddy_free(struct drm_buddy_mm *mm, struct drm_buddy_block *block);
>> +
>> +void drm_buddy_free_list(struct drm_buddy_mm *mm, struct list_head *objects);
>> +
>> +void drm_buddy_print(struct drm_buddy_mm *mm, struct drm_printer *p);
>> +void drm_buddy_block_print(struct drm_buddy_mm *mm,
>> + struct drm_buddy_block *block,
>> + struct drm_printer *p);
>> +
>> +void drm_buddy_module_exit(void);
>> +int drm_buddy_module_init(void);
>> +
>> +#endif
>
^ permalink raw reply [flat|nested] 46+ messages in thread
* Re: [PATCH v3 1/6] drm: move the buddy allocator from i915 into common drm
@ 2021-11-17 17:05 ` Arunpravin
0 siblings, 0 replies; 46+ messages in thread
From: Arunpravin @ 2021-11-17 17:05 UTC (permalink / raw)
To: Christian König, dri-devel, intel-gfx, amd-gfx
Cc: daniel, jani.nikula, matthew.auld, tzimmermann,
alexander.deucher, christian.koenig
Hi Christian,
I will make this a separate module.
Thanks,
Arun
On 17/11/21 1:33 pm, Christian König wrote:
> I've looked a bit more into this and I think we should just follow
> Thomas Zimmermann's idea to make this a separate module.
>
> Otherwise we just have the code around all the time even if it is unused
> and implementing this should be trivial.
>
> See how DRM_GEM_CMA_HELPER or DRM_VRAM_HELPER are done in
> drivers/gpu/drm/Kconfig and then have the desired effect in
> drivers/gpu/drm/Makefile
>
> Should be something like ~15 lines of additional configuration which
> saves a bit of memory on embedded systems which just need a fbdev
> replacement.
>
> Thanks,
> Christian.
>
> Am 16.11.21 um 21:18 schrieb Arunpravin:
>> Move the base i915 buddy allocator code into drm
>> - Move i915_buddy.h to include/drm
>> - Move i915_buddy.c to drm root folder
>> - Rename "i915" string with "drm" string wherever applicable
>> - Rename "I915" string with "DRM" string wherever applicable
>> - Fix header file dependencies
>> - Fix alignment issues
>> - add Makefile support for drm buddy
>> - export functions and write kerneldoc description
>> - Remove i915 selftest config check condition as buddy selftest
>> will be moved to drm selftest folder
>>
>> cleanup i915 buddy references in i915 driver module
>> and replace with drm buddy
>>
>> v2:
>> - include header file in alphabetical order (Thomas)
>> - merged changes listed in the body section into a single patch
>> to keep the build intact (Christian, Jani)
>>
>> Signed-off-by: Arunpravin <Arunpravin.PaneerSelvam@amd.com>
>> ---
>> drivers/gpu/drm/Makefile | 2 +-
>> drivers/gpu/drm/drm_buddy.c | 521 ++++++++++++++++++
>> drivers/gpu/drm/drm_drv.c | 3 +
>> drivers/gpu/drm/i915/Makefile | 1 -
>> drivers/gpu/drm/i915/i915_buddy.c | 466 ----------------
>> drivers/gpu/drm/i915/i915_buddy.h | 143 -----
>> drivers/gpu/drm/i915/i915_module.c | 3 -
>> drivers/gpu/drm/i915/i915_scatterlist.c | 11 +-
>> drivers/gpu/drm/i915/i915_ttm_buddy_manager.c | 33 +-
>> drivers/gpu/drm/i915/i915_ttm_buddy_manager.h | 4 +-
>> include/drm/drm_buddy.h | 153 +++++
>> 11 files changed, 702 insertions(+), 638 deletions(-)
>> create mode 100644 drivers/gpu/drm/drm_buddy.c
>> delete mode 100644 drivers/gpu/drm/i915/i915_buddy.c
>> delete mode 100644 drivers/gpu/drm/i915/i915_buddy.h
>> create mode 100644 include/drm/drm_buddy.h
>>
>> diff --git a/drivers/gpu/drm/Makefile b/drivers/gpu/drm/Makefile
>> index 0dff40bb863c..dc61e91a3154 100644
>> --- a/drivers/gpu/drm/Makefile
>> +++ b/drivers/gpu/drm/Makefile
>> @@ -18,7 +18,7 @@ drm-y := drm_aperture.o drm_auth.o drm_cache.o \
>> drm_dumb_buffers.o drm_mode_config.o drm_vblank.o \
>> drm_syncobj.o drm_lease.o drm_writeback.o drm_client.o \
>> drm_client_modeset.o drm_atomic_uapi.o drm_hdcp.o \
>> - drm_managed.o drm_vblank_work.o
>> + drm_managed.o drm_vblank_work.o drm_buddy.o
>>
>> drm-$(CONFIG_DRM_LEGACY) += drm_agpsupport.o drm_bufs.o drm_context.o drm_dma.o \
>> drm_legacy_misc.o drm_lock.o drm_memory.o drm_scatter.o \
>> diff --git a/drivers/gpu/drm/drm_buddy.c b/drivers/gpu/drm/drm_buddy.c
>> new file mode 100644
>> index 000000000000..39eb1d224bec
>> --- /dev/null
>> +++ b/drivers/gpu/drm/drm_buddy.c
>> @@ -0,0 +1,521 @@
>> +// SPDX-License-Identifier: MIT
>> +/*
>> + * Copyright © 2021 Intel Corporation
>> + */
>> +
>> +#include <linux/kmemleak.h>
>> +#include <linux/sizes.h>
>> +
>> +#include <drm/drm_buddy.h>
>> +
>> +static struct kmem_cache *slab_blocks;
>> +
>> +static struct drm_buddy_block *drm_block_alloc(struct drm_buddy_mm *mm,
>> + struct drm_buddy_block *parent,
>> + unsigned int order,
>> + u64 offset)
>> +{
>> + struct drm_buddy_block *block;
>> +
>> + BUG_ON(order > DRM_BUDDY_MAX_ORDER);
>> +
>> + block = kmem_cache_zalloc(slab_blocks, GFP_KERNEL);
>> + if (!block)
>> + return NULL;
>> +
>> + block->header = offset;
>> + block->header |= order;
>> + block->parent = parent;
>> +
>> + BUG_ON(block->header & DRM_BUDDY_HEADER_UNUSED);
>> + return block;
>> +}
>> +
>> +static void drm_block_free(struct drm_buddy_mm *mm,
>> + struct drm_buddy_block *block)
>> +{
>> + kmem_cache_free(slab_blocks, block);
>> +}
>> +
>> +static void mark_allocated(struct drm_buddy_block *block)
>> +{
>> + block->header &= ~DRM_BUDDY_HEADER_STATE;
>> + block->header |= DRM_BUDDY_ALLOCATED;
>> +
>> + list_del(&block->link);
>> +}
>> +
>> +static void mark_free(struct drm_buddy_mm *mm,
>> + struct drm_buddy_block *block)
>> +{
>> + block->header &= ~DRM_BUDDY_HEADER_STATE;
>> + block->header |= DRM_BUDDY_FREE;
>> +
>> + list_add(&block->link,
>> + &mm->free_list[drm_buddy_block_order(block)]);
>> +}
>> +
>> +static void mark_split(struct drm_buddy_block *block)
>> +{
>> + block->header &= ~DRM_BUDDY_HEADER_STATE;
>> + block->header |= DRM_BUDDY_SPLIT;
>> +
>> + list_del(&block->link);
>> +}
>> +
>> +/**
>> + * drm_buddy_init - init memory manager
>> + *
>> + * @mm: DRM buddy manager to initialize
>> + * @size: size in bytes to manage
>> + * @chunk_size: minimum page size in bytes for our allocations
>> + *
>> + * Initializes the memory manager and its resources.
>> + *
>> + * Returns:
>> + * 0 on success, error code on failure.
>> + */
>> +int drm_buddy_init(struct drm_buddy_mm *mm, u64 size, u64 chunk_size)
>> +{
>> + unsigned int i;
>> + u64 offset;
>> +
>> + if (size < chunk_size)
>> + return -EINVAL;
>> +
>> + if (chunk_size < PAGE_SIZE)
>> + return -EINVAL;
>> +
>> + if (!is_power_of_2(chunk_size))
>> + return -EINVAL;
>> +
>> + size = round_down(size, chunk_size);
>> +
>> + mm->size = size;
>> + mm->avail = size;
>> + mm->chunk_size = chunk_size;
>> + mm->max_order = ilog2(size) - ilog2(chunk_size);
>> +
>> + BUG_ON(mm->max_order > DRM_BUDDY_MAX_ORDER);
>> +
>> + mm->free_list = kmalloc_array(mm->max_order + 1,
>> + sizeof(struct list_head),
>> + GFP_KERNEL);
>> + if (!mm->free_list)
>> + return -ENOMEM;
>> +
>> + for (i = 0; i <= mm->max_order; ++i)
>> + INIT_LIST_HEAD(&mm->free_list[i]);
>> +
>> + mm->n_roots = hweight64(size);
>> +
>> + mm->roots = kmalloc_array(mm->n_roots,
>> + sizeof(struct drm_buddy_block *),
>> + GFP_KERNEL);
>> + if (!mm->roots)
>> + goto out_free_list;
>> +
>> + offset = 0;
>> + i = 0;
>> +
>> + /*
>> + * Split into power-of-two blocks, in case we are given a size that is
>> + * not itself a power-of-two.
>> + */
>> + do {
>> + struct drm_buddy_block *root;
>> + unsigned int order;
>> + u64 root_size;
>> +
>> + root_size = rounddown_pow_of_two(size);
>> + order = ilog2(root_size) - ilog2(chunk_size);
>> +
>> + root = drm_block_alloc(mm, NULL, order, offset);
>> + if (!root)
>> + goto out_free_roots;
>> +
>> + mark_free(mm, root);
>> +
>> + BUG_ON(i > mm->max_order);
>> + BUG_ON(drm_buddy_block_size(mm, root) < chunk_size);
>> +
>> + mm->roots[i] = root;
>> +
>> + offset += root_size;
>> + size -= root_size;
>> + i++;
>> + } while (size);
>> +
>> + return 0;
>> +
>> +out_free_roots:
>> + while (i--)
>> + drm_block_free(mm, mm->roots[i]);
>> + kfree(mm->roots);
>> +out_free_list:
>> + kfree(mm->free_list);
>> + return -ENOMEM;
>> +}
>> +EXPORT_SYMBOL(drm_buddy_init);
>> +
>> +/**
>> + * drm_buddy_fini - tear down the memory manager
>> + *
>> + * @mm: DRM buddy manager to free
>> + *
>> + * Cleanup memory manager resources and the freelist
>> + */
>> +void drm_buddy_fini(struct drm_buddy_mm *mm)
>> +{
>> + int i;
>> +
>> + for (i = 0; i < mm->n_roots; ++i) {
>> + WARN_ON(!drm_buddy_block_is_free(mm->roots[i]));
>> + drm_block_free(mm, mm->roots[i]);
>> + }
>> +
>> + WARN_ON(mm->avail != mm->size);
>> +
>> + kfree(mm->roots);
>> + kfree(mm->free_list);
>> +}
>> +EXPORT_SYMBOL(drm_buddy_fini);
>> +
>> +static int split_block(struct drm_buddy_mm *mm,
>> + struct drm_buddy_block *block)
>> +{
>> + unsigned int block_order = drm_buddy_block_order(block) - 1;
>> + u64 offset = drm_buddy_block_offset(block);
>> +
>> + BUG_ON(!drm_buddy_block_is_free(block));
>> + BUG_ON(!drm_buddy_block_order(block));
>> +
>> + block->left = drm_block_alloc(mm, block, block_order, offset);
>> + if (!block->left)
>> + return -ENOMEM;
>> +
>> + block->right = drm_block_alloc(mm, block, block_order,
>> + offset + (mm->chunk_size << block_order));
>> + if (!block->right) {
>> + drm_block_free(mm, block->left);
>> + return -ENOMEM;
>> + }
>> +
>> + mark_free(mm, block->left);
>> + mark_free(mm, block->right);
>> +
>> + mark_split(block);
>> +
>> + return 0;
>> +}
>> +
>> +static struct drm_buddy_block *
>> +get_buddy(struct drm_buddy_block *block)
>> +{
>> + struct drm_buddy_block *parent;
>> +
>> + parent = block->parent;
>> + if (!parent)
>> + return NULL;
>> +
>> + if (parent->left == block)
>> + return parent->right;
>> +
>> + return parent->left;
>> +}
>> +
>> +static void __drm_buddy_free(struct drm_buddy_mm *mm,
>> + struct drm_buddy_block *block)
>> +{
>> + struct drm_buddy_block *parent;
>> +
>> + while ((parent = block->parent)) {
>> + struct drm_buddy_block *buddy;
>> +
>> + buddy = get_buddy(block);
>> +
>> + if (!drm_buddy_block_is_free(buddy))
>> + break;
>> +
>> + list_del(&buddy->link);
>> +
>> + drm_block_free(mm, block);
>> + drm_block_free(mm, buddy);
>> +
>> + block = parent;
>> + }
>> +
>> + mark_free(mm, block);
>> +}
>> +
>> +void drm_buddy_free(struct drm_buddy_mm *mm,
>> + struct drm_buddy_block *block)
>> +{
>> + BUG_ON(!drm_buddy_block_is_allocated(block));
>> + mm->avail += drm_buddy_block_size(mm, block);
>> + __drm_buddy_free(mm, block);
>> +}
>> +
>> +/**
>> + * drm_buddy_free_list - free blocks
>> + *
>> + * @mm: DRM buddy manager
>> + * @objects: input list head to free blocks
>> + */
>> +void drm_buddy_free_list(struct drm_buddy_mm *mm, struct list_head *objects)
>> +{
>> + struct drm_buddy_block *block, *on;
>> +
>> + list_for_each_entry_safe(block, on, objects, link) {
>> + drm_buddy_free(mm, block);
>> + cond_resched();
>> + }
>> + INIT_LIST_HEAD(objects);
>> +}
>> +EXPORT_SYMBOL(drm_buddy_free_list);
>> +
>> +/**
>> + * drm_buddy_alloc - allocate power-of-two blocks
>> + *
>> + * @mm: DRM buddy manager to allocate from
>> + * @order: size of the allocation
>> + *
>> + * The order value here translates to:
>> + *
>> + * 0 = 2^0 * mm->chunk_size
>> + * 1 = 2^1 * mm->chunk_size
>> + * 2 = 2^2 * mm->chunk_size
>> + *
>> + * Returns:
>> + * allocated ptr to the &drm_buddy_block on success
>> + */
>> +struct drm_buddy_block *
>> +drm_buddy_alloc(struct drm_buddy_mm *mm, unsigned int order)
>> +{
>> + struct drm_buddy_block *block = NULL;
>> + unsigned int i;
>> + int err;
>> +
>> + for (i = order; i <= mm->max_order; ++i) {
>> + block = list_first_entry_or_null(&mm->free_list[i],
>> + struct drm_buddy_block,
>> + link);
>> + if (block)
>> + break;
>> + }
>> +
>> + if (!block)
>> + return ERR_PTR(-ENOSPC);
>> +
>> + BUG_ON(!drm_buddy_block_is_free(block));
>> +
>> + while (i != order) {
>> + err = split_block(mm, block);
>> + if (unlikely(err))
>> + goto out_free;
>> +
>> + /* Go low */
>> + block = block->left;
>> + i--;
>> + }
>> +
>> + mark_allocated(block);
>> + mm->avail -= drm_buddy_block_size(mm, block);
>> + kmemleak_update_trace(block);
>> + return block;
>> +
>> +out_free:
>> + if (i != order)
>> + __drm_buddy_free(mm, block);
>> + return ERR_PTR(err);
>> +}
>> +EXPORT_SYMBOL(drm_buddy_alloc);
>> +
>> +static inline bool overlaps(u64 s1, u64 e1, u64 s2, u64 e2)
>> +{
>> + return s1 <= e2 && e1 >= s2;
>> +}
>> +
>> +static inline bool contains(u64 s1, u64 e1, u64 s2, u64 e2)
>> +{
>> + return s1 <= s2 && e1 >= e2;
>> +}
>> +
>> +/**
>> + * drm_buddy_alloc_range - allocate range
>> + *
>> + * @mm: DRM buddy manager to allocate from
>> + * @blocks: output list head to add allocated blocks
>> + * @start: start of the allowed range for this block
>> + * @size: size of the allocation
>> + *
>> + * Intended for pre-allocating portions of the address space, for example to
>> + * reserve a block for the initial framebuffer or similar, hence the expectation
>> + * here is that drm_buddy_alloc() is still the main vehicle for
>> + * allocations, so if that's not the case then the drm_mm range allocator is
>> + * probably a much better fit, and so you should probably go use that instead.
>> + *
>> + * Note that it's safe to chain together multiple alloc_ranges
>> + * with the same blocks list
>> + *
>> + * Returns:
>> + * 0 on success, error code on failure.
>> + */
>> +int drm_buddy_alloc_range(struct drm_buddy_mm *mm,
>> + struct list_head *blocks,
>> + u64 start, u64 size)
>> +{
>> + struct drm_buddy_block *block;
>> + struct drm_buddy_block *buddy;
>> + LIST_HEAD(allocated);
>> + LIST_HEAD(dfs);
>> + u64 end;
>> + int err;
>> + int i;
>> +
>> + if (size < mm->chunk_size)
>> + return -EINVAL;
>> +
>> + if (!IS_ALIGNED(size | start, mm->chunk_size))
>> + return -EINVAL;
>> +
>> + if (range_overflows(start, size, mm->size))
>> + return -EINVAL;
>> +
>> + for (i = 0; i < mm->n_roots; ++i)
>> + list_add_tail(&mm->roots[i]->tmp_link, &dfs);
>> +
>> + end = start + size - 1;
>> +
>> + do {
>> + u64 block_start;
>> + u64 block_end;
>> +
>> + block = list_first_entry_or_null(&dfs,
>> + struct drm_buddy_block,
>> + tmp_link);
>> + if (!block)
>> + break;
>> +
>> + list_del(&block->tmp_link);
>> +
>> + block_start = drm_buddy_block_offset(block);
>> + block_end = block_start + drm_buddy_block_size(mm, block) - 1;
>> +
>> + if (!overlaps(start, end, block_start, block_end))
>> + continue;
>> +
>> + if (drm_buddy_block_is_allocated(block)) {
>> + err = -ENOSPC;
>> + goto err_free;
>> + }
>> +
>> + if (contains(start, end, block_start, block_end)) {
>> + if (!drm_buddy_block_is_free(block)) {
>> + err = -ENOSPC;
>> + goto err_free;
>> + }
>> +
>> + mark_allocated(block);
>> + mm->avail -= drm_buddy_block_size(mm, block);
>> + list_add_tail(&block->link, &allocated);
>> + continue;
>> + }
>> +
>> + if (!drm_buddy_block_is_split(block)) {
>> + err = split_block(mm, block);
>> + if (unlikely(err))
>> + goto err_undo;
>> + }
>> +
>> + list_add(&block->right->tmp_link, &dfs);
>> + list_add(&block->left->tmp_link, &dfs);
>> + } while (1);
>> +
>> + list_splice_tail(&allocated, blocks);
>> + return 0;
>> +
>> +err_undo:
>> + /*
>> + * We really don't want to leave around a bunch of split blocks, since
>> + * bigger is better, so make sure we merge everything back before we
>> + * free the allocated blocks.
>> + */
>> + buddy = get_buddy(block);
>> + if (buddy &&
>> + (drm_buddy_block_is_free(block) &&
>> + drm_buddy_block_is_free(buddy)))
>> + __drm_buddy_free(mm, block);
>> +
>> +err_free:
>> + drm_buddy_free_list(mm, &allocated);
>> + return err;
>> +}
>> +EXPORT_SYMBOL(drm_buddy_alloc_range);
>> +
>> +/**
>> + * drm_buddy_block_print - print block information
>> + *
>> + * @mm: DRM buddy manager
>> + * @block: DRM buddy block
>> + * @p: DRM printer to use
>> + */
>> +void drm_buddy_block_print(struct drm_buddy_mm *mm,
>> + struct drm_buddy_block *block,
>> + struct drm_printer *p)
>> +{
>> + u64 start = drm_buddy_block_offset(block);
>> + u64 size = drm_buddy_block_size(mm, block);
>> +
>> + drm_printf(p, "%#018llx-%#018llx: %llu\n", start, start + size, size);
>> +}
>> +EXPORT_SYMBOL(drm_buddy_block_print);
>> +
>> +/**
>> + * drm_buddy_print - print allocator state
>> + *
>> + * @mm: DRM buddy manager
>> + * @p: DRM printer to use
>> + */
>> +void drm_buddy_print(struct drm_buddy_mm *mm, struct drm_printer *p)
>> +{
>> + int order;
>> +
>> + drm_printf(p, "chunk_size: %lluKiB, total: %lluMiB, free: %lluMiB\n",
>> + mm->chunk_size >> 10, mm->size >> 20, mm->avail >> 20);
>> +
>> + for (order = mm->max_order; order >= 0; order--) {
>> + struct drm_buddy_block *block;
>> + u64 count = 0, free;
>> +
>> + list_for_each_entry(block, &mm->free_list[order], link) {
>> + BUG_ON(!drm_buddy_block_is_free(block));
>> + count++;
>> + }
>> +
>> + drm_printf(p, "order-%d ", order);
>> +
>> + free = count * (mm->chunk_size << order);
>> + if (free < SZ_1M)
>> + drm_printf(p, "free: %lluKiB", free >> 10);
>> + else
>> + drm_printf(p, "free: %lluMiB", free >> 20);
>> +
>> + drm_printf(p, ", pages: %llu\n", count);
>> + }
>> +}
>> +EXPORT_SYMBOL(drm_buddy_print);
>> +
>> +void drm_buddy_module_exit(void)
>> +{
>> + kmem_cache_destroy(slab_blocks);
>> +}
>> +
>> +int __init drm_buddy_module_init(void)
>> +{
>> + slab_blocks = KMEM_CACHE(drm_buddy_block, 0);
>> + if (!slab_blocks)
>> + return -ENOMEM;
>> +
>> + return 0;
>> +}
>> diff --git a/drivers/gpu/drm/drm_drv.c b/drivers/gpu/drm/drm_drv.c
>> index 7a5097467ba5..5d5e46e60586 100644
>> --- a/drivers/gpu/drm/drm_drv.c
>> +++ b/drivers/gpu/drm/drm_drv.c
>> @@ -35,6 +35,7 @@
>> #include <linux/slab.h>
>> #include <linux/srcu.h>
>>
>> +#include <drm/drm_buddy.h>
>> #include <drm/drm_cache.h>
>> #include <drm/drm_client.h>
>> #include <drm/drm_color_mgmt.h>
>> @@ -1034,6 +1035,7 @@ static void drm_core_exit(void)
>> drm_sysfs_destroy();
>> idr_destroy(&drm_minors_idr);
>> drm_connector_ida_destroy();
>> + drm_buddy_module_exit();
>> }
>>
>> static int __init drm_core_init(void)
>> @@ -1043,6 +1045,7 @@ static int __init drm_core_init(void)
>> drm_connector_ida_init();
>> idr_init(&drm_minors_idr);
>> drm_memcpy_init_early();
>> + drm_buddy_module_init();
>>
>> ret = drm_sysfs_init();
>> if (ret < 0) {
>> diff --git a/drivers/gpu/drm/i915/Makefile b/drivers/gpu/drm/i915/Makefile
>> index 467872cca027..fc5ca8c4ccb2 100644
>> --- a/drivers/gpu/drm/i915/Makefile
>> +++ b/drivers/gpu/drm/i915/Makefile
>> @@ -161,7 +161,6 @@ gem-y += \
>> i915-y += \
>> $(gem-y) \
>> i915_active.o \
>> - i915_buddy.o \
>> i915_cmd_parser.o \
>> i915_gem_evict.o \
>> i915_gem_gtt.o \
>> diff --git a/drivers/gpu/drm/i915/i915_buddy.c b/drivers/gpu/drm/i915/i915_buddy.c
>> deleted file mode 100644
>> index 6e2ad68f8f3f..000000000000
>> --- a/drivers/gpu/drm/i915/i915_buddy.c
>> +++ /dev/null
>> @@ -1,466 +0,0 @@
>> -// SPDX-License-Identifier: MIT
>> -/*
>> - * Copyright © 2021 Intel Corporation
>> - */
>> -
>> -#include <linux/kmemleak.h>
>> -#include <linux/sizes.h>
>> -
>> -#include "i915_buddy.h"
>> -
>> -#include "i915_gem.h"
>> -#include "i915_utils.h"
>> -
>> -static struct kmem_cache *slab_blocks;
>> -
>> -static struct i915_buddy_block *i915_block_alloc(struct i915_buddy_mm *mm,
>> - struct i915_buddy_block *parent,
>> - unsigned int order,
>> - u64 offset)
>> -{
>> - struct i915_buddy_block *block;
>> -
>> - GEM_BUG_ON(order > I915_BUDDY_MAX_ORDER);
>> -
>> - block = kmem_cache_zalloc(slab_blocks, GFP_KERNEL);
>> - if (!block)
>> - return NULL;
>> -
>> - block->header = offset;
>> - block->header |= order;
>> - block->parent = parent;
>> -
>> - GEM_BUG_ON(block->header & I915_BUDDY_HEADER_UNUSED);
>> - return block;
>> -}
>> -
>> -static void i915_block_free(struct i915_buddy_mm *mm,
>> - struct i915_buddy_block *block)
>> -{
>> - kmem_cache_free(slab_blocks, block);
>> -}
>> -
>> -static void mark_allocated(struct i915_buddy_block *block)
>> -{
>> - block->header &= ~I915_BUDDY_HEADER_STATE;
>> - block->header |= I915_BUDDY_ALLOCATED;
>> -
>> - list_del(&block->link);
>> -}
>> -
>> -static void mark_free(struct i915_buddy_mm *mm,
>> - struct i915_buddy_block *block)
>> -{
>> - block->header &= ~I915_BUDDY_HEADER_STATE;
>> - block->header |= I915_BUDDY_FREE;
>> -
>> - list_add(&block->link,
>> - &mm->free_list[i915_buddy_block_order(block)]);
>> -}
>> -
>> -static void mark_split(struct i915_buddy_block *block)
>> -{
>> - block->header &= ~I915_BUDDY_HEADER_STATE;
>> - block->header |= I915_BUDDY_SPLIT;
>> -
>> - list_del(&block->link);
>> -}
>> -
>> -int i915_buddy_init(struct i915_buddy_mm *mm, u64 size, u64 chunk_size)
>> -{
>> - unsigned int i;
>> - u64 offset;
>> -
>> - if (size < chunk_size)
>> - return -EINVAL;
>> -
>> - if (chunk_size < PAGE_SIZE)
>> - return -EINVAL;
>> -
>> - if (!is_power_of_2(chunk_size))
>> - return -EINVAL;
>> -
>> - size = round_down(size, chunk_size);
>> -
>> - mm->size = size;
>> - mm->avail = size;
>> - mm->chunk_size = chunk_size;
>> - mm->max_order = ilog2(size) - ilog2(chunk_size);
>> -
>> - GEM_BUG_ON(mm->max_order > I915_BUDDY_MAX_ORDER);
>> -
>> - mm->free_list = kmalloc_array(mm->max_order + 1,
>> - sizeof(struct list_head),
>> - GFP_KERNEL);
>> - if (!mm->free_list)
>> - return -ENOMEM;
>> -
>> - for (i = 0; i <= mm->max_order; ++i)
>> - INIT_LIST_HEAD(&mm->free_list[i]);
>> -
>> - mm->n_roots = hweight64(size);
>> -
>> - mm->roots = kmalloc_array(mm->n_roots,
>> - sizeof(struct i915_buddy_block *),
>> - GFP_KERNEL);
>> - if (!mm->roots)
>> - goto out_free_list;
>> -
>> - offset = 0;
>> - i = 0;
>> -
>> - /*
>> - * Split into power-of-two blocks, in case we are given a size that is
>> - * not itself a power-of-two.
>> - */
>> - do {
>> - struct i915_buddy_block *root;
>> - unsigned int order;
>> - u64 root_size;
>> -
>> - root_size = rounddown_pow_of_two(size);
>> - order = ilog2(root_size) - ilog2(chunk_size);
>> -
>> - root = i915_block_alloc(mm, NULL, order, offset);
>> - if (!root)
>> - goto out_free_roots;
>> -
>> - mark_free(mm, root);
>> -
>> - GEM_BUG_ON(i > mm->max_order);
>> - GEM_BUG_ON(i915_buddy_block_size(mm, root) < chunk_size);
>> -
>> - mm->roots[i] = root;
>> -
>> - offset += root_size;
>> - size -= root_size;
>> - i++;
>> - } while (size);
>> -
>> - return 0;
>> -
>> -out_free_roots:
>> - while (i--)
>> - i915_block_free(mm, mm->roots[i]);
>> - kfree(mm->roots);
>> -out_free_list:
>> - kfree(mm->free_list);
>> - return -ENOMEM;
>> -}
>> -
>> -void i915_buddy_fini(struct i915_buddy_mm *mm)
>> -{
>> - int i;
>> -
>> - for (i = 0; i < mm->n_roots; ++i) {
>> - GEM_WARN_ON(!i915_buddy_block_is_free(mm->roots[i]));
>> - i915_block_free(mm, mm->roots[i]);
>> - }
>> -
>> - GEM_WARN_ON(mm->avail != mm->size);
>> -
>> - kfree(mm->roots);
>> - kfree(mm->free_list);
>> -}
>> -
>> -static int split_block(struct i915_buddy_mm *mm,
>> - struct i915_buddy_block *block)
>> -{
>> - unsigned int block_order = i915_buddy_block_order(block) - 1;
>> - u64 offset = i915_buddy_block_offset(block);
>> -
>> - GEM_BUG_ON(!i915_buddy_block_is_free(block));
>> - GEM_BUG_ON(!i915_buddy_block_order(block));
>> -
>> - block->left = i915_block_alloc(mm, block, block_order, offset);
>> - if (!block->left)
>> - return -ENOMEM;
>> -
>> - block->right = i915_block_alloc(mm, block, block_order,
>> - offset + (mm->chunk_size << block_order));
>> - if (!block->right) {
>> - i915_block_free(mm, block->left);
>> - return -ENOMEM;
>> - }
>> -
>> - mark_free(mm, block->left);
>> - mark_free(mm, block->right);
>> -
>> - mark_split(block);
>> -
>> - return 0;
>> -}
>> -
>> -static struct i915_buddy_block *
>> -get_buddy(struct i915_buddy_block *block)
>> -{
>> - struct i915_buddy_block *parent;
>> -
>> - parent = block->parent;
>> - if (!parent)
>> - return NULL;
>> -
>> - if (parent->left == block)
>> - return parent->right;
>> -
>> - return parent->left;
>> -}
>> -
>> -static void __i915_buddy_free(struct i915_buddy_mm *mm,
>> - struct i915_buddy_block *block)
>> -{
>> - struct i915_buddy_block *parent;
>> -
>> - while ((parent = block->parent)) {
>> - struct i915_buddy_block *buddy;
>> -
>> - buddy = get_buddy(block);
>> -
>> - if (!i915_buddy_block_is_free(buddy))
>> - break;
>> -
>> - list_del(&buddy->link);
>> -
>> - i915_block_free(mm, block);
>> - i915_block_free(mm, buddy);
>> -
>> - block = parent;
>> - }
>> -
>> - mark_free(mm, block);
>> -}
>> -
>> -void i915_buddy_free(struct i915_buddy_mm *mm,
>> - struct i915_buddy_block *block)
>> -{
>> - GEM_BUG_ON(!i915_buddy_block_is_allocated(block));
>> - mm->avail += i915_buddy_block_size(mm, block);
>> - __i915_buddy_free(mm, block);
>> -}
>> -
>> -void i915_buddy_free_list(struct i915_buddy_mm *mm, struct list_head *objects)
>> -{
>> - struct i915_buddy_block *block, *on;
>> -
>> - list_for_each_entry_safe(block, on, objects, link) {
>> - i915_buddy_free(mm, block);
>> - cond_resched();
>> - }
>> - INIT_LIST_HEAD(objects);
>> -}
>> -
>> -/*
>> - * Allocate power-of-two block. The order value here translates to:
>> - *
>> - * 0 = 2^0 * mm->chunk_size
>> - * 1 = 2^1 * mm->chunk_size
>> - * 2 = 2^2 * mm->chunk_size
>> - * ...
>> - */
>> -struct i915_buddy_block *
>> -i915_buddy_alloc(struct i915_buddy_mm *mm, unsigned int order)
>> -{
>> - struct i915_buddy_block *block = NULL;
>> - unsigned int i;
>> - int err;
>> -
>> - for (i = order; i <= mm->max_order; ++i) {
>> - block = list_first_entry_or_null(&mm->free_list[i],
>> - struct i915_buddy_block,
>> - link);
>> - if (block)
>> - break;
>> - }
>> -
>> - if (!block)
>> - return ERR_PTR(-ENOSPC);
>> -
>> - GEM_BUG_ON(!i915_buddy_block_is_free(block));
>> -
>> - while (i != order) {
>> - err = split_block(mm, block);
>> - if (unlikely(err))
>> - goto out_free;
>> -
>> - /* Go low */
>> - block = block->left;
>> - i--;
>> - }
>> -
>> - mark_allocated(block);
>> - mm->avail -= i915_buddy_block_size(mm, block);
>> - kmemleak_update_trace(block);
>> - return block;
>> -
>> -out_free:
>> - if (i != order)
>> - __i915_buddy_free(mm, block);
>> - return ERR_PTR(err);
>> -}
>> -
>> -static inline bool overlaps(u64 s1, u64 e1, u64 s2, u64 e2)
>> -{
>> - return s1 <= e2 && e1 >= s2;
>> -}
>> -
>> -static inline bool contains(u64 s1, u64 e1, u64 s2, u64 e2)
>> -{
>> - return s1 <= s2 && e1 >= e2;
>> -}
>> -
>> -/*
>> - * Allocate range. Note that it's safe to chain together multiple alloc_ranges
>> - * with the same blocks list.
>> - *
>> - * Intended for pre-allocating portions of the address space, for example to
>> - * reserve a block for the initial framebuffer or similar, hence the expectation
>> - * here is that i915_buddy_alloc() is still the main vehicle for
>> - * allocations, so if that's not the case then the drm_mm range allocator is
>> - * probably a much better fit, and so you should probably go use that instead.
>> - */
>> -int i915_buddy_alloc_range(struct i915_buddy_mm *mm,
>> - struct list_head *blocks,
>> - u64 start, u64 size)
>> -{
>> - struct i915_buddy_block *block;
>> - struct i915_buddy_block *buddy;
>> - LIST_HEAD(allocated);
>> - LIST_HEAD(dfs);
>> - u64 end;
>> - int err;
>> - int i;
>> -
>> - if (size < mm->chunk_size)
>> - return -EINVAL;
>> -
>> - if (!IS_ALIGNED(size | start, mm->chunk_size))
>> - return -EINVAL;
>> -
>> - if (range_overflows(start, size, mm->size))
>> - return -EINVAL;
>> -
>> - for (i = 0; i < mm->n_roots; ++i)
>> - list_add_tail(&mm->roots[i]->tmp_link, &dfs);
>> -
>> - end = start + size - 1;
>> -
>> - do {
>> - u64 block_start;
>> - u64 block_end;
>> -
>> - block = list_first_entry_or_null(&dfs,
>> - struct i915_buddy_block,
>> - tmp_link);
>> - if (!block)
>> - break;
>> -
>> - list_del(&block->tmp_link);
>> -
>> - block_start = i915_buddy_block_offset(block);
>> - block_end = block_start + i915_buddy_block_size(mm, block) - 1;
>> -
>> - if (!overlaps(start, end, block_start, block_end))
>> - continue;
>> -
>> - if (i915_buddy_block_is_allocated(block)) {
>> - err = -ENOSPC;
>> - goto err_free;
>> - }
>> -
>> - if (contains(start, end, block_start, block_end)) {
>> - if (!i915_buddy_block_is_free(block)) {
>> - err = -ENOSPC;
>> - goto err_free;
>> - }
>> -
>> - mark_allocated(block);
>> - mm->avail -= i915_buddy_block_size(mm, block);
>> - list_add_tail(&block->link, &allocated);
>> - continue;
>> - }
>> -
>> - if (!i915_buddy_block_is_split(block)) {
>> - err = split_block(mm, block);
>> - if (unlikely(err))
>> - goto err_undo;
>> - }
>> -
>> - list_add(&block->right->tmp_link, &dfs);
>> - list_add(&block->left->tmp_link, &dfs);
>> - } while (1);
>> -
>> - list_splice_tail(&allocated, blocks);
>> - return 0;
>> -
>> -err_undo:
>> - /*
>> - * We really don't want to leave around a bunch of split blocks, since
>> - * bigger is better, so make sure we merge everything back before we
>> - * free the allocated blocks.
>> - */
>> - buddy = get_buddy(block);
>> - if (buddy &&
>> - (i915_buddy_block_is_free(block) &&
>> - i915_buddy_block_is_free(buddy)))
>> - __i915_buddy_free(mm, block);
>> -
>> -err_free:
>> - i915_buddy_free_list(mm, &allocated);
>> - return err;
>> -}
>> -
>> -void i915_buddy_block_print(struct i915_buddy_mm *mm,
>> - struct i915_buddy_block *block,
>> - struct drm_printer *p)
>> -{
>> - u64 start = i915_buddy_block_offset(block);
>> - u64 size = i915_buddy_block_size(mm, block);
>> -
>> - drm_printf(p, "%#018llx-%#018llx: %llu\n", start, start + size, size);
>> -}
>> -
>> -void i915_buddy_print(struct i915_buddy_mm *mm, struct drm_printer *p)
>> -{
>> - int order;
>> -
>> - drm_printf(p, "chunk_size: %lluKiB, total: %lluMiB, free: %lluMiB\n",
>> - mm->chunk_size >> 10, mm->size >> 20, mm->avail >> 20);
>> -
>> - for (order = mm->max_order; order >= 0; order--) {
>> - struct i915_buddy_block *block;
>> - u64 count = 0, free;
>> -
>> - list_for_each_entry(block, &mm->free_list[order], link) {
>> - GEM_BUG_ON(!i915_buddy_block_is_free(block));
>> - count++;
>> - }
>> -
>> - drm_printf(p, "order-%d ", order);
>> -
>> - free = count * (mm->chunk_size << order);
>> - if (free < SZ_1M)
>> - drm_printf(p, "free: %lluKiB", free >> 10);
>> - else
>> - drm_printf(p, "free: %lluMiB", free >> 20);
>> -
>> - drm_printf(p, ", pages: %llu\n", count);
>> - }
>> -}
>> -
>> -#if IS_ENABLED(CONFIG_DRM_I915_SELFTEST)
>> -#include "selftests/i915_buddy.c"
>> -#endif
>> -
>> -void i915_buddy_module_exit(void)
>> -{
>> - kmem_cache_destroy(slab_blocks);
>> -}
>> -
>> -int __init i915_buddy_module_init(void)
>> -{
>> - slab_blocks = KMEM_CACHE(i915_buddy_block, 0);
>> - if (!slab_blocks)
>> - return -ENOMEM;
>> -
>> - return 0;
>> -}
>> diff --git a/drivers/gpu/drm/i915/i915_buddy.h b/drivers/gpu/drm/i915/i915_buddy.h
>> deleted file mode 100644
>> index 7077742112ac..000000000000
>> --- a/drivers/gpu/drm/i915/i915_buddy.h
>> +++ /dev/null
>> @@ -1,143 +0,0 @@
>> -/* SPDX-License-Identifier: MIT */
>> -/*
>> - * Copyright © 2021 Intel Corporation
>> - */
>> -
>> -#ifndef __I915_BUDDY_H__
>> -#define __I915_BUDDY_H__
>> -
>> -#include <linux/bitops.h>
>> -#include <linux/list.h>
>> -#include <linux/slab.h>
>> -
>> -#include <drm/drm_print.h>
>> -
>> -struct i915_buddy_block {
>> -#define I915_BUDDY_HEADER_OFFSET GENMASK_ULL(63, 12)
>> -#define I915_BUDDY_HEADER_STATE GENMASK_ULL(11, 10)
>> -#define I915_BUDDY_ALLOCATED (1 << 10)
>> -#define I915_BUDDY_FREE (2 << 10)
>> -#define I915_BUDDY_SPLIT (3 << 10)
>> -/* Free to be used, if needed in the future */
>> -#define I915_BUDDY_HEADER_UNUSED GENMASK_ULL(9, 6)
>> -#define I915_BUDDY_HEADER_ORDER GENMASK_ULL(5, 0)
>> - u64 header;
>> -
>> - struct i915_buddy_block *left;
>> - struct i915_buddy_block *right;
>> - struct i915_buddy_block *parent;
>> -
>> - void *private; /* owned by creator */
>> -
>> - /*
>> - * While the block is allocated by the user through i915_buddy_alloc*,
>> - * the user has ownership of the link, for example to maintain within
>> - * a list, if so desired. As soon as the block is freed with
>> - * i915_buddy_free* ownership is given back to the mm.
>> - */
>> - struct list_head link;
>> - struct list_head tmp_link;
>> -};
>> -
>> -/* Order-zero must be at least PAGE_SIZE */
>> -#define I915_BUDDY_MAX_ORDER (63 - PAGE_SHIFT)
>> -
>> -/*
>> - * Binary Buddy System.
>> - *
>> - * Locking should be handled by the user, a simple mutex around
>> - * i915_buddy_alloc* and i915_buddy_free* should suffice.
>> - */
>> -struct i915_buddy_mm {
>> - /* Maintain a free list for each order. */
>> - struct list_head *free_list;
>> -
>> - /*
>> - * Maintain explicit binary tree(s) to track the allocation of the
>> - * address space. This gives us a simple way of finding a buddy block
>> - * and performing the potentially recursive merge step when freeing a
>> - * block. Nodes are either allocated or free, in which case they will
>> - * also exist on the respective free list.
>> - */
>> - struct i915_buddy_block **roots;
>> -
>> - /*
>> - * Anything from here is public, and remains static for the lifetime of
>> - * the mm. Everything above is considered do-not-touch.
>> - */
>> - unsigned int n_roots;
>> - unsigned int max_order;
>> -
>> - /* Must be at least PAGE_SIZE */
>> - u64 chunk_size;
>> - u64 size;
>> - u64 avail;
>> -};
>> -
>> -static inline u64
>> -i915_buddy_block_offset(struct i915_buddy_block *block)
>> -{
>> - return block->header & I915_BUDDY_HEADER_OFFSET;
>> -}
>> -
>> -static inline unsigned int
>> -i915_buddy_block_order(struct i915_buddy_block *block)
>> -{
>> - return block->header & I915_BUDDY_HEADER_ORDER;
>> -}
>> -
>> -static inline unsigned int
>> -i915_buddy_block_state(struct i915_buddy_block *block)
>> -{
>> - return block->header & I915_BUDDY_HEADER_STATE;
>> -}
>> -
>> -static inline bool
>> -i915_buddy_block_is_allocated(struct i915_buddy_block *block)
>> -{
>> - return i915_buddy_block_state(block) == I915_BUDDY_ALLOCATED;
>> -}
>> -
>> -static inline bool
>> -i915_buddy_block_is_free(struct i915_buddy_block *block)
>> -{
>> - return i915_buddy_block_state(block) == I915_BUDDY_FREE;
>> -}
>> -
>> -static inline bool
>> -i915_buddy_block_is_split(struct i915_buddy_block *block)
>> -{
>> - return i915_buddy_block_state(block) == I915_BUDDY_SPLIT;
>> -}
>> -
>> -static inline u64
>> -i915_buddy_block_size(struct i915_buddy_mm *mm,
>> - struct i915_buddy_block *block)
>> -{
>> - return mm->chunk_size << i915_buddy_block_order(block);
>> -}
>> -
>> -int i915_buddy_init(struct i915_buddy_mm *mm, u64 size, u64 chunk_size);
>> -
>> -void i915_buddy_fini(struct i915_buddy_mm *mm);
>> -
>> -struct i915_buddy_block *
>> -i915_buddy_alloc(struct i915_buddy_mm *mm, unsigned int order);
>> -
>> -int i915_buddy_alloc_range(struct i915_buddy_mm *mm,
>> - struct list_head *blocks,
>> - u64 start, u64 size);
>> -
>> -void i915_buddy_free(struct i915_buddy_mm *mm, struct i915_buddy_block *block);
>> -
>> -void i915_buddy_free_list(struct i915_buddy_mm *mm, struct list_head *objects);
>> -
>> -void i915_buddy_print(struct i915_buddy_mm *mm, struct drm_printer *p);
>> -void i915_buddy_block_print(struct i915_buddy_mm *mm,
>> - struct i915_buddy_block *block,
>> - struct drm_printer *p);
>> -
>> -void i915_buddy_module_exit(void);
>> -int i915_buddy_module_init(void);
>> -
>> -#endif
>> diff --git a/drivers/gpu/drm/i915/i915_module.c b/drivers/gpu/drm/i915/i915_module.c
>> index c7507266aa83..355681dbd7a8 100644
>> --- a/drivers/gpu/drm/i915/i915_module.c
>> +++ b/drivers/gpu/drm/i915/i915_module.c
>> @@ -9,7 +9,6 @@
>> #include "gem/i915_gem_context.h"
>> #include "gem/i915_gem_object.h"
>> #include "i915_active.h"
>> -#include "i915_buddy.h"
>> #include "i915_params.h"
>> #include "i915_pci.h"
>> #include "i915_perf.h"
>> @@ -50,8 +49,6 @@ static const struct {
>> { .init = i915_check_nomodeset },
>> { .init = i915_active_module_init,
>> .exit = i915_active_module_exit },
>> - { .init = i915_buddy_module_init,
>> - .exit = i915_buddy_module_exit },
>> { .init = i915_context_module_init,
>> .exit = i915_context_module_exit },
>> { .init = i915_gem_context_module_init,
>> diff --git a/drivers/gpu/drm/i915/i915_scatterlist.c b/drivers/gpu/drm/i915/i915_scatterlist.c
>> index 4a6712dca838..84d622aa32d2 100644
>> --- a/drivers/gpu/drm/i915/i915_scatterlist.c
>> +++ b/drivers/gpu/drm/i915/i915_scatterlist.c
>> @@ -5,10 +5,9 @@
>> */
>>
>> #include "i915_scatterlist.h"
>> -
>> -#include "i915_buddy.h"
>> #include "i915_ttm_buddy_manager.h"
>>
>> +#include <drm/drm_buddy.h>
>> #include <drm/drm_mm.h>
>>
>> #include <linux/slab.h>
>> @@ -126,9 +125,9 @@ struct sg_table *i915_sg_from_buddy_resource(struct ttm_resource *res,
>> struct i915_ttm_buddy_resource *bman_res = to_ttm_buddy_resource(res);
>> const u64 size = res->num_pages << PAGE_SHIFT;
>> const u64 max_segment = rounddown(UINT_MAX, PAGE_SIZE);
>> - struct i915_buddy_mm *mm = bman_res->mm;
>> + struct drm_buddy_mm *mm = bman_res->mm;
>> struct list_head *blocks = &bman_res->blocks;
>> - struct i915_buddy_block *block;
>> + struct drm_buddy_block *block;
>> struct scatterlist *sg;
>> struct sg_table *st;
>> resource_size_t prev_end;
>> @@ -151,8 +150,8 @@ struct sg_table *i915_sg_from_buddy_resource(struct ttm_resource *res,
>> list_for_each_entry(block, blocks, link) {
>> u64 block_size, offset;
>>
>> - block_size = min_t(u64, size, i915_buddy_block_size(mm, block));
>> - offset = i915_buddy_block_offset(block);
>> + block_size = min_t(u64, size, drm_buddy_block_size(mm, block));
>> + offset = drm_buddy_block_offset(block);
>>
>> while (block_size) {
>> u64 len;
>> diff --git a/drivers/gpu/drm/i915/i915_ttm_buddy_manager.c b/drivers/gpu/drm/i915/i915_ttm_buddy_manager.c
>> index d59fbb019032..c4b70cb8c248 100644
>> --- a/drivers/gpu/drm/i915/i915_ttm_buddy_manager.c
>> +++ b/drivers/gpu/drm/i915/i915_ttm_buddy_manager.c
>> @@ -8,14 +8,15 @@
>> #include <drm/ttm/ttm_bo_driver.h>
>> #include <drm/ttm/ttm_placement.h>
>>
>> +#include <drm/drm_buddy.h>
>> +
>> #include "i915_ttm_buddy_manager.h"
>>
>> -#include "i915_buddy.h"
>> #include "i915_gem.h"
>>
>> struct i915_ttm_buddy_manager {
>> struct ttm_resource_manager manager;
>> - struct i915_buddy_mm mm;
>> + struct drm_buddy_mm mm;
>> struct list_head reserved;
>> struct mutex lock;
>> u64 default_page_size;
>> @@ -34,7 +35,7 @@ static int i915_ttm_buddy_man_alloc(struct ttm_resource_manager *man,
>> {
>> struct i915_ttm_buddy_manager *bman = to_buddy_manager(man);
>> struct i915_ttm_buddy_resource *bman_res;
>> - struct i915_buddy_mm *mm = &bman->mm;
>> + struct drm_buddy_mm *mm = &bman->mm;
>> unsigned long n_pages;
>> unsigned int min_order;
>> u64 min_page_size;
>> @@ -73,7 +74,7 @@ static int i915_ttm_buddy_man_alloc(struct ttm_resource_manager *man,
>> n_pages = size >> ilog2(mm->chunk_size);
>>
>> do {
>> - struct i915_buddy_block *block;
>> + struct drm_buddy_block *block;
>> unsigned int order;
>>
>> order = fls(n_pages) - 1;
>> @@ -82,7 +83,7 @@ static int i915_ttm_buddy_man_alloc(struct ttm_resource_manager *man,
>>
>> do {
>> mutex_lock(&bman->lock);
>> - block = i915_buddy_alloc(mm, order);
>> + block = drm_buddy_alloc(mm, order);
>> mutex_unlock(&bman->lock);
>> if (!IS_ERR(block))
>> break;
>> @@ -106,7 +107,7 @@ static int i915_ttm_buddy_man_alloc(struct ttm_resource_manager *man,
>>
>> err_free_blocks:
>> mutex_lock(&bman->lock);
>> - i915_buddy_free_list(mm, &bman_res->blocks);
>> + drm_buddy_free_list(mm, &bman_res->blocks);
>> mutex_unlock(&bman->lock);
>> err_free_res:
>> kfree(bman_res);
>> @@ -120,7 +121,7 @@ static void i915_ttm_buddy_man_free(struct ttm_resource_manager *man,
>> struct i915_ttm_buddy_manager *bman = to_buddy_manager(man);
>>
>> mutex_lock(&bman->lock);
>> - i915_buddy_free_list(&bman->mm, &bman_res->blocks);
>> + drm_buddy_free_list(&bman->mm, &bman_res->blocks);
>> mutex_unlock(&bman->lock);
>>
>> kfree(bman_res);
>> @@ -130,17 +131,17 @@ static void i915_ttm_buddy_man_debug(struct ttm_resource_manager *man,
>> struct drm_printer *printer)
>> {
>> struct i915_ttm_buddy_manager *bman = to_buddy_manager(man);
>> - struct i915_buddy_block *block;
>> + struct drm_buddy_block *block;
>>
>> mutex_lock(&bman->lock);
>> drm_printf(printer, "default_page_size: %lluKiB\n",
>> bman->default_page_size >> 10);
>>
>> - i915_buddy_print(&bman->mm, printer);
>> + drm_buddy_print(&bman->mm, printer);
>>
>> drm_printf(printer, "reserved:\n");
>> list_for_each_entry(block, &bman->reserved, link)
>> - i915_buddy_block_print(&bman->mm, block, printer);
>> + drm_buddy_block_print(&bman->mm, block, printer);
>> mutex_unlock(&bman->lock);
>> }
>>
>> @@ -190,7 +191,7 @@ int i915_ttm_buddy_man_init(struct ttm_device *bdev,
>> if (!bman)
>> return -ENOMEM;
>>
>> - err = i915_buddy_init(&bman->mm, size, chunk_size);
>> + err = drm_buddy_init(&bman->mm, size, chunk_size);
>> if (err)
>> goto err_free_bman;
>>
>> @@ -228,7 +229,7 @@ int i915_ttm_buddy_man_fini(struct ttm_device *bdev, unsigned int type)
>> {
>> struct ttm_resource_manager *man = ttm_manager_type(bdev, type);
>> struct i915_ttm_buddy_manager *bman = to_buddy_manager(man);
>> - struct i915_buddy_mm *mm = &bman->mm;
>> + struct drm_buddy_mm *mm = &bman->mm;
>> int ret;
>>
>> ttm_resource_manager_set_used(man, false);
>> @@ -240,8 +241,8 @@ int i915_ttm_buddy_man_fini(struct ttm_device *bdev, unsigned int type)
>> ttm_set_driver_manager(bdev, type, NULL);
>>
>> mutex_lock(&bman->lock);
>> - i915_buddy_free_list(mm, &bman->reserved);
>> - i915_buddy_fini(mm);
>> + drm_buddy_free_list(mm, &bman->reserved);
>> + drm_buddy_fini(mm);
>> mutex_unlock(&bman->lock);
>>
>> ttm_resource_manager_cleanup(man);
>> @@ -264,11 +265,11 @@ int i915_ttm_buddy_man_reserve(struct ttm_resource_manager *man,
>> u64 start, u64 size)
>> {
>> struct i915_ttm_buddy_manager *bman = to_buddy_manager(man);
>> - struct i915_buddy_mm *mm = &bman->mm;
>> + struct drm_buddy_mm *mm = &bman->mm;
>> int ret;
>>
>> mutex_lock(&bman->lock);
>> - ret = i915_buddy_alloc_range(mm, &bman->reserved, start, size);
>> + ret = drm_buddy_alloc_range(mm, &bman->reserved, start, size);
>> mutex_unlock(&bman->lock);
>>
>> return ret;
>> diff --git a/drivers/gpu/drm/i915/i915_ttm_buddy_manager.h b/drivers/gpu/drm/i915/i915_ttm_buddy_manager.h
>> index 0722d33f3e14..fa644b512c2e 100644
>> --- a/drivers/gpu/drm/i915/i915_ttm_buddy_manager.h
>> +++ b/drivers/gpu/drm/i915/i915_ttm_buddy_manager.h
>> @@ -13,7 +13,7 @@
>>
>> struct ttm_device;
>> struct ttm_resource_manager;
>> -struct i915_buddy_mm;
>> +struct drm_buddy_mm;
>>
>> /**
>> * struct i915_ttm_buddy_resource
>> @@ -28,7 +28,7 @@ struct i915_buddy_mm;
>> struct i915_ttm_buddy_resource {
>> struct ttm_resource base;
>> struct list_head blocks;
>> - struct i915_buddy_mm *mm;
>> + struct drm_buddy_mm *mm;
>> };
>>
>> /**
>> diff --git a/include/drm/drm_buddy.h b/include/drm/drm_buddy.h
>> new file mode 100644
>> index 000000000000..5ce3fc702f80
>> --- /dev/null
>> +++ b/include/drm/drm_buddy.h
>> @@ -0,0 +1,153 @@
>> +/* SPDX-License-Identifier: MIT */
>> +/*
>> + * Copyright © 2021 Intel Corporation
>> + */
>> +
>> +#ifndef __DRM_BUDDY_H__
>> +#define __DRM_BUDDY_H__
>> +
>> +#include <linux/bitops.h>
>> +#include <linux/list.h>
>> +#include <linux/slab.h>
>> +#include <linux/sched.h>
>> +
>> +#include <drm/drm_print.h>
>> +
>> +#define range_overflows(start, size, max) ({ \
>> + typeof(start) start__ = (start); \
>> + typeof(size) size__ = (size); \
>> + typeof(max) max__ = (max); \
>> + (void)(&start__ == &size__); \
>> + (void)(&start__ == &max__); \
>> + start__ >= max__ || size__ > max__ - start__; \
>> +})
>> +
>> +struct drm_buddy_block {
>> +#define DRM_BUDDY_HEADER_OFFSET GENMASK_ULL(63, 12)
>> +#define DRM_BUDDY_HEADER_STATE GENMASK_ULL(11, 10)
>> +#define DRM_BUDDY_ALLOCATED (1 << 10)
>> +#define DRM_BUDDY_FREE (2 << 10)
>> +#define DRM_BUDDY_SPLIT (3 << 10)
>> +/* Free to be used, if needed in the future */
>> +#define DRM_BUDDY_HEADER_UNUSED GENMASK_ULL(9, 6)
>> +#define DRM_BUDDY_HEADER_ORDER GENMASK_ULL(5, 0)
>> + u64 header;
>> +
>> + struct drm_buddy_block *left;
>> + struct drm_buddy_block *right;
>> + struct drm_buddy_block *parent;
>> +
>> + void *private; /* owned by creator */
>> +
>> + /*
>> + * While the block is allocated by the user through drm_buddy_alloc*,
>> + * the user has ownership of the link, for example to maintain within
>> + * a list, if so desired. As soon as the block is freed with
>> + * drm_buddy_free* ownership is given back to the mm.
>> + */
>> + struct list_head link;
>> + struct list_head tmp_link;
>> +};
>> +
>> +/* Order-zero must be at least PAGE_SIZE */
>> +#define DRM_BUDDY_MAX_ORDER (63 - PAGE_SHIFT)
>> +
>> +/*
>> + * Binary Buddy System.
>> + *
>> + * Locking should be handled by the user, a simple mutex around
>> + * drm_buddy_alloc* and drm_buddy_free* should suffice.
>> + */
>> +struct drm_buddy_mm {
>> + /* Maintain a free list for each order. */
>> + struct list_head *free_list;
>> +
>> + /*
>> + * Maintain explicit binary tree(s) to track the allocation of the
>> + * address space. This gives us a simple way of finding a buddy block
>> + * and performing the potentially recursive merge step when freeing a
>> + * block. Nodes are either allocated or free, in which case they will
>> + * also exist on the respective free list.
>> + */
>> + struct drm_buddy_block **roots;
>> +
>> + /*
>> + * Anything from here is public, and remains static for the lifetime of
>> + * the mm. Everything above is considered do-not-touch.
>> + */
>> + unsigned int n_roots;
>> + unsigned int max_order;
>> +
>> + /* Must be at least PAGE_SIZE */
>> + u64 chunk_size;
>> + u64 size;
>> + u64 avail;
>> +};
>> +
>> +static inline u64
>> +drm_buddy_block_offset(struct drm_buddy_block *block)
>> +{
>> + return block->header & DRM_BUDDY_HEADER_OFFSET;
>> +}
>> +
>> +static inline unsigned int
>> +drm_buddy_block_order(struct drm_buddy_block *block)
>> +{
>> + return block->header & DRM_BUDDY_HEADER_ORDER;
>> +}
>> +
>> +static inline unsigned int
>> +drm_buddy_block_state(struct drm_buddy_block *block)
>> +{
>> + return block->header & DRM_BUDDY_HEADER_STATE;
>> +}
>> +
>> +static inline bool
>> +drm_buddy_block_is_allocated(struct drm_buddy_block *block)
>> +{
>> + return drm_buddy_block_state(block) == DRM_BUDDY_ALLOCATED;
>> +}
>> +
>> +static inline bool
>> +drm_buddy_block_is_free(struct drm_buddy_block *block)
>> +{
>> + return drm_buddy_block_state(block) == DRM_BUDDY_FREE;
>> +}
>> +
>> +static inline bool
>> +drm_buddy_block_is_split(struct drm_buddy_block *block)
>> +{
>> + return drm_buddy_block_state(block) == DRM_BUDDY_SPLIT;
>> +}
>> +
>> +static inline u64
>> +drm_buddy_block_size(struct drm_buddy_mm *mm,
>> + struct drm_buddy_block *block)
>> +{
>> + return mm->chunk_size << drm_buddy_block_order(block);
>> +}
>> +
>> +int drm_buddy_init(struct drm_buddy_mm *mm, u64 size, u64 chunk_size);
>> +
>> +void drm_buddy_fini(struct drm_buddy_mm *mm);
>> +
>> +struct drm_buddy_block *
>> +drm_buddy_alloc(struct drm_buddy_mm *mm, unsigned int order);
>> +
>> +int drm_buddy_alloc_range(struct drm_buddy_mm *mm,
>> + struct list_head *blocks,
>> + u64 start, u64 size);
>> +
>> +void drm_buddy_free(struct drm_buddy_mm *mm, struct drm_buddy_block *block);
>> +
>> +void drm_buddy_free_list(struct drm_buddy_mm *mm, struct list_head *objects);
>> +
>> +void drm_buddy_print(struct drm_buddy_mm *mm, struct drm_printer *p);
>> +void drm_buddy_block_print(struct drm_buddy_mm *mm,
>> + struct drm_buddy_block *block,
>> + struct drm_printer *p);
>> +
>> +void drm_buddy_module_exit(void);
>> +int drm_buddy_module_init(void);
>> +
>> +#endif
>
^ permalink raw reply [flat|nested] 46+ messages in thread
* Re: [Intel-gfx] [PATCH v3 1/6] drm: move the buddy allocator from i915 into common drm
@ 2021-11-17 17:05 ` Arunpravin
0 siblings, 0 replies; 46+ messages in thread
From: Arunpravin @ 2021-11-17 17:05 UTC (permalink / raw)
To: Christian König, dri-devel, intel-gfx, amd-gfx
Cc: matthew.auld, tzimmermann, alexander.deucher, christian.koenig
Hi Christian,
I will make this a separate module.
Thanks,
Arun
On 17/11/21 1:33 pm, Christian König wrote:
> I've looked a bit more into this and I think we should just follow
> Thomas Zimmermann's idea to make this a separate module.
>
> Otherwise we just have the code around all the time even if it is unused
> and implementing this should be trivial.
>
> See how DRM_GEM_CMA_HELPER or DRM_VRAM_HELPER are done in
> drivers/gpu/drm/Kconfig and then have the desired effect in
> drivers/gpu/drm/Makefile
>
> Should be something like ~15 lines of additional configuration which
> saves a bit of memory on embedded systems which just need a fbdev
> replacement.
>
> Thanks,
> Christian.
>
> Am 16.11.21 um 21:18 schrieb Arunpravin:
>> Move the base i915 buddy allocator code into drm
>> - Move i915_buddy.h to include/drm
>> - Move i915_buddy.c to drm root folder
>> - Rename "i915" string with "drm" string wherever applicable
>> - Rename "I915" string with "DRM" string wherever applicable
>> - Fix header file dependencies
>> - Fix alignment issues
>> - add Makefile support for drm buddy
>> - export functions and write kerneldoc description
>> - Remove i915 selftest config check condition as buddy selftest
>> will be moved to drm selftest folder
>>
>> cleanup i915 buddy references in i915 driver module
>> and replace with drm buddy
>>
>> v2:
>> - include header file in alphabetical order (Thomas)
>> - merged changes listed in the body section into a single patch
>> to keep the build intact (Christian, Jani)
>>
>> Signed-off-by: Arunpravin <Arunpravin.PaneerSelvam@amd.com>
>> ---
>> drivers/gpu/drm/Makefile | 2 +-
>> drivers/gpu/drm/drm_buddy.c | 521 ++++++++++++++++++
>> drivers/gpu/drm/drm_drv.c | 3 +
>> drivers/gpu/drm/i915/Makefile | 1 -
>> drivers/gpu/drm/i915/i915_buddy.c | 466 ----------------
>> drivers/gpu/drm/i915/i915_buddy.h | 143 -----
>> drivers/gpu/drm/i915/i915_module.c | 3 -
>> drivers/gpu/drm/i915/i915_scatterlist.c | 11 +-
>> drivers/gpu/drm/i915/i915_ttm_buddy_manager.c | 33 +-
>> drivers/gpu/drm/i915/i915_ttm_buddy_manager.h | 4 +-
>> include/drm/drm_buddy.h | 153 +++++
>> 11 files changed, 702 insertions(+), 638 deletions(-)
>> create mode 100644 drivers/gpu/drm/drm_buddy.c
>> delete mode 100644 drivers/gpu/drm/i915/i915_buddy.c
>> delete mode 100644 drivers/gpu/drm/i915/i915_buddy.h
>> create mode 100644 include/drm/drm_buddy.h
>>
>> diff --git a/drivers/gpu/drm/Makefile b/drivers/gpu/drm/Makefile
>> index 0dff40bb863c..dc61e91a3154 100644
>> --- a/drivers/gpu/drm/Makefile
>> +++ b/drivers/gpu/drm/Makefile
>> @@ -18,7 +18,7 @@ drm-y := drm_aperture.o drm_auth.o drm_cache.o \
>> drm_dumb_buffers.o drm_mode_config.o drm_vblank.o \
>> drm_syncobj.o drm_lease.o drm_writeback.o drm_client.o \
>> drm_client_modeset.o drm_atomic_uapi.o drm_hdcp.o \
>> - drm_managed.o drm_vblank_work.o
>> + drm_managed.o drm_vblank_work.o drm_buddy.o
>>
>> drm-$(CONFIG_DRM_LEGACY) += drm_agpsupport.o drm_bufs.o drm_context.o drm_dma.o \
>> drm_legacy_misc.o drm_lock.o drm_memory.o drm_scatter.o \
>> diff --git a/drivers/gpu/drm/drm_buddy.c b/drivers/gpu/drm/drm_buddy.c
>> new file mode 100644
>> index 000000000000..39eb1d224bec
>> --- /dev/null
>> +++ b/drivers/gpu/drm/drm_buddy.c
>> @@ -0,0 +1,521 @@
>> +// SPDX-License-Identifier: MIT
>> +/*
>> + * Copyright © 2021 Intel Corporation
>> + */
>> +
>> +#include <linux/kmemleak.h>
>> +#include <linux/sizes.h>
>> +
>> +#include <drm/drm_buddy.h>
>> +
>> +static struct kmem_cache *slab_blocks;
>> +
>> +static struct drm_buddy_block *drm_block_alloc(struct drm_buddy_mm *mm,
>> + struct drm_buddy_block *parent,
>> + unsigned int order,
>> + u64 offset)
>> +{
>> + struct drm_buddy_block *block;
>> +
>> + BUG_ON(order > DRM_BUDDY_MAX_ORDER);
>> +
>> + block = kmem_cache_zalloc(slab_blocks, GFP_KERNEL);
>> + if (!block)
>> + return NULL;
>> +
>> + block->header = offset;
>> + block->header |= order;
>> + block->parent = parent;
>> +
>> + BUG_ON(block->header & DRM_BUDDY_HEADER_UNUSED);
>> + return block;
>> +}
>> +
>> +static void drm_block_free(struct drm_buddy_mm *mm,
>> + struct drm_buddy_block *block)
>> +{
>> + kmem_cache_free(slab_blocks, block);
>> +}
>> +
>> +static void mark_allocated(struct drm_buddy_block *block)
>> +{
>> + block->header &= ~DRM_BUDDY_HEADER_STATE;
>> + block->header |= DRM_BUDDY_ALLOCATED;
>> +
>> + list_del(&block->link);
>> +}
>> +
>> +static void mark_free(struct drm_buddy_mm *mm,
>> + struct drm_buddy_block *block)
>> +{
>> + block->header &= ~DRM_BUDDY_HEADER_STATE;
>> + block->header |= DRM_BUDDY_FREE;
>> +
>> + list_add(&block->link,
>> + &mm->free_list[drm_buddy_block_order(block)]);
>> +}
>> +
>> +static void mark_split(struct drm_buddy_block *block)
>> +{
>> + block->header &= ~DRM_BUDDY_HEADER_STATE;
>> + block->header |= DRM_BUDDY_SPLIT;
>> +
>> + list_del(&block->link);
>> +}
>> +
>> +/**
>> + * drm_buddy_init - init memory manager
>> + *
>> + * @mm: DRM buddy manager to initialize
>> + * @size: size in bytes to manage
>> + * @chunk_size: minimum page size in bytes for our allocations
>> + *
>> + * Initializes the memory manager and its resources.
>> + *
>> + * Returns:
>> + * 0 on success, error code on failure.
>> + */
>> +int drm_buddy_init(struct drm_buddy_mm *mm, u64 size, u64 chunk_size)
>> +{
>> + unsigned int i;
>> + u64 offset;
>> +
>> + if (size < chunk_size)
>> + return -EINVAL;
>> +
>> + if (chunk_size < PAGE_SIZE)
>> + return -EINVAL;
>> +
>> + if (!is_power_of_2(chunk_size))
>> + return -EINVAL;
>> +
>> + size = round_down(size, chunk_size);
>> +
>> + mm->size = size;
>> + mm->avail = size;
>> + mm->chunk_size = chunk_size;
>> + mm->max_order = ilog2(size) - ilog2(chunk_size);
>> +
>> + BUG_ON(mm->max_order > DRM_BUDDY_MAX_ORDER);
>> +
>> + mm->free_list = kmalloc_array(mm->max_order + 1,
>> + sizeof(struct list_head),
>> + GFP_KERNEL);
>> + if (!mm->free_list)
>> + return -ENOMEM;
>> +
>> + for (i = 0; i <= mm->max_order; ++i)
>> + INIT_LIST_HEAD(&mm->free_list[i]);
>> +
>> + mm->n_roots = hweight64(size);
>> +
>> + mm->roots = kmalloc_array(mm->n_roots,
>> + sizeof(struct drm_buddy_block *),
>> + GFP_KERNEL);
>> + if (!mm->roots)
>> + goto out_free_list;
>> +
>> + offset = 0;
>> + i = 0;
>> +
>> + /*
>> + * Split into power-of-two blocks, in case we are given a size that is
>> + * not itself a power-of-two.
>> + */
>> + do {
>> + struct drm_buddy_block *root;
>> + unsigned int order;
>> + u64 root_size;
>> +
>> + root_size = rounddown_pow_of_two(size);
>> + order = ilog2(root_size) - ilog2(chunk_size);
>> +
>> + root = drm_block_alloc(mm, NULL, order, offset);
>> + if (!root)
>> + goto out_free_roots;
>> +
>> + mark_free(mm, root);
>> +
>> + BUG_ON(i > mm->max_order);
>> + BUG_ON(drm_buddy_block_size(mm, root) < chunk_size);
>> +
>> + mm->roots[i] = root;
>> +
>> + offset += root_size;
>> + size -= root_size;
>> + i++;
>> + } while (size);
>> +
>> + return 0;
>> +
>> +out_free_roots:
>> + while (i--)
>> + drm_block_free(mm, mm->roots[i]);
>> + kfree(mm->roots);
>> +out_free_list:
>> + kfree(mm->free_list);
>> + return -ENOMEM;
>> +}
>> +EXPORT_SYMBOL(drm_buddy_init);
>> +
>> +/**
>> + * drm_buddy_fini - tear down the memory manager
>> + *
>> + * @mm: DRM buddy manager to free
>> + *
>> + * Cleanup memory manager resources and the freelist
>> + */
>> +void drm_buddy_fini(struct drm_buddy_mm *mm)
>> +{
>> + int i;
>> +
>> + for (i = 0; i < mm->n_roots; ++i) {
>> + WARN_ON(!drm_buddy_block_is_free(mm->roots[i]));
>> + drm_block_free(mm, mm->roots[i]);
>> + }
>> +
>> + WARN_ON(mm->avail != mm->size);
>> +
>> + kfree(mm->roots);
>> + kfree(mm->free_list);
>> +}
>> +EXPORT_SYMBOL(drm_buddy_fini);
>> +
>> +static int split_block(struct drm_buddy_mm *mm,
>> + struct drm_buddy_block *block)
>> +{
>> + unsigned int block_order = drm_buddy_block_order(block) - 1;
>> + u64 offset = drm_buddy_block_offset(block);
>> +
>> + BUG_ON(!drm_buddy_block_is_free(block));
>> + BUG_ON(!drm_buddy_block_order(block));
>> +
>> + block->left = drm_block_alloc(mm, block, block_order, offset);
>> + if (!block->left)
>> + return -ENOMEM;
>> +
>> + block->right = drm_block_alloc(mm, block, block_order,
>> + offset + (mm->chunk_size << block_order));
>> + if (!block->right) {
>> + drm_block_free(mm, block->left);
>> + return -ENOMEM;
>> + }
>> +
>> + mark_free(mm, block->left);
>> + mark_free(mm, block->right);
>> +
>> + mark_split(block);
>> +
>> + return 0;
>> +}
>> +
>> +static struct drm_buddy_block *
>> +get_buddy(struct drm_buddy_block *block)
>> +{
>> + struct drm_buddy_block *parent;
>> +
>> + parent = block->parent;
>> + if (!parent)
>> + return NULL;
>> +
>> + if (parent->left == block)
>> + return parent->right;
>> +
>> + return parent->left;
>> +}
>> +
>> +static void __drm_buddy_free(struct drm_buddy_mm *mm,
>> + struct drm_buddy_block *block)
>> +{
>> + struct drm_buddy_block *parent;
>> +
>> + while ((parent = block->parent)) {
>> + struct drm_buddy_block *buddy;
>> +
>> + buddy = get_buddy(block);
>> +
>> + if (!drm_buddy_block_is_free(buddy))
>> + break;
>> +
>> + list_del(&buddy->link);
>> +
>> + drm_block_free(mm, block);
>> + drm_block_free(mm, buddy);
>> +
>> + block = parent;
>> + }
>> +
>> + mark_free(mm, block);
>> +}
>> +
>> +void drm_buddy_free(struct drm_buddy_mm *mm,
>> + struct drm_buddy_block *block)
>> +{
>> + BUG_ON(!drm_buddy_block_is_allocated(block));
>> + mm->avail += drm_buddy_block_size(mm, block);
>> + __drm_buddy_free(mm, block);
>> +}
>> +
>> +/**
>> + * drm_buddy_free_list - free blocks
>> + *
>> + * @mm: DRM buddy manager
>> + * @objects: input list head to free blocks
>> + */
>> +void drm_buddy_free_list(struct drm_buddy_mm *mm, struct list_head *objects)
>> +{
>> + struct drm_buddy_block *block, *on;
>> +
>> + list_for_each_entry_safe(block, on, objects, link) {
>> + drm_buddy_free(mm, block);
>> + cond_resched();
>> + }
>> + INIT_LIST_HEAD(objects);
>> +}
>> +EXPORT_SYMBOL(drm_buddy_free_list);
>> +
>> +/**
>> + * drm_buddy_alloc - allocate power-of-two blocks
>> + *
>> + * @mm: DRM buddy manager to allocate from
>> + * @order: size of the allocation
>> + *
>> + * The order value here translates to:
>> + *
>> + * 0 = 2^0 * mm->chunk_size
>> + * 1 = 2^1 * mm->chunk_size
>> + * 2 = 2^2 * mm->chunk_size
>> + *
>> + * Returns:
>> + * allocated ptr to the &drm_buddy_block on success
>> + */
>> +struct drm_buddy_block *
>> +drm_buddy_alloc(struct drm_buddy_mm *mm, unsigned int order)
>> +{
>> + struct drm_buddy_block *block = NULL;
>> + unsigned int i;
>> + int err;
>> +
>> + for (i = order; i <= mm->max_order; ++i) {
>> + block = list_first_entry_or_null(&mm->free_list[i],
>> + struct drm_buddy_block,
>> + link);
>> + if (block)
>> + break;
>> + }
>> +
>> + if (!block)
>> + return ERR_PTR(-ENOSPC);
>> +
>> + BUG_ON(!drm_buddy_block_is_free(block));
>> +
>> + while (i != order) {
>> + err = split_block(mm, block);
>> + if (unlikely(err))
>> + goto out_free;
>> +
>> + /* Go low */
>> + block = block->left;
>> + i--;
>> + }
>> +
>> + mark_allocated(block);
>> + mm->avail -= drm_buddy_block_size(mm, block);
>> + kmemleak_update_trace(block);
>> + return block;
>> +
>> +out_free:
>> + if (i != order)
>> + __drm_buddy_free(mm, block);
>> + return ERR_PTR(err);
>> +}
>> +EXPORT_SYMBOL(drm_buddy_alloc);
>> +
>> +static inline bool overlaps(u64 s1, u64 e1, u64 s2, u64 e2)
>> +{
>> + return s1 <= e2 && e1 >= s2;
>> +}
>> +
>> +static inline bool contains(u64 s1, u64 e1, u64 s2, u64 e2)
>> +{
>> + return s1 <= s2 && e1 >= e2;
>> +}
>> +
>> +/**
>> + * drm_buddy_alloc_range - allocate range
>> + *
>> + * @mm: DRM buddy manager to allocate from
>> + * @blocks: output list head to add allocated blocks
>> + * @start: start of the allowed range for this block
>> + * @size: size of the allocation
>> + *
>> + * Intended for pre-allocating portions of the address space, for example to
>> + * reserve a block for the initial framebuffer or similar, hence the expectation
>> + * here is that drm_buddy_alloc() is still the main vehicle for
>> + * allocations, so if that's not the case then the drm_mm range allocator is
>> + * probably a much better fit, and so you should probably go use that instead.
>> + *
>> + * Note that it's safe to chain together multiple alloc_ranges
>> + * with the same blocks list
>> + *
>> + * Returns:
>> + * 0 on success, error code on failure.
>> + */
>> +int drm_buddy_alloc_range(struct drm_buddy_mm *mm,
>> + struct list_head *blocks,
>> + u64 start, u64 size)
>> +{
>> + struct drm_buddy_block *block;
>> + struct drm_buddy_block *buddy;
>> + LIST_HEAD(allocated);
>> + LIST_HEAD(dfs);
>> + u64 end;
>> + int err;
>> + int i;
>> +
>> + if (size < mm->chunk_size)
>> + return -EINVAL;
>> +
>> + if (!IS_ALIGNED(size | start, mm->chunk_size))
>> + return -EINVAL;
>> +
>> + if (range_overflows(start, size, mm->size))
>> + return -EINVAL;
>> +
>> + for (i = 0; i < mm->n_roots; ++i)
>> + list_add_tail(&mm->roots[i]->tmp_link, &dfs);
>> +
>> + end = start + size - 1;
>> +
>> + do {
>> + u64 block_start;
>> + u64 block_end;
>> +
>> + block = list_first_entry_or_null(&dfs,
>> + struct drm_buddy_block,
>> + tmp_link);
>> + if (!block)
>> + break;
>> +
>> + list_del(&block->tmp_link);
>> +
>> + block_start = drm_buddy_block_offset(block);
>> + block_end = block_start + drm_buddy_block_size(mm, block) - 1;
>> +
>> + if (!overlaps(start, end, block_start, block_end))
>> + continue;
>> +
>> + if (drm_buddy_block_is_allocated(block)) {
>> + err = -ENOSPC;
>> + goto err_free;
>> + }
>> +
>> + if (contains(start, end, block_start, block_end)) {
>> + if (!drm_buddy_block_is_free(block)) {
>> + err = -ENOSPC;
>> + goto err_free;
>> + }
>> +
>> + mark_allocated(block);
>> + mm->avail -= drm_buddy_block_size(mm, block);
>> + list_add_tail(&block->link, &allocated);
>> + continue;
>> + }
>> +
>> + if (!drm_buddy_block_is_split(block)) {
>> + err = split_block(mm, block);
>> + if (unlikely(err))
>> + goto err_undo;
>> + }
>> +
>> + list_add(&block->right->tmp_link, &dfs);
>> + list_add(&block->left->tmp_link, &dfs);
>> + } while (1);
>> +
>> + list_splice_tail(&allocated, blocks);
>> + return 0;
>> +
>> +err_undo:
>> + /*
>> + * We really don't want to leave around a bunch of split blocks, since
>> + * bigger is better, so make sure we merge everything back before we
>> + * free the allocated blocks.
>> + */
>> + buddy = get_buddy(block);
>> + if (buddy &&
>> + (drm_buddy_block_is_free(block) &&
>> + drm_buddy_block_is_free(buddy)))
>> + __drm_buddy_free(mm, block);
>> +
>> +err_free:
>> + drm_buddy_free_list(mm, &allocated);
>> + return err;
>> +}
>> +EXPORT_SYMBOL(drm_buddy_alloc_range);
>> +
>> +/**
>> + * drm_buddy_block_print - print block information
>> + *
>> + * @mm: DRM buddy manager
>> + * @block: DRM buddy block
>> + * @p: DRM printer to use
>> + */
>> +void drm_buddy_block_print(struct drm_buddy_mm *mm,
>> + struct drm_buddy_block *block,
>> + struct drm_printer *p)
>> +{
>> + u64 start = drm_buddy_block_offset(block);
>> + u64 size = drm_buddy_block_size(mm, block);
>> +
>> + drm_printf(p, "%#018llx-%#018llx: %llu\n", start, start + size, size);
>> +}
>> +EXPORT_SYMBOL(drm_buddy_block_print);
>> +
>> +/**
>> + * drm_buddy_print - print allocator state
>> + *
>> + * @mm: DRM buddy manager
>> + * @p: DRM printer to use
>> + */
>> +void drm_buddy_print(struct drm_buddy_mm *mm, struct drm_printer *p)
>> +{
>> + int order;
>> +
>> + drm_printf(p, "chunk_size: %lluKiB, total: %lluMiB, free: %lluMiB\n",
>> + mm->chunk_size >> 10, mm->size >> 20, mm->avail >> 20);
>> +
>> + for (order = mm->max_order; order >= 0; order--) {
>> + struct drm_buddy_block *block;
>> + u64 count = 0, free;
>> +
>> + list_for_each_entry(block, &mm->free_list[order], link) {
>> + BUG_ON(!drm_buddy_block_is_free(block));
>> + count++;
>> + }
>> +
>> + drm_printf(p, "order-%d ", order);
>> +
>> + free = count * (mm->chunk_size << order);
>> + if (free < SZ_1M)
>> + drm_printf(p, "free: %lluKiB", free >> 10);
>> + else
>> + drm_printf(p, "free: %lluMiB", free >> 20);
>> +
>> + drm_printf(p, ", pages: %llu\n", count);
>> + }
>> +}
>> +EXPORT_SYMBOL(drm_buddy_print);
>> +
>> +void drm_buddy_module_exit(void)
>> +{
>> + kmem_cache_destroy(slab_blocks);
>> +}
>> +
>> +int __init drm_buddy_module_init(void)
>> +{
>> + slab_blocks = KMEM_CACHE(drm_buddy_block, 0);
>> + if (!slab_blocks)
>> + return -ENOMEM;
>> +
>> + return 0;
>> +}
>> diff --git a/drivers/gpu/drm/drm_drv.c b/drivers/gpu/drm/drm_drv.c
>> index 7a5097467ba5..5d5e46e60586 100644
>> --- a/drivers/gpu/drm/drm_drv.c
>> +++ b/drivers/gpu/drm/drm_drv.c
>> @@ -35,6 +35,7 @@
>> #include <linux/slab.h>
>> #include <linux/srcu.h>
>>
>> +#include <drm/drm_buddy.h>
>> #include <drm/drm_cache.h>
>> #include <drm/drm_client.h>
>> #include <drm/drm_color_mgmt.h>
>> @@ -1034,6 +1035,7 @@ static void drm_core_exit(void)
>> drm_sysfs_destroy();
>> idr_destroy(&drm_minors_idr);
>> drm_connector_ida_destroy();
>> + drm_buddy_module_exit();
>> }
>>
>> static int __init drm_core_init(void)
>> @@ -1043,6 +1045,7 @@ static int __init drm_core_init(void)
>> drm_connector_ida_init();
>> idr_init(&drm_minors_idr);
>> drm_memcpy_init_early();
>> + drm_buddy_module_init();
>>
>> ret = drm_sysfs_init();
>> if (ret < 0) {
>> diff --git a/drivers/gpu/drm/i915/Makefile b/drivers/gpu/drm/i915/Makefile
>> index 467872cca027..fc5ca8c4ccb2 100644
>> --- a/drivers/gpu/drm/i915/Makefile
>> +++ b/drivers/gpu/drm/i915/Makefile
>> @@ -161,7 +161,6 @@ gem-y += \
>> i915-y += \
>> $(gem-y) \
>> i915_active.o \
>> - i915_buddy.o \
>> i915_cmd_parser.o \
>> i915_gem_evict.o \
>> i915_gem_gtt.o \
>> diff --git a/drivers/gpu/drm/i915/i915_buddy.c b/drivers/gpu/drm/i915/i915_buddy.c
>> deleted file mode 100644
>> index 6e2ad68f8f3f..000000000000
>> --- a/drivers/gpu/drm/i915/i915_buddy.c
>> +++ /dev/null
>> @@ -1,466 +0,0 @@
>> -// SPDX-License-Identifier: MIT
>> -/*
>> - * Copyright © 2021 Intel Corporation
>> - */
>> -
>> -#include <linux/kmemleak.h>
>> -#include <linux/sizes.h>
>> -
>> -#include "i915_buddy.h"
>> -
>> -#include "i915_gem.h"
>> -#include "i915_utils.h"
>> -
>> -static struct kmem_cache *slab_blocks;
>> -
>> -static struct i915_buddy_block *i915_block_alloc(struct i915_buddy_mm *mm,
>> - struct i915_buddy_block *parent,
>> - unsigned int order,
>> - u64 offset)
>> -{
>> - struct i915_buddy_block *block;
>> -
>> - GEM_BUG_ON(order > I915_BUDDY_MAX_ORDER);
>> -
>> - block = kmem_cache_zalloc(slab_blocks, GFP_KERNEL);
>> - if (!block)
>> - return NULL;
>> -
>> - block->header = offset;
>> - block->header |= order;
>> - block->parent = parent;
>> -
>> - GEM_BUG_ON(block->header & I915_BUDDY_HEADER_UNUSED);
>> - return block;
>> -}
>> -
>> -static void i915_block_free(struct i915_buddy_mm *mm,
>> - struct i915_buddy_block *block)
>> -{
>> - kmem_cache_free(slab_blocks, block);
>> -}
>> -
>> -static void mark_allocated(struct i915_buddy_block *block)
>> -{
>> - block->header &= ~I915_BUDDY_HEADER_STATE;
>> - block->header |= I915_BUDDY_ALLOCATED;
>> -
>> - list_del(&block->link);
>> -}
>> -
>> -static void mark_free(struct i915_buddy_mm *mm,
>> - struct i915_buddy_block *block)
>> -{
>> - block->header &= ~I915_BUDDY_HEADER_STATE;
>> - block->header |= I915_BUDDY_FREE;
>> -
>> - list_add(&block->link,
>> - &mm->free_list[i915_buddy_block_order(block)]);
>> -}
>> -
>> -static void mark_split(struct i915_buddy_block *block)
>> -{
>> - block->header &= ~I915_BUDDY_HEADER_STATE;
>> - block->header |= I915_BUDDY_SPLIT;
>> -
>> - list_del(&block->link);
>> -}
>> -
>> -int i915_buddy_init(struct i915_buddy_mm *mm, u64 size, u64 chunk_size)
>> -{
>> - unsigned int i;
>> - u64 offset;
>> -
>> - if (size < chunk_size)
>> - return -EINVAL;
>> -
>> - if (chunk_size < PAGE_SIZE)
>> - return -EINVAL;
>> -
>> - if (!is_power_of_2(chunk_size))
>> - return -EINVAL;
>> -
>> - size = round_down(size, chunk_size);
>> -
>> - mm->size = size;
>> - mm->avail = size;
>> - mm->chunk_size = chunk_size;
>> - mm->max_order = ilog2(size) - ilog2(chunk_size);
>> -
>> - GEM_BUG_ON(mm->max_order > I915_BUDDY_MAX_ORDER);
>> -
>> - mm->free_list = kmalloc_array(mm->max_order + 1,
>> - sizeof(struct list_head),
>> - GFP_KERNEL);
>> - if (!mm->free_list)
>> - return -ENOMEM;
>> -
>> - for (i = 0; i <= mm->max_order; ++i)
>> - INIT_LIST_HEAD(&mm->free_list[i]);
>> -
>> - mm->n_roots = hweight64(size);
>> -
>> - mm->roots = kmalloc_array(mm->n_roots,
>> - sizeof(struct i915_buddy_block *),
>> - GFP_KERNEL);
>> - if (!mm->roots)
>> - goto out_free_list;
>> -
>> - offset = 0;
>> - i = 0;
>> -
>> - /*
>> - * Split into power-of-two blocks, in case we are given a size that is
>> - * not itself a power-of-two.
>> - */
>> - do {
>> - struct i915_buddy_block *root;
>> - unsigned int order;
>> - u64 root_size;
>> -
>> - root_size = rounddown_pow_of_two(size);
>> - order = ilog2(root_size) - ilog2(chunk_size);
>> -
>> - root = i915_block_alloc(mm, NULL, order, offset);
>> - if (!root)
>> - goto out_free_roots;
>> -
>> - mark_free(mm, root);
>> -
>> - GEM_BUG_ON(i > mm->max_order);
>> - GEM_BUG_ON(i915_buddy_block_size(mm, root) < chunk_size);
>> -
>> - mm->roots[i] = root;
>> -
>> - offset += root_size;
>> - size -= root_size;
>> - i++;
>> - } while (size);
>> -
>> - return 0;
>> -
>> -out_free_roots:
>> - while (i--)
>> - i915_block_free(mm, mm->roots[i]);
>> - kfree(mm->roots);
>> -out_free_list:
>> - kfree(mm->free_list);
>> - return -ENOMEM;
>> -}
>> -
>> -void i915_buddy_fini(struct i915_buddy_mm *mm)
>> -{
>> - int i;
>> -
>> - for (i = 0; i < mm->n_roots; ++i) {
>> - GEM_WARN_ON(!i915_buddy_block_is_free(mm->roots[i]));
>> - i915_block_free(mm, mm->roots[i]);
>> - }
>> -
>> - GEM_WARN_ON(mm->avail != mm->size);
>> -
>> - kfree(mm->roots);
>> - kfree(mm->free_list);
>> -}
>> -
>> -static int split_block(struct i915_buddy_mm *mm,
>> - struct i915_buddy_block *block)
>> -{
>> - unsigned int block_order = i915_buddy_block_order(block) - 1;
>> - u64 offset = i915_buddy_block_offset(block);
>> -
>> - GEM_BUG_ON(!i915_buddy_block_is_free(block));
>> - GEM_BUG_ON(!i915_buddy_block_order(block));
>> -
>> - block->left = i915_block_alloc(mm, block, block_order, offset);
>> - if (!block->left)
>> - return -ENOMEM;
>> -
>> - block->right = i915_block_alloc(mm, block, block_order,
>> - offset + (mm->chunk_size << block_order));
>> - if (!block->right) {
>> - i915_block_free(mm, block->left);
>> - return -ENOMEM;
>> - }
>> -
>> - mark_free(mm, block->left);
>> - mark_free(mm, block->right);
>> -
>> - mark_split(block);
>> -
>> - return 0;
>> -}
>> -
>> -static struct i915_buddy_block *
>> -get_buddy(struct i915_buddy_block *block)
>> -{
>> - struct i915_buddy_block *parent;
>> -
>> - parent = block->parent;
>> - if (!parent)
>> - return NULL;
>> -
>> - if (parent->left == block)
>> - return parent->right;
>> -
>> - return parent->left;
>> -}
>> -
>> -static void __i915_buddy_free(struct i915_buddy_mm *mm,
>> - struct i915_buddy_block *block)
>> -{
>> - struct i915_buddy_block *parent;
>> -
>> - while ((parent = block->parent)) {
>> - struct i915_buddy_block *buddy;
>> -
>> - buddy = get_buddy(block);
>> -
>> - if (!i915_buddy_block_is_free(buddy))
>> - break;
>> -
>> - list_del(&buddy->link);
>> -
>> - i915_block_free(mm, block);
>> - i915_block_free(mm, buddy);
>> -
>> - block = parent;
>> - }
>> -
>> - mark_free(mm, block);
>> -}
>> -
>> -void i915_buddy_free(struct i915_buddy_mm *mm,
>> - struct i915_buddy_block *block)
>> -{
>> - GEM_BUG_ON(!i915_buddy_block_is_allocated(block));
>> - mm->avail += i915_buddy_block_size(mm, block);
>> - __i915_buddy_free(mm, block);
>> -}
>> -
>> -void i915_buddy_free_list(struct i915_buddy_mm *mm, struct list_head *objects)
>> -{
>> - struct i915_buddy_block *block, *on;
>> -
>> - list_for_each_entry_safe(block, on, objects, link) {
>> - i915_buddy_free(mm, block);
>> - cond_resched();
>> - }
>> - INIT_LIST_HEAD(objects);
>> -}
>> -
>> -/*
>> - * Allocate power-of-two block. The order value here translates to:
>> - *
>> - * 0 = 2^0 * mm->chunk_size
>> - * 1 = 2^1 * mm->chunk_size
>> - * 2 = 2^2 * mm->chunk_size
>> - * ...
>> - */
>> -struct i915_buddy_block *
>> -i915_buddy_alloc(struct i915_buddy_mm *mm, unsigned int order)
>> -{
>> - struct i915_buddy_block *block = NULL;
>> - unsigned int i;
>> - int err;
>> -
>> - for (i = order; i <= mm->max_order; ++i) {
>> - block = list_first_entry_or_null(&mm->free_list[i],
>> - struct i915_buddy_block,
>> - link);
>> - if (block)
>> - break;
>> - }
>> -
>> - if (!block)
>> - return ERR_PTR(-ENOSPC);
>> -
>> - GEM_BUG_ON(!i915_buddy_block_is_free(block));
>> -
>> - while (i != order) {
>> - err = split_block(mm, block);
>> - if (unlikely(err))
>> - goto out_free;
>> -
>> - /* Go low */
>> - block = block->left;
>> - i--;
>> - }
>> -
>> - mark_allocated(block);
>> - mm->avail -= i915_buddy_block_size(mm, block);
>> - kmemleak_update_trace(block);
>> - return block;
>> -
>> -out_free:
>> - if (i != order)
>> - __i915_buddy_free(mm, block);
>> - return ERR_PTR(err);
>> -}
>> -
>> -static inline bool overlaps(u64 s1, u64 e1, u64 s2, u64 e2)
>> -{
>> - return s1 <= e2 && e1 >= s2;
>> -}
>> -
>> -static inline bool contains(u64 s1, u64 e1, u64 s2, u64 e2)
>> -{
>> - return s1 <= s2 && e1 >= e2;
>> -}
>> -
>> -/*
>> - * Allocate range. Note that it's safe to chain together multiple alloc_ranges
>> - * with the same blocks list.
>> - *
>> - * Intended for pre-allocating portions of the address space, for example to
>> - * reserve a block for the initial framebuffer or similar, hence the expectation
>> - * here is that i915_buddy_alloc() is still the main vehicle for
>> - * allocations, so if that's not the case then the drm_mm range allocator is
>> - * probably a much better fit, and so you should probably go use that instead.
>> - */
>> -int i915_buddy_alloc_range(struct i915_buddy_mm *mm,
>> - struct list_head *blocks,
>> - u64 start, u64 size)
>> -{
>> - struct i915_buddy_block *block;
>> - struct i915_buddy_block *buddy;
>> - LIST_HEAD(allocated);
>> - LIST_HEAD(dfs);
>> - u64 end;
>> - int err;
>> - int i;
>> -
>> - if (size < mm->chunk_size)
>> - return -EINVAL;
>> -
>> - if (!IS_ALIGNED(size | start, mm->chunk_size))
>> - return -EINVAL;
>> -
>> - if (range_overflows(start, size, mm->size))
>> - return -EINVAL;
>> -
>> - for (i = 0; i < mm->n_roots; ++i)
>> - list_add_tail(&mm->roots[i]->tmp_link, &dfs);
>> -
>> - end = start + size - 1;
>> -
>> - do {
>> - u64 block_start;
>> - u64 block_end;
>> -
>> - block = list_first_entry_or_null(&dfs,
>> - struct i915_buddy_block,
>> - tmp_link);
>> - if (!block)
>> - break;
>> -
>> - list_del(&block->tmp_link);
>> -
>> - block_start = i915_buddy_block_offset(block);
>> - block_end = block_start + i915_buddy_block_size(mm, block) - 1;
>> -
>> - if (!overlaps(start, end, block_start, block_end))
>> - continue;
>> -
>> - if (i915_buddy_block_is_allocated(block)) {
>> - err = -ENOSPC;
>> - goto err_free;
>> - }
>> -
>> - if (contains(start, end, block_start, block_end)) {
>> - if (!i915_buddy_block_is_free(block)) {
>> - err = -ENOSPC;
>> - goto err_free;
>> - }
>> -
>> - mark_allocated(block);
>> - mm->avail -= i915_buddy_block_size(mm, block);
>> - list_add_tail(&block->link, &allocated);
>> - continue;
>> - }
>> -
>> - if (!i915_buddy_block_is_split(block)) {
>> - err = split_block(mm, block);
>> - if (unlikely(err))
>> - goto err_undo;
>> - }
>> -
>> - list_add(&block->right->tmp_link, &dfs);
>> - list_add(&block->left->tmp_link, &dfs);
>> - } while (1);
>> -
>> - list_splice_tail(&allocated, blocks);
>> - return 0;
>> -
>> -err_undo:
>> - /*
>> - * We really don't want to leave around a bunch of split blocks, since
>> - * bigger is better, so make sure we merge everything back before we
>> - * free the allocated blocks.
>> - */
>> - buddy = get_buddy(block);
>> - if (buddy &&
>> - (i915_buddy_block_is_free(block) &&
>> - i915_buddy_block_is_free(buddy)))
>> - __i915_buddy_free(mm, block);
>> -
>> -err_free:
>> - i915_buddy_free_list(mm, &allocated);
>> - return err;
>> -}
>> -
>> -void i915_buddy_block_print(struct i915_buddy_mm *mm,
>> - struct i915_buddy_block *block,
>> - struct drm_printer *p)
>> -{
>> - u64 start = i915_buddy_block_offset(block);
>> - u64 size = i915_buddy_block_size(mm, block);
>> -
>> - drm_printf(p, "%#018llx-%#018llx: %llu\n", start, start + size, size);
>> -}
>> -
>> -void i915_buddy_print(struct i915_buddy_mm *mm, struct drm_printer *p)
>> -{
>> - int order;
>> -
>> - drm_printf(p, "chunk_size: %lluKiB, total: %lluMiB, free: %lluMiB\n",
>> - mm->chunk_size >> 10, mm->size >> 20, mm->avail >> 20);
>> -
>> - for (order = mm->max_order; order >= 0; order--) {
>> - struct i915_buddy_block *block;
>> - u64 count = 0, free;
>> -
>> - list_for_each_entry(block, &mm->free_list[order], link) {
>> - GEM_BUG_ON(!i915_buddy_block_is_free(block));
>> - count++;
>> - }
>> -
>> - drm_printf(p, "order-%d ", order);
>> -
>> - free = count * (mm->chunk_size << order);
>> - if (free < SZ_1M)
>> - drm_printf(p, "free: %lluKiB", free >> 10);
>> - else
>> - drm_printf(p, "free: %lluMiB", free >> 20);
>> -
>> - drm_printf(p, ", pages: %llu\n", count);
>> - }
>> -}
>> -
>> -#if IS_ENABLED(CONFIG_DRM_I915_SELFTEST)
>> -#include "selftests/i915_buddy.c"
>> -#endif
>> -
>> -void i915_buddy_module_exit(void)
>> -{
>> - kmem_cache_destroy(slab_blocks);
>> -}
>> -
>> -int __init i915_buddy_module_init(void)
>> -{
>> - slab_blocks = KMEM_CACHE(i915_buddy_block, 0);
>> - if (!slab_blocks)
>> - return -ENOMEM;
>> -
>> - return 0;
>> -}
>> diff --git a/drivers/gpu/drm/i915/i915_buddy.h b/drivers/gpu/drm/i915/i915_buddy.h
>> deleted file mode 100644
>> index 7077742112ac..000000000000
>> --- a/drivers/gpu/drm/i915/i915_buddy.h
>> +++ /dev/null
>> @@ -1,143 +0,0 @@
>> -/* SPDX-License-Identifier: MIT */
>> -/*
>> - * Copyright © 2021 Intel Corporation
>> - */
>> -
>> -#ifndef __I915_BUDDY_H__
>> -#define __I915_BUDDY_H__
>> -
>> -#include <linux/bitops.h>
>> -#include <linux/list.h>
>> -#include <linux/slab.h>
>> -
>> -#include <drm/drm_print.h>
>> -
>> -struct i915_buddy_block {
>> -#define I915_BUDDY_HEADER_OFFSET GENMASK_ULL(63, 12)
>> -#define I915_BUDDY_HEADER_STATE GENMASK_ULL(11, 10)
>> -#define I915_BUDDY_ALLOCATED (1 << 10)
>> -#define I915_BUDDY_FREE (2 << 10)
>> -#define I915_BUDDY_SPLIT (3 << 10)
>> -/* Free to be used, if needed in the future */
>> -#define I915_BUDDY_HEADER_UNUSED GENMASK_ULL(9, 6)
>> -#define I915_BUDDY_HEADER_ORDER GENMASK_ULL(5, 0)
>> - u64 header;
>> -
>> - struct i915_buddy_block *left;
>> - struct i915_buddy_block *right;
>> - struct i915_buddy_block *parent;
>> -
>> - void *private; /* owned by creator */
>> -
>> - /*
>> - * While the block is allocated by the user through i915_buddy_alloc*,
>> - * the user has ownership of the link, for example to maintain within
>> - * a list, if so desired. As soon as the block is freed with
>> - * i915_buddy_free* ownership is given back to the mm.
>> - */
>> - struct list_head link;
>> - struct list_head tmp_link;
>> -};
>> -
>> -/* Order-zero must be at least PAGE_SIZE */
>> -#define I915_BUDDY_MAX_ORDER (63 - PAGE_SHIFT)
>> -
>> -/*
>> - * Binary Buddy System.
>> - *
>> - * Locking should be handled by the user, a simple mutex around
>> - * i915_buddy_alloc* and i915_buddy_free* should suffice.
>> - */
>> -struct i915_buddy_mm {
>> - /* Maintain a free list for each order. */
>> - struct list_head *free_list;
>> -
>> - /*
>> - * Maintain explicit binary tree(s) to track the allocation of the
>> - * address space. This gives us a simple way of finding a buddy block
>> - * and performing the potentially recursive merge step when freeing a
>> - * block. Nodes are either allocated or free, in which case they will
>> - * also exist on the respective free list.
>> - */
>> - struct i915_buddy_block **roots;
>> -
>> - /*
>> - * Anything from here is public, and remains static for the lifetime of
>> - * the mm. Everything above is considered do-not-touch.
>> - */
>> - unsigned int n_roots;
>> - unsigned int max_order;
>> -
>> - /* Must be at least PAGE_SIZE */
>> - u64 chunk_size;
>> - u64 size;
>> - u64 avail;
>> -};
>> -
>> -static inline u64
>> -i915_buddy_block_offset(struct i915_buddy_block *block)
>> -{
>> - return block->header & I915_BUDDY_HEADER_OFFSET;
>> -}
>> -
>> -static inline unsigned int
>> -i915_buddy_block_order(struct i915_buddy_block *block)
>> -{
>> - return block->header & I915_BUDDY_HEADER_ORDER;
>> -}
>> -
>> -static inline unsigned int
>> -i915_buddy_block_state(struct i915_buddy_block *block)
>> -{
>> - return block->header & I915_BUDDY_HEADER_STATE;
>> -}
>> -
>> -static inline bool
>> -i915_buddy_block_is_allocated(struct i915_buddy_block *block)
>> -{
>> - return i915_buddy_block_state(block) == I915_BUDDY_ALLOCATED;
>> -}
>> -
>> -static inline bool
>> -i915_buddy_block_is_free(struct i915_buddy_block *block)
>> -{
>> - return i915_buddy_block_state(block) == I915_BUDDY_FREE;
>> -}
>> -
>> -static inline bool
>> -i915_buddy_block_is_split(struct i915_buddy_block *block)
>> -{
>> - return i915_buddy_block_state(block) == I915_BUDDY_SPLIT;
>> -}
>> -
>> -static inline u64
>> -i915_buddy_block_size(struct i915_buddy_mm *mm,
>> - struct i915_buddy_block *block)
>> -{
>> - return mm->chunk_size << i915_buddy_block_order(block);
>> -}
>> -
>> -int i915_buddy_init(struct i915_buddy_mm *mm, u64 size, u64 chunk_size);
>> -
>> -void i915_buddy_fini(struct i915_buddy_mm *mm);
>> -
>> -struct i915_buddy_block *
>> -i915_buddy_alloc(struct i915_buddy_mm *mm, unsigned int order);
>> -
>> -int i915_buddy_alloc_range(struct i915_buddy_mm *mm,
>> - struct list_head *blocks,
>> - u64 start, u64 size);
>> -
>> -void i915_buddy_free(struct i915_buddy_mm *mm, struct i915_buddy_block *block);
>> -
>> -void i915_buddy_free_list(struct i915_buddy_mm *mm, struct list_head *objects);
>> -
>> -void i915_buddy_print(struct i915_buddy_mm *mm, struct drm_printer *p);
>> -void i915_buddy_block_print(struct i915_buddy_mm *mm,
>> - struct i915_buddy_block *block,
>> - struct drm_printer *p);
>> -
>> -void i915_buddy_module_exit(void);
>> -int i915_buddy_module_init(void);
>> -
>> -#endif
>> diff --git a/drivers/gpu/drm/i915/i915_module.c b/drivers/gpu/drm/i915/i915_module.c
>> index c7507266aa83..355681dbd7a8 100644
>> --- a/drivers/gpu/drm/i915/i915_module.c
>> +++ b/drivers/gpu/drm/i915/i915_module.c
>> @@ -9,7 +9,6 @@
>> #include "gem/i915_gem_context.h"
>> #include "gem/i915_gem_object.h"
>> #include "i915_active.h"
>> -#include "i915_buddy.h"
>> #include "i915_params.h"
>> #include "i915_pci.h"
>> #include "i915_perf.h"
>> @@ -50,8 +49,6 @@ static const struct {
>> { .init = i915_check_nomodeset },
>> { .init = i915_active_module_init,
>> .exit = i915_active_module_exit },
>> - { .init = i915_buddy_module_init,
>> - .exit = i915_buddy_module_exit },
>> { .init = i915_context_module_init,
>> .exit = i915_context_module_exit },
>> { .init = i915_gem_context_module_init,
>> diff --git a/drivers/gpu/drm/i915/i915_scatterlist.c b/drivers/gpu/drm/i915/i915_scatterlist.c
>> index 4a6712dca838..84d622aa32d2 100644
>> --- a/drivers/gpu/drm/i915/i915_scatterlist.c
>> +++ b/drivers/gpu/drm/i915/i915_scatterlist.c
>> @@ -5,10 +5,9 @@
>> */
>>
>> #include "i915_scatterlist.h"
>> -
>> -#include "i915_buddy.h"
>> #include "i915_ttm_buddy_manager.h"
>>
>> +#include <drm/drm_buddy.h>
>> #include <drm/drm_mm.h>
>>
>> #include <linux/slab.h>
>> @@ -126,9 +125,9 @@ struct sg_table *i915_sg_from_buddy_resource(struct ttm_resource *res,
>> struct i915_ttm_buddy_resource *bman_res = to_ttm_buddy_resource(res);
>> const u64 size = res->num_pages << PAGE_SHIFT;
>> const u64 max_segment = rounddown(UINT_MAX, PAGE_SIZE);
>> - struct i915_buddy_mm *mm = bman_res->mm;
>> + struct drm_buddy_mm *mm = bman_res->mm;
>> struct list_head *blocks = &bman_res->blocks;
>> - struct i915_buddy_block *block;
>> + struct drm_buddy_block *block;
>> struct scatterlist *sg;
>> struct sg_table *st;
>> resource_size_t prev_end;
>> @@ -151,8 +150,8 @@ struct sg_table *i915_sg_from_buddy_resource(struct ttm_resource *res,
>> list_for_each_entry(block, blocks, link) {
>> u64 block_size, offset;
>>
>> - block_size = min_t(u64, size, i915_buddy_block_size(mm, block));
>> - offset = i915_buddy_block_offset(block);
>> + block_size = min_t(u64, size, drm_buddy_block_size(mm, block));
>> + offset = drm_buddy_block_offset(block);
>>
>> while (block_size) {
>> u64 len;
>> diff --git a/drivers/gpu/drm/i915/i915_ttm_buddy_manager.c b/drivers/gpu/drm/i915/i915_ttm_buddy_manager.c
>> index d59fbb019032..c4b70cb8c248 100644
>> --- a/drivers/gpu/drm/i915/i915_ttm_buddy_manager.c
>> +++ b/drivers/gpu/drm/i915/i915_ttm_buddy_manager.c
>> @@ -8,14 +8,15 @@
>> #include <drm/ttm/ttm_bo_driver.h>
>> #include <drm/ttm/ttm_placement.h>
>>
>> +#include <drm/drm_buddy.h>
>> +
>> #include "i915_ttm_buddy_manager.h"
>>
>> -#include "i915_buddy.h"
>> #include "i915_gem.h"
>>
>> struct i915_ttm_buddy_manager {
>> struct ttm_resource_manager manager;
>> - struct i915_buddy_mm mm;
>> + struct drm_buddy_mm mm;
>> struct list_head reserved;
>> struct mutex lock;
>> u64 default_page_size;
>> @@ -34,7 +35,7 @@ static int i915_ttm_buddy_man_alloc(struct ttm_resource_manager *man,
>> {
>> struct i915_ttm_buddy_manager *bman = to_buddy_manager(man);
>> struct i915_ttm_buddy_resource *bman_res;
>> - struct i915_buddy_mm *mm = &bman->mm;
>> + struct drm_buddy_mm *mm = &bman->mm;
>> unsigned long n_pages;
>> unsigned int min_order;
>> u64 min_page_size;
>> @@ -73,7 +74,7 @@ static int i915_ttm_buddy_man_alloc(struct ttm_resource_manager *man,
>> n_pages = size >> ilog2(mm->chunk_size);
>>
>> do {
>> - struct i915_buddy_block *block;
>> + struct drm_buddy_block *block;
>> unsigned int order;
>>
>> order = fls(n_pages) - 1;
>> @@ -82,7 +83,7 @@ static int i915_ttm_buddy_man_alloc(struct ttm_resource_manager *man,
>>
>> do {
>> mutex_lock(&bman->lock);
>> - block = i915_buddy_alloc(mm, order);
>> + block = drm_buddy_alloc(mm, order);
>> mutex_unlock(&bman->lock);
>> if (!IS_ERR(block))
>> break;
>> @@ -106,7 +107,7 @@ static int i915_ttm_buddy_man_alloc(struct ttm_resource_manager *man,
>>
>> err_free_blocks:
>> mutex_lock(&bman->lock);
>> - i915_buddy_free_list(mm, &bman_res->blocks);
>> + drm_buddy_free_list(mm, &bman_res->blocks);
>> mutex_unlock(&bman->lock);
>> err_free_res:
>> kfree(bman_res);
>> @@ -120,7 +121,7 @@ static void i915_ttm_buddy_man_free(struct ttm_resource_manager *man,
>> struct i915_ttm_buddy_manager *bman = to_buddy_manager(man);
>>
>> mutex_lock(&bman->lock);
>> - i915_buddy_free_list(&bman->mm, &bman_res->blocks);
>> + drm_buddy_free_list(&bman->mm, &bman_res->blocks);
>> mutex_unlock(&bman->lock);
>>
>> kfree(bman_res);
>> @@ -130,17 +131,17 @@ static void i915_ttm_buddy_man_debug(struct ttm_resource_manager *man,
>> struct drm_printer *printer)
>> {
>> struct i915_ttm_buddy_manager *bman = to_buddy_manager(man);
>> - struct i915_buddy_block *block;
>> + struct drm_buddy_block *block;
>>
>> mutex_lock(&bman->lock);
>> drm_printf(printer, "default_page_size: %lluKiB\n",
>> bman->default_page_size >> 10);
>>
>> - i915_buddy_print(&bman->mm, printer);
>> + drm_buddy_print(&bman->mm, printer);
>>
>> drm_printf(printer, "reserved:\n");
>> list_for_each_entry(block, &bman->reserved, link)
>> - i915_buddy_block_print(&bman->mm, block, printer);
>> + drm_buddy_block_print(&bman->mm, block, printer);
>> mutex_unlock(&bman->lock);
>> }
>>
>> @@ -190,7 +191,7 @@ int i915_ttm_buddy_man_init(struct ttm_device *bdev,
>> if (!bman)
>> return -ENOMEM;
>>
>> - err = i915_buddy_init(&bman->mm, size, chunk_size);
>> + err = drm_buddy_init(&bman->mm, size, chunk_size);
>> if (err)
>> goto err_free_bman;
>>
>> @@ -228,7 +229,7 @@ int i915_ttm_buddy_man_fini(struct ttm_device *bdev, unsigned int type)
>> {
>> struct ttm_resource_manager *man = ttm_manager_type(bdev, type);
>> struct i915_ttm_buddy_manager *bman = to_buddy_manager(man);
>> - struct i915_buddy_mm *mm = &bman->mm;
>> + struct drm_buddy_mm *mm = &bman->mm;
>> int ret;
>>
>> ttm_resource_manager_set_used(man, false);
>> @@ -240,8 +241,8 @@ int i915_ttm_buddy_man_fini(struct ttm_device *bdev, unsigned int type)
>> ttm_set_driver_manager(bdev, type, NULL);
>>
>> mutex_lock(&bman->lock);
>> - i915_buddy_free_list(mm, &bman->reserved);
>> - i915_buddy_fini(mm);
>> + drm_buddy_free_list(mm, &bman->reserved);
>> + drm_buddy_fini(mm);
>> mutex_unlock(&bman->lock);
>>
>> ttm_resource_manager_cleanup(man);
>> @@ -264,11 +265,11 @@ int i915_ttm_buddy_man_reserve(struct ttm_resource_manager *man,
>> u64 start, u64 size)
>> {
>> struct i915_ttm_buddy_manager *bman = to_buddy_manager(man);
>> - struct i915_buddy_mm *mm = &bman->mm;
>> + struct drm_buddy_mm *mm = &bman->mm;
>> int ret;
>>
>> mutex_lock(&bman->lock);
>> - ret = i915_buddy_alloc_range(mm, &bman->reserved, start, size);
>> + ret = drm_buddy_alloc_range(mm, &bman->reserved, start, size);
>> mutex_unlock(&bman->lock);
>>
>> return ret;
>> diff --git a/drivers/gpu/drm/i915/i915_ttm_buddy_manager.h b/drivers/gpu/drm/i915/i915_ttm_buddy_manager.h
>> index 0722d33f3e14..fa644b512c2e 100644
>> --- a/drivers/gpu/drm/i915/i915_ttm_buddy_manager.h
>> +++ b/drivers/gpu/drm/i915/i915_ttm_buddy_manager.h
>> @@ -13,7 +13,7 @@
>>
>> struct ttm_device;
>> struct ttm_resource_manager;
>> -struct i915_buddy_mm;
>> +struct drm_buddy_mm;
>>
>> /**
>> * struct i915_ttm_buddy_resource
>> @@ -28,7 +28,7 @@ struct i915_buddy_mm;
>> struct i915_ttm_buddy_resource {
>> struct ttm_resource base;
>> struct list_head blocks;
>> - struct i915_buddy_mm *mm;
>> + struct drm_buddy_mm *mm;
>> };
>>
>> /**
>> diff --git a/include/drm/drm_buddy.h b/include/drm/drm_buddy.h
>> new file mode 100644
>> index 000000000000..5ce3fc702f80
>> --- /dev/null
>> +++ b/include/drm/drm_buddy.h
>> @@ -0,0 +1,153 @@
>> +/* SPDX-License-Identifier: MIT */
>> +/*
>> + * Copyright © 2021 Intel Corporation
>> + */
>> +
>> +#ifndef __DRM_BUDDY_H__
>> +#define __DRM_BUDDY_H__
>> +
>> +#include <linux/bitops.h>
>> +#include <linux/list.h>
>> +#include <linux/slab.h>
>> +#include <linux/sched.h>
>> +
>> +#include <drm/drm_print.h>
>> +
>> +#define range_overflows(start, size, max) ({ \
>> + typeof(start) start__ = (start); \
>> + typeof(size) size__ = (size); \
>> + typeof(max) max__ = (max); \
>> + (void)(&start__ == &size__); \
>> + (void)(&start__ == &max__); \
>> + start__ >= max__ || size__ > max__ - start__; \
>> +})
>> +
>> +struct drm_buddy_block {
>> +#define DRM_BUDDY_HEADER_OFFSET GENMASK_ULL(63, 12)
>> +#define DRM_BUDDY_HEADER_STATE GENMASK_ULL(11, 10)
>> +#define DRM_BUDDY_ALLOCATED (1 << 10)
>> +#define DRM_BUDDY_FREE (2 << 10)
>> +#define DRM_BUDDY_SPLIT (3 << 10)
>> +/* Free to be used, if needed in the future */
>> +#define DRM_BUDDY_HEADER_UNUSED GENMASK_ULL(9, 6)
>> +#define DRM_BUDDY_HEADER_ORDER GENMASK_ULL(5, 0)
>> + u64 header;
>> +
>> + struct drm_buddy_block *left;
>> + struct drm_buddy_block *right;
>> + struct drm_buddy_block *parent;
>> +
>> + void *private; /* owned by creator */
>> +
>> + /*
>> + * While the block is allocated by the user through drm_buddy_alloc*,
>> + * the user has ownership of the link, for example to maintain within
>> + * a list, if so desired. As soon as the block is freed with
>> + * drm_buddy_free* ownership is given back to the mm.
>> + */
>> + struct list_head link;
>> + struct list_head tmp_link;
>> +};
>> +
>> +/* Order-zero must be at least PAGE_SIZE */
>> +#define DRM_BUDDY_MAX_ORDER (63 - PAGE_SHIFT)
>> +
>> +/*
>> + * Binary Buddy System.
>> + *
>> + * Locking should be handled by the user, a simple mutex around
>> + * drm_buddy_alloc* and drm_buddy_free* should suffice.
>> + */
>> +struct drm_buddy_mm {
>> + /* Maintain a free list for each order. */
>> + struct list_head *free_list;
>> +
>> + /*
>> + * Maintain explicit binary tree(s) to track the allocation of the
>> + * address space. This gives us a simple way of finding a buddy block
>> + * and performing the potentially recursive merge step when freeing a
>> + * block. Nodes are either allocated or free, in which case they will
>> + * also exist on the respective free list.
>> + */
>> + struct drm_buddy_block **roots;
>> +
>> + /*
>> + * Anything from here is public, and remains static for the lifetime of
>> + * the mm. Everything above is considered do-not-touch.
>> + */
>> + unsigned int n_roots;
>> + unsigned int max_order;
>> +
>> + /* Must be at least PAGE_SIZE */
>> + u64 chunk_size;
>> + u64 size;
>> + u64 avail;
>> +};
>> +
>> +static inline u64
>> +drm_buddy_block_offset(struct drm_buddy_block *block)
>> +{
>> + return block->header & DRM_BUDDY_HEADER_OFFSET;
>> +}
>> +
>> +static inline unsigned int
>> +drm_buddy_block_order(struct drm_buddy_block *block)
>> +{
>> + return block->header & DRM_BUDDY_HEADER_ORDER;
>> +}
>> +
>> +static inline unsigned int
>> +drm_buddy_block_state(struct drm_buddy_block *block)
>> +{
>> + return block->header & DRM_BUDDY_HEADER_STATE;
>> +}
>> +
>> +static inline bool
>> +drm_buddy_block_is_allocated(struct drm_buddy_block *block)
>> +{
>> + return drm_buddy_block_state(block) == DRM_BUDDY_ALLOCATED;
>> +}
>> +
>> +static inline bool
>> +drm_buddy_block_is_free(struct drm_buddy_block *block)
>> +{
>> + return drm_buddy_block_state(block) == DRM_BUDDY_FREE;
>> +}
>> +
>> +static inline bool
>> +drm_buddy_block_is_split(struct drm_buddy_block *block)
>> +{
>> + return drm_buddy_block_state(block) == DRM_BUDDY_SPLIT;
>> +}
>> +
>> +static inline u64
>> +drm_buddy_block_size(struct drm_buddy_mm *mm,
>> + struct drm_buddy_block *block)
>> +{
>> + return mm->chunk_size << drm_buddy_block_order(block);
>> +}
>> +
>> +int drm_buddy_init(struct drm_buddy_mm *mm, u64 size, u64 chunk_size);
>> +
>> +void drm_buddy_fini(struct drm_buddy_mm *mm);
>> +
>> +struct drm_buddy_block *
>> +drm_buddy_alloc(struct drm_buddy_mm *mm, unsigned int order);
>> +
>> +int drm_buddy_alloc_range(struct drm_buddy_mm *mm,
>> + struct list_head *blocks,
>> + u64 start, u64 size);
>> +
>> +void drm_buddy_free(struct drm_buddy_mm *mm, struct drm_buddy_block *block);
>> +
>> +void drm_buddy_free_list(struct drm_buddy_mm *mm, struct list_head *objects);
>> +
>> +void drm_buddy_print(struct drm_buddy_mm *mm, struct drm_printer *p);
>> +void drm_buddy_block_print(struct drm_buddy_mm *mm,
>> + struct drm_buddy_block *block,
>> + struct drm_printer *p);
>> +
>> +void drm_buddy_module_exit(void);
>> +int drm_buddy_module_init(void);
>> +
>> +#endif
>
^ permalink raw reply [flat|nested] 46+ messages in thread
* Re: [PATCH v3 1/6] drm: move the buddy allocator from i915 into common drm
2021-11-16 20:18 ` Arunpravin
(?)
@ 2021-11-17 17:52 ` Matthew Auld
-1 siblings, 0 replies; 46+ messages in thread
From: Matthew Auld @ 2021-11-17 17:52 UTC (permalink / raw)
To: Arunpravin, dri-devel, intel-gfx, amd-gfx
Cc: alexander.deucher, tzimmermann, christian.koenig
On 16/11/2021 20:18, Arunpravin wrote:
> Move the base i915 buddy allocator code into drm
> - Move i915_buddy.h to include/drm
> - Move i915_buddy.c to drm root folder
> - Rename "i915" string with "drm" string wherever applicable
> - Rename "I915" string with "DRM" string wherever applicable
> - Fix header file dependencies
> - Fix alignment issues
> - add Makefile support for drm buddy
> - export functions and write kerneldoc description
> - Remove i915 selftest config check condition as buddy selftest
> will be moved to drm selftest folder
>
> cleanup i915 buddy references in i915 driver module
> and replace with drm buddy
>
> v2:
> - include header file in alphabetical order (Thomas)
> - merged changes listed in the body section into a single patch
> to keep the build intact (Christian, Jani)
>
> Signed-off-by: Arunpravin <Arunpravin.PaneerSelvam@amd.com>
Any ideas for what to do with the existing selftests? Currently this
series doesn't build yet for i915 due to this, and prevents throwing the
series at CI.
^ permalink raw reply [flat|nested] 46+ messages in thread
* Re: [Intel-gfx] [PATCH v3 1/6] drm: move the buddy allocator from i915 into common drm
@ 2021-11-17 17:52 ` Matthew Auld
0 siblings, 0 replies; 46+ messages in thread
From: Matthew Auld @ 2021-11-17 17:52 UTC (permalink / raw)
To: Arunpravin, dri-devel, intel-gfx, amd-gfx
Cc: alexander.deucher, tzimmermann, christian.koenig
On 16/11/2021 20:18, Arunpravin wrote:
> Move the base i915 buddy allocator code into drm
> - Move i915_buddy.h to include/drm
> - Move i915_buddy.c to drm root folder
> - Rename "i915" string with "drm" string wherever applicable
> - Rename "I915" string with "DRM" string wherever applicable
> - Fix header file dependencies
> - Fix alignment issues
> - add Makefile support for drm buddy
> - export functions and write kerneldoc description
> - Remove i915 selftest config check condition as buddy selftest
> will be moved to drm selftest folder
>
> cleanup i915 buddy references in i915 driver module
> and replace with drm buddy
>
> v2:
> - include header file in alphabetical order (Thomas)
> - merged changes listed in the body section into a single patch
> to keep the build intact (Christian, Jani)
>
> Signed-off-by: Arunpravin <Arunpravin.PaneerSelvam@amd.com>
Any ideas for what to do with the existing selftests? Currently this
series doesn't build yet for i915 due to this, and prevents throwing the
series at CI.
^ permalink raw reply [flat|nested] 46+ messages in thread
* Re: [PATCH v3 1/6] drm: move the buddy allocator from i915 into common drm
@ 2021-11-17 17:52 ` Matthew Auld
0 siblings, 0 replies; 46+ messages in thread
From: Matthew Auld @ 2021-11-17 17:52 UTC (permalink / raw)
To: Arunpravin, dri-devel, intel-gfx, amd-gfx
Cc: alexander.deucher, tzimmermann, jani.nikula, christian.koenig, daniel
On 16/11/2021 20:18, Arunpravin wrote:
> Move the base i915 buddy allocator code into drm
> - Move i915_buddy.h to include/drm
> - Move i915_buddy.c to drm root folder
> - Rename "i915" string with "drm" string wherever applicable
> - Rename "I915" string with "DRM" string wherever applicable
> - Fix header file dependencies
> - Fix alignment issues
> - add Makefile support for drm buddy
> - export functions and write kerneldoc description
> - Remove i915 selftest config check condition as buddy selftest
> will be moved to drm selftest folder
>
> cleanup i915 buddy references in i915 driver module
> and replace with drm buddy
>
> v2:
> - include header file in alphabetical order (Thomas)
> - merged changes listed in the body section into a single patch
> to keep the build intact (Christian, Jani)
>
> Signed-off-by: Arunpravin <Arunpravin.PaneerSelvam@amd.com>
Any ideas for what to do with the existing selftests? Currently this
series doesn't build yet for i915 due to this, and prevents throwing the
series at CI.
^ permalink raw reply [flat|nested] 46+ messages in thread
* Re: [PATCH v3 2/6] drm: improve drm_buddy_alloc function
2021-11-16 20:18 ` Arunpravin
(?)
@ 2021-11-17 18:39 ` Matthew Auld
-1 siblings, 0 replies; 46+ messages in thread
From: Matthew Auld @ 2021-11-17 18:39 UTC (permalink / raw)
To: Arunpravin, dri-devel, intel-gfx, amd-gfx
Cc: alexander.deucher, tzimmermann, christian.koenig
On 16/11/2021 20:18, Arunpravin wrote:
> - Make drm_buddy_alloc a single function to handle
> range allocation and non-range allocation demands
>
> - Implemented a new function alloc_range() which allocates
> the requested power-of-two block comply with range limitations
>
> - Moved order computation and memory alignment logic from
> i915 driver to drm buddy
>
> v2:
> merged below changes to keep the build unbroken
> - drm_buddy_alloc_range() becomes obsolete and may be removed
> - enable ttm range allocation (fpfn / lpfn) support in i915 driver
> - apply enhanced drm_buddy_alloc() function to i915 driver
>
> v3(Matthew Auld):
> - Fix alignment issues and remove unnecessary list_empty check
> - add more validation checks for input arguments
> - make alloc_range() block allocations as bottom-up
> - optimize order computation logic
> - replace uint64_t with u64, which is preferred in the kernel
>
> Signed-off-by: Arunpravin <Arunpravin.PaneerSelvam@amd.com>
> ---
> drivers/gpu/drm/drm_buddy.c | 259 ++++++++++--------
> drivers/gpu/drm/i915/i915_ttm_buddy_manager.c | 69 ++---
> drivers/gpu/drm/i915/i915_ttm_buddy_manager.h | 2 +
> include/drm/drm_buddy.h | 22 +-
> 4 files changed, 203 insertions(+), 149 deletions(-)
>
> diff --git a/drivers/gpu/drm/drm_buddy.c b/drivers/gpu/drm/drm_buddy.c
> index 39eb1d224bec..c9b18a29f8d1 100644
> --- a/drivers/gpu/drm/drm_buddy.c
> +++ b/drivers/gpu/drm/drm_buddy.c
> @@ -274,63 +274,6 @@ void drm_buddy_free_list(struct drm_buddy_mm *mm, struct list_head *objects)
> }
> EXPORT_SYMBOL(drm_buddy_free_list);
>
> -/**
> - * drm_buddy_alloc - allocate power-of-two blocks
> - *
> - * @mm: DRM buddy manager to allocate from
> - * @order: size of the allocation
> - *
> - * The order value here translates to:
> - *
> - * 0 = 2^0 * mm->chunk_size
> - * 1 = 2^1 * mm->chunk_size
> - * 2 = 2^2 * mm->chunk_size
> - *
> - * Returns:
> - * allocated ptr to the &drm_buddy_block on success
> - */
> -struct drm_buddy_block *
> -drm_buddy_alloc(struct drm_buddy_mm *mm, unsigned int order)
> -{
> - struct drm_buddy_block *block = NULL;
> - unsigned int i;
> - int err;
> -
> - for (i = order; i <= mm->max_order; ++i) {
> - block = list_first_entry_or_null(&mm->free_list[i],
> - struct drm_buddy_block,
> - link);
> - if (block)
> - break;
> - }
> -
> - if (!block)
> - return ERR_PTR(-ENOSPC);
> -
> - BUG_ON(!drm_buddy_block_is_free(block));
> -
> - while (i != order) {
> - err = split_block(mm, block);
> - if (unlikely(err))
> - goto out_free;
> -
> - /* Go low */
> - block = block->left;
> - i--;
> - }
> -
> - mark_allocated(block);
> - mm->avail -= drm_buddy_block_size(mm, block);
> - kmemleak_update_trace(block);
> - return block;
> -
> -out_free:
> - if (i != order)
> - __drm_buddy_free(mm, block);
> - return ERR_PTR(err);
> -}
> -EXPORT_SYMBOL(drm_buddy_alloc);
> -
> static inline bool overlaps(u64 s1, u64 e1, u64 s2, u64 e2)
> {
> return s1 <= e2 && e1 >= s2;
> @@ -341,52 +284,22 @@ static inline bool contains(u64 s1, u64 e1, u64 s2, u64 e2)
> return s1 <= s2 && e1 >= e2;
> }
>
> -/**
> - * drm_buddy_alloc_range - allocate range
> - *
> - * @mm: DRM buddy manager to allocate from
> - * @blocks: output list head to add allocated blocks
> - * @start: start of the allowed range for this block
> - * @size: size of the allocation
> - *
> - * Intended for pre-allocating portions of the address space, for example to
> - * reserve a block for the initial framebuffer or similar, hence the expectation
> - * here is that drm_buddy_alloc() is still the main vehicle for
> - * allocations, so if that's not the case then the drm_mm range allocator is
> - * probably a much better fit, and so you should probably go use that instead.
> - *
> - * Note that it's safe to chain together multiple alloc_ranges
> - * with the same blocks list
> - *
> - * Returns:
> - * 0 on success, error code on failure.
> - */
> -int drm_buddy_alloc_range(struct drm_buddy_mm *mm,
> - struct list_head *blocks,
> - u64 start, u64 size)
> +static struct drm_buddy_block *
> +alloc_range(struct drm_buddy_mm *mm,
> + u64 start, u64 end,
> + unsigned int order)
> {
> struct drm_buddy_block *block;
> struct drm_buddy_block *buddy;
> - LIST_HEAD(allocated);
> LIST_HEAD(dfs);
> - u64 end;
> int err;
> int i;
>
> - if (size < mm->chunk_size)
> - return -EINVAL;
> -
> - if (!IS_ALIGNED(size | start, mm->chunk_size))
> - return -EINVAL;
> -
> - if (range_overflows(start, size, mm->size))
> - return -EINVAL;
> + end = end - 1;
>
> for (i = 0; i < mm->n_roots; ++i)
> list_add_tail(&mm->roots[i]->tmp_link, &dfs);
>
> - end = start + size - 1;
> -
> do {
> u64 block_start;
> u64 block_end;
> @@ -399,26 +312,26 @@ int drm_buddy_alloc_range(struct drm_buddy_mm *mm,
>
> list_del(&block->tmp_link);
>
> + if (drm_buddy_block_order(block) < order)
> + continue;
> +
> block_start = drm_buddy_block_offset(block);
> block_end = block_start + drm_buddy_block_size(mm, block) - 1;
>
> if (!overlaps(start, end, block_start, block_end))
> continue;
>
> - if (drm_buddy_block_is_allocated(block)) {
> - err = -ENOSPC;
> - goto err_free;
> - }
> + if (drm_buddy_block_is_allocated(block))
> + continue;
>
> - if (contains(start, end, block_start, block_end)) {
> - if (!drm_buddy_block_is_free(block)) {
> - err = -ENOSPC;
> - goto err_free;
> - }
> + if (contains(start, end, block_start, block_end) &&
> + order == drm_buddy_block_order(block)) {
> + /*
> + * Find the free block within the range.
> + */
> + if (drm_buddy_block_is_free(block))
> + return block;
AFAIK this is still randomly ordered when dealing with actual range
allocation. Maybe I'm missing something, but it looks like we are just
repeatedly picking the largest order that fits in the remaining number
of pages, but it might be the case that the smallest block is for
example at the start of the range, depending on the layout of the
address space, which would then only get allocated last.
I think I mentioned this before, but most of the block_trim() looks to
already do what we want for this case, and could maybe be factored out,
since that is also just another range allocation, except we start with
one root node for our "dfs" search.
Maybe something like:
drm_buddy_trim(block, new_size...)
{
....
mark_free(block);
list_add(&block->tmp_link, &dfs);
err = __alloc_range(mm, &dfs, block->start, new_size, ...);
if (err)
....
}
__drm_buddy_alloc_range(start, size, blocks)
{
for_each_root()
list_add(&root->tmp_link, &dfs);
err = __alloc_range(mm, &dfs, start, size, ...);
if (err)
....
}
drm_buddy_alloc(...)
{
/* Actual range allocation */
if (start + size == end)
return __drm_buddy_alloc_range(...);
....
}
And then have something different for the alloc_range_bias()?
>
> - mark_allocated(block);
> - mm->avail -= drm_buddy_block_size(mm, block);
> - list_add_tail(&block->link, &allocated);
> continue;
> }
>
> @@ -432,8 +345,7 @@ int drm_buddy_alloc_range(struct drm_buddy_mm *mm,
> list_add(&block->left->tmp_link, &dfs);
> } while (1);
>
> - list_splice_tail(&allocated, blocks);
> - return 0;
> + return ERR_PTR(-ENOSPC);
>
> err_undo:
> /*
> @@ -446,12 +358,145 @@ int drm_buddy_alloc_range(struct drm_buddy_mm *mm,
> (drm_buddy_block_is_free(block) &&
> drm_buddy_block_is_free(buddy)))
> __drm_buddy_free(mm, block);
> + return ERR_PTR(err);
> +}
> +
> +static struct drm_buddy_block *
> +alloc_from_freelist(struct drm_buddy_mm *mm,
> + unsigned int order,
> + unsigned long flags)
> +{
> + struct drm_buddy_block *block = NULL;
> + unsigned int i;
> + int err;
> +
> + for (i = order; i <= mm->max_order; ++i) {
> + block = list_first_entry_or_null(&mm->free_list[i],
> + struct drm_buddy_block,
> + link);
> + if (block)
> + break;
> + }
> +
> + if (!block)
> + return ERR_PTR(-ENOSPC);
> +
> + BUG_ON(!drm_buddy_block_is_free(block));
> +
> + while (i != order) {
> + err = split_block(mm, block);
> + if (unlikely(err))
> + goto err_undo;
> +
> + block = block->right;
> + i--;
> + }
> + return block;
> +
> +err_undo:
> + if (i != order)
> + __drm_buddy_free(mm, block);
> + return ERR_PTR(err);
> +}
> +
> +/**
> + * drm_buddy_alloc - allocate power-of-two blocks
> + *
> + * @mm: DRM buddy manager to allocate from
> + * @start: start of the allowed range for this block
> + * @end: end of the allowed range for this block
> + * @size: size of the allocation
> + * @min_page_size: alignment of the allocation
> + * @blocks: output list head to add allocated blocks
> + * @flags: DRM_BUDDY_*_ALLOCATION flags
> + *
> + * alloc_range() called on range limitations, which traverses
> + * the tree and returns the desired block.
> + *
> + * alloc_from_freelist() called when *no* range restrictions
> + * are enforced, which picks the block from the freelist.
> + *
> + * blocks are allocated in order, the order value here translates to:
> + *
> + * 0 = 2^0 * mm->chunk_size
> + * 1 = 2^1 * mm->chunk_size
> + * 2 = 2^2 * mm->chunk_size
> + *
> + * Returns:
> + * 0 on success, error code on failure.
> + */
> +int drm_buddy_alloc(struct drm_buddy_mm *mm,
> + u64 start, u64 end, u64 size,
> + u64 min_page_size,
> + struct list_head *blocks,
> + unsigned long flags)
> +{
> + struct drm_buddy_block *block = NULL;
> + unsigned int min_order, order;
> + unsigned long pages;
> + LIST_HEAD(allocated);
> + int err;
> +
> + if (size < mm->chunk_size)
> + return -EINVAL;
> +
> + if (min_page_size < mm->chunk_size)
> + return -EINVAL;
> +
> + if (!is_power_of_2(min_page_size))
> + return -EINVAL;
> +
> + if (!IS_ALIGNED(start | end | size, mm->chunk_size))
> + return -EINVAL;
> +
> + if (check_range_overflow(start, end, size, mm->size))
> + return -EINVAL;
> +
> + pages = size >> ilog2(mm->chunk_size);
> + order = fls(pages) - 1;
> + min_order = ilog2(min_page_size) - ilog2(mm->chunk_size);
> +
> + do {
> + order = min(order, (unsigned int)fls(pages) - 1);
> + BUG_ON(order > mm->max_order);
> + BUG_ON(order < min_order);
> +
> + do {
> + if (flags & DRM_BUDDY_RANGE_ALLOCATION)
> + /* Allocate traversing within the range */
> + block = alloc_range(mm, start, end, order);
> + else
> + /* Allocate from freelist */
> + block = alloc_from_freelist(mm, order, flags);
> +
> + if (!IS_ERR(block))
> + break;
> +
> + if (order-- == min_order) {
> + err = -ENOSPC;
> + goto err_free;
> + }
> + } while (1);
> +
> + mark_allocated(block);
> + mm->avail -= drm_buddy_block_size(mm, block);
> + kmemleak_update_trace(block);
> + list_add_tail(&block->link, &allocated);
> +
> + pages -= BIT(order);
> +
> + if (!pages)
> + break;
> + } while (1);
> +
> + list_splice_tail(&allocated, blocks);
> + return 0;
>
> err_free:
> drm_buddy_free_list(mm, &allocated);
> return err;
> }
> -EXPORT_SYMBOL(drm_buddy_alloc_range);
> +EXPORT_SYMBOL(drm_buddy_alloc);
>
> /**
> * drm_buddy_block_print - print block information
> diff --git a/drivers/gpu/drm/i915/i915_ttm_buddy_manager.c b/drivers/gpu/drm/i915/i915_ttm_buddy_manager.c
> index c4b70cb8c248..9e3d130c3f42 100644
> --- a/drivers/gpu/drm/i915/i915_ttm_buddy_manager.c
> +++ b/drivers/gpu/drm/i915/i915_ttm_buddy_manager.c
> @@ -36,13 +36,14 @@ static int i915_ttm_buddy_man_alloc(struct ttm_resource_manager *man,
> struct i915_ttm_buddy_manager *bman = to_buddy_manager(man);
> struct i915_ttm_buddy_resource *bman_res;
> struct drm_buddy_mm *mm = &bman->mm;
> - unsigned long n_pages;
> - unsigned int min_order;
> + unsigned long n_pages, lpfn;
> u64 min_page_size;
> u64 size;
> int err;
>
> - GEM_BUG_ON(place->fpfn || place->lpfn);
> + lpfn = place->lpfn;
> + if (!lpfn)
> + lpfn = man->size;
>
> bman_res = kzalloc(sizeof(*bman_res), GFP_KERNEL);
> if (!bman_res)
> @@ -52,6 +53,9 @@ static int i915_ttm_buddy_man_alloc(struct ttm_resource_manager *man,
> INIT_LIST_HEAD(&bman_res->blocks);
> bman_res->mm = mm;
>
> + if (place->fpfn || lpfn != man->size)
> + bman_res->flags |= DRM_BUDDY_RANGE_ALLOCATION;
> +
> GEM_BUG_ON(!bman_res->base.num_pages);
> size = bman_res->base.num_pages << PAGE_SHIFT;
>
> @@ -60,10 +64,16 @@ static int i915_ttm_buddy_man_alloc(struct ttm_resource_manager *man,
> min_page_size = bo->page_alignment << PAGE_SHIFT;
>
> GEM_BUG_ON(min_page_size < mm->chunk_size);
> - min_order = ilog2(min_page_size) - ilog2(mm->chunk_size);
> +
> if (place->flags & TTM_PL_FLAG_CONTIGUOUS) {
> + unsigned long pages;
> +
> size = roundup_pow_of_two(size);
> - min_order = ilog2(size) - ilog2(mm->chunk_size);
> + min_page_size = size;
> +
> + pages = size >> ilog2(mm->chunk_size);
> + if (pages > lpfn)
> + lpfn = pages;
> }
>
> if (size > mm->size) {
> @@ -73,34 +83,16 @@ static int i915_ttm_buddy_man_alloc(struct ttm_resource_manager *man,
>
> n_pages = size >> ilog2(mm->chunk_size);
>
> - do {
> - struct drm_buddy_block *block;
> - unsigned int order;
> -
> - order = fls(n_pages) - 1;
> - GEM_BUG_ON(order > mm->max_order);
> - GEM_BUG_ON(order < min_order);
> -
> - do {
> - mutex_lock(&bman->lock);
> - block = drm_buddy_alloc(mm, order);
> - mutex_unlock(&bman->lock);
> - if (!IS_ERR(block))
> - break;
> -
> - if (order-- == min_order) {
> - err = -ENOSPC;
> - goto err_free_blocks;
> - }
> - } while (1);
> -
> - n_pages -= BIT(order);
> -
> - list_add_tail(&block->link, &bman_res->blocks);
> -
> - if (!n_pages)
> - break;
> - } while (1);
> + mutex_lock(&bman->lock);
> + err = drm_buddy_alloc(mm, (u64)place->fpfn << PAGE_SHIFT,
> + (u64)place->lpfn << PAGE_SHIFT,
> + (u64)n_pages << PAGE_SHIFT,
> + min_page_size,
> + &bman_res->blocks,
> + bman_res->flags);
> + mutex_unlock(&bman->lock);
> + if (unlikely(err))
> + goto err_free_blocks;
>
> *res = &bman_res->base;
> return 0;
> @@ -266,10 +258,19 @@ int i915_ttm_buddy_man_reserve(struct ttm_resource_manager *man,
> {
> struct i915_ttm_buddy_manager *bman = to_buddy_manager(man);
> struct drm_buddy_mm *mm = &bman->mm;
> + unsigned long flags = 0;
> + u64 min_size;
> int ret;
>
> + min_size = size;
> + flags |= DRM_BUDDY_RANGE_ALLOCATION;
> +
> mutex_lock(&bman->lock);
> - ret = drm_buddy_alloc_range(mm, &bman->reserved, start, size);
> + ret = drm_buddy_alloc(mm, start,
> + start + size,
> + size, min_size,
min_page_size = min_size = size. I don't think we want that here. Also
the size here might not be power of two. I guess we need to use
chunk_size here instead?
> + &bman->reserved,
> + flags);
> mutex_unlock(&bman->lock);
>
> return ret;
> diff --git a/drivers/gpu/drm/i915/i915_ttm_buddy_manager.h b/drivers/gpu/drm/i915/i915_ttm_buddy_manager.h
> index fa644b512c2e..5ba490875f66 100644
> --- a/drivers/gpu/drm/i915/i915_ttm_buddy_manager.h
> +++ b/drivers/gpu/drm/i915/i915_ttm_buddy_manager.h
> @@ -20,6 +20,7 @@ struct drm_buddy_mm;
> *
> * @base: struct ttm_resource base class we extend
> * @blocks: the list of struct i915_buddy_block for this resource/allocation
> + * @flags: DRM_BUDDY_*_ALLOCATION flags
> * @mm: the struct i915_buddy_mm for this resource
> *
> * Extends the struct ttm_resource to manage an address space allocation with
> @@ -28,6 +29,7 @@ struct drm_buddy_mm;
> struct i915_ttm_buddy_resource {
> struct ttm_resource base;
> struct list_head blocks;
> + unsigned long flags;
> struct drm_buddy_mm *mm;
> };
>
> diff --git a/include/drm/drm_buddy.h b/include/drm/drm_buddy.h
> index 5ce3fc702f80..2ec3cbc9d5d7 100644
> --- a/include/drm/drm_buddy.h
> +++ b/include/drm/drm_buddy.h
> @@ -13,15 +13,22 @@
>
> #include <drm/drm_print.h>
>
> -#define range_overflows(start, size, max) ({ \
> +#define check_range_overflow(start, end, size, max) ({ \
> typeof(start) start__ = (start); \
> + typeof(end) end__ = (end);\
> typeof(size) size__ = (size); \
> typeof(max) max__ = (max); \
> (void)(&start__ == &size__); \
> (void)(&start__ == &max__); \
> - start__ >= max__ || size__ > max__ - start__; \
> + (void)(&start__ == &end__); \
> + (void)(&end__ == &size__); \
> + (void)(&end__ == &max__); \
> + start__ >= max__ || end__ > max__ || \
> + size__ > end__ - start__; \
> })
>
> +#define DRM_BUDDY_RANGE_ALLOCATION (1 << 0)
> +
> struct drm_buddy_block {
> #define DRM_BUDDY_HEADER_OFFSET GENMASK_ULL(63, 12)
> #define DRM_BUDDY_HEADER_STATE GENMASK_ULL(11, 10)
> @@ -131,12 +138,11 @@ int drm_buddy_init(struct drm_buddy_mm *mm, u64 size, u64 chunk_size);
>
> void drm_buddy_fini(struct drm_buddy_mm *mm);
>
> -struct drm_buddy_block *
> -drm_buddy_alloc(struct drm_buddy_mm *mm, unsigned int order);
> -
> -int drm_buddy_alloc_range(struct drm_buddy_mm *mm,
> - struct list_head *blocks,
> - u64 start, u64 size);
> +int drm_buddy_alloc(struct drm_buddy_mm *mm,
> + u64 start, u64 end, u64 size,
> + u64 min_page_size,
> + struct list_head *blocks,
> + unsigned long flags);
>
> void drm_buddy_free(struct drm_buddy_mm *mm, struct drm_buddy_block *block);
>
>
^ permalink raw reply [flat|nested] 46+ messages in thread
* Re: [Intel-gfx] [PATCH v3 2/6] drm: improve drm_buddy_alloc function
@ 2021-11-17 18:39 ` Matthew Auld
0 siblings, 0 replies; 46+ messages in thread
From: Matthew Auld @ 2021-11-17 18:39 UTC (permalink / raw)
To: Arunpravin, dri-devel, intel-gfx, amd-gfx
Cc: alexander.deucher, tzimmermann, christian.koenig
On 16/11/2021 20:18, Arunpravin wrote:
> - Make drm_buddy_alloc a single function to handle
> range allocation and non-range allocation demands
>
> - Implemented a new function alloc_range() which allocates
> the requested power-of-two block comply with range limitations
>
> - Moved order computation and memory alignment logic from
> i915 driver to drm buddy
>
> v2:
> merged below changes to keep the build unbroken
> - drm_buddy_alloc_range() becomes obsolete and may be removed
> - enable ttm range allocation (fpfn / lpfn) support in i915 driver
> - apply enhanced drm_buddy_alloc() function to i915 driver
>
> v3(Matthew Auld):
> - Fix alignment issues and remove unnecessary list_empty check
> - add more validation checks for input arguments
> - make alloc_range() block allocations as bottom-up
> - optimize order computation logic
> - replace uint64_t with u64, which is preferred in the kernel
>
> Signed-off-by: Arunpravin <Arunpravin.PaneerSelvam@amd.com>
> ---
> drivers/gpu/drm/drm_buddy.c | 259 ++++++++++--------
> drivers/gpu/drm/i915/i915_ttm_buddy_manager.c | 69 ++---
> drivers/gpu/drm/i915/i915_ttm_buddy_manager.h | 2 +
> include/drm/drm_buddy.h | 22 +-
> 4 files changed, 203 insertions(+), 149 deletions(-)
>
> diff --git a/drivers/gpu/drm/drm_buddy.c b/drivers/gpu/drm/drm_buddy.c
> index 39eb1d224bec..c9b18a29f8d1 100644
> --- a/drivers/gpu/drm/drm_buddy.c
> +++ b/drivers/gpu/drm/drm_buddy.c
> @@ -274,63 +274,6 @@ void drm_buddy_free_list(struct drm_buddy_mm *mm, struct list_head *objects)
> }
> EXPORT_SYMBOL(drm_buddy_free_list);
>
> -/**
> - * drm_buddy_alloc - allocate power-of-two blocks
> - *
> - * @mm: DRM buddy manager to allocate from
> - * @order: size of the allocation
> - *
> - * The order value here translates to:
> - *
> - * 0 = 2^0 * mm->chunk_size
> - * 1 = 2^1 * mm->chunk_size
> - * 2 = 2^2 * mm->chunk_size
> - *
> - * Returns:
> - * allocated ptr to the &drm_buddy_block on success
> - */
> -struct drm_buddy_block *
> -drm_buddy_alloc(struct drm_buddy_mm *mm, unsigned int order)
> -{
> - struct drm_buddy_block *block = NULL;
> - unsigned int i;
> - int err;
> -
> - for (i = order; i <= mm->max_order; ++i) {
> - block = list_first_entry_or_null(&mm->free_list[i],
> - struct drm_buddy_block,
> - link);
> - if (block)
> - break;
> - }
> -
> - if (!block)
> - return ERR_PTR(-ENOSPC);
> -
> - BUG_ON(!drm_buddy_block_is_free(block));
> -
> - while (i != order) {
> - err = split_block(mm, block);
> - if (unlikely(err))
> - goto out_free;
> -
> - /* Go low */
> - block = block->left;
> - i--;
> - }
> -
> - mark_allocated(block);
> - mm->avail -= drm_buddy_block_size(mm, block);
> - kmemleak_update_trace(block);
> - return block;
> -
> -out_free:
> - if (i != order)
> - __drm_buddy_free(mm, block);
> - return ERR_PTR(err);
> -}
> -EXPORT_SYMBOL(drm_buddy_alloc);
> -
> static inline bool overlaps(u64 s1, u64 e1, u64 s2, u64 e2)
> {
> return s1 <= e2 && e1 >= s2;
> @@ -341,52 +284,22 @@ static inline bool contains(u64 s1, u64 e1, u64 s2, u64 e2)
> return s1 <= s2 && e1 >= e2;
> }
>
> -/**
> - * drm_buddy_alloc_range - allocate range
> - *
> - * @mm: DRM buddy manager to allocate from
> - * @blocks: output list head to add allocated blocks
> - * @start: start of the allowed range for this block
> - * @size: size of the allocation
> - *
> - * Intended for pre-allocating portions of the address space, for example to
> - * reserve a block for the initial framebuffer or similar, hence the expectation
> - * here is that drm_buddy_alloc() is still the main vehicle for
> - * allocations, so if that's not the case then the drm_mm range allocator is
> - * probably a much better fit, and so you should probably go use that instead.
> - *
> - * Note that it's safe to chain together multiple alloc_ranges
> - * with the same blocks list
> - *
> - * Returns:
> - * 0 on success, error code on failure.
> - */
> -int drm_buddy_alloc_range(struct drm_buddy_mm *mm,
> - struct list_head *blocks,
> - u64 start, u64 size)
> +static struct drm_buddy_block *
> +alloc_range(struct drm_buddy_mm *mm,
> + u64 start, u64 end,
> + unsigned int order)
> {
> struct drm_buddy_block *block;
> struct drm_buddy_block *buddy;
> - LIST_HEAD(allocated);
> LIST_HEAD(dfs);
> - u64 end;
> int err;
> int i;
>
> - if (size < mm->chunk_size)
> - return -EINVAL;
> -
> - if (!IS_ALIGNED(size | start, mm->chunk_size))
> - return -EINVAL;
> -
> - if (range_overflows(start, size, mm->size))
> - return -EINVAL;
> + end = end - 1;
>
> for (i = 0; i < mm->n_roots; ++i)
> list_add_tail(&mm->roots[i]->tmp_link, &dfs);
>
> - end = start + size - 1;
> -
> do {
> u64 block_start;
> u64 block_end;
> @@ -399,26 +312,26 @@ int drm_buddy_alloc_range(struct drm_buddy_mm *mm,
>
> list_del(&block->tmp_link);
>
> + if (drm_buddy_block_order(block) < order)
> + continue;
> +
> block_start = drm_buddy_block_offset(block);
> block_end = block_start + drm_buddy_block_size(mm, block) - 1;
>
> if (!overlaps(start, end, block_start, block_end))
> continue;
>
> - if (drm_buddy_block_is_allocated(block)) {
> - err = -ENOSPC;
> - goto err_free;
> - }
> + if (drm_buddy_block_is_allocated(block))
> + continue;
>
> - if (contains(start, end, block_start, block_end)) {
> - if (!drm_buddy_block_is_free(block)) {
> - err = -ENOSPC;
> - goto err_free;
> - }
> + if (contains(start, end, block_start, block_end) &&
> + order == drm_buddy_block_order(block)) {
> + /*
> + * Find the free block within the range.
> + */
> + if (drm_buddy_block_is_free(block))
> + return block;
AFAIK this is still randomly ordered when dealing with actual range
allocation. Maybe I'm missing something, but it looks like we are just
repeatedly picking the largest order that fits in the remaining number
of pages, but it might be the case that the smallest block is for
example at the start of the range, depending on the layout of the
address space, which would then only get allocated last.
I think I mentioned this before, but most of the block_trim() looks to
already do what we want for this case, and could maybe be factored out,
since that is also just another range allocation, except we start with
one root node for our "dfs" search.
Maybe something like:
drm_buddy_trim(block, new_size...)
{
....
mark_free(block);
list_add(&block->tmp_link, &dfs);
err = __alloc_range(mm, &dfs, block->start, new_size, ...);
if (err)
....
}
__drm_buddy_alloc_range(start, size, blocks)
{
for_each_root()
list_add(&root->tmp_link, &dfs);
err = __alloc_range(mm, &dfs, start, size, ...);
if (err)
....
}
drm_buddy_alloc(...)
{
/* Actual range allocation */
if (start + size == end)
return __drm_buddy_alloc_range(...);
....
}
And then have something different for the alloc_range_bias()?
>
> - mark_allocated(block);
> - mm->avail -= drm_buddy_block_size(mm, block);
> - list_add_tail(&block->link, &allocated);
> continue;
> }
>
> @@ -432,8 +345,7 @@ int drm_buddy_alloc_range(struct drm_buddy_mm *mm,
> list_add(&block->left->tmp_link, &dfs);
> } while (1);
>
> - list_splice_tail(&allocated, blocks);
> - return 0;
> + return ERR_PTR(-ENOSPC);
>
> err_undo:
> /*
> @@ -446,12 +358,145 @@ int drm_buddy_alloc_range(struct drm_buddy_mm *mm,
> (drm_buddy_block_is_free(block) &&
> drm_buddy_block_is_free(buddy)))
> __drm_buddy_free(mm, block);
> + return ERR_PTR(err);
> +}
> +
> +static struct drm_buddy_block *
> +alloc_from_freelist(struct drm_buddy_mm *mm,
> + unsigned int order,
> + unsigned long flags)
> +{
> + struct drm_buddy_block *block = NULL;
> + unsigned int i;
> + int err;
> +
> + for (i = order; i <= mm->max_order; ++i) {
> + block = list_first_entry_or_null(&mm->free_list[i],
> + struct drm_buddy_block,
> + link);
> + if (block)
> + break;
> + }
> +
> + if (!block)
> + return ERR_PTR(-ENOSPC);
> +
> + BUG_ON(!drm_buddy_block_is_free(block));
> +
> + while (i != order) {
> + err = split_block(mm, block);
> + if (unlikely(err))
> + goto err_undo;
> +
> + block = block->right;
> + i--;
> + }
> + return block;
> +
> +err_undo:
> + if (i != order)
> + __drm_buddy_free(mm, block);
> + return ERR_PTR(err);
> +}
> +
> +/**
> + * drm_buddy_alloc - allocate power-of-two blocks
> + *
> + * @mm: DRM buddy manager to allocate from
> + * @start: start of the allowed range for this block
> + * @end: end of the allowed range for this block
> + * @size: size of the allocation
> + * @min_page_size: alignment of the allocation
> + * @blocks: output list head to add allocated blocks
> + * @flags: DRM_BUDDY_*_ALLOCATION flags
> + *
> + * alloc_range() called on range limitations, which traverses
> + * the tree and returns the desired block.
> + *
> + * alloc_from_freelist() called when *no* range restrictions
> + * are enforced, which picks the block from the freelist.
> + *
> + * blocks are allocated in order, the order value here translates to:
> + *
> + * 0 = 2^0 * mm->chunk_size
> + * 1 = 2^1 * mm->chunk_size
> + * 2 = 2^2 * mm->chunk_size
> + *
> + * Returns:
> + * 0 on success, error code on failure.
> + */
> +int drm_buddy_alloc(struct drm_buddy_mm *mm,
> + u64 start, u64 end, u64 size,
> + u64 min_page_size,
> + struct list_head *blocks,
> + unsigned long flags)
> +{
> + struct drm_buddy_block *block = NULL;
> + unsigned int min_order, order;
> + unsigned long pages;
> + LIST_HEAD(allocated);
> + int err;
> +
> + if (size < mm->chunk_size)
> + return -EINVAL;
> +
> + if (min_page_size < mm->chunk_size)
> + return -EINVAL;
> +
> + if (!is_power_of_2(min_page_size))
> + return -EINVAL;
> +
> + if (!IS_ALIGNED(start | end | size, mm->chunk_size))
> + return -EINVAL;
> +
> + if (check_range_overflow(start, end, size, mm->size))
> + return -EINVAL;
> +
> + pages = size >> ilog2(mm->chunk_size);
> + order = fls(pages) - 1;
> + min_order = ilog2(min_page_size) - ilog2(mm->chunk_size);
> +
> + do {
> + order = min(order, (unsigned int)fls(pages) - 1);
> + BUG_ON(order > mm->max_order);
> + BUG_ON(order < min_order);
> +
> + do {
> + if (flags & DRM_BUDDY_RANGE_ALLOCATION)
> + /* Allocate traversing within the range */
> + block = alloc_range(mm, start, end, order);
> + else
> + /* Allocate from freelist */
> + block = alloc_from_freelist(mm, order, flags);
> +
> + if (!IS_ERR(block))
> + break;
> +
> + if (order-- == min_order) {
> + err = -ENOSPC;
> + goto err_free;
> + }
> + } while (1);
> +
> + mark_allocated(block);
> + mm->avail -= drm_buddy_block_size(mm, block);
> + kmemleak_update_trace(block);
> + list_add_tail(&block->link, &allocated);
> +
> + pages -= BIT(order);
> +
> + if (!pages)
> + break;
> + } while (1);
> +
> + list_splice_tail(&allocated, blocks);
> + return 0;
>
> err_free:
> drm_buddy_free_list(mm, &allocated);
> return err;
> }
> -EXPORT_SYMBOL(drm_buddy_alloc_range);
> +EXPORT_SYMBOL(drm_buddy_alloc);
>
> /**
> * drm_buddy_block_print - print block information
> diff --git a/drivers/gpu/drm/i915/i915_ttm_buddy_manager.c b/drivers/gpu/drm/i915/i915_ttm_buddy_manager.c
> index c4b70cb8c248..9e3d130c3f42 100644
> --- a/drivers/gpu/drm/i915/i915_ttm_buddy_manager.c
> +++ b/drivers/gpu/drm/i915/i915_ttm_buddy_manager.c
> @@ -36,13 +36,14 @@ static int i915_ttm_buddy_man_alloc(struct ttm_resource_manager *man,
> struct i915_ttm_buddy_manager *bman = to_buddy_manager(man);
> struct i915_ttm_buddy_resource *bman_res;
> struct drm_buddy_mm *mm = &bman->mm;
> - unsigned long n_pages;
> - unsigned int min_order;
> + unsigned long n_pages, lpfn;
> u64 min_page_size;
> u64 size;
> int err;
>
> - GEM_BUG_ON(place->fpfn || place->lpfn);
> + lpfn = place->lpfn;
> + if (!lpfn)
> + lpfn = man->size;
>
> bman_res = kzalloc(sizeof(*bman_res), GFP_KERNEL);
> if (!bman_res)
> @@ -52,6 +53,9 @@ static int i915_ttm_buddy_man_alloc(struct ttm_resource_manager *man,
> INIT_LIST_HEAD(&bman_res->blocks);
> bman_res->mm = mm;
>
> + if (place->fpfn || lpfn != man->size)
> + bman_res->flags |= DRM_BUDDY_RANGE_ALLOCATION;
> +
> GEM_BUG_ON(!bman_res->base.num_pages);
> size = bman_res->base.num_pages << PAGE_SHIFT;
>
> @@ -60,10 +64,16 @@ static int i915_ttm_buddy_man_alloc(struct ttm_resource_manager *man,
> min_page_size = bo->page_alignment << PAGE_SHIFT;
>
> GEM_BUG_ON(min_page_size < mm->chunk_size);
> - min_order = ilog2(min_page_size) - ilog2(mm->chunk_size);
> +
> if (place->flags & TTM_PL_FLAG_CONTIGUOUS) {
> + unsigned long pages;
> +
> size = roundup_pow_of_two(size);
> - min_order = ilog2(size) - ilog2(mm->chunk_size);
> + min_page_size = size;
> +
> + pages = size >> ilog2(mm->chunk_size);
> + if (pages > lpfn)
> + lpfn = pages;
> }
>
> if (size > mm->size) {
> @@ -73,34 +83,16 @@ static int i915_ttm_buddy_man_alloc(struct ttm_resource_manager *man,
>
> n_pages = size >> ilog2(mm->chunk_size);
>
> - do {
> - struct drm_buddy_block *block;
> - unsigned int order;
> -
> - order = fls(n_pages) - 1;
> - GEM_BUG_ON(order > mm->max_order);
> - GEM_BUG_ON(order < min_order);
> -
> - do {
> - mutex_lock(&bman->lock);
> - block = drm_buddy_alloc(mm, order);
> - mutex_unlock(&bman->lock);
> - if (!IS_ERR(block))
> - break;
> -
> - if (order-- == min_order) {
> - err = -ENOSPC;
> - goto err_free_blocks;
> - }
> - } while (1);
> -
> - n_pages -= BIT(order);
> -
> - list_add_tail(&block->link, &bman_res->blocks);
> -
> - if (!n_pages)
> - break;
> - } while (1);
> + mutex_lock(&bman->lock);
> + err = drm_buddy_alloc(mm, (u64)place->fpfn << PAGE_SHIFT,
> + (u64)place->lpfn << PAGE_SHIFT,
> + (u64)n_pages << PAGE_SHIFT,
> + min_page_size,
> + &bman_res->blocks,
> + bman_res->flags);
> + mutex_unlock(&bman->lock);
> + if (unlikely(err))
> + goto err_free_blocks;
>
> *res = &bman_res->base;
> return 0;
> @@ -266,10 +258,19 @@ int i915_ttm_buddy_man_reserve(struct ttm_resource_manager *man,
> {
> struct i915_ttm_buddy_manager *bman = to_buddy_manager(man);
> struct drm_buddy_mm *mm = &bman->mm;
> + unsigned long flags = 0;
> + u64 min_size;
> int ret;
>
> + min_size = size;
> + flags |= DRM_BUDDY_RANGE_ALLOCATION;
> +
> mutex_lock(&bman->lock);
> - ret = drm_buddy_alloc_range(mm, &bman->reserved, start, size);
> + ret = drm_buddy_alloc(mm, start,
> + start + size,
> + size, min_size,
min_page_size = min_size = size. I don't think we want that here. Also
the size here might not be power of two. I guess we need to use
chunk_size here instead?
> + &bman->reserved,
> + flags);
> mutex_unlock(&bman->lock);
>
> return ret;
> diff --git a/drivers/gpu/drm/i915/i915_ttm_buddy_manager.h b/drivers/gpu/drm/i915/i915_ttm_buddy_manager.h
> index fa644b512c2e..5ba490875f66 100644
> --- a/drivers/gpu/drm/i915/i915_ttm_buddy_manager.h
> +++ b/drivers/gpu/drm/i915/i915_ttm_buddy_manager.h
> @@ -20,6 +20,7 @@ struct drm_buddy_mm;
> *
> * @base: struct ttm_resource base class we extend
> * @blocks: the list of struct i915_buddy_block for this resource/allocation
> + * @flags: DRM_BUDDY_*_ALLOCATION flags
> * @mm: the struct i915_buddy_mm for this resource
> *
> * Extends the struct ttm_resource to manage an address space allocation with
> @@ -28,6 +29,7 @@ struct drm_buddy_mm;
> struct i915_ttm_buddy_resource {
> struct ttm_resource base;
> struct list_head blocks;
> + unsigned long flags;
> struct drm_buddy_mm *mm;
> };
>
> diff --git a/include/drm/drm_buddy.h b/include/drm/drm_buddy.h
> index 5ce3fc702f80..2ec3cbc9d5d7 100644
> --- a/include/drm/drm_buddy.h
> +++ b/include/drm/drm_buddy.h
> @@ -13,15 +13,22 @@
>
> #include <drm/drm_print.h>
>
> -#define range_overflows(start, size, max) ({ \
> +#define check_range_overflow(start, end, size, max) ({ \
> typeof(start) start__ = (start); \
> + typeof(end) end__ = (end);\
> typeof(size) size__ = (size); \
> typeof(max) max__ = (max); \
> (void)(&start__ == &size__); \
> (void)(&start__ == &max__); \
> - start__ >= max__ || size__ > max__ - start__; \
> + (void)(&start__ == &end__); \
> + (void)(&end__ == &size__); \
> + (void)(&end__ == &max__); \
> + start__ >= max__ || end__ > max__ || \
> + size__ > end__ - start__; \
> })
>
> +#define DRM_BUDDY_RANGE_ALLOCATION (1 << 0)
> +
> struct drm_buddy_block {
> #define DRM_BUDDY_HEADER_OFFSET GENMASK_ULL(63, 12)
> #define DRM_BUDDY_HEADER_STATE GENMASK_ULL(11, 10)
> @@ -131,12 +138,11 @@ int drm_buddy_init(struct drm_buddy_mm *mm, u64 size, u64 chunk_size);
>
> void drm_buddy_fini(struct drm_buddy_mm *mm);
>
> -struct drm_buddy_block *
> -drm_buddy_alloc(struct drm_buddy_mm *mm, unsigned int order);
> -
> -int drm_buddy_alloc_range(struct drm_buddy_mm *mm,
> - struct list_head *blocks,
> - u64 start, u64 size);
> +int drm_buddy_alloc(struct drm_buddy_mm *mm,
> + u64 start, u64 end, u64 size,
> + u64 min_page_size,
> + struct list_head *blocks,
> + unsigned long flags);
>
> void drm_buddy_free(struct drm_buddy_mm *mm, struct drm_buddy_block *block);
>
>
^ permalink raw reply [flat|nested] 46+ messages in thread
* Re: [PATCH v3 2/6] drm: improve drm_buddy_alloc function
@ 2021-11-17 18:39 ` Matthew Auld
0 siblings, 0 replies; 46+ messages in thread
From: Matthew Auld @ 2021-11-17 18:39 UTC (permalink / raw)
To: Arunpravin, dri-devel, intel-gfx, amd-gfx
Cc: alexander.deucher, tzimmermann, jani.nikula, christian.koenig, daniel
On 16/11/2021 20:18, Arunpravin wrote:
> - Make drm_buddy_alloc a single function to handle
> range allocation and non-range allocation demands
>
> - Implemented a new function alloc_range() which allocates
> the requested power-of-two block comply with range limitations
>
> - Moved order computation and memory alignment logic from
> i915 driver to drm buddy
>
> v2:
> merged below changes to keep the build unbroken
> - drm_buddy_alloc_range() becomes obsolete and may be removed
> - enable ttm range allocation (fpfn / lpfn) support in i915 driver
> - apply enhanced drm_buddy_alloc() function to i915 driver
>
> v3(Matthew Auld):
> - Fix alignment issues and remove unnecessary list_empty check
> - add more validation checks for input arguments
> - make alloc_range() block allocations as bottom-up
> - optimize order computation logic
> - replace uint64_t with u64, which is preferred in the kernel
>
> Signed-off-by: Arunpravin <Arunpravin.PaneerSelvam@amd.com>
> ---
> drivers/gpu/drm/drm_buddy.c | 259 ++++++++++--------
> drivers/gpu/drm/i915/i915_ttm_buddy_manager.c | 69 ++---
> drivers/gpu/drm/i915/i915_ttm_buddy_manager.h | 2 +
> include/drm/drm_buddy.h | 22 +-
> 4 files changed, 203 insertions(+), 149 deletions(-)
>
> diff --git a/drivers/gpu/drm/drm_buddy.c b/drivers/gpu/drm/drm_buddy.c
> index 39eb1d224bec..c9b18a29f8d1 100644
> --- a/drivers/gpu/drm/drm_buddy.c
> +++ b/drivers/gpu/drm/drm_buddy.c
> @@ -274,63 +274,6 @@ void drm_buddy_free_list(struct drm_buddy_mm *mm, struct list_head *objects)
> }
> EXPORT_SYMBOL(drm_buddy_free_list);
>
> -/**
> - * drm_buddy_alloc - allocate power-of-two blocks
> - *
> - * @mm: DRM buddy manager to allocate from
> - * @order: size of the allocation
> - *
> - * The order value here translates to:
> - *
> - * 0 = 2^0 * mm->chunk_size
> - * 1 = 2^1 * mm->chunk_size
> - * 2 = 2^2 * mm->chunk_size
> - *
> - * Returns:
> - * allocated ptr to the &drm_buddy_block on success
> - */
> -struct drm_buddy_block *
> -drm_buddy_alloc(struct drm_buddy_mm *mm, unsigned int order)
> -{
> - struct drm_buddy_block *block = NULL;
> - unsigned int i;
> - int err;
> -
> - for (i = order; i <= mm->max_order; ++i) {
> - block = list_first_entry_or_null(&mm->free_list[i],
> - struct drm_buddy_block,
> - link);
> - if (block)
> - break;
> - }
> -
> - if (!block)
> - return ERR_PTR(-ENOSPC);
> -
> - BUG_ON(!drm_buddy_block_is_free(block));
> -
> - while (i != order) {
> - err = split_block(mm, block);
> - if (unlikely(err))
> - goto out_free;
> -
> - /* Go low */
> - block = block->left;
> - i--;
> - }
> -
> - mark_allocated(block);
> - mm->avail -= drm_buddy_block_size(mm, block);
> - kmemleak_update_trace(block);
> - return block;
> -
> -out_free:
> - if (i != order)
> - __drm_buddy_free(mm, block);
> - return ERR_PTR(err);
> -}
> -EXPORT_SYMBOL(drm_buddy_alloc);
> -
> static inline bool overlaps(u64 s1, u64 e1, u64 s2, u64 e2)
> {
> return s1 <= e2 && e1 >= s2;
> @@ -341,52 +284,22 @@ static inline bool contains(u64 s1, u64 e1, u64 s2, u64 e2)
> return s1 <= s2 && e1 >= e2;
> }
>
> -/**
> - * drm_buddy_alloc_range - allocate range
> - *
> - * @mm: DRM buddy manager to allocate from
> - * @blocks: output list head to add allocated blocks
> - * @start: start of the allowed range for this block
> - * @size: size of the allocation
> - *
> - * Intended for pre-allocating portions of the address space, for example to
> - * reserve a block for the initial framebuffer or similar, hence the expectation
> - * here is that drm_buddy_alloc() is still the main vehicle for
> - * allocations, so if that's not the case then the drm_mm range allocator is
> - * probably a much better fit, and so you should probably go use that instead.
> - *
> - * Note that it's safe to chain together multiple alloc_ranges
> - * with the same blocks list
> - *
> - * Returns:
> - * 0 on success, error code on failure.
> - */
> -int drm_buddy_alloc_range(struct drm_buddy_mm *mm,
> - struct list_head *blocks,
> - u64 start, u64 size)
> +static struct drm_buddy_block *
> +alloc_range(struct drm_buddy_mm *mm,
> + u64 start, u64 end,
> + unsigned int order)
> {
> struct drm_buddy_block *block;
> struct drm_buddy_block *buddy;
> - LIST_HEAD(allocated);
> LIST_HEAD(dfs);
> - u64 end;
> int err;
> int i;
>
> - if (size < mm->chunk_size)
> - return -EINVAL;
> -
> - if (!IS_ALIGNED(size | start, mm->chunk_size))
> - return -EINVAL;
> -
> - if (range_overflows(start, size, mm->size))
> - return -EINVAL;
> + end = end - 1;
>
> for (i = 0; i < mm->n_roots; ++i)
> list_add_tail(&mm->roots[i]->tmp_link, &dfs);
>
> - end = start + size - 1;
> -
> do {
> u64 block_start;
> u64 block_end;
> @@ -399,26 +312,26 @@ int drm_buddy_alloc_range(struct drm_buddy_mm *mm,
>
> list_del(&block->tmp_link);
>
> + if (drm_buddy_block_order(block) < order)
> + continue;
> +
> block_start = drm_buddy_block_offset(block);
> block_end = block_start + drm_buddy_block_size(mm, block) - 1;
>
> if (!overlaps(start, end, block_start, block_end))
> continue;
>
> - if (drm_buddy_block_is_allocated(block)) {
> - err = -ENOSPC;
> - goto err_free;
> - }
> + if (drm_buddy_block_is_allocated(block))
> + continue;
>
> - if (contains(start, end, block_start, block_end)) {
> - if (!drm_buddy_block_is_free(block)) {
> - err = -ENOSPC;
> - goto err_free;
> - }
> + if (contains(start, end, block_start, block_end) &&
> + order == drm_buddy_block_order(block)) {
> + /*
> + * Find the free block within the range.
> + */
> + if (drm_buddy_block_is_free(block))
> + return block;
AFAIK this is still randomly ordered when dealing with actual range
allocation. Maybe I'm missing something, but it looks like we are just
repeatedly picking the largest order that fits in the remaining number
of pages, but it might be the case that the smallest block is for
example at the start of the range, depending on the layout of the
address space, which would then only get allocated last.
I think I mentioned this before, but most of the block_trim() looks to
already do what we want for this case, and could maybe be factored out,
since that is also just another range allocation, except we start with
one root node for our "dfs" search.
Maybe something like:
drm_buddy_trim(block, new_size...)
{
....
mark_free(block);
list_add(&block->tmp_link, &dfs);
err = __alloc_range(mm, &dfs, block->start, new_size, ...);
if (err)
....
}
__drm_buddy_alloc_range(start, size, blocks)
{
for_each_root()
list_add(&root->tmp_link, &dfs);
err = __alloc_range(mm, &dfs, start, size, ...);
if (err)
....
}
drm_buddy_alloc(...)
{
/* Actual range allocation */
if (start + size == end)
return __drm_buddy_alloc_range(...);
....
}
And then have something different for the alloc_range_bias()?
>
> - mark_allocated(block);
> - mm->avail -= drm_buddy_block_size(mm, block);
> - list_add_tail(&block->link, &allocated);
> continue;
> }
>
> @@ -432,8 +345,7 @@ int drm_buddy_alloc_range(struct drm_buddy_mm *mm,
> list_add(&block->left->tmp_link, &dfs);
> } while (1);
>
> - list_splice_tail(&allocated, blocks);
> - return 0;
> + return ERR_PTR(-ENOSPC);
>
> err_undo:
> /*
> @@ -446,12 +358,145 @@ int drm_buddy_alloc_range(struct drm_buddy_mm *mm,
> (drm_buddy_block_is_free(block) &&
> drm_buddy_block_is_free(buddy)))
> __drm_buddy_free(mm, block);
> + return ERR_PTR(err);
> +}
> +
> +static struct drm_buddy_block *
> +alloc_from_freelist(struct drm_buddy_mm *mm,
> + unsigned int order,
> + unsigned long flags)
> +{
> + struct drm_buddy_block *block = NULL;
> + unsigned int i;
> + int err;
> +
> + for (i = order; i <= mm->max_order; ++i) {
> + block = list_first_entry_or_null(&mm->free_list[i],
> + struct drm_buddy_block,
> + link);
> + if (block)
> + break;
> + }
> +
> + if (!block)
> + return ERR_PTR(-ENOSPC);
> +
> + BUG_ON(!drm_buddy_block_is_free(block));
> +
> + while (i != order) {
> + err = split_block(mm, block);
> + if (unlikely(err))
> + goto err_undo;
> +
> + block = block->right;
> + i--;
> + }
> + return block;
> +
> +err_undo:
> + if (i != order)
> + __drm_buddy_free(mm, block);
> + return ERR_PTR(err);
> +}
> +
> +/**
> + * drm_buddy_alloc - allocate power-of-two blocks
> + *
> + * @mm: DRM buddy manager to allocate from
> + * @start: start of the allowed range for this block
> + * @end: end of the allowed range for this block
> + * @size: size of the allocation
> + * @min_page_size: alignment of the allocation
> + * @blocks: output list head to add allocated blocks
> + * @flags: DRM_BUDDY_*_ALLOCATION flags
> + *
> + * alloc_range() called on range limitations, which traverses
> + * the tree and returns the desired block.
> + *
> + * alloc_from_freelist() called when *no* range restrictions
> + * are enforced, which picks the block from the freelist.
> + *
> + * blocks are allocated in order, the order value here translates to:
> + *
> + * 0 = 2^0 * mm->chunk_size
> + * 1 = 2^1 * mm->chunk_size
> + * 2 = 2^2 * mm->chunk_size
> + *
> + * Returns:
> + * 0 on success, error code on failure.
> + */
> +int drm_buddy_alloc(struct drm_buddy_mm *mm,
> + u64 start, u64 end, u64 size,
> + u64 min_page_size,
> + struct list_head *blocks,
> + unsigned long flags)
> +{
> + struct drm_buddy_block *block = NULL;
> + unsigned int min_order, order;
> + unsigned long pages;
> + LIST_HEAD(allocated);
> + int err;
> +
> + if (size < mm->chunk_size)
> + return -EINVAL;
> +
> + if (min_page_size < mm->chunk_size)
> + return -EINVAL;
> +
> + if (!is_power_of_2(min_page_size))
> + return -EINVAL;
> +
> + if (!IS_ALIGNED(start | end | size, mm->chunk_size))
> + return -EINVAL;
> +
> + if (check_range_overflow(start, end, size, mm->size))
> + return -EINVAL;
> +
> + pages = size >> ilog2(mm->chunk_size);
> + order = fls(pages) - 1;
> + min_order = ilog2(min_page_size) - ilog2(mm->chunk_size);
> +
> + do {
> + order = min(order, (unsigned int)fls(pages) - 1);
> + BUG_ON(order > mm->max_order);
> + BUG_ON(order < min_order);
> +
> + do {
> + if (flags & DRM_BUDDY_RANGE_ALLOCATION)
> + /* Allocate traversing within the range */
> + block = alloc_range(mm, start, end, order);
> + else
> + /* Allocate from freelist */
> + block = alloc_from_freelist(mm, order, flags);
> +
> + if (!IS_ERR(block))
> + break;
> +
> + if (order-- == min_order) {
> + err = -ENOSPC;
> + goto err_free;
> + }
> + } while (1);
> +
> + mark_allocated(block);
> + mm->avail -= drm_buddy_block_size(mm, block);
> + kmemleak_update_trace(block);
> + list_add_tail(&block->link, &allocated);
> +
> + pages -= BIT(order);
> +
> + if (!pages)
> + break;
> + } while (1);
> +
> + list_splice_tail(&allocated, blocks);
> + return 0;
>
> err_free:
> drm_buddy_free_list(mm, &allocated);
> return err;
> }
> -EXPORT_SYMBOL(drm_buddy_alloc_range);
> +EXPORT_SYMBOL(drm_buddy_alloc);
>
> /**
> * drm_buddy_block_print - print block information
> diff --git a/drivers/gpu/drm/i915/i915_ttm_buddy_manager.c b/drivers/gpu/drm/i915/i915_ttm_buddy_manager.c
> index c4b70cb8c248..9e3d130c3f42 100644
> --- a/drivers/gpu/drm/i915/i915_ttm_buddy_manager.c
> +++ b/drivers/gpu/drm/i915/i915_ttm_buddy_manager.c
> @@ -36,13 +36,14 @@ static int i915_ttm_buddy_man_alloc(struct ttm_resource_manager *man,
> struct i915_ttm_buddy_manager *bman = to_buddy_manager(man);
> struct i915_ttm_buddy_resource *bman_res;
> struct drm_buddy_mm *mm = &bman->mm;
> - unsigned long n_pages;
> - unsigned int min_order;
> + unsigned long n_pages, lpfn;
> u64 min_page_size;
> u64 size;
> int err;
>
> - GEM_BUG_ON(place->fpfn || place->lpfn);
> + lpfn = place->lpfn;
> + if (!lpfn)
> + lpfn = man->size;
>
> bman_res = kzalloc(sizeof(*bman_res), GFP_KERNEL);
> if (!bman_res)
> @@ -52,6 +53,9 @@ static int i915_ttm_buddy_man_alloc(struct ttm_resource_manager *man,
> INIT_LIST_HEAD(&bman_res->blocks);
> bman_res->mm = mm;
>
> + if (place->fpfn || lpfn != man->size)
> + bman_res->flags |= DRM_BUDDY_RANGE_ALLOCATION;
> +
> GEM_BUG_ON(!bman_res->base.num_pages);
> size = bman_res->base.num_pages << PAGE_SHIFT;
>
> @@ -60,10 +64,16 @@ static int i915_ttm_buddy_man_alloc(struct ttm_resource_manager *man,
> min_page_size = bo->page_alignment << PAGE_SHIFT;
>
> GEM_BUG_ON(min_page_size < mm->chunk_size);
> - min_order = ilog2(min_page_size) - ilog2(mm->chunk_size);
> +
> if (place->flags & TTM_PL_FLAG_CONTIGUOUS) {
> + unsigned long pages;
> +
> size = roundup_pow_of_two(size);
> - min_order = ilog2(size) - ilog2(mm->chunk_size);
> + min_page_size = size;
> +
> + pages = size >> ilog2(mm->chunk_size);
> + if (pages > lpfn)
> + lpfn = pages;
> }
>
> if (size > mm->size) {
> @@ -73,34 +83,16 @@ static int i915_ttm_buddy_man_alloc(struct ttm_resource_manager *man,
>
> n_pages = size >> ilog2(mm->chunk_size);
>
> - do {
> - struct drm_buddy_block *block;
> - unsigned int order;
> -
> - order = fls(n_pages) - 1;
> - GEM_BUG_ON(order > mm->max_order);
> - GEM_BUG_ON(order < min_order);
> -
> - do {
> - mutex_lock(&bman->lock);
> - block = drm_buddy_alloc(mm, order);
> - mutex_unlock(&bman->lock);
> - if (!IS_ERR(block))
> - break;
> -
> - if (order-- == min_order) {
> - err = -ENOSPC;
> - goto err_free_blocks;
> - }
> - } while (1);
> -
> - n_pages -= BIT(order);
> -
> - list_add_tail(&block->link, &bman_res->blocks);
> -
> - if (!n_pages)
> - break;
> - } while (1);
> + mutex_lock(&bman->lock);
> + err = drm_buddy_alloc(mm, (u64)place->fpfn << PAGE_SHIFT,
> + (u64)place->lpfn << PAGE_SHIFT,
> + (u64)n_pages << PAGE_SHIFT,
> + min_page_size,
> + &bman_res->blocks,
> + bman_res->flags);
> + mutex_unlock(&bman->lock);
> + if (unlikely(err))
> + goto err_free_blocks;
>
> *res = &bman_res->base;
> return 0;
> @@ -266,10 +258,19 @@ int i915_ttm_buddy_man_reserve(struct ttm_resource_manager *man,
> {
> struct i915_ttm_buddy_manager *bman = to_buddy_manager(man);
> struct drm_buddy_mm *mm = &bman->mm;
> + unsigned long flags = 0;
> + u64 min_size;
> int ret;
>
> + min_size = size;
> + flags |= DRM_BUDDY_RANGE_ALLOCATION;
> +
> mutex_lock(&bman->lock);
> - ret = drm_buddy_alloc_range(mm, &bman->reserved, start, size);
> + ret = drm_buddy_alloc(mm, start,
> + start + size,
> + size, min_size,
min_page_size = min_size = size. I don't think we want that here. Also
the size here might not be power of two. I guess we need to use
chunk_size here instead?
> + &bman->reserved,
> + flags);
> mutex_unlock(&bman->lock);
>
> return ret;
> diff --git a/drivers/gpu/drm/i915/i915_ttm_buddy_manager.h b/drivers/gpu/drm/i915/i915_ttm_buddy_manager.h
> index fa644b512c2e..5ba490875f66 100644
> --- a/drivers/gpu/drm/i915/i915_ttm_buddy_manager.h
> +++ b/drivers/gpu/drm/i915/i915_ttm_buddy_manager.h
> @@ -20,6 +20,7 @@ struct drm_buddy_mm;
> *
> * @base: struct ttm_resource base class we extend
> * @blocks: the list of struct i915_buddy_block for this resource/allocation
> + * @flags: DRM_BUDDY_*_ALLOCATION flags
> * @mm: the struct i915_buddy_mm for this resource
> *
> * Extends the struct ttm_resource to manage an address space allocation with
> @@ -28,6 +29,7 @@ struct drm_buddy_mm;
> struct i915_ttm_buddy_resource {
> struct ttm_resource base;
> struct list_head blocks;
> + unsigned long flags;
> struct drm_buddy_mm *mm;
> };
>
> diff --git a/include/drm/drm_buddy.h b/include/drm/drm_buddy.h
> index 5ce3fc702f80..2ec3cbc9d5d7 100644
> --- a/include/drm/drm_buddy.h
> +++ b/include/drm/drm_buddy.h
> @@ -13,15 +13,22 @@
>
> #include <drm/drm_print.h>
>
> -#define range_overflows(start, size, max) ({ \
> +#define check_range_overflow(start, end, size, max) ({ \
> typeof(start) start__ = (start); \
> + typeof(end) end__ = (end);\
> typeof(size) size__ = (size); \
> typeof(max) max__ = (max); \
> (void)(&start__ == &size__); \
> (void)(&start__ == &max__); \
> - start__ >= max__ || size__ > max__ - start__; \
> + (void)(&start__ == &end__); \
> + (void)(&end__ == &size__); \
> + (void)(&end__ == &max__); \
> + start__ >= max__ || end__ > max__ || \
> + size__ > end__ - start__; \
> })
>
> +#define DRM_BUDDY_RANGE_ALLOCATION (1 << 0)
> +
> struct drm_buddy_block {
> #define DRM_BUDDY_HEADER_OFFSET GENMASK_ULL(63, 12)
> #define DRM_BUDDY_HEADER_STATE GENMASK_ULL(11, 10)
> @@ -131,12 +138,11 @@ int drm_buddy_init(struct drm_buddy_mm *mm, u64 size, u64 chunk_size);
>
> void drm_buddy_fini(struct drm_buddy_mm *mm);
>
> -struct drm_buddy_block *
> -drm_buddy_alloc(struct drm_buddy_mm *mm, unsigned int order);
> -
> -int drm_buddy_alloc_range(struct drm_buddy_mm *mm,
> - struct list_head *blocks,
> - u64 start, u64 size);
> +int drm_buddy_alloc(struct drm_buddy_mm *mm,
> + u64 start, u64 end, u64 size,
> + u64 min_page_size,
> + struct list_head *blocks,
> + unsigned long flags);
>
> void drm_buddy_free(struct drm_buddy_mm *mm, struct drm_buddy_block *block);
>
>
^ permalink raw reply [flat|nested] 46+ messages in thread
* Re: [PATCH v3 4/6] drm: implement a method to free unused pages
2021-11-16 20:18 ` Arunpravin
(?)
@ 2021-11-17 19:02 ` Matthew Auld
-1 siblings, 0 replies; 46+ messages in thread
From: Matthew Auld @ 2021-11-17 19:02 UTC (permalink / raw)
To: Arunpravin, dri-devel, intel-gfx, amd-gfx
Cc: alexander.deucher, tzimmermann, christian.koenig
On 16/11/2021 20:18, Arunpravin wrote:
> On contiguous allocation, we round up the size
> to the *next* power of 2, implement a function
> to free the unused pages after the newly allocate block.
>
> v2(Matthew Auld):
> - replace function name 'drm_buddy_free_unused_pages' with
> drm_buddy_block_trim
> - replace input argument name 'actual_size' with 'new_size'
> - add more validation checks for input arguments
> - add overlaps check to avoid needless searching and splitting
> - merged the below patch to see the feature in action
> - add free unused pages support to i915 driver
> - lock drm_buddy_block_trim() function as it calls mark_free/mark_split
> are all globally visible
>
> Signed-off-by: Arunpravin <Arunpravin.PaneerSelvam@amd.com>
> ---
> drivers/gpu/drm/drm_buddy.c | 108 ++++++++++++++++++
> drivers/gpu/drm/i915/i915_ttm_buddy_manager.c | 10 ++
> include/drm/drm_buddy.h | 4 +
> 3 files changed, 122 insertions(+)
>
> diff --git a/drivers/gpu/drm/drm_buddy.c b/drivers/gpu/drm/drm_buddy.c
> index 0a9db2981188..943fe2ad27bf 100644
> --- a/drivers/gpu/drm/drm_buddy.c
> +++ b/drivers/gpu/drm/drm_buddy.c
> @@ -284,6 +284,114 @@ static inline bool contains(u64 s1, u64 e1, u64 s2, u64 e2)
> return s1 <= s2 && e1 >= e2;
> }
>
> +/**
> + * drm_buddy_block_trim - free unused pages
> + *
> + * @mm: DRM buddy manager
> + * @new_size: original size requested
> + * @blocks: output list head to add allocated blocks
> + *
> + * For contiguous allocation, we round up the size to the nearest
> + * power of two value, drivers consume *actual* size, so remaining
> + * portions are unused and it can be freed.
> + *
> + * Returns:
> + * 0 on success, error code on failure.
> + */
> +int drm_buddy_block_trim(struct drm_buddy_mm *mm,
> + u64 new_size,
> + struct list_head *blocks)
> +{
> + struct drm_buddy_block *block;
> + struct drm_buddy_block *buddy;
> + u64 new_start;
> + u64 new_end;
> + LIST_HEAD(dfs);
> + u64 count = 0;
> + int err;
> +
> + if (!list_is_singular(blocks))
> + return -EINVAL;
> +
> + block = list_first_entry(blocks,
> + struct drm_buddy_block,
> + link);
> +
> + if (!drm_buddy_block_is_allocated(block))
> + return -EINVAL;
> +
> + if (new_size > drm_buddy_block_size(mm, block))
> + return -EINVAL;
> +
> + if (!new_size && !IS_ALIGNED(new_size, mm->chunk_size))
> + return -EINVAL;
> +
> + if (new_size == drm_buddy_block_size(mm, block))
> + return 0;
> +
> + list_del(&block->link);
> +
> + new_start = drm_buddy_block_offset(block);
> + new_end = new_start + new_size - 1;
> +
> + mark_free(mm, block);
> +
> + list_add(&block->tmp_link, &dfs);
> +
> + do {
> + u64 block_start;
> + u64 block_end;
> +
> + block = list_first_entry_or_null(&dfs,
> + struct drm_buddy_block,
> + tmp_link);
> + if (!block)
> + break;
> +
> + list_del(&block->tmp_link);
> +
> + if (count == new_size)
> + return 0;
> +
> + block_start = drm_buddy_block_offset(block);
> + block_end = block_start + drm_buddy_block_size(mm, block) - 1;
> +
> + if (!overlaps(new_start, new_end, block_start, block_end))
> + continue;
> +
> + if (contains(new_start, new_end, block_start, block_end)) {
> + BUG_ON(!drm_buddy_block_is_free(block));
> +
> + /* Allocate only required blocks */
> + mark_allocated(block);
> + mm->avail -= drm_buddy_block_size(mm, block);
> + list_add_tail(&block->link, blocks);
> + count += drm_buddy_block_size(mm, block);
> + continue;
> + }
> +
> + if (!drm_buddy_block_is_split(block)) {
Should always be true, right? But I guess depends if we want to re-use
this for generic range allocation...
> + err = split_block(mm, block);
> + if (unlikely(err))
> + goto err_undo;
> + }
> +
> + list_add(&block->right->tmp_link, &dfs);
> + list_add(&block->left->tmp_link, &dfs);
> + } while (1);
> +
> + return -ENOSPC;
> +
> +err_undo:
> + buddy = get_buddy(block);
> + if (buddy &&
> + (drm_buddy_block_is_free(block) &&
> + drm_buddy_block_is_free(buddy)))
> + __drm_buddy_free(mm, block);
> + return err;
Looking at the split_block failure path. The user allocated some block,
and then tried to trim it, but this then marks it as free and removes it
from their original list(potentially also freeing it), if we fail here.
Would it be better to leave that decision to the user? If the trim()
fails, worse case we get some internal fragmentation, and the user might
be totally fine with that? I guess we could leave as-is, but for sure
needs some big comment somewhere.
> +}
> +EXPORT_SYMBOL(drm_buddy_block_trim);
> +
> static struct drm_buddy_block *
> alloc_range(struct drm_buddy_mm *mm,
> u64 start, u64 end,
> diff --git a/drivers/gpu/drm/i915/i915_ttm_buddy_manager.c b/drivers/gpu/drm/i915/i915_ttm_buddy_manager.c
> index b6ed5b37cf18..5e1f8c443058 100644
> --- a/drivers/gpu/drm/i915/i915_ttm_buddy_manager.c
> +++ b/drivers/gpu/drm/i915/i915_ttm_buddy_manager.c
> @@ -97,6 +97,16 @@ static int i915_ttm_buddy_man_alloc(struct ttm_resource_manager *man,
> if (unlikely(err))
> goto err_free_blocks;
>
> + if (place->flags & TTM_PL_FLAG_CONTIGUOUS) {
> + mutex_lock(&bman->lock);
> + err = drm_buddy_block_trim(mm,
> + (u64)n_pages << PAGE_SHIFT,
> + &bman_res->blocks);
> + mutex_unlock(&bman->lock);
> + if (unlikely(err))
> + goto err_free_blocks;
Yeah, so maybe we could in theory treat this as best effort? But I guess
unlikely to ever hit this anyway, so meh.
> + }
> +
> *res = &bman_res->base;
> return 0;
>
> diff --git a/include/drm/drm_buddy.h b/include/drm/drm_buddy.h
> index cbe5e648440a..36e8f548acf7 100644
> --- a/include/drm/drm_buddy.h
> +++ b/include/drm/drm_buddy.h
> @@ -145,6 +145,10 @@ int drm_buddy_alloc(struct drm_buddy_mm *mm,
> struct list_head *blocks,
> unsigned long flags);
>
> +int drm_buddy_block_trim(struct drm_buddy_mm *mm,
> + u64 new_size,
> + struct list_head *blocks);
> +
> void drm_buddy_free(struct drm_buddy_mm *mm, struct drm_buddy_block *block);
>
> void drm_buddy_free_list(struct drm_buddy_mm *mm, struct list_head *objects);
>
^ permalink raw reply [flat|nested] 46+ messages in thread
* Re: [Intel-gfx] [PATCH v3 4/6] drm: implement a method to free unused pages
@ 2021-11-17 19:02 ` Matthew Auld
0 siblings, 0 replies; 46+ messages in thread
From: Matthew Auld @ 2021-11-17 19:02 UTC (permalink / raw)
To: Arunpravin, dri-devel, intel-gfx, amd-gfx
Cc: alexander.deucher, tzimmermann, christian.koenig
On 16/11/2021 20:18, Arunpravin wrote:
> On contiguous allocation, we round up the size
> to the *next* power of 2, implement a function
> to free the unused pages after the newly allocate block.
>
> v2(Matthew Auld):
> - replace function name 'drm_buddy_free_unused_pages' with
> drm_buddy_block_trim
> - replace input argument name 'actual_size' with 'new_size'
> - add more validation checks for input arguments
> - add overlaps check to avoid needless searching and splitting
> - merged the below patch to see the feature in action
> - add free unused pages support to i915 driver
> - lock drm_buddy_block_trim() function as it calls mark_free/mark_split
> are all globally visible
>
> Signed-off-by: Arunpravin <Arunpravin.PaneerSelvam@amd.com>
> ---
> drivers/gpu/drm/drm_buddy.c | 108 ++++++++++++++++++
> drivers/gpu/drm/i915/i915_ttm_buddy_manager.c | 10 ++
> include/drm/drm_buddy.h | 4 +
> 3 files changed, 122 insertions(+)
>
> diff --git a/drivers/gpu/drm/drm_buddy.c b/drivers/gpu/drm/drm_buddy.c
> index 0a9db2981188..943fe2ad27bf 100644
> --- a/drivers/gpu/drm/drm_buddy.c
> +++ b/drivers/gpu/drm/drm_buddy.c
> @@ -284,6 +284,114 @@ static inline bool contains(u64 s1, u64 e1, u64 s2, u64 e2)
> return s1 <= s2 && e1 >= e2;
> }
>
> +/**
> + * drm_buddy_block_trim - free unused pages
> + *
> + * @mm: DRM buddy manager
> + * @new_size: original size requested
> + * @blocks: output list head to add allocated blocks
> + *
> + * For contiguous allocation, we round up the size to the nearest
> + * power of two value, drivers consume *actual* size, so remaining
> + * portions are unused and it can be freed.
> + *
> + * Returns:
> + * 0 on success, error code on failure.
> + */
> +int drm_buddy_block_trim(struct drm_buddy_mm *mm,
> + u64 new_size,
> + struct list_head *blocks)
> +{
> + struct drm_buddy_block *block;
> + struct drm_buddy_block *buddy;
> + u64 new_start;
> + u64 new_end;
> + LIST_HEAD(dfs);
> + u64 count = 0;
> + int err;
> +
> + if (!list_is_singular(blocks))
> + return -EINVAL;
> +
> + block = list_first_entry(blocks,
> + struct drm_buddy_block,
> + link);
> +
> + if (!drm_buddy_block_is_allocated(block))
> + return -EINVAL;
> +
> + if (new_size > drm_buddy_block_size(mm, block))
> + return -EINVAL;
> +
> + if (!new_size && !IS_ALIGNED(new_size, mm->chunk_size))
> + return -EINVAL;
> +
> + if (new_size == drm_buddy_block_size(mm, block))
> + return 0;
> +
> + list_del(&block->link);
> +
> + new_start = drm_buddy_block_offset(block);
> + new_end = new_start + new_size - 1;
> +
> + mark_free(mm, block);
> +
> + list_add(&block->tmp_link, &dfs);
> +
> + do {
> + u64 block_start;
> + u64 block_end;
> +
> + block = list_first_entry_or_null(&dfs,
> + struct drm_buddy_block,
> + tmp_link);
> + if (!block)
> + break;
> +
> + list_del(&block->tmp_link);
> +
> + if (count == new_size)
> + return 0;
> +
> + block_start = drm_buddy_block_offset(block);
> + block_end = block_start + drm_buddy_block_size(mm, block) - 1;
> +
> + if (!overlaps(new_start, new_end, block_start, block_end))
> + continue;
> +
> + if (contains(new_start, new_end, block_start, block_end)) {
> + BUG_ON(!drm_buddy_block_is_free(block));
> +
> + /* Allocate only required blocks */
> + mark_allocated(block);
> + mm->avail -= drm_buddy_block_size(mm, block);
> + list_add_tail(&block->link, blocks);
> + count += drm_buddy_block_size(mm, block);
> + continue;
> + }
> +
> + if (!drm_buddy_block_is_split(block)) {
Should always be true, right? But I guess depends if we want to re-use
this for generic range allocation...
> + err = split_block(mm, block);
> + if (unlikely(err))
> + goto err_undo;
> + }
> +
> + list_add(&block->right->tmp_link, &dfs);
> + list_add(&block->left->tmp_link, &dfs);
> + } while (1);
> +
> + return -ENOSPC;
> +
> +err_undo:
> + buddy = get_buddy(block);
> + if (buddy &&
> + (drm_buddy_block_is_free(block) &&
> + drm_buddy_block_is_free(buddy)))
> + __drm_buddy_free(mm, block);
> + return err;
Looking at the split_block failure path. The user allocated some block,
and then tried to trim it, but this then marks it as free and removes it
from their original list(potentially also freeing it), if we fail here.
Would it be better to leave that decision to the user? If the trim()
fails, worse case we get some internal fragmentation, and the user might
be totally fine with that? I guess we could leave as-is, but for sure
needs some big comment somewhere.
> +}
> +EXPORT_SYMBOL(drm_buddy_block_trim);
> +
> static struct drm_buddy_block *
> alloc_range(struct drm_buddy_mm *mm,
> u64 start, u64 end,
> diff --git a/drivers/gpu/drm/i915/i915_ttm_buddy_manager.c b/drivers/gpu/drm/i915/i915_ttm_buddy_manager.c
> index b6ed5b37cf18..5e1f8c443058 100644
> --- a/drivers/gpu/drm/i915/i915_ttm_buddy_manager.c
> +++ b/drivers/gpu/drm/i915/i915_ttm_buddy_manager.c
> @@ -97,6 +97,16 @@ static int i915_ttm_buddy_man_alloc(struct ttm_resource_manager *man,
> if (unlikely(err))
> goto err_free_blocks;
>
> + if (place->flags & TTM_PL_FLAG_CONTIGUOUS) {
> + mutex_lock(&bman->lock);
> + err = drm_buddy_block_trim(mm,
> + (u64)n_pages << PAGE_SHIFT,
> + &bman_res->blocks);
> + mutex_unlock(&bman->lock);
> + if (unlikely(err))
> + goto err_free_blocks;
Yeah, so maybe we could in theory treat this as best effort? But I guess
unlikely to ever hit this anyway, so meh.
> + }
> +
> *res = &bman_res->base;
> return 0;
>
> diff --git a/include/drm/drm_buddy.h b/include/drm/drm_buddy.h
> index cbe5e648440a..36e8f548acf7 100644
> --- a/include/drm/drm_buddy.h
> +++ b/include/drm/drm_buddy.h
> @@ -145,6 +145,10 @@ int drm_buddy_alloc(struct drm_buddy_mm *mm,
> struct list_head *blocks,
> unsigned long flags);
>
> +int drm_buddy_block_trim(struct drm_buddy_mm *mm,
> + u64 new_size,
> + struct list_head *blocks);
> +
> void drm_buddy_free(struct drm_buddy_mm *mm, struct drm_buddy_block *block);
>
> void drm_buddy_free_list(struct drm_buddy_mm *mm, struct list_head *objects);
>
^ permalink raw reply [flat|nested] 46+ messages in thread
* Re: [PATCH v3 4/6] drm: implement a method to free unused pages
@ 2021-11-17 19:02 ` Matthew Auld
0 siblings, 0 replies; 46+ messages in thread
From: Matthew Auld @ 2021-11-17 19:02 UTC (permalink / raw)
To: Arunpravin, dri-devel, intel-gfx, amd-gfx
Cc: alexander.deucher, tzimmermann, jani.nikula, christian.koenig, daniel
On 16/11/2021 20:18, Arunpravin wrote:
> On contiguous allocation, we round up the size
> to the *next* power of 2, implement a function
> to free the unused pages after the newly allocate block.
>
> v2(Matthew Auld):
> - replace function name 'drm_buddy_free_unused_pages' with
> drm_buddy_block_trim
> - replace input argument name 'actual_size' with 'new_size'
> - add more validation checks for input arguments
> - add overlaps check to avoid needless searching and splitting
> - merged the below patch to see the feature in action
> - add free unused pages support to i915 driver
> - lock drm_buddy_block_trim() function as it calls mark_free/mark_split
> are all globally visible
>
> Signed-off-by: Arunpravin <Arunpravin.PaneerSelvam@amd.com>
> ---
> drivers/gpu/drm/drm_buddy.c | 108 ++++++++++++++++++
> drivers/gpu/drm/i915/i915_ttm_buddy_manager.c | 10 ++
> include/drm/drm_buddy.h | 4 +
> 3 files changed, 122 insertions(+)
>
> diff --git a/drivers/gpu/drm/drm_buddy.c b/drivers/gpu/drm/drm_buddy.c
> index 0a9db2981188..943fe2ad27bf 100644
> --- a/drivers/gpu/drm/drm_buddy.c
> +++ b/drivers/gpu/drm/drm_buddy.c
> @@ -284,6 +284,114 @@ static inline bool contains(u64 s1, u64 e1, u64 s2, u64 e2)
> return s1 <= s2 && e1 >= e2;
> }
>
> +/**
> + * drm_buddy_block_trim - free unused pages
> + *
> + * @mm: DRM buddy manager
> + * @new_size: original size requested
> + * @blocks: output list head to add allocated blocks
> + *
> + * For contiguous allocation, we round up the size to the nearest
> + * power of two value, drivers consume *actual* size, so remaining
> + * portions are unused and it can be freed.
> + *
> + * Returns:
> + * 0 on success, error code on failure.
> + */
> +int drm_buddy_block_trim(struct drm_buddy_mm *mm,
> + u64 new_size,
> + struct list_head *blocks)
> +{
> + struct drm_buddy_block *block;
> + struct drm_buddy_block *buddy;
> + u64 new_start;
> + u64 new_end;
> + LIST_HEAD(dfs);
> + u64 count = 0;
> + int err;
> +
> + if (!list_is_singular(blocks))
> + return -EINVAL;
> +
> + block = list_first_entry(blocks,
> + struct drm_buddy_block,
> + link);
> +
> + if (!drm_buddy_block_is_allocated(block))
> + return -EINVAL;
> +
> + if (new_size > drm_buddy_block_size(mm, block))
> + return -EINVAL;
> +
> + if (!new_size && !IS_ALIGNED(new_size, mm->chunk_size))
> + return -EINVAL;
> +
> + if (new_size == drm_buddy_block_size(mm, block))
> + return 0;
> +
> + list_del(&block->link);
> +
> + new_start = drm_buddy_block_offset(block);
> + new_end = new_start + new_size - 1;
> +
> + mark_free(mm, block);
> +
> + list_add(&block->tmp_link, &dfs);
> +
> + do {
> + u64 block_start;
> + u64 block_end;
> +
> + block = list_first_entry_or_null(&dfs,
> + struct drm_buddy_block,
> + tmp_link);
> + if (!block)
> + break;
> +
> + list_del(&block->tmp_link);
> +
> + if (count == new_size)
> + return 0;
> +
> + block_start = drm_buddy_block_offset(block);
> + block_end = block_start + drm_buddy_block_size(mm, block) - 1;
> +
> + if (!overlaps(new_start, new_end, block_start, block_end))
> + continue;
> +
> + if (contains(new_start, new_end, block_start, block_end)) {
> + BUG_ON(!drm_buddy_block_is_free(block));
> +
> + /* Allocate only required blocks */
> + mark_allocated(block);
> + mm->avail -= drm_buddy_block_size(mm, block);
> + list_add_tail(&block->link, blocks);
> + count += drm_buddy_block_size(mm, block);
> + continue;
> + }
> +
> + if (!drm_buddy_block_is_split(block)) {
Should always be true, right? But I guess depends if we want to re-use
this for generic range allocation...
> + err = split_block(mm, block);
> + if (unlikely(err))
> + goto err_undo;
> + }
> +
> + list_add(&block->right->tmp_link, &dfs);
> + list_add(&block->left->tmp_link, &dfs);
> + } while (1);
> +
> + return -ENOSPC;
> +
> +err_undo:
> + buddy = get_buddy(block);
> + if (buddy &&
> + (drm_buddy_block_is_free(block) &&
> + drm_buddy_block_is_free(buddy)))
> + __drm_buddy_free(mm, block);
> + return err;
Looking at the split_block failure path. The user allocated some block,
and then tried to trim it, but this then marks it as free and removes it
from their original list(potentially also freeing it), if we fail here.
Would it be better to leave that decision to the user? If the trim()
fails, worse case we get some internal fragmentation, and the user might
be totally fine with that? I guess we could leave as-is, but for sure
needs some big comment somewhere.
> +}
> +EXPORT_SYMBOL(drm_buddy_block_trim);
> +
> static struct drm_buddy_block *
> alloc_range(struct drm_buddy_mm *mm,
> u64 start, u64 end,
> diff --git a/drivers/gpu/drm/i915/i915_ttm_buddy_manager.c b/drivers/gpu/drm/i915/i915_ttm_buddy_manager.c
> index b6ed5b37cf18..5e1f8c443058 100644
> --- a/drivers/gpu/drm/i915/i915_ttm_buddy_manager.c
> +++ b/drivers/gpu/drm/i915/i915_ttm_buddy_manager.c
> @@ -97,6 +97,16 @@ static int i915_ttm_buddy_man_alloc(struct ttm_resource_manager *man,
> if (unlikely(err))
> goto err_free_blocks;
>
> + if (place->flags & TTM_PL_FLAG_CONTIGUOUS) {
> + mutex_lock(&bman->lock);
> + err = drm_buddy_block_trim(mm,
> + (u64)n_pages << PAGE_SHIFT,
> + &bman_res->blocks);
> + mutex_unlock(&bman->lock);
> + if (unlikely(err))
> + goto err_free_blocks;
Yeah, so maybe we could in theory treat this as best effort? But I guess
unlikely to ever hit this anyway, so meh.
> + }
> +
> *res = &bman_res->base;
> return 0;
>
> diff --git a/include/drm/drm_buddy.h b/include/drm/drm_buddy.h
> index cbe5e648440a..36e8f548acf7 100644
> --- a/include/drm/drm_buddy.h
> +++ b/include/drm/drm_buddy.h
> @@ -145,6 +145,10 @@ int drm_buddy_alloc(struct drm_buddy_mm *mm,
> struct list_head *blocks,
> unsigned long flags);
>
> +int drm_buddy_block_trim(struct drm_buddy_mm *mm,
> + u64 new_size,
> + struct list_head *blocks);
> +
> void drm_buddy_free(struct drm_buddy_mm *mm, struct drm_buddy_block *block);
>
> void drm_buddy_free_list(struct drm_buddy_mm *mm, struct list_head *objects);
>
^ permalink raw reply [flat|nested] 46+ messages in thread
* Re: [PATCH v3 1/6] drm: move the buddy allocator from i915 into common drm
2021-11-16 20:18 ` Arunpravin
(?)
@ 2021-11-17 20:45 ` kernel test robot
-1 siblings, 0 replies; 46+ messages in thread
From: kernel test robot @ 2021-11-17 20:45 UTC (permalink / raw)
To: Arunpravin, dri-devel, intel-gfx, amd-gfx
Cc: kbuild-all, Arunpravin, matthew.auld, tzimmermann,
alexander.deucher, christian.koenig
[-- Attachment #1: Type: text/plain, Size: 3050 bytes --]
Hi Arunpravin,
Thank you for the patch! Yet something to improve:
[auto build test ERROR on drm/drm-next]
[also build test ERROR on drm-intel/for-linux-next v5.16-rc1]
[cannot apply to drm-tip/drm-tip next-20211117]
[If your patch is applied to the wrong git tree, kindly drop us a note.
And when submitting patch, we suggest to use '--base' as documented in
https://git-scm.com/docs/git-format-patch]
url: https://github.com/0day-ci/linux/commits/Arunpravin/drm-move-the-buddy-allocator-from-i915-into-common-drm/20211117-041920
base: git://anongit.freedesktop.org/drm/drm drm-next
config: i386-allyesconfig (attached as .config)
compiler: gcc-9 (Debian 9.3.0-22) 9.3.0
reproduce (this is a W=1 build):
# https://github.com/0day-ci/linux/commit/47fb1aeae75661971f4526efddf4ae5b5738977f
git remote add linux-review https://github.com/0day-ci/linux
git fetch --no-tags linux-review Arunpravin/drm-move-the-buddy-allocator-from-i915-into-common-drm/20211117-041920
git checkout 47fb1aeae75661971f4526efddf4ae5b5738977f
# save the attached .config to linux build tree
mkdir build_dir
make W=1 O=build_dir ARCH=i386 SHELL=/bin/bash
If you fix the issue, kindly add following tag as appropriate
Reported-by: kernel test robot <lkp@intel.com>
All errors (new ones prefixed by >>):
In file included from drivers/gpu/drm/i915/intel_memory_region.c:242:
>> drivers/gpu/drm/i915/selftests/intel_memory_region.c:23:10: fatal error: i915_buddy.h: No such file or directory
23 | #include "i915_buddy.h"
| ^~~~~~~~~~~~~~
compilation terminated.
vim +23 drivers/gpu/drm/i915/selftests/intel_memory_region.c
232a6ebae419193 Matthew Auld 2019-10-08 14
340be48f2c5a3c0 Matthew Auld 2019-10-25 15 #include "gem/i915_gem_context.h"
b908be543e44414 Matthew Auld 2019-10-25 16 #include "gem/i915_gem_lmem.h"
232a6ebae419193 Matthew Auld 2019-10-08 17 #include "gem/i915_gem_region.h"
340be48f2c5a3c0 Matthew Auld 2019-10-25 18 #include "gem/selftests/igt_gem_utils.h"
232a6ebae419193 Matthew Auld 2019-10-08 19 #include "gem/selftests/mock_context.h"
99919be74aa3753 Thomas Hellström 2021-06-17 20 #include "gt/intel_engine_pm.h"
6804da20bb549e3 Chris Wilson 2019-10-27 21 #include "gt/intel_engine_user.h"
b908be543e44414 Matthew Auld 2019-10-25 22 #include "gt/intel_gt.h"
d53ec322dc7de32 Matthew Auld 2021-06-16 @23 #include "i915_buddy.h"
99919be74aa3753 Thomas Hellström 2021-06-17 24 #include "gt/intel_migrate.h"
ba12993c5228015 Matthew Auld 2020-01-29 25 #include "i915_memcpy.h"
d53ec322dc7de32 Matthew Auld 2021-06-16 26 #include "i915_ttm_buddy_manager.h"
01377a0d7e6648b Abdiel Janulgue 2019-10-25 27 #include "selftests/igt_flush_test.h"
2f0b97ca0211863 Matthew Auld 2019-10-08 28 #include "selftests/i915_random.h"
232a6ebae419193 Matthew Auld 2019-10-08 29
---
0-DAY CI Kernel Test Service, Intel Corporation
https://lists.01.org/hyperkitty/list/kbuild-all@lists.01.org
[-- Attachment #2: .config.gz --]
[-- Type: application/gzip, Size: 66043 bytes --]
^ permalink raw reply [flat|nested] 46+ messages in thread
* Re: [Intel-gfx] [PATCH v3 1/6] drm: move the buddy allocator from i915 into common drm
@ 2021-11-17 20:45 ` kernel test robot
0 siblings, 0 replies; 46+ messages in thread
From: kernel test robot @ 2021-11-17 20:45 UTC (permalink / raw)
To: Arunpravin, dri-devel, intel-gfx, amd-gfx
Cc: kbuild-all, Arunpravin, matthew.auld, tzimmermann,
alexander.deucher, christian.koenig
[-- Attachment #1: Type: text/plain, Size: 3050 bytes --]
Hi Arunpravin,
Thank you for the patch! Yet something to improve:
[auto build test ERROR on drm/drm-next]
[also build test ERROR on drm-intel/for-linux-next v5.16-rc1]
[cannot apply to drm-tip/drm-tip next-20211117]
[If your patch is applied to the wrong git tree, kindly drop us a note.
And when submitting patch, we suggest to use '--base' as documented in
https://git-scm.com/docs/git-format-patch]
url: https://github.com/0day-ci/linux/commits/Arunpravin/drm-move-the-buddy-allocator-from-i915-into-common-drm/20211117-041920
base: git://anongit.freedesktop.org/drm/drm drm-next
config: i386-allyesconfig (attached as .config)
compiler: gcc-9 (Debian 9.3.0-22) 9.3.0
reproduce (this is a W=1 build):
# https://github.com/0day-ci/linux/commit/47fb1aeae75661971f4526efddf4ae5b5738977f
git remote add linux-review https://github.com/0day-ci/linux
git fetch --no-tags linux-review Arunpravin/drm-move-the-buddy-allocator-from-i915-into-common-drm/20211117-041920
git checkout 47fb1aeae75661971f4526efddf4ae5b5738977f
# save the attached .config to linux build tree
mkdir build_dir
make W=1 O=build_dir ARCH=i386 SHELL=/bin/bash
If you fix the issue, kindly add following tag as appropriate
Reported-by: kernel test robot <lkp@intel.com>
All errors (new ones prefixed by >>):
In file included from drivers/gpu/drm/i915/intel_memory_region.c:242:
>> drivers/gpu/drm/i915/selftests/intel_memory_region.c:23:10: fatal error: i915_buddy.h: No such file or directory
23 | #include "i915_buddy.h"
| ^~~~~~~~~~~~~~
compilation terminated.
vim +23 drivers/gpu/drm/i915/selftests/intel_memory_region.c
232a6ebae419193 Matthew Auld 2019-10-08 14
340be48f2c5a3c0 Matthew Auld 2019-10-25 15 #include "gem/i915_gem_context.h"
b908be543e44414 Matthew Auld 2019-10-25 16 #include "gem/i915_gem_lmem.h"
232a6ebae419193 Matthew Auld 2019-10-08 17 #include "gem/i915_gem_region.h"
340be48f2c5a3c0 Matthew Auld 2019-10-25 18 #include "gem/selftests/igt_gem_utils.h"
232a6ebae419193 Matthew Auld 2019-10-08 19 #include "gem/selftests/mock_context.h"
99919be74aa3753 Thomas Hellström 2021-06-17 20 #include "gt/intel_engine_pm.h"
6804da20bb549e3 Chris Wilson 2019-10-27 21 #include "gt/intel_engine_user.h"
b908be543e44414 Matthew Auld 2019-10-25 22 #include "gt/intel_gt.h"
d53ec322dc7de32 Matthew Auld 2021-06-16 @23 #include "i915_buddy.h"
99919be74aa3753 Thomas Hellström 2021-06-17 24 #include "gt/intel_migrate.h"
ba12993c5228015 Matthew Auld 2020-01-29 25 #include "i915_memcpy.h"
d53ec322dc7de32 Matthew Auld 2021-06-16 26 #include "i915_ttm_buddy_manager.h"
01377a0d7e6648b Abdiel Janulgue 2019-10-25 27 #include "selftests/igt_flush_test.h"
2f0b97ca0211863 Matthew Auld 2019-10-08 28 #include "selftests/i915_random.h"
232a6ebae419193 Matthew Auld 2019-10-08 29
---
0-DAY CI Kernel Test Service, Intel Corporation
https://lists.01.org/hyperkitty/list/kbuild-all@lists.01.org
[-- Attachment #2: .config.gz --]
[-- Type: application/gzip, Size: 66043 bytes --]
^ permalink raw reply [flat|nested] 46+ messages in thread
* Re: [PATCH v3 1/6] drm: move the buddy allocator from i915 into common drm
@ 2021-11-17 20:45 ` kernel test robot
0 siblings, 0 replies; 46+ messages in thread
From: kernel test robot @ 2021-11-17 20:45 UTC (permalink / raw)
To: kbuild-all
[-- Attachment #1: Type: text/plain, Size: 3112 bytes --]
Hi Arunpravin,
Thank you for the patch! Yet something to improve:
[auto build test ERROR on drm/drm-next]
[also build test ERROR on drm-intel/for-linux-next v5.16-rc1]
[cannot apply to drm-tip/drm-tip next-20211117]
[If your patch is applied to the wrong git tree, kindly drop us a note.
And when submitting patch, we suggest to use '--base' as documented in
https://git-scm.com/docs/git-format-patch]
url: https://github.com/0day-ci/linux/commits/Arunpravin/drm-move-the-buddy-allocator-from-i915-into-common-drm/20211117-041920
base: git://anongit.freedesktop.org/drm/drm drm-next
config: i386-allyesconfig (attached as .config)
compiler: gcc-9 (Debian 9.3.0-22) 9.3.0
reproduce (this is a W=1 build):
# https://github.com/0day-ci/linux/commit/47fb1aeae75661971f4526efddf4ae5b5738977f
git remote add linux-review https://github.com/0day-ci/linux
git fetch --no-tags linux-review Arunpravin/drm-move-the-buddy-allocator-from-i915-into-common-drm/20211117-041920
git checkout 47fb1aeae75661971f4526efddf4ae5b5738977f
# save the attached .config to linux build tree
mkdir build_dir
make W=1 O=build_dir ARCH=i386 SHELL=/bin/bash
If you fix the issue, kindly add following tag as appropriate
Reported-by: kernel test robot <lkp@intel.com>
All errors (new ones prefixed by >>):
In file included from drivers/gpu/drm/i915/intel_memory_region.c:242:
>> drivers/gpu/drm/i915/selftests/intel_memory_region.c:23:10: fatal error: i915_buddy.h: No such file or directory
23 | #include "i915_buddy.h"
| ^~~~~~~~~~~~~~
compilation terminated.
vim +23 drivers/gpu/drm/i915/selftests/intel_memory_region.c
232a6ebae419193 Matthew Auld 2019-10-08 14
340be48f2c5a3c0 Matthew Auld 2019-10-25 15 #include "gem/i915_gem_context.h"
b908be543e44414 Matthew Auld 2019-10-25 16 #include "gem/i915_gem_lmem.h"
232a6ebae419193 Matthew Auld 2019-10-08 17 #include "gem/i915_gem_region.h"
340be48f2c5a3c0 Matthew Auld 2019-10-25 18 #include "gem/selftests/igt_gem_utils.h"
232a6ebae419193 Matthew Auld 2019-10-08 19 #include "gem/selftests/mock_context.h"
99919be74aa3753 Thomas Hellström 2021-06-17 20 #include "gt/intel_engine_pm.h"
6804da20bb549e3 Chris Wilson 2019-10-27 21 #include "gt/intel_engine_user.h"
b908be543e44414 Matthew Auld 2019-10-25 22 #include "gt/intel_gt.h"
d53ec322dc7de32 Matthew Auld 2021-06-16 @23 #include "i915_buddy.h"
99919be74aa3753 Thomas Hellström 2021-06-17 24 #include "gt/intel_migrate.h"
ba12993c5228015 Matthew Auld 2020-01-29 25 #include "i915_memcpy.h"
d53ec322dc7de32 Matthew Auld 2021-06-16 26 #include "i915_ttm_buddy_manager.h"
01377a0d7e6648b Abdiel Janulgue 2019-10-25 27 #include "selftests/igt_flush_test.h"
2f0b97ca0211863 Matthew Auld 2019-10-08 28 #include "selftests/i915_random.h"
232a6ebae419193 Matthew Auld 2019-10-08 29
---
0-DAY CI Kernel Test Service, Intel Corporation
https://lists.01.org/hyperkitty/list/kbuild-all(a)lists.01.org
[-- Attachment #2: config.gz --]
[-- Type: application/gzip, Size: 66043 bytes --]
^ permalink raw reply [flat|nested] 46+ messages in thread
* Re: [PATCH v3 2/6] drm: improve drm_buddy_alloc function
2021-11-17 18:39 ` [Intel-gfx] " Matthew Auld
(?)
@ 2021-11-23 22:39 ` Arunpravin
-1 siblings, 0 replies; 46+ messages in thread
From: Arunpravin @ 2021-11-23 22:39 UTC (permalink / raw)
To: Matthew Auld, dri-devel, intel-gfx, amd-gfx
Cc: alexander.deucher, tzimmermann, christian.koenig
On 18/11/21 12:09 am, Matthew Auld wrote:
> On 16/11/2021 20:18, Arunpravin wrote:
>> - Make drm_buddy_alloc a single function to handle
>> range allocation and non-range allocation demands
>>
>> - Implemented a new function alloc_range() which allocates
>> the requested power-of-two block comply with range limitations
>>
>> - Moved order computation and memory alignment logic from
>> i915 driver to drm buddy
>>
>> v2:
>> merged below changes to keep the build unbroken
>> - drm_buddy_alloc_range() becomes obsolete and may be removed
>> - enable ttm range allocation (fpfn / lpfn) support in i915 driver
>> - apply enhanced drm_buddy_alloc() function to i915 driver
>>
>> v3(Matthew Auld):
>> - Fix alignment issues and remove unnecessary list_empty check
>> - add more validation checks for input arguments
>> - make alloc_range() block allocations as bottom-up
>> - optimize order computation logic
>> - replace uint64_t with u64, which is preferred in the kernel
>>
>> Signed-off-by: Arunpravin <Arunpravin.PaneerSelvam@amd.com>
>> ---
>> drivers/gpu/drm/drm_buddy.c | 259 ++++++++++--------
>> drivers/gpu/drm/i915/i915_ttm_buddy_manager.c | 69 ++---
>> drivers/gpu/drm/i915/i915_ttm_buddy_manager.h | 2 +
>> include/drm/drm_buddy.h | 22 +-
>> 4 files changed, 203 insertions(+), 149 deletions(-)
>>
>> diff --git a/drivers/gpu/drm/drm_buddy.c b/drivers/gpu/drm/drm_buddy.c
>> index 39eb1d224bec..c9b18a29f8d1 100644
>> --- a/drivers/gpu/drm/drm_buddy.c
>> +++ b/drivers/gpu/drm/drm_buddy.c
>> @@ -274,63 +274,6 @@ void drm_buddy_free_list(struct drm_buddy_mm *mm, struct list_head *objects)
>> }
>> EXPORT_SYMBOL(drm_buddy_free_list);
>>
>> -/**
>> - * drm_buddy_alloc - allocate power-of-two blocks
>> - *
>> - * @mm: DRM buddy manager to allocate from
>> - * @order: size of the allocation
>> - *
>> - * The order value here translates to:
>> - *
>> - * 0 = 2^0 * mm->chunk_size
>> - * 1 = 2^1 * mm->chunk_size
>> - * 2 = 2^2 * mm->chunk_size
>> - *
>> - * Returns:
>> - * allocated ptr to the &drm_buddy_block on success
>> - */
>> -struct drm_buddy_block *
>> -drm_buddy_alloc(struct drm_buddy_mm *mm, unsigned int order)
>> -{
>> - struct drm_buddy_block *block = NULL;
>> - unsigned int i;
>> - int err;
>> -
>> - for (i = order; i <= mm->max_order; ++i) {
>> - block = list_first_entry_or_null(&mm->free_list[i],
>> - struct drm_buddy_block,
>> - link);
>> - if (block)
>> - break;
>> - }
>> -
>> - if (!block)
>> - return ERR_PTR(-ENOSPC);
>> -
>> - BUG_ON(!drm_buddy_block_is_free(block));
>> -
>> - while (i != order) {
>> - err = split_block(mm, block);
>> - if (unlikely(err))
>> - goto out_free;
>> -
>> - /* Go low */
>> - block = block->left;
>> - i--;
>> - }
>> -
>> - mark_allocated(block);
>> - mm->avail -= drm_buddy_block_size(mm, block);
>> - kmemleak_update_trace(block);
>> - return block;
>> -
>> -out_free:
>> - if (i != order)
>> - __drm_buddy_free(mm, block);
>> - return ERR_PTR(err);
>> -}
>> -EXPORT_SYMBOL(drm_buddy_alloc);
>> -
>> static inline bool overlaps(u64 s1, u64 e1, u64 s2, u64 e2)
>> {
>> return s1 <= e2 && e1 >= s2;
>> @@ -341,52 +284,22 @@ static inline bool contains(u64 s1, u64 e1, u64 s2, u64 e2)
>> return s1 <= s2 && e1 >= e2;
>> }
>>
>> -/**
>> - * drm_buddy_alloc_range - allocate range
>> - *
>> - * @mm: DRM buddy manager to allocate from
>> - * @blocks: output list head to add allocated blocks
>> - * @start: start of the allowed range for this block
>> - * @size: size of the allocation
>> - *
>> - * Intended for pre-allocating portions of the address space, for example to
>> - * reserve a block for the initial framebuffer or similar, hence the expectation
>> - * here is that drm_buddy_alloc() is still the main vehicle for
>> - * allocations, so if that's not the case then the drm_mm range allocator is
>> - * probably a much better fit, and so you should probably go use that instead.
>> - *
>> - * Note that it's safe to chain together multiple alloc_ranges
>> - * with the same blocks list
>> - *
>> - * Returns:
>> - * 0 on success, error code on failure.
>> - */
>> -int drm_buddy_alloc_range(struct drm_buddy_mm *mm,
>> - struct list_head *blocks,
>> - u64 start, u64 size)
>> +static struct drm_buddy_block *
>> +alloc_range(struct drm_buddy_mm *mm,
>> + u64 start, u64 end,
>> + unsigned int order)
>> {
>> struct drm_buddy_block *block;
>> struct drm_buddy_block *buddy;
>> - LIST_HEAD(allocated);
>> LIST_HEAD(dfs);
>> - u64 end;
>> int err;
>> int i;
>>
>> - if (size < mm->chunk_size)
>> - return -EINVAL;
>> -
>> - if (!IS_ALIGNED(size | start, mm->chunk_size))
>> - return -EINVAL;
>> -
>> - if (range_overflows(start, size, mm->size))
>> - return -EINVAL;
>> + end = end - 1;
>>
>> for (i = 0; i < mm->n_roots; ++i)
>> list_add_tail(&mm->roots[i]->tmp_link, &dfs);
>>
>> - end = start + size - 1;
>> -
>> do {
>> u64 block_start;
>> u64 block_end;
>> @@ -399,26 +312,26 @@ int drm_buddy_alloc_range(struct drm_buddy_mm *mm,
>>
>> list_del(&block->tmp_link);
>>
>> + if (drm_buddy_block_order(block) < order)
>> + continue;
>> +
>> block_start = drm_buddy_block_offset(block);
>> block_end = block_start + drm_buddy_block_size(mm, block) - 1;
>>
>> if (!overlaps(start, end, block_start, block_end))
>> continue;
>>
>> - if (drm_buddy_block_is_allocated(block)) {
>> - err = -ENOSPC;
>> - goto err_free;
>> - }
>> + if (drm_buddy_block_is_allocated(block))
>> + continue;
>>
>> - if (contains(start, end, block_start, block_end)) {
>> - if (!drm_buddy_block_is_free(block)) {
>> - err = -ENOSPC;
>> - goto err_free;
>> - }
>> + if (contains(start, end, block_start, block_end) &&
>> + order == drm_buddy_block_order(block)) {
>> + /*
>> + * Find the free block within the range.
>> + */
>> + if (drm_buddy_block_is_free(block))
>> + return block;
>
> AFAIK this is still randomly ordered when dealing with actual range
> allocation. Maybe I'm missing something, but it looks like we are just
> repeatedly picking the largest order that fits in the remaining number
> of pages, but it might be the case that the smallest block is for
> example at the start of the range, depending on the layout of the
> address space, which would then only get allocated last.
>
> I think I mentioned this before, but most of the block_trim() looks to
> already do what we want for this case, and could maybe be factored out,
> since that is also just another range allocation, except we start with
> one root node for our "dfs" search.
>
> Maybe something like:
>
> drm_buddy_trim(block, new_size...)
> {
> ....
> mark_free(block);
> list_add(&block->tmp_link, &dfs);
> err = __alloc_range(mm, &dfs, block->start, new_size, ...);
> if (err)
> ....
> }
>
> __drm_buddy_alloc_range(start, size, blocks)
> {
> for_each_root()
> list_add(&root->tmp_link, &dfs);
>
> err = __alloc_range(mm, &dfs, start, size, ...);
> if (err)
> ....
> }
>
> drm_buddy_alloc(...)
> {
> /* Actual range allocation */
> if (start + size == end)
> return __drm_buddy_alloc_range(...);
> ....
> }
>
> And then have something different for the alloc_range_bias()?
>
Yes, we will have a common function __alloc_range() which does the range
allocation for block_trim() and __drm_buddy_alloc_range() (actual range
allocation).
And, I understood that we keep the alloc_range() implementation for end
bias allocations?
>>
>> - mark_allocated(block);
>> - mm->avail -= drm_buddy_block_size(mm, block);
>> - list_add_tail(&block->link, &allocated);
>> continue;
>> }
>>
>> @@ -432,8 +345,7 @@ int drm_buddy_alloc_range(struct drm_buddy_mm *mm,
>> list_add(&block->left->tmp_link, &dfs);
>> } while (1);
>>
>> - list_splice_tail(&allocated, blocks);
>> - return 0;
>> + return ERR_PTR(-ENOSPC);
>>
>> err_undo:
>> /*
>> @@ -446,12 +358,145 @@ int drm_buddy_alloc_range(struct drm_buddy_mm *mm,
>> (drm_buddy_block_is_free(block) &&
>> drm_buddy_block_is_free(buddy)))
>> __drm_buddy_free(mm, block);
>> + return ERR_PTR(err);
>> +}
>> +
>> +static struct drm_buddy_block *
>> +alloc_from_freelist(struct drm_buddy_mm *mm,
>> + unsigned int order,
>> + unsigned long flags)
>> +{
>> + struct drm_buddy_block *block = NULL;
>> + unsigned int i;
>> + int err;
>> +
>> + for (i = order; i <= mm->max_order; ++i) {
>> + block = list_first_entry_or_null(&mm->free_list[i],
>> + struct drm_buddy_block,
>> + link);
>> + if (block)
>> + break;
>> + }
>> +
>> + if (!block)
>> + return ERR_PTR(-ENOSPC);
>> +
>> + BUG_ON(!drm_buddy_block_is_free(block));
>> +
>> + while (i != order) {
>> + err = split_block(mm, block);
>> + if (unlikely(err))
>> + goto err_undo;
>> +
>> + block = block->right;
>> + i--;
>> + }
>> + return block;
>> +
>> +err_undo:
>> + if (i != order)
>> + __drm_buddy_free(mm, block);
>> + return ERR_PTR(err);
>> +}
>> +
>> +/**
>> + * drm_buddy_alloc - allocate power-of-two blocks
>> + *
>> + * @mm: DRM buddy manager to allocate from
>> + * @start: start of the allowed range for this block
>> + * @end: end of the allowed range for this block
>> + * @size: size of the allocation
>> + * @min_page_size: alignment of the allocation
>> + * @blocks: output list head to add allocated blocks
>> + * @flags: DRM_BUDDY_*_ALLOCATION flags
>> + *
>> + * alloc_range() called on range limitations, which traverses
>> + * the tree and returns the desired block.
>> + *
>> + * alloc_from_freelist() called when *no* range restrictions
>> + * are enforced, which picks the block from the freelist.
>> + *
>> + * blocks are allocated in order, the order value here translates to:
>> + *
>> + * 0 = 2^0 * mm->chunk_size
>> + * 1 = 2^1 * mm->chunk_size
>> + * 2 = 2^2 * mm->chunk_size
>> + *
>> + * Returns:
>> + * 0 on success, error code on failure.
>> + */
>> +int drm_buddy_alloc(struct drm_buddy_mm *mm,
>> + u64 start, u64 end, u64 size,
>> + u64 min_page_size,
>> + struct list_head *blocks,
>> + unsigned long flags)
>> +{
>> + struct drm_buddy_block *block = NULL;
>> + unsigned int min_order, order;
>> + unsigned long pages;
>> + LIST_HEAD(allocated);
>> + int err;
>> +
>> + if (size < mm->chunk_size)
>> + return -EINVAL;
>> +
>> + if (min_page_size < mm->chunk_size)
>> + return -EINVAL;
>> +
>> + if (!is_power_of_2(min_page_size))
>> + return -EINVAL;
>> +
>> + if (!IS_ALIGNED(start | end | size, mm->chunk_size))
>> + return -EINVAL;
>> +
>> + if (check_range_overflow(start, end, size, mm->size))
>> + return -EINVAL;
>> +
>> + pages = size >> ilog2(mm->chunk_size);
>> + order = fls(pages) - 1;
>> + min_order = ilog2(min_page_size) - ilog2(mm->chunk_size);
>> +
>> + do {
>> + order = min(order, (unsigned int)fls(pages) - 1);
>> + BUG_ON(order > mm->max_order);
>> + BUG_ON(order < min_order);
>> +
>> + do {
>> + if (flags & DRM_BUDDY_RANGE_ALLOCATION)
>> + /* Allocate traversing within the range */
>> + block = alloc_range(mm, start, end, order);
>> + else
>> + /* Allocate from freelist */
>> + block = alloc_from_freelist(mm, order, flags);
>> +
>> + if (!IS_ERR(block))
>> + break;
>> +
>> + if (order-- == min_order) {
>> + err = -ENOSPC;
>> + goto err_free;
>> + }
>> + } while (1);
>> +
>> + mark_allocated(block);
>> + mm->avail -= drm_buddy_block_size(mm, block);
>> + kmemleak_update_trace(block);
>> + list_add_tail(&block->link, &allocated);
>> +
>> + pages -= BIT(order);
>> +
>> + if (!pages)
>> + break;
>> + } while (1);
>> +
>> + list_splice_tail(&allocated, blocks);
>> + return 0;
>>
>> err_free:
>> drm_buddy_free_list(mm, &allocated);
>> return err;
>> }
>> -EXPORT_SYMBOL(drm_buddy_alloc_range);
>> +EXPORT_SYMBOL(drm_buddy_alloc);
>>
>> /**
>> * drm_buddy_block_print - print block information
>> diff --git a/drivers/gpu/drm/i915/i915_ttm_buddy_manager.c b/drivers/gpu/drm/i915/i915_ttm_buddy_manager.c
>> index c4b70cb8c248..9e3d130c3f42 100644
>> --- a/drivers/gpu/drm/i915/i915_ttm_buddy_manager.c
>> +++ b/drivers/gpu/drm/i915/i915_ttm_buddy_manager.c
>> @@ -36,13 +36,14 @@ static int i915_ttm_buddy_man_alloc(struct ttm_resource_manager *man,
>> struct i915_ttm_buddy_manager *bman = to_buddy_manager(man);
>> struct i915_ttm_buddy_resource *bman_res;
>> struct drm_buddy_mm *mm = &bman->mm;
>> - unsigned long n_pages;
>> - unsigned int min_order;
>> + unsigned long n_pages, lpfn;
>> u64 min_page_size;
>> u64 size;
>> int err;
>>
>> - GEM_BUG_ON(place->fpfn || place->lpfn);
>> + lpfn = place->lpfn;
>> + if (!lpfn)
>> + lpfn = man->size;
>>
>> bman_res = kzalloc(sizeof(*bman_res), GFP_KERNEL);
>> if (!bman_res)
>> @@ -52,6 +53,9 @@ static int i915_ttm_buddy_man_alloc(struct ttm_resource_manager *man,
>> INIT_LIST_HEAD(&bman_res->blocks);
>> bman_res->mm = mm;
>>
>> + if (place->fpfn || lpfn != man->size)
>> + bman_res->flags |= DRM_BUDDY_RANGE_ALLOCATION;
>> +
>> GEM_BUG_ON(!bman_res->base.num_pages);
>> size = bman_res->base.num_pages << PAGE_SHIFT;
>>
>> @@ -60,10 +64,16 @@ static int i915_ttm_buddy_man_alloc(struct ttm_resource_manager *man,
>> min_page_size = bo->page_alignment << PAGE_SHIFT;
>>
>> GEM_BUG_ON(min_page_size < mm->chunk_size);
>> - min_order = ilog2(min_page_size) - ilog2(mm->chunk_size);
>> +
>> if (place->flags & TTM_PL_FLAG_CONTIGUOUS) {
>> + unsigned long pages;
>> +
>> size = roundup_pow_of_two(size);
>> - min_order = ilog2(size) - ilog2(mm->chunk_size);
>> + min_page_size = size;
>> +
>> + pages = size >> ilog2(mm->chunk_size);
>> + if (pages > lpfn)
>> + lpfn = pages;
>> }
>>
>> if (size > mm->size) {
>> @@ -73,34 +83,16 @@ static int i915_ttm_buddy_man_alloc(struct ttm_resource_manager *man,
>>
>> n_pages = size >> ilog2(mm->chunk_size);
>>
>> - do {
>> - struct drm_buddy_block *block;
>> - unsigned int order;
>> -
>> - order = fls(n_pages) - 1;
>> - GEM_BUG_ON(order > mm->max_order);
>> - GEM_BUG_ON(order < min_order);
>> -
>> - do {
>> - mutex_lock(&bman->lock);
>> - block = drm_buddy_alloc(mm, order);
>> - mutex_unlock(&bman->lock);
>> - if (!IS_ERR(block))
>> - break;
>> -
>> - if (order-- == min_order) {
>> - err = -ENOSPC;
>> - goto err_free_blocks;
>> - }
>> - } while (1);
>> -
>> - n_pages -= BIT(order);
>> -
>> - list_add_tail(&block->link, &bman_res->blocks);
>> -
>> - if (!n_pages)
>> - break;
>> - } while (1);
>> + mutex_lock(&bman->lock);
>> + err = drm_buddy_alloc(mm, (u64)place->fpfn << PAGE_SHIFT,
>> + (u64)place->lpfn << PAGE_SHIFT,
>> + (u64)n_pages << PAGE_SHIFT,
>> + min_page_size,
>> + &bman_res->blocks,
>> + bman_res->flags);
>> + mutex_unlock(&bman->lock);
>> + if (unlikely(err))
>> + goto err_free_blocks;
>>
>> *res = &bman_res->base;
>> return 0;
>> @@ -266,10 +258,19 @@ int i915_ttm_buddy_man_reserve(struct ttm_resource_manager *man,
>> {
>> struct i915_ttm_buddy_manager *bman = to_buddy_manager(man);
>> struct drm_buddy_mm *mm = &bman->mm;
>> + unsigned long flags = 0;
>> + u64 min_size;
>> int ret;
>>
>> + min_size = size;
>> + flags |= DRM_BUDDY_RANGE_ALLOCATION;
>> +
>> mutex_lock(&bman->lock);
>> - ret = drm_buddy_alloc_range(mm, &bman->reserved, start, size);
>> + ret = drm_buddy_alloc(mm, start,
>> + start + size,
>> + size, min_size,
>
> min_page_size = min_size = size. I don't think we want that here. Also
> the size here might not be power of two. I guess we need to use
> chunk_size here instead?
ok, we will use chunk_size here.
>
>> + &bman->reserved,
>> + flags);
>> mutex_unlock(&bman->lock);
>>
>> return ret;
>> diff --git a/drivers/gpu/drm/i915/i915_ttm_buddy_manager.h b/drivers/gpu/drm/i915/i915_ttm_buddy_manager.h
>> index fa644b512c2e..5ba490875f66 100644
>> --- a/drivers/gpu/drm/i915/i915_ttm_buddy_manager.h
>> +++ b/drivers/gpu/drm/i915/i915_ttm_buddy_manager.h
>> @@ -20,6 +20,7 @@ struct drm_buddy_mm;
>> *
>> * @base: struct ttm_resource base class we extend
>> * @blocks: the list of struct i915_buddy_block for this resource/allocation
>> + * @flags: DRM_BUDDY_*_ALLOCATION flags
>> * @mm: the struct i915_buddy_mm for this resource
>> *
>> * Extends the struct ttm_resource to manage an address space allocation with
>> @@ -28,6 +29,7 @@ struct drm_buddy_mm;
>> struct i915_ttm_buddy_resource {
>> struct ttm_resource base;
>> struct list_head blocks;
>> + unsigned long flags;
>> struct drm_buddy_mm *mm;
>> };
>>
>> diff --git a/include/drm/drm_buddy.h b/include/drm/drm_buddy.h
>> index 5ce3fc702f80..2ec3cbc9d5d7 100644
>> --- a/include/drm/drm_buddy.h
>> +++ b/include/drm/drm_buddy.h
>> @@ -13,15 +13,22 @@
>>
>> #include <drm/drm_print.h>
>>
>> -#define range_overflows(start, size, max) ({ \
>> +#define check_range_overflow(start, end, size, max) ({ \
>> typeof(start) start__ = (start); \
>> + typeof(end) end__ = (end);\
>> typeof(size) size__ = (size); \
>> typeof(max) max__ = (max); \
>> (void)(&start__ == &size__); \
>> (void)(&start__ == &max__); \
>> - start__ >= max__ || size__ > max__ - start__; \
>> + (void)(&start__ == &end__); \
>> + (void)(&end__ == &size__); \
>> + (void)(&end__ == &max__); \
>> + start__ >= max__ || end__ > max__ || \
>> + size__ > end__ - start__; \
>> })
>>
>> +#define DRM_BUDDY_RANGE_ALLOCATION (1 << 0)
>> +
>> struct drm_buddy_block {
>> #define DRM_BUDDY_HEADER_OFFSET GENMASK_ULL(63, 12)
>> #define DRM_BUDDY_HEADER_STATE GENMASK_ULL(11, 10)
>> @@ -131,12 +138,11 @@ int drm_buddy_init(struct drm_buddy_mm *mm, u64 size, u64 chunk_size);
>>
>> void drm_buddy_fini(struct drm_buddy_mm *mm);
>>
>> -struct drm_buddy_block *
>> -drm_buddy_alloc(struct drm_buddy_mm *mm, unsigned int order);
>> -
>> -int drm_buddy_alloc_range(struct drm_buddy_mm *mm,
>> - struct list_head *blocks,
>> - u64 start, u64 size);
>> +int drm_buddy_alloc(struct drm_buddy_mm *mm,
>> + u64 start, u64 end, u64 size,
>> + u64 min_page_size,
>> + struct list_head *blocks,
>> + unsigned long flags);
>>
>> void drm_buddy_free(struct drm_buddy_mm *mm, struct drm_buddy_block *block);
>>
>>
^ permalink raw reply [flat|nested] 46+ messages in thread
* Re: [PATCH v3 2/6] drm: improve drm_buddy_alloc function
@ 2021-11-23 22:39 ` Arunpravin
0 siblings, 0 replies; 46+ messages in thread
From: Arunpravin @ 2021-11-23 22:39 UTC (permalink / raw)
To: Matthew Auld, dri-devel, intel-gfx, amd-gfx
Cc: alexander.deucher, tzimmermann, jani.nikula, christian.koenig, daniel
On 18/11/21 12:09 am, Matthew Auld wrote:
> On 16/11/2021 20:18, Arunpravin wrote:
>> - Make drm_buddy_alloc a single function to handle
>> range allocation and non-range allocation demands
>>
>> - Implemented a new function alloc_range() which allocates
>> the requested power-of-two block comply with range limitations
>>
>> - Moved order computation and memory alignment logic from
>> i915 driver to drm buddy
>>
>> v2:
>> merged below changes to keep the build unbroken
>> - drm_buddy_alloc_range() becomes obsolete and may be removed
>> - enable ttm range allocation (fpfn / lpfn) support in i915 driver
>> - apply enhanced drm_buddy_alloc() function to i915 driver
>>
>> v3(Matthew Auld):
>> - Fix alignment issues and remove unnecessary list_empty check
>> - add more validation checks for input arguments
>> - make alloc_range() block allocations as bottom-up
>> - optimize order computation logic
>> - replace uint64_t with u64, which is preferred in the kernel
>>
>> Signed-off-by: Arunpravin <Arunpravin.PaneerSelvam@amd.com>
>> ---
>> drivers/gpu/drm/drm_buddy.c | 259 ++++++++++--------
>> drivers/gpu/drm/i915/i915_ttm_buddy_manager.c | 69 ++---
>> drivers/gpu/drm/i915/i915_ttm_buddy_manager.h | 2 +
>> include/drm/drm_buddy.h | 22 +-
>> 4 files changed, 203 insertions(+), 149 deletions(-)
>>
>> diff --git a/drivers/gpu/drm/drm_buddy.c b/drivers/gpu/drm/drm_buddy.c
>> index 39eb1d224bec..c9b18a29f8d1 100644
>> --- a/drivers/gpu/drm/drm_buddy.c
>> +++ b/drivers/gpu/drm/drm_buddy.c
>> @@ -274,63 +274,6 @@ void drm_buddy_free_list(struct drm_buddy_mm *mm, struct list_head *objects)
>> }
>> EXPORT_SYMBOL(drm_buddy_free_list);
>>
>> -/**
>> - * drm_buddy_alloc - allocate power-of-two blocks
>> - *
>> - * @mm: DRM buddy manager to allocate from
>> - * @order: size of the allocation
>> - *
>> - * The order value here translates to:
>> - *
>> - * 0 = 2^0 * mm->chunk_size
>> - * 1 = 2^1 * mm->chunk_size
>> - * 2 = 2^2 * mm->chunk_size
>> - *
>> - * Returns:
>> - * allocated ptr to the &drm_buddy_block on success
>> - */
>> -struct drm_buddy_block *
>> -drm_buddy_alloc(struct drm_buddy_mm *mm, unsigned int order)
>> -{
>> - struct drm_buddy_block *block = NULL;
>> - unsigned int i;
>> - int err;
>> -
>> - for (i = order; i <= mm->max_order; ++i) {
>> - block = list_first_entry_or_null(&mm->free_list[i],
>> - struct drm_buddy_block,
>> - link);
>> - if (block)
>> - break;
>> - }
>> -
>> - if (!block)
>> - return ERR_PTR(-ENOSPC);
>> -
>> - BUG_ON(!drm_buddy_block_is_free(block));
>> -
>> - while (i != order) {
>> - err = split_block(mm, block);
>> - if (unlikely(err))
>> - goto out_free;
>> -
>> - /* Go low */
>> - block = block->left;
>> - i--;
>> - }
>> -
>> - mark_allocated(block);
>> - mm->avail -= drm_buddy_block_size(mm, block);
>> - kmemleak_update_trace(block);
>> - return block;
>> -
>> -out_free:
>> - if (i != order)
>> - __drm_buddy_free(mm, block);
>> - return ERR_PTR(err);
>> -}
>> -EXPORT_SYMBOL(drm_buddy_alloc);
>> -
>> static inline bool overlaps(u64 s1, u64 e1, u64 s2, u64 e2)
>> {
>> return s1 <= e2 && e1 >= s2;
>> @@ -341,52 +284,22 @@ static inline bool contains(u64 s1, u64 e1, u64 s2, u64 e2)
>> return s1 <= s2 && e1 >= e2;
>> }
>>
>> -/**
>> - * drm_buddy_alloc_range - allocate range
>> - *
>> - * @mm: DRM buddy manager to allocate from
>> - * @blocks: output list head to add allocated blocks
>> - * @start: start of the allowed range for this block
>> - * @size: size of the allocation
>> - *
>> - * Intended for pre-allocating portions of the address space, for example to
>> - * reserve a block for the initial framebuffer or similar, hence the expectation
>> - * here is that drm_buddy_alloc() is still the main vehicle for
>> - * allocations, so if that's not the case then the drm_mm range allocator is
>> - * probably a much better fit, and so you should probably go use that instead.
>> - *
>> - * Note that it's safe to chain together multiple alloc_ranges
>> - * with the same blocks list
>> - *
>> - * Returns:
>> - * 0 on success, error code on failure.
>> - */
>> -int drm_buddy_alloc_range(struct drm_buddy_mm *mm,
>> - struct list_head *blocks,
>> - u64 start, u64 size)
>> +static struct drm_buddy_block *
>> +alloc_range(struct drm_buddy_mm *mm,
>> + u64 start, u64 end,
>> + unsigned int order)
>> {
>> struct drm_buddy_block *block;
>> struct drm_buddy_block *buddy;
>> - LIST_HEAD(allocated);
>> LIST_HEAD(dfs);
>> - u64 end;
>> int err;
>> int i;
>>
>> - if (size < mm->chunk_size)
>> - return -EINVAL;
>> -
>> - if (!IS_ALIGNED(size | start, mm->chunk_size))
>> - return -EINVAL;
>> -
>> - if (range_overflows(start, size, mm->size))
>> - return -EINVAL;
>> + end = end - 1;
>>
>> for (i = 0; i < mm->n_roots; ++i)
>> list_add_tail(&mm->roots[i]->tmp_link, &dfs);
>>
>> - end = start + size - 1;
>> -
>> do {
>> u64 block_start;
>> u64 block_end;
>> @@ -399,26 +312,26 @@ int drm_buddy_alloc_range(struct drm_buddy_mm *mm,
>>
>> list_del(&block->tmp_link);
>>
>> + if (drm_buddy_block_order(block) < order)
>> + continue;
>> +
>> block_start = drm_buddy_block_offset(block);
>> block_end = block_start + drm_buddy_block_size(mm, block) - 1;
>>
>> if (!overlaps(start, end, block_start, block_end))
>> continue;
>>
>> - if (drm_buddy_block_is_allocated(block)) {
>> - err = -ENOSPC;
>> - goto err_free;
>> - }
>> + if (drm_buddy_block_is_allocated(block))
>> + continue;
>>
>> - if (contains(start, end, block_start, block_end)) {
>> - if (!drm_buddy_block_is_free(block)) {
>> - err = -ENOSPC;
>> - goto err_free;
>> - }
>> + if (contains(start, end, block_start, block_end) &&
>> + order == drm_buddy_block_order(block)) {
>> + /*
>> + * Find the free block within the range.
>> + */
>> + if (drm_buddy_block_is_free(block))
>> + return block;
>
> AFAIK this is still randomly ordered when dealing with actual range
> allocation. Maybe I'm missing something, but it looks like we are just
> repeatedly picking the largest order that fits in the remaining number
> of pages, but it might be the case that the smallest block is for
> example at the start of the range, depending on the layout of the
> address space, which would then only get allocated last.
>
> I think I mentioned this before, but most of the block_trim() looks to
> already do what we want for this case, and could maybe be factored out,
> since that is also just another range allocation, except we start with
> one root node for our "dfs" search.
>
> Maybe something like:
>
> drm_buddy_trim(block, new_size...)
> {
> ....
> mark_free(block);
> list_add(&block->tmp_link, &dfs);
> err = __alloc_range(mm, &dfs, block->start, new_size, ...);
> if (err)
> ....
> }
>
> __drm_buddy_alloc_range(start, size, blocks)
> {
> for_each_root()
> list_add(&root->tmp_link, &dfs);
>
> err = __alloc_range(mm, &dfs, start, size, ...);
> if (err)
> ....
> }
>
> drm_buddy_alloc(...)
> {
> /* Actual range allocation */
> if (start + size == end)
> return __drm_buddy_alloc_range(...);
> ....
> }
>
> And then have something different for the alloc_range_bias()?
>
Yes, we will have a common function __alloc_range() which does the range
allocation for block_trim() and __drm_buddy_alloc_range() (actual range
allocation).
And, I understood that we keep the alloc_range() implementation for end
bias allocations?
>>
>> - mark_allocated(block);
>> - mm->avail -= drm_buddy_block_size(mm, block);
>> - list_add_tail(&block->link, &allocated);
>> continue;
>> }
>>
>> @@ -432,8 +345,7 @@ int drm_buddy_alloc_range(struct drm_buddy_mm *mm,
>> list_add(&block->left->tmp_link, &dfs);
>> } while (1);
>>
>> - list_splice_tail(&allocated, blocks);
>> - return 0;
>> + return ERR_PTR(-ENOSPC);
>>
>> err_undo:
>> /*
>> @@ -446,12 +358,145 @@ int drm_buddy_alloc_range(struct drm_buddy_mm *mm,
>> (drm_buddy_block_is_free(block) &&
>> drm_buddy_block_is_free(buddy)))
>> __drm_buddy_free(mm, block);
>> + return ERR_PTR(err);
>> +}
>> +
>> +static struct drm_buddy_block *
>> +alloc_from_freelist(struct drm_buddy_mm *mm,
>> + unsigned int order,
>> + unsigned long flags)
>> +{
>> + struct drm_buddy_block *block = NULL;
>> + unsigned int i;
>> + int err;
>> +
>> + for (i = order; i <= mm->max_order; ++i) {
>> + block = list_first_entry_or_null(&mm->free_list[i],
>> + struct drm_buddy_block,
>> + link);
>> + if (block)
>> + break;
>> + }
>> +
>> + if (!block)
>> + return ERR_PTR(-ENOSPC);
>> +
>> + BUG_ON(!drm_buddy_block_is_free(block));
>> +
>> + while (i != order) {
>> + err = split_block(mm, block);
>> + if (unlikely(err))
>> + goto err_undo;
>> +
>> + block = block->right;
>> + i--;
>> + }
>> + return block;
>> +
>> +err_undo:
>> + if (i != order)
>> + __drm_buddy_free(mm, block);
>> + return ERR_PTR(err);
>> +}
>> +
>> +/**
>> + * drm_buddy_alloc - allocate power-of-two blocks
>> + *
>> + * @mm: DRM buddy manager to allocate from
>> + * @start: start of the allowed range for this block
>> + * @end: end of the allowed range for this block
>> + * @size: size of the allocation
>> + * @min_page_size: alignment of the allocation
>> + * @blocks: output list head to add allocated blocks
>> + * @flags: DRM_BUDDY_*_ALLOCATION flags
>> + *
>> + * alloc_range() called on range limitations, which traverses
>> + * the tree and returns the desired block.
>> + *
>> + * alloc_from_freelist() called when *no* range restrictions
>> + * are enforced, which picks the block from the freelist.
>> + *
>> + * blocks are allocated in order, the order value here translates to:
>> + *
>> + * 0 = 2^0 * mm->chunk_size
>> + * 1 = 2^1 * mm->chunk_size
>> + * 2 = 2^2 * mm->chunk_size
>> + *
>> + * Returns:
>> + * 0 on success, error code on failure.
>> + */
>> +int drm_buddy_alloc(struct drm_buddy_mm *mm,
>> + u64 start, u64 end, u64 size,
>> + u64 min_page_size,
>> + struct list_head *blocks,
>> + unsigned long flags)
>> +{
>> + struct drm_buddy_block *block = NULL;
>> + unsigned int min_order, order;
>> + unsigned long pages;
>> + LIST_HEAD(allocated);
>> + int err;
>> +
>> + if (size < mm->chunk_size)
>> + return -EINVAL;
>> +
>> + if (min_page_size < mm->chunk_size)
>> + return -EINVAL;
>> +
>> + if (!is_power_of_2(min_page_size))
>> + return -EINVAL;
>> +
>> + if (!IS_ALIGNED(start | end | size, mm->chunk_size))
>> + return -EINVAL;
>> +
>> + if (check_range_overflow(start, end, size, mm->size))
>> + return -EINVAL;
>> +
>> + pages = size >> ilog2(mm->chunk_size);
>> + order = fls(pages) - 1;
>> + min_order = ilog2(min_page_size) - ilog2(mm->chunk_size);
>> +
>> + do {
>> + order = min(order, (unsigned int)fls(pages) - 1);
>> + BUG_ON(order > mm->max_order);
>> + BUG_ON(order < min_order);
>> +
>> + do {
>> + if (flags & DRM_BUDDY_RANGE_ALLOCATION)
>> + /* Allocate traversing within the range */
>> + block = alloc_range(mm, start, end, order);
>> + else
>> + /* Allocate from freelist */
>> + block = alloc_from_freelist(mm, order, flags);
>> +
>> + if (!IS_ERR(block))
>> + break;
>> +
>> + if (order-- == min_order) {
>> + err = -ENOSPC;
>> + goto err_free;
>> + }
>> + } while (1);
>> +
>> + mark_allocated(block);
>> + mm->avail -= drm_buddy_block_size(mm, block);
>> + kmemleak_update_trace(block);
>> + list_add_tail(&block->link, &allocated);
>> +
>> + pages -= BIT(order);
>> +
>> + if (!pages)
>> + break;
>> + } while (1);
>> +
>> + list_splice_tail(&allocated, blocks);
>> + return 0;
>>
>> err_free:
>> drm_buddy_free_list(mm, &allocated);
>> return err;
>> }
>> -EXPORT_SYMBOL(drm_buddy_alloc_range);
>> +EXPORT_SYMBOL(drm_buddy_alloc);
>>
>> /**
>> * drm_buddy_block_print - print block information
>> diff --git a/drivers/gpu/drm/i915/i915_ttm_buddy_manager.c b/drivers/gpu/drm/i915/i915_ttm_buddy_manager.c
>> index c4b70cb8c248..9e3d130c3f42 100644
>> --- a/drivers/gpu/drm/i915/i915_ttm_buddy_manager.c
>> +++ b/drivers/gpu/drm/i915/i915_ttm_buddy_manager.c
>> @@ -36,13 +36,14 @@ static int i915_ttm_buddy_man_alloc(struct ttm_resource_manager *man,
>> struct i915_ttm_buddy_manager *bman = to_buddy_manager(man);
>> struct i915_ttm_buddy_resource *bman_res;
>> struct drm_buddy_mm *mm = &bman->mm;
>> - unsigned long n_pages;
>> - unsigned int min_order;
>> + unsigned long n_pages, lpfn;
>> u64 min_page_size;
>> u64 size;
>> int err;
>>
>> - GEM_BUG_ON(place->fpfn || place->lpfn);
>> + lpfn = place->lpfn;
>> + if (!lpfn)
>> + lpfn = man->size;
>>
>> bman_res = kzalloc(sizeof(*bman_res), GFP_KERNEL);
>> if (!bman_res)
>> @@ -52,6 +53,9 @@ static int i915_ttm_buddy_man_alloc(struct ttm_resource_manager *man,
>> INIT_LIST_HEAD(&bman_res->blocks);
>> bman_res->mm = mm;
>>
>> + if (place->fpfn || lpfn != man->size)
>> + bman_res->flags |= DRM_BUDDY_RANGE_ALLOCATION;
>> +
>> GEM_BUG_ON(!bman_res->base.num_pages);
>> size = bman_res->base.num_pages << PAGE_SHIFT;
>>
>> @@ -60,10 +64,16 @@ static int i915_ttm_buddy_man_alloc(struct ttm_resource_manager *man,
>> min_page_size = bo->page_alignment << PAGE_SHIFT;
>>
>> GEM_BUG_ON(min_page_size < mm->chunk_size);
>> - min_order = ilog2(min_page_size) - ilog2(mm->chunk_size);
>> +
>> if (place->flags & TTM_PL_FLAG_CONTIGUOUS) {
>> + unsigned long pages;
>> +
>> size = roundup_pow_of_two(size);
>> - min_order = ilog2(size) - ilog2(mm->chunk_size);
>> + min_page_size = size;
>> +
>> + pages = size >> ilog2(mm->chunk_size);
>> + if (pages > lpfn)
>> + lpfn = pages;
>> }
>>
>> if (size > mm->size) {
>> @@ -73,34 +83,16 @@ static int i915_ttm_buddy_man_alloc(struct ttm_resource_manager *man,
>>
>> n_pages = size >> ilog2(mm->chunk_size);
>>
>> - do {
>> - struct drm_buddy_block *block;
>> - unsigned int order;
>> -
>> - order = fls(n_pages) - 1;
>> - GEM_BUG_ON(order > mm->max_order);
>> - GEM_BUG_ON(order < min_order);
>> -
>> - do {
>> - mutex_lock(&bman->lock);
>> - block = drm_buddy_alloc(mm, order);
>> - mutex_unlock(&bman->lock);
>> - if (!IS_ERR(block))
>> - break;
>> -
>> - if (order-- == min_order) {
>> - err = -ENOSPC;
>> - goto err_free_blocks;
>> - }
>> - } while (1);
>> -
>> - n_pages -= BIT(order);
>> -
>> - list_add_tail(&block->link, &bman_res->blocks);
>> -
>> - if (!n_pages)
>> - break;
>> - } while (1);
>> + mutex_lock(&bman->lock);
>> + err = drm_buddy_alloc(mm, (u64)place->fpfn << PAGE_SHIFT,
>> + (u64)place->lpfn << PAGE_SHIFT,
>> + (u64)n_pages << PAGE_SHIFT,
>> + min_page_size,
>> + &bman_res->blocks,
>> + bman_res->flags);
>> + mutex_unlock(&bman->lock);
>> + if (unlikely(err))
>> + goto err_free_blocks;
>>
>> *res = &bman_res->base;
>> return 0;
>> @@ -266,10 +258,19 @@ int i915_ttm_buddy_man_reserve(struct ttm_resource_manager *man,
>> {
>> struct i915_ttm_buddy_manager *bman = to_buddy_manager(man);
>> struct drm_buddy_mm *mm = &bman->mm;
>> + unsigned long flags = 0;
>> + u64 min_size;
>> int ret;
>>
>> + min_size = size;
>> + flags |= DRM_BUDDY_RANGE_ALLOCATION;
>> +
>> mutex_lock(&bman->lock);
>> - ret = drm_buddy_alloc_range(mm, &bman->reserved, start, size);
>> + ret = drm_buddy_alloc(mm, start,
>> + start + size,
>> + size, min_size,
>
> min_page_size = min_size = size. I don't think we want that here. Also
> the size here might not be power of two. I guess we need to use
> chunk_size here instead?
ok, we will use chunk_size here.
>
>> + &bman->reserved,
>> + flags);
>> mutex_unlock(&bman->lock);
>>
>> return ret;
>> diff --git a/drivers/gpu/drm/i915/i915_ttm_buddy_manager.h b/drivers/gpu/drm/i915/i915_ttm_buddy_manager.h
>> index fa644b512c2e..5ba490875f66 100644
>> --- a/drivers/gpu/drm/i915/i915_ttm_buddy_manager.h
>> +++ b/drivers/gpu/drm/i915/i915_ttm_buddy_manager.h
>> @@ -20,6 +20,7 @@ struct drm_buddy_mm;
>> *
>> * @base: struct ttm_resource base class we extend
>> * @blocks: the list of struct i915_buddy_block for this resource/allocation
>> + * @flags: DRM_BUDDY_*_ALLOCATION flags
>> * @mm: the struct i915_buddy_mm for this resource
>> *
>> * Extends the struct ttm_resource to manage an address space allocation with
>> @@ -28,6 +29,7 @@ struct drm_buddy_mm;
>> struct i915_ttm_buddy_resource {
>> struct ttm_resource base;
>> struct list_head blocks;
>> + unsigned long flags;
>> struct drm_buddy_mm *mm;
>> };
>>
>> diff --git a/include/drm/drm_buddy.h b/include/drm/drm_buddy.h
>> index 5ce3fc702f80..2ec3cbc9d5d7 100644
>> --- a/include/drm/drm_buddy.h
>> +++ b/include/drm/drm_buddy.h
>> @@ -13,15 +13,22 @@
>>
>> #include <drm/drm_print.h>
>>
>> -#define range_overflows(start, size, max) ({ \
>> +#define check_range_overflow(start, end, size, max) ({ \
>> typeof(start) start__ = (start); \
>> + typeof(end) end__ = (end);\
>> typeof(size) size__ = (size); \
>> typeof(max) max__ = (max); \
>> (void)(&start__ == &size__); \
>> (void)(&start__ == &max__); \
>> - start__ >= max__ || size__ > max__ - start__; \
>> + (void)(&start__ == &end__); \
>> + (void)(&end__ == &size__); \
>> + (void)(&end__ == &max__); \
>> + start__ >= max__ || end__ > max__ || \
>> + size__ > end__ - start__; \
>> })
>>
>> +#define DRM_BUDDY_RANGE_ALLOCATION (1 << 0)
>> +
>> struct drm_buddy_block {
>> #define DRM_BUDDY_HEADER_OFFSET GENMASK_ULL(63, 12)
>> #define DRM_BUDDY_HEADER_STATE GENMASK_ULL(11, 10)
>> @@ -131,12 +138,11 @@ int drm_buddy_init(struct drm_buddy_mm *mm, u64 size, u64 chunk_size);
>>
>> void drm_buddy_fini(struct drm_buddy_mm *mm);
>>
>> -struct drm_buddy_block *
>> -drm_buddy_alloc(struct drm_buddy_mm *mm, unsigned int order);
>> -
>> -int drm_buddy_alloc_range(struct drm_buddy_mm *mm,
>> - struct list_head *blocks,
>> - u64 start, u64 size);
>> +int drm_buddy_alloc(struct drm_buddy_mm *mm,
>> + u64 start, u64 end, u64 size,
>> + u64 min_page_size,
>> + struct list_head *blocks,
>> + unsigned long flags);
>>
>> void drm_buddy_free(struct drm_buddy_mm *mm, struct drm_buddy_block *block);
>>
>>
^ permalink raw reply [flat|nested] 46+ messages in thread
* Re: [Intel-gfx] [PATCH v3 2/6] drm: improve drm_buddy_alloc function
@ 2021-11-23 22:39 ` Arunpravin
0 siblings, 0 replies; 46+ messages in thread
From: Arunpravin @ 2021-11-23 22:39 UTC (permalink / raw)
To: Matthew Auld, dri-devel, intel-gfx, amd-gfx
Cc: alexander.deucher, tzimmermann, christian.koenig
On 18/11/21 12:09 am, Matthew Auld wrote:
> On 16/11/2021 20:18, Arunpravin wrote:
>> - Make drm_buddy_alloc a single function to handle
>> range allocation and non-range allocation demands
>>
>> - Implemented a new function alloc_range() which allocates
>> the requested power-of-two block comply with range limitations
>>
>> - Moved order computation and memory alignment logic from
>> i915 driver to drm buddy
>>
>> v2:
>> merged below changes to keep the build unbroken
>> - drm_buddy_alloc_range() becomes obsolete and may be removed
>> - enable ttm range allocation (fpfn / lpfn) support in i915 driver
>> - apply enhanced drm_buddy_alloc() function to i915 driver
>>
>> v3(Matthew Auld):
>> - Fix alignment issues and remove unnecessary list_empty check
>> - add more validation checks for input arguments
>> - make alloc_range() block allocations as bottom-up
>> - optimize order computation logic
>> - replace uint64_t with u64, which is preferred in the kernel
>>
>> Signed-off-by: Arunpravin <Arunpravin.PaneerSelvam@amd.com>
>> ---
>> drivers/gpu/drm/drm_buddy.c | 259 ++++++++++--------
>> drivers/gpu/drm/i915/i915_ttm_buddy_manager.c | 69 ++---
>> drivers/gpu/drm/i915/i915_ttm_buddy_manager.h | 2 +
>> include/drm/drm_buddy.h | 22 +-
>> 4 files changed, 203 insertions(+), 149 deletions(-)
>>
>> diff --git a/drivers/gpu/drm/drm_buddy.c b/drivers/gpu/drm/drm_buddy.c
>> index 39eb1d224bec..c9b18a29f8d1 100644
>> --- a/drivers/gpu/drm/drm_buddy.c
>> +++ b/drivers/gpu/drm/drm_buddy.c
>> @@ -274,63 +274,6 @@ void drm_buddy_free_list(struct drm_buddy_mm *mm, struct list_head *objects)
>> }
>> EXPORT_SYMBOL(drm_buddy_free_list);
>>
>> -/**
>> - * drm_buddy_alloc - allocate power-of-two blocks
>> - *
>> - * @mm: DRM buddy manager to allocate from
>> - * @order: size of the allocation
>> - *
>> - * The order value here translates to:
>> - *
>> - * 0 = 2^0 * mm->chunk_size
>> - * 1 = 2^1 * mm->chunk_size
>> - * 2 = 2^2 * mm->chunk_size
>> - *
>> - * Returns:
>> - * allocated ptr to the &drm_buddy_block on success
>> - */
>> -struct drm_buddy_block *
>> -drm_buddy_alloc(struct drm_buddy_mm *mm, unsigned int order)
>> -{
>> - struct drm_buddy_block *block = NULL;
>> - unsigned int i;
>> - int err;
>> -
>> - for (i = order; i <= mm->max_order; ++i) {
>> - block = list_first_entry_or_null(&mm->free_list[i],
>> - struct drm_buddy_block,
>> - link);
>> - if (block)
>> - break;
>> - }
>> -
>> - if (!block)
>> - return ERR_PTR(-ENOSPC);
>> -
>> - BUG_ON(!drm_buddy_block_is_free(block));
>> -
>> - while (i != order) {
>> - err = split_block(mm, block);
>> - if (unlikely(err))
>> - goto out_free;
>> -
>> - /* Go low */
>> - block = block->left;
>> - i--;
>> - }
>> -
>> - mark_allocated(block);
>> - mm->avail -= drm_buddy_block_size(mm, block);
>> - kmemleak_update_trace(block);
>> - return block;
>> -
>> -out_free:
>> - if (i != order)
>> - __drm_buddy_free(mm, block);
>> - return ERR_PTR(err);
>> -}
>> -EXPORT_SYMBOL(drm_buddy_alloc);
>> -
>> static inline bool overlaps(u64 s1, u64 e1, u64 s2, u64 e2)
>> {
>> return s1 <= e2 && e1 >= s2;
>> @@ -341,52 +284,22 @@ static inline bool contains(u64 s1, u64 e1, u64 s2, u64 e2)
>> return s1 <= s2 && e1 >= e2;
>> }
>>
>> -/**
>> - * drm_buddy_alloc_range - allocate range
>> - *
>> - * @mm: DRM buddy manager to allocate from
>> - * @blocks: output list head to add allocated blocks
>> - * @start: start of the allowed range for this block
>> - * @size: size of the allocation
>> - *
>> - * Intended for pre-allocating portions of the address space, for example to
>> - * reserve a block for the initial framebuffer or similar, hence the expectation
>> - * here is that drm_buddy_alloc() is still the main vehicle for
>> - * allocations, so if that's not the case then the drm_mm range allocator is
>> - * probably a much better fit, and so you should probably go use that instead.
>> - *
>> - * Note that it's safe to chain together multiple alloc_ranges
>> - * with the same blocks list
>> - *
>> - * Returns:
>> - * 0 on success, error code on failure.
>> - */
>> -int drm_buddy_alloc_range(struct drm_buddy_mm *mm,
>> - struct list_head *blocks,
>> - u64 start, u64 size)
>> +static struct drm_buddy_block *
>> +alloc_range(struct drm_buddy_mm *mm,
>> + u64 start, u64 end,
>> + unsigned int order)
>> {
>> struct drm_buddy_block *block;
>> struct drm_buddy_block *buddy;
>> - LIST_HEAD(allocated);
>> LIST_HEAD(dfs);
>> - u64 end;
>> int err;
>> int i;
>>
>> - if (size < mm->chunk_size)
>> - return -EINVAL;
>> -
>> - if (!IS_ALIGNED(size | start, mm->chunk_size))
>> - return -EINVAL;
>> -
>> - if (range_overflows(start, size, mm->size))
>> - return -EINVAL;
>> + end = end - 1;
>>
>> for (i = 0; i < mm->n_roots; ++i)
>> list_add_tail(&mm->roots[i]->tmp_link, &dfs);
>>
>> - end = start + size - 1;
>> -
>> do {
>> u64 block_start;
>> u64 block_end;
>> @@ -399,26 +312,26 @@ int drm_buddy_alloc_range(struct drm_buddy_mm *mm,
>>
>> list_del(&block->tmp_link);
>>
>> + if (drm_buddy_block_order(block) < order)
>> + continue;
>> +
>> block_start = drm_buddy_block_offset(block);
>> block_end = block_start + drm_buddy_block_size(mm, block) - 1;
>>
>> if (!overlaps(start, end, block_start, block_end))
>> continue;
>>
>> - if (drm_buddy_block_is_allocated(block)) {
>> - err = -ENOSPC;
>> - goto err_free;
>> - }
>> + if (drm_buddy_block_is_allocated(block))
>> + continue;
>>
>> - if (contains(start, end, block_start, block_end)) {
>> - if (!drm_buddy_block_is_free(block)) {
>> - err = -ENOSPC;
>> - goto err_free;
>> - }
>> + if (contains(start, end, block_start, block_end) &&
>> + order == drm_buddy_block_order(block)) {
>> + /*
>> + * Find the free block within the range.
>> + */
>> + if (drm_buddy_block_is_free(block))
>> + return block;
>
> AFAIK this is still randomly ordered when dealing with actual range
> allocation. Maybe I'm missing something, but it looks like we are just
> repeatedly picking the largest order that fits in the remaining number
> of pages, but it might be the case that the smallest block is for
> example at the start of the range, depending on the layout of the
> address space, which would then only get allocated last.
>
> I think I mentioned this before, but most of the block_trim() looks to
> already do what we want for this case, and could maybe be factored out,
> since that is also just another range allocation, except we start with
> one root node for our "dfs" search.
>
> Maybe something like:
>
> drm_buddy_trim(block, new_size...)
> {
> ....
> mark_free(block);
> list_add(&block->tmp_link, &dfs);
> err = __alloc_range(mm, &dfs, block->start, new_size, ...);
> if (err)
> ....
> }
>
> __drm_buddy_alloc_range(start, size, blocks)
> {
> for_each_root()
> list_add(&root->tmp_link, &dfs);
>
> err = __alloc_range(mm, &dfs, start, size, ...);
> if (err)
> ....
> }
>
> drm_buddy_alloc(...)
> {
> /* Actual range allocation */
> if (start + size == end)
> return __drm_buddy_alloc_range(...);
> ....
> }
>
> And then have something different for the alloc_range_bias()?
>
Yes, we will have a common function __alloc_range() which does the range
allocation for block_trim() and __drm_buddy_alloc_range() (actual range
allocation).
And, I understood that we keep the alloc_range() implementation for end
bias allocations?
>>
>> - mark_allocated(block);
>> - mm->avail -= drm_buddy_block_size(mm, block);
>> - list_add_tail(&block->link, &allocated);
>> continue;
>> }
>>
>> @@ -432,8 +345,7 @@ int drm_buddy_alloc_range(struct drm_buddy_mm *mm,
>> list_add(&block->left->tmp_link, &dfs);
>> } while (1);
>>
>> - list_splice_tail(&allocated, blocks);
>> - return 0;
>> + return ERR_PTR(-ENOSPC);
>>
>> err_undo:
>> /*
>> @@ -446,12 +358,145 @@ int drm_buddy_alloc_range(struct drm_buddy_mm *mm,
>> (drm_buddy_block_is_free(block) &&
>> drm_buddy_block_is_free(buddy)))
>> __drm_buddy_free(mm, block);
>> + return ERR_PTR(err);
>> +}
>> +
>> +static struct drm_buddy_block *
>> +alloc_from_freelist(struct drm_buddy_mm *mm,
>> + unsigned int order,
>> + unsigned long flags)
>> +{
>> + struct drm_buddy_block *block = NULL;
>> + unsigned int i;
>> + int err;
>> +
>> + for (i = order; i <= mm->max_order; ++i) {
>> + block = list_first_entry_or_null(&mm->free_list[i],
>> + struct drm_buddy_block,
>> + link);
>> + if (block)
>> + break;
>> + }
>> +
>> + if (!block)
>> + return ERR_PTR(-ENOSPC);
>> +
>> + BUG_ON(!drm_buddy_block_is_free(block));
>> +
>> + while (i != order) {
>> + err = split_block(mm, block);
>> + if (unlikely(err))
>> + goto err_undo;
>> +
>> + block = block->right;
>> + i--;
>> + }
>> + return block;
>> +
>> +err_undo:
>> + if (i != order)
>> + __drm_buddy_free(mm, block);
>> + return ERR_PTR(err);
>> +}
>> +
>> +/**
>> + * drm_buddy_alloc - allocate power-of-two blocks
>> + *
>> + * @mm: DRM buddy manager to allocate from
>> + * @start: start of the allowed range for this block
>> + * @end: end of the allowed range for this block
>> + * @size: size of the allocation
>> + * @min_page_size: alignment of the allocation
>> + * @blocks: output list head to add allocated blocks
>> + * @flags: DRM_BUDDY_*_ALLOCATION flags
>> + *
>> + * alloc_range() called on range limitations, which traverses
>> + * the tree and returns the desired block.
>> + *
>> + * alloc_from_freelist() called when *no* range restrictions
>> + * are enforced, which picks the block from the freelist.
>> + *
>> + * blocks are allocated in order, the order value here translates to:
>> + *
>> + * 0 = 2^0 * mm->chunk_size
>> + * 1 = 2^1 * mm->chunk_size
>> + * 2 = 2^2 * mm->chunk_size
>> + *
>> + * Returns:
>> + * 0 on success, error code on failure.
>> + */
>> +int drm_buddy_alloc(struct drm_buddy_mm *mm,
>> + u64 start, u64 end, u64 size,
>> + u64 min_page_size,
>> + struct list_head *blocks,
>> + unsigned long flags)
>> +{
>> + struct drm_buddy_block *block = NULL;
>> + unsigned int min_order, order;
>> + unsigned long pages;
>> + LIST_HEAD(allocated);
>> + int err;
>> +
>> + if (size < mm->chunk_size)
>> + return -EINVAL;
>> +
>> + if (min_page_size < mm->chunk_size)
>> + return -EINVAL;
>> +
>> + if (!is_power_of_2(min_page_size))
>> + return -EINVAL;
>> +
>> + if (!IS_ALIGNED(start | end | size, mm->chunk_size))
>> + return -EINVAL;
>> +
>> + if (check_range_overflow(start, end, size, mm->size))
>> + return -EINVAL;
>> +
>> + pages = size >> ilog2(mm->chunk_size);
>> + order = fls(pages) - 1;
>> + min_order = ilog2(min_page_size) - ilog2(mm->chunk_size);
>> +
>> + do {
>> + order = min(order, (unsigned int)fls(pages) - 1);
>> + BUG_ON(order > mm->max_order);
>> + BUG_ON(order < min_order);
>> +
>> + do {
>> + if (flags & DRM_BUDDY_RANGE_ALLOCATION)
>> + /* Allocate traversing within the range */
>> + block = alloc_range(mm, start, end, order);
>> + else
>> + /* Allocate from freelist */
>> + block = alloc_from_freelist(mm, order, flags);
>> +
>> + if (!IS_ERR(block))
>> + break;
>> +
>> + if (order-- == min_order) {
>> + err = -ENOSPC;
>> + goto err_free;
>> + }
>> + } while (1);
>> +
>> + mark_allocated(block);
>> + mm->avail -= drm_buddy_block_size(mm, block);
>> + kmemleak_update_trace(block);
>> + list_add_tail(&block->link, &allocated);
>> +
>> + pages -= BIT(order);
>> +
>> + if (!pages)
>> + break;
>> + } while (1);
>> +
>> + list_splice_tail(&allocated, blocks);
>> + return 0;
>>
>> err_free:
>> drm_buddy_free_list(mm, &allocated);
>> return err;
>> }
>> -EXPORT_SYMBOL(drm_buddy_alloc_range);
>> +EXPORT_SYMBOL(drm_buddy_alloc);
>>
>> /**
>> * drm_buddy_block_print - print block information
>> diff --git a/drivers/gpu/drm/i915/i915_ttm_buddy_manager.c b/drivers/gpu/drm/i915/i915_ttm_buddy_manager.c
>> index c4b70cb8c248..9e3d130c3f42 100644
>> --- a/drivers/gpu/drm/i915/i915_ttm_buddy_manager.c
>> +++ b/drivers/gpu/drm/i915/i915_ttm_buddy_manager.c
>> @@ -36,13 +36,14 @@ static int i915_ttm_buddy_man_alloc(struct ttm_resource_manager *man,
>> struct i915_ttm_buddy_manager *bman = to_buddy_manager(man);
>> struct i915_ttm_buddy_resource *bman_res;
>> struct drm_buddy_mm *mm = &bman->mm;
>> - unsigned long n_pages;
>> - unsigned int min_order;
>> + unsigned long n_pages, lpfn;
>> u64 min_page_size;
>> u64 size;
>> int err;
>>
>> - GEM_BUG_ON(place->fpfn || place->lpfn);
>> + lpfn = place->lpfn;
>> + if (!lpfn)
>> + lpfn = man->size;
>>
>> bman_res = kzalloc(sizeof(*bman_res), GFP_KERNEL);
>> if (!bman_res)
>> @@ -52,6 +53,9 @@ static int i915_ttm_buddy_man_alloc(struct ttm_resource_manager *man,
>> INIT_LIST_HEAD(&bman_res->blocks);
>> bman_res->mm = mm;
>>
>> + if (place->fpfn || lpfn != man->size)
>> + bman_res->flags |= DRM_BUDDY_RANGE_ALLOCATION;
>> +
>> GEM_BUG_ON(!bman_res->base.num_pages);
>> size = bman_res->base.num_pages << PAGE_SHIFT;
>>
>> @@ -60,10 +64,16 @@ static int i915_ttm_buddy_man_alloc(struct ttm_resource_manager *man,
>> min_page_size = bo->page_alignment << PAGE_SHIFT;
>>
>> GEM_BUG_ON(min_page_size < mm->chunk_size);
>> - min_order = ilog2(min_page_size) - ilog2(mm->chunk_size);
>> +
>> if (place->flags & TTM_PL_FLAG_CONTIGUOUS) {
>> + unsigned long pages;
>> +
>> size = roundup_pow_of_two(size);
>> - min_order = ilog2(size) - ilog2(mm->chunk_size);
>> + min_page_size = size;
>> +
>> + pages = size >> ilog2(mm->chunk_size);
>> + if (pages > lpfn)
>> + lpfn = pages;
>> }
>>
>> if (size > mm->size) {
>> @@ -73,34 +83,16 @@ static int i915_ttm_buddy_man_alloc(struct ttm_resource_manager *man,
>>
>> n_pages = size >> ilog2(mm->chunk_size);
>>
>> - do {
>> - struct drm_buddy_block *block;
>> - unsigned int order;
>> -
>> - order = fls(n_pages) - 1;
>> - GEM_BUG_ON(order > mm->max_order);
>> - GEM_BUG_ON(order < min_order);
>> -
>> - do {
>> - mutex_lock(&bman->lock);
>> - block = drm_buddy_alloc(mm, order);
>> - mutex_unlock(&bman->lock);
>> - if (!IS_ERR(block))
>> - break;
>> -
>> - if (order-- == min_order) {
>> - err = -ENOSPC;
>> - goto err_free_blocks;
>> - }
>> - } while (1);
>> -
>> - n_pages -= BIT(order);
>> -
>> - list_add_tail(&block->link, &bman_res->blocks);
>> -
>> - if (!n_pages)
>> - break;
>> - } while (1);
>> + mutex_lock(&bman->lock);
>> + err = drm_buddy_alloc(mm, (u64)place->fpfn << PAGE_SHIFT,
>> + (u64)place->lpfn << PAGE_SHIFT,
>> + (u64)n_pages << PAGE_SHIFT,
>> + min_page_size,
>> + &bman_res->blocks,
>> + bman_res->flags);
>> + mutex_unlock(&bman->lock);
>> + if (unlikely(err))
>> + goto err_free_blocks;
>>
>> *res = &bman_res->base;
>> return 0;
>> @@ -266,10 +258,19 @@ int i915_ttm_buddy_man_reserve(struct ttm_resource_manager *man,
>> {
>> struct i915_ttm_buddy_manager *bman = to_buddy_manager(man);
>> struct drm_buddy_mm *mm = &bman->mm;
>> + unsigned long flags = 0;
>> + u64 min_size;
>> int ret;
>>
>> + min_size = size;
>> + flags |= DRM_BUDDY_RANGE_ALLOCATION;
>> +
>> mutex_lock(&bman->lock);
>> - ret = drm_buddy_alloc_range(mm, &bman->reserved, start, size);
>> + ret = drm_buddy_alloc(mm, start,
>> + start + size,
>> + size, min_size,
>
> min_page_size = min_size = size. I don't think we want that here. Also
> the size here might not be power of two. I guess we need to use
> chunk_size here instead?
ok, we will use chunk_size here.
>
>> + &bman->reserved,
>> + flags);
>> mutex_unlock(&bman->lock);
>>
>> return ret;
>> diff --git a/drivers/gpu/drm/i915/i915_ttm_buddy_manager.h b/drivers/gpu/drm/i915/i915_ttm_buddy_manager.h
>> index fa644b512c2e..5ba490875f66 100644
>> --- a/drivers/gpu/drm/i915/i915_ttm_buddy_manager.h
>> +++ b/drivers/gpu/drm/i915/i915_ttm_buddy_manager.h
>> @@ -20,6 +20,7 @@ struct drm_buddy_mm;
>> *
>> * @base: struct ttm_resource base class we extend
>> * @blocks: the list of struct i915_buddy_block for this resource/allocation
>> + * @flags: DRM_BUDDY_*_ALLOCATION flags
>> * @mm: the struct i915_buddy_mm for this resource
>> *
>> * Extends the struct ttm_resource to manage an address space allocation with
>> @@ -28,6 +29,7 @@ struct drm_buddy_mm;
>> struct i915_ttm_buddy_resource {
>> struct ttm_resource base;
>> struct list_head blocks;
>> + unsigned long flags;
>> struct drm_buddy_mm *mm;
>> };
>>
>> diff --git a/include/drm/drm_buddy.h b/include/drm/drm_buddy.h
>> index 5ce3fc702f80..2ec3cbc9d5d7 100644
>> --- a/include/drm/drm_buddy.h
>> +++ b/include/drm/drm_buddy.h
>> @@ -13,15 +13,22 @@
>>
>> #include <drm/drm_print.h>
>>
>> -#define range_overflows(start, size, max) ({ \
>> +#define check_range_overflow(start, end, size, max) ({ \
>> typeof(start) start__ = (start); \
>> + typeof(end) end__ = (end);\
>> typeof(size) size__ = (size); \
>> typeof(max) max__ = (max); \
>> (void)(&start__ == &size__); \
>> (void)(&start__ == &max__); \
>> - start__ >= max__ || size__ > max__ - start__; \
>> + (void)(&start__ == &end__); \
>> + (void)(&end__ == &size__); \
>> + (void)(&end__ == &max__); \
>> + start__ >= max__ || end__ > max__ || \
>> + size__ > end__ - start__; \
>> })
>>
>> +#define DRM_BUDDY_RANGE_ALLOCATION (1 << 0)
>> +
>> struct drm_buddy_block {
>> #define DRM_BUDDY_HEADER_OFFSET GENMASK_ULL(63, 12)
>> #define DRM_BUDDY_HEADER_STATE GENMASK_ULL(11, 10)
>> @@ -131,12 +138,11 @@ int drm_buddy_init(struct drm_buddy_mm *mm, u64 size, u64 chunk_size);
>>
>> void drm_buddy_fini(struct drm_buddy_mm *mm);
>>
>> -struct drm_buddy_block *
>> -drm_buddy_alloc(struct drm_buddy_mm *mm, unsigned int order);
>> -
>> -int drm_buddy_alloc_range(struct drm_buddy_mm *mm,
>> - struct list_head *blocks,
>> - u64 start, u64 size);
>> +int drm_buddy_alloc(struct drm_buddy_mm *mm,
>> + u64 start, u64 end, u64 size,
>> + u64 min_page_size,
>> + struct list_head *blocks,
>> + unsigned long flags);
>>
>> void drm_buddy_free(struct drm_buddy_mm *mm, struct drm_buddy_block *block);
>>
>>
^ permalink raw reply [flat|nested] 46+ messages in thread
* Re: [PATCH v3 4/6] drm: implement a method to free unused pages
2021-11-17 19:02 ` [Intel-gfx] " Matthew Auld
(?)
@ 2021-11-23 22:40 ` Arunpravin
-1 siblings, 0 replies; 46+ messages in thread
From: Arunpravin @ 2021-11-23 22:40 UTC (permalink / raw)
To: Matthew Auld, dri-devel, intel-gfx, amd-gfx
Cc: alexander.deucher, tzimmermann, christian.koenig
On 18/11/21 12:32 am, Matthew Auld wrote:
> On 16/11/2021 20:18, Arunpravin wrote:
>> On contiguous allocation, we round up the size
>> to the *next* power of 2, implement a function
>> to free the unused pages after the newly allocate block.
>>
>> v2(Matthew Auld):
>> - replace function name 'drm_buddy_free_unused_pages' with
>> drm_buddy_block_trim
>> - replace input argument name 'actual_size' with 'new_size'
>> - add more validation checks for input arguments
>> - add overlaps check to avoid needless searching and splitting
>> - merged the below patch to see the feature in action
>> - add free unused pages support to i915 driver
>> - lock drm_buddy_block_trim() function as it calls mark_free/mark_split
>> are all globally visible
>>
>> Signed-off-by: Arunpravin <Arunpravin.PaneerSelvam@amd.com>
>> ---
>> drivers/gpu/drm/drm_buddy.c | 108 ++++++++++++++++++
>> drivers/gpu/drm/i915/i915_ttm_buddy_manager.c | 10 ++
>> include/drm/drm_buddy.h | 4 +
>> 3 files changed, 122 insertions(+)
>>
>> diff --git a/drivers/gpu/drm/drm_buddy.c b/drivers/gpu/drm/drm_buddy.c
>> index 0a9db2981188..943fe2ad27bf 100644
>> --- a/drivers/gpu/drm/drm_buddy.c
>> +++ b/drivers/gpu/drm/drm_buddy.c
>> @@ -284,6 +284,114 @@ static inline bool contains(u64 s1, u64 e1, u64 s2, u64 e2)
>> return s1 <= s2 && e1 >= e2;
>> }
>>
>> +/**
>> + * drm_buddy_block_trim - free unused pages
>> + *
>> + * @mm: DRM buddy manager
>> + * @new_size: original size requested
>> + * @blocks: output list head to add allocated blocks
>> + *
>> + * For contiguous allocation, we round up the size to the nearest
>> + * power of two value, drivers consume *actual* size, so remaining
>> + * portions are unused and it can be freed.
>> + *
>> + * Returns:
>> + * 0 on success, error code on failure.
>> + */
>> +int drm_buddy_block_trim(struct drm_buddy_mm *mm,
>> + u64 new_size,
>> + struct list_head *blocks)
>> +{
>> + struct drm_buddy_block *block;
>> + struct drm_buddy_block *buddy;
>> + u64 new_start;
>> + u64 new_end;
>> + LIST_HEAD(dfs);
>> + u64 count = 0;
>> + int err;
>> +
>> + if (!list_is_singular(blocks))
>> + return -EINVAL;
>> +
>> + block = list_first_entry(blocks,
>> + struct drm_buddy_block,
>> + link);
>> +
>> + if (!drm_buddy_block_is_allocated(block))
>> + return -EINVAL;
>> +
>> + if (new_size > drm_buddy_block_size(mm, block))
>> + return -EINVAL;
>> +
>> + if (!new_size && !IS_ALIGNED(new_size, mm->chunk_size))
>> + return -EINVAL;
>> +
>> + if (new_size == drm_buddy_block_size(mm, block))
>> + return 0;
>> +
>> + list_del(&block->link);
>> +
>> + new_start = drm_buddy_block_offset(block);
>> + new_end = new_start + new_size - 1;
>> +
>> + mark_free(mm, block);
>> +
>> + list_add(&block->tmp_link, &dfs);
>> +
>> + do {
>> + u64 block_start;
>> + u64 block_end;
>> +
>> + block = list_first_entry_or_null(&dfs,
>> + struct drm_buddy_block,
>> + tmp_link);
>> + if (!block)
>> + break;
>> +
>> + list_del(&block->tmp_link);
>> +
>> + if (count == new_size)
>> + return 0;
>> +
>> + block_start = drm_buddy_block_offset(block);
>> + block_end = block_start + drm_buddy_block_size(mm, block) - 1;
>> +
>> + if (!overlaps(new_start, new_end, block_start, block_end))
>> + continue;
>> +
>> + if (contains(new_start, new_end, block_start, block_end)) {
>> + BUG_ON(!drm_buddy_block_is_free(block));
>> +
>> + /* Allocate only required blocks */
>> + mark_allocated(block);
>> + mm->avail -= drm_buddy_block_size(mm, block);
>> + list_add_tail(&block->link, blocks);
>> + count += drm_buddy_block_size(mm, block);
>> + continue;
>> + }
>> +
>> + if (!drm_buddy_block_is_split(block)) {
>
> Should always be true, right? But I guess depends if we want to re-use
> this for generic range allocation...
yes, since we re-use this for generic range allocation I think we can
keep this check
>
>> + err = split_block(mm, block);
>> + if (unlikely(err))
>> + goto err_undo;
>> + }
>> +
>> + list_add(&block->right->tmp_link, &dfs);
>> + list_add(&block->left->tmp_link, &dfs);
>> + } while (1);
>> +
>> + return -ENOSPC;
>> +
>> +err_undo:
>> + buddy = get_buddy(block);
>> + if (buddy &&
>> + (drm_buddy_block_is_free(block) &&
>> + drm_buddy_block_is_free(buddy)))
>> + __drm_buddy_free(mm, block);
>> + return err;
>
> Looking at the split_block failure path. The user allocated some block,
> and then tried to trim it, but this then marks it as free and removes it
> from their original list(potentially also freeing it), if we fail here.
> Would it be better to leave that decision to the user? If the trim()
> fails, worse case we get some internal fragmentation, and the user might
> be totally fine with that? I guess we could leave as-is, but for sure
> needs some big comment somewhere.
Agreed
would it make sense to add a bool type input argument, so that we can
skip the split_block failure path in case of block_trim().
__alloc_range(mm, &dfs, start, size, ... bool trim)
err = split_block(mm, block);
if (unlikely(err)) {
/* I think we can add big comment here for trim case */
if (trim)
return err;
goto err_undo;
}
>
>> +}
>> +EXPORT_SYMBOL(drm_buddy_block_trim);
>> +
>> static struct drm_buddy_block *
>> alloc_range(struct drm_buddy_mm *mm,
>> u64 start, u64 end,
>> diff --git a/drivers/gpu/drm/i915/i915_ttm_buddy_manager.c b/drivers/gpu/drm/i915/i915_ttm_buddy_manager.c
>> index b6ed5b37cf18..5e1f8c443058 100644
>> --- a/drivers/gpu/drm/i915/i915_ttm_buddy_manager.c
>> +++ b/drivers/gpu/drm/i915/i915_ttm_buddy_manager.c
>> @@ -97,6 +97,16 @@ static int i915_ttm_buddy_man_alloc(struct ttm_resource_manager *man,
>> if (unlikely(err))
>> goto err_free_blocks;
>>
>> + if (place->flags & TTM_PL_FLAG_CONTIGUOUS) {
>> + mutex_lock(&bman->lock);
>> + err = drm_buddy_block_trim(mm,
>> + (u64)n_pages << PAGE_SHIFT,
>> + &bman_res->blocks);
>> + mutex_unlock(&bman->lock);
>> + if (unlikely(err))
>> + goto err_free_blocks;
>
> Yeah, so maybe we could in theory treat this as best effort? But I guess
> unlikely to ever hit this anyway, so meh.
so I understood that we remove the below 2 lines
if (unlikely(err))
goto err_free_blocks;
would it make sense to print a WARN msg
WARN(err < 0, "Trim failed returning %d for ttm_resource(%llu)\n",
err, &bman_res->base);
>
>> + }
>> +
>> *res = &bman_res->base;
>> return 0;
>>
>> diff --git a/include/drm/drm_buddy.h b/include/drm/drm_buddy.h
>> index cbe5e648440a..36e8f548acf7 100644
>> --- a/include/drm/drm_buddy.h
>> +++ b/include/drm/drm_buddy.h
>> @@ -145,6 +145,10 @@ int drm_buddy_alloc(struct drm_buddy_mm *mm,
>> struct list_head *blocks,
>> unsigned long flags);
>>
>> +int drm_buddy_block_trim(struct drm_buddy_mm *mm,
>> + u64 new_size,
>> + struct list_head *blocks);
>> +
>> void drm_buddy_free(struct drm_buddy_mm *mm, struct drm_buddy_block *block);
>>
>> void drm_buddy_free_list(struct drm_buddy_mm *mm, struct list_head *objects);
>>
^ permalink raw reply [flat|nested] 46+ messages in thread
* Re: [PATCH v3 4/6] drm: implement a method to free unused pages
@ 2021-11-23 22:40 ` Arunpravin
0 siblings, 0 replies; 46+ messages in thread
From: Arunpravin @ 2021-11-23 22:40 UTC (permalink / raw)
To: Matthew Auld, dri-devel, intel-gfx, amd-gfx
Cc: alexander.deucher, tzimmermann, jani.nikula, christian.koenig, daniel
On 18/11/21 12:32 am, Matthew Auld wrote:
> On 16/11/2021 20:18, Arunpravin wrote:
>> On contiguous allocation, we round up the size
>> to the *next* power of 2, implement a function
>> to free the unused pages after the newly allocate block.
>>
>> v2(Matthew Auld):
>> - replace function name 'drm_buddy_free_unused_pages' with
>> drm_buddy_block_trim
>> - replace input argument name 'actual_size' with 'new_size'
>> - add more validation checks for input arguments
>> - add overlaps check to avoid needless searching and splitting
>> - merged the below patch to see the feature in action
>> - add free unused pages support to i915 driver
>> - lock drm_buddy_block_trim() function as it calls mark_free/mark_split
>> are all globally visible
>>
>> Signed-off-by: Arunpravin <Arunpravin.PaneerSelvam@amd.com>
>> ---
>> drivers/gpu/drm/drm_buddy.c | 108 ++++++++++++++++++
>> drivers/gpu/drm/i915/i915_ttm_buddy_manager.c | 10 ++
>> include/drm/drm_buddy.h | 4 +
>> 3 files changed, 122 insertions(+)
>>
>> diff --git a/drivers/gpu/drm/drm_buddy.c b/drivers/gpu/drm/drm_buddy.c
>> index 0a9db2981188..943fe2ad27bf 100644
>> --- a/drivers/gpu/drm/drm_buddy.c
>> +++ b/drivers/gpu/drm/drm_buddy.c
>> @@ -284,6 +284,114 @@ static inline bool contains(u64 s1, u64 e1, u64 s2, u64 e2)
>> return s1 <= s2 && e1 >= e2;
>> }
>>
>> +/**
>> + * drm_buddy_block_trim - free unused pages
>> + *
>> + * @mm: DRM buddy manager
>> + * @new_size: original size requested
>> + * @blocks: output list head to add allocated blocks
>> + *
>> + * For contiguous allocation, we round up the size to the nearest
>> + * power of two value, drivers consume *actual* size, so remaining
>> + * portions are unused and it can be freed.
>> + *
>> + * Returns:
>> + * 0 on success, error code on failure.
>> + */
>> +int drm_buddy_block_trim(struct drm_buddy_mm *mm,
>> + u64 new_size,
>> + struct list_head *blocks)
>> +{
>> + struct drm_buddy_block *block;
>> + struct drm_buddy_block *buddy;
>> + u64 new_start;
>> + u64 new_end;
>> + LIST_HEAD(dfs);
>> + u64 count = 0;
>> + int err;
>> +
>> + if (!list_is_singular(blocks))
>> + return -EINVAL;
>> +
>> + block = list_first_entry(blocks,
>> + struct drm_buddy_block,
>> + link);
>> +
>> + if (!drm_buddy_block_is_allocated(block))
>> + return -EINVAL;
>> +
>> + if (new_size > drm_buddy_block_size(mm, block))
>> + return -EINVAL;
>> +
>> + if (!new_size && !IS_ALIGNED(new_size, mm->chunk_size))
>> + return -EINVAL;
>> +
>> + if (new_size == drm_buddy_block_size(mm, block))
>> + return 0;
>> +
>> + list_del(&block->link);
>> +
>> + new_start = drm_buddy_block_offset(block);
>> + new_end = new_start + new_size - 1;
>> +
>> + mark_free(mm, block);
>> +
>> + list_add(&block->tmp_link, &dfs);
>> +
>> + do {
>> + u64 block_start;
>> + u64 block_end;
>> +
>> + block = list_first_entry_or_null(&dfs,
>> + struct drm_buddy_block,
>> + tmp_link);
>> + if (!block)
>> + break;
>> +
>> + list_del(&block->tmp_link);
>> +
>> + if (count == new_size)
>> + return 0;
>> +
>> + block_start = drm_buddy_block_offset(block);
>> + block_end = block_start + drm_buddy_block_size(mm, block) - 1;
>> +
>> + if (!overlaps(new_start, new_end, block_start, block_end))
>> + continue;
>> +
>> + if (contains(new_start, new_end, block_start, block_end)) {
>> + BUG_ON(!drm_buddy_block_is_free(block));
>> +
>> + /* Allocate only required blocks */
>> + mark_allocated(block);
>> + mm->avail -= drm_buddy_block_size(mm, block);
>> + list_add_tail(&block->link, blocks);
>> + count += drm_buddy_block_size(mm, block);
>> + continue;
>> + }
>> +
>> + if (!drm_buddy_block_is_split(block)) {
>
> Should always be true, right? But I guess depends if we want to re-use
> this for generic range allocation...
yes, since we re-use this for generic range allocation I think we can
keep this check
>
>> + err = split_block(mm, block);
>> + if (unlikely(err))
>> + goto err_undo;
>> + }
>> +
>> + list_add(&block->right->tmp_link, &dfs);
>> + list_add(&block->left->tmp_link, &dfs);
>> + } while (1);
>> +
>> + return -ENOSPC;
>> +
>> +err_undo:
>> + buddy = get_buddy(block);
>> + if (buddy &&
>> + (drm_buddy_block_is_free(block) &&
>> + drm_buddy_block_is_free(buddy)))
>> + __drm_buddy_free(mm, block);
>> + return err;
>
> Looking at the split_block failure path. The user allocated some block,
> and then tried to trim it, but this then marks it as free and removes it
> from their original list(potentially also freeing it), if we fail here.
> Would it be better to leave that decision to the user? If the trim()
> fails, worse case we get some internal fragmentation, and the user might
> be totally fine with that? I guess we could leave as-is, but for sure
> needs some big comment somewhere.
Agreed
would it make sense to add a bool type input argument, so that we can
skip the split_block failure path in case of block_trim().
__alloc_range(mm, &dfs, start, size, ... bool trim)
err = split_block(mm, block);
if (unlikely(err)) {
/* I think we can add big comment here for trim case */
if (trim)
return err;
goto err_undo;
}
>
>> +}
>> +EXPORT_SYMBOL(drm_buddy_block_trim);
>> +
>> static struct drm_buddy_block *
>> alloc_range(struct drm_buddy_mm *mm,
>> u64 start, u64 end,
>> diff --git a/drivers/gpu/drm/i915/i915_ttm_buddy_manager.c b/drivers/gpu/drm/i915/i915_ttm_buddy_manager.c
>> index b6ed5b37cf18..5e1f8c443058 100644
>> --- a/drivers/gpu/drm/i915/i915_ttm_buddy_manager.c
>> +++ b/drivers/gpu/drm/i915/i915_ttm_buddy_manager.c
>> @@ -97,6 +97,16 @@ static int i915_ttm_buddy_man_alloc(struct ttm_resource_manager *man,
>> if (unlikely(err))
>> goto err_free_blocks;
>>
>> + if (place->flags & TTM_PL_FLAG_CONTIGUOUS) {
>> + mutex_lock(&bman->lock);
>> + err = drm_buddy_block_trim(mm,
>> + (u64)n_pages << PAGE_SHIFT,
>> + &bman_res->blocks);
>> + mutex_unlock(&bman->lock);
>> + if (unlikely(err))
>> + goto err_free_blocks;
>
> Yeah, so maybe we could in theory treat this as best effort? But I guess
> unlikely to ever hit this anyway, so meh.
so I understood that we remove the below 2 lines
if (unlikely(err))
goto err_free_blocks;
would it make sense to print a WARN msg
WARN(err < 0, "Trim failed returning %d for ttm_resource(%llu)\n",
err, &bman_res->base);
>
>> + }
>> +
>> *res = &bman_res->base;
>> return 0;
>>
>> diff --git a/include/drm/drm_buddy.h b/include/drm/drm_buddy.h
>> index cbe5e648440a..36e8f548acf7 100644
>> --- a/include/drm/drm_buddy.h
>> +++ b/include/drm/drm_buddy.h
>> @@ -145,6 +145,10 @@ int drm_buddy_alloc(struct drm_buddy_mm *mm,
>> struct list_head *blocks,
>> unsigned long flags);
>>
>> +int drm_buddy_block_trim(struct drm_buddy_mm *mm,
>> + u64 new_size,
>> + struct list_head *blocks);
>> +
>> void drm_buddy_free(struct drm_buddy_mm *mm, struct drm_buddy_block *block);
>>
>> void drm_buddy_free_list(struct drm_buddy_mm *mm, struct list_head *objects);
>>
^ permalink raw reply [flat|nested] 46+ messages in thread
* Re: [Intel-gfx] [PATCH v3 4/6] drm: implement a method to free unused pages
@ 2021-11-23 22:40 ` Arunpravin
0 siblings, 0 replies; 46+ messages in thread
From: Arunpravin @ 2021-11-23 22:40 UTC (permalink / raw)
To: Matthew Auld, dri-devel, intel-gfx, amd-gfx
Cc: alexander.deucher, tzimmermann, christian.koenig
On 18/11/21 12:32 am, Matthew Auld wrote:
> On 16/11/2021 20:18, Arunpravin wrote:
>> On contiguous allocation, we round up the size
>> to the *next* power of 2, implement a function
>> to free the unused pages after the newly allocate block.
>>
>> v2(Matthew Auld):
>> - replace function name 'drm_buddy_free_unused_pages' with
>> drm_buddy_block_trim
>> - replace input argument name 'actual_size' with 'new_size'
>> - add more validation checks for input arguments
>> - add overlaps check to avoid needless searching and splitting
>> - merged the below patch to see the feature in action
>> - add free unused pages support to i915 driver
>> - lock drm_buddy_block_trim() function as it calls mark_free/mark_split
>> are all globally visible
>>
>> Signed-off-by: Arunpravin <Arunpravin.PaneerSelvam@amd.com>
>> ---
>> drivers/gpu/drm/drm_buddy.c | 108 ++++++++++++++++++
>> drivers/gpu/drm/i915/i915_ttm_buddy_manager.c | 10 ++
>> include/drm/drm_buddy.h | 4 +
>> 3 files changed, 122 insertions(+)
>>
>> diff --git a/drivers/gpu/drm/drm_buddy.c b/drivers/gpu/drm/drm_buddy.c
>> index 0a9db2981188..943fe2ad27bf 100644
>> --- a/drivers/gpu/drm/drm_buddy.c
>> +++ b/drivers/gpu/drm/drm_buddy.c
>> @@ -284,6 +284,114 @@ static inline bool contains(u64 s1, u64 e1, u64 s2, u64 e2)
>> return s1 <= s2 && e1 >= e2;
>> }
>>
>> +/**
>> + * drm_buddy_block_trim - free unused pages
>> + *
>> + * @mm: DRM buddy manager
>> + * @new_size: original size requested
>> + * @blocks: output list head to add allocated blocks
>> + *
>> + * For contiguous allocation, we round up the size to the nearest
>> + * power of two value, drivers consume *actual* size, so remaining
>> + * portions are unused and it can be freed.
>> + *
>> + * Returns:
>> + * 0 on success, error code on failure.
>> + */
>> +int drm_buddy_block_trim(struct drm_buddy_mm *mm,
>> + u64 new_size,
>> + struct list_head *blocks)
>> +{
>> + struct drm_buddy_block *block;
>> + struct drm_buddy_block *buddy;
>> + u64 new_start;
>> + u64 new_end;
>> + LIST_HEAD(dfs);
>> + u64 count = 0;
>> + int err;
>> +
>> + if (!list_is_singular(blocks))
>> + return -EINVAL;
>> +
>> + block = list_first_entry(blocks,
>> + struct drm_buddy_block,
>> + link);
>> +
>> + if (!drm_buddy_block_is_allocated(block))
>> + return -EINVAL;
>> +
>> + if (new_size > drm_buddy_block_size(mm, block))
>> + return -EINVAL;
>> +
>> + if (!new_size && !IS_ALIGNED(new_size, mm->chunk_size))
>> + return -EINVAL;
>> +
>> + if (new_size == drm_buddy_block_size(mm, block))
>> + return 0;
>> +
>> + list_del(&block->link);
>> +
>> + new_start = drm_buddy_block_offset(block);
>> + new_end = new_start + new_size - 1;
>> +
>> + mark_free(mm, block);
>> +
>> + list_add(&block->tmp_link, &dfs);
>> +
>> + do {
>> + u64 block_start;
>> + u64 block_end;
>> +
>> + block = list_first_entry_or_null(&dfs,
>> + struct drm_buddy_block,
>> + tmp_link);
>> + if (!block)
>> + break;
>> +
>> + list_del(&block->tmp_link);
>> +
>> + if (count == new_size)
>> + return 0;
>> +
>> + block_start = drm_buddy_block_offset(block);
>> + block_end = block_start + drm_buddy_block_size(mm, block) - 1;
>> +
>> + if (!overlaps(new_start, new_end, block_start, block_end))
>> + continue;
>> +
>> + if (contains(new_start, new_end, block_start, block_end)) {
>> + BUG_ON(!drm_buddy_block_is_free(block));
>> +
>> + /* Allocate only required blocks */
>> + mark_allocated(block);
>> + mm->avail -= drm_buddy_block_size(mm, block);
>> + list_add_tail(&block->link, blocks);
>> + count += drm_buddy_block_size(mm, block);
>> + continue;
>> + }
>> +
>> + if (!drm_buddy_block_is_split(block)) {
>
> Should always be true, right? But I guess depends if we want to re-use
> this for generic range allocation...
yes, since we re-use this for generic range allocation I think we can
keep this check
>
>> + err = split_block(mm, block);
>> + if (unlikely(err))
>> + goto err_undo;
>> + }
>> +
>> + list_add(&block->right->tmp_link, &dfs);
>> + list_add(&block->left->tmp_link, &dfs);
>> + } while (1);
>> +
>> + return -ENOSPC;
>> +
>> +err_undo:
>> + buddy = get_buddy(block);
>> + if (buddy &&
>> + (drm_buddy_block_is_free(block) &&
>> + drm_buddy_block_is_free(buddy)))
>> + __drm_buddy_free(mm, block);
>> + return err;
>
> Looking at the split_block failure path. The user allocated some block,
> and then tried to trim it, but this then marks it as free and removes it
> from their original list(potentially also freeing it), if we fail here.
> Would it be better to leave that decision to the user? If the trim()
> fails, worse case we get some internal fragmentation, and the user might
> be totally fine with that? I guess we could leave as-is, but for sure
> needs some big comment somewhere.
Agreed
would it make sense to add a bool type input argument, so that we can
skip the split_block failure path in case of block_trim().
__alloc_range(mm, &dfs, start, size, ... bool trim)
err = split_block(mm, block);
if (unlikely(err)) {
/* I think we can add big comment here for trim case */
if (trim)
return err;
goto err_undo;
}
>
>> +}
>> +EXPORT_SYMBOL(drm_buddy_block_trim);
>> +
>> static struct drm_buddy_block *
>> alloc_range(struct drm_buddy_mm *mm,
>> u64 start, u64 end,
>> diff --git a/drivers/gpu/drm/i915/i915_ttm_buddy_manager.c b/drivers/gpu/drm/i915/i915_ttm_buddy_manager.c
>> index b6ed5b37cf18..5e1f8c443058 100644
>> --- a/drivers/gpu/drm/i915/i915_ttm_buddy_manager.c
>> +++ b/drivers/gpu/drm/i915/i915_ttm_buddy_manager.c
>> @@ -97,6 +97,16 @@ static int i915_ttm_buddy_man_alloc(struct ttm_resource_manager *man,
>> if (unlikely(err))
>> goto err_free_blocks;
>>
>> + if (place->flags & TTM_PL_FLAG_CONTIGUOUS) {
>> + mutex_lock(&bman->lock);
>> + err = drm_buddy_block_trim(mm,
>> + (u64)n_pages << PAGE_SHIFT,
>> + &bman_res->blocks);
>> + mutex_unlock(&bman->lock);
>> + if (unlikely(err))
>> + goto err_free_blocks;
>
> Yeah, so maybe we could in theory treat this as best effort? But I guess
> unlikely to ever hit this anyway, so meh.
so I understood that we remove the below 2 lines
if (unlikely(err))
goto err_free_blocks;
would it make sense to print a WARN msg
WARN(err < 0, "Trim failed returning %d for ttm_resource(%llu)\n",
err, &bman_res->base);
>
>> + }
>> +
>> *res = &bman_res->base;
>> return 0;
>>
>> diff --git a/include/drm/drm_buddy.h b/include/drm/drm_buddy.h
>> index cbe5e648440a..36e8f548acf7 100644
>> --- a/include/drm/drm_buddy.h
>> +++ b/include/drm/drm_buddy.h
>> @@ -145,6 +145,10 @@ int drm_buddy_alloc(struct drm_buddy_mm *mm,
>> struct list_head *blocks,
>> unsigned long flags);
>>
>> +int drm_buddy_block_trim(struct drm_buddy_mm *mm,
>> + u64 new_size,
>> + struct list_head *blocks);
>> +
>> void drm_buddy_free(struct drm_buddy_mm *mm, struct drm_buddy_block *block);
>>
>> void drm_buddy_free_list(struct drm_buddy_mm *mm, struct list_head *objects);
>>
^ permalink raw reply [flat|nested] 46+ messages in thread
* Re: [PATCH v3 2/6] drm: improve drm_buddy_alloc function
2021-11-23 22:39 ` Arunpravin
(?)
@ 2021-11-24 10:33 ` Matthew Auld
-1 siblings, 0 replies; 46+ messages in thread
From: Matthew Auld @ 2021-11-24 10:33 UTC (permalink / raw)
To: Arunpravin, dri-devel, intel-gfx, amd-gfx
Cc: alexander.deucher, tzimmermann, christian.koenig
On 23/11/2021 22:39, Arunpravin wrote:
>
>
> On 18/11/21 12:09 am, Matthew Auld wrote:
>> On 16/11/2021 20:18, Arunpravin wrote:
>>> - Make drm_buddy_alloc a single function to handle
>>> range allocation and non-range allocation demands
>>>
>>> - Implemented a new function alloc_range() which allocates
>>> the requested power-of-two block comply with range limitations
>>>
>>> - Moved order computation and memory alignment logic from
>>> i915 driver to drm buddy
>>>
>>> v2:
>>> merged below changes to keep the build unbroken
>>> - drm_buddy_alloc_range() becomes obsolete and may be removed
>>> - enable ttm range allocation (fpfn / lpfn) support in i915 driver
>>> - apply enhanced drm_buddy_alloc() function to i915 driver
>>>
>>> v3(Matthew Auld):
>>> - Fix alignment issues and remove unnecessary list_empty check
>>> - add more validation checks for input arguments
>>> - make alloc_range() block allocations as bottom-up
>>> - optimize order computation logic
>>> - replace uint64_t with u64, which is preferred in the kernel
>>>
>>> Signed-off-by: Arunpravin <Arunpravin.PaneerSelvam@amd.com>
>>> ---
>>> drivers/gpu/drm/drm_buddy.c | 259 ++++++++++--------
>>> drivers/gpu/drm/i915/i915_ttm_buddy_manager.c | 69 ++---
>>> drivers/gpu/drm/i915/i915_ttm_buddy_manager.h | 2 +
>>> include/drm/drm_buddy.h | 22 +-
>>> 4 files changed, 203 insertions(+), 149 deletions(-)
>>>
>>> diff --git a/drivers/gpu/drm/drm_buddy.c b/drivers/gpu/drm/drm_buddy.c
>>> index 39eb1d224bec..c9b18a29f8d1 100644
>>> --- a/drivers/gpu/drm/drm_buddy.c
>>> +++ b/drivers/gpu/drm/drm_buddy.c
>>> @@ -274,63 +274,6 @@ void drm_buddy_free_list(struct drm_buddy_mm *mm, struct list_head *objects)
>>> }
>>> EXPORT_SYMBOL(drm_buddy_free_list);
>>>
>>> -/**
>>> - * drm_buddy_alloc - allocate power-of-two blocks
>>> - *
>>> - * @mm: DRM buddy manager to allocate from
>>> - * @order: size of the allocation
>>> - *
>>> - * The order value here translates to:
>>> - *
>>> - * 0 = 2^0 * mm->chunk_size
>>> - * 1 = 2^1 * mm->chunk_size
>>> - * 2 = 2^2 * mm->chunk_size
>>> - *
>>> - * Returns:
>>> - * allocated ptr to the &drm_buddy_block on success
>>> - */
>>> -struct drm_buddy_block *
>>> -drm_buddy_alloc(struct drm_buddy_mm *mm, unsigned int order)
>>> -{
>>> - struct drm_buddy_block *block = NULL;
>>> - unsigned int i;
>>> - int err;
>>> -
>>> - for (i = order; i <= mm->max_order; ++i) {
>>> - block = list_first_entry_or_null(&mm->free_list[i],
>>> - struct drm_buddy_block,
>>> - link);
>>> - if (block)
>>> - break;
>>> - }
>>> -
>>> - if (!block)
>>> - return ERR_PTR(-ENOSPC);
>>> -
>>> - BUG_ON(!drm_buddy_block_is_free(block));
>>> -
>>> - while (i != order) {
>>> - err = split_block(mm, block);
>>> - if (unlikely(err))
>>> - goto out_free;
>>> -
>>> - /* Go low */
>>> - block = block->left;
>>> - i--;
>>> - }
>>> -
>>> - mark_allocated(block);
>>> - mm->avail -= drm_buddy_block_size(mm, block);
>>> - kmemleak_update_trace(block);
>>> - return block;
>>> -
>>> -out_free:
>>> - if (i != order)
>>> - __drm_buddy_free(mm, block);
>>> - return ERR_PTR(err);
>>> -}
>>> -EXPORT_SYMBOL(drm_buddy_alloc);
>>> -
>>> static inline bool overlaps(u64 s1, u64 e1, u64 s2, u64 e2)
>>> {
>>> return s1 <= e2 && e1 >= s2;
>>> @@ -341,52 +284,22 @@ static inline bool contains(u64 s1, u64 e1, u64 s2, u64 e2)
>>> return s1 <= s2 && e1 >= e2;
>>> }
>>>
>>> -/**
>>> - * drm_buddy_alloc_range - allocate range
>>> - *
>>> - * @mm: DRM buddy manager to allocate from
>>> - * @blocks: output list head to add allocated blocks
>>> - * @start: start of the allowed range for this block
>>> - * @size: size of the allocation
>>> - *
>>> - * Intended for pre-allocating portions of the address space, for example to
>>> - * reserve a block for the initial framebuffer or similar, hence the expectation
>>> - * here is that drm_buddy_alloc() is still the main vehicle for
>>> - * allocations, so if that's not the case then the drm_mm range allocator is
>>> - * probably a much better fit, and so you should probably go use that instead.
>>> - *
>>> - * Note that it's safe to chain together multiple alloc_ranges
>>> - * with the same blocks list
>>> - *
>>> - * Returns:
>>> - * 0 on success, error code on failure.
>>> - */
>>> -int drm_buddy_alloc_range(struct drm_buddy_mm *mm,
>>> - struct list_head *blocks,
>>> - u64 start, u64 size)
>>> +static struct drm_buddy_block *
>>> +alloc_range(struct drm_buddy_mm *mm,
>>> + u64 start, u64 end,
>>> + unsigned int order)
>>> {
>>> struct drm_buddy_block *block;
>>> struct drm_buddy_block *buddy;
>>> - LIST_HEAD(allocated);
>>> LIST_HEAD(dfs);
>>> - u64 end;
>>> int err;
>>> int i;
>>>
>>> - if (size < mm->chunk_size)
>>> - return -EINVAL;
>>> -
>>> - if (!IS_ALIGNED(size | start, mm->chunk_size))
>>> - return -EINVAL;
>>> -
>>> - if (range_overflows(start, size, mm->size))
>>> - return -EINVAL;
>>> + end = end - 1;
>>>
>>> for (i = 0; i < mm->n_roots; ++i)
>>> list_add_tail(&mm->roots[i]->tmp_link, &dfs);
>>>
>>> - end = start + size - 1;
>>> -
>>> do {
>>> u64 block_start;
>>> u64 block_end;
>>> @@ -399,26 +312,26 @@ int drm_buddy_alloc_range(struct drm_buddy_mm *mm,
>>>
>>> list_del(&block->tmp_link);
>>>
>>> + if (drm_buddy_block_order(block) < order)
>>> + continue;
>>> +
>>> block_start = drm_buddy_block_offset(block);
>>> block_end = block_start + drm_buddy_block_size(mm, block) - 1;
>>>
>>> if (!overlaps(start, end, block_start, block_end))
>>> continue;
>>>
>>> - if (drm_buddy_block_is_allocated(block)) {
>>> - err = -ENOSPC;
>>> - goto err_free;
>>> - }
>>> + if (drm_buddy_block_is_allocated(block))
>>> + continue;
>>>
>>> - if (contains(start, end, block_start, block_end)) {
>>> - if (!drm_buddy_block_is_free(block)) {
>>> - err = -ENOSPC;
>>> - goto err_free;
>>> - }
>>> + if (contains(start, end, block_start, block_end) &&
>>> + order == drm_buddy_block_order(block)) {
>>> + /*
>>> + * Find the free block within the range.
>>> + */
>>> + if (drm_buddy_block_is_free(block))
>>> + return block;
>>
>> AFAIK this is still randomly ordered when dealing with actual range
>> allocation. Maybe I'm missing something, but it looks like we are just
>> repeatedly picking the largest order that fits in the remaining number
>> of pages, but it might be the case that the smallest block is for
>> example at the start of the range, depending on the layout of the
>> address space, which would then only get allocated last.
>>
>> I think I mentioned this before, but most of the block_trim() looks to
>> already do what we want for this case, and could maybe be factored out,
>> since that is also just another range allocation, except we start with
>> one root node for our "dfs" search.
>>
>> Maybe something like:
>>
>> drm_buddy_trim(block, new_size...)
>> {
>> ....
>> mark_free(block);
>> list_add(&block->tmp_link, &dfs);
>> err = __alloc_range(mm, &dfs, block->start, new_size, ...);
>> if (err)
>> ....
>> }
>>
>> __drm_buddy_alloc_range(start, size, blocks)
>> {
>> for_each_root()
>> list_add(&root->tmp_link, &dfs);
>>
>> err = __alloc_range(mm, &dfs, start, size, ...);
>> if (err)
>> ....
>> }
>>
>> drm_buddy_alloc(...)
>> {
>> /* Actual range allocation */
>> if (start + size == end)
>> return __drm_buddy_alloc_range(...);
>> ....
>> }
>>
>> And then have something different for the alloc_range_bias()?
>>
> Yes, we will have a common function __alloc_range() which does the range
> allocation for block_trim() and __drm_buddy_alloc_range() (actual range
> allocation).
>
> And, I understood that we keep the alloc_range() implementation for end
> bias allocations?
Yeah, I think that makes sense.
>
>>>
>>> - mark_allocated(block);
>>> - mm->avail -= drm_buddy_block_size(mm, block);
>>> - list_add_tail(&block->link, &allocated);
>>> continue;
>>> }
>>>
>>> @@ -432,8 +345,7 @@ int drm_buddy_alloc_range(struct drm_buddy_mm *mm,
>>> list_add(&block->left->tmp_link, &dfs);
>>> } while (1);
>>>
>>> - list_splice_tail(&allocated, blocks);
>>> - return 0;
>>> + return ERR_PTR(-ENOSPC);
>>>
>>> err_undo:
>>> /*
>>> @@ -446,12 +358,145 @@ int drm_buddy_alloc_range(struct drm_buddy_mm *mm,
>>> (drm_buddy_block_is_free(block) &&
>>> drm_buddy_block_is_free(buddy)))
>>> __drm_buddy_free(mm, block);
>>> + return ERR_PTR(err);
>>> +}
>>> +
>>> +static struct drm_buddy_block *
>>> +alloc_from_freelist(struct drm_buddy_mm *mm,
>>> + unsigned int order,
>>> + unsigned long flags)
>>> +{
>>> + struct drm_buddy_block *block = NULL;
>>> + unsigned int i;
>>> + int err;
>>> +
>>> + for (i = order; i <= mm->max_order; ++i) {
>>> + block = list_first_entry_or_null(&mm->free_list[i],
>>> + struct drm_buddy_block,
>>> + link);
>>> + if (block)
>>> + break;
>>> + }
>>> +
>>> + if (!block)
>>> + return ERR_PTR(-ENOSPC);
>>> +
>>> + BUG_ON(!drm_buddy_block_is_free(block));
>>> +
>>> + while (i != order) {
>>> + err = split_block(mm, block);
>>> + if (unlikely(err))
>>> + goto err_undo;
>>> +
>>> + block = block->right;
>>> + i--;
>>> + }
>>> + return block;
>>> +
>>> +err_undo:
>>> + if (i != order)
>>> + __drm_buddy_free(mm, block);
>>> + return ERR_PTR(err);
>>> +}
>>> +
>>> +/**
>>> + * drm_buddy_alloc - allocate power-of-two blocks
>>> + *
>>> + * @mm: DRM buddy manager to allocate from
>>> + * @start: start of the allowed range for this block
>>> + * @end: end of the allowed range for this block
>>> + * @size: size of the allocation
>>> + * @min_page_size: alignment of the allocation
>>> + * @blocks: output list head to add allocated blocks
>>> + * @flags: DRM_BUDDY_*_ALLOCATION flags
>>> + *
>>> + * alloc_range() called on range limitations, which traverses
>>> + * the tree and returns the desired block.
>>> + *
>>> + * alloc_from_freelist() called when *no* range restrictions
>>> + * are enforced, which picks the block from the freelist.
>>> + *
>>> + * blocks are allocated in order, the order value here translates to:
>>> + *
>>> + * 0 = 2^0 * mm->chunk_size
>>> + * 1 = 2^1 * mm->chunk_size
>>> + * 2 = 2^2 * mm->chunk_size
>>> + *
>>> + * Returns:
>>> + * 0 on success, error code on failure.
>>> + */
>>> +int drm_buddy_alloc(struct drm_buddy_mm *mm,
>>> + u64 start, u64 end, u64 size,
>>> + u64 min_page_size,
>>> + struct list_head *blocks,
>>> + unsigned long flags)
>>> +{
>>> + struct drm_buddy_block *block = NULL;
>>> + unsigned int min_order, order;
>>> + unsigned long pages;
>>> + LIST_HEAD(allocated);
>>> + int err;
>>> +
>>> + if (size < mm->chunk_size)
>>> + return -EINVAL;
>>> +
>>> + if (min_page_size < mm->chunk_size)
>>> + return -EINVAL;
>>> +
>>> + if (!is_power_of_2(min_page_size))
>>> + return -EINVAL;
>>> +
>>> + if (!IS_ALIGNED(start | end | size, mm->chunk_size))
>>> + return -EINVAL;
>>> +
>>> + if (check_range_overflow(start, end, size, mm->size))
>>> + return -EINVAL;
>>> +
>>> + pages = size >> ilog2(mm->chunk_size);
>>> + order = fls(pages) - 1;
>>> + min_order = ilog2(min_page_size) - ilog2(mm->chunk_size);
>>> +
>>> + do {
>>> + order = min(order, (unsigned int)fls(pages) - 1);
>>> + BUG_ON(order > mm->max_order);
>>> + BUG_ON(order < min_order);
>>> +
>>> + do {
>>> + if (flags & DRM_BUDDY_RANGE_ALLOCATION)
>>> + /* Allocate traversing within the range */
>>> + block = alloc_range(mm, start, end, order);
>>> + else
>>> + /* Allocate from freelist */
>>> + block = alloc_from_freelist(mm, order, flags);
>>> +
>>> + if (!IS_ERR(block))
>>> + break;
>>> +
>>> + if (order-- == min_order) {
>>> + err = -ENOSPC;
>>> + goto err_free;
>>> + }
>>> + } while (1);
>>> +
>>> + mark_allocated(block);
>>> + mm->avail -= drm_buddy_block_size(mm, block);
>>> + kmemleak_update_trace(block);
>>> + list_add_tail(&block->link, &allocated);
>>> +
>>> + pages -= BIT(order);
>>> +
>>> + if (!pages)
>>> + break;
>>> + } while (1);
>>> +
>>> + list_splice_tail(&allocated, blocks);
>>> + return 0;
>>>
>>> err_free:
>>> drm_buddy_free_list(mm, &allocated);
>>> return err;
>>> }
>>> -EXPORT_SYMBOL(drm_buddy_alloc_range);
>>> +EXPORT_SYMBOL(drm_buddy_alloc);
>>>
>>> /**
>>> * drm_buddy_block_print - print block information
>>> diff --git a/drivers/gpu/drm/i915/i915_ttm_buddy_manager.c b/drivers/gpu/drm/i915/i915_ttm_buddy_manager.c
>>> index c4b70cb8c248..9e3d130c3f42 100644
>>> --- a/drivers/gpu/drm/i915/i915_ttm_buddy_manager.c
>>> +++ b/drivers/gpu/drm/i915/i915_ttm_buddy_manager.c
>>> @@ -36,13 +36,14 @@ static int i915_ttm_buddy_man_alloc(struct ttm_resource_manager *man,
>>> struct i915_ttm_buddy_manager *bman = to_buddy_manager(man);
>>> struct i915_ttm_buddy_resource *bman_res;
>>> struct drm_buddy_mm *mm = &bman->mm;
>>> - unsigned long n_pages;
>>> - unsigned int min_order;
>>> + unsigned long n_pages, lpfn;
>>> u64 min_page_size;
>>> u64 size;
>>> int err;
>>>
>>> - GEM_BUG_ON(place->fpfn || place->lpfn);
>>> + lpfn = place->lpfn;
>>> + if (!lpfn)
>>> + lpfn = man->size;
>>>
>>> bman_res = kzalloc(sizeof(*bman_res), GFP_KERNEL);
>>> if (!bman_res)
>>> @@ -52,6 +53,9 @@ static int i915_ttm_buddy_man_alloc(struct ttm_resource_manager *man,
>>> INIT_LIST_HEAD(&bman_res->blocks);
>>> bman_res->mm = mm;
>>>
>>> + if (place->fpfn || lpfn != man->size)
>>> + bman_res->flags |= DRM_BUDDY_RANGE_ALLOCATION;
>>> +
>>> GEM_BUG_ON(!bman_res->base.num_pages);
>>> size = bman_res->base.num_pages << PAGE_SHIFT;
>>>
>>> @@ -60,10 +64,16 @@ static int i915_ttm_buddy_man_alloc(struct ttm_resource_manager *man,
>>> min_page_size = bo->page_alignment << PAGE_SHIFT;
>>>
>>> GEM_BUG_ON(min_page_size < mm->chunk_size);
>>> - min_order = ilog2(min_page_size) - ilog2(mm->chunk_size);
>>> +
>>> if (place->flags & TTM_PL_FLAG_CONTIGUOUS) {
>>> + unsigned long pages;
>>> +
>>> size = roundup_pow_of_two(size);
>>> - min_order = ilog2(size) - ilog2(mm->chunk_size);
>>> + min_page_size = size;
>>> +
>>> + pages = size >> ilog2(mm->chunk_size);
>>> + if (pages > lpfn)
>>> + lpfn = pages;
>>> }
>>>
>>> if (size > mm->size) {
>>> @@ -73,34 +83,16 @@ static int i915_ttm_buddy_man_alloc(struct ttm_resource_manager *man,
>>>
>>> n_pages = size >> ilog2(mm->chunk_size);
>>>
>>> - do {
>>> - struct drm_buddy_block *block;
>>> - unsigned int order;
>>> -
>>> - order = fls(n_pages) - 1;
>>> - GEM_BUG_ON(order > mm->max_order);
>>> - GEM_BUG_ON(order < min_order);
>>> -
>>> - do {
>>> - mutex_lock(&bman->lock);
>>> - block = drm_buddy_alloc(mm, order);
>>> - mutex_unlock(&bman->lock);
>>> - if (!IS_ERR(block))
>>> - break;
>>> -
>>> - if (order-- == min_order) {
>>> - err = -ENOSPC;
>>> - goto err_free_blocks;
>>> - }
>>> - } while (1);
>>> -
>>> - n_pages -= BIT(order);
>>> -
>>> - list_add_tail(&block->link, &bman_res->blocks);
>>> -
>>> - if (!n_pages)
>>> - break;
>>> - } while (1);
>>> + mutex_lock(&bman->lock);
>>> + err = drm_buddy_alloc(mm, (u64)place->fpfn << PAGE_SHIFT,
>>> + (u64)place->lpfn << PAGE_SHIFT,
>>> + (u64)n_pages << PAGE_SHIFT,
>>> + min_page_size,
>>> + &bman_res->blocks,
>>> + bman_res->flags);
>>> + mutex_unlock(&bman->lock);
>>> + if (unlikely(err))
>>> + goto err_free_blocks;
>>>
>>> *res = &bman_res->base;
>>> return 0;
>>> @@ -266,10 +258,19 @@ int i915_ttm_buddy_man_reserve(struct ttm_resource_manager *man,
>>> {
>>> struct i915_ttm_buddy_manager *bman = to_buddy_manager(man);
>>> struct drm_buddy_mm *mm = &bman->mm;
>>> + unsigned long flags = 0;
>>> + u64 min_size;
>>> int ret;
>>>
>>> + min_size = size;
>>> + flags |= DRM_BUDDY_RANGE_ALLOCATION;
>>> +
>>> mutex_lock(&bman->lock);
>>> - ret = drm_buddy_alloc_range(mm, &bman->reserved, start, size);
>>> + ret = drm_buddy_alloc(mm, start,
>>> + start + size,
>>> + size, min_size,
>>
>> min_page_size = min_size = size. I don't think we want that here. Also
>> the size here might not be power of two. I guess we need to use
>> chunk_size here instead?
> ok, we will use chunk_size here.
>>
>>> + &bman->reserved,
>>> + flags);
>>> mutex_unlock(&bman->lock);
>>>
>>> return ret;
>>> diff --git a/drivers/gpu/drm/i915/i915_ttm_buddy_manager.h b/drivers/gpu/drm/i915/i915_ttm_buddy_manager.h
>>> index fa644b512c2e..5ba490875f66 100644
>>> --- a/drivers/gpu/drm/i915/i915_ttm_buddy_manager.h
>>> +++ b/drivers/gpu/drm/i915/i915_ttm_buddy_manager.h
>>> @@ -20,6 +20,7 @@ struct drm_buddy_mm;
>>> *
>>> * @base: struct ttm_resource base class we extend
>>> * @blocks: the list of struct i915_buddy_block for this resource/allocation
>>> + * @flags: DRM_BUDDY_*_ALLOCATION flags
>>> * @mm: the struct i915_buddy_mm for this resource
>>> *
>>> * Extends the struct ttm_resource to manage an address space allocation with
>>> @@ -28,6 +29,7 @@ struct drm_buddy_mm;
>>> struct i915_ttm_buddy_resource {
>>> struct ttm_resource base;
>>> struct list_head blocks;
>>> + unsigned long flags;
>>> struct drm_buddy_mm *mm;
>>> };
>>>
>>> diff --git a/include/drm/drm_buddy.h b/include/drm/drm_buddy.h
>>> index 5ce3fc702f80..2ec3cbc9d5d7 100644
>>> --- a/include/drm/drm_buddy.h
>>> +++ b/include/drm/drm_buddy.h
>>> @@ -13,15 +13,22 @@
>>>
>>> #include <drm/drm_print.h>
>>>
>>> -#define range_overflows(start, size, max) ({ \
>>> +#define check_range_overflow(start, end, size, max) ({ \
>>> typeof(start) start__ = (start); \
>>> + typeof(end) end__ = (end);\
>>> typeof(size) size__ = (size); \
>>> typeof(max) max__ = (max); \
>>> (void)(&start__ == &size__); \
>>> (void)(&start__ == &max__); \
>>> - start__ >= max__ || size__ > max__ - start__; \
>>> + (void)(&start__ == &end__); \
>>> + (void)(&end__ == &size__); \
>>> + (void)(&end__ == &max__); \
>>> + start__ >= max__ || end__ > max__ || \
>>> + size__ > end__ - start__; \
>>> })
>>>
>>> +#define DRM_BUDDY_RANGE_ALLOCATION (1 << 0)
>>> +
>>> struct drm_buddy_block {
>>> #define DRM_BUDDY_HEADER_OFFSET GENMASK_ULL(63, 12)
>>> #define DRM_BUDDY_HEADER_STATE GENMASK_ULL(11, 10)
>>> @@ -131,12 +138,11 @@ int drm_buddy_init(struct drm_buddy_mm *mm, u64 size, u64 chunk_size);
>>>
>>> void drm_buddy_fini(struct drm_buddy_mm *mm);
>>>
>>> -struct drm_buddy_block *
>>> -drm_buddy_alloc(struct drm_buddy_mm *mm, unsigned int order);
>>> -
>>> -int drm_buddy_alloc_range(struct drm_buddy_mm *mm,
>>> - struct list_head *blocks,
>>> - u64 start, u64 size);
>>> +int drm_buddy_alloc(struct drm_buddy_mm *mm,
>>> + u64 start, u64 end, u64 size,
>>> + u64 min_page_size,
>>> + struct list_head *blocks,
>>> + unsigned long flags);
>>>
>>> void drm_buddy_free(struct drm_buddy_mm *mm, struct drm_buddy_block *block);
>>>
>>>
^ permalink raw reply [flat|nested] 46+ messages in thread
* Re: [Intel-gfx] [PATCH v3 2/6] drm: improve drm_buddy_alloc function
@ 2021-11-24 10:33 ` Matthew Auld
0 siblings, 0 replies; 46+ messages in thread
From: Matthew Auld @ 2021-11-24 10:33 UTC (permalink / raw)
To: Arunpravin, dri-devel, intel-gfx, amd-gfx
Cc: alexander.deucher, tzimmermann, christian.koenig
On 23/11/2021 22:39, Arunpravin wrote:
>
>
> On 18/11/21 12:09 am, Matthew Auld wrote:
>> On 16/11/2021 20:18, Arunpravin wrote:
>>> - Make drm_buddy_alloc a single function to handle
>>> range allocation and non-range allocation demands
>>>
>>> - Implemented a new function alloc_range() which allocates
>>> the requested power-of-two block comply with range limitations
>>>
>>> - Moved order computation and memory alignment logic from
>>> i915 driver to drm buddy
>>>
>>> v2:
>>> merged below changes to keep the build unbroken
>>> - drm_buddy_alloc_range() becomes obsolete and may be removed
>>> - enable ttm range allocation (fpfn / lpfn) support in i915 driver
>>> - apply enhanced drm_buddy_alloc() function to i915 driver
>>>
>>> v3(Matthew Auld):
>>> - Fix alignment issues and remove unnecessary list_empty check
>>> - add more validation checks for input arguments
>>> - make alloc_range() block allocations as bottom-up
>>> - optimize order computation logic
>>> - replace uint64_t with u64, which is preferred in the kernel
>>>
>>> Signed-off-by: Arunpravin <Arunpravin.PaneerSelvam@amd.com>
>>> ---
>>> drivers/gpu/drm/drm_buddy.c | 259 ++++++++++--------
>>> drivers/gpu/drm/i915/i915_ttm_buddy_manager.c | 69 ++---
>>> drivers/gpu/drm/i915/i915_ttm_buddy_manager.h | 2 +
>>> include/drm/drm_buddy.h | 22 +-
>>> 4 files changed, 203 insertions(+), 149 deletions(-)
>>>
>>> diff --git a/drivers/gpu/drm/drm_buddy.c b/drivers/gpu/drm/drm_buddy.c
>>> index 39eb1d224bec..c9b18a29f8d1 100644
>>> --- a/drivers/gpu/drm/drm_buddy.c
>>> +++ b/drivers/gpu/drm/drm_buddy.c
>>> @@ -274,63 +274,6 @@ void drm_buddy_free_list(struct drm_buddy_mm *mm, struct list_head *objects)
>>> }
>>> EXPORT_SYMBOL(drm_buddy_free_list);
>>>
>>> -/**
>>> - * drm_buddy_alloc - allocate power-of-two blocks
>>> - *
>>> - * @mm: DRM buddy manager to allocate from
>>> - * @order: size of the allocation
>>> - *
>>> - * The order value here translates to:
>>> - *
>>> - * 0 = 2^0 * mm->chunk_size
>>> - * 1 = 2^1 * mm->chunk_size
>>> - * 2 = 2^2 * mm->chunk_size
>>> - *
>>> - * Returns:
>>> - * allocated ptr to the &drm_buddy_block on success
>>> - */
>>> -struct drm_buddy_block *
>>> -drm_buddy_alloc(struct drm_buddy_mm *mm, unsigned int order)
>>> -{
>>> - struct drm_buddy_block *block = NULL;
>>> - unsigned int i;
>>> - int err;
>>> -
>>> - for (i = order; i <= mm->max_order; ++i) {
>>> - block = list_first_entry_or_null(&mm->free_list[i],
>>> - struct drm_buddy_block,
>>> - link);
>>> - if (block)
>>> - break;
>>> - }
>>> -
>>> - if (!block)
>>> - return ERR_PTR(-ENOSPC);
>>> -
>>> - BUG_ON(!drm_buddy_block_is_free(block));
>>> -
>>> - while (i != order) {
>>> - err = split_block(mm, block);
>>> - if (unlikely(err))
>>> - goto out_free;
>>> -
>>> - /* Go low */
>>> - block = block->left;
>>> - i--;
>>> - }
>>> -
>>> - mark_allocated(block);
>>> - mm->avail -= drm_buddy_block_size(mm, block);
>>> - kmemleak_update_trace(block);
>>> - return block;
>>> -
>>> -out_free:
>>> - if (i != order)
>>> - __drm_buddy_free(mm, block);
>>> - return ERR_PTR(err);
>>> -}
>>> -EXPORT_SYMBOL(drm_buddy_alloc);
>>> -
>>> static inline bool overlaps(u64 s1, u64 e1, u64 s2, u64 e2)
>>> {
>>> return s1 <= e2 && e1 >= s2;
>>> @@ -341,52 +284,22 @@ static inline bool contains(u64 s1, u64 e1, u64 s2, u64 e2)
>>> return s1 <= s2 && e1 >= e2;
>>> }
>>>
>>> -/**
>>> - * drm_buddy_alloc_range - allocate range
>>> - *
>>> - * @mm: DRM buddy manager to allocate from
>>> - * @blocks: output list head to add allocated blocks
>>> - * @start: start of the allowed range for this block
>>> - * @size: size of the allocation
>>> - *
>>> - * Intended for pre-allocating portions of the address space, for example to
>>> - * reserve a block for the initial framebuffer or similar, hence the expectation
>>> - * here is that drm_buddy_alloc() is still the main vehicle for
>>> - * allocations, so if that's not the case then the drm_mm range allocator is
>>> - * probably a much better fit, and so you should probably go use that instead.
>>> - *
>>> - * Note that it's safe to chain together multiple alloc_ranges
>>> - * with the same blocks list
>>> - *
>>> - * Returns:
>>> - * 0 on success, error code on failure.
>>> - */
>>> -int drm_buddy_alloc_range(struct drm_buddy_mm *mm,
>>> - struct list_head *blocks,
>>> - u64 start, u64 size)
>>> +static struct drm_buddy_block *
>>> +alloc_range(struct drm_buddy_mm *mm,
>>> + u64 start, u64 end,
>>> + unsigned int order)
>>> {
>>> struct drm_buddy_block *block;
>>> struct drm_buddy_block *buddy;
>>> - LIST_HEAD(allocated);
>>> LIST_HEAD(dfs);
>>> - u64 end;
>>> int err;
>>> int i;
>>>
>>> - if (size < mm->chunk_size)
>>> - return -EINVAL;
>>> -
>>> - if (!IS_ALIGNED(size | start, mm->chunk_size))
>>> - return -EINVAL;
>>> -
>>> - if (range_overflows(start, size, mm->size))
>>> - return -EINVAL;
>>> + end = end - 1;
>>>
>>> for (i = 0; i < mm->n_roots; ++i)
>>> list_add_tail(&mm->roots[i]->tmp_link, &dfs);
>>>
>>> - end = start + size - 1;
>>> -
>>> do {
>>> u64 block_start;
>>> u64 block_end;
>>> @@ -399,26 +312,26 @@ int drm_buddy_alloc_range(struct drm_buddy_mm *mm,
>>>
>>> list_del(&block->tmp_link);
>>>
>>> + if (drm_buddy_block_order(block) < order)
>>> + continue;
>>> +
>>> block_start = drm_buddy_block_offset(block);
>>> block_end = block_start + drm_buddy_block_size(mm, block) - 1;
>>>
>>> if (!overlaps(start, end, block_start, block_end))
>>> continue;
>>>
>>> - if (drm_buddy_block_is_allocated(block)) {
>>> - err = -ENOSPC;
>>> - goto err_free;
>>> - }
>>> + if (drm_buddy_block_is_allocated(block))
>>> + continue;
>>>
>>> - if (contains(start, end, block_start, block_end)) {
>>> - if (!drm_buddy_block_is_free(block)) {
>>> - err = -ENOSPC;
>>> - goto err_free;
>>> - }
>>> + if (contains(start, end, block_start, block_end) &&
>>> + order == drm_buddy_block_order(block)) {
>>> + /*
>>> + * Find the free block within the range.
>>> + */
>>> + if (drm_buddy_block_is_free(block))
>>> + return block;
>>
>> AFAIK this is still randomly ordered when dealing with actual range
>> allocation. Maybe I'm missing something, but it looks like we are just
>> repeatedly picking the largest order that fits in the remaining number
>> of pages, but it might be the case that the smallest block is for
>> example at the start of the range, depending on the layout of the
>> address space, which would then only get allocated last.
>>
>> I think I mentioned this before, but most of the block_trim() looks to
>> already do what we want for this case, and could maybe be factored out,
>> since that is also just another range allocation, except we start with
>> one root node for our "dfs" search.
>>
>> Maybe something like:
>>
>> drm_buddy_trim(block, new_size...)
>> {
>> ....
>> mark_free(block);
>> list_add(&block->tmp_link, &dfs);
>> err = __alloc_range(mm, &dfs, block->start, new_size, ...);
>> if (err)
>> ....
>> }
>>
>> __drm_buddy_alloc_range(start, size, blocks)
>> {
>> for_each_root()
>> list_add(&root->tmp_link, &dfs);
>>
>> err = __alloc_range(mm, &dfs, start, size, ...);
>> if (err)
>> ....
>> }
>>
>> drm_buddy_alloc(...)
>> {
>> /* Actual range allocation */
>> if (start + size == end)
>> return __drm_buddy_alloc_range(...);
>> ....
>> }
>>
>> And then have something different for the alloc_range_bias()?
>>
> Yes, we will have a common function __alloc_range() which does the range
> allocation for block_trim() and __drm_buddy_alloc_range() (actual range
> allocation).
>
> And, I understood that we keep the alloc_range() implementation for end
> bias allocations?
Yeah, I think that makes sense.
>
>>>
>>> - mark_allocated(block);
>>> - mm->avail -= drm_buddy_block_size(mm, block);
>>> - list_add_tail(&block->link, &allocated);
>>> continue;
>>> }
>>>
>>> @@ -432,8 +345,7 @@ int drm_buddy_alloc_range(struct drm_buddy_mm *mm,
>>> list_add(&block->left->tmp_link, &dfs);
>>> } while (1);
>>>
>>> - list_splice_tail(&allocated, blocks);
>>> - return 0;
>>> + return ERR_PTR(-ENOSPC);
>>>
>>> err_undo:
>>> /*
>>> @@ -446,12 +358,145 @@ int drm_buddy_alloc_range(struct drm_buddy_mm *mm,
>>> (drm_buddy_block_is_free(block) &&
>>> drm_buddy_block_is_free(buddy)))
>>> __drm_buddy_free(mm, block);
>>> + return ERR_PTR(err);
>>> +}
>>> +
>>> +static struct drm_buddy_block *
>>> +alloc_from_freelist(struct drm_buddy_mm *mm,
>>> + unsigned int order,
>>> + unsigned long flags)
>>> +{
>>> + struct drm_buddy_block *block = NULL;
>>> + unsigned int i;
>>> + int err;
>>> +
>>> + for (i = order; i <= mm->max_order; ++i) {
>>> + block = list_first_entry_or_null(&mm->free_list[i],
>>> + struct drm_buddy_block,
>>> + link);
>>> + if (block)
>>> + break;
>>> + }
>>> +
>>> + if (!block)
>>> + return ERR_PTR(-ENOSPC);
>>> +
>>> + BUG_ON(!drm_buddy_block_is_free(block));
>>> +
>>> + while (i != order) {
>>> + err = split_block(mm, block);
>>> + if (unlikely(err))
>>> + goto err_undo;
>>> +
>>> + block = block->right;
>>> + i--;
>>> + }
>>> + return block;
>>> +
>>> +err_undo:
>>> + if (i != order)
>>> + __drm_buddy_free(mm, block);
>>> + return ERR_PTR(err);
>>> +}
>>> +
>>> +/**
>>> + * drm_buddy_alloc - allocate power-of-two blocks
>>> + *
>>> + * @mm: DRM buddy manager to allocate from
>>> + * @start: start of the allowed range for this block
>>> + * @end: end of the allowed range for this block
>>> + * @size: size of the allocation
>>> + * @min_page_size: alignment of the allocation
>>> + * @blocks: output list head to add allocated blocks
>>> + * @flags: DRM_BUDDY_*_ALLOCATION flags
>>> + *
>>> + * alloc_range() called on range limitations, which traverses
>>> + * the tree and returns the desired block.
>>> + *
>>> + * alloc_from_freelist() called when *no* range restrictions
>>> + * are enforced, which picks the block from the freelist.
>>> + *
>>> + * blocks are allocated in order, the order value here translates to:
>>> + *
>>> + * 0 = 2^0 * mm->chunk_size
>>> + * 1 = 2^1 * mm->chunk_size
>>> + * 2 = 2^2 * mm->chunk_size
>>> + *
>>> + * Returns:
>>> + * 0 on success, error code on failure.
>>> + */
>>> +int drm_buddy_alloc(struct drm_buddy_mm *mm,
>>> + u64 start, u64 end, u64 size,
>>> + u64 min_page_size,
>>> + struct list_head *blocks,
>>> + unsigned long flags)
>>> +{
>>> + struct drm_buddy_block *block = NULL;
>>> + unsigned int min_order, order;
>>> + unsigned long pages;
>>> + LIST_HEAD(allocated);
>>> + int err;
>>> +
>>> + if (size < mm->chunk_size)
>>> + return -EINVAL;
>>> +
>>> + if (min_page_size < mm->chunk_size)
>>> + return -EINVAL;
>>> +
>>> + if (!is_power_of_2(min_page_size))
>>> + return -EINVAL;
>>> +
>>> + if (!IS_ALIGNED(start | end | size, mm->chunk_size))
>>> + return -EINVAL;
>>> +
>>> + if (check_range_overflow(start, end, size, mm->size))
>>> + return -EINVAL;
>>> +
>>> + pages = size >> ilog2(mm->chunk_size);
>>> + order = fls(pages) - 1;
>>> + min_order = ilog2(min_page_size) - ilog2(mm->chunk_size);
>>> +
>>> + do {
>>> + order = min(order, (unsigned int)fls(pages) - 1);
>>> + BUG_ON(order > mm->max_order);
>>> + BUG_ON(order < min_order);
>>> +
>>> + do {
>>> + if (flags & DRM_BUDDY_RANGE_ALLOCATION)
>>> + /* Allocate traversing within the range */
>>> + block = alloc_range(mm, start, end, order);
>>> + else
>>> + /* Allocate from freelist */
>>> + block = alloc_from_freelist(mm, order, flags);
>>> +
>>> + if (!IS_ERR(block))
>>> + break;
>>> +
>>> + if (order-- == min_order) {
>>> + err = -ENOSPC;
>>> + goto err_free;
>>> + }
>>> + } while (1);
>>> +
>>> + mark_allocated(block);
>>> + mm->avail -= drm_buddy_block_size(mm, block);
>>> + kmemleak_update_trace(block);
>>> + list_add_tail(&block->link, &allocated);
>>> +
>>> + pages -= BIT(order);
>>> +
>>> + if (!pages)
>>> + break;
>>> + } while (1);
>>> +
>>> + list_splice_tail(&allocated, blocks);
>>> + return 0;
>>>
>>> err_free:
>>> drm_buddy_free_list(mm, &allocated);
>>> return err;
>>> }
>>> -EXPORT_SYMBOL(drm_buddy_alloc_range);
>>> +EXPORT_SYMBOL(drm_buddy_alloc);
>>>
>>> /**
>>> * drm_buddy_block_print - print block information
>>> diff --git a/drivers/gpu/drm/i915/i915_ttm_buddy_manager.c b/drivers/gpu/drm/i915/i915_ttm_buddy_manager.c
>>> index c4b70cb8c248..9e3d130c3f42 100644
>>> --- a/drivers/gpu/drm/i915/i915_ttm_buddy_manager.c
>>> +++ b/drivers/gpu/drm/i915/i915_ttm_buddy_manager.c
>>> @@ -36,13 +36,14 @@ static int i915_ttm_buddy_man_alloc(struct ttm_resource_manager *man,
>>> struct i915_ttm_buddy_manager *bman = to_buddy_manager(man);
>>> struct i915_ttm_buddy_resource *bman_res;
>>> struct drm_buddy_mm *mm = &bman->mm;
>>> - unsigned long n_pages;
>>> - unsigned int min_order;
>>> + unsigned long n_pages, lpfn;
>>> u64 min_page_size;
>>> u64 size;
>>> int err;
>>>
>>> - GEM_BUG_ON(place->fpfn || place->lpfn);
>>> + lpfn = place->lpfn;
>>> + if (!lpfn)
>>> + lpfn = man->size;
>>>
>>> bman_res = kzalloc(sizeof(*bman_res), GFP_KERNEL);
>>> if (!bman_res)
>>> @@ -52,6 +53,9 @@ static int i915_ttm_buddy_man_alloc(struct ttm_resource_manager *man,
>>> INIT_LIST_HEAD(&bman_res->blocks);
>>> bman_res->mm = mm;
>>>
>>> + if (place->fpfn || lpfn != man->size)
>>> + bman_res->flags |= DRM_BUDDY_RANGE_ALLOCATION;
>>> +
>>> GEM_BUG_ON(!bman_res->base.num_pages);
>>> size = bman_res->base.num_pages << PAGE_SHIFT;
>>>
>>> @@ -60,10 +64,16 @@ static int i915_ttm_buddy_man_alloc(struct ttm_resource_manager *man,
>>> min_page_size = bo->page_alignment << PAGE_SHIFT;
>>>
>>> GEM_BUG_ON(min_page_size < mm->chunk_size);
>>> - min_order = ilog2(min_page_size) - ilog2(mm->chunk_size);
>>> +
>>> if (place->flags & TTM_PL_FLAG_CONTIGUOUS) {
>>> + unsigned long pages;
>>> +
>>> size = roundup_pow_of_two(size);
>>> - min_order = ilog2(size) - ilog2(mm->chunk_size);
>>> + min_page_size = size;
>>> +
>>> + pages = size >> ilog2(mm->chunk_size);
>>> + if (pages > lpfn)
>>> + lpfn = pages;
>>> }
>>>
>>> if (size > mm->size) {
>>> @@ -73,34 +83,16 @@ static int i915_ttm_buddy_man_alloc(struct ttm_resource_manager *man,
>>>
>>> n_pages = size >> ilog2(mm->chunk_size);
>>>
>>> - do {
>>> - struct drm_buddy_block *block;
>>> - unsigned int order;
>>> -
>>> - order = fls(n_pages) - 1;
>>> - GEM_BUG_ON(order > mm->max_order);
>>> - GEM_BUG_ON(order < min_order);
>>> -
>>> - do {
>>> - mutex_lock(&bman->lock);
>>> - block = drm_buddy_alloc(mm, order);
>>> - mutex_unlock(&bman->lock);
>>> - if (!IS_ERR(block))
>>> - break;
>>> -
>>> - if (order-- == min_order) {
>>> - err = -ENOSPC;
>>> - goto err_free_blocks;
>>> - }
>>> - } while (1);
>>> -
>>> - n_pages -= BIT(order);
>>> -
>>> - list_add_tail(&block->link, &bman_res->blocks);
>>> -
>>> - if (!n_pages)
>>> - break;
>>> - } while (1);
>>> + mutex_lock(&bman->lock);
>>> + err = drm_buddy_alloc(mm, (u64)place->fpfn << PAGE_SHIFT,
>>> + (u64)place->lpfn << PAGE_SHIFT,
>>> + (u64)n_pages << PAGE_SHIFT,
>>> + min_page_size,
>>> + &bman_res->blocks,
>>> + bman_res->flags);
>>> + mutex_unlock(&bman->lock);
>>> + if (unlikely(err))
>>> + goto err_free_blocks;
>>>
>>> *res = &bman_res->base;
>>> return 0;
>>> @@ -266,10 +258,19 @@ int i915_ttm_buddy_man_reserve(struct ttm_resource_manager *man,
>>> {
>>> struct i915_ttm_buddy_manager *bman = to_buddy_manager(man);
>>> struct drm_buddy_mm *mm = &bman->mm;
>>> + unsigned long flags = 0;
>>> + u64 min_size;
>>> int ret;
>>>
>>> + min_size = size;
>>> + flags |= DRM_BUDDY_RANGE_ALLOCATION;
>>> +
>>> mutex_lock(&bman->lock);
>>> - ret = drm_buddy_alloc_range(mm, &bman->reserved, start, size);
>>> + ret = drm_buddy_alloc(mm, start,
>>> + start + size,
>>> + size, min_size,
>>
>> min_page_size = min_size = size. I don't think we want that here. Also
>> the size here might not be power of two. I guess we need to use
>> chunk_size here instead?
> ok, we will use chunk_size here.
>>
>>> + &bman->reserved,
>>> + flags);
>>> mutex_unlock(&bman->lock);
>>>
>>> return ret;
>>> diff --git a/drivers/gpu/drm/i915/i915_ttm_buddy_manager.h b/drivers/gpu/drm/i915/i915_ttm_buddy_manager.h
>>> index fa644b512c2e..5ba490875f66 100644
>>> --- a/drivers/gpu/drm/i915/i915_ttm_buddy_manager.h
>>> +++ b/drivers/gpu/drm/i915/i915_ttm_buddy_manager.h
>>> @@ -20,6 +20,7 @@ struct drm_buddy_mm;
>>> *
>>> * @base: struct ttm_resource base class we extend
>>> * @blocks: the list of struct i915_buddy_block for this resource/allocation
>>> + * @flags: DRM_BUDDY_*_ALLOCATION flags
>>> * @mm: the struct i915_buddy_mm for this resource
>>> *
>>> * Extends the struct ttm_resource to manage an address space allocation with
>>> @@ -28,6 +29,7 @@ struct drm_buddy_mm;
>>> struct i915_ttm_buddy_resource {
>>> struct ttm_resource base;
>>> struct list_head blocks;
>>> + unsigned long flags;
>>> struct drm_buddy_mm *mm;
>>> };
>>>
>>> diff --git a/include/drm/drm_buddy.h b/include/drm/drm_buddy.h
>>> index 5ce3fc702f80..2ec3cbc9d5d7 100644
>>> --- a/include/drm/drm_buddy.h
>>> +++ b/include/drm/drm_buddy.h
>>> @@ -13,15 +13,22 @@
>>>
>>> #include <drm/drm_print.h>
>>>
>>> -#define range_overflows(start, size, max) ({ \
>>> +#define check_range_overflow(start, end, size, max) ({ \
>>> typeof(start) start__ = (start); \
>>> + typeof(end) end__ = (end);\
>>> typeof(size) size__ = (size); \
>>> typeof(max) max__ = (max); \
>>> (void)(&start__ == &size__); \
>>> (void)(&start__ == &max__); \
>>> - start__ >= max__ || size__ > max__ - start__; \
>>> + (void)(&start__ == &end__); \
>>> + (void)(&end__ == &size__); \
>>> + (void)(&end__ == &max__); \
>>> + start__ >= max__ || end__ > max__ || \
>>> + size__ > end__ - start__; \
>>> })
>>>
>>> +#define DRM_BUDDY_RANGE_ALLOCATION (1 << 0)
>>> +
>>> struct drm_buddy_block {
>>> #define DRM_BUDDY_HEADER_OFFSET GENMASK_ULL(63, 12)
>>> #define DRM_BUDDY_HEADER_STATE GENMASK_ULL(11, 10)
>>> @@ -131,12 +138,11 @@ int drm_buddy_init(struct drm_buddy_mm *mm, u64 size, u64 chunk_size);
>>>
>>> void drm_buddy_fini(struct drm_buddy_mm *mm);
>>>
>>> -struct drm_buddy_block *
>>> -drm_buddy_alloc(struct drm_buddy_mm *mm, unsigned int order);
>>> -
>>> -int drm_buddy_alloc_range(struct drm_buddy_mm *mm,
>>> - struct list_head *blocks,
>>> - u64 start, u64 size);
>>> +int drm_buddy_alloc(struct drm_buddy_mm *mm,
>>> + u64 start, u64 end, u64 size,
>>> + u64 min_page_size,
>>> + struct list_head *blocks,
>>> + unsigned long flags);
>>>
>>> void drm_buddy_free(struct drm_buddy_mm *mm, struct drm_buddy_block *block);
>>>
>>>
^ permalink raw reply [flat|nested] 46+ messages in thread
* Re: [PATCH v3 2/6] drm: improve drm_buddy_alloc function
@ 2021-11-24 10:33 ` Matthew Auld
0 siblings, 0 replies; 46+ messages in thread
From: Matthew Auld @ 2021-11-24 10:33 UTC (permalink / raw)
To: Arunpravin, dri-devel, intel-gfx, amd-gfx
Cc: alexander.deucher, tzimmermann, jani.nikula, christian.koenig, daniel
On 23/11/2021 22:39, Arunpravin wrote:
>
>
> On 18/11/21 12:09 am, Matthew Auld wrote:
>> On 16/11/2021 20:18, Arunpravin wrote:
>>> - Make drm_buddy_alloc a single function to handle
>>> range allocation and non-range allocation demands
>>>
>>> - Implemented a new function alloc_range() which allocates
>>> the requested power-of-two block comply with range limitations
>>>
>>> - Moved order computation and memory alignment logic from
>>> i915 driver to drm buddy
>>>
>>> v2:
>>> merged below changes to keep the build unbroken
>>> - drm_buddy_alloc_range() becomes obsolete and may be removed
>>> - enable ttm range allocation (fpfn / lpfn) support in i915 driver
>>> - apply enhanced drm_buddy_alloc() function to i915 driver
>>>
>>> v3(Matthew Auld):
>>> - Fix alignment issues and remove unnecessary list_empty check
>>> - add more validation checks for input arguments
>>> - make alloc_range() block allocations as bottom-up
>>> - optimize order computation logic
>>> - replace uint64_t with u64, which is preferred in the kernel
>>>
>>> Signed-off-by: Arunpravin <Arunpravin.PaneerSelvam@amd.com>
>>> ---
>>> drivers/gpu/drm/drm_buddy.c | 259 ++++++++++--------
>>> drivers/gpu/drm/i915/i915_ttm_buddy_manager.c | 69 ++---
>>> drivers/gpu/drm/i915/i915_ttm_buddy_manager.h | 2 +
>>> include/drm/drm_buddy.h | 22 +-
>>> 4 files changed, 203 insertions(+), 149 deletions(-)
>>>
>>> diff --git a/drivers/gpu/drm/drm_buddy.c b/drivers/gpu/drm/drm_buddy.c
>>> index 39eb1d224bec..c9b18a29f8d1 100644
>>> --- a/drivers/gpu/drm/drm_buddy.c
>>> +++ b/drivers/gpu/drm/drm_buddy.c
>>> @@ -274,63 +274,6 @@ void drm_buddy_free_list(struct drm_buddy_mm *mm, struct list_head *objects)
>>> }
>>> EXPORT_SYMBOL(drm_buddy_free_list);
>>>
>>> -/**
>>> - * drm_buddy_alloc - allocate power-of-two blocks
>>> - *
>>> - * @mm: DRM buddy manager to allocate from
>>> - * @order: size of the allocation
>>> - *
>>> - * The order value here translates to:
>>> - *
>>> - * 0 = 2^0 * mm->chunk_size
>>> - * 1 = 2^1 * mm->chunk_size
>>> - * 2 = 2^2 * mm->chunk_size
>>> - *
>>> - * Returns:
>>> - * allocated ptr to the &drm_buddy_block on success
>>> - */
>>> -struct drm_buddy_block *
>>> -drm_buddy_alloc(struct drm_buddy_mm *mm, unsigned int order)
>>> -{
>>> - struct drm_buddy_block *block = NULL;
>>> - unsigned int i;
>>> - int err;
>>> -
>>> - for (i = order; i <= mm->max_order; ++i) {
>>> - block = list_first_entry_or_null(&mm->free_list[i],
>>> - struct drm_buddy_block,
>>> - link);
>>> - if (block)
>>> - break;
>>> - }
>>> -
>>> - if (!block)
>>> - return ERR_PTR(-ENOSPC);
>>> -
>>> - BUG_ON(!drm_buddy_block_is_free(block));
>>> -
>>> - while (i != order) {
>>> - err = split_block(mm, block);
>>> - if (unlikely(err))
>>> - goto out_free;
>>> -
>>> - /* Go low */
>>> - block = block->left;
>>> - i--;
>>> - }
>>> -
>>> - mark_allocated(block);
>>> - mm->avail -= drm_buddy_block_size(mm, block);
>>> - kmemleak_update_trace(block);
>>> - return block;
>>> -
>>> -out_free:
>>> - if (i != order)
>>> - __drm_buddy_free(mm, block);
>>> - return ERR_PTR(err);
>>> -}
>>> -EXPORT_SYMBOL(drm_buddy_alloc);
>>> -
>>> static inline bool overlaps(u64 s1, u64 e1, u64 s2, u64 e2)
>>> {
>>> return s1 <= e2 && e1 >= s2;
>>> @@ -341,52 +284,22 @@ static inline bool contains(u64 s1, u64 e1, u64 s2, u64 e2)
>>> return s1 <= s2 && e1 >= e2;
>>> }
>>>
>>> -/**
>>> - * drm_buddy_alloc_range - allocate range
>>> - *
>>> - * @mm: DRM buddy manager to allocate from
>>> - * @blocks: output list head to add allocated blocks
>>> - * @start: start of the allowed range for this block
>>> - * @size: size of the allocation
>>> - *
>>> - * Intended for pre-allocating portions of the address space, for example to
>>> - * reserve a block for the initial framebuffer or similar, hence the expectation
>>> - * here is that drm_buddy_alloc() is still the main vehicle for
>>> - * allocations, so if that's not the case then the drm_mm range allocator is
>>> - * probably a much better fit, and so you should probably go use that instead.
>>> - *
>>> - * Note that it's safe to chain together multiple alloc_ranges
>>> - * with the same blocks list
>>> - *
>>> - * Returns:
>>> - * 0 on success, error code on failure.
>>> - */
>>> -int drm_buddy_alloc_range(struct drm_buddy_mm *mm,
>>> - struct list_head *blocks,
>>> - u64 start, u64 size)
>>> +static struct drm_buddy_block *
>>> +alloc_range(struct drm_buddy_mm *mm,
>>> + u64 start, u64 end,
>>> + unsigned int order)
>>> {
>>> struct drm_buddy_block *block;
>>> struct drm_buddy_block *buddy;
>>> - LIST_HEAD(allocated);
>>> LIST_HEAD(dfs);
>>> - u64 end;
>>> int err;
>>> int i;
>>>
>>> - if (size < mm->chunk_size)
>>> - return -EINVAL;
>>> -
>>> - if (!IS_ALIGNED(size | start, mm->chunk_size))
>>> - return -EINVAL;
>>> -
>>> - if (range_overflows(start, size, mm->size))
>>> - return -EINVAL;
>>> + end = end - 1;
>>>
>>> for (i = 0; i < mm->n_roots; ++i)
>>> list_add_tail(&mm->roots[i]->tmp_link, &dfs);
>>>
>>> - end = start + size - 1;
>>> -
>>> do {
>>> u64 block_start;
>>> u64 block_end;
>>> @@ -399,26 +312,26 @@ int drm_buddy_alloc_range(struct drm_buddy_mm *mm,
>>>
>>> list_del(&block->tmp_link);
>>>
>>> + if (drm_buddy_block_order(block) < order)
>>> + continue;
>>> +
>>> block_start = drm_buddy_block_offset(block);
>>> block_end = block_start + drm_buddy_block_size(mm, block) - 1;
>>>
>>> if (!overlaps(start, end, block_start, block_end))
>>> continue;
>>>
>>> - if (drm_buddy_block_is_allocated(block)) {
>>> - err = -ENOSPC;
>>> - goto err_free;
>>> - }
>>> + if (drm_buddy_block_is_allocated(block))
>>> + continue;
>>>
>>> - if (contains(start, end, block_start, block_end)) {
>>> - if (!drm_buddy_block_is_free(block)) {
>>> - err = -ENOSPC;
>>> - goto err_free;
>>> - }
>>> + if (contains(start, end, block_start, block_end) &&
>>> + order == drm_buddy_block_order(block)) {
>>> + /*
>>> + * Find the free block within the range.
>>> + */
>>> + if (drm_buddy_block_is_free(block))
>>> + return block;
>>
>> AFAIK this is still randomly ordered when dealing with actual range
>> allocation. Maybe I'm missing something, but it looks like we are just
>> repeatedly picking the largest order that fits in the remaining number
>> of pages, but it might be the case that the smallest block is for
>> example at the start of the range, depending on the layout of the
>> address space, which would then only get allocated last.
>>
>> I think I mentioned this before, but most of the block_trim() looks to
>> already do what we want for this case, and could maybe be factored out,
>> since that is also just another range allocation, except we start with
>> one root node for our "dfs" search.
>>
>> Maybe something like:
>>
>> drm_buddy_trim(block, new_size...)
>> {
>> ....
>> mark_free(block);
>> list_add(&block->tmp_link, &dfs);
>> err = __alloc_range(mm, &dfs, block->start, new_size, ...);
>> if (err)
>> ....
>> }
>>
>> __drm_buddy_alloc_range(start, size, blocks)
>> {
>> for_each_root()
>> list_add(&root->tmp_link, &dfs);
>>
>> err = __alloc_range(mm, &dfs, start, size, ...);
>> if (err)
>> ....
>> }
>>
>> drm_buddy_alloc(...)
>> {
>> /* Actual range allocation */
>> if (start + size == end)
>> return __drm_buddy_alloc_range(...);
>> ....
>> }
>>
>> And then have something different for the alloc_range_bias()?
>>
> Yes, we will have a common function __alloc_range() which does the range
> allocation for block_trim() and __drm_buddy_alloc_range() (actual range
> allocation).
>
> And, I understood that we keep the alloc_range() implementation for end
> bias allocations?
Yeah, I think that makes sense.
>
>>>
>>> - mark_allocated(block);
>>> - mm->avail -= drm_buddy_block_size(mm, block);
>>> - list_add_tail(&block->link, &allocated);
>>> continue;
>>> }
>>>
>>> @@ -432,8 +345,7 @@ int drm_buddy_alloc_range(struct drm_buddy_mm *mm,
>>> list_add(&block->left->tmp_link, &dfs);
>>> } while (1);
>>>
>>> - list_splice_tail(&allocated, blocks);
>>> - return 0;
>>> + return ERR_PTR(-ENOSPC);
>>>
>>> err_undo:
>>> /*
>>> @@ -446,12 +358,145 @@ int drm_buddy_alloc_range(struct drm_buddy_mm *mm,
>>> (drm_buddy_block_is_free(block) &&
>>> drm_buddy_block_is_free(buddy)))
>>> __drm_buddy_free(mm, block);
>>> + return ERR_PTR(err);
>>> +}
>>> +
>>> +static struct drm_buddy_block *
>>> +alloc_from_freelist(struct drm_buddy_mm *mm,
>>> + unsigned int order,
>>> + unsigned long flags)
>>> +{
>>> + struct drm_buddy_block *block = NULL;
>>> + unsigned int i;
>>> + int err;
>>> +
>>> + for (i = order; i <= mm->max_order; ++i) {
>>> + block = list_first_entry_or_null(&mm->free_list[i],
>>> + struct drm_buddy_block,
>>> + link);
>>> + if (block)
>>> + break;
>>> + }
>>> +
>>> + if (!block)
>>> + return ERR_PTR(-ENOSPC);
>>> +
>>> + BUG_ON(!drm_buddy_block_is_free(block));
>>> +
>>> + while (i != order) {
>>> + err = split_block(mm, block);
>>> + if (unlikely(err))
>>> + goto err_undo;
>>> +
>>> + block = block->right;
>>> + i--;
>>> + }
>>> + return block;
>>> +
>>> +err_undo:
>>> + if (i != order)
>>> + __drm_buddy_free(mm, block);
>>> + return ERR_PTR(err);
>>> +}
>>> +
>>> +/**
>>> + * drm_buddy_alloc - allocate power-of-two blocks
>>> + *
>>> + * @mm: DRM buddy manager to allocate from
>>> + * @start: start of the allowed range for this block
>>> + * @end: end of the allowed range for this block
>>> + * @size: size of the allocation
>>> + * @min_page_size: alignment of the allocation
>>> + * @blocks: output list head to add allocated blocks
>>> + * @flags: DRM_BUDDY_*_ALLOCATION flags
>>> + *
>>> + * alloc_range() called on range limitations, which traverses
>>> + * the tree and returns the desired block.
>>> + *
>>> + * alloc_from_freelist() called when *no* range restrictions
>>> + * are enforced, which picks the block from the freelist.
>>> + *
>>> + * blocks are allocated in order, the order value here translates to:
>>> + *
>>> + * 0 = 2^0 * mm->chunk_size
>>> + * 1 = 2^1 * mm->chunk_size
>>> + * 2 = 2^2 * mm->chunk_size
>>> + *
>>> + * Returns:
>>> + * 0 on success, error code on failure.
>>> + */
>>> +int drm_buddy_alloc(struct drm_buddy_mm *mm,
>>> + u64 start, u64 end, u64 size,
>>> + u64 min_page_size,
>>> + struct list_head *blocks,
>>> + unsigned long flags)
>>> +{
>>> + struct drm_buddy_block *block = NULL;
>>> + unsigned int min_order, order;
>>> + unsigned long pages;
>>> + LIST_HEAD(allocated);
>>> + int err;
>>> +
>>> + if (size < mm->chunk_size)
>>> + return -EINVAL;
>>> +
>>> + if (min_page_size < mm->chunk_size)
>>> + return -EINVAL;
>>> +
>>> + if (!is_power_of_2(min_page_size))
>>> + return -EINVAL;
>>> +
>>> + if (!IS_ALIGNED(start | end | size, mm->chunk_size))
>>> + return -EINVAL;
>>> +
>>> + if (check_range_overflow(start, end, size, mm->size))
>>> + return -EINVAL;
>>> +
>>> + pages = size >> ilog2(mm->chunk_size);
>>> + order = fls(pages) - 1;
>>> + min_order = ilog2(min_page_size) - ilog2(mm->chunk_size);
>>> +
>>> + do {
>>> + order = min(order, (unsigned int)fls(pages) - 1);
>>> + BUG_ON(order > mm->max_order);
>>> + BUG_ON(order < min_order);
>>> +
>>> + do {
>>> + if (flags & DRM_BUDDY_RANGE_ALLOCATION)
>>> + /* Allocate traversing within the range */
>>> + block = alloc_range(mm, start, end, order);
>>> + else
>>> + /* Allocate from freelist */
>>> + block = alloc_from_freelist(mm, order, flags);
>>> +
>>> + if (!IS_ERR(block))
>>> + break;
>>> +
>>> + if (order-- == min_order) {
>>> + err = -ENOSPC;
>>> + goto err_free;
>>> + }
>>> + } while (1);
>>> +
>>> + mark_allocated(block);
>>> + mm->avail -= drm_buddy_block_size(mm, block);
>>> + kmemleak_update_trace(block);
>>> + list_add_tail(&block->link, &allocated);
>>> +
>>> + pages -= BIT(order);
>>> +
>>> + if (!pages)
>>> + break;
>>> + } while (1);
>>> +
>>> + list_splice_tail(&allocated, blocks);
>>> + return 0;
>>>
>>> err_free:
>>> drm_buddy_free_list(mm, &allocated);
>>> return err;
>>> }
>>> -EXPORT_SYMBOL(drm_buddy_alloc_range);
>>> +EXPORT_SYMBOL(drm_buddy_alloc);
>>>
>>> /**
>>> * drm_buddy_block_print - print block information
>>> diff --git a/drivers/gpu/drm/i915/i915_ttm_buddy_manager.c b/drivers/gpu/drm/i915/i915_ttm_buddy_manager.c
>>> index c4b70cb8c248..9e3d130c3f42 100644
>>> --- a/drivers/gpu/drm/i915/i915_ttm_buddy_manager.c
>>> +++ b/drivers/gpu/drm/i915/i915_ttm_buddy_manager.c
>>> @@ -36,13 +36,14 @@ static int i915_ttm_buddy_man_alloc(struct ttm_resource_manager *man,
>>> struct i915_ttm_buddy_manager *bman = to_buddy_manager(man);
>>> struct i915_ttm_buddy_resource *bman_res;
>>> struct drm_buddy_mm *mm = &bman->mm;
>>> - unsigned long n_pages;
>>> - unsigned int min_order;
>>> + unsigned long n_pages, lpfn;
>>> u64 min_page_size;
>>> u64 size;
>>> int err;
>>>
>>> - GEM_BUG_ON(place->fpfn || place->lpfn);
>>> + lpfn = place->lpfn;
>>> + if (!lpfn)
>>> + lpfn = man->size;
>>>
>>> bman_res = kzalloc(sizeof(*bman_res), GFP_KERNEL);
>>> if (!bman_res)
>>> @@ -52,6 +53,9 @@ static int i915_ttm_buddy_man_alloc(struct ttm_resource_manager *man,
>>> INIT_LIST_HEAD(&bman_res->blocks);
>>> bman_res->mm = mm;
>>>
>>> + if (place->fpfn || lpfn != man->size)
>>> + bman_res->flags |= DRM_BUDDY_RANGE_ALLOCATION;
>>> +
>>> GEM_BUG_ON(!bman_res->base.num_pages);
>>> size = bman_res->base.num_pages << PAGE_SHIFT;
>>>
>>> @@ -60,10 +64,16 @@ static int i915_ttm_buddy_man_alloc(struct ttm_resource_manager *man,
>>> min_page_size = bo->page_alignment << PAGE_SHIFT;
>>>
>>> GEM_BUG_ON(min_page_size < mm->chunk_size);
>>> - min_order = ilog2(min_page_size) - ilog2(mm->chunk_size);
>>> +
>>> if (place->flags & TTM_PL_FLAG_CONTIGUOUS) {
>>> + unsigned long pages;
>>> +
>>> size = roundup_pow_of_two(size);
>>> - min_order = ilog2(size) - ilog2(mm->chunk_size);
>>> + min_page_size = size;
>>> +
>>> + pages = size >> ilog2(mm->chunk_size);
>>> + if (pages > lpfn)
>>> + lpfn = pages;
>>> }
>>>
>>> if (size > mm->size) {
>>> @@ -73,34 +83,16 @@ static int i915_ttm_buddy_man_alloc(struct ttm_resource_manager *man,
>>>
>>> n_pages = size >> ilog2(mm->chunk_size);
>>>
>>> - do {
>>> - struct drm_buddy_block *block;
>>> - unsigned int order;
>>> -
>>> - order = fls(n_pages) - 1;
>>> - GEM_BUG_ON(order > mm->max_order);
>>> - GEM_BUG_ON(order < min_order);
>>> -
>>> - do {
>>> - mutex_lock(&bman->lock);
>>> - block = drm_buddy_alloc(mm, order);
>>> - mutex_unlock(&bman->lock);
>>> - if (!IS_ERR(block))
>>> - break;
>>> -
>>> - if (order-- == min_order) {
>>> - err = -ENOSPC;
>>> - goto err_free_blocks;
>>> - }
>>> - } while (1);
>>> -
>>> - n_pages -= BIT(order);
>>> -
>>> - list_add_tail(&block->link, &bman_res->blocks);
>>> -
>>> - if (!n_pages)
>>> - break;
>>> - } while (1);
>>> + mutex_lock(&bman->lock);
>>> + err = drm_buddy_alloc(mm, (u64)place->fpfn << PAGE_SHIFT,
>>> + (u64)place->lpfn << PAGE_SHIFT,
>>> + (u64)n_pages << PAGE_SHIFT,
>>> + min_page_size,
>>> + &bman_res->blocks,
>>> + bman_res->flags);
>>> + mutex_unlock(&bman->lock);
>>> + if (unlikely(err))
>>> + goto err_free_blocks;
>>>
>>> *res = &bman_res->base;
>>> return 0;
>>> @@ -266,10 +258,19 @@ int i915_ttm_buddy_man_reserve(struct ttm_resource_manager *man,
>>> {
>>> struct i915_ttm_buddy_manager *bman = to_buddy_manager(man);
>>> struct drm_buddy_mm *mm = &bman->mm;
>>> + unsigned long flags = 0;
>>> + u64 min_size;
>>> int ret;
>>>
>>> + min_size = size;
>>> + flags |= DRM_BUDDY_RANGE_ALLOCATION;
>>> +
>>> mutex_lock(&bman->lock);
>>> - ret = drm_buddy_alloc_range(mm, &bman->reserved, start, size);
>>> + ret = drm_buddy_alloc(mm, start,
>>> + start + size,
>>> + size, min_size,
>>
>> min_page_size = min_size = size. I don't think we want that here. Also
>> the size here might not be power of two. I guess we need to use
>> chunk_size here instead?
> ok, we will use chunk_size here.
>>
>>> + &bman->reserved,
>>> + flags);
>>> mutex_unlock(&bman->lock);
>>>
>>> return ret;
>>> diff --git a/drivers/gpu/drm/i915/i915_ttm_buddy_manager.h b/drivers/gpu/drm/i915/i915_ttm_buddy_manager.h
>>> index fa644b512c2e..5ba490875f66 100644
>>> --- a/drivers/gpu/drm/i915/i915_ttm_buddy_manager.h
>>> +++ b/drivers/gpu/drm/i915/i915_ttm_buddy_manager.h
>>> @@ -20,6 +20,7 @@ struct drm_buddy_mm;
>>> *
>>> * @base: struct ttm_resource base class we extend
>>> * @blocks: the list of struct i915_buddy_block for this resource/allocation
>>> + * @flags: DRM_BUDDY_*_ALLOCATION flags
>>> * @mm: the struct i915_buddy_mm for this resource
>>> *
>>> * Extends the struct ttm_resource to manage an address space allocation with
>>> @@ -28,6 +29,7 @@ struct drm_buddy_mm;
>>> struct i915_ttm_buddy_resource {
>>> struct ttm_resource base;
>>> struct list_head blocks;
>>> + unsigned long flags;
>>> struct drm_buddy_mm *mm;
>>> };
>>>
>>> diff --git a/include/drm/drm_buddy.h b/include/drm/drm_buddy.h
>>> index 5ce3fc702f80..2ec3cbc9d5d7 100644
>>> --- a/include/drm/drm_buddy.h
>>> +++ b/include/drm/drm_buddy.h
>>> @@ -13,15 +13,22 @@
>>>
>>> #include <drm/drm_print.h>
>>>
>>> -#define range_overflows(start, size, max) ({ \
>>> +#define check_range_overflow(start, end, size, max) ({ \
>>> typeof(start) start__ = (start); \
>>> + typeof(end) end__ = (end);\
>>> typeof(size) size__ = (size); \
>>> typeof(max) max__ = (max); \
>>> (void)(&start__ == &size__); \
>>> (void)(&start__ == &max__); \
>>> - start__ >= max__ || size__ > max__ - start__; \
>>> + (void)(&start__ == &end__); \
>>> + (void)(&end__ == &size__); \
>>> + (void)(&end__ == &max__); \
>>> + start__ >= max__ || end__ > max__ || \
>>> + size__ > end__ - start__; \
>>> })
>>>
>>> +#define DRM_BUDDY_RANGE_ALLOCATION (1 << 0)
>>> +
>>> struct drm_buddy_block {
>>> #define DRM_BUDDY_HEADER_OFFSET GENMASK_ULL(63, 12)
>>> #define DRM_BUDDY_HEADER_STATE GENMASK_ULL(11, 10)
>>> @@ -131,12 +138,11 @@ int drm_buddy_init(struct drm_buddy_mm *mm, u64 size, u64 chunk_size);
>>>
>>> void drm_buddy_fini(struct drm_buddy_mm *mm);
>>>
>>> -struct drm_buddy_block *
>>> -drm_buddy_alloc(struct drm_buddy_mm *mm, unsigned int order);
>>> -
>>> -int drm_buddy_alloc_range(struct drm_buddy_mm *mm,
>>> - struct list_head *blocks,
>>> - u64 start, u64 size);
>>> +int drm_buddy_alloc(struct drm_buddy_mm *mm,
>>> + u64 start, u64 end, u64 size,
>>> + u64 min_page_size,
>>> + struct list_head *blocks,
>>> + unsigned long flags);
>>>
>>> void drm_buddy_free(struct drm_buddy_mm *mm, struct drm_buddy_block *block);
>>>
>>>
^ permalink raw reply [flat|nested] 46+ messages in thread
end of thread, other threads:[~2021-11-24 13:32 UTC | newest]
Thread overview: 46+ messages (download: mbox.gz / follow: Atom feed)
-- links below jump to the message on this page --
2021-11-16 20:18 [PATCH v3 1/6] drm: move the buddy allocator from i915 into common drm Arunpravin
2021-11-16 20:18 ` [Intel-gfx] " Arunpravin
2021-11-16 20:18 ` Arunpravin
2021-11-16 20:18 ` [PATCH v3 2/6] drm: improve drm_buddy_alloc function Arunpravin
2021-11-16 20:18 ` [Intel-gfx] " Arunpravin
2021-11-16 20:18 ` Arunpravin
2021-11-17 18:39 ` Matthew Auld
2021-11-17 18:39 ` Matthew Auld
2021-11-17 18:39 ` [Intel-gfx] " Matthew Auld
2021-11-23 22:39 ` Arunpravin
2021-11-23 22:39 ` [Intel-gfx] " Arunpravin
2021-11-23 22:39 ` Arunpravin
2021-11-24 10:33 ` Matthew Auld
2021-11-24 10:33 ` Matthew Auld
2021-11-24 10:33 ` [Intel-gfx] " Matthew Auld
2021-11-16 20:18 ` [PATCH v3 3/6] drm: implement top-down allocation method Arunpravin
2021-11-16 20:18 ` [Intel-gfx] " Arunpravin
2021-11-16 20:18 ` Arunpravin
2021-11-16 20:18 ` [PATCH v3 4/6] drm: implement a method to free unused pages Arunpravin
2021-11-16 20:18 ` [Intel-gfx] " Arunpravin
2021-11-16 20:18 ` Arunpravin
2021-11-17 19:02 ` Matthew Auld
2021-11-17 19:02 ` Matthew Auld
2021-11-17 19:02 ` [Intel-gfx] " Matthew Auld
2021-11-23 22:40 ` Arunpravin
2021-11-23 22:40 ` [Intel-gfx] " Arunpravin
2021-11-23 22:40 ` Arunpravin
2021-11-16 20:18 ` [PATCH v3 5/6] drm/amdgpu: move vram inline functions into a header Arunpravin
2021-11-16 20:18 ` [Intel-gfx] " Arunpravin
2021-11-16 20:18 ` Arunpravin
2021-11-16 20:18 ` [PATCH v3 6/6] drm/amdgpu: add drm buddy support to amdgpu Arunpravin
2021-11-16 20:18 ` [Intel-gfx] " Arunpravin
2021-11-16 20:18 ` Arunpravin
2021-11-17 2:55 ` [Intel-gfx] ✗ Fi.CI.BUILD: failure for series starting with [v3,1/6] drm: move the buddy allocator from i915 into common drm Patchwork
2021-11-17 8:03 ` [PATCH v3 1/6] " Christian König
2021-11-17 8:03 ` [Intel-gfx] " Christian König
2021-11-17 8:03 ` Christian König
2021-11-17 17:05 ` Arunpravin
2021-11-17 17:05 ` [Intel-gfx] " Arunpravin
2021-11-17 17:05 ` Arunpravin
2021-11-17 17:52 ` Matthew Auld
2021-11-17 17:52 ` Matthew Auld
2021-11-17 17:52 ` [Intel-gfx] " Matthew Auld
2021-11-17 20:45 ` kernel test robot
2021-11-17 20:45 ` kernel test robot
2021-11-17 20:45 ` [Intel-gfx] " kernel test robot
This is an external index of several public inboxes,
see mirroring instructions on how to clone and mirror
all data and code used by this external index.