WebSVN – HelenOS – Path Comparison – / – /branches/dynload/ Rev 4340 and /branches/dynload/ Rev 4341

Ignore whitespace Rev 4340 → Rev 4341

 /branches/dynload/contrib/default/sparc64/Makefile.config
 ,0 → 1,62
+# Platform
+PLATFORM = sparc64
+# CPU type
+MACHINE = us
+# Ramdisk format
+RDFMT = tmpfs
+# Compiler
+COMPILER = gcc_cross
+# Debug build
+CONFIG_DEBUG = y
+# Support for SMP
+CONFIG_SMP = y
+# Lazy FPU context switching
+CONFIG_FPU_LAZY = y
+# Use TSB
+CONFIG_TSB = y
+# Support for Z8530 serial port
+CONFIG_Z8530 = y
+# Support for NS16550 serial port
+CONFIG_NS16550 = y
+# Support for Serengeti console
+CONFIG_SGCN = y
+# Interrupt-driven driver for NS16550?
+CONFIG_NS16550_INTERRUPT_DRIVEN = y
+# Virtually indexed D-cache support
+CONFIG_VIRT_IDX_DCACHE = y
+# Support for userspace debuggers
+CONFIG_UDEBUG = n
+# Kernel console support
+CONFIG_KCONSOLE = y
+# Detailed kernel logging
+CONFIG_LOG = n
+# Deadlock detection support for spinlocks
+CONFIG_DEBUG_SPINLOCK = y
+# Compile kernel tests
+CONFIG_TEST = y
+# Start AP processors by the loader
+CONFIG_AP = y
+# Preserve A.OUT header in isofs.b
+CONFIG_AOUT_ISOFS_B = y
+# External ramdisk
+CONFIG_RD_EXTERNAL = n

/branches/dynload/contrib/default/sparc64/output
0,0 → 1,0
image.iso

/branches/dynload/contrib/default/ia64/output
0,0 → 1,0
image.boot

 /branches/dynload/contrib/default/ia64/Makefile.config
 ,0 → 1,47
+# Platform
+PLATFORM = ia64
+# Machine type
+MACHINE = i460GX
+# Ramdisk format
+RDFMT = tmpfs
+# Compiler
+COMPILER = gcc_cross
+# Debug build
+CONFIG_DEBUG = y
+# Support for SMP
+CONFIG_SMP = y
+# Lazy FPU context switching
+CONFIG_FPU_LAZY = y
+# Use VHPT
+CONFIG_VHPT = n
+# Support for NS16550 serial port
+CONFIG_NS16550 = y
+# IOSapic on default address support
+CONFIG_IOSAPIC = y
+# Interrupt-driven driver for NS16550?
+CONFIG_NS16550_INTERRUPT_DRIVEN = y
+# Support for userspace debuggers
+CONFIG_UDEBUG = n
+# Kernel console support
+CONFIG_KCONSOLE = y
+# Detailed kernel logging
+CONFIG_LOG = n
+# Deadlock detection support for spinlocks
+CONFIG_DEBUG_SPINLOCK = y
+# Compile kernel tests
+CONFIG_TEST = y

/branches/dynload/contrib/default/arm32/output
0,0 → 1,0
image.boot

 /branches/dynload/contrib/default/arm32/Makefile.config
 ,0 → 1,26
+# Platform
+PLATFORM = arm32
+# Ramdisk format
+RDFMT = tmpfs
+# Compiler
+COMPILER = gcc_cross
+# Debug build
+CONFIG_DEBUG = y
+# Support for userspace debuggers
+CONFIG_UDEBUG = n
+# Kernel console support
+CONFIG_KCONSOLE = y
+# Detailed kernel logging
+CONFIG_LOG = n
+# Compile kernel tests
+CONFIG_TEST = y
+# Framebuffer support
+CONFIG_FB = y

/branches/dynload/contrib/default/ppc32/output
0,0 → 1,0
image.boot

 /branches/dynload/contrib/default/ppc32/Makefile.config
 ,0 → 1,26
+# Platform
+PLATFORM = ppc32
+# Ramdisk format
+RDFMT = tmpfs
+# Compiler
+COMPILER = gcc_cross
+# Debug build
+CONFIG_DEBUG = y
+# Support for userspace debuggers
+CONFIG_UDEBUG = n
+# Kernel console support
+CONFIG_KCONSOLE = y
+# Detailed kernel logging
+CONFIG_LOG = n
+# Compile kernel tests
+CONFIG_TEST = y
+# Use Block Address Translation by the loader
+CONFIG_BAT = y

/branches/dynload/contrib/default/ia32xen/output
0,0 → 1,0
image.iso

 /branches/dynload/contrib/default/ia32xen/Makefile.config
 ,0 → 1,44
+# Platform
+PLATFORM = ia32xen
+# CPU type
+MACHINE = pentium4
+# Ramdisk format
+RDFMT = tmpfs
+# Compiler
+COMPILER = gcc_cross
+# Debug build
+CONFIG_DEBUG = y
+# Support for SMP
+CONFIG_SMP = y
+# Improved support for hyperthreading
+CONFIG_HT = y
+# Lazy FPU context switching
+CONFIG_FPU_LAZY = y
+# Support for userspace debuggers
+CONFIG_UDEBUG = n
+# Kernel console support
+CONFIG_KCONSOLE = y
+# Detailed kernel logging
+CONFIG_LOG = n
+# Deadlock detection support for spinlocks
+CONFIG_DEBUG_SPINLOCK = y
+# Watchpoint on rewriting AS with zero
+CONFIG_DEBUG_AS_WATCHPOINT = y
+# Save all interrupt registers
+CONFIG_DEBUG_ALLREGS = y
+# Compile kernel tests
+CONFIG_TEST = y

/branches/dynload/contrib/default/ppc64/output
0,0 → 1,0
image.boot

 /branches/dynload/contrib/default/ppc64/Makefile.config
 ,0 → 1,23
+# Platform
+PLATFORM = ppc64
+# Ramdisk format
+RDFMT = tmpfs
+# Compiler
+COMPILER = gcc_cross
+# Debug build
+CONFIG_DEBUG = y
+# Support for userspace debuggers
+CONFIG_UDEBUG = n
+# Kernel console support
+CONFIG_KCONSOLE = y
+# Detailed kernel logging
+CONFIG_LOG = n
+# Compile kernel tests
+CONFIG_TEST = y

/branches/dynload/contrib/default/mips32/output
0,0 → 1,0
image.boot

 /branches/dynload/contrib/default/mips32/Makefile.config
 ,0 → 1,35
+# Platform
+PLATFORM = mips32
+# Machine type
+MACHINE = lgxemul
+# Ramdisk format
+RDFMT = tmpfs
+# Compiler
+COMPILER = gcc_cross
+# Debug build
+CONFIG_DEBUG = y
+# Lazy FPU context switching
+CONFIG_FPU_LAZY = y
+# Support for userspace debuggers
+CONFIG_UDEBUG = n
+# Kernel console support
+CONFIG_KCONSOLE = y
+# Detailed kernel logging
+CONFIG_LOG = n
+# Save all interrupt registers
+CONFIG_DEBUG_ALLREGS = y
+# Compile kernel tests
+CONFIG_TEST = y
+# Framebuffer support
+CONFIG_FB = y

/branches/dynload/contrib/default/ia32/output
0,0 → 1,0
image.iso

 /branches/dynload/contrib/default/ia32/Makefile.config
 ,0 → 1,59
+# Platform
+PLATFORM = ia32
+# CPU type
+MACHINE = pentium4
+# Ramdisk format
+RDFMT = tmpfs
+# Compiler
+COMPILER = gcc_cross
+# Debug build
+CONFIG_DEBUG = y
+# Support for SMP
+CONFIG_SMP = y
+# Improved support for hyperthreading
+CONFIG_HT = y
+# Simics BIOS AP boot fix
+CONFIG_SIMICS_FIX = y
+# Lazy FPU context switching
+CONFIG_FPU_LAZY = y
+# Support for userspace debuggers
+CONFIG_UDEBUG = n
+# Kernel console support
+CONFIG_KCONSOLE = y
+# Detailed kernel logging
+CONFIG_LOG = n
+# Deadlock detection support for spinlocks
+CONFIG_DEBUG_SPINLOCK = y
+# Watchpoint on rewriting AS with zero
+CONFIG_DEBUG_AS_WATCHPOINT = y
+# Save all interrupt registers
+CONFIG_DEBUG_ALLREGS = y
+# Compile kernel tests
+CONFIG_TEST = y
+# Framebuffer support
+CONFIG_FB = y
+# Framebuffer width
+CONFIG_VESA_WIDTH = 1024
+# Framebuffer height
+CONFIG_VESA_HEIGHT = 768
+# Framebuffer depth
+CONFIG_VESA_BPP = 24

/branches/dynload/contrib/default/amd64/output
0,0 → 1,0
image.iso

 /branches/dynload/contrib/default/amd64/Makefile.config
 ,0 → 1,59
+# Platform
+PLATFORM = amd64
+# CPU type
+MACHINE = opteron
+# Ramdisk format
+RDFMT = tmpfs
+# Compiler
+COMPILER = gcc_cross
+# Debug build
+CONFIG_DEBUG = y
+# Support for SMP
+CONFIG_SMP = y
+# Improved support for hyperthreading
+CONFIG_HT = y
+# Simics BIOS AP boot fix
+CONFIG_SIMICS_FIX = y
+# Lazy FPU context switching
+CONFIG_FPU_LAZY = y
+# Support for userspace debuggers
+CONFIG_UDEBUG = n
+# Kernel console support
+CONFIG_KCONSOLE = y
+# Detailed kernel logging
+CONFIG_LOG = n
+# Deadlock detection support for spinlocks
+CONFIG_DEBUG_SPINLOCK = y
+# Watchpoint on rewriting AS with zero
+CONFIG_DEBUG_AS_WATCHPOINT = y
+# Save all interrupt registers
+CONFIG_DEBUG_ALLREGS = y
+# Compile kernel tests
+CONFIG_TEST = y
+# Framebuffer support
+CONFIG_FB = y
+# Framebuffer width
+CONFIG_VESA_WIDTH = 1024
+# Framebuffer height
+CONFIG_VESA_HEIGHT = 768
+# Framebuffer depth
+CONFIG_VESA_BPP = 24

 /branches/dynload/kernel/test/synch/rwlock4.c
 ,7 → 60,7
     spinlock_lock(&rw_lock);
     rc = seed % max;
-    seed = (((seed<<2) ^ (seed>>2)) * 487) + rc;
+    seed = (((seed << 2) ^ (seed >> 2)) * 487) + rc;
     spinlock_unlock(&rw_lock);
     return rc;
 }

 /branches/dynload/kernel/test/synch/semaphore2.c
 ,7 → 53,7
     spinlock_lock(&sem_lock);
     rc = seed % max;
-    seed = (((seed<<2) ^ (seed>>2)) * 487) + rc;
+    seed = (((seed << 2) ^ (seed >> 2)) * 487) + rc;
     spinlock_unlock(&sem_lock);
     return rc;
 }

 /branches/dynload/kernel/genarch/src/fb/fb.c
 ,12 → 184,13
 /** Hide logo and refresh screen
  *
  */
-static void logo_hide(void)
+static void logo_hide(bool silent)
 {
     ylogo = 0;
     ytrim = yres;
     rowtrim = rows;
-    fb_redraw();
+    if (!silent)
+        fb_redraw();
 }
 ,7 → 197,7
 /** Draw character at given position
  *
  */
-static void glyph_draw(uint8_t glyph, unsigned int col, unsigned int row)
+static void glyph_draw(uint8_t glyph, unsigned int col, unsigned int row, bool silent)
 {
     unsigned int x = COL2X(col);
     unsigned int y = ROW2Y(row);
 ,13 → 204,15
     unsigned int yd;
     if (y >= ytrim)
-        logo_hide();
+        logo_hide(silent);
     backbuf[BB_POS(col, row)] = glyph;
-    for (yd = 0; yd < FONT_SCANLINES; yd++)
-        memcpy(&fb_addr[FB_POS(x, y + yd + ylogo)],
-            &glyphs[GLYPH_POS(glyph, yd)], glyphscanline);
+    if (!silent) {
+        for (yd = 0; yd < FONT_SCANLINES; yd++)
+            memcpy(&fb_addr[FB_POS(x, y + yd + ylogo)],
+                &glyphs[GLYPH_POS(glyph, yd)], glyphscanline);
+    }
 }
 ,39 → 220,41
  *
  *
  */
