Changes since April

Clean up of build directories.
Simplifications to capability model.

conts/userlibs/libmem/include/mem/alloc_page.h

@@ -0,0 +1,30 @@
+#ifndef __ALLOC_PAGE_H__
+#define __ALLOC_PAGE_H__
+
+#include <mem/memcache.h>
+
+/* List member to keep track of free and unused physical pages.
+ * Has PAGE_SIZE granularity */
+struct page_area {
+	struct link list;
+	unsigned int used;	/* Used or free */
+	unsigned int pfn;	/* Base pfn */
+	unsigned int numpages;	/* Number of pages this region covers */
+	struct mem_cache *cache;/* The cache used when freeing the page area for
+				 * quickly finding where the area is stored. */
+};
+
+struct page_allocator {
+	struct link page_area_list;
+	struct link pga_cache_list;
+	int pga_free;
+};
+
+/* Initialises the page allocator */
+void init_page_allocator(unsigned long start, unsigned long end);
+
+/* Page allocation functions */
+void *alloc_page(int quantity);
+int free_page(void *paddr);
+
+#endif /* __ALLOC_PAGE_H__ */

conts/userlibs/libmem/include/mem/clz.h

@@ -0,0 +1,7 @@
+
+#ifndef __CLZ_H__
+#define __CLZ_H__
+
+unsigned int __clz(unsigned int bitvector);
+
+#endif /* __CLZ_H__ */

conts/userlibs/libmem/include/mem/debug.h

@@ -0,0 +1,17 @@
+#ifndef __DEBUG_H__
+#define __DEBUG_H__
+
+//#include <kmem/kmalloc.h>
+#include <mem/alloc_page.h>
+#include <l4/lib/list.h>
+
+#if defined(DEBUG)
+#define dprintf	printf
+#else
+#define dprintf(...)
+#endif
+
+void print_page_area_list(struct page_allocator *p);
+void print_km_area_list(struct link *s);
+void print_km_area(struct km_area *s);
+#endif /* DEBUG_H */

conts/userlibs/libmem/include/mem/libl4.h

@@ -0,0 +1,17 @@
+/*
+ * Mock-up l4 library definitions for host testing.
+ *
+ */
+#ifndef __TESTS_LIBL4_H__
+#define __TESTS_LIBL4_H__
+
+#include <l4/macros.h>
+#include <l4/config.h>
+#include <l4/types.h>
+
+u32 l4_map(unsigned long phys, unsigned long virt, u32 size, u32 flags, u32 tid);
+u32 l4_unmap(unsigned long a, unsigned long b, u32 npages);
+u32 l4_getpid(unsigned int *a, unsigned int *b, unsigned int *c);
+
+
+#endif

conts/userlibs/libmem/include/mem/malloc.h

@@ -0,0 +1,19 @@
+#ifndef __PRIVATE_MALLOC_H__
+#define __PRIVATE_MALLOC_H__
+
+#include <stddef.h>
+#include <string.h>
+
+void *kmalloc(size_t size);
+void kfree(void *blk);
+
+static inline void *kzalloc(size_t size)
+{
+	void *buf = kmalloc(size);
+
+	memset(buf, 0, size);
+	return buf;
+}
+
+
+#endif /*__PRIVATE_MALLOC_H__ */

conts/userlibs/libmem/include/mem/memcache.h

@@ -0,0 +1,50 @@
+/*
+ * Bitmap-based link-listable fixed-size memory cache.
+ *
+ * Copyright (C) 2007 Bahadir Balban
+ */
+
+#ifndef __MEMCACHE_H__
+#define __MEMCACHE_H__
+
+#include <l4/config.h>
+#include <l4/macros.h>
+#include <l4/types.h>
+#include <l4/lib/list.h>
+
+/* Very basic cache structure. All it does is, keep an internal bitmap of
+ * items of struct_size. (Note bitmap is fairly efficient and simple for a
+ * fixed-size memory cache) Keeps track of free/occupied items within its
+ * start/end boundaries. Does not grow/shrink but you can link-list it. */
+struct mem_cache {
+	struct link list;
+	int total;
+	int free;
+	unsigned int start;
+	unsigned int end;
+	unsigned int struct_size;
+	unsigned int *bitmap;
+};
+
+void *mem_cache_zalloc(struct mem_cache *cache);
+void *mem_cache_alloc(struct mem_cache *cache);
+int mem_cache_free(struct mem_cache *cache, void *addr);
+struct mem_cache *mem_cache_init(void *start, int cache_size,
+				 int struct_size, unsigned int alignment);
+static inline int mem_cache_is_full(struct mem_cache *cache)
+{
+	return cache->free == 0;
+}
+static inline int mem_cache_is_empty(struct mem_cache *cache)
+{
+	return cache->free == cache->total;
+}
+static inline int mem_cache_is_last_free(struct mem_cache *cache)
+{
+	return cache->free == 1;
+}
+static inline int mem_cache_total_empty(struct mem_cache *cache)
+{
+	return cache->free;
+}
+#endif /* __MEMCACHE_H__ */

