771ca4e8e2
Creating a memory allocator based on linked list (ll-pool) to support non-contiguous allocation for remote memory. It is to be used in ab-dram component to replace current genpool allocator. The reason this component is needed is that the genpool allocator does not allow non-contiguous allocation, and there is no off-the-shelf solution that does that. Bug:128546831 Change-Id: I8af9a44f8b19ffbbdb8b193f64faa6e65a3f9d2a Signed-off-by: Alex Tang <pztang@google.com>
99 lines
3.0 KiB
C
99 lines
3.0 KiB
C
/*
|
|
* Linked List Based Memory Allocator
|
|
*
|
|
* Copyright (C) 2019 Google, Inc.
|
|
*
|
|
* This software is licensed under the terms of the GNU General Public
|
|
* License version 2, as published by the Free Software Foundation, and
|
|
* may be copied, distributed, and modified under those terms.
|
|
*
|
|
* This program is distributed in the hope that it will be useful,
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
* GNU General Public License for more details.
|
|
*/
|
|
|
|
#ifndef __LL_POOL_H__
|
|
#define __LL_POOL_H__
|
|
|
|
#include <linux/list.h>
|
|
#include <linux/mutex.h>
|
|
#include <linux/slab.h>
|
|
#include <linux/scatterlist.h>
|
|
#include <linux/types.h>
|
|
|
|
/* Allocator with allocation granularity of page size
|
|
* Note: this allocator may sleep, do not use in interrupt context
|
|
*/
|
|
|
|
/**
|
|
* ll_pool: allocator instance object contains meta-data
|
|
*
|
|
* @lock: mutex lock to synchronize usage of the allocator
|
|
* @free_list_head: list to all free memory blocks in order
|
|
* @base_addr: starting address for the managed range
|
|
* @remaining_size: remaining free bytes
|
|
* @mem_block_slab: slab for allocating mem block struct
|
|
* @allocation_slab: slab for allocating allocation struct
|
|
*/
|
|
struct ll_pool {
|
|
struct mutex lock;
|
|
struct list_head free_list_head;
|
|
phys_addr_t base_addr;
|
|
size_t remaining_size;
|
|
|
|
struct kmem_cache *mem_block_slab;
|
|
struct kmem_cache *allocation_slab;
|
|
};
|
|
|
|
/**
|
|
* ll_pool_alloc(): Allocate from ll pool
|
|
* @pool: allocator pool to allocate memory from
|
|
* @len: length of memory requested in bytes
|
|
* @contiguous: whether allocation is to be contiguous
|
|
*
|
|
* Use this function to allocate memory from the given memory pool.
|
|
*
|
|
* Return: pointer to the sg_table(scattergather list table) of the allocation.
|
|
*/
|
|
struct sg_table *ll_pool_alloc(struct ll_pool *pool, size_t len,
|
|
bool contiguous);
|
|
|
|
/**
|
|
* ll_pool_free(): Free an allocation from a given pool
|
|
* @pool: allocator pool the allocation is from
|
|
* @table: sg_table(scattergather list table) of the allocation to be freed
|
|
*
|
|
* Function takes 2 parameters: the pool and the table. After calling This
|
|
* function the sg_table pointer becomes invalid for the user.
|
|
*
|
|
* Return: Function does not return anything.
|
|
*/
|
|
void ll_pool_free(struct ll_pool *pool, struct sg_table *table);
|
|
|
|
/**
|
|
* ll_pool_create(): create a remote linked list based allocator pool
|
|
* @base: base address that the pool manages
|
|
* @size: size in bytes of the memory to be managed
|
|
*
|
|
* Create an allocator pool object.
|
|
*
|
|
* Return: pointer to the pool object
|
|
*/
|
|
struct ll_pool *ll_pool_create(phys_addr_t base, size_t size);
|
|
|
|
/**
|
|
* ll_pool_destroy(): destroy a given remote linked list based
|
|
* allocator pool
|
|
* @pool: allocator pool to be destroyed
|
|
*
|
|
* Destroy the given remote linked list based allocator pool. If allocations
|
|
* still exist, they will become invalid/unmanaged, and there will be a Memory
|
|
* leak due to unreleased sg_tables.
|
|
*
|
|
* Return: Function does not return anything.
|
|
*/
|
|
void ll_pool_destroy(struct ll_pool *pool);
|
|
|
|
#endif /* __LL_POOL_H__ */
|