WebSVN – HelenOS – Path Comparison – / – /branches/sparc/ Rev 3492 and /branches/sparc Rev 3489

Ignore whitespace Rev 3492 → Rev 3489

 /branches/sparc/kernel/arch/sparc64/include/trap/syscall.h
 ,14 → 31,26
  */
 /**
  * @file
- * @brief
+ * @brief This file contains the trap_instruction handler.
+ *
+ * The trap_instruction trap is used to implement syscalls.
  */
 #ifndef KERN_sparc64_SYSCALL_TRAP_H_
 #define KERN_sparc64_SYSCALL_TRAP_H_
-#define TT_TRAP_INSTRUCTION_0       0x100
+#define TT_TRAP_INSTRUCTION(n)      (0x100 + (n))
+#define TT_TRAP_INSTRUCTION_LAST    TT_TRAP_INSTRUCTION(127)
+#ifdef __ASM__
+.macro TRAP_INSTRUCTION n
+    ba trap_instruction_handler
+    mov TT_TRAP_INSTRUCTION(\n) - TT_TRAP_INSTRUCTION(0), %g2
+.endm
+#endif /* __ASM__ */
 #endif
 /** @}

 /branches/sparc/kernel/arch/sparc64/include/trap/regwin.h
 ,7 → 39,6
 #include <arch/stack.h>
 #include <arch/arch.h>
-#include <align.h>
 #define TT_CLEAN_WINDOW         0x24
 #define TT_SPILL_0_NORMAL       0x80    /* kernel spills */
 ,11 → 72,6
 #define I6_OFFSET   112
 #define I7_OFFSET   120
-/* Uspace Window Buffer constants. */
-#define UWB_SIZE    ((NWINDOWS - 1) * STACK_WINDOW_SAVE_AREA_SIZE)
-#define UWB_ALIGNMENT   1024
-#define UWB_ASIZE   ALIGN_UP(UWB_SIZE, UWB_ALIGNMENT)
 #ifdef __ASM__
 /*

 /branches/sparc/kernel/arch/sparc64/src/trap/trap_table.S
 ,22 → 329,198
 fill_1_normal_tl0:
     FILL_NORMAL_HANDLER_USERSPACE
-/* TT = 0x100 - 0x17f, TL = 0, trap_instruction_0 - trap_instruction_7f */
-.irp cur, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19,\
-, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38,\
-, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57,\
-, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76,\
-, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95,\
-, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111,\
-, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126,\
-.org trap_table + (TT_TRAP_INSTRUCTION_0+\cur)*ENTRY_SIZE
-.global trap_instruction_\cur\()_tl0
-trap_instruction_\cur\()_tl0:
-    ba trap_instruction_handler
-    mov \cur, %g2
-.endr
+/* TT = 0x100, TL = 0, trap_instruction_0 */
+.org trap_table + TT_TRAP_INSTRUCTION(0)*ENTRY_SIZE
+.global trap_instruction_0_tl0
+trap_instruction_0_tl0:
+    TRAP_INSTRUCTION 0
+/* TT = 0x101, TL = 0, trap_instruction_1 */
+.org trap_table + TT_TRAP_INSTRUCTION(1)*ENTRY_SIZE
+.global trap_instruction_1_tl0
+trap_instruction_1_tl0:
+    TRAP_INSTRUCTION 1
+/* TT = 0x102, TL = 0, trap_instruction_2 */
+.org trap_table + TT_TRAP_INSTRUCTION(2)*ENTRY_SIZE
+.global trap_instruction_2_tl0
+trap_instruction_2_tl0:
+    TRAP_INSTRUCTION 2
+/* TT = 0x103, TL = 0, trap_instruction_3 */
+.org trap_table + TT_TRAP_INSTRUCTION(3)*ENTRY_SIZE
+.global trap_instruction_3_tl0
+trap_instruction_3_tl0:
+    TRAP_INSTRUCTION 3
+/* TT = 0x104, TL = 0, trap_instruction_4 */
+.org trap_table + TT_TRAP_INSTRUCTION(4)*ENTRY_SIZE
+.global trap_instruction_4_tl0
+trap_instruction_4_tl0:
+    TRAP_INSTRUCTION 4
+/* TT = 0x105, TL = 0, trap_instruction_5 */
+.org trap_table + TT_TRAP_INSTRUCTION(5)*ENTRY_SIZE
+.global trap_instruction_5_tl0
+trap_instruction_5_tl0:
+    TRAP_INSTRUCTION 5
+/* TT = 0x106, TL = 0, trap_instruction_6 */
+.org trap_table + TT_TRAP_INSTRUCTION(6)*ENTRY_SIZE
+.global trap_instruction_6_tl0
+trap_instruction_6_tl0:
+    TRAP_INSTRUCTION 6
+/* TT = 0x107, TL = 0, trap_instruction_7 */
+.org trap_table + TT_TRAP_INSTRUCTION(7)*ENTRY_SIZE
+.global trap_instruction_7_tl0
+trap_instruction_7_tl0:
+    TRAP_INSTRUCTION 7
+/* TT = 0x108, TL = 0, trap_instruction_8 */
+.org trap_table + TT_TRAP_INSTRUCTION(8)*ENTRY_SIZE
+.global trap_instruction_8_tl0
+trap_instruction_8_tl0:
+    TRAP_INSTRUCTION 8
+/* TT = 0x109, TL = 0, trap_instruction_9 */
+.org trap_table + TT_TRAP_INSTRUCTION(9)*ENTRY_SIZE
+.global trap_instruction_9_tl0
+trap_instruction_9_tl0:
+    TRAP_INSTRUCTION 9
+/* TT = 0x10a, TL = 0, trap_instruction_10 */
+.org trap_table + TT_TRAP_INSTRUCTION(10)*ENTRY_SIZE
+.global trap_instruction_10_tl0
+trap_instruction_10_tl0:
+    TRAP_INSTRUCTION 10
+/* TT = 0x10b, TL = 0, trap_instruction_11 */
+.org trap_table + TT_TRAP_INSTRUCTION(11)*ENTRY_SIZE
+.global trap_instruction_11_tl0
+trap_instruction_11_tl0:
+    TRAP_INSTRUCTION 11
+/* TT = 0x10c, TL = 0, trap_instruction_12 */
+.org trap_table + TT_TRAP_INSTRUCTION(12)*ENTRY_SIZE
+.global trap_instruction_12_tl0
+trap_instruction_12_tl0:
+    TRAP_INSTRUCTION 12
+/* TT = 0x10d, TL = 0, trap_instruction_13 */
+.org trap_table + TT_TRAP_INSTRUCTION(13)*ENTRY_SIZE
+.global trap_instruction_13_tl0
+trap_instruction_13_tl0:
+    TRAP_INSTRUCTION 13
+/* TT = 0x10e, TL = 0, trap_instruction_14 */
+.org trap_table + TT_TRAP_INSTRUCTION(14)*ENTRY_SIZE
+.global trap_instruction_14_tl0
+trap_instruction_14_tl0:
+    TRAP_INSTRUCTION 14
+/* TT = 0x10f, TL = 0, trap_instruction_15 */
+.org trap_table + TT_TRAP_INSTRUCTION(15)*ENTRY_SIZE
+.global trap_instruction_15_tl0
+trap_instruction_15_tl0:
+    TRAP_INSTRUCTION 15
+/* TT = 0x110, TL = 0, trap_instruction_16 */
+.org trap_table + TT_TRAP_INSTRUCTION(16)*ENTRY_SIZE
+.global trap_instruction_16_tl0
+trap_instruction_16_tl0:
+    TRAP_INSTRUCTION 16
+/* TT = 0x111, TL = 0, trap_instruction_17 */
+.org trap_table + TT_TRAP_INSTRUCTION(17)*ENTRY_SIZE
+.global trap_instruction_17_tl0
+trap_instruction_17_tl0:
+    TRAP_INSTRUCTION 17
+/* TT = 0x112, TL = 0, trap_instruction_18 */
+.org trap_table + TT_TRAP_INSTRUCTION(18)*ENTRY_SIZE
+.global trap_instruction_18_tl0
+trap_instruction_18_tl0:
+    TRAP_INSTRUCTION 18
+/* TT = 0x113, TL = 0, trap_instruction_19 */
+.org trap_table + TT_TRAP_INSTRUCTION(19)*ENTRY_SIZE
+.global trap_instruction_19_tl0
+trap_instruction_19_tl0:
+    TRAP_INSTRUCTION 19
+/* TT = 0x114, TL = 0, trap_instruction_20 */
+.org trap_table + TT_TRAP_INSTRUCTION(20)*ENTRY_SIZE
+.global trap_instruction_20_tl0
+trap_instruction_20_tl0:
+    TRAP_INSTRUCTION 20
+/* TT = 0x115, TL = 0, trap_instruction_21 */
+.org trap_table + TT_TRAP_INSTRUCTION(21)*ENTRY_SIZE
+.global trap_instruction_21_tl0
+trap_instruction_21_tl0:
+    TRAP_INSTRUCTION 21
+/* TT = 0x116, TL = 0, trap_instruction_22 */
+.org trap_table + TT_TRAP_INSTRUCTION(22)*ENTRY_SIZE
+.global trap_instruction_22_tl0
+trap_instruction_22_tl0:
+    TRAP_INSTRUCTION 22
+/* TT = 0x117, TL = 0, trap_instruction_23 */
+.org trap_table + TT_TRAP_INSTRUCTION(23)*ENTRY_SIZE
+.global trap_instruction_23_tl0
+trap_instruction_23_tl0:
+    TRAP_INSTRUCTION 23
+/* TT = 0x118, TL = 0, trap_instruction_24 */
+.org trap_table + TT_TRAP_INSTRUCTION(24)*ENTRY_SIZE
+.global trap_instruction_24_tl0
+trap_instruction_24_tl0:
+    TRAP_INSTRUCTION 24
+/* TT = 0x119, TL = 0, trap_instruction_25 */
+.org trap_table + TT_TRAP_INSTRUCTION(25)*ENTRY_SIZE
+.global trap_instruction_25_tl0
+trap_instruction_25_tl0:
+    TRAP_INSTRUCTION 25
+/* TT = 0x11a, TL = 0, trap_instruction_26 */
+.org trap_table + TT_TRAP_INSTRUCTION(26)*ENTRY_SIZE
+.global trap_instruction_26_tl0
+trap_instruction_26_tl0:
+    TRAP_INSTRUCTION 26
+/* TT = 0x11b, TL = 0, trap_instruction_27 */
+.org trap_table + TT_TRAP_INSTRUCTION(27)*ENTRY_SIZE
+.global trap_instruction_27_tl0
+trap_instruction_27_tl0:
+    TRAP_INSTRUCTION 27
+/* TT = 0x11c, TL = 0, trap_instruction_28 */
+.org trap_table + TT_TRAP_INSTRUCTION(28)*ENTRY_SIZE
+.global trap_instruction_28_tl0
+trap_instruction_28_tl0:
+    TRAP_INSTRUCTION 28
+/* TT = 0x11d, TL = 0, trap_instruction_29 */
+.org trap_table + TT_TRAP_INSTRUCTION(29)*ENTRY_SIZE
+.global trap_instruction_29_tl0
+trap_instruction_29_tl0:
+    TRAP_INSTRUCTION 29
+/* TT = 0x11e, TL = 0, trap_instruction_30 */
+.org trap_table + TT_TRAP_INSTRUCTION(30)*ENTRY_SIZE
+.global trap_instruction_30_tl0
+trap_instruction_30_tl0:
+    TRAP_INSTRUCTION 30
+/* TT = 0x11f, TL = 0, trap_instruction_31 */
+.org trap_table + TT_TRAP_INSTRUCTION(31)*ENTRY_SIZE
+.global trap_instruction_31_tl0
+trap_instruction_31_tl0:
+    TRAP_INSTRUCTION 31
 /*
  * Handlers for TL>0.
  */
 ,8 → 924,9
      * Fill all windows stored in the buffer.
      */
     clr %g4
-:  andcc %g7, UWB_ALIGNMENT - 1, %g0   ! alignment check
-    bz 0f                   ! %g7 is UWB_ALIGNMENT-aligned, no more windows to refill
+    set PAGE_SIZE - 1, %g5
+:  andcc %g7, %g5, %g0         ! PAGE_SIZE alignment check
+    bz 0f                   ! %g7 is page-aligned, no more windows to refill
     nop
     add %g7, -STACK_WINDOW_SAVE_AREA_SIZE, %g7

 /branches/sparc/kernel/arch/sparc64/src/proc/thread.c
 ,8 → 34,9
 #include <proc/thread.h>
 #include <arch/proc/thread.h>
-#include <mm/slab.h>
-#include <arch/trap/regwin.h>
+#include <mm/frame.h>
+#include <mm/page.h>
+#include <arch/mm/page.h>
 #include <align.h>
 void thr_constructor_arch(thread_t *t)
 ,12 → 50,12
 void thr_destructor_arch(thread_t *t)
 {
     if (t->arch.uspace_window_buffer) {
-        uintptr_t uw_buf = (uintptr_t) t->arch.uspace_window_buffer;
         /*
          * Mind the possible alignment of the userspace window buffer
          * belonging to a killed thread.
          */
-        free((uint8_t *) ALIGN_DOWN(uw_buf, UWB_ALIGNMENT));
+        frame_free(KA2PA(ALIGN_DOWN((uintptr_t)
+            t->arch.uspace_window_buffer, PAGE_SIZE)));
     }
 }
 ,7 → 67,7
          * The thread needs userspace window buffer and the object
          * returned from the slab allocator doesn't have any.
          */
-        t->arch.uspace_window_buffer = malloc(UWB_ASIZE, 0);
+        t->arch.uspace_window_buffer = frame_alloc(ONE_FRAME, FRAME_KA);
     } else {
         uintptr_t uw_buf = (uintptr_t) t->arch.uspace_window_buffer;
 ,7 → 76,7
          * belonging to a killed thread.
          */
         t->arch.uspace_window_buffer = (uint8_t *) ALIGN_DOWN(uw_buf,
-            UWB_ASIZE);
+            PAGE_SIZE);
     }
 }

 /branches/sparc/kernel/arch/ia64/include/asm.h
 ,50 → 44,21
 static inline void  outb(uint64_t port,uint8_t v)
 {
-    *((uint8_t *)(IA64_IOSPACE_ADDRESS + ( (port & 0xfff) | ( (port >> 2) << 12 )))) = v;
+    *((char *)(IA64_IOSPACE_ADDRESS + ( (port & 0xfff) | ( (port >> 2) << 12 )))) = v;
     asm volatile ("mf\n" ::: "memory");
 }
-static inline void  outw(uint64_t port,uint16_t v)
-{
-    *((uint16_t *)(IA64_IOSPACE_ADDRESS + ( (port & 0xfff) | ( (port >> 2) << 12 )))) = v;
-    asm volatile ("mf\n" ::: "memory");
-}
-static inline void  outl(uint64_t port,uint32_t v)
-{
-    *((uint32_t *)(IA64_IOSPACE_ADDRESS + ( (port & 0xfff) | ( (port >> 2) << 12 )))) = v;
-    asm volatile ("mf\n" ::: "memory");
-}
 static inline uint8_t inb(uint64_t port)
 {
     asm volatile ("mf\n" ::: "memory");
-    return *((uint8_t *)(IA64_IOSPACE_ADDRESS + ( (port & 0xfff) | ( (port >> 2) << 12 ))));
+    return *((char *)(IA64_IOSPACE_ADDRESS + ( (port & 0xfff) | ( (port >> 2) << 12 ))));
 }
-static inline uint16_t inw(uint64_t port)
-{
-    asm volatile ("mf\n" ::: "memory");
-    return *((uint16_t *)(IA64_IOSPACE_ADDRESS + ( (port & 0xffE) | ( (port >> 2) << 12 ))));
-}
-static inline uint32_t inl(uint64_t port)
-{
-    asm volatile ("mf\n" ::: "memory");
-    return *((uint32_t *)(IA64_IOSPACE_ADDRESS + ( (port & 0xfff) | ( (port >> 2) << 12 ))));
-}
 /** Return base address of current stack
  *
  * Return the base address of the current stack.

/branches/sparc/kernel/arch/arm32/include/interrupt.h
37,7 → 37,6
#define KERN_arm32_INTERRUPT_H_

#include <arch/types.h>
#include <arch/exception.h>

/** Initial size of exception dispatch table. */
#define IVT_ITEMS 6

 /branches/sparc/kernel/arch/ppc32/include/exception.h
 ,7 → 36,6
 #define KERN_ppc32_EXCEPTION_H_
 #include <arch/types.h>
-#include <arch/regutils.h>
 typedef struct {
     uint32_t r0;
 ,10 → 84,11
 }
 /** Return true if exception happened while in userspace */
+#include <panic.h>
 static inline int istate_from_uspace(istate_t *istate)
 {
-    /* true if privilege level PR (copied from MSR) == 1 */
-    return (istate->srr1 & MSR_PR) != 0;
+    panic("istate_from_uspace not yet implemented");
+    return 0;
 }
 static inline unative_t istate_get_pc(istate_t *istate)

 /branches/sparc/kernel/arch/ppc32/include/asm/regname.h
 ,8 → 214,8
 #define hid0    1008
 /* MSR bits */
-#define msr_dr  (1 << 4)
-#define msr_ir  (1 << 5)
+#define msr_ir  (1 << 4)
+#define msr_dr  (1 << 5)
 #define msr_pr  (1 << 14)
 #define msr_ee  (1 << 15)

 /branches/sparc/kernel/arch/amd64/include/syscall.h
 ,6 → 35,8
 #ifndef KERN_amd64_SYSCALL_H_
 #define KERN_amd64_SYSCALL_H_