conts/userlibs/libmem/include/mem/test_alloc_generic.h

@@ -0,0 +1,29 @@
+#ifndef __TEST_ALLOC_GENERIC_H__
+#define __TEST_ALLOC_GENERIC_H__
+
+enum test_state_title {
+	TEST_STATE_BEGIN = 0,
+	TEST_STATE_MIDDLE,
+	TEST_STATE_END,
+	TEST_STATE_ERROR
+};
+
+typedef void (*print_alloc_state_t)(void);
+typedef void *(*alloc_func_t)(int size);
+typedef int (*free_func_t)(void *addr);
+
+enum alloc_action {
+	FREE = 0,
+	ALLOCATE = 1,
+};
+
+void get_output_filepaths(FILE **out1, FILE **out2,
+			  char *alloc_func_name);
+
+int test_alloc_free_random_order(const int MAX_ALLOCATIONS,
+				 const int ALLOC_SIZE_MAX,
+				 alloc_func_t alloc, free_func_t free,
+				 print_alloc_state_t print_allocator_state,
+				 FILE *init_state, FILE *exit_state);
+
+#endif /* __TEST_ALLOC_GENERIC_H__ */

conts/userlibs/libmem/include/mem/test_allocpage.h

@@ -0,0 +1,13 @@
+#ifndef __TEST_ALLOCPAGE_H__
+#define __TEST_ALLOCPAGE_H__
+
+#include <mem/alloc_page.h>
+#include "tests.h"
+
+void test_allocpage(int num_allocs, int alloc_max, FILE *init, FILE *exit);
+void print_page_area(struct page_area *a, int no);
+void print_caches(struct link *cache_head);
+void print_cache(struct mem_cache *c, int cacheno);
+void print_areas(struct link *area_head);
+void print_page_area(struct page_area *ar, int areano);
+#endif

conts/userlibs/libmem/include/mem/test_kmalloc.h

@@ -0,0 +1,8 @@
+#ifndef __TEST_KMALLOC_H__
+#define __TEST_KMALLOC_H__
+
+#include <kmem/kmalloc.h>
+
+void test_kmalloc(int num_allocs, int allocs_max, FILE *initstate, FILE *exitstate);
+
+#endif

conts/userlibs/libmem/include/mem/test_memcache.h

@@ -0,0 +1,10 @@
+#ifndef __TEST_MEMCACHE_H__
+#define __TEST_MEMCACHE_H__
+
+#include <mem/memcache.h>
+
+int test_memcache(int num_alloc, int alloc_size_max, FILE *initstate, FILE *exitstate, int aligned);
+
+
+#endif /* __TEST_MEMCACHE_H__ */
+

conts/userlibs/libmem/include/mem/tests.h

@@ -0,0 +1,21 @@
+#ifndef __TESTS_H__
+#define __TESTS_H__
+
+/* Mock-up physical memory */
+extern unsigned int TEST_PHYSMEM_TOTAL_PAGES;
+extern unsigned int TEST_PHYSMEM_TOTAL_SIZE;
+
+/* Allocator test */
+extern unsigned int PAGE_ALLOCATIONS;
+extern unsigned int PAGE_ALLOC_SIZE_MAX;
+
+/* Memcache test */
+extern unsigned int MEMCACHE_ALLOCS_MAX;
+extern unsigned int TEST_CACHE_ITEM_SIZE;
+
+/* Kmalloc */
+extern unsigned int KMALLOC_ALLOCATIONS;
+extern unsigned int KMALLOC_ALLOC_SIZE_MAX;
+
+
+#endif /* __TESTS_H__ */