Changeset 49ff5f3 in mainline for kernel/generic/src

Timestamp:

2012-04-18T20:55:21Z (14 years ago)

Author:

Maurizio Lombardi <m.lombardi85@…>

Branches:

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

Children:

7769ec9

Parents:

e895352 (diff), 63920b0 (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:

• console/cmd.c (modified) (1 diff)
• console/console.c (modified) (1 diff)
• console/kconsole.c (modified) (1 diff)
• cpu/cpu.c (modified) (1 diff)
• ddi/ddi.c (modified) (12 diffs)
• ipc/irq.c (modified) (13 diffs)
• ipc/sysipc.c (modified) (3 diffs)
• lib/elf.c (modified) (1 diff)
• lib/func.c (modified) (1 diff)
• lib/ra.c (added)
• lib/rd.c (modified) (2 diffs)
• lib/str.c (modified) (5 diffs)
• main/kinit.c (modified) (4 diffs)
• main/main.c (modified) (7 diffs)
• main/version.c (modified) (1 diff)
• mm/as.c (modified) (12 diffs)
• mm/backend_anon.c (modified) (7 diffs)
• mm/backend_elf.c (modified) (12 diffs)
• mm/frame.c (modified) (22 diffs)
• mm/km.c (added)
• mm/page.c (modified) (4 diffs)
• mm/reserve.c (modified) (5 diffs)
• printf/printf_core.c (modified) (2 diffs)
• proc/program.c (modified) (1 diff)
• proc/thread.c (modified) (1 diff)
• syscall/copy.c (modified) (2 diffs)
• syscall/syscall.c (modified) (2 diffs)
• sysinfo/stats.c (modified) (25 diffs)
• sysinfo/sysinfo.c (modified) (22 diffs)

kernel/generic/src/console/cmd.c

@@ -906 +906 @@
                    ((char *) argv->buffer)[0] <= '9') {
                 uint64_t value;
-                rc = str_uint64((char *) argv->buffer, NULL, 0, true, &value);
+                rc = str_uint64_t((char *) argv->buffer, NULL, 0, true, &value);
                 if (rc == EOK)
                         addr = (uintptr_t) value;

kernel/generic/src/console/console.c

@@ -57 +57 @@
 
 /** Kernel log cyclic buffer */
-static wchar_t klog[KLOG_LENGTH] __attribute__ ((aligned (PAGE_SIZE)));
+wchar_t klog[KLOG_LENGTH] __attribute__((aligned(PAGE_SIZE)));
 
 /** Kernel log initialized */

kernel/generic/src/console/kconsole.c

@@ -472 +472 @@
                 /* It's a number - convert it */
                 uint64_t value;
-                int rc = str_uint64(text, NULL, 0, true, &value);
+                int rc = str_uint64_t(text, NULL, 0, true, &value);
                 switch (rc) {
                 case EINVAL:

kernel/generic/src/cpu/cpu.c

@@ -74 +74 @@
                 for (i = 0; i < config.cpu_count; i++) {
                         cpus[i].stack = (uint8_t *) frame_alloc(STACK_FRAMES,
-                            FRAME_KA | FRAME_ATOMIC);
+                            FRAME_LOWMEM | FRAME_KA | FRAME_ATOMIC);
                         cpus[i].id = i;
                         

kernel/generic/src/ddi/ddi.c

@@ -45 +45 @@
 #include <mm/frame.h>
 #include <mm/as.h>
+#include <mm/page.h>
 #include <synch/mutex.h>
 #include <syscall/copy.h>
@@ -52 +53 @@
 #include <errno.h>
 #include <trace.h>
+#include <bitops.h>
 
 /** This lock protects the parea_btree. */
@@ -87 +89 @@
 /** Map piece of physical memory into virtual address space of current task.
  *
- * @param pf    Physical address of the starting frame.
- * @param vp    Virtual address of the starting page.
+ * @param phys  Physical address of the starting frame.
  * @param pages Number of pages to map.
  * @param flags Address space area flags for the mapping.
- *
- * @return 0 on success, EPERM if the caller lacks capabilities to use this
- *         syscall, EBADMEM if pf or vf is not page aligned, ENOENT if there
- *         is no task matching the specified ID or the physical address space
- *         is not enabled for mapping and ENOMEM if there was a problem in
- *         creating address space area.
- *
- */
-NO_TRACE static int ddi_physmem_map(uintptr_t pf, uintptr_t vp, size_t pages,
-    unsigned int flags)
+ * @param virt  Virtual address of the starting page.
+ * @param bound Lowest virtual address bound.
+ *
+ * @return EOK on success.
+ * @return EPERM if the caller lacks capabilities to use this syscall.
+ * @return EBADMEM if phys is not page aligned.
+ * @return ENOENT if there is no task matching the specified ID or
+ *         the physical address space is not enabled for mapping.
+ * @return ENOMEM if there was a problem in creating address space area.
+ *
+ */
+NO_TRACE static int physmem_map(uintptr_t phys, size_t pages,
+    unsigned int flags, uintptr_t *virt, uintptr_t bound)
 {
         ASSERT(TASK);
         
-        if ((pf % FRAME_SIZE) != 0)
-                return EBADMEM;
-        
-        if ((vp % PAGE_SIZE) != 0)
+        if ((phys % FRAME_SIZE) != 0)
                 return EBADMEM;
         
@@ -118 +119 @@
         
         mem_backend_data_t backend_data;
-        backend_data.base = pf;
+        backend_data.base = phys;
         backend_data.frames = pages;
         
@@ -129 +130 @@
         btree_node_t *nodep;
         parea_t *parea = (parea_t *) btree_search(&parea_btree,
-            (btree_key_t) pf, &nodep);
+            (btree_key_t) phys, &nodep);
         
         if ((parea != NULL) && (parea->frames >= pages)) {
@@ -149 +150 @@
         
         irq_spinlock_lock(&zones.lock, true);
-        size_t znum = find_zone(ADDR2PFN(pf), pages, 0);
+        size_t znum = find_zone(ADDR2PFN(phys), pages, 0);
         
         if (znum == (size_t) -1) {
@@ -165 +166 @@
         }
         
-        if (zones.info[znum].flags & ZONE_FIRMWARE) {
-                /*
-                 * Frames are part of firmware
+        if (zones.info[znum].flags & (ZONE_FIRMWARE | ZONE_RESERVED)) {
+                /*
+                 * Frames are part of firmware or reserved zone
                  * -> allow mapping for privileged tasks.
                  */
@@ -182 +183 @@
         
 map:
-        if (!as_area_create(TASK->as, flags, pages * PAGE_SIZE, vp,
-            AS_AREA_ATTR_NONE, &phys_backend, &backend_data)) {
+        if (!as_area_create(TASK->as, flags, FRAMES2SIZE(pages),
+            AS_AREA_ATTR_NONE, &phys_backend, &backend_data, virt, bound)) {
                 /*
                  * The address space area was not created.
@@ -207 +208 @@
 }
 
+NO_TRACE static int physmem_unmap(uintptr_t virt)
+{
+        // TODO: implement unmap
+        return EOK;
+}
+
+/** Wrapper for SYS_PHYSMEM_MAP syscall.
+ *
+ * @param phys     Physical base address to map
+ * @param pages    Number of pages
+ * @param flags    Flags of newly mapped pages
+ * @param virt_ptr Destination virtual address
+ * @param bound    Lowest virtual address bound.
+ *
+ * @return 0 on success, otherwise it returns error code found in errno.h
+ *
+ */
+sysarg_t sys_physmem_map(uintptr_t phys, size_t pages, unsigned int flags,
+    void *virt_ptr, uintptr_t bound)
+{
+        uintptr_t virt = (uintptr_t) -1;
+        int rc = physmem_map(ALIGN_DOWN(phys, FRAME_SIZE), pages, flags,
+            &virt, bound);
+        if (rc != EOK)
+                return rc;
+        
+        rc = copy_to_uspace(virt_ptr, &virt, sizeof(virt));
+        if (rc != EOK) {
+                physmem_unmap((uintptr_t) virt);
+                return rc;
+        }
+        
+        return EOK;
+}
+
+sysarg_t sys_physmem_unmap(uintptr_t virt)
+{
+        return physmem_unmap(virt);
+}
+
 /** Enable range of I/O space for task.
  *
@@ -217 +258 @@
  *
  */
-NO_TRACE static int ddi_iospace_enable(task_id_t id, uintptr_t ioaddr,
-    size_t size)
+NO_TRACE static int iospace_enable(task_id_t id, uintptr_t ioaddr, size_t size)
 {
         /*
@@ -243 +283 @@
         /* Lock the task and release the lock protecting tasks_btree. */
         irq_spinlock_exchange(&tasks_lock, &task->lock);
-        
         int rc = ddi_iospace_enable_arch(task, ioaddr, size);
-        
         irq_spinlock_unlock(&task->lock, true);
         
         return rc;
-}
-
-/** Wrapper for SYS_PHYSMEM_MAP syscall.
- *
- * @param phys_base Physical base address to map
- * @param virt_base Destination virtual address
- * @param pages Number of pages
- * @param flags Flags of newly mapped pages
- *
- * @return 0 on success, otherwise it returns error code found in errno.h
- *
- */
-sysarg_t sys_physmem_map(sysarg_t phys_base, sysarg_t virt_base,
-    sysarg_t pages, sysarg_t flags)
-{
-        return (sysarg_t) ddi_physmem_map(ALIGN_DOWN((uintptr_t) phys_base,
-            FRAME_SIZE), ALIGN_DOWN((uintptr_t) virt_base, PAGE_SIZE),
-            (size_t) pages, (int) flags);
 }
 
@@ -283 +303 @@
                 return (sysarg_t) rc;
         
-        return (sysarg_t) ddi_iospace_enable((task_id_t) arg.task_id,
+        return (sysarg_t) iospace_enable((task_id_t) arg.task_id,
             (uintptr_t) arg.ioaddr, (size_t) arg.size);
 }
 
+sysarg_t sys_iospace_disable(ddi_ioarg_t *uspace_io_arg)
+{
+        // TODO: implement
+        return ENOTSUP;
+}
+
+NO_TRACE static int dmamem_map(uintptr_t virt, size_t size, unsigned int map_flags,
+    unsigned int flags, void **phys)
+{
+        ASSERT(TASK);
+        
+        // TODO: implement locking of non-anonymous mapping
+        return page_find_mapping(virt, phys);
+}
+
+NO_TRACE static int dmamem_map_anonymous(size_t size, unsigned int map_flags,
+    unsigned int flags, void **phys, uintptr_t *virt, uintptr_t bound)
+{
+        ASSERT(TASK);
+        
+        size_t pages = SIZE2FRAMES(size);
+        uint8_t order;
+        
+        /* We need the 2^order >= pages */
+        if (pages == 1)
+                order = 0;
+        else
+                order = fnzb(pages - 1) + 1;
+        
+        *phys = frame_alloc_noreserve(order, 0);
+        if (*phys == NULL)
+                return ENOMEM;
+        
+        mem_backend_data_t backend_data;
+        backend_data.base = (uintptr_t) *phys;
+        backend_data.frames = pages;
+        
+        if (!as_area_create(TASK->as, map_flags, size,
+            AS_AREA_ATTR_NONE, &phys_backend, &backend_data, virt, bound)) {
+                frame_free_noreserve((uintptr_t) *phys);
+                return ENOMEM;
+        }
+        
+        return EOK;
+}
+
+NO_TRACE static int dmamem_unmap(uintptr_t virt, size_t size)
+{
+        // TODO: implement unlocking & unmap
+        return EOK;
+}
+
+NO_TRACE static int dmamem_unmap_anonymous(uintptr_t virt)
+{
+        // TODO: implement unlocking & unmap
+        return EOK;
+}
+
+sysarg_t sys_dmamem_map(size_t size, unsigned int map_flags, unsigned int flags,
+    void *phys_ptr, void *virt_ptr, uintptr_t bound)
+{
+        if ((flags & DMAMEM_FLAGS_ANONYMOUS) == 0) {
+                /*
+                 * Non-anonymous DMA mapping
+                 */
+                
+                void *phys;
+                int rc = dmamem_map((uintptr_t) virt_ptr, size, map_flags,
+                    flags, &phys);
+                
+                if (rc != EOK)
+                        return rc;
+                
+                rc = copy_to_uspace(phys_ptr, &phys, sizeof(phys));
+                if (rc != EOK) {
+                        dmamem_unmap((uintptr_t) virt_ptr, size);
+                        return rc;
+                }
+        } else {
+                /*
+                 * Anonymous DMA mapping
+                 */
+                
+                void *phys;
+                uintptr_t virt = (uintptr_t) -1;
+                int rc = dmamem_map_anonymous(size, map_flags, flags,
+                    &phys, &virt, bound);
+                if (rc != EOK)
+                        return rc;
+                
+                rc = copy_to_uspace(phys_ptr, &phys, sizeof(phys));
+                if (rc != EOK) {
+                        dmamem_unmap_anonymous((uintptr_t) virt);
+                        return rc;
+                }
+                
+                rc = copy_to_uspace(virt_ptr, &virt, sizeof(virt));
+                if (rc != EOK) {
+                        dmamem_unmap_anonymous((uintptr_t) virt);
+                        return rc;
+                }
+        }
+        
+        return EOK;
+}
+
+sysarg_t sys_dmamem_unmap(uintptr_t virt, size_t size, unsigned int flags)
+{
+        if ((flags & DMAMEM_FLAGS_ANONYMOUS) == 0)
+                return dmamem_unmap(virt, size);
+        else
+                return dmamem_unmap_anonymous(virt);
+}
+
 /** @}
  */

kernel/generic/src/ipc/irq.c

@@ -42 +42 @@
  *
  * The structure of a notification message is as follows:
- * - IMETHOD: interface and method as registered by the SYS_REGISTER_IRQ
- *            syscall
+ * - IMETHOD: interface and method as registered by
+ *            the SYS_IRQ_REGISTER syscall
  * - ARG1: payload modified by a 'top-half' handler
  * - ARG2: payload modified by a 'top-half' handler
@@ -74 +74 @@
 #include <arch.h>
 #include <mm/slab.h>
+#include <mm/page.h>
+#include <mm/km.h>
 #include <errno.h>
 #include <ddi/irq.h>
@@ -81 +83 @@
 #include <console/console.h>
 #include <print.h>
+#include <macros.h>
+
+static void ranges_unmap(irq_pio_range_t *ranges, size_t rangecount)
+{
+        size_t i;
+
+        for (i = 0; i < rangecount; i++) {
+#ifdef IO_SPACE_BOUNDARY
+                if ((void *) ranges[i].base >= IO_SPACE_BOUNDARY)
+#endif
+                        km_unmap(ranges[i].base, ranges[i].size);
+        }
+}
+
+static int ranges_map_and_apply(irq_pio_range_t *ranges, size_t rangecount,
+    irq_cmd_t *cmds, size_t cmdcount)
+{
+        uintptr_t *pbase;
+        size_t i, j;
+
+        /* Copy the physical base addresses aside. */
+        pbase = malloc(rangecount * sizeof(uintptr_t), 0);
+        for (i = 0; i < rangecount; i++)
+                pbase[i] = ranges[i].base;
+
+        /* Map the PIO ranges into the kernel virtual address space. */
+        for (i = 0; i < rangecount; i++) {
+#ifdef IO_SPACE_BOUNDARY
+                if ((void *) ranges[i].base < IO_SPACE_BOUNDARY)
+                        continue;
+#endif
+                ranges[i].base = km_map(pbase[i], ranges[i].size,
+                    PAGE_READ | PAGE_WRITE | PAGE_KERNEL | PAGE_NOT_CACHEABLE);
+                if (!ranges[i].base) {
+                        ranges_unmap(ranges, i);
+                        free(pbase);
+                        return ENOMEM;
+                }
+        }
+
+        /* Rewrite the pseudocode addresses from physical to kernel virtual. */
+        for (i = 0; i < cmdcount; i++) {
+                uintptr_t addr;
+                size_t size;
+
+                /* Process only commands that use an address. */
+                switch (cmds[i].cmd) {
+                case CMD_PIO_READ_8:
+                case CMD_PIO_WRITE_8:
+                case CMD_PIO_WRITE_A_8:
+                        size = 1;
+                        break;
+                case CMD_PIO_READ_16:
+                case CMD_PIO_WRITE_16:
+                case CMD_PIO_WRITE_A_16:
+                        size = 2;
+                        break;
+                case CMD_PIO_READ_32:
+                case CMD_PIO_WRITE_32:
+                case CMD_PIO_WRITE_A_32:
+                        size = 4;
+                        break;
+                default:
+                        /* Move onto the next command. */
+                        continue;
+                }
+
+                addr = (uintptr_t) cmds[i].addr;
+                
+                for (j = 0; j < rangecount; j++) {
+
+                        /* Find the matching range. */
+                        if (!iswithin(pbase[j], ranges[j].size, addr, size))
+                                continue;
+
+                        /* Switch the command to a kernel virtual address. */
+                        addr -= pbase[j];
+                        addr += ranges[j].base;
+
+                        cmds[i].addr = (void *) addr;
+                        break;
+                }
+
+                if (j == rangecount) {
+                        /*
+                         * The address used in this command is outside of all
+                         * defined ranges.
+                         */
+                        ranges_unmap(ranges, rangecount);
+                        free(pbase);
+                        return EINVAL;
+                }
+        }
+
+        free(pbase);
+        return EOK;
+}
 
 /** Free the top-half pseudocode.
@@ -90 +189 @@
 {
         if (code) {
+                ranges_unmap(code->ranges, code->rangecount);
+                free(code->ranges);
                 free(code->cmds);
                 free(code);
@@ -104 +205 @@
 static irq_code_t *code_from_uspace(irq_code_t *ucode)
 {
+        irq_pio_range_t *ranges = NULL;
+        irq_cmd_t *cmds = NULL;
+
         irq_code_t *code = malloc(sizeof(*code), 0);
         int rc = copy_from_uspace(code, ucode, sizeof(*code));
-        if (rc != 0) {
-                free(code);
-                return NULL;
-        }
-        
-        if (code->cmdcount > IRQ_MAX_PROG_SIZE) {
-                free(code);
-                return NULL;
-        }
-        
-        irq_cmd_t *ucmds = code->cmds;
-        code->cmds = malloc(sizeof(code->cmds[0]) * code->cmdcount, 0);
-        rc = copy_from_uspace(code->cmds, ucmds,
+        if (rc != EOK)
+                goto error;
+        
+        if ((code->rangecount > IRQ_MAX_RANGE_COUNT) ||
+            (code->cmdcount > IRQ_MAX_PROG_SIZE))
+                goto error;
+        
+        ranges = malloc(sizeof(code->ranges[0]) * code->rangecount, 0);
+        rc = copy_from_uspace(ranges, code->ranges,
+            sizeof(code->ranges[0]) * code->rangecount);
+        if (rc != EOK)
+                goto error;
+
+        cmds = malloc(sizeof(code->cmds[0]) * code->cmdcount, 0);
+        rc = copy_from_uspace(cmds, code->cmds,
             sizeof(code->cmds[0]) * code->cmdcount);
-        if (rc != 0) {
-                free(code->cmds);
-                free(code);
-                return NULL;
-        }
-        
+        if (rc != EOK)
+                goto error;
+
+        rc = ranges_map_and_apply(ranges, code->rangecount, cmds,
+            code->cmdcount);
+        if (rc != EOK)
+                goto error;
+
+        code->ranges = ranges;
+        code->cmds = cmds;
+
         return code;
+
+error:
+        if (cmds)
+                free(cmds);
+        if (ranges)
+                free(ranges);
+        free(code);
+        return NULL;
 }
 
@@ -174 +293 @@
         irq->notif_cfg.code = code;
         irq->notif_cfg.counter = 0;
-        irq->driver_as = AS;
         
         /*
@@ -239 +357 @@
         
         ASSERT(irq->notif_cfg.answerbox == box);
-        
-        /* Free up the pseudo code and associated structures. */
-        code_free(irq->notif_cfg.code);
         
         /* Remove the IRQ from the answerbox's list. */
@@ -260 +375 @@
         irq_spinlock_unlock(&box->irq_lock, false);
         irq_spinlock_unlock(&irq_uspace_hash_table_lock, true);
+        
+        /* Free up the pseudo code and associated structures. */
+        code_free(irq->notif_cfg.code);
         
         /* Free up the IRQ structure. */
@@ -307 +425 @@
                 list_remove(&irq->notif_cfg.link);
                 
-                /* Free up the pseudo code and associated structures. */
-                code_free(irq->notif_cfg.code);
-                
                 /*
                  * We need to drop the IRQ lock now because hash_table_remove()
@@ -321 +436 @@
                 /* Remove from the hash table. */
                 hash_table_remove(&irq_uspace_hash_table, key, 2);
-                
+
+                /*
+                 * Release both locks so that we can free the pseudo code.
+                 */
+                irq_spinlock_unlock(&box->irq_lock, false);
+                irq_spinlock_unlock(&irq_uspace_hash_table_lock, true);
+
+                code_free(irq->notif_cfg.code);
                 free(irq);
+                
+                /* Reacquire both locks before taking another round. */
+                irq_spinlock_lock(&irq_uspace_hash_table_lock, true);
+                irq_spinlock_lock(&box->irq_lock, false);
         }
         
@@ -365 +491 @@
                 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++) {
+        for (size_t i = 0; i < code->cmdcount; i++) {
                 uint32_t dstval;
+                
                 uintptr_t srcarg = code->cmds[i].srcarg;
                 uintptr_t dstarg = code->cmds[i].dstarg;
@@ -442 +549 @@
                         }
                         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)) {
@@ -503 +562 @@
                         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/sysipc.c

@@ -271 +271 @@
                         irq_spinlock_unlock(&answer->sender->lock, true);
                         
+                        uintptr_t dst_base = (uintptr_t) -1;
                         int rc = as_area_share(as, IPC_GET_ARG1(*olddata),
-                            IPC_GET_ARG2(*olddata), AS,
-                            IPC_GET_ARG1(answer->data), IPC_GET_ARG3(*olddata));
+                            IPC_GET_ARG2(*olddata), AS, IPC_GET_ARG3(*olddata),
+                            &dst_base, IPC_GET_ARG1(answer->data));
+                        
+                        if (rc == EOK)
+                                rc = copy_to_uspace((void *) IPC_GET_ARG2(answer->data),
+                                    &dst_base, sizeof(dst_base));
+                        
                         IPC_SET_RETVAL(answer->data, rc);
                         return rc;
                 }
         } else if (IPC_GET_IMETHOD(*olddata) == IPC_M_SHARE_IN) {
-                if (!IPC_GET_RETVAL(answer->data)) { 
+                if (!IPC_GET_RETVAL(answer->data)) {
                         irq_spinlock_lock(&answer->sender->lock, true);
                         as_t *as = answer->sender->as;
                         irq_spinlock_unlock(&answer->sender->lock, true);
                         
+                        uintptr_t dst_base = (uintptr_t) -1;
                         int rc = as_area_share(AS, IPC_GET_ARG1(answer->data),
-                            IPC_GET_ARG2(*olddata), as, IPC_GET_ARG1(*olddata),
-                            IPC_GET_ARG2(answer->data));
+                            IPC_GET_ARG1(*olddata), as, IPC_GET_ARG2(answer->data),
+                            &dst_base, IPC_GET_ARG3(answer->data));
+                        IPC_SET_ARG4(answer->data, dst_base);
                         IPC_SET_RETVAL(answer->data, rc);
                 }
@@ -1185 +1193 @@
  *
  */
-sysarg_t sys_register_irq(inr_t inr, devno_t devno, sysarg_t imethod,
+sysarg_t sys_irq_register(inr_t inr, devno_t devno, sysarg_t imethod,
     irq_code_t *ucode)
 {
@@ -1202 +1210 @@
  *
  */
-sysarg_t sys_unregister_irq(inr_t inr, devno_t devno)
+sysarg_t sys_irq_unregister(inr_t inr, devno_t devno)
 {
         if (!(cap_get(TASK) & CAP_IRQ_REG))

kernel/generic/src/lib/elf.c

@@ -226 +226 @@
         size_t mem_sz = entry->p_memsz + (entry->p_vaddr - base);
         
-        as_area_t *area = as_area_create(as, flags, mem_sz, base,
-            AS_AREA_ATTR_NONE, &elf_backend, &backend_data);
+        as_area_t *area = as_area_create(as, flags, mem_sz,
+            AS_AREA_ATTR_NONE, &elf_backend, &backend_data, &base, 0);
         if (!area)
                 return EE_MEMORY;

kernel/generic/src/lib/func.c

@@ -53 +53 @@
 void halt()
 {
-#ifdef CONFIG_DEBUG
+#if (defined(CONFIG_DEBUG)) && (defined(CONFIG_KCONSOLE))
         bool rundebugger = false;
         

kernel/generic/src/lib/rd.c

@@ -33 +33 @@
 /**
  * @file
- * @brief       RAM disk support.
+ * @brief RAM disk support.
  *
  * Support for RAM disk images.
@@ -39 +39 @@
 
 #include <lib/rd.h>
-#include <byteorder.h>
 #include <mm/frame.h>
 #include <sysinfo/sysinfo.h>
 #include <ddi/ddi.h>
-#include <align.h>
 
-static parea_t rd_parea;                /**< Physical memory area for rd. */
+/** Physical memory area for RAM disk. */
+static parea_t rd_parea;
 
-/**
- * RAM disk initialization routine. At this point, the RAM disk memory is shared
- * and information about the share is provided as sysinfo values to the
- * userspace tasks.
- */  
-int init_rd(rd_header_t *header, size_t size)
+/** RAM disk initialization routine
+ *
+ * The information about the RAM disk is provided as sysinfo
+ * values to the uspace tasks.
+ *
+ */
+void init_rd(void *data, size_t size)
 {
-        /* Identify RAM disk */
-        if ((header->magic[0] != RD_MAG0) || (header->magic[1] != RD_MAG1) ||
-            (header->magic[2] != RD_MAG2) || (header->magic[3] != RD_MAG3))
-                return RE_INVALID;
+        uintptr_t base = (uintptr_t) data;
+        ASSERT((base % FRAME_SIZE) == 0);
         
-        /* Identify version */  
-        if (header->version != RD_VERSION)
-                return RE_UNSUPPORTED;
-        
-        uint32_t hsize;
-        uint64_t dsize;
-        switch (header->data_type) {
-        case RD_DATA_LSB:
-                hsize = uint32_t_le2host(header->header_size);
-                dsize = uint64_t_le2host(header->data_size);
-                break;
-        case RD_DATA_MSB:
-                hsize = uint32_t_be2host(header->header_size);
-                dsize = uint64_t_be2host(header->data_size);
-                break;
-        default:
-                return RE_UNSUPPORTED;
-        }
-        
-        if ((hsize % FRAME_SIZE) || (dsize % FRAME_SIZE))
-                return RE_UNSUPPORTED;
-                
-        if (hsize > size)
-                return RE_INVALID;
-        
-        if ((uint64_t) hsize + dsize > size)
-                dsize = size - hsize;
-        
-        rd_parea.pbase = ALIGN_DOWN((uintptr_t) KA2PA((void *) header + hsize),
-            FRAME_SIZE);
-        rd_parea.frames = SIZE2FRAMES(dsize);
+        rd_parea.pbase = base;
+        rd_parea.frames = SIZE2FRAMES(size);
         rd_parea.unpriv = false;
         rd_parea.mapped = false;
         ddi_parea_register(&rd_parea);
-
+        
         sysinfo_set_item_val("rd", NULL, true);
-        sysinfo_set_item_val("rd.header_size", NULL, hsize);    
-        sysinfo_set_item_val("rd.size", NULL, dsize);
-        sysinfo_set_item_val("rd.address.physical", NULL,
-            (sysarg_t) KA2PA((void *) header + hsize));
-
-        return RE_OK;
+        sysinfo_set_item_val("rd.size", NULL, size);
+        sysinfo_set_item_val("rd.address.physical", NULL, (sysarg_t) base);
 }
 

kernel/generic/src/lib/str.c

@@ -111 +111 @@
 #include <debug.h>
 #include <macros.h>
+
+/** Check the condition if wchar_t is signed */
+#ifdef WCHAR_IS_UNSIGNED
+        #define WCHAR_SIGNED_CHECK(cond)  (true)
+#else
+        #define WCHAR_SIGNED_CHECK(cond)  (cond)
+#endif
 
 /** Byte mask consisting of lowest @n bits (out of 8) */
@@ -206 +213 @@
  *
  * @return EOK if the character was encoded successfully, EOVERFLOW if there
- *         was not enough space in the output buffer or EINVAL if the character
- *         code was invalid.
- */
-int chr_encode(wchar_t ch, char *str, size_t *offset, size_t size)
+ *         was not enough space in the output buffer or EINVAL if the character
+ *         code was invalid.
+ */
+int chr_encode(const wchar_t ch, char *str, size_t *offset, size_t size)
 {
         if (*offset >= size)
@@ -427 +434 @@
 bool ascii_check(wchar_t ch)
 {
-        if ((ch >= 0) && (ch <= 127))
+        if (WCHAR_SIGNED_CHECK(ch >= 0) && (ch <= 127))
                 return true;
         
@@ -440 +447 @@
 bool chr_check(wchar_t ch)
 {
-        if ((ch >= 0) && (ch <= 1114111))
+        if (WCHAR_SIGNED_CHECK(ch >= 0) && (ch <= 1114111))
                 return true;
         
@@ -893 +900 @@
  *
  */
-int str_uint64(const char *nptr, char **endptr, unsigned int base,
+int str_uint64_t(const char *nptr, char **endptr, unsigned int base,
     bool strict, uint64_t *result)
 {

kernel/generic/src/main/kinit.c

@@ -57 +57 @@
 #include <mm/as.h>
 #include <mm/frame.h>
+#include <mm/km.h>
 #include <print.h>
 #include <memstr.h>
@@ -68 +69 @@
 #include <str.h>
 #include <sysinfo/stats.h>
+#include <align.h>
 
 #ifdef CONFIG_SMP
@@ -178 +180 @@
         
         for (i = 0; i < init.cnt; i++) {
-                if (init.tasks[i].addr % FRAME_SIZE) {
-                        printf("init[%zu].addr is not frame aligned\n", i);
+                if (init.tasks[i].paddr % FRAME_SIZE) {
+                        printf("init[%zu]: Address is not frame aligned\n", i);
                         programs[i].task = NULL;
                         continue;
@@ -199 +201 @@
                 str_cpy(namebuf + INIT_PREFIX_LEN,
                     TASK_NAME_BUFLEN - INIT_PREFIX_LEN, name);
-                
-                int rc = program_create_from_image((void *) init.tasks[i].addr,
-                    namebuf, &programs[i]);
-                
-                if ((rc == 0) && (programs[i].task != NULL)) {
+
+                /*
+                 * Create virtual memory mappings for init task images.
+                 */
+                uintptr_t page = km_map(init.tasks[i].paddr,
+                    init.tasks[i].size,
+                    PAGE_READ | PAGE_WRITE | PAGE_CACHEABLE);
+                ASSERT(page);
+                
+                int rc = program_create_from_image((void *) page, namebuf,
+                    &programs[i]);
+                
+                if (rc == 0) {
+                        if (programs[i].task != NULL) {
+                                /*
+                                 * Set capabilities to init userspace tasks.
+                                 */
+                                cap_set(programs[i].task, CAP_CAP | CAP_MEM_MANAGER |
+                                    CAP_IO_MANAGER | CAP_IRQ_REG);
+                                
+                                if (!ipc_phone_0)
+                                        ipc_phone_0 = &programs[i].task->answerbox;
+                        }
+                        
                         /*
-                         * Set capabilities to init userspace tasks.
+                         * If programs[i].task == NULL then it is
+                         * the program loader and it was registered
+                         * successfully.
                          */
-                        cap_set(programs[i].task, CAP_CAP | CAP_MEM_MANAGER |
-                            CAP_IO_MANAGER | CAP_IRQ_REG);
-                        
-                        if (!ipc_phone_0)
-                                ipc_phone_0 = &programs[i].task->answerbox;
-                } else if (rc == 0) {
-                        /* It was the program loader and was registered */
-                } else {
-                        /* RAM disk image */
-                        int rd = init_rd((rd_header_t *) init.tasks[i].addr, init.tasks[i].size);
-                        
-                        if (rd != RE_OK)
-                                printf("Init binary %zu not used (error %d)\n", i, rd);
-                }
+                } else if (i == init.cnt - 1) {
+                        /*
+                         * Assume the last task is the RAM disk.
+                         */
+                        init_rd((void *) init.tasks[i].paddr, init.tasks[i].size);
+                } else
+                        printf("init[%zu]: Init binary load failed (error %d)\n", i, rc);
         }
         

kernel/generic/src/main/main.c

@@ -68 +68 @@
 #include <mm/page.h>
 #include <genarch/mm/page_pt.h>
+#include <mm/km.h>
 #include <mm/tlb.h>
 #include <mm/as.h>
@@ -86 +87 @@
 #include <sysinfo/sysinfo.h>
 #include <sysinfo/stats.h>
+#include <lib/ra.h>
 
 /** Global configuration structure. */
-config_t config;
+config_t config = {
+        .identity_configured = false,
+        .non_identity_configured = false,
+        .physmem_end = 0
+};
 
 /** Initial user-space tasks */
@@ -145 +151 @@
         size_t i;
         for (i = 0; i < init.cnt; i++) {
-                if (PA_OVERLAPS(config.stack_base, config.stack_size,
-                    init.tasks[i].addr, init.tasks[i].size))
-                        config.stack_base = ALIGN_UP(init.tasks[i].addr +
-                            init.tasks[i].size, config.stack_size);
+                if (overlaps(KA2PA(config.stack_base), config.stack_size,
+                    init.tasks[i].paddr, init.tasks[i].size)) {
+                        /*
+                         * The init task overlaps with the memory behind the
+                         * kernel image so it must be in low memory and we can
+                         * use PA2KA on the init task's physical address.
+                         */
+                        config.stack_base = ALIGN_UP(
+                            PA2KA(init.tasks[i].paddr) + init.tasks[i].size,
+                            config.stack_size);
+                }
         }
         
@@ -205 +218 @@
          */
         arch_pre_mm_init();
+        km_identity_init();
         frame_init();
-        
-        /* Initialize at least 1 memory segment big enough for slab to work. */
         slab_cache_init();
+        ra_init();
         sysinfo_init();
         btree_init();
@@ -214 +227 @@
         page_init();
         tlb_init();
+        km_non_identity_init();
         ddi_init();
         arch_post_mm_init();
@@ -243 +257 @@
                 for (i = 0; i < init.cnt; i++)
                         LOG("init[%zu].addr=%p, init[%zu].size=%zu",
-                            i, (void *) init.tasks[i].addr, i, init.tasks[i].size);
+                            i, (void *) init.tasks[i].paddr, i, init.tasks[i].size);
         } else
                 printf("No init binaries found.\n");
@@ -262 +276 @@
          * Create the first thread.
          */
-        thread_t *kinit_thread
-                = thread_create(kinit, NULL, kernel, 0, "kinit", true);
+        thread_t *kinit_thread =
+            thread_create(kinit, NULL, kernel, 0, "kinit", true);
         if (!kinit_thread)
                 panic("Cannot create kinit thread.");

kernel/generic/src/main/version.c

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

kernel/generic/src/mm/as.c

@@ -387 +387 @@
 }
 
+/** Return pointer to unmapped address space area
+ *
+ * The address space must be already locked when calling
+ * this function.
+ *
+ * @param as    Address space.
+ * @param bound Lowest address bound.
+ * @param size  Requested size of the allocation.
+ *
+ * @return Address of the beginning of unmapped address space area.
+ * @return -1 if no suitable address space area was found.
+ *
+ */
+NO_TRACE static uintptr_t as_get_unmapped_area(as_t *as, uintptr_t bound,
+    size_t size)
+{
+        ASSERT(mutex_locked(&as->lock));
+        
+        if (size == 0)
+                return (uintptr_t) -1;
+        
+        /*
+         * Make sure we allocate from page-aligned
+         * address. Check for possible overflow in
+         * each step.
+         */
+        
+        size_t pages = SIZE2FRAMES(size);
+        
+        /*
+         * Find the lowest unmapped address aligned on the size
+         * boundary, not smaller than bound and of the required size.
+         */
+        
+        /* First check the bound address itself */
+        uintptr_t addr = ALIGN_UP(bound, PAGE_SIZE);
+        if ((addr >= bound) &&
+            (check_area_conflicts(as, addr, pages, NULL)))
+                return addr;
+        
+        /* Eventually check the addresses behind each area */
+        list_foreach(as->as_area_btree.leaf_list, cur) {
+                btree_node_t *node =
+                    list_get_instance(cur, btree_node_t, leaf_link);
+                
+                for (btree_key_t i = 0; i < node->keys; i++) {
+                        as_area_t *area = (as_area_t *) node->value[i];
+                        
+                        mutex_lock(&area->lock);
+                        
+                        addr =
+                            ALIGN_UP(area->base + P2SZ(area->pages), PAGE_SIZE);
+                        bool avail =
+                            ((addr >= bound) && (addr >= area->base) &&
+                            (check_area_conflicts(as, addr, pages, area)));
+                        
+                        mutex_unlock(&area->lock);
+                        
+                        if (avail)
+                                return addr;
+                }
+        }
+        
+        /* No suitable address space area found */
+        return (uintptr_t) -1;
+}
+
 /** Create address space area of common attributes.
  *
@@ -394 +461 @@
  * @param flags        Flags of the area memory.
  * @param size         Size of area.
- * @param base         Base address of area.
  * @param attrs        Attributes of the area.
  * @param backend      Address space area backend. NULL if no backend is used.
  * @param backend_data NULL or a pointer to an array holding two void *.
+ * @param base         Starting virtual address of the area.
+ *                     If set to -1, a suitable mappable area is found.
+ * @param bound        Lowest address bound if base is set to -1.
+ *                     Otherwise ignored.
  *
  * @return Address space area on success or NULL on failure.
@@ -403 +473 @@
  */
 as_area_t *as_area_create(as_t *as, unsigned int flags, size_t size,
-    uintptr_t base, unsigned int attrs, mem_backend_t *backend,
-    mem_backend_data_t *backend_data)
-{
-        if ((base % PAGE_SIZE) != 0)
+    unsigned int attrs, mem_backend_t *backend,
+    mem_backend_data_t *backend_data, uintptr_t *base, uintptr_t bound)
+{
+        if ((*base != (uintptr_t) -1) && ((*base % PAGE_SIZE) != 0))
                 return NULL;
         
@@ -420 +490 @@
         mutex_lock(&as->lock);
         
-        if (!check_area_conflicts(as, base, pages, NULL)) {
+        if (*base == (uintptr_t) -1) {
+                *base = as_get_unmapped_area(as, bound, size);
+                if (*base == (uintptr_t) -1) {
+                        mutex_unlock(&as->lock);
+                        return NULL;
+                }
+        }
+        
+        if (!check_area_conflicts(as, *base, pages, NULL)) {
                 mutex_unlock(&as->lock);
                 return NULL;
@@ -434 +512 @@
         area->pages = pages;
         area->resident = 0;
-        area->base = base;
+        area->base = *base;
         area->sh_info = NULL;
         area->backend = backend;
@@ -452 +530 @@
         
         btree_create(&area->used_space);
-        btree_insert(&as->as_area_btree, base, (void *) area, NULL);
+        btree_insert(&as->as_area_btree, *base, (void *) area,
+            NULL);
         
         mutex_unlock(&as->lock);
@@ -860 +939 @@
  * @param acc_size       Expected size of the source area.
  * @param dst_as         Pointer to destination address space.
- * @param dst_base       Target base address.
  * @param dst_flags_mask Destination address space area flags mask.
+ * @param dst_base       Target base address. If set to -1,
+ *                       a suitable mappable area is found.
+ * @param bound          Lowest address bound if dst_base is set to -1.
+ *                       Otherwise ignored.
  *
  * @return Zero on success.
@@ -873 +955 @@
  */
 int as_area_share(as_t *src_as, uintptr_t src_base, size_t acc_size,
-    as_t *dst_as, uintptr_t dst_base, unsigned int dst_flags_mask)
+    as_t *dst_as, unsigned int dst_flags_mask, uintptr_t *dst_base,
+    uintptr_t bound)
 {
         mutex_lock(&src_as->lock);
@@ -945 +1028 @@
          * to support sharing in less privileged mode.
          */
-        as_area_t *dst_area = as_area_create(dst_as, dst_flags_mask, src_size,
-            dst_base, AS_AREA_ATTR_PARTIAL, src_backend, &src_backend_data);
+        as_area_t *dst_area = as_area_create(dst_as, dst_flags_mask,
+            src_size, AS_AREA_ATTR_PARTIAL, src_backend,
+            &src_backend_data, dst_base, bound);
         if (!dst_area) {
                 /*
@@ -1955 +2039 @@
  */
 
-/** Wrapper for as_area_create(). */
-sysarg_t sys_as_area_create(uintptr_t address, size_t size, unsigned int flags)
-{
-        if (as_area_create(AS, flags | AS_AREA_CACHEABLE, size, address,
-            AS_AREA_ATTR_NONE, &anon_backend, NULL))
-                return (sysarg_t) address;
-        else
+sysarg_t sys_as_area_create(uintptr_t base, size_t size, unsigned int flags,
+    uintptr_t bound)
+{
+        uintptr_t virt = base;
+        as_area_t *area = as_area_create(AS, flags | AS_AREA_CACHEABLE, size,
+            AS_AREA_ATTR_NONE, &anon_backend, NULL, &virt, bound);
+        if (area == NULL)
                 return (sysarg_t) -1;
-}
-
-/** Wrapper for as_area_resize(). */
+        
+        return (sysarg_t) virt;
+}
+
 sysarg_t sys_as_area_resize(uintptr_t address, size_t size, unsigned int flags)
 {
@@ -1971 +2056 @@
 }
 
-/** Wrapper for as_area_change_flags(). */
 sysarg_t sys_as_area_change_flags(uintptr_t address, unsigned int flags)
 {
@@ -1977 +2061 @@
 }
 
-/** Wrapper for as_area_destroy(). */
 sysarg_t sys_as_area_destroy(uintptr_t address)
 {
         return (sysarg_t) as_area_destroy(AS, address);
-}
-
-/** Return pointer to unmapped address space area
- *
- * @param base Lowest address bound.
- * @param size Requested size of the allocation.
- *
- * @return Pointer to the beginning of unmapped address space area.
- *
- */
-sysarg_t sys_as_get_unmapped_area(uintptr_t base, size_t size)
-{
-        if (size == 0)
-                return 0;
-        
-        /*
-         * Make sure we allocate from page-aligned
-         * address. Check for possible overflow in
-         * each step.
-         */
-        
-        size_t pages = SIZE2FRAMES(size);
-        uintptr_t ret = 0;
-        
-        /*
-         * Find the lowest unmapped address aligned on the sz
-         * boundary, not smaller than base and of the required size.
-         */
-        
-        mutex_lock(&AS->lock);
-        
-        /* First check the base address itself */
-        uintptr_t addr = ALIGN_UP(base, PAGE_SIZE);
-        if ((addr >= base) &&
-            (check_area_conflicts(AS, addr, pages, NULL)))
-                ret = addr;
-        
-        /* Eventually check the addresses behind each area */
-        list_foreach(AS->as_area_btree.leaf_list, cur) {
-                if (ret != 0)
-                        break;
-
-                btree_node_t *node =
-                    list_get_instance(cur, btree_node_t, leaf_link);
-                
-                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);
-                        
-                        addr = ALIGN_UP(area->base + P2SZ(area->pages),
-                            PAGE_SIZE);
-                        
-                        if ((addr >= base) && (addr >= area->base) &&
-                            (check_area_conflicts(AS, addr, pages, area)))
-                                ret = addr;
-                        
-                        mutex_unlock(&area->lock);
-                }
-        }
-        
-        mutex_unlock(&AS->lock);
-        
-        return (sysarg_t) ret;
 }
 

kernel/generic/src/mm/backend_anon.c

@@ -44 +44 @@
 #include <mm/frame.h>
 #include <mm/slab.h>
+#include <mm/km.h>
 #include <synch/mutex.h>
 #include <adt/list.h>
@@ -155 +156 @@
 int anon_page_fault(as_area_t *area, uintptr_t addr, pf_access_t access)
 {
+        uintptr_t upage = ALIGN_DOWN(addr, PAGE_SIZE);
+        uintptr_t kpage;
         uintptr_t frame;
 
@@ -175 +178 @@
                 mutex_lock(&area->sh_info->lock);
                 frame = (uintptr_t) btree_search(&area->sh_info->pagemap,
-                    ALIGN_DOWN(addr, PAGE_SIZE) - area->base, &leaf);
+                    upage - area->base, &leaf);
                 if (!frame) {
                         bool allocate = true;
@@ -185 +188 @@
                          */
                         for (i = 0; i < leaf->keys; i++) {
-                                if (leaf->key[i] ==
-                                    ALIGN_DOWN(addr, PAGE_SIZE) - area->base) {
+                                if (leaf->key[i] == upage - area->base) {
                                         allocate = false;
                                         break;
@@ -192 +194 @@
                         }
                         if (allocate) {
-                                frame = (uintptr_t) frame_alloc_noreserve(
-                                    ONE_FRAME, 0);
-                                memsetb((void *) PA2KA(frame), FRAME_SIZE, 0);
+                                kpage = km_temporary_page_get(&frame,
+                                    FRAME_NO_RESERVE);
+                                memsetb((void *) kpage, PAGE_SIZE, 0);
+                                km_temporary_page_put(kpage);
                                 
                                 /*
@@ -201 +204 @@
                                  */
                                 btree_insert(&area->sh_info->pagemap,
-                                    ALIGN_DOWN(addr, PAGE_SIZE) - area->base,
-                                    (void *) frame, leaf);
+                                    upage - area->base, (void *) frame, leaf);
                         }
                 }
@@ -223 +225 @@
                  *   the different causes
                  */
-                frame = (uintptr_t) frame_alloc_noreserve(ONE_FRAME, 0);
-                memsetb((void *) PA2KA(frame), FRAME_SIZE, 0);
+                kpage = km_temporary_page_get(&frame, FRAME_NO_RESERVE);
+                memsetb((void *) kpage, PAGE_SIZE, 0);
+                km_temporary_page_put(kpage);
         }
         
         /*
-         * Map 'page' to 'frame'.
+         * Map 'upage' to 'frame'.
          * Note that TLB shootdown is not attempted as only new information is
          * being inserted into page tables.
          */
-        page_mapping_insert(AS, addr, frame, as_area_get_flags(area));
-        if (!used_space_insert(area, ALIGN_DOWN(addr, PAGE_SIZE), 1))
+        page_mapping_insert(AS, upage, frame, as_area_get_flags(area));
+        if (!used_space_insert(area, upage, 1))
                 panic("Cannot insert used space.");
                 

kernel/generic/src/mm/backend_elf.c

@@ -44 +44 @@
 #include <mm/page.h>
 #include <mm/reserve.h>
+#include <mm/km.h>
 #include <genarch/mm/page_pt.h>
 #include <genarch/mm/page_ht.h>
@@ -229 +230 @@
         elf_segment_header_t *entry = area->backend_data.segment;
         btree_node_t *leaf;
-        uintptr_t base, frame, page, start_anon;
+        uintptr_t base;
+        uintptr_t frame;
+        uintptr_t kpage;
+        uintptr_t upage;
+        uintptr_t start_anon;
         size_t i;
         bool dirty = false;
@@ -249 +254 @@
             (((void *) elf) + ALIGN_DOWN(entry->p_offset, PAGE_SIZE));
 
-        /* Virtual address of faulting page*/
-        page = ALIGN_DOWN(addr, PAGE_SIZE);
+        /* Virtual address of faulting page */
+        upage = ALIGN_DOWN(addr, PAGE_SIZE);
 
         /* Virtual address of the end of initialized part of segment */
@@ -264 +269 @@
                 mutex_lock(&area->sh_info->lock);
                 frame = (uintptr_t) btree_search(&area->sh_info->pagemap,
-                    page - area->base, &leaf);
+                    upage - area->base, &leaf);
                 if (!frame) {
                         unsigned int i;
@@ -273 +278 @@
 
                         for (i = 0; i < leaf->keys; i++) {
-                                if (leaf->key[i] == page - area->base) {
+                                if (leaf->key[i] == upage - area->base) {
                                         found = true;
                                         break;
@@ -281 +286 @@
                 if (frame || found) {
                         frame_reference_add(ADDR2PFN(frame));
-                        page_mapping_insert(AS, addr, frame,
+                        page_mapping_insert(AS, upage, frame,
                             as_area_get_flags(area));
-                        if (!used_space_insert(area, page, 1))
+                        if (!used_space_insert(area, upage, 1))
                                 panic("Cannot insert used space.");
                         mutex_unlock(&area->sh_info->lock);
@@ -294 +299 @@
          * mapping.
          */
-        if (page >= entry->p_vaddr && page + PAGE_SIZE <= start_anon) {
+        if (upage >= entry->p_vaddr && upage + PAGE_SIZE <= start_anon) {
                 /*
                  * Initialized portion of the segment. The memory is backed
@@ -304 +309 @@
                  */
                 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);
+                        kpage = km_temporary_page_get(&frame, FRAME_NO_RESERVE);
+                        memcpy((void *) kpage, (void *) (base + i * PAGE_SIZE),
+                            PAGE_SIZE);
                         if (entry->p_flags & PF_X) {
-                                smc_coherence_block((void *) PA2KA(frame),
-                                    FRAME_SIZE);
+                                smc_coherence_block((void *) kpage, PAGE_SIZE);
                         }
+                        km_temporary_page_put(kpage);
                         dirty = true;
                 } else {
-                        frame = KA2PA(base + i * FRAME_SIZE);
+                        pte_t *pte = page_mapping_find(AS_KERNEL,
+                            base + i * FRAME_SIZE, true);
+
+                        ASSERT(pte);
+                        ASSERT(PTE_PRESENT(pte));
+
+                        frame = PTE_GET_FRAME(pte);
                 }       
-        } else if (page >= start_anon) {
+        } else if (upage >= start_anon) {
                 /*
                  * This is the uninitialized portion of the segment.
@@ -322 +333 @@
                  * and cleared.
                  */
-                frame = (uintptr_t) frame_alloc_noreserve(ONE_FRAME, 0);
-                memsetb((void *) PA2KA(frame), FRAME_SIZE, 0);
+                kpage = km_temporary_page_get(&frame, FRAME_NO_RESERVE);
+                memsetb((void *) kpage, PAGE_SIZE, 0);
+                km_temporary_page_put(kpage);
                 dirty = true;
         } else {
@@ -334 +346 @@
                  * (The segment can be and often is shorter than 1 page).
                  */
-                if (page < entry->p_vaddr)
-                        pad_lo = entry->p_vaddr - page;
+                if (upage < entry->p_vaddr)
+                        pad_lo = entry->p_vaddr - upage;
                 else
                         pad_lo = 0;
 
-                if (start_anon < page + PAGE_SIZE)
-                        pad_hi = page + PAGE_SIZE - start_anon;
+                if (start_anon < upage + PAGE_SIZE)
+                        pad_hi = upage + 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);
+                kpage = km_temporary_page_get(&frame, FRAME_NO_RESERVE);
+                memcpy((void *) (kpage + pad_lo),
+                    (void *) (base + i * PAGE_SIZE + pad_lo),
+                    PAGE_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);
+                        smc_coherence_block((void *) (kpage + pad_lo), 
+                            PAGE_SIZE - pad_lo - pad_hi);
                 }
-                memsetb((void *) PA2KA(frame), pad_lo, 0);
-                memsetb((void *) (PA2KA(frame) + FRAME_SIZE - pad_hi), pad_hi,
-                    0);
+                memsetb((void *) kpage, pad_lo, 0);
+                memsetb((void *) (kpage + PAGE_SIZE - pad_hi), pad_hi, 0);
+                km_temporary_page_put(kpage);
                 dirty = true;
         }
@@ -360 +372 @@
         if (dirty && area->sh_info) {
                 frame_reference_add(ADDR2PFN(frame));
-                btree_insert(&area->sh_info->pagemap, page - area->base,
+                btree_insert(&area->sh_info->pagemap, upage - area->base,
                     (void *) frame, leaf);
         }
@@ -367 +379 @@
                 mutex_unlock(&area->sh_info->lock);
 
-        page_mapping_insert(AS, addr, frame, as_area_get_flags(area));
-        if (!used_space_insert(area, page, 1))
+        page_mapping_insert(AS, upage, frame, as_area_get_flags(area));
+        if (!used_space_insert(area, upage, 1))
                 panic("Cannot insert used space.");
 

kernel/generic/src/mm/frame.c

@@ -240 +240 @@
 NO_TRACE static bool zone_can_alloc(zone_t *zone, uint8_t order)
 {
-        return (zone_flags_available(zone->flags)
-            && buddy_system_can_alloc(zone->buddy_system, order));
+        return ((zone->flags & ZONE_AVAILABLE) &&
+            buddy_system_can_alloc(zone->buddy_system, order));
 }
 
@@ -265 +265 @@
                  * Check whether the zone meets the search criteria.
                  */
-                if ((zones.info[i].flags & flags) == flags) {
+                if (ZONE_FLAGS_MATCH(zones.info[i].flags, flags)) {
                         /*
                          * Check if the zone has 2^order frames area available.
@@ -460 +460 @@
 NO_TRACE static pfn_t zone_frame_alloc(zone_t *zone, uint8_t order)
 {
-        ASSERT(zone_flags_available(zone->flags));
+        ASSERT(zone->flags & ZONE_AVAILABLE);
         
         /* Allocate frames from zone buddy system */
@@ -490 +490 @@
 NO_TRACE static size_t zone_frame_free(zone_t *zone, size_t frame_idx)
 {
-        ASSERT(zone_flags_available(zone->flags));
+        ASSERT(zone->flags & ZONE_AVAILABLE);
         
         frame_t *frame = &zone->frames[frame_idx];
@@ -518 +518 @@
 NO_TRACE static void zone_mark_unavailable(zone_t *zone, size_t frame_idx)
 {
-        ASSERT(zone_flags_available(zone->flags));
+        ASSERT(zone->flags & ZONE_AVAILABLE);
         
         frame_t *frame = zone_get_frame(zone, frame_idx);
@@ -549 +549 @@
     buddy_system_t *buddy)
 {
-        ASSERT(zone_flags_available(zones.info[z1].flags));
-        ASSERT(zone_flags_available(zones.info[z2].flags));
+        ASSERT(zones.info[z1].flags & ZONE_AVAILABLE);
+        ASSERT(zones.info[z2].flags & ZONE_AVAILABLE);
         ASSERT(zones.info[z1].flags == zones.info[z2].flags);
         ASSERT(zones.info[z1].base < zones.info[z2].base);
@@ -645 +645 @@
 NO_TRACE static void return_config_frames(size_t znum, pfn_t pfn, size_t count)
 {
-        ASSERT(zone_flags_available(zones.info[znum].flags));
+        ASSERT(zones.info[znum].flags & ZONE_AVAILABLE);
         
         size_t cframes = SIZE2FRAMES(zone_conf_size(count));
@@ -681 +681 @@
     size_t count)
 {
-        ASSERT(zone_flags_available(zones.info[znum].flags));
+        ASSERT(zones.info[znum].flags & ZONE_AVAILABLE);
         ASSERT(frame_idx + count < zones.info[znum].count);
         
@@ -723 +723 @@
          * set of flags
          */
-        if ((z1 >= zones.count) || (z2 >= zones.count)
-            || (z2 - z1 != 1)
-            || (!zone_flags_available(zones.info[z1].flags))
-            || (!zone_flags_available(zones.info[z2].flags))
-            || (zones.info[z1].flags != zones.info[z2].flags)) {
+        if ((z1 >= zones.count) || (z2 >= zones.count) || (z2 - z1 != 1) ||
+            (zones.info[z1].flags != zones.info[z2].flags)) {
                 ret = false;
                 goto errout;
@@ -828 +825 @@
         zone->buddy_system = buddy;
         
-        if (zone_flags_available(flags)) {
+        if (flags & ZONE_AVAILABLE) {
                 /*
                  * Compute order for buddy system and initialize
@@ -865 +862 @@
 {
         return (count * sizeof(frame_t) + buddy_conf_size(fnzb(count)));
+}
+
+/** Allocate external configuration frames from low memory. */
+pfn_t zone_external_conf_alloc(size_t count)
+{
+        size_t size = zone_conf_size(count);
+        size_t order = ispwr2(size) ? fnzb(size) : (fnzb(size) + 1);
+
+        return ADDR2PFN((uintptr_t) frame_alloc(order - FRAME_WIDTH,
+            FRAME_LOWMEM | FRAME_ATOMIC));
 }
 
@@ -888 +895 @@
         irq_spinlock_lock(&zones.lock, true);
         
-        if (zone_flags_available(flags)) {  /* Create available zone */
+        if (flags & ZONE_AVAILABLE) {  /* Create available zone */
                 /* Theoretically we could have NULL here, practically make sure
                  * nobody tries to do that. If some platform requires, remove
@@ -894 +901 @@
                  */
                 ASSERT(confframe != ADDR2PFN((uintptr_t ) NULL));
+
+                /* Update the known end of physical memory. */
+                config.physmem_end = max(config.physmem_end, PFN2ADDR(start + count));
                 
                 /* If confframe is supposed to be inside our zone, then make sure
@@ -914 +924 @@
                                 for (i = 0; i < init.cnt; i++)
                                         if (overlaps(addr, PFN2ADDR(confcount),
-                                            KA2PA(init.tasks[i].addr),
+                                            init.tasks[i].paddr,
                                             init.tasks[i].size)) {
                                                 overlap = true;
@@ -1232 +1242 @@
         
         /* Tell the architecture to create some memory */
-        frame_arch_init();
+        frame_low_arch_init();
         if (config.cpu_active == 1) {
                 frame_mark_unavailable(ADDR2PFN(KA2PA(config.base)),
@@ -1241 +1251 @@
                 size_t i;
                 for (i = 0; i < init.cnt; i++) {
-                        pfn_t pfn = ADDR2PFN(KA2PA(init.tasks[i].addr));
+                        pfn_t pfn = ADDR2PFN(init.tasks[i].paddr);
                         frame_mark_unavailable(pfn,
                             SIZE2FRAMES(init.tasks[i].size));
@@ -1255 +1265 @@
                 frame_mark_unavailable(0, 1);
         }
+        frame_high_arch_init();
+}
+
+/** Adjust bounds of physical memory region according to low/high memory split.
+ *
+ * @param low[in]       If true, the adjustment is performed to make the region
+ *                      fit in the low memory. Otherwise the adjustment is
+ *                      performed to make the region fit in the high memory.
+ * @param basep[inout]  Pointer to a variable which contains the region's base
+ *                      address and which may receive the adjusted base address.
+ * @param sizep[inout]  Pointer to a variable which contains the region's size
+ *                      and which may receive the adjusted size.
+ * @retun               True if the region still exists even after the
+ *                      adjustment, false otherwise.
+ */
+bool frame_adjust_zone_bounds(bool low, uintptr_t *basep, size_t *sizep)
+{
+        uintptr_t limit = KA2PA(config.identity_base) + config.identity_size;
+
+        if (low) {
+                if (*basep > limit)
+                        return false;
+                if (*basep + *sizep > limit)
+                        *sizep = limit - *basep;
+        } else {
+                if (*basep + *sizep <= limit)
+                        return false;
+                if (*basep <= limit) {
+                        *sizep -= limit - *basep;
+                        *basep = limit;
+                }
+        }
+        return true;
 }
 
@@ -1293 +1336 @@
                 *total += (uint64_t) FRAMES2SIZE(zones.info[i].count);
                 
-                if (zone_flags_available(zones.info[i].flags)) {
+                if (zones.info[i].flags & ZONE_AVAILABLE) {
                         *busy += (uint64_t) FRAMES2SIZE(zones.info[i].busy_count);
                         *free += (uint64_t) FRAMES2SIZE(zones.info[i].free_count);
@@ -1344 +1387 @@
                 irq_spinlock_unlock(&zones.lock, true);
                 
-                bool available = zone_flags_available(flags);
+                bool available = ((flags & ZONE_AVAILABLE) != 0);
                 
                 printf("%-4zu", i);
@@ -1356 +1399 @@
 #endif
                 
-                printf(" %12zu %c%c%c      ", count,
-                    available ? 'A' : ' ',
-                    (flags & ZONE_RESERVED) ? 'R' : ' ',
-                    (flags & ZONE_FIRMWARE) ? 'F' : ' ');
+                printf(" %12zu %c%c%c%c%c    ", count,
+                    available ? 'A' : '-',
+                    (flags & ZONE_RESERVED) ? 'R' : '-',
+                    (flags & ZONE_FIRMWARE) ? 'F' : '-',
+                    (flags & ZONE_LOWMEM) ? 'L' : '-',
+                    (flags & ZONE_HIGHMEM) ? 'H' : '-');
                 
                 if (available)
@@ -1401 +1446 @@
         irq_spinlock_unlock(&zones.lock, true);
         
-        bool available = zone_flags_available(flags);
+        bool available = ((flags & ZONE_AVAILABLE) != 0);
         
         uint64_t size;
@@ -1411 +1456 @@
         printf("Zone size:         %zu frames (%" PRIu64 " %s)\n", count,
             size, size_suffix);
-        printf("Zone flags:        %c%c%c\n",
-            available ? 'A' : ' ',
-            (flags & ZONE_RESERVED) ? 'R' : ' ',
-            (flags & ZONE_FIRMWARE) ? 'F' : ' ');
+        printf("Zone flags:        %c%c%c%c%c\n",
+            available ? 'A' : '-',
+            (flags & ZONE_RESERVED) ? 'R' : '-',
+            (flags & ZONE_FIRMWARE) ? 'F' : '-',
+            (flags & ZONE_LOWMEM) ? 'L' : '-',
+            (flags & ZONE_HIGHMEM) ? 'H' : '-');
         
         if (available) {

kernel/generic/src/mm/page.c

@@ -53 +53 @@
  * We assume that the other processors are either not using the mapping yet
  * (i.e. during the bootstrap) or are executing the TLB shootdown code.  While
- * we don't care much about the former case, the processors in the latter case 
+ * we don't care much about the former case, the processors in the latter case
  * will do an implicit serialization by virtue of running the TLB shootdown
  * interrupt handler.
@@ -74 +74 @@
 #include <syscall/copy.h>
 #include <errno.h>
+#include <align.h>
 
 /** Virtual operations for page subsystem. */
@@ -81 +82 @@
 {
         page_arch_init();
-}
-
-/** Map memory structure
- *
- * Identity-map memory structure
- * considering possible crossings
- * of page boundaries.
- *
- * @param addr Address of the structure.
- * @param size Size of the structure.
- *
- */
-void map_structure(uintptr_t addr, size_t size)
-{
-        size_t length = size + (addr - (addr & ~(PAGE_SIZE - 1)));
-        size_t cnt = length / PAGE_SIZE + (length % PAGE_SIZE > 0);
-        
-        size_t i;
-        for (i = 0; i < cnt; i++)
-                page_mapping_insert(AS_KERNEL, addr + i * PAGE_SIZE,
-                    addr + i * PAGE_SIZE, PAGE_NOT_CACHEABLE | PAGE_WRITE);
-        
-        /* Repel prefetched accesses to the old mapping. */
-        memory_barrier();
 }
 
@@ -176 +153 @@
 }
 
+/** Make the mapping shared by all page tables (not address spaces).
+ * 
+ * @param base Starting virtual address of the range that is made global.
+ * @param size Size of the address range that is made global.
+ */
+void page_mapping_make_global(uintptr_t base, size_t size)
+{
+        ASSERT(page_mapping_operations);
+        ASSERT(page_mapping_operations->mapping_make_global);
+        
+        return page_mapping_operations->mapping_make_global(base, size);
+}
+
+int page_find_mapping(uintptr_t virt, void **phys)
+{
+        page_table_lock(AS, true);
+        
+        pte_t *pte = page_mapping_find(AS, virt, false);
+        if ((!PTE_VALID(pte)) || (!PTE_PRESENT(pte))) {
+                page_table_unlock(AS, true);
+                return ENOENT;
+        }
+        
+        *phys = (void *) PTE_GET_FRAME(pte) +
+            (virt - ALIGN_DOWN(virt, PAGE_SIZE));
+        
+        page_table_unlock(AS, true);
+        
+        return EOK;
+}
+
 /** 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;
+ *
+ * @return EOK on success.
+ * @return ENOENT if no virtual address mapping found.
+ *
+ */
+sysarg_t sys_page_find_mapping(uintptr_t virt, void *phys_ptr)
+{
+        void *phys;
+        int rc = page_find_mapping(virt, &phys);
+        if (rc != EOK)
+                return rc;
+        
+        rc = copy_to_uspace(phys_ptr, &phys, sizeof(phys));
+        return (sysarg_t) rc;
 }
 

kernel/generic/src/mm/reserve.c

@@ -42 +42 @@
 #include <typedefs.h>
 #include <arch/types.h>
+#include <debug.h>
+
+static bool reserve_initialized = false;
 
 IRQ_SPINLOCK_STATIC_INITIALIZE_NAME(reserve_lock, "reserve_lock");
@@ -54 +57 @@
 {
         reserve = frame_total_free_get();
+        reserve_initialized = true;
 }
 
@@ -67 +71 @@
 {
         bool reserved = false;
+
+        ASSERT(reserve_initialized);
 
         irq_spinlock_lock(&reserve_lock, true);
@@ -111 +117 @@
 void reserve_force_alloc(size_t size)
 {
+        if (!reserve_initialized)
+                return;
+
         irq_spinlock_lock(&reserve_lock, true);
         reserve -= size;
@@ -122 +131 @@
 void reserve_free(size_t size)
 {
+        if (!reserve_initialized)
+                return;
+
         irq_spinlock_lock(&reserve_lock, true);
         reserve += size;

kernel/generic/src/printf/printf_core.c

@@ -284 +284 @@
         /* Print leading spaces. */
         size_t strw = str_length(str);
-        if (precision == 0)
+        if ((precision == 0) || (precision > strw))
                 precision = strw;
         
@@ -332 +332 @@
         /* Print leading spaces. */
         size_t strw = wstr_length(str);
-        if (precision == 0)
+        if ((precision == 0) || (precision > strw))
                 precision = strw;
         

kernel/generic/src/proc/program.c

@@ -87 +87 @@
          * Create the stack address space area.
          */
+        uintptr_t virt = USTACK_ADDRESS;
         as_area_t *area = as_area_create(as,
             AS_AREA_READ | AS_AREA_WRITE | AS_AREA_CACHEABLE,
-            STACK_SIZE, USTACK_ADDRESS, AS_AREA_ATTR_NONE,
-            &anon_backend, NULL);
+            STACK_SIZE, AS_AREA_ATTR_NONE, &anon_backend, NULL, &virt, 0);
         if (!area)
                 return ENOMEM;

kernel/generic/src/proc/thread.c

@@ -173 +173 @@
 #endif /* CONFIG_FPU */
         
+        /*
+         * Allocate the kernel stack from the low-memory to prevent an infinite
+         * nesting of TLB-misses when accessing the stack from the part of the
+         * TLB-miss handler written in C.
+         *
+         * Note that low-memory is safe to be used for the stack as it will be
+         * covered by the kernel identity mapping, which guarantees not to
+         * nest TLB-misses infinitely (either via some hardware mechanism or
+         * by the construciton of the assembly-language part of the TLB-miss
+         * handler).
+         *
+         * This restriction can be lifted once each architecture provides
+         * a similar guarantee, for example by locking the kernel stack
+         * in the TLB whenever it is allocated from the high-memory and the
+         * thread is being scheduled to run.
+         */
+        kmflags |= FRAME_LOWMEM;
+        kmflags &= ~FRAME_HIGHMEM;
+
         thread->kstack = (uint8_t *) frame_alloc(STACK_FRAMES, FRAME_KA | kmflags);
         if (!thread->kstack) {

kernel/generic/src/syscall/copy.c

@@ -56 +56 @@
  * @param size Size of the data to be copied.
  *
- * @return 0 on success or error code from @ref errno.h.
+ * @return EOK on success or error code from @ref errno.h.
  */
 int copy_from_uspace(void *dst, const void *uspace_src, size_t size)
@@ -94 +94 @@
 
         interrupts_restore(ipl);
-        return !rc ? EPERM : 0;
+        return !rc ? EPERM : EOK;
 }
 

kernel/generic/src/syscall/syscall.c

@@ -146 +146 @@
         (syshandler_t) sys_as_area_change_flags,
         (syshandler_t) sys_as_area_destroy,
-        (syshandler_t) sys_as_get_unmapped_area,
         
         /* Page mapping related syscalls. */
@@ -176 +175 @@
         (syshandler_t) sys_device_assign_devno,
         (syshandler_t) sys_physmem_map,
+        (syshandler_t) sys_physmem_unmap,
+        (syshandler_t) sys_dmamem_map,
+        (syshandler_t) sys_dmamem_unmap,
         (syshandler_t) sys_iospace_enable,
-        (syshandler_t) sys_register_irq,
-        (syshandler_t) sys_unregister_irq,
+        (syshandler_t) sys_iospace_disable,
+        (syshandler_t) sys_irq_register,
+        (syshandler_t) sys_irq_unregister,
         
         /* Sysinfo syscalls. */
+        (syshandler_t) sys_sysinfo_get_keys_size,
+        (syshandler_t) sys_sysinfo_get_keys,
         (syshandler_t) sys_sysinfo_get_val_type,
         (syshandler_t) sys_sysinfo_get_value,

kernel/generic/src/sysinfo/stats.c

@@ -83 +83 @@
  *
  * @param item Sysinfo item (unused).
+ * @param data Unused.
  *
  * @return System uptime (in secords).
  *
  */
-static sysarg_t get_stats_uptime(struct sysinfo_item *item)
+static sysarg_t get_stats_uptime(struct sysinfo_item *item, void *data)
 {
         /* This doesn't have to be very accurate */
@@ -98 +99 @@
  * @param size    Size of the returned data.
  * @param dry_run Do not get the data, just calculate the size.
+ * @param data    Unused.
  *
  * @return Data containing several stats_cpu_t structures.
@@ -104 +106 @@
  */
 static void *get_stats_cpus(struct sysinfo_item *item, size_t *size,
-    bool dry_run)
+    bool dry_run, void *data)
 {
         *size = sizeof(stats_cpu_t) * config.cpu_count;
@@ -249 +251 @@
         ASSERT(interrupts_disabled());
         ASSERT(irq_spinlock_locked(&task->lock));
-
+        
         stats_task->task_id = task->taskid;
         str_cpy(stats_task->name, TASK_NAME_BUFLEN, task->name);
@@ -293 +295 @@
  * @param size    Size of the returned data.
  * @param dry_run Do not get the data, just calculate the size.
+ * @param data    Unused.
  *
  * @return Data containing several stats_task_t structures.
@@ -299 +302 @@
  */
 static void *get_stats_tasks(struct sysinfo_item *item, size_t *size,
-    bool dry_run)
+    bool dry_run, void *data)
 {
         /* Messing with task structures, avoid deadlock */
@@ -350 +353 @@
         ASSERT(interrupts_disabled());
         ASSERT(irq_spinlock_locked(&thread->lock));
-
+        
         stats_thread->thread_id = thread->tid;
         stats_thread->task_id = thread->task->taskid;
@@ -398 +401 @@
  * @param size    Size of the returned data.
  * @param dry_run Do not get the data, just calculate the size.
+ * @param data    Unused.
  *
  * @return Data containing several stats_task_t structures.
@@ -404 +408 @@
  */
 static void *get_stats_threads(struct sysinfo_item *item, size_t *size,
-    bool dry_run)
+    bool dry_run, void *data)
 {
         /* Messing with threads structures, avoid deadlock */
@@ -451 +455 @@
  * @param name    Task ID (string-encoded number).
  * @param dry_run Do not get the data, just calculate the size.
+ * @param data    Unused.
  *
  * @return Sysinfo return holder. The type of the returned
@@ -460 +465 @@
  *
  */
-static sysinfo_return_t get_stats_task(const char *name, bool dry_run)
+static sysinfo_return_t get_stats_task(const char *name, bool dry_run,
+    void *data)
 {
         /* Initially no return value */
@@ -468 +474 @@
         /* Parse the task ID */
         task_id_t task_id;
-        if (str_uint64(name, NULL, 0, true, &task_id) != EOK)
+        if (str_uint64_t(name, NULL, 0, true, &task_id) != EOK)
                 return ret;
         
@@ -520 +526 @@
  * @param name    Thread ID (string-encoded number).
  * @param dry_run Do not get the data, just calculate the size.
+ * @param data    Unused.
  *
  * @return Sysinfo return holder. The type of the returned
@@ -529 +536 @@
  *
  */
-static sysinfo_return_t get_stats_thread(const char *name, bool dry_run)
+static sysinfo_return_t get_stats_thread(const char *name, bool dry_run,
+    void *data)
 {
         /* Initially no return value */
@@ -537 +545 @@
         /* Parse the thread ID */
         thread_id_t thread_id;
-        if (str_uint64(name, NULL, 0, true, &thread_id) != EOK)
+        if (str_uint64_t(name, NULL, 0, true, &thread_id) != EOK)
                 return ret;
         
@@ -586 +594 @@
  * @param size    Size of the returned data.
  * @param dry_run Do not get the data, just calculate the size.
+ * @param data    Unused.
  *
  * @return Data containing several stats_exc_t structures.
@@ -592 +601 @@
  */
 static void *get_stats_exceptions(struct sysinfo_item *item, size_t *size,
-    bool dry_run)
+    bool dry_run, void *data)
 {
         *size = sizeof(stats_exc_t) * IVT_ITEMS;
@@ -634 +643 @@
  * @param name    Exception number (string-encoded number).
  * @param dry_run Do not get the data, just calculate the size.
+ * @param data    Unused.
  *
  * @return Sysinfo return holder. The type of the returned
@@ -643 +653 @@
  *
  */
-static sysinfo_return_t get_stats_exception(const char *name, bool dry_run)
+static sysinfo_return_t get_stats_exception(const char *name, bool dry_run,
+    void *data)
 {
         /* Initially no return value */
@@ -651 +662 @@
         /* Parse the exception number */
         uint64_t excn;
-        if (str_uint64(name, NULL, 0, true, &excn) != EOK)
+        if (str_uint64_t(name, NULL, 0, true, &excn) != EOK)
                 return ret;
         
@@ -705 +716 @@
  * @param size    Size of the returned data.
  * @param dry_run Do not get the data, just calculate the size.
+ * @param data    Unused.
  *
  * @return Data containing stats_physmem_t.
@@ -711 +723 @@
  */
 static void *get_stats_physmem(struct sysinfo_item *item, size_t *size,
-    bool dry_run)
+    bool dry_run, void *data)
 {
         *size = sizeof(stats_physmem_t);
@@ -735 +747 @@
  * @param size    Size of the returned data.
  * @param dry_run Do not get the data, just calculate the size.
+ * @param data    Unused.
  *
  * @return Data several load_t values.
@@ -741 +754 @@
  */
 static void *get_stats_load(struct sysinfo_item *item, size_t *size,
-    bool dry_run)
+    bool dry_run, void *data)
 {
         *size = sizeof(load_t) * LOAD_STEPS;
@@ -810 +823 @@
         mutex_initialize(&load_lock, MUTEX_PASSIVE);
         
-        sysinfo_set_item_fn_val("system.uptime", NULL, get_stats_uptime);
-        sysinfo_set_item_fn_data("system.cpus", NULL, get_stats_cpus);
-        sysinfo_set_item_fn_data("system.physmem", NULL, get_stats_physmem);
-        sysinfo_set_item_fn_data("system.load", NULL, get_stats_load);
-        sysinfo_set_item_fn_data("system.tasks", NULL, get_stats_tasks);
-        sysinfo_set_item_fn_data("system.threads", NULL, get_stats_threads);
-        sysinfo_set_item_fn_data("system.exceptions", NULL, get_stats_exceptions);
-        sysinfo_set_subtree_fn("system.tasks", NULL, get_stats_task);
-        sysinfo_set_subtree_fn("system.threads", NULL, get_stats_thread);
-        sysinfo_set_subtree_fn("system.exceptions", NULL, get_stats_exception);
+        sysinfo_set_item_gen_val("system.uptime", NULL, get_stats_uptime, NULL);
+        sysinfo_set_item_gen_data("system.cpus", NULL, get_stats_cpus, NULL);
+        sysinfo_set_item_gen_data("system.physmem", NULL, get_stats_physmem, NULL);
+        sysinfo_set_item_gen_data("system.load", NULL, get_stats_load, NULL);
+        sysinfo_set_item_gen_data("system.tasks", NULL, get_stats_tasks, NULL);
+        sysinfo_set_item_gen_data("system.threads", NULL, get_stats_threads, NULL);
+        sysinfo_set_item_gen_data("system.exceptions", NULL, get_stats_exceptions, NULL);
+        sysinfo_set_subtree_fn("system.tasks", NULL, get_stats_task, NULL);
+        sysinfo_set_subtree_fn("system.threads", NULL, get_stats_thread, NULL);
+        sysinfo_set_subtree_fn("system.exceptions", NULL, get_stats_exception, NULL);
 }
 

kernel/generic/src/sysinfo/sysinfo.c

@@ -1 +1 @@
 /*
  * Copyright (c) 2006 Jakub Vana
+ * Copyright (c) 2012 Martin Decky
  * All rights reserved.
  *
@@ -99 +100 @@
             sizeof(sysinfo_item_t), 0, sysinfo_item_constructor,
             sysinfo_item_destructor, SLAB_CACHE_MAGDEFERRED);
-
+        
         mutex_initialize(&sysinfo_lock, MUTEX_ACTIVE);
 }
@@ -110 +111 @@
  * @param subtree Current sysinfo (sub)tree root item.
  * @param ret     If the return value is NULL, this argument
- *                can be either also NULL (i.e. no item was
+ *                can be set either to NULL (i.e. no item was
  *                found and no data was generated) or the
  *                original pointer is used to store the value
@@ -125 +126 @@
 {
         ASSERT(subtree != NULL);
-        ASSERT(ret != NULL);
         
         sysinfo_item_t *cur = subtree;
@@ -151 +151 @@
                         case SYSINFO_SUBTREE_FUNCTION:
                                 /* Get generated data */
-                                **ret = cur->subtree.get_data(name + i + 1, dry_run);
+                                if (ret != NULL)
+                                        **ret = cur->subtree.generator.fn(name + i + 1,
+                                            dry_run, cur->subtree.generator.data);
+                                
                                 return NULL;
                         default:
                                 /* Not found, no data generated */
-                                *ret = NULL;
+                                if (ret != NULL)
+                                        *ret = NULL;
+                                
                                 return NULL;
                         }
@@ -164 +169 @@
         
         /* Not found, no data generated */
-        *ret = NULL;
+        if (ret != NULL)
+                *ret = NULL;
+        
         return NULL;
 }
@@ -352 +359 @@
  *             a new root item (NULL for global sysinfo root).
  * @param fn   Numeric value generator function.
- *
- */
-void sysinfo_set_item_fn_val(const char *name, sysinfo_item_t **root,
-    sysinfo_fn_val_t fn)
+ * @param data Private data.
+ *
+ */
+void sysinfo_set_item_gen_val(const char *name, sysinfo_item_t **root,
+    sysinfo_fn_val_t fn, void *data)
 {
         /* Protect sysinfo tree consistency */
@@ -366 +374 @@
         if (item != NULL) {
                 item->val_type = SYSINFO_VAL_FUNCTION_VAL;
-                item->val.fn_val = fn;
+                item->val.gen_val.fn = fn;
+                item->val.gen_val.data = data;
         }
         
@@ -383 +392 @@
  *             a new root item (NULL for global sysinfo root).
  * @param fn   Binary data generator function.
- *
- */
-void sysinfo_set_item_fn_data(const char *name, sysinfo_item_t **root,
-    sysinfo_fn_data_t fn)
+ * @param data Private data.
+ *
+ */
+void sysinfo_set_item_gen_data(const char *name, sysinfo_item_t **root,
+    sysinfo_fn_data_t fn, void *data)
 {
         /* Protect sysinfo tree consistency */
@@ -397 +407 @@
         if (item != NULL) {
                 item->val_type = SYSINFO_VAL_FUNCTION_DATA;
-                item->val.fn_data = fn;
+                item->val.gen_data.fn = fn;
+                item->val.gen_data.data = data;
         }
         
@@ -431 +442 @@
  *             a new root item (NULL for global sysinfo root).
  * @param fn   Subtree generator function.
+ * @param data Private data to be passed to the generator.
  *
  */
 void sysinfo_set_subtree_fn(const char *name, sysinfo_item_t **root,
-    sysinfo_fn_subtree_t fn)
+    sysinfo_fn_subtree_t fn, void *data)
 {
         /* Protect sysinfo tree consistency */
@@ -448 +460 @@
         if ((item != NULL) && (item->subtree_type != SYSINFO_SUBTREE_TABLE)) {
                 item->subtree_type = SYSINFO_SUBTREE_FUNCTION;
-                item->subtree.get_data = fn;
+                item->subtree.generator.fn = fn;
+                item->subtree.generator.data = data;
         }
         
@@ -456 +469 @@
 /** Sysinfo dump indentation helper routine
  *
- * @param depth Number of indentation characters to print.
- *
- */
-NO_TRACE static void sysinfo_indent(unsigned int depth)
-{
-        unsigned int i;
-        for (i = 0; i < depth; i++)
-                printf("  ");
+ * @param depth Number of spaces to print.
+ *
+ */
+NO_TRACE static void sysinfo_indent(size_t spaces)
+{
+        for (size_t i = 0; i < spaces; i++)
+                printf(" ");
 }
 
@@ -470 +482 @@
  * Should be called with sysinfo_lock held.
  *
- * @param root  Root item of the current (sub)tree.
- * @param depth Current depth in the sysinfo tree.
- *
- */
-NO_TRACE static void sysinfo_dump_internal(sysinfo_item_t *root, unsigned int depth)
-{
-        sysinfo_item_t *cur = root;
-        
+ * @param root   Root item of the current (sub)tree.
+ * @param spaces Current indentation level.
+ *
+ */
+NO_TRACE static void sysinfo_dump_internal(sysinfo_item_t *root, size_t spaces)
+{
         /* Walk all siblings */
-        while (cur != NULL) {
-                sysinfo_indent(depth);
+        for (sysinfo_item_t *cur = root; cur; cur = cur->next) {
+                size_t length;
+                
+                if (spaces == 0) {
+                        printf("%s", cur->name);
+                        length = str_length(cur->name);
+                } else {
+                        sysinfo_indent(spaces);
+                        printf(".%s", cur->name);
+                        length = str_length(cur->name) + 1;
+                }
                 
                 sysarg_t val;
@@ -488 +507 @@
                 switch (cur->val_type) {
                 case SYSINFO_VAL_UNDEFINED:
-                        printf("+ %s\n", cur->name);
+                        printf(" [undefined]\n");
                         break;
                 case SYSINFO_VAL_VAL:
-                        printf("+ %s -> %" PRIun" (%#" PRIxn ")\n", cur->name,
-                            cur->val.val, cur->val.val);
+                        printf(" -> %" PRIun" (%#" PRIxn ")\n", cur->val.val,
+                            cur->val.val);
                         break;
                 case SYSINFO_VAL_DATA:
-                        printf("+ %s (%zu bytes)\n", cur->name,
-                            cur->val.data.size);
+                        printf(" (%zu bytes)\n", cur->val.data.size);
                         break;
                 case SYSINFO_VAL_FUNCTION_VAL:
-                        val = cur->val.fn_val(cur);
-                        printf("+ %s -> %" PRIun" (%#" PRIxn ") [generated]\n",
-                            cur->name, val, val);
+                        val = cur->val.gen_val.fn(cur, cur->val.gen_val.data);
+                        printf(" -> %" PRIun" (%#" PRIxn ") [generated]\n", val,
+                            val);
                         break;
                 case SYSINFO_VAL_FUNCTION_DATA:
                         /* N.B.: No data was actually returned (only a dry run) */
-                        (void) cur->val.fn_data(cur, &size, true);
-                        printf("+ %s (%zu bytes) [generated]\n", cur->name,
-                            size);
+                        (void) cur->val.gen_data.fn(cur, &size, true,
+                            cur->val.gen_data.data);
+                        printf(" (%zu bytes) [generated]\n", size);
                         break;
                 default:
@@ -518 +536 @@
                         break;
                 case SYSINFO_SUBTREE_TABLE:
-                        sysinfo_dump_internal(cur->subtree.table, depth + 1);
+                        sysinfo_dump_internal(cur->subtree.table, spaces + length);
                         break;
                 case SYSINFO_SUBTREE_FUNCTION:
-                        sysinfo_indent(depth + 1);
-                        printf("+ [generated subtree]\n");
+                        sysinfo_indent(spaces + length);
+                        printf("<generated subtree>\n");
                         break;
                 default:
-                        sysinfo_indent(depth + 1);
-                        printf("+ [unknown subtree]\n");
+                        sysinfo_indent(spaces + length);
+                        printf("<unknown subtree>\n");
                 }
-                
-                cur = cur->next;
         }
 }
@@ -594 +610 @@
                         break;
                 case SYSINFO_VAL_FUNCTION_VAL:
-                        ret.val = item->val.fn_val(item);
+                        ret.val = item->val.gen_val.fn(item, item->val.gen_val.data);
                         break;
                 case SYSINFO_VAL_FUNCTION_DATA:
-                        ret.data.data = item->val.fn_data(item, &ret.data.size,
-                            dry_run);
+                        ret.data.data = item->val.gen_data.fn(item, &ret.data.size,
+                            dry_run, item->val.gen_data.data);
                         break;
                 }
@@ -635 +651 @@
         ASSERT(path);
         
-        if ((copy_from_uspace(path, ptr, size + 1) == 0)
-            && (path[size] == 0)) {
+        if ((copy_from_uspace(path, ptr, size + 1) == 0) &&
+            (path[size] == 0)) {
                 /*
                  * Prevent other functions from messing with sysinfo while we
@@ -645 +661 @@
                 mutex_unlock(&sysinfo_lock);
         }
+        
         free(path);
         return ret;
+}
+
+/** Return sysinfo keys determined by name
+ *
+ * Should be called with sysinfo_lock held.
+ *
+ * @param name    Sysinfo path.
+ * @param root    Root item of the sysinfo (sub)tree.
+ *                If it is NULL then consider the global
+ *                sysinfo tree.
+ * @param dry_run Do not actually get any generated
+ *                binary data, just calculate the size.
+ *
+ * @return Item value (constant or generated).
+ *
+ */
+NO_TRACE static sysinfo_return_t sysinfo_get_keys(const char *name,
+    sysinfo_item_t **root, bool dry_run)
+{
+        if (root == NULL)
+                root = &global_root;
+        
+        sysinfo_item_t *subtree = NULL;
+        
+        if (name[0] != 0) {
+                /* Try to find the item */
+                sysinfo_item_t *item =
+                    sysinfo_find_item(name, *root, NULL, dry_run);
+                if ((item != NULL) &&
+                    (item->subtree_type == SYSINFO_SUBTREE_TABLE))
+                        subtree = item->subtree.table;
+        } else
+                subtree = *root;
+        
+        sysinfo_return_t ret;
+        
+        if (subtree != NULL) {
+                /*
+                 * Calculate the size of subkeys.
+                 */
+                size_t size = 0;
+                for (sysinfo_item_t *cur = subtree; cur; cur = cur->next)
+                        size += str_size(cur->name) + 1;
+                
+                if (dry_run) {
+                        ret.tag = SYSINFO_VAL_DATA;
+                        ret.data.data = NULL;
+                        ret.data.size = size;
+                } else {
+                        /* Allocate buffer for subkeys */
+                        char *names = (char *) malloc(size, FRAME_ATOMIC);
+                        if (names == NULL)
+                                return ret;
+                        
+                        size_t pos = 0;
+                        for (sysinfo_item_t *cur = subtree; cur; cur = cur->next) {
+                                str_cpy(names + pos, size - pos, cur->name);
+                                pos += str_size(cur->name) + 1;
+                        }
+                        
+                        /* Correct return value */
+                        ret.tag = SYSINFO_VAL_DATA;
+                        ret.data.data = (void *) names;
+                        ret.data.size = size;
+                }
+        } else {
+                /* No item in the fixed sysinfo tree */
+                ret.tag = SYSINFO_VAL_UNDEFINED;
+        }
+        
+        return ret;
+}
+
+/** Return sysinfo keys determined by name from user space
+ *
+ * The path string passed from the user space has to be properly
+ * null-terminated (the last passed character must be null).
+ *
+ * @param ptr     Sysinfo path in the user address space.
+ * @param size    Size of the path string.
+ * @param dry_run Do not actually get any generated
+ *                binary data, just calculate the size.
+ *
+ */
+NO_TRACE static sysinfo_return_t sysinfo_get_keys_uspace(void *ptr, size_t size,
+    bool dry_run)
+{
+        sysinfo_return_t ret;
+        ret.tag = SYSINFO_VAL_UNDEFINED;
+        
+        if (size > SYSINFO_MAX_PATH)
+                return ret;
+        
+        char *path = (char *) malloc(size + 1, 0);
+        ASSERT(path);
+        
+        if ((copy_from_uspace(path, ptr, size + 1) == 0) &&
+            (path[size] == 0)) {
+                /*
+                 * Prevent other functions from messing with sysinfo while we
+                 * are reading it.
+                 */
+                mutex_lock(&sysinfo_lock);
+                ret = sysinfo_get_keys(path, NULL, dry_run);
+                mutex_unlock(&sysinfo_lock);
+        }
+        
+        free(path);
+        return ret;
+}
+
+/** Get the sysinfo keys size (syscall)
+ *
+ * The path string passed from the user space has
+ * to be properly null-terminated (the last passed
+ * character must be null).
+ *
+ * @param path_ptr  Sysinfo path in the user address space.
+ * @param path_size Size of the path string.
+ * @param size_ptr  User space pointer where to store the
+ *                  keys size.
+ *
+ * @return Error code (EOK in case of no error).
+ *
+ */
+sysarg_t sys_sysinfo_get_keys_size(void *path_ptr, size_t path_size,
+    void *size_ptr)
+{
+        int rc;
+        
+        /*
+         * Get the keys.
+         *
+         * N.B.: There is no need to free any potential keys
+         * since we request a dry run.
+         */
+        sysinfo_return_t ret =
+            sysinfo_get_keys_uspace(path_ptr, path_size, true);
+        
+        /* Check return data tag */
+        if (ret.tag == SYSINFO_VAL_DATA)
+                rc = copy_to_uspace(size_ptr, &ret.data.size,
+                    sizeof(ret.data.size));
+        else
+                rc = EINVAL;
+        
+        return (sysarg_t) rc;
+}
+
+/** Get the sysinfo keys (syscall)
+ *
+ * The path string passed from the user space has
+ * to be properly null-terminated (the last passed
+ * character must be null).
+ *
+ * If the user space buffer size does not equal
+ * the actual size of the returned data, the data
+ * is truncated.
+ *
+ * The actual size of data returned is stored to
+ * size_ptr.
+ *
+ * @param path_ptr    Sysinfo path in the user address space.
+ * @param path_size   Size of the path string.
+ * @param buffer_ptr  User space pointer to the buffer where
+ *                    to store the binary data.
+ * @param buffer_size User space buffer size.
+ * @param size_ptr    User space pointer where to store the
+ *                    binary data size.
+ *
+ * @return Error code (EOK in case of no error).
+ *
+ */
+sysarg_t sys_sysinfo_get_keys(void *path_ptr, size_t path_size,
+    void *buffer_ptr, size_t buffer_size, size_t *size_ptr)
+{
+        int rc;
+        
+        /* Get the keys */
+        sysinfo_return_t ret = sysinfo_get_keys_uspace(path_ptr, path_size,
+            false);
+        
+        /* Check return data tag */
+        if (ret.tag == SYSINFO_VAL_DATA) {
+                size_t size = min(ret.data.size, buffer_size);
+                rc = copy_to_uspace(buffer_ptr, ret.data.data, size);
+                if (rc == EOK)
+                        rc = copy_to_uspace(size_ptr, &size, sizeof(size));
+                
+                free(ret.data.data);
+        } else
+                rc = EINVAL;
+        
+        return (sysarg_t) rc;
 }
 
@@ -672 +883 @@
         
         /*
-         * Map generated value types to constant types (user space does not care
-         * whether the value is constant or generated).
+         * Map generated value types to constant types (user space does
+         * not care whether the value is constant or generated).
          */
         if (ret.tag == SYSINFO_VAL_FUNCTION_VAL)
@@ -701 +912 @@
 {
         int rc;
-
+        
         /*
          * Get the item.
          *
-         * N.B.: There is no need to free any potential generated binary data
-         * since we request a dry run.
+         * N.B.: There is no need to free any potential generated binary
+         * data since we request a dry run.
          */
         sysinfo_return_t ret = sysinfo_get_item_uspace(path_ptr, path_size, true);
@@ -741 +952 @@
          * Get the item.
          *
-         * N.B.: There is no need to free any potential generated binary data
-         * since we request a dry run.
+         * N.B.: There is no need to free any potential generated binary
+         * data since we request a dry run.
          */
         sysinfo_return_t ret = sysinfo_get_item_uspace(path_ptr, path_size, true);