/*
 * Copyright (C) 2001,2002,2003 Philippe Gerum <rpm@xenomai.org>.
 *
 * Xenomai is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published
 * by the Free Software Foundation; either version 2 of the License,
 * or (at your option) any later version.
 *
 * Xenomai 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 Xenomai; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
 * 02111-1307, USA.
 */
#include <linux/stdarg.h>
#include <linux/vmalloc.h>
#include <linux/slab.h>
#include <linux/kernel.h>
#include <linux/log2.h>
#include <linux/bitops.h>
#include <linux/mm.h>
#include <asm/pgtable.h>
#include <cobalt/kernel/assert.h>
#include <cobalt/kernel/heap.h>
#include <cobalt/kernel/vfile.h>
#include <cobalt/kernel/ancillaries.h>
#include <asm/xenomai/wrappers.h>

/**
 * @ingroup cobalt_core
 * @defgroup cobalt_core_heap Dynamic memory allocation services
 *
 * This code implements a variant of the allocator described in
 * "Design of a General Purpose Memory Allocator for the 4.3BSD Unix
 * Kernel" by Marshall K. McKusick and Michael J. Karels (USENIX
 * 1988), see http://docs.FreeBSD.org/44doc/papers/kernmalloc.pdf.
 * The free page list is maintained in rbtrees for fast lookups of
 * multi-page memory ranges, and pages holding bucketed memory have a
 * fast allocation bitmap to manage their blocks internally.
 *@{
 */
struct xnheap cobalt_heap;		/* System heap */
EXPORT_SYMBOL_GPL(cobalt_heap);

static LIST_HEAD(heapq);	/* Heap list for v-file dump */

static int nrheaps;

#ifdef CONFIG_XENO_OPT_VFILE

static struct xnvfile_rev_tag vfile_tag;

static struct xnvfile_snapshot_ops vfile_ops;

struct vfile_priv {
	struct xnheap *curr;
};

struct vfile_data {
	size_t all_mem;
	size_t free_mem;
	char name[XNOBJECT_NAME_LEN];
};

static struct xnvfile_snapshot vfile = {
	.privsz = sizeof(struct vfile_priv),
	.datasz = sizeof(struct vfile_data),
	.tag = &vfile_tag,
	.ops = &vfile_ops,
};

static int vfile_rewind(struct xnvfile_snapshot_iterator *it)
{
	struct vfile_priv *priv = xnvfile_iterator_priv(it);

	if (list_empty(&heapq)) {
		priv->curr = NULL;
		return 0;
	}

	priv->curr = list_first_entry(&heapq, struct xnheap, next);

	return nrheaps;
}

static int vfile_next(struct xnvfile_snapshot_iterator *it, void *data)
{
	struct vfile_priv *priv = xnvfile_iterator_priv(it);
	struct vfile_data *p = data;
	struct xnheap *heap;

	if (priv->curr == NULL)
		return 0;	/* We are done. */

	heap = priv->curr;
	if (list_is_last(&heap->next, &heapq))
		priv->curr = NULL;
	else
		priv->curr = list_entry(heap->next.next,
					struct xnheap, next);

	p->all_mem = xnheap_get_size(heap);
	p->free_mem = xnheap_get_free(heap);
	knamecpy(p->name, heap->name);

	return 1;
}

static int vfile_show(struct xnvfile_snapshot_iterator *it, void *data)
{
	struct vfile_data *p = data;

	if (p == NULL)
		xnvfile_printf(it, "%9s %9s  %s\n",
			       "TOTAL", "FREE", "NAME");
	else
		xnvfile_printf(it, "%9zu %9zu  %s\n",
			       p->all_mem,
			       p->free_mem,
			       p->name);
	return 0;
}

static struct xnvfile_snapshot_ops vfile_ops = {
	.rewind = vfile_rewind,
	.next = vfile_next,
	.show = vfile_show,
};

void xnheap_init_proc(void)
{
	xnvfile_init_snapshot("heap", &vfile, &cobalt_vfroot);
}

void xnheap_cleanup_proc(void)
{
	xnvfile_destroy_snapshot(&vfile);
}

#endif /* CONFIG_XENO_OPT_VFILE */

enum xnheap_pgtype {
	page_free =0,
	page_cont =1,
	page_list =2
};

static inline u32 __always_inline
gen_block_mask(int log2size)
{
	return -1U >> (32 - (XNHEAP_PAGE_SIZE >> log2size));
}