+#include <arch/types.h>
 extern void syscall_setup_cpu(void);
 #endif

/branches/sparc/kernel/arch/ia32/include/syscall.h
File deleted
\ No newline at end of file
Property changes:
Deleted: svn:special
-*
\ No newline at end of property

 /branches/sparc/kernel/arch/ia32/include/asm.h
 ,22 → 247,6
     return v;
 }
-/** Write to MSR */
-static inline void write_msr(uint32_t msr, uint64_t value)
-{
-    asm volatile ("wrmsr" : : "c" (msr), "a" ((uint32_t)(value)),
-        "d" ((uint32_t)(value >> 32)));
-}
-static inline uint64_t read_msr(uint32_t msr)
-{
-    uint32_t ax, dx;
-    asm volatile ("rdmsr" : "=a"(ax), "=d"(dx) : "c" (msr));
-    return ((uint64_t)dx << 32) | ax;
-}
 /** Return base address of current stack
  *
  * Return the base address of the current stack.

 /branches/sparc/kernel/arch/ia32/include/cpu.h
 ,21 → 35,12
 #ifndef KERN_ia32_CPU_H_
 #define KERN_ia32_CPU_H_
+#include <arch/pm.h>
+#include <arch/asm.h>
 #define EFLAGS_IF       (1 << 9)
 #define EFLAGS_RF       (1 << 16)
-#define CR4_OSFXSR_MASK (1<<9)
-/* Support for SYSENTER and SYSEXIT */
-#define IA32_MSR_SYSENTER_CS    0x174
-#define IA32_MSR_SYSENTER_ESP   0x175
-#define IA32_MSR_SYSENTER_EIP   0x176
-#ifndef __ASM__
-#include <arch/pm.h>
-#include <arch/asm.h>
 typedef struct {
     int vendor;
     int family;
 ,8 → 51,9
     count_t iomapver_copy;  /** Copy of TASK's I/O Permission bitmap generation count. */
 } cpu_arch_t;
-#endif
+#define CR4_OSFXSR_MASK (1<<9)
 #endif
 /** @}

/branches/sparc/kernel/arch/ia32/Makefile.inc
160,5 → 160,4
arch/$(ARCH)/src/boot/boot.S \
arch/$(ARCH)/src/boot/memmap.c \
arch/$(ARCH)/src/fpu_context.c \
arch/$(ARCH)/src/debugger.c \
arch/$(ARCH)/src/syscall.c
arch/$(ARCH)/src/debugger.c

 /branches/sparc/kernel/arch/ia32/src/asm.S
 ,45 → 147,6
     popfl
 .endm
-/*
- * The SYSENTER syscall mechanism can be used for syscalls with
- * four or fewer arguments. To pass these four arguments, we
- * use four registers: EDX, ECX, EBX, ESI. The syscall number
- * is passed in EAX. We use EDI to remember the return address
- * and EBP to remember the stack. The INT-based syscall mechanism
- * can actually handle six arguments plus the syscall number
- * entirely in registers.
- */
-.global sysenter_handler
-sysenter_handler:
-    pushl %ebp  # remember user stack
-    pushl %edi  # remember return user address
-    pushl %gs   # remember TLS
-    pushl %eax  # syscall number
-    subl $8, %esp   # unused sixth and fifth argument
-    pushl %esi  # fourth argument
-    pushl %ebx  # third argument
-    pushl %ecx  # second argument
-    pushl %edx  # first argument
-    movw $16, %ax
-    movw %ax, %ds
-    movw %ax, %es
-    cld
-    call syscall_handler
-    addl $28, %esp  # remove arguments from stack
-    pop %gs     # restore TLS
-    pop %edx    # prepare return EIP for SYSEXIT
-    pop %ecx    # prepare userspace ESP for SYSEXIT
-    sysexit     # return to userspace
 ## Declare interrupt handlers
 #
 # Declare interrupt handlers for n interrupt

 /branches/sparc/kernel/arch/ia32/src/proc/scheduler.c
 ,14 → 58,8
  */
 void before_thread_runs_arch(void)
 {
-    uintptr_t kstk = (uintptr_t) &THREAD->kstack[THREAD_STACK_SIZE -
+    CPU->arch.tss->esp0 = (uintptr_t) &THREAD->kstack[THREAD_STACK_SIZE -
         SP_DELTA];
-    /* Set kernel stack for CP3 -> CPL0 switch via SYSENTER */
-    write_msr(IA32_MSR_SYSENTER_ESP, kstk);
-    /* Set kernel stack for CPL3 -> CPL0 switch via interrupt */
-    CPU->arch.tss->esp0 = kstk;
     CPU->arch.tss->ss0 = selector(KDATA_DES);
     /* Set up TLS in GS register */

 /branches/sparc/kernel/arch/ia32/src/cpu/cpu.c
 ,7 → 42,6
 #include <fpu_context.h>
 #include <arch/smp/apic.h>
-#include <arch/syscall.h>
 /*
  * Identification of CPUs.
 ,9 → 123,6
             : "i" (CR4_OSFXSR_MASK|(1<<10))
         );
     }
-    /* Setup fast SYSENTER/SYSEXIT syscalls */
-    syscall_setup_cpu();
 }
 void cpu_identify(void)

 /branches/sparc/kernel/generic/src/main/uinit.c
 ,9 → 46,7
 #include <userspace.h>
 #include <mm/slab.h>
 #include <arch.h>
-#include <udebug/udebug.h>
 /** Thread used to bring up userspace thread.
  *
  * @param arg Pointer to structure containing userspace entry and stack
 ,10 → 65,6
      * deployed for the event of forceful task termination.
      */
     thread_detach(THREAD);
-#ifdef CONFIG_UDEBUG
-    udebug_stoppable_end();
-#endif
     uarg.uspace_entry = ((uspace_arg_t *) arg)->uspace_entry;
     uarg.uspace_stack = ((uspace_arg_t *) arg)->uspace_stack;

 /branches/sparc/kernel/generic/src/proc/task.c
 ,18 → 155,7
     ta->capabilities = 0;
     ta->cycles = 0;
-#ifdef CONFIG_UDEBUG
-    /* Init debugging stuff */
-    udebug_task_init(&ta->udebug);
-    /* Init kbox stuff */
-    ipc_answerbox_init(&ta->kernel_box, ta);
-    ta->kb_thread = NULL;
-    mutex_initialize(&ta->kb_cleanup_lock, MUTEX_PASSIVE);
-    ta->kb_finished = false;
-#endif
     ipc_answerbox_init(&ta->answerbox, ta);
     for (i = 0; i < IPC_MAX_PHONES; i++)
         ipc_phone_init(&ta->phones[i]);

 /branches/sparc/kernel/generic/src/proc/thread.c
 ,10 → 180,6
         return -1;
     }
-#ifdef CONFIG_UDEBUG
-    mutex_initialize(&t->udebug.lock, MUTEX_PASSIVE);
-#endif
     return 0;
 }
 ,11 → 347,6
     avltree_node_initialize(&t->threads_tree_node);
     t->threads_tree_node.key = (uintptr_t) t;
-#ifdef CONFIG_UDEBUG
-    /* Init debugging stuff */
-    udebug_thread_initialize(&t->udebug);
-#endif
     /* might depend on previous initialization */
     thread_create_arch(t);
 ,17 → 409,12
     ipl_t ipl;
     /*
-     * Attach to the specified task.
+     * Attach to the current task.
      */
     ipl = interrupts_disable();
     spinlock_lock(&task->lock);
     atomic_inc(&task->refcount);
