Changes in / [2d0c3a6:527298a] in mainline

Files:

• HelenOS.config (modified) (2 diffs)
• boot/Makefile (modified) (1 diff)
• boot/Makefile.build (modified) (1 diff)
• boot/arch/arm32/Makefile.inc (modified) (1 diff)
• boot/arch/arm32/src/asm.S (modified) (2 diffs)
• boot/arch/ia64/Makefile.inc (modified) (1 diff)
• boot/arch/ia64/src/asm.S (modified) (2 diffs)
• boot/arch/mips32/Makefile.inc (modified) (1 diff)
• boot/arch/mips32/src/asm.S (modified) (2 diffs)
• boot/arch/ppc32/Makefile.inc (modified) (1 diff)
• boot/arch/ppc32/src/asm.S (modified) (2 diffs)
• boot/arch/sparc64/Makefile.inc (modified) (1 diff)
• boot/arch/sparc64/src/asm.S (modified) (2 diffs)
• boot/generic/src/memstr.c (deleted)
• contrib/conf/ia32-qe.sh (modified) (1 diff)
• contrib/conf/mips32-gx.sh (modified) (1 diff)
• kernel/Makefile (modified) (2 diffs)
• kernel/arch/abs32le/src/debug/stacktrace.c (modified) (1 diff)
• kernel/arch/amd64/_link.ld.in (modified) (1 diff)
• kernel/arch/amd64/include/pm.h (modified) (2 diffs)
• kernel/arch/amd64/src/asm.S (modified) (1 diff)
• kernel/arch/amd64/src/boot/boot.S (modified) (4 diffs)
• kernel/arch/amd64/src/boot/vesa_ret.inc (modified) (2 diffs)
• kernel/arch/amd64/src/ddi/ddi.c (modified) (1 diff)
• kernel/arch/amd64/src/debug/stacktrace.c (modified) (3 diffs)
• kernel/arch/amd64/src/pm.c (modified) (2 diffs)
• kernel/arch/amd64/src/smp/ap.S (modified) (2 diffs)
• kernel/arch/amd64/src/syscall.c (modified) (1 diff)
• kernel/arch/amd64/src/userspace.c (modified) (1 diff)
• kernel/arch/arm32/src/debug/stacktrace.c (modified) (3 diffs)
• kernel/arch/ia32/include/bios/bios.h (modified) (1 diff)
• kernel/arch/ia32/include/mm/as.h (modified) (1 diff)
• kernel/arch/ia32/include/mm/page.h (modified) (2 diffs)
• kernel/arch/ia32/include/pm.h (modified) (2 diffs)
• kernel/arch/ia32/src/asm.S (modified) (4 diffs)
• kernel/arch/ia32/src/bios/bios.c (modified) (1 diff)
• kernel/arch/ia32/src/boot/boot.S (modified) (3 diffs)
• kernel/arch/ia32/src/boot/vesa_real.inc (modified) (2 diffs)
• kernel/arch/ia32/src/boot/vesa_ret.inc (modified) (2 diffs)
• kernel/arch/ia32/src/ddi/ddi.c (modified) (1 diff)
• kernel/arch/ia32/src/debug/stacktrace.c (modified) (1 diff)
• kernel/arch/ia32/src/mm/frame.c (modified) (3 diffs)
• kernel/arch/ia32/src/pm.c (modified) (4 diffs)
• kernel/arch/ia32/src/proc/scheduler.c (modified) (1 diff)
• kernel/arch/ia32/src/syscall.c (modified) (1 diff)
• kernel/arch/ia32/src/userspace.c (modified) (1 diff)
• kernel/arch/ia64/src/debug/stacktrace.c (modified) (1 diff)
• kernel/arch/mips32/include/debugger.h (modified) (1 diff)
• kernel/arch/mips32/src/debug/stacktrace.c (modified) (1 diff)
• kernel/arch/mips32/src/debug/stacktrace_asm.S (modified) (1 diff)
• kernel/arch/mips32/src/debugger.c (modified) (1 diff)
• kernel/arch/ppc32/src/debug/stacktrace.c (modified) (1 diff)
• kernel/arch/sparc64/src/debug/stacktrace.c (modified) (4 diffs)
• kernel/generic/include/macros.h (modified) (2 diffs)
• kernel/generic/include/stacktrace.h (modified) (3 diffs)
• kernel/generic/src/debug/stacktrace.c (modified) (6 diffs)
• kernel/generic/src/main/main.c (modified) (2 diffs)
• kernel/generic/src/mm/frame.c (modified) (6 diffs)
• tools/mkfat.py (modified) (3 diffs)
• uspace/Makefile.common (modified) (1 diff)
• uspace/app/klog/klog.c (modified) (3 diffs)
• uspace/lib/c/generic/io/io.c (modified) (1 diff)
• uspace/lib/c/include/stdio.h (modified) (1 diff)
• uspace/srv/fs/fat/fat.h (modified) (2 diffs)
• uspace/srv/fs/fat/fat_fat.c (modified) (19 diffs)
• uspace/srv/fs/fat/fat_fat.h (modified) (1 diff)
• uspace/srv/fs/fat/fat_ops.c (modified) (50 diffs)
• uspace/srv/fs/tmpfs/tmpfs_ops.c (modified) (1 diff)

HelenOS.config

@@ -498 +498 @@
 @ "1152x720"
 @ "1152x864"
-@ "1280x720"
-@ "1280x800"
 @ "1280x960"
 @ "1280x1024"
@@ -546 +544 @@
 ! CONFIG_BAREBONE (n/y)
 
-% Line debugging information
-! [CONFIG_STRIP_BINARIES!=y] CONFIG_LINE_DEBUG (n/y)

boot/Makefile

@@ -48 +48 @@
 endif
 ifeq ($(RDFMT),fat)
-        $(MKFAT) 1048576 $(DIST_PATH) $@
+        $(MKFAT) $(DIST_PATH) $@
 endif
 

boot/Makefile.build

@@ -61 +61 @@
         GCC_CFLAGS += -Werror
         ICC_CFLAGS += -Werror
-endif
-
-ifeq ($(CONFIG_LINE_DEBUG),y)
-        GCC_CFLAGS += -g
-        ICC_CFLAGS += -g
-        SUNCC_CFLAGS += -g
-        CLANG_CFLAGS += -g
 endif
 

boot/arch/arm32/Makefile.inc

@@ -55 +55 @@
         $(COMPS_C) \
         genarch/src/division.c \
-        generic/src/memstr.c \
         generic/src/printf_core.c \
         generic/src/vprintf.c \

boot/arch/arm32/src/asm.S

@@ -35 +35 @@
 .global boot_stack
 .global halt
+.global memcpy
 .global jump_to_kernel
 
@@ -54 +55 @@
         b halt
 
+memcpy:
+        add r3, r1, #3
+        bic r3, r3, #3
+        cmp r1, r3
+        stmdb sp!, {r4, r5, lr}
+        mov r5, r0
+        beq 4f
+        
+        1:
+                cmp r2, #0
+                movne ip, #0
+                beq 3f
+        
+        2:
+                ldrb r3, [ip, r1]
+                strb r3, [ip, r0]
+                add ip, ip, #1
+                cmp ip, r2
+                bne 2b
+        
+        3:
+                mov r0, r5
+                ldmia sp!, {r4, r5, pc}
+        
+        4:
+                add r3, r0, #3
+                bic r3, r3, #3
+                cmp r0, r3
+                bne 1b
+                movs r4, r2, lsr #2
+                moveq lr, r4
+                beq 6f
+                mov lr, #0
+                mov ip, lr
+        
+        5:
+                ldr r3, [ip, r1]
+                add lr, lr, #1
+                cmp lr, r4
+                str r3, [ip, r0]
+                add ip, ip, #4
+                bne 5b
+        
+        6:
+                ands r4, r2, #3
+                beq 3b
+                mov r3, lr, lsl #2
+                add r0, r3, r0
+                add ip, r3, r1
+                mov r2, #0
+        
+        7:
+                ldrb r3, [r2, ip]
+                strb r3, [r2, r0]
+                add r2, r2, #1
+                cmp r2, r4
+                bne 7b
+                b 3b
+
 jump_to_kernel:
         #

boot/arch/ia64/Makefile.inc

@@ -49 +49 @@
         genarch/src/division.c \
         generic/src/balloc.c \
-        generic/src/memstr.c \
         generic/src/printf_core.c \
         generic/src/vprintf.c \

boot/arch/ia64/src/asm.S

@@ -1 +1 @@
 #
 # Copyright (c) 2006 Martin Decky
-# Copyright (c) 2006 Jakub Jermar
+# Copyright (c) 2006 Jakub Jermar 
 # All rights reserved.
 #
@@ -39 +39 @@
         br halt
 
+memcpy:
+        alloc loc0 = ar.pfs, 3, 1, 0, 0
+
+        adds r14 = 7, in1
+        mov r2 = ar.lc
+        mov r8 = in0 ;;
+        and r14 = -8, r14 ;;
+        cmp.ne p6, p7 = r14, in1
+(p7)    br.cond.dpnt 3f ;;
+0:
+        cmp.ne p6, p7 = 0, in2
+(p7)    br.cond.dpnt 2f ;;
+(p6)    adds r14 = -1, in2
+(p6)    mov r16 = r0
+(p6)    mov r17 = r0 ;;
+(p6)    mov ar.lc = r14
+1:
+        add r14 = r16, in1 
+        add r15 = r16, in0
+        adds r17 = 1, r17 ;;
+        ld1 r14 = [r14]
+        mov r16 = r17 ;;
+        st1 [r15] = r14
+        br.cloop.sptk.few 1b ;;
+2:
+        mov ar.lc = r2
+        mov ar.pfs = loc0
+        br.ret.sptk.many rp
+3:
+        adds r14 = 7, in0 ;;
+        and r14 = -8, r14 ;;
+        cmp.eq p6, p7 = r14, in0
+(p7)    br.cond.dptk 0b
+        shr.u r18 = in2, 3 ;;
+        cmp.ne p6, p7 = 0, r18
+(p7)    br.cond.dpnt 5f ;;
+(p6)    adds r14 = -1, r18
+(p6)    mov r16 = r0
+(p6)    mov r17 = r0 ;;
+(p6)    mov ar.lc = r14
+4:
+        shladd r14 = r16, 3, r0
+        adds r16 = 1, r17 ;;
+        add r15 = in1, r14
+        add r14 = in0, r14
+        mov r17 = r16 ;;
+        ld8 r15 = [r15] ;;
+        st8 [r14] = r15
+        br.cloop.sptk.few 4b
+5:
+        and r15 = 7, in2
+        shladd r14 = r18, 3, r0
+        mov r16 = r0
+        mov r18 = r0 ;;
+        cmp.eq p6, p7 = 0, r15
+        add in0 = r14, in0
+        adds r15 = -1, r15
+        add r17 = r14, in1 
+(p6)    br.cond.dpnt 2b ;;
+        mov ar.lc = r15
+6:
+        add r14 = r16, r17
+        add r15 = r16, in0
+        adds r16 = 1, r18 ;;
+        ld1 r14 = [r14]
+        mov r18 = r16 ;;
+        st1 [r15] = r14
+        br.cloop.sptk.few 6b ;;
+        mov ar.lc = r2
+        mov ar.pfs = loc0
+        br.ret.sptk.many rp
+
 jump_to_kernel:
         alloc loc0 = ar.pfs, 1, 1, 0, 0

boot/arch/mips32/Makefile.inc

@@ -61 +61 @@
         genarch/src/division.c \
         genarch/src/multiplication.c \
-        generic/src/memstr.c \
         generic/src/printf_core.c \
         generic/src/vprintf.c \

boot/arch/mips32/src/asm.S

@@ -36 +36 @@
 .global start
 .global halt
+.global memcpy
 .global jump_to_kernel
 
@@ -125 +126 @@
         j halt
         nop
+
+memcpy:
+        addiu $v0, $a1, 3
+        li $v1, -4
+        and $v0, $v0, $v1
+        beq $a1, $v0, 3f
+        move $t0, $a0
+        move $t2, $a0
+        
+        0:
+                beq $a2, $zero, 2f
+                move $a3, $zero
+        
+        1:
+                addu $v0, $a1, $a3
+                lbu $a0, 0($v0)
+                addu $v1, $t0, $a3
+                addiu $a3, $a3, 1
+                bne $a3, $a2, 1b
+                sb $a0, 0($v1)
+        
+        2:
+                jr $ra
+                move $v0, $t2
+        
+        3:
+                addiu $v0, $a0, 3
+                and $v0, $v0, $v1
+                bne $a0, $v0, 0b
+                srl $t1, $a2, 2
+                
+                beq $t1, $zero, 5f
+                move $a3, $zero
+                
+                move $a3, $zero
+                move $a0, $zero
+        
+        4:
+                addu $v0, $a1, $a0
+                lw $v1, 0($v0)
+                addiu $a3, $a3, 1
+                addu $v0, $t0, $a0
+                sw $v1, 0($v0)
+                bne $a3, $t1, 4b
+                addiu $a0, $a0, 4
+        
+        5:
+                andi $a2, $a2, 0x3
+                beq $a2, $zero, 2b
+                nop
+                
+                sll $v0, $a3, 2
+                addu $t1, $v0, $t0
+                move $a3, $zero
+                addu $t0, $v0, $a1
+        
+        6:
+                addu $v0, $t0, $a3
+                lbu $a0, 0($v0)
+                addu $v1, $t1, $a3
+                addiu $a3, $a3, 1
+                bne $a3, $a2, 6b
+                sb $a0, 0($v1)
+                
+                jr $ra
+                move $v0, $t2
 
 jump_to_kernel:

boot/arch/ppc32/Makefile.inc

@@ -56 +56 @@
         genarch/src/multiplication.c \
         generic/src/balloc.c \
-        generic/src/memstr.c \
         generic/src/printf_core.c \
         generic/src/vprintf.c \

boot/arch/ppc32/src/asm.S

@@ -60 +60 @@
 .global start
 .global halt
+.global memcpy
 .global jump_to_kernel
 .global real_mode
@@ -77 +78 @@
 halt:
         b halt