-static void screen_scroll(void)
+static void screen_scroll(bool silent)
 {
     if (ylogo > 0) {
-        logo_hide();
+        logo_hide(silent);
         return;
     }
-    unsigned int row;
-    for (row = 0; row < rows; row++) {
-        unsigned int y = ROW2Y(row);
-        unsigned int yd;
+    if (!silent) {
+        unsigned int row;
-        for (yd = 0; yd < FONT_SCANLINES; yd++) {
-            unsigned int x;
-            unsigned int col;
+        for (row = 0; row < rows; row++) {
+            unsigned int y = ROW2Y(row);
+            unsigned int yd;
-            for (col = 0, x = 0; col < cols; col++,
-                x += FONT_WIDTH) {
-                uint8_t glyph;
+            for (yd = 0; yd < FONT_SCANLINES; yd++) {
+                unsigned int x;
+                unsigned int col;
-                if (row < rows - 1) {
-                    if (backbuf[BB_POS(col, row)] ==
-                        backbuf[BB_POS(col, row + 1)])
-                        continue;
+                for (col = 0, x = 0; col < cols; col++,
+                    x += FONT_WIDTH) {
+                    uint8_t glyph;
-                    glyph = backbuf[BB_POS(col, row + 1)];
-                } else
-                    glyph = 0;
-                memcpy(&fb_addr[FB_POS(x, y + yd)],
-                    &glyphs[GLYPH_POS(glyph, yd)],
-                    glyphscanline);
+                    if (row < rows - 1) {
+                        if (backbuf[BB_POS(col, row)] ==
+                            backbuf[BB_POS(col, row + 1)])
+                            continue;
+                        glyph = backbuf[BB_POS(col, row + 1)];
+                    } else
+                        glyph = 0;
+                    memcpy(&fb_addr[FB_POS(x, y + yd)],
+                        &glyphs[GLYPH_POS(glyph, yd)],
+                        glyphscanline);
+                }
             }
         }
     }
 ,15 → 264,15
 }
-static void cursor_put(void)
+static void cursor_put(bool silent)
 {
-    glyph_draw(CURSOR, position % cols, position / cols);
+    glyph_draw(CURSOR, position % cols, position / cols, silent);
 }
-static void cursor_remove(void)
+static void cursor_remove(bool silent)
 {
-    glyph_draw(0, position % cols, position / cols);
+    glyph_draw(0, position % cols, position / cols, silent);
 }
 ,44 → 281,45
  * Emulate basic terminal commands.
  *
  */
-static void fb_putchar(chardev_t *dev, char ch)
+static void fb_putchar(chardev_t *dev, char ch, bool silent)
 {
     spinlock_lock(&fb_lock);
     switch (ch) {
     case '\n':
-        cursor_remove();
+        cursor_remove(silent);
         position += cols;
         position -= position % cols;
         break;
     case '\r':
-        cursor_remove();
+        cursor_remove(silent);
         position -= position % cols;
         break;
     case '\b':
-        cursor_remove();
+        cursor_remove(silent);
         if (position % cols)
             position--;
         break;
     case '\t':
-        cursor_remove();
+        cursor_remove(silent);
         do {
             glyph_draw((uint8_t) ' ', position % cols,
-                position / cols);
+                position / cols, silent);
             position++;
         } while ((position % 8) && (position < cols * rows));
         break;
     default:
-        glyph_draw((uint8_t) ch, position % cols, position / cols);
+        glyph_draw((uint8_t) ch, position % cols,
+            position / cols, silent);
         position++;
     }
     if (position >= cols * rows) {
         position -= cols;
-        screen_scroll();
+        screen_scroll(silent);
     }
-    cursor_put();
+    cursor_put(silent);
     spinlock_unlock(&fb_lock);
 }

 /branches/dynload/kernel/genarch/src/drivers/ega/ega.c
 ,54 → 62,8
 static uint8_t *backbuf;
 static ioport_t ega_base;
-static void ega_putchar(chardev_t *d, const char ch);
 chardev_t ega_console;
-static chardev_operations_t ega_ops = {
-    .write = ega_putchar
-};
-static void ega_move_cursor(void);
-void ega_init(ioport_t base, uintptr_t videoram_phys)
-{
-    /* Initialize the software structure. */
-    ega_base = base;
-    backbuf = (uint8_t *) malloc(SCREEN * 2, 0);
-    if (!backbuf)
-        panic("Unable to allocate backbuffer.");
-    videoram = (uint8_t *) hw_map(videoram_phys, SCREEN * 2);
-    /* Clear the screen and set the cursor position. */
-    memsetw(videoram, SCREEN, 0x0720);
-    memsetw(backbuf, SCREEN, 0x0720);
-    ega_move_cursor();
-    chardev_initialize("ega_out", &ega_console, &ega_ops);
-    stdout = &ega_console;
-    ega_parea.pbase = videoram_phys;
-    ega_parea.vbase = (uintptr_t) videoram;
-    ega_parea.frames = 1;
-    ega_parea.cacheable = false;
-    ddi_parea_register(&ega_parea);
-    sysinfo_set_item_val("fb", NULL, true);
-    sysinfo_set_item_val("fb.kind", NULL, 2);
-    sysinfo_set_item_val("fb.width", NULL, ROW);
-    sysinfo_set_item_val("fb.height", NULL, ROWS);
-    sysinfo_set_item_val("fb.blinking", NULL, true);
-    sysinfo_set_item_val("fb.address.physical", NULL, videoram_phys);
-}
-static void ega_display_char(char ch)
-{
-    videoram[ega_cursor * 2] = ch;
-    backbuf[ega_cursor * 2] = ch;
-}
 /*
  * This function takes care of scrolling.
  */
 ,13 → 81,29
     ega_cursor = ega_cursor - ROW;
 }
-void ega_putchar(chardev_t *d __attribute__((unused)), const char ch)
+static void ega_move_cursor(void)
 {
+    outb(ega_base + EGA_INDEX_REG, 0xe);
+    outb(ega_base + EGA_DATA_REG, (uint8_t) ((ega_cursor >> 8) & 0xff));
+    outb(ega_base + EGA_INDEX_REG, 0xf);
+    outb(ega_base + EGA_DATA_REG, (uint8_t) (ega_cursor & 0xff));
+}
+static void ega_display_char(char ch, bool silent)
+{
+    backbuf[ega_cursor * 2] = ch;
+    if (!silent)
+        videoram[ega_cursor * 2] = ch;
+}
+static void ega_putchar(chardev_t *d __attribute__((unused)), const char ch, bool silent)
+{
     ipl_t ipl;
     ipl = interrupts_disable();
     spinlock_lock(&egalock);
     switch (ch) {
     case '\n':
         ega_cursor = (ega_cursor + ROW) - ega_cursor % ROW;
 ,23 → 116,54
             ega_cursor--;
         break;
     default:
-        ega_display_char(ch);
+        ega_display_char(ch, silent);
         ega_cursor++;
         break;
     }
     ega_check_cursor();
-    ega_move_cursor();
+    if (!silent)
+        ega_move_cursor();
     spinlock_unlock(&egalock);
     interrupts_restore(ipl);
 }
-void ega_move_cursor(void)
+static chardev_operations_t ega_ops = {
+    .write = ega_putchar
+};
+void ega_init(ioport_t base, uintptr_t videoram_phys)
 {
-    outb(ega_base + EGA_INDEX_REG, 0xe);
-    outb(ega_base + EGA_DATA_REG, (uint8_t) ((ega_cursor >> 8) & 0xff));
-    outb(ega_base + EGA_INDEX_REG, 0xf);
-    outb(ega_base + EGA_DATA_REG, (uint8_t) (ega_cursor & 0xff));
+    /* Initialize the software structure. */
+    ega_base = base;
+    backbuf = (uint8_t *) malloc(SCREEN * 2, 0);
+    if (!backbuf)
+        panic("Unable to allocate backbuffer.");
+    videoram = (uint8_t *) hw_map(videoram_phys, SCREEN * 2);
+    /* Clear the screen and set the cursor position. */
+    memsetw(videoram, SCREEN, 0x0720);
+    memsetw(backbuf, SCREEN, 0x0720);
+    ega_move_cursor();
+    chardev_initialize("ega_out", &ega_console, &ega_ops);
+    stdout = &ega_console;
+    ega_parea.pbase = videoram_phys;
+    ega_parea.vbase = (uintptr_t) videoram;
+    ega_parea.frames = 1;
+    ega_parea.cacheable = false;
+    ddi_parea_register(&ega_parea);
+    sysinfo_set_item_val("fb", NULL, true);
+    sysinfo_set_item_val("fb.kind", NULL, 2);
+    sysinfo_set_item_val("fb.width", NULL, ROW);
+    sysinfo_set_item_val("fb.height", NULL, ROWS);
+    sysinfo_set_item_val("fb.blinking", NULL, true);
+    sysinfo_set_item_val("fb.address.physical", NULL, videoram_phys);
 }
 void ega_redraw(void)

 /branches/dynload/kernel/generic/include/interrupt.h
 ,8 → 48,8
 { \
     if (istate_from_uspace(istate)) { \
         task_t *task = TASK; \
-        printf("Task %" PRIu64 " killed due to an exception at %p.", task->taskid, istate_get_pc(istate)); \
-        printf("  " fmt "\n", ##__VA_ARGS__); \
+        printf("Task %s (%" PRIu64 ") killed due to an exception at %p: ", task->name, task->taskid, istate_get_pc(istate)); \
+        printf(fmt "\n", ##__VA_ARGS__); \
         task_kill(task->taskid); \
         thread_exit(); \
     } \

 /branches/dynload/kernel/generic/include/console/chardev.h
 ,7 → 50,7
     /** Resume pushing characters. */
     void (* resume)(struct chardev *);
     /** Write character to stream. */
-    void (* write)(struct chardev *, char c);
+    void (* write)(struct chardev *, char c, bool silent);
     /** Read character directly from device, assume interrupts disabled. */
     char (* read)(struct chardev *);
 } chardev_operations_t;

 /branches/dynload/kernel/generic/include/console/console.h
 ,6 → 49,9
 extern count_t gets(chardev_t *chardev, char *buf, size_t buflen);
 extern void putchar(char c);
+extern void grab_console(void);
+extern void release_console(void);
 extern void arch_grab_console(void);
 extern void arch_release_console(void);

 /branches/dynload/kernel/generic/include/macros.h
 ,6 → 76,18
 #define STRING(arg) STRING_ARG(arg)
 #define STRING_ARG(arg) #arg
+/** Pseudorandom generator
+ *
+ * A pretty standard linear congruential pseudorandom
+ * number generator (m = 2^32 or 2^64 depending on architecture).
+ *
+ */
+#define RANDI(seed) \
+    ({ \
+        (seed) = 1103515245 * (seed) + 12345; \
+        (seed); \
+    })
 #endif
 /** @}

/branches/dynload/kernel/generic/include/syscall/syscall.h
62,6 → 62,7
SYS_IPC_ANSWER_FAST,
SYS_IPC_ANSWER_SLOW,
SYS_IPC_FORWARD_FAST,
SYS_IPC_FORWARD_SLOW,
SYS_IPC_WAIT,
SYS_IPC_HANGUP,
SYS_IPC_REGISTER_IRQ,
79,6 → 80,7

SYS_DEBUG_PUTINT,
SYS_DEBUG_ENABLE_CONSOLE,
SYS_DEBUG_DISABLE_CONSOLE,
SYS_IPC_CONNECT_KBOX,
SYSCALL_END
} syscall_t;

 /branches/dynload/kernel/generic/include/ipc/sysipc.h
 ,6 → 53,8
     int nonblocking);
 unative_t sys_ipc_forward_fast(unative_t callid, unative_t phoneid,
     unative_t method, unative_t arg1, unative_t arg2, int mode);
+unative_t sys_ipc_forward_slow(unative_t callid, unative_t phoneid,
+    ipc_data_t *data, int mode);
 unative_t sys_ipc_hangup(int phoneid);
 unative_t sys_ipc_register_irq(inr_t inr, devno_t devno, unative_t method,
     irq_code_t *ucode);

 /branches/dynload/kernel/generic/src/main/kinit.c
 ,6 → 72,10
 #include <synch/waitq.h>
 #include <synch/spinlock.h>
+#define ALIVE_CHARS  4
+static char alive[ALIVE_CHARS] = "-\\|/";
 /** Kernel initialization thread.
  *
  * kinit takes care of higher level kernel
 ,11 → 208,12
 #ifdef CONFIG_KCONSOLE
     if (!stdin) {
-        printf("kinit: No stdin\nKernel alive: ");
+        thread_sleep(10);
+        printf("kinit: No stdin\nKernel alive: .");
-        uint64_t i = 0;
-        while (1) {
-            printf(PRIu64 " ", i);
+        unsigned int i = 0;
+        while (true) {
+            printf("\b%c", alive[i % ALIVE_CHARS]);
             thread_sleep(1);
             i++;
         }

 /branches/dynload/kernel/generic/src/console/console.c
 ,12 → 65,15
 /**< Number of stored kernel log characters for uspace */
 static size_t klog_uspace = 0;
+/**< Silent output */
+static bool silent = false;
 /**< Kernel log spinlock */
 SPINLOCK_INITIALIZE(klog_lock);
 /** Physical memory area used for klog buffer */
 static parea_t klog_parea;
 /*
  * For now, we use 0 as INR.
  * However, it is therefore desirable to have architecture specific
 ,6 → 147,18
     spinlock_unlock(&klog_lock);
 }
+void grab_console(void)
+{
+    silent = false;
+    arch_grab_console();
+}
+void release_console(void)
+{
+    silent = true;
+    arch_release_console();
+}
 /** Get character from character device. Do not echo character.
  *
  * @param chardev Character device.
 ,7 → 214,7
 {
     index_t index = 0;
     char ch;
     while (index < buflen) {
         ch = _getc(chardev);
         if (ch == '\b') {
 ,7 → 228,7
             continue;
         }
         putchar(ch);
         if (ch == '\n') { /* end of string => write 0, return */
             buf[index] = '\0';
             return (count_t) index;
 ,7 → 268,7
         /* Print charaters stored in kernel log */
         index_t i;
         for (i = klog_len - klog_stored; i < klog_len; i++)
-            stdout->op->write(stdout, klog[(klog_start + i) % KLOG_SIZE]);
+            stdout->op->write(stdout, klog[(klog_start + i) % KLOG_SIZE], silent);
         klog_stored = 0;
     }
 ,7 → 280,7
         klog_start = (klog_start + 1) % KLOG_SIZE;
     if (stdout->op->write)
-        stdout->op->write(stdout, c);
+        stdout->op->write(stdout, c, silent);
     else {
         /* The character is just in the kernel log */
         if (klog_stored < klog_len)

 /branches/dynload/kernel/generic/src/console/cmd.c
 ,7 → 976,7
 int cmd_continue(cmd_arg_t *argv)
 {
     printf("The kernel will now relinquish the console.\n");
-    arch_release_console();
+    release_console();
     if ((kconsole_notify) && (kconsole_irq.notif_cfg.notify))
         ipc_irq_send_msg_0(&kconsole_irq);

 /branches/dynload/kernel/generic/src/printf/vprintf.c
 ,13 → 62,13
 {
     struct printf_spec ps = {(int(*)(void *, size_t, void *)) vprintf_write, NULL};
-    int irqpri = interrupts_disable();
+    ipl_t ipl = interrupts_disable();
     spinlock_lock(&printf_lock);
     int ret = printf_core(fmt, &ps, ap);
     spinlock_unlock(&printf_lock);
-    interrupts_restore(irqpri);
+    interrupts_restore(ipl);
     return ret;
 }

 /branches/dynload/kernel/generic/src/syscall/syscall.c
 ,7 → 62,6
  */
 static unative_t sys_klog(int fd, const void * buf, size_t count)
 {
-    size_t i;
     char *data;
     int rc;
 ,7 → 69,7
         return ELIMIT;
     if (count > 0) {
-        data = (char *) malloc(count, 0);
+        data = (char *) malloc(count + 1, 0);
         if (!data)
             return ENOMEM;
 ,9 → 78,9
             free(data);
             return rc;
         }
-        for (i = 0; i < count; i++)
-            putchar(data[i]);
+        data[count] = 0;
+        printf("%s", data);
         free(data);
     } else
         klog_update();
 ,7 → 92,7
 static unative_t sys_debug_enable_console(void)
 {
 #ifdef CONFIG_KCONSOLE
-    arch_grab_console();
+    grab_console();
     return true;
 #else
     return false;
 ,6 → 106,13
     return 0;
 }
+/** Tell kernel to relinquish keyboard/console access */
+static unative_t sys_debug_disable_console(void)
+{
+    release_console();
+    return true;
+}
 /** Dispatch system call */
 unative_t syscall_handler(unative_t a1, unative_t a2, unative_t a3,
     unative_t a4, unative_t a5, unative_t a6, unative_t id)
 ,6 → 177,7
     (syshandler_t) sys_ipc_answer_fast,
     (syshandler_t) sys_ipc_answer_slow,
     (syshandler_t) sys_ipc_forward_fast,
+    (syshandler_t) sys_ipc_forward_slow,
     (syshandler_t) sys_ipc_wait_for_call,
     (syshandler_t) sys_ipc_hangup,
     (syshandler_t) sys_ipc_register_irq,
 ,7 → 199,8
     /* Debug calls */
     (syshandler_t) sys_debug_putint,
     (syshandler_t) sys_debug_enable_console,
+    (syshandler_t) sys_debug_disable_console,
     (syshandler_t) sys_ipc_connect_kbox
 };

 /branches/dynload/kernel/generic/src/ipc/sysipc.c
 ,7 → 618,8
     return (unative_t) call;
 }
-/** Forward a received call to another destination.
+/** Forward a received call to another destination - common code for both the
+ * fast and the slow version.
  *
  * @param callid    Hash of the call to forward.
  * @param phoneid   Phone handle to use for forwarding.
 ,23 → 626,21
  * @param method    New method to use for the forwarded call.
  * @param arg1      New value of the first argument for the forwarded call.
  * @param arg2      New value of the second argument for the forwarded call.
+ * @param arg3      New value of the third argument for the forwarded call.
+ * @param arg4      New value of the fourth argument for the forwarded call.
+ * @param arg5      New value of the fifth argument for the forwarded call.
  * @param mode      Flags that specify mode of the forward operation.
+ * @param slow      If true, arg3, arg4 and arg5 are considered. Otherwise
+ *          the function considers only the fast version arguments:
+ *          i.e. arg1 and arg2.
  *
  * @return      Return 0 on succes, otherwise return an error code.
  *
- * In case the original method is a system method, ARG1, ARG2 and ARG3 are
- * overwritten in the forwarded message with the new method and the new arg1 and
- * arg2, respectively. Otherwise the METHOD, ARG1 and ARG2 are rewritten with
- * the new method, arg1 and arg2, respectively. Also note there is a set of
- * immutable methods, for which the new method and argument is not set and
- * these values are ignored.
- *
- * Warning: When implementing support for changing additional payload
- *      arguments, make sure that ARG5 is not rewritten for certain
- *      system IPC
+ * Warning: Make sure that ARG5 is not rewritten for certain system IPC
  */
-unative_t sys_ipc_forward_fast(unative_t callid, unative_t phoneid,
-    unative_t method, unative_t arg1, unative_t arg2, int mode)
+static unative_t sys_ipc_forward_common(unative_t callid, unative_t phoneid,
+    unative_t method, unative_t arg1, unative_t arg2, unative_t arg3,
+    unative_t arg4, unative_t arg5, int mode, bool slow)
 {
     call_t *call;
     phone_t *phone;
 ,7 → 648,7
     call = get_call(callid);
     if (!call)
         return ENOENT;
     call->flags |= IPC_CALL_FORWARDED;
     GET_CHECK_PHONE(phone, phoneid, {
 ,8 → 665,8
     /*
      * Userspace is not allowed to change method of system methods on
-     * forward, allow changing ARG1, ARG2 and ARG3 by means of method,
-     * arg1 and arg2.
+     * forward, allow changing ARG1, ARG2, ARG3 and ARG4 by means of method,
+     * arg1, arg2 and arg3.
      * If the method is immutable, don't change anything.
      */
     if (!method_is_immutable(IPC_GET_METHOD(call->data))) {
 ,10 → 677,22
             IPC_SET_ARG1(call->data, method);
             IPC_SET_ARG2(call->data, arg1);
             IPC_SET_ARG3(call->data, arg2);
+            if (slow) {
+                IPC_SET_ARG4(call->data, arg3);
+                /*
+                 * For system methods we deliberately don't
+                 * overwrite ARG5.
+                 */
+            }
         } else {
             IPC_SET_METHOD(call->data, method);
             IPC_SET_ARG1(call->data, arg1);
             IPC_SET_ARG2(call->data, arg2);
+            if (slow) {
+                IPC_SET_ARG3(call->data, arg3);
+                IPC_SET_ARG4(call->data, arg4);
+                IPC_SET_ARG5(call->data, arg5);
+            }
         }
     }
 ,6 → 699,64
     return ipc_forward(call, phone, &TASK->answerbox, mode);
 }
+/** Forward a received call to another destination - fast version.
+ *
+ * @param callid    Hash of the call to forward.
+ * @param phoneid   Phone handle to use for forwarding.
+ * @param method    New method to use for the forwarded call.
+ * @param arg1      New value of the first argument for the forwarded call.
+ * @param arg2      New value of the second argument for the forwarded call.
+ * @param mode      Flags that specify mode of the forward operation.
+ *
+ * @return      Return 0 on succes, otherwise return an error code.
+ *
+ * In case the original method is a system method, ARG1, ARG2 and ARG3 are
+ * overwritten in the forwarded message with the new method and the new
+ * arg1 and arg2, respectively. Otherwise the METHOD, ARG1 and ARG2 are
+ * rewritten with the new method, arg1 and arg2, respectively. Also note there
+ * is a set of immutable methods, for which the new method and arguments are not
+ * set and these values are ignored.
+ */
+unative_t sys_ipc_forward_fast(unative_t callid, unative_t phoneid,
+    unative_t method, unative_t arg1, unative_t arg2, int mode)
+{
+    return sys_ipc_forward_common(callid, phoneid, method, arg1, arg2, 0, 0,
+, mode, false);
+}
+/** Forward a received call to another destination - slow version.
+ *
+ * @param callid    Hash of the call to forward.
+ * @param phoneid   Phone handle to use for forwarding.
+ * @param data      Userspace address of the new IPC data.
+ * @param mode      Flags that specify mode of the forward operation.
+ *
+ * @return      Return 0 on succes, otherwise return an error code.
+ *
+ * This function is the slow verision of the sys_ipc_forward_fast interface.
+ * It can copy all five new arguments and the new method from the userspace.
+ * It naturally extends the functionality of the fast version. For system
+ * methods, it additionally stores the new value of arg3 to ARG4. For non-system
+ * methods, it additionally stores the new value of arg3, arg4 and arg5,
+ * respectively, to ARG3, ARG4 and ARG5, respectively.
+ */
+unative_t sys_ipc_forward_slow(unative_t callid, unative_t phoneid,
+    ipc_data_t *data, int mode)
+{
+    ipc_data_t newdata;
+    int rc;
+    rc = copy_from_uspace(&newdata.args, &data->args,
+        sizeof(newdata.args));
+    if (rc != 0)
+        return (unative_t) rc;
+    return sys_ipc_forward_common(callid, phoneid,
+        IPC_GET_METHOD(newdata), IPC_GET_ARG1(newdata),
+        IPC_GET_ARG2(newdata), IPC_GET_ARG3(newdata),
+        IPC_GET_ARG4(newdata), IPC_GET_ARG5(newdata), mode, true);
+}
 /** Answer an IPC call - fast version.
  *
  * This function can handle only two return arguments of payload, but is faster

 /branches/dynload/kernel/arch/sparc64/src/drivers/sgcn.c
 ,7 → 146,7
 /* functions referenced from definitions of I/O operations structures */
 static void sgcn_noop(chardev_t *);
-static void sgcn_putchar(chardev_t *, const char);
+static void sgcn_putchar(chardev_t *, const char, bool);
 static char sgcn_key_read(chardev_t *);
 /** character device operations */
 ,16 → 295,17
  * feed character is written ('\n'), the carriage return character ('\r') is
  * written straight away.
  */
-static void sgcn_putchar(struct chardev * cd, const char c)
+static void sgcn_putchar(struct chardev * cd, const char c, bool silent)
 {
-    spinlock_lock(&sgcn_output_lock);
-    sgcn_do_putchar(c);
-    if (c == '\n') {
-        sgcn_do_putchar('\r');
+    if (!silent) {
+        spinlock_lock(&sgcn_output_lock);
+        sgcn_do_putchar(c);
+        if (c == '\n')
+            sgcn_do_putchar('\r');
+        spinlock_unlock(&sgcn_output_lock);
     }
-    spinlock_unlock(&sgcn_output_lock);
 }
 /**

 /branches/dynload/kernel/arch/ia64/src/ia64.c
 ,8 → 254,8
     ns16550_grab();
 #else
     i8042_grab();
-#endif
-#endif
+#endif
+#endif
 }
 /** Return console to userspace

 /branches/dynload/kernel/arch/ia64/src/ski/ski.c
 ,9 → 56,6
 static bool kbd_disabled;
-static void ski_putchar(chardev_t *d, const char ch);
-static int32_t ski_getchar(void);
 /** Display character on debug console
  *
  * Use SSC (Simulator System Call) to
 ,19 → 64,21
  * @param d Character device.
  * @param ch Character to be printed.
  */
-void ski_putchar(chardev_t *d, const char ch)
+static void ski_putchar(chardev_t *d, const char ch, bool silent)
 {
-    asm volatile (
-        "mov r15 = %0\n"
-        "mov r32 = %1\n"    /* r32 is in0 */
-        "break 0x80000\n"   /* modifies r8 */
-        :
-        : "i" (SKI_PUTCHAR), "r" (ch)
-        : "r15", "in0", "r8"
-    );
-    if (ch == '\n')
-        ski_putchar(d, '\r');
+    if (!silent) {
+        asm volatile (
+            "mov r15 = %0\n"
+            "mov r32 = %1\n"   /* r32 is in0 */
+            "break 0x80000\n"  /* modifies r8 */
+            :
+            : "i" (SKI_PUTCHAR), "r" (ch)
+            : "r15", "in0", "r8"
+        );
+        if (ch == '\n')
+            ski_putchar(d, '\r', false);
+    }
 }
 /** Ask debug console if a key was pressed.
 ,7 → 90,7
  *
  * @return ASCII code of pressed key or 0 if no key pressed.
  */
-int32_t ski_getchar(void)
+static int32_t ski_getchar(void)
 {
     uint64_t ch;

 /branches/dynload/kernel/arch/arm32/include/machine.h
 ,18 → 102,17
 extern uintptr_t machine_get_fb_address(void);
-#ifdef MACHINE_GXEMUL_TESTARM
-#define machine_console_init(devno)           gxemul_console_init(devno)
-#define machine_grab_console                  gxemul_grab_console
-#define machine_release_console               gxemul_release_console
-#define machine_hw_map_init                   gxemul_hw_map_init
-#define machine_timer_irq_start               gxemul_timer_irq_start
-#define machine_cpu_halt                      gxemul_cpu_halt
-#define machine_get_memory_size               gxemul_get_memory_size
-#define machine_debug_putc(ch)                gxemul_debug_putc(ch)
-#define machine_irq_exception(exc_no, istate) \
-        gxemul_irq_exception(exc_no, istate)
-#define machine_get_fb_address                gxemul_get_fb_address
+#ifdef MACHINE_GXEMUL_TESTARM
+    #define machine_console_init(devno)            gxemul_console_init(devno)
+    #define machine_grab_console                   gxemul_grab_console
+    #define machine_release_console                gxemul_release_console
+    #define machine_hw_map_init                    gxemul_hw_map_init
+    #define machine_timer_irq_start                gxemul_timer_irq_start
+    #define machine_cpu_halt                       gxemul_cpu_halt
+    #define machine_get_memory_size                gxemul_get_memory_size
+    #define machine_debug_putc(ch)                 gxemul_debug_putc(ch)
+    #define machine_irq_exception(exc_no, istate)  gxemul_irq_exception(exc_no, istate)
+    #define machine_get_fb_address                 gxemul_get_fb_address
 #endif
 #endif

 /branches/dynload/kernel/arch/arm32/src/drivers/gxemul.c
 ,9 → 133,10
  * @param dev Not used.
  * @param ch Characted to be printed.
  */
-static void gxemul_write(chardev_t *dev, const char ch)
+static void gxemul_write(chardev_t *dev, const char ch, bool silent)
 {
-    *((char *) gxemul_hw_map.videoram) = ch;
+    if (!silent)
+        *((char *) gxemul_hw_map.videoram) = ch;
 }
 /** Enables gxemul keyboard (interrupt unmasked).

 /branches/dynload/kernel/arch/ppc32/_link.ld.in
 ,11 → 1,11
 /** PPC32 linker script
  *
  * umapped section:
- *  kernel text
- *  kernel data
+ *  kernel text
+ *  kernel data
  * mapped section:
- *  kernel text
- *  kernel data
+ *  kernel text
+ *  kernel data
  *
  */
 ,7 → 27,7
         unmapped_kdata_start = .;
     }
-    .mapped PA2KA(BOOT_OFFSET): AT (BOOT_OFFSET) {
+    .mapped PA2KA(BOOT_OFFSET): AT (BOOT_OFFSET) {
         ktext_start = .;
         *(K_TEXT_START);
         *(.text);
 ,22 → 37,22
         *(K_DATA_START);
         *(.rodata);
         *(.rodata.*);
-        *(.data);       /* initialized data */
+        *(.data);       /* initialized data */
         *(.sdata);
         *(.sdata2);
         *(.sbss);
         hardcoded_ktext_size = .;
-        LONG(ktext_end - ktext_start);
+        LONG(ktext_end - ktext_start);
         hardcoded_kdata_size = .;
         LONG(kdata_end - kdata_start);
         hardcoded_load_address = .;
         LONG(PA2KA(BOOT_OFFSET));
-        *(.bss);        /* uninitialized static variables */
-        *(COMMON);      /* global variables */
+        *(.bss);        /* uninitialized static variables */
+        *(COMMON);      /* global variables */
         symbol_table = .;
-        *(symtab.*);            /* Symbol table, must be LAST symbol!*/
+        *(symtab.*);    /* Symbol table, must be LAST symbol!*/
         kdata_end = .;
     }
 }

 /branches/dynload/kernel/arch/ppc32/include/asm/regname.h
 ,6 → 211,9
 #define dbat2l  541
 #define dbat3u  542
 #define dbat3l  543
+#define tlbmiss 980
+#define ptehi   981
+#define ptelo   982
 #define hid0    1008
 /* MSR bits */
 ,6 → 223,7
 #define msr_ee  (1 << 15)
 /* HID0 bits */
+#define hid0_sten   (1 << 24)
 #define hid0_ice    (1 << 15)
 #define hid0_dce    (1 << 14)
 #define hid0_icfi   (1 << 11)

/branches/dynload/kernel/arch/ppc32/include/exception.h
75,6 → 75,7
uint32_t lr;
uint32_t ctr;
uint32_t xer;
uint32_t dar;
uint32_t r12;
uint32_t sp;
} istate_t;

 /branches/dynload/kernel/arch/ppc32/include/types.h
 ,11 → 84,13
 /** Page Table Entry. */
 typedef struct {
-    unsigned p : 1;       /**< Present bit. */
-    unsigned a : 1;       /**< Accessed bit. */
-    unsigned g : 1;       /**< Global bit. */
-    unsigned valid : 1;   /**< Valid content even if not present. */
-    unsigned pfn : 20;    /**< Physical frame number. */
+    unsigned present : 1;             /**< Present bit. */
+    unsigned page_write_through : 1;  /**< Write thought caching. */
+    unsigned page_cache_disable : 1;  /**< No caching. */
+    unsigned accessed : 1;            /**< Accessed bit. */
+    unsigned global : 1;              /**< Global bit. */
+    unsigned valid : 1;               /**< Valid content even if not present. */
+    unsigned pfn : 20;                /**< Physical frame number. */
 } pte_t;
 #endif

 /branches/dynload/kernel/arch/ppc32/include/boot/boot.h
 ,13 → 79,13
 typedef struct {
     uintptr_t addr;
     unsigned int size;
-} keyboard_t;
+} macio_t;
 typedef struct {
     memmap_t memmap;
     taskmap_t taskmap;
     screen_t screen;
-    keyboard_t keyboard;
+    macio_t macio;
 } bootinfo_t;
 extern bootinfo_t bootinfo;

 /branches/dynload/kernel/arch/ppc32/include/mm/page.h
 ,7 → 120,7
 /* Macros for querying the last-level PTEs. */
 #define PTE_VALID_ARCH(pte)         (*((uint32_t *) (pte)) != 0)
-#define PTE_PRESENT_ARCH(pte)           ((pte)->p != 0)
+#define PTE_PRESENT_ARCH(pte)           ((pte)->present != 0)
 #define PTE_GET_FRAME_ARCH(pte)         ((pte)->pfn << 12)
 #define PTE_WRITABLE_ARCH(pte)          1
 #define PTE_EXECUTABLE_ARCH(pte)        1
 ,13 → 134,13
 {
     pte_t *p = &pt[i];
-    return ((1 << PAGE_CACHEABLE_SHIFT) |
-        ((!p->p) << PAGE_PRESENT_SHIFT) |
+    return (((!p->page_cache_disable) << PAGE_CACHEABLE_SHIFT) |
+        ((!p->present) << PAGE_PRESENT_SHIFT) |
         (1 << PAGE_USER_SHIFT) |
         (1 << PAGE_READ_SHIFT) |
         (1 << PAGE_WRITE_SHIFT) |
         (1 << PAGE_EXEC_SHIFT) |
-        (p->g << PAGE_GLOBAL_SHIFT));
+        (p->global << PAGE_GLOBAL_SHIFT));
 }
 static inline void set_pt_flags(pte_t *pt, index_t i, int flags)
 ,8 → 147,9
 {
     pte_t *p = &pt[i];
-    p->p = !(flags & PAGE_NOT_PRESENT);
-    p->g = (flags & PAGE_GLOBAL) != 0;
+    p->page_cache_disable = !(flags & PAGE_CACHEABLE);
+    p->present = !(flags & PAGE_NOT_PRESENT);
+    p->global = (flags & PAGE_GLOBAL) != 0;
     p->valid = 1;
 }

 /branches/dynload/kernel/arch/ppc32/include/mm/tlb.h
 ,6 → 39,11
 #include <arch/types.h>
 #include <typedefs.h>
+#define WIMG_GUARDED    0x01
+#define WIMG_COHERENT   0x02
+#define WIMG_NO_CACHE   0x04
+#define WIMG_WRITETHRU  0x08
 typedef struct {
     unsigned v : 1;          /**< Valid */
     unsigned vsid : 24;      /**< Virtual Segment ID */
 ,9 → 58,27
     unsigned pp : 2;         /**< Page protection */
 } phte_t;
+typedef struct {
+    unsigned v : 1;
+    unsigned vsid : 24;
+    unsigned reserved0 : 1;
+    unsigned api : 6;
+} ptehi_t;
+typedef struct {
+    unsigned rpn : 20;
+    unsigned xpn : 3;
+    unsigned reserved0 : 1;
+    unsigned c : 1;
+    unsigned wimg : 4;
+    unsigned x : 1;
+    unsigned pp : 2;
+} ptelo_t;
+extern void pht_init(void);
 extern void pht_refill(int n, istate_t *istate);
-extern bool pht_real_refill(int n, istate_t *istate) __attribute__ ((section("K_UNMAPPED_TEXT_START")));
-extern void pht_init(void);
+extern bool pht_refill_real(int n, istate_t *istate) __attribute__ ((section("K_UNMAPPED_TEXT_START")));
+extern void tlb_refill_real(int n, uint32_t tlbmiss, ptehi_t ptehi, ptelo_t ptelo, istate_t *istate) __attribute__ ((section("K_UNMAPPED_TEXT_START")));
 #endif

 /branches/dynload/kernel/arch/ppc32/include/barrier.h
 ,6 → 55,7
         "dcbst 0, %0\n"
         "sync\n"
         "icbi 0, %0\n"
+        "sync\n"
         "isync\n"
         :: "r" (addr)
     );
 ,7 → 77,10
         asm volatile ("icbi 0, %0\n" :: "r" (addr + i));
     }
