Changeset 1affcdf3 in mainline for kernel/generic/src

Timestamp:

2011-06-10T19:33:41Z (14 years ago)

Author:

Maurizio Lombardi <m.lombardi85@…>

Branches:

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

Children:

1878386

Parents:

13ecdac9 (diff), 79a141a (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

Location:

kernel/generic/src

Files:

• adt/list.c (modified) (1 diff)
• console/cmd.c (modified) (1 diff)
• console/console.c (modified) (8 diffs)
• ddi/ddi.c (modified) (1 diff)
• debug/panic.c (modified) (1 diff)
• interrupt/interrupt.c (modified) (2 diffs)
• ipc/event.c (modified) (3 diffs)
• ipc/ipc.c (modified) (1 diff)
• ipc/irq.c (modified) (4 diffs)
• ipc/kbox.c (modified) (2 diffs)
• ipc/sysipc.c (modified) (4 diffs)
• lib/elf.c (modified) (1 diff)
• lib/memfnc.c (modified) (2 diffs)
• main/main.c (modified) (6 diffs)
• main/uinit.c (modified) (6 diffs)
• main/version.c (modified) (1 diff)
• mm/as.c (modified) (53 diffs)
• mm/backend_anon.c (modified) (2 diffs)
• mm/backend_elf.c (modified) (2 diffs)
• mm/frame.c (modified) (4 diffs)
• mm/page.c (modified) (6 diffs)
• mm/reserve.c (modified) (1 diff)
• printf/vprintf.c (modified) (2 diffs)
• proc/program.c (modified) (2 diffs)
• proc/scheduler.c (modified) (1 diff)
• proc/task.c (modified) (7 diffs)
• proc/the.c (modified) (2 diffs)
• proc/thread.c (modified) (9 diffs)
• security/cap.c (modified) (2 diffs)
• synch/futex.c (modified) (2 diffs)
• synch/spinlock.c (modified) (1 diff)
• syscall/syscall.c (modified) (6 diffs)

kernel/generic/src/adt/list.c

@@ -52 +52 @@
  *
  */
-bool list_member(const link_t *link, const link_t *head)
+int list_member(const link_t *link, const link_t *head)
 {
         bool found = false;

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>
 
-#define KLOG_PAGES    4
+#define KLOG_PAGES    8
 #define KLOG_LENGTH   (KLOG_PAGES * PAGE_SIZE / sizeof(wchar_t))
-#define KLOG_LATENCY  8
 
 /** Kernel log cyclic buffer */
@@ -61 +60 @@
 
 /** Kernel log initialized */
-static bool klog_inited = false;
+static atomic_t klog_inited = {false};
 
 /** First kernel log characters */
@@ -76 +75 @@
 
 /** Kernel log spinlock */
-SPINLOCK_STATIC_INITIALIZE_NAME(klog_lock, "*klog_lock");
+SPINLOCK_STATIC_INITIALIZE_NAME(klog_lock, "klog_lock");
 
 /** Physical memory area used for klog buffer */
@@ -166 +165 @@
         sysinfo_set_item_val("klog.pages", NULL, KLOG_PAGES);
         
-        spinlock_lock(&klog_lock);
-        klog_inited = true;
-        spinlock_unlock(&klog_lock);
+        event_set_unmask_callback(EVENT_KLOG, klog_update);
+        atomic_set(&klog_inited, true);
 }
 
@@ -263 +261 @@
 void klog_update(void)
 {
+        if (!atomic_get(&klog_inited))
+                return;
+        
         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_uspace > 0) {
+                if (event_notify_3(EVENT_KLOG, true, klog_start, klog_len,
+                    klog_uspace) == EOK)
+                        klog_uspace = 0;
         }
         
@@ -275 +277 @@
 void putchar(const wchar_t ch)
 {
+        bool ordy = ((stdout) && (stdout->op->write));
+        
         spinlock_lock(&klog_lock);
         
-        if ((klog_stored > 0) && (stdout) && (stdout->op->write)) {
-                /* Print charaters stored in kernel log */
-                size_t i;
-                for (i = klog_len - klog_stored; i < klog_len; i++)
-                        stdout->op->write(stdout, klog[(klog_start + i) % KLOG_LENGTH], silent);
-                klog_stored = 0;
+        /* Print charaters stored in kernel log */
+        if (ordy) {
+                while (klog_stored > 0) {
+                        wchar_t tmp = klog[(klog_start + klog_len - klog_stored) % KLOG_LENGTH];
+                        klog_stored--;
+                        
+                        /*
+                         * We need to give up the spinlock for
+                         * the physical operation of writting out
+                         * the character.
+                         */
+                        spinlock_unlock(&klog_lock);
+                        stdout->op->write(stdout, tmp, silent);
+                        spinlock_lock(&klog_lock);
+                }
         }
         
@@ -292 +305 @@
                 klog_start = (klog_start + 1) % KLOG_LENGTH;
         
-        if ((stdout) && (stdout->op->write))
+        if (!ordy) {
+                if (klog_stored < klog_len)
+                        klog_stored++;
+        }
+        
+        /* The character is stored for uspace */
+        if (klog_uspace < klog_len)
+                klog_uspace++;
+        
+        spinlock_unlock(&klog_lock);
+        
+        if (ordy) {
+                /*
+                 * Output the character. In this case
+                 * it should be no longer buffered.
+                 */
                 stdout->op->write(stdout, ch, silent);
-        else {
+        } else {
                 /*
                  * No standard output routine defined yet.
@@ -304 +332 @@
                  * Note that the early_putc() function might be
                  * a no-op on certain hardware configurations.
-                 *
                  */
                 early_putchar(ch);
-                
-                if (klog_stored < klog_len)
-                        klog_stored++;
-        }
-        
-        /* The character is stored for uspace */
-        if (klog_uspace < klog_len)
-                klog_uspace++;
-        
-        /* Check notify uspace to update */
-        bool update;
-        if ((klog_uspace > KLOG_LATENCY) || (ch == '\n'))
-                update = true;
-        else
-                update = false;
-        
-        spinlock_unlock(&klog_lock);
-        
-        if (update)
+        }
+        
+        /* Force notification on newline */
+        if (ch == '\n')
                 klog_update();
 }

kernel/generic/src/ddi/ddi.c

@@ -224 +224 @@
         task_t *task = task_find_by_id(id);
         
-        if ((!task) || (!context_check(CONTEXT, task->context))) {
+        if ((!task) || (!container_check(CONTAINER, task->container))) {
                 /*
                  * There is no task with the specified ID

kernel/generic/src/debug/panic.c

@@ -95 +95 @@
         printf("\n");
         
+        printf("THE=%p: ", THE);
+        if (THE != NULL) {
+                printf("pe=%" PRIun " thr=%p task=%p cpu=%p as=%p"
+                    " magic=%#" PRIx32 "\n", THE->preemption_disabled,
+                    THE->thread, THE->task, THE->cpu, THE->as, THE->magic);
+        } else
+                printf("invalid\n");
+        
         if (istate) {
                 istate_decode(istate);

kernel/generic/src/interrupt/interrupt.c

@@ -177 +177 @@
             (void *) istate_get_pc(istate));
         
+        istate_decode(istate);
         stack_trace_istate(istate);
         
@@ -205 +206 @@
          * stack.
          */
-        return (istate_t *) ((uint8_t *) thread->kstack + THREAD_STACK_SIZE -
-            sizeof(istate_t));
+        return (istate_t *) ((uint8_t *)
+            thread->kstack + STACK_SIZE - sizeof(istate_t));
 }
 

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_callback = 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 callback Callback function to be called when
+ *                 the event is unmasked.
+ *
+ */
+void event_set_unmask_callback(event_type_t evno, event_callback_t callback)
+{
+        ASSERT(evno < EVENT_END);
+        
+        spinlock_lock(&events[evno].lock);
+        events[evno].unmask_callback = callback;
+        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 +190 @@
                 events[evno].imethod = imethod;
                 events[evno].counter = 0;
+                events[evno].masked = false;
                 res = EOK;
         } else
@@ -84 +200 @@
 }
 
+/** Unmask event notifications
+ *
+ * @param evno Event type to unmask.
+ *
+ */
+static void event_unmask(event_type_t evno)
+{
+        ASSERT(evno < EVENT_END);
+        
+        spinlock_lock(&events[evno].lock);
+        events[evno].masked = false;
+        event_callback_t callback = events[evno].unmask_callback;
+        spinlock_unlock(&events[evno].lock);
+        
+        /*
+         * Check if there is an unmask callback
+         * function defined for this event.
+         */
+        if (callback != NULL)
+                callback();
+}
+
+/** 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/ipc/ipc.c

@@ -44 +44 @@
 #include <synch/synch.h>
 #include <ipc/ipc.h>
+#include <ipc/ipc_methods.h>
 #include <ipc/kbox.h>
 #include <ipc/event.h>

kernel/generic/src/ipc/irq.c

@@ -174 +174 @@
         irq->notif_cfg.code = code;
         irq->notif_cfg.counter = 0;
+        irq->driver_as = AS;
         
         /*
@@ -364 +365 @@
                 return IRQ_DECLINE;
         
+#define CMD_MEM_READ(target) \
+do { \
+        void *va = code->cmds[i].addr; \
+        if (AS != irq->driver_as) \
+                as_switch(AS, irq->driver_as); \
+        memcpy_from_uspace(&target, va, (sizeof(target))); \
+        if (dstarg) \
+                scratch[dstarg] = target; \
+} while(0)
+
+#define CMD_MEM_WRITE(val) \
+do { \
+        void *va = code->cmds[i].addr; \
+        if (AS != irq->driver_as) \
+                as_switch(AS, irq->driver_as); \
+        memcpy_to_uspace(va, &val, sizeof(val)); \
+} while (0)
+
+        as_t *current_as = AS;
         size_t i;
         for (i = 0; i < code->cmdcount; i++) {
@@ -422 +442 @@
                         }
                         break;
+                case CMD_MEM_READ_8: {
+                        uint8_t val;
+                        CMD_MEM_READ(val);
+                        break;
+                        }
+                case CMD_MEM_READ_16: {
+                        uint16_t val;
+                        CMD_MEM_READ(val);
+                        break;
+                        }
+                case CMD_MEM_READ_32: {
+                        uint32_t val;
+                        CMD_MEM_READ(val);
+                        break;
+                        }
+                case CMD_MEM_WRITE_8: {
+                        uint8_t val = code->cmds[i].value;
+                        CMD_MEM_WRITE(val);
+                        break;
+                        }
+                case CMD_MEM_WRITE_16: {
+                        uint16_t val = code->cmds[i].value;
+                        CMD_MEM_WRITE(val);
+                        break;
+                        }
+                case CMD_MEM_WRITE_32: {
+                        uint32_t val = code->cmds[i].value;
+                        CMD_MEM_WRITE(val);
+                        break;
+                        }
+                case CMD_MEM_WRITE_A_8:
+                        if (srcarg) {
+                                uint8_t val = scratch[srcarg];
+                                CMD_MEM_WRITE(val);
+                        }
+                        break;
+                case CMD_MEM_WRITE_A_16:
+                        if (srcarg) {
+                                uint16_t val = scratch[srcarg];
+                                CMD_MEM_WRITE(val);
+                        }
+                        break;
+                case CMD_MEM_WRITE_A_32:
+                        if (srcarg) {
+                                uint32_t val = scratch[srcarg];
+                                CMD_MEM_WRITE(val);
+                        }
+                        break;
                 case CMD_BTEST:
                         if ((srcarg) && (dstarg)) {
@@ -435 +503 @@
                         break;
                 case CMD_ACCEPT:
+                        if (AS != current_as)
+                                as_switch(AS, current_as);
                         return IRQ_ACCEPT;
                 case CMD_DECLINE:
                 default:
+                        if (AS != current_as)
+                                as_switch(AS, current_as);
                         return IRQ_DECLINE;
                 }
         }
+        if (AS != current_as)
+                as_switch(AS, current_as);
         
         return IRQ_DECLINE;

kernel/generic/src/ipc/kbox.c

@@ -37 +37 @@
 #include <synch/mutex.h>
 #include <ipc/ipc.h>
+#include <ipc/ipc_methods.h>
 #include <ipc/ipcrsc.h>
 #include <arch.h>
@@ -169 +170 @@
                 switch (IPC_GET_IMETHOD(call->data)) {
                 
-                case IPC_M_DEBUG_ALL:
+                case IPC_M_DEBUG:
                         /* Handle debug call. */
                         udebug_call_receive(call);

kernel/generic/src/ipc/sysipc.c

@@ -40 +40 @@
 #include <debug.h>
 #include <ipc/ipc.h>
+#include <ipc/ipc_methods.h>
 #include <ipc/sysipc.h>
 #include <ipc/irq.h>
@@ -460 +461 @@
         }
 #ifdef CONFIG_UDEBUG
-        case IPC_M_DEBUG_ALL:
+        case IPC_M_DEBUG:
                 return udebug_request_preprocess(call, phone);
 #endif
@@ -495 +496 @@
                 /*
                  * This must be an affirmative answer to IPC_M_DATA_READ
-                 * or IPC_M_DEBUG_ALL/UDEBUG_M_MEM_READ...
+                 * or IPC_M_DEBUG/UDEBUG_M_MEM_READ...
                  *
                  */
@@ -531 +532 @@
         
         switch (IPC_GET_IMETHOD(call->data)) {
-        case IPC_M_DEBUG_ALL:
+        case IPC_M_DEBUG:
                 return -1;
         default:

kernel/generic/src/lib/elf.c

@@ -114 +114 @@
         }
         
-        /* Inspect all section headers and proccess them. */
+        /* Inspect all section headers and process them. */
         for (i = 0; i < header->e_shnum; i++) {
                 elf_section_header_t *sechdr =

kernel/generic/src/lib/memfnc.c

@@ -56 +56 @@
 void *memset(void *dst, int val, size_t cnt)
 {
-        size_t i;
-        uint8_t *ptr = (uint8_t *) dst;
+        uint8_t *dp = (uint8_t *) dst;
         
-        for (i = 0; i < cnt; i++)
-                ptr[i] = val;
+        while (cnt-- != 0)
+                *dp++ = val;
         
         return dst;
@@ -83 +82 @@
         
         while (cnt-- != 0)
-                        *dp++ = *sp++;
+                *dp++ = *sp++;
         
         return dst;

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>
@@ -117 +118 @@
 #endif
 
-#define CONFIG_STACK_SIZE  ((1 << STACK_FRAMES) * STACK_SIZE)
-
 /** Main kernel routine for bootstrap CPU.
  *
@@ -138 +137 @@
         config.kernel_size = ALIGN_UP(hardcoded_ktext_size +
             hardcoded_kdata_size, PAGE_SIZE);
-        config.stack_size = CONFIG_STACK_SIZE;
+        config.stack_size = STACK_SIZE;
         
         /* Initialy the stack is placed just after the kernel */
@@ -164 +163 @@
         
         context_save(&ctx);
-        context_set(&ctx, FADDR(main_bsp_separated_stack), config.stack_base,
-            THREAD_STACK_SIZE);
+        context_set(&ctx, FADDR(main_bsp_separated_stack),
+            config.stack_base, STACK_SIZE);
         context_restore(&ctx);
         /* not reached */
@@ -217 +216 @@
         ddi_init();
         arch_post_mm_init();
+        reserve_init();
         arch_pre_smp_init();
         smp_init();
@@ -321 +321 @@
         context_save(&CPU->saved_context);
         context_set(&CPU->saved_context, FADDR(main_ap_separated_stack),
-            (uintptr_t) CPU->stack, CPU_STACK_SIZE);
+            (uintptr_t) CPU->stack, STACK_SIZE);
         context_restore(&CPU->saved_context);
         /* not reached */

kernel/generic/src/main/uinit.c

@@ -33 +33 @@
 /**
  * @file
- * @brief       Userspace bootstrap thread.
+ * @brief Userspace bootstrap thread.
  *
  * This file contains uinit kernel thread wich is used to start every
@@ -40 +40 @@
  * @see SYS_THREAD_CREATE
  */
- 
+
 #include <main/uinit.h>
 #include <typedefs.h>
@@ -48 +48 @@
 #include <arch.h>
 #include <udebug/udebug.h>
-
 
 /** Thread used to bring up userspace thread.
@@ -58 +57 @@
 {
         uspace_arg_t uarg;
-
+        
         /*
          * So far, we don't have a use for joining userspace threads so we
@@ -68 +67 @@
          */
         thread_detach(THREAD);
-
+        
 #ifdef CONFIG_UDEBUG
         udebug_stoppable_end();
@@ -78 +77 @@
         uarg.uspace_thread_function = NULL;
         uarg.uspace_thread_arg = NULL;
-
+        
         free((uspace_arg_t *) arg);
         

kernel/generic/src/main/version.c

@@ -38 +38 @@
 
 static const char *project = "SPARTAN kernel";
-static const char *copyright = "Copyright (c) 2001-2010 HelenOS project";
+static const char *copyright = "Copyright (c) 2001-2011 HelenOS project";
 static const char *release = STRING(RELEASE);
 static const char *name = STRING(NAME);

kernel/generic/src/mm/as.c

@@ -302 +302 @@
          * We don't want any area to have conflicts with NULL page.
          */
-        if (overlaps(addr, count << PAGE_WIDTH, (uintptr_t) NULL, PAGE_SIZE))
+        if (overlaps(addr, P2SZ(count), (uintptr_t) NULL, PAGE_SIZE))
                 return false;
         
@@ -329 +329 @@
                         mutex_lock(&area->lock);
                         
-                        if (overlaps(addr, count << PAGE_WIDTH,
-                            area->base, area->pages << PAGE_WIDTH)) {
+                        if (overlaps(addr, P2SZ(count), area->base,
+                            P2SZ(area->pages))) {
                                 mutex_unlock(&area->lock);
                                 return false;
@@ -346 +346 @@
                         mutex_lock(&area->lock);
                         
-                        if (overlaps(addr, count << PAGE_WIDTH,
-                            area->base, area->pages << PAGE_WIDTH)) {
+                        if (overlaps(addr, P2SZ(count), area->base,
+                            P2SZ(area->pages))) {
                                 mutex_unlock(&area->lock);
                                 return false;
@@ -366 +366 @@
                 mutex_lock(&area->lock);
                 
-                if (overlaps(addr, count << PAGE_WIDTH,
-                    area->base, area->pages << PAGE_WIDTH)) {
+                if (overlaps(addr, P2SZ(count), area->base,
+                    P2SZ(area->pages))) {
                         mutex_unlock(&area->lock);
                         return false;
@@ -380 +380 @@
          */
         if (!KERNEL_ADDRESS_SPACE_SHADOWED) {
-                return !overlaps(addr, count << PAGE_WIDTH,
-                    KERNEL_ADDRESS_SPACE_START,
+                return !overlaps(addr, P2SZ(count), KERNEL_ADDRESS_SPACE_START,
                     KERNEL_ADDRESS_SPACE_END - KERNEL_ADDRESS_SPACE_START);
         }
@@ -474 +473 @@
         
         btree_node_t *leaf;
-        as_area_t *area = (as_area_t *) btree_search(&as->as_area_btree, va, &leaf);
+        as_area_t *area = (as_area_t *) btree_search(&as->as_area_btree, va,
+            &leaf);
         if (area) {
                 /* va is the base address of an address space area */
@@ -482 +482 @@
         
         /*
-         * Search the leaf node and the righmost record of its left neighbour
+         * Search the leaf node and the rightmost record of its left neighbour
          * to find out whether this is a miss or va belongs to an address
          * space area found there.
@@ -494 +494 @@
                 
                 mutex_lock(&area->lock);
-                
+
                 if ((area->base <= va) &&
-                    (va < area->base + (area->pages << PAGE_WIDTH)))
+                    (va <= area->base + (P2SZ(area->pages) - 1)))
                         return area;
                 
@@ -506 +506 @@
          * Because of its position in the B+tree, it must have base < va.
          */
-        btree_node_t *lnode = btree_leaf_node_left_neighbour(&as->as_area_btree, leaf);
+        btree_node_t *lnode = btree_leaf_node_left_neighbour(&as->as_area_btree,
+            leaf);
         if (lnode) {
                 area = (as_area_t *) lnode->value[lnode->keys - 1];
@@ -512 +513 @@
                 mutex_lock(&area->lock);
                 
-                if (va < area->base + (area->pages << PAGE_WIDTH))
+                if (va <= area->base + (P2SZ(area->pages) - 1))
                         return area;
                 
@@ -577 +578 @@
         
         if (pages < area->pages) {
-                uintptr_t start_free = area->base + (pages << PAGE_WIDTH);
+                uintptr_t start_free = area->base + P2SZ(pages);
                 
                 /*
@@ -590 +591 @@
                  */
                 ipl_t ipl = tlb_shootdown_start(TLB_INVL_PAGES, as->asid,
-                    area->base + (pages << PAGE_WIDTH), area->pages - pages);
+                    area->base + P2SZ(pages), area->pages - pages);
                 
                 /*
@@ -613 +614 @@
                                 size_t i = 0;
                                 
-                                if (overlaps(ptr, size << PAGE_WIDTH, area->base,
-                                    pages << PAGE_WIDTH)) {
+                                if (overlaps(ptr, P2SZ(size), area->base,
+                                    P2SZ(pages))) {
                                         
-                                        if (ptr + (size << PAGE_WIDTH) <= start_free) {
+                                        if (ptr + P2SZ(size) <= start_free) {
                                                 /*
                                                  * The whole interval fits
@@ -647 +648 @@
                                 
                                 for (; i < size; i++) {
-                                        pte_t *pte = page_mapping_find(as, ptr +
-                                            (i << PAGE_WIDTH));
+                                        pte_t *pte = page_mapping_find(as,
+                                            ptr + P2SZ(i), false);
                                         
                                         ASSERT(pte);
@@ -657 +658 @@
                                             (area->backend->frame_free)) {
                                                 area->backend->frame_free(area,
-                                                    ptr + (i << PAGE_WIDTH),
+                                                    ptr + P2SZ(i),
                                                     PTE_GET_FRAME(pte));
                                         }
                                         
-                                        page_mapping_remove(as, ptr +
-                                            (i << PAGE_WIDTH));
+                                        page_mapping_remove(as, ptr + P2SZ(i));
                                 }
                         }
@@ -671 +671 @@
                  */
                 
-                tlb_invalidate_pages(as->asid, area->base + (pages << PAGE_WIDTH),
+                tlb_invalidate_pages(as->asid, area->base + P2SZ(pages),
                     area->pages - pages);
                 
                 /*
-                 * Invalidate software translation caches (e.g. TSB on sparc64).
-                 */
-                as_invalidate_translation_cache(as, area->base +
-                    (pages << PAGE_WIDTH), area->pages - pages);
+                 * Invalidate software translation caches
+                 * (e.g. TSB on sparc64, PHT on ppc32).
+                 */
+                as_invalidate_translation_cache(as, area->base + P2SZ(pages),
+                    area->pages - pages);
                 tlb_shootdown_finalize(ipl);
                 
@@ -797 +798 @@
                         
                         for (size = 0; size < (size_t) node->value[i]; size++) {
-                                pte_t *pte =
-                                    page_mapping_find(as, ptr + (size << PAGE_WIDTH));
+                                pte_t *pte = page_mapping_find(as,
+                                     ptr + P2SZ(size), false);
                                 
                                 ASSERT(pte);
@@ -807 +808 @@
                                     (area->backend->frame_free)) {
                                         area->backend->frame_free(area,
-                                            ptr + (size << PAGE_WIDTH), PTE_GET_FRAME(pte));
+                                            ptr + P2SZ(size),
+                                            PTE_GET_FRAME(pte));
                                 }
                                 
-                                page_mapping_remove(as, ptr + (size << PAGE_WIDTH));
+                                page_mapping_remove(as, ptr + P2SZ(size));
                         }
                 }
@@ -822 +824 @@
         
         /*
-         * Invalidate potential software translation caches (e.g. TSB on
-         * sparc64).
+         * Invalidate potential software translation caches
+         * (e.g. TSB on sparc64, PHT on ppc32).
          */
         as_invalidate_translation_cache(as, area->base, area->pages);
@@ -897 +899 @@
         }
         
-        size_t src_size = src_area->pages << PAGE_WIDTH;
+        size_t src_size = P2SZ(src_area->pages);
         unsigned int src_flags = src_area->flags;
         mem_backend_t *src_backend = src_area->backend;
@@ -1094 +1096 @@
         for (cur = area->used_space.leaf_head.next;
             cur != &area->used_space.leaf_head; cur = cur->next) {
-                btree_node_t *node
-                    = list_get_instance(cur, btree_node_t, leaf_link);
+                btree_node_t *node = list_get_instance(cur, btree_node_t,
+                    leaf_link);
                 btree_key_t i;
                 
@@ -1103 +1105 @@
                         
                         for (size = 0; size < (size_t) node->value[i]; size++) {
-                                pte_t *pte =
-                                    page_mapping_find(as, ptr + (size << PAGE_WIDTH));
+                                pte_t *pte = page_mapping_find(as,
+                                    ptr + P2SZ(size), false);
                                 
                                 ASSERT(pte);
@@ -1113 +1115 @@
                                 
                                 /* Remove old mapping */
-                                page_mapping_remove(as, ptr + (size << PAGE_WIDTH));
+                                page_mapping_remove(as, ptr + P2SZ(size));
                         }
                 }
@@ -1125 +1127 @@
         
         /*
-         * Invalidate potential software translation caches (e.g. TSB on
-         * sparc64).
+         * Invalidate potential software translation caches
+         * (e.g. TSB on sparc64, PHT on ppc32).
          */
         as_invalidate_translation_cache(as, area->base, area->pages);
@@ -1159 +1161 @@
                                 
                                 /* Insert the new mapping */
-                                page_mapping_insert(as, ptr + (size << PAGE_WIDTH),
+                                page_mapping_insert(as, ptr + P2SZ(size),
                                     old_frame[frame_idx++], page_flags);
                                 
@@ -1240 +1242 @@
          */
         pte_t *pte;
-        if ((pte = page_mapping_find(AS, page))) {
+        if ((pte = page_mapping_find(AS, page, false))) {
                 if (PTE_PRESENT(pte)) {
                         if (((access == PF_ACCESS_READ) && PTE_READABLE(pte)) ||
@@ -1481 +1483 @@
         
         if (src_area) {
-                size = src_area->pages << PAGE_WIDTH;
+                size = P2SZ(src_area->pages);
                 mutex_unlock(&src_area->lock);
         } else
@@ -1536 +1538 @@
                 if (page >= right_pg) {
                         /* Do nothing. */
-                } else if (overlaps(page, count << PAGE_WIDTH, left_pg,
-                    left_cnt << PAGE_WIDTH)) {
+                } else if (overlaps(page, P2SZ(count), left_pg,
+                    P2SZ(left_cnt))) {
                         /* The interval intersects with the left interval. */
                         return false;
-                } else if (overlaps(page, count << PAGE_WIDTH, right_pg,
-                    right_cnt << PAGE_WIDTH)) {
+                } else if (overlaps(page, P2SZ(count), right_pg,
+                    P2SZ(right_cnt))) {
                         /* The interval intersects with the right interval. */
                         return false;
-                } else if ((page == left_pg + (left_cnt << PAGE_WIDTH)) &&
-                    (page + (count << PAGE_WIDTH) == right_pg)) {
+                } else if ((page == left_pg + P2SZ(left_cnt)) &&
+                    (page + P2SZ(count) == right_pg)) {
                         /*
                          * The interval can be added by merging the two already
@@ -1553 +1555 @@
                         btree_remove(&area->used_space, right_pg, leaf);
                         goto success;
-                } else if (page == left_pg + (left_cnt << PAGE_WIDTH)) {
+                } else if (page == left_pg + P2SZ(left_cnt)) {
                         /*
                          * The interval can be added by simply growing the left
@@ -1560 +1562 @@
                         node->value[node->keys - 1] += count;
                         goto success;
-                } else if (page + (count << PAGE_WIDTH) == right_pg) {
+                } else if (page + P2SZ(count) == right_pg) {
                         /*
                          * The interval can be addded by simply moving base of
@@ -1587 +1589 @@
                  */
                 
-                if (overlaps(page, count << PAGE_WIDTH, right_pg,
-                    right_cnt << PAGE_WIDTH)) {
+                if (overlaps(page, P2SZ(count), right_pg, P2SZ(right_cnt))) {
                         /* The interval intersects with the right interval. */
                         return false;
-                } else if (page + (count << PAGE_WIDTH) == right_pg) {
+                } else if (page + P2SZ(count) == right_pg) {
                         /*
                          * The interval can be added by moving the base of the
@@ -1626 +1627 @@
                 if (page < left_pg) {
                         /* Do nothing. */
-                } else if (overlaps(page, count << PAGE_WIDTH, left_pg,
-                    left_cnt << PAGE_WIDTH)) {
+                } else if (overlaps(page, P2SZ(count), left_pg,
+                    P2SZ(left_cnt))) {
                         /* The interval intersects with the left interval. */
                         return false;
-                } else if (overlaps(page, count << PAGE_WIDTH, right_pg,
-                    right_cnt << PAGE_WIDTH)) {
+                } else if (overlaps(page, P2SZ(count), right_pg,
+                    P2SZ(right_cnt))) {
                         /* The interval intersects with the right interval. */
                         return false;
-                } else if ((page == left_pg + (left_cnt << PAGE_WIDTH)) &&
-                    (page + (count << PAGE_WIDTH) == right_pg)) {
+                } else if ((page == left_pg + P2SZ(left_cnt)) &&
+                    (page + P2SZ(count) == right_pg)) {
                         /*
                          * The interval can be added by merging the two already
@@ -1643 +1644 @@
                         btree_remove(&area->used_space, right_pg, node);
                         goto success;
-                } else if (page == left_pg + (left_cnt << PAGE_WIDTH)) {
+                } else if (page == left_pg + P2SZ(left_cnt)) {
                         /*
                          * The interval can be added by simply growing the left
@@ -1650 +1651 @@
                         leaf->value[leaf->keys - 1] += count;
                         goto success;
-                } else if (page + (count << PAGE_WIDTH) == right_pg) {
+                } else if (page + P2SZ(count) == right_pg) {
                         /*
                          * The interval can be addded by simply moving base of
@@ -1677 +1678 @@
                  */
                 
-                if (overlaps(page, count << PAGE_WIDTH, left_pg,
-                    left_cnt << PAGE_WIDTH)) {
+                if (overlaps(page, P2SZ(count), left_pg, P2SZ(left_cnt))) {
                         /* The interval intersects with the left interval. */
                         return false;
-                } else if (left_pg + (left_cnt << PAGE_WIDTH) == page) {
+                } else if (left_pg + P2SZ(left_cnt) == page) {
                         /*
                          * The interval can be added by growing the left
@@ -1716 +1716 @@
                          */
                         
-                        if (overlaps(page, count << PAGE_WIDTH, left_pg,
-                            left_cnt << PAGE_WIDTH)) {
+                        if (overlaps(page, P2SZ(count), left_pg,
+                            P2SZ(left_cnt))) {
                                 /*
                                  * The interval intersects with the left
@@ -1723 +1723 @@
                                  */
                                 return false;
-                        } else if (overlaps(page, count << PAGE_WIDTH, right_pg,
-                            right_cnt << PAGE_WIDTH)) {
+                        } else if (overlaps(page, P2SZ(count), right_pg,
+                            P2SZ(right_cnt))) {
                                 /*
                                  * The interval intersects with the right
@@ -1730 +1730 @@
                                  */
                                 return false;
-                        } else if ((page == left_pg + (left_cnt << PAGE_WIDTH)) &&
-                            (page + (count << PAGE_WIDTH) == right_pg)) {
+                        } else if ((page == left_pg + P2SZ(left_cnt)) &&
+                            (page + P2SZ(count) == right_pg)) {
                                 /*
                                  * The interval can be added by merging the two
@@ -1739 +1739 @@
                                 btree_remove(&area->used_space, right_pg, leaf);
                                 goto success;
-                        } else if (page == left_pg + (left_cnt << PAGE_WIDTH)) {
+                        } else if (page == left_pg + P2SZ(left_cnt)) {
                                 /*
                                  * The interval can be added by simply growing
@@ -1746 +1746 @@
                                 leaf->value[i - 1] += count;
                                 goto success;
-                        } else if (page + (count << PAGE_WIDTH) == right_pg) {
+                        } else if (page + P2SZ(count) == right_pg) {
                                 /*
                                  * The interval can be addded by simply moving
@@ -1812 +1812 @@
                         for (i = 0; i < leaf->keys; i++) {
                                 if (leaf->key[i] == page) {
-                                        leaf->key[i] += count << PAGE_WIDTH;
+                                        leaf->key[i] += P2SZ(count);
                                         leaf->value[i] -= count;
                                         goto success;
@@ -1822 +1822 @@
         }
         
-        btree_node_t *node = btree_leaf_node_left_neighbour(&area->used_space, leaf);
+        btree_node_t *node = btree_leaf_node_left_neighbour(&area->used_space,
+            leaf);
         if ((node) && (page < leaf->key[0])) {
                 uintptr_t left_pg = node->key[node->keys - 1];
                 size_t left_cnt = (size_t) node->value[node->keys - 1];
                 
-                if (overlaps(left_pg, left_cnt << PAGE_WIDTH, page,
-                    count << PAGE_WIDTH)) {
-                        if (page + (count << PAGE_WIDTH) ==
-                            left_pg + (left_cnt << PAGE_WIDTH)) {
+                if (overlaps(left_pg, P2SZ(left_cnt), page, P2SZ(count))) {
+                        if (page + P2SZ(count) == left_pg + P2SZ(left_cnt)) {
                                 /*
                                  * The interval is contained in the rightmost
@@ -1839 +1838 @@
                                 node->value[node->keys - 1] -= count;
                                 goto success;
-                        } else if (page + (count << PAGE_WIDTH) <
-                            left_pg + (left_cnt << PAGE_WIDTH)) {
+                        } else if (page + P2SZ(count) <
+                            left_pg + P2SZ(left_cnt)) {
+                                size_t new_cnt;
+
                                 /*
                                  * The interval is contained in the rightmost
@@ -1848 +1849 @@
                                  * new interval.
                                  */
-                                size_t new_cnt = ((left_pg + (left_cnt << PAGE_WIDTH)) -
-                                    (page + (count << PAGE_WIDTH))) >> PAGE_WIDTH;
+                                new_cnt = ((left_pg + P2SZ(left_cnt)) -
+                                    (page + P2SZ(count))) >> PAGE_WIDTH;
                                 node->value[node->keys - 1] -= count + new_cnt;
                                 btree_insert(&area->used_space, page +
-                                    (count << PAGE_WIDTH), (void *) new_cnt, leaf);
+                                    P2SZ(count), (void *) new_cnt, leaf);
                                 goto success;
                         }
@@ -1865 +1866 @@
                 size_t left_cnt = (size_t) leaf->value[leaf->keys - 1];
                 
-                if (overlaps(left_pg, left_cnt << PAGE_WIDTH, page,
-                    count << PAGE_WIDTH)) {
-                        if (page + (count << PAGE_WIDTH) ==
-                            left_pg + (left_cnt << PAGE_WIDTH)) {
+                if (overlaps(left_pg, P2SZ(left_cnt), page, P2SZ(count))) {
+                        if (page + P2SZ(count) == left_pg + P2SZ(left_cnt)) {
                                 /*
                                  * The interval is contained in the rightmost
@@ -1876 +1875 @@
                                 leaf->value[leaf->keys - 1] -= count;
                                 goto success;
-                        } else if (page + (count << PAGE_WIDTH) < left_pg +
-                            (left_cnt << PAGE_WIDTH)) {
+                        } else if (page + P2SZ(count) < left_pg +
+                            P2SZ(left_cnt)) {
+                                size_t new_cnt;
+
                                 /*
                                  * The interval is contained in the rightmost
@@ -1885 +1886 @@
                                  * interval.
                                  */
-                                size_t new_cnt = ((left_pg + (left_cnt << PAGE_WIDTH)) -
-                                    (page + (count << PAGE_WIDTH))) >> PAGE_WIDTH;
+                                new_cnt = ((left_pg + P2SZ(left_cnt)) -
+                                    (page + P2SZ(count))) >> PAGE_WIDTH;
                                 leaf->value[leaf->keys - 1] -= count + new_cnt;
                                 btree_insert(&area->used_space, page +
-                                    (count << PAGE_WIDTH), (void *) new_cnt, leaf);
+                                    P2SZ(count), (void *) new_cnt, leaf);
                                 goto success;
                         }
@@ -1911 +1912 @@
                          * to (i - 1) and i.
                          */
-                        if (overlaps(left_pg, left_cnt << PAGE_WIDTH, page,
-                            count << PAGE_WIDTH)) {
-                                if (page + (count << PAGE_WIDTH) ==
-                                    left_pg + (left_cnt << PAGE_WIDTH)) {
+                        if (overlaps(left_pg, P2SZ(left_cnt), page,
+                            P2SZ(count))) {
+                                if (page + P2SZ(count) ==
+                                    left_pg + P2SZ(left_cnt)) {
                                         /*
                                          * The interval is contained in the
@@ -1923 +1924 @@
                                         leaf->value[i - 1] -= count;
                                         goto success;
-                                } else if (page + (count << PAGE_WIDTH) <
-                                    left_pg + (left_cnt << PAGE_WIDTH)) {
+                                } else if (page + P2SZ(count) <
+                                    left_pg + P2SZ(left_cnt)) {
+                                        size_t new_cnt;
+
                                         /*
                                          * The interval is contained in the
@@ -1932 +1935 @@
                                          * also inserting a new interval.
                                          */
-                                        size_t new_cnt = ((left_pg +
-                                            (left_cnt << PAGE_WIDTH)) -
-                                            (page + (count << PAGE_WIDTH))) >>
+                                        new_cnt = ((left_pg + P2SZ(left_cnt)) -
+                                            (page + P2SZ(count))) >>
                                             PAGE_WIDTH;
                                         leaf->value[i - 1] -= count + new_cnt;
                                         btree_insert(&area->used_space, page +
-                                            (count << PAGE_WIDTH), (void *) new_cnt,
+                                            P2SZ(count), (void *) new_cnt,
                                             leaf);
                                         goto success;
@@ -2034 +2036 @@
                 btree_key_t i;
                 for (i = 0; (ret == 0) && (i < node->keys); i++) {
+                        uintptr_t addr;
+
                         as_area_t *area = (as_area_t *) node->value[i];
                         
                         mutex_lock(&area->lock);
                         
-                        uintptr_t addr =
-                            ALIGN_UP(area->base + (area->pages << PAGE_WIDTH),
+                        addr = ALIGN_UP(area->base + P2SZ(area->pages),
                             PAGE_SIZE);
                         
@@ -2098 +2101 @@
                         
                         info[area_idx].start_addr = area->base;
-                        info[area_idx].size = FRAMES2SIZE(area->pages);
+                        info[area_idx].size = P2SZ(area->pages);
                         info[area_idx].flags = area->flags;
                         ++area_idx;
@@ -2136 +2139 @@
                             " (%p - %p)\n", area, (void *) area->base,
                             area->pages, (void *) area->base,
-                            (void *) (area->base + FRAMES2SIZE(area->pages)));
+                            (void *) (area->base + P2SZ(area->pages)));
                         mutex_unlock(&area->lock);
                 }

kernel/generic/src/mm/backend_anon.c

@@ -50 +50 @@
 #include <typedefs.h>
 #include <align.h>
+#include <memstr.h>
 #include <arch.h>
 
@@ -121 +122 @@
                                 page_table_lock(area->as, false);
                                 pte = page_mapping_find(area->as,
-                                    base + j * PAGE_SIZE);
+                                    base + P2SZ(j), false);
                                 ASSERT(pte && PTE_VALID(pte) &&
                                     PTE_PRESENT(pte));
                                 btree_insert(&area->sh_info->pagemap,
-                                    (base + j * PAGE_SIZE) - area->base,
+                                    (base + P2SZ(j)) - area->base,
                                     (void *) PTE_GET_FRAME(pte), NULL);
                                 page_table_unlock(area->as, false);

kernel/generic/src/mm/backend_elf.c

@@ -170 +170 @@
                         if (!(area->flags & AS_AREA_WRITE))
                                 if (base >= entry->p_vaddr &&
-                                    base + count * PAGE_SIZE <= start_anon)
+                                    base + P2SZ(count) <= start_anon)
                                         continue;
                         
@@ -182 +182 @@
                                 if (!(area->flags & AS_AREA_WRITE))
                                         if (base >= entry->p_vaddr &&
-                                            base + (j + 1) * PAGE_SIZE <=
-                                            start_anon)
+                                            base + P2SZ(j + 1) <= start_anon)
                                                 continue;
                                 
                                 page_table_lock(area->as, false);
                                 pte = page_mapping_find(area->as,
-                                    base + j * PAGE_SIZE);
+                                    base + P2SZ(j), false);
                                 ASSERT(pte && PTE_VALID(pte) &&
                                     PTE_PRESENT(pte));
                                 btree_insert(&area->sh_info->pagemap,
-                                    (base + j * PAGE_SIZE) - area->base,
+                                    (base + P2SZ(j)) - area->base,
                                     (void *) PTE_GET_FRAME(pte), NULL);
                                 page_table_unlock(area->as, false);

kernel/generic/src/mm/frame.c

@@ -182 +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;
@@ -192 +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.
@@ -840 +851 @@
                         buddy_system_free(zone->buddy_system, &zone->frames[i].buddy_link);
                 }
-
-                /* "Unreserve" new frames. */
-                reserve_free(count);
         } else
                 zone->frames = NULL;
@@ -1051 +1059 @@
                 
 #ifdef CONFIG_DEBUG
-                size_t avail = total_frames_free();
+                size_t avail = frame_total_free_get_internal();
 #endif
                 

kernel/generic/src/mm/page.c

@@ -60 +60 @@
 
 #include <mm/page.h>
+#include <genarch/mm/page_ht.h>
+#include <genarch/mm/page_pt.h>
 #include <arch/mm/page.h>
 #include <arch/mm/asid.h>
@@ -70 +72 @@
 #include <debug.h>
 #include <arch.h>
+#include <syscall/copy.h>
+#include <errno.h>
 
 /** Virtual operations for page subsystem. */
@@ -108 +112 @@
  * using flags. Allocate and setup any missing page tables.
  *
- * @param as    Address space to wich page belongs.
+ * @param as    Address space to which page belongs.
  * @param page  Virtual address of the page to be mapped.
  * @param frame Physical address of memory frame to which the mapping is
@@ -135 +139 @@
  * this call visible.
  *
- * @param as   Address space to wich page belongs.
+ * @param as   Address space to which page belongs.
  * @param page Virtual address of the page to be demapped.
  *
@@ -152 +156 @@
 }
 
-/** Find mapping for virtual page
- *
- * Find mapping for virtual page.
- *
- * @param as   Address space to wich page belongs.
- * @param page Virtual page.
+/** Find mapping for virtual page.
+ *
+ * @param as     Address space to which page belongs.
+ * @param page   Virtual page.
+ * @param nolock True if the page tables need not be locked.
  *
  * @return NULL if there is no such mapping; requested mapping
@@ -163 +166 @@
  *
  */
-NO_TRACE pte_t *page_mapping_find(as_t *as, uintptr_t page)
-{
-        ASSERT(page_table_locked(as));
+NO_TRACE pte_t *page_mapping_find(as_t *as, uintptr_t page, bool nolock)
+{
+        ASSERT(nolock || page_table_locked(as));
         
         ASSERT(page_mapping_operations);
         ASSERT(page_mapping_operations->mapping_find);
         
-        return page_mapping_operations->mapping_find(as, page);
+        return page_mapping_operations->mapping_find(as, page, nolock);
+}
+
+/** Syscall wrapper for getting mapping of a virtual page.
+ * 
+ * @retval EOK Everything went find, @p uspace_frame and @p uspace_node
+ *             contains correct values.
+ * @retval ENOENT Virtual address has no mapping.
+ */
+sysarg_t sys_page_find_mapping(uintptr_t virt_address,
+    uintptr_t *uspace_frame)
+{
+        mutex_lock(&AS->lock);
+        
+        pte_t *pte = page_mapping_find(AS, virt_address, false);
+        if (!PTE_VALID(pte) || !PTE_PRESENT(pte)) {
+                mutex_unlock(&AS->lock);
+                
+                return (sysarg_t) ENOENT;
+        }
+        
+        uintptr_t phys_address = PTE_GET_FRAME(pte);
+        
+        mutex_unlock(&AS->lock);
+        
+        int rc = copy_to_uspace(uspace_frame,
+            &phys_address, sizeof(phys_address));
+        if (rc != EOK) {
+                return (sysarg_t) rc;
+        }
+        
+        return EOK;
 }
 

kernel/generic/src/mm/reserve.c

@@ -45 +45 @@
 IRQ_SPINLOCK_STATIC_INITIALIZE_NAME(reserve_lock, "reserve_lock");
 static ssize_t reserve = 0;
+
+/** Initialize memory reservations tracking.
+ *
+ * This function must be called after frame zones are created and merged
+ * and before any address space area is created.
+ */
+void reserve_init(void)
+{
+        reserve = frame_total_free_get();
+}
 
 /** Try to reserve memory.

kernel/generic/src/printf/vprintf.c

@@ -41 +41 @@
 #include <typedefs.h>
 #include <str.h>
-
-IRQ_SPINLOCK_STATIC_INITIALIZE_NAME(printf_lock, "*printf_lock");
 
 static int vprintf_str_write(const char *str, size_t size, void *data)
@@ -93 +91 @@
         };
         
-        irq_spinlock_lock(&printf_lock, true);
-        int ret = printf_core(fmt, &ps, ap);
-        irq_spinlock_unlock(&printf_lock, true);
-        
-        return ret;
+        return printf_core(fmt, &ps, ap);
 }
 

kernel/generic/src/proc/program.c

@@ -54 +54 @@
 #include <proc/program.h>
 
-#ifndef LOADED_PROG_STACK_PAGES_NO
-#define LOADED_PROG_STACK_PAGES_NO 1
-#endif
-
 /**
  * Points to the binary image used as the program loader. All non-initial
@@ -90 +86 @@
         
         /*
-         * Create the data address space area.
+         * Create the stack address space area.
          */
         as_area_t *area = as_area_create(as,
             AS_AREA_READ | AS_AREA_WRITE | AS_AREA_CACHEABLE,
-            LOADED_PROG_STACK_PAGES_NO * PAGE_SIZE, USTACK_ADDRESS,
-            AS_AREA_ATTR_NONE, &anon_backend, NULL);
+            STACK_SIZE, USTACK_ADDRESS, AS_AREA_ATTR_NONE,
+            &anon_backend, NULL);
         if (!area)
                 return ENOMEM;

kernel/generic/src/proc/scheduler.c

@@ -376 +376 @@
         context_save(&CPU->saved_context);
         context_set(&CPU->saved_context, FADDR(scheduler_separated_stack),
-            (uintptr_t) CPU->stack, CPU_STACK_SIZE);
+            (uintptr_t) CPU->stack, STACK_SIZE);
         context_restore(&CPU->saved_context);
         

kernel/generic/src/proc/task.c

@@ -190 +190 @@
         str_cpy(task->name, TASK_NAME_BUFLEN, name);
         
-        task->context = CONTEXT;
+        task->container = CONTAINER;
         task->capabilities = 0;
         task->ucycles = 0;
@@ -211 +211 @@
         
         if ((ipc_phone_0) &&
-            (context_check(ipc_phone_0->task->context, task->context)))
+            (container_check(ipc_phone_0->task->container, task->container)))
                 ipc_phone_connect(&task->phones[0], ipc_phone_0);
         
@@ -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. */
@@ -586 +584 @@
                 printf("%-8" PRIu64 " %-14s %-5" PRIu32 " %10p %10p"
                     " %9" PRIu64 "%c %9" PRIu64 "%c\n", task->taskid,
-                    task->name, task->context, task, task->as,
+                    task->name, task->container, task, task->as,
                     ucycles, usuffix, kcycles, ksuffix);
 #endif
@@ -597 +595 @@
         else
                 printf("%-8" PRIu64 " %-14s %-5" PRIu32 " %18p %18p\n",
-                    task->taskid, task->name, task->context, task, task->as);
+                    task->taskid, task->name, task->container, task, task->as);
 #endif
         
@@ -627 +625 @@
                 printf("[id    ] [threads] [calls] [callee\n");
         else
-                printf("[id    ] [name        ] [ctx] [address ] [as      ]"
+                printf("[id    ] [name        ] [ctn] [address ] [as      ]"
                     " [ucycles ] [kcycles ]\n");
 #endif
@@ -636 +634 @@
                     " [callee\n");
         else
-                printf("[id    ] [name        ] [ctx] [address         ]"
+                printf("[id    ] [name        ] [ctn] [address         ]"
                     " [as              ]\n");
 #endif

kernel/generic/src/proc/the.c

@@ -58 +58 @@
         the->task = NULL;
         the->as = NULL;
+        the->magic = MAGIC;
 }
 
@@ -70 +71 @@
 NO_TRACE void the_copy(the_t *src, the_t *dst)
 {
+        ASSERT(src->magic == MAGIC);
         *dst = *src;
 }

kernel/generic/src/proc/thread.c

@@ -55 +55 @@
 #include <time/clock.h>
 #include <time/timeout.h>
+#include <time/delay.h>
 #include <config.h>
 #include <arch/interrupt.h>
@@ -67 +68 @@
 #include <syscall/copy.h>
 #include <errno.h>
-
-
-#ifndef LOADED_PROG_STACK_PAGES_NO
-#define LOADED_PROG_STACK_PAGES_NO 1
-#endif
-
 
 /** Thread states */
@@ -300 +295 @@
         
         /* Not needed, but good for debugging */
-        memsetb(thread->kstack, THREAD_STACK_SIZE * 1 << STACK_FRAMES, 0);
+        memsetb(thread->kstack, STACK_SIZE, 0);
         
         irq_spinlock_lock(&tidlock, true);
@@ -308 +303 @@
         context_save(&thread->saved_context);
         context_set(&thread->saved_context, FADDR(cushion),
-            (uintptr_t) thread->kstack, THREAD_STACK_SIZE);
+            (uintptr_t) thread->kstack, STACK_SIZE);
         
         the_initialize((the_t *) thread->kstack);
@@ -605 +600 @@
                 printf("%-8" PRIu64 " %-14s %10p %-8s %10p %-5" PRIu32 "\n",
                     thread->tid, name, thread, thread_states[thread->state],
-                    thread->task, thread->task->context);
+                    thread->task, thread->task->container);
 #endif
         
@@ -617 +612 @@
                 printf("%-8" PRIu64 " %-14s %18p %-8s %18p %-5" PRIu32 "\n",
                     thread->tid, name, thread, thread_states[thread->state],
-                    thread->task, thread->task->context);
+                    thread->task, thread->task->container);
 #endif
         
@@ -658 +653 @@
         else
                 printf("[id    ] [name        ] [address ] [state ] [task    ]"
-                    " [ctx]\n");
+                    " [ctn]\n");
 #endif
         
@@ -667 +662 @@
         } else
                 printf("[id    ] [name        ] [address         ] [state ]"
-                    " [task            ] [ctx]\n");
+                    " [task            ] [ctn]\n");
 #endif
         
@@ -918 +913 @@
 }
 
+sysarg_t sys_thread_udelay(uint32_t usec)
+{
+        delay(usec);
+        return 0;
+}
+
 /** @}
  */

kernel/generic/src/security/cap.c

@@ -92 +92 @@
         task_t *task = task_find_by_id(taskid);
         
-        if ((!task) || (!context_check(CONTEXT, task->context))) {
+        if ((!task) || (!container_check(CONTAINER, task->container))) {
                 irq_spinlock_unlock(&tasks_lock, true);
                 return (sysarg_t) ENOENT;
@@ -121 +121 @@
         
         task_t *task = task_find_by_id(taskid);
-        if ((!task) || (!context_check(CONTEXT, task->context))) {
+        if ((!task) || (!container_check(CONTAINER, task->container))) {
                 irq_spinlock_unlock(&tasks_lock, true);
                 return (sysarg_t) ENOENT;

kernel/generic/src/synch/futex.c

@@ -119 +119 @@
          */
         page_table_lock(AS, true);
-        t = page_mapping_find(AS, ALIGN_DOWN(uaddr, PAGE_SIZE));
+        t = page_mapping_find(AS, ALIGN_DOWN(uaddr, PAGE_SIZE), false);
         if (!t || !PTE_VALID(t) || !PTE_PRESENT(t)) {
                 page_table_unlock(AS, true);
@@ -155 +155 @@
          */
         page_table_lock(AS, true);
-        t = page_mapping_find(AS, ALIGN_DOWN(uaddr, PAGE_SIZE));
+        t = page_mapping_find(AS, ALIGN_DOWN(uaddr, PAGE_SIZE), false);
         if (!t || !PTE_VALID(t) || !PTE_PRESENT(t)) {
                 page_table_unlock(AS, true);

kernel/generic/src/synch/spinlock.c

@@ -96 +96 @@
                  * run in a simulator) that caused problems with both
                  * printf_lock and the framebuffer lock.
-                 *
                  */
                 if (lock->name[0] == '*')

kernel/generic/src/syscall/syscall.c

@@ -41 +41 @@
 #include <proc/program.h>
 #include <mm/as.h>
+#include <mm/page.h>
 #include <print.h>
 #include <arch.h>
@@ -118 +119 @@
 
 syshandler_t syscall_table[SYSCALL_END] = {
+        /* System management syscalls. */
         (syshandler_t) sys_klog,
         (syshandler_t) sys_tls_set,
@@ -126 +128 @@
         (syshandler_t) sys_thread_get_id,
         (syshandler_t) sys_thread_usleep,
+        (syshandler_t) sys_thread_udelay,
         
         (syshandler_t) sys_task_get_id,
@@ -145 +148 @@
         (syshandler_t) sys_as_get_unmapped_area,
         
+        /* Page mapping related syscalls. */
+        (syshandler_t) sys_page_find_mapping,
+        
         /* IPC related syscalls. */
         (syshandler_t) sys_ipc_call_sync_fast,
@@ -161 +167 @@
         /* Event notification syscalls. */
         (syshandler_t) sys_event_subscribe,
+        (syshandler_t) sys_event_unmask,
         
         /* Capabilities related syscalls. */
@@ -173 +180 @@
         (syshandler_t) sys_unregister_irq,
         
-        /* Sysinfo syscalls */
+        /* Sysinfo syscalls. */
         (syshandler_t) sys_sysinfo_get_tag,
         (syshandler_t) sys_sysinfo_get_value,