+
+memcpy:
+        srwi. r7, r5, 3
+        addi r6, r3, -4
+        addi r4, r4, -4
+        beq 2f
+        
+        andi. r0, r6, 3
+        mtctr r7
+        bne 5f
+        
+        1:
+                lwz r7, 4(r4)
+                lwzu r8, 8(r4)
+                stw r7, 4(r6)
+                stwu r8, 8(r6)
+                bdnz 1b
+                
+                andi. r5, r5, 7
+        
+        2:
+                cmplwi 0, r5, 4
+                blt 3f
+                
+                lwzu r0, 4(r4)
+                addi r5, r5, -4
+                stwu r0, 4(r6)
+        
+        3:
+                cmpwi 0, r5, 0
+                beqlr
+                mtctr r5
+                addi r4, r4, 3
+                addi r6, r6, 3
+        
+        4:
+                lbzu r0, 1(r4)
+                stbu r0, 1(r6)
+                bdnz 4b
+                blr
+        
+        5:
+                subfic r0, r0, 4
+                mtctr r0
+        
+        6:
+                lbz r7, 4(r4)
+                addi r4, r4, 1
+                stb r7, 4(r6)
+                addi r6, r6, 1
+                bdnz 6b
+                subf r5, r0, r5
+                rlwinm. r7, r5, 32-3, 3, 31
+                beq 2b
+                mtctr r7
+                b 1b
 
 jump_to_kernel:

boot/arch/sparc64/Makefile.inc

@@ -54 +54 @@
         genarch/src/ofw_tree.c \
         generic/src/balloc.c \
-        generic/src/memstr.c \
         generic/src/printf_core.c \
         generic/src/vprintf.c \

boot/arch/sparc64/src/asm.S

@@ -42 +42 @@
 .global start
 .global halt
+.global memcpy
 .global jump_to_kernel
 
@@ -97 +98 @@
         ba %xcc, halt
         nop
+
+memcpy:
+        ! Save dst
+        
+        mov %o0, %o3
+        add %o1, 7, %g1
+        and %g1, -8, %g1
+        cmp %o1, %g1
+        be,pn %xcc, 3f
+        add %o0, 7, %g1
+        mov 0, %g3
+        
+        0:
+                brz,pn %o2, 2f
+                mov 0, %g2
+        
+        1:
+                ldub [%g3 + %o1], %g1
+                add %g2, 1, %g2
+                cmp %o2, %g2
+                stb %g1, [%g3 + %o0]
+                bne,pt %xcc, 1b
+                mov %g2, %g3
+        
+        2:
+                ! Exit point
+                
+                jmp %o7 + 8
+                mov %o3, %o0
+        
+        3:
+                and %g1, -8, %g1
+                cmp %o0, %g1
+                bne,pt %xcc, 0b
+                mov 0, %g3
+                srlx %o2, 3, %g4
+                brz,pn %g4, 5f
+                mov 0, %g5
+        
+        4:
+                sllx %g3, 3, %g2
+                add %g5, 1, %g3
+                ldx [%o1 + %g2], %g1
+                mov %g3, %g5
+                cmp %g4, %g3
+                bne,pt %xcc, 4b
+                stx %g1, [%o0 + %g2]
+        
+        5:
+                and %o2, 7, %o2
+                brz,pn %o2, 2b
+                sllx %g4, 3, %g1
+                mov 0, %g2
+                add %g1, %o0, %o0
+                add %g1, %o1, %g4
+                mov 0, %g3
+        
+        6:
+                ldub [%g2 + %g4], %g1
+                stb %g1, [%g2 + %o0]
+                add %g3, 1, %g2
+                cmp %o2, %g2
+                bne,pt %xcc, 6b
+                mov %g2, %g3
+        
+        ! Exit point
+        
+        jmp %o7 + 8
+        mov %o3, %o0
 
 jump_to_kernel:

contrib/conf/ia32-qe.sh

@@ -5 +5 @@
 # Create a disk image if it does not exist
 if [ ! -f "$DISK_IMG" ]; then
-        tools/mkfat.py 1048576 uspace/dist/data "$DISK_IMG"
+        tools/mkfat.py uspace/dist/data "$DISK_IMG"
 fi
 

contrib/conf/mips32-gx.sh

@@ -5 +5 @@
 # Create a disk image if it does not exist
 if [ ! -f "$DISK_IMG" ]; then
-        tools/mkfat.py 1048576 uspace/dist/data "$DISK_IMG"
+        tools/mkfat.py uspace/dist/data "$DISK_IMG"
 fi
 

kernel/Makefile

@@ -120 +120 @@
 ifeq ($(CONFIG_LTO),y)
         GCC_CFLAGS += -flto
-endif
-
-ifeq ($(CONFIG_LINE_DEBUG),y)
-        GCC_CFLAGS += -g
-        ICC_CFLAGS += -g
-        SUNCC_CFLAGS += -g
-        CLANG_CFLAGS += -g
 endif
 
@@ -408 +401 @@
 
 $(DISASM): $(RAW)
-ifeq ($(CONFIG_LINE_DEBUG),y)
-        $(OBJDUMP) -d -S $< > $@
-else
         $(OBJDUMP) -d $< > $@
-endif
 
 $(RAW): $(LINK) $(ARCH_OBJECTS) $(GENARCH_OBJECTS) $(GENERIC_OBJECTS) $(SYMTAB_OBJECTS)

kernel/arch/abs32le/src/debug/stacktrace.c

@@ -37 +37 @@
 #include <typedefs.h>
 
-bool kernel_stack_trace_context_validate(stack_trace_context_t *ctx)
+bool kernel_frame_pointer_validate(uintptr_t fp)
 {
         return true;
 }
 
-bool kernel_frame_pointer_prev(stack_trace_context_t *ctx, uintptr_t *prev)
+bool kernel_frame_pointer_prev(uintptr_t fp, uintptr_t *prev)
 {
         return true;
 }
 
-bool kernel_return_address_get(stack_trace_context_t *ctx, uintptr_t *ra)
+bool kernel_return_address_get(uintptr_t fp, uintptr_t *ra)
 {
         return true;
 }
 
-bool uspace_stack_trace_context_validate(stack_trace_context_t *ctx)
+bool uspace_frame_pointer_validate(uintptr_t fp)
 {
         return true;
 }
 
-bool uspace_frame_pointer_prev(stack_trace_context_t *ctx, uintptr_t *prev)
+bool uspace_frame_pointer_prev(uintptr_t fp, uintptr_t *prev)
 {
         return true;
 }
 
-bool uspace_return_address_get(stack_trace_context_t *ctx, uintptr_t *ra)
+bool uspace_return_address_get(uintptr_t fp, uintptr_t *ra)
 {
         return true;

kernel/arch/amd64/_link.ld.in

@@ -53 +53 @@
         }
         
-#ifdef CONFIG_LINE_DEBUG
-        .comment 0 : { *(.comment); }
-        .debug_abbrev 0 : { *(.debug_abbrev); }
-        .debug_aranges 0 : { *(.debug_aranges); }
-        .debug_info 0 : { *(.debug_info); }
-        .debug_line 0 : { *(.debug_line); }
-        .debug_loc 0 : { *(.debug_loc); }
-        .debug_pubnames 0 : { *(.debug_pubnames); }
-        .debug_pubtypes 0 : { *(.debug_pubtypes); }
-        .debug_ranges 0 : { *(.debug_ranges); }
-        .debug_str 0 : { *(.debug_str); }
-#endif
-        
         /DISCARD/ : {
                 *(*);

kernel/arch/amd64/include/pm.h

@@ -65 +65 @@
 #endif /* CONFIG_FB */
 
-#define GDT_SELECTOR(des)  ((des) << 3)
+#define gdtselector(des)  ((des) << 3)
+#define idtselector(des)  ((des) << 4)
 
 #define PL_KERNEL  0
@@ -167 +168 @@
 
 extern ptr_16_64_t gdtr;
+extern ptr_16_32_t bootstrap_gdtr;
 extern ptr_16_32_t protected_ap_gdtr;
 

kernel/arch/amd64/src/asm.S

@@ -244 +244 @@
          */
         xorq %rdx, %rdx
-        cmpq $(GDT_SELECTOR(KTEXT_DES)), ISTATE_OFFSET_CS(%rsp)
+        cmpq $(gdtselector(KTEXT_DES)), ISTATE_OFFSET_CS(%rsp)
         cmovnzq %rdx, %rbp
 

kernel/arch/amd64/src/boot/boot.S

@@ -85 +85 @@
         
         /* Kernel data + stack */
-        movw $GDT_SELECTOR(KDATA_DES), %cx
+        movw $gdtselector(KDATA_DES), %cx
         movw %cx, %es
         movw %cx, %ds
@@ -94 +94 @@
          * when _visible_ part of GS does not point to user-mode segment.
          */
-        movw $GDT_SELECTOR(UDATA_DES), %cx
+        movw $gdtselector(UDATA_DES), %cx
         movw %cx, %fs
         movw %cx, %gs
         
-        jmpl $GDT_SELECTOR(KTEXT32_DES), $multiboot_meeting_point
+        jmpl $gdtselector(KTEXT32_DES), $multiboot_meeting_point
         multiboot_meeting_point:
         
@@ -182 +182 @@
         
         /* At this point we are in compatibility mode */
-        jmpl $GDT_SELECTOR(KTEXT_DES), $start64
+        jmpl $gdtselector(KTEXT_DES), $start64
 
 /** Print string to EGA display (in light red) and halt.
@@ -645 +645 @@
 .section K_DATA_START, "aw", @progbits
 
+.global bootstrap_gdtr
 bootstrap_gdtr:
-        .word GDT_SELECTOR(GDT_ITEMS)
+        .word gdtselector(GDT_ITEMS)
         .long KA2PA(gdt)
 

kernel/arch/amd64/src/boot/vesa_ret.inc

@@ -7 +7 @@
         
         /* Kernel data + stack */
-        movw $GDT_SELECTOR(KDATA_DES), %cx
+        movw $gdtselector(KDATA_DES), %cx
         movw %cx, %es
         movw %cx, %ds
@@ -17 +17 @@
          */
         
-        movw $GDT_SELECTOR(UDATA_DES), %cx
+        movw $gdtselector(UDATA_DES), %cx
         movw %cx, %fs
         movw %cx, %gs
         
-        jmpl $GDT_SELECTOR(KTEXT32_DES), $vesa_meeting_point
+        jmpl $gdtselector(KTEXT32_DES), $vesa_meeting_point

kernel/arch/amd64/src/ddi/ddi.c

@@ -153 +153 @@
         tss_descriptor_t *tss_desc = (tss_descriptor_t *) &gdt_p[TSS_DES];
         tss_desc->type = AR_TSS;
-        tr_load(GDT_SELECTOR(TSS_DES));
+        tr_load(gdtselector(TSS_DES));
         
         /*

kernel/arch/amd64/src/debug/stacktrace.c

@@ -40 +40 @@
 #define FRAME_OFFSET_RA       1
 
-bool kernel_stack_trace_context_validate(stack_trace_context_t *ctx)
+bool kernel_frame_pointer_validate(uintptr_t fp)
 {
-        return ctx->fp != 0;
+        return fp != 0;
 }
 
-bool kernel_frame_pointer_prev(stack_trace_context_t *ctx, uintptr_t *prev)
+bool kernel_frame_pointer_prev(uintptr_t fp, uintptr_t *prev)
 {
-        uint64_t *stack = (void *) ctx->fp;
+        uint64_t *stack = (void *) fp;
         *prev = stack[FRAME_OFFSET_FP_PREV];
         
@@ -53 +53 @@
 }
 
-bool kernel_return_address_get(stack_trace_context_t *ctx, uintptr_t *ra)
+bool kernel_return_address_get(uintptr_t fp, uintptr_t *ra)
 {
-        uint64_t *stack = (void *) ctx->fp;
+        uint64_t *stack = (void *) fp;
         *ra = stack[FRAME_OFFSET_RA];
         
@@ -61 +61 @@
 }
 
-bool uspace_stack_trace_context_validate(stack_trace_context_t *ctx)
+bool uspace_frame_pointer_validate(uintptr_t fp)
 {
-        return ctx->fp != 0;
+        return fp != 0;
 }
 
-bool uspace_frame_pointer_prev(stack_trace_context_t *ctx, uintptr_t *prev)
+bool uspace_frame_pointer_prev(uintptr_t fp, uintptr_t *prev)
 {
         return !copy_from_uspace((void *) prev,
-            (uint64_t *) ctx->fp + FRAME_OFFSET_FP_PREV, sizeof(*prev));
+            (uint64_t *) fp + FRAME_OFFSET_FP_PREV, sizeof(*prev));
 }
 
-bool uspace_return_address_get(stack_trace_context_t *ctx, uintptr_t *ra)
+bool uspace_return_address_get(uintptr_t fp, uintptr_t *ra)
 {
-        return !copy_from_uspace((void *) ra,
-            (uint64_t *) ctx->fp + FRAME_OFFSET_RA, sizeof(*ra));
+        return !copy_from_uspace((void *) ra, (uint64_t *) fp + FRAME_OFFSET_RA,
+            sizeof(*ra));
 }
 

kernel/arch/amd64/src/pm.c

@@ -171 +171 @@
 
                 d->unused = 0;
-                d->selector = GDT_SELECTOR(KTEXT_DES);
+                d->selector = gdtselector(KTEXT_DES);
 
                 d->present = 1;
@@ -291 +291 @@
          * to its own TSS. We just need to load the TR register.
          */
-        tr_load(GDT_SELECTOR(TSS_DES));
+        tr_load(gdtselector(TSS_DES));
 }
 

kernel/arch/amd64/src/smp/ap.S

@@ -61 +61 @@
         orl $1, %eax
         movl %eax, %cr0     # switch to protected mode
-        jmpl $GDT_SELECTOR(KTEXT32_DES), $jump_to_kernel - BOOT_OFFSET + AP_BOOT_OFFSET
+        jmpl $gdtselector(KTEXT32_DES), $jump_to_kernel - BOOT_OFFSET + AP_BOOT_OFFSET
 
 jump_to_kernel:
 .code32
-        movw $GDT_SELECTOR(KDATA_DES), %ax
+        movw $gdtselector(KDATA_DES), %ax
         movw %ax, %ds
         movw %ax, %es
         movw %ax, %ss
-        movw $GDT_SELECTOR(UDATA_DES), %ax
+        movw $gdtselector(UDATA_DES), %ax
         movw %ax, %gs
         
@@ -94 +94 @@
         
         # At this point we are in compatibility mode
-        jmpl $GDT_SELECTOR(KTEXT_DES), $start64 - BOOT_OFFSET + AP_BOOT_OFFSET
+        jmpl $gdtselector(KTEXT_DES), $start64 - BOOT_OFFSET + AP_BOOT_OFFSET
 
 .code64

kernel/arch/amd64/src/syscall.c