static inline  __always_inline
int addr_to_pagenr(struct xnheap *heap, void *p)
{
	return ((void *)p - heap->membase) >> XNHEAP_PAGE_SHIFT;
}

static inline  __always_inline
void *pagenr_to_addr(struct xnheap *heap, int pg)
{
	return heap->membase + (pg << XNHEAP_PAGE_SHIFT);
}

#ifdef CONFIG_XENO_OPT_DEBUG_MEMORY
/*
 * Setting page_cont/page_free in the page map is only required for
 * enabling full checking of the block address in free requests, which
 * may be extremely time-consuming when deallocating huge blocks
 * spanning thousands of pages. We only do such marking when running
 * in memory debug mode.
 */
static inline bool
page_is_valid(struct xnheap *heap, int pg)
{
	switch (heap->pagemap[pg].type) {
	case page_free:
	case page_cont:
		return false;
	case page_list:
	default:
		return true;
	}
}

static void mark_pages(struct xnheap *heap,
		       int pg, int nrpages,
		       enum xnheap_pgtype type)
{
	while (nrpages-- > 0)
		heap->pagemap[pg].type = type;
}

#else

static inline bool
page_is_valid(struct xnheap *heap, int pg)
{
	return true;
}

static void mark_pages(struct xnheap *heap,
		       int pg, int nrpages,
		       enum xnheap_pgtype type)
{ }

#endif

static struct xnheap_range *
search_size_ge(struct rb_root *t, size_t size)
{
	struct rb_node *rb, *deepest = NULL;
	struct xnheap_range *r;
	
	/*
	 * We first try to find an exact match. If that fails, we walk
	 * the tree in logical order by increasing size value from the
	 * deepest node traversed until we find the first successor to
	 * that node, or nothing beyond it, whichever comes first.
	 */
	rb = t->rb_node;
	while (rb) {
		deepest = rb;
		r = rb_entry(rb, struct xnheap_range, size_node);
		if (size < r->size) {
			rb = rb->rb_left;
			continue;
		}
		if (size > r->size) {
			rb = rb->rb_right;
			continue;
		}
		return r;
	}

	rb = deepest;
	while (rb) {
		r = rb_entry(rb, struct xnheap_range, size_node);
		if (size <= r->size)
			return r;
		rb = rb_next(rb);
	}

	return NULL;
}

static struct xnheap_range *
search_left_mergeable(struct xnheap *heap, struct xnheap_range *r)
{
  	struct rb_node *node = heap->addr_tree.rb_node;
	struct xnheap_range *p;

  	while (node) {
		p = rb_entry(node, struct xnheap_range, addr_node);
		if ((void *)p + p->size == (void *)r)
			return p;
		if (&r->addr_node < node)
  			node = node->rb_left;
		else
  			node = node->rb_right;
	}

	return NULL;
}

static struct xnheap_range *
search_right_mergeable(struct xnheap *heap, struct xnheap_range *r)
{
  	struct rb_node *node = heap->addr_tree.rb_node;
	struct xnheap_range *p;

  	while (node) {
		p = rb_entry(node, struct xnheap_range, addr_node);
		if ((void *)r + r->size == (void *)p)
			return p;
		if (&r->addr_node < node)
  			node = node->rb_left;
		else
  			node = node->rb_right;
	}

	return NULL;
}

static void insert_range_bysize(struct xnheap *heap, struct xnheap_range *r)
{
  	struct rb_node **new = &heap->size_tree.rb_node, *parent = NULL;
	struct xnheap_range *p;

  	while (*new) {
  		p = container_of(*new, struct xnheap_range, size_node);
		parent = *new;
  		if (r->size <= p->size)
  			new = &((*new)->rb_left);
  		else
  			new = &((*new)->rb_right);
  	}

  	rb_link_node(&r->size_node, parent, new);
  	rb_insert_color(&r->size_node, &heap->size_tree);
}

static void insert_range_byaddr(struct xnheap *heap, struct xnheap_range *r)
{
  	struct rb_node **new = &heap->addr_tree.rb_node, *parent = NULL;
	struct xnheap_range *p;

  	while (*new) {
  		p = container_of(*new, struct xnheap_range, addr_node);
		parent = *new;
  		if (r < p)
  			new = &((*new)->rb_left);
  		else
  			new = &((*new)->rb_right);
  	}

  	rb_link_node(&r->addr_node, parent, new);
  	rb_insert_color(&r->addr_node, &heap->addr_tree);
}