-    /* Must not count kbox thread into lifecount */
-    if (t->flags & THREAD_FLAG_USPACE)
-        atomic_inc(&task->lifecount);
+    atomic_inc(&task->lifecount);
     list_append(&t->th_link, &task->th_head);
     spinlock_unlock(&task->lock);
 ,19 → 437,14
 {
     ipl_t ipl;
-    if (THREAD->flags & THREAD_FLAG_USPACE) {
-#ifdef CONFIG_UDEBUG
-        /* Generate udebug THREAD_E event */
-        udebug_thread_e_event();
-#endif
-        if (atomic_predec(&TASK->lifecount) == 0) {
-            /*
-             * We are the last userspace thread in the task that
-             * still has not exited. With the exception of the
-             * moment the task was created, new userspace threads
-             * can only be created by threads of the same task.
-             * We are safe to perform cleanup.
-             */
+    if (atomic_predec(&TASK->lifecount) == 0) {
+        /*
+         * We are the last thread in the task that still has not exited.
+         * With the exception of the moment the task was created, new
+         * threads can only be created by threads of the same task.
+         * We are safe to perform cleanup.
+         */
+        if (THREAD->flags & THREAD_FLAG_USPACE) {
             ipc_cleanup();
             futex_cleanup();
             LOG("Cleanup of task %" PRIu64" completed.", TASK->taskid);
 ,11 → 741,6
         thread_attach(t, TASK);
         thread_ready(t);
-#ifdef CONFIG_UDEBUG
-        /* Generate udebug THREAD_B event */
-        udebug_thread_b_event(t);
-#endif
         return 0;
     } else
         free(kernel_uarg);

 /branches/sparc/kernel/generic/src/mm/as.c
 ,7 → 385,7
     if (pages < area->pages) {
         bool cond;
-        uintptr_t start_free = area->base + pages * PAGE_SIZE;
+        uintptr_t start_free = area->base + pages*PAGE_SIZE;
         /*
          * Shrinking the area.
 ,7 → 395,7
         /*
          * Start TLB shootdown sequence.
          */
-        tlb_shootdown_start(TLB_INVL_PAGES, as->asid, area->base +
+        tlb_shootdown_start(TLB_INVL_PAGES, AS->asid, area->base +
             pages * PAGE_SIZE, area->pages - pages);
         /*

 /branches/sparc/kernel/generic/src/ipc/sysipc.c
 ,9 → 42,8
 #include <ipc/sysipc.h>
 #include <ipc/irq.h>
 #include <ipc/ipcrsc.h>
-#include <ipc/kbox.h>
-#include <udebug/udebug_ipc.h>
 #include <arch/interrupt.h>
+#include <print.h>
 #include <syscall/copy.h>
 #include <security/cap.h>
 #include <mm/as.h>
 ,11 → 295,10
 /** Called before the request is sent.
  *
  * @param call      Call structure with the request.
- * @param phone     Phone that the call will be sent through.
  *
  * @return      Return 0 on success, ELIMIT or EPERM on error.
  */
-static int request_preprocess(call_t *call, phone_t *phone)
+static int request_preprocess(call_t *call)
 {
     int newphid;
     size_t size;
 ,10 → 340,6
             return rc;
         }
         break;
-#ifdef CONFIG_UDEBUG
-    case IPC_M_DEBUG_ALL:
-        return udebug_request_preprocess(call, phone);
-#endif
     default:
         break;
     }
 ,7 → 369,6
     if (call->buffer) {
         /* This must be an affirmative answer to IPC_M_DATA_READ. */
-        /* or IPC_M_DEBUG_ALL/UDEBUG_M_MEM_READ... */
         uintptr_t dst = IPC_GET_ARG1(call->data);
         size_t size = IPC_GET_ARG2(call->data);
         int rc = copy_to_uspace((void *) dst, call->buffer, size);
 ,13 → 399,7
             return -1;
         }
         IPC_SET_ARG5(call->data, phoneid);
-    }
-    switch (IPC_GET_METHOD(call->data)) {
-    case IPC_M_DEBUG_ALL:
-        return -1;
-    default:
-        break;
-    }
+    }
     return 0;
 }
 ,7 → 441,7
     IPC_SET_ARG4(call.data, 0);
     IPC_SET_ARG5(call.data, 0);
-    if (!(res = request_preprocess(&call, phone))) {
+    if (!(res = request_preprocess(&call))) {
         rc = ipc_call_sync(phone, &call);
         if (rc != EOK)
             return rc;
 ,7 → 481,7
     GET_CHECK_PHONE(phone, phoneid, return ENOENT);
-    if (!(res = request_preprocess(&call, phone))) {
+    if (!(res = request_preprocess(&call))) {
         rc = ipc_call_sync(phone, &call);
         if (rc != EOK)
             return rc;
 ,7 → 550,7
      */
     IPC_SET_ARG5(call->data, 0);
-    if (!(res = request_preprocess(call, phone)))
+    if (!(res = request_preprocess(call)))
         ipc_call(phone, call);
     else
         ipc_backsend_err(phone, call, res);
 ,7 → 584,7
         ipc_call_free(call);
         return (unative_t) rc;
     }
-    if (!(res = request_preprocess(call, phone)))
+    if (!(res = request_preprocess(call)))
         ipc_call(phone, call);
     else
         ipc_backsend_err(phone, call, res);
 ,16 → 809,11
         ASSERT(! (call->flags & IPC_CALL_STATIC_ALLOC));
+        atomic_dec(&TASK->active_calls);
         if (call->flags & IPC_CALL_DISCARD_ANSWER) {
             ipc_call_free(call);
             goto restart;
-        } else {
-            /*
-             * Decrement the counter of active calls only if the
-             * call is not an answer to IPC_M_PHONE_HUNGUP,
-             * which doesn't contribute to the counter.
-             */
-            atomic_dec(&TASK->active_calls);
         }
         STRUCT_TO_USPACE(&calldata->args, &call->data.args);
 ,30 → 868,5
     return 0;
 }
-#include <console/console.h>
-/**
- * Syscall connect to a task by id.
- *
- * @return      Phone id on success, or negative error code.
- */
-unative_t sys_ipc_connect_kbox(sysarg64_t *uspace_taskid_arg)
-{
-#ifdef CONFIG_UDEBUG
-    sysarg64_t taskid_arg;
-    int rc;
-    rc = copy_from_uspace(&taskid_arg, uspace_taskid_arg, sizeof(sysarg64_t));
-    if (rc != 0)
-        return (unative_t) rc;
-    LOG("sys_ipc_connect_kbox(%" PRIu64 ")\n", taskid_arg.value);
-    return ipc_connect_kbox(taskid_arg.value);
-#else
-    return (unative_t) ENOTSUP;
-#endif
-}
 /** @}
  */

 /branches/sparc/kernel/generic/src/ipc/ipc.c
 ,7 → 43,6
 #include <synch/waitq.h>
 #include <synch/synch.h>
 #include <ipc/ipc.h>
-#include <ipc/kbox.h>
 #include <errno.h>
 #include <mm/slab.h>
 #include <arch.h>
 ,7 → 51,6
 #include <debug.h>
 #include <print.h>
-#include <console/console.h>
 #include <proc/thread.h>
 #include <arch/interrupt.h>
 #include <ipc/irq.h>
 ,7 → 427,7
  *
  * @param lst       Head of the list to be cleaned up.
  */
-void ipc_cleanup_call_list(link_t *lst)
+static void ipc_cleanup_call_list(link_t *lst)
 {
     call_t *call;
 ,31 → 442,33
     }
 }
-/** Disconnects all phones connected to an answerbox.
+/** Cleans up all IPC communication of the current task.
  *
- * @param box       Answerbox to disconnect phones from.
- * @param notify_box    If true, the answerbox will get a hangup message for
- *          each disconnected phone.
+ * Note: ipc_hangup sets returning answerbox to TASK->answerbox, you
+ * have to change it as well if you want to cleanup other tasks than TASK.
  */
-void ipc_answerbox_slam_phones(answerbox_t *box, bool notify_box)
+void ipc_cleanup(void)
 {
+    int i;
+    call_t *call;
     phone_t *phone;
     DEADLOCK_PROBE_INIT(p_phonelck);
-    ipl_t ipl;
-    call_t *call;
-    call = notify_box ? ipc_call_alloc(0) : NULL;
+    /* Disconnect all our phones ('ipc_phone_hangup') */
+    for (i = 0; i < IPC_MAX_PHONES; i++)
+        ipc_phone_hangup(&TASK->phones[i]);
+    /* Disconnect all connected irqs */
+    ipc_irq_cleanup(&TASK->answerbox);
     /* Disconnect all phones connected to our answerbox */
 restart_phones:
-    ipl = interrupts_disable();
-    spinlock_lock(&box->lock);
-    while (!list_empty(&box->connected_phones)) {
-        phone = list_get_instance(box->connected_phones.next,
+    spinlock_lock(&TASK->answerbox.lock);
+    while (!list_empty(&TASK->answerbox.connected_phones)) {
+        phone = list_get_instance(TASK->answerbox.connected_phones.next,
             phone_t, link);
         if (SYNCH_FAILED(mutex_trylock(&phone->lock))) {
-            spinlock_unlock(&box->lock);
-            interrupts_restore(ipl);
+            spinlock_unlock(&TASK->answerbox.lock);
             DEADLOCK_PROBE(p_phonelck, DEADLOCK_THRESHOLD);
             goto restart_phones;
         }
 ,70 → 475,13
         /* Disconnect phone */
         ASSERT(phone->state == IPC_PHONE_CONNECTED);
+        phone->state = IPC_PHONE_SLAMMED;
         list_remove(&phone->link);
-        phone->state = IPC_PHONE_SLAMMED;
-        if (notify_box) {
-            mutex_unlock(&phone->lock);
-            spinlock_unlock(&box->lock);
-            interrupts_restore(ipl);
-            /*
-             * Send one message to the answerbox for each
-             * phone. Used to make sure the kbox thread
-             * wakes up after the last phone has been
-             * disconnected.
-             */
-            IPC_SET_METHOD(call->data, IPC_M_PHONE_HUNGUP);
-            call->flags |= IPC_CALL_DISCARD_ANSWER;
-            _ipc_call(phone, box, call);
-            /* Allocate another call in advance */
-            call = ipc_call_alloc(0);
-            /* Must start again */
-            goto restart_phones;
-        }
         mutex_unlock(&phone->lock);
     }
-    spinlock_unlock(&box->lock);
-    interrupts_restore(ipl);
-    /* Free unused call */
-    if (call)
-        ipc_call_free(call);
-}
-/** Cleans up all IPC communication of the current task.
- *
- * Note: ipc_hangup sets returning answerbox to TASK->answerbox, you
- * have to change it as well if you want to cleanup other tasks than TASK.
- */
-void ipc_cleanup(void)
-{
-    int i;
-    call_t *call;
-    /* Disconnect all our phones ('ipc_phone_hangup') */
-    for (i = 0; i < IPC_MAX_PHONES; i++)
-        ipc_phone_hangup(&TASK->phones[i]);
-    /* Disconnect all connected irqs */
-    ipc_irq_cleanup(&TASK->answerbox);
-    /* Disconnect all phones connected to our regular answerbox */
-    ipc_answerbox_slam_phones(&TASK->answerbox, false);
-#ifdef CONFIG_UDEBUG
-    /* Clean up kbox thread and communications */
-    ipc_kbox_cleanup();
-#endif
     /* Answer all messages in 'calls' and 'dispatched_calls' queues */
-    spinlock_lock(&TASK->answerbox.lock);
     ipc_cleanup_call_list(&TASK->answerbox.dispatched_calls);
     ipc_cleanup_call_list(&TASK->answerbox.calls);
     spinlock_unlock(&TASK->answerbox.lock);
 ,13 → 517,7
             (call->flags & IPC_CALL_NOTIF));
         ASSERT(!(call->flags & IPC_CALL_STATIC_ALLOC));
-        /*
-         * Record the receipt of this call in the current task's counter
-         * of active calls. IPC_M_PHONE_HUNGUP calls do not contribute
-         * to this counter so do not record answers to them either.
-         */
-        if (!(call->flags & IPC_CALL_DISCARD_ANSWER))
-            atomic_dec(&TASK->active_calls);
+        atomic_dec(&TASK->active_calls);
         ipc_call_free(call);
     }
 }

 /branches/sparc/kernel/generic/src/lib/memstr.c
 ,10 → 34,12
  * @file
  * @brief   Memory string operations.
  *
- * This file provides architecture independent functions to manipulate blocks of
- * memory. These functions are optimized as much as generic functions of this
- * type can be. However, architectures are free to provide even more optimized
- * versions of these functions.
+ * This file provides architecture independent functions
+ * to manipulate blocks of memory. These functions
+ * are optimized as much as generic functions of
+ * this type can be. However, architectures are
+ * free to provide even more optimized versions of these
+ * functions.
  */
 #include <memstr.h>
 ,33 → 46,32
 #include <arch/types.h>
 #include <align.h>
-/** Copy block of memory.
+/** Copy block of memory
  *
- * Copy cnt bytes from src address to dst address.  The copying is done
- * word-by-word and then byte-by-byte.  The source and destination memory areas
- * cannot overlap.
+ * Copy cnt bytes from src address to dst address.
+ * The copying is done word-by-word and then byte-by-byte.
+ * The source and destination memory areas cannot overlap.
  *
- * @param src       Source address to copy from.
- * @param dst       Destination address to copy to.
- * @param cnt       Number of bytes to copy.
+ * @param src Origin address to copy from.
+ * @param dst Origin address to copy to.
+ * @param cnt Number of bytes to copy.
  *
- * @return      Destination address.
  */
-void *_memcpy(void *dst, const void *src, size_t cnt)
+void *_memcpy(void * dst, const void *src, size_t cnt)
 {
     unsigned int i, j;
     if (ALIGN_UP((uintptr_t) src, sizeof(unative_t)) != (uintptr_t) src ||
-        ALIGN_UP((uintptr_t) dst, sizeof(unative_t)) != (uintptr_t) dst) {
+        ALIGN_UP((uintptr_t) dst, sizeof(unative_t)) != (uintptr_t) dst) {
         for (i = 0; i < cnt; i++)
             ((uint8_t *) dst)[i] = ((uint8_t *) src)[i];
     } else {
         for (i = 0; i < cnt / sizeof(unative_t); i++)
             ((unative_t *) dst)[i] = ((unative_t *) src)[i];
         for (j = 0; j < cnt % sizeof(unative_t); j++)
-            ((uint8_t *)(((unative_t *) dst) + i))[j] =
-                ((uint8_t *)(((unative_t *) src) + i))[j];
+            ((uint8_t *)(((unative_t *) dst) + i))[j] = ((uint8_t *)(((unative_t *) src) + i))[j];
     }
     return (char *) dst;
 ,12 → 79,12
 /** Fill block of memory
  *
- * Fill cnt bytes at dst address with the value x.  The filling is done
- * byte-by-byte.
+ * Fill cnt bytes at dst address with the value x.
+ * The filling is done byte-by-byte.
  *
- * @param dst       Destination address to fill.
- * @param cnt       Number of bytes to fill.
- * @param x     Value to fill.
+ * @param dst Origin address to fill.
+ * @param cnt Number of bytes to fill.
+ * @param x   Value to fill.
  *
  */
 void _memsetb(void *dst, size_t cnt, uint8_t x)
 ,14 → 96,14
         p[i] = x;
 }
-/** Fill block of memory.
+/** Fill block of memory
  *
- * Fill cnt words at dst address with the value x.  The filling is done
- * word-by-word.
+ * Fill cnt words at dst address with the value x.
+ * The filling is done word-by-word.
  *
- * @param dst       Destination address to fill.
- * @param cnt       Number of words to fill.
- * @param x     Value to fill.
+ * @param dst Origin address to fill.
+ * @param cnt Number of words to fill.
+ * @param x   Value to fill.
  *
  */
 void _memsetw(void *dst, size_t cnt, uint16_t x)
 ,16 → 115,16
         p[i] = x;
 }
-/** Copy string.
+/** Copy string
  *
- * Copy string from src address to dst address.  The copying is done
- * char-by-char until the null character. The source and destination memory
- * areas cannot overlap.
+ * Copy string from src address to dst address.
+ * The copying is done char-by-char until the null
+ * character. The source and destination memory areas
+ * cannot overlap.
  *
- * @param src       Source string to copy from.
- * @param dst       Destination string to copy to.
+ * @param src Origin string to copy from.
+ * @param dst Origin string to copy to.
  *
- * @return      Address of the destination string.
  */
 char *strcpy(char *dest, const char *src)
 {

 /branches/sparc/kernel/generic/src/syscall/syscall.c
 ,7 → 53,6
 #include <syscall/copy.h>
 #include <sysinfo/sysinfo.h>
 #include <console/console.h>
-#include <udebug/udebug.h>
 /** Print using kernel facility
  *
 ,16 → 101,9
 {
     unative_t rc;
-#ifdef CONFIG_UDEBUG
-    udebug_syscall_event(a1, a2, a3, a4, a5, a6, id, 0, false);
-#endif
-    if (id < SYSCALL_END) {
-#ifdef CONFIG_UDEBUG
-        udebug_stoppable_begin();
-#endif
+    if (id < SYSCALL_END)
         rc = syscall_table[id](a1, a2, a3, a4, a5, a6);
-    } else {
+    else {
         printf("Task %" PRIu64": Unknown syscall %#" PRIxn, TASK->taskid, id);
         task_kill(TASK->taskid);
         thread_exit();
 ,11 → 111,6
     if (THREAD->interrupted)
         thread_exit();
-#ifdef CONFIG_UDEBUG
-    udebug_syscall_event(a1, a2, a3, a4, a5, a6, id, rc, true);
-    udebug_stoppable_end();
-#endif
     return rc;
 }
 ,9 → 165,7
     (syshandler_t) sys_sysinfo_value,
     /* Debug calls */
-    (syshandler_t) sys_debug_enable_console,
-    (syshandler_t) sys_ipc_connect_kbox
+    (syshandler_t) sys_debug_enable_console
 };
 /** @}

 /branches/sparc/kernel/generic/src/console/cmd.c
 ,17 → 398,17
     .argc = 0
 };
-/* Data and methods for 'ipc' command */
-static int cmd_ipc(cmd_arg_t *argv);
-static cmd_arg_t ipc_argv = {
+/* Data and methods for 'ipc_task' command */
+static int cmd_ipc_task(cmd_arg_t *argv);
+static cmd_arg_t ipc_task_argv = {
     .type = ARG_TYPE_INT,
 };
-static cmd_info_t ipc_info = {
-    .name = "ipc",
-    .description = "ipc <taskid> Show IPC information of given task.",
-    .func = cmd_ipc,
+static cmd_info_t ipc_task_info = {
+    .name = "ipc_task",
+    .description = "ipc_task <taskid> Show IPC information of given task.",
+    .func = cmd_ipc_task,
     .argc = 1,
-    .argv = &ipc_argv
+    .argv = &ipc_task_argv
 };
 /* Data and methods for 'zone' command */
 ,7 → 461,7
     &uptime_info,
     &halt_info,
     &help_info,
-    &ipc_info,
+    &ipc_task_info,
     &set4_info,
     &slabs_info,
     &symaddr_info,
 ,7 → 937,7
  *
  * return Always 1
  */
-int cmd_ipc(cmd_arg_t * argv) {
+int cmd_ipc_task(cmd_arg_t * argv) {
     ipc_print_task(argv[0].intval);
     return 1;
 }

 /branches/sparc/kernel/generic/include/ipc/ipc.h
 ,12 → 195,6
  */
 #define IPC_M_DATA_READ     7
-/** Debug the recipient.
- * - ARG1 - specifies the debug method (from udebug_method_t)
- * - other arguments are specific to the debug method
- */
-#define IPC_M_DEBUG_ALL     8
 /* Well-known methods */
 #define IPC_M_LAST_SYSTEM   511
 #define IPC_M_PING      512
 ,8 → 307,6
 extern int ipc_phone_hangup(phone_t *);
 extern void ipc_backsend_err(phone_t *, call_t *, unative_t);
 extern void ipc_print_task(task_id_t);
-extern void ipc_answerbox_slam_phones(answerbox_t *, bool);
-extern void ipc_cleanup_call_list(link_t *);
 extern answerbox_t *ipc_phone_0;

/branches/sparc/kernel/generic/include/ipc/sysipc.h
57,7 → 57,6
unative_t sys_ipc_register_irq(inr_t inr, devno_t devno, unative_t method,
irq_code_t *ucode);
unative_t sys_ipc_unregister_irq(inr_t inr, devno_t devno);
unative_t sys_ipc_connect_kbox(sysarg64_t *task_id);

#endif

 /branches/sparc/kernel/generic/include/proc/task.h
 ,7 → 52,6
 #include <arch/cpu.h>
 #include <mm/tlb.h>
 #include <proc/scheduler.h>
-#include <udebug/udebug.h>
 struct thread;
 ,20 → 93,6
      * certain extent.
      */
     atomic_t active_calls;
-#ifdef CONFIG_UDEBUG
-    /** Debugging stuff */
-    udebug_task_t udebug;
-    /** Kernel answerbox */
-    answerbox_t kernel_box;
-    /** Thread used to service kernel answerbox */
-    struct thread *kb_thread;
-    /** Kbox thread creation vs. begin of cleanup mutual exclusion */
-    mutex_t kb_cleanup_lock;
-    /** True if cleanup of kbox has already started */
-    bool kb_finished;
-#endif
     /** Architecture specific task data. */
     task_arch_t arch;

 /branches/sparc/kernel/generic/include/proc/thread.h
 ,7 → 46,6
 #include <arch/cpu.h>
 #include <mm/tlb.h>
 #include <proc/uarg.h>
-#include <udebug/udebug.h>
 #define THREAD_STACK_SIZE   STACK_SIZE
 #define THREAD_NAME_BUFLEN  20
 ,12 → 203,6
     /** Thread's kernel stack. */
     uint8_t *kstack;
-#ifdef CONFIG_UDEBUG
-    /** Debugging stuff */
-    udebug_thread_t udebug;
-#endif
 } thread_t;
 /** Thread list lock.

/branches/sparc/kernel/generic/include/syscall/syscall.h
78,7 → 78,6
SYS_SYSINFO_VALUE,

SYS_DEBUG_ENABLE_CONSOLE,
SYS_IPC_CONNECT_KBOX,
SYSCALL_END
} syscall_t;

 /branches/sparc/kernel/kernel.config
 ,8 → 149,6
 # Virtually indexed D-cache support
 ! [ARCH=sparc64] CONFIG_VIRT_IDX_DCACHE (y/n)
-# Support for userspace debuggers
-! CONFIG_UDEBUG (n/y)
 ## Debugging configuration directives

 /branches/sparc/kernel/Makefile
 ,7 → 44,7
 GCC_CFLAGS = -I$(INCLUDES) -O$(OPTIMIZATION) \
     -fno-builtin -Wall -Wextra -Wno-unused-parameter -Wmissing-prototypes -Werror \
-    -nostdlib -nostdinc -pipe
+    -nostdlib -nostdinc
 ICC_CFLAGS = -I$(INCLUDES) -O$(OPTIMIZATION) \
     -fno-builtin -Wall -Wmissing-prototypes -Werror \
 ,10 → 150,6
     endif
 endif
-ifeq ($(CONFIG_UDEBUG),y)
-    DEFS += -DCONFIG_UDEBUG
-endif
 ## Simple detection for the type of the host system
 #
 HOST = $(shell uname)
 ,17 → 283,6
     generic/src/security/cap.c \
     generic/src/sysinfo/sysinfo.c
-## Udebug interface sources
-#
-ifeq ($(CONFIG_UDEBUG),y)
-GENERIC_SOURCES += \
-    generic/src/ipc/kbox.c \
-    generic/src/udebug/udebug.c \
-    generic/src/udebug/udebug_ops.c \
-    generic/src/udebug/udebug_ipc.c
-endif
 ## Test sources
 #
 ,7 → 350,7
     ln -sfn ../../genarch/include/ generic/include/genarch
 depend: archlinks
-    -makedepend -f - -- $(DEFS) $(CFLAGS) -- $(ARCH_SOURCES) $(GENARCH_SOURCES) $(GENERIC_SOURCES) > Makefile.depend 2> /dev/null
+    -makedepend $(DEFS) $(CFLAGS) -f - $(ARCH_SOURCES) $(GENARCH_SOURCES) $(GENERIC_SOURCES) > Makefile.depend 2> /dev/null
 arch/$(ARCH)/_link.ld: arch/$(ARCH)/_link.ld.in
     $(GCC) $(DEFS) $(GCC_CFLAGS) -D__ASM__ -D__LINKER__ -E -x c $< | grep -v "^\#" > $@

 /branches/sparc/uspace/app/init/init.c
 ,15 → 104,15
         return -1;
     }
-    // FIXME: spawn("/srv/pci");
-    //spawn("/srv/fb");
-    spawn("/srv/kbd");
-    spawn("/srv/console");
+    // FIXME: spawn("/sbin/pci");
+    //spawn("/sbin/fb");
+    spawn("/sbin/kbd");
+    spawn("/sbin/console");
     console_wait();
     version_print();
-    spawn("/app/bdsh");
+    spawn("/sbin/bdsh");
     return 0;
 }

 /branches/sparc/uspace/app/bdsh/scli.c
 ,8 → 53,8
 const char *progname = PACKAGE_NAME;
 /* These are not exposed, even to builtins */
-static int cli_init(cliuser_t *);
-static void cli_finit(cliuser_t *);
+static int cli_init(cliuser_t *usr);
+static void cli_finit(cliuser_t *usr);
 /* Constructor */
 static int cli_init(cliuser_t *usr)

 /branches/sparc/uspace/app/bdsh/cmds/builtins/cd/cd.c
 ,7 → 42,7
 static char * cmdname = "cd";
-void help_cmd_cd(unsigned int level)
+void * help_cmd_cd(unsigned int level)
 {
     if (level == HELP_SHORT) {
         printf("`%s' changes the current working directory.\n", cmdname);
 ,12 → 53,12
             cmdname, cmdname);
     }
-    return;
+    return CMD_VOID;
 }
 /* This is a very rudamentary 'cd' command. It is not 'link smart' (yet) */
-int cmd_cd(char **argv, cliuser_t *usr)
+int * cmd_cd(char **argv, cliuser_t *usr)
 {
     int argc, rc = 0;

 /branches/sparc/uspace/app/bdsh/cmds/builtins/cd/entry.h
 ,8 → 4,8
 #include "scli.h"
 /* Entry points for the cd command */
-extern void help_cmd_cd(unsigned int);
-extern int cmd_cd(char **, cliuser_t *);
+extern void * help_cmd_cd(unsigned int);
+extern int * cmd_cd(char **, cliuser_t *);
 #endif

 /branches/sparc/uspace/app/bdsh/cmds/modules/touch/touch.c
 ,7 → 48,7
 static char *cmdname = "touch";
 /* Dispays help for touch in various levels */
-void help_cmd_touch(unsigned int level)
+void * help_cmd_touch(unsigned int level)
 {
     if (level == HELP_SHORT) {
         printf("`%s' updates access times for files\n", cmdname);
 ,11 → 58,11
                 "created\n", cmdname);
     }
-    return;
+    return CMD_VOID;
 }
 /* Main entry point for touch, accepts an array of arguments */
-int cmd_touch(char **argv)
+int * cmd_touch(char **argv)
 {
     unsigned int argc, i = 0, ret = 0;
     int fd;

 /branches/sparc/uspace/app/bdsh/cmds/modules/touch/entry.h
 ,8 → 2,8
 #define TOUCH_ENTRY_H
 /* Entry points for the touch command */
-extern int cmd_touch(char **);
-extern void help_cmd_touch(unsigned int);
+extern int * cmd_touch(char **);
+extern void * help_cmd_touch(unsigned int);
 #endif /* TOUCH_ENTRY_H */

 /branches/sparc/uspace/app/bdsh/cmds/modules/mkdir/mkdir.c
 ,7 → 60,7
 };
-void help_cmd_mkdir(unsigned int level)
+void * help_cmd_mkdir(unsigned int level)
 {
     if (level == HELP_SHORT) {
         printf("`%s' creates a new directory\n", cmdname);
 ,7 → 79,7
         cmdname, cmdname);
     }
-    return;
+    return CMD_VOID;
 }
 /* This is kind of clunky, but effective for now */
 ,7 → 181,7
     return ret;
 }
-int cmd_mkdir(char **argv)
+int * cmd_mkdir(char **argv)
 {
     unsigned int argc, create_parents = 0, i, ret = 0, follow = 0;
     unsigned int verbose = 0;

 /branches/sparc/uspace/app/bdsh/cmds/modules/mkdir/entry.h
 ,8 → 2,8
 #define MKDIR_ENTRY_H
 /* Entry points for the mkdir command */
-extern int cmd_mkdir(char **);
-extern void help_cmd_mkdir(unsigned int);
+extern int * cmd_mkdir(char **);
+extern void * help_cmd_mkdir(unsigned int);
 #endif /* MKDIR_ENTRY_H */

 /branches/sparc/uspace/app/bdsh/cmds/modules/cat/cat.c
 ,7 → 59,7
 };
 /* Dispays help for cat in various levels */
-void help_cmd_cat(unsigned int level)
+void * help_cmd_cat(unsigned int level)
 {
     if (level == HELP_SHORT) {
         printf("`%s' shows the contents of files\n", cmdname);
 ,7 → 78,7
         cmdname, cmdname);
     }
-    return;
+    return CMD_VOID;
 }
 static unsigned int cat_file(const char *fname, size_t blen)
 ,6 → 121,12
         return 1;
     }
