Index: generic/include/mm/buddy.h
===================================================================
--- generic/include/mm/buddy.h	(revision bd6e392fb9a42852294e181af5e1bd31204dcaf3)
+++ generic/include/mm/buddy.h	(revision 1093620503b2f69322a4608d2a3ce6af5b4336cd)
@@ -46,5 +46,5 @@
 
 struct buddy_system {
-	__u8 max_order;
+	__u8 max_order;				/**< Maximal order of block which can be stored by buddy system. */
 	link_t *order;
 	buddy_system_operations_t *op;
Index: generic/src/mm/buddy.c
===================================================================
--- generic/src/mm/buddy.c	(revision bd6e392fb9a42852294e181af5e1bd31204dcaf3)
+++ generic/src/mm/buddy.c	(revision 1093620503b2f69322a4608d2a3ce6af5b4336cd)
@@ -69,5 +69,5 @@
 		 * Allocate memory for all orders this buddy system will work with.
 		 */
-		b->order = (link_t *) early_malloc(max_order * sizeof(link_t));
+		b->order = (link_t *) early_malloc((max_order + 1) * sizeof(link_t));
 		if (!b->order) {
 			early_free(b);
@@ -75,5 +75,5 @@
 		}
 	
-		for (i = 0; i < max_order; i++)
+		for (i = 0; i <= max_order; i++)
 			list_initialize(&b->order[i]);
 	
@@ -96,7 +96,14 @@
 	__u8 k;
 	
-	ASSERT(i < b->max_order);
-	
-	for (k=i; k < b->max_order; k++) {
+	/*
+	 * If requested block is greater then maximal block
+	 * we know immediatly that we cannot satisfy the request.
+	 */
+	if (i > b->max_order) return false;
+
+	/*
+	 * Check if any bigger or equal order has free elements
+	 */
+	for (k=i; k <= b->max_order; k++) {
 		if (!list_empty(&b->order[k])) {
 			return true;
@@ -119,5 +126,5 @@
 	link_t *res, *hlp;
 
-	ASSERT(i < b->max_order);
+	ASSERT(i <= b->max_order);
 
 	/*
@@ -136,5 +143,5 @@
 	 * the request cannot be satisfied.
 	 */
-	if (i == b->max_order - 1)
+	if (i == b->max_order)
 		return NULL;
 
@@ -186,7 +193,7 @@
 	i = b->op->get_order(b, block);
 
-	ASSERT(i < b->max_order);
-
-	if (i != b->max_order - 1) {
+	ASSERT(i <= b->max_order);
+
+	if (i != b->max_order) {
 		/*
 		 * See if there is any buddy in the list of order i.
@@ -246,5 +253,5 @@
 	printf("-----\t------\t--------\t----------\t---------------\n");
 	
-	for (i=0;i < b->max_order; i++) {
+	for (i=0;i <= b->max_order; i++) {
 		cnt = 0;
 		if (!list_empty(&b->order[i])) {
Index: generic/src/mm/frame.c
===================================================================
--- generic/src/mm/frame.c	(revision bd6e392fb9a42852294e181af5e1bd31204dcaf3)
+++ generic/src/mm/frame.c	(revision 1093620503b2f69322a4608d2a3ce6af5b4336cd)
@@ -153,4 +153,6 @@
 	interrupts_restore(ipl);
 
+	ASSERT(v == ALIGN_UP(v, FRAME_SIZE << order));
+
 	if (flags & FRAME_KA)
 		v = PA2KA(v);
Index: test/mm/falloc1/test.c
===================================================================
--- test/mm/falloc1/test.c	(revision bd6e392fb9a42852294e181af5e1bd31204dcaf3)
+++ test/mm/falloc1/test.c	(revision 1093620503b2f69322a4608d2a3ce6af5b4336cd)
@@ -30,14 +30,15 @@
 #include <mm/page.h>
 #include <mm/frame.h>
+#include <mm/heap.h>
 #include <arch/mm/page.h>
 #include <arch/types.h>
 #include <debug.h>
 
-#define MAX_FRAMES 2048
+#define MAX_FRAMES 1024
 #define MAX_ORDER 8
-#define TEST_RUNS 4
+#define TEST_RUNS 2
 
 void test(void) {
-	__address frames[MAX_FRAMES];
+	__address * frames = (__address *) malloc(MAX_FRAMES*sizeof(__address));
 	int results[MAX_ORDER+1];
 	
@@ -53,5 +54,5 @@
 			allocated = 0;
 			for (i=0;i<MAX_FRAMES>>order;i++) {
-				frames[allocated] = frame_alloc(FRAME_NON_BLOCKING, order, &status);
+				frames[allocated] = frame_alloc(FRAME_NON_BLOCKING | FRAME_KA, order, &status);
 				
 				if (frames[allocated] % (FRAME_SIZE << order) != 0) {
@@ -83,5 +84,5 @@
 	}
 
-
+	free(frames);
 	
 	printf("Test passed\n");
Index: test/mm/falloc2/test.c
===================================================================
--- test/mm/falloc2/test.c	(revision bd6e392fb9a42852294e181af5e1bd31204dcaf3)
+++ test/mm/falloc2/test.c	(revision 1093620503b2f69322a4608d2a3ce6af5b4336cd)
@@ -30,4 +30,5 @@
 #include <mm/page.h>
 #include <mm/frame.h>
+#include <mm/heap.h>
 #include <arch/mm/page.h>
 #include <arch/types.h>
@@ -37,9 +38,9 @@
 #include <memstr.h>
 
-#define MAX_FRAMES 128
-#define MAX_ORDER 2
+#define MAX_FRAMES 256
+#define MAX_ORDER 8
 
 #define THREAD_RUNS 1
-#define THREADS 6
+#define THREADS 8
 
 static void thread(void * arg);
@@ -54,5 +55,5 @@
 	index_t k;
 	
-	__address frames[MAX_FRAMES];
+	__address * frames =  (__address *) malloc(MAX_FRAMES * sizeof(__address));
 
 	for (run=0;run<THREAD_RUNS;run++) {
@@ -61,5 +62,5 @@
 			printf("Thread #%d: Allocating %d frames blocks ... \n",val, 1<<order);
 			allocated = 0;
-			for (i=0;i<MAX_FRAMES>>order;i++) {
+			for (i=0;i < (MAX_FRAMES >> order);i++) {
 				frames[allocated] = frame_alloc(FRAME_NON_BLOCKING | FRAME_KA,order, &status);
 				if (status == 0) {
@@ -75,4 +76,5 @@
 			printf("Thread #%d: Deallocating ... \n", val);
 			for (i=0;i<allocated;i++) {
+			
 				for (k=0;k<=((FRAME_SIZE << order) - 1);k++) {
 					if ( ((char *) frames[i])[k] != val ) {
@@ -82,5 +84,5 @@
 				
 				}
-			
+				
 				frame_free(frames[i]);
 			}