@@ -58 +58 @@
          */
         write_msr(AMD_MSR_STAR,
-            ((uint64_t) (GDT_SELECTOR(KDATA_DES) | PL_USER) << 48) |
-            ((uint64_t) (GDT_SELECTOR(KTEXT_DES) | PL_KERNEL) << 32));
+            ((uint64_t)(gdtselector(KDATA_DES) | PL_USER) << 48) |
+            ((uint64_t)(gdtselector(KTEXT_DES) | PL_KERNEL) << 32));
         write_msr(AMD_MSR_LSTAR, (uint64_t)syscall_entry);
         /* Mask RFLAGS on syscall 

kernel/arch/amd64/src/userspace.c

@@ -65 +65 @@
                 "xorq %%rdi, %%rdi\n"
                 "iretq\n"
-                :: [udata_des] "i" (GDT_SELECTOR(UDATA_DES) | PL_USER),
+                :: [udata_des] "i" (gdtselector(UDATA_DES) | PL_USER),
                    [stack_size] "r" (kernel_uarg->uspace_stack + THREAD_STACK_SIZE),
                    [ipl] "r" (ipl),
-                   [utext_des] "i" (GDT_SELECTOR(UTEXT_DES) | PL_USER),
+                   [utext_des] "i" (gdtselector(UTEXT_DES) | PL_USER),
                    [entry] "r" (kernel_uarg->uspace_entry),
                    [uarg] "r" (kernel_uarg->uspace_uarg)

kernel/arch/arm32/src/debug/stacktrace.c

@@ -40 +40 @@
 #define FRAME_OFFSET_RA         -1
 
-bool kernel_stack_trace_context_validate(stack_trace_context_t *ctx)
+bool kernel_frame_pointer_validate(uintptr_t fp)
 {
-        return ctx->fp != 0;
+        return fp != 0;
 }
 
-bool kernel_frame_pointer_prev(stack_trace_context_t *ctx, uintptr_t *prev)
+bool kernel_frame_pointer_prev(uintptr_t fp, uintptr_t *prev)
 {
-        uint32_t *stack = (void *) ctx->fp;
+        uint32_t *stack = (void *) fp;
 
         *prev = stack[FRAME_OFFSET_FP_PREV];
@@ -53 +53 @@
 }
 
-bool kernel_return_address_get(stack_trace_context_t *ctx, uintptr_t *ra)
+bool kernel_return_address_get(uintptr_t fp, uintptr_t *ra)
 {
-        uint32_t *stack = (void *) ctx->fp;
+        uint32_t *stack = (void *) fp;
 
         *ra = stack[FRAME_OFFSET_RA];
@@ -61 +61 @@
 }
 
-bool uspace_stack_trace_context_validate(stack_trace_context_t *ctx)
+bool uspace_frame_pointer_validate(uintptr_t fp)
 {
-        return ctx->fp != 0;
+        return fp != 0;
 }
 
-bool uspace_frame_pointer_prev(stack_trace_context_t *ctx, uintptr_t *prev)
+bool uspace_frame_pointer_prev(uintptr_t fp, uintptr_t *prev)
 {
         return !copy_from_uspace((void *) prev,
-            (uint32_t *) ctx->fp + FRAME_OFFSET_FP_PREV, sizeof(*prev));
+            (uint32_t *) fp + FRAME_OFFSET_FP_PREV, sizeof(*prev));
 }
 
-bool uspace_return_address_get(stack_trace_context_t *ctx, uintptr_t *ra)
+bool uspace_return_address_get(uintptr_t fp, uintptr_t *ra)
 {
-        return !copy_from_uspace((void *) ra,
-            (uint32_t *) ctx->fp + FRAME_OFFSET_RA, sizeof(*ra));
+        return !copy_from_uspace((void *) ra, (uint32_t *) fp + FRAME_OFFSET_RA,
+            sizeof(*ra));
 }
 

kernel/arch/ia32/include/bios/bios.h

@@ -38 +38 @@
 #include <typedefs.h>
 
+#define BIOS_EBDA_PTR  0x40e
+
 extern uintptr_t ebda;
 

kernel/arch/ia32/include/mm/as.h

@@ -27 +27 @@
  */
 
-/** @addtogroup ia32mm
+/** @addtogroup ia32mm  
  * @{
  */

kernel/arch/ia32/include/mm/page.h

@@ -27 +27 @@
  */
 
-/** @addtogroup ia32mm
+/** @addtogroup ia32mm  
  * @{
  */
@@ -106 +106 @@
 
 /* Set PTE flags accessors for each level. */
-#define SET_PTL1_FLAGS_ARCH(ptl0, i, x) \
+#define SET_PTL1_FLAGS_ARCH(ptl0, i, x) \
         set_pt_flags((pte_t *) (ptl0), (size_t) (i), (x))
 #define SET_PTL2_FLAGS_ARCH(ptl1, i, x)

kernel/arch/ia32/include/pm.h

@@ -58 +58 @@
 #endif /* CONFIG_FB */
 
-#define GDT_SELECTOR(des)  ((des) << 3)
+#define gdtselector(des)  ((des) << 3)
 
 #define PL_KERNEL  0
@@ -153 +153 @@
 
 extern ptr_16_32_t gdtr;
+extern ptr_16_32_t bootstrap_gdtr;
 extern ptr_16_32_t protected_ap_gdtr;
 extern tss_t *tss_p;

kernel/arch/ia32/src/asm.S

@@ -225 +225 @@
          * Switch to kernel selectors.
          */
-        movw $(GDT_SELECTOR(KDATA_DES)), %ax
+        movw $(gdtselector(KDATA_DES)), %ax
         movw %ax, %ds
         movw %ax, %es
@@ -304 +304 @@
          * Switch to kernel selectors.
          */
-        movl $(GDT_SELECTOR(KDATA_DES)), %eax
+        movl $(gdtselector(KDATA_DES)), %eax
         movl %eax, %ds
         movl %eax, %es
@@ -407 +407 @@
          * Switch to kernel selectors.
          */
-        movl $(GDT_SELECTOR(KDATA_DES)), %eax
+        movl $(gdtselector(KDATA_DES)), %eax
         movl %eax, %ds
         movl %eax, %es
@@ -416 +416 @@
          */
         xorl %eax, %eax
-        cmpl $(GDT_SELECTOR(KTEXT_DES)), ISTATE_OFFSET_CS(%esp)
+        cmpl $(gdtselector(KTEXT_DES)), ISTATE_OFFSET_CS(%esp)
         cmovnzl %eax, %ebp
 

kernel/arch/ia32/src/bios/bios.c

@@ -36 +36 @@
 #include <typedefs.h>
 
-#define BIOS_EBDA_PTR  0x40e
-
 uintptr_t ebda = 0;
 

kernel/arch/ia32/src/boot/boot.S

@@ -78 +78 @@
         
         /* Initialize Global Descriptor Table register */
-        lgdtl bootstrap_gdtr
+        lgdtl KA2PA(bootstrap_gdtr)
         
         /* Kernel data + stack */
-        movw $GDT_SELECTOR(KDATA_DES), %cx
+        movw $gdtselector(KDATA_DES), %cx
         movw %cx, %es
         movw %cx, %fs
@@ -88 +88 @@
         movw %cx, %ss
         
-        jmpl $GDT_SELECTOR(KTEXT_DES), $multiboot_meeting_point
+        jmpl $gdtselector(KTEXT_DES), $multiboot_meeting_point
         multiboot_meeting_point:
         
@@ -514 +514 @@
 page_directory:
         .space 4096, 0
-
-bootstrap_gdtr:
-        .word GDT_SELECTOR(GDT_ITEMS)
-        .long KA2PA(gdt)
 
 grub_eax:

kernel/arch/ia32/src/boot/vesa_real.inc

@@ -30 +30 @@
 .code32
 vesa_init:
-        jmp $GDT_SELECTOR(VESA_INIT_DES), $vesa_init_real - vesa_init
+        jmp $gdtselector(VESA_INIT_DES), $vesa_init_real - vesa_init
 
 .code16
@@ -335 +335 @@
                 vesa_leave_real2:
                 
-                        ljmpl $GDT_SELECTOR(KTEXT32_DES), $(vesa_init_protected - vesa_init + VESA_INIT_SEGMENT << 4)
+                        ljmpl $gdtselector(KTEXT32_DES), $(vesa_init_protected - vesa_init + VESA_INIT_SEGMENT << 4)
         
         no_mode:

kernel/arch/ia32/src/boot/vesa_ret.inc

@@ -7 +7 @@
         
         /* Kernel data + stack */
-        movw $GDT_SELECTOR(KDATA_DES), %cx
+        movw $gdtselector(KDATA_DES), %cx
         movw %cx, %es
         movw %cx, %fs
@@ -14 +14 @@
         movw %cx, %ss
         
-        jmpl $GDT_SELECTOR(KTEXT_DES), $vesa_meeting_point
+        jmpl $gdtselector(KTEXT_DES), $vesa_meeting_point

kernel/arch/ia32/src/ddi/ddi.c

@@ -153 +153 @@
          */
         gdt_p[TSS_DES].access = AR_PRESENT | AR_TSS | DPL_KERNEL;
-        tr_load(GDT_SELECTOR(TSS_DES));
+        tr_load(gdtselector(TSS_DES));
         
         /*

kernel/arch/ia32/src/debug/stacktrace.c

@@ -40 +40 @@
 #define FRAME_OFFSET_RA         1
 
-bool kernel_stack_trace_context_validate(stack_trace_context_t *ctx)
+bool kernel_frame_pointer_validate(uintptr_t fp)
 {
-        return ctx->fp != 0;
+        return fp != 0;
 }
 
-bool kernel_frame_pointer_prev(stack_trace_context_t *ctx, uintptr_t *prev)
+bool kernel_frame_pointer_prev(uintptr_t fp, uintptr_t *prev)
 {
-        uint32_t *stack = (void *) ctx->fp;
+        uint32_t *stack = (void *) fp;
         *prev = stack[FRAME_OFFSET_FP_PREV];
         return true;
 }
 
-bool kernel_return_address_get(stack_trace_context_t *ctx, uintptr_t *ra)
+bool kernel_return_address_get(uintptr_t fp, uintptr_t *ra)
 {
-        uint32_t *stack = (void *) ctx->fp;
+        uint32_t *stack = (void *) fp;
         *ra = stack[FRAME_OFFSET_RA];
         return true;
 }
 
-bool uspace_stack_trace_context_validate(stack_trace_context_t *ctx)
+bool uspace_frame_pointer_validate(uintptr_t fp)
 {
-        return ctx->fp != 0;
+        return fp != 0;
 }
 
-bool uspace_frame_pointer_prev(stack_trace_context_t *ctx, uintptr_t *prev)
+bool uspace_frame_pointer_prev(uintptr_t fp, uintptr_t *prev)
 {
         return !copy_from_uspace((void *) prev,
-            (uint32_t *) ctx->fp + FRAME_OFFSET_FP_PREV, sizeof(*prev));
+            (uint32_t *) fp + FRAME_OFFSET_FP_PREV, sizeof(*prev));
 }
 
-bool uspace_return_address_get(stack_trace_context_t *ctx, uintptr_t *ra)
+bool uspace_return_address_get(uintptr_t fp, uintptr_t *ra)
 {
-        return !copy_from_uspace((void *) ra,
-            (uint32_t *) ctx->fp + FRAME_OFFSET_RA, sizeof(*ra));
+        return !copy_from_uspace((void *) ra, (uint32_t *) fp + FRAME_OFFSET_RA,
+            sizeof(*ra));
 }
 

kernel/arch/ia32/src/mm/frame.c

@@ -131 +131 @@
                         if (last_frame < ALIGN_UP(new_base + new_size, FRAME_SIZE))
                                 last_frame = ALIGN_UP(new_base + new_size, FRAME_SIZE);
-                } else if ((e820table[i].type == MEMMAP_MEMORY_ACPI) ||
-                    (e820table[i].type == MEMMAP_MEMORY_NVS)) {
+                }
+                
+                if (e820table[i].type == MEMMAP_MEMORY_RESERVED) {
+                        /* To be safe, make the reserved zone possibly larger */
+                        uint64_t new_base = ALIGN_DOWN(base, FRAME_SIZE);
+                        uint64_t new_size = ALIGN_UP(size + (base - new_base),
+                            FRAME_SIZE);
+                        
+                        zone_create(ADDR2PFN(new_base), SIZE2FRAMES(new_size), 0,
+                            ZONE_RESERVED);
+                }
+                
+                if (e820table[i].type == MEMMAP_MEMORY_ACPI) {
                         /* To be safe, make the firmware zone possibly larger */
                         uint64_t new_base = ALIGN_DOWN(base, FRAME_SIZE);
@@ -140 +151 @@
                         zone_create(ADDR2PFN(new_base), SIZE2FRAMES(new_size), 0,
                             ZONE_FIRMWARE);
-                } else {
-                        /* To be safe, make the reserved zone possibly larger */
-                        uint64_t new_base = ALIGN_DOWN(base, FRAME_SIZE);
-                        uint64_t new_size = ALIGN_UP(size + (base - new_base),
-                            FRAME_SIZE);
-                        
-                        zone_create(ADDR2PFN(new_base), SIZE2FRAMES(new_size), 0,
-                            ZONE_RESERVED);
                 }
         }
@@ -200 +203 @@
 #ifdef CONFIG_SMP
                 /* Reserve AP real mode bootstrap memory */
-                frame_mark_unavailable(AP_BOOT_OFFSET >> FRAME_WIDTH,
+                frame_mark_unavailable(AP_BOOT_OFFSET >> FRAME_WIDTH, 
                     (hardcoded_unmapped_ktext_size +
                     hardcoded_unmapped_kdata_size) >> FRAME_WIDTH);

kernel/arch/ia32/src/pm.c

@@ -75 +75 @@
         /* VESA Init descriptor */
 #ifdef CONFIG_FB
-        { 0xffff, 0, VESA_INIT_SEGMENT >> 12, AR_PRESENT | AR_CODE | DPL_KERNEL, 0xf, 0, 0, 0, 0, 0 }
-#endif
+        { 0xffff, 0, VESA_INIT_SEGMENT>>12, AR_PRESENT | AR_CODE | DPL_KERNEL, 0xf, 0, 0, 0, 0, 0 }
+#endif  
 };
 
@@ -86 +86 @@
 
 /* gdtr is changed by kmp before next CPU is initialized */
-ptr_16_32_t gdtr = {
-        .limit = sizeof(gdt),
-        .base = (uintptr_t) gdt
-};
+ptr_16_32_t bootstrap_gdtr = { .limit = sizeof(gdt), .base = KA2PA((uintptr_t) gdt) };
+ptr_16_32_t gdtr = { .limit = sizeof(gdt), .base = (uintptr_t) gdt };
 
 void gdt_setbase(descriptor_t *d, uintptr_t base)