-    asm volatile ("isync");
+    asm volatile (
+        "sync\n"
+        "isync\n"
+    );
 }
 #endif

 /branches/dynload/kernel/arch/ppc32/src/exception.S
 ,7 → 60,7
 :
-    subi sp, sp, 160
+    subi sp, sp, 164
     stw r0, 8(sp)
     stw r2, 12(sp)
     stw r3, 16(sp)
 ,11 → 109,14
     mfxer r12
     stw r12, 148(sp)
-    mfsprg1 r12
+    mfdar r12
     stw r12, 152(sp)
+    mfsprg1 r12
+    stw r12, 156(sp)
     mfsprg2 r12
-    stw r12, 156(sp)
+    stw r12, 160(sp)
 .endm
 .org 0x100
 ,16 → 140,7
 exc_data_storage:
     CONTEXT_STORE
-    li r3, 2
-    mr r4, sp
-    addi r4, r4, 8
-    bl pht_real_refill
-    cmpwi r3, 0
-    bne iret_real
-    li r3, 2
-    b jump_to_kernel
+    b data_storage
 .org 0x400
 .global exc_instruction_storage
 ,17 → 147,8
 exc_instruction_storage:
     CONTEXT_STORE
-    li r3, 3
-    mr r4, sp
-    addi r4, r4, 8
-    bl pht_real_refill
-    cmpwi r3, 0
-    bne iret_real
+    b instruction_storage
-    li r3, 3
-    b jump_to_kernel
 .org 0x500
 .global exc_external
 exc_external:
 ,7 → 208,7
 .org 0xc00
 .global exc_syscall
 exc_syscall:
-    CONTEXT_STORE
+    CONTEXT_STORE
     b jump_to_kernel_syscall
 ,7 → 220,63
     li r3, 12
     b jump_to_kernel
+.org 0x1000
+.global exc_itlb_miss
+exc_itlb_miss:
+    CONTEXT_STORE
+    b tlb_miss
+.org 0x1100
+.global exc_dtlb_miss_load
+exc_dtlb_miss_load:
+    CONTEXT_STORE
+    b tlb_miss
+.org 0x1200
+.global exc_dtlb_miss_store
+exc_dtlb_miss_store:
+    CONTEXT_STORE
+    b tlb_miss
 .org 0x4000
+data_storage:
+    li r3, 2
+    mr r4, sp
+    addi r4, r4, 8
+    bl pht_refill_real
+    cmpwi r3, 0
+    bne iret_real
+    li r3, 2
+    b jump_to_kernel
+instruction_storage:
+    li r3, 3
+    mr r4, sp
+    addi r4, r4, 8
+    bl pht_refill_real
+    cmpwi r3, 0
+    bne iret_real
+    li r3, 3
+    b jump_to_kernel
+tlb_miss:
+    li r3, 16
+    mfspr r4, tlbmiss
+    mfspr r5, ptehi
+    mfspr r6, ptelo
+    mr r7, sp
+    addi r7, r7, 20
+    bl tlb_refill_real
+    b iret_real
 jump_to_kernel:
     lis r12, iret@ha
     addi r12, r12, iret@l
 ,7 → 313,6
     rfi
 iret_real:
     lwz r0, 8(sp)
     lwz r2, 12(sp)
     lwz r3, 16(sp)
 ,7 → 362,7
     lwz r12, 148(sp)
     mtxer r12
-    lwz r12, 152(sp)
-    lwz sp, 156(sp)
+    lwz r12, 156(sp)
+    lwz sp, 160(sp)
     rfi

 /branches/dynload/kernel/arch/ppc32/src/asm.S
 ,8 → 131,8
     lwz r12, 148(sp)
     mtxer r12
-    lwz r12, 152(sp)
-    lwz sp, 156(sp)
+    lwz r12, 156(sp)
+    lwz sp, 160(sp)
     rfi
 ,8 → 197,8
     lwz r12, 148(sp)
     mtxer r12
