WebSVN – Kolibri OS – Diff – /kernel/trunk/core/heap.inc

 ;; Copyright (C) KolibriOS team 2004-2012. All rights reserved. ;;
 ;; Distributed under terms of the GNU General Public License    ;;
 ;;                                                              ;;
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
-$Revision: 4424 $
+$Revision: 5130 $
 restore block_list
 restore block_base
 restore block_size
 restore block_flags
-;;;;;;;;;;;;;;      USER     ;;;;;;;;;;;;;;;;;
+;;;;;;;;;;;;;;      USER HEAP     ;;;;;;;;;;;;;;;;;
 HEAP_TOP  equ 0x80000000
 align 4
 proc init_heap
-        mov     ebx, [current_slot]
+        mov     ebx, [current_process]
-        mov     eax, [ebx+APPDATA.heap_top]
+        mov     eax, [ebx+PROC.heap_top]
         test    eax, eax
         jz      @F
+        sub     eax, [ebx+PROC.heap_base]
+        sub     eax, PAGE_SIZE
+        ret
-        sub     eax, [ebx+APPDATA.heap_base]
+@@:
-        sub     eax, 4096
+        lea     ecx, [ebx+PROC.heap_lock]
-        ret
+        call    mutex_init
-@@:
-        mov     esi, [ebx+APPDATA.mem_size]
+        mov     esi, [ebx+PROC.mem_used]
         add     esi, 4095
         and     esi, not 4095
-        mov     [ebx+APPDATA.mem_size], esi
+        mov     [ebx+PROC.mem_used], esi
         mov     eax, HEAP_TOP
-        mov     [ebx+APPDATA.heap_base], esi
+        mov     [ebx+PROC.heap_base], esi
-        mov     [ebx+APPDATA.heap_top], eax
+        mov     [ebx+PROC.heap_top], eax
         sub     eax, esi
         shr     esi, 10
         mov     ecx, eax
         push    ebx
         push    esi
+        push    edi
+        mov     ebx, [current_process]
+        lea     ecx, [ebx+PROC.heap_lock]
-        push    edi
+        call    mutex_lock
         mov     ecx, [alloc_size]
-        add     ecx, (4095+4096)
-        and     ecx, not 4095
+        add     ecx, (4095+PAGE_SIZE)
+        and     ecx, not 4095
-        mov     ebx, [current_slot]
-        mov     esi, dword [ebx+APPDATA.heap_base] ; heap_base
+        mov     esi, dword [ebx+PROC.heap_base] ; heap_base
-        mov     edi, dword [ebx+APPDATA.heap_top]  ; heap_top
+        mov     edi, dword [ebx+PROC.heap_top]  ; heap_top
-l_0:
+.scan:
         cmp     esi, edi
-        jae     m_exit
+        jae     .m_exit
         mov     ebx, esi
         shr     ebx, 12
         mov     eax, [page_tabs+ebx*4]
         test    al, FREE_BLOCK
-        jz      test_used
+        jz      .test_used
         and     eax, 0xFFFFF000
         cmp     eax, ecx   ;alloc_size
-        jb      m_next
+        jb      .m_next
         inc     ebx
         dec     ecx
         jnz     @B
 .no:
-        mov     edx, [current_slot]
+        mov     edx, [current_process]
         mov     ebx, [alloc_size]
         add     ebx, 0xFFF
+        and     ebx, not 0xFFF
+        add     [edx+PROC.mem_used], ebx
-        and     ebx, not 0xFFF
-        add     ebx, [edx+APPDATA.mem_size]
+        lea     ecx, [edx+PROC.heap_lock]
-        call    update_mem_size
+        call    mutex_unlock
         lea     eax, [esi+4096]
         pop     edi
         pop     esi
         pop     ebx
         ret
-test_used:
+.test_used:
         test    al, USED_BLOCK
-        jz      m_exit
+        jz      .m_exit
         and     eax, 0xFFFFF000
+.m_next:
+        add     esi, eax
+        jmp     .scan
+.m_exit:
-m_next:
+        mov     ecx, [current_process]
-        add     esi, eax
+        lea     ecx, [ecx+PROC.heap_lock]
-        jmp     l_0
+        call    mutex_unlock
 m_exit:
         xor     eax, eax
         push    ebx
         push    esi
         push    edi
+        mov     ebx, [current_process]
+        lea     ecx, [ebx+PROC.heap_lock]
         call    mutex_lock
         mov     ebx, [current_slot]
         mov     edx, [address]
         and     edx, not 0xFFF
         mov     [address], edx
         sub     edx, 0x1000
         jb      .error
