WebSVN – HelenOS – Path Comparison – / – /branches/network/uspace/lib Rev 3369 and /branches/network/uspace/lib Rev 3386

Ignore whitespace Rev 3369 → Rev 3386

 /branches/network/uspace/lib/libc/arch/ia64/Makefile.inc
 ,8 → 29,12
 ## Toolchain configuration
 #
+ifndef CROSS_PREFIX
+    CROSS_PREFIX = /usr/local
+endif
 TARGET = ia64-pc-linux-gnu
-TOOLCHAIN_DIR = /usr/local/ia64/bin
+TOOLCHAIN_DIR = $(CROSS_PREFIX)/ia64/bin
 CFLAGS += -fno-unwind-tables -DMALLOC_ALIGNMENT_16
 LFLAGS += -N $(SOFTINT_PREFIX)/libsoftint.a
 AFLAGS +=

 /branches/network/uspace/lib/libc/arch/ia64/include/config.h
 ,8 → 36,7
 #define LIBC_ia64_CONFIG_H_
 #define PAGE_WIDTH  14
-#define PAGE_SIZE   (1<<PAGE_WIDTH)
-#define PAGE_COLOR_BITS 0        /* dummy */
+#define PAGE_SIZE   (1 << PAGE_WIDTH)
 #endif

 /branches/network/uspace/lib/libc/arch/ia64/include/byteorder.h
 ,0 → 1,44
+/*
+ * Copyright (c) 2005 Jakub Jermar
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * - Redistributions of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * - Redistributions in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in the
+ *   documentation and/or other materials provided with the distribution.
+ * - The name of the author may not be used to endorse or promote products
+ *   derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+/** @addtogroup libcia64
+ * @{
+ */
+/** @file
+ */
+#ifndef LIBC_ia64_BYTEORDER_H_
+#define LIBC_ia64_BYTEORDER_H_
+/* IA-64 is little-endian */
+#define ARCH_IS_LITTLE_ENDIAN
+#endif
+/** @}
+ */

 /branches/network/uspace/lib/libc/arch/ia64/src/entry.s
 ,27 → 31,17
 .org 0
 .globl __entry
-.globl __entry_driver
 ## User-space task entry point
 #
+# r2 contains the PCB pointer
 #
 __entry:
     alloc loc0 = ar.pfs, 0, 1, 2, 0
-    mov r1 = _gp
-    br.call.sptk.many b0 = __main
-:
-    br.call.sptk.many b0 = __io_init
-:
-    br.call.sptk.many b0 = main
-:
-    br.call.sptk.many b0 = __exit
+    mov r1 = _gp
-__entry_driver:
-    alloc loc0 = ar.pfs, 0, 1, 2, 0
-    mov r1 = _gp
+    # Pass PCB pointer as the first argument to __main
+    mov out0 = r2
     br.call.sptk.many b0 = __main
 :