-    lwz r12, 152(sp)
-    lwz sp, 156(sp)
+    lwz r12, 156(sp)
+    lwz sp, 160(sp)
     rfi

 /branches/dynload/kernel/arch/ppc32/src/ppc32.c
 ,43 → 76,47
 {
     if (config.cpu_active == 1) {
         /* Initialize framebuffer */
-        unsigned int visual;
-        switch (bootinfo.screen.bpp) {
-        case 8:
-            visual = VISUAL_INDIRECT_8;
-            break;
-        case 16:
-            visual = VISUAL_RGB_5_5_5;
-            break;
-        case 24:
-            visual = VISUAL_RGB_8_8_8;
-            break;
-        case 32:
-            visual = VISUAL_RGB_0_8_8_8;
-            break;
-        default:
-            panic("Unsupported bits per pixel.");
+        if (bootinfo.screen.addr) {
+            unsigned int visual;
+            switch (bootinfo.screen.bpp) {
+            case 8:
+                visual = VISUAL_INDIRECT_8;
+                break;
+            case 16:
+                visual = VISUAL_RGB_5_5_5;
+                break;
+            case 24:
+                visual = VISUAL_RGB_8_8_8;
+                break;
+            case 32:
+                visual = VISUAL_RGB_0_8_8_8;
+                break;
+            default:
+                panic("Unsupported bits per pixel.");
+            }
+            fb_properties_t prop = {
+                .addr = bootinfo.screen.addr,
+                .offset = 0,
+                .x = bootinfo.screen.width,
+                .y = bootinfo.screen.height,
+                .scan = bootinfo.screen.scanline,
+                .visual = visual,
+            };
+            fb_init(&prop);
         }
-        fb_properties_t prop = {
-            .addr = bootinfo.screen.addr,
-            .offset = 0,
-            .x = bootinfo.screen.width,
-            .y = bootinfo.screen.height,
-            .scan = bootinfo.screen.scanline,
-            .visual = visual,
-        };
-        fb_init(&prop);
         /* Initialize IRQ routing */
         irq_init(IRQ_COUNT, IRQ_COUNT);
-        /* Initialize PIC */
-        pic_init(bootinfo.keyboard.addr, PAGE_SIZE);
-        /* Initialize I/O controller */
-        cuda_init(device_assign_devno(),
-            bootinfo.keyboard.addr + 0x16000, 2 * PAGE_SIZE);
+        if (bootinfo.macio.addr) {
+            /* Initialize PIC */
+            pic_init(bootinfo.macio.addr, PAGE_SIZE);
+            /* Initialize I/O controller */
+            cuda_init(device_assign_devno(),
+                bootinfo.macio.addr + 0x16000, 2 * PAGE_SIZE);
+        }
         /* Merge all zones to 1 big zone */
         zone_merge_all();
 ,8 → 147,7
         (uintptr_t) kernel_uarg->uspace_entry);
     /* Unreachable */
-    for (;;)
-        ;
+    while (true);
 }
 /** Acquire console back for kernel

 /branches/dynload/kernel/arch/ppc32/src/mm/tlb.c
 ,7 → 26,7
  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
-/** @addtogroup ppc32mm
+/** @addtogroup ppc32mm
  * @{
  */
 /** @file
 ,8 → 40,18
 #include <arch.h>
 #include <print.h>
 #include <symtab.h>
+#include <macros.h>
+static unsigned int seed = 10;
+static unsigned int seed_real __attribute__ ((section("K_UNMAPPED_DATA_START"))) = 42;
+#define TLB_FLUSH \
+    "tlbie %0\n" \
+    "addi %0, %0, 0x1000\n"
 /** Try to find PTE for faulting address
  *
  * Try to find PTE for faulting address.
 ,7 → 76,7
      * Check if the mapping exists in page tables.
      */
     pte_t *pte = page_mapping_find(as, badvaddr);
-    if ((pte) && (pte->p)) {
+    if ((pte) && (pte->present)) {
         /*
          * Mapping found in page tables.
          * Immediately succeed.
 ,7 → 98,7
              */
             page_table_lock(as, lock);
             pte = page_mapping_find(as, badvaddr);
-            ASSERT((pte) && (pte->p));
+            ASSERT((pte) && (pte->present));
             *pfrc = 0;
             return pte;
         case AS_PF_DEFER:
 ,22 → 121,21
     char *symbol = "";
     char *sym2 = "";
-    char *s = get_symtab_entry(istate->pc);
-    if (s)
-        symbol = s;
-    s = get_symtab_entry(istate->lr);
-    if (s)
-        sym2 = s;
+    char *str = get_symtab_entry(istate->pc);
+    if (str)
+        symbol = str;
+    str = get_symtab_entry(istate->lr);
+    if (str)
+        sym2 = str;
     fault_if_from_uspace(istate,
-        "%p: PHT Refill Exception at %p (%s<-%s).", badvaddr,
-        istate->pc, symbol, sym2);
+        "PHT Refill Exception on %p.", badvaddr);
     panic("%p: PHT Refill Exception at %p (%s<-%s).", badvaddr,
         istate->pc, symbol, sym2);
 }
-static void pht_insert(const uintptr_t vaddr, const pfn_t pfn)
+static void pht_insert(const uintptr_t vaddr, const pte_t *pte)
 {
     uint32_t page = (vaddr >> 12) & 0xffff;
     uint32_t api = (vaddr >> 22) & 0x3f;
 ,11 → 161,12
     uint32_t i;
     bool found = false;
-    /* Find unused or colliding
-       PTE in PTEG */
+    /* Find colliding PTE in PTEG */
     for (i = 0; i < 8; i++) {
-        if ((!phte[base + i].v) || ((phte[base + i].vsid == vsid) &&
-            (phte[base + i].api == api))) {
+        if ((phte[base + i].v)
+            && (phte[base + i].vsid == vsid)
+            && (phte[base + i].api == api)
+            && (phte[base + i].h == 0)) {
             found = true;
             break;
         }
 ,86 → 173,25
     }
     if (!found) {
-        /* Secondary hash (not) */
-        uint32_t base2 = (~hash & 0x3ff) << 3;
-        /* Find unused or colliding
-           PTE in PTEG */
+        /* Find unused PTE in PTEG */
         for (i = 0; i < 8; i++) {
-            if ((!phte[base2 + i].v) ||
-                ((phte[base2 + i].vsid == vsid) &&
-                (phte[base2 + i].api == api))) {
+            if (!phte[base + i].v) {
                 found = true;
-                base = base2;
-                h = 1;
                 break;
             }
         }
-        if (!found) {
-            // TODO: A/C precedence groups
-            i = page % 8;
-        }
     }
-    phte[base + i].v = 1;
-    phte[base + i].vsid = vsid;
-    phte[base + i].h = h;
-    phte[base + i].api = api;
-    phte[base + i].rpn = pfn;
-    phte[base + i].r = 0;
-    phte[base + i].c = 0;
-    phte[base + i].pp = 2; // FIXME
-}
-static void pht_real_insert(const uintptr_t vaddr, const pfn_t pfn)
-{
-    uint32_t page = (vaddr >> 12) & 0xffff;
-    uint32_t api = (vaddr >> 22) & 0x3f;
-    uint32_t vsid;
-    asm volatile (
-        "mfsrin %0, %1\n"
-        : "=r" (vsid)
-        : "r" (vaddr)
-    );
-    uint32_t sdr1;
-    asm volatile (
-        "mfsdr1 %0\n"
-        : "=r" (sdr1)
-    );
-    phte_t *phte_physical = (phte_t *) (sdr1 & 0xffff0000);
-    /* Primary hash (xor) */
-    uint32_t h = 0;
-    uint32_t hash = vsid ^ page;
-    uint32_t base = (hash & 0x3ff) << 3;
-    uint32_t i;
-    bool found = false;
-    /* Find unused or colliding
-       PTE in PTEG */
-    for (i = 0; i < 8; i++) {
-        if ((!phte_physical[base + i].v) ||
-            ((phte_physical[base + i].vsid == vsid) &&
-            (phte_physical[base + i].api == api))) {
-            found = true;
-            break;
-        }
-    }
     if (!found) {
         /* Secondary hash (not) */
         uint32_t base2 = (~hash & 0x3ff) << 3;
-        /* Find unused or colliding
-           PTE in PTEG */
+        /* Find colliding PTE in PTEG */
         for (i = 0; i < 8; i++) {
-            if ((!phte_physical[base2 + i].v) ||
-                ((phte_physical[base2 + i].vsid == vsid) &&
-                (phte_physical[base2 + i].api == api))) {
+            if ((phte[base2 + i].v)
+                && (phte[base2 + i].vsid == vsid)
+                && (phte[base2 + i].api == api)
+                && (phte[base2 + i].h == 1)) {
                 found = true;
                 base = base2;
                 h = 1;
 ,26 → 200,37
         }
         if (!found) {
-            // TODO: A/C precedence groups
-            i = page % 8;
+            /* Find unused PTE in PTEG */
+            for (i = 0; i < 8; i++) {
+                if (!phte[base2 + i].v) {
+                    found = true;
+                    base = base2;
+                    h = 1;
+                    break;
+                }
+            }
         }
+        if (!found)
+            i = RANDI(seed) % 8;
     }
-    phte_physical[base + i].v = 1;
-    phte_physical[base + i].vsid = vsid;
-    phte_physical[base + i].h = h;
-    phte_physical[base + i].api = api;
-    phte_physical[base + i].rpn = pfn;
-    phte_physical[base + i].r = 0;
-    phte_physical[base + i].c = 0;
-    phte_physical[base + i].pp = 2; // FIXME
+    phte[base + i].v = 1;
+    phte[base + i].vsid = vsid;
+    phte[base + i].h = h;
+    phte[base + i].api = api;
+    phte[base + i].rpn = pte->pfn;
+    phte[base + i].r = 0;
+    phte[base + i].c = 0;
+    phte[base + i].wimg = (pte->page_cache_disable ? WIMG_NO_CACHE : 0);
+    phte[base + i].pp = 2; // FIXME
 }
-/** Process Instruction/Data Storage Interrupt
+/** Process Instruction/Data Storage Exception
  *
- * @param n     Interrupt vector number.
- * @param istate    Interrupted register context.
+ * @param n      Exception vector number.
+ * @param istate Interrupted register context.
  *
  */
 void pht_refill(int n, istate_t *istate)
 ,12 → 249,9
         lock = true;
     }
-    if (n == VECTOR_DATA_STORAGE) {
-        asm volatile (
-            "mfdar %0\n"
-            : "=r" (badvaddr)
-        );
-    } else
+    if (n == VECTOR_DATA_STORAGE)
+        badvaddr = istate->dar;
+    else
         badvaddr = istate->pc;
     page_table_lock(as, lock);
 ,8 → 275,8
         }
     }
-    pte->a = 1; /* Record access to PTE */
-    pht_insert(badvaddr, pte->pfn);
+    pte->accessed = 1; /* Record access to PTE */
+    pht_insert(badvaddr, pte);
     page_table_unlock(as, lock);
     return;
 ,22 → 287,19
 }
-/** Process Instruction/Data Storage Interrupt in Real Mode
+/** Process Instruction/Data Storage Exception in Real Mode
  *
- * @param n     Interrupt vector number.
- * @param istate    Interrupted register context.
+ * @param n      Exception vector number.
+ * @param istate Interrupted register context.
  *
  */
-bool pht_real_refill(int n, istate_t *istate)
+bool pht_refill_real(int n, istate_t *istate)
 {
     uintptr_t badvaddr;
-    if (n == VECTOR_DATA_STORAGE) {
-        asm volatile (
-            "mfdar %0\n"
-            : "=r" (badvaddr)
-        );
-    } else
+    if (n == VECTOR_DATA_STORAGE)
+        badvaddr = istate->dar;
+    else
         badvaddr = istate->pc;
     uint32_t physmem;
 ,15 → 308,140
         : "=r" (physmem)
     );
-    if ((badvaddr >= PA2KA(0)) && (badvaddr < PA2KA(physmem))) {
-        pht_real_insert(badvaddr, KA2PA(badvaddr) >> 12);
-        return true;
+    if ((badvaddr < PA2KA(0)) || (badvaddr >= PA2KA(physmem)))
+        return false;
+    uint32_t page = (badvaddr >> 12) & 0xffff;
+    uint32_t api = (badvaddr >> 22) & 0x3f;
+    uint32_t vsid;
+    asm volatile (
+        "mfsrin %0, %1\n"
+        : "=r" (vsid)
+        : "r" (badvaddr)
+    );
+    uint32_t sdr1;
+    asm volatile (
+        "mfsdr1 %0\n"
+        : "=r" (sdr1)
+    );
+    phte_t *phte_real = (phte_t *) (sdr1 & 0xffff0000);
+    /* Primary hash (xor) */
+    uint32_t h = 0;
+    uint32_t hash = vsid ^ page;
+    uint32_t base = (hash & 0x3ff) << 3;
+    uint32_t i;
+    bool found = false;
+    /* Find colliding PTE in PTEG */
+    for (i = 0; i < 8; i++) {
+        if ((phte_real[base + i].v)
+            && (phte_real[base + i].vsid == vsid)
+            && (phte_real[base + i].api == api)
+            && (phte_real[base + i].h == 0)) {
+            found = true;
+            break;
+        }
     }
-    return false;
+    if (!found) {
+        /* Find unused PTE in PTEG */
+        for (i = 0; i < 8; i++) {
+            if (!phte_real[base + i].v) {
+                found = true;
+                break;
+            }
+        }
+    }
+    if (!found) {
+        /* Secondary hash (not) */
+        uint32_t base2 = (~hash & 0x3ff) << 3;
+        /* Find colliding PTE in PTEG */
+        for (i = 0; i < 8; i++) {
+            if ((phte_real[base2 + i].v)
+                && (phte_real[base2 + i].vsid == vsid)
+                && (phte_real[base2 + i].api == api)
+                && (phte_real[base2 + i].h == 1)) {
+                found = true;
+                base = base2;
+                h = 1;
+                break;
+            }
+        }
+        if (!found) {
+            /* Find unused PTE in PTEG */
+            for (i = 0; i < 8; i++) {
+                if (!phte_real[base2 + i].v) {
+                    found = true;
+                    base = base2;
+                    h = 1;
+                    break;
+                }
+            }
+        }
+        if (!found) {
+            /* Use secondary hash to avoid collisions
+               with usual PHT refill handler. */
+            i = RANDI(seed_real) % 8;
+            base = base2;
+            h = 1;
+        }
+    }
+    phte_real[base + i].v = 1;
+    phte_real[base + i].vsid = vsid;
+    phte_real[base + i].h = h;
+    phte_real[base + i].api = api;
+    phte_real[base + i].rpn = KA2PA(badvaddr) >> 12;
+    phte_real[base + i].r = 0;
+    phte_real[base + i].c = 0;
+    phte_real[base + i].wimg = 0;
+    phte_real[base + i].pp = 2; // FIXME
+    return true;
 }
+/** Process ITLB/DTLB Miss Exception in Real Mode
+ *
+ *
+ */
+void tlb_refill_real(int n, uint32_t tlbmiss, ptehi_t ptehi, ptelo_t ptelo, istate_t *istate)
+{
+    uint32_t badvaddr = tlbmiss & 0xfffffffc;
+    uint32_t physmem;
+    asm volatile (
+        "mfsprg3 %0\n"
+        : "=r" (physmem)
+    );
+    if ((badvaddr < PA2KA(0)) || (badvaddr >= PA2KA(physmem)))
+        return; // FIXME
+    ptelo.rpn = KA2PA(badvaddr) >> 12;
+    ptelo.wimg = 0;
+    ptelo.pp = 2; // FIXME
+    uint32_t index = 0;
+    asm volatile (
+        "mtspr 981, %0\n"
+        "mtspr 982, %1\n"
+        "tlbld %2\n"
+        "tlbli %2\n"
+        : "=r" (index)
+        : "r" (ptehi),
+          "r" (ptelo)
+    );
+}
 void tlb_arch_init(void)
 {
     tlb_invalidate_all();
 ,9 → 450,87
 void tlb_invalidate_all(void)
 {
+    uint32_t index;
     asm volatile (
-        "tlbia\n"
+        "li %0, 0\n"
+        "sync\n"
+        TLB_FLUSH
+        TLB_FLUSH
+        TLB_FLUSH
+        TLB_FLUSH
+        TLB_FLUSH
+        TLB_FLUSH
+        TLB_FLUSH
+        TLB_FLUSH
+        TLB_FLUSH
+        TLB_FLUSH
+        TLB_FLUSH
+        TLB_FLUSH
+        TLB_FLUSH
+        TLB_FLUSH
+        TLB_FLUSH
+        TLB_FLUSH
+        TLB_FLUSH
+        TLB_FLUSH
+        TLB_FLUSH
+        TLB_FLUSH
+        TLB_FLUSH
+        TLB_FLUSH
+        TLB_FLUSH
+        TLB_FLUSH
+        TLB_FLUSH
+        TLB_FLUSH
+        TLB_FLUSH
+        TLB_FLUSH
+        TLB_FLUSH
+        TLB_FLUSH
+        TLB_FLUSH
+        TLB_FLUSH
+        TLB_FLUSH
+        TLB_FLUSH
+        TLB_FLUSH
+        TLB_FLUSH
+        TLB_FLUSH
+        TLB_FLUSH
+        TLB_FLUSH
+        TLB_FLUSH
+        TLB_FLUSH
+        TLB_FLUSH
+        TLB_FLUSH
+        TLB_FLUSH
+        TLB_FLUSH
+        TLB_FLUSH
+        TLB_FLUSH
+        TLB_FLUSH
+        TLB_FLUSH
+        TLB_FLUSH
+        TLB_FLUSH
+        TLB_FLUSH
+        TLB_FLUSH
+        TLB_FLUSH
+        TLB_FLUSH
+        TLB_FLUSH
+        TLB_FLUSH
+        TLB_FLUSH
+        TLB_FLUSH
+        TLB_FLUSH
+        TLB_FLUSH
+        TLB_FLUSH
+        TLB_FLUSH
+        TLB_FLUSH
+        "eieio\n"
         "tlbsync\n"
+        "sync\n"
+        : "=r" (index)
     );
 }
 ,7 → 599,7
             : "=r" (vsid)
             : "r" (sr << 28)
         );
-        printf("vsid[%d]: VSID=%.*p (ASID=%d)%s%s\n", sr,
+        printf("sr[%02u]: vsid=%.*p (asid=%u)%s%s\n", sr,
             sizeof(vsid) * 2, vsid & 0xffffff, (vsid & 0xffffff) >> 4,
             ((vsid >> 30) & 1) ? " supervisor" : "",
             ((vsid >> 29) & 1) ? " user" : "");

 /branches/dynload/kernel/arch/ppc32/src/interrupt.c
 ,8 → 92,8
 static void exception_decrementer(int n, istate_t *istate)
 {
+    start_decrementer();
     clock();
-    start_decrementer();
 }

 /branches/dynload/kernel/arch/ppc32/src/drivers/pic.c
 ,7 → 38,7
 #include <byteorder.h>
 #include <bitops.h>
-static volatile uint32_t *pic;
+static volatile uint32_t *pic = NULL;
 void pic_init(uintptr_t base, size_t size)
 {
 ,10 → 47,11
 void pic_enable_interrupt(int intnum)
 {
-    if (intnum < 32) {
-        pic[PIC_MASK_LOW] = pic[PIC_MASK_LOW] | (1 << intnum);
-    } else {
-        pic[PIC_MASK_HIGH] = pic[PIC_MASK_HIGH] | (1 << (intnum - 32));
+    if (pic) {
+        if (intnum < 32)
+            pic[PIC_MASK_LOW] = pic[PIC_MASK_LOW] | (1 << intnum);
+        else
+            pic[PIC_MASK_HIGH] = pic[PIC_MASK_HIGH] | (1 << (intnum - 32));
     }
 }
 ,34 → 58,39
 void pic_disable_interrupt(int intnum)
 {
-    if (intnum < 32) {
-        pic[PIC_MASK_LOW] = pic[PIC_MASK_LOW] & (~(1 << intnum));
-    } else {
-        pic[PIC_MASK_HIGH] = pic[PIC_MASK_HIGH] & (~(1 << (intnum - 32)));
+    if (pic) {
+        if (intnum < 32)
+            pic[PIC_MASK_LOW] = pic[PIC_MASK_LOW] & (~(1 << intnum));
+        else
+            pic[PIC_MASK_HIGH] = pic[PIC_MASK_HIGH] & (~(1 << (intnum - 32)));
     }
 }
 void pic_ack_interrupt(int intnum)
 {
-    if (intnum < 32)
-        pic[PIC_ACK_LOW] = 1 << intnum;
-    else
-        pic[PIC_ACK_HIGH] = 1 << (intnum - 32);
+    if (pic) {
+        if (intnum < 32)
+            pic[PIC_ACK_LOW] = 1 << intnum;
+        else
+            pic[PIC_ACK_HIGH] = 1 << (intnum - 32);
+    }
 }
 /** Return number of pending interrupt */
 int pic_get_pending(void)
 {
-    int pending;
-    pending = pic[PIC_PENDING_LOW];
-    if (pending)
-        return fnzb32(pending);
+    if (pic) {
+        int pending;
+        pending = pic[PIC_PENDING_LOW];
+        if (pending)
+            return fnzb32(pending);
+        pending = pic[PIC_PENDING_HIGH];
+        if (pending)
+            return fnzb32(pending) + 32;
+    }
-    pending = pic[PIC_PENDING_HIGH];
-    if (pending)
-        return fnzb32(pending) + 32;
     return -1;
 }

 /branches/dynload/kernel/arch/ppc32/src/drivers/cuda.c
 ,14 → 236,16
 int cuda_get_scancode(void)
 {
-    uint8_t kind;
-    uint8_t data[4];
+    if (cuda) {
+        uint8_t kind;
+        uint8_t data[4];
+        receive_packet(&kind, 4, data);
+        if ((kind == PACKET_ADB) && (data[0] == 0x40) && (data[1] == 0x2c))
+            return data[2];
+    }
-    receive_packet(&kind, 4, data);
-    if ((kind == PACKET_ADB) && (data[0] == 0x40) && (data[1] == 0x2c))
-        return data[2];
     return -1;
 }
 ,11 → 273,13
 /** Initialize keyboard and service interrupts using kernel routine */
 void cuda_grab(void)
 {
-    ipl_t ipl = interrupts_disable();
-    spinlock_lock(&cuda_irq.lock);
-    cuda_irq.notif_cfg.notify = false;
-    spinlock_unlock(&cuda_irq.lock);
-    interrupts_restore(ipl);
+    if (cuda) {
+        ipl_t ipl = interrupts_disable();
+        spinlock_lock(&cuda_irq.lock);
+        cuda_irq.notif_cfg.notify = false;
+        spinlock_unlock(&cuda_irq.lock);
+        interrupts_restore(ipl);
+    }
 }
 ,18 → 286,20
 /** Resume the former interrupt vector */
 void cuda_release(void)
 {
-    ipl_t ipl = interrupts_disable();
-    spinlock_lock(&cuda_irq.lock);
-    if (cuda_irq.notif_cfg.answerbox)
-        cuda_irq.notif_cfg.notify = true;
-    spinlock_unlock(&cuda_irq.unlock);
-    interrupts_restore(ipl);
+    if (cuda) {
+        ipl_t ipl = interrupts_disable();
+        spinlock_lock(&cuda_irq.lock);
+        if (cuda_irq.notif_cfg.answerbox)
+            cuda_irq.notif_cfg.notify = true;
+        spinlock_unlock(&cuda_irq.unlock);
+        interrupts_restore(ipl);
+    }
 }
 void cuda_init(devno_t devno, uintptr_t base, size_t size)
 {
-    cuda = (uint8_t *) hw_map(base, size);
+    cuda = (uint8_t *) hw_map(base, size);
     chardev_initialize("cuda_kbd", &kbrd, &ops);
     stdin = &kbrd;
 ,7 → 312,7
     irq_register(&cuda_irq);
     pic_enable_interrupt(CUDA_IRQ);
     sysinfo_set_item_val("kbd", NULL, true);
     sysinfo_set_item_val("kbd.devno", NULL, devno);
     sysinfo_set_item_val("kbd.inr", NULL, CUDA_IRQ);
 ,7 → 351,9
 }
 void arch_reboot(void) {
-    send_packet(PACKET_CUDA, 1, CUDA_RESET);
+    if (cuda)
+        send_packet(PACKET_CUDA, 1, CUDA_RESET);
     asm volatile (
         "b 0\n"
     );

 /branches/dynload/kernel/arch/ia32xen/src/drivers/xconsole.c
 ,28 → 55,30
     stdout = &xen_console;
 }
-void xen_putchar(chardev_t *d, const char ch)
+void xen_putchar(chardev_t *d, const char ch, bool silent)
 {
-    if (start_info.console.domU.evtchn != 0) {
-        uint32_t cons = console_page.out_cons;
-        uint32_t prod = console_page.out_prod;
-        memory_barrier();
-        if ((prod - cons) > sizeof(console_page.out))
-            return;
-        if (ch == '\n')
-            console_page.out[MASK_INDEX(prod++, console_page.out)] = '\r';
-        console_page.out[MASK_INDEX(prod++, console_page.out)] = ch;
-        write_barrier();
-        console_page.out_prod = prod;
-        xen_notify_remote(start_info.console.domU.evtchn);
-    } else
-        xen_console_io(CONSOLE_IO_WRITE, 1, &ch);
+    if (!silent) {
+        if (start_info.console.domU.evtchn != 0) {
+            uint32_t cons = console_page.out_cons;
+            uint32_t prod = console_page.out_prod;
+            memory_barrier();
+            if ((prod - cons) > sizeof(console_page.out))
+                return;
+            if (ch == '\n')
+                console_page.out[MASK_INDEX(prod++, console_page.out)] = '\r';
+            console_page.out[MASK_INDEX(prod++, console_page.out)] = ch;
+            write_barrier();
+            console_page.out_prod = prod;
+            xen_notify_remote(start_info.console.domU.evtchn);
+        } else
+            xen_console_io(CONSOLE_IO_WRITE, 1, &ch);
+    }
 }
 /** @}

/branches/dynload/kernel/arch/amd64/src/boot/boot.S
1,4 → 1,4

#
# Copyright (c) 2005 Ondrej Palkovsky
# Copyright (c) 2006 Martin Decky
# Copyright (c) 2008 Jakub Jermar

/branches/dynload/kernel/arch/amd64/src/interrupt.c
150,11 → 150,13
#endif
}

#ifdef CONFIG_SMP
static void tlb_shootdown_ipi(int n, istate_t *istate)
{
trap_virtual_eoi();
tlb_shootdown_ipi_recv();
}
#endif

/** Handler of IRQ exceptions */
static void irq_interrupt(int n, istate_t *istate)

/branches/dynload/kernel/arch/ppc64/src/mm/tlb.c
49,7 → 49,6
void tlb_invalidate_all(void)
{
asm volatile (
"tlbia\n"
"tlbsync\n"
);
}

 /branches/dynload/kernel/arch/mips32/src/drivers/serial.c
 ,7 → 26,7
  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
-/** @addtogroup mips32
+/** @addtogroup mips32
  * @{
  */
 /** @file
 ,16 → 46,18
 static serial_t sconf[SERIAL_MAX];
 static bool kb_enabled;
-static void serial_write(chardev_t *d, const char ch)
+static void serial_write(chardev_t *d, const char ch, bool silent)
 {
-    serial_t *sd = (serial_t *)d->data;
-    if (ch == '\n')
-        serial_write(d, '\r');
-    /* Wait until transmit buffer empty */
-    while (! (SERIAL_READ_LSR(sd->port) & (1<<TRANSMIT_EMPTY_BIT)))
-        ;
-    SERIAL_WRITE(sd->port, ch);
+    if (!silent) {
+        serial_t *sd = (serial_t *)d->data;
+        if (ch == '\n')
+            serial_write(d, '\r', false);
+        /* Wait until transmit buffer empty */
+        while (!(SERIAL_READ_LSR(sd->port) & (1 << TRANSMIT_EMPTY_BIT)));
+        SERIAL_WRITE(sd->port, ch);
+    }
 }
 static void serial_enable(chardev_t *d)
 ,8 → 135,7
 void serial_console(devno_t devno)
 {
     serial_t *sd = &sconf[0];
     chardev_initialize("serial_console", &console, &serial_ops);
     console.data = sd;
     kb_enabled = true;
 ,10 → 146,9
     serial_irq.claim = serial_claim;
     serial_irq.handler = serial_irq_handler;
     irq_register(&serial_irq);
     /* I don't know why, but the serial interrupts simply
-     * don't work on simics
-     */
+       don't work on simics */
     virtual_timer_fnc = &serial_handler;
     stdin = &console;

 /branches/dynload/kernel/arch/mips32/src/drivers/msim.c
 ,7 → 26,7
  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
-/** @addtogroup mips32
+/** @addtogroup mips32
  * @{
  */
 /** @file
 ,7 → 45,7
 static chardev_t console;
 static irq_t msim_irq;
-static void msim_write(chardev_t *dev, const char ch);
+static void msim_write(chardev_t *dev, const char ch, bool silent);
 static void msim_enable(chardev_t *dev);
 static void msim_disable(chardev_t *dev);
 static char msim_do_read(chardev_t *dev);
 ,9 → 58,10
 };
 /** Putchar that works with MSIM & gxemul */
-void msim_write(chardev_t *dev, const char ch)
+void msim_write(chardev_t *dev, const char ch, bool silent)
 {
-    *((char *) MSIM_VIDEORAM) = ch;
+    if (!silent)
+        *((char *) MSIM_VIDEORAM) = ch;
 }
 /* Called from getc(). */
 ,7 → 81,7
 static char msim_do_read(chardev_t *dev)
 {
     char ch;
     while (1) {
         ch = *((volatile char *) MSIM_KBD_ADDRESS);
         if (ch) {
 ,12 → 102,12
     else {
         char ch = 0;
-            ch = *((char *) MSIM_KBD_ADDRESS);
-            if (ch =='\r')
-                ch = '\n';
-            if (ch == 0x7f)
-                ch = '\b';
-            chardev_push_character(&console, ch);
+        ch = *((char *) MSIM_KBD_ADDRESS);
+        if (ch =='\r')
+            ch = '\n';
+        if (ch == 0x7f)
+            ch = '\b';
+        chardev_push_character(&console, ch);
     }
 }

 /branches/dynload/tools/xtui.py
 ,6 → 167,9
         return (buttonbar.buttonPressed(retval), listbox.current())
     elif (dialog):
+        if (width < 35):
+            width = 35
         args = []
         cnt = 0
         for option in options:

 /branches/dynload/tools/config.py
 ,6 → 257,12
             create_output(OUTPUT, defaults, ask_names)
             return 0
+    # Check mode: only check defaults
+    if ((len(sys.argv) >= 3) and (sys.argv[2] == 'check')):
+        if (check_choices(defaults, ask_names)):
+            return 0
+        return 1
     screen = xtui.screen_init()
     try:
         selname = None
 ,4 → 350,4
     return 0
 if __name__ == '__main__':
-    exit(main())
+    sys.exit(main())

 /branches/dynload/uspace/app/dltest/Makefile
 ,7 → 27,7
 #
 include ../../../version
-include ../../Makefile.config
+-include ../../../Makefile.config
 ## Setup toolchain
 #

 /branches/dynload/uspace/app/bdsh/input.c
 ,21 → 42,8
 #include "errors.h"
 #include "exec.h"
-extern volatile unsigned int cli_interactive;
-/* Not exposed in input.h */
-static void cli_restricted(char *);
 static void read_line(char *, int);
-/* More than a macro than anything */
-static void cli_restricted(char *cmd)
-{
-    printf("%s is not available in %s mode\n", cmd,
-        cli_interactive ? "interactive" : "non-interactive");
-    return;
-}
 /* Tokenizes input from console, sees if the first word is a built-in, if so
  * invokes the built-in entry point (a[0]) passing all arguments in a[] to
  * the handler */
 ,14 → 57,11
     if (NULL == usr->line)
         return CL_EFAIL;
-    tmp = cli_strdup(usr->line);
+    tmp = strdup(usr->line);
-    /* Break up what the user typed, space delimited */
-    /* TODO: Protect things in quotes / ticks, expand wildcards */
-    cmd[n] = cli_strtok(tmp, " ");
+    cmd[n] = strtok(tmp, " ");
     while (cmd[n] && n < WORD_MAX) {
-        cmd[++n] = cli_strtok(NULL, " ");
+        cmd[++n] = strtok(NULL, " ");
     }
     /* We have rubbish */
 ,39 → 70,19
         goto finit;
     }
-    /* Its a builtin command */
+    /* Its a builtin command ? */
     if ((i = (is_builtin(cmd[0]))) > -1) {
-        /* Its not available in this mode, see what try_exec() thinks */
-        if (builtin_is_restricted(i)) {
-                rc = try_exec(cmd[0], cmd);
-                if (rc)
-                    /* No external matching it could be found, tell the
-                     * user that the command does exist, but is not
-                     * available in this mode. */
-                    cli_restricted(cmd[0]);
-                goto finit;
-        }
-        /* Its a builtin, its available, run it */
         rc = run_builtin(i, cmd, usr);
         goto finit;
-    /* We repeat the same dance for modules */
+    /* Its a module ? */
     } else if ((i = (is_module(cmd[0]))) > -1) {
-        if (module_is_restricted(i)) {
-            rc = try_exec(cmd[0], cmd);
-            if (rc)
-                cli_restricted(cmd[0]);
-            goto finit;
-        }
         rc = run_module(i, cmd);
         goto finit;
-    } else {
-        /* Its not a module or builtin, restricted or otherwise.
-         * See what try_exec() thinks of it and just pass its return
-         * value back to the caller */
-        rc = try_exec(cmd[0], cmd);
-        goto finit;
     }
+    /* See what try_exec thinks of it */
+    rc = try_exec(cmd[0], cmd);
 finit:
     if (NULL != usr->line) {
         free(usr->line);
 ,7 → 138,7
     /* Make sure we don't have rubbish or a C/R happy user */
     if (len == 0 || line[0] == '\n')
         return;
-    usr->line = cli_strdup(line);
+    usr->line = strdup(line);
     return;
 }

 /branches/dynload/uspace/app/bdsh/AUTHORS
 ,9 → 8,6
 * Based on the HelenOS testing sub-system written by Martin Decky
-* cli_strtok() and cli_strtok_r() (util.c) were adapted from the FreeBSD
-  strtok() and strtok_r() functions written by Wes Peters.
 * read_line() (input.c) was written by Jiri Svoboda
 Individual author copyrights are listed in the headers of each file.

 /branches/dynload/uspace/app/bdsh/cmds/mknewcmd
 ,8 → 46,6
   -e, --entry        Entry function of the command (def: cmd_${def})
   -h, --help-entry   Entry function for command help (def: help_cmd_${def})
   -a, --alias        Alias (nickname) for this command (def: none)
-  -r, --restrict     Restriction level (interactive, non-interactive, both)
-                     (def: module is both, builtin is interactive only)
   -t, --type         Type of command (module or builtin) (def: module)
   -H, --help         This help summary
   -V, --version      Print $PROGNAME version and exit normally
 ,8 → 65,7
     $PROGNAME -n foo -d "Foo power" -a bar -r both -t module modules/foo
   The example would generate a modular command named 'foo', which is also
-  reached by typing 'bar' and available in either interactive or noninteractive
-  mode.
+  reached by typing 'bar'.
   Skeletal files do *not* depend on the autoconf generated "config.h" unless you
   include it. This may or may not be desirable depending on your use.
 ,7 → 94,6
     "${CMDDESC}",
     &${CMDENTRY},
     &${HELPENTRY},
-    ${CMDRESTRICT}
 },
 EOF
 ,7 → 103,6
     NULL,
     &${CMDENTRY},
     &${HELPENTRY},
-    ${CMDRESTRICT}
 },
 EOF
 ,7 → 162,7
 #include "${CMDNAME}.h"
 #include "cmds.h"
-static char *cmdname = "${CMDNAME}";
+static const char *cmdname = "${CMDNAME}";
 /* Dispays help for ${CMDNAME} in various levels */
 void ${HELPENTRY}(unsigned int level)
 ,8 → 229,8
 # We need at least one
 [ $# = 0 ] && usage && exit 1;
-TEMP=$(getopt -o n:d:e:h:a:r:t:HV \
---long name:,desc:,entry:,help-entry:,alias:,restrict:,type:,help,version \
+TEMP=$(getopt -o n:d:e:h:a:t:HV \
+--long name:,desc:,entry:,help-entry:,alias:,type:,help,version \
 -- "$@") || {
     echo "Try $PROGNAME --help for help"
 }
 ,11 → 264,6
         shift 2
         continue
     ;;
-    -r | --restrict)
-        CMDRESTRICT="$2"
-        shift 2
-        continue
-    ;;
     -t | --type)
         CMDTYPE="$2"
         shift 2
 ,30 → 295,7
 [ -n "$CMDTYPE" ] || CMDTYPE="module"
 [ -n "$OUTDIR" ] || OUTDIR="${CMDTYPE}s/${CMDNAME}"
-# Builtins typically only need to be available in interactive mode,
-# set the default accordingly.
-[ -n "$CMDRESTRICT" ] || {
-    [ "$CMDTYPE" = "module" ] && CMDRESTRICT="both"
-    [ "$CMDTYPE" = "builtin" ] && CMDRESTRICT="interactive"
-}
-# Set the restriction level as the structure expects to see it
-case "$CMDRESTRICT" in
-| both)
-        CMDRESTRICT="0"
-    ;;
-| non-interactive)
-        CMDRESTRICT="1"
-    ;;
-    -1 | interactive)
-        CMDRESTRICT="-1"
-    ;;
-    *)
-        usage
-        exit 1
-    ;;
-esac
 # Do a little sanity
 [ -d $OUTDIR ] && {
     echo "$OUTDIR already exists, remove it to proceed."

 /branches/dynload/uspace/app/bdsh/cmds/mod_cmds.c
 ,26 → 53,6
 extern volatile unsigned int cli_interactive;
-int module_is_restricted(int pos)
-{
-    /* Restriction Levels:
-     * -1 -> Available only in interactive mode
-     *  0 -> Available in any mode
-     *  1 -> Available only in non-interactive mode */
-    module_t *mod = modules;
-    mod += pos;
-    /* We're interactive, and the module is OK to run */
-    if (cli_interactive && mod->restricted <= 0)
-        return 0;
-    /* We're not interactive, and the module is OK to run */
-    if (!cli_interactive && mod->restricted >= 0)
-        return 0;
-    /* Anything else is just a big fat no :) */
-    return 1;
-}
 /* Checks if an entry function matching command exists in modules[], if so
  * its position in the array is returned */
 int is_module(const char *command)

 /branches/dynload/uspace/app/bdsh/cmds/modules/cp/cp.c
 ,7 → 34,6
 #include <getopt.h>
 #include <string.h>
 #include <fcntl.h>
-#include <assert.h>
 #include "config.h"
 #include "util.h"
 #include "errors.h"
 ,7 → 69,8
     return (int) t1;
 }