-        mov     esi, [ebx+APPDATA.heap_base]
+        mov     esi, [ebx+PROC.heap_base]
-        mov     edi, [ebx+APPDATA.heap_top]
+        mov     edi, [ebx+PROC.heap_top]
         cmp     edx, esi
         jb      .error
 .scan:
         cmp     edx, ecx
         jb      .found
         mov     esi, ecx
         jmp     .scan
 .error:
+        mov     ecx, [current_process]
+        lea     ecx, [ecx+PROC.heap_lock]
+        call    mutex_unlock
         xor     eax, eax
         pop     edi
         pop     esi
         pop     ebx
         ret
         jz      .nothird
         or      cl, FREE_BLOCK
         mov     [page_tabs+ebx*4], ecx
-.nothird:
+.nothird:
-        mov     edx, [current_slot]
+        mov     edx, [current_process]
         mov     ebx, [alloc_size]
         add     ebx, 0xFFF
+        and     ebx, not 0xFFF
+        add     [edx+PROC.mem_used], ebx
-        and     ebx, not 0xFFF
-        add     ebx, [edx+APPDATA.mem_size]
+        lea     ecx, [edx+PROC.heap_lock]
-        call    update_mem_size
+        call    mutex_unlock
         mov     eax, [address]
         push    esi
         mov     esi, [base]
         test    esi, esi
+        jz      .fail
+        push    ebx
-        jz      .exit
+        mov     ebx, [current_process]
         lea     ecx, [ebx+PROC.heap_lock]
-        push    ebx
+        call    mutex_lock
         xor     ebx, ebx
         jnz     .release
 .released:
         push    edi
+        mov     edx, [current_process]
-        mov     edx, [current_slot]
+        lea     ecx, [edx+PROC.heap_lock]
-        mov     esi, dword [edx+APPDATA.heap_base]
+        mov     esi, dword [edx+PROC.heap_base]
-        mov     edi, dword [edx+APPDATA.heap_top]
+        mov     edi, dword [edx+PROC.heap_top]
-        sub     ebx, [edx+APPDATA.mem_size]
+        sub     ebx, [edx+PROC.mem_used]
         neg     ebx
-        call    update_mem_size
+        mov     [edx+PROC.mem_used], ebx
-        call    user_normalize
-        pop     edi
-        pop     ebx
-        pop     esi
+        call    user_normalize
+        pop     edi
+.exit:
-        ret
+        call    mutex_unlock
 .exit:
+        xor     eax, eax
-        xor     eax, eax
+        inc     eax
-        inc     eax
+        pop     ebx
+        pop     esi
-        pop     esi
+        ret
+.cantfree:
+        mov     ecx, [current_process]
+        lea     ecx, [ecx+PROC.heap_lock]
-        ret
+        jmp     .exit
-.cantfree:
-        xor     eax, eax
+.fail:
-        pop     ebx
+        xor     eax, eax
         pop     esi
         push    ebx
         call    user_alloc
         ret
 @@:
         push    ecx edx
+        push    eax
+        mov     ecx, [current_process]
+        lea     ecx, [ecx+PROC.heap_lock]
+        call    mutex_lock
+        pop     eax
         lea     ecx, [eax - 0x1000]
         shr     ecx, 12
         mov     edx, [page_tabs+ecx*4]
         test    dl, USED_BLOCK
         jnz     @f
 ; attempt to realloc invalid pointer
 .ret0:
+        mov     ecx, [current_process]
+        lea     ecx, [ecx+PROC.heap_lock]
+        call    mutex_unlock
         pop     edx ecx
         xor     eax, eax
         ret
 @@:
         test    dl, DONT_FREE_BLOCK
         sub     ebx, ecx
         cmp     ebx, 1
         jnz     .nofreeall
         mov     eax, [page_tabs+ecx*4]
         and     eax, not 0xFFF
-        mov     edx, [current_slot]
+        mov     edx, [current_process]
-        mov     ebx, [APPDATA.mem_size+edx]
+        mov     ebx, [edx+PROC.mem_used]
         sub     ebx, eax
         add     ebx, 0x1000
         or      al, FREE_BLOCK
         mov     [page_tabs+ecx*4], eax
         push    esi edi
-        mov     esi, [APPDATA.heap_base+edx]
+        mov     esi, [edx+PROC.heap_base]
-        mov     edi, [APPDATA.heap_top+edx]
+        mov     edi, [edx+PROC.heap_top]
-        call    update_mem_size
+        mov     [edx+PROC.mem_used], ebx
         call    user_normalize
         pop     edi esi
         jmp     .ret0   ; all freed
 .nofreeall:
         sub     edx, ecx
         or      ebx, USED_BLOCK
         xchg    [page_tabs+ecx*4], ebx
         shr     ebx, 12
         sub     ebx, edx
         push    ebx ecx edx
-        mov     edx, [current_slot]
+        mov     edx, [current_process]
         shl     ebx, 12
-        sub     ebx, [APPDATA.mem_size+edx]
+        sub     ebx, [edx+PROC.mem_used]
         neg     ebx
-        call    update_mem_size
+        mov     [edx+PROC.mem_used], ebx
         pop     edx ecx ebx
         lea     eax, [ecx+1]
         shl     eax, 12
         push    eax
         add     ecx, edx
         lea     edx, [ecx+ebx]
         shl     ebx, 12
         jz      .ret
         push    esi
-        mov     esi, [current_slot]
+        mov     esi, [current_process]
-        mov     esi, [APPDATA.heap_top+esi]
+        mov     esi, [esi+PROC.heap_top]
         shr     esi, 12
 @@:
         cmp     edx, esi
         jae     .merge_done
         mov     eax, [page_tabs+edx*4]
 .merge_done:
         pop     esi
         or      ebx, FREE_BLOCK
         mov     [page_tabs+ecx*4], ebx
 .ret:
+        mov     ecx, [current_process]
+        lea     ecx, [ecx+PROC.heap_lock]
+        call    mutex_unlock
         pop     eax edx ecx
         ret
 .realloc_add:
 ; get some additional memory
-        mov     eax, [current_slot]
+        mov     eax, [current_process]
-        mov     eax, [APPDATA.heap_top+eax]
+        mov     eax, [eax+PROC.heap_top]
         shr     eax, 12
         cmp     edx, eax
         jae     .cant_inplace
         mov     eax, [page_tabs+edx*4]
         test    al, FREE_BLOCK
         sub     ebx, edx
         mov     ecx, ebx
         cld
         rep stosd
         pop     edi
-        mov     edx, [current_slot]
+        mov     edx, [current_process]
         shl     ebx, 12
-        add     ebx, [APPDATA.mem_size+edx]
+        add     [edx+PROC.mem_used], ebx
+        mov     ecx, [current_process]
+        lea     ecx, [ecx+PROC.heap_lock]
-        call    update_mem_size
+        call    mutex_unlock
         pop     eax edx ecx
         ret
 .cant_inplace:
         push    esi edi
-        mov     eax, [current_slot]
+        mov     eax, [current_process]
-        mov     esi, [APPDATA.heap_base+eax]
+        mov     esi, [eax+PROC.heap_base]
-        mov     edi, [APPDATA.heap_top+eax]
+        mov     edi, [eax+PROC.heap_top]
         shr     esi, 12
         shr     edi, 12
         sub     ebx, ecx
 .find_place:
         cmp     esi, edi
         dec     ebx
         dec     edx
         jnz     @b
 .no:
         push    ebx
-        mov     edx, [current_slot]
+        mov     edx, [current_process]
         shl     ebx, 12
-        add     ebx, [APPDATA.mem_size+edx]
+        add     [edx+PROC.mem_used], ebx
-        call    update_mem_size
         pop     ebx
 @@:
         mov     dword [page_tabs+esi*4], 2
         inc     esi
         dec     ebx
         jnz     @b
-        pop     eax edi esi edx ecx
-        ret
-if 0
-align 4
-proc alloc_dll
-        pushf
-        cli
-        bsf     eax, [dll_map]
-        jnz     .find
-        popf
-        xor     eax, eax
-        ret
-.find:
-        btr     [dll_map], eax
-        popf
-        shl     eax, 5
-        add     eax, dll_tab
-        ret
-endp
-align 4
-proc alloc_service
-        pushf
-        cli
+        mov     ecx, [current_process]
-        bsf     eax, [srv_map]
+        lea     ecx, [ecx+PROC.heap_lock]
-        jnz     .find
-        popf
+        call    mutex_unlock
-        xor     eax, eax
-        ret
-.find:
-        btr     [srv_map], eax
-        popf
-        shl     eax, 0x02
-        lea     eax, [srv_tab+eax+eax*8] ;srv_tab+eax*36
+        pop     eax edi esi edx ecx
-        ret
-endp
+        ret
 end if

Subversion Repositories Kolibri OS

(root)/kernel/trunk/core/heap.inc – Rev 4424 → 5130