![Ossama Othman](/assets/img/avatar_default.png)
The Intel Restricted Access Region Handler provides a buffer allocation mechanism to RAR users. Since the intended usage model is to lock out CPU access to RAR (the CPU will not be able to access RAR memory), this driver does not access RAR memory, and merely keeps track of what areas of RAR memory are in use. It has it's own simple allocator that does not rely on existing kernel allocators (SLAB, etc) since those allocators are too tightly coupled with the paging mechanism, which isn't needed for the intended RAR use cases. An mmap() implementation is provided for debugging purposes to simplify RAR memory access from the user space. However, it will effectively be a no-op when RAR access control is enabled since the CPU will not be able to access RAR. This driver should not be confused with the rar_register driver. That driver exposes an interface to access RAR registers on the Moorestown platform. The RAR handler driver relies on the rar_register driver for low level RAR register reads and writes. This patch was generated and built against the latest linux-2.6 master branch. Signed-off-by: Ossama Othman <ossama.othman@intel.com> Signed-off-by: Greg Kroah-Hartman <gregkh@suse.de>
150 lines
5.1 KiB
C
150 lines
5.1 KiB
C
/*
|
|
* Copyright (C) 2010 Intel Corporation. All rights reserved.
|
|
*
|
|
* This program is free software; you can redistribute it and/or
|
|
* modify it under the terms of version 2 of the GNU General
|
|
* Public License as published by the Free Software Foundation.
|
|
*
|
|
* This program is distributed in the hope that it will be
|
|
* useful, but WITHOUT ANY WARRANTY; without even the implied
|
|
* warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
|
|
* PURPOSE. See the GNU General Public License for more details.
|
|
* You should have received a copy of the GNU General Public
|
|
* License along with this program; if not, write to the Free
|
|
* Software Foundation, Inc., 59 Temple Place - Suite 330,
|
|
* Boston, MA 02111-1307, USA.
|
|
* The full GNU General Public License is included in this
|
|
* distribution in the file called COPYING.
|
|
*/
|
|
|
|
#ifndef MEMRAR_ALLOCATOR_H
|
|
#define MEMRAR_ALLOCATOR_H
|
|
|
|
|
|
#include <linux/mutex.h>
|
|
#include <linux/list.h>
|
|
#include <linux/types.h>
|
|
#include <linux/kernel.h>
|
|
|
|
|
|
/**
|
|
* struct memrar_address_range - struct that describes a memory range
|
|
* @begin: Beginning of available address range.
|
|
* @end: End of available address range, one past the end,
|
|
* i.e. [begin, end).
|
|
*/
|
|
struct memrar_address_range {
|
|
/* private: internal use only */
|
|
unsigned long begin;
|
|
unsigned long end;
|
|
};
|
|
|
|
/**
|
|
* struct memrar_address_ranges - list of areas of memory.
|
|
* @list: Linked list of address ranges.
|
|
* @range: Memory address range corresponding to given list node.
|
|
*/
|
|
struct memrar_address_ranges {
|
|
/* private: internal use only */
|
|
struct list_head list;
|
|
struct memrar_address_range range;
|
|
};
|
|
|
|
/**
|
|
* struct memrar_allocator - encapsulation of the memory allocator state
|
|
* @lock: Lock used to synchronize access to the memory
|
|
* allocator state.
|
|
* @base: Base (start) address of the allocator memory
|
|
* space.
|
|
* @capacity: Size of the allocator memory space in bytes.
|
|
* @block_size: The size in bytes of individual blocks within
|
|
* the allocator memory space.
|
|
* @largest_free_area: Largest free area of memory in the allocator
|
|
* in bytes.
|
|
* @allocated_list: List of allocated memory block address
|
|
* ranges.
|
|
* @free_list: List of free address ranges.
|
|
*
|
|
* This structure contains all memory allocator state, including the
|
|
* base address, capacity, free list, lock, etc.
|
|
*/
|
|
struct memrar_allocator {
|
|
/* private: internal use only */
|
|
struct mutex lock;
|
|
unsigned long base;
|
|
size_t capacity;
|
|
size_t block_size;
|
|
size_t largest_free_area;
|
|
struct memrar_address_ranges allocated_list;
|
|
struct memrar_address_ranges free_list;
|
|
};
|
|
|
|
/**
|
|
* memrar_create_allocator() - create a memory allocator
|
|
* @base: Address at which the memory allocator begins.
|
|
* @capacity: Desired size of the memory allocator. This value must
|
|
* be larger than the block_size, ideally more than twice
|
|
* as large since there wouldn't be much point in using a
|
|
* memory allocator otherwise.
|
|
* @block_size: The size of individual blocks within the memory
|
|
* allocator. This value must smaller than the
|
|
* capacity.
|
|
*
|
|
* Create a memory allocator with the given capacity and block size.
|
|
* The capacity will be reduced to be a multiple of the block size, if
|
|
* necessary.
|
|
*
|
|
* Returns an instance of the memory allocator, if creation succeeds,
|
|
* otherwise zero if creation fails. Failure may occur if not enough
|
|
* kernel memory exists to create the memrar_allocator instance
|
|
* itself, or if the capacity and block_size arguments are not
|
|
* compatible or make sense.
|
|
*/
|
|
struct memrar_allocator *memrar_create_allocator(unsigned long base,
|
|
size_t capacity,
|
|
size_t block_size);
|
|
|
|
/**
|
|
* memrar_destroy_allocator() - destroy allocator
|
|
* @allocator: The allocator being destroyed.
|
|
*
|
|
* Reclaim resources held by the memory allocator. The caller must
|
|
* explicitly free all memory reserved by memrar_allocator_alloc()
|
|
* prior to calling this function. Otherwise leaks will occur.
|
|
*/
|
|
void memrar_destroy_allocator(struct memrar_allocator *allocator);
|
|
|
|
/**
|
|
* memrar_allocator_alloc() - reserve an area of memory of given size
|
|
* @allocator: The allocator instance being used to reserve buffer.
|
|
* @size: The size in bytes of the buffer to allocate.
|
|
*
|
|
* This functions reserves an area of memory managed by the given
|
|
* allocator. It returns zero if allocation was not possible.
|
|
* Failure may occur if the allocator no longer has space available.
|
|
*/
|
|
unsigned long memrar_allocator_alloc(struct memrar_allocator *allocator,
|
|
size_t size);
|
|
|
|
/**
|
|
* memrar_allocator_free() - release buffer starting at given address
|
|
* @allocator: The allocator instance being used to release the buffer.
|
|
* @address: The address of the buffer being released.
|
|
*
|
|
* Release an area of memory starting at the given address. Failure
|
|
* could occur if the given address is not in the address space
|
|
* managed by the allocator. Returns zero on success or an errno
|
|
* (negative value) on failure.
|
|
*/
|
|
long memrar_allocator_free(struct memrar_allocator *allocator,
|
|
unsigned long address);
|
|
|
|
#endif /* MEMRAR_ALLOCATOR_H */
|
|
|
|
|
|
/*
|
|
Local Variables:
|
|
c-file-style: "linux"
|
|
End:
|
|
*/
|