static int reserve_page_range(struct xnheap *heap, size_t size)
{
	struct xnheap_range *new, *splitr;

	/* Find a suitable range of pages covering 'size'. */
	new = search_size_ge(&heap->size_tree, size);
	if (new == NULL)
		return -1;

	rb_erase(&new->size_node, &heap->size_tree);
	if (new->size == size) {
		rb_erase(&new->addr_node, &heap->addr_tree);
		return addr_to_pagenr(heap, new);
	}

	/*
	 * The free range fetched is larger than what we need: split
	 * it in two, the upper part is returned to the caller, the
	 * lower part is sent back to the free list, which makes
	 * reindexing by address pointless.
	 */
	splitr = new;
	splitr->size -= size;
	new = (struct xnheap_range *)((void *)new + splitr->size);
	insert_range_bysize(heap, splitr);

	return addr_to_pagenr(heap, new);
}

static void release_page_range(struct xnheap *heap,
			       void *page, size_t size)
{
	struct xnheap_range *freed = page, *left, *right;
	bool addr_linked = false;

	freed->size = size;

	left = search_left_mergeable(heap, freed);
	if (left) {
		rb_erase(&left->size_node, &heap->size_tree);
		left->size += freed->size;
		freed = left;
		addr_linked = true;
	}

	right = search_right_mergeable(heap, freed);
	if (right) {
		rb_erase(&right->size_node, &heap->size_tree);
		freed->size += right->size;
		if (addr_linked)
			rb_erase(&right->addr_node, &heap->addr_tree);
		else
			rb_replace_node(&right->addr_node, &freed->addr_node,
					&heap->addr_tree);
	} else if (!addr_linked)
		insert_range_byaddr(heap, freed);

	insert_range_bysize(heap, freed);
	mark_pages(heap, addr_to_pagenr(heap, page),
		   size >> XNHEAP_PAGE_SHIFT, page_free);
}

static void add_page_front(struct xnheap *heap,
			   int pg, int log2size)
{
	struct xnheap_pgentry *new, *head, *next;
	int ilog;

	/* Insert page at front of the per-bucket page list. */
	
	ilog = log2size - XNHEAP_MIN_LOG2;
	new = &heap->pagemap[pg];
	if (heap->buckets[ilog] == -1U) {
		heap->buckets[ilog] = pg;
		new->prev = new->next = pg;
	} else {
		head = &heap->pagemap[heap->buckets[ilog]];
		new->prev = heap->buckets[ilog];
		new->next = head->next;
		next = &heap->pagemap[new->next];
		next->prev = pg;
		head->next = pg;
		heap->buckets[ilog] = pg;
	}
}

static void remove_page(struct xnheap *heap,
			int pg, int log2size)
{
	struct xnheap_pgentry *old, *prev, *next;
	int ilog = log2size - XNHEAP_MIN_LOG2;

	/* Remove page from the per-bucket page list. */

	old = &heap->pagemap[pg];
	if (pg == old->next)
		heap->buckets[ilog] = -1U;
	else {
		if (pg == heap->buckets[ilog])
			heap->buckets[ilog] = old->next;
		prev = &heap->pagemap[old->prev];
		prev->next = old->next;
		next = &heap->pagemap[old->next];
		next->prev = old->prev;
	}
}

static void move_page_front(struct xnheap *heap,
			    int pg, int log2size)
{
	int ilog = log2size - XNHEAP_MIN_LOG2;

	/* Move page at front of the per-bucket page list. */
	
	if (heap->buckets[ilog] == pg)
		return;	 /* Already at front, no move. */
		
	remove_page(heap, pg, log2size);
	add_page_front(heap, pg, log2size);
}

static void move_page_back(struct xnheap *heap,
			   int pg, int log2size)
{
	struct xnheap_pgentry *old, *last, *head, *next;
	int ilog;

	/* Move page at end of the per-bucket page list. */
	
	old = &heap->pagemap[pg];
	if (pg == old->next) /* Singleton, no move. */
		return;
		
	remove_page(heap, pg, log2size);

	ilog = log2size - XNHEAP_MIN_LOG2;
	head = &heap->pagemap[heap->buckets[ilog]];
	last = &heap->pagemap[head->prev];
	old->prev = head->prev;
	old->next = last->next;
	next = &heap->pagemap[old->next];
	next->prev = pg;
	last->next = pg;
}