+    /* Debug stuff, newline not added purposefully */
+    printf("** %s is a file with the size of %ld bytes\n",
+        fname, total);
+    printf( "** %d bytes were read in a buffer of %d bytes in %d reads\n",
+        count, blen, reads);
+    printf("** Read %s\n", count == total ? "Succeeded" : "Failed");
     free(buff);
     return 0;
 ,7 → 133,7
 }
 /* Main entry point for cat, accepts an array of arguments */
-int cmd_cat(char **argv)
+int * cmd_cat(char **argv)
 {
     unsigned int argc, i, ret = 0, buffer = 0;
     int c, opt_ind;

 /branches/sparc/uspace/app/bdsh/cmds/modules/cat/entry.h
 ,8 → 2,8
 #define CAT_ENTRY_H
 /* Entry points for the cat command */
-extern int cmd_cat(char **);
-extern void help_cmd_cat(unsigned int);
+extern int * cmd_cat(char **);
+extern void * help_cmd_cat(unsigned int);
 #endif /* CAT_ENTRY_H */

 /branches/sparc/uspace/app/bdsh/cmds/modules/help/help.c
 ,7 → 69,7
     return HELP_IS_RUBBISH;
 }
-void help_cmd_help(unsigned int level)
+void *help_cmd_help(unsigned int level)
 {
     if (level == HELP_SHORT) {
         printf(
 ,10 → 86,10
         cmdname, cmdname, cmdname, cmdname);
     }
-    return;
+    return CMD_VOID;
 }
-int cmd_help(char *argv[])
+int *cmd_help(char *argv[])
 {
     module_t *mod;
     builtin_t *cmd;

 /branches/sparc/uspace/app/bdsh/cmds/modules/help/entry.h
 ,7 → 2,7
 #define HELP_ENTRY_H_
 /* Entry points for the help command */
-extern void help_cmd_help(unsigned int);
-extern int cmd_help(char *[]);
+extern void * help_cmd_help(unsigned int);
+extern int * cmd_help(char *[]);
 #endif

 /branches/sparc/uspace/app/bdsh/cmds/modules/ls/ls.c
 ,7 → 132,7
     return;
 }
-void help_cmd_ls(unsigned int level)
+void * help_cmd_ls(unsigned int level)
 {
     if (level == HELP_SHORT) {
         printf("`%s' lists files and directories.\n", cmdname);
 ,10 → 142,10
                 "working directory is used.\n", cmdname);
     }
-    return;
+    return CMD_VOID;
 }
-int cmd_ls(char **argv)
+int * cmd_ls(char **argv)
 {
     unsigned int argc;
     unsigned int scope;

 /branches/sparc/uspace/app/bdsh/cmds/modules/ls/entry.h
 ,8 → 2,8
 #define LS_ENTRY_H
 /* Entry points for the ls command */
-extern int cmd_ls(char **);
-extern void help_cmd_ls(unsigned int);
+extern int * cmd_ls(char **);
+extern void * help_cmd_ls(unsigned int);
 #endif /* LS_ENTRY_H */

 /branches/sparc/uspace/app/bdsh/cmds/modules/rm/rm.c
 ,7 → 144,7
 }
 /* Dispays help for rm in various levels */
-void help_cmd_rm(unsigned int level)
+void * help_cmd_rm(unsigned int level)
 {
     if (level == HELP_SHORT) {
         printf("`%s' removes files and directories.\n", cmdname);
 ,11 → 161,11
         "Currently, %s is under development, some options don't work.\n",
         cmdname, cmdname);
     }
-    return;
+    return CMD_VOID;
 }
 /* Main entry point for rm, accepts an array of arguments */
-int cmd_rm(char **argv)
+int * cmd_rm(char **argv)
 {
     unsigned int argc;
     unsigned int i, scope, ret = 0;

 /branches/sparc/uspace/app/bdsh/cmds/modules/rm/entry.h
 ,8 → 2,8
 #define RM_ENTRY_H
 /* Entry points for the rm command */
-extern int cmd_rm(char **);
-extern void help_cmd_rm(unsigned int);
+extern int * cmd_rm(char **);
+extern void * help_cmd_rm(unsigned int);
 #endif /* RM_ENTRY_H */

 /branches/sparc/uspace/app/bdsh/cmds/modules/quit/quit.c
 ,15 → 39,15
 extern volatile unsigned int cli_quit;
 extern const char *progname;
-void help_cmd_quit(unsigned int level)
+void * help_cmd_quit(unsigned int level)
 {
     printf("Type `%s' to exit %s\n", cmdname, progname);
-    return;
+    return CMD_VOID;
 }
 /* Quits the program and returns the status of whatever command
  * came before invoking 'quit' */
-int cmd_quit(char *argv[])
+int * cmd_quit(char *argv[])
 {
     /* Inform that we're outta here */
     cli_quit = 1;

 /branches/sparc/uspace/app/bdsh/cmds/modules/quit/entry.h
 ,8 → 2,8
 #define QUIT_ENTRY_H_
 /* Entry points for the quit command */
-extern void help_cmd_quit(unsigned int);
-extern int cmd_quit(char *[]);
+extern void * help_cmd_quit(unsigned int);
+extern int * cmd_quit(char *[]);
 #endif

 /branches/sparc/uspace/app/bdsh/cmds/modules/pwd/entry.h
 ,8 → 4,8
 #include "scli.h"
 /* Entry points for the pwd command */
-extern void help_cmd_pwd(unsigned int);
-extern int cmd_pwd(char **);
+extern void * help_cmd_pwd(unsigned int);
+extern int * cmd_pwd(char **);
 #endif

 /branches/sparc/uspace/app/bdsh/cmds/modules/pwd/pwd.c
 ,13 → 39,13
 static char * cmdname = "pwd";
-void help_cmd_pwd(unsigned int level)
+void * help_cmd_pwd(unsigned int level)
 {
     printf("`%s' prints your current working directory.\n", cmdname);
-    return;
+    return CMD_VOID;
 }
-int cmd_pwd(char *argv[])
+int * cmd_pwd(char *argv[])
 {
     char *buff;

 /branches/sparc/uspace/app/bdsh/cmds/modules/modules.h
 ,8 → 25,6
 #include "touch/entry.h"
 #include "ls/entry.h"
 #include "pwd/entry.h"
-#include "sleep/entry.h"
-#include "cp/entry.h"
 /* Each .def function fills the module_t struct with the individual name, entry
  * point, help entry point, etc. You can use config.h to control what modules
 ,8 → 39,6
 #include "touch/touch_def.h"
 #include "ls/ls_def.h"
 #include "pwd/pwd_def.h"
-#include "sleep/sleep_def.h"
-#include "cp/cp_def.h"
     {NULL, NULL, NULL, NULL}
 };

 /branches/sparc/uspace/app/bdsh/cmds/mknewcmd
 ,8 → 120,8
 EOF
     [ "${CMDTYPE}" = "module" ] && cat << EOF >> ${OUTDIR}/entry.h
 /* Entry points for the ${CMDNAME} command */
-extern int ${CMDENTRY}(char **);
-extern void ${HELPENTRY}(unsigned int);
+extern int * ${CMDENTRY}(char **);
+extern void * ${HELPENTRY}(unsigned int);
 #endif /* ${defname}_ENTRY_H */
 ,22 → 170,22
 static char *cmdname = "${CMDNAME}";
 /* Dispays help for ${CMDNAME} in various levels */
-void ${HELPENTRY}(unsigned int level)
+void * ${HELPENTRY}(unsigned int level)
 {
     printf("This is the %s help for '%s'.\n",
         level ? EXT_HELP : SHORT_HELP, cmdname);
-    return;
+    return CMD_VOID;
 }
 EOF
     [ "${CMDTYPE}" = "module" ] && cat << EOF >> ${OUTDIR}/${CMDNAME}.c
 /* Main entry point for ${CMDNAME}, accepts an array of arguments */
-int ${CMDENTRY}(char **argv)
+int * ${CMDENTRY}(char **argv)
 EOF
     [ "${CMDTYPE}" = "builtin" ] && cat << EOF >> ${OUTDIR}/${CMDNAME}.c
 /* Main entry point for ${CMDNAME}, accepts an array of arguments and a
  * pointer to the cliuser_t structure */
-int ${CMDENTRY}(char **argv, cliuser_t *usr)
+int * ${CMDENTRY}(char **argv, cliuser_t *usr)
 EOF
     cat << EOF >> ${OUTDIR}/${CMDNAME}.c
 {

 /branches/sparc/uspace/app/bdsh/cmds/cmds.h
 ,16 → 19,17
 #define BUFF_SMALL  255
 /* Return macros for int type entry points */
-#define CMD_FAILURE 1
+#define CMD_FAILURE (int*)1
 #define CMD_SUCCESS 0
+#define CMD_VOID (void *)NULL
 /* Types for module command entry and help */
-typedef int (* mod_entry_t)(char **);
-typedef void (* mod_help_t)(unsigned int);
+typedef int * (* mod_entry_t)(char **);
+typedef void * (* mod_help_t)(unsigned int);
 /* Built-in commands need to be able to modify cliuser_t */
-typedef int (* builtin_entry_t)(char **, cliuser_t *);
-typedef void (* builtin_help_t)(unsigned int);
+typedef int * (* builtin_entry_t)(char **, cliuser_t *);
+typedef void * (* builtin_help_t)(unsigned int);
 /* Module structure */
 typedef struct {

 /branches/sparc/uspace/app/bdsh/util.c
 ,6 → 70,125
     return (char *) memcpy(ret, s1, len);
 }
+/*
+ * Take a previously allocated string (s1), re-size it to accept s2 and copy
+ * the contents of s2 into s1.
+ * Return -1 on failure, or the length of the copied string on success.
+ */
+int cli_redup(char **s1, const char *s2)
+{
+    size_t len = strlen(s2) + 1;
+    if (! len)
+        return -1;
+    *s1 = realloc(*s1, len);
+    if (*s1 == NULL) {
+        cli_errno = CL_ENOMEM;
+        return -1;
+    }
+    memset(*s1, 0, sizeof(*s1));
+    memcpy(*s1, s2, len);
+    cli_errno = CL_EOK;
+    return (int) len;
+}
+/* An asprintf() for formatting paths, similar to asprintf() but ensures
+ * the returned allocated string is <= PATH_MAX. On failure, an attempt
+ * is made to return the original string (if not null) unmodified.
+ *
+ * Returns: Length of the new string on success, 0 if the string was handed
+ * back unmodified, -1 on failure. On failure, cli_errno is set.
+ *
+ * We do not use POSIX_PATH_MAX, as it is typically much smaller than the
+ * PATH_MAX defined by the kernel.
+ *
+ * Use this like:
+ * if (1 > cli_psprintf(&char, "%s/%s", foo, bar)) {
+ *   cli_error(cli_errno, "Failed to format path");
+ *   stop_what_your_doing_as_your_out_of_memory();
+ * }
+ */
+int cli_psprintf(char **s1, const char *fmt, ...)
+{
+    va_list ap;
+    size_t needed, base = PATH_MAX + 1;
+    int skipped = 0;
+    char *orig = NULL;
+    char *tmp = (char *) malloc(base);
+    /* Don't even touch s1, not enough memory */
+    if (NULL == tmp) {
+        cli_errno = CL_ENOMEM;
+        return -1;
+    }
+    /* If re-allocating s1, save a copy in case we fail */
+    if (NULL != *s1)
+        orig = cli_strdup(*s1);
+    /* Print the string to tmp so we can determine the size that
+     * we actually need */
+    memset(tmp, 0, sizeof(tmp));
+    va_start(ap, fmt);
+    /* vsnprintf will return the # of bytes not written */
+    skipped = vsnprintf(tmp, base, fmt, ap);
+    va_end(ap);
+    /* realloc/alloc s1 to be just the size that we need */
+    needed = strlen(tmp) + 1;
+    *s1 = realloc(*s1, needed);
+    if (NULL == *s1) {
+        /* No string lived here previously, or we failed to
+         * make a copy of it, either way there's nothing we
+         * can do. */
+        if (NULL == *orig) {
+            cli_errno = CL_ENOMEM;
+            return -1;
+        }
+        /* We can't even allocate enough size to restore the
+         * saved copy, just give up */
+        *s1 = realloc(*s1, strlen(orig) + 1);
+        if (NULL == *s1) {
+            free(tmp);
+            free(orig);
+            cli_errno = CL_ENOMEM;
+            return -1;
+        }
+        /* Give the string back as we found it */
+        memset(*s1, 0, sizeof(*s1));
+        memcpy(*s1, orig, strlen(orig) + 1);
+        free(tmp);
+        free(orig);
+        cli_errno = CL_ENOMEM;
+        return 0;
+    }
+    /* Ok, great, we have enough room */
+    memset(*s1, 0, sizeof(*s1));
+    memcpy(*s1, tmp, needed);
+    free(tmp);
+    /* Free tmp only if s1 was reallocated instead of allocated */
+    if (NULL != orig)
+        free(orig);
+    if (skipped) {
+        /* s1 was bigger than PATH_MAX when expanded, however part
+         * of the string was printed. Tell the caller not to use it */
+        cli_errno = CL_ETOOBIG;
+        return -1;
+    }
+    /* Success! */
+    cli_errno = CL_EOK;
+    return (int) needed;
+}
 /* Ported from FBSD strtok.c 8.1 (Berkeley) 6/4/93 */
 char * cli_strtok_r(char *s, const char *delim, char **last)
 {
 ,7 → 273,10
     if (NULL == usr->cwd)
         snprintf(usr->cwd, PATH_MAX, "(unknown)");
-    asprintf(&usr->prompt, "%s # ", usr->cwd);
+    if (1 < cli_psprintf(&usr->prompt, "%s # ", usr->cwd)) {
+        cli_error(cli_errno, "Failed to set prompt");
+        return 1;
+    }
     return 0;
 }

 /branches/sparc/uspace/app/bdsh/util.h
 ,6 → 5,8
 /* Internal string handlers */
 extern char * cli_strdup(const char *);
+extern int cli_redup(char **, const char *);
+extern int cli_psprintf(char **, const char *, ...);
 extern char * cli_strtok_r(char *, const char *, char **);
 extern char * cli_strtok(char *, const char *);

 /branches/sparc/uspace/app/bdsh/Makefile
 ,8 → 64,6
     cmds/modules/touch/ \
     cmds/modules/ls/ \
     cmds/modules/pwd/ \
-    cmds/modules/sleep/ \
-    cmds/modules/cp/ \
     cmds/builtins/ \
     cmds/builtins/cd/
 ,8 → 76,6
     cmds/modules/touch/touch.c \
     cmds/modules/ls/ls.c \
     cmds/modules/pwd/pwd.c \
-    cmds/modules/sleep/sleep.c \
-    cmds/modules/cp/cp.c \
     cmds/builtins/cd/cd.c \
     cmds/mod_cmds.c \
     cmds/builtin_cmds.c \

 /branches/sparc/uspace/app/bdsh/exec.c
 ,13 → 46,13
 #include "errors.h"
 /* FIXME: Just have find_command() return an allocated string */
-static char *found;
+char *found;
 static char *find_command(char *);
-static int try_access(const char *);
+static unsigned int try_access(const char *);
 /* work-around for access() */
-static int try_access(const char *f)
+static unsigned int try_access(const char *f)
 {
     int fd;
 ,7 → 117,7
     tmp = cli_strdup(find_command(cmd));
     free(found);
-    tid = task_spawn((const char *)tmp, argv);
+    tid = task_spawn((const char *)tmp, (const char **)argv);
     free(tmp);
     if (tid == 0) {

 /branches/sparc/uspace/app/bdsh/README
 ,12 → 57,12
 They are typed as such (from cmds.h):
 /* Types for module command entry and help */
-typedef int (* mod_entry_t)(char **);
-typedef void (* mod_help_t)(unsigned int);
+typedef int * (* mod_entry_t)(char **);
+typedef void * (* mod_help_t)(unsigned int);
 /* Built-in commands need to be able to modify cliuser_t */
-typedef int (* builtin_entry_t)(char **, cliuser_t *);
-typedef void (* builtin_help_t)(unsigned int);
+typedef int * (* builtin_entry_t)(char **, cliuser_t *);
+typedef void * (* builtin_help_t)(unsigned int);
 As you can see, both modular and builtin commands expect an array of
 arguments, however bulitins also expect to be pointed to cliuser_t.
 ,7 → 153,9
 : Change your "usage()" command as shown:
      -- void usage(...)
-     ++ void help_cmd_foo(unsigned int level)
+     ++ void * help_cmd_foo(unsigned int level)
+     -- return;
+     ++ retrn CMD_VOID;
      'level' is either 0 or 1, indicating the level of help requested.
      If the help / usage function currently exits based on how it is
 ,19 → 163,33
 : Change the programs "main()" as shown:
      -- int main(int argc, char **argv)
-     ++ int cmd_foo(char **argv)
+     ++ int * cmd_foo(char **argv)
      -- return 1;
      ++ return CMD_FAILURE;
      -- return 0;
      ++ return CMD_SUCCESS;
+     If main() returns an int that is not 1 or 0 (e.g. 127), cast it as
+     such:
+     -- return 127;
+     ++ return (int *) 127;
+     NOTE: _ONLY_ the main and help entry points need to return int * or
+     void *, respectively. Also take note that argc has changed. The type
+     for entry points may soon change.
      NOTE: If main is void, you'll need to change it and ensure that its
      expecting an array of arguments, even if they'll never be read or
      used. I.e.:
      -- void main(void)
-     ++ int cmd_foo(char **argv)
+     ++ int * cmd_foo(char **argv)
+     Similararly, do not try to return CMD_VOID within the modules main
+     entry point. If somehow you escape the compiler yelling at you, you
+     will surely see pretty blue and yellow fireworks once its reached.
 : Don't expose more than the entry and help points:
      -- void my_function(int n)
      ++ static void my_function(int n)

 /branches/sparc/uspace/app/bdsh/config.h
 ,18 → 1,15
-/* Various things that are used in many places including a few
- * tidbits left over from autoconf prior to the HelenOS port */
+/* Various things that are used in many files
+ * Various temporary port work-arounds are addressed in __HELENOS__ , this
+ * serves as a convenience and later as a guide to make "phony.h" for future
+ * ports */
 /* Specific port work-arounds : */
-#ifndef PATH_MAX
 #define PATH_MAX 255
-#endif
-#ifndef EXIT_SUCCESS
 #define EXIT_SUCCESS 0
-#define EXIT_FAILURE 1
-#endif
+#define EXIT_FAILURE 0
 /* Work around for getenv() */
-#define PATH "/srv:/app"
+#define PATH "/bin:/sbin:/usr/bin:/usr/sbin:/usr/local/bin:/usr/local/sbin"
 #define PATH_DELIM ":"
 /* Used in many places */
 ,7 → 26,7
 #define PACKAGE_BUGREPORT "echo@echoreply.us"
 #define PACKAGE_NAME "bdsh"
 #define PACKAGE_STRING "The brain dead shell"
-#define PACKAGE_TARNAME "bdsh"
+#define PACKAGE_TARNAME "scli"
 #define PACKAGE_VERSION "0.0.1"

 /branches/sparc/uspace/app/tester/tester.c
 ,7 → 133,7
                 if (c == 'a')
                     break;
-            if (test->name == NULL)
+            if (c > 'a')
                 printf("Unknown test\n\n");
             else
                 run_test(test);
 ,8 → 147,6
         }
     }
-    return 0;
 }
 /** @}

/branches/sparc/uspace/app/tester/ipc/send_sync.c
35,6 → 35,7
{
int phoneid;
int res;
static int msgid = 1;
char c;

printf("Select phoneid to send msg: 2-9 (q to skip)\n");

 /branches/sparc/uspace/lib/libc/include/string.h
 ,9 → 64,6
 extern long int strtol(const char *, char **, int);
 extern unsigned long strtoul(const char *, char **, int);
-extern char * strtok_r(char *, const char *, char **);
-extern char * strtok(char *, const char *);
 #endif
 /** @}

 /branches/sparc/uspace/lib/libc/include/task.h
 ,7 → 40,7
 typedef uint64_t task_id_t;
 extern task_id_t task_get_id(void);
-extern task_id_t task_spawn(const char *path, char *const argv[]);
+extern task_id_t task_spawn(const char *path, const char *argv[]);
 #endif

 /branches/sparc/uspace/lib/libc/include/libc.h
 ,14 → 39,14
 #include <kernel/syscall/syscall.h>
 #include <libarch/syscall.h>
-#define __SYSCALL0(id) __syscall0(0, 0, 0, 0, 0, 0, id)
-#define __SYSCALL1(id, p1) __syscall1(p1, 0, 0, 0, 0, 0, id)
-#define __SYSCALL2(id, p1, p2) __syscall2(p1, p2, 0, 0, 0, 0, id)
-#define __SYSCALL3(id, p1, p2, p3) __syscall3(p1, p2, p3, 0, 0, 0, id)
-#define __SYSCALL4(id, p1, p2, p3, p4) __syscall4(p1, p2, p3, p4, 0, 0, id)
-#define __SYSCALL5(id, p1, p2, p3, p4, p5) __syscall5(p1, p2, p3, p4, p5, 0, id)
+#define __SYSCALL0(id) __syscall(0, 0, 0, 0, 0, 0, id)
+#define __SYSCALL1(id, p1) __syscall(p1, 0, 0, 0, 0, 0, id)
+#define __SYSCALL2(id, p1, p2) __syscall(p1, p2, 0, 0, 0, 0, id)
+#define __SYSCALL3(id, p1, p2, p3) __syscall(p1, p2, p3, 0, 0, 0, id)
+#define __SYSCALL4(id, p1, p2, p3, p4) __syscall(p1, p2, p3, p4, 0, 0, id)
+#define __SYSCALL5(id, p1, p2, p3, p4, p5) __syscall(p1, p2, p3, p4, p5, 0, id)
 #define __SYSCALL6(id, p1, p2, p3, p4, p5, p6) \
-    __syscall6(p1, p2, p3, p4, p5, p6, id)
+    __syscall(p1, p2, p3, p4, p5, p6,id)
 extern void __main(void *pcb_ptr);
 extern void __exit(void);

 /branches/sparc/uspace/lib/libc/include/loader/pcb.h
 ,8 → 40,7
 typedef void (*entry_point_t)(void);
-/** Program Control Block.
- *
+/**
  * Holds pointers to data passed from the program loader to the program
  * and/or to the dynamic linker. This includes the program entry point,
  * arguments, environment variables etc.

 /branches/sparc/uspace/lib/libc/include/ipc/loader.h
 ,17 → 32,15
 /** @file
  */
-#ifndef LIBC_IPC_LOADER_H_
-#define LIBC_IPC_LOADER_H_
+#ifndef LIBC_LOADER_H_
+#define LIBC_LOADER_H_
 #include <ipc/ipc.h>
 typedef enum {
     LOADER_HELLO = IPC_FIRST_USER_METHOD,
-    LOADER_GET_TASKID,
     LOADER_SET_PATHNAME,
     LOADER_SET_ARGS,
-    LOADER_LOAD,
     LOADER_RUN
 } fb_request_t;

 /branches/sparc/uspace/lib/libc/include/ipc/ipc.h
 ,16 → 283,11
 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_read_finalize(ipc_callid_t callid, void *src, size_t size);
+extern int ipc_data_write_start(int phoneid, 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);
-#include <task.h>
-extern int ipc_connect_kbox(task_id_t id);
 #endif
 /** @}

 /branches/sparc/uspace/lib/libc/include/syscall.h
 ,28 → 32,15
 /**
  * @file
  * @brief   Syscall function declaration for architectures that don't
- *      inline syscalls or architectures that handle syscalls
- *      according to the number of arguments.
+ *      inline syscalls.
  */
 #ifndef LIBC_SYSCALL_H_
 #define LIBC_SYSCALL_H_
-#ifndef LIBARCH_SYSCALL_GENERIC
-#error "You can't include this file directly."
-#endif
 #include <sys/types.h>
 #include <kernel/syscall/syscall.h>
-#define __syscall0  __syscall
-#define __syscall1  __syscall
-#define __syscall2  __syscall
-#define __syscall3  __syscall
-#define __syscall4  __syscall
-#define __syscall5  __syscall
-#define __syscall6  __syscall
 extern sysarg_t __syscall(const sysarg_t p1, const sysarg_t p2,
     const sysarg_t p3, const sysarg_t p4, const sysarg_t p5, const sysarg_t p6,
     const syscall_t id);

 /branches/sparc/uspace/lib/libc/generic/ipc.c
 ,7 → 847,7
  *
  * @return      Zero on success or a value from @ref errno.h on failure.
  */
-int ipc_data_read_finalize(ipc_callid_t callid, const void *src, size_t size)
+int ipc_data_read_finalize(ipc_callid_t callid, void *src, size_t size)
 {
     return ipc_answer_2(callid, EOK, (ipcarg_t) src, (ipcarg_t) size);
 }
 ,7 → 860,7
  *
  * @return      Zero on success or a negative error code from errno.h.
  */
-int ipc_data_write_start(int phoneid, const void *src, size_t size)
+int ipc_data_write_start(int phoneid, void *src, size_t size)
 {
     return async_req_2_0(phoneid, IPC_M_DATA_WRITE, (ipcarg_t) src,
         (ipcarg_t) size);
 ,18 → 909,6
 {
     return ipc_answer_2(callid, EOK, (ipcarg_t) dst, (ipcarg_t) size);
 }
-#include <kernel/syscall/sysarg64.h>
-/** Connect to a task specified by id.
- */
-int ipc_connect_kbox(task_id_t id)
-{
-    sysarg64_t arg;
-    arg.value = (unsigned long long) id;
-    return __SYSCALL1(SYS_IPC_CONNECT_KBOX, (sysarg_t) &arg);
-}
 /** @}
  */

/branches/sparc/uspace/lib/libc/generic/vfs/canonify.c
36,7 → 36,6
*/

#include <stdlib.h>
#include <vfs/canonify.h>

/** Token types used for tokenization of path. */
typedef enum {

 /branches/sparc/uspace/lib/libc/generic/vfs/vfs.c
 ,7 → 116,7
     return vfs_phone;
 }
-static int device_get_handle(const char *name, dev_handle_t *handle)
+static int device_get_handle(char *name, dev_handle_t *handle)
 {
     int phone = ipc_connect_me_to(PHONE_NS, SERVICE_DEVMAP, DEVMAP_CLIENT,
 );
 ,9 → 364,9
         }
     }
-    ipcarg_t newoffs;
+    off_t newoffs;
     rc = async_req_3_1(vfs_phone, VFS_SEEK, fildes, offset, whence,
-        &newoffs);
+        (ipcarg_t)&newoffs);
     async_serialize_end();
     futex_up(&vfs_phone_futex);
 ,7 → 374,7
     if (rc != EOK)
         return (off_t) -1;
-    return (off_t) newoffs;
+    return newoffs;
 }
 int ftruncate(int fildes, off_t length)
 ,7 → 599,6
     cwd_path = pa;
     cwd_len = pa_len;
     futex_up(&cwd_futex);
-    return EOK;
 }
 char *getcwd(char *buf, size_t size)

 /branches/sparc/uspace/lib/libc/generic/task.c
 ,10 → 34,14
  */
 #include <task.h>