-    br.call.sptk.many b0 = main
-:
     br.call.sptk.many b0 = __exit

 /branches/network/uspace/lib/libc/arch/ia64/_link.ld.in
 ,9 → 7,9
 }
 SECTIONS {
-    . = 0x4000;
+    . = 0x4000 + SIZEOF_HEADERS;
-    .init ALIGN(0x4000): SUBALIGN(0x4000) {
+    .init : {
         *(.init);
     } : text
     .text : {
 ,7 → 17,9
         *(.rodata*);
     } :text
-    .got ALIGN(0x4000) : SUBALIGN(0x4000) {
+    . = . + 0x4000;
+    .got : {
         _gp = .;
         *(.got*);
     } :data

 /branches/network/uspace/lib/libc/arch/arm32/Makefile.inc
 ,8 → 30,12
 ## Toolchain configuration
 #
+ifndef CROSS_PREFIX
+    CROSS_PREFIX = /usr/local
+endif
 TARGET = arm-linux-gnu
-TOOLCHAIN_DIR = /usr/local/arm/bin
+TOOLCHAIN_DIR = $(CROSS_PREFIX)/arm/bin
 CFLAGS += -ffixed-r9 -mtp=soft
 LFLAGS += -N $(SOFTINT_PREFIX)/libsoftint.a
 AFLAGS +=

/branches/network/uspace/lib/libc/arch/arm32/include/config.h
38,7 → 38,6

#define PAGE_WIDTH 12
#define PAGE_SIZE (1 << PAGE_WIDTH)
#define PAGE_COLOR_BITS 0 /* dummy */

#endif

 /branches/network/uspace/lib/libc/arch/arm32/include/byteorder.h
 ,0 → 1,44
+/*
+ * Copyright (c) 2005 Jakub Jermar
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * - Redistributions of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * - Redistributions in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in the
+ *   documentation and/or other materials provided with the distribution.
+ * - The name of the author may not be used to endorse or promote products
+ *   derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+/** @addtogroup libcarm32
+ * @{
+ */
+/** @file
+ *  @brief Endianness definitions.
+ */
+#ifndef LIBC_arm32_BYTEORDER_H_
+#define LIBC_arm32_BYTEORDER_H_
+#define ARCH_IS_LITTLE_ENDIAN
+#endif
+/** @}
+ */

 /branches/network/uspace/lib/libc/arch/arm32/src/entry.s
 ,19 → 31,14
 .org 0
 .global __entry
-.global __entry_driver
 ## User-space task entry point
 #
+# r1 contains the PCB pointer
 #
 __entry:
+    # Pass pcb_ptr to __main as the first argument (in r0)
+    mov r0, r1
     bl __main
-    bl __io_init
-    bl main
-    bl __exit
-__entry_driver:
-    bl __main
-    bl main
     bl __exit

 /branches/network/uspace/lib/libc/arch/arm32/_link.ld.in
 ,9 → 7,9
 }
 SECTIONS {
-    . = 0x1000;
+    . = 0x1000 + SIZEOF_HEADERS;
-    .init ALIGN(0x1000): SUBALIGN(0x1000) {
+    .init : {
         *(.init);
     } : text
     .text : {
 ,8 → 16,10
         *(.text);
         *(.rodata*);
     } :text
-    .data ALIGN(0x1000) : SUBALIGN(0x1000) {
+    . = . + 0x1000;
+    .data : {
         *(.opd);
         *(.data .data.*);
         *(.sdata);

 /branches/network/uspace/lib/libc/arch/mips32eb/Makefile.inc
 ,8 → 29,12
 ## Toolchain configuration
 #
+ifndef CROSS_PREFIX
+    CROSS_PREFIX = /usr/local
+endif
 TARGET = mips-sgi-irix5
-TOOLCHAIN_DIR = /usr/local/mips/bin
+TOOLCHAIN_DIR = $(CROSS_PREFIX)/mips/bin
 CFLAGS += -mips3
 ARCH_SOURCES += arch/$(ARCH)/src/syscall.c \

/branches/network/uspace/lib/libc/arch/mips32eb/include/context_offset.h
File deleted
\ No newline at end of file
Property changes:
Deleted: svn:special
-*
\ No newline at end of property

 /branches/network/uspace/lib/libc/arch/mips32eb/include/byteorder.h
 ,0 → 1,43
+/*
+ * Copyright (c) 2005 Jakub Jermar
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * - Redistributions of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * - Redistributions in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in the
+ *   documentation and/or other materials provided with the distribution.
+ * - The name of the author may not be used to endorse or promote products
+ *   derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+/** @addtogroup libcmips32
+ * @{
+ */
+/** @file
+ */
+#ifndef LIBC_mips32eb_BYTEORDER_H_
+#define LIBC_mips32eb_BYTEORDER_H_
+#define ARCH_IS_BIG_ENDIAN
+#endif
+/** @}
+ */

 /branches/network/uspace/lib/libc/arch/ppc32/Makefile.inc
 ,8 → 29,12
 ## Toolchain configuration
 #
+ifndef CROSS_PREFIX
+    CROSS_PREFIX = /usr/local
+endif
 TARGET = ppc-linux-gnu
-TOOLCHAIN_DIR = /usr/local/ppc/bin
+TOOLCHAIN_DIR = $(CROSS_PREFIX)/ppc/bin
 ARCH_SOURCES += arch/$(ARCH)/src/syscall.c \
         arch/$(ARCH)/src/fibril.S \

 /branches/network/uspace/lib/libc/arch/ppc32/include/config.h
 ,8 → 36,7
 #define LIBC_ppc32_CONFIG_H_
 #define PAGE_WIDTH  12
-#define PAGE_SIZE   (1<<PAGE_WIDTH)
-#define PAGE_COLOR_BITS 0        /* dummy */
+#define PAGE_SIZE   (1 << PAGE_WIDTH)
 #endif

 /branches/network/uspace/lib/libc/arch/ppc32/include/byteorder.h
 ,0 → 1,43
+/*
+ * Copyright (c) 2005 Jakub Jermar
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * - Redistributions of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * - Redistributions in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in the
+ *   documentation and/or other materials provided with the distribution.
+ * - The name of the author may not be used to endorse or promote products
+ *   derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+/** @addtogroup libcppc32
+ * @{
+ */
+/** @file
+ */
+#ifndef LIBC_ppc32_BYTEORDER_H_
+#define LIBC_ppc32_BYTEORDER_H_
+#define ARCH_IS_BIG_ENDIAN
+#endif
+/** @}
+ */

 /branches/network/uspace/lib/libc/arch/ppc32/src/entry.s
 ,18 → 31,14
 .org 0
 .globl __entry
-.globl __entry_driver
 ## User-space task entry point
 #
+# r3 contains the PCB pointer
 #
 __entry:
+    # Pass the PCB pointer to __main() as the first argument.
+    # Since the first argument is passed in r3, no operation is needed.
     bl __main
-    bl __io_init
-    bl main
-    bl __exit
-__entry_driver:
-    bl __main
-    bl main
     bl __exit

 /branches/network/uspace/lib/libc/arch/ppc32/src/fibril.S
 ,58 → 32,10
 .global context_restore
 #include <libarch/regname.h>
-#include <libarch/context_offset.h>
+#include <arch/context_offset.h>
-.macro CONTEXT_STORE r
-    stw sp, OFFSET_SP(\r)
-    stw r2, OFFSET_R2(\r)
-    stw r13, OFFSET_R13(\r)
-    stw r14, OFFSET_R14(\r)
-    stw r15, OFFSET_R15(\r)
-    stw r16, OFFSET_R16(\r)
-    stw r17, OFFSET_R17(\r)
-    stw r18, OFFSET_R18(\r)
-    stw r19, OFFSET_R19(\r)
-    stw r20, OFFSET_R20(\r)
-    stw r21, OFFSET_R21(\r)
-    stw r22, OFFSET_R22(\r)
-    stw r23, OFFSET_R23(\r)
-    stw r24, OFFSET_R24(\r)
-    stw r25, OFFSET_R25(\r)
-    stw r26, OFFSET_R26(\r)
-    stw r27, OFFSET_R27(\r)
-    stw r28, OFFSET_R28(\r)
-    stw r29, OFFSET_R29(\r)
-    stw r30, OFFSET_R30(\r)
-    stw r31, OFFSET_R31(\r)
-.endm
-.macro CONTEXT_LOAD r
-    lwz sp, OFFSET_SP(\r)
-    lwz r2, OFFSET_R2(\r)
-    lwz r13, OFFSET_R13(\r)
-    lwz r14, OFFSET_R14(\r)
-    lwz r15, OFFSET_R15(\r)
-    lwz r16, OFFSET_R16(\r)
-    lwz r17, OFFSET_R17(\r)
-    lwz r18, OFFSET_R18(\r)
-    lwz r19, OFFSET_R19(\r)
-    lwz r20, OFFSET_R20(\r)
-    lwz r21, OFFSET_R21(\r)
-    lwz r22, OFFSET_R22(\r)
-    lwz r23, OFFSET_R23(\r)
-    lwz r24, OFFSET_R24(\r)
-    lwz r25, OFFSET_R25(\r)
-    lwz r26, OFFSET_R26(\r)
-    lwz r27, OFFSET_R27(\r)
-    lwz r28, OFFSET_R28(\r)
-    lwz r29, OFFSET_R29(\r)
-    lwz r30, OFFSET_R30(\r)
-    lwz r31, OFFSET_R31(\r)
-.endm
 context_save:
-    CONTEXT_STORE r3
+    CONTEXT_SAVE_ARCH_CORE r3
     mflr r4
     stw r4, OFFSET_PC(r3)
 ,7 → 49,7
 context_restore:
-    CONTEXT_LOAD r3
+    CONTEXT_RESTORE_ARCH_CORE r3
     lwz r4, OFFSET_CR(r3)
     mtcr r4

 /branches/network/uspace/lib/libc/arch/ppc32/_link.ld.in
 ,9 → 7,9
 }
 SECTIONS {
-    . = 0x1000;
+    . = 0x1000 + SIZEOF_HEADERS;
-    .init ALIGN(0x1000) : SUBALIGN(0x1000) {
+    .init : {
         *(.init);
     } :text
     .text : {
 ,8 → 16,10
         *(.text);
         *(.rodata*);
     } :text
-    .data ALIGN(0x1000) : SUBALIGN(0x1000) {
+    . = . + 0x1000;
+    .data : {
         *(.data);
         *(.sdata);
     } :data

 /branches/network/uspace/lib/libc/arch/amd64/Makefile.inc
 ,8 → 29,12
 ## Toolchain configuration
 #
+ifndef CROSS_PREFIX
+    CROSS_PREFIX = /usr/local
+endif
 TARGET = amd64-linux-gnu
-TOOLCHAIN_DIR = /usr/local/amd64/bin
+TOOLCHAIN_DIR = $(CROSS_PREFIX)/amd64/bin
 ARCH_SOURCES += arch/$(ARCH)/src/syscall.S \
         arch/$(ARCH)/src/fibril.S \

 /branches/network/uspace/lib/libc/arch/amd64/include/config.h
 ,8 → 36,7
 #define LIBC_amd64_CONFIG_H_
 #define PAGE_WIDTH  12
-#define PAGE_SIZE   (1<<PAGE_WIDTH)
-#define PAGE_COLOR_BITS 0        /* dummy */
+#define PAGE_SIZE   (1 << PAGE_WIDTH)
 #endif

 /branches/network/uspace/lib/libc/arch/amd64/include/atomic.h
 ,11 → 38,11
 #define LIBC_amd64_ATOMIC_H_
 static inline void atomic_inc(atomic_t *val) {
-    asm volatile ("lock incq %0\n" : "=m" (val->count));
+    asm volatile ("lock incq %0\n" : "+m" (val->count));
 }
 static inline void atomic_dec(atomic_t *val) {
-    asm volatile ("lock decq %0\n" : "=m" (val->count));
+    asm volatile ("lock decq %0\n" : "+m" (val->count));
 }
 static inline long atomic_postinc(atomic_t *val)
 ,7 → 52,7
     asm volatile (
         "movq $1, %0\n"
         "lock xaddq %0, %1\n"
-        : "=r" (r), "=m" (val->count)
+        : "=r" (r), "+m" (val->count)
     );
     return r;
 ,14 → 65,14
     asm volatile (
         "movq $-1, %0\n"
         "lock xaddq %0, %1\n"
-        : "=r" (r), "=m" (val->count)
+        : "=r" (r), "+m" (val->count)
     );
     return r;
 }
-#define atomic_preinc(val) (atomic_postinc(val)+1)
-#define atomic_predec(val) (atomic_postdec(val)-1)
+#define atomic_preinc(val) (atomic_postinc(val) + 1)
+#define atomic_predec(val) (atomic_postdec(val) - 1)
 #endif

 /branches/network/uspace/lib/libc/arch/amd64/include/byteorder.h
 ,0 → 1,44
+/*
+ * Copyright (c) 2005 Jakub Jermar
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * - Redistributions of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * - Redistributions in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in the
+ *   documentation and/or other materials provided with the distribution.
+ * - The name of the author may not be used to endorse or promote products
+ *   derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+/** @addtogroup libcamd64
+ * @{
+ */
+/** @file
+ */
+#ifndef LIBC_amd64_BYTEORDER_H_
+#define LIBC_amd64_BYTEORDER_H_
+/* AMD64 is little-endian */
+#define ARCH_IS_LITTLE_ENDIAN
+#endif
+/** @}
+ */

 /branches/network/uspace/lib/libc/arch/amd64/src/entry.s
 ,18 → 31,14
 .org 0
 .globl __entry
-.globl __entry_driver
 ## User-space task entry point
 #
+# %rdi contains the PCB pointer
 #
 __entry:
+    # %rdi was deliberately chosen as the first argument is also in %rdi
+    # Pass PCB pointer to __main (no operation)
     call __main
-    call __io_init
-    call main
-    call __exit
-__entry_driver:
-    call __main
-    call main
     call __exit

 /branches/network/uspace/lib/libc/arch/amd64/src/fibril.S
 ,7 → 31,7
 .global context_save
 .global context_restore
-#include <libarch/context_offset.h>
+#include <kernel/arch/context_offset.h>
 ## Save current CPU context
 #
 ,17 → 40,10
 #
 context_save:
     movq (%rsp), %rdx     # the caller's return %eip
     # In %edi is passed 1st argument
-    movq %rdx, OFFSET_PC(%rdi)
-    movq %rsp, OFFSET_SP(%rdi)
+    CONTEXT_SAVE_ARCH_CORE %rdi %rdx
-    movq %rbx, OFFSET_RBX(%rdi)
-    movq %rbp, OFFSET_RBP(%rdi)
-    movq %r12, OFFSET_R12(%rdi)
-    movq %r13, OFFSET_R13(%rdi)
-    movq %r14, OFFSET_R14(%rdi)
-    movq %r15, OFFSET_R15(%rdi)
     # Save TLS
     movq %fs:0, %rax
     movq %rax, OFFSET_TLS(%rdi)
 ,16 → 59,9
 # pointed by the 1st argument. Returns 0 in EAX.
 #
 context_restore:
-    movq OFFSET_R15(%rdi), %r15
-    movq OFFSET_R14(%rdi), %r14
-    movq OFFSET_R13(%rdi), %r13
-    movq OFFSET_R12(%rdi), %r12
-    movq OFFSET_RBP(%rdi), %rbp
-    movq OFFSET_RBX(%rdi), %rbx
-    movq OFFSET_SP(%rdi), %rsp   # ctx->sp -> %rsp
+    CONTEXT_RESTORE_ARCH_CORE %rdi %rdx
-    movq OFFSET_PC(%rdi), %rdx
     movq %rdx,(%rsp)
     # Set thread local storage

 /branches/network/uspace/lib/libc/arch/amd64/_link.ld.in
 ,9 → 7,9
 }
 SECTIONS {
-    . = 0x1000;
+    . = 0x1000 + SIZEOF_HEADERS;
-    .init ALIGN(0x1000) : SUBALIGN(0x1000) {
+    .init : {
         *(.init);
     } :text
     .text : {
 ,8 → 16,10
         *(.text);
         *(.rodata*);
     } :text
-    .data ALIGN(0x1000) : SUBALIGN(0x1000) {
+    . = . + 0x1000;
+    .data : {
         *(.data);
     } :data
     .tdata : {

 /branches/network/uspace/lib/libc/arch/ppc64/Makefile.inc
 ,8 → 29,12
 ## Toolchain configuration
 #
+ifndef CROSS_PREFIX
+    CROSS_PREFIX = /usr/local
+endif
 TARGET = ppc64-linux-gnu
-TOOLCHAIN_DIR = /usr/local/ppc64/bin
+TOOLCHAIN_DIR = $(CROSS_PREFIX)/ppc64/bin
 ARCH_SOURCES += arch/$(ARCH)/src/syscall.c \
         arch/$(ARCH)/src/fibril.S \

 /branches/network/uspace/lib/libc/arch/ppc64/include/config.h
 ,8 → 36,7
 #define LIBC_ppc64_CONFIG_H_
 #define PAGE_WIDTH  12
-#define PAGE_SIZE   (1<<PAGE_WIDTH)
-#define PAGE_COLOR_BITS 0        /* dummy */
+#define PAGE_SIZE   (1 << PAGE_WIDTH)
 #endif

 /branches/network/uspace/lib/libc/arch/ppc64/include/byteorder.h
 ,0 → 1,43
+/*
+ * Copyright (c) 2005 Jakub Jermar
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * - Redistributions of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * - Redistributions in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in the
+ *   documentation and/or other materials provided with the distribution.
+ * - The name of the author may not be used to endorse or promote products
+ *   derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+/** @addtogroup libcppc64
+ * @{
+ */
+/** @file
+ */
+#ifndef LIBC_ppc64_BYTEORDER_H_
+#define LIBC_ppc64_BYTEORDER_H_
+#define ARCH_IS_BIG_ENDIAN
+#endif
+/** @}
+ */

 /branches/network/uspace/lib/libc/arch/ppc64/src/entry.s
 ,7 → 31,6
 .org 0
 .globl __entry
-.globl __entry_driver
 ## User-space task entry point
 #
 ,11 → 37,4
 #
 __entry:
     bl __main
-    bl __io_init
-    bl main
     bl __exit
-__entry_driver:
-    bl __main
-    bl main
-    bl __exit

 /branches/network/uspace/lib/libc/arch/ppc64/src/fibril.S
 ,58 → 32,10
 .global context_restore
 #include <libarch/regname.h>
-#include <libarch/context_offset.h>
+#include <kernel/arch/context_offset.h>
-.macro CONTEXT_STORE r
-    stw sp, OFFSET_SP(\r)
-    stw r2, OFFSET_R2(\r)
-    stw r13, OFFSET_R13(\r)
-    stw r14, OFFSET_R14(\r)
-    stw r15, OFFSET_R15(\r)
-    stw r16, OFFSET_R16(\r)
-    stw r17, OFFSET_R17(\r)
-    stw r18, OFFSET_R18(\r)
-    stw r19, OFFSET_R19(\r)
-    stw r20, OFFSET_R20(\r)
-    stw r21, OFFSET_R21(\r)
-    stw r22, OFFSET_R22(\r)
-    stw r23, OFFSET_R23(\r)
-    stw r24, OFFSET_R24(\r)
-    stw r25, OFFSET_R25(\r)
-    stw r26, OFFSET_R26(\r)
-    stw r27, OFFSET_R27(\r)
-    stw r28, OFFSET_R28(\r)
-    stw r29, OFFSET_R29(\r)
-    stw r30, OFFSET_R30(\r)
-    stw r31, OFFSET_R31(\r)
-.endm
-.macro CONTEXT_LOAD r
-    lwz sp, OFFSET_SP(\r)
-    lwz r2, OFFSET_R2(\r)
-    lwz r13, OFFSET_R13(\r)
-    lwz r14, OFFSET_R14(\r)
-    lwz r15, OFFSET_R15(\r)
-    lwz r16, OFFSET_R16(\r)
-    lwz r17, OFFSET_R17(\r)
-    lwz r18, OFFSET_R18(\r)
-    lwz r19, OFFSET_R19(\r)
-    lwz r20, OFFSET_R20(\r)
-    lwz r21, OFFSET_R21(\r)
-    lwz r22, OFFSET_R22(\r)
-    lwz r23, OFFSET_R23(\r)
-    lwz r24, OFFSET_R24(\r)
-    lwz r25, OFFSET_R25(\r)
-    lwz r26, OFFSET_R26(\r)
-    lwz r27, OFFSET_R27(\r)
-    lwz r28, OFFSET_R28(\r)
-    lwz r29, OFFSET_R29(\r)
-    lwz r30, OFFSET_R30(\r)
-    lwz r31, OFFSET_R31(\r)
-.endm
 context_save:
-    CONTEXT_STORE r3
+    CONTEXT_SAVE_ARCH_CORE r3
     mflr r4
     stw r4, OFFSET_PC(r3)
 ,7 → 49,7
 context_restore:
-    CONTEXT_LOAD r3
+    CONTEXT_RESTORE_ARCH_CORE r3
     lwz r4, OFFSET_CR(r3)
     mtcr r4

 /branches/network/uspace/lib/libc/arch/ppc64/src/syscall.c
 ,13 → 36,16
 #include <libc.h>
-sysarg_t __syscall(const sysarg_t p1, const sysarg_t p2, const sysarg_t p3, const sysarg_t p4, const syscall_t id)
+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)
 {
     register sysarg_t __ppc32_reg_r3 asm("3") = p1;
     register sysarg_t __ppc32_reg_r4 asm("4") = p2;
     register sysarg_t __ppc32_reg_r5 asm("5") = p3;
     register sysarg_t __ppc32_reg_r6 asm("6") = p4;
-    register sysarg_t __ppc32_reg_r7 asm("7") = id;
+    register sysarg_t __ppc32_reg_r7 asm("7") = p5;
+    register sysarg_t __ppc32_reg_r8 asm("8") = p6;
+    register sysarg_t __ppc32_reg_r9 asm("9") = id;
     asm volatile (
         "sc\n"
 ,7 → 54,9
           "r" (__ppc32_reg_r4),
           "r" (__ppc32_reg_r5),
           "r" (__ppc32_reg_r6),
-          "r" (__ppc32_reg_r7)
+          "r" (__ppc32_reg_r7),
+          "r" (__ppc32_reg_r8),
+          "r" (__ppc32_reg_r9)
     );
     return __ppc32_reg_r3;

 /branches/network/uspace/lib/libc/arch/ppc64/_link.ld.in
 ,9 → 7,9
 }
 SECTIONS {
-    . = 0x1000;
+    . = 0x1000 + SIZEOF_HEADERS;
-    .init ALIGN(0x1000) : SUBALIGN(0x1000) {
+    .init : {
         *(.init);
     } :text
     .text : {
 ,8 → 17,10
         *(.toc);
         *(.rodata*);
     } :text
-    .data ALIGN(0x1000) : SUBALIGN(0x1000) {
+    . = . + 0x1000;
+    .data : {
         *(.opd);
         *(.data*);
         *(.sdata);

 /branches/network/uspace/lib/libc/arch/mips32/Makefile.inc
 ,8 → 29,12
 ## Toolchain configuration
 #
+ifndef CROSS_PREFIX
+    CROSS_PREFIX = /usr/local
+endif
 TARGET = mipsel-linux-gnu
-TOOLCHAIN_DIR = /usr/local/mipsel/bin
+TOOLCHAIN_DIR = $(CROSS_PREFIX)/mipsel/bin
 CFLAGS += -mips3
 -include ../../Makefile.config

 /branches/network/uspace/lib/libc/arch/mips32/include/config.h
 ,8 → 36,7
 #define LIBC_mips32_CONFIG_H_
 #define PAGE_WIDTH  14
-#define PAGE_SIZE   (1<<PAGE_WIDTH)
-#define PAGE_COLOR_BITS 0        /* dummy */
+#define PAGE_SIZE   (1 << PAGE_WIDTH)
 #endif

 /branches/network/uspace/lib/libc/arch/mips32/include/atomic.h
 ,7 → 64,7
         "   sc %0, %1\n"
         "   beq %0, %4, 1b\n"   /* if the atomic operation failed, try again */
         /*  nop */      /* nop is inserted automatically by compiler */
-        : "=r" (tmp), "=m" (val->count), "=r" (v)
+        : "=&r" (tmp), "+m" (val->count), "=&r" (v)
         : "i" (i), "i" (0)
         );

 /branches/network/uspace/lib/libc/arch/mips32/include/byteorder.h
 ,0 → 1,43
+/*
+ * Copyright (c) 2005 Jakub Jermar
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * - Redistributions of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * - Redistributions in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in the
+ *   documentation and/or other materials provided with the distribution.
+ * - The name of the author may not be used to endorse or promote products
+ *   derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+/** @addtogroup libcmips32
+ * @{
+ */
+/** @file
+ */
+#ifndef LIBC_mips32_BYTEORDER_H_
+#define LIBC_mips32_BYTEORDER_H_
+#define ARCH_IS_LITTLE_ENDIAN
+#endif
+/** @}
+ */

 /branches/network/uspace/lib/libc/arch/mips32/src/entry.s
 ,13 → 35,13
 ## User-space task entry point
 #
+# $a0 ($4) contains the PCB pointer
 #
 .ent __entry
 __entry:
     .frame $sp, 32, $31
     .cpload $25
     # Mips o32 may store its arguments on stack, make space (16 bytes),
     # so that it could work with -O0
     # Make space additional 16 bytes for the stack frame
 ,42 → 48,18
     addiu $sp, -32
     .cprestore 16   # Allow PIC code
-    jal __main
-    nop
-    jal __io_init
-    nop
-    jal main
-    nop
-    jal __exit
-    nop
-.end
-.ent __entry_driver
-__entry_driver:
-    .frame $sp, 32, $31
-    .cpload $25
-    # Mips o32 may store its arguments on stack, make space (16 bytes),
-    # so that it could work with -O0
-    # Make space additional 16 bytes for the stack frame
+    # Pass pcb_ptr to __main() as the first argument. pcb_ptr is already
+    # in $a0. As the first argument is passed in $a0, no operation
+    # is needed.
-    addiu $sp, -32
-    .cprestore 16   # Allow PIC code
     jal __main
     nop
-    jal main
-    nop
     jal __exit
     nop
 .end
 # Alignment of output section data to 0x4000
 .section .data
 .align 14

 /branches/network/uspace/lib/libc/arch/mips32/src/fibril.S
 ,119 → 31,13
 .set noat
 .set noreorder
-#include <arch/asm/regname.h>
-#include <libarch/context_offset.h>
+#include <arch/context_offset.h>
 .global context_save
 .global context_restore
-.macro CONTEXT_STORE r
-    sw $s0,OFFSET_S0(\r)
-    sw $s1,OFFSET_S1(\r)
-    sw $s2,OFFSET_S2(\r)
-    sw $s3,OFFSET_S3(\r)
-    sw $s4,OFFSET_S4(\r)
-    sw $s5,OFFSET_S5(\r)
-    sw $s6,OFFSET_S6(\r)
-    sw $s7,OFFSET_S7(\r)
-    sw $s8,OFFSET_S8(\r)
-    sw $gp,OFFSET_GP(\r)
-    sw $k1,OFFSET_TLS(\r)
-#ifdef CONFIG_MIPS_FPU
-    mfc1 $t0,$20
-    sw $t0, OFFSET_F20(\r)
-    mfc1 $t0,$21
-    sw $t0, OFFSET_F21(\r)
-    mfc1 $t0,$22
-    sw $t0, OFFSET_F22(\r)
-    mfc1 $t0,$23
-    sw $t0, OFFSET_F23(\r)
-    mfc1 $t0,$24
-    sw $t0, OFFSET_F24(\r)
-    mfc1 $t0,$25
-    sw $t0, OFFSET_F25(\r)
-    mfc1 $t0,$26
-    sw $t0, OFFSET_F26(\r)
-    mfc1 $t0,$27
-    sw $t0, OFFSET_F27(\r)
-    mfc1 $t0,$28
-    sw $t0, OFFSET_F28(\r)
-    mfc1 $t0,$29
-    sw $t0, OFFSET_F29(\r)
-    mfc1 $t0,$30
-    sw $t0, OFFSET_F30(\r)
-#endif
-    sw $ra,OFFSET_PC(\r)
-    sw $sp,OFFSET_SP(\r)
-.endm
-.macro CONTEXT_LOAD r
-    lw $s0,OFFSET_S0(\r)
-    lw $s1,OFFSET_S1(\r)
-    lw $s2,OFFSET_S2(\r)
-    lw $s3,OFFSET_S3(\r)
-    lw $s4,OFFSET_S4(\r)
-    lw $s5,OFFSET_S5(\r)
-    lw $s6,OFFSET_S6(\r)
-    lw $s7,OFFSET_S7(\r)
-    lw $s8,OFFSET_S8(\r)
-    lw $gp,OFFSET_GP(\r)
-    lw $k1,OFFSET_TLS(\r)
-#ifdef CONFIG_MIPS_FPU
-    lw $t0, OFFSET_F20(\r)
-    mtc1 $t0,$20
-    lw $t0, OFFSET_F21(\r)
-    mtc1 $t0,$21
-    lw $t0, OFFSET_F22(\r)
-    mtc1 $t0,$22
-    lw $t0, OFFSET_F23(\r)
-    mtc1 $t0,$23
-    lw $t0, OFFSET_F24(\r)
-    mtc1 $t0,$24
-    lw $t0, OFFSET_F25(\r)
-    mtc1 $t0,$25
-    lw $t0, OFFSET_F26(\r)
-    mtc1 $t0,$26
-    lw $t0, OFFSET_F27(\r)
-    mtc1 $t0,$27
-    lw $t0, OFFSET_F28(\r)
-    mtc1 $t0,$28
-    lw $t0, OFFSET_F29(\r)
-    mtc1 $t0,$29
-    lw $t0, OFFSET_F30(\r)
-    mtc1 $t0,$30
-#endif
-    lw $ra,OFFSET_PC(\r)
-    lw $sp,OFFSET_SP(\r)
-.endm
 context_save:
-    CONTEXT_STORE $a0
+    CONTEXT_SAVE_ARCH_CORE $a0
     # context_save returns 1
     j $ra
 ,7 → 44,7
     li $v0, 1
 context_restore:
-    CONTEXT_LOAD $a0
+    CONTEXT_RESTORE_ARCH_CORE $a0
     # Just for the jump into first function, but one instruction
     # should not bother us

 /branches/network/uspace/lib/libc/arch/mips32/_link.ld.in
 ,9 → 7,9
 }
 SECTIONS {
-    . = 0x4000;
+    . = 0x4000 + SIZEOF_HEADERS;
-    .init ALIGN(0x4000) : SUBALIGN(0x4000) {
+    .init : {
         *(.init);
     } :text
     .text : {
 ,6 → 17,8
         *(.rodata*);
     } :text
+    . = . + 0x4000;
     .data : {
         *(.data);
         *(.data.rel*);

 /branches/network/uspace/lib/libc/arch/ia32/Makefile.inc
 ,8 → 29,12
 ## Toolchain configuration
 #
+ifndef CROSS_PREFIX
+    CROSS_PREFIX = /usr/local
+endif
 TARGET = i686-pc-linux-gnu
-TOOLCHAIN_DIR = /usr/local/i686/bin
+TOOLCHAIN_DIR = $(CROSS_PREFIX)/i686/bin
 ARCH_SOURCES += arch/$(ARCH)/src/syscall.S \
         arch/$(ARCH)/src/fibril.S \

 /branches/network/uspace/lib/libc/arch/ia32/include/config.h
 ,8 → 36,7
 #define LIBC_ia32_CONFIG_H_
 #define PAGE_WIDTH  12
-#define PAGE_SIZE   (1<<PAGE_WIDTH)
-#define PAGE_COLOR_BITS 0        /* dummy */
+#define PAGE_SIZE   (1 << PAGE_WIDTH)
 #endif

 /branches/network/uspace/lib/libc/arch/ia32/include/atomic.h
 ,11 → 36,11
 #define LIBC_ia32_ATOMIC_H_
 static inline void atomic_inc(atomic_t *val) {
-    asm volatile ("lock incl %0\n" : "=m" (val->count));
+    asm volatile ("lock incl %0\n" : "+m" (val->count));
 }
 static inline void atomic_dec(atomic_t *val) {
-    asm volatile ("lock decl %0\n" : "=m" (val->count));
+    asm volatile ("lock decl %0\n" : "+m" (val->count));
 }
 static inline long atomic_postinc(atomic_t *val)
 ,7 → 50,7
     asm volatile (
         "movl $1, %0\n"
         "lock xaddl %0, %1\n"
-        : "=r" (r), "=m" (val->count)
+        : "=r" (r), "+m" (val->count)
     );
     return r;
 ,14 → 63,14
     asm volatile (
         "movl $-1, %0\n"
         "lock xaddl %0, %1\n"
-        : "=r" (r), "=m" (val->count)
+        : "=r" (r), "+m" (val->count)
     );
     return r;
 }
-#define atomic_preinc(val) (atomic_postinc(val)+1)
-#define atomic_predec(val) (atomic_postdec(val)-1)
+#define atomic_preinc(val) (atomic_postinc(val) + 1)
+#define atomic_predec(val) (atomic_postdec(val) - 1)
 #endif

 /branches/network/uspace/lib/libc/arch/ia32/include/byteorder.h
 ,0 → 1,44
+/*
+ * Copyright (c) 2005 Jakub Jermar
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * - Redistributions of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * - Redistributions in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in the
+ *   documentation and/or other materials provided with the distribution.
+ * - The name of the author may not be used to endorse or promote products
+ *   derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+/** @addtogroup libcia32
+ * @{
+ */
+/** @file
+ */
+#ifndef LIBC_ia32_BYTEORDER_H_
+#define LIBC_ia32_BYTEORDER_H_
+/* IA-32 is little-endian */
+#define ARCH_IS_LITTLE_ENDIAN
+#endif
+/** @}
+ */

 /branches/network/uspace/lib/libc/arch/ia32/src/entry.s
 ,10 → 31,10
 .org 0
 .globl __entry
-.globl __entry_driver
 ## User-space task entry point
 #
+# %ebx contains the PCB pointer
 #
 __entry:
     mov %ss, %ax
 ,19 → 42,9
     mov %ax, %es
     mov %ax, %fs
     # Do not set %gs, it contains descriptor that can see TLS
+    # Pass the PCB pointer to __main as the first argument
+    pushl %ebx
     call __main
-    call __io_init
-    call main
     call __exit
-__entry_driver:
-    mov %ss, %ax
-    mov %ax, %ds
-    mov %ax, %es
-    mov %ax, %fs
-    # Do not set %gs, it contains descriptor that can see TLS
-    call __main
-    call main
-    call __exit

 /branches/network/uspace/lib/libc/arch/ia32/src/setjmp.S
 ,6 → 26,8
 # THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #
+#include <kernel/arch/context_offset.h>
 .text
 .global setjmp
 .global longjmp
 ,18 → 34,13
 .type setjmp,@function
 setjmp:
-    movl    0(%esp), %ecx   # save current pc
-    leal    4(%esp), %edx   # save stack pointer
-    movl    (%edx), %eax    # get jmp_buf pointer
+    movl 0(%esp),%eax   # save pc value into eax
+    movl 4(%esp),%edx   # address of the jmp_buf structure to save context to
-        # Save registers
-    movl %ebx, 0(%eax)
-    movl %esi, 4(%eax)
-    movl %edi, 8(%eax)
-    movl %ebp, 12(%eax)
-    movl %edx, 16(%eax)
+        # save registers to the jmp_buf structure
+    CONTEXT_SAVE_ARCH_CORE %edx %eax
-    movl %ecx, 20(%eax) # save pc
+    xorl %eax,%eax      # set_jmp returns 0
     ret
 .type longjmp,@function
 ,12 → 49,9
     movl 4(%esp), %ecx  # put address of jmp_buf into ecx
     movl 8(%esp), %eax  # put return value into eax
-        # restore all registers
-    movl 0(%ecx), %ebx
-    movl 4(%ecx), %esi
-    movl 8(%ecx), %edi
-    movl 12(%ecx), %ebp
-    movl 16(%ecx), %esp
-    movl 20(%ecx), %edx # saved return address
-    jmp *%edx
+        # restore registers from the jmp_buf structure
+    CONTEXT_RESTORE_ARCH_CORE %ecx %edx
+    movl %edx,0(%esp)   # put saved pc on stack
+    ret

 /branches/network/uspace/lib/libc/arch/ia32/src/fibril.S
 ,6 → 26,8
 # THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #
+#include <kernel/arch/context_offset.h>
 .text
 .global context_save
 ,16 → 43,12
     movl 0(%esp),%eax   # the caller's return %eip
     movl 4(%esp),%edx   # address of the context variable to save context to
-    movl %esp,0(%edx)   # %esp -> ctx->sp
-    movl %eax,4(%edx)   # %eip -> ctx->pc
-    movl %ebx,8(%edx)   # %ebx -> ctx->ebx
-    movl %esi,12(%edx)  # %esi -> ctx->esi
-    movl %edi,16(%edx)  # %edi -> ctx->edi
-    movl %ebp,20(%edx)  # %ebp -> ctx->ebp
+        # save registers to the context structure
+    CONTEXT_SAVE_ARCH_CORE %edx %eax
     # Save TLS
     movl %gs:0, %eax
-    movl %eax, 24(%edx)     # tls -> ctx->tls
+    movl %eax, OFFSET_TLS(%edx)     # tls -> ctx->tls
     xorl %eax,%eax      # context_save returns 1
     incl %eax
 ,18 → 62,15
 #
 context_restore:
     movl 4(%esp),%eax   # address of the context variable to restore context from
-    movl 0(%eax),%esp   # ctx->sp -> %esp
-    movl 4(%eax),%edx   # ctx->pc -> %edx
-    movl 8(%eax),%ebx   # ctx->ebx -> %ebx
-    movl 12(%eax),%esi  # ctx->esi -> %esi
-    movl 16(%eax),%edi  # ctx->edi -> %edi
-    movl 20(%eax),%ebp  # ctx->ebp -> %ebp
+        # restore registers from the context structure
+    CONTEXT_RESTORE_ARCH_CORE %eax %edx
     movl %edx,0(%esp)   # ctx->pc -> saver's return %eip
     # Set thread local storage
     pushl %edx
-    movl 24(%eax), %edx   # Set arg1 to TLS addr
+    movl OFFSET_TLS(%eax), %edx   # Set arg1 to TLS addr
     movl $1, %eax         # Syscall SYS_TLS_SET
     int $0x30
     popl %edx

 /branches/network/uspace/lib/libc/arch/ia32/_link.ld.in
 ,9 → 7,9
 }
 SECTIONS {
-    . = 0x1000;
+    . = 0x1000 + SIZEOF_HEADERS;
-    .init ALIGN(0x1000) : SUBALIGN(0x1000) {
+    .init : {
         *(.init);
     } :text
     .text : {
 ,8 → 16,10
         *(.text);
                 *(.rodata*);
     } :text
-    .data ALIGN(0x1000) : SUBALIGN(0x1000) {
+    . = . + 0x1000;
+    .data : {
         *(.data);
     } :data
     .tdata : {

 /branches/network/uspace/lib/libc/arch/sparc64/Makefile.inc
 ,8 → 29,12
 ## Toolchain configuration
 #
+ifndef CROSS_PREFIX
+    CROSS_PREFIX = /usr/local
+endif
 TARGET = sparc64-linux-gnu
-TOOLCHAIN_DIR = /usr/local/sparc64/bin
+TOOLCHAIN_DIR = $(CROSS_PREFIX)/sparc64/bin
 ARCH_SOURCES += arch/$(ARCH)/src/fibril.S \
         arch/$(ARCH)/src/tls.c

/branches/network/uspace/lib/libc/arch/sparc64/include/config.h
37,7 → 37,6

#define PAGE_WIDTH 14
#define PAGE_SIZE (1 << PAGE_WIDTH)
#define PAGE_COLOR_BITS 0 /*< Only one page color. /

#endif

 /branches/network/uspace/lib/libc/arch/sparc64/include/byteorder.h
 ,0 → 1,43
+/*
+ * Copyright (c) 2005 Jakub Jermar
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * - Redistributions of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * - Redistributions in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in the
+ *   documentation and/or other materials provided with the distribution.
+ * - The name of the author may not be used to endorse or promote products
+ *   derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+/** @addtogroup libcsparc64
+ * @{
+ */
+/** @file
+ */
+#ifndef LIBC_sparc64_BYTEORDER_H_
+#define LIBC_sparc64_BYTEORDER_H_
+#define ARCH_IS_BIG_ENDIAN
+#endif
+/** @}
+ */

 /branches/network/uspace/lib/libc/arch/sparc64/src/entry.s
 ,27 → 31,18
 .org 0
 .globl __entry
-.globl __entry_driver
 ## User-space task entry point
 #
+# %o0 contains uarg
+# %o1 contains pcb_ptr
 #
 __entry:
+    # Pass pcb_ptr as the first argument to __main()
+    mov %o1, %o0
     sethi %hi(_gp), %l7
     call __main
     or %l7, %lo(_gp), %l7
-    call __io_init
-    nop
-    call main
-    nop
-    call __exit
-    nop
-__entry_driver:
-    sethi %hi(_gp), %l7
-    call __main
-    or %l7, %lo(_gp), %l7
-    call main
-    nop
     call __exit
     nop

 /branches/network/uspace/lib/libc/arch/sparc64/src/fibril.S
 ,7 → 26,7
 # THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #
-#include <libarch/context_offset.h>
+#include <kernel/arch/context_offset.h>
 .text
 ,52 → 33,8
 .global context_save
 .global context_restore
-.macro CONTEXT_STORE r
-    stx %sp, [\r + OFFSET_SP]
-    stx %o7, [\r + OFFSET_PC]
-    stx %i0, [\r + OFFSET_I0]
-    stx %i1, [\r + OFFSET_I1]
-    stx %i2, [\r + OFFSET_I2]
-    stx %i3, [\r + OFFSET_I3]
-    stx %i4, [\r + OFFSET_I4]
-    stx %i5, [\r + OFFSET_I5]
-    stx %fp, [\r + OFFSET_FP]
-    stx %i7, [\r + OFFSET_I7]
-    stx %l0, [\r + OFFSET_L0]
-    stx %l1, [\r + OFFSET_L1]
-    stx %l2, [\r + OFFSET_L2]
-    stx %l3, [\r + OFFSET_L3]
-    stx %l4, [\r + OFFSET_L4]
-    stx %l5, [\r + OFFSET_L5]
-    stx %l6, [\r + OFFSET_L6]
-    stx %l7, [\r + OFFSET_L7]
-    stx %g7, [\r + OFFSET_TP]
-.endm
-.macro CONTEXT_LOAD r
-    ldx [\r + OFFSET_SP], %sp
-    ldx [\r + OFFSET_PC], %o7
-    ldx [\r + OFFSET_I0], %i0
-    ldx [\r + OFFSET_I1], %i1
-    ldx [\r + OFFSET_I2], %i2
-    ldx [\r + OFFSET_I3], %i3
-    ldx [\r + OFFSET_I4], %i4
-    ldx [\r + OFFSET_I5], %i5
-    ldx [\r + OFFSET_FP], %fp
-    ldx [\r + OFFSET_I7], %i7
-    ldx [\r + OFFSET_L0], %l0
-    ldx [\r + OFFSET_L1], %l1
-    ldx [\r + OFFSET_L2], %l2
-    ldx [\r + OFFSET_L3], %l3
-    ldx [\r + OFFSET_L4], %l4
-    ldx [\r + OFFSET_L5], %l5
-    ldx [\r + OFFSET_L6], %l6
-    ldx [\r + OFFSET_L7], %l7
-    ldx [\r + OFFSET_TP], %g7
-.endm
 context_save:
-    CONTEXT_STORE %o0
+    CONTEXT_SAVE_ARCH_CORE %o0
     retl
     mov 1, %o0      ! context_save_arch returns 1
 ,6 → 48,6
     #
     flushw
-    CONTEXT_LOAD %o0
+    CONTEXT_RESTORE_ARCH_CORE %o0
     retl
     xor %o0, %o0, %o0   ! context_restore_arch returns 0

 /branches/network/uspace/lib/libc/arch/sparc64/_link.ld.in
 ,9 → 7,9
 }
 SECTIONS {
-    . = 0x4000;
+    . = 0x4000 + SIZEOF_HEADERS;
-    .init ALIGN(0x4000) : SUBALIGN(0x4000) {
+    .init : {
         *(.init);
     } :text
     .text : {
 ,12 → 16,14
         *(.text);
         *(.rodata*);
     } :text
-    .got ALIGN(0x4000) : SUBALIGN(0x4000) {
+    . = . + 0x4000;
+    .got : {
          _gp = .;
          *(.got*);
     } :data
-    .data ALIGN(0x4000) : SUBALIGN(0x4000) {
+    .data : {
         *(.data);
         *(.sdata);
     } :data

 /branches/network/uspace/lib/libc/generic/io/asprintf.c
 ,0 → 1,79
+/*
+ * Copyright (c) 2006 Josef Cejka
+ * Copyright (c) 2008 Jakub Jermar
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * - Redistributions of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * - Redistributions in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in the
+ *   documentation and/or other materials provided with the distribution.
+ * - The name of the author may not be used to endorse or promote products
+ *   derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+/** @addtogroup libc
+ * @{
+ */
+/** @file
+ */
+#include <stdarg.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <io/printf_core.h>
+static int asprintf_prewrite(const char *str, size_t count, void *unused)
+{
+    return count;
+}
+/** Allocate and print to string.
+ *
+ * @param strp      Address of the pointer where to store the address of
+ *          the newly allocated string.
+ * @fmt         Format strin.
+ *
+ * @return      Number of characters printed or a negative error code.
+ */
+int asprintf(char **strp, const char *fmt, ...)
+{
+    struct printf_spec ps = {
+         asprintf_prewrite,
+         NULL
+    };
+    int ret;
+    va_list args;
+    va_start(args, fmt);
+    ret = printf_core(fmt, &ps, args);
+    va_end(args);
+    if (ret > 0) {
+        *strp = malloc(ret + 20);
+        if (!*strp)
+            return -1;
+        va_start(args, fmt);
+        vsprintf(*strp, fmt, args);
+        va_end(args);
+    }
+    return ret;
+}
+/** @}
+ */

 /branches/network/uspace/lib/libc/generic/io/vsnprintf.c
 ,22 → 38,27
 #include <io/printf_core.h>
 struct vsnprintf_data {
-    size_t size; /* total space for string */
-    size_t len; /* count of currently used characters */
-    char *string; /* destination string */
+    size_t size;    /* total space for string */
+    size_t len; /* count of currently used characters */
+    char *string;   /* destination string */
 };
 /** Write string to given buffer.
- * Write at most data->size characters including trailing zero. According to C99 has snprintf to return number
- * of characters that would have been written if enough space had been available. Hence the return value is not
- * number of really printed characters but size of input string. Number of really used characters
- * is stored in data->len.
- * @param str source string to print
- * @param count size of source string
- * @param data structure with destination string, counter of used space and total string size.
- * @return number of characters to print (not characters really printed!)
+ * Write at most data->size characters including trailing zero. According to C99
+ * has snprintf to return number of characters that would have been written if
+ * enough space had been available. Hence the return value is not number of
+ * really printed characters but size of input string. Number of really used
+ * characters is stored in data->len.
+ *
+ * @param str       Source string to print.
+ * @param count     Size of the source string.
+ * @param data      Structure with destination string, counter of used space
+ *          and total string size.
+ * @return      Number of characters to print (not characters really
+ *          printed!)
  */
-static int vsnprintf_write(const char *str, size_t count, struct vsnprintf_data *data)
+static int
+vsnprintf_write(const char *str, size_t count, struct vsnprintf_data *data)
 {
     size_t i;
     i = data->size - data->len;
 ,7 → 68,10
     }
     if (i == 1) {
-        /* We have only one free byte left in buffer => write there trailing zero */
+        /*
+         * We have only one free byte left in buffer => write there
+         * trailing zero.
+         */
         data->string[data->size - 1] = 0;
         data->len = data->size;
         return count;
 ,17 → 78,23
     }
     if (i <= count) {
-        /* We have not enought space for whole string with the trailing zero => print only a part of string */
-            memcpy((void *)(data->string + data->len), (void *)str, i - 1);
-            data->string[data->size - 1] = 0;
-            data->len = data->size;
-            return count;
+        /*
+         * We have not enought space for whole string with the trailing
+         * zero => print only a part of string.
+         */
+        memcpy((void *)(data->string + data->len), (void *)str, i - 1);
+        data->string[data->size - 1] = 0;
+        data->len = data->size;
+        return count;
     }
     /* Buffer is big enought to print whole string */
     memcpy((void *)(data->string + data->len), (void *)str, count);
     data->len += count;
-    /* Put trailing zero at end, but not count it into data->len so it could be rewritten next time */
+    /*
+     * Put trailing zero at end, but not count it into data->len so it could
+     * be rewritten next time.
+     */
     data->string[data->len] = 0;
     return count;
 ,17 → 101,22
 }
 /** Print formatted to the given buffer with limited size.
- * @param str   buffer
- * @param size  buffer size
- * @param fmt   format string
+ * @param str       Buffer.
+ * @param size      Bffer size.
+ * @param fmt       Format string.
  * \see For more details about format string see printf_core.
  */
 int vsnprintf(char *str, size_t size, const char *fmt, va_list ap)
 {
     struct vsnprintf_data data = {size, 0, str};
-    struct printf_spec ps = {(int(*)(void *, size_t, void *)) vsnprintf_write, &data};
+    struct printf_spec ps = {
+        (int(*)(void *, size_t, void *)) vsnprintf_write,
+        &data
+    };
-    /* Print 0 at end of string - fix the case that nothing will be printed */
+    /*
+     * Print 0 at end of string - fix the case that nothing will be printed.
+     */
     if (size > 0)
         str[0] = 0;

/branches/network/uspace/lib/libc/generic/io/sprintf.c
48,7 → 48,6

va_start(args, fmt);
ret = vsprintf(str, fmt, args);

va_end(args);

return ret;

 /branches/network/uspace/lib/libc/generic/io/printf_core.c
 ,12 → 94,9
     if (str == NULL)
         return printf_putnchars("(NULL)", 6, ps);
-    for (count = 0; str[count] != 0; count++);
+    count = strlen(str);
-    if (ps->write((void *) str, count, ps->data) == count)
-        return 0;
-    return EOF;
+    return ps->write((void *) str, count, ps->data);
 }
 /** Print one character to output

 /branches/network/uspace/lib/libc/generic/io/stream.c
 ,52 → 56,63
 ssize_t read_stdin(void *buf, size_t count)
 {
-    ipcarg_t r0, r1;
-    size_t i = 0;
-    while (i < count) {
-        if (async_req_0_2(console_phone, CONSOLE_GETCHAR, &r0,
-            &r1) < 0) {
-            return -1;
+    open_console();
+    if (console_phone >= 0) {
+        ipcarg_t r0, r1;
+        size_t i = 0;
+        while (i < count) {
+            if (async_req_0_2(console_phone, CONSOLE_GETCHAR, &r0, &r1) < 0)
+                return -1;
+            ((char *) buf)[i++] = r0;
         }
-        ((char *) buf)[i++] = r0;
+        return i;
+    } else {
+        return -1;
     }
-    return i;
 }
 ssize_t write_stdout(const void *buf, size_t count)
 {
-    int i;
-    for (i = 0; i < count; i++)
-        async_msg_1(console_phone, CONSOLE_PUTCHAR,
-            ((const char *) buf)[i]);
+    open_console();
+    if (console_phone >= 0) {
+        int i;
-    return count;
+        for (i = 0; i < count; i++)
+            async_msg_1(console_phone, CONSOLE_PUTCHAR,
+                ((const char *) buf)[i]);
+        return count;
+    } else
+        return __SYSCALL3(SYS_KLOG, 1, (sysarg_t) buf, count);
 }
-void open_stdin(void)
+void open_console(void)
 {
     if (console_phone < 0) {
-        while ((console_phone = ipc_connect_me_to(PHONE_NS,
-            SERVICE_CONSOLE, 0, 0)) < 0) {
-            usleep(10000);
-        }
+        int phone = ipc_connect_me_to(PHONE_NS, SERVICE_CONSOLE, 0, 0);
+        if (phone >= 0)
+            console_phone = phone;
     }
 }
-void open_stdout(void)
+void close_console(void)
 {
-    if (console_phone < 0) {
-        while ((console_phone = ipc_connect_me_to(PHONE_NS,
-            SERVICE_CONSOLE, 0, 0)) < 0) {
-            usleep(10000);
+    if (console_phone >= 0) {
+        if (ipc_hangup(console_phone) == 0) {
+            console_phone = -1;
         }
     }
 }
+void klog_update(void)
+{
+    (void) __SYSCALL3(SYS_KLOG, 1, NULL, 0);
+}
 int get_cons_phone(void)
 {
+    open_console();
     return console_phone;
 }

 /branches/network/uspace/lib/libc/generic/getopt.c
 ,0 → 1,478
+/*  $NetBSD: getopt_long.c,v 1.21.4.1 2008/01/09 01:34:14 matt Exp $    */
+/*-
+ * Copyright (c) 2000 The NetBSD Foundation, Inc.
+ * All rights reserved.
+ *
+ * This code is derived from software contributed to The NetBSD Foundation
+ * by Dieter Baron and Thomas Klausner.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
+ * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
+ * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+ * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
+ * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ */
+/* Ported to HelenOS August 2008 by Tim Post <echo@echoreply.us> */
+#include <assert.h>
+#include <stdarg.h>
+#include <err.h>
+#include <errno.h>
+#include <getopt.h>
+#include <stdlib.h>
+#include <string.h>
+/* HelenOS Port : We're incorporating only the modern getopt_long with wrappers
+ * to keep legacy getopt() usage from breaking. All references to REPLACE_GETOPT
+ * are dropped, we just include the code */
+int opterr = 1;     /* if error message should be printed */
+int optind = 1;     /* index into parent argv vector */
+int optopt = '?';       /* character checked for validity */
+int optreset;       /* reset getopt */
+char *optarg;       /* argument associated with option */
+#define IGNORE_FIRST    (*options == '-' || *options == '+')
+#define PRINT_ERROR ((opterr) && ((*options != ':') \
+                      || (IGNORE_FIRST && options[1] != ':')))
+/*HelenOS Port - POSIXLY_CORRECT is always false */
+#define IS_POSIXLY_CORRECT 0
+#define PERMUTE         (!IS_POSIXLY_CORRECT && !IGNORE_FIRST)
+/* XXX: GNU ignores PC if *options == '-' */
+#define IN_ORDER        (!IS_POSIXLY_CORRECT && *options == '-')
+/* return values */
+#define BADCH   (int)'?'
+#define BADARG      ((IGNORE_FIRST && options[1] == ':') \
+             || (*options == ':') ? (int)':' : (int)'?')
+#define INORDER (int)1
+#define EMSG    ""
+static int getopt_internal(int, char **, const char *);
+static int gcd(int, int);
+static void permute_args(int, int, int, char **);
+static const char *place = EMSG; /* option letter processing */
+/* XXX: set optreset to 1 rather than these two */
+static int nonopt_start = -1; /* first non option argument (for permute) */
+static int nonopt_end = -1;   /* first option after non options (for permute) */
+/* Error messages */
+/* HelenOS Port: Calls to warnx() were eliminated (as we have no stderr that
+ * may be redirected) and replaced with printf. As such, error messages now
+ * end in a newline */
+static const char recargchar[] = "option requires an argument -- %c\n";
+static const char recargstring[] = "option requires an argument -- %s\n";
+static const char ambig[] = "ambiguous option -- %.*s\n";
+static const char noarg[] = "option doesn't take an argument -- %.*s\n";
+static const char illoptchar[] = "unknown option -- %c\n";
+static const char illoptstring[] = "unknown option -- %s\n";
+/*
+ * Compute the greatest common divisor of a and b.
+ */
+static int
+gcd(a, b)
+    int a;
+    int b;
+{
+    int c;
+    c = a % b;
+    while (c != 0) {
+        a = b;
+        b = c;
+        c = a % b;
+    }
+    return b;
+}
+/*
+ * Exchange the block from nonopt_start to nonopt_end with the block
+ * from nonopt_end to opt_end (keeping the same order of arguments
+ * in each block).
+ */
+static void
+permute_args(panonopt_start, panonopt_end, opt_end, nargv)
+    int panonopt_start;
+    int panonopt_end;
+    int opt_end;
+    char **nargv;
+{
+    int cstart, cyclelen, i, j, ncycle, nnonopts, nopts, pos;
+    char *swap;
+    assert(nargv != NULL);
+    /*
+     * compute lengths of blocks and number and size of cycles
+     */
+    nnonopts = panonopt_end - panonopt_start;
+    nopts = opt_end - panonopt_end;
+    ncycle = gcd(nnonopts, nopts);
+    cyclelen = (opt_end - panonopt_start) / ncycle;
+    for (i = 0; i < ncycle; i++) {
+        cstart = panonopt_end+i;
+        pos = cstart;
+        for (j = 0; j < cyclelen; j++) {
+            if (pos >= panonopt_end)
+                pos -= nnonopts;
+            else
+                pos += nopts;
+            swap = nargv[pos];
+            nargv[pos] = nargv[cstart];
+            nargv[cstart] = swap;
+        }
+    }
+}
+/*
+ * getopt_internal --
+ *  Parse argc/argv argument vector.  Called by user level routines.
+ *  Returns -2 if -- is found (can be long option or end of options marker).
+ */
+static int
+getopt_internal(nargc, nargv, options)
+    int nargc;
+    char **nargv;
+    const char *options;
+{
+    char *oli;              /* option letter list index */
+    int optchar;
+    assert(nargv != NULL);
+    assert(options != NULL);
+    optarg = NULL;
+    /*
+     * XXX Some programs (like rsyncd) expect to be able to
+     * XXX re-initialize optind to 0 and have getopt_long(3)
+     * XXX properly function again.  Work around this braindamage.
+     */
+    if (optind == 0)
+        optind = 1;
+    if (optreset)
+        nonopt_start = nonopt_end = -1;
+start:
+    if (optreset || !*place) {      /* update scanning pointer */
+        optreset = 0;
+        if (optind >= nargc) {          /* end of argument vector */
+            place = EMSG;
+            if (nonopt_end != -1) {
+                /* do permutation, if we have to */
+                permute_args(nonopt_start, nonopt_end,
+                    optind, nargv);
+                optind -= nonopt_end - nonopt_start;
+            }
+            else if (nonopt_start != -1) {
+                /*
+                 * If we skipped non-options, set optind
+                 * to the first of them.
+                 */
+                optind = nonopt_start;
+            }
+            nonopt_start = nonopt_end = -1;
+            return -1;
+        }
+        if ((*(place = nargv[optind]) != '-')
+            || (place[1] == '\0')) {    /* found non-option */
+            place = EMSG;
+            if (IN_ORDER) {
+                /*
+                 * GNU extension:
+                 * return non-option as argument to option 1
+                 */
+                optarg = nargv[optind++];
+                return INORDER;
+            }
+            if (!PERMUTE) {
+                /*
+                 * if no permutation wanted, stop parsing
+                 * at first non-option
+                 */
+                return -1;
+            }
+            /* do permutation */
+            if (nonopt_start == -1)
+                nonopt_start = optind;
+            else if (nonopt_end != -1) {
+                permute_args(nonopt_start, nonopt_end,
+                    optind, nargv);
+                nonopt_start = optind -
+                    (nonopt_end - nonopt_start);
+                nonopt_end = -1;
+            }
+            optind++;
+            /* process next argument */
+            goto start;
+        }
+        if (nonopt_start != -1 && nonopt_end == -1)
+            nonopt_end = optind;
+        if (place[1] && *++place == '-') {  /* found "--" */
+            place++;
+            return -2;
+        }
+    }
+    if ((optchar = (int)*place++) == (int)':' ||
+        (oli = strchr(options + (IGNORE_FIRST ? 1 : 0), optchar)) == NULL) {
+        /* option letter unknown or ':' */
+        if (!*place)
+            ++optind;
+        if (PRINT_ERROR)
+            printf(illoptchar, optchar);
+        optopt = optchar;
+        return BADCH;
+    }
+    if (optchar == 'W' && oli[1] == ';') {      /* -W long-option */
+        /* XXX: what if no long options provided (called by getopt)? */
+        if (*place)
+            return -2;
+        if (++optind >= nargc) {    /* no arg */
+            place = EMSG;
+            if (PRINT_ERROR)
+                printf(recargchar, optchar);
+            optopt = optchar;
+            return BADARG;
+        } else              /* white space */
+            place = nargv[optind];
+        /*
+         * Handle -W arg the same as --arg (which causes getopt to
+         * stop parsing).
+         */
+        return -2;
+    }
+    if (*++oli != ':') {            /* doesn't take argument */
+        if (!*place)
+            ++optind;
+    } else {                /* takes (optional) argument */
+        optarg = NULL;
+        if (*place)         /* no white space */
+            optarg = *place;
+        /* XXX: disable test for :: if PC? (GNU doesn't) */
+        else if (oli[1] != ':') {   /* arg not optional */
+            if (++optind >= nargc) {    /* no arg */
+                place = EMSG;
+                if (PRINT_ERROR)
+                    printf(recargchar, optchar);
+                optopt = optchar;
+                return BADARG;
+            } else
+                optarg = nargv[optind];
+        }
+        place = EMSG;
+        ++optind;
+    }
+    /* dump back option letter */
+    return optchar;
+}
+/*
+ * getopt --
+ *  Parse argc/argv argument vector.
+ */
+int
+getopt(nargc, nargv, options)
+    int nargc;
+    char * const *nargv;
+    const char *options;
+{
+    int retval;
+    assert(nargv != NULL);
+    assert(options != NULL);
+    retval = getopt_internal(nargc, (char **)nargv, options);
+    if (retval == -2) {
+        ++optind;
+        /*
+         * We found an option (--), so if we skipped non-options,
+         * we have to permute.
+         */
+        if (nonopt_end != -1) {
+            permute_args(nonopt_start, nonopt_end, optind,
+                       (char **)nargv);
+            optind -= nonopt_end - nonopt_start;
+        }
+        nonopt_start = nonopt_end = -1;
+        retval = -1;
+    }
+    return retval;
+}
+/*
+ * getopt_long --
+ *  Parse argc/argv argument vector.
+ */
+int
+getopt_long(nargc, nargv, options, long_options, idx)
+    int nargc;
+    char * const *nargv;
+    const char *options;
+    const struct option *long_options;
+    int *idx;
+{
+    int retval;
+#define IDENTICAL_INTERPRETATION(_x, _y)                \
+    (long_options[(_x)].has_arg == long_options[(_y)].has_arg &&    \
+     long_options[(_x)].flag == long_options[(_y)].flag &&      \
+     long_options[(_x)].val == long_options[(_y)].val)
+    assert(nargv != NULL);
+    assert(options != NULL);
+    assert(long_options != NULL);
+    /* idx may be NULL */
+    retval = getopt_internal(nargc, (char **)nargv, options);
+    if (retval == -2) {
+        char *current_argv, *has_equal;
+        size_t current_argv_len;
+        int i, ambiguous, match;
+        current_argv = (char *)place;
+        match = -1;
+        ambiguous = 0;
+        optind++;
+        place = EMSG;
+        if (*current_argv == '\0') {        /* found "--" */
+            /*
+             * We found an option (--), so if we skipped
+             * non-options, we have to permute.
+             */
+            if (nonopt_end != -1) {
+                permute_args(nonopt_start, nonopt_end,
+                    optind, (char **)nargv);
+                optind -= nonopt_end - nonopt_start;
+            }
+            nonopt_start = nonopt_end = -1;
+            return -1;
+        }
+        if ((has_equal = strchr(current_argv, '=')) != NULL) {
+            /* argument found (--option=arg) */
+            current_argv_len = has_equal - current_argv;
+            has_equal++;
+        } else
+            current_argv_len = strlen(current_argv);
+        for (i = 0; long_options[i].name; i++) {
+            /* find matching long option */
+            if (strncmp(current_argv, long_options[i].name,
+                current_argv_len))
+                continue;
+            if (strlen(long_options[i].name) ==
+                (unsigned)current_argv_len) {
+                /* exact match */
+                match = i;
+                ambiguous = 0;
+                break;
+            }
+            if (match == -1)        /* partial match */
+                match = i;
+            else if (!IDENTICAL_INTERPRETATION(i, match))
+                ambiguous = 1;
+        }
+        if (ambiguous) {
+            /* ambiguous abbreviation */
+            if (PRINT_ERROR)
+                printf(ambig, (int)current_argv_len,
+                     current_argv);
+            optopt = 0;
+            return BADCH;
+        }
+        if (match != -1) {          /* option found */
+                if (long_options[match].has_arg == no_argument
+                && has_equal) {
+                if (PRINT_ERROR)
+                    printf(noarg, (int)current_argv_len,
+                         current_argv);
+                /*
+                 * XXX: GNU sets optopt to val regardless of
+                 * flag
+                 */
+                if (long_options[match].flag == NULL)
+                    optopt = long_options[match].val;
+                else
+                    optopt = 0;
+                return BADARG;
+            }
+            if (long_options[match].has_arg == required_argument ||
+                long_options[match].has_arg == optional_argument) {
+                if (has_equal)
+                    optarg = has_equal;
+                else if (long_options[match].has_arg ==
+                    required_argument) {
+                    /*
+                     * optional argument doesn't use
+                     * next nargv
+                     */
+                    optarg = nargv[optind++];
+                }
+            }
+            if ((long_options[match].has_arg == required_argument)
+                && (optarg == NULL)) {
+                /*
+                 * Missing argument; leading ':'
+                 * indicates no error should be generated
+                 */
+                if (PRINT_ERROR)
+                    printf(recargstring, current_argv);
+                /*
+                 * XXX: GNU sets optopt to val regardless
+                 * of flag
+                 */
+                if (long_options[match].flag == NULL)
+                    optopt = long_options[match].val;
+                else
+                    optopt = 0;
+                --optind;
+                return BADARG;
+            }
+        } else {            /* unknown option */
+            if (PRINT_ERROR)
+                printf(illoptstring, current_argv);
+            optopt = 0;
+            return BADCH;
+        }
+        if (long_options[match].flag) {
+            *long_options[match].flag = long_options[match].val;
+            retval = 0;
+        } else
+            retval = long_options[match].val;
+        if (idx)
+            *idx = match;
+    }
+    return retval;
+#undef IDENTICAL_INTERPRETATION
+}

 /branches/network/uspace/lib/libc/generic/ipc.c
 ,7 → 682,7
 {
     int res;
     sysarg_t tmp_flags;
-    res = ipc_call_sync_3_2(phoneid, IPC_M_SHARE_IN, (ipcarg_t) dst,
+    res = async_req_3_2(phoneid, IPC_M_SHARE_IN, (ipcarg_t) dst,
         (ipcarg_t) size, arg, NULL, &tmp_flags);
     if (flags)
         *flags = tmp_flags;
 ,7 → 742,7
  */
 int ipc_share_out_start(int phoneid, void *src, int flags)
 {
-    return ipc_call_sync_3_0(phoneid, IPC_M_SHARE_OUT, (ipcarg_t) src, 0,
+    return async_req_3_0(phoneid, IPC_M_SHARE_OUT, (ipcarg_t) src, 0,
         (ipcarg_t) flags);
 }
 ,7 → 770,7
     assert(flags);
     *callid = async_get_call(&data);
-    if (IPC_GET_METHOD(data) != IPC_M_DATA_WRITE)
+    if (IPC_GET_METHOD(data) != IPC_M_SHARE_OUT)
         return 0;
     *size = (size_t) IPC_GET_ARG2(data);
     *flags = (int) IPC_GET_ARG3(data);
 ,7 → 803,7
  */
 int ipc_data_read_start(int phoneid, void *dst, size_t size)
 {
-    return ipc_call_sync_2_0(phoneid, IPC_M_DATA_READ, (ipcarg_t) dst,
+    return async_req_2_0(phoneid, IPC_M_DATA_READ, (ipcarg_t) dst,
         (ipcarg_t) size);
 }
 ,7 → 862,7
  */
 int ipc_data_write_start(int phoneid, void *src, size_t size)
 {
-    return ipc_call_sync_2_0(phoneid, IPC_M_DATA_WRITE, (ipcarg_t) src,
+    return async_req_2_0(phoneid, IPC_M_DATA_WRITE, (ipcarg_t) src,
         (ipcarg_t) size);
 }

 /branches/network/uspace/lib/libc/generic/vfs/canonify.c
 ,0 → 1,340
+/*
+ * Copyright (c) 2008 Jakub Jermar
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * - Redistributions of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * - Redistributions in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in the
+ *   documentation and/or other materials provided with the distribution.
+ * - The name of the author may not be used to endorse or promote products
+ *   derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+/** @addtogroup libc
+ * @{
+ */
+/**
+ * @file
+ * @brief
+ */
+#include <stdlib.h>
+/** Token types used for tokenization of path. */
+typedef enum {
+    TK_INVALID,
+    TK_SLASH,
+    TK_DOT,
+    TK_DOTDOT,
+    TK_COMP,
+    TK_NUL
+} tokval_t;
+typedef struct {
+    tokval_t kind;
+    char *start;
+    char *stop;
+} token_t;
+/** Fake up the TK_SLASH token. */
+static token_t slash_token(char *start)
+{
+    token_t ret;
+    ret.kind = TK_SLASH;
+    ret.start = start;
+    ret.stop = start;
+    return ret;
+}
+/** Given a token, return the next token. */
+static token_t next_token(token_t *cur)
+{
+    token_t ret;
+    if (cur->stop[1] == '\0') {
+        ret.kind = TK_NUL;
+        ret.start = cur->stop + 1;
+        ret.stop = ret.start;
+        return ret;
+    }
+    if (cur->stop[1] == '/') {
+        ret.kind = TK_SLASH;
+        ret.start = cur->stop + 1;
+        ret.stop = ret.start;
+        return ret;
+    }
+    if (cur->stop[1] == '.' && (!cur->stop[2] || cur->stop[2] == '/')) {
+        ret.kind = TK_DOT;
+        ret.start = cur->stop + 1;
+        ret.stop = ret.start;
+        return ret;
+    }
+    if (cur->stop[1] == '.' && cur->stop[2] == '.' &&
+        (!cur->stop[3] || cur->stop[3] == '/')) {
+        ret.kind = TK_DOTDOT;
+        ret.start = cur->stop + 1;
+        ret.stop = cur->stop + 2;
+        return ret;
+    }
+    unsigned i;
+    for (i = 1; cur->stop[i] && cur->stop[i] != '/'; i++)
+        ;
+    ret.kind = TK_COMP;
+    ret.start = &cur->stop[1];
+    ret.stop = &cur->stop[i - 1];
+    return ret;
+}
+/** States used by canonify(). */
+typedef enum {
+    S_INI,
+    S_A,
+    S_B,
+    S_C,
+    S_ACCEPT,
+    S_RESTART,
+    S_REJECT
+} state_t;
+typedef struct {
+    state_t s;
+    void (* f)(token_t *, token_t *, token_t *);
+} change_state_t;
+/*
+ * Actions that can be performed when transitioning from one
+ * state of canonify() to another.
+ */
+static void set_first_slash(token_t *t, token_t *tfsl, token_t *tlcomp)
+{
+    *tfsl = *t;
+    *tlcomp = *t;
+}
+static void save_component(token_t *t, token_t *tfsl, token_t *tlcomp)
+{
+    *tlcomp = *t;
+}
+static void terminate_slash(token_t *t, token_t *tfsl, token_t *tlcomp)
+{
+    if (tfsl->stop[1])  /* avoid writing to a well-formatted path */
+        tfsl->stop[1] = '\0';
+}
+static void remove_trailing_slash(token_t *t, token_t *tfsl, token_t *tlcomp)
+{
+    t->start[-1] = '\0';
+}
+/** Eat the extra '/'..
+ *
+ * @param t     The current TK_SLASH token.
+ */
+static void shift_slash(token_t *t, token_t *tfsl, token_t *tlcomp)
+{
+    char *p = t->start;
+    char *q = t->stop + 1;
+    while ((*p++ = *q++))
+        ;
+}
+/** Eat the extra '.'.
+ *
+ * @param t     The current TK_DOT token.
+ */
+static void shift_dot(token_t *t, token_t *tfsl, token_t *tlcomp)
+{
+    char *p = t->start;
+    char *q = t->stop + 1;
+    while ((*p++ = *q++))
+        ;
+}
+/** Collapse the TK_COMP TK_SLASH TK_DOTDOT pattern.
+ *
+ * @param t     The current TK_DOTDOT token.
+ * @param tlcomp    The last TK_COMP token.
+ */
+static void shift_dotdot(token_t *t, token_t *tfsl, token_t *tlcomp)
+{
+    char *p = tlcomp->start;
+    char *q = t->stop + 1;
+    while ((*p++ = *q++))
+        ;
+}
+/** Transition function for canonify(). */
+static change_state_t trans[4][6] = {
+    [S_INI] = {
+        [TK_SLASH] = {
+            .s = S_A,
+            .f = set_first_slash,
+        },
+        [TK_DOT] = {
+            .s = S_REJECT,
+            .f = NULL,
+        },
+        [TK_DOTDOT] = {
+            .s = S_REJECT,
+            .f = NULL,
+        },
+        [TK_COMP] = {
+            .s = S_REJECT,
+            .f = NULL,
+        },
+        [TK_NUL] = {
+            .s = S_REJECT,
+            .f = NULL,
+        },
+        [TK_INVALID] = {
+            .s = S_REJECT,
+            .f = NULL,
+        },
+    },
+    [S_A] = {
+        [TK_SLASH] = {
+            .s = S_A,
+            .f = set_first_slash,
+        },
+        [TK_DOT] = {
+            .s = S_A,
+            .f = NULL,
+        },
+        [TK_DOTDOT] = {
+            .s = S_A,
+            .f = NULL,
+        },
+        [TK_COMP] = {
+            .s = S_B,
+            .f = save_component,
+        },
+        [TK_NUL] = {
+            .s = S_ACCEPT,
+            .f = terminate_slash,
+        },
+        [TK_INVALID] = {
+            .s = S_REJECT,
+            .f = NULL,
+        },
+    },
+    [S_B] = {
+        [TK_SLASH] = {
+            .s = S_C,
+            .f = NULL,
+        },
+        [TK_DOT] = {
+            .s = S_REJECT,
+            .f = NULL,
+        },
+        [TK_DOTDOT] = {
+            .s = S_REJECT,
+            .f = NULL,
+        },
+        [TK_COMP] = {
+            .s = S_REJECT,
+            .f = NULL,
+        },
+        [TK_NUL] = {
+            .s = S_ACCEPT,
+            .f = NULL,
+        },
+        [TK_INVALID] = {
+            .s = S_REJECT,
+            .f = NULL,
+        },
+    },
+    [S_C] = {
+        [TK_SLASH] = {
+            .s = S_RESTART,
+            .f = shift_slash,
+        },
+        [TK_DOT] = {
+            .s = S_RESTART,
+            .f = shift_dot,
+        },
+        [TK_DOTDOT] = {
+            .s = S_RESTART,
+            .f = shift_dotdot,
+        },
+        [TK_COMP] = {
+            .s = S_B,
+            .f = save_component,
+        },
+        [TK_NUL] = {
+            .s = S_ACCEPT,
+            .f = remove_trailing_slash,
+        },
+        [TK_INVALID] = {
+            .s = S_REJECT,
+            .f = NULL,
+        },
+    }
+};
+/** Canonify a file system path.
+ *
+ * A file system path is canonical, if the following holds:
+ * 1) the path is absolute (i.e. a/b/c is not canonical)
+ * 2) there is no trailing slash in the path (i.e. /a/b/c is not canonical)
+ * 3) there is no extra slash in the path (i.e. /a//b/c is not canonical)
+ * 4) there is no '.' component in the path (i.e. /a/./b/c is not canonical)
+ * 5) there is no '..' component in the path (i.e. /a/b/../c is not canonical)
+ *
+ * This function makes a potentially non-canonical file system path canonical.
+ * It works in-place and requires a NULL-terminated input string.
+ *
+ * @param path      Path to be canonified.
+ * @param lenp      Pointer where the length of the final path will be
+ *          stored. Can be NULL.
+ *
+ * @return      Canonified path or NULL on failure.
+ */
+char *canonify(char *path, size_t *lenp)
+{
+    state_t state;
+    token_t t;
+    token_t tfsl;       /* first slash */
+    token_t tlcomp;     /* last component */
+    if (*path != '/')
+        return NULL;
+    tfsl = slash_token(path);
+restart:
+    state = S_INI;
+    t = tfsl;
+    tlcomp = tfsl;
+    while (state != S_ACCEPT && state != S_RESTART && state != S_REJECT) {
+        if (trans[state][t.kind].f)
+            trans[state][t.kind].f(&t, &tfsl, &tlcomp);
+        state = trans[state][t.kind].s;
+        t = next_token(&t);
+    }
+    switch (state) {
+    case S_RESTART:
+        goto restart;
+    case S_REJECT:
+        return NULL;
+    case S_ACCEPT:
+        if (lenp)
+            *lenp = (size_t)((tlcomp.stop - tfsl.start) + 1);
+        return tfsl.start;
+    default:
+        abort();
+    }
+}
+/**
+ * @}
+ */

 /branches/network/uspace/lib/libc/generic/vfs/vfs.c
 ,0 → 1,619
+/*
+ * Copyright (c) 2008 Jakub Jermar
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * - Redistributions of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * - Redistributions in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in the
+ *   documentation and/or other materials provided with the distribution.
+ * - The name of the author may not be used to endorse or promote products
+ *   derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+/** @addtogroup libc
+ * @{
+ */
+/** @file
+ */
+#include <vfs/vfs.h>
+#include <vfs/canonify.h>
+#include <stdlib.h>
+#include <unistd.h>
+#include <dirent.h>
+#include <fcntl.h>
+#include <sys/stat.h>
+#include <stdio.h>
+#include <sys/types.h>
+#include <ipc/ipc.h>
+#include <ipc/services.h>
+#include <async.h>
+#include <atomic.h>
+#include <futex.h>
+#include <errno.h>
+#include <string.h>
+#include <ipc/devmap.h>
+#include "../../srv/vfs/vfs.h"
+int vfs_phone = -1;
+futex_t vfs_phone_futex = FUTEX_INITIALIZER;
+futex_t cwd_futex = FUTEX_INITIALIZER;
+DIR *cwd_dir = NULL;
+char *cwd_path = NULL;
+size_t cwd_len = 0;
+char *absolutize(const char *path, size_t *retlen)
+{
+    char *ncwd_path;
+    char *ncwd_path_nc;
+    futex_down(&cwd_futex);
+    size_t len = strlen(path);
+    if (*path != '/') {
+        if (!cwd_path) {
+            futex_up(&cwd_futex);
+            return NULL;
+        }
+        ncwd_path_nc = malloc(cwd_len + 1 + len + 1);
+        if (!ncwd_path_nc) {
+            futex_up(&cwd_futex);
+            return NULL;
+        }
+        strcpy(ncwd_path_nc, cwd_path);
+        ncwd_path_nc[cwd_len] = '/';
+        ncwd_path_nc[cwd_len + 1] = '\0';
+    } else {
+        ncwd_path_nc = malloc(len + 1);
+        if (!ncwd_path_nc) {
+            futex_up(&cwd_futex);
+            return NULL;
+        }
+        ncwd_path_nc[0] = '\0';
+    }
+    strcat(ncwd_path_nc, path);
+    ncwd_path = canonify(ncwd_path_nc, retlen);
+    if (!ncwd_path) {
+        futex_up(&cwd_futex);
+        free(ncwd_path_nc);
+        return NULL;
+    }
+    /*
+     * We need to clone ncwd_path because canonify() works in-place and thus
+     * the address in ncwd_path need not be the same as ncwd_path_nc, even
+     * though they both point into the same dynamically allocated buffer.
+     */
+    ncwd_path = strdup(ncwd_path);
+    free(ncwd_path_nc);
+    if (!ncwd_path) {
+        futex_up(&cwd_futex);
+        return NULL;
+    }
+    futex_up(&cwd_futex);
+    return ncwd_path;
+}
+static int vfs_connect(void)
+{
+    if (vfs_phone < 0)
+        vfs_phone = ipc_connect_me_to(PHONE_NS, SERVICE_VFS, 0, 0);
+    return vfs_phone;
+}
+static int device_get_handle(char *name, dev_handle_t *handle)
+{
+    int phone = ipc_connect_me_to(PHONE_NS, SERVICE_DEVMAP, DEVMAP_CLIENT,
+);
+    if (phone < 0)
+        return phone;
+    ipc_call_t answer;
+    aid_t req = async_send_2(phone, DEVMAP_DEVICE_GET_HANDLE, 0, 0,
+        &answer);
+    ipcarg_t retval = ipc_data_write_start(phone, name, strlen(name) + 1);
+    if (retval != EOK) {
+        async_wait_for(req, NULL);
+        ipc_hangup(phone);
+        return retval;
+    }
+    async_wait_for(req, &retval);
+    if (handle != NULL)
+        *handle = -1;
+    if (retval == EOK) {
+        if (handle != NULL)
+            *handle = (dev_handle_t) IPC_GET_ARG1(answer);
+    }
+    ipc_hangup(phone);
+    return retval;
+}
+int mount(const char *fs_name, const char *mp, const char *dev)
+{
+    int res;
+    ipcarg_t rc;
+    aid_t req;
+    dev_handle_t dev_handle;
+    res = device_get_handle(dev, &dev_handle);
+    if (res != EOK)
+        return res;
+    size_t mpa_len;
+    char *mpa = absolutize(mp, &mpa_len);
+    if (!mpa)
+        return ENOMEM;
+    futex_down(&vfs_phone_futex);
+    async_serialize_start();
+    if (vfs_phone < 0) {
+        res = vfs_connect();
+        if (res < 0) {
+            async_serialize_end();
+            futex_up(&vfs_phone_futex);
+            free(mpa);
+            return res;
+        }
+    }
+    req = async_send_1(vfs_phone, VFS_MOUNT, dev_handle, NULL);
+    rc = ipc_data_write_start(vfs_phone, (void *)fs_name, strlen(fs_name));
+    if (rc != EOK) {
+        async_wait_for(req, NULL);
+        async_serialize_end();
+        futex_up(&vfs_phone_futex);
+        free(mpa);
+        return (int) rc;
+    }
+    /* Ask VFS whether it likes fs_name. */
+    rc = async_req_0_0(vfs_phone, IPC_M_PING);
+    if (rc != EOK) {
+        async_wait_for(req, NULL);
+        async_serialize_end();
+        futex_up(&vfs_phone_futex);
+        free(mpa);
+        return (int) rc;
+    }
+    rc = ipc_data_write_start(vfs_phone, (void *)mpa, mpa_len);
+    if (rc != EOK) {
+        async_wait_for(req, NULL);
+        async_serialize_end();
+        futex_up(&vfs_phone_futex);
+        free(mpa);
+        return (int) rc;
+    }
+    async_wait_for(req, &rc);
+    async_serialize_end();
+    futex_up(&vfs_phone_futex);
+    free(mpa);
+    return (int) rc;
+}
+static int _open(const char *path, int lflag, int oflag, ...)
+{
+    int res;
+    ipcarg_t rc;
+    ipc_call_t answer;
+    aid_t req;
+    size_t pa_len;
+    char *pa = absolutize(path, &pa_len);
+    if (!pa)
+        return ENOMEM;
+    futex_down(&vfs_phone_futex);
+    async_serialize_start();
+    if (vfs_phone < 0) {
+        res = vfs_connect();
+        if (res < 0) {
+            async_serialize_end();
+            futex_up(&vfs_phone_futex);
+            free(pa);
+            return res;
+        }
+    }
+    req = async_send_3(vfs_phone, VFS_OPEN, lflag, oflag, 0, &answer);
+    rc = ipc_data_write_start(vfs_phone, pa, pa_len);
+    if (rc != EOK) {
+        async_wait_for(req, NULL);
+        async_serialize_end();
+        futex_up(&vfs_phone_futex);
+        free(pa);
+        return (int) rc;
+    }
+    async_wait_for(req, &rc);
+    async_serialize_end();
+    futex_up(&vfs_phone_futex);
+    free(pa);
+    if (rc != EOK)
+        return (int) rc;
+    return (int) IPC_GET_ARG1(answer);
+}
+int open(const char *path, int oflag, ...)
+{
+    return _open(path, L_FILE, oflag);
+}
+int close(int fildes)
+{
+    int res;
+    ipcarg_t rc;
+    futex_down(&vfs_phone_futex);
+    async_serialize_start();
+    if (vfs_phone < 0) {
+        res = vfs_connect();
+        if (res < 0) {
+            async_serialize_end();
+            futex_up(&vfs_phone_futex);
+            return res;
+        }
+    }
+    rc = async_req_1_0(vfs_phone, VFS_CLOSE, fildes);
+    async_serialize_end();
+    futex_up(&vfs_phone_futex);
+    return (int)rc;
+}
+ssize_t read(int fildes, void *buf, size_t nbyte)
+{
+    int res;
+    ipcarg_t rc;
+    ipc_call_t answer;
+    aid_t req;
+    futex_down(&vfs_phone_futex);
+    async_serialize_start();
+    if (vfs_phone < 0) {
+        res = vfs_connect();
+        if (res < 0) {
+            async_serialize_end();
+            futex_up(&vfs_phone_futex);
+            return res;
+        }
+    }
+    req = async_send_1(vfs_phone, VFS_READ, fildes, &answer);
+    rc = ipc_data_read_start(vfs_phone, (void *)buf, nbyte);
+    if (rc != EOK) {
+        async_wait_for(req, NULL);
+        async_serialize_end();
+        futex_up(&vfs_phone_futex);
+        return (ssize_t) rc;
+    }
+    async_wait_for(req, &rc);
+    async_serialize_end();
+    futex_up(&vfs_phone_futex);
+    if (rc == EOK)
+        return (ssize_t) IPC_GET_ARG1(answer);
+    else
+        return rc;
+}
+ssize_t write(int fildes, const void *buf, size_t nbyte)
+{
+    int res;
+    ipcarg_t rc;
+    ipc_call_t answer;
+    aid_t req;
+    futex_down(&vfs_phone_futex);
+    async_serialize_start();
+    if (vfs_phone < 0) {
+        res = vfs_connect();
+        if (res < 0) {
+            async_serialize_end();
+            futex_up(&vfs_phone_futex);
+            return res;
+        }
+    }
+    req = async_send_1(vfs_phone, VFS_WRITE, fildes, &answer);
+    rc = ipc_data_write_start(vfs_phone, (void *)buf, nbyte);
+    if (rc != EOK) {
+        async_wait_for(req, NULL);
+        async_serialize_end();
+        futex_up(&vfs_phone_futex);
+        return (ssize_t) rc;
+    }
+    async_wait_for(req, &rc);
+    async_serialize_end();
+    futex_up(&vfs_phone_futex);
+    if (rc == EOK)
+        return (ssize_t) IPC_GET_ARG1(answer);
+    else
+        return -1;
+}
+off_t lseek(int fildes, off_t offset, int whence)
+{
+    int res;
+    ipcarg_t rc;
+    futex_down(&vfs_phone_futex);
+    async_serialize_start();
+    if (vfs_phone < 0) {
+        res = vfs_connect();
+        if (res < 0) {
+            async_serialize_end();
+            futex_up(&vfs_phone_futex);
+            return res;
+        }
+    }
+    off_t newoffs;
+    rc = async_req_3_1(vfs_phone, VFS_SEEK, fildes, offset, whence,
+        (ipcarg_t)&newoffs);
+    async_serialize_end();
+    futex_up(&vfs_phone_futex);
+    if (rc != EOK)
+        return (off_t) -1;
+    return newoffs;
+}
+int ftruncate(int fildes, off_t length)
+{
+    int res;
+    ipcarg_t rc;
+    futex_down(&vfs_phone_futex);
+    async_serialize_start();
+    if (vfs_phone < 0) {
+        res = vfs_connect();
+        if (res < 0) {
+            async_serialize_end();
+            futex_up(&vfs_phone_futex);
+            return res;
+        }
+    }
+    rc = async_req_2_0(vfs_phone, VFS_TRUNCATE, fildes, length);
+    async_serialize_end();
+    futex_up(&vfs_phone_futex);
+    return (int) rc;
+}
+DIR *opendir(const char *dirname)
+{
+    DIR *dirp = malloc(sizeof(DIR));
+    if (!dirp)
+        return NULL;
+    dirp->fd = _open(dirname, L_DIRECTORY, 0);
+    if (dirp->fd < 0) {
+        free(dirp);
+        return NULL;
+    }
+    return dirp;
+}
+struct dirent *readdir(DIR *dirp)
+{
+    ssize_t len = read(dirp->fd, &dirp->res.d_name[0], NAME_MAX + 1);
+    if (len <= 0)
+        return NULL;
+    return &dirp->res;
+}
+void rewinddir(DIR *dirp)
+{
+    (void) lseek(dirp->fd, 0, SEEK_SET);
+}
+int closedir(DIR *dirp)
+{
+    (void) close(dirp->fd);
+    free(dirp);
+    return 0;
+}
+int mkdir(const char *path, mode_t mode)
+{
+    int res;
+    ipcarg_t rc;
+    aid_t req;
+    size_t pa_len;
+    char *pa = absolutize(path, &pa_len);
+    if (!pa)
+        return ENOMEM;
+    futex_down(&vfs_phone_futex);
+    async_serialize_start();
+    if (vfs_phone < 0) {
+        res = vfs_connect();
+        if (res < 0) {
+            async_serialize_end();
+            futex_up(&vfs_phone_futex);
+            free(pa);
+            return res;
+        }
+    }
+    req = async_send_1(vfs_phone, VFS_MKDIR, mode, NULL);
+    rc = ipc_data_write_start(vfs_phone, pa, pa_len);
+    if (rc != EOK) {
+        async_wait_for(req, NULL);
+        async_serialize_end();
+        futex_up(&vfs_phone_futex);
+        free(pa);
+        return (int) rc;
+    }
+    async_wait_for(req, &rc);
+    async_serialize_end();
+    futex_up(&vfs_phone_futex);
+    free(pa);
+    return rc;
+}
+static int _unlink(const char *path, int lflag)
+{
+    int res;
+    ipcarg_t rc;
+    aid_t req;
+    size_t pa_len;
+    char *pa = absolutize(path, &pa_len);
+    if (!pa)
+        return ENOMEM;
+    futex_down(&vfs_phone_futex);
+    async_serialize_start();
+    if (vfs_phone < 0) {
+        res = vfs_connect();
+        if (res < 0) {
+            async_serialize_end();
+            futex_up(&vfs_phone_futex);
+            free(pa);
+            return res;
+        }
+    }
+    req = async_send_0(vfs_phone, VFS_UNLINK, NULL);
+    rc = ipc_data_write_start(vfs_phone, pa, pa_len);
+    if (rc != EOK) {
+        async_wait_for(req, NULL);
+        async_serialize_end();
+        futex_up(&vfs_phone_futex);
+        free(pa);
+        return (int) rc;
+    }
+    async_wait_for(req, &rc);
+    async_serialize_end();
+    futex_up(&vfs_phone_futex);
+    free(pa);
+    return rc;
+}
+int unlink(const char *path)
+{
+    return _unlink(path, L_NONE);
+}
+int rmdir(const char *path)
+{
+    return _unlink(path, L_DIRECTORY);
+}
+int rename(const char *old, const char *new)
+{
+    int res;
+    ipcarg_t rc;
+    aid_t req;
+    size_t olda_len;
+    char *olda = absolutize(old, &olda_len);
+    if (!olda)
+        return ENOMEM;
+    size_t newa_len;
+    char *newa = absolutize(new, &newa_len);
+    if (!newa) {
+        free(olda);
+        return ENOMEM;
+    }
+    futex_down(&vfs_phone_futex);
+    async_serialize_start();
+    if (vfs_phone < 0) {
+        res = vfs_connect();
+        if (res < 0) {
+            async_serialize_end();
+            futex_up(&vfs_phone_futex);
+            free(olda);
+            free(newa);
+            return res;
+        }
+    }
+    req = async_send_0(vfs_phone, VFS_RENAME, NULL);
+    rc = ipc_data_write_start(vfs_phone, olda, olda_len);
+    if (rc != EOK) {
+        async_wait_for(req, NULL);
+        async_serialize_end();
+        futex_up(&vfs_phone_futex);
+        free(olda);
+        free(newa);
+        return (int) rc;
+    }
+    rc = ipc_data_write_start(vfs_phone, newa, newa_len);
+    if (rc != EOK) {
+        async_wait_for(req, NULL);
+        async_serialize_end();
+        futex_up(&vfs_phone_futex);
+        free(olda);
+        free(newa);
+        return (int) rc;
+    }
+    async_wait_for(req, &rc);
+    async_serialize_end();
+    futex_up(&vfs_phone_futex);
+    free(olda);
+    free(newa);
+    return rc;
+}
+int chdir(const char *path)
+{
+    size_t pa_len;
+    char *pa = absolutize(path, &pa_len);
+    if (!pa)
+        return ENOMEM;
+    DIR *d = opendir(pa);
+    if (!d) {
+        free(pa);
+        return ENOENT;
+    }
+    futex_down(&cwd_futex);
+    if (cwd_dir) {
+        closedir(cwd_dir);
+        cwd_dir = NULL;
+        free(cwd_path);
+        cwd_path = NULL;
+        cwd_len = 0;
+    }
+    cwd_dir = d;
+    cwd_path = pa;
+    cwd_len = pa_len;
+    futex_up(&cwd_futex);
+}
+char *getcwd(char *buf, size_t size)
+{
+    if (!size)
+        return NULL;
+    futex_down(&cwd_futex);
+    if (size < cwd_len + 1) {
+        futex_up(&cwd_futex);
+        return NULL;
+    }
+    strcpy(buf, cwd_path);
+    futex_up(&cwd_futex);
+    return buf;
+}
+/** @}
+ */

 /branches/network/uspace/lib/libc/generic/task.c
 ,5 → 1,6
 /*
  * Copyright (c) 2006 Jakub Jermar
+ * Copyright (c) 2008 Jiri Svoboda
  * All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
 ,7 → 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 <vfs/vfs.h>
 task_id_t task_get_id(void)
 {
 ,5 → 52,136
     return task_id;
 }
+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.
+ *
+ * @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, const char *argv[])
+{
+    int phone_id;
+    ipc_call_t answer;
+    aid_t req;
+    int rc;
+    ipcarg_t retval;
+    char *pa;
+    size_t pa_len;
+    pa = absolutize(path, &pa_len);
+    if (!pa)
+        return 0;
+    /* Spawn a program loader */
+    phone_id = task_spawn_loader();
+    if (phone_id < 0)
+        return 0;
+    /*
+     * 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)
+        return 0;
+    /* 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;
+    /* Send arguments */
+    rc = loader_set_args(phone_id, argv);
+    if (rc != EOK)
+        goto error;
+    /* 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;
+    /* Error exit */
+error:
+    ipc_hangup(phone_id);
+    return 0;
+}
 /** @}
  */

 /branches/network/uspace/lib/libc/generic/string.c
 ,8 → 38,8
 #include <limits.h>
 #include <align.h>
 #include <sys/types.h>
+#include <malloc.h>
 /* Dummy implementation of mem/ functions */
 void *memset(void *s, int c, size_t n)
 ,9 → 66,10
         adst[i].n = asrc[i].n;
     for (j = 0; j < n % sizeof(unsigned long); j++)
-        ((unsigned char *) (((unsigned long *) dst) + i))[j] = ((unsigned char *) (((unsigned long *) src) + i))[j];
+        ((unsigned char *) (((unsigned long *) dst) + i))[j] =
+            ((unsigned char *) (((unsigned long *) src) + i))[j];
-    return (char *) src;
+    return (char *) dst;
 }
 void *memcpy(void *dst, const void *src, size_t n)
 ,7 → 76,8
 {
     int i, j;
-    if (((long) dst & (sizeof(long) - 1)) || ((long) src & (sizeof(long) - 1)))
+    if (((long) dst & (sizeof(long) - 1)) ||
+        ((long) src & (sizeof(long) - 1)))
         return unaligned_memcpy(dst, src, n);
     for (i = 0; i < n / sizeof(unsigned long); i++)
 ,9 → 84,10
         ((unsigned long *) dst)[i] = ((unsigned long *) src)[i];
     for (j = 0; j < n % sizeof(unsigned long); j++)
-        ((unsigned char *) (((unsigned long *) dst) + i))[j] = ((unsigned char *) (((unsigned long *) src) + i))[j];
+        ((unsigned char *) (((unsigned long *) dst) + i))[j] =
+            ((unsigned char *) (((unsigned long *) src) + i))[j];
-    return (char *) src;
+    return (char *) dst;
 }
 void *memmove(void *dst, const void *src, size_t n)
 ,22 → 98,23
         return memcpy(dst, src, n);
     for (j = (n % sizeof(unsigned long)) - 1; j >= 0; j--)
-        ((unsigned char *) ((unsigned long *) dst))[j] = ((unsigned char *) ((unsigned long *) src))[j];
+        ((unsigned char *) ((unsigned long *) dst))[j] =
+            ((unsigned char *) ((unsigned long *) src))[j];
     for (i = n / sizeof(unsigned long) - 1; i >=0 ; i--)
         ((unsigned long *) dst)[i] = ((unsigned long *) src)[i];
-    return (char *) src;
+    return (char *) dst;
 }
 /** Compare two memory areas.
  *
- * @param s1    Pointer to the first area to compare.
- * @param s2    Pointer to the second area to compare.
- * @param len   Size of the first area in bytes. Both areas must have the same
- *      length.
- * @return  If len is 0, return zero. If the areas match, return zero.
- *      Otherwise return non-zero.
+ * @param s1        Pointer to the first area to compare.
+ * @param s2        Pointer to the second area to compare.
+ * @param len       Size of the first area in bytes. Both areas must have
+ *          the same length.
+ * @return      If len is 0, return zero. If the areas match, return
+ *          zero. Otherwise return non-zero.
  */
 int bcmp(const char *s1, const char *s2, size_t len)
 {
 ,8 → 124,9
 }
 /** Count the number of characters in the string, not including terminating 0.
- * @param str string
- * @return number of characters in string.
+ *
+ * @param str       String.
+ * @return      Number of characters in string.
  */
 size_t strlen(const char *str)
 {
 ,7 → 146,6
         c++;
     return (a[c] - b[c]);
 }
 int strncmp(const char *a, const char *b, size_t n)
 ,10 → 159,22
 }
-/** Return pointer to the first occurence of character c in string
- * @param str scanned string
- * @param c searched character (taken as one byte)
- * @return pointer to the matched character or NULL if it is not found in given string.
+int stricmp(const char *a, const char *b)
+{
+    int c = 0;
+    while (a[c] && b[c] && (!(tolower(a[c]) - tolower(b[c]))))
+        c++;
+    return (tolower(a[c]) - tolower(b[c]));
+}
+/** Return pointer to the first occurence of character c in string.
+ *
+ * @param str       Scanned string.
+ * @param c     Searched character (taken as one byte).
+ * @return      Pointer to the matched character or NULL if it is not
+ *          found in given string.
  */
 char *strchr(const char *str, int c)
 {
 ,10 → 187,12
     return NULL;
 }
-/** Return pointer to the last occurence of character c in string
- * @param str scanned string
- * @param c searched character (taken as one byte)
- * @return pointer to the matched character or NULL if it is not found in given string.
+/** Return pointer to the last occurence of character c in string.
+ *
+ * @param str       Scanned string.
+ * @param c     Searched character (taken as one byte).
+ * @return      Pointer to the matched character or NULL if it is not
+ *          found in given string.
  */
 char *strrchr(const char *str, int c)
 {
 ,13 → 209,16
 /** Convert string to a number.
  * Core of strtol and strtoul functions.
- * @param nptr pointer to string
- * @param endptr if not NULL, function stores here pointer to the first invalid character
- * @param base zero or number between 2 and 36 inclusive
- * @param sgn its set to 1 if minus found
- * @return result of conversion.
+ *
+ * @param nptr      Pointer to string.
+ * @param endptr    If not NULL, function stores here pointer to the first
+ *          invalid character.
+ * @param base      Zero or number between 2 and 36 inclusive.
+ * @param sgn       It's set to 1 if minus found.
+ * @return      Result of conversion.
  */
-static unsigned long _strtoul(const char *nptr, char **endptr, int base, char *sgn)
+static unsigned long
+_strtoul(const char *nptr, char **endptr, int base, char *sgn)
 {
     unsigned char c;
     unsigned long result = 0;
 ,7 → 240,8
             /* FIXME: set errno to EINVAL */
             return 0;
         }
-        if ((base == 16) && (*str == '0') && ((str[1] == 'x') || (str[1] == 'X'))) {
+        if ((base == 16) && (*str == '0') && ((str[1] == 'x') ||
+            (str[1] == 'X'))) {
             str += 2;
         }
     } else {
 ,7 → 260,8
     while (*str) {
         c = *str;
-        c = (c >= 'a' ? c - 'a' + 10 : (c >= 'A' ? c - 'A' + 10 : (c <= '9' ? c - '0' : 0xff)));
+        c = (c >= 'a' ? c - 'a' + 10 : (c >= 'A' ? c - 'A' + 10 :
+            (c <= '9' ? c - '0' : 0xff)));
         if (c > base) {
             break;
         }
 ,7 → 280,10
     }
     if (str == tmpptr) {
-        /* no number was found => first invalid character is the first character of the string */
+        /*
+         * No number was found => first invalid character is the first
+         * character of the string.
+         */
         /* FIXME: set errno to EINVAL */
         str = nptr;
         result = 0;
 ,14 → 301,17
 }
 /** Convert initial part of string to long int according to given base.
- * The number may begin with an arbitrary number of whitespaces followed by optional sign (`+' or `-').
- * If the base is 0 or 16, the prefix `0x' may be inserted and the number will be taken as hexadecimal one.
- * If the base is 0 and the number begin with a zero, number will be taken as octal one (as with base 8).
- * Otherwise the base 0 is taken as decimal.
- * @param nptr pointer to string
- * @param endptr if not NULL, function stores here pointer to the first invalid character
- * @param base zero or number between 2 and 36 inclusive
- * @return result of conversion.
+ * The number may begin with an arbitrary number of whitespaces followed by
+ * optional sign (`+' or `-'). If the base is 0 or 16, the prefix `0x' may be
+ * inserted and the number will be taken as hexadecimal one. If the base is 0
+ * and the number begin with a zero, number will be taken as octal one (as with
+ * base 8). Otherwise the base 0 is taken as decimal.
+ *
+ * @param nptr      Pointer to string.
+ * @param endptr    If not NULL, function stores here pointer to the first
+ *          invalid character.
+ * @param base      Zero or number between 2 and 36 inclusive.
+ * @return      Result of conversion.
  */
 long int strtol(const char *nptr, char **endptr, int base)
 {
 ,14 → 334,17
 /** Convert initial part of string to unsigned long according to given base.
- * The number may begin with an arbitrary number of whitespaces followed by optional sign (`+' or `-').
- * If the base is 0 or 16, the prefix `0x' may be inserted and the number will be taken as hexadecimal one.
- * If the base is 0 and the number begin with a zero, number will be taken as octal one (as with base 8).
- * Otherwise the base 0 is taken as decimal.
- * @param nptr pointer to string
- * @param endptr if not NULL, function stores here pointer to the first invalid character
- * @param base zero or number between 2 and 36 inclusive
- * @return result of conversion.
+ * The number may begin with an arbitrary number of whitespaces followed by
+ * optional sign (`+' or `-'). If the base is 0 or 16, the prefix `0x' may be
+ * inserted and the number will be taken as hexadecimal one. If the base is 0
+ * and the number begin with a zero, number will be taken as octal one (as with
+ * base 8). Otherwise the base 0 is taken as decimal.
+ *
+ * @param nptr      Pointer to string.
+ * @param endptr    If not NULL, function stores here pointer to the first
+ *          invalid character
+ * @param base      Zero or number between 2 and 36 inclusive.
+ * @return      Result of conversion.
  */
 unsigned long strtoul(const char *nptr, char **endptr, int base)
 {
 ,7 → 360,8
 {
     char *orig = dest;
-    while ((*(dest++) = *(src++)));
+    while ((*(dest++) = *(src++)))
+        ;
     return orig;
 }
 ,9 → 369,32
 {
     char *orig = dest;
-    while ((*(dest++) = *(src++)) && --n);
+    while ((*(dest++) = *(src++)) && --n)
+        ;
     return orig;
 }
+char *strcat(char *dest, const char *src)
+{
+    char *orig = dest;
+    while (*dest++)
+        ;
+    --dest;
+    while ((*dest++ = *src++))
+        ;
+    return orig;
+}
+char * strdup(const char *s1)
+{
+    size_t len = strlen(s1) + 1;
+    void *ret = malloc(len);
+    if (ret == NULL)
+        return (char *) NULL;
+    return (char *) memcpy(ret, s1, len);
+}
 /** @}
  */

 /branches/network/uspace/lib/libc/generic/as.c
 ,6 → 85,20
     return __SYSCALL1(SYS_AS_AREA_DESTROY, (sysarg_t ) address);
 }
+/** Change address-space area flags.
+ *
+ * @param address Virtual address pointing into the address space area being
+ *  modified.
+ * @param flags New flags describing type of the area.
+ *
+ * @return Zero on success or a code from @ref errno.h on failure.
+ */
+int as_area_change_flags(void *address, int flags)
+{
+    return __SYSCALL2(SYS_AS_AREA_CHANGE_FLAGS, (sysarg_t) address,
+        (sysarg_t) flags);
+}
 static size_t heapsize = 0;
 static size_t maxheapsize = (size_t) (-1);

 /branches/network/uspace/lib/libc/generic/pcb.c
 ,0 → 1,40
+/*
+ * Copyright (c) 2008 Jiri Svoboda
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * - Redistributions of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * - Redistributions in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in the
+ *   documentation and/or other materials provided with the distribution.
+ * - The name of the author may not be used to endorse or promote products
+ *   derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+/** @addtogroup libc
+ * @{
+ */
+/** @file
+ */
+#include <loader/pcb.h>
+pcb_t *__pcb;
+/** @}
+ */

 /branches/network/uspace/lib/libc/generic/libc.c
 ,8 → 48,10
 #include <ipc/ipc.h>
 #include <async.h>
 #include <as.h>
+#include <loader/pcb.h>
 extern char _heap;
+extern int main(int argc, char *argv[]);
 void _exit(int status)
 {
 ,20 → 58,31
     thread_exit(status);
 }
-void __main(void)
+void __main(void *pcb_ptr)
 {
     fibril_t *f;
+    int argc;
+    char **argv;
     (void) as_area_create(&_heap, 1, AS_AREA_WRITE | AS_AREA_READ);
     _async_init();
     f = fibril_setup();
     __tcb_set(f->tcb);
-}
+    open_console();
-void __io_init(void)
-{
-    open_stdin();
-    open_stdout();
+    /* Save the PCB pointer */
+    __pcb = (pcb_t *)pcb_ptr;
+    if (__pcb == NULL) {
+        argc = 0;
+        argv = NULL;
+    } else {
+        argc = __pcb->argc;
+        argv = __pcb->argv;
+    }
+    main(argc, argv);
 }
 void __exit(void)

 /branches/network/uspace/lib/libc/generic/smc.c
 ,0 → 1,45
+/*
+ * Copyright (c) 2008 Jiri Svoboda
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * - Redistributions of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * - Redistributions in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in the
+ *   documentation and/or other materials provided with the distribution.
+ * - The name of the author may not be used to endorse or promote products
+ *   derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+/** @addtogroup libc
+ * @{
+ */
+/** @file
+ */
+#include <libc.h>
+#include <sys/types.h>
+int smc_coherence(void *address, size_t size)
+{
+    return __SYSCALL2(SYS_SMC_COHERENCE, (sysarg_t) address,
+        (sysarg_t) size);
+}
+/** @}
+ */

 /branches/network/uspace/lib/libc/generic/libadt/hash_table.c
 ,5 → 1,5
 /*
- * Copyright (c) 2006 Jakub Jermar
+ * Copyright (c) 2008 Jakub Jermar
  * All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
 ,13 → 46,14
 /** Create chained hash table.
  *
- * @param h Hash table structure. Will be initialized by this call.
- * @param m Number of slots in the hash table.
- * @param max_keys Maximal number of keys needed to identify an item.
- * @param op Hash table operations structure.
- * @return true on success
+ * @param h     Hash table structure. Will be initialized by this call.
+ * @param m     Number of hash table buckets.
+ * @param max_keys  Maximal number of keys needed to identify an item.
+ * @param op        Hash table operations structure.
+ * @return      True on success
  */
-int hash_table_create(hash_table_t *h, hash_count_t m, hash_count_t max_keys, hash_table_operations_t *op)
+int hash_table_create(hash_table_t *h, hash_count_t m, hash_count_t max_keys,
+    hash_table_operations_t *op)
 {
     hash_count_t i;
 ,12 → 77,23
     return true;
 }
-/** Insert item into hash table.
+/** Destroy a hash table instance.
  *
- * @param h Hash table.
- * @param key Array of all keys necessary to compute hash index.
- * @param item Item to be inserted into the hash table.
+ * @param h     Hash table to be destroyed.
  */
+void hash_table_destroy(hash_table_t *h)
+{
+    assert(h);
+    assert(h->entry);
+    free(h->entry);
+}
+/** Insert item into a hash table.
+ *
+ * @param h     Hash table.
+ * @param key       Array of all keys necessary to compute hash index.
+ * @param item      Item to be inserted into the hash table.
+ */
 void hash_table_insert(hash_table_t *h, unsigned long key[], link_t *item)
 {
     hash_index_t chain;
 ,10 → 109,10
 /** Search hash table for an item matching keys.
  *
- * @param h Hash table.
- * @param key Array of all keys needed to compute hash index.
+ * @param h     Hash table.
+ * @param key       Array of all keys needed to compute hash index.
  *
- * @return Matching item on success, NULL if there is no such item.
+ * @return      Matching item on success, NULL if there is no such item.
  */
 link_t *hash_table_find(hash_table_t *h, unsigned long key[])
 {
 ,7 → 124,8
     chain = h->op->hash(key);
     assert(chain < h->entries);
-    for (cur = h->entry[chain].next; cur != &h->entry[chain]; cur = cur->next) {
+    for (cur = h->entry[chain].next; cur != &h->entry[chain];
+        cur = cur->next) {
         if (h->op->compare(key, h->max_keys, cur)) {
             /*
              * The entry is there.
 ,9 → 141,10
  *
  * For each removed item, h->remove_callback() is called.
  *
- * @param h Hash table.
- * @param key Array of keys that will be compared against items of the hash table.
- * @param keys Number of keys in the 'key' array.
+ * @param h     Hash table.
+ * @param key       Array of keys that will be compared against items of
+ *          the hash table.
+ * @param keys      Number of keys in the 'key' array.
  */
 void hash_table_remove(hash_table_t *h, unsigned long key[], hash_count_t keys)
 {
 ,13 → 151,15
     hash_index_t chain;
     link_t *cur;
-    assert(h && h->op && h->op->hash && h->op->compare && h->op->remove_callback);
+    assert(h && h->op && h->op->hash && h->op->compare &&
+        h->op->remove_callback);
     assert(keys <= h->max_keys);
     if (keys == h->max_keys) {
         /*
-         * All keys are known, hash_table_find() can be used to find the entry.
+         * All keys are known, hash_table_find() can be used to find the
+         * entry.
          */
         cur = hash_table_find(h, key);
 ,7 → 175,8
      * Any partially matching entries are to be removed.
      */
     for (chain = 0; chain < h->entries; chain++) {
-        for (cur = h->entry[chain].next; cur != &h->entry[chain]; cur = cur->next) {
+        for (cur = h->entry[chain].next; cur != &h->entry[chain];
+            cur = cur->next) {
             if (h->op->compare(key, keys, cur)) {
                 link_t *hlp;

 /branches/network/uspace/lib/libc/include/stdio.h
 ,24 → 49,27
     int n; \
     n = snprintf(buf, sizeof(buf), fmt, ##__VA_ARGS__); \
     if (n > 0) \
-        (void) __SYSCALL3(SYS_IO, 1, (sysarg_t) buf, strlen(buf)); \
+        (void) __SYSCALL3(SYS_KLOG, 1, (sysarg_t) buf, strlen(buf)); \
 }
 extern int getchar(void);
-extern int puts(const char * str);
-extern int putchar(int c);
+extern int puts(const char *);
+extern int putchar(int);
-extern int printf(const char *fmt, ...);
-extern int sprintf(char *str, const char *fmt, ...);
-extern int snprintf(char *str, size_t size, const char *fmt, ...);
+extern int printf(const char *, ...);
+extern int asprintf(char **, const char *, ...);
+extern int sprintf(char *, const char *fmt, ...);
+extern int snprintf(char *, size_t , const char *, ...);
-extern int vprintf(const char *fmt, va_list ap);
-extern int vsprintf(char *str, const char *fmt, va_list ap);
-extern int vsnprintf(char *str, size_t size, const char *fmt, va_list ap);
+extern int vprintf(const char *, va_list);
+extern int vsprintf(char *, const char *, va_list);
+extern int vsnprintf(char *, size_t, const char *, va_list);
 #define fprintf(f, fmt, ...) printf(fmt, ##__VA_ARGS__)
+extern int rename(const char *, const char *);
 #endif
 /** @}

 /branches/network/uspace/lib/libc/include/getopt.h
 ,0 → 1,71
+/*  $NetBSD: getopt.h,v 1.10.6.1 2008/05/18 12:30:09 yamt Exp $ */
+/*-
+ * Copyright (c) 2000 The NetBSD Foundation, Inc.
+ * All rights reserved.
+ *
+ * This code is derived from software contributed to The NetBSD Foundation
+ * by Dieter Baron and Thomas Klausner.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
+ * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
+ * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+ * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
+ * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ */
+/* Ported to HelenOS August 2008 by Tim Post <echo@echoreply.us> */
+#ifndef _GETOPT_H_
+#define _GETOPT_H_
+#include <unistd.h>
+/*
+ * Gnu like getopt_long() and BSD4.4 getsubopt()/optreset extensions
+ */
+#define no_argument        0
+#define required_argument  1
+#define optional_argument  2
+struct option {
+    /* name of long option */
+    const char *name;
+    /*
+     * one of no_argument, required_argument, and optional_argument:
+     * whether option takes an argument
+     */
+    int has_arg;
+    /* if not NULL, set *flag to val when option found */
+    int *flag;
+    /* if flag not NULL, value to set *flag to; else return value */
+    int val;
+};
+/* HelenOS Port - These need to be exposed for legacy getopt() */
+extern char *optarg;
+extern int optind, opterr, optopt;
+extern int optreset;
+int getopt_long(int, char * const *, const char *,
+    const struct option *, int *);
+/* HelenOS Port : Expose legacy getopt() */
+int  getopt(int, char * const [], const char *);
+#endif /* !_GETOPT_H_ */

 /branches/network/uspace/lib/libc/include/vfs/vfs.h
 ,0 → 1,47
+/*
+ * Copyright (c) 2007 Jakub Jermar
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * - Redistributions of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * - Redistributions in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in the
+ *   documentation and/or other materials provided with the distribution.
+ * - The name of the author may not be used to endorse or promote products
+ *   derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+/** @addtogroup libc
+ * @{
+ */
+/** @file
+ */
+#ifndef LIBC_VFS_H_
+#define LIBC_VFS_H_
+#include <sys/types.h>
+extern char *absolutize(const char *, size_t *);
+extern int mount(const char *, const char *, const char *);
+#endif
+/** @}
+ */

 /branches/network/uspace/lib/libc/include/vfs/canonify.h
 ,0 → 1,45
+/*
+ * Copyright (c) 2008 Jakub Jermar
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * - Redistributions of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * - Redistributions in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in the
+ *   documentation and/or other materials provided with the distribution.
+ * - The name of the author may not be used to endorse or promote products
+ *   derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+/** @addtogroup libc
+ * @{
+ */
+/** @file
+ */
+#ifndef LIBC_VFS_CANONIFY_H_
+#define LIBC_VFS_CANONIFY_H_
+#include <sys/types.h>
+extern char *canonify(char *, size_t *);
+#endif
+/** @}
+ */

 /branches/network/uspace/lib/libc/include/string.h
 ,26 → 39,31
 #define bzero(ptr, len) memset((ptr), 0, (len))
-void * memset(void *s, int c, size_t n);
-void * memcpy(void *dest, const void *src, size_t n);
-void * memmove(void *dest, const void *src, size_t n);
+extern void * memset(void *, int, size_t);
+extern void * memcpy(void *, const void *, size_t);
+extern void * memmove(void *, const void *, size_t);
-int bcmp(const char *s1, const char *s2, size_t n);
+extern int bcmp(const char *, const char *, size_t);
-int strcmp(const char *, const char *);
-int strncmp(const char *, const char *, size_t n);
+extern int strcmp(const char *, const char *);
+extern int strncmp(const char *, const char *, size_t);
+extern int stricmp(const char *, const char *);
-char *strcpy(char *dest, const char *src);
-char *strncpy(char *dest, const char *src, size_t n);
+extern char *strcpy(char *, const char *);
+extern char *strncpy(char *, const char *, size_t);
-size_t strlen(const char *str);
+extern char *strcat(char *, const char *);
-char *strchr(const char *str, int c);
-char *strrchr(const char *str, int c);
+extern size_t strlen(const char *);
-long int strtol(const char *nptr, char **endptr, int base);
-unsigned long strtoul(const char *nptr, char **endptr, int base);
+extern char *strdup(const char *);
+extern char *strchr(const char *, int);
+extern char *strrchr(const char *, int);
+extern long int strtol(const char *, char **, int);
+extern unsigned long strtoul(const char *, char **, int);
 #endif
 /** @}

 /branches/network/uspace/lib/libc/include/ctype.h
 ,6 → 76,14
     }
 }
+static inline int tolower(int c)
+{
+    if (isupper(c))
+        return (c + ('a' - 'A' > 0 ? 'a' - 'A' : 'A' - 'a'));
+    else
+        return c;
+}
 #endif
 /** @}

/branches/network/uspace/lib/libc/include/as.h
42,6 → 42,7

extern void as_area_create(void address, size_t size, int flags);
extern int as_area_resize(void *address, size_t size, int flags);
extern int as_area_change_flags(void *address, int flags);
extern int as_area_destroy(void *address);
extern void *set_maxheapsize(size_t mhs);
extern void * as_get_mappable_page(size_t sz);

/branches/network/uspace/lib/libc/include/task.h
40,6 → 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, const char argv[]);

#endif

 /branches/network/uspace/lib/libc/include/libc.h
 ,8 → 48,7
 #define __SYSCALL6(id, p1, p2, p3, p4, p5, p6) \
     __syscall(p1, p2, p3, p4, p5, p6,id)
-extern void __main(void);
-extern void __io_init(void);
+extern void __main(void *pcb_ptr);
 extern void __exit(void);
 #endif

 /branches/network/uspace/lib/libc/include/loader/pcb.h
 ,0 → 1,74
+/*
+ * Copyright (c) 2008 Jiri Svoboda
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * - Redistributions of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * - Redistributions in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in the
+ *   documentation and/or other materials provided with the distribution.
+ * - The name of the author may not be used to endorse or promote products
+ *   derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+/** @addtogroup fs
+ * @{
+ */
+/** @file
+ * @brief Program Control Block interface.
+ */
+#ifndef LIBC_PCB_H_
+#define LIBC_PCB_H_
+#include <sys/types.h>
+typedef void (*entry_point_t)(void);
+/**
+ * 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.
+ */
+typedef struct {
+    /** Program entry point */
+    entry_point_t entry;
+    /** Number of command-line arguments */
+    int argc;
+    /** Command-line arguments */
+    char **argv;
+    /*
+     * ELF-specific data
+     */
+    /** Pointer to ELF dynamic section of the program */
+    void *dynamic;
+    /** Pointer to dynamic section of the runtime linker */
+    void *rtld_dynamic;
+    /** Runtime-linker load bias */
+    uintptr_t rtld_bias;
+} pcb_t;
+extern pcb_t *__pcb;
+#endif
+/**
+ * @}
+ */

 /branches/network/uspace/lib/libc/include/io/stream.h
 ,8 → 39,9
 #define EMFILE -17
-extern void open_stdin(void);
-extern void open_stdout(void);
+extern void open_console(void);
+extern void close_console(void);
+extern void klog_update(void);
 extern ssize_t read_stdin(void *, size_t);
 extern ssize_t write_stdout(const void *, size_t);

 /branches/network/uspace/lib/libc/include/smc.h
 ,0 → 1,45
+/*
+ * Copyright (c) 2008 Jiri Svoboda
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * - Redistributions of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * - Redistributions in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in the
+ *   documentation and/or other materials provided with the distribution.
+ * - The name of the author may not be used to endorse or promote products
+ *   derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+/** @addtogroup libc
+ * @{
+ */
+/** @file
+ */
+#ifndef LIBC_SMC_H_
+#define LIBC_SMC_H_
+#include <sys/types.h>
+extern int smc_coherence(void *address, size_t size);
+#endif
+/** @}
+ */

 /branches/network/uspace/lib/libc/include/ipc/loader.h
 ,0 → 1,50
+/*
+ * Copyright (c) 2008 Jiri Svoboda
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * - Redistributions of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * - Redistributions in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in the
+ *   documentation and/or other materials provided with the distribution.
+ * - The name of the author may not be used to endorse or promote products
+ *   derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+/** @addtogroup libcipc
+ * @{
+ */
+/** @file
+ */
+#ifndef LIBC_LOADER_H_
+#define LIBC_LOADER_H_
+#include <ipc/ipc.h>
+typedef enum {
+    LOADER_HELLO = IPC_FIRST_USER_METHOD,
+    LOADER_SET_PATHNAME,
+    LOADER_SET_ARGS,
+    LOADER_RUN
+} fb_request_t;
+#endif
+/** @}
+ */

 /branches/network/uspace/lib/libc/include/ipc/devmap.h
 ,0 → 1,99
+/*
+ * Copyright (c) 2007 Josef Cejka
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * - Redistributions of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * - Redistributions in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in the
+ *   documentation and/or other materials provided with the distribution.
+ * - The name of the author may not be used to endorse or promote products
+ *   derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+/** @addtogroup devmap
+ * @{
+ */
+#ifndef DEVMAP_DEVMAP_H_
+#define DEVMAP_DEVMAP_H_
+#include <ipc/ipc.h>
+#include <libadt/list.h>
+#define DEVMAP_NAME_MAXLEN 512
+typedef enum {
+    DEVMAP_DRIVER_REGISTER = IPC_FIRST_USER_METHOD,
+    DEVMAP_DRIVER_UNREGISTER,
+    DEVMAP_DEVICE_REGISTER,
+    DEVMAP_DEVICE_UNREGISTER,
+    DEVMAP_DEVICE_GET_NAME,
+    DEVMAP_DEVICE_GET_HANDLE
+} devmap_request_t;
+/** Representation of device driver.
+ * Each driver is responsible for a set of devices.
+ */
+typedef struct {
+        /** Pointers to previous and next drivers in linked list */
+    link_t drivers;
+        /** Pointer to the linked list of devices controlled by
+         * this driver */
+    link_t devices;
+        /** Phone asociated with this driver */
+    ipcarg_t phone;
+        /** Device driver name */
+    char *name;
+        /** Futex for list of devices owned by this driver */
+    atomic_t devices_futex;
+} devmap_driver_t;
+/** Info about registered device
+ *
+ */
+typedef struct {
+        /** Pointer to the previous and next device in the list of all devices */
+    link_t devices;
+        /** Pointer to the previous and next device in the list of devices
+         owned by one driver */
+    link_t driver_devices;
+        /** Unique device identifier  */
+    int handle;
+        /** Device name */
+    char *name;
+        /** Device driver handling this device */
+    devmap_driver_t *driver;
+} devmap_device_t;
+/** Interface provided by devmap.
+ * Every process that connects to devmap must ask one of following
+ * interfaces otherwise connection will be refused.
+ */
+typedef enum {
+        /** Connect as device driver */
+    DEVMAP_DRIVER = 1,
+        /** Connect as client */
+    DEVMAP_CLIENT,
+        /** Create new connection to instance of device that
+         * is specified by second argument of call. */
+    DEVMAP_CONNECT_TO_DEVICE
+} devmap_interface_t;
+#endif

/branches/network/uspace/lib/libc/include/ipc/services.h
42,7 → 42,6
SERVICE_KEYBOARD,
SERVICE_VIDEO,
SERVICE_CONSOLE,
SERVICE_RD,
SERVICE_VFS,
SERVICE_DEVMAP
} services_t;

 /branches/network/uspace/lib/libc/include/ipc/ipc.h
 ,26 → 130,26
     ipc_call_sync_fast((phoneid), (method), (arg1), (arg2), (arg3), \
         (res1), (res2), (res3), (res4), (res5))
 #define ipc_call_sync_4_0(phoneid, method, arg1, arg2, arg3, arg4) \
-    ipc_call_sync_slow((phoneid), (method), (arg1), (arg2), (arg3), (arg4), \
+    ipc_call_sync_slow((phoneid), (method), (arg1), (arg2), (arg3), (arg4), 0, \
 , 0, 0, 0, 0)
 #define ipc_call_sync_4_1(phoneid, method, arg1, arg2, arg3, arg4, res1) \
-    ipc_call_sync_slow((phoneid), (method), (arg1), (arg2), (arg3), (arg4), \
+    ipc_call_sync_slow((phoneid), (method), (arg1), (arg2), (arg3), (arg4), 0, \
     (res1), 0, 0, 0, 0)
 #define ipc_call_sync_4_2(phoneid, method, arg1, arg2, arg3, arg4, res1, res2) \
-    ipc_call_sync_slow((phoneid), (method), (arg1), (arg2), (arg3), (arg4), \
+    ipc_call_sync_slow((phoneid), (method), (arg1), (arg2), (arg3), (arg4), 0, \
     (res1), (res2), 0, 0, 0)
 #define ipc_call_sync_4_3(phoneid, method, arg1, arg2, arg3, arg4, res1, res2, \
     res3) \
     ipc_call_sync_slow((phoneid), (method), (arg1), (arg2), (arg3), \
-        (arg4), (res1), (res2), (res3), 0, 0)
+        (arg4), 0, (res1), (res2), (res3), 0, 0)
 #define ipc_call_sync_4_4(phoneid, method, arg1, arg2, arg3, arg4, res1, res2, \
     res3, res4) \
     ipc_call_sync_slow((phoneid), (method), (arg1), (arg2), (arg3), \
-        (arg4), (res1), (res2), (res3), (res4), 0)
+        (arg4), 0, (res1), (res2), (res3), (res4), 0)
 #define ipc_call_sync_4_5(phoneid, method, arg1, arg2, arg3, arg4, res1, res2, \
     res3, res4, res5) \
     ipc_call_sync_slow((phoneid), (method), (arg1), (arg2), (arg3), \
-        (arg4), (res1), (res2), (res3), (res4), (res5))
+        (arg4), 0, (res1), (res2), (res3), (res4), (res5))
 #define ipc_call_sync_5_0(phoneid, method, arg1, arg2, arg3, arg4, arg5) \
     ipc_call_sync_slow((phoneid), (method), (arg1), (arg2), (arg3), (arg4), \
         (arg5), 0, 0, 0, 0, 0)

 /branches/network/uspace/lib/libc/include/libadt/list.h
 ,6 → 112,18
     head->prev = link;
 }
+/** Insert item before another item in doubly-linked circular list. */
+static inline void list_insert_before(link_t *l, link_t *r)
+{
+    list_append(l, r);
+}
+/** Insert item after another item in doubly-linked circular list. */
+static inline void list_insert_after(link_t *r, link_t *l)
+{
+    list_prepend(l, r);
+}
 /** Remove item from doubly-linked circular list
  *
  * Remove item from doubly-linked circular list.

/branches/network/uspace/lib/libc/include/libadt/hash_table.h
86,6 → 86,7
extern void hash_table_insert(hash_table_t , unsigned long [], link_t );
extern link_t hash_table_find(hash_table_t , unsigned long []);
extern void hash_table_remove(hash_table_t *, unsigned long [], hash_count_t);
extern void hash_table_destroy(hash_table_t *);

#endif

 /branches/network/uspace/lib/libc/include/byteorder.h
 ,0 → 1,96
+/*
+ * Copyright (c) 2005 Jakub Jermar
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * - Redistributions of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * - Redistributions in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in the
+ *   documentation and/or other materials provided with the distribution.
+ * - The name of the author may not be used to endorse or promote products
+ *   derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+/** @addtogroup libc
+ * @{
+ */
+/** @file
+ */
+#ifndef LIBC_BYTEORDER_H_
+#define LIBC_BYTEORDER_H_
+#include <libarch/byteorder.h>
+#include <stdint.h>
+#if !(defined(ARCH_IS_BIG_ENDIAN) ^ defined(ARCH_IS_LITTLE_ENDIAN))
+#error The architecture must be either big-endian or little-endian.
+#endif
+#ifdef ARCH_IS_BIG_ENDIAN
+#define uint16_t_le2host(n)     uint16_t_byteorder_swap(n)
+#define uint32_t_le2host(n)     uint32_t_byteorder_swap(n)
+#define uint64_t_le2host(n)     uint64_t_byteorder_swap(n)
+#define uint16_t_be2host(n)     (n)
+#define uint32_t_be2host(n)     (n)
+#define uint64_t_be2host(n)     (n)
+#else
+#define uint16_t_le2host(n)     (n)
+#define uint32_t_le2host(n)     (n)
+#define uint64_t_le2host(n)     (n)
+#define uint16_t_be2host(n)     uint16_t_byteorder_swap(n)
+#define uint32_t_be2host(n)     uint32_t_byteorder_swap(n)
+#define uint64_t_be2host(n)     uint64_t_byteorder_swap(n)
+#endif
+static inline uint64_t uint64_t_byteorder_swap(uint64_t n)
+{
+    return ((n & 0xff) << 56) |
+        ((n & 0xff00) << 40) |
+        ((n & 0xff0000) << 24) |
+        ((n & 0xff000000LL) << 8) |
+        ((n & 0xff00000000LL) >> 8) |
+        ((n & 0xff0000000000LL) >> 24) |
+        ((n & 0xff000000000000LL) >> 40) |
+        ((n & 0xff00000000000000LL) >> 56);
+}
+static inline uint32_t uint32_t_byteorder_swap(uint32_t n)
+{
+    return ((n & 0xff) << 24) |
+        ((n & 0xff00) << 8) |
+        ((n & 0xff0000) >> 8) |
+        ((n & 0xff000000) >> 24);
+}
+static inline uint16_t uint16_t_byteorder_swap(uint16_t n)
+{
+    return ((n & 0xff) << 8) |
+        ((n & 0xff00) >> 8);
+}
+#endif
+/** @}
+ */

 /branches/network/uspace/lib/libc/include/setjmp.h
 ,0 → 1,49
+/*
+ * Copyright (c) 2008 Josef Cejka
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * - Redistributions of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * - Redistributions in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in the
+ *   documentation and/or other materials provided with the distribution.
+ * - The name of the author may not be used to endorse or promote products
+ *   derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+/** @addtogroup libc
+ * @{
+ */
+/** @file
+ */
+#ifndef LIBC_SETJMP_H_
+#define LIBC_SETJMP_H_
+#include <libarch/fibril.h>
+typedef context_t jmp_buf;
+extern int setjmp(jmp_buf env);
+extern void longjmp(jmp_buf env,int val) __attribute__((__noreturn__));
+#endif
+/** @}
+ */

 /branches/network/uspace/lib/libc/include/unistd.h
 ,7 → 38,10
 #include <sys/types.h>
 #include <libarch/config.h>
+#ifndef NULL
 #define NULL 0
+#endif
 #define getpagesize()     (PAGE_SIZE)
 #define SEEK_SET    0
 ,6 → 53,10
 extern off_t lseek(int, off_t, int);
 extern int ftruncate(int, off_t);
 extern int close(int);
+extern int unlink(const char *);
+extern int rmdir(const char *);
+extern int chdir(const char *);
+extern char *getcwd(char *buf, size_t);
 extern void _exit(int status);
 extern void *sbrk(ssize_t incr);

 /branches/network/uspace/lib/libc/include/errno.h
 ,6 → 42,10
 #define ENOTDIR     (-258)
 #define ENOSPC      (-259)
 #define EEXIST      (-260)
+#define ENOTEMPTY   (-261)
+#define EBADF       (-262)
+#define ERANGE      (-263)
+#define EXDEV       (-264)
 #endif

 /branches/network/uspace/lib/libc/Makefile
 ,10 → 51,13
     generic/cap.c \
     generic/string.c \
     generic/fibril.c \
+    generic/pcb.c \
+    generic/smc.c \
     generic/thread.c \
     generic/tls.c \
     generic/task.c \
     generic/futex.c \
+    generic/io/asprintf.c \
     generic/io/io.c \
     generic/io/printf.c \
     generic/io/stream.c \
 ,6 → 71,7
     generic/sysinfo.c \
     generic/ipc.c \
     generic/async.c \
+    generic/getopt.c \
     generic/libadt/list.o \
     generic/libadt/hash_table.o \
     generic/time.c \
 ,7 → 78,8
     generic/err.c \
     generic/stdlib.c \
     generic/mman.c \
-    generic/vfs.c
+    generic/vfs/vfs.c \
+    generic/vfs/canonify.c
 ARCH_SOURCES += \
     arch/$(ARCH)/src/entry.s \

 /branches/network/uspace/lib/libfs/libfs.c
 ,5 → 1,5
 /*
- * Copyright (c) 2007 Jakub Jermar
+ * Copyright (c) 2008 Jakub Jermar
  * All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
 ,10 → 36,13
 #include "libfs.h"
 #include "../../srv/vfs/vfs.h"
+#include "../../srv/rd/rd.h"
 #include <errno.h>
 #include <async.h>
 #include <ipc/ipc.h>
 #include <as.h>
+#include <assert.h>
+#include <dirent.h>
 /** Register file system server.
  *
 ,5 → 123,270
     return IPC_GET_RETVAL(answer);
 }
+/** Lookup VFS triplet by name in the file system name space.
+ *
+ * The path passed in the PLB must be in the canonical file system path format
+ * as returned by the canonify() function.
+ *
+ * @param ops       libfs operations structure with function pointers to
+ *          file system implementation
+ * @param fs_handle File system handle of the file system where to perform
+ *          the lookup.
+ * @param rid       Request ID of the VFS_LOOKUP request.
+ * @param request   VFS_LOOKUP request data itself.
+ */
+void libfs_lookup(libfs_ops_t *ops, fs_handle_t fs_handle, ipc_callid_t rid,
+    ipc_call_t *request)
+{
+    unsigned next = IPC_GET_ARG1(*request);
+    unsigned last = IPC_GET_ARG2(*request);
+    dev_handle_t dev_handle = IPC_GET_ARG3(*request);
+    int lflag = IPC_GET_ARG4(*request);
+    fs_index_t index = IPC_GET_ARG5(*request); /* when L_LINK specified */
+    char component[NAME_MAX + 1];
+    int len;
+    if (last < next)
+        last += PLB_SIZE;
+    void *par = NULL;
+    void *cur = ops->root_get(dev_handle);
+    void *tmp = NULL;
+    if (ops->plb_get_char(next) == '/')
+        next++;     /* eat slash */
+    while (next <= last && ops->has_children(cur)) {
+        /* collect the component */
+        len = 0;
+        while ((next <= last) &&  (ops->plb_get_char(next) != '/')) {
+            if (len + 1 == NAME_MAX) {
+                /* component length overflow */
+                ipc_answer_0(rid, ENAMETOOLONG);
+                goto out;
+            }
+            component[len++] = ops->plb_get_char(next);
+            next++; /* process next character */
+        }
+        assert(len);
+        component[len] = '\0';
+        next++;     /* eat slash */
+        /* match the component */
+        tmp = ops->match(cur, component);
+        /* handle miss: match amongst siblings */
+        if (!tmp) {
+            if (next <= last) {
+                /* there are unprocessed components */
+                ipc_answer_0(rid, ENOENT);
+                goto out;
+            }
+            /* miss in the last component */
+            if (lflag & (L_CREATE | L_LINK)) {
+                /* request to create a new link */
+                if (!ops->is_directory(cur)) {
+                    ipc_answer_0(rid, ENOTDIR);
+                    goto out;
+                }
+                void *nodep;
+                if (lflag & L_CREATE)
+                    nodep = ops->create(lflag);
+                else
+                    nodep = ops->node_get(dev_handle,
+                        index);
+                if (nodep) {
+                    if (!ops->link(cur, nodep, component)) {
+                        if (lflag & L_CREATE) {
+                            (void)ops->destroy(
+                                nodep);
+                        }
+                        ipc_answer_0(rid, ENOSPC);
+                    } else {
+                        ipc_answer_5(rid, EOK,
+                            fs_handle, dev_handle,
+                            ops->index_get(nodep),
+                            ops->size_get(nodep),
+                            ops->lnkcnt_get(nodep));
+                        ops->node_put(nodep);
+                    }
+                } else {
+                    ipc_answer_0(rid, ENOSPC);
+                }
+                goto out;
+            } else if (lflag & L_PARENT) {
+                /* return parent */
+                ipc_answer_5(rid, EOK, fs_handle, dev_handle,
+                    ops->index_get(cur), ops->size_get(cur),
+                    ops->lnkcnt_get(cur));
+            }
+            ipc_answer_0(rid, ENOENT);
+            goto out;
+        }
+        if (par)
+            ops->node_put(par);
+        /* descend one level */
+        par = cur;
+        cur = tmp;
+        tmp = NULL;
+    }
+    /* handle miss: excessive components */
+    if (next <= last && !ops->has_children(cur)) {
+        if (lflag & (L_CREATE | L_LINK)) {
+            if (!ops->is_directory(cur)) {
+                ipc_answer_0(rid, ENOTDIR);
+                goto out;
+            }
+            /* collect next component */
+            len = 0;
+            while (next <= last) {
+                if (ops->plb_get_char(next) == '/') {
+                    /* more than one component */
+                    ipc_answer_0(rid, ENOENT);
+                    goto out;
+                }
+                if (len + 1 == NAME_MAX) {
+                    /* component length overflow */
+                    ipc_answer_0(rid, ENAMETOOLONG);
+                    goto out;
+                }
+                component[len++] = ops->plb_get_char(next);
+                next++; /* process next character */
+            }
+            assert(len);
+            component[len] = '\0';
+            void *nodep;
+            if (lflag & L_CREATE)
+                nodep = ops->create(lflag);
+            else
+                nodep = ops->node_get(dev_handle, index);
+            if (nodep) {
+                if (!ops->link(cur, nodep, component)) {
+                    if (lflag & L_CREATE)
+                        (void)ops->destroy(nodep);
+                    ipc_answer_0(rid, ENOSPC);
+                } else {
+                    ipc_answer_5(rid, EOK,
+                        fs_handle, dev_handle,
+                        ops->index_get(nodep),
+                        ops->size_get(nodep),
+                        ops->lnkcnt_get(nodep));
+                    ops->node_put(nodep);
+                }
+            } else {
+                ipc_answer_0(rid, ENOSPC);
+            }
+            goto out;
+        }
+        ipc_answer_0(rid, ENOENT);
+        goto out;
+    }
+    /* handle hit */
+    if (lflag & L_PARENT) {
+        ops->node_put(cur);
+        cur = par;
+        par = NULL;
+        if (!cur) {
+            ipc_answer_0(rid, ENOENT);
+            goto out;
+        }
+    }
+    if (lflag & L_UNLINK) {
+        unsigned old_lnkcnt = ops->lnkcnt_get(cur);
+        int res = ops->unlink(par, cur);
+        ipc_answer_5(rid, (ipcarg_t)res, fs_handle, dev_handle,
+            ops->index_get(cur), ops->size_get(cur), old_lnkcnt);
+        goto out;
+    }
+    if (((lflag & (L_CREATE | L_EXCLUSIVE)) == (L_CREATE | L_EXCLUSIVE)) ||
+        (lflag & L_LINK)) {
+        ipc_answer_0(rid, EEXIST);
+        goto out;
+    }
+    if ((lflag & L_FILE) && (ops->is_directory(cur))) {
+        ipc_answer_0(rid, EISDIR);
+        goto out;
+    }
+    if ((lflag & L_DIRECTORY) && (ops->is_file(cur))) {
+        ipc_answer_0(rid, ENOTDIR);
+        goto out;
+    }
+    ipc_answer_5(rid, EOK, fs_handle, dev_handle, ops->index_get(cur),
+        ops->size_get(cur), ops->lnkcnt_get(cur));
+out:
+    if (par)
+        ops->node_put(par);
+    if (cur)
+        ops->node_put(cur);
+    if (tmp)
+        ops->node_put(tmp);
+}
+/** Read data from a block device.
+ *
+ * @param phone     Phone to be used to communicate with the device.
+ * @param buffer    Communication buffer shared with the device.
+ * @param bufpos    Pointer to the first unread valid offset within the
+ *          communication buffer.
+ * @param buflen    Pointer to the number of unread bytes that are ready in
+ *          the communication buffer.
+ * @param pos       Device position to be read.
+ * @param dst       Destination buffer.
+ * @param size      Size of the destination buffer.
+ * @param block_size    Block size to be used for the transfer.
+ *
+ * @return      True on success, false on failure.
+ */
+bool libfs_blockread(int phone, void *buffer, off_t *bufpos, size_t *buflen,
+    off_t *pos, void *dst, size_t size, size_t block_size)
+{
+    off_t offset = 0;
+    size_t left = size;
+    while (left > 0) {
+        size_t rd;
+        if (*bufpos + left < *buflen)
+            rd = left;
+        else
+            rd = *buflen - *bufpos;
+        if (rd > 0) {
+            /*
+             * Copy the contents of the communication buffer to the
+             * destination buffer.
+             */
+            memcpy(dst + offset, buffer + *bufpos, rd);
+            offset += rd;
+            *bufpos += rd;
+            *pos += rd;
+            left -= rd;
+        }
+        if (*bufpos == *buflen) {
+            /* Refill the communication buffer with a new block. */
+            ipcarg_t retval;
+            int rc = async_req_2_1(phone, RD_READ_BLOCK,
+                *pos / block_size, block_size, &retval);
+            if ((rc != EOK) || (retval != EOK))
+                return false;
+            *bufpos = 0;
+            *buflen = block_size;
+        }
+    }
+    return true;
+}
 /** @}
  */

 /branches/network/uspace/lib/libfs/libfs.h
 ,6 → 42,24
 #include <async.h>
 typedef struct {
+    void * (* match)(void *, const char *);
+    void * (* node_get)(dev_handle_t, fs_index_t);
+    void (* node_put)(void *);
+    void * (* create)(int);
+    int (* destroy)(void *);
+    bool (* link)(void *, void *, const char *);
+    int (* unlink)(void *, void *);
+    fs_index_t (* index_get)(void *);
+    size_t (* size_get)(void *);
+    unsigned (* lnkcnt_get)(void *);
+    bool (* has_children)(void *);
+    void *(* root_get)(dev_handle_t);
+    char (* plb_get_char)(unsigned pos);
+    bool (* is_directory)(void *);
+    bool (* is_file)(void *);
+} libfs_ops_t;
+typedef struct {
     int fs_handle;      /**< File system handle. */
     ipcarg_t vfs_phonehash; /**< Initial VFS phonehash. */
     uint8_t *plb_ro;    /**< Read-only PLB view. */
 ,12 → 67,11
 extern int fs_register(int, fs_reg_t *, vfs_info_t *, async_client_conn_t);
-extern int block_read(int, unsigned long, void *);
-extern int block_write(int, unsigned long, void *);
+extern void libfs_lookup(libfs_ops_t *, fs_handle_t, ipc_callid_t, ipc_call_t *);
-extern void node_add_mp(int, unsigned long);
-extern void node_del_mp(int, unsigned long);
-extern bool node_is_mp(int, unsigned long);
+extern bool libfs_blockread(int, void *, off_t *, size_t *, off_t *, void *,
+    size_t, size_t);
 #endif
 /** @}

 /branches/network/uspace/lib/softfloat/include/sftypes.h
 ,7 → 35,7
 #ifndef __SFTYPES_H__
 #define __SFTYPES_H__
-#include <endian.h>
+#include <byteorder.h>
 #include <stdint.h>
 typedef union {
 ,17 → 43,17
     uint32_t binary;
     struct  {
-        #if __BYTE_ORDER == __BIG_ENDIAN
+#if defined(ARCH_IS_BIG_ENDIAN)
         uint32_t sign:1;
         uint32_t exp:8;
         uint32_t fraction:23;
-        #elif __BYTE_ORDER == __LITTLE_ENDIAN
+#elif defined(ARCH_IS_LITTLE_ENDIAN)
         uint32_t fraction:23;
         uint32_t exp:8;
         uint32_t sign:1;
-        #else
-            #error "Unknown endians."
-        #endif
+#else
+#error "Unknown endians."
+#endif
         } parts __attribute__ ((packed));
     } float32;
 ,17 → 62,17
     uint64_t binary;
     struct  {
-        #if __BYTE_ORDER == __BIG_ENDIAN
+#if defined(ARCH_IS_BIG_ENDIAN)
         uint64_t sign:1;
         uint64_t exp:11;
         uint64_t fraction:52;
-        #elif __BYTE_ORDER == __LITTLE_ENDIAN
+#elif defined(ARCH_IS_LITTLE_ENDIAN)
         uint64_t fraction:52;
         uint64_t exp:11;
         uint64_t sign:1;
-        #else
-            #error "Unknown endians."
-        #endif
+#else
+#error "Unknown endians."
+#endif
         } parts __attribute__ ((packed));
     } float64;
 ,7 → 81,10
 #define FLOAT64_MAX
 #define FLOAT64_MIN
-/* For recognizing NaNs or infinity use isFloat32NaN and is Float32Inf, comparing with this constants is not sufficient */
+/*
+ * For recognizing NaNs or infinity use isFloat32NaN and is Float32Inf,
+ * comparing with these constants is not sufficient.
+ */
 #define FLOAT32_NAN 0x7FC00001
 #define FLOAT32_SIGNAN 0x7F800001
 #define FLOAT32_INF 0x7F800000

Subversion Repositories HelenOS

Compare Revisions

Ignore whitespace Rev 3369 → Rev 3386