static void *add_free_range(struct xnheap *heap,
			    size_t bsize, int log2size)
{
	int pg;

	pg = reserve_page_range(heap, ALIGN(bsize, XNHEAP_PAGE_SIZE));
	if (pg < 0)
		return NULL;
	
	/*
	 * Update the page entry.  If @log2size is non-zero
	 * (i.e. bsize < XNHEAP_PAGE_SIZE), bsize is (1 << log2Size)
	 * between 2^XNHEAP_MIN_LOG2 and 2^(XNHEAP_PAGE_SHIFT - 1).
	 * Save the log2 power into entry.type, then update the
	 * per-page allocation bitmap to reserve the first block.
	 *
	 * Otherwise, we have a larger block which may span multiple
	 * pages: set entry.type to page_list, indicating the start of
	 * the page range, and entry.bsize to the overall block size.
	 */
	if (log2size) {
		heap->pagemap[pg].type = log2size;
		/*
		 * Mark the first object slot (#0) as busy, along with
		 * the leftmost bits we won't use for this log2 size.
		 */
		heap->pagemap[pg].map = ~gen_block_mask(log2size) | 1;
		/*
		 * Insert the new page at front of the per-bucket page
		 * list, enforcing the assumption that pages with free
		 * space live close to the head of this list.
		 */
		add_page_front(heap, pg, log2size);
	} else {
		heap->pagemap[pg].type = page_list;
		heap->pagemap[pg].bsize = (u32)bsize;
		mark_pages(heap, pg + 1,
			   (bsize >> XNHEAP_PAGE_SHIFT) - 1, page_cont);
	}

	heap->used_size += bsize;

	return pagenr_to_addr(heap, pg);
}

/**
 * @fn void *xnheap_alloc(struct xnheap *heap, size_t size)
 * @brief Allocate a memory block from a memory heap.
 *
 * Allocates a contiguous region of memory from an active memory heap.
 * Such allocation is guaranteed to be time-bounded.
 *
 * @param heap The descriptor address of the heap to get memory from.
 *
 * @param size The size in bytes of the requested block.
 *
 * @return The address of the allocated region upon success, or NULL
 * if no memory is available from the specified heap.
 *
 * @coretags{unrestricted}
 */
void *xnheap_alloc(struct xnheap *heap, size_t size)
{
	int log2size, ilog, pg, b = -1;
	size_t bsize;
	void *block;
	spl_t s;

	if (size == 0)
		return NULL;

	if (size < XNHEAP_MIN_ALIGN) {
		bsize = size = XNHEAP_MIN_ALIGN;
		log2size = XNHEAP_MIN_LOG2;
	} else {
		log2size = ilog2(size);
		if (log2size < XNHEAP_PAGE_SHIFT) {
			if (size & (size - 1))
				log2size++;
			bsize = 1 << log2size;
		} else
			bsize = ALIGN(size, XNHEAP_PAGE_SIZE);
	}
	
	/*
	 * Allocate entire pages directly from the pool whenever the
	 * block is larger or equal to XNHEAP_PAGE_SIZE.  Otherwise,
	 * use bucketed memory.
	 *
	 * NOTE: Fully busy pages from bucketed memory are moved back
	 * at the end of the per-bucket page list, so that we may
	 * always assume that either the heading page has some room
	 * available, or no room is available from any page linked to
	 * this list, in which case we should immediately add a fresh
	 * page.
	 */
	xnlock_get_irqsave(&heap->lock, s);

	if (bsize >= XNHEAP_PAGE_SIZE)
		/* Add a range of contiguous free pages. */
		block = add_free_range(heap, bsize, 0);
	else {
		ilog = log2size - XNHEAP_MIN_LOG2;
		XENO_WARN_ON(MEMORY, ilog < 0 || ilog >= XNHEAP_MAX_BUCKETS);
		pg = heap->buckets[ilog];
		/*
		 * Find a block in the heading page if any. If there
		 * is none, there won't be any down the list: add a
		 * new page right away.
		 */
		if (pg < 0 || heap->pagemap[pg].map == -1U)
			block = add_free_range(heap, bsize, log2size);
		else {
			b = ffs(~heap->pagemap[pg].map) - 1;
			/*
			 * Got one block from the heading per-bucket
			 * page, tag it as busy in the per-page
			 * allocation map.
			 */
			heap->pagemap[pg].map |= (1U << b);
			heap->used_size += bsize;
			block = heap->membase +
				(pg << XNHEAP_PAGE_SHIFT) +
				(b << log2size);
			if (heap->pagemap[pg].map == -1U)
				move_page_back(heap, pg, log2size);
		}
	}

	xnlock_put_irqrestore(&heap->lock, s);

	return block;
}
EXPORT_SYMBOL_GPL(xnheap_alloc);