-static int64_t copy_file(const char *src, const char *dest, size_t blen, int vb)
+static int64_t copy_file(const char *src, const char *dest,
+    size_t blen, int vb)
 {
     int fd1, fd2, bytes = 0;
     off_t total = 0;
 ,12 → 124,19
                 goto err;
             res -= bytes;
         } while (res > 0);
-        assert(res == 0);
+        /* TODO: re-insert assert() once this is stand alone,
+         * removed as abort() exits the entire shell
+         */
+        if (res != 0) {
+            printf("\n%d more bytes than actually exist were copied\n", res);
+            goto err;
+        }
     }
     if (bytes < 0) {
 err:
-        printf("Error copying %s, (%d)\n", src, bytes);
+        printf("\nError copying %s, (%d)\n", src, bytes);
         copied = bytes;
     }

/branches/dynload/uspace/app/bdsh/cmds/modules/cp/cp_def.h
3,6 → 3,5
"Copy files and directories",
&cmd_cp,
&help_cmd_cp,
0
},

 /branches/dynload/uspace/app/bdsh/cmds/modules/touch/touch.c
 ,6 → 37,7
 #include <fcntl.h>
 #include <dirent.h>
 #include <sys/types.h>
+#include <string.h>
 #include "config.h"
 #include "errors.h"
 ,7 → 80,7
     }
     for (i = 1; i < argc; i ++) {
-        buff = cli_strdup(argv[i]);
+        buff = strdup(argv[i]);
         dirp = opendir(buff);
         if (dirp) {
             cli_error(CL_ENOTSUP, "%s is a directory", buff);

/branches/dynload/uspace/app/bdsh/cmds/modules/touch/touch_def.h
3,6 → 3,5
"Create files or update access times",
&cmd_touch,
&help_cmd_touch,
0
},

 /branches/dynload/uspace/app/bdsh/cmds/modules/mkdir/mkdir.c
 ,7 → 93,7
     /* Its a good idea to allocate path, plus we (may) need a copy of
      * path to tokenize if parents are specified */
-    if (NULL == (tmp = cli_strdup(path))) {
+    if (NULL == (tmp = strdup(path))) {
         cli_error(CL_ENOMEM, "%s: path too big?", cmdname);
         return 1;
     }
 ,9 → 128,9
         absolute = 1;
     /* TODO: Canonify the path prior to tokenizing it, see below */
-    dirs[i] = cli_strtok(tmp, "/");
+    dirs[i] = strtok(tmp, "/");
     while (dirs[i] && i < 255)
-        dirs[++i] = cli_strtok(NULL, "/");
+        dirs[++i] = strtok(NULL, "/");
     if (NULL == dirs[0])
         return 1;

 /branches/dynload/uspace/app/bdsh/cmds/modules/mkdir/mkdir_def.h
 ,14 → 3,6
     "Create new directories",
     &cmd_mkdir,
     &help_cmd_mkdir,
 },
-{
-    "md",
-    NULL,
-    &cmd_mkdir,
-    &help_cmd_mkdir,
-},

/branches/dynload/uspace/app/bdsh/cmds/modules/cat/cat_def.h
3,6 → 3,5
"Show the contents of a file",
&cmd_cat,
&help_cmd_cat,
0
},