@@ -130 +128 @@
 
                 d->unused = 0;
-                d->selector = GDT_SELECTOR(KTEXT_DES);
+                d->selector = gdtselector(KTEXT_DES);
 
                 if (i == VECTOR_SYSCALL) {
@@ -285 +283 @@
          * to its own TSS. We just need to load the TR register.
          */
-        tr_load(GDT_SELECTOR(TSS_DES));
+        tr_load(gdtselector(TSS_DES));
         
         clean_IOPL_NT_flags();    /* Disable I/O on nonprivileged levels and clear NT flag. */

kernel/arch/ia32/src/proc/scheduler.c

@@ -67 +67 @@
         /* Set kernel stack for CPL3 -> CPL0 switch via interrupt */
         CPU->arch.tss->esp0 = kstk;
-        CPU->arch.tss->ss0 = GDT_SELECTOR(KDATA_DES);
+        CPU->arch.tss->ss0 = gdtselector(KDATA_DES);
         
         /* Set up TLS in GS register */

kernel/arch/ia32/src/syscall.c

@@ -45 +45 @@
 
         /* set kernel mode CS selector */
-        write_msr(IA32_MSR_SYSENTER_CS, GDT_SELECTOR(KTEXT_DES));
+        write_msr(IA32_MSR_SYSENTER_CS, gdtselector(KTEXT_DES));
         /* set kernel mode entry point */
         write_msr(IA32_MSR_SYSENTER_EIP, (uint32_t) sysenter_handler);

kernel/arch/ia32/src/userspace.c

@@ -75 +75 @@
                 "iret\n"
                 :
-                : [udata_des] "i" (GDT_SELECTOR(UDATA_DES) | PL_USER),
+                : [udata_des] "i" (gdtselector(UDATA_DES) | PL_USER),
                   [stack_size] "r" ((uint8_t *) kernel_uarg->uspace_stack + THREAD_STACK_SIZE),
                   [ipl] "r" (ipl),
-                  [utext_des] "i" (GDT_SELECTOR(UTEXT_DES) | PL_USER),
+                  [utext_des] "i" (gdtselector(UTEXT_DES) | PL_USER),
                   [entry] "r" (kernel_uarg->uspace_entry),
                   [uarg] "r" (kernel_uarg->uspace_uarg),
-                  [tls_des] "r" (GDT_SELECTOR(TLS_DES))
+                  [tls_des] "r" (gdtselector(TLS_DES))
                 : "eax");
         

kernel/arch/ia64/src/debug/stacktrace.c

@@ -37 +37 @@
 #include <typedefs.h>
 
-bool kernel_stack_trace_context_validate(stack_trace_context_t *ctx)
+bool kernel_frame_pointer_validate(uintptr_t fp)
 {
         return false;
 }
 
-bool kernel_frame_pointer_prev(stack_trace_context_t *ctx, uintptr_t *prev)
+bool kernel_frame_pointer_prev(uintptr_t fp, uintptr_t *prev)
 {
         return false;
 }
 
-bool kernel_return_address_get(stack_trace_context_t *ctx, uintptr_t *ra)
+bool kernel_return_address_get(uintptr_t fp, uintptr_t *ra)
 {
         return false;
 }
 
-bool uspace_stack_trace_context_validate(stack_trace_context_t *ctx)
+bool uspace_frame_pointer_validate(uintptr_t fp)
 {
         return false;
 }
 
-bool uspace_frame_pointer_prev(stack_trace_context_t *ctx, uintptr_t *prev)
+bool uspace_frame_pointer_prev(uintptr_t fp, uintptr_t *prev)
 {
         return false;
 }
 
