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)
v3: - make drm buddy a separate module(Thomas, Christian)
Signed-off-by: Arunpravin Arunpravin.PaneerSelvam@amd.com --- drivers/gpu/drm/Kconfig | 6 + drivers/gpu/drm/Makefile | 2 + drivers/gpu/drm/drm_buddy.c | 516 ++++++++++++++++++ drivers/gpu/drm/i915/Kconfig | 1 + 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 | 154 ++++++ 12 files changed, 703 insertions(+), 637 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/Kconfig b/drivers/gpu/drm/Kconfig index 0039df26854b..7a4a66d54782 100644 --- a/drivers/gpu/drm/Kconfig +++ b/drivers/gpu/drm/Kconfig @@ -197,6 +197,12 @@ config DRM_TTM GPU memory types. Will be enabled automatically if a device driver uses it.
+config DRM_BUDDY + tristate + depends on DRM + help + A page based buddy allocator + config DRM_VRAM_HELPER tristate depends on DRM diff --git a/drivers/gpu/drm/Makefile b/drivers/gpu/drm/Makefile index 0dff40bb863c..e62e432bf1e5 100644 --- a/drivers/gpu/drm/Makefile +++ b/drivers/gpu/drm/Makefile @@ -35,6 +35,8 @@ drm-$(CONFIG_DRM_LOAD_EDID_FIRMWARE) += drm_edid_load.o
obj-$(CONFIG_DRM_DP_AUX_BUS) += drm_dp_aux_bus.o
+obj-$(CONFIG_DRM_BUDDY) += drm_buddy.o + drm_vram_helper-y := drm_gem_vram_helper.o obj-$(CONFIG_DRM_VRAM_HELPER) += drm_vram_helper.o
diff --git a/drivers/gpu/drm/drm_buddy.c b/drivers/gpu/drm/drm_buddy.c new file mode 100644 index 000000000000..9340a4b61c5a --- /dev/null +++ b/drivers/gpu/drm/drm_buddy.c @@ -0,0 +1,516 @@ +// SPDX-License-Identifier: MIT +/* + * Copyright © 2021 Intel Corporation + */ + +#include <linux/kmemleak.h> +#include <linux/module.h> +#include <linux/sizes.h> + +#include <drm/drm_buddy.h> + +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(mm->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(mm->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->slab_blocks = KMEM_CACHE(drm_buddy_block, 0); + if (!mm->slab_blocks) + return -ENOMEM; + + mm->free_list = kmalloc_array(mm->max_order + 1, + sizeof(struct list_head), + GFP_KERNEL); + if (!mm->free_list) + goto out_destroy_slab; + + 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); +out_destroy_slab: + kmem_cache_destroy(mm->slab_blocks); + 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); + kmem_cache_destroy(mm->slab_blocks); +} +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); + +MODULE_DESCRIPTION("DRM Buddy Allocator"); +MODULE_LICENSE("GPL"); diff --git a/drivers/gpu/drm/i915/Kconfig b/drivers/gpu/drm/i915/Kconfig index a4c94dc2e216..64b5e0a44d4c 100644 --- a/drivers/gpu/drm/i915/Kconfig +++ b/drivers/gpu/drm/i915/Kconfig @@ -27,6 +27,7 @@ config DRM_I915 select CEC_CORE if CEC_NOTIFIER select VMAP_PFN select DRM_TTM + select DRM_BUDDY help Choose this option if you have a system that has "Intel Graphics Media Accelerator" or "HD Graphics" integrated graphics, diff --git a/drivers/gpu/drm/i915/Makefile b/drivers/gpu/drm/i915/Makefile index 568d711a3537..a5a0fb33c897 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..f9ff48a3f3a6 --- /dev/null +++ b/include/drm/drm_buddy.h @@ -0,0 +1,154 @@ +/* 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 { + struct kmem_cache *slab_blocks; + /* 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
- 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
v4(Matthew Auld): - keep drm_buddy_alloc_range() function implementation for generic actual range allocations - keep alloc_range() implementation for end bias allocations
Signed-off-by: Arunpravin Arunpravin.PaneerSelvam@amd.com --- drivers/gpu/drm/drm_buddy.c | 316 +++++++++++++----- drivers/gpu/drm/i915/i915_ttm_buddy_manager.c | 67 ++-- drivers/gpu/drm/i915/i915_ttm_buddy_manager.h | 2 + include/drm/drm_buddy.h | 22 +- 4 files changed, 285 insertions(+), 122 deletions(-)
diff --git a/drivers/gpu/drm/drm_buddy.c b/drivers/gpu/drm/drm_buddy.c index 9340a4b61c5a..7f47632821f4 100644 --- a/drivers/gpu/drm/drm_buddy.c +++ b/drivers/gpu/drm/drm_buddy.c @@ -280,23 +280,97 @@ 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) +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; +} + +static struct drm_buddy_block * +alloc_range_bias(struct drm_buddy_mm *mm, + u64 start, u64 end, + unsigned int order) +{ + struct drm_buddy_block *block; + struct drm_buddy_block *buddy; + LIST_HEAD(dfs); + int err; + int i; + + end = end - 1; + + for (i = 0; i < mm->n_roots; ++i) + list_add_tail(&mm->roots[i]->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 (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)) + continue; + + 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; + + 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 ERR_PTR(-ENOSPC); + +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); + 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; @@ -318,78 +392,28 @@ drm_buddy_alloc(struct drm_buddy_mm *mm, unsigned int order) while (i != order) { err = split_block(mm, block); if (unlikely(err)) - goto out_free; + goto err_undo;
- /* Go low */ - block = block->left; + block = block->right; i--; } - - mark_allocated(block); - mm->avail -= drm_buddy_block_size(mm, block); - kmemleak_update_trace(block); return block;
-out_free: +err_undo: 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) +static int __alloc_range(struct drm_buddy_mm *mm, + struct list_head *dfs, + u64 start, u64 size, + struct list_head *blocks) { 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;
@@ -397,7 +421,7 @@ int drm_buddy_alloc_range(struct drm_buddy_mm *mm, u64 block_start; u64 block_end;
- block = list_first_entry_or_null(&dfs, + block = list_first_entry_or_null(dfs, struct drm_buddy_block, tmp_link); if (!block) @@ -424,7 +448,7 @@ int drm_buddy_alloc_range(struct drm_buddy_mm *mm,
mark_allocated(block); mm->avail -= drm_buddy_block_size(mm, block); - list_add_tail(&block->link, &allocated); + list_add_tail(&block->link, blocks); continue; }
@@ -434,11 +458,10 @@ int drm_buddy_alloc_range(struct drm_buddy_mm *mm, goto err_undo; }
- list_add(&block->right->tmp_link, &dfs); - list_add(&block->left->tmp_link, &dfs); + 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: @@ -453,11 +476,144 @@ int drm_buddy_alloc_range(struct drm_buddy_mm *mm, drm_buddy_block_is_free(buddy))) __drm_buddy_free(mm, block);
+err_free: + drm_buddy_free_list(mm, blocks); + return err; +} + +/** + * __drm_buddy_alloc_range - actual range allocation + * + * @mm: DRM buddy manager to allocate from + * @start: start of the allowed range for this block + * @size: size of the allocation + * @blocks: output list head to add allocated blocks + * + * Intended for pre-allocating portions of the address space, for example to + * reserve a block for the initial framebuffer or similar + * + * Note that it's safe to chain together multiple alloc_ranges + * with the same blocks list + * + * Returns: + * 0 on success, error code on failure. + */ +static int __drm_buddy_alloc_range(struct drm_buddy_mm *mm, + u64 start, + u64 size, + struct list_head *blocks) +{ + LIST_HEAD(dfs); + int i; + + for (i = 0; i < mm->n_roots; ++i) + list_add_tail(&mm->roots[i]->tmp_link, &dfs); + + return __alloc_range(mm, &dfs, start, size, blocks); +} + +/** + * 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_bias() 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; + + /* Actual range allocation */ + if (start + size == end) + return __drm_buddy_alloc_range(mm, start, size, blocks); + + 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_bias(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..7621d42155e6 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,17 @@ 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; int ret;
+ 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, mm->chunk_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 f9ff48a3f3a6..221de702e909 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) @@ -132,12 +139,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);
[AMD Official Use Only]
Hi Matthew,
Ping on this?
Regards, Arun -----Original Message----- From: amd-gfx amd-gfx-bounces@lists.freedesktop.org On Behalf Of Arunpravin Sent: Wednesday, December 1, 2021 10:10 PM To: dri-devel@lists.freedesktop.org; intel-gfx@lists.freedesktop.org; amd-gfx@lists.freedesktop.org Cc: daniel@ffwll.ch; Paneer Selvam, Arunpravin Arunpravin.PaneerSelvam@amd.com; jani.nikula@linux.intel.com; matthew.auld@intel.com; tzimmermann@suse.de; Deucher, Alexander Alexander.Deucher@amd.com; Koenig, Christian Christian.Koenig@amd.com Subject: [PATCH v4 2/6] drm: improve drm_buddy_alloc function
- 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
v4(Matthew Auld): - keep drm_buddy_alloc_range() function implementation for generic actual range allocations - keep alloc_range() implementation for end bias allocations
Signed-off-by: Arunpravin Arunpravin.PaneerSelvam@amd.com --- drivers/gpu/drm/drm_buddy.c | 316 +++++++++++++----- drivers/gpu/drm/i915/i915_ttm_buddy_manager.c | 67 ++-- drivers/gpu/drm/i915/i915_ttm_buddy_manager.h | 2 + include/drm/drm_buddy.h | 22 +- 4 files changed, 285 insertions(+), 122 deletions(-)
diff --git a/drivers/gpu/drm/drm_buddy.c b/drivers/gpu/drm/drm_buddy.c index 9340a4b61c5a..7f47632821f4 100644 --- a/drivers/gpu/drm/drm_buddy.c +++ b/drivers/gpu/drm/drm_buddy.c @@ -280,23 +280,97 @@ 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) +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; +} + +static struct drm_buddy_block * +alloc_range_bias(struct drm_buddy_mm *mm, + u64 start, u64 end, + unsigned int order) +{ + struct drm_buddy_block *block; + struct drm_buddy_block *buddy; + LIST_HEAD(dfs); + int err; + int i; + + end = end - 1; + + for (i = 0; i < mm->n_roots; ++i) + list_add_tail(&mm->roots[i]->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 (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)) + continue; + + 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; + + 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 ERR_PTR(-ENOSPC); + +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); + 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; @@ -318,78 +392,28 @@ drm_buddy_alloc(struct drm_buddy_mm *mm, unsigned int order) while (i != order) { err = split_block(mm, block); if (unlikely(err)) - goto out_free; + goto err_undo;
- /* Go low */ - block = block->left; + block = block->right; i--; } - - mark_allocated(block); - mm->avail -= drm_buddy_block_size(mm, block); - kmemleak_update_trace(block); return block;
-out_free: +err_undo: 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) +static int __alloc_range(struct drm_buddy_mm *mm, + struct list_head *dfs, + u64 start, u64 size, + struct list_head *blocks) { 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;
@@ -397,7 +421,7 @@ int drm_buddy_alloc_range(struct drm_buddy_mm *mm, u64 block_start; u64 block_end;
- block = list_first_entry_or_null(&dfs, + block = list_first_entry_or_null(dfs, struct drm_buddy_block, tmp_link); if (!block) @@ -424,7 +448,7 @@ int drm_buddy_alloc_range(struct drm_buddy_mm *mm,
mark_allocated(block); mm->avail -= drm_buddy_block_size(mm, block); - list_add_tail(&block->link, &allocated); + list_add_tail(&block->link, blocks); continue; }
@@ -434,11 +458,10 @@ int drm_buddy_alloc_range(struct drm_buddy_mm *mm, goto err_undo; }
- list_add(&block->right->tmp_link, &dfs); - list_add(&block->left->tmp_link, &dfs); + 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: @@ -453,11 +476,144 @@ int drm_buddy_alloc_range(struct drm_buddy_mm *mm, drm_buddy_block_is_free(buddy))) __drm_buddy_free(mm, block);
+err_free: + drm_buddy_free_list(mm, blocks); + return err; +} + +/** + * __drm_buddy_alloc_range - actual range allocation + * + * @mm: DRM buddy manager to allocate from + * @start: start of the allowed range for this block + * @size: size of the allocation + * @blocks: output list head to add allocated blocks + * + * Intended for pre-allocating portions of the address space, for +example to + * reserve a block for the initial framebuffer or similar + * + * Note that it's safe to chain together multiple alloc_ranges + * with the same blocks list + * + * Returns: + * 0 on success, error code on failure. + */ +static int __drm_buddy_alloc_range(struct drm_buddy_mm *mm, + u64 start, + u64 size, + struct list_head *blocks) +{ + LIST_HEAD(dfs); + int i; + + for (i = 0; i < mm->n_roots; ++i) + list_add_tail(&mm->roots[i]->tmp_link, &dfs); + + return __alloc_range(mm, &dfs, start, size, blocks); } + +/** + * 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_bias() 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; + + /* Actual range allocation */ + if (start + size == end) + return __drm_buddy_alloc_range(mm, start, size, blocks); + + 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_bias(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..7621d42155e6 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,17 @@ 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; int ret;
+ 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, mm->chunk_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 f9ff48a3f3a6..221de702e909 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) @@ -132,12 +139,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
On 09/12/2021 15:47, Paneer Selvam, Arunpravin wrote:
[AMD Official Use Only]
Hi Matthew,
Ping on this?
No new comments from me :) I guess just a question of what we should do with the selftests, and then ofc at some point being able to throw this at CI, or at least test locally, once the series builds.
Regards, Arun -----Original Message----- From: amd-gfx amd-gfx-bounces@lists.freedesktop.org On Behalf Of Arunpravin Sent: Wednesday, December 1, 2021 10:10 PM To: dri-devel@lists.freedesktop.org; intel-gfx@lists.freedesktop.org; amd-gfx@lists.freedesktop.org Cc: daniel@ffwll.ch; Paneer Selvam, Arunpravin Arunpravin.PaneerSelvam@amd.com; jani.nikula@linux.intel.com; matthew.auld@intel.com; tzimmermann@suse.de; Deucher, Alexander Alexander.Deucher@amd.com; Koenig, Christian Christian.Koenig@amd.com Subject: [PATCH v4 2/6] drm: improve drm_buddy_alloc function
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
v4(Matthew Auld):
- keep drm_buddy_alloc_range() function implementation for generic actual range allocations
- keep alloc_range() implementation for end bias allocations
Signed-off-by: Arunpravin Arunpravin.PaneerSelvam@amd.com
drivers/gpu/drm/drm_buddy.c | 316 +++++++++++++----- drivers/gpu/drm/i915/i915_ttm_buddy_manager.c | 67 ++-- drivers/gpu/drm/i915/i915_ttm_buddy_manager.h | 2 + include/drm/drm_buddy.h | 22 +- 4 files changed, 285 insertions(+), 122 deletions(-)
diff --git a/drivers/gpu/drm/drm_buddy.c b/drivers/gpu/drm/drm_buddy.c index 9340a4b61c5a..7f47632821f4 100644 --- a/drivers/gpu/drm/drm_buddy.c +++ b/drivers/gpu/drm/drm_buddy.c @@ -280,23 +280,97 @@ 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) +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;
+}
+static struct drm_buddy_block * +alloc_range_bias(struct drm_buddy_mm *mm,
u64 start, u64 end,unsigned int order)+{
- struct drm_buddy_block *block;
- struct drm_buddy_block *buddy;
- LIST_HEAD(dfs);
- int err;
- int i;
- end = end - 1;
- for (i = 0; i < mm->n_roots; ++i)
list_add_tail(&mm->roots[i]->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 (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))continue;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;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 ERR_PTR(-ENOSPC);
+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);- return ERR_PTR(err);
+}
+static struct drm_buddy_block * +alloc_from_freelist(struct drm_buddy_mm *mm,
unsigned int order,unsigned long flags)@@ -318,78 +392,28 @@ drm_buddy_alloc(struct drm_buddy_mm *mm, unsigned int order) while (i != order) { err = split_block(mm, block); if (unlikely(err))
goto out_free;
goto err_undo;
/* Go low */block = block->left;
block = block->right;
- mark_allocated(block);
- mm->avail -= drm_buddy_block_size(mm, block);
- kmemleak_update_trace(block); return block;
-out_free: +err_undo: 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)+static int __alloc_range(struct drm_buddy_mm *mm,
struct list_head *dfs,u64 start, u64 size,struct list_head *blocks)
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;
@@ -397,7 +421,7 @@ int drm_buddy_alloc_range(struct drm_buddy_mm *mm, u64 block_start; u64 block_end;
block = list_first_entry_or_null(&dfs,
block = list_first_entry_or_null(dfs, struct drm_buddy_block, tmp_link);@@ -424,7 +448,7 @@ int drm_buddy_alloc_range(struct drm_buddy_mm *mm,
mark_allocated(block); mm->avail -= drm_buddy_block_size(mm, block);
list_add_tail(&block->link, &allocated);
list_add_tail(&block->link, blocks); continue;@@ -434,11 +458,10 @@ int drm_buddy_alloc_range(struct drm_buddy_mm *mm, goto err_undo; }
list_add(&block->right->tmp_link, &dfs);list_add(&block->left->tmp_link, &dfs);
list_add(&block->right->tmp_link, dfs);list_add(&block->left->tmp_link, dfs);
list_splice_tail(&allocated, blocks); return 0;
err_undo:
@@ -453,11 +476,144 @@ int drm_buddy_alloc_range(struct drm_buddy_mm *mm, drm_buddy_block_is_free(buddy))) __drm_buddy_free(mm, block);
+err_free:
- drm_buddy_free_list(mm, blocks);
- return err;
+}
+/**
- __drm_buddy_alloc_range - actual range allocation
- @mm: DRM buddy manager to allocate from
- @start: start of the allowed range for this block
- @size: size of the allocation
- @blocks: output list head to add allocated blocks
- Intended for pre-allocating portions of the address space, for
+example to
- reserve a block for the initial framebuffer or similar
- Note that it's safe to chain together multiple alloc_ranges
- with the same blocks list
- Returns:
- 0 on success, error code on failure.
- */
+static int __drm_buddy_alloc_range(struct drm_buddy_mm *mm,
u64 start,u64 size,struct list_head *blocks)+{
- LIST_HEAD(dfs);
- int i;
- for (i = 0; i < mm->n_roots; ++i)
list_add_tail(&mm->roots[i]->tmp_link, &dfs);- return __alloc_range(mm, &dfs, start, size, blocks); }
+/**
- 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_bias() 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;- /* Actual range allocation */
- if (start + size == end)
return __drm_buddy_alloc_range(mm, start, size, blocks);- 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_bias(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..7621d42155e6 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,17 @@ 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; int ret;
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, mm->chunk_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
struct ttm_resource base; struct list_head blocks;
- @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 {
- unsigned long flags; struct drm_buddy_mm *mm; };
diff --git a/include/drm/drm_buddy.h b/include/drm/drm_buddy.h index f9ff48a3f3a6..221de702e909 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) @@ -132,12 +139,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
On 14/12/21 12:29 am, Matthew Auld wrote:
On 09/12/2021 15:47, Paneer Selvam, Arunpravin wrote:
[AMD Official Use Only]
Hi Matthew,
Ping on this?
No new comments from me :) I guess just a question of what we should do with the selftests, and then ofc at some point being able to throw this at CI, or at least test locally, once the series builds.
sure :) I think we should rewrite the i915 buddy selftests since now we have a single function for range and non-range requirements. I will rewrite the i915 buddy selftests and move to drm selftests folder? so for the time being, I remove the i915_buddy_mock_selftest() from i915_mock_selftests.h list to avoid build errors?
Regards, Arun -----Original Message----- From: amd-gfx amd-gfx-bounces@lists.freedesktop.org On Behalf Of Arunpravin Sent: Wednesday, December 1, 2021 10:10 PM To: dri-devel@lists.freedesktop.org; intel-gfx@lists.freedesktop.org; amd-gfx@lists.freedesktop.org Cc: daniel@ffwll.ch; Paneer Selvam, Arunpravin Arunpravin.PaneerSelvam@amd.com; jani.nikula@linux.intel.com; matthew.auld@intel.com; tzimmermann@suse.de; Deucher, Alexander Alexander.Deucher@amd.com; Koenig, Christian Christian.Koenig@amd.com Subject: [PATCH v4 2/6] drm: improve drm_buddy_alloc function
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
v4(Matthew Auld):
- keep drm_buddy_alloc_range() function implementation for generic actual range allocations
- keep alloc_range() implementation for end bias allocations
Signed-off-by: Arunpravin Arunpravin.PaneerSelvam@amd.com
drivers/gpu/drm/drm_buddy.c | 316 +++++++++++++----- drivers/gpu/drm/i915/i915_ttm_buddy_manager.c | 67 ++-- drivers/gpu/drm/i915/i915_ttm_buddy_manager.h | 2 + include/drm/drm_buddy.h | 22 +- 4 files changed, 285 insertions(+), 122 deletions(-)
diff --git a/drivers/gpu/drm/drm_buddy.c b/drivers/gpu/drm/drm_buddy.c index 9340a4b61c5a..7f47632821f4 100644 --- a/drivers/gpu/drm/drm_buddy.c +++ b/drivers/gpu/drm/drm_buddy.c @@ -280,23 +280,97 @@ 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) +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;
+}
+static struct drm_buddy_block * +alloc_range_bias(struct drm_buddy_mm *mm,
u64 start, u64 end,unsigned int order)+{
- struct drm_buddy_block *block;
- struct drm_buddy_block *buddy;
- LIST_HEAD(dfs);
- int err;
- int i;
- end = end - 1;
- for (i = 0; i < mm->n_roots; ++i)
list_add_tail(&mm->roots[i]->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 (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))continue;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;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 ERR_PTR(-ENOSPC);
+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);- return ERR_PTR(err);
+}
+static struct drm_buddy_block * +alloc_from_freelist(struct drm_buddy_mm *mm,
unsigned int order,unsigned long flags)@@ -318,78 +392,28 @@ drm_buddy_alloc(struct drm_buddy_mm *mm, unsigned int order) while (i != order) { err = split_block(mm, block); if (unlikely(err))
goto out_free;
goto err_undo;
/* Go low */block = block->left;
block = block->right;
- mark_allocated(block);
- mm->avail -= drm_buddy_block_size(mm, block);
- kmemleak_update_trace(block); return block;
-out_free: +err_undo: 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)+static int __alloc_range(struct drm_buddy_mm *mm,
struct list_head *dfs,u64 start, u64 size,struct list_head *blocks)
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;
@@ -397,7 +421,7 @@ int drm_buddy_alloc_range(struct drm_buddy_mm *mm, u64 block_start; u64 block_end;
block = list_first_entry_or_null(&dfs,
block = list_first_entry_or_null(dfs, struct drm_buddy_block, tmp_link);@@ -424,7 +448,7 @@ int drm_buddy_alloc_range(struct drm_buddy_mm *mm,
mark_allocated(block); mm->avail -= drm_buddy_block_size(mm, block);
list_add_tail(&block->link, &allocated);
list_add_tail(&block->link, blocks); continue;@@ -434,11 +458,10 @@ int drm_buddy_alloc_range(struct drm_buddy_mm *mm, goto err_undo; }
list_add(&block->right->tmp_link, &dfs);list_add(&block->left->tmp_link, &dfs);
list_add(&block->right->tmp_link, dfs);list_add(&block->left->tmp_link, dfs);
list_splice_tail(&allocated, blocks); return 0;
err_undo:
@@ -453,11 +476,144 @@ int drm_buddy_alloc_range(struct drm_buddy_mm *mm, drm_buddy_block_is_free(buddy))) __drm_buddy_free(mm, block);
+err_free:
- drm_buddy_free_list(mm, blocks);
- return err;
+}
+/**
- __drm_buddy_alloc_range - actual range allocation
- @mm: DRM buddy manager to allocate from
- @start: start of the allowed range for this block
- @size: size of the allocation
- @blocks: output list head to add allocated blocks
- Intended for pre-allocating portions of the address space, for
+example to
- reserve a block for the initial framebuffer or similar
- Note that it's safe to chain together multiple alloc_ranges
- with the same blocks list
- Returns:
- 0 on success, error code on failure.
- */
+static int __drm_buddy_alloc_range(struct drm_buddy_mm *mm,
u64 start,u64 size,struct list_head *blocks)+{
- LIST_HEAD(dfs);
- int i;
- for (i = 0; i < mm->n_roots; ++i)
list_add_tail(&mm->roots[i]->tmp_link, &dfs);- return __alloc_range(mm, &dfs, start, size, blocks); }
+/**
- 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_bias() 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;- /* Actual range allocation */
- if (start + size == end)
return __drm_buddy_alloc_range(mm, start, size, blocks);- 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_bias(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..7621d42155e6 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,17 @@ 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; int ret;
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, mm->chunk_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
struct ttm_resource base; struct list_head blocks;
- @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 {
- unsigned long flags; struct drm_buddy_mm *mm; };
diff --git a/include/drm/drm_buddy.h b/include/drm/drm_buddy.h index f9ff48a3f3a6..221de702e909 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) @@ -132,12 +139,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
On 15/12/2021 20:46, Arunpravin wrote:
On 14/12/21 12:29 am, Matthew Auld wrote:
On 09/12/2021 15:47, Paneer Selvam, Arunpravin wrote:
[AMD Official Use Only]
Hi Matthew,
Ping on this?
No new comments from me :) I guess just a question of what we should do with the selftests, and then ofc at some point being able to throw this at CI, or at least test locally, once the series builds.
sure :) I think we should rewrite the i915 buddy selftests since now we have a single function for range and non-range requirements. I will rewrite the i915 buddy selftests and move to drm selftests folder? so for the time being, I remove the i915_buddy_mock_selftest() from i915_mock_selftests.h list to avoid build errors?
Yeah, whatever is easiest.
Regards, Arun -----Original Message----- From: amd-gfx amd-gfx-bounces@lists.freedesktop.org On Behalf Of Arunpravin Sent: Wednesday, December 1, 2021 10:10 PM To: dri-devel@lists.freedesktop.org; intel-gfx@lists.freedesktop.org; amd-gfx@lists.freedesktop.org Cc: daniel@ffwll.ch; Paneer Selvam, Arunpravin Arunpravin.PaneerSelvam@amd.com; jani.nikula@linux.intel.com; matthew.auld@intel.com; tzimmermann@suse.de; Deucher, Alexander Alexander.Deucher@amd.com; Koenig, Christian Christian.Koenig@amd.com Subject: [PATCH v4 2/6] drm: improve drm_buddy_alloc function
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
v4(Matthew Auld): - keep drm_buddy_alloc_range() function implementation for generic actual range allocations - keep alloc_range() implementation for end bias allocations
Signed-off-by: Arunpravin Arunpravin.PaneerSelvam@amd.com
drivers/gpu/drm/drm_buddy.c | 316 +++++++++++++----- drivers/gpu/drm/i915/i915_ttm_buddy_manager.c | 67 ++-- drivers/gpu/drm/i915/i915_ttm_buddy_manager.h | 2 + include/drm/drm_buddy.h | 22 +- 4 files changed, 285 insertions(+), 122 deletions(-)
diff --git a/drivers/gpu/drm/drm_buddy.c b/drivers/gpu/drm/drm_buddy.c index 9340a4b61c5a..7f47632821f4 100644 --- a/drivers/gpu/drm/drm_buddy.c +++ b/drivers/gpu/drm/drm_buddy.c @@ -280,23 +280,97 @@ 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) +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;
+}
+static struct drm_buddy_block * +alloc_range_bias(struct drm_buddy_mm *mm,
u64 start, u64 end,unsigned int order)+{
- struct drm_buddy_block *block;
- struct drm_buddy_block *buddy;
- LIST_HEAD(dfs);
- int err;
- int i;
- end = end - 1;
- for (i = 0; i < mm->n_roots; ++i)
list_add_tail(&mm->roots[i]->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 (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))continue;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;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 ERR_PTR(-ENOSPC);
+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);- return ERR_PTR(err);
+}
+static struct drm_buddy_block * +alloc_from_freelist(struct drm_buddy_mm *mm,
unsigned int order,unsigned long flags)@@ -318,78 +392,28 @@ drm_buddy_alloc(struct drm_buddy_mm *mm, unsigned int order) while (i != order) { err = split_block(mm, block); if (unlikely(err))
goto out_free;
goto err_undo;
/* Go low */block = block->left;
block = block->right; i--;
- mark_allocated(block);
- mm->avail -= drm_buddy_block_size(mm, block);
- kmemleak_update_trace(block); return block;
-out_free: +err_undo: 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)+static int __alloc_range(struct drm_buddy_mm *mm,
struct list_head *dfs,u64 start, u64 size,struct list_head *blocks)
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;
@@ -397,7 +421,7 @@ int drm_buddy_alloc_range(struct drm_buddy_mm *mm, u64 block_start; u64 block_end;
block = list_first_entry_or_null(&dfs,
block = list_first_entry_or_null(dfs, struct drm_buddy_block, tmp_link); if (!block)@@ -424,7 +448,7 @@ int drm_buddy_alloc_range(struct drm_buddy_mm *mm,
mark_allocated(block); mm->avail -= drm_buddy_block_size(mm, block);
list_add_tail(&block->link, &allocated);
list_add_tail(&block->link, blocks); continue; }@@ -434,11 +458,10 @@ int drm_buddy_alloc_range(struct drm_buddy_mm *mm, goto err_undo; }
list_add(&block->right->tmp_link, &dfs);list_add(&block->left->tmp_link, &dfs);
list_add(&block->right->tmp_link, dfs);list_add(&block->left->tmp_link, dfs);
list_splice_tail(&allocated, blocks); return 0;
err_undo:
@@ -453,11 +476,144 @@ int drm_buddy_alloc_range(struct drm_buddy_mm *mm, drm_buddy_block_is_free(buddy))) __drm_buddy_free(mm, block);
+err_free:
- drm_buddy_free_list(mm, blocks);
- return err;
+}
+/**
- __drm_buddy_alloc_range - actual range allocation
- @mm: DRM buddy manager to allocate from
- @start: start of the allowed range for this block
- @size: size of the allocation
- @blocks: output list head to add allocated blocks
- Intended for pre-allocating portions of the address space, for
+example to
- reserve a block for the initial framebuffer or similar
- Note that it's safe to chain together multiple alloc_ranges
- with the same blocks list
- Returns:
- 0 on success, error code on failure.
- */
+static int __drm_buddy_alloc_range(struct drm_buddy_mm *mm,
u64 start,u64 size,struct list_head *blocks)+{
- LIST_HEAD(dfs);
- int i;
- for (i = 0; i < mm->n_roots; ++i)
list_add_tail(&mm->roots[i]->tmp_link, &dfs);- return __alloc_range(mm, &dfs, start, size, blocks); }
+/**
- 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_bias() 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;- /* Actual range allocation */
- if (start + size == end)
return __drm_buddy_alloc_range(mm, start, size, blocks);- 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_bias(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..7621d42155e6 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,17 @@ 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; int ret;
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, mm->chunk_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
struct ttm_resource base; struct list_head blocks;
- @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 {
- unsigned long flags; struct drm_buddy_mm *mm; };
diff --git a/include/drm/drm_buddy.h b/include/drm/drm_buddy.h index f9ff48a3f3a6..221de702e909 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) @@ -132,12 +139,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
Hi
Am 01.12.21 um 17:39 schrieb Arunpravin:
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
v4(Matthew Auld):
- keep drm_buddy_alloc_range() function implementation for generic actual range allocations
- keep alloc_range() implementation for end bias allocations
Signed-off-by: Arunpravin Arunpravin.PaneerSelvam@amd.com
drivers/gpu/drm/drm_buddy.c | 316 +++++++++++++----- drivers/gpu/drm/i915/i915_ttm_buddy_manager.c | 67 ++-- drivers/gpu/drm/i915/i915_ttm_buddy_manager.h | 2 + include/drm/drm_buddy.h | 22 +- 4 files changed, 285 insertions(+), 122 deletions(-)
diff --git a/drivers/gpu/drm/drm_buddy.c b/drivers/gpu/drm/drm_buddy.c index 9340a4b61c5a..7f47632821f4 100644 --- a/drivers/gpu/drm/drm_buddy.c +++ b/drivers/gpu/drm/drm_buddy.c @@ -280,23 +280,97 @@ 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) +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;
+}
+static struct drm_buddy_block * +alloc_range_bias(struct drm_buddy_mm *mm,
u64 start, u64 end,unsigned int order)+{
- struct drm_buddy_block *block;
- struct drm_buddy_block *buddy;
- LIST_HEAD(dfs);
- int err;
- int i;
- end = end - 1;
- for (i = 0; i < mm->n_roots; ++i)
list_add_tail(&mm->roots[i]->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 (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))continue;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;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 ERR_PTR(-ENOSPC);
+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);- return ERR_PTR(err);
+}
+static struct drm_buddy_block * +alloc_from_freelist(struct drm_buddy_mm *mm,
unsigned int order,unsigned long flags)@@ -318,78 +392,28 @@ drm_buddy_alloc(struct drm_buddy_mm *mm, unsigned int order) while (i != order) { err = split_block(mm, block); if (unlikely(err))
goto out_free;
goto err_undo;
/* Go low */block = block->left;
block = block->right;
- mark_allocated(block);
- mm->avail -= drm_buddy_block_size(mm, block);
- kmemleak_update_trace(block); return block;
-out_free: +err_undo: 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)+static int __alloc_range(struct drm_buddy_mm *mm,
struct list_head *dfs,u64 start, u64 size,struct list_head *blocks)
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;
@@ -397,7 +421,7 @@ int drm_buddy_alloc_range(struct drm_buddy_mm *mm, u64 block_start; u64 block_end;
block = list_first_entry_or_null(&dfs,
block = list_first_entry_or_null(dfs, struct drm_buddy_block, tmp_link);@@ -424,7 +448,7 @@ int drm_buddy_alloc_range(struct drm_buddy_mm *mm,
mark_allocated(block); mm->avail -= drm_buddy_block_size(mm, block);
list_add_tail(&block->link, &allocated);
list_add_tail(&block->link, blocks); continue;@@ -434,11 +458,10 @@ int drm_buddy_alloc_range(struct drm_buddy_mm *mm, goto err_undo; }
list_add(&block->right->tmp_link, &dfs);list_add(&block->left->tmp_link, &dfs);
list_add(&block->right->tmp_link, dfs);list_add(&block->left->tmp_link, dfs);
list_splice_tail(&allocated, blocks); return 0;
err_undo:
@@ -453,11 +476,144 @@ int drm_buddy_alloc_range(struct drm_buddy_mm *mm, drm_buddy_block_is_free(buddy))) __drm_buddy_free(mm, block);
+err_free:
- drm_buddy_free_list(mm, blocks);
- return err;
+}
+/**
- __drm_buddy_alloc_range - actual range allocation
- @mm: DRM buddy manager to allocate from
- @start: start of the allowed range for this block
- @size: size of the allocation
- @blocks: output list head to add allocated blocks
- Intended for pre-allocating portions of the address space, for example to
- reserve a block for the initial framebuffer or similar
- Note that it's safe to chain together multiple alloc_ranges
- with the same blocks list
- Returns:
- 0 on success, error code on failure.
- */
+static int __drm_buddy_alloc_range(struct drm_buddy_mm *mm,
u64 start,u64 size,struct list_head *blocks)+{
- LIST_HEAD(dfs);
- int i;
- for (i = 0; i < mm->n_roots; ++i)
list_add_tail(&mm->roots[i]->tmp_link, &dfs);- return __alloc_range(mm, &dfs, start, size, blocks);
+}
+/**
- 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_bias() 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;- /* Actual range allocation */
- if (start + size == end)
return __drm_buddy_alloc_range(mm, start, size, blocks);- 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_bias(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..7621d42155e6 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,17 @@ 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; int ret;
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, mm->chunk_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 f9ff48a3f3a6..221de702e909 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)
@@ -132,12 +139,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);
Just a style issue. The structure is called drm_buddy_mm. For consistency, I like to suggest to name all the public interfaces and defines drm_buddy_mm_* instead of just drm_buddy_*.
-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);
I'd call those *_alloc_blocks() and _free_blocks(). Right now it sounds as if they allocate and free instances of drm_buddy_mm.
Best regards Thomas
Hi Thomas
On 16/12/21 5:05 pm, Thomas Zimmermann wrote:
Hi
Am 01.12.21 um 17:39 schrieb Arunpravin:
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
v4(Matthew Auld):
- keep drm_buddy_alloc_range() function implementation for generic actual range allocations
- keep alloc_range() implementation for end bias allocations
Signed-off-by: Arunpravin Arunpravin.PaneerSelvam@amd.com
<SNIP>
+#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)
@@ -132,12 +139,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);
Just a style issue. The structure is called drm_buddy_mm. For consistency, I like to suggest to name all the public interfaces and defines drm_buddy_mm_* instead of just drm_buddy_*.
Thanks for the suggestion, I think renaming drm_buddy_* to drm_buddy_mm_* creates a long name for the public interfaces, for instance - drm_buddy_mm_alloc_blocks(), discussing the style issue internally @Matthew, @christian - please let me know your opinion
-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);
I'd call those *_alloc_blocks() and _free_blocks(). Right now it sounds as if they allocate and free instances of drm_buddy_mm.
can we call those drm_buddy_alloc_blocks() and drm_buddy_free_blocks() Does this make sense?
Best regards Thomas
Am 26.12.21 um 21:59 schrieb Arunpravin:
Hi Thomas
On 16/12/21 5:05 pm, Thomas Zimmermann wrote:
Hi
Am 01.12.21 um 17:39 schrieb Arunpravin:
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
v4(Matthew Auld): - keep drm_buddy_alloc_range() function implementation for generic actual range allocations - keep alloc_range() implementation for end bias allocations
Signed-off-by: Arunpravin Arunpravin.PaneerSelvam@amd.com
<SNIP>
+#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)
@@ -132,12 +139,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);
Just a style issue. The structure is called drm_buddy_mm. For consistency, I like to suggest to name all the public interfaces and defines drm_buddy_mm_* instead of just drm_buddy_*.
Thanks for the suggestion, I think renaming drm_buddy_* to drm_buddy_mm_* creates a long name for the public interfaces, for instance - drm_buddy_mm_alloc_blocks(), discussing the style issue internally @Matthew, @christian - please let me know your opinion
I would prefer drm_buddy as prefix as well and I think we could rather drop the _mm postfix from the structure here.
Cause what we try to manage is not necessary memory, but rather address space.
Christian.
-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);
I'd call those *_alloc_blocks() and _free_blocks(). Right now it sounds as if they allocate and free instances of drm_buddy_mm.
can we call those drm_buddy_alloc_blocks() and drm_buddy_free_blocks() Does this make sense?
Best regards Thomas
Hi
Am 03.01.22 um 08:41 schrieb Christian König:
Am 26.12.21 um 21:59 schrieb Arunpravin:
Hi Thomas
On 16/12/21 5:05 pm, Thomas Zimmermann wrote:
Hi
Am 01.12.21 um 17:39 schrieb Arunpravin:
- 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
v4(Matthew Auld): - keep drm_buddy_alloc_range() function implementation for generic actual range allocations - keep alloc_range() implementation for end bias allocations
Signed-off-by: Arunpravin Arunpravin.PaneerSelvam@amd.com
<SNIP>
+#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) @@ -132,12 +139,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);
Just a style issue. The structure is called drm_buddy_mm. For consistency, I like to suggest to name all the public interfaces and defines drm_buddy_mm_* instead of just drm_buddy_*.
Thanks for the suggestion, I think renaming drm_buddy_* to drm_buddy_mm_* creates a long name for the public interfaces, for instance - drm_buddy_mm_alloc_blocks(), discussing the style issue internally @Matthew, @christian - please let me know your opinion
I would prefer drm_buddy as prefix as well and I think we could rather drop the _mm postfix from the structure here.
I was mostly concerned about mismatching names for functions and structures. If drm_buddy_ (without mm) for all naming is preferred, I wouldn't mind.
Best regards Thomas
Cause what we try to manage is not necessary memory, but rather address space.
Christian.
-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);
I'd call those *_alloc_blocks() and _free_blocks(). Right now it sounds as if they allocate and free instances of drm_buddy_mm.
can we call those drm_buddy_alloc_blocks() and drm_buddy_free_blocks() Does this make sense?
Best regards Thomas
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 7f47632821f4..eddc1eeda02e 100644 --- a/drivers/gpu/drm/drm_buddy.c +++ b/drivers/gpu/drm/drm_buddy.c @@ -367,6 +367,26 @@ alloc_range_bias(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, @@ -377,11 +397,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 7621d42155e6..7c58efb60dba 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 221de702e909..316ac0d25f08 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)
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
v3: - remove drm_buddy_block_trim() error handling and print a warn message if it fails
Signed-off-by: Arunpravin Arunpravin.PaneerSelvam@amd.com --- drivers/gpu/drm/drm_buddy.c | 72 ++++++++++++++++++- drivers/gpu/drm/i915/i915_ttm_buddy_manager.c | 10 +++ include/drm/drm_buddy.h | 4 ++ 3 files changed, 83 insertions(+), 3 deletions(-)
diff --git a/drivers/gpu/drm/drm_buddy.c b/drivers/gpu/drm/drm_buddy.c index eddc1eeda02e..707efc82216d 100644 --- a/drivers/gpu/drm/drm_buddy.c +++ b/drivers/gpu/drm/drm_buddy.c @@ -434,7 +434,8 @@ alloc_from_freelist(struct drm_buddy_mm *mm, static int __alloc_range(struct drm_buddy_mm *mm, struct list_head *dfs, u64 start, u64 size, - struct list_head *blocks) + struct list_head *blocks, + bool trim_path) { struct drm_buddy_block *block; struct drm_buddy_block *buddy; @@ -480,8 +481,20 @@ static int __alloc_range(struct drm_buddy_mm *mm,
if (!drm_buddy_block_is_split(block)) { err = split_block(mm, block); - if (unlikely(err)) + if (unlikely(err)) { + if (trim_path) + /* + * Here in case of trim, we return and dont goto + * split failure path as it removes from the + * original list and potentially also freeing + * the block. so we could leave as it is, + * worse case we get some internal fragmentation + * and leave the decision to the user + */ + return err; + goto err_undo; + } }
list_add(&block->right->tmp_link, dfs); @@ -535,8 +548,61 @@ static int __drm_buddy_alloc_range(struct drm_buddy_mm *mm, for (i = 0; i < mm->n_roots; ++i) list_add_tail(&mm->roots[i]->tmp_link, &dfs);
- return __alloc_range(mm, &dfs, start, size, blocks); + return __alloc_range(mm, &dfs, start, size, blocks, 0); +} + +/** + * 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; + u64 new_start; + LIST_HEAD(dfs); + + 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); + + mark_free(mm, block); + + list_add(&block->tmp_link, &dfs); + + return __alloc_range(mm, &dfs, new_start, new_size, blocks, 1); } +EXPORT_SYMBOL(drm_buddy_block_trim);
/** * drm_buddy_alloc - allocate power-of-two blocks diff --git a/drivers/gpu/drm/i915/i915_ttm_buddy_manager.c b/drivers/gpu/drm/i915/i915_ttm_buddy_manager.c index 7c58efb60dba..c5831c27fe82 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); + pr_warn("drm_buddy_block_trim failed returing %d for ttm_buffer_object(%p)\n", + err, bo); + } + *res = &bman_res->base; return 0;
diff --git a/include/drm/drm_buddy.h b/include/drm/drm_buddy.h index 316ac0d25f08..90906d9dbbf0 100644 --- a/include/drm/drm_buddy.h +++ b/include/drm/drm_buddy.h @@ -146,6 +146,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);
[Public]
Hi Matthew,
Ping?
Regards, Arun -----Original Message----- From: Paneer Selvam, Arunpravin Arunpravin.PaneerSelvam@amd.com Sent: Wednesday, December 1, 2021 10:10 PM To: dri-devel@lists.freedesktop.org; intel-gfx@lists.freedesktop.org; amd-gfx@lists.freedesktop.org Cc: matthew.auld@intel.com; daniel@ffwll.ch; Koenig, Christian Christian.Koenig@amd.com; Deucher, Alexander Alexander.Deucher@amd.com; tzimmermann@suse.de; jani.nikula@linux.intel.com; Paneer Selvam, Arunpravin Arunpravin.PaneerSelvam@amd.com Subject: [PATCH v4 4/6] drm: implement a method to free unused pages
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
v3: - remove drm_buddy_block_trim() error handling and print a warn message if it fails
Signed-off-by: Arunpravin Arunpravin.PaneerSelvam@amd.com --- drivers/gpu/drm/drm_buddy.c | 72 ++++++++++++++++++- drivers/gpu/drm/i915/i915_ttm_buddy_manager.c | 10 +++ include/drm/drm_buddy.h | 4 ++ 3 files changed, 83 insertions(+), 3 deletions(-)
diff --git a/drivers/gpu/drm/drm_buddy.c b/drivers/gpu/drm/drm_buddy.c index eddc1eeda02e..707efc82216d 100644 --- a/drivers/gpu/drm/drm_buddy.c +++ b/drivers/gpu/drm/drm_buddy.c @@ -434,7 +434,8 @@ alloc_from_freelist(struct drm_buddy_mm *mm, static int __alloc_range(struct drm_buddy_mm *mm, struct list_head *dfs, u64 start, u64 size, - struct list_head *blocks) + struct list_head *blocks, + bool trim_path) { struct drm_buddy_block *block; struct drm_buddy_block *buddy; @@ -480,8 +481,20 @@ static int __alloc_range(struct drm_buddy_mm *mm,
if (!drm_buddy_block_is_split(block)) { err = split_block(mm, block); - if (unlikely(err)) + if (unlikely(err)) { + if (trim_path) + /* + * Here in case of trim, we return and dont goto + * split failure path as it removes from the + * original list and potentially also freeing + * the block. so we could leave as it is, + * worse case we get some internal fragmentation + * and leave the decision to the user + */ + return err; + goto err_undo; + } }
list_add(&block->right->tmp_link, dfs); @@ -535,8 +548,61 @@ static int __drm_buddy_alloc_range(struct drm_buddy_mm *mm, for (i = 0; i < mm->n_roots; ++i) list_add_tail(&mm->roots[i]->tmp_link, &dfs);
- return __alloc_range(mm, &dfs, start, size, blocks); + return __alloc_range(mm, &dfs, start, size, blocks, 0); } + +/** + * 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; + u64 new_start; + LIST_HEAD(dfs); + + 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); + + mark_free(mm, block); + + list_add(&block->tmp_link, &dfs); + + return __alloc_range(mm, &dfs, new_start, new_size, blocks, 1); } +EXPORT_SYMBOL(drm_buddy_block_trim);
/** * drm_buddy_alloc - allocate power-of-two blocks diff --git a/drivers/gpu/drm/i915/i915_ttm_buddy_manager.c b/drivers/gpu/drm/i915/i915_ttm_buddy_manager.c index 7c58efb60dba..c5831c27fe82 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); + pr_warn("drm_buddy_block_trim failed returing %d for ttm_buffer_object(%p)\n", + err, bo); + } + *res = &bman_res->base; return 0;
diff --git a/include/drm/drm_buddy.h b/include/drm/drm_buddy.h index 316ac0d25f08..90906d9dbbf0 100644 --- a/include/drm/drm_buddy.h +++ b/include/drm/drm_buddy.h @@ -146,6 +146,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
On 01/12/2021 16:39, 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
v3:
- remove drm_buddy_block_trim() error handling and print a warn message if it fails
Signed-off-by: Arunpravin Arunpravin.PaneerSelvam@amd.com
drivers/gpu/drm/drm_buddy.c | 72 ++++++++++++++++++- drivers/gpu/drm/i915/i915_ttm_buddy_manager.c | 10 +++ include/drm/drm_buddy.h | 4 ++ 3 files changed, 83 insertions(+), 3 deletions(-)
diff --git a/drivers/gpu/drm/drm_buddy.c b/drivers/gpu/drm/drm_buddy.c index eddc1eeda02e..707efc82216d 100644 --- a/drivers/gpu/drm/drm_buddy.c +++ b/drivers/gpu/drm/drm_buddy.c @@ -434,7 +434,8 @@ alloc_from_freelist(struct drm_buddy_mm *mm, static int __alloc_range(struct drm_buddy_mm *mm, struct list_head *dfs, u64 start, u64 size,
struct list_head *blocks)
struct list_head *blocks,bool trim_path)@@ -480,8 +481,20 @@ static int __alloc_range(struct drm_buddy_mm *mm,
if (!drm_buddy_block_is_split(block)) { err = split_block(mm, block);
if (unlikely(err))
if (unlikely(err)) {if (trim_path)/** Here in case of trim, we return and dont goto* split failure path as it removes from the* original list and potentially also freeing* the block. so we could leave as it is,* worse case we get some internal fragmentation* and leave the decision to the user*/return err;
Hmm, ideally we don't want to leave around blocks where both buddies are free without then also merging them back(not sure if that trips some BUG_ON). Also IIUC, if we hit this failure path, depending on where the split_block() fails we might be allocating something less than new_size? Also if it's the first split_block() that fails then the user just gets an empty list?
Could we perhaps just turn this node into a temporary root node to prevent recursively freeing itself, but still retain the un-splitting/freeing of the other nodes i.e something like:
list_del(&block->link); mark_free(mm, block); mm->avail += ...;
/* Prevent recursively freeing this node */ parent = block->parent; block->parent = NULL;
list_add(&block->tmp_link, &dfs); ret = _alloc_range(mm, &dfs, new_start, new_size, blocks); if (ret) { mem->avail -= ...; mark_allocated(block); list_add(&block->link, blocks); }
block->parent = parent; return ret;
That way we can also drop the special trim_path handling. Thoughts?
goto err_undo;}}
list_add(&block->right->tmp_link, dfs);
@@ -535,8 +548,61 @@ static int __drm_buddy_alloc_range(struct drm_buddy_mm *mm, for (i = 0; i < mm->n_roots; ++i) list_add_tail(&mm->roots[i]->tmp_link, &dfs);
- return __alloc_range(mm, &dfs, start, size, blocks);
- return __alloc_range(mm, &dfs, start, size, blocks, 0);
+}
+/**
- 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;
- u64 new_start;
- LIST_HEAD(dfs);
- 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);
- mark_free(mm, block);
- list_add(&block->tmp_link, &dfs);
- return __alloc_range(mm, &dfs, new_start, new_size, blocks, 1); }
+EXPORT_SYMBOL(drm_buddy_block_trim);
/**
- drm_buddy_alloc - allocate power-of-two blocks
diff --git a/drivers/gpu/drm/i915/i915_ttm_buddy_manager.c b/drivers/gpu/drm/i915/i915_ttm_buddy_manager.c index 7c58efb60dba..c5831c27fe82 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);pr_warn("drm_buddy_block_trim failed returing %d for ttm_buffer_object(%p)\n",err, bo);
IIUC this prints a warning even for success? Anyway, I think we can drop the pr_warn, since normal user can't really do much here?
- }
- *res = &bman_res->base; return 0;
diff --git a/include/drm/drm_buddy.h b/include/drm/drm_buddy.h index 316ac0d25f08..90906d9dbbf0 100644 --- a/include/drm/drm_buddy.h +++ b/include/drm/drm_buddy.h @@ -146,6 +146,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);
On 14/12/21 12:10 am, Matthew Auld wrote:
On 01/12/2021 16:39, 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
v3:
- remove drm_buddy_block_trim() error handling and print a warn message if it fails
Signed-off-by: Arunpravin Arunpravin.PaneerSelvam@amd.com
drivers/gpu/drm/drm_buddy.c | 72 ++++++++++++++++++- drivers/gpu/drm/i915/i915_ttm_buddy_manager.c | 10 +++ include/drm/drm_buddy.h | 4 ++ 3 files changed, 83 insertions(+), 3 deletions(-)
diff --git a/drivers/gpu/drm/drm_buddy.c b/drivers/gpu/drm/drm_buddy.c index eddc1eeda02e..707efc82216d 100644 --- a/drivers/gpu/drm/drm_buddy.c +++ b/drivers/gpu/drm/drm_buddy.c @@ -434,7 +434,8 @@ alloc_from_freelist(struct drm_buddy_mm *mm, static int __alloc_range(struct drm_buddy_mm *mm, struct list_head *dfs, u64 start, u64 size,
struct list_head *blocks)
struct list_head *blocks,bool trim_path)@@ -480,8 +481,20 @@ static int __alloc_range(struct drm_buddy_mm *mm,
if (!drm_buddy_block_is_split(block)) { err = split_block(mm, block);
if (unlikely(err))
if (unlikely(err)) {if (trim_path)/** Here in case of trim, we return and dont goto* split failure path as it removes from the* original list and potentially also freeing* the block. so we could leave as it is,* worse case we get some internal fragmentation* and leave the decision to the user*/return err;Hmm, ideally we don't want to leave around blocks where both buddies are free without then also merging them back(not sure if that trips some BUG_ON). Also IIUC, if we hit this failure path, depending on where the split_block() fails we might be allocating something less than new_size? Also if it's the first split_block() that fails then the user just gets an empty list?
Could we perhaps just turn this node into a temporary root node to prevent recursively freeing itself, but still retain the un-splitting/freeing of the other nodes i.e something like:
list_del(&block->link); mark_free(mm, block); mm->avail += ...;
/* Prevent recursively freeing this node */ parent = block->parent; block->parent = NULL;
list_add(&block->tmp_link, &dfs); ret = _alloc_range(mm, &dfs, new_start, new_size, blocks); if (ret) { mem->avail -= ...; mark_allocated(block); list_add(&block->link, blocks); }
block->parent = parent; return ret;
That way we can also drop the special trim_path handling. Thoughts?
That's a nice idea. It will work.
goto err_undo;}}
list_add(&block->right->tmp_link, dfs);
@@ -535,8 +548,61 @@ static int __drm_buddy_alloc_range(struct drm_buddy_mm *mm, for (i = 0; i < mm->n_roots; ++i) list_add_tail(&mm->roots[i]->tmp_link, &dfs);
- return __alloc_range(mm, &dfs, start, size, blocks);
- return __alloc_range(mm, &dfs, start, size, blocks, 0);
+}
+/**
- 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;
- u64 new_start;
- LIST_HEAD(dfs);
- 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);
- mark_free(mm, block);
- list_add(&block->tmp_link, &dfs);
- return __alloc_range(mm, &dfs, new_start, new_size, blocks, 1); }
+EXPORT_SYMBOL(drm_buddy_block_trim);
/**
- drm_buddy_alloc - allocate power-of-two blocks
diff --git a/drivers/gpu/drm/i915/i915_ttm_buddy_manager.c b/drivers/gpu/drm/i915/i915_ttm_buddy_manager.c index 7c58efb60dba..c5831c27fe82 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);pr_warn("drm_buddy_block_trim failed returing %d for ttm_buffer_object(%p)\n",err, bo);IIUC this prints a warning even for success? Anyway, I think we can drop the pr_warn, since normal user can't really do much here?
Yes, I will drop pr_warn
- }
- *res = &bman_res->base; return 0;
diff --git a/include/drm/drm_buddy.h b/include/drm/drm_buddy.h index 316ac0d25f08..90906d9dbbf0 100644 --- a/include/drm/drm_buddy.h +++ b/include/drm/drm_buddy.h @@ -146,6 +146,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);
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
- 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
v3: - remove drm_buddy_block_trim() error handling and print a warn message if it fails
Signed-off-by: Arunpravin Arunpravin.PaneerSelvam@amd.com --- drivers/gpu/drm/Kconfig | 1 + .../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 | 261 ++++++++++-------- 4 files changed, 232 insertions(+), 133 deletions(-)
diff --git a/drivers/gpu/drm/Kconfig b/drivers/gpu/drm/Kconfig index 7a4a66d54782..dd880910282b 100644 --- a/drivers/gpu/drm/Kconfig +++ b/drivers/gpu/drm/Kconfig @@ -276,6 +276,7 @@ config DRM_AMDGPU select HWMON select BACKLIGHT_CLASS_DEVICE select INTERVAL_TREE + select DRM_BUDDY help Choose this option if you have a recent AMD Radeon graphics card.
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..ca57de89d274 100644 --- a/drivers/gpu/drm/amd/amdgpu/amdgpu_vram_mgr.c +++ b/drivers/gpu/drm/amd/amdgpu/amdgpu_vram_mgr.c @@ -32,8 +32,11 @@ #include "atom.h"
struct amdgpu_vram_reservation { + u64 start; + u64 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 +199,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 +223,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 +233,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 +244,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, mm->chunk_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 +290,16 @@ 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->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 +322,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 +342,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 +361,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 +386,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 +397,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 +407,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 +425,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); + pr_warn("drm_buddy_block_trim failed returing %d for ttm_buffer_object(%p)\n", + r, tbo); + } + + 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 +495,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 +517,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 +692,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 +728,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 +769,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);
Hi Arunpravin,
Thank you for the patch! Yet something to improve:
[auto build test ERROR on drm-intel/for-linux-next] [also build test ERROR on v5.16-rc3] [cannot apply to drm/drm-next drm-tip/drm-tip next-20211201] [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-alloc... base: git://anongit.freedesktop.org/drm-intel for-linux-next config: x86_64-randconfig-a012-20211130 (https://download.01.org/0day-ci/archive/20211202/202112020812.Si0y9psY-lkp@i...) compiler: clang version 14.0.0 (https://github.com/llvm/llvm-project 4b553297ef3ee4dc2119d5429adf3072e90fac38) reproduce (this is a W=1 build): wget https://raw.githubusercontent.com/intel/lkp-tests/master/sbin/make.cross -O ~/bin/make.cross chmod +x ~/bin/make.cross # https://github.com/0day-ci/linux/commit/afbc900c0399e8c6220abd729932e877e81f... 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/20211202-004327 git checkout afbc900c0399e8c6220abd729932e877e81f37c8 # save the config file to linux build tree mkdir build_dir COMPILER_INSTALL_PATH=$HOME/0day COMPILER=clang make.cross W=1 O=build_dir ARCH=x86_64 SHELL=/bin/bash drivers/gpu/
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' file not found
#include "i915_buddy.h" ^~~~~~~~~~~~~~ 1 error generated.
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
Hi Arunpravin,
Thank you for the patch! Yet something to improve:
[auto build test ERROR on drm-intel/for-linux-next] [also build test ERROR on v5.16-rc3] [cannot apply to drm/drm-next drm-tip/drm-tip next-20211201] [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-alloc... base: git://anongit.freedesktop.org/drm-intel for-linux-next config: i386-allyesconfig (https://download.01.org/0day-ci/archive/20211202/202112021239.jPtbRhi2-lkp@i...) 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/afbc900c0399e8c6220abd729932e877e81f... 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/20211202-004327 git checkout afbc900c0399e8c6220abd729932e877e81f37c8 # save the config file 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
232a6ebae41919 Matthew Auld 2019-10-08 14 340be48f2c5a3c Matthew Auld 2019-10-25 15 #include "gem/i915_gem_context.h" b908be543e4441 Matthew Auld 2019-10-25 16 #include "gem/i915_gem_lmem.h" 232a6ebae41919 Matthew Auld 2019-10-08 17 #include "gem/i915_gem_region.h" 340be48f2c5a3c Matthew Auld 2019-10-25 18 #include "gem/selftests/igt_gem_utils.h" 232a6ebae41919 Matthew Auld 2019-10-08 19 #include "gem/selftests/mock_context.h" 99919be74aa375 Thomas Hellström 2021-06-17 20 #include "gt/intel_engine_pm.h" 6804da20bb549e Chris Wilson 2019-10-27 21 #include "gt/intel_engine_user.h" b908be543e4441 Matthew Auld 2019-10-25 22 #include "gt/intel_gt.h" d53ec322dc7de3 Matthew Auld 2021-06-16 @23 #include "i915_buddy.h" 99919be74aa375 Thomas Hellström 2021-06-17 24 #include "gt/intel_migrate.h" ba12993c522801 Matthew Auld 2020-01-29 25 #include "i915_memcpy.h" d53ec322dc7de3 Matthew Auld 2021-06-16 26 #include "i915_ttm_buddy_manager.h" 01377a0d7e6648 Abdiel Janulgue 2019-10-25 27 #include "selftests/igt_flush_test.h" 2f0b97ca021186 Matthew Auld 2019-10-08 28 #include "selftests/i915_random.h" 232a6ebae41919 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
Am 01.12.21 um 17:39 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)
v3:
- make drm buddy a separate module(Thomas, Christian)
I only skimmed over this, but this looks really good now.
Only remaining problem is that you need to fix the build error reported by the kernel robot in drivers/gpu/drm/i915/selftests/intel_memory_region.c.
I strongly suggest that you use a build test config with all DRM drivers and selftests enabled to narrow down things like that before sending it out. I can help with that if necessary.
Regards, Christian.
Signed-off-by: Arunpravin Arunpravin.PaneerSelvam@amd.com
drivers/gpu/drm/Kconfig | 6 + drivers/gpu/drm/Makefile | 2 + drivers/gpu/drm/drm_buddy.c | 516 ++++++++++++++++++ drivers/gpu/drm/i915/Kconfig | 1 + 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 | 154 ++++++ 12 files changed, 703 insertions(+), 637 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/Kconfig b/drivers/gpu/drm/Kconfig index 0039df26854b..7a4a66d54782 100644 --- a/drivers/gpu/drm/Kconfig +++ b/drivers/gpu/drm/Kconfig @@ -197,6 +197,12 @@ config DRM_TTM GPU memory types. Will be enabled automatically if a device driver uses it.
+config DRM_BUDDY
- tristate
- depends on DRM
- help
A page based buddy allocator- config DRM_VRAM_HELPER tristate depends on DRM
diff --git a/drivers/gpu/drm/Makefile b/drivers/gpu/drm/Makefile index 0dff40bb863c..e62e432bf1e5 100644 --- a/drivers/gpu/drm/Makefile +++ b/drivers/gpu/drm/Makefile @@ -35,6 +35,8 @@ drm-$(CONFIG_DRM_LOAD_EDID_FIRMWARE) += drm_edid_load.o
obj-$(CONFIG_DRM_DP_AUX_BUS) += drm_dp_aux_bus.o
+obj-$(CONFIG_DRM_BUDDY) += drm_buddy.o
- drm_vram_helper-y := drm_gem_vram_helper.o obj-$(CONFIG_DRM_VRAM_HELPER) += drm_vram_helper.o
diff --git a/drivers/gpu/drm/drm_buddy.c b/drivers/gpu/drm/drm_buddy.c new file mode 100644 index 000000000000..9340a4b61c5a --- /dev/null +++ b/drivers/gpu/drm/drm_buddy.c @@ -0,0 +1,516 @@ +// SPDX-License-Identifier: MIT +/*
- Copyright © 2021 Intel Corporation
- */
+#include <linux/kmemleak.h> +#include <linux/module.h> +#include <linux/sizes.h>
+#include <drm/drm_buddy.h>
+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(mm->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(mm->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->slab_blocks = KMEM_CACHE(drm_buddy_block, 0);
- if (!mm->slab_blocks)
return -ENOMEM;- mm->free_list = kmalloc_array(mm->max_order + 1,
sizeof(struct list_head),GFP_KERNEL);- if (!mm->free_list)
goto out_destroy_slab;- 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);
+out_destroy_slab:
- kmem_cache_destroy(mm->slab_blocks);
- 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);
- kmem_cache_destroy(mm->slab_blocks);
+} +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);elsedrm_printf(p, "free: %lluMiB", free >> 20);drm_printf(p, ", pages: %llu\n", count);- }
+} +EXPORT_SYMBOL(drm_buddy_print);
+MODULE_DESCRIPTION("DRM Buddy Allocator"); +MODULE_LICENSE("GPL"); diff --git a/drivers/gpu/drm/i915/Kconfig b/drivers/gpu/drm/i915/Kconfig index a4c94dc2e216..64b5e0a44d4c 100644 --- a/drivers/gpu/drm/i915/Kconfig +++ b/drivers/gpu/drm/i915/Kconfig @@ -27,6 +27,7 @@ config DRM_I915 select CEC_CORE if CEC_NOTIFIER select VMAP_PFN select DRM_TTM
- select DRM_BUDDY help Choose this option if you have a system that has "Intel Graphics Media Accelerator" or "HD Graphics" integrated graphics,
diff --git a/drivers/gpu/drm/i915/Makefile b/drivers/gpu/drm/i915/Makefile index 568d711a3537..a5a0fb33c897 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 \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);elsedrm_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 },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);@@ -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..f9ff48a3f3a6 --- /dev/null +++ b/include/drm/drm_buddy.h @@ -0,0 +1,154 @@ +/* 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 {
- struct kmem_cache *slab_blocks;
- /* 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
dri-devel@lists.freedesktop.org
-
Arunpravin -
Arunpravin
-
Christian König -
Christian König -
kernel test robot -
Matthew Auld -
Paneer Selvam, Arunpravin
-
Thomas Zimmermann