/branches/dynload/uspace/app/bdsh/cmds/modules/help/help.c
133,13 → 133,11

/* First, show a list of built in commands that are available in this mode */
for (cmd = builtins; cmd->name != NULL; cmd++, i++) {
if (!builtin_is_restricted(i)) {
if (is_builtin_alias(cmd->name))
printf(" %-16s\tAlias for `%s'\n", cmd->name,
alias_for_builtin(cmd->name));
else
printf(" %-16s\t%s\n", cmd->name, cmd->desc);
}
}

i = 0;
146,13 → 144,11

/* Now, show a list of module commands that are available in this mode */
for (mod = modules; mod->name != NULL; mod++, i++) {
if (!module_is_restricted(i)) {
if (is_module_alias(mod->name))
printf(" %-16s\tAlias for `%s'\n", mod->name,
alias_for_module(mod->name));
else
printf(" %-16s\t%s\n", mod->name, mod->desc);
}
}

printf("\n Try %s %s for more information on how `%s' works.\n\n",

/branches/dynload/uspace/app/bdsh/cmds/modules/help/help_def.h
3,5 → 3,4
"Show help for commands",
&cmd_help,
&help_cmd_help,
0
},

/branches/dynload/uspace/app/bdsh/cmds/modules/sleep/sleep_def.h
3,6 → 3,5
"Pause for given time interval (in seconds)",
&cmd_sleep,
&help_cmd_sleep,
0
},

/branches/dynload/uspace/app/bdsh/cmds/modules/pwd/pwd_def.h
3,5 → 3,4
"Prints the current working directory",
&cmd_pwd,
&help_cmd_pwd,
-1
},

 /branches/dynload/uspace/app/bdsh/cmds/modules/module_aliases.h
 ,10 → 12,6
  * the entry point being reached. */
 char *mod_aliases[] = {
-    "exit", "quit",
-    "md", "mkdir",
-    "del", "rm",
-    "dir", "ls",
     NULL, NULL
 };

 /branches/dynload/uspace/app/bdsh/cmds/modules/ls/ls.c
 ,6 → 50,24
 static char *cmdname = "ls";
+static inline off_t flen(const char *f)
+{
+    int fd;
+    off_t size;
+    fd = open(f, O_RDONLY);
+    if (fd == -1)
+        return 0;
+    size = lseek(fd, 0, SEEK_END);
+    close(fd);
+    if (size < 0)
+        size = 0;
+    return size;
+}
 static unsigned int ls_scope(const char *path)
 {
     int fd;
 ,7 → 138,7
 static void ls_print_dir(const char *d)
 {
-    printf("%-40s\t<DIR>\n", d);
+    printf("%-40s\t<dir>\n", d);
     return;
 }
 ,7 → 145,7
 static void ls_print_file(const char *f)
 {
-    printf("%-40s\n", f);
+    printf("%-40s\t%llu\n", f, (long long) flen(f));
     return;
 }

 /branches/dynload/uspace/app/bdsh/cmds/modules/ls/ls_def.h
 ,14 → 3,4
     "List files and directories",
     &cmd_ls,
     &help_cmd_ls,
 },
-{
-    "dir",
-    NULL,
-    &cmd_ls,
-    &help_cmd_ls,
-},

/branches/dynload/uspace/app/bdsh/cmds/modules/modules.h
18,7 → 18,6
/* Prototypes for each module's entry (help/exec) points */

#include "help/entry.h"
#include "quit/entry.h"
#include "mkdir/entry.h"
#include "rm/entry.h"
#include "cat/entry.h"
34,7 → 33,6

module_t modules[] = {
#include "help/help_def.h"
#include "quit/quit_def.h"
#include "mkdir/mkdir_def.h"
#include "rm/rm_def.h"
#include "cat/cat_def.h"

 /branches/dynload/uspace/app/bdsh/cmds/modules/rm/rm.c
 ,7 → 33,6
 #include <unistd.h>
 #include <fcntl.h>
 #include <dirent.h>
-#include <assert.h>
 #include <getopt.h>
 #include "config.h"
 ,7 → 218,11
     while (NULL != argv[i]) {
         len = strlen(argv[i]) + 2;
         buff = (char *) realloc(buff, len);
-        assert(buff != NULL);
+        if (buff == NULL) {
+            printf("rm: out of memory\n");
+            ret = 1;
+            break;
+        }
         memset(buff, 0, sizeof(buff));
         snprintf(buff, len, argv[i]);

 /branches/dynload/uspace/app/bdsh/cmds/modules/rm/rm_def.h
 ,14 → 3,5
     "Remove files and directories",
     &cmd_rm,
     &help_cmd_rm,
 },
-{
-    "del",
-    NULL,
-    &cmd_rm,
-    &help_cmd_rm,
-},

/branches/dynload/uspace/app/bdsh/cmds/builtins/builtins.h
4,9 → 4,11
#include "config.h"

#include "cd/entry.h"
#include "exit/entry.h"

builtin_t builtins[] = {
#include "cd/cd_def.h"
#include "exit/exit_def.h"
{NULL, NULL, NULL, NULL}
};

 /branches/dynload/uspace/app/bdsh/cmds/builtins/cd/cd_def.h
 ,12 → 3,4
     "Change the current working directory",
     &cmd_cd,
     &help_cmd_cd,
-    -1
 },
-{
-    "chdir",
-    NULL,
-    &cmd_cd,
-    &help_cmd_cd,
-    -1
-},

/branches/dynload/uspace/app/bdsh/cmds/builtins/exit/exit.h
0,0 → 1,6
#ifndef EXIT_H
#define EXIT_H

/* Prototypes for the quit command (excluding entry points) */

#endif

 /branches/dynload/uspace/app/bdsh/cmds/builtins/exit/entry.h
 ,0 → 1,12
+#ifndef EXIT_ENTRY_H_
+#define EXIT_ENTRY_H_
+#include "scli.h"
+/* Entry points for the quit command */
+extern void help_cmd_exit(unsigned int);
+extern int cmd_exit(char *[], cliuser_t *);
+#endif

 /branches/dynload/uspace/app/bdsh/cmds/builtins/exit/exit.c
 ,0 → 1,55
+/* Copyright (c) 2008, Tim Post <tinkertim@gmail.com>
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * Redistributions of source code must retain the above copyright notice, this
+ * list of conditions and the following disclaimer.
+ *
+ * Redistributions in binary form must reproduce the above copyright notice,
+ * this list of conditions and the following disclaimer in the documentation
+ * and/or other materials provided with the distribution.
+ *
+ * Neither the name of the original program's authors nor the names of its
+ * contributors may be used to endorse or promote products derived from this
+ * software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ */
+#include <stdio.h>
+#include <stdlib.h>
+#include "entry.h"
+#include "exit.h"
+#include "cmds.h"
+static const char *cmdname = "exit";
+extern volatile unsigned int cli_quit;
+extern const char *progname;
+void help_cmd_exit(unsigned int level)
+{
+    printf("Type `%s' to exit %s\n", cmdname, progname);
+    return;
+}
+/* Quits the program and returns the status of whatever command
+ * came before invoking 'quit' */
+int cmd_exit(char *argv[], cliuser_t *usr)
+{
+    /* Inform that we're outta here */
+    cli_quit = 1;
+    return CMD_SUCCESS;
+}

/branches/dynload/uspace/app/bdsh/cmds/builtins/exit/exit_def.h
0,0 → 1,6
{
"exit",
"Exit the shell",
&cmd_exit,
&help_cmd_exit,
},

/branches/dynload/uspace/app/bdsh/cmds/builtins/builtin_aliases.h
4,7 → 4,6
/* See modules/module_aliases.h for an explanation of this file */

char *builtin_aliases[] = {
"chdir", "cd",
NULL, NULL
};

/branches/dynload/uspace/app/bdsh/cmds/cmds.h
36,7 → 36,6
char desc; / Description of the command */
mod_entry_t entry; /* Command (exec) entry function */
mod_help_t help; /* Command (help) entry function */
int restricted; /* Restricts to interactive/non-interactive only */
} module_t;

/* Builtin structure, same as modules except different types of entry points */

 /branches/dynload/uspace/app/bdsh/cmds/builtin_cmds.c
 ,19 → 40,6
 extern volatile unsigned int cli_interactive;
-int builtin_is_restricted(int pos)
-{
-    builtin_t *cmd = builtins;
-    cmd += pos;
-    if (cli_interactive && cmd->restricted <= 0)
-        return 0;
-    if (!cli_interactive && cmd->restricted >= 0)
-        return 0;
-    return 1;
-}
 int is_builtin(const char *command)
 {
     builtin_t *cmd;

 /branches/dynload/uspace/app/bdsh/util.c
 ,7 → 1,4
-/* Copyright (c) 2008, Tim Post <tinkertim@gmail.com>
- * Copyright (C) 1998 by Wes Peters <wes@softweyr.com>
- * Copyright (c) 1988, 1993 The Regents of the University of California.
- * All rights reserved by all copyright holders.
+/* Copyright (c) 2008, Tim Post <tinkertim@gmail.com> - All rights reserved
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are met:
 ,18 → 27,6
  * POSSIBILITY OF SUCH DAMAGE.
  */
-/* NOTES:
- * 1 - Various functions were adapted from FreeBSD (copyright holders noted above)
- *     these functions are identified with comments.
- *
- * 2 - Some of these have since appeared in libc. They remain here for various
- *     reasons, such as the eventual integration of garbage collection for things
- *     that allocate memory and don't automatically free it.
- *
- * 3 - Things that expect a pointer to an allocated string do _no_ sanity checking
- *     if developing on a simulator with no debugger, take care :)
- */
 #include <stdio.h>
 #include <string.h>
 #include <stdarg.h>
 ,71 → 39,6
 extern volatile int cli_errno;
-/* some platforms do not have strdup, implement it here.
- * Returns a pointer to an allocated string or NULL on failure */
-char * cli_strdup(const char *s1)
-{
-    size_t len = strlen(s1) + 1;
-    void *ret = malloc(len);
-    if (ret == NULL) {
-        cli_errno = CL_ENOMEM;
-        return (char *) NULL;
-    }
-    cli_errno = CL_EOK;
-    return (char *) memcpy(ret, s1, len);
-}
-/* Ported from FBSD strtok.c 8.1 (Berkeley) 6/4/93 */
-char * cli_strtok_r(char *s, const char *delim, char **last)
-{
-    char *spanp, *tok;
-    int c, sc;
-    if (s == NULL && (s = *last) == NULL) {
-        cli_errno = CL_EFAIL;
-        return (NULL);
-    }
-cont:
-    c = *s++;
-    for (spanp = (char *)delim; (sc = *spanp++) != 0;) {
-        if (c == sc)
-            goto cont;
-    }
-    if (c == 0) {       /* no non-delimiter characters */
-        *last = NULL;
-        return (NULL);
-    }
-    tok = s - 1;
-    for (;;) {
-        c = *s++;
-        spanp = (char *)delim;
-        do {
-            if ((sc = *spanp++) == c) {
-                if (c == 0)
-                    s = NULL;
-                else
-                    s[-1] = '\0';
-                *last = s;
-                return (tok);
-            }
-        } while (sc != 0);
-    }
-}
-/* Ported from FBSD strtok.c 8.1 (Berkeley) 6/4/93 */
-char * cli_strtok(char *s, const char *delim)
-{
-    static char *last;
-    return (cli_strtok_r(s, delim, &last));
-}
 /* Count and return the # of elements in an array */
 unsigned int cli_count_args(char **args)
 {

 /branches/dynload/uspace/app/bdsh/util.h
 ,11 → 3,6
 #include "scli.h"
-/* Internal string handlers */
-extern char * cli_strdup(const char *);
-extern char * cli_strtok_r(char *, const char *, char **);
-extern char * cli_strtok(char *, const char *);
 /* Utility functions */
 extern unsigned int cli_count_args(char **);
 extern unsigned int cli_set_prompt(cliuser_t *usr);

 /branches/dynload/uspace/app/bdsh/exec.c
 ,10 → 80,10
         return (char *) cmd;
     }
-    path_tok = cli_strdup(PATH);
+    path_tok = strdup(PATH);
     /* Extract the PATH env to a path[] array */
-    path[n] = cli_strtok(path_tok, PATH_DELIM);
+    path[n] = strtok(path_tok, PATH_DELIM);
     while (NULL != path[n]) {
         if ((strlen(path[n]) + x ) > PATH_MAX) {
             cli_error(CL_ENOTSUP,
 ,7 → 91,7
                 n, n-1);
             break;
         }
-        path[++n] = cli_strtok(NULL, PATH_DELIM);
+        path[++n] = strtok(NULL, PATH_DELIM);
     }
     /* We now have n places to look for the command */
 ,7 → 114,7
     task_id_t tid;
     char *tmp;
-    tmp = cli_strdup(find_command(cmd));
+    tmp = strdup(find_command(cmd));
     free(found);
     tid = task_spawn((const char *)tmp, argv);

/branches/dynload/uspace/app/bdsh/scli.c
45,7 → 45,6
/* Globals that are modified during start-up that modules/builtins
* should be aware of. */
volatile unsigned int cli_quit = 0;
volatile unsigned int cli_interactive = 1;
volatile unsigned int cli_verbocity = 1;

/* The official name of this program

/branches/dynload/uspace/app/bdsh/Makefile
58,7 → 58,6
cmds/ \
cmds/modules/ \
cmds/modules/help/ \
cmds/modules/quit/ \
cmds/modules/mkdir/ \
cmds/modules/rm/ \
cmds/modules/cat/ \
68,11 → 67,11
cmds/modules/sleep/ \
cmds/modules/cp/ \
cmds/builtins/ \
cmds/builtins/exit/\
cmds/builtins/cd/

SOURCES = \
cmds/modules/help/help.c \
cmds/modules/quit/quit.c \
cmds/modules/mkdir/mkdir.c \
cmds/modules/rm/rm.c \
cmds/modules/cat/cat.c \
81,6 → 80,7
cmds/modules/pwd/pwd.c \
cmds/modules/sleep/sleep.c \
cmds/modules/cp/cp.c \
cmds/builtins/exit/exit.c \
cmds/builtins/cd/cd.c \
cmds/mod_cmds.c \
cmds/builtin_cmds.c \

 /branches/dynload/uspace/app/dltest2/Makefile
 ,7 → 27,7
 #
 include ../../../version
-include ../../Makefile.config
+-include ../../../Makefile.config
 ## Setup toolchain
 #

 /branches/dynload/uspace/app/dload/Makefile
 ,7 → 27,7
 #
 include ../../../version
-include ../../Makefile.config
+-include ../../../Makefile.config
 ## Setup toolchain
 #

 /branches/dynload/uspace/app/trace/trace.c
 ,6 → 642,18
     proto_add_oper(p, VFS_MOUNT, o);
 /*  o = oper_new("unmount", 0, arg_def);
     proto_add_oper(p, VFS_UNMOUNT, o);*/
+    o = oper_new("open", 2, arg_def, V_INT_ERRNO, 0, resp_def);
+    proto_add_oper(p, VFS_OPEN, o);
+    o = oper_new("close", 1, arg_def, V_ERRNO, 0, resp_def);
+    proto_add_oper(p, VFS_CLOSE, o);
+    o = oper_new("seek", 3, arg_def, V_ERRNO, 0, resp_def);
+    proto_add_oper(p, VFS_SEEK, o);
+    o = oper_new("mkdir", 1, arg_def, V_ERRNO, 0, resp_def);
+    proto_add_oper(p, VFS_MKDIR, o);
+    o = oper_new("unlink", 0, arg_def, V_ERRNO, 0, resp_def);
+    proto_add_oper(p, VFS_UNLINK, o);
+    o = oper_new("rename", 0, arg_def, V_ERRNO, 0, resp_def);
+    proto_add_oper(p, VFS_RENAME, o);
     proto_register(SERVICE_VFS, p);
 ,13 → 679,13
     proto_add_oper(p, CONSOLE_FLUSH, o);
     arg_def[0] = V_INTEGER;
-    o = oper_new("set_style", 1, arg_def, V_INTEGER, 0, resp_def);
+    o = oper_new("set_style", 1, arg_def, V_VOID, 0, resp_def);
     proto_add_oper(p, CONSOLE_SET_STYLE, o);
     arg_def[0] = V_INTEGER; arg_def[1] = V_INTEGER; arg_def[2] = V_INTEGER;
-    o = oper_new("set_color", 3, arg_def, V_INTEGER, 0, resp_def);
+    o = oper_new("set_color", 3, arg_def, V_VOID, 0, resp_def);
     proto_add_oper(p, CONSOLE_SET_COLOR, o);
     arg_def[0] = V_INTEGER; arg_def[1] = V_INTEGER;
-    o = oper_new("set_rgb_color", 2, arg_def, V_INTEGER, 0, resp_def);
+    o = oper_new("set_rgb_color", 2, arg_def, V_VOID, 0, resp_def);
     proto_add_oper(p, CONSOLE_SET_RGB_COLOR, o);
     o = oper_new("cursor_visibility", 1, arg_def, V_VOID, 0, resp_def);
     proto_add_oper(p, CONSOLE_CURSOR_VISIBILITY, o);

/branches/dynload/uspace/app/trace/syscalls.c
59,6 → 59,7
[SYS_IPC_ANSWER_FAST] = { "ipc_answer_fast", 6, V_ERRNO },
[SYS_IPC_ANSWER_SLOW] = { "ipc_answer_slow", 2, V_ERRNO },
[SYS_IPC_FORWARD_FAST] = { "ipc_forward_fast", 6, V_ERRNO },
[SYS_IPC_FORWARD_SLOW] = { "ipc_forward_slow", 3, V_ERRNO },
[SYS_IPC_WAIT] = { "ipc_wait_for_call", 3, V_HASH },
[SYS_IPC_HANGUP] = { "ipc_hangup", 1, V_ERRNO },
[SYS_IPC_REGISTER_IRQ] = { "ipc_register_irq", 4, V_ERRNO },

 /branches/dynload/uspace/lib/rtld/Makefile
 ,7 → 27,7
 #
 include ../../../version
-include ../../Makefile.config
+-include ../../../Makefile.config
 ## Setup toolchain
 #

 /branches/dynload/uspace/lib/libtest/Makefile
 ,7 → 27,7
 #
 include ../../../version
-include ../../Makefile.config
+-include ../../../Makefile.config
 ## Setup toolchain
 #

 /branches/dynload/uspace/lib/libc/include/ipc/ipc.h
 ,8 → 47,7
 } ipc_call_t;
 typedef sysarg_t ipc_callid_t;
