--- /dev/null
+/* Copyright (c) 2007, Sandia National Laboratories */
+
+#include <lwk/kernel.h>
+#include <lwk/buddy.h>
+#include <lwk/log2.h>
+
+
+/**
+ * This specifies the minimum sized memory block to request from the underlying
+ * buddy system memory allocator, 2^MIN_ORDER bytes. It must be at least big
+ * enough to hold a 'struct kmem_block_hdr'.
+ */
+#define MIN_ORDER 5 /* 32 bytes */
+
+
+/**
+ * Magic value used for sanity checking. Every block of memory allocated via
+ * kmem_alloc() has this value in its block header.
+ */
+#define KMEM_MAGIC 0xF0F0F0F0F0F0F0F0UL
+
+
+/**
+ * The kernel memory pool. This manages all memory available for dynamic
+ * allocation by the kernel. The kernel reserves some amount of memory
+ * (e.g., the first 8 MB, amount specifiable on kernel boot command line) for
+ * its own use, included in which is the kernel memory pool. The rest of memory
+ * is reserved for user applications.
+ *
+ * NOTE: There is currently only one buddy_mempool for the entire system.
+ * This may change to one per NUMA node in the future.
+ */
+static struct buddy_mempool *kmem = NULL;
+
+
+/**
+ * Total number of bytes in the kernel memory pool.
+ */
+static unsigned long kmem_bytes_managed;
+
+
+/**
+ * Total number of bytes allocated from the kernel memory pool.
+ */
+static unsigned long kmem_bytes_allocated;
+
+
+/**
+ * Each block of memory allocated from the kernel memory pool has one of these
+ * structures at its head. The structure contains information needed to free
+ * the block and return it to the underlying memory allocator.
+ *
+ * When a block is allocated, the address returned to the caller is
+ * sizeof(struct kmem_block_hdr) bytes greater than the block allocated from
+ * the underlying memory allocator.
+ *
+ * WARNING: This structure is defined to be exactly 16 bytes in size.
+ * Do not change this unless you really know what you are doing.
+ */
+struct kmem_block_hdr {
+ uint64_t order; /* order of the block allocated from buddy system */
+ uint64_t magic; /* magic value used as sanity check */
+} __attribute__((packed));
+
+
+/**
+ * This adds a zone to the kernel memory pool. Zones exist to allow there to be
+ * multiple non-adjacent regions of physically contiguous memory. The
+ * bookkeeping needed to cover the gaps would waste a lot of memory and have no
+ * benefit.
+ *
+ * Arguments:
+ * [IN] base_addr: Base address of the memory pool.
+ * [IN] size: Size of the memory pool in bytes.
+ *
+ * NOTE: Currently only one zone is supported. Calling kmem_create_zone() more
+ * than once will result in a panic.
+ */
+void
+kmem_create_zone(unsigned long base_addr, size_t size)
+{
+ unsigned long pool_order = ilog2(roundup_pow_of_two(size));
+ unsigned long min_order = MIN_ORDER;
+
+ /* For now, protect against calling kmem_create_zone() more than once */
+ BUG_ON(kmem != NULL);
+
+ /* Initialize the underlying buddy allocator */
+ if ((kmem = buddy_init(base_addr, pool_order, min_order)) == NULL)
+ panic("buddy_init() failed.");
+}
+
+
+/**
+ * This adds memory to the kernel memory pool. The memory region being added
+ * must fall within a zone previously specified via kmem_create_zone().
+ *
+ * Arguments:
+ * [IN] base_addr: Base address of the memory region to add.
+ * [IN] size: Size of the memory region in bytes.
+ */
+void
+kmem_add_memory(unsigned long base_addr, size_t size)
+{
+ /*
+ * kmem buddy allocator is initially empty.
+ * Memory is added to it via buddy_free().
+ * buddy_free() will panic if there are any problems with the args.
+ */
+ buddy_free(kmem, (void *)base_addr, ilog2(size));
+
+ /* Update statistics */
+ kmem_bytes_managed += size;
+}
+
+
+/**
+ * Allocates memory from the kernel memory pool. This will return a memory
+ * region that is at least 16-byte aligned. The memory returned is zeroed.
+ *
+ * Arguments:
+ * [IN] size: Amount of memory to allocate in bytes.
+ *
+ * Returns:
+ * Success: Pointer to the start of the allocated memory.
+ * Failure: NULL
+ */
+void *
+kmem_alloc(size_t size)
+{
+ unsigned long order;
+ struct kmem_block_hdr *hdr;
+
+ /* Make room for block header */
+ size += sizeof(struct kmem_block_hdr);
+
+ /* Calculate the block order needed */
+ order = ilog2(roundup_pow_of_two(size));
+ if (order < MIN_ORDER)
+ order = MIN_ORDER;
+
+ /* Allocate memory from the underlying buddy system */
+ if ((hdr = buddy_alloc(kmem, order)) == NULL)
+ return NULL;
+
+ /* Zero the block */
+ memset(hdr, 0, (1UL << order));
+
+ /* Initialize the block header */
+ hdr->order = order; /* kmem_free() needs this to free the block */
+ hdr->magic = KMEM_MAGIC; /* used for sanity check */
+
+ /* Update statistics */
+ kmem_bytes_allocated += (1UL << order);
+
+ /* Return address of first byte after block header to caller */
+ return hdr + 1;
+}
+
+
+/**
+ * Frees memory previously allocated with kmem_alloc().
+ *
+ * Arguments:
+ * [IN] addr: Address of the memory region to free.
+ *
+ * NOTE: The size of the memory region being freed is assumed to be in a
+ * 'struct kmem_block_hdr' header located immediately before the address
+ * passed in by the caller. This header is created and initialized by
+ * kmem_alloc().
+ */
+void
+kmem_free(void *addr)
+{
+ struct kmem_block_hdr *hdr;
+
+ BUG_ON((unsigned long)addr < sizeof(struct kmem_block_hdr));
+
+ /* Find the block header */
+ hdr = (struct kmem_block_hdr *)addr - 1;
+ BUG_ON(hdr->magic != KMEM_MAGIC);
+
+ /* Return block to the underlying buddy system */
+ buddy_free(kmem, hdr, hdr->order);
+
+ kmem_bytes_allocated -= (1 << hdr->order);
+}
+
+
+/**
+ * Allocates pages of memory from the kernel memory pool. The number of pages
+ * requested must be a power of two and the returned pages will be contiguous
+ * in physical memory. The memory returned is zeroed.
+ *
+ * Arguments:
+ * [IN] order: Number of pages to allocated, 2^order:
+ * 0 = 1 page
+ * 1 = 2 pages
+ * 2 = 4 pages
+ * 3 = 8 pages
+ * ...
+ * Returns:
+ * Success: Pointer to the start of the allocated memory.
+ * Failure: NULL
+ */
+void *
+kmem_get_pages(unsigned long order)
+{
+ unsigned long block_order;
+ void *addr;
+
+ /* Calculate the block size needed; convert page order to byte order */
+ block_order = order + ilog2(PAGE_SIZE);
+
+ /* Allocate memory from the underlying buddy system */
+ if ((addr = buddy_alloc(kmem, block_order)) == NULL)
+ return NULL;
+
+ /* Zero the block and return its address */
+ memset(addr, 0, (1UL << block_order));
+ return addr;
+}
+
+
+/**
+ * Frees pages of memory previously allocated with kmem_get_pages().
+ *
+ * Arguments:
+ * [IN] addr: Address of the memory region to free.
+ * [IN] order: Number of pages to free, 2^order.
+ * The order must match the value passed to kmem_get_pages()
+ * when the pages were allocated.
+ */
+void
+kmem_free_pages(void *addr, unsigned long order)
+{
+ buddy_free(kmem, addr, order + ilog2(PAGE_SIZE));
+}
+
+