/**
 * @fn void xnheap_free(struct xnheap *heap, void *block)
 * @brief Release a block to a memory heap.
 *
 * Releases a memory block to a heap.
 *
 * @param heap The heap descriptor.
 *
 * @param block The block to be returned to the heap.
 *
 * @coretags{unrestricted}
 */
void xnheap_free(struct xnheap *heap, void *block)
{
	unsigned long pgoff, boff;
	int log2size, pg, n;
	size_t bsize;
	u32 oldmap;
	spl_t s;

	xnlock_get_irqsave(&heap->lock, s);

	/* Compute the heading page number in the page map. */
	pgoff = block - heap->membase;
	pg = pgoff >> XNHEAP_PAGE_SHIFT;

	if (!page_is_valid(heap, pg))
		goto bad;
	
	switch (heap->pagemap[pg].type) {
	case page_list:
		bsize = heap->pagemap[pg].bsize;
		XENO_WARN_ON(MEMORY, (bsize & (XNHEAP_PAGE_SIZE - 1)) != 0);
		release_page_range(heap, pagenr_to_addr(heap, pg), bsize);
		break;

	default:
		log2size = heap->pagemap[pg].type;
		bsize = (1 << log2size);
		XENO_WARN_ON(MEMORY, bsize >= XNHEAP_PAGE_SIZE);
		boff = pgoff & ~XNHEAP_PAGE_MASK;
		if ((boff & (bsize - 1)) != 0) /* Not at block start? */
			goto bad;

		n = boff >> log2size; /* Block position in page. */
		oldmap = heap->pagemap[pg].map;
		heap->pagemap[pg].map &= ~(1U << n);

		/*
		 * If the page the block was sitting on is fully idle,
		 * return it to the pool. Otherwise, check whether
		 * that page is transitioning from fully busy to
		 * partially busy state, in which case it should move
		 * toward the front of the per-bucket page list.
		 */
		if (heap->pagemap[pg].map == ~gen_block_mask(log2size)) {
			remove_page(heap, pg, log2size);
			release_page_range(heap, pagenr_to_addr(heap, pg),
					   XNHEAP_PAGE_SIZE);
		} else if (oldmap == -1U)
			move_page_front(heap, pg, log2size);
	}

	heap->used_size -= bsize;

	xnlock_put_irqrestore(&heap->lock, s);

	return;
bad:
	xnlock_put_irqrestore(&heap->lock, s);

	XENO_WARN(MEMORY, 1, "invalid block %p in heap %s",
		  block, heap->name);
}
EXPORT_SYMBOL_GPL(xnheap_free);

ssize_t xnheap_check_block(struct xnheap *heap, void *block)
{
	unsigned long pg, pgoff, boff;
	ssize_t ret = -EINVAL;
	size_t bsize;
	spl_t s;

	xnlock_get_irqsave(&heap->lock, s);

	/* Calculate the page number from the block address. */
	pgoff = block - heap->membase;
	pg = pgoff >> XNHEAP_PAGE_SHIFT;
	if (page_is_valid(heap, pg)) {
		if (heap->pagemap[pg].type == page_list)
			bsize = heap->pagemap[pg].bsize;
		else {
			bsize = (1 << heap->pagemap[pg].type);
			boff = pgoff & ~XNHEAP_PAGE_MASK;
			if ((boff & (bsize - 1)) != 0) /* Not at block start? */
				goto out;
		}
		ret = (ssize_t)bsize;
	}
out:
	xnlock_put_irqrestore(&heap->lock, s);

	return ret;
}
EXPORT_SYMBOL_GPL(xnheap_check_block);

/**
 * @fn xnheap_init(struct xnheap *heap, void *membase, u32 size)
 * @brief Initialize a memory heap.
 *
 * Initializes a memory heap suitable for time-bounded allocation
 * requests of dynamic memory.
 *
 * @param heap The address of a heap descriptor to initialize.
 *
 * @param membase The address of the storage area.
 *
 * @param size The size in bytes of the storage area.  @a size must be
 * a multiple of XNHEAP_PAGE_SIZE and smaller than (4Gb - PAGE_SIZE)
 * in the current implementation.
 *
 * @return 0 is returned upon success, or:
 *
 * - -EINVAL is returned if @a size is either greater than
 *   XNHEAP_MAX_HEAPSZ, or not aligned on PAGE_SIZE.
 *
 * - -ENOMEM is returned upon failure of allocating the meta-data area
 * used internally to maintain the heap.
 *
 * @coretags{secondary-only}
 */