-typedef void (* ipc_async_callback_t)(void *private, int retval,
-    ipc_call_t *data);
+typedef void (* ipc_async_callback_t)(void *, int, ipc_call_t *);
 /*
  * User-friendly wrappers for ipc_call_sync_fast() and ipc_call_sync_slow().
 ,22 → 172,20
     ipc_call_sync_slow((phoneid), (method), (arg1), (arg2), (arg3), \
         (arg4), (arg5), (res1), (res2), (res3), (res4), (res5))
-extern int ipc_call_sync_fast(int phoneid, ipcarg_t method, ipcarg_t arg1,
-    ipcarg_t arg2, ipcarg_t arg3, ipcarg_t *result1, ipcarg_t *result2,
-    ipcarg_t *result3, ipcarg_t *result4, ipcarg_t *result5);
+extern int ipc_call_sync_fast(int, ipcarg_t, ipcarg_t, ipcarg_t, ipcarg_t,
+    ipcarg_t *, ipcarg_t *, ipcarg_t *, ipcarg_t *, ipcarg_t *);
-extern int ipc_call_sync_slow(int phoneid, ipcarg_t method, ipcarg_t arg1,
-    ipcarg_t arg2, ipcarg_t arg3, ipcarg_t arg4, ipcarg_t arg5,
-    ipcarg_t *result1, ipcarg_t *result2, ipcarg_t *result3, ipcarg_t *result4,
-    ipcarg_t *result5);
+extern int ipc_call_sync_slow(int, ipcarg_t, ipcarg_t, ipcarg_t, ipcarg_t,
+    ipcarg_t, ipcarg_t, ipcarg_t *, ipcarg_t *, ipcarg_t *, ipcarg_t *,
+    ipcarg_t *);
-extern ipc_callid_t ipc_wait_cycle(ipc_call_t *call, uint32_t usec, int flags);
-extern ipc_callid_t ipc_wait_for_call_timeout(ipc_call_t *data, uint32_t usec);
+extern ipc_callid_t ipc_wait_cycle(ipc_call_t *, uint32_t, int);
+extern ipc_callid_t ipc_wait_for_call_timeout(ipc_call_t *, uint32_t);
 static inline ipc_callid_t ipc_wait_for_call(ipc_call_t *data)
 {
     return ipc_wait_for_call_timeout(data, SYNCH_NO_TIMEOUT);
 }
-extern ipc_callid_t ipc_trywait_for_call(ipc_call_t *data);
+extern ipc_callid_t ipc_trywait_for_call(ipc_call_t *);
 /*
  * User-friendly wrappers for ipc_answer_fast() and ipc_answer_slow().
 ,10 → 206,10
 #define ipc_answer_5(callid, retval, arg1, arg2, arg3, arg4, arg5) \
     ipc_answer_slow((callid), (retval), (arg1), (arg2), (arg3), (arg4), (arg5))
-extern ipcarg_t ipc_answer_fast(ipc_callid_t callid, ipcarg_t retval,
-    ipcarg_t arg1, ipcarg_t arg2, ipcarg_t arg3, ipcarg_t arg4);
-extern ipcarg_t ipc_answer_slow(ipc_callid_t callid, ipcarg_t retval,
-    ipcarg_t arg1, ipcarg_t arg2, ipcarg_t arg3, ipcarg_t arg4, ipcarg_t arg5);
+extern ipcarg_t ipc_answer_fast(ipc_callid_t, ipcarg_t, ipcarg_t, ipcarg_t,
+    ipcarg_t, ipcarg_t);
+extern ipcarg_t ipc_answer_slow(ipc_callid_t, ipcarg_t, ipcarg_t, ipcarg_t,
+    ipcarg_t, ipcarg_t, ipcarg_t);
 /*
  * User-friendly wrappers for ipc_call_async_fast() and ipc_call_async_slow().
 ,8 → 217,7
  * arguments. The macros decide between the fast and the slow version according
  * to m.
  */
-#define ipc_call_async_0(phoneid, method, private, callback, \
-    can_preempt) \
+#define ipc_call_async_0(phoneid, method, private, callback, can_preempt) \
     ipc_call_async_fast((phoneid), (method), 0, 0, 0, 0, (private), \
         (callback), (can_preempt))
 #define ipc_call_async_1(phoneid, method, arg1, private, callback, \
 ,21 → 241,19
     ipc_call_async_slow((phoneid), (method), (arg1), (arg2), (arg3), \
         (arg4), (arg5), (private), (callback), (can_preempt))
-extern void ipc_call_async_fast(int phoneid, ipcarg_t method, ipcarg_t arg1,
-    ipcarg_t arg2, ipcarg_t arg3, ipcarg_t arg4, void *private,
-    ipc_async_callback_t callback, int can_preempt);
-extern void ipc_call_async_slow(int phoneid, ipcarg_t method, ipcarg_t arg1,
-    ipcarg_t arg2, ipcarg_t arg3, ipcarg_t arg4, ipcarg_t arg5, void *private,
-    ipc_async_callback_t callback, int can_preempt);
+extern void ipc_call_async_fast(int, ipcarg_t, ipcarg_t, ipcarg_t, ipcarg_t,
+    ipcarg_t, void *, ipc_async_callback_t, int);
+extern void ipc_call_async_slow(int, ipcarg_t, ipcarg_t, ipcarg_t, ipcarg_t,
+    ipcarg_t, ipcarg_t, void *, ipc_async_callback_t, int);
-extern int ipc_connect_to_me(int phoneid, int arg1, int arg2, int arg3,
-    ipcarg_t *phone);
-extern int ipc_connect_me_to(int phoneid, int arg1, int arg2, int arg3);
-extern int ipc_hangup(int phoneid);
-extern int ipc_register_irq(int inr, int devno, int method, irq_code_t *code);
-extern int ipc_unregister_irq(int inr, int devno);
-extern int ipc_forward_fast(ipc_callid_t callid, int phoneid, int method,
-    ipcarg_t arg1, ipcarg_t arg2, int mode);
+extern int ipc_connect_to_me(int, int, int, int, ipcarg_t *);
+extern int ipc_connect_me_to(int, int, int, int);
+extern int ipc_hangup(int);
+extern int ipc_register_irq(int, int, int, irq_code_t *);
+extern int ipc_unregister_irq(int, int);
+extern int ipc_forward_fast(ipc_callid_t, int, int, ipcarg_t, ipcarg_t, int);
+extern int ipc_forward_slow(ipc_callid_t, int, int, ipcarg_t, ipcarg_t,
+    ipcarg_t, ipcarg_t, ipcarg_t, int);
 /*
 ,24 → 268,22
 #define ipc_share_in_start_1_1(phoneid, dst, size, arg, flags) \
     ipc_share_in_start((phoneid), (dst), (size), (arg), (flags))
-extern int ipc_share_in_start(int phoneid, void *dst, size_t size, ipcarg_t arg,
-    int *flags);
-extern int ipc_share_in_receive(ipc_callid_t *callid, size_t *size);
-extern int ipc_share_in_finalize(ipc_callid_t callid, void *src, int flags);
-extern int ipc_share_out_start(int phoneid, void *src, int flags);
-extern int ipc_share_out_receive(ipc_callid_t *callid, size_t *size, int *flags);
-extern int ipc_share_out_finalize(ipc_callid_t callid, void *dst);
-extern int ipc_data_read_start(int phoneid, void *dst, size_t size);
-extern int ipc_data_read_receive(ipc_callid_t *callid, size_t *size);
-extern int ipc_data_read_finalize(ipc_callid_t callid, const void *src,
-    size_t size);
-extern int ipc_data_write_start(int phoneid, const void *src, size_t size);
-extern int ipc_data_write_receive(ipc_callid_t *callid, size_t *size);
-extern int ipc_data_write_finalize(ipc_callid_t callid, void *dst, size_t size);
+extern int ipc_share_in_start(int, void *, size_t, ipcarg_t, int *);
+extern int ipc_share_in_receive(ipc_callid_t *, size_t *);
+extern int ipc_share_in_finalize(ipc_callid_t, void *, int );
+extern int ipc_share_out_start(int, void *, int);
+extern int ipc_share_out_receive(ipc_callid_t *, size_t *, int *);
+extern int ipc_share_out_finalize(ipc_callid_t, void *);
+extern int ipc_data_read_start(int, void *, size_t);
+extern int ipc_data_read_receive(ipc_callid_t *, size_t *);
+extern int ipc_data_read_finalize(ipc_callid_t, const void *, size_t);
+extern int ipc_data_write_start(int, const void *, size_t);
+extern int ipc_data_write_receive(ipc_callid_t *, size_t *);
+extern int ipc_data_write_finalize(ipc_callid_t, void *, size_t);
 #include <task.h>
-extern int ipc_connect_kbox(task_id_t id);
+extern int ipc_connect_kbox(task_id_t);
 #endif

 /branches/dynload/uspace/lib/libc/shared/Makefile
 ,7 → 27,7
 #
 include ../../../../version
-include ../../../Makefile.config
+-include ../../../../Makefile.config
 ## Setup toolchain
 #

 /branches/dynload/uspace/lib/libc/generic/libc.c
 ,8 → 75,6
     f = fibril_setup();
     __tcb_set(f->tcb);
-    open_console();
     /* Save the PCB pointer */
     __pcb = (pcb_t *)pcb_ptr;

 /branches/dynload/uspace/lib/libc/generic/ipc.c
 ,6 → 666,23
         arg2, mode);
 }
+int ipc_forward_slow(ipc_callid_t callid, int phoneid, int method,
+    ipcarg_t arg1, ipcarg_t arg2, ipcarg_t arg3, ipcarg_t arg4, ipcarg_t arg5,
+    int mode)
+{
+    ipc_call_t data;
+    IPC_SET_METHOD(data, method);
+    IPC_SET_ARG1(data, arg1);
+    IPC_SET_ARG2(data, arg2);
+    IPC_SET_ARG3(data, arg3);
+    IPC_SET_ARG4(data, arg4);
+    IPC_SET_ARG5(data, arg5);
+    return __SYSCALL3(SYS_IPC_FORWARD_SLOW, callid, (sysarg_t) &data, mode);
+}
 /** Wrapper for making IPC_M_SHARE_IN calls.
  *
  * @param phoneid   Phone that will be used to contact the receiving side.

 /branches/dynload/uspace/srv/kbd/arch/ppc32/src/kbd.c
 ,6 → 183,9
 int kbd_arch_init(void)
 {
+    if (!sysinfo_value("kbd"))
+        return 0;
     return ipc_register_irq(sysinfo_value("kbd.inr"), sysinfo_value("kbd.devno"), 0, &cuda_kbd);
 }

 /branches/dynload/uspace/srv/console/console.c
 ,7 → 500,6
     async_set_client_connection(client_connection);
     /* Connect to keyboard driver */
     kbd_phone = ipc_connect_me_to(PHONE_NS, SERVICE_KEYBOARD, 0, 0);
     while (kbd_phone < 0) {
         usleep(10000);
 ,6 → 517,9
         fb_info.phone = ipc_connect_me_to(PHONE_NS, SERVICE_VIDEO, 0, 0);
     }
+    /* Disable kernel output to the console */
+    __SYSCALL0(SYS_DEBUG_DISABLE_CONSOLE);
     /* Initialize gcons */
     gcons_init(fb_info.phone);
     /* Synchronize, the gcons can have something in queue */
 ,6 → 589,6
     return 0;
 }
 /** @}
  */

 /branches/dynload/uspace/srv/fs/tmpfs/tmpfs.c
 ,16 → 55,6
 vfs_info_t tmpfs_vfs_info = {
     .name = "tmpfs",
-    .ops = {
-        [IPC_METHOD_TO_VFS_OP(VFS_LOOKUP)] = VFS_OP_DEFINED,
-        [IPC_METHOD_TO_VFS_OP(VFS_READ)] = VFS_OP_DEFINED,
-        [IPC_METHOD_TO_VFS_OP(VFS_WRITE)] = VFS_OP_DEFINED,
-        [IPC_METHOD_TO_VFS_OP(VFS_TRUNCATE)] = VFS_OP_DEFINED,
-        [IPC_METHOD_TO_VFS_OP(VFS_MOUNT)] = VFS_OP_DEFINED,
-        [IPC_METHOD_TO_VFS_OP(VFS_MOUNTED)] = VFS_OP_DEFINED,
-        [IPC_METHOD_TO_VFS_OP(VFS_UNMOUNT)] = VFS_OP_NULL,
-        [IPC_METHOD_TO_VFS_OP(VFS_DESTROY)] = VFS_OP_DEFINED,
-    }
 };
 fs_reg_t tmpfs_reg;

 /branches/dynload/uspace/srv/fs/fat/fat.c
 ,15 → 49,6
 vfs_info_t fat_vfs_info = {
     .name = "fat",
-    .ops = {
-        [IPC_METHOD_TO_VFS_OP(VFS_LOOKUP)] = VFS_OP_DEFINED,
-        [IPC_METHOD_TO_VFS_OP(VFS_READ)] = VFS_OP_DEFINED,
-        [IPC_METHOD_TO_VFS_OP(VFS_WRITE)] = VFS_OP_NULL,
-        [IPC_METHOD_TO_VFS_OP(VFS_TRUNCATE)] = VFS_OP_NULL,
-        [IPC_METHOD_TO_VFS_OP(VFS_MOUNT)] = VFS_OP_NULL,
-        [IPC_METHOD_TO_VFS_OP(VFS_MOUNTED)] = VFS_OP_DEFINED,
-        [IPC_METHOD_TO_VFS_OP(VFS_UNMOUNT)] = VFS_OP_NULL,
-    }
 };
 fs_reg_t fat_reg;

/branches/dynload/uspace/srv/pci/libpci/Makefile
7,7 → 7,6

LIBC_PREFIX=$(shell cd ../../../lib/libc; pwd)

include ../../../Makefile.config
include $(LIBC_PREFIX)/Makefile.toolchain

LIBS = $(LIBC_PREFIX)/libc.a

 /branches/dynload/uspace/srv/vfs/vfs.c
 ,6 → 72,8
     while (keep_on_going) {
         ipc_callid_t callid;
         ipc_call_t call;
+        int phone;
+        fs_handle_t fs_handle;
         callid = async_get_call(&call);
 ,9 → 81,28
         case IPC_M_PHONE_HUNGUP:
             keep_on_going = false;
             break;
+        case IPC_M_CONNECT_ME_TO:
+            /*
+             * Connect the client file system to another one.
+             */
+            /* FIXME:
+             * Prevent ordinary clients from connecting to file
+             * system servers directly. This should be solved by
+             * applying some security mechanisms.
+             */
+            fs_handle = IPC_GET_ARG1(call);
+            phone = vfs_grab_phone(fs_handle);
+            (void) ipc_forward_fast(callid, phone, 0, 0, 0,
+                IPC_FF_NONE);
+            vfs_release_phone(phone);
+            break;
         case VFS_REGISTER:
             vfs_register(callid, &call);
-            keep_on_going = false;
+            /*
+             * Keep the connection open so that a file system can
+             * later ask us to connect it to another file system.
+             * This is necessary to support non-root mounts.
+             */
             break;
         case VFS_MOUNT:
             vfs_mount(callid, &call);

 /branches/dynload/uspace/srv/vfs/vfs_register.c
 ,30 → 98,6
         return false;
     }
-    /*
-     * Check if the FS implements mandatory VFS operations.
-     */
-    if (info->ops[IPC_METHOD_TO_VFS_OP(VFS_LOOKUP)] != VFS_OP_DEFINED) {
-        dprintf("Operation VFS_LOOKUP not defined by the client.\n");
-        return false;
-    }
-    if (info->ops[IPC_METHOD_TO_VFS_OP(VFS_READ)] != VFS_OP_DEFINED) {
-        dprintf("Operation VFS_READ not defined by the client.\n");
-        return false;
-    }
-    /*
-     * Check if each operation is either not defined, defined or default.
-     */
-    for (i = VFS_FIRST; i < VFS_LAST_CLNT; i++) {
-        if ((info->ops[IPC_METHOD_TO_VFS_OP(i)] != VFS_OP_NULL) &&
-            (info->ops[IPC_METHOD_TO_VFS_OP(i)] != VFS_OP_DEFAULT) &&
-            (info->ops[IPC_METHOD_TO_VFS_OP(i)] != VFS_OP_DEFINED)) {
-            dprintf("Operation info not understood.\n");
-            return false;
-        }
-    }
     return true;
 }

 /branches/dynload/uspace/srv/vfs/vfs.h
 ,8 → 47,6
 #define VFS_FIRST   IPC_FIRST_USER_METHOD