-bool uspace_return_address_get(stack_trace_context_t *ctx, uintptr_t *ra)
+bool uspace_return_address_get(uintptr_t fp, uintptr_t *ra)
 {
         return false;

kernel/arch/mips32/include/debugger.h

@@ -68 +68 @@
 extern bpinfo_t breakpoints[BKPOINTS_MAX];
 
-extern bool is_jump(unative_t);
-
 extern void debugger_init(void);
 extern void debugger_bpoint(istate_t *);

kernel/arch/mips32/src/debug/stacktrace.c

@@ -36 +36 @@
 #include <syscall/copy.h>
 #include <typedefs.h>
-#include <arch/debugger.h>
-#include <print.h>
 
-#define R0      0U
-#define SP      29U
-#define RA      31U
-
-#define OP_SHIFT        26
-#define RS_SHIFT        21
-#define RT_SHIFT        16
-#define RD_SHIFT        11
-
-#define HINT_SHIFT      6
-#define BASE_SHIFT      RS_SHIFT
-#define IMM_SHIFT       0
-#define OFFSET_SHIFT    IMM_SHIFT
-
-#define RS_MASK         (0x1f << RS_SHIFT)
-#define RT_MASK         (0x1f << RT_SHIFT)
-#define RD_MASK         (0x1f << RD_SHIFT)
-#define HINT_MASK       (0x1f << HINT_SHIFT)
-#define BASE_MASK       RS_MASK
-#define IMM_MASK        (0xffff << IMM_SHIFT)
-#define OFFSET_MASK     IMM_MASK        
-
-#define RS_GET(inst)            (((inst) & RS_MASK) >> RS_SHIFT)
-#define RD_GET(inst)            (((inst) & RD_MASK) >> RD_SHIFT)
-#define IMM_GET(inst)           (int16_t)(((inst) & IMM_MASK) >> IMM_SHIFT)
-#define BASE_GET(inst)          RS_GET(inst)
-#define OFFSET_GET(inst)        IMM_GET(inst)   
-
-#define ADDU_R_SP_R0_TEMPL \
-        ((0x0 << OP_SHIFT) | (SP << RS_SHIFT) | (R0 << RT_SHIFT) | 0x21)
-#define ADDU_SP_R_R0_TEMPL \
-        ((0x0 << OP_SHIFT) | (SP << RD_SHIFT) | (R0 << RT_SHIFT) | 0x21)
-#define ADDI_SP_SP_IMM_TEMPL \
-        ((0x8 << OP_SHIFT) | (SP << RS_SHIFT) | (SP << RT_SHIFT))
-#define ADDIU_SP_SP_IMM_TEMPL \
-        ((0x9 << OP_SHIFT) | (SP << RS_SHIFT) | (SP << RT_SHIFT))
-#define JR_RA_TEMPL \
-        ((0x0 << OP_SHIFT) | (RA << RS_SHIFT) | (0x0 << HINT_SHIFT) | 0x8)
-#define SW_RA_TEMPL \
-        ((0x2b << OP_SHIFT) | (RA << RT_SHIFT))
-
-#define IS_ADDU_R_SP_R0(inst) \
-        (((inst) & ~RD_MASK) == ADDU_R_SP_R0_TEMPL)
-#define IS_ADDU_SP_R_R0(inst) \
-        (((inst) & ~RS_MASK) == ADDU_SP_R_R0_TEMPL)
-#define IS_ADDI_SP_SP_IMM(inst) \
-        (((inst) & ~IMM_MASK) == ADDI_SP_SP_IMM_TEMPL)
-#define IS_ADDIU_SP_SP_IMM(inst) \
-        (((inst) & ~IMM_MASK) == ADDIU_SP_SP_IMM_TEMPL)
-#define IS_JR_RA(inst) \
-        (((inst) & ~HINT_MASK) == JR_RA_TEMPL)
-#define IS_SW_RA(inst) \
-        (((inst) & ~(BASE_MASK | OFFSET_MASK)) == SW_RA_TEMPL)
-
-extern char ktext_start;
-extern char ktext_end;
-
-static bool
-scan(stack_trace_context_t *ctx, uintptr_t *prev_fp, uintptr_t *prev_ra)
-{
-        uint32_t *inst = (void *) ctx->pc;
-        bool has_fp = false;
-        size_t frame_size;
-        unsigned int fp = SP;
-
-        do {
-                inst--;
-#if 0
-                /*
-                 * This is one of the situations in which the theory (ABI) does
-                 * not meet the practice (GCC). GCC simply does not place the
-                 * JR $ra instruction as dictated by the ABI, rendering the
-                 * official stack tracing algorithm somewhat unapplicable.
-                 */
-
-                if (IS_ADDU_R_SP_R0(*inst)) {
-                        uint32_t *cur;
-                        fp = RD_GET(*inst);
-                        /*
-                         * We have a candidate for frame pointer.
-                         */
-                        
-                        /* Seek to the end of this function. */
-                        for (cur = inst + 1; !IS_JR_RA(*cur); cur++)
-                                ;
-                        /* Scan the last basic block */
-                        for (cur--; !is_jump(*(cur - 1)); cur--) {
-                                if (IS_ADDU_SP_R_R0(*cur) &&
-                                    (fp == RS_GET(*cur))) {
-                                        has_fp = true;
-                                }
-                        }
-                        continue;
-                }
-                
-                if (IS_JR_RA(*inst)) {
-                        if (!ctx->istate)
-                                return false;
-                        /*
-                         * No stack frame has been allocated yet.
-                         * Use the values stored in istate.
-                         */
-                        if (prev_fp)
-                                *prev_fp = ctx->istate->sp;
-                        if (prev_ra)
-                                *prev_ra = ctx->istate->ra - 8;
-                        ctx->istate = NULL;
-                        return true;
-                }
-#endif
-
-        } while ((!IS_ADDIU_SP_SP_IMM(*inst) && !IS_ADDI_SP_SP_IMM(*inst)) ||
-            (IMM_GET(*inst) >= 0));
-        
-        /*
-         * We are at the instruction which allocates the space for the current
-         * stack frame.
-         */
-        frame_size = -IMM_GET(*inst);
-        if (prev_fp)
-                *prev_fp = ctx->fp + frame_size;
-
-        /*
-         * Scan the first basic block for the occurrence of
-         * SW $ra, OFFSET($base).
-         */
-        for (inst++; !is_jump(*(inst - 1)) && (uintptr_t) inst < ctx->pc;
-            inst++) {
-                if (IS_SW_RA(*inst)) {
-                        unsigned int base = BASE_GET(*inst);
-                        int16_t offset = OFFSET_GET(*inst);
-
-                        if (base == SP || (has_fp && base == fp)) {
-                                uint32_t *addr = (void *) (ctx->fp + offset);
-                                
-                                if (offset % 4 != 0)
-                                        return false;
-                                /* cannot store below current stack pointer */
-                                if (offset < 0)
-                                        return false;
-                                /* too big offsets are suspicious */
-                                if (offset > 32 * 4)
-                                        return false;
-
-                                if (prev_ra)
-                                        *prev_ra = *addr;
-                                return true;
-                        }
-                }
-        }
-
-        /*
-         * The first basic block does not save the return address or saves it
-         * after ctx->pc, which means that the correct value is in istate.
-         */
-        if (prev_ra) {
-                if (!ctx->istate)
-                        return false;
-                *prev_ra = ctx->istate->ra - 8;
-                ctx->istate = NULL;
-        }
-        return true;
-}
-
-
-bool kernel_stack_trace_context_validate(stack_trace_context_t *ctx)
-{
-        return !((ctx->fp == 0) || ((ctx->fp % 8) != 0) ||
-            (ctx->pc % 4 != 0) || (ctx->pc < (uintptr_t) &ktext_start) ||
-            (ctx->pc >= (uintptr_t) &ktext_end));
-}
-
-bool kernel_frame_pointer_prev(stack_trace_context_t *ctx, uintptr_t *prev)
-{
-        return scan(ctx, prev, NULL);
-}
-
-bool kernel_return_address_get(stack_trace_context_t *ctx, uintptr_t *ra)
-{
-        return scan(ctx, NULL, ra);
-}
-
-bool uspace_stack_trace_context_validate(stack_trace_context_t *ctx)
+bool kernel_frame_pointer_validate(uintptr_t fp)
 {
         return false;
 }
 
-bool uspace_frame_pointer_prev(stack_trace_context_t *ctx, uintptr_t *prev)
+bool kernel_frame_pointer_prev(uintptr_t fp, uintptr_t *prev)
 {
         return false;
 }
 
-bool uspace_return_address_get(stack_trace_context_t *ctx, uintptr_t *ra)
+bool kernel_return_address_get(uintptr_t fp, uintptr_t *ra)
+{
+        return false;
+}
+
+bool uspace_frame_pointer_validate(uintptr_t fp)
+{
+        return false;
+}
+
+bool uspace_frame_pointer_prev(uintptr_t fp, uintptr_t *prev)
+{
+        return false;
+}
+
+bool uspace_return_address_get(uintptr_t fp, uintptr_t *ra)
 {
         return false;

kernel/arch/mips32/src/debug/stacktrace_asm.S

@@ -37 +37 @@
 frame_pointer_get:
         j $ra
-        move $v0, $sp
+        xor $v0, $v0
 
 program_counter_get:
         j $ra
-        move $v0, $ra
+        xor $v0, $v0

kernel/arch/mips32/src/debugger.c

@@ -134 +134 @@
  *
  */
-bool is_jump(unative_t instr)
+static bool is_jump(unative_t instr)
 {
         unsigned int i;

kernel/arch/ppc32/src/debug/stacktrace.c

@@ -40 +40 @@
 #define FRAME_OFFSET_RA       1
 
-bool kernel_stack_trace_context_validate(stack_trace_context_t *ctx)
+bool kernel_frame_pointer_validate(uintptr_t fp)
 {
-        return ctx->fp != 0;
+        return fp != 0;
 }
 
-bool kernel_frame_pointer_prev(stack_trace_context_t *ctx, uintptr_t *prev)
+bool kernel_frame_pointer_prev(uintptr_t fp, uintptr_t *prev)
 {
-        uint32_t *stack = (void *) ctx->fp;
+        uint32_t *stack = (void *) fp;
         *prev = stack[FRAME_OFFSET_FP_PREV];
         return true;
 }
 
-bool kernel_return_address_get(stack_trace_context_t *ctx, uintptr_t *ra)
+bool kernel_return_address_get(uintptr_t fp, uintptr_t *ra)
 {
-        uint32_t *stack = (void *) ctx->fp;
+        uint32_t *stack = (void *) fp;
         *ra = stack[FRAME_OFFSET_RA];
         return true;
 }
 
-bool uspace_stack_trace_context_validate(stack_trace_context_t *ctx)
+bool uspace_frame_pointer_validate(uintptr_t fp)
 {
-        return ctx->fp != 0;
+        return fp != 0;
 }
 
-bool uspace_frame_pointer_prev(stack_trace_context_t *ctx, uintptr_t *prev)
+bool uspace_frame_pointer_prev(uintptr_t fp, uintptr_t *prev)
 {
         return !copy_from_uspace((void *) prev,
-            (uint32_t *) ctx->fp + FRAME_OFFSET_FP_PREV, sizeof(*prev));
+            (uint32_t *) fp + FRAME_OFFSET_FP_PREV, sizeof(*prev));
 }
 
-bool uspace_return_address_get(stack_trace_context_t *ctx, uintptr_t *ra)
+bool uspace_return_address_get(uintptr_t fp, uintptr_t *ra)
 {
-        return !copy_from_uspace((void *) ra,
-            (uint32_t *) ctx->fp + FRAME_OFFSET_RA, sizeof(*ra));
+        return !copy_from_uspace((void *) ra, (uint32_t *) fp + FRAME_OFFSET_RA,
+            sizeof(*ra));
 }
 

kernel/arch/sparc64/src/debug/stacktrace.c

@@ -50 +50 @@
 extern void alloc_window_and_flush(void);
 
-bool kernel_stack_trace_context_validate(stack_trace_context_t *ctx)
+bool kernel_frame_pointer_validate(uintptr_t fp)
 {
         uintptr_t kstack;
@@ -63 +63 @@
         kstack -= PREEMPTIBLE_HANDLER_STACK_FRAME_SIZE;
 
-        if (THREAD && (ctx->fp == kstack))
+        if (THREAD && (fp == kstack))
                 return false;
-        return ctx->fp != 0;
+        return fp != 0;
 }
 
-bool kernel_frame_pointer_prev(stack_trace_context_t *ctx, uintptr_t *prev)
+bool kernel_frame_pointer_prev(uintptr_t fp, uintptr_t *prev)
 {
-        uint64_t *stack = (void *) ctx->fp;
+        uint64_t *stack = (void *) fp;
         alloc_window_and_flush();
         *prev = stack[FRAME_OFFSET_FP_PREV] + STACK_BIAS;
@@ -76 +76 @@
 }
 
-bool kernel_return_address_get(stack_trace_context_t *ctx, uintptr_t *ra)
+bool kernel_return_address_get(uintptr_t fp, uintptr_t *ra)
 {
-        uint64_t *stack = (void *) ctx->fp;
+        uint64_t *stack = (void *) fp;
         alloc_window_and_flush();
         *ra = stack[FRAME_OFFSET_RA];
@@ -84 +84 @@
 }
 
-bool uspace_stack_trace_context_validate(stack_trace_context_t *ctx)
+bool uspace_frame_pointer_validate(uintptr_t fp)
 {
         return false;
 }
 
-bool uspace_frame_pointer_prev(stack_trace_context_t *ctx, uintptr_t *prev)
+bool uspace_frame_pointer_prev(uintptr_t fp, uintptr_t *prev)
 {
         return false;
 }
 
-bool uspace_return_address_get(stack_trace_context_t *ctx , uintptr_t *ra)
+bool uspace_return_address_get(uintptr_t fp, uintptr_t *ra)
 {
         return false;

kernel/generic/include/macros.h

@@ -47 +47 @@
  * @param s2  Start address of the second interval.
  * @param sz2 Size of the second interval.
- *
  */
-NO_TRACE static inline int overlaps(uint64_t s1, uint64_t sz1, uint64_t s2,
-    uint64_t sz2)
+NO_TRACE static inline int overlaps(uintptr_t s1, size_t sz1, uintptr_t s2,
+    size_t sz2)
 {
-        uint64_t e1 = s1 + sz1;
-        uint64_t e2 = s2 + sz2;
+        uintptr_t e1 = s1 + sz1;
+        uintptr_t e2 = s2 + sz2;
         
         return ((s1 < e2) && (s2 < e1));
-}
-
-/** Return true if the second interval is within the first interval.
- *
- * @param s1  Start address of the first interval.
- * @param sz1 Size of the first interval.
- * @param s2  Start address of the second interval.
- * @param sz2 Size of the second interval.
- *
- */
-NO_TRACE static inline int iswithin(uint64_t s1, uint64_t sz1, uint64_t s2,
-    uint64_t sz2)
-{
-        uint64_t e1 = s1 + sz1;
-        uint64_t e2 = s2 + sz2;
-        
-        return ((s1 <= s2) && (e1 >= e2));
 }
 
@@ -92 +74 @@
 
 /* Compute overlapping of physical addresses */
-#define PA_OVERLAPS(x, szx, y, szy) \
+#define PA_overlaps(x, szx, y, szy) \
         overlaps(KA2PA((x)), (szx), KA2PA((y)), (szy))
 

kernel/generic/include/stacktrace.h

@@ -42 +42 @@
 
 typedef struct {
-        uintptr_t fp;
-        uintptr_t pc;
-        struct istate *istate;
-} stack_trace_context_t;
-
-typedef struct {
-        bool (* stack_trace_context_validate)(stack_trace_context_t *);
-        bool (* frame_pointer_prev)(stack_trace_context_t *, uintptr_t *);
-        bool (* return_address_get)(stack_trace_context_t *, uintptr_t *);
+        bool (* frame_pointer_validate)(uintptr_t);
+        bool (* frame_pointer_prev)(uintptr_t, uintptr_t *);
+        bool (* return_address_get)(uintptr_t, uintptr_t *);
         bool (* symbol_resolve)(uintptr_t, const char **, uintptr_t *);
 } stack_trace_ops_t;
@@ -59 +53 @@
 extern void stack_trace(void);
 extern void stack_trace_istate(struct istate *);
-extern void stack_trace_ctx(stack_trace_ops_t *, stack_trace_context_t *);
+extern void stack_trace_fp_pc(stack_trace_ops_t *, uintptr_t, uintptr_t);
 
 /*
@@ -67 +61 @@
 extern uintptr_t program_counter_get(void);
 
-extern bool kernel_stack_trace_context_validate(stack_trace_context_t *);
-extern bool kernel_frame_pointer_prev(stack_trace_context_t *, uintptr_t *);
-extern bool kernel_return_address_get(stack_trace_context_t *, uintptr_t *);
+extern bool kernel_frame_pointer_validate(uintptr_t);
+extern bool kernel_frame_pointer_prev(uintptr_t, uintptr_t *);
+extern bool kernel_return_address_get(uintptr_t, uintptr_t *);
 
-extern bool uspace_stack_trace_context_validate(stack_trace_context_t *);
-extern bool uspace_frame_pointer_prev(stack_trace_context_t *, uintptr_t *);
-extern bool uspace_return_address_get(stack_trace_context_t *, uintptr_t *);
+extern bool uspace_frame_pointer_validate(uintptr_t);
+extern bool uspace_frame_pointer_prev(uintptr_t, uintptr_t *);
+extern bool uspace_return_address_get(uintptr_t, uintptr_t *);
 
 #endif

kernel/generic/src/debug/stacktrace.c

@@ -27 +27 @@
  */
 
-/** @addtogroup genericdebug
+/** @addtogroup genericdebug 
  * @{
  */
@@ -42 +42 @@
 
 void
-stack_trace_ctx(stack_trace_ops_t *ops, stack_trace_context_t *ctx)
+stack_trace_fp_pc(stack_trace_ops_t *ops, uintptr_t fp, uintptr_t pc)
 {
         int cnt = 0;
         const char *symbol;
         uintptr_t offset;
-        uintptr_t fp;
-        uintptr_t pc;
         
-        while (cnt++ < STACK_FRAMES_MAX &&
-            ops->stack_trace_context_validate(ctx)) {
+        while (cnt++ < STACK_FRAMES_MAX && ops->frame_pointer_validate(fp)) {
                 if (ops->symbol_resolve &&
-                    ops->symbol_resolve(ctx->pc, &symbol, &offset)) {
+                    ops->symbol_resolve(pc, &symbol, &offset)) {
                         if (offset)
-                                printf("%p: %s+%" PRIp "()\n",
-                                    ctx->fp, symbol, offset);
+                                printf("%p: %s+%" PRIp "()\n", fp, symbol, offset);
                         else
-                                printf("%p: %s()\n",
-                                    ctx->fp, symbol);
+                                printf("%p: %s()\n", fp, symbol);
                 } else {
-                        printf("%p: %p()\n", ctx->fp, ctx->pc);
+                        printf("%p: %p()\n", fp, pc);
                 }
-                if (!ops->return_address_get(ctx, &pc))
+                if (!ops->return_address_get(fp, &pc))
                         break;
-                if (!ops->frame_pointer_prev(ctx, &fp))
+                if (!ops->frame_pointer_prev(fp, &fp))
                         break;
-                ctx->fp = fp;
-                ctx->pc = pc;
         }
 }
@@ -74 +67 @@
 void stack_trace(void)
 {
-        stack_trace_context_t ctx = {
-                .fp = frame_pointer_get(),
-                .pc = program_counter_get(),
-                .istate = NULL
-        };
-
-        stack_trace_ctx(&kst_ops, &ctx);
+        stack_trace_fp_pc(&kst_ops, frame_pointer_get(), program_counter_get());
 
         /*
@@ -91 +78 @@
 void stack_trace_istate(istate_t *istate)
 {
-        stack_trace_context_t ctx = {
-                .fp = istate_get_fp(istate),
-                .pc = istate_get_pc(istate),
-                .istate = istate
-        };
-        
         if (istate_from_uspace(istate))
-                stack_trace_ctx(&ust_ops, &ctx);
+                stack_trace_fp_pc(&ust_ops, istate_get_fp(istate),
+                    istate_get_pc(istate));
         else
-                stack_trace_ctx(&kst_ops, &ctx);
+                stack_trace_fp_pc(&kst_ops, istate_get_fp(istate),
+                    istate_get_pc(istate));
 }
 
-static bool
-kernel_symbol_resolve(uintptr_t addr, const char **sp, uintptr_t *op)
+static bool kernel_symbol_resolve(uintptr_t addr, const char **sp, uintptr_t *op)
 {
         return (symtab_name_lookup(addr, sp, op) == 0);
@@ -110 +92 @@
 
 stack_trace_ops_t kst_ops = {
-        .stack_trace_context_validate = kernel_stack_trace_context_validate,
+        .frame_pointer_validate = kernel_frame_pointer_validate,
         .frame_pointer_prev = kernel_frame_pointer_prev,
         .return_address_get = kernel_return_address_get,
@@ -117 +99 @@
 
 stack_trace_ops_t ust_ops = {
-        .stack_trace_context_validate = uspace_stack_trace_context_validate,
+        .frame_pointer_validate = uspace_frame_pointer_validate,
         .frame_pointer_prev = uspace_frame_pointer_prev,
         .return_address_get = uspace_return_address_get,

kernel/generic/src/main/main.c

@@ -147 +147 @@
         size_t i;
         for (i = 0; i < init.cnt; i++) {
-                if (PA_OVERLAPS(config.stack_base, config.stack_size,
+                if (PA_overlaps(config.stack_base, config.stack_size,
                     init.tasks[i].addr, init.tasks[i].size))
                         config.stack_base = ALIGN_UP(init.tasks[i].addr +
@@ -155 +155 @@
         /* Avoid placing stack on top of boot allocations. */
         if (ballocs.size) {
-                if (PA_OVERLAPS(config.stack_base, config.stack_size,
+                if (PA_overlaps(config.stack_base, config.stack_size,
                     ballocs.base, ballocs.size))
                         config.stack_base = ALIGN_UP(ballocs.base +

kernel/generic/src/mm/frame.c

@@ -121 +121 @@
  *
  */
-NO_TRACE static size_t zones_insert_zone(pfn_t base, size_t count,
-    zone_flags_t flags)
+NO_TRACE static size_t zones_insert_zone(pfn_t base, size_t count)
 {
         if (zones.count + 1 == ZONES_MAX) {
@@ -132 +131 @@
         for (i = 0; i < zones.count; i++) {
                 /* Check for overlap */
-                if (overlaps(zones.info[i].base, zones.info[i].count,
-                    base, count)) {
-                        
-                        /*
-                         * If the overlaping zones are of the same type
-                         * and the new zone is completely within the previous
-                         * one, then quietly ignore the new zone.
-                         *
-                         */
-                        
-                        if ((zones.info[i].flags != flags) ||
-                            (!iswithin(zones.info[i].base, zones.info[i].count,
-                            base, count))) {
-                                printf("Zone (%p, %p) overlaps with previous zone (%p, %p)!\n",
-                                    PFN2ADDR(base), PFN2ADDR(count),
-                                    PFN2ADDR(zones.info[i].base),
-                                    PFN2ADDR(zones.info[i].count));
-                        }
-                        
+                if (overlaps(base, count,
+                    zones.info[i].base, zones.info[i].count)) {
+                        printf("Zone (%p, %p) overlaps with zone (%p, %p)!\n",
+                            PFN2ADDR(base), PFN2ADDR(base + count),
+                            PFN2ADDR(zones.info[i].base),
+                            PFN2ADDR(zones.info[i].base + zones.info[i].count));
                         return (size_t) -1;
                 }
@@ -161 +147 @@
         for (j = zones.count; j > i; j--) {
                 zones.info[j] = zones.info[j - 1];
-                if (zones.info[j].buddy_system != NULL)
-                        zones.info[j].buddy_system->data =
-                            (void *) &zones.info[j];
+                zones.info[j].buddy_system->data =
+                    (void *) &zones.info[j - 1];
         }
         
@@ -763 +748 @@
         for (i = z2 + 1; i < zones.count; i++) {
                 zones.info[i - 1] = zones.info[i];
-                if (zones.info[i - 1].buddy_system != NULL)
-                        zones.info[i - 1].buddy_system->data =
-                            (void *) &zones.info[i - 1];
+                zones.info[i - 1].buddy_system->data =
+                    (void *) &zones.info[i - 1];
         }
         
@@ -914 +898 @@
                 }
                 
-                size_t znum = zones_insert_zone(start, count, flags);
+                size_t znum = zones_insert_zone(start, count);
                 if (znum == (size_t) -1) {
                         irq_spinlock_unlock(&zones.lock, true);
@@ -937 +921 @@
         
         /* Non-available zone */
-        size_t znum = zones_insert_zone(start, count, flags);
+        size_t znum = zones_insert_zone(start, count);
         if (znum == (size_t) -1) {
                 irq_spinlock_unlock(&zones.lock, true);

tools/mkfat.py

@@ -343 +343 @@
 def usage(prname):
         "Print usage syntax"
-        print prname + " <EXTRA_BYTES> <PATH> <IMAGE>"
+        print prname + " <PATH> <IMAGE>"
 
 def main():
-        if (len(sys.argv) < 4):
+        if (len(sys.argv) < 3):
                 usage(sys.argv[0])
                 return
         
-        if (not sys.argv[1].isdigit()):
-                print "<EXTRA_BYTES> must be a number"
-                return
-        
-        extra_bytes = int(sys.argv[1])
-        
-        path = os.path.abspath(sys.argv[2])
+        path = os.path.abspath(sys.argv[1])
         if (not os.path.isdir(path)):
                 print "<PATH> must be a directory"
@@ -371 +365 @@
         
         # Make sure the filesystem is large enought for FAT16
-        size = subtree_size(path, cluster_size, dirent_size) + reserved_clusters * cluster_size + extra_bytes
+        size = subtree_size(path, cluster_size, dirent_size) + reserved_clusters * cluster_size
         while (size / cluster_size < fat16_clusters):
                 if (cluster_size > sector_size):
                         cluster_size /= 2
-                        size = subtree_size(path, cluster_size, dirent_size) + reserved_clusters * cluster_size + extra_bytes
+                        size = subtree_size(path, cluster_size, dirent_size) + reserved_clusters * cluster_size
                 else:
                         size = fat16_clusters * cluster_size + reserved_clusters * cluster_size
@@ -387 +381 @@
         data_start = root_start + root_size
         
-        outf = file(sys.argv[3], "w")
+        outf = file(sys.argv[2], "w")
         
         boot_sector = xstruct.create(BOOT_SECTOR)

uspace/Makefile.common

@@ -172 +172 @@
 ifneq ($(BINARY),)
 %.disasm: $(BINARY)
-ifeq ($(CONFIG_LINE_DEBUG),y)
-        $(OBJDUMP) -d -S $< > $@
-else
         $(OBJDUMP) -d $< > $@
-endif
 
 $(BINARY): $(LINKER_SCRIPT) $(OBJECTS) $(LIBS) $(BASE_LIBS)

uspace/app/klog/klog.c

@@ -43 +43 @@
 #include <event.h>
 #include <errno.h>
-#include <str_error.h>
 #include <io/klog.h>
 
-#define NAME       "klog"
-#define LOG_FNAME  "/log/klog"
+#define NAME  "klog"
 
 /* Pointer to klog area */
 static wchar_t *klog;
 static size_t klog_length;
-
-static FILE *log;
 
 static void interrupt_received(ipc_callid_t callid, ipc_call_t *call)
@@ -62 +58 @@
         size_t i;
         
-        for (i = klog_len - klog_stored; i < klog_len; i++) {
-                wchar_t ch = klog[(klog_start + i) % klog_length];
-                
-                putchar(ch);
-                
-                if (log != NULL)
-                        fputc(ch, log);
-        }
-        
-        if (log != NULL) {
-                fflush(log);
-                fsync(fileno(log));
-        }
+        for (i = klog_len - klog_stored; i < klog_len; i++)
+                putchar(klog[(klog_start + i) % klog_length]);
 }
 
@@ -106 +91 @@
         }
         
-        /*
-         * Mode "a" would be definitively much better here, but it is
-         * not well supported by the FAT driver.
-         *
-         */
-        log = fopen(LOG_FNAME, "w");
-        if (log == NULL)
-                printf("%s: Unable to create log file %s (%s)\n", NAME, LOG_FNAME,
-                    str_error(errno));
-        
         async_set_interrupt_received(interrupt_received);
         klog_update();

uspace/lib/c/generic/io/io.c

@@ -757 +757 @@
 }
 
-int fileno(FILE *stream)
-{
-        if (stream->klog) {
-                errno = EBADF;
-                return -1;
-        }
-        
-        return stream->fd;
-}
-
 int fphone(FILE *stream)
 {

uspace/lib/c/include/stdio.h

@@ -171 +171 @@
 extern off64_t ftell(FILE *);
 extern int feof(FILE *);
-extern int fileno(FILE *);
 
 extern int fflush(FILE *);

uspace/srv/fs/fat/fat.h

@@ -48 +48 @@
 
 #define min(a, b)               ((a) < (b) ? (a) : (b))
-
-/*
- * Convenience macros for accessing some frequently used boot sector members.
- */
-#define BPS(bs)         uint16_t_le2host((bs)->bps)
-#define SPC(bs)         (bs)->spc
-#define RSCNT(bs)       uint16_t_le2host((bs)->rscnt)
-#define FATCNT(bs)      (bs)->fatcnt
-#define SF(bs)          uint16_t_le2host((bs)->sec_per_fat)
-#define RDE(bs)         uint16_t_le2host((bs)->root_ent_max)
-#define TS(bs)          (uint16_t_le2host((bs)->totsec16) != 0 ? \
-                        uint16_t_le2host((bs)->totsec16) : \
-                        uint32_t_le2host(bs->totsec32))
 
 #define BS_BLOCK                0
@@ -211 +198 @@
         unsigned                refcnt;
         bool                    dirty;
-
-        /*
-         * Cache of the node's last and "current" cluster to avoid some
-         * unnecessary FAT walks.
-         */
-        /* Node's last cluster in FAT. */
-        bool            lastc_cached_valid;
-        fat_cluster_t   lastc_cached_value;
-        /* Node's "current" cluster, i.e. where the last I/O took place. */
-        bool            currc_cached_valid;
-        aoff64_t        currc_cached_bn;
-        fat_cluster_t   currc_cached_value;
 } fat_node_t;
 

uspace/srv/fs/fat/fat_fat.c

@@ -49 +49 @@
 #include <mem.h>
 
-/*
- * Convenience macros for computing some frequently used values from the
- * primitive boot sector members.
- */
-#define RDS(bs)         ((sizeof(fat_dentry_t) * RDE((bs))) / BPS((bs))) + \
-                        (((sizeof(fat_dentry_t) * RDE((bs))) % BPS((bs))) != 0)
-#define SSA(bs)         (RSCNT((bs)) + FATCNT((bs)) * SF((bs)) + RDS(bs))
-
-#define CLBN2PBN(bs, cl, bn) \
-        (SSA((bs)) + ((cl) - FAT_CLST_FIRST) * SPC((bs)) + (bn) % SPC((bs)))
-
 /**
  * The fat_alloc_lock mutex protects all copies of the File Allocation Table
@@ -85 +74 @@
 {
         block_t *b;
+        unsigned bps;
+        unsigned rscnt;         /* block address of the first FAT */
         uint16_t clusters = 0;
         fat_cluster_t clst = firstc;
         int rc;
+
+        bps = uint16_t_le2host(bs->bps);
+        rscnt = uint16_t_le2host(bs->rscnt);
 
         if (firstc == FAT_CLST_RES0) {
@@ -105 +99 @@
                 if (lastc)
                         *lastc = clst;  /* remember the last cluster number */
-                fsec = (clst * sizeof(fat_cluster_t)) / BPS(bs);
-                fidx = clst % (BPS(bs) / sizeof(fat_cluster_t));
+                fsec = (clst * sizeof(fat_cluster_t)) / bps;
+                fidx = clst % (bps / sizeof(fat_cluster_t));
                 /* read FAT1 */
-                rc = block_get(&b, dev_handle, RSCNT(bs) + fsec,
-                    BLOCK_FLAGS_NONE);
+                rc = block_get(&b, dev_handle, rscnt + fsec, BLOCK_FLAGS_NONE);
                 if (rc != EOK)
                         return rc;
@@ -132 +125 @@
  * @param block         Pointer to a block pointer for storing result.
  * @param bs            Buffer holding the boot sector of the file system.
- * @param nodep         FAT node.
+ * @param dev_handle    Device handle of the file system.
+ * @param firstc        First cluster used by the file. Can be zero if the file
+ *                      is empty.
  * @param bn            Block number.
  * @param flags         Flags passed to libblock.
@@ -139 +134 @@
  */
 int
-fat_block_get(block_t **block, struct fat_bs *bs, fat_node_t *nodep,
-    aoff64_t bn, int flags)
-{
-        fat_cluster_t firstc = nodep->firstc;
-        fat_cluster_t currc;
-        aoff64_t relbn = bn;
-        int rc;
-
-        if (!nodep->size)
-                return ELIMIT;
-
-        if (nodep->firstc == FAT_CLST_ROOT) 
-                goto fall_through;
-
-        if (((((nodep->size - 1) / BPS(bs)) / SPC(bs)) == bn / SPC(bs)) &&
-            nodep->lastc_cached_valid) {
-                /*
-                 * This is a request to read a block within the last cluster
-                 * when fortunately we have the last cluster number cached.
-                 */
-                return block_get(block, nodep->idx->dev_handle,
-                    CLBN2PBN(bs, nodep->lastc_cached_value, bn), flags);
-        }
-
-        if (nodep->currc_cached_valid && bn >= nodep->currc_cached_bn) {
-                /*
-                 * We can start with the cluster cached by the previous call to
-                 * fat_block_get().
-                 */
-                firstc = nodep->currc_cached_value;
-                relbn -= (nodep->currc_cached_bn / SPC(bs)) * SPC(bs);
-        }
-
-fall_through:
-        rc = _fat_block_get(block, bs, nodep->idx->dev_handle, firstc,
-            &currc, relbn, flags);
-        if (rc != EOK)
-                return rc;
-        
-        /*
-         * Update the "current" cluster cache.
-         */
-        nodep->currc_cached_valid = true;
-        nodep->currc_cached_bn = bn;
-        nodep->currc_cached_value = currc;
-
-        return rc;
-}
-
-/** Read block from file located on a FAT file system.
- *
- * @param block         Pointer to a block pointer for storing result.
- * @param bs            Buffer holding the boot sector of the file system.
- * @param dev_handle    Device handle of the file system.
- * @param fcl           First cluster used by the file. Can be zero if the file
- *                      is empty.
- * @param clp           If not NULL, address where the cluster containing bn
- *                      will be stored.
- *                      stored 
- * @param bn            Block number.
- * @param flags         Flags passed to libblock.
- *
- * @return              EOK on success or a negative error code.
- */
-int
 _fat_block_get(block_t **block, fat_bs_t *bs, dev_handle_t dev_handle,
-    fat_cluster_t fcl, fat_cluster_t *clp, aoff64_t bn, int flags)
-{
+    fat_cluster_t firstc, aoff64_t bn, int flags)
+{
+        unsigned bps;
+        unsigned rscnt;         /* block address of the first FAT */
+        unsigned rde;
+        unsigned rds;           /* root directory size */
+        unsigned sf;
+        unsigned ssa;           /* size of the system area */
         uint16_t clusters;
         unsigned max_clusters;
-        fat_cluster_t c;
+        fat_cluster_t lastc;
         int rc;
 
@@ -215 +151 @@
          * This function can only operate on non-zero length files.
          */
-        if (fcl == FAT_CLST_RES0)
+        if (firstc == FAT_CLST_RES0)
                 return ELIMIT;
 
-        if (fcl == FAT_CLST_ROOT) {
+        bps = uint16_t_le2host(bs->bps);
+        rscnt = uint16_t_le2host(bs->rscnt);
+        rde = uint16_t_le2host(bs->root_ent_max);
+        sf = uint16_t_le2host(bs->sec_per_fat);
+
+        rds = (sizeof(fat_dentry_t) * rde) / bps;
+        rds += ((sizeof(fat_dentry_t) * rde) % bps != 0);
+        ssa = rscnt + bs->fatcnt * sf + rds;
+
+        if (firstc == FAT_CLST_ROOT) {
                 /* root directory special case */
-                assert(bn < RDS(bs));
-                rc = block_get(block, dev_handle,
-                    RSCNT(bs) + FATCNT(bs) * SF(bs) + bn, flags);
+                assert(bn < rds);
+                rc = block_get(block, dev_handle, rscnt + bs->fatcnt * sf + bn,
+                    flags);
                 return rc;
         }
 
-        max_clusters = bn / SPC(bs);
-        rc = fat_cluster_walk(bs, dev_handle, fcl, &c, &clusters, max_clusters);
+        max_clusters = bn / bs->spc;
+        rc = fat_cluster_walk(bs, dev_handle, firstc, &lastc, &clusters,
+            max_clusters);
         if (rc != EOK)
                 return rc;
         assert(clusters == max_clusters);
 
-        rc = block_get(block, dev_handle, CLBN2PBN(bs, c, bn), flags);
-
-        if (clp)
-                *clp = c;
+        rc = block_get(block, dev_handle,
+            ssa + (lastc - FAT_CLST_FIRST) * bs->spc + bn % bs->spc, flags);
 
         return rc;
@@ -254 +198 @@
 int fat_fill_gap(fat_bs_t *bs, fat_node_t *nodep, fat_cluster_t mcl, aoff64_t pos)
 {
+        uint16_t bps;
+        unsigned spc;
         block_t *b;
         aoff64_t o, boundary;
         int rc;
 
-        boundary = ROUND_UP(nodep->size, BPS(bs) * SPC(bs));
+        bps = uint16_t_le2host(bs->bps);
+        spc = bs->spc;
+        
+        boundary = ROUND_UP(nodep->size, bps * spc);
 
         /* zero out already allocated space */
         for (o = nodep->size; o < pos && o < boundary;
-            o = ALIGN_DOWN(o + BPS(bs), BPS(bs))) {
-                int flags = (o % BPS(bs) == 0) ?
+            o = ALIGN_DOWN(o + bps, bps)) {
+                int flags = (o % bps == 0) ?
                     BLOCK_FLAGS_NOREAD : BLOCK_FLAGS_NONE;
-                rc = fat_block_get(&b, bs, nodep, o / BPS(bs), flags);
-                if (rc != EOK)
-                        return rc;
-                memset(b->data + o % BPS(bs), 0, BPS(bs) - o % BPS(bs));
+                rc = fat_block_get(&b, bs, nodep, o / bps, flags);
+                if (rc != EOK)
+                        return rc;
+                memset(b->data + o % bps, 0, bps - o % bps);
                 b->dirty = true;                /* need to sync node */
                 rc = block_put(b);
@@ -279 +228 @@
         
         /* zero out the initial part of the new cluster chain */
-        for (o = boundary; o < pos; o += BPS(bs)) {
+        for (o = boundary; o < pos; o += bps) {
                 rc = _fat_block_get(&b, bs, nodep->idx->dev_handle, mcl,
-                    NULL, (o - boundary) / BPS(bs), BLOCK_FLAGS_NOREAD);
-                if (rc != EOK)
-                        return rc;
-                memset(b->data, 0, min(BPS(bs), pos - o));
+                    (o - boundary) / bps, BLOCK_FLAGS_NOREAD);
+                if (rc != EOK)
+                        return rc;
+                memset(b->data, 0, min(bps, pos - o));
                 b->dirty = true;                /* need to sync node */
                 rc = block_put(b);
@@ -308 +257 @@
 {
         block_t *b;
+        uint16_t bps;
+        uint16_t rscnt;
+        uint16_t sf;
         fat_cluster_t *cp;
         int rc;
 
-        rc = block_get(&b, dev_handle, RSCNT(bs) + SF(bs) * fatno +
-            (clst * sizeof(fat_cluster_t)) / BPS(bs), BLOCK_FLAGS_NONE);
+        bps = uint16_t_le2host(bs->bps);
+        rscnt = uint16_t_le2host(bs->rscnt);
+        sf = uint16_t_le2host(bs->sec_per_fat);
+
+        rc = block_get(&b, dev_handle, rscnt + sf * fatno +
+            (clst * sizeof(fat_cluster_t)) / bps, BLOCK_FLAGS_NONE);
         if (rc != EOK)
                 return rc;
-        cp = (fat_cluster_t *)b->data +
-            clst % (BPS(bs) / sizeof(fat_cluster_t));
+        cp = (fat_cluster_t *)b->data + clst % (bps / sizeof(fat_cluster_t));
         *value = uint16_t_le2host(*cp);
         rc = block_put(b);
@@ -338 +293 @@
 {
         block_t *b;
+        uint16_t bps;
+        uint16_t rscnt;
+        uint16_t sf;
         fat_cluster_t *cp;
         int rc;
 
-        assert(fatno < FATCNT(bs));
-        rc = block_get(&b, dev_handle, RSCNT(bs) + SF(bs) * fatno +
-            (clst * sizeof(fat_cluster_t)) / BPS(bs), BLOCK_FLAGS_NONE);
+        bps = uint16_t_le2host(bs->bps);
+        rscnt = uint16_t_le2host(bs->rscnt);
+        sf = uint16_t_le2host(bs->sec_per_fat);
+
+        assert(fatno < bs->fatcnt);
+        rc = block_get(&b, dev_handle, rscnt + sf * fatno +
+            (clst * sizeof(fat_cluster_t)) / bps, BLOCK_FLAGS_NONE);
         if (rc != EOK)
                 return rc;
-        cp = (fat_cluster_t *)b->data +
-            clst % (BPS(bs) / sizeof(fat_cluster_t));
+        cp = (fat_cluster_t *)b->data + clst % (bps / sizeof(fat_cluster_t));
         *cp = host2uint16_t_le(value);
         b->dirty = true;                /* need to sync block */
@@ -403 +364 @@
     fat_cluster_t *mcl, fat_cluster_t *lcl)
 {
+        uint16_t bps;
+        uint16_t rscnt;
+        uint16_t sf;
+        uint32_t ts;
+        unsigned rde;
+        unsigned rds;
+        unsigned ssa;
         block_t *blk;
         fat_cluster_t *lifo;    /* stack for storing free cluster numbers */ 
@@ -413 +381 @@
                 return ENOMEM;
         
+        bps = uint16_t_le2host(bs->bps);
+        rscnt = uint16_t_le2host(bs->rscnt);
+        sf = uint16_t_le2host(bs->sec_per_fat);
+        rde = uint16_t_le2host(bs->root_ent_max);
+        ts = (uint32_t) uint16_t_le2host(bs->totsec16);
+        if (ts == 0)
+                ts = uint32_t_le2host(bs->totsec32);
+
+        rds = (sizeof(fat_dentry_t) * rde) / bps;
+        rds += ((sizeof(fat_dentry_t) * rde) % bps != 0);
+        ssa = rscnt + bs->fatcnt * sf + rds;
+        
         /*
          * Search FAT1 for unused clusters.
          */
         fibril_mutex_lock(&fat_alloc_lock);
-        for (b = 0, cl = 0; b < SF(bs); b++) {
-                rc = block_get(&blk, dev_handle, RSCNT(bs) + b,
-                    BLOCK_FLAGS_NONE);
+        for (b = 0, cl = 0; b < sf; b++) {
+                rc = block_get(&blk, dev_handle, rscnt + b, BLOCK_FLAGS_NONE);
                 if (rc != EOK)
                         goto error;
-                for (c = 0; c < BPS(bs) / sizeof(fat_cluster_t); c++, cl++) {
+                for (c = 0; c < bps / sizeof(fat_cluster_t); c++, cl++) {
                         /*
-                         * Check if the entire cluster is physically there.
-                         * This check becomes necessary when the file system is
-                         * created with fewer total sectors than how many is
-                         * inferred from the size of the file allocation table
-                         * or when the last cluster ends beyond the end of the
-                         * device.
+                         * Check if the cluster is physically there. This check
+                         * becomes necessary when the file system is created
+                         * with fewer total sectors than how many is inferred
+                         * from the size of the file allocation table.
                          */
-                        if ((cl >= FAT_CLST_FIRST) &&
-                            CLBN2PBN(bs, cl, SPC(bs) - 1) >= TS(bs)) {
+                        if ((cl >= 2) && ((cl - 2) * bs->spc + ssa >= ts)) {
                                 rc = block_put(blk);
                                 if (rc != EOK)
@@ -535 +511 @@
  * @param nodep         Node representing the file.
  * @param mcl           First cluster of the cluster chain to append.
- * @param lcl           Last cluster of the cluster chain to append.
  *
  * @return              EOK on success or a negative error code.
  */
-int
-fat_append_clusters(fat_bs_t *bs, fat_node_t *nodep, fat_cluster_t mcl,
-    fat_cluster_t lcl)
+int fat_append_clusters(fat_bs_t *bs, fat_node_t *nodep, fat_cluster_t mcl)
 {
         dev_handle_t dev_handle = nodep->idx->dev_handle;
-        fat_cluster_t lastc;
+        fat_cluster_t lcl;
         uint16_t numc;
         uint8_t fatno;
         int rc;
 
-        if (nodep->lastc_cached_valid) {
-                lastc = nodep->lastc_cached_value;
-                nodep->lastc_cached_valid = false;
-        } else {
-                rc = fat_cluster_walk(bs, dev_handle, nodep->firstc, &lastc,
-                    &numc, (uint16_t) -1);
-                if (rc != EOK)
-                        return rc;
-
-                if (numc == 0) {
-                        /* No clusters allocated to the node yet. */
-                        nodep->firstc = mcl;
-                        nodep->dirty = true;    /* need to sync node */
-                        return EOK;
-                }
+        rc = fat_cluster_walk(bs, dev_handle, nodep->firstc, &lcl, &numc,
+            (uint16_t) -1);
+        if (rc != EOK)
+                return rc;
+
+        if (numc == 0) {
+                /* No clusters allocated to the node yet. */
+                nodep->firstc = mcl;
+                nodep->dirty = true;            /* need to sync node */
+                return EOK;
         }
 
         for (fatno = FAT1; fatno < bs->fatcnt; fatno++) {
-                rc = fat_set_cluster(bs, nodep->idx->dev_handle, fatno, lastc,
+                rc = fat_set_cluster(bs, nodep->idx->dev_handle, fatno, lcl,
                     mcl);
                 if (rc != EOK)
                         return rc;
         }
-
-        nodep->lastc_cached_valid = true;
-        nodep->lastc_cached_value = lcl;
 
         return EOK;
@@ -583 +548 @@
  * @param bs            Buffer holding the boot sector of the file system.
  * @param nodep         FAT node where the chopping will take place.
- * @param lcl           Last cluster which will remain in the node. If this
+ * @param lastc         Last cluster which will remain in the node. If this
  *                      argument is FAT_CLST_RES0, then all clusters will
  *                      be chopped off.
@@ -589 +554 @@
  * @return              EOK on success or a negative return code.
  */
-int fat_chop_clusters(fat_bs_t *bs, fat_node_t *nodep, fat_cluster_t lcl)
-{
-        int rc;
+int fat_chop_clusters(fat_bs_t *bs, fat_node_t *nodep, fat_cluster_t lastc)
+{
+        int rc;
+
         dev_handle_t dev_handle = nodep->idx->dev_handle;
-
-        /*
-         * Invalidate cached cluster numbers.
-         */
-        nodep->lastc_cached_valid = false;
-        if (nodep->currc_cached_value != lcl)
-                nodep->currc_cached_valid = false;
-
-        if (lcl == FAT_CLST_RES0) {
+        if (lastc == FAT_CLST_RES0) {
                 /* The node will have zero size and no clusters allocated. */
                 rc = fat_free_clusters(bs, dev_handle, nodep->firstc);
@@ -612 +570 @@
                 unsigned fatno;
 
-                rc = fat_get_cluster(bs, dev_handle, FAT1, lcl, &nextc);
+                rc = fat_get_cluster(bs, dev_handle, FAT1, lastc, &nextc);
                 if (rc != EOK)
                         return rc;
@@ -618 +576 @@
                 /* Terminate the cluster chain in all copies of FAT. */
                 for (fatno = FAT1; fatno < bs->fatcnt; fatno++) {
-                        rc = fat_set_cluster(bs, dev_handle, fatno, lcl,
+                        rc = fat_set_cluster(bs, dev_handle, fatno, lastc,
                             FAT_CLST_LAST1);
                         if (rc != EOK)
@@ -630 +588 @@
         }
 
-        /*
-         * Update and re-enable the last cluster cache.
-         */
-        nodep->lastc_cached_valid = true;
-        nodep->lastc_cached_value = lcl;
-
         return EOK;
 }
@@ -644 +596 @@
         int i;
         block_t *b;
-        int rc;
-
-        for (i = 0; i < SPC(bs); i++) {
-                rc = _fat_block_get(&b, bs, dev_handle, c, NULL, i,
+        unsigned bps;
+        int rc;
+
+        bps = uint16_t_le2host(bs->bps);
+        
+        for (i = 0; i < bs->spc; i++) {
+                rc = _fat_block_get(&b, bs, dev_handle, c, i,
                     BLOCK_FLAGS_NOREAD);
                 if (rc != EOK)
                         return rc;
-                memset(b->data, 0, BPS(bs));
+                memset(b->data, 0, bps);
                 b->dirty = true;
                 rc = block_put(b);

uspace/srv/fs/fat/fat_fat.h

@@ -64 +64 @@
     fat_cluster_t *, uint16_t *, uint16_t);
 
-extern int fat_block_get(block_t **, struct fat_bs *, struct fat_node *,
-    aoff64_t, int);
+#define fat_block_get(b, bs, np, bn, flags) \
+    _fat_block_get((b), (bs), (np)->idx->dev_handle, (np)->firstc, (bn), \
+    (flags))
+
 extern int _fat_block_get(block_t **, struct fat_bs *, dev_handle_t,
-    fat_cluster_t, fat_cluster_t *, aoff64_t, int);
+    fat_cluster_t, aoff64_t, int);
 
 extern int fat_append_clusters(struct fat_bs *, struct fat_node *,
-    fat_cluster_t, fat_cluster_t);
+    fat_cluster_t);
 extern int fat_chop_clusters(struct fat_bs *, struct fat_node *,
     fat_cluster_t);

uspace/srv/fs/fat/fat_ops.c

@@ -60 +60 @@
 #define FS_NODE(node)   ((node) ? (node)->bp : NULL)
 
-#define DPS(bs)         (BPS((bs)) / sizeof(fat_dentry_t))
-#define BPC(bs)         (BPS((bs)) * SPC((bs)))
-
 /** Mutex protecting the list of cached free FAT nodes. */
 static FIBRIL_MUTEX_INITIALIZE(ffn_mutex);
@@ -104 +101 @@
         node->refcnt = 0;
         node->dirty = false;
-        node->lastc_cached_valid = false;
-        node->lastc_cached_value = FAT_CLST_LAST1;
-        node->currc_cached_valid = false;
-        node->currc_cached_bn = 0;
-        node->currc_cached_value = FAT_CLST_LAST1;
 }
 
@@ -116 +108 @@
         fat_bs_t *bs;
         fat_dentry_t *d;
+        uint16_t bps;
+        unsigned dps;
         int rc;
         
@@ -121 +115 @@
 
         bs = block_bb_get(node->idx->dev_handle);
+        bps = uint16_t_le2host(bs->bps);
+        dps = bps / sizeof(fat_dentry_t);
         
         /* Read the block that contains the dentry of interest. */
         rc = _fat_block_get(&b, bs, node->idx->dev_handle, node->idx->pfc,
-            NULL, (node->idx->pdi * sizeof(fat_dentry_t)) / BPS(bs),
-            BLOCK_FLAGS_NONE);
+            (node->idx->pdi * sizeof(fat_dentry_t)) / bps, BLOCK_FLAGS_NONE);
         if (rc != EOK)
                 return rc;
 
-        d = ((fat_dentry_t *)b->data) + (node->idx->pdi % DPS(bs));
+        d = ((fat_dentry_t *)b->data) + (node->idx->pdi % dps);
 
         d->firstc = host2uint16_t_le(node->firstc);
@@ -271 +266 @@
         fat_dentry_t *d;
         fat_node_t *nodep = NULL;
+        unsigned bps;
+        unsigned spc;
+        unsigned dps;
         int rc;
 
@@ -300 +298 @@
 
         bs = block_bb_get(idxp->dev_handle);
+        bps = uint16_t_le2host(bs->bps);
+        spc = bs->spc;
+        dps = bps / sizeof(fat_dentry_t);
 
         /* Read the block that contains the dentry of interest. */
-        rc = _fat_block_get(&b, bs, idxp->dev_handle, idxp->pfc, NULL,
-            (idxp->pdi * sizeof(fat_dentry_t)) / BPS(bs), BLOCK_FLAGS_NONE);
+        rc = _fat_block_get(&b, bs, idxp->dev_handle, idxp->pfc,
+            (idxp->pdi * sizeof(fat_dentry_t)) / bps, BLOCK_FLAGS_NONE);
         if (rc != EOK) {
                 (void) fat_node_put(FS_NODE(nodep));
@@ -309 +310 @@
         }
 
-        d = ((fat_dentry_t *)b->data) + (idxp->pdi % DPS(bs));
+        d = ((fat_dentry_t *)b->data) + (idxp->pdi % dps);
         if (d->attr & FAT_ATTR_SUBDIR) {
                 /* 
@@ -329 +330 @@
                         return rc;
                 }
-                nodep->size = BPS(bs) * SPC(bs) * clusters;
+                nodep->size = bps * spc * clusters;
         } else {
                 nodep->type = FAT_FILE;
@@ -367 +368 @@
         char name[FAT_NAME_LEN + 1 + FAT_EXT_LEN + 1];
         unsigned i, j;
+        unsigned bps;           /* bytes per sector */
+        unsigned dps;           /* dentries per sector */
         unsigned blocks;
         fat_dentry_t *d;
@@ -374 +377 @@
         fibril_mutex_lock(&parentp->idx->lock);
         bs = block_bb_get(parentp->idx->dev_handle);
-        blocks = parentp->size / BPS(bs);
+        bps = uint16_t_le2host(bs->bps);
+        dps = bps / sizeof(fat_dentry_t);
+        blocks = parentp->size / bps;
         for (i = 0; i < blocks; i++) {
                 rc = fat_block_get(&b, bs, parentp, i, BLOCK_FLAGS_NONE);
@@ -381 +386 @@
                         return rc;
                 }
-                for (j = 0; j < DPS(bs); j++) { 
+                for (j = 0; j < dps; j++) { 
                         d = ((fat_dentry_t *)b->data) + j;
                         switch (fat_classify_dentry(d)) {
@@ -409 +414 @@
                                 fat_idx_t *idx = fat_idx_get_by_pos(
                                     parentp->idx->dev_handle, parentp->firstc,
-                                    i * DPS(bs) + j);
+                                    i * dps + j);
                                 fibril_mutex_unlock(&parentp->idx->lock);
                                 if (!idx) {
@@ -508 +513 @@
         fat_bs_t *bs;
         fat_cluster_t mcl, lcl;
+        uint16_t bps;
         int rc;
 
         bs = block_bb_get(dev_handle);
+        bps = uint16_t_le2host(bs->bps);
         if (flags & L_DIRECTORY) {
                 /* allocate a cluster */
@@ -539 +546 @@
                 nodep->type = FAT_DIRECTORY;
                 nodep->firstc = mcl;
-                nodep->size = BPS(bs) * SPC(bs);
+                nodep->size = bps * bs->spc;
         } else {
                 nodep->type = FAT_FILE;
@@ -602 +609 @@
         block_t *b;
         unsigned i, j;
+        uint16_t bps;
+        unsigned dps;
         unsigned blocks;
         fat_cluster_t mcl, lcl;
@@ -631 +640 @@
         fibril_mutex_lock(&parentp->idx->lock);
         bs = block_bb_get(parentp->idx->dev_handle);
-
-        blocks = parentp->size / BPS(bs);
+        bps = uint16_t_le2host(bs->bps);
+        dps = bps / sizeof(fat_dentry_t);
+
+        blocks = parentp->size / bps;
 
         for (i = 0; i < blocks; i++) {
@@ -640 +651 @@
                         return rc;
                 }
-                for (j = 0; j < DPS(bs); j++) {
+                for (j = 0; j < dps; j++) {
                         d = ((fat_dentry_t *)b->data) + j;
                         switch (fat_classify_dentry(d)) {
@@ -680 +691 @@
                 return rc;
         }
-        rc = fat_append_clusters(bs, parentp, mcl, lcl);
+        rc = fat_append_clusters(bs, parentp, mcl);
         if (rc != EOK) {
                 (void) fat_free_clusters(bs, parentp->idx->dev_handle, mcl);
@@ -686 +697 @@
                 return rc;
         }
-        parentp->size += BPS(bs) * SPC(bs);
+        parentp->size += bps * bs->spc;
         parentp->dirty = true;          /* need to sync node */
         rc = fat_block_get(&b, bs, parentp, i, BLOCK_FLAGS_NONE);
@@ -760 +771 @@
 
         childp->idx->pfc = parentp->firstc;
-        childp->idx->pdi = i * DPS(bs) + j;
+        childp->idx->pdi = i * dps + j;
         fibril_mutex_unlock(&childp->idx->lock);
 
@@ -782 +793 @@
         fat_bs_t *bs;
         fat_dentry_t *d;
+        uint16_t bps;
         block_t *b;
         bool has_children;
@@ -800 +812 @@
         fibril_mutex_lock(&childp->idx->lock);
         bs = block_bb_get(childp->idx->dev_handle);
+        bps = uint16_t_le2host(bs->bps);
 
         rc = _fat_block_get(&b, bs, childp->idx->dev_handle, childp->idx->pfc,
-            NULL, (childp->idx->pdi * sizeof(fat_dentry_t)) / BPS(bs),
+            (childp->idx->pdi * sizeof(fat_dentry_t)) / bps,
             BLOCK_FLAGS_NONE);
         if (rc != EOK) 
                 goto error;
         d = (fat_dentry_t *)b->data +
-            (childp->idx->pdi % (BPS(bs) / sizeof(fat_dentry_t)));
+            (childp->idx->pdi % (bps / sizeof(fat_dentry_t)));
         /* mark the dentry as not-currently-used */
         d->name[0] = FAT_DENTRY_ERASED;
@@ -839 +852 @@
         fat_bs_t *bs;
         fat_node_t *nodep = FAT_NODE(fn);
+        unsigned bps;
+        unsigned dps;
         unsigned blocks;
         block_t *b;
@@ -851 +866 @@
         fibril_mutex_lock(&nodep->idx->lock);
         bs = block_bb_get(nodep->idx->dev_handle);
-
-        blocks = nodep->size / BPS(bs);
+        bps = uint16_t_le2host(bs->bps);
+        dps = bps / sizeof(fat_dentry_t);
+
+        blocks = nodep->size / bps;
 
         for (i = 0; i < blocks; i++) {
@@ -862 +879 @@
                         return rc;
                 }
-                for (j = 0; j < DPS(bs); j++) {
+                for (j = 0; j < dps; j++) {
                         d = ((fat_dentry_t *)b->data) + j;
                         switch (fat_classify_dentry(d)) {
@@ -959 +976 @@
         enum cache_mode cmode;
         fat_bs_t *bs;
+        uint16_t bps;
+        uint16_t rde;
         
         /* Accept the mount options */
@@ -995 +1014 @@
         bs = block_bb_get(dev_handle);
         
-        if (BPS(bs) != BS_SIZE) {
+        /* Read the number of root directory entries. */
+        bps = uint16_t_le2host(bs->bps);
+        rde = uint16_t_le2host(bs->root_ent_max);
+
+        if (bps != BS_SIZE) {
                 block_fini(dev_handle);
                 ipc_answer_0(rid, ENOTSUP);
@@ -1002 +1025 @@
 
         /* Initialize the block cache */
-        rc = block_cache_init(dev_handle, BPS(bs), 0 /* XXX */, cmode);
+        rc = block_cache_init(dev_handle, bps, 0 /* XXX */, cmode);
         if (rc != EOK) {
                 block_fini(dev_handle);
@@ -1064 +1087 @@
         rootp->refcnt = 1;
         rootp->lnkcnt = 0;      /* FS root is not linked */
-        rootp->size = RDE(bs) * sizeof(fat_dentry_t);
+        rootp->size = rde * sizeof(fat_dentry_t);
         rootp->idx = ridxp;
         ridxp->nodep = rootp;
@@ -1142 +1165 @@
         fat_node_t *nodep;
         fat_bs_t *bs;
+        uint16_t bps;
         size_t bytes;
         block_t *b;
@@ -1167 +1191 @@
 
         bs = block_bb_get(dev_handle);
+        bps = uint16_t_le2host(bs->bps);
 
         if (nodep->type == FAT_FILE) {
@@ -1179 +1204 @@
                         (void) async_data_read_finalize(callid, NULL, 0);
                 } else {
-                        bytes = min(len, BPS(bs) - pos % BPS(bs));
+                        bytes = min(len, bps - pos % bps);
                         bytes = min(bytes, nodep->size - pos);
-                        rc = fat_block_get(&b, bs, nodep, pos / BPS(bs),
+                        rc = fat_block_get(&b, bs, nodep, pos / bps,
                             BLOCK_FLAGS_NONE);
                         if (rc != EOK) {
@@ -1189 +1214 @@
                                 return;
                         }
-                        (void) async_data_read_finalize(callid,
-                            b->data + pos % BPS(bs), bytes);
+                        (void) async_data_read_finalize(callid, b->data + pos % bps,
+                            bytes);
                         rc = block_put(b);
                         if (rc != EOK) {
@@ -1205 +1230 @@
 
                 assert(nodep->type == FAT_DIRECTORY);
-                assert(nodep->size % BPS(bs) == 0);
-                assert(BPS(bs) % sizeof(fat_dentry_t) == 0);
+                assert(nodep->size % bps == 0);
+                assert(bps % sizeof(fat_dentry_t) == 0);
 
                 /*
@@ -1214 +1239 @@
                  * the position pointer accordingly.
                  */
-                bnum = (pos * sizeof(fat_dentry_t)) / BPS(bs);
-                while (bnum < nodep->size / BPS(bs)) {
+                bnum = (pos * sizeof(fat_dentry_t)) / bps;
+                while (bnum < nodep->size / bps) {
                         aoff64_t o;
 
@@ -1222 +1247 @@
                         if (rc != EOK)
                                 goto err;
-                        for (o = pos % (BPS(bs) / sizeof(fat_dentry_t));
-                            o < BPS(bs) / sizeof(fat_dentry_t);
+                        for (o = pos % (bps / sizeof(fat_dentry_t));
+                            o < bps / sizeof(fat_dentry_t);
                             o++, pos++) {
                                 d = ((fat_dentry_t *)b->data) + o;
@@ -1281 +1306 @@
         size_t bytes, size;
         block_t *b;
+        uint16_t bps;
+        unsigned spc;
+        unsigned bpc;           /* bytes per cluster */
         aoff64_t boundary;
         int flags = BLOCK_FLAGS_NONE;
@@ -1306 +1334 @@
 
         bs = block_bb_get(dev_handle);
+        bps = uint16_t_le2host(bs->bps);
+        spc = bs->spc;
+        bpc = bps * spc;
 
         /*
@@ -1314 +1345 @@
          * value signalizing a smaller number of bytes written. 
          */ 
-        bytes = min(len, BPS(bs) - pos % BPS(bs));
-        if (bytes == BPS(bs))
+        bytes = min(len, bps - pos % bps);
+        if (bytes == bps)
                 flags |= BLOCK_FLAGS_NOREAD;
         
-        boundary = ROUND_UP(nodep->size, BPC(bs));
+        boundary = ROUND_UP(nodep->size, bpc);
         if (pos < boundary) {
                 /*
@@ -1333 +1364 @@
                         return;
                 }
-                rc = fat_block_get(&b, bs, nodep, pos / BPS(bs), flags);
+                rc = fat_block_get(&b, bs, nodep, pos / bps, flags);
                 if (rc != EOK) {
                         (void) fat_node_put(fn);
@@ -1340 +1371 @@
                         return;
                 }
-                (void) async_data_write_finalize(callid,
-                    b->data + pos % BPS(bs), bytes);
+                (void) async_data_write_finalize(callid, b->data + pos % bps,
+                    bytes);
                 b->dirty = true;                /* need to sync block */
                 rc = block_put(b);
@@ -1365 +1396 @@
                 fat_cluster_t mcl, lcl; 
  
-                nclsts = (ROUND_UP(pos + bytes, BPC(bs)) - boundary) / BPC(bs);
+                nclsts = (ROUND_UP(pos + bytes, bpc) - boundary) / bpc;
                 /* create an independent chain of nclsts clusters in all FATs */
                 rc = fat_alloc_clusters(bs, dev_handle, nclsts, &mcl, &lcl);
@@ -1384 +1415 @@
                         return;
                 }
-                rc = _fat_block_get(&b, bs, dev_handle, lcl, NULL,
-                    (pos / BPS(bs)) % SPC(bs), flags);
+                rc = _fat_block_get(&b, bs, dev_handle, lcl, (pos / bps) % spc,
+                    flags);
                 if (rc != EOK) {
                         (void) fat_free_clusters(bs, dev_handle, mcl);
@@ -1393 +1424 @@
                         return;
                 }
-                (void) async_data_write_finalize(callid,
-                    b->data + pos % BPS(bs), bytes);
+                (void) async_data_write_finalize(callid, b->data + pos % bps,
+                    bytes);
                 b->dirty = true;                /* need to sync block */
                 rc = block_put(b);
@@ -1407 +1438 @@
                  * node's cluster chain.
                  */
-                rc = fat_append_clusters(bs, nodep, mcl, lcl);
+                rc = fat_append_clusters(bs, nodep, mcl);
                 if (rc != EOK) {
                         (void) fat_free_clusters(bs, dev_handle, mcl);
@@ -1431 +1462 @@
         fat_node_t *nodep;
         fat_bs_t *bs;
+        uint16_t bps;
+        uint8_t spc;
+        unsigned bpc;   /* bytes per cluster */
         int rc;
 
@@ -1445 +1479 @@
 
         bs = block_bb_get(dev_handle);
+        bps = uint16_t_le2host(bs->bps);
+        spc = bs->spc;
+        bpc = bps * spc;
 
         if (nodep->size == size) {
@@ -1454 +1491 @@
                  */
                 rc = EINVAL;
-        } else if (ROUND_UP(nodep->size, BPC(bs)) == ROUND_UP(size, BPC(bs))) {
+        } else if (ROUND_UP(nodep->size, bpc) == ROUND_UP(size, bpc)) {
                 /*
                  * The node will be shrunk, but no clusters will be deallocated.
@@ -1472 +1509 @@
                         fat_cluster_t lastc;
                         rc = fat_cluster_walk(bs, dev_handle, nodep->firstc,
-                            &lastc, NULL, (size - 1) / BPC(bs));
+                            &lastc, NULL, (size - 1) / bpc);
                         if (rc != EOK)
                                 goto out;
@@ -1527 +1564 @@
 void fat_sync(ipc_callid_t rid, ipc_call_t *request)
 {
-        dev_handle_t dev_handle = (dev_handle_t) IPC_GET_ARG1(*request);
-        fs_index_t index = (fs_index_t) IPC_GET_ARG2(*request);
-        
-        fs_node_t *fn;
-        int rc = fat_node_get(&fn, dev_handle, index);
-        if (rc != EOK) {
-                ipc_answer_0(rid, rc);
-                return;
-        }
-        if (!fn) {
-                ipc_answer_0(rid, ENOENT);
-                return;
-        }
-        
-        fat_node_t *nodep = FAT_NODE(fn);
-        
-        nodep->dirty = true;
-        rc = fat_node_sync(nodep);
-        
-        fat_node_put(fn);
-        ipc_answer_0(rid, rc);
+        /* Dummy implementation */
+        ipc_answer_0(rid, EOK);
 }
 

uspace/srv/fs/tmpfs/tmpfs_ops.c

@@ -736 +736 @@
 void tmpfs_sync(ipc_callid_t rid, ipc_call_t *request)
 {
-        /*
-         * TMPFS keeps its data structures always consistent,
-         * thus the sync operation is a no-op.
-         */
+        /* Dummy implementation */
         ipc_answer_0(rid, EOK);
 }