Subversion Repositories Kolibri OS

; Tests of malloc()/free() from the kernel heap.

; This file is not included in the kernel, it is just test application.

use32

        db      'MENUET01'

        dd      1, start, i_end, mem, mem, 0, 0

start:

; Zero-initialize uglobals (as in kernel at boot)

        mov     ecx, (zeroend - zerostart + 3) / 4

        xor     eax, eax

        mov     edi, zerostart

        rep stosd

; Initialize small heap (as in kernel at boot)

        call    init_malloc

; Run tests

        call    run_test1

        call    run_test2

        call    run_test3

; All is OK, return

        or      eax, -1

        int     0x40

run_test1:

; basic test

        mov     eax, 1

        call    malloc_with_test

        mov     byte [eax], 0xDD

        mov     esi, eax

        mov     eax, 1

        call    malloc_with_test

        cmp     byte [esi], 0xDD

        jnz     memory_destroyed

        mov     byte [eax], 0xEE

        xchg    eax, esi

        call    free

        cmp     byte [esi], 0xEE

        jnz     memory_destroyed

        xchg    eax, esi

        call    free

        ret

run_test2:

        ret

run_test3:

; 1024000 times run random operation.

; Randomly select malloc(random size from 1 to 1023)

; or free(random of previously allocated areas)

        mov     edi, 0x12345678

        xor     esi, esi        ; 0 areas allocated

        mov     ebx, 1024000

.loop:

        imul    edi, 1103515245

        add     edi, 12345

        mov     eax, edi

        shr     eax, 16

        test    ebx, 64

        jz      .prefer_free

.prefer_malloc:

        test    eax, 3

        jz      .free

        jmp     @f

.prefer_free:

        test    eax, 3

        jnz     .free

@@:

        shr     eax, 2

        and     eax, 1023

        jz      .loop

        push    ebx

        push    eax

;       mov     ecx, [saved_state_num]

;       mov     [saved_state+ecx*8], eax

        call    malloc_with_test

;       mov     ecx, [saved_state_num]

;       mov     [saved_state+ecx*8+4], eax

;       inc     [saved_state_num]

        pop     ecx

        pop     ebx

        inc     esi

        push    ecx eax

        push    edi

        mov     edi, eax

        mov     eax, esi

        rep stosb

        pop     edi

        jmp     .common

.free:

        test    esi, esi

        jz      .loop

        xor     edx, edx

        div     esi

        sub     edx, esi

        neg     edx

        dec     edx

        mov     eax, [esp+edx*8]

;       mov     ecx, [saved_state_num]

;       mov     [saved_state+ecx*8], -1

;       mov     [saved_state+ecx*8+4], eax

;       inc     [saved_state_num]

        mov     ecx, [esp+edx*8+4]

        push    edi eax

        mov     edi, eax

        mov     al, [edi]

        repz scasb

        jnz     memory_destroyed

        pop     eax edi

        push    ebx edx

        call    free

        pop     edx ebx

        dec     esi

        pop     eax ecx

        push    edi

        lea     edi, [esp+4]

@@:

        dec     edx

        js      @f

        xchg    eax, [edi]

        xchg    ecx, [edi+4]

        add     edi, 8

        jmp     @b

@@:

        pop     edi

.common:

        dec     ebx

        jnz     .loop

@@:

        dec     esi

        js      @f

        pop     eax ecx

        call    free

        jmp     @b

@@:

        ret

malloc_with_test:

; calls malloc() and checks returned value

        call    malloc

        test    eax, eax

        jz      generic_malloc_fail

        call    check_mutex

        call    check_range

        ret

; Stubs for kernel procedures used by heap code

wait_mutex:

        inc     dword [ebx]

        ret

kernel_alloc:

        cmp     dword [esp+4], bufsize

        jnz     error1

        mov     eax, buffer

        ret     4

macro $Revision [args]

{

}

; Error handlers

error1:

        mov     eax, 1

        jmp     error_with_code

generic_malloc_fail:

        mov     eax, 2

        jmp     error_with_code

check_mutex:

        cmp     [mst.mutex], 0

        jnz     @f

        ret

@@:

        mov     eax, 3

        jmp     error_with_code

check_range:

        cmp     eax, buffer

        jb      @f

        cmp     eax, buffer+bufsize

        jae     @f

        ret

@@:

        mov     eax, 4

        jmp     error_with_code

memory_destroyed:

        mov     eax, 5

        jmp     error_with_code

error_with_code:

        mov     edx, saved_state_num

; eax = error code

; 1 signals error in testing code (wrong bufsize)

; 2 = malloc() returned NULL

; 3 = mutex not released

; 4 = weird returned value from malloc()

; 5 = memory destroyed by malloc() or free()

        int3    ; simplest way to report error

        jmp     $-1     ; just in case

; Include main heap code

include '../proc32.inc'

include '../const.inc'

include 'malloc.inc'

i_end:

align 4

zerostart:

mst     MEM_STATE

align 16

bufsize = 0x40000       ; change if malloc.inc changes

buffer  rb      bufsize

zeroend:

saved_state_num dd      ?

saved_state     rd      0x10000

align 4

        rb      0x10000 ; for stack

mem: