Changeset 3375bd4 in mainline for kernel

Timestamp:

2011-05-17T07:44:17Z (14 years ago)

Author:

Vojtech Horky <vojtechhorky@…>

Branches:

lfn, master, serial, ticket/834-toolchain-update, topic/msim-upgrade, topic/simplify-dev-export

Children:

04c418d, 2586860, 5e6e50b

Parents:

72cd53d (diff), 0d8a304 (diff)
Note: this is a merge changeset, the changes displayed below correspond to the merge itself.
Use the (diff) links above to see all the changes relative to each parent.

Message:

Merge mainline changes

Conflicts:
kernel/generic/src/console/console.c

size of klog, taken upstream

uspace/app/klog/klog.c

taken upstream (upstream fixed the broken output on huge load)

uspace/app/tester/Makefile
uspace/app/tester/tester.c
uspace/app/tester/tester.h

merged without problems

uspace/lib/c/include/as.h

merged without problems (upstream use bare declarations)

Also needed to fix some missing includes.

Location:

kernel

Files:

• Makefile (modified) (3 diffs)
• arch/abs32le/include/types.h (modified) (1 diff)
• arch/amd64/include/types.h (modified) (1 diff)
• arch/amd64/src/interrupt.c (modified) (1 diff)
• arch/arm32/include/types.h (modified) (1 diff)
• arch/arm32/src/exception.c (modified) (1 diff)
• arch/ia32/Makefile.inc (modified) (1 diff)
• arch/ia32/include/barrier.h (modified) (2 diffs)
• arch/ia32/include/types.h (modified) (1 diff)
• arch/ia32/src/interrupt.c (modified) (1 diff)
• arch/ia64/_link.ld.in (modified) (1 diff)
• arch/ia64/include/types.h (modified) (1 diff)
• arch/ia64/src/ivt.S (modified) (1 diff)
• arch/ia64/src/start.S (modified) (1 diff)
• arch/mips32/include/types.h (modified) (1 diff)
• arch/mips32/src/exception.c (modified) (2 diffs)
• arch/mips32/src/mm/frame.c (modified) (1 diff)
• arch/ppc32/include/types.h (modified) (1 diff)
• arch/ppc32/src/interrupt.c (modified) (1 diff)
• arch/sparc64/include/cpu.h (modified) (1 diff)
• arch/sparc64/include/sun4u/cpu.h (modified) (1 diff)
• arch/sparc64/include/types.h (modified) (1 diff)
• generic/include/ipc/event.h (modified) (1 diff)
• generic/include/ipc/event_types.h (modified) (1 diff)
• generic/include/macros.h (modified) (1 diff)
• generic/include/mm/as.h (modified) (1 diff)
• generic/include/mm/frame.h (modified) (4 diffs)
• generic/include/mm/reserve.h (added)
• generic/include/str.h (modified) (1 diff)
• generic/include/syscall/syscall.h (modified) (1 diff)
• generic/src/console/cmd.c (modified) (1 diff)
• generic/src/console/console.c (modified) (3 diffs)
• generic/src/ipc/event.c (modified) (3 diffs)
• generic/src/lib/str.c (modified) (2 diffs)
• generic/src/main/main.c (modified) (3 diffs)
• generic/src/mm/as.c (modified) (4 diffs)
• generic/src/mm/backend_anon.c (modified) (5 diffs)
• generic/src/mm/backend_elf.c (modified) (3 diffs)
• generic/src/mm/backend_phys.c (modified) (2 diffs)
• generic/src/mm/frame.c (modified) (18 diffs)
• generic/src/mm/reserve.c (added)
• generic/src/proc/scheduler.c (modified) (1 diff)
• generic/src/proc/task.c (modified) (1 diff)
• generic/src/syscall/syscall.c (modified) (1 diff)

kernel/Makefile

@@ -94 +94 @@
         -fexec-charset=UTF-8 -fwide-exec-charset=UTF-32$(ENDIANESS) \
         -finput-charset=UTF-8 -ffreestanding -fno-builtin -nostdlib -nostdinc \
-        -Wall -Wextra -Wno-unused-parameter -Wmissing-prototypes \
+        -std=gnu99 -Wall -Wextra -Wno-unused-parameter -Wmissing-prototypes \
         -Werror-implicit-function-declaration -Wwrite-strings \
         -pipe
@@ -134 +134 @@
 #
 AFLAGS =
-LFLAGS = -N -T $(LINK) -M
+LFLAGS = -n -T $(LINK) -M
 
 #
@@ -228 +228 @@
         generic/src/syscall/syscall.c \
         generic/src/syscall/copy.c \
+        generic/src/mm/reserve.c \
         generic/src/mm/buddy.c \
         generic/src/mm/frame.c \

kernel/arch/abs32le/include/types.h

@@ -40 +40 @@
 
 typedef uint32_t size_t;
+typedef int32_t ssize_t;
 
 typedef uint32_t uintptr_t;

kernel/arch/amd64/include/types.h

@@ -37 +37 @@
 
 typedef uint64_t size_t;
+typedef int64_t ssize_t;
 
 typedef uint64_t uintptr_t;

kernel/arch/amd64/src/interrupt.c

@@ -66 +66 @@
 void istate_decode(istate_t *istate)
 {
-        printf("cs =%#0" PRIx64 "\trip=%p\t"
-            "rfl=%#0" PRIx64 "\terr=%#0" PRIx64 "\n",
-            istate->cs, (void *) istate->rip,
-            istate->rflags, istate->error_word);
+        printf("cs =%0#18" PRIx64 "\trip=%0#18" PRIx64 "\t"
+            "rfl=%0#18" PRIx64 "\terr=%0#18" PRIx64 "\n",
+            istate->cs, istate->rip, istate->rflags, istate->error_word);
         
         if (istate_from_uspace(istate))
-                printf("ss =%#0" PRIx64 "\n", istate->ss);
-        
-        printf("rax=%#0" PRIx64 "\trbx=%#0" PRIx64 "\t"
-            "rcx=%#0" PRIx64 "\trdx=%#0" PRIx64 "\n",
+                printf("ss =%0#18" PRIx64 "\n", istate->ss);
+        
+        printf("rax=%0#18" PRIx64 "\trbx=%0#18" PRIx64 "\t"
+            "rcx=%0#18" PRIx64 "\trdx=%0#18" PRIx64 "\n",
             istate->rax, istate->rbx, istate->rcx, istate->rdx);
         
-        printf("rsi=%p\trdi=%p\trbp=%p\trsp=%p\n",
-            (void *) istate->rsi, (void *) istate->rdi,
-            (void *) istate->rbp,
-            istate_from_uspace(istate) ? ((void *) istate->rsp) :
-            &istate->rsp);
-        
-        printf("r8 =%#0" PRIx64 "\tr9 =%#0" PRIx64 "\t"
-            "r10=%#0" PRIx64 "\tr11=%#0" PRIx64 "\n",
+        printf("rsi=%0#18" PRIx64 "\trdi=%0#18" PRIx64 "\t"
+            "rbp=%0#18" PRIx64 "\trsp=%0#18" PRIx64 "\n",
+            istate->rsi, istate->rdi, istate->rbp,
+            istate_from_uspace(istate) ? istate->rsp :
+            (uintptr_t) &istate->rsp);
+        
+        printf("r8 =%0#18" PRIx64 "\tr9 =%0#18" PRIx64 "\t"
+            "r10=%0#18" PRIx64 "\tr11=%0#18" PRIx64 "\n",
             istate->r8, istate->r9, istate->r10, istate->r11);
         
-        printf("r12=%#0" PRIx64 "\tr13=%#0" PRIx64 "\t"
-            "r14=%#0" PRIx64 "\tr15=%#0" PRIx64 "\n",
+        printf("r12=%0#18" PRIx64 "\tr13=%0#18" PRIx64 "\t"
+            "r14=%0#18" PRIx64 "\tr15=%0#18" PRIx64 "\n",
             istate->r12, istate->r13, istate->r14, istate->r15);
 }

kernel/arch/arm32/include/types.h

@@ -44 +44 @@
 
 typedef uint32_t size_t;
+typedef int32_t ssize_t;
 
 typedef uint32_t uintptr_t;

kernel/arch/arm32/src/exception.c

@@ -174 +174 @@
 void istate_decode(istate_t *istate)
 {
-        printf("r0 =%#0" PRIx32 "\tr1 =%#0" PRIx32 "\t"
-            "r2 =%#0" PRIx32 "\tr3 =%#0" PRIx32 "\n",
+        printf("r0 =%0#10" PRIx32 "\tr1 =%0#10" PRIx32 "\t"
+            "r2 =%0#10" PRIx32 "\tr3 =%0#10" PRIx32 "\n",
             istate->r0, istate->r1, istate->r2, istate->r3);
-        printf("r4 =%#" PRIx32 "\tr5 =%#0" PRIx32 "\t"
-            "r6 =%#0" PRIx32 "\tr7 =%#0" PRIx32 "\n",
+        printf("r4 =%0#10" PRIx32 "\tr5 =%0#10" PRIx32 "\t"
+            "r6 =%0#10" PRIx32 "\tr7 =%0#10" PRIx32 "\n",
             istate->r4, istate->r5, istate->r6, istate->r7);
-        printf("r8 =%#0" PRIx32 "\tr9 =%#0" PRIx32 "\t"
-            "r10=%#0" PRIx32 "\tfp =%p\n",
-            istate->r8, istate->r9, istate->r10,
-            (void *) istate->fp);
-        printf("r12=%#0" PRIx32 "\tsp =%p\tlr =%p\tspsr=%p\n",
-            istate->r12, (void *) istate->sp,
-            (void *) istate->lr, (void *) istate->spsr);
+        printf("r8 =%0#10" PRIx32 "\tr9 =%0#10" PRIx32 "\t"
+            "r10=%0#10" PRIx32 "\tfp =%0#10" PRIx32 "\n",
+            istate->r8, istate->r9, istate->r10, istate->fp);
+        printf("r12=%0#10" PRIx32 "\tsp =%0#10" PRIx32 "\t"
+            "lr =%0#10" PRIx32 "\tspsr=%0#10" PRIx32 "\n",
+            istate->r12, istate->sp, istate->lr, istate->spsr);
 }
 

kernel/arch/ia32/Makefile.inc

@@ -35 +35 @@
 ENDIANESS = LE
 
-CMN1 = -m32
+CMN1 = -m32 -fno-omit-frame-pointer
 GCC_CFLAGS += $(CMN1)
 ICC_CFLAGS += $(CMN1)

kernel/arch/ia32/include/barrier.h

@@ -54 +54 @@
 NO_TRACE static inline void cpuid_serialization(void)
 {
+#ifndef __IN_SHARED_LIBC__
         asm volatile (
                 "xorl %%eax, %%eax\n"
@@ -59 +60 @@
                 ::: "eax", "ebx", "ecx", "edx", "memory"
         );
+#else
+        /* Must not clobber PIC register ebx */
+        asm volatile (
+                "movl %%ebx, %%esi\n"
+                "xorl %%eax, %%eax\n"
+                "cpuid\n"
+                "movl %%esi, %%ebx\n"
+                ::: "eax", "ecx", "edx", "esi", "memory"
+        );
+#endif
 }
 

kernel/arch/ia32/include/types.h

@@ -37 +37 @@
 
 typedef uint32_t size_t;
+typedef int32_t ssize_t;
 
 typedef uint32_t uintptr_t;

kernel/arch/ia32/src/interrupt.c

@@ -66 +66 @@
 void istate_decode(istate_t *istate)
 {
-        printf("cs =%#0" PRIx32 "\teip=%p\t"
-            "efl=%#0" PRIx32 "\terr=%#0" PRIx32 "\n",
-            istate->cs, (void *) istate->eip,
-            istate->eflags, istate->error_word);
-        
-        printf("ds =%#0" PRIx32 "\tes =%#0" PRIx32 "\t"
-            "fs =%#0" PRIx32 "\tgs =%#0" PRIx32 "\n",
+        printf("cs =%0#10" PRIx32 "\teip=%0#10" PRIx32 "\t"
+            "efl=%0#10" PRIx32 "\terr=%0#10" PRIx32 "\n",
+            istate->cs, istate->eip, istate->eflags, istate->error_word);
+        
+        printf("ds =%0#10" PRIx32 "\tes =%0#10" PRIx32 "\t"
+            "fs =%0#10" PRIx32 "\tgs =%0#10" PRIx32 "\n",
             istate->ds, istate->es, istate->fs, istate->gs);
         
         if (istate_from_uspace(istate))
-                printf("ss =%#0" PRIx32 "\n", istate->ss);
-        
-        printf("eax=%#0" PRIx32 "\tebx=%#0" PRIx32 "\t"
-            "ecx=%#0" PRIx32 "\tedx=%#0" PRIx32 "\n",
+                printf("ss =%0#10" PRIx32 "\n", istate->ss);
+        
+        printf("eax=%0#10" PRIx32 "\tebx=%0#10" PRIx32 "\t"
+            "ecx=%0#10" PRIx32 "\tedx=%0#10" PRIx32 "\n",
             istate->eax, istate->ebx, istate->ecx, istate->edx);
         
-        printf("esi=%p\tedi=%p\tebp=%p\tesp=%p\n",
-            (void *) istate->esi, (void *) istate->edi,
-            (void *) istate->ebp,
-            istate_from_uspace(istate) ? ((void *) istate->esp) :
-            &istate->esp);
+        printf("esi=%0#10" PRIx32 "\tedi=%0#10" PRIx32 "\t"
+            "ebp=%0#10" PRIx32 "\tesp=%0#10" PRIx32 "\n",
+            istate->esi, istate->edi, istate->ebp,
+            istate_from_uspace(istate) ? istate->esp :
+            (uintptr_t) &istate->esp);
 }
 

kernel/arch/ia64/_link.ld.in

@@ -30 +30 @@
                 hardcoded_kdata_size = .;
                 QUAD(kdata_end - kdata_start);
+                __gp = .;
                 *(.got .got.*)
                 *(.sdata)

kernel/arch/ia64/include/types.h

@@ -37 +37 @@
 
 typedef uint64_t size_t;
+typedef int64_t ssize_t;
 
 typedef uint64_t uintptr_t;

kernel/arch/ia64/src/ivt.S

@@ -391 +391 @@
 
     /* 10. call handler */
-        movl r1 = kernel_image_start
+        movl r1 = __gp
     
         mov b1 = loc2

kernel/arch/ia64/src/start.S

@@ -174 +174 @@
         
         # Initialize gp (Global Pointer) register
-        movl gp = kernel_image_start
+        movl gp = __gp
         
-        #       
+        #
         # Initialize bootinfo on BSP.
         #

kernel/arch/mips32/include/types.h

@@ -37 +37 @@
 
 typedef uint32_t size_t;
+typedef int32_t ssize_t;
 
 typedef uint32_t uintptr_t;

kernel/arch/mips32/src/exception.c

@@ -74 +74 @@
 void istate_decode(istate_t *istate)
 {
-        printf("epc=%p\tsta=%#010" PRIx32 "\t"
+        printf("epc=%#010" PRIx32 "\tsta=%#010" PRIx32 "\t"
             "lo =%#010" PRIx32 "\thi =%#010" PRIx32 "\n",
-            (void *) istate->epc, istate->status,
-            istate->lo, istate->hi);
+            istate->epc, istate->status, istate->lo, istate->hi);
         
         printf("a0 =%#010" PRIx32 "\ta1 =%#010" PRIx32 "\t"
@@ -107 +106 @@
             istate->s8, istate->at, istate->kt0, istate->kt1);
         
-        printf("sp =%p\tra =%p\tgp =%p\n",
-            (void *) istate->sp, (void *) istate->ra,
-            (void *) istate->gp);
+        printf("sp =%#010" PRIx32 "\tra =%#010" PRIx32 "\t"
+            "gp =%#010" PRIx32 "\n",
+            istate->sp, istate->ra, istate->gp);
 }
 

kernel/arch/mips32/src/mm/frame.c

@@ -88 +88 @@
         /* gxemul devices */
         if (overlaps(frame << ZERO_PAGE_WIDTH, ZERO_PAGE_SIZE,
-            0x10000000, MB2SIZE(256)))
+            0x10000000, MiB2SIZE(256)))
                 return false;
 #endif

kernel/arch/ppc32/include/types.h

@@ -37 +37 @@
 
 typedef uint32_t size_t;
+typedef int32_t ssize_t;
 
 typedef uint32_t uintptr_t;

kernel/arch/ppc32/src/interrupt.c

@@ -54 +54 @@
 void istate_decode(istate_t *istate)
 {
-        printf("r0 =%#0" PRIx32 "\tr1 =%p\tr2 =%#0" PRIx32 "\n",
-            istate->r0, (void *) istate->sp, istate->r2);
+        printf("r0 =%0#10" PRIx32 "\tr1 =%0#10" PRIx32 "\t"
+            "r2 =%0#10" PRIx32 "\n", istate->r0, istate->sp, istate->r2);
         
-        printf("r3 =%#0" PRIx32 "\tr4 =%#0" PRIx32 "\tr5 =%#0" PRIx32 "\n",
-            istate->r3, istate->r4, istate->r5);
+        printf("r3 =%0#10" PRIx32 "\tr4 =%0#10" PRIx32 "\t"
+            "r5 =%0#10" PRIx32 "\n", istate->r3, istate->r4, istate->r5);
         
-        printf("r6 =%#0" PRIx32 "\tr7 =%#0" PRIx32 "\tr8 =%#0" PRIx32 "\n",
-            istate->r6, istate->r7, istate->r8);
+        printf("r6 =%0#10" PRIx32 "\tr7 =%0#10" PRIx32 "\t"
+            "r8 =%0#10" PRIx32 "\n", istate->r6, istate->r7, istate->r8);
         
-        printf("r9 =%#0" PRIx32 "\tr10=%#0" PRIx32 "\tr11=%#0" PRIx32 "\n",
-            istate->r9, istate->r10, istate->r11);
+        printf("r9 =%0#10" PRIx32 "\tr10=%0#10" PRIx32 "\t"
+            "r11=%0#10" PRIx32 "\n", istate->r9, istate->r10, istate->r11);
         
-        printf("r12=%#0" PRIx32 "\tr13=%#0" PRIx32 "\tr14=%#0" PRIx32 "\n",
-            istate->r12, istate->r13, istate->r14);
+        printf("r12=%0#10" PRIx32 "\tr13=%0#10" PRIx32 "\t"
+            "r14=%0#10" PRIx32 "\n", istate->r12, istate->r13, istate->r14);
         
-        printf("r15=%#0" PRIx32 "\tr16=%#0" PRIx32 "\tr17=%#0" PRIx32 "\n",
-            istate->r15, istate->r16, istate->r17);
+        printf("r15=%0#10" PRIx32 "\tr16=%0#10" PRIx32 "\t"
+            "r17=%0#10" PRIx32 "\n", istate->r15, istate->r16, istate->r17);
         
-        printf("r18=%#0" PRIx32 "\tr19=%#0" PRIx32 "\tr20=%#0" PRIx32 "\n",
-            istate->r18, istate->r19, istate->r20);
+        printf("r18=%0#10" PRIx32 "\tr19=%0#10" PRIx32 "\t"
+            "r20=%0#10" PRIx32 "\n", istate->r18, istate->r19, istate->r20);
         
-        printf("r21=%#0" PRIx32 "\tr22=%#0" PRIx32 "\tr23=%#0" PRIx32 "\n",
-            istate->r21, istate->r22, istate->r23);
+        printf("r21=%0#10" PRIx32 "\tr22=%0#10" PRIx32 "\t"
+            "r23=%0#10" PRIx32 "\n", istate->r21, istate->r22, istate->r23);
         
-        printf("r24=%#0" PRIx32 "\tr25=%#0" PRIx32 "\tr26=%#0" PRIx32 "\n",
-            istate->r24, istate->r25, istate->r26);
+        printf("r24=%0#10" PRIx32 "\tr25=%0#10" PRIx32 "\t"
+            "r26=%0#10" PRIx32 "\n", istate->r24, istate->r25, istate->r26);
         
-        printf("r27=%#0" PRIx32 "\tr28=%#0" PRIx32 "\tr29=%#0" PRIx32 "\n",
-            istate->r27, istate->r28, istate->r29);
+        printf("r27=%0#10" PRIx32 "\tr28=%0#10" PRIx32 "\t"
+            "r29=%0#10" PRIx32 "\n", istate->r27, istate->r28, istate->r29);
         
-        printf("r30=%#0" PRIx32 "\tr31=%#0" PRIx32 "\n",
+        printf("r30=%0#10" PRIx32 "\tr31=%0#10" PRIx32 "\n",
             istate->r30, istate->r31);
         
-        printf("cr =%#0" PRIx32 "\tpc =%p\tlr =%p\n",
-            istate->cr, (void *) istate->pc, (void *) istate->lr);
+        printf("cr =%0#10" PRIx32 "\tpc =%0#10" PRIx32 "\t"
+            "lr =%0#10" PRIx32 "\n", istate->cr, istate->pc, istate->lr);
         
-        printf("ctr=%#0" PRIx32 "\txer=%#0" PRIx32 "\tdar=%#0" PRIx32 "\n",
-            istate->ctr, istate->xer, istate->dar);
+        printf("ctr=%0#10" PRIx32 "\txer=%0#10" PRIx32 "\t"
+            "dar=%0#10" PRIx32 "\n", istate->ctr, istate->xer, istate->dar);
         
-        printf("srr1=%p\n", (void *) istate->srr1);
+        printf("srr1=%0#10" PRIx32 "\n", istate->srr1);
 }
 

kernel/arch/sparc64/include/cpu.h

@@ -59 +59 @@
 #include <arch/asm.h>
 
-#ifdef CONFIG_SMP
-#include <arch/mm/cache.h>
-#endif
-
-
 #if defined (SUN4U)
 #include <arch/sun4u/cpu.h>

kernel/arch/sparc64/include/sun4u/cpu.h

@@ -60 +60 @@
 #include <trace.h>
 
-#ifdef CONFIG_SMP
-#include <arch/mm/cache.h>
-#endif
-
 typedef struct {
         uint32_t mid;              /**< Processor ID as read from

kernel/arch/sparc64/include/types.h

@@ -37 +37 @@
 
 typedef uint64_t size_t;
+typedef int64_t ssize_t;
 
 typedef uint64_t uintptr_t;

kernel/generic/include/ipc/event.h

@@ -51 +51 @@
         /** Counter. */
         size_t counter;
+        /** Masked flag. */
+        bool masked;
+        /** Unmask callback. */
+        void (*unmask_cb)(void);
 } event_t;
 
 extern void event_init(void);
+extern void event_cleanup_answerbox(answerbox_t *);
+extern void event_set_unmask_callback(event_type_t, void (*)(void));
+
+#define event_notify_0(e, m) \
+        event_notify((e), (m), 0, 0, 0, 0, 0)
+#define event_notify_1(e, m, a1) \
+        event_notify((e), (m), (a1), 0, 0, 0, 0)
+#define event_notify_2(e, m, a1, a2) \
+        event_notify((e), (m), (a1), (a2), 0, 0, 0)
+#define event_notify_3(e, m, a1, a2, a3) \
+        event_notify((e), (m), (a1), (a2), (a3), 0, 0)
+#define event_notify_4(e, m, a1, a2, a3, a4) \
+        event_notify((e), (m), (a1), (a2), (a3), (a4), 0)
+#define event_notify_5(e, m, a1, a2, a3, a4, a5) \
+        event_notify((e), (m), (a1), (a2), (a3), (a4), (a5))
+
+extern int event_notify(event_type_t, bool, sysarg_t, sysarg_t, sysarg_t,
+    sysarg_t, sysarg_t);
+
 extern sysarg_t sys_event_subscribe(sysarg_t, sysarg_t);
-extern bool event_is_subscribed(event_type_t);
-extern void event_cleanup_answerbox(answerbox_t *);
-
-#define event_notify_0(e) \
-        event_notify((e), 0, 0, 0, 0, 0)
-#define event_notify_1(e, a1) \
-        event_notify((e), (a1), 0, 0, 0, 0)
-#define event_notify_2(e, a1, a2) \
-        event_notify((e), (a1), (a2), 0, 0, 0)
-#define event_notify_3(e, a1, a2, a3) \
-        event_notify((e), (a1), (a2), (a3), 0, 0)
-#define event_notify_4(e, a1, a2, a3, a4) \
-        event_notify((e), (a1), (a2), (a3), (a4), 0)
-#define event_notify_5(e, a1, a2, a3, a4, a5) \
-        event_notify((e), (a1), (a2), (a3), (a4), (a5))
-
-extern void event_notify(event_type_t, sysarg_t, sysarg_t, sysarg_t,
-    sysarg_t, sysarg_t);
+extern sysarg_t sys_event_unmask(sysarg_t);
 
 #endif

kernel/generic/include/ipc/event_types.h

@@ -39 +39 @@
         /** New data available in kernel log */
         EVENT_KLOG = 0,
-        /** Returning from kernel console to userspace */
+        /** Returning from kernel console to uspace */
         EVENT_KCONSOLE,
         /** A task/thread has faulted and will be terminated */

kernel/generic/include/macros.h

@@ -95 +95 @@
         overlaps(KA2PA((x)), (szx), KA2PA((y)), (szy))
 
-#define SIZE2KB(size)  ((size) >> 10)
-#define SIZE2MB(size)  ((size) >> 20)
-
-#define KB2SIZE(kb)  ((kb) << 10)
-#define MB2SIZE(mb)  ((mb) << 20)
+#define KiB2SIZE(kb)  ((kb) << 10)
+#define MiB2SIZE(mb)  ((mb) << 20)
 
 #define STRING(arg)      STRING_ARG(arg)

kernel/generic/include/mm/as.h

@@ -238 +238 @@
 /** Address space area backend structure. */
 typedef struct mem_backend {
+        bool (* create)(as_area_t *);
+        bool (* resize)(as_area_t *, size_t);
+        void (* share)(as_area_t *);
+        void (* destroy)(as_area_t *);
+
         int (* page_fault)(as_area_t *, uintptr_t, pf_access_t);
         void (* frame_free)(as_area_t *, uintptr_t, uintptr_t);
-        void (* share)(as_area_t *);
 } mem_backend_t;
 

kernel/generic/include/mm/frame.h

@@ -62 +62 @@
 
 /** Convert the frame address to kernel VA. */
-#define FRAME_KA          0x01
+#define FRAME_KA          0x1
 /** Do not panic and do not sleep on failure. */
-#define FRAME_ATOMIC      0x02
+#define FRAME_ATOMIC      0x2
 /** Do not start reclaiming when no free memory. */
-#define FRAME_NO_RECLAIM  0x04
+#define FRAME_NO_RECLAIM  0x4
+/** Do not reserve / unreserve memory. */
+#define FRAME_NO_RESERVE  0x8
 
 typedef uint8_t zone_flags_t;
 
 /** Available zone (free for allocation) */
-#define ZONE_AVAILABLE  0x00
+#define ZONE_AVAILABLE  0x0
 /** Zone is reserved (not available for allocation) */
-#define ZONE_RESERVED   0x08
+#define ZONE_RESERVED   0x8
 /** Zone is used by firmware (not available for allocation) */
 #define ZONE_FIRMWARE   0x10
@@ -85 +87 @@
         uint8_t buddy_order;  /**< Buddy system block order */
         link_t buddy_link;    /**< Link to the next free block inside
-                               one order */
+                                   one order */
         void *parent;         /**< If allocated by slab, this points there */
 } frame_t;
@@ -91 +93 @@
 typedef struct {
         pfn_t base;                    /**< Frame_no of the first frame
-                                        in the frames array */
+                                            in the frames array */
         size_t count;                  /**< Size of zone */
         size_t free_count;             /**< Number of free frame_t
-                                        structures */
+                                            structures */
         size_t busy_count;             /**< Number of busy frame_t
-                                        structures */
+                                            structures */
         zone_flags_t flags;            /**< Type of the zone */
         
         frame_t *frames;               /**< Array of frame_t structures
-                                        in this zone */
+                                            in this zone */
         buddy_system_t *buddy_system;  /**< Buddy system for the zone */
 } zone_t;
@@ -146 +148 @@
     ((~(((sysarg_t) -1) << (order)) & (index)) == 0)
 #define IS_BUDDY_LEFT_BLOCK(zone, frame) \
-    (((frame_index((zone), (frame)) >> (frame)->buddy_order) & 0x01) == 0)
+    (((frame_index((zone), (frame)) >> (frame)->buddy_order) & 0x1) == 0)
 #define IS_BUDDY_RIGHT_BLOCK(zone, frame) \
-    (((frame_index((zone), (frame)) >> (frame)->buddy_order) & 0x01) == 1)
+    (((frame_index((zone), (frame)) >> (frame)->buddy_order) & 0x1) == 1)
 #define IS_BUDDY_LEFT_BLOCK_ABS(zone, frame) \
-    (((frame_index_abs((zone), (frame)) >> (frame)->buddy_order) & 0x01) == 0)
+    (((frame_index_abs((zone), (frame)) >> (frame)->buddy_order) & 0x1) == 0)
 #define IS_BUDDY_RIGHT_BLOCK_ABS(zone, frame) \
-    (((frame_index_abs((zone), (frame)) >> (frame)->buddy_order) & 0x01) == 1)
-
-#define frame_alloc(order, flags) \
-    frame_alloc_generic(order, flags, NULL)
+    (((frame_index_abs((zone), (frame)) >> (frame)->buddy_order) & 0x1) == 1)
 
 extern void frame_init(void);
 extern void *frame_alloc_generic(uint8_t, frame_flags_t, size_t *);
+extern void *frame_alloc(uint8_t, frame_flags_t);
+extern void *frame_alloc_noreserve(uint8_t, frame_flags_t);
+extern void frame_free_generic(uintptr_t, frame_flags_t);
 extern void frame_free(uintptr_t);
+extern void frame_free_noreserve(uintptr_t);
 extern void frame_reference_add(pfn_t);
+extern size_t frame_total_free_get(void);
 
-extern size_t find_zone(pfn_t frame, size_t count, size_t hint);
+extern size_t find_zone(pfn_t, size_t, size_t);
 extern size_t zone_create(pfn_t, size_t, pfn_t, zone_flags_t);
 extern void *frame_get_parent(pfn_t, size_t);

kernel/generic/include/str.h

@@ -99 +99 @@
 extern int str_uint64(const char *, char **, unsigned int, bool, uint64_t *);
 
-extern void order_suffix(const uint64_t val, uint64_t *rv, char *suffix);
+extern void order_suffix(const uint64_t, uint64_t *, char *);
+extern void bin_order_suffix(const uint64_t, uint64_t *, const char **, bool);
 
 #endif

kernel/generic/include/syscall/syscall.h

@@ -78 +78 @@
         
         SYS_EVENT_SUBSCRIBE,
+        SYS_EVENT_UNMASK,
         
         SYS_CAP_GRANT,

kernel/generic/src/console/cmd.c

@@ -1107 +1107 @@
         release_console();
         
-        event_notify_0(EVENT_KCONSOLE);
+        event_notify_0(EVENT_KCONSOLE, false);
         indev_pop_character(stdin);
         

kernel/generic/src/console/console.c

@@ -53 +53 @@
 #include <str.h>
 
-/*
- * devman produces a lot of output and by giving so many pages
- * we to allow /app/klog to catch-up.
- */
-#ifdef CONFIG_DEVMAN_EARLY_LAUNCH
-#define KLOG_PAGES    64
-#else
-#define KLOG_PAGES    4
-#endif
-
+#define KLOG_PAGES    8
 #define KLOG_LENGTH   (KLOG_PAGES * PAGE_SIZE / sizeof(wchar_t))
 #define KLOG_LATENCY  8
@@ -174 +165 @@
         sysinfo_set_item_val("klog.faddr", NULL, (sysarg_t) faddr);
         sysinfo_set_item_val("klog.pages", NULL, KLOG_PAGES);
+
+        event_set_unmask_callback(EVENT_KLOG, klog_update);
         
         spinlock_lock(&klog_lock);
@@ -274 +267 @@
         spinlock_lock(&klog_lock);
         
-        if ((klog_inited) && (event_is_subscribed(EVENT_KLOG)) && (klog_uspace > 0)) {
-                event_notify_3(EVENT_KLOG, klog_start, klog_len, klog_uspace);
-                klog_uspace = 0;
+        if ((klog_inited) && (klog_uspace > 0)) {
+                if (event_notify_3(EVENT_KLOG, true, klog_start, klog_len,
+                    klog_uspace) == EOK)
+                        klog_uspace = 0;
         }
         

kernel/generic/src/ipc/event.c

@@ -48 +48 @@
 static event_t events[EVENT_END];
 
-/** Initialize kernel events. */
+/** Initialize kernel events.
+ *
+ */
 void event_init(void)
 {
-        unsigned int i;
-        
-        for (i = 0; i < EVENT_END; i++) {
+        for (unsigned int i = 0; i < EVENT_END; i++) {
                 spinlock_initialize(&events[i].lock, "event.lock");
                 events[i].answerbox = NULL;
                 events[i].counter = 0;
                 events[i].imethod = 0;
+                events[i].masked = false;
+                events[i].unmask_cb = NULL;
         }
 }
 
+/** Unsubscribe kernel events associated with an answerbox
+ *
+ * @param answerbox Answerbox to be unsubscribed.
+ *
+ */
+void event_cleanup_answerbox(answerbox_t *answerbox)
+{
+        for (unsigned int i = 0; i < EVENT_END; i++) {
+                spinlock_lock(&events[i].lock);
+                
+                if (events[i].answerbox == answerbox) {
+                        events[i].answerbox = NULL;
+                        events[i].counter = 0;
+                        events[i].imethod = 0;
+                        events[i].masked = false;
+                }
+                
+                spinlock_unlock(&events[i].lock);
+        }
+}
+
+/** Define a callback function for the event unmask event.
+ *
+ * @param evno Event type.
+ * @param cb   Callback function to be called when the event is unmasked.
+ *
+ */
+void event_set_unmask_callback(event_type_t evno, void (*cb)(void))
+{
+        ASSERT(evno < EVENT_END);
+        
+        spinlock_lock(&events[evno].lock);
+        events[evno].unmask_cb = cb;
+        spinlock_unlock(&events[evno].lock);
+}
+
+/** Send kernel notification event
+ *
+ * @param evno Event type.
+ * @param mask Mask further notifications after a successful
+ *             sending.
+ * @param a1   First argument.
+ * @param a2   Second argument.
+ * @param a3   Third argument.
+ * @param a4   Fourth argument.
+ * @param a5   Fifth argument.
+ *
+ * @return EOK if notification was successfully sent.
+ * @return ENOMEM if the notification IPC message failed to allocate.
+ * @return EBUSY if the notifications of the given type are
+ *         currently masked.
+ * @return ENOENT if the notifications of the given type are
+ *         currently not subscribed.
+ *
+ */
+int event_notify(event_type_t evno, bool mask, sysarg_t a1, sysarg_t a2,
+    sysarg_t a3, sysarg_t a4, sysarg_t a5)
+{
+        ASSERT(evno < EVENT_END);
+        
+        spinlock_lock(&events[evno].lock);
+        
+        int ret;
+        
+        if (events[evno].answerbox != NULL) {
+                if (!events[evno].masked) {
+                        call_t *call = ipc_call_alloc(FRAME_ATOMIC);
+                        
+                        if (call) {
+                                call->flags |= IPC_CALL_NOTIF;
+                                call->priv = ++events[evno].counter;
+                                
+                                IPC_SET_IMETHOD(call->data, events[evno].imethod);
+                                IPC_SET_ARG1(call->data, a1);
+                                IPC_SET_ARG2(call->data, a2);
+                                IPC_SET_ARG3(call->data, a3);
+                                IPC_SET_ARG4(call->data, a4);
+                                IPC_SET_ARG5(call->data, a5);
+                                
+                                irq_spinlock_lock(&events[evno].answerbox->irq_lock, true);
+                                list_append(&call->link, &events[evno].answerbox->irq_notifs);
+                                irq_spinlock_unlock(&events[evno].answerbox->irq_lock, true);
+                                
+                                waitq_wakeup(&events[evno].answerbox->wq, WAKEUP_FIRST);
+                                
+                                if (mask)
+                                        events[evno].masked = true;
+                                
+                                ret = EOK;
+                        } else
+                                ret = ENOMEM;
+                } else
+                        ret = EBUSY;
+        } else
+                ret = ENOENT;
+        
+        spinlock_unlock(&events[evno].lock);
+        
+        return ret;
+}
+
+/** Subscribe event notifications
+ *
+ * @param evno      Event type.
+ * @param imethod   IPC interface and method to be used for
+ *                  the notifications.
+ * @param answerbox Answerbox to send the notifications to.
+ *
+ * @return EOK if the subscription was successful.
+ * @return EEXISTS if the notifications of the given type are
+ *         already subscribed.
+ *
+ */
 static int event_subscribe(event_type_t evno, sysarg_t imethod,
     answerbox_t *answerbox)
 {
-        if (evno >= EVENT_END)
-                return ELIMIT;
+        ASSERT(evno < EVENT_END);
         
         spinlock_lock(&events[evno].lock);
@@ -75 +189 @@
                 events[evno].imethod = imethod;
                 events[evno].counter = 0;
+                events[evno].masked = false;
                 res = EOK;
         } else
@@ -84 +199 @@
 }
 
+/** Unmask event notifications
+ *
+ * @param evno Event type to unmask.
+ *
+ */
+static void event_unmask(event_type_t evno)
+{
+        void (*cb)(void);
+        ASSERT(evno < EVENT_END);
+        
+        spinlock_lock(&events[evno].lock);
+        events[evno].masked = false;
+        cb = events[evno].unmask_cb;
+        spinlock_unlock(&events[evno].lock);
+        
+        /*
+         * Check if there is an unmask callback function defined for this event.
+         */
+        if (cb)
+            cb();
+}
+
+/** Event notification syscall wrapper
+ *
+ * @param evno    Event type to subscribe.
+ * @param imethod IPC interface and method to be used for
+ *                the notifications.
+ *
+ * @return EOK on success.
+ * @return ELIMIT on unknown event type.
+ * @return EEXISTS if the notifications of the given type are
+ *         already subscribed.
+ *
+ */
 sysarg_t sys_event_subscribe(sysarg_t evno, sysarg_t imethod)
 {
+        if (evno >= EVENT_END)
+                return ELIMIT;
+        
         return (sysarg_t) event_subscribe((event_type_t) evno, (sysarg_t)
             imethod, &TASK->answerbox);
 }
 
-bool event_is_subscribed(event_type_t evno)
-{
-        bool res;
-        
-        ASSERT(evno < EVENT_END);
-        
-        spinlock_lock(&events[evno].lock);
-        res = events[evno].answerbox != NULL;
-        spinlock_unlock(&events[evno].lock);
-        
-        return res;
-}
-
-
-void event_cleanup_answerbox(answerbox_t *answerbox)
-{
-        unsigned int i;
-        
-        for (i = 0; i < EVENT_END; i++) {
-                spinlock_lock(&events[i].lock);
-                if (events[i].answerbox == answerbox) {
-                        events[i].answerbox = NULL;
-                        events[i].counter = 0;
-                        events[i].imethod = 0;
-                }
-                spinlock_unlock(&events[i].lock);
-        }
-}
-
-void event_notify(event_type_t evno, sysarg_t a1, sysarg_t a2, sysarg_t a3,
-    sysarg_t a4, sysarg_t a5)
-{
-        ASSERT(evno < EVENT_END);
-        
-        spinlock_lock(&events[evno].lock);
-        if (events[evno].answerbox != NULL) {
-                call_t *call = ipc_call_alloc(FRAME_ATOMIC);
-                if (call) {
-                        call->flags |= IPC_CALL_NOTIF;
-                        call->priv = ++events[evno].counter;
-                        IPC_SET_IMETHOD(call->data, events[evno].imethod);
-                        IPC_SET_ARG1(call->data, a1);
-                        IPC_SET_ARG2(call->data, a2);
-                        IPC_SET_ARG3(call->data, a3);
-                        IPC_SET_ARG4(call->data, a4);
-                        IPC_SET_ARG5(call->data, a5);
-                        
-                        irq_spinlock_lock(&events[evno].answerbox->irq_lock, true);
-                        list_append(&call->link, &events[evno].answerbox->irq_notifs);
-                        irq_spinlock_unlock(&events[evno].answerbox->irq_lock, true);
-                        
-                        waitq_wakeup(&events[evno].answerbox->wq, WAKEUP_FIRST);
-                }
-        }
-        spinlock_unlock(&events[evno].lock);
+/** Event notification unmask syscall wrapper
+ *
+ * Note that currently no tests are performed whether the calling
+ * task is entitled to unmask the notifications. However, thanks
+ * to the fact that notification masking is only a performance
+ * optimization, this has probably no security implications.
+ *
+ * @param evno Event type to unmask.
+ *
+ * @return EOK on success.
+ * @return ELIMIT on unknown event type.
+ *
+ */
+sysarg_t sys_event_unmask(sysarg_t evno)
+{
+        if (evno >= EVENT_END)
+                return ELIMIT;
+        
+        event_unmask((event_type_t) evno);
+        return EOK;
 }
 

kernel/generic/src/lib/str.c

@@ -922 +922 @@
 void order_suffix(const uint64_t val, uint64_t *rv, char *suffix)
 {
-        if (val > 10000000000000000000ULL) {
-                *rv = val / 1000000000000000000ULL;
+        if (val > UINT64_C(10000000000000000000)) {
+                *rv = val / UINT64_C(1000000000000000000);
                 *suffix = 'Z';
-        } else if (val > 1000000000000000000ULL) {
-                *rv = val / 1000000000000000ULL;
+        } else if (val > UINT64_C(1000000000000000000)) {
+                *rv = val / UINT64_C(1000000000000000);
                 *suffix = 'E';
-        } else if (val > 1000000000000000ULL) {
-                *rv = val / 1000000000000ULL;
+        } else if (val > UINT64_C(1000000000000000)) {
+                *rv = val / UINT64_C(1000000000000);
                 *suffix = 'T';
-        } else if (val > 1000000000000ULL) {
-                *rv = val / 1000000000ULL;
+        } else if (val > UINT64_C(1000000000000)) {
+                *rv = val / UINT64_C(1000000000);
                 *suffix = 'G';
-        } else if (val > 1000000000ULL) {
-                *rv = val / 1000000ULL;
+        } else if (val > UINT64_C(1000000000)) {
+                *rv = val / UINT64_C(1000000);
                 *suffix = 'M';
-        } else if (val > 1000000ULL) {
-                *rv = val / 1000ULL;
+        } else if (val > UINT64_C(1000000)) {
+                *rv = val / UINT64_C(1000);
                 *suffix = 'k';
         } else {
@@ -946 +946 @@
 }
 
+void bin_order_suffix(const uint64_t val, uint64_t *rv, const char **suffix,
+    bool fixed)
+{
+        if (val > UINT64_C(1152921504606846976)) {
+                *rv = val / UINT64_C(1125899906842624);
+                *suffix = "EiB";
+        } else if (val > UINT64_C(1125899906842624)) {
+                *rv = val / UINT64_C(1099511627776);
+                *suffix = "TiB";
+        } else if (val > UINT64_C(1099511627776)) {
+                *rv = val / UINT64_C(1073741824);
+                *suffix = "GiB";
+        } else if (val > UINT64_C(1073741824)) {
+                *rv = val / UINT64_C(1048576);
+                *suffix = "MiB";
+        } else if (val > UINT64_C(1048576)) {
+                *rv = val / UINT64_C(1024);
+                *suffix = "KiB";
+        } else {
+                *rv = val;
+                if (fixed)
+                        *suffix = "B  ";
+                else
+                        *suffix = "B";
+        }
+}
+
 /** @}
  */

kernel/generic/src/main/main.c

@@ -71 +71 @@
 #include <mm/as.h>
 #include <mm/slab.h>
+#include <mm/reserve.h>
 #include <synch/waitq.h>
 #include <synch/futex.h>
@@ -217 +218 @@
         ddi_init();
         arch_post_mm_init();
+        reserve_init();
         arch_pre_smp_init();
         smp_init();
@@ -223 +225 @@
         slab_enable_cpucache();
         
-        printf("Detected %u CPU(s), %" PRIu64 " MiB free memory\n",
-            config.cpu_count, SIZE2MB(zones_total_size()));
+        uint64_t size;
+        const char *size_suffix;
+        bin_order_suffix(zones_total_size(), &size, &size_suffix, false);
+        printf("Detected %u CPU(s), %" PRIu64 " %s free memory\n",
+            config.cpu_count, size, size_suffix);
         
         cpu_init();

kernel/generic/src/mm/as.c

@@ -80 +80 @@
 #include <arch/interrupt.h>
 
-#ifdef CONFIG_VIRT_IDX_DCACHE
-#include <arch/mm/cache.h>
-#endif /* CONFIG_VIRT_IDX_DCACHE */
-
 /**
  * Each architecture decides what functions will be used to carry out
@@ -447 +443 @@
         else
                 memsetb(&area->backend_data, sizeof(area->backend_data), 0);
+        
+        if (area->backend && area->backend->create) {
+                if (!area->backend->create(area)) {
+                        free(area);
+                        mutex_unlock(&as->lock);
+                        return NULL;
+                }
+        }
         
         btree_create(&area->used_space);
@@ -690 +694 @@
         }
         
+        if (area->backend && area->backend->resize) {
+                if (!area->backend->resize(area, pages)) {
+                        mutex_unlock(&area->lock);
+                        mutex_unlock(&as->lock);
+                        return ENOMEM;
+                }
+        }
+        
         area->pages = pages;
         
@@ -756 +768 @@
                 return ENOENT;
         }
+
+        if (area->backend && area->backend->destroy)
+                area->backend->destroy(area);
         
         uintptr_t base = area->base;

kernel/generic/src/mm/backend_anon.c

@@ -39 +39 @@
 #include <mm/as.h>
 #include <mm/page.h>
+#include <mm/reserve.h>
 #include <genarch/mm/page_pt.h>
 #include <genarch/mm/page_ht.h>
@@ -51 +52 @@
 #include <arch.h>
 
-#ifdef CONFIG_VIRT_IDX_DCACHE
-#include <arch/mm/cache.h>
-#endif
-
-static int anon_page_fault(as_area_t *area, uintptr_t addr, pf_access_t access);
-static void anon_frame_free(as_area_t *area, uintptr_t page, uintptr_t frame);
-static void anon_share(as_area_t *area);
+static bool anon_create(as_area_t *);
+static bool anon_resize(as_area_t *, size_t);
+static void anon_share(as_area_t *);
+static void anon_destroy(as_area_t *);
+
+static int anon_page_fault(as_area_t *, uintptr_t, pf_access_t);
+static void anon_frame_free(as_area_t *, uintptr_t, uintptr_t);
 
 mem_backend_t anon_backend = {
+        .create = anon_create,
+        .resize = anon_resize,
+        .share = anon_share,
+        .destroy = anon_destroy,
+
         .page_fault = anon_page_fault,
         .frame_free = anon_frame_free,
-        .share = anon_share
 };
+
+bool anon_create(as_area_t *area)
+{
+        return reserve_try_alloc(area->pages);
+}
+
+bool anon_resize(as_area_t *area, size_t new_pages)
+{
+        if (new_pages > area->pages)
+                return reserve_try_alloc(new_pages - area->pages);
+        else if (new_pages < area->pages)
+                reserve_free(area->pages - new_pages);
+
+        return true;
+}
+
+/** Share the anonymous address space area.
+ *
+ * Sharing of anonymous area is done by duplicating its entire mapping
+ * to the pagemap. Page faults will primarily search for frames there.
+ *
+ * The address space and address space area must be already locked.
+ *
+ * @param area Address space area to be shared.
+ */
+void anon_share(as_area_t *area)
+{
+        link_t *cur;
+
+        ASSERT(mutex_locked(&area->as->lock));
+        ASSERT(mutex_locked(&area->lock));
+
+        /*
+         * Copy used portions of the area to sh_info's page map.
+         */
+        mutex_lock(&area->sh_info->lock);
+        for (cur = area->used_space.leaf_head.next;
+            cur != &area->used_space.leaf_head; cur = cur->next) {
+                btree_node_t *node;
+                unsigned int i;
+                
+                node = list_get_instance(cur, btree_node_t, leaf_link);
+                for (i = 0; i < node->keys; i++) {
+                        uintptr_t base = node->key[i];
+                        size_t count = (size_t) node->value[i];
+                        unsigned int j;
+                        
+                        for (j = 0; j < count; j++) {
+                                pte_t *pte;
+                        
+                                page_table_lock(area->as, false);
+                                pte = page_mapping_find(area->as,
+                                    base + j * PAGE_SIZE);
+                                ASSERT(pte && PTE_VALID(pte) &&
+                                    PTE_PRESENT(pte));
+                                btree_insert(&area->sh_info->pagemap,
+                                    (base + j * PAGE_SIZE) - area->base,
+                                    (void *) PTE_GET_FRAME(pte), NULL);
+                                page_table_unlock(area->as, false);
+
+                                pfn_t pfn = ADDR2PFN(PTE_GET_FRAME(pte));
+                                frame_reference_add(pfn);
+                        }
+
+                }
+        }
+        mutex_unlock(&area->sh_info->lock);
+}
+
+void anon_destroy(as_area_t *area)
+{
+        reserve_free(area->pages);
+}
+
 
 /** Service a page fault in the anonymous memory address space area.
@@ -115 +194 @@
                         }
                         if (allocate) {
-                                frame = (uintptr_t) frame_alloc(ONE_FRAME, 0);
+                                frame = (uintptr_t) frame_alloc_noreserve(
+                                    ONE_FRAME, 0);
                                 memsetb((void *) PA2KA(frame), FRAME_SIZE, 0);
                                 
@@ -145 +225 @@
                  *   the different causes
                  */
-                frame = (uintptr_t) frame_alloc(ONE_FRAME, 0);
+                frame = (uintptr_t) frame_alloc_noreserve(ONE_FRAME, 0);
                 memsetb((void *) PA2KA(frame), FRAME_SIZE, 0);
         }
@@ -174 +254 @@
         ASSERT(mutex_locked(&area->lock));
 
-        frame_free(frame);
-}
-
-/** Share the anonymous address space area.
- *
- * Sharing of anonymous area is done by duplicating its entire mapping
- * to the pagemap. Page faults will primarily search for frames there.
- *
- * The address space and address space area must be already locked.
- *
- * @param area Address space area to be shared.
- */
-void anon_share(as_area_t *area)
-{
-        link_t *cur;
-
-        ASSERT(mutex_locked(&area->as->lock));
-        ASSERT(mutex_locked(&area->lock));
-
-        /*
-         * Copy used portions of the area to sh_info's page map.
-         */
-        mutex_lock(&area->sh_info->lock);
-        for (cur = area->used_space.leaf_head.next;
-            cur != &area->used_space.leaf_head; cur = cur->next) {
-                btree_node_t *node;
-                unsigned int i;
-                
-                node = list_get_instance(cur, btree_node_t, leaf_link);
-                for (i = 0; i < node->keys; i++) {
-                        uintptr_t base = node->key[i];
-                        size_t count = (size_t) node->value[i];
-                        unsigned int j;
-                        
-                        for (j = 0; j < count; j++) {
-                                pte_t *pte;
-                        
-                                page_table_lock(area->as, false);
-                                pte = page_mapping_find(area->as,
-                                    base + j * PAGE_SIZE);
-                                ASSERT(pte && PTE_VALID(pte) &&
-                                    PTE_PRESENT(pte));
-                                btree_insert(&area->sh_info->pagemap,
-                                    (base + j * PAGE_SIZE) - area->base,
-                                    (void *) PTE_GET_FRAME(pte), NULL);
-                                page_table_unlock(area->as, false);
-
-                                pfn_t pfn = ADDR2PFN(PTE_GET_FRAME(pte));
-                                frame_reference_add(pfn);
-                        }
-
-                }
-        }
-        mutex_unlock(&area->sh_info->lock);
+        frame_free_noreserve(frame);
 }
 

kernel/generic/src/mm/backend_elf.c

@@ -43 +43 @@
 #include <mm/slab.h>
 #include <mm/page.h>
+#include <mm/reserve.h>
 #include <genarch/mm/page_pt.h>
 #include <genarch/mm/page_ht.h>
@@ -51 +52 @@
 #include <arch/barrier.h>
 
-#ifdef CONFIG_VIRT_IDX_DCACHE
-#include <arch/mm/cache.h>
-#endif
-
-static int elf_page_fault(as_area_t *area, uintptr_t addr, pf_access_t access);
-static void elf_frame_free(as_area_t *area, uintptr_t page, uintptr_t frame);
-static void elf_share(as_area_t *area);
+static bool elf_create(as_area_t *);
+static bool elf_resize(as_area_t *, size_t);
+static void elf_share(as_area_t *);
+static void elf_destroy(as_area_t *);
+
+static int elf_page_fault(as_area_t *, uintptr_t, pf_access_t);
+static void elf_frame_free(as_area_t *, uintptr_t, uintptr_t);
 
 mem_backend_t elf_backend = {
+        .create = elf_create,
+        .resize = elf_resize,
+        .share = elf_share,
+        .destroy = elf_destroy,
+
         .page_fault = elf_page_fault,
         .frame_free = elf_frame_free,
-        .share = elf_share
 };
 
-/** Service a page fault in the ELF backend address space area.
- *
- * The address space area and page tables must be already locked.
- *
- * @param area          Pointer to the address space area.
- * @param addr          Faulting virtual address.
- * @param access        Access mode that caused the fault (i.e.
- *                      read/write/exec).
- *
- * @return              AS_PF_FAULT on failure (i.e. page fault) or AS_PF_OK
- *                      on success (i.e. serviced).
- */
-int elf_page_fault(as_area_t *area, uintptr_t addr, pf_access_t access)
-{
-        elf_header_t *elf = area->backend_data.elf;
+static size_t elf_nonanon_pages_get(as_area_t *area)
+{
         elf_segment_header_t *entry = area->backend_data.segment;
-        btree_node_t *leaf;
-        uintptr_t base, frame, page, start_anon;
-        size_t i;
-        bool dirty = false;
-
-        ASSERT(page_table_locked(AS));
-        ASSERT(mutex_locked(&area->lock));
-
-        if (!as_area_check_access(area, access))
-                return AS_PF_FAULT;
+        uintptr_t first = ALIGN_UP(entry->p_vaddr, PAGE_SIZE);
+        uintptr_t last = ALIGN_DOWN(entry->p_vaddr + entry->p_filesz,
+            PAGE_SIZE);
+
+        if (entry->p_flags & PF_W)
+                return 0;
+
+        if (last < first)
+                return 0;
+
+        return last - first;
+}
+
+bool elf_create(as_area_t *area)
+{
+        size_t nonanon_pages = elf_nonanon_pages_get(area);
+
+        if (area->pages <= nonanon_pages)
+                return true;
         
-        if (addr < ALIGN_DOWN(entry->p_vaddr, PAGE_SIZE))
-                return AS_PF_FAULT;
+        return reserve_try_alloc(area->pages - nonanon_pages);
+}
+
+bool elf_resize(as_area_t *area, size_t new_pages)
+{
+        size_t nonanon_pages = elf_nonanon_pages_get(area);
+
+        if (new_pages > area->pages) {
+                /* The area is growing. */
+                if (area->pages >= nonanon_pages)
+                        return reserve_try_alloc(new_pages - area->pages);
+                else if (new_pages > nonanon_pages)
+                        return reserve_try_alloc(new_pages - nonanon_pages);
+        } else if (new_pages < area->pages) {
+                /* The area is shrinking. */
+                if (new_pages >= nonanon_pages)
+                        reserve_free(area->pages - new_pages);
+                else if (area->pages > nonanon_pages)
+                        reserve_free(nonanon_pages - new_pages);
+        }
         
-        if (addr >= entry->p_vaddr + entry->p_memsz)
-                return AS_PF_FAULT;
-        
-        i = (addr - ALIGN_DOWN(entry->p_vaddr, PAGE_SIZE)) >> PAGE_WIDTH;
-        base = (uintptr_t)
-            (((void *) elf) + ALIGN_DOWN(entry->p_offset, PAGE_SIZE));
-
-        /* Virtual address of faulting page*/
-        page = ALIGN_DOWN(addr, PAGE_SIZE);
-
-        /* Virtual address of the end of initialized part of segment */
-        start_anon = entry->p_vaddr + entry->p_filesz;
-
-        if (area->sh_info) {
-                bool found = false;
-
-                /*
-                 * The address space area is shared.
-                 */
-                
-                mutex_lock(&area->sh_info->lock);
-                frame = (uintptr_t) btree_search(&area->sh_info->pagemap,
-                    page - area->base, &leaf);
-                if (!frame) {
-                        unsigned int i;
-
-                        /*
-                         * Workaround for valid NULL address.
-                         */
-
-                        for (i = 0; i < leaf->keys; i++) {
-                                if (leaf->key[i] == page - area->base) {
-                                        found = true;
-                                        break;
-                                }
-                        }
-                }
-                if (frame || found) {
-                        frame_reference_add(ADDR2PFN(frame));
-                        page_mapping_insert(AS, addr, frame,
-                            as_area_get_flags(area));
-                        if (!used_space_insert(area, page, 1))
-                                panic("Cannot insert used space.");
-                        mutex_unlock(&area->sh_info->lock);
-                        return AS_PF_OK;
-                }
-        }
-
-        /*
-         * The area is either not shared or the pagemap does not contain the
-         * mapping.
-         */
-        if (page >= entry->p_vaddr && page + PAGE_SIZE <= start_anon) {
-                /*
-                 * Initialized portion of the segment. The memory is backed
-                 * directly by the content of the ELF image. Pages are
-                 * only copied if the segment is writable so that there
-                 * can be more instantions of the same memory ELF image
-                 * used at a time. Note that this could be later done
-                 * as COW.
-                 */
-                if (entry->p_flags & PF_W) {
-                        frame = (uintptr_t)frame_alloc(ONE_FRAME, 0);
-                        memcpy((void *) PA2KA(frame),
-                            (void *) (base + i * FRAME_SIZE), FRAME_SIZE);
-                        if (entry->p_flags & PF_X) {
-                                smc_coherence_block((void *) PA2KA(frame),
-                                    FRAME_SIZE);
-                        }
-                        dirty = true;
-                } else {
-                        frame = KA2PA(base + i * FRAME_SIZE);
-                }       
-        } else if (page >= start_anon) {
-                /*
-                 * This is the uninitialized portion of the segment.
-                 * It is not physically present in the ELF image.
-                 * To resolve the situation, a frame must be allocated
-                 * and cleared.
-                 */
-                frame = (uintptr_t)frame_alloc(ONE_FRAME, 0);
-                memsetb((void *) PA2KA(frame), FRAME_SIZE, 0);
-                dirty = true;
-        } else {
-                size_t pad_lo, pad_hi;
-                /*
-                 * The mixed case.
-                 *
-                 * The middle part is backed by the ELF image and
-                 * the lower and upper parts are anonymous memory.
-                 * (The segment can be and often is shorter than 1 page).
-                 */
-                if (page < entry->p_vaddr)
-                        pad_lo = entry->p_vaddr - page;
-                else
-                        pad_lo = 0;
-
-                if (start_anon < page + PAGE_SIZE)
-                        pad_hi = page + PAGE_SIZE - start_anon;
-                else
-                        pad_hi = 0;
-
-                frame = (uintptr_t)frame_alloc(ONE_FRAME, 0);
-                memcpy((void *) (PA2KA(frame) + pad_lo),
-                    (void *) (base + i * FRAME_SIZE + pad_lo),
-                    FRAME_SIZE - pad_lo - pad_hi);
-                if (entry->p_flags & PF_X) {
-                        smc_coherence_block((void *) (PA2KA(frame) + pad_lo), 
-                            FRAME_SIZE - pad_lo - pad_hi);
-                }
-                memsetb((void *) PA2KA(frame), pad_lo, 0);
-                memsetb((void *) (PA2KA(frame) + FRAME_SIZE - pad_hi), pad_hi,
-                    0);
-                dirty = true;
-        }
-
-        if (dirty && area->sh_info) {
-                frame_reference_add(ADDR2PFN(frame));
-                btree_insert(&area->sh_info->pagemap, page - area->base,
-                    (void *) frame, leaf);
-        }
-
-        if (area->sh_info)
-                mutex_unlock(&area->sh_info->lock);
-
-        page_mapping_insert(AS, addr, frame, as_area_get_flags(area));
-        if (!used_space_insert(area, page, 1))
-                panic("Cannot insert used space.");
-
-        return AS_PF_OK;
-}
-
-/** Free a frame that is backed by the ELF backend.
- *
- * The address space area and page tables must be already locked.
- *
- * @param area          Pointer to the address space area.
- * @param page          Page that is mapped to frame. Must be aligned to
- *                      PAGE_SIZE.
- * @param frame         Frame to be released.
- *
- */
-void elf_frame_free(as_area_t *area, uintptr_t page, uintptr_t frame)
-{
-        elf_segment_header_t *entry = area->backend_data.segment;
-        uintptr_t start_anon;
-
-        ASSERT(page_table_locked(area->as));
-        ASSERT(mutex_locked(&area->lock));
-
-        ASSERT(page >= ALIGN_DOWN(entry->p_vaddr, PAGE_SIZE));
-        ASSERT(page < entry->p_vaddr + entry->p_memsz);
-
-        start_anon = entry->p_vaddr + entry->p_filesz;
-
-        if (page >= entry->p_vaddr && page + PAGE_SIZE <= start_anon) {
-                if (entry->p_flags & PF_W) {
-                        /*
-                         * Free the frame with the copy of writable segment
-                         * data.
-                         */
-                        frame_free(frame);
-                }
-        } else {
-                /*
-                 * The frame is either anonymous memory or the mixed case (i.e.
-                 * lower part is backed by the ELF image and the upper is
-                 * anonymous). In any case, a frame needs to be freed.
-                 */
-                frame_free(frame);
-        }
+        return true;
 }
 
@@ -356 +205 @@
 }
 
+void elf_destroy(as_area_t *area)
+{
+        size_t nonanon_pages = elf_nonanon_pages_get(area);
+
+        if (area->pages > nonanon_pages)
+                reserve_free(area->pages - nonanon_pages);
+}
+
+/** Service a page fault in the ELF backend address space area.
+ *
+ * The address space area and page tables must be already locked.
+ *
+ * @param area          Pointer to the address space area.
+ * @param addr          Faulting virtual address.
+ * @param access        Access mode that caused the fault (i.e.
+ *                      read/write/exec).
+ *
+ * @return              AS_PF_FAULT on failure (i.e. page fault) or AS_PF_OK
+ *                      on success (i.e. serviced).
+ */
+int elf_page_fault(as_area_t *area, uintptr_t addr, pf_access_t access)
+{
+        elf_header_t *elf = area->backend_data.elf;
+        elf_segment_header_t *entry = area->backend_data.segment;
+        btree_node_t *leaf;
+        uintptr_t base, frame, page, start_anon;
+        size_t i;
+        bool dirty = false;
+
+        ASSERT(page_table_locked(AS));
+        ASSERT(mutex_locked(&area->lock));
+
+        if (!as_area_check_access(area, access))
+                return AS_PF_FAULT;
+        
+        if (addr < ALIGN_DOWN(entry->p_vaddr, PAGE_SIZE))
+                return AS_PF_FAULT;
+        
+        if (addr >= entry->p_vaddr + entry->p_memsz)
+                return AS_PF_FAULT;
+        
+        i = (addr - ALIGN_DOWN(entry->p_vaddr, PAGE_SIZE)) >> PAGE_WIDTH;
+        base = (uintptr_t)
+            (((void *) elf) + ALIGN_DOWN(entry->p_offset, PAGE_SIZE));
+
+        /* Virtual address of faulting page*/
+        page = ALIGN_DOWN(addr, PAGE_SIZE);
+
+        /* Virtual address of the end of initialized part of segment */
+        start_anon = entry->p_vaddr + entry->p_filesz;
+
+        if (area->sh_info) {
+                bool found = false;
+
+                /*
+                 * The address space area is shared.
+                 */
+                
+                mutex_lock(&area->sh_info->lock);
+                frame = (uintptr_t) btree_search(&area->sh_info->pagemap,
+                    page - area->base, &leaf);
+                if (!frame) {
+                        unsigned int i;
+
+                        /*
+                         * Workaround for valid NULL address.
+                         */
+
+                        for (i = 0; i < leaf->keys; i++) {
+                                if (leaf->key[i] == page - area->base) {
+                                        found = true;
+                                        break;
+                                }
+                        }
+                }
+                if (frame || found) {
+                        frame_reference_add(ADDR2PFN(frame));
+                        page_mapping_insert(AS, addr, frame,
+                            as_area_get_flags(area));
+                        if (!used_space_insert(area, page, 1))
+                                panic("Cannot insert used space.");
+                        mutex_unlock(&area->sh_info->lock);
+                        return AS_PF_OK;
+                }
+        }
+
+        /*
+         * The area is either not shared or the pagemap does not contain the
+         * mapping.
+         */
+        if (page >= entry->p_vaddr && page + PAGE_SIZE <= start_anon) {
+                /*
+                 * Initialized portion of the segment. The memory is backed
+                 * directly by the content of the ELF image. Pages are
+                 * only copied if the segment is writable so that there
+                 * can be more instantions of the same memory ELF image
+                 * used at a time. Note that this could be later done
+                 * as COW.
+                 */
+                if (entry->p_flags & PF_W) {
+                        frame = (uintptr_t)frame_alloc_noreserve(ONE_FRAME, 0);
+                        memcpy((void *) PA2KA(frame),
+                            (void *) (base + i * FRAME_SIZE), FRAME_SIZE);
+                        if (entry->p_flags & PF_X) {
+                                smc_coherence_block((void *) PA2KA(frame),
+                                    FRAME_SIZE);
+                        }
+                        dirty = true;
+                } else {
+                        frame = KA2PA(base + i * FRAME_SIZE);
+                }       
+        } else if (page >= start_anon) {
+                /*
+                 * This is the uninitialized portion of the segment.
+                 * It is not physically present in the ELF image.
+                 * To resolve the situation, a frame must be allocated
+                 * and cleared.
+                 */
+                frame = (uintptr_t) frame_alloc_noreserve(ONE_FRAME, 0);
+                memsetb((void *) PA2KA(frame), FRAME_SIZE, 0);
+                dirty = true;
+        } else {
+                size_t pad_lo, pad_hi;
+                /*
+                 * The mixed case.
+                 *
+                 * The middle part is backed by the ELF image and
+                 * the lower and upper parts are anonymous memory.
+                 * (The segment can be and often is shorter than 1 page).
+                 */
+                if (page < entry->p_vaddr)
+                        pad_lo = entry->p_vaddr - page;
+                else
+                        pad_lo = 0;
+
+                if (start_anon < page + PAGE_SIZE)
+                        pad_hi = page + PAGE_SIZE - start_anon;
+                else
+                        pad_hi = 0;
+
+                frame = (uintptr_t) frame_alloc_noreserve(ONE_FRAME, 0);
+                memcpy((void *) (PA2KA(frame) + pad_lo),
+                    (void *) (base + i * FRAME_SIZE + pad_lo),
+                    FRAME_SIZE - pad_lo - pad_hi);
+                if (entry->p_flags & PF_X) {
+                        smc_coherence_block((void *) (PA2KA(frame) + pad_lo), 
+                            FRAME_SIZE - pad_lo - pad_hi);
+                }
+                memsetb((void *) PA2KA(frame), pad_lo, 0);
+                memsetb((void *) (PA2KA(frame) + FRAME_SIZE - pad_hi), pad_hi,
+                    0);
+                dirty = true;
+        }
+
+        if (dirty && area->sh_info) {
+                frame_reference_add(ADDR2PFN(frame));
+                btree_insert(&area->sh_info->pagemap, page - area->base,
+                    (void *) frame, leaf);
+        }
+
+        if (area->sh_info)
+                mutex_unlock(&area->sh_info->lock);
+
+        page_mapping_insert(AS, addr, frame, as_area_get_flags(area));
+        if (!used_space_insert(area, page, 1))
+                panic("Cannot insert used space.");
+
+        return AS_PF_OK;
+}
+
+/** Free a frame that is backed by the ELF backend.
+ *
+ * The address space area and page tables must be already locked.
+ *
+ * @param area          Pointer to the address space area.
+ * @param page          Page that is mapped to frame. Must be aligned to
+ *                      PAGE_SIZE.
+ * @param frame         Frame to be released.
+ *
+ */
+void elf_frame_free(as_area_t *area, uintptr_t page, uintptr_t frame)
+{
+        elf_segment_header_t *entry = area->backend_data.segment;
+        uintptr_t start_anon;
+
+        ASSERT(page_table_locked(area->as));
+        ASSERT(mutex_locked(&area->lock));
+
+        ASSERT(page >= ALIGN_DOWN(entry->p_vaddr, PAGE_SIZE));
+        ASSERT(page < entry->p_vaddr + entry->p_memsz);
+
+        start_anon = entry->p_vaddr + entry->p_filesz;
+
+        if (page >= entry->p_vaddr && page + PAGE_SIZE <= start_anon) {
+                if (entry->p_flags & PF_W) {
+                        /*
+                         * Free the frame with the copy of writable segment
+                         * data.
+                         */
+                        frame_free_noreserve(frame);
+                }
+        } else {
+                /*
+                 * The frame is either anonymous memory or the mixed case (i.e.
+                 * lower part is backed by the ELF image and the upper is
+                 * anonymous). In any case, a frame needs to be freed.
+                 */
+                frame_free_noreserve(frame);
+        }
+}
+
 /** @}
  */

kernel/generic/src/mm/backend_phys.c

@@ -48 +48 @@
 #include <align.h>
 
-static int phys_page_fault(as_area_t *area, uintptr_t addr, pf_access_t access);
-static void phys_share(as_area_t *area);
+static bool phys_create(as_area_t *);
+static void phys_share(as_area_t *);
+static void phys_destroy(as_area_t *);
+
+static int phys_page_fault(as_area_t *, uintptr_t, pf_access_t);
 
 mem_backend_t phys_backend = {
+        .create = phys_create,
+        .resize = NULL,
+        .share = phys_share,
+        .destroy = phys_destroy,
+
         .page_fault = phys_page_fault,
         .frame_free = NULL,
-        .share = phys_share
 };
+
+bool phys_create(as_area_t *area)
+{
+        return true;
+}
+
+/** Share address space area backed by physical memory.
+ *
+ * Do actually nothing as sharing of address space areas
+ * that are backed up by physical memory is very easy.
+ * Note that the function must be defined so that
+ * as_area_share() will succeed.
+ */
+void phys_share(as_area_t *area)
+{
+        ASSERT(mutex_locked(&area->as->lock));
+        ASSERT(mutex_locked(&area->lock));
+}
+
+
+void phys_destroy(as_area_t *area)
+{
+        /* Nothing to do. */
+}
 
 /** Service a page fault in the address space area backed by physical memory.
@@ -88 +119 @@
 }
 
-/** Share address space area backed by physical memory.
- *
- * Do actually nothing as sharing of address space areas
- * that are backed up by physical memory is very easy.
- * Note that the function must be defined so that
- * as_area_share() will succeed.
- */
-void phys_share(as_area_t *area)
-{
-        ASSERT(mutex_locked(&area->as->lock));
-        ASSERT(mutex_locked(&area->lock));
-}
-
 /** @}
  */

kernel/generic/src/mm/frame.c

@@ -45 +45 @@
 #include <typedefs.h>
 #include <mm/frame.h>
+#include <mm/reserve.h>
 #include <mm/as.h>
 #include <panic.h>
@@ -59 +60 @@
 #include <macros.h>
 #include <config.h>
+#include <str.h>
 
 zones_t zones;
@@ -180 +182 @@
  *
  */
-#ifdef CONFIG_DEBUG
-NO_TRACE static size_t total_frames_free(void)
+NO_TRACE static size_t frame_total_free_get_internal(void)
 {
         size_t total = 0;
         size_t i;
+
         for (i = 0; i < zones.count; i++)
                 total += zones.info[i].free_count;
@@ -190 +192 @@
         return total;
 }
-#endif /* CONFIG_DEBUG */
+
+NO_TRACE size_t frame_total_free_get(void)
+{
+        size_t total;
+
+        irq_spinlock_lock(&zones.lock, true);
+        total = frame_total_free_get_internal();
+        irq_spinlock_unlock(&zones.lock, true);
+
+        return total;
+}
+
 
 /** Find a zone with a given frames.
@@ -472 +485 @@
  * @param frame_idx Frame index relative to zone.
  *
- */
-NO_TRACE static void zone_frame_free(zone_t *zone, size_t frame_idx)
+ * @return          Number of freed frames.
+ *
+ */
+NO_TRACE static size_t zone_frame_free(zone_t *zone, size_t frame_idx)
 {
         ASSERT(zone_flags_available(zone->flags));
         
         frame_t *frame = &zone->frames[frame_idx];
-        
-        /* Remember frame order */
-        uint8_t order = frame->buddy_order;
+        size_t size = 0;
         
         ASSERT(frame->refcount);
         
         if (!--frame->refcount) {
-                buddy_system_free(zone->buddy_system, &frame->buddy_link);
-                
+                size = 1 << frame->buddy_order;
+                buddy_system_free(zone->buddy_system, &frame->buddy_link);              
                 /* Update zone information. */
-                zone->free_count += (1 << order);
-                zone->busy_count -= (1 << order);
-        }
+                zone->free_count += size;
+                zone->busy_count -= size;
+        }
+        
+        return size;
 }
 
@@ -516 +531 @@
         ASSERT(link);
         zone->free_count--;
+        reserve_force_alloc(1);
 }
 
@@ -645 +661 @@
         for (i = 0; i < cframes; i++) {
                 zones.info[znum].busy_count++;
-                zone_frame_free(&zones.info[znum],
+                (void) zone_frame_free(&zones.info[znum],
                     pfn - zones.info[znum].base + i);
         }
@@ -683 +699 @@
         /* Free unneeded frames */
         for (i = count; i < (size_t) (1 << order); i++)
-                zone_frame_free(&zones.info[znum], i + frame_idx);
+                (void) zone_frame_free(&zones.info[znum], i + frame_idx);
 }
 
@@ -695 +711 @@
  * not to be 2^order size. Once the allocator is running it is no longer
  * possible, merged configuration data occupies more space :-/
- *
- * The function uses
  *
  */
@@ -999 +1013 @@
         size_t hint = pzone ? (*pzone) : 0;
         
+        /*
+         * If not told otherwise, we must first reserve the memory.
+         */
+        if (!(flags & FRAME_NO_RESERVE)) 
+                reserve_force_alloc(size);
+
 loop:
         irq_spinlock_lock(&zones.lock, true);
@@ -1033 +1053 @@
                 if (flags & FRAME_ATOMIC) {
                         irq_spinlock_unlock(&zones.lock, true);
+                        if (!(flags & FRAME_NO_RESERVE))
+                                reserve_free(size);
                         return NULL;
                 }
                 
 #ifdef CONFIG_DEBUG
-                size_t avail = total_frames_free();
+                size_t avail = frame_total_free_get_internal();
 #endif
                 
@@ -1088 +1110 @@
 }
 
+void *frame_alloc(uint8_t order, frame_flags_t flags)
+{
+        return frame_alloc_generic(order, flags, NULL);
+}
+
+void *frame_alloc_noreserve(uint8_t order, frame_flags_t flags)
+{
+        return frame_alloc_generic(order, flags | FRAME_NO_RESERVE, NULL);
+}
+
 /** Free a frame.
  *
@@ -1095 +1127 @@
  *
  * @param frame Physical Address of of the frame to be freed.
- *
- */
-void frame_free(uintptr_t frame)
-{
+ * @param flags Flags to control memory reservation.
+ *
+ */
+void frame_free_generic(uintptr_t frame, frame_flags_t flags)
+{
+        size_t size;
+        
         irq_spinlock_lock(&zones.lock, true);
         
@@ -1106 +1141 @@
         pfn_t pfn = ADDR2PFN(frame);
         size_t znum = find_zone(pfn, 1, 0);
+
         
         ASSERT(znum != (size_t) -1);
         
-        zone_frame_free(&zones.info[znum], pfn - zones.info[znum].base);
+        size = zone_frame_free(&zones.info[znum], pfn - zones.info[znum].base);
         
         irq_spinlock_unlock(&zones.lock, true);
@@ -1118 +1154 @@
         mutex_lock(&mem_avail_mtx);
         if (mem_avail_req > 0)
-                mem_avail_req--;
+                mem_avail_req -= min(mem_avail_req, size);
         
         if (mem_avail_req == 0) {
@@ -1125 +1161 @@
         }
         mutex_unlock(&mem_avail_mtx);
+        
+        if (!(flags & FRAME_NO_RESERVE))
+                reserve_free(size);
+}
+
+void frame_free(uintptr_t frame)
+{
+        frame_free_generic(frame, 0);
+}
+
+void frame_free_noreserve(uintptr_t frame)
+{
+        frame_free_generic(frame, FRAME_NO_RESERVE);
 }
 
@@ -1355 +1404 @@
         bool available = zone_flags_available(flags);
         
+        uint64_t size;
+        const char *size_suffix;
+        bin_order_suffix(FRAMES2SIZE(count), &size, &size_suffix, false);
+        
         printf("Zone number:       %zu\n", znum);
         printf("Zone base address: %p\n", (void *) base);
-        printf("Zone size:         %zu frames (%zu KiB)\n", count,
-            SIZE2KB(FRAMES2SIZE(count)));
+        printf("Zone size:         %zu frames (%" PRIu64 " %s)\n", count,
+            size, size_suffix);
         printf("Zone flags:        %c%c%c\n",
             available ? 'A' : ' ',
@@ -1365 +1418 @@
         
         if (available) {
-                printf("Allocated space:   %zu frames (%zu KiB)\n",
-                    busy_count, SIZE2KB(FRAMES2SIZE(busy_count)));
-                printf("Available space:   %zu frames (%zu KiB)\n",
-                    free_count, SIZE2KB(FRAMES2SIZE(free_count)));
+                bin_order_suffix(FRAMES2SIZE(busy_count), &size, &size_suffix,
+                    false);
+                printf("Allocated space:   %zu frames (%" PRIu64 " %s)\n",
+                    busy_count, size, size_suffix);
+                bin_order_suffix(FRAMES2SIZE(free_count), &size, &size_suffix,
+                    false);
+                printf("Available space:   %zu frames (%" PRIu64 " %s)\n",
+                    free_count, size, size_suffix);
         }
 }

kernel/generic/src/proc/scheduler.c

@@ -354 +354 @@
         
         /*
-         * Through the 'THE' structure, we keep track of THREAD, TASK, CPU, VM
+         * Through the 'THE' structure, we keep track of THREAD, TASK, CPU, AS
          * and preemption counter. At this point THE could be coming either
          * from THREAD's or CPU's stack.

kernel/generic/src/proc/task.c

@@ -534 +534 @@
         */
         if (notify) {
-                if (event_is_subscribed(EVENT_FAULT)) {
-                        /* Notify the subscriber that a fault occurred. */
-                        event_notify_3(EVENT_FAULT, LOWER32(TASK->taskid),
-                            UPPER32(TASK->taskid), (sysarg_t) THREAD);
-                
+                /* Notify the subscriber that a fault occurred. */
+                if (event_notify_3(EVENT_FAULT, false, LOWER32(TASK->taskid),
+                    UPPER32(TASK->taskid), (sysarg_t) THREAD) == EOK) {
 #ifdef CONFIG_UDEBUG
                         /* Wait for a debugging session. */

kernel/generic/src/syscall/syscall.c

@@ -166 +166 @@
         /* Event notification syscalls. */
         (syshandler_t) sys_event_subscribe,
+        (syshandler_t) sys_event_unmask,
         
         /* Capabilities related syscalls. */