mirror of
https://github.com/AuxXxilium/linux_dsm_epyc7002.git
synced 2024-12-05 11:36:41 +07:00
7f4eec3953
The kfree() function tests whether its argument is NULL and then returns immediately. Thus the test around the call is not needed. This issue was detected by using the Coccinelle software. Signed-off-by: Markus Elfring <elfring@users.sourceforge.net> Signed-off-by: Michael Ellerman <mpe@ellerman.id.au>
748 lines
16 KiB
C
748 lines
16 KiB
C
/*
|
|
* A Remote Heap. Remote means that we don't touch the memory that the
|
|
* heap points to. Normal heap implementations use the memory they manage
|
|
* to place their list. We cannot do that because the memory we manage may
|
|
* have special properties, for example it is uncachable or of different
|
|
* endianess.
|
|
*
|
|
* Author: Pantelis Antoniou <panto@intracom.gr>
|
|
*
|
|
* 2004 (c) INTRACOM S.A. Greece. This file is licensed under
|
|
* the terms of the GNU General Public License version 2. This program
|
|
* is licensed "as is" without any warranty of any kind, whether express
|
|
* or implied.
|
|
*/
|
|
#include <linux/types.h>
|
|
#include <linux/errno.h>
|
|
#include <linux/kernel.h>
|
|
#include <linux/export.h>
|
|
#include <linux/mm.h>
|
|
#include <linux/err.h>
|
|
#include <linux/slab.h>
|
|
|
|
#include <asm/rheap.h>
|
|
|
|
/*
|
|
* Fixup a list_head, needed when copying lists. If the pointers fall
|
|
* between s and e, apply the delta. This assumes that
|
|
* sizeof(struct list_head *) == sizeof(unsigned long *).
|
|
*/
|
|
static inline void fixup(unsigned long s, unsigned long e, int d,
|
|
struct list_head *l)
|
|
{
|
|
unsigned long *pp;
|
|
|
|
pp = (unsigned long *)&l->next;
|
|
if (*pp >= s && *pp < e)
|
|
*pp += d;
|
|
|
|
pp = (unsigned long *)&l->prev;
|
|
if (*pp >= s && *pp < e)
|
|
*pp += d;
|
|
}
|
|
|
|
/* Grow the allocated blocks */
|
|
static int grow(rh_info_t * info, int max_blocks)
|
|
{
|
|
rh_block_t *block, *blk;
|
|
int i, new_blocks;
|
|
int delta;
|
|
unsigned long blks, blke;
|
|
|
|
if (max_blocks <= info->max_blocks)
|
|
return -EINVAL;
|
|
|
|
new_blocks = max_blocks - info->max_blocks;
|
|
|
|
block = kmalloc(sizeof(rh_block_t) * max_blocks, GFP_ATOMIC);
|
|
if (block == NULL)
|
|
return -ENOMEM;
|
|
|
|
if (info->max_blocks > 0) {
|
|
|
|
/* copy old block area */
|
|
memcpy(block, info->block,
|
|
sizeof(rh_block_t) * info->max_blocks);
|
|
|
|
delta = (char *)block - (char *)info->block;
|
|
|
|
/* and fixup list pointers */
|
|
blks = (unsigned long)info->block;
|
|
blke = (unsigned long)(info->block + info->max_blocks);
|
|
|
|
for (i = 0, blk = block; i < info->max_blocks; i++, blk++)
|
|
fixup(blks, blke, delta, &blk->list);
|
|
|
|
fixup(blks, blke, delta, &info->empty_list);
|
|
fixup(blks, blke, delta, &info->free_list);
|
|
fixup(blks, blke, delta, &info->taken_list);
|
|
|
|
/* free the old allocated memory */
|
|
if ((info->flags & RHIF_STATIC_BLOCK) == 0)
|
|
kfree(info->block);
|
|
}
|
|
|
|
info->block = block;
|
|
info->empty_slots += new_blocks;
|
|
info->max_blocks = max_blocks;
|
|
info->flags &= ~RHIF_STATIC_BLOCK;
|
|
|
|
/* add all new blocks to the free list */
|
|
blk = block + info->max_blocks - new_blocks;
|
|
for (i = 0; i < new_blocks; i++, blk++)
|
|
list_add(&blk->list, &info->empty_list);
|
|
|
|
return 0;
|
|
}
|
|
|
|
/*
|
|
* Assure at least the required amount of empty slots. If this function
|
|
* causes a grow in the block area then all pointers kept to the block
|
|
* area are invalid!
|
|
*/
|
|
static int assure_empty(rh_info_t * info, int slots)
|
|
{
|
|
int max_blocks;
|
|
|
|
/* This function is not meant to be used to grow uncontrollably */
|
|
if (slots >= 4)
|
|
return -EINVAL;
|
|
|
|
/* Enough space */
|
|
if (info->empty_slots >= slots)
|
|
return 0;
|
|
|
|
/* Next 16 sized block */
|
|
max_blocks = ((info->max_blocks + slots) + 15) & ~15;
|
|
|
|
return grow(info, max_blocks);
|
|
}
|
|
|
|
static rh_block_t *get_slot(rh_info_t * info)
|
|
{
|
|
rh_block_t *blk;
|
|
|
|
/* If no more free slots, and failure to extend. */
|
|
/* XXX: You should have called assure_empty before */
|
|
if (info->empty_slots == 0) {
|
|
printk(KERN_ERR "rh: out of slots; crash is imminent.\n");
|
|
return NULL;
|
|
}
|
|
|
|
/* Get empty slot to use */
|
|
blk = list_entry(info->empty_list.next, rh_block_t, list);
|
|
list_del_init(&blk->list);
|
|
info->empty_slots--;
|
|
|
|
/* Initialize */
|
|
blk->start = 0;
|
|
blk->size = 0;
|
|
blk->owner = NULL;
|
|
|
|
return blk;
|
|
}
|
|
|
|
static inline void release_slot(rh_info_t * info, rh_block_t * blk)
|
|
{
|
|
list_add(&blk->list, &info->empty_list);
|
|
info->empty_slots++;
|
|
}
|
|
|
|
static void attach_free_block(rh_info_t * info, rh_block_t * blkn)
|
|
{
|
|
rh_block_t *blk;
|
|
rh_block_t *before;
|
|
rh_block_t *after;
|
|
rh_block_t *next;
|
|
int size;
|
|
unsigned long s, e, bs, be;
|
|
struct list_head *l;
|
|
|
|
/* We assume that they are aligned properly */
|
|
size = blkn->size;
|
|
s = blkn->start;
|
|
e = s + size;
|
|
|
|
/* Find the blocks immediately before and after the given one
|
|
* (if any) */
|
|
before = NULL;
|
|
after = NULL;
|
|
next = NULL;
|
|
|
|
list_for_each(l, &info->free_list) {
|
|
blk = list_entry(l, rh_block_t, list);
|
|
|
|
bs = blk->start;
|
|
be = bs + blk->size;
|
|
|
|
if (next == NULL && s >= bs)
|
|
next = blk;
|
|
|
|
if (be == s)
|
|
before = blk;
|
|
|
|
if (e == bs)
|
|
after = blk;
|
|
|
|
/* If both are not null, break now */
|
|
if (before != NULL && after != NULL)
|
|
break;
|
|
}
|
|
|
|
/* Now check if they are really adjacent */
|
|
if (before && s != (before->start + before->size))
|
|
before = NULL;
|
|
|
|
if (after && e != after->start)
|
|
after = NULL;
|
|
|
|
/* No coalescing; list insert and return */
|
|
if (before == NULL && after == NULL) {
|
|
|
|
if (next != NULL)
|
|
list_add(&blkn->list, &next->list);
|
|
else
|
|
list_add(&blkn->list, &info->free_list);
|
|
|
|
return;
|
|
}
|
|
|
|
/* We don't need it anymore */
|
|
release_slot(info, blkn);
|
|
|
|
/* Grow the before block */
|
|
if (before != NULL && after == NULL) {
|
|
before->size += size;
|
|
return;
|
|
}
|
|
|
|
/* Grow the after block backwards */
|
|
if (before == NULL && after != NULL) {
|
|
after->start -= size;
|
|
after->size += size;
|
|
return;
|
|
}
|
|
|
|
/* Grow the before block, and release the after block */
|
|
before->size += size + after->size;
|
|
list_del(&after->list);
|
|
release_slot(info, after);
|
|
}
|
|
|
|
static void attach_taken_block(rh_info_t * info, rh_block_t * blkn)
|
|
{
|
|
rh_block_t *blk;
|
|
struct list_head *l;
|
|
|
|
/* Find the block immediately before the given one (if any) */
|
|
list_for_each(l, &info->taken_list) {
|
|
blk = list_entry(l, rh_block_t, list);
|
|
if (blk->start > blkn->start) {
|
|
list_add_tail(&blkn->list, &blk->list);
|
|
return;
|
|
}
|
|
}
|
|
|
|
list_add_tail(&blkn->list, &info->taken_list);
|
|
}
|
|
|
|
/*
|
|
* Create a remote heap dynamically. Note that no memory for the blocks
|
|
* are allocated. It will upon the first allocation
|
|
*/
|
|
rh_info_t *rh_create(unsigned int alignment)
|
|
{
|
|
rh_info_t *info;
|
|
|
|
/* Alignment must be a power of two */
|
|
if ((alignment & (alignment - 1)) != 0)
|
|
return ERR_PTR(-EINVAL);
|
|
|
|
info = kmalloc(sizeof(*info), GFP_ATOMIC);
|
|
if (info == NULL)
|
|
return ERR_PTR(-ENOMEM);
|
|
|
|
info->alignment = alignment;
|
|
|
|
/* Initially everything as empty */
|
|
info->block = NULL;
|
|
info->max_blocks = 0;
|
|
info->empty_slots = 0;
|
|
info->flags = 0;
|
|
|
|
INIT_LIST_HEAD(&info->empty_list);
|
|
INIT_LIST_HEAD(&info->free_list);
|
|
INIT_LIST_HEAD(&info->taken_list);
|
|
|
|
return info;
|
|
}
|
|
EXPORT_SYMBOL_GPL(rh_create);
|
|
|
|
/*
|
|
* Destroy a dynamically created remote heap. Deallocate only if the areas
|
|
* are not static
|
|
*/
|
|
void rh_destroy(rh_info_t * info)
|
|
{
|
|
if ((info->flags & RHIF_STATIC_BLOCK) == 0)
|
|
kfree(info->block);
|
|
|
|
if ((info->flags & RHIF_STATIC_INFO) == 0)
|
|
kfree(info);
|
|
}
|
|
EXPORT_SYMBOL_GPL(rh_destroy);
|
|
|
|
/*
|
|
* Initialize in place a remote heap info block. This is needed to support
|
|
* operation very early in the startup of the kernel, when it is not yet safe
|
|
* to call kmalloc.
|
|
*/
|
|
void rh_init(rh_info_t * info, unsigned int alignment, int max_blocks,
|
|
rh_block_t * block)
|
|
{
|
|
int i;
|
|
rh_block_t *blk;
|
|
|
|
/* Alignment must be a power of two */
|
|
if ((alignment & (alignment - 1)) != 0)
|
|
return;
|
|
|
|
info->alignment = alignment;
|
|
|
|
/* Initially everything as empty */
|
|
info->block = block;
|
|
info->max_blocks = max_blocks;
|
|
info->empty_slots = max_blocks;
|
|
info->flags = RHIF_STATIC_INFO | RHIF_STATIC_BLOCK;
|
|
|
|
INIT_LIST_HEAD(&info->empty_list);
|
|
INIT_LIST_HEAD(&info->free_list);
|
|
INIT_LIST_HEAD(&info->taken_list);
|
|
|
|
/* Add all new blocks to the free list */
|
|
for (i = 0, blk = block; i < max_blocks; i++, blk++)
|
|
list_add(&blk->list, &info->empty_list);
|
|
}
|
|
EXPORT_SYMBOL_GPL(rh_init);
|
|
|
|
/* Attach a free memory region, coalesces regions if adjuscent */
|
|
int rh_attach_region(rh_info_t * info, unsigned long start, int size)
|
|
{
|
|
rh_block_t *blk;
|
|
unsigned long s, e, m;
|
|
int r;
|
|
|
|
/* The region must be aligned */
|
|
s = start;
|
|
e = s + size;
|
|
m = info->alignment - 1;
|
|
|
|
/* Round start up */
|
|
s = (s + m) & ~m;
|
|
|
|
/* Round end down */
|
|
e = e & ~m;
|
|
|
|
if (IS_ERR_VALUE(e) || (e < s))
|
|
return -ERANGE;
|
|
|
|
/* Take final values */
|
|
start = s;
|
|
size = e - s;
|
|
|
|
/* Grow the blocks, if needed */
|
|
r = assure_empty(info, 1);
|
|
if (r < 0)
|
|
return r;
|
|
|
|
blk = get_slot(info);
|
|
blk->start = start;
|
|
blk->size = size;
|
|
blk->owner = NULL;
|
|
|
|
attach_free_block(info, blk);
|
|
|
|
return 0;
|
|
}
|
|
EXPORT_SYMBOL_GPL(rh_attach_region);
|
|
|
|
/* Detatch given address range, splits free block if needed. */
|
|
unsigned long rh_detach_region(rh_info_t * info, unsigned long start, int size)
|
|
{
|
|
struct list_head *l;
|
|
rh_block_t *blk, *newblk;
|
|
unsigned long s, e, m, bs, be;
|
|
|
|
/* Validate size */
|
|
if (size <= 0)
|
|
return (unsigned long) -EINVAL;
|
|
|
|
/* The region must be aligned */
|
|
s = start;
|
|
e = s + size;
|
|
m = info->alignment - 1;
|
|
|
|
/* Round start up */
|
|
s = (s + m) & ~m;
|
|
|
|
/* Round end down */
|
|
e = e & ~m;
|
|
|
|
if (assure_empty(info, 1) < 0)
|
|
return (unsigned long) -ENOMEM;
|
|
|
|
blk = NULL;
|
|
list_for_each(l, &info->free_list) {
|
|
blk = list_entry(l, rh_block_t, list);
|
|
/* The range must lie entirely inside one free block */
|
|
bs = blk->start;
|
|
be = blk->start + blk->size;
|
|
if (s >= bs && e <= be)
|
|
break;
|
|
blk = NULL;
|
|
}
|
|
|
|
if (blk == NULL)
|
|
return (unsigned long) -ENOMEM;
|
|
|
|
/* Perfect fit */
|
|
if (bs == s && be == e) {
|
|
/* Delete from free list, release slot */
|
|
list_del(&blk->list);
|
|
release_slot(info, blk);
|
|
return s;
|
|
}
|
|
|
|
/* blk still in free list, with updated start and/or size */
|
|
if (bs == s || be == e) {
|
|
if (bs == s)
|
|
blk->start += size;
|
|
blk->size -= size;
|
|
|
|
} else {
|
|
/* The front free fragment */
|
|
blk->size = s - bs;
|
|
|
|
/* the back free fragment */
|
|
newblk = get_slot(info);
|
|
newblk->start = e;
|
|
newblk->size = be - e;
|
|
|
|
list_add(&newblk->list, &blk->list);
|
|
}
|
|
|
|
return s;
|
|
}
|
|
EXPORT_SYMBOL_GPL(rh_detach_region);
|
|
|
|
/* Allocate a block of memory at the specified alignment. The value returned
|
|
* is an offset into the buffer initialized by rh_init(), or a negative number
|
|
* if there is an error.
|
|
*/
|
|
unsigned long rh_alloc_align(rh_info_t * info, int size, int alignment, const char *owner)
|
|
{
|
|
struct list_head *l;
|
|
rh_block_t *blk;
|
|
rh_block_t *newblk;
|
|
unsigned long start, sp_size;
|
|
|
|
/* Validate size, and alignment must be power of two */
|
|
if (size <= 0 || (alignment & (alignment - 1)) != 0)
|
|
return (unsigned long) -EINVAL;
|
|
|
|
/* Align to configured alignment */
|
|
size = (size + (info->alignment - 1)) & ~(info->alignment - 1);
|
|
|
|
if (assure_empty(info, 2) < 0)
|
|
return (unsigned long) -ENOMEM;
|
|
|
|
blk = NULL;
|
|
list_for_each(l, &info->free_list) {
|
|
blk = list_entry(l, rh_block_t, list);
|
|
if (size <= blk->size) {
|
|
start = (blk->start + alignment - 1) & ~(alignment - 1);
|
|
if (start + size <= blk->start + blk->size)
|
|
break;
|
|
}
|
|
blk = NULL;
|
|
}
|
|
|
|
if (blk == NULL)
|
|
return (unsigned long) -ENOMEM;
|
|
|
|
/* Just fits */
|
|
if (blk->size == size) {
|
|
/* Move from free list to taken list */
|
|
list_del(&blk->list);
|
|
newblk = blk;
|
|
} else {
|
|
/* Fragment caused, split if needed */
|
|
/* Create block for fragment in the beginning */
|
|
sp_size = start - blk->start;
|
|
if (sp_size) {
|
|
rh_block_t *spblk;
|
|
|
|
spblk = get_slot(info);
|
|
spblk->start = blk->start;
|
|
spblk->size = sp_size;
|
|
/* add before the blk */
|
|
list_add(&spblk->list, blk->list.prev);
|
|
}
|
|
newblk = get_slot(info);
|
|
newblk->start = start;
|
|
newblk->size = size;
|
|
|
|
/* blk still in free list, with updated start and size
|
|
* for fragment in the end */
|
|
blk->start = start + size;
|
|
blk->size -= sp_size + size;
|
|
/* No fragment in the end, remove blk */
|
|
if (blk->size == 0) {
|
|
list_del(&blk->list);
|
|
release_slot(info, blk);
|
|
}
|
|
}
|
|
|
|
newblk->owner = owner;
|
|
attach_taken_block(info, newblk);
|
|
|
|
return start;
|
|
}
|
|
EXPORT_SYMBOL_GPL(rh_alloc_align);
|
|
|
|
/* Allocate a block of memory at the default alignment. The value returned is
|
|
* an offset into the buffer initialized by rh_init(), or a negative number if
|
|
* there is an error.
|
|
*/
|
|
unsigned long rh_alloc(rh_info_t * info, int size, const char *owner)
|
|
{
|
|
return rh_alloc_align(info, size, info->alignment, owner);
|
|
}
|
|
EXPORT_SYMBOL_GPL(rh_alloc);
|
|
|
|
/* Allocate a block of memory at the given offset, rounded up to the default
|
|
* alignment. The value returned is an offset into the buffer initialized by
|
|
* rh_init(), or a negative number if there is an error.
|
|
*/
|
|
unsigned long rh_alloc_fixed(rh_info_t * info, unsigned long start, int size, const char *owner)
|
|
{
|
|
struct list_head *l;
|
|
rh_block_t *blk, *newblk1, *newblk2;
|
|
unsigned long s, e, m, bs = 0, be = 0;
|
|
|
|
/* Validate size */
|
|
if (size <= 0)
|
|
return (unsigned long) -EINVAL;
|
|
|
|
/* The region must be aligned */
|
|
s = start;
|
|
e = s + size;
|
|
m = info->alignment - 1;
|
|
|
|
/* Round start up */
|
|
s = (s + m) & ~m;
|
|
|
|
/* Round end down */
|
|
e = e & ~m;
|
|
|
|
if (assure_empty(info, 2) < 0)
|
|
return (unsigned long) -ENOMEM;
|
|
|
|
blk = NULL;
|
|
list_for_each(l, &info->free_list) {
|
|
blk = list_entry(l, rh_block_t, list);
|
|
/* The range must lie entirely inside one free block */
|
|
bs = blk->start;
|
|
be = blk->start + blk->size;
|
|
if (s >= bs && e <= be)
|
|
break;
|
|
blk = NULL;
|
|
}
|
|
|
|
if (blk == NULL)
|
|
return (unsigned long) -ENOMEM;
|
|
|
|
/* Perfect fit */
|
|
if (bs == s && be == e) {
|
|
/* Move from free list to taken list */
|
|
list_del(&blk->list);
|
|
blk->owner = owner;
|
|
|
|
start = blk->start;
|
|
attach_taken_block(info, blk);
|
|
|
|
return start;
|
|
|
|
}
|
|
|
|
/* blk still in free list, with updated start and/or size */
|
|
if (bs == s || be == e) {
|
|
if (bs == s)
|
|
blk->start += size;
|
|
blk->size -= size;
|
|
|
|
} else {
|
|
/* The front free fragment */
|
|
blk->size = s - bs;
|
|
|
|
/* The back free fragment */
|
|
newblk2 = get_slot(info);
|
|
newblk2->start = e;
|
|
newblk2->size = be - e;
|
|
|
|
list_add(&newblk2->list, &blk->list);
|
|
}
|
|
|
|
newblk1 = get_slot(info);
|
|
newblk1->start = s;
|
|
newblk1->size = e - s;
|
|
newblk1->owner = owner;
|
|
|
|
start = newblk1->start;
|
|
attach_taken_block(info, newblk1);
|
|
|
|
return start;
|
|
}
|
|
EXPORT_SYMBOL_GPL(rh_alloc_fixed);
|
|
|
|
/* Deallocate the memory previously allocated by one of the rh_alloc functions.
|
|
* The return value is the size of the deallocated block, or a negative number
|
|
* if there is an error.
|
|
*/
|
|
int rh_free(rh_info_t * info, unsigned long start)
|
|
{
|
|
rh_block_t *blk, *blk2;
|
|
struct list_head *l;
|
|
int size;
|
|
|
|
/* Linear search for block */
|
|
blk = NULL;
|
|
list_for_each(l, &info->taken_list) {
|
|
blk2 = list_entry(l, rh_block_t, list);
|
|
if (start < blk2->start)
|
|
break;
|
|
blk = blk2;
|
|
}
|
|
|
|
if (blk == NULL || start > (blk->start + blk->size))
|
|
return -EINVAL;
|
|
|
|
/* Remove from taken list */
|
|
list_del(&blk->list);
|
|
|
|
/* Get size of freed block */
|
|
size = blk->size;
|
|
attach_free_block(info, blk);
|
|
|
|
return size;
|
|
}
|
|
EXPORT_SYMBOL_GPL(rh_free);
|
|
|
|
int rh_get_stats(rh_info_t * info, int what, int max_stats, rh_stats_t * stats)
|
|
{
|
|
rh_block_t *blk;
|
|
struct list_head *l;
|
|
struct list_head *h;
|
|
int nr;
|
|
|
|
switch (what) {
|
|
|
|
case RHGS_FREE:
|
|
h = &info->free_list;
|
|
break;
|
|
|
|
case RHGS_TAKEN:
|
|
h = &info->taken_list;
|
|
break;
|
|
|
|
default:
|
|
return -EINVAL;
|
|
}
|
|
|
|
/* Linear search for block */
|
|
nr = 0;
|
|
list_for_each(l, h) {
|
|
blk = list_entry(l, rh_block_t, list);
|
|
if (stats != NULL && nr < max_stats) {
|
|
stats->start = blk->start;
|
|
stats->size = blk->size;
|
|
stats->owner = blk->owner;
|
|
stats++;
|
|
}
|
|
nr++;
|
|
}
|
|
|
|
return nr;
|
|
}
|
|
EXPORT_SYMBOL_GPL(rh_get_stats);
|
|
|
|
int rh_set_owner(rh_info_t * info, unsigned long start, const char *owner)
|
|
{
|
|
rh_block_t *blk, *blk2;
|
|
struct list_head *l;
|
|
int size;
|
|
|
|
/* Linear search for block */
|
|
blk = NULL;
|
|
list_for_each(l, &info->taken_list) {
|
|
blk2 = list_entry(l, rh_block_t, list);
|
|
if (start < blk2->start)
|
|
break;
|
|
blk = blk2;
|
|
}
|
|
|
|
if (blk == NULL || start > (blk->start + blk->size))
|
|
return -EINVAL;
|
|
|
|
blk->owner = owner;
|
|
size = blk->size;
|
|
|
|
return size;
|
|
}
|
|
EXPORT_SYMBOL_GPL(rh_set_owner);
|
|
|
|
void rh_dump(rh_info_t * info)
|
|
{
|
|
static rh_stats_t st[32]; /* XXX maximum 32 blocks */
|
|
int maxnr;
|
|
int i, nr;
|
|
|
|
maxnr = ARRAY_SIZE(st);
|
|
|
|
printk(KERN_INFO
|
|
"info @0x%p (%d slots empty / %d max)\n",
|
|
info, info->empty_slots, info->max_blocks);
|
|
|
|
printk(KERN_INFO " Free:\n");
|
|
nr = rh_get_stats(info, RHGS_FREE, maxnr, st);
|
|
if (nr > maxnr)
|
|
nr = maxnr;
|
|
for (i = 0; i < nr; i++)
|
|
printk(KERN_INFO
|
|
" 0x%lx-0x%lx (%u)\n",
|
|
st[i].start, st[i].start + st[i].size,
|
|
st[i].size);
|
|
printk(KERN_INFO "\n");
|
|
|
|
printk(KERN_INFO " Taken:\n");
|
|
nr = rh_get_stats(info, RHGS_TAKEN, maxnr, st);
|
|
if (nr > maxnr)
|
|
nr = maxnr;
|
|
for (i = 0; i < nr; i++)
|
|
printk(KERN_INFO
|
|
" 0x%lx-0x%lx (%u) %s\n",
|
|
st[i].start, st[i].start + st[i].size,
|
|
st[i].size, st[i].owner != NULL ? st[i].owner : "");
|
|
printk(KERN_INFO "\n");
|
|
}
|
|
EXPORT_SYMBOL_GPL(rh_dump);
|
|
|
|
void rh_dump_blk(rh_info_t * info, rh_block_t * blk)
|
|
{
|
|
printk(KERN_INFO
|
|
"blk @0x%p: 0x%lx-0x%lx (%u)\n",
|
|
blk, blk->start, blk->start + blk->size, blk->size);
|
|
}
|
|
EXPORT_SYMBOL_GPL(rh_dump_blk);
|
|
|