-#define IPC_METHOD_TO_VFS_OP(m) ((m) - VFS_FIRST)
 /* Basic types. */
 typedef int16_t fs_handle_t;
 typedef int16_t dev_handle_t;
 ,32 → 79,16
     VFS_LAST_SRV,   /* keep this the last member of this enum */
 } vfs_request_srv_t;
-/**
- * An instance of this structure is associated with a particular FS operation.
- * It tells VFS if the FS supports the operation or maybe if a default one
- * should be used.
- */
-typedef enum {
-    VFS_OP_NULL = 0,
-    VFS_OP_DEFAULT,
-    VFS_OP_DEFINED
-} vfs_op_t;
 #define FS_NAME_MAXLEN  20
 /**
  * A structure like this is passed to VFS by each individual FS upon its
  * registration. It assosiates a human-readable identifier with each
- * registered FS. More importantly, through this structure, the FS announces
- * what operations it supports.
+ * registered FS.
  */
 typedef struct {
     /** Unique identifier of the fs. */
     char name[FS_NAME_MAXLEN + 1];
-    /** Operations. */
-    vfs_op_t ops[VFS_LAST_CLNT - VFS_FIRST];
 } vfs_info_t;
 /**

 /branches/dynload/HelenOS.config
 ,10 → 141,10
 % IOSapic on default address support
 ! [PLATFORM=ia64&MACHINE!=ski] CONFIG_IOSAPIC (y/n)
-% Interrupt-driven driver for Legacy Keyboard?
+% Interrupt-driven driver for Legacy Keyboard
 ! [CONFIG_NS16550=n&CONFIG_IOSAPIC=y&MACHINE!=ski] CONFIG_I8042_INTERRUPT_DRIVEN (y/n)
-% Interrupt-driven driver for NS16550?
+% Interrupt-driven driver for NS16550
 ! [CONFIG_NS16550=y&((PLATFORM!=ia64)|CONFIG_IOSAPIC=y)&MACHINE!=ski] CONFIG_NS16550_INTERRUPT_DRIVEN (y/n)
 % Virtually indexed D-cache support
 ,7 → 209,7
 ! [(PLATFORM=ia32|PLATFORM=amd64)&CONFIG_FB=y] CONFIG_VESA_BPP (choice)
 % Start AP processors by the loader
-! [PLATFORM=sparc64] CONFIG_SMP (y/n)
+! [PLATFORM=sparc64&CONFIG_SMP=y] CONFIG_AP (y/n)
 % Use Block Address Translation by the loader
 ! [PLATFORM=ppc32] CONFIG_BAT (y/n)

 /branches/dynload/boot/genarch/ofw.h
 ,7 → 74,7
 typedef struct {
     void *addr;
     uint32_t size;
-} keyboard_t;
+} macio_t;
 typedef struct {
     uint32_t info;
 ,7 → 122,7
 extern int ofw_map(const void *phys, const void *virt, const int size, const int mode);
 extern int ofw_memmap(memmap_t *map);
 extern int ofw_screen(screen_t *screen);
-extern int ofw_keyboard(keyboard_t *keyboard);
+extern int ofw_macio(macio_t *macio);
 extern int setup_palette(void);
 extern void ofw_quiesce(void);

 /branches/dynload/boot/genarch/ofw.c
 ,8 → 203,8
     ofw_arg_t result[4];
     int shift;
-    if (ofw_call("call-method", 3, 5, result, "translate", ofw_mmu,
-        virt) != 0) {
+    if (ofw_call("call-method", 4, 5, result, "translate", ofw_mmu,
+        virt, 0) != 0) {
         puts("Error: MMU method translate() failed, halting.\n");
         halt();
     }

 /branches/dynload/boot/Makefile
 ,8 → 46,8
     DEFS += -DCONFIG_BAT
 endif
-ifeq ($(CONFIG_SMP),y)
-    DEFS += -DCONFIG_SMP
+ifeq ($(CONFIG_AP),y)
+    DEFS += -DCONFIG_AP
 endif
 .PHONY: all build clean generic_clean

 /branches/dynload/boot/arch/sparc64/loader/main.c
 ,8 → 141,8
         silo_ramdisk_image += bootinfo.physmem_start;
         silo_ramdisk_image -= 0x400000;
         /* Install 1:1 mapping for the ramdisk. */
-        if (ofw_map((void *)((uintptr_t)silo_ramdisk_image),
-            (void *)((uintptr_t)silo_ramdisk_image),
+        if (ofw_map((void *)((uintptr_t) silo_ramdisk_image),
+            (void *)((uintptr_t) silo_ramdisk_image),
             silo_ramdisk_size, -1) != 0) {
             printf("Failed to map ramdisk.\n");
             halt();
 ,7 → 202,8
          * given to us by SILO.
          */
         (void) ofw_claim_phys(base + top, silo_ramdisk_size);
-        (void) ofw_map(base + top, base + top, silo_ramdisk_size, -1);
+        (void) ofw_map(bootinfo.physmem_start + base + top, base + top,
+            silo_ramdisk_size, -1);
         /*
          * FIXME If the source and destination overlap, it may be
          * desirable to copy in reverse order, depending on how the two
 ,7 → 258,8
     balloc_base = base + ALIGN_UP(top, PAGE_SIZE);
     (void) ofw_claim_phys(bootinfo.physmem_start + balloc_base,
         BALLOC_MAX_SIZE);
-    (void) ofw_map(balloc_base, balloc_base, BALLOC_MAX_SIZE, -1);
+    (void) ofw_map(bootinfo.physmem_start + balloc_base, balloc_base,
+        BALLOC_MAX_SIZE, -1);
     balloc_init(&bootinfo.ballocs, (uintptr_t)balloc_base);
     printf("\nCanonizing OpenFirmware device tree...");
 ,7 → 266,7
     bootinfo.ofw_root = ofw_tree_build();
     printf("done.\n");
-#ifdef CONFIG_SMP
+#ifdef CONFIG_AP
     printf("\nChecking for secondary processors...");
     if (!ofw_cpu())
         printf("Error: unable to get CPU properties\n");
 ,4 → 280,3
         bootinfo.physmem_start | BSP_PROCESSOR, &bootinfo,
         sizeof(bootinfo));
 }

 /branches/dynload/boot/arch/ppc32/loader/_link.ld.in
 ,7 → 3,7
 ENTRY(start)
 SECTIONS {
-    .boot 0x10000000: AT (0) {
+    .boot 0x01000000: AT (0) {
         *(BOOTSTRAP);
         *(REALMODE);
         *(.text);

 /branches/dynload/boot/arch/ppc32/loader/asm.S
 ,8 → 28,26
 #include "asm.h"
 #include "regname.h"
-#include "debug.inc"
+.macro SMC_COHERENCY addr
+    dcbst 0, \addr
+    sync
+    icbi 0, \addr
+    sync
+    isync
+.endm
+.macro FLUSH_DCACHE addr
+    dcbst 0, \addr
+    sync
+    isync
+.endm
+.macro TLB_FLUSH reg
+    tlbie \reg
+    addi \reg, \reg, 0x1000
+.endm
 .text
 .global halt
 ,9 → 158,6
 real_mode:
-    DEBUG_INIT
-    DEBUG_real_mode
     # copy kernel to proper location
     #
     # r5 = trans (pa)
 ,14 → 178,13
         mtctr r31
         lwz r29, 0(r5)
-        DEBUG_INIT
-        DEBUG_copy_loop
         copy_loop:
             lwz r28, 0(r29)
             stw r28, 0(r30)
+            SMC_COHERENCY r30
             addi r29, r29, 4
             addi r30, r30, 4
             subi r6, r6, 4
 ,15 → 194,11
             bdnz copy_loop
-            DEBUG_end_copy_loop
         addi r5, r5, 4
         b page_copy
     copy_end:
-    DEBUG_segments
     # initially fill segment registers
     li r31, 0
 ,7 → 206,7
     li r29, 8
     mtctr r29
     li r30, 0                     # ASID 0 (VSIDs 0 .. 7)
     seg_fill_uspace:
         mtsrin r30, r31
 ,8 → 230,6
     # invalidate block address translation registers
-    DEBUG_bat
     li r30, 0
     mtspr ibat0u, r30
 ,8 → 259,6
     # create empty Page Hash Table
     # on top of memory, size 64 KB
-    DEBUG_pht
     lwz r31, 0(r3)                # r31 = memory size
     lis r30, 65536@h
 ,6 → 280,7
         # write zeroes
         stw r29, 0(r31)
+        FLUSH_DCACHE r31
         addi r31, r31, 4
         subi r30, r30, 4
 ,8 → 289,6
         beq clear_end
         bdnz pht_clear
-        DEBUG_end_pht_clear
     clear_end:
 ,8 → 296,6
     # create BAT identity mapping
-    DEBUG_mapping
     lwz r31, 0(r3)                # r31 = memory size
     lis r29, 0x0002
 ,8 → 318,6
         bdnz bat_mask
-    DEBUG_bat_mask
     andi. r31, r31, 0x07ff        # mask = mask & 0x07ff (BAT can map up to 256 MB)
     li r29, 2
 ,16 → 337,90
     mtspr dbat0l, r30
     no_bat:
 #endif
-    DEBUG_tlb
+    # flush TLB
-    tlbia
+    li r31, 0
+    sync
+    TLB_FLUSH r31
+    TLB_FLUSH r31
+    TLB_FLUSH r31
+    TLB_FLUSH r31
+    TLB_FLUSH r31
+    TLB_FLUSH r31
+    TLB_FLUSH r31
+    TLB_FLUSH r31
+    TLB_FLUSH r31
+    TLB_FLUSH r31
+    TLB_FLUSH r31
+    TLB_FLUSH r31
+    TLB_FLUSH r31
+    TLB_FLUSH r31
+    TLB_FLUSH r31
+    TLB_FLUSH r31
+    TLB_FLUSH r31
+    TLB_FLUSH r31
+    TLB_FLUSH r31
+    TLB_FLUSH r31
+    TLB_FLUSH r31
+    TLB_FLUSH r31
+    TLB_FLUSH r31
+    TLB_FLUSH r31
+    TLB_FLUSH r31
+    TLB_FLUSH r31
+    TLB_FLUSH r31
+    TLB_FLUSH r31
+    TLB_FLUSH r31
+    TLB_FLUSH r31
+    TLB_FLUSH r31
+    TLB_FLUSH r31
+    TLB_FLUSH r31
+    TLB_FLUSH r31
+    TLB_FLUSH r31
+    TLB_FLUSH r31
+    TLB_FLUSH r31
+    TLB_FLUSH r31
+    TLB_FLUSH r31
+    TLB_FLUSH r31
+    TLB_FLUSH r31
+    TLB_FLUSH r31
+    TLB_FLUSH r31
+    TLB_FLUSH r31
+    TLB_FLUSH r31
+    TLB_FLUSH r31
+    TLB_FLUSH r31
+    TLB_FLUSH r31
+    TLB_FLUSH r31
+    TLB_FLUSH r31
+    TLB_FLUSH r31
+    TLB_FLUSH r31
+    TLB_FLUSH r31
+    TLB_FLUSH r31
+    TLB_FLUSH r31
+    TLB_FLUSH r31
+    TLB_FLUSH r31
+    TLB_FLUSH r31
+    TLB_FLUSH r31
+    TLB_FLUSH r31
+    TLB_FLUSH r31
+    TLB_FLUSH r31
+    TLB_FLUSH r31
+    TLB_FLUSH r31
+    eieio
     tlbsync
+    sync
-    DEBUG_prepare
     # start the kernel
     #
     # pc = KERNEL_START_ADDR
 ,8 → 448,6
     sync
     isync
-    DEBUG_rfi
     rfi
 .align PAGE_WIDTH

 /branches/dynload/boot/arch/ppc32/loader/regname.h
 ,11 → 208,13
 #define hid0    1008
 /* MSR bits */
-#define msr_ir  (1 << 4)
-#define msr_dr  (1 << 5)
+#define msr_dr  (1 << 4)
+#define msr_ir  (1 << 5)
+#define msr_pr  (1 << 14)
 #define msr_ee  (1 << 15)
 /* HID0 bits */
+#define hid0_sten   (1 << 24)
 #define hid0_ice    (1 << 15)
 #define hid0_dce    (1 << 14)
 #define hid0_icfi   (1 << 11)

 /branches/dynload/boot/arch/ppc32/loader/main.c
 ,7 → 89,7
 /** Print version information. */
 static void version_print(void)
 {
-    printf("HelenOS PPC32 Bootloader\nRelease %s%s%s\nCopyright (c) 2006 HelenOS project\n", release, revision, timestamp);
+    printf("HelenOS PPC32 Bootloader\nRelease %s%s%s\nCopyright (c) 2006 HelenOS project\n\n", release, revision, timestamp);
 }
 void bootstrap(void)
 ,25 → 107,29
     check_align(&trans, "translation table");
     if (!ofw_memmap(&bootinfo.memmap)) {
-        printf("Error: unable to get memory map, halting.\n");
+        printf("Error: Unable to get memory map, halting.\n");
         halt();
     }
     if (bootinfo.memmap.total == 0) {
-        printf("Error: no memory detected, halting.\n");
+        printf("Error: No memory detected, halting.\n");
         halt();
     }
     if (!ofw_screen(&bootinfo.screen))
-        printf("Warning: unable to get screen properties.\n");
+        printf("Warning: Unable to get screen properties.\n");
-    if (!ofw_keyboard(&bootinfo.keyboard))
-        printf("Warning: unable to get keyboard properties.\n");
+    if (!ofw_macio(&bootinfo.macio))
+        printf("Warning: Unable to get macio properties.\n");
-    printf("\nDevice statistics\n");
-    printf(" screen at %L, resolution %dx%d, %d bpp (scanline %d bytes)\n", bootinfo.screen.addr, bootinfo.screen.width, bootinfo.screen.height, bootinfo.screen.bpp, bootinfo.screen.scanline);
-    printf(" keyboard at %L (size %d bytes)\n", bootinfo.keyboard.addr, bootinfo.keyboard.size);
+    printf("Device statistics\n");
+    if (bootinfo.screen.addr)
+        printf(" screen at %L, resolution %dx%d, %d bpp (scanline %d bytes)\n", bootinfo.screen.addr, bootinfo.screen.width, bootinfo.screen.height, bootinfo.screen.bpp, bootinfo.screen.scanline);
+    if (bootinfo.macio.addr)
+        printf(" macio at %L (size %d bytes)\n", bootinfo.macio.addr, bootinfo.macio.size);
     void *real_mode_pa = ofw_translate(&real_mode);
     void *trans_pa = ofw_translate(&trans);
     void *bootinfo_pa = ofw_translate(&bootinfo);

 /branches/dynload/boot/arch/ppc32/loader/main.h
 ,7 → 47,7
     memmap_t memmap;
     taskmap_t taskmap;
     screen_t screen;
-    keyboard_t keyboard;
+    macio_t macio;
 } bootinfo_t;
 extern void start(void);

 /branches/dynload/boot/arch/ppc32/loader/ofwarch.c
 ,22 → 48,23
     }
 }
-int ofw_keyboard(keyboard_t *keyboard)
+int ofw_macio(macio_t *macio)
 {
     char device_name[BUF_SIZE];
     if (ofw_get_property(ofw_aliases, "macio", device_name, sizeof(device_name)) <= 0)
         return false;
     phandle device = ofw_find_device(device_name);
     if (device == -1)
         return false;
-    pci_reg_t macio;
-    if (ofw_get_property(device, "assigned-addresses", &macio, sizeof(macio)) <= 0)
+    pci_reg_t pci_reg;
+    if (ofw_get_property(device, "assigned-addresses", &pci_reg, sizeof(pci_reg)) <= 0)
         return false;
-    keyboard->addr = (void *) macio.addr.addr_lo;
-    keyboard->size = macio.size_lo;
+    macio->addr = (void *) pci_reg.addr.addr_lo;
+    macio->size = pci_reg.size_lo;
     return true;
 }

 /branches/dynload/boot/arch/ppc32/loader/Makefile
 ,7 → 83,7
     $(USPACEDIR)/app/init/init \
     $(USPACEDIR)/srv/devmap/devmap \
     $(USPACEDIR)/srv/rd/rd \
-    $(USPACEDIR)/srv/vfs/vfs
+    $(USPACEDIR)/srv/vfs/vfs
 ifeq ($(RDFMT),tmpfs)
     COMPONENTS += $(USPACEDIR)/srv/fs/tmpfs/tmpfs
 endif

 /branches/dynload/boot/arch/ppc64/loader/asm.S
 ,7 → 28,6
 #include "asm.h"
 #include "regname.h"
-#include "debug.inc"
 .text
 ,9 → 139,6
 real_mode:
-    DEBUG_INIT
-    DEBUG_real_mode
     # copy kernel to proper location
     #
     # r5 = trans (pa)
 ,9 → 159,6
         mtctr r31
         lwz r29, 0(r5)
-        DEBUG_INIT
-        DEBUG_copy_loop
         copy_loop:
             lwz r28, 0(r29)
 ,15 → 173,11
             bdnz copy_loop
-            DEBUG_end_copy_loop
         addi r5, r5, 4
         b page_copy
     copy_end:
-    DEBUG_segments
     # initially fill segment registers
     li r31, 0
 ,8 → 210,6
     # create empty Page Hash Table
     # on top of memory, size 64 KB
-    DEBUG_pht
     lwz r31, 0(r3)                # r31 = memory size
     lis r30, 65536@h
 ,18 → 239,11
         beq clear_end
         bdnz pht_clear
-        DEBUG_end_pht_clear
     clear_end:
-    DEBUG_tlb
-    tlbia
     tlbsync
-    DEBUG_prepare
     # start the kernel
     #
     # pc = KERNEL_START_ADDR
 ,8 → 271,6
     sync
     isync
-    DEBUG_rfi
     rfid
 .align PAGE_WIDTH

Subversion Repositories HelenOS

Compare Revisions

Ignore whitespace Rev 4340 → Rev 4341