int xnheap_init(struct xnheap *heap, void *membase, size_t size)
{
	int n, nrpages;
	spl_t s;

	secondary_mode_only();

 	if (size > XNHEAP_MAX_HEAPSZ || !PAGE_ALIGNED(size))
		return -EINVAL;

	/* Reset bucket page lists, all empty. */
	for (n = 0; n < XNHEAP_MAX_BUCKETS; n++)
		heap->buckets[n] = -1U;

	xnlock_init(&heap->lock);

	nrpages = size >> XNHEAP_PAGE_SHIFT;
	heap->pagemap = vzalloc(sizeof(struct xnheap_pgentry) * nrpages);
	if (heap->pagemap == NULL)
		return -ENOMEM;

	heap->membase = membase;
	heap->usable_size = size;
	heap->used_size = 0;
		      
	/*
	 * The free page pool is maintained as a set of ranges of
	 * contiguous pages indexed by address and size in rbtrees.
	 * Initially, we have a single range in those trees covering
	 * the whole memory we have been given for the heap. Over
	 * time, that range will be split then possibly re-merged back
	 * as allocations and deallocations take place.
	 */
	heap->size_tree = RB_ROOT;
	heap->addr_tree = RB_ROOT;
	release_page_range(heap, membase, size);

	/* Default name, override with xnheap_set_name() */
	ksformat(heap->name, sizeof(heap->name), "(%p)", heap);

	xnlock_get_irqsave(&nklock, s);
	list_add_tail(&heap->next, &heapq);
	nrheaps++;
	xnvfile_touch_tag(&vfile_tag);
	xnlock_put_irqrestore(&nklock, s);

	return 0;
}
EXPORT_SYMBOL_GPL(xnheap_init);

/**
 * @fn void xnheap_destroy(struct xnheap *heap)
 * @brief Destroys a memory heap.
 *
 * Destroys a memory heap.
 *
 * @param heap The heap descriptor.
 *
 * @coretags{secondary-only}
 */
void xnheap_destroy(struct xnheap *heap)
{
	spl_t s;

	secondary_mode_only();

	xnlock_get_irqsave(&nklock, s);
	list_del(&heap->next);
	nrheaps--;
	xnvfile_touch_tag(&vfile_tag);
	xnlock_put_irqrestore(&nklock, s);
	vfree(heap->pagemap);
}
EXPORT_SYMBOL_GPL(xnheap_destroy);

/**
 * @fn xnheap_set_name(struct xnheap *heap,const char *name,...)
 * @brief Set the heap's name string.
 *
 * Set the heap name that will be used in statistic outputs.
 *
 * @param heap The address of a heap descriptor.
 *
 * @param name Name displayed in statistic outputs. This parameter can
 * be a printk()-like format argument list.
 *
 * @coretags{task-unrestricted}
 */
void xnheap_set_name(struct xnheap *heap, const char *name, ...)
{
	va_list args;

	va_start(args, name);
	kvsformat(heap->name, sizeof(heap->name), name, args);
	va_end(args);
}
EXPORT_SYMBOL_GPL(xnheap_set_name);

void *xnheap_vmalloc(size_t size)
{
	/*
	 * We want memory used in real-time context to be pulled from
	 * ZONE_NORMAL, however we don't need it to be physically
	 * contiguous.
	 *
	 * 32bit systems which would need HIGHMEM for running a Cobalt
	 * configuration would also be required to support PTE
	 * pinning, which not all architectures provide.  Moreover,
	 * pinning PTEs eagerly for a potentially (very) large amount
	 * of memory may quickly degrade performance.
	 *
	 * If using a different kernel/user memory split cannot be the
	 * answer for those configs, it's likely that basing such
	 * software on a 32bit system had to be wrong in the first
	 * place anyway.
	 */
	return vmalloc_kernel(size, 0);
}
EXPORT_SYMBOL_GPL(xnheap_vmalloc);

void xnheap_vfree(void *p)
{
	vfree(p);
}
EXPORT_SYMBOL_GPL(xnheap_vfree);

/** @} */