+#include <ipc/ipc.h>
+#include <ipc/loader.h>
 #include <libc.h>
+#include <string.h>
 #include <stdlib.h>
+#include <async.h>
 #include <errno.h>
-#include <loader/loader.h>
+#include <vfs/vfs.h>
 task_id_t task_get_id(void)
 {
 ,62 → 52,134
     return task_id;
 }
-/** Create a new task by running an executable from the filesystem.
+static int task_spawn_loader(void)
+{
+    int phone_id, rc;
+    rc = __SYSCALL1(SYS_PROGRAM_SPAWN_LOADER, (sysarg_t) &phone_id);
+    if (rc != 0)
+        return rc;
+    return phone_id;
+}
+static int loader_set_args(int phone_id, const char *argv[])
+{
+    aid_t req;
+    ipc_call_t answer;
+    ipcarg_t rc;
+    const char **ap;
+    char *dp;
+    char *arg_buf;
+    size_t buffer_size;
+    size_t len;
+    /*
+     * Serialize the arguments into a single array. First
+     * compute size of the buffer needed.
+     */
+    ap = argv;
+    buffer_size = 0;
+    while (*ap != NULL) {
+        buffer_size += strlen(*ap) + 1;
+        ++ap;
+    }
+    arg_buf = malloc(buffer_size);
+    if (arg_buf == NULL) return ENOMEM;
+    /* Now fill the buffer with null-terminated argument strings */
+    ap = argv;
+    dp = arg_buf;
+    while (*ap != NULL) {
+        strcpy(dp, *ap);
+        dp += strlen(*ap) + 1;
+        ++ap;
+    }
+    /* Send serialized arguments to the loader */
+    req = async_send_0(phone_id, LOADER_SET_ARGS, &answer);
+    rc = ipc_data_write_start(phone_id, (void *)arg_buf, buffer_size);
+    if (rc != EOK) {
+        async_wait_for(req, NULL);
+        return rc;
+    }
+    async_wait_for(req, &rc);
+    if (rc != EOK) return rc;
+    /* Free temporary buffer */
+    free(arg_buf);
+    return EOK;
+}
+/** Create a new task by running an executable from VFS.
  *
- * This is really just a convenience wrapper over the more complicated
- * loader API.
- *
  * @param path  pathname of the binary to execute
  * @param argv  command-line arguments
  * @return  ID of the newly created task or zero on error.
  */
-task_id_t task_spawn(const char *path, char *const argv[])
+task_id_t task_spawn(const char *path, const char *argv[])
 {
-    loader_t *ldr;
-    task_id_t task_id;
+    int phone_id;
+    ipc_call_t answer;
+    aid_t req;
     int rc;
+    ipcarg_t retval;
-    /* Spawn a program loader. */
-    ldr = loader_spawn();
-    if (ldr == NULL)
+    char *pa;
+    size_t pa_len;
+    pa = absolutize(path, &pa_len);
+    if (!pa)
         return 0;
-    /* Get task ID. */
-    rc = loader_get_task_id(ldr, &task_id);
-    if (rc != EOK)
-        goto error;
+    /* Spawn a program loader */
+    phone_id = task_spawn_loader();
+    if (phone_id < 0)
+        return 0;
-    /* Send program pathname. */
-    rc = loader_set_pathname(ldr, path);
+    /*
+     * Say hello so that the loader knows the incoming connection's
+     * phone hash.
+     */
+    rc = async_req_0_0(phone_id, LOADER_HELLO);
     if (rc != EOK)
-        goto error;
+        return 0;
-    /* Send arguments. */
-    rc = loader_set_args(ldr, argv);
-    if (rc != EOK)
+    /* Send program pathname */
+    req = async_send_0(phone_id, LOADER_SET_PATHNAME, &answer);
+    rc = ipc_data_write_start(phone_id, (void *)pa, pa_len);
+    if (rc != EOK) {
+        async_wait_for(req, NULL);
+        return 1;
+    }
+    async_wait_for(req, &retval);
+    if (retval != EOK)
         goto error;
-    /* Load the program. */
-    rc = loader_load_program(ldr);
+    /* Send arguments */
+    rc = loader_set_args(phone_id, argv);
     if (rc != EOK)
         goto error;
-    /* Run it. */
-    /* Load the program. */
-    rc = loader_run(ldr);
+    /* Request loader to start the program */
+    rc = async_req_0_0(phone_id, LOADER_RUN);
     if (rc != EOK)
         goto error;
     /* Success */
+    ipc_hangup(phone_id);
+    return 1;
-    free(ldr);
-    return task_id;
     /* Error exit */
 error:
-    loader_abort(ldr);
-    free(ldr);
+    ipc_hangup(phone_id);
     return 0;
 }

 /branches/sparc/uspace/lib/libc/generic/string.c
 ,7 → 1,5
 /*
  * Copyright (c) 2005 Martin Decky
- * Copyright (C) 1998 by Wes Peters <wes@softweyr.com>
- * Copyright (c) 1988, 1993 The Regents of the University of California.
  * All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
 ,52 → 396,5
     return (char *) memcpy(ret, s1, len);
 }
-/* Ported from FBSD strtok.c 8.1 (Berkeley) 6/4/93 */
-char * strtok_r(char *s, const char *delim, char **last)
-{
-    char *spanp, *tok;
-    int c, sc;
-    if (s == NULL && (s = *last) == NULL)
-        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 * strtok(char *s, const char *delim)
-{
-    static char *last;
-    return (strtok_r(s, delim, &last));
-}
 /** @}
  */

/branches/sparc/uspace/lib/libc/generic/smc.c
34,7 → 34,6

#include <libc.h>
#include <sys/types.h>
#include <smc.h>

int smc_coherence(void *address, size_t size)
{

 /branches/sparc/uspace/lib/libc/generic/time.c
 ,8 → 47,6
 #include <as.h>
 #include <ddi.h>
-#include <time.h>
 /* Pointers to public variables with time */
 struct {
     volatile sysarg_t seconds1;

 /branches/sparc/uspace/lib/libc/generic/tls.c
 ,7 → 116,7
     tcb_t *tcb;
     size = ALIGN_UP(size, &_tls_alignment);
-    *data = memalign((uintptr_t) &_tls_alignment, sizeof(tcb_t) + size);
+    *data = memalign(&_tls_alignment, sizeof(tcb_t) + size);
     tcb = (tcb_t *) (*data + size);
     tcb->self = tcb;

/branches/sparc/uspace/lib/libc/Makefile
71,7 → 71,6
generic/sysinfo.c \
generic/ipc.c \
generic/async.c \
generic/loader.c \
generic/getopt.c \
generic/libadt/list.o \
generic/libadt/hash_table.o \
79,7 → 78,6
generic/err.c \
generic/stdlib.c \
generic/mman.c \
generic/udebug.c \
generic/vfs/vfs.c \
generic/vfs/canonify.c

106,7 → 104,7
find generic/ arch/$(ARCH)/ -name '*.o' -follow -exec rm \{\} \;

depend: kerninc
-makedepend -f - -- $(DEFS) $(CFLAGS) -- $(ARCH_SOURCES) $(GENERIC_SOURCES) > Makefile.depend 2> /dev/null
-makedepend $(DEFS) $(CFLAGS) -f - $(ARCH_SOURCES) $(GENERIC_SOURCES) > Makefile.depend 2> /dev/null

libc.a: depend $(ARCH_OBJECTS) $(GENERIC_OBJECTS)
$(AR) rc libc.a $(LIBS) $(ARCH_OBJECTS) $(GENERIC_OBJECTS)

 /branches/sparc/uspace/lib/libc/arch/sparc64/include/syscall.h
 ,14 → 38,6
 #include <sys/types.h>
 #include <kernel/syscall/syscall.h>
-#define __syscall0  __syscall
-#define __syscall1  __syscall
-#define __syscall2  __syscall
-#define __syscall3  __syscall
-#define __syscall4  __syscall
-#define __syscall5  __syscall
-#define __syscall6  __syscall
 static inline sysarg_t
 __syscall(const sysarg_t p1, const sysarg_t p2, const sysarg_t p3,
     const sysarg_t p4, const sysarg_t p5, const sysarg_t p6, const syscall_t id)

 /branches/sparc/uspace/lib/libc/arch/ia64/include/syscall.h
 ,8 → 36,6
 #ifndef LIBC_ia64_SYSCALL_H_
 #define LIBC_ia64_SYSCALL_H_
-#define LIBARCH_SYSCALL_GENERIC
 #include <syscall.h>
 #endif

 /branches/sparc/uspace/lib/libc/arch/arm32/include/syscall.h
 ,14 → 30,12
  * @{
  */
 /** @file
- *  @brief
+ *  @brief Empty.
  */
 #ifndef LIBC_arm32_SYSCALL_H_
 #define LIBC_arm32_SYSCALL_H_
-#define LIBARCH_SYSCALL_GENERIC
 #include <syscall.h>
 #endif

 /branches/sparc/uspace/lib/libc/arch/ppc32/include/syscall.h
 ,8 → 36,6
 #ifndef LIBC_ppc32_SYSCALL_H_
 #define LIBC_ppc32_SYSCALL_H_
-#define LIBARCH_SYSCALL_GENERIC
 #include <syscall.h>
 #endif

 /branches/sparc/uspace/lib/libc/arch/amd64/include/syscall.h
 ,8 → 36,6
 #ifndef LIBC_amd64_SYSCALL_H_
 #define LIBC_amd64_SYSCALL_H_
-#define LIBARCH_SYSCALL_GENERIC
 #include <syscall.h>
 #endif

 /branches/sparc/uspace/lib/libc/arch/ppc64/include/syscall.h
 ,8 → 36,6
 #ifndef LIBC_ppc64_SYSCALL_H_
 #define LIBC_ppc64_SYSCALL_H_
-#define LIBARCH_SYSCALL_GENERIC
 #include <syscall.h>
 #endif

 /branches/sparc/uspace/lib/libc/arch/mips32/include/syscall.h
 ,8 → 36,6
 #ifndef LIBC_mips32_SYSCALL_H_
 #define LIBC_mips32_SYSCALL_H_
-#define LIBARCH_SYSCALL_GENERIC
 #include <syscall.h>
 #endif

 /branches/sparc/uspace/lib/libc/arch/ia32/include/syscall.h
 ,25 → 36,8
 #ifndef LIBC_ia32_SYSCALL_H_
 #define LIBC_ia32_SYSCALL_H_
-#include <sys/types.h>
-#include <kernel/syscall/syscall.h>
+#include <syscall.h>
-#define __syscall0  __syscall_sysenter
-#define __syscall1  __syscall_sysenter
-#define __syscall2  __syscall_sysenter
-#define __syscall3  __syscall_sysenter
-#define __syscall4  __syscall_sysenter
-#define __syscall5  __syscall_int
-#define __syscall6  __syscall_int
-extern sysarg_t
-__syscall_sysenter(const sysarg_t, const sysarg_t, const sysarg_t, const sysarg_t,
-     const sysarg_t, const sysarg_t, const syscall_t);
-extern sysarg_t
-__syscall_int(const sysarg_t, const sysarg_t, const sysarg_t, const sysarg_t,
-     const sysarg_t, const sysarg_t, const syscall_t);
 #endif
 /** @}

 /branches/sparc/uspace/lib/libc/arch/ia32/src/syscall.S
 ,14 → 28,14
 .text
-/** Syscall wrapper - INT $0x30 version.
+/** Syscall wrapper.
  *
  * Mind the order of arguments. First two arguments and the syscall number go to
  * scratch registers. An optimized version of this wrapper for fewer arguments
  * could benefit from this and not save unused registers on the stack.
  */
-.global __syscall_int
-__syscall_int:
+.global __syscall
+__syscall:
     pushl %ebx
     pushl %esi
     pushl %edi
 ,38 → 53,3
     popl %esi
     popl %ebx
     ret
-/** Syscall wrapper - SYSENTER version.
- *
- * This is an optimized version of syscall for four or less arguments.  Note
- * that EBP and EDI are used to remember user stack address and the return
- * address. The kernel part doesn't save DS, ES and FS so the handler restores
- * these to the selector immediately following CS (it must be the flat data
- * segment, otherwise the SYSENTER wouldn't work in the first place).
- */
-.global __syscall_sysenter
-__syscall_sysenter:
-    pushl %ebx
-    pushl %esi
-    pushl %edi
-    pushl %ebp
-    mov %esp, %ebp
-    lea ra, %edi
-    movl 20(%esp), %edx # First argument.
-    movl 24(%esp), %ecx # Second argument.
-    movl 28(%esp), %ebx # Third argument.
-    movl 32(%esp), %esi # Fourth argument.
-    movl 44(%esp), %eax # Syscall number.
-    sysenter
-ra:
-    movw %cs, %cx
-    addw $8, %cx
-    movw %cx, %ds
-    movw %cx, %es
-    movw %cx, %fs
-    popl %ebp
-    popl %edi
-    popl %esi
-    popl %ebx
-    ret

 /branches/sparc/uspace/lib/libc/Makefile.toolchain
 ,7 → 27,7
 #
 DEFS = -DARCH=$(ARCH)
-CFLAGS = -fno-builtin -Wall -Werror-implicit-function-declaration -Wmissing-prototypes -O3 -nostdlib -nostdinc -I$(LIBC_PREFIX)/include -pipe
+CFLAGS = -fno-builtin -Wall -Werror-implicit-function-declaration -Wmissing-prototypes -O3 -nostdlib -nostdinc -I$(LIBC_PREFIX)/include
 LFLAGS = -M -N $(SOFTINT_PREFIX)/libsoftint.a
 AFLAGS =
 #-Werror

 /branches/sparc/uspace/lib/libfs/Makefile
 ,7 → 57,7
     find . -name '*.o' -follow -exec rm \{\} \;
 depend:
-    -makedepend -f - -- $(DEFS) $(CFLAGS) -- $(SOURCES) > Makefile.depend 2> /dev/null
+    -makedepend $(DEFS) $(CFLAGS) -f - $(SOURCES) > Makefile.depend 2> /dev/null
 libfs.a: depend $(OBJECTS)
     $(AR) rc libfs.a $(OBJECTS)

 /branches/sparc/uspace/lib/softfloat/Makefile
 ,7 → 66,7
     find generic/ -name '*.o' -follow -exec rm \{\} \;
 depend:
-    -makedepend -f - -- $(DEFS) $(CFLAGS) -- $(GENERIC_SOURCES) > Makefile.depend 2> /dev/null
+    -makedepend $(DEFS) $(CFLAGS) -f - $(GENERIC_SOURCES) > Makefile.depend 2> /dev/null
 libsoftfloat.a: depend $(ARCH_OBJECTS) $(GENERIC_OBJECTS)
     $(AR) rc libsoftfloat.a $(ARCH_OBJECTS) $(GENERIC_OBJECTS)

 /branches/sparc/uspace/lib/softint/Makefile
 ,7 → 58,7
     find generic/ -name '*.o' -follow -exec rm \{\} \;
 depend:
-    -makedepend -f - -- $(DEFS) $(CFLAGS) -- $(GENERIC_SOURCES) > Makefile.depend 2> /dev/null
+    -makedepend $(DEFS) $(CFLAGS) -f - $(GENERIC_SOURCES) > Makefile.depend 2> /dev/null
 libsoftint.a: depend $(ARCH_OBJECTS) $(GENERIC_OBJECTS)
     $(AR) rc libsoftint.a $(ARCH_OBJECTS) $(GENERIC_OBJECTS)

 /branches/sparc/uspace/srv/vfs/vfs_ops.c
 ,7 → 153,7
         return;
     }
     /* Allocate buffer for the mount point data being received. */
-    char *buf;
+    uint8_t *buf;
     buf = malloc(size + 1);
     if (!buf) {
         ipc_answer_0(callid, ENOMEM);

 /branches/sparc/uspace/srv/vfs/vfs.c
 ,6 → 49,8
 #define NAME "vfs"
+#define dprintf(...)    printf(__VA_ARGS__)
 static void vfs_connection(ipc_callid_t iid, ipc_call_t *icall)
 {
     bool keep_on_going = 1;

 /branches/sparc/uspace/srv/loader/main.c
 ,7 → 46,6
 #include <stdio.h>
 #include <stdlib.h>
 #include <unistd.h>
-#include <bool.h>
 #include <fcntl.h>
 #include <sys/types.h>
 #include <ipc/ipc.h>
 ,33 → 77,6
 /** Buffer holding all arguments */
 static char *arg_buf = NULL;
-static elf_info_t prog_info;
-static elf_info_t interp_info;
-static bool is_dyn_linked;
-static void loader_get_taskid(ipc_callid_t rid, ipc_call_t *request)
-{
-    ipc_callid_t callid;
-    task_id_t task_id;
-    size_t len;
-    task_id = task_get_id();
-    if (!ipc_data_read_receive(&callid, &len)) {
-        ipc_answer_0(callid, EINVAL);
-        ipc_answer_0(rid, EINVAL);
-        return;
-    }
-    if (len > sizeof(task_id)) len = sizeof(task_id);
-    ipc_data_read_finalize(callid, &task_id, len);
-    ipc_answer_0(rid, EOK);
-}
 /** Receive a call setting pathname of the program to execute.
  *
  * @param rid
 ,16 → 191,20
     argv[n] = NULL;
 }
-/** Load the previously selected program.
+/** Load and run the previously selected program.
  *
  * @param rid
  * @param request
  * @return 0 on success, !0 on error.
  */
-static int loader_load(ipc_callid_t rid, ipc_call_t *request)
+static int loader_run(ipc_callid_t rid, ipc_call_t *request)
 {
     int rc;
+    elf_info_t prog_info;
+    elf_info_t interp_info;
 //  printf("Load program '%s'\n", pathname);
     rc = elf_load_file(pathname, 0, &prog_info);
 ,8 → 224,9
         /* Statically linked program */
 //      printf("Run statically linked program\n");
 //      printf("entry point: 0x%llx\n", prog_info.entry);
-        is_dyn_linked = false;
         ipc_answer_0(rid, EOK);
+        close_console();
+        elf_run(&prog_info, &pcb);
         return 0;
     }
 ,40 → 244,17
     pcb.rtld_dynamic = interp_info.dynamic;
     pcb.rtld_bias = RTLD_BIAS;
-    is_dyn_linked = true;
+    printf("run dynamic linker\n");
+    printf("entry point: 0x%llx\n", interp_info.entry);
+    close_console();
     ipc_answer_0(rid, EOK);
+    elf_run(&interp_info, &pcb);
+    /* Not reached */
     return 0;
 }
-/** Run the previously loaded program.
- *
- * @param rid
- * @param request
- * @return 0 on success, !0 on error.
- */
-static void loader_run(ipc_callid_t rid, ipc_call_t *request)
-{
-    if (is_dyn_linked == true) {
-        /* Dynamically linked program */
-        printf("run dynamic linker\n");
-        printf("entry point: 0x%llx\n", interp_info.entry);
-        close_console();
-        ipc_answer_0(rid, EOK);
-        elf_run(&interp_info, &pcb);
-    } else {
-        /* Statically linked program */
-        close_console();
-        ipc_answer_0(rid, EOK);
-        elf_run(&prog_info, &pcb);
-    }
-    /* Not reached */
-}
 /** Handle loader connection.
  *
  * Receive and carry out commands (of which the last one should be
 ,23 → 271,18
     while (1) {
         callid = async_get_call(&call);
+//      printf("received call from phone %d, method=%d\n",
+//          call.in_phone_hash, IPC_GET_METHOD(call));
         switch (IPC_GET_METHOD(call)) {
-        case LOADER_GET_TASKID:
-            loader_get_taskid(callid, &call);
-            continue;
         case LOADER_SET_PATHNAME:
             loader_set_pathname(callid, &call);
             continue;
         case LOADER_SET_ARGS:
             loader_set_args(callid, &call);
-            continue;
-        case LOADER_LOAD:
-            loader_load(callid, &call);
-            continue;
         case LOADER_RUN:
             loader_run(callid, &call);
-            /* Not reached */
+            exit(0);
+            continue;
         default:
             retval = ENOENT;
             break;

/branches/sparc/uspace/Makefile
48,7 → 48,6
srv/devmap \
app/tetris \
app/tester \
app/trace \
app/klog \
app/init \
app/bdsh

/branches/sparc/uspace/dist/etc/inittab
--- boot/boot.config (revision 3492)
+++ boot/boot.config (revision 3489)
@@ -84,7 +84,4 @@
! RDFMT (choice)

# Preserve A.OUT header in isofs.b
-! [ARCH=sparc64] CONFIG_AOUT_ISOFS_B (y/n)
-
-# External ramdisk
-! [ARCH=sparc64] CONFIG_RD_EXTERNAL (y/n)
+! [ARCH=sparc64] CONFIG_AOUT_ISOFS_B (y/n)
\ No newline at end of file

 /branches/sparc/boot/arch/sparc64/Makefile.inc
 ,7 → 26,7
 # THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #
-TMP = distroot
+TMP=distroot
 ifeq ($(CONFIG_AOUT_ISOFS_B),n)
     SILO_PACKAGE=silo.patched.tar.gz
 ,23 → 38,13
 build: $(BASE)/image.iso
-ifeq ($(CONFIG_RD_EXTERNAL),y)
-SILO_CONF_FILTER = cat
-else
-SILO_CONF_FILTER = grep -v initrd
-endif
 $(BASE)/image.iso: depend arch/$(ARCH)/loader/image.boot
     mkdir -p $(TMP)/boot
     mkdir -p $(TMP)/HelenOS
     cat arch/$(ARCH)/silo/$(SILO_PACKAGE) | (cd $(TMP)/boot; tar xvfz -)
-    cp arch/$(ARCH)/silo/README arch/$(ARCH)/silo/COPYING $(TMP)/boot
-    cat arch/$(ARCH)/silo/silo.conf | $(SILO_CONF_FILTER) >$(TMP)/boot/silo.conf
+    cp arch/$(ARCH)/silo/README arch/$(ARCH)/silo/COPYING arch/$(ARCH)/silo/silo.conf $(TMP)/boot
     cp arch/$(ARCH)/loader/image.boot $(TMP)/HelenOS/image.boot
     gzip -f $(TMP)/HelenOS/image.boot
-ifeq ($(CONFIG_RD_EXTERNAL),y)
-    cp arch/$(ARCH)/loader/initrd.img $(TMP)/HelenOS/initrd.img
-endif
     mkisofs -f -G $(TMP)/boot/isofs.b -B ... -r -o $(BASE)/image.iso $(TMP)/
 depend:

 /branches/sparc/boot/arch/sparc64/loader/main.c
 ,7 → 36,6
 #include <ofw_tree.h>
 #include "ofwarch.h"
 #include <align.h>
-#include <string.h>
 bootinfo_t bootinfo;
 component_t components[COMPONENTS];
 ,11 → 64,6
 void bootstrap(void)
 {
-    void *base = (void *) KERNEL_VIRTUAL_ADDRESS;
-    void *balloc_base;
-    unsigned int top = 0;
-    int i, j;
     version_print();
     init_components(components);
 ,13 → 91,6
     if (silo_ramdisk_image) {
         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),
-            silo_ramdisk_size, -1) != 0) {
-            printf("Failed to map ramdisk.\n");
-            halt();
-        }
     }
     printf("\nSystem info\n");
 ,68 → 101,20
     printf(" kernel entry point at %P\n", KERNEL_VIRTUAL_ADDRESS);
     printf(" %P: boot info structure\n", &bootinfo);
-    /*
-     * Figure out destination address for each component.
-     * In this phase, we don't copy the components yet because we want to
-     * to be careful not to overwrite anything, especially the components
-     * which haven't been copied yet.
-     */
-    bootinfo.taskmap.count = 0;
-    for (i = 0; i < COMPONENTS; i++) {
+    unsigned int i;
+    for (i = 0; i < COMPONENTS; i++)
         printf(" %P: %s image (size %d bytes)\n", components[i].start,
             components[i].name, components[i].size);
-        top = ALIGN_UP(top, PAGE_SIZE);
-        if (i > 0) {
-            if (bootinfo.taskmap.count == TASKMAP_MAX_RECORDS) {
-                printf("Skipping superfluous components.\n");
-                break;
-            }
-            bootinfo.taskmap.tasks[bootinfo.taskmap.count].addr =
-                base + top;
-            bootinfo.taskmap.tasks[bootinfo.taskmap.count].size =
-                components[i].size;
-            bootinfo.taskmap.count++;
-        }
-        top += components[i].size;
-    }
-    j = bootinfo.taskmap.count - 1; /* do not consider ramdisk */
+    void * base = (void *) KERNEL_VIRTUAL_ADDRESS;
+    unsigned int top = 0;
-    if (silo_ramdisk_image) {
-        /* Treat the ramdisk as the last bootinfo task. */
-        if (bootinfo.taskmap.count == TASKMAP_MAX_RECORDS) {
-            printf("Skipping ramdisk.\n");
-            goto skip_ramdisk;
-        }
+    printf("\nCopying components\n");
+    bootinfo.taskmap.count = 0;
+    for (i = 0; i < COMPONENTS; i++) {
+        printf(" %s...", components[i].name);
         top = ALIGN_UP(top, PAGE_SIZE);
-        bootinfo.taskmap.tasks[bootinfo.taskmap.count].addr =
-            base + top;
-        bootinfo.taskmap.tasks[bootinfo.taskmap.count].size =
-            silo_ramdisk_size;
-        bootinfo.taskmap.count++;
-        printf("\nCopying ramdisk...");
-        /*
-         * Claim and map the whole ramdisk as it may exceed the area
-         * 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);
-        memmove(base + top, (void *)((uintptr_t)silo_ramdisk_image),
-            silo_ramdisk_size);
-        printf("done.\n");
-        top += silo_ramdisk_size;
-    }
-skip_ramdisk:
-    /*
-     * Now we can proceed to copy the components. We do it in reverse order
-     * so that we don't overwrite anything even if the components overlap
-     * with base.
-     */
-    printf("\nCopying bootinfo tasks\n");
-    for (i = COMPONENTS - 1; i > 0; i--, j--) {
-        printf(" %s...", components[i].name);
         /*
          * At this point, we claim the physical memory that we are
          * going to use. We should be safe in case of the virtual
 ,34 → 122,30
          * SPARC binding, should restrict its use of virtual memory
          * to addresses from [0xffd00000; 0xffefffff] and
          * [0xfe000000; 0xfeffffff].
-         *
-         * XXX We don't map this piece of memory. We simply rely on
-         *     SILO to have it done for us already in this case.
          */
-        (void) ofw_claim_phys(bootinfo.physmem_start +
-            bootinfo.taskmap.tasks[j].addr,
+        (void) ofw_claim_phys(bootinfo.physmem_start + base + top,
             ALIGN_UP(components[i].size, PAGE_SIZE));
-        memcpy((void *)bootinfo.taskmap.tasks[j].addr,
-            components[i].start, components[i].size);
+        memcpy(base + top, components[i].start, components[i].size);
+        if (i > 0) {
+            bootinfo.taskmap.tasks[bootinfo.taskmap.count].addr =
+                base + top;
+            bootinfo.taskmap.tasks[bootinfo.taskmap.count].size =
+                components[i].size;
+            bootinfo.taskmap.count++;
+        }
+        top += components[i].size;
         printf("done.\n");
     }
-    printf("\nCopying kernel...");
-    (void) ofw_claim_phys(bootinfo.physmem_start + base,
-        ALIGN_UP(components[0].size, PAGE_SIZE));
-    memcpy(base, components[0].start, components[0].size);
-    printf("done.\n");
     /*
-     * Claim and map the physical memory for the boot allocator.
+     * Claim the physical memory for the boot allocator.
      * Initialize the boot allocator.
      */
-    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);
-    balloc_init(&bootinfo.ballocs, (uintptr_t)balloc_base);
+    (void) ofw_claim_phys(bootinfo.physmem_start +
+        base + ALIGN_UP(top, PAGE_SIZE), BALLOC_MAX_SIZE);
+    balloc_init(&bootinfo.ballocs, ALIGN_UP(((uintptr_t) base) + top,
+        PAGE_SIZE));
     printf("\nCanonizing OpenFirmware device tree...");
     bootinfo.ofw_root = ofw_tree_build();

 /branches/sparc/boot/arch/sparc64/loader/Makefile
 ,7 → 57,7
     OBJDUMP = $(TOOLCHAIN_DIR)/$(TARGET)-objdump
 endif
-CFLAGS = -DRELEASE=\"$(RELEASE)\" -I. -I../../../generic -I../../../genarch -nostdinc -nostdlib -fno-builtin -Werror-implicit-function-declaration -Wmissing-prototypes -Werror -O3 -mcpu=ultrasparc -m64 -mno-fpu -pipe
+CFLAGS = -DRELEASE=\"$(RELEASE)\" -I. -I../../../generic -I../../../genarch -nostdinc -nostdlib -fno-builtin -Werror-implicit-function-declaration -Wmissing-prototypes -Werror -O3 -mcpu=ultrasparc -m64
 ifdef REVISION
     CFLAGS += "-DREVISION=\"$(REVISION)\""
 ,9 → 79,6
     asm.S \
     boot.S
-#
-# All components that go to image.boot without the ramdisk.
-#
 COMPONENTS = \
     $(KERNELDIR)/kernel.bin \
     $(USPACEDIR)/srv/ns/ns \
 ,30 → 94,19
     COMPONENTS += $(USPACEDIR)/srv/fs/fat/fat
 endif
-#
-# Final list of all components that go to image.boot.
-#
-ALL_COMPONENTS = $(COMPONENTS)
-ifeq ($(CONFIG_RD_EXTERNAL),n)
-    ALL_COMPONENTS += ./initrd.img
-endif
-RD_SRVS = \
+RD_TASKS = \
     $(USPACEDIR)/srv/fb/fb \
     $(USPACEDIR)/srv/kbd/kbd \
     $(USPACEDIR)/srv/console/console \
     $(USPACEDIR)/srv/fs/tmpfs/tmpfs \
-    $(USPACEDIR)/srv/fs/fat/fat
-RD_APPS = \
+    $(USPACEDIR)/srv/fs/fat/fat \
     $(USPACEDIR)/app/tetris/tetris \
     $(USPACEDIR)/app/tester/tester \
-    $(USPACEDIR)/app/trace/trace \
     $(USPACEDIR)/app/bdsh/bdsh \
     $(USPACEDIR)/app/klog/klog
 OBJECTS := $(addsuffix .o,$(basename $(SOURCES)))
-ALL_COMPONENT_OBJECTS := $(addsuffix .o,$(basename $(notdir $(ALL_COMPONENTS))))
+COMPONENT_OBJECTS := $(addsuffix .o,$(basename $(notdir $(COMPONENTS))))
 .PHONY: all clean depend
 ,28 → 114,22
 -include Makefile.depend
-image.boot: depend _components.h _link.ld $(ALL_COMPONENT_OBJECTS) $(OBJECTS)
-    $(LD) -Map image.map -no-check-sections -N -T _link.ld $(ALL_COMPONENT_OBJECTS) $(OBJECTS) -o $@
+image.boot: depend _components.h _link.ld $(COMPONENT_OBJECTS) initrd.o $(OBJECTS)
+    $(LD) -Map image.map -no-check-sections -N -T _link.ld $(COMPONENT_OBJECTS) initrd.o $(OBJECTS) -o $@
 depend:
-    -makedepend -f - -- $(DEFS) $(CFLAGS) -- $(SOURCES) > Makefile.depend 2> /dev/null
+    -makedepend $(DEFS) $(CFLAGS) -f - $(SOURCES) > Makefile.depend 2> /dev/null
 clean:
-    -for file in $(RD_SRVS) ; do \
-        rm -f $(USPACEDIR)/dist/srv/`basename $$file` ; \
+    -for task in $(RD_TASKS) ; do \
+        rm -f $(USPACEDIR)/dist/sbin/`basename $$task` ; \
     done
-    -for file in $(RD_APPS) ; do \
-        rm -f $(USPACEDIR)/dist/app/`basename $$file` ; \
-    done
-    -rm -f _components.h _components.c _link.ld $(ALL_COMPONENT_OBJECTS) $(OBJECTS) initrd.img image.boot image.map image.disasm Makefile.depend
+    -rm -f _components.h _components.c _link.ld $(COMPONENT_OBJECTS) initrd.o $(OBJECTS) initrd.img image.boot image.map image.disasm Makefile.depend
-_components.h _components.c _link.ld $(ALL_COMPONENT_OBJECTS): $(COMPONENTS) $(RD_SRVS) $(RD_APPS) _link.ld.in
-    for file in $(RD_SRVS) ; do \
-        cp $$file $(USPACEDIR)/dist/srv/ ; \
+_components.h _components.c _link.ld $(COMPONENT_OBJECTS) initrd.o: $(COMPONENTS) $(RD_TASKS) _link.ld.in
+    for task in $(RD_TASKS) ; do \
+        cp $$task $(USPACEDIR)/dist/sbin/ ; \
     done
-    for file in $(RD_APPS) ; do \
-        cp $$file $(USPACEDIR)/dist/app/ ; \
-    done
 ifeq ($(RDFMT),tmpfs)
     ../../../../tools/mktmpfs.py $(USPACEDIR)/dist/ initrd.fs
 endif
 ,7 → 138,7
 endif
     ../../../../tools/mkhord.py 16384 initrd.fs initrd.img
     rm initrd.fs
-    ../../../tools/pack.py $(OBJCOPY) $(BFD_NAME) $(BFD_ARCH) 1 "unsigned long" $(ALL_COMPONENTS)
+    ../../../tools/pack.py $(OBJCOPY) $(BFD_NAME) $(BFD_ARCH) 1 "unsigned long" $(COMPONENTS) ./initrd.img
 %.o: %.S
     $(CC) $(DEFS) $(CFLAGS) -D__ASM__ -c $< -o $@

/branches/sparc/boot/arch/sparc64/silo/silo.conf
1,4 → 1,3
timeout = 0
image = /HelenOS/image.boot.gz
label = HelenOS
initrd = /HelenOS/initrd.img

 /branches/sparc/boot/arch/ppc32/loader/Makefile
 ,7 → 57,7
     OBJDUMP = $(TOOLCHAIN_DIR)/$(TARGET)-objdump
 endif
-CFLAGS = -DRELEASE=\"$(RELEASE)\" -I. -I../../../generic -I../../../genarch -nostdinc -nostdlib -fno-builtin -Werror-implicit-function-declaration -Wmissing-prototypes -Werror -O3 -mcpu=powerpc -msoft-float -m32 -pipe
+CFLAGS = -DRELEASE=\"$(RELEASE)\" -I. -I../../../generic -I../../../genarch -nostdinc -nostdlib -fno-builtin -Werror-implicit-function-declaration -Wmissing-prototypes -Werror -O3 -mcpu=powerpc -msoft-float -m32
 ifdef REVISION
     CFLAGS += "-DREVISION=\"$(REVISION)\""
 ,17 → 91,14
     COMPONENTS += $(USPACEDIR)/srv/fs/fat/fat
 endif
-RD_SRVS = \
+RD_TASKS = \
     $(USPACEDIR)/srv/fb/fb \
     $(USPACEDIR)/srv/kbd/kbd \
     $(USPACEDIR)/srv/console/console \
     $(USPACEDIR)/srv/fs/tmpfs/tmpfs \
-    $(USPACEDIR)/srv/fs/fat/fat
-RD_APPS = \
+    $(USPACEDIR)/srv/fs/fat/fat \
     $(USPACEDIR)/app/tetris/tetris \
     $(USPACEDIR)/app/tester/tester \
-    $(USPACEDIR)/app/trace/trace \
     $(USPACEDIR)/app/klog/klog \
     $(USPACEDIR)/app/bdsh/bdsh
 ,24 → 115,18
     $(LD) -no-check-sections -N -T _link.ld $(COMPONENT_OBJECTS) initrd.o $(OBJECTS) -o $@
 depend:
-    -makedepend -f - -- $(DEFS) $(CFLAGS) -- $(SOURCES) > Makefile.depend 2> /dev/null
+    -makedepend $(DEFS) $(CFLAGS) -f - $(SOURCES) > Makefile.depend 2> /dev/null
 clean:
-    -for file in $(RD_SRVS) ; do \
-        rm -f $(USPACEDIR)/dist/srv/`basename $$file` ; \
+    -for task in $(RD_TASKS) ; do \
+        rm -f $(USPACEDIR)/dist/sbin/`basename $$task` ; \
     done
-    -for file in $(RD_APPS) ; do \
-        rm -f $(USPACEDIR)/dist/app/`basename $$file` ; \
-    done
     -rm -f _components.h _components.c _link.ld $(COMPONENT_OBJECTS) initrd.o $(OBJECTS) initrd.img image.boot Makefile.depend
-_components.h _components.c _link.ld $(COMPONENT_OBJECTS) initrd.o: $(COMPONENTS) $(RD_SRVS) $(RD_APPS) _link.ld.in
-    for file in $(RD_SRVS) ; do \
-        cp $$file $(USPACEDIR)/dist/srv/ ; \
+_components.h _components.c _link.ld $(COMPONENT_OBJECTS) initrd.o: $(COMPONENTS) $(RD_TASKS) _link.ld.in
+    for task in $(RD_TASKS) ; do \
+        cp $$task $(USPACEDIR)/dist/sbin/ ; \
     done
-    for file in $(RD_APPS) ; do \
-        cp $$file $(USPACEDIR)/dist/app/ ; \
-    done
 ifeq ($(RDFMT),tmpfs)
     ../../../../tools/mktmpfs.py $(USPACEDIR)/dist/ initrd.fs
 endif

 /branches/sparc/boot/arch/ppc64/loader/Makefile
 ,7 → 57,7
     OBJDUMP = $(TOOLCHAIN_DIR)/$(TARGET)-objdump
 endif
-CFLAGS = -DRELEASE=\"$(RELEASE)\" -I. -I../../../generic -I../../../genarch -nostdinc -nostdlib -fno-builtin -Werror-implicit-function-declaration -Wmissing-prototypes -Werror -O3 -mcpu=powerpc64 -msoft-float -m64 -pipe
+CFLAGS = -DRELEASE=\"$(RELEASE)\" -I. -I../../../generic -I../../../genarch -nostdinc -nostdlib -fno-builtin -Werror-implicit-function-declaration -Wmissing-prototypes -Werror -O3 -mcpu=powerpc64 -msoft-float -m64
 ifdef REVISION
     CFLAGS += "-DREVISION=\"$(REVISION)\""
 ,7 → 89,6
     $(USPACEDIR)/app/init/init \
     $(USPACEDIR)/app/tetris/tetris \
     $(USPACEDIR)/app/tester/tester \
-    $(USPACEDIR)/app/trace/trace \
     $(USPACEDIR)/app/klog/klog
 OBJECTS := $(addsuffix .o,$(basename $(SOURCES)))
 ,7 → 104,7
     $(LD) -no-check-sections -N -T _link.ld $(COMPONENT_OBJECTS) $(OBJECTS) -o $@
 depend:
-    -makedepend -f - -- $(DEFS) $(CFLAGS) -- $(SOURCES) > Makefile.depend 2> /dev/null
+    -makedepend $(DEFS) $(CFLAGS) -f - $(SOURCES) > Makefile.depend 2> /dev/null
 clean:
     -rm -f _components.h _components.c _link.ld $(COMPONENT_OBJECTS) $(OBJECTS) image.boot Makefile.depend

 /branches/sparc/boot/arch/ia64/loader/Makefile
 ,7 → 68,7
 endif
 #-mno-pic means do not use gp + imm22 to address data
-CFLAGS = -DRELEASE=\"$(RELEASE)\" -I. -I../../../generic -I../../../genarch -I../../../../kernel/generic/include -nostdinc -nostdlib -fno-builtin -Werror-implicit-function-declaration -Wmissing-prototypes -Werror -O3 -fno-unwind-tables -mfixed-range=f32-f127 -mno-pic -pipe
+CFLAGS = -DRELEASE=\"$(RELEASE)\" -I. -I../../../generic -I../../../genarch -I../../../../kernel/generic/include -nostdinc -nostdlib -fno-builtin -Werror-implicit-function-declaration -Wmissing-prototypes -Werror -O3 -fno-unwind-tables -mfixed-range=f32-f127 -mno-pic
 ifdef REVISION
     CFLAGS += "-DREVISION=\"$(REVISION)\""
 ,7 → 101,6
     $(USPACEDIR)/app/init/init \
     $(USPACEDIR)/app/tetris/tetris \
     $(USPACEDIR)/app/tester/tester \
-    $(USPACEDIR)/app/trace/trace \
     $(USPACEDIR)/app/klog/klog
 OBJECTS := $(addsuffix .o,$(basename $(SOURCES)))
 ,7 → 122,7
     $(LD) -Map image.map -no-check-sections -N -T _link.ld $(COMPONENT_OBJECTS) $(OBJECTS) -o $@
 depend:
-    -makedepend -f - -- $(DEFS) $(CFLAGS) -- $(SOURCES) > Makefile.depend 2> /dev/null
+    -makedepend $(DEFS) $(CFLAGS) -f - $(SOURCES) > Makefile.depend 2> /dev/null
 clean:
     -rm -f _components.h _components.c _link.ld $(COMPONENT_OBJECTS) $(OBJECTS) image.boot image.map image.disasm Makefile.depend ../../../../image.bin ../../../../hello.efi

 /branches/sparc/boot/arch/arm32/loader/Makefile
 ,7 → 57,7
     OBJDUMP = $(TOOLCHAIN_DIR)/$(TARGET)-objdump
 endif
-CFLAGS = -DRELEASE=\"$(RELEASE)\" -I. -I../../../generic -I../../.. -nostdinc -nostdlib -fno-builtin -Werror-implicit-function-declaration -Wmissing-prototypes -Werror -O3 -pipe
+CFLAGS = -DRELEASE=\"$(RELEASE)\" -I. -I../../../generic -I../../.. -nostdinc -nostdlib -fno-builtin -Werror-implicit-function-declaration -Wmissing-prototypes -Werror -O3
 ifdef REVISION
     CFLAGS += "-DREVISION=\"$(REVISION)\""
 ,17 → 96,14
     COMPONENTS += $(USPACEDIR)/srv/fs/fat/fat
 endif
-RD_SRVS = \
+RD_TASKS = \
     $(USPACEDIR)/srv/fb/fb \
     $(USPACEDIR)/srv/kbd/kbd \
     $(USPACEDIR)/srv/console/console \
     $(USPACEDIR)/srv/fs/tmpfs/tmpfs \
-    $(USPACEDIR)/srv/fs/fat/fat
-RD_APPS = \
+    $(USPACEDIR)/srv/fs/fat/fat \
     $(USPACEDIR)/app/tetris/tetris \
     $(USPACEDIR)/app/tester/tester \
-    $(USPACEDIR)/app/trace/trace \
     $(USPACEDIR)/app/klog/klog \
     $(USPACEDIR)/app/bdsh/bdsh
 ,24 → 120,18
     $(LD) -no-check-sections -N -T _link.ld $(COMPONENT_OBJECTS) initrd.o $(OBJECTS) -o $@
 depend:
-    -makedepend -f - -- $(DEFS) $(CFLAGS) -- $(SOURCES) > Makefile.depend 2> /dev/null
+    -makedepend $(DEFS) $(CFLAGS) -f - $(SOURCES) > Makefile.depend 2> /dev/null
 clean:
-    -for file in $(RD_SRVS) ; do \
-        rm -f $(USPACEDIR)/dist/srv/`basename $$file` ; \
+    -for task in $(RD_TASKS) ; do \
+        rm -f $(USPACEDIR)/dist/sbin/`basename $$task` ; \
     done
-    -for file in $(RD_APPS) ; do \
-        rm -f $(USPACEDIR)/dist/app/`basename $$file` ; \
-    done
     -rm -f _components.h _components.c _link.ld $(COMPONENT_OBJECTS) initrd.o $(OBJECTS) initrd.img image.boot Makefile.depend
-_components.h _components.c _link.ld $(COMPONENT_OBJECTS) initrd.o: $(COMPONENTS) $(RD_SRVS) $(RD_APPS) _link.ld.in
-    for file in $(RD_SRVS) ; do \
-        cp $$file $(USPACEDIR)/dist/srv/ ; \
+_components.h _components.c _link.ld $(COMPONENT_OBJECTS) initrd.o: $(COMPONENTS) _link.ld.in
+    for task in $(RD_TASKS) ; do \
+        cp $$task $(USPACEDIR)/dist/sbin/ ; \
     done
-    for file in $(RD_APPS) ; do \
-        cp $$file $(USPACEDIR)/dist/app/ ; \
-    done
 ifeq ($(RDFMT),tmpfs)
     ../../../../tools/mktmpfs.py $(USPACEDIR)/dist/ initrd.fs
 endif

 /branches/sparc/boot/arch/amd64/Makefile.inc
 ,24 → 40,21
     INIT_TASKS += $(USPACEDIR)/srv/fs/fat/fat
 endif
-RD_SRVS = \
+RD_TASKS = \
     $(USPACEDIR)/srv/pci/pci \
     $(USPACEDIR)/srv/fb/fb \
     $(USPACEDIR)/srv/kbd/kbd \
     $(USPACEDIR)/srv/console/console \
-    $(USPACEDIR)/srv/fs/tmpfs/tmpfs \
-    $(USPACEDIR)/srv/fs/fat/fat
-RD_APPS = \
     $(USPACEDIR)/app/tetris/tetris \
     $(USPACEDIR)/app/tester/tester \
-    $(USPACEDIR)/app/trace/trace \
     $(USPACEDIR)/app/klog/klog \
-    $(USPACEDIR)/app/bdsh/bdsh
+    $(USPACEDIR)/app/bdsh/bdsh \
+    $(USPACEDIR)/srv/fs/tmpfs/tmpfs \
+    $(USPACEDIR)/srv/fs/fat/fat
 build: $(BASE)/image.iso
-$(BASE)/image.iso: arch/$(ARCH)/grub/stage2_eltorito arch/$(ARCH)/grub/menu.lst $(KERNELDIR)/kernel.bin $(INIT_TASKS) $(RD_SRVS) $(RD_APPS)
+$(BASE)/image.iso: arch/$(ARCH)/grub/stage2_eltorito arch/$(ARCH)/grub/menu.lst $(KERNELDIR)/kernel.bin $(INIT_TASKS) $(RD_TASKS)
     mkdir -p arch/$(ARCH)/iso/boot/grub
     cp arch/$(ARCH)/grub/stage2_eltorito arch/$(ARCH)/iso/boot/grub/
 ifneq ($(RDFMT),tmpfs)
 ,12 → 67,9
     for task in $(INIT_TASKS) ; do \
         cp $$task arch/$(ARCH)/iso/boot/ ; \
     done
-    for file in $(RD_SRVS) ; do \
-        cp $$file $(USPACEDIR)/dist/srv/ ; \
+    for task in $(RD_TASKS) ; do \
+        cp $$task $(USPACEDIR)/dist/sbin/ ; \
     done
-    for file in $(RD_APPS) ; do \
-        cp $$file $(USPACEDIR)/dist/app/ ; \
-    done
 ifeq ($(RDFMT),tmpfs)
     $(BASE)/tools/mktmpfs.py $(USPACEDIR)/dist/ arch/$(ARCH)/iso/boot/initrd.fs
 endif
 ,11 → 81,8
     mkisofs -J -r -b boot/grub/stage2_eltorito -no-emul-boot -boot-load-size 4 -boot-info-table -o $(BASE)/image.iso arch/$(ARCH)/iso/
 clean:
-    -for file in $(RD_SRVS) ; do \
-        rm -f $(USPACEDIR)/dist/srv/`basename $$file` ; \
+    -for task in $(RD_TASKS) ; do \
+        rm -f $(USPACEDIR)/dist/sbin/`basename $$task` ; \
     done
-    -for file in $(RD_APPS) ; do \
-        rm -f $(USPACEDIR)/dist/app/`basename $$file` ; \
-    done
     -rm -fr arch/$(ARCH)/iso
     -rm -f $(BASE)/image.iso

 /branches/sparc/boot/arch/mips32/loader/Makefile
 ,7 → 63,7
     OBJDUMP = $(TOOLCHAIN_DIR)/$(TARGET)-objdump
 endif
-CFLAGS = -DRELEASE=\"$(RELEASE)\" -I. -I../../../generic -nostdinc -nostdlib -fno-builtin -Werror-implicit-function-declaration -Wmissing-prototypes -Werror -O3 -mno-abicalls -G 0 -fno-zero-initialized-in-bss -mhard-float -mips3 -pipe
+CFLAGS = -DRELEASE=\"$(RELEASE)\" -I. -I../../../generic -nostdinc -nostdlib -fno-builtin -Werror-implicit-function-declaration -Wmissing-prototypes -Werror -O3 -mno-abicalls -G 0 -fno-zero-initialized-in-bss -mhard-float -mips3
 ifdef REVISION
     CFLAGS += "-DREVISION=\"$(REVISION)\""
 ,20 → 96,18
     COMPONENTS += $(USPACEDIR)/srv/fs/fat/fat
 endif
-RD_SRVS = \
+RD_TASKS = \
     $(USPACEDIR)/srv/fb/fb \
     $(USPACEDIR)/srv/kbd/kbd \
     $(USPACEDIR)/srv/console/console \
     $(USPACEDIR)/srv/fs/tmpfs/tmpfs \
-    $(USPACEDIR)/srv/fs/fat/fat
-RD_APPS = \
+    $(USPACEDIR)/srv/fs/fat/fat \
     $(USPACEDIR)/app/tetris/tetris \
     $(USPACEDIR)/app/tester/tester \
-    $(USPACEDIR)/app/trace/trace \
     $(USPACEDIR)/app/bdsh/bdsh \
     $(USPACEDIR)/app/klog/klog
 OBJECTS := $(addsuffix .o,$(basename $(SOURCES)))
 COMPONENT_OBJECTS := $(addsuffix .o,$(basename $(notdir $(COMPONENTS))))
 ,24 → 121,18
     $(LD) -no-check-sections -N -T _link.ld $(COMPONENT_OBJECTS) initrd.o $(OBJECTS) -o $@
 depend:
-    -makedepend -f - -- $(DEFS) $(CFLAGS) -- $(SOURCES) > Makefile.depend 2> /dev/null
+    -makedepend $(DEFS) $(CFLAGS) -f - $(SOURCES) > Makefile.depend 2> /dev/null
 clean:
-    -for file in $(RD_SRVS) ; do \
-        rm -f $(USPACEDIR)/dist/srv/`basename $$file` ; \
+    -for task in $(RD_TASKS) ; do \
+        rm -f $(USPACEDIR)/dist/sbin/`basename $$task` ; \
     done
-    -for file in $(RD_APPS) ; do \
-        rm -f $(USPACEDIR)/dist/app/`basename $$file` ; \
-    done
     -rm -f _components.h _components.c _link.ld _link.ld.in $(COMPONENT_OBJECTS) initrd.o $(OBJECTS) initrd.img image.boot Makefile.depend
-_components.h _components.c _link.ld $(COMPONENT_OBJECTS) initrd.o: $(COMPONENTS) $(RD_SRVS) $(RD_APPS) _link.ld.in
-    for file in $(RD_SRVS) ; do \
-        cp $$file $(USPACEDIR)/dist/srv/ ; \
+_components.h _components.c _link.ld $(COMPONENT_OBJECTS) initrd.o: $(COMPONENTS) _link.ld.in
+    for task in $(RD_TASKS) ; do \
+        cp $$task $(USPACEDIR)/dist/sbin/ ; \
     done
-    for file in $(RD_APPS) ; do \
-        cp $$file $(USPACEDIR)/dist/app/ ; \
-    done
 ifeq ($(RDFMT),tmpfs)
     ../../../../tools/mktmpfs.py $(USPACEDIR)/dist/ initrd.fs
 endif

 /branches/sparc/boot/arch/ia32/Makefile.inc
 ,23 → 40,20
     INIT_TASKS += $(USPACEDIR)/srv/fs/fat/fat
 endif
-RD_SRVS = \
+RD_TASKS = \
     $(USPACEDIR)/srv/pci/pci \
     $(USPACEDIR)/srv/fb/fb \
     $(USPACEDIR)/srv/kbd/kbd \
     $(USPACEDIR)/srv/console/console \
-    $(USPACEDIR)/srv/fs/fat/fat
-RD_APPS = \
+    $(USPACEDIR)/srv/fs/fat/fat \
     $(USPACEDIR)/app/tetris/tetris \
     $(USPACEDIR)/app/tester/tester \
-    $(USPACEDIR)/app/trace/trace \
     $(USPACEDIR)/app/klog/klog \
     $(USPACEDIR)/app/bdsh/bdsh
 build: $(BASE)/image.iso
-$(BASE)/image.iso: arch/$(ARCH)/grub/stage2_eltorito arch/$(ARCH)/grub/menu.lst $(KERNELDIR)/kernel.bin $(INIT_TASKS) $(RD_SRVS) $(RD_APPS)
+$(BASE)/image.iso: arch/$(ARCH)/grub/stage2_eltorito arch/$(ARCH)/grub/menu.lst $(KERNELDIR)/kernel.bin $(INIT_TASKS) $(RD_TASKS)
     mkdir -p arch/$(ARCH)/iso/boot/grub
     cp arch/$(ARCH)/grub/stage2_eltorito arch/$(ARCH)/iso/boot/grub/
 ifneq ($(RDFMT),tmpfs)
 ,12 → 66,9
     for task in $(INIT_TASKS) ; do \
         cp $$task arch/$(ARCH)/iso/boot/ ; \
     done
-    for file in $(RD_SRVS) ; do \
-        cp $$file $(USPACEDIR)/dist/srv/ ; \
+    for task in $(RD_TASKS) ; do \
+        cp $$task $(USPACEDIR)/dist/sbin/ ; \
     done
-    for file in $(RD_APPS) ; do \
-        cp $$file $(USPACEDIR)/dist/app/ ; \
-    done
 ifeq ($(RDFMT),tmpfs)
     $(BASE)/tools/mktmpfs.py $(USPACEDIR)/dist/ arch/$(ARCH)/iso/boot/initrd.fs
 endif
 ,11 → 80,8
     mkisofs -J -r -b boot/grub/stage2_eltorito -no-emul-boot -boot-load-size 4 -boot-info-table -o $(BASE)/image.iso arch/$(ARCH)/iso/
 clean:
-    -for file in $(RD_SRVS) ; do \
-        rm -f $(USPACEDIR)/dist/srv/`basename $$file` ; \
+    -for task in $(RD_TASKS) ; do \
+        rm -f $(USPACEDIR)/dist/sbin/`basename $$task` ; \
     done
-    -for file in $(RD_APPS) ; do \
-        rm -f $(USPACEDIR)/dist/app/`basename $$file` ; \
-    done
     -rm -fr arch/$(ARCH)/iso
     -rm -f $(BASE)/image.iso

 /branches/sparc/boot/generic/string.c
 ,9 → 39,9
 /** Return number of characters in a string.
  *
- * @param str       NULL terminated string.
+ * @param str NULL terminated string.
  *
- * @return      Number of characters in str.
+ * @return Number of characters in str.
  */
 size_t strlen(const char *str)
 {
 ,17 → 53,16
     return i;
 }
-/** Compare two NULL terminated strings.
+/** Compare two NULL terminated strings
  *
  * Do a char-by-char comparison of two NULL terminated strings.
  * The strings are considered equal iff they consist of the same
  * characters on the minimum of their lengths.
  *
- * @param src       First string to compare.
- * @param dst       Second string to compare.
+ * @param src First string to compare.
+ * @param dst Second string to compare.
  *
- * @return      0 if the strings are equal, -1 if first is smaller,
- *          1 if second smaller.
+ * @return 0 if the strings are equal, -1 if first is smaller, 1 if second smaller.
  *
  */
 int strcmp(const char *src, const char *dst)
 ,7 → 81,7
 }
-/** Compare two NULL terminated strings.
+/** Compare two NULL terminated strings
  *
  * Do a char-by-char comparison of two NULL terminated strings.
  * The strings are considered equal iff they consist of the same
 ,12 → 88,11
  * characters on the minimum of their lengths and specified maximal
  * length.
  *
- * @param src       First string to compare.
- * @param dst       Second string to compare.
- * @param len       Maximal length for comparison.
+ * @param src First string to compare.
+ * @param dst Second string to compare.
+ * @param len Maximal length for comparison.
  *
- * @return      0 if the strings are equal, -1 if first is smaller,
- *          1 if second smaller.
+ * @return 0 if the strings are equal, -1 if first is smaller, 1 if second smaller.
  *
  */
 int strncmp(const char *src, const char *dst, size_t len)
 ,9 → 118,9
  * If 'src' is shorter than 'len', '\0' is inserted behind the
  * last copied character.
  *
- * @param src       Source string.
- * @param dest      Destination buffer.
- * @param len       Size of destination buffer.
+ * @param src Source string.
+ * @param dest Destination buffer.
+ * @param len Size of destination buffer.
  */
 void strncpy(char *dest, const char *src, size_t len)
 {
 ,13 → 132,13
     dest[i-1] = '\0';
 }
-/** Convert ascii representation to unative_t.
+/** Convert ascii representation to unative_t
  *
  * Supports 0x for hexa & 0 for octal notation.
  * Does not check for overflows, does not support negative numbers
  *
- * @param text      Textual representation of number.
- * @return      Converted number or 0 if no valid number found.
+ * @param text Textual representation of number
+ * @return Converted number or 0 if no valid number ofund
  */
 unative_t atoi(const char *text)
 {
 ,9 → 152,9
         base = 8;
     while (*text) {
-        if (base != 16 &&
-            ((*text >= 'A' && *text <= 'F') ||
-            (*text >='a' && *text <='f')))
+        if (base != 16 && \
+            ((*text >= 'A' && *text <= 'F' )
+             || (*text >='a' && *text <='f')))
             break;
         if (base == 8 && *text >='8')
             break;
 ,28 → 176,5
     return result;
 }
-/** Move piece of memory to another, possibly overlapping, location.
- *
- * @param dst       Destination address.
- * @param src       Source address.
- * @param len       Number of bytes to move.
- *
- * @return      Destination address.
- */
-void *memmove(void *dst, const void *src, size_t len)
-{
-    char *d = dst;
-    const char *s = src;
-    if (s < d) {
-        while (len--)
-            *(d + len) = *(s + len);
-    } else {
-        while (len--)
-            *d++ = *s++;
-    }
-    return dst;
-}
 /** @}
  */

/branches/sparc/boot/generic/string.h
42,7 → 42,6
extern int strncmp(const char src, const char dst, size_t len);
extern void strncpy(char dest, const char src, size_t len);
extern unative_t atoi(const char *text);
extern void memmove(void dst, const void *src, size_t len);

#endif

Subversion Repositories HelenOS

Compare Revisions

Ignore whitespace Rev 3492 → Rev 3489